- Added proof of concept menu (currently this can be classified as aesthetic torture!) in index.html

- Moved the entire game to game.html.
- Added public functions for switching between animations in ModelRender.
- MapParser now nicely formats entity values into JSON objects.
- Added an util class for handling mouse events similiarly to how Keyboard.js handles keyboard events.
- Implemented player-shooting-animation and player-reload-animation in Player.js
- Fixed floating point errors in collision detection

Author: Mathias

CollisionDetection.js

@@ -28,9 +28,9 @@ cs.CollisionDetection = (function() {
 		//models[0] is the geometry of the entire map
 		recursiveHullCheck(mapData.models[0].iHeadNodes[0], 0, 1,
 			vStart, vEnd, traceObj);
-		
+
 		//If ratio is still 1 we never collided with anything
-		if(traceObj.ratio == 1.0) {
+		if(traceObj.ratio === 1.0) {
 			return vEnd;
 		}
 		//Collision found
@@ -216,7 +216,8 @@ cs.CollisionDetection = (function() {
 			var x = pos[0];
 			var y = pos[1];
 			var z = pos[2];
-			return trace(pos, [x, y, z-1], false)[2] >= z;
+			var t = trace(pos, [x, y, z-1], false);
+			return Math.abs(t[2] - z) < 0.000001;
 		}
 	};
 })();

MapParser.js

@@ -80,14 +80,84 @@ cs.MapParser = (function () {
 		//Split into an array of entities
 		var entitiesArray = sEntities.split("}\n{");
 
+		//Helper formatters
+		var identity = function(x) { return x; };
+		var parseList = function(formatter) {
+			return function(x) {
+				var list = [];
+				for(var o in x.split(" ")) {
+					list.push(formatter(o));
+				}
+				return list;
+			};
+		};
+		//A map from key to value formatters.
+		var formatters = {
+			MaxRange: parseInt,
+			classname: identity,
+			light: parseInt,
+			message: identity,
+			skyname: identity,
+			sounds: parseInt,
+			wad: function(x) { return x.split(";"); },
+			model: function(x) {
+				//Most entities have a value of the form *N where N is an integer
+				//But some entities have a string value instead,
+				//(i.e path to models in case of hostages)
+				if(x[0] === "*")
+					return parseInt(x.substr(1));
+				return identity;
+			},
+			renderamt: parseInt,
+			rendercolor: new parseList(parseInt),
+			rendermode: parseInt,
+			skin: parseInt,
+			angles: new parseList(parseInt),
+			delay: parseInt,
+			distance: parseInt,
+			dmg: parseInt,
+			health: parseInt,
+			lip: parseInt,
+			locked_sentence: parseInt,
+			locked_sound: parseInt,
+			movesnd: parseInt,
+			origin: new parseList(parseInt),
+			renderfx: parseInt,
+			speed: parseInt,
+			stopsnd: parseInt,
+			unlocked_sentence: parseInt,
+			unlocked_sound: parseInt,
+			wait: parseInt,
+			_light: new parseList(parseInt),
+			pitch: parseInt,
+			angle: parseInt,
+			spawnflags: parseInt,
+			target: identity,
+			deceleration: parseInt,
+			targetname: identity,
+			explodemagnitude: parseInt,
+			explosion: parseInt,
+			material: parseInt,
+			spawnobject: parseInt,
+			texture: identity,
+			acceleration: parseInt,
+			killtarget: identity,
+			triggerstate: parseInt,
+			_fade: parseFloat
+		};
+		
 		var entityLump = Array(entitiesArray.length);
 		for(var i = 0; i < entitiesArray.length; ++i) {
 			//Get key
 			var sKeyVal = entitiesArray[i].split("\"");
 			var map = {};
 			//Create a mapping from key => value
 			for(var j = 1; j < sKeyVal.length; j += 4) {
-				map[sKeyVal[j]] = sKeyVal[j+2];
+				var key = sKeyVal[j];
+				var value = sKeyVal[j+2];
+				var formatter = formatters[key];
+				if(!formatter) console.log("Unknown entity name: " + key);
+				else map[key] = formatter(value);
 			}
 			entityLump[i] = map;
 		}

PlayerParser.js renamed to ModelParser.js

@@ -43,11 +43,12 @@ cs.ModelRender = function(gl, player) {
 		STUDIO_RLOOP:	0x8000
 	};
 
-	this.sequenceIndex = 1;
-	
+	var sequenceIndex = 0;
 	var frame = 0;
-	
+	var customFPS = null;
 	var vertexBuffer = gl.createBuffer();
+	var animationQueue = [];
+	var previous = new Date().getTime();
 
 	var fragmentShader = 
 	"	precision mediump float;" +
@@ -401,13 +402,25 @@ cs.ModelRender = function(gl, player) {
 		if(dt > 0.1) {
 			dt = 0.1;
 		}
-		frame += dt * sequence.fps;
+		frame += dt * (customFPS || sequence.fps);
 
 		if(sequence.numFrames <= 1) {
 			frame = 0;
 		}
 		else {
-			frame -= Math.floor(frame / (sequence.numFrames - 1)) * (sequence.numFrames - 1);
+			var newFrame = frame - Math.floor(frame / (sequence.numFrames - 1)) * (sequence.numFrames - 1);
+			//Did we just restart our animation?
+			if(newFrame < frame) {
+				//Do we have an animation queued up?
+				if(animationQueue.length != 0) {
+					//Yep. Set index and requested fps
+					newFrame = 0;
+					var anim = animationQueue.shift();
+					sequenceIndex = anim.index;
+					customFPS = anim.fps;
+				}
+			}
+			frame = newFrame;
 		}
 		return frame;
 	};
@@ -424,7 +437,6 @@ cs.ModelRender = function(gl, player) {
 			transforms[n] = vectorTransform([vertices[i], vertices[i+1], vertices[i+2]], transformations[model.transformIndices[n]]);
 		}
 
-		var k = 0;
 		for(var i = 0; i < model.numMesh; ++i) {
 			var mesh = model.mesh[i];
 			var texture = player.textures[DataReader.readSignedShort(player.data, player.header.skinIndex + 2*mesh.skinRef)];
@@ -460,10 +472,6 @@ cs.ModelRender = function(gl, player) {
 
 					//Add vertex
 					var vertex = transforms[vertIndex];
-					++k;
-					if(k === 130) {
-						var g = 0;
-					}
 
 					buffer.push(vertex[0]);
 					buffer.push(vertex[1]);
@@ -490,8 +498,6 @@ cs.ModelRender = function(gl, player) {
 		}
 	};
 
-	var previous = new Date().getTime();
-	
 	this.render = function(){
 		gl.useProgram(shaderProgram);
 
@@ -504,7 +510,7 @@ cs.ModelRender = function(gl, player) {
 		gl.uniformMatrix4fv(shaderProgram.pMatrixUniform, false, cs.pMatrix);
 		gl.uniformMatrix4fv(shaderProgram.mvMatrixUniform, false, cs.mvMatrix);
 
-		var sequence = player.sequences[this.sequenceIndex];
+		var sequence = player.sequences[sequenceIndex];
 		var transformations = setupBones(frame, sequence);
 
 		for(var i = 0; i < player.header.numBodyParts; ++i) {
@@ -520,4 +526,10 @@ cs.ModelRender = function(gl, player) {
 		gl.disableVertexAttribArray(shaderProgram.vertexPositionAttribute);
 		gl.disableVertexAttribArray(shaderProgram.texCoordAttribute);
 	};
+	
+	this.queueAnimation = function(sequenceIndex, fps) {
+		//If no fps was provided, use the default
+		fps = fps || player.sequences[sequenceIndex].fps;
+		animationQueue.push({index: sequenceIndex, fps: fps});
+	};
 };

ModelRender.js

@@ -13,7 +13,7 @@ cs.Player = function(gl, x, y, z, data) {
 	this.xAngle = 0;
 	this.speed = 5;
 	//X and Y direction. Not necessarily normalized
-	var dir = [0, 0];
+	var dir = [0, 0, 0];
 	var playerData = cs.PlayerParser.parse(gl, data);
 	var playerRender = new cs.ModelRender(gl, playerData);
 
@@ -23,14 +23,13 @@ cs.Player = function(gl, x, y, z, data) {
 
 	this.move = function() {
 		var onGround = cs.CollisionDetection.isOnGround(this.position());
-	
-		//TODO: If not on the ground the formulas for newX and newY should be changed
-		var normalDir = [0, 0];
-		vec2.normalize(normalDir, dir);
+		var normalDir = [0, 0, 0];
+		vec3.normalize(normalDir, dir);
+		
 		//Move forward
 		var newX = this.x + this.speed*normalDir[0]*Math.cos(this.yAngle);
 		var newY = this.y - this.speed*normalDir[0]*Math.sin(this.yAngle);
-		var newZ = this.z;
+		var newZ = this.z + 18*dir[2];
 
 		//Strafe
 		newY -= this.speed*normalDir[1]*Math.cos(Math.PI - this.yAngle);
@@ -39,9 +38,10 @@ cs.Player = function(gl, x, y, z, data) {
 		//Apply gravity if we're not on the ground. TODO: Accelerate instead of subtracting a constant
 		if(!onGround) {
 			newZ -= cs.config.GRAVITY;
+			dir[2] = Math.max(0, dir[2] - 0.1);
 		}
 
-		newPosition = cs.CollisionDetection.move([this.x, this.y, this.z + cs.config.MAX_Z_CHANGE], [newX, newY, newZ], true);
+		newPosition = cs.CollisionDetection.move([this.x, this.y, this.z + cs.config.MAX_Z_CHANGE], [newX, newY, newZ]);
 
 		this.x = newPosition[0];
 		this.y = newPosition[1];
@@ -69,8 +69,26 @@ cs.Player = function(gl, x, y, z, data) {
 		if(this.xAngle > PI_HALF) {
 			this.xAngle = PI_HALF;
 		}
+	};
+	
+	this.render = function() {
+		return playerRender.render();
 	}
 
+	MouseJS.on("left", function(e) {
+		//Player is shooting. Set shooting animation
+		playerRender.queueAnimation(3, 125);
+	}, function(e) {
+		//No longer shooting. Set idle animation once the current animation has finished
+		playerRender.queueAnimation(0);
+	});
+	
+	KeyboardJS.on("r", function(event, keys, combo) {
+		//Play reload animation
+		playerRender.queueAnimation(1);
+		playerRender.queueAnimation(0);
+	}, function(event, keys, combo) {});
+	
 	//Handle w and s keys
 	KeyboardJS.on("w,s", function(event, keys, combo){
 		//Is w down?
@@ -110,10 +128,6 @@ cs.Player = function(gl, x, y, z, data) {
 		}
 	});
 
-	this.render = function() {
-		return playerRender.render();
-	}
-	
 	//Handle a and d keys
 	//Symmetric to the handling of w and s
 	KeyboardJS.on("a,d", function(event, keys, combo){
@@ -146,4 +160,12 @@ cs.Player = function(gl, x, y, z, data) {
 			}
 		}
 	});
+	
+	KeyboardJS.on("space", function(event, keys, combo) {
+		//Cannot access outer scope, so we have to do the jump code in here :(
+		var d = dir[2];
+		if(d < 0.0001 && d > -0.0001) {
+			dir[2] = 1;
+		}
+	}, function(event, keys, combo) {});
 }