empi 0.16.6

data/lib/army.rb

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

data/lib/cursor.rb

@@ -0,0 +1,99 @@
+class Cursor
+  attr_accessor :x, :y, :freeroam
+
+  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
+  end
+
+  def update(key)
+    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
+
+    # Functions
+    when Gosu::KbS then
+      uu = @map.get_unit(@x, @y)
+      if uu then uu.set_function(FUNCSENTRY) end
+    when Gosu::KbB then
+      uu = @map.get_unit(@x, @y)
+      if uu then uu.set_function(FUNCBUILD) end
+    when Gosu::KbN then
+      uu = @map.get_unit(@x, @y)
+      if uu then uu.set_function(FUNCNONE) end
+
+    when Gosu::KbReturn then
+      info
+    end
+  end
+
+  def draw
+    @image.draw(@x * TILESIZE, (@y + 1) * TILESIZE, ZCURSOR)
+  end
+
+  # Move to given coordinates
+  def warp(x, y)
+    @x = x
+    @y = y
+  end
+
+  # Switch between being attached to unit and being able to freeroam
+  def switch_freeroam
+    if freeroam == true
+      @infopane.text = 'freeroam disabled'
+      puts 'freeroam disabled'
+    else
+      @infopane.text = 'freeroam enabled'
+      puts 'freeroam enabled'
+    end
+    @freeroam = !@freeroam
+  end
+
+  # Find some info about unit in current tile
+  def info
+    uu = @map.get_unit(@x, @y)
+    if uu
+      @infopane.text = uu.info
+      puts uu.info
+    else
+      @infopane.text = ''
+      puts 'nothing here'
+    end
+  end
+end

data/lib/docu/info.txt

@@ -0,0 +1,149 @@
+/--  ///  /-/  -/-
+/--  |||  /-/   | 
+/--  |||  |    -/-
+
+Empi: Ruby Edition
+====================
+
+
+v16 dev
+=========
+- units on sentry duty say so when functioning
+- neutral units can't have functions
+- links to media and save files use full path
+- towns build armies
+! hardcoded unit type to be built
+- units can transport other units
+- newly built units are stored in town instead of map
+  fixes: new units are saved in map instead of the towns that built them
+! transported units are not drawn
+! transported units show info of their transport instead when selected
+! all units can capture and visit towns
+
+file changes
+--------------
+map
+  initialize() uses full paths to files
+  all_units renamed to all_map_units() - Return only units directly on map
+  +all_transported_units() - Return only units transported by other units
+  +all_units() - Return both map units and transported units
+  draw_units() draws only map units
+
+unit
+  +@cargo, @cargo_max
+  +can_transport?() - Unit is able to both transport other units and currently has some space left
+  set_function() checks for @faction == 0
+  checking of movement separated from update()
+  +check_movement() - Processes move of unit and takes care of its (un)loading or attack
+  capture() makes newly captured towns start building
+
+town
+  initialize() uses full path to file
+  +parts_built
+  +@cargo_max set to 10
+
+army
+  initialize() uses full path to file
+
+ship
+  initialize() uses full path to file
+  +@cargo_max set to 3
+
+unitFunction
+  +FUNCBUILD case in func!()
+  FUNCSENTRY case in func!() sets "ret" even when unit keeps sentrying 
+
+
+v15 dev
+=========
+- units referenced only from map
+  fixed: no destruction of units
+- loading of units from file
+  fixed: no loading
+- checks of loaded terrain tiles and units
+- map stored as [row, column], not [xx, yy]
+
+file changes
+--------------
+empi.rb
+  -scenario_units() - Return list of units for given scenario
+
+map.rb
+  load_map() now loads units too
+  load_head() now returns number of units to load too
+  load_map(), tile(), get_unit(), set_unit() use rr and cc instead of xx and yy
+  +load_unit() - Load one unit from given line
+  +draw_units() - Draw all units
+
+save/m01.esf
+  8 units from old empi.scenario_units()
+
+save/m02.esf
+  10 units similar to old empi.scenario_units()
+
+save/m03.esf
+
+
+v14 dev
+=========
+- loading of terrain tiles from file
+  fixed: hardcoded starting scenario
+! hardcoded save file name
+! hardcoded map size
+
+file changes
+--------------
+empi.rb
+  TILE constants moved to map.rb
+
+map.rb
+  -scenario_tiles() - Return map tile for given scenario
+  +load_map() - Load map from file (for now only terrain tiles)
+  +load_head() - Load head row of file
+
+unit.rb
+  removed generic unit image
+
+save/m01.esf
+save/m02.esf
+
+
+older versions
+================
+- towns and armies
+- functions none and sentry
+- armor and movement points
+- movement of units
+- rudimentary terrain checking after move
+- capturing of units
+- turn and score counting
+- commmand line and screen text output
+- next avaiable unit / freeroam cursor
+
+current state
+===============
+old wishlist
+! no panning of map
+!x no destruction of units
+!x no building of units
+! no victory conditions
+! attacker always wins
+! player playing both factions at once
+!x hardcoded starting scenario
+! no fog of war
+! no saving
+!x no loading
+! no title screen
+! no highscore screen
+! no settings
+! no sound, no music
+
+new problems
+! hardcoded save file name
+! hardcoded map size
+! hardcoded unit type to be built
+! transported units are not drawn
+! transported units show info of their transport instead when selected
+! all units can capture and visit towns
+
+(! thing to fix, !x fixed thing)

data/lib/empi.rb

@@ -0,0 +1,143 @@
+require 'rubygems'
+require 'gosu'
+
+require_relative './army'
+require_relative './cursor'
+require_relative './infopane'
+require_relative './map'
+require_relative './ship'
+require_relative './town'
+
+TILESIZE = 50
+MAPX = 10
+MAPY = 10
+
+XTEXT = 5
+YTEXT = 5
+
+ZTILE = 0
+ZUNIT = 1
+ZTEXT = 2
+ZCURSOR = 3
+
+FACTIONS = 2
+COLOUR = [0xff_ffffff, 0xff_ff3300, 0xff_ffcc00]
+
+FUNCNONE = 'none'
+FUNCSENTRY = 'sentry'
+FUNCBUILD = 'build'
+
+# Main class
+class GameWindow < Gosu::Window
+  def initialize(width = (MAPX + 1) * TILESIZE, \
+                 height = (MAPY + 2) * TILESIZE, \
+                 fullscreen = false)
+    super
+    self.caption = 'Empi: Ruby Edition 0.16 dev'
+
+    @infopane = Infopane.new
+    @map = Map.new(@infopane)
+    @cursor = Cursor.new(5, 5, @map, @infopane)
+
+    new_turn
+  end
+
+  def button_up(key)
+    @button = key
+
+    case(key)
+    when Gosu::KbEscape then
+      close
+    when Gosu::KbPeriod then
+      new_turn
+    when Gosu::KbH then
+      help
+    when Gosu::KbJ then
+      unit_to_move = 0
+      @cursor.switch_freeroam
+    end
+  end
+
+  # Process given button to cursor
+  def update
+    if @button == -1 then return end
+
+    movable_units = @map.all_units.select { |uu| uu.can_move && uu.function == FUNCNONE}
+    # If there are any movable units without functions select one of them with the cursor
+    if @cursor.freeroam == false && movable_units.size > 0
+      unit_to_move = movable_units[0]
+      unit_to_move.update(@button)
+
+      # Can it still move?
+      if unit_to_move.can_move && unit_to_move.function == FUNCNONE
+       # Move the cursor to it unless it is already there
+        if (@cursor.x != unit_to_move.x \
+            || @cursor.y != unit_to_move.y)
+          @cursor.warp(unit_to_move.x, unit_to_move.y)
+          @cursor.info
+        end
+      else
+        # Was that the last currently avaiable non-function move?
+        movable_units = @map.all_units.select { |uu| uu.can_move && uu.function == FUNCNONE}
+        if movable_units.size == 0
+          puts 'all movable units without functions moved'
+          @cursor.switch_freeroam
+        else
+          # Move cursor to next avaiable unit
+          unit_to_move = movable_units[0]
+          @cursor.warp(unit_to_move.x, unit_to_move.y)
+          @cursor.info
+        end
+      end
+
+    else
+      # Cursor in freeroam mode
+      @cursor.update(@button) 
+    end
+  end
+
+  # Draw only after some button was released and in the start
+  def needs_redraw?
+    @button != -1
+  end
+
+  def draw
+    @button = -1 # use each button just once
+
+    # Draw map tiles and units
+    @map.draw_tiles
+    @map.draw_units
+# DEBUG    @map.all_units.each { |uu| puts uu.info}
+
+    @cursor.draw
+    @infopane.draw
+
+    # @message = Gosu::Image.from_text(
+    # self, "Empire", Gosu.default_font_name, 20)
+    # @message.draw(10, 10, 2)
+  end
+
+  # End current turn and start next one
+  def new_turn
+    @cursor.freeroam = true
+    @cursor.switch_freeroam # so freeroam = false, with messages
+
+    functionable_units = @map.all_units.select { |uu| uu.function != FUNCNONE}
+    functionable_units.each { |uu| uu.function! }
+
+    @map.all_units.each { |uu| uu.reset_moves}
+    @infopane.next_turn
+  end
+
+  def help
+    puts "----------\n" \
+         "QWEADZXC movement, h help, Enter info, j switch freeroam\n" \
+         "functions: s sentry, n none\n" \
+         "----------\n"
+  end
+end
+
+# ---------------------------------------------------------------
+
+window = GameWindow.new
+window.show

data/lib/infopane.rb

@@ -0,0 +1,36 @@
+# Score, turn and event texts
+class Infopane
+  attr_writer :text, :act_fact
+
+  def initialize
+    @score = [0, 0]
+    @turn = 0
+    @act_fact = 0 # active faction
+    @text = 'ready'
+  end
+
+  def update
+  end
+
+  def draw
+    turnscore = Gosu::Image.from_text(
+      self, "Turn: #{@turn}, Score: #{@score[0]} -  #{@score[1]}", Gosu.default_font_name, 20)
+    turnscore.draw(XTEXT, YTEXT, ZTEXT)
+
+    text = Gosu::Image.from_text(self, "#{@text}", Gosu.default_font_name, 20)
+    text.draw(XTEXT, (TILESIZE / 2) + YTEXT, ZTEXT)
+  end
+
+  def next_faction
+    
+  end
+  
+  def next_turn
+    @turn += 1
+    puts "Turn: #{@turn}, Score: #{@score[0]} -  #{@score[1]}"
+  end
+
+  def add_score(to_whom, how_much)
+    @score[to_whom] += how_much
+  end
+end

data/lib/map.rb

@@ -0,0 +1,172 @@
+TILE_SEA = 0
+TILE_GROUND = 1
+
+SYMBOL_SEA = '.'
+SYMBOL_GROUND = '#'
+SYMBOL_TOWN = 'T'
+SYMBOL_ARMY = 'A'
+SYMBOL_SHIP = 'S'
+
+class Map
+  attr_accessor :name, :mapx, :mapy, :infopane
+
+  # Fill tile map and prepare 
+  def initialize(infopane)
+    dir_path = File.dirname(__FILE__)
+
+    @infopane = infopane
+    @sea_image = Gosu::Image.new(dir_path + '/media/sea.png')
+    @ground_image = Gosu::Image.new(dir_path + '/media/ground.png')
+    load_map(dir_path + '/save/m03.esf')
+  end
+
+  # Load map from file
+  def load_map(filename)
+    input = File.open(filename, 'r')
+    unit_count = load_head(input.gets)
+
+    # Load tiles
+    @tiles = []
+    @units = []
+    0.upto(@mapy - 1) { |rr|
+      @tiles[rr] = []
+      @units[rr] = []
+      map_row = input.gets
+      0.upto(@mapx - 1) { |cc|
+        case(map_row[cc])
+        when SYMBOL_SEA then
+          @tiles[rr][cc] = TILE_SEA
+        when SYMBOL_GROUND then
+          @tiles[rr][cc] = TILE_GROUND
+        else
+          abort("map.load_map(): Unknown terrain symbol (#{map_row[cc]})")
+        end
+      }
+    }
+
+    # Load units
+    unit_count.times { load_unit(input.gets) }
+
+    puts("Save loaded: #{@name} with #{unit_count} units")
+    input.close
+  end
+
+  # Load core info from given head row of file
+  # Return number of units to be loaded
+  def load_head(row)
+    head = []
+    size = []
+
+    head = row.split(' ')
+    size = head[1].split('x')
+
+    @name = head[0]
+    @mapx = size[0].to_i
+    @mapy = size[1].to_i
+
+    head[2].to_i # unit_count
+  end
+
+  # Load one unit from given line
+  def load_unit(row)
+    unit = []
+    coords = []
+
+    unit = row.split(' ')
+    coords = unit[2].split('-')
+
+    # Check faction
+    fac = unit[1].to_i
+    if(fac < 0 || fac > FACTIONS)
+      abort("map.load_unit(): Bad faction id (#{fac})")
+    end
+
+    # Check coordinates
+    coords_x = coords[0].to_i
+    coords_y = coords[1].to_i
+    if (coords_x < 0 || coords_x >= @mapx ||
+        coords_y < 0 || coords_y >= @mapy)
+      abort("map.load_unit(): Unit out of map borders (#{coords_x}-#{coords_y})")
+    end
+
+    # Create unit
+    case(unit[0])
+    when SYMBOL_TOWN then
+      Town.new(coords_x, coords_y, fac, self, @infopane)
+    when SYMBOL_ARMY then
+      Army.new(coords_x, coords_y, fac, self, @infopane)
+    when SYMBOL_SHIP then
+      Ship.new(coords_x, coords_y, fac, self, @infopane)
+    else
+      abort("map.load_unit(): Unknown unit type symbol (#{unit[0]})")
+    end
+  end
+
+  # Draw all tiles
+  def draw_tiles
+    # TODO combine with draw_units()
+
+    0.upto(MAPX) { |rr|
+      0.upto(MAPX) { |cc|
+        if @tiles[rr][cc] == TILE_SEA
+          # TODO tiles (z1) and units (z2) together
+          im = @sea_image
+        else
+          im = @ground_image
+        end
+        im.draw(cc * TILESIZE, (rr + 1) * TILESIZE, ZTILE)
+      }
+    }
+  end
+
+  # Draw all map units
+  def draw_units
+    all_map_units.each { |uu| uu.draw} # TODO do not draw transported units? only draw them on selection (with their tile)?
+  end
+
+  # Getter for tile type in given coordinates
+  def tile(cc, rr)
+    @tiles[rr][cc]
+  end
+
+  # Getter for unit in given coordinates
+  def get_unit(cc, rr)
+    @units[rr][cc]
+  end
+
+  # Setter for tile type in given coordinates
+  def set_unit(cc, rr, uu)
+    @units[rr][cc] = uu
+  end
+
+  # Return both map units and transported units
+  def all_units
+    all_map_units + all_transported_units
+  end
+
+  # Return only units directly on map
+  def all_map_units
+    ret = []
+    ii = 0
+    0.upto(MAPX) { |rr|
+      0.upto(MAPX) { |cc|
+        if @units[rr][cc]
+          ret[ii] = @units[rr][cc]
+          ii += 1
+        end
+      }
+    }
+    ret
+  end
+
+  # Return only units transported by other units
+  def all_transported_units
+    ret = []
+    all_map_units.each { |uu| 
+      if uu.is_transporting?
+        ret += uu.cargo
+      end
+    }
+    ret
+  end
+end

data/lib/save/m01.esf

@@ -0,0 +1,20 @@
+mission01 11x11 8
+#####..####
+####....###
+###......##
+##........#
+#...###...#
+....##....#
+....#....##
+#.......###
+##.....####
+###...#####
+###########
+T 0 1-3
+T 0 3-1
+T 0 6-9
+T 0 9-6
+T 1 8-1
+A 1 9-1
+T 2 1-8
+A 2 1-9

data/lib/save/m02.esf

@@ -0,0 +1,22 @@
+mission02 11x11 10
+###########
+#..###..###
+#....#...##
+##...#....#
+##....#...#
+####...####
+#...#....##
+#....#....#
+##...#....#
+###..##..##
+###########
+T 0 1-3
+T 0 3-1
+T 0 6-9
+T 0 9-6
+T 1 8-1
+T 1 9-2
+A 1 10-0
+T 2 1-8
+T 2 2-9
+A 2 0-10

data/lib/save/m03.esf

@@ -0,0 +1,24 @@
+mission03 11x11 11
+.....###...
+..#######..
+.#.##.##.#.
+#.#....#.##
+##...##.###
+#..#####..#
+###.##...##
+##.#....#.#
+.#.##.##.#.
+..#######..
+...###.....
+T 0 3-8
+T 0 10-4
+T 0 5-1
+T 0 5-5
+T 0 5-9
+T 0 7-2
+T 0 0-6
+T 1 2-3
+A 1 1-2
+T 2 8-7
+A 2 9-8
+

data/lib/ship.rb

@@ -0,0 +1,19 @@
+require_relative './unit'
+
+class Ship < Unit
+  def initialize(x, y, faction, map, infopane)
+    super
+    dir_path = File.dirname(__FILE__)
+    @image = Gosu::Image.new(dir_path + '/media/ship.png')
+
+    @name = 'ship'
+    @value = 10
+    @armor_left = @armor_max = 1
+    @moves_max = 2
+    @cargo_max = 3
+  end
+
+  def can_sail?
+    true
+  end
+end

data/lib/town.rb

@@ -0,0 +1,24 @@
+require_relative './unit'
+
+class Town < Unit
+  attr_accessor :parts_built
+
+  def initialize(x, y, faction, map, infopane)
+    super
+    dir_path = File.dirname(__FILE__)
+    @image = Gosu::Image.new(dir_path + '/media/town.png')
+
+    @name = 'town'
+    @value = 20
+    @armor_left = @armor_max = 1
+    @moves_max = 0
+
+    @parts_built = 0
+    @cargo_max = 10
+    set_function(FUNCBUILD)
+  end
+
+  def can_build?
+    true
+  end
+end

data/lib/unit.rb

@@ -0,0 +1,244 @@
+require_relative './unitFunction'
+
+# All capturable game pieces
+class Unit
+  attr_accessor :x, :y, :faction, :function, :cargo
+
+
+  def initialize(x, y, faction, map, infopane)
+    @x = x
+    @y = y
+    @faction = faction
+    @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)
+
+
+
+    # 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
+
+  # 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
+
+    # if you are a town, start building units
+    if can_build?
+      set_function(FUNCBUILD)
+    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
+
+    # Functions
+    when Gosu::KbS then
+      set_function(FUNCSENTRY)
+    when Gosu::KbB then
+      set_function(FUNCBUILD)
+    end
+
+    check_movement(old_x, old_y)
+  end
+
+
+  # Processes move of unit and takes care of its (un)loading or attack
+  def check_movement(old_x, old_y)
+    if @x != old_x || @y != old_y
+      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 !newcoords_unit || \
+        (newcoords_unit.faction == @faction && newcoords_unit.can_transport?)
+
+        # Leave old coordinates
+        if oldcoords_unit == self 
+          @map.set_unit(old_x, old_y, nil)
+        else # if you have been transported
+puts "oldcoords_unit.cargo = \"#{oldcoords_unit.cargo}\""
+          oldcoords_unit.cargo.delete(self)
+puts "oldcoords_unit.cargo = \"#{oldcoords_unit.cargo}\""
+        end
+
+        # Get to new coordinates
+        if newcoords_unit == nil
+          @map.set_unit(@x, @y, self)
+        else # if you are going to be transported
+          newcoords_unit.cargo.insert(-1, self) # -1 = to the end
+        end
+
+      else # if there already is somebody
+          # Stay on your original tile
+          @x = old_x
+          @y = old_y
+
+          # Don't capture allies
+          if newcoords_unit.faction != @faction
+            puts to_s + ' is capturing ' + newcoords_unit.to_s # TODO capture only towns, do combat otherwise
+            newcoords_unit.capture(@faction)
+          end      
+      end
+      @moves_left -= 1
+
+      # Check if unit is on invalid type of tile
+      if tile_check == false
+        puts 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 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
+
+  # Unit is able to both transport other units and currently has some space left
+  def can_transport?
+    @cargo_max > 0 && @cargo.size < @cargo_max
+  end
+
+  def is_transporting?
+    @cargo.size > 0
+  end
+
+  def tile_check
+    case @map.tile(@x, @y)
+    when TILE_SEA
+      return can_fly? || can_sail?
+    when TILE_GROUND
+      return can_fly? || can_ride?
+    end
+    true
+  end
+
+  def function
+    @function.func
+  end
+
+  def set_function(func)
+    unless @faction == 0 # neutral faction doesn't need functions
+      if (func == FUNCBUILD && !can_build?)
+        puts to_s + ": this unit can't build other units"
+      end
+
+      if @function == func
+        puts to_s + ": function already set to #{@function.func}"
+      else
+        @function.func = func
+        puts to_s + ": function set to #{@function.func}"
+      end
+    end
+  end
+
+
+  def function!
+    ret = @function.func!(@x, @y, @map, @infopane)
+    puts to_s + ret
+  end
+
+  # Set short info string: type, faction, coordinates
+  def to_s
+    "#{@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
+      ret = ret + ", moves #{@moves_left}/#{@moves_max}"
+    end
+
+    ret = ret + ", func #{@function.func}"
+
+    if @cargo.size > 0
+      ret = ret + ", transports #{@cargo.size} units"
+    end
+
+    ret
+  end
+
+  def reset_moves
+    @moves_left = @moves_max
+  end
+end

data/lib/unitFunction.rb

@@ -0,0 +1,47 @@
+PARTS = 3
+
+class UnitFunction
+  attr_accessor :func
+
+  def initialize(function = FUNCNONE)
+    @func = function
+  end
+
+  def func!(xx, yy, map, infopane)
+    ret = " didn't actually do anything (ERROR)"
+
+    unit = map.get_unit(xx, yy)
+    if unit == nil
+      abort("unitFunction.func!(): Functioning unit not found at given coordinates (#{xx}-#{yy})")
+    end
+
+    case @func
+    # Build given unit
+    when FUNCBUILD
+      if(unit.parts_built >= PARTS) # just == should be enough
+        ret = " completed building of army"
+        unit.parts_built = 0
+        Army.new(unit.x, unit.y, unit.faction, map, infopane) # TODO allow setting what to build
+      else
+        ret = " built next part of army"
+        unit.parts_built = unit.parts_built + 1
+      end
+    
+    # Wake up when enemies are nearby
+    when FUNCSENTRY
+      units_around = map.all_units.select { |uu|
+        (uu.x - xx).abs <= 1 &&
+        (uu.y - yy).abs <= 1 &&
+        uu.faction != unit.faction
+      }
+      if units_around.size > 0
+        ret = " woke up"
+        @func = FUNCNONE
+      else
+        ret = " was on sentry duty"
+      end
+    end
+
+    ret
+  end
+end

metadata

@@ -0,0 +1,99 @@
+--- !ruby/object:Gem::Specification
+name: empi
+version: !ruby/object:Gem::Version
+  version: 0.16.6
+  prerelease: 
+platform: ruby
+authors:
+- Detros
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-04-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: gosu
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+description: ! 'Empi: Ruby Edition is a turn based wargame, currently deep in development.
+  While learning Ruby I have found there are hardly any strategic games avaiable.
+  So this should be Ruby version of Classic Empire, wargame from old times.'
+email: rasunadon@seznam.cz
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/docu/Empi v14.png
+- lib/docu/info.txt
+- lib/media/town.png
+- lib/media/ship.png
+- lib/media/army.png
+- lib/media/cursor.png
+- lib/media/sea.png
+- lib/media/ground.png
+- lib/save/m02.esf
+- lib/save/m01.esf
+- lib/save/m03.esf
+- lib/ship.rb
+- lib/unit.rb
+- lib/unitFunction.rb
+- lib/town.rb
+- lib/map.rb
+- lib/army.rb
+- lib/cursor.rb
+- lib/infopane.rb
+- lib/empi.rb
+homepage: http://www.bay12forums.com/smf/index.php?topic=157538.0
+licenses:
+- CC-BY-SA 3.0
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Turn-based wargame
+test_files: []