game_machine 0.0.8

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

@@ -0,0 +1,25 @@
+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

@@ -0,0 +1,195 @@
+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/java/com/game_machine/core/GridValue.java

@@ -0,0 +1,30 @@
+package com.game_machine.core;
+
+import java.io.Serializable;
+
+
+public class GridValue implements Serializable {
+
+	/**
+	 * 
+	 */
+	private static final long serialVersionUID = -2653791674585495109L;
+	public final String id;
+	public final int cell;
+	public final float x;
+	public final float y;
+	public final float z;
+	
+	public final String entityType;
+	public long createdAt;
+
+	public GridValue(String id, int cell, float x, float y, float z, String entityType) {
+		this.id = id;
+		this.cell = cell;
+		this.x = x;
+		this.y = y;
+		this.z = z;
+		this.entityType = entityType;
+		//this.createdAt = System.nanoTime();
+	}
+}

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

@@ -0,0 +1,7 @@
+package com.game_machine.core;
+
+import akka.actor.UntypedActor;
+
+public interface IActorFactory {
+	UntypedActor create();
+}

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

@@ -0,0 +1,28 @@
+package com.game_machine.core;
+
+import io.netty.channel.ChannelHandlerContext;
+
+public class NetMessage {
+
+	// Protocols
+	public static final int UDP = 0;
+	public static final int UDT = 1;
+	public static final int TCP = 2;
+
+	public final byte[] bytes;
+	public final String host;
+	public final int port;
+	public final int protocol;
+	public final String clientId;
+	public final ChannelHandlerContext ctx;
+
+	public NetMessage(String clientId, int protocol, byte[] bytes, String host, int port, ChannelHandlerContext ctx) {
+		this.clientId = clientId;
+		this.bytes = bytes;
+		this.host = host;
+		this.port = port;
+		this.protocol = protocol;
+		this.ctx = ctx;
+	}
+
+}

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

@@ -0,0 +1,97 @@
+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;
+
+public final class UdpServer implements Runnable {
+
+	private static final Logger log = LoggerFactory.getLogger(UdpServer.class);
+	private static Thread serverThread;
+
+	private static UdpServer udpServer;
+
+	private final String hostname;
+	private final int port;
+
+	private final UdpServerHandler handler;
+
+
+	public static UdpServer getUdpServer() {
+		return udpServer;
+	}
+
+	public static void start(String host, Integer port) {
+
+		// Don't try to start an already running server
+		if (udpServer != null) {
+			return;
+		}
+
+		udpServer = new UdpServer(host, port);
+		serverThread = new Thread(udpServer);
+		serverThread.start();
+	}
+
+	public static void stop() {
+		log.info("Stopping UDP server");
+		// Don't try to stop a server that's not running
+		if (udpServer == null) {
+			return;
+		}
+
+	}
+
+	public UdpServerHandler getHandler() {
+		return this.handler;
+	}
+
+	public UdpServer(final String hostname, final int port) {
+		this.port = port;
+		this.hostname = hostname;
+		this.handler = new UdpServerHandler();
+	}
+
+	public void run() {
+		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();
+		
+		} catch (InterruptedException e) {
+			// TODO Auto-generated catch block
+			e.printStackTrace();
+		} finally {
+			 group.shutdownGracefully();
+		}
+	}
+
+	public void sendToClient(byte[] bytes, String host, int port, ChannelHandlerContext ctx) {
+		handler.send(bytes, host, port, ctx);
+	}
+
+	
+
+}

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

@@ -0,0 +1,90 @@
+package com.game_machine.core;
+
+import io.netty.buffer.ByteBuf;
+import io.netty.buffer.Unpooled;
+import io.netty.channel.ChannelFuture;
+import io.netty.channel.ChannelFutureListener;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.channel.SimpleChannelInboundHandler;
+import io.netty.channel.socket.DatagramPacket;
+
+import java.net.InetSocketAddress;
+import java.util.HashMap;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import akka.actor.ActorSelection;
+
+import com.game_machine.core.ActorUtil;
+import com.game_machine.core.NetMessage;
+
+//@Sharable
+public final class UdpServerHandler extends
+		SimpleChannelInboundHandler<DatagramPacket> {
+
+	private static final Logger log = LoggerFactory
+			.getLogger(UdpServerHandler.class);
+	public ChannelHandlerContext ctx = null;
+	private ActorSelection inbound;
+
+	private HashMap<String,String> clients = new HashMap<String,String>();
+	
+	public UdpServerHandler() {
+		this.inbound = ActorUtil
+				.getSelectionByName("GameMachine::Endpoints::UdpIncoming");
+	}
+
+	@Override
+	public void exceptionCaught(final ChannelHandlerContext ctx,
+			final Throwable cause) {
+		log.info("close the connection when an exception is raised", cause);
+		ctx.close();
+	}
+
+	@Override
+	public void channelReadComplete(ChannelHandlerContext ctx) {
+		ctx.flush();
+	}
+
+	@Override
+	public void channelActive(final ChannelHandlerContext ctx) {
+		log.info("UDP server active");
+		this.ctx = ctx;
+	}
+
+	public void send(byte[] bytes, String host, int port,
+			ChannelHandlerContext ctx) {
+			//log.info("send " + "host: " + host + " port: " + port + " bytes: "
+			//		+ bytes.toString()+" ctx: "+ctx);
+
+			ByteBuf buf = Unpooled.copiedBuffer(bytes);
+			DatagramPacket packet = new DatagramPacket(buf,
+					new InetSocketAddress(host, port));
+			ctx.writeAndFlush(packet);
+	}
+
+	public void echo(ChannelHandlerContext ctx, DatagramPacket m, byte[] bytes)
+	{
+		ByteBuf buf = Unpooled.copiedBuffer(bytes);
+		DatagramPacket packet = new DatagramPacket(buf,
+				new InetSocketAddress(m.sender().getHostString(), m.sender().getPort()));
+		ctx.writeAndFlush(packet);
+	}
+	
+	@Override
+	protected void channelRead0(ChannelHandlerContext ctx, DatagramPacket m)
+			throws Exception {
+		byte[] bytes = new byte[m.content().readableBytes()];
+		m.content().readBytes(bytes);
+
+		
+		NetMessage gameMessage = new NetMessage(null, NetMessage.UDP, bytes, m
+				.sender().getHostString(), m.sender().getPort(), ctx);
+		log.debug("MessageReceived length" + bytes.length + " "
+				+ new String(bytes));
+		this.inbound.tell(gameMessage, null);
+
+	}
+
+}