diff --git a/scripts/buildObjects.js b/scripts/buildObjects.js
index 86e0948..b5d8030 100644
--- a/scripts/buildObjects.js
+++ b/scripts/buildObjects.js
@@ -1,1812 +1,1836 @@
 /*
  * 3DCycles - A lightcycle game.
  * Copyright (C) 2019 Glen Harpring
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
  * of the License, or (at your option) any later version.
  * 
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  * 
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  */
 
 
 //TODO: neaten up this file, make it so the map isn't parsed a bunch of times
 //TODO: use an object for the cycles?
 //lots of Durf code around these parts...
 
 //NOTE: these functions depend on the presence of mapSTRING and/or mapXML
 //RETURNS: scene mesh/object to add into global object
 
 function loadTextures()
 {
 	engine.textures.floor = new new THREE.TextureLoader().load(relPath(settings.FLOOR_TEXTURE,"images"));
 	engine.textures.rim_wall = new new THREE.TextureLoader().load(relPath(settings.RIM_WALL_TEXTURE,"images"));
 	//engine.textures.cycle_wall = new new THREE.TextureLoader().load('images/textures/dir_wall.png');
 	engine.textures.cycle_body = new THREE.TextureLoader().load(relPath(settings.CYCLE_TEXTURES[0],"images"));
 	engine.textures.cycle_wheel = new THREE.TextureLoader().load(relPath(settings.CYCLE_TEXTURES[1],"images"))
 	engine.textures.cycle_shadow = new THREE.TextureLoader().load('images/textures/shadow.png')
 }
 
 //GRID
 function buildGrid()
 {
 	//floor texture stuff
 	engine.grid = new THREE.Object3D();//initialize global object
 
 	var sizeFactorHandle = settings.SIZE_FACTOR / 2;
 	engine.REAL_ARENA_SIZE_FACTOR = Math.pow(2, sizeFactorHandle);
 
 	var logicalBox = getLogicalBox(engine.mapString);// x, y, minx, miny, maxx, maxy
 	engine.logicalBox = {
 		center: { x:logicalBox[0], y: logicalBox[1]},
 		min: { x:logicalBox[2], y: logicalBox[3]},
 		max: { x:logicalBox[4], y: logicalBox[5]}
 	};
 	var logicalHeight = ((logicalBox[5]-logicalBox[3]) * engine.REAL_ARENA_SIZE_FACTOR)/* + 10*/;//+10 for outer edge
 	var logicalWidth = ((logicalBox[4]-logicalBox[2]) * engine.REAL_ARENA_SIZE_FACTOR)/* + 10*/;
 	
 	if(!engine.dedicated)
 	{
 		var floorTexture = engine.textures.floor;
 		floorTexture.wrapS = floorTexture.wrapT = THREE.RepeatWrapping; 
 		floorTexture.repeat.set(logicalWidth,logicalHeight);	//floorTexture.repeat.set( 500, 500 );
 
 		var centerOffset_x = (logicalBox[2] * engine.REAL_ARENA_SIZE_FACTOR);//offset from bottom left corner
 		var centerOffset_x2 = Math.round((centerOffset_x % 1)*100000000)/100000000;
 		floorTexture.offset.x = centerOffset_x2;  
 		
 		var centerOffset_y = (logicalBox[3] * engine.REAL_ARENA_SIZE_FACTOR);//-5;//not needed since we only take %1 offset
 		var centerOffset_y2 = Math.round((centerOffset_y % 1)*100000000)/100000000;
 		
 		floorTexture.offset.y = centerOffset_y2; 
 
 
 		if(engine.usingWebgl)
 		{
 			var maxAnisotropy = engine.renderer.capabilities.getMaxAnisotropy();
 			floorTexture.anisotropy = maxAnisotropy;
 		}
 		
 		var color = new THREE.Color(settings.FLOOR_RED,settings.FLOOR_GREEN,settings.FLOOR_BLUE);
 		var floorMaterial = new THREE.MeshBasicMaterial( { color:color, map: floorTexture,/* transparent: settings.ALPHA_BLEND /*, side: THREE.DoubleSide*/} );
 
 		
 		floorMaterial.needsUpdate = true;//is this needed?
 		var floorGeometry = new THREE.PlaneBufferGeometry(logicalWidth*settings.GRID_SIZE,logicalHeight*settings.GRID_SIZE,1,1);
 		floorGeometry.dynamic = true;//is this needed?
 		var grid_object = new THREE.Mesh(floorGeometry, floorMaterial);
 		grid_object.position.x = logicalBox[0] * engine.REAL_ARENA_SIZE_FACTOR;
 		grid_object.position.y = logicalBox[1] * engine.REAL_ARENA_SIZE_FACTOR;
 		grid_object.position.z = -2/100;//move down 2/100 units for render glitch
 		//grid_object.scale.set(settings.GRID_SIZE,settings.GRID_SIZE,1);
 		//console.log("gridx: "+grid_object.position.x+"  gridy: "+grid_object.position.y);
 		grid_object.geometry.dynamic = true;//is this needed?
 		
 		if(settings.FLOOR_MIRROR)
 		{
 			engine.grid.mirror = grid_object.clone();
 			engine.grid.mirror.position.z -= 1/100;
 			engine.grid.reflection = new THREE.CubeCamera(0.01,100000,128);
 			engine.scene.add(engine.grid.reflection);
 			floorMaterial.envMap = engine.grid.reflection.renderTarget;
 			engine.grid.reflection.position.copy(grid_object.position);
 			//engine.grid.reflection.position.z = -250;
 		}
 	}
 	
 //	return grid_object;
 	engine.grid.add(grid_object);//add to global object
 	
 
 	//SPAWNS add to map data
 	var allSpawns = engine.mapXML.getElementsByTagName("Spawn");
 	for (s = 0; s < allSpawns.length; s++)
 	{ 
 		var sXpos = (allSpawns[s].getAttribute("x") * engine.REAL_ARENA_SIZE_FACTOR);
 		var sYpos = (allSpawns[s].getAttribute("y") * engine.REAL_ARENA_SIZE_FACTOR);
 		var sZpos = (allSpawns[s].getAttribute("z") * 1);
 		if(isNaN(sZpos)) sZpos = 0;
 		if ( allSpawns[s].hasAttribute("angle") ) { var sAng = allSpawns[s].getAttribute("angle"); }
 		else { var sAng = gafd( parseFloat(allSpawns[s].getAttribute("xdir")), parseFloat(allSpawns[s].getAttribute("ydir")) ); }
 		var spawn_data = [sXpos, sYpos, sZpos, sAng];
 		engine.map.spawns.push( spawn_data );
 	}
 
 }//end of grid
 
 
 
 ///////////////////////////////
 //WALLS
 function buildWalls() {//builds all walls in map and returns object to add to scene
 engine.walls = new THREE.Object3D();
 	var allWalls = engine.mapXML.getElementsByTagName("Wall");
 	for (var r = 0; r < allWalls.length; r++) {
 		var wall_points = new Array();
 		if(settings.HIGH_RIM)
 			var wall_height = Math.pow(2,16);
 		else
 			var wall_height = settings.LOW_RIM_HEIGHT; //4
 		if (allWalls[r].hasAttribute("height")) { wall_height = allWalls[r].getAttribute("height")*1; }
 		var allWallPoints = allWalls[r].getElementsByTagName("Point");
 		for (var q = 0; q < allWallPoints.length; q++)
 		{
 			wall_points.push(
 				[
 					allWallPoints[q].getAttribute("x") * engine.REAL_ARENA_SIZE_FACTOR, 
 					allWallPoints[q].getAttribute("y") * engine.REAL_ARENA_SIZE_FACTOR,
 					0, //wall_bottom
 					wall_height
 				]
 			);
 		}
 		wall_object = buildWall(wall_points, wall_height);
 		//wall_object.receiveShadow = true;
 		//wall_object.castShadow = true;
 		engine.walls.add(wall_object);//add complete object to global walls
 		
 		engine.map.walls.push(wall_points);//add to map data
 	}
 
 }
 
 //this is for buildWalls - builds a single wall out of many
 var totalWallsLength = 0;//used to line textures like arma does
 function buildWall(pointArray, height) {//builds a single <Wall> tag
 	if(!settings.RIM_WALL_REPEAT_TOP && height > settings.RIM_WALL_STRETCH_Y) height = settings.RIM_WALL_STRETCH_Y;
 	var geo = new THREE.Geometry();
 	for (var n = 0; n < pointArray.length; n++) {
 		var thisPoint = pointArray[n];
 		geo.vertices.push( new THREE.Vector3( (thisPoint[0]), (thisPoint[1]), 0) );
 	}
 	for (var m = 0; m < pointArray.length; m++) {
 		var thisPoint = pointArray[m];
 		geo.vertices.push( new THREE.Vector3( (thisPoint[0]), (thisPoint[1]), height) );
 	}
 	var totalLength = 0;
 	for (var i = 0; i < (geo.vertices.length/2)-1; i++) {
 
 		var p1x = geo.vertices[i].x; var p1y = geo.vertices[i].y;
       var p2x = geo.vertices[i+1].x; var p2y = geo.vertices[i+1].y;      
 
 		var dist = Math.sqrt( (p2x-=p1x)*p2x + (p2y-=p1y)*p2y );
 		totalLength += dist;
 		totalWallsLength += dist;
 //		console.log(totalLength);
 //      var slope = ( (py2 - py1) / (px2 - px1) );
 //      var invslope = -( (px2 - px1) / (py2 - py1) );
 		var normal = new THREE.Vector3( (p2y - p1y), -(p2x - p1x), 0 );
 // c       d
 // a       b
 		geo.faces.push( 
 			new THREE.Face3( (i), (i+1), (i+(geo.vertices.length/2)), normal ), //a,b,c
 			new THREE.Face3( (i+(geo.vertices.length/2)+1), (i+(geo.vertices.length/2)), (i+1), normal ) //d,c,b 
 		);
 		geo.faceVertexUvs[0].push(
 		[new THREE.Vector2((totalWallsLength-dist),0),new THREE.Vector2((totalWallsLength),0),new THREE.Vector2((totalWallsLength-dist),1)], //a,b,c
 		[new THREE.Vector2((totalWallsLength),1),new THREE.Vector2((totalWallsLength-dist),1),new THREE.Vector2((totalWallsLength),0)] //d,c,b
 		);
 		
 	}
 	
 	if(!engine.dedicated)
 	{
 		geo.uvsNeedUpdate = true;
 		geo.buffersNeedUpdate = true; //apparently isn't needed for desired effect
 		geo.computeFaceNormals();//for lighting
 		geo.computeVertexNormals();//for lighting?
 
 		if(settings.RIM_WALL_TEXTURE != "") 
 		{
 			var wallTexture = engine.textures.rim_wall;
 			wallTexture.wrapS = THREE.RepeatWrapping;
 			if(settings.RIM_WALL_WRAP_Y) wallTexture.wrapT = THREE.RepeatWrapping;
 			wallTexture.repeat.set(1/settings.RIM_WALL_STRETCH_X,height/settings.RIM_WALL_STRETCH_Y);	//totalLength, height
 		}
 
 		if(engine.usingWebgl) 
 		{
 			var maxAnisotropy = engine.renderer.getMaxAnisotropy();
 			wallTexture.anisotropy = maxAnisotropy;
 		}
 		
 		var wallIsTooLow = height<settings.RIM_WALL_LOWEST_HEIGHT;
 		
 		var wallmat = new (settings.RIM_WALL_DEPTH?THREE.MeshLambertMaterial:THREE.MeshBasicMaterial)({ 
 			map: wallIsTooLow?null:(wallTexture==""?null:wallTexture),
 			transparent:settings.ALPHA_BLEND,opacity:settings.RIM_WALL_ALPHA,
 			color: wallIsTooLow?
 				new THREE.Color(settings.RIM_WALL_BELOW_HEIGHT_COLOR_R,settings.RIM_WALL_BELOW_HEIGHT_COLOR_G,settings.RIM_WALL_BELOW_HEIGHT_COLOR_B)
 				:
 				new THREE.Color(settings.RIM_WALL_RED,settings.RIM_WALL_GREEN,settings.RIM_WALL_BLUE),
 			side: THREE.DoubleSide, flatShading: true 
 		});
 
 	//	var wallmat = new THREE.MeshLambertMaterial({ color: 0x404040, side: THREE.DoubleSide, shading: THREE.FlatShading});    
 	//use this material for better fps - textures OFF
 
 		var thewall = new THREE.Mesh( geo, wallmat );
 		return thewall;
 	}
 }
 
 
 /////////////////////////////
 //ZONES
 function buildZones()
 {
 	engine.zones = new THREE.Object3D();
 	var mapsZones = engine.mapXML.getElementsByTagName("Zone");
 	console.log("NUM ZONES = "+mapsZones.length);
 	for (var p = 0; p < mapsZones.length; p++)
 	{
 		var zone = {};
 		if(mapsZones[p].hasAttribute("effect")) { zone.type = mapsZones[p].getAttribute("effect"); }
 		var point = mapsZones[p].getElementsByTagName("Point");
 		zone.x = (point[0].getAttribute("x") * engine.REAL_ARENA_SIZE_FACTOR);
 		zone.y = (point[0].getAttribute("y") * engine.REAL_ARENA_SIZE_FACTOR);
 		var shape = mapsZones[p].getElementsByTagName("ShapeCircle");
 		if(shape.length == 0)
 		{
 			var shape = mapsZones[p].getElementsByTagName("ShapePolygon");
 			if(shape.length > 0)
 			{
 				zone.shape = "polygon"; zone.points = [];
 				for(var i=1;i<point.length;i++)
 				{
 					zone.points.push([point[i].attributes.x.value*1,point[i].attributes.y.value*1]);
 				}
 			}
 			else
 			{
 				console.error("Invalid or no zone shape specified");
 			}
 		}
 		
 		if(shape.length > 0)
 		{
 			if(shape[0].attributes.radius)
 			{
 				zone.radius = (shape[0].getAttribute("radius") * engine.REAL_ARENA_SIZE_FACTOR);
 			}
 			else
 			{
 				zone.radius = engine.REAL_ARENA_SIZE_FACTOR;
 			}
 			zone.expansion = shape[0].getAttribute("growth")*1;
 			
 			if(shape[0].attributes.rotation)
 			{
 				var s = shape[0].attributes.rotation.value.split(";");
 				zone.rot = s[1];
 			}
 			
 			var colorelement = mapsZones[p].getElementsByTagName("Color")[0];
 			if(colorelement)
 			{
 				if(colorelement.attributes.hexCode) // +ap compatibility
 				{
 					zone.color = 1*(colorelement.getAttribute("hexCode"));
 				}
 				else if(colorelement.attributes.r || colorelement.attributes.g || colorelement.attributes.b) // +ap compatibility
 				{
 					zone.color = new THREE.Color(colorelement.getAttribute("r")/15,colorelement.getAttribute("g")/15,colorelement.getAttribute("b")/15);
 				}
 				else if(colorelement.attributes.red || colorelement.attributes.green || colorelement.attributes.blue) //0.4 compatibility
 				{
 					var r=colorelement.getAttribute("red"),g=colorelement.getAttribute("green"),b=colorelement.getAttribute("blue");
 					var a = colorelement.attributes.alpha?colorelement.getAttribute("alpha"):1;
 					zone.color = new THREE.Color(r,g,b);
 					
 				}
 			}
 			
 			var delay = mapsZones[p].attributes.delay?mapsZones[p].getAttribute("delay"):0;
 			
 			switch(zone.type)
 			{
 				case "rubber":
 					zone.value = mapsZones[p].getAttribute("rubberVal");
 					break;
 				case "speed": case "acceleration":
 					zone.value = mapsZones[p].getAttribute("speed");
 					break;
 			}
 			
 			/*zone_object = createZone(zonesType,zonesXpos,zonesYpos,zonesRadius,color);
 			var zone_data = [zonesType, zonesXpos, zonesYpos, zonesRadius, zonesExpansion, value,0,0,false];
 			engine.map.zones.push(zone_data);
 			console.log("ZONE ADDED: "+zonesType);
 			engine.zones.add(zone_object);*/
 			new Zone(zone).spawn();
 		}
 		else
 		{
 			console.log("Zone skipped");
 		}
 	}
 	//for (var z = 0; z < engine.a_zone.length; z++) { all_zones.add( a_zone[z] ); }
 
 }
 
 var zSpawn = function() 
 { 
 	engine.zones.add(this);
 	engine.map.zones.push([this.type,this.x,this.y,this.radius,this.expansion,this.value,this.xdir,this.ydir,this.bounce]); //DEPRECATED
 };
 
 function llll(zone)
 {
 	
 }
 
 
 
 
 /////////////////////////////
 //CYCLE (TODO:split into cycle model chooser file)
 
 var cycleModel = function(colorCode) {//builds a single cycle
 	var model = new THREE.Object3D();
 
 	if(!engine.dedicated)
 	{
 		var geo_body = new THREE.Geometry();
 		var geo_front = new THREE.Geometry();
 		var geo_back = new THREE.Geometry();
 		/*____________armagetron cycle______________*/
 		geo_body.vertices.push( 
 			new THREE.Vector3(  0.787148,	 0.394117,	0.964472),
 			new THREE.Vector3(  1.982280,	 0.145382,	1.00079),
 			new THREE.Vector3(  1.685360,	 0.169418,	1.21508),
 			new THREE.Vector3(  1.179990,	 0.197158,	1.43881),
 			new THREE.Vector3(  0.586153,	 0.197158,	1.54688),
 			new THREE.Vector3( -0.340365,	 0.164937,	1.54215),
 			new THREE.Vector3( -0.476320,	 0.145253,	1.44595),
 			new THREE.Vector3( -0.508108,	 0.135410,	1.30398),
 			new THREE.Vector3(  0.531900,	 0.197158,	0.234183),
 			new THREE.Vector3(  1.482190,	 0.197158,	0.232375),
 			new THREE.Vector3(  2.049060,	 0.141480,	0.847465),
 			new THREE.Vector3(  1.982280,	-0.143510,	1.00079),
 			new THREE.Vector3(  1.685360,	-0.171200,	1.21508),
 			new THREE.Vector3(  1.179990,	-0.199500,	1.43881),
 			new THREE.Vector3(  0.586153,	-0.199500,	1.54688),
 			new THREE.Vector3( -0.340450,	-0.168183,	1.54215),
 			new THREE.Vector3( -0.476405,	-0.138655,	1.44595),
 			new THREE.Vector3( -0.508192,	-0.128813,	1.30398),
 			new THREE.Vector3(  0.531900,	-0.199500,	0.234183),
 			new THREE.Vector3(  1.482190,	-0.199500,	0.232375),
 			new THREE.Vector3(  2.046890,	-0.134012,	0.847465),
 			new THREE.Vector3(  0.785515,	-0.393152,	0.964472) 
 		);
 
 	//minx = -0.508192
 	//maxx =  2.049060
 	//miny = -0.393152
 	//maxy =  0.394117
 	//minz =  0.232375
 	//maxz =  1.54688
 
 	//0 , 0  -  1 , 1
 	//-0.508192 , 0.232375
 	//2.049060 , 1.54688
 
 
 	//x & z
 	var bodyrangex = (-0.508192 - 2.049060) * -1; 	//range = (lowest - highest) * -1
 	var bodyoffsetx = 0 - -0.508192;						//offset = 0 - lowest
 	var bodyrangez = (0.232375 - 1.54688) * -1;
 	var bodyoffsetz = 0 - 0.232375;
 
 		geo_body.faces.push( 
 			new THREE.Face3( 0, 2, 1 ),
 			new THREE.Face3( 0, 3, 2 ),
 			new THREE.Face3( 0, 4, 3 ),
 			new THREE.Face3( 0, 5, 4 ),
 			new THREE.Face3( 0, 6, 5 ),
 			new THREE.Face3( 0, 7, 6 ),
 			new THREE.Face3( 0, 8, 7 ),
 			new THREE.Face3( 0, 9, 8 ),
 			new THREE.Face3( 0, 10, 9 ),
 			new THREE.Face3( 0, 1, 10 ),
 			new THREE.Face3( 1, 12, 11 ),
 			new THREE.Face3( 1, 2, 12 ),
 			new THREE.Face3( 2, 13, 12 ),
 			new THREE.Face3( 2, 3, 13 ),
 			new THREE.Face3( 3, 14, 13 ),
 			new THREE.Face3( 3, 4, 14 ),
 			new THREE.Face3( 4, 15, 14 ),
 			new THREE.Face3( 4, 5, 15 ),
 			new THREE.Face3( 5, 16, 15 ),
 			new THREE.Face3( 5, 6, 16 ),
 			new THREE.Face3( 6, 17, 16 ),
 			new THREE.Face3( 6, 7, 17 ),
 			new THREE.Face3( 7, 18, 17 ),
 			new THREE.Face3( 7, 8, 18 ),
 			new THREE.Face3( 8, 19, 18 ),
 			new THREE.Face3( 8, 9, 19 ),
 			new THREE.Face3( 9, 20, 19 ),
 			new THREE.Face3( 9, 10, 20 ),
 			new THREE.Face3( 10, 11, 20 ),
 			new THREE.Face3( 10, 1, 11 ),
 			new THREE.Face3( 21, 11, 12 ),
 			new THREE.Face3( 21, 12, 13 ),
 			new THREE.Face3( 21, 13, 14 ),
 			new THREE.Face3( 21, 14, 15 ),
 			new THREE.Face3( 21, 15, 16 ),
 			new THREE.Face3( 21, 16, 17 ),
 			new THREE.Face3( 21, 17, 18 ),
 			new THREE.Face3( 21, 18, 19 ),
 			new THREE.Face3( 21, 19, 20 ),
 			new THREE.Face3( 21, 20, 11 )
 		);
 
 		geo_body.faceVertexUvs[0].push(
 			[
 				new THREE.Vector2( ((geo_body.vertices[0].x + bodyoffsetx) / bodyrangex ), ((geo_body.vertices[0].z + bodyoffsetz) / bodyrangez)),
 				new THREE.Vector2( ((geo_body.vertices[2].x + bodyoffsetx) / bodyrangex ), ((geo_body.vertices[2].z + bodyoffsetz) / bodyrangez)),
 				new THREE.Vector2( ((geo_body.vertices[1].x + bodyoffsetx) / bodyrangex ), ((geo_body.vertices[1].z + bodyoffsetz) / bodyrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_body.vertices[0].x + bodyoffsetx) / bodyrangex ), ((geo_body.vertices[0].z + bodyoffsetz) / bodyrangez)),
 				new THREE.Vector2( ((geo_body.vertices[3].x + bodyoffsetx) / bodyrangex ), ((geo_body.vertices[3].z + bodyoffsetz) / bodyrangez)),
 				new THREE.Vector2( ((geo_body.vertices[2].x + bodyoffsetx) / bodyrangex ), ((geo_body.vertices[2].z + bodyoffsetz) / bodyrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_body.vertices[0].x + bodyoffsetx) / bodyrangex ), ((geo_body.vertices[0].z + bodyoffsetz) / bodyrangez)),
 				new THREE.Vector2( ((geo_body.vertices[4].x + bodyoffsetx) / bodyrangex ), ((geo_body.vertices[4].z + bodyoffsetz) / bodyrangez)),
 				new THREE.Vector2( ((geo_body.vertices[3].x + bodyoffsetx) / bodyrangex ), ((geo_body.vertices[3].z + bodyoffsetz) / bodyrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_body.vertices[0].x + bodyoffsetx) / bodyrangex ), ((geo_body.vertices[0].z + bodyoffsetz) / bodyrangez)),
 				new THREE.Vector2( ((geo_body.vertices[5].x + bodyoffsetx) / bodyrangex ), ((geo_body.vertices[5].z + bodyoffsetz) / bodyrangez)),
 				new THREE.Vector2( ((geo_body.vertices[4].x + bodyoffsetx) / bodyrangex ), ((geo_body.vertices[4].z + bodyoffsetz) / bodyrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_body.vertices[0].x + bodyoffsetx) / bodyrangex ), ((geo_body.vertices[0].z + bodyoffsetz) / bodyrangez)),
 				new THREE.Vector2( ((geo_body.vertices[6].x + bodyoffsetx) / bodyrangex ), ((geo_body.vertices[6].z + bodyoffsetz) / bodyrangez)),
 				new THREE.Vector2( ((geo_body.vertices[5].x + bodyoffsetx) / bodyrangex ), ((geo_body.vertices[5].z + bodyoffsetz) / bodyrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_body.vertices[0].x + bodyoffsetx) / bodyrangex ), ((geo_body.vertices[0].z + bodyoffsetz) / bodyrangez)),
 				new THREE.Vector2( ((geo_body.vertices[7].x + bodyoffsetx) / bodyrangex ), ((geo_body.vertices[7].z + bodyoffsetz) / bodyrangez)),
 				new THREE.Vector2( ((geo_body.vertices[6].x + bodyoffsetx) / bodyrangex ), ((geo_body.vertices[6].z + bodyoffsetz) / bodyrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_body.vertices[0].x + bodyoffsetx) / bodyrangex ), ((geo_body.vertices[0].z + bodyoffsetz) / bodyrangez)),
 				new THREE.Vector2( ((geo_body.vertices[8].x + bodyoffsetx) / bodyrangex ), ((geo_body.vertices[8].z + bodyoffsetz) / bodyrangez)),
 				new THREE.Vector2( ((geo_body.vertices[7].x + bodyoffsetx) / bodyrangex ), ((geo_body.vertices[7].z + bodyoffsetz) / bodyrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_body.vertices[0].x + bodyoffsetx) / bodyrangex ), ((geo_body.vertices[0].z + bodyoffsetz) / bodyrangez)),
 				new THREE.Vector2( ((geo_body.vertices[9].x + bodyoffsetx) / bodyrangex ), ((geo_body.vertices[9].z + bodyoffsetz) / bodyrangez)),
 				new THREE.Vector2( ((geo_body.vertices[8].x + bodyoffsetx) / bodyrangex ), ((geo_body.vertices[8].z + bodyoffsetz) / bodyrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_body.vertices[0].x + bodyoffsetx) / bodyrangex ), ((geo_body.vertices[0].z + bodyoffsetz) / bodyrangez)),
 				new THREE.Vector2( ((geo_body.vertices[10].x + bodyoffsetx) / bodyrangex ), ((geo_body.vertices[10].z + bodyoffsetz) / bodyrangez)),
 				new THREE.Vector2( ((geo_body.vertices[9].x + bodyoffsetx) / bodyrangex ), ((geo_body.vertices[9].z + bodyoffsetz) / bodyrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_body.vertices[0].x + bodyoffsetx) / bodyrangex ), ((geo_body.vertices[0].z + bodyoffsetz) / bodyrangez)),
 				new THREE.Vector2( ((geo_body.vertices[1].x + bodyoffsetx) / bodyrangex ), ((geo_body.vertices[1].z + bodyoffsetz) / bodyrangez)),
 				new THREE.Vector2( ((geo_body.vertices[10].x + bodyoffsetx) / bodyrangex ), ((geo_body.vertices[10].z + bodyoffsetz) / bodyrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_body.vertices[1].x + bodyoffsetx) / bodyrangex ), ((geo_body.vertices[1].z + bodyoffsetz) / bodyrangez)),
 				new THREE.Vector2( ((geo_body.vertices[12].x + bodyoffsetx) / bodyrangex ), ((geo_body.vertices[12].z + bodyoffsetz) / bodyrangez)),
 				new THREE.Vector2( ((geo_body.vertices[11].x + bodyoffsetx) / bodyrangex ), ((geo_body.vertices[11].z + bodyoffsetz) / bodyrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_body.vertices[1].x + bodyoffsetx) / bodyrangex ), ((geo_body.vertices[1].z + bodyoffsetz) / bodyrangez)),
 				new THREE.Vector2( ((geo_body.vertices[2].x + bodyoffsetx) / bodyrangex ), ((geo_body.vertices[2].z + bodyoffsetz) / bodyrangez)),
 				new THREE.Vector2( ((geo_body.vertices[12].x + bodyoffsetx) / bodyrangex ), ((geo_body.vertices[12].z + bodyoffsetz) / bodyrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_body.vertices[2].x + bodyoffsetx) / bodyrangex ), ((geo_body.vertices[2].z + bodyoffsetz) / bodyrangez)),
 				new THREE.Vector2( ((geo_body.vertices[13].x + bodyoffsetx) / bodyrangex ), ((geo_body.vertices[13].z + bodyoffsetz) / bodyrangez)),
 				new THREE.Vector2( ((geo_body.vertices[12].x + bodyoffsetx) / bodyrangex ), ((geo_body.vertices[12].z + bodyoffsetz) / bodyrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_body.vertices[2].x + bodyoffsetx) / bodyrangex ), ((geo_body.vertices[2].z + bodyoffsetz) / bodyrangez)),
 				new THREE.Vector2( ((geo_body.vertices[3].x + bodyoffsetx) / bodyrangex ), ((geo_body.vertices[3].z + bodyoffsetz) / bodyrangez)),
 				new THREE.Vector2( ((geo_body.vertices[13].x + bodyoffsetx) / bodyrangex ), ((geo_body.vertices[13].z + bodyoffsetz) / bodyrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_body.vertices[3].x + bodyoffsetx) / bodyrangex ), ((geo_body.vertices[3].z + bodyoffsetz) / bodyrangez)),
 				new THREE.Vector2( ((geo_body.vertices[14].x + bodyoffsetx) / bodyrangex ), ((geo_body.vertices[14].z + bodyoffsetz) / bodyrangez)),
 				new THREE.Vector2( ((geo_body.vertices[13].x + bodyoffsetx) / bodyrangex ), ((geo_body.vertices[13].z + bodyoffsetz) / bodyrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_body.vertices[3].x + bodyoffsetx) / bodyrangex ), ((geo_body.vertices[3].z + bodyoffsetz) / bodyrangez)),
 				new THREE.Vector2( ((geo_body.vertices[4].x + bodyoffsetx) / bodyrangex ), ((geo_body.vertices[4].z + bodyoffsetz) / bodyrangez)),
 				new THREE.Vector2( ((geo_body.vertices[14].x + bodyoffsetx) / bodyrangex ), ((geo_body.vertices[14].z + bodyoffsetz) / bodyrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_body.vertices[4].x + bodyoffsetx) / bodyrangex ), ((geo_body.vertices[4].z + bodyoffsetz) / bodyrangez)),
 				new THREE.Vector2( ((geo_body.vertices[15].x + bodyoffsetx) / bodyrangex ), ((geo_body.vertices[15].z + bodyoffsetz) / bodyrangez)),
 				new THREE.Vector2( ((geo_body.vertices[14].x + bodyoffsetx) / bodyrangex ), ((geo_body.vertices[14].z + bodyoffsetz) / bodyrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_body.vertices[4].x + bodyoffsetx) / bodyrangex ), ((geo_body.vertices[4].z + bodyoffsetz) / bodyrangez)),
 				new THREE.Vector2( ((geo_body.vertices[5].x + bodyoffsetx) / bodyrangex ), ((geo_body.vertices[5].z + bodyoffsetz) / bodyrangez)),
 				new THREE.Vector2( ((geo_body.vertices[15].x + bodyoffsetx) / bodyrangex ), ((geo_body.vertices[15].z + bodyoffsetz) / bodyrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_body.vertices[5].x + bodyoffsetx) / bodyrangex ), ((geo_body.vertices[5].z + bodyoffsetz) / bodyrangez)),
 				new THREE.Vector2( ((geo_body.vertices[16].x + bodyoffsetx) / bodyrangex ), ((geo_body.vertices[16].z + bodyoffsetz) / bodyrangez)),
 				new THREE.Vector2( ((geo_body.vertices[15].x + bodyoffsetx) / bodyrangex ), ((geo_body.vertices[15].z + bodyoffsetz) / bodyrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_body.vertices[5].x + bodyoffsetx) / bodyrangex ), ((geo_body.vertices[5].z + bodyoffsetz) / bodyrangez)),
 				new THREE.Vector2( ((geo_body.vertices[6].x + bodyoffsetx) / bodyrangex ), ((geo_body.vertices[6].z + bodyoffsetz) / bodyrangez)),
 				new THREE.Vector2( ((geo_body.vertices[16].x + bodyoffsetx) / bodyrangex ), ((geo_body.vertices[16].z + bodyoffsetz) / bodyrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_body.vertices[6].x + bodyoffsetx) / bodyrangex ), ((geo_body.vertices[6].z + bodyoffsetz) / bodyrangez)),
 				new THREE.Vector2( ((geo_body.vertices[17].x + bodyoffsetx) / bodyrangex ), ((geo_body.vertices[17].z + bodyoffsetz) / bodyrangez)),
 				new THREE.Vector2( ((geo_body.vertices[16].x + bodyoffsetx) / bodyrangex ), ((geo_body.vertices[16].z + bodyoffsetz) / bodyrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_body.vertices[6].x + bodyoffsetx) / bodyrangex ), ((geo_body.vertices[6].z + bodyoffsetz) / bodyrangez)),
 				new THREE.Vector2( ((geo_body.vertices[7].x + bodyoffsetx) / bodyrangex ), ((geo_body.vertices[7].z + bodyoffsetz) / bodyrangez)),
 				new THREE.Vector2( ((geo_body.vertices[17].x + bodyoffsetx) / bodyrangex ), ((geo_body.vertices[17].z + bodyoffsetz) / bodyrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_body.vertices[7].x + bodyoffsetx) / bodyrangex ), ((geo_body.vertices[7].z + bodyoffsetz) / bodyrangez)),
 				new THREE.Vector2( ((geo_body.vertices[18].x + bodyoffsetx) / bodyrangex ), ((geo_body.vertices[18].z + bodyoffsetz) / bodyrangez)),
 				new THREE.Vector2( ((geo_body.vertices[17].x + bodyoffsetx) / bodyrangex ), ((geo_body.vertices[17].z + bodyoffsetz) / bodyrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_body.vertices[7].x + bodyoffsetx) / bodyrangex ), ((geo_body.vertices[7].z + bodyoffsetz) / bodyrangez)),
 				new THREE.Vector2( ((geo_body.vertices[8].x + bodyoffsetx) / bodyrangex ), ((geo_body.vertices[8].z + bodyoffsetz) / bodyrangez)),
 				new THREE.Vector2( ((geo_body.vertices[18].x + bodyoffsetx) / bodyrangex ), ((geo_body.vertices[18].z + bodyoffsetz) / bodyrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_body.vertices[8].x + bodyoffsetx) / bodyrangex ), ((geo_body.vertices[8].z + bodyoffsetz) / bodyrangez)),
 				new THREE.Vector2( ((geo_body.vertices[19].x + bodyoffsetx) / bodyrangex ), ((geo_body.vertices[19].z + bodyoffsetz) / bodyrangez)),
 				new THREE.Vector2( ((geo_body.vertices[18].x + bodyoffsetx) / bodyrangex ), ((geo_body.vertices[18].z + bodyoffsetz) / bodyrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_body.vertices[8].x + bodyoffsetx) / bodyrangex ), ((geo_body.vertices[8].z + bodyoffsetz) / bodyrangez)),
 				new THREE.Vector2( ((geo_body.vertices[9].x + bodyoffsetx) / bodyrangex ), ((geo_body.vertices[9].z + bodyoffsetz) / bodyrangez)),
 				new THREE.Vector2( ((geo_body.vertices[19].x + bodyoffsetx) / bodyrangex ), ((geo_body.vertices[19].z + bodyoffsetz) / bodyrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_body.vertices[9].x + bodyoffsetx) / bodyrangex ), ((geo_body.vertices[9].z + bodyoffsetz) / bodyrangez)),
 				new THREE.Vector2( ((geo_body.vertices[20].x + bodyoffsetx) / bodyrangex ), ((geo_body.vertices[20].z + bodyoffsetz) / bodyrangez)),
 				new THREE.Vector2( ((geo_body.vertices[19].x + bodyoffsetx) / bodyrangex ), ((geo_body.vertices[19].z + bodyoffsetz) / bodyrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_body.vertices[9].x + bodyoffsetx) / bodyrangex ), ((geo_body.vertices[9].z + bodyoffsetz) / bodyrangez)),
 				new THREE.Vector2( ((geo_body.vertices[10].x + bodyoffsetx) / bodyrangex ), ((geo_body.vertices[10].z + bodyoffsetz) / bodyrangez)),
 				new THREE.Vector2( ((geo_body.vertices[20].x + bodyoffsetx) / bodyrangex ), ((geo_body.vertices[20].z + bodyoffsetz) / bodyrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_body.vertices[10].x + bodyoffsetx) / bodyrangex ), ((geo_body.vertices[10].z + bodyoffsetz) / bodyrangez)),
 				new THREE.Vector2( ((geo_body.vertices[11].x + bodyoffsetx) / bodyrangex ), ((geo_body.vertices[11].z + bodyoffsetz) / bodyrangez)),
 				new THREE.Vector2( ((geo_body.vertices[20].x + bodyoffsetx) / bodyrangex ), ((geo_body.vertices[20].z + bodyoffsetz) / bodyrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_body.vertices[10].x + bodyoffsetx) / bodyrangex ), ((geo_body.vertices[10].z + bodyoffsetz) / bodyrangez)),
 				new THREE.Vector2( ((geo_body.vertices[1].x + bodyoffsetx) / bodyrangex ), ((geo_body.vertices[1].z + bodyoffsetz) / bodyrangez)),
 				new THREE.Vector2( ((geo_body.vertices[11].x + bodyoffsetx) / bodyrangex ), ((geo_body.vertices[11].z + bodyoffsetz) / bodyrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_body.vertices[21].x + bodyoffsetx) / bodyrangex ), ((geo_body.vertices[21].z + bodyoffsetz) / bodyrangez)),
 				new THREE.Vector2( ((geo_body.vertices[11].x + bodyoffsetx) / bodyrangex ), ((geo_body.vertices[11].z + bodyoffsetz) / bodyrangez)),
 				new THREE.Vector2( ((geo_body.vertices[12].x + bodyoffsetx) / bodyrangex ), ((geo_body.vertices[12].z + bodyoffsetz) / bodyrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_body.vertices[21].x + bodyoffsetx) / bodyrangex ), ((geo_body.vertices[21].z + bodyoffsetz) / bodyrangez)),
 				new THREE.Vector2( ((geo_body.vertices[12].x + bodyoffsetx) / bodyrangex ), ((geo_body.vertices[12].z + bodyoffsetz) / bodyrangez)),
 				new THREE.Vector2( ((geo_body.vertices[13].x + bodyoffsetx) / bodyrangex ), ((geo_body.vertices[13].z + bodyoffsetz) / bodyrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_body.vertices[21].x + bodyoffsetx) / bodyrangex ), ((geo_body.vertices[21].z + bodyoffsetz) / bodyrangez)),
 				new THREE.Vector2( ((geo_body.vertices[13].x + bodyoffsetx) / bodyrangex ), ((geo_body.vertices[13].z + bodyoffsetz) / bodyrangez)),
 				new THREE.Vector2( ((geo_body.vertices[14].x + bodyoffsetx) / bodyrangex ), ((geo_body.vertices[14].z + bodyoffsetz) / bodyrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_body.vertices[21].x + bodyoffsetx) / bodyrangex ), ((geo_body.vertices[21].z + bodyoffsetz) / bodyrangez)),
 				new THREE.Vector2( ((geo_body.vertices[14].x + bodyoffsetx) / bodyrangex ), ((geo_body.vertices[14].z + bodyoffsetz) / bodyrangez)),
 				new THREE.Vector2( ((geo_body.vertices[15].x + bodyoffsetx) / bodyrangex ), ((geo_body.vertices[15].z + bodyoffsetz) / bodyrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_body.vertices[21].x + bodyoffsetx) / bodyrangex ), ((geo_body.vertices[21].z + bodyoffsetz) / bodyrangez)),
 				new THREE.Vector2( ((geo_body.vertices[15].x + bodyoffsetx) / bodyrangex ), ((geo_body.vertices[15].z + bodyoffsetz) / bodyrangez)),
 				new THREE.Vector2( ((geo_body.vertices[16].x + bodyoffsetx) / bodyrangex ), ((geo_body.vertices[16].z + bodyoffsetz) / bodyrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_body.vertices[21].x + bodyoffsetx) / bodyrangex ), ((geo_body.vertices[21].z + bodyoffsetz) / bodyrangez)),
 				new THREE.Vector2( ((geo_body.vertices[16].x + bodyoffsetx) / bodyrangex ), ((geo_body.vertices[16].z + bodyoffsetz) / bodyrangez)),
 				new THREE.Vector2( ((geo_body.vertices[17].x + bodyoffsetx) / bodyrangex ), ((geo_body.vertices[17].z + bodyoffsetz) / bodyrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_body.vertices[21].x + bodyoffsetx) / bodyrangex ), ((geo_body.vertices[21].z + bodyoffsetz) / bodyrangez)),
 				new THREE.Vector2( ((geo_body.vertices[17].x + bodyoffsetx) / bodyrangex ), ((geo_body.vertices[17].z + bodyoffsetz) / bodyrangez)),
 				new THREE.Vector2( ((geo_body.vertices[18].x + bodyoffsetx) / bodyrangex ), ((geo_body.vertices[18].z + bodyoffsetz) / bodyrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_body.vertices[21].x + bodyoffsetx) / bodyrangex ), ((geo_body.vertices[21].z + bodyoffsetz) / bodyrangez)),
 				new THREE.Vector2( ((geo_body.vertices[18].x + bodyoffsetx) / bodyrangex ), ((geo_body.vertices[18].z + bodyoffsetz) / bodyrangez)),
 				new THREE.Vector2( ((geo_body.vertices[19].x + bodyoffsetx) / bodyrangex ), ((geo_body.vertices[19].z + bodyoffsetz) / bodyrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_body.vertices[21].x + bodyoffsetx) / bodyrangex ), ((geo_body.vertices[21].z + bodyoffsetz) / bodyrangez)),
 				new THREE.Vector2( ((geo_body.vertices[19].x + bodyoffsetx) / bodyrangex ), ((geo_body.vertices[19].z + bodyoffsetz) / bodyrangez)),
 				new THREE.Vector2( ((geo_body.vertices[20].x + bodyoffsetx) / bodyrangex ), ((geo_body.vertices[20].z + bodyoffsetz) / bodyrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_body.vertices[21].x + bodyoffsetx) / bodyrangex ), ((geo_body.vertices[21].z + bodyoffsetz) / bodyrangez)),
 				new THREE.Vector2( ((geo_body.vertices[20].x + bodyoffsetx) / bodyrangex ), ((geo_body.vertices[20].z + bodyoffsetz) / bodyrangez)),
 				new THREE.Vector2( ((geo_body.vertices[11].x + bodyoffsetx) / bodyrangex ), ((geo_body.vertices[11].z + bodyoffsetz) / bodyrangez))
 			]
 		);
 
 		geo_front.vertices.push( 
 			new THREE.Vector3( -0.439773,	 0.00019,	 0				),
 			new THREE.Vector3( -0.355783,	 0.00019,	 0.258492	),
 			new THREE.Vector3( -0.135898,	 0.00019,	 0.418248	),
 			new THREE.Vector3(  0.135898,	 0.00019,	 0.418248	),
 			new THREE.Vector3(  0.355783,	 0.00019,	 0.258492	),
 			new THREE.Vector3(  0.439770,	 0.00019,	 0				),
 			new THREE.Vector3(  0.355783,	 0.00019,	-0.25849		),
 			new THREE.Vector3(  0.135898,	 0.00019,	-0.418248	),
 			new THREE.Vector3( -0.135898,	 0.00019,	-0.418248	),
 			new THREE.Vector3( -0.355783,	 0.00019,	-0.25849		),
 			new THREE.Vector3( -0.336475,	 0.29717,	 0				),
 			new THREE.Vector3( -0.272215,	 0.29717,	 0.197775	),
 			new THREE.Vector3( -0.103978,	 0.29717,	 0.320007	),
 			new THREE.Vector3(  0.103975,	 0.29717,	 0.320007	),
 			new THREE.Vector3(  0.272213,	 0.29717,	 0.197775	),
 			new THREE.Vector3(  0.336475,	 0.29717,	 0				),
 			new THREE.Vector3(  0.272213,	 0.29717,	-0.197775	),
 			new THREE.Vector3(  0.103975,	 0.29717,	-0.320005	),
 			new THREE.Vector3( -0.103978,	 0.29717,	-0.320005	),
 			new THREE.Vector3( -0.272215,	 0.29717,	-0.197775	),
 			new THREE.Vector3(  0.000000,	 0.29717,	 0				),
 			new THREE.Vector3( -0.336475,	-0.29679,	 0				),
 			new THREE.Vector3( -0.272215,	-0.29679,	 0.197775	),
 			new THREE.Vector3( -0.103978,	-0.29679,	 0.320007	),
 			new THREE.Vector3(  0.103975,	-0.29679,	 0.320007	),
 			new THREE.Vector3(  0.272213,	-0.29679,	 0.197775	),
 			new THREE.Vector3(  0.336475,	-0.29679,	 0				),
 			new THREE.Vector3(  0.272213,	-0.29679,	-0.197775	),
 			new THREE.Vector3(  0.103975,	-0.29679,	-0.320005	),
 			new THREE.Vector3( -0.103978,	-0.29679,	-0.320005	),
 			new THREE.Vector3( -0.272215,	-0.29679,	-0.197775	),
 			new THREE.Vector3(  0.000000,	-0.29679,	 0				)
 		);
 
 	//x & z
 	var frontrangex = (-0.439773 - 0.439770) * -1; 	//range = (lowest - highest) * -1
 	var frontoffsetx = 0 - -0.439773;						//offset = 0 - lowest
 	var frontrangez = (-0.418248 - 0.418248) * -1;
 	var frontoffsetz = 0 - -0.418248;
 
 
 		geo_front.faces.push( 
 			new THREE.Face3( 	 0,	11,	10	),
 			new THREE.Face3( 	 0,	 1,	11	),
 			new THREE.Face3( 	 1,	12,	11	),
 			new THREE.Face3( 	 1,	 2,	12	),
 			new THREE.Face3( 	 2,	13,	12	),
 			new THREE.Face3( 	 2,	 3,	13	),
 			new THREE.Face3( 	 3,	14,	13	),
 			new THREE.Face3( 	 3,	 4,	14	),
 			new THREE.Face3( 	 4,	15,	14	),
 			new THREE.Face3( 	 4,	 5,	15	),
 			new THREE.Face3( 	 5,	16,	15	),
 			new THREE.Face3( 	 5,	 6,	16	),
 			new THREE.Face3( 	 6,	17,	16	),
 			new THREE.Face3( 	 6,	 7,	17	),
 			new THREE.Face3( 	 7,	18,	17	),
 			new THREE.Face3( 	 7,	 8,	18	),
 			new THREE.Face3( 	 8,	19,	18	),
 			new THREE.Face3( 	 8,	 9,	19	),
 			new THREE.Face3( 	 9,	10,	19	),
 			new THREE.Face3( 	 9,	 0,	10	),
 			new THREE.Face3( 	20,	10,	11	),
 			new THREE.Face3( 	20,	11,	12	),
 			new THREE.Face3( 	20,	12,	13	),
 			new THREE.Face3( 	20,	13,	14	),
 			new THREE.Face3( 	20,	14,	15	),
 			new THREE.Face3( 	20,	15,	16	),
 			new THREE.Face3( 	20,	16,	17	),
 			new THREE.Face3( 	20,	17,	18	),
 			new THREE.Face3( 	20,	18,	19	),
 			new THREE.Face3( 	20,	19,	10	),
 			new THREE.Face3( 	21,	22,	0	),
 			new THREE.Face3( 	22,	 1,	0	),
 			new THREE.Face3( 	22,	23,	1	),
 			new THREE.Face3( 	23,	 2,	1	),
 			new THREE.Face3( 	23,	24,	2	),
 			new THREE.Face3( 	24,	 3,	2	),
 			new THREE.Face3( 	24,	25,	3	),
 			new THREE.Face3( 	25,	 4,	3	),
 			new THREE.Face3( 	25,	26,	4	),
 			new THREE.Face3( 	26,	 5,	4	),
 			new THREE.Face3( 	26,	27,	5	),
 			new THREE.Face3( 	27,	 6,	5	),
 			new THREE.Face3( 	27,	28,	6	),
 			new THREE.Face3( 	28,	 7,	6	),
 			new THREE.Face3( 	28,	29,	7	),
 			new THREE.Face3( 	29,	 8,	7	),
 			new THREE.Face3( 	29,	30,	8	),
 			new THREE.Face3( 	30,	 9,	8	),
 			new THREE.Face3( 	30,	21,	9	),
 			new THREE.Face3( 	21,	 0,	9	),
 			new THREE.Face3( 	22,	21,	31	),
 			new THREE.Face3( 	23,	22,	31	),
 			new THREE.Face3( 	24,	23,	31	),
 			new THREE.Face3( 	25,	24,	31	),
 			new THREE.Face3( 	26,	25,	31	),
 			new THREE.Face3( 	27,	26,	31	),
 			new THREE.Face3( 	28,	27,	31	),
 			new THREE.Face3( 	29,	28,	31	),
 			new THREE.Face3( 	30,	29,	31	),
 			new THREE.Face3( 	21,	30,	31	)
 		);
 		
 		geo_front.faceVertexUvs[0].push(
 			[
 				new THREE.Vector2( ((geo_front.vertices[0].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[0].z + frontoffsetz) / frontrangez)),
 				new THREE.Vector2( ((geo_front.vertices[11].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[11].z + frontoffsetz) / frontrangez)),
 				new THREE.Vector2( ((geo_front.vertices[10].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[10].z + frontoffsetz) / frontrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_front.vertices[0].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[0].z + frontoffsetz) / frontrangez)),
 				new THREE.Vector2( ((geo_front.vertices[1].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[1].z + frontoffsetz) / frontrangez)),
 				new THREE.Vector2( ((geo_front.vertices[11].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[11].z + frontoffsetz) / frontrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_front.vertices[1].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[1].z + frontoffsetz) / frontrangez)),
 				new THREE.Vector2( ((geo_front.vertices[12].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[12].z + frontoffsetz) / frontrangez)),
 				new THREE.Vector2( ((geo_front.vertices[11].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[11].z + frontoffsetz) / frontrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_front.vertices[1].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[1].z + frontoffsetz) / frontrangez)),
 				new THREE.Vector2( ((geo_front.vertices[2].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[2].z + frontoffsetz) / frontrangez)),
 				new THREE.Vector2( ((geo_front.vertices[12].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[12].z + frontoffsetz) / frontrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_front.vertices[2].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[2].z + frontoffsetz) / frontrangez)),
 				new THREE.Vector2( ((geo_front.vertices[13].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[13].z + frontoffsetz) / frontrangez)),
 				new THREE.Vector2( ((geo_front.vertices[12].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[12].z + frontoffsetz) / frontrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_front.vertices[2].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[2].z + frontoffsetz) / frontrangez)),
 				new THREE.Vector2( ((geo_front.vertices[3].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[3].z + frontoffsetz) / frontrangez)),
 				new THREE.Vector2( ((geo_front.vertices[13].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[13].z + frontoffsetz) / frontrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_front.vertices[3].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[3].z + frontoffsetz) / frontrangez)),
 				new THREE.Vector2( ((geo_front.vertices[14].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[14].z + frontoffsetz) / frontrangez)),
 				new THREE.Vector2( ((geo_front.vertices[13].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[13].z + frontoffsetz) / frontrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_front.vertices[3].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[3].z + frontoffsetz) / frontrangez)),
 				new THREE.Vector2( ((geo_front.vertices[4].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[4].z + frontoffsetz) / frontrangez)),
 				new THREE.Vector2( ((geo_front.vertices[14].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[14].z + frontoffsetz) / frontrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_front.vertices[4].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[4].z + frontoffsetz) / frontrangez)),
 				new THREE.Vector2( ((geo_front.vertices[15].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[15].z + frontoffsetz) / frontrangez)),
 				new THREE.Vector2( ((geo_front.vertices[14].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[14].z + frontoffsetz) / frontrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_front.vertices[4].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[4].z + frontoffsetz) / frontrangez)),
 				new THREE.Vector2( ((geo_front.vertices[5].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[5].z + frontoffsetz) / frontrangez)),
 				new THREE.Vector2( ((geo_front.vertices[15].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[15].z + frontoffsetz) / frontrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_front.vertices[5].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[5].z + frontoffsetz) / frontrangez)),
 				new THREE.Vector2( ((geo_front.vertices[16].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[16].z + frontoffsetz) / frontrangez)),
 				new THREE.Vector2( ((geo_front.vertices[15].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[15].z + frontoffsetz) / frontrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_front.vertices[5].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[5].z + frontoffsetz) / frontrangez)),
 				new THREE.Vector2( ((geo_front.vertices[6].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[6].z + frontoffsetz) / frontrangez)),
 				new THREE.Vector2( ((geo_front.vertices[16].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[16].z + frontoffsetz) / frontrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_front.vertices[6].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[6].z + frontoffsetz) / frontrangez)),
 				new THREE.Vector2( ((geo_front.vertices[17].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[17].z + frontoffsetz) / frontrangez)),
 				new THREE.Vector2( ((geo_front.vertices[16].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[16].z + frontoffsetz) / frontrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_front.vertices[6].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[6].z + frontoffsetz) / frontrangez)),
 				new THREE.Vector2( ((geo_front.vertices[7].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[7].z + frontoffsetz) / frontrangez)),
 				new THREE.Vector2( ((geo_front.vertices[17].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[17].z + frontoffsetz) / frontrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_front.vertices[7].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[7].z + frontoffsetz) / frontrangez)),
 				new THREE.Vector2( ((geo_front.vertices[18].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[18].z + frontoffsetz) / frontrangez)),
 				new THREE.Vector2( ((geo_front.vertices[17].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[17].z + frontoffsetz) / frontrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_front.vertices[7].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[7].z + frontoffsetz) / frontrangez)),
 				new THREE.Vector2( ((geo_front.vertices[8].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[8].z + frontoffsetz) / frontrangez)),
 				new THREE.Vector2( ((geo_front.vertices[18].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[18].z + frontoffsetz) / frontrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_front.vertices[8].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[8].z + frontoffsetz) / frontrangez)),
 				new THREE.Vector2( ((geo_front.vertices[19].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[19].z + frontoffsetz) / frontrangez)),
 				new THREE.Vector2( ((geo_front.vertices[18].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[18].z + frontoffsetz) / frontrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_front.vertices[8].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[8].z + frontoffsetz) / frontrangez)),
 				new THREE.Vector2( ((geo_front.vertices[9].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[9].z + frontoffsetz) / frontrangez)),
 				new THREE.Vector2( ((geo_front.vertices[19].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[19].z + frontoffsetz) / frontrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_front.vertices[9].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[9].z + frontoffsetz) / frontrangez)),
 				new THREE.Vector2( ((geo_front.vertices[10].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[10].z + frontoffsetz) / frontrangez)),
 				new THREE.Vector2( ((geo_front.vertices[19].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[19].z + frontoffsetz) / frontrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_front.vertices[9].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[9].z + frontoffsetz) / frontrangez)),
 				new THREE.Vector2( ((geo_front.vertices[0].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[0].z + frontoffsetz) / frontrangez)),
 				new THREE.Vector2( ((geo_front.vertices[10].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[10].z + frontoffsetz) / frontrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_front.vertices[20].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[20].z + frontoffsetz) / frontrangez)),
 				new THREE.Vector2( ((geo_front.vertices[10].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[10].z + frontoffsetz) / frontrangez)),
 				new THREE.Vector2( ((geo_front.vertices[11].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[11].z + frontoffsetz) / frontrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_front.vertices[20].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[20].z + frontoffsetz) / frontrangez)),
 				new THREE.Vector2( ((geo_front.vertices[11].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[11].z + frontoffsetz) / frontrangez)),
 				new THREE.Vector2( ((geo_front.vertices[12].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[12].z + frontoffsetz) / frontrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_front.vertices[20].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[20].z + frontoffsetz) / frontrangez)),
 				new THREE.Vector2( ((geo_front.vertices[12].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[12].z + frontoffsetz) / frontrangez)),
 				new THREE.Vector2( ((geo_front.vertices[13].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[13].z + frontoffsetz) / frontrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_front.vertices[20].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[20].z + frontoffsetz) / frontrangez)),
 				new THREE.Vector2( ((geo_front.vertices[13].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[13].z + frontoffsetz) / frontrangez)),
 				new THREE.Vector2( ((geo_front.vertices[14].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[14].z + frontoffsetz) / frontrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_front.vertices[20].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[20].z + frontoffsetz) / frontrangez)),
 				new THREE.Vector2( ((geo_front.vertices[14].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[14].z + frontoffsetz) / frontrangez)),
 				new THREE.Vector2( ((geo_front.vertices[15].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[15].z + frontoffsetz) / frontrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_front.vertices[20].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[20].z + frontoffsetz) / frontrangez)),
 				new THREE.Vector2( ((geo_front.vertices[15].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[15].z + frontoffsetz) / frontrangez)),
 				new THREE.Vector2( ((geo_front.vertices[16].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[16].z + frontoffsetz) / frontrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_front.vertices[20].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[20].z + frontoffsetz) / frontrangez)),
 				new THREE.Vector2( ((geo_front.vertices[16].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[16].z + frontoffsetz) / frontrangez)),
 				new THREE.Vector2( ((geo_front.vertices[17].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[17].z + frontoffsetz) / frontrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_front.vertices[20].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[20].z + frontoffsetz) / frontrangez)),
 				new THREE.Vector2( ((geo_front.vertices[17].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[17].z + frontoffsetz) / frontrangez)),
 				new THREE.Vector2( ((geo_front.vertices[18].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[18].z + frontoffsetz) / frontrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_front.vertices[20].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[20].z + frontoffsetz) / frontrangez)),
 				new THREE.Vector2( ((geo_front.vertices[18].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[18].z + frontoffsetz) / frontrangez)),
 				new THREE.Vector2( ((geo_front.vertices[19].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[19].z + frontoffsetz) / frontrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_front.vertices[20].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[20].z + frontoffsetz) / frontrangez)),
 				new THREE.Vector2( ((geo_front.vertices[19].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[19].z + frontoffsetz) / frontrangez)),
 				new THREE.Vector2( ((geo_front.vertices[10].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[10].z + frontoffsetz) / frontrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_front.vertices[21].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[21].z + frontoffsetz) / frontrangez)),
 				new THREE.Vector2( ((geo_front.vertices[22].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[22].z + frontoffsetz) / frontrangez)),
 				new THREE.Vector2( ((geo_front.vertices[0].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[0].z + frontoffsetz) / frontrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_front.vertices[22].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[22].z + frontoffsetz) / frontrangez)),
 				new THREE.Vector2( ((geo_front.vertices[1].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[1].z + frontoffsetz) / frontrangez)),
 				new THREE.Vector2( ((geo_front.vertices[0].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[0].z + frontoffsetz) / frontrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_front.vertices[22].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[22].z + frontoffsetz) / frontrangez)),
 				new THREE.Vector2( ((geo_front.vertices[23].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[23].z + frontoffsetz) / frontrangez)),
 				new THREE.Vector2( ((geo_front.vertices[1].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[1].z + frontoffsetz) / frontrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_front.vertices[23].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[23].z + frontoffsetz) / frontrangez)),
 				new THREE.Vector2( ((geo_front.vertices[2].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[2].z + frontoffsetz) / frontrangez)),
 				new THREE.Vector2( ((geo_front.vertices[1].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[1].z + frontoffsetz) / frontrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_front.vertices[23].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[23].z + frontoffsetz) / frontrangez)),
 				new THREE.Vector2( ((geo_front.vertices[24].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[24].z + frontoffsetz) / frontrangez)),
 				new THREE.Vector2( ((geo_front.vertices[2].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[2].z + frontoffsetz) / frontrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_front.vertices[24].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[24].z + frontoffsetz) / frontrangez)),
 				new THREE.Vector2( ((geo_front.vertices[3].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[3].z + frontoffsetz) / frontrangez)),
 				new THREE.Vector2( ((geo_front.vertices[2].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[2].z + frontoffsetz) / frontrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_front.vertices[24].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[24].z + frontoffsetz) / frontrangez)),
 				new THREE.Vector2( ((geo_front.vertices[25].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[25].z + frontoffsetz) / frontrangez)),
 				new THREE.Vector2( ((geo_front.vertices[3].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[3].z + frontoffsetz) / frontrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_front.vertices[25].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[25].z + frontoffsetz) / frontrangez)),
 				new THREE.Vector2( ((geo_front.vertices[4].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[4].z + frontoffsetz) / frontrangez)),
 				new THREE.Vector2( ((geo_front.vertices[3].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[3].z + frontoffsetz) / frontrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_front.vertices[25].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[25].z + frontoffsetz) / frontrangez)),
 				new THREE.Vector2( ((geo_front.vertices[26].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[26].z + frontoffsetz) / frontrangez)),
 				new THREE.Vector2( ((geo_front.vertices[4].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[4].z + frontoffsetz) / frontrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_front.vertices[26].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[26].z + frontoffsetz) / frontrangez)),
 				new THREE.Vector2( ((geo_front.vertices[5].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[5].z + frontoffsetz) / frontrangez)),
 				new THREE.Vector2( ((geo_front.vertices[4].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[4].z + frontoffsetz) / frontrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_front.vertices[26].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[26].z + frontoffsetz) / frontrangez)),
 				new THREE.Vector2( ((geo_front.vertices[27].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[27].z + frontoffsetz) / frontrangez)),
 				new THREE.Vector2( ((geo_front.vertices[5].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[5].z + frontoffsetz) / frontrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_front.vertices[27].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[27].z + frontoffsetz) / frontrangez)),
 				new THREE.Vector2( ((geo_front.vertices[6].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[6].z + frontoffsetz) / frontrangez)),
 				new THREE.Vector2( ((geo_front.vertices[5].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[5].z + frontoffsetz) / frontrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_front.vertices[27].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[27].z + frontoffsetz) / frontrangez)),
 				new THREE.Vector2( ((geo_front.vertices[28].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[28].z + frontoffsetz) / frontrangez)),
 				new THREE.Vector2( ((geo_front.vertices[6].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[6].z + frontoffsetz) / frontrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_front.vertices[28].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[28].z + frontoffsetz) / frontrangez)),
 				new THREE.Vector2( ((geo_front.vertices[7].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[7].z + frontoffsetz) / frontrangez)),
 				new THREE.Vector2( ((geo_front.vertices[6].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[6].z + frontoffsetz) / frontrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_front.vertices[28].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[28].z + frontoffsetz) / frontrangez)),
 				new THREE.Vector2( ((geo_front.vertices[29].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[29].z + frontoffsetz) / frontrangez)),
 				new THREE.Vector2( ((geo_front.vertices[7].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[7].z + frontoffsetz) / frontrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_front.vertices[29].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[29].z + frontoffsetz) / frontrangez)),
 				new THREE.Vector2( ((geo_front.vertices[8].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[8].z + frontoffsetz) / frontrangez)),
 				new THREE.Vector2( ((geo_front.vertices[7].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[7].z + frontoffsetz) / frontrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_front.vertices[29].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[29].z + frontoffsetz) / frontrangez)),
 				new THREE.Vector2( ((geo_front.vertices[30].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[30].z + frontoffsetz) / frontrangez)),
 				new THREE.Vector2( ((geo_front.vertices[8].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[8].z + frontoffsetz) / frontrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_front.vertices[30].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[30].z + frontoffsetz) / frontrangez)),
 				new THREE.Vector2( ((geo_front.vertices[9].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[9].z + frontoffsetz) / frontrangez)),
 				new THREE.Vector2( ((geo_front.vertices[8].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[8].z + frontoffsetz) / frontrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_front.vertices[30].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[30].z + frontoffsetz) / frontrangez)),
 				new THREE.Vector2( ((geo_front.vertices[21].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[21].z + frontoffsetz) / frontrangez)),
 				new THREE.Vector2( ((geo_front.vertices[9].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[9].z + frontoffsetz) / frontrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_front.vertices[21].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[21].z + frontoffsetz) / frontrangez)),
 				new THREE.Vector2( ((geo_front.vertices[0].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[0].z + frontoffsetz) / frontrangez)),
 				new THREE.Vector2( ((geo_front.vertices[9].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[9].z + frontoffsetz) / frontrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_front.vertices[22].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[22].z + frontoffsetz) / frontrangez)),
 				new THREE.Vector2( ((geo_front.vertices[21].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[21].z + frontoffsetz) / frontrangez)),
 				new THREE.Vector2( ((geo_front.vertices[31].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[31].z + frontoffsetz) / frontrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_front.vertices[23].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[23].z + frontoffsetz) / frontrangez)),
 				new THREE.Vector2( ((geo_front.vertices[22].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[22].z + frontoffsetz) / frontrangez)),
 				new THREE.Vector2( ((geo_front.vertices[31].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[31].z + frontoffsetz) / frontrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_front.vertices[24].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[24].z + frontoffsetz) / frontrangez)),
 				new THREE.Vector2( ((geo_front.vertices[23].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[23].z + frontoffsetz) / frontrangez)),
 				new THREE.Vector2( ((geo_front.vertices[31].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[31].z + frontoffsetz) / frontrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_front.vertices[25].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[25].z + frontoffsetz) / frontrangez)),
 				new THREE.Vector2( ((geo_front.vertices[24].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[24].z + frontoffsetz) / frontrangez)),
 				new THREE.Vector2( ((geo_front.vertices[31].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[31].z + frontoffsetz) / frontrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_front.vertices[26].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[26].z + frontoffsetz) / frontrangez)),
 				new THREE.Vector2( ((geo_front.vertices[25].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[25].z + frontoffsetz) / frontrangez)),
 				new THREE.Vector2( ((geo_front.vertices[31].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[31].z + frontoffsetz) / frontrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_front.vertices[27].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[27].z + frontoffsetz) / frontrangez)),
 				new THREE.Vector2( ((geo_front.vertices[26].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[26].z + frontoffsetz) / frontrangez)),
 				new THREE.Vector2( ((geo_front.vertices[31].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[31].z + frontoffsetz) / frontrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_front.vertices[28].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[28].z + frontoffsetz) / frontrangez)),
 				new THREE.Vector2( ((geo_front.vertices[27].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[27].z + frontoffsetz) / frontrangez)),
 				new THREE.Vector2( ((geo_front.vertices[31].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[31].z + frontoffsetz) / frontrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_front.vertices[29].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[29].z + frontoffsetz) / frontrangez)),
 				new THREE.Vector2( ((geo_front.vertices[28].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[28].z + frontoffsetz) / frontrangez)),
 				new THREE.Vector2( ((geo_front.vertices[31].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[31].z + frontoffsetz) / frontrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_front.vertices[30].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[30].z + frontoffsetz) / frontrangez)),
 				new THREE.Vector2( ((geo_front.vertices[29].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[29].z + frontoffsetz) / frontrangez)),
 				new THREE.Vector2( ((geo_front.vertices[31].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[31].z + frontoffsetz) / frontrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_front.vertices[21].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[21].z + frontoffsetz) / frontrangez)),
 				new THREE.Vector2( ((geo_front.vertices[30].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[30].z + frontoffsetz) / frontrangez)),
 				new THREE.Vector2( ((geo_front.vertices[31].x + frontoffsetx) / frontrangex ), ((geo_front.vertices[31].z + frontoffsetz) / frontrangez))
 			]
 		);
 
 		geo_back.vertices.push( 
 			new THREE.Vector3( 	0.0004475,		0.00019,		0.0002975	),
 			new THREE.Vector3(  -0.7435,			0.00019,		0.0002975	),
 			new THREE.Vector3(  -0.601417,		0.00019,		0.43758	),
 			new THREE.Vector3(  -0.229445,		0.00019,		0.707835	),
 			new THREE.Vector3( 	0.230340,		0.00019,		0.707835	),
 			new THREE.Vector3( 	0.602315,		0.00019,		0.43758	),
 			new THREE.Vector3( 	0.744397,		0.00019,		0.0002975	),
 			new THREE.Vector3( 	0.602315,		0.00019,		-0.436985	),
 			new THREE.Vector3( 	0.23034,			0.00019,		-0.70724	),
 			new THREE.Vector3(  -0.229445,		0.00019,		-0.70724	),
 			new THREE.Vector3(  -0.601417,		0.00019,		-0.436985	),
 			new THREE.Vector3(  -0.568755,		0.29717,		0.0002975	),
 			new THREE.Vector3(  -0.460047,		0.29717,		0.334868	),
 			new THREE.Vector3(  -0.175445,		0.29717,		0.541643	),
 			new THREE.Vector3( 	0.176342,		0.29717,		0.541643	),
 			new THREE.Vector3( 	0.460945,		0.29717,		0.334868	),
 			new THREE.Vector3( 	0.569653,		0.29717,		0.0002975	),
 			new THREE.Vector3( 	0.460945,		0.29717,		-0.334273	),
 			new THREE.Vector3( 	0.176342,		0.29717,		-0.541047	),
 			new THREE.Vector3(  -0.175445,		0.29717,		-0.541047	),
 			new THREE.Vector3(  -0.460047,		0.29717,		-0.334273	),
 			new THREE.Vector3( 	0.0004475,		0.29717,		0.0002975	),
 			new THREE.Vector3(  -0.568755,		-0.29679,		0.0002975	),
 			new THREE.Vector3(  -0.460047,		-0.29679,		0.334868	),
 			new THREE.Vector3(  -0.175445,		-0.29679,		0.541643	),
 			new THREE.Vector3( 	0.176342,		-0.29679,		0.541643	),
 			new THREE.Vector3( 	0.460945,		-0.29679,		0.334868	),
 			new THREE.Vector3( 	0.569653,		-0.29679,		0.0002975	),
 			new THREE.Vector3( 	0.460945,		-0.29679,		-0.334273	),
 			new THREE.Vector3( 	0.176342,		-0.29679,		-0.541047	),
 			new THREE.Vector3(  -0.175445,		-0.29679,		-0.541047	),
 			new THREE.Vector3(  -0.460047,		-0.29679,		-0.334273	),
 			new THREE.Vector3( 	0.0004475,		-0.29679,		0.0002975	)
 		);
 
 	//x & z
 	var backrangex = (-0.7435 - 0.744397) * -1; 	//range = (lowest - highest) * -1
 	var backoffsetx = 0 - -0.7435;						//offset = 0 - lowest
 	var backrangez = (-0.70724 - 0.707835) * -1;
 	var backoffsetz = 0 - -0.70724;
 
 		geo_back.faces.push( 
 			new THREE.Face3( 	  0,		 2,		 1	),
 			new THREE.Face3( 	  0,		 3,		 2	),
 			new THREE.Face3( 	  0,		 4,		 3	),
 			new THREE.Face3( 	  0,		 5,		 4	),
 			new THREE.Face3( 	  0,		 6,		 5	),
 			new THREE.Face3( 	  0,		 7,		 6	),
 			new THREE.Face3( 	  0,		 8,		 7	),
 			new THREE.Face3( 	  0,		 9,		 8	),
 			new THREE.Face3( 	  0,		10,		 9	),
 			new THREE.Face3( 	  0,		 1,		10	),
 			new THREE.Face3( 	  1,		12,		11	),
 			new THREE.Face3( 	  1,		 2,		12	),
 			new THREE.Face3( 	  2,		13,		12	),
 			new THREE.Face3( 	  2,		 3,		13	),
 			new THREE.Face3( 	  3,		14,		13	),
 			new THREE.Face3( 	  3,		 4,		14	),
 			new THREE.Face3( 	  4,		15,		14	),
 			new THREE.Face3( 	  4,		 5,		15	),
 			new THREE.Face3( 	  5,		16,		15	),
 			new THREE.Face3( 	  5,		 6,		16	),
 			new THREE.Face3( 	  6,		17,		16	),
 			new THREE.Face3( 	  6,		 7,		17	),
 			new THREE.Face3( 	  7,		18,		17	),
 			new THREE.Face3( 	  7,		 8,		18	),
 			new THREE.Face3( 	  8,		19,		18	),
 			new THREE.Face3( 	  8,		 9,		19	),
 			new THREE.Face3( 	  9,		20,		19	),
 			new THREE.Face3( 	  9,		10,		20	),
 			new THREE.Face3( 	 10,		11,		20	),
 			new THREE.Face3( 	 10,		 1,		11	),
 			new THREE.Face3( 	 21,		11,		12	),
 			new THREE.Face3( 	 21,		12,		13	),
 			new THREE.Face3( 	 21,		13,		14	),
 			new THREE.Face3( 	 21,		14,		15	),
 			new THREE.Face3( 	 21,		15,		16	),
 			new THREE.Face3( 	 21,		16,		17	),
 			new THREE.Face3( 	 21,		17,		18	),
 			new THREE.Face3( 	 21,		18,		19	),
 			new THREE.Face3( 	 21,		19,		20	),
 			new THREE.Face3( 	 21,		20,		11	),
 			new THREE.Face3( 	  1,		 2,		 0	),
 			new THREE.Face3( 	  2,		 3,		 0	),
 			new THREE.Face3( 	  3,		 4,		 0	),
 			new THREE.Face3( 	  4,		 5,		 0	),		
 			new THREE.Face3( 	  5,		 6,		 0	),
 			new THREE.Face3( 	  6,		 7,		 0	),
 			new THREE.Face3( 	  7,		 8,		 0	),
 			new THREE.Face3( 	  8,		 9,		 0	),
 			new THREE.Face3( 	  9,		10,		 0	),
 			new THREE.Face3( 	 10,		 1,		 0	),
 			new THREE.Face3( 	 22,		23,		 1	),
 			new THREE.Face3( 	 23,		 2,		 1	),
 			new THREE.Face3( 	 23,		24,		 2	),
 			new THREE.Face3( 	 24,		 3,		 2	),
 			new THREE.Face3( 	 24,		25,		 3	),
 			new THREE.Face3( 	 25,		 4,		 3	),
 			new THREE.Face3( 	 25,		26,		 4	),
 			new THREE.Face3( 	 26,		 5,		 4	),
 			new THREE.Face3( 	 26,		27,	 	 5	),
 			new THREE.Face3( 	 27,		 6, 		 5	),
 			new THREE.Face3( 	 27,		28,		 6	),
 			new THREE.Face3( 	 28,		 7,		 6	),
 			new THREE.Face3( 	 28,		29,		 7	),
 			new THREE.Face3( 	 29,		 8,		 7	),
 			new THREE.Face3( 	 29,		30,		 8	),
 			new THREE.Face3( 	 30,		 9,		 8	),
 			new THREE.Face3( 	 30,		31,		 9	),
 			new THREE.Face3( 	 31,		10,		 9	),
 			new THREE.Face3( 	 31,		22,		10	),
 			new THREE.Face3( 	 22,		 1,		10	),
 			new THREE.Face3( 	 23,		22,		32	),
 			new THREE.Face3( 	 24,		23,		32	),
 			new THREE.Face3( 	 25,		24,		32	),
 			new THREE.Face3( 	 26,		25,		32	),
 			new THREE.Face3( 	 27,		26,		32	),
 			new THREE.Face3( 	 28,		27,		32	),
 			new THREE.Face3( 	 29,		28,		32	),
 			new THREE.Face3( 	 30,		29,		32	),
 			new THREE.Face3( 	 31,		30,		32	),
 			new THREE.Face3( 	 22,		31,		32	)
 		);
 
 		geo_back.faceVertexUvs[0].push(
 			[
 				new THREE.Vector2( ((geo_back.vertices[0].x + backoffsetx) / backrangex ), 		((geo_back.vertices[0].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[2].x + backoffsetx) / backrangex ), 		((geo_back.vertices[2].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[1].x + backoffsetx) / backrangex ), 		((geo_back.vertices[1].z + backoffsetz) / backrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_back.vertices[0].x + backoffsetx) / backrangex ), 		((geo_back.vertices[0].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[3].x + backoffsetx) / backrangex ), 		((geo_back.vertices[3].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[2].x + backoffsetx) / backrangex ), 		((geo_back.vertices[3].z + backoffsetz) / backrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_back.vertices[0].x + backoffsetx) / backrangex ), 		((geo_back.vertices[0].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[4].x + backoffsetx) / backrangex ), 		((geo_back.vertices[4].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[3].x + backoffsetx) / backrangex ), 		((geo_back.vertices[3].z + backoffsetz) / backrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_back.vertices[0].x + backoffsetx) / backrangex ), 		((geo_back.vertices[0].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[5].x + backoffsetx) / backrangex ), 		((geo_back.vertices[5].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[4].x + backoffsetx) / backrangex ), 		((geo_back.vertices[4].z + backoffsetz) / backrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_back.vertices[0].x + backoffsetx) / backrangex ), 		((geo_back.vertices[0].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[6].x + backoffsetx) / backrangex ), 		((geo_back.vertices[6].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[5].x + backoffsetx) / backrangex ), 		((geo_back.vertices[5].z + backoffsetz) / backrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_back.vertices[0].x + backoffsetx) / backrangex ), 		((geo_back.vertices[0].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[7].x + backoffsetx) / backrangex ), 		((geo_back.vertices[7].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[6].x + backoffsetx) / backrangex ), 		((geo_back.vertices[6].z + backoffsetz) / backrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_back.vertices[0].x + backoffsetx) / backrangex ), 		((geo_back.vertices[0].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[8].x + backoffsetx) / backrangex ), 		((geo_back.vertices[8].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[7].x + backoffsetx) / backrangex ), 		((geo_back.vertices[7].z + backoffsetz) / backrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_back.vertices[0].x + backoffsetx) / backrangex ), 		((geo_back.vertices[0].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[9].x + backoffsetx) / backrangex ), 		((geo_back.vertices[9].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[8].x + backoffsetx) / backrangex ), 		((geo_back.vertices[8].z + backoffsetz) / backrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_back.vertices[0].x + backoffsetx) / backrangex ), 		((geo_back.vertices[0].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[10].x + backoffsetx) / backrangex ), 		((geo_back.vertices[10].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[9].x + backoffsetx) / backrangex ), 		((geo_back.vertices[9].z + backoffsetz) / backrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_back.vertices[0].x + backoffsetx) / backrangex ), 		((geo_back.vertices[0].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[1].x + backoffsetx) / backrangex ), 		((geo_back.vertices[1].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[10].x + backoffsetx) / backrangex ), 		((geo_back.vertices[10].z + backoffsetz) / backrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_back.vertices[1].x + backoffsetx) / backrangex ), 		((geo_back.vertices[1].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[12].x + backoffsetx) / backrangex ), 		((geo_back.vertices[12].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[11].x + backoffsetx) / backrangex ), 		((geo_back.vertices[11].z + backoffsetz) / backrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_back.vertices[1].x + backoffsetx) / backrangex ), 		((geo_back.vertices[1].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[2].x + backoffsetx) / backrangex ), 		((geo_back.vertices[2].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[12].x + backoffsetx) / backrangex ), 		((geo_back.vertices[12].z + backoffsetz) / backrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_back.vertices[2].x + backoffsetx) / backrangex ), 		((geo_back.vertices[2].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[13].x + backoffsetx) / backrangex ), 		((geo_back.vertices[13].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[12].x + backoffsetx) / backrangex ), 		((geo_back.vertices[12].z + backoffsetz) / backrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_back.vertices[2].x + backoffsetx) / backrangex ), 		((geo_back.vertices[2].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[3].x + backoffsetx) / backrangex ), 		((geo_back.vertices[3].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[13].x + backoffsetx) / backrangex ), 		((geo_back.vertices[13].z + backoffsetz) / backrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_back.vertices[3].x + backoffsetx) / backrangex ), 		((geo_back.vertices[3].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[14].x + backoffsetx) / backrangex ), 		((geo_back.vertices[14].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[13].x + backoffsetx) / backrangex ), 		((geo_back.vertices[13].z + backoffsetz) / backrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_back.vertices[3].x + backoffsetx) / backrangex ), 		((geo_back.vertices[3].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[4].x + backoffsetx) / backrangex ), 		((geo_back.vertices[4].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[14].x + backoffsetx) / backrangex ), 		((geo_back.vertices[14].z + backoffsetz) / backrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_back.vertices[4].x + backoffsetx) / backrangex ), 		((geo_back.vertices[4].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[15].x + backoffsetx) / backrangex ), 		((geo_back.vertices[15].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[14].x + backoffsetx) / backrangex ), 		((geo_back.vertices[14].z + backoffsetz) / backrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_back.vertices[4].x + backoffsetx) / backrangex ), 		((geo_back.vertices[4].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[5].x + backoffsetx) / backrangex ), 		((geo_back.vertices[5].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[15].x + backoffsetx) / backrangex ), 		((geo_back.vertices[15].z + backoffsetz) / backrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_back.vertices[5].x + backoffsetx) / backrangex ), 		((geo_back.vertices[5].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[16].x + backoffsetx) / backrangex ), 		((geo_back.vertices[16].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[15].x + backoffsetx) / backrangex ), 		((geo_back.vertices[15].z + backoffsetz) / backrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_back.vertices[5].x + backoffsetx) / backrangex ), 		((geo_back.vertices[5].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[6].x + backoffsetx) / backrangex ), 		((geo_back.vertices[6].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[16].x + backoffsetx) / backrangex ), 		((geo_back.vertices[16].z + backoffsetz) / backrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_back.vertices[6].x + backoffsetx) / backrangex ), 		((geo_back.vertices[6].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[17].x + backoffsetx) / backrangex ), 		((geo_back.vertices[17].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[16].x + backoffsetx) / backrangex ), 		((geo_back.vertices[16].z + backoffsetz) / backrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_back.vertices[6].x + backoffsetx) / backrangex ), 		((geo_back.vertices[6].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[7].x + backoffsetx) / backrangex ), 		((geo_back.vertices[7].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[17].x + backoffsetx) / backrangex ), 		((geo_back.vertices[17].z + backoffsetz) / backrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_back.vertices[7].x + backoffsetx) / backrangex ), 		((geo_back.vertices[7].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[18].x + backoffsetx) / backrangex ), 		((geo_back.vertices[18].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[17].x + backoffsetx) / backrangex ), 		((geo_back.vertices[17].z + backoffsetz) / backrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_back.vertices[7].x + backoffsetx) / backrangex ), 		((geo_back.vertices[7].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[8].x + backoffsetx) / backrangex ), 		((geo_back.vertices[8].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[18].x + backoffsetx) / backrangex ), 		((geo_back.vertices[18].z + backoffsetz) / backrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_back.vertices[8].x + backoffsetx) / backrangex ), 		((geo_back.vertices[8].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[19].x + backoffsetx) / backrangex ), 		((geo_back.vertices[19].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[18].x + backoffsetx) / backrangex ), 		((geo_back.vertices[18].z + backoffsetz) / backrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_back.vertices[8].x + backoffsetx) / backrangex ), 		((geo_back.vertices[8].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[9].x + backoffsetx) / backrangex ), 		((geo_back.vertices[9].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[19].x + backoffsetx) / backrangex ), 		((geo_back.vertices[19].z + backoffsetz) / backrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_back.vertices[9].x + backoffsetx) / backrangex ), 		((geo_back.vertices[9].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[20].x + backoffsetx) / backrangex ), 		((geo_back.vertices[20].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[19].x + backoffsetx) / backrangex ), 		((geo_back.vertices[19].z + backoffsetz) / backrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_back.vertices[9].x + backoffsetx) / backrangex ), 		((geo_back.vertices[9].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[10].x + backoffsetx) / backrangex ), 		((geo_back.vertices[10].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[20].x + backoffsetx) / backrangex ), 		((geo_back.vertices[20].z + backoffsetz) / backrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_back.vertices[10].x + backoffsetx) / backrangex ), 		((geo_back.vertices[10].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[11].x + backoffsetx) / backrangex ), 		((geo_back.vertices[11].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[20].x + backoffsetx) / backrangex ), 		((geo_back.vertices[20].z + backoffsetz) / backrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_back.vertices[10].x + backoffsetx) / backrangex ), 		((geo_back.vertices[10].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[1].x + backoffsetx) / backrangex ), 		((geo_back.vertices[1].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[11].x + backoffsetx) / backrangex ), 		((geo_back.vertices[11].z + backoffsetz) / backrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_back.vertices[21].x + backoffsetx) / backrangex ), 		((geo_back.vertices[21].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[11].x + backoffsetx) / backrangex ), 		((geo_back.vertices[11].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[12].x + backoffsetx) / backrangex ), 		((geo_back.vertices[12].z + backoffsetz) / backrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_back.vertices[21].x + backoffsetx) / backrangex ), 		((geo_back.vertices[21].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[12].x + backoffsetx) / backrangex ), 		((geo_back.vertices[12].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[13].x + backoffsetx) / backrangex ), 		((geo_back.vertices[13].z + backoffsetz) / backrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_back.vertices[21].x + backoffsetx) / backrangex ), 		((geo_back.vertices[21].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[13].x + backoffsetx) / backrangex ), 		((geo_back.vertices[13].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[14].x + backoffsetx) / backrangex ), 		((geo_back.vertices[14].z + backoffsetz) / backrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_back.vertices[21].x + backoffsetx) / backrangex ), 		((geo_back.vertices[21].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[14].x + backoffsetx) / backrangex ), 		((geo_back.vertices[14].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[15].x + backoffsetx) / backrangex ), 		((geo_back.vertices[15].z + backoffsetz) / backrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_back.vertices[21].x + backoffsetx) / backrangex ), 		((geo_back.vertices[21].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[15].x + backoffsetx) / backrangex ), 		((geo_back.vertices[15].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[16].x + backoffsetx) / backrangex ), 		((geo_back.vertices[16].z + backoffsetz) / backrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_back.vertices[21].x + backoffsetx) / backrangex ), 		((geo_back.vertices[21].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[16].x + backoffsetx) / backrangex ), 		((geo_back.vertices[16].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[17].x + backoffsetx) / backrangex ), 		((geo_back.vertices[17].z + backoffsetz) / backrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_back.vertices[21].x + backoffsetx) / backrangex ), 		((geo_back.vertices[21].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[17].x + backoffsetx) / backrangex ), 		((geo_back.vertices[17].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[18].x + backoffsetx) / backrangex ), 		((geo_back.vertices[18].z + backoffsetz) / backrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_back.vertices[21].x + backoffsetx) / backrangex ), 		((geo_back.vertices[21].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[18].x + backoffsetx) / backrangex ), 		((geo_back.vertices[18].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[19].x + backoffsetx) / backrangex ), 		((geo_back.vertices[19].z + backoffsetz) / backrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_back.vertices[21].x + backoffsetx) / backrangex ), 		((geo_back.vertices[21].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[19].x + backoffsetx) / backrangex ), 		((geo_back.vertices[19].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[20].x + backoffsetx) / backrangex ), 		((geo_back.vertices[20].z + backoffsetz) / backrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_back.vertices[21].x + backoffsetx) / backrangex ), 		((geo_back.vertices[21].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[20].x + backoffsetx) / backrangex ), 		((geo_back.vertices[20].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[11].x + backoffsetx) / backrangex ), 		((geo_back.vertices[11].z + backoffsetz) / backrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_back.vertices[1].x + backoffsetx) / backrangex ), 		((geo_back.vertices[1].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[2].x + backoffsetx) / backrangex ), 		((geo_back.vertices[2].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[0].x + backoffsetx) / backrangex ), 		((geo_back.vertices[0].z + backoffsetz) / backrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_back.vertices[2].x + backoffsetx) / backrangex ), 		((geo_back.vertices[2].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[3].x + backoffsetx) / backrangex ), 		((geo_back.vertices[3].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[0].x + backoffsetx) / backrangex ), 		((geo_back.vertices[0].z + backoffsetz) / backrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_back.vertices[3].x + backoffsetx) / backrangex ), 		((geo_back.vertices[3].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[4].x + backoffsetx) / backrangex ), 		((geo_back.vertices[4].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[0].x + backoffsetx) / backrangex ), 		((geo_back.vertices[0].z + backoffsetz) / backrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_back.vertices[4].x + backoffsetx) / backrangex ), 		((geo_back.vertices[4].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[5].x + backoffsetx) / backrangex ), 		((geo_back.vertices[5].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[0].x + backoffsetx) / backrangex ), 		((geo_back.vertices[0].z + backoffsetz) / backrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_back.vertices[5].x + backoffsetx) / backrangex ), 		((geo_back.vertices[5].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[6].x + backoffsetx) / backrangex ), 		((geo_back.vertices[6].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[0].x + backoffsetx) / backrangex ), 		((geo_back.vertices[0].z + backoffsetz) / backrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_back.vertices[6].x + backoffsetx) / backrangex ), 		((geo_back.vertices[6].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[7].x + backoffsetx) / backrangex ), 		((geo_back.vertices[7].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[0].x + backoffsetx) / backrangex ), 		((geo_back.vertices[0].z + backoffsetz) / backrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_back.vertices[7].x + backoffsetx) / backrangex ), 		((geo_back.vertices[7].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[8].x + backoffsetx) / backrangex ), 		((geo_back.vertices[8].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[0].x + backoffsetx) / backrangex ), 		((geo_back.vertices[0].z + backoffsetz) / backrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_back.vertices[8].x + backoffsetx) / backrangex ), 		((geo_back.vertices[8].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[9].x + backoffsetx) / backrangex ), 		((geo_back.vertices[9].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[0].x + backoffsetx) / backrangex ), 		((geo_back.vertices[0].z + backoffsetz) / backrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_back.vertices[9].x + backoffsetx) / backrangex ), 		((geo_back.vertices[9].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[10].x + backoffsetx) / backrangex ), 		((geo_back.vertices[10].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[0].x + backoffsetx) / backrangex ), 		((geo_back.vertices[0].z + backoffsetz) / backrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_back.vertices[10].x + backoffsetx) / backrangex ), 		((geo_back.vertices[10].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[1].x + backoffsetx) / backrangex ), 		((geo_back.vertices[1].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[0].x + backoffsetx) / backrangex ), 		((geo_back.vertices[0].z + backoffsetz) / backrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_back.vertices[22].x + backoffsetx) / backrangex ), 		((geo_back.vertices[22].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[23].x + backoffsetx) / backrangex ), 		((geo_back.vertices[23].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[1].x + backoffsetx) / backrangex ), 		((geo_back.vertices[1].z + backoffsetz) / backrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_back.vertices[23].x + backoffsetx) / backrangex ), 		((geo_back.vertices[23].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[2].x + backoffsetx) / backrangex ), 		((geo_back.vertices[2].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[1].x + backoffsetx) / backrangex ), 		((geo_back.vertices[1].z + backoffsetz) / backrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_back.vertices[23].x + backoffsetx) / backrangex ), 		((geo_back.vertices[23].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[24].x + backoffsetx) / backrangex ), 		((geo_back.vertices[24].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[2].x + backoffsetx) / backrangex ), 		((geo_back.vertices[2].z + backoffsetz) / backrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_back.vertices[24].x + backoffsetx) / backrangex ), 		((geo_back.vertices[24].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[3].x + backoffsetx) / backrangex ), 		((geo_back.vertices[3].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[2].x + backoffsetx) / backrangex ), 		((geo_back.vertices[2].z + backoffsetz) / backrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_back.vertices[24].x + backoffsetx) / backrangex ), 		((geo_back.vertices[24].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[25].x + backoffsetx) / backrangex ), 		((geo_back.vertices[25].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[3].x + backoffsetx) / backrangex ), 		((geo_back.vertices[3].z + backoffsetz) / backrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_back.vertices[25].x + backoffsetx) / backrangex ), 		((geo_back.vertices[25].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[4].x + backoffsetx) / backrangex ), 		((geo_back.vertices[4].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[3].x + backoffsetx) / backrangex ), 		((geo_back.vertices[3].z + backoffsetz) / backrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_back.vertices[25].x + backoffsetx) / backrangex ), 		((geo_back.vertices[25].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[26].x + backoffsetx) / backrangex ), 		((geo_back.vertices[26].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[4].x + backoffsetx) / backrangex ), 		((geo_back.vertices[4].z + backoffsetz) / backrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_back.vertices[26].x + backoffsetx) / backrangex ), 		((geo_back.vertices[26].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[5].x + backoffsetx) / backrangex ), 		((geo_back.vertices[5].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[4].x + backoffsetx) / backrangex ), 		((geo_back.vertices[4].z + backoffsetz) / backrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_back.vertices[26].x + backoffsetx) / backrangex ), 		((geo_back.vertices[26].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[27].x + backoffsetx) / backrangex ), 		((geo_back.vertices[27].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[5].x + backoffsetx) / backrangex ), 		((geo_back.vertices[5].z + backoffsetz) / backrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_back.vertices[27].x + backoffsetx) / backrangex ), 		((geo_back.vertices[27].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[6].x + backoffsetx) / backrangex ), 		((geo_back.vertices[6].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[5].x + backoffsetx) / backrangex ), 		((geo_back.vertices[5].z + backoffsetz) / backrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_back.vertices[27].x + backoffsetx) / backrangex ), 		((geo_back.vertices[27].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[28].x + backoffsetx) / backrangex ), 		((geo_back.vertices[28].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[6].x + backoffsetx) / backrangex ), 		((geo_back.vertices[6].z + backoffsetz) / backrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_back.vertices[28].x + backoffsetx) / backrangex ), 		((geo_back.vertices[28].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[7].x + backoffsetx) / backrangex ), 		((geo_back.vertices[7].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[6].x + backoffsetx) / backrangex ), 		((geo_back.vertices[6].z + backoffsetz) / backrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_back.vertices[28].x + backoffsetx) / backrangex ), 		((geo_back.vertices[28].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[29].x + backoffsetx) / backrangex ), 		((geo_back.vertices[29].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[7].x + backoffsetx) / backrangex ), 		((geo_back.vertices[7].z + backoffsetz) / backrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_back.vertices[29].x + backoffsetx) / backrangex ), 		((geo_back.vertices[29].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[8].x + backoffsetx) / backrangex ), 		((geo_back.vertices[8].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[7].x + backoffsetx) / backrangex ), 		((geo_back.vertices[7].z + backoffsetz) / backrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_back.vertices[29].x + backoffsetx) / backrangex ), 		((geo_back.vertices[29].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[30].x + backoffsetx) / backrangex ), 		((geo_back.vertices[30].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[8].x + backoffsetx) / backrangex ), 		((geo_back.vertices[8].z + backoffsetz) / backrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_back.vertices[30].x + backoffsetx) / backrangex ), 		((geo_back.vertices[30].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[9].x + backoffsetx) / backrangex ), 		((geo_back.vertices[9].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[8].x + backoffsetx) / backrangex ), 		((geo_back.vertices[8].z + backoffsetz) / backrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_back.vertices[30].x + backoffsetx) / backrangex ), 		((geo_back.vertices[30].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[31].x + backoffsetx) / backrangex ), 		((geo_back.vertices[31].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[9].x + backoffsetx) / backrangex ), 		((geo_back.vertices[9].z + backoffsetz) / backrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_back.vertices[31].x + backoffsetx) / backrangex ), 		((geo_back.vertices[31].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[10].x + backoffsetx) / backrangex ), 		((geo_back.vertices[10].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[9].x + backoffsetx) / backrangex ), 		((geo_back.vertices[9].z + backoffsetz) / backrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_back.vertices[31].x + backoffsetx) / backrangex ), 		((geo_back.vertices[31].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[22].x + backoffsetx) / backrangex ), 		((geo_back.vertices[22].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[10].x + backoffsetx) / backrangex ), 		((geo_back.vertices[10].z + backoffsetz) / backrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_back.vertices[22].x + backoffsetx) / backrangex ), 		((geo_back.vertices[22].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[1].x + backoffsetx) / backrangex ), 		((geo_back.vertices[1].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[10].x + backoffsetx) / backrangex ), 		((geo_back.vertices[10].z + backoffsetz) / backrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_back.vertices[23].x + backoffsetx) / backrangex ), 		((geo_back.vertices[23].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[22].x + backoffsetx) / backrangex ), 		((geo_back.vertices[22].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[32].x + backoffsetx) / backrangex ), 		((geo_back.vertices[32].z + backoffsetz) / backrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_back.vertices[24].x + backoffsetx) / backrangex ), 		((geo_back.vertices[24].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[23].x + backoffsetx) / backrangex ), 		((geo_back.vertices[23].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[32].x + backoffsetx) / backrangex ), 		((geo_back.vertices[32].z + backoffsetz) / backrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_back.vertices[25].x + backoffsetx) / backrangex ), 		((geo_back.vertices[25].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[24].x + backoffsetx) / backrangex ), 		((geo_back.vertices[24].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[32].x + backoffsetx) / backrangex ), 		((geo_back.vertices[32].z + backoffsetz) / backrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_back.vertices[26].x + backoffsetx) / backrangex ), 		((geo_back.vertices[26].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[25].x + backoffsetx) / backrangex ), 		((geo_back.vertices[25].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[32].x + backoffsetx) / backrangex ), 		((geo_back.vertices[32].z + backoffsetz) / backrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_back.vertices[27].x + backoffsetx) / backrangex ), 		((geo_back.vertices[27].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[26].x + backoffsetx) / backrangex ), 		((geo_back.vertices[26].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[32].x + backoffsetx) / backrangex ), 		((geo_back.vertices[32].z + backoffsetz) / backrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_back.vertices[28].x + backoffsetx) / backrangex ), 		((geo_back.vertices[28].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[27].x + backoffsetx) / backrangex ), 		((geo_back.vertices[27].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[32].x + backoffsetx) / backrangex ), 		((geo_back.vertices[32].z + backoffsetz) / backrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_back.vertices[29].x + backoffsetx) / backrangex ), 		((geo_back.vertices[29].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[28].x + backoffsetx) / backrangex ), 		((geo_back.vertices[28].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[32].x + backoffsetx) / backrangex ), 		((geo_back.vertices[32].z + backoffsetz) / backrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_back.vertices[30].x + backoffsetx) / backrangex ), 		((geo_back.vertices[30].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[29].x + backoffsetx) / backrangex ), 		((geo_back.vertices[29].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[32].x + backoffsetx) / backrangex ), 		((geo_back.vertices[32].z + backoffsetz) / backrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_back.vertices[31].x + backoffsetx) / backrangex ), 		((geo_back.vertices[31].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[30].x + backoffsetx) / backrangex ), 		((geo_back.vertices[30].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[32].x + backoffsetx) / backrangex ), 		((geo_back.vertices[32].z + backoffsetz) / backrangez))
 			],
 			[
 				new THREE.Vector2( ((geo_back.vertices[22].x + backoffsetx) / backrangex ), 		((geo_back.vertices[22].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[31].x + backoffsetx) / backrangex ), 		((geo_back.vertices[31].z + backoffsetz) / backrangez)),
 				new THREE.Vector2( ((geo_back.vertices[32].x + backoffsetx) / backrangex ), 		((geo_back.vertices[32].z + backoffsetz) / backrangez))
 			]
 		);
 
 		/*____________armagetron cycle______________*/
 
 
 		geo_body.computeFaceNormals();//for lighting
 		geo_front.computeFaceNormals();//for lighting
 		geo_back.computeFaceNormals();//for lighting
 
 
 	//UV MAPS NEEDED OR ERRORS for mapping
 	//materials
 	var bodyMaterial = [
 			new THREE.MeshBasicMaterial( { 
 				color: colorCode, 
 	//			shading: THREE.FlatShading
 			}),
 			new THREE.MeshBasicMaterial( { 
 				map: engine.textures.cycle_body,
 				transparent: settings.ALPHA_BLEND, 
 				opacity: 1.0,
 			})];
 
 			
 	var wheelMaterial = [
 			new THREE.MeshBasicMaterial( { //MeshLambertMaterial
 				color: colorCode, 
 	//			shading: THREE.FlatShading
 			}),
 			new THREE.MeshBasicMaterial( { 
 				map: engine.textures.cycle_wheel,
 				transparent: settings.ALPHA_BLEND, 
 				opacity: 1.0,
 			})];
 
 
 
 
 	//	var cycleBody = new THREE.Mesh( geo_body, bodyMaterial );
 		var cycleBody = new THREE.SceneUtils.createMultiMaterialObject( geo_body, bodyMaterial );
 		
 	//	var cycleFront = new THREE.Mesh( geo_front, wheelMaterial );
 	//	var cycleBack = new THREE.Mesh( geo_back, wheelMaterial );
 		var cycleFront = new THREE.SceneUtils.createMultiMaterialObject( geo_front, wheelMaterial );
 		var cycleBack = new THREE.SceneUtils.createMultiMaterialObject( geo_back, wheelMaterial );
 
 
 		cycleFront.position.x = 1.9;//push front wheel to front
 		cycleFront.position.z = 0.418248;//raise front wheel
 		cycleBack.position.z += 0.70724;//raise back wheel
 		
 		cycleBody.position.x -= 1.5;//move back 1.5
 		cycleFront.position.x -= 1.5;
 		cycleBack.position.x -= 1.5;
 		model.add(cycleBody);
 		model.add(cycleFront);
 		model.add(cycleBack);
 	}
 	
 		model.scale.set(0.5,0.5,0.5);//half size
 		model.rotaon = {
 			front: 133.55356,
 			back: 78.947758
 		};
 	return model;
 };
 
+
+function newChatArrow()
+{
+	var mat = new THREE.MeshBasicMaterial({
+			side: THREE.DoubleSide, color: new THREE.Color("yellow"),
+		});
+	
+	var geo = new THREE.Geometry();
+	geo.vertices.push(new THREE.Vector3(0,0,0));
+	geo.vertices.push(new THREE.Vector3(-1,-1,2));
+	geo.vertices.push(new THREE.Vector3(-1, 1,2));
+	geo.vertices.push(new THREE.Vector3( 1, 1,2));
+	geo.vertices.push(new THREE.Vector3( 1,-1,2));
+	geo.vertices.push(new THREE.Vector3(-1,-1,2));
+	
+	for(var i=1;i<geo.vertices.length-1;i++)
+	{
+		geo.faces.push(new THREE.Face3(i,i+1,0));
+	}
+	
+	return new THREE.Mesh(geo,mat);
+}
+
+
 /*—–––––––––––cycle constructor—–––––––––––*/
 var createLightcycle = function(cfg) //DEPRECATED
 {
 	return new Cycle(cfg);
 }
 
 
 
 /*_*/
 
 /*—––––––––––––wall–constructor—–––––––––––*/	
 
 function newWall(tailColor,x,y,z=0)
 {
 	var xy = 0.001;
 	
 	//var wallTextureProportion;
 	var textureBlending = true;
 	if(!engine.dedicated)
 	{
 		/*var texture = engine.textures.cycle_wall;
 		texture.wrapS = THREE.RepeatWrapping;
 		texture.repeat.set(xy,1);*/
 		/*if (texture.image)
 		{
 			wallTextureProportion = (texture.image.width / texture.image.height) * xy; // *4 is actual size
 		}//*/
 
 		var wallMaterial = new THREE.MeshLambertMaterial({
 			side: THREE.DoubleSide,
 			color: tailColor,
 			//map: texture,
 			//blending: textureBlending ? THREE.AdditiveBlending : THREE.NormalBlending,
 			transparent: settings.ALPHA_BLEND, opacity: 0.6
 		});
 	}
 	
 	//var wallGeometry = new THREE.PlaneBufferGeometry( 1, 4 );
 	
 	/*var m = new THREE.Matrix4();
 		m.makeRotationX(pi(0.5));
 		m.makeTranslation( 0.5, 2, 0 );
 		wallGeometry.applyMatrix( m );*/
 	
 	var geo = new THREE.Geometry();
 	geo.vertices.push(new THREE.Vector3(0,0,0));
 	geo.vertices.push(new THREE.Vector3(xy,xy,0));
 	geo.vertices.push(new THREE.Vector3(xy,xy,1));
 	geo.vertices.push(new THREE.Vector3(0,0,1));
 	geo.vertices.push(new THREE.Vector3(0,0,0));
 	geo.vertices.push(new THREE.Vector3(xy,xy,0));
 	
 	geo.faces = [new THREE.Face3(0,1,2),new THREE.Face3(1,2,3),new THREE.Face3(2,3,4),new THREE.Face3(3,4,5)];
 	
 	geo.computeFaceNormals();
     geo.computeVertexNormals();
 	
 	var wall1 = new THREE.Mesh(geo,wallMaterial);
 
 	// hacky solution to make wall visible from straight on
 	var geo = new THREE.Geometry();
 	geo.vertices.push(new THREE.Vector3(0,0,1));
 	geo.vertices.push(new THREE.Vector3(xy,xy,1));
 	var wall2 = new THREE.Line(geo,wallMaterial);
 	
 	var wall = new THREE.Group();
 	wall.add(wall1); wall.add(wall2);
 	
 	wall.position.set(x,y,z);
 	wall.size = xy;
 	wall.scale.set(1,1,0.75);
 	
 	return wall;
 }
 
 var createWall = function(cycle,x,y)
 {
 
 	var group = new THREE.Group();
 
 	var wall = newWall(cycle.tailColor,x,y);
 
 	group.add(wall); // === .children[0]
 	//group.add(line); // === .children[1]
 	
 	group.netLength = 0;
 	group.map = [[x,y],[x,y]];
 
 	return group;
 };
 
 /*–––––––––––––––––––––––––––––––––––––––––*/
 
 function lineExplosion(pos,color1=0xffffff,color2=color1)
 {
 	if(typeof(pos) != "object") pos = {x:0,y:0,z:0};
 	else if(typeof(pos.x) == "undefined") pos.x = 0;
 	else if(typeof(pos.y) == "undefined") pos.y = 0;
 	else if(typeof(pos.z) == "undefined") pos.z = 0;
 	if(!settings.EXPLOSIONS) return false;
 	
 	var group = new THREE.Group();
 	
 	var expvec = [
 		//new THREE.Vector3(0,0,1),
 		new THREE.Vector3(0,1,1),
 		new THREE.Vector3(0,-1,1),
 		new THREE.Vector3(1,0,1),
 		new THREE.Vector3(-1,0,1),
 		new THREE.Vector3(1,1,1),
 		new THREE.Vector3(-1,1,1),
 		new THREE.Vector3(1,-1,1),
 		new THREE.Vector3(-1,-1,1),
 	];
 	
 	var fak=7;
 	
 	for(var j=40-expvec.length;j--;)
 	{
 		expvec.push(new THREE.Vector3(
 			fak*((Math.random())-.5),
 			fak*((Math.random())-.5),
 			1
 		));
 	}
 	for(var j=40-expvec.length;j--;)
 	{
 		expvec.push(new THREE.Vector3(
 			fak*((Math.random())-.5),
 			fak*((Math.random())-.5),
 			-1
 		));
 	}
 	
 	var mat = [
 		new THREE.LineBasicMaterial({color:color1,transparent:settings.ALPHA_BLEND,opacity:1}),
 		new THREE.LineBasicMaterial({color:color2,transparent:settings.ALPHA_BLEND,opacity:1})
 	];
 	for(var z=expvec.length;z--;)
 	{
 		var geometry = new THREE.Geometry();
 		geometry.vertices.push(new THREE.Vector3(0,0,0));
 		geometry.vertices.push(expvec[z]);
 		var line = new THREE.Line(geometry,mat[Math.round(Math.random())]);
 		line.position.set(pos.x,pos.y,pos.z); line.scale.set(0,0,0);
 		group.add(line);
 	}
 	engine.expl.push(group);
 	engine.scene.add(group);
 }
 function zmanCircleExplosion(pos,color1=0xffffff,color2=color1)
 {
 	
 }
 
 spawnExplosion = lineExplosion;
 //spawnExplosion = zmanCircleExplosion;
diff --git a/scripts/player.js b/scripts/player.js
index aa8d01f..6bb5280 100644
--- a/scripts/player.js
+++ b/scripts/player.js
@@ -1,609 +1,614 @@
 /*
  * 3DCycles - A lightcycle game.
  * Copyright (C) 2019 Glen Harpring
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
  * of the License, or (at your option) any later version.
  * 
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  * 
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  */
 
 //if(typeof(THREE) == "undefined") var THREE = require('./lib/Three.js');
 
 class Player extends THREE.Object3D
 {
 	softReset() //! Resets the cycle state to default variables
 	{
 		this.speed = 0;
 		this.lastSpeed = this.speed;
 		this.rubber = 0;
 		this.brakes = 1;
 		this.braking = false;
 		this.boosting = false;
 		this.boost = 0;
 		this.dedtime = 0;
 		this.alive = false;
 		this.collidetime = Infinity;
 		this.sensor = {left:Infinity,right:Infinity,front:Infinity};
 		this.dir = {front:[0,0],left:[0,0],right:[0,0]};
 		this.minDistance = {front:settings.CYCLE_RUBBER_MINDISTANCE};
 		this.turnQueue = [];
 		this.lastTurnTime = 0;
 		this.gameTime = 0;
 		this.handleNetTurn = true;
 	}
 	hardReset() //! Same as soft reset but resets all varaibles
 	{
 		this.softReset();
 		this.score = 0;
 		this.ping = 0;
 	}
 	getColoredName() //! Name with colors...
 	{
 		switch(typeof(this.tailColor))
 		{
 			case "string":
 				return this.tailColor.replace("#","0x")+this.name;
 			case "object":
 				return "0x"+this.tailColor.getHexString()+this.name;
 			case "number":
 				var color = this.tailColor.toString(16);
 				color = ("0".repeat(6-color.length))+color;
 				return "0x"+color+this.name;
 			default:
 				console.warn("Can't get color");
 				return "0xRESETT"+this.name;
 		}
 	}
 	getBoringName() //! Name without colors...
 	{
 		return removeColors(cycle.name);
 	}
 	newWallSegment() //should be called on turns
 	{
 		var adj = 0.7, wmap = this.walls.map, dirmult = this.dir.front;
 		wmap[wmap.length-1] = [this.position.x,this.position.y,this.position.z];
 		wmap[wmap.length] = [this.position.x,this.position.y,this.position.z]; 
 		this.resetCurrWallSegment(false,1);
 		var wall = newWall(this.tailColor,this.position.x,this.position.y,this.position.z);
 		var adjx = (dirmult[0]*adj), adjy = (dirmult[1]*adj);
 		wall.scale.x -= adjx/wall.size; wall.scale.y -= adjy/wall.size;
 		this.walls.add(wall);
 	}
 	/*recalcCurrWallLength(tocurrpos=false)
 	{
 		var adj = 0.7, dirmult = this.dir.front, wall = this.walls.children[this.walls.children.length-1];
 		var adjx = (dirmult[0]*adj), adjy = (dirmult[1]*adj);
 		wall.scale.x += adjx/wall.size; wall.scale.y += adjy/wall.size;
 		this.resetCurrWallSegment(tocurrpos,0,true);
 		wall.scale.x -= adjx/wall.size; wall.scale.y -= adjy/wall.size;
 	}*/
 	resetCurrWallSegment(tocurrpos=false,offset=0,breakWallLength=false) //! Redoes the current 3D wall segment to the actual wall segment.
 	{
 		var wmap = this.walls.map;
 		var oldwall = this.walls.children[this.walls.children.length-1];
 		
 		if(breakWallLength)
 		{
 			var sizex = oldwall.scale.x*oldwall.size,sizey = oldwall.scale.y*oldwall.size;
 			this.walls.netLength -= Math.sqrt((sizex*sizex)+(sizey*sizey));
 		}
 		
 		if(typeof(wmap[wmap.length-3]) == "undefined")
 		{
 			console.warn("Wall was undefined when trying to calculate wall size");
 			//console.log();
 			return;
 		}
 		if(tocurrpos)
 		{
 			wmap[wmap.length-2] = [this.position.x,this.position.y,this.position.z];
 		}
 		var a = 2+offset, b=1+offset;
 		oldwall.position.set(wmap[wmap.length-a][0],wmap[wmap.length-a][1],wmap[wmap.length-3][2]||0);
 		oldwall.scale.x = (wmap[wmap.length-b][0]-wmap[wmap.length-a][0])/oldwall.size||1;
 		oldwall.scale.y = (wmap[wmap.length-b][1]-wmap[wmap.length-a][1])/oldwall.size||1;
 		
 		if(breakWallLength)
 		{
 			var sizex = oldwall.scale.x*oldwall.size,sizey = oldwall.scale.y*oldwall.size;
 			this.walls.netLength += Math.sqrt((sizex*sizex)+(sizey*sizey));
 		}
 		else
 		{
 			this.calcWallLength();
 		}
 	}
 	calcWallLength(cycle) //! sets the actual wall length
 	{
 		var wmap = this.walls.map;
 		this.walls.netLength = 0;
 		for(var x=wmap.length;x>=0;x--)
 		{
 			if(wmap[x+1] !== undefined)
 			{
 				var p1=wmap[x],p2=wmap[x+1];
 				this.walls.netLength += pointDistance(p1[0],p1[1],p2[0],p2[1]);
 			}
 		}
 		return this.walls.netLength;
 	}
 	resetWall(cycle,full=true) //! Completely redoes the 3D wall according to the actual wall
 	{
 		if(full === true)
 		{
 			for(var x=0,len=this.walls.children.length;x<len;x++)
 			{
 				this.walls.remove(this.walls.children[x]);
 			}
 		}
 		var wmap = this.walls.map, wallmod;
 		for(var x=1,len=wmap.length;x<len;x++)
 		{
 			if(full === true)
 			{
 				this.walls.add(wallmod = newWall(this.tailColor,wmap[x][0],wmap[x][1],wmap[x][2]));
 			}
 			else
 			{
 				wallmod = this.walls.children[x-1];
 				wallmod.position.set(wmap[x][0],wmap[x][1],wmap[x][2]||0);
 			}
 			wallmod.scale.x = (wmap[x-1][0]-wmap[x][0])/wallmod.size;
 			wallmod.scale.y = (wmap[x-1][1]-wmap[x][1])/wallmod.size;
 		}
 		if(full !== true)
 		{
 			for(;x<this.walls.length;x++)
 			{
 				this.walls.remove(this.walls.children[x]);
 			}
 		}
 		
 		this.calcWallLength();
 	}
 	turn(dir)
 	{
         if(dir != -1 && dir != 1) return false;
 		this.turnQueue.push(dir);
 	}
 	turnAbs(dirX,dirY)
 	{
 		var ang = Math.atan2(this.position.y+dirY,this.position.x+dirX);
 		centerMessage(ang,500);
 		if(ang > Math.PI)
 		{
 			return this.turn(1);
 		}
 		else if(ang != 0)
 		{
 			return this.turn(-1);
 		}
 	}
 	spawn(cfg,respawn=true,update=true)
 	{
 		//configure cycle
 		this.softReset();
 		
 		this.position.set(cfg.x,cfg.y,cfg.z);
 		this.lastpos = this.position.clone();
 		this.rotation.set(0,0,cfg.dir);
 		this.lastdir = {front:0};
 		this.alive = true;
 		this.speed = settings.CYCLE_START_SPEED;
 		this.gameTime = this.spawntime = Math.max(0,engine.gtime);
 		this.haswall = !(respawn||settings.CYCLE_FIRST_SPAWN_PROTECTION);
 		
 		//walls
 		if(this.haswall)
 		{
 			this.walls = createWall(this,cfg.x,cfg.y,cfg.z);
 			engine.scene.add(this.walls);
 		}
 		
 		if(this.audio) this.audio.panner.connect(ctx.destination);
 		
 		engine.scene.add(this);
 		if(update) updateScoreBoard();
 		
 		if(this == engine.players[engine.activePlayer]) engine.viewTarget = engine.activePlayer;
 	}
 	kill()
 	{
 		this.resetCurrWallSegment();
 		this.alive = false; this.dedtime = performance.now();
 		engine.scene.remove(this);
 		if(this == engine.players[engine.viewTarget] && !engine.dedicated)
 			setTimeout(function(){if(!engine.players[engine.viewTarget].alive)changeViewTarget()},3000);
 		if(this.audio)
 		{
 			this.audio.panner.disconnect();
 			playSound(bufferLoader.bufferList[this.engineType+6],0.5,1,false,ctx.destination);
 			spawnExplosion(this.position,this.cycleColor,this.tailColor);
 		}
 		updateScoreBoard();
 		
 		if(engine.dedicated) 
 		{
 			var alive = 0, aliveAI = 0;
 			for(var x=engine.players.length-1;x>=0;--x) if(engine.players[x])
 			{
 				if(engine.players[x].alive)
 				{
 					alive++;
 					if(engine.players[x].AI) aliveAI++;
 				}
 			}
 			if(alive==aliveAI) changeViewTarget(0); //this will handle the finish type stuff
 		}
 	}
 	killAt(position,y=false,z=false)
 	{
 		if(y !== false) var x = position;
 		else var x=position.x,y=position.y,z=position.z;
 		this.position.set(x,y,z===false?this.position.z:z);
 		this.kill();
 	}
 	killIn(timestep)
 	{
 		this.update(timestep);
 		this.kill();
 	}
 	doChat(msg)
 	{
 		if(engine.network)
 		{
 			engine.connection.send(JSON.stringify({type:"chat",data:msg}));
 		}
 		else
 		{
 			engine.console.print(this.getColoredName()+"0xffff7f: "+msg+"\n");
 			if(engine.dedicated) {}
 		}
 	}
 	update(timestep=false) //! Simulates game movement on cycles
 	{
 		if(timestep === false) { timestep = (engine.gtime-this.gameTime)/1000; }
 		this.gameTime += timestep*1000;
 		//var timeElapsed = engine.gtime;
 		var timeElapsed = this.gameTime;
 		//movement
 		var acceleration = 0;
 		if(this.braking)
 		{
 			if(this.brakes > 0)
 			{
 				acceleration -= settings.CYCLE_BRAKE;
 				this.brakes -= timestep*settings.CYCLE_BRAKE_DEPLETE;
 			}
 		}
 		else if(this.brakes < 1)
 		{
 			this.brakes += timestep*settings.CYCLE_BRAKE_REFILL;
 		}
 		if(this.brakes > 1) this.brakes = 1;
 		else if(this.brakes < 0) this.brakes = 0;
 		if(this.boosting)
 			acceleration += settings.CYCLE_BOOST;
 		if(this.speed < settings.CYCLE_SPEED)
 		{
 			acceleration += (settings.CYCLE_SPEED-this.speed)*settings.CYCLE_SPEED_DECAY_BELOW;
 		}
 		else if(this.speed > settings.CYCLE_SPEED)
 		{
 			acceleration += (settings.CYCLE_SPEED-this.speed)*settings.CYCLE_SPEED_DECAY_ABOVE;
 		}
 		if(this.sensor.left < settings.CYCLE_WALL_NEAR || this.sensor.right < settings.CYCLE_WALL_NEAR)
 		{
 			var wallAccel = settings.CYCLE_ACCEL;
 			if(wallAccel != 0) //don't bother if there's no accel
 			{
 				var accelMult = [(settings.CYCLE_WALL_NEAR-this.sensor.left)/settings.CYCLE_WALL_NEAR,(settings.CYCLE_WALL_NEAR-this.sensor.right)/settings.CYCLE_WALL_NEAR];
 				var accelTargets = [this.sensor.lnearestobj,this.sensor.rnearestobj];
 				for(var z=2;z--;)
 				{
 					if(accelMult[z] > 0)
 					{
 						if(accelTargets[z] == "rim")
 						{
 							wallAccel *= settings.CYCLE_ACCEL_RIM;
 						}
 						else if(typeof(accelTargets[z]) == "object")
 						{
 							if(accelTargets[z] == this)
 							{
 								wallAccel *= settings.CYCLE_ACCEL_SELF;
 							}
 							else
 							{
 								wallAccel *= settings.CYCLE_ACCEL_ENEMY;
 							}
 						}
 						else
 						{
 							throw "Accel target is unknown.";
 						}
 						wallAccel *= accelMult[z];
 					}
 				}
 				//console.log(wallAccel);
 				acceleration += wallAccel;
 			}
 		}
 		this.speed += acceleration*timestep;
 		if(this.speed < settings.CYCLE_SPEED*settings.CYCLE_SPEED_MIN)
 		{
 			this.speed = settings.CYCLE_SPEED*settings.CYCLE_SPEED_MIN;
 		}
 		if(settings.CYCLE_SPEED_MAX != 0 && this.speed > settings.CYCLE_SPEED*settings.CYCLE_SPEED_MIN)
 		{
 			this.speed = settings.CYCLE_SPEED*settings.CYCLE_SPEED_MAX;
 		}
 		this.accel = acceleration;
 		if(this.speed < 0) this.speed = 0;
 		
 		//wheel spin per player
 		if(!engine.dedicated)
 		{
 			this.model.children[1].rotation.y += (deg2rad(this.model.rotaon.front * this.speed) * timestep);//0.5x wheel size
 			this.model.children[2].rotation.y += (deg2rad(this.model.rotaon.back * this.speed) * timestep);
 		}
 		
 		//collision test
 		var dir = cdir(this.rotation.z);
 		var posx = this.position.x, posy = this.position.y;
 		var escape = false;
 		if(posx+settings.ARENA_BOUNDARY > engine.logicalBox.max.x*engine.REAL_ARENA_SIZE_FACTOR)
 		{
 			escape = true;
 			this.position.x = (engine.logicalBox.max.x*engine.REAL_ARENA_SIZE_FACTOR)-settings.ARENA_BOUNDARY;
 		}
 		if(posy+settings.ARENA_BOUNDARY > engine.logicalBox.max.y*engine.REAL_ARENA_SIZE_FACTOR)
 		{
 			escape = true;
 			this.position.y = (engine.logicalBox.max.y*engine.REAL_ARENA_SIZE_FACTOR)-settings.ARENA_BOUNDARY;
 		}
 		if(posx-settings.ARENA_BOUNDARY < engine.logicalBox.min.x*engine.REAL_ARENA_SIZE_FACTOR)
 		{
 			escape = true;
 			this.position.x = (engine.logicalBox.min.x*engine.REAL_ARENA_SIZE_FACTOR)+settings.ARENA_BOUNDARY;
 		}
 		if(posy-settings.ARENA_BOUNDARY < engine.logicalBox.min.y*engine.REAL_ARENA_SIZE_FACTOR)
 		{
 			escape = true;
 			this.position.y = (engine.logicalBox.min.y*engine.REAL_ARENA_SIZE_FACTOR)+settings.ARENA_BOUNDARY;
 		}
 		/*var collided = false;
 		for(var y=0; y<engine.map.walls.length;y++)
 		{
 			for(var i=0;i<engine.map.walls[y].length;i++)
 			{
 				var p = engine.map.walls[y][i].split(",");
 				var w1x = p[0],w1y = p[1];
 				
 				if(engine.map.walls[y][i+1] !== undefined)
 				{
 					var p = engine.map.walls[y][i+1].split(",");
 					var w2x = p[0],w2y = p[1];
 					
 					if(lineIntersect(posx,posy,posx+(dir[0]/4),posy+(dir[1]/4),w1x,w1y,w2x,w2y))
 					{
 						//console.log("Hitting wall");
 						collided = true;
 					}
 				}
 			}
 		}*/
 		var collided = (this.sensor.front <= this.minDistance.front); //potential replacement for above code
 		//var collided = false;
 		/*if(collided || (escape && settings.ARENA_BOUNDARY_KILLS))
 		{
 			this.collidetime = Infinity; //we've collided, no need to check
 
 		}
 		else*/
 		{
 			
 			//var newx = dir[0]*this.speed*timestep, newy = dir[1]*this.speed*timestep;
 			var dist = this.speed*timestep, radj = dist;
 			if(dist < 0) dist = 0;
 			if(this.collidetime <= timeElapsed)
 			{
 				//this.rubber += timestep*(this.lastSpeed);
 				collided = true; 
 				var adjdist = (((timeElapsed-this.collidetime)/1000)*this.lastSpeed);
 				radj = timestep;
 				//radj = adjdist;
 				radj *= this.lastSpeed;
 				dist -= adjdist;
 				//console.warn(x+" should have collided: "+(this.collidetime-timeElapsed)+"ms\n");
 			}
 			//if((dir[0]==0?0:(newx/dir[0]))+(dir[1]==0?0:(newx/dir[1])) >= this.sensor.front)
 			if(dist >= this.sensor.front-(this.minDistance.front))
 			//if(this.speed*timestep >= this.sensor.front)
 			{
 				dist = (this.sensor.front-(this.minDistance.front));
 				//if(x == engine.viewTarget) console.warn(dist+" "+this.sensor.front+"\n");
 				collided = true;
 			}
 			if(dist > this.sensor.front-(this.minDistance.front)) //shouldn't happen
 			{
 				dist = this.minDistance.front;
 			}
 			if(collided || (escape && settings.ARENA_BOUNDARY_KILLS))
 			{
 				if(this.rubber >= settings.CYCLE_RUBBER)
 				{
 					if(!engine.network)
 					{
 						doDeath(this,escape);
 					}
 				}
 				else if(
 					(settings.CYCLE_RUBBER_DEPLETE_RIM && this.sensor.nearestobj == "rim") ||
 					(settings.CYCLE_RUBBER_DEPLETE_SELF && this.sensor.nearestobj == this) ||
 					(settings.CYCLE_RUBBER_DEPLETE_ENEMY && this.sensor.nearestobj != this && typeof(this.sensor.nearestobj) == "object")
 				)
 				{
 					this.rubber += radj;
 				}
 			}
 			var move2d = Math.cos(this.model.rotation.y), movez = -this.model.rotation.y;
 			var dist2d = dist*move2d;
 			var newx = dist2d*dir[0], newy = dist2d*dir[1], newz = dist*movez;
 			
 			this.position.x += newx;
 			this.position.y += newy;
 			this.position.z += newz;
 			if(this.position.z-this.sensor.bottom < this.model.rotation.y)
 			{
 				this.model.rotation.y = this.position.z;
 				if(this.model.rotation.y < 0)
 				{
 					this.model.rotation.y = 0;
 					this.position.z = this.sensor.bottom;
 				}
 			}
 			if(this.position.z > this.sensor.bottom)
 			{
 				this.model.rotation.y += timestep*(1-this.model.rotation.y);
 			}
 			//if(typeof(this.walls.children) != "undefined")
 			if(this.haswall)
 			{
 				var wallmod = this.walls.children[this.walls.children.length-1];
 				var wallmap = this.walls.map[this.walls.map.length-1];
 			
 				wallmap[0]+=(newx); wallmap[1]+=(newy);
 				
 				wallmod.scale.x += newx/wallmod.size;
 				wallmod.scale.y += newy/wallmod.size;
 				
 				this.walls.netLength += dist;
 				
 				this.sensor.front -= dist; //assume distance until we have new real results.
 				//this.sensor.front = 
 				
 				var lendiff = this.walls.netLength - settings.WALLS_LENGTH;
 				while(settings.WALLS_LENGTH > 0 && lendiff > 0)
 				{
 					var map = this.walls.map;
 					var xdir = (map[1][0]-map[0][0]), ydir = (map[1][1]-map[0][1]);
 					var len = Math.sqrt((xdir*xdir)+(ydir*ydir));
 					if(len > 1) { xdir /= len; ydir /= len; }
 					
 					
 					if(isNaN(xdir)) xdir = SMALL_NUM; if(isNaN(ydir)) ydir = SMALL_NUM; 
 					//console.log(lendiff,xdir,ydir);
 					if(xdir == 0 && ydir == 0 && this.walls.map.length > 2)
 					{
 						//this.walls.children.shift();
 						this.walls.remove(this.walls.children[0]);
 						this.walls.map.shift();
 					}
 					else
 					{
 						this.walls.children[0].scale.x -= xdir/wallmod.size;
 						this.walls.children[0].position.x += xdir;
 						this.walls.children[0].scale.y -= ydir/wallmod.size;
 						this.walls.children[0].position.y += ydir;
 						this.walls.map[0][0] += xdir;
 						this.walls.map[0][1] += ydir;
 						this.walls.netLength -= Math.sqrt((xdir*xdir)+(ydir*ydir));
 					}
 					
 					lendiff = this.walls.netLength - settings.WALLS_LENGTH;
 				}//*/
 				if(this.position.z > 0) this.newWallSegment();
 			}
 			else if(engine.gtime > this.spawntime+(settings.CYCLE_WALL_TIME*1000))
 			{
 				this.walls = createWall(this,this.position.x,this.position.y,this.position.z);
 				engine.scene.add(this.walls);
 				this.haswall = true;
 			}
 			
 			this.collidetime = timeElapsed+(((this.sensor.front-this.minDistance.front)/this.speed)*1000);
 			this.lastSpeed = this.speed;
 		}
 		if(this.speed > engine.fastestSpeed)
 		{
 			engine.fastestPlayer = this; engine.fastestSpeed = this.speed;
 		}
 	}
 	constructor(cfg)
 	{
 		super();
 		
 		//var dir = cdir(cfg.dir);
 		
 		//this.cfg = cfg;//carry over the cfg???
 
 		//choose model
 		this.model = cycleModel(cfg.cycleColor);
 		this.add(this.model);
 		//this.shadow = cycleShadow();
 		//this.add(this.shadow);
+		this.chatarrow = newChatArrow();
+		this.chatarrow.position.z = 1.20;
+		this.chatarrow.position.x -= 0.5;
+		this.chatarrow.scale.set(0.25,0.25,0.25);
+		this.add(this.chatarrow);
 		
 		
 		this.cycleColor = cfg.cycleColor;
 		this.tailColor = cfg.tailColor;
 
 		/*this.walls = {};
 		//this.walls.children = [];
 
 		this.walls.netLength = 0;
 		this.walls.map = [];
 		this.walls.scale = this.walls.position = new THREE.Vector3();*/
 		
 		this.walls = createWall(this,0,0,0); //walls are still called upon when spectating
 
 		this.hardReset();
 
 		this.chatting = cfg.chatting||false; this.spectating = cfg.spectating||false;
 		if(cfg.ai||settings.DEBUG_EVERYONE_IS_AI)
 		{
 			this.AI = new AI(this);
 		}
 		else
 		{
 			this.AI = false;
 		}
 
 	//	this.playerID = cfg.playerID;
 
 		this.name = cfg.name;
 		
 		
 		//audio creation
 		this.engineType = cfg.engineType;
 		if(ctx)
 		{
 			this.audio = ctx.createGain();
 			this.audio.gain.value = 0.01;
 			this.audio.panner = ctx.createPanner();
 			if(engine.retroSound)
 				this.audio.panner.panningModel = "HRTF";
 			else
 				this.audio.panner.panningModel = "equalpower";
 			this.audio.connect(this.audio.panner);
 			this.audio.panner.connect(ctx.destination);
 
 			//audio initialization
 			this.engineSound = playSound(bufferLoader.bufferList[this.engineType], 0.5, 0, true, this.audio);
 			this.audio.gain.setTargetAtTime(6, ctx.currentTime, 1.0);
 		}
 	}
 	
 };
 
 if(typeof(module) != "undefined") module.exports = Player;
diff --git a/scripts/render.js b/scripts/render.js
index b0f7628..857991a 100644
--- a/scripts/render.js
+++ b/scripts/render.js
@@ -1,556 +1,562 @@
 /*
  * 3DCycles - A lightcycle game.
  * Copyright (C) 2019 Glen Harpring
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
  * of the License, or (at your option) any later version.
  * 
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  * 
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  */
 
 var draw2dmap = true;
 
 function render()
 {
 	if(!engine.roundCommencing && !engine.paused)
 	{
 		engine.renderRunning = true;
 		if(settings.GAME_LOOP > 0) game(true); //update game right before render
 		if(settings.REDRAW_MODE == 0) requestAnimationFrame(render); 
 		else setTimeout(render,1000/settings.TARGET_FPS);
 		draw(); //actual 3d draw
 		if(settings.HUD_MAP && draw2dmap && engine.hud.style.opacity > 0)
 		{
 			draw2dmap = false;
 			if(settings.REDRAW_MODE == 0)
 				setTimeout(draw2d_canvas,0);
 			else
 				requestAnimationFrame(draw2d_canvas); 
 		}
 	}
 	else
 	{
 		engine.renderRunning = false;
 		if(engine.paused)
 		{
 			//var lines = engine.console.innerText.split("\n");
 			//if(lines[(parseFloat(0+engine.console.style.top)/engine.console.scrollby].length > 0) 
 		}
 	}
 	if(settings.TEXT_OUT_MODE == 1)
 	{
 		var lines = engine.console.scrollback
 		var lnnum = engine.console.scrollby;
 		var currln = lines[lnnum];
 	}
 	else
 	{
 		var lines = engine.console.innerText.split("\n");
 		var lnnum = (-(parseFloat(engine.console.style.top)/engine.console.scrollby));
 		var currln = lines[lnnum-1];
 	}
 	if(Math.round(engine.console.time/engine.console.scrolltime) < Math.round(performance.now()/engine.console.scrolltime) || (performance.now() > engine.console.time_manual+engine.console.scrolltime_manual && lines.length-lnnum > 10))
 	{
 		if(!currln && lnnum != lines.length)
 		{
 			if(lnnum < 0) var scrby = 1;
 			if(lnnum > lines.length) var scrby = -1;
 			engine.console.scroll(scrby);
 			console.log("scroll",scrby);
 		}
 		else
 		{
 			engine.console.time = performance.now();
 			if(typeof(currln) != "undefined" && currln.length > 0) 
 				engine.console.scroll();
 			console.log("scroll");
 		}
 	}
 }
 
 function draw()
 {
 	//time handlers and delta
 	var timenow = performance.now();
 	var delta = (timenow - engine.lastRenderTime);
 	var frametime = delta/1000;//time step
 	engine.lastRenderTime = timenow;
 	var fpsDelta = (timenow - engine.fpsTime);
 	settings.TARGET_FPS = (1000/delta)*2;
 	if(settings.TARGET_FPS < 10) settings.TARGET_FPS = 10;
 	if(settings.MAX_TARGET_FPS < settings.TARGET_FPS) settings.TARGET_FPS = settings.MAX_TARGET_FPS;
 	//if(fpsDelta > 999) //update fps gui once every second
 	if(fpsDelta >= 500) // experimental quicker FPS updating...
 	{
 		//var fpsValue = fpsDelta/delta;
 		/*var fpsValue = 1000/delta;*/
 		var fpsValue = engine.framesCount*(1000/fpsDelta);
 		//settings.TARGET_FPS = fpsValue*2;
 		engine.framesCount = 0;
 		engine.fpsTime = timenow;
 		/*document.getElementById("fps").innerHTML = "FPS: " + fpsValue;*/
 		updateHUD("current_framerate",fpsValue);
 	}
 	//updateHUD("current_framerate_now",1000/delta);
 	updateHUD("current_frametime",delta);
 	var timeElapsed = (timenow - engine.timeStart)-engine.totalPauseTime-4000;
 		
 	if(engine.zones) for(var x=engine.zones.children.length-1;x>=0;--x)
 	{
 		//zones spin
 		switch(settings.ZONE_RENDER_TYPE)
 		{
 			case "cylinder":
 				engine.zones.children[x].rotation.y += ((engine.zones.children[x].cfg.rotationSpeed * pi(2)) * frametime);
 				break;
 			default:
 				engine.zones.children[x].rotation.z += ((engine.zones.children[x].cfg.rotationSpeed * pi(2)) * frametime);
 				break;
 		}
 	}
 	
 	for(var x=engine.players.length-1;x>=0;x--) if(engine.players[x] !== undefined)
 	{ //cycle un-tilting
 		var cycle=engine.players[x];
 		var xdir=Math.cos(cycle.rotation.z),ydir=Math.sin(cycle.rotation.z);
 		var xd = Math.abs(xdir), yd = Math.abs(ydir);
 		var sens = 0;
 		if(cycle.sensor.left < 1) sens -= 0.02/cycle.sensor.left;
 		if(cycle.sensor.right < 1) sens += 0.02/cycle.sensor.right;
 		if(sens > 1) sens = 1;
 		if(sens < -1) sens = -1;
 		
 		cycle.rotation.x -= xd*(((cycle.rotation.x)*frametime*4)+(sens*frametime*xdir));
 		cycle.rotation.y -= yd*(((cycle.rotation.y)*frametime*4)+(sens*frametime*ydir));
 		
+		if(cycle.chatting != cycle.chatarrow.visible) cycle.chatarrow.visible = cycle.chatting;
+		if(cycle.chatting)
+		{
+			cycle.chatarrow.rotation.z += frametime;
+		}
+		
 		//sound
 		mixCycle(cycle);
 	}
 	
 	if(settings.WALLS_STAY_UP_DELAY >= 0)
 	{
 		for(var x=engine.players.length;x>=0;x--) if(engine.players[x] !== undefined)
 		{
 			if(!engine.players[x].alive && timenow-engine.players[x].dedtime >= settings.WALLS_STAY_UP_DELAY*1000)
 			{
 				if(engine.players[x].walls.scale.z > 0)
 				{
 					engine.players[x].walls.scale.z -= frametime*2;
 				}
 				else
 				{
 					engine.scene.remove(engine.players[x].walls);
 				}
 			}
 		}
 	}
 	
 	for(var x=engine.expl.length-1;x>=0;x--)
 	{
 		if(engine.expl[x].children[0].material.opacity <= 0)
 		{
 			engine.scene.remove(engine.expl[x]);
 			engine.expl.splice(x,1);
 		}
 		else for(var y=engine.expl[x].children.length-1;y>=0;y--)
 		{
 			engine.expl[x].children[y].scale.x = engine.expl[x].children[y].scale.y = engine.expl[x].children[y].scale.z += frametime*10;
 			//engine.expl[x].children[y].position.z += frametime;
 			if(engine.expl[x].children[y].scale.z > 10)
 			{
 				engine.expl[x].children[y].material.opacity -= frametime/25;
 			}
 		}
 	}
 	
 	if(settings.FLOOR_MIRROR && typeof(engine.grid.reflection) != "undefined")
 	{
 		engine.grid.visible = false;
 		engine.grid.reflection.update(engine.renderer,engine.scene);
 		engine.grid.visible = true;
 	}
 	
 	if(settings.RIM_WALL_COLOR_MODE == 3)
 	{
 		var color = engine.walls.children[0].material.color;
 		var p = settings.COLOR_MODE_3_COLORS.split(";");
 		var c = p[engine.currrim3clr].split(",");
 		//var c = {r:parse[0],g:parse[1],b:parse[2]};
 		var sum = color.r+color.g+color.b;
 		var keys = Object.keys(color);
 		for(var x=keys.length-1;x>=0;--x)
 		{
 			if(c[x] < color[keys[x]])
 			{
 				color[keys[x]] -= frametime*settings.COLOR_MODE_3_SPEED;
 			}
 			else if(c[x] > color[keys[x]])
 			{
 				color[keys[x]] += frametime*settings.COLOR_MODE_3_SPEED;
 			}
 			if(color[keys[x]] > 1)
 				color[keys[x]] = 1;
 			if(color[keys[x]] < 0)
 				color[keys[x]] = 0;
 		}
 		//console.log(color,c);
 		if(color.r == c[0] && color.g == c[1] && color.b == c[2])
 		{
 			engine.currrim3clr += 1;
 			if(engine.currrim3clr >= p.length)
 				engine.currrim3clr = 0;
 		}
 		for(var x=engine.walls.children.length-1;x>=0;--x)
 		{
 			engine.walls.children[x].material.color = color;
 		}
 	}
 
 	if(timenow > engine.cMFadeOutAfter)
 	{
 		var cm = document.getElementById("centerMessage")
 		cm.style.opacity -= frametime;
 		if(cm.style.opacity <= 0)
 		{
 			cm.style.opacity = 0;
 			cm.style.display = "none";
 			engine.cMFadeOutAfter = Infinity;
 		}
 	}
 	
 	if(engine.hud.fadein && engine.hud.game.style.opacity < 1)
 	{
 		engine.hud.game.style.opacity = (engine.hud.game.style.opacity*1)+(frametime*0.25); //workaround for opacity being a string
 		if(engine.hud.game.style.opacity > 1) engine.hud.game.style.opacity = 1;
 	}
 	else if(!engine.hud.fadein && engine.hud.game.style.opacity > 0)
 	{
 		engine.hud.game.style.opacity -= frametime*0.25;
 		if(engine.hud.game.style.opacity < 0) engine.hud.game.style.opacity = 0;
 	}
 	
 	//update HUD (needs to be done for cycle being viewed)
 	var cycle = engine.players[engine.viewTarget];
 	updateHUD("player_rubber",cycle.rubber,0,settings.CYCLE_RUBBER);
 	var maxspeed = maxSpeed();
 	updateHUD("player_speed",cycle.speed,0,maxspeed);
 	updateHUD("player_brake",cycle.brakes,0,1);
 	updateHUD("max_speed",maxspeed);
 	updateHUD("player_acceleration",cycle.accel);
 	updateHUD("dist_to_impact_front",cycle.sensor.front);
 	updateHUD("time_to_impact_front",cycle.sensor.front/cycle.speed);
 	updateHUD("dist_to_impact_left",cycle.sensor.left);
 	updateHUD("time_to_impact_left",cycle.sensor.left/cycle.speed);
 	updateHUD("dist_to_impact_right",cycle.sensor.right);
 	updateHUD("time_to_impact_right",cycle.sensor.right/cycle.speed);
 	updateHUD("current_name",cycle.name);
 	updateHUD("current_pos_x",cycle.position.x,engine.logicalBox.min.x*engine.REAL_ARENA_SIZE_FACTOR,engine.logicalBox.max.x*engine.REAL_ARENA_SIZE_FACTOR);
 	updateHUD("current_pos_y",cycle.position.y,engine.logicalBox.min.y*engine.REAL_ARENA_SIZE_FACTOR,engine.logicalBox.max.y*engine.REAL_ARENA_SIZE_FACTOR);
 	updateHUD("current_pos_x_adj",cycle.position.x/engine.REAL_ARENA_SIZE_FACTOR,engine.logicalBox.min.x,engine.logicalBox.max.x);
 	updateHUD("current_pos_y_adj",cycle.position.y/engine.REAL_ARENA_SIZE_FACTOR,engine.logicalBox.min.y,engine.logicalBox.max.y);
 	var dir = cdir(cycle.rotation.z);
 	updateHUD("current_angle_x",dir[0]);
 	updateHUD("current_angle_y",dir[1]);
 	
 	updateHUD("current_time",Math.round(timeElapsed)/1000);
 	
 	//settings test
 	var setnames = Object.keys(settings);
 	for(var i=setnames.length;i--;)
 	{
 		var setting = setnames[i];
 		updateHUD(setting.toLowerCase(),settings[setting]);
 	}
 	
 	
 	//actual drawing
 	
 	/*if(engine.players[engine.viewTarget].alive)*/ cameraView(engine.players[engine.viewTarget],frametime*engine.timemult);
 	
 	if(ctx) audioMixing();
 	
 	//renderer switch for post processing
 	if (engine.usingPostProcessing) {
 		engine.composer.render();//new render? for post processing
 	}
 	else {
 		engine.renderer.render(engine.scene, engine.camera);
 	}
 	engine.framesCount++;
 }
 
 function updateHUD(celement,thevalue,min=false,max=false)
 {
 	var elements = document.getElementsByName(celement);
 	for(var i=elements.length;i--;)
 	{
 		var value = thevalue;
 		var element = elements[i];
 		if(min && element.attributes.min) element.setAttribute("min",min);
 		if(max && element.attributes.max) element.setAttribute("max",max);
 		if(element.attributes.precision) 
 		{
 			var prec = Math.pow(10,element.attributes.precision.value); 
 			value = Math.round(value*prec)/prec;
 			if(isNaN(value)) value = 0;
 		}
 		if(element.attributes.toprecision) 
 		{
 			var prec = 1*element.attributes.toprecision.value;
 			if(!element.attributes.dontlimit)
 			{
 				value = parseFloat(value).toPrecision(prec-1+((""+Math.round(thevalue)).length));
 			}
 			else
 			{
 				value = value.toPrecision(prec);
 			}
 		}
 		//if(element.attributes.precision) element.attributes.precision.value==0?value=Math.round(value):value.toPrecision(element.attributes.precision.value);
 		//if(value)
 		{
 			if(element.tagName == "PROGRESS") 
 			{
 				element.setAttribute("value",value);
 				//console.log(value);
 			}
 			else if(element.className == "progress") 
 			{
 				element.style.width = (Math.min(1,value/max)*100)+"%";
 			}
 			else if(!element.attributes.ignoretext)
 			{
 				element.innerHTML = ""+value;
 			}
 			if(element.attributes.bgcolorgrad)
 			{
 				var grad = element.attributes.bgcolorgrad.value;
 				var p = grad.split(";");
 				var c1 = p[0].split(",");
 				var c2 = p[1].split(",");
 				var color = {r:c1[0]*1,g:c1[1]*1,b:c1[2]*1},key=['r','g','b'];
 				var progval = (value/max)*15;
 				for(var x=0;x<3;x++)
 				{
 					if(c1[x] < c2[x])
 					{
 						color[key[x]] += progval;
 					}
 					else if(c1[x] > c2[x])
 					{
 						color[key[x]] -= progval;
 					}
 				}
 				element.style.backgroundColor = "rgb("+(color.r*255)+","+(color.g*255)+","+(color.b*255)+")";
 			}
 		}
 	}
 }
 
 function draw2d_canvas() //TODO: have an svg output option
 {
 	var canvas = document.getElementById("canvas");
 	if(!canvas) return;
 	var ctx = canvas.getContext("2d");
 	ctx.clearRect(0,0,canvas.width,canvas.height);
 	var xsize = engine.logicalBox.max.x-engine.logicalBox.min.x, ysize = engine.logicalBox.max.y-engine.logicalBox.min.y;
 	canvas.width = canvas.offsetWidth;
 	canvas.height = canvas.offsetWidth*(ysize/xsize);
 	ctx.scale(
 		canvas.width/(xsize*engine.REAL_ARENA_SIZE_FACTOR),
 		canvas.height/(ysize*engine.REAL_ARENA_SIZE_FACTOR),
 	);
 	var ax = engine.logicalBox.min.x * engine.REAL_ARENA_SIZE_FACTOR, 
 		ay = engine.logicalBox.min.y * engine.REAL_ARENA_SIZE_FACTOR;
 	ctx.lineWidth = ((xsize*engine.REAL_ARENA_SIZE_FACTOR)/canvas.width);
 	//ctx.lineWidth = canvas.width-canvas.height-2;
 	//ctx.lineWidth = (canvas.offsetWidth-canvas.width)*engine.REAL_ARENA_SIZE_FACTOR;
 	ctx.strokeStyle = "white";
 	for(var i=engine.map.walls.length-1;i>=0;i--)
 	{
 		ctx.beginPath();
 		var spl = engine.map.walls[i][engine.map.walls[i].length-1];
 		ctx.moveTo(1*spl[0],1*spl[1]);
 		for(var z=engine.map.walls[i].length-1;z>=0;z--)
 		{
 			var spl = engine.map.walls[i][z];
 			ctx.lineTo(1*spl[0]-ax,1*spl[1]-ay);
 			//console.log(spl[0],spl[1]);
 		}
 		ctx.stroke();
 	}
 	for(var x=engine.players.length-1;x>=0;x--) if(engine.players[x] !== undefined)
 	{
 		var color = engine.players[x].walls.children[0].children[0].material.color;
 		ctx.strokeStyle = "rgb("+(color.r*255)+","+(color.g*255)+","+(color.b*255)+")";
 		ctx.beginPath();
 		if(engine.players[x].walls.map.length > 0)
 		{
 			var walls = engine.players[x].walls.map;
 			ctx.moveTo(walls[walls.length-1][0]-ax,walls[walls.length-1][1]-ay);
 			for(var i=walls.length-1;i>=0;i--)
 			{
 				ctx.lineTo(walls[i][0]-ax,walls[i][1]-ay);
 			}
 		}
 		ctx.stroke();
 		if(engine.players[x].alive)
 		{
 			var color = new THREE.Color(engine.players[x].cycleColor);
 			ctx.fillStyle = "rgb("+(color.r*255)+","+(color.g*255)+","+(color.b*255)+")";
 			ctx.beginPath();
 			ctx.arc(engine.players[x].position.x-ax,engine.players[x].position.y-ay, ctx.lineWidth, 0,Math.PI*2);
 			ctx.fill();
 		}
 	}
 	
 	var lw = ctx.lineWidth;
 	ctx.lineWidth = lw*settings.ZONE_ALPHA*settings.ZONE_ALPHA_SERVER;
 	for(var x=engine.zones.children.length-1;x>=0;--x)
 	{
 		var zone = engine.zones.children[x];
 		var color = zone.material.color;
 		ctx.strokeStyle = "rgb("+(color.r*255)+","+(color.g*255)+","+(color.b*255)+")";
 		var geo = zone.geometry.clone(); geo.applyMatrix(zone.matrix); //apply rotation, scale, and position
 		
 		ctx.beginPath();
 		var pX = zone.position.x-ax, pY = zone.position.y-ay;
 		for(var i=geo.faces.length-2;i>=0;i-=2)
 		{
 			ctx.moveTo(geo.vertices[geo.faces[i].b].x-ax,geo.vertices[geo.faces[i].b].y-ay);
 			ctx.lineTo(geo.vertices[geo.faces[i].a].x-ax,geo.vertices[geo.faces[i].a].y-ay);
 		}
 		ctx.stroke();
 	}
 	
 	lw *= 0.7;
 	for(var x=engine.expl.length-1;x>=0;x--)
 	{
 		ctx.lineWidth = lw*engine.expl[x].children[0].material.opacity;
 		if(ctx.lineWidth > 0)
 		{
 			var scale = (engine.expl[x].children[0].scale.x+engine.expl[x].children[0].scale.y)/2;
 			var cx = engine.expl[x].children[0].position.x, cy = engine.expl[x].children[0].position.y;
 			for(var y=engine.expl[x].children.length;y--;)
 			{
 				var color = engine.expl[x].children[y].material.color;
 				ctx.strokeStyle = "rgb("+(color.r*255)+","+(color.g*255)+","+(color.b*255)+")";
 				ctx.beginPath();
 				ctx.moveTo(cx-ax,cy-ay);
 				ctx.lineTo(
 					(cx+engine.expl[x].children[y].geometry.vertices[1].x*scale)-ax,
 					(cy+engine.expl[x].children[y].geometry.vertices[1].y*scale)-ay
 				);
 				ctx.stroke();
 			}
 		}
 	}
 	draw2dmap = true;
 }
 
 
 //camera view function (handles all views for view target)
 var cameraView = function(cycle, timestep) {
 	var relativeCameraOffset, cameraOffset;
 	var cameraEase = engine.cameraEase;
 	
 	if(engine.camera.userViewDir !== false) // HACK: camera rotation
 	{
 		var realRot = cycle.rotation.z;
 		cycle.rotation.z = Math.atan2(engine.camera.userViewDir[1],engine.camera.userViewDir[0]);
 		cycle.updateWorldMatrix();
 		cycle.rotation.z = realRot;
 	}
 
 	switch(engine.view)
 	{
 		case 'smart':
 			if(engine.camera.userViewDir === false)
 			{
 				//relativeCameraOffset = new THREE.Vector3(-5,0,5+cycle.speed);
 				relativeCameraOffset = new THREE.Vector3(-5,0,(5+cycle.speed*0.006));
 				cameraOffset = relativeCameraOffset.applyMatrix4(cycle.matrixWorld);
 				engine.camera.position.x += (cameraOffset.x - engine.camera.position.x) * (engine.cameraEase/3) * timestep*60;
 				engine.camera.position.y += (cameraOffset.y - engine.camera.position.y) * (engine.cameraEase/3) * timestep*60;
 				engine.camera.position.z += (cameraOffset.z - engine.camera.position.z) * (engine.cameraEase/5) * timestep*60;
 				engine.camera.lookAt(cycle.position);
 				break;
 			}
 			else
 			{
 				relativeCameraOffset = new THREE.Vector3((-10-(cycle.speed*0.006)),0,(5+cycle.speed*0.006));
 				cameraEase = 0.3;
 				// [[FALLTHROUGH]]
 			}
 		case 'chase':
 			if(!relativeCameraOffset) relativeCameraOffset = new THREE.Vector3((-10-(cycle.speed*0.006)),0,(15+cycle.speed*0.006));
 			cameraOffset = relativeCameraOffset.applyMatrix4(cycle.matrixWorld);
 			engine.camera.position.x += (cameraOffset.x - engine.camera.position.x) * cameraEase * timestep*60;
 			engine.camera.position.y += (cameraOffset.y - engine.camera.position.y) * cameraEase * timestep*60;
 			engine.camera.position.z += (cameraOffset.z - engine.camera.position.z) * cameraEase * timestep*60;
 			engine.camera.lookAt(cycle.position);
 			break;
 		case 'custom':
 			engine.camera.position.set(0,0,0);
 			engine.camera.rotation.z = settings.CAMERA_CUSTOM_PITCH;
 			break;
 		case 'stationary':
 			break;
 		case 'track':
 			engine.camera.lookAt(cycle.position);
 			break;
 		case 'topdown':
 			engine.camera.position.set(cycle.position.x, (cycle.position.y-0.01), (10+cycle.speed*timestep));
 			engine.camera.lookAt(cycle.position);
 			break;
 		case 'birdseye':
 			relativeCameraOffset = new THREE.Vector3(-0.1, 0, 10+(cycle.speed*timestep));
 			cameraOffset = relativeCameraOffset.applyMatrix4(cycle.matrixWorld);
 			engine.camera.position.x += (cameraOffset.x - engine.camera.position.x) * engine.cameraEase * timestep*60;
 			engine.camera.position.y += (cameraOffset.y - engine.camera.position.y) * engine.cameraEase * timestep*60;
 			engine.camera.position.z += (cameraOffset.z - engine.camera.position.z) * engine.cameraEase * timestep*60;
 //			engine.camera.position.set(cycle.position.x, cycle.position.y, (10+cycle.speed));
 //			engine.camera.rotation.z = cycle.rotation.z;
 	 		engine.camera.lookAt(cycle.position);
 			break;
 		case 'cockpit':
 			/**/// cockpit
 			//if(cycle.speed > 2)
 			{
 				relativeCameraOffset = new THREE.Vector3(-2+(2.5*cycle.speed),0,0.5);
 			}
 			/*else
 			{
 				relativeCameraOffset = new THREE.Vector3(0.01,0,0.5);
 			}*/
 			cameraOffset = relativeCameraOffset.applyMatrix4(cycle.matrixWorld);
 			engine.camera.position.set(cycle.position.x,cycle.position.y,cycle.position.z+0.5);
 			//engine.camera.rotation.set(cycle.rotation.x,cycle.rotation.y,0);
 //			engine.camera.position.x += (cameraOffset.x - engine.camera.position.x) * 0.5;
 //			engine.camera.position.y += (cameraOffset.y - engine.camera.position.y) * 0.5;
 //			engine.camera.position.z = 2;
 		 	engine.camera.lookAt(cameraOffset);
 			//engine.camera.rotation.z = cycle.rotation.x+cycle.rotation.y;
 
 //		 	cycle.audio.gain.setTargetAtTime(0.2, ctx.currentTime, 0.02);
 			//cycle.textLabel.style.visibility = 'hidden';
 			//cycle.model.visible = false;
 
 			/*/
 			if (cycle.walls.children[cycle.walls.children.length-2]) {
 				cycle.walls.children[cycle.walls.children.length-1].visible = false;
 				cycle.walls.children[cycle.walls.children.length-2].visible = true;
 			}
 			/**/
 			break;
 	}
 };