smash_and_grab 0.0.1alpha

data/lib/smash_and_grab/map/wall.rb

@@ -0,0 +1,139 @@
+module SmashAndGrab
+class Wall < GameObject
+  SEMI_TRANSPARENT_COLOR = Color.rgba(255, 255, 255, 120)
+  OPAQUE_COLOR = Color::WHITE
+  
+  SPRITE_WIDTH, SPRITE_HEIGHT = 32, 64
+
+  # [[x_offset, _y_offset], direction, height needed to occlude
+  WALL_OCCLUSION_POSITIONS = {
+      vertical: [
+          [[ 0,  0],  1], # Own tile.
+          [[+1,  0],  1], # Right.
+          [[+1, -1],  2], # Top right.
+          [[+2, -1],  2],
+      ],
+      horizontal: [
+          [[ 0,  0],  1], # Own tile.
+          [[ 0, -1],  1], # Top.
+          [[+1, -1],  2], # Top right.
+          [[+1, -2],  2],
+      ]
+  }
+    
+  attr_reader :minimap_color, :tiles_high, :thickness, :movement_cost, :type, :tiles, :orientation
+
+  def blocks_movement?; movement_cost == Float::INFINITY; end
+  def allows_movement?; movement_cost < Float::INFINITY; end
+
+  def zorder; super + 0.01; end
+  def to_s; "<#{self.class.name}##{@type} #{@tiles[0].grid_position} <=> #{@tiles[1].grid_position}]>"; end
+  def occludes?; @occludes; end
+
+  def blocks_sight?; @blocks_sight; end
+
+  def self.config; @@config ||= YAML.load_file(File.expand_path("config/map/walls.yml", EXTRACT_PATH)); end
+  def self.sprites; @@sprites ||= SpriteSheet.new("walls.png", SPRITE_WIDTH, SPRITE_HEIGHT, 8); end
+
+  def initialize(map, data)
+    options = {
+        rotation_center: :bottom_center,
+    }
+
+    super(options)
+
+    @objects = []
+    @occludes = false # Does the wall occlude anything that should be seen?
+
+    @map = map
+
+    @tiles = data[:tiles].map {|p| map.tile_at_grid(*p) }.sort_by(&:y)
+
+    @destinations = {
+        @tiles.first => @tiles.last,
+        @tiles.last => @tiles.first,
+    }
+
+    self.x, self.y = @tiles.first.x, @tiles.first.y + (SPRITE_HEIGHT / 8),
+    self.zorder = @tiles.first.y + 0.01
+
+    if @tiles.last.grid_y > @tiles.first.grid_y
+      @tiles.last.add_wall :up, self
+      @tiles.first.add_wall :down, self
+      @orientation = :vertical
+    else
+      @tiles.last.add_wall :right, self
+      @tiles.first.add_wall :left, self
+      @orientation = :horizontal
+    end
+
+    self.type = data[:type]
+  end
+
+  def type=(type)
+    changed = defined? @type
+
+    @type = type
+
+    config = self.class.config[@type]
+
+    @minimap_color = Color.rgba(*config[:minimap_color])
+    @blocks_sight = config[:blocks_sight]
+    @movement_cost = config[:movement_cost]
+    @tiles_high = config[:tiles_high]
+
+    #@y -= (4 - @thickness) / 2 if @thickness
+    @thickness = config[:thickness]
+    #@y += (4 - @thickness) / 2 if @thickness
+
+    spritesheet_positions = config[:spritesheet_positions]
+    image = if @tiles.last.grid_y > @tiles.first.grid_y
+      spritesheet_positions ? self.class.sprites[*spritesheet_positions[:vertical]] : nil
+    else
+      spritesheet_positions ? self.class.sprites[*spritesheet_positions[:horizontal]] : nil
+    end
+
+    @map.remove self if @image
+    @image = image
+    @map << self if @image
+
+    @map.publish :wall_type_changed, self if changed
+
+    update_occlusion
+
+    type
+  end
+
+  # Recalculate possible occlusions from permanent objects.
+  def update_occlusion
+    grid_x, grid_y = tiles.first.grid_position
+
+    # Look at all positions that could
+    @occludes = WALL_OCCLUSION_POSITIONS[@orientation].any? do |(offset_x, offset_y), min_height|
+      if @tiles_high >= min_height
+        tile = @map.tile_at_grid(grid_x + offset_x, grid_y + offset_y)
+        tile and tile.needs_to_be_seen?
+      else
+        false
+      end
+    end
+
+    @color = occludes? ? SEMI_TRANSPARENT_COLOR : OPAQUE_COLOR
+  end
+
+  def destination(from)
+    blocks_movement? ? nil : @destinations[from]
+  end
+
+  def draw
+    @image.draw_rot @x, @y, @zorder, 0, 0.5, 1, 1, 1, @color
+  end
+
+  def to_json(*a)
+    {
+        type: @type,
+        tiles: @tiles.map(&:grid_position),
+    }.to_json(*a)
+  end
+end
+end

data/lib/smash_and_grab/mouse_selection.rb

@@ -0,0 +1,154 @@
+module SmashAndGrab
+class MouseSelection < GameObject
+  attr_reader :selected_tile, :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
+  
+  def initialize(map, options = {})
+    @map = map
+
+    @potential_moves = []
+
+    @selected_image = Image["tile_selection.png"]
+    @mouse_hover_image = Image["mouse_hover.png"]
+
+    @selected_tile = @hover_tile = nil
+    @path = nil
+    @moves_record = nil
+
+    super(options)
+
+    add_inputs(released_left_mouse_button: :left_click,
+               released_right_mouse_button: :right_click)
+  end
+  
+  def tile=(tile)
+    if tile != @hover_tile
+      modify_occlusions [@hover_tile], -1 if @hover_tile
+      @hover_tile = tile
+      modify_occlusions [@hover_tile], +1 if @hover_tile
+      calculate_path
+    end
+  end
+
+  def calculate_path
+    if @selected_tile
+      modify_occlusions @path.tiles, -1 if @path
+
+      if @hover_tile
+        @path = @selected_tile.object.path_to(@hover_tile)
+        @path.prepare_for_drawing(@potential_moves)
+        modify_occlusions @path.tiles, +1
+      else
+        @path = nil
+      end
+    else
+      modify_occlusions @potential_moves, +1
+      @potential_moves.clear
+    end
+  end
+
+  def calculate_potential_moves
+    modify_occlusions @potential_moves, -1
+    @potential_moves = @selected_tile.object.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)
+            MELEE_COLOR
+          else
+            MOVE_COLOR
+          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?
+            Tile.blank.draw_rot tile.x, tile.y, 0, 0, 0.5, 0.5, 0.2, 0.2, ZOC_COLOR
+          end
+        end
+      end
+    end
+  end
+
+  def modify_occlusions(tiles, amount)
+    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
+
+      # Highlight all squares that character can travel to.
+      @moves_record.draw 0, 0, ZOrder::TILE_SELECTION if @moves_record
+      @path.draw if @path
+
+    elsif @hover_tile
+      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
+  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
+      end
+    elsif @hover_tile and @hover_tile.object.is_a? Objects::Entity and @hover_tile.object.active?
+      # Select a character to move.
+      select(@hover_tile.object)
+    end
+  end
+
+  def select(entity)
+    if entity
+      @selected_tile = entity.tile
+      @moves_record = nil
+      calculate_potential_moves
+    else
+      modify_occlusions @potential_moves, -1
+      @potential_moves.clear
+
+      modify_occlusions @path.tiles, -1 if @path
+      @path = nil
+
+      @selected_tile = nil
+    end
+  end
+
+  def right_click
+    # Deselect the currently selected character.
+    if @selected_tile
+      select nil
+    end
+  end
+end
+end

data/lib/smash_and_grab/objects/entity.rb

@@ -0,0 +1,359 @@
+require 'set'
+require_relative "../path"
+require_relative "../abilities"
+require_relative "world_object"
+require_relative "floating_text"
+
+module SmashAndGrab
+module Objects
+class Entity < WorldObject
+  extend Forwardable
+
+  CLASS = :entity
+
+  SPRITE_WIDTH, SPRITE_HEIGHT = 66, 66
+  PORTRAIT_WIDTH, PORTRAIT_HEIGHT = 36, 36
+
+  MELEE_COST = 1
+  MELEE_DAMAGE = 5
+
+  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
+
+  attr_writer :movement_points, :action_points
+
+  alias_method :max_mp, :max_movement_points
+  alias_method :max_ap, :max_action_points
+
+  alias_method :mp, :movement_points
+  alias_method :ap, :action_points
+
+  alias_method :mp=, :movement_points=
+  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 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]]
+
+    @faction = map.send(config[:faction])
+
+    options = {
+        image: self.class.sprites[*config[:spritesheet_position]],
+        factor_x: data[:facing].to_sym == :right ? 1 : -1,
+    }
+
+    @portrait = self.class.portraits[*config[:spritesheet_position]]
+
+    super(map, data, options)
+
+    raise @type unless image
+
+    @max_movement_points = config[:movement_points]
+    @movement_points = data[:movement_points] || @max_movement_points
+
+    @max_action_points = config[:action_points]
+    @action_points = data[:action_points] || @max_action_points
+
+    @max_health = config[:health]
+    @health = data[:health] || @max_health
+
+    # Load other abilities of the entity from config.
+    @abilities = {}
+
+    # Everyone who has movement_points has the ability to move, without it needing to be explicit.
+    @abilities[:move] = Abilities.ability(self, type: :move) if max_movement_points > 0
+
+    if config[:abilities]
+      config[:abilities].each do |ability_data|
+        ability_data = ability_data
+        @abilities[ability_data[:type]] = Abilities.ability(self, ability_data)
+      end
+    end
+
+    @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
+
+    # Show damage/healing as a floating number.
+    if original_health != @health
+      text, color = if @health > original_health
+                      ["+#{@health - original_health}", Color::GREEN]
+                    else
+                      [(@health - original_health).to_s, Color::RED]
+                    end
+
+      FloatingText.new(text, color: color, x: x, y: y - height / 3, zorder: y - 0.01)
+    end
+
+    if @health == 0 and @tile
+      self.tile = nil
+    end
+  end
+
+  def melee(other)
+    other.health -= MELEE_DAMAGE
+    @action_points -= MELEE_COST
+  end
+
+  def start_turn
+    @movement_points = @max_movement_points
+    @action_points = @max_action_points
+  end
+
+  def end_turn
+    # Do something?
+  end
+
+  def draw
+    super() if alive?
+  end
+
+  def friend?(character); @faction.friend? character.faction; end
+  def enemy?(character); @faction.enemy? character.faction; end
+
+  def exerts_zoc?; true; end
+  def action?; @action_points > 0; end
+  def move?; @movement_points > 0; end
+  def end_turn_on?(person); false; end
+  def impassable?(character); enemy? character; end
+  def passable?(character); friend? character; end
+
+  def destroy
+    @faction.remove self
+    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) }
+
+    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
+            if old_path = open_paths[testing_tile]
+              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 }.
+
+    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 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.
+        if old_path = open_paths[testing_tile]
+          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
+
+  # Actually perform movement (called from GameAction::Move).
+  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
+
+    # Turn based on movement.
+    self.factor_x = change_in_x > 0 ? 1 : -1
+
+    self.tile = destination
+  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)
+    enemies.each do |enemy|
+      map.actions.do :ability, :melee, enemy, self # Only get one opportunity attack per enemy entering.
+    end
+  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
+        end
+      end
+    else
+      # 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
+          x1 += step_x
+        else
+          error += dx
+          y1 += step_y
+        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
+        end
+      end
+    end
+
+    nil # Didn't hit anything.
+  end
+
+  def to_json(*a)
+    data = {
+        class: CLASS,
+        type: @type,
+        id: id,
+        health: @health,
+        movement_points: @movement_points,
+        action_points: @action_points,
+        facing: factor_x > 0 ? :right : :left,
+    }
+
+    data[:tile] = grid_position if @tile
+
+    data.to_json(*a)
+  end
+end
+end
+end

data/lib/smash_and_grab/objects/floating_text.rb

@@ -0,0 +1,27 @@
+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 = {})
+    super(options)
+
+    @final_y = y - 60
+    @text = text
+    @font = Font[FONT_NAME, FONT_SIZE]
+
+    parent.map.add_effect self
+  end
+
+  def update
+    self.y -= 1 # TODO: scale this with FPS.
+    parent.map.remove_effect(self) if y < @final_y
+  end
+
+  def draw
+    @font.draw_rel @text, x, y, zorder, 0.5, 0.5, 1, 1, color
+  end
+end
+end
+end