smash_and_grab 0.0.3alpha → 0.0.5alpha

data/lib/smash_and_grab/mouse_selection.rb

@@ -1,13 +1,11 @@
 module SmashAndGrab
 class MouseSelection < GameObject
-  attr_reader :selected_tile, :hover_tile
+  attr_reader :selected, :hover_tile
 
   MOVE_COLOR = Color.rgba(0, 255, 0, 60)
   MELEE_COLOR = Color.rgba(255, 0, 0, 80)
   NO_MOVE_COLOR = Color.rgba(255, 0, 0, 30)
-  ZOC_COLOR = Color.rgba(255, 0, 0, 255)
-
-  def selected; @selected_tile ? @selected_tile.object : nil; end
+  ZOC_COLOR = Color.rgba(255, 0, 0, 100)
   
   def initialize(map, options = {})
     @map = map
@@ -17,32 +15,51 @@ class MouseSelection < GameObject
     @selected_image = Image["tile_selection.png"]
     @mouse_hover_image = Image["mouse_hover.png"]
 
-    @selected_tile = @hover_tile = nil
+    @selected = @hover_tile = nil
     @path = nil
     @moves_record = nil
+    @selected_changed_handler = nil
 
     super(options)
 
     add_inputs(released_left_mouse_button: :left_click,
                released_right_mouse_button: :right_click)
+
+    @map.factions.each do |faction|
+      faction.subscribe :turn_ended do
+        recalculate
+      end
+      faction.subscribe :turn_started do
+        recalculate
+      end
+    end
+  end
+
+  def update
+    self.selected = nil if selected and selected.tile.nil?
+    super
+  end
+
+  def selected_can_be_controlled?
+    selected and selected.active? and selected.faction.player.is_a?(Players::Human) and not @map.busy?
   end
   
   def tile=(tile)
     if tile != @hover_tile
-      modify_occlusions [@hover_tile], -1 if @hover_tile
+      modify_occlusions @hover_tile, -1 if @hover_tile
       @hover_tile = tile
-      modify_occlusions [@hover_tile], +1 if @hover_tile
+      modify_occlusions @hover_tile, +1 if @hover_tile
       calculate_path
     end
   end
 
   def calculate_path
-    if @selected_tile
+    if selected_can_be_controlled?
       modify_occlusions @path.tiles, -1 if @path
 
       if @hover_tile
-        @path = @selected_tile.object.path_to(@hover_tile)
-        @path.prepare_for_drawing(@potential_moves)
+        @path = selected.path_to @hover_tile
+        @path.prepare_for_drawing @potential_moves
         modify_occlusions @path.tiles, +1
       else
         @path = nil
@@ -55,16 +72,16 @@ class MouseSelection < GameObject
 
   def calculate_potential_moves
     modify_occlusions @potential_moves, -1
-    @potential_moves = @selected_tile.object.potential_moves
+    @potential_moves = selected.potential_moves
     modify_occlusions @potential_moves, +1
 
-
     @moves_record = if @potential_moves.empty?
       nil
     else
       $window.record(1, 1) do
         @potential_moves.each do |tile|
-          color = if entity = tile.object and entity.enemy?(@selected_tile.object)
+          entity = tile.object
+          color = if entity and entity.enemy?(selected)
             MELEE_COLOR
           else
             MOVE_COLOR
@@ -74,8 +91,8 @@ class MouseSelection < GameObject
           Tile.blank.draw_rot tile.x, tile.y, 0, 0, 0.5, 0.5, 1, 1, color, :additive
 
           # ZOC indicator.
-          if tile.entities_exerting_zoc(@selected_tile.object.faction).any?
-            Tile.blank.draw_rot tile.x, tile.y, 0, 0, 0.5, 0.5, 0.2, 0.2, ZOC_COLOR
+          if tile.entities_exerting_zoc(selected.tile.object.faction).any? and tile.empty?
+            Tile.blank.draw_rot tile.x, tile.y, 0, 0, 0.5, 0.5, 0.7, 0.7, ZOC_COLOR
           end
         end
       end
@@ -83,16 +100,25 @@ class MouseSelection < GameObject
   end
 
   def modify_occlusions(tiles, amount)
-    tiles.each do |tile|
+    Array(tiles).each do |tile|
       tile.modify_occlusions amount
     end
   end
   
   def draw
     # Draw a disc under the selected object.
-    if @selected_tile
-      selected_color = @selected_tile.object.move? ? Color::GREEN : Color::BLACK
-      @selected_image.draw_rot @selected_tile.x, @selected_tile.y, ZOrder::TILE_SELECTION, 0, 0.5, 0.5, 1, 1, selected_color
+    if selected and selected.tile
+      selected_color = if selected.is_a? Objects::Entity
+                         if selected_can_be_controlled? and selected.move?
+                           Color::GREEN
+                         else
+                           Color::BLACK
+                         end
+                        else
+                          Color::BLUE
+                        end
+
+      @selected_image.draw_rot selected.tile.x, selected.tile.y, ZOrder::TILE_SELECTION, 0, 0.5, 0.5, 1, 1, selected_color
 
       # Highlight all squares that character can travel to.
       @moves_record.draw 0, 0, ZOrder::TILE_SELECTION if @moves_record
@@ -102,36 +128,45 @@ class MouseSelection < GameObject
       color = (@hover_tile.empty? or @hover_tile.object.inactive?) ? Color::BLUE : Color::CYAN
       @mouse_hover_image.draw_rot @hover_tile.x, @hover_tile.y, ZOrder::TILE_SELECTION, 0, 0.5, 0.5, 1, 1, color
     end
+
+    # Make the stat-bars visible when hovering over something else.
+    if @hover_tile and not (selected and @hover_tile == selected.tile)
+      object = @hover_tile.object
+      object.draw_stat_bars 10000 if object.is_a? Objects::Entity and object.alive?
+    end
   end
 
   def left_click
-    if @selected_tile
-      path = @path
-      # Move the character.
-      if @potential_moves.include? @hover_tile
-        case path
-          when Paths::Move
-            @map.actions.do :ability, selected.ability(:move).action_data(path)
-            @selected_tile = @hover_tile
-          when Paths::Melee
-            attacker = selected
-            @map.actions.do :ability, attacker.ability(:move).action_data(path.previous_path) if path.requires_movement?
-            @map.actions.do :ability, attacker.ability(:melee).action_data(path.last)
-            @selected_tile = attacker.tile
-        end
-        calculate_path
-        calculate_potential_moves
+    if @potential_moves.include? @hover_tile
+      path = @path # @path will change as we move.
+
+      # Move the character, perhaps with melee at the end.
+      case path
+        when Paths::Move
+          selected.use_ability :move, path
+        when Paths::Melee
+          selected.use_ability :move, path.previous_path if path.requires_movement?
+
+          # Only perform melee if you weren't killed by attacks of opportunity.
+          attacker, target = selected, path.last.object
+          attacker.add_activity do
+            attacker.use_ability :melee, target if attacker.alive?
+          end
       end
-    elsif @hover_tile and @hover_tile.object.is_a? Objects::Entity and @hover_tile.object.active?
+
+      calculate_path
+      calculate_potential_moves
+    elsif @hover_tile and @hover_tile.object
       # Select a character to move.
-      select(@hover_tile.object)
+      self.selected = @hover_tile.object
     end
   end
 
-  def select(entity)
-    if entity
-      @selected_tile = entity.tile
-      @moves_record = nil
+  def recalculate
+    @moves_record = nil
+
+    if selected and selected_can_be_controlled?
+      calculate_path
       calculate_potential_moves
     else
       modify_occlusions @potential_moves, -1
@@ -139,16 +174,38 @@ class MouseSelection < GameObject
 
       modify_occlusions @path.tiles, -1 if @path
       @path = nil
+    end
+  end
 
-      @selected_tile = nil
+  def selected=(object)
+    # Make sure we learn of any changes made to the selected object so we can move.
+    if selected
+      @selected_changed_handler.unsubscribe
+      @selected_changed_handler = nil
+    end
+
+    @selected = object
+    recalculate
+
+    if selected
+      tile, path, potential_moves = selected.tile, @path, @potential_moves.dup
+
+      @selected_changed_handler = selected.subscribe :changed do |entity|
+        recalculate
+
+        # Create a partial path while we move.
+        if path and entity.tile != tile
+          tile = entity.tile
+          path.prepare_for_drawing potential_moves, from: entity.tile
+          modify_occlusions path.tiles, +1
+          @path = path
+        end
+      end
     end
   end
 
   def right_click
-    # Deselect the currently selected character.
-    if @selected_tile
-      select nil
-    end
+    self.selected = nil if selected
   end
 end
 end

data/lib/smash_and_grab/objects/entity.rb

@@ -1,4 +1,6 @@
 require 'set'
+require 'fiber'
+
 require_relative "../path"
 require_relative "../abilities"
 require_relative "world_object"
@@ -14,14 +16,29 @@ class Entity < WorldObject
   SPRITE_WIDTH, SPRITE_HEIGHT = 66, 66
   PORTRAIT_WIDTH, PORTRAIT_HEIGHT = 36, 36
 
-  MELEE_COST = 1
-  MELEE_DAMAGE = 5
+  STATS_BACKGROUND_COLOR = Color::BLACK
+  STATS_HP_COLOR = Color.rgb(0, 200, 0)
+  STATS_MP_COLOR = Color.rgb(100, 100, 255)
+  STATS_AP_COLOR = Color::YELLOW
+  STATS_USED_COLOR = Color.rgb(100, 100, 100)
+  STATS_WIDTH = 12.0
+  STATS_HALF_WIDTH = STATS_WIDTH / 2
+
+  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
+  end
 
   def_delegators :@faction, :minimap_color, :active?, :inactive?
 
   attr_reader :faction, :movement_points, :action_points, :health, :type, :portrait,
               :max_movement_points, :max_action_points, :max_health
 
+  alias_method :hp, :health
+  alias_method :max_hp, :max_health
+
   attr_writer :movement_points, :action_points
 
   alias_method :max_mp, :max_movement_points
@@ -37,11 +54,6 @@ class Entity < WorldObject
   def name; @type.to_s.split("_").map(&:capitalize).join(" "); end
   def alive?; @health > 0 and @tile; end
 
-  def self.config; @@config ||= YAML.load_file(File.expand_path("config/map/entities.yml", EXTRACT_PATH)); end
-  def self.types; config.keys; end
-  def self.sprites; @@sprites ||= SpriteSheet.new("entities.png", SPRITE_WIDTH, SPRITE_HEIGHT, 8); end
-  def self.portraits; @@portraits ||= SpriteSheet.new("entity_portraits.png", PORTRAIT_WIDTH, PORTRAIT_HEIGHT, 8); end
-
   def initialize(map, data)
     @type = data[:type]
     config = self.class.config[data[:type]]
@@ -76,12 +88,18 @@ class Entity < WorldObject
 
     if config[:abilities]
       config[:abilities].each do |ability_data|
-        ability_data = ability_data
         @abilities[ability_data[:type]] = Abilities.ability(self, ability_data)
       end
     end
 
+    @queued_activities = []
+
     @faction << self
+
+    @stat_bars_record = nil
+    subscribe :changed do
+      @stat_bars_record = nil
+    end
   end
 
   def has_ability?(type); @abilities.has_key? type; end
@@ -100,21 +118,55 @@ class Entity < WorldObject
                     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!"
       self.tile = nil
+      @queued_activities.empty?
     end
   end
-
-  def melee(other)
-    other.health -= MELEE_DAMAGE
-    @action_points -= MELEE_COST
+  alias_method :hp=, :health=
+
+  # Called from GameAction::Ability
+  # Also used to un-melee :)
+  def melee(target, damage)
+    add_activity do
+      if damage > 0 # do => wound
+        face target
+        self.z += 10
+        delay 0.1
+        self.z -= 10
+
+        # 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
+
+          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"
+        end
+      else # undo => heal
+        target.color = Color.rgb(255, 100, 100)
+        delay 0.1
+        target.health -= damage
+        target.color = Color::WHITE
+
+        self.z += 10
+        delay 0.1
+        self.z -= 10
+      end
+    end
   end
 
   def start_turn
     @movement_points = @max_movement_points
     @action_points = @max_action_points
+    publish :changed
   end
 
   def end_turn
@@ -122,7 +174,39 @@ class Entity < WorldObject
   end
 
   def draw
-    super() if alive?
+    return unless alive?
+
+    super()
+
+    draw_stat_bars @y
+  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
+
+      $window.pixel.draw -0.5, -0.5, 0, STATS_WIDTH + 1, height + 1, STATS_BACKGROUND_COLOR
+
+      # Health.
+      $window.pixel.draw 0, 0, 0, STATS_WIDTH * health / max_health, 1, STATS_HP_COLOR
+
+      # Action points.
+      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
+      end
+
+      # Movement points.
+      $window.pixel.draw 0, 2, 0, 12.0 * mp / max_mp, 1, STATS_MP_COLOR if active?
+    end
+
+    @stat_bars_record.draw @x - STATS_HALF_WIDTH, @y - 4, zorder
   end
 
   def friend?(character); @faction.friend? character.faction; end
@@ -151,6 +235,8 @@ class Entity < WorldObject
     # 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
@@ -165,7 +251,7 @@ class Entity < WorldObject
 
         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
+          if (current_tile.empty? or current_tile == tile) and ap >= melee_cost
             valid_tiles << testing_tile
           end
 
@@ -174,7 +260,8 @@ class Entity < WorldObject
 
           # 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
-            if old_path = open_paths[testing_tile]
+            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
@@ -198,6 +285,11 @@ class Entity < WorldObject
     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)
@@ -218,15 +310,18 @@ class Entity < WorldObject
         new_path = nil
 
         object = testing_tile.object
-        if object and object.is_a?(Objects::Entity) and enemy?(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
+          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))
+          if object.nil? or object.passable?(self)
             new_path = Paths::Move.new(path, testing_tile, wall.movement_cost)
           else
             next
@@ -234,7 +329,8 @@ class Entity < WorldObject
         end
 
         # If the path is shorter than one we've already calculated, then replace it. Otherwise just store it.
-        if old_path = open_paths[testing_tile]
+        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
@@ -247,28 +343,111 @@ class Entity < WorldObject
     Paths::Inaccessible.new(destination_tile) # Failed to connect at all.
   end
 
-  # Actually perform movement (called from GameAction::Move).
+  def update
+    super
+
+    unless @queued_activities.empty?
+      @queued_activities.first.resume if @queued_activities.first.alive?
+      unless @queued_activities.first.alive?
+        @queued_activities.shift
+        publish :changed if @queued_activities.empty?
+      end
+    end
+  end
+
+  def add_activity(&action)
+    @queued_activities << Fiber.new(&action)
+    publish :changed if @queued_activities.size == 1 # Means busy? changed from false to true.
+  end
+
+  def prepend_activity(&action)
+    @queued_activities.unshift Fiber.new(&action)
+    publish :changed if @queued_activities.size == 1 # Means busy? changed from false to true.
+  end
+
+  def clear_activities
+    has_activities = @queued_activities.any?
+    @queued_activities.clear
+    publish :changed if has_activities # Means busy? changed from true to false.
+  end
+
+  def busy?
+    @queued_activities.any?
+  end
+
+  # @overload delay(duration)
+  #   Wait for duration (Called from an activity ONLY!)
+  #   @param duration [Number]
+  #
+  # @overload delay
+  #   Wait until next frame (Called from an activity ONLY!)
+  def delay(duration = 0)
+    raise if duration < 0
+
+    if duration == 0
+      Fiber.yield
+    else
+      finish = Time.now + duration
+      Fiber.yield until Time.now >= finish
+    end
+  end
+
+  # @param target [Tile, Objects::WorldObject]
+  def face(target)
+    change_in_x = target.x - x
+    self.factor_x = change_in_x > 0 ? 1 : -1
+  end
+
+  # Actually perform movement (called from GameAction::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
 
     tiles = tiles.map {|pos| @map.tile_at_grid *pos } unless tiles.first.is_a? Tile
 
-    destination = tiles.last
     @movement_points -= movement_cost
 
-    change_in_x = destination.x - tiles[-2].x
+    add_activity do
+      tiles.each_cons(2) do |from, to|
+        face to
 
-    # Turn based on movement.
-    self.factor_x = change_in_x > 0 ? 1 : -1
+        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!
+        if to.object
+          self.z = 20
+          self.x, self.y = to.x, to.y
+        else
+          self.tile = to
+          self.z = 0
+        end
 
-    self.tile = destination
+        # TODO: this will be triggered _every_ time you move, even when redoing is done!
+        trigger_zoc_melee to
+        break unless alive?
+      end
+    end
+
+    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_attacks
-    enemies = tile.entities_exerting_zoc(self)
+  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|
-      map.actions.do :ability, :melee, enemy, self # Only get one opportunity attack per enemy entering.
+      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?
+      end
     end
   end
 
@@ -339,9 +518,19 @@ class Entity < WorldObject
     nil # Didn't hit anything.
   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
+  end
+
   def to_json(*a)
     data = {
-        class: CLASS,
+        :class => CLASS,
         type: @type,
         id: id,
         health: @health,
@@ -356,4 +545,4 @@ class Entity < WorldObject
   end
 end
 end
-end
+end

data/lib/smash_and_grab/objects/static.rb

@@ -12,11 +12,13 @@ class Static < WorldObject
   def inactive?; true; end
 
   def to_s; "<#{self.class.name}/#{@type}##{id} #{tile ? grid_position : "[off-map]"}>"; end
-  def name; @type.split("_").map(&:capitalize).join(" "); end
+  def name; @type.to_s.split("_").map(&:capitalize).join(" "); end
 
-  def self.config; @@config ||= YAML.load_file(File.expand_path("config/map/objects.yml", EXTRACT_PATH)); end
-  def self.types; config.keys; end
-  def self.sprites; @@sprites ||= SpriteSheet.new("objects.png", 64 + 2, 64 + 2, 8); end
+  class << self
+    def config; @config ||= YAML.load_file(File.expand_path("config/map/objects.yml", EXTRACT_PATH)); end
+    def types; config.keys; end
+    def sprites; @sprites ||= SpriteSheet.new("objects.png", 64 + 2, 64 + 2, 8); end
+  end
 
   def initialize(map, data)
     @type = data[:type]
@@ -36,7 +38,7 @@ class Static < WorldObject
 
   def to_json(*a)
     {
-        class: CLASS,
+        :class => CLASS,
         type: @type,
         id: id,
         tile: grid_position,

data/lib/smash_and_grab/objects/vehicle.rb

@@ -21,11 +21,13 @@ class Vehicle < WorldObject
   def inactive?; true; end
 
   def to_s; "<#{self.class.name}/#{@type}##{id} #{tile ? grid_position : "[off-map]"}>"; end
-  def name; @type.split("_").map(&:capitalize).join(" "); end
+  def name; @type.to_s.split("_").map(&:capitalize).join(" "); end
 
-  def self.config; @@config ||= YAML.load_file(File.expand_path("config/map/vehicles.yml", EXTRACT_PATH)); end
-  def self.types; config.keys; end
-  def self.sprites; @@sprites ||= SpriteSheet.new("vehicles.png", (128 * 2) + 2, (128 * 2) + 2, 3); end
+  class << self
+    def config; @config ||= YAML.load_file(File.expand_path("config/map/vehicles.yml", EXTRACT_PATH)); end
+    def types; config.keys; end
+    def sprites; @sprites ||= SpriteSheet.new("vehicles.png", (128 * 2) + 2, (128 * 2) + 2, 3); end
+  end
 
   def fills_tile_on_minimap?; true; end
 
@@ -89,7 +91,7 @@ class Vehicle < WorldObject
 
   def to_json(*a)
     {
-        class: CLASS,
+        :class => CLASS,
         type: @type,
         id: id,
         tile: grid_position,