fixes #147, fixes #136, is related to but doesnt entirely complete #144

app/Game/Channel/Channel.js

@@ -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");

app/Game/Channel/GameController.js

@@ -21,6 +21,7 @@ function (Parent, PhysicsEngine, Settings, PlayerController, requestAnimFrame, N
         this.animationTimeout = null;
         this.worldUpdateTimeout = null;
         this.spawnTimeouts = [];
+        this.roundHasEnded = false;
 
         Parent.call(this, options);
 
@@ -214,6 +215,14 @@ function (Parent, PhysicsEngine, Settings, PlayerController, requestAnimFrame, N
         this.spawnPlayer(player, 0);
     };
 
+    GameController.prototype.endRound = function() {
+        this.roundHasEnded = true;
+
+        for(var id in this.players) {
+            this.players[id].getPlayerController().setIsInBetweenGames(true);
+        }
+    };
+
     // FIXME: remove this method
     GameController.prototype.onResetLevel = function(userId) {
 

app/Game/Client/Control/PlayerController.js

@@ -27,76 +27,86 @@ 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');
     }
 
     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');
     }
 
+    // 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');
     }
 
     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');
     }
 
+    // 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');
     }
 
     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);
     };
 
     PlayerController.prototype.suicide = function() {
-        if (!PointerLockManager.isLocked()) return;
+        if (!this.isPlayerInputAllowed()) return;
         Nc.trigger(Nc.ns.client.to.server.gameCommand.send, "suicide");
     };
 
     PlayerController.prototype.handActionRequest = function(options) {
-        if (!PointerLockManager.isLocked()) return;
+        if (!this.isPlayerInputAllowed()) return;
         Nc.trigger(Nc.ns.client.to.server.gameCommand.send, "handActionRequest", options);
     };
 
     PlayerController.prototype.showInfo = function() {
-        if (!PointerLockManager.isLocked()) return;
+        if (!this.isPlayerInputAllowed()) return;
         Nc.trigger(Nc.ns.client.game.gameStats.toggle, true);
     };
 
     PlayerController.prototype.hideInfo = function() {
-        if (!PointerLockManager.isLocked()) return;
+        if (!this.isPlayerInputAllowed()) return;
         Nc.trigger(Nc.ns.client.game.gameStats.toggle, false);
     };
 
     PlayerController.prototype.zoomIn = function() {
-        if (!PointerLockManager.isLocked()) return;
+        if (!this.isPlayerInputAllowed()) return;
         Nc.trigger(Nc.ns.client.game.zoomIn, true);
     };
 
     PlayerController.prototype.zoomOut = function() {
-        if (!PointerLockManager.isLocked()) return;
+        if (!this.isPlayerInputAllowed()) return;
         Nc.trigger(Nc.ns.client.game.zoomOut, false);
     };
 
     PlayerController.prototype.zoomReset = function() {
-        if (!PointerLockManager.isLocked()) return;
+        if (!this.isPlayerInputAllowed()) return;
         Nc.trigger(Nc.ns.client.game.zoomReset, false);
     };
-    
 
+    /*
+     * 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/GameController.js

@@ -130,6 +130,10 @@ function (Parent, Box2D, PhysicsEngine, ViewManager, PlayerController, Nc, reque
     };
     */
 
+    GameController.prototype.onRemoveGameObject = function(options) {
+
+    };
+
     GameController.prototype.updateGameObject = function (gameObject, gameObjectUpdate) {
         if(gameObject === this.me.doll) {
             this.me.setLastServerPositionState(gameObjectUpdate);
@@ -252,6 +256,17 @@ function (Parent, Box2D, PhysicsEngine, ViewManager, PlayerController, Nc, reque
         Nc.trigger(Nc.ns.client.view.gameStats.toggle, show);
     };
 
+    GameController.prototype.beginRound = function() {
+        if (this.me.getPlayerController()) {
+            this.me.getPlayerController().setIsInBetweenGames(false);
+        }
+    };
+
+    GameController.prototype.endRound = function() {
+        this.me.getPlayerController().setIsInBetweenGames(true);
+        this.toggleGameStats(true);
+    };
+
     GameController.prototype.destroy = function() {
 
         if (!window.cancelAnimationFrame) {

app/Game/Client/Networker.js

@@ -196,10 +196,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/View/Pixi/GameStats.js

@@ -9,7 +9,7 @@ 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();
 
@@ -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);
         }
     }
 

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

@@ -174,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');
         }
@@ -228,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/View.js

@@ -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();
@@ -143,7 +143,8 @@ function (Parent, DomController, PIXI, Settings, Nc, Exception, GameStats, Layer
         if (!Settings.ENABLE_POINTER_LOCK_FILTER) return;
 
         if(isLocked) {
-            this.container.filters = null;
+            this.removeFilters(this.pointerLockFilters);
+            
             this.clickToEnable.visible = false;
             this.onZoomReset();
         } else {
@@ -159,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)
@@ -170,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();
         

app/Game/Config/Settings.js

@@ -39,7 +39,7 @@ function () {
         VIEW_CONTROLLER: 0 ? "Three" : "Pixi",
         ARROW_GLIDE: 30, // % of the way per frame     
         SHOW_LAYER_INFO: false,
-        ENABLE_POINTER_LOCK_FILTER: false,
+        ENABLE_POINTER_LOCK_FILTER: true,
 
         // GAME PLAY 
         WALK_SPEED: 4,
@@ -88,8 +88,8 @@ function () {
         CHANNEL_MAX_USERS: 20,
         CHANNEL_DESTRUCTION_TIME: 0.5 * 60,
         CHANNEL_END_ROUND_TIME: 20, //10,
-        CHANNEL_DEFAULT_MAX_USERS: 40,
+        CHANNEL_DEFAULT_MAX_USERS: 10,
-        CHANNEL_DEFAULT_SCORE_LIMIT: 10,
+        CHANNEL_DEFAULT_SCORE_LIMIT: 1,
         CHANNEL_DEFAULT_LEVELS: ["debug"],
         CHANNEL_RECORD_SESSION: false,
 

app/Game/Core/Control/PlayerController.js

@@ -10,14 +10,18 @@ function () {
         this._shift;
         this._isJumping;
         this._walkingDirectionStatus = 0;
+
+        this.isInBetweenGames = false;
     }
 
     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,6 +32,7 @@ function () {
     }
 
     PlayerController.prototype.jump = function () {
+        if(!this.isPlayerInputAllowed()) return;
         this._isJumping = true;
         this.player.jump();
     }
@@ -37,9 +42,18 @@ function () {
     }
 
     PlayerController.prototype.lookAt = function (options) {
+        if(!this.isPlayerInputAllowed()) return;
         if(options) this.player.lookAt(options.x, options.y);
     }
 
+    PlayerController.prototype.setIsInBetweenGames = function(isInBetweenGames) {
+        this.isInBetweenGames = !!isInBetweenGames;
+    };
+
+    PlayerController.prototype.isPlayerInputAllowed = function() {
+        return !this.isInBetweenGames;
+    };
+
     PlayerController.prototype.update = function () {
         if(this._walkingDirectionStatus != 0) {
             this.player.move(this._walkingDirectionStatus);

app/Game/Core/Player.js

@@ -187,5 +187,9 @@ function (Doll, Settings, Nc, Exception, ColorConverter, SpectatorDoll, RubeDoll
         this.playerController = playerController;
     }
 
+    Player.prototype.getPlayerController = function() {
+        return this.playerController;
+    }
+
     return Player;
 });

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";
 
@@ -29,6 +30,8 @@ function (ColorConverter, Exception, PointerLockManager, Qs) {
 		if(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;

static/html/index.html

@@ -21,8 +21,8 @@
 		<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>Score limit:<br> <input id="scoreLimit" type="number" value=""></label></p>
-			<p><label>User limit:<br> <input id="userLimit" type="number" value="10"></label></p>
+			<p><label>User limit:<br> <input id="userLimit" type="number" value=""></label></p>
 			<fieldset>
 				<legend>Maps</legend>
 				<ul id="maps">