Class: PirateGame::ClientApp

Inherits:

Object

• Object
• PirateGame::ClientApp

Defined in:

lib/pirate_game/client_app.rb

Class Method Summary

• .run ⇒ Object

Class Method Details

.run ⇒ Object

# File 'lib/pirate_game/client_app.rb', line 3

def self.run
  @my_app = Shoes.app width: 360, height: 360, resizeable: false, title: 'Pirate Game' do

    require 'pirate_game/shoes4_patch'

    def animate fps, &block
      opts = { framerate: fps }
      PirateGame::Animation.new @app, opts, block
    end

    ##
    # Creates the animation trigger for animating items.  An animatable item
    # must respond to #animate and accept a frame number.

    def animate_items
      @items_animation = animate(30) do |frame|
        @background.animate frame
      end
    end

    ##
    # Creates the waves and ship graphics that must be animated.

    def create_items
      @background = PirateGame::Background.new(self)
    end

    ##
    # Clears the app, draws the background, ship and waves, then yields to
    # draw UI items.

    def draw_items
      clear

      @background.draw do
        yield
      end
    end

    ##
    # Sets the application state

    def state= state
      @state = state
      @client.set_state @state
    end

    ##
    # The launch screen.

    def launch_screen
      @items_animation.start if @items_animation

      pirate_ship do
        title "What's your name", stroke: PirateGame::Boot::COLORS[:dark]

        edit_line text: 'Name' do |s|
          @name = s.text
        end

        button('launch') {
          @client = PirateGame::Client.new(name: @name)
        }
      end

      @state_watcher = animate(5) {
        watch_state
      }
    end

    ##
    # Draws a pirate ship background with waves yields to draw additional
    # UI.

    def pirate_ship
      draw_items do
        stack margin: 20 do
          yield
        end
      end
    end

    ##
    # Watches the state of the client to switch to a new screen.

    def watch_state
      return if @client.nil?
      return if @state == @client.state

      @state = @client.state

      case @state
      when :select_game
        select_game_screen
      when :pub
        pub_screen
      when :stage
        stage_screen
      when :end
        end_screen
      end
    end

    ##
    # Displays the UI for choosing a game to join

    def select_game_screen
      @items_animation.start if @items_animation

      motherships = @client.find_all_motherships

      title_text = if motherships.empty? then
                     "No Games Found"
                   else
                     "Choose Game"
                   end

      pirate_ship do
        title title_text, stroke: PirateGame::Boot::COLORS[:dark]

        for mothership in motherships
          draw_mothership_button mothership
        end

        button('rescan') {
          select_game_screen
        }
      end
    rescue DRb::DRbConnError
      state = :select_game
      select_game_screen
    end

    ##
    # The pirate pub screen where you wait to start a game

    def pub_screen
      @stage_animation.remove if @stage_animation
      @items_animation.stop if @items_animation

      @pub_tagline ||= "Welcome #{@client.name}"

      clear do
        background PirateGame::Boot::COLORS[:pub]
        stack :margin => 20 do
          title "Pirate Pub", stroke: PirateGame::Boot::COLORS[:light]
          tagline @pub_tagline, stroke: PirateGame::Boot::COLORS[:light]

          stack do @status = para '', stroke: PirateGame::Boot::COLORS[:light] end

          @registered = nil
          @updating_area = stack
          stack do
            @chat_title = tagline 'Pub Chat', stroke: PirateGame::Boot::COLORS[:light]
            @chat_input = flow
            @chat_messages = stack
          end
        end

        # checks for registration changes
        # updates chat messages
        @pub_animation = animate(5) {
          if @client

            # updates screen only when registration state changes
            update_on_registration_change

            # updates screen, runs every time
            update_chat_room
          end
        }
      end
    rescue DRb::DRbConnError
      state = :select_game
      select_game_screen
    end

    ##
    # The screen where the game occurs

    def stage_screen
      @pub_animation.remove if @pub_animation
      @items_animation.start if @items_animation

      # if we get back to pub then stage was success
      @pub_tagline = 'SUCCESS!'

      pirate_ship do
        title PirateCommand.exclaim!, stroke: PirateGame::Boot::COLORS[:dark]

        @instruction = caption stroke: PirateGame::Boot::COLORS[:dark]
        @progress = progress

        @client.bridge.items.each_slice(3).with_index do |items, row|
          items.each_with_index do |item, column|
            bridge_button =
              PirateGame::BridgeButton.new self, item, row, column do
                @client.clicked item
              end

            @background.add_extra_item bridge_button
          end
        end
      end

      @stage_animation = animate(10) {
        @client.issue_command unless @client.waiting?

        @instruction.replace @client.current_action

        progress_fraction = (@client.action_time_left.to_f / @client.completion_time.to_f)
        @progress.fraction = progress_fraction
      }
    rescue DRb::DRbConnError
      state = :select_game
      select_game_screen
    end

    ##
    # The end-game screen

    def end_screen
      @pub_animation.remove if @pub_animation
      @stage_animation.remove if @stage_animation
      @items_animation.stop if @items_animation

      clear do
        jolly_roger = File.expand_path '../../../imgs/jolly_roger_sm.png', __FILE__
        background PirateGame::Boot::COLORS[:dark]
        background jolly_roger, height: 256
        background rgb(0, 0, 0, 180)

        stack margin: 20 do

          title "END OF GAME", stroke: PirateGame::Boot::COLORS[:light]

          if @client.slop_bucket[:end_game]
            game_stats = @client.slop_bucket[:end_game]
            para "Game Stats", stroke: PirateGame::Boot::COLORS[:light]
            para "Total Stages Completed: #{game_stats[:total_stages]}", stroke: PirateGame::Boot::COLORS[:light]
            para "Total Actions: #{game_stats[:total_actions]}", stroke: PirateGame::Boot::COLORS[:light]
            para "My Contribution: #{game_stats[:player_breakdown][DRb.uri]}", stroke: PirateGame::Boot::COLORS[:light]
          end
        end
      end
    rescue DRb::DRbConnError
      state = :select_game
      select_game_screen
    end

    ##
    # If the registration state has changed, yields to the block.

    def detect_registration_change
      return if @client.registered? == @registered

      @registered = @client.registered?

      @status.replace "#{"Not " unless @registered}Registered"

      yield
    end

    ##
    # Updates the chat messages with new messages

    def update_chat_room
      if @registered
        @chat_messages.clear do
          for msg, name in @client.log_book
            para "#{name} said: #{msg}", stroke: PirateGame::Boot::COLORS[:light]
          end
        end
      end
    end

    ##
    # Updates the registration view in the pub screen

    def update_on_registration_change
      detect_registration_change do
        @updating_area.clear do
          button("Register") { register } unless @registered
        end

        # chat input box only appears when registered
        @chat_input.clear do
          if @registered
            el = edit_line

            button("Send") {
              unless el.text.empty?
                @client.broadcast(el.text)
                el.text = ''
              end
            }
          end
        end
      end
    end

    ##
    # Draws a button for joining a game playing on +mothership+

    def draw_mothership_button mothership
      button(mothership[:name]) {|b|
        begin
          @client.initiate_communication_with_mothership(b.text)
          @client.register
        rescue
          select_game_screen
        end
      }
    end

    ##
    # Registers the client with a game master

    def register
      @client.register if @client
    end

    ##
    # Unregisters a game with a game master

    def unregister
      @client.unregister if @client
    end

    @client = nil
    create_items
    animate_items
    launch_screen
  end
ensure
  @my_app.unregister if @my_app
end