game_machine 0.0.11 → 1.0.2

data/java/project/src/main/java/com/game_machine/core/GameMessageActor.java

@@ -0,0 +1,44 @@
+package com.game_machine.core;
+
+import GameMachine.Messages.ClientManagerEvent;
+import GameMachine.Messages.GameMessage;
+
+public class GameMessageActor extends GameActor {
+
+	
+	public void onReceive(Object message) throws Exception {
+		if (message instanceof GameMessage) {
+			GameMessage gameMessage = (GameMessage)message;
+			setPlayerId(gameMessage.playerId);
+			onGameMessage(gameMessage);
+		} else if (message instanceof ClientManagerEvent) {
+			ClientManagerEvent clientManagerEvent = (ClientManagerEvent)message;
+			if (clientManagerEvent.event.equals("disconnected")) {
+				onPlayerDisconnect(clientManagerEvent.player_id);
+			}
+		} else {
+			unhandled(message);
+		}
+	}
+	
+	@Override
+	public void preStart() {
+		awake();
+	}
+	
+	public void awake() {
+		
+	}
+	
+	public void onGameMessage(GameMessage gameMessage) {
+		
+	}
+	
+	public void sendGameMessage(GameMessage gameMessage, String playerId) {
+		PlayerCommands.sendGameMessage(gameMessage, playerId);
+	}
+	
+	private void onPlayerDisconnect(String playerId) {
+		
+	}
+}

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

@@ -0,0 +1,255 @@
+package com.game_machine.core;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+
+import GameMachine.Messages.TrackData;
+
+public class Grid {
+
+	private float max;
+	private int cellSize = 0;
+	private float convFactor;
+	private int width;
+	private int cellCount;
+
+	private MovementVerifier movementVerifier;
+	
+	public static ConcurrentHashMap<String, Grid> grids = new ConcurrentHashMap<String, Grid>();
+	
+	private ConcurrentHashMap<String, TrackData> deltaIndex = new ConcurrentHashMap<String, TrackData>();
+	private ConcurrentHashMap<String, TrackData> objectIndex = new ConcurrentHashMap<String, TrackData>();
+	private ConcurrentHashMap<String, Integer> cellsIndex = new ConcurrentHashMap<String, Integer>();
+	private ConcurrentHashMap<Integer, ConcurrentHashMap<String, TrackData>> cells = new ConcurrentHashMap<Integer, ConcurrentHashMap<String, TrackData>>();
+	private ConcurrentHashMap<Integer, Set<Integer>> cellsCache = new ConcurrentHashMap<Integer, Set<Integer>>();
+
+	public static void resetGrids()
+	{
+		grids = new ConcurrentHashMap<String, Grid>();
+	}
+	
+	public static synchronized Grid findOrCreate(String name, int gridSize, int cellSize) {
+		if (grids.containsKey(name)) {
+			return grids.get(name);
+		} else {
+			Grid grid = new Grid(gridSize,cellSize);
+			grids.put(name, grid);
+			return grid;
+		}
+	}
+	
+	public static Grid find(String name) {
+		if (grids.containsKey(name)) {
+			return grids.get(name);
+		} else {
+			return null;
+		}
+	}
+	
+	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 void setMovementVerifier(MovementVerifier movementVerifier) {
+		this.movementVerifier = movementVerifier;
+	}
+	
+	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<TrackData> neighbors(float x, float y, String entityType) {
+		int myCell = hash(x, y);
+		return neighbors(myCell, x, y, entityType);
+	}
+
+	// This could be optimized more (and gridValuesInCell), but it's simply dwarfed by
+	// the overhead of serialization that at this point it's not really worth it.
+	// - entityType should be an integer
+	// - where we call gridValuesInCell, filter out by entity type there.
+	// - and then just concat the return values of gridValuesInCell instead of building
+	//   result one item at a time
+	public ArrayList<TrackData> neighbors(int myCell, float x, float y, String entityType) {
+		ArrayList<TrackData> result;
+
+		TrackData[] gridValues;
+		result = new ArrayList<TrackData>();
+		Set<Integer> cells = cellsWithinRadius(myCell, x, y);
+		for (int cell : cells) {
+			gridValues = gridValuesInCell(cell);
+			if (gridValues != null) {
+				for (TrackData gridValue : gridValues) {
+					if (gridValue != null) {
+						if (entityType == null) {
+							result.add(gridValue);
+						} else if (gridValue.entityType.equals(entityType)) {
+							result.add(gridValue);
+						}
+					}
+				}
+			}
+		}
+		return result;
+	}
+
+	public TrackData[] gridValuesInCell(int cell) {
+		ConcurrentHashMap<String, TrackData> cellGridValues = cells.get(cell);
+
+		if (cellGridValues != null) {
+			TrackData[] a = new TrackData[cellGridValues.size()];
+			cellGridValues.values().toArray(a);
+			return a;
+			// return cellGridValues.values();
+		} else {
+			return null;
+		}
+	}
+
+	public void updateFromDelta(TrackData[] gridValues) {
+		for (TrackData gridValue : gridValues) {
+			if (gridValue != null) {
+				objectIndex.put(gridValue.id, gridValue);
+			}
+		}
+	}
+
+	public TrackData[] currentDelta() {
+		TrackData[] a = new TrackData[deltaIndex.size()];
+		deltaIndex.values().toArray(a);
+		deltaIndex.clear();
+		return a;
+	}
+
+	public ArrayList<TrackData> getNeighborsFor(String id, String entityType) {
+		TrackData gridValue = get(id);
+		if (gridValue == null)
+		{
+			return null;
+		}
+		return neighbors(gridValue.x, gridValue.y, entityType);
+	}
+	
+	public TrackData get(String id) {
+		return objectIndex.get(id);
+	}
+
+	public void remove(String id) {
+		TrackData indexValue = objectIndex.get(id);
+		if (indexValue != null) {
+			int cell = cellsIndex.get(id);
+			ConcurrentHashMap<String, TrackData> cellGridValues = cells.get(cell);
+			if (cellGridValues != null) {
+				cellGridValues.remove(id);
+			}
+			objectIndex.remove(id);
+			cellsIndex.remove(id);
+		}
+	}
+
+	public Boolean set(String id, float x, float y, float z, String entityType) {
+		TrackData trackData = new TrackData();
+		trackData.id = id;
+		trackData.x = x;
+		trackData.y = y;
+		trackData.z = z;
+		trackData.entityType = entityType;
+		return set(trackData);
+	}
+	
+	public Boolean set(TrackData trackData) {
+		
+		if (trackData.entityType.equals("player")) {
+			if (movementVerifier != null) {
+				if (!movementVerifier.verify(trackData)) {
+					return false;
+				}
+			}
+		}
+		
+		
+		Boolean hasExisting = false;
+		Integer oldCellValue = -1;
+		String id = trackData.id;
+		
+		if (objectIndex.containsKey(id)) {
+			hasExisting = true;
+			oldCellValue = cellsIndex.get(id);
+		}
+		
+		int cell = hash(trackData.x, trackData.y);
+
+		if (hasExisting) {
+			if (oldCellValue != cell) {
+				ConcurrentHashMap<String, TrackData> cellGridValues = cells.get(oldCellValue);
+				cellGridValues.remove(id);
+				if (cellGridValues.size() == 0) {
+					cells.remove(oldCellValue);
+				}
+					
+			}
+			objectIndex.replace(id, trackData);
+			cellsIndex.replace(id, cell);
+		} else {
+			cellsIndex.put(id, cell);
+			objectIndex.put(id, trackData);
+		}
+		
+		if (!cells.containsKey(cell)) {
+			cells.put(cell, new ConcurrentHashMap<String, TrackData>());
+		}
+		cells.get(cell).put(id, trackData);
+
+		//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/project/src/main/java/com/game_machine/core/Hashring.java

@@ -0,0 +1,66 @@
+package com.game_machine.core;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.ConcurrentHashMap;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import akka.routing.ConsistentHash;
+
+public class Hashring {
+
+	private static final Logger log = LoggerFactory.getLogger(Hashring.class);
+	public static ConcurrentHashMap<String, Hashring> hashrings = new ConcurrentHashMap<String, Hashring>();
+	
+	private ConsistentHash<String> hash;
+	public String name;
+	public List<String> nodes = new ArrayList<String>();
+	
+	public static void dump() {
+		for (String key : hashrings.keySet()) {
+			Hashring ring = hashrings.get(key);
+			log.warn("Ring: "+key);
+			for (String node : ring.nodes) {
+				log.warn("Node: "+node);
+			}
+		}
+	}
+	
+	public static void addHashring(String name, Hashring ring) {
+		hashrings.put(name, ring);
+	}
+	
+	public static void removeHashring(String name) {
+		hashrings.remove(name);
+	}
+	
+	public static Hashring getHashring(String name) {
+		return hashrings.get(name);
+	}
+	
+	public Hashring(String name, List<String> nodes, int vnodes) {
+		for (String node : nodes) {
+			this.nodes.add(node);
+		}
+		this.name = name;
+		hash = ConsistentHash.create(nodes, vnodes);
+		addHashring(name,this);
+	}
+	
+	public void addNode(String node) {
+		hash = hash.add(node);
+		nodes.add(node);
+	}
+	
+	public void removeNode(String node) {
+		hash = hash.remove(node);
+		nodes.remove(node);
+	}
+	
+	public String nodeFor(String key) {
+		return hash.nodeFor(key);
+	}
+	
+}

data/java/project/src/main/java/com/game_machine/core/LocalLinkedBuffer.java

@@ -0,0 +1,20 @@
+package com.game_machine.core;
+
+import static com.dyuproject.protostuff.LinkedBuffer.allocate;
+import com.dyuproject.protostuff.LinkedBuffer;
+
+public class LocalLinkedBuffer {
+
+	static int bufferSize = 2048;
+
+	private static final ThreadLocal<LinkedBuffer> localBuffer = new ThreadLocal<LinkedBuffer>() {
+		@Override
+		protected LinkedBuffer initialValue() {
+			return allocate(bufferSize);
+		}
+	};
+	
+	public static LinkedBuffer get() {
+        return localBuffer.get();
+    }
+}

data/java/project/src/main/java/com/game_machine/core/MessageGateway.java

@@ -0,0 +1,120 @@
+package com.game_machine.core;
+
+import java.util.List;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import GameMachine.Messages.ClientManagerEvent;
+import GameMachine.Messages.ClientMessage;
+import GameMachine.Messages.Entity;
+import GameMachine.Messages.Player;
+import akka.actor.ActorSelection;
+import akka.actor.UntypedActor;
+import akka.event.Logging;
+import akka.event.LoggingAdapter;
+
+public class MessageGateway extends UntypedActor {
+
+	public static AtomicInteger messageCount;
+	public static ConcurrentHashMap<String, NetMessage> netMessages = new ConcurrentHashMap<String, NetMessage>();
+	public static String name = "message_gateway";
+
+	LoggingAdapter log = Logging.getLogger(getContext().system(), this);
+	private ActorSelection udpIncoming;
+	private ActorSelection entityTracking;
+	private UdpServer udpServer;
+	private Boolean fastpathOnly;
+
+	public MessageGateway() {
+		udpServer = UdpServer.getUdpServer();
+		udpIncoming = ActorUtil
+				.getSelectionByName("GameMachine::Endpoints::UdpIncoming");
+		entityTracking = ActorUtil
+				.getSelectionByName("fastpath_entity_tracking");
+		Commands.clientManagerRegister(name);
+		messageCount = new AtomicInteger();
+	}
+
+	@Override
+	public void onReceive(Object message) throws Exception {
+
+		// Incoming message
+		if (message instanceof NetMessage) {
+			messageCount.incrementAndGet();
+			NetMessage netMessage = (NetMessage) message;
+			ClientMessage clientMessage;
+
+			if (netMessage.protocol == NetMessage.UDP) {
+				clientMessage = ClientMessage.parseFrom(netMessage.bytes);
+			} else if (netMessage.protocol == NetMessage.TCP) {
+				clientMessage = netMessage.clientMessage;
+			} else {
+				clientMessage = null;
+			}
+
+			if (!netMessages.containsKey(clientMessage.player.id)) {
+				netMessages.put(clientMessage.player.id, netMessage);
+			}
+			
+			
+			List<Entity> entities = clientMessage.getEntityList();
+			
+			if (entities == null) {
+				udpIncoming.tell(message, null);
+			} else {
+				fastpathOnly = true;
+				for (Entity entity : clientMessage.getEntityList()) {
+					if (entity.hasFastpath()) {
+						routeFastpath(clientMessage.player, entity);
+					} else {
+						fastpathOnly = false;
+					}
+				}
+
+				if (!fastpathOnly) {
+					udpIncoming.tell(message, null);
+				}
+			}
+			
+			
+
+			// outgoing message
+		} else if (message instanceof Entity) {
+			Entity entity = (Entity) message;
+			NetMessage netMessage = netMessages.get(entity.player.id);
+			ClientMessage clientMessage = new ClientMessage();
+			clientMessage.addEntity(entity);
+
+			if (netMessage.protocol == NetMessage.UDP) {
+				// ByteBuf bb = clientMessage.toByteBuf();
+				// udpServer.sendToClient(bb, netMessage.host, netMessage.port,
+				// netMessage.ctx);
+
+				byte[] bytes = clientMessage.toByteArray();
+				udpServer.sendToClient(netMessage.address, bytes,
+						netMessage.ctx);
+			} else if (netMessage.protocol == NetMessage.TCP) {
+				netMessage.ctx.write(clientMessage);
+				UdpServerHandler.countOut.getAndIncrement();
+			}
+
+		} else if (message instanceof ClientManagerEvent) {
+			// log.warning("Message gateway got client manager event");
+			ClientManagerEvent event = (ClientManagerEvent) message;
+			if (event.event.equals("disconnected")) {
+				netMessages.remove(event.player_id);
+			}
+		}
+
+	}
+	
+	private void routeFastpath(Player player, Entity entity) {
+		entity.setPlayer(player);
+		if (entity.hasTrackData()) {
+			entityTracking.tell(entity, getSelf());
+		} else {
+			log.warning("Unable to find destination for entity id " + entity.id);
+		}
+	}
+
+}