Old stuff/old_sites/threejs/15_die/js/maze.js
(Deskargatu)
var Maze = function(game, options)
{
var self=this;
this.id = game.getNewId();
options.maze_num = options.level+3;
this.outside_separators = [];
this.nextType='Path';
var available_nodes = [];
// Cells, // by array
this.cells = [];
// Cells, by line/row
this.generated_doors = {};
this.closed_doors = {};
this.closed_doors_collision = {};
// Load / Save structure
this.maze_data = [];
this.load_data = [];
this.maze_global_path = {};
var maze_path_ref = {};
var perso = game.focus_perso;
console.log('test ',perso);
this.ennemys_data=[];
this.ennemys=[];
this.keys=[];
// Internal vars
var depth;
var depth2;
var current_cellid = null;
var findPath_cache;
this.load = function(data)
{
this.load_data = data.random;
options.maze_num = data.maze_num;
};
this.loadSaveRandom = function(value)
{
if(this.load_data.length>0)
{
return this.load_data.shift();
}
else
{
this.maze_data.push(value);
return value;
}
};
this.build_doors = function()
{
var self=this;
depth = (Math.sqrt(3)/2) * game.opt.door_size*1.0;
depth2 = (Math.sqrt(3)/2) * game.opt.door_size * Math.sqrt(3)/2 *1.35;
this.container = new THREE.Object3D();
this.floor_geom_refs = {};
this.floor_geom = new THREE.Geometry();
this.walls_geom = new THREE.Geometry();
this.doors_geom = new THREE.Geometry();
this.walls_collision_geom = new THREE.Geometry();
this.num_items_line = Math.floor(Math.sqrt(options.maze_num));
var total=0;
self.max_row = 0;
self.max_line = 0;
// Loop to create maze
// Loop lines
for(var row=0; (row<this.num_items_line || total < options.maze_num); row++)
{
self.max_row = row;
for(var line=0; (line<this.num_items_line && total < options.maze_num); line++)
{
if(self.max_line<line) { self.max_line= line ; }
total++;
var cell = self.create_cell({ x: row , y: 1, z:line });
if(!self.generated_doors[row])
{
self.generated_doors[row] = {};
}
self.generated_doors[row][line] = cell;
}
}
// Open/Close some doors
this.maze_doors();
// Close some doors, add ennemys, etc
this.game_doors(null, this.maze_global_path[this.start_x*this.num_items_line+this.start_z]);
// Loop to create the meshes
total=0;
for(var row=0; (row<this.num_items_line || total < options.maze_num); row++)
{
for(var line=0; (line<this.num_items_line && total < options.maze_num); line++)
{
self.create_meshes({num:total, real_x:row, x: row , y: 1, real_z : line, z:line });
total++;
}
}
var maze_floor_texture = game.assets.maze_floor_texture;
maze_floor_texture.repeat.set(1,1);
var maze_floor_bump_texture = game.assets.maze_floor_bump_texture;
maze_floor_bump_texture.repeat.set(1,1);
var floor_material = new THREE.MeshPhongMaterial({
bumpScale:0.5,
map: maze_floor_texture,
bumpMap: maze_floor_bump_texture
});
if(game.opt.debug_level>1)
{
floor_material = new THREE.MeshPhongMaterial({ color:0x555555, visible: true});
}
this.floor_geom.computeVertexNormals();
var floor = new THREE.Mesh( this.floor_geom, floor_material);
floor.receiveShadow=true;
floor.castShadow=true;
this.container.add(floor);
var cell_wall_texture = game.assets.cell_wall_texture;
cell_wall_texture.repeat.set(1,1);
var cell_wall_bump_texture = game.assets.cell_wall_bump_texture;
cell_wall_bump_texture.repeat.set(1,1);
var wall_material = new THREE.MeshPhongMaterial({
bumpScale:0.5,
map: cell_wall_texture,
bumpMap: cell_wall_bump_texture
});
if(game.opt.debug_level>1)
{
wall_material = new THREE.MeshPhongMaterial({ visible: true});
}
var wall = new THREE.Mesh( this.walls_geom, new THREE.MultiMaterial([wall_material]));
wall.name='walls';
wall.receiveShadow=true;
wall.castShadow=true;
wall.receiveShadow=true;
this.container.add(wall);
var door = new THREE.Mesh( this.doors_geom, new THREE.MultiMaterial([wall_material]));
door.name='doors';
door.receiveShadow=true;
door.castShadow=true;
door.receiveShadow=true;
this.container.add(door);
this.walls_collision = new THREE.Mesh( this.walls_collision_geom, new THREE.MeshPhongMaterial( { color:0x555555, wireframe: false, visible:game.opt.debug_level>1 } ));
this.walls_collision.name='walls';
this.container.add(this.walls_collision);
// Correct position of the maze depending on the start position and direction
var move_x = this.start_x*depth2*2;
var move_z = this.start_z*depth2*2;
this.container.position.x = options.x - move_x;
this.container.position.y = 0;
this.container.position.z = options.z - move_z;
game.scene.add( this.container );
};
this.get_random_start_end = function()
{
var start_on_x = this.loadSaveRandom(!!Math.floor(Math.random()*2));
var x=0;
var z =-1;
// Start pos
while(!this.generated_doors[x] || !this.generated_doors[x][z])
{
z = this.loadSaveRandom(Math.floor(Math.random()*(this.max_line+1)));
}
this.start_x = x;
this.start_z = z;
z=-1;
x= this.max_row;
// End door
while(!this.generated_doors[x] || !this.generated_doors[x][z] || (this.start_x===x && this.start_z===z))
{
z = this.loadSaveRandom(Math.floor(Math.random()*(this.max_line+1)));
}
this.end_x = x;
this.end_z = z;
this.start_door = this.generated_doors[this.start_x][this.start_z];
this.end_door = this.generated_doors[this.end_x][this.end_z];
};
this.maze_doors = function()
{
this.get_random_start_end();
// Start doors
var params = { x: this.start_x , z: this.start_z, real_x:'outside',real_z:'outside'};
var cell = this.cells[this.start_x*this.num_items_line + this.start_z];
var start_door_top_bottom=false;
this.start_i = 4;
this.create_separation_line(cell,params, this.start_i, 'start');
this.generated_doors[this.start_x][this.start_z].opened_doors.push(this.start_i);
// End doors
var params = { x: this.end_x , z: this.end_z, real_x:'outside',real_z:'outside'};
var cell = this.cells[this.end_x*this.num_items_line + this.end_z];
this.end_i = 1;
this.create_separation_line(cell,params, this.end_i, 'end');
this.generated_doors[this.end_x][this.end_z].opened_doors.push(this.end_i);
var x= this.start_x;
var z= this.start_z;
var cellid = x*this.num_items_line + z;
this.maze_global_path = {};
this.maze_global_path[cellid] = {};
maze_path_ref[cellid] = this.maze_global_path[cellid];
this.generated_doors[x][z].used=1;
this.maze_doors_queue = [[x,z]];
while(this.maze_doors_queue.length>0)
{
this.maze_doors_next();
}
};
this.getCellId = function(x, z)
{
return x*this.num_items_line + z;
};
this.maze_doors_next = function()
{
var self=this;
var opt = this.maze_doors_queue.shift();
if(opt===undefined)
{
return;
}
var initial_x = opt[0];
var initial_z = opt[1];
var initial_cellid = initial_x * this.num_items_line + initial_z;
var parent_path = maze_path_ref[initial_cellid];
var next_doors_full = this.near_doors(initial_x, initial_z);
var next_doors_unused=[];
next_doors_full.forEach(function(door)
{
if(!self.generated_doors[door[0]][door[1]].used)
{
next_doors_unused.push(door);
}
});
if(next_doors_unused.length>0)
{
var doors_to_open = this.loadSaveRandom(Math.ceil(Math.random()*3));
for(var i=0; i<doors_to_open;i++)
{
var opened_link = this.loadSaveRandom(Math.floor(Math.random()*next_doors_unused.length));
var dest_x = next_doors_unused[opened_link][0];
var dest_z = next_doors_unused[opened_link][1];
var dest_i = next_doors_unused[opened_link][2];
this.generated_doors[initial_x][initial_z].opened_doors.push(this.get_opposide_door(dest_i));
this.generated_doors[dest_x][dest_z].opened_doors.push(dest_i);
var cellid = dest_x * this.num_items_line + dest_z;
parent_path[cellid] = {};
maze_path_ref[cellid] = parent_path[cellid];
this.generated_doors[next_doors_unused[opened_link][0]][next_doors_unused[opened_link][1]].used=1;
this.maze_doors_queue.push(next_doors_unused[opened_link]);
}
}
// Do a maze with the not connected dots too
else
{
for(var x=0; x<=this.max_row; x++)
{
for(var z=0; z<=this.max_line; z++)
{
// Need to link and unused cell with a used cell
if(this.generated_doors[x][z] && !this.generated_doors[x][z].used)
{
next_doors_full = this.near_doors(x, z);
next_doors_used=[];
next_doors_full.forEach(function(door)
{
if(self.generated_doors[door[0]][door[1]].used)
{
next_doors_used.push(door);
}
});
if(next_doors_used.length>0)
{
var connected_door = next_doors_used[this.loadSaveRandom(Math.floor(Math.random()* next_doors_used.length))];
var cellid = connected_door[0] * this.num_items_line + connected_door[1];
parent_path = maze_path_ref[initial_cellid];
cellid = x*this.num_items_line + z;
parent_path[cellid] = {};
maze_path_ref[cellid] = parent_path[cellid];
this.generated_doors[connected_door[0]][connected_door[1]].used=1;
this.maze_doors_queue.push(connected_door);
}
}
}
}
}
};
// Close some doors, add ennemys, etc
this.game_doors = function(currentid, subnodes)
{
var doors = Object.keys(subnodes);
if(!doors || !doors.length)
{
return;
}
if(currentid)
{
available_nodes.push(currentid);
}
var has_closed_door = true;
if(available_nodes.length>1 && has_closed_door)
{
var close_door = doors[this.loadSaveRandom(Math.floor(Math.random()*doors.length))];
var cell_door = this.cells[close_door];
var close_i = cell_door.opened_doors[this.loadSaveRandom(Math.floor(Math.random()*cell_door.opened_doors.length))];
if(cell_door.opened_doors.length>0 && cell_door.closed_doors.indexOf(close_i)===-1)
{
var interruptor_idx = this.loadSaveRandom(Math.floor(Math.random()*available_nodes.length));
var cell_interruptor = this.cells[available_nodes[interruptor_idx]];
cell_door.closed_doors.push(close_i);
// Needs to add corresponding closed door from the other side
var opposite_pos = this.get_coord_next_door(cell_door.params.x, cell_door.params.z, close_i);
var cellid = this.getCellId(opposite_pos[0], opposite_pos[1]);
var opposite_cell = this.cells[cellid];
// If it is the end cell, there is no opposite cell
if(opposite_cell)
{
opposite_cell.closed_doors.push(opposite_pos[2]);
}
var pos_interruptor = this.get_cell_pos(available_nodes[interruptor_idx]);
var key = this.add_key({
mazeid: this.id,
cellid: this.getCellId(cell_interruptor.params.x, cell_interruptor.params.z),
type: 'key',
callback: this.openDoor.bind(this, cell_door, close_i),
x: pos_interruptor.x,
y: 0,
z: pos_interruptor.z,
});
cell_interruptor.objects_with_callback.push(key.container_mesh);
available_nodes = available_nodes.splice(interruptor_idx-1, 1);
}
}
if(currentid)
{
var patrol_positions = this.ennemy_patrol_round(currentid, this.loadSaveRandom(Math.floor(Math.random()*12), Math.random()<0.5));
this.add_ennemy(
{
x: patrol_positions[0].x,
z: patrol_positions[0].z,
patrol_positions: patrol_positions,
patrol_wait:0,
patrol_loop:true
});
}
for(var i=0; i<doors.length; i++)
{
this.game_doors(doors[i], subnodes[doors[i]]);
}
};
this.ennemy_patrol_round = function(cellid, start_angle, clockwise)
{
var start = this.get_cell_pos(cellid);
var patrol_positions = [];
for(var i=start_angle; i< start_angle+12;i++)
{
patrol_positions.push({
x: start.x + (Math.cos(Math.radians((clockwise ? i : -i)*30)) * game.opt.door_size*0.8),
z: start.z + (Math.sin(Math.radians((clockwise ? i : -i)*30)) * game.opt.door_size*0.8),
});
}
return patrol_positions;
};
this.openDoor = function(closed_door, i, opposite_cell, opposite_i)
{
var closed_door_id = this.get_closed_door_id(closed_door.params, i);
var closed_door_mesh = this.closed_doors[closed_door_id];
var closed_door_mesh_col = this.closed_doors_collision[closed_door_id];
if(closed_door_mesh)
{
closed_door_mesh.material.visible=false;
closed_door_mesh_col.material.visible=false;
delete this.closed_doors[closed_door_id];
delete this.closed_doors_collision[closed_door_id];
}
}
this.get_closed_door_id= function(params,i)
{
var first_cellid = this.getCellId(params.x, params.z);
var coord_next = this.get_coord_next_door(params.x, params.z, i);
var next_cellid = this.getCellId(coord_next[0], coord_next[1]);
if(first_cellid>next_cellid)
{
var t = next_cellid;
next_cellid=first_cellid;
first_cellid=t;
}
return 'closed_from_'+first_cellid+'_to_'+next_cellid;
};
this.get_opposide_door = function(i)
{
switch(i)
{
case 0: return 3;
case 1: return 4;
case 2: return 5;
case 3: return 0;
case 4: return 1;
case 5: return 2;
}
};
this.get_coord_next_door = function(initial_x, initial_z, i)
{
var pair = !!(initial_x%2===0);
switch(i)
{
//bottom
case 0: return([ initial_x, initial_z+1, this.get_opposide_door(i)]); break;
// right bottom
case 1: return([ initial_x+1, pair ? initial_z : initial_z+1, this.get_opposide_door(i)]); break;
// right top
case 2: return([ initial_x+1, pair ? initial_z-1 : initial_z, this.get_opposide_door(i)]); break;
// top
case 3: return([ initial_x, initial_z-1, this.get_opposide_door(i)]); break;
// left top
case 4: return([ initial_x-1, pair ? initial_z-1 : initial_z, this.get_opposide_door(i) ]); break;
// left bottom
case 5: return([ initial_x-1, pair ? initial_z : initial_z+1, this.get_opposide_door(i)]); break;
}
};
this.near_doors = function(initial_x, initial_z, only_connected)
{
var self=this;
var next_doors = [];
var check = [];
var door = this.generated_doors[initial_x][initial_z];
var add_check = only_connected ?
[
door.opened_doors.indexOf(0)!==-1 ? 1 : 0,
door.opened_doors.indexOf(1)!==-1 ? 1 : 0,
door.opened_doors.indexOf(2)!==-1 ? 1 : 0,
door.opened_doors.indexOf(3)!==-1 ? 1 : 0,
door.opened_doors.indexOf(4)!==-1 ? 1 : 0,
door.opened_doors.indexOf(5)!==-1 ? 1 : 0
] :
[ 1, 1, 1, 1, 1, 1 ];
for(var i=0; i<6;i++)
{
if(add_check[i]) { check.push(this.get_coord_next_door(initial_x, initial_z, i)); }
}
check.forEach(function(c)
{
var x = c[0];
var z = c[1];
var i = c[2];
if(self.generated_doors[x] && self.generated_doors[x][z])
{
next_doors.push([x,z,i]);
}
});
return next_doors;
};
/* Memorize the doors created, to avoid creating doble contiguous doors */
var created_doors = {};
this.register_door= function(x, z, i, cell)
{
if(!created_doors[x+'.'+z])
{
created_doors[x+'.'+z]={};
}
created_doors[x+'.'+z][i] = 1;
if(cell)
{
var coords = this.get_coord_next_door(x, z, this.get_opposide_door(i));
this.register_door(coords[0], coords[1], i, false);
}
};
this.get_pos = function(params)
{
var pair = params.x%2 ? depth2 : 0;
var x =params.x * depth *2;
var z =params.z * depth2 *2 + pair;
return { x: x, z: z};
};
this.get_start_pos = function()
{
var cellid = this.getCellId(this.start_x, this.start_z);
return this.get_cell_pos(cellid);
};
this.get_cell_pos = function(cellid)
{
var cell = this.cells[cellid];
var coord = this.get_pos({ x: cell.params.x - this.start_x , z: cell.params.z - this.start_z });
return { x: coord.x + options.x , z: coord.z + options.z, cellid: 0 };
};
this.get_end_pos = function()
{
var coord = this.get_pos({ x: this.end_x - this.start_x , z: this.end_z - this.start_z });
var angle = Math.radians(30);
coord.x += Math.cos(angle) * game.opt.door_size;
coord.z += Math.sin(angle) * game.opt.door_size;
return { x: coord.x + options.x , z: coord.z + options.z, cellid: this.cells.length };
};
this.create_cell = function(params)
{
var self=this;
var cellid = params.real_x=='outside' ? 'outside' : params.real_x*this.num_items_line + params.real_z;
this.fulldepth = game.opt.door_size + game.opt.door_size*2;
var pair = params.x%2 ? depth2 : 0;
var cell = new THREE.Object3D();
cell.id=cellid;
cell.name='pos '+params.x+' / '+params.z;
cell.separation_lines=[];
cell.objects_with_callback=[];
cell.opened_doors=[];
cell.closed_doors=[];
var pos = this.get_pos(params);
cell.position.x=pos.x;
cell.position.y=0;
cell.position.z=pos.z;
cell.incell=false;
cell.params=params;
this.cells.push(cell);
this.container.add(cell);
spotTarget = new THREE.Object3D();
spotTarget.position.set(0, 0, 0);
var key = params.x+'_'+params.z;
var start_idx = this.floor_geom.vertices.length;
// Create ground of that pivot
// V1 = top left, V2 = left, V3 = bottom left, etc
var vcenter = new THREE.Vector3(cell.position.x ,1,cell.position.z);
this.floor_geom.vertices.push(vcenter);
var vcenter_idx = start_idx;
start_idx++;
if(!this.floor_geom_refs[key] || !this.floor_geom_refs[key].v1 )
{
var v1 = new THREE.Vector3(cell.position.x - game.opt.door_size/1.8 , 0 , cell.position.z-depth2*1.0 );
this.floor_geom.vertices.push(v1);
v1_idx = start_idx;
start_idx++;
}
else
{
v1_idx = this.floor_geom_refs[key].v1;
}
if(!this.floor_geom_refs[key] || !this.floor_geom_refs[key].v2)
{
var v2 = new THREE.Vector3(cell.position.x - game.opt.door_size*1.2 , 0,cell.position.z);
this.floor_geom.vertices.push(v2);
v2_idx = start_idx;
start_idx++;
}
else
{
v2_idx = this.floor_geom_refs[key].v2;
}
if(!this.floor_geom_refs[key] || !this.floor_geom_refs[key].v3)
{
var v3 = new THREE.Vector3(cell.position.x - game.opt.door_size/1.8 , 0 , cell.position.z+depth2*1.0 );
this.floor_geom.vertices.push(v3);
v3_idx = start_idx;
start_idx++;
}
else
{
v3_idx = this.floor_geom_refs[key].v3;
}
if(!this.floor_geom_refs[key] || !this.floor_geom_refs[key].v4)
{
var v4 = new THREE.Vector3(cell.position.x + game.opt.door_size/1.8 , 0 , cell.position.z+depth2*1.0 );
this.floor_geom.vertices.push(v4);
v4_idx = start_idx;
start_idx++;
}
else
{
v4_idx = this.floor_geom_refs[key].v4;
}
if(!this.floor_geom_refs[key] || !this.floor_geom_refs[key].v5)
{
var v5 = new THREE.Vector3(cell.position.x + game.opt.door_size*1.2 , 0,cell.position.z);
this.floor_geom.vertices.push(v5);
v5_idx = start_idx;
start_idx++;
}
else
{
v5_idx = this.floor_geom_refs[key].v5;
}
if(!this.floor_geom_refs[key] || !this.floor_geom_refs[key].v6)
{
var v6 = new THREE.Vector3(cell.position.x + game.opt.door_size/1.8 , 0 , cell.position.z-depth2*1.0 );
this.floor_geom.vertices.push(v6);
v6_idx = start_idx;
start_idx++;
}
else
{
v6_idx = this.floor_geom_refs[key].v6;
}
var subkey;
// Top / Bottom vertices
subkey = (params.x)+'_'+(params.z+1);
if(!this.floor_geom_refs[subkey])
{
this.floor_geom_refs[subkey] = {};
}
this.floor_geom_refs[subkey].v1 = v3_idx;
this.floor_geom_refs[subkey].v6 = v4_idx;
// Side vertices
if(params.x%2==0)
{
subkey = (params.x+1)+'_'+(params.z);
if(!this.floor_geom_refs[subkey])
{
this.floor_geom_refs[subkey] = {};
}
this.floor_geom_refs[subkey].v1 = v5_idx;
this.floor_geom_refs[subkey].v2 = v4_idx;
subkey = (params.x+1)+'_'+(params.z-1);
if(!this.floor_geom_refs[subkey])
{
this.floor_geom_refs[subkey] = {};
}
this.floor_geom_refs[subkey].v2 = v6_idx;
this.floor_geom_refs[subkey].v3 = v5_idx;
}
else
{
subkey = (params.x+1)+'_'+(params.z);
if(!this.floor_geom_refs[subkey])
{
this.floor_geom_refs[subkey] = {};
}
this.floor_geom_refs[subkey].v2 = v6_idx;
this.floor_geom_refs[subkey].v3 = v5_idx;
subkey = (params.x-1)+'_'+(params.z+1);
if(!this.floor_geom_refs[subkey])
{
this.floor_geom_refs[subkey] = {};
}
this.floor_geom_refs[subkey].v6 = v2_idx;
this.floor_geom_refs[subkey].v5 = v3_idx;
}
var material = new THREE.MeshBasicMaterial( { color: 0x3366bb } );
this.floor_geom.faces.push( new THREE.Face3( vcenter_idx, v1_idx, v2_idx ) );
var faceuv = [
new THREE.Vector2(0,0),
new THREE.Vector2(1,1),
new THREE.Vector2(1,0),
];
this.floor_geom.faceVertexUvs[0].push(faceuv);
this.floor_geom.faces.push( new THREE.Face3( vcenter_idx, v2_idx, v3_idx ) );
var faceuv = [
new THREE.Vector2(1,1), // 3
new THREE.Vector2(0,1), // 1
new THREE.Vector2(1,0), // 2
];
this.floor_geom.faceVertexUvs[0].push(faceuv);
this.floor_geom.faces.push( new THREE.Face3( vcenter_idx, v3_idx, v4_idx ) );
var faceuv = [
new THREE.Vector2(1,0), // 1
new THREE.Vector2(1,1), // 2
new THREE.Vector2(0,1) // 3
];
this.floor_geom.faceVertexUvs[0].push(faceuv);
this.floor_geom.faces.push( new THREE.Face3( vcenter_idx, v4_idx, v5_idx ) );
var faceuv = [
new THREE.Vector2(0,1),
new THREE.Vector2(1,1),
new THREE.Vector2(1,0),
];
this.floor_geom.faceVertexUvs[0].push(faceuv);
this.floor_geom.faces.push( new THREE.Face3( vcenter_idx, v5_idx, v6_idx ) );
var faceuv = [
new THREE.Vector2(1,0),
new THREE.Vector2(0,1),
new THREE.Vector2(1,1),
];
this.floor_geom.faceVertexUvs[0].push(faceuv);
this.floor_geom.faces.push( new THREE.Face3( vcenter_idx, v6_idx, v1_idx) );
var faceuv = [
new THREE.Vector2(0,1), // 2
new THREE.Vector2(0,0), // 1
new THREE.Vector2(1,0), // 3
];
this.floor_geom.faceVertexUvs[0].push(faceuv);
/*
for(var i=0; i<6;i++)
{
var pivot = this.get_pivot(cell, params, i);
var ambient_light = new THREE.SpotLight(0xffffff,0.2, 200, 2, 0);
ambient_light.position.set(game.opt.door_size*0.9,10,0);
ambient_light.target = cell;
pivot.add(ambient_light);
pivot.add(new THREE.PointLightHelper(ambient_light, 1));
}
*/
return cell;
};
this.get_pivot = function(cell, params, i)
{
var pivot = new THREE.Object3D();
pivot.name ='p '+params.x+'/'+params.z+'/'+i;
pivot.rotation.y= Math.radians(i*60);
cell.add(pivot);
return pivot;
};
this.set_mesh_orientation = function(mesh,i)
{
var ratio = 0.6;
mesh.scale.x=ratio*game.opt.door_size;
mesh.scale.y= ratio*game.opt.door_size;
mesh.scale.z= ratio*game.opt.door_size;
mesh.rotation.y= Math.radians(i*60);
switch(i)
{
case 0:
mesh.position.z += game.opt.door_size;
break;
case 1:
mesh.position.z += game.opt.door_size * 0.50;
mesh.position.x += depth;
break;
case 2:
mesh.position.z -= game.opt.door_size * 0.50;
mesh.position.x += depth;
break;
case 3:
mesh.position.z -= game.opt.door_size;
break;
case 4:
mesh.position.z -= game.opt.door_size * 0.50;
mesh.position.x -= depth;
break;
case 5:
mesh.position.z += game.opt.door_size * 0.50;
mesh.position.x -= depth;
break;
}
mesh.updateMatrix();
};
this.create_meshes = function(params)
{
var self=this;
this.fulldepth = game.opt.door_size + game.opt.door_size*2;
var cell = this.cells[params.num];
for(var i=0; i<6;i++)
{
if(!created_doors[params.x+'.'+params.z] || !created_doors[params.x+'.'+params.z][i])
{
this.register_door(params.x, params.z, i, cell);
var pivot = this.get_pivot(cell, params, i);
var materials = [];
var mesh=null;
var collision_mesh=null;
if(this.generated_doors[params.real_x][params.real_z].opened_doors.indexOf(i)!==-1)
{
mesh = new THREE.Mesh( game.assets.door1_geo);
mesh.type=='door';
collision_mesh = new THREE.Mesh( game.assets.door_geo);
var closed_door_id = this.get_closed_door_id(params,i);
if(this.generated_doors[params.x][params.z].closed_doors.indexOf(i)!==-1 && !this.closed_doors[closed_door_id])
{
var door_collision_mat = new THREE.MeshBasicMaterial( { color:0xffbbbb, wireframe: false, visible:game.opt.debug_level>1 } );
var close_mesh = new THREE.Mesh( game.assets.dooropen_geo, door_collision_mat);
var close_mesh1 = new THREE.Mesh( game.assets.dooropen1_geo, new THREE.MultiMaterial(game.assets.dooropen1_mat));
close_mesh.name=closed_door_id;
this.closed_doors[closed_door_id] = close_mesh;
this.closed_doors_collision[closed_door_id] = close_mesh1;
this.container.add(close_mesh);
this.container.add(close_mesh1);
close_mesh.position.x = cell.position.x;
close_mesh.position.y = cell.position.y;
close_mesh.position.z = cell.position.z;
this.set_mesh_orientation(close_mesh, i);
close_mesh1.position.x = cell.position.x;
close_mesh1.position.y = cell.position.y;
close_mesh1.position.z = cell.position.z;
this.set_mesh_orientation(close_mesh1, i);
}
}
else
{
mesh = new THREE.Mesh( game.assets.wall1_geo);
mesh.type=='wall';
collision_mesh = new THREE.Mesh( game.assets.wall_geo);
}
if(mesh)
{
mesh.position.x = cell.position.x;
mesh.position.y = cell.position.y;
mesh.position.z = cell.position.z;
collision_mesh.position.x = cell.position.x;
collision_mesh.position.y = cell.position.y;
collision_mesh.position.z = cell.position.z;
this.set_mesh_orientation(mesh, i);
this.set_mesh_orientation(collision_mesh, i);
if(game.opt.debug_level<1)
{
if(mesh.type=='wall')
{
this.walls_geom.merge(mesh.geometry, mesh.matrix);
}
else
{
this.doors_geom.merge(mesh.geometry, mesh.matrix);
}
}
this.walls_collision_geom.merge(collision_mesh.geometry, mesh.matrix);
}
}
var areas=[];
// Create collision items to detect enter in the cell
if(this.generated_doors[params.real_x][params.real_z].opened_doors.indexOf(i)!==-1)
{
var door = this.generated_doors[params.real_x][params.real_z];
var outside_door =
( params.real_x == this.start_x && params.real_z == this.start_z && i == this.start_i) ||
( params.real_x == this.end_x && params.real_z == this.end_z && i == this.end_i);
this.create_separation_line(cell,params, i, false, outside_door);
}
}
return cell;
};
this.findPath = function(destination, finalpos)
{
var origin = this.cells[game.focus_perso.current_cell];
if(findPath_cache[origin.name+' to '+destination.name])
{
var res = findPath_cache[origin.name+' to '+destination.name].concat();
res.unshift(finalpos);
return res;
}
var parent_paths= {};
var to_visit = [];
var correct_path= null;
var doors = this.near_doors(origin.params.x, origin.params.z, true);
var i=0;
while(i<doors.length && !correct_path)
{
var door_data = doors[i];
var cell = self.generated_doors[door_data[0]][door_data[1]];
parent_paths[cell.name] = { i : (door_data[2]), cell: origin };
correct_path = (cell===destination);
if(!correct_path)
{
to_visit.push({ parent: origin.name, cell: cell});
}
i++;
}
while(!correct_path && to_visit.length>0)
{
var next = to_visit.shift();
var cell = next.cell;
this.near_doors(cell.params.x, cell.params.z, true).forEach(function(door_data)
{
var near_cell = self.generated_doors[door_data[0]][door_data[1]];
if(!parent_paths[near_cell.name])
{
parent_paths[near_cell.name] = { i : (door_data[2]), cell: cell };
if(near_cell===destination)
{
correct_path = true;
}
to_visit.push({ parent: cell.name, cell: near_cell});
}
});
}
var path = [];
// There is a path to this
if(correct_path)
{
var current = destination;
var loop_avoid=0;
var next_i = this.get_opposide_door(parent_paths[destination.name].i);
path.push(this.getFindPathCoord(destination, parent_paths[destination.name].i));
while(parent_paths[current.name] && parent_paths[current.name].cell!==origin)
{
var old_current = current;
current = parent_paths[current.name].cell;
path.push(this.getFindPathCoord(parent_paths[old_current.name].cell, next_i));
next_i = this.get_opposide_door(parent_paths[current.name].i);
path.push(this.getFindPathCoord(parent_paths[old_current.name].cell, parent_paths[current.name].i));
loop_avoid++;
}
path.push(this.getFindPathCoord(origin, next_i));
}
// Debug draw path
for(var i=1; i<path.length;i++)
{
draw_line({
visible: game.opt.debug_level>1,
opacity:game.opt.debug_level>1 ? 1 : 0,
container: game.scene,
color: 0xff0000,
origin: path[i-1],
destination: path[i]
});
}
findPath_cache[origin.name+' to '+destination.name] = path.concat();
path.unshift(finalpos);
return path;
};
this.getFindPathCoord = function(door, i)
{
var origin = new THREE.Vector3(
door.position.x + this.container.position.x,
door.position.y + this.container.position.y+5,
door.position.z + this.container.position.z);
var dot = new THREE.Vector3(0, 0, game.opt.door_size*0.7);
dot.applyAxisAngle(new THREE.Vector3(0,1,0), Math.radians(i*60));
dot.add(origin);
return dot;
};
this.create_separation_line= function(cell,params, i, extra_door, outside_door)
{
var material = new THREE.MeshBasicMaterial( { color: 0x666699, transparent:true, visible:false } );
if(game.opt.debug_level>1)
{
material = new THREE.MeshBasicMaterial( { color: 0xffff99 + 0x0000ff, visible:true } );
}
var extra = extra_door ? game.opt.door_size*0.4 : 0;
var separator = outside_door ? 1 : 0.85;
var pivot = this.get_pivot(cell, params, i);
draw_line({
visible: game.opt.debug_level>1,
opacity:game.opt.debug_level>1 ? 1 : 0,
container: pivot,
color: 0x777777,
origin: { x: depth*( !extra_door ? .65 : .7), y: 1, z: game.opt.door_size*separator +extra },
destination: { x: -depth*(!extra_door ? .65 : .7), y: 1, z: game.opt.door_size*separator +extra }
});
var cellid = params.real_x=='outside' ? 'outside' : params.real_x*this.num_items_line + params.real_z;
// Used by game enter detection.
line.mazeid = this.id;
line.cellid = cellid;
cell.separation_lines.push(line);
var action = '';
if(extra_door=='start'){
action = 'leave_maze_from_start';
}
if(extra_door=='end'){
action = 'leave_maze_from_end';
}
line.callback=this.changeCellEvent.bind(this, cellid, action);
line.enter_leave_door = !!extra;
line.outside_door = outside_door;
if(outside_door)
{
self.outside_separators.push(line);
}
};
this.reload = function()
{
var self=this;
console.log('maze reload!');
// Kill all ennemys
this.ennemys.forEach(function(ennemy)
{
ennemy.die();
});
// Recreate all ennemys
this.ennemys_data.forEach(function(params)
{
self.add_ennemy(params, true);
});
};
this.getStaticObstacles = function()
{
var obstacles = [this.walls_collision];
for(var i in this.closed_doors)
{
obstacles.push(this.closed_doors[i]);
}
return obstacles;
};
this.getMovingObstacles = function()
{
var obstacles=[];
this.ennemys.forEach(function(ennemy)
{
if(!ennemy.dead)
{
obstacles.push(ennemy.container_mesh);
}
});
return obstacles;
};
this.getHovers = function()
{
var hovers = [];
this.ennemys.forEach(function(ennemy)
{
if(!ennemy.dead)
{
hovers.push(ennemy.container_mesh);
}
});
return hovers;
};
this.getCollisionCallbacks = function()
{
var self=this;
if(perso.current_cell!==null)
{
var cbs=[];
var cell = this.cells[perso.current_cell];
var params = cell.params;
// If current cell has an enter/leave maze separation line,
// add it to collision callback
cell.separation_lines.forEach(function(line)
{
if(line.enter_leave_door && !line.outside_door)
{
cbs.push(line);
}
});
cbs = cbs.concat(cell.objects_with_callback);
// Add separation lines of neighbor cells
var doors = this.near_doors(params.x, params.z);
doors.forEach(function(door)
{
var door_x = door[0];
var door_z = door[1];
var near_cell = self.cells[door_x*self.num_items_line+door_z];
cbs=cbs.concat(near_cell.separation_lines)
});
return cbs;
}
else
{
return [];
}
};
this.getOutsideCollisionCallbacks = function()
{
return this.outside_separators;
};
this.changeCellEvent = function(cellid, action)
{
if(cellid != current_cellid)
{
current_cellid = cellid;
if(cellid!='outside')
{
this.changeCell(cellid);
}
if(action=='leave_maze_from_start')
{
game.setItem(options.parent);
}
else if(action=='leave_maze_from_end')
{
console.log('leave maze from end');
game.setItem(this.next_item);
}
game.updateCollisionsCache();
}
};
this.changeCell= function(cellid)
{
console.log('entering cell here ',cellid);
game.setItem(this);
game.focus_perso.current_cell=cellid;
var cell = this.cells[cellid];
};
this.build = function(load_data)
{
var self=this;
if(load_data)
{
this.load(load_data);
}
this.build_doors();
};
this.getMazeGenerationString = function()
{
return {
maze_num: options.maze_num,
random: this.maze_data
};
};
this.enter = function()
{
if(!this.entered)
{
console.log('entering maze 2');
game.setItem(this);
}
this.buildNext();
};
this.leave = function()
{
this.entered=false;
console.log('leave maze');
};
this.remove_key = function(item)
{
var idx = this.keys.indexOf(item);
if(idx>-1)
{
this.keys.splice(idx, 1);
}
};
this.add_key = function(options)
{
options.parentStructure = this;
options.game = game;
var key = new Key(game, options);
this.keys.push(key);
return key;
};
this.remove_ennemy = function(item)
{
var idx = this.ennemys.indexOf(item);
this.ennemys.splice(idx, 1);
};
this.add_ennemy = function(options, reloading)
{
if(!reloading)
{
this.ennemys_data.push(options);
}
options.ai = true;
options.parentStructure = this;
options.game = game;
var ennemy = new Ennemy(game, options);
ennemy.build();
ennemy.name='ennemy';
this.ennemys.push(ennemy);
return ennemy;
};
this.update= function(delta)
{
this.ennemys.forEach(function(ennemy)
{
ennemy.update(delta);
});
this.keys.forEach(function(key)
{
key.update(delta);
});
};
this.buildNext = function()
{
if(!this.next_item)
{
var pos = this.get_end_pos();
this.next_item = new window[this.nextType](game, {
parent: this,
level: options.level+1,
x: pos.x,
z: pos.z });
this.next_item.build();
}
};
}
Tfe