smash_and_grab 0.0.5alpha → 0.0.6alpha

data/lib/smash_and_grab/objects/entity.rb

@@ -1,15 +1,21 @@
 require 'set'
 require 'fiber'
 
-require_relative "../path"
+
 require_relative "../abilities"
 require_relative "world_object"
 require_relative "floating_text"
 
+require_relative "../mixins/line_of_sight"
+require_relative "../mixins/pathfinding"
+require_relative "../mixins/has_contents"
+
 module SmashAndGrab
 module Objects
 class Entity < WorldObject
-  extend Forwardable
+  include Mixins::LineOfSight
+  include Mixins::Pathfinding
+  include Mixins::HasContents
 
   CLASS = :entity
 
@@ -18,28 +24,54 @@ class Entity < WorldObject
 
   STATS_BACKGROUND_COLOR = Color::BLACK
   STATS_HP_COLOR = Color.rgb(0, 200, 0)
-  STATS_MP_COLOR = Color.rgb(100, 100, 255)
+  STATS_MP_COLOR = Color::rgb(50, 50, 255)
   STATS_AP_COLOR = Color::YELLOW
-  STATS_USED_COLOR = Color.rgb(100, 100, 100)
   STATS_WIDTH = 12.0
   STATS_HALF_WIDTH = STATS_WIDTH / 2
+  PIP_WIDTH, PIP_SEP_WIDTH = 2, 0.5
+  STATS_USED_SATURATION = 0.5
+
+  ACTOR_NAME_COLOR = Color.rgb(50, 200, 50)
+  TARGET_NAME_COLOR = Color.rgb(50, 200, 50)
+  DAMAGE_NUMBER_COLOR = Color::RED
+
+  COLOR_ACTIVE = Color::rgb(255, 255, 255)
+  COLOR_ACTIVE_NO_MOVE = STATS_AP_COLOR
+  COLOR_ACTIVE_NO_ACTION = STATS_MP_COLOR
+  COLOR_ACTIVE_FINISHED = Color.rgb(70, 70, 70)
+  COLOR_INACTIVE = Color::BLACK
 
   class << self
     def config; @config ||= YAML.load_file(File.expand_path("config/map/entities.yml", EXTRACT_PATH)); end
     def types; config.keys; end
-    def sprites; @sprites ||= SpriteSheet.new("entities.png", SPRITE_WIDTH, SPRITE_HEIGHT, 8); end
-    def portraits; @portraits ||= SpriteSheet.new("entity_portraits.png", PORTRAIT_WIDTH, PORTRAIT_HEIGHT, 8); end
+    def sprites; @sprites ||= SpriteSheet["entities.png", SPRITE_WIDTH, SPRITE_HEIGHT, 8]; end
+    def portraits; @portraits ||= SpriteSheet["entity_portraits.png", PORTRAIT_WIDTH, PORTRAIT_HEIGHT, 8]; end
   end
 
-  def_delegators :@faction, :minimap_color, :active?, :inactive?
+  event :ended_turn
+  event :started_turn
+
+  attr_reader :faction, :movement_points, :action_points, :health_points, :type, :portrait,
+              :max_movement_points, :max_action_points, :max_health_points, :default_faction_type
 
-  attr_reader :faction, :movement_points, :action_points, :health, :type, :portrait,
-              :max_movement_points, :max_action_points, :max_health
+  alias_method :hp, :health_points
+  alias_method :max_hp, :max_health_points
 
-  alias_method :hp, :health
-  alias_method :max_hp, :max_health
+  def minimap_color; @faction.minimap_color; end
+  def active?; @faction.active?; end
+  def inactive?; @faction.inactive?; end
 
-  attr_writer :movement_points, :action_points
+  def movement_points=(movement_points)
+    @movement_points = movement_points
+    publish :changed
+    @movement_points
+  end
+
+  def action_points=(action_points)
+    @action_points = action_points
+    publish :changed
+    @action_points
+  end
 
   alias_method :max_mp, :max_movement_points
   alias_method :max_ap, :max_action_points
@@ -51,14 +83,20 @@ class Entity < WorldObject
   alias_method :ap=, :action_points=
 
   def to_s; "<#{self.class.name}/#{@type}##{id} #{tile ? grid_position : "[off-map]"}>"; end
-  def name; @type.to_s.split("_").map(&:capitalize).join(" "); end
-  def alive?; @health > 0 and @tile; end
+  def alive?; @health_points > 0 and @tile; end
+  def title; t.title; end
+  def colorized_name; faction.class::TEXT_COLOR.colorize name; end
+
+  def bystander?; faction.is_a? Factions::Bystanders; end
+  def goody?; faction.is_a? Factions::Goodies; end
+  def baddy?; faction.is_a? Factions::Baddies; end
 
   def initialize(map, data)
     @type = data[:type]
     config = self.class.config[data[:type]]
 
-    @faction = map.send(config[:faction])
+    @default_faction_type = config[:faction]
+    @faction = nil
 
     options = {
         image: self.class.sprites[*config[:spritesheet_position]],
@@ -77,8 +115,8 @@ class Entity < WorldObject
     @max_action_points = config[:action_points]
     @action_points = data[:action_points] || @max_action_points
 
-    @max_health = config[:health]
-    @health = data[:health] || @max_health
+    @max_health_points = config[:health_points]
+    @health_points = data[:health_points] || @max_health_points
 
     # Load other abilities of the entity from config.
     @abilities = {}
@@ -92,9 +130,14 @@ class Entity < WorldObject
       end
     end
 
-    @queued_activities = []
+    if max_ap > 0
+      @abilities[:pick_up] = Abilities.ability(self, type: :pick_up)
+      @abilities[:drop] = Abilities.ability(self, type: :drop)
+    end
 
-    @faction << self
+    @tmp_contents_id = data[:contents_id] # Need to wait until all objects are loaded before picking it up.
+
+    @queued_activities = []
 
     @stat_bars_record = nil
     subscribe :changed do
@@ -102,38 +145,61 @@ class Entity < WorldObject
     end
   end
 
+  def faction=(faction)
+    @faction.remove self if @faction
+    @faction = faction
+    @faction << self
+  end
+
   def has_ability?(type); @abilities.has_key? type; end
   def ability(type); @abilities[type]; end
 
-  def health=(value)
-    original_health = @health
-    @health = [value, 0].max
+  def health_points=(value)
+    original_health = @health_points
+    @health_points = [value, 0].max
 
     # Show damage/healing as a floating number.
-    if original_health != @health
-      text, color = if @health > original_health
-                      ["+#{@health - original_health}", Color::GREEN]
+    if original_health != @health_points
+      text, color = if @health_points > original_health
+                      ["+#{@health_points - original_health}", Color::GREEN]
                     else
-                      [(@health - original_health).to_s, Color::RED]
+                      [(@health_points - original_health).to_s, Color::RED]
                     end
 
       FloatingText.new(text, color: color, x: x, y: y - height / 3, zorder: y - 0.01)
       publish :changed
     end
 
-    if @health == 0 and @tile
-      parent.publish :game_info, "#{name} was vanquished!"
+    if @health_points == 0 and @tile
+      parent.publish :game_info, "#{colorized_name} was vanquished!"
+
+      # Leave the tile, then drop anything we are carrying into it.
+      # TODO: this is not undo/redoable!
+      old_tile = tile
       self.tile = nil
+      drop old_tile if contents
+
       @queued_activities.empty?
     end
+
+    @health_points
   end
-  alias_method :hp=, :health=
+  alias_method :hp=, :health_points=
 
-  # Called from GameAction::Ability
+  # Called from GameActions::Ability
   # Also used to un-melee :)
-  def melee(target, damage)
+  def make_melee_attack(target, damage)
     add_activity do
-      if damage > 0 # do => wound
+      if damage == 0 # Missed
+        face target
+        self.z += 10
+        delay 0.1
+        self.z -= 10
+
+        parent.publish :game_info, "#{colorized_name} swung at #{target.colorized_name}, but missed"
+        missed target
+
+      elsif damage > 0 # do => wound
         face target
         self.z += 10
         delay 0.1
@@ -141,19 +207,19 @@ class Entity < WorldObject
 
         # Can be dead at this point if there were 2-3 attackers of opportunity!
         if target.alive?
-          parent.publish :game_info, "#{name} smashed #{target.name} for {#{damage}}"
-          target.health -= damage
+          parent.publish :game_info, "#{colorized_name} smashed #{target.colorized_name} for {#{DAMAGE_NUMBER_COLOR.colorize damage}}"
+          target.hp -= damage
 
           target.color = Color.rgb(255, 100, 100)
           delay 0.1
           target.color = Color::WHITE
         else
-          parent.publish :game_info, "#{name} kicked #{target.name} while they were down"
+          parent.publish :game_info, "#{colorized_name} kicked #{target.colorized_name} while they were down"
         end
       else # undo => heal
         target.color = Color.rgb(255, 100, 100)
         delay 0.1
-        target.health -= damage
+        target.hp -= damage
         target.color = Color::WHITE
 
         self.z += 10
@@ -163,50 +229,148 @@ class Entity < WorldObject
     end
   end
 
+  def missed(target)
+    FloatingText.new("Miss!", color: Color::YELLOW, x: target.x, y: target.y - target.height / 3, zorder: target.y - 0.01)
+  end
+
+  def make_ranged_attack(target, damage)
+    add_activity do
+      if damage == 0
+        face target
+
+        parent.publish :game_info, "#{colorized_name} shot at #{target.colorized_name}, but missed"
+
+        missed target
+      elsif damage > 0 # do => wound
+        face target
+
+        # Can be dead at this point if there were 2-3 attackers of opportunity!
+        if target.alive?
+          parent.publish :game_info, "#{colorized_name} shot #{target.colorized_name} for {#{DAMAGE_NUMBER_COLOR.colorize damage}}"
+          target.hp -= damage
+
+          target.color = Color.rgb(255, 100, 100)
+          delay 0.1
+          target.color = Color::WHITE
+        else
+          parent.publish :game_info, "#{colorized_name} shot #{target.colorized_name} while they were down"
+        end
+      else # undo => heal
+        target.color = Color.rgb(255, 100, 100)
+        delay 0.1
+        target.hp -= damage
+        target.color = Color::WHITE
+      end
+    end
+  end
+
+  def start_game
+    @health_points = max_hp # Has to be done directly or you could take damage or heal from it :D
+    self.mp = max_mp
+    self.ap = max_ap
+  end
+
   def start_turn
-    @movement_points = @max_movement_points
-    @action_points = @max_action_points
+    self.mp = max_mp
+    self.ap = max_ap
+    publish :started_turn
     publish :changed
   end
 
   def end_turn
-    # Do something?
+    publish :ended_turn
+    publish :changed
+  end
+
+  # Color of circular base you stand on.
+  def base_color
+    if active?
+      if move?
+        ap > 0 ? COLOR_ACTIVE : COLOR_ACTIVE_NO_ACTION
+      else
+        ap > 0 ? COLOR_ACTIVE_NO_MOVE : COLOR_ACTIVE_FINISHED
+      end
+    else
+      COLOR_INACTIVE
+    end
   end
 
   def draw
     return unless alive?
 
+    if active?
+      color = base_color.dup
+      color.alpha = 60
+      Image["tile_selection.png"].draw_rot x, y, y, 0, 0.5, 0.5, 1, 1, color
+    end
+
     super()
 
-    draw_stat_bars @y
+    draw_stat_bars if parent.zoom >= 2
   end
 
-  def draw_stat_bars(zorder)
-    @stat_bars_record ||= $window.record 1, 1 do
-      # Draw background shadow.
-      height = 1
-      height += 1 if active?
-      height += 1 if max_ap > 0
+  def draw_stat_pips(value, max, color, y)
+    # Draw a background which appears between and underneath the pips.
+    width = (max - 1) * PIP_SEP_WIDTH + max * PIP_WIDTH
+    $window.pixel.draw 0, y, 0, width, 1 + PIP_SEP_WIDTH, STATS_BACKGROUND_COLOR
+
+    # Draw the pips themselves.
+    max.times do |i|
+      if i < value and alive?
+        pip_color = color
+      else
+        pip_color = color.dup
+        pip_color.red *= STATS_USED_SATURATION
+        pip_color.blue *= STATS_USED_SATURATION
+        pip_color.green *= STATS_USED_SATURATION
+      end
+      $window.pixel.draw i * (PIP_WIDTH + PIP_SEP_WIDTH), y, 0, PIP_WIDTH, 1, pip_color
+    end
+  end
 
-      $window.pixel.draw -0.5, -0.5, 0, STATS_WIDTH + 1, height + 1, STATS_BACKGROUND_COLOR
+  def draw_stat_bars(options = {})
+    options = {
+        x: x - STATS_HALF_WIDTH,
+        y: y - 4,
+        zorder: y,
+        factor_x: 1,
+        factor_y: 1,
+    }.merge! options
 
-      # Health.
-      $window.pixel.draw 0, 0, 0, STATS_WIDTH * health / max_health, 1, STATS_HP_COLOR
+    @stat_bars_record ||= $window.record 1, 1 do
+      # Health. 1 or two rows of up to 5 pips. Cannot have > 10 HP!
+      full_rows, top_row_pips = max_hp.divmod 5
+      case full_rows
+        when 0
+          draw_stat_pips(hp, top_row_pips, STATS_HP_COLOR, 1.5)
+        when 1
+          draw_stat_pips(hp - 5, top_row_pips, STATS_HP_COLOR, 0) if max_hp > 5
+          draw_stat_pips([hp,  5].min, 5, STATS_HP_COLOR, 1.5)
+        else # 2
+          draw_stat_pips(hp - 5, 5, STATS_HP_COLOR, 0)
+          draw_stat_pips([hp,  5].min, 5, STATS_HP_COLOR, 1.5)
+      end
 
-      # Action points.
+      # Action points. Cannot have > 5 AP!
       if max_ap > 0
-        pip_width = (STATS_WIDTH + 1 - max_ap) / max_ap
-        max_ap.times do |i|
-          color = i < ap ? STATS_AP_COLOR : STATS_USED_COLOR
-          $window.pixel.draw i * pip_width + i, 1, 0, pip_width, 1, color
-        end
+        draw_stat_pips(ap, max_ap, STATS_AP_COLOR, 3)
       end
 
-      # Movement points.
-      $window.pixel.draw 0, 2, 0, 12.0 * mp / max_mp, 1, STATS_MP_COLOR if active?
+      # Movement points. Just use a bar, since they aren't so critical and could be up to 20.
+      if active?
+        $window.pixel.draw 0, 4.5, 0, STATS_WIDTH, 1.5, STATS_BACKGROUND_COLOR
+        used_color = STATS_MP_COLOR.dup
+        used_color.red *= STATS_USED_SATURATION
+        used_color.blue *= STATS_USED_SATURATION
+        used_color.green *= STATS_USED_SATURATION
+        $window.pixel.draw 0, 4.5, 0, STATS_WIDTH, 1, used_color
+
+        width = alive? ? STATS_WIDTH * mp : 0
+        $window.pixel.draw 0, 4.5, 0, width / [mp, max_mp].max, 1, STATS_MP_COLOR if active?
+      end
     end
 
-    @stat_bars_record.draw @x - STATS_HALF_WIDTH, @y - 4, zorder
+    @stat_bars_record.draw options[:x], options[:y], options[:zorder], options[:factor_x], options[:factor_y]
   end
 
   def friend?(character); @faction.friend? character.faction; end
@@ -224,125 +388,6 @@ class Entity < WorldObject
     super
   end
 
-  # Returns a list of tiles this entity could move to (including those they could melee at) [Set]
-  def potential_moves
-    destination_tile = tile # We are sort of working backwards here.
-
-    # Tiles we've already dealt with.
-    closed_tiles = Set.new
-    # Tiles we've looked at and that are in-range.
-    valid_tiles = Set.new
-    # Paths to check { tile => path_to_tile }.
-    open_paths = { destination_tile => Paths::Start.new(destination_tile, destination_tile) }
-
-    melee_cost = has_ability?(:melee) ? ability(:melee).action_cost : Float::INFINITY
-
-    while open_paths.any?
-      path = open_paths.each_value.min_by(&:cost)
-      current_tile = path.last
-
-      open_paths.delete current_tile
-      closed_tiles << current_tile
-
-      exits = current_tile.exits(self).reject {|wall| closed_tiles.include? wall.destination(current_tile) }
-      exits.each do |wall|
-        testing_tile = wall.destination(current_tile)
-        object = testing_tile.object
-
-        if object and object.is_a?(Objects::Entity) and enemy?(object)
-          # Ensure that the current tile is somewhere we could launch an attack from and we could actually perform it.
-          if (current_tile.empty? or current_tile == tile) and ap >= melee_cost
-            valid_tiles << testing_tile
-          end
-
-        elsif testing_tile.passable?(self) and (object.nil? or object.passable?(self))
-          new_path = Paths::Move.new(path, testing_tile, wall.movement_cost)
-
-          # If the path is shorter than one we've already calculated, then replace it. Otherwise just store it.
-          if new_path.move_distance <= movement_points
-            old_path = open_paths[testing_tile]
-            if old_path
-              if new_path.move_distance < old_path.move_distance
-                open_paths[testing_tile] = new_path
-              end
-            else
-              open_paths[testing_tile] = new_path
-              valid_tiles << testing_tile if testing_tile.empty?
-            end
-          end
-        end
-      end
-    end
-
-    valid_tiles
-  end
-
-  # A* path-finding.
-  def path_to(destination_tile)
-    return Paths::None.new if destination_tile == tile
-    return Paths::Inaccessible.new(destination_tile) unless destination_tile.passable?(self)
-
-    closed_tiles = Set.new # Tiles we've already dealt with.
-    open_paths = { tile => Paths::Start.new(tile, destination_tile) } # Paths to check { tile => path_to_tile }.
-
-    destination_object =  destination_tile.object
-    destination_is_enemy = (destination_object and destination_object.is_a? Entity and destination_object.enemy?(self))
-
-    melee_cost = has_ability?(:melee) ? ability(:melee).action_cost : Float::INFINITY
-
-    while open_paths.any?
-      # Check the (expected) shortest path and move it to closed, since we have considered it.
-      path = open_paths.each_value.min_by(&:cost)
-      current_tile = path.last
-
-      return path if current_tile == destination_tile
-
-      open_paths.delete current_tile
-      closed_tiles << current_tile
-
-      next if path.is_a? Paths::Melee
-
-      # Check adjacent tiles.
-      exits = current_tile.exits(self).reject {|wall| closed_tiles.include? wall.destination(current_tile) }
-      exits.each do |wall|
-        testing_tile = wall.destination(current_tile)
-
-        new_path = nil
-
-        object = testing_tile.object
-        if testing_tile.zoc?(faction) and not (testing_tile == destination_tile or destination_is_enemy)
-          # Avoid tiles that have zoc, unless at the end of the path. You have to MANUALLY enter.
-          next
-        elsif object and object.is_a?(Objects::Entity) and enemy?(object)
-          # Ensure that the current tile is somewhere we could launch an attack from and we could actually perform it.
-          if (current_tile.empty? or current_tile == tile) and ap >= melee_cost
-            new_path = Paths::Melee.new(path, testing_tile)
-          else
-            next
-          end
-        elsif testing_tile.passable?(self)
-          if object.nil? or object.passable?(self)
-            new_path = Paths::Move.new(path, testing_tile, wall.movement_cost)
-          else
-            next
-          end
-        end
-
-        # If the path is shorter than one we've already calculated, then replace it. Otherwise just store it.
-        old_path = open_paths[testing_tile]
-        if old_path
-          if new_path.move_distance < old_path.move_distance
-            open_paths[testing_tile] = new_path
-          end
-        else
-          open_paths[testing_tile] = new_path
-        end
-      end
-    end
-
-    Paths::Inaccessible.new(destination_tile) # Failed to connect at all.
-  end
-
   def update
     super
 
@@ -366,9 +411,9 @@ class Entity < WorldObject
   end
 
   def clear_activities
-    has_activities = @queued_activities.any?
+    had_activities = @queued_activities.any?
     @queued_activities.clear
-    publish :changed if has_activities # Means busy? changed from true to false.
+    publish :changed if had_activities # Means busy? changed from true to false.
   end
 
   def busy?
@@ -392,13 +437,14 @@ class Entity < WorldObject
     end
   end
 
-  # @param target [Tile, Objects::WorldObject]
+  # @param target [Tile, Objects::WorldObject, Numeric]
   def face(target)
-    change_in_x = target.x - x
+    x_pos = target.is_a?(Numeric) ? target : target.x
+    change_in_x = x_pos - x
     self.factor_x = change_in_x > 0 ? 1 : -1
   end
 
-  # Actually perform movement (called from GameAction::Ability).
+  # Actually perform movement (called from GameActions::Ability).
   def move(tiles, movement_cost)
     raise "Not enough movement points (#{self} tried to move #{movement_cost} with #{@movement_points} left #{tiles} )" unless movement_cost <= @movement_points
 
@@ -410,10 +456,12 @@ class Entity < WorldObject
       tiles.each_cons(2) do |from, to|
         face to
 
+        # TODO: this will be triggered _every_ time you move, even when redoing is done!
+        trigger_zoc_melees from
+        break unless alive?
+
         delay 0.1
 
-        # TODO: this will be triggered _every_ time you move, even when redoing is done!
-        trigger_zoc_melee from
         break unless alive?
 
         # Skip through a tile if we are moving through something else!
@@ -426,7 +474,11 @@ class Entity < WorldObject
         end
 
         # TODO: this will be triggered _every_ time you move, even when redoing is done!
-        trigger_zoc_melee to
+        trigger_overwatches to
+        break unless alive?
+
+        # TODO: this will be triggered _every_ time you move, even when redoing is done!
+        trigger_zoc_melees to
         break unless alive?
       end
     end
@@ -434,112 +486,111 @@ class Entity < WorldObject
     nil
   end
 
-  # TODO: Need to think of the best way to trigger this. It should only happen once, when you actually "first" move.
-  def trigger_zoc_melee(tile)
-    entities = tile.entities_exerting_zoc(self)
-    enemies = entities.find_all {|e| e.enemy?(self) and e.has_ability?(:melee) and e.use_ability?(:melee) }
-    enemies.each do |enemy|
-      break unless alive? and enemy.alive?
-
-      parent.publish :game_info, "#{enemy.name} got an attack of opportunity!"
-
-      enemy.use_ability :melee, self
-
-      prepend_activity do
-        delay while enemy.busy?
+  def potential_ranged
+    tiles = []
+
+    if use_ability? :ranged
+      ranged = ability :ranged
+      min, max = ranged.min_range, ranged.max_range
+      ((grid_x - max)..(grid_x + max)).each do |x|
+        ((grid_y - max)..(grid_y + max)).each do |y|
+          tile = map.tile_at_grid(x, y)
+          if tile and tile != self.tile and
+              not (tile.object.is_a?(Static)) and
+              not (tile.object.is_a?(Entity) and friend?(tile.object)) and
+              manhattan_distance(tile).between?(min, max) and line_of_sight? tile
+
+            tiles << tile
+          end
+        end
       end
     end
+
+    tiles
   end
 
-  #
-  def line_of_sight?(tile)
-    !line_of_sight_blocked_by(tile)
-  end
-
-  # Returns the tile that blocks sight, otherwise nil.
-  # Implements 'Bresenham's line algorithm'
-  def line_of_sight_blocked_by(target_tile)
-    start_tile = tile
-
-    # Check for the special case of looking diagonally.
-    x1, y1 = tile.grid_x, tile.grid_y
-    x2, y2 = target_tile.grid_x, target_tile.grid_y
-
-    step_x = x1 < x2 ? 1 : -1
-    step_y = y1 < y2 ? 1 : -1
-    dx, dy = (x2 - x1).abs, (y2 - y1).abs
-
-    if dx == dy
-      # Special case of the diagonal line.
-      (dx - 1).times do
-        x1 += step_x
-        y1 += step_y
-
-        # If the centre tile is blocked, then we don't work.
-        tile = @map.tile_at_grid(x1, y1)
-        if tile.blocks_sight?
-          #Tile.blank.draw_rot tile.x, tile.y, ZOrder::TILE_SELECTION, 0, 0.5, 0.5, 1, 1, Color::RED
-          return tile
-        else
-          #Tile.blank.draw_rot tile.x, tile.y, ZOrder::TILE_SELECTION, 0, 0.5, 0.5, 1, 1, Color::BLUE
+  def manhattan_distance(tile)
+    (tile.grid_x - grid_x).abs + (tile.grid_y - grid_y).abs
+  end
+
+  # We have moved; let all our enemies shoot at us.
+  def trigger_overwatches(tile)
+    @map.factions.each do |faction|
+      if faction.enemy? self.faction
+        faction.entities.each do |enemy|
+          if alive?
+            enemy.attempt_overwatch self
+            prepend_activity do
+              delay while enemy.busy?
+            end
+          end
         end
       end
-    else
-      # General case, ray-trace.
-      error = dx - dy
+    end
+  end
 
-      # Ensure that all tiles are visited that the sight-line passes over,
-      # not just those that create a "drawn" line.
-      dx *= 2
-      dy *= 2
+  # Someone has moved into our view and we get to shoot them...
+  def attempt_overwatch(target)
+    if overwatch? target.tile
+      parent.publish :game_info, "#{colorized_name} made a snap shot!"
+      use_ability :ranged, target
+    end
+  end
 
-      length = ((dx + dy + 1) / 2)
+  def overwatch?(tile)
+    if alive? and use_ability? :ranged
+      ranged = ability :ranged
+      range = manhattan_distance tile
 
-      (length - 1).times do
-        # Note that this ignores the special case of error == 0
-        if error > 0
-          error -= dy
-          x1 += step_x
-        else
-          error += dx
-          y1 += step_y
-        end
+      range.between?(ranged.min_range, ranged.max_range) and line_of_sight? tile
+    end
+  end
 
-        tile = @map.tile_at_grid(x1, y1)
-        if tile.blocks_sight?
-          #Tile.blank.draw_rot tile.x, tile.y, ZOrder::TILE_SELECTION, 0, 0.5, 0.5, 1, 1, Color::RED
-          return tile
-        else
-          #Tile.blank.draw_rot tile.x, tile.y, ZOrder::TILE_SELECTION, 0, 0.5, 0.5, 1, 1, Color::BLUE
+  # TODO: Need to think of the best way to trigger this. It should only happen once, when you actually "first" move.
+  def trigger_zoc_melees(tile)
+    entities = tile.entities_exerting_zoc(self)
+    enemies = entities.find_all {|e| e.enemy? self }
+    enemies.each do |enemy|
+      if alive?
+        enemy.attempt_zoc_melee self
+        prepend_activity do
+          delay while enemy.busy?
         end
       end
     end
+  end
 
-    nil # Didn't hit anything.
+  # Someone has moved into, or out of, our ZoC.
+  def attempt_zoc_melee(target)
+    if alive? and use_ability?(:melee)
+      parent.publish :game_info, "#{colorized_name} got an attack of opportunity!"
+      use_ability :melee, target
+    end
   end
 
+
   def use_ability(name, *args)
     raise "#{self} does not have ability: #{name.inspect}" unless has_ability? name
     map.actions.do :ability, ability(name).action_data(*args)
-    publish :changed
   end
 
   def use_ability?(name)
-    alive? and has_ability?(name) and ap >= ability(name).action_cost
+    alive? and has_ability?(name) and ap >= ability(name).action_cost and ability(name).use?
   end
 
   def to_json(*a)
     data = {
         :class => CLASS,
-        type: @type,
+        type: type,
         id: id,
-        health: @health,
-        movement_points: @movement_points,
-        action_points: @action_points,
+        health: health_points,
+        contents_id: contents ? contents.id : nil,
+        movement_points: movement_points,
+        action_points: action_points,
         facing: factor_x > 0 ? :right : :left,
     }
 
-    data[:tile] = grid_position if @tile
+    data[:tile] = grid_position if tile
 
     data.to_json(*a)
   end