game_machine 0.0.11 → 1.0.2

data/config/test.conf

@@ -0,0 +1,149 @@
+
+gamemachine {
+
+  environment = test
+  use_regions = true
+  orm = false
+  mono_enabled = false
+
+  client {
+
+    # Sets the protocol and host/port used by the client if set to TCP or UDP.  ANY lets the client use it's own values
+    protocol = ANY
+  }
+
+   handlers {
+
+    # Team handler
+    team = "GameMachine::DefaultHandlers::TeamHandler"
+
+    # Authentication handlers.  
+
+    #PublicAuthenticator allows any user/password combination to work
+    auth = "com.game_machine.authentication.PublicAuthenticator"
+
+    # The default.  Uses salted password hash (bcrypt)
+    #auth = "com.game_machine.authentication.DefaultAuthenticator"
+
+  }
+  
+  routers {
+    # Size of the router for incoming message from all clients
+    game_handler = 5
+
+    # Also in the pipeline for all incoming requests, should be set the same as
+    # game_handler_routers
+    request_handler = 5
+
+    # router size for the udp actor that handles all incoming upd messages
+    udp = 5
+
+    objectdb =  5
+  }
+  
+  datastore {
+    # What data store the object database will use (one of memory, mapdb, or couchbase)
+    store = gamecloud
+
+    serialization = json
+
+    # minimum time in milliseconds between writes to the backing store of the same key.  When a message
+    # exceeds the limit it is either enqueued, or if already enqueued, it's value is updated, it's
+    # value is updated. -1 disables caching.  Default 1000
+    cache_write_interval = -1
+
+    # Total writes per second to the backing store that an actor will allow, across all keys.  Note this is on a per actor
+    # basis.  If you want to limit total writes per second to your database, this value should be a multiple of the number
+    # of write behind cache actors that are started.  -1 disables caching. Default 100
+    cache_writes_per_second = -1
+  }
+  
+
+  gamecloud {
+    #host = "localhost:9000"
+    #user = test
+    #api_key = 294122207690d6e93867c56fae265c24
+    #api_key = 20934a81ba104ad1936b8a3e9e7fdaef
+
+    user = chris
+    host = "cloud-dev.gamemachine.io:80"
+    api_key = 1a77d75e32767f89b0710311be1fd8a5
+  }
+
+  grids {
+    default = "4000, 50, 1"
+    aoe =  "4000, 5, 1"
+    local_chat =  "4000, 10, 10"
+  }
+
+  couchbase {
+    bucket = gamemachine
+    password = pass
+    servers = ["http://192.168.1.8:8091/pools"]
+  }
+
+  jdbc {
+    
+    // Postgres
+    hostname = 127.0.0.1
+    port = 5432
+    database = gamemachine
+    url = "jdbc:postgresql://127.0.0.1:5432/gamemachine"
+    ds = "org.postgresql.ds.PGSimpleDataSource"
+    driver = "org.postgresql.Driver"
+    username = gamemachine
+    password = gamemachine
+
+    // Mysql
+    #hostname = 127.0.0.1
+    #port = 3306
+    #database = gamemachine
+    #url = "mysql://127.0.0.1:3306/game_machine"
+    #ds = "com.mysql.jdbc.jdbc2.optional.MysqlDataSource"
+    #driver = "com.mysql.jdbc.Driver"
+    #username = gamemachine
+    #password = gamemachine
+
+  }
+
+  http {
+    enabled = true
+    host = 0.0.0.0
+    port = 3000
+  }
+
+  udp {
+    enabled = true
+    host = 0.0.0.0
+    port = 24130
+  }
+
+  tcp {
+    enabled = true
+    host = 0.0.0.0
+    port = 8910
+  }
+
+  akka {
+    host = 127.0.0.1
+    port = 2551
+  }
+
+  # Seeds are akka nodes that should already be in the cluster.  We use them as first points of contact to join against
+  # If there are no seeds, we start the cluster by joining to ourself
+  #seeds = ["127.0.0.1:9991","127.0.0.1:9992"]
+  seeds = []
+
+  admin {
+    user = admin
+    pass = pass
+  }
+  
+  regions = [
+    ["zone1","GameMachine::DefaultHandlers::ZoneManager"],
+    ["zone2", "GameMachine::DefaultHandlers::ZoneManager"]
+  ]
+    
+}
+ 
+ 

data/game_machine.gemspec

@@ -18,17 +18,22 @@ Gem::Specification.new do |gem|
   gem.require_paths = ["lib"]
 
   gem.add_dependency 'i18n'
-  gem.add_dependency 'rjack-logback'
-  gem.add_dependency 'settingslogic'
-  gem.add_dependency 'consistent-hashing'
   gem.add_dependency  'json'
   gem.add_dependency 'ffi'
   gem.add_dependency 'sinatra'
   gem.add_dependency 'sinatra-contrib'
-  gem.add_dependency 'haml'
-  gem.add_dependency 'webrick'
+  gem.add_dependency 'rack-flash3'
+  gem.add_dependency 'activesupport'
+  gem.add_dependency 'wavefront'
+  gem.add_dependency 'puma'
+  gem.add_dependency 'faraday'
+  gem.add_dependency 'bcrypt'
+  gem.add_dependency 'bundler'
+
 
   gem.add_development_dependency 'rake'
+  gem.add_development_dependency 'nanoc'
+  gem.add_development_dependency 'kramdown'
   gem.add_development_dependency 'rspec'
   gem.add_development_dependency 'rspec-mocks'
   gem.add_development_dependency 'rspec-expectations'

data/games/boot.rb

@@ -0,0 +1,3 @@
+
+#require_relative 'example/boot'
+require_relative 'tutorial/boot'

data/games/example/data/game_data.yml

@@ -1,9 +1,9 @@
 ---
 zone1:
-  male: 200
-  viking: 200
-  golem: 200
-  worm: 200
+  male: 400
+  viking: 100
+  golem: 100
+  worm: 2000
 zone2:
   male: 100
   viking: 100

data/games/example/lib/aggressive_npc.rb

@@ -49,7 +49,7 @@ module Example
         if position.distance(player[:vector]) <= @agro_radius
           movement.set_target(player[:vector])
           @target_id = player[:id]
-          #log("target chosen #{@target_id}")
+          log("target chosen #{@target_id}")
         end
       end
     end

data/games/example/lib/game.rb

@@ -4,9 +4,7 @@ require_relative 'models/attack'
 require_relative 'models/user'
 require_relative 'models/combat_update'
 require_relative 'models/player_command'
-require_relative 'authentication_handler'
 require_relative 'tracking_handler'
-require_relative 'player_register'
 require_relative 'example_controller'
 require_relative 'chatbot'
 require_relative 'combat_controller'
@@ -16,6 +14,7 @@ require_relative 'aggressive_npc'
 require_relative 'npc_group'
 require_relative 'player_manager'
 require_relative 'zone_manager'
+require_relative 'player_register'
 
 module Example
   class Game

data/games/example/lib/player_register.rb

@@ -77,4 +77,4 @@ module Example
     end
 
   end
-end
+end

data/games/routes.rb

@@ -0,0 +1,9 @@
+
+GameMachine::Routes.game_messages do
+
+  # The route id and the to: parameter are both required.  Everything else is optional
+  # route id's can be any positive integer.  For ruby actors, to: should be the class.  For java actors
+  # to: should be the string name of the actor (as defined in the java class)
+  route 1, to: 'Tutorial::ItemManager', distributed: true, name: 'item_manager'
+  route 2, to: 'loot_generator', name: 'loot_generator'
+end

data/games/tutorial/boot.rb

@@ -0,0 +1,12 @@
+
+require_relative 'item_manager'
+
+# For the inventory handler we use a distributed router.  The routing system for game messages uses
+# the player id to hash against which guarantees that player ids are mapped to specific actors.
+# This lets us cache player specific data in the actor that the player is hashed to.
+if GameMachine::Application.config.orm
+  require_relative 'seed'
+  GameMachine::Actor::Builder.new(Tutorial::ItemManager).distributed(3).start
+end
+
+

data/games/tutorial/item_manager.rb

@@ -0,0 +1,256 @@
+require_relative 'object_store'
+require_relative 'sql_store'
+
+module Tutorial
+
+  # Provides item persistence and management.  Choice of using object store or sql on a per item basis.
+  # Items that have a limited quantity or a cost involve updating multiple records.  These items will benefit from
+  # using sql as the item manager wraps those updates in a transaction to ensure the updates are atomic.  But that comes
+  # at a cost.  Do not use sql for items just because you prefer sql.
+
+  # Items that are not limited quantity or have a cost, only require updating the item itself.  These items are ideal for
+  # the object store.  Because we use a distributed router for the item manager, even object store items are saved atomically.
+  # The limitation of the object store is that we cannot save multiple items atomically, but are limited to just one.
+
+  # This demo is designed to show the full persistence api and reliable messaging in a common use case.  It should work
+  # fine as a starting point for your own item management.
+
+
+  # Design notes:
+  # - Item definitions are just items assigned to the 'global' user.  Player items are created by cloning one of the global items.
+  #
+  # - Extending the system for more types of items should be done compositionally by adding new messages to PlayerItem.  Think of it
+  # as an entity component system where PlayerItem is the entity, and all the messages it contains are the components.
+  #
+  # - We prefer to use nested messages instead of adding concrete fields to PlayerItem.  It's a good way to keep encapsulation.
+
+  class ItemManager < GameMachine::Actor::GameActor
+    include GameMachine
+    attr_reader :player_item_cache, :catalog_list, :catalog_map, :object_store, :sql_store, :catalog_user
+
+    def awake(args)
+      @catalog_user = 'global'
+      @sql_store = SqlStore.new
+      @object_store = ObjectStore.new
+
+      @player_item_cache = {}
+
+      @catalog_list = MessageLib::PlayerItem.db_find_all(catalog_user)
+      @catalog_map = catalog_list.each_with_object({}) {|v,res| res[v.id] = v}
+    end
+
+    def on_game_message(game_message)
+      player_items_message = MessageLib::PlayerItems.new
+
+      # exactly_once returns true of the message is a reliable message, and it is the first time we have seen
+      # the message.  Use set_reply instead of tell_player for reliable messages. 
+      if exactly_once(game_message)
+        reply = new_game_message.set_player_items(player_items_message)
+
+        if game_message.has_add_player_item
+          add_player_item(game_message.add_player_item.player_item).each do |player_item|
+            reply.player_items.add_player_item(player_item)
+          end
+        end
+
+        if game_message.has_remove_player_item
+          if player_item = remove_player_item(game_message.remove_player_item.id,
+            game_message.remove_player_item.quantity
+          )
+            reply.player_items.add_player_item(player_item)
+          end
+        end
+
+        set_reply(reply)
+
+      elsif game_message.has_request_player_items
+
+        if game_message.request_player_items.catalog
+          player_items_message.set_player_item_list(catalog_list)
+          player_items_message.catalog = true
+        else
+          player_items.values.each {|pi| player_items_message.add_player_item(pi)}
+        end
+        
+        player_message = new_game_message
+        player_message.set_player_items(player_items_message)
+        tell_player(player_message)
+      else
+        unhandled(game_message)
+      end
+    end
+
+    def on_player_disconnect(player_id)
+      player_item_cache.delete(player_id)
+    end
+
+    private
+
+    def player_items
+      unless player_item_cache.fetch(player_id,nil)
+        player_item_cache[player_id] = {}
+        sql_store.all_for_player(player_id).each do |player_item|
+          player_item_cache[player_id][player_item.id] = player_item
+        end
+        object_store.all_for_player(player_id).each do |player_item|
+          player_item_cache[player_id][player_item.id] = player_item
+        end
+      end
+      player_item_cache[player_id]
+    end
+
+    def add_player_item(player_item)
+      catalog_item = catalog_map.fetch(player_item.id,nil)
+      return nil if catalog_item.nil?
+
+      if object_store_item?(player_item)
+        return add_object_store_item(player_item,catalog_item)
+      else
+        return add_sql_item(player_item,catalog_item)
+      end
+    end
+
+    def remove_player_item(id,quantity)
+      if player_item = player_items.fetch(id,nil)
+        player_item.quantity -= quantity
+        if player_item.quantity >= 1
+          store_save_player_item(player_item,player_id)
+        else
+          store_delete_player_item(player_item,player_id)
+          player_items.delete(id)
+        end
+        player_item
+      end
+    end
+
+    # Retrieves current player item, or creates new one from catalog item
+    # new items are set to 0 quantity and stripped of components that we don't need
+    # to store on the player copy, such as the cost.
+    def player_item(id,catalog_item)
+      if current_player_item = player_items.fetch(id,nil)
+        current_player_item
+      else
+        current_player_item = catalog_item.clone
+        current_player_item.quantity = 0
+        current_player_item.set_cost(nil)
+        current_player_item
+      end
+    end
+
+    def deduct_item_cost(player_item,catalog_item)
+      currency = catalog_item.cost.currency
+      return nil unless player_items.has_key?(currency)
+
+      player_currency = player_items[currency].clone
+      
+      currency_required = player_item.quantity * catalog_item.cost.amount
+      if player_currency.quantity >= currency_required
+        player_currency.quantity -= currency_required
+        store_save_player_item(player_currency,player_id,true)
+        return player_currency
+      else
+        nil
+      end
+    end
+
+    def add_object_store_item(player_item,catalog_item)
+      current_player_item = player_item(player_item.id,catalog_item)
+      current_player_item.quantity += player_item.quantity
+      player_items[current_player_item.id] = current_player_item
+
+      store_save_player_item(current_player_item,player_id)
+      return [current_player_item]
+    end
+
+    def add_sql_item(player_item,catalog_item)
+      state = OpenStruct.new
+      changed_items = []
+      state.player_item = player_item(player_item.id,catalog_item).clone
+
+      begin
+        ModelLib::PlayerItem.open_transaction
+
+        limited_item = catalog_item.quantity == -1 ? false : true
+
+        if limited_item
+          state.catalog_item = sql_store.find_by_id(catalog_item.id,catalog_user,true)
+          if state.catalog_item.quantity >= player_item.quantity
+            state.catalog_item.quantity -= player_item.quantity
+            store_save_player_item(state.catalog_item,catalog_user,true)
+          else
+            ModelLib::PlayerItem.rollback_transaction
+            GameMachine.logger.info "Insufficient quantity (#{current_catalog_item.quantity}) for #{player_item.id}"
+            return changed_items
+          end
+        end
+
+        if catalog_item.has_cost
+          state.player_currency = deduct_item_cost(player_item,catalog_item)
+          if state.player_currency.nil?
+            ModelLib::PlayerItem.rollback_transaction
+            GameMachine.logger.info "cost deduction failed #{player_item.id}"
+            return changed_items
+          end
+        end
+
+        state.player_item.quantity += player_item.quantity
+        store_save_player_item(state.player_item,player_id,true)
+        
+        ModelLib::PlayerItem.commit_transaction
+
+        player_items[state.player_item.id] = state.player_item
+        changed_items << state.player_item
+        
+        if state.catalog_item
+          catalog_item = state.catalog_item
+        end
+
+        if state.player_currency
+          player_items[state.player_currency.id] = state.player_currency
+          changed_items << state.player_currency
+        end
+
+        return changed_items
+      rescue Exception => e
+        GameMachine.logger.error "Error adding sql item #{player_item.id} #{e.to_s} \n #{e.backtrace.join("\n")}"
+        ModelLib::PlayerItem.rollback_transaction
+      end
+    end
+
+    # Use object store when:
+    # - item is not currency
+    # - item is not limited quantity
+    # - item does not have a cost
+
+    # Note that cost handling is not implemented for object store items.
+    def object_store_item?(player_item)
+      catalog_item = catalog_map.fetch(player_item.id)
+      if catalog_item.has_cost
+        false
+      elsif ['gold','silver'].include?(catalog_item.id)
+        false
+      elsif catalog_item.quantity = -1
+        true
+      else
+        false
+      end
+    end
+
+    def store_save_player_item(player_item,player_id,in_transaction=false)
+      if object_store_item?(player_item)
+        object_store.save_player_item(player_item,player_id)
+      else
+        sql_store.save_player_item(player_item,player_id,in_transaction)
+      end
+    end
+
+    def store_delete_player_item(player_item,player_id)
+      if object_store_item?(player_item)
+        object_store.delete_player_item(player_item.id,player_id)
+      else
+        sql_store.delete_player_item(player_item.id,player_id)
+      end
+    end
+    
+  end
+end