Page MenuHomePhabricator
Files F61382

No OneTemporary
Actions

View Options

diff --git a/scripts/buildObjects.js b/scripts/buildObjects.js
index 14f266f..a0f27cd 100644
--- a/scripts/buildObjects.js
+++ b/scripts/buildObjects.js
@@ -1,1787 +1,1787 @@
/*
* 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(settings.FLOOR_TEXTURE);
- engine.textures.rim_wall = new new THREE.TextureLoader().load(settings.RIM_WALL_TEXTURE);
- engine.textures.cycle_wall = new new THREE.TextureLoader().load('images/textures/dir_wall.png');
- engine.textures.cycle_body = new THREE.TextureLoader().load('images/textures/cycle_body.png');
- engine.textures.cycle_wheel = new THREE.TextureLoader().load('images/textures/cycle_wheel.png')
+ engine.textures.floor = new new THREE.TextureLoader().load("images/"+settings.FLOOR_TEXTURE);
+ engine.textures.rim_wall = new new THREE.TextureLoader().load("images/"+settings.RIM_WALL_TEXTURE);
+ //engine.textures.cycle_wall = new new THREE.TextureLoader().load('images/textures/dir_wall.png');
+ engine.textures.cycle_body = new THREE.TextureLoader().load("images/"+settings.CYCLE_TEXTURES[0]);
+ engine.textures.cycle_wheel = new THREE.TextureLoader().load("images/"+settings.CYCLE_TEXTURES[1])
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 zonesType = "death", color = false, value = 0;
if (mapsZones[p].hasAttribute("effect")) { zonesType = mapsZones[p].getAttribute("effect"); }
var point = mapsZones[p].getElementsByTagName("Point");
var zonesXpos = (point[0].getAttribute("x") * engine.REAL_ARENA_SIZE_FACTOR);
var zonesYpos = (point[0].getAttribute("y") * engine.REAL_ARENA_SIZE_FACTOR);
var circle = mapsZones[p].getElementsByTagName("ShapeCircle");
if(circle)
{
var zonesRadius = (circle[0].getAttribute("radius") * engine.REAL_ARENA_SIZE_FACTOR);
var zonesExpansion = circle[0].getAttribute("growth")*1;
}
else
{
var polygon = mapsZones[p].getElementsByTagName("ShapePolygon");
if(polygon)
{
}
}
if(isNaN(zonesExpansion)) zonesExpansion = 0;
var colorelement = mapsZones[p].getElementsByTagName("Color")[0];
if(colorelement)
{
if(colorelement.attributes.hexCode)
{
color = 1*(colorelement.getAttribute("hexCode"));
}
else if(colorelement.attributes.r || colorelement.attributes.g || colorelement.attributes.b)
{
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)
{
var r=colorelement.getAttribute("red"),g=colorelement.getAttribute("green"),b=colorelement.getAttribute("blue");
var a = colorelement.attributes.alpha?colorelement.getAttribute("alpha"):1;
color = new THREE.Color(r,g,b);
}
}
var delay = mapsZones[p].attributes.delay?mapsZones[p].getAttribute("delay"):0;
switch(zonesType)
{
case "rubber":
value = mapsZones[p].getAttribute("rubberVal");
break;
case "speed": case "acceleration":
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({type:zonesType,x:zonesXpos,y:zonesYpos,radius:zonesRadius,color:color}).spawn();
}
//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;
};
/*—–––––––––––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;
+ /*var texture = engine.textures.cycle_wall;
texture.wrapS = THREE.RepeatWrapping;
- texture.repeat.set(xy,1);
+ 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/config.js b/scripts/config.js
index d77a96a..56d0e08 100644
--- a/scripts/config.js
+++ b/scripts/config.js
@@ -1,1336 +1,1338 @@
/*
* 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.
*/
/*class Setting
{
constructor(conf)
{
switch(typeof(conf))
{
case "object": this = conf; break;
}
}
push()
{
settings_work[this.name] = this;
settings[this.name] = this.val;
}
}
//new Setting({name:"VERIFY_COLOR_STRICT",val:false}).push();
var settings_work = {};*/
settings = {
VERIFY_COLOR_STRICT: false,
TEXT_BRIGHTEN: false,
TEXT_DARK_HIGHLIGHT: true,
FONT_MIN_R: 0.5, FONT_MIN_G: 0.5, FONT_MIN_B: 0.5,
FONT_MIN_TOTAL: 0.7,
CHAT_LAYER: 0.5,
TEXT_OUT: function(params=undefined){if(params !== undefined) engine.console.style.display=params?"block":"none"; return engine.console.style.display!="none";},
TEXT_OUT_MODE: 1,
FULLSCREEN: function(params=undefined){
if(params !== undefined)
{
var bd = document.body;
if(params)
{
if(bd.requestFullscreen) bd.requestFullscreen();
else if(bd.webkitRequestFullscreen) bd.webkitRequestFullscreen();
else if(bd.mozRequestFullScreen) bd.mozRequestFullScreen();
else if(bd.msRequestFullscreen) bd.msRequestFullscreen();
else alert("Can't go into fullscreen. Please alert nelg with information on what browser you're using.")
}
else
{
if(bd.exitFullscreen) bd.exitFullscreen();
else if(document.webkitExitFullscreen) document.webkitExitFullscreen();
else if(document.mozCancelFullScreen) document.mozCancelFullScreen();
//else if(document.msCancelFullscreen) bd.msCancelFullscreen();
else alert("Can't exit fullscreen. Please alert nelg with information on what browser you're using")
}
}
return Boolean(window.fullScreen || document.mozFullScreen || document.msFullScreen || document.webkitIsFullScreen || window.outerHeight - window.innerHeight <= 1);
},
//CAMERA
CAMERA_FOV: 60,
CAMERA_NEAR_RENDER: 0.001,
CAMERA_FAR_RENDER: 2000,
//GAME
GRID_SIZE: 1,
/*FLOOR_RED: 0.75,
FLOOR_GREEN: 0.75,
FLOOR_BLUE: 0.98,*/
FLOOR_RED: 0.03,
FLOOR_GREEN: 0.266,
FLOOR_BLUE: 0.8,
- FLOOR_TEXTURE: "images/textures/floor.png",
+ FLOOR_TEXTURE: "textures/floor.png",
/*GRID_SIZE: 2,
FLOOR_RED: 1,
FLOOR_GREEN: 1,
FLOOR_BLUE: 1,
- FLOOR_TEXTURE: "images/textures/moviepack_t_r_u_e/floor.png",*/
+ FLOOR_TEXTURE: "textures/moviepack_t_r_u_e/floor.png",*/
/*GRID_SIZE: 1,
FLOOR_RED: 0.01,
FLOOR_GREEN: 0.14,
FLOOR_BLUE: 0.35,
- FLOOR_TEXTURE: "images/textures/aaold/floor.png",*/
+ FLOOR_TEXTURE: "textures/aaold/floor.png",*/
FLOOR_MIRROR: false,
FLOOR_MIRROR_INT: 1,
+ CYCLE_TEXTURES: ["textures/cycle_body.png","textures/cycle_wheel.png"],
+
EXPLOSIONS: true,
HIGH_RIM: false,
LOW_RIM_HEIGHT: 50,
RIM_WALL_RED: 0,
RIM_WALL_GREEN: 0, // 0.533
RIM_WALL_BLUE: 0, // 1
RIM_WALL_ALPHA: 0.9,
RIM_WALL_COLOR_MODE: 3,
RIM_WALL_STRETCH_X: 50,
RIM_WALL_STRETCH_Y: 13.5,
RIM_WALL_WRAP_Y: false,
RIM_WALL_REPEAT_TOP: false,
- RIM_WALL_TEXTURE: "images/textures/futurerim.png",
+ RIM_WALL_TEXTURE: "textures/futurerim.png",
RIM_WALL_DEPTH: true,
RIM_WALL_LOWEST_HEIGHT: 0,
RIM_WALL_BELOW_HEIGHT_COLOR_R: 0,
RIM_WALL_BELOW_HEIGHT_COLOR_G: 0,
RIM_WALL_BELOW_HEIGHT_COLOR_B: 0,
/*RIM_WALL_RED: 1,
RIM_WALL_GREEN: 1,
RIM_WALL_BLUE: 1,
RIM_WALL_ALPHA: 1,
RIM_WALL_COLOR_MODE: 0,
//RIM_WALL_STRETCH_X: 300,
//RIM_WALL_STRETCH_Y: 50,
RIM_WALL_STRETCH_X: 128,
RIM_WALL_STRETCH_Y: 32,
LOW_RIM_HEIGHT: 32,
RIM_WALL_WRAP_Y: false,
- RIM_WALL_TEXTURE: "images/textures/moviepack_eddkeefe/rim_wall.png",
+ RIM_WALL_TEXTURE: "textures/moviepack_eddkeefe/rim_wall.png",
RIM_WALL_LOWEST_HEIGHT: 32,
RIM_WALL_BELOW_HEIGHT_COLOR_R: 166/255,
RIM_WALL_BELOW_HEIGHT_COLOR_G: 45/255,
RIM_WALL_BELOW_HEIGHT_COLOR_B: 237/255,//*/
RIM_WALL_RED: 1,
RIM_WALL_GREEN: 1,
RIM_WALL_BLUE: 1,
RIM_WALL_ALPHA: 1,
RIM_WALL_COLOR_MODE: 0,
//RIM_WALL_STRETCH_X: 300,
//RIM_WALL_STRETCH_Y: 50,
RIM_WALL_STRETCH_X: 1536,
RIM_WALL_STRETCH_Y: 32,
LOW_RIM_HEIGHT: 32,
RIM_WALL_WRAP_Y: false,
- RIM_WALL_TEXTURE: "images/textures/moviepack_t_r_u_e/movie-rim-wall.png",
+ RIM_WALL_TEXTURE: "textures/moviepack_t_r_u_e/movie-rim-wall.png",
RIM_WALL_DEPTH: true,
RIM_WALL_LOWEST_HEIGHT: 32,
/*RIM_WALL_BELOW_HEIGHT_COLOR_R: 188/255,
RIM_WALL_BELOW_HEIGHT_COLOR_G: 206/255,
RIM_WALL_BELOW_HEIGHT_COLOR_B: 250/255,//*/
RIM_WALL_BELOW_HEIGHT_COLOR_R: 0.5,
RIM_WALL_BELOW_HEIGHT_COLOR_G: 0.5,
RIM_WALL_BELOW_HEIGHT_COLOR_B: 0.7,
COLOR_MODE_3_COLORS: "1,0,0;1,1,0;0,1,0;0,1,1;0,0,1;1,0,1",
COLOR_MODE_3_SPEED: 0.2,
ALPHA_BLEND: true,
MENU_RENDER: "img",
REDRAW_MODE: 0,
TARGET_FPS: 1,
MAX_TARGET_FPS: 1000,
//DEDICATED_FPS: Infinity,
DEDICATED_FPS: 40,
GRAB_SENSORS_ON_TURN: true,
CYCLE_SENSORS_RANGE: 100,
GAME_LOOP: 0.5,
TIME_FACTOR: 1,
HUD_MAP: true,
ADMIN_KILL_MESSAGE: true,
//SOUNDS
SOUNDS_INTRO: false,
SOUNDS_EXTRO: false,
SOUNDS_COUNTDOWN: true,
SOUNDS_GO: false,
SOUNDS_ZONES: false,
MUSIC: 0,
//ZONES
ZONE_HEIGHT: 5,
ZONE_SEGMENTS: 11,//arma render only
ZONE_SEG_LENGTH: 0.5,//arma render only
ZONE_ALPHA: 0.7,
ZONE_SPIN_SPEED: 0.05,
ZONE_RENDER_TYPE: 'arma',//cylinder or arma
//player (for armagetron nabs) //can't have people changing these on a server
PLAYER_1: function(val) { if(engine.dedicated) return (settings.PLAYER_1 = "Player 1"); if(typeof(val) != "undefined") {settings.players[0].name=val;} return settings.players[0].name; },
COLOR_R_1: function(r=undefined) { if(engine.dedicated) return (settings.COLOR_R_1=13); return plnumcolors({r:r}) },
COLOR_G_1: function(g=undefined) { if(engine.dedicated) return (settings.COLOR_G_1=13); return plnumcolors({g:g}) },
COLOR_B_1: function(b=undefined) { if(engine.dedicated) return (settings.COLOR_B_1=0); return plnumcolors({b:b}) },
PLAYER_DEL_HIST_PERROUND: true, //what was this?
TIMESTEP_MAX: 0.2,
//debug
DEBUG_EVERYONE_IS_AI: false,
HACK_TURN_LEFT_WHEN_POSSIBLE: 0,
HACK_TURN_RIGHT_WHEN_POSSIBLE: 0,
HACK_TURN_SENSOR_DIST: 5,
CHATBOT_ALWAYS_ACTIVE: false,
//NETWORK
CONNECT_PORT: 8765,
CONNECT_HOST: "armagetron.kevinh.us",
CONNECT_SSL: true,
CYCLE_SMOOTH_TIME: 0.3,
CYCLE_SYNC_INTERVAL: 0.1,
SERVER_PORT: 8765,
SERVER_NAME: "Unnamed Server",
SERVER_DNS: "",
SERVER_SSL_ENABLED: false,
SERVER_SSL_KEY: "",
SERVER_SSL_CERT: "",
};
if(!Detector.webgl)
{
//choose better defaults for the software renderer
settings.HIGH_RIM = false;
settings.LOW_RIM_HEIGHT = 4;
settings.RIM_WALL_TEXTURE = "";
settings.RIM_WALL_DEPTH = false;
settings.ALPHA_BLEND = false;
}
game_settings_default = {
AI_FORCE_BRAKE: false,
//CYCLE
CYCLE_ACCEL: 10,
CYCLE_ACCEL_ENEMY: 1,
CYCLE_ACCEL_OFFSET: 2,
CYCLE_ACCEL_RIM: 0,
CYCLE_ACCEL_SELF: 1,
CYCLE_ACCEL_SLINGSHOT: 1,
CYCLE_ACCEL_TEAM: 1,
CYCLE_ACCEL_TUNNEL: 1,
CYCLE_WALL_NEAR: 6,
CYCLE_BRAKE: 30,
CYCLE_BRAKE_DEPLETE: 1,
CYCLE_BRAKE_REFILL: 0.1,
CYCLE_BOOST: 0,
CYCLE_JUMP: 0.5,
CYCLE_JUMP: 0,
CYCLE_MIDAIR_JUMP: false,
CYCLE_MIDAIR_TURN: false,
CYCLE_WALL_RAMP_ENABLE: true,
CYCLE_DELAY: 0.02,
CYCLE_RUBBER: 5,
CYCLE_RUBBER_TIME: 10,
//CYCLE_RUBBER_TIMEBASED: 0,
CYCLE_RUBBER_MINDISTANCE: 0.03,
CYCLE_RUBBER_MINADJUST: 0.05,
CYCLE_RUBBER_DEPLETE_RIM: true,
CYCLE_RUBBER_DEPLETE_SELF: true,
CYCLE_RUBBER_DEPLETE_ENEMY: true,
CYCLE_SOUND_SPEED: 30,
CYCLE_SPEED: 20,
CYCLE_SPEED_DECAY_ABOVE: 0.1,
CYCLE_SPEED_DECAY_BELOW: 5,
CYCLE_SPEED_MAX: 0,
CYCLE_SPEED_MIN: 0.25,
CYCLE_START_SPEED: 20,
CYCLE_TURN_MEMORY: 3,
CYCLE_TURN_SPEED_FACTOR: 0.95,
WALLS_LENGTH: 600,
//WALLS_LENGTH: 30,
RESPAWN_TIME: -1,
CYCLE_FIRST_SPAWN_PROTECTION: false,
CYCLE_WALL_TIME: 5,
CYCLE_INVULNERABILITY_TIME: -1,
WALLS_STAY_UP_DELAY: 1,
//TEAMS
TEAMS_MAX_PLAYERS: 1,
TEAMS_MIN_PLAYERS: 1,
TEAMS_MAX: 16,
TEAMS_MIN: 4,
//TEAMS_MIN: 2,
TEAM_ALLOW_SHUFFLE_IP: 0,
ALLOW_TEAM_NAME_PLAYER: true,
ALLOW_TEAM_NAME_COLOR: true,
MIN_PLAYERS: 1,
NUM_AIS: 0,
TEAM_NAME_1: "Team Blue", //name of team 1
TEAM_RED_1: 4, //red portion of team 1's color
TEAM_GREEN_1: 8, //green portion of team 1's color
TEAM_BLUE_1: 15, //blue portion of team 1's color
TEAM_NAME_2: "Team Gold", //name of team 2
TEAM_RED_2: 15, //red portion of team 2's color
TEAM_GREEN_2: 15, //green portion of team 2's color
TEAM_BLUE_2: 4, //blue portion of team 2's color
TEAM_NAME_3: "Team Red", //name of team 3
TEAM_RED_3: 15, //red portion of team 3's color
TEAM_GREEN_3: 4, //green portion of team 3's color
TEAM_BLUE_3: 4, //blue portion of team 3's color
TEAM_NAME_4: "Team Green", //name of team 4
TEAM_RED_4: 4, //red portion of team 4's color
TEAM_GREEN_4: 15, //green portion of team 4's color
TEAM_BLUE_4: 4, //blue portion of team 4's color
TEAM_NAME_5: "Team Violet", //name of team 5
TEAM_RED_5: 15, //red portion of team 5's color
TEAM_GREEN_5: 4, //green portion of team 5's color
TEAM_BLUE_5: 15, //blue portion of team 5's color
TEAM_NAME_6: "Team Cyan", //name of team 6
TEAM_RED_6: 4, //red portion of team 6's color
TEAM_GREEN_6: 15, //green portion of team 6's color
TEAM_BLUE_6: 15, //blue portion of team 6's color
TEAM_NAME_7: "Team White", //name of team 7
TEAM_RED_7: 15, //red portion of team 7's color
TEAM_GREEN_7: 15, //green portion of team 7's color
TEAM_BLUE_7: 15, //blue portion of team 7's color
TEAM_NAME_8: "Team Black", //name of team 8
TEAM_RED_8: 8, //red portion of team 8's color
TEAM_GREEN_8: 8, //green portion of team 8's color
TEAM_BLUE_8: 8, //blue portion of team 8's color
//MAP
ARENA_AXES: 4,
STRICT_AXES_SPAWN: true,
RESOURCE_REPOSITORY_CACHE: './cache/resource/',
MAP_FILE: 'Anonymous/polygon/regular/square-1.0.1.aamap.xml',
MAP_ROTATION: "",
ROTATION_TYPE: 0, //1:round, 2:match
RESOURCE_REPOSITORY_SERVER: 'https://www.armanelgtron.tk/armagetronad/resource/',
//RESOURCE_REPOSITORY_BACKUP: 'http://resource.armagetronad.net/resource/',
SIZE_FACTOR: -3,
ARENA_BOUNDARY: -10,
ARENA_BOUNDARY_KILLS: true,
ZONE_ALPHA_SERVER: 1,
//GAME PLAY
GAME_TYPE: 1,
FINISH_TYPE: 2,
LIMIT_ROUNDS: 10,
LIMIT_TIME: 30,
LIMIT_SCORE: 100,
ROUND_WAIT: false,
//SHOOTING
SHOT_THRESH: 2,
//WIN ZONE
WIN_ZONE_DEATHS: false,
WIN_ZONE_EXPANSION: 1,
WIN_ZONE_INITIAL_SIZE: 5,
WIN_ZONE_RANDOMNESS: 0.8,
WIN_ZONE_MIN_LAST_DEATH: 30,
WIN_ZONE_MIN_ROUND_TIME: Infinity, //60
//FORTRESS
FORTRESS_CONQUEST_RATE: 0.5,
FORTRESS_CONQUEST_DECAY_RATE: 0.1,
//SPAWN
SPAWN_WINGMEN_SIDE: 2.75362,
SPAWN_WINGMEN_BACK: 2.202896,
//ROUNDLY
ROUND_COMMAND: "",
ROUND_CONSOLE_MESSAGE: "",
ROUND_CENTER_MESSAGE: "",
//TARGET
DEFAULT_TARGET_COMMAND: "",
//TARGET_DECLARE_WINNER: true,
//TARGET_LIFETIME: -1,
TARGET_INITIAL_SCORE: 10,
//TARGET_SCORE_DEPLETE: 2,
//TARGET_SURVIVE_TIME: 10,
};
var sets = Object.keys(game_settings_default);
for(var i=0;i<sets.length;i++)
{
settings[sets[i]] = game_settings_default[sets[i]];
}
//possible admin commands (methods)
var commands = {
TOGGLE: function(params)
{
var split = params.split(" ");
if(split.length == 0)
{
engine.console.print("Usage: TOGGLE command <arguments to toggle between, seperated by a space>");
engine.console.print("If no additional arguments, toggles boolean commands between true and false.")
return false;
}
var cmd = split[0].toUpperCase();
if(split.length > 1)
{
var curr = chsetting(cmd,undefined,true), s = 0;
for(var i=0;i<split.length;i++)
{
if(curr = split[i]) s = i+1;
}
chsetting(cmd,split[s]);
}
else
{
chsetting(cmd,!chsetting(cmd,undefined,true));
}
},
CMD_VAL_ADD: function(params)
{
var split = params.split(" ");
split[0] = split[0].toUpperCase();
var from = chsetting(split[0],"",true);
var to = null;
switch(typeof(from))
{
case "number":
to = from+(split[1]*1);
break;
case "string":
to = from+split[1];
break;
}
chsetting(split[0],to);
},
CMD_PASS_FUNC: function(params)
{
params=params.replace(/rand\((\d+),(\d+)\)/g,function(arg,v1,v2)
{
console.log(arg,v1,v2);
return Math.round((Math.random()*(v2-v1))+v1);
});
loadcfg(params);
},
DELAY_COMMAND: function(params)
{
var interval=0,delay=0,cmd="";
var s = params.split(" ");
if(s[0][0] == "r") //assume repeat
{
interval = 1*(s.slice(0,1)[0].substr(1));
}
if(s[0][0] == "+")
{
delay = engine.gtime+(1*(s.slice(0,1)[0].substr(1)));
}
else
{
delay = 1*s.slice(0,1);
}
cmd = s.join(" ");
engine.delayedcommands[delay] = [cmd,interval];
engine.console.print("Delay command: \""+cmd+"\" at "+delay+"s, interval "+interval+"s.");
},
DELAY_COMMAND_CLEAR: function(params)
{
engine.delayedcommands = {};
engine.console.print("Cleared all delayed commands.");
},
MERGE_OBJ: function(params)
{
var pos = params.indexOf(" ");
var name = params.substr(0,pos), cfg = JSON.parse(params.substr(pos+1));
var sets = Object.keys(cfg);
for(var i=0;i<sets.length;i++)
{
if(typeof(settings[name][sets[i]]) != "undefined") settings[name][sets[i]] = cfg[sets[i]];
}
},
FLOOR_RED: updategrid, FLOOR_GREEN: updategrid, FLOOR_BLUE: updategrid, GRID_SIZE: updategrid,
CAMERA_FOV: function() {if(engine.camera){engine.camera.fov=settings.CAMERA_FOV;engine.camera.updateProjectionMatrix()}},
CAMERA_NEAR_RENDER: function() {if(engine.camera){engine.camera.near=settings.CAMERA_NEAR_RENDER;engine.camera.updateProjectionMatrix()}},
CAMERA_FAR_RENDER: function() {if(engine.camera){engine.camera.far=settings.CAMERA_FAR_RENDER;engine.camera.updateProjectionMatrix()}},
HUD_MAP: function()
{
document.getElementById("canvas").style.display = settings.HUD_MAP?"block":"none";
},
START_NEW_MATCH: function()
{
engine.round = 0;
engine.console.print("Resetting scores and starting new match after this round.");
centerMessage("New Match");
},
CONSOLE_MESSAGE: function(param) { engine.console.print(param+"\n") },
CENTER_MESSAGE: centerMessage,
SET_CYCLE_SPEED: function(params)
{
var s = params.split(" ");
var p = getPlayer(s[0]);
if(p) p.speed = s[1]*1;
},
SET_CYCLE_RUBBER: function(params)
{
var s = params.split(" ");
var p = getPlayer(s[0]);
if(p) p.rubber = s[1]*1;
},
SET_CYCLE_BRAKING: function(params)
{
var s = params.split(" ");
var p = getPlayer(s[0]);
if(p) p.braking = Boolean(1*s[1]);
},
SET_CYCLE_BRAKE: function(params)
{
var s = params.split(" ");
var p = getPlayer(s[0]);
if(p) p.brakes = s[2]*1;
},
RESPAWN: function(params)
{
var s = params.split(" ")
var p = getPlayer(s[0]);
if(p)
{
var cfg = {x:0,y:0,z:0,dir:0};
if(s.length > 2)
{
cfg.x = s[1]*engine.REAL_ARENA_SIZE_FACTOR; cfg.y = s[2]*engine.REAL_ARENA_SIZE_FACTOR;
if(s.length > 4)
{
cfg.dir = Math.atan2(s[4],s[3]);
if(settings.STRICT_AXES_SPAWN)
{
var deg = (pi(2)/settings.ARENA_AXES);
cfg.dir = Math.round(cfg.dir/deg)*deg;
}
}
}
p.spawn(cfg);
}
},
KILL: function(params)
{
var p = getPlayer(params);
if(p)
{
p.kill();
if(settings.ADMIN_KILL_MESSAGE)
engine.console.print(p.getColoredName()+"0xRESETT has been smitten by an administrator.\n");
}
},
KILL_ALL: function()
{
for(var x=engine.players.length-1;x>=0;--x) if(typeof(engine.players[x]) != "undefined")
{
engine.players[x].kill();
}
},
INCLUDE: function(params,silent=false,callback=undefined)
{
var file = params.replace(/\(.+\)/g,"");
var s = localStorage.getItem(file);
if(s == null && !engine.dedicated)
{
var incfile = settings.RESOURCE_REPOSITORY_CACHE+"../config/"+params;
engine.console.print("Loading CFG from "+incfile+"...\n");
httpGetAsync(incfile,function(txt){loadcfg(txt,silent);if(callback != undefined)callback();});
}
else
{
loadcfg(s,silent); if(callback != undefined)callback();
}
},
SINCLUDE: function(params) { commands.INCLUDE(params,true) },
RINCLUDE: function(params,callback=undefined)
{
var file = params.replace(/\(.+\)/g,"");
var incfile = settings.RESOURCE_REPOSITORY_SERVER+params;
engine.console.print("Downloading CFG from "+incfile+"...\n");
httpGetAsync(incfile,function(txt){loadcfg(txt);if(callback != undefined)callback();});
},
SPAWN_ZONE: function(params)
{
if(params == "")
{
engine.console.print("Usage:\nSPAWN_ZONE <win|death|ball|target|blast|object|koh> <x> <y> <size> <growth> <xdir> <ydir> <interactive> <r> <g> <b>\nSPAWN_ZONE <acceleration|speed> <speed> <x> <y> <size> <growth> <xdir> <ydir> <interactive> <r> <g> <b>\nSPAWN_ZONE <rubber|rubberadjust> <x> <y> <size> <growth> <xdir> <ydir> <rubber> <interactive> <r> <g> <b>\nSPAWN_ZONE <fortress|flag> <x> <y> <size> <growth> <xdir> <ydir> <interactive> <r> <g> <b>\n\nInstead of <x> <y> one can write: L <x1> <y1> <x2> <y2> [...] Z\nInstead of <size> one can write: P <scale> <x1> <y1> <x2> <y2> [...] Z");
}
else
{
var zone = {}, args = params.split(" ");
if(args[0] == "n")
{
zone.name = args.slice(0,2)[1];
}
zone.type = args[0];
if(zone.type == "acceleration" || zone.type == "speed")
{
zone.value = args.slice(1,2)[0];
}
if(args[1] === "L")
{
for(var i=2;args[i]=="Z"||i>args.length;i+=2)
{
if(i == 2)
{
zone.x = args[i] *engine.REAL_ARENA_SIZE_FACTOR;
zone.y = args[i+1]*engine.REAL_ARENA_SIZE_FACTOR;
}
}
args.slice(2,i);
}
else
{
zone.x = args[1]*engine.REAL_ARENA_SIZE_FACTOR;
zone.y = args[2]*engine.REAL_ARENA_SIZE_FACTOR;
}
if(args[3] === "P")
{
engine.console.print("WARNING: ShapePolygon may not currently work. Use at your own risk.\n",false);
for(var i=3;args[i]=="Z"||i>args.length;i+=2)
{
}
args.slice(3,i);
}
else
{
zone.radius = args[3]*engine.REAL_ARENA_SIZE_FACTOR;
}
zone.expansion = args[4]*1;
zone.xdir = args[5]*1; zone.ydir = args[6]*1;
zone.bounce = Boolean(parseInt+(args[7]))&&args[7]!="false";
if(args[7] != undefined)
{
zone.color = new THREE.Color(args[7]/15,args[8]/15,args[9]/15);
}
new Zone(zone).spawn();
console.log("new Zone: "+zone);
}
},
SPAWN_WALL: function(params)
{
if(params == "")
{
engine.console.print("Usage:\nSPAWN_WALL <height> <x1> <y1> <x2> <y2> [...]\n");
}
else
{
var params = params.split(" "), height = params.slice(0,1)[0]*1, points = [];
for(var q=0;q<params.length;q+=2)
{
points.push(
[
params[q]*engine.REAL_ARENA_SIZE_FACTOR,
params[q+1]*engine.REAL_ARENA_SIZE_FACTOR,
0, height
]
);
}
engine.walls.add(buildWall(points,height));
engine.map.walls.push(points);
}
},
SET_ZONE_POSITION: function(params)
{
var args = params.split(" ");
for(var x=engine.zones.children.length-1;x>=0;x--)
{
if(x == args[0])
{
engine.zones.children[x].position.x = args[1]*engine.REAL_ARENA_SIZE_FACTOR;
engine.zones.children[x].position.y = args[2]*engine.REAL_ARENA_SIZE_FACTOR;
return true;
}
}
engine.console.print("Invalid zone ID\n");
},
SET_AI_PATH: function(params)
{
var args = params.split(" ");
if(args[0] == "*")
{
}
else
{
var cycle = getPlayer(args.shift());
if(cycle)
{
for(var x=0,len=args.length;x<0;x+=2)
{
cycle.push([args[x],args[x+1]]);
}
}
else
{
engine.console.print("Usage: <AI Player name> <x1> <y1> <x2> <y2> ...");
}
}
},
CLEAR_AI_POSITION: function(params)
{
},
LIST_ZONES: function(params="")
{
var found = 0;
for(var x=0,len=engine.zones.children.length;x<len;x++)
{
var outputstr = "ID "+x+": ";
if(params == "" || outputstr.indexOf(params))
{
var zone = engine.zones[x];
engine.console.print(outputstr+zone.cfg.type+" zone @ "+zone.position.x/engine.REAL_ARENA_SIZE_FACTOR+","+zone.position.y/engine.REAL_ARENA_SIZE_FACTOR+".\n");
found++;
}
}
engine.console.print("Listed "+found+"/"+len+" zones.\n");
},
};
function updategrid() { if(!window.engine || !engine.scene) return; engine.scene.remove(engine.grid); buildGrid(); engine.scene.add(engine.grid); }
function plnumcolors(o)
{
if(typeof(o) == "object")
{
var r=o.r,g=o.g,b=o.b;
}
var retr = typeof(r) != "undefined",retb=typeof(g) != "undefined",retg=typeof(b) != "undefined";
if(r!=undefined)
{
var c_red=r&15,c_grn=g&15,c_blue=b&15;
var t_red=Math.max(15,r),t_grn=Math.max(15,g),t_blue=Math.max(15,b);
settings.players[0].cycleColor = "#"+(new THREE.Color(c_red,c_grn,c_blue)).toHexString();
settings.players[0].tailColor = "#"+(new THREE.Color(t_red,t_grn,t_blue)).toHexString();
}
var cycl=new THREE.Color(settings.players[0].cycleColor), tail=new THREE.Color(settings.players[0].tailColor);
var r=(cycl.r+(tail.r/15))/17,g=(cycl.g+(tail.g/15))/17,b=(cycl.b+(tail.b/15))/17
if(retr&&retg&&retb) return {r:r,g:g,b:b};
if(retr) return r; if(retg) return g; if(retb) return b;
}
function preset(name)
{
var leave = function() { for(var x=2;x--;) menu('exitmenu');
if(settings.TEXT_OUT_MODE == 1)
{
var lines = engine.console.scrollback,lnnum = engine.console.scrollby;
}
else
{
var lines = engine.console.innerText.split("\n"),lnnum = (-(parseFloat(engine.console.style.top)/engine.console.scrollby));
}
engine.console.scroll(lines.length-lnnum-6);
};
if(name != "default")
{
var tmp_settings = JSON.parse(JSON.stringify(game_settings_default));
tmp_settings.CYCLE_SPEED = 20;
tmp_settings.CYCLE_SPEED_DECAY_ABOVE = 0.1;
tmp_settings.CYCLE_SPEED_DECAY_BELOW = 5;
tmp_settings.CYCLE_BRAKE = 30;
tmp_settings.CYCLE_RUBBER = 1;
tmp_settings.WALLS_LENGTH = -1;
tmp_settings.CYCLE_JUMP = 0;
}
switch(name)
{
case "default":
applysettings(game_settings_default);
break;
case "zonetest":
chsetting("MAP_FILE","nelg/test/zonetest-0.1.aamap.xml");
chsetting("SIZE_FACTOR",6);
break;
case "classic":
applysettings(tmp_settings);
break;
case "fort":
applysettings(tmp_settings);
commands.RINCLUDE("vov/configs/fortress.cfg",leave);
break;
case "styball":
applysettings(tmp_settings);
commands.INCLUDE("styball.cfg",false,leave);
break;
case "df":
applysettings(tmp_settings);
var rsrc = settings.RESOURCE_REPOSITORY_SERVER;
commands.RINCLUDE("CFGs/df.cfg",function(){leave();chsetting("RESOURCE_REPOSITORY_SERVER",rsrc)});
break;
case "hr":
applysettings(tmp_settings);
commands.INCLUDE("tilthr_old.cfg",false,leave);
break;
case "ft":
applysettings(tmp_settings);
commands.RINCLUDE("vov/configs/fasttrack.cfg",function(){leave();loadcfg("TEAMS_MIN 4\nALLOW_TEAM_NAME_COLOR 1")});
break;
case "racing":
applysettings(tmp_settings);
settings.CYCLE_JUMP = 0;
settings.ARENA_AXES = 16;
commands.INCLUDE("AoT/AdvancedRacing.cfg",false,leave);
break;
case "snake":
applysettings(tmp_settings);
settings.CYCLE_JUMP = 0;
commands.INCLUDE("nelg/snake.cfg",false,leave);
break;
}
commands.KILL_ALL();
return "";
}
function aamenurender(value)
{
if(typeof(value) != "undefined") settings.MENU_RENDER = ""+value;
var specificState = engine.inputState.split(':');
if(specificState[0] == "menu") document.getElementById('menu').className = "noselect mainbg_"+settings.MENU_RENDER;
document.getElementById('menu').style.backgroundColor = "rgb("+settings.FLOOR_RED*255+","+settings.FLOOR_GREEN*255+","+settings.FLOOR_BLUE*255+")";
return settings.MENU_RENDER;
}
settings.controls = { //defaults declared
left: [65,68,70,83],//a s d f
right: [74,75,76,186],//j k l ;
north:[], south:[], east:[], west:[],
jump: [73],
brake: [32],//space bar
togglebrake: [86],//v
boost: [],//up arrow or w
toggleboost: [69],//v
chat: [84],//t
console: [192],//~
camera: [67],//c
look_left: [], look_right: [],
look_forward: [], look_back: [],
pause: [13],//enter
// fullscreen: [122],//f11
esc: [27],
score: [9],
scroll_up: [33],
scroll_down: [34],
scroll_end: [35],
//add glancing late
};
settings.instantchats = [
{
input: [49],
text: "Well done!",
},
{
input: [50],
text: "Thank you!",
},
{
input: [51],
text: "Good match!",
},
{
input: [115,52],
text: "LOL!",
},
]
function init_key(x=false) // ?
{
switch(x)
{
case 0:
break;
case 1:
break;
}
return 1*x;
}
settings.players = [];
settings.player = settings.players[0] = {
name: 'Player 1',
cycleColor: '#dddd00',
tailColor: '#dddd00',
engineType: 5,
spectating: false,
};
function applysettings(array1)
{
var sets = Object.keys(array1);
for(i=0;i<sets.length;i++)
{
chsetting(sets[i],array1[i]);
}
}
function loadcfg(str,silent=false,dontforcecase=false)
{
if(str == null) return false;
var lines = str.split("\n");
for(var i=0;i<lines.length;i++)
{
split = lines[i].split(" ");
var cmd = split.shift();
if(dontforcecase && (cmd == "FLOOR_RED" || cmd == "FLOOR_GREEN" || cmd == "FLOOR_BLUE" || cmd == "MENU_RENDER")) { cmd=""; }
chsetting(dontforcecase?cmd:cmd.toUpperCase(),split.join(" "),silent); //TODO: deal with additional spaces and spaces in setting values
}
}
var uservars = [
// "GRID_SIZE","FLOOR_RED","FLOOR_GREEN","FLOOR_BLUE",
"EXPLOSIONS","HIGH_RIM",
/*"MENU_RENDER",*/"REDRAW_MODE","MAX_TARGET_FPS",//"GAME_LOOP",
"ZONE_HEIGHT","ZONE_SEGMENTS","ZONE_SEG_LENGTH","ZONE_ALPHA","ZONE_SPIN_SPEED","ZONE_RENDER_TYPE",
"player","controls"
];
/*function netcfg(setting,value)
{
setting = setting.toUpperCase();
for(var i=uservars.length;i--;)
{
if(uservars[i] == setting) return false;
}
return chsetting(setting,value,false," on net order");
}*/
var netChanged = [];
function netcfg(setting,value)
{
setting = setting.toUpperCase();
for(var i=sets.length-1;i>=0;--i)
{
if(sets[i] == setting)
{
var settingFound = false;
for(var i=netChanged.length-1;i>=0;--i)
{
if(netChanged[i][0] == setting) settingFound = true;
}
if(!settingFound) netChanged.push([setting,chsetting("CYCLE_SPEED",undefined,true)]);
return "0xff7f7f"+chsetting(setting,value,false," on server order","0x808080");
}
}
return false;
}
function saveusercfg()
{
var usercfg = "";
for(var i=0;i<uservars.length;i++)
{
if(typeof(settings[uservars[i]]) == "object")
{
usercfg += "MERGE_OBJ "+uservars[i]+" "+JSON.stringify(settings[uservars[i]]);
}
else
{
usercfg += uservars[i]+" ";
if(typeof(settings[uservars[i]]) == "boolean")
usercfg += settings[uservars[i]]?1:0;
else
usercfg += settings[uservars[i]];
}
usercfg += "\n";
}
localStorage.setItem("user.cfg",usercfg);
}
function loadsettingcfgs()
{
loadcfg(localStorage.getItem("user.cfg"),true,true);
loadcfg(localStorage.getItem("server_info.cfg"),true);
loadcfg(localStorage.getItem("settings_custom.cfg"),true);
loadcfg(localStorage.getItem("autoexec.cfg"),true);
}
loadsettingcfgs();
window.onbeforeunload = saveusercfg;
function chsetting(setting,value,silent=false,txt="",pretxt="")
{
if(setting[0] == "#" || setting == "") return;
var exec = false, ret = undefined;
var event = getVarFromString(setting);
if(typeof(event[0][event[1]]) != "undefined")
{
var from = event[0][event[1]];
var isfunction = (typeof(from) == "function");
if(isfunction) from = event[0][event[1]]();
if(typeof(value) != "undefined" && value != "")
{
switch(typeof(from))
{
case "number":
var to = parseFloat(value);
if(isNaN(to))
to = 0;
break;
case "string":
var to = ""+value;
break;
case "boolean":
var int = parseInt(value);
if(isNaN(int))
var to = value[0]!="f"&&value[0]!="n";
else
var to = Boolean(int);
break;
case "object":
silent = true;
from = JSON.stringify(settings[uservars[i]]);
var to = JSON.parse(value);
break;
default:
engine.console.print("Unknown/unimplemented setting type "+typeof(event[0][event[1]])+".\n");
//return false;
}
if(isfunction) event[0][event[1]](to);
else event[0][event[1]] = to;
if(from != to)
{
if(!silent) engine.console.print(pretxt+event[1]+" changed from "+from+" to "+to+txt+".\n");
if(window.svr && typeof(game_settings_default[event[1]]) !== "undefined")
{
if(to == Infinity) to = Number.MAX_VALUE;
var data = JSON.stringify({type:"setting",setting:event[1],data:to});
window.svr.clients.forEach(function(ws){ws.send(data);});
}
}
ret = to;
}
else
{
if(!silent) engine.console.print(event[1]+" is currently set to "+from+"\n");
ret = from;
}
var exec = true;
}
if(event[2] && typeof(event[2][event[1]]) == "function")
{
event[2][event[1]](value);
var exec = true;
}
if(exec) return ret==undefined?exec:ret;
if(!silent)
{
engine.console.print("Unknown command "+event[1]+"\n");
if(inround())
{
var sets = Object.keys(settings), len = 0, print="";
for(i=0;i<sets.length;i++)
{
if(sets[i].search(setting) > -1)
{
if(len != 0) print += ", ";
len++; print += sets[i];
}
}
if(len > 0) engine.console.print("Perhaps you meant: "+print+"\n");
}
}
return exec;
}
function mkSettingCallback(setting,stringify=false)
{
if(stringify)
return function(set){return ""+chsetting(setting,set,true)}
else
return function(set){return chsetting(setting,set,true)}
}
function getargs()
{
var s = window.location.hash.replace("#","").split("&");
_GET = {};
for(var i=0,len=s.length;i<len;i++)
{
var e = s[i].split("=");
_GET[e[0]] = e[1];
}
}
if(typeof(_GET) == "undefined")
{
getargs();
}
//variables used by init and the engine - do not touch
engine = {
dedicated: false,
paused: false,//
inputState: '', inputStatePrev: '',
lastRenderTime: 0,//used in rendering loop
lastGameTime: 0,
fpsTime: 0, //render loop
timeStart: 0,
timeEnd: 0,//timer vars
totalPauseTime: 0,
startOfPause: 0,//used to prevent delta from offsetting due to pause
framesCount: 0,
avgTimeStep: 0,
gtime:-Infinity,
lastSyncTime:-Infinity,
lastScoreTime:-Infinity,
cMFadeOutAfter: Infinity,
//net
network: false,
activePlayer: 0,
//game stats
fastestPlayer: 0, fastestSpeed: 0,
deaths: 0,
//render loop toggles
//hasplayed: false,//used for playing again, reinitializing the render for another go (after having gone back to menus from it first)
currrim3clr: 0,
//info
usingWebgl: true,//variable to toggle webgl features
usingPostProcessing: false,//toggle for post processing features
concatch: undefined, msgcatch: undefined,
//fonts
font: 'Armagetronad',//active font face
fonts: ['Armagetronad','Flynn','monospace','nicefont','sans-serif','serif'],
textures: {},
//map data
currrot: 0, //rotation
loadedMap: "Anonymous/polygon/regular/square-1.0.1.aamap.xml",
//default:
mapString: '\<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?\>\n\<!DOCTYPE Resource SYSTEM \"AATeam/map-0.2.8.0_rc4.dtd\"\>\n\<Resource type=\"aamap\" name=\"square\" version=\"1.0.1\" author=\"Anonymous\" category=\"polygon/regular\"\>\n\t\<Map version=\"2\"\>\n\t\t\<!-- The original square map, technically created by z-man.\n\t Converted to XML by philippeqc.\n\t License: Public Domain. Do with it what you want.\n --\>\n\n\t\t\<World\>\n\t\t\t\<Field\>\n\t\t\t\t\<Spawn\tx=\"255\"\ty=\"50\"\txdir=\"0\"\tydir=\"1\"\t/\>\n\t\t\t\t\<Spawn\tx=\"245\"\ty=\"450\"\txdir=\"0\"\tydir=\"-1\"\t/\>\n\t\t\t\t\<Spawn\tx=\"50\"\ty=\"245\"\txdir=\"1\"\tydir=\"0\"\t/\>\n\t\t\t\t\<Spawn\tx=\"450\"\ty=\"255\"\txdir=\"-1\"\tydir=\"0\"\t/\>\n\n\t\t\t\t\<Spawn\tx=\"305\"\ty=\"100\"\txdir=\"0\"\tydir=\"1\"\t/\>\n\t\t\t\t\<Spawn\tx=\"195\"\ty=\"400\"\txdir=\"0\"\tydir=\"-1\"\t/\>\n\t\t\t\t\<Spawn\tx=\"100\"\ty=\"195\"\txdir=\"1\"\tydir=\"0\"\t/\>\n\t\t\t\t\<Spawn\tx=\"400\"\ty=\"305\"\txdir=\"-1\"\tydir=\"0\"\t/\>\n\n\t\t\t\t\<Spawn\tx=\"205\"\ty=\"100\"\txdir=\"0\"\tydir=\"1\"\t/\>\n\t\t\t\t\<Spawn\tx=\"295\"\ty=\"400\"\txdir=\"0\"\tydir=\"-1\"\t/\>\n\t\t\t\t\<Spawn\tx=\"100\"\ty=\"295\"\txdir=\"1\"\tydir=\"0\"\t/\>\n\t\t\t\t\<Spawn\tx=\"400\"\ty=\"205\"\txdir=\"-1\"\tydir=\"0\"\t/\>\n\n\t\t\t\t\<Wall\>\n\t\t\t\t\t\<Point\tx=\"0\"\ty=\"0\"\t/\>\n\t\t\t\t\t\<Point\tx=\"0\"\ty=\"500\"\t/\>\n\t\t\t\t\t\<Point\tx=\"500\"\ty=\"500\"\t/\>\n\t\t\t\t\t\<Point\tx=\"500\"\ty=\"0\"\t/\>\n\t\t\t\t\t\<Point\tx=\"0\"\ty=\"0\"\t/\>\n\t\t\t\t\</Wall\>\n\t\t\t\</Field\>\n\t\t\</World\>\n\t\</Map\>\n\</Resource\>',
//mapString: '\<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?\>\n\<!DOCTYPE Resource SYSTEM \"AATeam/map-0.2.8.0_rc4.dtd\"\>\n\<Resource type=\"aamap\" name=\"square\" version=\"1.0.1\" author=\"Anonymous\" category=\"polygon/regular\"\>\n\t\<Map version=\"2\"\>\n\t\t\<!-- The original square map, technically created by z-man.\n\t Converted to XML by philippeqc.\n\t License: Public Domain. Do with it what you want.\n --\>\n\n\t\t\<World\>\n\t\t\t\<Field\>\n\t\t\t\t\<Spawn\tx=\"255\"\ty=\"50\"\txdir=\"0\"\tydir=\"1\"\t/\>\n\t\t\t\t\<Spawn\tx=\"245\"\ty=\"450\"\txdir=\"0\"\tydir=\"-1\"\t/\>\n\t\t\t\t\<Spawn\tx=\"50\"\ty=\"245\"\txdir=\"1\"\tydir=\"0\"\t/\>\n\t\t\t\t\<Spawn\tx=\"450\"\ty=\"255\"\txdir=\"-1\"\tydir=\"0\"\t/\>\n\n\t\t\t\t\<Spawn\tx=\"305\"\ty=\"100\"\txdir=\"0\"\tydir=\"1\"\t/\>\n\t\t\t\t\<Spawn\tx=\"195\"\ty=\"400\"\txdir=\"0\"\tydir=\"-1\"\t/\>\n\t\t\t\t\<Spawn\tx=\"100\"\ty=\"195\"\txdir=\"1\"\tydir=\"0\"\t/\>\n\t\t\t\t\<Spawn\tx=\"400\"\ty=\"305\"\txdir=\"-1\"\tydir=\"0\"\t/\>\n\n\t\t\t\t\<Spawn\tx=\"205\"\ty=\"100\"\txdir=\"0\"\tydir=\"1\"\t/\>\n\t\t\t\t\<Spawn\tx=\"295\"\ty=\"400\"\txdir=\"0\"\tydir=\"-1\"\t/\>\n\t\t\t\t\<Spawn\tx=\"100\"\ty=\"295\"\txdir=\"1\"\tydir=\"0\"\t/\>\n\t\t\t\t\<Spawn\tx=\"400\"\ty=\"205\"\txdir=\"-1\"\tydir=\"0\"\t/\>\n\n\t\t\t\t\<Wall\>\n\t\t\t\t\t\<Point\tx=\"0\"\ty=\"0\"\t/\>\n\t\t\t\t\t\<Point\tx=\"0\"\ty=\"500\"\t/\>\n\t\t\t\t\t\<Point\tx=\"500\"\ty=\"500\"\t/\>\n\t\t\t\t\t\<Point\tx=\"500\"\ty=\"0\"\t/\>\n\t\t\t\t\t\<Point\tx=\"0\"\ty=\"0\"\t/\>\n\t\t\t\t\</Wall\>\n\t\t\t\</Field\>\n\t\t\</World\>\n\t\</Map\>\n\</Resource\>',
//two zones:
//mapString: '\<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?\>\n\<!DOCTYPE Resource SYSTEM \"AATeam/map-0.2.8.0_rc4.dtd\"\>\n\<Resource type=\"aamap\" name=\"square\" version=\"1.0.1\" author=\"Anonymous\" category=\"polygon/regular\"\>\n\t\<Map version=\"2\"\>\n\t\t\<!-- The original square map, technically created by z-man.\n\t Converted to XML by philippeqc.\n\t License: Public Domain. Do with it what you want.\n --\>\n\n\t\t\<World\>\n\t\t\t\<Field\>\n\t\t\t\t\<Spawn\tx=\"255\"\ty=\"50\"\txdir=\"0\"\tydir=\"1\"\t/\>\n\t\t\t\t\<Spawn\tx=\"245\"\ty=\"450\"\txdir=\"0\"\tydir=\"-1\"\t/\>\n\t\t\t\t\<Spawn\tx=\"50\"\ty=\"245\"\txdir=\"1\"\tydir=\"0\"\t/\>\n\t\t\t\t\<Spawn\tx=\"450\"\ty=\"255\"\txdir=\"-1\"\tydir=\"0\"\t/\>\n\n\t\t\t\t\<Spawn\tx=\"305\"\ty=\"100\"\txdir=\"0\"\tydir=\"1\"\t/\>\n\t\t\t\t\<Spawn\tx=\"195\"\ty=\"400\"\txdir=\"0\"\tydir=\"-1\"\t/\>\n\t\t\t\t\<Spawn\tx=\"100\"\ty=\"195\"\txdir=\"1\"\tydir=\"0\"\t/\>\n\t\t\t\t\<Spawn\tx=\"400\"\ty=\"305\"\txdir=\"-1\"\tydir=\"0\"\t/\>\n\n\t\t\t\t\<Spawn\tx=\"205\"\ty=\"100\"\txdir=\"0\"\tydir=\"1\"\t/\>\n\t\t\t\t\<Spawn\tx=\"295\"\ty=\"400\"\txdir=\"0\"\tydir=\"-1\"\t/\>\n\t\t\t\t\<Spawn\tx=\"100\"\ty=\"295\"\txdir=\"1\"\tydir=\"0\"\t/\>\n\t\t\t\t\<Spawn\tx=\"400\"\ty=\"205\"\txdir=\"-1\"\tydir=\"0\"\t/\>\n\n\t\t\t\t\<Wall\>\n\t\t\t\t\t\<Point\tx=\"0\"\ty=\"0\"\t/\>\n\t\t\t\t\t\<Point\tx=\"0\"\ty=\"500\"\t/\>\n\t\t\t\t\t\<Point\tx=\"500\"\ty=\"500\"\t/\>\n\t\t\t\t\t\<Point\tx=\"500\"\ty=\"0\"\t/\>\n\t\t\t\t\t\<Point\tx=\"0\"\ty=\"0\"\t/\>\n\t\t\t\t\</Wall\>\n\t\t\t\<Zone effect=\"death\"\>\<ShapeCircle radius=\"20\"\>\<Point y=\"275\" x=\"275\"/\>\n\t\t\t\</ShapeCircle\>\n\t\t\t\</Zone\>\n\t\t\t\<Zone effect=\"win\"\>\n\t\t\t\t\<ShapeCircle radius=\"10\"\>\n\t\t\t\t\t\<Point y=\"240\" x=\"250\"/\>\n\t\t\t\t\</ShapeCircle\>\n\t\t\t\</Zone\>\t\t\t\</Field\>\n\t\t\</World\>\n\t\</Map\>\n\</Resource\>',
//one zone:
//mapString: '\<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?\>\n\<!DOCTYPE Resource SYSTEM \"AATeam/map-0.2.8.0_rc4.dtd\"\>\n\<Resource type=\"aamap\" name=\"square\" version=\"1.0.1\" author=\"Anonymous\" category=\"polygon/regular\"\>\n\t\<Map version=\"2\"\>\n\t\t\<!-- The original square map, technically created by z-man.\n\t Converted to XML by philippeqc.\n\t License: Public Domain. Do with it what you want.\n --\>\n\n\t\t\<World\>\n\t\t\t\<Field\>\n\t\t\t\t\<Spawn\tx=\"255\"\ty=\"50\"\txdir=\"0\"\tydir=\"1\"\t/\>\n\t\t\t\t\<Spawn\tx=\"245\"\ty=\"450\"\txdir=\"0\"\tydir=\"-1\"\t/\>\n\t\t\t\t\<Spawn\tx=\"50\"\ty=\"245\"\txdir=\"1\"\tydir=\"0\"\t/\>\n\t\t\t\t\<Spawn\tx=\"450\"\ty=\"255\"\txdir=\"-1\"\tydir=\"0\"\t/\>\n\n\t\t\t\t\<Spawn\tx=\"305\"\ty=\"100\"\txdir=\"0\"\tydir=\"1\"\t/\>\n\t\t\t\t\<Spawn\tx=\"195\"\ty=\"400\"\txdir=\"0\"\tydir=\"-1\"\t/\>\n\t\t\t\t\<Spawn\tx=\"100\"\ty=\"195\"\txdir=\"1\"\tydir=\"0\"\t/\>\n\t\t\t\t\<Spawn\tx=\"400\"\ty=\"305\"\txdir=\"-1\"\tydir=\"0\"\t/\>\n\n\t\t\t\t\<Spawn\tx=\"205\"\ty=\"100\"\txdir=\"0\"\tydir=\"1\"\t/\>\n\t\t\t\t\<Spawn\tx=\"295\"\ty=\"400\"\txdir=\"0\"\tydir=\"-1\"\t/\>\n\t\t\t\t\<Spawn\tx=\"100\"\ty=\"295\"\txdir=\"1\"\tydir=\"0\"\t/\>\n\t\t\t\t\<Spawn\tx=\"400\"\ty=\"205\"\txdir=\"-1\"\tydir=\"0\"\t/\>\n\n\t\t\t\t\<Wall\>\n\t\t\t\t\t\<Point\tx=\"0\"\ty=\"0\"\t/\>\n\t\t\t\t\t\<Point\tx=\"0\"\ty=\"500\"\t/\>\n\t\t\t\t\t\<Point\tx=\"500\"\ty=\"500\"\t/\>\n\t\t\t\t\t\<Point\tx=\"500\"\ty=\"0\"\t/\>\n\t\t\t\t\t\<Point\tx=\"0\"\ty=\"0\"\t/\>\n\t\t\t\t\</Wall\>\n\t\t\t\<Zone effect=\"win\"\>\n\t\t\t\t\<ShapeCircle radius=\"10\"\>\n\t\t\t\t\t\<Point y=\"240\" x=\"250\"/\>\n\t\t\t\t\</ShapeCircle\>\n\t\t\t\</Zone\>\t\t\t\</Field\>\n\t\t\</World\>\n\t\</Map\>\n\</Resource\>',
//two zones + two walls:
//mapString: '\<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?\>\n\<!DOCTYPE Resource SYSTEM \"AATeam/map-0.2.8.0_rc4.dtd\"\>\n\<Resource type=\"aamap\" name=\"square\" version=\"1.0.1\" author=\"Anonymous\" category=\"polygon/regular\"\>\n\t\<Map version=\"2\"\>\n\t\t\<!-- The original square map, technically created by z-man.\n\t Converted to XML by philippeqc.\n\t License: Public Domain. Do with it what you want.\n --\>\n\n\t\t\<World\>\n\t\t\t\<Field\>\n\t\t\t\t\<Spawn\tx=\"255\"\ty=\"50\"\txdir=\"0\"\tydir=\"1\"\t/\>\n\t\t\t\t\<Spawn\tx=\"245\"\ty=\"450\"\txdir=\"0\"\tydir=\"-1\"\t/\>\n\t\t\t\t\<Spawn\tx=\"50\"\ty=\"245\"\txdir=\"1\"\tydir=\"0\"\t/\>\n\t\t\t\t\<Spawn\tx=\"450\"\ty=\"255\"\txdir=\"-1\"\tydir=\"0\"\t/\>\n\n\t\t\t\t\<Spawn\tx=\"305\"\ty=\"100\"\txdir=\"0\"\tydir=\"1\"\t/\>\n\t\t\t\t\<Spawn\tx=\"195\"\ty=\"400\"\txdir=\"0\"\tydir=\"-1\"\t/\>\n\t\t\t\t\<Spawn\tx=\"100\"\ty=\"195\"\txdir=\"1\"\tydir=\"0\"\t/\>\n\t\t\t\t\<Spawn\tx=\"400\"\ty=\"305\"\txdir=\"-1\"\tydir=\"0\"\t/\>\n\n\t\t\t\t\<Spawn\tx=\"205\"\ty=\"100\"\txdir=\"0\"\tydir=\"1\"\t/\>\n\t\t\t\t\<Spawn\tx=\"295\"\ty=\"400\"\txdir=\"0\"\tydir=\"-1\"\t/\>\n\t\t\t\t\<Spawn\tx=\"100\"\ty=\"295\"\txdir=\"1\"\tydir=\"0\"\t/\>\n\t\t\t\t\<Spawn\tx=\"400\"\ty=\"205\"\txdir=\"-1\"\tydir=\"0\"\t/\>\n\n\t\t\t\t\<Wall\>\n\t\t\t\t\t\<Point\tx=\"0\"\ty=\"0\"\t/\>\n\t\t\t\t\t\<Point\tx=\"0\"\ty=\"500\"\t/\>\n\t\t\t\t\t\<Point\tx=\"500\"\ty=\"500\"\t/\>\n\t\t\t\t\t\<Point\tx=\"500\"\ty=\"0\"\t/\>\n\t\t\t\t\t\<Point\tx=\"0\"\ty=\"0\"\t/\>\n\t\t\t\t\</Wall\>\n<Wall height=\"1\"\>\n\t\t\t\t\t\<Point\tx=\"200\"\ty=\"200\"\t/\>\n\t\t\t\t\t\<Point\tx=\"200\"\ty=\"300\"\t/\>\n\t\t\t\t\t\<Point\tx=\"300\"\ty=\"300\"\t/\>\n\t\t\t\t\t\<Point\tx=\"300\"\ty=\"200\"\t/\>\n\t\t\t\t\t\<Point\tx=\"200\"\ty=\"200\"\t/\>\n\t\t\t\t\</Wall\>\n\t\t\t\<Zone effect=\"death\"\>\<ShapeCircle radius=\"20\"\>\<Point y=\"275\" x=\"275\"/\>\n\t\t\t\</ShapeCircle\>\n\t\t\t\</Zone\>\n\t\t\t\<Zone effect=\"win\"\>\n\t\t\t\t\<ShapeCircle radius=\"10\"\>\n\t\t\t\t\t\<Point y=\"240\" x=\"250\"/\>\n\t\t\t\t\</ShapeCircle\>\n\t\t\t\</Zone\>\t\t\t\</Field\>\n\t\t\</World\>\n\t\</Map\>\n\</Resource\>',
mapXML: false,//xmlify(mapString);
//scene vars
renderer: false,
scene: false,
composer: false,//for post processing
//camera stuff
camera: false,//needed or any camera
cameraOrbit: false,//
view: 'smart',
views: ['smart','chase','stationary','track','topdown','birdseye','cockpit'],
cameraEase: 0.08,
viewTarget: 0,
menus: [],
//sound
useSound: true,
retroSound: true,
//
//scene objects (just used for render)
grid: false,
walls: false,
zones: {children:0},
//a_zone: [],//not needed with children?
//is running
gameRunning: false,
renderRunning: false,
uRound: false, //timeout ID for new round
//FOR PLAYER OBJECTS
//game stuff
// cycle: false,
// position: [0,0],
// speed: 1,
// angle: 0,
players: [],//array of player objects (info)
teams: [],//array of team objects
round: 0,
delayedcommands: {},
};
settings.engine = engine; //hack to allow menu to change engine config. (Potentially insecure?)
//CONSOLE, HUD
if(typeof(document) != "undefined")
{
engine.console = document.getElementById("console");
engine.console.time = 0;
engine.console.time_manual = 0;
engine.console.print = function(str)
{
//this.append(" "+str);
if(engine.concatch)
{
if(engine.concatch.type == "all") engine.concatch.to.append(str);
else engine.concatch.to.innerText = str;
}
if(settings.TEXT_OUT_MODE == 1)
{
this.scrollback.push(str);
}
this.innerHTML += " "+replaceColors(htmlEntities(str));
//console.log(replaceColors(str));
this.time = performance.now()+this.scrolltime;
if(!inround()||!settings.TEXT_OUT()) console.log("[CON] "+str);
}
engine.console.scrollby = 0;
engine.console.scrolltime = 5000;
engine.console.scrolltime_manual = 30000;
engine.console.time_manual -= engine.console.scrolltime_manual;
engine.console.scroll = function(times=1)
{
if(settings.TEXT_OUT_MODE == 1)
{
this.scrollby+=times; this.innerHTML = "";
for(var i=this.scrollby;i<engine.console.scrollback.length;i++)
{
this.innerHTML += " "+replaceColors(htmlEntities(this.scrollback[i]));
}
}
else
{
//this.scrollby = parseFloat(window.getComputedStyle(this).getPropertyValue('font-size'))+6;
//this.scrollby = this.children[0].offsetHeight;
var orig = parseFloat(this.style.top)/this.scrollby;
this.scrollby = this.offsetHeight/this.innerText.split("\n").length;
if(this.style.top == '') this.style.top = 0;
//this.style.top = (parseFloat(this.style.top)-(this.scrollby*times))+"px";
this.style.top = ((this.scrollby*orig)-(this.scrollby*times))+"px";
}
}
if(settings.TEXT_OUT_MODE == 1)
{
engine.console.scrollback = [];
engine.console.style.top = "-16px";
}
engine.console.scroll();
engine.hud = document.getElementById("HUD");
engine.hud.hide = function(){this.style.opacity=0;};
engine.hud.show = function(){this.style.opacity=1;};
engine.hud.basic = document.getElementById("gui_stats");
engine.hud.game = document.getElementById("game_stats");
engine.hud.fadein = true;
}
else
{
engine.console = {style:{}};
engine.console.print = function(str,netSend=true)
{
process.stdout.write(removeColors(str));
if(netSend && global.svr) //send over network
{
var data = JSON.stringify({type:"con",data:str}); //since all clients get the same info
global.svr.clients.forEach(function(ws) //I know this is slow, but I'm not aware of any other way
{
ws.send(data);
});
}
};
}
/*///team objects:
-name
-array of player IDs (order of shuffle)
-team score
/**/
//which controls are pressed down get added to arrays
var temp_items = Object.keys(settings.controls);
engine.controls = {pressed:[]};
for(var i=0;i<temp_items.length;i++)
{
engine.controls[temp_items[i]] = []; //array of keycodes that are pressed within a frame, removed when lifted
}
engine.map = { //virtual map data (used for positions, lines and stuff to calculate)
zones: [],
spawns: [],
walls: [],
};

File Metadata

Mime Type
text/x-diff
Expires
Thu, Aug 7, 8:24 AM (4 d, 12 h ago)
Storage Engine
blob
Storage Format
Raw Data
Storage Handle
11149

Event Timeline