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)
