game_2d 0.0.1

data/.gitignore

@@ -0,0 +1,15 @@
+*.swp
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in game_2d.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Greg Meyers
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,84 @@
+# Game2d
+
+A 2D sandbox game, using Gosu and REnet.
+
+There's not much here yet, in terms of actual gameplay.  At this point I'm laying the foundation.  What I have so far:
+
+* The server runs at 60 frames a second, to match Gosu.
+* A GameSpace holds a copy of the game's state.  This is primarily a grid populated by Entities.
+* The dimensions of the GameSpace (in cells) are specified on server startup.
+* Each cell in the grid is 40x40 pixels, but is represented as 400x400 internally.  This allows for motion at slow speeds (1 pixel every 10 ticks == 6 pixels per second).
+* Entity positions and velocities are integers.  Apart from player input, all entities' behaviors are predictable.  This allows the client to make accurate predictions of the server state.
+* New Entities are assigned IDs in order, again, to allow the client to predict which ID will be assigned to each new entity.
+* Clients connect using REnet.  The handshaking process creates a Player object to represent the client.
+* Keyboard commands control the player:
+  * A and D, or LeftArrow and RightArrow: Hold down to accelerate.
+  * LeftControl or RightControl: Hold down to brake (slow down).
+  * S, or DownArrow: Hold down to build (the longer you hold, the stronger the block).
+  * W, or UpArrow:
+    * When not building: Flip (turn 180 degrees).
+    * When building: Rise up (ascend to the top of the built block).
+  * Left button: Fire a pellet.  Mouse click determines the direction and speed -- closer to the player means slower speed.
+  * Right button: Build a block where you click.  *(This will eventually become part of a level-editing mode.)*
+* A simple menu system is also available.  Left-click to select.  Esc returns to the top-level.
+* The menus include a Save feature, which tells the server to save the level's state.
+  * Levels are persisted in ~/.game_2d/<level name> as JSON text.
+  * On subsequent startup with the same name, the level is loaded.
+* The client and server communicate using JSON text.  This is undoubtedly inefficient, but aids in debugging at this early stage.
+* Every frame is numbered by the server, and is referred to as a 'tick'.
+* Player actions are both executed locally, and sent to the server.
+* If other players are connected, the server sends everyone's actions to everyone else.
+* Player actions are dated six ticks in the future, to give everyone a chance to get the message early.  That way everyone can execute the action at the same time.
+* The server broadcasts the complete GameSpace four times a second, just in case a client gets out of sync.
+* The client predicts the server state, but treats its own copy as advisory only -- the server's is definitive.
+  * If the server sends something conflicting, the client discards its wrong prediction.
+  * This is intended to compensate for dropped packets or lag, but much more testing is needed.
+
+The physics is (intentionally) pretty simple.  Unsupported objects fall, accelerating downward at a rate of 1/10 pixel per tick per tick.  Blocks assume one of the following forms depending on how many hit points they possess:
+
+* Dirt blocks (1-5 HP) fall unless something is underneath.
+* Brick blocks (6-10 HP) can stay up if supported from both left and right.
+* Cement blocks (11-15 HP) can stay up if supported from *either* left *or* right.
+* Steel blocks (16-20 HP) can stay up if touching anything else, even above.
+* Unlikelium blocks (21-25 HP) never fall.
+
+When building a block, the longer you hold the S or DownArrow key, the more HP will be awarded to the block.  Hitting a block with a pellet reduces its HP, until it degrades to a lower form.  Dirt blocks with 1 HP will be entirely destroyed when hit.
+
+Whether an object is supported depends exclusively on its immediate surroundings.  That means two objects can support each other, and hang suspended.  For example, a dirt block sitting on a steel block will support each other.  A horizontal row of brick, capped at either end with cement, will also be free-standing.
+
+Pellets are fired from the player's center, and are affected by gravity.  They damage whatever they hit first, and disappear.  Pellets won't hit the player who fired them.
+
+There are also Titanium entities, which never fall, and are indestructible.  These are intended for use in designing levels with specific shapes.  They can only be created by using the menu to select Titanium, and then right-clicking.
+
+A player is considered to be supported if their "feet" are touching a block.  Unsupported players will turn feet-downward and fall, until they land on something.  Supported players may slide left or right, and will follow any edges they reach -- going up and down walls, or hanging under ceilings.  The "flip" maneuver swaps head and feet; this becomes useful if the player's head is exactly touching another block.  At all other times, a flip leads to a fall (which can be useful too).
+
+When building a block, the player and the new block occupy the same space.  This is allowed until the player moves off of the block.  After that, the block is considered opaque as usual.  While the block is still "inside" the player, the Rise Up maneuver may be used.  This moves the player headward (which may not be "up"--it depends which way the player is turned) to sit "on top" of the block.  It's possible to use this maneuver to construct a horizontal row of bricks, carefully.
+
+The GameSpace is bounded by invisible, indestructible Wall entities.  These can also support blocks, or the player.
+
+
+## Installation
+
+Install it with:
+
+    $ gem install game_2d
+
+## Usage
+
+This needs streamlining.
+
+Start a server in one window:
+
+    $ game_2d_server.rb -w 50 -h 50 --level example
+
+And a client in another window:
+
+    $ game_2d_client.rb --name Bender --hostname 127.0.0.1
+
+## Contributing
+
+1. Fork it ( https://github.com/sereneiconoclast/game_2d/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/game_2d_client.rb

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+require 'rubygems'
+require 'trollop'
+require 'game_2d/game_window'
+
+opts = Trollop::options do
+  opt :name, "Player name", :type => :string, :required => true
+  opt :hostname, "Hostname of server", :type => :string, :required => true
+  opt :port, "Port number", :default => DEFAULT_PORT
+  opt :profile, "Turn on profiling", :type => :boolean
+  opt :debug_traffic, "Debug network traffic", :type => :boolean
+end
+
+$debug_traffic = opts[:debug_traffic] || false
+
+window = GameWindow.new( opts[:name], opts[:hostname], opts[:port], opts[:profile] )
+window.show

data/bin/game_2d_server.rb

@@ -0,0 +1,21 @@
+#!/usr/bin/env ruby
+require 'rubygems'
+require 'trollop'
+require 'game_2d/game'
+
+opts = Trollop::options do
+  opt :level, "Level name", :type => :string, :required => true
+  opt :width, "Level width", :type => :integer
+  opt :height, "Level height", :type => :integer
+  opt :port, "Port number", :type => :integer
+  opt :storage, "Data storage dir (in home directory)", :type => :string
+  opt :max_clients, "Maximum clients", :type => :integer
+  opt :self_check, "Run data consistency checks", :type => :boolean
+  opt :profile, "Turn on profiling", :type => :boolean
+  opt :debug_traffic, "Debug network traffic", :type => :boolean
+  opt :registry_broadcast_every, "Send registry broadcasts every N frames (0 = never)", :type => :integer
+end
+
+$debug_traffic = opts[:debug_traffic] || false
+
+Game.new(opts).run

data/game_2d.gemspec

@@ -0,0 +1,32 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'game_2d/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "game_2d"
+  spec.version       = Game2d::VERSION
+  spec.authors       = ["Greg Meyers"]
+  spec.email         = ["cmdr.samvimes@gmail.com"]
+  spec.summary       = %q{Client/server sandbox game using Gosu and REnet}
+  spec.description   = %q{Client/server sandbox game using Gosu and REnet}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+  spec.required_ruby_version = ">= 1.9.3"
+
+  spec.add_runtime_dependency "facets", [">= 2.9.3"]
+  spec.add_runtime_dependency "gosu", [">= 0.8.5"]
+  spec.add_runtime_dependency "json", [">= 1.8.1"]
+  spec.add_runtime_dependency "renet", [">= 0.1.14"]
+  spec.add_runtime_dependency "trollop", [">= 2.0"]
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rr", "~> 1.1.2"
+  spec.add_development_dependency "rspec", "~> 3.1.0"
+end

data/lib/game_2d/client_connection.rb

@@ -0,0 +1,127 @@
+require 'renet'
+require 'json'
+require 'game_2d/hash'
+
+# The client creates one of these.
+# It is then used for all communication with the server.
+
+class ClientConnection
+  attr_reader :player_name
+  attr_accessor :engine
+
+  # We tell the server to execute all actions this many ticks
+  # in the future, to give the message time to propagate around
+  # the fleet
+  ACTION_DELAY = 6 # 1/10 of a second
+
+  def initialize(host, port, game, player_name, timeout=2000)
+    # remote host address, remote host port, channels, download bandwidth, upload bandwidth
+    @socket = _create_connection(host, port, 2, 0, 0)
+    @game = game
+    @player_name = player_name
+
+    @socket.on_connection(method(:on_connect))
+    @socket.on_disconnection(method(:on_close))
+    @socket.on_packet_receive(method(:on_packet))
+
+    @socket.connect(timeout)
+  end
+
+  def _create_connection(*args)
+    ENet::Connection.new(*args)
+  end
+
+  def on_connect
+    puts "Connected to server - sending handshake"
+    # send handshake reliably
+    send_record( { :handshake => { :player_name => @player_name } }, true)
+  end
+
+  def on_close
+    puts "Client disconnected by server"
+    @game.shutdown
+  end
+
+  def on_packet(data, channel)
+    hash = JSON.parse(data).fix_keys
+    debug_packet('Received', hash)
+
+    pong = hash[:pong]
+    if pong
+      stop = Time.now.to_f
+      puts "Ping took #{stop - pong[:start]} seconds"
+    end
+
+    at_tick = hash[:at_tick]
+    fail "No at_tick in #{hash.inspect}" unless at_tick
+
+    world = hash[:world]
+    if world
+      @engine.establish_world(world, at_tick)
+    end
+
+    delta_keys = [
+      :add_players, :add_npcs, :delete_entities, :update_entities, :update_score, :move
+    ]
+    @engine.add_delta(hash) if delta_keys.any? {|k| hash.has_key? k}
+
+    you_are = hash[:you_are]
+    if you_are
+      # The 'world' response includes deltas for add_players and add_npcs
+      # Need to process those first, as one of the players is us
+      @engine.apply_all_deltas(at_tick)
+
+      @engine.create_local_player you_are
+    end
+
+    registry, highest_id = hash[:registry], hash[:highest_id]
+    @engine.sync_registry(registry, highest_id, at_tick) if registry
+  end
+
+  def send_actions_at
+    @engine.tick + ACTION_DELAY
+  end
+
+  def send_move(move, args={})
+    return unless move
+    args[:move] = move.to_s
+    delta = { :at_tick => send_actions_at, :move => args }
+    send_record delta
+    delta[:move][:player_id] = @engine.player_id
+    @engine.add_delta delta
+  end
+
+  def send_create_npc(npc)
+    delta = { :at_tick => send_actions_at, :create_npc => npc }
+    send_record delta
+    @engine.add_delta delta
+  end
+
+  def send_save
+    send_record :save => true
+  end
+
+  def send_ping
+    send_record :ping => { :start => Time.now.to_f }
+  end
+
+  def send_record(data, reliable=false)
+    debug_packet('Sending', data)
+    @socket.send_packet(data.to_json, reliable, 0)
+    @socket.flush
+  end
+
+  def debug_packet(direction, hash)
+    return unless $debug_traffic
+    at_tick = hash[:at_tick] || 'NO TICK'
+    keys = hash.keys - [:at_tick]
+    puts "#{direction} #{keys.join(', ')} <#{at_tick}>"
+  end
+
+  def update
+    @socket.update(0) # non-blocking
+  end
+
+  def online?; @socket.online?; end
+  def disconnect; @socket.disconnect(200); end
+end

data/lib/game_2d/client_engine.rb

@@ -0,0 +1,227 @@
+require 'set'
+require 'game_2d/game_space'
+require 'game_2d/serializable'
+
+# Server sends authoritative copy of GameSpace for tick T0.
+# We store that, along with pending moves generated by
+# our player, and pending moves for other players sent to us
+# by the server.  Then we calculate further ticks of action.
+# These are predictions and might well be wrong.
+#
+# When the user requests an action at T0, we delay it by 100ms
+# (T6).  We tell the server about it immediately, but advise
+# it not to perform the action until T6 arrives.  The server
+# rebroadcasts this information to other players.  Hopefully,
+# everyone receives all players' actions before T6.
+#
+# We render one tick after another, 60 per second, the same
+# speed at which the server calculates them.  But because we
+# may get out of sync, we also watch for full server updates
+# at, e.g., T15.  When we get a new full update, we can discard
+# all information about older ticks.  Anything we've calculated
+# past the new update must now be recalculated, applying again
+# whatever pending player actions we have heard about.
+class ClientEngine
+  # If we haven't received a full update from the server in this
+  # many ticks, stop guessing.  We're almost certainly wrong by
+  # this point.
+  MAX_LEAD_TICKS = 30
+
+  attr_reader :tick
+
+  def initialize(game_window)
+    @game_window, @width, @height = game_window, 0, 0
+    @spaces = {}
+    @deltas = Hash.new {|h,tick| h[tick] = Array.new}
+    @earliest_tick = @tick = @preprocessed = nil
+  end
+
+  def establish_world(world, at_tick)
+    @world_name, @world_id = world[:world_name], world[:world_id]
+    @width, @height = world[:cell_width], world[:cell_height]
+    highest_id = world[:highest_id]
+    create_initial_space(at_tick, highest_id)
+  end
+
+  def create_initial_space(at_tick, highest_id)
+    @earliest_tick = @tick = at_tick
+    space = @spaces[@tick] = GameSpace.new.establish_world(@world_name, @world_id, @width, @height)
+    space.highest_id = highest_id
+    space
+  end
+
+  def space_at(tick)
+    return @spaces[tick] if @spaces[tick]
+
+    fail "Can't create space at #{tick}; earliest space we know about is #{@earliest_tick}" if tick < @earliest_tick
+
+    last_space = space_at(tick - 1)
+    @spaces[tick] = new_space = GameSpace.new.copy_from(last_space)
+
+    # Certain deltas, like add_npcs, need to be processed post-update
+    # to match the server's behavior.  An object created during tick T
+    # does not receive its first update until T+1.
+    apply_deltas_before_update(tick)
+    new_space.update
+    apply_deltas_after_update(tick)
+
+    new_space
+  end
+
+  def update
+    return unless @tick # handshake not yet answered
+
+    # Display the frame we received from the server as-is
+    if @preprocessed == @tick
+      @preprocessed = nil
+      return space_at(@tick)
+    end
+
+    if @tick - @earliest_tick >= MAX_LEAD_TICKS
+      $stderr.puts "Lost connection?  Running ahead of server?"
+      return space_at(@tick)
+    end
+    space_at(@tick += 1)
+  end
+
+  def space
+    @spaces[@tick]
+  end
+
+  def create_local_player(player_id)
+    old_player_id = @game_window.player_id
+    fail "Already have player #{old_player_id}!?" if old_player_id
+
+    @game_window.player_id = player_id
+    puts "I am player #{player_id}"
+  end
+
+  def player_id
+    @game_window.player_id
+  end
+
+  def add_delta(delta)
+    at_tick = delta.delete :at_tick
+    if at_tick < @tick
+      $stderr.puts "Received delta #{@tick - at_tick} ticks late"
+      if at_tick <= @earliest_tick
+        $stderr.puts "Discarding it - we've received registry sync at <#{@earliest_tick}>"
+        return
+      end
+      # Invalidate old spaces that were generated without this information
+      at_tick.upto(@tick) {|old_tick| @spaces.delete old_tick}
+    end
+    @deltas[at_tick] << delta
+  end
+
+  def apply_deltas_before_update(at_tick)
+    space = space_at(at_tick)
+
+    @deltas[at_tick].each do |hash|
+      players = hash[:add_players]
+      add_players(space, players) if players
+
+      doomed = hash[:delete_entities]
+      delete_entities(space, doomed) if doomed
+
+      updated = hash[:update_entities]
+      update_entities(space, updated) if updated
+
+      move = hash[:move]
+      apply_move(space, move) if move
+
+      score_update = hash[:update_score]
+      update_score(space, score_update) if score_update
+    end
+  end
+
+  def apply_deltas_after_update(at_tick)
+    space = space_at(at_tick)
+
+    @deltas[at_tick].each do |hash|
+      npcs = hash[:add_npcs]
+      add_npcs(space, npcs) if npcs
+    end
+
+    # Any later spaces are now invalid
+    @spaces.delete_if {|key, _| key > at_tick}
+  end
+
+  def apply_all_deltas(at_tick)
+    apply_deltas_before_update(at_tick)
+    apply_deltas_after_update(at_tick)
+  end
+
+  def add_player(space, hash)
+    player = Serializable.from_json(hash)
+    puts "Added player #{player}"
+    space << player
+    player.registry_id
+  end
+
+  def add_players(space, players)
+    players.each {|json| add_player(space, json) }
+  end
+
+  def apply_move(space, move)
+    player_id = move[:player_id]
+    player = space[player_id]
+    fail "No such player #{player_id}, can't apply #{move.inspect}" unless player
+    player.add_move move
+  end
+
+  def add_npcs(space, npcs)
+    npcs.each {|json| space << Serializable.from_json(json) }
+  end
+
+  def add_entity(space, json)
+    space << Serializable.from_json(json)
+  end
+
+  # Returns the set of registry IDs updated or added
+  def update_entities(space, updated)
+    registry_ids = Set.new
+    updated.each do |json|
+      registry_id = json[:registry_id]
+      fail "Can't update #{entity.inspect}, no registry_id!" unless registry_id
+      registry_ids << registry_id
+
+      if my_obj = space[registry_id]
+        my_obj.update_from_json(json)
+      else
+        add_entity(space, json)
+      end
+    end
+
+    registry_ids
+  end
+
+  def delete_entities(space, doomed)
+    doomed.each do |registry_id|
+      dead = space[registry_id]
+      next unless dead
+      puts "Disconnected: #{dead}" if dead.is_a? Player
+      space.doom dead
+    end
+    space.purge_doomed_entities
+  end
+
+  def update_score(space, update)
+    registry_id, score = update.to_a.first
+    return unless player = space[registry_id]
+    player.score = score
+  end
+
+  # Discard anything we think we know, in favor of the registry
+  # we just got from the server
+  def sync_registry(server_registry, highest_id, at_tick)
+    @spaces.clear
+    # Any older deltas are now irrelevant
+    @earliest_tick.upto(at_tick - 1) {|old_tick| @deltas.delete old_tick}
+    update_entities(create_initial_space(at_tick, highest_id), server_registry)
+
+    # The server has given us a complete, finished frame.  Don't
+    # create a new one until this one has been displayed once.
+    @preprocessed = at_tick
+  end
+end