engine/init.js

   1 /*
   2  * init.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 = {};
  25
  26         dragonblocks.backendCall = (call, plain, data) => {
  27                 data = data || {};
  28                 data.call = call;
  29
  30                 let fetchFunc = plain ? $.get : $.getJSON;
  31
  32                 let response = fetchFunc({
  33                         url: "api.php",
  34                         method: "POST",
  35                         data: data,
  36                 });
  37
  38                 return plain ? response.responseText : response.responseJSON;
  39         };
  40
  41         dragonblocks.settings = $.getJSON("settings.json").responseJSON;
  42
  43         let version = dragonblocks.version = $.getJSON("version.json").responseJSON;
  44         version.commit = version.development && (dragonblocks.backendCall("commitID", true) || "?");
  45         version.string = "Dragonblocks "
  46                 + version.major
  47                 + "." + version.minor
  48                 + (version.patch ? "." + version.patch : "")
  49                 + (version.development ? "-dev-" + version.commit : "");
  50
  51         dragonblocks.isChromeApp = window.chrome && chrome.app;
  52
  53         addEventListener("error", event => {
  54                 if (confirm(event.message + "\nStack trace: \n" + event.error.stack + "\nPlease report this to the dragonblocks developers."))
  55                         location.href = version.repo + "/issues/new?"
  56                         + "title=" + encodeURIComponent(event.message)
  57                         + "&body=" + encodeURIComponent(event.error.stack)
  58         });
  59
  60         dragonblocks.backlog = "";
  61
  62         dragonblocks.loadModList = _ => {
  63                 dragonblocks.gamemods = dragonblocks.backendCall("getGamemods");
  64                 dragonblocks.mods = dragonblocks.backendCall("getMods");
  65         };
  66
  67         dragonblocks.loggedin = dragonblocks.backendCall("isLoggedin");
  68         dragonblocks.username = dragonblocks.loggedin ? dragonblocks.backendCall("getUsername", true) : "singleplayer";
  69
  70         dragonblocks.log = text => {
  71                 console.log("[Dragonblocks] " + text);
  72                 dragonblocks.backlog += text + "\n";
  73         };
  74
  75         dragonblocks.error = err => {
  76                 let error = new Error(err);
  77                 dragonblocks.backlog += error;
  78
  79                 throw error;
  80         };
  81
  82         dragonblocks.getToken = _ => {
  83                 return "#" + (Math.random() * 10).toString().replace(".", "");
  84         };
  85
  86         dragonblocks.getModInfo = modname => {
  87                 return dragonblocks.mods[modname] || dragonblocks.gamemods[modname];
  88         };
  89
  90         dragonblocks.getModpath = modname => {
  91                 return dragonblocks.getModInfo(modname).path;
  92         };
  93
  94         let loadingMods = {};
  95
  96         let loadMod = modname => {
  97                 if (loadingMods[modname])
  98                         dragonblocks.error("Circular Mod Dependencies: " + modname);
  99
 100                 if (dragonblocks.loadedMods[modname])
 101                         return;
 102
 103                 let modinfo = dragonblocks.getModInfo(modname);
 104
 105                 if (! modinfo)
 106                         dragonblocks.error("Unresolved Mod Dependencies: " + modname);
 107
 108                 loadingMods[modname] = true;
 109
 110                 for (let dependency of modinfo.dependencies)
 111                         loadMod(dependency);
 112
 113                 $.getScript(modinfo.path + "/init.js");
 114
 115                 dragonblocks.loadedMods[modname] = modinfo;
 116                 loadingMods[modname] = false;
 117         };
 118
 119         dragonblocks.start = selectedMods => {
 120                 dragonblocks.log("Starting");
 121
 122                 for (let func of dragonblocks.onStartCallbacks)
 123                         func();
 124
 125                 setTimeout(_ => {
 126                         dragonblocks.loadedMods = {};
 127
 128                         for (let mod in selectedMods)
 129                                 if (selectedMods[mods])
 130                                         loadMod(mod);
 131
 132                         for (let mod in dragonblocks.gamemods)
 133                                 loadMod(mod);
 134
 135                         dragonblocks.map = new dragonblocks.Map();
 136                         dragonblocks.map.load();
 137
 138                         dragonblocks.player = new dragonblocks.Player();
 139
 140                         dragonblocks.worldIsLoaded || dragonblocks.generateMap();
 141
 142                         for (let func of dragonblocks.onStartedCallbacks)
 143                                 func();
 144                 });
 145         };
 146
 147         dragonblocks.onStartCallbacks = [];
 148         dragonblocks.registerOnStart = func => {
 149                 dragonblocks.onStartCallbacks.push(func);
 150         };
 151
 152         dragonblocks.onStartedCallbacks = [];
 153         dragonblocks.registerOnStarted = func => {
 154                 dragonblocks.onStartedCallbacks.push(func);
 155         };
 156
 157         dragonblocks.quit = _ => {
 158                 for (let func of dragonblocks.onQuitCallbacks)
 159                         func();
 160
 161                 if (dragonblocks.loggedin)
 162                         setTimeout(_ => {
 163                                 dragonblocks.save();
 164                                 location.reload();
 165                         });
 166                 else
 167                         location.reload();
 168         };
 169
 170         dragonblocks.onQuitCallbacks = [];
 171         dragonblocks.registerOnQuit = func => {
 172                 dragonblocks.onQuitCallbacks.push(func);
 173         };
 174
 175         let modules = [
 176                 "assets",
 177                 "key_handler",
 178                 "gui",
 179                 "mapgen",
 180                 "world",
 181                 "item",
 182                 "node",
 183                 "tool",
 184                 "group",
 185                 "builtin",
 186                 "map_node",
 187                 "map",
 188                 "item_stack",
 189                 "inventory",
 190                 "out_stack",
 191                 "inventory_group",
 192                 "hudbar",
 193                 "inventory_container",
 194                 "creative_inventory",
 195                 "recipe",
 196                 "craftfield",
 197                 "menu",
 198                 "skin",
 199                 "entity",
 200                 "map_interaction",
 201                 "spawned_entity",
 202                 "item_entity",
 203                 "falling_node",
 204                 "timer",
 205                 "player",
 206                 "pixel_manipulator",
 207                 "chat",
 208                 "chatcommands",
 209                 "mainmenu",
 210         ];
 211
 212         let moduleCount = modules.length;
 213
 214         let status = document.getElementById("elidragon.status");
 215         let loadbar = document.getElementById("elidragon.loadbar");
 216
 217         let loadNextModuleRecursive = _ => {
 218                 let nextModule = modules.shift();
 219
 220                 if (nextModule) {
 221                         let filename = nextModule + ".js";
 222                         status.innerHTML = filename;
 223
 224                         $.getScript({
 225                                 url: "engine/" + filename,
 226                                 async: true,
 227                                 cache: false,
 228                                 success: _ => {
 229                                         loadbar.style.width = (moduleCount - modules.length) / moduleCount * 100 + "%";
 230                                         loadNextModuleRecursive();
 231                                 },
 232                         });
 233                 }
 234         };
 235
 236         loadNextModuleRecursive();
 237 }