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 dragonblocks.MapIntercation = {
  24         initMapInteraction(){
  25                 let self = this;
  26                 let crack = document.createElement("div");
  27                 crack.id = "dragonblocks.crack[" + this.id + "]";
  28                 crack.style.position = "absolute";
  29                 crack.style.visibility = "hidden";
  30                 crack.style.backgroundSize = "cover";
  31                 crack.style.height = dragonblocks.settings.map.scale + "px";
  32                 crack.style.width = dragonblocks.settings.map.scale + "px";
  33                 crack.style.boxShadow = "0 0 0 1px black inset";
  34                 crack.style.zIndex = 2;
  35                 crack.addEventListener("mouseleave", event => {
  36                         self.digStop();
  37                         let [x, y] = dragonblocks.map.getCoordinate(event.srcElement.offsetLeft, event.srcElement.offsetTop);
  38                         dragonblocks.map.getNodeGraphics(x, y).style.boxShadow = "none";
  39                 });
  40                 crack.addEventListener("mouseover", event => {
  41                         let [x, y] = dragonblocks.map.getCoordinate(event.srcElement.offsetLeft + document.getElementById("dragonblocks.map").offsetLeft, event.srcElement.offsetTop + document.getElementById("dragonblocks.map").offsetTop);
  42                         dragonblocks.map.getNodeGraphics(x, y).style.boxShadow = "0 0 0 1px black inset";
  43                 });
  44                 document.getElementById("dragonblocks.map").appendChild(crack);
  45         },
  46         dig(x, y){
  47                 let mapNode = dragonblocks.getNode(x, y);
  48                 if(! mapNode)
  49                         return false;
  50                 let node = mapNode.toNode();
  51                 if(node.ondig && node.ondig(x, y) == false)
  52                         return false;
  53                 for(let func of dragonblocks.onDigNodeFunctions)
  54                         if(func(x, y) == false)
  55                                 return false;
  56                 node.playSound("dug");
  57                 dragonblocks.setNode(x, y, "air");
  58                 dragonblocks.map.activate(x, y);
  59                 return true;
  60         },
  61         digStart(x, y){
  62                 let mapNode = dragonblocks.getNode(x, y);
  63                 let node = mapNode.toNode();
  64                 mapNode.meta.hardness = node.hardness;
  65                 mapNode.meta.causedDamage = 0;
  66                 if(! this.canReach(x, y))
  67                         return;
  68                 let crack = document.getElementById("dragonblocks.crack[" + this.id + "]")
  69                 crack.style.visibility = "visible";
  70                 crack.style.left = (x - dragonblocks.map.displayLeft) * dragonblocks.settings.map.scale + "px";
  71                 crack.style.top = (y - dragonblocks.map.displayTop) * dragonblocks.settings.map.scale + "px";
  72                 dragonblocks.log("Punched Node at (" + x + ", " + y + ")");
  73                 node.onpunch && node.onpunch(x,y);
  74                 for(let func of dragonblocks.onPunchNodeFunctions)
  75                         func(x, y);
  76                 dragonblocks.map.activate(x, y);
  77                 this.digTick(x, y);
  78         },
  79         digTick(x, y){
  80                 let self = this;
  81                 let mapNode = dragonblocks.getNode(x, y);
  82                 if(! mapNode)
  83                         return;
  84                 let node = mapNode.toNode();
  85                 let damage = this.tool.calculateDamage(node);
  86                 if(damage == -1)
  87                         damage = this.tmp.defaultTool.calculateDamage(node);
  88                 mapNode.meta.hardness -= damage;
  89                 mapNode.meta.causedDamage += damage;
  90                 if(mapNode.meta.hardness <= 0 || isNaN(mapNode.meta.hardness))
  91                         this.digEnd(x, y);
  92                 else{
  93                         node.playSound("dig");
  94                         let crack = document.getElementById("dragonblocks.crack[" + this.id + "]");
  95                         crack.style.background = dragonblocks.getTexture("crack" + Math.floor(mapNode.meta.causedDamage / mapNode.toNode().hardness * 5) + ".png");
  96                         crack.style.backgroundSize = "cover";
  97                         this.tmp.digTimeout = setTimeout(_ => { self.digTick(x, y) }, this.tool.interval);
  98                 }
  99         },
 100         digEnd(x, y){
 101                 let mapNode = dragonblocks.getNode(x, y);
 102                 if(! mapNode)
 103                         return;
 104                 let node = mapNode.toNode();
 105                 if(this.dig(x, y)){
 106                         if(node.drops instanceof Function)
 107                                 this.tmp.mainInventory.add(node.drops());
 108                         else
 109                                 this.tmp.mainInventory.add(node.drops);
 110                 }
 111                 document.getElementById("dragonblocks.crack[" + this.id + "]").style.visibility = "hidden";
 112         },
 113         digStop(){
 114                 clearTimeout(this.tmp.digTimeout);
 115                 document.getElementById("dragonblocks.crack[" + this.id + "]").style.visibility = "hidden";
 116         },
 117         place(x, y, node){
 118                 if(! dragonblocks.getNode(x, y) || dragonblocks.getNode(x, y).stable)
 119                         return false;
 120                 if(node.onplace && node.onplace(x, y) == false)
 121                         return false;
 122                 for(let func of dragonblocks.onPlaceNodeFunctions)
 123                         if(func(node, x, y) == false)
 124                                 return false;
 125                 dragonblocks.setNode(x, y, node);
 126                 dragonblocks.map.activate(x, y);
 127                 node.playSound("place");
 128                 return true;
 129         },
 130         build(x, y){
 131                 if(this.canReach(x, y)){
 132                         let old = dragonblocks.getNode(x, y).toNode();
 133                         old.onclick && old.onclick(x, y);
 134                         for(let func of dragonblocks.onClickNodeFunctions)
 135                                 func(x, y);
 136                         if(this.touch(x, y))
 137                                 return;
 138                         var buildstack = dragonblocks.createItemstack();
 139                         if(! buildstack.addOne(this.getWieldedItem()))
 140                                 return;
 141                         if(buildstack.toItem() instanceof dragonblocks.Node){
 142                                 if(! this.place(x, y, buildstack.toItem()) || this.meta.creative)
 143                                         this.getWieldedItem().add(buildstack);
 144                         }
 145                         else{
 146                                 if(! buildstack.toItem().onuse || ! buildstack.toItem().onuse(x, y))
 147                                         this.getWieldedItem().add(buildstack);
 148                                 else{
 149                                         for(let func of dragonblocks.onUseItemFunctions)
 150                                                 func(buildstack.toItem(), x, y);
 151                                         if(this.meta.creative)
 152                                                 this.getWieldedItem().add(buildstack);
 153                                 }
 154                         }
 155                 }
 156         },
 157         canReach(x, y){
 158                 return (Math.sqrt(Math.pow(x - this.x, 2) + Math.pow(y - this.y, 2)) <= this.tool.range) || this.meta.creative;
 159         },
 160 }