game_machine 0.0.8

data/spec/message_buffer_spec.rb

@@ -0,0 +1,67 @@
+require 'spec_helper'
+module GameMachine
+
+  describe MessageBuffer do
+
+    let(:message) do
+      MessageLib::ClientMessage.new.add_entity(
+        MessageLib::Entity.new.set_id('0')
+      )
+    end
+
+    let(:message_size) {bytes.length - 1}
+    let(:bytes) {message.to_prefixed_byte_array }
+    let(:bytes_without_prefix) {message.to_byte_array }
+
+    subject {MessageBuffer.new}
+
+    describe "#add_bytes" do
+      it "adds bytes to buffer" do
+        puts bytes.length
+        subject.add_bytes(bytes)
+        expect(subject.bytes.length).to eql(bytes.length)
+      end
+
+      it "appends to the buffer when called multiple times" do
+        subject.add_bytes(bytes)
+        subject.add_bytes(bytes)
+        subject.add_bytes(bytes)
+        expect(subject.bytes.length).to eql(3 * bytes.length)
+      end
+    end
+
+    describe "#messages" do
+      it "returns a message" do
+        subject.add_bytes(bytes)
+        expect(subject.messages.size).to eql(1)
+      end
+
+      it "returns multiple messages" do
+        subject.add_bytes(bytes)
+        subject.add_bytes(bytes)
+        subject.add_bytes(bytes)
+        expect(subject.messages.size).to eql(3)
+      end
+
+      it "correctly handles partial messages" do
+        subject.add_bytes(bytes)
+        part = Java::byte[2].new
+        part[0] = bytes[0]
+        part[1] = bytes[1]
+        subject.add_bytes(part)
+        expect(subject.messages.size).to eql(1)
+        expect(subject.bytes.length).to eq(1)
+        expect(subject.next_message_length).to eql(5)
+        part = Java::byte[4].new
+        part[0] = bytes[2]
+        part[1] = bytes[3]
+        part[2] = bytes[4]
+        part[3] = bytes[5]
+        subject.add_bytes(part)
+        expect(subject.messages.size).to eql(1)
+        expect(subject.bytes).to be_nil
+      end
+    end
+
+  end
+end

data/spec/message_expectations.rb

@@ -0,0 +1,47 @@
+
+module ClassMethods
+
+  require "rspec/mocks/standalone"
+  require "rspec/expectations"
+
+    include RSpec::Matchers
+
+  def expected
+    @expected ||= {}
+  end
+
+  def actual
+    @actual ||= {}
+  end
+
+  def should_receive_message(message,name=self.name, &blk)
+    blk.call
+    called = false
+    10.times do
+      if actual.has_key?(name)
+        called = true
+        break
+      end
+      sleep 0.020
+    end
+    expect(actual[name]).to eq(message)
+    actual.delete(name)
+  end
+
+end
+
+module InstanceMethods
+
+    def onReceive(message)
+      on_receive(message)
+      self.class.actual[get_self.path.name] = message
+    end
+
+end
+result = []
+ObjectSpace.each_object(::Class) {|klass| result << klass if klass < GameMachine::Actor::Base }
+result.each do |klass|
+  klass.send(:include, InstanceMethods)
+  klass.send(:extend, ClassMethods)
+end
+

data/spec/message_queue_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+module GameMachine
+  describe MessageQueue do
+
+    let(:topic) {'test topic'}
+    let(:message) {'test message'}
+
+    let(:subscribe) do
+      MessageLib::Subscribe.new.set_topic(topic)
+    end
+
+    let(:unsubscribe) do
+      MessageLib::Unsubscribe.new.set_topic(topic)
+    end
+
+    let(:publish) do
+      publish = MessageLib::Publish.new
+      publish.set_topic(topic).set_message(message)
+    end
+
+  end
+end

data/spec/misc_spec.rb

@@ -0,0 +1,71 @@
+require 'spec_helper'
+require 'jruby/core_ext'
+module GameMachine
+  describe "misc" do 
+    let(:entity) do 
+      entity = MessageLib::Entity.new
+      entity.id = '1'
+      player = MessageLib::Player.new
+      player.authtoken = 'authorized'
+      player.id = '2'
+      entity.player = player
+      entity
+    end
+
+    it "singleton manager" do
+      ref = Akka.instance.actor_system.actor_selection('/user/region_manager_proxy')
+      ref.tell('HELLO',nil)
+      sleep 1
+    end
+
+    xit "vector3" do
+      vector = MessageLib::Vector3.new.set_x(0.0)
+      bytes = vector.to_byte_array
+      File.open('/tmp/bytes.txt','wb') {|f| f.write(bytes)}
+      vector = MessageLib::Vector3.parse_from(bytes)
+      expect(vector.x).to eq 0
+    end
+
+    xit "parses game messages" do
+      file = File.join(GameMachine.app_root,'config','game_messages.proto')
+      obj = Protobuf::GameMessages.new(file)
+      fields = obj.create_entity_fields
+      puts fields.inspect
+    end
+
+    xit "extends protobuf messages" do
+      MessageLib::Entity.class_eval do
+        define_method :doit do
+          "done it"
+        end
+      end
+      entity = MessageLib::Entity.new.set_id('3')
+      puts entity.doit
+    end
+
+    xit "protobuf delimited" do
+      message = MessageLib::ClientMessage.new.add_entity(
+        MessageLib::Entity.new.set_id('asjfl;asjflkasjdfljaslf')
+      )
+      prefixed_bytes = message.to_prefixed_byte_array 
+      bytes = message.to_byte_array
+      puts prefixed_bytes.size
+      puts bytes.size
+      stream = JavaLib::ByteArrayInputStream.new(prefixed_bytes)
+      puts "stream byte count #{stream.available}"
+      ProtoLib::CodedInput.readRawVarint32(stream, 1)
+      puts "stream byte count #{stream.available}"
+      bytes = Java::byte[stream.available].new
+      stream.read(bytes,0,stream.available)
+    end
+
+    xit "marshal" do
+      system = Akka.instance.actor_system
+      serialization = JavaLib::SerializationExtension.get(system)
+      serializer = serialization.findSerializerFor(entity)
+      bytes = serializer.toBinary(entity)
+      new_entity = serializer.fromBinary(bytes,entity.get_class)
+    end
+    
+  end
+end

data/spec/model_spec.rb

@@ -0,0 +1,103 @@
+require 'spec_helper'
+require 'json'
+require 'benchmark'
+
+module GameMachine
+  describe "model" do
+
+    class ScopedModel < GameMachine::Model
+      attribute :health, Integer
+      attribute :name, String
+      attribute :defense_skill, Integer
+      attribute :attack_skill, Integer
+      set_id_scope :tm
+    end
+
+    class TestModel < GameMachine::Model
+      attribute :health, Integer
+      attribute :name, String
+      attribute :defense_skill, Integer
+      attribute :attack_skill, Integer
+    end
+
+    let(:scoped_model) do
+      model = ScopedModel.new(:health => 100, :id => 'myid')
+    end
+
+    let(:scoped_storage_entity) do
+      scoped_model.to_storage_entity
+    end
+
+    let(:test_model) do
+      model = TestModel.new(:health => 100, :id => 'myid')
+    end
+
+
+    context :scoped_model do
+
+      describe "#unscoped_id" do
+        it "should return unscoped id" do
+          scoped_model.id = 'tm|myid'
+          expect(scoped_model.unscoped_id).to eq 'myid'
+        end
+      end
+
+      describe "#scoped_id" do
+        it "should return scoped id" do
+          expect(scoped_model.scoped_id).to eq 'tm|myid'
+        end
+      end
+
+      describe "#from_entity" do
+        it "should unscope id" do
+          model = ScopedModel.from_entity(scoped_storage_entity,:json_storage)
+          expect(model.id).to eq 'myid'
+        end
+      end
+    end
+
+
+    describe "#save" do
+
+      it "should return true on success" do
+        expect(test_model.save).to be_true
+      end
+
+      it "should return false if id is nil" do
+        test_model.id = nil
+        expect(test_model.save).to be_false
+      end
+    end
+
+    describe "#save!" do
+      it "should raise an exception if id is nil" do
+        test_model.id = nil
+        expect {test_model.save!}.to raise_error
+      end
+
+      it "should not raise an exception if id is not nil" do
+        expect {test_model.save!}.to_not raise_error
+      end
+    end
+
+    describe "#to_json" do
+      it "should set klass" do
+        model_hash = JSON.parse(test_model.to_json)
+        expect(model_hash.has_key?('klass')).to be_true
+      end
+    end
+
+    describe "#to_entity" do
+      it "should return an entity with json entity" do
+        expect(test_model.to_entity.has_json_entity).to be_true
+      end
+    end
+
+    describe "#from_entity" do
+      it "should return a test model" do
+        entity = test_model.to_entity
+        expect(TestModel.from_entity(entity)).to be_a(TestModel)
+      end
+    end
+  end
+end

data/spec/mono_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+require_relative 'mono_test'
+require "base64"
+require 'socket'
+require "uri"
+require 'net/http'
+java_import 'java.util.concurrent.ThreadPoolExecutor'
+java_import 'java.util.concurrent.TimeUnit'
+java_import 'java.util.concurrent.LinkedBlockingQueue'
+java_import 'java.util.concurrent.FutureTask'
+java_import 'java.util.concurrent.Callable'
+
+CHARS = [*('a'..'z'),*('0'..'9')].flatten
+STR = Array.new(100) {|i| CHARS.sample}.join
+STR2 = Array.new(1000) {|i| CHARS.sample}.join
+
+
+module GameMachine
+  describe 'mono' do
+
+    it "mono gateway" do
+      Actor::Builder.new(Endpoints::MonoGateway).start
+      sleep 1
+      str = Array.new(1000) {|i| CHARS.sample}.join
+      message = MessageLib::Entity.new.set_id(STR)
+      message.set_destination('GameMachine.TestActor')
+      puts timed = Benchmark.realtime {
+        10.times do
+          Endpoints::MonoGateway.find.tell(message)
+        end
+      }
+      sleep 2
+    end
+
+  end
+end

data/spec/mono_test.rb

@@ -0,0 +1,18 @@
+class MonoTest < GameMachine::Actor::Base
+
+  def post_init(*args)
+    @vm = Mono::Vm.instance
+  end
+
+  def on_receive(message)
+    namespace = 'GameMachine'
+    klass = 'TestActor'
+    response = @vm.send_message(namespace,klass,message)
+    unless response && response.id == message.id
+      #thread_id = JRuby.reference(Thread.current).native_thread.id
+      puts "Response #{response}"
+    end
+    sender.tell(message,self)
+  end
+
+end

data/spec/navigation/detour_navmesh_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+module GameMachine
+  module Navigation
+    describe DetourNavmesh do
+
+      let(:meshfile) {File.join(GameMachine.app_root,'../data/meshes/test.bin')}
+      let(:bad_meshfile) {File.join(GameMachine.app_root,'../data/meshes/bad.bin')}
+      let(:navmesh_id) {1}
+
+      describe "#create" do
+        it "raises an error if meshfile does not exist" do
+          expect {
+            DetourNavmesh.create(navmesh_id,bad_meshfile)
+          }.to raise_error(/file does not exist/)
+        end
+      end
+
+      describe "#load_mesh!" do
+        it "should return 1 on success" do
+          expect(DetourNavmesh.create(navmesh_id,meshfile).load_mesh!).to eql(1)
+        end
+
+        it "should raise error on failure" do
+          #Detour.stub(:loadNavMesh).and_return(0)
+          expect {
+            DetourNavmesh.new(navmesh_id,meshfile).load_mesh!
+          }.to raise_error(/failed to load/)
+        end
+      end
+
+    end
+  end
+end

data/spec/navigation/detour_path_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+module GameMachine
+  module Navigation
+    describe DetourPath do
+
+      let(:meshfile) {File.join(GameMachine.app_root,'../data/meshes/test.bin')}
+
+      subject {DetourPath}
+
+      describe "#query_ref" do
+        it "returns a detour path for the given navmesh id" do
+          DetourNavmesh.create(2,meshfile)
+          expect(subject.query_ref(1)).to be_a(subject)
+        end
+
+        it "raises an error if the navmesh is not found" do
+          expect {
+            subject.query_ref(3)
+          }.to raise_error(/Navmesh with id 3 not found/)
+        end
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,40 @@
+
+ENV['APP_ROOT'] ||= File.expand_path(Dir.pwd)
+ENV['JAVA_ROOT'] = File.join(ENV['APP_ROOT'],'java')
+ENV['GAME_ENV'] = 'test'
+require 'rubygems'
+
+begin
+  require 'game_machine'
+rescue LoadError
+  require_relative '../lib/game_machine'
+end
+
+RSpec.configure do |config|
+  config.before(:suite) do
+    GameMachine::Application.initialize!('default',true)
+  end
+
+  config.before(:each) do
+    GameMachine::AuthHandlers::Base.instance
+    GameMachine::Application.create_grids
+    GameMachine::Application.start_actor_system
+    GameMachine::Application.start_core_systems
+    GameMachine::Application.start_handlers
+    #GameMachine::Application.start_game_systems
+    GameMachine::GameLoader.new.load_all
+  end
+
+  config.after(:each) do
+    GameMachine::Application.stop_actor_system
+  end
+
+  config.after(:suite) do
+    puts "after suite"
+  end
+end
+
+begin
+  require_relative 'message_expectations'
+rescue LoadError
+end