├── README
├── dots
    ├── csg.js
    ├── dev.js
    ├── favicon.ico
    ├── game.js
    ├── glMatrix-0.9.5.min.js
    ├── index.html
    ├── meshes.js
    ├── package.json
    ├── particles.js
    ├── physics.js
    ├── reference.txt
    ├── server.js
    ├── shaders.js
    ├── tedge.js
    ├── textures.js
    ├── thick.png
    └── thin.png
├── ducks
    ├── convert.html
    ├── converth.html
    ├── duck.js
    ├── duck.zip
    ├── game.js
    ├── glMatrix-0.9.5.min.js
    ├── gun.h
    ├── index.html
    ├── meshes.js
    ├── node_modules
    │   └── socket.io
    │   │   ├── .gitignore
    │   │   ├── .npmignore
    │   │   ├── History.md
    │   │   ├── Makefile
    │   │   ├── Readme.md
    │   │   ├── index.js
    │   │   ├── lib
    │   │       ├── logger.js
    │   │       ├── manager.js
    │   │       ├── namespace.js
    │   │       ├── parser.js
    │   │       ├── socket.io.js
    │   │       ├── socket.js
    │   │       ├── store.js
    │   │       ├── stores
    │   │       │   ├── memory.js
    │   │       │   └── redis.js
    │   │       ├── transport.js
    │   │       ├── transports
    │   │       │   ├── flashsocket.js
    │   │       │   ├── htmlfile.js
    │   │       │   ├── http-polling.js
    │   │       │   ├── http.js
    │   │       │   ├── index.js
    │   │       │   ├── jsonp-polling.js
    │   │       │   ├── websocket.js
    │   │       │   └── xhr-polling.js
    │   │       └── util.js
    │   │   └── package.json
    ├── physics.js
    ├── server.js
    ├── tedge.js
    └── thick.png
├── rift
    ├── build-docs.bat
    ├── csg.js
    ├── dev.js
    ├── game.js
    ├── glMatrix-0.9.5.min.js
    ├── ideas.txt
    ├── index.html
    ├── meshes.js
    ├── model.html
    ├── particles.js
    ├── physics.js
    ├── reference.txt
    ├── release
    │   ├── compiled.js
    │   ├── index.html
    │   └── introspection.mp3
    ├── shaders.js
    ├── tedge notes.txt
    ├── tedge.js
    ├── texture.html
    ├── textures.js
    └── tools
    │   └── documentation.js
├── space
    ├── dev.js
    ├── game.js
    ├── glMatrix-0.9.5.min.js
    ├── lab
    │   ├── advanced.html
    │   ├── compiled.html
    │   ├── dev.js
    │   ├── game.js
    │   ├── glMatrix-0.9.5.min.js
    │   ├── index.html
    │   ├── meshes.js
    │   ├── noise.txt
    │   ├── physics.js
    │   ├── print.html
    │   ├── shaders.js
    │   ├── tedge.js
    │   ├── tedge.js.bak
    │   └── tunnel.html
    ├── meshes.js
    ├── physics.js
    ├── shaders.js
    ├── stars.html
    └── tedge.js
└── tanks
    ├── favicon.ico
    ├── game.js
    ├── glMatrix-0.9.5.min.js
    ├── index.html
    ├── link
    ├── meshes.js
    ├── package.json
    ├── server.js
    ├── singleplayer.html
    ├── tedge.js
    ├── thick.png
    └── thin.png


/README:
--------------------------------------------------------------------------------
1 | A collection of 3D JavaScript games using WebGL.
2 | 
3 | Developed by Team Duck.


--------------------------------------------------------------------------------
/dots/csg.js:
--------------------------------------------------------------------------------
  1 | // constructive solid geometry -- needs some work
  2 | // todo: support UVs
  3 | //   check intersection direction
  4 | 
  5 | function LineIntersection(lineVertex, lineVector, pointA, pointB)
  6 | {
  7 | 	debugger;
  8 | 	var c = VecSub(lineVertex, pointA);
  9 | 	var v = VecSub(pointB, pointA);
 10 | 	var d = VecLength(v);
 11 | 	var t = VecDot(v, c);
 12 | 	var q = VecAdd(pointA, VecScale(v, t/d));
 13 | 	var vq = VecSub(q, lineVertex);
 14 | 	var r = VecLength(vq) / VecDot(q, vq);
 15 | 	var F = VecAdd(lineVertex, VecScale(lineVector, r));
 16 | 	return F;
 17 | 	//var r = VecDot(v, q);
 18 | 	//t = (t + r) / d;
 19 | 	// if 0 <= t <= d, then it's on the segment; otherwise it's off in space
 20 | 	//if (t >= 0 && t <= d)
 21 | 	//	return VecAdd(pointA, VecScale(v, t / d));
 22 | 	return;
 23 | }
 24 | 
 25 | function LineOverlap(segmentA, segmentB, lineVector) 
 26 | {
 27 | 	var aVector = VecSub(segmentA[1], segmentA[0]);
 28 | 	var bVector = VecSub(segmentB[1], segmentB[0]);
 29 | 	if (VecDot(aVector, lineVector) < 0) {
 30 | 		var swap = segmentA[0];
 31 | 		segmentA[0] = segmentA[1];
 32 | 		segmentA[1] = swap;
 33 | 	}
 34 | 	if (VecDot(bVector, lineVector) < 0) {
 35 | 		var swap = segmentB[0];
 36 | 		segmentB[0] = segmentB[1];
 37 | 		segmentB[1] = swap;
 38 | 	}
 39 | 	// a and b are both facing the same direction
 40 | 	var q;
 41 | 	if (VecDot(segmentA[0], lineVector) >= VecDot(segmentB[0], lineVector)) {
 42 | 		q = segmentA[0];
 43 | 	} else {
 44 | 		q = segmentB[0];
 45 | 	}
 46 | 	
 47 | 	var r;
 48 | 	if (VecDot(segmentA[1], lineVector) <= VecDot(segmentB[1], lineVector)) {
 49 | 		r = segmentA[1];
 50 | 	} else {
 51 | 		r = segmentB[1];
 52 | 	}
 53 | 	
 54 | 	if (VecDot(VecSub(r, q), lineVector) > 0)
 55 | 		return [q, r];
 56 | 	return;
 57 | }
 58 | 
 59 | function CSG() {
 60 | 	var csg = {
 61 | 		mesh: {vertices: [], normals: [], uvs: [], count: 0},
 62 | 		
 63 | 		append: function(subMesh, transform, uvTransform) {
 64 | 			if (transform) {
 65 | 				subMesh = CloneMesh(subMesh);
 66 | 				subMesh = TransformMesh(subMesh, transform);
 67 | 				if (uvTransform)
 68 | 					TransformMeshUVs(subMesh, uvTransform);
 69 | 			}
 70 | 			
 71 | 			csg.mesh.count += subMesh.count;
 72 | 			csg.mesh.vertices = csg.mesh.vertices.concat(subMesh.vertices);
 73 | 			if (subMesh.normals)
 74 | 				csg.mesh.normals = csg.mesh.normals.concat(subMesh.normals);
 75 | 			if (subMesh.uvs)
 76 | 				csg.mesh.uvs = csg.mesh.uvs.concat(subMesh.uvs);
 77 | 		},
 78 | 		
 79 | 		subtract: function(subMesh, transform) {
 80 | 			if (transform) {
 81 | 				subMesh = CloneMesh(subMesh);
 82 | 				subMesh = TransformMesh(subMesh, transform);
 83 | 			}
 84 | 			
 85 | 			var mesh = csg.mesh;
 86 | 			var culled = {count: 0, vertices: [], normals: [], uvs: []}
 87 | 			var intersection = false;
 88 | 			
 89 | 			// go through each triangle in the mesh
 90 | 			for (var i = 0; i < mesh.vertices.length; i+=9) 
 91 | 			{
 92 | 				var segments = []; var linkedVertices = [];
 93 | 				var linkedNormals = [];
 94 | 				// go through each triangle of the subtrahend
 95 | 				for (var j = 0; j < subMesh.vertices.length; j+=9)
 96 | 				{
 97 | 					// check if the triangles collide and find the overlapping segment
 98 | 					
 99 | 					// find the line of the intersection of the planes
100 | 					var mNormal = [mesh.normals[i], mesh.normals[i+1], mesh.normals[i+2]];
101 | 					var sNormal = [subMesh.normals[j], subMesh.normals[j+1], subMesh.normals[j+2]];
102 | 					var lineVector = VecCross(mNormal, sNormal);
103 | 					if (VecLengthSqr(lineVector) < 0.5) continue;
104 | 					
105 | 					var lineVertex;
106 | 					var mAnchor = Vector3(mesh.vertices[i], mesh.vertices[i+1], mesh.vertices[i+2]);
107 | 					var sAnchor = Vector3(subMesh.vertices[j], subMesh.vertices[j+1], subMesh.vertices[j+2]);
108 | 					lineVertex = VecDot(VecSub(mAnchor, sAnchor), mNormal);
109 | 					lineVertex = VecAdd(VecScale(mNormal, lineVertex), sAnchor);
110 | 					
111 | 					// clip segment along mTriangle
112 | 					var mSegment = []; var mK;
113 | 					for (var k = 0; k < 3; k++) {
114 | 						var m0 = Vector3(mesh.vertices[i+k*3], mesh.vertices[i+k*3+1], mesh.vertices[i+k*3+2]);
115 | 						var m1 = Vector3(mesh.vertices[i+((k+1)%3)*3],
116 | 							mesh.vertices[i+((k+1)%3)*3+1],
117 | 							mesh.vertices[i+((k+1)%3)*3+2]);
118 | 						var mV = LineIntersection(lineVertex, lineVector, m0, m1);
119 | 						if (mV) {
120 | 							mSegment.push(mV);
121 | 						} else {
122 | 							mK = k;
123 | 						}
124 | 					}
125 | 					if (mSegment.length < 2) continue;
126 | 					
127 | 					// clip segment along sTriangle
128 | 					var sSegment = [];
129 | 					for (var k = 0; k < 3; k++) {
130 | 						var s0 = Vector3(subMesh.vertices[j+k*3], subMesh.vertices[j+k*3+1], subMesh.vertices[j+k*3+2]);
131 | 						var s1 = Vector3(subMesh.vertices[j+((k+1)%3)*3],
132 | 							subMesh.vertices[j+((k+1)%3)*3+1],
133 | 							subMesh.vertices[j+((k+1)%3)*3+2]);
134 | 						var sV = LineIntersection(lineVertex, lineVector, s0, s1);
135 | 						if (sV) {
136 | 							sSegment.push(sV);
137 | 						}
138 | 					}
139 | 					if (sSegment.length < 2) continue;
140 | 					
141 | 					var segment = LineOverlap(mSegment, sSegment, lineVector);
142 | 					if (segment) {
143 | 						segments.push(segment);
144 | 						linkedVertices.push([
145 | 							Vector3(mesh.vertices[i+mK*3], 
146 | 								mesh.vertices[i+mK*3+1], 
147 | 								mesh.vertices[i+mK*3+2]),
148 | 							Vector3(mesh.vertices[i+((mK+1)%3)*3],
149 | 								mesh.vertices[i+((mK+1)%3)*3+1],
150 | 								mesh.vertices[i+((mK+1)%3)*3+2])
151 | 						]);
152 | 						linkedNormals.push(mNormal);
153 | 					}
154 | 				}
155 | 				if (segments.length > 0) {
156 | 					// create new faces
157 | 					intersection = true;
158 | 					for (var k = 0; k < segments.length; k++) {
159 | 						culled.count += 2;
160 | 						culled.vertices = culled.vertices.concat(segments[k][0]);
161 | 						culled.vertices = culled.vertices.concat(segments[k][1]);
162 | 						culled.vertices = culled.vertices.concat(linkedVertices[k][0]);
163 | 						culled.vertices = culled.vertices.concat(segments[k][1]);
164 | 						culled.vertices = culled.vertices.concat(linkedVertices[k][1]);
165 | 						culled.vertices = culled.vertices.concat(linkedVertices[k][0]);
166 | 						for (var q = 0; q < 6; q++)
167 | 							culled.normals = culled.normals.concat(linkedNormals[k]);
168 | 					}
169 | 				} else {
170 | 					// no intersection, so keep this triangle
171 | 					culled.count++;
172 | 					for (var k = 0; k < 9; k++) {
173 | 						culled.vertices.push(mesh.vertices[i+k]);
174 | 						culled.normals.push(mesh.normals[i+k]);
175 | 					}
176 | 					if (mesh.uvs) {
177 | 						var ui = i*2/3;
178 | 						for (var k = 0; k < 6; k++) {
179 | 							culled.uvs.push(mesh.uvs[ui+k]);
180 | 						}
181 | 					}
182 | 				}
183 | 			}
184 | 			
185 | 			csg.mesh = culled;
186 | 			csg.mesh.uvs = [];
187 | 		},
188 | 		
189 | 		compile: function(transform) {
190 | 			var mesh = {vertices: csg.mesh.vertices, count: csg.mesh.count};
191 | 			if (csg.mesh.normals.length) mesh.normals = csg.mesh.normals;
192 | 			if (csg.mesh.uvs.length) mesh.uvs = csg.mesh.uvs;
193 | 			if (transform)
194 | 				mesh = TransformMesh(mesh, transform);
195 | 			return BufferMesh(mesh);
196 | 		}
197 | 	};
198 | 	return csg;
199 | }
200 | 


--------------------------------------------------------------------------------
/dots/dev.js:
--------------------------------------------------------------------------------
 1 | function TextSprite(text, style, font, x, y) {
 2 | 	if (style === undefined) style = "white";
 3 | 	if (font === undefined) font = "32px lucida console";
 4 | 	if (x === undefined) x = 0;
 5 | 	if (y === undefined) y = 0;
 6 | 	
 7 | 	var t = {"x": x, "y": y};
 8 | 	var bitmap;
 9 | 	var size;
10 | 	var texture = gl.createTexture();
11 | 	var mesh = BufferMesh(SQUARE_MESH);
12 | 	
13 | 	
14 | 	context.clearRect(0, 0, canvas2D.width, canvas2D.height);
15 | 	context.fillStyle = style;
16 | 	context.font = font;
17 | 	context.textBaseline = "top";
18 | 	context.fillText(text, 0, 0);
19 | 	size = context.measureText(text);
20 | 	t.size = size;
21 | 	var width = 1; while (width < size.width) width *= 2;
22 | 	bitmap = context.getImageData(0, 0, width, width);
23 | 	StoreTexture(texture, bitmap);
24 | 	
25 | 	var identity = Mat4List(Matrix4());
26 | 	var screen = Matrix4();
27 | 	screen = Mat4Mult(screen, Mat4Translate([1, -1, 0]));
28 | 	screen = Mat4Mult(screen, Mat4Scale(width/2, width/2, 1));
29 | 	screen = Mat4Mult(screen, Mat4Translate([-canvas.width/2, -canvas.height/2, 0]));
30 | 	screen = Mat4Mult(screen, Mat4Scale(2/canvas.width, 2/canvas.height, 1));
31 | 	screen = Mat4List(screen);
32 | 	
33 | 	if (x < 0) t.x = canvas.width - size.width + t.x;
34 | 	
35 | 	t.render = function (mtx) {
36 | 		// set up texture shader
37 | 		TEX_SHADER.enable();
38 | 		
39 | 		// orthogonal
40 | 		gl.uniformMatrix4fv(TEX_SHADER.pMatrix, false, identity);
41 | 		gl.uniformMatrix4fv(TEX_SHADER.vMatrix, false, screen);
42 | 		
43 | 		// blending for transparency
44 | 		gl.enable(gl.BLEND);
45 | 		gl.blendFunc(gl.SRC_ALPHA, gl.ONE);
46 | 		gl.depthMask(false);
47 | 		
48 | 		// bind texture
49 | 		gl.activeTexture(gl.TEXTURE0);
50 | 		gl.bindTexture(gl.TEXTURE_2D, texture);
51 | 		gl.uniform1i(TEX_SHADER.samplerUniform, 0);
52 | 		DrawMesh(mesh, Mat4List(Mat4Translate([2*t.x/width, 2*(canvas.height - t.y)/width, 0])), TEX_SHADER);
53 | 		
54 | 		gl.disable(gl.BLEND);
55 | 		gl.depthMask(true);
56 | 		
57 | 		// draw
58 | 		gl.uniformMatrix4fv(TEX_SHADER.pMatrix, false, pMatrix);
59 | 		gl.uniformMatrix4fv(TEX_SHADER.vMatrix, false, vMatrix);
60 | 		TEX_SHADER.disable();
61 | 		STD_SHADER.enable();
62 | 	}
63 | 	return t;
64 | }
65 | 


--------------------------------------------------------------------------------
/dots/favicon.ico:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/teamduck/gametube/40e8ea4b963148dadadea1f7d28f6d10e0a07953/dots/favicon.ico


--------------------------------------------------------------------------------
/dots/index.html:
--------------------------------------------------------------------------------
 1 | <html>
 2 | 	<head>
 3 | 		<title>DOTS</title>
 4 | 		<script src="glMatrix-0.9.5.min.js"></script>
 5 | 		<script src="tedge.js"></script>
 6 | 		<script src="dev.js"></script>
 7 | 		<script src="shaders.js"></script>
 8 | 		<script src="physics.js"></script>
 9 | 		<script src="meshes.js"></script>
10 | 		<script src="csg.js"></script>
11 | 		<script src="textures.js"></script>
12 | 		<script src="particles.js"></script>
13 | 		<script src="game.js"></script>
14 | 		</script>
15 | 		<style>
16 | 			#game {
17 | 				position: absolute;
18 | 				top: 0;
19 | 				left: 0;
20 | 				border: none;
21 |                 /*cursor: none;*/
22 | 			}
23 | 		</style>
24 | 	</head>
25 | 	<body>
26 | 		<canvas id="game" width="100%" height="100%">
27 | 		</canvas>
28 | 		<canvas id="2D" style="display: none;">
29 | 	</body>
30 | </html>


--------------------------------------------------------------------------------
/dots/meshes.js:
--------------------------------------------------------------------------------
  1 | /* simple meshes */
  2 | BOX_MESH = {"count":12,"vertices":[0,1,1,0,0,1,1,1,1,0,0,1,1,0,1,1,1,1,1,1,1,1,0,1,1,1,0,1,0,1,1,0,0,1,1,0,1,1,0,1,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,1,0,1,1,0,1,0,0,1,1,1,1,0,0,1,1,1,1,1,1,1,0,0,0,1,0,0,0,1,0,1,0,0,0,1,0,0,1,0,1],"uvs":[0,0,0,1,1,0,0,1,1,1,1,0,0,0,0,1,1,0,0,1,1,1,1,0,0,0,0,1,1,0,0,1,1,1,1,0,0,0,0,1,1,0,0,1,1,1,1,0,0,0,0,1,1,0,0,1,1,1,1,0,0,0,0,1,1,0,0,1,1,1,1,0],"normals":[0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0]};
  3 | 
  4 | SQUARE_MESH = {"count":2,"vertices":[-1,-1,0,1,-1,0,-1,1,0,-1,1,0,1,-1,0,1,1,0],"uvs":[0,0,1,0,0,1,0,1,1,0,1,1],"normals":[0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1]};
  5 | 
  6 | /* procedural meshes */
  7 | var MARK_MESH;
  8 | function GetMarkMesh() {
  9 | 	if (MARK_MESH === undefined) {
 10 | 		var csg = CSG();
 11 | 		csg.append(SQUARE_MESH, Mat4Translate(0, 0, 0.1));
 12 | 		csg.append(SQUARE_MESH, Mat4Translate(0, 0, -0.1));
 13 | 		MARK_MESH = csg.compile();
 14 | 	}
 15 | 	return MARK_MESH;
 16 | }
 17 | 
 18 | function BlobMesh() 
 19 | {
 20 | 	var blob = Math2MeshSphere(function () { 
 21 | 		return (1 + Math.random()) * 2;
 22 | 	}, 16, 16);
 23 | 	
 24 | 	TransformMesh(blob, Mat4Translate(0, 1, 0));
 25 | 	
 26 | 	for (var i = 0; i < blob.vertices.length; i+=3) {
 27 | 		if (blob.vertices[i+1] < 0)
 28 | 			blob.vertices[i+1] = 0;
 29 | 	}
 30 | 	
 31 | 	TransformMesh(blob, Mat4Scale(1.4, 1.25, 1.4));
 32 | 	
 33 | 	var csg = CSG();
 34 | 	csg.append(blob);
 35 | 	
 36 | 	for (var k = 0; k < 8; k++) {
 37 | 		// psuedo randomly oriented limbs
 38 | 		var pos = [k*k + 17*(k+1) + 13];
 39 | 		pos.push(pos[0]*11*k + 13*k + 19);
 40 | 		pos.push(pos[0] + pos[1]*2 + 21*k);
 41 | 		pos[0] = ((pos[0]%11)/11)*5 - 2.5;
 42 | 		pos[1] = ((pos[1]%11)/11)*2 + 1.0;
 43 | 		pos[2] = ((pos[2]%11)/11)*5 - 2.5;
 44 | 		
 45 | 		var path = [{
 46 | 			pos: pos,
 47 | 			radius: 0.5
 48 | 		}];
 49 | 		var angle = QuatFromVectors(VEC_UP, VecNormalize(path[0].pos));
 50 | 		angle = QuatNormalize(angle);
 51 | 		for (var i = 1; i < 7; i++) {
 52 | 			// randomly arrange the tentacles
 53 | 			var pos = Mat4TransformPoint([Math.random()*2 - 1, Math.random()+0.5, Math.random()*2 - 1], Mat4Rotate(angle));
 54 | 			pos = VecAdd(pos, path[i-1].pos);
 55 | 			path.push({pos: pos, radius: 0.5});
 56 | 		}
 57 | 		var tentacle = Math2MeshPath(path, 3);
 58 | 		csg.append(tentacle, Matrix4(), [0.2, 0, 0, 0, 0.2, 0]);
 59 | 	}
 60 | 	
 61 | 	return csg.compile();
 62 | }
 63 | 
 64 | 
 65 | function PlasmaGunMesh(transform)
 66 | {
 67 | 	var csg = CSG();
 68 | 	var matrix;
 69 | 	
 70 | 	var barrel = Math2MeshCylinder(function (theta, t) {
 71 | 		return MAX(Math.sin(t*6)*0.5 + 1.2, Math.cos(t*6)*0.5 + 1);
 72 | 	}, 12, 12);
 73 | 	
 74 | 	var ball = Math2MeshSphere(function() { return 0.5; }, 8, 8);
 75 | 	
 76 | 	var handle = CloneMesh(BOX_MESH);
 77 | 	matrix = Mat4Translate(-0.5, -0.5, 0)
 78 | 	matrix = Mat4Mult(matrix, Mat4Scale(0.4, 0.5, 1.2));
 79 | 	matrix = Mat4Mult(matrix, Mat4Rotate(QuatXYZ(0.5, 0, 0)));
 80 | 	handle = TransformMesh(handle, matrix);
 81 | 	
 82 | 	csg.append(barrel, Mat4Scale(0.25, 2, 0.25), [1, 0, 0, 0, 0.48, 0.01]);
 83 | 	csg.append(ball, Matrix4(), [0.5, 0, 0, 0, 0.5, 0.5]);
 84 | 	csg.append(handle, Matrix4(), [0.5, 0, 0.5, 0, 0.5, 0.5]);
 85 | 	if (transform) {
 86 | 		transform = Mat4Mult(Mat4Rotate(QUAT_X), transform);
 87 | 	} else {
 88 | 		transform = Mat4Rotate(QUAT_X);
 89 | 	}
 90 | 	return csg.compile(transform);
 91 | }
 92 | 
 93 | /* model viewing tool */
 94 | function ModelViewer()
 95 | {
 96 | 	//var mesh = BufferMesh(BOX_MESH);
 97 | 	var model = 0;
 98 | 	var models = [
 99 | 		PlasmaGunMesh(),
100 | 		BlobMesh(),
101 | 	];
102 | 	var texture = MakeTexture(CheckeredTexture(), 256);
103 | 	gl.clearColor(0.0, 0.0, 1.0, 1.0);
104 | 	
105 | 	var mv = InputtingEntity({}, puid);
106 | 	var rotation = Quat();
107 | 	var wireframe = false;
108 | 	var t = 0;
109 | 	var zoom = 1;
110 | 	mv.update = function (dt)
111 | 	{
112 | 		t += dt;
113 | 		if (mv.mouseHit(M_LEFT)) {
114 | 			origin = mv.mousePosition();
115 | 		}
116 | 		if (mv.mouseDown(M_LEFT)) {
117 | 			var vector = mv.mousePosition();
118 | 			vector = [(vector[0] - origin[0])*3, 
119 | 					(origin[1] - vector[1])*3];
120 | 			rotation = QuatMult(rotation, QuatXYZ(0, vector[0], 0));
121 | 			rotation = QuatMult(QuatXYZ(vector[1], 0, 0), rotation);
122 | 			origin = mv.mousePosition();
123 | 		}
124 | 		if (mv.keyHit(K_W)) {
125 | 			wireframe = !wireframe;
126 | 		}
127 | 		if (mv.keyHit(K_LEFT)) model = (model+1)%models.length;
128 | 		if (mv.keyHit(K_RIGHT)) model = (model-1+models.length)%models.length;
129 | 		if (mv.keyDown(K_UP)) zoom *= 1 + dt;
130 | 		if (mv.keyDown(K_DOWN)) zoom *= 1 - dt;
131 | 	}
132 | 	
133 | 	gCamera = Camera(VEC_FORWARD);
134 | 	mv.render = function ()
135 | 	{
136 | 		var matrix = Mat4World([0, 0, 5], rotation);
137 | 		matrix = Mat4Mult(Mat4Scale(zoom), matrix);
138 | 		matrix = Mat4List(matrix);
139 | 		TEX_SHADER.enable(texture);
140 | 		DrawMesh(models[model], matrix, TEX_SHADER, wireframe);
141 | 	}
142 | 	
143 | 	entities.push(mv);
144 | 	
145 | 	startGame();
146 | }
147 | 


--------------------------------------------------------------------------------
/dots/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "tanks",
 3 |   "subdomain": "cybertanks",
 4 |   "scripts": {
 5 |     "start": "node server.js"
 6 |   },
 7 |   "version": "1.0.0-2",
 8 |   "dependencies": {
 9 |     "socket.io": "*"
10 |   },
11 |   "engines": {
12 |     "node": "0.8.x"
13 |   }
14 | }
15 | 


--------------------------------------------------------------------------------
/dots/particles.js:
--------------------------------------------------------------------------------
  1 | /* particle effects */
  2 | function ParticleGenerator() 
  3 | {
  4 | 	var pg = {
  5 | 		pos: [25, 1, 30],
  6 | 		delay: 0.1,
  7 | 		size: 1,
  8 | 		range: 2,
  9 | 		count: 25,
 10 | 		color: [1, 1, 1, 1],
 11 | 		velocity: VEC_UP,
 12 | 		blending: [gl.SRC_ALPHA, gl.ONE]
 13 | 	};
 14 | 	var particles = [];
 15 | 	
 16 | 	pg.texture = GetParticleTexture();
 17 | 	pg.mesh = BufferMesh(SQUARE_MESH);
 18 | 	
 19 | 	var t = 0;
 20 | 	pg.update = function (dt) {
 21 | 		pg.duration = pg.delay * pg.count;
 22 | 		t += dt;
 23 | 		
 24 | 		// generate new particles
 25 | 		if (t > pg.delay) {
 26 | 			var particle = {life: 0};
 27 | 			particle.pos = Vector3(Math.random(), Math.random(), Math.random());
 28 | 			particle.pos = VecSub(particle.pos, [0.5, 0.5, 0.5]);
 29 | 			if (pg.range.length)
 30 | 				particle.pos = VecMult(particle.pos, pg.range);
 31 | 			else
 32 | 				particle.pos = VecScale(particle.pos, pg.range);
 33 | 			particle.pos = VecAdd(particle.pos, pg.pos);
 34 | 			particles.push(particle);
 35 | 			
 36 | 			if (particles.length > pg.count) {
 37 | 				particles = particles.slice(particles.length - pg.count);
 38 | 			}
 39 | 			
 40 | 			t -= pg.delay;
 41 | 		}
 42 | 		
 43 | 		// update existing ones
 44 | 		for (var p in particles) {
 45 | 			var particle = particles[p];
 46 | 			particle.pos = VecAdd(VecScale(pg.velocity, dt), particle.pos);
 47 | 			particle.life += dt;
 48 | 		}
 49 | 	}
 50 | 	
 51 | 	pg.render = function () {
 52 | 		TEX_SHADER.enable(pg.texture);
 53 | 		gl.enable(gl.BLEND);
 54 | 		gl.blendFunc(pg.blending[0], pg.blending[1]);
 55 | 		gl.depthMask(false);
 56 | 		var rot = gCamera.rot;
 57 | 		for (var p in particles) 
 58 | 		{
 59 | 			var particle = particles[p];
 60 | 			var matrix = Mat4World(particle.pos, rot);
 61 | 			matrix = Mat4Mult(Mat4Scale(pg.size), matrix);
 62 | 			var alpha = 1 - (2*abs(particle.life - pg.duration/2) / pg.duration);
 63 | 			TEX_SHADER.setColor(pg.color[0], pg.color[1], pg.color[2], pg.color[3] * alpha);
 64 | 			matrix = Mat4List(matrix);
 65 | 			DrawMesh(pg.mesh, matrix, TEX_SHADER);
 66 | 		}
 67 | 		gl.depthMask(true);
 68 | 		gl.disable(gl.BLEND);
 69 | 		
 70 | 		TEX_SHADER.setColor(1, 1, 1, 1);
 71 | 	}
 72 | 	
 73 | 	pg.devRender = function () 
 74 | 	{
 75 | 		var verts = [];
 76 | 		for (var i = 0; i < particles.length; i++) {
 77 | 			verts = verts.concat(particles[i].pos);
 78 | 		}
 79 | 		var boundingBox = BBFromMesh(verts);
 80 | 		DrawBoundingBox(boundingBox);
 81 | 	}
 82 | 	
 83 | 	return pg;
 84 | }
 85 | 
 86 | function FireEffect(pos) 
 87 | {
 88 | 	var effect = {rot: Quat()};
 89 | 	var fire = ParticleGenerator();
 90 | 	if (pos) {
 91 | 		fire.pos = pos;
 92 | 	}
 93 | 	effect.pos = fire.pos;
 94 | 	fire.size = 1.5;
 95 | 	fire.pos[1] = 0;
 96 | 	fire.range = 2.5;
 97 | 	fire.velocity = [0.6, 4, 0];
 98 | 	fire.color = [1, 0.25, 0.1, 2];
 99 | 	fire.delay = 0.02;
100 | 	fire.count = 50;
101 | 	
102 | 	var smoke = ParticleGenerator();
103 | 	smoke.size = fire.size * 2;
104 | 	smoke.pos = VecAdd(fire.pos, VecScale(fire.velocity, 0.5));
105 | 	smoke.range = fire.range * 3;
106 | 	smoke.velocity = VecScale(fire.velocity, 0.25);
107 | 	smoke.color = [0.5, 0.5, 0.5, 1];
108 | 	smoke.delay = 0.5;
109 | 	smoke.count = 20;
110 | 	smoke.blending = [gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA];
111 | 	
112 | 	effect.update = function (dt) {
113 | 		fire.pos = effect.pos;
114 | 		smoke.pos = VecAdd(effect.pos, VecScale(fire.velocity, 0.5));
115 | 		
116 | 		fire.update(dt);
117 | 		smoke.update(dt);
118 | 	}
119 | 	
120 | 	effect.render = function () {
121 | 		fire.render();
122 | 		smoke.render();
123 | 	}
124 | 	
125 | 	effect.devRender = function () {
126 | 		fire.devRender(); smoke.devRender();
127 | 	}
128 | 	
129 | 	return effect;
130 | }
131 | 
132 | function Explosion(pos) 
133 | {
134 | 	var exp = {
135 | 		pos: [25, 0, 30],
136 | 		size: 1,
137 | 		range: 1,
138 | 		count: 50,
139 | 		duration: 1,
140 | 		color: [0.8, 0.3, 0.2, 1],
141 | 		velocity: [0, 0, 0],
142 | 		velocityRange: 15,
143 | 		force: [0, 0, 0],
144 | 		blending: [gl.SRC_ALPHA, gl.ONE]
145 | 	};	
146 | 	exp.texture = GetParticleTexture();
147 | 	exp.mesh = BufferMesh(SQUARE_MESH);
148 | 	
149 | 	if (pos) exp.pos = pos;
150 | 	
151 | 	var particles = [];
152 | 	// generate particles
153 | 	for (var i = 0; i < exp.count; i++) {
154 | 		var particle = {life: 0};
155 | 		particle.pos = Vector3(Math.random(), Math.random(), Math.random());
156 | 		particle.pos = VecSub(particle.pos, [0.5, 0.5, 0.5]);
157 | 		if (exp.range.length)
158 | 			particle.pos = VecMult(particle.pos, exp.range);
159 | 		else
160 | 			particle.pos = VecScale(particle.pos, exp.range);
161 | 		particle.pos = VecAdd(particle.pos, exp.pos);
162 | 		
163 | 		particle.vel = Vector3(Math.random(), Math.random(), Math.random());
164 | 		particle.vel = VecSub(particle.vel, [0.5, 0.5, 0.5]);
165 | 		if (exp.velocityRange.length)
166 | 			particle.vel = VecMult(particle.vel, exp.velocityRange);
167 | 		else
168 | 			particle.vel = VecScale(particle.vel, exp.velocityRange);
169 | 		particle.vel = VecAdd(particle.vel, exp.velocity);
170 | 		
171 | 		particles.push(particle);
172 | 	}
173 | 	
174 | 	var t = 0;
175 | 	exp.update = function (dt) {
176 | 		t += dt;
177 | 		if (t < exp.duration) {
178 | 			// update existing ones
179 | 			for (var p in particles) {
180 | 				var particle = particles[p];
181 | 				particle.pos = VecAdd(VecScale(particle.vel, dt), particle.pos);
182 | 				particle.vel = VecAdd(VecScale(exp.force, dt), particle.vel);
183 | 				particle.life += dt;
184 | 			}
185 | 		} else {
186 | 			// delete?
187 | 			removeEntity(exp);
188 | 		}
189 | 	}
190 | 	
191 | 	exp.render = function () {
192 | 		TEX_SHADER.enable(exp.texture);
193 | 		gl.enable(gl.BLEND);
194 | 		gl.blendFunc(exp.blending[0], exp.blending[1]);
195 | 		gl.depthMask(false);
196 | 		var rot = gCamera.rot;
197 | 		for (var p in particles) 
198 | 		{
199 | 			var particle = particles[p];
200 | 			var matrix = Mat4World(particle.pos, rot);
201 | 			matrix = Mat4Mult(Mat4Scale(exp.size), matrix);
202 | 			var alpha = 1 - particle.life/exp.duration;
203 | 			TEX_SHADER.setColor(exp.color[0], exp.color[1], exp.color[2], exp.color[3] * alpha);
204 | 			matrix = Mat4List(matrix);
205 | 			DrawMesh(exp.mesh, matrix, TEX_SHADER);
206 | 		}
207 | 		gl.depthMask(true);
208 | 		gl.disable(gl.BLEND);
209 | 		
210 | 		TEX_SHADER.setColor(1, 1, 1, 1);
211 | 	}
212 | 	
213 | 	exp.devRender = function () 
214 | 	{
215 | 		var verts = [];
216 | 		for (var i = 0; i < particles.length; i++) {
217 | 			verts = verts.concat(particles[i].pos);
218 | 		}
219 | 		var boundingBox = BBFromMesh(verts);
220 | 		DrawBoundingBox(boundingBox);
221 | 	}
222 | 	
223 | 	return exp;
224 | }
225 | 


--------------------------------------------------------------------------------
/dots/reference.txt:
--------------------------------------------------------------------------------
  1 | TEDGE PROJECT QUICK REFERENCE
  2 | =================================
  3 | =================================
  4 | 
  5 | 
  6 | csg.js:
  7 | 	200 lines and 3 functions
  8 | 	
  9 | 	function LineIntersection(lineVertex, lineVector, pointA, pointB)
 10 | 	function LineOverlap(segmentA, segmentB, lineVector)
 11 | 	function CSG()
 12 | 
 13 | 
 14 | dev.js:
 15 | 	65 lines and 1 function
 16 | 	
 17 | 	function TextSprite(text, style, font, x, y)
 18 | 
 19 | 
 20 | game.js:
 21 | 	728 lines and 18 functions
 22 | 	
 23 | 	function SpaceBox()
 24 | 	function EnergyCore()
 25 | 	function Tree(pos)
 26 | 	function Box(position, rotation)
 27 | 	function Red()
 28 | 	function Blue()
 29 | 	function White()
 30 | 	function Resource(position, rotation)
 31 | 	function GameMap()
 32 | 	function RTSCamera()
 33 | 	function TargetCursor(position)
 34 | 	function Base(player)
 35 | 	function PQ()
 36 | 	function FindPath(start, dest, terrain)
 37 | 	function Worker()
 38 | 	function ControlScreen()
 39 | 	function gameInit()
 40 | 	function finishedLoading()
 41 | 
 42 | 
 43 | glMatrix-0.9.5.min.js:
 44 | 	33 lines and 0 functions
 45 | 	
 46 | 
 47 | 
 48 | meshes.js:
 49 | 	147 lines and 4 functions
 50 | 	
 51 | 	function GetMarkMesh()
 52 | 	function BlobMesh()
 53 | 	function PlasmaGunMesh(transform)
 54 | 	function ModelViewer()
 55 | 
 56 | 
 57 | particles.js:
 58 | 	225 lines and 3 functions
 59 | 	
 60 | 	function ParticleGenerator()
 61 | 	function FireEffect(pos)
 62 | 	function Explosion(pos)
 63 | 
 64 | 
 65 | physics.js:
 66 | 	1043 lines and 63 functions
 67 | 	
 68 | 	function MAX(a,b)
 69 | 	function MIN(a,b)
 70 | 	function MOD(a,b)
 71 | 	function Vector3(x, y, z)
 72 | 	function VecCopy(v)
 73 | 	function VecAdd(a, b, c)
 74 | 	function VecAdd(a, b)
 75 | 	function VecSub(a, b)
 76 | 	function VecScale(v, s)
 77 | 	function VecNormalize(v)
 78 | 	function VecLength(v)
 79 | 	function VecLengthSqr(v)
 80 | 	function VecDot(a, b)
 81 | 	function VecCross(a, b)
 82 | 	function VecMult(a, b)
 83 | 	function VecRotate(v, q)
 84 | 	function Quat(w, x, y, z)
 85 | 	function QuatInverse(q)
 86 | 	function QuatFromVectors(a, b)
 87 | 	function QuatNormalize(q)
 88 | 	function QuatMult(a, b)
 89 | 	function QuatXYZ(pitch, yaw, roll)
 90 | 	function QuatSlerp(start, end, alpha)
 91 | 	function Matrix4()
 92 | 	function Mat4List(m)
 93 | 	function Mat4Scale(x, y, z)
 94 | 	function Mat4Translate(x, y, z)
 95 | 	function Mat4FromVectors(right, up, forward)
 96 | 	function Mat4World(pos, rot)
 97 | 	function Mat4Rotate(rot)
 98 | 	function Mat4TransformPoints(points, mtx)
 99 | 	function Mat4TransformPoint(point, mtx)
100 | 	function Mat3TransformPoints(points, mtx)
101 | 	function Mat3TransformPoint(point, mtx)
102 | 	function Mat4Mult(a, b)
103 | 	function Mat4Determinant(a)
104 | 	function Mat4Transpose(m)
105 | 	function Mat4Inverse(a)
106 | 	function BBCopy(bb)
107 | 	function BBJoin(bb1, bb2)
108 | 	function BBAddPoint(bb, point)
109 | 	function BBTestPoint(bb, point)
110 | 	function BBTestBB(bb1, bb2)
111 | 	function BBTestRay(box, origin, dir, t0, t1)
112 | 	function BBFromMesh(verts)
113 | 	function DrawBoundingBox(bb)
114 | 	function BBSize(bb)
115 | 	function BBCenter(bb)
116 | 	function BBContains(big, small)
117 | 	function BBCut(bb, axis)
118 | 	function BBTransform(bb, m)
119 | 	function Prune(vertices, bb)
120 | 	function Octree(vertices, rootBB)
121 | 	function PhysicalEntity(e, mesh, dynamic)
122 | 	function Physics(dt)
123 | 	function checkCollision(objA, objB)
124 | 	function sphereSphereCollision(objA, objB)
125 | 	function geometryGeometryCollision(objA, objB)
126 | 	function geometrySphereCollision(geom, sphere)
127 | 	function sphereGeometryCollision(sphere, geom)
128 | 	function SignedDistToPlane(point, normal, planeConst)
129 | 	function PointIsInTriangle(point, tri)
130 | 	function ClosestPointOnLine(point, lineA, lineB)
131 | 
132 | 
133 | shaders.js:
134 | 	421 lines and 8 functions
135 | 	
136 | 	function StandardShader()
137 | 	function TextureShader()
138 | 	function AnimationShader()
139 | 	function OrthogonalProjection()
140 | 	function NormalProjection()
141 | 	function StaticMatrix(vMatrix)
142 | 	function FixedMatrix(vMatrix)
143 | 	function initShaders()
144 | 
145 | 
146 | tedge.js:
147 | 	1260 lines and 47 functions
148 | 	
149 | 	function run()
150 | 	function Load(constructorList, callback)
151 | 	function LoadInstance()
152 | 	function connect()
153 | 	function receive(type, arg)
154 | 	function receiveAll(type, N, arg)
155 | 	function receiveNew(type, arg)
156 | 	function initGL()
157 | 	function render()
158 | 	function loadTexture(file)
159 | 	function setTexture(texture)
160 | 	function handleLoadedTexture(texture)
161 | 	function StoreTexture(texture, bitmap)
162 | 	function MakeTexture(shader, size)
163 | 	function UpdateTexture(texture, shader)
164 | 	function PackTexture(shaders, size)
165 | 	function BufferMesh(mesh)
166 | 	function UpdateMesh(mesh)
167 | 	function DrawMesh(mesh, worldMtx, shader, wireframe)
168 | 	function CloneMesh(mesh)
169 | 	function TransformMesh(mesh, mtx)
170 | 	function TransformMeshNonlinear(mesh, transformFunction)
171 | 	function TransformMeshUVs(mesh, affineMatrix)
172 | 	function InputtingEntity(e, player)
173 | 	function onKeyDown(evt)
174 | 	function onKeyUp(evt)
175 | 	function onMouseDown(evt)
176 | 	function onMouseUp(evt)
177 | 	function onMouseMove(evt)
178 | 	function startGame()
179 | 	function gameLoop()
180 | 	function update(dt)
181 | 	function removeEntity(e)
182 | 	function StaticEntity(mesh, mdlMtx)
183 | 	function DynamicEntity(origMesh, mdlMtx)
184 | 	function addPoint(mesh, values, x, z, wrap, u, v)
185 | 	function Math2Mesh(maths, xrange, zrange, quality)
186 | 	function Math2MeshSphere(maths, slices, cuts)
187 | 	function Math2MeshCylinder(maths, slices, cuts, caps)
188 | 	function Math2MeshTunnel(maths, slices, cuts, caps)
189 | 	function Math2MeshPath(path, cuts)
190 | 	function SimplePhysics(p, dt)
191 | 	function FPSCounter()
192 | 	function LoadingScreen()
193 | 	function Camera(vector)
194 | 	function TrackingCamera(target)
195 | 	function FPSCamera()
196 | 
197 | 
198 | textures.js:
199 | 	382 lines and 20 functions
200 | 	
201 | 	function CrateTexture()
202 | 	function WoodGrainTexture()
203 | 	function LeafTexture()
204 | 	function HazardTexture()
205 | 	function PanelTexture()
206 | 	function SteelGridTexture()
207 | 	function CheckeredTexture()
208 | 	function DeepPurpleTexture()
209 | 	function FunHouseTexture()
210 | 	function CorrugatedSteelTexture()
211 | 	function HazardSteelTexture()
212 | 	function LightParticleTexture()
213 | 	function GetParticleTexture()
214 | 	function HexagonalTexture()
215 | 	function HelmetTexture()
216 | 	function TargettingTexture()
217 | 	function SpaceBoxTexture(face)
218 | 	function BlobTexture()
219 | 	function PlasmaGunTexture()
220 | 	function TextureViewer()
221 | 
222 | 
223 | 4504 lines and 167 functions for the entire project. Total filesize: 127.079kb:
224 | 


--------------------------------------------------------------------------------
/dots/server.js:
--------------------------------------------------------------------------------
  1 | /* js echo server
  2 |  */
  3 | 
  4 | // NODE LIBRARIES ////////////////////////////////////////////////////////////
  5 | var sys 	= require('sys');
  6 | var http	= require('http');
  7 | var fs 		= require('fs');
  8 | var url 	= require('url');
  9 | 
 10 | // uses socket.io 0.7.9
 11 | var sio		= require('socket.io');
 12 | 
 13 | // CONSTANTS /////////////////////////////////////////////////////////////////
 14 | var PORT	= 8080;
 15 | 
 16 | // DATA STRUCTURES ///////////////////////////////////////////////////////////
 17 | var uid		= 1;	// unique id counter
 18 | var clients	= [];	// array of socket.io client objects
 19 | 
 20 | 
 21 | // PROTOCOL //////////////////////////////////////////////////////////////////
 22 | //
 23 | // SERVER -> CLIENT:
 24 | //   {event: 'hi', id: u_id}
 25 | //
 26 | // CLIENT -> SERVER:
 27 | //   {event: 'pos', blah blah}	- rebroadcast message volatile
 28 | //   {blah blah blah}			- rebroadcast message
 29 | //
 30 | 
 31 | function debug(message)
 32 | {
 33 | 	sys.puts("error: " + message);
 34 | }
 35 | 
 36 | var mime_types = 
 37 | {
 38 | 	html:"text/html",
 39 | 	htm:"text/html",
 40 | 	css:"text/css",
 41 | 	js:"text/javascript",
 42 | 	png:"image/png",
 43 | 	jpg:"image/jpeg",
 44 | 	ico:"image/vnd.microsoft.icon",
 45 | 	txt:"text/plain"
 46 | };
 47 | 
 48 | // SERVER HANDLERS ///////////////////////////////////////////////////////////
 49 | 
 50 | function staticFileHandler(filename)
 51 | {
 52 | 	// cache the data ahead of time
 53 | 	var file = fs.readFileSync(filename, "binary");
 54 | 	var stats = fs.statSync(filename);
 55 | 	var etag = '"' + stats.ino + '-' + stats.size + '-' + Date.parse(stats.mtime) + '"';
 56 | 	
 57 | 	var i = filename.lastIndexOf(".");
 58 | 	var content_type = "text/plain";
 59 | 	if (i != -1) 
 60 | 	{
 61 | 		var extension = filename.substring(i+1);
 62 | 		if (extension != "" && mime_types[extension] != undefined)
 63 | 			content_type = mime_types[extension];
 64 | 	}	
 65 | 	
 66 | 	var header = {
 67 | 		"Server": 			"tank-game",
 68 | 		"ETag": 			etag,
 69 | 		"Content-Type": 	content_type,
 70 | 		"Content-Length": 	file.length
 71 | 	}
 72 | 	
 73 | 	return function(request, response)
 74 | 	{
 75 | 		if (request.headers['if-none-match'] != undefined && 
 76 | 			request.headers['if-none-match'].indexOf(etag) != -1)
 77 | 		{
 78 | 			//sys.puts("304 on " + filename);
 79 | 			response.writeHead(304);
 80 | 			response.end();
 81 | 			return;
 82 | 		}
 83 | 
 84 | 		// sys.puts("Serving file " + filename + ".");		
 85 | 		response.writeHead(200, header);  
 86 | 		response.write(file, "binary");  
 87 | 		response.end();
 88 | 	};
 89 | }
 90 | 
 91 | var root = staticFileHandler("index.html");
 92 | var handler = {};
 93 | 
 94 | function listFile(file) { handler[file] = staticFileHandler(file); }
 95 | 
 96 | // list of files on the server
 97 | handler["index.html"] 	= root;
 98 | listFile("favicon.ico");
 99 | listFile("server.js");
100 | listFile("game.js");
101 | listFile("tedge.js");
102 | listFile("meshes.js");
103 | listFile("glMatrix-0.9.5.min.js");
104 | listFile("thick.png");
105 | listFile("thin.png");
106 | 
107 | // FILE SERVER ///////////////////////////////////////////////////////////////
108 | server = http.createServer(function(req, resp)
109 | {
110 | 	var uri = url.parse(req.url).pathname;
111 | 	var filename = uri.substring(1);
112 | 
113 | 	if (filename)
114 | 	{
115 | 		if (handler[filename])
116 | 		{
117 | 			handler[filename](req, resp);
118 | 		}
119 | 		else
120 | 		{		
121 | 			resp.writeHead(404, {"Content-Type": "text/plain"});  
122 | 			resp.write("Error 404: file not found");  
123 | 			resp.end();
124 | 			debug("requested invalid file: '" + filename + "'");			
125 | 		}
126 | 	}
127 | 	else
128 | 	{
129 | 		root(req, resp);
130 | 	}
131 | });
132 | 
133 | server.listen(PORT);
134 | 
135 | // SOCKET.IO SERVER //////////////////////////////////////////////////////////
136 | 
137 | var io = sio.listen(server); 
138 | io.sockets.on('connection', function(client)
139 | { 
140 | 	// new player connected
141 | 	var user_id = uid++;
142 | 	clients[user_id] = client;
143 | 	
144 | 	// incoming ajax
145 | 	client.on('message', function(msg)
146 | 	{
147 | 		if (msg.event == 'pos')
148 | 		{
149 | 			client.volatile.broadcast.json.send(msg);
150 | 		}
151 | 		else
152 | 		{
153 | 			client.broadcast.json.send(msg);
154 | 		}
155 | 	}); 
156 | 	
157 | 	// client disconnect
158 | 	client.on('disconnect', function()
159 | 	{
160 | 		delete clients[user_id];
161 | 	});
162 | 	
163 | 	// begin the handshake
164 | 	client.json.send({event: "hi", id: user_id});
165 | 	
166 | 	sys.puts("New player with id " + user_id);
167 | }); 
168 | 


--------------------------------------------------------------------------------
/dots/thick.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/teamduck/gametube/40e8ea4b963148dadadea1f7d28f6d10e0a07953/dots/thick.png


--------------------------------------------------------------------------------
/dots/thin.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/teamduck/gametube/40e8ea4b963148dadadea1f7d28f6d10e0a07953/dots/thin.png


--------------------------------------------------------------------------------
/ducks/convert.html:
--------------------------------------------------------------------------------
 1 | <html>
 2 | <head>
 3 | <title>model process</title>
 4 | <script>
 5 | function process()
 6 | {
 7 | 	var m = document.getElementById('ms').value;
 8 | 	var data = m.split('\n');
 9 | 	var i = 5;
10 | 	var line = data[i];
11 | 	var parts = line.split(' ');
12 | 	var n_meshes = parseInt(parts[1]);
13 | 	if (n_meshes != 1)
14 | 		alert("lol u should have exactly 1 mesh");
15 | 	i++;
16 | 	
17 | 	line = data[i];
18 | 	var name = line.split(' ')[0];
19 | 	name = name.substring(1, name.length - 1);
20 | 	alert(name + " name");
21 | 	i++;
22 | 	
23 | 	var num_verts = parseInt(data[i]);
24 | 	alert(num_verts + " verts");
25 | 	var vert_data = [];
26 | 	var uv_data = [];
27 | 	i++;
28 | 	for (var j = 0; j < num_verts; j++)
29 | 	{
30 | 		line = data[i + j];
31 | 		parts = line.split(' ');
32 | 		for (var x = 1; x < 4; x++)
33 | 			vert_data.push(parseFloat(parts[x]));
34 | 		for (var x = 4; x < 6; x++)
35 | 			uv_data.push(parseFloat(parts[x]));
36 | 	}
37 | 	i += num_verts;
38 | 	
39 | 	var num_normals = parseInt(data[i]);
40 | 	alert(num_normals + " normals");
41 | 	i++;
42 | 	i += num_normals;
43 | 	
44 | 	var f_verts = [];
45 | 	var f_uvs = [];
46 | 	
47 | 	var num_tris = parseInt(data[i]);
48 | 	alert(num_tris + " tris");
49 | 	i++;
50 | 	for (var j = 0; j < num_tris; j++)
51 | 	{
52 | 		var idxs = data[i + j].split(' ');
53 | 		for (var x = 1; x < 4; x++)
54 | 		{
55 | 			var idx = idxs[x];
56 | 			for (var k = 0; k < 3; k++)
57 | 			{
58 | 				f_verts.push(vert_data[idx*3 + k]);
59 | 			}
60 | 			for (var k = 0; k < 2; k++)
61 | 			{
62 | 				f_uvs.push(uv_data[idx*2 + k]);
63 | 			}
64 | 		}
65 | 	}
66 | 	
67 | 	var mesh = {count: num_tris, vertices: f_verts, uvs: f_uvs};
68 | 
69 | 	var output = document.getElementById('out');
70 | 	output.value = name + " = " + JSON.stringify(mesh);
71 | }
72 | 
73 | </script>
74 | </head>
75 | <body>
76 | <span style="font-size: 18pt; font-weight: bold;">MilkShape ASCII -> JS Model Convertar&nbsp;</span><span style="font-size: 11pt;">by greg</span><br /><br />
77 | 
78 | <br />
79 | <input value="process" type="button" onClick="process();" />
80 | 
81 | ASCII:
82 | <textarea id="ms" style="width: 100%; height:100px;"></textarea>
83 | <br />
84 | JS:
85 | <textarea id="out" style="width: 100%; height:100px;"></textarea>
86 | <br />
87 | 
88 | <br /><br />
89 | </body>
90 | </html>
91 | 


--------------------------------------------------------------------------------
/ducks/duck.zip:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/teamduck/gametube/40e8ea4b963148dadadea1f7d28f6d10e0a07953/ducks/duck.zip


--------------------------------------------------------------------------------
/ducks/game.js:
--------------------------------------------------------------------------------
 1 | /* Quack Arena.js
 2 |  * 12/2011
 3 |  * by Team Duck
 4 |  * ***************/
 5 |     
 6 | function Box()
 7 | {
 8 |     var b = StaticEntity(BOX_MESH, Mat4Mult(Mat4Scale(Math.random()*13+1),Mat4World(Vector3(),QuatXYZ(Math.random(),Math.random(),Math.random()))));
 9 |     b.pos = [Math.random()*100.0 - 50, Math.random() * 7.0 - 5.0, Math.random()*100.0 - 50];
10 |     return b;
11 | }
12 | 
13 | function Level()
14 | {
15 |     var placement = Mat4Scale(100);    
16 |     placement = Mat4Mult(placement, Mat4World(Vector3(-50.0, -100.0, -50.0),Quat()));
17 |     //placement = Mat4Mult(Mat4Scale(100), Mat4World(Vector3(), QuatXYZ(0.1, 0.0, 0.0)));
18 |     var l = StaticEntity(BOX_MESH, placement);
19 |     //l.pos = Vector3(-50.0, -100.0, -50.0);
20 |     return l;
21 | }
22 | 
23 | function Player(puid)
24 | {
25 |     var p = DynamicEntity(DUCK_MESH, Mat4World(Vector3(), QuatXYZ(0, 3.14, 0)));//, Mat4Scale(1));
26 |     InputtingEntity(p, puid);
27 |     
28 |     p.pos = [3.0, 12.0, 3.0];
29 |     
30 |     p.update = function (dt)
31 |     {
32 |         //setTexture(loadTexture("thick.png"));
33 |         p.force = Vector3(0.0, -60.0, 0.0);
34 |         p.rotVel = Quat();
35 |         //p.acl[0] = 0; p.acl[1] = 0; p.acl[2] = 0;
36 |         if (p.keyDown(K_UP)) 
37 |             p.acl = VecAdd(p.acl, VecRotate(VecScale(VEC_FORWARD, 30.0), p.rot));
38 |         if (p.keyDown(K_DOWN)) 
39 |             p.acl = VecAdd(p.acl, VecRotate(VecScale(VEC_FORWARD, -15.0), p.rot));
40 |         if (p.keyDown(K_LEFT)) p.rotVel = QuatXYZ(0.0, 1.5, 0.0);
41 |         //p.rot = QuatMult(p.rot, QuatXYZ(0.0, -dt, 0.0));
42 |         if (p.keyDown(K_RIGHT)) p.rotVel = QuatXYZ(0.0, -1.5, 0.0);
43 |         //p.rot = QuatMult(p.rot, QuatXYZ(0.0, dt * 100, 0.0));
44 |         if (p.keyDown(K_SPACE))
45 |         {
46 |             //receiveNew(Bullet, p);
47 |             p.acl[1] = 20.0;
48 |         }
49 |     }
50 |     
51 |     p.health = 5;
52 |     p.hit = function (by)
53 |     {
54 |         p.health--;
55 |     }
56 |     
57 |     return p;
58 | }
59 | 
60 | Camera = createTrackingCamera;
61 | 
62 | function Bullet(shooter)
63 | {
64 |     var b = DynamicEntity(BULLET_MESH);
65 |     b.pos = shooter.pos;
66 |     b.rot = shooter.rot;
67 |     b.vel = VecRotate(VecScale(VEC_FORWARD, 100.0), b.rot);
68 |     
69 |     b.collision = function (target)
70 |     {
71 |         if (target != shooter)
72 |         {
73 |             if (target.hit) target.hit(shooter);
74 |             removeEntity(b);
75 |         }
76 |     }
77 |     
78 |     return b;
79 | }
80 | 
81 | function gameInit()
82 | {
83 |     puid = connect("server:port");
84 |     
85 |     // receive / create game data
86 |     obstacles = receiveAll(Box, 50);
87 |     level = receive(Level);
88 |     players = receiveAll(Player);
89 |     bullets = receiveAll(Bullet);
90 | 
91 |     player = receiveNew(Player, puid);
92 |     gCamera = receiveNew(Camera, player);
93 | 
94 |     // hand over control to tedge / tedge server enterprise
95 |     startGame();
96 | }
97 | 


--------------------------------------------------------------------------------
/ducks/index.html:
--------------------------------------------------------------------------------
 1 | <html>
 2 | 	<head>
 3 | 		<title>TANK GAME</title>
 4 | 		<script src="/socket.io/socket.io.js"></script>
 5 | 		<script src="glMatrix-0.9.5.min.js"></script>
 6 | 		<script src="tedge.js"></script>
 7 |         <script src="physics.js"></script>
 8 | 		<script src="meshes.js"></script>
 9 | 		<script src="game.js"></script>
10 | 		</script>		
11 | 	</head>
12 | 	<body onload="run();">
13 | 		<canvas id="game" style="border: none;" width="800" height="600">
14 | 		</canvas>
15 | 	</body>
16 | </html>
17 | 


--------------------------------------------------------------------------------
/ducks/node_modules/socket.io/.gitignore:
--------------------------------------------------------------------------------
 1 | .DS_Store
 2 | lib-cov
 3 | *.seed
 4 | *.log
 5 | *.csv
 6 | *.dat
 7 | *.out
 8 | *.pid
 9 | node_modules
10 | 


--------------------------------------------------------------------------------
/ducks/node_modules/socket.io/.npmignore:
--------------------------------------------------------------------------------
1 | support
2 | test
3 | examples
4 | 


--------------------------------------------------------------------------------
/ducks/node_modules/socket.io/History.md:
--------------------------------------------------------------------------------
 1 | 
 2 | 0.7.9 / 2011-08-12
 3 | ==================
 4 | 
 5 |   * Updated socket.io-client.
 6 |   * Make sure we only do garbage collection when the server we receive is actually run.
 7 | 
 8 | 0.7.8 / 2011-08-08
 9 | ==================
10 | 
11 |   * Changed; make sure sio#listen passes options to both HTTP server and socket.io manager.
12 |   * Added docs for sio#listen.
13 |   * Added options parameter support for Manager constructor.
14 |   * Added memory leaks tests and test-leaks Makefile task.
15 |   * Removed auto npm-linking from make test.
16 |   * Make sure that you can disable heartbeats. [3rd-Eden]
17 |   * Fixed rooms memory leak [3rd-Eden]
18 |   * Send response once we got all POST data, not immediately [Pita]
19 |   * Fixed onLeave behavior with missing clientsk [3rd-Eden]
20 |   * Prevent duplicate references in rooms.
21 |   * Added alias for `to` to `in` and `in` to `to`.
22 |   * Fixed roomClients definition.
23 |   * Removed dependency on redis for installation without npm [3rd-Eden]
24 |   * Expose path and querystring in handshakeData [3rd-Eden]
25 | 
26 | 0.7.7 / 2011-07-12
27 | ==================
28 | 
29 |   * Fixed double dispatch handling with emit to closed clients.
30 |   * Added test for emitting to closed clients to prevent regression.
31 |   * Fixed race condition in redis test.
32 |   * Changed Transport#end instrumentation.
33 |   * Leveraged $emit instead of emit internally.
34 |   * Made tests faster.
35 |   * Fixed double disconnect events.
36 |   * Fixed disconnect logic
37 |   * Simplified remote events handling in Socket.
38 |   * Increased testcase timeout.
39 |   * Fixed unknown room emitting (GH-291). [3rd-Eden]
40 |   * Fixed `address` in handshakeData. [3rd-Eden]
41 |   * Removed transports definition in chat example.
42 |   * Fixed room cleanup
43 |   * Fixed; make sure the client is cleaned up after booting.
44 |   * Make sure to mark the client as non-open if the connection is closed.
45 |   * Removed unneeded `buffer` declarations.
46 |   * Fixed; make sure to clear socket handlers and subscriptions upon transport close.
47 | 
48 | 0.7.6 / 2011-06-30
49 | ==================
50 | 
51 |   * Fixed general dispatching when a client has closed.
52 | 
53 | 0.7.5 / 2011-06-30
54 | ==================
55 | 
56 |   * Fixed dispatching to clients that are disconnected.
57 | 
58 | 0.7.4 / 2011-06-30
59 | ==================
60 | 
61 |   * Fixed; only clear handlers if they were set. [level09]
62 | 
63 | 0.7.3 / 2011-06-30
64 | ==================
65 | 
66 |   * Exposed handshake data to clients.
67 |   * Refactored dispatcher interface.
68 |   * Changed; Moved id generation method into the manager.
69 |   * Added sub-namespace authorization. [3rd-Eden]
70 |   * Changed; normalized SocketNamespace local eventing [dvv]
71 |   * Changed; Use packet.reason or default to 'packet' [3rd-Eden]
72 |   * Changed console.error to console.log.
73 |   * Fixed; bind both servers at the same time do that the test never times out.
74 |   * Added 304 support.
75 |   * Removed `Transport#name` for abstract interface.
76 |   * Changed; lazily require http and https module only when needed. [3rd-Eden]
77 | 
78 | 0.7.2 / 2011-06-22
79 | ==================
80 | 
81 |   * Make sure to write a packet (of type `noop`) when closing a poll.
82 |     This solves a problem with cross-domain requests being flagged as aborted and
83 |     reconnection being triggered.
84 |   * Added `noop` message type.
85 | 
86 | 0.7.1 / 2011-06-21 
87 | ==================
88 | 
89 |   * Fixed cross-domain XHR.
90 |   * Added CORS test to xhr-polling suite.
91 | 
92 | 0.7.0 / 2010-06-21
93 | ==================
94 | 
95 |   * http://socket.io/announcement.html
96 | 


--------------------------------------------------------------------------------
/ducks/node_modules/socket.io/Makefile:
--------------------------------------------------------------------------------
 1 | 
 2 | ALL_TESTS = $(shell find test/ -name '*.test.js')
 3 | 
 4 | run-tests:
 5 | 	@./node_modules/.bin/expresso \
 6 | 		-t 3000 \
 7 | 		-I support \
 8 | 		-I lib \
 9 | 		--serial \
10 | 		$(TESTFLAGS) \
11 | 		$(TESTS)
12 | 
13 | test:
14 | 	@$(MAKE) TESTS="$(ALL_TESTS)" run-tests
15 | 
16 | test-cov:
17 | 	@TESTFLAGS=--cov $(MAKE) test
18 | 
19 | test-leaks:
20 | 	@ls test/leaks/* | xargs node --expose_debug_as=debug --expose_gc
21 | 
22 | .PHONY: test
23 | 


--------------------------------------------------------------------------------
/ducks/node_modules/socket.io/Readme.md:
--------------------------------------------------------------------------------
  1 | # Socket.IO
  2 | 
  3 | Socket.IO is a Node.JS project that makes WebSockets and realtime possible in
  4 | all browsers. It also enhances WebSockets by providing built-in multiplexing,
  5 | horizontal scalability, automatic JSON encoding/decoding, and more.
  6 | 
  7 | ## How to Install
  8 | 
  9 |     npm install socket.io
 10 | 
 11 | ## How to use
 12 | 
 13 | First, require `socket.io`:
 14 | 
 15 | ```js
 16 | var io = require('socket.io');
 17 | ```
 18 | 
 19 | Next, attach it to a HTTP/HTTPS server. If you're using the fantastic `express`
 20 | web framework:
 21 | 
 22 | ```js
 23 | var app = express.createServer()
 24 |   , io = io.listen(app);
 25 | 
 26 | app.listen(80);
 27 | 
 28 | io.sockets.on('connection', function (socket) {
 29 |   socket.emit('news', { hello: 'world' });
 30 |   socket.on('my other event', function (data) {
 31 |     console.log(data);
 32 |   });
 33 | });
 34 | ```
 35 | 
 36 | Finally, load it from the client side code:
 37 | 
 38 | ```html
 39 | <script src="/socket.io/socket.io.js"></script>
 40 | <script>
 41 |   var socket = io.connect('http://localhost');
 42 |   socket.on('news', function (data) {
 43 |     console.log(data);
 44 |     socket.emit('my other event', { my: 'data' });
 45 |   });
 46 | </script>
 47 | ```
 48 | 
 49 | For more thorough examples, look at the `examples/` directory.
 50 | 
 51 | ## Short recipes
 52 | 
 53 | ### Sending and receiving events.
 54 | 
 55 | Socket.IO allows you to emit and receive custom events.
 56 | Besides `connect`, `message` and `disconnect`, you can emit custom events:
 57 | 
 58 | ```js
 59 | // note, io.listen(<port>) will create a http server for you
 60 | var io = require('socket.io').listen(80);
 61 | 
 62 | io.sockets.on('connection', function (socket) {
 63 |   io.sockets.emit('this', { will: 'be received by everyone');
 64 | 
 65 |   socket.on('private message', function (from, msg) {
 66 |     console.log('I received a private message by ', from, ' saying ', msg);
 67 |   });
 68 | 
 69 |   socket.on('disconnect', function () {
 70 |     sockets.emit('user disconnected');
 71 |   });
 72 | });
 73 | ```
 74 | 
 75 | ### Storing data associated to a client
 76 | 
 77 | Sometimes it's necessary to store data associated with a client that's
 78 | necessary for the duration of the session.
 79 | 
 80 | #### Server side
 81 | 
 82 | ```js
 83 | var io = require('socket.io').listen(80);
 84 | 
 85 | io.sockets.on('connection', function (socket) {
 86 |   socket.on('set nickname', function (name) {
 87 |     socket.set('nickname', name, function () { socket.emit('ready'); });
 88 |   });
 89 | 
 90 |   socket.on('msg', function () {
 91 |     socket.get('nickname', function (err, name) {
 92 |       console.log('Chat message by ', name);
 93 |     });
 94 |   });
 95 | });
 96 | ```
 97 | 
 98 | #### Client side
 99 | 
100 | ```html
101 | <script>
102 |   var socket = io.connect('http://localhost');
103 | 
104 |   socket.on('connect', function () {
105 |     socket.emit('set nickname', confirm('What is your nickname?'));
106 |     socket.on('ready', function () {
107 |       console.log('Connected !');
108 |       socket.emit('msg', confirm('What is your message?'));
109 |     });
110 |   });
111 | </script>
112 | ```
113 | 
114 | ### Restricting yourself to a namespace
115 | 
116 | If you have control over all the messages and events emitted for a particular
117 | application, using the default `/` namespace works.
118 | 
119 | If you want to leverage 3rd-party code, or produce code to share with others,
120 | socket.io provides a way of namespacing a `socket`.
121 | 
122 | This has the benefit of `multiplexing` a single connection. Instead of
123 | socket.io using two `WebSocket` connections, it'll use one.
124 | 
125 | The following example defines a socket that listens on '/chat' and one for
126 | '/news':
127 | 
128 | #### Server side
129 | 
130 | ```js
131 | var io = require('socket.io').listen(80);
132 | 
133 | var chat = io
134 |   .of('/chat');
135 |   .on('connection', function (socket) {
136 |     socket.emit('a message', { that: 'only', '/chat': 'will get' });
137 |     chat.emit('a message', { everyone: 'in', '/chat': 'will get' });
138 |   });
139 | 
140 | var news = io
141 |   .of('/news');
142 |   .on('connection', function (socket) {
143 |     socket.emit('item', { news: 'item' });
144 |   });
145 | ```
146 | 
147 | #### Client side:
148 | 
149 | ```html
150 | <script>
151 |   var chat = io.connect('http://localhost/chat')
152 |     , news = io.connect('http://localhost/news');
153 | 
154 |   chat.on('connect', function () {
155 |     chat.emit('hi!');
156 |   });
157 | 
158 |   news.on('news', function () {
159 |     news.emit('woot');
160 |   });
161 | </script>
162 | ```
163 | 
164 | ### Sending volatile messages.
165 | 
166 | Sometimes certain messages can be dropped. Let's say you have an app that
167 | shows realtime tweets for the keyword `bieber`. 
168 | 
169 | If a certain client is not ready to receive messages (because of network slowness
170 | or other issues, or because he's connected through long polling and is in the
171 | middle of a request-response cycle), if he doesn't receive ALL the tweets related
172 | to bieber your application won't suffer.
173 | 
174 | In that case, you might want to send those messages as volatile messages.
175 | 
176 | #### Server side
177 | 
178 | ```js
179 | var io = require('socket.io').listen(80);
180 | 
181 | io.sockets.on('connection', function (socket) {
182 |   var tweets = setInterval(function () {
183 |     getBieberTweet(function (tweet) {
184 |       socket.volatile.emit('bieber tweet', tweet);
185 |     });
186 |   }, 100);
187 | 
188 |   socket.on('disconnect', function () {
189 |     clearInterval(tweets);
190 |   });
191 | });
192 | ```
193 | 
194 | #### Client side
195 | 
196 | In the client side, messages are received the same way whether they're volatile
197 | or not.
198 | 
199 | ### Getting acknowledgements
200 | 
201 | Sometimes, you might want to get a callback when the client confirmed the message
202 | reception.
203 | 
204 | To do this, simply pass a function as the last parameter of `.send` or `.emit`.
205 | What's more, when you use `.emit`, the acknowledgement is done by you, which
206 | means you can also pass data along:
207 | 
208 | #### Server side
209 | 
210 | ```js
211 | var io = require('socket.io').listen(80);
212 | 
213 | io.sockets.on('connection', function (socket) {
214 |   socket.on('ferret', function (name, fn) {
215 |     fn('woot');
216 |   });
217 | });
218 | ```
219 | 
220 | #### Client side
221 | 
222 | ```html
223 | <script>
224 |   var socket = io.connect(); // TIP: .connect with no args does auto-discovery
225 |   socket.on('connection', function () {
226 |     socket.emit('ferret', 'tobi', function (data) {
227 |       console.log(data); // data will be 'woot'
228 |     });
229 |   });
230 | </script>
231 | ```
232 | 
233 | ### Broadcasting messages
234 | 
235 | To broadcast, simply add a `broadcast` flag to `emit` and `send` method calls.
236 | Broadcasting means sending a message to everyone else except for the socket
237 | that starts it.
238 | 
239 | #### Server side
240 | 
241 | ```js
242 | var io = require('socket.io').listen(80);
243 | 
244 | io.sockets.on('connection', function (socket) {
245 |   socket.broadcast.emit('user connected');
246 |   socket.broadcast.json.send({ a: 'message' });
247 | });
248 | ```
249 | 
250 | ### Rooms
251 | 
252 | Sometimes you want to put certain sockets in the same room, so that it's easy
253 | to broadcast to all of them together.
254 | 
255 | Think of this as built-in channels for sockets. Sockets `join` and `leave`
256 | rooms in each socket.
257 | 
258 | #### Server side
259 | 
260 | ```js
261 | var io = require('socket.io').listen(80);
262 | 
263 | io.sockets.on('connection', function (socket) {
264 |   socket.join('justin bieber fans');
265 |   socket.broadcast.to('justin bieber fans').emit('new fan');
266 |   io.sockets.in('rammstein fans').emit('new non-fan');
267 | });
268 | ```
269 | 
270 | ### Using it just as a cross-browser WebSocket
271 | 
272 | If you just want the WebSocket semantics, you can do that too.
273 | Simply leverage `send` and listen on the `message` event:
274 | 
275 | #### Server side
276 | 
277 | ```js
278 | var io = require('socket.io').listen(80);
279 | 
280 | io.sockets.on('connection', function (socket) {
281 |   socket.on('message', function () { });
282 |   socket.on('disconnect', function () { });
283 | });
284 | ```
285 | 
286 | #### Client side
287 | 
288 | ```html
289 | <script>
290 |   var socket = io.connect('http://localhost/');
291 |   socket.on('connect', function () {
292 |     socket.send('hi');
293 | 
294 |     socket.on('message', function (msg) {
295 |       // my msg
296 |     });
297 |   });
298 | </script>
299 | ```
300 | 
301 | ### Changing configuration
302 | 
303 | Configuration in socket.io is TJ-style:
304 | 
305 | #### Server side
306 | 
307 | ```js
308 | var io = require('socket.io').listen(80);
309 | 
310 | io.configure(function () {
311 |   io.set('transports', ['websocket', 'flashsocket', 'xhr-polling']);
312 | });
313 | 
314 | io.configure('development', function () {
315 |   io.set('transports', ['websocket', 'xhr-polling']);
316 |   io.enable('log');
317 | });
318 | ```
319 | 
320 | ## License 
321 | 
322 | (The MIT License)
323 | 
324 | Copyright (c) 2011 Guillermo Rauch &lt;guillermo@learnboost.com&gt;
325 | 
326 | Permission is hereby granted, free of charge, to any person obtaining
327 | a copy of this software and associated documentation files (the
328 | 'Software'), to deal in the Software without restriction, including
329 | without limitation the rights to use, copy, modify, merge, publish,
330 | distribute, sublicense, and/or sell copies of the Software, and to
331 | permit persons to whom the Software is furnished to do so, subject to
332 | the following conditions:
333 | 
334 | The above copyright notice and this permission notice shall be
335 | included in all copies or substantial portions of the Software.
336 | 
337 | THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
338 | EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
339 | MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
340 | IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
341 | CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
342 | TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
343 | SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
344 | 


--------------------------------------------------------------------------------
/ducks/node_modules/socket.io/index.js:
--------------------------------------------------------------------------------
1 | 
2 | /*!
3 |  * socket.io-node
4 |  * Copyright(c) 2011 LearnBoost <dev@learnboost.com>
5 |  * MIT Licensed
6 |  */
7 | 
8 | module.exports = require('./lib/socket.io');
9 | 


--------------------------------------------------------------------------------
/ducks/node_modules/socket.io/lib/logger.js:
--------------------------------------------------------------------------------
 1 | 
 2 | /*!
 3 |  * socket.io-node
 4 |  * Copyright(c) 2011 LearnBoost <dev@learnboost.com>
 5 |  * MIT Licensed
 6 |  */
 7 | 
 8 | /**
 9 |  * Module dependencies.
10 |  */
11 | 
12 | var util = require('./util')
13 |   , toArray = util.toArray;
14 | 
15 | /**
16 |  * Log levels.
17 |  */
18 | 
19 | var levels = [
20 |     'error'
21 |   , 'warn'
22 |   , 'info'
23 |   , 'debug'
24 | ];
25 | 
26 | /**
27 |  * Colors for log levels.
28 |  */
29 | 
30 | var colors = [
31 |     31
32 |   , 33
33 |   , 36
34 |   , 90
35 | ];
36 | 
37 | /**
38 |  * Pads the nice output to the longest log level.
39 |  */
40 | 
41 | function pad (str) {
42 |   var max = 0;
43 | 
44 |   for (var i = 0, l = levels.length; i < l; i++)
45 |     max = Math.max(max, levels[i].length);
46 | 
47 |   if (str.length < max)
48 |     return str + new Array(max - str.length + 1).join(' ');
49 | 
50 |   return str;
51 | };
52 | 
53 | /**
54 |  * Logger (console).
55 |  *
56 |  * @api public
57 |  */
58 | 
59 | var Logger = module.exports = function (opts) {
60 |   opts = opts || {}
61 |   this.colors = false !== opts.colors;
62 |   this.level = 3;
63 | };
64 | 
65 | /**
66 |  * Log method.
67 |  *
68 |  * @api public
69 |  */
70 | 
71 | Logger.prototype.log = function (type) {
72 |   var index = levels.indexOf(type);
73 | 
74 |   if (index > this.level)
75 |     return this;
76 | 
77 |   console.log.apply(
78 |       console
79 |     , [this.colors
80 |         ? '   \033[' + colors[index] + 'm' + pad(type) + ' -\033[39m'
81 |         : type + ':'
82 |       ].concat(toArray(arguments).slice(1))
83 |   );
84 | 
85 |   return this;
86 | };
87 | 
88 | /**
89 |  * Generate methods.
90 |  */
91 | 
92 | levels.forEach(function (name) {
93 |   Logger.prototype[name] = function () {
94 |     this.log.apply(this, [name].concat(toArray(arguments)));
95 |   };
96 | });
97 | 


--------------------------------------------------------------------------------
/ducks/node_modules/socket.io/lib/namespace.js:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * Module dependencies.
  3 |  */
  4 | 
  5 | var Socket = require('./socket')
  6 |   , EventEmitter = process.EventEmitter
  7 |   , parser = require('./parser')
  8 |   , util = require('./util');
  9 | 
 10 | /**
 11 |  * Exports the constructor.
 12 |  */
 13 | 
 14 | exports = module.exports = SocketNamespace;
 15 | 
 16 | /**
 17 |  * Constructor.
 18 |  *
 19 |  * @api public.
 20 |  */
 21 | 
 22 | function SocketNamespace (mgr, name) {
 23 |   this.manager = mgr;
 24 |   this.name = name || '';
 25 |   this.sockets = {};
 26 |   this.auth = false;
 27 |   this.setFlags();
 28 | };
 29 | 
 30 | /**
 31 |  * Inherits from EventEmitter.
 32 |  */
 33 | 
 34 | SocketNamespace.prototype.__proto__ = EventEmitter.prototype;
 35 | 
 36 | /**
 37 |  * Copies emit since we override it
 38 |  *
 39 |  * @api private
 40 |  */
 41 | 
 42 | SocketNamespace.prototype.$emit = EventEmitter.prototype.emit;
 43 | 
 44 | /**
 45 |  * Retrieves all clients as Socket instances as an array.
 46 |  *
 47 |  * @api public
 48 |  */
 49 | 
 50 | SocketNamespace.prototype.clients = function (room) {
 51 |   var room = this.name + (room !== undefined ?
 52 |      '/' + room : '');
 53 | 
 54 |   if (!this.manager.rooms[room]) {
 55 |     return [];
 56 |   }
 57 | 
 58 |   return this.manager.rooms[room].map(function (id) {
 59 |     return this.socket(id);
 60 |   }, this);
 61 | };
 62 | 
 63 | /**
 64 |  * Access logger interface.
 65 |  *
 66 |  * @api public
 67 |  */
 68 | 
 69 | SocketNamespace.prototype.__defineGetter__('log', function () {
 70 |   return this.manager.log;
 71 | });
 72 | 
 73 | /**
 74 |  * Access store.
 75 |  *
 76 |  * @api public
 77 |  */
 78 | 
 79 | SocketNamespace.prototype.__defineGetter__('store', function () {
 80 |   return this.manager.store;
 81 | });
 82 | 
 83 | /**
 84 |  * JSON message flag.
 85 |  *
 86 |  * @api public
 87 |  */
 88 | 
 89 | SocketNamespace.prototype.__defineGetter__('json', function () {
 90 |   this.flags.json = true;
 91 |   return this;
 92 | });
 93 | 
 94 | /**
 95 |  * Volatile message flag.
 96 |  *
 97 |  * @api public
 98 |  */
 99 | 
100 | SocketNamespace.prototype.__defineGetter__('volatile', function () {
101 |   this.flags.volatile = true;
102 |   return this;
103 | });
104 | 
105 | /**
106 |  * Overrides the room to relay messages to (flag)
107 |  *
108 |  * @api public
109 |  */
110 | 
111 | SocketNamespace.prototype.in = SocketNamespace.prototype.to = function (room) {
112 |   this.flags.endpoint = this.name + (room ? '/' + room : '');
113 |   return this;
114 | };
115 | 
116 | /**
117 |  * Adds a session id we should prevent relaying messages to (flag)
118 |  *
119 |  * @api public
120 |  */
121 | 
122 | SocketNamespace.prototype.except = function (id) {
123 |   this.flags.exceptions.push(id);
124 |   return this;
125 | };
126 | 
127 | /**
128 |  * Sets the default flags.
129 |  *
130 |  * @api private
131 |  */
132 | 
133 | SocketNamespace.prototype.setFlags = function () {
134 |   this.flags = {
135 |       endpoint: this.name
136 |     , exceptions: []
137 |   };
138 |   return this;
139 | };
140 | 
141 | /**
142 |  * Sends out a packet
143 |  *
144 |  * @api private
145 |  */
146 | 
147 | SocketNamespace.prototype.packet = function (packet) {
148 |   packet.endpoint = this.name;
149 | 
150 |   var store = this.store
151 |     , log = this.log
152 |     , volatile = this.flags.volatile
153 |     , exceptions = this.flags.exceptions
154 |     , packet = parser.encodePacket(packet);
155 | 
156 |   this.manager.onDispatch(this.flags.endpoint, packet, volatile, exceptions);
157 |   this.store.publish('dispatch', this.flags.endpoint, packet, volatile, exceptions);
158 | 
159 |   this.setFlags();
160 | 
161 |   return this;
162 | };
163 | 
164 | /**
165 |  * Sends to everyone.
166 |  *
167 |  * @api public
168 |  */
169 | 
170 | SocketNamespace.prototype.send = function (data) {
171 |   return this.packet({
172 |       type: this.flags.json ? 'json' : 'message'
173 |     , data: data
174 |   });
175 | };
176 | 
177 | /**
178 |  * Emits to everyone (override)
179 |  *
180 |  * @api private
181 |  */
182 | 
183 | SocketNamespace.prototype.emit = function (name) {
184 |   if (name == 'newListener') {
185 |     return this.$emit.apply(this, arguments);
186 |   }
187 | 
188 |   return this.packet({
189 |       type: 'event'
190 |     , name: name
191 |     , args: util.toArray(arguments).slice(1)
192 |   });
193 | };
194 | 
195 | /**
196 |  * Retrieves or creates a write-only socket for a client, unless specified.
197 |  *
198 |  * @param {Boolean} whether the socket will be readable when initialized
199 |  * @api private
200 |  */
201 | 
202 | SocketNamespace.prototype.socket = function (sid, readable) {
203 |   if (!this.sockets[sid]) {
204 |     this.sockets[sid] = new Socket(this.manager, sid, this, readable);
205 |   }
206 | 
207 |   return this.sockets[sid];
208 | };
209 | 
210 | /**
211 |  * Sets authorization for this namespace
212 |  *
213 |  * @api public
214 |  */
215 | 
216 | SocketNamespace.prototype.authorization = function (fn) {
217 |   this.auth = fn;
218 |   return this;
219 | };
220 | 
221 | /**
222 |  * Called when a socket disconnects entirely.
223 |  *
224 |  * @api private
225 |  */
226 | 
227 | SocketNamespace.prototype.handleDisconnect = function (sid, reason) {
228 |   if (this.sockets[sid] && this.sockets[sid].readable) {
229 |     this.sockets[sid].onDisconnect(reason);
230 |     delete this.sockets[sid];
231 |   }
232 | };
233 | 
234 | /**
235 |  * Performs authentication.
236 |  *
237 |  * @param Object client request data
238 |  * @api private
239 |  */
240 | 
241 | SocketNamespace.prototype.authorize = function (data, fn) {
242 |   if (this.auth) {
243 |     var self = this;
244 | 
245 |     this.auth.call(this, data, function (err, authorized) {
246 |       self.log.debug('client ' +
247 |         (authorized ? '' : 'un') + 'authorized for ' + self.name);
248 |       fn(err, authorized);
249 |     });
250 |   } else {
251 |     this.log.debug('client authorized for ' + this.name);
252 |     fn(null, true);
253 |   }
254 | 
255 |   return this;
256 | };
257 | 
258 | /**
259 |  * Handles a packet.
260 |  *
261 |  * @api private
262 |  */
263 | 
264 | SocketNamespace.prototype.handlePacket = function (sessid, packet) {
265 |   var socket = this.socket(sessid)
266 |     , dataAck = packet.ack == 'data'
267 |     , self = this;
268 | 
269 |   function ack () {
270 |     self.log.debug('sending data ack packet');
271 |     socket.packet({
272 |         type: 'ack'
273 |       , args: util.toArray(arguments)
274 |       , ackId: packet.id
275 |     });
276 |   };
277 | 
278 |   function error (err) {
279 |     self.log.warn('handshake error ' + err + ' for ' + self.name);
280 |     socket.packet({ type: 'error', reason: err });
281 |   };
282 | 
283 |   function connect () {
284 |     self.manager.onJoin(sessid, self.name);
285 |     self.store.publish('join', sessid, self.name);
286 | 
287 |     // packet echo
288 |     socket.packet({ type: 'connect' });
289 | 
290 |     // emit connection event
291 |     self.$emit('connection', socket);
292 |   };
293 | 
294 |   switch (packet.type) {
295 |     case 'connect':
296 |       if (packet.endpoint == '') {
297 |         connect();
298 |       } else {
299 |         var manager = this.manager
300 |           , handshakeData = manager.handshaken[sessid];
301 | 
302 |         this.authorize(handshakeData, function (err, authorized, newData) {
303 |           if (err) return error(err);
304 | 
305 |           if (authorized) {
306 |             manager.onHandshake(sessid, newData || handshakeData);
307 |             self.store.publish('handshake', sessid, newData || handshakeData);
308 |             connect();
309 |           } else {
310 |             error('unauthorized');
311 |           }
312 |         });
313 |       }
314 |       break;
315 | 
316 |     case 'ack':
317 |       if (socket.acks[packet.ackId]) {
318 |         socket.acks[packet.ackId].apply(socket, packet.args);
319 |       } else {
320 |         this.log.info('unknown ack packet');
321 |       }
322 |       break;
323 | 
324 |     case 'event':
325 |       var params = [packet.name].concat(packet.args);
326 | 
327 |       if (dataAck)
328 |         params.push(ack);
329 | 
330 |       socket.$emit.apply(socket, params);
331 |       break;
332 | 
333 |     case 'disconnect':
334 |       this.manager.onLeave(sessid, this.name);
335 |       this.store.publish('leave', sessid, this.name);
336 | 
337 |       socket.$emit('disconnect', packet.reason || 'packet');
338 |       break;
339 | 
340 |     case 'json':
341 |     case 'message':
342 |       var params = ['message', packet.data];
343 | 
344 |       if (dataAck)
345 |         params.push(ack);
346 | 
347 |       socket.$emit.apply(socket, params);
348 |   };
349 | };
350 | 


--------------------------------------------------------------------------------
/ducks/node_modules/socket.io/lib/parser.js:
--------------------------------------------------------------------------------
  1 | 
  2 | /*!
  3 |  * socket.io-node
  4 |  * Copyright(c) 2011 LearnBoost <dev@learnboost.com>
  5 |  * MIT Licensed
  6 |  */
  7 | 
  8 | /**
  9 |  * Module dependencies.
 10 |  */
 11 | 
 12 | /**
 13 |  * Packet types.
 14 |  */
 15 | 
 16 | var packets = exports.packets = [
 17 |     'disconnect'
 18 |   , 'connect'
 19 |   , 'heartbeat'
 20 |   , 'message'
 21 |   , 'json'
 22 |   , 'event'
 23 |   , 'ack'
 24 |   , 'error'
 25 |   , 'noop'
 26 | ];
 27 | 
 28 | /**
 29 |  * Errors reasons.
 30 |  */
 31 | 
 32 | var reasons = exports.reasons = [
 33 |     'transport not supported'
 34 |   , 'client not handshaken'
 35 |   , 'unauthorized'
 36 | ];
 37 | 
 38 | /**
 39 |  * Errors advice.
 40 |  */
 41 | 
 42 | var advice = exports.advice = [
 43 |     'reconnect'
 44 | ];
 45 | 
 46 | /**
 47 |  * Encodes a packet.
 48 |  *
 49 |  * @api private
 50 |  */
 51 | 
 52 | exports.encodePacket = function (packet) {
 53 |   var type = packets.indexOf(packet.type)
 54 |     , id = packet.id || ''
 55 |     , endpoint = packet.endpoint || ''
 56 |     , ack = packet.ack
 57 |     , data = null;
 58 | 
 59 |   switch (packet.type) {
 60 |     case 'error':
 61 |       var reason = packet.reason ? reasons.indexOf(packet.reason) : ''
 62 |         , adv = packet.advice ? advice.indexOf(packet.advice) : ''
 63 | 
 64 |       if (reason !== '' || adv !== '')
 65 |         data = reason + (adv !== '' ? ('+' + adv) : '')
 66 | 
 67 |       break;
 68 | 
 69 |     case 'message':
 70 |       if (packet.data !== '')
 71 |         data = packet.data;
 72 |       break;
 73 | 
 74 |     case 'event':
 75 |       var ev = { name: packet.name };
 76 | 
 77 |       if (packet.args && packet.args.length) {
 78 |         ev.args = packet.args;
 79 |       }
 80 | 
 81 |       data = JSON.stringify(ev);
 82 |       break;
 83 | 
 84 |     case 'json':
 85 |       data = JSON.stringify(packet.data);
 86 |       break;
 87 | 
 88 |     case 'connect':
 89 |       if (packet.qs)
 90 |         data = packet.qs;
 91 |       break;
 92 | 
 93 |     case 'ack':
 94 |       data = packet.ackId
 95 |         + (packet.args && packet.args.length
 96 |             ? '+' + JSON.stringify(packet.args) : '');
 97 |       break;
 98 |   }
 99 | 
100 |   // construct packet with required fragments
101 |   var encoded = [
102 |       type
103 |     , id + (ack == 'data' ? '+' : '')
104 |     , endpoint
105 |   ];
106 | 
107 |   // data fragment is optional
108 |   if (data !== null && data !== undefined)
109 |     encoded.push(data);
110 | 
111 |   return encoded.join(':');
112 | };
113 | 
114 | /**
115 |  * Encodes multiple messages (payload).
116 |  *
117 |  * @param {Array} messages
118 |  * @api private
119 |  */
120 | 
121 | exports.encodePayload = function (packets) {
122 |   var decoded = '';
123 | 
124 |   if (packets.length == 1)
125 |     return packets[0];
126 | 
127 |   for (var i = 0, l = packets.length; i < l; i++) {
128 |     var packet = packets[i];
129 |     decoded += '\ufffd' + packet.length + '\ufffd' + packets[i]
130 |   }
131 | 
132 |   return decoded;
133 | };
134 | 
135 | /**
136 |  * Decodes a packet
137 |  *
138 |  * @api private
139 |  */
140 | 
141 | var regexp = /^([^:]+):([0-9]+)?(\+)?:([^:]+)?:?(.*)?$/;
142 | 
143 | exports.decodePacket = function (data) {
144 |   var pieces = data.match(regexp);
145 | 
146 |   if (!pieces) return {};
147 | 
148 |   var id = pieces[2] || ''
149 |     , data = pieces[5] || ''
150 |     , packet = {
151 |           type: packets[pieces[1]]
152 |         , endpoint: pieces[4] || ''
153 |       };
154 | 
155 |   // whether we need to acknowledge the packet
156 |   if (id) {
157 |     packet.id = id;
158 |     if (pieces[3])
159 |       packet.ack = 'data';
160 |     else
161 |       packet.ack = true;
162 |   }
163 | 
164 |   // handle different packet types
165 |   switch (packet.type) {
166 |     case 'error':
167 |       var pieces = data.split('+');
168 |       packet.reason = reasons[pieces[0]] || '';
169 |       packet.advice = advice[pieces[1]] || '';
170 |       break;
171 | 
172 |     case 'message':
173 |       packet.data = data || '';
174 |       break;
175 | 
176 |     case 'event':
177 |       try {
178 |         var opts = JSON.parse(data);
179 |         packet.name = opts.name;
180 |         packet.args = opts.args;
181 |       } catch (e) { }
182 | 
183 |       packet.args = packet.args || [];
184 |       break;
185 | 
186 |     case 'json':
187 |       try {
188 |         packet.data = JSON.parse(data);
189 |       } catch (e) { }
190 |       break;
191 | 
192 |     case 'connect':
193 |       packet.qs = data || '';
194 |       break;
195 | 
196 |     case 'ack':
197 |       var pieces = data.match(/^([0-9]+)(\+)?(.*)/);
198 |       if (pieces) {
199 |         packet.ackId = pieces[1];
200 |         packet.args = [];
201 | 
202 |         if (pieces[3]) {
203 |           try {
204 |             packet.args = pieces[3] ? JSON.parse(pieces[3]) : [];
205 |           } catch (e) { }
206 |         }
207 |       }
208 |       break;
209 | 
210 |     case 'disconnect':
211 |     case 'heartbeat':
212 |       break;
213 |   };
214 | 
215 |   return packet;
216 | };
217 | 
218 | /**
219 |  * Decodes data payload. Detects multiple messages
220 |  *
221 |  * @return {Array} messages
222 |  * @api public
223 |  */
224 | 
225 | exports.decodePayload = function (data) {
226 |   if (data[0] == '\ufffd') {
227 |     var ret = [];
228 | 
229 |     for (var i = 1, length = ''; i < data.length; i++) {
230 |       if (data[i] == '\ufffd') {
231 |         ret.push(exports.decodePacket(data.substr(i + 1).substr(0, length)));
232 |         i += Number(length) + 1;
233 |         length = '';
234 |       } else {
235 |         length += data[i];
236 |       }
237 |     }
238 | 
239 |     return ret;
240 |   } else {
241 |     return [exports.decodePacket(data)];
242 |   }
243 | };
244 | 


--------------------------------------------------------------------------------
/ducks/node_modules/socket.io/lib/socket.io.js:
--------------------------------------------------------------------------------
  1 | 
  2 | /*!
  3 |  * socket.io-node
  4 |  * Copyright(c) 2011 LearnBoost <dev@learnboost.com>
  5 |  * MIT Licensed
  6 |  */
  7 | 
  8 | /**
  9 |  * Module dependencies.
 10 |  */
 11 | 
 12 | var client = require('socket.io-client');
 13 | 
 14 | /**
 15 |  * Version.
 16 |  */
 17 | 
 18 | exports.version = '0.7.9';
 19 | 
 20 | /**
 21 |  * Supported protocol version.
 22 |  */
 23 | 
 24 | exports.protocol = 1;
 25 | 
 26 | /**
 27 |  * Client that we serve.
 28 |  */
 29 | 
 30 | exports.clientVersion = client.version;
 31 | 
 32 | /**
 33 |  * Attaches a manager
 34 |  *
 35 |  * @param {HTTPServer/Number} a HTTP/S server or a port number to listen on.
 36 |  * @param {Object} opts to be passed to Manager and/or http server
 37 |  * @param {Function} callback if a port is supplied
 38 |  * @api public
 39 |  */
 40 | 
 41 | exports.listen = function (server, options, fn) {
 42 |   if ('function' == typeof options) {
 43 |     fn = options;
 44 |     options = {};
 45 |   }
 46 | 
 47 |   if ('undefined' == typeof server) {
 48 |     // create a server that listens on port 80
 49 |     server = 80;
 50 |   }
 51 | 
 52 |   if ('number' == typeof server) {
 53 |     // if a port number is passed
 54 |     var port = server;
 55 | 
 56 |     if (options && options.key)
 57 |       server = require('https').createServer(options);
 58 |     else
 59 |       server = require('http').createServer();
 60 | 
 61 |     // default response
 62 |     server.on('request', function (req, res) {
 63 |       res.writeHead(200);
 64 |       res.end('Welcome to socket.io.');
 65 |     });
 66 | 
 67 |     server.listen(port, fn);
 68 |   }
 69 | 
 70 |   // otherwise assume a http/s server
 71 |   return new exports.Manager(server, options);
 72 | };
 73 | 
 74 | /**
 75 |  * Manager constructor.
 76 |  *
 77 |  * @api public
 78 |  */
 79 | 
 80 | exports.Manager = require('./manager');
 81 | 
 82 | /**
 83 |  * Transport constructor.
 84 |  *
 85 |  * @api public
 86 |  */
 87 | 
 88 | exports.Transport = require('./transport');
 89 | 
 90 | /**
 91 |  * Socket constructor.
 92 |  *
 93 |  * @api public
 94 |  */
 95 | 
 96 | exports.Socket = require('./socket');
 97 | 
 98 | /**
 99 |  * Store constructor.
100 |  *
101 |  * @api public
102 |  */
103 | 
104 | exports.Store = require('./store');
105 | 
106 | /**
107 |  * Memory Store constructor.
108 |  *
109 |  * @api public
110 |  */
111 | 
112 | exports.MemoryStore = require('./stores/memory');
113 | 
114 | /**
115 |  * Redis Store constructor.
116 |  *
117 |  * @api public
118 |  */
119 | 
120 | exports.RedisStore = require('./stores/redis');
121 | 
122 | /**
123 |  * Parser.
124 |  *
125 |  * @api public
126 |  */
127 | 
128 | exports.parser = require('./parser');
129 | 


--------------------------------------------------------------------------------
/ducks/node_modules/socket.io/lib/socket.js:
--------------------------------------------------------------------------------
  1 | 
  2 | /*!
  3 |  * socket.io-node
  4 |  * Copyright(c) 2011 LearnBoost <dev@learnboost.com>
  5 |  * MIT Licensed
  6 |  */
  7 | 
  8 | /**
  9 |  * Module dependencies.
 10 |  */
 11 | 
 12 | var parser = require('./parser')
 13 |   , util = require('./util')
 14 |   , EventEmitter = process.EventEmitter;
 15 | 
 16 | /**
 17 |  * Export the constructor.
 18 |  */
 19 | 
 20 | exports = module.exports = Socket;
 21 | 
 22 | /**
 23 |  * Socket constructor.
 24 |  *
 25 |  * @param {Manager} manager instance
 26 |  * @param {String} session id
 27 |  * @param {Namespace} namespace the socket belongs to
 28 |  * @param {Boolean} whether the 
 29 |  * @api public
 30 |  */
 31 | 
 32 | function Socket (manager, id, nsp, readable) {
 33 |   this.id = id;
 34 |   this.namespace = nsp;
 35 |   this.manager = manager;
 36 |   this.disconnected = false;
 37 |   this.ackPackets = 0;
 38 |   this.acks = {};
 39 |   this.setFlags();
 40 |   this.readable = readable;
 41 |   this.store = this.manager.store.client(this.id);
 42 | };
 43 | 
 44 | /**
 45 |  * Inherits from EventEmitter.
 46 |  */
 47 | 
 48 | Socket.prototype.__proto__ = EventEmitter.prototype;
 49 | 
 50 | /**
 51 |  * Accessor shortcut for the handshake data
 52 |  *
 53 |  * @api private
 54 |  */
 55 | 
 56 | Socket.prototype.__defineGetter__('handshake', function () {
 57 |   return this.manager.handshaken[this.id];
 58 | });
 59 | 
 60 | /**
 61 |  * Accessor shortcut for the logger.
 62 |  *
 63 |  * @api private
 64 |  */
 65 | 
 66 | Socket.prototype.__defineGetter__('log', function () {
 67 |   return this.manager.log;
 68 | });
 69 | 
 70 | /**
 71 |  * JSON message flag.
 72 |  *
 73 |  * @api public
 74 |  */
 75 | 
 76 | Socket.prototype.__defineGetter__('json', function () {
 77 |   this.flags.json = true;
 78 |   return this;
 79 | });
 80 | 
 81 | /**
 82 |  * Volatile message flag.
 83 |  *
 84 |  * @api public
 85 |  */
 86 | 
 87 | Socket.prototype.__defineGetter__('volatile', function () {
 88 |   this.flags.volatile = true;
 89 |   return this;
 90 | });
 91 | 
 92 | /**
 93 |  * Broadcast message flag.
 94 |  *
 95 |  * @api public
 96 |  */
 97 | 
 98 | Socket.prototype.__defineGetter__('broadcast', function () {
 99 |   this.flags.broadcast = true;
100 |   return this;
101 | });
102 | 
103 | /**
104 |  * Overrides the room to broadcast messages to (flag)
105 |  *
106 |  * @api public
107 |  */
108 | 
109 | Socket.prototype.to = Socket.prototype.in = function (room) {
110 |   this.flags.room = room;
111 |   return this;
112 | };
113 | 
114 | /**
115 |  * Resets flags
116 |  *
117 |  * @api private
118 |  */
119 | 
120 | Socket.prototype.setFlags = function () {
121 |   this.flags = {
122 |       endpoint: this.namespace.name
123 |     , room: ''
124 |   };
125 |   return this;
126 | };
127 | 
128 | /**
129 |  * Triggered on disconnect
130 |  *
131 |  * @api private
132 |  */
133 | 
134 | Socket.prototype.onDisconnect = function (reason) {
135 |   if (!this.disconnected) {
136 |     this.$emit('disconnect', reason);
137 |     this.disconnected = true;
138 |   }
139 | };
140 | 
141 | /**
142 |  * Joins a user to a room.
143 |  *
144 |  * @api public
145 |  */
146 | 
147 | Socket.prototype.join = function (name, fn) {
148 |   var nsp = this.namespace.name
149 |     , name = (nsp + '/') + name;
150 | 
151 |   this.manager.onJoin(this.id, name);
152 |   this.manager.store.publish('join', this.id, name);
153 | 
154 |   if (fn) {
155 |     this.log.warn('Client#join callback is deprecated');
156 |     fn();
157 |   }
158 | 
159 |   return this;
160 | };
161 | 
162 | /**
163 |  * Joins a user to a room.
164 |  *
165 |  * @api public
166 |  */
167 | 
168 | Socket.prototype.leave = function (name, fn) {
169 |   var nsp = this.namespace.name
170 |     , name = (nsp + '/') + name;
171 | 
172 |   this.manager.onLeave(this.id, name);
173 |   this.manager.store.publish('leave', this.id, name);
174 | 
175 |   if (fn) {
176 |     this.log.warn('Client#leave callback is deprecated');
177 |     fn();
178 |   }
179 | 
180 |   return this;
181 | };
182 | 
183 | /**
184 |  * Transmits a packet.
185 |  *
186 |  * @api private
187 |  */
188 | 
189 | Socket.prototype.packet = function (packet) {
190 |   if (this.flags.broadcast) {
191 |     this.log.debug('broadcasting packet');
192 |     this.namespace.in(this.flags.room).except(this.id).packet(packet);
193 |   } else {
194 |     packet.endpoint = this.flags.endpoint;
195 |     packet = parser.encodePacket(packet);
196 | 
197 |     this.dispatch(packet, this.flags.volatile);
198 |   }
199 | 
200 |   this.setFlags();
201 | 
202 |   return this;
203 | };
204 | 
205 | /**
206 |  * Dispatches a packet
207 |  *
208 |  * @api private
209 |  */
210 | 
211 | Socket.prototype.dispatch = function (packet, volatile) {
212 |   if (this.manager.transports[this.id] && this.manager.transports[this.id].open) {
213 |     this.manager.transports[this.id].onDispatch(packet, volatile);
214 |   } else {
215 |     if (!volatile) {
216 |       this.manager.onClientDispatch(this.id, packet, volatile);
217 |     }
218 | 
219 |     this.manager.store.publish('dispatch:' + this.id, packet, volatile);
220 |   }
221 | };
222 | 
223 | /**
224 |  * Stores data for the client.
225 |  *
226 |  * @api public
227 |  */
228 | 
229 | Socket.prototype.set = function (key, value, fn) {
230 |   this.store.set(key, value, fn);
231 |   return this;
232 | };
233 | 
234 | /**
235 |  * Retrieves data for the client
236 |  *
237 |  * @api public
238 |  */
239 | 
240 | Socket.prototype.get = function (key, fn) {
241 |   this.store.get(key, fn);
242 |   return this;
243 | };
244 | 
245 | /**
246 |  * Checks data for the client
247 |  *
248 |  * @api public
249 |  */
250 | 
251 | Socket.prototype.has = function (key, fn) {
252 |   this.store.has(key, fn);
253 |   return this;
254 | };
255 | 
256 | /**
257 |  * Deletes data for the client
258 |  *
259 |  * @api public
260 |  */
261 | 
262 | Socket.prototype.del = function (key, fn) {
263 |   this.store.del(key, fn);
264 |   return this;
265 | };
266 | 
267 | /**
268 |  * Kicks client
269 |  *
270 |  * @api public
271 |  */
272 | 
273 | Socket.prototype.disconnect = function () {
274 |   if (!this.disconnected) {
275 |     this.log.info('booting client');
276 | 
277 |     if (this.manager.transports[this.id] && this.manager.transports[this.id].open) {
278 |       this.manager.transports[this.id].onForcedDisconnect();
279 |     } else {
280 |       this.manager.onClientDisconnect(this.id);
281 |       this.manager.store.publish('disconnect:' + this.id);
282 |     }
283 |   }
284 | 
285 |   return this;
286 | };
287 | 
288 | /**
289 |  * Send a message.
290 |  *
291 |  * @api public
292 |  */
293 | 
294 | Socket.prototype.send = function (data, fn) {
295 |   var packet = {
296 |       type: this.flags.json ? 'json' : 'message'
297 |     , data: data
298 |   };
299 | 
300 |   if (fn) {
301 |     packet.id = ++this.ackPackets;
302 |     packet.ack = true;
303 |     this.acks[packet.id] = fn;
304 |   }
305 | 
306 |   return this.packet(packet);
307 | };
308 | 
309 | /**
310 |  * Original emit function.
311 |  *
312 |  * @api private
313 |  */
314 | 
315 | Socket.prototype.$emit = EventEmitter.prototype.emit;
316 | 
317 | /**
318 |  * Emit override for custom events.
319 |  *
320 |  * @api public
321 |  */
322 | 
323 | Socket.prototype.emit = function (ev) {
324 |   if (ev == 'newListener') {
325 |     return this.$emit.apply(this, arguments);
326 |   }
327 | 
328 |   var args = util.toArray(arguments).slice(1)
329 |     , lastArg = args[args.length - 1]
330 |     , packet = {
331 |           type: 'event'
332 |         , name: ev
333 |       };
334 | 
335 |   if ('function' == typeof lastArg) {
336 |     packet.id = ++this.ackPackets;
337 |     packet.ack = lastArg.length ? 'data' : true;
338 |     this.acks[packet.id] = lastArg;
339 |     args = args.slice(0, args.length - 1);
340 |   }
341 | 
342 |   packet.args = args;
343 | 
344 |   return this.packet(packet);
345 | };
346 | 


--------------------------------------------------------------------------------
/ducks/node_modules/socket.io/lib/store.js:
--------------------------------------------------------------------------------
 1 | 
 2 | /*!
 3 |  * socket.io-node
 4 |  * Copyright(c) 2011 LearnBoost <dev@learnboost.com>
 5 |  * MIT Licensed
 6 |  */
 7 | 
 8 | /**
 9 |  * Expose the constructor.
10 |  */
11 | 
12 | exports = module.exports = Store;
13 | 
14 | /**
15 |  * Module dependencies.
16 |  */
17 | 
18 | var EventEmitter = process.EventEmitter;
19 | 
20 | /**
21 |  * Store interface
22 |  *
23 |  * @api public
24 |  */
25 | 
26 | function Store (options) {
27 |   this.options = options;
28 |   this.clients = {};
29 | };
30 | 
31 | /**
32 |  * Inherit from EventEmitter.
33 |  */
34 | 
35 | Store.prototype.__proto__ = EventEmitter.prototype;
36 | 
37 | /**
38 |  * Initializes a client store
39 |  *
40 |  * @param {String} id
41 |  * @api public
42 |  */
43 | 
44 | Store.prototype.client = function (id) {
45 |   if (!this.clients[id]) {
46 |     this.clients[id] = new (this.constructor.Client)(this, id);
47 |   }
48 | 
49 |   return this.clients[id];
50 | };
51 | 
52 | /**
53 |  * Destroys a client
54 |  *
55 |  * @api {String} sid
56 |  * @param {Number} number of seconds to expire client data
57 |  * @api private
58 |  */
59 | 
60 | Store.prototype.destroyClient = function (id, expiration) {
61 |   if (this.clients[id]) {
62 |     this.clients[id].destroy(expiration);
63 |     delete this.clients[id];
64 |   }
65 | 
66 |   return this;
67 | };
68 | 
69 | /**
70 |  * Destroys the store
71 |  *
72 |  * @param {Number} number of seconds to expire client data
73 |  * @api private
74 |  */
75 | 
76 | Store.prototype.destroy = function (clientExpiration) {
77 |   var keys = Object.keys(this.clients)
78 |     , count = keys.length;
79 | 
80 |   for (var i = 0, l = count; i < l; i++) {
81 |     this.destroyClient(keys[i], clientExpiration);
82 |   }
83 | 
84 |   this.clients = {};
85 | 
86 |   return this;
87 | };
88 | 
89 | /**
90 |  * Client.
91 |  *
92 |  * @api public
93 |  */
94 | 
95 | Store.Client = function (store, id) {
96 |   this.store = store;
97 |   this.id = id;
98 | };
99 | 


--------------------------------------------------------------------------------
/ducks/node_modules/socket.io/lib/stores/memory.js:
--------------------------------------------------------------------------------
  1 | 
  2 | /*!
  3 |  * socket.io-node
  4 |  * Copyright(c) 2011 LearnBoost <dev@learnboost.com>
  5 |  * MIT Licensed
  6 |  */
  7 | 
  8 | /**
  9 |  * Module dependencies.
 10 |  */
 11 | 
 12 | var crypto = require('crypto')
 13 |   , Store = require('../store');
 14 | 
 15 | /**
 16 |  * Exports the constructor.
 17 |  */
 18 | 
 19 | exports = module.exports = Memory;
 20 | Memory.Client = Client;
 21 | 
 22 | /**
 23 |  * Memory store
 24 |  *
 25 |  * @api public
 26 |  */
 27 | 
 28 | function Memory (opts) {
 29 |   Store.call(this, opts);
 30 | };
 31 | 
 32 | /**
 33 |  * Inherits from Store.
 34 |  */
 35 | 
 36 | Memory.prototype.__proto__ = Store.prototype;
 37 | 
 38 | /**
 39 |  * Publishes a message.
 40 |  *
 41 |  * @api private
 42 |  */
 43 | 
 44 | Memory.prototype.publish = function () { };
 45 | 
 46 | /**
 47 |  * Subscribes to a channel
 48 |  *
 49 |  * @api private
 50 |  */
 51 | 
 52 | Memory.prototype.subscribe = function () { };
 53 | 
 54 | /**
 55 |  * Unsubscribes
 56 |  *
 57 |  * @api private
 58 |  */
 59 | 
 60 | Memory.prototype.unsubscribe = function () { };
 61 | 
 62 | /**
 63 |  * Client constructor
 64 |  *
 65 |  * @api private
 66 |  */
 67 | 
 68 | function Client () {
 69 |   Store.Client.apply(this, arguments);
 70 |   this.data = {};
 71 | };
 72 | 
 73 | /**
 74 |  * Inherits from Store.Client
 75 |  */
 76 | 
 77 | Client.prototype.__proto__ = Store.Client;
 78 | 
 79 | /**
 80 |  * Gets a key
 81 |  *
 82 |  * @api public
 83 |  */
 84 | 
 85 | Client.prototype.get = function (key, fn) {
 86 |   fn(null, this.data[key] === undefined ? null : this.data[key]);
 87 |   return this;
 88 | };
 89 | 
 90 | /**
 91 |  * Sets a key
 92 |  *
 93 |  * @api public
 94 |  */
 95 | 
 96 | Client.prototype.set = function (key, value, fn) {
 97 |   this.data[key] = value;
 98 |   fn && fn(null);
 99 |   return this;
100 | };
101 | 
102 | /**
103 |  * Has a key
104 |  *
105 |  * @api public
106 |  */
107 | 
108 | Client.prototype.has = function (key, fn) {
109 |   fn(null, key in this.data);
110 | };
111 | 
112 | /**
113 |  * Deletes a key
114 |  *
115 |  * @api public
116 |  */
117 | 
118 | Client.prototype.del = function (key, fn) {
119 |   delete this.data[key];
120 |   fn && fn(null);
121 |   return this;
122 | };
123 | 
124 | /**
125 |  * Destroys the client.
126 |  *
127 |  * @param {Number} number of seconds to expire data
128 |  * @api private
129 |  */
130 | 
131 | Client.prototype.destroy = function (expiration) {
132 |   if ('number' != typeof expiration) {
133 |     this.data = {};
134 |   } else {
135 |     var self = this;
136 | 
137 |     setTimeout(function () {
138 |       self.data = {};
139 |     }, expiration * 1000);
140 |   }
141 | 
142 |   return this;
143 | };
144 | 


--------------------------------------------------------------------------------
/ducks/node_modules/socket.io/lib/stores/redis.js:
--------------------------------------------------------------------------------
  1 | 
  2 | /*!
  3 |  * socket.io-node
  4 |  * Copyright(c) 2011 LearnBoost <dev@learnboost.com>
  5 |  * MIT Licensed
  6 |  */
  7 | 
  8 | /**
  9 |  * Module dependencies.
 10 |  */
 11 | 
 12 | var crypto = require('crypto')
 13 |   , Store = require('../store')
 14 |   , assert = require('assert');
 15 | 
 16 | /**
 17 |  * Exports the constructor.
 18 |  */
 19 | 
 20 | exports = module.exports = Redis;
 21 | Redis.Client = Client;
 22 | 
 23 | /**
 24 |  * Redis store.
 25 |  * Options:
 26 |  *     - nodeId (fn) gets an id that uniquely identifies this node
 27 |  *     - redis (fn) redis constructor, defaults to redis
 28 |  *     - redisPub (object) options to pass to the pub redis client
 29 |  *     - redisSub (object) options to pass to the sub redis client
 30 |  *     - redisClient (object) options to pass to the general redis client
 31 |  *     - pack (fn) custom packing, defaults to JSON or msgpack if installed
 32 |  *     - unpack (fn) custom packing, defaults to JSON or msgpack if installed
 33 |  *
 34 |  * @api public
 35 |  */
 36 | 
 37 | function Redis (opts) {
 38 |   opts = opts || {};
 39 | 
 40 |   // node id to uniquely identify this node
 41 |   var nodeId = opts.nodeId || function () {
 42 |     // by default, we generate a random id 
 43 |     return Math.abs(Math.random() * Math.random() * Date.now() | 0);
 44 |   };
 45 | 
 46 |   this.nodeId = nodeId();
 47 | 
 48 |   // packing / unpacking mechanism
 49 |   if (opts.pack) {
 50 |     this.pack = opts.pack;
 51 |     this.unpack = opts.unpack;
 52 |   } else {
 53 |     try {
 54 |       var msgpack = require('msgpack');
 55 |       this.pack = msgpack.pack;
 56 |       this.unpack = msgpack.unpack;
 57 |     } catch (e) {
 58 |       this.pack = JSON.stringify;
 59 |       this.unpack = JSON.parse;
 60 |     }
 61 |   }
 62 | 
 63 |   var redis = opts.redis || require('redis');
 64 | 
 65 |   // initialize a pubsub client and a regular client
 66 |   this.pub = redis.createClient(opts.redisPub);
 67 |   this.sub = redis.createClient(opts.redisSub);
 68 |   this.cmd = redis.createClient(opts.redisClient);
 69 | 
 70 |   Store.call(this, opts);
 71 | };
 72 | 
 73 | /**
 74 |  * Inherits from Store.
 75 |  */
 76 | 
 77 | Redis.prototype.__proto__ = Store.prototype;
 78 | 
 79 | /**
 80 |  * Publishes a message.
 81 |  *
 82 |  * @api private
 83 |  */
 84 | 
 85 | Redis.prototype.publish = function (name) {
 86 |   var args = Array.prototype.slice.call(arguments, 1);
 87 |   this.pub.publish(name, this.pack({ nodeId: this.nodeId, args: args }));
 88 |   this.emit.apply(this, ['publish', name].concat(args));
 89 | };
 90 | 
 91 | /**
 92 |  * Subscribes to a channel
 93 |  *
 94 |  * @api private
 95 |  */
 96 | 
 97 | Redis.prototype.subscribe = function (name, consumer, fn) {
 98 |   this.sub.subscribe(name);
 99 | 
100 |   if (consumer || fn) {
101 |     var self = this;
102 | 
103 |     self.sub.on('subscribe', function subscribe (ch) {
104 |       if (name == ch) {
105 |         function message (ch, msg) {
106 |           if (name == ch) {
107 |             msg = self.unpack(msg);
108 | 
109 |             // we check that the message consumed wasnt emitted by this node
110 |             if (self.nodeId != msg.nodeId) {
111 |               consumer.apply(null, msg.args);
112 |             }
113 |           }
114 |         };
115 | 
116 |         self.sub.on('message', message);
117 | 
118 |         self.on('unsubscribe', function unsubscribe (ch) {
119 |           if (name == ch) {
120 |             self.sub.removeListener('message', message);
121 |             self.removeEvent('unsubscribe', unsubscribe);
122 |           }
123 |         });
124 | 
125 |         self.sub.removeListener('subscribe', subscribe);
126 | 
127 |         fn && fn();
128 |       }
129 |     });
130 |   }
131 | 
132 |   this.emit('subscribe', name, consumer, fn);
133 | };
134 | 
135 | /**
136 |  * Unsubscribes
137 |  *
138 |  * @api private
139 |  */
140 | 
141 | Redis.prototype.unsubscribe = function (name, fn) {
142 |   this.sub.unsubscribe(name);
143 | 
144 |   if (fn) {
145 |     var client = this.sub;
146 | 
147 |     client.on('unsubscribe', function unsubscribe (ch) {
148 |       if (name == ch) {
149 |         fn();
150 |         client.removeListener('unsubscribe', unsubscribe);
151 |       }
152 |     });
153 |   }
154 | 
155 |   this.emit('unsubscribe', name, fn);
156 | };
157 | 
158 | /**
159 |  * Destroys the store
160 |  *
161 |  * @api public
162 |  */
163 | 
164 | Redis.prototype.destroy = function () {
165 |   Store.prototype.destroy.call(this);
166 | 
167 |   this.pub.end();
168 |   this.sub.end();
169 |   this.cmd.end();
170 | };
171 | 
172 | /**
173 |  * Client constructor
174 |  *
175 |  * @api private
176 |  */
177 | 
178 | function Client (store, id) {
179 |   Store.Client.call(this, store, id);
180 | };
181 | 
182 | /**
183 |  * Inherits from Store.Client
184 |  */
185 | 
186 | Client.prototype.__proto__ = Store.Client;
187 | 
188 | /**
189 |  * Redis hash get
190 |  *
191 |  * @api private
192 |  */
193 | 
194 | Client.prototype.get = function (key, fn) {
195 |   this.store.cmd.hget(this.id, key, fn);
196 |   return this;
197 | };
198 | 
199 | /**
200 |  * Redis hash set
201 |  *
202 |  * @api private
203 |  */
204 | 
205 | Client.prototype.set = function (key, value, fn) {
206 |   this.store.cmd.hset(this.id, key, value, fn);
207 |   return this;
208 | };
209 | 
210 | /**
211 |  * Redis hash del
212 |  *
213 |  * @api private
214 |  */
215 | 
216 | Client.prototype.del = function (key, fn) {
217 |   this.store.cmd.hdel(this.id, key, fn);
218 |   return this;
219 | };
220 | 
221 | /**
222 |  * Redis hash has
223 |  *
224 |  * @api private
225 |  */
226 | 
227 | Client.prototype.has = function (key, fn) {
228 |   this.store.cmd.hexists(this.id, key, function (err, has) {
229 |     if (err) return fn(err);
230 |     fn(null, !!has);
231 |   });
232 |   return this;
233 | };
234 | 
235 | /**
236 |  * Destroys client
237 |  *
238 |  * @param {Number} number of seconds to expire data
239 |  * @api private
240 |  */
241 | 
242 | Client.prototype.destroy = function (expiration) {
243 |   if ('number' != typeof expiration) {
244 |     this.store.cmd.del(this.id);
245 |   } else {
246 |     this.store.cmd.expire(this.id, expiration);
247 |   }
248 | 
249 |   return this;
250 | };
251 | 


--------------------------------------------------------------------------------
/ducks/node_modules/socket.io/lib/transports/flashsocket.js:
--------------------------------------------------------------------------------
  1 | 
  2 | /*!
  3 |  * socket.io-node
  4 |  * Copyright(c) 2011 LearnBoost <dev@learnboost.com>
  5 |  * MIT Licensed
  6 |  */
  7 | 
  8 | /**
  9 |  * Module requirements.
 10 |  */
 11 | var WebSocket = require('./websocket');
 12 | 
 13 | /**
 14 |  * Export the constructor.
 15 |  */
 16 | 
 17 | exports = module.exports = FlashSocket;
 18 | 
 19 | /**
 20 |  * The FlashSocket transport is just a proxy
 21 |  * for WebSocket connections.
 22 |  *
 23 |  * @api public
 24 |  */
 25 |  
 26 | function FlashSocket (mng, data, req) {
 27 |   WebSocket.call(this, mng, data, req);
 28 | }
 29 | 
 30 | /**
 31 |  * Inherits from WebSocket.
 32 |  */
 33 | 
 34 | FlashSocket.prototype.__proto__ = WebSocket.prototype;
 35 | 
 36 | /**
 37 |  * Transport name
 38 |  *
 39 |  * @api public
 40 |  */
 41 | 
 42 | FlashSocket.prototype.name = 'flashsocket';
 43 | 
 44 | /**
 45 |  * Listens for new configuration changes of the Manager
 46 |  * this way we can enable and disable the flash server.
 47 |  *
 48 |  * @param {Manager} Manager instance.
 49 |  * @api private
 50 |  */
 51 | 
 52 | var server;
 53 | 
 54 | FlashSocket.init = function (manager) {
 55 |   function create () {
 56 |     server = require('policyfile').createServer({ 
 57 |       log: function(msg){
 58 |         manager.log.info(msg.toLowerCase());
 59 |       }
 60 |     }, manager.get('origins'));
 61 | 
 62 |     server.on('close', function (e) {
 63 |       server = null;
 64 |     });
 65 | 
 66 |     server.listen(manager.get('flash policy port'), manager.server);
 67 | 
 68 |     manager.flashPolicyServer = server;
 69 |   }
 70 | 
 71 |   // listen for origin changes, so we can update the server
 72 |   manager.on('set:origins', function (value, key) {
 73 |     if (!server) return;
 74 | 
 75 |     // update the origins and compile a new response buffer
 76 |     server.origins = Array.isArray(value) ? value : [value];
 77 |     server.compile();
 78 |   });
 79 | 
 80 |   // destory the server and create a new server
 81 |   manager.on('set:flash policy port', function (value, key) {
 82 |     var transports = manager.get('transports');
 83 | 
 84 |     if (server && server.port !== value && ~transports.indexOf('flashsocket')) {
 85 |       // destroy the server and rebuild it on a new port
 86 |       server.close();
 87 |       create();
 88 |     }
 89 |   });
 90 | 
 91 |   // only start the server
 92 |   manager.on('set:transports', function (value, key){
 93 |     if (!server && ~manager.get('transports').indexOf('flashsocket')) {
 94 |       create();
 95 |     }
 96 |   });
 97 | 
 98 |   // check if we need to initialize at start
 99 |   if (~manager.get('transports').indexOf('flashsocket')){
100 |     create();
101 |   }
102 | };
103 | 


--------------------------------------------------------------------------------
/ducks/node_modules/socket.io/lib/transports/htmlfile.js:
--------------------------------------------------------------------------------
 1 | 
 2 | /*!
 3 |  * socket.io-node
 4 |  * Copyright(c) 2011 LearnBoost <dev@learnboost.com>
 5 |  * MIT Licensed
 6 |  */
 7 | 
 8 | /**
 9 |  * Module requirements.
10 |  */
11 | 
12 | var HTTPTransport = require('./http');
13 | 
14 | /**
15 |  * Export the constructor.
16 |  */
17 | 
18 | exports = module.exports = HTMLFile;
19 | 
20 | /**
21 |  * HTMLFile transport constructor.
22 |  *
23 |  * @api public
24 |  */
25 | 
26 | function HTMLFile (mng, data, req) {
27 |   HTTPTransport.call(this, mng, data, req);
28 | };
29 | 
30 | /**
31 |  * Inherits from Transport.
32 |  */
33 | 
34 | HTMLFile.prototype.__proto__ = HTTPTransport.prototype;
35 | 
36 | /**
37 |  * Transport name
38 |  *
39 |  * @api public
40 |  */
41 | 
42 | HTMLFile.prototype.name = 'htmlfile';
43 | 
44 | /**
45 |  * Handles the request.
46 |  *
47 |  * @api private
48 |  */
49 | 
50 | HTMLFile.prototype.handleRequest = function (req) {
51 |   HTTPTransport.prototype.handleRequest.call(this, req);
52 | 
53 |   if (req.method == 'GET') {
54 |     req.res.writeHead(200, {
55 |         'Content-Type': 'text/html'
56 |       , 'Connection': 'keep-alive'
57 |       , 'Transfer-Encoding': 'chunked'
58 |     });
59 | 
60 |     req.res.write(
61 |         '<html><body>'
62 |       + '<script>var _ = function (msg) { parent.s._(msg, document); };</script>'
63 |       + new Array(174).join(' ')
64 |     );
65 |   }
66 | };
67 | 
68 | /**
69 |  * Performs the write.
70 |  *
71 |  * @api private
72 |  */
73 | 
74 | HTMLFile.prototype.write = function (data) {
75 |   data = '<script>_(' + JSON.stringify(data) + ');</script>';
76 | 
77 |   if (this.response.write(data)) {
78 |     this.drained = true;
79 |   }
80 | 
81 |   this.log.debug(this.name + ' writing', data);
82 | };
83 | 


--------------------------------------------------------------------------------
/ducks/node_modules/socket.io/lib/transports/http-polling.js:
--------------------------------------------------------------------------------
  1 | 
  2 | /*!
  3 |  * socket.io-node
  4 |  * Copyright(c) 2011 LearnBoost <dev@learnboost.com>
  5 |  * MIT Licensed
  6 |  */
  7 | 
  8 | /**
  9 |  * Module requirements.
 10 |  */
 11 | 
 12 | var HTTPTransport = require('./http');
 13 | 
 14 | /**
 15 |  * Exports the constructor.
 16 |  */
 17 | 
 18 | exports = module.exports = HTTPPolling;
 19 | 
 20 | /**
 21 |  * HTTP polling constructor.
 22 |  *
 23 |  * @api public.
 24 |  */
 25 | 
 26 | function HTTPPolling (mng, data, req) {
 27 |   HTTPTransport.call(this, mng, data, req);
 28 | };
 29 | 
 30 | /**
 31 |  * Inherits from HTTPTransport.
 32 |  *
 33 |  * @api public.
 34 |  */
 35 | 
 36 | HTTPPolling.prototype.__proto__ = HTTPTransport.prototype;
 37 | 
 38 | /**
 39 |  * Transport name
 40 |  *
 41 |  * @api public
 42 |  */
 43 | 
 44 | HTTPPolling.prototype.name = 'httppolling';
 45 | 
 46 | /**
 47 |  * Removes heartbeat timeouts for polling.
 48 |  */
 49 | 
 50 | HTTPPolling.prototype.setHeartbeatInterval = function () {
 51 |   return this;
 52 | };
 53 | 
 54 | /**
 55 |  * Handles a request
 56 |  *
 57 |  * @api private
 58 |  */
 59 | 
 60 | HTTPPolling.prototype.handleRequest = function (req) {
 61 |   HTTPTransport.prototype.handleRequest.call(this, req);
 62 | 
 63 |   if (req.method == 'GET') {
 64 |     var self = this;
 65 | 
 66 |     this.pollTimeout = setTimeout(function () {
 67 |       self.packet({ type: 'noop' });
 68 |       self.log.debug(self.name + ' closed due to exceeded duration');
 69 |     }, this.manager.get('polling duration') * 1000);
 70 | 
 71 |     this.log.debug('setting poll timeout');
 72 |   }
 73 | };
 74 | 
 75 | /**
 76 |  * Clears polling timeout
 77 |  *
 78 |  * @api private
 79 |  */
 80 | 
 81 | HTTPPolling.prototype.clearPollTimeout = function () {
 82 |   if (this.pollTimeout) {
 83 |     clearTimeout(this.pollTimeout);
 84 |     this.pollTimeout = null;
 85 |     this.log.debug('clearing poll timeout');
 86 |   }
 87 | 
 88 |   return this;
 89 | };
 90 | 
 91 | /**
 92 |  * Override clear timeouts to clear the poll timeout
 93 |  *
 94 |  * @api private
 95 |  */
 96 | 
 97 | HTTPPolling.prototype.clearTimeouts = function () {
 98 |   HTTPTransport.prototype.clearTimeouts.call(this);
 99 | 
100 |   this.clearPollTimeout();
101 | };
102 | 
103 | /**
104 |  * doWrite to clear poll timeout
105 |  *
106 |  * @api private
107 |  */
108 | 
109 | HTTPPolling.prototype.doWrite = function () {
110 |   this.clearPollTimeout();
111 | };
112 | 
113 | /**
114 |  * Performs a write.
115 |  *
116 |  * @api private.
117 |  */
118 | 
119 | HTTPPolling.prototype.write = function (data, close) {
120 |   this.doWrite(data);
121 |   this.response.end();
122 |   this.onClose();
123 | };
124 | 
125 | /**
126 |  * Override end.
127 |  *
128 |  * @api private
129 |  */
130 | 
131 | HTTPPolling.prototype.end = function () {
132 |   this.clearPollTimeout();
133 |   return HTTPTransport.prototype.end.call(this);
134 | };
135 | 
136 | 


--------------------------------------------------------------------------------
/ducks/node_modules/socket.io/lib/transports/http.js:
--------------------------------------------------------------------------------
  1 | 
  2 | /*!
  3 |  * socket.io-node
  4 |  * Copyright(c) 2011 LearnBoost <dev@learnboost.com>
  5 |  * MIT Licensed
  6 |  */
  7 | 
  8 | /**
  9 |  * Module requirements.
 10 |  */
 11 | 
 12 | var Transport = require('../transport')
 13 |   , parser = require('../parser')
 14 |   , qs = require('querystring');
 15 | 
 16 | /**
 17 |  * Export the constructor.
 18 |  */
 19 | 
 20 | exports = module.exports = HTTPTransport;
 21 | 
 22 | /**
 23 |  * HTTP interface constructor. For all non-websocket transports.
 24 |  *
 25 |  * @api public
 26 |  */
 27 | 
 28 | function HTTPTransport (mng, data, req) {
 29 |   Transport.call(this, mng, data, req);
 30 | };
 31 | 
 32 | /**
 33 |  * Inherits from Transport.
 34 |  */
 35 | 
 36 | HTTPTransport.prototype.__proto__ = Transport.prototype;
 37 | 
 38 | /**
 39 |  * Handles a request.
 40 |  *
 41 |  * @api private
 42 |  */
 43 | 
 44 | HTTPTransport.prototype.handleRequest = function (req) {
 45 |   if (req.method == 'POST') {
 46 |     var buffer = ''
 47 |       , res = req.res
 48 |       , origin = req.headers.origin
 49 |       , headers = { 'Content-Length': 1 }
 50 |       , self = this;
 51 | 
 52 |     req.on('data', function (data) {
 53 |       buffer += data;
 54 |     });
 55 | 
 56 |     req.on('end', function () {
 57 |       res.writeHead(200, headers);
 58 |       res.end('1');
 59 |       
 60 |       self.onData(self.postEncoded ? qs.parse(buffer).d : buffer);
 61 |     });
 62 | 
 63 |     if (origin) {
 64 |       // https://developer.mozilla.org/En/HTTP_Access_Control
 65 |       headers['Access-Control-Allow-Origin'] = '*';
 66 | 
 67 |       if (req.headers.cookie) {
 68 |         headers['Access-Control-Allow-Credentials'] = 'true';
 69 |       }
 70 |     }
 71 |   } else {
 72 |     this.response = req.res;
 73 | 
 74 |     Transport.prototype.handleRequest.call(this, req);
 75 |   }
 76 | };
 77 | 
 78 | /**
 79 |  * Handles data payload.
 80 |  *
 81 |  * @api private
 82 |  */
 83 | 
 84 | HTTPTransport.prototype.onData = function (data) {
 85 |   var messages = parser.decodePayload(data);
 86 | 
 87 |   for (var i = 0, l = messages.length; i < l; i++) {
 88 |     this.log.debug(this.name + ' received data packet', data);
 89 |     this.onMessage(messages[i]);
 90 |   }
 91 | };
 92 | 
 93 | /**
 94 |  * Closes the request-response cycle
 95 |  *
 96 |  * @api private
 97 |  */
 98 | 
 99 | HTTPTransport.prototype.doClose = function () {
100 |   this.response.end();
101 | };
102 | 
103 | /**
104 |  * Writes a payload of messages
105 |  *
106 |  * @api private
107 |  */
108 | 
109 | HTTPTransport.prototype.payload = function (msgs) {
110 |   this.write(parser.encodePayload(msgs));
111 | };
112 | 


--------------------------------------------------------------------------------
/ducks/node_modules/socket.io/lib/transports/index.js:
--------------------------------------------------------------------------------
 1 | 
 2 | /**
 3 |  * Export transports.
 4 |  */
 5 | 
 6 | module.exports = {
 7 |     websocket: require('./websocket')
 8 |   , flashsocket: require('./flashsocket')
 9 |   , htmlfile: require('./htmlfile')
10 |   , 'xhr-polling': require('./xhr-polling')
11 |   , 'jsonp-polling': require('./jsonp-polling')
12 | };
13 | 


--------------------------------------------------------------------------------
/ducks/node_modules/socket.io/lib/transports/jsonp-polling.js:
--------------------------------------------------------------------------------
 1 | 
 2 | /*!
 3 |  * socket.io-node
 4 |  * Copyright(c) 2011 LearnBoost <dev@learnboost.com>
 5 |  * MIT Licensed
 6 |  */
 7 | 
 8 | /**
 9 |  * Module requirements.
10 |  */
11 | 
12 | var HTTPPolling = require('./http-polling');
13 | 
14 | /**
15 |  * Export the constructor.
16 |  */
17 | 
18 | exports = module.exports = JSONPPolling;
19 | 
20 | /**
21 |  * JSON-P polling transport.
22 |  *
23 |  * @api public
24 |  */
25 | 
26 | function JSONPPolling (mng, data, req) {
27 |   HTTPPolling.call(this, mng, data, req);
28 | 
29 |   this.head = 'io.j[0](';
30 |   this.foot = ');';
31 | 
32 |   if (data.query.i) {
33 |     this.head = 'io.j[' + data.query.i + '](';
34 |   }
35 | };
36 | 
37 | /**
38 |  * Inherits from Transport.
39 |  */
40 | 
41 | JSONPPolling.prototype.__proto__ = HTTPPolling.prototype;
42 | 
43 | /**
44 |  * Transport name
45 |  *
46 |  * @api public
47 |  */
48 | 
49 | JSONPPolling.prototype.name = 'jsonppolling';
50 | 
51 | /**
52 |  * Make sure POST are decoded.
53 |  */
54 | 
55 | JSONPPolling.prototype.postEncoded = true;
56 | 
57 | /**
58 |  * Performs the write.
59 |  *
60 |  * @api private
61 |  */
62 | 
63 | JSONPPolling.prototype.doWrite = function (data) {
64 |   HTTPPolling.prototype.doWrite.call(this);
65 | 
66 |   var data = data === undefined
67 |       ? '' : this.head + JSON.stringify(data) + this.foot;
68 | 
69 |   this.response.writeHead(200, {
70 |       'Content-Type': 'text/javascript; charset=UTF-8'
71 |     , 'Content-Length': Buffer.byteLength(data)
72 |     , 'Connection': 'Keep-Alive'
73 |     , 'X-XSS-Protection': '0'
74 |   });
75 | 
76 |   this.response.write(data);
77 |   this.log.debug(this.name + ' writing', data);
78 | };
79 | 


--------------------------------------------------------------------------------
/ducks/node_modules/socket.io/lib/transports/websocket.js:
--------------------------------------------------------------------------------
  1 | 
  2 | /*!
  3 |  * socket.io-node
  4 |  * Copyright(c) 2011 LearnBoost <dev@learnboost.com>
  5 |  * MIT Licensed
  6 |  */
  7 | 
  8 | /**
  9 |  * Module requirements.
 10 |  */
 11 | 
 12 | var Transport = require('../transport')
 13 |   , EventEmitter = process.EventEmitter
 14 |   , crypto = require('crypto')
 15 |   , parser = require('../parser');
 16 | 
 17 | /**
 18 |  * Export the constructor.
 19 |  */
 20 | 
 21 | exports = module.exports = WebSocket;
 22 | 
 23 | /**
 24 |  * HTTP interface constructor. Interface compatible with all transports that
 25 |  * depend on request-response cycles.
 26 |  *
 27 |  * @api public
 28 |  */
 29 | 
 30 | function WebSocket (mng, data, req) {
 31 |   // parser
 32 |   var self = this;
 33 | 
 34 |   this.parser = new Parser();
 35 |   this.parser.on('data', function (packet) {
 36 |     self.log.debug(self.name + ' received data packet', packet);
 37 |     self.onMessage(parser.decodePacket(packet));
 38 |   });
 39 |   this.parser.on('close', function () {
 40 |     self.end();
 41 |   });
 42 |   this.parser.on('error', function () {
 43 |     self.end();
 44 |   });
 45 | 
 46 |   Transport.call(this, mng, data, req);
 47 | };
 48 | 
 49 | /**
 50 |  * Inherits from Transport.
 51 |  */
 52 | 
 53 | WebSocket.prototype.__proto__ = Transport.prototype;
 54 | 
 55 | /**
 56 |  * Transport name
 57 |  *
 58 |  * @api public
 59 |  */
 60 | 
 61 | WebSocket.prototype.name = 'websocket';
 62 | 
 63 | /**
 64 |  * Called when the socket connects.
 65 |  *
 66 |  * @api private
 67 |  */
 68 | 
 69 | WebSocket.prototype.onSocketConnect = function () {
 70 |   var self = this;
 71 | 
 72 |   this.socket.setNoDelay(true);
 73 | 
 74 |   this.buffer = true;
 75 |   this.buffered = [];
 76 | 
 77 |   if (this.req.headers.upgrade !== 'WebSocket') {
 78 |     this.log.warn(this.name + ' connection invalid');
 79 |     this.end();
 80 |     return;
 81 |   }
 82 | 
 83 |   var origin = this.req.headers.origin
 84 |     , location = (this.socket.encrypted ? 'wss' : 'ws')
 85 |                + '://' + this.req.headers.host + this.req.url
 86 |     , waitingForNonce = false;
 87 | 
 88 |   if (this.req.headers['sec-websocket-key1']) {
 89 |     // If we don't have the nonce yet, wait for it (HAProxy compatibility).
 90 |     if (! (this.req.head && this.req.head.length >= 8)) {
 91 |       waitingForNonce = true;
 92 |     }
 93 | 
 94 |     var headers = [
 95 |         'HTTP/1.1 101 WebSocket Protocol Handshake'
 96 |       , 'Upgrade: WebSocket'
 97 |       , 'Connection: Upgrade'
 98 |       , 'Sec-WebSocket-Origin: ' + origin
 99 |       , 'Sec-WebSocket-Location: ' + location
100 |     ];
101 | 
102 |     if (this.req.headers['sec-websocket-protocol']){
103 |       headers.push('Sec-WebSocket-Protocol: '
104 |           + this.req.headers['sec-websocket-protocol']);
105 |     }
106 |   } else {
107 |     var headers = [
108 |         'HTTP/1.1 101 Web Socket Protocol Handshake'
109 |       , 'Upgrade: WebSocket'
110 |       , 'Connection: Upgrade'
111 |       , 'WebSocket-Origin: ' + origin
112 |       , 'WebSocket-Location: ' + location
113 |     ];
114 |   }
115 | 
116 |   try {
117 |     this.socket.write(headers.concat('', '').join('\r\n'));
118 |     this.socket.setTimeout(0);
119 |     this.socket.setNoDelay(true);
120 |     this.socket.setEncoding('utf8');
121 |   } catch (e) {
122 |     this.end();
123 |     return;
124 |   }
125 | 
126 |   if (waitingForNonce) {
127 |     this.socket.setEncoding('binary');
128 |   } else if (this.proveReception(headers)) {
129 |     self.flush();
130 |   }
131 | 
132 |   var headBuffer = '';
133 | 
134 |   this.socket.on('data', function (data) {
135 |     if (waitingForNonce) {
136 |       headBuffer += data;
137 | 
138 |       if (headBuffer.length < 8) {
139 |         return;
140 |       }
141 | 
142 |       // Restore the connection to utf8 encoding after receiving the nonce
143 |       self.socket.setEncoding('utf8');
144 |       waitingForNonce = false;
145 | 
146 |       // Stuff the nonce into the location where it's expected to be
147 |       self.req.head = headBuffer.substr(0, 8);
148 |       headBuffer = '';
149 | 
150 |       if (self.proveReception(headers)) {
151 |         self.flush();
152 |       }
153 | 
154 |       return;
155 |     }
156 | 
157 |     self.parser.add(data);
158 |   });
159 | };
160 | 
161 | /**
162 |  * Writes to the socket.
163 |  *
164 |  * @api private
165 |  */
166 | 
167 | WebSocket.prototype.write = function (data) {
168 |   if (this.open) {
169 |     this.drained = false;
170 | 
171 |     if (this.buffer) {
172 |       this.buffered.push(data);
173 |       return this;
174 |     }
175 | 
176 |     var length = Buffer.byteLength(data)
177 |       , buffer = new Buffer(2 + length);
178 | 
179 |     buffer.write('\u0000', 'binary');
180 |     buffer.write(data, 1, 'utf8');
181 |     buffer.write('\uffff', 1 + length, 'binary');
182 | 
183 |     try {
184 |       if (this.socket.write(buffer)) {
185 |         this.drained = true;
186 |       }
187 |     } catch (e) {
188 |       this.end();
189 |     }
190 | 
191 |     this.log.debug(this.name + ' writing', data);
192 |   }
193 | };
194 | 
195 | /**
196 |  * Flushes the internal buffer
197 |  *
198 |  * @api private
199 |  */
200 | 
201 | WebSocket.prototype.flush = function () {
202 |   this.buffer = false;
203 | 
204 |   for (var i = 0, l = this.buffered.length; i < l; i++) {
205 |     this.write(this.buffered.splice(0, 1)[0]);
206 |   }
207 | };
208 | 
209 | /**
210 |  * Finishes the handshake.
211 |  *
212 |  * @api private
213 |  */
214 | 
215 | WebSocket.prototype.proveReception = function (headers) {
216 |   var self = this
217 |     , k1 = this.req.headers['sec-websocket-key1']
218 |     , k2 = this.req.headers['sec-websocket-key2'];
219 | 
220 |   if (k1 && k2){
221 |     var md5 = crypto.createHash('md5');
222 | 
223 |     [k1, k2].forEach(function (k) {
224 |       var n = parseInt(k.replace(/[^\d]/g, ''))
225 |         , spaces = k.replace(/[^ ]/g, '').length;
226 | 
227 |       if (spaces === 0 || n % spaces !== 0){
228 |         self.log.warn('Invalid ' + self.name + ' key: "' + k + '".');
229 |         self.end();
230 |         return false;
231 |       }
232 | 
233 |       n /= spaces;
234 | 
235 |       md5.update(String.fromCharCode(
236 |         n >> 24 & 0xFF,
237 |         n >> 16 & 0xFF,
238 |         n >> 8  & 0xFF,
239 |         n       & 0xFF));
240 |     });
241 | 
242 |     md5.update(this.req.head.toString('binary'));
243 | 
244 |     try {
245 |       this.socket.write(md5.digest('binary'), 'binary');
246 |     } catch (e) {
247 |       this.end();
248 |     }
249 |   }
250 | 
251 |   return true;
252 | };
253 | 
254 | /**
255 |  * Writes a payload.
256 |  *
257 |  * @api private
258 |  */
259 | 
260 | WebSocket.prototype.payload = function (msgs) {
261 |   for (var i = 0, l = msgs.length; i < l; i++) {
262 |     this.write(msgs[i]);
263 |   }
264 | 
265 |   return this;
266 | };
267 | 
268 | /**
269 |  * Closes the connection.
270 |  *
271 |  * @api private
272 |  */
273 | 
274 | WebSocket.prototype.doClose = function () {
275 |   this.socket.end();
276 | };
277 | 
278 | /**
279 |  * WebSocket parser
280 |  *
281 |  * @api public
282 |  */
283 | 
284 | function Parser () {
285 |   this.buffer = '';
286 |   this.i = 0;
287 | };
288 | 
289 | /**
290 |  * Inherits from EventEmitter.
291 |  */
292 | 
293 | Parser.prototype.__proto__ = EventEmitter.prototype;
294 | 
295 | /**
296 |  * Adds data to the buffer.
297 |  *
298 |  * @api public
299 |  */
300 | 
301 | Parser.prototype.add = function (data) {
302 |   this.buffer += data;
303 |   this.parse();
304 | };
305 | 
306 | /**
307 |  * Parses the buffer.
308 |  *
309 |  * @api private
310 |  */
311 | 
312 | Parser.prototype.parse = function () {
313 |   for (var i = this.i, chr, l = this.buffer.length; i < l; i++){
314 |     chr = this.buffer[i];
315 | 
316 |     if (this.buffer.length == 2 && this.buffer[1] == '\u0000') {
317 |       this.emit('close');
318 |       this.buffer = '';
319 |       this.i = 0;
320 |       return;
321 |     }
322 | 
323 |     if (i === 0){
324 |       if (chr != '\u0000')
325 |         this.error('Bad framing. Expected null byte as first frame');
326 |       else
327 |         continue;
328 |     }
329 | 
330 |     if (chr == '\ufffd'){
331 |       this.emit('data', this.buffer.substr(1, i - 1));
332 |       this.buffer = this.buffer.substr(i + 1);
333 |       this.i = 0;
334 |       return this.parse();
335 |     }
336 |   }
337 | };
338 | 
339 | /**
340 |  * Handles an error
341 |  *
342 |  * @api private
343 |  */
344 | 
345 | Parser.prototype.error = function (reason) {
346 |   this.buffer = '';
347 |   this.i = 0;
348 |   this.emit('error', reason);
349 |   return this;
350 | };
351 | 


--------------------------------------------------------------------------------
/ducks/node_modules/socket.io/lib/transports/xhr-polling.js:
--------------------------------------------------------------------------------
 1 | 
 2 | /*!
 3 |  * socket.io-node
 4 |  * Copyright(c) 2011 LearnBoost <dev@learnboost.com>
 5 |  * MIT Licensed
 6 |  */
 7 | 
 8 | /**
 9 |  * Module requirements.
10 |  */
11 | 
12 | var HTTPPolling = require('./http-polling');
13 | 
14 | /**
15 |  * Export the constructor.
16 |  */
17 | 
18 | exports = module.exports = XHRPolling;
19 | 
20 | /**
21 |  * Ajax polling transport.
22 |  *
23 |  * @api public
24 |  */
25 | 
26 | function XHRPolling (mng, data, req) {
27 |   HTTPPolling.call(this, mng, data, req);
28 | };
29 | 
30 | /**
31 |  * Inherits from Transport.
32 |  */
33 | 
34 | XHRPolling.prototype.__proto__ = HTTPPolling.prototype;
35 | 
36 | /**
37 |  * Transport name
38 |  *
39 |  * @api public
40 |  */
41 | 
42 | XHRPolling.prototype.name = 'xhr-polling';
43 | 
44 | /**
45 |  * Frames data prior to write.
46 |  *
47 |  * @api private
48 |  */
49 | 
50 | XHRPolling.prototype.doWrite = function (data) {
51 |   HTTPPolling.prototype.doWrite.call(this);
52 | 
53 |   var origin = this.req.headers.origin
54 |     , headers = {
55 |           'Content-Type': 'text/plain; charset=UTF-8'
56 |         , 'Content-Length': data === undefined ? 0 : Buffer.byteLength(data)
57 |         , 'Connection': 'Keep-Alive'
58 |       };
59 | 
60 |   if (origin) {
61 |     // https://developer.mozilla.org/En/HTTP_Access_Control
62 |     headers['Access-Control-Allow-Origin'] = '*';
63 | 
64 |     if (this.req.headers.cookie) {
65 |       headers['Access-Control-Allow-Credentials'] = 'true';
66 |     }
67 |   }
68 | 
69 |   this.response.writeHead(200, headers);
70 |   this.response.write(data);
71 |   this.log.debug(this.name + ' writing', data);
72 | };
73 | 


--------------------------------------------------------------------------------
/ducks/node_modules/socket.io/lib/util.js:
--------------------------------------------------------------------------------
 1 | 
 2 | /*!
 3 |  * socket.io-node
 4 |  * Copyright(c) 2011 LearnBoost <dev@learnboost.com>
 5 |  * MIT Licensed
 6 |  */
 7 | 
 8 | /**
 9 |  * Module dependencies.
10 |  */
11 | 
12 | /**
13 |  * Converts an enumerable to an array.
14 |  *
15 |  * @api public
16 |  */
17 | 
18 | exports.toArray = function (enu) {
19 |   var arr = [];
20 | 
21 |   for (var i = 0, l = enu.length; i < l; i++)
22 |     arr.push(enu[i]);
23 | 
24 |   return arr;
25 | };
26 | 


--------------------------------------------------------------------------------
/ducks/node_modules/socket.io/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "name": "socket.io"
 3 |   , "version": "0.7.9"
 4 |   , "description": "Real-time apps made cross-browser & easy with a WebSocket-like API"
 5 |   , "homepage": "http://socket.io"
 6 |   , "keywords": ["websocket", "socket", "realtime", "socket.io", "comet", "ajax"]
 7 |   , "author": "Guillermo Rauch <guillermo@learnboost.com>"
 8 |   , "contributors": [
 9 |         { "name": "Guillermo Rauch", "email": "rauchg@gmail.com" }
10 |       , { "name": "Arnout Kazemier", "email": "info@3rd-eden.com" }
11 |       , { "name": "Vladimir Dronnikov", "email": "dronnikov@gmail.com" }
12 |     ]
13 |   , "repository":{
14 |         "type": "git"
15 |       , "url": "https://github.com/LearnBoost/Socket.IO-node.git"
16 |     }
17 |   , "dependencies": {
18 |         "socket.io-client": "0.7.9"
19 |       , "policyfile": "0.0.4"
20 |       , "redis": "0.6.6"
21 |     }
22 |   , "devDependencies": {
23 |         "expresso": "0.7.7"
24 |       , "should": "0.0.4"
25 |       , "assertvanish": "0.0.3-1"
26 |     }
27 |   , "main": "index"
28 |   , "engines": { "node": ">= 0.4.0" }
29 | }
30 | 


--------------------------------------------------------------------------------
/ducks/server.js:
--------------------------------------------------------------------------------
  1 | /* js tanks server
  2 |  * 7/23/2011
  3 |  * aizuwakamatsu, fukushimaken, japan
  4 |  */
  5 | 
  6 | // NODE LIBRARIES ////////////////////////////////////////////////////////////
  7 | var sys 	= require('sys');
  8 | var http	= require('http');
  9 | var fs 		= require('fs');
 10 | var url 	= require('url');
 11 | 
 12 | // uses socket.io 0.7.9
 13 | var sio		= require('socket.io');
 14 | 
 15 | // CONSTANTS /////////////////////////////////////////////////////////////////
 16 | var PORT	= 8079;
 17 | 
 18 | // DATA STRUCTURES ///////////////////////////////////////////////////////////
 19 | var uid		= 1;	// unique id counter
 20 | var clients	= [];	// array of socket.io client objects
 21 | 
 22 | 
 23 | // PROTOCOL //////////////////////////////////////////////////////////////////
 24 | //
 25 | // SERVER -> CLIENT:
 26 | //   {event: 'hi', id: u_id}
 27 | //
 28 | // CLIENT -> SERVER:
 29 | //   {event: 'pos', blah blah}	- rebroadcast message volatile
 30 | //   {blah blah blah}			- rebroadcast message
 31 | //
 32 | 
 33 | function debug(message)
 34 | {
 35 | 	sys.puts("error: " + message);
 36 | }
 37 | 
 38 | var mime_types = 
 39 | {
 40 | 	html:"text/html",
 41 | 	htm:"text/html",
 42 | 	css:"text/css",
 43 | 	js:"text/javascript",
 44 | 	png:"image/png",
 45 | 	jpg:"image/jpeg",
 46 | 	ico:"image/vnd.microsoft.icon",
 47 | 	txt:"text/plain"
 48 | };
 49 | 
 50 | // SERVER HANDLERS ///////////////////////////////////////////////////////////
 51 | 
 52 | function staticFileHandler(filename)
 53 | {
 54 | 	// cache the data ahead of time
 55 | 	var file = fs.readFileSync(filename, "binary");
 56 | 	var stats = fs.statSync(filename);
 57 | 	var etag = '"' + stats.ino + '-' + stats.size + '-' + Date.parse(stats.mtime) + '"';
 58 | 	
 59 | 	var i = filename.lastIndexOf(".");
 60 | 	var content_type = "text/plain";
 61 | 	if (i != -1) 
 62 | 	{
 63 | 		var extension = filename.substring(i+1);
 64 | 		if (extension != "" && mime_types[extension] != undefined)
 65 | 			content_type = mime_types[extension];
 66 | 	}	
 67 | 	
 68 | 	var header = {
 69 | 		"Server": 			"halo-infinity",
 70 | 		"ETag": 			etag,
 71 | 		"Content-Type": 	content_type,
 72 | 		"Content-Length": 	file.length
 73 | 	}
 74 | 	
 75 | 	return function(request, response)
 76 | 	{
 77 | 		if (request.headers['if-none-match'] != undefined && 
 78 | 			request.headers['if-none-match'].indexOf(etag) != -1)
 79 | 		{
 80 | 			//sys.puts("304 on " + filename);
 81 | 			response.writeHead(304);
 82 | 			response.end();
 83 | 			return;
 84 | 		}
 85 | 
 86 | 		// sys.puts("Serving file " + filename + ".");		
 87 | 		response.writeHead(200, header);  
 88 | 		response.write(file, "binary");  
 89 | 		response.end();
 90 | 	};
 91 | }
 92 | 
 93 | var root = staticFileHandler("index.html");
 94 | var handler = {};
 95 | 
 96 | function listFile(file) { handler[file] = staticFileHandler(file); }
 97 | 
 98 | // list of files on the server
 99 | handler["index.html"] 	= root;
100 | //listFile("favicon.ico");
101 | listFile("server.js");
102 | listFile("game.js");
103 | listFile("duck.js");
104 | listFile("tedge.js");
105 | listFile("physics.js");
106 | listFile("meshes.js");
107 | listFile("glMatrix-0.9.5.min.js");
108 | listFile("thick.png");
109 | //listFile("thin.png");
110 | 
111 | // FILE SERVER ///////////////////////////////////////////////////////////////
112 | server = http.createServer(function(req, resp)
113 | {
114 | 	var uri = url.parse(req.url).pathname;
115 | 	var filename = uri.substring(1);
116 | 
117 | 	if (filename)
118 | 	{
119 | 		if (handler[filename])
120 | 		{
121 | 			handler[filename](req, resp);
122 | 		}
123 | 		else
124 | 		{		
125 | 			resp.writeHead(404, {"Content-Type": "text/plain"});  
126 | 			resp.write("Error 404: file not found");  
127 | 			resp.end();
128 | 			debug("requested invalid file: '" + filename + "'");			
129 | 		}
130 | 	}
131 | 	else
132 | 	{
133 | 		root(req, resp);
134 | 	}
135 | });
136 | 
137 | server.listen(PORT);
138 | 
139 | // SOCKET.IO SERVER //////////////////////////////////////////////////////////
140 | 
141 | var io = sio.listen(server); 
142 | io.sockets.on('connection', function(client)
143 | { 
144 | 	// new player connected
145 | 	var user_id = uid++;
146 | 	clients[user_id] = client;
147 | 	
148 | 	// incoming ajax
149 | 	client.on('message', function(msg)
150 | 	{
151 | 		if (msg.event == 'pos')
152 | 		{
153 | 			client.volatile.broadcast.json.send(msg);
154 | 		}
155 | 		else
156 | 		{
157 | 			client.broadcast.json.send(msg);		
158 | 		}
159 | 	}); 
160 | 	
161 | 	// client disconnect
162 | 	client.on('disconnect', function()
163 | 	{
164 | 		delete clients[user_id];
165 | 		// RemovePlayer(user_id);
166 | 	});
167 | 	
168 | 	// begin the handshake
169 | 	client.json.send({event: "hi", id: user_id});
170 | 	
171 | 	sys.puts("New player with id " + user_id);
172 | }); 
173 | 


--------------------------------------------------------------------------------
/ducks/thick.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/teamduck/gametube/40e8ea4b963148dadadea1f7d28f6d10e0a07953/ducks/thick.png


--------------------------------------------------------------------------------
/rift/build-docs.bat:
--------------------------------------------------------------------------------
1 | node tools\documentation.js reference.txt
2 | pause


--------------------------------------------------------------------------------
/rift/csg.js:
--------------------------------------------------------------------------------
  1 | // constructive solid geometry -- needs some work
  2 | // todo: support UVs
  3 | //   check intersection direction
  4 | 
  5 | function LineIntersection(lineVertex, lineVector, pointA, pointB)
  6 | {
  7 | 	debugger;
  8 | 	var c = VecSub(lineVertex, pointA);
  9 | 	var v = VecSub(pointB, pointA);
 10 | 	var d = VecLength(v);
 11 | 	var t = VecDot(v, c);
 12 | 	var q = VecAdd(pointA, VecScale(v, t/d));
 13 | 	var vq = VecSub(q, lineVertex);
 14 | 	var r = VecLength(vq) / VecDot(q, vq);
 15 | 	var F = VecAdd(lineVertex, VecScale(lineVector, r));
 16 | 	return F;
 17 | 	//var r = VecDot(v, q);
 18 | 	//t = (t + r) / d;
 19 | 	// if 0 <= t <= d, then it's on the segment; otherwise it's off in space
 20 | 	//if (t >= 0 && t <= d)
 21 | 	//	return VecAdd(pointA, VecScale(v, t / d));
 22 | 	return;
 23 | }
 24 | 
 25 | function LineOverlap(segmentA, segmentB, lineVector) 
 26 | {
 27 | 	var aVector = VecSub(segmentA[1], segmentA[0]);
 28 | 	var bVector = VecSub(segmentB[1], segmentB[0]);
 29 | 	if (VecDot(aVector, lineVector) < 0) {
 30 | 		var swap = segmentA[0];
 31 | 		segmentA[0] = segmentA[1];
 32 | 		segmentA[1] = swap;
 33 | 	}
 34 | 	if (VecDot(bVector, lineVector) < 0) {
 35 | 		var swap = segmentB[0];
 36 | 		segmentB[0] = segmentB[1];
 37 | 		segmentB[1] = swap;
 38 | 	}
 39 | 	// a and b are both facing the same direction
 40 | 	var q;
 41 | 	if (VecDot(segmentA[0], lineVector) >= VecDot(segmentB[0], lineVector)) {
 42 | 		q = segmentA[0];
 43 | 	} else {
 44 | 		q = segmentB[0];
 45 | 	}
 46 | 	
 47 | 	var r;
 48 | 	if (VecDot(segmentA[1], lineVector) <= VecDot(segmentB[1], lineVector)) {
 49 | 		r = segmentA[1];
 50 | 	} else {
 51 | 		r = segmentB[1];
 52 | 	}
 53 | 	
 54 | 	if (VecDot(VecSub(r, q), lineVector) > 0)
 55 | 		return [q, r];
 56 | 	return;
 57 | }
 58 | 
 59 | function CSG() {
 60 | 	var csg = {
 61 | 		mesh: {vertices: [], normals: [], uvs: [], count: 0},
 62 | 		
 63 | 		append: function(subMesh, transform, uvTransform) {
 64 | 			if (transform) {
 65 | 				subMesh = CloneMesh(subMesh);
 66 | 				subMesh = TransformMesh(subMesh, transform);
 67 | 				if (uvTransform)
 68 | 					TransformMeshUVs(subMesh, uvTransform);
 69 | 			}
 70 | 			
 71 | 			csg.mesh.count += subMesh.count;
 72 | 			csg.mesh.vertices = csg.mesh.vertices.concat(subMesh.vertices);
 73 | 			if (subMesh.normals)
 74 | 				csg.mesh.normals = csg.mesh.normals.concat(subMesh.normals);
 75 | 			if (subMesh.uvs)
 76 | 				csg.mesh.uvs = csg.mesh.uvs.concat(subMesh.uvs);
 77 | 		},
 78 | 		
 79 | 		subtract: function(subMesh, transform) {
 80 | 			if (transform) {
 81 | 				subMesh = CloneMesh(subMesh);
 82 | 				subMesh = TransformMesh(subMesh, transform);
 83 | 			}
 84 | 			
 85 | 			var mesh = csg.mesh;
 86 | 			var culled = {count: 0, vertices: [], normals: [], uvs: []}
 87 | 			var intersection = false;
 88 | 			
 89 | 			// go through each triangle in the mesh
 90 | 			for (var i = 0; i < mesh.vertices.length; i+=9) 
 91 | 			{
 92 | 				var segments = []; var linkedVertices = [];
 93 | 				var linkedNormals = [];
 94 | 				// go through each triangle of the subtrahend
 95 | 				for (var j = 0; j < subMesh.vertices.length; j+=9)
 96 | 				{
 97 | 					// check if the triangles collide and find the overlapping segment
 98 | 					
 99 | 					// find the line of the intersection of the planes
100 | 					var mNormal = [mesh.normals[i], mesh.normals[i+1], mesh.normals[i+2]];
101 | 					var sNormal = [subMesh.normals[j], subMesh.normals[j+1], subMesh.normals[j+2]];
102 | 					var lineVector = VecCross(mNormal, sNormal);
103 | 					if (VecLengthSqr(lineVector) < 0.5) continue;
104 | 					
105 | 					var lineVertex;
106 | 					var mAnchor = Vector3(mesh.vertices[i], mesh.vertices[i+1], mesh.vertices[i+2]);
107 | 					var sAnchor = Vector3(subMesh.vertices[j], subMesh.vertices[j+1], subMesh.vertices[j+2]);
108 | 					lineVertex = VecDot(VecSub(mAnchor, sAnchor), mNormal);
109 | 					lineVertex = VecAdd(VecScale(mNormal, lineVertex), sAnchor);
110 | 					
111 | 					// clip segment along mTriangle
112 | 					var mSegment = []; var mK;
113 | 					for (var k = 0; k < 3; k++) {
114 | 						var m0 = Vector3(mesh.vertices[i+k*3], mesh.vertices[i+k*3+1], mesh.vertices[i+k*3+2]);
115 | 						var m1 = Vector3(mesh.vertices[i+((k+1)%3)*3],
116 | 							mesh.vertices[i+((k+1)%3)*3+1],
117 | 							mesh.vertices[i+((k+1)%3)*3+2]);
118 | 						var mV = LineIntersection(lineVertex, lineVector, m0, m1);
119 | 						if (mV) {
120 | 							mSegment.push(mV);
121 | 						} else {
122 | 							mK = k;
123 | 						}
124 | 					}
125 | 					if (mSegment.length < 2) continue;
126 | 					
127 | 					// clip segment along sTriangle
128 | 					var sSegment = [];
129 | 					for (var k = 0; k < 3; k++) {
130 | 						var s0 = Vector3(subMesh.vertices[j+k*3], subMesh.vertices[j+k*3+1], subMesh.vertices[j+k*3+2]);
131 | 						var s1 = Vector3(subMesh.vertices[j+((k+1)%3)*3],
132 | 							subMesh.vertices[j+((k+1)%3)*3+1],
133 | 							subMesh.vertices[j+((k+1)%3)*3+2]);
134 | 						var sV = LineIntersection(lineVertex, lineVector, s0, s1);
135 | 						if (sV) {
136 | 							sSegment.push(sV);
137 | 						}
138 | 					}
139 | 					if (sSegment.length < 2) continue;
140 | 					
141 | 					var segment = LineOverlap(mSegment, sSegment, lineVector);
142 | 					if (segment) {
143 | 						segments.push(segment);
144 | 						linkedVertices.push([
145 | 							Vector3(mesh.vertices[i+mK*3], 
146 | 								mesh.vertices[i+mK*3+1], 
147 | 								mesh.vertices[i+mK*3+2]),
148 | 							Vector3(mesh.vertices[i+((mK+1)%3)*3],
149 | 								mesh.vertices[i+((mK+1)%3)*3+1],
150 | 								mesh.vertices[i+((mK+1)%3)*3+2])
151 | 						]);
152 | 						linkedNormals.push(mNormal);
153 | 					}
154 | 				}
155 | 				if (segments.length > 0) {
156 | 					// create new faces
157 | 					intersection = true;
158 | 					for (var k = 0; k < segments.length; k++) {
159 | 						culled.count += 2;
160 | 						culled.vertices = culled.vertices.concat(segments[k][0]);
161 | 						culled.vertices = culled.vertices.concat(segments[k][1]);
162 | 						culled.vertices = culled.vertices.concat(linkedVertices[k][0]);
163 | 						culled.vertices = culled.vertices.concat(segments[k][1]);
164 | 						culled.vertices = culled.vertices.concat(linkedVertices[k][1]);
165 | 						culled.vertices = culled.vertices.concat(linkedVertices[k][0]);
166 | 						for (var q = 0; q < 6; q++)
167 | 							culled.normals = culled.normals.concat(linkedNormals[k]);
168 | 					}
169 | 				} else {
170 | 					// no intersection, so keep this triangle
171 | 					culled.count++;
172 | 					for (var k = 0; k < 9; k++) {
173 | 						culled.vertices.push(mesh.vertices[i+k]);
174 | 						culled.normals.push(mesh.normals[i+k]);
175 | 					}
176 | 					if (mesh.uvs) {
177 | 						var ui = i*2/3;
178 | 						for (var k = 0; k < 6; k++) {
179 | 							culled.uvs.push(mesh.uvs[ui+k]);
180 | 						}
181 | 					}
182 | 				}
183 | 			}
184 | 			
185 | 			csg.mesh = culled;
186 | 			csg.mesh.uvs = [];
187 | 		},
188 | 		
189 | 		compile: function(transform) {
190 | 			var mesh = {vertices: csg.mesh.vertices, count: csg.mesh.count};
191 | 			if (csg.mesh.normals.length) mesh.normals = csg.mesh.normals;
192 | 			if (csg.mesh.uvs.length) mesh.uvs = csg.mesh.uvs;
193 | 			if (transform) {
194 | 				mesh = TransformMesh(mesh, transform);
195 |                 Mat3TransformPoints(mesh.normals, transform);
196 |             }
197 |             if (mesh.normals) {
198 | /*
199 |                 var k;
200 |                 for (k = 0; k < mesh.normals.length; k += 9)
201 |                 {
202 | //                  var V = VecNormalize([mesh.normals[k+0],
203 | //                                          mesh.normals[k+1],
204 | //                                          mesh.normals[k+2]]); 
205 | 
206 |                     var a = Vector3(mesh.vertices[k], mesh.vertices[k+1], mesh.vertices[k+2]);
207 |                     var b = Vector3(mesh.vertices[k+3], mesh.vertices[k+4], mesh.vertices[k+5]);
208 |                     var c = Vector3(mesh.vertices[k+6], mesh.vertices[k+7], mesh.vertices[k+8]);
209 |                     var V = VecNormalize(VecCross(VecSub(a, b), VecSub(b, c)));
210 |                     
211 |                     mesh.normals[k+0] = V[0];
212 |                     mesh.normals[k+1] = V[1];
213 |                     mesh.normals[k+2] = V[2];
214 |                     mesh.normals[k+3] = V[0];
215 |                     mesh.normals[k+4] = V[1];
216 |                     mesh.normals[k+5] = V[2];
217 |                     mesh.normals[k+6] = V[0];
218 |                     mesh.normals[k+7] = V[1];
219 |                     mesh.normals[k+8] = V[2];
220 |                 }
221 | */
222 |             }
223 | 			return BufferMesh(mesh);
224 | 		}
225 | 	};
226 | 	return csg;
227 | }
228 | 


--------------------------------------------------------------------------------
/rift/dev.js:
--------------------------------------------------------------------------------
 1 | function TextSprite(text, style, font, x, y) {
 2 | 	if (style === undefined) style = "white";
 3 | 	if (font === undefined) font = "32px lucida console";
 4 | 	if (x === undefined) x = 0;
 5 | 	if (y === undefined) y = 0;
 6 | 	
 7 | 	var t = {"x": x, "y": y};
 8 | 	var bitmap;
 9 | 	var size;
10 | 	var texture = gl.createTexture();
11 | 	var mesh = BufferMesh(SQUARE_MESH);
12 | 	
13 | 	
14 | 	context.clearRect(0, 0, canvas2D.width, canvas2D.height);
15 | 	context.fillStyle = style;
16 | 	context.font = font;
17 | 	context.textBaseline = "top";
18 | 	context.fillText(text, 0, 0);
19 | 	size = context.measureText(text);
20 | 	t.size = size;
21 | 	var width = 1; while (width < size.width) width *= 2;
22 | 	bitmap = context.getImageData(0, 0, width, width);
23 | 	StoreTexture(texture, bitmap);
24 | 	
25 | 	var identity = Mat4List(Matrix4());
26 | 	var screen = Matrix4();
27 | 	screen = Mat4Mult(screen, Mat4Translate([1, -1, 0]));
28 | 	screen = Mat4Mult(screen, Mat4Scale(width/2, width/2, 1));
29 | 	screen = Mat4Mult(screen, Mat4Translate([-canvas.width/2, -canvas.height/2, 0]));
30 | 	screen = Mat4Mult(screen, Mat4Scale(2/canvas.width, 2/canvas.height, 1));
31 | 	screen = Mat4List(screen);
32 | 	
33 | 	if (x < 0) t.x = canvas.width - size.width + t.x;
34 | 	
35 | 	t.render = function (mtx) {
36 | 		// set up texture shader
37 | 		TEX_SHADER.enable();
38 | 		
39 | 		// orthogonal
40 | 		gl.uniformMatrix4fv(TEX_SHADER.pMatrix, false, identity);
41 | 		gl.uniformMatrix4fv(TEX_SHADER.vMatrix, false, screen);
42 | 		
43 | 		// blending for transparency
44 | 		gl.enable(gl.BLEND);
45 | 		gl.blendFunc(gl.SRC_ALPHA, gl.ONE);
46 | 		gl.depthMask(false);
47 | 		
48 | 		// bind texture
49 | 		gl.activeTexture(gl.TEXTURE0);
50 | 		gl.bindTexture(gl.TEXTURE_2D, texture);
51 | 		gl.uniform1i(TEX_SHADER.samplerUniform, 0);
52 | 		DrawMesh(mesh, Mat4List(Mat4Translate([2*t.x/width, 2*(canvas.height - t.y)/width, 0])), TEX_SHADER);
53 | 		
54 | 		gl.disable(gl.BLEND);
55 | 		gl.depthMask(true);
56 | 		
57 | 		// draw
58 | 		gl.uniformMatrix4fv(TEX_SHADER.pMatrix, false, pMatrix);
59 | 		gl.uniformMatrix4fv(TEX_SHADER.vMatrix, false, vMatrix);
60 | 		TEX_SHADER.disable();
61 | 		STD_SHADER.enable();
62 | 	}
63 | 	return t;
64 | }
65 | 


--------------------------------------------------------------------------------
/rift/ideas.txt:
--------------------------------------------------------------------------------
 1 | elevators
 2 | windows
 3 | gun rooms
 4 | hallway
 5 | upper floor
 6 | lower hangar
 7 | space ship
 8 | 
 9 | assault rifle
10 | laser blaster
11 | daft punk robot police
12 | wall crawlers
13 | probes
14 | boss battle
15 | 
16 | compound model
17 | multi texture
18 | blended animations
19 | 
20 | lounge
21 | arcade machine
22 | computer lab
23 | 
24 | asteroids crashing through hull
25 | 
26 | collectible items?


--------------------------------------------------------------------------------
/rift/index.html:
--------------------------------------------------------------------------------
 1 | <html>
 2 | 	<head>
 3 | 		<title>RIFT FPS</title>
 4 | 		<script src="glMatrix-0.9.5.min.js"></script>
 5 | 		<script src="tedge.js"></script>
 6 | 		<script src="dev.js"></script>
 7 | 		<script src="shaders.js"></script>
 8 | 		<script src="physics.js"></script>
 9 | 		<script src="meshes.js"></script>
10 | 		<script src="csg.js"></script>
11 | 		<script src="textures.js"></script>
12 | 		<script src="particles.js"></script>
13 | 		<script src="game.js"></script>
14 | 		<style>
15 | 			#game {
16 | 				position: absolute;
17 | 				top: 0;
18 | 				left: 0;
19 | 				border: none;
20 | 			}
21 | 		</style>
22 | 	</head>
23 | 	<body>
24 | 		<!--<audio src="introspection.mp3" autoplay loop></audio>-->
25 | 		<canvas id="game" width="100%" height="100%">
26 | 		</canvas>
27 | 		<canvas id="2D" style="display: none;">
28 | 	</body>
29 | </html>
30 | 


--------------------------------------------------------------------------------
/rift/meshes.js:
--------------------------------------------------------------------------------
  1 | /* simple meshes */
  2 | BOX_MESH = {"count":12,"vertices":[0,1,1,0,0,1,1,1,1,0,0,1,1,0,1,1,1,1,1,1,1,1,0,1,1,1,0,1,0,1,1,0,0,1,1,0,1,1,0,1,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,1,0,1,1,0,1,0,0,1,1,1,1,0,0,1,1,1,1,1,1,1,0,0,0,1,0,0,0,1,0,1,0,0,0,1,0,0,1,0,1],"uvs":[0,0,0,1,1,0,0,1,1,1,1,0,0,0,0,1,1,0,0,1,1,1,1,0,0,0,0,1,1,0,0,1,1,1,1,0,0,0,0,1,1,0,0,1,1,1,1,0,0,0,0,1,1,0,0,1,1,1,1,0,0,0,0,1,1,0,0,1,1,1,1,0],"normals":[0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0]};
  3 | 
  4 | SQUARE_MESH = {"count":2,"vertices":[-1,-1,0,1,-1,0,-1,1,0,-1,1,0,1,-1,0,1,1,0],"uvs":[0,0,1,0,0,1,0,1,1,0,1,1],"normals":[0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1]};
  5 | 
  6 | /* procedural meshes */
  7 | var MARK_MESH;
  8 | function GetMarkMesh() {
  9 | 	if (MARK_MESH === undefined) {
 10 | 		var csg = CSG();
 11 | 		csg.append(SQUARE_MESH, Mat4Translate(0, 0, 0.1));
 12 | 		csg.append(SQUARE_MESH, Mat4Translate(0, 0, -0.1));
 13 | 		MARK_MESH = csg.compile();
 14 | 	}
 15 | 	return MARK_MESH;
 16 | }
 17 | 
 18 | function BlobMesh() 
 19 | {
 20 | 	var blob = Math2MeshSphere(function () { 
 21 | 		return (1 + Math.random()) * 2;
 22 | 	}, 16, 16);
 23 | 	
 24 | 	TransformMesh(blob, Mat4Translate(0, 1, 0));
 25 | 	
 26 | 	for (var i = 0; i < blob.vertices.length; i+=3) {
 27 | 		if (blob.vertices[i+1] < 0)
 28 | 			blob.vertices[i+1] = 0;
 29 | 	}
 30 | 	
 31 | 	TransformMesh(blob, Mat4Scale(1.4, 1.25, 1.4));
 32 | 	
 33 | 	var csg = CSG();
 34 | 	csg.append(blob);
 35 | 	
 36 | 	for (var k = 0; k < 8; k++) {
 37 | 		// psuedo randomly oriented limbs
 38 | 		var pos = [k*k + 17*(k+1) + 13];
 39 | 		pos.push(pos[0]*11*k + 13*k + 19);
 40 | 		pos.push(pos[0] + pos[1]*2 + 21*k);
 41 | 		pos[0] = ((pos[0]%11)/11)*5 - 2.5;
 42 | 		pos[1] = ((pos[1]%11)/11)*2 + 1.0;
 43 | 		pos[2] = ((pos[2]%11)/11)*5 - 2.5;
 44 | 		
 45 | 		var path = [{
 46 | 			pos: pos,
 47 | 			radius: 0.5
 48 | 		}];
 49 | 		var angle = QuatFromVectors(VEC_UP, VecNormalize(path[0].pos));
 50 | 		angle = QuatNormalize(angle);
 51 | 		for (var i = 1; i < 7; i++) {
 52 | 			// randomly arrange the tentacles
 53 | 			var pos = Mat4TransformPoint([Math.random()*2 - 1, Math.random()+0.5, Math.random()*2 - 1], Mat4Rotate(angle));
 54 | 			pos = VecAdd(pos, path[i-1].pos);
 55 | 			path.push({pos: pos, radius: 0.5});
 56 | 		}
 57 | 		var tentacle = Math2MeshPath(path, 3);
 58 | 		csg.append(tentacle, Matrix4(), [0.2, 0, 0, 0, 0.2, 0]);
 59 | 	}
 60 | 	
 61 | 	return csg.compile();
 62 | }
 63 | 
 64 | 
 65 | function PlasmaGunMesh(transform)
 66 | {
 67 | 	var csg = CSG();
 68 | 	var matrix;
 69 | 	
 70 | 	var barrel = Math2MeshCylinder(function (theta, t) {
 71 | 		return MAX(Math.sin(t*6)*0.5 + 1.2, Math.cos(t*6)*0.5 + 1);
 72 | 	}, 12, 12);
 73 | 	
 74 | 	var ball = Math2MeshSphere(function() { return 0.5; }, 8, 8);
 75 | 	
 76 | 	var handle = CloneMesh(BOX_MESH);
 77 | 	matrix = Mat4Translate(-0.5, -0.5, 0)
 78 | 	matrix = Mat4Mult(matrix, Mat4Scale(0.4, 0.5, 1.2));
 79 | 	matrix = Mat4Mult(matrix, Mat4Rotate(QuatXYZ(0.5, 0, 0)));
 80 | 	handle = TransformMesh(handle, matrix);
 81 | 	
 82 | 	csg.append(barrel, Mat4Scale(0.25, 2, 0.25), [1, 0, 0, 0, 0.48, 0.01]);
 83 | 	csg.append(ball, Matrix4(), [0.5, 0, 0, 0, 0.5, 0.5]);
 84 | 	csg.append(handle, Matrix4(), [0.5, 0, 0.5, 0, 0.5, 0.5]);
 85 | 	if (transform) {
 86 | 		transform = Mat4Mult(Mat4Rotate(QUAT_X), transform);
 87 | 	} else {
 88 | 		transform = Mat4Rotate(QUAT_X);
 89 | 	}
 90 | 	return csg.compile(transform);
 91 | }
 92 | 
 93 | /* model viewing tool */
 94 | function ModelViewer()
 95 | {
 96 | 	puid = connect();
 97 | 
 98 | 	//var mesh = BufferMesh(BOX_MESH);
 99 | 	var model = 0;
100 | 	var models = [
101 | 		PlasmaGunMesh(),
102 |         //BOX_MESH,
103 |         //Math2MeshSphere(function() {return 0.75;}, 5, 5),
104 |         Tree().mesh,
105 |         Snake([0,0,0]).mesh,
106 |         EnergyCore().mesh,
107 |         Tubes([0,0,0]).mesh,
108 |         Map().mesh,
109 | 		//BlobMesh(),
110 | 	];
111 | 	var texture = MakeTexture(CheckeredTexture(), 256);
112 | 	gl.clearColor(0.0, 0.0, 1.0, 1.0);
113 | 	
114 | 	var mv = InputtingEntity({}, puid);
115 | 	var rotation = Quat();
116 | 	var wireframe = false;
117 | 	var t = 0;
118 | 	var zoom = 1;
119 | 	mv.update = function (dt)
120 | 	{
121 | 		t += dt;
122 | 		if (mv.mouseHit(M_LEFT)) {
123 | 			origin = mv.mousePosition();
124 | 		}
125 | 		if (mv.mouseDown(M_LEFT)) {
126 | 			var vector = mv.mousePosition();
127 | 			vector = [(vector[0] - origin[0])*3, 
128 | 					(origin[1] - vector[1])*3];
129 | 			rotation = QuatMult(rotation, QuatXYZ(0, vector[0], 0));
130 | 			rotation = QuatMult(QuatXYZ(vector[1], 0, 0), rotation);
131 | 			origin = mv.mousePosition();
132 | 		}
133 | 		if (mv.keyHit(K_W)) {
134 | 			wireframe = !wireframe;
135 | 		}
136 | 		if (mv.keyHit(K_LEFT)) model = (model+1)%models.length;
137 | 		if (mv.keyHit(K_RIGHT)) model = (model-1+models.length)%models.length;
138 | 		if (mv.keyDown(K_UP)) zoom *= 1 + dt;
139 | 		if (mv.keyDown(K_DOWN)) zoom *= 1 - dt;
140 | 	}
141 | 	
142 | 	gCamera = Camera(VEC_FORWARD);
143 | 	mv.render = function ()
144 | 	{
145 | 		var matrix = Mat4World([0, 0, 5], rotation);
146 | 		matrix = Mat4Mult(Mat4Scale(zoom), matrix);
147 | 		matrix = Mat4List(matrix);
148 | 		TEX_SHADER.enable(texture);
149 | 		DrawMesh(models[model], matrix, TEX_SHADER, wireframe);
150 | 	}
151 | 	
152 | 	entities.push(mv);
153 | 	
154 | 	startGame();
155 | }
156 | 


--------------------------------------------------------------------------------
/rift/model.html:
--------------------------------------------------------------------------------
 1 | <html>
 2 | 	<head>
 3 | 		<title>RIFT FPS</title>
 4 | 		<script src="glMatrix-0.9.5.min.js"></script>
 5 | 		<script src="tedge.js"></script>
 6 | 		<script src="dev.js"></script>
 7 | 		<script src="shaders.js"></script>
 8 | 		<script src="physics.js"></script>
 9 | 		<script src="meshes.js"></script>
10 | 		<script src="csg.js"></script>
11 | 		<script src="textures.js"></script>
12 | 		<script src="particles.js"></script>
13 | 		<script src="game.js"></script>
14 | 		<script>gameInit = ModelViewer;</script>
15 | 		<style>
16 | 			#game {
17 | 				position: absolute;
18 | 				top: 0;
19 | 				left: 0;
20 | 				border: none;
21 | 			}
22 | 		</style>
23 | 	</head>
24 | 	<body>
25 | 		<!--<audio src="introspection.mp3" autoplay loop></audio>-->
26 | 		<canvas id="game" width="100%" height="100%">
27 | 		</canvas>
28 | 		<canvas id="2D" style="display: none;">
29 | 	</body>
30 | </html>
31 | 


--------------------------------------------------------------------------------
/rift/particles.js:
--------------------------------------------------------------------------------
  1 | /* particle effects */
  2 | function ParticleGenerator() 
  3 | {
  4 | 	var pg = {
  5 | 		pos: [25, 1, 30],
  6 | 		delay: 0.1,
  7 | 		size: 1,
  8 | 		range: 2,
  9 | 		count: 25,
 10 | 		color: [1, 1, 1, 1],
 11 | 		velocity: VEC_UP,
 12 | 		blending: [gl.SRC_ALPHA, gl.ONE]
 13 | 	};
 14 | 	var particles = [];
 15 | 	
 16 | 	pg.texture = GetParticleTexture();
 17 | 	pg.mesh = BufferMesh(SQUARE_MESH);
 18 | 	
 19 | 	var t = 0;
 20 | 	pg.update = function (dt) {
 21 | 		pg.duration = pg.delay * pg.count;
 22 | 		t += dt;
 23 | 		
 24 | 		// generate new particles
 25 | 		if (t > pg.delay) {
 26 | 			var particle = {life: 0};
 27 | 			particle.pos = Vector3(Math.random(), Math.random(), Math.random());
 28 | 			particle.pos = VecSub(particle.pos, [0.5, 0.5, 0.5]);
 29 | 			if (pg.range.length)
 30 | 				particle.pos = VecMult(particle.pos, pg.range);
 31 | 			else
 32 | 				particle.pos = VecScale(particle.pos, pg.range);
 33 | 			particle.pos = VecAdd(particle.pos, pg.pos);
 34 | 			particles.push(particle);
 35 | 			
 36 | 			if (particles.length > pg.count) {
 37 | 				particles = particles.slice(particles.length - pg.count);
 38 | 			}
 39 | 			
 40 | 			t -= pg.delay;
 41 | 		}
 42 | 		
 43 | 		// update existing ones
 44 | 		for (var p in particles) {
 45 | 			var particle = particles[p];
 46 | 			particle.pos = VecAdd(VecScale(pg.velocity, dt), particle.pos);
 47 | 			particle.life += dt;
 48 | 		}
 49 | 	}
 50 | 	
 51 | 	pg.render = function () {
 52 | 		TEX_SHADER.enable(pg.texture);
 53 | 		gl.enable(gl.BLEND);
 54 | 		gl.blendFunc(pg.blending[0], pg.blending[1]);
 55 | 		gl.depthMask(false);
 56 | 		var rot = gCamera.rot;
 57 | 		for (var p in particles) 
 58 | 		{
 59 | 			var particle = particles[p];
 60 | 			var matrix = Mat4World(particle.pos, rot);
 61 | 			matrix = Mat4Mult(Mat4Scale(pg.size), matrix);
 62 | 			var alpha = 1 - (2*abs(particle.life - pg.duration/2) / pg.duration);
 63 | 			TEX_SHADER.setColor(pg.color[0], pg.color[1], pg.color[2], pg.color[3] * alpha);
 64 | 			matrix = Mat4List(matrix);
 65 | 			DrawMesh(pg.mesh, matrix, TEX_SHADER);
 66 | 		}
 67 | 		gl.depthMask(true);
 68 | 		gl.disable(gl.BLEND);
 69 | 		
 70 | 		TEX_SHADER.setColor(1, 1, 1, 1);
 71 | 	}
 72 | 	
 73 | 	pg.devRender = function () 
 74 | 	{
 75 | 		var verts = [];
 76 | 		for (var i = 0; i < particles.length; i++) {
 77 | 			verts = verts.concat(particles[i].pos);
 78 | 		}
 79 | 		var boundingBox = BBFromMesh(verts);
 80 | 		DrawBoundingBox(boundingBox);
 81 | 	}
 82 | 	
 83 | 	return pg;
 84 | }
 85 | 
 86 | function FireEffect(pos) 
 87 | {
 88 | 	var effect = {rot: Quat()};
 89 | 	var fire = ParticleGenerator();
 90 | 	if (pos) {
 91 | 		fire.pos = pos;
 92 | 	}
 93 | 	effect.pos = fire.pos;
 94 | 	fire.size = 1.5;
 95 | 	fire.pos[1] = 0;
 96 | 	fire.range = 2.5;
 97 | 	fire.velocity = [0.6, 4, 0];
 98 | 	fire.color = [1, 0.25, 0.1, 2];
 99 | 	fire.delay = 0.02;
100 | 	fire.count = 50;
101 | 	
102 | 	var smoke = ParticleGenerator();
103 | 	smoke.size = fire.size * 2;
104 | 	smoke.pos = VecAdd(fire.pos, VecScale(fire.velocity, 0.5));
105 | 	smoke.range = fire.range * 3;
106 | 	smoke.velocity = VecScale(fire.velocity, 0.25);
107 | 	smoke.color = [0.5, 0.5, 0.5, 1];
108 | 	smoke.delay = 0.5;
109 | 	smoke.count = 20;
110 | 	smoke.blending = [gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA];
111 | 	
112 | 	effect.update = function (dt) {
113 | 		fire.pos = effect.pos;
114 | 		smoke.pos = VecAdd(effect.pos, VecScale(fire.velocity, 0.5));
115 | 		
116 | 		fire.update(dt);
117 | 		smoke.update(dt);
118 | 	}
119 | 	
120 | 	effect.render = function () {
121 | 		fire.render();
122 | 		smoke.render();
123 | 	}
124 | 	
125 | 	effect.devRender = function () {
126 | 		fire.devRender(); smoke.devRender();
127 | 	}
128 | 	
129 | 	return effect;
130 | }
131 | 
132 | function Explosion(pos) 
133 | {
134 | 	var exp = {
135 | 		pos: [25, 0, 30],
136 | 		size: 1,
137 | 		range: 1,
138 | 		count: 50,
139 | 		duration: 1,
140 | 		color: [0.8, 0.3, 0.2, 1],
141 | 		velocity: [0, 0, 0],
142 | 		velocityRange: 15,
143 | 		force: [0, 0, 0],
144 | 		blending: [gl.SRC_ALPHA, gl.ONE]
145 | 	};	
146 | 	exp.texture = GetParticleTexture();
147 | 	exp.mesh = BufferMesh(SQUARE_MESH);
148 | 	
149 | 	if (pos) exp.pos = pos;
150 | 	
151 | 	var particles = [];
152 | 	// generate particles
153 | 	for (var i = 0; i < exp.count; i++) {
154 | 		var particle = {life: 0};
155 | 		particle.pos = Vector3(Math.random(), Math.random(), Math.random());
156 | 		particle.pos = VecSub(particle.pos, [0.5, 0.5, 0.5]);
157 | 		if (exp.range.length)
158 | 			particle.pos = VecMult(particle.pos, exp.range);
159 | 		else
160 | 			particle.pos = VecScale(particle.pos, exp.range);
161 | 		particle.pos = VecAdd(particle.pos, exp.pos);
162 | 		
163 | 		particle.vel = Vector3(Math.random(), Math.random(), Math.random());
164 | 		particle.vel = VecSub(particle.vel, [0.5, 0.5, 0.5]);
165 | 		if (exp.velocityRange.length)
166 | 			particle.vel = VecMult(particle.vel, exp.velocityRange);
167 | 		else
168 | 			particle.vel = VecScale(particle.vel, exp.velocityRange);
169 | 		particle.vel = VecAdd(particle.vel, exp.velocity);
170 | 		
171 | 		particles.push(particle);
172 | 	}
173 | 	
174 | 	var t = 0;
175 | 	exp.update = function (dt) {
176 | 		t += dt;
177 | 		if (t < exp.duration) {
178 | 			// update existing ones
179 | 			for (var p in particles) {
180 | 				var particle = particles[p];
181 | 				particle.pos = VecAdd(VecScale(particle.vel, dt), particle.pos);
182 | 				particle.vel = VecAdd(VecScale(exp.force, dt), particle.vel);
183 | 				particle.life += dt;
184 | 			}
185 | 		} else {
186 | 			// delete?
187 | 			removeEntity(exp);
188 | 		}
189 | 	}
190 | 	
191 | 	exp.render = function () {
192 | 		TEX_SHADER.enable(exp.texture);
193 | 		gl.enable(gl.BLEND);
194 | 		gl.blendFunc(exp.blending[0], exp.blending[1]);
195 | 		gl.depthMask(false);
196 | 		var rot = gCamera.rot;
197 | 		for (var p in particles) 
198 | 		{
199 | 			var particle = particles[p];
200 | 			var matrix = Mat4World(particle.pos, rot);
201 | 			matrix = Mat4Mult(Mat4Scale(exp.size), matrix);
202 | 			var alpha = 1 - particle.life/exp.duration;
203 | 			TEX_SHADER.setColor(exp.color[0], exp.color[1], exp.color[2], exp.color[3] * alpha);
204 | 			matrix = Mat4List(matrix);
205 | 			DrawMesh(exp.mesh, matrix, TEX_SHADER);
206 | 		}
207 | 		gl.depthMask(true);
208 | 		gl.disable(gl.BLEND);
209 | 		
210 | 		TEX_SHADER.setColor(1, 1, 1, 1);
211 | 	}
212 | 	
213 | 	exp.devRender = function () 
214 | 	{
215 | 		var verts = [];
216 | 		for (var i = 0; i < particles.length; i++) {
217 | 			verts = verts.concat(particles[i].pos);
218 | 		}
219 | 		var boundingBox = BBFromMesh(verts);
220 | 		DrawBoundingBox(boundingBox);
221 | 	}
222 | 	
223 | 	return exp;
224 | }
225 | 


--------------------------------------------------------------------------------
/rift/reference.txt:
--------------------------------------------------------------------------------
  1 | TEDGE PROJECT QUICK REFERENCE
  2 | =================================
  3 | =================================
  4 | 
  5 | 
  6 | csg.js:
  7 | 	200 lines and 3 functions
  8 | 	
  9 | 	function LineIntersection(lineVertex, lineVector, pointA, pointB)
 10 | 	function LineOverlap(segmentA, segmentB, lineVector)
 11 | 	function CSG()
 12 | 
 13 | 
 14 | dev.js:
 15 | 	65 lines and 1 function
 16 | 	
 17 | 	function TextSprite(text, style, font, x, y)
 18 | 
 19 | 
 20 | game.js:
 21 | 	959 lines and 16 functions
 22 | 	
 23 | 	function Box(position, rotation)
 24 | 	function SpaceBox()
 25 | 	function Map()
 26 | 	function transformPosition(v)
 27 | 	function transformRotation(v, q)
 28 | 	function Player(puid)
 29 | 	function PlasmaBolt(shooter, pos, rotation)
 30 | 	function ScorchMark(pos, normal)
 31 | 	function Tubes(pos)
 32 | 	function EnergyCore()
 33 | 	function Tree(pos)
 34 | 	function Snake(pos)
 35 | 	function BlobMonster(pos)
 36 | 	function HelmetDisplay()
 37 | 	function gameInit()
 38 | 	function finishedLoading()
 39 | 
 40 | 
 41 | glMatrix-0.9.5.min.js:
 42 | 	33 lines and 0 functions
 43 | 	
 44 | 
 45 | 
 46 | meshes.js:
 47 | 	147 lines and 4 functions
 48 | 	
 49 | 	function GetMarkMesh()
 50 | 	function BlobMesh()
 51 | 	function PlasmaGunMesh(transform)
 52 | 	function ModelViewer()
 53 | 
 54 | 
 55 | particles.js:
 56 | 	225 lines and 3 functions
 57 | 	
 58 | 	function ParticleGenerator()
 59 | 	function FireEffect(pos)
 60 | 	function Explosion(pos)
 61 | 
 62 | 
 63 | physics.js:
 64 | 	1043 lines and 63 functions
 65 | 	
 66 | 	function MAX(a,b)
 67 | 	function MIN(a,b)
 68 | 	function MOD(a,b)
 69 | 	function Vector3(x, y, z)
 70 | 	function VecCopy(v)
 71 | 	function VecAdd(a, b, c)
 72 | 	function VecAdd(a, b)
 73 | 	function VecSub(a, b)
 74 | 	function VecScale(v, s)
 75 | 	function VecNormalize(v)
 76 | 	function VecLength(v)
 77 | 	function VecLengthSqr(v)
 78 | 	function VecDot(a, b)
 79 | 	function VecCross(a, b)
 80 | 	function VecMult(a, b)
 81 | 	function VecRotate(v, q)
 82 | 	function Quat(w, x, y, z)
 83 | 	function QuatInverse(q)
 84 | 	function QuatFromVectors(a, b)
 85 | 	function QuatNormalize(q)
 86 | 	function QuatMult(a, b)
 87 | 	function QuatXYZ(pitch, yaw, roll)
 88 | 	function QuatSlerp(start, end, alpha)
 89 | 	function Matrix4()
 90 | 	function Mat4List(m)
 91 | 	function Mat4Scale(x, y, z)
 92 | 	function Mat4Translate(x, y, z)
 93 | 	function Mat4FromVectors(right, up, forward)
 94 | 	function Mat4World(pos, rot)
 95 | 	function Mat4Rotate(rot)
 96 | 	function Mat4TransformPoints(points, mtx)
 97 | 	function Mat4TransformPoint(point, mtx)
 98 | 	function Mat3TransformPoints(points, mtx)
 99 | 	function Mat3TransformPoint(point, mtx)
100 | 	function Mat4Mult(a, b)
101 | 	function Mat4Determinant(a)
102 | 	function Mat4Transpose(m)
103 | 	function Mat4Inverse(a)
104 | 	function BBCopy(bb)
105 | 	function BBJoin(bb1, bb2)
106 | 	function BBAddPoint(bb, point)
107 | 	function BBTestPoint(bb, point)
108 | 	function BBTestBB(bb1, bb2)
109 | 	function BBTestRay(box, origin, dir, t0, t1)
110 | 	function BBFromMesh(verts)
111 | 	function DrawBoundingBox(bb)
112 | 	function BBSize(bb)
113 | 	function BBCenter(bb)
114 | 	function BBContains(big, small)
115 | 	function BBCut(bb, axis)
116 | 	function BBTransform(bb, m)
117 | 	function Prune(vertices, bb)
118 | 	function Octree(vertices, rootBB)
119 | 	function PhysicalEntity(e, mesh, dynamic)
120 | 	function Physics(dt)
121 | 	function checkCollision(objA, objB)
122 | 	function sphereSphereCollision(objA, objB)
123 | 	function geometryGeometryCollision(objA, objB)
124 | 	function geometrySphereCollision(geom, sphere)
125 | 	function sphereGeometryCollision(sphere, geom)
126 | 	function SignedDistToPlane(point, normal, planeConst)
127 | 	function PointIsInTriangle(point, tri)
128 | 	function ClosestPointOnLine(point, lineA, lineB)
129 | 
130 | 
131 | shaders.js:
132 | 	421 lines and 8 functions
133 | 	
134 | 	function StandardShader()
135 | 	function TextureShader()
136 | 	function AnimationShader()
137 | 	function OrthogonalProjection()
138 | 	function NormalProjection()
139 | 	function StaticMatrix(vMatrix)
140 | 	function FixedMatrix(vMatrix)
141 | 	function initShaders()
142 | 
143 | 
144 | tedge.js:
145 | 	1259 lines and 47 functions
146 | 	
147 | 	function run()
148 | 	function Load(constructorList, callback)
149 | 	function LoadInstance()
150 | 	function connect()
151 | 	function receive(type, arg)
152 | 	function receiveAll(type, N, arg)
153 | 	function receiveNew(type, arg)
154 | 	function initGL()
155 | 	function render()
156 | 	function loadTexture(file)
157 | 	function setTexture(texture)
158 | 	function handleLoadedTexture(texture)
159 | 	function StoreTexture(texture, bitmap)
160 | 	function MakeTexture(shader, size)
161 | 	function UpdateTexture(texture, shader)
162 | 	function PackTexture(shaders, size)
163 | 	function BufferMesh(mesh)
164 | 	function UpdateMesh(mesh)
165 | 	function DrawMesh(mesh, worldMtx, shader, wireframe)
166 | 	function CloneMesh(mesh)
167 | 	function TransformMesh(mesh, mtx)
168 | 	function TransformMeshNonlinear(mesh, transformFunction)
169 | 	function TransformMeshUVs(mesh, affineMatrix)
170 | 	function InputtingEntity(e, player)
171 | 	function onKeyDown(evt)
172 | 	function onKeyUp(evt)
173 | 	function onMouseDown(evt)
174 | 	function onMouseUp(evt)
175 | 	function onMouseMove(evt)
176 | 	function startGame()
177 | 	function gameLoop()
178 | 	function update(dt)
179 | 	function removeEntity(e)
180 | 	function StaticEntity(mesh, mdlMtx)
181 | 	function DynamicEntity(origMesh, mdlMtx)
182 | 	function addPoint(mesh, values, x, z, wrap, u, v)
183 | 	function Math2Mesh(maths, xrange, zrange, quality)
184 | 	function Math2MeshSphere(maths, slices, cuts)
185 | 	function Math2MeshCylinder(maths, slices, cuts, caps)
186 | 	function Math2MeshTunnel(maths, slices, cuts, caps)
187 | 	function Math2MeshPath(path, cuts)
188 | 	function SimplePhysics(p, dt)
189 | 	function FPSCounter()
190 | 	function LoadingScreen()
191 | 	function Camera(vector)
192 | 	function TrackingCamera(target)
193 | 	function FPSCamera()
194 | 
195 | 
196 | textures.js:
197 | 	382 lines and 20 functions
198 | 	
199 | 	function CrateTexture()
200 | 	function WoodGrainTexture()
201 | 	function LeafTexture()
202 | 	function HazardTexture()
203 | 	function PanelTexture()
204 | 	function SteelGridTexture()
205 | 	function CheckeredTexture()
206 | 	function DeepPurpleTexture()
207 | 	function FunHouseTexture()
208 | 	function CorrugatedSteelTexture()
209 | 	function HazardSteelTexture()
210 | 	function LightParticleTexture()
211 | 	function GetParticleTexture()
212 | 	function HexagonalTexture()
213 | 	function HelmetTexture()
214 | 	function TargettingTexture()
215 | 	function SpaceBoxTexture(face)
216 | 	function BlobTexture()
217 | 	function PlasmaGunTexture()
218 | 	function TextureViewer()
219 | 
220 | 
221 | 4734 lines and 165 functions for the entire project. Total filesize: 133.537kb:
222 | 


--------------------------------------------------------------------------------
/rift/release/index.html:
--------------------------------------------------------------------------------
 1 | <html>
 2 | 	<head>
 3 | 		<title>RIFT &lt;classified&gt;</title>
 4 | 		<script src="compiled.js"></script>
 5 | 		</script>
 6 | 		<style>
 7 | 			#game {
 8 | 				position: absolute;
 9 | 				top: 0;
10 | 				left: 0;
11 | 				border: none;
12 | 			}
13 | 		</style>
14 | 	</head>
15 | 	<body>
16 | 		<audio src="introspection.mp3" autoplay loop></audio>
17 | 		<canvas id="game" width="100%" height="100%">
18 | 		</canvas>
19 | 		<canvas id="2D" style="display: none;">
20 | 	</body>
21 | </html>


--------------------------------------------------------------------------------
/rift/release/introspection.mp3:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/teamduck/gametube/40e8ea4b963148dadadea1f7d28f6d10e0a07953/rift/release/introspection.mp3


--------------------------------------------------------------------------------
/rift/tedge notes.txt:
--------------------------------------------------------------------------------
 1 | Game Framework
 2 | ------------------
 3 | 
 4 | make a level in some fancy program
 5 | this includes geometry, textures, and material properties
 6 | also has spawn points and arguments for different entities / generators / triggers
 7 | 
 8 | loading... screen
 9 | 
10 | load this into a root tree object, add the geometry to the collision engine
11 | initialize all the entities from the map
12 | these all have specific models / textures / shaders bound to them
13 | and are either static, dynamic, or invisible
14 | this means render() is taken care of with a model {} object
15 | and collision / "physics" is good to go
16 | update controls game logic & input, for the player(s) and mobs, and animation states
17 | enemy generators can pump out instances of entities
18 | particle generators, etc
19 | when cinematics are triggered, add black bars, swap to a different camera and queue a bunch of animations
20 | 	also disable input
21 | reset stuff afterward or load a new level (empty entity list, unbuffer almost everything)
22 | 
23 | 
24 | 
25 | for multiplayer...
26 | 	player characters are controlled locally, and have their essential state is broadcast
27 | 	one player is the host, others are designated clients, and there is a heartbeat of game state
28 | 		which means all the essential info (location, health) of mobs
29 | 		mob.pos,vel		mob.health		mob.color	
30 | 		mob.addProperty(health);		mob.setProperty(health, 10);	mob.setProperty(health, health-1);
31 | 		networkHeartbeat() { /* send broadcasts for all properties that changed */ }
32 | 	events like a monster dying are also sent out and probably need a response
33 | 			thisMob.gameEvent("dead");	cinematic.gameEvent("nextScene");
34 | 			entity.gameEvent = function (tag) { if (host) -> broadcast, call handler; else wait for event to call }
35 | 	if the host disconnects, one of the other players becomes the host
36 | 	
37 | 
38 | 
39 | some_editor.3Dfile.compile =>
40 | 
41 | game = {
42 | 	title: "rift",
43 | 	maps: {
44 | 		point_insertion: {},
45 | 		fusion_lab: {},
46 | 		tiberium_research: {},
47 | 		nikai_office: {},
48 | 		aqua: {}
49 | 	},
50 | 	entities: {
51 | 		genericPlayerGuy: {},
52 | 		fpsCamera: tedgeFpsCamera,
53 | 		randomNPC: animatedDude(scientist_model),
54 | 		flyingRobot: {},
55 | 		sexyAIgirl: animatedDude(hot_chick_model, glowy_shader),
56 | 		environmentalHazard: {},
57 | 		boss: energySpaceWorm,
58 | 		key: collectyThing(key_mesh),
59 | 		nextSceneCinematic: shows up after you kill the boss, pans camera around the hero wherever he is and plays music
60 | 	},
61 | 	meshes: {
62 | 	
63 | 	},
64 | 	textures: {
65 | 	
66 | 	}
67 | };
68 | 
69 | 
70 | 
71 | 


--------------------------------------------------------------------------------
/rift/texture.html:
--------------------------------------------------------------------------------
 1 | <html>
 2 | 	<head>
 3 | 		<title>RIFT FPS</title>
 4 | 		<script src="glMatrix-0.9.5.min.js"></script>
 5 | 		<script src="tedge.js"></script>
 6 | 		<script src="dev.js"></script>
 7 | 		<script src="shaders.js"></script>
 8 | 		<script src="physics.js"></script>
 9 | 		<script src="meshes.js"></script>
10 | 		<script src="csg.js"></script>
11 | 		<script src="textures.js"></script>
12 | 		<script src="particles.js"></script>
13 | 		<script src="game.js"></script>
14 | 		<script>gameInit = TextureViewer;</script>
15 | 		<style>
16 | 			#game {
17 | 				position: absolute;
18 | 				top: 0;
19 | 				left: 0;
20 | 				border: none;
21 | 			}
22 | 		</style>
23 | 	</head>
24 | 	<body>
25 | 		<!--<audio src="introspection.mp3" autoplay loop></audio>-->
26 | 		<canvas id="game" width="100%" height="100%">
27 | 		</canvas>
28 | 		<canvas id="2D" style="display: none;">
29 | 	</body>
30 | </html>
31 | 


--------------------------------------------------------------------------------
/rift/tools/documentation.js:
--------------------------------------------------------------------------------
  1 | // node script to pull out some primitive docs from the code
  2 | 
  3 | fs = require("fs");
  4 | 
  5 | var blacklist = {};
  6 | //blacklist["glMatrix-0.9.5.min.js"] = true;
  7 | //blacklist["compiled.js"] = true;
  8 | 
  9 | var totalLines = 0;
 10 | var totalFunctions = 0;
 11 | var totalSize = 0;
 12 | var compiled = "";
 13 | 
 14 | console.log("\nparsing .js files...\n");
 15 | 
 16 | if (process.argv.length < 3) {
 17 | 	console.log("needs an output file\n");
 18 | 	process.exit(1);
 19 | }
 20 | 
 21 | var output = {
 22 | 	"title": "TEDGE PROJECT QUICK REFERENCE",
 23 | 	"file": process.argv[2],
 24 | 	"sdivider": "---------------------------------\r\n\r\n",
 25 | 	"ddivider": "=================================\r\n",
 26 | 	"data": "",
 27 | 	"section": function (title) {
 28 | 		console.log(title + "...");
 29 | 		output.data += title + ":\r\n";
 30 | 	},
 31 | 	"stub": function (s) {
 32 | 		output.data += "\t" + s + "\r\n";
 33 | 	},
 34 | 	"end": function () {
 35 | 		output.data += "\r\n\r\n";
 36 | 	},
 37 | 	"write": function () {
 38 | 		output.data = output.title + "\r\n" + output.ddivider + 
 39 | 			output.ddivider + "\r\n\r\n" + output.data;
 40 | 		fs.writeFile(output.file, output.data, function (err) {
 41 | 			if (err) throw err;
 42 | 			console.log("\nsaved to " + output.file + "\n");
 43 | 		});
 44 | 	}
 45 | }
 46 | 
 47 | function parse(data)
 48 | {
 49 | 	var functionCount = 0;
 50 | 	var lineCount = 0;
 51 | 	totalSize += data.length;
 52 | 	compiled += data;
 53 | 	
 54 | 	var functions = data.match(/function\s+[A-Z0-9_]+\s*\([A-Z0-9_, ]*\)/gi);
 55 | 	var lines = data.split("\n");
 56 | 	
 57 | 	if (functions) {
 58 | 		functionCount = functions.length;
 59 | 		totalFunctions += functions.length;
 60 | 	}
 61 | 	if (lines) {
 62 | 		lineCount = lines.length;
 63 | 		totalLines += lineCount;
 64 | 	}
 65 | 	
 66 | 	var details = lineCount + " line";
 67 | 	if (lineCount != 1) details += "s";
 68 | 	details += " and " + functionCount + " function";
 69 | 	if (functionCount != 1) details += "s";
 70 | 	
 71 | 	output.stub(details);
 72 | 	output.stub("");
 73 | 	
 74 | 	for (var f in functions) {
 75 | 		output.stub(functions[f]);
 76 | 	}
 77 | 	if (functions) return functions.length;
 78 | 	return 0;
 79 | }
 80 | 
 81 | fs.readdir(".", function (err, files) {
 82 | 	if (err) throw err;
 83 | 	for (var f in files) {
 84 | 		var file = files[f];
 85 | 		var suffix = file.substring(file.length-3);
 86 | 		if (suffix == ".js" && !blacklist[file]) {
 87 | 			output.section(file);
 88 | 			compiled += "/* " + file + " */\r\n";
 89 | 			var count = parse(fs.readFileSync(file, {encoding: "binary", flags: "r"}));
 90 | 			output.end();
 91 | 		}
 92 | 	}
 93 | 	
 94 | 	// save cheatsheet
 95 | 	output.section(totalLines + " lines and " + totalFunctions + " functions for the entire project. Total filesize: " + totalSize/1000 + "kb");
 96 | 	output.write();
 97 | 	
 98 | 	// save compiled .js file
 99 | 	fs.writeFile("release\\compiled.js", compiled, function (err) {
100 | 		if (err) throw err;
101 | 		console.log("compiled successfully\n");
102 | 	});
103 | });
104 | 


--------------------------------------------------------------------------------
/space/dev.js:
--------------------------------------------------------------------------------
 1 | function TextSprite(text, style, font, x, y) {
 2 | 	if (style === undefined) style = "white";
 3 | 	if (font === undefined) font = "32px lucida console";
 4 | 	if (x === undefined) x = 0;
 5 | 	if (y === undefined) y = 0;
 6 | 	
 7 | 	var t = {"x": x, "y": y};
 8 | 	var bitmap;
 9 | 	var size;
10 | 	var texture = gl.createTexture();
11 | 	var mesh = BufferMesh(SQUARE_MESH);
12 | 	
13 | 	
14 | 	context.clearRect(0, 0, canvas2D.width, canvas2D.height);
15 | 	context.fillStyle = style;
16 | 	context.font = font;
17 | 	context.textBaseline = "top";
18 | 	context.fillText(text, 0, 0);
19 | 	size = context.measureText(text);
20 | 	var width = 1; while (width < size.width) width *= 2;
21 | 	bitmap = context.getImageData(0, 0, width, width);
22 | 	StoreTexture(texture, bitmap);
23 | 	
24 | 	var identity = Mat4List(Matrix4());
25 | 	var screen = Matrix4();
26 | 	screen = Mat4Mult(screen, Mat4Translate([1, -1, 0]));
27 | 	screen = Mat4Mult(screen, Mat4Scale(width/2, width/2, 1));
28 | 	screen = Mat4Mult(screen, Mat4Translate([-canvas.width/2, -canvas.height/2, 0]));
29 | 	screen = Mat4Mult(screen, Mat4Scale(2/canvas.width, 2/canvas.height, 1));
30 | 	screen = Mat4List(screen);
31 | 	
32 | 	t.render = function (mtx) {
33 | 		// set up texture shader
34 | 		TEX_SHADER.enable();
35 | 		
36 | 		// orthogonal
37 | 		gl.uniformMatrix4fv(TEX_SHADER.pMatrix, false, identity);
38 | 		gl.uniformMatrix4fv(TEX_SHADER.vMatrix, false, screen);
39 | 		
40 | 		// blending for transparency
41 | 		gl.enable(gl.BLEND);
42 | 		gl.blendFunc(gl.SRC_ALPHA, gl.ONE);
43 | 		gl.depthMask(false);
44 | 		
45 | 		// bind texture
46 | 		gl.activeTexture(gl.TEXTURE0);
47 | 		gl.bindTexture(gl.TEXTURE_2D, texture);
48 | 		gl.uniform1i(TEX_SHADER.samplerUniform, 0);
49 | 		DrawMesh(mesh, Mat4List(Mat4Translate([2*t.x/width, 2*(canvas.height - t.y)/width, 0])), TEX_SHADER);
50 | 		
51 | 		gl.disable(gl.BLEND);
52 | 		gl.depthMask(true);	
53 | 		
54 | 		// draw
55 | 		gl.uniformMatrix4fv(TEX_SHADER.pMatrix, false, pMatrix);
56 | 		gl.uniformMatrix4fv(TEX_SHADER.vMatrix, false, vMatrix);
57 | 		TEX_SHADER.disable();
58 | 		STD_SHADER.enable();
59 | 	}
60 | 	return t;
61 | }
62 | 


--------------------------------------------------------------------------------
/space/lab/advanced.html:
--------------------------------------------------------------------------------
  1 | <html>
  2 | 	<head>
  3 | 		<title>Tunnel Vision</title>
  4 | 		<script>
  5 | var a = !1, m, p, q, r = [];
  6 | function t() { return[1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1] }
  7 | var u = t(), v = t(), w = t();
  8 | u[10] = -1;
  9 | var y, z;
 10 | window.j = window.requestAnimationFrame || window.webkitRequestAnimationFrame || window.mozRequestAnimationFrame || window.oRequestAnimationFrame || window.msRequestAnimationFrame || function(e) {
 11 |   window.setTimeout(e, 1E3 / 30)
 12 | };
 13 | function A() {
 14 |   m.clear(m.COLOR_BUFFER_BIT | m.DEPTH_BUFFER_BIT);
 15 |   for(ent in r) {
 16 |     r[ent].f && r[ent].f(v)
 17 |   }
 18 |   y = z;
 19 |   z = (new Date).getTime();
 20 |   var e = (z - y) / 1E3;
 21 |   1 < e && (e = 1);
 22 |   for(ent in r) {
 23 |     r[ent].update && r[ent].update(e)
 24 |   }
 25 |   window.j(A, p);  
 26 | }
 27 | function B(e, n, g, l, b, f) {
 28 |   e.e = e.e.concat(n[g][l]);
 29 |   void 0 === b || void 0 === f ? (e.a.push(g / n.length), e.a.push(l / n[0].length)) : (e.a.push(b / n.length), e.a.push(f / n[0].length))
 30 | }
 31 | function C() {
 32 |   function e(b) {
 33 |     return[Math.sin(8 * b * Math.PI), 80 * b, Math.cos(8 * b * Math.PI)]
 34 |   }
 35 |   for(var n = {}, g = q.createImageData(64, 64), l = m.createTexture(), b = [], f = [], c = 0;20 > c;c++) {
 36 |     b.push([]);
 37 |     f.push([]);
 38 |     for(var d = 0;100 > d;d++) {
 39 |       var h;
 40 |       h = 2 * d / 100 * Math.PI - Math.PI;
 41 |       h = [Math.cos(h), 0, Math.sin(h)];
 42 |       var x = e(c / 20);
 43 |       h = [h[0] + x[0], h[1] + x[1], h[2] + x[2]];
 44 |       f[c][d] = h;
 45 |       b[c][d] = h
 46 |     }
 47 |   }
 48 |   f = {count:3800, e:[], n:[], a:[]};
 49 |   for(c = 0;19 > c;c++) {
 50 |     for(d = 0;100 > d;d++) {
 51 |       B(f, b, c, d), B(f, b, c + 1, d), B(f, b, c, (d + 1) % 100, c, d + 1), B(f, b, c, (d + 1) % 100, c, d + 1), B(f, b, c + 1, d), B(f, b, c + 1, (d + 1) % 100, c + 1, d + 1)
 52 |     }
 53 |   }
 54 |   b = tunnelMesh = f;
 55 |   c = [15, 0, 0, 1, 0, 0];
 56 |   for(d = 0;d < b.a.length;d += 2) {
 57 |     f = b.a[d], h = b.a[d + 1], b.a[d] = c[0] * f + c[1] * h + c[2], b.a[d + 1] = c[3] * f + c[4] * h + c[5]
 58 |   }
 59 |   var k = tunnelMesh;
 60 |   k.buffered || (k.h = m.createBuffer(), m.bindBuffer(m.ARRAY_BUFFER, k.h), m.bufferData(m.ARRAY_BUFFER, new Float32Array(k.e), m.STATIC_DRAW), k.a && (k.d = m.createBuffer(), m.bindBuffer(m.ARRAY_BUFFER, k.d), m.bufferData(m.ARRAY_BUFFER, new Float32Array(k.a), m.STATIC_DRAW)), k.buffered = !0);
 61 |   for(b = 0;64 > b;b++) {
 62 |     for(c = 0;64 > c;c++) {
 63 |       g.data[4 * (c + 64 * b) + 0] = 128 * Math.sin(c / 5 + Math.PI / 1.5) + 127, g.data[4 * (c + 64 * b) + 1] = 128 * Math.sin(c / 5) + 127, g.data[4 * (c + 64 * b) + 2] = 128 * Math.sin(c / 5 - Math.PI / 1.5) + 127, g.data[4 * (c + 64 * b) + 3] = 255
 64 |     }
 65 |   }
 66 |   m.pixelStorei(m.UNPACK_FLIP_Y_WEBGL, !0);
 67 |   m.bindTexture(m.TEXTURE_2D, l);
 68 |   m.texImage2D(m.TEXTURE_2D, 0, m.RGBA, m.RGBA, m.UNSIGNED_BYTE, g);
 69 |   m.texParameteri(m.TEXTURE_2D, m.TEXTURE_MAG_FILTER, m.LINEAR);
 70 |   m.texParameteri(m.TEXTURE_2D, m.TEXTURE_MIN_FILTER, m.LINEAR);
 71 |   m.bindTexture(m.TEXTURE_2D, null);
 72 |   var s = 6;
 73 |   n.update = function(b) {
 74 |     s -= b
 75 |   };
 76 |   n.f = function(b) {
 77 |     b = s / 10;
 78 |     1 > s && (s += 5);
 79 |     b = e(b);
 80 |     var c = [0, 0, 0];
 81 |     b = [c[0] - b[0], c[1] - b[1], c[2] - b[2]];
 82 |     b = [1, 0, 0, 0, 0, 0, 1, 0, 0, -1, 0, 0, b[0], -b[2], b[1], 1];
 83 |     TEX_SHADER.enable();
 84 |     m.uniformMatrix4fv(TEX_SHADER.i, a, w);
 85 |     m.uniformMatrix4fv(TEX_SHADER.g, a, u);
 86 |     m.activeTexture(m.TEXTURE0);
 87 |     m.bindTexture(m.TEXTURE_2D, l);
 88 |     m.uniform1i(TEX_SHADER.p, 0);
 89 |     c = TEX_SHADER;
 90 |     m.bindBuffer(m.ARRAY_BUFFER, k.h);
 91 |     m.vertexAttribPointer(c.c, 3, m.FLOAT, a, 0, 0);
 92 |     k.d && void 0 !== c.b && (m.bindBuffer(m.ARRAY_BUFFER, k.d), m.vertexAttribPointer(c.b, 2, m.FLOAT, a, 0, 0));
 93 |     m.uniformMatrix4fv(c.m, a, b);
 94 |     m.drawArrays(m.TRIANGLES, 0, 3 * k.count);
 95 |     m.uniformMatrix4fv(TEX_SHADER.g, a, u);
 96 |     TEX_SHADER.disable()
 97 |   };
 98 |   return n
 99 | }
100 | function run() {
101 |   p = document.getElementById("game");
102 |   p.width = document.body.clientWidth;
103 |   p.height = document.body.clientHeight;
104 |   try {
105 |     m = p.getContext("webgl") || p.getContext("experimental-webgl") || p.getContext("webkit-3d") || p.getContext("moz-webgl"), m.l = p.width, m.k = p.height
106 |   }catch(e) {
107 |   }
108 |   m || alert("Sorry, WebGL not supported.");
109 |   try {
110 |     q = document.getElementById("2D").getContext("2d")
111 |   }catch(n) {
112 |   }
113 |   q || alert("Could not bind 2D context.");
114 |   a: {
115 |     var g = m.createShader(m.FRAGMENT_SHADER), l = m.createShader(m.VERTEX_SHADER);
116 |     m.shaderSource(g, "#ifdef GL_ES\nprecision highp float;\n#endif\nuniform sampler2D uTexture;\nvarying vec2 vTexCoord;\nvoid main(void)\n{\ngl_FragColor = texture2D(uTexture, vTexCoord);\n}\n");
117 |     m.compileShader(g);
118 |     if(m.getShaderParameter(g, m.COMPILE_STATUS)) {
119 |       if(m.shaderSource(l, "attribute vec3 aVertPos;\nattribute vec2 aTexCoord;\nuniform mat4 uWMatrix;\nuniform mat4 uVMatrix;\nuniform mat4 uPMatrix;\nvarying vec2 vTexCoord;\nvoid main(void) {\ngl_Position = uPMatrix * uVMatrix * uWMatrix * vec4(aVertPos, 1.0);\nvTexCoord = aTexCoord;\n}\n"), m.compileShader(l), m.getShaderParameter(l, m.COMPILE_STATUS)) {
120 |         var b = m.createProgram();
121 |         m.attachShader(b, g);
122 |         m.attachShader(b, l);
123 |         m.linkProgram(b);
124 |         if(m.getProgramParameter(b, m.LINK_STATUS)) {
125 |           m.useProgram(b);
126 |           b.c = m.getAttribLocation(b, "aVertPos");
127 |           m.enableVertexAttribArray(b.c);
128 |           b.b = m.getAttribLocation(b, "aTexCoord");
129 |           m.enableVertexAttribArray(b.b);
130 |           b.m = m.getUniformLocation(b, "uWMatrix");
131 |           b.g = m.getUniformLocation(b, "uVMatrix");
132 |           b.i = m.getUniformLocation(b, "uPMatrix");
133 |           b.enable = function() {
134 |             m.enableVertexAttribArray(b.c);
135 |             m.enableVertexAttribArray(b.b);
136 |             m.useProgram(b)
137 |           };
138 |           b.disable = function() {
139 |             m.disableVertexAttribArray(b.c);
140 |             m.disableVertexAttribArray(b.b)
141 |           };
142 |           b.disable();
143 |           TEX_SHADER = b;
144 |           break a
145 |         }
146 |         alert("Error: Could not initialize texture shader.")
147 |       }else {
148 |         alert(m.getShaderInfoLog(l))
149 |       }
150 |     }else {
151 |       alert(m.getShaderInfoLog(g))
152 |     }
153 |     TEX_SHADER = void 0
154 |   }
155 |   m.clearColor(0, 0, 0, 1);
156 |   m.enable(m.DEPTH_TEST);
157 |   m.viewport(0, 0, m.l, m.k);
158 |   w = [1.1, 0, 0, 0, 0, 1.9, 0, 0, 0, 0, -1, -1, 0, 0, -0.6, 0];
159 |   r.push(C());
160 |   z = (new Date).getTime();
161 |   A()
162 | };
163 | 		</script>
164 | 		<style>
165 | 			#game {
166 | 				position: absolute;
167 | 				top: 0;
168 | 				left: 0;
169 | 				border: none;
170 | 			}
171 | 		</style>
172 | 	</head>
173 | 	<body onload="run();">
174 | 		<canvas id="game" width="100%" height="100%">
175 | 		</canvas>
176 | 		<canvas id="2D" style="display: none;">
177 | 	</body>
178 | </html>
179 | 


--------------------------------------------------------------------------------
/space/lab/dev.js:
--------------------------------------------------------------------------------
 1 | function TextSprite(text, style, font, x, y) {
 2 | 	if (style === undefined) style = "white";
 3 | 	if (font === undefined) font = "32px lucida console";
 4 | 	if (x === undefined) x = 0;
 5 | 	if (y === undefined) y = 0;
 6 | 	
 7 | 	var t = {"x": x, "y": y};
 8 | 	var bitmap;
 9 | 	var size;
10 | 	var texture = gl.createTexture();
11 | 	var mesh = BufferMesh(SQUARE_MESH);
12 | 	
13 | 	
14 | 	context.clearRect(0, 0, canvas2D.width, canvas2D.height);
15 | 	context.fillStyle = style;
16 | 	context.font = font;
17 | 	context.textBaseline = "top";
18 | 	context.fillText(text, 0, 0);
19 | 	size = context.measureText(text);
20 | 	var width = 1; while (width < size.width) width *= 2;
21 | 	bitmap = context.getImageData(0, 0, width, width);
22 | 	StoreTexture(texture, bitmap);
23 | 	
24 | 	var identity = Mat4List(Matrix4());
25 | 	var screen = Matrix4();
26 | 	screen = Mat4Mult(screen, Mat4Translate([1, -1, 0]));
27 | 	screen = Mat4Mult(screen, Mat4Scale(width/2, width/2, 1));
28 | 	screen = Mat4Mult(screen, Mat4Translate([-canvas.width/2, -canvas.height/2, 0]));
29 | 	screen = Mat4Mult(screen, Mat4Scale(2/canvas.width, 2/canvas.height, 1));
30 | 	screen = Mat4List(screen);
31 | 	
32 | 	t.render = function (mtx) {
33 | 		// set up texture shader
34 | 		TEX_SHADER.enable();
35 | 		
36 | 		// orthogonal
37 | 		gl.uniformMatrix4fv(TEX_SHADER.pMatrix, false, identity);
38 | 		gl.uniformMatrix4fv(TEX_SHADER.vMatrix, false, screen);
39 | 		
40 | 		// blending for transparency
41 | 		gl.enable(gl.BLEND);
42 | 		gl.blendFunc(gl.SRC_ALPHA, gl.ONE);
43 | 		gl.depthMask(false);
44 | 		
45 | 		// bind texture
46 | 		gl.activeTexture(gl.TEXTURE0);
47 | 		gl.bindTexture(gl.TEXTURE_2D, texture);
48 | 		gl.uniform1i(TEX_SHADER.samplerUniform, 0);
49 | 		DrawMesh(mesh, Mat4List(Mat4Translate([2*t.x/width, 2*(canvas.height - t.y)/width, 0])), TEX_SHADER);
50 | 		
51 | 		gl.disable(gl.BLEND);
52 | 		gl.depthMask(true);	
53 | 		
54 | 		// draw
55 | 		gl.uniformMatrix4fv(TEX_SHADER.pMatrix, false, pMatrix);
56 | 		gl.uniformMatrix4fv(TEX_SHADER.vMatrix, false, vMatrix);
57 | 		TEX_SHADER.disable();
58 | 		STD_SHADER.enable();
59 | 	}
60 | 	return t;
61 | }
62 | 


--------------------------------------------------------------------------------
/space/lab/index.html:
--------------------------------------------------------------------------------
 1 | <html>
 2 | 	<head>
 3 | 		<title>Research</title>
 4 | 		<script src="glMatrix-0.9.5.min.js"></script>
 5 | 		<script src="tedge.js"></script>
 6 | 		<script src="shaders.js"></script>
 7 |         <script src="physics.js"></script>
 8 | 		<script src="meshes.js"></script>
 9 | 		<script src="game.js"></script>
10 | 		<script src="dev.js"></script>
11 | 		</script>
12 | 		<style>
13 | 			#game {
14 | 				position: absolute;
15 | 				top: 0;
16 | 				left: 0;
17 | 				border: none;
18 | 			}
19 | 		</style>
20 | 	</head>
21 | 	<body onload="run();">
22 | 		<canvas id="game" width="100%" height="100%">
23 | 		</canvas>
24 | 		<canvas id="2D" style="display: none;">
25 | 	</body>
26 | </html>


--------------------------------------------------------------------------------
/space/lab/meshes.js:
--------------------------------------------------------------------------------
1 | // Meshes
2 | BOX_MESH = {"count":12,"vertices":[0,1,1,0,0,1,1,1,1,0,0,1,1,0,1,1,1,1,1,1,1,1,0,1,1,1,0,1,0,1,1,0,0,1,1,0,1,1,0,1,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,1,0,1,1,0,1,0,0,1,1,1,1,0,0,1,1,1,1,1,1,1,0,0,0,1,0,0,0,1,0,1,0,0,0,1,0,0,1,0,1],"uvs":[0,0,0,1,1,0,0,1,1,1,1,0,0,0,0,1,1,0,0,1,1,1,1,0,0,0,0,1,1,0,0,1,1,1,1,0,0,0,0,1,1,0,0,1,1,1,1,0,0,0,0,1,1,0,0,1,1,1,1,0,0,0,0,1,1,0,0,1,1,1,1,0],"normals":[0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0]};
3 | 
4 | SQUARE_MESH = {"count":2,"vertices":[-1,-1,0,1,-1,0,-1,1,0,-1,1,0,1,-1,0,1,1,0],"uvs":[0,0,1,0,0,1,0,1,1,0,1,1]};
5 | 


--------------------------------------------------------------------------------
/space/lab/noise.txt:
--------------------------------------------------------------------------------
  1 | 2 bit expanded
  2 | function NoiseSampler(density, seed)
  3 | {
  4 | 	var primes = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41];
  5 | 	var p1, p2;
  6 | 	var j = 13; var k = seed;
  7 | 	j = (2*j + k)%256;
  8 | 	k = (k*primes[j%primes.length] + k)%256;
  9 | 	p1 = (j+k)%256;
 10 | 	j = (3*j + k)%256;
 11 | 	k = (k*primes[j%primes.length] + k)%256;
 12 | 	p2 = (j+k)%256;
 13 | 	
 14 | 	return function (x, y) {
 15 | 		var q = 0;
 16 | 		
 17 | 		for (var d = 1; d <= density; d++) {
 18 | 			var r = 1;
 19 | 			x = x/d; y = y/d;
 20 | 			//x = Math.floor(x/d) * d;
 21 | 			//y = Math.floor(y/d) * d;
 22 | 			r += (r%p1) * (x + p1) * (y + p1);
 23 | 			r += (r%p2) * (x + p2) * (y + p2);
 24 | 			
 25 | 			q += (r%256)/density;
 26 | 		}
 27 | 		return Math.floor(q)%256;
 28 | 	};
 29 | }
 30 | 
 31 | full form
 32 | function NoiseSampler(density, seed)
 33 | {
 34 | 	var primes = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41];
 35 | 	var stream = [];
 36 | 	var j = 13; var k = seed;
 37 | 	for (var i = 0; i < 25; i++) {
 38 | 		j = (j*primes[i%primes.length] + k)%256;
 39 | 		k = (k*primes[j%primes.length] + k)%256;
 40 | 		stream.push((j+k)%256);
 41 | 	}
 42 | 	
 43 | 	return function (x, y) {
 44 | 		var q = 0;
 45 | 		
 46 | 		for (var d = 1; d <= density; d++) {
 47 | 			var r = 1;
 48 | 			x = x/d; y = y/d;
 49 | 			//x = Math.floor(x/d) * d;
 50 | 			//y = Math.floor(y/d) * d;			
 51 | 			for (var i = 0; i < stream.length; i++) {
 52 | 				r += (r%stream[i]) * (x + stream[i]) * (y + stream[i]);
 53 | 			}
 54 | 			q += (r%256)/density;
 55 | 		}
 56 | 		return Math.floor(q)%256;
 57 | 	};
 58 | }
 59 | 
 60 | grid blur hm
 61 | function NoiseSampler(density, seed)
 62 | {
 63 | 	var primes = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41];
 64 | 	var stream = [];
 65 | 	var j = 13; var k = seed;
 66 | 	for (var i = 0; i < 2; i++) {
 67 | 		j = (j*primes[i%primes.length] + k)%256;
 68 | 		k = (k*primes[j%primes.length] + k)%256;
 69 | 		stream.push((j+k)%256);
 70 | 	}
 71 | 	
 72 | 	return function (x, y) {
 73 | 		var q = 0;
 74 | 		for (var d = 0; d < density; d++) {
 75 | 			var r = 0; var n2 = (2*d+1)*(2*d+1);
 76 | 			for (dx = -d; dx <= d; dx++) {
 77 | 				for (dy = -d; dy <= d; dy++) {
 78 | 					var s = 1;
 79 | 					var xx = x + dx; var yy = y + dy;
 80 | 					for (var i = 0; i < stream.length; i++) {
 81 | 						s += (s%stream[i]) * (xx + stream[i]) * (yy + stream[i]);
 82 | 					}
 83 | 					r += (s%256)/(n2);
 84 | 				}
 85 | 			}
 86 | 			q += (r%256)/density;
 87 | 		}
 88 | 		return Math.floor(q)%256;
 89 | 	};
 90 | }
 91 | 
 92 | // inputs [0, 1], [0, 1]
 93 | // 0..255
 94 | function NoiseSampler(density, seed)
 95 | {
 96 | 	var primes = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41];
 97 | 	var p1, p2, p3;
 98 | 	var j = 13; var k = seed;
 99 | 	j = (2*j + k)%256;
100 | 	k = (k*primes[j%primes.length] + k)%256;
101 | 	p1 = j + k;
102 | 	j = (3*j + k + seed)%256;
103 | 	k = (k*primes[j%primes.length] + k)%256;
104 | 	p2 = j + k;
105 | 	j = (5*j + k + 1)%256;
106 | 	k = (k*primes[j%primes.length] + k)%256;
107 | 	p3 = j + k;
108 | 	
109 | 	function r(x, y) {
110 | 		var r1 = 1 + x*y + x*p1 + y*p1 + p1*p1 + y;
111 | 		var r2 = r1 + (r1%p2) * (x + x*p2 + y*p2 + p2*p2);
112 | 		var r3 = r2 + (r2%p3) * (p2 + x*p3 + y*p3 + p3*p3);
113 | 		return r3%256;
114 | 	}
115 | 	
116 | 	function rdx(y) {
117 | 		// r3dx
118 | 		return ((1 + y + p1) + ((1 + y + p1)%p2) * (1 + p2) 
119 | 			+ (((1 + y + p1) + ((1 + y + p1)%p2) * (1 + p2))%p3)*p3)%256;
120 | 	}
121 | 	
122 | 	function rdy(x) {
123 | 		// r3dy
124 | 		return ((x + p1 + 1) + ((x + p1 + 1)%p2)*p2 
125 | 		+ (((x + p1 + 1) + ((x + p1 + 1)%p2)*p2)%p3)*p3)%256;
126 | 	}
127 | 	
128 | 	function rdxdy(x, y) {	
129 | 		// r3' dx dy
130 | 		return ((y + x + 2*p1 + 1) 
131 | 			+ ((y + x + 2*p1 + 1)%p2) * (1 + 2*p2)
132 | 			+ (((y + x + 2*p1 + 1) + ((y + x + 2*p1 + 1)%p2) * (1 + 2*p2))%p3)*2*p3)%256;
133 | 	}
134 | 	
135 | 	return function(x,y) {
136 | 		var dx = x - Math.floor(x);
137 | 		var dy = y - Math.floor(y);
138 | 		x -= dx; y -= dy;
139 | 		
140 | 		return r(x,y) * (1 - dx) * (1 - dy)
141 | 			//+ r(x+1, y) * dx * (1 - dy)
142 | 			//+ r(x, y+1) * (1 - dx) * dy
143 | 			//+ r(x+1, y+1) * dx * dy
144 | 			+ rdx(y)*dx*(1-dy) + rdy(x)*dy*(1-dx) + rdxdy(x,y)*dx*dy;
145 | 	};
146 | }
147 | 


--------------------------------------------------------------------------------
/space/lab/print.html:
--------------------------------------------------------------------------------
  1 | <html>
  2 | 	<head>
  3 | 		<title>Tunnel Vision</title>
  4 | 		<script>
  5 | var a = !1, m, p, q, r = []; FRAMES = 40; frame = 0; buffers = []; SIZE = 256;
  6 | function t() { return[1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1] }
  7 | var u = t(), v = t(), w = t();
  8 | u[10] = -1;
  9 | var y, z;
 10 | window.j = window.requestAnimationFrame || window.webkitRequestAnimationFrame || window.mozRequestAnimationFrame || window.oRequestAnimationFrame || window.msRequestAnimationFrame || function(e) {
 11 |   window.setTimeout(e, 1E3 / 30)
 12 | };
 13 | function A() {
 14 |   m.clear(m.COLOR_BUFFER_BIT | m.DEPTH_BUFFER_BIT);
 15 |   for(ent in r) {
 16 |     r[ent].f && r[ent].f(v)
 17 |   }
 18 |   y = z;
 19 |   z = (new Date).getTime();
 20 |   var e = (z - y) / 1E3;
 21 |   1 < e && (e = 1);
 22 |   for(ent in r) {
 23 |     r[ent].update && r[ent].update(e)
 24 |   }
 25 |   context.drawImage(p, 0, 0);
 26 |   buffers.push(context.getImageData(0, 0, SIZE, SIZE));
 27 |   frame++;
 28 |   if (frame < FRAMES) window.j(A, p);
 29 |   else print();
 30 | }
 31 | function B(e, n, g, l, b, f) {
 32 |   e.e = e.e.concat(n[g][l]);
 33 |   void 0 === b || void 0 === f ? (e.a.push(g / n.length), e.a.push(l / n[0].length)) : (e.a.push(b / n.length), e.a.push(f / n[0].length))
 34 | }
 35 | function C() {
 36 |   function e(b) {
 37 |     return[Math.sin(8 * b * Math.PI), 80 * b, Math.cos(8 * b * Math.PI)]
 38 |   }
 39 |   for(var n = {}, g = q.createImageData(64, 64), l = m.createTexture(), b = [], f = [], c = 0;20 > c;c++) {
 40 |     b.push([]);
 41 |     f.push([]);
 42 |     for(var d = 0;100 > d;d++) {
 43 |       var h;
 44 |       h = 2 * d / 100 * Math.PI - Math.PI;
 45 |       h = [Math.cos(h), 0, Math.sin(h)];
 46 |       var x = e(c / 20);
 47 |       h = [h[0] + x[0], h[1] + x[1], h[2] + x[2]];
 48 |       f[c][d] = h;
 49 |       b[c][d] = h
 50 |     }
 51 |   }
 52 |   f = {count:3800, e:[], n:[], a:[]};
 53 |   for(c = 0;19 > c;c++) {
 54 |     for(d = 0;100 > d;d++) {
 55 |       B(f, b, c, d), B(f, b, c + 1, d), B(f, b, c, (d + 1) % 100, c, d + 1), B(f, b, c, (d + 1) % 100, c, d + 1), B(f, b, c + 1, d), B(f, b, c + 1, (d + 1) % 100, c + 1, d + 1)
 56 |     }
 57 |   }
 58 |   b = tunnelMesh = f;
 59 |   c = [15, 0, 0, 1, 0, 0];
 60 |   for(d = 0;d < b.a.length;d += 2) {
 61 |     f = b.a[d], h = b.a[d + 1], b.a[d] = c[0] * f + c[1] * h + c[2], b.a[d + 1] = c[3] * f + c[4] * h + c[5]
 62 |   }
 63 |   var k = tunnelMesh;
 64 |   k.buffered || (k.h = m.createBuffer(), m.bindBuffer(m.ARRAY_BUFFER, k.h), m.bufferData(m.ARRAY_BUFFER, new Float32Array(k.e), m.STATIC_DRAW), k.a && (k.d = m.createBuffer(), m.bindBuffer(m.ARRAY_BUFFER, k.d), m.bufferData(m.ARRAY_BUFFER, new Float32Array(k.a), m.STATIC_DRAW)), k.buffered = !0);
 65 |   for(b = 0;64 > b;b++) {
 66 |     for(c = 0;64 > c;c++) {
 67 |       g.data[4 * (c + 64 * b) + 0] = 128 * Math.sin(c / 5 + Math.PI / 1.5) + 127, g.data[4 * (c + 64 * b) + 1] = 128 * Math.sin(c / 5) + 127, g.data[4 * (c + 64 * b) + 2] = 128 * Math.sin(c / 5 - Math.PI / 1.5) + 127, g.data[4 * (c + 64 * b) + 3] = 255
 68 |     }
 69 |   }
 70 |   m.pixelStorei(m.UNPACK_FLIP_Y_WEBGL, !0);
 71 |   m.bindTexture(m.TEXTURE_2D, l);
 72 |   m.texImage2D(m.TEXTURE_2D, 0, m.RGBA, m.RGBA, m.UNSIGNED_BYTE, g);
 73 |   m.texParameteri(m.TEXTURE_2D, m.TEXTURE_MAG_FILTER, m.LINEAR);
 74 |   m.texParameteri(m.TEXTURE_2D, m.TEXTURE_MIN_FILTER, m.LINEAR);
 75 |   m.bindTexture(m.TEXTURE_2D, null);
 76 |   var s = 6;
 77 |   n.update = function(b) {
 78 |     s -= 5.0/FRAMES;
 79 |   };
 80 |   n.f = function(b) {
 81 |     b = s / 10;
 82 |     1 > s && (s += 5);
 83 |     b = e(b);
 84 |     var c = [0, 0, 0];
 85 |     b = [c[0] - b[0], c[1] - b[1], c[2] - b[2]];
 86 |     b = [1, 0, 0, 0, 0, 0, 1, 0, 0, -1, 0, 0, b[0], -b[2], b[1], 1];
 87 |     TEX_SHADER.enable();
 88 |     m.uniformMatrix4fv(TEX_SHADER.i, a, w);
 89 |     m.uniformMatrix4fv(TEX_SHADER.g, a, u);
 90 |     m.activeTexture(m.TEXTURE0);
 91 |     m.bindTexture(m.TEXTURE_2D, l);
 92 |     m.uniform1i(TEX_SHADER.p, 0);
 93 |     c = TEX_SHADER;
 94 |     m.bindBuffer(m.ARRAY_BUFFER, k.h);
 95 |     m.vertexAttribPointer(c.c, 3, m.FLOAT, a, 0, 0);
 96 |     k.d && void 0 !== c.b && (m.bindBuffer(m.ARRAY_BUFFER, k.d), m.vertexAttribPointer(c.b, 2, m.FLOAT, a, 0, 0));
 97 |     m.uniformMatrix4fv(c.m, a, b);
 98 |     m.drawArrays(m.TRIANGLES, 0, 3 * k.count);
 99 |     m.uniformMatrix4fv(TEX_SHADER.g, a, u);
100 |     TEX_SHADER.disable()
101 |   };
102 |   return n
103 | }
104 | function run() {
105 |   p = document.getElementById("game");
106 |   p.width = SIZE;
107 |   p.height = SIZE;
108 |   flags = {preserveDrawingBuffer: true};
109 |   canvas = document.getElementById("2D");
110 |   canvas.width = SIZE;
111 |   canvas.height = SIZE;
112 |   context = canvas.getContext("2d");
113 |   try {
114 |     m = p.getContext("webgl", flags) || p.getContext("experimental-webgl", flags) || p.getContext("webkit-3d", flags) || p.getContext("moz-webgl", flags), m.l = p.width, m.k = p.height
115 |   }catch(e) {
116 |   }
117 |   m || alert("Sorry, WebGL not supported.");
118 |   try {
119 |     q = document.getElementById("2D").getContext("2d")
120 |   }catch(n) {
121 |   }
122 |   q || alert("Could not bind 2D context.");
123 |   a: {
124 |     var g = m.createShader(m.FRAGMENT_SHADER), l = m.createShader(m.VERTEX_SHADER);
125 |     m.shaderSource(g, "#ifdef GL_ES\nprecision highp float;\n#endif\nuniform sampler2D uTexture;\nvarying vec2 vTexCoord;\nvoid main(void)\n{\ngl_FragColor = texture2D(uTexture, vTexCoord);\n}\n");
126 |     m.compileShader(g);
127 |     if(m.getShaderParameter(g, m.COMPILE_STATUS)) {
128 |       if(m.shaderSource(l, "attribute vec3 aVertPos;\nattribute vec2 aTexCoord;\nuniform mat4 uWMatrix;\nuniform mat4 uVMatrix;\nuniform mat4 uPMatrix;\nvarying vec2 vTexCoord;\nvoid main(void) {\ngl_Position = uPMatrix * uVMatrix * uWMatrix * vec4(aVertPos, 1.0);\nvTexCoord = aTexCoord;\n}\n"), m.compileShader(l), m.getShaderParameter(l, m.COMPILE_STATUS)) {
129 |         var b = m.createProgram();
130 |         m.attachShader(b, g);
131 |         m.attachShader(b, l);
132 |         m.linkProgram(b);
133 |         if(m.getProgramParameter(b, m.LINK_STATUS)) {
134 |           m.useProgram(b);
135 |           b.c = m.getAttribLocation(b, "aVertPos");
136 |           m.enableVertexAttribArray(b.c);
137 |           b.b = m.getAttribLocation(b, "aTexCoord");
138 |           m.enableVertexAttribArray(b.b);
139 |           b.m = m.getUniformLocation(b, "uWMatrix");
140 |           b.g = m.getUniformLocation(b, "uVMatrix");
141 |           b.i = m.getUniformLocation(b, "uPMatrix");
142 |           b.enable = function() {
143 |             m.enableVertexAttribArray(b.c);
144 |             m.enableVertexAttribArray(b.b);
145 |             m.useProgram(b)
146 |           };
147 |           b.disable = function() {
148 |             m.disableVertexAttribArray(b.c);
149 |             m.disableVertexAttribArray(b.b)
150 |           };
151 |           b.disable();
152 |           TEX_SHADER = b;
153 |           break a
154 |         }
155 |         alert("Error: Could not initialize texture shader.")
156 |       }else {
157 |         alert(m.getShaderInfoLog(l))
158 |       }
159 |     }else {
160 |       alert(m.getShaderInfoLog(g))
161 |     }
162 |     TEX_SHADER = void 0
163 |   }
164 |   m.clearColor(0, 0, 0, 1);
165 |   m.enable(m.DEPTH_TEST);
166 |   m.viewport(0, 0, m.l, m.k);
167 |   w = [1.1, 0, 0, 0, 0, 1.9, 0, 0, 0, 0, -1, -1, 0, 0, -0.6, 0];
168 |   r.push(C());
169 |   z = (new Date).getTime();
170 |   A()
171 | };
172 | function print() {
173 | 	frame = 0;
174 | 	while (frame < FRAMES) {
175 | 		context.putImageData(buffers[frame], 0, 0);
176 | 		var img = canvas.toDataURL("image/png");
177 | 		document.write('<img src="'+img+'"/>');
178 | 		frame++;
179 | 	}
180 | }
181 | 		</script>
182 | 		<style>
183 | 			#game {
184 | 				position: absolute;
185 | 				top: 0;
186 | 				left: 0;
187 | 				border: none;
188 | 			}
189 | 		</style>
190 | 	</head>
191 | 	<body onload="run();">
192 | 		<canvas id="game" width="100%" height="100%">
193 | 		</canvas>
194 | 		<canvas id="2D" style="display: none;">
195 | 	</body>
196 | </html>
197 | 


--------------------------------------------------------------------------------
/space/lab/shaders.js:
--------------------------------------------------------------------------------
  1 | // SHADERS: //////////////////////////////////////////
  2 | 
  3 | var STD_PIXEL_SHADER = 
  4 | "#ifdef GL_ES\n" +
  5 | "precision highp float;\n" +
  6 | "#endif\n" +
  7 | "varying vec4 vColor;\n" +
  8 | "varying vec3 vLighting;\n"+
  9 | "void main(void)\n" +
 10 | "{\n" +
 11 | "gl_FragColor = ((dot(vLighting, vLighting) * 0.5) + (dot(vLighting, vec3(-0.4, 0.4, -0.4)) * 0.7)) * vColor;\n" +
 12 | "gl_FragColor = vec4(vec3(gl_FragColor), 1.0);\n" + 
 13 | "}\n";
 14 | 
 15 | var STD_VERT_SHADER = 
 16 | "attribute vec3 aVertPos;\n" +
 17 | "attribute vec3 aVertNorm;\n" +
 18 | "attribute vec4 aVertColor;\n" +
 19 | "uniform mat4 uWMatrix;\n" +
 20 | "uniform mat4 uVMatrix;\n" +
 21 | "uniform mat4 uPMatrix;\n" +
 22 | "uniform vec4 uColor;\n" +
 23 | "varying vec4 vColor;\n" +
 24 | "varying vec3 vLighting;\n" +
 25 | "void main(void) {\n" +
 26 | "gl_Position = uPMatrix * uVMatrix * uWMatrix * vec4(aVertPos, 1.0);\n" +
 27 | "vLighting = normalize(aVertPos);\n" +
 28 | "vColor = uColor;\n" +
 29 | "}\n";
 30 | 
 31 | var TEX_PIXEL_SHADER = 
 32 | "#ifdef GL_ES\n" +
 33 | "precision highp float;\n" +
 34 | "#endif\n" +
 35 | "uniform sampler2D uTexture;\n" +
 36 | "varying vec2 vTexCoord;\n" +
 37 | "void main(void)\n" +
 38 | "{\n" +
 39 | "gl_FragColor = texture2D(uTexture, vTexCoord);\n" + 
 40 | "}\n";
 41 | 
 42 | var TEX_VERT_SHADER = 
 43 | "attribute vec3 aVertPos;\n" +
 44 | "attribute vec2 aTexCoord;\n" +
 45 | "uniform mat4 uWMatrix;\n" +
 46 | "uniform mat4 uVMatrix;\n" +
 47 | "uniform mat4 uPMatrix;\n" +
 48 | "varying vec2 vTexCoord;\n" +
 49 | "void main(void) {\n" +
 50 | "gl_Position = uPMatrix * uVMatrix * uWMatrix * vec4(aVertPos, 1.0);\n" +
 51 | "vTexCoord = aTexCoord;\n" +
 52 | "}\n";
 53 | 
 54 | function StandardShader()
 55 | {
 56 | 	var pShader = gl.createShader(gl.FRAGMENT_SHADER);
 57 | 	var vShader = gl.createShader(gl.VERTEX_SHADER);
 58 | 	
 59 | 	gl.shaderSource(pShader, STD_PIXEL_SHADER);
 60 | 	gl.compileShader(pShader);
 61 | 	if (!gl.getShaderParameter(pShader, gl.COMPILE_STATUS))
 62 | 	{
 63 | 		alert(gl.getShaderInfoLog(pShader));
 64 | 		return;
 65 | 	}
 66 | 	
 67 | 	gl.shaderSource(vShader, STD_VERT_SHADER);
 68 | 	gl.compileShader(vShader);
 69 | 	if (!gl.getShaderParameter(vShader, gl.COMPILE_STATUS))
 70 | 	{
 71 | 		alert(gl.getShaderInfoLog(vShader));
 72 | 		return;
 73 | 	}
 74 | 	
 75 | 	var shader = gl.createProgram();
 76 | 	gl.attachShader(shader, pShader);
 77 | 	gl.attachShader(shader, vShader);
 78 | 	gl.linkProgram(shader);
 79 | 	if (!gl.getProgramParameter(shader, gl.LINK_STATUS))
 80 | 	{
 81 | 		alert("Error: Could not initialize standard shader.");
 82 | 		return;
 83 | 	}
 84 | 	
 85 | 	gl.useProgram(shader);
 86 | 	
 87 | 	shader.vertPos = gl.getAttribLocation(shader, "aVertPos");
 88 | 	gl.enableVertexAttribArray(shader.vertPos);
 89 | 	shader.wMatrix = gl.getUniformLocation(shader, "uWMatrix");	
 90 | 	shader.vMatrix = gl.getUniformLocation(shader, "uVMatrix");	
 91 | 	shader.pMatrix = gl.getUniformLocation(shader, "uPMatrix");
 92 | 	
 93 | 	shader.color   = gl.getUniformLocation(shader, "uColor");
 94 | 	shader.setColor = function(r, g, b, a)
 95 | 	{
 96 | 		if (r[0] !== undefined)
 97 | 		{
 98 | 			g = r[1]; b = r[2];
 99 | 			if (r[3] !== undefined)
100 | 				a = r[3];
101 | 			r = r[0];
102 | 		}
103 | 		if (a === undefined)
104 | 			a = 1.0;
105 | 		gl.uniform4f(shader.color, r, g, b, a);
106 | 	}
107 | 	shader.setColor([1.0, 1.0, 1.0]);
108 | 	
109 | 	shader.enable = function () {
110 | 		gl.enableVertexAttribArray(shader.vertPos);
111 | 		gl.useProgram(shader);
112 | 	}
113 | 	shader.disable = function () {
114 | 		gl.disableVertexAttribArray(shader.vertPos);
115 | 	}
116 | 	
117 | 	shader.disable();
118 | 	return shader;
119 | }
120 | 
121 | function TextureShader()
122 | {
123 | 	var pShader = gl.createShader(gl.FRAGMENT_SHADER);
124 | 	var vShader = gl.createShader(gl.VERTEX_SHADER);
125 | 	
126 | 	gl.shaderSource(pShader, TEX_PIXEL_SHADER);
127 | 	gl.compileShader(pShader);
128 | 	if (!gl.getShaderParameter(pShader, gl.COMPILE_STATUS))
129 | 	{
130 | 		alert(gl.getShaderInfoLog(pShader));
131 | 		return;
132 | 	}
133 | 	
134 | 	gl.shaderSource(vShader, TEX_VERT_SHADER);
135 | 	gl.compileShader(vShader);
136 | 	if (!gl.getShaderParameter(vShader, gl.COMPILE_STATUS))
137 | 	{
138 | 		alert(gl.getShaderInfoLog(vShader));
139 | 		return;
140 | 	}
141 | 	
142 | 	var shader = gl.createProgram();
143 | 	gl.attachShader(shader, pShader);
144 | 	gl.attachShader(shader, vShader);
145 | 	gl.linkProgram(shader);
146 | 	if (!gl.getProgramParameter(shader, gl.LINK_STATUS))
147 | 	{
148 | 		alert("Error: Could not initialize texture shader.");
149 | 		return;
150 | 	}
151 | 	
152 | 	gl.useProgram(shader);
153 | 	
154 | 	shader.vertPos = gl.getAttribLocation(shader, "aVertPos");
155 | 	gl.enableVertexAttribArray(shader.vertPos);
156 | 	shader.texCoord = gl.getAttribLocation(shader, "aTexCoord");
157 | 	gl.enableVertexAttribArray(shader.texCoord);
158 | 	shader.wMatrix = gl.getUniformLocation(shader, "uWMatrix");	
159 | 	shader.vMatrix = gl.getUniformLocation(shader, "uVMatrix");	
160 | 	shader.pMatrix = gl.getUniformLocation(shader, "uPMatrix");
161 | 	
162 | 	shader.enable = function () {
163 | 		gl.enableVertexAttribArray(shader.vertPos);
164 | 		gl.enableVertexAttribArray(shader.texCoord);
165 | 		gl.useProgram(shader);
166 | 	}
167 | 	shader.disable = function () {
168 | 		gl.disableVertexAttribArray(shader.vertPos);
169 | 		gl.disableVertexAttribArray(shader.texCoord);
170 | 	}
171 | 	
172 | 	shader.disable();
173 | 	return shader;
174 | }
175 | 
176 | // shaders
177 | function initShaders()
178 | {
179 | 	TEX_SHADER = TextureShader();
180 | 	STD_SHADER = StandardShader();
181 | 	STD_SHADER.enable();
182 | }
183 | 


--------------------------------------------------------------------------------
/space/meshes.js:
--------------------------------------------------------------------------------
1 | // Meshes
2 | BOX_MESH = {"count":12,"vertices":[0,1,1,0,0,1,1,1,1,0,0,1,1,0,1,1,1,1,1,1,1,1,0,1,1,1,0,1,0,1,1,0,0,1,1,0,1,1,0,1,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,1,0,1,1,0,1,0,0,1,1,1,1,0,0,1,1,1,1,1,1,1,0,0,0,1,0,0,0,1,0,1,0,0,0,1,0,0,1,0,1],"uvs":[0,0,0,1,1,0,0,1,1,1,1,0,0,0,0,1,1,0,0,1,1,1,1,0,0,0,0,1,1,0,0,1,1,1,1,0,0,0,0,1,1,0,0,1,1,1,1,0,0,0,0,1,1,0,0,1,1,1,1,0,0,0,0,1,1,0,0,1,1,1,1,0],"normals":[0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0]};
3 | 
4 | SQUARE_MESH = {"count":2,"vertices":[-1,-1,0,1,-1,0,-1,1,0,-1,1,0,1,-1,0,1,1,0],"uvs":[0,0,1,0,0,1,0,1,1,0,1,1]};
5 | 


--------------------------------------------------------------------------------
/space/shaders.js:
--------------------------------------------------------------------------------
  1 | // SHADERS: //////////////////////////////////////////
  2 | 
  3 | var STD_PIXEL_SHADER = 
  4 | "#ifdef GL_ES\n" +
  5 | "precision highp float;\n" +
  6 | "#endif\n" +
  7 | "varying vec4 vColor;\n" +
  8 | "varying vec3 vLighting;\n"+
  9 | "void main(void)\n" +
 10 | "{\n" +
 11 | "gl_FragColor = ((dot(vLighting, vLighting) * 0.5) + (dot(vLighting, vec3(-0.4, 0.4, -0.4)) * 0.7)) * vColor;\n" +
 12 | "gl_FragColor = vec4(vec3(gl_FragColor), 1.0);\n" + 
 13 | "}\n";
 14 | 
 15 | var STD_VERT_SHADER = 
 16 | "attribute vec3 aVertPos;\n" +
 17 | "attribute vec3 aVertNorm;\n" +
 18 | "attribute vec4 aVertColor;\n" +
 19 | "uniform mat4 uWMatrix;\n" +
 20 | "uniform mat4 uVMatrix;\n" +
 21 | "uniform mat4 uPMatrix;\n" +
 22 | "uniform vec4 uColor;\n" +
 23 | "varying vec4 vColor;\n" +
 24 | "varying vec3 vLighting;\n" +
 25 | "void main(void) {\n" +
 26 | "gl_Position = uPMatrix * uVMatrix * uWMatrix * vec4(aVertPos, 1.0);\n" +
 27 | "vLighting = normalize(aVertPos);\n" +
 28 | "vColor = uColor;\n" +
 29 | "}\n";
 30 | 
 31 | var TEX_PIXEL_SHADER = 
 32 | "#ifdef GL_ES\n" +
 33 | "precision highp float;\n" +
 34 | "#endif\n" +
 35 | "uniform sampler2D uTexture;\n" +
 36 | "varying vec2 vTexCoord;\n" +
 37 | "void main(void)\n" +
 38 | "{\n" +
 39 | "gl_FragColor = texture2D(uTexture, vTexCoord);\n" + 
 40 | "}\n";
 41 | 
 42 | var TEX_VERT_SHADER = 
 43 | "attribute vec3 aVertPos;\n" +
 44 | "attribute vec2 aTexCoord;\n" +
 45 | "uniform mat4 uWMatrix;\n" +
 46 | "uniform mat4 uVMatrix;\n" +
 47 | "uniform mat4 uPMatrix;\n" +
 48 | "varying vec2 vTexCoord;\n" +
 49 | "void main(void) {\n" +
 50 | "gl_Position = uPMatrix * uVMatrix * uWMatrix * vec4(aVertPos, 1.0);\n" +
 51 | "vTexCoord = aTexCoord;\n" +
 52 | "}\n";
 53 | 
 54 | function StandardShader()
 55 | {
 56 | 	var pShader = gl.createShader(gl.FRAGMENT_SHADER);
 57 | 	var vShader = gl.createShader(gl.VERTEX_SHADER);
 58 | 	
 59 | 	gl.shaderSource(pShader, STD_PIXEL_SHADER);
 60 | 	gl.compileShader(pShader);
 61 | 	if (!gl.getShaderParameter(pShader, gl.COMPILE_STATUS))
 62 | 	{
 63 | 		alert(gl.getShaderInfoLog(pShader));
 64 | 		return;
 65 | 	}
 66 | 	
 67 | 	gl.shaderSource(vShader, STD_VERT_SHADER);
 68 | 	gl.compileShader(vShader);
 69 | 	if (!gl.getShaderParameter(vShader, gl.COMPILE_STATUS))
 70 | 	{
 71 | 		alert(gl.getShaderInfoLog(vShader));
 72 | 		return;
 73 | 	}
 74 | 	
 75 | 	var shader = gl.createProgram();
 76 | 	gl.attachShader(shader, pShader);
 77 | 	gl.attachShader(shader, vShader);
 78 | 	gl.linkProgram(shader);
 79 | 	if (!gl.getProgramParameter(shader, gl.LINK_STATUS))
 80 | 	{
 81 | 		alert("Error: Could not initialize standard shader.");
 82 | 		return;
 83 | 	}
 84 | 	
 85 | 	gl.useProgram(shader);
 86 | 	
 87 | 	shader.vertPos = gl.getAttribLocation(shader, "aVertPos");
 88 | 	gl.enableVertexAttribArray(shader.vertPos);
 89 | 	shader.wMatrix = gl.getUniformLocation(shader, "uWMatrix");	
 90 | 	shader.vMatrix = gl.getUniformLocation(shader, "uVMatrix");	
 91 | 	shader.pMatrix = gl.getUniformLocation(shader, "uPMatrix");
 92 | 	
 93 | 	shader.color   = gl.getUniformLocation(shader, "uColor");
 94 | 	shader.setColor = function(r, g, b, a)
 95 | 	{
 96 | 		if (r[0] !== undefined)
 97 | 		{
 98 | 			g = r[1]; b = r[2];
 99 | 			if (r[3] !== undefined)
100 | 				a = r[3];
101 | 			r = r[0];
102 | 		}
103 | 		if (a === undefined)
104 | 			a = 1.0;
105 | 		gl.uniform4f(shader.color, r, g, b, a);
106 | 	}
107 | 	shader.setColor([1.0, 1.0, 1.0]);
108 | 	
109 | 	shader.enable = function () {
110 | 		gl.enableVertexAttribArray(shader.vertPos);
111 | 		gl.useProgram(shader);
112 | 	}
113 | 	shader.disable = function () {
114 | 		gl.disableVertexAttribArray(shader.vertPos);
115 | 	}
116 | 	
117 | 	shader.disable();
118 | 	return shader;
119 | }
120 | 
121 | function TextureShader()
122 | {
123 | 	var pShader = gl.createShader(gl.FRAGMENT_SHADER);
124 | 	var vShader = gl.createShader(gl.VERTEX_SHADER);
125 | 	
126 | 	gl.shaderSource(pShader, TEX_PIXEL_SHADER);
127 | 	gl.compileShader(pShader);
128 | 	if (!gl.getShaderParameter(pShader, gl.COMPILE_STATUS))
129 | 	{
130 | 		alert(gl.getShaderInfoLog(pShader));
131 | 		return;
132 | 	}
133 | 	
134 | 	gl.shaderSource(vShader, TEX_VERT_SHADER);
135 | 	gl.compileShader(vShader);
136 | 	if (!gl.getShaderParameter(vShader, gl.COMPILE_STATUS))
137 | 	{
138 | 		alert(gl.getShaderInfoLog(vShader));
139 | 		return;
140 | 	}
141 | 	
142 | 	var shader = gl.createProgram();
143 | 	gl.attachShader(shader, pShader);
144 | 	gl.attachShader(shader, vShader);
145 | 	gl.linkProgram(shader);
146 | 	if (!gl.getProgramParameter(shader, gl.LINK_STATUS))
147 | 	{
148 | 		alert("Error: Could not initialize texture shader.");
149 | 		return;
150 | 	}
151 | 	
152 | 	gl.useProgram(shader);
153 | 	
154 | 	shader.vertPos = gl.getAttribLocation(shader, "aVertPos");
155 | 	gl.enableVertexAttribArray(shader.vertPos);
156 | 	shader.texCoord = gl.getAttribLocation(shader, "aTexCoord");
157 | 	gl.enableVertexAttribArray(shader.texCoord);
158 | 	shader.wMatrix = gl.getUniformLocation(shader, "uWMatrix");	
159 | 	shader.vMatrix = gl.getUniformLocation(shader, "uVMatrix");	
160 | 	shader.pMatrix = gl.getUniformLocation(shader, "uPMatrix");
161 | 	
162 | 	shader.enable = function () {
163 | 		gl.enableVertexAttribArray(shader.vertPos);
164 | 		gl.enableVertexAttribArray(shader.texCoord);
165 | 		gl.useProgram(shader);
166 | 	}
167 | 	shader.disable = function () {
168 | 		gl.disableVertexAttribArray(shader.vertPos);
169 | 		gl.disableVertexAttribArray(shader.texCoord);
170 | 	}
171 | 	
172 | 	shader.disable();
173 | 	return shader;
174 | }
175 | 
176 | // shaders
177 | function initShaders()
178 | {
179 | 	TEX_SHADER = TextureShader();
180 | 	STD_SHADER = StandardShader();
181 | 	STD_SHADER.enable();
182 | }
183 | 


--------------------------------------------------------------------------------
/space/stars.html:
--------------------------------------------------------------------------------
 1 | <html>
 2 | 	<head>
 3 | 		<title>Space Explorer</title>
 4 | 		<script src="glMatrix-0.9.5.min.js"></script>
 5 | 		<script src="tedge.js"></script>
 6 | 		<script src="shaders.js"></script>
 7 |         <script src="physics.js"></script>
 8 | 		<script src="meshes.js"></script>
 9 | 		<script src="game.js"></script>
10 | 		<script src="dev.js"></script>
11 | 		</script>
12 | 		<style>
13 | 			#game {
14 | 				position: absolute;
15 | 				top: 0;
16 | 				left: 0;
17 | 				border: none;
18 | 			}
19 | 		</style>
20 | 	</head>
21 | 	<body onload="run();">
22 | 		<canvas id="game" width="100%" height="100%">
23 | 		</canvas>
24 | 		<canvas id="2D" style="display: none;">
25 | 	</body>
26 | </html>


--------------------------------------------------------------------------------
/tanks/favicon.ico:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/teamduck/gametube/40e8ea4b963148dadadea1f7d28f6d10e0a07953/tanks/favicon.ico


--------------------------------------------------------------------------------
/tanks/index.html:
--------------------------------------------------------------------------------
 1 | <html>
 2 | 	<head>
 3 | 		<title>Cyber Tanks</title>
 4 | 		<script src="/socket.io/socket.io.js"></script>
 5 | 		<script src="glMatrix-0.9.5.min.js"></script>
 6 | 		<script src="tedge.js"></script>
 7 | 		<script src="meshes.js"></script>		
 8 | 		<script src="game.js"></script>
 9 |     <script>
10 | var singleplayer = false;
11 |     </script>
12 | 		<!-- standard textured shaders -->
13 | 		<script id="shader-fs" type="x-shader/x-fragment">
14 | 		  #ifdef GL_ES
15 | 		  precision highp float;
16 | 		  #endif
17 | 		  
18 | 		  varying vec2 vTextureCoord;
19 | 		  varying vec4 vColor;
20 | 		  varying float vTexScale;
21 | 		  varying float vPulse;
22 | 		  
23 | 		  uniform sampler2D uSampler;
24 | 
25 | 		  void main(void) 
26 | 		  {
27 | 			gl_FragColor = (texture2D(uSampler, vTextureCoord * vTexScale) 
28 | 				+ texture2D(uSampler, vTextureCoord * vTexScale * 10.0) * vPulse)
29 | 				* vColor;
30 | 		  }
31 | 		</script>
32 | 		<script id="shader-vs" type="x-shader/x-vertex">
33 | 		  attribute vec3 aVertexPosition;
34 | 		  attribute vec2 aTextureCoord;
35 | 
36 | 		  uniform mat4 uWMatrix;
37 | 		  uniform mat4 uVMatrix;
38 | 		  uniform mat4 uPMatrix;
39 | 		  
40 | 		  uniform vec4 uColor;
41 | 		  uniform float uTexScale;
42 | 		  uniform float uPulse;
43 | 		  
44 | 		  varying vec2 vTextureCoord;
45 | 		  varying vec4 vColor;
46 | 		  varying float vTexScale;
47 | 		  varying float vPulse;
48 | 
49 | 		  void main(void) {
50 | 			gl_Position = uPMatrix * uVMatrix * uWMatrix * vec4(aVertexPosition, 1.0);
51 | 			vTextureCoord = aTextureCoord;
52 | 			
53 | 			vColor = uColor;
54 | 			vTexScale = uTexScale;
55 | 			vPulse = uPulse;
56 | 		  }
57 | 		</script>		
58 | 		<style>
59 | 			#game {
60 | 				position: absolute;
61 | 				top: 0;
62 | 				left: 0;
63 | 				border: none;
64 | 			}
65 | 		</style>
66 | 	</head>
67 | 	<body onload="run();">
68 | 		<canvas id="game" width="100%" height="100%">
69 | 		</canvas>
70 | 	</body>
71 | </html>
72 | 


--------------------------------------------------------------------------------
/tanks/link:
--------------------------------------------------------------------------------
1 | https://powerful-hamlet-2595.herokuapp.com
2 | 


--------------------------------------------------------------------------------
/tanks/meshes.js:
--------------------------------------------------------------------------------
1 | // models by greg
2 | // (box is my favorite)
3 | 
4 | TANK_MESH = {"count":48,"vertices":[1.167307,0.682266,0.503587,1.545776,0.014036,1.025895,1.167307,0.682266,-0.454115,1.545776,0.014036,1.025895,1.545776,0.014036,-0.976423,1.167307,0.682266,-0.454115,1.167307,0.682266,-0.454115,1.545776,0.014036,-0.976423,-0.58051,0.682266,-0.363133,1.545776,0.014036,-0.976423,-1.53071,0.014036,-0.976423,-0.58051,0.682266,-0.363133,-0.58051,0.682266,-0.363133,-1.53071,0.014036,-0.976423,-0.580509,0.682266,0.412606,-1.53071,0.014036,-0.976423,-1.53071,0.014036,1.025895,-0.580509,0.682266,0.412606,-0.580509,0.682266,0.412606,-1.53071,0.014036,1.025895,1.167307,0.682266,0.503587,-1.53071,0.014036,1.025895,1.545776,0.014036,1.025895,1.167307,0.682266,0.503587,-0.580509,0.682266,0.412606,1.167307,0.682266,0.503587,-0.58051,0.682266,-0.363133,1.167307,0.682266,0.503587,1.167307,0.682266,-0.454115,-0.58051,0.682266,-0.363133,1.545776,0.014036,1.025895,-1.53071,0.014036,1.025895,1.545776,0.014036,-0.976423,-1.53071,0.014036,1.025895,-1.53071,0.014036,-0.976423,1.545776,0.014036,-0.976423,0.638483,0.922296,0.222402,0.815716,0.68021,0.32601,0.638483,0.922296,-0.172929,0.815716,0.68021,0.32601,0.815716,0.68021,-0.276537,0.638483,0.922296,-0.172929,0.638483,0.922296,-0.172929,0.815716,0.68021,-0.276537,-0.037777,0.922296,-0.172929,0.815716,0.68021,-0.276537,-0.21501,0.68021,-0.276537,-0.037777,0.922296,-0.172929,-0.037777,0.922296,-0.172929,-0.21501,0.68021,-0.276537,-0.037777,0.922296,0.222402,-0.21501,0.68021,-0.276537,-0.21501,0.68021,0.32601,-0.037777,0.922296,0.222402,-0.037777,0.922296,0.222402,-0.21501,0.68021,0.32601,0.638483,0.922296,0.222402,-0.21501,0.68021,0.32601,0.815716,0.68021,0.32601,0.638483,0.922296,0.222402,-0.037777,0.922296,0.222402,0.638483,0.922296,0.222402,-0.037777,0.922296,-0.172929,0.638483,0.922296,0.222402,0.638483,0.922296,-0.172929,-0.037777,0.922296,-0.172929,0.815716,0.68021,0.32601,-0.21501,0.68021,0.32601,0.815716,0.68021,-0.276537,-0.21501,0.68021,0.32601,-0.21501,0.68021,-0.276537,0.815716,0.68021,-0.276537,-0.972211,0.355986,-0.304011,-0.972211,0.266512,-0.304011,-0.972211,0.355986,-0.416096,-0.972211,0.266512,-0.304011,-0.972211,0.266512,-0.416096,-0.972211,0.355986,-0.416096,-0.972211,0.355986,-0.416096,-0.972211,0.266512,-0.416096,-1.519424,0.355986,-0.416096,-0.972211,0.266512,-0.416096,-1.519424,0.266512,-0.416096,-1.519424,0.355986,-0.416096,-1.519424,0.355986,-0.416096,-1.519424,0.266512,-0.416096,-1.519424,0.355986,-0.304011,-1.519424,0.266512,-0.416096,-1.519424,0.266512,-0.304011,-1.519424,0.355986,-0.304011,-1.519424,0.355986,-0.304011,-1.519424,0.266512,-0.304011,-0.972211,0.355986,-0.304011,-1.519424,0.266512,-0.304011,-0.972211,0.266512,-0.304011,-0.972211,0.355986,-0.304011,-1.519424,0.355986,-0.304011,-0.972211,0.355986,-0.304011,-1.519424,0.355986,-0.416096,-0.972211,0.355986,-0.304011,-0.972211,0.355986,-0.416096,-1.519424,0.355986,-0.416096,-0.972211,0.266512,-0.304011,-1.519424,0.266512,-0.304011,-0.972211,0.266512,-0.416096,-1.519424,0.266512,-0.304011,-1.519424,0.266512,-0.416096,-0.972211,0.266512,-0.416096,-0.972211,0.355986,0.465569,-0.972211,0.266512,0.353485,-0.972211,0.355986,0.353485,-0.972211,0.355986,0.465569,-0.972211,0.266512,0.465569,-0.972211,0.266512,0.353485,-1.519424,0.355986,0.465569,-0.972211,0.266512,0.465569,-0.972211,0.355986,0.465569,-1.519424,0.355986,0.465569,-1.519424,0.266512,0.465569,-0.972211,0.266512,0.465569,-1.519424,0.355986,0.353485,-1.519424,0.266512,0.465569,-1.519424,0.355986,0.465569,-1.519424,0.355986,0.353485,-1.519424,0.266512,0.353485,-1.519424,0.266512,0.465569,-0.972211,0.355986,0.353485,-1.519424,0.266512,0.353485,-1.519424,0.355986,0.353485,-0.972211,0.355986,0.353485,-0.972211,0.266512,0.353485,-1.519424,0.266512,0.353485,-1.519424,0.355986,0.465569,-0.972211,0.355986,0.353485,-1.519424,0.355986,0.353485,-1.519424,0.355986,0.465569,-0.972211,0.355986,0.465569,-0.972211,0.355986,0.353485,-0.972211,0.266512,0.465569,-1.519424,0.266512,0.353485,-0.972211,0.266512,0.353485,-0.972211,0.266512,0.465569,-1.519424,0.266512,0.465569,-1.519424,0.266512,0.353485],"uvs":[0,0,0,1,1,0,0,1,1,1,1,0,0,0,0,1,1,0,0,1,1,1,1,0,0,0,0,1,1,0,0,1,1,1,1,0,0,0,0,1,1,0,0,1,1,1,1,0,0,0,0,1,1,0,0,1,1,1,1,0,0,0,0,1,1,0,0,1,1,1,1,0,0,0,0,1,1,0,0,1,1,1,1,0,0,0,0,1,1,0,0,1,1,1,1,0,0,0,0,1,1,0,0,1,1,1,1,0,0,0,0,1,1,0,0,1,1,1,1,0,0,0,0,1,1,0,0,1,1,1,1,0,0,0,0,1,1,0,0,1,1,1,1,0,0,0,0,1,1,0,0,1,1,1,1,0,0,0,0,1,1,0,0,1,1,1,1,0,0,0,0,1,1,0,0,1,1,1,1,0,0,0,0,1,1,0,0,1,1,1,1,0,0,0,0,1,1,0,0,1,1,1,1,0,0,0,0,1,1,0,0,1,1,1,1,0,1,0,0,1,0,0,1,0,1,1,0,1,1,0,0,1,0,0,1,0,1,1,0,1,1,0,0,1,0,0,1,0,1,1,0,1,1,0,0,1,0,0,1,0,1,1,0,1,1,0,0,1,0,0,1,0,1,1,0,1,1,0,0,1,0,0,1,0,1,1,0,1]};
5 | 
6 | BOX_MESH = {"count":12,"vertices":[0,1,1,0,0,1,1,1,1,0,0,1,1,0,1,1,1,1,1,1,1,1,0,1,1,1,0,1,0,1,1,0,0,1,1,0,1,1,0,1,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,1,0,1,1,0,1,0,0,1,1,1,1,0,0,1,1,1,1,1,1,1,0,0,0,1,0,0,0,1,0,1,0,0,0,1,0,0,1,0,1],"uvs":[0,0,0,1,1,0,0,1,1,1,1,0,0,0,0,1,1,0,0,1,1,1,1,0,0,0,0,1,1,0,0,1,1,1,1,0,0,0,0,1,1,0,0,1,1,1,1,0,0,0,0,1,1,0,0,1,1,1,1,0,0,0,0,1,1,0,0,1,1,1,1,0]};
7 | 
8 | BULLET_MESH = {"count":12,"vertices":[0.408321,0.04406,0.055932,0.408321,-0.045414,-0.056153,0.408321,0.04406,-0.056153,0.408321,0.04406,0.055932,0.408321,-0.045414,0.055932,0.408321,-0.045414,-0.056153,-0.412499,0.04406,0.055932,0.408321,-0.045414,0.055932,0.408321,0.04406,0.055932,-0.412499,0.04406,0.055932,-0.412499,-0.045414,0.055932,0.408321,-0.045414,0.055932,-0.412499,0.04406,-0.056153,-0.412499,-0.045414,0.055932,-0.412499,0.04406,0.055932,-0.412499,0.04406,-0.056153,-0.412499,-0.045414,-0.056153,-0.412499,-0.045414,0.055932,0.408321,0.04406,-0.056153,-0.412499,-0.045414,-0.056153,-0.412499,0.04406,-0.056153,0.408321,0.04406,-0.056153,0.408321,-0.045414,-0.056153,-0.412499,-0.045414,-0.056153,-0.412499,0.04406,0.055932,0.408321,0.04406,-0.056153,-0.412499,0.04406,-0.056153,-0.412499,0.04406,0.055932,0.408321,0.04406,0.055932,0.408321,0.04406,-0.056153,0.408321,-0.045414,0.055932,-0.412499,-0.045414,-0.056153,0.408321,-0.045414,-0.056153,0.408321,-0.045414,0.055932,-0.412499,-0.045414,0.055932,-0.412499,-0.045414,-0.056153],"uvs":[1,0,0,1,0,0,1,0,1,1,0,1,1,0,0,1,0,0,1,0,1,1,0,1,1,0,0,1,0,0,1,0,1,1,0,1,1,0,0,1,0,0,1,0,1,1,0,1,1,0,0,1,0,0,1,0,1,1,0,1,1,0,0,1,0,0,1,0,1,1,0,1]};
9 | 


--------------------------------------------------------------------------------
/tanks/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "tanks",
 3 |   "subdomain": "cybertanks",
 4 |   "scripts": {
 5 |     "start": "node server.js"
 6 |   },
 7 |   "version": "1.0.0-2",
 8 |   "dependencies": {
 9 |     "socket.io": "*"
10 |   },
11 |   "engines": {
12 |     "node": "0.8.x"
13 |   }
14 | }
15 | 


--------------------------------------------------------------------------------
/tanks/server.js:
--------------------------------------------------------------------------------
  1 | /* js tanks server
  2 |  * 7/23/2011
  3 |  * aizuwakamatsu, fukushimaken, japan
  4 |  */
  5 | 
  6 | // NODE LIBRARIES ////////////////////////////////////////////////////////////
  7 | var sys 	= require('sys');
  8 | var http	= require('http');
  9 | var fs 		= require('fs');
 10 | var url 	= require('url');
 11 | 
 12 | // uses socket.io 0.7.9
 13 | var sio		= require('socket.io');
 14 | 
 15 | // CONSTANTS /////////////////////////////////////////////////////////////////
 16 | var PORT	= 80;
 17 | 
 18 | // DATA STRUCTURES ///////////////////////////////////////////////////////////
 19 | var uid		= 1;	// unique id counter
 20 | var clients	= [];	// array of socket.io client objects
 21 | 
 22 | 
 23 | // PROTOCOL //////////////////////////////////////////////////////////////////
 24 | //
 25 | // SERVER -> CLIENT:
 26 | //   {event: 'hi', id: u_id}
 27 | //
 28 | // CLIENT -> SERVER:
 29 | //   {event: 'pos', blah blah}	- rebroadcast message volatile
 30 | //   {blah blah blah}			- rebroadcast message
 31 | //
 32 | 
 33 | function debug(message)
 34 | {
 35 | 	sys.puts("error: " + message);
 36 | }
 37 | 
 38 | var mime_types = 
 39 | {
 40 | 	html:"text/html",
 41 | 	htm:"text/html",
 42 | 	css:"text/css",
 43 | 	js:"text/javascript",
 44 | 	png:"image/png",
 45 | 	jpg:"image/jpeg",
 46 | 	ico:"image/vnd.microsoft.icon",
 47 | 	txt:"text/plain"
 48 | };
 49 | 
 50 | // SERVER HANDLERS ///////////////////////////////////////////////////////////
 51 | 
 52 | function staticFileHandler(filename)
 53 | {
 54 | 	// cache the data ahead of time
 55 | 	var file = fs.readFileSync(filename, "binary");
 56 | 	var stats = fs.statSync(filename);
 57 | 	var etag = '"' + stats.ino + '-' + stats.size + '-' + Date.parse(stats.mtime) + '"';
 58 | 	
 59 | 	var i = filename.lastIndexOf(".");
 60 | 	var content_type = "text/plain";
 61 | 	if (i != -1) 
 62 | 	{
 63 | 		var extension = filename.substring(i+1);
 64 | 		if (extension != "" && mime_types[extension] != undefined)
 65 | 			content_type = mime_types[extension];
 66 | 	}	
 67 | 	
 68 | 	var header = {
 69 | 		"Server": 			"tank-game",
 70 | 		"ETag": 			etag,
 71 | 		"Content-Type": 	content_type,
 72 | 		"Content-Length": 	file.length
 73 | 	}
 74 | 	
 75 | 	return function(request, response)
 76 | 	{
 77 | 		if (request.headers['if-none-match'] != undefined && 
 78 | 			request.headers['if-none-match'].indexOf(etag) != -1)
 79 | 		{
 80 | 			//sys.puts("304 on " + filename);
 81 | 			response.writeHead(304);
 82 | 			response.end();
 83 | 			return;
 84 | 		}
 85 | 
 86 | 		// sys.puts("Serving file " + filename + ".");		
 87 | 		response.writeHead(200, header);  
 88 | 		response.write(file, "binary");  
 89 | 		response.end();
 90 | 	};
 91 | }
 92 | 
 93 | var root = staticFileHandler("index.html");
 94 | var handler = {};
 95 | 
 96 | function listFile(file) { handler[file] = staticFileHandler(file); }
 97 | 
 98 | // list of files on the server
 99 | handler["index.html"] 	= root;
100 | listFile("favicon.ico");
101 | listFile("server.js");
102 | listFile("game.js");
103 | listFile("tedge.js");
104 | listFile("meshes.js");
105 | listFile("glMatrix-0.9.5.min.js");
106 | listFile("thick.png");
107 | listFile("thin.png");
108 | 
109 | // FILE SERVER ///////////////////////////////////////////////////////////////
110 | server = http.createServer(function(req, resp)
111 | {
112 | 	var uri = url.parse(req.url).pathname;
113 | 	var filename = uri.substring(1);
114 | 
115 | 	if (filename)
116 | 	{
117 | 		if (handler[filename])
118 | 		{
119 | 			handler[filename](req, resp);
120 | 		}
121 | 		else
122 | 		{		
123 | 			resp.writeHead(404, {"Content-Type": "text/plain"});  
124 | 			resp.write("Error 404: file not found");  
125 | 			resp.end();
126 | 			debug("requested invalid file: '" + filename + "'");			
127 | 		}
128 | 	}
129 | 	else
130 | 	{
131 | 		root(req, resp);
132 | 	}
133 | });
134 | 
135 | server.listen(PORT);
136 | 
137 | // SOCKET.IO SERVER //////////////////////////////////////////////////////////
138 | 
139 | var io = sio.listen(server); 
140 | io.sockets.on('connection', function(client)
141 | { 
142 | 	// new player connected
143 | 	var user_id = uid++;
144 | 	clients[user_id] = client;
145 | 	
146 | 	// incoming ajax
147 | 	client.on('message', function(msg)
148 | 	{
149 | 		if (msg.event == 'pos')
150 | 		{
151 | 			client.volatile.broadcast.json.send(msg);
152 | 		}
153 | 		else
154 | 		{
155 | 			client.broadcast.json.send(msg);		
156 | 		}
157 | 	}); 
158 | 	
159 | 	// client disconnect
160 | 	client.on('disconnect', function()
161 | 	{
162 | 		delete clients[user_id];
163 | 	});
164 | 	
165 | 	// begin the handshake
166 | 	client.json.send({event: "hi", id: user_id});
167 | 	
168 | 	sys.puts("New player with id " + user_id);
169 | }); 
170 | 


--------------------------------------------------------------------------------
/tanks/singleplayer.html:
--------------------------------------------------------------------------------
 1 | <html>
 2 | 	<head>
 3 | 		<title>Cyber Tanks</title>
 4 | 		<script src="/socket.io/socket.io.js"></script>
 5 | 		<script src="glMatrix-0.9.5.min.js"></script>
 6 | 		<script src="tedge.js"></script>
 7 | 		<script src="meshes.js"></script>		
 8 | 		<script src="game.js"></script>
 9 |     <script>
10 | var singleplayer = true;
11 |     </script>
12 | 		<!-- standard textured shaders -->
13 | 		<script id="shader-fs" type="x-shader/x-fragment">
14 | 		  #ifdef GL_ES
15 | 		  precision highp float;
16 | 		  #endif
17 | 		  
18 | 		  varying vec2 vTextureCoord;
19 | 		  varying vec4 vColor;
20 | 		  varying float vTexScale;
21 | 		  varying float vPulse;
22 | 		  
23 | 		  uniform sampler2D uSampler;
24 | 
25 | 		  void main(void) 
26 | 		  {
27 | 			gl_FragColor = (texture2D(uSampler, vTextureCoord * vTexScale) 
28 | 				+ texture2D(uSampler, vTextureCoord * vTexScale * 10.0) * vPulse)
29 | 				* vColor;
30 | 		  }
31 | 		</script>
32 | 		<script id="shader-vs" type="x-shader/x-vertex">
33 | 		  attribute vec3 aVertexPosition;
34 | 		  attribute vec2 aTextureCoord;
35 | 
36 | 		  uniform mat4 uWMatrix;
37 | 		  uniform mat4 uVMatrix;
38 | 		  uniform mat4 uPMatrix;
39 | 		  
40 | 		  uniform vec4 uColor;
41 | 		  uniform float uTexScale;
42 | 		  uniform float uPulse;
43 | 		  
44 | 		  varying vec2 vTextureCoord;
45 | 		  varying vec4 vColor;
46 | 		  varying float vTexScale;
47 | 		  varying float vPulse;
48 | 
49 | 		  void main(void) {
50 | 			gl_Position = uPMatrix * uVMatrix * uWMatrix * vec4(aVertexPosition, 1.0);
51 | 			vTextureCoord = aTextureCoord;
52 | 			
53 | 			vColor = uColor;
54 | 			vTexScale = uTexScale;
55 | 			vPulse = uPulse;
56 | 		  }
57 | 		</script>		
58 | 		<style>
59 | 			#game {
60 | 				position: absolute;
61 | 				top: 0;
62 | 				left: 0;
63 | 				border: none;
64 | 			}
65 | 		</style>
66 | 	</head>
67 | 	<body onload="run();">
68 | 		<canvas id="game" width="100%" height="100%">
69 | 		</canvas>
70 | 	</body>
71 | </html>
72 | 


--------------------------------------------------------------------------------
/tanks/thick.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/teamduck/gametube/40e8ea4b963148dadadea1f7d28f6d10e0a07953/tanks/thick.png


--------------------------------------------------------------------------------
/tanks/thin.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/teamduck/gametube/40e8ea4b963148dadadea1f7d28f6d10e0a07953/tanks/thin.png


--------------------------------------------------------------------------------