smash_and_grab 0.0.5alpha → 0.0.6alpha

data/lib/smash_and_grab/objects/floating_text.rb

@@ -1,7 +1,6 @@
 module SmashAndGrab
 module Objects
 class FloatingText < GameObject
-  FONT_NAME = File.expand_path("media/fonts/UnmaskedBB.ttf", EXTRACT_PATH)
   FONT_SIZE = 16
 
   def initialize(text, options = {})

data/lib/smash_and_grab/objects/static.rb

@@ -12,14 +12,16 @@ class Static < WorldObject
   def inactive?; true; end
 
   def to_s; "<#{self.class.name}/#{@type}##{id} #{tile ? grid_position : "[off-map]"}>"; end
-  def name; @type.to_s.split("_").map(&:capitalize).join(" "); 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
+    def sprites; @sprites ||= SpriteSheet["objects.png", 64 + 2, 64 + 2, 8]; end
   end
 
+  # TODO: configure this value.
+  def pick_up?(entity); @passable; end
+
   def initialize(map, data)
     @type = data[:type]
     config = self.class.config[@type]
@@ -41,9 +43,14 @@ class Static < WorldObject
         :class => CLASS,
         type: @type,
         id: id,
-        tile: grid_position,
+        tile: tile ? grid_position : nil,
     }.to_json(*a)
   end
+
+  def draw
+    # Without a tile, it has probably been picked up.
+    super if tile
+  end
 end
 end
 end

data/lib/smash_and_grab/objects/vehicle.rb

@@ -21,12 +21,11 @@ class Vehicle < WorldObject
   def inactive?; true; end
 
   def to_s; "<#{self.class.name}/#{@type}##{id} #{tile ? grid_position : "[off-map]"}>"; end
-  def name; @type.to_s.split("_").map(&:capitalize).join(" "); 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
+    def sprites; @sprites ||= SpriteSheet["vehicles.png", (128 * 2) + 2, (128 * 2) + 2, 3]; end
   end
 
   def fills_tile_on_minimap?; true; end
@@ -80,6 +79,12 @@ class Vehicle < WorldObject
     end
   end
 
+  def draw_base
+    tiles do |tile|
+      Image["tiles_selection.png"].draw_rot tile.x, tile.y, ZOrder::TILE_SELECTION, 0, 0.5, 0.5, 1, 1, base_color
+    end
+  end
+
   def draw
     # Draw the image in sections, since it has to exist at several zorder positions in order to render correctly.
     DRAW_POSITIONS.each do |clip_width, offset_z|

data/lib/smash_and_grab/objects/world_object.rb

@@ -20,6 +20,11 @@ class WorldObject < GameObject
   def fills_tile_on_minimap?; false; end
   def casts_shadow?; true; end
 
+  def t; R18n.get.t[Inflector.demodulize self.class.name][type]; end
+  def name; t.name; end
+  def colorized_name; name; end
+  def base_color; Color::BLUE; end
+
   OUTLINE_SCALE = Image::THIN_OUTLINE_SCALE
 
   def initialize(map, data, options = {})
@@ -88,14 +93,16 @@ class WorldObject < GameObject
     @image.draw_rot @x, @y + 2.5 - @z, @y, 0, 0.5, 1, OUTLINE_SCALE * @factor_x, OUTLINE_SCALE, color
   end
 
+  def draw_base
+    Image["tile_selection.png"].draw_rot x, y, ZOrder::TILE_SELECTION, 0, 0.5, 0.5, 1, 1, base_color
+  end
+
   def busy?; false; end
   def active?; false; end
 
   def destroy
-    self.tile = nil
     map.remove self
-
-    publish :changed
+    self.tile = nil
 
     super
   end

data/lib/smash_and_grab/path.rb

@@ -7,7 +7,7 @@ class Path
   TILE_SIZE = 16
 
   class << self
-    def sprites; @sprites ||= SpriteSheet.new("path.png", 32, 16, 4); end
+    def sprites; @sprites ||= SpriteSheet["path.png", 32, 16, 4]; end
   end
 
   attr_reader :cost, :move_distance, :previous_path, :destination_distance, :first, :last
@@ -16,13 +16,13 @@ class Path
   def tiles; @previous_path.tiles + [@last]; end
   def sprites; self.class.sprites; end
 
-  def initialize(previous_path, next_tile, extra_move_distance)
+  def initialize(previous_path, next_tile, extra_move_distance, disincentive)
     @previous_path = previous_path
     @first, @last = @previous_path.first, next_tile
 
     @move_distance = @previous_path.move_distance + extra_move_distance
     @destination_distance = @previous_path.destination_distance
-    @cost = @move_distance + @destination_distance
+    @cost = @move_distance + @destination_distance + disincentive
   end
 
   # @option from [Tile] Tile to start drawing the path from.
@@ -64,7 +64,7 @@ class Path
             end
 
         color = if tile == first or tiles_within_range.include?(tile)
-          Color::GREEN
+          Color.rgb(50, 50, 255)
         else
           Color::BLACK
         end
@@ -74,16 +74,20 @@ class Path
     end
   end
 
-  def draw
+  def draw(move_points)
     @record.draw 0, 0, ZOrder::PATH
+
+    if last.empty? and move_distance > 0
+      Font[FONT_NAME, 8].draw_rel move_points - move_distance, last.x, last.y, ZOrder::BEHIND_GUI, 0.5, 0.5
+    end
   end
 end
 
 # A path consisting just of movement.
 class Move < Path
   def mover; first.object; end
-  def initialize(previous_path, last, extra_move_distance)
-    super(previous_path, last, last.movement_cost + extra_move_distance)
+  def initialize(previous_path, last, extra_move_distance, disincentive)
+    super(previous_path, last, last.movement_cost + extra_move_distance, disincentive)
   end
 end
 
@@ -92,11 +96,10 @@ class Melee < Path
   COLOR_IN_RANGE = Color::WHITE
   COLOR_OUT_OF_RANGE = Color.rgb(100, 100, 100)
 
-  def attacker; previous_path.last.object; end
   def defender; last.object; end
   def requires_movement?; previous_path.is_a? Paths::Move; end
   def initialize(previous_path, last)
-    super(previous_path, last, 0)
+    super(previous_path, last, 0, 0)
   end
 
   def prepare_for_drawing(tiles_within_range, options = {})
@@ -106,10 +109,29 @@ class Melee < Path
 
   def draw(*args)
     super(*args)
+    sprites[3, 1].draw_rot last.x, last.y, ZOrder::PATH, 0, 0.5, 0.5, 1, 1, @draw_color
+  end
+end
 
-    if last.object.is_a? Objects::Entity
-      sprites[3, 1].draw_rot last.x, last.y, ZOrder::PATH, 0, 0.5, 0.5, 1, 1, @draw_color
-    end
+# A path consisting of melee, possibly with some movement beforehand.
+class PickUp < Path
+  COLOR_IN_RANGE = Color::WHITE
+  COLOR_OUT_OF_RANGE = Color.rgb(100, 100, 100)
+
+  def object; last.object; end
+  def requires_movement?; previous_path.is_a? Paths::Move; end
+  def initialize(previous_path, last)
+    super(previous_path, last, 0, 0)
+  end
+
+  def prepare_for_drawing(tiles_within_range, options = {})
+    super(tiles_within_range)
+    @draw_color = tiles_within_range.include?(last) ? COLOR_IN_RANGE : COLOR_OUT_OF_RANGE
+  end
+
+  def draw(*args)
+    super(*args)
+    sprites[0, 5].draw_rot last.x, last.y, ZOrder::PATH, 0, 0.5, 0.5, 1, 1, @draw_color
   end
 end
 
@@ -127,6 +149,8 @@ end
 
 # Path where the destination is unreachable.
 class Inaccessible < Path
+  def cost; 0; end
+  def move_distance; Float::INFINITY; end
   def accessible?; false; end
   def tiles; [@last]; end
 
@@ -143,6 +167,8 @@ end
 
 # Path going to the same location as it started.
 class None < Path
+  def cost; 0; end
+  def move_distance; 0; end
   def accessible?; false; end
   def tiles; []; end
   def initialize; end

data/lib/smash_and_grab/players/ai.rb

@@ -0,0 +1,91 @@
+require_relative "player"
+
+module SmashAndGrab
+  module Players
+    # Local AI.
+    class AI < Player
+      def faction=(faction)
+        super faction
+        faction.subscribe :turn_started do
+          @active_entities = faction.entities.find_all(&:alive?)
+        end
+        faction
+      end
+
+      def update
+        return if faction.map.busy?
+
+        if @active_entities.empty?
+          faction.end_turn
+        else
+          # Attempt to attack, else move, else stand around like a loon.
+          entity = @active_entities.first
+          if entity.alive?
+            # Try ranged, then charge into melee, then pick up, then move.
+            ranged = entity.potential_ranged.map(&:object).compact.find_all do |object|
+              object.is_a?(Objects::Entity) and entity.enemy?(object)
+            end
+
+            if ranged.any?
+              # Avoid bystanders if there are better opponents.
+              unless ranged.all? {|a| a.bystander? }
+                ranged.delete_if {|a| a.bystander? }
+              end
+
+              entity.use_ability :ranged, ranged.sample
+              # Try melee or moving next time.
+            else
+              moves, actions = entity.potential_moves.partition {|t| t.empty? }
+              attacks, pick_ups = actions.partition {|a| a.object.is_a? Objects::Entity }
+
+              if attacks.any?
+                # Avoid bystanders if there are better opponents.
+                unless attacks.all? {|a| a.object.bystander? }
+                  attacks.delete_if {|a| a.object.bystander? }
+                end
+
+                # TODO: Pick the nearest and most dangerous/weakest attack and consider re-attacking.
+                path = entity.path_to(attacks.sample)
+                entity.use_ability :move, path.previous_path if path.requires_movement?
+
+                # Only perform melee if you weren't killed by attacks of opportunity.
+                target = path.last.object
+                entity.add_activity do
+                  if entity.alive?
+                    entity.use_ability :melee, target
+                  else
+                    @active_entities.shift
+                  end
+                end
+
+              elsif pick_ups.any?
+                # TODO: Pick the nearest object or most valuable?
+                path = entity.path_to(pick_ups.sample)
+                entity.use_ability :move, path.previous_path if path.requires_movement?
+
+                # Only pick up if you weren't killed by attacks of opportunity.
+                target = path.last.object
+                entity.add_activity do
+                  if entity.alive?
+                    entity.use_ability :pick_up, target
+                  else
+                    @active_entities.shift
+                  end
+                end
+
+              elsif moves.any?
+                # TODO: Wait with moves until everyone who can has attacked?
+                entity.use_ability :move, entity.path_to(moves.sample)
+                @active_entities.shift
+              else
+                # Can't do anything at all :(
+                # TODO: Maybe wait until other people have tried to move?
+                @active_entities.shift
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/smash_and_grab/players/human.rb

@@ -0,0 +1,9 @@
+require_relative "player"
+
+module SmashAndGrab
+  module Players
+    # Local human player.
+    class Human < Player
+    end
+  end
+end

data/lib/smash_and_grab/players/player.rb

@@ -1,76 +1,27 @@
 module SmashAndGrab
-module Players
-class Player
-  attr_reader :faction
+  module Players
+    class Player
+      attr_reader :faction
 
-  def initialize
-    @faction = nil
-  end
-
-  def faction=(faction)
-    @faction = faction
-
-    @faction.player = self
-
-    @faction.subscribe :turn_started do |faction, entities|
-      @active_entities = entities.select(&:alive?).shuffle
-    end
-
-    @faction.subscribe :turn_ended do
-      @active_entities = nil
-    end
-  end
-
-  def update; end
-end
-
-# Local human player.
-class Human < Player
-end
-
-# Remote human or AI.
-class Remote < Player
-end
+      def human?; self.is_a? Human; end
+      def ai?; self.is_a? AI; end
+      def remote?; self.is_a? Remote; end
 
-# Local AI.
-class AI < Player
-  def update
-    return if faction.map.busy?
-
-    if @active_entities.empty?
-      faction.end_turn
-    else
-       # Attempt to attack, else move, else stand around like a loon.
-      entity = @active_entities.first
-      if entity.alive?
-        moves, attacks = entity.potential_moves.partition {|t| t.empty? }
+      def initialize
+        @faction = nil
+      end
 
-        if attacks.any?
-          # TODO: Pick the nearest attack and consider re-attacking.
-          path = entity.path_to(attacks.sample)
-          entity.use_ability :move, path.previous_path if path.requires_movement?
-          # Only perform melee if you weren't killed by attacks of opportunity.
-          target = path.last.object
-          entity.add_activity do
-            entity.use_ability :melee, target if entity.alive?
-          end
+      def faction=(faction)
+        @faction = faction
 
-          entity.add_activity do
-            @active_entities.shift unless entity.use_ability?(:melee)
-          end
+        @faction.player = self
 
-        elsif moves.any?
-          # TODO: Wait with moves until everyone who can has attacked?
-          entity.use_ability :move, entity.path_to(moves.sample)
-          @active_entities.shift
-        else
-          # Can't do anything at all :(
-          # TODO: Maybe wait until other people have tried to move?
-          @active_entities.shift
+        @faction.subscribe :turn_ended do
+          # Do nothing.
         end
       end
+
+      def update; end
     end
   end
-end
-end
 end

data/lib/smash_and_grab/players/remote.rb

@@ -0,0 +1,9 @@
+require_relative "player"
+
+module SmashAndGrab
+  module Players
+    # Remote human or AI.
+    class Remote < Player
+    end
+  end
+end

data/lib/smash_and_grab/sprite_sheet.rb

@@ -4,6 +4,15 @@ class SpriteSheet
 
   def_delegators :@sprites, :map, :each
 
+  class << self
+    def [](file, width, height, tiles_wide = 0)
+      @cached_sheets ||= Hash.new do |h, k|
+         h[k] = new(*k)
+      end
+      @cached_sheets[[file, width, height, tiles_wide]]
+    end
+  end
+
   def initialize(file, width, height, tiles_wide = 0)
     @sprites = Image.load_tiles($window, File.expand_path(file, Image.autoload_dirs[0]), width, height, false)
     @tiles_wide = tiles_wide