game_machine 0.0.8

data/lib/game_machine/message_buffer.rb

@@ -0,0 +1,58 @@
+module GameMachine
+  class MessageBuffer
+
+    attr_reader :bytes, :next_message_length
+    def initialize
+      reset
+    end
+
+    def messages
+      byte_messages = []
+      return byte_messages if bytes.nil?
+      stream = JavaLib::ByteArrayInputStream.new(bytes)
+      if next_message_length == 0
+        @next_message_length = read_message_length(stream)
+      end
+      while next_message_length >= 1 && stream.available >= next_message_length
+        message_bytes = Java::byte[next_message_length].new
+        stream.read(message_bytes,0,next_message_length)
+        byte_messages << message_bytes
+        if stream.available >= 1
+          @next_message_length = read_message_length(stream)
+          if next_message_length > stream.available
+            @bytes = Java::byte[stream.available].new
+            stream.read(@bytes,0,stream.available)
+          end
+        else
+          reset
+        end
+      end
+      byte_messages
+    end
+
+    def add_bytes(bytes_to_add)
+      if @bytes.nil?
+        @bytes = bytes_to_add
+      else
+        new_bytes = Java::byte[bytes_to_add.length + @bytes.length].new
+        java.lang.System.arraycopy(@bytes, 0, new_bytes, 0, @bytes.length)
+        java.lang.System.arraycopy(bytes_to_add, 0, new_bytes, @bytes.length, bytes_to_add.length)
+        @bytes = new_bytes
+      end
+    end
+
+    private
+
+    def reset
+      @next_message_length = 0
+      @bytes = nil
+    end
+
+    def read_message_length(s)
+      ProtoLib::CodedInput.readRawVarint32(s)
+    rescue Exception => e
+      raise "Error reading protobuf message length: #{e.to_s}"
+    end
+
+  end
+end

data/lib/game_machine/message_queue.rb

@@ -0,0 +1,63 @@
+module GameMachine
+  class MessageQueue < Actor::Base
+
+    def preStart
+      if getContext.system.name == 'cluster'
+        @mediator = JavaLib::DistributedPubSubExtension.get(get_context.system).mediator
+      end
+    end
+
+    def on_receive(message)
+      unless @mediator
+        GameMachine.logger.info "Cluster mediator not found, message queue disabled!"
+        unhandled(message)
+        return
+      end
+      if message.is_a?(MessageLib::Publish)
+        publish(message)
+      elsif message.is_a?(MessageLib::Subscribe)
+        subscribe(message)
+      elsif message.is_a?(MessageLib::Unsubscribe)
+        unsubscribe(message)
+      elsif message.is_a?(JavaLib::DistributedPubSubMediator::SubscribeAck)
+        GameMachine.logger.debug "Subscribed"
+      else
+        unhandled(message)
+      end
+    end
+
+    private
+
+    def subscribe(message)
+      if message.topic
+        sub = Java::akka::contrib::pattern::DistributedPubSubMediator::Subscribe.new(message.topic, get_sender)
+      else
+        sub = Java::akka::contrib::pattern::DistributedPubSubMediator::Put.new(get_sender)
+      end
+      @mediator.tell(sub, get_sender)
+    end
+
+    def unsubscribe(message)
+      sub = Java::akka::contrib::pattern::DistributedPubSubMediator::Unsubscribe.new(message.topic, get_sender)
+      @mediator.tell(sub, get_sender)
+    end
+
+    def publish(publish)
+      if publish.message.has_chat_message
+        publish_message = publish.message #publish.message.chat_message.message
+      else
+        publish_message = publish.message
+      end
+      if publish.topic
+        message = Java::akka::contrib::pattern::DistributedPubSubMediator::Publish.new(publish.topic, publish_message)
+      elsif publish.path
+        message = Java::akka::contrib::pattern::DistributedPubSubMediator::SendToAll.new(publish.path, publish_message,true)
+      else
+        GameMachine.logger.error("Publish missing topic or path")
+        return
+      end
+      @mediator.tell(message, get_sender)
+    end
+
+  end
+end

data/lib/game_machine/model.rb

@@ -0,0 +1,125 @@
+require 'json'
+# JSON models that will get converted appropriately when sent to or
+# received by actors.
+
+# JsonEntity messages always get converted.  JsonStorage messages
+# are a special case for the object database and are left untouched
+# by the tell/ask/on_receive filters
+
+require 'ostruct'
+
+module GameMachine
+  class Model < OpenStruct
+    include GameMachine::Commands
+
+    class << self
+
+      def attribute(*args)
+
+      end
+
+      def find!(id)
+        scoped_id = scope_for(id)
+        if entity = Commands::Base.commands.datastore.get!(scoped_id)
+          from_entity(entity,:json_storage)
+        else
+          nil
+        end
+      end
+
+      def find(id,timeout=1000)
+        scoped_id = scope_for(id)
+        if entity = Commands::Base.commands.datastore.get(scoped_id,timeout)
+          from_entity(entity,:json_storage)
+        else
+          nil
+        end
+      end
+
+      # TODO cache klass names in hash to avoid constantize
+      def from_entity(entity,type=:json_entity)
+        if type == :json_storage
+          json = entity.json_storage.json
+        else
+          json = entity.json_entity.json
+        end
+
+        attributes = JSON.parse(json)
+        if klass = attributes.delete('klass')
+          model = klass.constantize.new(attributes)
+          model.id = model.unscoped_id
+          model
+        else
+          raise "Unable to find klass attribute in #{attributes.inspect}"
+        end
+      end
+
+      def scope_for(id)
+        if id_scope
+          "#{id_scope}|#{id}"
+        else
+          id
+        end
+      end
+
+      def set_id_scope(scope)
+        @id_scope = scope
+      end
+
+      def id_scope
+        @id_scope
+      end
+    end
+
+    def attributes
+      self.marshal_dump
+    end
+
+    def scoped_id
+      if self.class.id_scope
+        self.class.scope_for(id)
+      else
+        id
+      end
+    end
+
+    def unscoped_id
+      if self.class.id_scope
+        id.sub(/^#{self.class.id_scope}\|/,'')
+      else
+        id
+      end
+    end
+
+    def to_json
+      attributes['id'] = scoped_id
+      JSON.dump(attributes.merge(:klass => self.class.name))
+    end
+
+    def to_entity
+      MessageLib::Entity.new.set_id(scoped_id).set_json_entity(to_json_entity)
+    end
+
+    def to_json_entity
+      MessageLib::JsonEntity.new.set_json(to_json).set_klass(self.class.name)
+    end
+
+    def to_storage_entity
+      MessageLib::Entity.new.set_id(scoped_id).set_json_storage(to_json_storage)
+    end
+
+    def to_json_storage
+      MessageLib::JsonStorage.new.set_json(to_json)
+    end
+
+    def save
+      commands.datastore.put(to_storage_entity)
+    end
+
+    def save!
+      commands.datastore.put!(to_storage_entity)
+    end
+
+  end
+end
+

data/lib/game_machine/models.rb

@@ -0,0 +1,3 @@
+
+require_relative 'models/region'
+require_relative 'models/player_status_update'

data/lib/game_machine/models/player_status_update.rb

@@ -0,0 +1,8 @@
+module GameMachine
+  module Models
+    class PlayerStatusUpdate < Model
+      attribute :player_id, String
+      attribute :status, String
+    end
+  end
+end

data/lib/game_machine/models/region.rb

@@ -0,0 +1,9 @@
+module GameMachine
+  module Models
+    class Region < Model
+      attribute :name, String
+      attribute :server, String
+      attribute :manager, String
+    end
+  end
+end

data/lib/game_machine/mono_server.rb

@@ -0,0 +1,20 @@
+module GameMachine
+  class MonoServer
+
+    attr_reader :mono_path
+    def initialize
+      @mono_path = File.join(GameMachine.app_root,'mono','server')
+    end
+
+    def run!
+      # mono server blocks.  We run in a loop so if it dies or we restart it,
+      # it will just get restarted
+      Thread.new do
+        loop do
+          system("cd #{mono_path} && mono server.exe #{Application.config.mono_gateway_port}")
+          sleep 10
+        end
+      end
+    end
+  end
+end

data/lib/game_machine/navigation.rb

@@ -0,0 +1,4 @@
+require_relative 'navigation/detour'
+require_relative 'navigation/detour_navmesh'
+require_relative 'navigation/detour_path'
+require_relative 'navigation/path'

data/lib/game_machine/navigation/detour.rb

@@ -0,0 +1,20 @@
+require 'ffi'
+require 'benchmark'
+module GameMachine
+  module Navigation
+    module Detour
+      extend FFI::Library
+      sofile = File.join(File.dirname(__FILE__), '../../../pathfinding/bin/libdetour_path.so')
+      if File.exists?(sofile)
+        ffi_lib sofile
+        attach_function :findPath, [:pointer,:float,:float,:float,:float,:float,:float, :int, :pointer], :int
+        attach_function :loadNavMesh, [:int, :string], :int
+        attach_function :freePath, [:pointer], :void
+        attach_function :getPathPtr, [:int], :pointer
+        attach_function :freeQuery, [:pointer], :void
+        attach_function :getQuery, [:int], :pointer
+      end
+
+    end
+  end
+end

data/lib/game_machine/navigation/detour_navmesh.rb

@@ -0,0 +1,53 @@
+module GameMachine
+  module Navigation
+    class DetourNavmesh
+
+      def self.meshes
+        if @meshes
+          @meshes
+        else
+          @meshes = java.util.concurrent.ConcurrentHashMap.new
+        end
+      end
+
+      def self.create(id,meshfile)
+        if meshes.has_key?(id)
+          return false
+        end
+        meshes[id] = new(id,meshfile)
+      end
+
+      def self.find(id)
+        meshes.fetch(id,nil)
+      end
+
+      attr_reader :id, :meshfile, :loaded
+      def initialize(id,meshfile)
+        @id = id
+        @meshfile = meshfile
+        unless File.exists?(meshfile)
+          raise "Navigation mesh file does not exist (#{meshfile})"
+        end
+        @loaded = false
+      end
+
+      def loaded?
+        loaded
+      end
+
+      def load_mesh!
+        if loaded?
+          raise "DetourNavmesh #{id} already loaded"
+        end
+
+        load_res = Detour.loadNavMesh(id,meshfile)
+        unless load_res == 1
+          raise "DetourNavmesh #{id} failed to load (#{load_res})"
+        end
+        @loaded = true
+        load_res
+      end
+
+    end
+  end
+end

data/lib/game_machine/navigation/detour_path.rb

@@ -0,0 +1,53 @@
+module GameMachine
+  module Navigation
+    class DetourPath
+
+      def self.query_ref(navmesh_id)
+        if navmesh = DetourNavmesh.find(navmesh_id)
+          Thread.current[navmesh_id.to_s.to_sym] ||= new(navmesh)
+        else
+          raise "Navmesh with id #{navmesh_id} not found"
+        end
+      end
+
+      attr_reader :navmesh, :error, :max_paths
+      def initialize(navmesh)
+        @navmesh = navmesh
+        @max_paths = 256
+        @error = nil
+
+        unless navmesh.loaded?
+          raise "Navmesh #{navmesh.id} not loaded"
+        end
+        @query_ptr = Detour.getQuery(navmesh.id)
+      end
+
+      def destroy_query
+        Detour.freeQuery(@query_ptr)
+      end
+
+      # Detour coords:
+      # z = unity x, x = unity z
+      def find_path( start_x, start_y, start_z, end_x, end_y, end_z,straight_path)
+
+        @error = nil
+
+        ptr = Detour.getPathPtr(max_paths)
+        paths_found = Detour.findPath(
+          @query_ptr,start_z,start_y,
+          start_x, end_z,end_y,end_x, straight_path, ptr
+        )
+
+        if paths_found <= 0
+          @error = paths_found
+          return []
+        end
+
+        fptr = ptr.read_pointer()
+        path = fptr.null? ? [] : ptr.get_array_of_float(0,paths_found*3)
+        Detour.freePath(ptr)
+        path.each_slice(3).map {|i| Vector.new(i[2],i[1],i[0])}.to_a
+      end
+    end
+  end
+end

data/lib/game_machine/navigation/path.rb

@@ -0,0 +1,31 @@
+module GameMachine
+  module Navigation
+    class Path
+
+      attr_accessor :path, :current_location
+      attr_reader :current_point
+      def initialize(path,current_location)
+        @path = path
+        @current_point = path.first
+        @current_location = current_location
+      end
+
+      def set_path(path)
+        @path = path
+        @current_point = path.first
+      end
+
+      def next_point
+        if point_reached?
+          @current_point = path.shift
+        end
+        @current_point
+      end
+
+      def point_reached?
+        return true if current_point.nil?
+        current_location.distance(current_point) < 1
+      end
+    end
+  end
+end