game_machine 0.0.11 → 1.0.2

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

@@ -2,37 +2,35 @@ 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 java.util.concurrent.atomic.AtomicInteger;
 
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+import GameMachine.Messages.ClientMessage;
 import akka.actor.ActorSelection;
 
-import com.game_machine.core.ActorUtil;
-import com.game_machine.core.NetMessage;
-
 //@Sharable
 public final class UdpServerHandler extends
 		SimpleChannelInboundHandler<DatagramPacket> {
 
+	public static AtomicInteger countIn = new AtomicInteger();
+	public static AtomicInteger countOut = new AtomicInteger();
+
 	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");
+		this.inbound = ActorUtil.getSelectionByName("message_gateway");
 	}
 
 	@Override
@@ -53,37 +51,36 @@ public final class UdpServerHandler extends
 		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);
+		
+	public void send(InetSocketAddress address, byte[] bytes, ChannelHandlerContext ctx) {
 
-			ByteBuf buf = Unpooled.copiedBuffer(bytes);
-			DatagramPacket packet = new DatagramPacket(buf,
-					new InetSocketAddress(host, port));
-			ctx.writeAndFlush(packet);
+		ByteBuf buf = Unpooled.wrappedBuffer(bytes);
+		DatagramPacket packet = new DatagramPacket(buf, address);
+		ctx.writeAndFlush(packet);
+		countOut.incrementAndGet();
 	}
 
-	public void echo(ChannelHandlerContext ctx, DatagramPacket m, byte[] bytes)
-	{
+	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()));
+		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);
+		NetMessage netMessage = new NetMessage(NetMessage.UDP, m.sender()
+				.getHostString(), m.sender().getPort(), ctx);
+		netMessage.bytes = bytes;
+		netMessage.address = m.sender();
 		log.debug("MessageReceived length" + bytes.length + " "
 				+ new String(bytes));
-		this.inbound.tell(gameMessage, null);
+		this.inbound.tell(netMessage, null);
+		countIn.incrementAndGet();
 
 	}
 

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

@@ -0,0 +1,159 @@
+package com.game_machine.core;
+
+public class Vector3 {
+	private double x;
+	private double y;
+	private double z;
+	
+	public Vector3() {
+	}
+	
+	public Vector3(double x, double y, double z) {
+		this.x = x;
+		this.y = y;
+		this.z = z;
+	}
+	
+	public static Vector3 from(Vector3 other) {
+    Vector3 vec = new Vector3(other.x,other.y,other.z);
+    return vec;
+	}
+
+	public Vector3(Vector3 other) {
+		x = other.x;
+		y = other.y;
+		z = other.z;
+	}
+	
+	public double x() {
+		return x;
+	}
+	
+	public double y() {
+		return y;
+	}
+	
+	public double z() {
+		return z;
+	}
+	
+	public void set(double x, double y, double z) {
+		this.x = x;
+		this.y = y;
+		this.z = z;
+	}
+	
+	public void set(Vector3 other) {
+		x = other.x;
+		y = other.y;
+		z = other.z;
+	}
+	
+	public void addLocal(Vector3 other) {
+		x += other.x;
+		y += other.y;
+		z += other.z;
+	}
+	
+	public void addLocal(double x, double y, double z) {
+		this.x += x;
+		this.y += y;
+		this.z += z;
+	}
+	
+	public Vector3 subtract(Vector3 other) {
+		return new Vector3(x - other.x, y - other.y, z - other.z);
+	}
+	
+	public double angle(Vector3 other) {
+		// TODO: Find a faster arccos and sqrt method
+		
+		double lengthSquare = x * x + y * y + z * z;
+		double otherLengthSquare = other.x * other.x + other.y * other.y + other.z * other.z;
+		
+		double angle = Math.acos((x * other.x + y * other.y + z * other.z)/Math.sqrt(lengthSquare * otherLengthSquare));
+		
+		return angle;
+	}
+	
+	public Vector3 cross(Vector3 other) {
+		return new Vector3(y * other.z - z * other.y,
+				z * other.x - x * other.z, x * other.y - y * other.x);
+	}
+	
+	public double dot(Vector3 other) {
+		return (x * other.x + y * other.y + z * other.z);
+	}
+	
+	public void crossLocal(Vector3 other) {
+		set(y * other.z - z * other.y, z * other.x - x * other.z, x * other.y - y * other.x);
+	}
+	
+	public Vector3 multiply(double scalar) {
+		return new Vector3(x * scalar, y * scalar, z * scalar);
+	}
+	
+	public void multiplyLocal(double scalar) {
+		x = scalar * x;
+		y = scalar * y;
+		z = scalar * z;
+	}
+	
+	public Vector3 normalize() {
+		double length = Math.sqrt(x * x + y * y + z * z);
+		if (length > Double.MIN_NORMAL) {
+			return new Vector3(x / length, y / length, z / length);
+		} else {
+			return new Vector3(0, 0, 0);
+		}
+	}
+	
+	public void normalizeLocal() {
+		double length = Math.sqrt(x * x + y * y + z * z);
+		if (length > Double.MIN_NORMAL) {
+			x /= length;
+			y /= length;
+			z /= length;
+		} else {
+			x = y = z = 0;
+		}
+	}
+	
+	// Obtain distance between position vectors
+	public double distance(Vector3 other) {
+		return Math.sqrt(Math.pow(x - other.x, 2) + Math.pow(y - other.y, 2) + Math.pow(z - other.z, 2));
+	}
+	
+	// Project the vector onto the plane passing through the origin, perpendicular to the given normal
+	public Vector3 projectNormal(Vector3 normal) {
+		return subtract(normal.multiply(this.dot(normal)));
+	}
+	
+	public Vector3 rotate(Vector3 normal, double angle) {
+    	// Parametric equation for circle in 3D space:
+    	// P = Rcos(t)u + Rsin(t)nxu + c
+    	//
+    	// Where:
+    	//  -u is a unit vector from the centre of the circle to any point
+    	// on the circumference
+    	//  -R is the radius
+    	//  -n is a unit vector perpendicular to the plane
+        //  -c is the centre of the circle.
+    	
+		//TODO: obtain a more efficient sin function
+		
+    	Vector3 rotated;
+    	
+    	rotated = normal.normalize();
+    	rotated.crossLocal(this);
+    	rotated.multiplyLocal(Math.sin(angle));
+    	rotated.addLocal(this.multiply(Math.cos(angle)));
+    	
+    	return rotated;
+    }
+	
+	@Override
+	public String toString() {
+		return "(" + x + ", " + y + ", " + z + ")";
+	}
+}

data/java/project/src/main/java/com/game_machine/orm/models/PlayerItem.java

@@ -0,0 +1,118 @@
+package com.game_machine.orm.models;
+
+import org.javalite.activejdbc.DB;
+import org.javalite.activejdbc.Model;
+import org.javalite.activejdbc.annotations.IdName;
+
+import com.game_machine.core.DbConnectionPool;
+import com.zaxxer.hikari.HikariDataSource;
+
+/*
+Postgresql
+
+Database/user creation
+CREATE ROLE gamemachine WITH ENCRYPTED PASSWORD 'gamemachine' LOGIN CREATEDB CREATEROLE;
+CREATE DATABASE gamemachine WITH OWNER=gamemachine ENCODING='UTF8';
+
+Table
+CREATE TABLE player_items (
+  id bigserial NOT NULL,
+  
+  player_item_id character varying(128) NOT NULL,
+  
+  player_item_name character varying(128) NOT NULL,
+  
+  player_item_quantity integer NOT NULL,
+  
+  player_item_color character varying(128) DEFAULT NULL,
+
+  weapon_attack integer DEFAULT NULL,
+  	
+  weapon_delay integer DEFAULT NULL,
+
+  consumable_type character varying(128) DEFAULT NULL,
+  	
+  consumable_size character varying(128) DEFAULT NULL,
+
+  cost_amount double precision DEFAULT NULL,
+  	
+  cost_currency character varying(128) DEFAULT NULL,
+
+  player_id character varying(128) NOT NULL,
+  CONSTRAINT player_item_pkey PRIMARY KEY (id),
+  CONSTRAINT player_item_id_player_id_idx UNIQUE (player_item_id,player_id)
+);
+alter table player_items owner to gamemachine;
+
+Mysql
+
+Database/user creation
+CREATE DATABASE IF NOT EXISTS gamemachine CHARACTER SET utf8 COLLATE utf8_general_ci;
+GRANT ALL PRIVILEGES ON gamemachine.* TO 'gamemachine'@'%' IDENTIFIED BY 'gamemachine' WITH GRANT OPTION;
+FLUSH PRIVILEGES;
+
+Table
+CREATE TABLE `player_items` (
+  `id` int(11) NOT NULL AUTO_INCREMENT,
+  
+  `player_item_id` varchar(128) NOT NULL,
+  
+  `player_item_name` varchar(128) NOT NULL,
+  
+  `player_item_quantity` int(11) NOT NULL,
+  
+  `player_item_color` varchar(128) DEFAULT NULL,
+
+  `weapon_attack` int(11) DEFAULT NULL,
+  	
+  `weapon_delay` int(11) DEFAULT NULL,
+
+  `consumable_type` varchar(128) DEFAULT NULL,
+  	
+  `consumable_size` varchar(128) DEFAULT NULL,
+
+  `cost_amount` float DEFAULT NULL,
+  	
+  `cost_currency` varchar(128) DEFAULT NULL,
+
+  `player_id` varchar(128) NOT NULL,
+  PRIMARY KEY(`id`),
+  UNIQUE KEY `player_item_id_player_id_idx` (`player_item_id`,`player_id`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8;
+*/
+
+public class PlayerItem extends Model {
+	
+	public static void openTransaction() {
+		open();
+		DB db = new DB("default");
+		db.openTransaction();
+	}
+	
+	public static void commitTransaction() {
+		DB db = new DB("default");
+		db.commitTransaction();
+		close();
+	}
+	
+	public static void rollbackTransaction() {
+		DB db = new DB("default");
+		db.rollbackTransaction();
+		close();
+	}
+	
+	public static void close() {
+		DB db = new DB("default");
+		if(db.hasConnection()) {
+			db.close();
+		}
+	}
+	
+	public static void open() {
+		DB db = new DB("default");
+		if(!db.hasConnection()) {
+			HikariDataSource ds = DbConnectionPool.getInstance().getDataSource("game_machine_orm");
+			db.open(ds);
+		}
+	}
+}

data/java/project/src/main/java/com/game_machine/orm/models/TestObject.java

@@ -0,0 +1,110 @@
+package com.game_machine.orm.models;
+
+import org.javalite.activejdbc.DB;
+import org.javalite.activejdbc.Model;
+import org.javalite.activejdbc.annotations.IdName;
+
+import com.game_machine.core.DbConnectionPool;
+import com.zaxxer.hikari.HikariDataSource;
+
+/*
+Postgresql
+
+Database/user creation
+CREATE ROLE gamemachine WITH ENCRYPTED PASSWORD 'gamemachine' LOGIN CREATEDB CREATEROLE;
+CREATE DATABASE gamemachine WITH OWNER=gamemachine ENCODING='UTF8';
+
+Table
+CREATE TABLE test_objects (
+  id bigserial NOT NULL,
+  
+  test_object_optional_string character varying(128) DEFAULT NULL,
+  
+  test_object_required_string character varying(128) NOT NULL,
+  
+  test_object_numbers integer DEFAULT NULL,
+
+  test_object_bvalue integer DEFAULT NULL,
+  
+  test_object_dvalue double precision DEFAULT NULL,
+  
+  test_object_fvalue double precision DEFAULT NULL,
+  
+  test_object_numbers64 integer DEFAULT NULL,
+
+  test_object_id character varying(128) NOT NULL,
+
+  player_id character varying(128) NOT NULL,
+  CONSTRAINT test_object_pkey PRIMARY KEY (id),
+  CONSTRAINT test_object_id_player_id_idx UNIQUE (test_object_id,player_id)
+);
+alter table test_objects owner to gamemachine;
+
+Mysql
+
+Database/user creation
+CREATE DATABASE IF NOT EXISTS gamemachine CHARACTER SET utf8 COLLATE utf8_general_ci;
+GRANT ALL PRIVILEGES ON gamemachine.* TO 'gamemachine'@'%' IDENTIFIED BY 'gamemachine' WITH GRANT OPTION;
+FLUSH PRIVILEGES;
+
+Table
+CREATE TABLE `test_objects` (
+  `id` int(11) NOT NULL AUTO_INCREMENT,
+  
+  `test_object_optional_string` varchar(128) DEFAULT NULL,
+  
+  `test_object_required_string` varchar(128) NOT NULL,
+  
+  `test_object_numbers` int(11) DEFAULT NULL,
+
+  `test_object_bvalue` tinyint(4) DEFAULT NULL,
+  
+  `test_object_dvalue` double DEFAULT NULL,
+  
+  `test_object_fvalue` float DEFAULT NULL,
+  
+  `test_object_numbers64` int(11) DEFAULT NULL,
+
+  `test_object_id` varchar(128) NOT NULL,
+
+  `player_id` varchar(128) NOT NULL,
+  PRIMARY KEY(`id`),
+  UNIQUE KEY `test_object_id_player_id_idx` (`test_object_id`,`player_id`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8;
+*/
+
+public class TestObject extends Model {
+	
+	public static void openTransaction() {
+		open();
+		DB db = new DB("default");
+		db.openTransaction();
+	}
+	
+	public static void commitTransaction() {
+		DB db = new DB("default");
+		db.commitTransaction();
+		close();
+	}
+	
+	public static void rollbackTransaction() {
+		DB db = new DB("default");
+		db.rollbackTransaction();
+		close();
+	}
+	
+	public static void close() {
+		DB db = new DB("default");
+		if(db.hasConnection()) {
+			db.close();
+		}
+	}
+	
+	public static void open() {
+		DB db = new DB("default");
+		if(!db.hasConnection()) {
+			HikariDataSource ds = DbConnectionPool.getInstance().getDataSource("game_machine_orm");
+			db.open(ds);
+		}
+	}
+}