pirate_game 0.0.1

data/lib/pirate_game/game_master.rb

@@ -0,0 +1,208 @@
+require 'shuttlecraft/mothership'
+
+class PirateGame::GameMaster < Shuttlecraft::Mothership
+
+
+  MIN_PLAYERS = 1 # for now
+  MAX_PLAYERS = 4
+
+  STATES = [:pending, :startable, :playing, :ended]
+
+  attr_accessor :stage, :stage_ary
+
+  ##
+  # The state of the game. See STATES.
+
+  attr_reader :state
+
+  ##
+  # Number of players in the game.  Call #update to refresh
+
+  attr_reader :num_players
+
+  ##
+  # Names of players in the game.  Call #update to refresh
+
+  attr_reader :player_names
+
+  def initialize(opts={})
+    opts[:protocol] ||= PirateGame::Protocol.default
+
+    super(opts.merge({:verbose => true}))
+
+    set_state :pending
+
+    @last_update  = Time.at 0
+    @num_players  = 0
+    @player_names = []
+    @stage        = nil
+    @stage_ary    = []
+
+    @action_watcher = create_action_watcher
+  end
+
+  def registrations_text
+    "Num Players: #{@num_players}\n#{@player_names.join(', ')}\n"
+  end
+
+  def stage_info
+    return unless @stage
+
+    info = "Stage #{@stage.level}: \n"
+    if @stage.in_progress?
+      info << "Actions: #{@stage.actions_completed}\n"
+      info << "Time Left: #{@stage.time_left.to_i} seconds\n"
+    else
+      info << "Status: #{@stage.status}\n"
+
+      rundown = @stage.rundown
+
+      info << "Actions: #{rundown[:total_actions]}\n"
+
+      rundown[:player_breakdown].each do |player_uri, actions|
+        info << "#{player_uri}: #{actions}\n"
+      end
+
+    end
+
+    info
+  end
+
+  def game_info
+    return if @stage_ary.empty?
+
+    info = "Game Rundown:\n"
+    gr = game_rundown
+
+    info << "Total Actions: #{gr[:total_actions]}\n"
+
+    gr[:player_breakdown].each do |player_uri, actions|
+      info << "#{player_uri}: #{actions}\n"
+    end
+
+    info
+  end
+
+  def game_rundown
+    return {} if @stage_ary.empty?
+
+    rundown = {
+      :total_stages => @stage_ary.length,
+      :total_actions => @stage_ary.inject(0) {|sum,stage| sum += stage.actions_completed},
+      :player_breakdown => {}}
+
+    for stage in @stage_ary
+      stage.player_stats.each_pair do |key, value|
+        rundown[:player_breakdown][key] ||= 0
+        rundown[:player_breakdown][key] += value.size
+      end
+    end
+
+    rundown
+  end
+
+  def allow_registration?
+    return (@stage.nil? && @num_players < MAX_PLAYERS)
+  end
+
+  def startable?
+    update!
+    return (@stage.nil? || @stage.success?) &&
+           @num_players >= MIN_PLAYERS &&
+           @num_players <= MAX_PLAYERS
+  end
+
+  def increment_stage
+    @stage =
+      if @stage
+        @stage.increment
+      else
+        PirateGame::Stage.new 1, @num_players
+      end
+
+    @stage_ary << @stage
+    @stage
+  end
+
+  def on_registration
+    set_state :startable if startable?
+  end
+
+  def start
+    return unless startable?
+
+    increment_stage
+
+    return true
+  end
+
+  def send_stage_info_to_clients
+    if @stage.in_progress?
+      set_state :playing
+      send_start_to_clients
+
+    elsif @stage.success?
+      set_state :startable
+      send_return_to_pub_to_clients
+
+    elsif @stage.failure?
+      set_state :ended
+      send_end_game_to_clients
+    end
+  end
+
+  def send_start_to_clients
+    each_client do |client|
+      bridge = @stage.bridge_for_player
+      client.start_stage(bridge, @stage.all_items)
+    end
+  end
+
+  def send_return_to_pub_to_clients
+    each_client do |client|
+      client.return_to_pub
+    end
+  end
+
+  def send_end_game_to_clients
+    each_client do |client|
+      client.end_game game_rundown
+    end
+  end
+
+  def create_action_watcher
+    Thread.new do
+      loop do
+        handle_action @ts.take([:action, nil, nil, nil])
+      end
+    end
+  end
+
+  def handle_action action_array
+    if @stage && @stage.in_progress?
+      @stage.complete action_array[1], action_array[3]
+    end
+  end
+
+  ##
+  # Retrieves the latest data from the TupleSpace.
+
+  def update
+    ret = super
+    return if ret.nil?
+
+    @num_players = @registered_services_ary.length
+
+    @player_names = @registered_services_ary.map { |name,| name }
+
+    ret
+  end
+
+  private
+
+  def set_state state
+    @state = state if STATES.include? state
+  end
+
+end
+

data/lib/pirate_game/image.rb

@@ -0,0 +1,23 @@
+class PirateGame::Image < PirateGame::WavingItem
+
+  def initialize shoes, image, top, left
+    super 0, 10, 4
+
+    @shoes = shoes
+    @image = image
+    @top   = top
+    @left  = left
+  end
+
+  def animate frame
+    top_offset, left_offset = waving_offset frame
+
+    @ship.move @top + top_offset, @left + left_offset
+  end
+
+  def draw
+    @ship = @shoes.image @image, top: @top, left: @left
+  end
+
+end
+

data/lib/pirate_game/log_book.rb

@@ -0,0 +1,39 @@
+require 'thread'
+
+class PirateGame::LogBook
+
+  include Enumerable
+
+  def initialize size = 10
+    @mutex = Mutex.new
+    @log_book = []
+    @size = size
+  end
+
+  def add entry, author = 'unknown'
+    @mutex.synchronize do
+      @log_book << [entry, author]
+
+      @log_book.shift if @log_book.size > @size
+    end
+  end
+
+  def each
+    return enum_for __method__ unless block_given?
+
+    @log_book.each do |(entry, author)|
+      yield [entry, author]
+    end
+  end
+
+  def empty?
+    @log_book.empty?
+  end
+
+  def length
+    @log_book.length
+  end
+  alias_method :size, :length
+
+end
+

data/lib/pirate_game/master_app.rb

@@ -0,0 +1,103 @@
+module PirateGame
+  class MasterApp
+
+    def self.run
+      new.run
+    end
+
+    def initialize
+      @game_master = nil
+    end
+
+    def run
+      Shoes.app width: 360, height: 360, resizeable: false, title: 'Game Master' do
+
+        def launch_screen
+          clear do
+            background Boot::COLORS[:dark]
+            stack margin: 20 do
+              title "Start Game", stroke: Boot::COLORS[:light]
+              edit_line text: 'Name' do |s|
+                @name = s.text
+              end
+              button('launch') {
+                @game_master = GameMaster.new(name: @name)
+                display_screen
+              }
+            end
+          end
+        end
+
+        def display_screen
+          @game_master.update
+
+          clear do
+            background Boot::COLORS[:light]
+
+            stack :margin => 20 do
+              title "Game #{@game_master.name}", stroke: Boot::COLORS[:dark]
+
+              @button_stack = stack
+              @registrations = para stroke: Boot::COLORS[:dark]
+              @stage_info = para stroke: Boot::COLORS[:dark]
+              @game_info = para stroke: Boot::COLORS[:dark]
+            end
+
+            animate(5) {
+              detect_state_change {
+                update_button_stack
+              }
+
+              detect_stage_status_change {
+                @game_master.send_stage_info_to_clients
+              }
+
+              @registrations.replace @game_master.registrations_text
+              @stage_info.replace @game_master.stage_info
+              @game_info.replace @game_master.game_info
+            }
+          end
+        end
+
+        ##
+        # Responsible for updating the display of the START button
+
+        def update_button_stack
+          @button_stack.clear do
+
+            case @state
+            when :startable
+              button('START') {
+                @game_master.start
+              }
+            end
+          end
+        end
+
+        ##
+        # If the game_master.state has changed, yields to the block.
+
+        def detect_state_change
+          return if @state == @game_master.state
+
+          @state = @game_master.state
+
+          yield
+        end
+
+        ##
+        # If the stage status has changed, yields to the block
+        def detect_stage_status_change
+          return unless @game_master.stage
+          return if @stage_status == @game_master.stage.status
+
+          @stage_status = @game_master.stage.status
+
+          yield
+        end
+
+        launch_screen
+      end
+    end
+  end
+end

data/lib/pirate_game/protocol.rb

@@ -0,0 +1,10 @@
+require 'shuttlecraft/protocol'
+
+class PirateGame::Protocol < Shuttlecraft::Protocol
+
+  def self.default
+    @@default ||= self.new :PirateGame, "Pirate Game"
+    @@default
+  end
+
+end

data/lib/pirate_game/shoes4_patch.rb

@@ -0,0 +1,30 @@
+class Shoes
+  module Swt
+    class Progress
+      def fraction=(value)
+        @real.selection = (value*100).to_i unless @real.disposed?
+      end
+    end
+
+    class TextBlockPainter
+
+      # added the return statement on line 8
+      def paintControl(paint_event)
+        graphics_context = paint_event.gc
+        gcs_reset graphics_context
+        @text_layout.setText @dsl.text
+        set_styles
+        if @dsl.width
+          @text_layout.setWidth @dsl.width
+          return if @dsl.absolute_left.nil? || @dsl.margin_left.nil? || @dsl.absolute_top.nil? || @dsl.margin_top.nil?
+          @text_layout.draw graphics_context, @dsl.absolute_left + @dsl.margin_left, @dsl.absolute_top + @dsl.margin_top
+          if @dsl.cursor
+            move_text_cursor
+          else
+            (@dsl.textcursor.remove; @dsl.textcursor = nil) if @dsl.textcursor
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pirate_game/stage.rb

@@ -0,0 +1,96 @@
+require 'pirate_command'
+
+class PirateGame::Stage
+
+  attr_accessor :actions_completed
+  attr_accessor :player_stats
+  attr_accessor :all_items
+  attr_accessor :begin_time
+  attr_accessor :level
+  attr_accessor :players
+
+  ITEMS_PER_BRIDGE = 6
+  DURATION = PirateGame::Boot.config["stage_duration"]
+
+  IN_PROGRESS = 'In Progress'
+  SUCCESS = 'Success'
+  FAILURE = 'Failure'
+
+  def initialize(level, players)
+    @level = level
+    @players = players
+    @actions_completed = 0
+    @player_stats = {}
+    generate_all_items
+
+    @begin_time = Time.now
+  end
+
+  def increment
+    PirateGame::Stage.new self.level + 1, self.players
+  end
+
+  def time_left
+    [0, (begin_time + DURATION) - Time.now].max
+  end
+
+  def status
+    if time_left > 0
+      IN_PROGRESS
+    else
+      passed? ? SUCCESS : FAILURE
+    end
+  end
+
+  def in_progress?
+    status == IN_PROGRESS
+  end
+
+  def success?
+    status == SUCCESS
+  end
+
+  def failure?
+    status == FAILURE
+  end
+
+  def generate_all_items
+    @all_items = []
+
+    while @all_items.length < @players*ITEMS_PER_BRIDGE
+      thing = PirateCommand.thing
+      @all_items << thing unless @all_items.include?(thing)
+    end
+    @boards = @all_items.each_slice(ITEMS_PER_BRIDGE).to_a
+  end
+
+  def bridge_for_player
+    @boards.shift
+  end
+
+  def complete action, from
+    @actions_completed += 1
+    @player_stats[from] ||= []
+    @player_stats[from] << action
+  end
+
+  def required_actions
+    @level * 2 + 1
+  end
+
+  def passed?
+    @actions_completed >= required_actions
+  end
+
+  def rundown
+    return if status == IN_PROGRESS
+
+    rundown = {stage: @level, total_actions: @actions_completed}
+    rundown[:player_breakdown] = {}
+
+    @player_stats.each {|p,v| rundown[:player_breakdown][p] = v.size}
+
+    rundown
+  end
+
+end