smash_and_grab 0.0.5alpha → 0.0.6alpha

data/lib/smash_and_grab.rb

@@ -43,6 +43,10 @@ TEXT
         options[:dev] = true
       end
 
+      parser.on('--fullscreen', "Run fullscreen at native resolution") do
+        options[:fullscreen] = true
+      end
+
       parser.on('--console', 'Console mode (no log file)') do
         options[:log] = nil # Write to console.
       end
@@ -75,6 +79,7 @@ TEXT
     options[:log] = DEFAULT_LOG_FILE_PATH
   end
 
+  FULLSCREEN = options[:fullscreen]
   LOG_FILE = options[:log]
   DEVELOPMENT_MODE = options[:dev]
 

data/lib/smash_and_grab/abilities.rb

@@ -1,4 +1,4 @@
-require_folder "abilities", %w[area melee move ranged sprint]
+require_folder "abilities", %w[area drop melee move pick_up ranged sprint]
 
 module SmashAndGrab::Abilities
   # Create an ability based on class name.

data/lib/smash_and_grab/abilities/ability.rb

@@ -2,14 +2,20 @@ module SmashAndGrab::Abilities
   # @abstract
   class Ability
     attr_reader :skill, :owner
+    NON_SKILL = 0
     SKILL_LEVEL_DESCRIPTIONS = %w[Fair Good Excellent Heroic Legendary]
 
+    def use?; true; end
     def can_be_undone?; true; end
     def action_cost; @action_cost == :all ? owner.max_action_points : @action_cost; end
     def type; Inflector.underscore(Inflector.demodulize(self.class.name)).to_sym; end
 
     def tip
-      "#{SKILL_LEVEL_DESCRIPTIONS[skill - 1]} #{type.capitalize} (#{'*' * skill})"
+      if skill > NON_SKILL
+       "#{SKILL_LEVEL_DESCRIPTIONS[skill - 1]} #{type.capitalize} (#{'*' * skill})"
+      else
+        type.capitalize
+      end
     end
 
     protected
@@ -23,11 +29,15 @@ module SmashAndGrab::Abilities
     public
     # Data saved with the character.
     def to_json(*a)
+      to_hash.to_json(*a)
+    end
+
+    def to_hash
       {
           type: type,
           skill: skill,
           action_cost: @action_cost,
-      }.to_json(*a)
+      }
     end
 
     public
@@ -57,6 +67,8 @@ module SmashAndGrab::Abilities
   # Ability that has an effect every turn.
   # @abstract
   class ContinuousAbility < Ability
+    def active?; @active; end
+
     def initialize(owner, data)
       @active = data[:active]
       super(owner, data)
@@ -74,9 +86,36 @@ module SmashAndGrab::Abilities
   # An ability that has an effect, but the player can turn it on and off. e.g. Invisibility.
   # @abstract
   class ToggleAbility < ContinuousAbility
+    def activate?; owner.action_points >= action_cost and not active?; end
+    def deactivate?; owner.movement_points >= movement_bonus and active?; end
+
     def initialize(owner, data)
       super(owner, { active: false }.merge!(data))
     end
+
+    def do(data)
+      if active?
+        deactivate data
+      else
+        activate data
+      end
+    end
+
+    def undo(data)
+      self.do data # Effect is based on current state, not on whether it is done or undone.
+    end
+
+    protected
+    def activate(data)
+      owner.action_points -= action_cost
+      @active = true
+    end
+
+    protected
+    def deactivate(data)
+      owner.action_points += action_cost
+      @active = false
+    end
   end
 
   # Ability that can be activated, but only on oneself.
@@ -97,10 +136,13 @@ module SmashAndGrab::Abilities
           target_position: target_tile.grid_position
       )
     end
+
+    protected
+    def target(data); owner.map.object_by_id(data[:target_id]); end
   end
 
   # An ability that requires that the actor be adjacent to the target
-  # and will move them if necessary. E.g. Melee.
+  # and will move them if necessary. E.g. Melee or PickUp.
   # @abstract
   class TouchAbility < TargetedAbility
   end

data/lib/smash_and_grab/abilities/drop.rb

@@ -0,0 +1,38 @@
+require_relative "ability"
+
+# Pick up an object from the ground
+module SmashAndGrab::Abilities
+  class Drop < TargetedAbility
+    def can_be_undone?; true; end
+    def use?; !owner.contents.nil? and owner.tile.adjacent_tiles(owner).any?(&:empty?); end
+
+    def tip
+      "#{super} #{owner.contents ? owner.contents.name : "something" }"
+    end
+
+    def initialize(owner, data)
+      super(owner, data.merge(action_cost: 1, skill: NON_SKILL))
+    end
+
+    def action_data
+      # TODO: find a way to get a specific position.
+      target_tile = owner.tile.adjacent_tiles(owner).find_all(&:empty?).sample
+
+      super(target_tile).merge(
+          target_id: owner.contents.id
+      )
+    end
+
+    def do(data)
+      super(data)
+
+      owner.drop owner.map.tile_at_grid(*data[:target_position])
+    end
+
+    def undo(data)
+      owner.pick_up target(data)
+
+      super(data)
+    end
+  end
+end

data/lib/smash_and_grab/abilities/melee.rb

@@ -21,23 +21,21 @@ module SmashAndGrab::Abilities
       )
     end
 
-    def target(data); owner.map.object_by_id(data[:target_id]); end
-
     def random_damage
-      # 1..skill as damage in a bell-ish curve.
-      (skill - 1).times.find_all { rand(2) == 1 }.size + 1
+      # 0..skill as damage in a bell-ish curve.
+      skill.times.find_all { rand(6) + 1 <= 3 }.size # 3 potential hits on each d6.
     end
 
     def do(data)
       super(data)
 
-      owner.melee(target(data), data[:damage])
+      owner.make_melee_attack(target(data), data[:damage])
     end
 
     def undo(data)
       target = target(data)
       target.tile = owner.map.tile_at_grid(data[:target_position]) unless target.tile
-      owner.melee(target(data), -data[:damage])
+      owner.make_melee_attack(target(data), -data[:damage])
 
       super(data)
     end

data/lib/smash_and_grab/abilities/pick_up.rb

@@ -0,0 +1,33 @@
+require_relative "ability"
+
+# Pick up an object from the ground
+module SmashAndGrab::Abilities
+  class PickUp < TouchAbility
+    def can_be_undone?; true; end
+
+    def tip
+      raise "n/a"
+    end
+
+    def initialize(owner, data)
+      super(owner, data.merge(action_cost: 1, skill: NON_SKILL))
+    end
+
+    def action_data(object)
+      super(object.tile).merge({
+      })
+    end
+
+    def do(data)
+      super(data)
+
+      owner.pick_up target(data)
+    end
+
+    def undo(data)
+      owner.drop owner.map.tile_at_grid(*data[:target_position])
+
+      super(data)
+    end
+  end
+end

data/lib/smash_and_grab/abilities/ranged.rb

@@ -4,49 +4,55 @@ module SmashAndGrab::Abilities
   class Ranged < TargetedAbility
     attr_reader :min_range, :max_range
 
-    def can_undo?; false; end
+    def can_be_undone?; false; end
 
     # TODO: Take into account min/max range and LOS.
     def target_valid?(tile); !!(tile.object.is_a?(Objects::Entity) and tile.object.enemy?(owner)); end
 
     def initialize(owner, data)
-      super(owner, data.merge(action_cost: 1))
+      data = {
+          action_cost: 1,
+          min_range: 2 # Can't fire at adjacent (melee) squares.
+      }.merge data
+
+      @min_range = data[:min_range]
       @max_range = data[:max_range] || raise(ArgumentError, "no :max_range specified")
-      @min_range = data[:min_range] || raise(ArgumentError, "no :min_range specified")
+
+      super(owner, data)
     end
 
     def tip
       "#{super} attack in ranged combat, at range #{min_range}..#{max_range}"
     end
 
-    def to_json(*args)
+    def to_hash
       super.merge(
           min_range: @min_range,
           max_range: @max_range,
-      ).to_json(*args)
+      )
     end
 
-    def action_data(target_tile)
-      super(target_tile).merge!(
+    def action_data(target)
+      super(target.tile).merge!(
           damage: random_damage
       )
     end
 
     def random_damage
-      # 1..skill as damage in a bell-ish curve.
-      (skill - 1).times.find_all { rand(2) == 1 }.size + 1
+      # 0..skill as damage in a bell-ish curve.
+      skill.times.find_all { rand(6) + 1 <= 2 }.size # 2 potential hits on each d6.
     end
 
     def do(data)
       super(data)
 
-      owner.map.object_by_id(data[:target_id]).health -= data[:damage]
+      owner.make_ranged_attack(target(data), data[:damage])
     end
 
     def undo(data)
-      target = owner.map.object_by_id(data[:target_id])
-      target.health += data[:damage]
+      target = target(data)
       target.tile = owner.map.tile_at_grid(data[:target_position]) unless target.tile
+      owner.make_ranged_attack(target(data), -data[:damage])
 
       super(data)
     end

data/lib/smash_and_grab/abilities/sprint.rb

@@ -1,9 +1,13 @@
 require_relative "ability"
 
 module SmashAndGrab::Abilities
-  class Sprint < SelfAbility
+  class Sprint < ToggleAbility
     def initialize(owner, data)
       super(owner, data.merge(action_cost: :all))
+
+      owner.subscribe :ended_turn do
+        @active = false
+      end
     end
 
     def movement_bonus
@@ -31,16 +35,16 @@ module SmashAndGrab::Abilities
       )
     end
 
-    def do(data)
-      super(data)
-
+    protected
+    def activate(data)
+      super
       owner.movement_points += data[:movement_bonus]
     end
 
-    def undo(data)
+    protected
+    def deactivate(data)
+      super
       owner.movement_points -= data[:movement_bonus]
-
-      super(data)
     end
   end
 end

data/lib/smash_and_grab/chingu_ext/basic_game_object.rb

@@ -0,0 +1,26 @@
+module Chingu
+  class BasicGameObject
+    def initialize(options = {})
+      @options = options
+      @parent = options[:parent]
+
+      # SMASH_AND_GRAB PATCH: Do not want to store this at all.
+      #self.class.instances ||= Array.new
+      #self.class.instances << self
+
+      #
+      # A GameObject either belong to a GameState or our mainwindow ($window)
+      #
+      @parent = $window.current_scope if !@parent && $window
+
+      # if true, BasicGameObject#update will be called
+      @paused = options[:paused] || options[:pause] || false
+
+      # This will call #setup_trait on the latest trait mixed in
+      # which then will pass it on to the next setup_trait() with a super-call.
+      setup_trait(options)
+
+      setup
+    end
+  end
+end

data/lib/smash_and_grab/game_window.rb

@@ -3,7 +3,11 @@ class GameWindow < Chingu::Window
   attr_reader :pixel
 
   def initialize
-    super(800, 600, false)
+    if FULLSCREEN
+      super(screen_width, screen_height, true)
+    else
+      super(800, 600, false)
+    end
   end
 
   def setup

data/lib/smash_and_grab/gui/entity_panel.rb

@@ -1,6 +1,8 @@
 module SmashAndGrab
   module Gui
     class EntityPanel < Fidgit::Horizontal
+      TITLE_COLOR = Color.rgb(150, 150, 150)
+
       event :info_toggled
 
       def initialize(entity, info_shown, options = {})
@@ -25,8 +27,9 @@ module SmashAndGrab
           end
         end
 
-        vertical padding: 0, spacing: 4 do
-          @name = label @entity.name
+        vertical padding: 0, spacing: 1.5 do
+          @name = label @entity.name, font_height: 20, color: Color::WHITE
+          label TITLE_COLOR.colorize("#{entity.title} - #{@entity.faction.colorized_name}"), font_height: 12
           @sub_panel_container = vertical spacing: 0, padding: 0
         end
 
@@ -36,7 +39,11 @@ module SmashAndGrab
 
         update_details @entity
 
-        @entity.subscribe :changed, method(:update_details)
+        @changed_event = @entity.subscribe :changed, method(:update_details)
+      end
+
+      def finalize
+        @changed_event.unsubscribe
       end
 
       def switch_sub_panel
@@ -47,9 +54,9 @@ module SmashAndGrab
       def create_info_sub_panel
         @info_sub_panel = Fidgit::Vertical.new padding: 0, spacing: 0 do
           text = nil
-          scroll = scroll_window width: 350, height: 72 do
+          scroll = scroll_window width: 350, height: 68 do
             text = text_area text: "#{@entity.name} once ate a pomegranate, but it took all day and all night... " * 5,
-                                  width: 330, font_height: 14, enabled: false
+                                  width: 330, font_height: 14, editable: false
           end
           scroll.background_color = text.background_color
         end
@@ -70,20 +77,22 @@ module SmashAndGrab
 
             label_options = button_options.merge border_thickness: 2, border_color: Color.rgba(255, 255, 255, 100)
 
-            [:melee, :ranged, :sprint].each do |ability_name|
+            [:melee, :ranged, :sprint, :drop].each do |ability_name|
               if @entity.has_ability? ability_name
                 ability = @entity.ability ability_name
                 @ability_buttons[ability_name] = button("#{ability_name.to_s[0].upcase}#{ability.skill}",
                                                         button_options.merge(tip: ability.tip)) do
 
-                  @entity.use_ability :sprint if ability_name == :sprint
+                  if ability_name == :sprint or ability_name == :drop
+                    @entity.use_ability ability_name
+                  end
                 end
               else
                 label "", label_options
               end
             end
 
-            5.times do |i|
+            4.times do |i|
                label "", label_options
             end
           end
@@ -91,7 +100,9 @@ module SmashAndGrab
       end
 
       def update_details(entity)
-        @health.text = "HP: #{entity.health} / #{entity.max_health}"
+        return unless entity.faction.player
+
+        @health.text = "HP: #{entity.hp} / #{entity.max_hp}"
         @movement_points.text = "MP: #{entity.mp} / #{entity.max_mp}"
         @action_points.text = "AP: #{entity.ap} / #{entity.max_ap}"
 
@@ -100,7 +111,12 @@ module SmashAndGrab
         end
 
         @ability_buttons.each do |ability, button|
-          button.enabled = (entity.active? and (entity.has_ability?(ability) and entity.action_points >= entity.ability(ability).action_cost))
+          button.enabled = entity.active? && entity.faction.player.human? && entity.use_ability?(ability)
+
+          # TODO: this should be more sensible (allows un-sprinting).
+          if ability == :sprint && entity.active? && entity.faction.player.human? && entity.ability(ability).deactivate?
+            button.enabled = true
+          end
         end
 
         @portrait.image = entity.image