smash_and_grab 0.0.5alpha → 0.0.6alpha

data/lib/smash_and_grab/mixins/line_of_sight.rb

@@ -0,0 +1,129 @@
+module SmashAndGrab
+  module Mixins
+    module LineOfSight
+      #
+      def line_of_sight?(target_tile)
+        !line_of_sight_blocked_by(target_tile)
+      end
+
+      # Returns the tile that blocks sight, otherwise nil.
+      # Implements 'Bresenham's line algorithm'
+      # @return [Tile, Wall, nil]
+      def line_of_sight_blocked_by(target_tile)
+        raise unless target_tile.is_a? 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, which has to run either
+          # .45      ..5
+          # 23.  OR  .34
+          # 1..      12.
+          # Blocked only if BOTH are blocked - return blockage from just one if both are blocked.
+          blockage1 = zig_zag_blocked_by(tile, step_x, step_y, dx - 1, true)
+          blockage2 = zig_zag_blocked_by(tile, step_x, step_y, dx - 1, false)
+          if blockage1 && blockage2
+            # Choose the blockage that is closest to us, since the other is irrelevant.
+            [blockage1, blockage2].min_by do |blockage|
+              case blockage
+                when Wall
+                  blockage.tiles.map {|t| manhattan_distance t }.min
+                when Tile
+                  manhattan_distance blockage
+              end
+            end
+          elsif blockage1
+            blockage1
+          else
+            blockage2
+          end
+        else
+          ray_trace_blocked_by tile, step_x, step_y, dx, dy
+        end
+      end
+
+      protected
+      def zig_zag_blocked_by(from, step_x, step_y, length, x_first)
+        current = from
+        x, y = from.grid_x, from.grid_y
+
+        length.times do
+          if x_first
+            x += step_x
+          else
+            y += step_y
+          end
+
+          checking = @map.tile_at_grid(x, y)
+          blockage = tile_to_tile_blocked_by current, checking
+          return blockage if blockage
+          current = checking
+
+          if x_first
+            y += step_y
+          else
+            x += step_x
+          end
+
+          checking = @map.tile_at_grid(x, y)
+          blockage = tile_to_tile_blocked_by current, checking
+          return blockage if blockage
+          current = checking
+        end
+
+        nil
+      end
+
+      protected
+      def ray_trace_blocked_by(from, step_x, step_y, dx, dy)
+        current = from
+        x, y = from.grid_x, from.grid_y
+
+        # General case, ray-trace.
+        error = dx - dy
+
+        # Ensure that all tiles are visited that the sight-line passes over,
+        # not just those that create a "drawn" line.
+        dx *= 2
+        dy *= 2
+
+        length = ((dx + dy + 1) / 2)
+
+        (length - 1).times do
+          # Note that this ignores the special case of error == 0
+          if error > 0
+            error -= dy
+            x += step_x
+          else
+            error += dx
+            y += step_y
+          end
+
+          # Look at the next tile and see which wall is in the way.
+          checking = @map.tile_at_grid(x, y)
+          blockage = tile_to_tile_blocked_by current, checking
+          return blockage if blockage
+          current = checking
+        end
+
+        nil
+      end
+
+      protected
+      def tile_to_tile_blocked_by(from, to)
+        wall = from.wall_to to
+        if wall and wall.blocks_sight?
+          wall
+        elsif to.blocks_sight?
+          to
+        end
+      end
+    end
+  end
+end

data/lib/smash_and_grab/mixins/pathfinding.rb

@@ -0,0 +1,145 @@
+require_relative "../path"
+
+module SmashAndGrab
+  module Mixins
+    module Pathfinding
+      # 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
+        pick_up_cost = has_ability?(:pick_up) ? ability(:pick_up).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 object and object.is_a?(Objects::Static) and pick_up?(object)
+              if (current_tile.empty? or current_tile == tile) and ap >= pick_up_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, 0)
+
+              # 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? Objects::Entity and destination_object.enemy?(self))
+
+        melee_cost = has_ability?(:melee) ? ability(:melee).action_cost : Float::INFINITY
+        pick_up_cost = has_ability?(:pick_up) ? ability(:pick_up).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 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 object and object.is_a?(Objects::Static) and pick_up?(object)
+              if (current_tile.empty? or current_tile == tile) and ap >= pick_up_cost
+                new_path = Paths::PickUp.new(path, testing_tile)
+              else
+                next
+              end
+
+            elsif testing_tile.passable?(self)
+              if object.nil? or object.passable?(self)
+                disincentive = 0
+                disincentive += 1 if testing_tile.overwatched? faction
+                if testing_tile.object
+                  disincentive += 1 # Try to avoid moving through objects, so try alternate routes in preference.
+                else
+                  disincentive += 1 if testing_tile.zoc? faction
+                end
+                new_path = Paths::Move.new(path, testing_tile, wall.movement_cost, disincentive)
+              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
+    end
+  end
+end

data/lib/smash_and_grab/mouse_selection.rb

@@ -2,22 +2,34 @@ module SmashAndGrab
 class MouseSelection < GameObject
   attr_reader :selected, :hover_tile
 
-  MOVE_COLOR = Color.rgba(0, 255, 0, 60)
-  MELEE_COLOR = Color.rgba(255, 0, 0, 80)
+  MOVE_COLOR = Color.rgba(50, 50, 255, 60)
+  POTENTIAL_ATTACK_COLOR = Color.rgba(255, 255, 255, 100)
+  RANGED_EYE_COLOR = Color.rgba(255, 255, 255, 30)
   NO_MOVE_COLOR = Color.rgba(255, 0, 0, 30)
-  ZOC_COLOR = Color.rgba(255, 0, 0, 100)
+  WARNING_COLOR = Color.rgba(255, 255, 255, 50) # ZOC/Overwatch warnings
   
   def initialize(map, options = {})
     @map = map
 
     @potential_moves = []
+    @potential_ranged = []
 
     @selected_image = Image["tile_selection.png"]
     @mouse_hover_image = Image["mouse_hover.png"]
 
+    path_images = SpriteSheet["path.png", 32, 16, 4]
+    @ranged_target_image = path_images[0, 4]
+    @ranged_eye_image = path_images[1, 4]
+    @ranged_dot_image = path_images[2, 4]
+    @melee_target_image = path_images[3, 1]
+    @pick_up_image = path_images[0, 5]
+    @zoc_image = path_images[3, 4]
+    @overwatch_image = path_images[2, 4]
+
     @selected = @hover_tile = nil
     @path = nil
     @moves_record = nil
+    @ranged_record = nil
     @selected_changed_handler = nil
 
     super(options)
@@ -37,11 +49,21 @@ class MouseSelection < GameObject
 
   def update
     self.selected = nil if selected and selected.tile.nil?
+
+    # Ensure the character faces the mouse, but don't flip out when moving the mouse directly above or
+    # below the character, so ensure that the cursor has to move a few pixels further across to trigger switch.
+    if @hover_tile and selected_can_be_controlled?
+      if (parent.cursor_world_x - selected.x >  2 and selected.factor_x < 0) or # Turn right
+         (parent.cursor_world_x - selected.x < -2 and selected.factor_x > 0)    # Turn left
+        selected.face parent.cursor_world_x
+      end
+    end
+
     super
   end
 
   def selected_can_be_controlled?
-    selected and selected.active? and selected.faction.player.is_a?(Players::Human) and not @map.busy?
+    selected and selected.active? and selected.faction.player.human? and not @map.busy?
   end
   
   def tile=(tile)
@@ -67,6 +89,8 @@ class MouseSelection < GameObject
     else
       modify_occlusions @potential_moves, +1
       @potential_moves.clear
+      modify_occlusions @potential_ranged, +1
+      @potential_ranged.clear
     end
   end
 
@@ -80,19 +104,46 @@ class MouseSelection < GameObject
     else
       $window.record(1, 1) do
         @potential_moves.each do |tile|
-          entity = tile.object
-          color = if entity and entity.enemy?(selected)
-            MELEE_COLOR
-          else
-            MOVE_COLOR
+          case tile.object
+            when Objects::Entity
+              if tile.object.enemy?(selected)
+                @melee_target_image.draw_rot tile.x, tile.y, 0, 0, 0.5, 0.5, 1, 1, POTENTIAL_ATTACK_COLOR
+              end
+            when Objects::Static
+              @pick_up_image.draw_rot tile.x, tile.y, 0, 0, 0.5, 0.5, 1, 1, POTENTIAL_ATTACK_COLOR
+
+            else
+              Tile.blank.draw_rot tile.x, tile.y, 0, 0, 0.5, 0.5, 1, 1, MOVE_COLOR, :additive
           end
 
-          # Tile background
-          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? and tile.empty?
-            Tile.blank.draw_rot tile.x, tile.y, 0, 0, 0.5, 0.5, 0.7, 0.7, ZOC_COLOR
+            @zoc_image.draw_rot tile.x, tile.y, 0, 0, 0.5, 0.5, 1, 1, WARNING_COLOR
+          end
+
+          if tile.overwatched? selected.faction
+            @overwatch_image.draw_rot tile.x, tile.y, 0, 0, 0.5, 0.5, 1, 1, WARNING_COLOR
+          end
+        end
+      end
+    end
+  end
+
+  def calculate_potential_ranged
+    modify_occlusions @potential_ranged, -1
+    @potential_ranged = selected.potential_ranged
+    modify_occlusions @potential_ranged, +1
+
+    # Draw a mark on all tiles that could be affected by ranged attack.
+    @ranged_record = if @potential_ranged.empty?
+      nil
+    else
+      $window.record 1, 1 do
+        @potential_ranged.each do |tile|
+          if tile.object and tile.object.is_a?(Objects::Entity) and selected.enemy?(tile.object)
+            @ranged_target_image.draw_rot tile.x, tile.y, 0, 0, 0.5, 0.5, 1, 1, POTENTIAL_ATTACK_COLOR
+          else
+            @ranged_eye_image.draw_rot tile.x, tile.y, 0, 0, 0.5, 0.5, 1, 1, RANGED_EYE_COLOR
           end
         end
       end
@@ -106,23 +157,22 @@ class MouseSelection < GameObject
   end
   
   def draw
-    # Draw a disc under the selected object.
     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
+      # Draw a disc/box under the selected object.
+      selected.draw_base
 
       # Highlight all squares that character can travel to.
       @moves_record.draw 0, 0, ZOrder::TILE_SELECTION if @moves_record
-      @path.draw if @path
+
+      @ranged_record.draw 0, 0, ZOrder::TILE_SELECTION if @ranged_record
+
+      if @ranged_record and @potential_ranged.include?(@hover_tile) and @hover_tile.object and
+          @hover_tile.object.is_a?(Objects::Entity) and selected.enemy?(@hover_tile.object) and
+          selected.line_of_sight?(@hover_tile)
+        @ranged_target_image.draw_rot @hover_tile.x, @hover_tile.y, 0, 0, 0.5, 0.5, 1, 1
+      elsif @path
+        @path.draw selected.mp
+      end
 
     elsif @hover_tile
       color = (@hover_tile.empty? or @hover_tile.object.inactive?) ? Color::BLUE : Color::CYAN
@@ -130,32 +180,49 @@ class MouseSelection < GameObject
     end
 
     # Make the stat-bars visible when hovering over something else.
-    if @hover_tile and not (selected and @hover_tile == selected.tile)
+    if @hover_tile
       object = @hover_tile.object
-      object.draw_stat_bars 10000 if object.is_a? Objects::Entity and object.alive?
+      object.draw_stat_bars zorder: ZOrder::BEHIND_GUI if object.is_a? Objects::Entity and object.alive?
     end
   end
 
   def left_click
-    if @potential_moves.include? @hover_tile
-      path = @path # @path will change as we move.
+    if @ranged_record and @hover_tile and @hover_tile.object and
+        @hover_tile.object.is_a?(Objects::Entity) and selected.enemy?(@hover_tile.object) and
+        selected.line_of_sight?(@hover_tile)
+
+      selected.use_ability :ranged, @hover_tile.object
+      calculate_potential_ranged unless selected.use_ability? :ranged
+
+    elsif @potential_moves.include? @hover_tile
+      actor = selected
+      saved_path = @path # @path will change as we move.
 
       # Move the character, perhaps with melee at the end.
-      case path
+      case saved_path
         when Paths::Move
-          selected.use_ability :move, path
+          actor.use_ability :move, saved_path
+
         when Paths::Melee
-          selected.use_ability :move, path.previous_path if path.requires_movement?
+          actor.use_ability :move, saved_path.previous_path if saved_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?
+          actor.add_activity do
+            actor.use_ability :melee, saved_path.defender if actor.alive?
+          end
+
+        when Paths::PickUp
+          actor.use_ability :move, saved_path.previous_path if saved_path.requires_movement?
+
+          # Only pick up if you weren't killed by attacks of opportunity.
+          actor.add_activity do
+            actor.use_ability :pick_up, saved_path.object if actor.alive?
           end
       end
 
       calculate_path
       calculate_potential_moves
+      calculate_potential_ranged
     elsif @hover_tile and @hover_tile.object
       # Select a character to move.
       self.selected = @hover_tile.object
@@ -164,13 +231,17 @@ class MouseSelection < GameObject
 
   def recalculate
     @moves_record = nil
+    @ranged_record = nil
 
     if selected and selected_can_be_controlled?
       calculate_path
       calculate_potential_moves
+      calculate_potential_ranged
     else
       modify_occlusions @potential_moves, -1
       @potential_moves.clear
+      modify_occlusions @potential_ranged, -1
+      @potential_ranged.clear
 
       modify_occlusions @path.tiles, -1 if @path
       @path = nil