empi 0.17 → 0.22.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) 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)
+  end
+
+  # Set desired function and possibly also project
+  def set_function!(func)
+    super
+
+    if @faction != 0 and func == FUNCBUILD # neutral towns don't need projects
+      # 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/{unit.rb → lib/units/unit.rb}

@@ -1,9 +1,12 @@
 require_relative './unitFunction'
 
-# All capturable game pieces
+# Both capturable and movable game pieces
 class Unit
-  attr_accessor :x, :y, :faction, :function, :cargo
+  class << self
+    attr_reader :name, :map_symbol, :price, :value
+  end
 
+  attr_accessor :x, :y, :faction, :function, :cargo, :cargo_max
 
   def initialize(x, y, faction, map, infopane)
     @x = x
@@ -12,17 +15,13 @@ class Unit
     @map = map
     @infopane = infopane
 
-    @name = 'unit'
-    @value = 1
     @armor_max = 1
     @armor_left = @armor_max
     @moves_max = 1
     @moves_left = @moves_max
     @cargo = [] # transported units
     @cargo_max = 0
-    @function = UnitFunction.new(FUNCNONE)
-
-
+    @function = UnitFunction.new(FUNCNONE, self)
 
     # Store yourself
     coords_unit = @map.get_unit(@x, @y)
@@ -33,75 +32,68 @@ class Unit
     end
   end
 
-  # Add <value> to the other faction
-  def destroy
-    @infopane.add_score(3 - @faction - 1, @value) # TODO more factions?
-    # TODO is this deleted enough?
-    @map.set_unit(@x, @y, nil)
-  end
-
-  def capture(by_whom)
-    # add <value> to the capturing faction
-    @infopane.add_score(by_whom - 1, @value)
-    @faction = by_whom
+  # 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
 
-    # if you are a town, start building units
-    if can_build?
-      set_function(FUNCBUILD)
+    # 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
 
-  def update(key)
-    old_x = @x
-    old_y = @y
-
-    case key
-    # Cardinal directions
-    when Gosu::KbLeft, Gosu::KbA then
-      @x -= 1 unless @x <= 0
-    when Gosu::KbRight, Gosu::KbD then
-      @x += 1 unless @x >= MAPX
-    when Gosu::KbUp, Gosu::KbW then
-      @y -= 1 unless @y <= 0
-    when Gosu::KbDown, Gosu::KbX then
-      @y += 1 unless @y >= MAPY
-
-    # Intercardinal directions
-    when Gosu::KbQ then
-      unless @x <= 0 || @y <= 0
-        @x -= 1
-        @y -= 1
-      end
-    when Gosu::KbE then
-      unless @x >= MAPX || @y <= 0
-        @x += 1
-        @y -= 1
-      end
-    when Gosu::KbZ then
-      unless @x <= 0 || @y >= MAPY
-        @x -= 1
-        @y += 1
-      end
-    when Gosu::KbC then
-      unless @x >= MAPX || @y >= MAPY
-        @x += 1
-        @y += 1
-      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
 
-    # Functions
-    when Gosu::KbS then
-      set_function(FUNCSENTRY)
-    when Gosu::KbB then
-      set_function(FUNCBUILD)
+  # Process capture targeted at this unit
+  def capture!(by_whom)
+    unless can_be_captured?
+      abort("unit.capture!(): This unit can\'t be captured")
     end
 
-    check_movement(old_x, old_y)
+    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!
+    # 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
 
-  # Processes move of unit and takes care of its (un)loading or attack
+  # 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
+    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
@@ -109,65 +101,61 @@ class Unit
       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
+      # 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 
+        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 == nil
+        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
+        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 # newcoords_unit.can_full?; has to be full then
-              puts PROMPT + newcoords_unit.to_s + ' is already full'
-            end
+        # 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
-            # Can it be captured?
-            if newcoords_unit.can_be_captured?
-              if can_capture? # then capture it if you can
-                puts PROMPT + to_s + ' is capturing ' + newcoords_unit.to_s
-                newcoords_unit.capture(@faction)
-              else
-                puts PROMPT + to_s + ' can\'t capture other units'
-              end 
-            else # then battle it
-              puts PROMPT + to_s + ' is battling ' + newcoords_unit.to_s
-              newcoords_unit.destroy # TODO randomized combat
+            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      
+          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 tile_check == true
+      unless is_terrain_suitable?
         puts PROMPT + to_s + " found itself in a bad place"
-        destroy
+        destroy!
       end
     end
   end
@@ -198,6 +186,10 @@ class Unit
     false
   end
 
+  def can_be_built?
+    self.class.price > 0
+  end
+
   def can_transport?
     @cargo_max > 0
   end
@@ -223,7 +215,7 @@ class Unit
   end
 
   # Checks if unit is on the right type of terrain (not for transported units)
-  def tile_check
+  def is_terrain_suitable?
     unless is_transported?
       case @map.tile(@x, @y).terrain
       when TILE_SEA
@@ -239,14 +231,19 @@ class Unit
     @function.func
   end
 
-  def set_function(func)
-    unless @faction == 0 # neutral faction doesn't need functions
-      if (func == FUNCBUILD && !can_build?)
+  # Set desired function
+  def set_function!(func)
+    if @faction == 0
+      puts PROMPT + to_s + ": neutral towns can't have functions set"
+    else
+      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 has already been set to #{@function.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}"
@@ -255,27 +252,27 @@ class Unit
   end
 
   def function!
-    ret = @function.func!(@x, @y, @map, @infopane)
+    ret = @function.func!(@map, @infopane)
     puts to_s + ret
   end
 
   # Set short info string: type, faction, coordinates
   def to_s
-    "#{@name} (FAC#{@faction} #{@x}-#{@y})"
+    "#{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 can_move?
+
+    if @moves_max > 0
       ret = ret + ", moves #{@moves_left}/#{@moves_max}"
     end
 
-    ret = ret + ", func #{@function.func}"
+    ret = ret + ", #{@function.info}"
 
-    if @cargo.size > 0
-      ret = ret + ", transports #{@cargo.size}/#{@cargo_max} units"
+    if @cargo_max > 0
+      ret = ret + ", cargo #{@cargo.size}/#{@cargo_max}"
     end
 
     ret

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