game_2d 0.0.1

data/lib/game_2d/game_window.rb

@@ -0,0 +1,260 @@
+## Author: Greg Meyers
+## License: Same as for Gosu (MIT)
+
+require 'rubygems'
+require 'gosu'
+
+require 'game_2d/client_connection'
+require 'game_2d/client_engine'
+require 'game_2d/game_space'
+require 'game_2d/entity'
+require 'game_2d/player'
+require 'game_2d/menu'
+require 'game_2d/zorder'
+
+SCREEN_WIDTH = 640  # in pixels
+SCREEN_HEIGHT = 480 # in pixels
+
+DEFAULT_PORT = 4321
+
+# The Gosu::Window is always the "environment" of our game
+# It also provides the pulse of our game
+class GameWindow < Gosu::Window
+  attr_reader :animation, :font
+  attr_accessor :player_id
+
+  def initialize(player_name, hostname, port=DEFAULT_PORT, profile=false)
+    @conn_update_total = @engine_update_total = 0.0
+    @conn_update_count = @engine_update_count = 0
+    @profile = profile
+
+    super(SCREEN_WIDTH, SCREEN_HEIGHT, false, 16)
+    self.caption = "Ruby Gosu Game"
+
+    @pressed_buttons = []
+
+    @background_image = Gosu::Image.new(self, media("Space.png"), true)
+    @animation = Hash.new do |h, k|
+      h[k] = Gosu::Image::load_tiles(
+        self, k, Entity::CELL_WIDTH_IN_PIXELS, Entity::CELL_WIDTH_IN_PIXELS, false)
+    end
+
+    @cursor_anim = @animation[media("crosshair.gif")]
+
+    @beep = Gosu::Sample.new(self, media("Beep.wav")) # not used yet
+
+    @font = Gosu::Font.new(self, Gosu::default_font_name, 20)
+
+    # Local settings
+    @local = {
+      :create_npc => {
+        :type => 'Entity::Block',
+        :hp   => 5,
+        :snap => false,
+      },
+    }
+    snap_text = lambda do |item|
+      @local[:create_npc][:snap] ? "Turn snap off" : "Turn snap on"
+    end
+
+    object_type_submenus = [
+      ['Dirt',       'Entity::Block',    5],
+      ['Brick',      'Entity::Block',    10],
+      ['Cement',     'Entity::Block',    15],
+      ['Steel',      'Entity::Block',    20],
+      ['Unlikelium', 'Entity::Block',    25],
+      ['Titanium',   'Entity::Titanium', 0]
+    ].collect do |type_name, class_name, hp|
+      MenuItem.new(type_name, self, @font) do |item|
+        @local[:create_npc][:type] = class_name
+        @local[:create_npc][:hp] = hp
+      end
+    end
+    object_type_menu = Menu.new('Object type', self, @font,
+      *object_type_submenus)
+
+    object_creation_menu = Menu.new('Object creation', self, @font,
+      MenuItem.new('Object type', self, @font) { object_type_menu },
+      MenuItem.new(snap_text, self, @font) do
+        @local[:create_npc][:snap] = !@local[:create_npc][:snap]
+      end,
+      MenuItem.new('Save!', self, @font) { @conn.send_save }
+    )
+    main_menu = Menu.new('Main menu', self, @font,
+      MenuItem.new('Object creation', self, @font) { object_creation_menu },
+      MenuItem.new('Quit!', self, @font) { shutdown }
+    )
+    @menu = @top_menu = MenuItem.new('Click for menu', self, @font) { main_menu }
+
+    # Connect to server and kick off handshaking
+    # We will create our player object only after we've been accepted by the server
+    # and told our starting position
+    @conn = ClientConnection.new(hostname, port, self, player_name)
+    @engine = @conn.engine = ClientEngine.new(self)
+    @run_start = Time.now.to_f
+    @update_count = 0
+  end
+
+  def media(filename)
+    "#{File.dirname __FILE__}/../../media/#{filename}"
+  end
+
+  def space
+    @engine.space
+  end
+
+  def player
+    space[@player_id]
+  end
+
+  def update
+    @update_count += 1
+
+    # Handle any pending ENet events
+    before_t = Time.now.to_f
+    @conn.update
+    if @profile
+      @conn_update_total += (Time.now.to_f - before_t)
+      @conn_update_count += 1
+      $stderr.puts "@conn.update() averages #{@conn_update_total / @conn_update_count} seconds each" if (@conn_update_count % 60) == 0
+    end
+    return unless @conn.online? && @engine
+
+    before_t = Time.now.to_f
+    @engine.update
+    if @profile
+      @engine_update_total += (Time.now.to_f - before_t)
+      @engine_update_count += 1
+      $stderr.puts "@engine.update() averages #{@engine_update_total / @engine_update_count} seconds" if (@engine_update_count % 60) == 0
+    end
+
+    # Player at the keyboard queues up a command
+    # @pressed_buttons is emptied by handle_input
+    handle_input if @player_id
+
+    $stderr.puts "Updates per second: #{@update_count / (Time.now.to_f - @run_start)}" if @profile
+  end
+
+  def draw
+    @background_image.draw(0, 0, ZOrder::Background)
+    return unless @player_id
+    @camera_x, @camera_y = space.good_camera_position_for(player, SCREEN_WIDTH, SCREEN_HEIGHT)
+    translate(-@camera_x, -@camera_y) do
+      (space.players + space.npcs).each {|entity| entity.draw(self) }
+    end
+
+    space.players.sort.each_with_index do |player, num|
+      @font.draw("#{player.player_name}: #{player.score}", 10, 10 * (num * 2 + 1), ZOrder::Text, 1.0, 1.0, Gosu::Color::YELLOW)
+    end
+
+    @menu.draw
+
+    cursor_img = @cursor_anim[Gosu::milliseconds / 50 % @cursor_anim.size]
+    cursor_img.draw(
+      mouse_x - cursor_img.width / 2.0,
+      mouse_y - cursor_img.height / 2.0,
+      ZOrder::Cursor,
+      1, 1, Gosu::Color::WHITE, :add)
+  end
+
+  def draw_box_at(x1, y1, x2, y2, c)
+    draw_quad(x1, y1, c, x2, y1, c, x2, y2, c, x1, y2, c, ZOrder::Highlight)
+  end
+
+  def button_down(id)
+    case id
+      when Gosu::KbP then @conn.send_ping
+      when Gosu::KbEscape then @menu = @top_menu
+      when Gosu::MsLeft then # left-click
+        if new_menu = @menu.handle_click
+          # If handle_click returned anything, the menu consumed the click
+          # If it returned a menu, that's the new one we display
+          @menu = (new_menu.respond_to?(:handle_click) ? new_menu : @top_menu)
+        else
+          send_fire
+        end
+      when Gosu::MsRight then # right-click
+        send_create_npc
+      else @pressed_buttons << id
+    end
+  end
+
+  def send_fire
+    return unless @player_id
+    x, y = mouse_coords
+    x_vel = (x - (player.x + Entity::WIDTH / 2)) / Entity::PIXEL_WIDTH
+    y_vel = (y - (player.y + Entity::WIDTH / 2)) / Entity::PIXEL_WIDTH
+    @conn.send_move :fire, :x_vel => x_vel, :y_vel => y_vel
+  end
+
+  # X/Y position of the mouse (center of the crosshairs), adjusted for camera
+  def mouse_coords
+    # For some reason, Gosu's mouse_x/mouse_y return Floats, so round it off
+    [
+      (mouse_x.round + @camera_x) * Entity::PIXEL_WIDTH,
+      (mouse_y.round + @camera_y) * Entity::PIXEL_WIDTH
+    ]
+  end
+
+  def send_create_npc
+    x, y = mouse_coords
+
+    if @local[:create_npc][:snap]
+      # When snap is on, we want the upper-left corner of the cell we clicked in
+      x = (x / Entity::WIDTH) * Entity::WIDTH
+      y = (y / Entity::HEIGHT) * Entity::HEIGHT
+    else
+      # When snap is off, we want the click to be the new entity's center, not
+      # its upper-left corner
+      x -= Entity::WIDTH / 2
+      y -= Entity::HEIGHT / 2
+    end
+
+    @conn.send_create_npc(
+      :class => @local[:create_npc][:type],
+      :position => [x, y],
+      :velocity => [0, 0],
+      :angle => 0,
+      :moving => true,
+      :hp => @local[:create_npc][:hp]
+    )
+  end
+
+  def shutdown
+    @conn.disconnect
+    close
+  end
+
+  # Dequeue an input event
+  def handle_input
+    return if player.falling?
+    move = move_for_keypress
+    @conn.send_move move # also creates a delta in the engine
+  end
+
+  # Check keyboard, return a motion symbol or nil
+  #
+  #
+  def move_for_keypress
+    # Generated once for each keypress
+    until @pressed_buttons.empty?
+      button = @pressed_buttons.shift
+      case button
+        when Gosu::KbUp, Gosu::KbW
+          return (player.building?) ? :rise_up : :flip
+      end
+    end
+
+    # Continuously-generated when key held down
+    case
+      when button_down?(Gosu::KbLeft), button_down?(Gosu::KbA)
+        :slide_left
+      when button_down?(Gosu::KbRight), button_down?(Gosu::KbD)
+        :slide_right
+      when button_down?(Gosu::KbRightControl), button_down?(Gosu::KbLeftControl)
+        :brake
+      when button_down?(Gosu::KbDown), button_down?(Gosu::KbS)
+        :build
+    end
+  end
+end

data/lib/game_2d/hash.rb

@@ -0,0 +1,11 @@
+require 'facets/array/recurse'
+require 'facets/hash/recurse'
+require 'facets/hash/symbolize_keys'
+
+class Hash
+  def fix_keys
+    recurse(Hash, Array) do |x|
+      x.is_a?(Hash) ? x.symbolize_keys : x
+    end
+  end
+end

data/lib/game_2d/menu.rb

@@ -0,0 +1,82 @@
+require 'gosu'
+require 'game_2d/zorder'
+
+class Menu
+  def initialize(name, window, font, *choices)
+    @name, @window, @font, @choices = name, window, font, choices
+
+    @main_color, @select_color = Gosu::Color::YELLOW, Gosu::Color::CYAN
+    @right = window.width - 1
+    @choices.each_with_index do |choice, num|
+      choice.x = @right
+      choice.y = (num + 2) * 20
+    end
+  end
+
+  def draw
+    str = to_s
+    @font.draw_rel(str, @window.width - 1, 0, ZOrder::Text, 1.0, 0.0, 1.0, 1.0,
+      @main_color)
+    x1, x2, y, c = @right - @font.text_width(str), @right, 20, @main_color
+    @window.draw_box_at(x1, y, x2, y+1, @main_color)
+    @choices.each(&:draw)
+  end
+
+  # Returns a true value if it handled the click
+  # May return a Menu or MenuItem to be set as the new menu to display
+  # May return simply 'true' if we should redisplay the top-level menu
+  def handle_click
+    @choices.collect(&:handle_click).compact.first
+  end
+
+  def to_s
+    @name.respond_to?(:call) ? @name.call(self) : @name.to_s
+  end
+end
+
+class MenuItem
+  attr_accessor :x, :y, :name
+  def initialize(name, window, font, &action)
+    @name, @window, @font, @action = name, window, font, action
+    @main_color, @select_color, @highlight_color =
+      Gosu::Color::YELLOW, Gosu::Color::BLACK, Gosu::Color::CYAN
+
+    # Default position: Upper-right corner
+    @x, @y = @window.width - 1, 0
+  end
+
+  def mouse_over?
+    x, y = @window.mouse_x, @window.mouse_y
+    (y >= top) && (y < bottom) && (x > left)
+  end
+
+  def left; @x - @font.text_width(to_s); end
+  def right; @x; end
+  def top; @y; end
+  def bottom; @y + 20; end
+
+  def draw
+    selected = mouse_over?
+    color = choose_color(selected)
+    @font.draw_rel(to_s, @x, @y, ZOrder::Text, 1.0, 0.0, 1.0, 1.0, color)
+    if selected
+      @window.draw_box_at(left, top, right, bottom, @highlight_color)
+    end
+  end
+
+  def choose_color(selected)
+    selected ? @select_color : @main_color
+  end
+
+  # Returns a true value if it handled the click
+  # May return a Menu or MenuItem to be set as the new menu to display
+  # May return simply 'true' if we should redisplay the top-level menu
+  def handle_click
+    return unless mouse_over?
+    @action.call(self) || true
+  end
+
+  def to_s
+    @name.respond_to?(:call) ? @name.call(self) : @name.to_s
+  end
+end

data/lib/game_2d/move/rise_up.rb

@@ -0,0 +1,77 @@
+require 'game_2d/complex_move'
+require 'game_2d/entity_constants'
+
+module Move
+
+class RiseUp < ComplexMove
+  include EntityConstants
+
+  # Valid stages: :center, :rise, :reset
+  # Distance is how much further we need to go
+  # (in pixels) in stage :rise
+  attr_accessor :stage, :distance
+  def initialize(actor=nil)
+    super
+    @stage = :center
+  end
+
+  def on_completion(actor)
+    actor.instance_exec { @x_vel = @y_vel = 0 }
+  end
+
+  def update(actor)
+    # It's convenient to set 'self' to the Player
+    # object, here
+    actor.instance_exec(self) do |cm|
+      # Abort if the build_block gets destroyed
+      blok = build_block
+      return false unless blok
+
+      start_x, start_y = blok.x, blok.y
+      case cm.stage
+      when :center, :reset
+        if x == start_x && y == start_y
+          # If we're in reset, we're all done
+          return false if cm.stage == :reset
+
+          # Establish our velocity for :rise
+          cm.stage = :rise
+          @x_vel, @y_vel = angle_to_vector(a, PIXEL_WIDTH)
+          cm.distance = CELL_WIDTH_IN_PIXELS
+          return cm.update(self)
+        end
+        @x_vel = [[start_x - x, -PIXEL_WIDTH].max, PIXEL_WIDTH].min
+        @y_vel = [[start_y - y, -PIXEL_WIDTH].max, PIXEL_WIDTH].min
+        # move returns false: it failed somehow
+        return move
+      when :rise
+        # Success
+        return false if cm.distance.zero?
+
+        cm.distance -= 1
+        # move fails? Go to :reset
+        move || (cm.stage = :reset)
+        return true
+      end
+    end
+  end
+
+  def all_state
+    super.push @stage, @distance
+  end
+  def as_json
+    super.merge! :stage => @stage,
+      :distance => @distance
+  end
+  def update_from_json(json)
+    self.stage = json[:stage].to_sym
+    self.distance = json[:distance]
+    super
+  end
+  def to_s
+    "RiseUp[#{stage}, #{distance} to go]"
+  end
+
+end
+
+end

data/lib/game_2d/player.rb

@@ -0,0 +1,251 @@
+require 'facets/kernel/try'
+require 'gosu'
+require 'game_2d/entity'
+require 'game_2d/entity/pellet'
+require 'game_2d/entity/block'
+require 'game_2d/move/rise_up'
+require 'game_2d/zorder'
+
+# The base Player class representing what all Players have in common
+# Moves can be enqueued by calling add_move
+# Calling update() causes a move to be dequeued and executed, applying forces
+# to the game object
+#
+# The server instantiates this class to represent each connected player
+class Player < Entity
+  include Comparable
+
+  # Game ticks it takes before a block's HP is raised by 1
+  BUILD_TIME = 7
+
+  # Amount to decelerate each tick when braking
+  BRAKE_SPEED = 4
+
+  attr_accessor :player_name, :score
+  attr_reader :build_block_id
+
+  def initialize(player_name = "<unknown>")
+    super
+    @player_name = player_name
+    @score = 0
+    @moves = []
+    @current_move = nil
+    @falling = false
+    @build_block_id = nil
+    @build_level = 0
+    @complex_move = nil
+  end
+
+  def sleep_now?; false; end
+
+  def falling?; @falling; end
+
+  def build_block_id=(new_id)
+    @build_block_id = new_id.try(:to_sym)
+  end
+
+  def building?; @build_block_id; end
+
+  def build_block
+    return nil unless building?
+    fail "Can't look up build_block when not in a space" unless @space
+    @space[@build_block_id] or fail "Don't have build_block #{@build_block_id}"
+  end
+
+  def destroy!
+    build_block.owner_id = nil if building?
+  end
+
+  # Pellets don't hit the originating player
+  def transparent_to_me?(other)
+    super ||
+    (other == build_block) ||
+    (other.is_a?(Pellet) && other.owner == self)
+  end
+
+  def update
+    fail "No space set for #{self}" unless @space
+    check_for_disown_block
+
+    if @complex_move
+      # returns true if more work to do
+      return if @complex_move.update(self)
+      @complex_move.on_completion(self)
+      @complex_move = nil
+    end
+
+    underfoot = next_to(self.a + 180)
+    if @falling = underfoot.empty?
+      self.a = 0
+      accelerate(0, 1)
+    end
+
+    args = @moves.shift
+    case (current_move = args.delete(:move).to_sym)
+      when :slide_left, :slide_right, :brake, :flip, :build, :rise_up
+        send current_move unless @falling
+      when :fire
+        fire args[:x_vel], args[:y_vel]
+      else
+        puts "Invalid move for #{self}: #{current_move}, #{args.inspect}"
+    end if args
+
+    # Only go around corner if sitting on exactly one object
+    if underfoot.size == 1
+      other = underfoot.first
+      # Figure out where corner is and whether we're about to reach or pass it
+      corner, distance, overshoot, turn = going_past_entity(other.x, other.y)
+      if corner
+        original_speed = @x_vel.abs + @y_vel.abs
+        original_dir = vector_to_angle
+        new_dir = original_dir + turn
+
+        # Make sure nothing occupies any space we're about to move through
+        if opaque(
+          @space.entities_overlapping(*corner) + next_to(new_dir, *corner)
+        ).empty?
+          # Move to the corner
+          self.x_vel, self.y_vel = angle_to_vector(original_dir, distance)
+          move
+
+          # Turn and apply remaining velocity
+          # Make sure we move at least one subpixel so we don't sit exactly at
+          # the corner, and fall
+          self.a += turn
+          overshoot = 1 if overshoot.zero?
+          self.x_vel, self.y_vel = angle_to_vector(new_dir, overshoot)
+          move
+
+          self.x_vel, self.y_vel = angle_to_vector(new_dir, original_speed)
+        else
+          # Something's in the way -- possibly in front of us, or possibly
+          # around the corner
+          move
+        end
+      else
+        # Not yet reaching the corner -- or making a diagonal motion, for which
+        # we can't support going around the corner
+        move
+      end
+    else
+      # Straddling two objects, or falling
+      move
+    end
+
+    # Check again whether we've moved off of a block
+    # we were building
+    check_for_disown_block
+  end
+
+  def slide_left; slide(self.a - 90); end
+  def slide_right; slide(self.a + 90); end
+
+  def slide(dir)
+    if opaque(next_to(dir)).empty?
+      accelerate(*angle_to_vector(dir))
+    else
+      self.a = dir + 180
+    end
+  end
+
+  def brake
+    if @x_vel.zero?
+      self.y_vel = brake_velocity(@y_vel)
+    else
+      self.x_vel = brake_velocity(@x_vel)
+    end
+  end
+
+  def brake_velocity(v)
+    return 0 if v.abs < BRAKE_SPEED
+    sign = v <=> 0
+    sign * (v.abs - BRAKE_SPEED)
+  end
+
+  def flip
+    self.a += 180
+  end
+
+  # Create the actual pellet
+  def fire(x_vel, y_vel)
+    pellet = Entity::Pellet.new(@x, @y, 0, x_vel, y_vel)
+    pellet.owner = self
+    @space << pellet
+  end
+
+  # Create the actual block
+  def build
+    if building?
+      @build_level += 1
+      if @build_level >= BUILD_TIME
+        @build_level = 0
+        build_block.hp += 1
+      end
+    else
+      bb = Entity::Block.new(@x, @y)
+      bb.owner_id = registry_id
+      bb.hp = 1
+      @space << bb # generates an ID
+      @build_block_id = bb.registry_id
+      @build_level = 0
+    end
+  end
+
+  def disown_block; $stderr.puts "#{self} disowning #{build_block}"; @build_block_id, @build_level = nil, 0; end
+
+  def check_for_disown_block
+    return unless building?
+    return if @space.entities_overlapping(@x, @y).include?(build_block)
+    build_block.owner_id = nil
+    build_block.wake!
+    disown_block
+  end
+
+  def rise_up
+    @complex_move = Move::RiseUp.new(self)
+  end
+
+  # Accepts a hash, with a key :move => move_type
+  def add_move(new_move)
+    return unless new_move
+    @moves << new_move
+  end
+
+  def to_s
+    "#{player_name} (#{registry_id_safe}) at #{x}x#{y}"
+  end
+
+  def all_state
+    super.unshift(player_name).push(
+      score, build_block_id, @complex_move)
+  end
+
+  def as_json
+    super.merge!(
+      :player_name => player_name,
+      :score => score,
+      :build_block => @build_block_id,
+      :complex_move => @complex_move.as_json
+    )
+  end
+
+  def update_from_json(json)
+    @player_name = json[:player_name]
+    @score = json[:score]
+    @build_block_id = json[:build_block].try(:to_sym)
+    @complex_move = Serializable.from_json(json[:complex_move])
+    super
+  end
+
+  def image_filename; "player.png"; end
+
+  def draw_zorder; ZOrder::Player end
+
+  def draw(window)
+    super
+    window.font.draw_rel(player_name,
+      pixel_x + CELL_WIDTH_IN_PIXELS / 2, pixel_y, ZOrder::Text,
+      0.5, 1.0, # Centered X; above Y
+      1.0, 1.0, Gosu::Color::YELLOW)
+  end
+end