game_machine 0.0.8

data/lib/game_machine/object_db.rb

@@ -0,0 +1,67 @@
+module GameMachine
+  class ObjectDb < Actor::Base
+
+    class << self
+      def dbprocs
+        @dbprocs ||= java.util.concurrent.ConcurrentHashMap.new
+      end
+    end
+
+    attr_accessor :entities, :store
+    def post_init(*args)
+      @entities = {}
+      @store = DataStore.instance
+    end
+
+    def delete_entity(entity_id)
+      entities.delete(entity_id)
+      @store.delete(entity_id)
+    end
+
+    def delete_all
+      entities = {}
+      store.delete_all
+    end
+
+    def set_entity(entity)
+      entities[entity.id] = entity
+      WriteBehindCache.find_distributed(entity.id).tell(entity)
+    end
+
+    def get_entity(entity_id)
+      entity = entities.fetch(entity_id,nil)
+      if entity.nil?
+        if bytes = store.get(entity_id)
+          entity = MessageLib::Entity.parse_from(bytes)
+        end
+      end
+      entity
+    end
+
+    def on_receive(message)
+      if message.is_a?(MessageLib::ObjectdbUpdate)
+        procname = message.get_update_method.to_sym
+        current_entity_id = message.get_current_entity_id
+        update_entity = message.get_update_entity
+        unless current_entity = get_entity(current_entity_id)
+          current_entity = MessageLib::Entity.new.set_id(current_entity_id)
+        end
+        returned_entity = self.class.dbprocs[procname].call(
+          current_entity,update_entity
+        )
+        set_entity(returned_entity)
+        sender.tell(returned_entity || false)
+      elsif message.is_a?(MessageLib::ObjectdbPut)
+        set_entity(message.get_entity)
+        sender.tell(true)
+      elsif message.is_a?(MessageLib::ObjectdbGet)
+        sender.tell(get_entity(message.get_entity_id) || false)
+      elsif message.is_a?(MessageLib::ObjectdbDel)
+        delete_entity(message.get_entity_id)
+      else
+        unhandled(message)
+      end
+    end
+
+  end
+end

data/lib/game_machine/protobuf.rb

@@ -0,0 +1,6 @@
+
+if ['development','test'].include?(GameMachine.env)
+  require_relative '../../java/local_lib/protostuff-compiler-1.0.7-jarjar.jar'
+  require_relative 'protobuf/game_messages'
+  require_relative 'protobuf/generate'
+end

data/lib/game_machine/protobuf/game_messages.rb

@@ -0,0 +1,24 @@
+module GameMachine
+  module Protobuf
+    class GameMessages
+
+      attr_reader :messages, :starting_field_number
+      def initialize(message_file)
+        @starting_field_number = 1000
+        @messages = IO.readlines(message_file)
+      end
+
+      def create_entity_fields
+        [].tap do |fields|
+          messages.each do |line|
+            if line.match(/^\s*?message\s+?(\w+?)\s+?{/)
+              name = $1[0,1].downcase + $1[1..-1]
+              fields << "optional #{$1} #{name} = #{starting_field_number};"
+              @starting_field_number += 1
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/game_machine/protobuf/generate.rb

@@ -0,0 +1,113 @@
+require 'java'
+require 'pathname'
+require 'erb'
+require 'fileutils'
+
+java_import java.lang.System
+java_import com.dyuproject.protostuff.compiler.CachingProtoLoader
+java_import java.io.FileNotFoundException
+java_import com.dyuproject.protostuff.parser.ProtoUtil
+
+module GameMachine
+  module Protobuf
+    class Generate
+
+      attr_reader :app_root
+      def initialize(app_root)
+        @app_root = app_root
+      end
+
+      def self.compile(path)
+        loader = CachingProtoLoader.new
+        file = java.io.File.new(path)
+        ProtoUtil.parseProto(file)
+      end
+
+      def erb_template
+        File.join(app_root,'java','component.erb')
+      end
+
+      def java_src
+        File.join(app_root,'java','src','main','java','GameMachine', 'Messages')
+      end
+
+      def config_path
+        File.join(app_root,'config')
+      end
+
+      def write_components(proto)
+        messages = proto.getMessages.reject {|message| message.getName == 'Components'}
+        FileUtils.mkdir_p(java_src)
+        proto.getMessages.each do |message|
+          klass = message.getName
+          #puts "Message: #{message.getName}"
+          out = ERB.new(File.read(erb_template),nil,'-').result(binding)
+          src_file = File.join(java_src,"#{message.getName}.java")
+          File.open(src_file,'w') {|f| f.write out}
+          #message.getFields.each do |field|
+          #  puts field.getJavaType
+          #  puts field.toString
+          #end
+        end
+      end
+
+      def get_type(field)
+        if field.getJavaType.to_s == 'int'
+          return 'Integer'
+        elsif ['boolean','double','float','long'].include?(field.getJavaType.to_s)
+          return field.getJavaType.to_s.clone.capitalize
+        else
+          return field.getJavaType
+        end
+      end
+
+      def varname(name)
+        name.slice(0,1).downcase + name.slice(1..-1)
+      end
+
+      def classname(name)
+        name.slice(0,1).capitalize + name.slice(1..-1)
+      end
+
+      def generate
+        game_protofile = File.join(config_path,'game_messages.proto')
+        protofile = File.join(config_path,'messages.proto')
+
+        if File.exists?(game_protofile)
+          game_messages = File.read(game_protofile)
+          gm = Protobuf::GameMessages.new(game_protofile)
+          entity_fields = gm.create_entity_fields
+          game_entity_fields = entity_fields.join("\n")
+        else
+          game_messages = ''
+          game_entity_fields = ''
+        end
+        messages = File.read(protofile)
+
+        combined_messages = messages.sub('//GAME_MESSAGES',game_messages)
+        combined_messages = combined_messages.sub('//GAME_ENTITY_MESSAGES',game_entity_fields)
+        combined_messages_protofile = File.join(config_path,'combined_messages.proto')
+
+        File.open(combined_messages_protofile,'w') {|f| f.write(combined_messages)}
+
+        # test message defintion validity
+        #tmp_dir = File.join('/tmp/proto_test')
+        #FileUtils.rm_rf(tmp_dir)
+        #FileUtils.mkdir_p(tmp_dir)
+        #unless system("protoc #{combined_messages_protofile} --java_out=#{tmp_dir}")
+        #  return false
+        #end
+
+        # This just stops generating code when it hits an error, but does not
+        # throw an exception
+        proto = self.class.compile(combined_messages_protofile)
+
+        write_components(proto)
+        #FileUtils.rm(combined_messages_protofile)
+        combined_messages
+      end
+    end
+  end
+end
+
+

data/lib/game_machine/protobuf_extensions/entity_helper.rb

@@ -0,0 +1,11 @@
+module GameMachine
+  module ProtobufExtensions
+    module EntityHelper
+      def add_component(component)
+        send(:"set#{component.message_name}",component)
+      end
+    end
+  end
+end
+
+GameMachine::MessageLib::Entity.send(:include, GameMachine::ProtobufExtensions::EntityHelper)

data/lib/game_machine/reloadable_monitor.rb

@@ -0,0 +1,26 @@
+module GameMachine
+  class ReloadableMonitor < Actor::Base
+
+    def post_init(*args)
+      @scheduler = get_context.system.scheduler
+      @dispatcher = get_context.system.dispatcher
+      update_interval = 2000
+      schedule_update(update_interval)
+    end
+
+    def update_reloadable
+      GameMachine::Actor::Reloadable.update_paths
+    end
+
+    def on_receive(message)
+      if message == 'update_reloadable'
+        update_reloadable
+      end
+    end
+
+    def schedule_update(update_interval)
+      duration = JavaLib::Duration.create(update_interval, java.util.concurrent.TimeUnit::MILLISECONDS)
+      @scheduler.schedule(duration, duration, get_self, "update_reloadable", @dispatcher, nil)
+    end
+  end
+end

data/lib/game_machine/restart_watcher.rb

@@ -0,0 +1,17 @@
+module GameMachine
+  class RestartWatcher < Actor::Base
+
+    def post_init(*args)
+      schedule_message('check_restart',1000)
+    end
+
+    def on_receive(message)
+      if message == 'check_restart'
+        if Console::Server.restart?
+          Console::Server.exit!
+        end
+      end
+    end
+
+  end
+end

data/lib/game_machine/ruby_extensions/nilclass.rb

@@ -0,0 +1,10 @@
+class NilClass
+  # +nil+ is blank:
+  #
+  #   nil.blank? # => true
+  #
+  # @return [true]
+  def blank?
+    true
+  end
+end

data/lib/game_machine/ruby_extensions/string.rb

@@ -0,0 +1,17 @@
+class String
+  def constantize
+    self.split("::").inject(Module) {|acc, val| acc.const_get(val)}
+  end
+
+  def blank?
+    self !~ /\S/
+  end
+
+  def underscore
+    self.gsub(/::/, '/').
+    gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+    gsub(/([a-z\d])([A-Z])/,'\1_\2').
+    tr("-", "_").
+    downcase
+  end
+end

data/lib/game_machine/scheduler.rb

@@ -0,0 +1,23 @@
+module GameMachine
+  class Scheduler < Actor::Base
+
+    def preStart
+      scheduler = get_context.system.scheduler
+      dispatcher = get_context.system.dispatcher
+
+      every_second = JavaLib::Duration.create(1, java.util.concurrent.TimeUnit::SECONDS)
+      #scheduler.schedule(every_second, every_second, get_self, "every_second", dispatcher, nil)
+
+      every_10_seconds = JavaLib::Duration.create(10, java.util.concurrent.TimeUnit::SECONDS)
+      #scheduler.schedule(every_10_seconds, every_10_seconds, get_self, "every_10_seconds", dispatcher, nil)
+    end
+
+    def on_receive(message)
+      if message == 'every_10_seconds'
+        #GameMachine.logger.debug "Cluster members #{ClusterMonitor.cluster_members.keys.to_a.inspect}"
+        #GameMachine.logger.debug "Hashrings #{Akka.instance.hashring.buckets.inspect}"
+      end
+    end
+  end
+end
+

data/lib/game_machine/securerandom.rb

@@ -0,0 +1,6 @@
+require 'securerandom'
+module SecureRandom
+  def self.hex(s)
+    raise NotImplementedError
+  end
+end

data/lib/game_machine/settings.rb

@@ -0,0 +1,11 @@
+require 'settingslogic'
+
+module GameMachine
+  class Settings < Settingslogic
+    source  File.expand_path(
+      ENV['CONFIG_FILE'] || File.join(ENV['APP_ROOT'], "config/config.yml")
+    )
+    namespace ENV['GAME_ENV']
+
+  end 
+end

data/lib/game_machine/system_monitor.rb

@@ -0,0 +1,19 @@
+module GameMachine
+  class SystemMonitor < Actor::Base
+
+    def post_init(*args)
+    end
+
+    def preStart
+      #getContext.system.eventStream.subscribe(getSelf, JavaLib::DeadLetter.java_class)
+    end
+
+    def on_receive(message)
+      if message.is_a?(JavaLib::DeadLetter)
+        #GameMachine.logger.debug("DeadLetter #{message.message}")
+      else
+        #GameMachine.logger.info("Unrecognized message #{message}")
+      end
+    end
+  end
+end

data/lib/game_machine/system_stats.rb

@@ -0,0 +1,24 @@
+module GameMachine
+  class SystemStats < Actor::Base
+
+    def post_init(*args)
+      if getContext.system.name == 'cluster'
+        @cluster = JavaLib::Cluster.get(getContext.system)
+      end
+      schedule_message('update',60,:seconds)
+    end
+
+    def on_receive(message)
+      if message.is_a?(String) and message == 'update'
+
+        Grid.grids.each do |name,grid|
+          object_index_size = grid.objectIndex.length
+          cellscache_size = grid.cellsCache.length
+          cells_size = grid.cells.length
+          GameMachine.logger.info "Grid #{name} ondex_size: #{object_index_size} ccache_size: #{cellscache_size} csize: #{cells_size}"
+        end
+      end
+      
+    end
+  end
+end

data/lib/game_machine/uniqueid.rb

@@ -0,0 +1,23 @@
+
+require 'securerandom'
+require 'digest/md5'
+
+module GameMachine
+  class Uniqueid
+    class << self
+      def generate_token(id)
+        digest(id + random_salt)
+      end
+
+
+      def random_salt
+        SecureRandom.urlsafe_base64
+      end
+
+
+      def digest(string)
+        Digest::MD5.hexdigest string
+      end
+    end
+  end
+end

data/lib/game_machine/vector.rb

@@ -0,0 +1,95 @@
+module GameMachine
+  class Vector
+
+    attr_accessor :x, :y, :z
+
+    def self.from_array(ar)
+      new(ar[0],ar[1],ar[2])
+    end
+
+    def self.from(v)
+      new(v.x,v.y,v.z)
+    end
+
+    def initialize(x=0.0,y=0.0,z=0.0)
+      @x = x
+      @y = y
+      @z = z
+    end
+
+    def==(v)
+      @x == v.x && @y = v.y && @z = v.z
+    end
+
+
+    def zero?
+      @x == 0 && @y == 0 && z == 0
+    end
+
+    def zero
+      @x = 0.0
+      @y = 0.0
+      @z = 0.0
+    end
+
+    def set(new_x,new_y,new_z)
+      @x = new_x
+      @y = new_y
+      @z = new_z
+    end
+
+    def distance_squared(v)
+      dx = @x - v.x
+      dy = @y - v.y
+      #dz = @z - v.z
+      #(dx * dx + dy * dy + dz * dz);
+      (dx * dx + dy * dy);
+    end
+
+    def distance(v)
+      Math.sqrt(distance_squared(v))
+    end
+
+    def lerp(vector,percent)
+      @x = lerp_float(x,vector.x,percent)
+      @y = lerp_float(y,vector.y,percent)
+    end
+
+    def lerp_float(start_loc,end_loc,percent)
+      start_loc + (percent * (end_loc - start_loc))
+    end
+
+    def interpolate(vector,change_amount)
+      @x=(1-change_amount)*@x + change_amount*vector.x
+      @y=(1-change_amount)*@y + change_amount*vector.y
+      #@z=(1-change_amount)*@z + change_amount*vector.z
+    end
+
+    def -(v1)
+      self.class.new( @x - v1.x, @y - v1.y )
+    end
+
+    def self.norm(i)
+      r = 0
+      length = Math.sqrt(i*i)
+      if length != 0
+        r = i * (1/length)
+      end
+      r
+    end
+
+    def normalize
+      vector = self.class.new
+      length = Math.sqrt(@x*@x + @y*@y)
+      if length != 0
+        vector.x = @x * (1/length)
+        vector.y = @y * (1/length)
+      end
+      vector
+    end
+
+    def inspect
+      "#{x} #{y} #{z}"
+    end
+  end
+end