game_machine 0.0.8

data/games/example/lib/player_manager.rb

@@ -0,0 +1,58 @@
+
+# We use this for player specific maintenance, such as regenerating health
+module Example
+  class PlayerManager < GameMachine::Actor::Base
+    include Models
+    include GameMachine::Commands
+
+    attr_reader :player_ids
+    def post_init(*args)
+      @player_ids = []
+      update_player_ids
+      schedule_message('update',5,:seconds)
+    end
+
+    # All players currently logged into this node
+    def update_player_ids
+      @player_ids = GameMachine::ClientManager.local_connections.keys
+    end
+
+    def regen_player_health
+      update_player_ids
+      player_ids.each do |player_id|
+        if vitals = Vitals.find(player_id)
+          vitals.health += 5
+          if vitals.health > vitals.max_health
+            vitals.health = vitals.max_health
+          end
+          if grid_value = commands.grid.find_by_id(player_id)
+            vitals.x = grid_value.x
+            vitals.y = grid_value.y
+          end
+          vitals.save
+          commands.player.send_message(vitals,player_id)
+        end
+      end
+    end
+
+    def on_receive(message)
+      if message.is_a?(String)
+        if message == 'update'
+          regen_player_health
+        end
+      elsif message.is_a?(GameMachine::Models::PlayerStatusUpdate)
+        if vitals = Vitals.find(message.player_id)
+          if message.status == 'registered'
+            if zone = GameMachine::GameSystems::RegionService.region
+              vitals.zone = zone
+              vitals.save
+              GameMachine.logger.info "#{message.player_id} entered zone #{vitals.zone}"
+            end
+          elsif message.status == 'unregistered'
+          end
+        end
+      end
+    end
+
+  end
+end

data/games/example/lib/player_register.rb

@@ -0,0 +1,80 @@
+module Example
+  class PlayerRegister
+    include Models
+
+    attr_accessor :params, :errors
+    def initialize(params)
+      @params = params
+      @errors = {}
+    end
+
+    def valid?
+      errors.size == 0
+    end
+
+    def add_error(field,message)
+      errors[field] ||= []
+      errors[field] << message
+    end
+
+    def error
+        {'error' => errors}
+    end
+
+    def success(message)
+      {'success' => message}
+    end
+
+    # This is called whenever a player is registered
+    # It must return a simple hash with a success or error key
+    def register!
+
+      # Create one character at registration time
+      password = params['password']
+      username = params['username']
+      character_name = params['character_name']
+
+      # make sure user/character do not already exist
+      if User.find(username,10000)
+        add_error('username','must not already exist')
+        return error
+      end
+
+      if username == character_name
+        add_error('username','must be different from character name')
+      end
+
+      # Create user
+      user = User.new(
+        :id => username,
+        :password => password,
+      )
+      if user.password.size > 4
+        user.save
+      else
+        add_error('password', 'length must be > 4')
+      end
+
+      # Create character
+      stats = Vitals.new(
+        :id => username,
+        :max_health => 100,
+        :health => 100,
+        :defense_skill => 10,
+        :offense_skill => 10,
+        :entity_type => 'player',
+        :x => 500,
+        :y => 500,
+        :zone => 'zone1'
+      )
+        stats.save
+
+      if valid?
+        success("Account created!")
+      else
+        error
+      end
+    end
+
+  end
+end

data/games/example/lib/tracking_handler.rb

@@ -0,0 +1,17 @@
+
+# This class is set in the config.  Every time the client sends it's location
+# the verify method is called.  You can use this to prevent things like speed hacking.
+module Example
+  class TrackingHandler
+
+    # This method must return true for the players location to be saved.
+    # If you return false here, the location sent by the player will be discarded
+    def verify(entity)
+      #vector = entity.vector3
+      #player_id = entity.id
+      #entity_type = entity.entity_type
+      #track_extra = entity.track_entity.track_extra
+      true
+    end
+  end
+end

data/games/example/lib/zone_manager.rb

@@ -0,0 +1,57 @@
+# This class is configured in regions.yml, which is a mapping of regions to classes
+# that handle running the region.  In this example we use the same class for both
+# of our regions.  Our example regions only vary in which npc's are spawned.
+module Example
+  class ZoneManager < GameMachine::Actor::Base
+
+    attr_reader :game_data
+    def post_init(*args)
+      @game_data = args.first
+      @region_up = false
+    end
+
+    def start_zone(zone)
+
+      # Start our combat controller
+      GameMachine::Actor::Builder.new(CombatController).start
+
+      if zone == 'zone1'
+        data = game_data.fetch('zone1')
+        spawn_npcs('male',data['male'],Npc)
+        spawn_npcs('viking',data['viking'],Npc)
+        spawn_npcs('golem',data['golem'],Npc)
+        spawn_npcs('worm',data['worm'],AggressiveNpc)
+      elsif zone == 'zone2'
+        data = game_data.fetch('zone2')
+        spawn_npcs('male',data['male'],Npc)
+        spawn_npcs('viking',data['viking'],Npc)
+        spawn_npcs('golem',data['golem'],Npc)
+        spawn_npcs('worm',data['worm'],AggressiveNpc)
+      end
+    end
+
+    def spawn_npcs(type,count,klass)
+      count.times.map {|i| "#{type}_#{i}"}.each_slice(20).each do |group|
+        name = Digest::MD5.hexdigest(group.join(''))
+        group.each do |npc_name|
+          Game.npcs[npc_name] = name
+        end
+        GameMachine::Actor::Builder.new(NpcGroup,group,klass).with_name(name).start
+      end
+    end
+
+    def on_receive(message)
+
+      # Region manager pings us every couple of seconds as long as we are alive,
+      # it's up to us to determine if we have started the region or not
+      if message.is_a?(GameMachine::Models::Region)
+        return if @region_up
+        @region_up = true
+
+        zone = message.name
+        GameMachine.logger.info "#{self.class.name} Starting region #{zone}"
+        start_zone(zone)
+      end
+    end
+  end
+end

data/games/preload.rb

@@ -0,0 +1,8 @@
+
+# If you have things you want loaded before game machine starts up, this
+# is the place to do it.  Examples might be specific handlers, or loading up
+# static data that needs to be there before the rest of the system starts up.
+
+
+# This needs to be loaded before the entity tracking system starts
+require_relative 'example/lib/tracking_handler'

data/integration_tests/basic_spec.rb

@@ -0,0 +1,68 @@
+require 'integration_helper'
+
+module GameMachine
+
+  describe "basic" do 
+
+    let(:client) {Clients::Client.new(:seed01)}
+
+    context "test" do
+
+      describe "sending messages to remote actors" do
+
+        it "there and back again" do
+          ref = GameSystems::LocalEcho.find_remote('seed01')
+          ref.send_message('blah', :blocking => true, :timeout => 1000).should == 'blah'
+          returned_entity = ref.send_message(static_entity, :blocking => true, :timeout => 1000)
+          returned_entity.get_id.should == static_entity.get_id
+        end
+
+        it "distributed messaging should return answer" do
+          ref = GameSystems::LocalEcho.find_distributed('blah', 'DistributedLocalEcho')
+          returned_entity = ref.send_message(static_entity, :blocking => true, :timeout => 1000)
+          returned_entity.get_id.should == static_entity.get_id
+        end
+
+        it "udt should get response" do
+          bytes = static_client_message.to_byte_array
+          Thread.current['s'] ||= Clients::Client.connect_udt
+          result = Clients::Client.send_udt(Thread.current['s'],bytes)
+          returned_message = ClientMessage.parse_from(result)
+          returned_message.get_entity_list.first.id.should == static_entity.id
+        end
+
+        it "udp should get response" do
+          bytes = static_client_message.to_byte_array
+          c = Clients::Client.new(:seed01)
+          c.send_message(bytes)
+          message = c.receive_message
+          returned_message = ClientMessage.parse_from(message.to_java_bytes)
+          returned_message.get_entity_list.first.id.should == static_entity.id
+        end
+
+        it "player should be able to login via http" do
+         response = Clients::Client.http_post('/auth',{:username => 'player', :password => 'pass'})
+         response = JSON.parse(response)
+         response['authtoken'].should == 'authorized'
+        end
+
+        it "write behind cache writes to couchbase" do
+          ObjectDb.put(static_entity)
+          ObjectDb.get(static_entity.id).id.should == static_entity.id
+        end
+
+        it "echo request" do
+          client = Clients::TestClient.start('test2',8200)
+          message = Helpers::GameMessage.new('player123')
+          message.echo_test('one')
+          client.send_to_server(message.client_message)
+          expect(client.entity_with_component('EchoTest',0.900)).to be_true
+          logout = Helpers::GameMessage.new('player123')
+          logout.player_logout
+          client.send_to_server(logout.client_message)
+        end
+      end
+
+    end
+  end
+end

data/integration_tests/bot_spec.rb

@@ -0,0 +1,18 @@
+require 'integration_helper'
+
+module GameMachine
+
+  describe "bot net" do 
+
+    describe "chat client bot" do
+      it "starts client" do
+        200.times do |i|
+          GameMachine::Bot::Client.start("bot#{i}",8200)
+        end
+        sleep 20000
+      end
+    end
+
+  end
+end
+

data/integration_tests/chat_spec.rb

@@ -0,0 +1,45 @@
+require 'integration_helper'
+module GameMachine
+
+  describe "chat" do 
+      
+    before(:all) do
+      @client = Clients::TestClient.start('test1',8200)
+      @client2 = Clients::TestClient.start('test2',8202)
+    end
+
+    after(:all) do
+      @client.stop
+      @client2.stop
+    end
+
+    it "join chat request sends ChatChannels to client" do
+      message = Helpers::GameMessage.new('player1')
+      message.join_chat('mygroup')
+      @client.send_to_server(message.client_message)
+      expect(@client.entity_with_component('ChatChannels')).to be_true
+    end
+
+    it "receive chat message from other player" do
+      client_join_message = Helpers::GameMessage.new('player1')
+      client_join_message.join_chat('mygroup')
+
+      client2_join_message = Helpers::GameMessage.new('player2')
+      client2_join_message.join_chat('mygroup')
+
+      chat_message = Helpers::GameMessage.new('player1')
+      chat_message.chat_message('group','Chat it up!','mygroup')
+
+      @client.send_to_server(client_join_message.client_message)
+      expect(@client.entity_with_component('ChatChannels')).to be_true
+
+      @client2.send_to_server(client2_join_message.client_message)
+      expect(@client2.entity_with_component('ChatChannels')).to be_true
+
+      @client.send_to_server(chat_message.client_message)
+      expect(@client2.entity_with_component('ChatMessage',1)).to be_true
+      
+    end
+
+  end
+end

data/integration_tests/distributed_spec.rb

@@ -0,0 +1,34 @@
+require 'integration_helper'
+
+module GameMachine
+  describe "basic" do 
+    let(:client) {Client.new(:seed01)}
+
+    describe "sending messages to remote actors" do
+      it "distributed messaging should return answer" do
+         e = entity.clone
+        10.times do |i|
+          ref = GameSystems::LocalEcho.find_distributed(i.to_s, 'DistributedLocalEcho')
+          returned_entity = ref.send_message(e, :blocking => true, :timeout => 1000)
+          returned_entity.get_id.should == e.id
+        end
+      end
+    end
+
+    describe "stress test" do
+      it "distributed stress" do
+        e = entity.clone
+        measure(10,100000) do
+          Thread.current['ref'] ||= GameSystems::LocalEcho.find_distributed(rand(100).to_s,'DistributedLocalEcho')
+          returned_entity = Thread.current['ref'].send_message(e, :blocking => true, :timeout => 1000)
+          if returned_entity 
+            returned_entity.id.should == e.id
+          else
+            puts 'Timeout'
+          end
+        end
+      end
+    end
+
+  end
+end

data/integration_tests/entity_tracking_spec.rb

@@ -0,0 +1,48 @@
+require 'integration_helper'
+
+  def get_neighbors_message(player_id)
+    m = GameMachine::Helpers::GameMessage.new(player_id.to_s)
+    m.track_entity
+    m.get_neighbors
+    m.to_entity
+    m.current_entity.player.set_x(rand(1000)).set_y(1000)
+    m
+  end
+
+  def player_logout(player_id)
+    m = GameMachine::Helpers::GameMessage.new(player_id.to_s)
+    m.player_logout
+    m
+  end
+
+module GameMachine
+  COUNT = JavaLib::AtomicInteger.new
+
+  describe 'Player tracking' do
+
+    it "players are tracked" do
+      pre = Proc.new do
+        player_id = COUNT.increment_and_get
+        Thread.current['player_id'] = player_id
+        Thread.current['bytes'] = get_neighbors_message(player_id).to_byte_array
+        Thread.current['c'] = Clients::UdtClient.new(:seed01)
+        Thread.current['c'].connect
+      end
+
+      post = Proc.new do
+        player_id = Thread.current['player_id']
+        Thread.current['c'].send_message(player_logout(player_id).to_byte_array)
+        sleep 0.100
+        Thread.current['c'].disconnect
+      end
+
+      measure(100,1000,pre,post) do
+        Thread.current['c'].send_message(Thread.current['bytes'])
+        res = Thread.current['c'].receive
+        client_message = ClientMessage.parse_from(res)
+      end
+    end
+  end
+end
+
+