2025 update!

Related to #128

README.md

@@ -2,8 +2,10 @@ chuck.js
 ========
 
 Physical JavaScript Action Browser Multiplayer Game - it will be awesome!
-
-[![Foo](http://25.media.tumblr.com/8249dcd3bdb176686421d1914937db1c/tumblr_mzc1ejGxNC1ry8awho1_400.png)](http://chuck-game.tumblr.com/ "Screenshot of chuck.js - click to visit our development blog!")
+  
+<a href="http://chuck-game.tumblr.com/about" title="Play the chuck trailer" target="_blank">
+  <img src="https://cloud.githubusercontent.com/assets/692826/8396811/3369df82-1db6-11e5-939f-5ceeba64d802.png">
+</a>
 
 Follow the development at http://chuck-game.tumblr.com/
 

app/Bootstrap/HttpServer.js

@@ -1,105 +1,74 @@
 define([
-    'http', 
-    'node-static',
+    'express',
+    'http',
+    'path',
     'Server/Api',
     'fs'
 ], 
 
-function (http, nodeStatic, Api, fs) {
+function (express, http, path, Api, fs) {
 
-	"use strict";
+    "use strict";
 
     function HttpServer (options, coordinator) {
         options.port = options.port || 1234;
-        options.caching = typeof options.caching != 'undefined' ? options.caching : 3600;
         options.rootDirectory = options.rootDirectory || './';
 
-        this.server = null;
         this.api = new Api(coordinator);
-
+        this.app = express();
+        this.server = http.createServer(this.app);
         this.init(options);
     }
 
     HttpServer.prototype.init = function (options) {
         var self = this;
+        var app = this.app;
 
-        //gzip true serves gzip file if there is one with .gz next to the original && if browser supports it
-        var fileServer = new nodeStatic.Server(options.rootDirectory, { cache: options.caching, gzip: true });
+        // Serve static files
+        app.use('/static', express.static(path.join(options.rootDirectory, 'static')));
+        app.use('/app', express.static(path.join(options.rootDirectory, 'app')));
 
-        this.server = http.createServer(
-            function (req, res) {
-                
-                var fullBody = '';
-                req.addListener('data', function(chunk) { // doesn't work on Jeenas computer without this
-                    fullBody += chunk.toString();
-                });
+        // Serve index.html at root
+        app.get('/', function(req, res) {
+            res.sendFile(path.resolve(options.rootDirectory, 'static/html/index.html'));
+        });
 
-                req.addListener('error', function(err) {
-                    console.log('');
-                });
-
-
-                req.addListener('end', function () {
-
-                    switch(true) {
-                        case req.url == '/':
-                            fileServer.serveFile('./static/html/index.html', 200, {}, req, res);
-                            console.checkpoint('HTTP Server serves index');
-                            break;
-
-                        case req.url == '/client.js':
-                            fs.exists('./build/client.min.js', function (exists) {
-                                if (process.env.NODE_ENV && process.env.NODE_ENV == 'production' && exists) {
-                                    fileServer.serveFile('./build/client.min.js', 200, {}, req, res);
-                                } else {
-                                    fileServer.serveFile('./client.js', 200, {}, req, res);
-                                }
-                            });
-                            break;
-
-                        case req.url == '/client.min.js':
-                            fileServer.serveFile('./build/client.min.js', 200, {}, req, res);
-                            break;
-
-                        case req.url == '/require.js':
-                            fileServer.serveFile('./node_modules/requirejs/require.js', 200, {}, req, res);
-                            break;
-
-                        case req.url == '/screenfull.js':
-                            fileServer.serveFile('./node_modules/screenfull/dist/screenfull.js', 200, {}, req, res);
-                            break;
-
-                        case req.url == '/chart.js':
-                            fileServer.serveFile('./node_modules/chart.js/Chart.js', 200, {}, req, res);
-                            break;
-
-                        case req.url == '/api':
-                            self.api.handleCall(fullBody);
-                            var status = self.api.isError ? 400 : 200;
-                            res.writeHead(status, {"Content-Type": self.api.getContentType()});
-                            res.end(self.api.getOutput());
-                            self.api.isError = false;
-                            break;
-
-                        case new RegExp(/^\/app/).test(req.url):
-                            fileServer.serve(req, res, function () {
-                                self.handleFileError(res)
-                            });
-                            break;
-
-                        case new RegExp(/^\/static/).test(req.url):
-                            fileServer.serve(req, res, function () {
-                                self.handleFileError(res)
-                            });
-                            break;
-
-                        default:
-                            self.handleFileError(res);
-                            break;
-                    }
-                });
+        // Serve client.js and minified version
+        app.get('/client.js', function(req, res) {
+            if (process.env.NODE_ENV === 'production' && fs.existsSync(path.resolve(options.rootDirectory, 'build/client.min.js'))) {
+                res.sendFile(path.resolve(options.rootDirectory, 'build/client.min.js'));
+            } else {
+                res.sendFile(path.resolve(options.rootDirectory, 'client.js'));
             }
-        );
+        });
+        app.get('/client.min.js', function(req, res) {
+            res.sendFile(path.resolve(options.rootDirectory, 'build/client.min.js'));
+        });
+
+        // Serve require.js, screenfull.js, chart.js from node_modules
+        app.get('/require.js', function(req, res) {
+            res.sendFile(path.resolve(options.rootDirectory, 'node_modules/requirejs/require.js'));
+        });
+        app.get('/screenfull.js', function(req, res) {
+            res.sendFile(path.resolve(options.rootDirectory, 'static/vendor/screenfull.js'));
+        });
+        app.get('/chart.js', function(req, res) {
+            // Chart.js v4 uses 'dist/chart.umd.js'
+            res.sendFile(path.resolve(options.rootDirectory, 'node_modules/chart.js/dist/chart.umd.js'));
+        });
+
+        // API endpoint
+        app.post('/api', express.text({type: '*/*'}), function(req, res) {
+            self.api.handleCall(req.body);
+            var status = self.api.isError ? 400 : 200;
+            res.status(status).type(self.api.getContentType()).send(self.api.getOutput());
+            self.api.isError = false;
+        });
+
+        // 404 handler
+        app.use(function(req, res) {
+            res.status(404).send('<h1>404 not ... found</h1>');
+        });
 
         this.server.once('error', function(err) {
             if(err.code == 'EADDRINUSE') {
@@ -110,7 +79,6 @@ function (http, nodeStatic, Api, fs) {
         });
 
         this.server.listen(options.port);
-
         console.checkpoint('start HTTP server');
     }
 
@@ -118,10 +86,5 @@ function (http, nodeStatic, Api, fs) {
         return this.server;
     }
 
-    HttpServer.prototype.handleFileError = function (res) {
-        res.writeHead(404, {'Content-Type': 'text/html'}); 
-        res.end('<h1>404 not ... found</h1>'); 
-    }
-
     return HttpServer;
 });

app/Bootstrap/Socket.js

@@ -4,35 +4,23 @@ define([
 
 function (io) {
 
-	"use strict";
+    "use strict";
 
     function Socket (server, options, coordinator) {
-        options.logLevel = typeof options.logLevel != 'undefined'
-            ? options.logLevel
-            : 0;
-        
         this.coordinator = coordinator;
-        this.socket = io.listen(server);
-
+        this.io = io(server, {
+            // No more 'log level' or 'transports' in v4
+            // Add any v4-compatible options here if needed
+        });
         this.init(options);
     }
 
     Socket.prototype.init = function (options) {
-
         var self = this;
-        this.socket.configure('development', function () {
-            this.set('log level', options.logLevel);
-        });
-
-        this.socket.configure('production', function () {
-            this.set('log level', options.logLevel);
-        });
-
-        this.socket.on('connection', function (user) {
+        this.io.on('connection', function (socket) {
             console.checkpoint('socket receiving connection');
-            self.onConnection(user);
+            self.onConnection(socket);
         });
-
         console.checkpoint('start Socket Listener');
     }
 

app/Game/Asset/RubeDoll.json

@@ -0,0 +1,783 @@
+{
+	"allowSleep" : true,
+	"autoClearForces" : true,
+	"body" : 
+	[
+		
+		{
+			"angle" : 0,
+			"angularVelocity" : 0,
+			"awake" : true,
+			"fixture" : 
+			[
+				
+				{
+					"density" : 1,
+					"filter-groupIndex" : -55,
+					"friction" : 0.2,
+					"name" : "fixture3",
+					"polygon" : 
+					{
+						"vertices" : 
+						{
+							"x" : 
+							[
+								0.04692989960312843,
+								0.04692989960312843,
+								-0.04693000018596649,
+								-0.04693000018596649
+							],
+							"y" : 
+							[
+								-0.1895969957113266,
+								0.1895969957113266,
+								0.1895969957113266,
+								-0.1895969957113266
+							]
+						}
+					}
+				}
+			],
+			"linearVelocity" : 0,
+			"massData-I" : 0.0004525936674326658,
+			"massData-center" : 
+			{
+				"x" : -5.029141902923584e-08,
+				"y" : 0
+			},
+			"massData-mass" : 0.03559110686182976,
+			"name" : "upperLeftArm",
+			"position" : 
+			{
+				"x" : -0.1165359988808632,
+				"y" : 0.9012569785118103
+			},
+			"type" : 2
+		},
+		
+		{
+			"angle" : 0,
+			"angularVelocity" : 0,
+			"awake" : true,
+			"fixture" : 
+			[
+				
+				{
+					"density" : 1,
+					"filter-groupIndex" : -55,
+					"friction" : 0.2,
+					"name" : "fixture2",
+					"polygon" : 
+					{
+						"vertices" : 
+						{
+							"x" : 
+							[
+								0.1366278976202011,
+								0.1366278976202011,
+								-0.1360991001129150,
+								-0.1360991001129150
+							],
+							"y" : 
+							[
+								-0.3788780868053436,
+								0.3830279111862183,
+								0.3830279111862183,
+								-0.3788780868053436
+							]
+						}
+					}
+				}
+			],
+			"linearVelocity" : 0,
+			"massData-I" : 0.01134084537625313,
+			"massData-center" : 
+			{
+				"x" : 0.0002643987536430359,
+				"y" : 0.002074912190437317
+			},
+			"massData-mass" : 0.2077923566102982,
+			"name" : "chest",
+			"position" : 
+			{
+				"x" : 0.0007875636219978333,
+				"y" : 0.7995355725288391
+			},
+			"type" : 2
+		},
+		
+		{
+			"angle" : 0,
+			"angularVelocity" : 0,
+			"awake" : true,
+			"fixture" : 
+			[
+				
+				{
+					"circle" : 
+					{
+						"center" : 
+						{
+							"x" : -0.01561669446527958,
+							"y" : 0.004700659774243832
+						},
+						"radius" : 0.2268356680870056
+					},
+					"density" : 0.2204959988594055,
+					"filter-groupIndex" : -55,
+					"friction" : 0.2,
+					"name" : "fixture1"
+				}
+			],
+			"linearVelocity" : 0,
+			"massData-I" : 0.0009264730615541339,
+			"massData-center" : 
+			{
+				"x" : -0.01561669446527958,
+				"y" : 0.004700659774243832
+			},
+			"massData-mass" : 0.03564291819930077,
+			"name" : "head",
+			"position" : 
+			{
+				"x" : 0.02309736609458923,
+				"y" : 1.497289657592773
+			},
+			"type" : 2
+		},
+		
+		{
+			"angle" : 0,
+			"angularVelocity" : 0,
+			"awake" : true,
+			"fixture" : 
+			[
+				
+				{
+					"density" : 1,
+					"filter-groupIndex" : -55,
+					"friction" : 0.2,
+					"name" : "fixture3",
+					"polygon" : 
+					{
+						"vertices" : 
+						{
+							"x" : 
+							[
+								0.04693000018596649,
+								0.04693000018596649,
+								-0.04693005979061127,
+								-0.04693005979061127
+							],
+							"y" : 
+							[
+								-0.1159216761589050,
+								0.1159217953681946,
+								0.1159217953681946,
+								-0.1159216761589050
+							]
+						}
+					}
+				}
+			],
+			"linearVelocity" : 0,
+			"massData-I" : 0.0001134485355578363,
+			"massData-center" : 
+			{
+				"x" : -2.980232238769531e-08,
+				"y" : 5.960464477539062e-08
+			},
+			"massData-mass" : 0.02176084183156490,
+			"name" : "lowerRightArm",
+			"position" : 
+			{
+				"x" : 0.1183081120252609,
+				"y" : 0.6842151284217834
+			},
+			"type" : 2
+		},
+		
+		{
+			"angle" : 0,
+			"angularVelocity" : 0,
+			"awake" : true,
+			"fixture" : 
+			[
+				
+				{
+					"density" : 1,
+					"filter-groupIndex" : -55,
+					"friction" : 0.2,
+					"name" : "fixture3",
+					"polygon" : 
+					{
+						"vertices" : 
+						{
+							"x" : 
+							[
+								0.07039500027894974,
+								0.07039500027894974,
+								-0.07039500027894974,
+								-0.07039500027894974
+							],
+							"y" : 
+							[
+								-0.09294360131025314,
+								0.1277720034122467,
+								0.1277720034122467,
+								-0.09294360131025314
+							]
+						}
+					}
+				}
+			],
+			"linearVelocity" : 0,
+			"massData-I" : 0.0001869037223514169,
+			"massData-center" : 
+			{
+				"x" : 0,
+				"y" : 0.01741420105099678
+			},
+			"massData-mass" : 0.03107454814016819,
+			"name" : "lowerLeftLeg",
+			"position" : 
+			{
+				"x" : -0.03829947486519814,
+				"y" : 0.09799569845199585
+			},
+			"type" : 2
+		},
+		
+		{
+			"angle" : 0,
+			"angularVelocity" : 0,
+			"awake" : true,
+			"fixture" : 
+			[
+				
+				{
+					"density" : 1,
+					"filter-groupIndex" : -55,
+					"friction" : 0.2,
+					"name" : "fixture3",
+					"polygon" : 
+					{
+						"vertices" : 
+						{
+							"x" : 
+							[
+								0.04693000763654709,
+								0.04693000763654709,
+								-0.04692991077899933,
+								-0.04692991077899933
+							],
+							"y" : 
+							[
+								-0.1159216761589050,
+								0.1159217953681946,
+								0.1159217953681946,
+								-0.1159216761589050
+							]
+						}
+					}
+				}
+			],
+			"linearVelocity" : 0,
+			"massData-I" : 0.0001134483172791079,
+			"massData-center" : 
+			{
+				"x" : 4.842877032729120e-08,
+				"y" : 5.960464477539062e-08
+			},
+			"massData-mass" : 0.02176081016659737,
+			"name" : "lowerLeftArm",
+			"position" : 
+			{
+				"x" : -0.1165381968021393,
+				"y" : 0.6842151284217834
+			},
+			"type" : 2
+		},
+		
+		{
+			"angle" : 0,
+			"angularVelocity" : 0,
+			"awake" : true,
+			"fixture" : 
+			[
+				
+				{
+					"density" : 1,
+					"filter-groupIndex" : -55,
+					"friction" : 0.2,
+					"name" : "fixture3",
+					"polygon" : 
+					{
+						"vertices" : 
+						{
+							"x" : 
+							[
+								0.04693000018596649,
+								0.04693000018596649,
+								-0.04693010076880455,
+								-0.04693010076880455
+							],
+							"y" : 
+							[
+								-0.1895969957113266,
+								0.1895969957113266,
+								0.1895969957113266,
+								-0.1895969957113266
+							]
+						}
+					}
+				}
+			],
+			"linearVelocity" : 0,
+			"massData-I" : 0.0004525947733782232,
+			"massData-center" : 
+			{
+				"x" : -5.029141902923584e-08,
+				"y" : 0
+			},
+			"massData-mass" : 0.03559118881821632,
+			"name" : "upperRightArm",
+			"position" : 
+			{
+				"x" : 0.1183080002665520,
+				"y" : 0.9012569785118103
+			},
+			"type" : 2
+		},
+		
+		{
+			"angle" : 0,
+			"angularVelocity" : 0,
+			"awake" : true,
+			"fixture" : 
+			[
+				
+				{
+					"density" : 1,
+					"filter-groupIndex" : -55,
+					"friction" : 0.2,
+					"name" : "fixture3",
+					"polygon" : 
+					{
+						"vertices" : 
+						{
+							"x" : 
+							[
+								0.07039496302604675,
+								0.07039496302604675,
+								-0.07039486616849899,
+								-0.07039486616849899
+							],
+							"y" : 
+							[
+								-0.1890522241592407,
+								0.1890524625778198,
+								0.1890524625778198,
+								-0.1890522241592407
+							]
+						}
+					}
+				}
+			],
+			"linearVelocity" : 0,
+			"massData-I" : 0.0007221315754577518,
+			"massData-center" : 
+			{
+				"x" : 4.842877388000488e-08,
+				"y" : 1.192092895507812e-07
+			},
+			"massData-mass" : 0.05323329567909241,
+			"name" : "upperRightLeg",
+			"position" : 
+			{
+				"x" : 0.03859551250934601,
+				"y" : 0.3325110077857971
+			},
+			"type" : 2
+		},
+		
+		{
+			"angle" : 0,
+			"angularVelocity" : 0,
+			"awake" : true,
+			"fixture" : 
+			[
+				
+				{
+					"density" : 1,
+					"filter-groupIndex" : -55,
+					"friction" : 0.2,
+					"name" : "fixture3",
+					"polygon" : 
+					{
+						"vertices" : 
+						{
+							"x" : 
+							[
+								0.07039505988359451,
+								0.07039505988359451,
+								-0.07039495557546616,
+								-0.07039495557546616
+							],
+							"y" : 
+							[
+								-0.1890522241592407,
+								0.1890524625778198,
+								0.1890524625778198,
+								-0.1890522241592407
+							]
+						}
+					}
+				}
+			],
+			"linearVelocity" : 0,
+			"massData-I" : 0.000722132739610970,
+			"massData-center" : 
+			{
+				"x" : 5.215406417846680e-08,
+				"y" : 1.192092824453539e-07
+			},
+			"massData-mass" : 0.05323336645960808,
+			"name" : "upperLeftLeg",
+			"position" : 
+			{
+				"x" : -0.03829947486519814,
+				"y" : 0.3325110077857971
+			},
+			"type" : 2
+		},
+		
+		{
+			"angle" : 0,
+			"angularVelocity" : 0,
+			"awake" : true,
+			"fixture" : 
+			[
+				
+				{
+					"density" : 1,
+					"filter-groupIndex" : -55,
+					"friction" : 0.2,
+					"name" : "fixture3",
+					"polygon" : 
+					{
+						"vertices" : 
+						{
+							"x" : 
+							[
+								0.07039500027894974,
+								0.07039500027894974,
+								-0.07039490342140198,
+								-0.07039490342140198
+							],
+							"y" : 
+							[
+								-0.09294389933347702,
+								0.1276109963655472,
+								0.1276109963655472,
+								-0.09294389933347702
+							]
+						}
+					}
+				}
+			],
+			"linearVelocity" : 0,
+			"massData-I" : 0.0001864968799054623,
+			"massData-center" : 
+			{
+				"x" : 4.842877032729120e-08,
+				"y" : 0.01733354665338993
+			},
+			"massData-mass" : 0.03105190023779869,
+			"name" : "lowerRightLeg",
+			"position" : 
+			{
+				"x" : 0.03859551250934601,
+				"y" : 0.09799569845199585
+			},
+			"type" : 2
+		}
+	],
+	"collisionbitplanes" : 
+	{
+		"names" : 
+		[
+			"bitplane1",
+			"bitplane2",
+			"bitplane3",
+			"bitplane4",
+			"bitplane5",
+			"bitplane6",
+			"bitplane7",
+			"bitplane8",
+			"bitplane9",
+			"bitplane10",
+			"bitplane11",
+			"bitplane12",
+			"bitplane13",
+			"bitplane14",
+			"bitplane15",
+			"bitplane16",
+			"bitplane17",
+			"bitplane18",
+			"bitplane19",
+			"bitplane20",
+			"bitplane21",
+			"bitplane22",
+			"bitplane23",
+			"bitplane24",
+			"bitplane25",
+			"bitplane26",
+			"bitplane27",
+			"bitplane28",
+			"bitplane29",
+			"bitplane30",
+			"bitplane31",
+			"bitplane32"
+		]
+	},
+	"continuousPhysics" : true,
+	"gravity" : 
+	{
+		"x" : 0,
+		"y" : -10
+	},
+	"joint" : 
+	[
+		
+		{
+			"anchorA" : 
+			{
+				"x" : 0.0003538504242897034,
+				"y" : 0.07107692956924438
+			},
+			"anchorB" : 
+			{
+				"x" : 0.0003536641597747803,
+				"y" : -0.1459649801254272
+			},
+			"bodyA" : 3,
+			"bodyB" : 6,
+			"enableLimit" : true,
+			"enableMotor" : false,
+			"jointSpeed" : 0,
+			"lowerLimit" : 0.01745329238474369,
+			"maxMotorTorque" : 1,
+			"motorSpeed" : 0,
+			"name" : "joint1",
+			"refAngle" : 0,
+			"type" : "revolute",
+			"upperLimit" : 1.919862151145935
+		},
+		
+		{
+			"anchorA" : 
+			{
+				"x" : -0.0007802955806255341,
+				"y" : -0.1484909951686859
+			},
+			"anchorB" : 
+			{
+				"x" : -0.0007801018655300140,
+				"y" : 0.08614099025726318
+			},
+			"bodyA" : 8,
+			"bodyB" : 4,
+			"enableLimit" : true,
+			"enableMotor" : false,
+			"jointSpeed" : 0,
+			"lowerLimit" : 0.01745329238474369,
+			"maxMotorTorque" : 1,
+			"motorSpeed" : 0,
+			"name" : "joint7",
+			"refAngle" : 0,
+			"type" : "revolute",
+			"upperLimit" : 2.443460941314697
+		},
+		
+		{
+			"anchorA" : 
+			{
+				"x" : -0.004979588091373444,
+				"y" : -0.1506859958171844
+			},
+			"anchorB" : 
+			{
+				"x" : -0.005973689258098602,
+				"y" : 0.08482310175895691
+			},
+			"bodyA" : 7,
+			"bodyB" : 9,
+			"enableLimit" : true,
+			"enableMotor" : false,
+			"jointSpeed" : 0,
+			"lowerLimit" : 0.01745329238474369,
+			"maxMotorTorque" : 1,
+			"motorSpeed" : 0,
+			"name" : "joint8",
+			"refAngle" : 0,
+			"type" : "revolute",
+			"upperLimit" : 2.443460941314697
+		},
+		
+		{
+			"anchorA" : 
+			{
+				"x" : -0.06799955666065216,
+				"y" : -0.3021813035011292
+			},
+			"anchorB" : 
+			{
+				"x" : -0.02891255542635918,
+				"y" : 0.1648437976837158
+			},
+			"bodyA" : 1,
+			"bodyB" : 8,
+			"enableLimit" : true,
+			"enableMotor" : false,
+			"jointSpeed" : 0,
+			"lowerLimit" : -0.7853981852531433,
+			"maxMotorTorque" : 1,
+			"motorSpeed" : 0,
+			"name" : "joint6",
+			"refAngle" : 0,
+			"type" : "revolute",
+			"upperLimit" : 1.570796370506287
+		},
+		
+		{
+			"anchorA" : 
+			{
+				"x" : 0.06260262429714203,
+				"y" : -0.3029872477054596
+			},
+			"anchorB" : 
+			{
+				"x" : 0.02294230461120605,
+				"y" : 0.1640380322933197
+			},
+			"bodyA" : 1,
+			"bodyB" : 7,
+			"enableLimit" : true,
+			"enableMotor" : false,
+			"jointSpeed" : 0,
+			"lowerLimit" : -0.7853981852531433,
+			"maxMotorTorque" : 1,
+			"motorSpeed" : 0,
+			"name" : "joint5",
+			"refAngle" : 0,
+			"type" : "revolute",
+			"upperLimit" : 1.570796370506287
+		},
+		
+		{
+			"anchorA" : 
+			{
+				"x" : 0.1179294362664223,
+				"y" : 0.2464744448661804
+			},
+			"anchorB" : 
+			{
+				"x" : 0.0004089996218681335,
+				"y" : 0.1447530388832092
+			},
+			"bodyA" : 1,
+			"bodyB" : 6,
+			"enableLimit" : false,
+			"enableMotor" : false,
+			"jointSpeed" : 0,
+			"lowerLimit" : -2.268928050994873,
+			"maxMotorTorque" : 1,
+			"motorSpeed" : 0,
+			"name" : "joint2",
+			"refAngle" : 0,
+			"type" : "revolute",
+			"upperLimit" : 3.141592741012573
+		},
+		
+		{
+			"anchorA" : 
+			{
+				"x" : -0.1188285648822784,
+				"y" : 0.2521644234657288
+			},
+			"anchorB" : 
+			{
+				"x" : -0.001505002379417419,
+				"y" : 0.1504430174827576
+			},
+			"bodyA" : 1,
+			"bodyB" : 0,
+			"enableLimit" : false,
+			"enableMotor" : false,
+			"jointSpeed" : 0,
+			"lowerLimit" : -2.268928050994873,
+			"maxMotorTorque" : 1,
+			"motorSpeed" : 0,
+			"name" : "joint3",
+			"refAngle" : 0,
+			"type" : "revolute",
+			"upperLimit" : 3.141592741012573
+		},
+		
+		{
+			"anchorA" : 
+			{
+				"x" : 0.0008554458618164062,
+				"y" : -0.1461489796638489
+			},
+			"anchorB" : 
+			{
+				"x" : 0.0008557140827178955,
+				"y" : 0.07089227437973022
+			},
+			"bodyA" : 0,
+			"bodyB" : 5,
+			"enableLimit" : true,
+			"enableMotor" : false,
+			"jointSpeed" : 0,
+			"lowerLimit" : -1.919862151145935,
+			"maxMotorTorque" : 1,
+			"motorSpeed" : 0,
+			"name" : "joint4",
+			"refAngle" : 0,
+			"type" : "revolute",
+			"upperLimit" : 0.01745329238474369
+		},
+		
+		{
+			"anchorA" : 
+			{
+				"x" : 0.02210754156112671,
+				"y" : 0.4607425332069397
+			},
+			"anchorB" : 
+			{
+				"x" : -0.02544101513922215,
+				"y" : -0.2591779232025146
+			},
+			"bodyA" : 1,
+			"bodyB" : 2,
+			"enableLimit" : true,
+			"enableMotor" : false,
+			"jointSpeed" : 0,
+			"lowerLimit" : -0.6981316804885864,
+			"maxMotorTorque" : 0,
+			"motorSpeed" : 0,
+			"name" : "joint9",
+			"refAngle" : 0,
+			"type" : "revolute",
+			"upperLimit" : 1.221730470657349
+		}
+	],
+	"positionIterations" : 3,
+	"stepsPerSecond" : 60.0,
+	"subStepping" : false,
+	"velocityIterations" : 8,
+	"warmStarting" : true
+}

app/Game/Channel/Channel.js

@@ -3,11 +3,11 @@
         "Lib/Utilities/NotificationCenter",
         "Game/Channel/User",
         "Lib/Utilities/Protocol/Helper",
-        "Lib/Utilities/Options",
+        "Lib/Utilities/OptionsHelper",
         "Game/Config/Settings"
     ], 
 
-    function (GameController, Nc, User, ProtocolHelper, Options, Settings) {
+    function (GameController, nc, User, ProtocolHelper, optionsHelper, Settings) {
 
         "use strict";
 
@@ -21,19 +21,19 @@
             this.levelListIndex = -1;
             this.gameController = null;
 
-            this.options = options = Options.merge(options, {
+            this.options = options = optionsHelper.merge(options, {
                 levelUids: Settings.CHANNEL_DEFAULT_LEVELS
             });
 
             // Notification Center
-            Nc.on(Nc.ns.channel.events.round.end, this.onEndRound, this);
-            Nc.on(Nc.ns.channel.events.controlCommand.channel, function (message) {
+            nc.on(nc.ns.channel.events.round.end, this.onEndRound, this);
+            nc.on(nc.ns.channel.events.controlCommand.channel, function (message) {
                 ProtocolHelper.applyCommand(message.data, self);
             });
-            Nc.on(Nc.ns.channel.to.client.gameCommand.broadcast, this.broadcastGameCommand, this);
-            Nc.on(Nc.ns.channel.to.client.controlCommand.broadcast, this.broadcastControlCommand, this);
-            //Nc.on(Nc.ns.channel.to.client.gameCommand.broadcastExcept, this.broadcastGameCommandExcept, this);
-            //Nc.on(Nc.ns.channel.to.client.controlCommand.broadcastExcept, this.broadcastControlCommandExcept, this);
+            nc.on(nc.ns.channel.to.client.gameCommand.broadcast, this.broadcastGameCommand, this);
+            nc.on(nc.ns.channel.to.client.controlCommand.broadcast, this.broadcastControlCommand, this);
+            //nc.on(nc.ns.channel.to.client.gameCommand.broadcastExcept, this.broadcastGameCommandExcept, this);
+            //nc.on(nc.ns.channel.to.client.controlCommand.broadcastExcept, this.broadcastControlCommandExcept, this);
 
             this.beginRound();
 
@@ -82,6 +82,7 @@
 
         Channel.prototype.onEndRound = function() {
             var self = this;
+            this.gameController.endRound();
             this.broadcastControlCommand("endRound", true);
 
             console.checkpoint("End Round (" + this.name + ") - Begin Round in " + Settings.CHANNEL_END_ROUND_TIME + " seconds");
@@ -102,10 +103,10 @@
             };
 
             if(!this.gameController.level || !this.gameController.level.isLoaded) {
-                var token = Nc.on(Nc.ns.core.game.events.level.loaded, function() {
+                var token = nc.on(nc.ns.core.game.events.level.loaded, function() {
                     self.sendJoinSuccess(options);
                     self.users[options.id].sendControlCommand("beginRound", clientGameControllerOptions);
-                    Nc.off(token);
+                    nc.off(token);
                 });
             } else {
                 this.sendJoinSuccess(options);
@@ -134,16 +135,16 @@
                 levelUid: levelUid
             };                 
 
-            //Nc.trigger("user/" + user.id + "/joinSuccess", options);
+            //nc.trigger("user/" + user.id + "/joinSuccess", options);
             user.sendControlCommand("joinSuccess", options);
-            Nc.trigger(Nc.ns.channel.events.user.joined, user);
+            nc.trigger(nc.ns.channel.events.user.joined, user);
 
             this.broadcastControlCommandExcept("userJoined", user.options, user);
         };
 
         Channel.prototype.onReleaseUser = function (userId) {
             var self = this;
-            Nc.trigger(Nc.ns.channel.events.user.left, userId);
+            nc.trigger(nc.ns.channel.events.user.left, userId);
             delete this.users[userId];
 
             this.broadcastControlCommand("userLeft", userId);

app/Game/Channel/Control/PlayerController.js

@@ -5,7 +5,7 @@ define([
     "Game/Config/Settings"
 ],
  
-function(Parent, Nc, Parser, Settings) {
+function(Parent, nc, Parser, Settings) {
 
     "use strict";
  
@@ -35,9 +35,9 @@ function(Parent, Nc, Parser, Settings) {
     };
 
     PlayerController.prototype.handActionRequest = function(options) {
-        options.x = parseFloat(options.x) || 0;
-        options.y = parseFloat(options.y) || 0;
-        options.av = parseFloat(options.av) || 0;
+        options.x = parseFloat(options.x) || 0.0;
+        options.y = parseFloat(options.y) || 0.0;
+        options.av = parseFloat(options.av) || 0.0;
         if (options) this.player.handActionRequest(options);
     };
 
@@ -45,7 +45,7 @@ function(Parent, Nc, Parser, Settings) {
         this.player.suicide();
     };
 
-    PlayerController.prototype.mePositionStateUpdate = function(update) {
+    PlayerController.prototype.mePositionStateOverride = function(update) {
 
         if(!this.player.isSpawned()) {
             // if someone still falls but is dead on the server already
@@ -57,7 +57,7 @@ function(Parent, Nc, Parser, Settings) {
             y: Math.abs(update.p.y - this.player.doll.body.GetPosition().y)
         };
 
-        if(true || difference.x < Settings.PUNKBUSTER_DIFFERENCE_METERS &&
+        if(difference.x < Settings.PUNKBUSTER_DIFFERENCE_METERS &&
            difference.y < Settings.PUNKBUSTER_DIFFERENCE_METERS) {
             this.player.doll.updatePositionState(update);
         } else {
@@ -71,7 +71,7 @@ function(Parent, Nc, Parser, Settings) {
                 lv: body.GetLinearVelocity()
             };
 
-            Nc.trigger(Nc.ns.channel.to.client.user.gameCommand.send + this.player.id, "positionStateReset", options);
+            nc.trigger(nc.ns.channel.to.client.user.gameCommand.send + this.player.id, "positionStateReset", options);
         }
     };
 

app/Game/Channel/GameController.js

@@ -2,17 +2,16 @@ define([
     "Game/Core/GameController",
     "Game/Channel/Physics/Engine",
     "Game/Config/Settings", 
-    "Game/Channel/Control/PlayerController",
     "Lib/Utilities/RequestAnimFrame",
     "Lib/Utilities/NotificationCenter",
     "Lib/Vendor/Box2D",
     "Game/Channel/Player",
     "Game/Channel/GameObjects/GameObject",
     "Game/Channel/GameObjects/Doll",
-    "Game/Channel/GameObjects/Items/RagDoll"
+    "Game/Channel/GameObjects/Items/RubeDoll"
 ],
 
-function (Parent, PhysicsEngine, Settings, PlayerController, requestAnimFrame, Nc, Box2D, Player, GameObject, Doll, RagDoll) {
+function (Parent, PhysicsEngine, Settings, requestAnimFrame, nc, Box2D, Player, GameObject, Doll, RubeDoll) {
 
 	"use strict";
 
@@ -21,22 +20,22 @@ function (Parent, PhysicsEngine, Settings, PlayerController, requestAnimFrame, N
         this.animationTimeout = null;
         this.worldUpdateTimeout = null;
         this.spawnTimeouts = [];
+        this.roundHasEnded = false;
 
         Parent.call(this, options);
 
         this.ncTokens = this.ncTokens.concat([
-            Nc.on(Nc.ns.channel.events.user.joined, this.onUserJoined, this),
-            Nc.on(Nc.ns.channel.events.user.left, this.onUserLeft, this),
-            Nc.on(Nc.ns.channel.events.user.level.reset, this.onResetLevel, this),
-            Nc.on(Nc.ns.channel.events.user.client.ready, this.onClientReady, this),
-            Nc.on(Nc.ns.core.game.events.level.loaded, this.onLevelLoaded, this), 
-            Nc.on(Nc.ns.channel.events.game.player.killed, this.onPlayerKilled, this),
+            nc.on(nc.ns.channel.events.user.joined, this.onUserJoined, this),
+            nc.on(nc.ns.channel.events.user.left, this.onUserLeft, this),
+            nc.on(nc.ns.channel.events.user.level.reset, this.onResetLevel, this),
+            nc.on(nc.ns.channel.events.user.client.ready, this.onClientReady, this),
+            nc.on(nc.ns.core.game.events.level.loaded, this.onLevelLoaded, this), 
+            nc.on(nc.ns.channel.events.game.player.killed, this.onPlayerKilled, this),
         ]);
 
         console.checkpoint('starting game controller for channel (' + options.channelName + ')');
     }
 
-
     GameController.prototype = Object.create(Parent.prototype);
 
     GameController.prototype.update  = function () {
@@ -59,15 +58,28 @@ function (Parent, PhysicsEngine, Settings, PlayerController, requestAnimFrame, N
         this.createPlayer(user);
     }
 
+    GameController.prototype.onUserLeft = function (userId) {
+        var player = this.players[userId];
+        this.clearItemsOfPlayerFingerPrints(player);
+        Parent.prototype.onUserLeft.call(this, userId);
+    };
+
+    GameController.prototype.clearItemsOfPlayerFingerPrints = function(player) {
+        nc.trigger(nc.ns.channel.events.game.player.clearFingerPrints, player);
+    };
+
     GameController.prototype.createPlayer = function(user) {
-        var player = Parent.prototype.createPlayer.call(this, user);
-        player.setPlayerController(new PlayerController(player))
+
+        var revealedGameController = {
+            isInBetweenRounds: this.isInBetweenRounds.bind(this)
+        }; 
+        var player = Parent.prototype.createPlayer.call(this, user, revealedGameController);
         user.setPlayer(player);
     };
 
     GameController.prototype.onPlayerKilled = function(player, killedByPlayer) {
         if(killedByPlayer.stats.score >= this.options.scoreLimit) {
-            Nc.trigger(Nc.ns.channel.events.round.end);
+            nc.trigger(nc.ns.channel.events.round.end);
         } else {
             this.spawnPlayer(player, Settings.RESPAWN_TIME);
         }
@@ -83,8 +95,6 @@ function (Parent, PhysicsEngine, Settings, PlayerController, requestAnimFrame, N
 
         var spawnTimeout = setTimeout(function() {
             player.spawn(spawnPoint.x, spawnPoint.y);
-            // put it into 
-            self.gameObjects.animated.push(player);
 
             var options = {
                 id: player.id, 
@@ -92,7 +102,7 @@ function (Parent, PhysicsEngine, Settings, PlayerController, requestAnimFrame, N
                 y: spawnPoint.y
             };
 
-            Nc.trigger(Nc.ns.channel.to.client.gameCommand.broadcast, "spawnPlayer", options);
+            nc.trigger(nc.ns.channel.to.client.gameCommand.broadcast, "spawnPlayer", options);
             
             var i = self.spawnTimeouts.indexOf(spawnTimeout);
             self.spawnTimeouts.splice(i, 1);
@@ -107,7 +117,7 @@ function (Parent, PhysicsEngine, Settings, PlayerController, requestAnimFrame, N
         var update = this.getWorldUpdateObject(false);
 
         if(Object.getOwnPropertyNames(update).length > 0) {
-            Nc.trigger(Nc.ns.channel.to.client.gameCommand.broadcast, "worldUpdate", update);
+            nc.trigger(nc.ns.channel.to.client.gameCommand.broadcast, "worldUpdate", update);
         }
 
         this.worldUpdateTimeout = setTimeout(this.updateWorld.bind(this), Settings.NETWORK_UPDATE_INTERVAL);
@@ -118,6 +128,7 @@ function (Parent, PhysicsEngine, Settings, PlayerController, requestAnimFrame, N
 
         var update = {};
 
+/*
         var body = this.physicsEngine.world.GetBodyList();
         do {
             if((getSleeping || body.IsAwake()) && body.GetType() === Box2D.Dynamics.b2Body.b2_dynamicBody) {
@@ -125,22 +136,33 @@ function (Parent, PhysicsEngine, Settings, PlayerController, requestAnimFrame, N
 
                 if (userData instanceof GameObject) {
                     var gameObject = userData;
-
-                    update[gameObject.uid] = {
-                        p: body.GetPosition(),
-                        a: body.GetAngle(),
-                        lv: body.GetLinearVelocity(),
-                        av: body.GetAngularVelocity()
-                    };
-
-                    if(gameObject instanceof Doll) {
-                        update[gameObject.uid].as = gameObject.getActionState();
-                        update[gameObject.uid].laxy = gameObject.lookAtXY;
+                    var updateData = gameObject.getUpdateData();
+                    
+                    if (updateData) {
+                        update[gameObject.uid] = updateData;
                     }
                 }
             }
 
         } while (body = body.GetNext());
+*/
+
+        for (var uid in this.worldUpdateObjects) {
+
+            var gameObject = this.worldUpdateObjects[uid];
+
+            if (!(gameObject instanceof GameObject)) {
+                console.warn('Cant find object ' + uid + ' in worldUpdateObjects pool (channel side), here is the object:');
+                console.log(gameObject);
+                continue;
+            }
+
+            var updateData = gameObject.getUpdateData(getSleeping);
+                    
+            if (updateData) {
+                update[gameObject.uid] = updateData;
+            }
+        }
 
         return update;
     };
@@ -168,23 +190,36 @@ function (Parent, PhysicsEngine, Settings, PlayerController, requestAnimFrame, N
         return spawnedPlayers;
     };
 
-    GameController.prototype.getRuntimeItems = function() {
-        var objects = [];
+    GameController.prototype._getRuntimeItems = function() {
 
-        for (var i = 0; i < this.gameObjects.animated.length; i++) {
-            if(this.gameObjects.animated[i] instanceof RagDoll) {
-                var object = this.gameObjects.animated[i];
-                var options = object.options;
-                options.x = object.getPosition().x;
-                options.y = object.getPosition().y;
-                objects.push({
-                    uid: object.uid,
-                    options: object.options
-                });
+        var runtimeItems = [];
+        for (var uid in this.worldUpdateObjects) {
+            if(this.worldUpdateObjects[uid] instanceof RubeDoll) {
+                var object = this.worldUpdateObjects[uid];
+                runtimeItems.push(object);
             }
         }
+        return runtimeItems;
+    };
 
-        return objects;
+    GameController.prototype.gatherRuntimeItemsForWorldUpdate = function() {
+        var infos = [];
+        var runtimeItems = this._getRuntimeItems();
+
+        // On the other side this is using the level.createItem mechanism to 
+        // create the RubeDoll from its ItemSettings
+        for (var i = 0; i < runtimeItems.length; i++) {
+            var object = runtimeItems[i];
+            var options = object.options;
+            options.x = object.getPosition().x;
+            options.y = object.getPosition().y;
+            infos.push({
+                uid: object.uid,
+                options: object.options
+            });
+        }
+
+        return infos;
     };
 
     GameController.prototype.onClientReady = function(userId) {
@@ -193,22 +228,34 @@ function (Parent, PhysicsEngine, Settings, PlayerController, requestAnimFrame, N
         var options = {
             spawnedPlayers: this.getSpawnedPlayersAndTheirPositions(),
             worldUpdate: this.getWorldUpdateObject(true),
-            runtimeItems: this.getRuntimeItems(),
+            runtimeItems: this.gatherRuntimeItemsForWorldUpdate(),
             userId: userId
         };
 
-        Nc.trigger(Nc.ns.channel.to.client.user.gameCommand.send + userId, "clientReadyResponse", options);
+        nc.trigger(nc.ns.channel.to.client.user.gameCommand.send + userId, "clientReadyResponse", options);
 
         this.spawnPlayer(player, 0);
     };
 
+    GameController.prototype.endRound = function() {
+        this.roundHasEnded = true;
+
+        for(var id in this.players) {
+            this.players[id].setInBetweenRounds(true);
+        }
+    };
+
+    GameController.prototype.isInBetweenRounds = function() {
+        return this.roundHasEnded;
+    };
+
     // FIXME: remove this method
     GameController.prototype.onResetLevel = function(userId) {
 
         console.log('OH NO!!! ON RESET LEVEL IS CALLED AND RESPAWNES PLAYERS');
 
         Parent.prototype.onResetLevel.call(this);
-        Nc.trigger(Nc.ns.channel.to.client.gameCommand.broadcast, "resetLevel", true);
+        nc.trigger(nc.ns.channel.to.client.gameCommand.broadcast, "resetLevel", true);
         for (var key in this.players) {
             this.spawnPlayer(this.players[key]);
         }
@@ -222,6 +269,11 @@ function (Parent, PhysicsEngine, Settings, PlayerController, requestAnimFrame, N
             clearTimeout(this.spawnTimeouts[i]);
         };
 
+        var runtimeItems = this._getRuntimeItems();
+        for (var i = 0; i < runtimeItems.length; i++) {
+            runtimeItems[i].destroy();
+        }
+
         Parent.prototype.destroy.call(this);
     };
 

app/Game/Channel/GameObjects/Doll.js

@@ -6,7 +6,7 @@ define([
     "Lib/Utilities/Assert"
 ],
  
-function (Parent, Item, Box2D, Nc, Assert) {
+function (Parent, Item, Box2D, nc, Assert) {
 
 	"use strict";
  
@@ -54,6 +54,7 @@ function (Parent, Item, Box2D, Nc, Assert) {
                     var b2Math = Box2D.Common.Math.b2Math;
                     var absItemVelocity = b2Math.AbsV(itemVelocity);
                     var min = 1;
+                    var damage = 0;
                     
                     if(absItemVelocity.x > min || absItemVelocity.y > min) {
                         if(item.lastMoved && item.lastMoved.player != this.player) {
@@ -72,18 +73,21 @@ function (Parent, Item, Box2D, Nc, Assert) {
                             // + 0.5 and / 2: offsetting for lower velocity impact
                             // * 300: tested imperically by throwing piano from deadly height
                             // * 80: tested imperically by throwing knife fast
-                            var damage = (velocityDamage + 0.5) * (weightDamage * 300 + dangerDamage * 80) / 2;
+                            damage = (velocityDamage + 0.5) * (weightDamage * 300 + dangerDamage * 80) / 2;
 
                             var lastMovedPlayer = item.lastMoved.player;
                             var callback = function() {
                                 self.player.addDamage(damage, lastMovedPlayer, item);
                             };
 
-                            Nc.trigger(Nc.ns.channel.engine.worldQueue.add, callback);
+                            nc.trigger(nc.ns.channel.engine.worldQueue.add, callback);
                         }
                     }
 
-                    item.setLastMovedBy(this.player);
+                    // only set lastMovedBy if player wasn't hurt by collision
+                    if (damage === 0) {
+                        item.setLastMovedBy(this.player);
+                    }
                 }
             }
         }
@@ -98,6 +102,18 @@ function (Parent, Item, Box2D, Nc, Assert) {
             this.body.SetLinearVelocity(update.lv);
         }
     };
+
+    Doll.prototype.getUpdateData = function(getSleeping) {
+
+        var updateData = Parent.prototype.getUpdateData.call(this, getSleeping);
+
+        if(updateData) {
+            updateData.as = this.getActionState();
+            updateData.laxy = this.lookAtXY;
+        }
+
+        return updateData;
+    };
  
     return Doll;
 

app/Game/Channel/GameObjects/GameObject.js

@@ -1,9 +1,39 @@
 define([
-	"Game/Core/GameObjects/GameObject"
+    "Game/Core/GameObjects/GameObject",
+    "Lib/Vendor/Box2D"
 ],
  
-function(Parent) {
+function (Parent, Box2D) {
 
-    return Parent;
+    "use strict";
  
+    function GameObject(physicsEngine, uid) {
+        Parent.call(this, physicsEngine, uid);
+    }
+
+    GameObject.prototype = Object.create(Parent.prototype);
+ 
+    GameObject.prototype.getUpdateData = function(getSleeping) {
+
+        if (!this.body) {
+            return null;
+        }
+
+        if (this.body.GetType() === Box2D.Dynamics.b2Body.b2_staticBody) {
+            return null;
+        }
+
+        if (!getSleeping && !this.body.IsAwake()) {
+            return null;
+        }
+        
+        return {
+            p: this.body.GetPosition(),
+            a: this.body.GetAngle(),
+            lv: this.body.GetLinearVelocity(),
+            av: this.body.GetAngularVelocity()
+        };
+    }
+ 
+    return GameObject;
 });

app/Game/Channel/GameObjects/Item.js

@@ -1,8 +1,9 @@
 define([
-	"Game/Core/GameObjects/Item"
+	"Game/Core/GameObjects/Item",
+    "Lib/Utilities/NotificationCenter",
 ],
  
-function (Parent) {
+function (Parent, nc) {
 
 	"use strict";
  
@@ -10,10 +11,17 @@ function (Parent) {
     	Parent.call(this, physicsEngine, uid, options);
     	this.heldByPlayers = [];
         this.lastMoved = null;
+
+        this.ncTokens = (this.ncTokens || []).concat([
+            nc.on(nc.ns.channel.events.game.player.clearFingerPrints, this.clearOfPlayerFingerPrints, this)
+        ]);
     }
 
     Item.prototype = Object.create(Parent.prototype);
  
+    Item.prototype.getLastMovedBy = function() {
+        return this.lastMoved;
+    }
 
     Item.prototype.setLastMovedBy = function(player) {
 
@@ -56,6 +64,13 @@ function (Parent) {
         }
     };
 
+    Item.prototype.clearOfPlayerFingerPrints = function(player) {
+        if (this.getLastMovedBy() && this.getLastMovedBy().player === player) {
+            console.checkpoint('Removing fingerprints from ' + this.options.image);
+            this.setLastMovedBy(null);
+        }
+    };
+
 	Item.prototype.onCollisionChange = function(isColliding, fixture) {
 
 		if(isColliding) {

app/Game/Channel/GameObjects/Items/RagDoll.js

@@ -4,7 +4,7 @@ define([
 	"Lib/Utilities/NotificationCenter"
 ],
  
-function (Parent, Settings, Nc) {
+function (Parent, Settings, nc) {
 
 	"use strict";
  
@@ -35,7 +35,7 @@ function (Parent, Settings, Nc) {
         var self = this;
         this.scheduledForDestruction = true;
         this.destructionTimeout = setTimeout(function() {
-            Nc.trigger(Nc.ns.channel.to.client.gameCommand.broadcast, 'removeGameObject', {
+            nc.trigger(nc.ns.channel.to.client.gameCommand.broadcast, 'removeGameObject', {
                 type: 'animated',
                 uid: self.uid
             });

app/Game/Channel/GameObjects/Items/Rube.js

@@ -1,11 +0,0 @@
-define([
-    "Game/Core/GameObjects/Items/Rube"
-],
- 
-function (Parent) {
-
-	"use strict";
-
-    return Parent;
- 
-});

app/Game/Channel/GameObjects/Items/RubeDoll.js

@@ -0,0 +1,79 @@
+define([
+    "Game/Core/GameObjects/Items/RubeDoll",
+   	"Game/Config/Settings",
+	"Lib/Utilities/NotificationCenter"
+],
+ 
+function (Parent, Settings, nc) {
+
+    "use strict";
+ 
+    function RubeDoll(physicsEngine, uid, options) {
+        this.scheduledForDestruction = false;
+        this.destructionTimeout = null;
+
+    	Parent.call(this, physicsEngine, uid, options);
+    }
+
+    RubeDoll.prototype = Object.create(Parent.prototype);
+
+    RubeDoll.prototype.beingGrabbed = function(player) {
+        Parent.prototype.beingGrabbed.call(this, player);
+        if(this.scheduledForDestruction) {
+            clearTimeout(this.destructionTimeout);
+        }
+    };
+ 
+    RubeDoll.prototype.beingReleased = function(player) {
+        Parent.prototype.beingReleased.call(this, player);
+        if(this.scheduledForDestruction) {
+            this.delayedDestroy();
+        }
+    };
+
+    RubeDoll.prototype.delayedDestroy = function() {
+        var self = this;
+        this.scheduledForDestruction = true;
+        this.destructionTimeout = setTimeout(function() {
+            nc.trigger(nc.ns.channel.to.client.gameCommand.broadcast, 'removeGameObject', {
+                type: 'animated',
+                uid: self.uid
+            });
+            self.destroy();
+        }, Settings.RAGDOLL_DESTRUCTION_TIME * 1000);
+    };
+
+    RubeDoll.prototype.getUpdateData = function(getSleeping) {
+        var updateData = Parent.prototype.getUpdateData.call(this, getSleeping);
+
+        // if parent is asleep it sends null, to do no update
+        if(!updateData) {
+            return updateData;
+        }
+
+        // adding limb update data
+        var limbUpdateData = {};
+
+        for(var name in this.limbs) {
+            limbUpdateData[name] = {
+                p: this.limbs[name].GetPosition(),
+                a: this.limbs[name].GetAngle(),
+                lv: this.limbs[name].GetLinearVelocity(),
+                av: this.limbs[name].GetAngularVelocity()
+            };
+        }
+        updateData['limbs'] = limbUpdateData;
+
+        return updateData;
+    }
+
+    RubeDoll.prototype.destroy = function() {
+        if(this.scheduledForDestruction) {
+            clearTimeout(this.destructionTimeout);
+        }
+    	Parent.prototype.destroy.call(this);
+    };
+ 
+    return RubeDoll;
+ 
+});

app/Game/Channel/Loader/Level.js

@@ -8,8 +8,8 @@ function (Parent, Settings, FileSystem) {
 
 	"use strict";
 
-    function Level (uid, engine, gameObjects) {
-        Parent.call(this, uid, engine, gameObjects);
+    function Level (uid, engine) {
+        Parent.call(this, uid, engine);
     }
 
     Level.prototype = Object.create(Parent.prototype);

app/Game/Channel/PipeToServer.js

@@ -5,7 +5,7 @@ define([
     "fs"
 ],
 
-function (Nc, Channel, Settings, fs) {
+function (nc, Channel, Settings, fs) {
 
 	"use strict";
 
@@ -14,7 +14,7 @@ function (Nc, Channel, Settings, fs) {
         this.process = process;
         this.recordingFileName = null;
 
-        Nc.on(Nc.ns.channel.to.server.controlCommand.send, this.send, this);
+        nc.on(nc.ns.channel.to.server.controlCommand.send, this.send, this);
 
         process.on("message", this.onProcessMessage.bind(this));   
     }
@@ -82,10 +82,10 @@ function (Nc, Channel, Settings, fs) {
     PipeToServer.prototype.onMessage = function (message) {
         switch(message.recipient) {
             case "channel":
-                Nc.trigger(Nc.ns.channel.events.controlCommand.channel, message);    
+                nc.trigger(nc.ns.channel.events.controlCommand.channel, message);    
                 break;
             default: 
-                Nc.trigger(Nc.ns.channel.events.controlCommand.user + message.recipient, message);    
+                nc.trigger(nc.ns.channel.events.controlCommand.user + message.recipient, message);    
                 break;
         }
         

app/Game/Channel/Player.js

@@ -1,14 +1,17 @@
 define([
 	"Game/Core/Player",
-	"Lib/Utilities/NotificationCenter"
+	"Lib/Utilities/NotificationCenter",
+    "Game/Channel/Control/PlayerController"
 ],
  
-function (Parent, Nc) {
+function (Parent, nc, PlayerController) {
 
 	"use strict";
  
-    function Player(id, physicsEngine, user) {
-    	Parent.call(this, id, physicsEngine, user);
+    function Player(id, physicsEngine, user, revealedGameController) {
+    	Parent.call(this, id, physicsEngine, user, revealedGameController);
+
+        this.playerController = new PlayerController(this);
     }
 
     Player.prototype = Object.create(Parent.prototype);
@@ -41,7 +44,7 @@ function (Parent, Nc) {
                 this.throw(options, item);
 
                 options.action = "throw";
-                Nc.trigger(Nc.ns.channel.to.client.gameCommand.broadcast, "handActionResponse", options);
+                nc.trigger(nc.ns.channel.to.client.gameCommand.broadcast, "handActionResponse", options);
             }
         } else {
             // grab
@@ -49,7 +52,7 @@ function (Parent, Nc) {
                 this.grab(item); 
 
                 options.action = "grab";
-                Nc.trigger(Nc.ns.channel.to.client.gameCommand.broadcast, "handActionResponse", options);
+                nc.trigger(nc.ns.channel.to.client.gameCommand.broadcast, "handActionResponse", options);
             }
         }
     };
@@ -61,6 +64,12 @@ function (Parent, Nc) {
     };
 
     Player.prototype.addDamage = function(damage, enemy, byItem) {
+
+        // Prevent stats change (kills) after round has ended
+        if (this.revealedGameController.isInBetweenRounds()) {
+            return;
+        }
+
         this.stats.health -= damage;
         
         if(this.stats.health < 0) this.stats.health = 0;
@@ -84,14 +93,14 @@ function (Parent, Nc) {
         var ragDollId = this.stats.deaths;
         Parent.prototype.kill.call(this, killedByPlayer, ragDollId);
 
-        Nc.trigger(Nc.ns.channel.to.client.gameCommand.broadcast, "playerKill", {
+        nc.trigger(nc.ns.channel.to.client.gameCommand.broadcast, "playerKill", {
             playerId: this.id,
             killedByPlayerId: killedByPlayer.id,
             ragDollId: ragDollId,
             item: byItem ? byItem.options.name : "Suicide"
         });
 
-        Nc.trigger(Nc.ns.channel.events.game.player.killed, this, killedByPlayer); // sends endround
+        nc.trigger(nc.ns.channel.events.game.player.killed, this, killedByPlayer); // sends endround
 
         if(this.ragDoll) {
             this.ragDoll.delayedDestroy();
@@ -103,19 +112,18 @@ function (Parent, Nc) {
     };
 
     Player.prototype.broadcastStats = function(enemy) {
-        Nc.trigger(Nc.ns.channel.to.client.gameCommand.broadcast, "updateStats", {
+        nc.trigger(nc.ns.channel.to.client.gameCommand.broadcast, "updateStats", {
             playerId: this.id,
             stats: this.stats
         });
         
         if(enemy && enemy != this) {
-            Nc.trigger(Nc.ns.channel.to.client.gameCommand.broadcast, "updateStats", {
+            nc.trigger(nc.ns.channel.to.client.gameCommand.broadcast, "updateStats", {
                 playerId: enemy.id,
                 stats: enemy.stats
             });            
         }
     };
-    
  
     return Player;
  

app/Game/Channel/User.js

@@ -5,7 +5,7 @@ define([
     "Lib/Utilities/Protocol/Parser",
 ],
  
-function(Parent, Nc, ProtocolHelper, ProtocolParser) {
+function(Parent, nc, ProtocolHelper, ProtocolParser) {
  
     function User(id, options) {
     	Parent.call(this, id, options);
@@ -14,15 +14,15 @@ function(Parent, Nc, ProtocolHelper, ProtocolParser) {
         this.isReady = false;
     	var self = this;
 
-    	Nc.on(Nc.ns.channel.to.client.user.controlCommand.joinSuccess + this.id, function(options) {
+    	nc.on(nc.ns.channel.to.client.user.controlCommand.joinSuccess + this.id, function(options) {
     		self.sendControlCommand("joinSuccess", options);
     	});
 
-        Nc.on(Nc.ns.channel.events.controlCommand.user + this.id, function(message) {
+        nc.on(nc.ns.channel.events.controlCommand.user + this.id, function(message) {
             ProtocolHelper.applyCommand(message.data, self);
         });
 
-        Nc.on(Nc.ns.channel.to.client.user.gameCommand.send + this.id, function(command, options) {
+        nc.on(nc.ns.channel.to.client.user.gameCommand.send + this.id, function(command, options) {
             self.sendGameCommand(command, options);
         });
         
@@ -44,10 +44,10 @@ function(Parent, Nc, ProtocolHelper, ProtocolParser) {
         } // FIXME: move this to Protocol helper as a function
 
         if(command.hasOwnProperty("resetLevel")) {
-            Nc.trigger(Nc.ns.channel.events.user.level.reset, this.id);
+            nc.trigger(nc.ns.channel.events.user.level.reset, this.id);
         } else if(command.hasOwnProperty("clientReady")) {
             this.isReady = true;
-            Nc.trigger(Nc.ns.channel.events.user.client.ready, this.id);
+            nc.trigger(nc.ns.channel.events.user.client.ready, this.id);
         } else {
             this.player.playerController.applyCommand(command);
         }
@@ -61,7 +61,17 @@ function(Parent, Nc, ProtocolHelper, ProtocolParser) {
     	var recipient = this.id;
 		var data = ProtocolHelper.encodeCommand(command, options);
 
-    	Nc.trigger(Nc.ns.channel.to.server.controlCommand.send, recipient, data);
+        /**
+          * Listen for beginRound control command
+          * to set client to be unready again
+          * so it can load its new level without getting
+          * any gameCommands like worldUpdate
+          */
+        if(command == "beginRound") {
+            this.isReady = false;
+        }
+
+    	nc.trigger(nc.ns.channel.to.server.controlCommand.send, recipient, data);
     };
 
     User.prototype.sendGameCommand = function(command, options) {

app/Game/Client/Control/Input.js

@@ -2,7 +2,7 @@ define([
 	"Lib/Utilities/NotificationCenter"
 ],
  
-function (Nc) {
+function (nc) {
  
     function Input(playerController) {
         this.playerController = playerController;

app/Game/Client/Control/Inputs/KeyboardAndMouse.js

@@ -6,7 +6,7 @@ define([
     "Game/Client/Control/Swiper"
 ],
  
-function (Parent, KeyboardInput, DomController, Settings, Swiper) {
+function (Parent, KeyboardInput, domController, Settings, Swiper) {
 
     "use strict";
  
@@ -122,7 +122,7 @@ function (Parent, KeyboardInput, DomController, Settings, Swiper) {
     };
 
     KeyboardAndMouse.prototype.mouseInit = function() {
-    	var canvas = DomController.getCanvas();
+    	var canvas = domController.getCanvas();
     	var self = this;
 
         canvas.onmousedown = function(e) {
@@ -216,6 +216,7 @@ function (Parent, KeyboardInput, DomController, Settings, Swiper) {
 
     KeyboardAndMouse.prototype.activateModifier = function() {
         this.modifier = true;
+        this.playerController.activateModifier();
     };
  
     KeyboardAndMouse.prototype.deactivateModifier = function() {
@@ -223,6 +224,7 @@ function (Parent, KeyboardInput, DomController, Settings, Swiper) {
         this.x = this.lastLookDirection * Settings.VIEWPORT_LOOK_AHEAD;
         this.y = 0;
         this.onXyChange(this.x, this.y);
+        this.playerController.deactivateModifier();
     };
     return KeyboardAndMouse;
  

app/Game/Client/Control/PlayerController.js

@@ -6,7 +6,7 @@ define([
     "Game/Client/PointerLockManager"
 ], 
 
-function (Parent, Nc, KeyboardAndMouse, Gamepad, PointerLockManager) {
+function (Parent, nc, KeyboardAndMouse, Gamepad, pointerLockManager) {
 
 	"use strict";
 
@@ -27,76 +27,98 @@ function (Parent, Nc, KeyboardAndMouse, Gamepad, PointerLockManager) {
     };
 
     PlayerController.prototype.moveLeft = function () {
-        if (!PointerLockManager.isLocked()) return;
+        if (!this.isPlayerInputAllowed()) return;
         Parent.prototype.moveLeft.call(this);
-        Nc.trigger(Nc.ns.client.to.server.gameCommand.send, 'moveLeft');
+        nc.trigger(nc.ns.client.to.server.gameCommand.send, 'moveLeft');
     }
 
     PlayerController.prototype.moveRight = function () {
-        if (!PointerLockManager.isLocked()) return;
+        if (!this.isPlayerInputAllowed()) return;
         Parent.prototype.moveRight.call(this);
-        Nc.trigger(Nc.ns.client.to.server.gameCommand.send, 'moveRight');
+        nc.trigger(nc.ns.client.to.server.gameCommand.send, 'moveRight');
     }
 
+    // always allow to stop, to prevent endless running
     PlayerController.prototype.stop = function () {
         Parent.prototype.stop.call(this);
-        Nc.trigger(Nc.ns.client.to.server.gameCommand.send, 'stop');
+        nc.trigger(nc.ns.client.to.server.gameCommand.send, 'stop');
     }
 
     PlayerController.prototype.jump = function () {
-        if (!PointerLockManager.isLocked()) return;
+        if (!this.isPlayerInputAllowed()) return;
         Parent.prototype.jump.call(this);
-        Nc.trigger(Nc.ns.client.to.server.gameCommand.send, 'jump');
+        nc.trigger(nc.ns.client.to.server.gameCommand.send, 'jump');
     }
 
+    // always allow to stop.
     PlayerController.prototype.jumpStop = function () {
-        if (!PointerLockManager.isLocked()) return;
         Parent.prototype.jumpStop.call(this);
-        Nc.trigger(Nc.ns.client.to.server.gameCommand.send, 'jumpStop');
+        nc.trigger(nc.ns.client.to.server.gameCommand.send, 'jumpStop');
     }
 
     PlayerController.prototype.setXY = function(x, y) {
-        if (!PointerLockManager.isLocked()) return;
+        if (!this.isPlayerInputAllowed()) return;
         var options = {x:x, y:y};
         Parent.prototype.lookAt.call(this, options);
-        Nc.trigger(Nc.ns.client.to.server.gameCommand.send, 'lookAt', options);
+        nc.trigger(nc.ns.client.to.server.gameCommand.send, 'lookAt', options);
     };
 
     PlayerController.prototype.suicide = function() {
-        if (!PointerLockManager.isLocked()) return;
-        Nc.trigger(Nc.ns.client.to.server.gameCommand.send, "suicide");
+        if (!this.isPlayerInputAllowed()) return;
+        nc.trigger(nc.ns.client.to.server.gameCommand.send, "suicide");
     };
 
     PlayerController.prototype.handActionRequest = function(options) {
-        if (!PointerLockManager.isLocked()) return;
-        Nc.trigger(Nc.ns.client.to.server.gameCommand.send, "handActionRequest", options);
+        if (!this.isPlayerInputAllowed()) return;
+        nc.trigger(nc.ns.client.to.server.gameCommand.send, "handActionRequest", options);
     };
 
     PlayerController.prototype.showInfo = function() {
-        if (!PointerLockManager.isLocked()) return;
-        Nc.trigger(Nc.ns.client.game.gameStats.toggle, true);
+        if (!this.isPlayerInputAllowed()) return;
+        nc.trigger(nc.ns.client.game.gameStats.toggle, true);
     };
 
     PlayerController.prototype.hideInfo = function() {
-        if (!PointerLockManager.isLocked()) return;
-        Nc.trigger(Nc.ns.client.game.gameStats.toggle, false);
+        if (!this.isPlayerInputAllowed()) return;
+        nc.trigger(nc.ns.client.game.gameStats.toggle, false);
     };
 
     PlayerController.prototype.zoomIn = function() {
-        if (!PointerLockManager.isLocked()) return;
-        Nc.trigger(Nc.ns.client.game.zoomIn, true);
+        if (!this.isPlayerInputAllowed()) return;
+        nc.trigger(nc.ns.client.game.zoomIn, true);
     };
 
     PlayerController.prototype.zoomOut = function() {
-        if (!PointerLockManager.isLocked()) return;
-        Nc.trigger(Nc.ns.client.game.zoomOut, false);
+        if (!this.isPlayerInputAllowed()) return;
+        nc.trigger(nc.ns.client.game.zoomOut, false);
     };
 
     PlayerController.prototype.zoomReset = function() {
-        if (!PointerLockManager.isLocked()) return;
-        Nc.trigger(Nc.ns.client.game.zoomReset, false);
+        if (!this.isPlayerInputAllowed()) return;
+        nc.trigger(nc.ns.client.game.zoomReset, false);
     };
-    
 
+    PlayerController.prototype.activateModifier = function() {
+        if (!this.isPlayerInputAllowed()) return;
+        Parent.prototype.activateModifier.call(this);
+        nc.trigger(nc.ns.client.to.server.gameCommand.send, "activateModifier");
+    };
+
+    PlayerController.prototype.deactivateModifier = function() {
+        if (!this.isPlayerInputAllowed()) return;
+        Parent.prototype.deactivateModifier.call(this);
+        nc.trigger(nc.ns.client.to.server.gameCommand.send, "deactivateModifier");
+    };
+
+    /*
+     * Client overwrite - allow player input if PointerLock is locked to canvas
+     * and is not in between games
+     */
+    PlayerController.prototype.isPlayerInputAllowed = function() {
+        return pointerLockManager.isLocked() 
+            && Parent.prototype.isPlayerInputAllowed.call(this);
+    };
+
+    
     return PlayerController;
 });

app/Game/Client/Control/Swiper.js

@@ -2,7 +2,7 @@ define([
 	"Lib/Utilities/NotificationCenter",
 ],
  
-function (Nc) {
+function (nc) {
 
 	var MAX_LENGTH = 200;
 	var MIN_LENGTH = 5;
@@ -42,7 +42,7 @@ function (Nc) {
 		}
 
 		var i = points.length - 1;
-		Nc.trigger(Nc.ns.client.view.swiper.swipe, points[i].x, points[i].y);
+		nc.trigger(nc.ns.client.view.swiper.swipe, points[i].x, points[i].y);
 	}
 
 	Swiper.prototype.updateLengthSum = function(currentLength) {
@@ -135,7 +135,7 @@ function (Nc) {
 		var sumx = 0;
 		var sumy = 0;
 
-		Nc.trigger(Nc.ns.client.view.swiper.end);
+		nc.trigger(nc.ns.client.view.swiper.end);
 		
 		for(var i=0, count = this.points.length; i < count; i++) {
 			var p = this.points[i];
@@ -166,7 +166,7 @@ function (Nc) {
 
 	Swiper.prototype.destroy = function() {
 		for (var i = 0; i < this.ncTokens.length; i++) {
-			Nc.off(this.ncTokens[i]);
+			nc.off(this.ncTokens[i]);
 		};
 	};
  

app/Game/Client/GameController.js

@@ -18,7 +18,7 @@ define([
     "Lib/Utilities/Exception"
 ],
 
-function (Parent, Box2D, PhysicsEngine, ViewManager, PlayerController, Nc, requestAnimFrame, Settings, GameObject, Doll, DomController, ProtocolHelper, Me, AudioPlayer, PointerLockManager, Assert, Exception) {
+function (Parent, Box2D, PhysicsEngine, ViewManager, PlayerController, nc, requestAnimFrame, Settings, GameObject, Doll, domController, ProtocolHelper, Me, AudioPlayer, pointerLockManager, Assert, Exception) {
 
 	"use strict";
 
@@ -33,7 +33,7 @@ function (Parent, Box2D, PhysicsEngine, ViewManager, PlayerController, Nc, reque
         Parent.call(this, options);
 
         this.ncTokens = this.ncTokens.concat([
-            Nc.on(Nc.ns.client.game.gameStats.toggle, this.toggleGameStats, this)
+            nc.on(nc.ns.client.game.gameStats.toggle, this.toggleGameStats, this)
         ]);
     }
 
@@ -52,43 +52,34 @@ function (Parent, Box2D, PhysicsEngine, ViewManager, PlayerController, Nc, reque
         
         if(this.me) {
             this.me.update();
-            this.mePositionStateUpdate();
+            this.mePositionStateOverride();
         }
 
-        for (var i = 0; i < this.gameObjects.animated.length; i++) {
-            this.gameObjects.animated[i].render();
-        }
+        nc.trigger(nc.ns.client.game.events.render);
 
         this.view.render();
-        DomController.fpsStep();
+        domController.fpsStep();
     };
 
-    GameController.prototype.mePositionStateUpdate = function() {   
-        if(this.me.isPositionStateUpdateNeeded()) {
-            Nc.trigger(Nc.ns.client.to.server.gameCommand.send, "mePositionStateUpdate", this.me.getPositionStateUpdate());
+    GameController.prototype.mePositionStateOverride = function() {   
+        if(this.me.isPositionStateOverrideNeeded()) {
+            nc.trigger(
+                nc.ns.client.to.server.gameCommand.send, 
+                "mePositionStateOverride", 
+                this.me.getPositionStateOverride()
+            );
         }
     };
 
     GameController.prototype.onClientReadyResponse = function(options) {
         var i;
 
-        if (options.worldUpdate) {
-            this.onWorldUpdate(options.worldUpdate);
-        }
-
         if (options.runtimeItems) {
             for (i = 0; i < options.runtimeItems.length; i++) {
+                
                 var itemDef = options.runtimeItems[i];
 
-                var alreadyExists = false;
-                for (var j = 0; j < this.gameObjects.animated.length; j++) {
-                    if(this.gameObjects.animated[j].uid == itemDef.uid) {
-                        alreadyExists = true;
-                        break;
-                    } 
-                }
-
-                if(!alreadyExists) {
+                if(!this.getItemByUid(itemDef.uid)) {
                     // When creating from synchronization we need to bring it into level format (px)
                     itemDef.options.x *= Settings.RATIO;
                     itemDef.options.y *= Settings.RATIO;
@@ -108,10 +99,21 @@ function (Parent, Box2D, PhysicsEngine, ViewManager, PlayerController, Nc, reque
             }
         }
 
+        if (options.worldUpdate) { // needs to stay after onSpawnPlayer otherwise others doll will not be there
+            this.onWorldUpdate(options.worldUpdate);
+        }
+
         //this.audioPlayer = new AudioPlayer(Settings.AUDIO_PATH + "city.mp3");
         //this.audioPlayer.play();
     };
 
+
+    /*
+
+    TODO : 
+    - remove this 
+    - overwrite setUpdateData inside client / Me with an empty function
+
     GameController.prototype.onWorldUpdateGameObject = function(body, gameObject, update) {
         if(gameObject === this.me.doll) {
             this.me.setLastServerPositionState(update);
@@ -122,6 +124,22 @@ function (Parent, Box2D, PhysicsEngine, ViewManager, PlayerController, Nc, reque
 
         Parent.prototype.onWorldUpdateGameObject.call(this, body, gameObject, update);
     };
+    */
+
+    GameController.prototype.onRemoveGameObject = function(options) {
+
+    };
+
+    GameController.prototype.updateGameObject = function (gameObject, gameObjectUpdate) {
+        if(gameObject === this.me.doll) {
+            this.me.setLastServerPositionState(gameObjectUpdate);
+            if(!this.me.acceptPositionStateUpdateFromServer()) {
+                return; // this is to ignore own doll updates from world update 
+            }
+        } 
+
+        Parent.prototype.updateGameObject.call(this, gameObject, gameObjectUpdate);
+    }
 
     GameController.prototype.createMe = function(user) {
         this.me = new Me(user.id, this.physicsEngine, user);
@@ -129,7 +147,6 @@ function (Parent, Box2D, PhysicsEngine, ViewManager, PlayerController, Nc, reque
     };
 
     GameController.prototype.setMe = function() {
-        this.me.setPlayerController(new PlayerController(this.me));
         this.view.setMe(this.me);
     };
 
@@ -161,15 +178,7 @@ function (Parent, Box2D, PhysicsEngine, ViewManager, PlayerController, Nc, reque
 
     GameController.prototype.onHandActionResponse = function(options) {
         var player = this.players[options.playerId];
-
-        var item = null;
-        for (var i = 0; i < this.gameObjects.animated.length; i++) {
-            var currentItem = this.gameObjects.animated[i];
-            if(currentItem.uid == options.itemUid) {
-                item = currentItem;
-                break;
-            }
-        }
+        var item = this.getItemByUid(options.itemUid);
 
         if(item) {
             if(options.action == "throw") {
@@ -205,7 +214,7 @@ function (Parent, Box2D, PhysicsEngine, ViewManager, PlayerController, Nc, reque
             return 0;
         });
 
-        Nc.trigger(Nc.ns.client.view.gameStats.update, sortedPlayers);
+        nc.trigger(nc.ns.client.view.gameStats.update, sortedPlayers);
     };
 
     GameController.prototype.onPlayerKill = function(options) {
@@ -213,7 +222,7 @@ function (Parent, Box2D, PhysicsEngine, ViewManager, PlayerController, Nc, reque
         var killedByPlayer = this.players[options.killedByPlayerId];
         player.kill(killedByPlayer, options.ragDollId);
 
-        Nc.trigger(Nc.ns.client.view.gameStats.kill, {
+        nc.trigger(nc.ns.client.view.gameStats.kill, {
             victim: {
                 name: player.user.options.nickname,
                 isMe: player === this.me
@@ -230,32 +239,25 @@ function (Parent, Box2D, PhysicsEngine, ViewManager, PlayerController, Nc, reque
         this.me.resetPositionState(options);
     };
 
-    GameController.prototype.onRemoveGameObject = function(options) {
-        var object = null;
-        for (var i = 0; i < this.gameObjects[options.type].length; i++) {
-            if(this.gameObjects[options.type][i].uid == options.uid) {
-                object = this.gameObjects[options.type][i];
-                break;
-            }
-        }
-        if(object) {
-            //this.onGameObjectRemove(options.type, object);
-            object.destroy();
-        } else {
-            console.warn("GameObject for removal can not be found locally. " + options.uid);
-        }
-    };
-
     GameController.prototype.loadLevel = function (path) {
         Parent.prototype.loadLevel.call(this, path);
     };
 
     GameController.prototype.onLevelLoaded = function () {
-        PointerLockManager.update(null, {start:true});
+        pointerLockManager.update(null, {start:true});
     };
 
     GameController.prototype.toggleGameStats = function(show) {
-        Nc.trigger(Nc.ns.client.view.gameStats.toggle, show);
+        nc.trigger(nc.ns.client.view.gameStats.toggle, show);
+    };
+
+    GameController.prototype.beginRound = function() {
+        this.me.setInBetweenRounds(false);
+    };
+
+    GameController.prototype.endRound = function() {
+        this.me.setInBetweenRounds(true);
+        this.toggleGameStats(true);
     };
 
     GameController.prototype.destroy = function() {

app/Game/Client/GameObjects/Doll.js

@@ -7,7 +7,7 @@ define([
     "Game/Client/View/Abstract/Layer",
 ],
  
-function (Parent, Settings, Nc, Exception, ColorConverter, Layer) {
+function (Parent, Settings, nc, Exception, ColorConverter, Layer) {
 
 	"use strict";
  
@@ -50,14 +50,14 @@ function (Parent, Settings, Nc, Exception, ColorConverter, Layer) {
         if(!state) throw new Exception("action state is undefined");
 
         if(this.animatedMeshes[this.actionState]) {
-            Nc.trigger(
-                Nc.ns.client.view.mesh.update,
+            nc.trigger(
+                nc.ns.client.view.mesh.update,
                 this.layerId,
                 this.animatedMeshesContainer.withArms[this.actionState],
                 { visible: false }
             );
-            Nc.trigger(
-                Nc.ns.client.view.mesh.update,
+            nc.trigger(
+                nc.ns.client.view.mesh.update,
                 this.layerId,
                 this.animatedMeshesContainer.withoutArms[this.actionState],
                 { visible: false }
@@ -66,8 +66,8 @@ function (Parent, Settings, Nc, Exception, ColorConverter, Layer) {
 
         Parent.prototype.setActionState.call(this, state);
 
-        Nc.trigger(
-            Nc.ns.client.view.mesh.update,
+        nc.trigger(
+            nc.ns.client.view.mesh.update,
             this.layerId,
             this.animatedMeshes[this.actionState],
             {
@@ -82,7 +82,7 @@ function (Parent, Settings, Nc, Exception, ColorConverter, Layer) {
         var self = this;
 
         var setShirtColor = function (mesh) {
-            Nc.trigger(Nc.ns.client.view.mesh.addFilter, self.layerId, mesh, 'colorRangeReplace', {
+            nc.trigger(nc.ns.client.view.mesh.addFilter, self.layerId, mesh, 'colorRangeReplace', {
                 minColor: 0x3b4a31,
                 maxColor: 0x657f54,
                 newColor: self.primaryColor,
@@ -131,12 +131,12 @@ function (Parent, Settings, Nc, Exception, ColorConverter, Layer) {
 
                 var callback = function(mesh) {
                     self.animatedMeshesContainer[arm][key] = mesh;
-                    Nc.trigger(Nc.ns.client.view.mesh.add, self.layerId, mesh);
+                    nc.trigger(nc.ns.client.view.mesh.add, self.layerId, mesh);
 
                     setShirtColor(mesh);
                 };
 
-                Nc.trigger(Nc.ns.client.view.animatedMesh.create, this.layerId, texturePaths, callback, { 
+                nc.trigger(nc.ns.client.view.animatedMesh.create, this.layerId, texturePaths, callback, { 
                     visible: false, 
                     pivot: {
                         x: 0,
@@ -159,9 +159,9 @@ function (Parent, Settings, Nc, Exception, ColorConverter, Layer) {
         var texturePath = Settings.GRAPHICS_PATH + "Characters/Chuck/head.png";
         var callback = function (mesh) {
             self.headMesh = mesh;
-            Nc.trigger(Nc.ns.client.view.mesh.add, self.layerId, mesh);
+            nc.trigger(nc.ns.client.view.mesh.add, self.layerId, mesh);
         }
-        Nc.trigger(Nc.ns.client.view.mesh.create, this.layerId, texturePath, callback, {
+        nc.trigger(nc.ns.client.view.mesh.create, this.layerId, texturePath, callback, {
             pivot: {
                 x: 5,
                 y: 12
@@ -179,10 +179,10 @@ function (Parent, Settings, Nc, Exception, ColorConverter, Layer) {
         texturePath = Settings.GRAPHICS_PATH + "Characters/Chuck/holdingArm.png";
         var callback = function (mesh) {
             self.holdingArmMesh = mesh;
-            Nc.trigger(Nc.ns.client.view.mesh.add, self.layerId, mesh);
+            nc.trigger(nc.ns.client.view.mesh.add, self.layerId, mesh);
             setShirtColor(mesh);
         }
-        Nc.trigger(Nc.ns.client.view.mesh.create, this.layerId, texturePath, callback, {
+        nc.trigger(nc.ns.client.view.mesh.create, this.layerId, texturePath, callback, {
             visible: false,
             pivot: {
                 //x: 35/2 * 4,
@@ -206,7 +206,7 @@ function (Parent, Settings, Nc, Exception, ColorConverter, Layer) {
 
         if(oldLookDirection != this.lookDirection) {
             for(var key in this.animatedMeshes) {
-                Nc.trigger(Nc.ns.client.view.mesh.update,
+                nc.trigger(nc.ns.client.view.mesh.update,
                     this.layerId,
                     this.animatedMeshes[key],
                     {
@@ -215,7 +215,7 @@ function (Parent, Settings, Nc, Exception, ColorConverter, Layer) {
                 );                   
             }
 
-            Nc.trigger(Nc.ns.client.view.mesh.update,
+            nc.trigger(nc.ns.client.view.mesh.update,
                 this.layerId,
                 this.holdingArmMesh,
                 {
@@ -226,7 +226,7 @@ function (Parent, Settings, Nc, Exception, ColorConverter, Layer) {
 
         var angle = Math.atan2(this.lookAtXY.x, this.lookAtXY.y) / 2 - 0.7855 * this.lookDirection; // 0.7855 = 45°
 
-        Nc.trigger(Nc.ns.client.view.mesh.update,
+        nc.trigger(nc.ns.client.view.mesh.update,
             this.layerId,
             this.headMesh,
             {
@@ -240,22 +240,22 @@ function (Parent, Settings, Nc, Exception, ColorConverter, Layer) {
         Parent.prototype.grab.call(this, item);
         this.animatedMeshes = this.animatedMeshesContainer.withoutArms;
         this.setActionState(this.actionState, true);
-        Nc.trigger(Nc.ns.client.view.mesh.update, this.layerId, this.holdingArmMesh, { visible: true });
+        nc.trigger(nc.ns.client.view.mesh.update, this.layerId, this.holdingArmMesh, { visible: true });
     };
 
     Doll.prototype.throw = function(item, options) {
         Parent.prototype.throw.call(this, item, options);
         this.animatedMeshes = this.animatedMeshesContainer.withArms;
         this.setActionState(this.actionState, true);
-        Nc.trigger(Nc.ns.client.view.mesh.update, this.layerId, this.holdingArmMesh, { visible: false });
+        nc.trigger(nc.ns.client.view.mesh.update, this.layerId, this.holdingArmMesh, { visible: false });
     };
 
     Doll.prototype.destroy = function () {
         for (var key in this.animatedMeshes) {
-            Nc.trigger(Nc.ns.client.view.mesh.remove, this.layerId, this.animatedMeshes[key]);
+            nc.trigger(nc.ns.client.view.mesh.remove, this.layerId, this.animatedMeshes[key]);
         }
 
-        Nc.trigger(Nc.ns.client.view.mesh.remove, this.layerId, this.headMesh);
+        nc.trigger(nc.ns.client.view.mesh.remove, this.layerId, this.headMesh);
 
         Parent.prototype.destroy.call(this);
     }
@@ -272,7 +272,7 @@ function (Parent, Settings, Nc, Exception, ColorConverter, Layer) {
 
             var factor = stepLength / 30;
 
-            Nc.trigger(Nc.ns.client.view.mesh.update,
+            nc.trigger(nc.ns.client.view.mesh.update,
                 this.layerId,
                 this.animatedMeshes[this.actionState],
                 {
@@ -283,7 +283,7 @@ function (Parent, Settings, Nc, Exception, ColorConverter, Layer) {
                 }
             );
 
-            Nc.trigger(Nc.ns.client.view.mesh.update,
+            nc.trigger(nc.ns.client.view.mesh.update,
                 this.layerId,
                 this.headMesh,
                 {
@@ -292,7 +292,7 @@ function (Parent, Settings, Nc, Exception, ColorConverter, Layer) {
                 }
             )
 
-            Nc.trigger(Nc.ns.client.view.mesh.update,
+            nc.trigger(nc.ns.client.view.mesh.update,
                 this.layerId,
                 this.holdingArmMesh,
                 {

app/Game/Client/GameObjects/GameObject.js

@@ -4,7 +4,7 @@ define([
     "Lib/Utilities/NotificationCenter"
 ],
  
-function (Parent, Exception, Nc) {
+function (Parent, Exception, nc) {
 
 	"use strict";
  
@@ -27,7 +27,7 @@ function (Parent, Exception, Nc) {
     GameObject.prototype.createMesh = function() {
     	throw new Exception('Abstract method GameObject.createMesh not overwritten');
     };
- 
+
     return GameObject;
  
 });

app/Game/Client/GameObjects/Item.js

@@ -5,13 +5,17 @@ define([
     "Game/Client/View/Abstract/Layer"
 ],
  
-function (Parent, Settings, Nc, Layer) {
+function (Parent, Settings, nc, Layer) {
 
 	"use strict";
  
     function Item(physicsEngine, uid, options) {
         this.layerId = Layer.ID.ITEM;
     	Parent.call(this, physicsEngine, uid, options);
+
+        this.ncTokens = this.ncTokens.concat([
+            nc.on(nc.ns.client.game.events.render, this.render, this)
+        ]);
     }
 
     Item.prototype = Object.create(Parent.prototype);
@@ -26,10 +30,10 @@ function (Parent, Settings, Nc, Layer) {
 
     	var callback = function(mesh) {
     		self.mesh = mesh;
-            Nc.trigger(Nc.ns.client.view.mesh.add, self.layerId, mesh);
+            nc.trigger(nc.ns.client.view.mesh.add, self.layerId, mesh);
     	}
    
-        Nc.trigger(Nc.ns.client.view.mesh.create,
+        nc.trigger(nc.ns.client.view.mesh.create,
             this.layerId,
             texturePath, 
             callback,
@@ -45,13 +49,13 @@ function (Parent, Settings, Nc, Layer) {
     };
 
     Item.prototype.destroy = function() {
-        Nc.trigger(Nc.ns.client.view.mesh.remove, this.layerId, this.mesh);
+        nc.trigger(nc.ns.client.view.mesh.remove, this.layerId, this.mesh);
         Parent.prototype.destroy.call(this);
     };
 
     Item.prototype.render = function() {
 
-        Nc.trigger(Nc.ns.client.view.mesh.update,
+        nc.trigger(nc.ns.client.view.mesh.update,
             this.layerId,
             this.mesh,
             {
@@ -68,7 +72,7 @@ function (Parent, Settings, Nc, Layer) {
         Parent.prototype.flip.call(this, direction);
 
         if(oldFlipDirection != direction) {
-            Nc.trigger(Nc.ns.client.view.mesh.update,
+            nc.trigger(nc.ns.client.view.mesh.update,
                 this.layerId,
                 this.mesh,
                 {

app/Game/Client/GameObjects/Items/RagDoll.js

@@ -6,7 +6,7 @@ define([
     "Game/Client/View/Abstract/Layer"
 ],
  
-function (Parent, CoreItem, Settings, Nc, Layer) {
+function (Parent, CoreItem, Settings, nc, Layer) {
 
 	"use strict";
  
@@ -40,10 +40,10 @@ function (Parent, CoreItem, Settings, Nc, Layer) {
 				self.limbMeshes[name] = mesh;
     		}
     		
-            Nc.trigger(Nc.ns.client.view.mesh.add, self.layerId, mesh);
+            nc.trigger(nc.ns.client.view.mesh.add, self.layerId, mesh);
     	}
    
-        Nc.trigger(Nc.ns.client.view.mesh.create,
+        nc.trigger(nc.ns.client.view.mesh.create,
             this.layerId,
             texturePath + name + ".png", 
             callback,
@@ -64,7 +64,7 @@ function (Parent, CoreItem, Settings, Nc, Layer) {
     	if(this.limbs) {
 	    	for(var name in this.limbMeshes) {
 	    		if(this.limbs[name]) {
-			        Nc.trigger(Nc.ns.client.view.mesh.update,
+			        nc.trigger(nc.ns.client.view.mesh.update,
                         this.layerId,
 			            this.limbMeshes[name],
 			            {
@@ -85,7 +85,7 @@ function (Parent, CoreItem, Settings, Nc, Layer) {
         CoreItem.prototype.flip.call(this, direction);
 
         if(oldFlipDirection != direction) {
-            Nc.trigger(Nc.ns.client.view.mesh.update,
+            nc.trigger(nc.ns.client.view.mesh.update,
                 this.layerId,
                 this.mesh,
                 {
@@ -94,7 +94,7 @@ function (Parent, CoreItem, Settings, Nc, Layer) {
             );
 
             for (var name in this.limbMeshes) {
-            	Nc.trigger(Nc.ns.client.view.mesh.update,
+            	nc.trigger(nc.ns.client.view.mesh.update,
                     this.layerId,
 	                this.limbMeshes[name],
 	                {
@@ -108,7 +108,7 @@ function (Parent, CoreItem, Settings, Nc, Layer) {
     RagDoll.prototype.destroy = function() {
         
         for (var name in this.limbMeshes) {
-            Nc.trigger(Nc.ns.client.view.mesh.remove, this.layerId, this.limbMeshes[name]);
+            nc.trigger(nc.ns.client.view.mesh.remove, this.layerId, this.limbMeshes[name]);
         };
 
         Parent.prototype.destroy.call(this);

app/Game/Client/GameObjects/Items/Rube.js

@@ -1,28 +0,0 @@
-define([
-	"Game/Core/GameObjects/Items/Rube"
-],
- 
-function (Parent) {
-
-	"use strict";
- 
-    function Rube(physicsEngine, uid, options) {
-    	Parent.call(this, physicsEngine, uid, options);
-    }
-
-    Rube.prototype = Object.create(Parent.prototype);
- 
-    Rube.prototype.createMesh = function() {
-    };
-
-    Rube.prototype.destroy = function() {
-    };
-
-    Rube.prototype.render = function() {
-    }
-
-    Rube.prototype.flip = function(direction) {
-    };
-
-    return Rube;
-});

app/Game/Client/GameObjects/Items/RubeDoll.js

@@ -0,0 +1,254 @@
+define([
+	"Game/Core/GameObjects/Items/RubeDoll",
+    "Game/Client/View/Abstract/Layer",
+    "Game/Config/Settings",
+    "Lib/Utilities/NotificationCenter",
+],
+ 
+function (Parent, Layer, Settings, nc) {
+
+	"use strict";
+ 
+    function RubeDoll(physicsEngine, uid, options) {
+
+        this.primaryColor = options.primaryColor;
+
+        var limbOptions = {};
+
+        limbOptions.chest = {
+            width: 6,
+            height: 18,
+            x: 0,
+            y: 0
+        };
+
+        limbOptions.head = {
+            width: 10,
+            height: 12,
+            x: 0,
+            y: - limbOptions.chest.height / 2 - 7
+        };
+
+        limbOptions.upperLeftLeg = {
+            width: 5,
+            height: 8,
+            x: -2,
+            y: limbOptions.chest.height / 2
+        };
+
+        limbOptions.upperRightLeg = {
+            width: 5,
+            height: 8,
+            x: 2,
+            y: limbOptions.chest.height / 2
+        };
+
+        limbOptions.lowerLeftLeg = {
+            width: 5,
+            height: 4,
+            x: -2,
+            y: limbOptions.chest.height / 2 + limbOptions.upperLeftLeg.height
+        };
+
+        limbOptions.lowerRightLeg = {
+            width: 5,
+            height: 4,
+            x: 2,
+            y: limbOptions.chest.height / 2 + limbOptions.upperRightLeg.height
+        };
+
+
+
+        limbOptions.upperLeftArm = {
+            width: 4,
+            height: 8,
+            x: -2,
+            y: -limbOptions.chest.height / 2
+        };
+
+        limbOptions.upperRightArm = {
+            width: 4,
+            height: 8,
+            x: 2,
+            y: -limbOptions.chest.height / 2
+        };
+
+        limbOptions.lowerLeftArm = {
+            width: 4,
+            height: 5,
+            x: -2,
+            y: -limbOptions.chest.height / 2 + limbOptions.upperLeftArm.height
+        };
+
+        limbOptions.lowerRightArm = {
+            width: 4,
+            height: 5,
+            x: 2,
+            y: -limbOptions.chest.height / 2 + limbOptions.upperRightArm.height
+        };
+
+        this.limbOptions = limbOptions;
+
+        this.layerId = Layer.ID.SPAWN;
+        this.limbMeshes = {};
+        this.baseMeshName = "chest";
+        this.characterName = "Chuck";
+        this.lastFlipDirection = -options.direction || 1;
+
+        Parent.call(this, physicsEngine, uid, options);
+    }
+
+    RubeDoll.prototype = Object.create(Parent.prototype);
+ 
+    RubeDoll.prototype.createMesh = function() {
+
+        this.createLimbMesh("lowerRightLeg");
+        this.createLimbMesh("upperRightLeg");
+        this.createLimbMesh("lowerRightArm");
+        this.createLimbMesh("upperRightArm");
+
+        this.createLimbMesh("chest");
+        this.createLimbMesh("head");
+
+        this.createLimbMesh("lowerLeftLeg");
+        this.createLimbMesh("upperLeftLeg");
+        this.createLimbMesh("lowerLeftArm");
+        this.createLimbMesh("upperLeftArm");
+
+    };
+
+    RubeDoll.prototype.createLimbMesh = function(name) {
+        var self = this;
+        var texturePath = Settings.GRAPHICS_PATH 
+            + Settings.GRAPHICS_SUBPATH_CHARACTERS + ""
+            + this.characterName + '/';
+
+
+        var callback = function(mesh) {
+            if(name == self.baseMeshName) {
+                self.mesh = mesh;
+            } 
+        
+            self.limbMeshes[name] = mesh;
+                
+            nc.trigger(nc.ns.client.view.mesh.add, self.layerId, mesh);
+
+            // setting shirt color
+            nc.trigger(nc.ns.client.view.mesh.addFilter, self.layerId, mesh, "colorRangeReplace", {
+                minColor: 0x3b4a31,
+                maxColor: 0x6d855d,
+                newColor: self.primaryColor,
+                brightnessOffset: 0.56
+            });
+        };
+   
+        nc.trigger(nc.ns.client.view.mesh.create,
+            this.layerId,
+            texturePath + name + ".png", 
+            callback,
+            {
+                width: this.limbOptions[name].width, 
+                height: this.limbOptions[name].height,
+                pivot: {
+                    x: this.limbOptions[name].width / 2,
+                    y: this.limbOptions[name].height / 2
+                }
+            }
+        );
+    };
+
+    RubeDoll.prototype.destroy = function() {
+        
+        for (var name in this.limbMeshes) {
+            nc.trigger(nc.ns.client.view.mesh.remove, this.layerId, this.limbMeshes[name]);
+        };
+
+        Parent.prototype.destroy.call(this);
+    };
+
+    RubeDoll.prototype.render = function() {
+        //Parent.prototype.render.call(this);
+
+        nc.trigger(nc.ns.client.view.mesh.update,
+            this.layerId,
+            this.mesh,
+            {
+                x: this.body.GetPosition().x * Settings.RATIO,
+                y: this.body.GetPosition().y * Settings.RATIO,
+                rotation: this.body.GetAngle()
+            }
+        );
+
+        if(this.limbs) {
+            for(var name in this.limbMeshes) {
+                if(this.limbs[name]) {
+                    nc.trigger(nc.ns.client.view.mesh.update,
+                        this.layerId,
+                        this.limbMeshes[name],
+                        {
+                            x: this.limbs[name].GetPosition().x * Settings.RATIO,
+                            y: this.limbs[name].GetPosition().y * Settings.RATIO,
+                            rotation: this.limbs[name].GetAngle()
+                        }
+                    );
+                }
+            }
+        }
+    };
+
+    RubeDoll.prototype.flip = function(direction) {
+        
+        Parent.prototype.flip.call(this, direction);
+
+        // flipping depth of right body side arm/leg images with left
+        if (this.lastFlipDirection != direction) { // FIXME : this is a bit broken.
+
+            this.lastFlipDirection = direction;
+
+            nc.trigger(nc.ns.client.view.mesh.swapMeshIndexes,
+                this.layerId,
+                this.limbMeshes["lowerRightLeg"], 
+                this.limbMeshes["lowerLeftLeg"]
+            );
+            nc.trigger(nc.ns.client.view.mesh.swapMeshIndexes,
+                this.layerId,
+                this.limbMeshes["upperRightLeg"], 
+                this.limbMeshes["upperLeftLeg"]
+            );
+            nc.trigger(nc.ns.client.view.mesh.swapMeshIndexes,
+                this.layerId,
+                this.limbMeshes["lowerRightArm"], 
+                this.limbMeshes["lowerLeftArm"]
+            );
+            nc.trigger(nc.ns.client.view.mesh.swapMeshIndexes,
+                this.layerId,
+                this.limbMeshes["upperRightArm"], 
+                this.limbMeshes["upperLeftArm"]
+            );
+
+            // swap short images
+            nc.trigger(nc.ns.client.view.mesh.swapMeshes,
+                this.layerId,
+                this.limbMeshes["upperRightLeg"],
+                this.limbMeshes["upperLeftLeg"]
+            );
+        }
+
+        // x flipping has to happen after (see swapMeshes)
+        if(this.limbs) {
+            for(var name in this.limbMeshes) {
+                if(this.limbs[name]) {
+                    nc.trigger(nc.ns.client.view.mesh.update,
+                        this.layerId,
+                        this.limbMeshes[name],
+                        {
+                            xScale: direction,
+                        }
+                    );
+                }
+            }
+        }
+    };
+
+    return RubeDoll;
+});

app/Game/Client/GameObjects/Tile.js

@@ -5,7 +5,7 @@ define([
     "Game/Client/View/Abstract/Layer"
 ],
  
-function (Parent, Settings, Nc, Layer) {
+function (Parent, Settings, nc, Layer) {
 
 	"use strict";
  
@@ -31,10 +31,10 @@ function (Parent, Settings, Nc, Layer) {
 
     	var callback = function(mesh) {
     		self.mesh = mesh;
-            Nc.trigger(Nc.ns.client.view.mesh.add, self.layerId, mesh);
+            nc.trigger(nc.ns.client.view.mesh.add, self.layerId, mesh);
     	}
    
-        Nc.trigger(Nc.ns.client.view.mesh.create,
+        nc.trigger(nc.ns.client.view.mesh.create,
             this.layerId,
             texturePath, 
             callback,
@@ -50,13 +50,13 @@ function (Parent, Settings, Nc, Layer) {
     };
 
     Tile.prototype.destroy = function() {
-        Nc.trigger(Nc.ns.client.view.mesh.remove, this.layerId, this.mesh);
+        nc.trigger(nc.ns.client.view.mesh.remove, this.layerId, this.mesh);
         Parent.prototype.destroy.call(this);
     };
 
     Tile.prototype.render = function() {
 
-        Nc.trigger(Nc.ns.client.view.mesh.update,
+        nc.trigger(nc.ns.client.view.mesh.update,
             this.layerId,
             this.mesh,
             {

app/Game/Client/Loader/Level.js

@@ -6,7 +6,7 @@ define([
     "Game/Client/View/Abstract/Layer"
 ],
 
-function (Parent, Settings, Nc, PIXI, AbstractLayer) {
+function (Parent, Settings, nc, PIXI, AbstractLayer) {
 
 	"use strict";
 
@@ -46,7 +46,7 @@ function (Parent, Settings, Nc, PIXI, AbstractLayer) {
         loader.onComplete = function() { callback(levelData); };
         loader.onProgress = function() { 
             var progress = parseInt(100 / numPaths * ++count, 10) + 1;
-            Nc.trigger(Nc.ns.client.view.preloadBar.update, progress);
+            nc.trigger(nc.ns.client.view.preloadBar.update, progress);
         }
         loader.load();
     };
@@ -116,8 +116,8 @@ function (Parent, Settings, Nc, PIXI, AbstractLayer) {
         if (options.properties && options.properties.parallaxSpeed) {
             parallaxSpeed = parseFloat(options.properties.parallaxSpeed);
         } 
-        Nc.trigger(
-            Nc.ns.client.view.layer.createAndInsert,
+        nc.trigger(
+            nc.ns.client.view.layer.createAndInsert,
             options.layerId,
             {
                 parallaxSpeed: parallaxSpeed,

app/Game/Client/Loader/TiledLevel.js

@@ -4,13 +4,13 @@ define([
     "Lib/Utilities/NotificationCenter",
 ],
  
-function (Parent, Settings, Nc) {
+function (Parent, Settings, nc) {
 
 	"use strict";
  
-    function TiledLevel(uid, engine, gameObjects) {
+    function TiledLevel(uid, engine) {
         this.layerId = "background";
-    	Parent.call(this, uid, engine, gameObjects);
+    	Parent.call(this, uid, engine);
     }
 
     TiledLevel.prototype = Object.create(Parent.prototype);
@@ -22,7 +22,7 @@ function (Parent, Settings, Nc) {
             height: tilesLayerData.height * Settings.TILE_SIZE
         };
 
-        Nc.trigger(Nc.ns.client.view.layer.levelSizeUpdate, this.levelSize);
+        nc.trigger(nc.ns.client.view.layer.levelSizeUpdate, this.levelSize);
 
         Parent.prototype.setup.call(this, levelData);
     };
@@ -78,8 +78,8 @@ function (Parent, Settings, Nc) {
             var texturePath = Settings.MAPS_PATH + options.image;
 
             var callback = function(mesh) {
-                Nc.trigger(Nc.ns.client.view.mesh.add, options.layerId, mesh);
-                Nc.trigger(Nc.ns.client.view.mesh.update, options.layerId, mesh, {
+                nc.trigger(nc.ns.client.view.mesh.add, options.layerId, mesh);
+                nc.trigger(nc.ns.client.view.mesh.update, options.layerId, mesh, {
                     x: 0,//self.levelData.width * Settings.TILE_SIZE / 2,
                     y: 0,//self.levelData.height * Settings.TILE_SIZE / 2,
                     pivot: {
@@ -91,7 +91,7 @@ function (Parent, Settings, Nc) {
                 });
             }
        
-            Nc.trigger(Nc.ns.client.view.mesh.create,
+            nc.trigger(nc.ns.client.view.mesh.create,
                 options.layerId,
                 texturePath, 
                 callback,
@@ -123,10 +123,10 @@ function (Parent, Settings, Nc) {
             var tileType = parts[parts.length - 1].split(".")[0].split("")
 
             var callback = function(mesh) {
-                Nc.trigger(Nc.ns.client.view.mesh.add, options.layerId, mesh);
+                nc.trigger(nc.ns.client.view.mesh.add, options.layerId, mesh);
             }
        
-            Nc.trigger(Nc.ns.client.view.mesh.create,
+            nc.trigger(nc.ns.client.view.mesh.create,
                 options.layerId,
                 Settings.MAPS_PATH + imagePath,
                 callback,

app/Game/Client/Me.js

@@ -2,10 +2,11 @@ define([
 	"Game/Client/Player",
 	"Game/Config/Settings",
     "Lib/Utilities/NotificationCenter",
-    "Lib/Utilities/Assert"
+    "Lib/Utilities/Assert",
+    "Game/Client/Control/PlayerController",
 ],
  
-function (Parent, Settings, Nc, Assert) {
+function (Parent, Settings, nc, Assert, PlayerController) {
 
 	"use strict";
  
@@ -27,6 +28,7 @@ function (Parent, Settings, Nc, Assert) {
 
         this.arrowMesh = null;
         this.createAndAddArrow();
+        this.playerController = new PlayerController(this);
     }
 
     Me.prototype = Object.create(Parent.prototype);
@@ -51,7 +53,8 @@ function (Parent, Settings, Nc, Assert) {
     	this.lastServerPositionState = update;
     };
 
-	Me.prototype.isPositionStateUpdateNeeded = function() {
+    // Checks if client should send out its position to server
+	Me.prototype.isPositionStateOverrideNeeded = function() {
 
 		if(!this.doll) {
             return false;
@@ -73,7 +76,7 @@ function (Parent, Settings, Nc, Assert) {
     	return false;
     };
 
-    Me.prototype.getPositionStateUpdate = function() {
+    Me.prototype.getPositionStateOverride = function() {
     	return {
     		p: this.doll.body.GetPosition().Copy(),
     		lv: this.doll.body.GetLinearVelocity().Copy()
@@ -105,7 +108,7 @@ function (Parent, Settings, Nc, Assert) {
         var callback = function(arrowMesh) {
             self.arrowMesh = arrowMesh;
         };
-        Nc.trigger(Nc.ns.client.view.playerArrow.createAndAdd, callback, options);
+        nc.trigger(nc.ns.client.view.playerArrow.createAndAdd, callback, options);
     };
 
     Me.prototype.render = function() {
@@ -117,7 +120,7 @@ function (Parent, Settings, Nc, Assert) {
             x: position.x * Settings.RATIO,
             y: position.y * Settings.RATIO,
         };
-        Nc.trigger(Nc.ns.client.view.playerArrow.update, this.arrowMesh, options);
+        nc.trigger(nc.ns.client.view.playerArrow.update, this.arrowMesh, options);
     };
 
     return Me;

app/Game/Client/Networker.js

@@ -7,7 +7,7 @@ define([
     "Game/Client/View/DomController"
 ], 
 
-function (ProtocolHelper, GameController, User, Nc, Settings, DomController) {
+function (ProtocolHelper, GameController, User, nc, Settings, domController) {
 
 	"use strict";
 
@@ -25,20 +25,32 @@ function (ProtocolHelper, GameController, User, Nc, Settings, DomController) {
         var self = this;
         this.socketLink.on('message', function (message) {
             var m = JSON.parse(message)
-            if(Settings.NETWORK_LOG_INCOMING) {
 
-                if (message.indexOf('worldUpdate') == -1 && message.indexOf('pong') == -1) {
+            if(Settings.NETWORK_LOG_INCOMING) {
+                var shouldBeFiltered = false;
+                var keyword;
+
+                for (var i = 0; i < Settings.NETWORK_LOG_FILTER.length; i++) {
+                    keyword = Settings.NETWORK_LOG_FILTER[i];
+                    if(message.search(keyword) != -1) {
+                        shouldBeFiltered = true;
+                        break;
+                    }
+                };
+
+                if(!shouldBeFiltered) {
                     console.log('INCOMING', message);
                 }
-                
             }
+
+            
             ProtocolHelper.applyCommand(message, self);
         });
 
-        Nc.on(Nc.ns.client.to.server.gameCommand.send, this.sendGameCommand, this);
-        Nc.on(Nc.ns.core.game.events.level.loaded, this.onLevelLoaded, this);
+        nc.on(nc.ns.client.to.server.gameCommand.send, this.sendGameCommand, this);
+        nc.on(nc.ns.core.game.events.level.loaded, this.onLevelLoaded, this);
 
-        DomController.setNick(nickname);
+        domController.setNick(nickname);
     }
 
     // Socket callbacks
@@ -51,7 +63,7 @@ function (ProtocolHelper, GameController, User, Nc, Settings, DomController) {
                 nickname: this.nickname
             }
             this.sendCommand('join', options);
-            DomController.setConnected(true);
+            domController.setConnected(true);
         } else {
             alert("Error: no channel name");
             window.location.href = "/";
@@ -62,7 +74,7 @@ function (ProtocolHelper, GameController, User, Nc, Settings, DomController) {
         //if(this.gameController) this.gameController.destruct();
         //this.gameController = null;
         console.log('disconnected. game destroyed. no auto-reconnect');
-        DomController.setConnected(false);
+        domController.setConnected(false);
     }
 
     Networker.prototype.onJoinSuccess = function (options) {
@@ -117,23 +129,18 @@ function (ProtocolHelper, GameController, User, Nc, Settings, DomController) {
         this.socketLink.send(message);
 
         if(Settings.NETWORK_LOG_OUTGOING) {
-            if(Settings.NETWORK_LOG_FILTER.length > 0) {
+            var shouldBeFiltered = false;
+            var keyword;
 
-                var shouldBeFiltered = false;
-                var keyword;
-
-                for (var i = 0; i < Settings.NETWORK_LOG_FILTER.length; i++) {
-                    keyword = Settings.NETWORK_LOG_FILTER[i];
-                    if(message.search(keyword) != -1) {
-                        shouldBeFiltered = true;
-                        break;
-                    }
-                };
-
-                if(!shouldBeFiltered) {
-                    console.log('OUTGOING', message);
+            for (var i = 0; i < Settings.NETWORK_LOG_FILTER.length; i++) {
+                keyword = Settings.NETWORK_LOG_FILTER[i];
+                if(message.search(keyword) != -1) {
+                    shouldBeFiltered = true;
+                    break;
                 }
-            } else {
+            };
+
+            if(!shouldBeFiltered) {
                 console.log('OUTGOING', message);
             }
         }
@@ -176,7 +183,7 @@ function (ProtocolHelper, GameController, User, Nc, Settings, DomController) {
 
     Networker.prototype.onPong = function(timestamp) {
         var ping = (Date.now() - parseInt(timestamp, 10));
-        DomController.setPing(ping);
+        domController.setPing(ping);
         setTimeout(this.ping.bind(this), 1000);
     };
 
@@ -184,7 +191,6 @@ function (ProtocolHelper, GameController, User, Nc, Settings, DomController) {
 
         if(this.gameController) {
             this.gameController.destroy();
-            delete this.gameController;
         }
 
         this.gameController = new GameController(options);
@@ -196,10 +202,12 @@ function (ProtocolHelper, GameController, User, Nc, Settings, DomController) {
                 this.gameController.createPlayer(this.users[userId]);
             }            
         }
+
+        this.gameController.beginRound();
     };
 
     Networker.prototype.onEndRound = function() {
-        this.gameController.toggleGameStats(true);
+        this.gameController.endRound();
     };
 
     return Networker;

app/Game/Client/Physics/Engine.js

@@ -8,7 +8,7 @@ define([
     "Game/Client/View/Pixi/Layers/Debug"
 ],
 
-function (Parent, Settings, DomController, Box2D, Nc, DebugDraw, debugLayer) {
+function (Parent, Settings, domController, Box2D, nc, DebugDraw, debugLayer) {
 
 	"use strict";
 
@@ -17,7 +17,7 @@ function (Parent, Settings, DomController, Box2D, Nc, DebugDraw, debugLayer) {
 
         this.debugMode = false;
 
-        Nc.on(Nc.ns.client.view.debugMode.toggle, this.onToggleDebugMode, this);
+        nc.on(nc.ns.client.view.debugMode.toggle, this.onToggleDebugMode, this);
     }
 
     Engine.prototype = Object.create(Parent.prototype);

app/Game/Client/Player.js

@@ -4,17 +4,21 @@ define([
 	"Game/Config/Settings"
 ],
  
-function (Parent, Nc, Settings) {
+function (Parent, nc, Settings) {
 
 	"use strict";
  
-    function Player(id, physicsEngine, user) {
+    function Player(id, physicsEngine, user, isMe) {
     	Parent.call(this, id, physicsEngine, user);
 
     	this.healthBarView = null;
     	this.healthBarViewVisibleTimeout = null;
     	this.healthBarViewVisible = false;
     	this.initHealthBar();
+
+        this.ncTokens = (this.ncTokens || []).concat([
+            nc.on(nc.ns.client.game.events.render, this.render, this)
+        ]);
     }
 
     Player.prototype = Object.create(Parent.prototype);
@@ -43,7 +47,7 @@ function (Parent, Nc, Settings) {
     	var callback = function(healthBarView) {
     		self.healthBarView = healthBarView;
     	}
-    	Nc.trigger(Nc.ns.client.view.healthBar.createAndAdd, callback, options);
+    	nc.trigger(nc.ns.client.view.healthBar.createAndAdd, callback, options);
     };
 
     Player.prototype.onHealthChange = function() {
@@ -71,22 +75,18 @@ function (Parent, Nc, Settings) {
 	    		healthFactor: this.stats.health / 100,
 	    		visible: this.healthBarViewVisible
 	    	};
-	    	Nc.trigger(Nc.ns.client.view.healthBar.update, this.healthBarView, options);
+	    	nc.trigger(nc.ns.client.view.healthBar.update, this.healthBarView, options);
 
 	    	this.healthBarViewVisibleTimeout = setTimeout(function() {
 	    		self.healthBarViewVisible = false;
-	    		Nc.trigger(Nc.ns.client.view.healthBar.update, self.healthBarView, {visible: self.healthBarViewVisible});
+	    		nc.trigger(nc.ns.client.view.healthBar.update, self.healthBarView, {visible: self.healthBarViewVisible});
 	    	}, Settings.HEALTH_DISPLAY_TIME * 1000);
 
     	} else {
-    		Nc.trigger(Nc.ns.client.view.healthBar.update, this.healthBarView, {visible: this.healthBarViewVisible});
+    		nc.trigger(nc.ns.client.view.healthBar.update, this.healthBarView, {visible: this.healthBarViewVisible});
     	}
     };
 
-    Player.prototype.getNickname = function() {
-        return this.user.options.nickname;
-    };
-
     Player.prototype.render = function() {
 
         if(this.doll) {
@@ -100,7 +100,7 @@ function (Parent, Nc, Settings) {
 				x: position.x * Settings.RATIO,
 	    		y: position.y * Settings.RATIO,
 	    	}
-	    	Nc.trigger(Nc.ns.client.view.healthBar.update, this.healthBarView, options);
+	    	nc.trigger(nc.ns.client.view.healthBar.update, this.healthBarView, options);
     	}
     };
 
@@ -110,7 +110,8 @@ function (Parent, Nc, Settings) {
 
     Player.prototype.destroy = function() {
         clearTimeout(this.healthBarViewVisibleTimeout);
-    	Nc.trigger(Nc.ns.client.view.healthBar.remove, this.healthBarView);
+    	nc.trigger(nc.ns.client.view.healthBar.remove, this.healthBarView);
+        nc.off(this.ncTokens);
         Parent.prototype.destroy.call(this);
     };
  

app/Game/Client/PointerLockManager.js

@@ -3,12 +3,12 @@ define([
     "Lib/Utilities/NotificationCenter"
 ], 
 
-function (Qs, Nc) {
+function (qs, nc) {
 
     "use strict";
  
     function PointerLockManager() {
-        this.canvas = Qs.$("#canvas");
+        this.canvas = qs.$("#canvas");
 
         this.listeners = [];
 
@@ -21,7 +21,7 @@ function (Qs, Nc) {
     	document.addEventListener('webkitpointerlockchange', this.update.bind(this), false);
 
         this.ncTokens = [
-            Nc.on(Nc.ns.client.pointerLock.request, this.request, this)
+            nc.on(nc.ns.client.pointerLock.request, this.request, this)
         ];
     }
  
@@ -40,7 +40,7 @@ function (Qs, Nc) {
     // called by the browser event and others
     PointerLockManager.prototype.update = function(e, options) {
         options = options ? options : {};
-        Nc.trigger(Nc.ns.client.pointerLock.change, this.isLocked(), options);
+        nc.trigger(nc.ns.client.pointerLock.change, this.isLocked(), options);
     };
 
     PointerLockManager.prototype.isLocked = function() {

app/Game/Client/View/Abstract/Layer.js

@@ -3,7 +3,7 @@ define([
     "Lib/Utilities/NotificationCenter"
 ], 
 
-function (Abstract, Nc) {
+function (Abstract, nc) {
 
 	"use strict";
 
@@ -59,7 +59,7 @@ function (Abstract, Nc) {
 
     Layer.prototype.destroy = function() {
         for (var i = 0; i < this.ncTokens.length; i++) {
-            Nc.off(this.ncTokens[i]);
+            nc.off(this.ncTokens[i]);
         };
     };
 

app/Game/Client/View/Abstract/View.js

@@ -6,7 +6,7 @@ define([
     "Lib/Utilities/NotificationCenter"
 ],
 
-function (Abstract, DomController, Settings, Exception, Nc) {
+function (Abstract, domController, Settings, Exception, nc) {
 
 	"use strict";
     
@@ -16,14 +16,14 @@ function (Abstract, DomController, Settings, Exception, Nc) {
         this.debugMode = false;
 
         this.ncTokens = [
-            Nc.on(Nc.ns.client.view.display.change, this.onDisplaySizeChange, this),
-            Nc.on(Nc.ns.client.view.debugMode.toggle, this.onToggleDebugMode, this),
+            nc.on(nc.ns.client.view.display.change, this.onDisplaySizeChange, this),
+            nc.on(nc.ns.client.view.debugMode.toggle, this.onToggleDebugMode, this),
 
-            Nc.on(Nc.ns.client.game.zoomIn, this.onZoomIn, this),
-            Nc.on(Nc.ns.client.game.zoomOut, this.onZoomOut, this),
-            Nc.on(Nc.ns.client.game.zoomReset, this.onZoomReset, this),
+            nc.on(nc.ns.client.game.zoomIn, this.onZoomIn, this),
+            nc.on(nc.ns.client.game.zoomOut, this.onZoomOut, this),
+            nc.on(nc.ns.client.game.zoomReset, this.onZoomReset, this),
 
-            Nc.on(Nc.ns.client.view.preloadBar.update, this.onUpdateLoader, this),
+            nc.on(nc.ns.client.view.preloadBar.update, this.onUpdateLoader, this),
         ];
     }
 
@@ -47,7 +47,7 @@ function (Abstract, DomController, Settings, Exception, Nc) {
 
     AbstractView.prototype.initCanvas = function (canvas) {
     	this.canvas = canvas;
-        DomController.initCanvas(canvas);
+        domController.initCanvas(canvas);
     }
 
     AbstractView.prototype.setMe = function(player) {
@@ -98,7 +98,7 @@ function (Abstract, DomController, Settings, Exception, Nc) {
 
     AbstractView.prototype.destroy = function() {
         for (var i = 0; i < this.ncTokens.length; i++) {
-            Nc.off(this.ncTokens[i]);
+            nc.off(this.ncTokens[i]);
         };
     };
 

app/Game/Client/View/DomController.js

@@ -6,7 +6,7 @@ define([
     "Game/Client/PointerLockManager"
 ], 
 
-function (Settings, Nc, Screenfull, Graph, PointerLockManager) {
+function (Settings, nc, Screenfull, Graph, pointerLockManager) {
 
 	"use strict";
 
@@ -15,18 +15,19 @@ function (Settings, Nc, Screenfull, Graph, PointerLockManager) {
         this.stats = null;
         this.ping = null;
         this.nickContainer = null;
-        this.fpsContainer = "";
+        this.fpsContainer = null;
         this.devToolsContainer = null;
+        this.frames = 0;
+
+        this.canvas = document.getElementById("canvas");
 
         this.initDevTools();
     }
 
     DomController.prototype.initDevTools = function() {
-
         var self = this;
         var li, button, label;
 
-        this.canvas = document.getElementById("canvas");
         this.devToolsContainer = document.getElementById("menuBar");
 
         // create back to menu button
@@ -48,6 +49,16 @@ function (Settings, Nc, Screenfull, Graph, PointerLockManager) {
         this.devToolsContainer.appendChild(li);
         this.nickContainer = label;
 
+
+        // create fps label with updater
+        li = document.createElement("li");
+        label = document.createElement("label");
+        label.id = "label-fps";
+        li.appendChild(label);
+        this.devToolsContainer.appendChild(li);
+        this.fpsContainer = label;
+
+/*
         // create new fps meter
         li = document.createElement("li");
         var fpsCanvas = document.createElement("canvas");
@@ -59,14 +70,6 @@ function (Settings, Nc, Screenfull, Graph, PointerLockManager) {
 
         this.fpsGraph = new Graph(fpsCanvas.getContext("2d"), true);
 
-        // create fps label with updater
-        li = document.createElement("li");
-        label = document.createElement("label");
-        label.id = "label-fps";
-        li.appendChild(label);
-        this.devToolsContainer.appendChild(li);
-        this.fpsContainer = label;
-
         this.fpsGraph.onUpdate(function(value){
             self.fpsContainer.innerHTML = "FPS:" + value;
 
@@ -99,6 +102,12 @@ function (Settings, Nc, Screenfull, Graph, PointerLockManager) {
             scaleStepWidth: 0, 
             scaleSteps: 0
         });
+*/
+
+        setInterval(function() {
+            self.fpsContainer.innerHTML = "FPS:" + self.frames;
+            self.frames = 0;
+        }, 1000);
 
         // create Ping: container
         li = document.createElement("li");
@@ -113,7 +122,7 @@ function (Settings, Nc, Screenfull, Graph, PointerLockManager) {
         var checkbox = document.createElement("input");
         checkbox.type = "checkbox";
         checkbox.onclick = function(e) {
-            Nc.trigger(Nc.ns.client.view.debugMode.toggle, e.target.checked);
+            nc.trigger(nc.ns.client.view.debugMode.toggle, e.target.checked);
         };
         label.appendChild(checkbox);
         label.appendChild(document.createTextNode("Debug"));
@@ -128,7 +137,7 @@ function (Settings, Nc, Screenfull, Graph, PointerLockManager) {
         button.innerHTML = "Fullscreen";
         button.onclick = function() {
             if(Screenfull.enabled) {
-                PointerLockManager.request();
+                pointerLockManager.request();
                 Screenfull.request(self.canvas);
             }
         };
@@ -138,7 +147,7 @@ function (Settings, Nc, Screenfull, Graph, PointerLockManager) {
 
         // FIXME : isn't this a weird place for this?
         window.onresize = function() {
-            Nc.trigger(Nc.ns.client.view.display.change);
+            nc.trigger(nc.ns.client.view.display.change);
         };
     };
 
@@ -147,12 +156,13 @@ function (Settings, Nc, Screenfull, Graph, PointerLockManager) {
     };
 
     DomController.prototype.fpsStep = function() {
-        this.fpsGraph.step();
+        this.frames++;
+        // this.fpsGraph.step();
     };
 
     DomController.prototype.setPing = function(ping) {
         this.ping.innerHTML = "Ping:" + ping;
-        this.pingGraph.addValue(ping);
+        // this.pingGraph.addValue(ping);
     };
 
     DomController.prototype.getCanvasContainer = function () {
@@ -170,7 +180,7 @@ function (Settings, Nc, Screenfull, Graph, PointerLockManager) {
     };
 
     DomController.prototype.initCanvas = function (canvas) {
-        Nc.trigger(Nc.ns.client.view.display.change, Screenfull.isFullscreen);
+        nc.trigger(nc.ns.client.view.display.change, Screenfull.isFullscreen);
     };
 
     DomController.prototype.setConnected = function(connected) {
@@ -180,13 +190,14 @@ function (Settings, Nc, Screenfull, Graph, PointerLockManager) {
             document.body.style.backgroundColor = '#aaaaaa';
             this.ping.innerHTML = "Disconnected. ".replace(/ /g, ' ');
             this.ping.style.color = "#ff0000";
-
+            /*
             self = this;
             setTimeout(function(){self.ping.innerHTML = "Reload Page...".replace(/ /g, ' ');}, 3000);
             setTimeout(function(){self.ping.innerHTML = "Reload in 3...".replace(/ /g, ' ');}, 6000);
             setTimeout(function(){self.ping.innerHTML = "Reload in 2...".replace(/ /g, ' ');}, 7000);
             setTimeout(function(){self.ping.innerHTML = "Reload in 1...".replace(/ /g, ' ');}, 8000);
             setTimeout(function(){self.ping.innerHTML = "Reload now.   ".replace(/ /g, ' '); location.reload(); }, 9000);
+            */
         }
     };
 

app/Game/Client/View/LayerManager.js

@@ -4,7 +4,7 @@ define([
     "Game/Client/View/Pixi/Layer"
 ],
  
-function (Nc, Exception, Layer) {
+function (nc, Exception, Layer) {
 
 	"use strict";
  
@@ -13,14 +13,16 @@ function (Nc, Exception, Layer) {
         this.container = container;
 
         this.ncTokens = [
-            Nc.on(Nc.ns.client.view.layer.createAndInsert, this.createAndInsert, this),
-            Nc.on(Nc.ns.client.view.mesh.create, this.createMesh, this),
-            Nc.on(Nc.ns.client.view.animatedMesh.create, this.createAnimatedMesh, this),
-            Nc.on(Nc.ns.client.view.mesh.add, this.addMesh, this),
-            Nc.on(Nc.ns.client.view.mesh.remove, this.removeMesh, this),
-            Nc.on(Nc.ns.client.view.mesh.update, this.updateMesh, this),
-            Nc.on(Nc.ns.client.view.mesh.addFilter, this.addFilter, this),
-            Nc.on(Nc.ns.client.view.mesh.removeFilter, this.removeFilter, this)
+            nc.on(nc.ns.client.view.layer.createAndInsert, this.createAndInsert, this),
+            nc.on(nc.ns.client.view.mesh.create, this.createMesh, this),
+            nc.on(nc.ns.client.view.animatedMesh.create, this.createAnimatedMesh, this),
+            nc.on(nc.ns.client.view.mesh.add, this.addMesh, this),
+            nc.on(nc.ns.client.view.mesh.remove, this.removeMesh, this),
+            nc.on(nc.ns.client.view.mesh.update, this.updateMesh, this),
+            nc.on(nc.ns.client.view.mesh.addFilter, this.addFilter, this),
+            nc.on(nc.ns.client.view.mesh.removeFilter, this.removeFilter, this),
+            nc.on(nc.ns.client.view.mesh.swapMeshIndexes, this.swapMeshIndexes, this),
+            nc.on(nc.ns.client.view.mesh.swapMeshes, this.swapMeshes, this)
         ];
     }
 
@@ -157,9 +159,19 @@ function (Nc, Exception, Layer) {
     	this.delegate.apply(this, arguments);
     };
 
+    LayerManager.prototype.swapMeshIndexes = function() {
+        Array.prototype.splice.call(arguments, 0, 0, 'swapMeshIndexes')
+        this.delegate.apply(this, arguments);
+    };
+
+    LayerManager.prototype.swapMeshes = function() {
+        Array.prototype.splice.call(arguments, 0, 0, 'swapMeshes')
+        this.delegate.apply(this, arguments);
+    };
+
     LayerManager.prototype.destroy = function() {
         for (var i = 0; i < this.ncTokens.length; i++) {
-            Nc.off(this.ncTokens[i]);
+            nc.off(this.ncTokens[i]);
         };
         for (var i = this.layers.length - 1; i >= 0; i--) { 
             var layer = this.layers[i];

app/Game/Client/View/Mesh.js

@@ -5,7 +5,7 @@ define([
     "Lib/Vendor/Screenfull"
 ],
 
-function (Settings, Nc, Stats, Screenfull) {
+function (Settings, nc, Stats, Screenfull) {
 
 	"use strict";
 

app/Game/Client/View/Pixi/GameStats.js

@@ -5,11 +5,11 @@ define([
 	"Lib/Utilities/ColorConverter"
 ],
  
-function (PIXI, Nc, Settings, ColorConverter) {
+function (PIXI, nc, Settings, ColorConverter) {
 
 	"use strict";
  
-    function GameStats(gameContainer) {
+    function GameStats(view) {
 
 		this.style = {
 			borderWidth: 3,
@@ -27,7 +27,7 @@ function (PIXI, Nc, Settings, ColorConverter) {
             fontSize: 12
 		};
 
-    	this.gameContainer = gameContainer;
+    	this.view = view;
 
         this.container = new PIXI.DisplayObjectContainer();
 
@@ -63,8 +63,8 @@ function (PIXI, Nc, Settings, ColorConverter) {
         this.sortedPlayers = [];
 
         this.ncTokens = [
-            Nc.on(Nc.ns.client.view.gameStats.toggle, this.toggle, this),
-            Nc.on(Nc.ns.client.view.gameStats.update, this.update, this)
+            nc.on(nc.ns.client.view.gameStats.toggle, this.toggle, this),
+            nc.on(nc.ns.client.view.gameStats.update, this.update, this)
         ];
     }
 
@@ -77,11 +77,12 @@ function (PIXI, Nc, Settings, ColorConverter) {
             this.redraw();
             // show stats with filters
             this.container.visible = true;
-            this.gameContainer.filters = this.filters;
+
+            this.view.addFilters(this.filters);
             this.filters.forEach(function(filter) { filter.dirty = true; });
         } else {
             this.container.visible = false;
-            this.gameContainer.filters = null;
+            this.view.removeFilters(this.filters);
         }
     }
 
@@ -196,7 +197,7 @@ function (PIXI, Nc, Settings, ColorConverter) {
 
     GameStats.prototype.destroy = function() {
         for (var i = 0; i < this.ncTokens.length; i++) {
-            Nc.off(this.ncTokens[i]);
+            nc.off(this.ncTokens[i]);
         };
     };
  

app/Game/Client/View/Pixi/Layer.js

@@ -7,7 +7,7 @@ define([
     "Lib/Utilities/NotificationCenter"
 ],
 
-function (Parent, PIXI, ColorRangeReplaceFilter, Settings, ColorConverter, Nc) {
+function (Parent, PIXI, ColorRangeReplaceFilter, Settings, ColorConverter, nc) {
 
 	"use strict";
     
@@ -23,7 +23,7 @@ function (Parent, PIXI, ColorRangeReplaceFilter, Settings, ColorConverter, Nc) {
         }
 
         this.ncTokens = this.ncTokens.concat([
-            Nc.on(Nc.ns.client.view.layer.levelSizeUpdate, this.onLevelSizeUpdate, this)
+            nc.on(nc.ns.client.view.layer.levelSizeUpdate, this.onLevelSizeUpdate, this)
         ]);
 
         if (Settings.SHOW_LAYER_INFO) {
@@ -95,6 +95,30 @@ function (Parent, PIXI, ColorRangeReplaceFilter, Settings, ColorConverter, Nc) {
         this.container.removeChild(mesh);
     };
 
+    Layer.prototype.swapMeshIndexes = function(meshA, meshB) {
+        var indexA = this.container.getChildIndex(meshA);
+        var indexB = this.container.getChildIndex(meshB);
+
+        this.container.setChildIndex(meshA, indexB);
+        this.container.setChildIndex(meshB, indexA);
+    };
+
+    Layer.prototype.swapMeshes = function(meshA, meshB) {
+        var textureA = meshA.texture;
+        var textureB = meshB.texture;
+
+        meshA.setTexture(textureB);
+        meshA.onTextureUpdate();
+        meshA.scale.x = 1;
+        meshA.scale.y = 1;
+
+        meshB.setTexture(textureA);
+        meshB.onTextureUpdate();
+        meshB.scale.x = 1;
+        meshB.scale.y = 1;
+
+    };
+
     Layer.prototype.createMesh = function (texturePath, callback, options) {
 
         var texture = (options && options.fromFrame)
@@ -150,6 +174,11 @@ function (Parent, PIXI, ColorRangeReplaceFilter, Settings, ColorConverter, Nc) {
 
     Layer.prototype.addFilter = function(mesh, filterName, options) {
 
+        // use game container if mesh null
+        if(mesh === null) {
+
+        }
+
         if (!this.getAvailableMeshFilters().hasOwnProperty(filterName)) {
             throw new Exception('Filter ' + filterName + ' is not available');
         }
@@ -204,6 +233,8 @@ function (Parent, PIXI, ColorRangeReplaceFilter, Settings, ColorConverter, Nc) {
             return;
         }
 
+        // FIXME this should throw an error i think since "options" is not defined here
+        // maybe we never actually call this method?
         var MeshFilter = this.getAvailableMeshFilters()[options.filter];
 
         filters = filters.filter(function(filter){

app/Game/Client/View/Pixi/Layers/Debug.js

@@ -16,12 +16,5 @@ function (Parent, PIXI) {
 
     Debug.prototype = Object.create(Parent.prototype);
 
-    Debug.prototype.render = function(centerPosition, zoom) {
-         Parent.prototype.render.call(this, centerPosition, zoom);
-
-         this.container.x -= 300 * zoom;
-         this.container.y -= 200 * zoom;
-     }; 
-    
     return new Debug();
 });

app/Game/Client/View/Pixi/Layers/Ghost.js

@@ -5,7 +5,7 @@ define([
 	"Game/Config/Settings"
 ],
  
-function (Parent, PIXI, Nc, Settings) {
+function (Parent, PIXI, nc, Settings) {
 
 	"use strict";
  
@@ -13,12 +13,12 @@ function (Parent, PIXI, Nc, Settings) {
     	Parent.call(this, "ghost", {parallaxSpeed: 0});
 
 		this.ncTokens = this.ncTokens.concat([
-            Nc.on(Nc.ns.client.view.layer.levelSizeUpdate, this.onLevelSizeUpdate, this),
-            Nc.on(Nc.ns.client.view.playerArrow.createAndAdd, this.onCreateAndAddPlayerArrow, this),
-            Nc.on(Nc.ns.client.view.playerArrow.update, this.onUpdatePlayerArrow, this),
-            Nc.on(Nc.ns.client.view.healthBar.createAndAdd, this.onCreateAndAddHealthBar, this),
-            Nc.on(Nc.ns.client.view.healthBar.update, this.onUpdateHealthBar, this),
-            Nc.on(Nc.ns.client.view.healthBar.remove, this.onRemoveHealthBar, this),
+            nc.on(nc.ns.client.view.layer.levelSizeUpdate, this.onLevelSizeUpdate, this),
+            nc.on(nc.ns.client.view.playerArrow.createAndAdd, this.onCreateAndAddPlayerArrow, this),
+            nc.on(nc.ns.client.view.playerArrow.update, this.onUpdatePlayerArrow, this),
+            nc.on(nc.ns.client.view.healthBar.createAndAdd, this.onCreateAndAddHealthBar, this),
+            nc.on(nc.ns.client.view.healthBar.update, this.onUpdateHealthBar, this),
+            nc.on(nc.ns.client.view.healthBar.remove, this.onRemoveHealthBar, this),
         ]);
 
     }
@@ -36,10 +36,10 @@ function (Parent, PIXI, Nc, Settings) {
         arrow.visible = false;
         this.container.addChild(arrow);
 
-        var width = 12,
-            height = 12;
+        var width = 10,
+            height = 10;
 
-        arrow.beginFill(0xffffff, 0.1);
+        arrow.beginFill(0xffffff, 0.4);
         arrow.lineStyle(0, 0x000000);
         arrow.moveTo(0, 0);
         arrow.lineTo(width, 0);
@@ -56,7 +56,7 @@ function (Parent, PIXI, Nc, Settings) {
     Ghost.prototype.onUpdatePlayerArrow = function(arrow, options) {
 
         var offsetX = 0,
-            offsetY = -60,
+            offsetY = -55,
             x = offsetX + options.x,
             y = offsetY + options.y;
 

app/Game/Client/View/Pixi/Layers/Messages.js

@@ -5,7 +5,7 @@ define([
     "Game/Config/Settings"
 ],
  
-function (Parent, PIXI, Nc, Settings) {
+function (Parent, PIXI, nc, Settings) {
 
     "use strict";
  
@@ -13,7 +13,7 @@ function (Parent, PIXI, Nc, Settings) {
     	Parent.call(this, "messages", {parallaxSpeed:-1});
 
 		this.ncTokens = this.ncTokens.concat([
-            Nc.on(Nc.ns.client.view.gameStats.kill, this.onKill, this)
+            nc.on(nc.ns.client.view.gameStats.kill, this.onKill, this)
         ]);
 
         this.mainTextOptions = {

app/Game/Client/View/Pixi/Layers/Swiper.js

@@ -5,7 +5,7 @@ define([
 	"Game/Config/Settings"
 ],
  
-function (Parent, PIXI, Nc, Settings) {
+function (Parent, PIXI, nc, Settings) {
  
     function Swiper() {
     	Parent.call(this, "swiper", {parallaxSpeed:0});
@@ -13,8 +13,8 @@ function (Parent, PIXI, Nc, Settings) {
         this.static = true;
 
     	this.ncTokens = this.ncTokens.concat([
-            Nc.on(Nc.ns.client.view.swiper.swipe, this.swipe, this),
-            Nc.on(Nc.ns.client.view.swiper.end, this.end, this)
+            nc.on(nc.ns.client.view.swiper.swipe, this.swipe, this),
+            nc.on(nc.ns.client.view.swiper.end, this.end, this)
         ]);
 
         this.sprite = new PIXI.Graphics();

app/Game/Client/View/Pixi/View.js

@@ -14,7 +14,7 @@ define([
     "Game/Client/View/Pixi/Layers/Messages"
 ], 
 
-function (Parent, DomController, PIXI, Settings, Nc, Exception, GameStats, LayerManager, Ghost, Swiper, PointerLockManager, Debug, Messages) {
+function (Parent, domController, PIXI, Settings, nc, Exception, GameStats, LayerManager, Ghost, Swiper, pointerLockManager, Debug, Messages) {
 
 	"use strict";
 
@@ -35,8 +35,8 @@ function (Parent, DomController, PIXI, Settings, Nc, Exception, GameStats, Layer
         this.init();
 
         this.ncTokens = this.ncTokens.concat([
-            Nc.on(Nc.ns.client.pointerLock.change, this.onPointerLockChange, this),
-            Nc.on(Nc.ns.core.game.events.level.loaded, this.showDefaultLayers, this)
+            nc.on(nc.ns.client.pointerLock.change, this.onPointerLockChange, this),
+            nc.on(nc.ns.core.game.events.level.loaded, this.showDefaultLayers, this)
         ]);
 
         PIXI.scaleModes.DEFAULT = PIXI.scaleModes.NEAREST;
@@ -47,7 +47,7 @@ function (Parent, DomController, PIXI, Settings, Nc, Exception, GameStats, Layer
     PixiView.prototype.init = function () {
 
         var rendererOptions = {
-            view: DomController.getCanvas(),
+            view: domController.getCanvas(),
             antialiasing: false,
             transparent: false,
             resolution: 1
@@ -82,7 +82,7 @@ function (Parent, DomController, PIXI, Settings, Nc, Exception, GameStats, Layer
         this.initPointerLockView();
 
         // Tab Overlay (not using layer manager, cause of filters)
-        this.gameStats = new GameStats(this.container);
+        this.gameStats = new GameStats(this);
         this.stage.addChild(this.gameStats.getInfoContainer());
 
         this.ghostLayer = new Ghost();
@@ -121,7 +121,8 @@ function (Parent, DomController, PIXI, Settings, Nc, Exception, GameStats, Layer
     }
 
     PixiView.prototype.initPointerLockView = function() {
-
+        if (!Settings.ENABLE_POINTER_LOCK_FILTER) return;
+        
         var blurFilter = new PIXI.BlurFilter();
         blurFilter.blurX = 42 * this.currentZoom;
         blurFilter.blurY = 42 * this.currentZoom;
@@ -139,8 +140,11 @@ function (Parent, DomController, PIXI, Settings, Nc, Exception, GameStats, Layer
     };
 
     PixiView.prototype.onPointerLockChange = function(isLocked, options) {
+        if (!Settings.ENABLE_POINTER_LOCK_FILTER) return;
+
         if(isLocked) {
-            this.container.filters = null;
+            this.removeFilters(this.pointerLockFilters);
+            
             this.clickToEnable.visible = false;
             this.onZoomReset();
         } else {
@@ -156,7 +160,7 @@ function (Parent, DomController, PIXI, Settings, Nc, Exception, GameStats, Layer
                 strokeThickness: 6 * this.currentZoom
             });
 
-            this.container.filters = this.pointerLockFilters;
+            this.addFilters(this.pointerLockFilters);
             this.pointerLockFilters.forEach(function(filter) { filter.dirty = true; });
 
             this.clickToEnable.position = new PIXI.Point(Settings.STAGE_WIDTH / 2 - this.clickToEnable.width / 2, Settings.STAGE_HEIGHT / 2 - this.clickToEnable.height / 2)
@@ -167,6 +171,46 @@ function (Parent, DomController, PIXI, Settings, Nc, Exception, GameStats, Layer
         }
     };
 
+    PixiView.prototype.removeFilters = function(filters) {
+
+        if(this.container && this.container.filters && this.container.filters.length) {
+            for (var i = this.container.filters.length - 1; i >= 0; i--) {
+
+                for (var j = filters.length - 1; j >= 0; j--) {
+                    if (filters[j] === this.container.filters[i]) {
+                        this.container.filters.splice(i, 1);
+                    }
+                }
+            }
+
+            // weird bug, filters.length cant be 0, must be set to null
+            if(this.container.filters.length < 1) {
+                this.container.filters = null;
+            }
+        }
+
+    };
+
+    PixiView.prototype.addFilters = function(filters) {
+        if (filters.length < 1) return;
+        if (!this.container) {
+            return;
+        }
+
+        if (!this.container.filters) {
+            /*
+             * slice does a copy, which is important here - 
+             * otherwise this.pointerLockFilters will be manipulated too on remove.
+             */ 
+            this.container.filters = filters.slice(); 
+            return;
+        }
+
+        for (var i = 0; i < filters.length; i++) {
+            this.container.filters.push(filters[i]);
+        }
+    };
+
     PixiView.prototype.calculateCenterPosition = function() {
         var target = this.me.getHeadPosition();
         
@@ -187,7 +231,7 @@ function (Parent, DomController, PIXI, Settings, Nc, Exception, GameStats, Layer
         this.renderer.resize(window.innerWidth, window.innerHeight);
         this.currentZoom = window.innerWidth / 600;
 
-        PointerLockManager.update(null, {}); // only to reposition clickToEnable text
+        pointerLockManager.update(null, {}); // only to reposition clickToEnable text
     };
 
     PixiView.prototype.initLoader = function() {

app/Game/Client/View/Three/View.js

@@ -1,11 +1,10 @@
 define([
     "Game/Client/View/Abstract/View",
-    "Game/Client/View/DomController", 
     "Lib/Vendor/Three", 
     "Game/Config/Settings"
 ], 
 
-function (Parent, DomController, Three, Settings) {
+function (Parent, Three, Settings) {
 
 	"use strict";
     

app/Game/Client/View/ViewManager.js

@@ -7,7 +7,7 @@ define([
     "Lib/Utilities/NotificationCenter"
 ],
  
-function (Settings, Exception, AbstractView, PixiView, Nc) {
+function (Settings, Exception, AbstractView, PixiView, nc) {
 
 	"use strict";
  

app/Game/Config/ItemSettings.js

@@ -411,19 +411,17 @@ function () {
         },
 
 
-
-
-        "Rube": 
+        "RubeDoll": 
         {
             "category":     "kitchen",
             "image":        "banana.gif",
-            
-   //         "type":         "rube",
-            "weight":       "1",
-            "width":        "5",
+
+            "weight":       "3",
+            "width":        "15",
             "height":       "9",
 
-            "grabAngle":    "0.5",
+            "type":         "rubedoll",
+            "grabAngle":    "0.001",  // seems to be a bug, that 0 does not work!
         }
     };
 

app/Game/Config/Settings.js

@@ -16,8 +16,8 @@ function () {
         BOX2D_WORLD_AABB_SIZE: 3000,
         BOX2D_ALLOW_SLEEP: true,
         BOX2D_GRAVITY: 26,
-        BOX2D_VELOCITY_ITERATIONS: 5,
-        BOX2D_POSITION_ITERATIONS: 5,
+        BOX2D_VELOCITY_ITERATIONS: 20,
+        BOX2D_POSITION_ITERATIONS: 10, // 200/100 created problems (awful teleporting when repositioning joints)
         BOX2D_TIME_STEP: 1 / 60,
 
         //  PATHS
@@ -39,6 +39,7 @@ function () {
         VIEW_CONTROLLER: 0 ? "Three" : "Pixi",
         ARROW_GLIDE: 30, // % of the way per frame     
         SHOW_LAYER_INFO: false,
+        ENABLE_POINTER_LOCK_FILTER: true,
 
         // GAME PLAY 
         WALK_SPEED: 4,
@@ -87,10 +88,10 @@ function () {
         CHANNEL_MAX_USERS: 20,
         CHANNEL_DESTRUCTION_TIME: 0.5 * 60,
         CHANNEL_END_ROUND_TIME: 20, //10,
-        CHANNEL_DEFAULT_MAX_USERS: 40,
-        CHANNEL_DEFAULT_SCORE_LIMIT: 10,
+        CHANNEL_DEFAULT_MAX_USERS: 10,
+        CHANNEL_DEFAULT_SCORE_LIMIT: 5,
         CHANNEL_DEFAULT_LEVELS: ["debug"],
-        CHANNEL_RECORD_SESSION: true,
+        CHANNEL_RECORD_SESSION: false,
 
         // ME STATE
         ME_STATE_MAX_DIFFERENCE_METERS: 1,

app/Game/Core/Control/PlayerController.js

@@ -4,20 +4,18 @@ define([
 function () {
 
     function PlayerController (player) {
-
         this.player = player;
-
-        this._shift;
-        this._isJumping;
         this._walkingDirectionStatus = 0;
     }
 
     PlayerController.prototype.moveLeft = function () {
+        if(!this.isPlayerInputAllowed()) return;
         this.player.move(-1);
         this._walkingDirectionStatus = -1;
     }
 
     PlayerController.prototype.moveRight = function () {
+        if(!this.isPlayerInputAllowed()) return;
         this.player.move(1);
         this._walkingDirectionStatus = 1;
     }
@@ -28,7 +26,7 @@ function () {
     }
 
     PlayerController.prototype.jump = function () {
-        this._isJumping = true;
+        if(!this.isPlayerInputAllowed()) return;
         this.player.jump();
     }
 
@@ -37,15 +35,31 @@ function () {
     }
 
     PlayerController.prototype.lookAt = function (options) {
+        if(!this.isPlayerInputAllowed()) return;
         if(options) this.player.lookAt(options.x, options.y);
     }
 
+    PlayerController.prototype.activateModifier = function() {
+        if (!this.isPlayerInputAllowed()) return;
+        this.player.activateModifier();
+    };
+
+    PlayerController.prototype.deactivateModifier = function() {
+        if (!this.isPlayerInputAllowed()) return;
+        this.player.deactivateModifier();
+    };
+
     PlayerController.prototype.update = function () {
         if(this._walkingDirectionStatus != 0) {
             this.player.move(this._walkingDirectionStatus);
         }
     }
 
+    // Default behaviour - may be needed later? 
+    PlayerController.prototype.isPlayerInputAllowed = function() {
+        return true;
+    };
+
     PlayerController.prototype.destroy = function() {
         // extend if necessary
     };

app/Game/Core/GameController.js

@@ -5,10 +5,11 @@ define([
     "Lib/Utilities/NotificationCenter",
     "Game/" + GLOBALS.context + "/GameObjects/Doll",
     "Game/" + GLOBALS.context + "/GameObjects/GameObject",
-    "Lib/Utilities/Assert"
+    "Game/" + GLOBALS.context + "/GameObjects/Item",
+    "Lib/Utilities/Assert",
 ],
 
-function (PhysicsEngine, TiledLevel, Player, Nc, Doll, GameObject, Assert) {
+function (PhysicsEngine, TiledLevel, Player, nc, Doll, GameObject, Item, Assert) {
 
 	"use strict";
 
@@ -17,15 +18,14 @@ function (PhysicsEngine, TiledLevel, Player, Nc, Doll, GameObject, Assert) {
         this.options = options;
         this.players = {};
         this.level = null;
-        this.gameObjects = null;
-        this.resetGameObjects();
+        this.worldUpdateObjects = {};
 
         this.physicsEngine = new PhysicsEngine();
         this.physicsEngine.setCollisionDetector();
 
         this.ncTokens = [
-            Nc.on(Nc.ns.core.game.gameObject.add, this.onGameObjectAdd, this),
-            Nc.on(Nc.ns.core.game.gameObject.remove, this.onGameObjectRemove, this)
+            nc.on(nc.ns.core.game.worldUpdateObjects.add, this.onWorldUpdateObjectAdd, this),
+            nc.on(nc.ns.core.game.worldUpdateObjects.remove, this.onWorldUpdateObjectRemove, this)
         ];
 
         this.loadLevel(options.levelUid);
@@ -37,89 +37,61 @@ function (PhysicsEngine, TiledLevel, Player, Nc, Doll, GameObject, Assert) {
         // extend for both sides if necessary
     };
 
-    GameController.prototype.resetGameObjects = function() {
-        this.gameObjects = {
-            fixed: [],
-            animated: []
-        };
+    GameController.prototype.onWorldUpdateObjectAdd = function(object) {
+        this.worldUpdateObjects[object.uid] = object;
     };
 
-    GameController.prototype.onGameObjectAdd = function(type, object) {
-        this.gameObjects[type].push(object);
-    };
-
-    GameController.prototype.onGameObjectRemove = function(type, object) {
-        var i = this.gameObjects[type].indexOf(object);
-        if(i>=0) this.gameObjects[type].splice(i, 1);
+    GameController.prototype.onWorldUpdateObjectRemove = function(object) {
+        delete this.worldUpdateObjects[object.uid];
     };
 
     GameController.prototype.getPhysicsEngine = function () {
         return this.physicsEngine;
     };
 
+    GameController.prototype.getItemByUid = function(uid) {
+        // FIXME : maybe divide this into a dedicated item pool?
+        return this.worldUpdateObjects[uid];
+    };
+
     GameController.prototype.loadLevel = function (levelUid) {
 
         if (this.level) {
             this.level.destroy();
-            this.resetGameObjects();
+            this.worldUpdateObjects = {};
         }
 
-        this.level = new TiledLevel(levelUid, this.physicsEngine, this.gameObjects);
+        this.level = new TiledLevel(levelUid, this.physicsEngine);
     };
 
+    /*
+     *  This is now in core, because the recorder/player 
+     *  uses the world update mechanism on the channel side
+     */ 
     GameController.prototype.onWorldUpdate = function (updateData) {
 
-        var body = this.physicsEngine.world.GetBodyList();
-        do {
-            var userData = body.GetUserData();
-            if (userData instanceof GameObject) {
-                var gameObject = userData;
-                if(updateData[gameObject.uid]) {
-                    var update = updateData[gameObject.uid];
-                    this.onWorldUpdateGameObject(body, gameObject, update);
-                }
+        for (var uid in updateData) {
+
+            var gameObject = this.worldUpdateObjects[uid];
+
+            if (!(gameObject instanceof GameObject)) {
+                console.warn('Can\'t find object ' + uid + ' in worldUpdateObjects pool:', Object.keys(this.worldUpdateObjects));
+                continue;
             }
 
-        } while (body = body.GetNext());
-
-    };
-
-    GameController.prototype.onWorldUpdateGameObject = function(body, gameObject, update) {
-        if (gameObject instanceof Doll) {
-            /*
-            if(gameObject === this.me.doll) {
-                this.me.setLastServerPositionState(update);
-                if(!this.me.acceptPositionStateUpdateFromServer()) {
-                    return; // this is to ignore own doll updates from world update 
-                }
-            }
-            */
-            gameObject.setActionState(update.as);
-            gameObject.lookAt(update.laxy.x, update.laxy.y);
+            this.updateGameObject(gameObject, updateData[uid]);
         }
-
-        Assert.number(update.p.x, update.p.y);
-        Assert.number(update.a);
-        Assert.number(update.lv.x, update.lv.y);
-        Assert.number(update.av);
-
-        body.SetAwake(true);
-        body.SetPosition(update.p);
-        body.SetAngle(update.a);
-        body.SetLinearVelocity(update.lv);
-        body.SetAngularVelocity(update.av);
     };
 
+
+    GameController.prototype.updateGameObject = function(gameObject, gameObjectUpdate) {
+        gameObject.setUpdateData(gameObjectUpdate);
+    }
+
     GameController.prototype.onResetLevel = function() {
         this.loadLevel(this.level.uid);
     };
 
-    /*
-    GameController.prototype.userJoined = function (user) {
-        this.players[user.id] = this.createPlayer(user);
-    }
-    */
-
     GameController.prototype.onUserLeft = function (userId) {
         var player = this.players[userId];
         if(!player) {
@@ -131,48 +103,31 @@ function (PhysicsEngine, TiledLevel, Player, Nc, Doll, GameObject, Assert) {
         delete this.players[userId];
     };
 
-    GameController.prototype.createPlayer = function(user) {
-        var player = new Player(user.id, this.physicsEngine, user);
+    GameController.prototype.createPlayer = function(user, revealedGameController) {
+        var player = new Player(user.id, this.physicsEngine, user, revealedGameController);
         this.players[user.id] = player;
         return player;
     };
 
+
     GameController.prototype.destroy = function () {
-        var i = 0;
-
-        /*
         for(var player in this.players) {
-            // this.players[player].destroy();
-
-            // FIXME: 
-            // commented out for now, because players are in gameObjects array.
-            // try using a real gameobject for the health bar
-        }*/
-
-
-        for (i = 0; i < this.ncTokens.length; i++) {
-            Nc.off(this.ncTokens[i]);
+            this.players[player].destroy();
         }
 
-        /*
-         *   Contents of gameObject: Players, Items, Tiles, RagDolls
-         *   No Dolls.
-         */
+        // FIXME ns.client in core?
+        nc.trigger(nc.ns.client.game.events.destroy);
 
-        for (var key in this.gameObjects) {
-            for (i = 0; i < this.gameObjects[key].length; i++) {
-                var gameObject = this.gameObjects[key][i];
-
-                gameObject.destroy();
-            }
+        // Testing after destroy if worldUpdateObjects is empty
+        // events.game.destroy -> gameobjects.destroy() -> nc.trigger(worldUpdateObjects.remove)
+        if(Object.keys(this.worldUpdateObjects).length > 0) {
+            console.warn('Not all worldUpdateObjects have been removed... ', Object.keys(this.worldUpdateObjects));
         }
 
-        this.gameObjects = {
-            fixed: [],
-            animated: []
-        };
-
         this.physicsEngine.destroy();
+        this.worldUpdateObjects = null;
+
+        nc.off(this.ncTokens);
     };
 
     return GameController;

app/Game/Core/GameObjects/Doll.js

@@ -9,7 +9,7 @@ define([
     "Lib/Utilities/Assert"
 ], 
 
-function (Parent, Exception, Box2D, Settings, CollisionDetector, Item, Nc, Assert) {
+function (Parent, Exception, Box2D, Settings, CollisionDetector, Item, nc, Assert) {
 
 	"use strict";
 
@@ -40,11 +40,12 @@ function (Parent, Exception, Box2D, Settings, CollisionDetector, Item, Nc, Asser
         this.holdingJoint = null;
         this.holdingItem = null;
 
-        this.ragDoll = {head: null, body: null};
+        this.ragDoll = {head: null, body: null}; // FIXME: wtf is this? can we remove it?
         
         this.createFixtures();
         this.body.SetActive(false);
 
+        nc.trigger(nc.ns.core.game.worldUpdateObjects.add, this);
     }
 
     Doll.prototype = Object.create(Parent.prototype);
@@ -227,14 +228,14 @@ function (Parent, Exception, Box2D, Settings, CollisionDetector, Item, Nc, Asser
         }
     };
 
-    Doll.prototype.move = function (direction) {
+    Doll.prototype.move = function (direction, modifierActivated) {
 
         this.moveDirection = direction;
         var speed;
         var isHoldingHeavyItem = this.holdingItem && this.holdingItem.options.weight > Settings.MAX_RUNNING_WEIGHT;
         
         switch(true) {
-            case direction == this.lookDirection && this.isStanding() && !isHoldingHeavyItem:
+            case direction == this.lookDirection && this.isStanding() && !isHoldingHeavyItem && !modifierActivated:
                 speed = Settings.RUN_SPEED;
                 break;
 
@@ -263,7 +264,7 @@ function (Parent, Exception, Box2D, Settings, CollisionDetector, Item, Nc, Asser
         if(this.isStanding()) {
             if(this.moveDirection == this.lookDirection) {
 
-                if(isHoldingHeavyItem) {
+                if(isHoldingHeavyItem || modifierActivated) {
                     this.setActionState("walk");
                 } else {
                     this.setActionState("run");
@@ -471,7 +472,16 @@ function (Parent, Exception, Box2D, Settings, CollisionDetector, Item, Nc, Asser
         }
     };
 
+    Doll.prototype.setUpdateData = function(update) {
+
+        Parent.prototype.setUpdateData.call(this, update);
+
+        this.setActionState(update.as);
+        this.lookAt(update.laxy.x, update.laxy.y);
+    };
+
     Doll.prototype.destroy = function() {
+        nc.trigger(nc.ns.core.game.worldUpdateObjects.remove, this);
         Parent.prototype.destroy.call(this);
     };
 

app/Game/Core/GameObjects/GameObject.js

@@ -1,9 +1,11 @@
 define([
     "Lib/Vendor/Box2D",
-    "Lib/Utilities/Exception"
+    "Lib/Utilities/Exception",
+    "Lib/Utilities/Assert",
+    "Lib/Utilities/NotificationCenter"
 ],
  
-function (Box2D, Exception) {
+function (Box2D, Exception, Assert, nc) {
 
 	"use strict";
  
@@ -12,7 +14,11 @@ function (Box2D, Exception) {
 
         var def = this.getBodyDef();
         def.userData = this;
-        this.body = physicsEngine.getWorld().CreateBody(def);
+        this.body = physicsEngine.createBody(def);
+
+        this.ncTokens = (this.ncTokens || []).concat([
+            nc.on(nc.ns.client.game.events.destroy, this.destroy, this)
+        ]);
     }
 
     GameObject.prototype.getBodyDef = function() {
@@ -20,11 +26,14 @@ function (Box2D, Exception) {
     };
 
     GameObject.prototype.destroy = function() {
+        
         if(this.body instanceof Box2D.Dynamics.b2Body) {
             this.body.GetWorld().DestroyBody(this.body);   
         } else {
             throw new Exception("can not destroy body");
         }
+
+        nc.off(this.ncTokens);
     };
 
     GameObject.prototype.getBody = function() {
@@ -34,6 +43,20 @@ function (Box2D, Exception) {
     GameObject.prototype.getPosition = function() {
         return this.body.GetPosition().Copy();
     };
+
+    GameObject.prototype.setUpdateData = function(update) {
+
+        Assert.number(update.p.x, update.p.y);
+        Assert.number(update.a);
+        Assert.number(update.lv.x, update.lv.y);
+        Assert.number(update.av);
+
+        this.body.SetAwake(true);
+        this.body.SetPosition(update.p);
+        this.body.SetAngle(update.a);
+        this.body.SetLinearVelocity(update.lv);
+        this.body.SetAngularVelocity(update.av);
+    };
  
     return GameObject;
  

app/Game/Core/GameObjects/Item.js

@@ -1,14 +1,14 @@
 define([
 	"Game/" + GLOBALS.context + "/GameObjects/GameObject",
 	"Lib/Vendor/Box2D",
-    "Lib/Utilities/Options",
+    "Lib/Utilities/OptionsHelper",
 	"Game/Config/Settings",
     "Lib/Utilities/Exception",
     "Lib/Utilities/NotificationCenter",
     "Lib/Utilities/Assert"
 ],
  
-function (Parent, Box2D, Options, Settings, Exception, Nc, Assert) {
+function (Parent, Box2D, optionsHelper, Settings, Exception, nc, Assert) {
 
 	"use strict";
  
@@ -26,7 +26,7 @@ function (Parent, Box2D, Options, Settings, Exception, Nc, Assert) {
             y: parseFloat(options.y)
         };
 
-        this.options = Options.merge(floatOptions, options);
+        this.options = optionsHelper.merge(floatOptions, options);
 
         if(!this.options.category) {
             // FIXME add more validation
@@ -41,7 +41,7 @@ function (Parent, Box2D, Options, Settings, Exception, Nc, Assert) {
             this.body.SetBullet(true);
         }
 
-        Nc.trigger(Nc.ns.core.game.gameObject.add, "animated", this);
+        nc.trigger(nc.ns.core.game.worldUpdateObjects.add, this);
     }
 
     Item.prototype = Object.create(Parent.prototype);
@@ -128,8 +128,8 @@ function (Parent, Box2D, Options, Settings, Exception, Nc, Assert) {
             handPosition.y
         );
         this.body.SetPosition(position);
+        this.body.SetAngle((this.options.grabAngle || 0.0) * direction);
         this.flip(direction);
-        this.body.SetAngle((this.options.grabAngle || 0) * direction);
     };
 
     Item.prototype.getGrabPoint = function() {
@@ -158,7 +158,7 @@ function (Parent, Box2D, Options, Settings, Exception, Nc, Assert) {
     };
 
     Item.prototype.destroy = function() {
-        Nc.trigger(Nc.ns.core.game.gameObject.remove, "animated", this);
+        nc.trigger(nc.ns.core.game.worldUpdateObjects.remove, this);
         Parent.prototype.destroy.call(this);
     };
  

app/Game/Core/GameObjects/Items/RagDoll.js

@@ -4,11 +4,11 @@ define([
 	"Game/Config/Settings",
     "Lib/Utilities/NotificationCenter",
     "Lib/Utilities/Assert",
-    "Lib/Utilities/Options",
+    "Lib/Utilities/OptionsHelper",
     "Game/Config/ItemSettings",
 ],
  
-function (Parent, Box2D, Settings, Nc, Assert, Options, ItemSettings) {
+function (Parent, Box2D, Settings, nc, Assert, optionsHelper, ItemSettings) {
 
 	"use strict";
  
@@ -96,8 +96,8 @@ function (Parent, Box2D, Settings, Nc, Assert, Options, ItemSettings) {
 
 
         // FIXME
-        var ragdollOptions = Options.merge(ItemSettings.RagDoll, ItemSettings.Default);
-        options = Options.merge(options, ragdollOptions);
+        var ragdollOptions = optionsHelper.merge(ItemSettings.RagDoll, ItemSettings.Default);
+        options = optionsHelper.merge(options, ragdollOptions);
         Parent.call(this, physicsEngine, uid, options);
         //this.createSensor();
 
@@ -352,7 +352,7 @@ function (Parent, Box2D, Settings, Nc, Assert, Options, ItemSettings) {
             chestPosition.y + this.options.limbs.head.y / Settings.RATIO
         );
         this.limbs.head.SetPosition(position);
-        this.limbs.head.SetAngle((this.options.grabAngle || 0) * direction);
+        this.limbs.head.SetAngle((this.options.grabAngle || 0.0) * direction);
     };
 
     RagDoll.prototype.throw = function(options, carrierVelocity) {
@@ -378,7 +378,6 @@ function (Parent, Box2D, Settings, Nc, Assert, Options, ItemSettings) {
 
     RagDoll.prototype.destroy = function() {
 
-        Nc.trigger(Nc.ns.core.game.gameObject.remove, "animated", this);
         var world = this.body.GetWorld();
         
         for (var name in this.limbs) {

app/Game/Core/GameObjects/Items/RubeDoll.js

@@ -0,0 +1,223 @@
+define([
+    "Game/" + GLOBALS.context + "/GameObjects/Item",
+    "Lib/Vendor/RubeLoader",
+    "Lib/Vendor/Box2D",
+    "Game/Config/Settings",
+    "Lib/Utilities/Assert",
+    "Lib/Utilities/NotificationCenter",
+    "Lib/Utilities/Matrix",
+    "json!Game/Asset/RubeDoll.json" // using requirejs json loader plugin
+],
+
+function (Parent, RubeLoader, Box2D, Settings, Assert, nc, Matrix, RubeDollJson) {
+
+	"use strict";
+ 
+    function RubeDoll(physicsEngine, uid, options) {
+        Assert.number(options.x, options.y);
+
+        this.rubeLoader = null;
+        this.body = null;
+        this.limbs = {};
+        this.joints = null;
+        this.limits = [];
+
+        var chest = null;
+        this.rubeLoader = new RubeLoader(RubeDollJson, physicsEngine.getWorldForRubeLoader());
+
+        this.loadRubeDollFromScene(options);
+
+        Parent.call(this, physicsEngine, uid, options);
+        physicsEngine.destroyBody(this.body);
+        this.body = this.limbs.chest;
+        delete this.limbs.chest;
+
+        this.body.SetUserData(this);
+
+        this.flip(options.direction || 1);
+    }
+
+    RubeDoll.prototype = Object.create(Parent.prototype);
+
+    RubeDoll.prototype.loadRubeDollFromScene = function(options) {
+        var scene = this.rubeLoader.getScene();
+
+
+
+        for (var i in scene.bodies) {
+            var body = scene.bodies[i];
+            var position = body.GetPosition().Copy();
+            position.Add(new Box2D.Common.Math.b2Vec2(
+                options.x / Settings.RATIO, 
+                options.y / Settings.RATIO
+            ));
+            body.SetPosition(position);
+            this.limbs[body.name] = body;
+
+            // code snipped possibly needed for filtering between doll and rubedoll while holding
+            //var filterData = new Box2D.Dynamics.b2FilterData();
+            //filterData.groupIndex = -66;
+            //if(body.name != "head" && body.name != "chest") {
+            //    for (var fixture = body.GetFixtureList(); fixture; fixture = fixture.GetNext()) {
+            //        fixture.SetFilterData(filterData);
+            //    }
+            //}
+        }
+
+        this.joints = scene.joints;
+
+        var count = 0;
+        for (var i in this.joints) {
+            this.limits[i] = {
+                lower: this.joints[i].GetLowerLimit(),
+                upper: this.joints[i].GetUpperLimit(),
+            };
+/*
+            this.joints[i].EnableLimit(false);
+
+            if(count < 4 && this.joints[i] instanceof Box2D.Dynamics.Joints.b2RevoluteJoint) {
+                console.log(i);
+            } else {
+                body.GetWorld().DestroyJoint(this.joints[i]);
+            }
+            count++;
+            */
+        }
+    };
+
+    RubeDoll.prototype.getFixtureDef = function() {
+        var fixtureDef = new Box2D.Dynamics.b2FixtureDef();
+        fixtureDef.shape = new Box2D.Collision.Shapes.b2CircleShape();
+        return fixtureDef;
+    };
+
+    RubeDoll.prototype.flip = function(direction) {
+        var oldFlipDirection = this.flipDirection;
+
+        Parent.prototype.flip.call(this, direction);
+
+        if(oldFlipDirection != direction) {
+
+            for (var i in this.joints) {
+                var joint = this.joints[i];
+                var limits = this.limits[i];
+
+                if (joint instanceof Box2D.Dynamics.Joints.b2RevoluteJoint) {
+
+                    if (direction > 0) {
+                        joint.SetLimits(limits.lower, limits.upper);
+                        continue;
+                    }
+
+                    var a1 = limits.lower * -1;
+                    var a2 = limits.upper * -1;
+
+                    if (a2 > a1) {
+                        joint.SetLimits(a1, a2);
+                    } else {
+                        joint.SetLimits(a2, a1);
+                    }
+
+                    // joint.SetAngle(joint.GetAngle() * -1);
+                }
+            }
+        }
+    };
+
+    RubeDoll.prototype.reposition = function(handPosition, direction) {
+        var oldPosition = this.getPosition();
+        var oldAngle = this.body.GetAngle();
+        var oldDirection = this.flipDirection;
+        
+        // calls flip() at the end of Parent reposition()
+        Parent.prototype.reposition.call(this, handPosition, direction);
+
+        var differenceAngle = oldAngle - this.body.GetAngle();
+
+        //this.body.SetLinearVelocity(new Box2D.Common.Math.b2Vec2(0, 0));
+
+        var offset = Box2D.Common.Math.b2Math.SubtractVV(this.getPosition(), oldPosition);
+        var grabAngle = (this.options.grabAngle || 0.001);
+
+        for(var key in this.limbs) {
+            var limb = this.limbs[key];
+
+            // Setting position offset first (floor to hand)
+            var position = limb.GetPosition().Copy();
+            position.Add(offset);
+            limb.SetPosition(position);
+
+            // grabing local point to "rotate" around (x, y position transform only)
+            var localPoint = this.body.GetLocalPoint(limb.GetPosition().Copy());
+
+            // create rotation matrix from chest rotation difference
+            var mat = Box2D.Common.Math.b2Mat22.FromAngle(differenceAngle);
+
+            // matrix multiplication with local limb position
+            position = Box2D.Common.Math.b2Math.MulTMV(mat, localPoint);
+
+            // translating back to global position
+            var globalPoint = this.body.GetWorldPoint(position);
+            limb.SetPosition(globalPoint);
+
+            // relative limb rotating by chest rotation difference
+            var d = (oldDirection == direction) ? -1 : 1;
+            limb.SetAngle((limb.GetAngle() - differenceAngle) * d);
+            
+            //limb.SetType(Box2D.Dynamics.b2Body.b2_staticBody);
+            //limb.SetLinearVelocity(new Box2D.Common.Math.b2Vec2(0, 0));
+        }
+    };
+
+    RubeDoll.prototype.setVelocities = function(options) {
+        Assert.number(options.linearVelocity.x, options.linearVelocity.y);
+        Assert.number(options.angularVelocity);
+
+        this.body.SetLinearVelocity(options.linearVelocity);
+        this.body.SetAngularVelocity(options.angularVelocity);
+        for(var name in this.limbs) {
+            this.limbs[name].SetLinearVelocity(options.linearVelocity);
+        }
+    };
+
+    RubeDoll.prototype.getPosition = function() {
+        return this.body.GetPosition().Copy();
+    };
+
+    RubeDoll.prototype.getHeadPosition = function() {
+        return this.limbs.head.GetPosition().Copy();
+    };
+
+    RubeDoll.prototype.setUpdateData = function(update) {
+        
+        Parent.prototype.setUpdateData.call(this, update);
+
+/*
+        for(var name in update.limbs) {
+            Assert.number(update.limbs[name].p.x, update.limbs[name].p.y);
+            Assert.number(update.limbs[name].a);
+            Assert.number(update.limbs[name].lv.x, update.limbs[name].lv.y);
+            Assert.number(update.limbs[name].av);
+
+            this.limbs[name].SetAwake(true);
+            this.limbs[name].SetPosition(update.limbs[name].p);
+            this.limbs[name].SetAngle(update.limbs[name].a);
+            this.limbs[name].SetLinearVelocity(update.limbs[name].lv);
+            this.limbs[name].SetAngularVelocity(update.limbs[name].av);
+        }
+        */
+    }
+
+    RubeDoll.prototype.destroy = function() {
+
+        var world = this.body.GetWorld();
+        
+        for (var name in this.limbs) {
+            world.DestroyBody(this.limbs[name]);
+        }
+
+        Parent.prototype.destroy.call(this);
+    };
+ 
+    return RubeDoll;
+});

app/Game/Core/GameObjects/Items/Skateboard.js

@@ -12,16 +12,106 @@ function (Parent, Box2D, Settings, Assert) {
     function Skateboard(physicsEngine, uid, options) {
 
     	Parent.call(this, physicsEngine, uid, options);
+    }
+
+    Skateboard.prototype = Object.create(Parent.prototype);
+
+    Skateboard.prototype.createFixture = function () {
+        Assert.number(this.options.width, this.options.height);
+        Assert.number(this.options.weight);
+
+        var deckShape = new Box2D.Collision.Shapes.b2PolygonShape();
+        var w = this.options.width / Settings.RATIO;
+        var h = 2 / Settings.RATIO;
+        deckShape.SetAsOrientedBox(w / 2, h / 2, new Box2D.Common.Math.b2Vec2(0, -(4.5 / Settings.RATIO)));
+
+        var fixtureDef = new Box2D.Dynamics.b2FixtureDef();
+        fixtureDef.shape = deckShape;
+
+        var offset = 4,
+            factor = 80;
+        var density = ((this.options.weight + offset) / this.options.width / this.options.height) * factor;
+        fixtureDef.density = density;
+        fixtureDef.friction = Settings.ITEM_FRICTION;
+        fixtureDef.restitution = 0.2;
+        fixtureDef.isSensor = false;
+
+        this.body.CreateFixture(fixtureDef);
+
+
+        this.addWheel(
+            -8,
+            -2.5
+        );
+
+        this.addWheel(
+            7,
+            -2.5
+        );
+
+    };
+
+    Skateboard.prototype.addWheel = function(x, y) {
+        Assert.number(x, y);
+
+    	var bodyDef = new Box2D.Dynamics.b2BodyDef();
+        bodyDef.type = Box2D.Dynamics.b2Body.b2_dynamicBody;
+        bodyDef.position.x = x / Settings.RATIO;
+        bodyDef.position.y = y / Settings.RATIO;
+        bodyDef.angle = 0;
+
+    	var wheelShape = new Box2D.Collision.Shapes.b2CircleShape();
+        wheelShape.SetRadius(2.5 / Settings.RATIO);
+        wheelShape.SetLocalPosition(new Box2D.Common.Math.b2Vec2(x / Settings.RATIO, y / Settings.RATIO));
+
+
+        var fixtureDef = new Box2D.Dynamics.b2FixtureDef();
+        var offset = 4,
+            factor = 80;
+        var density = ((0.1 + offset) / 3 / 3) * factor;
+        fixtureDef.density = density;
+        fixtureDef.shape = wheelShape;
+        fixtureDef.restitution = 0.2;
+        fixtureDef.isSensor = false;
+        fixtureDef.friction = 0.0005;
+
+        this.body.CreateFixture(fixtureDef);
+    };
+
+    Skateboard.prototype.flip = function(direction) {
+        this.flipDirection = direction;
+    };
+ 
+    return Skateboard;
+ 
+});
+
+
+/*
+define([
+    "Game/" + GLOBALS.context + "/GameObjects/Item",
+    "Lib/Vendor/Box2D",
+    "Game/Config/Settings",
+    "Lib/Utilities/Assert"
+],
+ 
+function (Parent, Box2D, Settings, Assert) {
+
+    "use strict";
+ 
+    function Skateboard(physicsEngine, uid, options) {
+
+        Parent.call(this, physicsEngine, uid, options);
 
         this.wheels = [
-        	this.addWheel(
-        		options.x + 8,
-        		options.y - 1.5
-        	),
-        	this.addWheel(
-        		options.x - 8,
-        		options.y - 1.5
-        	)
+            this.addWheel(
+                options.x + 8,
+                options.y - 1.5
+            ),
+            this.addWheel(
+                options.x - 8,
+                options.y - 1.5
+            )
         ];
     }
 
@@ -53,13 +143,13 @@ function (Parent, Box2D, Settings, Assert) {
     Skateboard.prototype.addWheel = function(x, y) {
         Assert.number(x, y);
 
-    	var bodyDef = new Box2D.Dynamics.b2BodyDef();
+        var bodyDef = new Box2D.Dynamics.b2BodyDef();
         bodyDef.type = Box2D.Dynamics.b2Body.b2_dynamicBody;
         bodyDef.position.x = x / Settings.RATIO;
         bodyDef.position.y = y / Settings.RATIO;
         bodyDef.angle = 0;
 
-    	var wheelShape = new Box2D.Collision.Shapes.b2CircleShape();
+        var wheelShape = new Box2D.Collision.Shapes.b2CircleShape();
         wheelShape.SetRadius(1.5 / Settings.RATIO);
         wheelShape.SetLocalPosition(new Box2D.Common.Math.b2Vec2(0, 0));
 
@@ -75,18 +165,18 @@ function (Parent, Box2D, Settings, Assert) {
         var wheelBody = this.body.GetWorld().CreateBody(bodyDef);
         wheelBody.CreateFixture(fixtureDef);
             
-		//var revoluteJointDef = new Box2D.Dynamics.Joints.b2RevoluteJointDef();
+        //var revoluteJointDef = new Box2D.Dynamics.Joints.b2RevoluteJointDef();
         var revoluteJointDef = new Box2D.Dynamics.Joints.b2WeldJointDef();
-		//revoluteJointDef.enableMotor = false;
+        //revoluteJointDef.enableMotor = false;
 
 
 
-		revoluteJointDef.Initialize(this.body, wheelBody, wheelBody.GetWorldCenter());
-		var j = this.body.GetWorld().CreateJoint(revoluteJointDef);
+        revoluteJointDef.Initialize(this.body, wheelBody, wheelBody.GetWorldCenter());
+        var j = this.body.GetWorld().CreateJoint(revoluteJointDef);
 
 
-		// FIXME this means, that we will have bodies in the world, which must not be
-		// updated (wheels) because they are always connected to a body which will be updated.
+        // FIXME this means, that we will have bodies in the world, which must not be
+        // updated (wheels) because they are always connected to a body which will be updated.
         return wheelBody;
     };
 
@@ -116,4 +206,5 @@ function (Parent, Box2D, Settings, Assert) {
  
     return Skateboard;
  
-});
+});
+*/

app/Game/Core/GameObjects/Tile.js

@@ -7,7 +7,7 @@ define([
     "Lib/Utilities/Assert"
 ],
  
-function (Parent, Box2D, Settings, Exception, Nc, Assert) {
+function (Parent, Box2D, Settings, Exception, nc, Assert) {
 
 	"use strict";
  
@@ -15,8 +15,6 @@ function (Parent, Box2D, Settings, Exception, Nc, Assert) {
     	this.options = options;
     	Parent.call(this, physicsEngine, uid);
     	this.createPhysicTile(this.options);
-
-        Nc.trigger(Nc.ns.core.game.gameObject.add, "fixed", this);
     }
 
     Tile.prototype = Object.create(Parent.prototype);
@@ -119,10 +117,6 @@ function (Parent, Box2D, Settings, Exception, Nc, Assert) {
     Tile.prototype.addVec = function (vs, m1, m2) {
         return vs.push(new Box2D.Common.Math.b2Vec2(this.mkArg(m1), this.mkArg(m2)));
     };
-
-    Tile.prototype.destroy = function() {
-        Nc.trigger(Nc.ns.core.game.gameObject.remove, "fixed", this);
-    };
  
     return Tile;
  

app/Game/Core/Loader/Level.js

@@ -8,9 +8,9 @@ define([
     "Game/" + GLOBALS.context + "/GameObjects/Item",
     "Game/" + GLOBALS.context + "/GameObjects/Items/Skateboard",
     "Game/" + GLOBALS.context + "/GameObjects/Items/RagDoll",
-    "Game/" + GLOBALS.context + "/GameObjects/Items/Rube"
+    "Game/" + GLOBALS.context + "/GameObjects/Items/RubeDoll"
 
-], function (Settings, Box2D, Nc, Abstract, CollisionDetector, Tile, Item, Skateboard, RagDoll, Rube) {
+], function (Settings, Box2D, nc, Abstract, CollisionDetector, Tile, Item, Skateboard, RagDoll, RubeDoll) {
     
     "use strict";
     
@@ -25,6 +25,7 @@ define([
 
     Level.prototype.load = function (uid) {
         var self = this;
+        // FIXME: check if theres a security hazard here (user injected path)
         var path = Settings.MAPS_PATH + uid + ".json";
         this.loadLevelDataFromPath(path, function (levelData) {
             self.setup(levelData);
@@ -33,7 +34,7 @@ define([
 
     Level.prototype.setup = function(levelData) { // jshint unused:false
         this.isLoaded = true;
-        Nc.trigger(Nc.ns.core.game.events.level.loaded);
+        nc.trigger(nc.ns.core.game.events.level.loaded);
     };
 
     Level.prototype.createItems = function(options) {
@@ -46,12 +47,12 @@ define([
     Level.prototype.createItem = function(uid, options) {
 
         switch(options.type) {
-            //case "skateboard":
-            //    return new Skateboard(this.engine, uid, options);
+            case "skateboard":
+                return new Skateboard(this.engine, uid, options);
             case "ragdoll":
                 return new RagDoll(this.engine, uid, options);
-            case "rube":
-                return new Rube(this.engine, uid, options);
+            case "rubedoll":
+                return new RubeDoll(this.engine, uid, options);
             default:
                 return new Item(this.engine, uid, options);
         }

app/Game/Core/Loader/TiledLevel.js

@@ -3,7 +3,7 @@ define([
     "Game/Config/Settings", 
     "Game/Config/ItemSettings",
     "Lib/Vendor/Box2D", 
-    "Lib/Utilities/Options",
+    "Lib/Utilities/OptionsHelper",
     "Lib/Utilities/Exception",
     "Lib/Utilities/NotificationCenter",
     "Lib/Utilities/Assert",
@@ -13,7 +13,7 @@ define([
     "Game/" + GLOBALS.context + "/GameObjects/Item",
     "Game/" + GLOBALS.context + "/GameObjects/Items/Skateboard",
 
-], function (Parent, Settings, ItemSettings, Box2D, Options, Exception, Nc, Assert, AbstractLayer, CollisionDetector, Tile, Item, Skateboard) {
+], function (Parent, Settings, ItemSettings, Box2D, optionsHelper, Exception, nc, Assert, AbstractLayer, CollisionDetector, Tile, Item, Skateboard) {
     
     "use strict";
 
@@ -187,7 +187,7 @@ define([
             throw new Exception("Item name (" + name + ") cannot be found in item list");
         }
 
-        return Options.merge(ItemSettings[name], ItemSettings.Default);
+        return optionsHelper.merge(ItemSettings[name], ItemSettings.Default);
     };
 
     TiledLevel.prototype.getTileImagePath = function(gid) {

app/Game/Core/Physics/Engine.js

@@ -5,7 +5,7 @@ define([
     "Lib/Utilities/NotificationCenter"
 ],
 
-function (Settings, Box2D, CollisionDetector, Nc) {
+function (Settings, Box2D, CollisionDetector, nc) {
 
 	"use strict";
 
@@ -15,33 +15,30 @@ function (Settings, Box2D, CollisionDetector, Nc) {
             Settings.BOX2D_ALLOW_SLEEP
         );
         this.world.SetWarmStarting(true);
-        this.ground = null;
         this.lastStep = Date.now();
         this.worldQueue = [];
 
         this.ncTokens = [
-            Nc.on(Nc.ns.channel.engine.worldQueue.add, this.addToWorldQueue, this)
+            nc.on(nc.ns.channel.engine.worldQueue.add, this.addToWorldQueue, this)
         ];
     }
 
-    Engine.prototype.getWorld = function () {
-        return this.world;
-    }
-
-    Engine.prototype.getGround = function () {
-        return this.ground;
-    }
-
     Engine.prototype.setCollisionDetector = function () {
         
         var detector = new CollisionDetector(); 
         this.world.SetContactListener(detector.getListener());
     }
 
+    Engine.prototype.getWorldForRubeLoader = function() {
+        return this.world;
+    };
+
     Engine.prototype.createBody = function (bodyDef) {
-        var body = this.world.CreateBody(bodyDef);
-        if(!this.ground) this.ground = body;
-        return body;
+        return this.world.CreateBody(bodyDef);
+    }
+
+    Engine.prototype.destroyBody = function (body) {
+        return this.world.DestroyBody(body);
     }
 
     Engine.prototype.addToWorldQueue = function(callback) {
@@ -65,8 +62,8 @@ function (Settings, Box2D, CollisionDetector, Nc) {
     }
 
     Engine.prototype.destroy = function() {
+        nc.offAll(this.ncTokens);
         delete this.world;
-        Nc.offAll(this.ncTokens);
     };
 
 

app/Game/Core/Player.js

@@ -1,17 +1,19 @@
 define([
     "Game/" + GLOBALS.context + "/GameObjects/Doll",
+    "Game/" + GLOBALS.context + "/Control/PlayerController",
     "Game/Config/Settings",
     "Lib/Utilities/NotificationCenter",
     "Lib/Utilities/Exception",
+    "Lib/Utilities/ColorConverter",
     "Game/" + GLOBALS.context + "/GameObjects/SpectatorDoll",
-    "Game/" + GLOBALS.context + "/GameObjects/Items/RagDoll"
+    "Game/" + GLOBALS.context + "/GameObjects/Items/RubeDoll"
 ],
 
-function (Doll, Settings, Nc, Exception, SpectatorDoll, RagDoll) {
+function (Doll, PlayerController, Settings, nc, Exception, ColorConverter, SpectatorDoll, RubeDoll) {
 
 	"use strict";
 
-    function Player (id, physicsEngine, user) {
+    function Player (id, physicsEngine, user, revealedGameController) {
         this.stats = {
             health: 100,
             deaths: 0,
@@ -20,16 +22,21 @@ function (Doll, Settings, Nc, Exception, SpectatorDoll, RagDoll) {
 
         this.user = user;
         this.physicsEngine = physicsEngine;
-        this.playerController = null;
+        this.playerController = null; // pre-initialise with null, because client/players don't get one
         this.doll;
         this.id = id;
         this.spawned = false;
         this.holdingItem = null;
+        this.inBetweenRounds = true;
         this.spectatorDoll = new SpectatorDoll(this.physicsEngine, "spectatorDoll-" + this.id, this);
-
-        Nc.trigger(Nc.ns.core.game.gameObject.add, 'animated', this);
+        this.revealedGameController = revealedGameController;
+        this.modifierActivated = false;
     }
 
+    Player.prototype.getNickname = function() {
+        return this.user.options.nickname;
+    };
+
     Player.prototype.getActiveDoll = function() {
         if(this.spawned) {
             return this.doll;
@@ -60,7 +67,7 @@ function (Doll, Settings, Nc, Exception, SpectatorDoll, RagDoll) {
 
     Player.prototype.move = function (direction) {
         if(!this.spawned) return false;
-        this.doll.move(direction);
+        this.doll.move(direction, this.modifierActivated);
     }
 
     Player.prototype.stop = function () {
@@ -84,6 +91,16 @@ function (Doll, Settings, Nc, Exception, SpectatorDoll, RagDoll) {
         this.doll.lookAt(x, y);
     }
 
+    Player.prototype.activateModifier = function () {
+        if(!this.spawned) return false;
+        this.modifierActivated = true;
+    }
+
+    Player.prototype.deactivateModifier = function () {
+        if(!this.spawned) return false;
+        this.modifierActivated = false;
+    }
+
     Player.prototype.grab = function(item) {
         if(!this.spawned) return false;
         this.doll.grab(item);
@@ -112,6 +129,10 @@ function (Doll, Settings, Nc, Exception, SpectatorDoll, RagDoll) {
         }
 
         // prepare for creating the ragdoll
+
+        var converter = new ColorConverter();
+        var primaryColor = converter.getColorByName(this.getNickname());
+
         var options = {
             x: this.getPosition().x * Settings.RATIO, 
             y: this.getPosition().y * Settings.RATIO,
@@ -120,21 +141,23 @@ function (Doll, Settings, Nc, Exception, SpectatorDoll, RagDoll) {
             image: "chest.png",
             name: "RagDoll",
             rotation: 0,
-            type: "ragdoll",
+            type: "rubedoll",
             weight: 3,
             width: 5,
-            height: 12
+            height: 12,
+            primaryColor: primaryColor,
+            direction: this.doll.lookDirection
         };
 
-        var ragDoll = new RagDoll(this.physicsEngine, "ragDoll-" + this.id + "-" + ragDollId, options);
-        ragDoll.setVelocities(this.doll.getVelocities());
+        var rubeDoll = new RubeDoll(this.physicsEngine, "rubeDoll-" + this.id + "-" + ragDollId, options);
+        rubeDoll.setVelocities(this.doll.getVelocities());
 
         this.spawned = false;
 
         this.doll.destroy();
         this.doll = null;
 
-        this.ragDoll = ragDoll;
+        this.ragDoll = rubeDoll;
     };
 
     Player.prototype.update = function () {
@@ -150,7 +173,7 @@ function (Doll, Settings, Nc, Exception, SpectatorDoll, RagDoll) {
 
     Player.prototype.destroy = function () {
 
-        Nc.trigger(Nc.ns.core.game.gameObject.remove, 'animated', this);
+        // FIXME add destroy nc hook
 
         if(this.holdingItem) {
             var options = {
@@ -163,8 +186,10 @@ function (Doll, Settings, Nc, Exception, SpectatorDoll, RagDoll) {
         
         this.spectatorDoll.destroy();
 
+        // doll destoys itself at the end cause its a gameobject
+        // but on userLeft, the player has to destroy it.
         if(this.doll) {
-            this.doll.destroy();
+            this.doll.destroy(); 
         }
 
         if(this.playerController) {
@@ -172,9 +197,13 @@ function (Doll, Settings, Nc, Exception, SpectatorDoll, RagDoll) {
         }
     }
 
-    Player.prototype.setPlayerController = function(playerController) {
-        this.playerController = playerController;
-    }
+    Player.prototype.setInBetweenRounds = function(inBetweenRounds) {
+        this.inBetweenRounds = inBetweenRounds;
+    };
+
+    Player.prototype.isInBetweenRounds = function() {
+        return this.inBetweenRounds;
+    };
 
     return Player;
 });

app/Lib/Utilities/Matrix.js

@@ -0,0 +1,334 @@
+define([
+],
+ 
+/*
+	Stolen from Pixi V2
+*/
+
+function () {
+
+    "use strict";
+
+    /**
+	 * The Point object represents a location in a two-dimensional coordinate system, where x represents the horizontal axis and y represents the vertical axis.
+	 *
+	 * @class Point
+	 * @constructor
+	 * @param x {Number} position of the point on the x axis
+	 * @param y {Number} position of the point on the y axis
+	 */
+	var Point = function(x, y)
+	{
+	    /**
+	     * @property x
+	     * @type Number
+	     * @default 0
+	     */
+	    this.x = x || 0;
+
+	    /**
+	     * @property y
+	     * @type Number
+	     * @default 0
+	     */
+	    this.y = y || 0;
+	};
+
+	/**
+	 * Creates a clone of this point
+	 *
+	 * @method clone
+	 * @return {Point} a copy of the point
+	 */
+	Point.prototype.clone = function()
+	{
+	    return new Point(this.x, this.y);
+	};
+
+	/**
+	 * Sets the point to a new x and y position.
+	 * If y is omitted, both x and y will be set to x.
+	 * 
+	 * @method set
+	 * @param [x=0] {Number} position of the point on the x axis
+	 * @param [y=0] {Number} position of the point on the y axis
+	 */
+	Point.prototype.set = function(x, y)
+	{
+	    this.x = x || 0;
+	    this.y = y || ( (y !== 0) ? this.x : 0 ) ;
+	};
+
+	// constructor
+	Point.prototype.constructor = Point;
+ 
+	/**
+	 * @author Mat Groves http://matgroves.com/ @Doormat23
+	 */
+
+	/**
+	 * The Matrix class is now an object, which makes it a lot faster, 
+	 * here is a representation of it : 
+	 * | a | b | tx|
+	 * | c | d | ty|
+	 * | 0 | 0 | 1 |
+	 *
+	 * @class Matrix
+	 * @constructor
+	 */
+	var Matrix = function()
+	{
+	    /**
+	     * @property a
+	     * @type Number
+	     * @default 1
+	     */
+	    this.a = 1;
+
+	    /**
+	     * @property b
+	     * @type Number
+	     * @default 0
+	     */
+	    this.b = 0;
+
+	    /**
+	     * @property c
+	     * @type Number
+	     * @default 0
+	     */
+	    this.c = 0;
+
+	    /**
+	     * @property d
+	     * @type Number
+	     * @default 1
+	     */
+	    this.d = 1;
+
+	    /**
+	     * @property tx
+	     * @type Number
+	     * @default 0
+	     */
+	    this.tx = 0;
+
+	    /**
+	     * @property ty
+	     * @type Number
+	     * @default 0
+	     */
+	    this.ty = 0;
+	};
+
+	/**
+	 * Creates a Matrix object based on the given array. The Element to Matrix mapping order is as follows:
+	 *
+	 * a = array[0]
+	 * b = array[1]
+	 * c = array[3]
+	 * d = array[4]
+	 * tx = array[2]
+	 * ty = array[5]
+	 *
+	 * @method fromArray
+	 * @param array {Array} The array that the matrix will be populated from.
+	 */
+	Matrix.prototype.fromArray = function(array)
+	{
+	    this.a = array[0];
+	    this.b = array[1];
+	    this.c = array[3];
+	    this.d = array[4];
+	    this.tx = array[2];
+	    this.ty = array[5];
+	};
+
+	/**
+	 * Creates an array from the current Matrix object.
+	 *
+	 * @method toArray
+	 * @param transpose {Boolean} Whether we need to transpose the matrix or not
+	 * @return {Array} the newly created array which contains the matrix
+	 */
+	Matrix.prototype.toArray = function(transpose)
+	{
+	    if(!this.array) this.array = new Float32Array(9);
+	    var array = this.array;
+
+	    if(transpose)
+	    {
+	        array[0] = this.a;
+	        array[1] = this.b;
+	        array[2] = 0;
+	        array[3] = this.c;
+	        array[4] = this.d;
+	        array[5] = 0;
+	        array[6] = this.tx;
+	        array[7] = this.ty;
+	        array[8] = 1;
+	    }
+	    else
+	    {
+	        array[0] = this.a;
+	        array[1] = this.c;
+	        array[2] = this.tx;
+	        array[3] = this.b;
+	        array[4] = this.d;
+	        array[5] = this.ty;
+	        array[6] = 0;
+	        array[7] = 0;
+	        array[8] = 1;
+	    }
+
+	    return array;
+	};
+
+	/**
+	 * Get a new position with the current transformation applied.
+	 * Can be used to go from a child's coordinate space to the world coordinate space. (e.g. rendering)
+	 *
+	 * @method apply
+	 * @param pos {Point} The origin
+	 * @param [newPos] {Point} The point that the new position is assigned to (allowed to be same as input)
+	 * @return {Point} The new point, transformed through this matrix
+	 */
+	Matrix.prototype.apply = function(pos, newPos)
+	{
+	    newPos = newPos || new Point();
+
+	    newPos.x = this.a * pos.x + this.c * pos.y + this.tx;
+	    newPos.y = this.b * pos.x + this.d * pos.y + this.ty;
+
+	    return newPos;
+	};
+
+	/**
+	 * Get a new position with the inverse of the current transformation applied.
+	 * Can be used to go from the world coordinate space to a child's coordinate space. (e.g. input)
+	 *
+	 * @method applyInverse
+	 * @param pos {Point} The origin
+	 * @param [newPos] {Point} The point that the new position is assigned to (allowed to be same as input)
+	 * @return {Point} The new point, inverse-transformed through this matrix
+	 */
+	Matrix.prototype.applyInverse = function(pos, newPos)
+	{
+	    newPos = newPos || new Point();
+
+	    var id = 1 / (this.a * this.d + this.c * -this.b);
+	     
+	    newPos.x = this.d * id * pos.x + -this.c * id * pos.y + (this.ty * this.c - this.tx * this.d) * id;
+	    newPos.y = this.a * id * pos.y + -this.b * id * pos.x + (-this.ty * this.a + this.tx * this.b) * id;
+
+	    return newPos;
+	};
+
+	/**
+	 * Translates the matrix on the x and y.
+	 * 
+	 * @method translate
+	 * @param {Number} x
+	 * @param {Number} y
+	 * @return {Matrix} This matrix. Good for chaining method calls.
+	 **/
+	Matrix.prototype.translate = function(x, y)
+	{
+	    this.tx += x;
+	    this.ty += y;
+	    
+	    return this;
+	};
+
+	/**
+	 * Applies a scale transformation to the matrix.
+	 * 
+	 * @method scale
+	 * @param {Number} x The amount to scale horizontally
+	 * @param {Number} y The amount to scale vertically
+	 * @return {Matrix} This matrix. Good for chaining method calls.
+	 **/
+	Matrix.prototype.scale = function(x, y)
+	{
+	    this.a *= x;
+	    this.d *= y;
+	    this.c *= x;
+	    this.b *= y;
+	    this.tx *= x;
+	    this.ty *= y;
+
+	    return this;
+	};
+
+
+	/**
+	 * Applies a rotation transformation to the matrix.
+	 * @method rotate
+	 * @param {Number} angle The angle in radians.
+	 * @return {Matrix} This matrix. Good for chaining method calls.
+	 **/
+	Matrix.prototype.rotate = function(angle)
+	{
+	    var cos = Math.cos( angle );
+	    var sin = Math.sin( angle );
+
+	    var a1 = this.a;
+	    var c1 = this.c;
+	    var tx1 = this.tx;
+
+	    this.a = a1 * cos-this.b * sin;
+	    this.b = a1 * sin+this.b * cos;
+	    this.c = c1 * cos-this.d * sin;
+	    this.d = c1 * sin+this.d * cos;
+	    this.tx = tx1 * cos - this.ty * sin;
+	    this.ty = tx1 * sin + this.ty * cos;
+	 
+	    return this;
+	};
+
+	/**
+	 * Appends the given Matrix to this Matrix.
+	 * 
+	 * @method append
+	 * @param {Matrix} matrix
+	 * @return {Matrix} This matrix. Good for chaining method calls.
+	 */
+	Matrix.prototype.append = function(matrix)
+	{
+	    var a1 = this.a;
+	    var b1 = this.b;
+	    var c1 = this.c;
+	    var d1 = this.d;
+
+	    this.a  = matrix.a * a1 + matrix.b * c1;
+	    this.b  = matrix.a * b1 + matrix.b * d1;
+	    this.c  = matrix.c * a1 + matrix.d * c1;
+	    this.d  = matrix.c * b1 + matrix.d * d1;
+
+	    this.tx = matrix.tx * a1 + matrix.ty * c1 + this.tx;
+	    this.ty = matrix.tx * b1 + matrix.ty * d1 + this.ty;
+	    
+	    return this;
+	};
+
+	/**
+	 * Resets this Matix to an identity (default) matrix.
+	 * 
+	 * @method identity
+	 * @return {Matrix} This matrix. Good for chaining method calls.
+	 */
+	Matrix.prototype.identity = function()
+	{
+	    this.a = 1;
+	    this.b = 0;
+	    this.c = 0;
+	    this.d = 1;
+	    this.tx = 0;
+	    this.ty = 0;
+
+	    return this;
+	};
+ 
+    return Matrix;
+ 
+});

app/Lib/Utilities/NotificationCenter.js

@@ -7,7 +7,7 @@ function (Exception) {
 	"use strict";
 
     function populate(obj, path) {
-        path = path || "Nc.ns";
+        path = path || "nc.ns";
         for(var key in obj) {
             if(!obj.hasOwnProperty(key)) continue;
             if(obj[key] === null) {
@@ -23,7 +23,6 @@ function (Exception) {
         this.topics = {};
         this.subUid = -1;
 
-        var i = 0;
         this.ns = {
             client: {
                 pointerLock: {
@@ -41,7 +40,9 @@ function (Exception) {
                         remove: null,
                         update: null,
                         addFilter: null,
-                        removeFilter: null
+                        removeFilter: null,
+                        swapMeshIndexes: null,
+                        swapMeshes: null
                     },
                     animatedMesh: {
                         create: null
@@ -83,6 +84,10 @@ function (Exception) {
                     }
                 },
                 game: {
+                    events: {
+                        render: null,
+                        destroy: null
+                    },
                     gameStats: {
                         toggle: null
                     },
@@ -100,9 +105,9 @@ function (Exception) {
             },
             core: {
                 game: {
-                    gameObject: {
+                    worldUpdateObjects: {
                         add: null,
-                        remove: null
+                        remove: null,
                     },
                     events: {
                         level: {
@@ -132,8 +137,10 @@ function (Exception) {
                     },
                     game: {
                         player: {
-                            killed: null
-                        }
+                            killed: null,
+                            clearFingerPrints: null
+                        },
+
                     }
                 },
                 engine: {
@@ -187,17 +194,20 @@ function (Exception) {
         };
 
         populate(this.ns);
-        
     }
 
 
     NotificationCenter.prototype.validate = function(topic) {
+        if (topic === undefined) {
+            throw new Exception("Topic not registered in nc. See stack trace.");
+        }
+
         if (typeof topic === 'object') {
             throw new Exception("Topic bad format " + JSON.stringify(topic));
         }
 
-        if (topic.indexOf("Nc.ns") !== 0) {
-             throw new Exception("Topic bad format, does not begin with Nc.ns. : " + topic);
+        if (topic.indexOf("nc.ns") !== 0) {
+             throw new Exception("Topic bad format, does not begin with nc.ns. : " + topic);
         }
     };
 
@@ -239,18 +249,24 @@ function (Exception) {
 
     NotificationCenter.prototype.off = function (token) {
 
+        if(token && token.constructor === Array) {
+            this.offAll(token);
+            return;
+        }
+
         for(var m in this.topics) {
             if (this.topics[m]) {
                 for(var i = 0, j = this.topics[m].length; i < j; i++) {
                     if (this.topics[m][i].token === token) {
                         this.topics[m].splice(i, 1);
-                        return token;
+                        return;
                     }
                 }
             }
         }
     }
 
+    // should be treated as a private function - use nc.off(Array);
     NotificationCenter.prototype.offAll = function (tokens) {
         for (var i = 0; i < tokens.length; i++) {
             this.off(tokens[i]);

app/Lib/Utilities/OptionsHelper.js

@@ -6,18 +6,19 @@ function (Exception) {
 
 	"use strict";
  
-    function Options() {
+    function OptionsHelper() {
 
     }
  
-    Options.prototype.merge = function(options, preset) {
+    // FIXME we could actually use Object.assign() for merging here
+    OptionsHelper.prototype.merge = function(options, preset) {
 
     	if(!preset && !options) {
-    		throw new Exception("Options requires objects");
+    		throw new Exception("OptionsHelper requires objects");
     	}
 
     	if(preset.constructor !== Object && options.constructor !== Object) {
-    		throw new Exception("Options requires objects");
+    		throw new Exception("OptionsHelper requires objects");
     	}
 
 		if(!preset || preset.constructor !== Object) {
@@ -43,7 +44,7 @@ function (Exception) {
 				if(options[key].constructor !== Object) {
 					preset[key] = options[key];
 				} else {
-					preset[key] = Options.prototype.merge.call(this, options[key], preset[key]);
+					preset[key] = OptionsHelper.prototype.merge.call(this, options[key], preset[key]);
 				}
 			}
 		}
@@ -51,6 +52,6 @@ function (Exception) {
 		return preset;
 	}
  
-    return new Options();
- 
-});
+    return new OptionsHelper();
+
+});

app/Lib/Vendor/Box2D.js

@@ -6006,6 +6006,10 @@ Box2D.postDefs = [];
             xf = b.m_xf;
             for (f = b.GetFixtureList();
             f; f = f.m_next) {
+               // Disable drawing sensors by removing false ||
+               if (false || f.IsSensor()) {
+                  continue;
+               }
                s = f.GetShape();
                if (b.IsActive() == false) {
                   color.Set(0.5, 0.5, 0.3);

app/Lib/Vendor/RequireJs/Plugin/Json.js

@@ -0,0 +1,72 @@
+/** @license
+ * RequireJS plugin for loading JSON files
+ * - depends on Text plugin and it was HEAVILY "inspired" by it as well.
+ * Author: Miller Medeiros
+ * Version: 0.4.0 (2014/04/10)
+ * Released under the MIT license
+ */
+define(['text'], function(text){
+
+    var CACHE_BUST_QUERY_PARAM = 'bust',
+        CACHE_BUST_FLAG = '!bust',
+        jsonParse = (typeof JSON !== 'undefined' && typeof JSON.parse === 'function')? JSON.parse : function(val){
+            return eval('('+ val +')'); //quick and dirty
+        },
+        buildMap = {};
+
+    function cacheBust(url){
+        url = url.replace(CACHE_BUST_FLAG, '');
+        url += (url.indexOf('?') < 0)? '?' : '&';
+        return url + CACHE_BUST_QUERY_PARAM +'='+ Math.round(2147483647 * Math.random());
+    }
+
+    //API
+    return {
+
+        load : function(name, req, onLoad, config) {
+            if (( config.isBuild && (config.inlineJSON === false || name.indexOf(CACHE_BUST_QUERY_PARAM +'=') !== -1)) || (req.toUrl(name).indexOf('empty:') === 0)) {
+                //avoid inlining cache busted JSON or if inlineJSON:false
+                //and don't inline files marked as empty!
+                onLoad(null);
+            } else {
+                text.get(req.toUrl(name), function(data){
+                    var parsed;
+                    if (config.isBuild) {
+                        buildMap[name] = data;
+                        onLoad(data);
+                    } else {
+                        try {
+                            parsed = jsonParse(data);
+                        } catch (e) {
+                            onLoad.error(e);
+                        }
+                        onLoad(parsed);
+                    }
+                },
+                    onLoad.error, {
+                        accept: 'application/json'
+                    }
+                );
+            }
+        },
+
+        normalize : function (name, normalize) {
+            // used normalize to avoid caching references to a "cache busted" request
+            if (name.indexOf(CACHE_BUST_FLAG) !== -1) {
+                name = cacheBust(name);
+            }
+            // resolve any relative paths
+            return normalize(name);
+        },
+
+        //write method based on RequireJS official text plugin by James Burke
+        //https://github.com/jrburke/requirejs/blob/master/text.js
+        write : function(pluginName, moduleName, write){
+            if(moduleName in buildMap){
+                var content = buildMap[moduleName];
+                write('define("'+ pluginName +'!'+ moduleName +'", function(){ return '+ content +';});\n');
+            }
+        }
+
+    };
+});

app/Lib/Vendor/RequireJs/Plugin/Text.js

@@ -0,0 +1,391 @@
+/**
+ * @license RequireJS text 2.0.14 Copyright (c) 2010-2014, The Dojo Foundation All Rights Reserved.
+ * Available via the MIT or new BSD license.
+ * see: http://github.com/requirejs/text for details
+ */
+/*jslint regexp: true */
+/*global require, XMLHttpRequest, ActiveXObject,
+  define, window, process, Packages,
+  java, location, Components, FileUtils */
+
+define(['module'], function (module) {
+    'use strict';
+
+    var text, fs, Cc, Ci, xpcIsWindows,
+        progIds = ['Msxml2.XMLHTTP', 'Microsoft.XMLHTTP', 'Msxml2.XMLHTTP.4.0'],
+        xmlRegExp = /^\s*<\?xml(\s)+version=[\'\"](\d)*.(\d)*[\'\"](\s)*\?>/im,
+        bodyRegExp = /<body[^>]*>\s*([\s\S]+)\s*<\/body>/im,
+        hasLocation = typeof location !== 'undefined' && location.href,
+        defaultProtocol = hasLocation && location.protocol && location.protocol.replace(/\:/, ''),
+        defaultHostName = hasLocation && location.hostname,
+        defaultPort = hasLocation && (location.port || undefined),
+        buildMap = {},
+        masterConfig = (module.config && module.config()) || {};
+
+    text = {
+        version: '2.0.14',
+
+        strip: function (content) {
+            //Strips <?xml ...?> declarations so that external SVG and XML
+            //documents can be added to a document without worry. Also, if the string
+            //is an HTML document, only the part inside the body tag is returned.
+            if (content) {
+                content = content.replace(xmlRegExp, "");
+                var matches = content.match(bodyRegExp);
+                if (matches) {
+                    content = matches[1];
+                }
+            } else {
+                content = "";
+            }
+            return content;
+        },
+
+        jsEscape: function (content) {
+            return content.replace(/(['\\])/g, '\\$1')
+                .replace(/[\f]/g, "\\f")
+                .replace(/[\b]/g, "\\b")
+                .replace(/[\n]/g, "\\n")
+                .replace(/[\t]/g, "\\t")
+                .replace(/[\r]/g, "\\r")
+                .replace(/[\u2028]/g, "\\u2028")
+                .replace(/[\u2029]/g, "\\u2029");
+        },
+
+        createXhr: masterConfig.createXhr || function () {
+            //Would love to dump the ActiveX crap in here. Need IE 6 to die first.
+            var xhr, i, progId;
+            if (typeof XMLHttpRequest !== "undefined") {
+                return new XMLHttpRequest();
+            } else if (typeof ActiveXObject !== "undefined") {
+                for (i = 0; i < 3; i += 1) {
+                    progId = progIds[i];
+                    try {
+                        xhr = new ActiveXObject(progId);
+                    } catch (e) {}
+
+                    if (xhr) {
+                        progIds = [progId];  // so faster next time
+                        break;
+                    }
+                }
+            }
+
+            return xhr;
+        },
+
+        /**
+         * Parses a resource name into its component parts. Resource names
+         * look like: module/name.ext!strip, where the !strip part is
+         * optional.
+         * @param {String} name the resource name
+         * @returns {Object} with properties "moduleName", "ext" and "strip"
+         * where strip is a boolean.
+         */
+        parseName: function (name) {
+            var modName, ext, temp,
+                strip = false,
+                index = name.lastIndexOf("."),
+                isRelative = name.indexOf('./') === 0 ||
+                             name.indexOf('../') === 0;
+
+            if (index !== -1 && (!isRelative || index > 1)) {
+                modName = name.substring(0, index);
+                ext = name.substring(index + 1);
+            } else {
+                modName = name;
+            }
+
+            temp = ext || modName;
+            index = temp.indexOf("!");
+            if (index !== -1) {
+                //Pull off the strip arg.
+                strip = temp.substring(index + 1) === "strip";
+                temp = temp.substring(0, index);
+                if (ext) {
+                    ext = temp;
+                } else {
+                    modName = temp;
+                }
+            }
+
+            return {
+                moduleName: modName,
+                ext: ext,
+                strip: strip
+            };
+        },
+
+        xdRegExp: /^((\w+)\:)?\/\/([^\/\\]+)/,
+
+        /**
+         * Is an URL on another domain. Only works for browser use, returns
+         * false in non-browser environments. Only used to know if an
+         * optimized .js version of a text resource should be loaded
+         * instead.
+         * @param {String} url
+         * @returns Boolean
+         */
+        useXhr: function (url, protocol, hostname, port) {
+            var uProtocol, uHostName, uPort,
+                match = text.xdRegExp.exec(url);
+            if (!match) {
+                return true;
+            }
+            uProtocol = match[2];
+            uHostName = match[3];
+
+            uHostName = uHostName.split(':');
+            uPort = uHostName[1];
+            uHostName = uHostName[0];
+
+            return (!uProtocol || uProtocol === protocol) &&
+                   (!uHostName || uHostName.toLowerCase() === hostname.toLowerCase()) &&
+                   ((!uPort && !uHostName) || uPort === port);
+        },
+
+        finishLoad: function (name, strip, content, onLoad) {
+            content = strip ? text.strip(content) : content;
+            if (masterConfig.isBuild) {
+                buildMap[name] = content;
+            }
+            onLoad(content);
+        },
+
+        load: function (name, req, onLoad, config) {
+            //Name has format: some.module.filext!strip
+            //The strip part is optional.
+            //if strip is present, then that means only get the string contents
+            //inside a body tag in an HTML string. For XML/SVG content it means
+            //removing the <?xml ...?> declarations so the content can be inserted
+            //into the current doc without problems.
+
+            // Do not bother with the work if a build and text will
+            // not be inlined.
+            if (config && config.isBuild && !config.inlineText) {
+                onLoad();
+                return;
+            }
+
+            masterConfig.isBuild = config && config.isBuild;
+
+            var parsed = text.parseName(name),
+                nonStripName = parsed.moduleName +
+                    (parsed.ext ? '.' + parsed.ext : ''),
+                url = req.toUrl(nonStripName),
+                useXhr = (masterConfig.useXhr) ||
+                         text.useXhr;
+
+            // Do not load if it is an empty: url
+            if (url.indexOf('empty:') === 0) {
+                onLoad();
+                return;
+            }
+
+            //Load the text. Use XHR if possible and in a browser.
+            if (!hasLocation || useXhr(url, defaultProtocol, defaultHostName, defaultPort)) {
+                text.get(url, function (content) {
+                    text.finishLoad(name, parsed.strip, content, onLoad);
+                }, function (err) {
+                    if (onLoad.error) {
+                        onLoad.error(err);
+                    }
+                });
+            } else {
+                //Need to fetch the resource across domains. Assume
+                //the resource has been optimized into a JS module. Fetch
+                //by the module name + extension, but do not include the
+                //!strip part to avoid file system issues.
+                req([nonStripName], function (content) {
+                    text.finishLoad(parsed.moduleName + '.' + parsed.ext,
+                                    parsed.strip, content, onLoad);
+                });
+            }
+        },
+
+        write: function (pluginName, moduleName, write, config) {
+            if (buildMap.hasOwnProperty(moduleName)) {
+                var content = text.jsEscape(buildMap[moduleName]);
+                write.asModule(pluginName + "!" + moduleName,
+                               "define(function () { return '" +
+                                   content +
+                               "';});\n");
+            }
+        },
+
+        writeFile: function (pluginName, moduleName, req, write, config) {
+            var parsed = text.parseName(moduleName),
+                extPart = parsed.ext ? '.' + parsed.ext : '',
+                nonStripName = parsed.moduleName + extPart,
+                //Use a '.js' file name so that it indicates it is a
+                //script that can be loaded across domains.
+                fileName = req.toUrl(parsed.moduleName + extPart) + '.js';
+
+            //Leverage own load() method to load plugin value, but only
+            //write out values that do not have the strip argument,
+            //to avoid any potential issues with ! in file names.
+            text.load(nonStripName, req, function (value) {
+                //Use own write() method to construct full module value.
+                //But need to create shell that translates writeFile's
+                //write() to the right interface.
+                var textWrite = function (contents) {
+                    return write(fileName, contents);
+                };
+                textWrite.asModule = function (moduleName, contents) {
+                    return write.asModule(moduleName, fileName, contents);
+                };
+
+                text.write(pluginName, nonStripName, textWrite, config);
+            }, config);
+        }
+    };
+
+    if (masterConfig.env === 'node' || (!masterConfig.env &&
+            typeof process !== "undefined" &&
+            process.versions &&
+            !!process.versions.node &&
+            !process.versions['node-webkit'] &&
+            !process.versions['atom-shell'])) {
+        //Using special require.nodeRequire, something added by r.js.
+        fs = require.nodeRequire('fs');
+
+        text.get = function (url, callback, errback) {
+            try {
+                var file = fs.readFileSync(url, 'utf8');
+                //Remove BOM (Byte Mark Order) from utf8 files if it is there.
+                if (file[0] === '\uFEFF') {
+                    file = file.substring(1);
+                }
+                callback(file);
+            } catch (e) {
+                if (errback) {
+                    errback(e);
+                }
+            }
+        };
+    } else if (masterConfig.env === 'xhr' || (!masterConfig.env &&
+            text.createXhr())) {
+        text.get = function (url, callback, errback, headers) {
+            var xhr = text.createXhr(), header;
+            xhr.open('GET', url, true);
+
+            //Allow plugins direct access to xhr headers
+            if (headers) {
+                for (header in headers) {
+                    if (headers.hasOwnProperty(header)) {
+                        xhr.setRequestHeader(header.toLowerCase(), headers[header]);
+                    }
+                }
+            }
+
+            //Allow overrides specified in config
+            if (masterConfig.onXhr) {
+                masterConfig.onXhr(xhr, url);
+            }
+
+            xhr.onreadystatechange = function (evt) {
+                var status, err;
+                //Do not explicitly handle errors, those should be
+                //visible via console output in the browser.
+                if (xhr.readyState === 4) {
+                    status = xhr.status || 0;
+                    if (status > 399 && status < 600) {
+                        //An http 4xx or 5xx error. Signal an error.
+                        err = new Error(url + ' HTTP status: ' + status);
+                        err.xhr = xhr;
+                        if (errback) {
+                            errback(err);
+                        }
+                    } else {
+                        callback(xhr.responseText);
+                    }
+
+                    if (masterConfig.onXhrComplete) {
+                        masterConfig.onXhrComplete(xhr, url);
+                    }
+                }
+            };
+            xhr.send(null);
+        };
+    } else if (masterConfig.env === 'rhino' || (!masterConfig.env &&
+            typeof Packages !== 'undefined' && typeof java !== 'undefined')) {
+        //Why Java, why is this so awkward?
+        text.get = function (url, callback) {
+            var stringBuffer, line,
+                encoding = "utf-8",
+                file = new java.io.File(url),
+                lineSeparator = java.lang.System.getProperty("line.separator"),
+                input = new java.io.BufferedReader(new java.io.InputStreamReader(new java.io.FileInputStream(file), encoding)),
+                content = '';
+            try {
+                stringBuffer = new java.lang.StringBuffer();
+                line = input.readLine();
+
+                // Byte Order Mark (BOM) - The Unicode Standard, version 3.0, page 324
+                // http://www.unicode.org/faq/utf_bom.html
+
+                // Note that when we use utf-8, the BOM should appear as "EF BB BF", but it doesn't due to this bug in the JDK:
+                // http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=4508058
+                if (line && line.length() && line.charAt(0) === 0xfeff) {
+                    // Eat the BOM, since we've already found the encoding on this file,
+                    // and we plan to concatenating this buffer with others; the BOM should
+                    // only appear at the top of a file.
+                    line = line.substring(1);
+                }
+
+                if (line !== null) {
+                    stringBuffer.append(line);
+                }
+
+                while ((line = input.readLine()) !== null) {
+                    stringBuffer.append(lineSeparator);
+                    stringBuffer.append(line);
+                }
+                //Make sure we return a JavaScript string and not a Java string.
+                content = String(stringBuffer.toString()); //String
+            } finally {
+                input.close();
+            }
+            callback(content);
+        };
+    } else if (masterConfig.env === 'xpconnect' || (!masterConfig.env &&
+            typeof Components !== 'undefined' && Components.classes &&
+            Components.interfaces)) {
+        //Avert your gaze!
+        Cc = Components.classes;
+        Ci = Components.interfaces;
+        Components.utils['import']('resource://gre/modules/FileUtils.jsm');
+        xpcIsWindows = ('@mozilla.org/windows-registry-key;1' in Cc);
+
+        text.get = function (url, callback) {
+            var inStream, convertStream, fileObj,
+                readData = {};
+
+            if (xpcIsWindows) {
+                url = url.replace(/\//g, '\\');
+            }
+
+            fileObj = new FileUtils.File(url);
+
+            //XPCOM, you so crazy
+            try {
+                inStream = Cc['@mozilla.org/network/file-input-stream;1']
+                           .createInstance(Ci.nsIFileInputStream);
+                inStream.init(fileObj, 1, 0, false);
+
+                convertStream = Cc['@mozilla.org/intl/converter-input-stream;1']
+                                .createInstance(Ci.nsIConverterInputStream);
+                convertStream.init(inStream, "utf-8", inStream.available(),
+                Ci.nsIConverterInputStream.DEFAULT_REPLACEMENT_CHARACTER);
+
+                convertStream.readString(inStream.available(), readData);
+                convertStream.close();
+                inStream.close();
+                callback(readData.value);
+            } catch (e) {
+                throw new Error((fileObj && fileObj.path || '') + ': ' + e);
+            }
+        };
+    }
+    return text;
+});

app/Lib/Vendor/RubeLoader.js

@@ -152,8 +152,7 @@ function (Box2D) {
 	    if ( bodyJson.hasOwnProperty('linearVelocity') && bodyJson.linearVelocity instanceof Object )
 	        bd.linearVelocity.SetV( bodyJson.linearVelocity );
 	    if ( bodyJson.hasOwnProperty('position') && bodyJson.position instanceof Object )
-	    	bodyJson.position.y *= -1;
-	        bd.position.SetV( bodyJson.position );
+	        bd.position.SetV( this.getVectorValue(bodyJson.position) );
 	    if ( bodyJson.hasOwnProperty('awake') )
 	        bd.awake = bodyJson.awake;
 	    else
@@ -169,6 +168,7 @@ function (Box2D) {
 	        body.name = bodyJson.name;
 	    if ( bodyJson.hasOwnProperty('customProperties') )
 	        body.customProperties = bodyJson.customProperties;
+
 	    return body;
 	}
 
@@ -231,8 +231,7 @@ function (Box2D) {
 
 	RubeLoader.prototype.getVectorValue = function (val) {
 	    if ( val instanceof Object ) {
-	    	val.y *= -1;
-	        return val;
+	        return { x: val.x, y: val.y * -1 };
 	    } else {
 	        return { x:0, y:0 };
 	    }
@@ -427,7 +426,7 @@ function (Box2D) {
 
 	    var scene = {
 	    	bodies: loadedBodies,
-	    //	joints: loadedJoints
+	    	joints: loadedJoints
 	    };
 
 	    return scene;

app/Lib/Vendor/SocketIO.js

@@ -1,3 +1,3 @@
-define(["socketio"], function() {
+define(["socketio"], function(io) {
     return io;
-});
+});

app/Menu/Menu.js

@@ -1,11 +1,12 @@
 define([
+	"Game/Config/Settings",
 	"Lib/Utilities/ColorConverter",
 	"Lib/Utilities/Exception",
 	"Game/Client/PointerLockManager",
 	"Lib/Utilities/QuerySelector"
 ],
  
-function (ColorConverter, Exception, PointerLockManager, Qs) {
+function (Settings, ColorConverter, Exception, pointerLockManager, qs) {
 
 	"use strict";
 
@@ -22,28 +23,30 @@ function (ColorConverter, Exception, PointerLockManager, Qs) {
     	if(localStorage["player"]) {
 			var player = JSON.parse(localStorage["player"]);
 			if(player.nickname) {
-				Qs.$("#nick").value = player.nickname;
+				qs.$("#nick").value = player.nickname;
 			}
 		}
 
 		if(localStorage["customname"]) {
-			Qs.$("#customname").value = localStorage["customname"];
+			qs.$("#customname").value = localStorage["customname"];
 		}
+		qs.$("#scoreLimit").value = Settings.CHANNEL_DEFAULT_SCORE_LIMIT;
+		qs.$("#userLimit").value = Settings.CHANNEL_DEFAULT_MAX_USERS;
 
 
-		Qs.$("#refresh").onclick = refresh;
+		qs.$("#refresh").onclick = refresh;
 		refresh();
 		populateMaps();
 		this.channelDestructionTimeout = null;
 		this.refreshInterval = setInterval(refresh, 5000);
 
-		Qs.$("#createbutton").onclick = function() {
+		qs.$("#createbutton").onclick = function() {
 			show('#createform');
 			return false;
 		};
-		Qs.$("#quickstartbutton").onclick = quickstart;
+		qs.$("#quickstartbutton").onclick = quickstart;
 
-		var cancelButtons = Qs.$$(".cancel");
+		var cancelButtons = qs.$$(".cancel");
 		for (var i = 0; i < cancelButtons.length; i++) {
 			cancelButtons[i].onclick = function() {
 				show('#listform');
@@ -52,13 +55,13 @@ function (ColorConverter, Exception, PointerLockManager, Qs) {
 		};
 
 		this.colorConverter = new ColorConverter();
-		var c = Qs.$("#nick");
+		var c = qs.$("#nick");
 		c.onchange = c.onkeyup = c.onblur = c.onclick = this.updatePrimaryColor.bind(this);
 		this.updatePrimaryColor({target:c});
     };
 
     Menu.prototype.updatePrimaryColor = function(e) {
-    	Qs.$("#primarycolor").style.backgroundColor = "#" + this.colorConverter.getColorByName(e.target.value).toString(16);
+    	qs.$("#primarycolor").style.backgroundColor = "#" + this.colorConverter.getColorByName(e.target.value).toString(16);
     };
 
 	Menu.prototype.onRun = function(channelName, nickname) {
@@ -67,7 +70,7 @@ function (ColorConverter, Exception, PointerLockManager, Qs) {
 
 	window.onhashchange = function() {
 		if(window.location.hash) {
-			if(Qs.$("#game").style.display == "block") {
+			if(qs.$("#game").style.display == "block") {
 				window.location.reload();
 			}
 			refresh(function(list) {
@@ -125,7 +128,7 @@ function (ColorConverter, Exception, PointerLockManager, Qs) {
 							errorCallback(xhr.status, xhr.responseText);
 		                } else {
 							console.error("Ajax error: " + xhr.status + " " + xhr.responseText)
-							Qs.$("#list").innerHTML = "";
+							qs.$("#list").innerHTML = "";
 							document.body.className = "offline";				
 						}
 		            }
@@ -163,7 +166,7 @@ function (ColorConverter, Exception, PointerLockManager, Qs) {
 			html += "<tr><td colspan='3'>No channels found.</td></tr>";
 		}
 
-		Qs.$("#list").innerHTML = html;
+		qs.$("#list").innerHTML = html;
 	}
 
 	function populateMaps() {
@@ -178,15 +181,15 @@ function (ColorConverter, Exception, PointerLockManager, Qs) {
 				html += "</label></li>";
 			};
 
-			Qs.$("#maps").innerHTML = html;
+			qs.$("#maps").innerHTML = html;
 		}, function(status, responseText) {
 			console.error("getMaps error:", status, responseText);
 		});
 	}
 
-	Qs.$("form#listform").onsubmit = function(e) {
+	qs.$("form#listform").onsubmit = function(e) {
 		try {
-			var nickname = Qs.$("#nick").value;
+			var nickname = qs.$("#nick").value;
 			var channelName = getSelectedChannel();
 			join(nickname, channelName);
 		} catch(e) {
@@ -196,14 +199,14 @@ function (ColorConverter, Exception, PointerLockManager, Qs) {
 		return false;
 	}
 
-	Qs.$("form#createform").onsubmit = function(e) {
+	qs.$("form#createform").onsubmit = function(e) {
 		try {
 
 			var options = {
-				channelName: Qs.$("#customname").value,
+				channelName: qs.$("#customname").value,
 				levelUids: getSelectedMaps(),
-				maxUsers: parseInt(Qs.$("#userLimit").value, 10),
-				scoreLimit: parseInt(Qs.$("#scoreLimit").value, 10)
+				maxUsers: parseInt(qs.$("#userLimit").value, 10),
+				scoreLimit: parseInt(qs.$("#scoreLimit").value, 10)
 			};
 
 			create(options, onCreateSuccess);
@@ -214,10 +217,10 @@ function (ColorConverter, Exception, PointerLockManager, Qs) {
 		return false;
 	}
 
-	Qs.$("form#customjoinform").onsubmit = function(e) {
+	qs.$("form#customjoinform").onsubmit = function(e) {
 		try {
-			var nickname = Qs.$("#nick").value;
-			var channelName = Qs.$("#customname").value;
+			var nickname = qs.$("#nick").value;
+			var channelName = qs.$("#customname").value;
 			join(nickname, channelName);
 		} catch(e) {
 			console.error(e);
@@ -232,29 +235,29 @@ function (ColorConverter, Exception, PointerLockManager, Qs) {
 	}
 
 	function showCustomJoinForm() {
-		Qs.$("#customname").value = unescape(window.location.hash.substr(1));
-		Qs.$("#link").value = window.location.href;
+		qs.$("#customname").value = unescape(window.location.hash.substr(1));
+		qs.$("#link").value = window.location.href;
 		show("#customjoinform");
 	}
 
 	function show(id) {
-		Qs.$("#createform").style.display = "none";
-		Qs.$("#listform").style.display = "none";
-		Qs.$("#customjoinform").style.display = "none";
-		Qs.$("#game").style.display = "none";
+		qs.$("#createform").style.display = "none";
+		qs.$("#listform").style.display = "none";
+		qs.$("#customjoinform").style.display = "none";
+		qs.$("#game").style.display = "none";
 
 		if(id != "#customjoinform") {
 			history.pushState("", document.title, window.location.pathname);
 		}
 
-		Qs.$(id).style.display = "block";
+		qs.$(id).style.display = "block";
 	}
 
 	function quickstart() {
 		refresh(function(list){
 			var defaultChannelName = quickstartChannelName;
 			history.pushState("", document.title, window.location.pathname + "#" + defaultChannelName);
-			var nickname = Qs.$("#nick").value;
+			var nickname = qs.$("#nick").value;
 
 			if(!nickname) {
 				nickname = "Guest" + (Math.floor(Math.random() * 899) + 100)
@@ -265,8 +268,8 @@ function (ColorConverter, Exception, PointerLockManager, Qs) {
 				var options = {
 					channelName: defaultChannelName,
 					levelUids: getSelectedMaps(),
-					maxUsers: parseInt(Qs.$("#userLimit").value, 10),
-					scoreLimit: parseInt(Qs.$("#scoreLimit").value, 10)
+					maxUsers: parseInt(qs.$("#userLimit").value, 10),
+					scoreLimit: parseInt(qs.$("#scoreLimit").value, 10)
 				};
 
 				create(options, function() {
@@ -289,7 +292,7 @@ function (ColorConverter, Exception, PointerLockManager, Qs) {
 				alert("Your channel has timed out.");
 				window.location.href = "/";
 			} else {
-				Qs.$("#timeout").innerHTML = " within " + formatDate(diff) + " minutes";
+				qs.$("#timeout").innerHTML = " within " + formatDate(diff) + " minutes";
 			}
 		}, 1000);
 	}
@@ -389,8 +392,8 @@ function (ColorConverter, Exception, PointerLockManager, Qs) {
 			});
 
 			//window.location.href = "/game.html";
-			Qs.$("#menu").style.display = "none";
-			Qs.$("#game").style.display = "block";
+			qs.$("#menu").style.display = "none";
+			qs.$("#game").style.display = "block";
 			instance.onRun(channelName, nickname); // Dumm und dümmer
 			
 			if(instance.refreshInterval) {
@@ -401,7 +404,7 @@ function (ColorConverter, Exception, PointerLockManager, Qs) {
 				clearInterval(instance.channelDestructionTimeout);
 			}
 
-			PointerLockManager.request();
+			pointerLockManager.request();
 		}
 	}
 
@@ -423,8 +426,8 @@ function (ColorConverter, Exception, PointerLockManager, Qs) {
 		}
 	}
 
-	Qs.$("#canvas").onclick = function(){
-		PointerLockManager.request();
+	qs.$("#canvas").onclick = function(){
+		pointerLockManager.request();
 	};
  
     return Menu;

app/Server/Api.js

@@ -2,12 +2,12 @@ define([
 	"Lib/Utilities/NotificationCenter",
 	"Lib/Utilities/Protocol/Helper",
 	"Lib/Utilities/Validate",
-	"Lib/Utilities/Options",
+	"Lib/Utilities/OptionsHelper",
 	"Game/Config/Settings",
 	"fs"
 ],
  
-function (Nc, ProtocolHelper, validate, Options, Settings, FileSystem) {
+function (nc, ProtocolHelper, validate, optionsHelper, Settings, FileSystem) {
 
 	"use strict";
 
@@ -121,7 +121,7 @@ function (Nc, ProtocolHelper, validate, Options, Settings, FileSystem) {
 				scoreLimit: Settings.CHANNEL_DEFAULT_SCORE_LIMIT
 			};
 
-			options = Options.merge(options, defaultOptions);
+			options = optionsHelper.merge(options, defaultOptions);
 
 			var result = this.coordinator.createChannel(options);
 			if(result !== false) {

app/Server/Coordinator.js

@@ -5,14 +5,14 @@ define([
     "Game/Config/Settings"
 ], 
 
-function (User, PipeToChannel, Nc, Settings) {
+function (User, PipeToChannel, nc, Settings) {
 
 	"use strict";
 
     function Coordinator() {
     	this.channelPipes = {};
 
-        Nc.on(Nc.ns.server.events.controlCommand.coordinator, this.onMessage, this);
+        nc.on(nc.ns.server.events.controlCommand.coordinator, this.onMessage, this);
 
         console.checkpoint('create Coordinator');
     }

app/Server/PipeToChannel.js

@@ -3,7 +3,7 @@ define([
 	"child_process"
 ],
 
-function (Nc, childProcess) {
+function (nc, childProcess) {
 
 	"use strict";
 
@@ -57,10 +57,10 @@ function (Nc, childProcess) {
 	PipeToChannel.prototype.onMessage = function (message) {
 		switch(message.recipient) {
 			case 'coordinator':
-				Nc.trigger(Nc.ns.server.events.controlCommand.coordinator, message.data);
+				nc.trigger(nc.ns.server.events.controlCommand.coordinator, message.data);
 				break;
 			default:
-				Nc.trigger(Nc.ns.server.events.controlCommand.user + message.recipient, message.data);
+				nc.trigger(nc.ns.server.events.controlCommand.user + message.recipient, message.data);
 				break;
 		}
 		

app/Server/User.js

@@ -4,7 +4,7 @@ define([
     "Lib/Utilities/NotificationCenter"
 ],
 
-function (Parent, ProtocolHelper, Nc) {
+function (Parent, ProtocolHelper, nc) {
 
 	"use strict";
 
@@ -19,7 +19,7 @@ function (Parent, ProtocolHelper, Nc) {
         socketLink.on('message', this.onMessage.bind(this));
         socketLink.on('disconnect', this.onDisconnect.bind(this));
 
-        Nc.on(Nc.ns.server.events.controlCommand.user + this.id, this.socketLink.send, this.socketLink);
+        nc.on(nc.ns.server.events.controlCommand.user + this.id, this.socketLink.send, this.socketLink);
     }
 
     User.prototype = Object.create(Parent.prototype);
@@ -97,7 +97,7 @@ function (Parent, ProtocolHelper, Nc) {
 
     User.prototype.onPing = function(timestamp) {
         var message = ProtocolHelper.encodeCommand("pong", timestamp);
-        Nc.trigger(Nc.ns.server.events.controlCommand.user + this.id, message);
+        nc.trigger(nc.ns.server.events.controlCommand.user + this.id, message);
     };
 
     return User;

channel.js

@@ -4,7 +4,11 @@ var requirejs = require('requirejs');
 requirejs.config({
     nodeRequire: require,
     baseUrl: 'app',
-    deps: ['Lib/Utilities/Channel/Extensions']
+    deps: ['Lib/Utilities/Channel/Extensions'],
+    paths: {
+        text: 'Lib/Vendor/RequireJs/Plugin/Text',
+        json: 'Lib/Vendor/RequireJs/Plugin/Json',
+    },
 });
 
 var inspector = {};

client.js

@@ -7,6 +7,8 @@ requirejs.config({
     deps: ['Lib/Utilities/Client/Extensions'],
     waitSeconds: 0,
     paths: {
+        text: 'Lib/Vendor/RequireJs/Plugin/Text',
+        json: 'Lib/Vendor/RequireJs/Plugin/Json',
         screenfull: "/screenfull",
         chart: "/chart",
         socketio: "/socket.io/socket.io"
@@ -25,25 +27,19 @@ requirejs([
     "Menu/Menu"
 ], 
 
-function (Networker, SocketIO, Settings, Exception, Nc, Menu) {
+function (Networker, io, Settings, Exception, nc, Menu) {
 
     var menu = new Menu();
     menu.onRun = function(channelName, nickname) {
         var options = {
-            "reconnect": false,
-            "reconnection delay": 500,
-            "max reconnection attempts": 10,
-            "transports": [
-                "websocket", 
-                "flashsocket"
-            ]
+            transports: ["websocket"] // v4: only use websocket, flashsocket is gone
         };
-        var socket = SocketIO.connect("/", options);
+        var socket = io("/", options);
         var networker = new Networker(socket, channelName, nickname);
         Chuck.inspector.networker = networker;
         Chuck.inspector.settings = Settings;
-        Chuck.inspector.nc = Nc;
+        Chuck.inspector.nc = nc;
         Chuck.inspector.resetLevel = function() { networker.sendGameCommand("resetLevel"); } 
     }
     menu.init();
-});
+});

config/build-profile.js

@@ -1,6 +1,8 @@
 ({
     baseUrl: "../app",
     paths: {
+        "text": 'Lib/Vendor/RequireJs/Plugin/Text',
+        "json": 'Lib/Vendor/RequireJs/Plugin/Json',
         "screenfull": "../node_modules/screenfull/dist/screenfull",
         "socketio": "../node_modules/socket.io/node_modules/socket.io-client/dist/socket.io",
 	"chart": "../node_modules/chart.js/Chart"

lab/Worker.js

@@ -6,7 +6,7 @@ define([
     "Lib/Utilities/NotificationCenter"
 ], 
 
-function (Parent, ProtocolHelper, GameController, User, Nc) {
+function (Parent, ProtocolHelper, GameController, User) {
 
     function Worker () {
         //this.socketLink = socketLink;
@@ -40,7 +40,7 @@ function (Parent, ProtocolHelper, GameController, User, Nc) {
 			}
 		}, this);
 
-       Nc.on(Nc.ns.client.to.server.gameCommand.send, this.sendGameCommand, this);
+       nc.on(nc.ns.client.to.server.gameCommand.send, this.sendGameCommand, this);
     }
 
     Worker.prototype.sendCommand = function (command, options) {

package.json

@@ -1,7 +1,9 @@
 {
   "name": "chuck.js",
   "author": "logsol <fartman@gmx.de>",
-  "contributors": ["Jeena Paradies <spam@jeenaparadies.net> (https://jeena.net)"],
+  "contributors": [
+    "Jeena Paradies <spam@jeenaparadies.net> (https://jeena.net)"
+  ],
   "description": "Multiplayer browser jump and run game",
   "version": "0.1.0",
   "homepage": "http://chuck-game.tumblr.com/",
@@ -13,21 +15,28 @@
     "url": "https://github.com/logsol/chuck.js/issues",
     "email": "fartman@gmx.de"
   },
-  "main": "",
+  "main": "server.js",
   "dependencies": {
-    "socket.io": "= 0.9.6",
-    "node-static": ">= 0.6.0",
-    "requirejs": "= 2.0.4",
-    "node-fork": ">= 0.4.2",
-    "screenfull": ">= 1.0.4",
-    "chart.js": ">= 1.0.1"
+    "socket.io": "^4.7.4",
+    "express": "^4.18.2",
+    "requirejs": "^2.3.6",
+    "screenfull": "^6.0.2",
+    "chart.js": "^4.4.0"
+  },
+  "devDependencies": {
+    "nodemon": "^3.0.2"
   },
-  "devDependencies": {},
   "optionalDependencies": {},
-  "engine": "node >= 0.8.4",
-  "config": { "port": "1234" },
+  "engines": {
+    "node": ">=16.0.0"
+  },
+  "config": {
+    "port": "1234"
+  },
   "private": true,
   "scripts": {
+    "start": "node server.js",
+    "dev": "nodemon server.js",
     "prestart": "scripts/build.sh"
   }
 }

recordings/Quickstart-2015-03-15T19:00:28.545Z-debug_residence_stones.rec

@@ -1,98 +0,0 @@
-m1426446028547{"recipient":"channel","data":{"addUser":{"id":"7389285181034131943","nickname":"Bot1"}}}
-m1426446029119{"recipient":"7389285181034131943","data":"{\"gameCommand\":\"{\\\"clientReady\\\":null}\"}"}
-w1426446029547{"doll-7389285181034131943":{"p":{"x":26.757009396292265,"y":2.8537988666369247},"a":0,"lv":{"x":0,"y":3.686287386450715e-18},"av":0,"as":"stand","laxy":{"x":0,"y":0}},"item-6":{"p":{"x":17.676190476190477,"y":14.278214285714286},"a":0,"lv":{"x":0,"y":0},"av":0},"item-5":{"p":{"x":20.68034223796989,"y":14.27172409912905},"a":0.05645956288623199,"lv":{"x":-0.3822032971313994,"y":0.10581586623357915},"av":-0.9131901027366345},"item-4":{"p":{"x":20.210667860242594,"y":14.23713937029844},"a":0.2172662762511257,"lv":{"x":-0.4539838684349691,"y":0.056447865910879066},"av":-0.8171646189887583},"item-3":{"p":{"x":22.4,"y":14.277445638095237},"a":0,"lv":{"x":0,"y":0},"av":0},"item-2":{"p":{"x":9.013612698412686,"y":18.087738095238098},"a":0,"lv":{"x":0,"y":0},"av":0},"item-1":{"p":{"x":19.642184126984116,"y":14.278214285714286},"a":0,"lv":{"x":0,"y":0},"av":0},"item-0":{"p":{"x":19.14632479802086,"y":14.27055244283271},"a":-0.030402669209750526,"lv":{"x":0.36764627338079947,"y":0.11541986576858798},"av":0.6858739292935763}}
-w1426446030548{"doll-7389285181034131943":{"p":{"x":26.757009396292265,"y":2.8537988666369247},"a":0,"lv":{"x":0,"y":0},"av":0,"as":"stand","laxy":{"x":0,"y":0}},"item-6":{"p":{"x":17.676190476190477,"y":14.278214285714286},"a":0,"lv":{"x":0,"y":0},"av":0},"item-5":{"p":{"x":20.676956793943322,"y":14.27693273489722},"a":-0.006893630787064592,"lv":{"x":0,"y":0},"av":0},"item-4":{"p":{"x":20.200040618322713,"y":14.276203443653712},"a":-0.0004911852214511643,"lv":{"x":-0.0017410956075321858,"y":8.552005003579723e-7},"av":3.946495907847236e-17},"item-3":{"p":{"x":22.4,"y":14.277445638095237},"a":0,"lv":{"x":0,"y":0},"av":0},"item-2":{"p":{"x":9.013612698412686,"y":18.087738095238098},"a":0,"lv":{"x":0,"y":0},"av":0},"item-1":{"p":{"x":19.642184126984116,"y":14.278214285714286},"a":0,"lv":{"x":0,"y":0},"av":0},"item-0":{"p":{"x":19.147450032657666,"y":14.276009262801196},"a":0.0025201794161469693,"lv":{"x":0,"y":0},"av":0}}
-m1426446031024{"recipient":"7389285181034131943","data":"{\"gameCommand\":\"{\\\"lookAt\\\":{\\\"x\\\":-0.1,\\\"y\\\":0}}\"}"}
-m1426446031024{"recipient":"7389285181034131943","data":"{\"gameCommand\":\"{\\\"moveLeft\\\":null}\"}"}
-w1426446031550{"doll-7389285181034131943":{"p":{"x":23.369073130763105,"y":5.155903892632974},"a":0,"lv":{"x":-6.2,"y":10.122520758193609},"av":0,"as":"run","laxy":{"x":-0.1,"y":0}},"item-6":{"p":{"x":17.676190476190477,"y":14.278214285714286},"a":0,"lv":{"x":0,"y":0},"av":0},"item-5":{"p":{"x":20.676956793943322,"y":14.27693273489722},"a":-0.006893630787064592,"lv":{"x":0,"y":0},"av":0},"item-4":{"p":{"x":20.200046042197616,"y":14.276203440989589},"a":-0.0004911852214511747,"lv":{"x":0,"y":0},"av":0},"item-3":{"p":{"x":22.4,"y":14.277445638095237},"a":0,"lv":{"x":0,"y":0},"av":0},"item-2":{"p":{"x":9.013612698412686,"y":18.087738095238098},"a":0,"lv":{"x":0,"y":0},"av":0},"item-1":{"p":{"x":19.642184126984116,"y":14.278214285714286},"a":0,"lv":{"x":0,"y":0},"av":0},"item-0":{"p":{"x":19.147450032657666,"y":14.276009262801196},"a":0.0025201794161469693,"lv":{"x":0,"y":0},"av":0}}
-m1426446031695{"recipient":"7389285181034131943","data":"{\"gameCommand\":\"{\\\"mePositionStateUpdate\\\":{\\\"p\\\":{\\\"x\\\":22.546741092148903,\\\"y\\\":6.945440200409302},\\\"lv\\\":{\\\"x\\\":-6.2,\\\"y\\\":13.302715397413536}}}\"}"}
-m1426446031704{"recipient":"7389285181034131943","data":"{\"gameCommand\":\"{\\\"mePositionStateUpdate\\\":{\\\"p\\\":{\\\"x\\\":22.484989092148904,\\\"y\\\":7.080524845767541},\\\"lv\\\":{\\\"x\\\":-6.2,\\\"y\\\":13.508464535823881}}}\"}"}
-m1426446031782{"recipient":"7389285181034131943","data":"{\"gameCommand\":\"{\\\"stop\\\":null}\"}"}
-m1426446031912{"recipient":"7389285181034131943","data":"{\"gameCommand\":\"{\\\"mePositionStateUpdate\\\":{\\\"p\\\":{\\\"x\\\":21.73476374575245,\\\"y\\\":10.32390717922336},\\\"lv\\\":{\\\"x\\\":-2.3463161980324543,\\\"y\\\":17.55729589350694}}}\"}"}
-m1426446032042{"recipient":"7389285181034131943","data":"{\"gameCommand\":\"{\\\"mePositionStateUpdate\\\":{\\\"p\\\":{\\\"x\\\":21.44100843193758,\\\"y\\\":12.7671303982799},\\\"lv\\\":{\\\"x\\\":-2.227842551800874,\\\"y\\\":19.92590130886559}}}\"}"}
-m1426446032126{"recipient":"7389285181034131943","data":"{\"gameCommand\":\"{\\\"mePositionStateUpdate\\\":{\\\"p\\\":{\\\"x\\\":21.2807959597357,\\\"y\\\":14.271291852124465},\\\"lv\\\":{\\\"x\\\":0,\\\"y\\\":-2.133620078919897}}}\"}"}
-m1426446032164{"recipient":"7389285181034131943","data":"{\"gameCommand\":\"{\\\"handActionRequest\\\":{\\\"x\\\":-0.1,\\\"y\\\":0,\\\"av\\\":0}}\"}"}
-w1426446032551{"doll-7389285181034131943":{"p":{"x":21.2807959597357,"y":14.2827540733478},"a":0,"lv":{"x":0,"y":2.0808241610672144e-17},"av":0,"as":"stand","laxy":{"x":-0.1,"y":0}},"item-6":{"p":{"x":17.676190476190477,"y":14.278214285714286},"a":0,"lv":{"x":0,"y":0},"av":0},"item-5":{"p":{"x":20.92365310259284,"y":13.401801692395418},"a":-0.3,"lv":{"x":1.1578834351175484e-60,"y":1.9012546152460842e-16},"av":6.564623608182231e-48},"item-4":{"p":{"x":20.200046042197616,"y":14.276203440989589},"a":-0.0004911852214511747,"lv":{"x":0,"y":0},"av":0},"item-3":{"p":{"x":22.4,"y":14.277445638095237},"a":0,"lv":{"x":0,"y":0},"av":0},"item-2":{"p":{"x":9.013612698412686,"y":18.087738095238098},"a":0,"lv":{"x":0,"y":0},"av":0},"item-1":{"p":{"x":19.642184126984116,"y":14.278214285714286},"a":0,"lv":{"x":0,"y":0},"av":0},"item-0":{"p":{"x":19.147450032657666,"y":14.276009262801196},"a":0.0025201794161469693,"lv":{"x":0,"y":0},"av":0}}
-m1426446032607{"recipient":"7389285181034131943","data":"{\"gameCommand\":\"{\\\"jump\\\":null}\"}"}
-m1426446032783{"recipient":"7389285181034131943","data":"{\"gameCommand\":\"{\\\"lookAt\\\":{\\\"x\\\":-0.1,\\\"y\\\":0}}\"}"}
-m1426446032783{"recipient":"7389285181034131943","data":"{\"gameCommand\":\"{\\\"moveLeft\\\":null}\"}"}
-m1426446033408{"recipient":"7389285181034131943","data":"{\"gameCommand\":\"{\\\"handActionRequest\\\":{\\\"x\\\":-2,\\\"y\\\":1.1616379503624417,\\\"av\\\":-0.33531939942689776}}\"}"}
-w1426446033552{"doll-7389285181034131943":{"p":{"x":16.557991085576948,"y":12.476641521631196},"a":0,"lv":{"x":-6.2,"y":9.458269369609303},"av":0,"as":"jump","laxy":{"x":-0.1,"y":0}},"item-6":{"p":{"x":17.676190476190477,"y":14.278214285714286},"a":0,"lv":{"x":0,"y":0},"av":0},"item-5":{"p":{"x":12.048335711507379,"y":9.27107894546859},"a":-0.15313010305101882,"lv":{"x":-34.2,"y":-6.332771923395663},"av":1.0059581982806933},"item-4":{"p":{"x":20.200046042197616,"y":14.276203440989589},"a":-0.0004911852214511747,"lv":{"x":0,"y":0},"av":0},"item-3":{"p":{"x":22.4,"y":14.277445638095237},"a":0,"lv":{"x":0,"y":0},"av":0},"item-2":{"p":{"x":9.013612698412686,"y":18.087738095238098},"a":0,"lv":{"x":0,"y":0},"av":0},"item-1":{"p":{"x":19.642184126984116,"y":14.278214285714286},"a":0,"lv":{"x":0,"y":0},"av":0},"item-0":{"p":{"x":19.147450032657666,"y":14.276009262801196},"a":0.0025201794161469693,"lv":{"x":0,"y":0},"av":0}}
-m1426446033620{"recipient":"7389285181034131943","data":"{\"gameCommand\":\"{\\\"jumpStop\\\":null}\"}"}
-m1426446033708{"recipient":"7389285181034131943","data":"{\"gameCommand\":\"{\\\"stop\\\":null}\"}"}
-m1426446033764{"recipient":"7389285181034131943","data":"{\"gameCommand\":\"{\\\"mePositionStateUpdate\\\":{\\\"p\\\":{\\\"x\\\":15.545509158762231,\\\"y\\\":14.939529946319917},\\\"lv\\\":{\\\"x\\\":-2.411280442117325,\\\"y\\\":13.851923076171733}}}\"}"}
-m1426446033823{"recipient":"7389285181034131943","data":"{\"gameCommand\":\"{\\\"mePositionStateUpdate\\\":{\\\"p\\\":{\\\"x\\\":15.407720608611541,\\\"y\\\":15.786375605059586},\\\"lv\\\":{\\\"x\\\":-2.355804291795286,\\\"y\\\":15.018971297630832}}}\"}"}
-m1426446033890{"recipient":"7389285181034131943","data":"{\"gameCommand\":\"{\\\"mePositionStateUpdate\\\":{\\\"p\\\":{\\\"x\\\":15.252508070805703,\\\"y\\\":16.84788590944936},\\\"lv\\\":{\\\"x\\\":-2.2933002802534532,\\\"y\\\":16.333499883787308}}}\"}"}
-m1426446033906{"recipient":"7389285181034131943","data":"{\"gameCommand\":\"{\\\"mePositionStateUpdate\\\":{\\\"p\\\":{\\\"x\\\":15.216050100270346,\\\"y\\\":17.114162758801857},\\\"lv\\\":{\\\"x\\\":-2.278623158459831,\\\"y\\\":16.642303084531072}}}\"}"}
-m1426446034032{"recipient":"7389285181034131943","data":"{\"gameCommand\":\"{\\\"lookAt\\\":{\\\"x\\\":-0.1,\\\"y\\\":0}}\"}"}
-m1426446034032{"recipient":"7389285181034131943","data":"{\"gameCommand\":\"{\\\"moveLeft\\\":null}\"}"}
-w1426446034554{"doll-7389285181034131943":{"p":{"x":11.194618169931237,"y":18.075345972889064},"a":0,"lv":{"x":-8,"y":-0.3919449863882458},"av":0,"as":"run","laxy":{"x":-0.1,"y":0}},"item-6":{"p":{"x":17.676190476190477,"y":14.278214285714286},"a":0,"lv":{"x":0,"y":0},"av":0},"item-5":{"p":{"x":3.5543134118221587,"y":18.08462667589248},"a":25.09946829820324,"lv":{"x":-0.19007540236753293,"y":-0.061006264861284215},"av":-0.46231125937975326},"item-4":{"p":{"x":20.200046042197616,"y":14.276203440989589},"a":-0.0004911852214511747,"lv":{"x":0,"y":0},"av":0},"item-3":{"p":{"x":22.4,"y":14.277445638095237},"a":0,"lv":{"x":0,"y":0},"av":0},"item-2":{"p":{"x":9.013612698412686,"y":18.087738095238098},"a":0,"lv":{"x":0,"y":0},"av":0},"item-1":{"p":{"x":19.642184126984116,"y":14.278214285714286},"a":0,"lv":{"x":0,"y":0},"av":0},"item-0":{"p":{"x":19.147450032657666,"y":14.276009262801196},"a":0.0025201794161469693,"lv":{"x":0,"y":0},"av":0}}
-m1426446034796{"recipient":"7389285181034131943","data":"{\"gameCommand\":\"{\\\"handActionRequest\\\":{\\\"x\\\":-0.1,\\\"y\\\":0,\\\"av\\\":0}}\"}"}
-m1426446034797{"recipient":"7389285181034131943","data":"{\"gameCommand\":\"{\\\"stop\\\":null}\"}"}
-m1426446035284{"recipient":"7389285181034131943","data":"{\"gameCommand\":\"{\\\"lookAt\\\":{\\\"x\\\":0.1,\\\"y\\\":0}}\"}"}
-m1426446035284{"recipient":"7389285181034131943","data":"{\"gameCommand\":\"{\\\"moveRight\\\":null}\"}"}
-m1426446035395{"recipient":"7389285181034131943","data":"{\"gameCommand\":\"{\\\"jump\\\":null}\"}"}
-w1426446035556{"doll-7389285181034131943":{"p":{"x":10.491286858763196,"y":16.009696234603773},"a":0,"lv":{"x":6.2,"y":-10.887028542012015},"av":0,"as":"jump","laxy":{"x":0.1,"y":0}},"item-6":{"p":{"x":17.676190476190477,"y":14.278214285714286},"a":0,"lv":{"x":0,"y":0},"av":0},"item-5":{"p":{"x":3.551564486509986,"y":18.086205519078288},"a":25.13402937147234,"lv":{"x":0,"y":0},"av":0},"item-4":{"p":{"x":20.200046042197616,"y":14.276203440989589},"a":-0.0004911852214511747,"lv":{"x":0,"y":0},"av":0},"item-3":{"p":{"x":22.4,"y":14.277445638095237},"a":0,"lv":{"x":0,"y":0},"av":0},"item-2":{"p":{"x":10.824620192096528,"y":15.128743853651395},"a":0.5,"lv":{"x":6.1577922291668665,"y":-10.887028542012015},"av":-1.4981364335015035e-95},"item-1":{"p":{"x":19.642184126984116,"y":14.278214285714286},"a":0,"lv":{"x":0,"y":0},"av":0},"item-0":{"p":{"x":19.147450032657666,"y":14.276009262801196},"a":0.0025201794161469693,"lv":{"x":0,"y":0},"av":0}}
-m1426446035619{"recipient":"7389285181034131943","data":"{\"gameCommand\":\"{\\\"jumpStop\\\":null}\"}"}
-m1426446035622{"recipient":"7389285181034131943","data":"{\"gameCommand\":\"{\\\"handActionRequest\\\":{\\\"x\\\":2,\\\"y\\\":1.0402407501042503,\\\"av\\\":0.4762204811665006}}\"}"}
-m1426446035669{"recipient":"7389285181034131943","data":"{\"gameCommand\":\"{\\\"stop\\\":null}\"}"}
-m1426446036222{"recipient":"7389285181034131943","data":"{\"gameCommand\":\"{\\\"lookAt\\\":{\\\"x\\\":0.1,\\\"y\\\":0}}\"}"}
-m1426446036222{"recipient":"7389285181034131943","data":"{\"gameCommand\":\"{\\\"moveRight\\\":null}\"}"}
-w1426446036557{"doll-7389285181034131943":{"p":{"x":14.892865112434567,"y":18.093198012571065},"a":0,"lv":{"x":8,"y":1.1357017756785659e-17},"av":0,"as":"run","laxy":{"x":0.1,"y":0}},"item-6":{"p":{"x":17.676190476190477,"y":14.278214285714286},"a":0,"lv":{"x":0,"y":0},"av":0},"item-5":{"p":{"x":3.551564486509986,"y":18.086205519078288},"a":25.13402937147234,"lv":{"x":0,"y":0},"av":0},"item-4":{"p":{"x":20.200046042197616,"y":14.276203440989589},"a":-0.0004911852214511747,"lv":{"x":0,"y":0},"av":0},"item-3":{"p":{"x":22.4,"y":14.277445638095237},"a":0,"lv":{"x":0,"y":0},"av":0},"item-2":{"p":{"x":25.67263575288429,"y":9.396029900844805},"a":1.5453100773100037,"lv":{"x":1.2141986028185257,"y":1.5118096406061725},"av":7.842891058848907},"item-1":{"p":{"x":19.642184126984116,"y":14.278214285714286},"a":0,"lv":{"x":0,"y":0},"av":0},"item-0":{"p":{"x":19.147450032657666,"y":14.276009262801196},"a":0.0025201794161469693,"lv":{"x":0,"y":0},"av":0}}
-m1426446036597{"recipient":"7389285181034131943","data":"{\"gameCommand\":\"{\\\"jump\\\":null}\"}"}
-m1426446037146{"recipient":"7389285181034131943","data":"{\"gameCommand\":\"{\\\"jumpStop\\\":null}\"}"}
-m1426446037146{"recipient":"7389285181034131943","data":"{\"gameCommand\":\"{\\\"stop\\\":null}\"}"}
-m1426446037233{"recipient":"7389285181034131943","data":"{\"gameCommand\":\"{\\\"lookAt\\\":{\\\"x\\\":-0.1,\\\"y\\\":0}}\"}"}
-m1426446037233{"recipient":"7389285181034131943","data":"{\"gameCommand\":\"{\\\"moveLeft\\\":null}\"}"}
-w1426446037559{"doll-7389285181034131943":{"p":{"x":16.315888057006195,"y":18.09351694650934},"a":0,"lv":{"x":-8,"y":0},"av":0,"as":"run","laxy":{"x":-0.1,"y":0}},"item-6":{"p":{"x":17.676190476190477,"y":14.278214285714286},"a":0,"lv":{"x":0,"y":0},"av":0},"item-5":{"p":{"x":3.551564486509986,"y":18.086205519078288},"a":25.13402937147234,"lv":{"x":0,"y":0},"av":0},"item-4":{"p":{"x":20.200046042197616,"y":14.276203440989589},"a":-0.0004911852214511747,"lv":{"x":0,"y":0},"av":0},"item-3":{"p":{"x":22.4,"y":14.277445638095237},"a":0,"lv":{"x":0,"y":0},"av":0},"item-2":{"p":{"x":25.676240547787568,"y":9.396188210902643},"a":1.5696221500784544,"lv":{"x":0,"y":0},"av":0},"item-1":{"p":{"x":19.642184126984116,"y":14.278214285714286},"a":0,"lv":{"x":0,"y":0},"av":0},"item-0":{"p":{"x":19.147450032657666,"y":14.276009262801196},"a":0.0025201794161469693,"lv":{"x":0,"y":0},"av":0}}
-m1426446037870{"recipient":"7389285181034131943","data":"{\"gameCommand\":\"{\\\"jump\\\":null}\"}"}
-m1426446037907{"recipient":"7389285181034131943","data":"{\"gameCommand\":\"{\\\"stop\\\":null}\"}"}
-m1426446037932{"recipient":"7389285181034131943","data":"{\"gameCommand\":\"{\\\"lookAt\\\":{\\\"x\\\":0.1,\\\"y\\\":0}}\"}"}
-m1426446037933{"recipient":"7389285181034131943","data":"{\"gameCommand\":\"{\\\"moveRight\\\":null}\"}"}
-m1426446038419{"recipient":"7389285181034131943","data":"{\"gameCommand\":\"{\\\"jumpStop\\\":null}\"}"}
-m1426446038432{"recipient":"7389285181034131943","data":"{\"gameCommand\":\"{\\\"stop\\\":null}\"}"}
-m1426446038538{"recipient":"7389285181034131943","data":"{\"gameCommand\":\"{\\\"handActionRequest\\\":{\\\"x\\\":0.1,\\\"y\\\":0,\\\"av\\\":0}}\"}"}
-w1426446038561{"doll-7389285181034131943":{"p":{"x":17.1826631025223,"y":14.213702272433377},"a":0,"lv":{"x":2.316415665762817,"y":3.1852767893487735},"av":0,"as":"stand","laxy":{"x":0.1,"y":0}},"item-6":{"p":{"x":17.49218691204611,"y":13.332749891480995},"a":0.3,"lv":{"x":2.316415665762817,"y":3.1852767893487735},"av":0},"item-5":{"p":{"x":3.551564486509986,"y":18.086205519078288},"a":25.13402937147234,"lv":{"x":0,"y":0},"av":0},"item-4":{"p":{"x":20.200046042197616,"y":14.276203440989589},"a":-0.0004911852214511747,"lv":{"x":0,"y":0},"av":0},"item-3":{"p":{"x":22.4,"y":14.277445638095237},"a":0,"lv":{"x":0,"y":0},"av":0},"item-2":{"p":{"x":25.676240547787568,"y":9.396188210902643},"a":1.5696221500784544,"lv":{"x":0,"y":0},"av":0},"item-1":{"p":{"x":19.642184126984116,"y":14.278214285714286},"a":0,"lv":{"x":0,"y":0},"av":0},"item-0":{"p":{"x":19.147450032657666,"y":14.276009262801196},"a":0.0025201794161469693,"lv":{"x":0,"y":0},"av":0}}
-m1426446038958{"recipient":"7389285181034131943","data":"{\"gameCommand\":\"{\\\"lookAt\\\":{\\\"x\\\":-0.1,\\\"y\\\":0}}\"}"}
-m1426446038958{"recipient":"7389285181034131943","data":"{\"gameCommand\":\"{\\\"moveLeft\\\":null}\"}"}
-m1426446038996{"recipient":"7389285181034131943","data":"{\"gameCommand\":\"{\\\"jump\\\":null}\"}"}
-m1426446039345{"recipient":"7389285181034131943","data":"{\"gameCommand\":\"{\\\"stop\\\":null}\"}"}
-m1426446039357{"recipient":"7389285181034131943","data":"{\"gameCommand\":\"{\\\"jumpStop\\\":null}\"}"}
-w1426446039562{"doll-7389285181034131943":{"p":{"x":14.373155722224688,"y":10.923172851093172},"a":0,"lv":{"x":-2.3491405651705346,"y":3.215539708036451},"av":0,"as":"jump","laxy":{"x":-0.1,"y":0}},"item-6":{"p":{"x":14.063631912700878,"y":10.04222047014079},"a":-0.3,"lv":{"x":-2.3491405651705346,"y":3.215539708036451},"av":1.4981364335015035e-95},"item-5":{"p":{"x":3.551564486509986,"y":18.086205519078288},"a":25.13402937147234,"lv":{"x":0,"y":0},"av":0},"item-4":{"p":{"x":20.200046042197616,"y":14.276203440989589},"a":-0.0004911852214511747,"lv":{"x":0,"y":0},"av":0},"item-3":{"p":{"x":22.4,"y":14.277445638095237},"a":0,"lv":{"x":0,"y":0},"av":0},"item-2":{"p":{"x":25.676240547787568,"y":9.396188210902643},"a":1.5696221500784544,"lv":{"x":0,"y":0},"av":0},"item-1":{"p":{"x":19.642184126984116,"y":14.278214285714286},"a":0,"lv":{"x":0,"y":0},"av":0},"item-0":{"p":{"x":19.147450032657666,"y":14.276009262801196},"a":0.0025201794161469693,"lv":{"x":0,"y":0},"av":0}}
-m1426446039848{"recipient":"7389285181034131943","data":"{\"gameCommand\":\"{\\\"jump\\\":null}\"}"}
-m1426446039870{"recipient":"7389285181034131943","data":"{\"gameCommand\":\"{\\\"lookAt\\\":{\\\"x\\\":-0.1,\\\"y\\\":0}}\"}"}
-m1426446039870{"recipient":"7389285181034131943","data":"{\"gameCommand\":\"{\\\"moveLeft\\\":null}\"}"}
-m1426446039961{"recipient":"7389285181034131943","data":"{\"gameCommand\":\"{\\\"mePositionStateUpdate\\\":{\\\"p\\\":{\\\"x\\\":13.763554582654288,\\\"y\\\":9.91021111614182},\\\"lv\\\":{\\\"x\\\":-6.2,\\\"y\\\":-12.214568104301154}}}\"}"}
-m1426446040457{"recipient":"7389285181034131943","data":"{\"gameCommand\":\"{\\\"jumpStop\\\":null}\"}"}
-m1426446040491{"recipient":"7389285181034131943","data":"{\"gameCommand\":\"{\\\"stop\\\":null}\"}"}
-w1426446040564{"doll-7389285181034131943":{"p":{"x":9.827992197957391,"y":7.616287969672424},"a":0,"lv":{"x":-0.0000010315612595218654,"y":-0.3467108761433166},"av":0,"as":"stand","laxy":{"x":-0.1,"y":0}},"item-6":{"p":{"x":9.51846838843358,"y":6.735335588720043},"a":-0.3,"lv":{"x":-0.0000010315612595218745,"y":-0.3467108761433166},"av":-3.237869826367756e-34},"item-5":{"p":{"x":3.551564486509986,"y":18.086205519078288},"a":25.13402937147234,"lv":{"x":0,"y":0},"av":0},"item-4":{"p":{"x":20.200046042197616,"y":14.276203440989589},"a":-0.0004911852214511747,"lv":{"x":0,"y":0},"av":0},"item-3":{"p":{"x":22.4,"y":14.277445638095237},"a":0,"lv":{"x":0,"y":0},"av":0},"item-2":{"p":{"x":25.676240547787568,"y":9.396188210902643},"a":1.5696221500784544,"lv":{"x":0,"y":0},"av":0},"item-1":{"p":{"x":19.642184126984116,"y":14.278214285714286},"a":0,"lv":{"x":0,"y":0},"av":0},"item-0":{"p":{"x":19.147450032657666,"y":14.276009262801196},"a":0.0025201794161469693,"lv":{"x":0,"y":0},"av":0}}
-m1426446040814{"recipient":"7389285181034131943","data":"{\"gameCommand\":\"{\\\"handActionRequest\\\":{\\\"x\\\":null,\\\"y\\\":null,\\\"av\\\":0}}\"}"}
-m1426446041546{"recipient":"7389285181034131943","data":"{\"gameCommand\":\"{\\\"lookAt\\\":{\\\"x\\\":-0.1,\\\"y\\\":0}}\"}"}
-m1426446041546{"recipient":"7389285181034131943","data":"{\"gameCommand\":\"{\\\"moveLeft\\\":null}\"}"}
-w1426446041565{"doll-7389285181034131943":{"p":{"x":9.695420727381228,"y":7.6162879696953505},"a":0,"lv":{"x":-8,"y":0},"av":0,"as":"run","laxy":{"x":-0.1,"y":0}},"item-6":{"p":{"x":9.401617976491387,"y":7.516140983169705},"a":-1.564982640581702,"lv":{"x":0.0015602824631008733,"y":-0.0055646575139384315},"av":0.0151800309605853},"item-5":{"p":{"x":3.551564486509986,"y":18.086205519078288},"a":25.13402937147234,"lv":{"x":0,"y":0},"av":0},"item-4":{"p":{"x":20.200046042197616,"y":14.276203440989589},"a":-0.0004911852214511747,"lv":{"x":0,"y":0},"av":0},"item-3":{"p":{"x":22.4,"y":14.277445638095237},"a":0,"lv":{"x":0,"y":0},"av":0},"item-2":{"p":{"x":25.676240547787568,"y":9.396188210902643},"a":1.5696221500784544,"lv":{"x":0,"y":0},"av":0},"item-1":{"p":{"x":19.642184126984116,"y":14.278214285714286},"a":0,"lv":{"x":0,"y":0},"av":0},"item-0":{"p":{"x":19.147450032657666,"y":14.276009262801196},"a":0.0025201794161469693,"lv":{"x":0,"y":0},"av":0}}
-m1426446041708{"recipient":"7389285181034131943","data":"{\"gameCommand\":\"{\\\"stop\\\":null}\"}"}
-m1426446042118{"recipient":"7389285181034131943","data":"{\"gameCommand\":\"{\\\"handActionRequest\\\":{\\\"x\\\":-0.1,\\\"y\\\":0,\\\"av\\\":0}}\"}"}
-m1426446042420{"recipient":"7389285181034131943","data":"{\"gameCommand\":\"{\\\"lookAt\\\":{\\\"x\\\":-0.1,\\\"y\\\":0}}\"}"}
-m1426446042420{"recipient":"7389285181034131943","data":"{\"gameCommand\":\"{\\\"moveLeft\\\":null}\"}"}
-w1426446042568{"doll-7389285181034131943":{"p":{"x":7.146502745202811,"y":7.6190476190527345},"a":0,"lv":{"x":-8,"y":1.8167431059639174e-9},"av":0,"as":"run","laxy":{"x":-0.1,"y":0}},"item-6":{"p":{"x":6.836978935679003,"y":6.738095238100354},"a":-0.3,"lv":{"x":-7.710315253398224,"y":1.816743105963944e-9},"av":-1.2647929009154966e-36},"item-5":{"p":{"x":3.551564486509986,"y":18.086205519078288},"a":25.13402937147234,"lv":{"x":0,"y":0},"av":0},"item-4":{"p":{"x":20.200046042197616,"y":14.276203440989589},"a":-0.0004911852214511747,"lv":{"x":0,"y":0},"av":0},"item-3":{"p":{"x":22.4,"y":14.277445638095237},"a":0,"lv":{"x":0,"y":0},"av":0},"item-2":{"p":{"x":25.676240547787568,"y":9.396188210902643},"a":1.5696221500784544,"lv":{"x":0,"y":0},"av":0},"item-1":{"p":{"x":19.642184126984116,"y":14.278214285714286},"a":0,"lv":{"x":0,"y":0},"av":0},"item-0":{"p":{"x":19.147450032657666,"y":14.276009262801196},"a":0.0025201794161469693,"lv":{"x":0,"y":0},"av":0}}
-m1426446042873{"recipient":"7389285181034131943","data":"{\"gameCommand\":\"{\\\"stop\\\":null}\"}"}
-m1426446042996{"recipient":"7389285181034131943","data":"{\"gameCommand\":\"{\\\"lookAt\\\":{\\\"x\\\":0.1,\\\"y\\\":0}}\"}"}
-m1426446042996{"recipient":"7389285181034131943","data":"{\"gameCommand\":\"{\\\"moveRight\\\":null}\"}"}
-m1426446043102{"recipient":"7389285181034131943","data":"{\"gameCommand\":\"{\\\"handActionRequest\\\":{\\\"x\\\":2,\\\"y\\\":0.24735158698021256,\\\"av\\\":-0.506800103937166}}\"}"}
-m1426446043149{"recipient":"7389285181034131943","data":"{\"gameCommand\":\"{\\\"stop\\\":null}\"}"}
-w1426446043570{"doll-7389285181034131943":{"p":{"x":6.717469927715379,"y":18.026718836374023},"a":0,"lv":{"x":0,"y":-1.5933058441069676},"av":0,"as":"stand","laxy":{"x":0.1,"y":0}},"item-6":{"p":{"x":15.346920374111809,"y":8.242346533188677},"a":13.745544723304238,"lv":{"x":8.865053038008881,"y":-6.948476024418163},"av":40.16880149763361},"item-5":{"p":{"x":3.551564486509986,"y":18.086205519078288},"a":25.13402937147234,"lv":{"x":0,"y":0},"av":0},"item-4":{"p":{"x":20.200046042197616,"y":14.276203440989589},"a":-0.0004911852214511747,"lv":{"x":0,"y":0},"av":0},"item-3":{"p":{"x":22.4,"y":14.277445638095237},"a":0,"lv":{"x":0,"y":0},"av":0},"item-2":{"p":{"x":25.676240547787568,"y":9.396188210902643},"a":1.5696221500784544,"lv":{"x":0,"y":0},"av":0},"item-1":{"p":{"x":19.642184126984116,"y":14.278214285714286},"a":0,"lv":{"x":0,"y":0},"av":0},"item-0":{"p":{"x":19.147450032657666,"y":14.276009262801196},"a":0.0025201794161469693,"lv":{"x":0,"y":0},"av":0}}
-w1426446044571{"doll-7389285181034131943":{"p":{"x":6.717469927715379,"y":18.094932218730197},"a":0,"lv":{"x":0,"y":0},"av":0,"as":"stand","laxy":{"x":0.1,"y":0}},"item-6":{"p":{"x":24.736836349036146,"y":14.105602828936636},"a":53.954515022435494,"lv":{"x":8.865053038008881,"y":19.077523975581837},"av":40.16880149763361},"item-5":{"p":{"x":3.551564486509986,"y":18.086205519078288},"a":25.13402937147234,"lv":{"x":0,"y":0},"av":0},"item-4":{"p":{"x":20.200046042197616,"y":14.276203440989589},"a":-0.0004911852214511747,"lv":{"x":0,"y":0},"av":0},"item-3":{"p":{"x":22.4,"y":14.277445638095237},"a":0,"lv":{"x":0,"y":0},"av":0},"item-2":{"p":{"x":25.676240547787568,"y":9.396188210902643},"a":1.5696221500784544,"lv":{"x":0,"y":0},"av":0},"item-1":{"p":{"x":19.642184126984116,"y":14.278214285714286},"a":0,"lv":{"x":0,"y":0},"av":0},"item-0":{"p":{"x":19.147450032657666,"y":14.276009262801196},"a":0.0025201794161469693,"lv":{"x":0,"y":0},"av":0}}
-w1426446045571{"doll-7389285181034131943":{"p":{"x":6.717469927715379,"y":18.094932218730197},"a":0,"lv":{"x":0,"y":0},"av":0,"as":"stand","laxy":{"x":0.1,"y":0}},"item-6":{"p":{"x":25.484252760088392,"y":17.1308518892069},"a":56.5833675581005,"lv":{"x":0.04489757650580847,"y":-0.010299028060006578},"av":0.12321006381376746},"item-5":{"p":{"x":3.551564486509986,"y":18.086205519078288},"a":25.13402937147234,"lv":{"x":0,"y":0},"av":0},"item-4":{"p":{"x":20.200046042197616,"y":14.276203440989589},"a":-0.0004911852214511747,"lv":{"x":0,"y":0},"av":0},"item-3":{"p":{"x":22.4,"y":14.277445638095237},"a":0,"lv":{"x":0,"y":0},"av":0},"item-2":{"p":{"x":25.676240547787568,"y":9.396188210902643},"a":1.5696221500784544,"lv":{"x":0,"y":0},"av":0},"item-1":{"p":{"x":19.642184126984116,"y":14.278214285714286},"a":0,"lv":{"x":0,"y":0},"av":0},"item-0":{"p":{"x":19.147450032657666,"y":14.276009262801196},"a":0.0025201794161469693,"lv":{"x":0,"y":0},"av":0}}
-w1426446046572{"doll-7389285181034131943":{"p":{"x":6.717469927715379,"y":18.094932218730197},"a":0,"lv":{"x":0,"y":0},"av":0,"as":"stand","laxy":{"x":0.1,"y":0}},"item-6":{"p":{"x":25.484809555865787,"y":17.13345683956885},"a":56.55108306250028,"lv":{"x":0,"y":0},"av":0},"item-5":{"p":{"x":3.551564486509986,"y":18.086205519078288},"a":25.13402937147234,"lv":{"x":0,"y":0},"av":0},"item-4":{"p":{"x":20.200046042197616,"y":14.276203440989589},"a":-0.0004911852214511747,"lv":{"x":0,"y":0},"av":0},"item-3":{"p":{"x":22.4,"y":14.277445638095237},"a":0,"lv":{"x":0,"y":0},"av":0},"item-2":{"p":{"x":25.676240547787568,"y":9.396188210902643},"a":1.5696221500784544,"lv":{"x":0,"y":0},"av":0},"item-1":{"p":{"x":19.642184126984116,"y":14.278214285714286},"a":0,"lv":{"x":0,"y":0},"av":0},"item-0":{"p":{"x":19.147450032657666,"y":14.276009262801196},"a":0.0025201794161469693,"lv":{"x":0,"y":0},"av":0}}
-w1426446047573{"doll-7389285181034131943":{"p":{"x":6.717469927715379,"y":18.094932218730197},"a":0,"lv":{"x":0,"y":0},"av":0,"as":"stand","laxy":{"x":0.1,"y":0}},"item-6":{"p":{"x":25.484809555865787,"y":17.13345683956885},"a":56.55108306250028,"lv":{"x":0,"y":0},"av":0},"item-5":{"p":{"x":3.551564486509986,"y":18.086205519078288},"a":25.13402937147234,"lv":{"x":0,"y":0},"av":0},"item-4":{"p":{"x":20.200046042197616,"y":14.276203440989589},"a":-0.0004911852214511747,"lv":{"x":0,"y":0},"av":0},"item-3":{"p":{"x":22.4,"y":14.277445638095237},"a":0,"lv":{"x":0,"y":0},"av":0},"item-2":{"p":{"x":25.676240547787568,"y":9.396188210902643},"a":1.5696221500784544,"lv":{"x":0,"y":0},"av":0},"item-1":{"p":{"x":19.642184126984116,"y":14.278214285714286},"a":0,"lv":{"x":0,"y":0},"av":0},"item-0":{"p":{"x":19.147450032657666,"y":14.276009262801196},"a":0.0025201794161469693,"lv":{"x":0,"y":0},"av":0}}
-w1426446048574{"doll-7389285181034131943":{"p":{"x":6.717469927715379,"y":18.094932218730197},"a":0,"lv":{"x":0,"y":0},"av":0,"as":"stand","laxy":{"x":0.1,"y":0}},"item-6":{"p":{"x":25.484809555865787,"y":17.13345683956885},"a":56.55108306250028,"lv":{"x":0,"y":0},"av":0},"item-5":{"p":{"x":3.551564486509986,"y":18.086205519078288},"a":25.13402937147234,"lv":{"x":0,"y":0},"av":0},"item-4":{"p":{"x":20.200046042197616,"y":14.276203440989589},"a":-0.0004911852214511747,"lv":{"x":0,"y":0},"av":0},"item-3":{"p":{"x":22.4,"y":14.277445638095237},"a":0,"lv":{"x":0,"y":0},"av":0},"item-2":{"p":{"x":25.676240547787568,"y":9.396188210902643},"a":1.5696221500784544,"lv":{"x":0,"y":0},"av":0},"item-1":{"p":{"x":19.642184126984116,"y":14.278214285714286},"a":0,"lv":{"x":0,"y":0},"av":0},"item-0":{"p":{"x":19.147450032657666,"y":14.276009262801196},"a":0.0025201794161469693,"lv":{"x":0,"y":0},"av":0}}
-w1426446049575{"doll-7389285181034131943":{"p":{"x":6.717469927715379,"y":18.094932218730197},"a":0,"lv":{"x":0,"y":0},"av":0,"as":"stand","laxy":{"x":0.1,"y":0}},"item-6":{"p":{"x":25.484809555865787,"y":17.13345683956885},"a":56.55108306250028,"lv":{"x":0,"y":0},"av":0},"item-5":{"p":{"x":3.551564486509986,"y":18.086205519078288},"a":25.13402937147234,"lv":{"x":0,"y":0},"av":0},"item-4":{"p":{"x":20.200046042197616,"y":14.276203440989589},"a":-0.0004911852214511747,"lv":{"x":0,"y":0},"av":0},"item-3":{"p":{"x":22.4,"y":14.277445638095237},"a":0,"lv":{"x":0,"y":0},"av":0},"item-2":{"p":{"x":25.676240547787568,"y":9.396188210902643},"a":1.5696221500784544,"lv":{"x":0,"y":0},"av":0},"item-1":{"p":{"x":19.642184126984116,"y":14.278214285714286},"a":0,"lv":{"x":0,"y":0},"av":0},"item-0":{"p":{"x":19.147450032657666,"y":14.276009262801196},"a":0.0025201794161469693,"lv":{"x":0,"y":0},"av":0}}
-w1426446050576{"doll-7389285181034131943":{"p":{"x":6.717469927715379,"y":18.094932218730197},"a":0,"lv":{"x":0,"y":0},"av":0,"as":"stand","laxy":{"x":0.1,"y":0}},"item-6":{"p":{"x":25.484809555865787,"y":17.13345683956885},"a":56.55108306250028,"lv":{"x":0,"y":0},"av":0},"item-5":{"p":{"x":3.551564486509986,"y":18.086205519078288},"a":25.13402937147234,"lv":{"x":0,"y":0},"av":0},"item-4":{"p":{"x":20.200046042197616,"y":14.276203440989589},"a":-0.0004911852214511747,"lv":{"x":0,"y":0},"av":0},"item-3":{"p":{"x":22.4,"y":14.277445638095237},"a":0,"lv":{"x":0,"y":0},"av":0},"item-2":{"p":{"x":25.676240547787568,"y":9.396188210902643},"a":1.5696221500784544,"lv":{"x":0,"y":0},"av":0},"item-1":{"p":{"x":19.642184126984116,"y":14.278214285714286},"a":0,"lv":{"x":0,"y":0},"av":0},"item-0":{"p":{"x":19.147450032657666,"y":14.276009262801196},"a":0.0025201794161469693,"lv":{"x":0,"y":0},"av":0}}
-m1426446051478{"recipient":"channel","data":{"releaseUser":"7389285181034131943"}}
-w1426446051575{"item-6":{"p":{"x":25.484809555865787,"y":17.13345683956885},"a":56.55108306250028,"lv":{"x":0,"y":0},"av":0},"item-5":{"p":{"x":3.551564486509986,"y":18.086205519078288},"a":25.13402937147234,"lv":{"x":0,"y":0},"av":0},"item-4":{"p":{"x":20.200046042197616,"y":14.276203440989589},"a":-0.0004911852214511747,"lv":{"x":0,"y":0},"av":0},"item-3":{"p":{"x":22.4,"y":14.277445638095237},"a":0,"lv":{"x":0,"y":0},"av":0},"item-2":{"p":{"x":25.676240547787568,"y":9.396188210902643},"a":1.5696221500784544,"lv":{"x":0,"y":0},"av":0},"item-1":{"p":{"x":19.642184126984116,"y":14.278214285714286},"a":0,"lv":{"x":0,"y":0},"av":0},"item-0":{"p":{"x":19.147450032657666,"y":14.276009262801196},"a":0.0025201794161469693,"lv":{"x":0,"y":0},"av":0}}
-w1426446052576{"item-6":{"p":{"x":25.484809555865787,"y":17.13345683956885},"a":56.55108306250028,"lv":{"x":0,"y":0},"av":0},"item-5":{"p":{"x":3.551564486509986,"y":18.086205519078288},"a":25.13402937147234,"lv":{"x":0,"y":0},"av":0},"item-4":{"p":{"x":20.200046042197616,"y":14.276203440989589},"a":-0.0004911852214511747,"lv":{"x":0,"y":0},"av":0},"item-3":{"p":{"x":22.4,"y":14.277445638095237},"a":0,"lv":{"x":0,"y":0},"av":0},"item-2":{"p":{"x":25.676240547787568,"y":9.396188210902643},"a":1.5696221500784544,"lv":{"x":0,"y":0},"av":0},"item-1":{"p":{"x":19.642184126984116,"y":14.278214285714286},"a":0,"lv":{"x":0,"y":0},"av":0},"item-0":{"p":{"x":19.147450032657666,"y":14.276009262801196},"a":0.0025201794161469693,"lv":{"x":0,"y":0},"av":0}}
-w1426446053576{"item-6":{"p":{"x":25.484809555865787,"y":17.13345683956885},"a":56.55108306250028,"lv":{"x":0,"y":0},"av":0},"item-5":{"p":{"x":3.551564486509986,"y":18.086205519078288},"a":25.13402937147234,"lv":{"x":0,"y":0},"av":0},"item-4":{"p":{"x":20.200046042197616,"y":14.276203440989589},"a":-0.0004911852214511747,"lv":{"x":0,"y":0},"av":0},"item-3":{"p":{"x":22.4,"y":14.277445638095237},"a":0,"lv":{"x":0,"y":0},"av":0},"item-2":{"p":{"x":25.676240547787568,"y":9.396188210902643},"a":1.5696221500784544,"lv":{"x":0,"y":0},"av":0},"item-1":{"p":{"x":19.642184126984116,"y":14.278214285714286},"a":0,"lv":{"x":0,"y":0},"av":0},"item-0":{"p":{"x":19.147450032657666,"y":14.276009262801196},"a":0.0025201794161469693,"lv":{"x":0,"y":0},"av":0}}
-w1426446054579{"item-6":{"p":{"x":25.484809555865787,"y":17.13345683956885},"a":56.55108306250028,"lv":{"x":0,"y":0},"av":0},"item-5":{"p":{"x":3.551564486509986,"y":18.086205519078288},"a":25.13402937147234,"lv":{"x":0,"y":0},"av":0},"item-4":{"p":{"x":20.200046042197616,"y":14.276203440989589},"a":-0.0004911852214511747,"lv":{"x":0,"y":0},"av":0},"item-3":{"p":{"x":22.4,"y":14.277445638095237},"a":0,"lv":{"x":0,"y":0},"av":0},"item-2":{"p":{"x":25.676240547787568,"y":9.396188210902643},"a":1.5696221500784544,"lv":{"x":0,"y":0},"av":0},"item-1":{"p":{"x":19.642184126984116,"y":14.278214285714286},"a":0,"lv":{"x":0,"y":0},"av":0},"item-0":{"p":{"x":19.147450032657666,"y":14.276009262801196},"a":0.0025201794161469693,"lv":{"x":0,"y":0},"av":0}}
-w1426446055579{"item-6":{"p":{"x":25.484809555865787,"y":17.13345683956885},"a":56.55108306250028,"lv":{"x":0,"y":0},"av":0},"item-5":{"p":{"x":3.551564486509986,"y":18.086205519078288},"a":25.13402937147234,"lv":{"x":0,"y":0},"av":0},"item-4":{"p":{"x":20.200046042197616,"y":14.276203440989589},"a":-0.0004911852214511747,"lv":{"x":0,"y":0},"av":0},"item-3":{"p":{"x":22.4,"y":14.277445638095237},"a":0,"lv":{"x":0,"y":0},"av":0},"item-2":{"p":{"x":25.676240547787568,"y":9.396188210902643},"a":1.5696221500784544,"lv":{"x":0,"y":0},"av":0},"item-1":{"p":{"x":19.642184126984116,"y":14.278214285714286},"a":0,"lv":{"x":0,"y":0},"av":0},"item-0":{"p":{"x":19.147450032657666,"y":14.276009262801196},"a":0.0025201794161469693,"lv":{"x":0,"y":0},"av":0}}
-w1426446056580{"item-6":{"p":{"x":25.484809555865787,"y":17.13345683956885},"a":56.55108306250028,"lv":{"x":0,"y":0},"av":0},"item-5":{"p":{"x":3.551564486509986,"y":18.086205519078288},"a":25.13402937147234,"lv":{"x":0,"y":0},"av":0},"item-4":{"p":{"x":20.200046042197616,"y":14.276203440989589},"a":-0.0004911852214511747,"lv":{"x":0,"y":0},"av":0},"item-3":{"p":{"x":22.4,"y":14.277445638095237},"a":0,"lv":{"x":0,"y":0},"av":0},"item-2":{"p":{"x":25.676240547787568,"y":9.396188210902643},"a":1.5696221500784544,"lv":{"x":0,"y":0},"av":0},"item-1":{"p":{"x":19.642184126984116,"y":14.278214285714286},"a":0,"lv":{"x":0,"y":0},"av":0},"item-0":{"p":{"x":19.147450032657666,"y":14.276009262801196},"a":0.0025201794161469693,"lv":{"x":0,"y":0},"av":0}}
-w1426446057580{"item-6":{"p":{"x":25.484809555865787,"y":17.13345683956885},"a":56.55108306250028,"lv":{"x":0,"y":0},"av":0},"item-5":{"p":{"x":3.551564486509986,"y":18.086205519078288},"a":25.13402937147234,"lv":{"x":0,"y":0},"av":0},"item-4":{"p":{"x":20.200046042197616,"y":14.276203440989589},"a":-0.0004911852214511747,"lv":{"x":0,"y":0},"av":0},"item-3":{"p":{"x":22.4,"y":14.277445638095237},"a":0,"lv":{"x":0,"y":0},"av":0},"item-2":{"p":{"x":25.676240547787568,"y":9.396188210902643},"a":1.5696221500784544,"lv":{"x":0,"y":0},"av":0},"item-1":{"p":{"x":19.642184126984116,"y":14.278214285714286},"a":0,"lv":{"x":0,"y":0},"av":0},"item-0":{"p":{"x":19.147450032657666,"y":14.276009262801196},"a":0.0025201794161469693,"lv":{"x":0,"y":0},"av":0}}

scripts/core_analyzer.js

@@ -0,0 +1,247 @@
+/*
+ * This will generate a core/channel/client overview of a class
+ *
+ * usage: 
+ * node scripts/core_analyzer.js [relative/path/class.js] -> relative path from core/client/channel split
+ *
+ * example:
+ * node scripts/core_analyzer.js GameObjects/Item.js
+ * 
+ * example result: 
+ * 
+ * | CHANNEL                               | CORE                                  | CLIENT
+ * |---------------------------------------|---------------------------------------|--------------------------------
+ * |                                       | getBodyDef                            |
+ * |                                       | getFixtureDef                         |
+ * |                                       | createFixture                         |
+ * |                                       | flip                                  | flip
+ * | beingGrabbed                          | beingGrabbed                          |
+ * | beingReleased                         | beingReleased                         |
+ * | onCollisionChange                     | onCollisionChange                     |
+ * |                                       | reposition                            |
+ * |                                       | getGrabPoint                          |
+ * |                                       | throw                                 |
+ * |                                       | accelerateBody                        |
+ * |                                       | destroy                               | destroy
+ * |                                       |                                       | createMesh
+ * |                                       |                                       | render
+ * | getLastMovedBy                        |                                       |
+ * | setLastMovedBy                        |                                       |
+ * | isGrabbingAllowed                     |                                       |
+ * | isReleasingAllowed                    |                                       |
+ *
+ */
+
+var fs = require('fs');
+var util = require('util');
+var esprima = require('esprima');
+var escodegen = require('escodegen');
+
+var info = [];
+var overview = {};
+
+var generatorOption =     {
+    format: {
+        indent: {
+            style: '    ',
+            base: 0,
+            adjustMultilineComment: true//false
+        },
+        newline: '\n',
+        space: ' ',
+        json: false,
+        renumber: false,
+        hexadecimal: false,
+        quotes: 'single',
+        escapeless: false,
+        compact: false,
+        parentheses: true,
+        semicolons: true,
+        safeConcatenation: true
+    },
+    moz: {
+        starlessGenerator: false,
+        parenthesizedComprehensionBlock: false,
+        comprehensionExpressionStartsWithAssignment: false
+    },
+    parse: null,
+    comment: true,
+    sourceMap: undefined,
+    sourceMapRoot: null,
+    sourceMapWithCode: false,
+    file: undefined,
+    directive: false,
+    verbatim: undefined
+};
+
+function readFile (path, category, fileName) {
+    //console.log("+++++ " + moduleName + " ++++++");
+    var contents = fs.readFileSync(path + "/" + category + "/" + fileName); 
+    contents = contents.toString(); 
+    
+    getMethods(path, fileName, contents, category);
+}
+
+function getMethods (path, fileName, contents, category) {
+
+    category = category.toLowerCase();
+
+    overview[category] = [];
+
+    var fullPath = path + "/" + fileName;
+    var moduleName = fileName.split(".js").join("");
+    var tree = esprima.parse(contents);
+
+    // find moduleId from return statement on module level
+    var module = tree.body[0].expression.arguments[1].body.body;
+    var moduleId = findModuleId(module);
+
+    if (!moduleId) {
+        info.push("could not find moduleId in: " + fullPath);
+        return;
+    }
+
+    if (moduleId == "Parent") {
+        info.push("not optimizing empty module (returning Parent) in: " + fullPath);
+        return;
+    }
+
+    // find constructor
+    var constructorPosition = findConstructorPosition(module, moduleId);
+    if (constructorPosition === false) {
+        info.push("could not find constructor in: " + fileName)
+        return;
+    }
+    var constructor = module[constructorPosition];
+
+
+
+    for (var j = 0; j < module.length; j++) {
+        var expression = module[j];
+
+        if (expression.type == "ExpressionStatement") {
+            if(expression.expression && expression.expression.right) {
+                if(expression.expression.right.type == "FunctionExpression") {
+                    overview[category].push(expression.expression.left.property.name);
+                }
+            }
+        }
+    }
+
+    //console.log(escodegen.generate(tree, generatorOption));
+}
+
+function findModuleId (module) {
+    var moduleId = false;
+    for (var j = 0; j < module.length; j++) {
+        var expression = module[j];
+
+        //console.log(util.inspect(expression, { showHidden: true, depth: 4 }));
+
+        if (expression.type == "ReturnStatement") {
+            
+            if(expression.argument.type == "Identifier") {
+
+                // for return Module;
+                moduleId = expression.argument.name; 
+                break;
+
+            } else if (expression.argument.type == "NewExpression") {
+
+                // for return new Module;
+                moduleId = expression.argument.callee.name; 
+                break;
+
+            } else {
+                info.push("Unexpected return type at module level. " + fullPath)
+            }
+        }
+    }
+    return moduleId;
+};
+
+function findConstructorPosition (module, moduleId) {
+
+    for (var j = 0; j < module.length; j++) {
+        var expression = module[j];
+
+        if (expression.type == "FunctionDeclaration" && expression.id.name == moduleId) {
+            return j;
+        }
+    }
+    return false;
+}
+
+
+var superOverview = {};
+function display (category) {
+
+    var all = ["core", "client", "channel"];
+    var removeIndex = all.indexOf(category);
+    all.splice(removeIndex, 1);
+
+    for (var k in overview[category]) {
+
+        var name = overview[category][k];
+
+        if(superOverview.hasOwnProperty(name)) {
+            continue;
+        }
+
+        var first = all[0];
+        var second = all[1];
+
+        fv = 0 + (overview[first].indexOf(name) !== -1);
+        sv = 0 + (overview[second].indexOf(name) !== -1);
+
+        superOverview[name] = {};
+
+        superOverview[name][category] = 1;
+        superOverview[name][first] = fv;
+        superOverview[name][second] = sv;
+        superOverview[name]['count'] = 1 + fv + sv;
+    }
+}
+
+function show(){
+    var alle = ['channel', 'core', 'client'];
+    console.log("| CHANNEL                               | CORE                                  | CLIENT");
+    console.log("|---------------------------------------|---------------------------------------|--------------------------------");
+    for (var method in superOverview) {
+        var line = "";
+
+        for (var i = 0; i < alle.length; i++) {
+            if (superOverview[method] && superOverview[method].hasOwnProperty(alle[i])) {
+
+                line += "| " ;
+
+                if(superOverview[method][alle[i]] === 1) {
+                    line += method;
+                    line += Array(39 - method.length).join(" ");
+                } else {
+                    line += Array(39).join(" ");
+                }
+
+                
+            } else {
+
+            }
+
+        }
+        console.log(line)        
+    }
+}
+
+
+
+readFile("app/Game", "Core", process.argv[2]);
+readFile("app/Game", "Channel", process.argv[2]);
+readFile("app/Game", "Client", process.argv[2]);
+
+display("core")
+display("client")
+display("channel")
+
+console.log("\n")
+show()
+console.log("\n")

server.js

@@ -2,6 +2,7 @@
 
 var GLOBALS = { context: "Channel" };
 var requirejs = require('requirejs');
+var fs = require('fs');
 
 var inspector;
 
@@ -25,10 +26,17 @@ var options = {
 requirejs([
     "Bootstrap/HttpServer", 
     "Bootstrap/Socket",
-    "Server/Coordinator"
+    "Server/Coordinator",
+    "Game/Config/Settings"
 ], 
 
-function (HttpServer, Socket, Coordinator) {
+function (HttpServer, Socket, Coordinator, Settings) {
+
+    var records = fs.readdirSync(Settings.CHANNEL_RECORDING_PATH);
+    if (records.length > 200) {
+        console.warn('Too many recordings!');
+    }
+
     var coordinator = new Coordinator();
     var httpServer = new HttpServer(options, coordinator);
     var socket = new Socket(httpServer.getServer(), options, coordinator);

static/html/index.html

@@ -21,17 +21,11 @@
 		<div>
 			<h2>Create your own!</h2>
 			<p><label>Name:<br> <input id="customname"></label></p>
-			<p><label>Score limit:<br> <input id="scoreLimit" type="number" value="5"></label></p>
-			<p><label>User limit:<br> <input id="userLimit" type="number" value="10"></label></p>
+			<p><label>Score limit:<br> <input id="scoreLimit" type="number" value=""></label></p>
+			<p><label>User limit:<br> <input id="userLimit" type="number" value=""></label></p>
 			<fieldset>
 				<legend>Maps</legend>
 				<ul id="maps">
-					<li>
-						<label><input name="maps" value="debug" type="checkbox" checked> Debug</label>
-					</li>
-					<li>
-						<label><input name="maps" value="stones" type="checkbox" checked> Stones</label>
-					</li>				
 				</ul>
 			</fieldset>
 
@@ -83,4 +77,4 @@
 </article>
 <script data-main="client" src="require.js"></script>
 </body>
-</html>
+</html>

static/html/not_available.html

@@ -53,7 +53,7 @@ a {
 
 <script type="text/javascript">
 
-var url = "https://api.github.com/repos/logsol/chuck.js/milestones?access_token=e54ce2084dcca03983780524fad234296cbc640a";
+var url = "https://api.github.com/repos/logsol/chuck.js/milestones?access_token=ce6b0623328e3733e160fe362d262a6b65e9cf27";
 var lookingFor = "Alpha-";
 
 $.get(url, function( data ) {
@@ -75,7 +75,7 @@ $.get(url, function( data ) {
     var progress =  parseInt(milestone.closed_issues) / (parseInt(milestone.open_issues)+parseInt(milestone.closed_issues));
     progress = Math.round(progress * 100);
 
-    $("#m-title").text(milestone.title);
+    $("#m-title").html('<a href="' + milestone.html_url + '">' + milestone.title + '</a>');
     $("#m-open").text(milestone.open_issues);
     $("#m-closed").text(milestone.closed_issues);
     $("#m-progress").text(progress + "%");

static/maps/tiled/debug.json

@@ -60,8 +60,8 @@
                  "type":"",
                  "visible":true,
                  "width":0,
-                 "x":222.535368857004,
-                 "y":170.525492560429
+                 "x":247.535368857004,
+                 "y":177.525492560429
                 }, 
                 {
                  "ellipse":true,
@@ -108,8 +108,8 @@
                  "type":"",
                  "visible":true,
                  "width":0,
-                 "x":516.282764098491,
-                 "y":128.219675479405
+                 "x":548.282764098491,
+                 "y":130.219675479405
                 }, 
                 {
                  "ellipse":true,
@@ -215,7 +215,7 @@
                 {
                  "height":0,
                  "id":10,
-                 "name":"Rube",
+                 "name":"RubeDoll",
                  "properties":
                     {
 
@@ -224,8 +224,8 @@
                  "type":"",
                  "visible":true,
                  "width":0,
-                 "x":236.607333333333,
-                 "y":471.255333333333
+                 "x":504.607333333333,
+                 "y":433.26
                 }, 
                 {
                  "height":0,
@@ -290,7 +290,7 @@
                 {
                  "height":0,
                  "id":15,
-                 "name":"Piano",
+                 "name":"Skateboard",
                  "properties":
                     {