1224 lines
28 KiB
JavaScript
1224 lines
28 KiB
JavaScript
if (data.entity === this.parentEntity) {
|
|
console.log('my entity loaded');
|
|
}
|
|
|
|
this.beforeRender = R3.EntityManager.Instance.findComponentById('skmfv0tk0w');
|
|
this.renderer = R3.EntityManager.Instance.findComponentById('fhfk8i6u7v');
|
|
this.keyDown = R3.EntityManager.Instance.findComponentById('4sjzwfvciu');
|
|
this.touchStart = R3.EntityManager.Instance.findComponentById('fs7e9y1lhh');
|
|
this.touchEnd = R3.EntityManager.Instance.findComponentById('3b588t2jz1');
|
|
this.box2 = R3.EntityManager.Instance.findComponentById('rr7z2fcdax');
|
|
this.image7 = R3.EntityManager.Instance.findComponentById('tzoiov5vo4');
|
|
this.image10 = R3.EntityManager.Instance.findComponentById('md3iest7ox');
|
|
this.image11 = R3.EntityManager.Instance.findComponentById('ofn6o71n9b');
|
|
this.image13 = R3.EntityManager.Instance.findComponentById('1026puir3d');
|
|
this.image14 = R3.EntityManager.Instance.findComponentById('vr9yv8qd2q');
|
|
this.image15 = R3.EntityManager.Instance.findComponentById('jg7m44cfjc');
|
|
this.boxCenter = R3.EntityManager.Instance.findComponentById('onflseabh3');
|
|
this.animation = R3.EntityManager.Instance.findComponentById('0429064v9c');
|
|
this.canvas = R3.EntityManager.Instance.findComponentById('kttg10l8u6');
|
|
this.burnLight = R3.EntityManager.Instance.findComponentById('zstk8iq2p2');
|
|
this.flamesSmall = R3.EntityManager.Instance.findComponentById('a3s12sqr9a');
|
|
this.camera = R3.EntityManager.Instance.findComponentById('gruhmdgjmi');
|
|
this.glow = R3.EntityManager.Instance.findComponentById('8ygsthn4n8');
|
|
this.glowMaterial = R3.EntityManager.Instance.findComponentById('3kg5h22b3h');
|
|
this.scoreTexture = R3.EntityManager.Instance.findComponentById('9azkxtbiaf');
|
|
this.scene = R3.EntityManager.Instance.findComponentById('h30wqcvha0');
|
|
this.gridMaterial = R3.EntityManager.Instance.findComponentById('jkpel4rvsy');
|
|
this.animationSystems = R3.EntityManager.Instance.queryComponents(R3.Component.SYSTEM_ANIMATION);
|
|
|
|
R3.CustomCode.TETRIS_BLOCK_I = 0;
|
|
R3.CustomCode.TETRIS_BLOCK_L = 1;
|
|
R3.CustomCode.TETRIS_BLOCK_L2 = 2;
|
|
R3.CustomCode.TETRIS_BLOCK_Z = 3;
|
|
R3.CustomCode.TETRIS_BLOCK_Z2 = 4;
|
|
R3.CustomCode.TETRIS_BLOCK_T = 5;
|
|
R3.CustomCode.TETRIS_BLOCK_O = 6;
|
|
R3.CustomCode.TETRIS_BLOCK_MAX = 7;
|
|
|
|
R3.CustomCode.TETRIS_GRID_WIDTH = 11;
|
|
R3.CustomCode.TETRIS_GRID_HEIGHT = 24;
|
|
R3.CustomCode.TETRIS_GRID_HEADSPACE = 4;
|
|
|
|
R3.CustomCode.TETRIS_GRID_NOT_TAKEN = 0;
|
|
R3.CustomCode.TETRIS_GRID_TAKEN = 1;
|
|
R3.CustomCode.TETRIS_GRID_DISAPPEARING = 2;
|
|
|
|
R3.CustomCode.prototype.visualizeGrid = function (color) {
|
|
|
|
if (this.starsMesh) {
|
|
this.scene.instance.remove(this.starsMesh);
|
|
}
|
|
|
|
this.starsGeometry = new THREE.Geometry();
|
|
|
|
for (var y = 0; y < this.beforeRender.grid.length; y++) {
|
|
for (var x = 0; x < this.beforeRender.grid[y].length; x++) {
|
|
if (this.beforeRender.grid[y][x].value === R3.CustomCode.TETRIS_GRID_TAKEN) {
|
|
this.starsGeometry.vertices.push(
|
|
new THREE.Vector3(
|
|
x,
|
|
y,
|
|
5
|
|
)
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
var starsMaterial = new THREE.PointsMaterial({color: color, size: 0.1});
|
|
|
|
this.starsMesh = new THREE.Points(this.starsGeometry, starsMaterial);
|
|
|
|
this.scene.instance.add(this.starsMesh);
|
|
|
|
}.bind(this)
|
|
|
|
R3.CustomCode.prototype.startAnimation = function (index) {
|
|
|
|
var glow = this.glow.clone();
|
|
|
|
glow.position.y = index;
|
|
glow.position.x = (R3.CustomCode.TETRIS_GRID_WIDTH / 2) - 0.5;
|
|
glow.position.z = 2;
|
|
glow.updateInstance('position');
|
|
|
|
var flames = this.flamesSmall.clone();
|
|
|
|
flames.position.y = index + 1;
|
|
flames.position.x = (R3.CustomCode.TETRIS_GRID_WIDTH / 2) - 0.5;
|
|
flames.position.z = 2;
|
|
flames.updateInstance('position');
|
|
|
|
var animationObject = {
|
|
rowNumber: index,
|
|
glow: glow,
|
|
flames: flames,
|
|
flamesArray: [],
|
|
time: 0
|
|
}
|
|
|
|
this.animationObjects.push(animationObject);
|
|
|
|
}.bind(this)
|
|
|
|
R3.CustomCode.prototype.removeLines = function () {
|
|
|
|
var indices = [];
|
|
|
|
for (var y = 0; y < R3.CustomCode.TETRIS_GRID_HEIGHT; y++) {
|
|
|
|
var line = true;
|
|
|
|
for (var x = 0; x < R3.CustomCode.TETRIS_GRID_WIDTH; x++) {
|
|
if (
|
|
this.beforeRender.grid[y][x].value === R3.CustomCode.TETRIS_GRID_NOT_TAKEN ||
|
|
this.beforeRender.grid[y][x].value === R3.CustomCode.TETRIS_GRID_DISAPPEARING
|
|
) {
|
|
line = false;
|
|
}
|
|
}
|
|
|
|
if (line) {
|
|
indices.push(y);
|
|
}
|
|
}
|
|
|
|
var multiplier = 1;
|
|
|
|
if (indices.length === 4) {
|
|
multiplier = 10000;
|
|
}
|
|
|
|
if (indices.length === 3) {
|
|
multiplier = 1000;
|
|
}
|
|
|
|
if (indices.length === 2) {
|
|
multiplier = 100;
|
|
}
|
|
|
|
if (indices.length === 1) {
|
|
multiplier = 10;
|
|
}
|
|
|
|
this.score += (multiplier * this.level);
|
|
|
|
this.rows += indices.length;
|
|
|
|
this.level = Math.floor(this.rows / 5) + 1;
|
|
|
|
if (this.level === 1) {
|
|
this.speed = 1;
|
|
}
|
|
|
|
if (this.level === 2) {
|
|
this.speed = 0.9;
|
|
}
|
|
|
|
if (this.level === 3) {
|
|
this.speed = 0.85;
|
|
}
|
|
|
|
if (this.level === 4) {
|
|
this.speed = 0.8;
|
|
}
|
|
|
|
if (this.level === 5) {
|
|
this.speed = 0.75;
|
|
}
|
|
|
|
if (this.level === 6) {
|
|
this.speed = 0.7;
|
|
}
|
|
|
|
if (this.level === 7) {
|
|
this.speed = 0.65;
|
|
}
|
|
|
|
if (this.level === 8) {
|
|
this.speed = 0.6;
|
|
}
|
|
|
|
if (this.level === 9) {
|
|
this.speed = 0.55;
|
|
}
|
|
|
|
if (this.level === 10) {
|
|
this.speed = 0.5;
|
|
}
|
|
|
|
if (this.level === 11) {
|
|
this.speed = 0.45;
|
|
}
|
|
|
|
if (this.level === 12) {
|
|
this.speed = 0.4;
|
|
}
|
|
|
|
if (this.level === 13) {
|
|
this.speed = 0.35;
|
|
}
|
|
|
|
if (this.level === 14) {
|
|
this.speed = 0.3;
|
|
}
|
|
|
|
if (this.level === 15) {
|
|
this.speed = 0.25;
|
|
}
|
|
|
|
if (this.level === 16) {
|
|
this.speed = 0.2;
|
|
}
|
|
|
|
if (this.level >= 17) {
|
|
this.speed = 0.18;
|
|
}
|
|
|
|
this.drawStatus();
|
|
|
|
this.animationsDone = [];
|
|
|
|
indices.map(
|
|
function (index) {
|
|
for (var x = 0; x < R3.CustomCode.TETRIS_GRID_WIDTH; x++) {
|
|
this.beforeRender.grid[index][x].value = R3.CustomCode.TETRIS_GRID_DISAPPEARING;
|
|
}
|
|
this.startAnimation(index);
|
|
}.bind(this)
|
|
);
|
|
|
|
}.bind(this);
|
|
|
|
|
|
R3.CustomCode.prototype.drawStatus = function () {
|
|
var context = this.canvas.instance.getContext('2d');
|
|
|
|
context.textBaseline = "middle";
|
|
|
|
context.clearRect(0, 0, this.canvas.width, this.canvas.height);
|
|
|
|
context.fillStyle = "rgba(15, 15, 15, 0.7)";
|
|
context.fillRect(12, 30, 485, 178);
|
|
|
|
context.lineWidth = 8;
|
|
|
|
context.strokeStyle = '#05c870';
|
|
context.strokeRect(12, 30, 485, 178);
|
|
|
|
context.beginPath();
|
|
context.moveTo(11, 68);
|
|
context.lineTo(498, 68);
|
|
context.stroke();
|
|
|
|
context.beginPath();
|
|
context.moveTo(172, 30);
|
|
context.lineTo(172, 208);
|
|
context.stroke();
|
|
|
|
context.beginPath();
|
|
context.moveTo(172, 135);
|
|
context.lineTo(498, 135);
|
|
context.stroke();
|
|
|
|
context.beginPath();
|
|
context.moveTo(172, 172);
|
|
context.lineTo(498, 172);
|
|
context.stroke();
|
|
|
|
/**
|
|
* Write text
|
|
*/
|
|
context.fillStyle = '#3db5e6';
|
|
context.font = '20pt BkBold';
|
|
context.fillText('NEXT TILES', 23, 52);
|
|
|
|
context.fillText('SCORE', 182, 52);
|
|
|
|
context.fillText('LEVEL', 182, 156);
|
|
|
|
context.fillText('ROWS', 182, 193);
|
|
|
|
context.fillStyle = '#ffffff';
|
|
|
|
context.font = '50pt BkBold';
|
|
|
|
var str = this.score.toString();
|
|
var pad = "0000000";
|
|
var ans = pad.substring(0, pad.length - str.length) + str;
|
|
|
|
context.fillText(ans, 225, 110);
|
|
|
|
str = this.level.toString();
|
|
pad = "000";
|
|
ans = pad.substring(0, pad.length - str.length) + str;
|
|
|
|
context.font = '20pt BkBold';
|
|
context.fillText(ans, 435, 156);
|
|
|
|
str = this.rows.toString();
|
|
pad = "000";
|
|
ans = pad.substring(0, pad.length - str.length) + str;
|
|
|
|
context.font = '20pt BkBold';
|
|
context.fillText(ans, 435, 193);
|
|
|
|
this.scoreTexture.instance.needsUpdate = true;
|
|
}.bind(this)
|
|
|
|
R3.CustomCode.prototype.getBlockGridPositions = function (block) {
|
|
|
|
var object = new THREE.Mesh();
|
|
|
|
object.position.x = block.center.position.x;
|
|
object.position.y = block.center.position.y;
|
|
object.position.z = block.center.position.z;
|
|
object.rotation.x = block.center.rotation.x;
|
|
object.rotation.y = block.center.rotation.y;
|
|
object.rotation.z = block.center.rotation.z;
|
|
|
|
var children = block.meshes.map(
|
|
function (mesh) {
|
|
var child = new THREE.Mesh();
|
|
child.position.x = mesh.position.x;
|
|
child.position.y = mesh.position.y;
|
|
child.position.z = mesh.position.z;
|
|
object.add(child);
|
|
child.mesh = mesh;
|
|
return child;
|
|
}
|
|
);
|
|
|
|
object.updateMatrixWorld();
|
|
|
|
var positions = children.map(
|
|
function (child) {
|
|
|
|
var vector = new THREE.Vector3();
|
|
|
|
vector.setFromMatrixPosition(child.matrixWorld);
|
|
|
|
var x = vector.x;
|
|
var y = vector.y;
|
|
|
|
x = Math.round(x);
|
|
y = Math.round(y);
|
|
|
|
return {
|
|
x: x,
|
|
y: y,
|
|
mesh: child.mesh
|
|
}
|
|
}
|
|
);
|
|
|
|
return positions;
|
|
|
|
}.bind(this);
|
|
|
|
R3.CustomCode.prototype.stopAnimations = function () {
|
|
this.animationSystems.map(
|
|
function (system) {
|
|
if (system.started) {
|
|
system.stop();
|
|
}
|
|
}
|
|
);
|
|
}.bind(this)
|
|
|
|
R3.CustomCode.prototype.startAnimations = function () {
|
|
this.animationSystems.map(
|
|
function (system) {
|
|
if (!system.started) {
|
|
system.start();
|
|
}
|
|
}
|
|
);
|
|
}.bind(this)
|
|
|
|
R3.CustomCode.prototype.drawGrid = function () {
|
|
|
|
this.gridMaterial.color.fromHex('#3db5e6');
|
|
this.gridMaterial.color.updateInstance('color');
|
|
|
|
var geometry = new THREE.Geometry();
|
|
|
|
for (var y = 0; y < (R3.CustomCode.TETRIS_GRID_HEIGHT - R3.CustomCode.TETRIS_GRID_HEADSPACE); y++) {
|
|
for (var x = 0; x < R3.CustomCode.TETRIS_GRID_WIDTH; x++) {
|
|
geometry.vertices.push(
|
|
new THREE.Vector3(
|
|
x,
|
|
y,
|
|
0.17
|
|
)
|
|
)
|
|
}
|
|
}
|
|
|
|
this.scene.instance.add(new THREE.Points(geometry, this.gridMaterial.instance));
|
|
|
|
geometry = new THREE.Geometry();
|
|
|
|
geometry.vertices.push(
|
|
new THREE.Vector3(
|
|
-0.5,
|
|
R3.CustomCode.TETRIS_GRID_HEIGHT - R3.CustomCode.TETRIS_GRID_HEADSPACE - 0.5,
|
|
5
|
|
),
|
|
new THREE.Vector3(
|
|
-0.5,
|
|
-0.5,
|
|
5
|
|
),
|
|
new THREE.Vector3(
|
|
R3.CustomCode.TETRIS_GRID_WIDTH - 0.5,
|
|
-0.5,
|
|
5
|
|
),
|
|
new THREE.Vector3(
|
|
R3.CustomCode.TETRIS_GRID_WIDTH - 0.5,
|
|
R3.CustomCode.TETRIS_GRID_HEIGHT - R3.CustomCode.TETRIS_GRID_HEADSPACE - 0.5,
|
|
5
|
|
)
|
|
);
|
|
|
|
this.scene.instance.add(
|
|
new THREE.Line(
|
|
geometry,
|
|
new THREE.LineBasicMaterial(
|
|
{
|
|
linewidth: 3,
|
|
color: 0x3db5e6
|
|
}
|
|
)
|
|
)
|
|
);
|
|
|
|
|
|
}.bind(this)
|
|
|
|
R3.CustomCode.prototype.checkBoundaries = function (block) {
|
|
|
|
/**
|
|
* collisions are true only for out of bounds indexes, and if the current block is taken
|
|
*/
|
|
var gridPositions = this.getBlockGridPositions(block);
|
|
|
|
var leftHit = false;
|
|
var rightHit = false;
|
|
var bottomHit = false;
|
|
var topHit = false;
|
|
var collision = false;
|
|
var bottomDisappearing = false;
|
|
|
|
gridPositions.map(
|
|
function (position) {
|
|
|
|
/**
|
|
* Check grid boundaries
|
|
*/
|
|
if (position.x === 0) {
|
|
leftHit = true;
|
|
}
|
|
|
|
if (position.x === (R3.CustomCode.TETRIS_GRID_WIDTH - 1)) {
|
|
rightHit = true;
|
|
}
|
|
|
|
if (position.y === 0) {
|
|
bottomHit = true;
|
|
}
|
|
|
|
if (position.y === (R3.CustomCode.TETRIS_GRID_HEIGHT - 1)) {
|
|
topHit = true;
|
|
}
|
|
|
|
/**
|
|
* Check outside of bounds
|
|
*/
|
|
if (position.x < 0) {
|
|
collision = true;
|
|
}
|
|
|
|
if (position.x >= R3.CustomCode.TETRIS_GRID_WIDTH) {
|
|
collision = true;
|
|
}
|
|
|
|
if (position.y < 0) {
|
|
collision = true;
|
|
}
|
|
|
|
if (position.y >= R3.CustomCode.TETRIS_GRID_HEIGHT) {
|
|
collision = true;
|
|
}
|
|
|
|
/**
|
|
* We want to see if the block to the right is taken, but we cannot
|
|
* be sure x+1 is inside bounds
|
|
*/
|
|
if (
|
|
((position.x + 1) < R3.CustomCode.TETRIS_GRID_WIDTH) &&
|
|
((position.x + 1) >= 0)
|
|
) {
|
|
/**
|
|
* But we cannot be sure y is inside bounds
|
|
*/
|
|
if (position.y < R3.CustomCode.TETRIS_GRID_HEIGHT && position.y >= 0) {
|
|
if (this.beforeRender.grid[position.y][position.x + 1].value === R3.CustomCode.TETRIS_GRID_TAKEN) {
|
|
/**
|
|
* Ok - we found a block to the right - its over
|
|
*/
|
|
rightHit = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* We want to see if the block to the left is taken, but we cannot be sure x - 1 is inside bounds
|
|
*/
|
|
if (
|
|
((position.x) > 0) &&
|
|
((position.x - 1) >= 0) &&
|
|
((position.x - 1) < R3.CustomCode.TETRIS_GRID_WIDTH)
|
|
) {
|
|
|
|
/**
|
|
* But we cannot be sure y is inside bounds
|
|
*/
|
|
if (position.y < R3.CustomCode.TETRIS_GRID_HEIGHT && position.y >= 0) {
|
|
if (this.beforeRender.grid[position.y][position.x - 1].value === R3.CustomCode.TETRIS_GRID_TAKEN) {
|
|
/**
|
|
* We found a block to the left - its over also
|
|
*/
|
|
leftHit = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Now we want to see if the block above is taken, we cannot be sure y+1 is inside bounds
|
|
*/
|
|
if (
|
|
((position.y + 1) < R3.CustomCode.TETRIS_GRID_HEIGHT) &&
|
|
((position.y + 1) >= 0)
|
|
) {
|
|
/**
|
|
* We cannot be sure, position.x is inside bounds
|
|
*/
|
|
if (position.x < R3.CustomCode.TETRIS_GRID_WIDTH && position.x >= 0) {
|
|
|
|
if (this.beforeRender.grid[position.y + 1][position.x].value === R3.CustomCode.TETRIS_GRID_TAKEN) {
|
|
/**
|
|
* Ok - this block is at the top
|
|
*/
|
|
topHit = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Now we want to see if the block below is taken, we cannot be sure y-1 is inside bounds
|
|
*/
|
|
if (
|
|
((position.y) > 0) &&
|
|
((position.y - 1) >= 0) &&
|
|
((position.y - 1) < R3.CustomCode.TETRIS_GRID_HEIGHT)
|
|
) {
|
|
/**
|
|
* We cannot be sure, position.x is inside bounds
|
|
*/
|
|
if (position.x < R3.CustomCode.TETRIS_GRID_WIDTH && position.x >= 0) {
|
|
if (this.beforeRender.grid[position.y - 1][position.x].value === R3.CustomCode.TETRIS_GRID_TAKEN) {
|
|
/**
|
|
* Ok - this block hit bottom
|
|
*/
|
|
bottomHit = true;
|
|
}
|
|
|
|
if (this.beforeRender.grid[position.y - 1][position.x].value === R3.CustomCode.TETRIS_GRID_DISAPPEARING) {
|
|
bottomDisappearing = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Now we want to see if the block is inside another block,
|
|
* we cannot be sure, x and y is inside bounds
|
|
*/
|
|
if (
|
|
(position.x < R3.CustomCode.TETRIS_GRID_WIDTH && position.x >= 0) &&
|
|
(position.y < R3.CustomCode.TETRIS_GRID_HEIGHT && position.y >= 0)
|
|
) {
|
|
if (this.beforeRender.grid[position.y][position.x].value === R3.CustomCode.TETRIS_GRID_TAKEN) {
|
|
collision = true;
|
|
}
|
|
}
|
|
}.bind(this)
|
|
);
|
|
|
|
return {
|
|
left: leftHit,
|
|
top: topHit,
|
|
right: rightHit,
|
|
bottom: bottomHit,
|
|
bottomDisappearing: bottomDisappearing,
|
|
collision: collision
|
|
}
|
|
|
|
}.bind(this)
|
|
|
|
R3.CustomCode.prototype.rotateBlock = function (clockwise) {
|
|
|
|
if (this.beforeRender.gameOver) {
|
|
return;
|
|
}
|
|
|
|
if (clockwise) {
|
|
var targetRotation = this.block.center.rotation.z - Math.PI / 2;
|
|
} else {
|
|
var targetRotation = this.block.center.rotation.z + Math.PI / 2;
|
|
}
|
|
|
|
this.stopAnimations();
|
|
|
|
var originalRotation = this.block.center.rotation.z;
|
|
|
|
this.block.center.rotation.z = targetRotation;
|
|
this.block.center.updateInstance('rotation');
|
|
|
|
var boundaries = this.checkBoundaries(this.block);
|
|
|
|
if (boundaries.collision) {
|
|
|
|
this.block.center.rotation.z = originalRotation;
|
|
this.block.center.updateInstance('rotation');
|
|
|
|
this.startAnimations();
|
|
|
|
} else {
|
|
|
|
this.block.center.rotation.z = originalRotation;
|
|
|
|
this.startAnimations();
|
|
|
|
this.block.center.rotation.z = targetRotation;
|
|
this.block.center.updateInstance('rotation');
|
|
|
|
}
|
|
|
|
}.bind(this);
|
|
|
|
R3.CustomCode.prototype.moveBlock = function (block, direction, units, collisionCheck) {
|
|
|
|
if (!units) {
|
|
units = 1;
|
|
}
|
|
|
|
var boundaries = null;
|
|
var moved = false;
|
|
|
|
if (collisionCheck) {
|
|
boundaries = this.checkBoundaries(block);
|
|
}
|
|
|
|
if (boundaries && boundaries.collision) {
|
|
return moved;
|
|
}
|
|
|
|
if (direction.left) {
|
|
|
|
if (boundaries && boundaries.left) {
|
|
//Do nothing
|
|
} else {
|
|
block.center.position.x -= units;
|
|
moved = true;
|
|
}
|
|
}
|
|
|
|
if (direction.right) {
|
|
|
|
if (boundaries && boundaries.right) {
|
|
//Do nothing
|
|
} else {
|
|
block.center.position.x += units;
|
|
moved = true;
|
|
}
|
|
}
|
|
|
|
if (direction.down) {
|
|
|
|
if (boundaries && boundaries.bottom) {
|
|
//Do nothing
|
|
} else if (boundaries && boundaries.bottomDisappearing) {
|
|
/**
|
|
* Set moved to 'null' instead of 'false' - null indicates to called we should wait - while still being 'false'
|
|
*/
|
|
moved = null;
|
|
} else {
|
|
block.center.position.y -= units;
|
|
moved = true;
|
|
}
|
|
}
|
|
|
|
if (direction.up) {
|
|
|
|
if (boundaries && boundaries.top) {
|
|
//Do nothing
|
|
} else {
|
|
block.center.position.y += units;
|
|
moved = true;
|
|
}
|
|
}
|
|
|
|
if (moved) {
|
|
block.center.updateInstance('position');
|
|
}
|
|
|
|
return moved;
|
|
}.bind(this);
|
|
|
|
R3.CustomCode.prototype.spawnBlock = function () {
|
|
|
|
var blockType = Math.floor(Math.random() * 7);
|
|
|
|
var mesh0 = null;
|
|
var mesh1 = null;
|
|
var mesh2 = null;
|
|
var mesh3 = null;
|
|
|
|
var offsetX = 0;
|
|
var offsetY = 0;
|
|
|
|
var tinyPositionX = 0;
|
|
var tinyPositionY = 0;
|
|
|
|
var nextPositionX = 0;
|
|
var nextPositionY = 0;
|
|
|
|
var center = this.boxCenter.clone();
|
|
|
|
center.position.y = 0;
|
|
center.position.x = 0;
|
|
center.position.z = 0.4;
|
|
|
|
if (blockType === R3.CustomCode.TETRIS_BLOCK_I) {
|
|
|
|
mesh0 = this.box11.clone();
|
|
mesh0.position.setFrom(center.position);
|
|
mesh0.position.z = -0.1;
|
|
mesh0.position.x -= 1;
|
|
|
|
mesh1 = this.box13.clone();
|
|
mesh1.position.setFrom(center.position);
|
|
mesh1.position.z = -0.1;
|
|
mesh1.position.x -= 2;
|
|
|
|
mesh2 = this.box14.clone();
|
|
mesh2.position.setFrom(center.position);
|
|
mesh2.position.z = -0.1;
|
|
mesh2.position.x += 0;
|
|
|
|
mesh3 = this.box15.clone();
|
|
mesh3.position.setFrom(center.position);
|
|
mesh3.position.z = -0.1;
|
|
mesh3.position.x += 1;
|
|
|
|
offsetX = 0.5;
|
|
offsetY = 1;
|
|
|
|
tinyPositionX = 1.32;
|
|
tinyPositionY = 16.7;
|
|
|
|
nextPositionX = 2.12;
|
|
nextPositionY = 15.5;
|
|
}
|
|
|
|
if (blockType === R3.CustomCode.TETRIS_BLOCK_L) {
|
|
mesh0 = this.box14.clone();
|
|
mesh0.position.setFrom(center.position);
|
|
mesh0.position.z = -0.1;
|
|
mesh0.position.x += 1;
|
|
mesh0.position.y += 1;
|
|
|
|
mesh1 = this.box11.clone();
|
|
mesh1.position.setFrom(center.position);
|
|
mesh1.position.z = -0.1;
|
|
mesh1.position.x += 1;
|
|
|
|
mesh2 = this.box14.clone();
|
|
mesh2.position.setFrom(center.position);
|
|
mesh2.position.z = -0.1;
|
|
mesh2.position.x += 0;
|
|
|
|
mesh3 = this.box15.clone();
|
|
mesh3.position.setFrom(center.position);
|
|
mesh3.position.z = -0.1;
|
|
mesh3.position.x -= 1;
|
|
|
|
offsetX = 0.5;
|
|
offsetY = 2;
|
|
|
|
tinyPositionX = 1.00;
|
|
tinyPositionY = 16.65;
|
|
|
|
nextPositionX = 1.78;
|
|
nextPositionY = 15.3;
|
|
}
|
|
|
|
if (blockType === R3.CustomCode.TETRIS_BLOCK_L2) {
|
|
mesh0 = this.box14.clone();
|
|
mesh0.position.setFrom(center.position);
|
|
mesh0.position.z = -0.1;
|
|
mesh0.position.x -= 1;
|
|
mesh0.position.y += 1;
|
|
|
|
mesh1 = this.box11.clone();
|
|
mesh1.position.setFrom(center.position);
|
|
mesh1.position.z = -0.1;
|
|
mesh1.position.x += 1;
|
|
|
|
mesh2 = this.box14.clone();
|
|
mesh2.position.setFrom(center.position);
|
|
mesh2.position.z = -0.1;
|
|
mesh2.position.x += 0;
|
|
|
|
mesh3 = this.box15.clone();
|
|
mesh3.position.setFrom(center.position);
|
|
mesh3.position.z = -0.1;
|
|
mesh3.position.x -= 1;
|
|
|
|
offsetX = 0.5;
|
|
offsetY = 2;
|
|
|
|
tinyPositionX = 1.00;
|
|
tinyPositionY = 16.65;
|
|
|
|
nextPositionX = 1.78;
|
|
nextPositionY = 15.3;
|
|
}
|
|
|
|
if (blockType === R3.CustomCode.TETRIS_BLOCK_Z) {
|
|
mesh0 = this.box10.clone();
|
|
mesh0.position.setFrom(center.position);
|
|
mesh0.position.z = -0.1;
|
|
mesh0.position.y += 1;
|
|
|
|
mesh1 = this.box11.clone();
|
|
mesh1.position.setFrom(center.position);
|
|
mesh1.position.z = -0.1;
|
|
mesh1.position.x -= 1;
|
|
mesh1.position.y += 1;
|
|
|
|
mesh2 = this.box15.clone();
|
|
mesh2.position.setFrom(center.position);
|
|
mesh2.position.z = -0.1;
|
|
|
|
mesh3 = this.box7.clone();
|
|
mesh3.position.setFrom(center.position);
|
|
mesh3.position.z = -0.1;
|
|
mesh3.position.x += 1;
|
|
|
|
offsetX = 0.5;
|
|
offsetY = 2;
|
|
|
|
tinyPositionX = 1.00;
|
|
tinyPositionY = 16.65;
|
|
|
|
nextPositionX = 1.78;
|
|
nextPositionY = 15.3;
|
|
}
|
|
|
|
if (blockType === R3.CustomCode.TETRIS_BLOCK_Z2) {
|
|
|
|
mesh0 = this.box10.clone();
|
|
mesh0.position.setFrom(center.position);
|
|
mesh0.position.z = -0.1;
|
|
mesh0.position.y += 1;
|
|
|
|
mesh1 = this.box11.clone();
|
|
mesh1.position.setFrom(center.position);
|
|
mesh1.position.z = -0.1;
|
|
mesh1.position.x += 1;
|
|
mesh1.position.y += 1;
|
|
|
|
mesh2 = this.box15.clone();
|
|
mesh2.position.setFrom(center.position);
|
|
mesh2.position.z = -0.1;
|
|
|
|
mesh3 = this.box7.clone();
|
|
mesh3.position.setFrom(center.position);
|
|
mesh3.position.z = -0.1;
|
|
mesh3.position.x -= 1;
|
|
|
|
offsetX = 0.5;
|
|
offsetY = 2;
|
|
|
|
tinyPositionX = 1.00;
|
|
tinyPositionY = 16.65;
|
|
|
|
nextPositionX = 1.78;
|
|
nextPositionY = 15.3;
|
|
}
|
|
|
|
if (blockType === R3.CustomCode.TETRIS_BLOCK_T) {
|
|
mesh0 = this.box14.clone();
|
|
mesh0.position.setFrom(center.position);
|
|
mesh0.position.z = -0.1;
|
|
mesh0.position.y -= 1;
|
|
|
|
mesh1 = this.box13.clone();
|
|
mesh1.position.setFrom(center.position);
|
|
mesh1.position.z = -0.1;
|
|
|
|
mesh2 = this.box11.clone();
|
|
mesh2.position.setFrom(center.position);
|
|
mesh2.position.z = -0.1;
|
|
mesh2.position.x -= 1;
|
|
|
|
mesh3 = this.box15.clone();
|
|
mesh3.position.setFrom(center.position);
|
|
mesh3.position.z = -0.1;
|
|
mesh3.position.x += 1;
|
|
|
|
offsetX = 0.5;
|
|
offsetY = 1;
|
|
|
|
tinyPositionX = 1.00;
|
|
tinyPositionY = 17;
|
|
|
|
nextPositionX = 1.78;
|
|
nextPositionY = 16;
|
|
}
|
|
|
|
if (blockType === R3.CustomCode.TETRIS_BLOCK_O) {
|
|
mesh0 = this.box10.clone();
|
|
mesh0.position.setFrom(center.position);
|
|
mesh0.position.z = -0.1;
|
|
mesh0.position.y += 0.5;
|
|
mesh0.position.x += 0.5;
|
|
|
|
mesh1 = this.box2.clone();
|
|
mesh1.position.setFrom(center.position);
|
|
mesh1.position.z = -0.1;
|
|
mesh1.position.y += 0.5;
|
|
mesh1.position.x -= 0.5;
|
|
|
|
mesh2 = this.box13.clone();
|
|
mesh2.position.setFrom(center.position);
|
|
mesh2.position.z = -0.1;
|
|
mesh2.position.y -= 0.5;
|
|
mesh2.position.x -= 0.5;
|
|
|
|
mesh3 = this.box15.clone();
|
|
mesh3.position.setFrom(center.position);
|
|
mesh3.position.z = -0.1;
|
|
mesh3.position.y -= 0.5;
|
|
mesh3.position.x += 0.5;
|
|
|
|
offsetX = 0;
|
|
offsetY = 1.5;
|
|
|
|
tinyPositionX = 1.00;
|
|
tinyPositionY = 16.85;
|
|
|
|
nextPositionX = 1.78;
|
|
nextPositionY = 15.65;
|
|
}
|
|
|
|
mesh0.setParentMesh(center);
|
|
mesh1.setParentMesh(center);
|
|
mesh2.setParentMesh(center);
|
|
mesh3.setParentMesh(center);
|
|
|
|
center.updateInstance('position');
|
|
|
|
mesh0.updateInstance('position');
|
|
mesh1.updateInstance('position');
|
|
mesh2.updateInstance('position');
|
|
mesh3.updateInstance('position');
|
|
|
|
var block = {
|
|
type: blockType,
|
|
offset: {
|
|
x: offsetX,
|
|
y: offsetY
|
|
},
|
|
tinyPosition: {
|
|
x: tinyPositionX,
|
|
y: tinyPositionY
|
|
},
|
|
nextPosition: {
|
|
x: nextPositionX,
|
|
y: nextPositionY
|
|
},
|
|
meshes: [
|
|
mesh0,
|
|
mesh1,
|
|
mesh2,
|
|
mesh3
|
|
],
|
|
angle: center.rotation.z,
|
|
center: center
|
|
};
|
|
|
|
return block;
|
|
|
|
}.bind(this)
|
|
|
|
R3.CustomCode.prototype.spawnTinyBlock = function () {
|
|
|
|
var block = this.spawnBlock();
|
|
|
|
/**
|
|
* Set the scale for the blocks
|
|
*/
|
|
block.center.scale.x = 0.333;
|
|
block.center.scale.y = 0.333;
|
|
block.center.scale.z = 0.333;
|
|
block.center.updateInstance('scale');
|
|
|
|
/**
|
|
* move tiny block a bit up - then a bit right
|
|
*/
|
|
block.center.position.x = block.tinyPosition.x;
|
|
block.center.position.y = block.tinyPosition.y;
|
|
block.center.position.z = 0.4;
|
|
block.center.updateInstance('position');
|
|
|
|
return block;
|
|
}.bind(this)
|
|
|
|
R3.CustomCode.prototype.spawnNextBlock = function () {
|
|
|
|
if (!this.tinyBlock) {
|
|
this.tinyBlock = this.spawnTinyBlock();
|
|
}
|
|
|
|
var block = this.tinyBlock;
|
|
|
|
block.center.scale.x = 0.666;
|
|
block.center.scale.y = 0.666;
|
|
block.center.scale.z = 0.666;
|
|
block.center.updateInstance('scale');
|
|
|
|
block.center.position.x = block.nextPosition.x;
|
|
block.center.position.y = block.nextPosition.y;
|
|
block.center.position.z = 0.4;
|
|
block.center.updateInstance('position');
|
|
|
|
this.tinyBlock = this.spawnTinyBlock();
|
|
|
|
return block;
|
|
}.bind(this)
|
|
|
|
R3.CustomCode.prototype.spawnBigBlock = function () {
|
|
|
|
if (!this.nextBlock) {
|
|
this.nextBlock = this.spawnNextBlock();
|
|
}
|
|
|
|
var block = this.nextBlock;
|
|
|
|
block.center.scale.x = 1;
|
|
block.center.scale.y = 1;
|
|
block.center.scale.z = 1;
|
|
block.center.updateInstance('scale');
|
|
|
|
block.center.position.x = 0;
|
|
block.center.position.y = 0;
|
|
block.center.position.z = 0.4;
|
|
block.center.updateInstance('position');
|
|
|
|
this.moveBlock(block, {up: true}, (R3.CustomCode.TETRIS_GRID_HEIGHT - R3.CustomCode.TETRIS_GRID_HEADSPACE), false);
|
|
this.moveBlock(block, {right: true}, R3.CustomCode.TETRIS_GRID_WIDTH / 2, false);
|
|
this.moveBlock(block, {left: true}, block.offset.x, false);
|
|
this.moveBlock(block, {down: true}, block.offset.y, false);
|
|
|
|
this.nextBlock = this.spawnNextBlock();
|
|
|
|
return block;
|
|
}.bind(this)
|
|
|
|
R3.CustomCode.prototype.getNextBlock = function () {
|
|
|
|
this.stopAnimations();
|
|
|
|
this.beforeRender.block = this.spawnBigBlock();
|
|
|
|
this.block = this.beforeRender.block;
|
|
|
|
R3.Event.Emit(
|
|
R3.Event.COMPONENT_REGISTER,
|
|
{
|
|
component: this.block.center
|
|
}
|
|
);
|
|
|
|
this.startAnimations();
|
|
|
|
this.animation.addMesh(this.block.center);
|
|
|
|
}.bind(this);
|
|
|
|
if (R3.Utils.UndefinedOrNull(this.subscriptions)) {
|
|
|
|
this.subscriptions = [];
|
|
|
|
R3.Event.Subscribe(
|
|
R3.Event.CUSTOM_CODE_WINDOW_RESIZE,
|
|
function (data) {
|
|
//var aspect = data.width / data.height;
|
|
this.camera.offsetX = -((this.camera.maxX - this.camera.minX) / 2) + (R3.CustomCode.TETRIS_GRID_WIDTH / 2) - 0.5 - (0.5 * this.camera.aspect);
|
|
this.camera.updateInstance('offsetX');
|
|
}.bind(this)
|
|
)
|
|
|
|
this.subscriptions.push(
|
|
new R3.Event.Subscribe(
|
|
R3.Event.CUSTOM_GAME_START,
|
|
|
|
function () {
|
|
|
|
R3.Event.Emit(
|
|
R3.Event.WINDOW_RESIZE,
|
|
{
|
|
width : window.innerWidth,
|
|
height : window.innerHeight
|
|
}
|
|
);
|
|
|
|
this.animationObjects = [];
|
|
|
|
this.score = 0;
|
|
this.level = 1;
|
|
this.rows = 0;
|
|
this.speed = 1;
|
|
|
|
this.drawGrid();
|
|
|
|
this.drawStatus();
|
|
|
|
/**
|
|
* Set the game parameters
|
|
*/
|
|
this.beforeRender.entityLoaded = null;
|
|
this.beforeRender.initialized = false;
|
|
|
|
/**
|
|
* Link the classes
|
|
*/
|
|
this.beforeRender.entityLoaded = this;
|
|
this.keyDown.entityLoaded = this;
|
|
this.touchEnd.entityLoaded = this;
|
|
this.touchStart.entityLoaded = this;
|
|
|
|
console.log('custom game start complete');
|
|
|
|
}.bind(this)
|
|
)
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Setup the game objects
|
|
* @type {boolean}
|
|
*/
|
|
this.box7 = this.box2.clone();
|
|
var material = this.box2.materials[0].clone();
|
|
var texture = material.diffuseMap.clone();
|
|
texture.image = this.image7;
|
|
texture.updateInstance('image');
|
|
material.diffuseMap = texture;
|
|
this.box7.materials = [material];
|
|
this.box7.materials[0].updateInstance('diffuseMap');
|
|
|
|
this.box10 = this.box2.clone();
|
|
material = this.box2.materials[0].clone();
|
|
texture = material.diffuseMap.clone();
|
|
texture.image = this.image10;
|
|
texture.updateInstance('image');
|
|
material.diffuseMap = texture;
|
|
this.box10.materials = [material];
|
|
this.box10.materials[0].updateInstance('diffuseMap');
|
|
|
|
this.box11 = this.box2.clone();
|
|
material = this.box2.materials[0].clone();
|
|
texture = material.diffuseMap.clone();
|
|
texture.image = this.image11;
|
|
texture.updateInstance('image');
|
|
material.diffuseMap = texture;
|
|
this.box11.materials = [material];
|
|
this.box11.materials[0].updateInstance('diffuseMap');
|
|
|
|
this.box13 = this.box2.clone();
|
|
material = this.box2.materials[0].clone();
|
|
texture = material.diffuseMap.clone();
|
|
texture.image = this.image13;
|
|
texture.updateInstance('image');
|
|
material.diffuseMap = texture;
|
|
this.box13.materials = [material];
|
|
this.box13.materials[0].updateInstance('diffuseMap');
|
|
|
|
this.box14 = this.box2.clone();
|
|
material = this.box2.materials[0].clone();
|
|
texture = material.diffuseMap.clone();
|
|
texture.image = this.image14;
|
|
texture.updateInstance('image');
|
|
material.diffuseMap = texture;
|
|
this.box14.materials = [material];
|
|
this.box14.materials[0].updateInstance('diffuseMap');
|
|
|
|
this.box15 = this.box2.clone();
|
|
material = this.box2.materials[0].clone();
|
|
texture = material.diffuseMap.clone();
|
|
texture.image = this.image15;
|
|
texture.updateInstance('image');
|
|
material.diffuseMap = texture;
|
|
this.box15.materials = [material];
|
|
this.box15.materials[0].updateInstance('diffuseMap');
|
|
|
|
R3.Event.Emit(R3.Event.GAME_LOADED);
|
|
|
|
//@ sourceURL=entityLoaded.js
|