game_machine 0.0.11 → 1.0.2

data/java/src/main/java/com/game_machine/core/GameMachineLoader.java

@@ -1,25 +0,0 @@
-package com.game_machine.core;
-
-import java.util.logging.Logger;
-
-import akka.actor.ActorSystem;
-import akka.actor.Props;
-
-public class GameMachineLoader {
-
-	
-
-	private static final Logger log = Logger.getLogger(GameMachineLoader.class.getName());
-	private static ActorSystem actorSystem;
-
-	public static ActorSystem getActorSystem() {
-		return actorSystem;
-	}
-	
-	public void run(ActorSystem newActorSystem, String gameHandler) {
-		Thread.currentThread().setName("game-machine");
-		actorSystem = newActorSystem;
-		actorSystem.actorOf(Props.create(EventStreamHandler.class), EventStreamHandler.class.getSimpleName());
-	}
-
-}

data/java/src/main/java/com/game_machine/core/Grid.java

@@ -1,195 +0,0 @@
-package com.game_machine.core;
-
-import java.util.ArrayList;
-import java.util.HashSet;
-import java.util.Set;
-import java.util.concurrent.ConcurrentHashMap;
-
-public class Grid {
-
-	private float max;
-	private int cellSize = 0;
-	private float convFactor;
-	private int width;
-	private int cellCount;
-
-	public ConcurrentHashMap<String, GridValue> deltaIndex = new ConcurrentHashMap<String, GridValue>();
-	public ConcurrentHashMap<String, GridValue> objectIndex = new ConcurrentHashMap<String, GridValue>();
-	public ConcurrentHashMap<Integer, ConcurrentHashMap<String, GridValue>> cells = new ConcurrentHashMap<Integer, ConcurrentHashMap<String, GridValue>>();
-	public ConcurrentHashMap<Integer, Set<Integer>> cellsCache = new ConcurrentHashMap<Integer, Set<Integer>>();
-
-	public Grid(int max, int cellSize) {
-		this.max = max;
-		this.cellSize = cellSize;
-		this.convFactor = 1.0f / this.cellSize;
-		this.width = (int) (this.max / this.cellSize);
-		this.cellCount = this.width * this.width;
-	}
-
-	public int getWidth() {
-		return this.width;
-	}
-
-	public int getCellCount() {
-		return this.cellCount;
-	}
-
-	public Set<Integer> cellsWithinRadius(float x, float y) {
-		int cellHash = hash(x, y);
-		return cellsWithinRadius(cellHash, x, y);
-	}
-
-	public Set<Integer> cellsWithinRadius(int cellHash, float x, float y) {
-		int key = cellHash;
-		Set<Integer> cells = cellsCache.get(key);
-		if (cells != null) {
-			return cells;
-		}
-		cells = new HashSet<Integer>();
-
-		int offset = this.cellSize;
-
-		int startX = (int) (x - offset);
-		int startY = (int) (y - offset);
-		int endX = (int) (x + offset);
-		int endY = (int) (y + offset);
-
-		for (int rowNum = startX; rowNum <= endX; rowNum += this.cellSize) {
-			for (int colNum = startY; colNum <= endY; colNum += this.cellSize) {
-				if (rowNum >= 0 && colNum >= 0) {
-					cells.add(hash(rowNum, colNum));
-				}
-			}
-		}
-		cellsCache.put(key, cells);
-		return cells;
-	}
-
-	public ArrayList<GridValue> neighbors(float x, float y, String entityType) {
-		int myCell = hash(x, y);
-		return neighbors(myCell, x, y, entityType);
-	}
-
-	public ArrayList<GridValue> neighbors(int myCell, float x, float y, String entityType) {
-		ArrayList<GridValue> result;
-
-		GridValue[] gridValues;
-		result = new ArrayList<GridValue>();
-		Set<Integer> cells = cellsWithinRadius(myCell, x, y);
-		for (int cell : cells) {
-			gridValues = gridValuesInCell(cell);
-			if (gridValues != null) {
-				for (GridValue gridValue : gridValues) {
-					if (gridValue != null) {
-						if (entityType == null) {
-							result.add(gridValue);
-						} else if (gridValue.entityType.equals(entityType)) {
-							result.add(gridValue);
-						}
-					}
-				}
-			}
-		}
-		return result;
-	}
-
-	public GridValue[] gridValuesInCell(int cell) {
-		ConcurrentHashMap<String, GridValue> cellGridValues = cells.get(cell);
-
-		if (cellGridValues != null) {
-			GridValue[] a = new GridValue[cellGridValues.size()];
-			cellGridValues.values().toArray(a);
-			return a;
-			// return cellGridValues.values();
-		} else {
-			return null;
-		}
-	}
-
-	public void updateFromDelta(GridValue[] gridValues) {
-		for (GridValue gridValue : gridValues) {
-			if (gridValue != null) {
-				objectIndex.put(gridValue.id, gridValue);
-			}
-		}
-	}
-
-	public GridValue[] currentDelta() {
-		GridValue[] a = new GridValue[deltaIndex.size()];
-		deltaIndex.values().toArray(a);
-		deltaIndex.clear();
-		return a;
-	}
-
-	public ArrayList<GridValue> getNeighborsFor(String id, String entityType) {
-		GridValue gridValue = get(id);
-		if (gridValue == null)
-		{
-			return null;
-		}
-		return neighbors(gridValue.x, gridValue.y, entityType);
-	}
-	
-	public GridValue get(String id) {
-		return objectIndex.get(id);
-	}
-
-	public void remove(String id) {
-		GridValue indexValue = objectIndex.get(id);
-		if (indexValue != null) {
-			int cell = indexValue.cell;
-			ConcurrentHashMap<String, GridValue> cellGridValues = cells.get(cell);
-			if (cellGridValues != null) {
-				cellGridValues.remove(id);
-			}
-			objectIndex.remove(id);
-		}
-	}
-
-	public Boolean set(String id, float x, float y, float z, String entityType) {
-		GridValue oldValue = objectIndex.get(id);
-
-		if (oldValue != null) {
-			if (oldValue.x == x && oldValue.y == y) {
-				return false;
-			}
-		}
-
-		int cell = hash(x, y);
-		
-
-		GridValue gridValue;
-		gridValue = new GridValue(id, cell, x, y, z, entityType);
-
-		if (oldValue == null) {
-			objectIndex.put(id, gridValue);
-		} else {
-			if (oldValue.cell != cell) {
-				ConcurrentHashMap<String, GridValue> cellGridValues = cells.get(oldValue.cell);
-				cellGridValues.remove(id);
-				if (cellGridValues.size() == 0) {
-					cells.remove(oldValue.cell);
-				}
-					
-			}
-			objectIndex.replace(id, gridValue);
-		}
-		
-		if (!cells.containsKey(cell)) {
-			cells.put(cell, new ConcurrentHashMap<String, GridValue>());
-		}
-		cells.get(cell).put(id, gridValue);
-
-		//deltaIndex.put(id, gridValue);
-
-		return true;
-	}
-
-	public int hash2(float x, float y) {
-		return (int) (Math.floor(x / this.cellSize) + Math.floor(y / this.cellSize) * width);
-	}
-
-	public int hash(float x, float y) {
-		return (int) ((x * this.convFactor)) + (int) ((y * this.convFactor)) * this.width;
-	}
-}

data/java/src/main/resources/logback.xml

@@ -1,14 +0,0 @@
-<configuration>
-
-  <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
-    <!-- encoders are assigned the type
-         ch.qos.logback.classic.encoder.PatternLayoutEncoder by default -->
-    <encoder>
-      <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
-    </encoder>
-  </appender>
-
-  <root level="info">
-    <appender-ref ref="STDOUT" />
-  </root>
-</configuration>

data/java/src/main/resources/logging.properties

@@ -1,3 +0,0 @@
-
-handlers = java.util.logging.ConsoleHandler.level
-java.util.logging.ConsoleHandler.level = INFO

data/lib/game_machine/actor/mono_actor.rb

@@ -1,89 +0,0 @@
-require 'base64'
-module GameMachine
-  module Actor
-    class MonoActor < Base
-
-      def self.images
-        @@images ||= java.util.concurrent.ConcurrentHashMap.new
-      end
-
-      def self.call_mono(message,image,domain,namespace,klass)
-        thread_id = JRuby.reference(Thread.current).native_thread.id
-        #Mono.attach_current_thread(domain)
-        bytes = message.to_byte_array
-        byte_string = bytes.to_s
-        encoded_bytes = Base64.encode64(byte_string)
-        encoded_bytes_size = encoded_bytes.size
-        actor_id = thread_id.to_s
-        if actor_id == '' or actor_id.nil?
-          puts "actor_id invalid #{actor_id}"
-          return
-        end
-
-        ns_mem_buf = FFI::MemoryPointer.new(:string, namespace.size)
-        ns_mem_buf.put_string(0, namespace)
-        klass_mem_buf = FFI::MemoryPointer.new(:string, klass.size)
-        klass_mem_buf.put_string(0, klass)
-        bytes_mem_buf = FFI::MemoryPointer.new(:string, encoded_bytes_size)
-        bytes_mem_buf.put_string(0, encoded_bytes)
-        mem_buf = FFI::MemoryPointer.new(:string, actor_id.size)
-        mem_buf.put_string(0, actor_id)
-
-        #puts "ENCODED #{encoded_bytes} = #{encoded_bytes_size}"
-        #res = Mono.ftest(@namespace,@klass,actor_id, encoded_bytes, encoded_bytes_size)
-        #puts 'before_on_receive'
-        res = Mono.on_receive2(domain,image,ns_mem_buf,klass_mem_buf,mem_buf, bytes_mem_buf, encoded_bytes_size)
-        #puts 'after_on_receive'
-        #res = Mono.on_receive(@mono_object,bytes.to_s,bytes.size)
-        if res == 0
-          raise "Mono managed code threw exception, restarting actor"
-        end
-      end
-
-      def post_init(*args)
-        @path = args[0]
-        @namespace = args[1]
-        @klass = args[2]
-        @domain = args[3]
-        @image = args[4]
-      end
-
-      def create_mono_object
-        @thread_id = JRuby.reference(Thread.current).native_thread.id
-        if @path.nil? or @namespace.nil? or @klass.nil?
-          raise "Missing post_init args"
-        end
-        Mono.attach_current_thread(@domain)
-        @image = Mono.load_assembly(@domain,@path)
-        #@mono_object = Mono.create_object(image,namespace,klass)
-        #if @mono_object == 0
-        #  raise "Mono.create_object failed"
-        #end
-      end
-
-      def ensure_image
-        thread_id = JRuby.reference(Thread.current).native_thread.id
-        image = self.class.images.fetch(thread_id,nil)
-        if image.nil?
-          Mono.attach_current_thread(@domain)
-          image = Mono.load_assembly(@domain,@path)
-          self.class.images[thread_id] = image
-        end
-        image
-      end
-
-      def postStop
-        puts 'postStop'
-        #Mono.destroy_object(@mono_object)
-      end
-
-      def on_receive(message)
-        Mono.attach_current_thread(@domain)
-
-        self.class.call_mono(message,@image,@domain,@namespace,@klass)
-        sender.tell(message,self)
-      end
-
-    end
-  end
-end

data/lib/game_machine/auth_handlers/base.rb

@@ -1,21 +0,0 @@
-require 'forwardable'
-
-module GameMachine
-  module AuthHandlers
-    class Base
-      include Singleton
-      extend Forwardable
-
-      def_delegators :@handler, :authorize, :authtoken_for
-
-      def initialize
-        @handler = Application.config.auth_handler.constantize.new
-      end
-
-      def set_handler(handler_name)
-        @handler = handler_name.constantize.new
-      end
-    end
-  end
-end
-

data/lib/game_machine/auth_handlers/public.rb

@@ -1,34 +0,0 @@
-require 'digest/md5'
-module GameMachine
-  module AuthHandlers
-    class Public
-
-      def initialize
-        @sessions = {}
-      end
-
-      def add_user(username,authtoken)
-        @sessions[username] = authtoken
-      end
-
-      def authorize(user,pass)
-        authtoken(user,'public')
-      end
-
-      def authtoken_for(user)
-        if @sessions.has_key?(user)
-          @sessions[user]
-        else
-          @sessions[user] = authtoken(user,'public')
-        end
-      end
-
-      private
-
-      def authtoken(user,pass)
-        Digest::MD5.hexdigest("#{user}#{pass}#{rand(10000)}")
-      end
-    end
-  end
-end
-

data/lib/game_machine/endpoints/mono_gateway.rb

@@ -1,87 +0,0 @@
-module GameMachine
-  module Endpoints
-    class MonoGateway < Actor::Base
-
-      def post_init(*args)
-        @clients = {}
-        @sender = nil
-        @socket = nil
-        @mono_connected = false
-        @last_mono_ping = nil
-      end
-
-      def preStart
-        mgr = JavaLib::Udp.get(getContext.system).getManager
-        inet = JavaLib::InetSocketAddress.new(
-          Application.config.mono_gateway_host,
-          Application.config.mono_gateway_port
-        )
-        mgr.tell( JavaLib::UdpMessage.bind(getSelf,inet), getSelf)
-      end
-
-      def on_receive(message)
-        if message.kind_of?(JavaLib::Udp::Bound)
-          @socket = getSender
-        elsif message.is_a?(MessageLib::Entity)
-          handle_outgoing(message)
-        elsif message.kind_of?(JavaLib::Udp::Received)
-          handle_incoming(message)
-        elsif message == JavaLib::UdpMessage::unbind
-          @socket.tell(message, get_self)
-        elsif message.kind_of?(JavaLib::Udp::Unbound)
-          get_context.stop(get_self)
-        else
-          unhandled(message)
-        end
-      end
-
-      private
-
-      def handle_outgoing(message)
-        if message.has_destination
-          if @sender
-            byte_string = JavaLib::ByteString.from_array(message.to_byte_array)
-            udp_message = JavaLib::UdpMessage.send(byte_string, @sender)
-            @socket.tell(udp_message, get_self)
-          else
-            GameMachine.logger.error "#{self.class.name} cannot send outgoing message (no sender) "
-          end
-        else
-          GameMachine.logger.error "#{self.class.name} destination missing (outgoing)"
-        end
-      rescue Exception => e
-        GameMachine.logger.error "#{self.class.name} #{e.to_s}"
-      end
-
-      def handle_incoming(message)
-        @sender = message.sender
-        entity = MessageLib::Entity.parse_from(message.data.to_array)
-        if entity.id == 'ping'
-          unless @mono_connected
-            GameMachine.logger.info "Mono server connected"
-          end
-          @mono_connected = true
-          @last_mono_ping = Time.now.to_i
-          echo(message)
-        elsif entity.has_destination
-          destination = entity.destination.sub(/^\//,'')
-          destination = destination.gsub('/','::')
-          entity.set_destination(nil)
-          GameMachine.logger.info "#{self.class.name} incoming to #{destination}"
-          Actor::Base.find(destination).tell(entity,get_self)
-        else
-          GameMachine.logger.error "#{self.class.name} destination missing (incoming)"
-        end
-      rescue Exception => e
-        GameMachine.logger.error "#{self.class.name} #{e.to_s}"
-      end
-
-      def echo(message)
-        byte_string = JavaLib::ByteString.from_array(message.data.to_array)
-        udp_message = JavaLib::UdpMessage.send(byte_string, message.sender)
-        @socket.tell(udp_message,get_self)
-      end
-
-    end
-  end
-end