Hart's Gaje Module

Subyek: Hart's Gaje Module 2011-01-31, 14:59

Hart Module?
Versi: -1.0
Tipe: Miscellanous

Pengenalan

Umm... ini sebenarnya cuma module untuk membantu "SAYA(Hart) SENDIRI", ya, tujuan yg egois, agar mempermudah membuat script(terutama yg berbau minigame, soalnya saya sering bikin ulang yg mirip2 kayak gini :hammer:

) di kemudian hari. Bagi yang tidak mengerti script tidak perlu capek2 mencoba script ini karena ini fungsinya cuma untuk memudahkan scripter.

Kalau tujuannya hanya untuk memudahkan saya sendiri, bahkan isinya hanya module2/class2 gaje, mengapa harus saya post? Karena pengalaman kemarin lappie saya diformat dan beberapa script iseng saya hilang :hammer:

Jadi, salah satu tujuan dipost adalah sebagai back-up.

Tujuan lainnya adalah agar scripter lain yg baik hati bisa melihat script saya dan mungkin memperbaiki script saya ini bila ada yg dirasa kurang benar/kurang efisien implementasinya. Atau ingin membantu ngerapiin scriptnya juga boleh.

Scripts

Kelas Vector 2D

Code:

module Hart
#=============================================================================
# * class Vector2D
#-----------------------------------------------------------------------------
# Sebuah class simpel untuk mengimplementasikan operasi vektor 2D
#=============================================================================
class Vector2D
attr_accessor :x
attr_accessor :y

# constructor
def initialize()
@x = 0.0
@y = 0.0
end

# constructor dengan 2 parameter
def initialize(x, y)
@x = x
@y = y
end

# apakah vektor bernilai (0, 0) ?
def is_zero?
return @x == 0.0 && @y == 0.0
end

# mengembalikan panjang/magnitude dari vektor
def length
return Math.sqrt((@x * @x) + (@y * @y))
end

# mengembalikan panjang/magnitude dari vektor dalam square/kuadrat
def length_sq
return (@x * @x) + (@y * @y)
end

# normalisasi vektor
def normalize!
@x /= self.length
@y /= self.length
end

# normalisasi vektor dan mengembalikan vektor baru sebagai hasilnya
def normalize
x = @x / self.length
y = @y / self.length

return Vector2D.new(x, y)
end

# mengembalikan hasil perkalian dot/titik dari 2 vektor
def dot_product(other)
return (self.x * other.x) + (self.y * other.y)
end

# menghitung sudut antara 2 vektor
def angle(other)
cos_theta = (self.dot_product(other)) / (self.length * other.length)

return Math.acos(cos_theta)
end

# apakah vektor lain berada di depan vektor ini?
def forward?(other)
return (self.dot_product > 0 ? true : false)
end

# mengembalikan vektor yang tegak lulus dengan vektor ini
def perpendicular
normalized = self.normalize
new_vector = Vector2D.new(-normalized.y, normalized.x)

return new_vector
end

# menghitung jarak antara 2 vektor
def distance(other)
x = self.x - other.x
y = self.y - other.y
new_vector = Vector2D.new(x, y)

return new_vector.length
end

# menghitung jarak 2 vektor dalam bentuk kuadrat
def distance_sq(other)
x = self.x - other.x
y = self.y - other.y
new_vector = Vector2D.new(x, y)

return new_vector.length_sq
end

# menset nilai x dan y vektor
def set(x, y)
@x = x
@y = y
end

# menjumlahkan vektor dengan vektor lain
def add(other)
self.x += other.x
self.y += other.y
end

# mengurangkan vektor dengan vektor lain
def sub(other)
self.x -= other.x
self.y -= other.y
end

# mengalikan vektor dengan vektor lain
def multiply(other)
self.x *= other.x
self.y *= other.y
end

# membagi vektor dengan vektor lain
def divide(other)
self.x /= other.x
self.y /= other.y
end
end
end
Entity_Base

Code:

module Hart
#=============================================================================
# * class Entity_Base
#-----------------------------------------------------------------------------
# Kelas dasar untuk entity
#=============================================================================
class Entity_Base
attr_reader :id

# constructor
def initialize(id)
@id = id
end

# mengubah id dari entity
def change_id(id)
@id = id
end

# update, akan didefinisikan pada kelas turunan
def update
end

# method untuk menghandle message yang diterima
def handle_message(telegram)
end
end
end
Entity Manager

Code:

module Hart
#=============================================================================
# * class Entity_Manager
#-----------------------------------------------------------------------------
# class untuk mempermudah menghandle entity
#=============================================================================
class Entity_Manager
attr_reader :entities

# constructor
def initialize
@entities = []
end

# menambahkan entity
def add_entity(entity)
@entities[entity.id] = entity
end

# mengambil entity dari id tertentu
def get_entity(id)
return @entities[id]
end

# menghapus entity
def delete_entity(id)
@entities[id] = nil
end
end
end

# membuat instans dari Entity_Manager
$entity_manager = Hart::Entity_Manager.new
State_Base

Code:

module Hart
#=============================================================================
# * class State_Base
#-----------------------------------------------------------------------------
# Kelas dasar untuk state untuk mengimplementasikan Finite State Machine
#=============================================================================
class State_Base
# method yang dipanggil ketika state dimulai, didefinisikan pada kelas turunan
def start(object)
end

# method yang dipanggil selama state berjalan, didefinisikan pada kelas turunan
def update(object)
end

# method yang dipanggil ketika state berakhir, didefinisikan pada kelas turunan
def exit(object)
end

# melakukan kegiatan tertentu ketika menerima message tertentu
# me-return nilai true atau false untuk menyatakan berhasil atau gagal
def on_message(object, telegram)
end
end
end
State Machine

Code:

module Hart
#=============================================================================
# * class State_Machine
#-----------------------------------------------------------------------------
# Kelas untuk mengimplementasikan State Machine
#=============================================================================
class State_Machine
attr_reader :owner
attr_reader :current_state
attr_reader :previous_state
attr_reader :global_state

# constructor, owner berarti pemilik dari state machine ini
def initialize(owner)
@owner = owner
@current_state = nil
@previous_state = nil
@global_state = nil
end

# method yang dipanggil untuk meng-update state machine
def update
@global_state.update(@owner) if @global_state != nil
@current_state.update(@owner) if @current_state != nil
end

# mengganti state
def change_state(new_state)
@previous_state = @current_state
@current_state.exit(@owner)
@current_state = new_state
@current_state.start(@owner)
end

# kembali ke state sebelumnya
def back_to_previous_state
change_state(@previous_state)
end

# apakah sedang dalam state tertentu?
def is_in_state?(state)
#return @current_state == state
end

# menghandle message
def handle_message(telegram)
if @current_state != nil && @current_state.on_message(@owner, telegram)
return true
end

if @global_state != nil && @global.on_message(@owner, telegram)
return true
end

return false
end
end
end
Telegram

Code:

module Hart
#=============================================================================
# * class Telegram
#-----------------------------------------------------------------------------
# Kelas untuk mengimplementasikan Message Driven Event
#=============================================================================
class Telegram
attr_accessor :sender
attr_accessor :receiver
attr_accessor :message
attr_accessor :dispatch_time
attr_accessor :extra_info

# constructor
def initialize(sender, receiver, message, dispatch_time, extra_info = nil)
@sender = sender
@receiver = receiver
@message = message
@dispatch_time = dispatch_time
@extra_info = extra_info
end
end
end
Message Handler

Code:

module Hart
#=============================================================================
# * class Message_Handler
#-----------------------------------------------------------------------------
# Kelas untuk menangani query2 message yang ada
#=============================================================================
class Message_Handler
def initialize
@query = []
end

def discharge(receiver_entity, telegram)
receiver_entity.handle_message(telegram)
end

def dispatch_message(delay, sender, receiver, message, extra_info = nil)
receiver_entity = $entity_manager.get_entity(receiver)
telegram = Telegram.new(0, sender, receiver, message, extra_info)

if(delay <= 0.0)
discharge(receiver_entity, telegram)
else
current_time = Time.now
telegram.dispatch_time = current_time + delay
@query.push(telegram)
end
end

def dispatch_delayed_message
current_time = Time.now

for telegram in @query
if telegram.dispatch_time < current_time && telegram.dispatch_time > 0
receiver_entity = $entity_manager.get_entity(telegram.receiver)
discharge(receiver_entity, telegram);
telegram = nil
end
end
end
end
end

# instans dari Message_Handler
$message_handler = Hart::Message_Handler.new

segitu dulu, entar mau ditambah lagi.

Credits

» [HBK]Basic Module v0.60
» Module Input
» [XP] Listra Pathfinder Module
» [VX] Listra Pathfinder Module
» NR's Pantun GaJe