empi 0.18 → 0.23

data/lib/{army.rb → lib/units/army.rb}

@@ -1,13 +1,16 @@
 require_relative './unit'
 
 class Army < Unit
+  @name = 'army'
+  @map_symbol = 'A'
+  @price = 3
+  @value = 5
+
   def initialize(x, y, faction, map, infopane)
     super
     dir_path = File.dirname(__FILE__)
-    @image = Gosu::Image.new(dir_path + '/media/army.png')
+    @image = Gosu::Image.new(dir_path + '/../../media/army.png')
 
-    @name = 'army'
-    @value = 5
     @armor_left = @armor_max = 3
     @moves_max = 5
   end

data/lib/{ship.rb → lib/units/ship.rb}

@@ -1,13 +1,16 @@
 require_relative './unit'
 
 class Ship < Unit
+  @name = 'ship'
+  @map_symbol = 'S'
+  @price = 5
+  @value = 10
+
   def initialize(x, y, faction, map, infopane)
     super
     dir_path = File.dirname(__FILE__)
-    @image = Gosu::Image.new(dir_path + '/media/ship.png')
+    @image = Gosu::Image.new(dir_path + '/../../media/ship.png')
 
-    @name = 'ship'
-    @value = 10
     @armor_left = @armor_max = 1
     @moves_max = 2
     @cargo_max = 3

data/lib/lib/units/town.rb

@@ -0,0 +1,106 @@
+require_relative './army'
+require_relative './ship'
+require_relative './unit'
+
+require_relative './../game_states/game_state'
+require_relative './../game_states/build_state'
+
+class Town < Unit
+  @name = 'town'
+  @map_symbol = 'T'
+  @value = 20
+
+  attr_accessor :project, :parts_built, :parts_needed
+
+  def initialize(x, y, faction, map, infopane)
+    super
+    dir_path = File.dirname(__FILE__)
+    @image = Gosu::Image.new(dir_path + '/../../media/town.png')
+
+    @armor_left = @armor_max = 1
+    @moves_max = 0
+    @cargo_max = 10
+
+    @starting_project = Army unless @faction == 0
+    @project = nil
+    @parts_built = 0
+    @parts_needed = 0
+
+    set_function!(FUNCBUILD, @faction) unless @faction == 0
+  end
+
+  def can_build?
+    true
+  end
+
+  def can_be_captured?
+    true
+  end
+
+  # Tell the state of current build project
+  def build_info
+    "#{@parts_built}/#{@parts_needed}"
+  end
+
+  # Process capture targeted at this town and reset build process
+  def capture!(by_whom)
+    super
+
+    # Reset build process
+    @function.func = FUNCNONE
+    @project = nil
+    @parts_built = 0
+
+    set_function!(FUNCBUILD, @faction)
+  end
+
+  # Set desired function and possibly also project
+  def set_function!(func, commanding_faction)
+    super
+
+    if @faction != 0 and commanding_faction == @faction and func == FUNCBUILD
+      # Set starting project once or ask player about next project
+      if @starting_project
+         set_project!(@starting_project)
+         @starting_project = nil
+      else
+        GameState.switch!(BuildState.instance)
+        BuildState.instance.unit = self
+      end
+    end
+  end
+
+  # Set desired project
+  def set_project!(desired_project)
+    unless price_list.key?(desired_project)
+      abort("town.set_project!(): Unknown project (#{desired_project})")
+    end
+    @parts_needed = price_list[desired_project]
+
+    # Compare new setting with the old one
+    if desired_project == @project
+      puts PROMPT + to_s + ": project has already been set to #{@project.name} (#{build_info} done)"
+    else
+      previous_project = @project
+      @project = desired_project
+      lost_parts = @parts_built
+      @parts_built = 0
+
+      new_project_set_text = PROMPT + to_s + ": project set to #{@project.name} (#{build_info} done)"
+      unless lost_parts > 0
+        puts new_project_set_text
+      else
+        puts new_project_set_text + ", losing #{lost_parts} " +
+          "part#{ 's' unless lost_parts == 1 } of #{previous_project.name}"
+
+      end
+    end
+  end
+
+  # Load all prices
+  def price_list
+    prices = Hash[
+      [Army, Ship].collect { |ii| [ii, ii.price] } # TODO all subclasses of Unit which can_be_built?
+    ]
+  end
+end

data/lib/lib/units/unit.rb

@@ -0,0 +1,301 @@
+require_relative './unitFunction'
+
+# Both capturable and movable game pieces
+class Unit
+  class << self
+    attr_reader :name, :map_symbol, :price, :value
+  end
+
+  attr_reader :armor_left
+  attr_accessor :x, :y, :faction, :function, :cargo, :cargo_max
+
+  def initialize(x, y, faction, map, infopane)
+    @x = x
+    @y = y
+    @faction = faction
+    @map = map
+    @infopane = infopane
+
+    @armor_max = 1
+    @armor_left = @armor_max
+    @moves_max = 1
+    @moves_left = @moves_max
+    @cargo = [] # transported units
+    @cargo_max = 0
+    @function = UnitFunction.new(FUNCNONE, self)
+
+    # Store yourself
+    coords_unit = @map.get_unit(@x, @y)
+    if !coords_unit
+      @map.set_unit(@x, @y, self)
+    else # some town has just built you
+      coords_unit.cargo.insert(-1, self) # -1 = to the end
+    end
+  end
+
+  # Process engagement targeted at this unit
+  def engage!(by_whom)
+    if by_whom == @faction
+      abort("unit.engage!(): Engaging unit is of the same faction as this one (#{@faction})")
+    end
+
+    # Can it be captured and is it without defenders?
+    if can_be_captured?
+      if is_transporting?
+        cargo[0].attack!(by_whom)
+      else # then capture it if you can
+        if by_whom.can_capture?
+          puts PROMPT + by_whom.to_s + ' is capturing ' + to_s
+          capture!(by_whom.faction)
+        else
+          puts PROMPT + by_whom.to_s + ' can\'t capture other units'
+        end
+      end
+    else
+      attack!(by_whom) # uncapturable transporters can't get help from their cargo
+    end
+  end
+
+  # Process attack targeted at this unit
+  def attack!(by_whom)
+    puts PROMPT + by_whom.to_s + ' is attacking ' + to_s
+    destroy! # TODO proper combat
+  end
+
+  # Process capture targeted at this unit
+  def capture!(by_whom)
+    unless can_be_captured?
+      abort("unit.capture!(): This unit can\'t be captured")
+    end
+
+    if by_whom == @faction
+      abort("unit.capture!(): This unit already belongs to faction #{@faction}")
+    end
+
+    # Add <value> to the capturing faction
+    @infopane.add_score(by_whom - 1, self.class.value)
+    @faction = by_whom
+  end
+
+  # Add <value> to the other faction and remove links to given unit
+  def destroy!
+    @armor_left = 0 # for non-attack damage
+
+    # If you are transporting somebody, destroy them first
+    @cargo.each { |uu| uu.destroy! }
+
+    @infopane.add_score(3 - @faction - 1, self.class.value) # TODO more factions?
+
+    if is_transported?
+      coords_unit = @map.get_unit(@x, @y)
+      coords_unit.cargo -= [self]
+    else
+      @map.set_unit(@x, @y, nil)
+    end
+  end
+
+  # Process move of unit and take care of its (un)loading or start of engagement
+  def check_movement(old_x, old_y)
+    if @x != old_x || @y != old_y # only if it moved
+      if @moves_left <= 0
+        abort("unit.check_movement(): Moving unit does not have enough move points (#{@moves_left} moves)")
+      end
+
+      oldcoords_unit = @map.get_unit(old_x, old_y)
+      newcoords_unit = @map.get_unit(@x, @y)
+
+      # If there is nobody or is there friendly unit with some cargo space (and bigger cargo space)
+      if !newcoords_unit || \
+        (newcoords_unit.faction == @faction && \
+         newcoords_unit.can_transport? && \
+         @cargo_max < newcoords_unit.cargo_max && \
+         !newcoords_unit.is_full?)
+
+        # Leave old coordinates
+        if oldcoords_unit == self
+          @map.set_unit(old_x, old_y, nil)
+        else # if you have been transported
+          oldcoords_unit.cargo.delete(self)
+        end
+
+        # Get to new coordinates
+        if !newcoords_unit
+          @map.set_unit(@x, @y, self)
+          @cargo.each { |uu|
+            uu.x = @x
+            uu.y = @y
+          }
+
+        else # if you are going to be transported
+          newcoords_unit.cargo.insert(-1, self) # -1 = to the end
+          puts PROMPT + to_s + ' got loaded into '+ newcoords_unit.to_s
+          @moves_left = 1 unless newcoords_unit.can_build? # use all your left moves unless you are getting loaded into a town
+        end
+
+      else # if there already is somebody that can't transport you (enemy or full friend)
+        # Stay on your original tile
+        @x = old_x
+        @y = old_y
+
+        # If it was a friend unit
+        if newcoords_unit.faction == @faction
+          if !newcoords_unit.can_transport?
+            puts PROMPT + newcoords_unit.to_s + ' can\'t transport other units'
+          else
+            if @cargo_max >= newcoords_unit.cargo_max
+              puts PROMPT + "#{self.class.name} can\'t fit in #{newcoords_unit.class.name}"
+            else # thus newcoords_unit.is_full? is true
+              puts PROMPT + newcoords_unit.to_s + ' is already full'
+            end
+          end
+        else
+          # Enemy!
+          newcoords_unit.engage!(self)
+        end
+      end
+      @moves_left -= 1
+
+      # Check if you are on an invalid type of terrain (unless transported)
+      unless is_terrain_suitable?
+        puts PROMPT + to_s + " found itself in a bad place"
+        destroy!
+      end
+    end
+  end
+
+  def draw
+    @image.draw(@x * TILESIZE, (@y + 1) * TILESIZE, ZUNIT,
+                scale_x = 1, scale_y = 1, color = COLOUR[@faction])
+  end
+
+  def is_waiting_for_commands?
+    @faction == @infopane.faction and
+    function == FUNCNONE and
+    can_move?
+  end
+
+  def can_move?
+    (can_fly? || can_sail? || can_ride?) && @moves_left > 0
+  end
+
+  def can_fly?
+    false
+  end
+
+  def can_sail?
+    false
+  end
+
+  def can_ride?
+    false
+  end
+
+  def can_build?
+    false
+  end
+
+  def can_be_built?
+    self.class.price > 0
+  end
+
+  def can_transport?
+    @cargo_max > 0
+  end
+
+  def is_full?
+     @cargo.size >= @cargo_max # just == should be enough
+  end
+
+  def is_transporting?
+    @cargo.size > 0
+  end
+
+  def is_transported?
+    @map.get_unit(@x, @y) != self
+  end
+
+  def can_capture?
+    false
+  end
+
+  def can_be_captured?
+    false
+  end
+
+  # Checks if unit is on the right type of terrain (not for transported units)
+  def is_terrain_suitable?
+    unless is_transported?
+      case @map.tile(@x, @y).terrain
+      when TILE_SEA
+        return can_fly? || can_sail?
+      when TILE_GROUND
+        return can_fly? || can_ride?
+      end
+    end
+    true
+  end
+
+  def function
+    @function.func
+  end
+
+  # Set desired function
+  def set_function!(func, commanding_faction)
+    # Check your neutrality
+    if @faction == 0
+      puts PROMPT + to_s + ": neutral units can't have functions set"
+      return
+    end
+
+    # Check origin of command
+    if commanding_faction != @faction
+      puts PROMPT + to_s + ": this unit does not take commands from other factions"
+      return
+    end
+
+    # Check your abilities
+    if func == FUNCBUILD and !can_build?
+      puts PROMPT + to_s + ": this unit can't build other units"
+      return
+    end
+
+    # Check current function and set the new one
+    if @function.func == func
+      puts PROMPT + to_s + ": function is already set to #{@function.func}"
+    else
+      @function.func = func
+      puts PROMPT + to_s + ": function set to #{@function.func}"
+    end
+  end
+
+  def function!
+    ret = @function.func!(@map, @infopane)
+    puts to_s + ret
+  end
+
+  # Set short info string: type, faction, coordinates
+  def to_s
+    "#{self.class.name} (FAC#{@faction} #{@x}-#{@y})"
+  end
+
+  # Set long info string: short info string, armor, moves, function, cargo
+  def info
+    ret = to_s + ": armor #{@armor_left}/#{@armor_max}"
+
+    if @moves_max > 0
+      ret = ret + ", moves #{@moves_left}/#{@moves_max}"
+    end
+
+    ret = ret + ", #{@function.info}"
+
+    if @cargo_max > 0
+      ret = ret + ", cargo #{@cargo.size}/#{@cargo_max}"
+    end
+
+    ret
+  end
+
+  def reset_moves!
+    @moves_left = @moves_max
+  end
+end

data/lib/lib/units/unitFunction.rb

@@ -0,0 +1,63 @@
+class UnitFunction
+  attr_accessor :func
+
+  def initialize(function = FUNCNONE, unit)
+    @func = function
+    @unit = unit
+  end
+
+  # Set function part of long info string of unit
+  def info
+    case @func
+    when FUNCNONE
+      "no function"
+    when FUNCBUILD
+      unless @unit.project
+        abort("unitFunction.info(): No project set (" + @unit.to_s + ")")
+      end
+      "building #{@unit.project.name} (#{@unit.build_info})"
+    when FUNCSENTRY
+      "sentrying"
+    end
+  end
+
+  def func!(map, infopane)
+    case @func
+    # Build given unit
+    when FUNCBUILD
+      unless @unit.project
+        abort("unitFunction.func!(): No project set (" + @unit.to_s + ")")
+      end
+
+      @unit.parts_built += 1
+
+      unless @unit.parts_built >= @unit.parts_needed # just == should be enough
+        ret = " built next part of #{@unit.project.name} (#{@unit.build_info} done)"
+      else
+        ret = " completed building of #{@unit.project.name}"
+        @unit.parts_built = 0
+        @unit.project.new(@unit.x, @unit.y, @unit.faction, map, infopane)
+      end
+
+    # Wake when enemies are nearby
+    when FUNCSENTRY
+      units_around = map.all_units.select { |uu|
+        (uu.x - @unit.x).abs <= 1 &&
+        (uu.y - @unit.y).abs <= 1 &&
+        uu.faction != @unit.faction
+      }
+      if units_around.size > 0
+        ret = " woke up"
+        @func = FUNCNONE
+      else
+        ret = " was on sentry duty"
+      end
+    end
+
+    unless ret
+      abort("unitFunction.func!(): Functionable unit didn't function (" + @unit.to_s + ")")
+    end
+
+    ret
+  end
+end