def add_crash(): log.printMSG("THE GAME CRASHED!!!") traceback.print_exc() try: _add_text("####################################") _add_text("the game crashed") _add_text("\nwith the following mods:") _print_mods() _add_text("\n") add_traceback() _add_text("------------------------------------") _add_text( "you are looking at the informations about the crash. look above for the real crash" ) add_header(head=False) _add_text("------------------------------------") _add_text("these is an redone of the log:") _add_text("++++++++++++++++++++++++++++++++++++") for e in log.CASH: _add_text(" ".join(e)) _add_text("++++++++++++++++++++++++++++++++++++") _add_text("####################################") except: _add_text("????????????????????????????????????") _add_text("EXCEPTION DURING HANDLING EXCEPTION") add_traceback() _add_text("????????????????????????????????????")
def on_end(entry): """ we know that this is stuff around blocks, but we need it to make shour we have all items registrated """ import textures.util textures.util.resize_file( G.local + "/assets/minecraft/textures/missingtexture.png", (32, 32), G.local + "/assets/minecraft/textures/missingtexture.png", ) for b in tuple(G.blockhandler.blocktable.values()): b = b.getName() if not G.blockhandler.blocktable[b].getName( ) in G.itemhandler.itemclasses: if G.blockhandler.blocktable[b].getItemFile(None): file = G.blockhandler.blocktable[b].getItemFile(None) block = b class MissingItem(G.itemclass): def getName(self): return block def getTexturFile(self): return file G.itemhandler.register(MissingItem) else: log.printMSG("[CHECK][ERROR] block " + str(b) + " has no ITEM!!!") register_l_block(G.blockhandler.blocktable[b].getName())
def generateBlocksFromChunkProvider(self, chunk): r = self.random chunkprovider = self.worldprovider.getChunkProviderFor(chunk) log.printMSG("[WORLDGEN][INFO] generating blocks...") i = 0 m = len(chunkprovider.generationcache["blocks_main"]) for e in chunkprovider.generationcache["blocks_main"].keys(): G.model.add_block(e, chunkprovider.generationcache["blocks_main"][e]) if i != 0 and i % 10 == 0: print("\x1b[2K\r", end="") log.printMSG( "[GENERATOR][INFO] added " + str(i) + " blocks. need " + str(m - i) + " more", end="", ) i += 1 for k in chunkprovider.generationcache["blocks"].keys(): G.BlockGenerateTasks[k] = [ chunkprovider.generationcache["blocks"][k] ] print("\x1b[2K\r", end="") chunkprovider.generationcache["blocks"] = {} chunkprovider.generationcache["blocks_main"] = {}
def saveWorld(self, file): log.printMSG( "[SAVER][0.0.0][WARNING] version 0.0.0 is NOT supported. do this on your own risk" ) if not os.path.isdir(file): os.makedirs(file) self.saveDim(G.player.dimension, file + "/DIM" + str(G.player.dimension.id)) playerdata = { "dim": G.player.dimension.id, "pos": G.window.position, "rot": G.window.rotation, "gamemode": G.player.gamemode, "flying": G.window.flying, "selectedinventoryslot": G.player.selectedinventoryslot, } with open(file + "/player.json", mode="w") as f: json.dump(playerdata, f) storagedata = { "version": self.getStorageVersion(), "gameversion": G.VERSION_ID, "gameversionanme": G.VERSION_NAME, "seed": G.seed, } with open(file + "/storage.json", mode="w") as f: json.dump(storagedata, f)
def checkDependecies(self): flag = True for mod in self.mods.values(): versions = mod.getMcPythonVersions() if versions != None: if type(versions) == str: if (versions != G.VERSION_NAME and not "--deactivateversionicompatibles" in sys.argv): log.printMSG("[MODLOADER][ERROR] mod " + str(mod) + " is requiring mc version " + str(versions)) flag = False else: if (not any([x == G.VERSION_NAME for x in versions]) and not "--deactivateversionicompatibles" in sys.argv): log.printMSG("[MODLOADER][ERROR] mod " + str(mod) + " is requiring one of mc versions " + str(versions)) flag = False for e in mod.getDependencies(): if not e[0] in self.mods: log.printMSG("[MODLOADER][ERROR] dependencie error: mod " + str(mod) + " needs mod " + str(e[0])) flag = False elif len(e) > 1: if callable(e[1]): f = e[1]() if not f: flag = False else: modd = self.mods[e[0]] depend_min = e[1][0] if len(e) > 1 else (-1, -1, -1) depend_max = (e[1][1] if len(e) > 1 and len(e[1]) > 1 else modd.getVersion()) depend_func = e[2] if len(e) > 2 else None version_modd = modd.getVersion() if not (depend_min[0] <= version_modd[0] <= depend_max[0] and depend_min[1] <= version_modd[1] <= depend_max[1] and depend_min[2] <= version_modd[2] <= depend_max[2]) and ( (depend_func and depend_func()) or not depend_func): log.printMSG( "[MODLOADER][ERROR] depenencie error: mod " + str(mod) + " needs mod " + str(e[0]) + " in version range " + str([depend_min, depend_max]) + ", but " + str(version_modd) + " is loaded") flag = False if len(e) > 2: f = e[2]() if not f: flag = False if not flag: log.printMSG( "[MODLOADER][ERROR] there were errors in mod initialisation phase. NOT beginning loading phase" ) sys.exit(-1)
def __init__(self, file, format="json"): if format == "old": self.data = _decodeOLD(file) elif format == "json": self.data = _decodeJSON(file) else: log.printMSG("[LANGUAGE][ERROR] can't load lang file " + str(file)) G.eventhandler.call("game:registry:on_language_registered", self)
def add_scoreboard(self, name, scoreboardtype, *args, **kwargs): if scoreboardtype not in self.scoreboardtypes: log.printMSG("[SCOREBOARDHANDLER][ERROR] type " + str(scoreboardtype) + " is unknown") return self.scoreboards[name] = self.scoreboardtypes[scoreboardtype](name, *args, **kwargs)
def saveWorld(self, file, version="latest"): if version == "latest": version = self.latest if not version in self.versions: log.printMSG("[WORLDSAVER][ERROR] version is not supported") return obj = self.versions[version] obj["saver"].saveWorld(file)
def remove_scoreboard(self, name): if name not in self.scoreboards: log.printMSG( "[SCOREBOARDHANDLER][ERROR] can't remove scoreboard named " + str(name) + ". These scoreboard" + " is not created.") return self.scoreboards[name].delete() del self.scoreboards[name]
def setState(self, name): if not name in self.states: log.printMSG("[STATEHANDLER][ERROR] can't access state named " + str(name)) return if self.active_state: self.active_state.deactivate() self.active_state = self.states[name] self.active_state.activate()
def update(self, dt): """This method is scheduled to be called repeatedly by the pyglet clock. Parameters ---------- dt : float The change in time since the last call. """ G.model.process_queue() sector = mathhelper.sectorize(self.position) if (sector != self.sector and G.statehandler.active_state.getName() == "minecraft:game"): G.model.change_sectors(self.sector, sector) if self.sector is None: G.model.process_entire_queue() self.sector = sector m = 8 dt = min(dt, 0.2) for _ in range(m): self._update(dt / m) for entity in G.entityhandler.entitys: entity.update(dt) G.eventhandler.call("core:update") if G.statehandler.active_state.getName() == "minecraft:game": self.time += dt * 20 self.day += round(self.time // 24000) self.time = round(self.time % 24000) if G.GAMESTAGE != 3: return i = 0 max = len(G.BlockGenerateTasks) l = list(G.BlockGenerateTasks.keys()) t = time.time() for position in l: G.model.add_block(position, G.BlockGenerateTasks[position][0], immediate=True) task = G.BlockGenerateTasks[position] if len(task) > 1: task = task[1:] while len(task) > 0: st = task.pop(0) cx, _, cz = mathhelper.sectorize(position) chunkprovider = ( G.player.dimension.worldprovider.getChunkProviderFor( (cx, cz))) if st == "sdata": chunkprovider.world[position].setStorageData( task.pop(0)) else: log.printMSG("[TASKS][ERROR] unknown subtask " + str(st)) del G.BlockGenerateTasks[position] if time.time() - t > 0.1: return
def execute(self, command): splitted = command.split(" ") if len(command) > 0 and command[0] != "/": log.printMSG("[CHAT] " + command) return else: G.commandhandler.executeCommand(command, G.player.entity, G.window.position) return
def __init__(self, name, *args, **kwargs): self.name = name if hasattr(self, "create"): self.create(*args, **kwargs) elif len(args) + len(kwargs) > 0: log.printMSG( "[SCOREBOARD][ERROR] getted arguments for scoreboard typed as " + str(type(self)) + " but it has no create-function for analysing it") return
def addEventName(self, name, msg=True): """ adds an new eventname :param name: the name of the event """ if name in self.eventnames: if msg: log.printMSG("[EVENTHANDLER][ERROR] try to add event named " + str(name) + ", but it is known") return self.eventnames[name] = []
def saveDim(self, dim, file): if not os.path.isdir(file): os.makedirs(file) if dim != G.player.dimension: log.printMSG( "[WORLDSAVER][0.0.0][ERROR] can't save unloaded dim " + str(dim)) return for cx, cz in G.player.dimension.worldprovider.chunkproviders.keys(): self.saveChunk(cx, cz, file + "/" + str(cx) + "." + str(cz) + ".chunk")
def executeCommand(command, entity, position): splitted = command.split(" ") if len(splitted) > 1: d = G.local + "/saves/" + splitted[1] elif G.window.worldname: d = G.window.worldname else: log.printMSG("[COMMANDPARSER][SAVE][ERROR] unknown dirname") return G.window.worldname = d G.storagehandler.saveWorld(d)
def searchForMods(self): # print(EVENTLIST, EVENTENTRYLIST) mods = self.getModDirs() self.loadMods(mods) self.checkDependecies() sorter = ModSorter.ModSorter(self.mods) sorter.sort() log.printMSG("[MODLOADER] we will load mods in the following order:") for mod in sorter.modlistsorted: log.printMSG(" :" + str(mod.getUserFriendlyName())) self.bind_events(sorter) self.call_events(sorter)
def removeEvent(self, name): """ remove an event :param name: the name of the event to remove """ if not name in self.eventnames: log.printMSG( "[EVENTHANDLER][ERROR] try to remove an unknown event: " + str(name)) return self.clearEvent(name) del self.eventnames[name]
def remove_on_event(self, id): """ unbinds an function to an event :param id: the id of the binding """ if not id in self.functions: log.printMSG( "[EVENTHANDLER][ERROR] try to remove an unknown function " + str(id)) return self.eventnames[self.functions[id][1]].remove(id) del self.functions[id]
def clearEvent(self, name): """ clear all functions to an event :param name: the name of the event to clear """ if not name in self.eventnames: log.printMSG( "[EVENTHANDLER][ERROR] try to clear an unknown event: " + str(name)) return for e in self.eventnames[name]: del self.functions[e] self.eventnames[name] = []
def __init__(self, name, amount=1): self.update_func = None self.slot = None if type(name) == str: self.name = name item = G.itemhandler.getByName(name) if item: self.item = item() self.amount = amount else: log.printMSG("[IItemStack][ERROR] item unknown (named " + str(name) + ")") self.item = None self.amount = 0 elif type(name) == G.itemclass: self.name = name.getName() self.item = name elif name == None: self.name = None self.item = None else: log.printMSG("[IItemStack][ERROR] can't set item " + str(name)) self.name = None self.item = None self.__amount = amount if self.item: textures.util.resize_file(self.item.getTexturFile(), (32, 32)) self.image = pyglet.sprite.Sprite( pyglet.image.load(self.item.getTexturFile())) """texturslitcher.ImageAtlas.save_image( texturslitcher.ImageAtlas.resize( texturslitcher.ImageAtlas.load_image(self.item.getTexturFile()), (32, 32) ), self.item.getTexturFile() ) texturslitcher.ImageAtlas.resize(image, (32, 32)) texturslitcher.ImageAtlas.save_image(image, self.item.getTexturFile()) #texturhandler.resize(self.item.getTexturFile(), (32, 32), self.item.getTexturFile()) self.image = pyglet.sprite.Sprite(pyglet.image.load(self.item.getTexturFile()))""" else: self.image = None self.texturfile = self.item.getTexturFile() if self.item else None self.lable = pyglet.text.Label( "", font_name="Arial", font_size=10, anchor_x="left", anchor_y="top", color=(255, 255, 255, 255), )
def hide_inventory(self, id): """hides the inventory""" if type(id) != int: id = id.id self.inventorys[id].active = False self.inventorys[id].on_hide() if id not in self.activeinventorys: log.printMSG("[ERROR]") return self.activeinventorys.remove(id) if type(self.inventorys[id]) == InventoryCollection: for e in self.activeated[id]: del self.activeated[id] self.hide_inventory(e)
def _initialize(self, *args): """Initialize the world by placing all the blocks.""" log.printMSG("[MAINTHREAD][WINDOW][MODEL][INFO] generating world...") import world.OverWorld G.dimensionhandler.register(world.OverWorld.OverWorld) G.dimensionhandler.dimensions[0].join() G.player.dimension = G.dimensionhandler.dimensions[0] G.dimensionhandler.prepare() G.GAMESTAGE = 3 self.change_sectors(None, G.window.get_motion_vector())
def saveChunk(self, cx, cz, file): if not (cx, cz) in G.player.dimension.worldprovider.chunkproviders: log.printMSG( "[WORLDSAVER][0.0.0][ERROR] can't save unloaded chunk " + str(cx, cz)) return chunkdata = {} chunkprovider = G.player.dimension.worldprovider.getChunkProviderFor( (cx, cz)) for position in chunkprovider.world.keys(): block = chunkprovider.world[position] chunkdata[str(self._transformposition( cx, cz, *position))] = block.getStorageData() with open(file, mode="wb") as f: pickle.dump(chunkdata, f)
def prepare(self): if not config.WorldGenerator.USED_DEBUG_GEN: for cx in range(*self.WORLDSIZE[0]): for cz in range(*self.WORLDSIZE[1]): log.printMSG( "[OVERWORLD][GENERATOR][INFO] generating chunk " + str(cx) + "|" + str(cz) ) self.worldprovider.generateChunkFor((cx, cz)) else: self.worldprovider.generateChunkFor((0, 0)) print(gen.DebugWorldGenerator.BLOCKTABLE.keys()) for chunk in gen.DebugWorldGenerator.BLOCKTABLE.keys(): self.worldprovider.generateChunkFor(chunk)
def loadChunk(self, cx, cz, file): log.printMSG(cx, cz) with open(file, mode="rb") as f: chunkdata = pickle.load(f) mx, mz = int(cx), int(cz) for rpos in chunkdata.keys(): x, y, z = rpos.split(",") x = int(x[1:]) y = int(y[1:]) z = int(z[1:-1]) pos = (x + mx * 16, y, z + mz * 16) G.BlockGenerateTasks[pos] = [ chunkdata[rpos]["name"], "sdata", chunkdata[rpos], ]
def on_key_press(self, symbol, modifiers): G.window.strafe = [0, 0] if symbol in [65505]: return elif symbol == config.Keyboard.CLOSE: self.text = "" self.commandpointer = -1 G.inventoryhandler.hide_inventory(self.id) elif symbol == config.Keyboard.RUN_COMMAND: self.execute(self.text) self.commandindex.insert(0, self.text) self.commandpointer = -1 self.text = "" G.inventoryhandler.hide_inventory(self.id) elif symbol == 65288: self.text = self.text[:-1] elif symbol == 65507 and (modifiers & key.MOD_CTRL): clipboard.copy(self.text) return elif symbol == key.V and (modifiers & key.MOD_CTRL): self.text += clipboard.paste() return elif symbol == key.D and (modifiers & key.MOD_CTRL): self.text = "" return elif modifiers & key.MOD_SHIFT: if symbol in KEYDICT[1]: self.text += KEYDICT[1][symbol] else: log.printMSG("[CHAT][ERROR] can't interpet key " + str(symbol) + " with SHIFT") elif modifiers & key.MOD_ALT: if symbol in KEYDICT[2]: self.text += KEYDICT[2][symbol] else: log.printMSG("[CHAT][ERROR] can't interpet key " + str(symbol) + " with ALT") elif symbol in KEYDICT[0]: self.text += KEYDICT[0][symbol] elif symbol == key.TAB: log.printMSG("[CHAT][WARN] complet of commands are not supported") elif symbol == key.UP: if self.commandpointer + 1 < len(self.commandindex): self.commandpointer += 1 self.text = self.commandindex[self.commandpointer] elif symbol == key.DOWN: if self.commandpointer > 0: self.commandpointer -= 1 self.text = self.commandindex[self.commandpointer] elif self.commandpointer != -1: self.commandpointer = -1 else: log.printMSG("[CHAT][ERROR] can't interpet key " + str(symbol) + " with modifiers: " + str(modifiers)) G.window.strafe = [0, 0]
def check_inventory(self, inventory): if not issubclass( type(inventory), crafting.ICraftingInventory.ICraftingInventory ): log.printMSG( "[CRAFTINGHANDLER][INFO] can't check inventory " + str(inventory) + ". Inventory is not an crafting inventory" ) return inventory.active_recipe = None for e in inventory.get_grid_names(): for slotarray in inventory.get_slot_arrays(e): recipe = inventory.check_recipes(self.recipes[e], slotarray) if recipe: inventory.set_output(inventory.get_output_for_recipe(recipe)) return inventory.clear_output()
def __init__(self, file, format="old"): if format == "old": self.data = _decodeOLD(file) elif format == "json": self.data = _decodeJSON(file) else: log.printMSG("[LANGUAGE][ERROR] can't load lang extension file " + str(file)) self.data = {} self.name = file.split("/")[-1].split(".")[0] if hasattr(G.LANG, self.name): getattr(G.LANG, self.name)._applyExtenstion(self) else: setattr( G.LANG, file.split("/")[-1].split(".")[0], LanguageFile(file, format="old"), )
def on_event(self, name, *args): if name == "opengl:draw2d": # G.window.set_size(1200, 620) G.window.set_exclusive_mouse(False) self.image1.draw() self.lable1.x = 90 self.lable1.y = 3 self.lable1.draw() self.lable2.x = 555 self.lable2.y = 358 self.lable2.draw() self.lable3.x = 550 self.lable3.y = 318 self.lable3.draw() self.lable4.x = 610 self.lable4.y = 210 self.lable4.draw() elif name == "core:window:on_mouse_press": x, y, button, mod = args if x >= 424 and y >= 348 and x <= 777 and y <= 381: G.window.flying = True G.window.position = (0, 4000, 0) G.dimensionhandler.generateclasses() G.player.dimension = G.dimensionhandler.dimensions[0] G.eventhandler.call("worldgen:newworld") G.window.time = 0 G.window.day = 0 chunk = (0, 0) x, y = random.randint(0, 15), random.randint(0, 15) x += chunk[0] * 16 y += chunk[1] * 16 G.window.position = (0, 255, 0) G.player.gamemode = 1 G.window.flying = True G.SPAWNPOINT = G.window.position G.window.rotation = (0, 0) G.window.flying = False G.statehandler.setState("minecraft:game") elif x >= 550 and y >= 318 and x <= 777 and y <= 338: log.printMSG("[TITLESCREEN][ERROR] multiplayer is NOT arrival") elif x >= 605 and y >= 200 and x <= 777 and y <= 234: G.window.close() else: log.printMSG(args)