empi 0.19 → 0.24

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

@@ -1,14 +1,17 @@
 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
+    @armour_left = @armour_max = 3
     @moves_max = 5
   end
 

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

@@ -1,14 +1,17 @@
 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
+    @armour_left = @armour_max = 1
     @moves_max = 2
     @cargo_max = 3
   end

data/lib/lib/units/town.rb

@@ -0,0 +1,108 @@
+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')
+
+    @armour_left = @armour_max = 1
+    @moves_max = 0
+    @cargo_max = 10
+
+    @starting_project = Army unless @faction == 0 # used once at the game start
+    @default_project = Army # used after capture
+    @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
+    # 1) remove old project so that it is not disclosed
+    # 2) set default project so that there is always some set (remove old parts)
+    # 3) offer change of the project to the new owner
+    @function.func = FUNCNONE
+    @project = nil
+    set_project!(@default_project)
+    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)"
+      if previous_project and lost_parts > 0 # parts were lost but not due to capture
+        puts new_project_set_text + ", losing #{lost_parts} " +
+          "part#{ 's' unless lost_parts == 1 } of #{previous_project.name}"
+      else
+        puts new_project_set_text
+      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,10 +1,13 @@
 require_relative './unitFunction'
 
-PARTS_TO_BE_BUILT = 0
-
 # 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_reader :armour_left
+  attr_accessor :x, :y, :faction, :function, :cargo, :cargo_max
 
   def initialize(x, y, faction, map, infopane)
     @x = x
@@ -13,10 +16,8 @@ class Unit
     @map = map
     @infopane = infopane
 
-    @name = 'unit'
-    @value = 1
-    @armor_max = 1
-    @armor_left = @armor_max
+    @armour_max = 1
+    @armour_left = @armour_max
     @moves_max = 1
     @moves_left = @moves_max
     @cargo = [] # transported units
@@ -72,16 +73,18 @@ class Unit
     end
 
     # Add <value> to the capturing faction
-    @infopane.add_score(by_whom - 1, @value)
+    @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!
+    @armour_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, @value) # TODO more factions?
+    @infopane.add_score(3 - @faction - 1, self.class.value) # TODO more factions?
 
     if is_transported?
       coords_unit = @map.get_unit(@x, @y)
@@ -101,10 +104,11 @@ 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
@@ -115,35 +119,39 @@ class Unit
         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_transport?; has to be full then
+        # 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
-          else
-            # Enemy!
-            newcoords_unit.engage!(self)
           end
+        else
+          # Enemy!
+          newcoords_unit.engage!(self)
+        end
       end
       @moves_left -= 1
 
@@ -155,12 +163,17 @@ class Unit
     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
@@ -182,7 +195,7 @@ class Unit
   end
 
   def can_be_built?
-    PARTS_TO_BE_BUILT > 0
+    self.class.price > 0
   end
 
   def can_transport?
@@ -227,19 +240,31 @@ class Unit
   end
 
   # Set desired function
-  def set_function!(func)
-    unless @faction == 0 # neutral towns dom't need functions
-      if func == FUNCBUILD and !can_build?
-        puts PROMPT + to_s + ": this unit can't build other units"
-        return
-      end
+  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
 
-      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
+    # 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
 
@@ -250,12 +275,12 @@ class Unit
 
   # 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
+  # Set long info string: short info string, armour, moves, function, cargo
   def info
-    ret = to_s + ": armor #{@armor_left}/#{@armor_max}"
+    ret = to_s + ": armour #{@armour_left}/#{@armour_max}"
 
     if @moves_max > 0
       ret = ret + ", moves #{@moves_left}/#{@moves_max}"

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

@@ -12,26 +12,31 @@ class UnitFunction
     when FUNCNONE
       "no function"
     when FUNCBUILD
-      "building #{@unit.project} (#{@unit.build_info})"
+      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)
-    ret = " didn't actually do anything (ERROR)"
-
     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} (#{@unit.build_info} done)"
+        ret = " built next part of #{@unit.project.name} (#{@unit.build_info} done)"
       else
-        ret = " completed building of #{@unit.project}"
+        ret = " completed building of #{@unit.project.name}"
         @unit.parts_built = 0
-        Army.new(@unit.x, @unit.y, @unit.faction, map, infopane)
+        @unit.project.new(@unit.x, @unit.y, @unit.faction, map, infopane)
       end
 
     # Wake when enemies are nearby
@@ -49,6 +54,10 @@ class UnitFunction
       end
     end
 
+    unless ret
+      abort("unitFunction.func!(): Functionable unit didn't function (" + @unit.to_s + ")")
+    end
+
     ret
   end
 end

data/lib/lib/user_interface/cursor.rb

@@ -0,0 +1,190 @@
+class Cursor
+  attr_accessor :freeroam, :info_stopped
+
+  def initialize(x, y, map, infopane)
+    dir_path = File.dirname(__FILE__)
+
+    @x = x
+    @y = y
+    @map = map
+    @infopane = infopane
+
+    @image = Gosu::Image.new(dir_path + '/../../media/cursor.png')
+    @freeroam = false
+    @info_stopped = false
+
+    # Give to Infopane link to yourself (for freeroam marker)
+    if !@infopane
+      abort("Cursor.initialize!(): Infopane is not set")
+    end
+    @infopane.cursor = self
+  end
+
+  def update(button)
+    case button
+    # Cardinal directions
+    when Gosu::KbLeft, Gosu::KbA, Gosu::KB_NUMPAD_4 then
+      move!(-1, 0) unless @x <= 0
+    when Gosu::KbRight, Gosu::KbD, Gosu::KB_NUMPAD_6 then
+      move!(1, 0) unless @x >= MAPX
+    when Gosu::KbUp, Gosu::KbW, Gosu::KB_NUMPAD_8 then
+      move!(0, -1) unless @y <= 0
+    when Gosu::KbDown, Gosu::KbX, Gosu::KB_NUMPAD_2 then
+      move!(0, 1) unless @y >= MAPY
+
+    # Intercardinal directions
+    when Gosu::KbQ, Gosu::KB_NUMPAD_7 then
+      move!(-1, -1) unless @x <= 0 || @y <= 0
+    when Gosu::KbE, Gosu::KB_NUMPAD_9 then
+      move!(1, -1) unless @x >= MAPX || @y <= 0
+    when Gosu::KbZ, Gosu::KB_NUMPAD_1 then
+      move!(-1, 1) unless @x <= 0 || @y >= MAPY
+    when Gosu::KbC, Gosu::KB_NUMPAD_3 then
+      move!(1, 1) unless @x >= MAPX || @y >= MAPY
+
+    # Functions
+    when Gosu::KbS then
+      set_function_to_unit(FUNCSENTRY)
+    when Gosu::KbB then
+      set_function_to_unit(FUNCBUILD)
+    when Gosu::KbN then
+      set_function_to_unit(FUNCNONE)
+
+    # The rest
+    when Gosu::KbJ, Gosu::KB_NUMPAD_0 then
+      switch_freeroam!
+    when Gosu::KbReturn, Gosu::KB_NUMPAD_5 then
+      info
+    end
+
+    # If in locked mode, stay at current/jump to next movable unit
+    to_next_unit! unless @freeroam
+  end
+
+  def draw
+    @image.draw(@x * TILESIZE, (@y + 1) * TILESIZE, ZCURSOR)
+  end
+
+  # Move to coordinates of unit the cursor is locked to
+  def warp_to_locked!()
+    @x = @locked_to.x
+    @y = @locked_to.y
+    @local_unit = @locked_to
+  end
+
+  # Move by given change of coordinates
+  def move!(xx, yy)
+    if freeroam
+      @x += xx
+      @y += yy
+      @local_unit = @map.get_unit(@x, @y)
+      # TODO show some basic tile info in infopane
+    else
+      check_unit
+
+      # Move the unit first
+      @locked_to.x += xx
+      @locked_to.y += yy
+      @locked_to.check_movement(@x, @y) # cursor coordinates work like old_x, old_y
+
+      # Is the unit still alive?
+      if @locked_to.armour_left > 0
+        warp_to_locked! # whether it moved or not
+      else
+        # It got destroyed so clear last links then so that (object of)
+        # given unit can be truly destroyed
+        @local_unit = nil
+        @locked_to = nil
+      end
+    end
+  end
+
+  # Tries to set function <func> to local unit
+  def set_function_to_unit(func)
+    check_unit
+
+    if @local_unit
+      @local_unit.set_function!(func, @infopane.faction)
+
+      # Update infopane with the new (possibly changed) state
+      # (visible only in freeroam mode as in locked one the infopane is
+      # overwritten as cursor either jumps away or switches to freeroam mode)
+      @infopane.text = @local_unit.info
+    else
+      puts "no unit to set that function to (at #{@x}-#{@y})"
+    end
+  end
+
+  # Reset to locked mode
+  def reset!
+    @freeroam = true
+    switch_freeroam!
+    @local_unit = nil
+    @locked_to = nil
+    to_next_unit!
+  end
+
+  # Find next unit which is still waiting for commands and lock to it
+  # (local -> last locked to -> next waiting) or switch (back) to freeroaming
+  def to_next_unit!
+    if @local_unit and @local_unit.is_waiting_for_commands?
+      # Lock to such unit (though it may have already been locked)
+      @locked_to = @local_unit
+    else
+      unless @locked_to and @locked_to.is_waiting_for_commands?
+        waiting = @map.all_units.select { |uu| uu.is_waiting_for_commands? }
+
+        # Are there still some units of active faction waiting for commands?
+        if waiting.size <= 0 # == would be enough
+          puts 'all movable units without functions moved'
+          switch_freeroam!
+          return
+        end
+
+        @locked_to = waiting[0] # newly selected one
+      end
+    end
+
+    warp_to_locked! # stay at old or go to new
+    info unless @info_stopped # due to switching out of the play game state
+  end
+
+  # When cursor is in locked mode there needs to be a local unit it is locked to
+  # When cursor is in freeroam mode the local unit should still be loaded
+  def check_unit
+    if !@freeroam and !@local_unit
+      abort("cursor.set_function_to_unit(): Cursor is in locked mode " \
+            "but there is no unit it is locked to (at #{@x}-#{@y})")
+    end
+  end
+
+  # Switch between being attached to unit and being able to freeroam
+  def switch_freeroam!
+    if freeroam
+      @infopane.text = 'freeroam disabled'
+      puts 'freeroam disabled'
+      @freeroam = false
+    else
+      @infopane.text = 'freeroam enabled'
+      puts 'freeroam enabled'
+      @freeroam = true
+    end
+  end
+
+  # Find some info about units on the current tile
+  def info
+    check_unit
+
+    if @local_unit
+      @infopane.text = @local_unit.info
+      puts @local_unit.info
+
+      if @local_unit.is_transporting?
+        @local_unit.cargo.each { |uu| puts '- cargo: ' + uu.info }
+      end
+    else
+      @infopane.text = ''
+      puts "no unit to show info of (at #{@x}-#{@y})"
+    end
+  end
+end