mirror of
https://github.com/simon987/Much-Assembly-Required-Frontend.git
synced 2025-04-10 14:26:44 +00:00
1697 lines
53 KiB
JavaScript
1697 lines
53 KiB
JavaScript
DIR_NORTH = 0;
|
|
DIR_EAST = 1;
|
|
DIR_SOUTH = 2;
|
|
DIR_WEST = 3;
|
|
|
|
WORLD_HEIGHT = WORLD_WIDTH = 16;
|
|
|
|
|
|
var colorScheme = {
|
|
tileTint: 0xFFFFFF,
|
|
wallTint: 0xDDDDDD,
|
|
cubotHoverTint: 0x00FF00,
|
|
cubotTint: 0xFFFFFF,
|
|
textFill: "#FFFFFF",
|
|
textStroke: "#9298a8",
|
|
biomassTint: 0x63B85F,
|
|
biomassHoverTint: 0x00FF00,
|
|
tileHoverTint: 0x00FF00,
|
|
itemIron: 0x434341,
|
|
itemCopper: 0xC87D38,
|
|
hologramFill: "#0aced6",
|
|
hologramStroke: "#12FFB0",
|
|
hologramAlpha: 0.9
|
|
};
|
|
|
|
var mar = {};
|
|
mar.kbBuffer = [];
|
|
mar.kbBufferText = "";
|
|
mar.animationFrames = {};
|
|
mar.controlledUnitVisible = false;
|
|
mar.lastLines = "";
|
|
mar.bigMessage = "";
|
|
|
|
CUBOT_WALK_FRAMES = {
|
|
south: 240,
|
|
north: 194,
|
|
west: 254,
|
|
east: 164
|
|
};
|
|
|
|
HARVESTER_WALK_FRAMES = {
|
|
south: 347,
|
|
north: 317,
|
|
west: 377,
|
|
east: 287
|
|
};
|
|
|
|
LOW_ENERGY = 100;
|
|
|
|
|
|
if (fullscreen) {
|
|
RENDERER_WIDTH = window.innerWidth* window.devicePixelRatio - 4;
|
|
RENDERER_HEIGHT = window.innerHeight* window.devicePixelRatio - 4;
|
|
} else {
|
|
RENDERER_WIDTH = document.getElementById("game").clientWidth * window.devicePixelRatio;
|
|
RENDERER_HEIGHT = (window.innerHeight / 1.40) * window.devicePixelRatio;
|
|
}
|
|
|
|
var game = new Phaser.Game(RENDERER_WIDTH, RENDERER_HEIGHT, Phaser.AUTO, 'game', null, true, false);
|
|
|
|
function dispatchTileLeave(x, y) {
|
|
|
|
for (var i = 0; i < mar.world.tiles.length; i++) {
|
|
|
|
var tX = mar.world.tiles[i].tileX;
|
|
var tY = mar.world.tiles[i].tileY;
|
|
|
|
|
|
if (mar.world.tiles[i].isWall && ((tX === x && tY - 1 === y ) || (tX - 1 === x && tY - 1 === y) || (tX - 1 === x && tY === y ))
|
|
&& mar.world.tiles[i].alpha !== 1) {
|
|
|
|
game.add.tween(mar.world.tiles[i]).to({alpha: 1}, 175, Phaser.Easing.Quadratic.In, true);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
function dispatchTileEnter(x, y) {
|
|
|
|
/*
|
|
* X X X
|
|
* X C T
|
|
* X T T
|
|
*
|
|
* Transparent, X: Normal, C: Cubot
|
|
*/
|
|
|
|
for (var i = 0; i < mar.world.tiles.length; i++) {
|
|
|
|
var tX = mar.world.tiles[i].tileX;
|
|
var tY = mar.world.tiles[i].tileY;
|
|
|
|
|
|
if (mar.world.tiles[i].isWall && ((tX === x && tY - 1 === y ) || (tX - 1 === x && tY - 1 === y) || (tX - 1 === x && tY === y ))) {
|
|
game.add.tween(mar.world.tiles[i]).to({alpha: 0.6}, 300, Phaser.Easing.Quadratic.In, true);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
function Word(terrain) {
|
|
|
|
var self = this;
|
|
|
|
self.tiles = [];
|
|
self.objects = [];
|
|
|
|
setupWorldArrows();
|
|
|
|
this.setTerrain = function (terrain) {
|
|
for (var x = 0; x < WORLD_HEIGHT; x++) {
|
|
for (var y = 0; y < WORLD_HEIGHT; y++) {
|
|
|
|
var terrainType = terrain[y * WORLD_WIDTH + x];
|
|
if (terrainType === 1) {
|
|
var tile = game.add.isoSprite(getIsoX(x), getIsoY(y), 0, 'sheet', "tiles/bigTile", isoGroup);
|
|
tile.baseZ = 0;
|
|
tile.baseTint = colorScheme.wallTint;
|
|
tile.anchor.set(0.5, 0.2);
|
|
tile.isWall = true;
|
|
|
|
} else if (terrainType === 2) {
|
|
|
|
tile = game.add.isoSprite(getIsoX(x), getIsoY(y), 0, 'sheet', "tiles/tile", isoGroup);
|
|
text = game.make.text(0, 16, "Iron", {
|
|
fontSize: 22,
|
|
fill: "#434341",
|
|
stroke: "#FFFFFF",
|
|
strokeThickness: 1,
|
|
font: "fixedsys"
|
|
});
|
|
text.alpha = 0.6;
|
|
text.anchor.set(0.5, 0);
|
|
tile.addChild(text);
|
|
tile.baseZ = 0;
|
|
// tile.baseTint = 0x434341;
|
|
tile.baseTint = 0xF3F3F3;
|
|
tile.anchor.set(0.5, 0);
|
|
} else if (terrainType === 3) {
|
|
tile = game.add.isoSprite(getIsoX(x), getIsoY(y), 0, 'sheet', "tiles/tile", isoGroup);
|
|
var text = game.make.text(0, 16, "Copper", {
|
|
fontSize: 22,
|
|
fill: "#C87D38",
|
|
stroke: "#FFFFFF",
|
|
strokeThickness: 1,
|
|
font: "fixedsys"
|
|
});
|
|
text.alpha = 0.6;
|
|
text.anchor.set(0.5, 0);
|
|
tile.addChild(text);
|
|
tile.baseZ = 0;
|
|
tile.baseTint = 0xF3F3F3;
|
|
tile.anchor.set(0.5, 0);
|
|
} else {
|
|
tile = game.add.isoSprite(getIsoX(x), getIsoY(y), 0, 'sheet', "tiles/tile", isoGroup);
|
|
tile.baseZ = 0;
|
|
tile.baseTint = colorScheme.tileTint;
|
|
tile.anchor.set(0.5, 0);
|
|
}
|
|
|
|
tile.isTile = true;
|
|
|
|
tile.tileX = x;
|
|
tile.tileY = y;
|
|
|
|
tile.tint = tile.baseTint;
|
|
|
|
self.tiles.push(tile);
|
|
}
|
|
}
|
|
};
|
|
|
|
this.setTerrain(terrain);
|
|
|
|
this.update = function (terrain) {
|
|
|
|
|
|
for (var i = 0; i < mar.world.objects.length; i++) {
|
|
mar.world.objects[i].destroy();
|
|
}
|
|
|
|
for (var i = 0; i < mar.world.tiles.length; i++) {
|
|
mar.world.tiles[i].destroy();
|
|
}
|
|
|
|
mar.world.objects = [];
|
|
mar.world.tiles = [];
|
|
|
|
this.setTerrain(terrain);
|
|
game.iso.topologicalSort(isoGroup);
|
|
|
|
|
|
};
|
|
|
|
/**
|
|
* Get object from the list of 'current' objects (Objects shown on the screen)
|
|
* @param id objectId of the object
|
|
*/
|
|
this.getObject = function (id) {
|
|
|
|
for (var i = 0; i < self.objects.length; i++) {
|
|
if (self.objects[i].id === id) {
|
|
return self.objects[i];
|
|
}
|
|
}
|
|
|
|
return null;
|
|
};
|
|
|
|
/**
|
|
* Update object from parsed JSON string sent from the server
|
|
* @param response parsed JSON string sent from the server
|
|
*/
|
|
this.updateObjects = function (response) {
|
|
|
|
//Mark objects as not updated
|
|
for (i = 0; i < self.objects.length; i++) {
|
|
self.objects[i].updated = false;
|
|
}
|
|
|
|
for (var i = 0; i < response.length; i++) {
|
|
|
|
//Update/Create the object
|
|
var existingObject = self.getObject(response[i].i);
|
|
|
|
if (existingObject !== null) {
|
|
//Object already exists
|
|
existingObject.updated = true;
|
|
|
|
// console.log("Update " + existingObject.id);
|
|
existingObject = updateGameObject(existingObject, response[i]);
|
|
|
|
} else {
|
|
|
|
//Object is new
|
|
var newObj = createGameObject(response[i]);
|
|
newObj.updated = true;
|
|
self.objects.push(newObj);
|
|
}
|
|
}
|
|
|
|
//Delete not updated objects (see above comments)
|
|
for (var i = 0; i < self.objects.length; i++) {
|
|
if (!self.objects[i].updated) {
|
|
|
|
|
|
//Check if the object we are removing is our controlledUnit, if so, follow it
|
|
if (mar.client.username !== "guest") {
|
|
if (self.objects[i].type === 1 && self.objects[i].username === mar.client.username) {
|
|
findMyRobot();
|
|
console.log("Following Cubot " + mar.client.username)
|
|
}
|
|
}
|
|
|
|
self.objects[i].destroy();
|
|
|
|
dispatchTileLeave(self.objects[i].tileX, self.objects[i].tileY);
|
|
self.objects.splice(i, 1);
|
|
}
|
|
}
|
|
};
|
|
|
|
}
|
|
|
|
function updateGameObject(object, responseObj) {
|
|
|
|
object.direction = responseObj.direction;
|
|
|
|
|
|
if (object.type === 1) {
|
|
|
|
object.action = responseObj.action;
|
|
object.energy = responseObj.energy;
|
|
|
|
//Update location
|
|
if ((object.tileX !== responseObj.x || object.tileY !== responseObj.y)) {
|
|
//location changed
|
|
|
|
//Walk
|
|
if (object.action === 2) {
|
|
dispatchTileLeave(object.tileX, object.tileY);
|
|
|
|
object.tileX = responseObj.x;
|
|
object.tileY = responseObj.y;
|
|
|
|
cubotMove(object, object.direction, undefined, CUBOT_WALK_FRAMES);
|
|
} else if (object.action === 6) {
|
|
//Jump
|
|
dispatchTileLeave(object.tileX, object.tileY);
|
|
|
|
object.tileX = responseObj.x;
|
|
object.tileY = responseObj.y;
|
|
|
|
cubotMove(object, object.direction, undefined, CUBOT_WALK_FRAMES, true);
|
|
}
|
|
}
|
|
|
|
//Update Inventory
|
|
if (object.heldItem !== responseObj.heldItem) {
|
|
|
|
if (object.inventory !== undefined) {
|
|
object.inventory.destroy();
|
|
}
|
|
|
|
object.inventory = createInventory([responseObj.heldItem]);
|
|
object.addChild(object.inventory);
|
|
object.heldItem = responseObj.heldItem;
|
|
|
|
}
|
|
|
|
//Battery indication
|
|
if (object.tint !== colorScheme.cubotHoverTint) {
|
|
if (object.energy <= LOW_ENERGY) {
|
|
object.tint = 0xFF0000;
|
|
} else {
|
|
object.tint = 0xFFFFFF;
|
|
}
|
|
}
|
|
|
|
|
|
//Update direction
|
|
switch (object.direction) {
|
|
case DIR_NORTH:
|
|
object.animations.frame = 194;
|
|
break;
|
|
case DIR_EAST:
|
|
object.animations.frame = 164;
|
|
break;
|
|
case DIR_SOUTH:
|
|
object.animations.frame = 240;
|
|
break;
|
|
case DIR_WEST:
|
|
object.animations.frame = 254;
|
|
break;
|
|
}
|
|
|
|
//Update hologram
|
|
if (object.hologram !== undefined) {
|
|
object.hologram.destroy();
|
|
}
|
|
|
|
var color = false;
|
|
if (responseObj.holoC) {
|
|
color = (responseObj.holoC & 0xFFFFFF).toString(16)
|
|
color = "#" + ("000000".substr(color.length) + color);
|
|
}
|
|
|
|
if (responseObj.holoMode === 1) {
|
|
//Hex
|
|
object.hologram = game.make.text(0, 32, "0x" + ("0000" + Number(responseObj.holo).toString(16).toUpperCase()).slice(-4), {
|
|
fontSize: 32,
|
|
fill: color ? color : colorScheme.hologramFill,
|
|
stroke: colorScheme.hologramStroke,
|
|
strokeThickness: 1,
|
|
font: "fixedsys"
|
|
});
|
|
|
|
console.log(Number(color).toString(16))
|
|
|
|
} else if (responseObj.holoMode === 2) {
|
|
//String
|
|
object.hologram = game.make.text(0, 32, responseObj.holoStr.replace(/[\n|\t]/g, ''), {
|
|
fontSize: 27,
|
|
fill: color ? color : colorScheme.hologramFill,
|
|
stroke: colorScheme.hologramStroke,
|
|
strokeThickness: 1,
|
|
font: "fixedsys"
|
|
});
|
|
|
|
} else if (responseObj.holoMode === 3) {
|
|
//Decimal
|
|
object.hologram = game.make.text(0, 32, Number(responseObj.holo).toString(), {
|
|
fontSize: 32,
|
|
fill: color ? color : colorScheme.hologramFill,
|
|
stroke: colorScheme.hologramStroke,
|
|
strokeThickness: 1,
|
|
font: "fixedsys"
|
|
});
|
|
}
|
|
|
|
if (object.hologram !== undefined) {
|
|
object.hologram.alpha = colorScheme.hologramAlpha;
|
|
object.hologram.anchor.set(0.5, 0);
|
|
object.addChild(object.hologram);
|
|
|
|
game.add.tween(object.hologram).to({tint: 0xFFFFF0, alpha: colorScheme.hologramAlpha - 0.1},
|
|
mar.client.tickLength, Phaser.Easing.Bounce.In, true);
|
|
}
|
|
|
|
|
|
if (object.action === 1) {
|
|
//Dig
|
|
cubotDig(object, object.direction);
|
|
}
|
|
} else if (object.type === 10) {
|
|
object.action = responseObj.action;
|
|
|
|
//Update location
|
|
if ((object.tileX !== responseObj.x || object.tileY !== responseObj.y)) {
|
|
//location changed
|
|
dispatchTileLeave(object.tileX, object.tileY);
|
|
|
|
object.tileX = responseObj.x;
|
|
object.tileY = responseObj.y;
|
|
cubotMove(object, object.direction, undefined, HARVESTER_WALK_FRAMES);
|
|
}
|
|
|
|
//Update direction
|
|
switch (object.direction) {
|
|
case DIR_NORTH:
|
|
object.animations.frame = HARVESTER_WALK_FRAMES.north;
|
|
break;
|
|
case DIR_EAST:
|
|
object.animations.frame = HARVESTER_WALK_FRAMES.east;
|
|
break;
|
|
case DIR_SOUTH:
|
|
object.animations.frame = HARVESTER_WALK_FRAMES.south;
|
|
break;
|
|
case DIR_WEST:
|
|
object.animations.frame = HARVESTER_WALK_FRAMES.west;
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
}
|
|
|
|
function itemColor(item) {
|
|
|
|
switch (item) {
|
|
|
|
case 1:
|
|
return colorScheme.biomassTint;
|
|
|
|
case 3:
|
|
return colorScheme.itemIron;
|
|
case 4:
|
|
return colorScheme.itemCopper;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
function createInventory(items) {
|
|
|
|
var inventory = game.make.group();
|
|
switch (items.length) {
|
|
case 0:
|
|
return inventory;
|
|
case 1:
|
|
if (items[0] !== 0) {
|
|
var shadow = game.make.sprite(0, 0, "sheet", "inventory/inv1x1");
|
|
shadow.anchor.set(0.5, 0.1);
|
|
shadow.alpha = 0.5;
|
|
var item = game.make.sprite(0, 0, "sheet", "inventory/item");
|
|
item.anchor.set(0.5, 0.1);
|
|
item.tint = itemColor(items[0]);
|
|
|
|
|
|
inventory.addChild(shadow);
|
|
inventory.addChild(item);
|
|
|
|
}
|
|
return inventory;
|
|
|
|
|
|
}
|
|
|
|
for (var i = 0; i < items.length; i++) {
|
|
|
|
}
|
|
|
|
}
|
|
|
|
function createGameObject(objData) {
|
|
|
|
if (objData.t === 1) {
|
|
var cubot = game.add.isoSprite(getIsoX(objData.x), getIsoY(objData.y), 15, "sheet", null, isoGroup);
|
|
cubot.anchor.set(0.5, 0);
|
|
|
|
cubot.inputEnabled = true;
|
|
cubot.events.onInputDown.add(function () {
|
|
debugObj = "Cubot: " + cubot.tileX + ", " + cubot.tileY;
|
|
});
|
|
|
|
cubot.events.onInputOver.add(function () {
|
|
document.body.style.cursor = 'pointer';
|
|
});
|
|
cubot.events.onInputOut.add(function () {
|
|
document.body.style.cursor = 'default';
|
|
});
|
|
|
|
cubot.id = objData.i;
|
|
cubot.type = 1;
|
|
cubot.tileX = objData.x;
|
|
cubot.tileY = objData.y;
|
|
cubot.username = objData.parent;
|
|
cubot.heldItem = objData.heldItem;
|
|
cubot.direction = objData.direction;
|
|
cubot.action = objData.action;
|
|
cubot.energy = objData.energy;
|
|
|
|
cubot.inventory = createInventory([cubot.heldItem]);
|
|
cubot.addChild(cubot.inventory);
|
|
|
|
dispatchTileEnter(objData.x, objData.y);
|
|
|
|
cubot.isAt = function (x, y) {
|
|
return this.tileX === x && this.tileY === y;
|
|
};
|
|
|
|
cubot.onTileHover = function () {
|
|
game.add.tween(this).to({isoZ: 45}, 200, Phaser.Easing.Quadratic.InOut, true);
|
|
game.add.tween(this.scale).to({x: 1.2, y: 1.2}, 200, Phaser.Easing.Linear.None, true);
|
|
|
|
this.tint = colorScheme.cubotHoverTint;
|
|
|
|
};
|
|
cubot.onTileOut = function () {
|
|
document.body.style.cursor = 'default';
|
|
|
|
game.add.tween(this).to({isoZ: 15}, 400, Phaser.Easing.Bounce.Out, true);
|
|
game.add.tween(this.scale).to({x: 1, y: 1}, 200, Phaser.Easing.Linear.None, true);
|
|
|
|
this.tint = 0xFFFFFF;
|
|
|
|
};
|
|
|
|
//Battery indication
|
|
if (cubot.energy <= LOW_ENERGY) {
|
|
cubot.tint = 0xCC0000;
|
|
}
|
|
|
|
cubot.animations.add("walk_w", mar.animationFrames.walk_w, true);
|
|
cubot.animations.add("walk_s", mar.animationFrames.walk_s, true);
|
|
cubot.animations.add("walk_e", mar.animationFrames.walk_e, true);
|
|
cubot.animations.add("walk_n", mar.animationFrames.walk_n, true);
|
|
cubot.animations.add("dig_w", mar.animationFrames.dig_w, false);
|
|
cubot.animations.add("dig_s", mar.animationFrames.dig_s, false);
|
|
cubot.animations.add("dig_e", mar.animationFrames.dig_e, false);
|
|
cubot.animations.add("dig_n", mar.animationFrames.dig_n, false);
|
|
|
|
cubot.queuedAnims = [];
|
|
|
|
switch (cubot.direction) {
|
|
case DIR_NORTH:
|
|
cubot.animations.frame = 194;
|
|
break;
|
|
case DIR_EAST:
|
|
cubot.animations.frame = 164;
|
|
break;
|
|
case DIR_SOUTH:
|
|
cubot.animations.frame = 240;
|
|
break;
|
|
case DIR_WEST:
|
|
cubot.animations.frame = 254;
|
|
break;
|
|
}
|
|
|
|
|
|
var username = game.make.text(0, -24, cubot.username, {
|
|
fontSize: 22,
|
|
fill: colorScheme.textFill,
|
|
stroke: colorScheme.textStroke,
|
|
strokeThickness: 2,
|
|
font: "fixedsys"
|
|
});
|
|
username.alpha = 0.85;
|
|
username.anchor.set(0.5, 0);
|
|
if (cubot.username === mar.client.username) {
|
|
username.tint = 0xFB4D0A;
|
|
} else {
|
|
cubot.alpha = 0.6;
|
|
}
|
|
cubot.addChild(username);
|
|
|
|
|
|
return cubot;
|
|
|
|
} else if (objData.t === 2) {
|
|
|
|
var biomass = game.add.isoSprite(getIsoX(objData.x), getIsoY(objData.y), 10, "sheet", 1, isoGroup);
|
|
biomass.animations.add("idle", mar.mar.animationFrames.biomassIdle, true);
|
|
biomass.anchor.set(0.5, 0);
|
|
|
|
biomass.type = 2;
|
|
biomass.tileX = objData.x;
|
|
biomass.tileY = objData.y;
|
|
biomass.id = objData.i;
|
|
|
|
biomass.tint = colorScheme.biomassTint;// "#3BB886"
|
|
|
|
biomass.hoverText = game.make.text(0, 0, "Biomass", {
|
|
fontSize: 22,
|
|
fill: colorScheme.textFill,
|
|
stroke: colorScheme.textStroke,
|
|
strokeThickness: 2,
|
|
font: "fixedsys"
|
|
});
|
|
biomass.hoverText.alpha = 0;
|
|
biomass.hoverText.anchor.set(0.5, 0);
|
|
biomass.addChild(biomass.hoverText);
|
|
|
|
biomass.isAt = function (x, y) {
|
|
return this.tileX === x && this.tileY === y;
|
|
};
|
|
|
|
biomass.isAt = function (x, y) {
|
|
return this.tileX === x && this.tileY === y;
|
|
};
|
|
|
|
biomass.onTileHover = function () {
|
|
game.tweens.removeFrom(this);
|
|
document.body.style.cursor = 'pointer';
|
|
game.add.tween(this).to({isoZ: 45}, 200, Phaser.Easing.Quadratic.InOut, true);
|
|
this.tint = colorScheme.biomassHoverTint;
|
|
game.add.tween(this.scale).to({x: 1.2, y: 1.2}, 200, Phaser.Easing.Linear.None, true);
|
|
game.add.tween(this.hoverText).to({alpha: 0.9}, 200, Phaser.Easing.Quadratic.In, true);
|
|
biomass.hoverText.visible = true;
|
|
|
|
|
|
};
|
|
biomass.onTileOut = function () {
|
|
game.tweens.removeFrom(this);
|
|
document.body.style.cursor = 'default';
|
|
|
|
game.add.tween(this).to({isoZ: 15}, 400, Phaser.Easing.Bounce.Out, true);
|
|
game.add.tween(this.scale).to({x: 1, y: 1}, 200, Phaser.Easing.Linear.None, true);
|
|
this.tint = colorScheme.biomassTint;
|
|
game.add.tween(this.hoverText).to({alpha: 0}, 200, Phaser.Easing.Quadratic.Out, true);
|
|
};
|
|
|
|
biomass.animations.play("idle", 45, true);
|
|
|
|
return biomass;
|
|
|
|
} else if (objData.t === 10) {
|
|
|
|
var harvester = game.add.isoSprite(getIsoX(objData.x), getIsoY(objData.y), 15, "sheet", null, isoGroup);
|
|
harvester.anchor.set(0.5, 0);
|
|
|
|
harvester.id = objData.i;
|
|
harvester.type = 10;
|
|
harvester.tileX = objData.x;
|
|
harvester.tileY = objData.y;
|
|
harvester.direction = objData.direction;
|
|
harvester.action = objData.action;
|
|
|
|
dispatchTileEnter(objData.x, objData.y);
|
|
|
|
harvester.isAt = function (x, y) {
|
|
return this.tileX === x && this.tileY === y;
|
|
};
|
|
|
|
harvester.onTileHover = function () {
|
|
game.add.tween(this).to({isoZ: 45}, 200, Phaser.Easing.Quadratic.InOut, true);
|
|
game.add.tween(this.scale).to({x: 1.2, y: 1.2}, 200, Phaser.Easing.Linear.None, true);
|
|
this.tint = colorScheme.cubotHoverTint;
|
|
};
|
|
harvester.onTileOut = function () {
|
|
game.add.tween(this).to({isoZ: 15}, 400, Phaser.Easing.Bounce.Out, true);
|
|
game.add.tween(this.scale).to({x: 1, y: 1}, 200, Phaser.Easing.Linear.None, true);
|
|
this.tint = colorScheme.cubotTint;
|
|
};
|
|
|
|
harvester.animations.add("walk_w", mar.animationFrames.harvester_walk_w, true);
|
|
harvester.animations.add("walk_s", mar.animationFrames.harvester_walk_s, true);
|
|
harvester.animations.add("walk_e", mar.animationFrames.harvester_walk_e, true);
|
|
harvester.animations.add("walk_n", mar.animationFrames.harvester_walk_n, true);
|
|
|
|
harvester.queuedAnims = [];
|
|
|
|
switch (harvester.direction) {
|
|
case DIR_NORTH:
|
|
harvester.animations.frame = HARVESTER_WALK_FRAMES.north;
|
|
break;
|
|
case DIR_EAST:
|
|
harvester.animations.frame = HARVESTER_WALK_FRAMES.east;
|
|
break;
|
|
case DIR_SOUTH:
|
|
harvester.animations.frame = HARVESTER_WALK_FRAMES.south;
|
|
break;
|
|
case DIR_WEST:
|
|
harvester.animations.frame = HARVESTER_WALK_FRAMES.west;
|
|
break;
|
|
}
|
|
|
|
|
|
return harvester;
|
|
} else if (objData.t === 3) {
|
|
//Factory
|
|
var factory = game.add.isoSprite(getIsoX(objData.x), getIsoY(objData.y), 15, "sheet", "objects/factory", isoGroup);
|
|
factory.anchor.set(0.5, .25);
|
|
|
|
factory.id = objData.i;
|
|
factory.type = 3;
|
|
factory.tileX = objData.x;
|
|
factory.tileY = objData.y;
|
|
|
|
|
|
factory.hoverText = game.make.text(0, 0, "Factory", {
|
|
fontSize: 22,
|
|
fill: colorScheme.textFill,
|
|
stroke: colorScheme.textStroke,
|
|
strokeThickness: 2,
|
|
font: "fixedsys"
|
|
});
|
|
factory.hoverText.alpha = 0;
|
|
factory.hoverText.anchor.set(0.5, 0);
|
|
factory.addChild(factory.hoverText);
|
|
|
|
factory.isAt = function (x, y) {
|
|
return (this.tileX === x || this.tileX + 1 === x) && (this.tileY + 1 === y || this.tileY === y);
|
|
};
|
|
|
|
factory.onTileHover = function () {
|
|
game.tweens.removeFrom(this);
|
|
game.add.tween(this).to({isoZ: 25}, 200, Phaser.Easing.Quadratic.InOut, true);
|
|
game.add.tween(this.scale).to({x: 1.06, y: 1.06}, 200, Phaser.Easing.Linear.None, true);
|
|
this.tint = colorScheme.cubotHoverTint;
|
|
|
|
game.add.tween(this.hoverText).to({alpha: 0.9}, 200, Phaser.Easing.Quadratic.In, true);
|
|
factory.hoverText.visible = true;
|
|
};
|
|
factory.onTileOut = function () {
|
|
game.tweens.removeFrom(this);
|
|
game.add.tween(this).to({isoZ: 15}, 400, Phaser.Easing.Bounce.Out, true);
|
|
game.add.tween(this.scale).to({x: 1, y: 1}, 200, Phaser.Easing.Linear.None, true);
|
|
this.tint = colorScheme.cubotTint;
|
|
|
|
game.add.tween(this.hoverText).to({alpha: 0}, 200, Phaser.Easing.Quadratic.Out, true);
|
|
};
|
|
|
|
return factory;
|
|
} else if (objData.t === 4) {
|
|
//Radio tower
|
|
var radioTower = game.add.isoSprite(getIsoX(objData.x), getIsoY(objData.y), 15, "sheet", "objects/RadioTower", isoGroup);
|
|
radioTower.anchor.set(0.5, 0.64);
|
|
|
|
radioTower.id = objData.i;
|
|
radioTower.type = 4;
|
|
radioTower.tileX = objData.x;
|
|
radioTower.tileY = objData.y;
|
|
|
|
|
|
radioTower.hoverText = game.make.text(0, 0, "Radio Tower", {
|
|
fontSize: 22,
|
|
fill: colorScheme.textFill,
|
|
stroke: colorScheme.textStroke,
|
|
strokeThickness: 2,
|
|
font: "fixedsys"
|
|
});
|
|
radioTower.hoverText.alpha = 0;
|
|
radioTower.hoverText.anchor.set(0.5, 0);
|
|
radioTower.addChild(radioTower.hoverText);
|
|
|
|
radioTower.isAt = function (x, y) {
|
|
return this.tileX === x && this.tileY === y;
|
|
};
|
|
|
|
radioTower.onTileHover = function () {
|
|
game.tweens.removeFrom(this);
|
|
game.add.tween(this).to({isoZ: 45}, 200, Phaser.Easing.Quadratic.InOut, true);
|
|
game.add.tween(this.scale).to({x: 1.15, y: 1.15}, 200, Phaser.Easing.Linear.None, true);
|
|
this.tint = colorScheme.cubotHoverTint;
|
|
|
|
game.add.tween(this.hoverText).to({alpha: 0.9}, 200, Phaser.Easing.Quadratic.In, true);
|
|
radioTower.hoverText.visible = true;
|
|
};
|
|
radioTower.onTileOut = function () {
|
|
game.tweens.removeFrom(this);
|
|
game.add.tween(this).to({isoZ: 15}, 400, Phaser.Easing.Bounce.Out, true);
|
|
game.add.tween(this.scale).to({x: 1, y: 1}, 200, Phaser.Easing.Linear.None, true);
|
|
this.tint = colorScheme.cubotTint;
|
|
|
|
game.add.tween(this.hoverText).to({alpha: 0}, 200, Phaser.Easing.Quadratic.Out, true);
|
|
};
|
|
|
|
return radioTower;
|
|
|
|
}
|
|
}
|
|
|
|
// --------------------------
|
|
//Integer distance between 2 tiles
|
|
function manhanttanDistance(x1, y1, x2, y2) {
|
|
return Math.abs(x1 - x2) + Math.abs(y1 - y2)
|
|
}
|
|
|
|
function codeListener(message) {
|
|
|
|
if (message.t === "code") {
|
|
|
|
ace.edit("editor").setValue(message.code);
|
|
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Listens for authentications responses from the server
|
|
*/
|
|
function authListener(message) {
|
|
|
|
if (message.t === "auth") {
|
|
|
|
if (message.m === "ok") {
|
|
console.log("Auth successful");
|
|
mar.client.requestUserInfo();
|
|
|
|
} else {
|
|
alert("Authentication failed. Please make sure you are logged in and reload the page.");
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
function codeResponseListener(message) {
|
|
if (message.t === "codeResponse") {
|
|
alert("Uploaded and assembled " + message.bytes + " bytes")
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Listens for user info responses from the server
|
|
*/
|
|
function userInfoListener(message) {
|
|
|
|
|
|
if (message.t === "userInfo") {
|
|
|
|
//Create new world / Find my robot
|
|
console.log(message);
|
|
|
|
mar.worldX = message.worldX;
|
|
mar.worldY = message.worldY;
|
|
|
|
mar.maxWidth = message.maxWidth;
|
|
|
|
mar.client.requestTerrain();
|
|
}
|
|
}
|
|
|
|
function terrainListener(message) {
|
|
if (message.t === "terrain") {
|
|
|
|
if (mar.bigMessage) {
|
|
mar.bigMessage.destroy();
|
|
}
|
|
|
|
if (message.ok) {
|
|
|
|
if (mar.world !== undefined) {
|
|
mar.client.socket.send(JSON.stringify({t: "object", x: mar.worldX, y: mar.worldY}));
|
|
mar.world.update(message.terrain);
|
|
|
|
} else {
|
|
mar.world = new Word(message.terrain);
|
|
console.log("Gameloop started");
|
|
|
|
//Handle keypresses
|
|
game.input.keyboard.onDownCallback = function (event) {
|
|
|
|
//If the game has focus
|
|
if (document.activeElement === document.getElementById("game")) {
|
|
if ((event.keyCode >= 37 && event.keyCode <= 40) || event.keyCode === 116 || event.keyCode === 32) {
|
|
event.preventDefault();
|
|
}
|
|
|
|
if (mar.client.username !== "guest" && mar.kbBuffer.length <= 16) {
|
|
mar.client.sendKeypress(event.keyCode);
|
|
|
|
//Locally update the buffer
|
|
mar.kbBuffer.push(event.keyCode);
|
|
mar.kbBufferText = formattedKeyBuffer(mar.kbBuffer);
|
|
}
|
|
}
|
|
};
|
|
|
|
//Grab focus when clicked (For chrome, Opera)
|
|
game.input.onDown.add(function () {
|
|
document.getElementById("game").focus();
|
|
})
|
|
}
|
|
} else {
|
|
//World is not available
|
|
if (mar.world !== undefined) {
|
|
mar.world.update([]);
|
|
} else {
|
|
mar.world = new Word([])
|
|
}
|
|
mar.bigMessage = game.add.text(908, 450, "[Uncharted World]", {
|
|
fontSize: 46,
|
|
fill: "#ff803d",
|
|
stroke: colorScheme.textStroke,
|
|
strokeThickness: 2,
|
|
font: "fixedsys"
|
|
}, textGroup);
|
|
}
|
|
|
|
|
|
}
|
|
}
|
|
|
|
function objectListener(message) {
|
|
|
|
if (message.t === "object") {
|
|
mar.world.updateObjects(message.objects);
|
|
}
|
|
}
|
|
|
|
function floppyListener(message) {
|
|
document.getElementById("floppyDown").innerHTML = "<i class=\"fa fa-long-arrow-down\" aria-hidden=\"true\"></i> <i class=\"fa fa-floppy-o\" aria-hidden=\"true\"></i>";
|
|
var blob = new Blob([message.data], {type: "application/octet-stream"});
|
|
saveAs(blob, "floppy.bin");
|
|
}
|
|
|
|
|
|
function tickListener(message) {
|
|
if (message.t === "tick") {
|
|
//Request objects
|
|
mar.client.socket.send(JSON.stringify({t: "object", x: mar.worldX, y: mar.worldY}));
|
|
|
|
//Update key buffer display
|
|
if (message.keys !== undefined) {
|
|
mar.kbBuffer = message.keys;
|
|
mar.kbBufferText = formattedKeyBuffer(mar.kbBuffer);
|
|
}
|
|
|
|
var myConsole = document.getElementById('console');
|
|
|
|
if (message.cm === 0) {
|
|
//Clear command was sent
|
|
myConsole.innerHTML = "";
|
|
mar.lastLines = "";
|
|
}
|
|
|
|
//Update console
|
|
if (message.c !== undefined) {
|
|
var str = mar.lastLines;
|
|
|
|
for (var i = 0; i < message.c.length; i++) {
|
|
|
|
str += message.c[i];
|
|
}
|
|
|
|
//Limit lines to 40 chars
|
|
myConsole.innerHTML = "";
|
|
var tmpBuffer = "";
|
|
var lines = str.split("\n");
|
|
for (var i = 0; i < lines.length; i++) {
|
|
|
|
if (lines[i].length >= 40) {
|
|
|
|
//Split the line...
|
|
var subLines = lines[i].match(/.{1,40}/g);
|
|
|
|
for (var j = 0; j < subLines.length; j++) {
|
|
|
|
//Don't put a newline at the end
|
|
if (j !== subLines.length - 1) {
|
|
tmpBuffer += "\n";
|
|
}
|
|
}
|
|
|
|
} else {
|
|
tmpBuffer += lines[i] + "\n";
|
|
}
|
|
}
|
|
|
|
myConsole.innerHTML = tmpBuffer;
|
|
mar.lastLines = str;
|
|
|
|
//Autoscroll
|
|
myConsole.scrollTop = myConsole.scrollHeight;
|
|
}
|
|
}
|
|
}
|
|
|
|
var GameClient = function (callback) {
|
|
|
|
var self = this;
|
|
|
|
var listeners = [];
|
|
var xhr = new XMLHttpRequest();
|
|
|
|
xhr.open("GET", "./getServerInfo.php", true);
|
|
|
|
xhr.onreadystatechange = function () {
|
|
if (xhr.readyState === 4 && xhr.status === 200) {
|
|
|
|
console.log("Received server info " + xhr.responseText);
|
|
|
|
setTimeout(function () {
|
|
var info = JSON.parse(xhr.responseText);
|
|
|
|
console.log(info.address);
|
|
self.socket = new WebSocket(info.address);
|
|
self.username = info.username;
|
|
self.tickLength = info.tickLength;
|
|
self.serverName = info.serverName;
|
|
|
|
mar.client.socket.binaryType = 'arraybuffer';
|
|
self.socket.onopen = function () {
|
|
|
|
//Send auth request
|
|
self.socket.send(info.token);
|
|
|
|
|
|
//Setup event managers
|
|
listeners.push(authListener);
|
|
listeners.push(userInfoListener);
|
|
listeners.push(terrainListener);
|
|
listeners.push(tickListener);
|
|
listeners.push(objectListener);
|
|
listeners.push(codeListener);
|
|
listeners.push(codeResponseListener);
|
|
|
|
mar.client.socket.onmessage = function (received) {
|
|
|
|
try {
|
|
var message = JSON.parse(received.data);
|
|
|
|
} catch (e) {
|
|
console.log(e)
|
|
floppyListener(received);
|
|
}
|
|
|
|
for (var i = 0; i < listeners.length; i++) {
|
|
listeners[i](message);
|
|
}
|
|
|
|
|
|
};
|
|
|
|
self.reloadCode();
|
|
|
|
|
|
if (callback !== undefined) {
|
|
callback();
|
|
}
|
|
};
|
|
|
|
self.socket.onerror = function (e) {
|
|
|
|
alert("Can't connect to game server at address " + info.address);
|
|
|
|
console.log(e);
|
|
};
|
|
|
|
self.socket.onclose = function (e) {
|
|
|
|
alert("Disconnected from server");
|
|
console.log(e);
|
|
}
|
|
}, 100);
|
|
}
|
|
};
|
|
xhr.send(null);
|
|
|
|
|
|
this.requestUserInfo = function () {
|
|
this.socket.send(JSON.stringify({t: "userInfo"}));
|
|
};
|
|
|
|
this.requestTerrain = function () {
|
|
this.socket.send(JSON.stringify({t: "terrain", x: mar.worldX, y: mar.worldY}));
|
|
};
|
|
|
|
this.uploadCode = function (code) {
|
|
console.log("Uploaded code");
|
|
this.socket.send(JSON.stringify({t: "uploadCode", code: code}))
|
|
};
|
|
|
|
this.reloadCode = function () {
|
|
this.socket.send(JSON.stringify({t: "codeRequest"}))
|
|
};
|
|
|
|
this.sendKeypress = function (key) {
|
|
if (key !== 0) {
|
|
this.socket.send(JSON.stringify({t: "k", k: key}));
|
|
}
|
|
};
|
|
|
|
this.requestFloppy = function () {
|
|
document.getElementById("floppyDown").innerHTML = "<i class=\"fa fa-cog fa-spin fa-fw\"></i>";
|
|
this.socket.send(JSON.stringify({t: "floppyDown"}));
|
|
};
|
|
|
|
this.notifyFloppyUp = function () {
|
|
this.socket.send(JSON.stringify({t: "floppyUp"}));
|
|
}
|
|
|
|
};
|
|
|
|
function dispatchTileHover(x, y) {
|
|
|
|
for (var i in mar.world.objects) {
|
|
|
|
var object = mar.world.objects[i];
|
|
|
|
if (object.isAt(x, y)) {
|
|
object.onTileHover();
|
|
}
|
|
}
|
|
}
|
|
|
|
function dispatchTileOut(x, y) {
|
|
for (var i in mar.world.objects) {
|
|
|
|
var object = mar.world.objects[i];
|
|
|
|
if (object.isAt(x, y)) {
|
|
object.onTileOut();
|
|
}
|
|
}
|
|
}
|
|
|
|
var count = 0;
|
|
var BasicGame = function (game) {
|
|
};
|
|
|
|
BasicGame.Boot = function (game) {
|
|
};
|
|
|
|
var isoGroup, cursorPos, cursor;
|
|
var textGroup;
|
|
var debugTile;
|
|
var debugObj;
|
|
var objectsGroup;
|
|
var cursors;
|
|
var tmpLine;
|
|
|
|
BasicGame.Boot.prototype = {
|
|
preload: function () {
|
|
game.load.atlasJSONHash("sheet", "./mar/sprites.png", "./mar/sprites.json");
|
|
|
|
game.time.advancedTiming = true;
|
|
|
|
// Add and enable the plug-in.
|
|
game.plugins.add(new Phaser.Plugin.Isometric(game));
|
|
|
|
// This is used to set a game canvas-based offset for the 0, 0, 0 isometric coordinate - by default
|
|
// this point would be at screen coordinates 0, 0 (top left) which is usually undesirable.
|
|
game.iso.anchor.setTo(0.5, 0);
|
|
game.world.setBounds(0, 0, 2200, 1100);
|
|
//Make camera more or less centered (tested on 1080 screen)
|
|
game.camera.x = 280;
|
|
game.camera.y = 90;
|
|
game.stage.disableVisibilityChange = true;
|
|
|
|
this.scale.scaleMode = Phaser.ScaleManager.RESIZE;
|
|
this.scale.pageAlignHorizontally = true;
|
|
this.scale.pageAlignVertically = true;
|
|
|
|
},
|
|
create: function () {
|
|
|
|
// Create a group for our tiles.
|
|
isoGroup = game.add.group();
|
|
objectsGroup = game.add.group();
|
|
textGroup = game.add.group();
|
|
|
|
//Initialise Cubot Animations Frames lists
|
|
initialiseAnimations();
|
|
|
|
// Let's make a load of tiles on a grid.
|
|
this.spawnTiles();
|
|
|
|
// Provide a 3D position for the cursor
|
|
cursorPos = new Phaser.Plugin.Isometric.Point3();
|
|
|
|
cursors = game.input.keyboard.createCursorKeys();
|
|
|
|
},
|
|
update: function () {
|
|
game.scale.refresh();
|
|
// Update the cursor position.
|
|
// It's important to understand that screen-to-isometric projection means you have to specify a z position manually, as this cannot be easily
|
|
// determined from the 2D pointer position without extra trickery. By default, the z position is 0 if not set.
|
|
game.iso.unproject(game.input.activePointer.position, cursorPos);
|
|
|
|
// Loop through all tiles and test to see if the 3D position from above intersects with the automatically generated IsoSprite tile bounds.
|
|
isoGroup.forEach(function (tile) {
|
|
|
|
if (tile.isTile) {
|
|
var inBounds = tile.isoBounds.containsXY(cursorPos.x, cursorPos.y);
|
|
// If it does, do a little animation and tint change.
|
|
if (!tile.selected && inBounds) {
|
|
tile.selected = true;
|
|
tile.tint = colorScheme.tileHoverTint;
|
|
|
|
debugTile = tile.tileX + ", " + tile.tileY;
|
|
|
|
dispatchTileHover(tile.tileX, tile.tileY);
|
|
|
|
game.add.tween(tile).to({isoZ: tile.baseZ + 8}, 200, Phaser.Easing.Quadratic.InOut, true);
|
|
}
|
|
// If not, revert back to how it was.
|
|
else if (tile.selected && !inBounds) {
|
|
dispatchTileOut(tile.tileX, tile.tileY);
|
|
tile.selected = false;
|
|
tile.tint = tile.baseTint;
|
|
game.add.tween(tile).to({isoZ: tile.baseZ}, 200, Phaser.Easing.Quadratic.InOut, true);
|
|
}
|
|
}
|
|
});
|
|
|
|
if (this.game.input.activePointer.isDown) {
|
|
if (this.game.origDragPoint) {
|
|
// move the camera by the amount the mouse has moved since last update
|
|
this.game.camera.x += this.game.origDragPoint.x - this.game.input.activePointer.position.x;
|
|
this.game.camera.y += this.game.origDragPoint.y - this.game.input.activePointer.position.y;
|
|
}
|
|
// set new drag origin to current position
|
|
this.game.origDragPoint = this.game.input.activePointer.position.clone();
|
|
|
|
} else {
|
|
this.game.origDragPoint = null;
|
|
}
|
|
|
|
count++;
|
|
|
|
if (count % 10 === 0) {
|
|
game.iso.topologicalSort(isoGroup);
|
|
}
|
|
|
|
|
|
// if(mar.world){
|
|
// for(var i = 0; i < mar.world.objects.length; i++){
|
|
// if(mar.world.objects[i].animations){
|
|
// console.log(mar.world.objects[i].animations.currentFrame)
|
|
//
|
|
// }
|
|
// }
|
|
// }
|
|
|
|
},
|
|
|
|
|
|
render: function () {
|
|
if (mar.worldX !== undefined) {
|
|
game.debug.text("World: (" + Number(mar.worldX).toString(16) + ", " + Number(mar.worldY).toString(16) + ")", 10, 20);
|
|
} else {
|
|
game.debug.text("World: (?,?)", 10, 20);
|
|
}
|
|
if (debugTile) {
|
|
game.debug.text(debugTile, 10, 40);
|
|
}
|
|
|
|
if (mar.client.username !== "guest") {
|
|
game.debug.text(mar.kbBufferText, 210, 20);
|
|
}
|
|
// game.debug.text(debugObj, 32, 190);
|
|
|
|
// game.debug.text(game.time.fps || '--', 2, 14, "#a7aebe");
|
|
|
|
// game.debug.cameraInfo(game.camera, 32, 32);
|
|
|
|
|
|
if (tmpLine !== undefined) {
|
|
game.debug.geom(tmpLine);
|
|
game.debug.lineInfo(tmpLine, 32, 32);
|
|
}
|
|
|
|
|
|
|
|
},
|
|
spawnTiles: function () {
|
|
mar.client = new GameClient();
|
|
}
|
|
};
|
|
|
|
function setupWorldArrows() {
|
|
|
|
var northArrow = game.make.isoSprite(528, -10, 10, "sheet", "ui/arrow_north", isoGroup);
|
|
northArrow.inputEnabled = true;
|
|
northArrow.events.onInputDown.add(function () {
|
|
|
|
if (mar.worldY === 0) {
|
|
mar.worldY = mar.maxWidth;
|
|
} else {
|
|
mar.worldY--;
|
|
}
|
|
mar.client.requestTerrain();
|
|
});
|
|
northArrow.events.onInputOver.add(function () {
|
|
northArrow.tint = 0x00ff00;
|
|
document.body.style.cursor = "pointer";
|
|
});
|
|
northArrow.events.onInputOut.add(function () {
|
|
northArrow.tint = 0xFFFFFF;
|
|
document.body.style.cursor = "default";
|
|
});
|
|
isoGroup.addChild(northArrow);
|
|
|
|
var eastArrow = game.make.isoSprite(1115, 587, 10, "sheet", "ui/arrow_east", isoGroup);
|
|
eastArrow.inputEnabled = true;
|
|
eastArrow.events.onInputDown.add(function () {
|
|
if (mar.worldX === mar.maxWidth) {
|
|
mar.worldX = 0;
|
|
} else {
|
|
mar.worldX++;
|
|
}
|
|
mar.client.requestTerrain();
|
|
});
|
|
eastArrow.events.onInputOver.add(function () {
|
|
eastArrow.tint = 0x00ff00;
|
|
document.body.style.cursor = "pointer";
|
|
});
|
|
eastArrow.events.onInputOut.add(function () {
|
|
eastArrow.tint = 0xFFFFFF;
|
|
document.body.style.cursor = "default";
|
|
});
|
|
isoGroup.addChild(eastArrow);
|
|
|
|
var southArrow = game.make.isoSprite(528, 1170, 10, "sheet", "ui/arrow_south", isoGroup);
|
|
southArrow.inputEnabled = true;
|
|
southArrow.events.onInputDown.add(function () {
|
|
if (mar.worldY === mar.maxWidth) {
|
|
mar.worldY = 0;
|
|
} else {
|
|
mar.worldY++;
|
|
}
|
|
mar.client.requestTerrain();
|
|
});
|
|
southArrow.events.onInputOver.add(function () {
|
|
southArrow.tint = 0x00ff00;
|
|
document.body.style.cursor = "pointer";
|
|
});
|
|
southArrow.events.onInputOut.add(function () {
|
|
southArrow.tint = 0xFFFFFF;
|
|
document.body.style.cursor = "default";
|
|
});
|
|
isoGroup.addChild(southArrow);
|
|
|
|
var westArrow = game.make.isoSprite(-60, 587, 10, "sheet", "ui/arrow_west", isoGroup);
|
|
westArrow.inputEnabled = true;
|
|
westArrow.events.onInputDown.add(function () {
|
|
if (mar.worldX === 0) {
|
|
mar.worldX = mar.maxWidth;
|
|
} else {
|
|
mar.worldX--;
|
|
}
|
|
mar.client.requestTerrain();
|
|
});
|
|
westArrow.events.onInputOver.add(function () {
|
|
westArrow.tint = 0x00ff00;
|
|
document.body.style.cursor = "pointer";
|
|
});
|
|
westArrow.events.onInputOut.add(function () {
|
|
westArrow.tint = 0xFFFFFF;
|
|
document.body.style.cursor = "default";
|
|
});
|
|
isoGroup.addChild(westArrow);
|
|
|
|
}
|
|
|
|
function cubotDig(cubot, direction, callback) {
|
|
if (direction === DIR_NORTH) {
|
|
cubot.animations.play("dig_n", 45);
|
|
} else if (direction === DIR_EAST) {
|
|
cubot.animations.play("dig_e", 45);
|
|
} else if (direction === DIR_SOUTH) {
|
|
cubot.animations.play("dig_s", 45);
|
|
} else if (direction === DIR_WEST) {
|
|
cubot.animations.play("dig_w", 45);
|
|
}
|
|
}
|
|
|
|
function cubotMove(cubot, direction, callback, walkFrames, jump) {
|
|
|
|
var tween;
|
|
|
|
if (direction === DIR_SOUTH) {
|
|
|
|
var walk = function (duration) {
|
|
|
|
|
|
if (jump) {
|
|
tween = game.add.tween(cubot).to({isoX: getIsoX(cubot.tileX), isoY: getIsoY(cubot.tileY)},
|
|
duration, Phaser.Easing.Linear.None, true);
|
|
var zTween1 = game.add.tween(cubot).to({isoX: getIsoX(cubot.tileX), isoZ: 90},
|
|
duration / 2, Phaser.Easing.Quadratic.Out, true);
|
|
zTween1.onComplete.add(function () {
|
|
game.add.tween(cubot).to({isoX: getIsoX(cubot.tileX), isoZ: 5},
|
|
duration / 2, Phaser.Easing.Quadratic.In, true);
|
|
})
|
|
} else {
|
|
tween = game.add.tween(cubot).to({isoX: getIsoX(cubot.tileX), isoY: getIsoY(cubot.tileY)},
|
|
duration, Phaser.Easing.Linear.None, true);
|
|
cubot.animations.play("walk_s", 60, true);
|
|
}
|
|
|
|
|
|
dispatchTileEnter(cubot.tileX, cubot.tileY);
|
|
|
|
tween.onComplete.add(function () {
|
|
cubot.animations.stop();
|
|
cubot.animations.frame = walkFrames.south;
|
|
// cubot.tileY++;
|
|
cubot.onTileOut();
|
|
//Resync position
|
|
cubot.isoX = getIsoX(cubot.tileX);
|
|
cubot.isoY = getIsoY(cubot.tileY);
|
|
|
|
if (callback !== undefined) {
|
|
callback();
|
|
}
|
|
|
|
for (var i = 0; i < cubot.queuedAnims.length; i++) {
|
|
cubot.queuedAnims[i](500);
|
|
cubot.queuedAnims.splice(i, 1)
|
|
}
|
|
})
|
|
}
|
|
|
|
} else if (direction === DIR_NORTH) {
|
|
|
|
walk = function (duration) {
|
|
|
|
if (jump) {
|
|
tween = game.add.tween(cubot).to({isoX: getIsoX(cubot.tileX), isoY: getIsoY(cubot.tileY)},
|
|
duration, Phaser.Easing.Linear.None, true);
|
|
var zTween1 = game.add.tween(cubot).to({isoZ: 90},
|
|
duration / 2, Phaser.Easing.Quadratic.Out, true);
|
|
zTween1.onComplete.add(function () {
|
|
game.add.tween(cubot).to({isoZ: 5},
|
|
duration / 2, Phaser.Easing.Quadratic.In, true);
|
|
})
|
|
} else {
|
|
tween = game.add.tween(cubot).to({isoX: getIsoX(cubot.tileX), isoY: getIsoY(cubot.tileY)},
|
|
duration, Phaser.Easing.Linear.None, true);
|
|
cubot.animations.play("walk_n", 60, true);
|
|
}
|
|
dispatchTileEnter(cubot.tileX, cubot.tileY);
|
|
|
|
tween.onComplete.add(function () {
|
|
cubot.animations.stop();
|
|
cubot.animations.frame = walkFrames.north;
|
|
// cubot.tileY--;
|
|
cubot.onTileOut();
|
|
//Resync position
|
|
cubot.isoX = getIsoX(cubot.tileX);
|
|
cubot.isoY = getIsoY(cubot.tileY);
|
|
|
|
if (callback !== undefined) {
|
|
callback();
|
|
}
|
|
|
|
for (var i = 0; i < cubot.queuedAnims.length; i++) {
|
|
cubot.queuedAnims[i](500);
|
|
cubot.queuedAnims.splice(i, 1)
|
|
}
|
|
})
|
|
}
|
|
|
|
} else if (direction === DIR_WEST) {
|
|
walk = function (duration) {
|
|
|
|
|
|
if (jump) {
|
|
tween = game.add.tween(cubot).to({isoX: getIsoX(cubot.tileX), isoY: getIsoY(cubot.tileY)},
|
|
duration, Phaser.Easing.Linear.None, true);
|
|
var zTween1 = game.add.tween(cubot).to({isoZ: 90},
|
|
duration / 2, Phaser.Easing.Quadratic.Out, true);
|
|
zTween1.onComplete.add(function () {
|
|
game.add.tween(cubot).to({isoZ: 5},
|
|
duration / 2, Phaser.Easing.Quadratic.In, true);
|
|
})
|
|
} else {
|
|
tween = game.add.tween(cubot).to({isoX: getIsoX(cubot.tileX), isoY: getIsoY(cubot.tileY)},
|
|
duration, Phaser.Easing.Linear.None, true);
|
|
cubot.animations.play("walk_w", 60, true);
|
|
}
|
|
|
|
dispatchTileEnter(cubot.tileX, cubot.tileY);
|
|
|
|
|
|
tween.onComplete.add(function () {
|
|
cubot.animations.stop();
|
|
cubot.animations.frame = walkFrames.west;
|
|
// cubot.tileX--;
|
|
cubot.onTileOut();
|
|
//Resync position
|
|
cubot.isoX = getIsoX(cubot.tileX);
|
|
cubot.isoY = getIsoY(cubot.tileY);
|
|
|
|
if (callback !== undefined) {
|
|
callback();
|
|
}
|
|
|
|
for (var i = 0; i < cubot.queuedAnims.length; i++) {
|
|
cubot.queuedAnims[i](500);
|
|
cubot.queuedAnims.splice(i, 1)
|
|
}
|
|
})
|
|
}
|
|
|
|
} else if (direction === DIR_EAST) {
|
|
walk = function (duration) {
|
|
|
|
if (jump) {
|
|
tween = game.add.tween(cubot).to({isoX: getIsoX(cubot.tileX), isoY: getIsoY(cubot.tileY)},
|
|
duration, Phaser.Easing.Linear.None, true);
|
|
var zTween1 = game.add.tween(cubot).to({isoZ: 90},
|
|
duration / 2, Phaser.Easing.Quadratic.Out, true);
|
|
zTween1.onComplete.add(function () {
|
|
game.add.tween(cubot).to({isoZ: 5},
|
|
duration / 2, Phaser.Easing.Quadratic.In, true);
|
|
})
|
|
} else {
|
|
tween = game.add.tween(cubot).to({isoX: getIsoX(cubot.tileX), isoY: getIsoY(cubot.tileY)},
|
|
duration, Phaser.Easing.Linear.None, true);
|
|
cubot.animations.play("walk_e", 60, true);
|
|
}
|
|
|
|
dispatchTileEnter(cubot.tileX, cubot.tileY);
|
|
|
|
|
|
tween.onComplete.add(function () {
|
|
cubot.animations.stop();
|
|
cubot.animations.frame = walkFrames.east;
|
|
// cubot.tileX++;
|
|
|
|
cubot.onTileOut();
|
|
//Resync position
|
|
cubot.isoX = getIsoX(cubot.tileX);
|
|
cubot.isoY = getIsoY(cubot.tileY);
|
|
|
|
if (callback !== undefined) {
|
|
callback();
|
|
}
|
|
|
|
for (var i = 0; i < cubot.queuedAnims.length; i++) {
|
|
cubot.queuedAnims[i](500);
|
|
cubot.queuedAnims.splice(i, 1)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
if (cubot.animations.currentAnim.isPlaying) {
|
|
//Queue up the animation
|
|
cubot.queuedAnims.push(walk);
|
|
|
|
console.log("Queued Animation");
|
|
|
|
} else {
|
|
walk(800);
|
|
}
|
|
}
|
|
|
|
|
|
function initialiseAnimations() {
|
|
//Walk =-------------------------------------------------------
|
|
//East
|
|
mar.animationFrames.walk_e_start = [];
|
|
for (var i = 0; i < 10; i++) {
|
|
mar.animationFrames.walk_e_start.push("cubot/walk_e/" + ("0000" + i).slice(-4));
|
|
}
|
|
mar.animationFrames.walk_e = [];
|
|
for (i = 10; i < 30; i++) {
|
|
mar.animationFrames.walk_e.push("cubot/walk_e/" + ("0000" + i).slice(-4));
|
|
}
|
|
|
|
mar.animationFrames.harvester_walk_e_start = [];
|
|
for (var i = 0; i < 10; i++) {
|
|
mar.animationFrames.harvester_walk_e_start.push("harvester/walk_e/" + ("0000" + i).slice(-4));
|
|
}
|
|
mar.animationFrames.harvester_walk_e = [];
|
|
for (i = 10; i < 30; i++) {
|
|
mar.animationFrames.harvester_walk_e.push("harvester/walk_e/" + ("0000" + i).slice(-4));
|
|
}
|
|
//North
|
|
mar.animationFrames.walk_n_start = [];
|
|
for (i = 0; i < 10; i++) {
|
|
mar.animationFrames.walk_n_start.push("cubot/walk_n/" + ("0000" + i).slice(-4));
|
|
}
|
|
mar.animationFrames.walk_n = [];
|
|
for (i = 10; i < 30; i++) {
|
|
mar.animationFrames.walk_n.push("cubot/walk_n/" + ("0000" + i).slice(-4));
|
|
}
|
|
|
|
mar.animationFrames.harvester_walk_n_start = [];
|
|
for (i = 0; i < 10; i++) {
|
|
mar.animationFrames.harvester_walk_n_start.push("harvester/walk_n/" + ("0000" + i).slice(-4));
|
|
}
|
|
mar.animationFrames.harvester_walk_n = [];
|
|
for (i = 10; i < 30; i++) {
|
|
mar.animationFrames.harvester_walk_n.push("harvester/walk_n/" + ("0000" + i).slice(-4));
|
|
}
|
|
//South
|
|
mar.animationFrames.walk_s_start = [];
|
|
for (i = 0; i < 10; i++) {
|
|
mar.animationFrames.walk_s_start.push("cubot/walk_s/" + ("0000" + i).slice(-4));
|
|
}
|
|
mar.animationFrames.walk_s = [];
|
|
for (i = 10; i < 30; i++) {
|
|
mar.animationFrames.walk_s.push("cubot/walk_s/" + ("0000" + i).slice(-4));
|
|
}
|
|
|
|
mar.animationFrames.harvester_walk_s_start = [];
|
|
for (i = 0; i < 10; i++) {
|
|
mar.animationFrames.harvester_walk_s_start.push("harvester/walk_s/" + ("0000" + i).slice(-4));
|
|
}
|
|
mar.animationFrames.harvester_walk_s = [];
|
|
for (i = 10; i < 30; i++) {
|
|
mar.animationFrames.harvester_walk_s.push("harvester/walk_s/" + ("0000" + i).slice(-4));
|
|
}
|
|
//West
|
|
mar.animationFrames.walk_w_start = [];
|
|
for (i = 0; i < 10; i++) {
|
|
mar.animationFrames.walk_w_start.push("cubot/walk_w/" + ("0000" + i).slice(-4));
|
|
}
|
|
mar.animationFrames.walk_w = [];
|
|
for (i = 10; i < 30; i++) {
|
|
mar.animationFrames.walk_w.push("cubot/walk_w/" + ("0000" + i).slice(-4));
|
|
}
|
|
|
|
mar.animationFrames.harvester_walk_w_start = [];
|
|
for (i = 0; i < 10; i++) {
|
|
mar.animationFrames.harvester_walk_w_start.push("harvester/walk_w/" + ("0000" + i).slice(-4));
|
|
}
|
|
mar.animationFrames.harvester_walk_w = [];
|
|
for (i = 10; i < 30; i++) {
|
|
mar.animationFrames.harvester_walk_w.push("harvester/walk_w/" + ("0000" + i).slice(-4));
|
|
}
|
|
|
|
//Dig =-------------------------------------------------------
|
|
mar.animationFrames.dig_e = [];
|
|
for (i = 1; i <= 41; i++) {
|
|
mar.animationFrames.dig_e.push("cubot/dig_e/" + ("0000" + i).slice(-4));
|
|
}
|
|
mar.animationFrames.dig_n = [];
|
|
for (i = 1; i <= 41; i++) {
|
|
mar.animationFrames.dig_n.push("cubot/dig_n/" + ("0000" + i).slice(-4));
|
|
}
|
|
mar.animationFrames.dig_s = [];
|
|
for (i = 1; i <= 41; i++) {
|
|
mar.animationFrames.dig_s.push("cubot/dig_s/" + ("0000" + i).slice(-4));
|
|
}
|
|
mar.animationFrames.dig_w = [];
|
|
for (i = 1; i <= 41; i++) {
|
|
mar.animationFrames.dig_w.push("cubot/dig_w/" + ("0000" + i).slice(-4));
|
|
}
|
|
|
|
//Biomass =-------------------------------------------------------
|
|
mar.animationFrames.biomassIdle = [];
|
|
for (i = 1; i < 60; i++) {
|
|
mar.animationFrames.biomassIdle.push("objects/biomass/idle/" + ("0000" + i).slice(-4));
|
|
}
|
|
}
|
|
|
|
function getIsoX(tileX) {
|
|
return (tileX * 71.5)
|
|
}
|
|
|
|
function getIsoY(tileY) {
|
|
return (tileY * 71.5)
|
|
}
|
|
|
|
function findMyRobot() {
|
|
|
|
if (mar.client.username === "guest") {
|
|
alert("You are not logged in!");
|
|
} else {
|
|
mar.client.requestUserInfo()
|
|
}
|
|
|
|
}
|
|
|
|
function formattedKeyBuffer(kbBuffer) {
|
|
|
|
var str = "KB: ";
|
|
|
|
for (var i = 0; i < 16; i++) {
|
|
|
|
if (kbBuffer[i] !== undefined) {
|
|
|
|
str += kbBuffer[i].toString(16) + " ";
|
|
|
|
} else {
|
|
|
|
str += "__ ";
|
|
}
|
|
|
|
}
|
|
|
|
return str;
|
|
}
|
|
|
|
|
|
|
|
game.state.add('Boot', BasicGame.Boot);
|
|
|
|
game.state.start('Boot');
|