v1.8

g.html

@@ -288,7 +288,52 @@ <h1 class="title" style="margin-bottom: 15px">Games</h1>
       <div class="game-title-overlay">
         <span>territorial.io</span>
       </div>
-  </div>
+    </div>
+
+    <div class="game-card" id="worlds hardest game">
+      <a href="/games/worldshardestgame/">
+        <img src="img/whg.png" style="width: 150px;">
+      </a>
+      <div class="game-title-overlay">
+        <span>World's Hardest Game</span>
+      </div>
+    </div>
+
+    <div class="game-card" id="ttt">
+      <a href="/games/tic-tac-toe/">
+        <img src="img/ttt.png" style="width: 150px;">
+      </a>
+      <div class="game-title-overlay">
+        <span>Tic Tac Toe</span>
+      </div>
+    </div>
+
+    <div class="game-card" id="2048">
+      <a href="/games/2048/">
+        <img src="img/2048.png" style="width: 150px;">
+      </a>
+      <div class="game-title-overlay">
+        <span>2048</span>
+      </div>
+    </div>
+
+    <div class="game-card" id="Chess">
+      <a href="/games/chess/">
+        <img src="img/chess.png" style="width: 150px;">
+      </a>
+      <div class="game-title-overlay">
+        <span>Chess</span>
+      </div>
+    </div>
+
+    <div class="game-card" id="cc">
+      <a href="/games/cookieclicker/">
+        <img src="img/cookieclicker.png" style="width: 150px;">
+      </a>
+      <div class="game-title-overlay">
+        <span>Cookie Clicker</span>
+      </div>
+    </div>
 
 </div>  
 

games/chess/canvas3dengine/camera.jsfb

@@ -0,0 +1,293 @@
+/*
+ * Javascript/Canvas Textured 3D Renderer v0.3.1
+ * Copyright (c) 2008 Jacob Seidelin, cupboy@gmail.com
+ * This software is free to use for non-commercial purposes. For anything else, please contact the author.
+ * This is a version modified by Stefano Gioffre'.
+ */
+
+Canvas3D.Camera = function() {
+
+	this._oPosition = new Canvas3D.Vec3(0,0,0);
+
+	this._oSideVec = new Canvas3D.Vec3(1,0,0);
+	this._oUpVec = new Canvas3D.Vec3(0,1,0);
+	this._oOutVec = new Canvas3D.Vec3(0,0,1);
+
+	this._oRotMat = new Canvas3D.Matrix3();
+
+	this._bDirty = false;
+	this._fFocal = 500;
+	this._fFocalDistance = this._fFocal;
+
+	this._bReverseX = false;
+	this._bReverseY = false;
+
+	this._bTarget = true;
+
+	this._iClipNear = 1;
+	this._iClipFar = 10000000;
+
+	this._fScale = 1;
+
+	this._oLookAt = new Canvas3D.Vec3(0,0,0);
+
+};
+
+var proto = Canvas3D.Camera.prototype;
+
+proto.getDirty = function() {
+	return this._bDirty;
+}
+
+proto.setDirty = function(bDirty) {
+	this._bDirty = bDirty;
+}
+
+proto.setPosition = function(oPos) {
+	this._oPosition.set(oPos.x, oPos.y, oPos.z);
+	this._bDirty = true;
+}
+
+proto.getPosition = function() {
+	return this._oPosition;
+}
+
+proto.setScale = function(fScale) {
+	this._fScale = fScale;
+	this._bDirty = true;
+}
+
+proto.getScale = function() {
+	return this._fScale;
+}
+
+proto.getSide = function() {
+	return this._oSideVec;
+}
+
+proto.getUp = function() {
+	return this._oUpVec;
+}
+
+proto.setUp = function(oVec) {
+	this._oUpVec = oVec;
+}
+
+proto.getOut = function() {
+	return this._oOutVec;
+}
+
+proto.moveSideways = function(d) {
+	this._oPosition.x += this._oSideVec.x * d;
+	this._oPosition.y += this._oSideVec.y * d;
+	this._oPosition.z += this._oSideVec.z * d;
+	this.setDirty(true);
+}
+
+proto.moveUpwards = function(d) {
+	this._oPosition.x += this._oUpVec.x * d;
+	this._oPosition.y += this._oUpVec.y * d;
+	this._oPosition.z += this._oUpVec.z * d;
+	this.setDirty(true);
+}
+
+proto.moveForward = function(d) {
+	this._oPosition.x += this._oOutVec.x * d;
+	this._oPosition.y += this._oOutVec.y * d;
+	this._oPosition.z += this._oOutVec.z * d;
+	this.setDirty(true);
+}
+
+// rotate around the camera's side axis with a target center point (uses camera target if oTarget is null)
+proto.pitchAroundTarget = function(fTheta, oTarget) {
+	var M = new Canvas3D.Matrix3();
+	var oPos = this.getPosition();
+	oTarget = oTarget || this.getLookAt();
+
+	// translate position to target space
+	oPos.subVector(oTarget);
+
+	// rotate around side axis
+	M.loadRotationAxis(this._oSideVec, Math.sin(fTheta * Math.PI / 180.0), Math.cos(fTheta * Math.PI / 180.0));
+	oPos = M.multiplyVector(oPos);
+
+	// translate position out of target space
+	oPos.addVector(oTarget);
+
+	this.setPosition(oPos);
+	this.setDirty(true);
+}
+
+proto.yaw = function(fTheta) {
+	var M = new Canvas3D.Matrix3();
+	M.loadRotationAxis(this._oUpVec, Math.sin(fTheta), Math.cos(fTheta));
+	this._oSideVec = M.multiplyVector(this._oSideVec);
+	this._oOutVec = M.multiplyVector(this._oOutVec);
+	this.setDirty(true);
+}
+
+// rotate around the camera's up axis with a target center point (uses camera target if oTarget is null)
+proto.yawAroundTarget = function(fTheta, oTarget) {
+	var M = new Canvas3D.Matrix3();
+	var oPos = this.getPosition();
+	oTarget = oTarget || this.getLookAt();
+
+	// translate position to target space
+	oPos.subVector(oTarget);
+
+	// rotate around up axis
+	M.loadRotationAxis(this._oUpVec, Math.sin(fTheta * Math.PI / 180.0), Math.cos(fTheta * Math.PI / 180.0));
+	oPos = M.multiplyVector(oPos);
+
+	// translate position out of target space
+	oPos.addVector(oTarget);
+
+	this.setPosition(oPos);
+	this.setDirty(true);
+}
+
+// rotate around the camera's out axis with a target center point (uses camera target if oTarget is null)
+proto.rollAroundTarget = function(fTheta, oTarget) {
+	var M = new Canvas3D.Matrix3();
+	var oPos = this.getPosition();
+	oTarget = oTarget || this.getLookAt();
+
+	// translate position to target space
+	oPos.subVector(oTarget);
+
+	// rotate around out axis
+	M.loadRotationAxis(this._oOutVec, Math.sin(fTheta * Math.PI / 180.0), Math.cos(fTheta * Math.PI / 180.0));
+	oPos = M.multiplyVector(oPos);
+
+	// translate position out of target space
+	oPos.addVector(oTarget);
+
+	this.setPosition(oPos);
+	this.setDirty(true);
+}
+
+proto.rotateY = function(sine, cosine) {
+	var M = new Canvas3D.Matrix3();
+	M.loadRotationY(sine, cosine);
+	this._oSideVec = M.multiplyVector(this._oSideVec);
+	this._oUpVec   = M.multiplyVector(this._oUpVec);
+	this._oOutVec  = M.multiplyVector(this._oOutVec);
+	this.setDirty(true);
+}
+
+
+proto.lookAt = function(P, Up) {
+	Up = Up || this._oUpVec;
+	this._oOutVec  = P.returnSub(this._oPosition).unit();
+
+	//this._oSideVec = this._oOutVec.cross(new Canvas3D.Vec3 (0.0, 1.0, 0.0)).unit();
+	//this._oSideVec = this._oOutVec.cross(this._oUpVec).unit();
+	this._oSideVec = this._oOutVec.cross(Up).unit();
+	this._oUpVec   = this._oSideVec.cross(this._oOutVec).unit();
+	this._vecLookAt = P.clone();
+	this.setDirty(true);
+}
+
+proto.getLookAt = function() {
+	return this._vecLookAt;
+}
+
+proto.updateRotationMatrix = function() {
+	var e0 = this._oRotMat.e[0];
+	var e1 = this._oRotMat.e[1];
+	var e2 = this._oRotMat.e[2];
+
+	e0[0] = this._oSideVec.x;
+	e0[1] = this._oSideVec.y;
+	e0[2] = this._oSideVec.z;
+
+	e1[0] = this._oUpVec.x;
+	e1[1] = this._oUpVec.y;
+	e1[2] = this._oUpVec.z;
+
+	e2[0] = this._oOutVec.x;
+	e2[1] = this._oOutVec.y;
+	e2[2] = this._oOutVec.z;
+}
+
+proto.transformPoint = function(P) {
+	var e = this._oRotMat.e;
+	var oPos = this._oPosition;
+
+	var e0 = e[0];
+	var e1 = e[1];
+	var e2 = e[2];
+
+	var vx = P.x - oPos.x;
+	var vy = P.y - oPos.y;
+	var vz = P.z - oPos.z;
+
+	return new Canvas3D.Vec3(
+		(vx * e0[0] + vy * e0[1] + vz * e0[2]),
+		(vx * e1[0] + vy * e1[1] + vz * e1[2]),
+		(vx * e2[0] + vy * e2[1] + vz * e2[2])
+	);
+}
+
+proto.project = function(P) {
+	var fFocal = this._fFocal;
+	return {
+		x: P.x * fFocal / (P.z + this._fFocalDistance) * this._fScale * (this._bReverseX?-1:1),
+		y: -P.y * fFocal / (P.z + this._fFocalDistance) * this._fScale * (this._bReverseY?-1:1)
+	};
+}
+
+proto.clip = function(P) {
+	if (P.z < 0) {
+		return true;
+	}
+	return false;
+}
+
+proto.isBehind = function(P) {
+	if (P.z > 0) return false;
+	return false;
+}
+
+proto.getClipNear = function() {
+	return this._iClipNear;
+}
+
+proto.getClipFar = function() {
+	return this._iClipFar;
+}
+
+proto.clip = function(P) {
+	if (P.z > this._iClipNear && P.z < this._iClipFar) {
+		return false;
+	} else {
+		return true;
+	}
+}
+
+proto.setFOV = function(fFOV) {
+	this._fFOV = fFOV;
+	var fFocal = 1 / Math.tan(105 * Math.PI*Math.PI / (180*180 * 2));
+	this._fFocal = fFocal;
+	this._fFocalDistance = fFocal;
+}
+
+proto.getFOV = function() {
+	return this._fFOV;
+}
+
+proto.getFocal = function() {
+	return this._fFocal;
+}
+
+proto.setFocalDistance = function(fValue) {
+	this._fFocalDistance = fValue;
+}
+
+proto.setReverseX = function(bEnable) {
+	this._bReverseX = bEnable;
+}
+
+proto.setReverseY = function(bEnable) {
+	this._bReverseY = bEnable;
+}