dragonblocks.entities[this.name] = this;
dragonblocks.registeredEntities.push(this);
}
-
- spawn(x, y)
- {
- return new dragonblocks.SpawnedEntity(this, x, y);
- }
};
dragonblocks.entities = {};
dragonblocks.registerEntity = def => {
new dragonblocks.Entity(def);
};
-
-dragonblocks.spawnEntity = (name, x, y) => {
- let def = dragonblocks.entities[name];
-
- if (def)
- return def.spawn(x, y);
-};
height: 1,
texture: this.texture,
oncollide: self => {
- let under = dragonblocks.getNode(Math.floor(self.x), Math.floor(self.y) + 1);
+ let under = self.map.getNode(Math.floor(self.x), Math.floor(self.y) + 1);
if (! under || under.mobstable) {
- dragonblocks.setNode(Math.floor(self.x), Math.floor(self.y), self.meta.nodeName);
+ self.map.setNode(Math.floor(self.x), Math.floor(self.y), self.meta.nodeName);
self.despawn();
}
}
});
-dragonblocks.registerOnActivateNode((x, y) => {
- let node = dragonblocks.getNode(x, y);
+dragonblocks.registerOnActivate((map, x, y) => {
+ let node = map.getNode(x, y);
if (! node.toNode().physics)
return;
- let under = dragonblocks.getNode(x, y + 1);
+ let under = map.getNode(x, y + 1);
if (under && ! under.mobstable)
- dragonblocks.spawnFallingNode(node.name, x, y)
+ dragonblocks.spawnFallingNode(node.name, map, x, y)
});
-dragonblocks.spawnFallingNode = (nodename, x, y) => {
+dragonblocks.spawnFallingNode = (nodename, map, x, y) => {
setTimeout(_ => {
- dragonblocks.map.activate(x, y);
+ map.activate(x, y);
}, 50);
- dragonblocks.setNode(x, y, "air");
+ map.setNode(x, y, "air");
- let entity = dragonblocks.spawnEntity("dragonblocks:falling_node", x, y);
+ let entity = map.spawnEntity("dragonblocks:falling_node", x, y);
entity.meta.nodeName = nodename;
entity.texture = dragonblocks.nodes[nodename].texture;
entity.updateTexture();
loadingMods[modname] = false;
};
- dragonblocks.start = selectedMods => {
+ dragonblocks.loadMods = selectedMods = _ => {
+ dragonblocks.loadedMods = {};
+
+ for (let mod in selectedMods)
+ if (selectedMods[mod])
+ loadMod(mod);
+
+ for (let mod in dragonblocks.gamemods)
+ loadMod(mod);
+ };
+
+ dragonblocks.start = worldProperties => {
dragonblocks.log("Starting");
for (let func of dragonblocks.onStartCallbacks)
func();
setTimeout(_ => {
- dragonblocks.loadedMods = {};
-
- for (let mod in selectedMods)
- if (selectedMods[mods])
- loadMod(mod);
-
- for (let mod in dragonblocks.gamemods)
- loadMod(mod);
-
- dragonblocks.map = new dragonblocks.Map();
- dragonblocks.map.load();
-
- dragonblocks.player = new dragonblocks.Player();
-
- dragonblocks.worldIsLoaded || dragonblocks.generateMap();
+ dragonblocks.world = new dragonblocks.World(worldProperties);
+ dragonblocks.player = dragonblocks.world.player;
for (let func of dragonblocks.onStartedCallbacks)
func();
if (dragonblocks.loggedin)
setTimeout(_ => {
- dragonblocks.save();
+ dragonblocks.player.despawn();
+ dragonblocks.world.save();
location.reload();
});
else
new dragonblocks.Item(def);
};
-dragonblocks.onUseItemCallbacks = [];
-dragonblocks.registerOnUseItem = func => {
- dragonblocks.onUseItemCallbacks.push(func);
-};
-
dragonblocks.itemMatch = (item1, item2) => {
item1 = dragonblocks.items[item1] || dragonblocks.groups[item1] || item1;
item2 = dragonblocks.items[item2] || dragonblocks.groups[item2] || item2;
gravity: true,
verticalSpeed: 2,
onpunch: self => {
- dragonblocks.dropItem(dragonblocks.player.give(self.meta.itemstring), self.x, self.y);
+ dragonblocks.dropItem(dragonblocks.player.give(self.meta.itemstring), self.map, self.x, self.y);
self.despawn();
},
oncollide: self => {
},
});
-dragonblocks.dropItem = (itemstack, x, y) => {
+dragonblocks.dropItem = (itemstack, map, x, y) => {
if (! itemstack || ! itemstack.item || ! itemstack.count)
return;
- let entity = dragonblocks.spawnEntity("dragonblocks:item_entity", x, y);
+ let entity = map.spawnEntity("dragonblocks:item_entity", x, y);
entity.meta.itemstring = itemstack.serialize();
entity.texture = itemstack.toItem().texture;
entity.updateTexture();
splash.style.color = "yellow";
splash.style.fontSize = "30px";
- let splashes = $.getJSON("splashes.json").responseJSON;
-
let status = center.appendChild(document.createElement("h1"));
status.style.fontSize = "50px";
status.style.display = "none";
elem.remove();
};
+ let worlds;
+
// Load World Button
{
let loadWorldGUI, worldlistDisplay, noWorldsNotice;
+ let worldProperties = new dragonblocks.World.Properties(true);
+
if (dragonblocks.loggedin) {
onReload.push(_ => {
if (loadWorldGUI) {
worldlistDisplay = loadWorldGUI.create("ul");
}
- noWorldsNotice.innerHTML = dragonblocks.worlds.length == 0 ? "No Worlds" : "";
+ noWorldsNotice.innerHTML = worlds.length == 0 ? "No Worlds" : "";
- for (let worldname in dragonblocks.worlds) {
- let world = dragonblocks.worlds[worldname];
+ for (let worldname in worlds) {
+ let world = worlds[worldname];
if (world.owned) {
let worldDisplay = worldlistDisplay.appendChild(document.createElement("li"));
event.srcElement.blur();
loadWorldGUI.close();
- dragonblocks.worldIsLoaded = true;
- dragonblocks.worldname = world.name;
- dragonblocks.world = $.getJSON("worlds/" + worldname + "/world.json").responseJSON;
-
- dragonblocks.mods = dragonblocks.world.mods;
-
- dragonblocks.start();
+ worldProperties.name = world.name;
+ dragonblocks.start(worldProperties);
});
}
}
let createWorldGUI = new dragonblocks.gui.Box();
let createButton;
- let worldProperties = {};
+ let worldProperties = new dragonblocks.World.Properties(false);
let headline = createWorldGUI.create("h1");
headline.innerHTML = "New World";
worldnameAlert.style.left = "50px";
worldnameInput.addEventListener("input", _ => {
- let worldname = worldnameInput.value;
+ worldProperties.name = worldnameInput.value;
- if(! dragonblocks.loggedin) {
+ if (! dragonblocks.loggedin) {
worldnameAlert.textContent = "Warning: You are not logged in and cannot save worlds.";
worldnameAlert.style.color = "#FF7D00";
createButton.disabled = false;
- } else if (worldname == "") {
+ } else if (worldProperties.name == "") {
worldnameAlert.textContent = "";
createButton.disabled = true;
- } else if (! dragonblocks.checkWorldnameSpelling(worldname)) {
+ } else if (! worldProperties.checkSpelling()) {
worldnameAlert.textContent = "The world name contains forbidden characters";
worldnameAlert.style.color = "#FF001F";
createButton.disabled = true;
- } else if (dragonblocks.worlds[worldname]) {
- if (dragonblocks.worlds[worldname].owned) {
+ } else if (worlds[worldProperties.name]) {
+ if (worlds[worldProperties.name].owned) {
worldnameAlert.textContent = "Warning: This will overwrite an existing world";
worldnameAlert.style.color = "#FF7D00";
createButton.disabled = false;
worldnameAlert.textContent = "";
createButton.disabled = false;
}
-
- worldProperties.worldname = worldname;
});
// Mods
- worldProperties.mods = {};
-
createWorldGUI.create("h2").innerHTML = " Mods";
let modlistDisplay;
};
// Gamemode
- worldProperties.gamemode = "survival";
-
createWorldGUI.create("h2").innerHTML = " Gamemode";
for (let gamemode of ["survival", "creative"]){
let selectMapgen = createWorldGUI.create("select");
selectMapgen.style.position = "relative";
selectMapgen.style.left = "40px";
+ selectMapgen.value = worldProperties.mapgen;
selectMapgen.addEventListener("input", _ => {
worldProperties.mapgen = selectMapgen.value;
for (let mapgen in dragonblocks.mapgen.list)
selectMapgen.appendChild(document.createElement("option")).innerHTML = mapgen;
- worldProperties.mapgen = selectMapgen.value;
-
createWorldGUI.create("br");
createWorldGUI.create("br");
event.srcElement.blur();
createWorldGUI.close();
- dragonblocks.worldIsLoaded = false;
- dragonblocks.worldname = worldProperties.worldname;
- dragonblocks.world = dragonblocks.getEmptyWorld();
-
- dragonblocks.entities["dragonblocks:player"].meta.creative = (worldProperties.gamemode == "creative");
-
- dragonblocks.mapgen.selected = worldProperties.mapgen;
-
- dragonblocks.start(worldProperties.mods);
+ dragonblocks.start(worldProperties);
});
createWorldGUI.create("br");
text: "Quit",
action: _ => {
if (dragonblocks.isChromeApp)
- window.close();
+ close();
else
history.back();
},
dragonblocks.enterMainMenu = _ => {
dragonblocks.loadModList();
- dragonblocks.loadWorldList();
+ worlds = dragonblocks.backendCall("getWorlds");
content.style.display = "inherit";
status.style.display = "none";
content.style.width = logo.offsetWidth + "px";
mainmenu.style.visibility = "visible";
+ let splashes = $.getJSON("splashes.json").responseJSON;
+
splash.innerHTML = splashes[Math.floor(Math.random() * splashes.length)];
let fontSize = Math.min(parseInt(10000 / splash.clientWidth), 30);
splash.style.fontSize = fontSize + "px";
dragonblocks.Map = class
{
- constructor()
+ constructor(data)
{
- dblib.copy(this, dragonblocks.world.map);
- this.data = this.data || this.content;
- delete this.content;
+ if (data)
+ this.deserialize(data);
+ else
+ this.clear();
+
+ this.initGraphics();
+ this.updateGraphics();
+ }
+
+ serialize()
+ {
+ return {
+ data: this.data,
+ width: this.width,
+ height: this.height,
+ displayLeft: this.displayLeft,
+ displayTop: this.displayTop,
+ structures: this.structures,
+ entities: dblib.removeTmp(this.entities),
+ };
}
- load()
+ deserialize(data)
{
- for (let x = 0; x < this.width; x++)
+ this.data = [];
+ this.width = data.width;
+ this.height = data.height;
+ this.displayLeft = data.displayLeft;
+ this.displayTop = data.displayTop;
+ this.entities = [];
+ this.structures = data.structures;
+
+ for (let x = 0; x < this.width; x++) {
+ this.data[x] = [];
for (let y = 0; y < this.height; y++)
- this.setNode(x, y, new dragonblocks.MapNode().createFromMapNode(this.data[x][y]));
+ this.setNode(x, y, new dragonblocks.MapNode().createFromMapNode(data.data[x][y]));
+ }
- this.initGraphics();
+ for (let entity of data.entities)
+ new dragonblocks.SpawnedEntity(entity);
+ }
+
+ clear()
+ {
+ this.data = [];
+ this.width = dragonblocks.settings.map.width;
+ this.height = dragonblocks.settings.map.height;
+ this.displayTop = dragonblocks.settings.map.height / 2;
+ this.displayLeft = dragonblocks.settings.map.width / 2 - 5;
+ this.entities = [];
+ this.structures = {};
+
+ for (let x = 0; x < this.width; x++) {
+ this.data[x] = [];
+ for (let y = 0; y < this.height; y++)
+ this.setNode(x, y, new dragonblocks.MapNode("air"));
+ }
+ }
+
+ withinBounds(x, y)
+ {
+ return x < this.width && y < this.height && x >= 0 && y >= 0;
+ }
+
+ getNode(x, y)
+ {
+ if (this.withinBounds(x, y))
+ return this.data[x][y];
}
setNode(x, y, node)
{
+ node = new dragonblocks.MapNode(node);
+
if (this.withinBounds(x, y)) {
let oldNode = this.data[x][y];
let oldNodeDef = oldNode instanceof dragonblocks.MapNode && oldNode.toNode();
- oldNodeDef && oldNodeDef.onremove && oldNodeDef.onremove(x, y);
-
- for (let func of dragonblocks.onRemoveNodeCallbacks)
- func(x, y);
+ oldNodeDef && oldNodeDef.onremove && oldNodeDef.onremove(this, x, y);
this.data[x][y] = node;
let nodeDef = node.toNode();
- nodeDef.onset && nodeDef.onset(x, y);
-
- for (let func of dragonblocks.onSetNodeCallbacks)
- func(x, y);
+ nodeDef.onset && nodeDef.onset(this, x, y);
this.updateNodeGraphics(x, y);
}
continue;
let nodeDef = node.toNode();
- nodeDef.onactivate && nodeDef.onactivate(ix, iy);
+ nodeDef.onactivate && nodeDef.onactivate(this, ix, iy);
- for(let func of dragonblocks.onActivateNodeCallbacks)
- func(ix, iy);
+ for (let func of dragonblocks.onActivateCallbacks)
+ func(this, ix, iy);
}
}
}
- getNode(x, y)
- {
- if (this.withinBounds(x, y))
- return this.data[x][y];
- }
-
- withinBounds(x, y)
- {
- return x < this.width && y < this.height && x >= 0 && y >= 0;
- }
-
getNodeDisplay(x, y)
{
return document.getElementById("dragonblocks.map.node[" + (x - this.displayLeft) + "][" + (y - this.displayTop) + "]");
}
}
}
-};
-dragonblocks.setNode = (x, y, node) => {
- dragonblocks.map.setNode(x, y, new dragonblocks.MapNode(node));
+ addStructure(name, msg, pos)
+ {
+ this.structures[name] = this.structures[name] || [];
+ this.structures[name].push({msg, pos});
+ }
+
+ spawnEntity(name, x, y)
+ {
+ let def = dragonblocks.entities[name];
+
+ if (def)
+ return new dragonblocks.SpawnedEntity(def, this, x, y);
+ }
+
};
-dragonblocks.getNode = (x, y) => {
- return dragonblocks.map.getNode(x, y);
+dragonblocks.onActivateCallbacks = [];
+dragonblocks.registerOnActivate = func => {
+ dragonblocks.onActivateCallbacks.push(func);
};
dragonblocks.registerOnStarted(_ => {
crack.addEventListener("mouseleave", event => {
self.digStop();
- let [x, y] = dragonblocks.map.getScreenCoordinates(event.srcElement.offsetLeft, event.srcElement.offsetTop);
- dragonblocks.map.getNodeDisplay(x, y).style.boxShadow = "none";
+ let [x, y] = self.map.getScreenCoordinates(event.srcElement.offsetLeft, event.srcElement.offsetTop);
+ self.map.getNodeDisplay(x, y).style.boxShadow = "none";
});
crack.addEventListener("mouseover", event => {
- let [x, y] = dragonblocks.map.getScreenCoordinates(event.srcElement.offsetLeft + document.getElementById("dragonblocks.map").offsetLeft, event.srcElement.offsetTop + document.getElementById("dragonblocks.map").offsetTop);
- dragonblocks.map.getNodeDisplay(x, y).style.boxShadow = "0 0 0 1px black inset";
+ let [x, y] = self.map.getScreenCoordinates(event.srcElement.offsetLeft + document.getElementById("dragonblocks.map").offsetLeft, event.srcElement.offsetTop + document.getElementById("dragonblocks.map").offsetTop);
+ self.map.getNodeDisplay(x, y).style.boxShadow = "0 0 0 1px black inset";
});
},
- dig(x, y)
+ dig(map, x, y)
{
- let node = dragonblocks.getNode(x, y);
+ console.log(this);
+ let node = map.getNode(x, y);
if (! node)
return false;
let nodeDef = node.toNode();
- if (nodeDef.ondig && nodeDef.ondig(x, y) == false)
+ if (nodeDef.ondig && nodeDef.ondig(map, x, y) == false)
return false;
- for (let func of dragonblocks.onDigNodeCallbacks)
- if (func(x, y) == false)
- return false;
-
nodeDef.playSound("dug");
- dragonblocks.setNode(x, y, "air");
- dragonblocks.map.activate(x, y);
+ map.setNode(x, y, "air");
+ map.activate(map, x, y);
return true;
},
digStart(x, y)
{
- let node = dragonblocks.getNode(x, y);
+ let node = this.map.getNode(x, y);
let nodeDef = node.toNode();
node.meta.hardness = nodeDef.hardness;
let crack = document.getElementById("dragonblocks.crack[" + this.id + "]")
crack.style.visibility = "visible";
- crack.style.left = (x - dragonblocks.map.displayLeft) * dragonblocks.settings.map.scale + "px";
- crack.style.top = (y - dragonblocks.map.displayTop) * dragonblocks.settings.map.scale + "px";
+ crack.style.left = (x - this.map.displayLeft) * dragonblocks.settings.map.scale + "px";
+ crack.style.top = (y - this.map.displayTop) * dragonblocks.settings.map.scale + "px";
dragonblocks.log("Punched Node at (" + x + ", " + y + ")");
- nodeDef.onpunch && nodeDef.onpunch(x,y);
-
- for (let func of dragonblocks.onPunchNodeCallbacks)
- func(x, y);
+ nodeDef.onpunch && nodeDef.onpunch(this.map, x,y);
- dragonblocks.map.activate(x, y);
+ this.map.activate(x, y);
this.digTick(x, y);
},
{
let self = this;
- let node = dragonblocks.getNode(x, y);
+ let node = this.map.getNode(x, y);
if (! node)
return;
digEnd(x, y)
{
- let node = dragonblocks.getNode(x, y);
+ let node = this.map.getNode(x, y);
if (! node)
return;
let nodeDef = node.toNode();
- if (this.dig(x, y))
- dragonblocks.handleNodeDrop(this.tmp.mainInventory, nodeDef, x, y);
+ if (this.dig(this.map, x, y))
+ dragonblocks.handleNodeDrop(this.tmp.mainInventory, nodeDef, this.map, x, y);
document.getElementById("dragonblocks.crack[" + this.id + "]").style.visibility = "hidden";
},
document.getElementById("dragonblocks.crack[" + this.id + "]").style.visibility = "hidden";
},
- place(x, y, node)
+ place(map, x, y, node)
{
- let oldNode = dragonblocks.getNode(x, y);
+ let oldNode = this.map.getNode(x, y);
if (! oldNode || oldNode.stable)
return false;
- if (node.onplace && node.onplace(x, y) == false)
+ if (node.onplace && node.onplace(map, x, y) == false)
return false;
- for (let func of dragonblocks.onPlaceNodeCallbacks)
- if (func(node, x, y) == false)
- return false;
-
- dragonblocks.setNode(x, y, node);
- dragonblocks.map.activate(x, y);
+ map.setNode(x, y, node);
+ map.activate(x, y);
node.playSound("place");
build(x, y)
{
if(this.canReach(x, y)) {
- let oldNodeDef = dragonblocks.getNode(x, y).toNode();
- oldNodeDef.onclick && oldNodeDef.onclick(x, y);
+ let oldNodeDef = this.map.getNode(x, y).toNode();
+ oldNodeDef.onclick && oldNodeDef.onclick(this.map, x, y);
- for (let func of dragonblocks.onClickNodeCallbacks)
- func(x, y);
-
- if (this.touch(x, y))
+ if (this.touch(this.map, x, y))
return;
let wielded = this.getWieldedItem();
let itemDef = itemstack.toItem();
if (itemDef instanceof dragonblocks.Node) {
- if (! this.place(x, y, itemDef) || this.meta.creative)
+ if (! this.place(this.map, x, y, itemDef) || this.meta.creative)
wielded.add(itemstack);
} else {
- if (! itemDef.onuse || ! itemDef.onuse(x, y)) {
+ if (! itemDef.onuse || ! itemDef.onuse(this.map, x, y))
+ wielded.add(itemstack);
+ else if (this.meta.creative)
wielded.add(itemstack);
- } else {
- for (let func of dragonblocks.onUseItemCallbacks)
- func(itemDef, x, y);
-
- if (this.meta.creative)
- wielded.add(itemstack);
- }
}
}
},
}
};
-dragonblocks.handleNodeDrop = (inventory, nodeDef, x, y) => {
- dragonblocks.dropItem(inventory.add((nodeDef.drops instanceof Function) ? nodeDef.drops() : nodeDef.drops), x + 0.2, y + 0.2);
+dragonblocks.handleNodeDrop = (inventory, nodeDef, map, x, y) => {
+ dragonblocks.dropItem(inventory.add((nodeDef.drops instanceof Function) ? nodeDef.drops() : nodeDef.drops), map, x + 0.2, y + 0.2);
};
dragonblocks.mapgen = {};
-dragonblocks.mapgen.addStructure = (name, msg, pos) => {
- let strs = dragonblocks.world.structures;
- strs[name] = strs[name] || [];
- strs[name].push({msg: msg, pos: pos});
-};
-
dragonblocks.mapgen.biomes = [];
dragonblocks.registerBiome = obj => {
dragonblocks.mapgen.biomes.push(obj);
dragonblocks.mapgen.ores.push(obj);
};
-dragonblocks.mapgen.selected = "empty";
dragonblocks.mapgen.list = {};
-dragonblocks.generateMap = _ => {
- dragonblocks.mapgen.list[dragonblocks.mapgen.selected]();
+dragonblocks.mapgen.generate = (mapgenName, map) => {
+ dragonblocks.mapgen.list[mapgenName](map);
};
-dragonblocks.mapgen.list["v3"] = _ => {
+dragonblocks.mapgen.list["v3"] = map => {
// Localize variables
-
let int = parseInt;
-
- let snode = dragonblocks.setNode;
- let gnode = dragonblocks.getNode;
-
let schem = dragonblocks.Schematic;
-
let rand = dblib.random;
-
- let height = dragonblocks.map.height;
- let width = dragonblocks.map.width;
+ let height = map.height;
+ let width = map.width;
// Biomes
let border = Math.min(d + rand(biomeList[i].size[0], biomeList[i].size[1]), width);
- dragonblocks.mapgen.addStructure(biomeList[i].name, "(" + d + " - " + border + ", *)", {x: int((d + border)/2), y: 5});
+ map.addStructure(biomeList[i].name, "(" + d + " - " + border + ", *)", {x: int((d + border)/2), y: 5});
for(; d < border; d++)
biomes.push(i);
let gx = int((start + end) / 2);
let gy = ground[gx] - 3;
- dragonblocks.mapgen.addStructure(level.name, "(" + start + " - " + end + ", *)", {x: gx, y: gy});
+ map.addStructure(level.name, "(" + start + " - " + end + ", *)", {x: gx, y: gy});
structAdded = true;
}
if (! ground[x] || y < ground[x] || (y / height * 100 - 50) < ore.deep)
return false;
- snode(x, y, ore.name);
+ map.setNode(x, y, ore.name);
return true;
};
let biome = biomeList[biomes[x]];
for (; y < g + 1; y++)
- snode(x, y, biome.surface);
+ map.setNode(x, y, biome.surface);
for (; y < g + 5; y++)
- snode(x, y, biome.ground);
+ map.setNode(x, y, biome.ground);
for (; y < height; y++) {
- snode(x, y, biome.underground);
+ map.setNode(x, y, biome.underground);
for (let ore of dragonblocks.mapgen.ores) {
if (dblib.random(0, ore.factor) == 0) {
if (setOre(x, y, ore))
- dragonblocks.mapgen.addStructure(ore.name, "(" + x + ", " + y + ")", {x: x, y: y});
+ map.addStructure(ore.name, "(" + x + ", " + y + ")", {x, y});
for (let i = 0; i < ore.clustersize; i++)
setOre(x + dblib.random(-2, 2), y + dblib.random(-2, 2), ore);
start = start || x;
water[x] = true;
- snode(x, top, biome.watertop);
+ map.setNode(x, top, biome.watertop);
let y = top + 1;
for(; y < ground[x]; y++)
- snode(x, y, biome.water);
+ map.setNode(x, y, biome.water);
for(; y < ground[x] + 5; y++)
- snode(x, y, biome.floor);
+ map.setNode(x, y, biome.floor);
} else if (start) {
let end = x - 1;
- dragonblocks.mapgen.addStructure("water", "(" + start + " - " + end + ", " + top + ")", {x: int((start + end) / 2), y: top});
+ map.addStructure("water", "(" + start + " - " + end + ", " + top + ")", {x: int((start + end) / 2), y: top});
start = 0;
}
}
if (start) {
let end = width;
- dragonblocks.mapgen.addStructure("water", "(" + start + " - " + end + ", " + top + ")", {x: int((start + end) / 2), y: top});
+ map.addStructure("water", "(" + start + " - " + end + ", " + top + ")", {x: int((start + end) / 2), y: top});
}
}
for (let tree of biome.trees) {
if (Math.random() <= tree.chance) {
- snode(x, g - 1, tree.sapling);
- gnode(x, g - 1) && dragonblocks.finishTimer("growTimer", gnode(x, g - 1).meta);
+ map.setNode(x, g - 1, tree.sapling);
+ map.getNode(x, g - 1) && dragonblocks.finishTimer("growTimer", map.getNode(x, g - 1).meta);
nextTree = x + tree.width;
break;
}
// Ressource Blobs (e.g. Gravel, Dirt)
{
- let belowGround = (node, x, y) => {
- return y > ground[x]
+ let belowGround = (node, map, x, y) => {
+ return y > ground[x];
};
- function structure(x, y, mat) {
+ let structure = (x, y, mat) => {
new schem([["§" + mat, mat], [mat, mat]])
.addFunction(belowGround)
- .apply(x, y);
+ .apply(map, x, y);
let sides = [
new schem([[mat, mat], ["§", ""]]),
for (let i in sides) {
if (Math.random() * 1.2 < 1){
- sides[i].apply(x, y);
+ sides[i].apply(map, x, y);
for (let j = i; j <= int(i) + 1; j++){
let corner = corners[j] || corners[0];
if (Math.random() * 1.5 < 1)
- corner.apply(x, y);
+ corner.apply(map, x, y);
}
if (Math.random() * 2 < 1)
- moresides[i].apply(x, y);
+ moresides[i].apply(map, x, y);
}
}
- }
+ };
for (let material of dragonblocks.mapgen.materials)
for (let i = 0; i < width / material.factor; i++)
// Caves
{
- let cave = (x, y, r) => {
+ let cave = (map, x, y, r) => {
r *= 2;
let caveschem = new schem([
["", "air", "air", "air", ""],
]);
- caveschem.addFunction((node, x, y) => {
+ caveschem.addFunction((node, map, x, y) => {
if (y < ground[x])
return false;
if (dblib.random(0, r) == 0)
- cave(x, y, r);
+ cave(map, x, y, r);
});
- caveschem.apply(x, y);
+ caveschem.apply(map, x, y);
};
- let newCave = (x, y) => {
+ let newCave = (map, x, y) => {
let r = dblib.random(0, 10) + 1;
if (y < ground[x] + 10)
return false;
- cave(x, y, r);
+ cave(map, x, y, r);
- dragonblocks.mapgen.addStructure("cave", "(" + x + ", " + y + ")", {x: x, y: y});
+ map.addStructure("cave", "(" + x + ", " + y + ")", {x, y});
};
let r = dblib.random(width / 5, width / 15);
for (let i = 0; i < r; i++)
- newCave(rand(0, width), rand(0, height));
+ newCave(map, rand(0, width), rand(0, height));
}
};
-dragonblocks.mapgen.list["flat"] = _ => {
- for (let x = 0; x < dragonblocks.map.width; x++) {
+dragonblocks.mapgen.list["flat"] = map => {
+ for (let x = 0; x < map.width; x++) {
let y = 0;
- for(; y < dragonblocks.map.height - 5; y++)
- dragonblocks.setNode(x, y, "air");
+ for(; y < map.height - 5; y++)
+ map.setNode(x, y, "air");
- for(; y < dragonblocks.map.height - 4; y++)
- dragonblocks.setNode(x, y, "dirt:grass");
+ for(; y < map.height - 4; y++)
+ map.setNode(x, y, "dirt:grass");
- for(; y < dragonblocks.map.height - 3; y++)
- dragonblocks.setNode(x, y, "dirt:dirt");
+ for(; y < map.height - 3; y++)
+ map.setNode(x, y, "dirt:dirt");
- for(; y < dragonblocks.map.height; y++)
- dragonblocks.setNode(x, y, "core:stone");
+ for(; y < map.height; y++)
+ map.setNode(x, y, "core:stone");
}
};
-dragonblocks.mapgen.list["empty"] = _ => {};
-
+dragonblocks.mapgen.list["void"] = _ => {};
let oldOnset = this.onset;
let self = this;
- this.onset = (x, y) => {
- let meta = dragonblocks.getNode(x, y).meta;
+ this.onset = (map, x, y) => {
+ let meta = map.getNode(x, y).meta;
meta.liquidInterval = setInterval(_ => {
for(let [ix, iy] of [[x + 1, y], [x - 1, y], [x, y + 1]]){
- let node = dragonblocks.getNode(ix, iy);
+ let node = map.getNode(ix, iy);
if (! node || node.stable || node.toNode().liquid)
continue;
- dragonblocks.setNode(ix, iy, self.name);
+ map.setNode(ix, iy, self.name);
}
}, self.liquidTickSpeed || 2000);
if (oldOnset)
- oldOnset(x, y);
+ oldOnset(map, x, y);
return meta;
};
let oldOnremove = this.onremove;
- this.onremove = (x, y) => {
- clearInterval(dragonblocks.getNode(x, y).meta.liquidInterval);
+ this.onremove = (map, x, y) => {
+ clearInterval(map.getNode(x, y).meta.liquidInterval);
if (oldOnremove)
- oldOnremove(x, y);
+ oldOnremove(map, x, y);
};
}
}
dragonblocks.nodes[nodeDef.name] = nodeDef;
dragonblocks.registeredNodes.push(nodeDef);
};
-
-dragonblocks.onSetNodeCallbacks = [];
-dragonblocks.registerOnSetNode = func => {
- dragonblocks.onSetNodeCallbacks.push(func);
-};
-
-dragonblocks.onRemoveNodeCallbacks = [];
-dragonblocks.registerOnRemoveNode = func => {
- dragonblocks.onRemoveNodeCallbacks.push(func);
-};
-
-dragonblocks.onPlaceNodeCallbacks = [];
-dragonblocks.registerOnPlaceNode = func => {
- dragonblocks.onPlaceNodeCallbacks.push(func);
-};
-
-dragonblocks.onDigNodeCallbacks = [];
-dragonblocks.registerOnDigNode = func => {
- dragonblocks.onDigNodeCallbacks.push(func);
-};
-
-dragonblocks.onClickNodeCallbacks = [];
-dragonblocks.registerOnClickNode = func => {
- dragonblocks.onClickNodeCallbacks.push(func);
-};
-
-dragonblocks.onActivateNodeCallbacks = [];
-dragonblocks.registerOnActivateNode = func => {
- dragonblocks.onActivateNodeCallbacks.push(func);
-};
-
-dragonblocks.onPunchNodeCallbacks = [];
-dragonblocks.registerOnPunchNode = func => {
- dragonblocks.onPunchNodeCallbacks.push(func);
-};
}
});
-dragonblocks.Player = class extends dragonblocks.SpawnedEntity{
- constructor()
+dragonblocks.Player = class extends dragonblocks.SpawnedEntity
+{
+ constructor(data, map)
{
- if (dragonblocks.worldIsLoaded) {
- super(dragonblocks.world.spawnedEntities.filter(entity => {
- return entity.name == "dragonblocks:player";
- })[0]);
-
- dragonblocks.world.spawnedEntities = dragonblocks.world.spawnedEntities.filter(entity => {
- return entity.name != "dragonblocks:player";
- });
- } else {
- super(dragonblocks.entities["dragonblocks:player"], dragonblocks.map.width / 2, 5);
- }
+ if (data)
+ super(data, map);
+ else
+ super(dragonblocks.entities["dragonblocks:player"], map, map.width / 2, 5);
let self = this;
this.skin = this.meta.skin;
// Inventory
- this.tmp.inventory = new dragonblocks.InventoryGroup(); // Create Inventory Group that can hold multible Inventories
+ this.tmp.inventory = new dragonblocks.InventoryGroup(); // Create inventory group that can hold multiple inventories
// Main Inventory
- this.tmp.mainInventory = new dragonblocks.Inventory(32, 8); // The Main Inventory
+ this.tmp.mainInventory = new dragonblocks.Inventory(32, 8); // The main Inventory
if (this.meta.mainInventory)
this.tmp.mainInventory.deserialize(this.meta.mainInventory); // Load saved Inventory
this.tmp.mainInventory.addEventListener("updateStack", event => {
self.meta.mainInventory = this.tmp.mainInventory.serialize(); // Save inventory after every change
- if (self.gamemode == "creative" && event.stack.count > 1) // Keep itemcount of every stack at one when in creative
+ if (self.gamemode == "creative" && event.stack.count > 1) // Keep count of every stack at one when in creative
event.stack.count = 1;
});
// Map Scroll
setInterval(_ => {
- if (dragonblocks.map.displayLeft + dragonblocks.map.displayWidth < self.x + self.width + 3)
- dragonblocks.map.displayLeft = parseInt(self.x + self.width + 3 - dragonblocks.map.displayWidth);
- else if (dragonblocks.map.displayLeft > self.x - 2)
- dragonblocks.map.displayLeft = parseInt(self.x - 2);
- if (dragonblocks.map.displayTop + dragonblocks.map.displayHeight < self.y + self.height + 3)
- dragonblocks.map.displayTop = parseInt(self.y + self.height + 3 - dragonblocks.map.displayHeight);
- else if (dragonblocks.map.displayTop > self.y - 2)
- dragonblocks.map.displayTop = parseInt(self.y - 2);
-
- dragonblocks.map.updateGraphics();
+ if (map.displayLeft + map.displayWidth < self.x + self.width + 3)
+ map.displayLeft = parseInt(self.x + self.width + 3 - map.displayWidth);
+ else if (map.displayLeft > self.x - 2)
+ map.displayLeft = parseInt(self.x - 2);
+
+ if (map.displayTop + map.displayHeight < self.y + self.height + 3)
+ map.displayTop = parseInt(self.y + self.height + 3 - map.displayHeight);
+ else if (map.displayTop > self.y - 2)
+ map.displayTop = parseInt(self.y - 2);
+
+ map.updateGraphics();
});
// Controls
});
}
- let mapDisplay = document.getElementById("dragonblocks.map");
-
addEventListener("mouseup", event => {
if (event.which == 1)
self.digStop();
});
// Map Interaction Controls
- for (let x = 0; x < dragonblocks.map.displayWidth; x++) {
- for (let y = 0; y < dragonblocks.map.displayHeight; y++) {
+ for (let x = 0; x < map.displayWidth; x++) {
+ for (let y = 0; y < map.displayHeight; y++) {
let nodeDisplay = document.getElementById("dragonblocks.map.node[" + x + "][" + y + "]");
nodeDisplay.addEventListener("mouseover", event => {
- if (self.canReach(x + dragonblocks.map.displayLeft, y + dragonblocks.map.displayTop))
+ if (self.canReach(x + map.displayLeft, y + map.displayTop))
event.srcElement.style.boxShadow = "0 0 0 1px black inset";
});
});
nodeDisplay.addEventListener("mousedown", event => {
- let [ix, iy] = [x + dragonblocks.map.displayLeft, y + dragonblocks.map.displayTop];
+ let [ix, iy] = [x + map.displayLeft, y + map.displayTop];
switch(event.which) {
case 1:
}
}
+ serialize()
+ {
+ return dblib.removeTmp([this])[0];
+ }
+
set skin(value)
{
this.meta.skin = value;
}
};
-Object.assign(dragonblocks.Player.prototype, dragonblocks.MapInteraction); //Mixin
+Object.assign(dragonblocks.Player.prototype, dragonblocks.MapInteraction); // Mixin
}
}
- apply(x, y)
+ apply(map, x, y)
{
for (let pixel of this.data) {
let mx, my;
mx = pixel.x + x;
my = pixel.y + y;
- let node = dragonblocks.getNode(mx, my);
+ let node = map.getNode(mx, my);
if (! node)
continue;
let doApply = true;
for (let func of this.functions) {
- if (func(nodeDef, mx, my, pixel.node) == false) {
+ if (func(nodeDef, map, mx, my, pixel.node) == false) {
doApply = false;
break;
}
}
if (doApply)
- dragonblocks.setNode(mx, my, pixel.node);
+ map.setNode(mx, my, pixel.node);
}
return this;
dragonblocks.SpawnedEntity = class
{
- constructor(def, x, y){
+ constructor(def, map, x, y)
+ {
dblib.copy(this, def);
+ this.tmp = {map};
if (def instanceof dragonblocks.Entity) {
this.id = dragonblocks.getToken();
}
this.restorePhysics();
- this.tmp = {};
-
this.addGraphics();
let self = this;
this.tickInterval = setInterval(_ => {
- self.tick()
+ self.tick();
}, 100);
+
this.physicInterval = setInterval(_=>{
- self.physicsTick()
+ self.physicsTick();
});
let entityDef = this.toEntity();
self.restorePhysics();
});
- dragonblocks.spawnedEntities.push(this);
+ map.entities.push(this);
}
toEntity()
entityDef.ondespawn && entityDef.ondespawn(this);
let id = this.id;
- dragonblocks.spawnedEntities = dragonblocks.spawnedEntities.filter(entity => {
+ this.map.entities = this.map.entities.filter(entity => {
return entity.id != id;
});
clearInterval(this.physicInterval);
clearInterval(this.tickInterval);
- document.getElementById("dragonblocks.entity[" + this.id + "]").remove();
+ let display = document.getElementById("dragonblocks.entity[" + this.id + "]");
+ display && display.remove();
}
restorePhysics()
if (this.x < 0)
return false;
- if (this.x + this.width > dragonblocks.map.width)
+ if (this.x + this.width > this.map.width)
return false;
return this.collision();
if (this.y < 0)
return false;
- if (this.y + this.height > dragonblocks.map.height)
+ if (this.y + this.height > this.map.height)
return false;
return this.collision();
{
for (let ix = Math.floor(this.x); ix <= Math.ceil(this.x + this.width - 0.01) - 1; ix++)
for (let iy = Math.floor(this.y); iy <= Math.ceil(this.y + this.height - 0.01) - 1; iy++)
- if (dragonblocks.getNode(ix, iy).mobstable)
+ if (this.map.getNode(ix, iy).mobstable)
return false;
return true;
}
{
let t = new Date().getTime() / 1000;
- var oldX = this.x;
- var dtx = t - this.tx0;
+ let oldX = this.x;
+ let dtx = t - this.tx0;
if (this.ax)
this.x = this.ax * dtx * dtx + this.vx * dtx + this.x0;
this.toEntity().oncollide && this.toEntity().oncollide(this);
}
- var oldY = this.y;
- var dty = t - this.ty0;
+ let oldY = this.y;
+ let dty = t - this.ty0;
if (this.ay)
this.y = this.ay * dty * dty + this.vy * dty + this.y0;
this.updateGraphics();
}
- touch(x, y)
+ touch(map, x, y)
{
+ if (map != this.map)
+ return false;
for (let ix = Math.floor(this.x); ix <= Math.ceil(this.x + this.width - 0.01) - 1; ix++)
for (let iy = Math.floor(this.y); iy <= Math.ceil(this.y + this.height - 0.01) - 1; iy++)
if (iy == y && ix == x)
addGraphics(obj)
{
- var display = document.getElementById("dragonblocks.map").appendChild(document.createElement("div"));
+ let display = document.getElementById("dragonblocks.map").appendChild(document.createElement("div"));
display.id = "dragonblocks.entity[" + this.id + "]";
display.style.position = "absolute";
display.style.width = this.width * dragonblocks.settings.map.scale + "px";
display.style.height = this.height * dragonblocks.settings.map.scale + "px";
display.style.zIndex = "0";
-
display.addEventListener("mouseover", event => {
event.srcElement.style.boxShadow = "0 0 0 1px black inset";
});
if (! display)
return;
- display.style.left = (this.x - dragonblocks.map.displayLeft) * dragonblocks.settings.map.scale + "px";
- display.style.top = (this.y - dragonblocks.map.displayTop) * dragonblocks.settings.map.scale + "px";
+ display.style.left = (this.x - this.map.displayLeft) * dragonblocks.settings.map.scale + "px";
+ display.style.top = (this.y - this.map.displayTop) * dragonblocks.settings.map.scale + "px";
}
updateTexture()
let y = Math.ceil(entityY);
if (y - entityY <= 0.01) {
- let node = dragonblocks.getNode(x, y);
+ let node = this.map.getNode(x, y);
if (! node || node.mobstable)
return true;
if (this.gravity)
this.gravity = true;
}
-};
-dragonblocks.spawnedEntities = [];
-dragonblocks.registerOnStarted(_ => {
- if (dragonblocks.worldIsLoaded)
- for (let entity of dragonblocks.world.spawnedEntities)
- new dragonblocks.SpawnedEntity(entity);
-});
+ get map()
+ {
+ return this.tmp.map;
+ }
+};
/*
* world.js
*
- * Copyright 2020 Elias Fleckenstein <eliasfleckenstein@web.de>
+ * Copyright 2021 Elias Fleckenstein <eliasfleckenstein@web.de>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
*
*/
-dragonblocks.getSavestring = _ => {
- dragonblocks.world.map = dragonblocks.map;
- dragonblocks.world.mods = dragonblocks.mods;
- dragonblocks.world.spawnedEntities = dblib.removeTmp(dragonblocks.spawnedEntities);
+dragonblocks.World = class
+{
+ constructor(properties)
+ {
+ this.name = properties.name;
+ this.isLoaded = properties.isLoaded;
- return JSON.stringify(dragonblocks.world);
-}
+ if (this.isLoaded) {
+ this.load();
+ } else {
+ this.mods = properties.mods;
-dragonblocks.save = _ => {
- if (dragonblocks.loggedin)
- return dragonblocks.backendCall("saveWorld", true, {name: dragonblocks.worldname, world: dragonblocks.getSavestring()});
-};
+ this.loadMods();
-dragonblocks.checkWorldnameSpelling = name => {
- return name.match(/^[a-zA-Z0-9]+$/);
-};
+ this.map = new dragonblocks.Map();
+ this.player = new dragonblocks.Player(null, this.map);
+
+ this.player.setGamemode(properties.gamemode);
+ dragonblocks.mapgen.generate(properties.mapgen, this.map);
+ }
+ }
+
+ serialize()
+ {
+ return {
+ mods: this.mods,
+ map: this.map.serialize(),
+ player: this.player.serialize(),
+ };
+ }
+
+ deserialize(data)
+ {
+ this.mods = data.mods;
+
+ this.loadMods();
+
+ this.map = new dragonblocks.Map(data.map);
+ this.player = new dragonblocks.Player(data.player, this.map);
+ }
-dragonblocks.loadWorldList = _ => {
- dragonblocks.worlds = dragonblocks.backendCall("getWorlds");
+ save()
+ {
+ if (dragonblocks.loggedin)
+ return dragonblocks.backendCall("saveWorld", true, {name: this.name, world: JSON.stringify(this.serialize())});
+ }
+
+ load()
+ {
+ this.deserialize($.getJSON("worlds/" + this.name + "/world.json").responseJSON);
+ }
+
+ loadMods()
+ {
+ dragonblocks.loadMods(this.mods);
+ }
};
-dragonblocks.getEmptyWorld = function(){
- return {
- map:{
- data: Array(dragonblocks.settings.map.width).fill(Array(dragonblocks.settings.map.width).fill(new dragonblocks.MapNode("air"))),
- width: dragonblocks.settings.map.width,
- height: dragonblocks.settings.map.height,
- displayTop: dragonblocks.settings.map.height / 2,
- displayLeft: dragonblocks.settings.map.width / 2 - 5,
- },
- structures: {},
- };
-}
+dragonblocks.World.Properties = class
+{
+ constructor(isLoaded)
+ {
+ this.name = "";
+ this.isLoaded = isLoaded;
+
+ if (! isLoaded) {
+ this.mods = [];
+
+ this.gamemode = dragonblocks.settings.defaultWorldOptions.gamemode;
+ this.mapgen = dragonblocks.settings.defaultWorldOptions.mapgen;
+ }
+ }
+
+ checkSpelling()
+ {
+ return this.name.match(/^[a-zA-Z0-9]+$/);
+ }
+};
hardness: 6,
desc: "Chest",
stable: true,
- onset: (x, y) => {
- let meta = dragonblocks.getNode(x, y).meta;
+ onset: (map, x, y) => {
+ let meta = map.getNode(x, y).meta;
meta.inventory = new dragonblocks.Inventory(32, 8);
if(meta.inventoryString)
meta.inventory.deserialize(meta.inventoryString);
},
- onclick: (x, y) => {
- let meta = dragonblocks.getNode(x, y).meta;
+ onclick: (map, x, y) => {
+ let meta = map.getNode(x, y).meta;
dragonblocks.player.setInventoryElements([meta.inventory, dragonblocks.player.tmp.mainInventory]);
dragonblocks.player.openInventory();
dragonblocks.nodes["chest:chest"].playSound("open");
meta.inventoryString = meta.inventory.serialize();
};
},
- ondig: (x, y) => {
- return dragonblocks.getNode(x, y).meta.inventory.isEmpty();
+ ondig: (map, x, y) => {
+ return map.getNode(x, y).meta.inventory.isEmpty();
},
sounds: {
open: "chest_open.ogg",
default:
commands.help(arg);
break;
- }
+ }
}
});
dragonblocks.registerChatcommand({
func: arg => {
let x = parseInt(arg.split(" ")[0]);
let y = parseInt(arg.split(" ")[1]);
- if(dragonblocks.map.contains(x, y)){
+ if(dragonblocks.player.map.withinBounds(x, y)){
dragonblocks.player.teleport(x, y, true);
dragonblocks.chatMessage("Teleported to " + x + ", " + y);
}
let x = parseInt(arg.split(" ")[0]);
let y = parseInt(arg.split(" ")[1]);
let node = arg.split(" ")[2];
- if(dragonblocks.map.contains(x, y)){
+ if(dragonblocks.player.map.withinBounds(x, y)){
if(dragonblocks.nodes[node]){
- dragonblocks.setNode(x, y, node);
- dragonblocks.chatMessage("Set " + node + " to " + x + ", " + y);
+ dragonblocks.player.map.setNode(x, y, node);
+ dragonblocks.chatMessage("Set " + node + " to " + x + ", " + y);
}
else
dragonblocks.chatMessage("Unknown Node.");
texture: "core_lava.png",
groups: ["liquid"],
desc: "Lava",
- onset: (x, y) => {
- dragonblocks.getNode(x, y).meta.lavaInterval = setInterval(_ => {
+ onset: (map, x, y) => {
+ map.getNode(x, y).meta.lavaInterval = setInterval(_ => {
for(let ix = x - 1; ix <= x + 1; ix++)
for(let iy = y - 1; iy <= y + 1; iy++)
- if(dragonblocks.getNode(ix, iy) && dragonblocks.getNode(ix, iy).toNode().lavacooling)
- dragonblocks.setNode(x, y, "core:obsidian");
+ if(map.getNode(ix, iy) && map.getNode(ix, iy).toNode().lavacooling)
+ map.setNode(x, y, "core:obsidian");
}, 2000);
},
- onremove: (x, y) => {
- clearInterval(dragonblocks.getNode(x, y).meta.lavaInterval);
+ onremove: (map, x, y) => {
+ clearInterval(map.getNode(x, y).meta.lavaInterval);
},
liquid: true,
});
hardness: 3,
desc: desc,
drops: "dirt:dirt",
- onset: (x, y) => {
- dragonblocks.getNode(x, y).meta.dirtInterval = setInterval(_ => {
+ onset: (map, x, y) => {
+ map.getNode(x, y).meta.dirtInterval = setInterval(_ => {
for(let ix = x - 1; ix <= x + 1; ix++)
for(let iy = y - 1; iy <= y + 1; iy++)
- if(dblib.random(0, 60) == 0 && dragonblocks.getNode(ix, iy) && dragonblocks.getNode(ix, iy).name == "dirt:dirt" && dragonblocks.getNode(ix, iy - 1) && ! dragonblocks.getNode(ix, iy - 1).stable)
- dragonblocks.setNode(ix, iy, name);
- if(dblib.random(0, 45) == 0 && dragonblocks.getNode(x, y - 1) && dragonblocks.getNode(x, y - 1).stable)
- dragonblocks.setNode(x, y, "dirt:dirt");
+ if(dblib.random(0, 60) == 0 && map.getNode(ix, iy) && map.getNode(ix, iy).name == "dirt:dirt" && map.getNode(ix, iy - 1) && ! map.getNode(ix, iy - 1).stable)
+ map.setNode(ix, iy, name);
+ if(dblib.random(0, 45) == 0 && map.getNode(x, y - 1) && map.getNode(x, y - 1).stable)
+ map.setNode(x, y, "dirt:dirt");
}, 1000);
},
- onremove: (x, y) => {
- clearInterval(dragonblocks.getNode(x, y).meta.dirtInterval);
+ onremove: (map, x, y) => {
+ clearInterval(map.getNode(x, y).meta.dirtInterval);
}
});
}
groups: obj.groups,
desc: obj.desc,
texture: texture + ".png",
- onuse: (x, y) => {
- if(! dragonblocks.getNode(x, y) || dragonblocks.getNode(x, y).stable || ! dragonblocks.getNode(x, y - 1) || dragonblocks.getNode(x, y - 1).stable)
+ onuse: (map, x, y) => {
+ if(! map.getNode(x, y) || map.getNode(x, y).stable || ! map.getNode(x, y - 1) || map.getNode(x, y - 1).stable)
return false;
- dragonblocks.setNode(x, y - 1, name + "_front_upper");
- dragonblocks.setNode(x, y, name + "_front_downer");
+ map.setNode(x, y - 1, name + "_front_upper");
+ map.setNode(x, y, name + "_front_downer");
dragonblocks.items[name].playSound("place");
return true;
},
hardness: obj.hardness,
desc: obj.desc,
texture: texture + "_front_upper.png",
- ondig: (x, y) => {
- if(dragonblocks.getNode(x, y + 1) && dragonblocks.getNode(x, y + 1).name == name + "_front_downer")
- dragonblocks.setNode(x, y + 1, "air");
+ ondig: (map, x, y) => {
+ if(map.getNode(x, y + 1) && map.getNode(x, y + 1).name == name + "_front_downer")
+ map.setNode(x, y + 1, "air");
},
- onclick: (x, y) => {
- if(dragonblocks.getNode(x, y + 1) && dragonblocks.getNode(x, y + 1).name == name + "_front_downer")
- dragonblocks.setNode(x, y + 1, name + "_side_downer");
- dragonblocks.setNode(x, y, name + "_side_upper");
+ onclick: (map, x, y) => {
+ if(map.getNode(x, y + 1) && map.getNode(x, y + 1).name == name + "_front_downer")
+ map.setNode(x, y + 1, name + "_side_downer");
+ map.setNode(x, y, name + "_side_upper");
dragonblocks.playSound(sound + "_close.ogg");
},
drops: name,
hardness: obj.hardness,
desc: obj.desc,
texture: texture + "_front_downer.png",
- ondig: (x, y) => {
- if(dragonblocks.getNode(x, y - 1) && dragonblocks.getNode(x, y - 1).name == name + "_front_upper")
- dragonblocks.setNode(x, y - 1, "air");
+ ondig: (map, x, y) => {
+ if(map.getNode(x, y - 1) && map.getNode(x, y - 1).name == name + "_front_upper")
+ map.setNode(x, y - 1, "air");
},
- onclick: (x, y) => {
- if(dragonblocks.getNode(x, y - 1) && dragonblocks.getNode(x, y - 1).name == name + "_front_upper")
- dragonblocks.setNode(x, y - 1, name + "_side_upper");
- dragonblocks.setNode(x, y, name + "_side_downer");
+ onclick: (map, x, y) => {
+ if(map.getNode(x, y - 1) && map.getNode(x, y - 1).name == name + "_front_upper")
+ map.setNode(x, y - 1, name + "_side_upper");
+ map.setNode(x, y, name + "_side_downer");
dragonblocks.playSound(sound + "_close.ogg");
},
drops: name,
hardness: obj.hardness,
desc: obj.desc,
texture: texture + "_side.png",
- ondig: (x, y) => {
- if(dragonblocks.getNode(x, y + 1) && dragonblocks.getNode(x, y + 1).name == name + "_side_downer")
- dragonblocks.setNode(x, y + 1, "air");
+ ondig: (map, x, y) => {
+ if(map.getNode(x, y + 1) && map.getNode(x, y + 1).name == name + "_side_downer")
+ map.setNode(x, y + 1, "air");
},
- onclick: (x, y) => {
- if(dragonblocks.getNode(x, y + 1) && dragonblocks.getNode(x, y + 1).name == name + "_side_downer")
- dragonblocks.setNode(x, y + 1, name + "_front_downer");
- dragonblocks.setNode(x, y, name + "_front_upper");
+ onclick: (map, x, y) => {
+ if(map.getNode(x, y + 1) && map.getNode(x, y + 1).name == name + "_side_downer")
+ map.setNode(x, y + 1, name + "_front_downer");
+ map.setNode(x, y, name + "_front_upper");
dragonblocks.playSound(sound + "_open.ogg");
},
drops: name,
hardness: obj.hardness,
desc: obj.desc,
texture: texture + "_side.png",
- ondig: (x, y) => {
- if(dragonblocks.getNode(x, y - 1) && dragonblocks.getNode(x, y - 1).name == name + "_side_upper")
- dragonblocks.setNode(x, y - 1, "air");
+ ondig: (map, x, y) => {
+ if(map.getNode(x, y - 1) && map.getNode(x, y - 1).name == name + "_side_upper")
+ map.setNode(x, y - 1, "air");
},
- onclick: (x, y) => {
- if(dragonblocks.getNode(x, y - 1) && dragonblocks.getNode(x, y - 1).name == name + "_side_upper")
- dragonblocks.setNode(x, y - 1, name + "_front_upper");
- dragonblocks.setNode(x, y, name + "_front_downer");
+ onclick: (map, x, y) => {
+ if(map.getNode(x, y - 1) && map.getNode(x, y - 1).name == name + "_side_upper")
+ map.setNode(x, y - 1, name + "_front_upper");
+ map.setNode(x, y, name + "_front_downer");
dragonblocks.playSound(sound + "_open.ogg");
},
drops: name,
hardness: obj.hardness,
desc: obj.desc,
texture: texture + ".png",
- onclick: (x, y) => {
- dragonblocks.setNode(x, y, name + "_closed");
+ onclick: (map, x, y) => {
+ map.setNode(x, y, name + "_closed");
dragonblocks.playSound(sound + "_close.ogg");
},
stacksize: obj.stacksize,
hardness: obj.hardness,
desc: obj.desc,
texture: texture + "_closed.png",
- onclick: (x, y) => {
- dragonblocks.setNode(x, y, name);
+ onclick: (map, x, y) => {
+ map.setNode(x, y, name);
dragonblocks.playSound(sound + "_open.ogg");
},
drops: name,
};
audio.play();
}
-fire.catchfire = function(x, y){
- let mapNode = dragonblocks.getNode(x, y);
+fire.catchfire = function(map, x, y){
+ let mapNode = map.getNode(x, y);
if(mapNode && mapNode.toNode().flammable){
if(mapNode.toNode().onfire && mapNode.toNode().onfire(x, y) == false)
return;
- dragonblocks.player.place(x, y - 1, "fire:fire");
+ dragonblocks.player.place(map, x, y - 1, "fire:fire");
}
}
dragonblocks.registerGroup({
dug: "fire_dug.ogg",
place: "",
},
- onset : (x, y) => {
- let meta = dragonblocks.getNode(x, y).meta;
+ onset: (map, x, y) => {
+ let meta = map.getNode(x, y).meta;
meta.fireInterval = setInterval(_ => {
if(dblib.random(0, 6) == 0);
fire.playBurnSound();
for(let ix = x - 1; ix <= x + 1; ix++){
for(let iy = y - 1; iy <= y + 2; iy++){
if(dblib.random(0, 3) == 0)
- fire.catchfire(ix, iy);
+ fire.catchfire(map, ix, iy);
}
}
- if(! dragonblocks.getNode(x, y + 1) || ! dragonblocks.getNode(x, y + 1).toNode().inGroup("flammable")){
- if(dblib.random(0, 20) == 0)
- dragonblocks.setNode(x, y, "air");
+ if (! map.getNode(x, y + 1) || ! map.getNode(x, y + 1).toNode().inGroup("flammable")) {
+ if (dblib.random(0, 20) == 0)
+ map.setNode(x, y, "air");
+ } else if (dblib.random(0, map.getNode(x, y + 1).toNode().hardness * 2) == 0) {
+ dragonblocks.player.dig(map, x, y + 1);
}
- else if(dblib.random(0, dragonblocks.getNode(x, y + 1).toNode().hardness * 2) == 0)
- dragonblocks.player.dig(x, y + 1);
}, 1000);
},
- onremove : (x, y) => {
- clearInterval(dragonblocks.getNode(x, y).meta.fireInterval);
+ onremove: (map, x, y) => {
+ clearInterval(map.getNode(x, y).meta.fireInterval);
}
});
hardness: 10,
desc: "Furnace",
stable: true,
- onset: (x, y) => {
- let meta = dragonblocks.getNode(x, y).meta;
+ onset: (map, x, y) => {
+ let meta = map.getNode(x, y).meta;
meta.inventory = new furnace.Inventory();
if(meta.inventoryString)
meta.inventory.ceserialize(meta.inventoryString);
},
- onclick: (x, y) => {
- let meta = dragonblocks.getNode(x, y).meta;
+ onclick: (map, x, y) => {
+ let meta = map.getNode(x, y).meta;
dragonblocks.player.setInventoryElements([meta.inventory, dragonblocks.player.tmp.mainInventory]);
dragonblocks.player.openInventory();
dragonblocks.player.onNextInventoryClose = _ => {
meta.inventoryString = meta.inventory.serialize();
};
},
- ondig: (x, y) => {
- return dragonblocks.getNode(x, y).meta.inventory.isEmpty();
+ ondig: (map, x, y) => {
+ return map.getNode(x, y).meta.inventory.isEmpty();
},
});
for(let i = 0; i < 6; i++){
let texture = "plants_" + obj.name;
obj.tree.replace("leaves", name + "_leaves");
obj.tree.replace("tree", name + "_tree");
- obj.tree.addFunction((node, x, y) => {
+ obj.tree.addFunction((node, map, x, y) => {
if(node.stable && node.name != name + "_sapling")
return false;
});
texture: texture + "_sapling.png",
groups: ["snappy"],
hardness: 2,
- onset: (x, y) => {
- dragonblocks.setTimer("growTimer", dblib.random(obj.growtimeMin, obj.growtimeMax), _ => {obj.tree.apply(x, y);}, dragonblocks.getNode(x, y).meta);
+ onset: (map, x, y) => {
+ dragonblocks.setTimer("growTimer", dblib.random(obj.growtimeMin, obj.growtimeMax), _ => {
+ obj.tree.apply(map, x, y);
+ }, map.getNode(x, y).meta);
},
- onremove: (x, y) => {
- dragonblocks.clearTimer("growTimer", dragonblocks.getNode(x, y).meta);
+ onremove: (map, x, y) => {
+ dragonblocks.clearTimer("growTimer", map.getNode(x, y).meta);
},
- onplace: (x, y) => {
- if(dragonblocks.getNode(x, y + 1) && ! dragonblocks.getNode(x, y + 1).toNode().inGroup("dirt"))
+ onplace: (map, x, y) => {
+ if(map.getNode(x, y + 1) && ! map.getNode(x, y + 1).toNode().inGroup("dirt"))
return false;
},
desc: obj.desc + " " + obj.saplingName,
desc: obj.desc + " " + obj.treeName,
stacksize: obj.stacksize,
flammable: true,
- onplace: (x, y) => {
- setTimeout(_ => {dragonblocks.getNode(x, y).mobstable = true})
+ onplace: (map, x, y) => {
+ setTimeout(_ => {
+ map.getNode(x, y).mobstable = true;
+ });
}
});
dragonblocks.registerNode({
groups: obj.groups,
hardness: obj.hardness,
desc: obj.desc || dblib.humanFormat(obj.name),
- onset: (x, y) => {
- let meta = dragonblocks.getNode(x, y).meta;
+ onset: (map, x, y) => {
+ let meta = map.getNode(x, y).meta;
meta.growTime = dblib.random(obj.growtimeMin, obj.growtimeMax);
meta.growInterval = setInterval(_ => {
- if(! dragonblocks.getNode(x, y - 1) || dragonblocks.getNode(x, y - 1).stable)
+ if(! map.getNode(x, y - 1) || map.getNode(x, y - 1).stable)
return meta.growTime = dblib.random(obj.growtimeMin, obj.growtimeMax);
let iy = y + 1;
while(true){
- if(! dragonblocks.getNode(x, iy))
+ if(! map.getNode(x, iy))
return meta.growTime = dblib.random(obj.growtimeMin, obj.growtimeMax);
else if(iy == y + obj.maxHeight)
return meta.growTime = dblib.random(obj.growtimeMin, obj.growtimeMax);
- else if(! dragonblocks.itemMatch(obj.growOn, dragonblocks.getNode(x, iy)))
+ else if(! dragonblocks.itemMatch(obj.growOn, map.getNode(x, iy)))
break;
- else if(dragonblocks.getNode(x, iy).name == name)
+ else if(map.getNode(x, iy).name == name)
iy++;
else
return meta.growTime = dblib.random(obj.growtimeMin, obj.growtimeMax);
}
meta.growTime--;
if(meta.growTime <= 0)
- dragonblocks.setNode(x, y - 1, name);
+ map.setNode(x, y - 1, name);
}, 1000);
},
- onremove: (x, y) => {
- clearInterval(dragonblocks.getNode(x, y).meta.growInterval);
+ onremove: (map, x, y) => {
+ clearInterval(map.getNode(x, y).meta.growInterval);
},
- ondig: (x, y) => {
- if(obj.dropAbove && dragonblocks.getNode(x, y - 1) && dragonblocks.getNode(x, y - 1).name == name)
+ ondig: (map, x, y) => {
+ if(obj.dropAbove && map.getNode(x, y - 1) && map.getNode(x, y - 1).name == name)
dragonblocks.player.digEnd(x, y - 1);
},
stacksize: obj.stacksize,
["air", "air", "air", "air", "air"],
["", "air", "air", "air", ""],
]);
-tnt.explosion.addFunction((node, x, y) => {
- if(node.onblast && node.onblast(x, y) == false)
+tnt.explosion.addFunction((node, map, x, y) => {
+ if(node.onblast && node.onblast(map, x, y) == false)
return false;
return dblib.random(0, 100) < 90;
});
-tnt.ignite = function(x, y, time){
- dragonblocks.setTimer("tntTimer", time, _ => {tnt.explode(x, y)}, dragonblocks.getNode(x, y).meta);
+tnt.ignite = function(map, x, y, time){
+ dragonblocks.setTimer("tntTimer", time, _ => {
+ tnt.explode(map, x, y);
+ }, map.getNode(x, y).meta);
}
-tnt.explode = function(x, y){
- dragonblocks.setNode(x, y, "air");
+tnt.explode = function(map, x, y){
+ map.setNode(x, y, "air");
dragonblocks.playSound("tnt_explode.ogg");
- tnt.explosion.apply(x, y);
+ tnt.explosion.apply(map, x, y);
}
dragonblocks.registerNode({
name: "tnt:tnt",
texture: "tnt_tnt.png",
onfire: (x, y) => {
dragonblocks.playSound("tnt_ignite.ogg");
- dragonblocks.setNode(x, y, "tnt:active_tnt");
+ map.setNode(x, y, "tnt:active_tnt");
},
- onblast: (x, y) => {
- dragonblocks.playSound("tnt_ignite.ogg");
- tnt.ignite(x, y, 0.1);
+ onblast: (map, x, y) => {
+ tnt.ignite(map, x, y, 0.1);
},
- onclick: (x, y) => {
+ onclick: (map, x, y) => {
if(dragonblocks.player.getWieldedItem().item == "torch:torch"){
dragonblocks.playSound("tnt_ignite.ogg");
- dragonblocks.setNode(x, y, "tnt:active_tnt");
+ map.setNode(x, y, "tnt:active_tnt");
}
},
flammable: true
stable: true,
desc: "TNT (active)",
texture: "tnt_active_tnt.png",
- onset: (x, y) => {
- tnt.ignite(x, y, 4);
+ onset: (map, x, y) => {
+ tnt.ignite(map, x, y, 4);
},
ondig: _ => {
return false;
mobstable: false,
desc: "Gunpowder",
texture: "tnt_gunpowder.png",
- onclick: (x, y) => {
+ onclick: (map, x, y) => {
if(dragonblocks.player.getWieldedItem().item == "torch:torch_floor")
- dragonblocks.setNode(x, y, "tnt:active_gunpowder");
+ map.setNode(x, y, "tnt:active_gunpowder");
},
hidden: true,
});
desc: "Gunpowder (active)",
texture: "tnt_active_gunpowder.png",
drops: "tnt:gunpowder",
- onset: (x, y) => {
- let meta = dragonblocks.getNode(x, y).meta;
+ onset: (map, x, y) => {
+ let meta = map.getNode(x, y).meta;
meta.gunpowderTime = 1;
meta.gunpowderInterval = setInterval(_ => {
meta.gunpowderTime -= 0.1;
if(meta.gunpowderTime <= 0){
- dragonblocks.setNode(x, y, "air");
+ map.setNode(x, y, "air");
for(let [ix, iy] of [[x - 1, y], [x + 1, y], [x, y - 1], [x, y + 1]]){
- if(dragonblocks.getNode(ix, iy).name == "tnt:gunpowder")
- dragonblocks.setNode(ix, iy, "tnt:active_gunpowder");
- else if(dragonblocks.getNode(ix, iy).name == "tnt:tnt")
- tnt.ignite(ix, iy, tnt.time);
+ if(map.getNode(ix, iy).name == "tnt:gunpowder")
+ map.setNode(ix, iy, "tnt:active_gunpowder");
+ else if(map.getNode(ix, iy).name == "tnt:tnt")
+ tnt.ignite(map, ix, iy, tnt.time);
}
clearInterval(meta.gunpowderInterval);
}
}, 100);
},
- onremove: (x, y) => {
- clearInterval(dragonblocks.getNode(x, y).meta.gunpowderInterval);
+ onremove: (map, x, y) => {
+ clearInterval(map.getNode(x, y).meta.gunpowderInterval);
},
hidden: true
});
torch = {};
torch.directions = ["floor", "left", "right", "ceiling"];
-torch.check = function(direction, x, y){
+torch.check = function(direction, map, x, y){
switch(direction){
case "floor":
- return ! dragonblocks.getNode(x, y + 1) || dragonblocks.getNode(x, y + 1).stable;
+ return ! map.getNode(x, y + 1) || map.getNode(x, y + 1).stable;
case "left":
- return ! dragonblocks.getNode(x - 1, y) || dragonblocks.getNode(x - 1, y).stable;
+ return ! map.getNode(x - 1, y) || map.getNode(x - 1, y).stable;
case "right":
- return ! dragonblocks.getNode(x + 1, y) || dragonblocks.getNode(x + 1, y).stable;
+ return ! map.getNode(x + 1, y) || map.getNode(x + 1, y).stable;
case "ceiling":
- return ! dragonblocks.getNode(x, y - 1) || dragonblocks.getNode(x, y - 1).stable;
+ return ! map.getNode(x, y - 1) || map.getNode(x, y - 1).stable;
}
}
dragonblocks.registerItem({
name: "torch:torch",
desc: "Torch",
texture: "torch_torch_floor.png",
- onuse: (x, y) => {
+ onuse: (map, x, y) => {
for(let direction of torch.directions)
- if(dragonblocks.player.place(x, y, dragonblocks.nodes["torch:torch_" + direction]))
+ if(dragonblocks.player.place(map, x, y, dragonblocks.nodes["torch:torch_" + direction]))
return true;
}
});
texture: "torch_torch_" + direction + ".png",
groups:["snappy"],
hidden: true,
- onactivate: (x, y) => {
- if(! torch.check(direction, x, y))
- dragonblocks.setNode(x, y, "air");
+ onactivate: (map, x, y) => {
+ if(! torch.check(direction, map, x, y))
+ map.setNode(x, y, "air");
},
- onplace: (x, y) => {
- if(! torch.check(direction, x, y))
+ onplace: (map, x, y) => {
+ if(! torch.check(direction, map, x, y))
return false;
}
});
-var wool = {};
+wool = {};
wool.colors = ["black", "blue", "brown", "cyan", "dark_green", "dark_grey", "green", "grey", "magenta", "orange", "pink", "red", "violet", "white", "yellow"];
for(let color of wool.colors){
dragonblocks.registerNode({
<meta charset="utf-8">
<link rel="icon" href="textures/icon.png">
<link rel="stylesheet" href="style.css">
- <script src="https://code.jquery.com/jquery-3.6.0.min.js" integrity="sha256-/xUj+3OJU5yExlq6GSYGSHk7tPXikynS7ogEvDej/m4=" crossorigin="anonymous"></script>
+ <!--<script src="https://code.jquery.com/jquery-3.6.0.min.js" integrity="sha256-/xUj+3OJU5yExlq6GSYGSHk7tPXikynS7ogEvDej/m4=" crossorigin="anonymous"></script>-->
+ <script src="https://code.jquery.com/jquery-3.6.0.js" integrity="sha256-H+K7U5CnXl1h5ywQfKtSj8PCmoN9aaq30gDh27Xc0jk=" crossorigin="anonymous"></script>
<script src="lib/dblib.js"></script>
<script>
$.ajaxSetup({
return Math.floor(min + Math.random() * (max - min + 1));
}
static humanFormat(str){
- var str = str.replace("_", " ");
+ str = str.replace("_", " ");
str = str[0].toUpperCase() + str.slice(1, str.length);
return str;
}
},
"timer": {
"tps": 3
+ },
+ "defaultWorldOptions": {
+ "gamemode": "survival",
+ "mapgen": "v3"
}
}
projects / dragonblocks.git / commitdiff