game_machine 0.0.11 → 1.0.2

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

@@ -0,0 +1,20 @@
+package com.game_machine.core;
+import GameMachine.Messages.ClientManagerRegister;
+import GameMachine.Messages.Entity;
+import GameMachine.Messages.Player;
+import akka.actor.ActorSelection;
+
+public class Commands {
+
+	public static void clientManagerRegister(String name) {
+		ClientManagerRegister register = new ClientManagerRegister();
+		register.setRegisterType("actor").setName(name);
+		register.setEvents("");
+		Entity entity = new Entity();
+		entity.setClientManagerRegister(register);
+		ActorSelection sel = ActorUtil.getSelectionByName("GameMachine::ClientManager");
+		sel.tell(entity, null);
+	}
+	
+	
+}

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

@@ -0,0 +1,43 @@
+package com.game_machine.core;
+
+import java.util.concurrent.TimeUnit;
+
+import scala.concurrent.Await;
+import scala.concurrent.Future;
+import scala.concurrent.duration.Duration;
+import GameMachine.Messages.Entity;
+import GameMachine.Messages.ObjectdbDel;
+import GameMachine.Messages.ObjectdbGet;
+import GameMachine.Messages.ObjectdbPut;
+import akka.actor.ActorSelection;
+import akka.pattern.AskableActorSelection;
+import akka.util.Timeout;
+
+public class DatastoreCommands {
+	
+	public static void put(Entity entity) {
+		ActorSelection sel = ActorUtil.findDistributed("GameMachine::ObjectDb", entity.id);
+		ObjectdbPut put = new ObjectdbPut().setEntity(entity);
+		sel.tell(put, null);
+	}
+	
+	public static void delete(String id) {
+		ActorSelection sel = ActorUtil.findDistributed("GameMachine::ObjectDb", id);
+		ObjectdbDel del = new ObjectdbDel().setEntityId(id);
+		sel.tell(del, null);
+	}
+	
+	public static Entity get(String id, int timeout) {
+		ObjectdbGet get = new ObjectdbGet().setEntityId(id);
+		ActorSelection sel = ActorUtil.findDistributed("GameMachine::ObjectDb", id);
+		Timeout t = new Timeout(Duration.create(timeout, TimeUnit.MILLISECONDS));
+		AskableActorSelection askable = new AskableActorSelection(sel);
+		Future<Object> future = askable.ask(get,t);
+		try {
+			Entity result = (Entity) Await.result(future, t.duration());
+			return result;
+		} catch (Exception e) {
+			return null;
+		}
+	}
+}

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

@@ -0,0 +1,72 @@
+package com.game_machine.core;
+
+import java.sql.Connection;
+import java.sql.SQLException;
+import java.util.concurrent.ConcurrentHashMap;
+
+import com.mysql.jdbc.Driver;
+import com.zaxxer.hikari.HikariConfig;
+import com.zaxxer.hikari.HikariDataSource;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+
+public class DbConnectionPool {
+	private static final Logger logger = LoggerFactory.getLogger(DbConnectionPool.class);
+
+	public ConcurrentHashMap<String, HikariDataSource> datasources = new ConcurrentHashMap<String, HikariDataSource>();
+
+	private DbConnectionPool() {
+	}
+
+	private static class LazyHolder {
+		private static final DbConnectionPool INSTANCE = new DbConnectionPool();
+	}
+
+	public static DbConnectionPool getInstance() {
+		return LazyHolder.INSTANCE;
+	}
+
+	public Boolean connect(String id, String hostname, int port, String dbname, String ds, String username, String password) throws SQLException {
+		if (datasources.containsKey(id)) {
+			return true;
+		}
+		
+		HikariConfig config = new HikariConfig();
+		config.setDataSourceClassName(ds);
+		config.addDataSourceProperty("serverName", hostname);
+		config.addDataSourceProperty("portNumber", port);
+		config.addDataSourceProperty("databaseName", dbname);
+		config.addDataSourceProperty("user", username);
+		config.addDataSourceProperty("password", password);
+		config.setMaximumPoolSize(10);
+		config.setIdleTimeout(0);
+		config.setLeakDetectionThreshold(10000);
+		//config.setAutoCommit(false);
+		
+
+		HikariDataSource datasource = new HikariDataSource(config);
+		
+		datasources.put(id, datasource);
+		return true;
+
+	}
+
+	public HikariDataSource getDataSource(String id) {
+		if (datasources.containsKey(id)) {
+			return datasources.get(id);
+		} else {
+			return null;
+		}
+	}
+
+	public Connection getConnection(String id) throws SQLException {
+		if (datasources.containsKey(id)) {
+			return datasources.get(id).getConnection();
+		} else {
+			return null;
+		}
+	}
+
+}

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

@@ -0,0 +1,56 @@
+package com.game_machine.core;
+
+import java.util.concurrent.ConcurrentHashMap;
+
+import GameMachine.Messages.TrackData;
+
+public class DefaultMovementVerifier implements MovementVerifier {
+
+	private ConcurrentHashMap<String, TrackData> trackdatas = new ConcurrentHashMap<String, TrackData>();
+	private ConcurrentHashMap<String, Long> lastUpdates = new ConcurrentHashMap<String, Long>();
+	private double maxUnitsPerSecond;
+	
+	private double distance(float px, float py, float x, float y) {
+		return Math.sqrt(Math.pow(x - px, 2) + Math.pow(y - py, 2));
+	}
+	
+	public DefaultMovementVerifier(double maxUnitsPerSecond) {
+		this.maxUnitsPerSecond = maxUnitsPerSecond;
+	}
+	
+	@Override
+	public boolean verify(TrackData trackData) {
+		if (!trackdatas.containsKey(trackData.id)) {
+			trackdatas.put(trackData.id, trackData);
+			lastUpdates.put(trackData.id, System.currentTimeMillis());
+			return true;
+		}
+		
+		// verify once per second, every update is a waste of cpu
+		Long lastUpdate = lastUpdates.get(trackData.id);
+		double seconds = (System.currentTimeMillis() - lastUpdate) / 1000;
+		if (seconds >= 1.0) {
+			TrackData previous = trackdatas.get(trackData.id);
+			
+			// check distance traveled over time (basic speed hack prevention)
+			double distance = distance(previous.x,previous.y,trackData.x,trackData.y);
+			double unitsPerSecond = distance / seconds;
+			if (unitsPerSecond > maxUnitsPerSecond) {
+				return false;
+			}
+			
+			// TODO check valid movement.
+			// using pathfinding, pre calculate every possible move and save it somewhere.
+			// At startup load the data and use it to check for valid movement.  Can also modify it
+			// at runtime if needed.
+			
+			// In addition, check for other objects that occupy the coordinates the player is trying to move to, and
+			// deny if they are occupied.  Need to look at most cost effective way to do this.
+			
+			trackdatas.put(trackData.id, trackData);
+			lastUpdates.put(trackData.id, System.currentTimeMillis());
+		}
+		return true;
+	}
+
+}

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

@@ -0,0 +1,119 @@
+package com.game_machine.core;
+
+import java.util.ArrayList;
+
+import GameMachine.Messages.ClientManagerEvent;
+import GameMachine.Messages.Entity;
+import GameMachine.Messages.Neighbors;
+import GameMachine.Messages.Player;
+import GameMachine.Messages.TrackData;
+import akka.actor.ActorSelection;
+import akka.actor.UntypedActor;
+import akka.event.Logging;
+import akka.event.LoggingAdapter;
+
+public class EntityTracking extends UntypedActor {
+
+	LoggingAdapter log = Logging.getLogger(getContext().system(), this);
+	public static String name = "fastpath_entity_tracking";
+
+	private Grid aoeGrid;
+	private Grid grid;
+	private ActorSelection messageGateway;
+
+	public EntityTracking() {
+		messageGateway = ActorUtil.getSelectionByName(MessageGateway.name);
+		grid = Grid.find("default");
+		aoeGrid = Grid.find("aoe");
+		Commands.clientManagerRegister(name);
+	}
+
+	@Override
+	public void onReceive(Object message) throws Exception {
+
+		if (message instanceof Entity) {
+			Entity entity = (Entity) message;
+
+			SendNeighbors(entity);
+			setEntityLocation(entity.trackData);
+
+		} else if (message instanceof ClientManagerEvent) {
+			ClientManagerEvent event = (ClientManagerEvent) message;
+			if (event.event.equals("disconnected")) {
+				removePlayerData(event);
+			}
+		} else {
+			unhandled(message);
+		}
+
+	}
+
+	private void removePlayerData(ClientManagerEvent event) {
+		grid.remove(event.player_id);
+		aoeGrid.remove(event.player_id);
+	}
+
+	private void SendNeighbors(Entity entity) {
+		Float x = entity.trackData.x;
+		Float y = entity.trackData.y;
+		if (x == null) {
+			x = 0f;
+		}
+		if (y == null) {
+			y = 0f;
+		}
+
+		ArrayList<TrackData> trackDatas = grid.neighbors(x, y,
+				entity.trackData.neighborEntityType);
+
+		if (trackDatas.size() >= 1) {
+			toNeighbors(entity.player, trackDatas);
+		}
+	}
+
+	private void SendToGateway(Player player, Neighbors neighbors) {
+		Entity playerMessage = new Entity();
+		playerMessage.setNeighbors(neighbors);
+		playerMessage.setPlayer(player);
+		playerMessage.setId(player.id);
+		messageGateway.tell(playerMessage, getSelf());
+	}
+
+	private void toNeighbors(Player player, ArrayList<TrackData> trackDatas) {
+		int count = 0;
+		Neighbors neighbors = new Neighbors();
+
+		for (TrackData trackData : trackDatas) {
+			neighbors.addTrackData(trackData);
+
+			count++;
+			if (count >= 30) {
+				SendToGateway(player, neighbors);
+				count = 0;
+				neighbors = new Neighbors();
+			}
+		}
+		SendToGateway(player, neighbors);
+	}
+
+	private void setEntityLocation(TrackData trackData) {
+		
+		// So either protostuff or protobuf-net has a bug where 0 floats come
+		// through as null
+		// This is *really* annoying must track down
+		if (trackData.x == null) {
+			trackData.x = 0f;
+		}
+		if (trackData.y == null) {
+			trackData.y = 0f;
+		}
+		if (trackData.z == null) {
+			trackData.z = 0f;
+		}
+
+		// TODO.  If set returns false send message to the client letting them know their movement was not allowed
+		grid.set(trackData);
+		aoeGrid.set(trackData);
+	}
+
+}

data/java/{src → project/src}/main/java/com/game_machine/core/EventStreamHandler.java

@@ -32,7 +32,7 @@ public class EventStreamHandler extends UntypedActor {
 	public void onReceive(Object message) throws Exception {
 		if (message instanceof DeadLetter) {
 			DeadLetter letter = (DeadLetter) message;
-			log.info("DeadLetter " + letter.message());
+			//log.warning("DeadLetter " + letter.message() + " " + letter.sender().toString() + " " + letter.recipient().toString());
 			// Scala creates bad class names that blow up in jruby and show up in dead letters.
 			//ActorSelection sel = ActorUtil
 			//		.getSelectionByName("GameMachine::SystemMonitor");

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

@@ -0,0 +1,73 @@
+package com.game_machine.core;
+
+import java.util.concurrent.ConcurrentHashMap;
+
+import GameMachine.Messages.Entity;
+import GameMachine.Messages.GameMessage;
+import GameMachine.Messages.GameMessages;
+import akka.actor.UntypedActor;
+
+public class GameActor extends UntypedActor {
+
+	private static ConcurrentHashMap<String, GameMessage> reliableMessages = new ConcurrentHashMap<String, GameMessage>();
+	private static ConcurrentHashMap<String, Integer> reliableMessageStatus = new ConcurrentHashMap<String, Integer>();
+
+	public String playerId;
+	public String messageId;
+	
+	public void setPlayerId(String playerId) {
+		this.playerId = playerId;
+	}
+
+	@Override
+	public void onReceive(Object message) throws Exception {
+
+	}
+
+	public static void removeReliableMessage(String id) {
+		if (reliableMessages.containsKey(id)) {
+			reliableMessages.remove(id);
+		}
+		
+		if (reliableMessageStatus.containsKey(id)) {
+			reliableMessageStatus.remove(id);
+		}
+	}
+
+	public boolean setReply(GameMessage gameMessage) {
+		gameMessage.messageId = this.messageId;
+		if (reliableMessageStatus.containsKey(gameMessage.messageId)) {
+			reliableMessages.put(gameMessage.messageId, gameMessage);
+			reliableMessageStatus.replace(gameMessage.messageId,1);
+			sendReply(gameMessage.messageId);
+			return true;
+		} else {
+			return false;
+		}
+	}
+
+	private void sendReply(String messageId) {
+		GameMessage gameMessage = reliableMessages.get(messageId);
+		Entity entity = new Entity();
+		entity.setId(messageId);
+		entity.setGameMessages(new GameMessages());
+		entity.gameMessages.addGameMessage(gameMessage);
+		PlayerCommands.sendToPlayer(entity, playerId);
+	}
+
+	public boolean exactlyOnce(GameMessage gameMessage) {
+		if (gameMessage.hasMessageId()) {
+			if (reliableMessageStatus.containsKey(gameMessage.messageId)) {
+				int status = reliableMessageStatus.get(gameMessage.messageId);
+				if (status == 1) {
+					sendReply(gameMessage.messageId);
+				}
+			} else {
+				reliableMessageStatus.put(gameMessage.messageId, 0);
+				this.messageId = gameMessage.messageId;
+				return true;
+			}
+		}
+		return false;
+	}
+}

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

@@ -0,0 +1,43 @@
+package com.game_machine.core;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import akka.actor.ActorSystem;
+import akka.actor.Props;
+import akka.routing.RoundRobinPool;
+
+public class GameMachineLoader {
+
+	
+
+	@SuppressWarnings("unused")
+	private static final Logger log = LoggerFactory.getLogger(GameMachineLoader.class);
+	public static final Logger logger = LoggerFactory.getLogger("game_machine");
+	private static ActorSystem actorSystem;
+
+	
+	public static ActorSystem getActorSystem() {
+		return actorSystem;
+	}
+	
+	public static void StartMessageGateway() {
+		actorSystem.actorOf(new RoundRobinPool(10).props(Props.create(MessageGateway.class)), 
+			    MessageGateway.name);
+	}
+	
+	public static void StartEntityTracking() {
+		actorSystem.actorOf(new RoundRobinPool(10).props(Props.create(EntityTracking.class)), 
+			    EntityTracking.name);
+	}
+	
+	public void run(ActorSystem newActorSystem) {
+		Thread.currentThread().setName("game-machine");
+		actorSystem = newActorSystem;
+		actorSystem.actorOf(Props.create(EventStreamHandler.class), EventStreamHandler.class.getSimpleName());
+		
+		actorSystem.actorOf(new RoundRobinPool(10).props(Props.create(MessagePersister.class)), 
+			    MessagePersister.name);
+	}
+
+}