def handle_userevent(self, event): #Gère l'usage de porte -> charge nouvelle map et déplace personnage
if event.name == EVENT_TP: # un nouveau rect pour le perso, une nouvelle map pour le Stage
actor = event.actor
actor.rect.x = int(event.spawn_pos.x)
actor.rect.y = int(event.spawn_pos.y)
actor.heal(10)
self.unload_gui_and_player()
self.map.save_in_game()
self.map.destroy()
self.map = Map.load_save(event.map_name)
self.music_init(event.map_name)
self.map.add_actor(event.actor)
self.load_gui_and_player() #soit on enlève celui-ci, soit celui du load_gui_and_player()
elif event.name == EVENT_GAME_OVER:
StageManager().push(StageGameOver())
self.state = StageState.QUIT
elif event.name == EVENT_WIN:
StageManager().push(StageWin())
self.state = StageState.QUIT
def init(self):
#ajout des différents acteurs ( bouttons ( dans l'ordre ) et fond d'écran)
self.map.add_actor(ActorBackgroundMenu())
if StageManager().music_state and not pygame.mixer.music.get_busy():
pygame.mixer.music.load("music/Beginning.ogg")
pygame.mixer.music.play()
self.map.add_actor(ActorButtonStart())
self.map.add_actor(ActorButtonEdit())
self.map.add_actor(ActorButtonSetting())
self.map.add_actor(ActorButtonQuit())
# répartis les bouttons au centre de l'écran
height = self.screen.get_height() / (len(self.map.actors) + 3)
for index, button in enumerate(self.map.actors):
if isinstance(button, ActorButton): #pour ne pas centrer le fond d'écran au centre de l'écran
button.set_centered_x(self.screen.get_width()) #on centre en x
button.rect.y = (index + 1) * height #et on répartit en y
else:
pass
def __init__(self, map="level_0"):
"""la base : initialise les trucs classiques de StageHandleConsole, ajoute une map, cherche le spwanpoint et crée le player dessus"""
super().__init__()
for loop in range(5):
try:
os.remove("saves/level_{0}.map".format(str(loop)))
except:
pass
if StageManager().music_state:
self.music_init()
self.map = Map.load_save(map) #chargement de la map
spawnpoint = self.map.get_actor(ActorSpawnpoint) #et de l'acteur
if spawnpoint is not None: # gère l'existance de spawnpoint
self.player = ActorPlayer()
self.player.rect.topleft = spawnpoint.rect.topleft
self.map.add_actor(self.player)
else:
raise NotImplementedError("Erreur la map n'a pas de spawnpoint!")
# Ensuite ajout de la barre de vie
self.gui_lifebar = ActorGUIBar(ratio=self.player.hp_max / self.player.hp, color=(255, 0, 0, 255))
self.gui_lifebar.rect.x = 24
self.gui_lifebar.rect.y = 24
self.map.add_actor(self.gui_lifebar)
def fct_suffixe(
self
): #On cherche si la musique est on ou off afin de choisir le bon boutton
if StageManager().music_state:
self.suffixe = "ON"
else:
self.suffixe = "OFF"
def handle_keydown(self, unicode, key,
mod): #gère l'évènement 'c' : lance la console
super().handle_keydown(unicode, key, mod)
if unicode == 'c':
self.state = StageState.PAUSE
StageManager().push(StageConsole(self))
def execute(self, command):
""" Gère les entrées dans l'invite de commande"""
commands = command.split(
sep=" "
) # sépare l'entrée en une liste ( escpaces supprimés, remplacés par les ',' de la liste)
if commands[0] == "debug":
pass
elif commands[0] == "hitbox":
self.draw_hit_box = not self.draw_hit_box
elif commands[0] == "print":
print(self.__getattribute__(commands[1]))
print(
self.__getattribute__(commands[1]).__getattribute__(
commands[2]))
elif commands[0] == "menu" or commands[
0] == "quit": #permet de revenir au menu via l'invite de commande
if pygame.mixer.music.get_busy():
pygame.mixer.music.stop(
) # On éteint la music pour permettre à celle du menu de se lancer (car vérifie si une musique est
self.state = StageState.QUIT # en trainde jouer ou non)
StageManager().push(game.stages.StageMainMenu.StageMainMenu())
elif commands[0] == "tp":
event = pygame.event.Event(pygame.USEREVENT,
name=EVENT_TP,
map_name=commands[1],
spawn_pos=Vector(700, 700),
actor=self.map.get_actor(ActorPlayer))
pygame.event.post(event)
elif commands[0] == "invincible":
self.map.get_actor(ActorPlayer).invicible = not self.map.get_actor(
ActorPlayer).invicible
def pause(self):
super().pause()
stage = StageManager().stack[-1]
if isinstance(stage, StageTileSelector):
self.object_pick = stage.tile_picked
if self.object_pick is not None:
self.state = StageState.RESUME
def __init__(self):
super().__init__(
WINDOW_WIDTH, WINDOW_HEIGHT, framerate=60,
fullscreen=False) # Appel de l'initialisation de Game -> du jeu
StageManager().push(
StageLoadingScreen()
) # on lance la scène de chargement - > première scène, sinon le jeu se fermerait (tout simplement )
def sprite(self, sprite): # pour lier l'acteur et l'image
if not isinstance(sprite, pygame.Surface):
self.log("Le Sprite n'est pas valide!", LOG_LEVEL.ERROR)
StageManager().exit()
else:
self.rect.width = sprite.get_width()
self.rect.height = sprite.get_height()
self._sprite = sprite
def music_init(self, map_name = "default"):
if not StageManager().music_state:
return None
if map_name in MUSIC_MAP.keys():
pygame.mixer.music.load(MUSIC_MAP[map_name])
pygame.mixer.music.play()
def execute(
self
): # On inverse la constante lorsque le boutton est activé (certes dans ce cas ce n'est plus une constante, mais bon...)
super().execute()
StageManager().music_state = not StageManager().music_state
if not StageManager().music_state:
pygame.mixer.music.stop()
else:
pygame.mixer.music.play()
self.__init__() # On change de boutton - > On vers OFF, ou inverse
height = WINDOW_HEIGHT / 7
self.set_centered_x(WINDOW_WIDTH) # Il faut recentrer le boutton
self.rect.y = (3) * height
def __init__(self):
super().__init__()
self.map.add_actor(ActorBackgroundWin())
if StageManager().music_state:
pygame.mixer.music.load(MUSIC_WIN)
pygame.mixer.music.play()
self.map.add_actor(ActorCredits())
self.alpha = 0
self.map.actors[1].sprite.set_alpha(self.alpha)
self.add_timer(Timer(56, self.fade_in_image, True, 63))
def __init__(
self,
width=640,
height=480,
log_level=LOG_LEVEL.INFO,
framerate=120,
fullscreen=False
): # Initialisation du jeu, On initialise pygame, on crée l'écran
pygame.init()
pygame.mixer.init()
if fullscreen:
flags = pygame.FULLSCREEN
else:
flags = pygame.NOFRAME
self.stage_manager = StageManager()
# assert not pygame.display.mode_ok((width, height), flags)
self.screen = pygame.display.set_mode((width, height), flags)
self.framerate = framerate
self.clock = pygame.time.Clock(
) #Création d'un système temporel -> pour géré certains trucs selon temps ( ex : vitesse )
Logger.set_log_level(log_level)
def draw(self, screen): # Dessine l'image
if not isinstance(self.sprite, pygame.Surface):
self.log("Le Sprite n'est pas valide!", LOG_LEVEL.ERROR)
StageManager().exit()
else:
try:
if self.draw_shadow:
rect = copy.deepcopy(self.rect)
rect.y += self.h
screen.blit(shadowizer(self.sprite), rect.pyrect)
screen.blit(self.sprite, self.rect.pyrect)
except:
self.load_sprite()
self.info("Rechargement des images car Pickle.")
screen.blit(self.sprite, self._rect.pyrect)
def start(self):
"""Called when you want the game to start -> unless you're using multi-threading, you won't be able to do
anything until your game ends """
""" Jeu fonctionne selon succesion de Stages ( comme un pièce de théâtre ) -> toutes les scènes se déroulent ici: StageManager gère le nombre de scènes en cours
la boucle qui suit active seulement les scènes selon leurs état ( StageState ) """
if self.screen == None:
self.error("Ecran non defini", LOG_LEVEL.ERROR)
StageManager().exit()
while not self.stage_manager.is_empty:
self.clock.tick(self.framerate)
self.screen.fill(
(0, 0, 0)
) #écran est noir, on colle ensuite le stage et les images des acteurs par dessus
for index, stage in enumerate(
self.stage_manager
): # Appelle fct correspondant à ce que le Stage doit faire selon son état ( quit() par exemple ne fait généralement rien)
type(self).CURRENT_STAGE = stage
if stage.state == StageState.RUN:
stage.run()
elif stage.state == StageState.PAUSE:
stage.pause()
elif stage.state == StageState.RESUME:
stage.state = StageState.RUN
stage.resume()
elif stage.state == StageState.INIT:
stage.state = StageState.RUN
stage.init()
elif stage.state == StageState.QUIT:
self.stage_manager.pop(index)
stage.quit()
pygame.display.update()
pygame.mixer.quit() # Plus de 'zic
pygame.quit() # le jeu est fini :)
print("Done")
def execute(self):
StageManager().push(
game.stages.StagePlayerGenerator.StagePlayerGenerator())
class Game(Logger):
"""Les bases de la logique du jeu... Si on veut modifier quelque chose qui touche tout le jeu, on le fait ici"""
CURRENT_STAGE = None
def __init__(
self,
width=640,
height=480,
log_level=LOG_LEVEL.INFO,
framerate=120,
fullscreen=False
): # Initialisation du jeu, On initialise pygame, on crée l'écran
pygame.init()
pygame.mixer.init()
if fullscreen:
flags = pygame.FULLSCREEN
else:
flags = pygame.NOFRAME
self.stage_manager = StageManager()
# assert not pygame.display.mode_ok((width, height), flags)
self.screen = pygame.display.set_mode((width, height), flags)
self.framerate = framerate
self.clock = pygame.time.Clock(
) #Création d'un système temporel -> pour géré certains trucs selon temps ( ex : vitesse )
Logger.set_log_level(log_level)
def start(self):
"""Called when you want the game to start -> unless you're using multi-threading, you won't be able to do
anything until your game ends """
""" Jeu fonctionne selon succesion de Stages ( comme un pièce de théâtre ) -> toutes les scènes se déroulent ici: StageManager gère le nombre de scènes en cours
la boucle qui suit active seulement les scènes selon leurs état ( StageState ) """
if self.screen == None:
self.error("Ecran non defini", LOG_LEVEL.ERROR)
StageManager().exit()
while not self.stage_manager.is_empty:
self.clock.tick(self.framerate)
self.screen.fill(
(0, 0, 0)
) #écran est noir, on colle ensuite le stage et les images des acteurs par dessus
for index, stage in enumerate(
self.stage_manager
): # Appelle fct correspondant à ce que le Stage doit faire selon son état ( quit() par exemple ne fait généralement rien)
type(self).CURRENT_STAGE = stage
if stage.state == StageState.RUN:
stage.run()
elif stage.state == StageState.PAUSE:
stage.pause()
elif stage.state == StageState.RESUME:
stage.state = StageState.RUN
stage.resume()
elif stage.state == StageState.INIT:
stage.state = StageState.RUN
stage.init()
elif stage.state == StageState.QUIT:
self.stage_manager.pop(index)
stage.quit()
pygame.display.update()
pygame.mixer.quit() # Plus de 'zic
pygame.quit() # le jeu est fini :)
print("Done")
def save_and_go(self, filename):
self.save(filename)
self.state = StageState.QUIT
StageManager().push(game.stages.StageLevel.StageLevel())
def execute(self):
StageManager().push(StageMenuSetting())
def execute(self):
StageManager().push(StageEditMode())
def execute(
self, command
): # récupère la commande fournie par StageCommand, agit selon celle-ci
super().execute(command)
commands = command.lower().split(sep=" ")
bug = False
if commands[0] == "map":
if commands[1] == "load":
self.map = Map.load_editor(commands[2]) #pour charger une map
elif commands[1] == "save":
self.map.save()
elif commands[1] == "print": #pour sauvegarder la map
self.map.info("Je suis : " + self.map.name)
elif commands[1] == "type":
if commands[2] == "print":
self.info(self.map.type)
elif commands[2] == "set":
self.map.type = commands[3]
else:
bug = True
else:
bug = True
elif commands[0] == "pick": # pour prendre et poser des acteurs
try:
id = int(commands[1])
except:
id = commands[1]
if isinstance(
id, type("")
): # pour obtenir l'acteur, d'abord selon son nom ( test str ) , ensuite selon son id ( int )
class_name = Register().get_actor_by_name(id)
else:
class_name = Register().get_actor(id)
if class_name is not None:
self.object_pick = class_name(*commands[2:])
#self.object_pick.should_update = False #Ne sais pas l'utilité : mais est cause bug : empêche player de bouger dans editeur
else:
self.object_pick = None
elif commands[0] == "pause": #pour mettre en pause
self.is_paused = True
elif commands[0] == "resume": #voilà ...
self.is_paused = False
elif commands[0] == "mode": #changer le mode actuel
if commands[1] == "get":
self.info(self.mode)
elif commands[1] == "set":
if commands[2] == "pick": #permet de poser acteurs
self.mode = EDIT_MODE.PICK
elif commands[2] == "move": #permet de déplacer un acteur
self.mode = EDIT_MODE.MOVE
elif commands[2] == "remove": #__________enlever___________
self.mode = EDIT_MODE.REMOVE
elif commands[
2] == "layer": #changer la hauteur d'un acteur ( + ou - selon le côté où l'on clic )
self.mode = EDIT_MODE.LAYER
elif commands[
2] == "copy": # de copier l'acteur en question ( avec la hauteur et tt)
self.mode = EDIT_MODE.COPY
else:
bug = True
else:
bug = True
elif commands[
0] == "grid": # pour créer une grille -> Posage d'acteur plus précis
if commands[1] == "turn":
if commands[
2] == "on": # voili voulou, allumer, éteindre, rien de nouveau sous le soleil
self.grid.should_draw = True
elif commands[2] == "off":
self.grid.should_draw = False
else:
bug = True
elif commands[1] == "set":
try:
if commands[3] == "":
self.grid.set_size(int(commands[2]), int(commands[2]))
else: #Afin de donner largeur et hauteur des rectangles de la grille
self.grid.set_size(int(commands[2]), int(commands[3]))
except:
bug = True
elif commands[1] == "origin":
if commands[2] == "" or commands[3] == "":
self.grid.set_origin(
0, 0) #On détermine l'origine de la grille
else:
self.grid.set_origin(int(commands[2]), int(commands[3]))
else:
bug = False
elif commands[0] == "actor":
if commands[1] != "":
self.object_pick = ActorSimpleLife(
commands[1]
) #permet de prendre un acteur particulier parmis les images de assets (au-dessus de tout)
else:
bug = True
elif commands[
0] == "tilesets": #lance le stage tilesets, pour avoir une image/acteur
self.state = StageState.PAUSE
StageManager().push(StageTileSelector())
elif commands[0] == "generator":
self.state = StageState.QUIT
StageManager().push(StagePlayerGenerator())
else:
bug = True
if bug:
print("\"", command, "\"", " est une commande inconnue", sep="")
def execute(self):
super().execute()
StageManager().push(game.stages.StageMainMenu.StageMainMenu())
def quit(self):
StageManager().stack[-1].state = StageState.RESUME
def handle_keydown(self, unicode, key, mod):
pygame.mixer.music.stop()
StageManager().push(StageMainMenu())
self.state = StageState.QUIT
def execute(self):
super().execute()
pygame.mixer.music.stop()
StageManager().push(game.stages.StageMainMenu.StageMainMenu())
def execute(self):
super().execute()
StageManager().exit()
def execute(self):
StageManager().exit()
def quit(self):
StageManager().push(StageMainMenu())