def startCredits(self): self.removeMapData() resetLag() self.fade_darkener.fadeIn(60) playMusic(toStringPath(FULL_MUSIC_PATH + ["ending.ogg"])) self.removeEndingData() self.ending_player = GraphicInterface() self.ending_player.setSprite(toStringPath(CHAR_GRAPHICS_FULL_PATH + ["char.png"])) self.ending_player.setPos(128,128) self.ending_player.setSpriteCenter(True, True) self.ending_player.setSpriteFollowCamera(True) self.ending_player.setSpriteAnimation("WALK_DOWN") self.ending_text = createLabel("Thanks for playing!", font = "kaimono3.gfont2") self.ending_text.setPos(128, 64) self.ending_text.follow_camera = True self.ending_text.setCenter(True,True) self.ending_text2 = createLabel("You got the", font = "kaimono3.gfont2") self.ending_text2.setPos(128, 192) self.ending_text2.follow_camera = True self.ending_text2.setCenter(True,True) self.ending_text3 = createLabel("Golden Squid!", font = "kaimono3.gfont2") self.ending_text3.setPos(128, 176) self.ending_text3.follow_camera = True self.ending_text3.setCenter(True,True) xoffset = getWindowDimensionsScaled()[0]/2 - (len(SQUID_GRAPHICS)-1)*ENDING_SQUID_X_SPACING/2 for i, val in enumerate(SQUID_GRAPHICS.values()): self.ending_squids.append(GraphicInterface()) self.ending_squids[-1].setSprite(toStringPath(CHAR_GRAPHICS_FULL_PATH + [val])) self.ending_squids[-1].setSpriteCenter(True, True) self.ending_squids[-1].setSpriteFollowCamera(True) self.ending_squids[-1].setPos(xoffset + i*ENDING_SQUID_X_SPACING, 96)
def getFontPath(*args): #extension not added if len(args) > 0: filepath = toStringPath(*args) if RESOURCE_PATH not in filepath: path2 = copy.copy(FULL_FONT_PATH) path2.append(filepath) filepath = toStringPath(*path2) else: filepath = toStringPath(*FULL_FONT_PATH) return filepath
def __init__(self): from .mappe import Map from .darkener import Darkener super(AGEDriver, self).__init__() self.glyph_filepath = toStringPath(os.path.dirname(__file__), RESOURCES_FOLDER, GLYPH_FILENAME) #default self.glyph_dim = [GLYPHS_W, GLYPHS_H] #default self.map = Map() self.darkener = Darkener() path = toStringPath(os.path.dirname(__file__), RESOURCES_FOLDER, BACKGROUND_FILENAME) self.background = Sprite(path, layer = BACKGROUND_LAYER) self.background.setColor(*DEFAULT_BACKGROUND_COLOR) self.background.set_dimensions(*getWindowDimensions()) self.background.follow_camera = True
def createStartingMap(self): self.mappe = createMap(MAP_NAME, self.player_starting_pos) #just one map for now self.fade_darkener.fadeIn(60) if self.bg: self.bg.destroy() self.bg = None playMusic(toStringPath(FULL_MUSIC_PATH + ["bgmusic.ogg"]))
def load_graphics(self): if self.font_folder is None: glyphfilepath = toStringPath(*FULL_FONT_PATH) else: glyphfilepath = fontglobals.getFontPath(self.font_folder) glyphs = load.load_graphic_font_glyph_paths(glyphfilepath) for glyph in glyphs: key = os.path.splitext(os.path.basename(glyph))[0] if key not in list(self.glyphs.keys()): self.set_glyph(key, glyph, True) for key, val in list(GRAPHICAL_FONT_DEFAULT_GLYPHS.items()): if key not in list(self.glyphs.keys()): if key == GRAPHICAL_FONT_DEFAULT_CHAR and not fontglobals.checkGlyphExists( val): #TODO: Handle this better, by including the default char image elsewhere, or making algorithmically, or something. raise Exception( "Graphical Font Error: Default character does not exist! Make sure a file named \"defaultchar.png\" exists in the font directory." ) self.set_glyph(key, val, True) glyphlist = [ glyph for key, glyph in list(self.glyphs.items()) if key not in list(GRAPHICAL_FONT_DEFAULT_GLYPHS.keys()) ] if len(glyphlist) > 0: self.standard_height = glyphlist[0].height else: self.standard_height = self.glyphs[ GRAPHICAL_FONT_DEFAULT_CHAR].height self.pre_load_glyphs()
def __init__(self, mappe, *args, **kwargs): super().__init__(*args, **kwargs) self.shadow = GraphicInterface() self.shadow.setSprite( toStringPath(CHAR_GRAPHICS_FULL_PATH + ["playershadow.png"])) self.shadow.setSpriteCenter(True, True) self.shadow.setSpriteLayer(SHADOW_LAYER) self.actor_id = -1 self.paused = False self._mappe = weakRef(mappe) self.facing = DIRECTION_DOWN self.moving = False self.collision = True self.flying = False self.base_layer = ACTOR_LAYER self.z_pos = 0 self.enemy = False self.player = False self.room_index = (0, 0) self.hurt = False self.event_flag = None #used for some enemies self.updateActorLayer(0) self.setSpriteCenter(x=True) self.Schedule(self.updateAnimation, 1, True)
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 load_font_paths(): from kaiengine.debug import debugLooseMessage filepath = fonts.getFontPath() paths = set() try: try: with zipfile.ZipFile(ARCHIVE_FILE_NAME) as f: names = f.namelist() except: debugLooseMessage( "Could not load font name list from resources.dat.") paths.update([ path for path in names if os.path.splitext(path)[1] in SUPPORTED_FONTS ]) except Exception as e: debugLooseMessage("Could not load fonts from resources.dat.") try: paths.update([ toStringPath(filepath, obj) for obj in os.listdir(filepath) if os.path.splitext(obj)[1] in SUPPORTED_FONTS ]) except: debugLooseMessage("Could not load loose fonts.") return list(paths)
def jsonLoad(path): data = jsonfuncs.jsonload(toStringPath(path)) try: del data[META_KEY] except KeyError: pass return data
def createObject(filepath, *args, default_type=KaiObject, **kwargs): filepath = toStringPath(filepath) prop = loadGenericObj(filepath) try: class_name = prop.pop(CLASS_TYPE) if class_name != DEFAULT_CLASS_TYPE: class_path = os.path.join(os.path.dirname(filepath), class_name + PYTHON_EXTENSION) try: class_type = _class_types_dict[class_path] except KeyError: if prop.get(ADDED_CLASS_TYPE, False) and not os.path.isfile( class_path ): #check if auto generated class type doesn't exist raise KeyError #hack to avoid duplicated code spec = importlib.util.spec_from_file_location( ".".join(toListPath(os.path.splitext(class_path)[0])), class_path) newmod = importlib.util.module_from_spec(spec) spec.loader.exec_module(newmod) class_type = newmod.MainClass _class_types_dict[class_path] = class_type else: raise KeyError #hack to avoid duplicated code except KeyError: class_type = default_type return class_type(*args, properties_dict=prop, **kwargs)
def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) self.player_starting_pos = (128, 48) self.game_flags = {} self.trophies_obtained = {} self.player_health = 3 self.fade_darkener = Darkener() self.bg = GraphicInterface() self.bg.setSprite(toStringPath(BG_GRAPHICS_FULL_PATH + ["loading.png"])) self.bg.setSpriteLayer(LOADING_LAYER) self.mappe = None self.ending_player = None self.ending_text = None self.ending_text2 = None self.ending_text3 = None self.ending_squids = [] self.player_health_sprites = [] for i in range(3): self.player_health_sprites.append(GraphicInterface()) self.player_health_sprites[-1].setSprite(toStringPath(UI_GRAPHICS_FULL_PATH + ["health.png"])) self.player_health_sprites[-1].setPos(HEALTH_X_OFFSET + HEALTH_X_STEP*i, getWindowDimensionsScaled()[1] + HEALTH_Y_OFFSET) self.player_health_sprites[-1].setSpriteFollowCamera(True) self.player_health_sprites[-1].setSpriteLayer(UI_LAYER) self.squid_trophy_sprites = [] for i in range(3): self.squid_trophy_sprites.append(GraphicInterface()) self.squid_trophy_sprites[-1].setSpriteFollowCamera(True) self.squid_trophy_sprites[-1].setPos(SQUID_X_OFFSET + SQUID_X_STEP*i, getWindowDimensionsScaled()[1] + SQUID_Y_OFFSET) self.squid_trophy_sprites[-1].setSpriteLayer(UI_LAYER) self.Schedule(self.createStartingMap, 2) self.addCustomListener(SQUID_TROPHY_OBTAINED_EVENT, self.squidTrophyObtained) self.addQueryListener(SQUID_TROPHY_OBTAINED_QUERY, self.checkTrophyObtained) self.addQueryListener(ALL_SQUID_TROPHIES_OBTAINED_QUERY, self.hasAllTrophies) self.addCustomListener(PLAYER_REDUCE_HP_EVENT, self.reduceHP) self.addCustomListener(PLAYER_MAX_HP_EVENT, self.maxHP) self.addQueryListener(CHECK_PLAYER_DEAD_QUERY, self.checkPlayerDead) self.addCustomListener(PUSH_SAVE_EVENT, self.pushSave) self.addCustomListener(FINAL_SQUID_OBTAINED_EVENT , self.finalSquidObtained) self.addCustomListener(GAME_LOST_EVENT, self.gameLost) self.loadSave()
def createObjectWithData(obj_filename, obj_filedir, obj_ext, default_type, *args, **kwargs): #for making wrappers path = toStringPath(toListPath(obj_filedir) + toListPath(obj_filename)) if obj_ext not in path: path += obj_ext if default_type is not None: kwargs["default_type"] = default_type return createObject(path, *args, **kwargs)
def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) self.sparkle_graphic_list = [ "sparkle1_green.png", "sparkle2_green.png" ] self.squid_trophy_index = SQUID_TROPHY_GREEN_INDEX self.setSprite( toStringPath(CHAR_GRAPHICS_FULL_PATH + ["squid_trophy_green.png"]))
def playerHit(self): self.player_health -= 1 self.updateHearts() self.player.gotHit() playSound(toStringPath(*HIT_SE_PATH)) if self.player_health <= 0: self.player.setKilled() settings.setValue(HIGH_SCORE, max(settings.getValue(HIGH_SCORE, 0.0), self.distance)) self.Schedule(self.resetGame, GAME_RESTART_TIME)
def _loadSprites(self): for sprite in self.multi_sprites: try: key = self.add_sprite(toStringPath(self._gfx_path + [sprite[MULTI_SPRITE_SPRITE_PATH]])) try: self._spriteLayers[key] = sprite[MULTI_SPRITE_SPRITE_LAYER] except KeyError: pass except KeyError: pass self.update_layer()
def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) self.setSprite(toStringPath(CHAR_GRAPHICS_FULL_PATH + ["bush.png"])) self.setSpriteCenter(False, False) self.setSpriteOtherOffset(ACTOR_Y_OFFSET, y=0) self.Schedule(self.updateBushCollision, 1) self.base_layer = BUSH_LAYER self.removeShadow()
def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) self.flying = True self.enemy_index = ENEMY_BAT_INDEX self.setSprite(toStringPath(CHAR_GRAPHICS_FULL_PATH + ["bat.png"])) self.startWander() self.Schedule(self.checkPlayerCollision, 1, True)
def _createSparkle(self): if self.sparkle_graphic_list and not self.open: sparkle_id = self.sparkle_graphics.append(GraphicInterface()) sparkle = self.sparkle_graphics[sparkle_id] sparkle.setSprite(toStringPath(EFFECTS_GRAPHICS_FULL_PATH + [random.choice(self.sparkle_graphic_list)])) x, y = self.getBottomLeftCorner() sparkle.setPos(x + random.random()*self.getSpriteWidth(), y+random.random()*self.getSpriteHeight()) sparkle.sprite.addAniFinishListener(None, sparkle.destroy) sparkle.setSpriteLayer(SPARKLE_LAYER) self.Schedule(self._createSparkle, int(random.random()*SPARKLE_TIME*SPARKLE_VARIANCE*2 + SPARKLE_TIME*(1.0-SPARKLE_VARIANCE)))
def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) self.enemy_index = ENEMY_BARRICADE_INDEX self.open = False self.setSprite(toStringPath(CHAR_GRAPHICS_FULL_PATH + ["barricade.png"])) self.setSpriteCenter(True, True) self.setSpriteOtherOffset(ACTOR_Y_OFFSET, y = 0) self.base_layer = BARRICADE_LAYER self.removeShadow()
def add_graphic(self): self.remove_sprites() for name in SPRITE_NAMES: self.sprites.append( display.createGraphic( toStringPath(self._gfx_path + [self._gfx_name + name + PNG_EXTENSION]), self.layer)) self.show = True self.update_dimensions()
def updateTrophyGraphics(self): for trophy in self.squid_trophy_sprites: trophy.setSpriteAlpha(0.0) for trophy_index in self.trophies_obtained.keys(): index = SQUID_ENUM.get(trophy_index, 999) try: self.squid_trophy_sprites[index].setSprite(toStringPath(CHAR_GRAPHICS_FULL_PATH + [SQUID_GRAPHICS[trophy_index]])) self.squid_trophy_sprites[index].setSpriteAlpha(1.0) except (KeyError, IndexError): pass
def loadGraphicFont3Data(filepath): filepath = fonts.getFontPath(filepath) if GRAPHIC_FONT_3_EXTENSION not in filepath: filepath += GRAPHIC_FONT_3_EXTENSION obj = load_object_no_class(filepath) if PROP_KEY in obj: newpath = toStringPath(os.path.split(filepath)[0], obj[PROP_KEY]) obj = updateNestedDict(loadGraphicFont3Data(newpath), obj) obj.pop(PROP_KEY) return obj
def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) self.jumping = False self.invulnerable = False self.z_pos = 0 self.jump_speed = 0 self.jumping_y_speed = 0 self.jumping_x_speed = 0 self.dead = False self.shadow = GraphicInterface() self.shadow.setSprite(toStringPath(*PLAYER_SHADOW_PATH)) self.shadow.setSpriteCenter(True,True) self.shadow.setSpriteLayer(0.5) self.setSprite(toStringPath(*PLAYER_CHAR_PATH)) self.Schedule(self.updateMovement, 1, True) self.addCustomListener(PLAYER_JUMP_EVENT, self.playerJump)
def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) self.collision = False #manually checks its own collision self.removeShadow() self.hit_something = False self.setSprite( toStringPath(EFFECTS_GRAPHICS_FULL_PATH + ["rainbowbubble.png"])) self.Schedule(self.updateHitSomething, 1, True)
def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) self.enemy_index = ENEMY_SAVE_INDEX self.setSprite(toStringPath(CHAR_GRAPHICS_FULL_PATH + ["save.png"])) self.setSpriteCenter(True, True) self.setSpriteOtherOffset(ACTOR_Y_OFFSET, y=0) self.base_layer = SAVE_LAYER self.removeShadow() self.Schedule(self.checkForPlayerToSave, 1, True)
def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) self.swinging_sword = False self.enemy_index = ENEMY_SKELETON_INDEX self.setSprite(toStringPath(CHAR_GRAPHICS_FULL_PATH + ["skeleton.png"])) self.Schedule(self.moveTowardPlayer, 30, True) self.Schedule(self.checkPlayerCollision, 1, True)
def resetToSave(self): stopMusic() if self.mappe: self.mappe.destroy() self.loadSave() if self.bg: self.bg.destroy() self.fade_darkener.fadeIn(1) self.bg = GraphicInterface() self.bg.setSprite(toStringPath(BG_GRAPHICS_FULL_PATH + ["loading.png"])) self.bg.setSpriteLayer(LOADING_LAYER) self.bg.setSpriteFollowCamera(True) self.Schedule(self.createStartingMap, 2)
def __init__(self, filepath): self._initialized = False newfilepath = filepath if CONFIG_EXTENSION not in filepath: newfilepath += CONFIG_EXTENSION if checkResourceExists(toStringPath(self._path + [newfilepath])): try: super(Settings, self).__init__(newfilepath) except: self.altInit(filepath) else: self.altInit(filepath) self._altered_values = self.serialize()
def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) self.player_health = 3 self.boulder_spawn_rate = 1.0 self.distance = 0.0 self.background = GraphicInterface() self.background.setSprite(toStringPath(*BG_PATH)) self.other_bg = GraphicInterface() self.other_bg.setSprite(toStringPath(*OTHER_BG_PATH)) self.other_bg.setSpriteLayer(-1) self.player = None self.boulders = sDict() self.hearts = [] for i in range(3): self.hearts.append(GraphicInterface()) self.hearts[i].setSprite(toStringPath(*HEART_PATH)) self.hearts[i].setPos(HEART_X_START_POS + HEART_X_OFFSET*i, HEART_Y_POS) self.hearts[i].setSpriteLayer(30) self.distance_counter = createLabel("", font = "kaimono3.gfont2") self.distance_counter.setPos(y = HEART_Y_POS) self.distance_counter.layer = 30 self.max_distance_counter = createLabel("", font = "kaimono3.gfont2") self.max_distance_counter.setPos(y = HEART_Y_POS - 12) self.max_distance_counter.layer = 30 playMusic(toStringPath(MUSIC_PATH)) self.resetGame() self.Schedule(self.updateBGScroll, 1, True) self.Schedule(self.boulderSpawnReduction, BOULDER_SPAWN_REDUCTION_APPLICATION_TIME, True) self.Schedule(self.checkCollision, 1, True) self.Schedule(self.updateDistance, 1, True) self.addCustomListener(REMOVE_BOULDER_EVENT, self.removeBoulder)
def __init__(self, x, y): super(Tile, self).__init__() self._sprite = Sprite(GetGlyphFilepath(), layer = GLYPH_LAYER) self._sprite.set_gridsize(GLYPHS_W, GLYPHS_H, True) self._spritehighlight = Sprite(toStringPath(os.path.dirname(__file__), RESOURCES_FOLDER, BACKGROUND_FILENAME), layer = GLYPH_HIGHLIGHT_LAYER) dim = GetGlyphColumnsRows() self._spritehighlight.set_dimensions(self._sprite.original_width / dim[0], self._sprite.original_height / dim[1]) self._default_image = [0,self._sprite.gridsize[1] - 1] self._sprite.change_image(self._default_image) self._spritehighlight.show = False self._layers = {} self._sorted_layer_keys = [] self._pos = [0,0] self.SetPos(x, y)