1711 lines
45 KiB
JavaScript
1711 lines
45 KiB
JavaScript
if (data.entity === this.parentEntity) {
|
|
console.log('my entity loaded');
|
|
}
|
|
|
|
/**
|
|
* Custom Code Components
|
|
*/
|
|
this.ccBeforeRender = R3.EntityManager.Instance.findComponentById('r8wkd1wwip');
|
|
this.ccKeyDown = R3.EntityManager.Instance.findComponentById('airpllbqpu');
|
|
this.ccTouchStart = R3.EntityManager.Instance.findComponentById('dwln7lp0w9');
|
|
this.ccTouchEnd = R3.EntityManager.Instance.findComponentById('cgw7pwx0jg');
|
|
|
|
/**
|
|
* Images
|
|
*/
|
|
this.image_0 = R3.EntityManager.Instance.findComponentById('l8cs0ftjfu');
|
|
this.image_1 = R3.EntityManager.Instance.findComponentById('nxx7ywvjua');
|
|
this.image_2 = R3.EntityManager.Instance.findComponentById('skuw2a1auy');
|
|
this.image_3 = R3.EntityManager.Instance.findComponentById('egq1q2p0jv');
|
|
this.image_4 = R3.EntityManager.Instance.findComponentById('nw49tomo2g');
|
|
this.image_5 = R3.EntityManager.Instance.findComponentById('5j8ht73i3y');
|
|
this.image_6 = R3.EntityManager.Instance.findComponentById('a9wz0y7ukl');
|
|
this.image_grid = R3.EntityManager.Instance.findComponentById('qy233xuf15');
|
|
this.image_glow = R3.EntityManager.Instance.findComponentById('j374jz2dlp');
|
|
this.image_flames_small = R3.EntityManager.Instance.findComponentById('o4tvl5tvk6');
|
|
|
|
/**
|
|
* Scene
|
|
*/
|
|
this.scene = R3.EntityManager.Instance.findComponentById('t551yp2uw2');
|
|
|
|
/**
|
|
* Materials
|
|
*/
|
|
this.gridMaterial = R3.EntityManager.Instance.findComponentById('ajx545c2rv');
|
|
|
|
/**
|
|
* Score
|
|
*/
|
|
this.scoreCanvas = R3.EntityManager.Instance.findComponentById('ke0mqfoxev');
|
|
this.scoreTexture = R3.EntityManager.Instance.findComponentById('6k8p84kkgz');
|
|
|
|
/**
|
|
* Animations
|
|
*/
|
|
this.animation = R3.EntityManager.Instance.findComponentById('73b6zgwi6g');
|
|
|
|
/**
|
|
* Lights
|
|
*/
|
|
this.burnLight = R3.EntityManager.Instance.findComponentById('bprzyzukkr');
|
|
|
|
/**
|
|
* Textures
|
|
*/
|
|
this.textureDisplacement = R3.EntityManager.Instance.findComponentById('dwooesyl8u');
|
|
|
|
/**
|
|
* Initial Game Settings
|
|
* @type {number}
|
|
*/
|
|
this.score = 0;
|
|
this.level = 1;
|
|
this.rows = 0;
|
|
this.speed = 1;
|
|
|
|
this.grid = [];
|
|
|
|
this.gameOver = false;
|
|
|
|
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.grid.length; y++) {
|
|
for (var x = 0; x < this.grid[y].length; x++) {
|
|
if (this.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, lines) {
|
|
|
|
for (var x = 0; x < R3.CustomCode.TETRIS_GRID_WIDTH; x++) {
|
|
|
|
var bacon = this.tile_bacon_disappearing.clone();
|
|
|
|
bacon.visible = true;
|
|
bacon.updateInstance('visible');
|
|
|
|
bacon.position.x = x;
|
|
bacon.position.y = index;
|
|
bacon.position.z = 2;
|
|
bacon.updateInstance('position');
|
|
|
|
this.grid[index][x].baconDisappearing = bacon;
|
|
|
|
this.baconMaterials.push(
|
|
this.grid[index][x].mesh.materials[0]
|
|
);
|
|
}
|
|
|
|
var glow = this.tile_glow.clone();
|
|
|
|
glow.visible = true;
|
|
glow.updateInstance('visible');
|
|
|
|
glow.position.y = index;
|
|
glow.position.x = (R3.CustomCode.TETRIS_GRID_WIDTH / 2) - 0.5;
|
|
glow.position.z = 4;
|
|
glow.updateInstance('position');
|
|
|
|
var flames = this.tile_flames_small.clone();
|
|
|
|
flames.visible = true;
|
|
flames.updateInstance('visible');
|
|
|
|
flames.position.y = index + 0.5;
|
|
flames.position.x = (R3.CustomCode.TETRIS_GRID_WIDTH / 2) - 0.5;
|
|
flames.position.z = 5;
|
|
flames.updateInstance('position');
|
|
|
|
var animationObject = {
|
|
rowNumber: index,
|
|
glow: glow,
|
|
flames: flames,
|
|
flamesArray: [],
|
|
time: 0
|
|
}
|
|
|
|
animationObject.subscription = R3.Event.Subscribe(
|
|
R3.Event.BEFORE_RENDER,
|
|
function (__animationObject) {
|
|
return function (data) {
|
|
__animationObject.time += data.delta * 4;
|
|
|
|
this.burnLight.intensity = lines * Math.sin(__animationObject.time);
|
|
this.burnLight.updateInstance('intensity');
|
|
|
|
this.tile_glowMaterial.opacity = Math.sin(__animationObject.time);
|
|
this.tile_glowMaterial.updateInstance('opacity');
|
|
|
|
if (__animationObject.time < (Math.PI / 2)) {
|
|
|
|
this.baconMaterials.map(
|
|
function (material) {
|
|
material.displacementScale = -1 * Math.sin(__animationObject.time);
|
|
material.updateInstance('displacementScale');
|
|
}
|
|
);
|
|
|
|
}
|
|
|
|
if (__animationObject.time > Math.PI) {
|
|
|
|
__animationObject.subscription.remove();
|
|
|
|
/**
|
|
* 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 any additional flames
|
|
*/
|
|
__animationObject.flamesArray.map(
|
|
function (flame) {
|
|
R3.Event.Emit(
|
|
R3.Event.REMOVE_COMPONENT,
|
|
{
|
|
component: flame
|
|
}
|
|
);
|
|
}
|
|
);
|
|
|
|
/**
|
|
* Remove the meshes and the baconDisappearing objects
|
|
*/
|
|
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
|
|
}
|
|
);
|
|
|
|
R3.Event.Emit(
|
|
R3.Event.REMOVE_COMPONENT,
|
|
{
|
|
component: this.grid[__animationObject.rowNumber][x].baconDisappearing
|
|
}
|
|
);
|
|
|
|
}
|
|
|
|
/**
|
|
* 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');
|
|
}
|
|
|
|
if (this.grid[y][x].baconDisappearing) {
|
|
this.grid[y][x].baconDisappearing.position.y = y;
|
|
this.grid[y][x].baconDisappearing.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);
|
|
|
|
/**
|
|
* Restore our bacon materials if we have no more animation objects
|
|
*/
|
|
if (this.animationObjects.length === 0) {
|
|
|
|
this.baconMaterials.map(
|
|
function (material) {
|
|
material.displacementScale = 0;
|
|
material.updateInstance('displacementScale');
|
|
}
|
|
);
|
|
|
|
this.baconMaterials = [];
|
|
}
|
|
|
|
}
|
|
|
|
}.bind(this)
|
|
}.bind(this)(animationObject)
|
|
);
|
|
|
|
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.grid[y][x].value === R3.CustomCode.TETRIS_GRID_NOT_TAKEN ||
|
|
this.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.grid[index][x].value = R3.CustomCode.TETRIS_GRID_DISAPPEARING;
|
|
}
|
|
this.startAnimation(index, indices.length);
|
|
}.bind(this)
|
|
);
|
|
|
|
}.bind(this);
|
|
|
|
|
|
R3.CustomCode.prototype.drawStatus = function () {
|
|
var context = this.scoreCanvas.instance.getContext('2d');
|
|
|
|
context.textBaseline = "middle";
|
|
|
|
context.clearRect(0, 0, this.scoreCanvas.width, this.scoreCanvas.height);
|
|
|
|
context.fillStyle = "rgba(58, 36, 25, 0.7)";
|
|
context.fillRect(12, 30, 485, 178);
|
|
|
|
context.lineWidth = 8;
|
|
|
|
context.strokeStyle = '#eeb999';
|
|
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 = '#eeb999';
|
|
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 = '#eeb999';
|
|
|
|
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.drawGrid = function () {
|
|
|
|
var geometry = new THREE.PlaneBufferGeometry();
|
|
|
|
var mesh = new THREE.Mesh(
|
|
geometry,
|
|
this.gridMaterial.instance
|
|
);
|
|
|
|
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++) {
|
|
|
|
var clone = mesh.clone();
|
|
|
|
clone.position.x = x;
|
|
clone.position.y = y;
|
|
clone.position.z = 2;
|
|
|
|
this.scene.instance.add(clone);
|
|
}
|
|
}
|
|
|
|
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: 0x612d1a
|
|
}
|
|
)
|
|
)
|
|
);
|
|
|
|
|
|
}.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.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.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.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.grid[position.y - 1][position.x].value === R3.CustomCode.TETRIS_GRID_TAKEN) {
|
|
/**
|
|
* Ok - this block hit bottom
|
|
*/
|
|
bottomHit = true;
|
|
}
|
|
|
|
if (this.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.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.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;
|
|
}
|
|
|
|
var rotationBackup = {
|
|
instance : this.block.center.instance.rotation.z,
|
|
object : 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) {
|
|
|
|
/**
|
|
* There's a collision, restore the instance rotation
|
|
*/
|
|
this.block.center.instance.rotation.z = rotationBackup.instance;
|
|
|
|
/**
|
|
* And also the object rotation
|
|
*/
|
|
this.block.center.rotation.z = rotationBackup.object;
|
|
|
|
} else {
|
|
|
|
/**
|
|
* Restore our instance rotation
|
|
*/
|
|
this.block.center.instance.rotation.z = rotationBackup.instance;
|
|
|
|
/**
|
|
* Update our object to the new rotation
|
|
*/
|
|
this.block.center.rotation.z = targetRotation;
|
|
}
|
|
|
|
}.bind(this);
|
|
|
|
R3.CustomCode.prototype.moveBlock = function (block, direction, units, collisionCheck) {
|
|
|
|
if (R3.Utils.UndefinedOrNull(block)) {
|
|
block = this.block;
|
|
}
|
|
|
|
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;
|
|
}
|
|
}
|
|
|
|
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.tile_center.clone();
|
|
|
|
center.visible = true;
|
|
center.updateInstance('visible');
|
|
|
|
center.position.y = 0;
|
|
center.position.x = 0;
|
|
center.position.z = 3.5;
|
|
|
|
if (blockType === R3.CustomCode.TETRIS_BLOCK_I) {
|
|
|
|
mesh0 = this.tile_4.clone();
|
|
mesh0.position.setFrom(center.position);
|
|
mesh0.position.z = -0.1;
|
|
mesh0.position.x -= 1;
|
|
|
|
mesh1 = this.tile_5.clone();
|
|
mesh1.position.setFrom(center.position);
|
|
mesh1.position.z = -0.1;
|
|
mesh1.position.x -= 2;
|
|
|
|
mesh2 = this.tile_6.clone();
|
|
mesh2.position.setFrom(center.position);
|
|
mesh2.position.z = -0.1;
|
|
mesh2.position.x += 0;
|
|
|
|
mesh3 = this.tile_2.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.tile_6.clone();
|
|
mesh0.position.setFrom(center.position);
|
|
mesh0.position.z = -0.1;
|
|
mesh0.position.x += 1;
|
|
mesh0.position.y += 1;
|
|
|
|
mesh1 = this.tile_4.clone();
|
|
mesh1.position.setFrom(center.position);
|
|
mesh1.position.z = -0.1;
|
|
mesh1.position.x += 1;
|
|
|
|
mesh2 = this.tile_6.clone();
|
|
mesh2.position.setFrom(center.position);
|
|
mesh2.position.z = -0.1;
|
|
mesh2.position.x += 0;
|
|
|
|
mesh3 = this.tile_2.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.tile_6.clone();
|
|
mesh0.position.setFrom(center.position);
|
|
mesh0.position.z = -0.1;
|
|
mesh0.position.x -= 1;
|
|
mesh0.position.y += 1;
|
|
|
|
mesh1 = this.tile_4.clone();
|
|
mesh1.position.setFrom(center.position);
|
|
mesh1.position.z = -0.1;
|
|
mesh1.position.x += 1;
|
|
|
|
mesh2 = this.tile_6.clone();
|
|
mesh2.position.setFrom(center.position);
|
|
mesh2.position.z = -0.1;
|
|
mesh2.position.x += 0;
|
|
|
|
mesh3 = this.tile_2.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.tile_3.clone();
|
|
mesh0.position.setFrom(center.position);
|
|
mesh0.position.z = -0.1;
|
|
mesh0.position.y += 1;
|
|
|
|
mesh1 = this.tile_4.clone();
|
|
mesh1.position.setFrom(center.position);
|
|
mesh1.position.z = -0.1;
|
|
mesh1.position.x -= 1;
|
|
mesh1.position.y += 1;
|
|
|
|
mesh2 = this.tile_2.clone();
|
|
mesh2.position.setFrom(center.position);
|
|
mesh2.position.z = -0.1;
|
|
|
|
mesh3 = this.tile_1.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.tile_3.clone();
|
|
mesh0.position.setFrom(center.position);
|
|
mesh0.position.z = -0.1;
|
|
mesh0.position.y += 1;
|
|
|
|
mesh1 = this.tile_4.clone();
|
|
mesh1.position.setFrom(center.position);
|
|
mesh1.position.z = -0.1;
|
|
mesh1.position.x += 1;
|
|
mesh1.position.y += 1;
|
|
|
|
mesh2 = this.tile_2.clone();
|
|
mesh2.position.setFrom(center.position);
|
|
mesh2.position.z = -0.1;
|
|
|
|
mesh3 = this.tile_1.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.tile_6.clone();
|
|
mesh0.position.setFrom(center.position);
|
|
mesh0.position.z = -0.1;
|
|
mesh0.position.y -= 1;
|
|
|
|
mesh1 = this.tile_5.clone();
|
|
mesh1.position.setFrom(center.position);
|
|
mesh1.position.z = -0.1;
|
|
|
|
mesh2 = this.tile_4.clone();
|
|
mesh2.position.setFrom(center.position);
|
|
mesh2.position.z = -0.1;
|
|
mesh2.position.x -= 1;
|
|
|
|
mesh3 = this.tile_2.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.tile_3.clone();
|
|
mesh0.position.setFrom(center.position);
|
|
mesh0.position.z = -0.1;
|
|
mesh0.position.y += 0.5;
|
|
mesh0.position.x += 0.5;
|
|
|
|
mesh1 = this.tile_0.clone();
|
|
mesh1.position.setFrom(center.position);
|
|
mesh1.position.z = -0.1;
|
|
mesh1.position.y += 0.5;
|
|
mesh1.position.x -= 0.5;
|
|
|
|
mesh2 = this.tile_5.clone();
|
|
mesh2.position.setFrom(center.position);
|
|
mesh2.position.z = -0.1;
|
|
mesh2.position.y -= 0.5;
|
|
mesh2.position.x -= 0.5;
|
|
|
|
mesh3 = this.tile_2.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.visible = true;
|
|
mesh0.updateInstance('visible');
|
|
mesh1.visible = true;
|
|
mesh1.updateInstance('visible');
|
|
mesh2.visible = true;
|
|
mesh2.updateInstance('visible');
|
|
mesh3.visible = true;
|
|
mesh3.updateInstance('visible');
|
|
|
|
mesh0.parentMesh = center;
|
|
mesh0.updateInstance('parentMesh');
|
|
|
|
mesh1.parentMesh = center;
|
|
mesh1.updateInstance('parentMesh');
|
|
|
|
mesh2.parentMesh = center;
|
|
mesh2.updateInstance('parentMesh');
|
|
|
|
mesh3.parentMesh = center;
|
|
mesh3.updateInstance('parentMesh');
|
|
|
|
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 = 2.5;
|
|
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);
|
|
block.center.updateInstance('position');
|
|
|
|
this.nextBlock = this.spawnNextBlock();
|
|
|
|
return block;
|
|
}.bind(this)
|
|
|
|
R3.CustomCode.prototype.getNextBlock = function () {
|
|
|
|
this.block = this.spawnBigBlock();
|
|
|
|
R3.Event.Emit(
|
|
R3.Event.COMPONENT_REGISTER,
|
|
{
|
|
component: this.block.center
|
|
}
|
|
);
|
|
|
|
this.animation.meshes.push(this.block.center);
|
|
|
|
}.bind(this);
|
|
|
|
/**
|
|
* This code executes when the 'bottom' has been reached (the block is stopping)
|
|
*/
|
|
R3.CustomCode.prototype.stopBlock = function() {
|
|
|
|
var gridPositions = this.getBlockGridPositions(this.block);
|
|
|
|
gridPositions.map(
|
|
|
|
function (position) {
|
|
|
|
/**
|
|
* If there already is a mesh - remove it -
|
|
*/
|
|
var block = this.grid[position.y][position.x];
|
|
|
|
if (block.mesh) {
|
|
this.scene.removeObject(block.mesh);
|
|
}
|
|
if (block.baconDisappearing) {
|
|
this.scene.removeObject(block.baconDisappearing);
|
|
}
|
|
|
|
block = {
|
|
value : R3.CustomCode.TETRIS_GRID_TAKEN,
|
|
mesh : position.mesh,
|
|
baconDisappearing : null
|
|
}
|
|
|
|
this.grid[position.y][position.x] = block;
|
|
|
|
}.bind(this)
|
|
|
|
);
|
|
|
|
/**
|
|
* We apply our current rotation and position to the instance
|
|
*/
|
|
this.block.center.updateInstance('position');
|
|
this.block.center.updateInstance('rotation');
|
|
|
|
/**
|
|
* Now we unlink the meshes from the controlling center block
|
|
*/
|
|
this.block.meshes.map(
|
|
function (mesh) {
|
|
|
|
mesh.parentMesh = null;
|
|
mesh.updateInstance('parentMesh');
|
|
|
|
mesh.position.z = 2.5;
|
|
mesh.updateInstance('position');
|
|
|
|
}.bind(this)
|
|
);
|
|
|
|
/**
|
|
* We remove the controlling block
|
|
*/
|
|
R3.Event.Emit(
|
|
R3.Event.REMOVE_COMPONENT,
|
|
{
|
|
component: this.block.center
|
|
}
|
|
);
|
|
|
|
/**
|
|
* We remove any lines
|
|
*/
|
|
this.removeLines();
|
|
|
|
//this.visualizeGrid(0xff0000);
|
|
|
|
/**
|
|
* Check if the game is over
|
|
*/
|
|
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) {
|
|
|
|
/**
|
|
* End the game if game over
|
|
*/
|
|
R3.Event.Emit(
|
|
R3.Event.GAME_OVER,
|
|
{
|
|
score: this.score,
|
|
level: this.level,
|
|
rows: this.rows
|
|
}
|
|
);
|
|
|
|
} else {
|
|
|
|
/**
|
|
* Otherwise continue
|
|
*/
|
|
this.getNextBlock();
|
|
}
|
|
|
|
}.bind(this);
|
|
|
|
/**
|
|
* Clears the grid
|
|
*/
|
|
R3.CustomCode.prototype.clearGrid = function() {
|
|
|
|
/**
|
|
* Remove all stale components (if any)
|
|
*/
|
|
if (this.grid instanceof Array) {
|
|
this.grid.map(
|
|
function(row) {
|
|
row.map(
|
|
function(block){
|
|
if (block.mesh) {
|
|
this.scene.removeObject(block.mesh);
|
|
}
|
|
if (block.baconDisappearing) {
|
|
this.scene.removeObject(block.baconDisappearing);
|
|
}
|
|
}.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,
|
|
baconDisappearing : null
|
|
};
|
|
}
|
|
}
|
|
|
|
}.bind(this)
|
|
|
|
R3.CustomCode.prototype.createTile = function(tileName, imageName, displace) {
|
|
|
|
var apiMaterial;
|
|
|
|
if (imageName) {
|
|
if (displace) {
|
|
apiMaterial = new R3.D3.API.Material.Phong(
|
|
null,
|
|
null,
|
|
null,
|
|
null,
|
|
null,
|
|
null,
|
|
null,
|
|
null,
|
|
this.textureDisplacement,
|
|
null,
|
|
null,
|
|
null,
|
|
null,
|
|
null,
|
|
null,
|
|
null,
|
|
null,
|
|
new R3.D3.API.Texture.Image(
|
|
null,
|
|
this[imageName]
|
|
)
|
|
)
|
|
} else {
|
|
apiMaterial = new R3.D3.API.Material.Phong(
|
|
null,
|
|
null,
|
|
null,
|
|
null,
|
|
null,
|
|
null,
|
|
null,
|
|
null,
|
|
null,
|
|
null,
|
|
null,
|
|
null,
|
|
null,
|
|
null,
|
|
null,
|
|
null,
|
|
null,
|
|
new R3.D3.API.Texture.Image(
|
|
null,
|
|
this[imageName]
|
|
)
|
|
)
|
|
}
|
|
} else {
|
|
apiMaterial = new R3.D3.API.Material.Phong();
|
|
}
|
|
|
|
this[tileName] = new R3.D3.Mesh(
|
|
this.graphics,
|
|
new R3.D3.API.Mesh(
|
|
null,
|
|
new R3.D3.API.Geometry.Buffer.Plane(
|
|
null,
|
|
1,
|
|
1,
|
|
10,
|
|
10
|
|
),
|
|
[
|
|
apiMaterial
|
|
],
|
|
null,
|
|
this.scene
|
|
)
|
|
)
|
|
|
|
this[tileName].visible = false;
|
|
this[tileName].updateInstance('visible');
|
|
|
|
/**
|
|
* Remove this tile from the 'meshes' so it is treated like a clone and doesn't get stored
|
|
*/
|
|
this[tileName].parentScene.addClone(this[tileName]);
|
|
|
|
}.bind(this);
|
|
|
|
R3.Event.Subscribe(
|
|
R3.Event.CUSTOM_GAME_START,
|
|
|
|
function () {
|
|
|
|
this.animationObjects = [];
|
|
|
|
this.baconMaterials = [];
|
|
|
|
this.score = 0;
|
|
this.level = 1;
|
|
this.rows = 0;
|
|
this.speed = 1;
|
|
|
|
/**
|
|
* Draw our new status
|
|
*/
|
|
this.drawStatus();
|
|
|
|
/**
|
|
* Ensure the grid is cleared
|
|
*/
|
|
this.clearGrid();
|
|
|
|
|
|
if (this.block && 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.getNextBlock();
|
|
|
|
/**
|
|
* Set the game parameters
|
|
*/
|
|
this.ccBeforeRender.entityLoaded = null;
|
|
this.ccBeforeRender.initialized = false;
|
|
|
|
/**
|
|
* Link the classes
|
|
*/
|
|
this.ccBeforeRender.entityLoaded = this;
|
|
this.ccKeyDown.entityLoaded = this;
|
|
this.ccTouchStart.entityLoaded = this;
|
|
this.ccTouchEnd.entityLoaded = this;
|
|
|
|
/**
|
|
* Allow the game to proceed
|
|
* @type {boolean}
|
|
*/
|
|
this.gameOver = false;
|
|
|
|
console.log('game start complete');
|
|
|
|
}.bind(this)
|
|
);
|
|
|
|
R3.Event.Emit(
|
|
R3.Event.GET_RUNTIME,
|
|
{},
|
|
function(runtime) {
|
|
|
|
this.graphics = runtime.graphics;
|
|
|
|
this.createTile('tile_0', 'image_0', true);
|
|
this.createTile('tile_1', 'image_1', true);
|
|
this.createTile('tile_2', 'image_2', true);
|
|
this.createTile('tile_3', 'image_3', true);
|
|
this.createTile('tile_4', 'image_4', true);
|
|
this.createTile('tile_5', 'image_5', true);
|
|
this.createTile('tile_6', 'image_6', true);
|
|
|
|
this.createTile('tile_grid', 'image_grid');
|
|
|
|
this.createTile('tile_flames_small', 'image_flames_small');
|
|
|
|
this.tile_flames_small.materials[0].transparent = true;
|
|
this.tile_flames_small.materials[0].updateInstance('transparent');
|
|
|
|
this.tile_flames_small.geometry.width = '11';
|
|
this.tile_flames_small.geometry.height = '11';
|
|
this.tile_flames_small.geometry.updateInstance('width');
|
|
|
|
this.createTile('tile_glow', 'image_glow');
|
|
|
|
this.tile_glow.materials[0].transparent = true;
|
|
this.tile_glow.materials[0].updateInstance('transparent');
|
|
|
|
this.tile_glow.geometry.width = '12';
|
|
this.tile_glow.geometry.height = '12';
|
|
this.tile_glow.geometry.updateInstance('width');
|
|
|
|
this.tile_glowMaterial = this.tile_glow.materials[0];
|
|
|
|
this.createTile('tile_center');
|
|
|
|
this.tile_center.materials[0].transparent = true;
|
|
this.tile_center.materials[0].updateInstance('transparent');
|
|
|
|
this.tile_center.materials[0].opacity = 0;
|
|
this.tile_center.materials[0].updateInstance('opacity');
|
|
|
|
this.tile_center.useQuaternion = false;
|
|
|
|
this.createTile('tile_bacon_disappearing');
|
|
|
|
this.tile_bacon_disappearing.materials[0].color.fromHex('#3e1d1d');
|
|
this.tile_bacon_disappearing.materials[0].updateInstance('color');
|
|
|
|
this.drawGrid();
|
|
this.drawStatus();
|
|
|
|
R3.Event.Emit(R3.Event.WINDOW_RESIZE, R3.Utils.GetWindowSize());
|
|
|
|
R3.Event.Emit(R3.Event.GAME_LOADED);
|
|
|
|
}.bind(this)
|
|
)
|
|
//@ sourceURL=entityLoaded.js
|