348 lines
7.4 KiB
JavaScript
348 lines
7.4 KiB
JavaScript
|
|
if (!this.entityLoaded) {
|
|
return;
|
|
}
|
|
|
|
if (!this.initialized) {
|
|
|
|
this.scene = this.entityLoaded.scene;
|
|
this.block = this.entityLoaded.block;
|
|
this.animation = this.entityLoaded.animation;
|
|
this.drawStatus = this.entityLoaded.drawStatus;
|
|
this.getNextBlock = this.entityLoaded.getNextBlock;
|
|
this.animationObjects = this.entityLoaded.animationObjects;
|
|
this.burnLight = this.entityLoaded.burnLight;
|
|
this.glowMaterial = this.entityLoaded.glowMaterial;
|
|
|
|
this.totalTime = 0;
|
|
this.waiting = false;
|
|
this.gameOver = false;
|
|
this.moveQueue = [];
|
|
|
|
if (this.grid instanceof Array) {
|
|
this.grid.map(
|
|
function(y) {
|
|
if (this.grid[y] instanceof Array) {
|
|
this.grid[y].map(
|
|
function(x){
|
|
if (this.grid[y][x].mesh) {
|
|
this.scene.removeObject(this.grid[y][x].mesh);
|
|
}
|
|
}.bind(this)
|
|
)
|
|
}
|
|
}.bind(this)
|
|
)
|
|
}
|
|
/**
|
|
* Initialize the grid
|
|
*/
|
|
this.grid = [];
|
|
for (var y = 0; y < R3.CustomCode.TETRIS_GRID_HEIGHT; y++) {
|
|
this.grid[y] = [];
|
|
for (var x = 0; x < R3.CustomCode.TETRIS_GRID_WIDTH; x++) {
|
|
this.grid[y][x] = {
|
|
value: R3.CustomCode.TETRIS_GRID_NOT_TAKEN,
|
|
mesh: null
|
|
};
|
|
}
|
|
}
|
|
|
|
if (this.block && this.block.center) {
|
|
|
|
this.animation.removeMesh(this.block.center);
|
|
|
|
R3.Event.Emit(
|
|
R3.Event.REMOVE_COMPONENT,
|
|
{
|
|
component: this.block.center
|
|
}
|
|
);
|
|
}
|
|
|
|
if (this.block && this.block.meshes) {
|
|
this.block.meshes.map(
|
|
function (mesh) {
|
|
R3.Event.Emit(
|
|
R3.Event.REMOVE_COMPONENT,
|
|
{
|
|
component: mesh
|
|
}
|
|
);
|
|
}.bind(this)
|
|
);
|
|
}
|
|
|
|
this.drawStatus();
|
|
|
|
this.getNextBlock();
|
|
|
|
this.initialized = true;
|
|
}
|
|
|
|
this.animationObjects.map(
|
|
|
|
function(animationObject){
|
|
|
|
animationObject.time += data.delta * 4;
|
|
|
|
this.burnLight.intensity = Math.sin(animationObject.time);
|
|
this.burnLight.updateInstance('intensity');
|
|
|
|
this.glowMaterial.opacity = Math.sin(animationObject.time);
|
|
this.glowMaterial.updateInstance('opacity');
|
|
|
|
/**
|
|
* Ok this looks weird - we're simulating 3d since we're in orthographic and z-distance doesn't make sense
|
|
*/
|
|
animationObject.flames.position.y += data.delta * (Math.random() - 0.5);
|
|
animationObject.flames.updateInstance('position');
|
|
|
|
animationObject.flames.scale.x += animationObject.time * 0.5;
|
|
animationObject.flames.scale.y += animationObject.time * 0.5;
|
|
animationObject.flames.updateInstance('scale');
|
|
|
|
if (animationObject.time > Math.PI) {
|
|
|
|
/**
|
|
* Done with animation
|
|
*/
|
|
this.burnLight.intensity = 0;
|
|
this.burnLight.updateInstance('intensity');
|
|
|
|
R3.Event.Emit(
|
|
R3.Event.REMOVE_COMPONENT,
|
|
{
|
|
component: animationObject.glow
|
|
}
|
|
);
|
|
|
|
R3.Event.Emit(
|
|
R3.Event.REMOVE_COMPONENT,
|
|
{
|
|
component: animationObject.flames
|
|
}
|
|
);
|
|
|
|
|
|
/**
|
|
* Remove the meshes
|
|
*/
|
|
for (var x = 0; x < R3.CustomCode.TETRIS_GRID_WIDTH; x++) {
|
|
|
|
if (!this.grid[animationObject.rowNumber][x].mesh) {
|
|
throw new Error('mesh should exist but does not');
|
|
}
|
|
|
|
R3.Event.Emit(
|
|
R3.Event.REMOVE_COMPONENT,
|
|
{
|
|
component: this.grid[animationObject.rowNumber][x].mesh
|
|
}
|
|
);
|
|
|
|
}
|
|
|
|
/**
|
|
* Add a new row to the top of the grid
|
|
*/
|
|
this.grid.splice(animationObject.rowNumber, 1);
|
|
|
|
var row = [];
|
|
|
|
for (var x = 0; x < R3.CustomCode.TETRIS_GRID_WIDTH; x++) {
|
|
row.push(
|
|
{
|
|
value: R3.CustomCode.TETRIS_GRID_NOT_TAKEN,
|
|
mesh: null
|
|
}
|
|
)
|
|
}
|
|
|
|
this.grid.push(row);
|
|
|
|
/**
|
|
* Now - drop all blocks above the current index down one row
|
|
*/
|
|
for (var y = animationObject.rowNumber; y < R3.CustomCode.TETRIS_GRID_HEIGHT - 1; y++) {
|
|
for (var x = 0; x < R3.CustomCode.TETRIS_GRID_WIDTH; x++) {
|
|
|
|
if (this.grid[y][x].mesh) {
|
|
this.grid[y][x].mesh.position.y = y;
|
|
this.grid[y][x].mesh.updateInstance('position');
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Find any animation objects with a line number greater than our current line number, decrease it
|
|
*/
|
|
this.animationObjects.map(
|
|
function (_animationObject) {
|
|
if (_animationObject.rowNumber > animationObject.rowNumber) {
|
|
_animationObject.rowNumber -= 1;
|
|
}
|
|
}
|
|
)
|
|
|
|
var objectIndex = this.animationObjects.indexOf(animationObject);
|
|
|
|
/**
|
|
* Remove ourselves from the animation objects
|
|
*/
|
|
this.animationObjects.splice(objectIndex, 1);
|
|
}
|
|
|
|
}.bind(this)
|
|
);
|
|
|
|
if (this.gameOver) {
|
|
return;
|
|
}
|
|
|
|
var moved = true;
|
|
var fall = false;
|
|
|
|
if (this.waiting) {
|
|
fall = true;
|
|
} else {
|
|
this.totalTime += data.delta;
|
|
}
|
|
|
|
if (this.drop) {
|
|
|
|
fall = true;
|
|
|
|
if (this.moveQueue && this.moveQueue.length > 0) {
|
|
|
|
var tryMove = function () {
|
|
if (this.moveQueue.length > 0) {
|
|
|
|
var move = this.moveQueue[0];
|
|
|
|
if (this.moveBlock(this.block, move, 1, true)) {
|
|
this.moveQueue.splice(0, 1);
|
|
tryMove();
|
|
}
|
|
}
|
|
}.bind(this);
|
|
|
|
tryMove();
|
|
}
|
|
}
|
|
|
|
if (this.totalTime > this.entityLoaded.speed) {
|
|
this.totalTime = 0;
|
|
fall = true;
|
|
}
|
|
|
|
if (fall) {
|
|
moved = this.moveBlock(this.block, {down: true}, 1, true);
|
|
}
|
|
|
|
if (moved === null) {
|
|
this.waiting = true;
|
|
} else {
|
|
this.waiting = false;
|
|
}
|
|
|
|
if (moved === false) {
|
|
|
|
/**
|
|
* We reached the bottom -
|
|
*/
|
|
this.drop = false;
|
|
|
|
this.moveQueue = [];
|
|
|
|
var gridPositions = this.getBlockGridPositions(this.block);
|
|
|
|
gridPositions.map(
|
|
function (position) {
|
|
/**
|
|
* If there already is a mesh - remove it -
|
|
*/
|
|
if (this.grid[position.y][position.x].mesh) {
|
|
this.scene.removeObject(this.grid[position.y][position.x].mesh);
|
|
}
|
|
|
|
this.grid[position.y][position.x] = {
|
|
value: R3.CustomCode.TETRIS_GRID_TAKEN,
|
|
mesh: position.mesh
|
|
};
|
|
}.bind(this)
|
|
);
|
|
|
|
this.block.center.instance.position.x = this.block.center.position.x;
|
|
this.block.center.instance.position.y = this.block.center.position.y;
|
|
this.block.center.instance.position.z = this.block.center.position.z;
|
|
|
|
this.block.center.instance.rotation.x = this.block.center.rotation.x;
|
|
this.block.center.instance.rotation.y = this.block.center.rotation.y;
|
|
this.block.center.instance.rotation.z = this.block.center.rotation.z;
|
|
|
|
this.block.center.instance.updateMatrixWorld();
|
|
|
|
this.block.meshes.map(
|
|
function (mesh) {
|
|
|
|
mesh.setParentMesh(null);
|
|
//mesh.position.z = 0.1;
|
|
mesh.updateInstancePosition();
|
|
|
|
}.bind(this)
|
|
);
|
|
|
|
this.animation.removeMesh(this.block.center);
|
|
|
|
R3.Event.Emit(
|
|
R3.Event.REMOVE_COMPONENT,
|
|
{
|
|
component: this.block.center
|
|
}
|
|
);
|
|
|
|
this.removeLines();
|
|
|
|
//this.visualizeGrid(0xff0000);
|
|
|
|
for (var x = 0; x < R3.CustomCode.TETRIS_GRID_WIDTH; x++) {
|
|
if (
|
|
this.grid[19][x].value === R3.CustomCode.TETRIS_GRID_TAKEN ||
|
|
this.grid[20][x].value === R3.CustomCode.TETRIS_GRID_TAKEN ||
|
|
this.grid[21][x].value === R3.CustomCode.TETRIS_GRID_TAKEN ||
|
|
this.grid[22][x].value === R3.CustomCode.TETRIS_GRID_TAKEN ||
|
|
this.grid[23][x].value === R3.CustomCode.TETRIS_GRID_TAKEN
|
|
) {
|
|
this.gameOver = true;
|
|
}
|
|
}
|
|
|
|
if (this.gameOver) {
|
|
|
|
this.block.meshes.map(
|
|
function (mesh) {
|
|
this.scene.removeObject(mesh);
|
|
}.bind(this)
|
|
);
|
|
|
|
delete this.block;
|
|
|
|
R3.Event.Emit(
|
|
R3.Event.GAME_OVER,
|
|
{
|
|
score: this.entityLoaded.score,
|
|
level: this.entityLoaded.level,
|
|
rows: this.entityLoaded.rows
|
|
}
|
|
);
|
|
|
|
//this.visualizeGrid(0xff0000);
|
|
|
|
} else {
|
|
this.getNextBlock();
|
|
}
|
|
}
|
|
|
|
//@ sourceURL=beforeRender.js
|