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

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

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

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

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

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

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