game_machine 0.0.11 → 1.0.2

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

@@ -0,0 +1,26 @@
+package com.game_machine.core;
+
+import akka.actor.UntypedActor;
+import akka.event.Logging;
+import akka.event.LoggingAdapter;
+
+
+public class MessagePersister extends UntypedActor {
+
+	public static String name = "message_persister";
+	LoggingAdapter log = Logging.getLogger(getContext().system(), this);
+	
+	@Override
+	public void onReceive(Object message) throws Exception {
+		
+		if (message instanceof PersistentMessage) {
+			PersistentMessage persistentMessage = (PersistentMessage)message;
+			String action = persistentMessage.getPersistAction();
+			if (action.equals("save")) {
+				persistentMessage.dbSave(persistentMessage.getPersistPlayerId());
+			} else if (action.equals("delete")) {
+				persistentMessage.dbDelete(persistentMessage.getPersistPlayerId());
+			}
+		}
+	}
+}

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

@@ -0,0 +1,39 @@
+package com.game_machine.core;
+
+import GameMachine.Messages.Entity;
+import GameMachine.Messages.MonoMessage;
+
+public class MonoProxy {
+	 
+    private static class LazyHolder {
+        private static final MonoProxy INSTANCE = new MonoProxy();
+    }
+ 
+    public static MonoProxy getInstance() {
+        return LazyHolder.INSTANCE;
+    }
+	
+    private MonoProxy() {
+		udpClient = new UdpClient(24320,1);
+		if (!udpClient.connect()) {
+			throw new RuntimeException("Unable to connect to mono");
+		}
+	}
+    
+	private UdpClient udpClient;
+	
+	
+	public Entity call(String klass, Entity entity) {
+		MonoMessage message = new MonoMessage();
+		message.setKlass(klass);
+		message.setEntity(entity);
+		byte[] bytes = udpClient.send(message.toByteArray());
+		if (bytes == null) {
+			return null;
+		} else {
+			message = MonoMessage.parseFrom(bytes);
+			return message.entity;
+		}
+	}
+		
+}

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

@@ -0,0 +1,7 @@
+package com.game_machine.core;
+
+import GameMachine.Messages.TrackData;
+
+public interface MovementVerifier {
+	boolean verify(TrackData trackData);
+}

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

@@ -1,5 +1,9 @@
 package com.game_machine.core;
 
+import java.net.InetSocketAddress;
+
+import GameMachine.Messages.ClientMessage;
+import io.netty.buffer.ByteBuf;
 import io.netty.channel.ChannelHandlerContext;
 
 public class NetMessage {
@@ -9,20 +13,20 @@ public class NetMessage {
 	public static final int UDT = 1;
 	public static final int TCP = 2;
 
-	public final byte[] bytes;
+	public byte[] bytes;
+	public ByteBuf buf;
+	public ClientMessage clientMessage;
 	public final String host;
 	public final int port;
 	public final int protocol;
-	public final String clientId;
 	public final ChannelHandlerContext ctx;
+	public InetSocketAddress address;
 
-	public NetMessage(String clientId, int protocol, byte[] bytes, String host, int port, ChannelHandlerContext ctx) {
-		this.clientId = clientId;
-		this.bytes = bytes;
+	public NetMessage(int protocol, String host, int port, ChannelHandlerContext ctx) {
 		this.host = host;
 		this.port = port;
 		this.protocol = protocol;
 		this.ctx = ctx;
 	}
-
+	
 }

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

@@ -0,0 +1,9 @@
+package com.game_machine.core;
+
+public interface PersistentMessage {
+	void dbSaveAsync(String playerId);
+	Boolean dbSave(String playerId);
+	Boolean dbDelete(String playerId);
+	String getPersistPlayerId();
+	String getPersistAction();
+}

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

@@ -0,0 +1,31 @@
+package com.game_machine.core;
+
+import akka.actor.ActorSelection;
+import GameMachine.Messages.Entity;
+import GameMachine.Messages.GameMessage;
+import GameMachine.Messages.GameMessages;
+import GameMachine.Messages.Player;
+
+public class PlayerCommands {
+
+	public static void sendGameMessage(GameMessage gameMessage, String playerId) {
+		GameMessages gameMessages = new GameMessages();
+		gameMessages.addGameMessage(gameMessage);
+		Entity entity = new Entity();
+		entity.setId("0");
+		entity.setGameMessages(gameMessages);
+		PlayerCommands.sendToPlayer(entity, playerId);
+	}
+	
+	public static void sendToPlayer(Entity entity, String playerId) {
+		if (!entity.hasPlayer()) {
+			Player player = new Player();
+			player.setId(playerId);
+			entity.setPlayer(player);
+		}
+		entity.setSendToPlayer(true);
+		
+		ActorSelection sel = ActorUtil.getSelectionByName("GameMachine::ClientManager");
+		sel.tell(entity, null);
+	}
+}

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

@@ -0,0 +1,100 @@
+package com.game_machine.core;
+import java.net.InetSocketAddress;
+import java.security.cert.CertificateException;
+
+import javax.net.ssl.SSLException;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import io.netty.bootstrap.ServerBootstrap;
+import io.netty.channel.ChannelOption;
+import io.netty.channel.EventLoopGroup;
+import io.netty.channel.nio.NioEventLoopGroup;
+import io.netty.channel.socket.nio.NioServerSocketChannel;
+import io.netty.handler.logging.LogLevel;
+import io.netty.handler.logging.LoggingHandler;
+import io.netty.handler.ssl.SslContext;
+import io.netty.handler.ssl.util.SelfSignedCertificate;
+
+public class TcpServer implements Runnable {
+	static final boolean SSL = System.getProperty("nossl") != null;
+    static final int PORT = Integer.parseInt(System.getProperty("port", "8463"));
+
+    private static final Logger log = LoggerFactory.getLogger(UdpServer.class);
+	private static Thread serverThread;
+
+	private static TcpServer tcpServer;
+
+	private final String hostname;
+	private final int port;
+
+	public static TcpServer getTcpServer() {
+		return tcpServer;
+	}
+
+	public static void start(String host, Integer port) {
+
+		// Don't try to start an already running server
+		if (tcpServer != null) {
+			return;
+		}
+
+		tcpServer = new TcpServer(host, port);
+		serverThread = new Thread(tcpServer);
+		serverThread.start();
+	}
+
+	public static void stop() {
+		log.info("Stopping TCP server");
+		// Don't try to stop a server that's not running
+		if (tcpServer == null) {
+			return;
+		}
+
+	}
+
+	public TcpServer(final String hostname, final int port) {
+		this.port = port;
+		this.hostname = hostname;
+	}
+	
+	@Override
+    public void run() {
+        // Configure SSL.
+        final SslContext sslCtx;
+        if (SSL) {
+            SelfSignedCertificate ssc;
+			try {
+				ssc = new SelfSignedCertificate();
+				sslCtx = SslContext.newServerContext(ssc.certificate(), ssc.privateKey());
+			} catch (CertificateException | SSLException e) {
+				e.printStackTrace();
+				return;
+			}
+        } else {
+            sslCtx = null;
+        }
+
+        EventLoopGroup bossGroup = new NioEventLoopGroup(1);
+        EventLoopGroup workerGroup = new NioEventLoopGroup();
+        try {
+            ServerBootstrap b = new ServerBootstrap();
+            b.group(bossGroup, workerGroup)
+             .channel(NioServerSocketChannel.class)
+             .childOption(ChannelOption.TCP_NODELAY, true)
+             .childOption(ChannelOption.SO_REUSEADDR, true)
+             .handler(new LoggingHandler(LogLevel.INFO))
+             .childHandler(new TcpServerInitializer(sslCtx));
+
+            InetSocketAddress address = new InetSocketAddress(hostname,port);
+            b.bind(address).sync().channel().closeFuture().sync();
+        } catch (InterruptedException e) {
+			e.printStackTrace();
+		} finally {
+            bossGroup.shutdownGracefully();
+            workerGroup.shutdownGracefully();
+        }
+    }
+	
+}

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

@@ -0,0 +1,54 @@
+package com.game_machine.core;
+import java.net.InetSocketAddress;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import GameMachine.Messages.ClientMessage;
+import akka.actor.ActorSelection;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.channel.SimpleChannelInboundHandler;
+
+public class TcpServerHandler extends SimpleChannelInboundHandler<ClientMessage> {
+	
+	private ActorSelection inbound;
+	
+	private static final Logger log = LoggerFactory
+			.getLogger(TcpServerHandler.class);
+	
+	public TcpServerHandler() {
+		this.inbound = ActorUtil
+				.getSelectionByName("message_gateway");
+	}
+	
+	public static void sendClientMessage(ClientMessage clientMessage,ChannelHandlerContext ctx) {
+		ctx.write(clientMessage);
+		ctx.flush();
+	}
+	
+	@Override
+    public void channelRead0(ChannelHandlerContext ctx, ClientMessage clientMessage) throws Exception {
+		InetSocketAddress address = (InetSocketAddress)ctx.channel().remoteAddress();
+		
+		NetMessage netMessage = new NetMessage(NetMessage.TCP, address.getHostString(), address.getPort(), ctx);
+		netMessage.clientMessage = clientMessage;
+		this.inbound.tell(netMessage, null);
+    }
+
+	@Override
+	public void channelActive(final ChannelHandlerContext ctx) {
+		log.info("Tcp server active");
+	}
+	
+    @Override
+    public void channelReadComplete(ChannelHandlerContext ctx) {
+        ctx.flush();
+    }
+
+    @Override
+    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
+        //cause.printStackTrace();
+        ctx.close();
+    }
+
+}

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

@@ -0,0 +1,32 @@
+package com.game_machine.core;
+import io.netty.channel.ChannelInitializer;
+import io.netty.channel.ChannelPipeline;
+import io.netty.channel.socket.SocketChannel;
+import io.netty.handler.codec.protobuf.ProtobufEncoder;
+import io.netty.handler.codec.protobuf.ProtobufVarint32FrameDecoder;
+import io.netty.handler.codec.protobuf.ProtobufVarint32LengthFieldPrepender;
+import io.netty.handler.ssl.SslContext;
+
+public class TcpServerInitializer  extends ChannelInitializer<SocketChannel> {
+	private final SslContext sslCtx;
+	
+    public TcpServerInitializer(SslContext sslCtx) {
+        this.sslCtx = sslCtx;
+    }
+
+    @Override
+    public void initChannel(SocketChannel ch) throws Exception {
+        ChannelPipeline p = ch.pipeline();
+        if (sslCtx != null) {
+            p.addLast(sslCtx.newHandler(ch.alloc()));
+        }
+
+        p.addLast(new ProtobufVarint32FrameDecoder());
+        p.addLast(new ClientMessageDecoder());
+
+        //p.addLast(new ProtobufVarint32LengthFieldPrepender());
+        p.addLast(new ClientMessageEncoder());
+
+        p.addLast(new TcpServerHandler());
+    }
+}

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

@@ -0,0 +1,86 @@
+package com.game_machine.core;
+
+import java.io.IOException;
+import java.net.DatagramPacket;
+import java.net.DatagramSocket;
+import java.net.InetAddress;
+import java.net.SocketException;
+import java.net.SocketTimeoutException;
+import java.util.Arrays;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class UdpClient {
+
+	private static final Logger log = LoggerFactory.getLogger(UdpClient.class);
+	private int port;
+	private InetAddress hostAddress;
+	private DatagramSocket s;
+	private DatagramPacket dp;
+	private int timeout;
+
+	public UdpClient(int port, int timeout) {
+		this.port = port;
+		this.timeout = timeout;
+
+		hostAddress = InetAddress.getLoopbackAddress();
+		byte[] in = new byte[2048];
+		dp = new DatagramPacket(in, in.length);
+	}
+
+	public Boolean connect() {
+		
+		try {
+			s = new DatagramSocket();
+			s.setSoTimeout(timeout);
+			return true;
+		} catch (SocketException e) {
+			e.printStackTrace();
+			return false;
+		}
+	}
+	
+	public byte[] send(byte[] bytes) {
+		try {
+
+			int retryCount = 0;
+			int retryLimit = 3;
+
+			DatagramPacket out = new DatagramPacket(bytes, bytes.length,
+					hostAddress, port);
+
+			
+			while (true) {
+				s.send(out);
+
+				try {
+					s.receive(dp);
+					byte[] received = Arrays.copyOfRange(dp.getData(),
+							dp.getOffset(), dp.getOffset() + dp.getLength());
+					return received;
+				} catch (SocketTimeoutException e) {
+					try {
+						Thread.sleep(retryCount + 1, 0);
+					} catch (InterruptedException e1) {
+						e1.printStackTrace();
+					}
+					if (retryCount > retryLimit) {
+						log.warn("Timeout retry limit exceeded " + e + " "
+								+ retryCount);
+						return null;
+					}
+					retryCount++;
+				}
+			}
+
+		} catch (SocketException e1) {
+			log.warn("Socket closed " + e1);
+			return null;
+
+		} catch (IOException e) {
+			e.printStackTrace();
+			return null;
+		}
+	}
+}

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

@@ -1,23 +1,16 @@
 package com.game_machine.core;
 
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
 import io.netty.bootstrap.Bootstrap;
-import io.netty.channel.ChannelFuture;
 import io.netty.channel.ChannelHandlerContext;
-import io.netty.channel.ChannelInitializer;
 import io.netty.channel.ChannelOption;
-import io.netty.channel.ChannelPipeline;
 import io.netty.channel.EventLoopGroup;
-import io.netty.channel.group.ChannelGroup;
-import io.netty.channel.group.ChannelGroupFuture;
-import io.netty.channel.group.DefaultChannelGroup;
 import io.netty.channel.nio.NioEventLoopGroup;
 import io.netty.channel.socket.nio.NioDatagramChannel;
-import io.netty.util.concurrent.DefaultEventExecutorGroup;
 
-import com.game_machine.core.NetMessage;
+import java.net.InetSocketAddress;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 public final class UdpServer implements Runnable {
 
@@ -31,7 +24,6 @@ public final class UdpServer implements Runnable {
 
 	private final UdpServerHandler handler;
 
-
 	public static UdpServer getUdpServer() {
 		return udpServer;
 	}
@@ -68,30 +60,29 @@ public final class UdpServer implements Runnable {
 	}
 
 	public void run() {
-		log.info("Starting UdpServer port=" + this.port + " hostname=" + this.hostname);
+		log.info("Starting UdpServer port=" + this.port + " hostname="
+				+ this.hostname);
 		Thread.currentThread().setName("udp-server");
 		EventLoopGroup group = new NioEventLoopGroup();
 		try {
-		Bootstrap boot = new Bootstrap();
-		boot.channel(NioDatagramChannel.class);
-		boot.group(group);
-		boot.option(ChannelOption.SO_BROADCAST, false);
-		boot.handler(new UdpServerHandler());
-		
-		boot.bind(this.port).sync().channel().closeFuture().await();
-		
+			Bootstrap boot = new Bootstrap();
+			boot.channel(NioDatagramChannel.class);
+			boot.group(group);
+			boot.option(ChannelOption.SO_BROADCAST, false);
+			boot.handler(new UdpServerHandler());
+
+			InetSocketAddress address = new InetSocketAddress(hostname,port);
+			boot.bind(address).sync().channel().closeFuture().await();
+
 		} catch (InterruptedException e) {
-			// TODO Auto-generated catch block
 			e.printStackTrace();
 		} finally {
-			 group.shutdownGracefully();
+			group.shutdownGracefully();
 		}
 	}
 
-	public void sendToClient(byte[] bytes, String host, int port, ChannelHandlerContext ctx) {
-		handler.send(bytes, host, port, ctx);
+	public void sendToClient(InetSocketAddress address, byte[] bytes, ChannelHandlerContext ctx) {
+		handler.send(address, bytes, ctx);
 	}
 
-	
-
 }