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] = self.map.getScreenCoordinates(event.srcElement.offsetLeft, event.srcElement.offsetTop);
  42                         self.map.getNodeDisplay(x, y).style.boxShadow = "none";
  43                 });
  44
  45                 crack.addEventListener("mouseover", event => {
  46                         let [x, y] = self.map.getScreenCoordinates(event.srcElement.offsetLeft + document.getElementById("dragonblocks.map").offsetLeft, event.srcElement.offsetTop + document.getElementById("dragonblocks.map").offsetTop);
  47                         self.map.getNodeDisplay(x, y).style.boxShadow = "0 0 0 1px black inset";
  48                 });
  49         },
  50
  51         dig(map, x, y)
  52         {
  53                 console.log(this);
  54                 let node = map.getNode(x, y);
  55
  56                 if (! node)
  57                         return false;
  58
  59                 let nodeDef = node.toNode();
  60                 if (nodeDef.ondig && nodeDef.ondig(map, x, y) == false)
  61                         return false;
  62
  63                 nodeDef.playSound("dug");
  64
  65                 map.setNode(x, y, "air");
  66                 map.activate(map, x, y);
  67
  68                 return true;
  69         },
  70
  71         digStart(x, y)
  72         {
  73                 let node = this.map.getNode(x, y);
  74                 let nodeDef = node.toNode();
  75
  76                 node.meta.hardness = nodeDef.hardness;
  77                 node.meta.causedDamage = 0;
  78
  79                 if (! this.canReach(x, y))
  80                         return;
  81
  82                 let crack = document.getElementById("dragonblocks.crack[" + this.id + "]")
  83                 crack.style.visibility = "visible";
  84                 crack.style.left = (x - this.map.displayLeft) * dragonblocks.settings.map.scale + "px";
  85                 crack.style.top = (y - this.map.displayTop) * dragonblocks.settings.map.scale + "px";
  86
  87                 dragonblocks.log("Punched Node at (" + x + ", " + y + ")");
  88
  89                 nodeDef.onpunch && nodeDef.onpunch(this.map, x,y);
  90
  91                 this.map.activate(x, y);
  92
  93                 this.digTick(x, y);
  94         },
  95
  96         digTick(x, y)
  97         {
  98                 let self = this;
  99
 100                 let node = this.map.getNode(x, y);
 101                 if (! node)
 102                         return;
 103
 104                 let nodeDef = node.toNode();
 105
 106                 let damage = this.tool.calculateDamage(nodeDef);
 107                 if (damage == -1)
 108                         damage = this.tmp.defaultTool.calculateDamage(nodeDef);
 109
 110                 node.meta.hardness -= damage;
 111                 node.meta.causedDamage += damage;
 112
 113                 if (isNaN(node.meta.hardness) || node.meta.hardness <= 0) {
 114                         this.digEnd(x, y);
 115                 } else {
 116                         nodeDef.playSound("dig");
 117
 118                         let crack = document.getElementById("dragonblocks.crack[" + this.id + "]");
 119                         crack.style.background = dragonblocks.getTexture("crack" + Math.floor(node.meta.causedDamage / nodeDef.hardness * 5) + ".png");
 120                         crack.style.backgroundSize = "cover";
 121                         crack.style.zIndex = nodeDef.zIndex || "1";
 122
 123                         this.tmp.digTimeout = setTimeout(_ => {
 124                                 self.digTick(x, y);
 125                         }, this.tool.interval);
 126                 }
 127         },
 128
 129         digEnd(x, y)
 130         {
 131                 let node = this.map.getNode(x, y);
 132
 133                 if (! node)
 134                         return;
 135
 136                 let nodeDef = node.toNode();
 137
 138                 if (this.dig(this.map, x, y))
 139                         dragonblocks.handleNodeDrop(this.tmp.mainInventory, nodeDef, this.map, x, y);
 140
 141                 document.getElementById("dragonblocks.crack[" + this.id + "]").style.visibility = "hidden";
 142         },
 143
 144         digStop()
 145         {
 146                 clearTimeout(this.tmp.digTimeout);
 147                 document.getElementById("dragonblocks.crack[" + this.id + "]").style.visibility = "hidden";
 148         },
 149
 150         place(map, x, y, node)
 151         {
 152                 let oldNode = this.map.getNode(x, y);
 153
 154                 if (! oldNode || oldNode.stable)
 155                         return false;
 156
 157                 if (node.onplace && node.onplace(map, x, y) == false)
 158                         return false;
 159
 160                 map.setNode(x, y, node);
 161                 map.activate(x, y);
 162
 163                 node.playSound("place");
 164
 165                 return true;
 166         },
 167
 168         build(x, y)
 169         {
 170                 if(this.canReach(x, y)) {
 171                         let oldNodeDef = this.map.getNode(x, y).toNode();
 172                         oldNodeDef.onclick && oldNodeDef.onclick(this.map, x, y);
 173
 174                         if (this.touch(this.map, x, y))
 175                                 return;
 176
 177                         let wielded = this.getWieldedItem();
 178                         let itemstack = new dragonblocks.ItemStack();
 179
 180                         if(! itemstack.addOne(wielded))
 181                                 return;
 182
 183                         let itemDef = itemstack.toItem();
 184
 185                         if (itemDef instanceof dragonblocks.Node) {
 186                                 if (! this.place(this.map, x, y, itemDef) || this.meta.creative)
 187                                         wielded.add(itemstack);
 188                         } else {
 189                                 if (! itemDef.onuse || ! itemDef.onuse(this.map, x, y))
 190                                         wielded.add(itemstack);
 191                                 else if (this.meta.creative)
 192                                         wielded.add(itemstack);
 193                         }
 194                 }
 195         },
 196
 197         canReach(x, y)
 198         {
 199                 return this.meta.creative || Math.sqrt(Math.pow(x - this.x, 2) + Math.pow(y - this.y, 2)) <= this.tool.range;
 200         }
 201 };
 202
 203 dragonblocks.handleNodeDrop = (inventory, nodeDef, map, x, y) => {
 204         dragonblocks.dropItem(inventory.add((nodeDef.drops instanceof Function) ? nodeDef.drops() : nodeDef.drops), map, x + 0.2, y + 0.2);
 205 };