def loadGenericObj(filepath, extension=None): #includes fixing file extension and doing inheritence if filepath is None: return {FILE_EXTENSION: extension, CLASS_TYPE: DEFAULT_CLASS_TYPE} filepathstr = toStringPath(filepath) #turn into string filepathlist = toListPath(filepath) #make sure we have a list too if extension is not None and extension not in filepathstr: filepathstr += extension if filepathstr not in LoadedData: obj = load_object_no_class(filepathstr, False) if PROP_KEY in list(obj.keys()): if obj[PROP_KEY] == filepathlist[-1]: debugMessage( "infinitely recursive prop detected! Did you use prop instead of type?" ) debugMessage(filepathstr) else: obj = updateNestedDict( loadGenericObj(filepathlist[:-1] + [obj[PROP_KEY]], extension), obj) obj.pop(PROP_KEY) obj = _load_object_add_class(obj, filepathstr) LoadedData[filepathstr] = copy.deepcopy(obj) else: obj = copy.deepcopy(LoadedData[filepathstr]) return obj
def playAudio(file_path=None, channel="special", thread_loading=True, loop=False, start=0, end=None, loop_start=0, fade_in=None, fade_out=None, crossfade=None, start_paused=False): try: file_handle = loadResource(file_path) except ResourceUnavailableError as e: debugMessage(e) debugMessage("Couldn't load resource: " + file_path) else: event_loop = getGameScheduler() _currently_playing.append( asyncio.create_task( _play_from_file(file_handle, event_loop, thread_loading=thread_loading, loop=loop, start=start, end=end, loop_start=loop_start, fade_in=fade_in, fade_out=fade_out, crossfade=crossfade, start_paused=start_paused)))
def _setGlowImage(self, image_path): try: self.set_image_from_buffer(self._GetGlowTexID(image_path), *self._CreateTexture(image_path)) except ResourceUnavailableError: debugMessage( "Failure to create glow image. Might be due to current incompatibility with dynamic textures (ttf text, etc)." )
def setupContainer(self, objname): if hasattr(self, objname): self._ContainerObjs = [ objname ] + self._ContainerObjs #done this way instead of insert to make sure it's a new list else: debugMessage( "you misspelled the name of your attribute in a container, or it doesn't exist yet: " + objname)
def create_font_size(self, font_size): if self.path is not None: try: self.font_sizes[font_size] = ImageFont.truetype( loadResource(self.path), font_size) except ResourceUnavailableError: debugMessage( "WARNING: Could not create font size due to resource error: %s" % self.path) raise ResourceUnavailableError
def getActorByIndex(self, actorindex, suppress_error=False): try: return self.actors[actorindex] except KeyError: if not (suppress_error or self.destroyed): debugMessage( "actor not found in scene when queried by index: " + str(actorindex)) raise return None
def __getattr__(self, name): for obj in self._ContainerObjs: try: return getattr(getattr(self, obj), name) except AttributeError: pass except RuntimeError: #infinite loop detected: self.removeContainer(obj) debugMessage("Infinite loop detected in container. " + obj + " key removed.") raise AttributeError("Attribute not found: " + name)
def init(): event.addGameCloseListener(close) if checkDebugOn(): debugMessage("WARNING: Launching in debug mode") #setup main window and initialize drivers setupWindowBasic("logo.png") setupDrivers() initGamestate() initializeGameFrames(main_loop)
def updateCameraSprites(self): x = self.getX() y = self.getY() if self._oldx != x or self._oldy != y: for key, sprite in list(self.camera_sprites.items()): #cast to list so we can remove keys if there's an exception try: sprite().updateWithCamera(x,y) #method(sprite(), x, y) except Exception as e: debugMessage(e) debugMessage("Camera sprite update function broke. Removed object that was following the camera? deleting") self.removeCameraSprite(key) self._oldx = x self._oldy = y
def runDelayedEvents(): global _currently_running_events _currently_running_events = True for priority, data in list(_delayed_events.items()): #listified to prevent errors when undelaying things in a delayed action for key, val in list(data.items()): listener, args, kwargs, ID = val try: listener(*args, **kwargs) except: import traceback from kaiengine.debug import debugMessage debugMessage("Error in delayed event.") traceback.print_exc() _removeAllDelayEvents() _currently_running_events = False
def setFocus(self, child): #pass None to clear focus try: ID = child.id except AttributeError: ID = child if ID != self._focused_child_id: oldfocus = self.getFocusedChild() if oldfocus: oldfocus._loseFocus() self._focused_child_id = ID if ID is not None: if ID in self._children: self.getChild(ID)._gainFocus() else: debugMessage("Probable error: child ID not found when setting focus: " + str(ID)) self._focused_child_id = None
def _realtimeEventRun(event, *args, **kwargs): try: event.listener(getGameScheduler().time() - event.scheduler_time, *args, **kwargs) except: from kaiengine.debug import debugMessage import traceback debugMessage( "Something broke with a scheduled realtime listener; deleting it.") traceback.print_exc() event.repeating = False #stop it from repeating _cleanupRealtimeScheduledEvent(event.eventid) if not event._destroyed: if event.repeating: _scheduleRealtimeWithEvent(event, *args, **kwargs) else: _destroyRealtimeEvent(event.eventid)
def setupWindow(fullscreen=None, x=None, y=None, fake_fullscreen=None): from . import settings #initial setup of the main window if fake_fullscreen is None: try: fake_fullscreen = settings.getValue( DYNAMIC_SETTINGS_FAKE_FULLSCREEN) except: pass if fake_fullscreen: x, y = sGraphics.getScreenResolution() try: multiplier = x / settings.getValue( DYNAMIC_SETTINGS_WINDOW_DIMENSIONS)[0] ymultiplier = y / settings.getValue( DYNAMIC_SETTINGS_WINDOW_DIMENSIONS)[1] if multiplier != ymultiplier: debugMessage( "WARNING: screen aspect ratio does not match for fake fullscreen! Setting to lower of possible values to avoid cutoff." ) multiplier = min(multiplier, ymultiplier) except: debugMessage( "WARNING: Error calculating multiplier for fake fullscreen (also check DYAMIC_SETTINGS_WINDOW_DIMENSIONS):\nWidth {0}\nHeight{1}" .format(x, y)) multiplier = 1 setGlobalScaling(multiplier) settings.setValue(DYNAMIC_SETTINGS_GLOBAL_SCALING, multiplier) sGraphics.graphicsInitWindow( main_window(x, y, None, fake_fullscreen=True)) #TODO: location to correct one for 2nd monitors, etc getWindow().set_location(0, 0) else: if x is None: x = int( settings.getValue(DYNAMIC_SETTINGS_WINDOW_DIMENSIONS)[0] * settings.getValue(DYNAMIC_SETTINGS_GLOBAL_SCALING)) if y is None: y = int( settings.getValue(DYNAMIC_SETTINGS_WINDOW_DIMENSIONS)[1] * settings.getValue(DYNAMIC_SETTINGS_GLOBAL_SCALING)) if fullscreen is None: fullscreen = settings.getValue(DYNAMIC_SETTINGS_FULLSCREEN) sGraphics.graphicsInitWindow(main_window(x, y, fullscreen))
def add_font(self, font_path, font_size=None): font_path = fontglobals.getFontPath(font_path) if font_path not in self.fonts: if TTF_EXTENSION == os.path.splitext(font_path)[1]: if font_size is None: font_size = MENU_TEXT_SIZE self.fonts[font_path] = TTFFont(font_path, font_size) return if GRAPHIC_FONT_EXTENSION == os.path.splitext(font_path)[1]: self.fonts[font_path] = GraphicFont(font_path) return if GRAPHIC_FONT_2_EXTENSION == os.path.splitext(font_path)[1]: self.fonts[font_path] = GraphicFont2(font_path) return if GRAPHIC_FONT_3_EXTENSION == os.path.splitext(font_path)[1]: self.fonts[font_path] = GraphicFont3(font_path) return debugMessage("Font not found: " + font_path) debugMessage("Did you remember to include the extension?")
def setAnimation(self, anikey = None, reset = True, default = None, starting_time = 0.0): if anikey is None: anikey = self.default_ani if anikey in self.animations: self._set_animation(anikey, reset, starting_time) else: errorstring = "" if default is None: #suppress printing this error if a default was defined errorstring = str(anikey) + " animation key not found. " if default is False: #passing a false will skip changing the animation at all return else: default = self.default_ani if default in self.animations: self._set_animation(default,reset, starting_time) else: errorstring += "Moreover, default key " + str(default) + " not found." if errorstring: debugMessage(errorstring)
def dumpScreenshot(screenshotPath=None, screenshotDir=None): """Take a screenshot and save it to a specified or default path.""" originalDir = os.getcwd() try: screenshot = takeScreenshot() if screenshotDir is not None: os.chdir(screenshotDir) if screenshotPath is None: index = 1 while os.path.exists("screenshot%05i.png" % index): index += 1 screenshotPath = "screenshot%05i.png" % index try: screenshot.save(screenshotPath) except IOError as e: debugMessage("Screenshot I/O error({0}): {1}".format( e.errno, e.strerror)) finally: os.chdir(originalDir)
def init(): event.addGameCloseListener(close) if checkDebugOn(): debugMessage("WARNING: Launching in debug mode") setupWindowBasic("logo.png") setupDrivers() keyevents.InitKeys() AGE.InitGame() AGE.SetMapDimensions(40, 40) AGE.SetTile([10, 0], GRASS_LAYER, 0, 0, 40, 40, COLOR_GREEN, COLOR_DARK_GREEN) # fill with grass AGE.InstantFadeIn() gamestate.glob.init() #AGE.SetBackgroundColor(COLOR_DARK_GREEN) initializeGameFrames(main_loop)
def createGraphic(path, layer=-1, *args, **kwargs): #generic loader for all graphic types if path is None: return createSprite(path, layer, *args, **kwargs) path = toStringPath(path) ext = os.path.splitext(path)[1] if ext == PNG_EXTENSION: return createSprite(path, layer, *args, **kwargs) if ext == GRAPHIC_OBJECT_EXTENSION: return createGraphicObject(path, layer, *args, **kwargs) if ext == LABEL_OBJECT_EXTENSION: return createLabelObject(path, layer, *args, **kwargs) if ext == BORDERED_SPRITE_EXTENSION: return createBorderedSprite(path, layer, *args, **kwargs) if ext == MULTI_SPRITE_EXTENSION: return createMultiSprite(path, layer, *args, **kwargs) debugMessage("graphic of unsupported format: " + path) if len(ext) == 0: debugMessage("You forgot to include the extension, methinks") return None
def findClasses(classdict, packname, defaultclass): if not classdict: try: pack = loadPackage(packname) except Exception as e: import traceback traceback.print_stack() debugMessage(e) return None #debugMessage(pack.__dict__) #debugMessage(os.listdir(pack.__path__[0])) classdict[DEFAULT_CLASS_TYPE] = defaultclass for importer, modname, ispkg in pkgutil.iter_modules(pack.__path__, pack.__package__ + "."): mod = importlib.import_module(modname, ".") if mod and hasMainClass(mod): try: classdict[mod.MainClass.type] = mod.MainClass except AttributeError: #hackish way to get rid of the package name from __name__ but oh well classdict[os.path.splitext(mod.__name__)[1][1:]] = mod.MainClass return classdict
def call_listener(self, *args, **kwargs): try: return self.listener(*args, **kwargs) except Exception as e: debugMessage(traceback.format_exc()) debugMessage("something broke with an event listener; deleting it") debugMessage(e) self.delete_me = True
def saveToFile(self): try: serialized = self._altered_values jsondumps(serialized) except Exception as e: from kaiengine.debug import debugMessage debugMessage("Settings serialization error:") debugMessage(e) else: try: jsondump(serialized, toStringPath(self.getFullFilepath())) except Exception as e: from kaiengine.debug import debugMessage debugMessage("Settings file save error:") debugMessage(e)
def endHangTime(self): self.unschedule(self.endHangTime) scene_type = None args = None kwargs = None while scene_type is None: try: data = self._next_scenes.pop(0) except IndexError: break try: scene_type, args, kwargs = data except ValueError: from kaiengine.debug import debugMessage debugMessage( "Cannot unpack scene data. Requires 3 arguments (scene_type, args, kwargs)." ) debugMessage(data) if scene_type is None: self.fadeToPreviousScene(self._fade_out_time) else: kwargs["next_scenes"] = self._next_scenes self.fadeToScene(scene_type, self._fade_out_time, True, args, kwargs)
def finishAnimationCapture(savePath=None): """Complete animation capture and save frames to disk.""" global screenshot_data unschedule(_captureAnimation) #unschedule if needed if not screenshot_data: #check if we don't have any available capture data return if savePath is None: index = 1 while os.path.exists("animation%05i.gif" % index): index += 1 savePath = "animation%05i.gif" % index try: screenshot_data[0].save(savePath, save_all=True, append_images=screenshot_data[1:], loop=0, duration=25) except IOError as e: debugMessage("Animation I/O error({0}): {1}".format( e.errno, e.strerror)) screenshot_data = []
def loadActors(self): for actordict in self.actor_list: try: newactor = self.getActorFactory(actordict)(actordict.pop( ACTOR_TYPE, None), self) pos = actordict.pop(ACTOR_POS) self.addActor(newactor) newactor.setPos(*pos) newsprite = actordict.pop(ACTOR_SPRITE, None) if newsprite != "" and newsprite != None: newactor.setSprite(newsprite) newactor.setExtraData(actordict) except Exception as e: debugMessage("Failed to create map actor!") debugMessage(e) debugMessage(actordict)
def loadTilemap(self): self.clearMapTiles() for tile in self.tile_data_list: try: pos = tuple(tile[MAPTILE_POS]) self.tile_data_map[pos] = self.createMapTileData( maptile_data=tile) except KeyError: debugMessage("Map tile data lacked position.") debugMessage(str(tile)) for layer, tilelist in self.tile_graphic_dict.items(): layer = int(layer) #since probably a string for tile in tilelist: try: pos = tuple(tile[MAPTILE_POS]) tilechild = self.addChild( self.createMapTileGraphic(maptile_data=tile), False) self.tile_graphics_map[layer][pos] = tilechild.id tilechild.setElementPosition(pos[0] * self.tile_width, pos[1] * self.tile_height) except KeyError: debugMessage("Map tile graphic lacked position.") debugMessage(str(tile))
def call_listener(self): if self._unscheduled: self.delete_me = True return if self.paused: return try: if self.listener(*self.args, **self.kwargs): self.delete_me = True except Exception as e: from kaiengine.debug import debugMessage debugMessage(traceback.format_exc()) debugMessage( "something broke with a scheduled listener; deleting it") debugMessage(e) self.delete_me = True if not self.repeating: self.delete_me = True
SHADERS_AVAILABLE = True try: base_vertex_shader = shaders.compileShader(BASE_VERTEX_SHADER, GL_VERTEX_SHADER) base_screen_vertex_shader = shaders.compileShader(BASE_SVERTEX_SHADER, GL_VERTEX_SHADER) overlay_vert = shaders.compileShader(OVERTEX_SHADER, GL_VERTEX_SHADER) base_fragment_shader = shaders.compileShader(BASE_FRAG_SHADER, GL_FRAGMENT_SHADER) base_post_shader = shaders.compileShader(BASE_SFRAG_SHADER, GL_FRAGMENT_SHADER) overlay_frag = shaders.compileShader(OFRAG_SHADER, GL_FRAGMENT_SHADER) except RuntimeError: debugMessage("WARNING: OpenGL 3.0 not supported; trying fallback shaders") SHADERS_AVAILABLE = False base_vertex_shader = shaders.compileShader(COMPAT_VERT_SHADER, GL_VERTEX_SHADER) base_screen_vertex_shader = shaders.compileShader(COMPAT_SVERT_SHADER, GL_VERTEX_SHADER) overlay_vert = shaders.compileShader(COMPAT_OVERTEX_SHADER, GL_VERTEX_SHADER) base_fragment_shader = shaders.compileShader(COMPAT_FRAG_SHADER, GL_FRAGMENT_SHADER) base_post_shader = shaders.compileShader(COMPAT_SFRAG_SHADER, GL_FRAGMENT_SHADER) overlay_frag = shaders.compileShader(COMPAT_OFRAG_SHADER, GL_FRAGMENT_SHADER)
def text_to_image_buffer(self, text, font_size): debugMessage( "text_to_image_buffer not supported for graphical fonts. Path: " + str(self.path) + "; returning None") return 0, 0, None
def requestOwnRemoval(self): try: self.getParent().removeChild(self.id) except AttributeError: debugMessage("Top-level element tried to request own removal:\n {}\n {}".format(self.id, str(self)))
def destroyed(self, val): debugMessage( "destroyed cannot be set outside of the destroy() method.")