empi 0.21 → 0.25

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c2a8c4d275198c690e2abe8ccaa6cc4fa6d636fa48a7aa5ddcf4cfd5e67a4e1b
-  data.tar.gz: 92d1bed4b5219e8ed122fa0abf5bb2065db2df87c6ac27698cc4c9c27750a935
+  metadata.gz: abe9081612cf59f547e94e98d5ee4373fab6ded9298bfb20366bc3d67725c0cc
+  data.tar.gz: 7f7683c7a94d512965feed1617fc3cb700851e5444862a28069b8c2ddb76cecc
 SHA512:
-  metadata.gz: 4c925aebb1925ccecbef7fa18e9bd1b18ec65d0066bfcd2b1ebc3e0f3476877c3f7b3dcd48f6d926057a85756591b70ec38d783134ba65e03b4436f9daf512dd
-  data.tar.gz: ab0dde3dd38a74a7639104601d6b972a824095f2b242acf81a5d8dc69b55e0be4eae0f3125f804b9106576c3cea185353b16ec0db1200d4c49ecf15c1dc67e80
+  metadata.gz: feac436c82e490b978bac742c546816879fa7c32ef3e14410023078d83b1e8d5366d3ffa7ef051442cf84d5cef728f8c7ee2f2577ddce84c7f3ef16c2661def1
+  data.tar.gz: 73ade95b93a6b84b509ecb88ea545aaa80babbd007586bc4d5db52dee03a79eec15c9fd18f7a4422db265398921e1ab33701bd2c2230f9a7592fdc64cae64277

data/lib/empi.rb

@@ -1,8 +1,8 @@
 require 'rubygems'
 require 'gosu'
 
-require_relative './game_state'
-require_relative './play_state'
+require_relative './lib/game_states/game_state'
+require_relative './lib/game_states/welcome_state'
 
 TILESIZE = 50
 MAPX = 10
@@ -19,11 +19,15 @@ class GameWindow < Gosu::Window
                  height = (MAPY + 2) * TILESIZE, \
                  fullscreen = false)
     super
-    self.caption = 'Empi: Ruby Edition 0.21 dev'
+
+    # Set version name
+    version = '0.25'
+    self.caption = "Empi: Ruby Edition #{version}"
+    WelcomeState.instance.version = version
 
     # Activate first state
     $window = self
-    GameState.switch!(PlayState.instance)
+    GameState.switch!(WelcomeState.instance)
   end
 
   # Catch the released button
@@ -46,7 +50,6 @@ class GameWindow < Gosu::Window
 
   # Draw according to current state
   def draw
-
     @button = BUTTON_PROCESSED # draw just once after each button release
     unless $window.state.nil?
       @state.draw

data/lib/lib/game_states/build_state.rb

@@ -0,0 +1,68 @@
+require 'singleton'
+
+require_relative './game_state'
+require_relative './play_state'
+
+require_relative './../units/army'
+require_relative './../units/ship'
+
+# Game state of selection of the build project
+class BuildState < GameState
+  include Singleton
+
+  attr_accessor :unit
+
+  # What to do just after state gets activated
+  #def after_start
+  #end
+
+  # What to do just before state gets deactivated
+  #def before_end
+  #end
+
+  # Process given button
+  def update(button)
+    newly_selected = nil
+
+    case(button)
+    # Cancelled change of project = return
+    when Gosu::KbEscape then
+      puts PROMPT + @unit.to_s + ": cancelling, nothing changed"
+      GameState.switch!(PlayState.instance)
+    # Paused production = reset function and return
+    when Gosu::Kb0, Gosu::KbN then
+      puts PROMPT + @unit.to_s + ": production paused, resetting function"
+      @unit.set_function!(FUNCNONE, @unit.faction)
+      GameState.switch!(PlayState.instance)
+    # Selected new project = set it and return
+    when Gosu::Kb1, Gosu::KbA then
+      newly_selected = Army
+    when Gosu::Kb2, Gosu::KbS then
+      newly_selected = Ship
+    end
+
+    # Did we get any proper answer?
+    if newly_selected
+      @unit.set_project!(newly_selected)
+      GameState.switch!(PlayState.instance)
+    end
+  end
+
+  def draw
+    # Combine parts according to if there already is some project set
+    unit_text = "Built so far in " + @unit.to_s + ":"
+    project_text = "
+        #{@unit.parts_built} " +
+        "part#{ 's' unless @unit.parts_built == 1 } of " +
+        @unit.project.name + " (" + @unit.build_info + ")"
+    options_text = "Select the project:\n
+        1, A – Army (#{ @unit.price_list[Army] } turns)
+        2, S – Ship (#{ @unit.price_list[Ship] } turns)\n
+        0, N – pause production
+        Esc – cancel change of project"
+
+    build_project = Gosu::Image.from_text(
+      unit_text + "\n" + project_text + "\n\n" + options_text, 20)
+    build_project.draw((2*TILESIZE) + XTEXT, (2*TILESIZE) + YTEXT, ZTEXT)
+  end
+end

data/lib/lib/game_states/play_state.rb

@@ -0,0 +1,149 @@
+require 'singleton'
+
+require_relative './game_state'
+require_relative './welcome_state'
+require_relative './win_state'
+
+require_relative './../user_interface/cursor'
+require_relative './../user_interface/infopane'
+require_relative './../user_interface/map'
+
+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'
+
+# Game state of main gameplay
+class PlayState < GameState
+  include Singleton
+
+  attr_reader :map
+  attr_writer :desired_new_map
+
+  # Load new scenario or resume game
+  def after_start
+    if @desired_new_map
+      WinState.instance.unset_victory!
+      load_new_map!
+      help # show help after each loading of a new map
+      @desired_new_map = nil
+
+      next_faction_turn! # so FAC1 will be the first active faction, with announcement
+    else
+      # Make sure everything is set up
+      unless @infopane and @map and @cursor
+        abort("PlayState.after_start(): Map parts are not properly loaded
+          (#{@infopane}, #{@map}, #{@cursor})")
+      end
+
+      @cursor.info_stopped = false
+
+      # Remind player the current status
+      if @cursor.freeroam
+        @infopane.text = 'freeroam is enabled'
+        puts 'freeroam is enabled'
+      else
+        @cursor.info
+      end
+    end
+  end
+
+  # What to do just before state gets deactivated
+  def before_end
+    @cursor.info_stopped = true
+  end
+
+  # Process given button or send it to cursor
+  def update(button)
+    case(button)
+    when Gosu::KbEscape then
+      unless WinState.instance.faction
+        GameState.switch!(WelcomeState.instance)
+      else
+        GameState.switch!(WinState.instance)
+      end
+    when Gosu::KbPeriod then
+      next_faction_turn!
+    when Gosu::KbH then
+      help
+    else
+      @cursor.update(button)
+    end
+  end
+
+  # Draw all parts of main window
+  def draw
+    @map.draw_tiles
+    @cursor.draw
+    @infopane.draw
+  end
+
+  # Load the desired map
+  def load_new_map!
+    puts("=============\n" \
+         "=============\n" \
+         "Loading save: #{@desired_new_map}")
+    @infopane = Infopane.new
+    @map = Map.new(@desired_new_map, @infopane)
+    @cursor = Cursor.new(0, 0, @map, @infopane)
+  end
+
+  # End turn of the active faction
+  def next_faction_turn!
+    @infopane.next_faction!
+
+    # Have all factions played this turn so we are now back at the first one?
+    if @infopane.faction == 1
+      puts "=============\n" \
+           "End of turn\n" \
+           "=============\n"
+      @infopane.next_turn!
+    end
+
+    # Announce game state at the start of turn of the next faction
+    # TODO add change-of-active-faction screen
+    puts "-----------\n" + @infopane.turnscore
+
+    # Activate functions and reset moves for units of the next faction
+    functionable_faction_units = @map.all_units.select { |uu|
+      uu.faction == @infopane.faction and
+      uu.function != FUNCNONE
+    }
+    functionable_faction_units.each { |uu| uu.function! }
+
+    all_faction_units = @map.all_units.select { |uu|
+      uu.faction == @infopane.faction
+    }
+    all_faction_units.each { |uu| uu.reset_moves!}
+
+    # Win check: current faction has lost all units
+    if !WinState.instance.faction and all_faction_units.empty?
+      WinState.instance.set_victory!(
+        3 - @infopane.faction, # TODO more factions?
+        'Annihilation', @infopane.turn, @infopane.score
+      )
+    end
+
+    # Lock the cursor to the first waiting unit
+    @cursor.reset!
+  end
+
+  # Printout the controls
+  def help
+    puts "-----------\n" \
+         "H: help, Esc: menu, Enter: info, " \
+         ".: end your turn, J: switch freeroam\n" \
+         "QWEADZXC or arrow keys: movement, K: previous unit, L: next unit\n" \
+         "functions: S sentry, B build, N none\n" \
+         "-----------\n"
+  end
+end

data/lib/{escape_state.rb → lib/game_states/quit_state.rb}

@@ -1,10 +1,10 @@
 require 'singleton'
 
 require_relative './game_state'
-require_relative './play_state'
+require_relative './welcome_state'
 
 # Game state of closing the game window
-class EscapeState < GameState
+class QuitState < GameState
   include Singleton
 
   # What to do just after state gets activated
@@ -13,16 +13,15 @@ class EscapeState < GameState
 
   # What to do just before state gets deactivated
   #def before_end
-  #  TODO hide question?
   #end
 
-  # Process given button to cursor
+  # Process given button
   def update(button)
     case(button)
     when Gosu::KbY then
       $window.close
     when Gosu::KbN, Gosu::KbEscape then
-      GameState.switch!(PlayState.instance) # TODO return to state that called you
+      GameState.switch!(WelcomeState.instance)
     end
   end
 

data/lib/lib/game_states/set_state.rb

@@ -0,0 +1,75 @@
+require 'singleton'
+
+require_relative './game_state'
+require_relative './welcome_state'
+
+# Game state of settings screen
+class SetState < GameState
+  include Singleton
+
+  # TODO move out?
+  attr_reader :settings
+
+  # What to do just after state gets activated
+  #def after_start
+  #end
+
+  # What to do just before state gets deactivated
+  #def before_end
+  #end
+
+  def initialize
+    super
+    @settings = { # TODO move out?
+      'axis_top'    => true,
+      'axis_bottom' => false,
+      'axis_left'   => true,
+      'axis_right'  => false
+    }
+  end
+
+  # Process given button
+  def update(button)
+    case(button)
+    when Gosu::Kb1, Gosu::Kb2, Gosu::Kb3, Gosu::Kb4 then
+      change_setting!(button)
+    when Gosu::KbEscape then
+      GameState.switch!(WelcomeState.instance)
+    end
+  end
+
+  def draw
+    header_text = '
+        /--  ///  /-/  -/-
+        /--  |||  /-/   |
+        /--  |||  |    -/-'
+    options_text = "
+        1 – show top axis: #{@settings['axis_top']}
+        2 – show bottom axis: #{@settings['axis_bottom']}
+        3 – show left axis: #{@settings['axis_left']}
+        4 – show right axis: #{@settings['axis_right']}\n
+        Esc – return to menu"
+    warning_text = '
+        Warning: settings are not saved
+        when Empi is closed'
+
+    menu = Gosu::Image.from_text(
+      header_text + "\n\n\n\n\n" + options_text + "\n\n\n" + warning_text, 20)
+
+    menu.draw((3*TILESIZE) + XTEXT, (2*TILESIZE) + YTEXT, ZTEXT)
+  end
+
+  def change_setting!(button)
+    changed_setting = {
+      Gosu::Kb1 => 'axis_top',
+      Gosu::Kb2 => 'axis_bottom',
+      Gosu::Kb3 => 'axis_left',
+      Gosu::Kb4 => 'axis_right'
+    }[button]
+
+    old_value = @settings[changed_setting]
+    @settings[changed_setting] = !@settings[changed_setting] # TODO other than boolean types?
+    puts "setting #{changed_setting} changed from #{old_value} " \
+         "to #{@settings[changed_setting]}"
+  end
+end

data/lib/lib/game_states/welcome_state.rb

@@ -0,0 +1,85 @@
+require 'singleton'
+
+require_relative './game_state'
+require_relative './play_state'
+require_relative './quit_state'
+require_relative './set_state'
+require_relative './win_state'
+
+# Game state of main menu
+class WelcomeState < GameState
+  include Singleton
+
+  attr_accessor :version
+
+  # What to do just after state gets activated
+  #def after_start
+  #end
+
+  # What to do just before state gets deactivated
+  #def before_end
+  #end
+
+  # Process given button
+  def update(button)
+    case(button)
+    when Gosu::KbEscape then
+      # If there is active map go either to it or to its win screen
+      if PlayState.instance.map
+        unless WinState.instance.faction
+          GameState.switch!(PlayState.instance)
+        else
+          GameState.switch!(WinState.instance)
+        end
+      end
+    when Gosu::Kb1, Gosu::Kb2, Gosu::Kb3 then
+      PlayState.instance.desired_new_map = {
+         Gosu::Kb1 => 'm01',
+         Gosu::Kb2 => 'm02',
+         Gosu::Kb3 => 'm03'
+      }[button]
+      GameState.switch!(PlayState.instance)
+    when Gosu::Kb9, Gosu::KbS then
+      GameState.switch!(SetState.instance)
+    when Gosu::Kb0, Gosu::KbQ then
+      GameState.switch!(QuitState.instance)
+    end
+  end
+
+  def draw
+    header_text = '
+        /--  ///  /-/  -/-
+        /--  |||  /-/   |
+        /--  |||  |    -/-'
+
+    # Is there active map? Is it won?
+    if PlayState.instance.map
+      unless WinState.instance.faction
+        resume_text = "
+        Esc – resume"
+      else
+        resume_text = "
+        Esc – return to victory screen"
+      end
+    else
+      resume_text = "\n"
+    end
+
+    options_text = "
+        1 – start new: Map 01
+        2 – start new: Map 02
+        3 – start new: Map 03\n
+        9, S – settings
+        0, Q – quit"
+
+    version_text = "
+        version #{self.version}"
+
+    menu = Gosu::Image.from_text(
+      header_text + "\n\n\n" +
+      resume_text + "\n" +
+      options_text + "\n\n\n\n\n\n\n\n" +
+      version_text, 20)
+    menu.draw((3*TILESIZE) + XTEXT, (2*TILESIZE) + YTEXT, ZTEXT)
+  end
+end