gameworks 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ffa430b13432be40c5d7012161ca9ae9d3cc2461
+  data.tar.gz: bd766b49c63da9fbf51686c611371ed979a8e3c2
+SHA512:
+  metadata.gz: 914f509a5940360aaa8d33e1762e6624d07055c5b1e8d511c7c0726bc88dd6d869237242c0ced9d6ae90f9873bab9923256c9b4f9ce003fc7efd123daa1941d0
+  data.tar.gz: 6b90a75243aad00713e1d8dac62331dda700a1673637a40900bb4de718d6ef4548de42d777264a234628e56659a857de586ca37df65f84ac13e1c7ea0e229271

data/Gemfile

@@ -0,0 +1,3 @@
+source "https://rubygems.org"
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,50 @@
+PATH
+  remote: .
+  specs:
+    gameworks (1.0.0)
+      eventmachine (~> 1.0.7)
+      json (~> 1.8.3)
+      rake (~> 10.0)
+      thin (~> 1.6.3)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    daemons (1.2.3)
+    diff-lcs (1.2.5)
+    eventmachine (1.0.7)
+    json (1.8.3)
+    rack (1.6.4)
+    rake (10.4.2)
+    rspec (3.3.0)
+      rspec-core (~> 3.3.0)
+      rspec-expectations (~> 3.3.0)
+      rspec-mocks (~> 3.3.0)
+    rspec-core (3.3.1)
+      rspec-support (~> 3.3.0)
+    rspec-eventmachine (0.2.0)
+      eventmachine (>= 0.12.0)
+      rspec (>= 2.0, < 4.0)
+    rspec-expectations (3.3.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.3.0)
+    rspec-mocks (3.3.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.3.0)
+    rspec-support (3.3.0)
+    thin (1.6.3)
+      daemons (~> 1.0, >= 1.0.9)
+      eventmachine (~> 1.0)
+      rack (~> 1.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.8)
+  gameworks!
+  rspec (~> 3.3.0)
+  rspec-eventmachine (~> 0.2.0)
+
+BUNDLED WITH
+   1.10.3

data/README

@@ -0,0 +1,155 @@
+= Quick start server
+
+Install required gems and run server:
+bundle install
+bundle exec thin start
+
+To run specs:
+bundle exec spec spec
+
+(You will probably already have the gems installed so you probably don't need the 'bundle exec')
+All request and response payloads are serialized JSON data.
+
+= DATA TYPES
+
+== New Player (request)
+
+  {name: <string>}
+
+name of the new player. the game engine may extend this.
+
+== Player (response)
+
+  {name: <string>,
+   score: <integer> or 'disqualified'}
+
+name and current score of the player. the game engine may extend this.
+
+== New Game (request)
+
+determined by the game engine
+
+== Game (response)
+
+  {players: [<Player>*],
+   state: <Game State>}
+
+players is the set of Players joined to the game.
+
+state is the current Game State.
+
+the game engine may extend this.
+
+== Game Delta (response)
+
+  {players: [<Player>*],
+   state: <Game State>}
+
+players is the set of Players whose scores have changed since the request
+began.
+
+state is the current Game State.
+
+the game engine may extend this.
+
+== Game State (response)
+
+  'initiating', 'in play', or 'completed'
+
+See descriptions of game states below.
+
+== New Move (request)
+
+determined by the game engine.
+
+= STARTING A GAME
+
+To spawn a new game on the server, POST to / with a New Game object as payload.
+You will receive a 201 Created response with the game's root path (henceforth
+<game path>) in the Location HTTP response header.
+
+= GAME STATES
+
+== INITIATING
+
+The game begins in this state. You join a game by POSTing to
+<game path>/players with a Player object as payload.
+
+If you successfully join the game, you will receive a 200 OK response at the
+beginning of your first turn, with a Game object as response payload. This
+response will include an X-Turn-Token HTTP response header.
+
+If the game is no longer in this state (i.e. the game is full and has begun)
+when you POST, you will receive a 410 Gone response indicating the game can no
+longer be joined.
+
+Once the game is full the game moves to the in play state.
+
+== IN PLAY
+
+In this state, players POST to <game path>/moves with Line objects as payload.
+These requests must include an X-Turn-Token HTTP request header with the value
+of the last turn token they received from the server.
+
+After receiving a 200 OK response to a <game path>/players or <game path>/moves
+POST request (indicating it is your turn) you are required to POST your next
+move within {{time limit}}. If you fail to POST in that time, you are
+disqualified and the game moves to the completed state.
+
+If the move POSTed is illegal, you will receive an immediate 403 Forbidden
+response describing the violation. You are disqualified and the game moves to
+the completed state.
+
+Otherwise, you will receive a 200 OK response at the beginning of your next
+turn, with a Game Delta object. This response will include an X-Turn-Token
+response header to be used in your next move.
+
+After a 200 OK response, the game may have moved to the completed state. This
+state change will be indicated in the Game Delta object. Once the game is
+completed, further moves are ignored with a 410 Gone response.
+
+== COMPLETED
+
+Play is complete. Game state can still be pulled, but no new POSTs are
+accepted.
+
+= IDEMPOTENT VIEW
+
+At any point, the full game state can be requested with a GET request to
+<game path>. You will receive an immediate 200 OK response with a Game object.
+
+= OBSERVERS
+
+(Intended for use by game viewer, but may be used by others.)
+
+At any point, an observer may be registered by POSTing to <game
+path>/observers. This will begin a long-running unbounded HTTP response of
+type application/x-multi-json , which is a series of one-line json
+documents separated by newlines.
+
+You will receive an immediate 200 OK response with the first document, a
+Game object.  After this, the response will remain open and new Game Delta
+objects will be returned as events occur.
+
+The HTTP response will end when the game ends, after the final Game Delta
+object is sent.
+
+The POST request requires no payload. However, if the payload includes a
+"wrapper" key, then each JSON document will be fprint'ed into that text,
+replacing the first %s. For instance, a HTML comet technique:
+
+    { "wrapper": "<script type='text/javascript'>myUpdater(%s);</script>\n" }
+
+= MATCHMAKING
+
+When you have a bot you'd like to try against others, but you don't want to set
+up a game yourself and you don't care who your opponent is, you can connect
+your bot to our dirt-simple (and stupid) matchmaking system.
+
+Simply GET /match and wait for a response. You will be added to a matchmaking
+queue, and once there are at least two people in the queue, the front two will
+be popped and each given a 302 Redirect with a game's url in the Location HTTP
+response header.
+
+If no one else is joining, feel free to request a match against any of our
+bots! (Our bots are not eligible to win, so don't worry.)

data/Rakefile

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

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "gameworks"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/gameworks.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'gameworks/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "gameworks"
+  spec.version       = Gameworks::VERSION
+  spec.authors       = ["Brian Palmer", "Jacob Fugal", "Travis Elnicky", "Dan Dorman", "Simon Williams"]
+  spec.email         = ["brianp@instructure.com", "jacob@instructure.com", "telnicky@instructure.com", "ddorman@instructure.com", "simon@instructure.com"]
+  spec.summary       = "A game framework"
+  spec.description   = "A ruby game framework used for final problems in instructure mebipenny competitions."
+  spec.homepage      = "https://instructure.github.io"
+
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "bin"
+  spec.executables   = []
+  spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency "rake", "~> 10.0"
+  spec.add_runtime_dependency 'eventmachine', '~> 1.0', '>= 1.0.7'
+  spec.add_runtime_dependency 'json', '~> 1.8', '>= 1.8.3'
+  spec.add_runtime_dependency 'thin', '~> 1.6', '>= 1.6.3'
+
+  spec.add_development_dependency "bundler", "~> 1.8"
+  spec.add_development_dependency 'rspec', '~> 3.3', '>= 3.3.0'
+  spec.add_development_dependency "rspec-eventmachine", "~> 0.2"
+end

data/lib/gameworks.rb

@@ -0,0 +1,2 @@
+require_relative "gameworks/game"
+require_relative "gameworks/server"

data/lib/gameworks/fuse.rb

@@ -0,0 +1,16 @@
+require 'eventmachine'
+
+module Gameworks
+  class Fuse
+    def initialize(seconds)
+      @aborted = false
+      EventMachine::add_timer(seconds) do
+        yield unless @aborted
+      end
+    end
+
+    def abort
+      @aborted = true
+    end
+  end
+end

data/lib/gameworks/game.rb

@@ -0,0 +1,175 @@
+require_relative 'player'
+require_relative 'game_snapshot'
+require_relative 'fuse'
+
+module Gameworks
+  class Game
+    TURN_TIME_LIMIT = 30
+    DEFAULT_DELAY = 0.3
+
+    STATE_INITIATING = 'initiating'
+    STATE_IN_PLAY = 'in play'
+    STATE_COMPLETED = 'completed'
+
+    attr_reader :players, :state, :id, :delay_time
+
+    def initialize(payload={})
+      @players = []
+      @state = STATE_INITIATING
+      @delay_time = payload['delay_time'] || DEFAULT_DELAY
+      @turns = {}
+      @observers = {}
+      @fuses = {}
+      @id = generate_uuid.split('-').first
+    end
+
+    def register_observer(cb)
+      token = generate_uuid
+      @observers[token] = [self.snapshot, cb]
+      token
+    end
+
+    def update_observers(end_game = false)
+      @observers.each do |token, (_, cb)|
+        snapshot = snapshot_for_observer(token)
+        cb.call(delta(snapshot).to_json)
+        cb.succeed if end_game
+      end
+    end
+
+    def snapshot_for_observer(token)
+      snapshot = nil
+      if @observers.has_key?(token)
+        snapshot, cb = @observers[token]
+        @observers[token][0] = self.snapshot
+      end
+      snapshot
+    end
+
+    def player_changed?(player, snapshot, for_player=nil)
+      player.score != snapshot.player_scores[player]
+    end
+
+    def delta(snapshot, for_player=nil)
+      { :players => @players.select{ |p| player_changed?(p, snapshot, for_player) }.map{ |p| p.as_json(for_player) },
+        :state   => @state }
+    end
+
+    def full?
+      raise NotImplementedError
+    end
+
+    def player_class
+      Gameworks::Player
+    end
+
+    def start_if_ready
+      if full?
+        init_game
+        signal_turns
+        update_observers
+      end
+    end
+
+    def add_player(payload={})
+      return false if full?
+
+      player = player_class.new(payload)
+      return false unless player.valid?
+
+      @players << player
+      update_observers
+      player
+    end
+
+    def init_game
+      @players.shuffle!
+      @state = STATE_IN_PLAY
+    end
+
+    def generate_uuid
+      SecureRandom.uuid
+    end
+
+    def active_players
+      raise NotImplementedError
+    end
+
+    def ignore_disqualified_players
+      @players.rotate! while @players.first.disqualified?
+    end
+
+    def signal_turns
+      active_players.each do |player|
+        token = generate_uuid
+        @turns[token] = player
+        @fuses[player].abort if @fuses[player]
+        @fuses[player] = Gameworks::Fuse.new(TURN_TIME_LIMIT) { disqualify(player) }
+        player.signal_turn(token)
+      end
+    end
+
+    def player_for_token(token)
+      @turns.delete(token)
+    end
+
+    def add_move(payload, player)
+      move, error = build_move(payload, player)
+      return false, error unless move
+      legal, error = move_legal?(move, player)
+      return false, error unless legal
+      legal, error = process_move(move, player)
+      return false, error unless legal
+      ignore_disqualified_players
+      update_observers
+      return true
+    end
+
+    def build_move(payload, player)
+      raise NotImplementedError
+    end
+
+    def move_legal?(move, player)
+      raise NotImplementedError
+    end
+
+    def process_move(move, player)
+      raise NotImplementedError
+    end
+
+    def disqualify(player)
+      player.score = 'disqualified'
+      update_observers
+      if @players.select { |p| !p.disqualified? }.size < 2
+        end_game
+      else
+        update_observers
+        end_turn
+      end
+    end
+
+    def end_game
+      @state = STATE_COMPLETED
+      @fuses.values.each(&:abort)
+      update_observers(true)
+      @players.each{ |p| p.signal_turn(nil) }
+    end
+
+    def snapshot_class
+      Gameworks::Game::Snapshot
+    end
+
+    def snapshot
+      snapshot_class.new(self)
+    end
+
+    def as_json(for_player=nil)
+      { :players => @players.map{ |player| player.as_json(for_player) },
+        :state   => @state }
+    end
+
+    def to_json(for_player=nil)
+      as_json(for_player).to_json
+    end
+  end
+end

data/lib/gameworks/game_registry.rb

@@ -0,0 +1,25 @@
+module Gameworks
+  class GameRegistry
+    def initialize
+      @instances = {}
+    end
+
+    def add(game)
+      @instances[game.id] = game
+    end
+
+    def instance(id)
+      @instances[id]
+    end
+
+    def as_json
+      @instances.map do |id, game|
+        { 'id' => game.id, 'state' => game.state }
+      end
+    end
+
+    def to_json
+      as_json.to_json
+    end
+  end
+end

data/lib/gameworks/game_snapshot.rb

@@ -0,0 +1,13 @@
+module Gameworks
+  class Game
+    class Snapshot
+      attr_reader :player_scores, :state
+
+      def initialize(game)
+        @player_scores = {}
+        game.players.each{ |p| @player_scores[p] = p.score }
+        @state = game.state
+      end
+    end
+  end
+end

data/lib/gameworks/player.rb

@@ -0,0 +1,50 @@
+require 'eventmachine'
+
+module Gameworks
+  class Player
+    attr_reader :name
+    attr_accessor :score
+
+    def initialize(payload={})
+      unless payload.is_a?(Hash) &&
+             payload.has_key?('name') &&
+             payload['name'].is_a?(String)
+        @invalid = true
+        return
+      end
+
+      @name = payload['name']
+      @score = 0
+
+      # used for evented "block until it's my turn". the game will push a token
+      # on this queue when it's the player's turn, or will push a nil when the
+      # game is completed
+      @em_queue = EventMachine::Queue.new
+    end
+
+    def valid?
+      !@invalid
+    end
+
+    def disqualified?
+      @score == 'disqualified'
+    end
+
+    def signal_turn(token)
+      @em_queue.push(token)
+    end
+
+    def wait_for_turn
+      @em_queue.pop{ |token| yield token }
+    end
+
+    def as_json(for_player=nil)
+      { :name  => @name,
+        :score => @score }
+    end
+
+    def to_json(for_player=nil)
+      as_json(for_player).to_json
+    end
+  end
+end

data/lib/gameworks/server.rb

@@ -0,0 +1,67 @@
+require 'json'
+require_relative 'game_registry'
+require_relative 'servlet/add_player'
+require_relative 'servlet/add_move'
+require_relative 'servlet/add_observer'
+require_relative 'servlet/game_view'
+require_relative 'servlet/game_list'
+require_relative 'servlet/match_maker'
+
+module Gameworks
+  class Server
+    attr_reader :game_registry
+
+    def initialize
+      @game_registry = Gameworks::GameRegistry.new
+    end
+
+    def game_class
+      raise NotImplementedError
+    end
+
+    def call(env)
+      tokens = {}
+      env.each do |key,value|
+        case key
+        when "HTTP_X_TURN_TOKEN"
+          tokens[:turn] = value
+        when "HTTP_X_OBSERVER_TOKEN"
+          tokens[:observer] = value
+        end
+      end
+      body = env["rack.input"].read
+      unless body.empty?
+        payload = JSON.parse("[#{body}]").first
+      end
+      process_request(
+        :method => env["REQUEST_METHOD"],
+        :path => env["REQUEST_PATH"],
+        :payload => payload,
+        :tokens => tokens,
+        :async_cb => env['async.callback'])
+    end
+
+    def process_request(request={})
+      handler = case request[:path]
+        when %r{^/$}                then Gameworks::Servlet::GameList
+        when %r{^/match$}           then Gameworks::Servlet::MatchMaker
+        when %r{^/[^/]+/?$}         then Gameworks::Servlet::GameView
+        when %r{^/[^/]+/players$}   then Gameworks::Servlet::AddPlayer
+        when %r{^/[^/]+/moves$}     then Gameworks::Servlet::AddMove
+        when %r{^/[^/]+/observers$} then Gameworks::Servlet::AddObserver
+      end
+
+      if handler
+        begin
+          handler.process(self, request)
+        rescue Exception => e
+          puts e.inspect
+          puts e.backtrace
+          [ 500, {}, [] ]
+        end
+      else
+        [ 404, {}, [] ]
+      end
+    end
+  end
+end

data/lib/gameworks/servlet/add_move.rb

@@ -0,0 +1,47 @@
+require_relative 'base'
+
+module Gameworks
+  module Servlet
+    class AddMove < Gameworks::Servlet::Base
+      def POST(request)
+        game_id = request[:path].split('/')[1]
+        game = @server.game_registry.instance(game_id)
+        return [404, {}, ["no such game"]] unless game
+
+        if game.state == Gameworks::Game::STATE_IN_PLAY
+          player = game.player_for_token(request[:tokens][:turn])
+          if player
+            snapshot = game.snapshot
+            legal, error = game.add_move(request[:payload], player)
+            if legal
+              player.wait_for_turn do |turn_token|
+                EventMachine.add_timer(game.delay_time) do
+                  request[:async_cb].call [ 200, {
+                    'Content-Type' => 'application/json',
+                    'X-Turn-Token' => turn_token
+                  }, [game.delta(snapshot, player).to_json] ]
+                end
+              end
+              [-1, {}, []]
+            else
+              # invalid move!
+              game.disqualify(player)
+              [403, {}, ["invalid move: #{error}. disqualified!"]]
+            end
+          else
+            # not your turn!
+            [403, {}, ["invalid/missing turn token"]]
+          end
+        else
+          if game.state == Gameworks::Game::STATE_INITIATING
+            # not yet allowed
+            [403, {}, ["game not yet started"]]
+          else
+            # no longer available
+            [410, {}, ["game finished"]]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/gameworks/servlet/add_observer.rb

@@ -0,0 +1,44 @@
+require_relative 'base'
+
+module Gameworks
+  module Servlet
+    class AddObserver < Gameworks::Servlet::Base
+      AsyncResponse = [-1, {}, []].freeze
+
+      class DeferrableBody
+        include EventMachine::Deferrable
+
+        def initialize(wrapper)
+          @wrapper = wrapper || "%s"
+        end
+
+        def call(json_chunk)
+          document = json_chunk.gsub("\n", ' ') + "\n"
+          @body_callback.call(@wrapper % [document])
+        end
+
+        def each(&blk)
+          @body_callback = blk
+        end
+      end
+
+      def POST(request)
+        game_id = request[:path].split('/')[1]
+        game = @server.game_registry.instance(game_id)
+        return [404, {}, ["no such game"]] unless game
+        wrapper = (request[:payload] || {})['wrapper']
+        body = DeferrableBody.new(wrapper)
+        token = game.register_observer(body)
+
+        # application/x-multi-json if a format i just made up,
+        # which is a series of json documents separated by newlines
+        # (there will be no newlines within the json document)
+        request[:async_cb].call [200,
+          {'Content-Type' => 'application/x-multi-json',
+           'X-Observer-Token' => token}, body]
+        body.call(game.to_json)
+        AsyncResponse
+      end
+    end
+  end
+end

data/lib/gameworks/servlet/add_player.rb

@@ -0,0 +1,30 @@
+require_relative 'base'
+
+module Gameworks
+  module Servlet
+    class AddPlayer < Gameworks::Servlet::Base
+      def POST(request)
+        game_id = request[:path].split('/')[1]
+        game = @server.game_registry.instance(game_id)
+        return [404, {}, ["no such game"]] unless game
+
+        if game.state == Gameworks::Game::STATE_INITIATING
+          if player = game.add_player(request[:payload])
+            game.start_if_ready
+            player.wait_for_turn do |turn_token|
+              request[:async_cb].call [ 200, {
+                'Content-Type' => 'application/json',
+                'X-Turn-Token' => turn_token
+              }, [game.to_json(player)] ]
+            end
+            [-1, {}, []]
+          else
+            [403, {}, ["invalid player data"]]
+          end
+        else
+          [410, {}, ["game already started"]]
+        end
+      end
+    end
+  end
+end

data/lib/gameworks/servlet/base.rb

@@ -0,0 +1,22 @@
+module Gameworks
+  module Servlet
+    class Base
+      def initialize(server)
+        @server = server
+      end
+
+      def self.process(server, request)
+        servlet = self.new(server)
+        if servlet.respond_to?(request[:method])
+          servlet.send(request[:method], request)
+        else
+          servlet.method_not_allowed
+        end
+      end
+
+      def method_not_allowed
+        [ 405, { 'Allow' => ['GET', 'POST'].select{ |m| respond_to?(m) }.join(', ') }, [] ]
+      end
+    end
+  end
+end

data/lib/gameworks/servlet/game_list.rb

@@ -0,0 +1,21 @@
+require_relative 'base'
+
+module Gameworks
+  module Servlet
+    class GameList < Gameworks::Servlet::Base
+      def POST(request)
+        game = @server.game_class.new(request[:payload])
+        if game.valid?
+          @server.game_registry.add(game)
+          [201, {'Location' => "/#{game.id}"}, []]
+        else
+          return [403, {}, ["invalid game data"]]
+        end
+      end
+
+      def GET(request)
+        [200, {}, [@server.game_registry.to_json]]
+      end
+    end
+  end
+end

data/lib/gameworks/servlet/game_view.rb

@@ -0,0 +1,24 @@
+require_relative 'base'
+
+module Gameworks
+  module Servlet
+    class GameView < Gameworks::Servlet::Base
+      def GET(request)
+        game_id = request[:path].split('/')[1]
+        game = @server.game_registry.instance(game_id)
+        return [404, {}, ["no such game"]] unless game
+
+        snapshot = nil
+        if request[:tokens][:observer]
+          snapshot = game.snapshot_for_observer(request[:tokens][:observer])
+        end
+
+        if snapshot
+          [ 200, { 'Content-Type' => 'application/json' }, [game.delta(snapshot).to_json] ]
+        else
+          [ 200, { 'Content-Type' => 'application/json' }, [game.to_json] ]
+        end
+      end
+    end
+  end
+end

data/lib/gameworks/servlet/match_maker.rb

@@ -0,0 +1,70 @@
+require_relative 'base'
+
+module Gameworks
+  module Servlet
+    class MatchMaker < Gameworks::Servlet::Base
+      class Promise
+        def initialize
+          @em_queue = EventMachine::Queue.new
+        end
+
+        def demand
+          @em_queue.pop{ |value| yield value }
+        end
+
+        def fulfill(value)
+          @em_queue.push(value)
+        end
+      end
+
+      class << self
+        attr_accessor :server
+
+        SEATS = 2
+
+        # on the class because I want it persistent
+        def request_game(&blk)
+          promise = Promise.new
+          promise.demand(&blk)
+          queue.push(promise)
+        end
+
+        protected
+        def queue
+          unless @queue
+            @queue = EventMachine::Queue.new
+            find_match
+          end
+          @queue
+        end
+
+        def find_match
+          match = []
+          SEATS.times do
+            queue.pop do |request|
+              match << request
+              if match.size == SEATS
+                run_match(match)
+                find_match
+              end
+            end
+          end
+        end
+
+        def run_match(match)
+          game = server.game_class.random('seats' => SEATS)
+          server.game_registry.add(game)
+          match.each{ |request| request.fulfill(game) }
+        end
+      end
+
+      def GET(request)
+        MatchMaker.server ||= @server
+        MatchMaker.request_game do |game|
+          request[:async_cb].call [201, {'Location' => "/#{game.id}"}, []]
+        end
+        [-1, {}, []]
+      end
+    end
+  end
+end

data/lib/gameworks/version.rb

@@ -0,0 +1,3 @@
+module Gameworks
+  VERSION = "1.0.0"
+end

metadata

@@ -0,0 +1,198 @@
+--- !ruby/object:Gem::Specification
+name: gameworks
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Brian Palmer
+- Jacob Fugal
+- Travis Elnicky
+- Dan Dorman
+- Simon Williams
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-07-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: eventmachine
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.7
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.7
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.8.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.8.3
+- !ruby/object:Gem::Dependency
+  name: thin
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.6.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.6.3
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.3'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.3.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.3'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.3.0
+- !ruby/object:Gem::Dependency
+  name: rspec-eventmachine
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+description: A ruby game framework used for final problems in instructure mebipenny
+  competitions.
+email:
+- brianp@instructure.com
+- jacob@instructure.com
+- telnicky@instructure.com
+- ddorman@instructure.com
+- simon@instructure.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- Gemfile.lock
+- README
+- Rakefile
+- bin/console
+- bin/setup
+- gameworks.gemspec
+- lib/gameworks.rb
+- lib/gameworks/fuse.rb
+- lib/gameworks/game.rb
+- lib/gameworks/game_registry.rb
+- lib/gameworks/game_snapshot.rb
+- lib/gameworks/player.rb
+- lib/gameworks/server.rb
+- lib/gameworks/servlet/add_move.rb
+- lib/gameworks/servlet/add_observer.rb
+- lib/gameworks/servlet/add_player.rb
+- lib/gameworks/servlet/base.rb
+- lib/gameworks/servlet/game_list.rb
+- lib/gameworks/servlet/game_view.rb
+- lib/gameworks/servlet/match_maker.rb
+- lib/gameworks/version.rb
+homepage: https://instructure.github.io
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.6
+signing_key: 
+specification_version: 4
+summary: A game framework
+test_files: []
+has_rdoc: