engine/map_interaction.js

   1 /*
   2  * map_interaction.js
   3  *
   4  * Copyright 2020 Elias Fleckenstein <eliasfleckenstein@web.de>
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
  19  * MA 02110-1301, USA.
  20  *
  21  *
  22  */
  23
  24 dragonblocks.MapInteraction = {
  25         initMapInteraction()
  26         {
  27                 let crack = document.getElementById("dragonblocks.map").appendChild(document.createElement("div"));
  28                 crack.id = "dragonblocks.crack[" + this.id + "]";
  29                 crack.style.position = "absolute";
  30                 crack.style.visibility = "hidden";
  31                 crack.style.backgroundSize = "cover";
  32                 crack.style.height = dragonblocks.settings.map.scale + "px";
  33                 crack.style.width = dragonblocks.settings.map.scale + "px";
  34                 crack.style.boxShadow = "0 0 0 1px black inset";
  35                 crack.style.zIndex = 2;
  36
  37                 let self = this;
  38
  39                 crack.addEventListener("mouseleave", event => {
  40                         self.digStop();
  41                         let [x, y] = dragonblocks.map.getScreenCoordinates(event.srcElement.offsetLeft, event.srcElement.offsetTop);
  42                         dragonblocks.map.getNodeDisplay(x, y).style.boxShadow = "none";
  43                 });
  44
  45                 crack.addEventListener("mouseover", event => {
  46                         let [x, y] = dragonblocks.map.getScreenCoordinates(event.srcElement.offsetLeft + document.getElementById("dragonblocks.map").offsetLeft, event.srcElement.offsetTop + document.getElementById("dragonblocks.map").offsetTop);
  47                         dragonblocks.map.getNodeDisplay(x, y).style.boxShadow = "0 0 0 1px black inset";
  48                 });
  49         },
  50
  51         dig(x, y)
  52         {
  53                 let node = dragonblocks.getNode(x, y);
  54
  55                 if (! node)
  56                         return false;
  57
  58                 let nodeDef = node.toNode();
  59                 if (nodeDef.ondig && nodeDef.ondig(x, y) == false)
  60                         return false;
  61
  62                 for (let func of dragonblocks.onDigNodeCallbacks)
  63                         if (func(x, y) == false)
  64                                 return false;
  65
  66                 nodeDef.playSound("dug");
  67
  68                 dragonblocks.setNode(x, y, "air");
  69                 dragonblocks.map.activate(x, y);
  70
  71                 return true;
  72         },
  73
  74         digStart(x, y)
  75         {
  76                 let node = dragonblocks.getNode(x, y);
  77                 let nodeDef = node.toNode();
  78
  79                 node.meta.hardness = nodeDef.hardness;
  80                 node.meta.causedDamage = 0;
  81
  82                 if (! this.canReach(x, y))
  83                         return;
  84
  85                 let crack = document.getElementById("dragonblocks.crack[" + this.id + "]")
  86                 crack.style.visibility = "visible";
  87                 crack.style.left = (x - dragonblocks.map.displayLeft) * dragonblocks.settings.map.scale + "px";
  88                 crack.style.top = (y - dragonblocks.map.displayTop) * dragonblocks.settings.map.scale + "px";
  89
  90                 dragonblocks.log("Punched Node at (" + x + ", " + y + ")");
  91
  92                 nodeDef.onpunch && nodeDef.onpunch(x,y);
  93
  94                 for (let func of dragonblocks.onPunchNodeCallbacks)
  95                         func(x, y);
  96
  97                 dragonblocks.map.activate(x, y);
  98
  99                 this.digTick(x, y);
 100         },
 101
 102         digTick(x, y)
 103         {
 104                 let self = this;
 105
 106                 let node = dragonblocks.getNode(x, y);
 107                 if (! node)
 108                         return;
 109
 110                 let nodeDef = node.toNode();
 111
 112                 let damage = this.tool.calculateDamage(nodeDef);
 113                 if (damage == -1)
 114                         damage = this.tmp.defaultTool.calculateDamage(nodeDef);
 115
 116                 node.meta.hardness -= damage;
 117                 node.meta.causedDamage += damage;
 118
 119                 if (isNaN(node.meta.hardness) || node.meta.hardness <= 0) {
 120                         this.digEnd(x, y);
 121                 } else {
 122                         nodeDef.playSound("dig");
 123
 124                         let crack = document.getElementById("dragonblocks.crack[" + this.id + "]");
 125                         crack.style.background = dragonblocks.getTexture("crack" + Math.floor(node.meta.causedDamage / nodeDef.hardness * 5) + ".png");
 126                         crack.style.backgroundSize = "cover";
 127
 128                         this.tmp.digTimeout = setTimeout(_ => {
 129                                 self.digTick(x, y);
 130                         }, this.tool.interval);
 131                 }
 132         },
 133
 134         digEnd(x, y)
 135         {
 136                 let node = dragonblocks.getNode(x, y);
 137
 138                 if (! node)
 139                         return;
 140
 141                 let nodeDef = node.toNode();
 142
 143                 if (this.dig(x, y))
 144                         dragonblocks.handleNodeDrop(this.tmp.mainInventory, nodeDef, x, y);
 145
 146                 document.getElementById("dragonblocks.crack[" + this.id + "]").style.visibility = "hidden";
 147         },
 148
 149         digStop()
 150         {
 151                 clearTimeout(this.tmp.digTimeout);
 152                 document.getElementById("dragonblocks.crack[" + this.id + "]").style.visibility = "hidden";
 153         },
 154
 155         place(x, y, node)
 156         {
 157                 let oldNode = dragonblocks.getNode(x, y);
 158
 159                 if (! oldNode || oldNode.stable)
 160                         return false;
 161
 162                 if (node.onplace && node.onplace(x, y) == false)
 163                         return false;
 164
 165                 for (let func of dragonblocks.onPlaceNodeCallbacks)
 166                         if (func(node, x, y) == false)
 167                                 return false;
 168
 169                 dragonblocks.setNode(x, y, node);
 170                 dragonblocks.map.activate(x, y);
 171
 172                 node.playSound("place");
 173
 174                 return true;
 175         },
 176
 177         build(x, y)
 178         {
 179                 if(this.canReach(x, y)) {
 180                         let oldNodeDef = dragonblocks.getNode(x, y).toNode();
 181                         oldNodeDef.onclick && oldNodeDef.onclick(x, y);
 182
 183                         for (let func of dragonblocks.onClickNodeCallbacks)
 184                                 func(x, y);
 185
 186                         if (this.touch(x, y))
 187                                 return;
 188
 189                         let wielded = this.getWieldedItem();
 190                         let itemstack = new dragonblocks.ItemStack();
 191
 192                         if(! itemstack.addOne(wielded))
 193                                 return;
 194
 195                         let itemDef = itemstack.toItem();
 196
 197                         if (itemDef instanceof dragonblocks.Node) {
 198                                 if (! this.place(x, y, itemDef) || this.meta.creative)
 199                                         wielded.add(itemstack);
 200                         } else {
 201                                 if (! itemDef.onuse || ! itemDef.onuse(x, y)) {
 202                                         wielded.add(itemstack);
 203                                 } else {
 204                                         for (let func of dragonblocks.onUseItemCallbacks)
 205                                                 func(itemDef, x, y);
 206
 207                                         if (this.meta.creative)
 208                                                 wielded.add(itemstack);
 209                                 }
 210                         }
 211                 }
 212         },
 213
 214         canReach(x, y)
 215         {
 216                 return this.meta.creative || Math.sqrt(Math.pow(x - this.x, 2) + Math.pow(y - this.y, 2)) <= this.tool.range;
 217         }
 218 };
 219
 220 dragonblocks.handleNodeDrop = (inventory, nodeDef, x, y) => {
 221         dragonblocks.dropItem(inventory.add((nodeDef.drops instanceof Function) ? nodeDef.drops() : nodeDef.drops), x + 0.2, y + 0.2);
 222 };