ruby-trade 0.1

data/.gitignore

@@ -0,0 +1,5 @@
+# Vim files
+*.swp
+
+# Compiled gem
+*.gem

data/README.md

@@ -0,0 +1,99 @@
+# Ruby-Trade
+
+Ruby-Trade is a game where each player builds an AI to compete against other AIs 
+in a virtual stock exchange.
+
+The way it works is just like a real stock exchange: you place orders to trade
+into the market to buy or sell shares.
+
+## Installation
+
+Just install the gem (not working just yet)
+
+    gem install ruby-trade
+
+## Lingo
+
+Before getting started, there are a few definitions that you should know about:
+
+* "fill" - An event triggered when one of your orders gets fully executed (that
+  is, all the shares that you requested to buy or sell are bought/sold).
+* "partial fill" - The same as a fill, but not all of the shares in your order
+  were executed. For example if you sent an order to buy 100 shares and someone
+  only sold you 50, it is called a partial fill.
+* "bid" - The highest price of all the buy orders.
+* "ask" - The lowest price of all the sell orders.
+* "last" - The last price that some shares were traded at.
+* "spread" - The difference between the bid and the ask.
+* "position" - The amount of stock that you have. If it is positive then it is
+  called a "long" position, if it is negative then it is called a "short" position.
+  Yes, it is possible to have negative shares.
+* "Level 1" - The bid, the ask, and the last.
+* "Outside the market" - Any buy order with a price less than the bid or any sell
+  order with a price higher than the ask is considered "outside the market."
+
+## Client
+
+Here is an example client:
+
+    require 'ruby-trade'
+
+    class MyApp
+      include RubyTrade::Client
+
+      # Called by the system when we connect to the exchange server
+      def self.on_connect
+        puts "sending order"
+        @buy_order = buy 100, at: 10.0
+      end
+
+      # Called whenever something happens on the exchange
+      def self.on_tick level1
+        puts "Cash: #{cash}"
+        puts "Stock: #{stock}"
+        puts "Bid: #{level1["bid"]}"
+        puts "Ask: #{level1["ask"]}"
+        puts "Last: #{level1["last"]}"
+      end
+
+      # Called when an order gets filled
+      def self.on_fill order, amount, price
+        puts "Order ID #{order.id} was filled for #{amount} shares at $%.2f" % price
+      end
+
+      # Called when an order gets partially filled
+      def self.on_partial_fill order, amount, price
+        puts "Order ID #{order.id} was partially filled for #{amount} shares at $%.2f" % price
+
+        # Cancel the order
+        @buy_order.cancel!
+      end
+
+    end
+
+    # Connect to the server
+    MyApp.connect_to "127.0.0.1", as: "Jim"
+
+## Events
+
+### Dividend
+
+Every half hour, a dividend is paid out. Anybody who has a long position will
+gain cash equal to the dividend times the number of shares that they own; anybody
+with a short position will lose cash equal to the dividend times the number of
+shares that they are short.
+
+### Big Trades
+
+At random times during the trading session, a large trade may be made. These trades
+will be set at some price outside the market, the distance determined randomly.
+These trades do not count towards the score.
+
+### Market Makers
+
+While not really an event, there will be a number of traders in the market who
+are designated as "market makers." They keep buy orders and sell orders a little
+bit outside the market to ensure that there is usually someone there to buy when
+people want to sell, or sell when people want to buy. Note that they are not
+always there, so traders should not rely on them being there. They are not there
+to make money and do not count towards the score.

data/examples/market_maker.rb

@@ -0,0 +1,42 @@
+require "ruby-trade"
+
+TradeAmount = 50_000
+InitialPrice = 10.0
+Distance = 2.0
+
+class Marketmaker
+  include RubyTrade::Client
+
+  def self.on_connect *args
+    puts "Connected."
+
+    update_orders
+
+    this = self
+    EM.add_periodic_timer 5 do
+      this.update_orders
+    end
+  end
+
+  def self.on_tick level1
+    @level1 = level1
+  end
+
+  def self.update_orders
+    @buy_order.cancel! if @buy_order
+    @sell_order.cancel! if @sell_order
+
+    last = @level1 ? @level1[:last] : InitialPrice
+    last ||= InitialPrice
+
+    # buy and sell a certain percentage from the last
+    buy_price = last * (1.0 - Distance / 100)
+    sell_price = last * (1.0 + Distance / 100)
+
+    @buy_order = buy TradeAmount, at: buy_price
+    @sell_order = sell TradeAmount, at: sell_price
+  end
+
+end
+
+Marketmaker.connect_to "127.0.0.1", as: "MarketMaker", ai: true

data/lib/Gemfile

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+
+gem 'zmq'
+gem 'algorithms'
+gem 'json'
+gem 'em-zeromq'

data/lib/Gemfile.lock

@@ -0,0 +1,23 @@
+GEM
+  remote: https://rubygems.org/
+  specs:
+    algorithms (0.6.1)
+    em-zeromq (0.4.2)
+      eventmachine (>= 1.0.0)
+      ffi (>= 1.0.0)
+      ffi-rzmq (~> 1.0.1)
+    eventmachine (1.0.3)
+    ffi (1.9.0)
+    ffi-rzmq (1.0.3)
+      ffi
+    json (1.8.1)
+    zmq (2.1.4)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  algorithms
+  em-zeromq
+  json
+  zmq

data/lib/client.rb

@@ -0,0 +1,203 @@
+require 'socket'
+require 'json'
+require 'em-zeromq'
+
+require_relative "order"
+
+DEFAULT_FEED_PORT = 9000
+DEFAULT_ORDER_PORT = 9001
+
+module RubyTrade
+  module ConnectionClient
+    def self.setup args, parent
+      @@username = args[:as]
+      @@ai = args[:ai] || false
+      @@parent = parent
+    end
+
+    def post_init
+      # identify with the server
+      data = {
+        action: "identify",
+        name: @@username,
+        ai: @@ai
+      }.to_json
+
+      send_data_f data
+
+      @order_no = 0
+      @orders = {}
+      @cash, @stock = 0, 0
+      @connect_triggered = false
+
+      @@parent.child = self
+    end
+
+    def cash; @cash; end
+    def stock; @stock; end
+
+    def send_order side, size, price
+      @order_no += 1
+
+      order = Order.new @order_no, side, price, size
+      order.add_observer self
+
+      @orders[@order_no] = order
+
+      send_data_f({
+        action: "new_order",
+        local_id: @order_no,
+        size: size,
+        price: price,
+        side: side
+      }.to_json)
+
+      order
+    end
+
+    def update what, *args
+      case what
+      when :cancel
+        order = args[0]
+        send_data_f({
+          action: "cancel_order",
+          id: order.id
+        }.to_json)
+      else
+        # Don't need to handle anything else
+      end
+    end
+
+    # Send a buy order
+    def buy amount, args
+      send_order "buy", amount, args[:at]
+    end
+
+    # Send a sell order
+    def sell amount, args
+      send_order "sell", amount, args[:at]
+    end
+
+    # Send data with tokens
+    def send_data_f data
+      send_data "\x02#{data}\x03"
+    end
+
+    # Strip off begin/end transmission tokens
+    def clean data
+      if data.length > 2
+        data[1..-2].split("\x03\x02")
+      else
+        []
+      end
+    end
+
+    # Called by EM when we receive data
+    def receive_data data
+      clean(data).each do |msg|
+        handle_message JSON.parse msg
+      end
+    end
+
+    # Recalculate cash/stock balances
+    def update_account data
+      order = @orders[data["local_id"]]
+
+      if order.side == "buy"
+        @cash -= data["price"] * data["amount"]
+        @stock += data["amount"]
+      else
+        @cash += data["price"] * data["amount"]
+        @stock -= data["amount"]
+      end
+    end
+
+    # Process a message from the server
+    def handle_message data
+      case data["action"]
+      when "order_accept"
+      when "order_fill"
+        update_account data
+        @@parent.on_fill @orders[data["local_id"]], data["amount"], data["price"]
+      when "order_partial_fill"
+        update_account data
+        @@parent.on_partial_fill @orders[data["local_id"]], data["amount"], data["price"]
+      when "order_cancel"
+        # Don't need to do anything here
+      when "account_update"
+        @cash, @stock = data["cash"], data["stock"]
+
+        if not @connect_triggered
+          @connect_triggered = true
+          @@parent.on_connect
+        end
+      end
+    end
+  end
+
+  module Client
+    def self.on_connect *args; end
+    def self.on_tick *args; end
+    def self.on_fill *args; end
+    def self.on_partial_fill *args; end
+
+    module ClassMethods
+      # hook so we can call child methods
+      def child= child
+        @@child = child
+      end
+
+      # Called when we receive feed data
+      def process_message data
+        case data["action"]
+        when "tick"
+          self.on_tick data["level1"]
+        end
+      end
+
+      def buy *args; @@child.buy(*args); end
+      def sell *args; @@child.sell(*args); end
+      def cash; @@child.cash; end
+      def stock; @@child.stock; end
+
+      def connect_to server, args
+        feed_port = args[:feed_port] || DEFAULT_FEED_PORT
+        order_port = args[:order_port] || DEFAULT_ORDER_PORT
+
+        if not args[:as]
+          raise "Need to specify a username: connect_to \"...\", as: \"username\""
+        end
+
+        @zmq_context = EM::ZeroMQ::Context.new 1
+
+        EM.run do
+          @feed = @zmq_context.socket ZMQ::SUB
+
+          puts "Listening to feed on #{server}:#{feed_port}"
+          @feed.connect "tcp://#{server}:#{feed_port}"
+          @feed.subscribe
+
+          @feed.on :message do |part|
+            begin
+              self.process_message JSON.parse part.copy_out_string
+            ensure
+              part.close
+            end
+          end
+
+          ConnectionClient.setup args, self
+
+          puts "Connecting to order server #{server}:#{order_port}"
+          EM.connect server, order_port, ConnectionClient
+
+          Signal.trap("INT") { EM.stop }
+          Signal.trap("TERM") { EM.stop }
+        end
+      end
+    end
+
+    def self.included subclass
+      subclass.extend ClassMethods
+    end
+  end
+end

data/lib/order.rb

@@ -0,0 +1,49 @@
+require 'observer'
+
+class Order
+  include Observable
+
+  attr_reader :id, :local_id, :side, :price, :size, :sent_at, :status
+
+  def initialize id, side, price, size
+    @id, @side, @price, @size = id, side, price, size
+    @sent_at = Time.now
+    @cancelled = false
+    @status = :pending_accept
+  end
+
+  def status= new_status
+    @status = new_status
+  end
+
+  def <=> order
+    if order.price == price
+      @sent_at <=> order.sent_at
+    else
+      price <=> order.price
+    end
+  end
+
+  def cancelled?
+    @cancelled
+  end
+
+  def fill! amount
+    changed
+
+    status = :fill
+    status = :partial_fill if amount < @size
+
+    @size -= amount
+    
+    notify_observers status, self
+  end
+
+  def cancel!
+    return if @cancelled  # can only cancel an order once
+
+    @cancelled = true
+    changed
+    notify_observers :cancel, self
+  end
+end

data/lib/ruby-trade.rb

@@ -0,0 +1 @@
+require_relative "client"

data/rubytrade.gemspec

@@ -0,0 +1,12 @@
+Gem::Specification.new do |s|
+  s.name = "ruby-trade"
+  s.version = "0.1"
+  s.date = "2013-11-09"
+  s.summary = "A stock market simulation game."
+  s.description = ""
+  s.authors = ["Rob Britton"]
+  s.email = "rob@robbritton.com"
+  s.files = `git ls-files`.split("\n")
+  s.require_paths = ["lib"]
+  s.license = "MIT"
+end