def sel_unit_move(self, pos):
"""
Move the selected unit to the given position.
"""
# Change the game state to show that there was a movement.
self.change_mode(Modes.Moving)
# Implements animation for movement of unit if it exists (teleport unit spawns a warp)
if self.sel_unit.move_animation:
self._effects.add(
self.sel_unit.move_animation(self.map.screen_coords(pos)))
# Mark that the unit has moved
self.sel_unit.turn_state[0] = True
#the tile position the unit is at
from_tile_pos = (self.sel_unit.tile_x, self.sel_unit.tile_y)
# Play the unit's movement sound
SoundManager.play(self.sel_unit.move_sound)
# These will be used in pathfinding
cost = lambda c: (self.sel_unit.move_cost(self.map.tile_data(c)))
passable = lambda c: (self.sel_unit.is_passable(
self.map.tile_data(c), c))
#set the path in the unit.
self.sel_unit.set_path(
tiles.find_path(self.map, from_tile_pos, pos, cost, passable))
def sel_unit_move(self, pos):
"""
Move the selected unit to the given position.
"""
# Change the game state to show that there was a movement.
self.change_mode(Modes.Moving)
# Mark that the unit has moved
self.sel_unit.turn_state[0] = True
#the tile position the unit is at
from_tile_pos = (self.sel_unit.tile_x, self.sel_unit.tile_y)
# Play the unit's movement sound
SoundManager.play(self.sel_unit.move_sound)
# These will be used in pathfinding
cost = lambda c: (self.sel_unit.move_cost(self.map.tile_data(c)))
passable = lambda c: (self.sel_unit.is_passable(
self.map.tile_data(c), c))
#set the path in the unit.
self.sel_unit.set_path(
tiles.find_path(self.map, from_tile_pos, pos, cost, passable))
class Client:
def __init__(self, gui) -> None:
self.gui = gui
self.sounds = SoundManager(self)
self.state = CSGOState(self)
async def update_status(self) -> None:
with self.state.lock:
if self.state.old_state is None:
self.gui.SetStatusText("Waiting for CS:GO...")
elif self.state.old_state.is_ingame:
phase = self.state.old_state.phase
if phase == "unknown":
phase = ""
else:
phase = " (%s)" % phase
self.gui.SetStatusText(
f"Round {self.state.old_state.current_round}{phase}"
)
else:
self.gui.SetStatusText("Not in a match.")
async def reload_sounds(self) -> None:
"""Reloads all sounds.
Do not call outside of gui, unless you disable the update sounds button first.
"""
await self.sounds.reload()
await self.update_status()
self.gui.updateSoundsBtn.Enable()
self.sounds.play("Round start")
def sel_unit_move(self, pos):
"""
Move the selected unit to the given position.
"""
# Change the game state to show that there was a movement.
self.change_mode(Modes.Moving)
# Mark that the unit has moved
self.sel_unit.turn_state[0] = True
#the tile position the unit is at
from_tile_pos = (self.sel_unit.tile_x,
self.sel_unit.tile_y)
# Play the unit's movement sound
SoundManager.play(self.sel_unit.move_sound)
# These will be used in pathfinding
cost = lambda c: (
self.sel_unit.move_cost(self.map.tile_data(c)))
passable = lambda c: (
self.sel_unit.is_passable(self.map.tile_data(c), c))
#set the path in the unit.
self.sel_unit.set_path(
tiles.find_path(
self.map,
from_tile_pos,
pos,
cost,
passable))
def __init__(self): #Créer le constructeur de la classe
self.is_playing = False #Dire que le jeu n'as pas commencé
self.end_game = False #Signaler que le jeu n'est pas terminé
self.all_players = pygame.sprite.Group() #Créer le groupe du joueur
self.player = Player(self) #Ajouter le joueur au jeu
self.all_players.add(self.player) #Ajouter le joueur au groupe
self.all_monsters = pygame.sprite.Group(
) #Créer le groupe des monstres
self.pressed = {
} #Définir le dictionnaire pour savoir si des touches sont pressées
self.comet_event = CometFallEvent(self) #Stocker la classe des comètes
self.score = 0 #Définir la score initial
self.font = pygame.font.Font("assets/Righteous-Regular.ttf",
25) # Créer la police du texte du score
self.sound_manager = SoundManager() #Stocker la classe des sons
self.all_boss = pygame.sprite.Group() # Créer le groupe du monstre
self.boss = Boss(self) # Stocker la classe du boss
self.projectile = True
self.event = 1
self.paused = False
self.end_text = self.font.render(
"Congratulations ! You have completed the game !!!", 1,
(0, 0, 0)) # Créer le texte des vies globales
self.general_data = {}
self.infinite = False
self.recovback()
def on_click(self, e):
"""
This is called when a click event occurs.
e is the click event.
"""
# Don't react when in move, attack or game over mode.
if (self.mode == Modes.Moving or self.mode == Modes.GameOver):
return
# make sure we have focus and that it was the left mouse button
if (e.type == pygame.MOUSEBUTTONUP and e.button == 1
and pygame.mouse.get_focused()):
# If this is in the map, we're dealing with units or tiles
if self.map.rect.collidepoint(e.pos):
# Get the tile's position
to_tile_pos = self.map.tile_coords(e.pos)
# get the unit at the mouseclick
unit = self.get_unit_at_screen_pos(e.pos)
if unit:
# clicking the same unit again deselects it and, if
# necessary, resets select mode
if unit == self.sel_unit:
self.change_mode(Modes.Select)
self.sel_unit = None
# select a new unit
elif (self.mode == Modes.Select
and unit.team == self.cur_team):
self.sel_unit = unit
SoundManager.play(SELECT_SOUND)
# Attack
elif (self.mode == Modes.ChooseAttack and self.sel_unit
and to_tile_pos in self._attackable_tiles):
# Attack the selected tile
self.sel_unit_attack(to_tile_pos)
else:
# No unit there, so a tile was clicked
if (self.mode == Modes.ChooseMove and self.sel_unit
and to_tile_pos in self._movable_tiles):
# Move to the selected tile
self.sel_unit_move(to_tile_pos)
# Otherwise, the user is interacting with the GUI panel
else:
# Check which button was pressed
for button in self.buttons:
# If the button is enabled and has a click function, call
# the function
if ((not button.condition or button.condition()) and
self.get_button_rect(button).collidepoint(e.pos)):
button.onClick()
# Play the button sound
SoundManager.play(BUTTON_SOUND)
def __init__(self):
self.is_playing = False
self.all_players = pygame.sprite.Group()
self.player = Player(self)
self.all_players.add(self.player)
self.all_monsters = pygame.sprite.Group()
self.sound_manager = SoundManager()
self.pressed = {}
self.score = 0
def __init__(self, gui, global_mutex):
self.threadripper = global_mutex
self.gui = gui
self.shard_code = gui.shardCodeIpt.GetValue()
self.sounds = SoundManager(self)
self.state = CSGOState(self)
Thread(target=self.listen, daemon=True).start()
Thread(target=self.keepalive, daemon=True).start()
def sel_unit_attack(self, pos):
"""
Attack the given position using the selected unit.
"""
# Change the game state to show that there was an attack.
self.change_mode(Modes.Select)
# Mark that the unit has attacked.
self.sel_unit.turn_state[1] = True
# Face the attackee
self.sel_unit.face_vector((
pos[0] - self.sel_unit.tile_x,
pos[1] - self.sel_unit.tile_y))
# Get info about the attackee
atk_unit = unit.base_unit.BaseUnit.get_unit_at_pos(pos)
atk_tile = self.map.tile_data(pos)
# Calculate the damage
damage = self.sel_unit.get_damage(atk_unit, atk_tile)
damage += random.choice([-1, -1, 0, 0, 0, 0, 0, 1, 1, 2])
damage = max(damage, 0)
# Deal damage
atk_unit.hurt(damage)
# Do the attack effect.
if self.sel_unit.hit_effect:
self._effects.add(self.sel_unit.hit_effect(
self.map.screen_coords(pos)))
# Play the unit's attack sound
if self.sel_unit.hit_sound:
SoundManager.play(self.sel_unit.hit_sound)
if not atk_unit.active:
# Add its death effect
if atk_unit.die_effect:
self._effects.add(atk_unit.die_effect(
self.map.screen_coords(pos)))
# Play its death sound
if atk_unit.die_sound:
SoundManager.play(atk_unit.die_sound)
# If the unit was destroyed, check if there are any others
# left on a team other than the selected unit
for u in unit.base_unit.BaseUnit.active_units:
if u.team != self.sel_unit.team:
return
# No other units, so game over!
self.win_team = self.sel_unit.team
self.mode = Modes.GameOver
def __init__(self):
self.is_playing = False
self.all_players = pygame.sprite.Group()
self.player = Player(self)
self.all_players.add(self.player)
self.comet_event = CometFallEvent(self)
self.all_monsters = pygame.sprite.Group()
self.font_text = pygame.font.Font("assets/DancingScript-Bold.ttf", 80)
self.score = 0
self.sound_manager = SoundManager()
self.pressed = {}
def __init__(self):
# definir si le jeu a commence ou non
self.is_playing = False
self.player = Player(self) # Generer joueur
self.all_player = pygame.sprite.Group()
self.all_player.add(self.player)
self.all_monster = pygame.sprite.Group() # groupe de monstre
self.sound_manager = SoundManager()
self.comet_event = CometFallEvent(self)
self.font = pygame.font.Font("./assets/PottaOne.ttf", 20)
self.score = 0
self.pressed = {}
def __init__(self):
self.is_playing = False
self.all_players = pygame.sprite.Group()
self.player = Player(self)
self.all_players.add(self.player)
self.all_monsters = pygame.sprite.Group()
#gerer le son
self.sound_manager = SoundManager()
#mettre le score a 0
self.font = pygame.font.Font("assets/my_custom_font.ttf", 25)
self.score = 0
self.pressed = {}
self.comet_event = CometFallEvent(self)
def __init__(self, screen, user, maze):
self.screen = screen
self.maze = maze
self.user = user
self.sound_manager = SoundManager(
sound_files=['portal-open.wav', 'portal-travel.wav'],
keys=['open', 'travel'],
channel=PortalController.PORTAL_AUDIO_CHANNEL)
self.blue_portal = pygame.sprite.GroupSingle(
) # portals as GroupSingle, which only allows one per group
self.blue_projectile = None
self.orange_portal = pygame.sprite.GroupSingle()
self.orange_projectile = None
self.portal_directions = {'l': 'r', 'r': 'l', 'u': 'd', 'd': 'u'}
def __init__(self, screen, score_controller, transition_time=5000):
self.screen = screen
self.score_controller = score_controller
self.sound = SoundManager(['pacman_beginning.wav'],
keys=['transition'],
channel=LevelTransition.TRANSITION_CHANNEL,
volume=0.6)
self.score_font = pygame.font.Font('fonts/emulogic.ttf', 24)
ready_pos = screen.get_width() // 2, int(screen.get_height() * 0.65)
self.level_msg = None
self.level_msg_rect = None
self.transition_time = transition_time # total time to wait until the transition ends
self.transition_begin = None
self.transition_show = False
def __init__(self):
self.is_playing = False
self.player = Player(self)
self.all_players = pygame.sprite.Group([self.player])
self.comet_event = CometFallEvent(self)
self.all_monster = pygame.sprite.Group()
self.sound_manager = SoundManager()
self.font = pygame.font.Font(
"cometfall/assets/fonts/Anton-Regular.ttf", 30)
self.score = 0
self.level = {}
self.username = None
self.comet_event_number = 0
image = pygame.image.load(f"cometfall/assets/background/planet.jpg")
self.background = pygame.transform.scale(image, (1200, 720))
def __init__(self):
pygame.init()
pygame.mixer.music.load('sounds/fortnite-dance.wav')
self.game_screen = pygame.display.set_mode((900, 700))
pygame.display.set_caption('Pacman')
self.tick_component = pygame.time.Clock()
self.hold_score = ScoreController(screen=self.game_screen,
sb_pos=((self.game_screen.get_width() // 5),
(self.game_screen.get_height() * 0.965)),
items_image='strawb.png',
itc_pos=(int(self.game_screen.get_width() * 0.6),
self.game_screen.get_height() * 0.965))
self.map_layout = Maze(screen=self.game_screen, maze_map_file='maze_map.txt')
self.lives_left = Counter(screen=self.game_screen, ct_pos=((self.game_screen.get_width() // 3),
(self.game_screen.get_height() * 0.965)),
images_size=(self.map_layout.block_size, self.map_layout.block_size))
self.next_level = LevelTransition(screen=self.game_screen, score_controller=self.hold_score)
self.lost_game = True
self.pause_game = False
self.pacman_player = Pacman(screen=self.game_screen, maze=self.map_layout)
self.pacman_ghosts = pygame.sprite.Group()
self.pacman_ghosts_sound = SoundManager(sound_files=['ghost.wav', 'pacman_eatghost.wav', 'pacman_siren.wav'],
keys=['blue', 'eaten', 'siren'],
channel=Ghost.ghost_audio)
self.pacman_ghosts_interval_active = 2500
self.pacman_ghosts_begin_chase = None
self.pacman_ghosts_blinky = None
self.pacman_ghosts_others = []
self.blit_ghosts()
self.game_actions = {PlayGame.event_start: self.init_ghosts,
PlayGame.event_remake: self.rebuild_maze,
PlayGame.event_next_level: self.next_level}
def __init__(self):
self.is_playing = False
# Génération de notre joueur
self.all_player = pygame.sprite.Group()
self.player = Player(self)
self.all_player.add(self.player)
# Générer l'évènement
self.comet_event = CometFallEvent(self)
# groupe de monstres
self.all_monster = pygame.sprite.Group()
self.pressed = {}
# Mettre le score a 0
self.score = 0
self.font = pygame.font.SysFont("monospace", 16, True)
# fself.ont = pygame.font.Font("assets/my_custom_font.ttf", 25)
# Gestion des effets sonores
self.sound_manager = SoundManager()
def __init__(self):
# definir si notre jeu a commencé ou non
self.is_playing = False
# generer notre joueur
self.all_players = pygame.sprite.Group()
self.player = Player(self)
self.all_players.add(self.player)
# generer l'evenement
self.comet_event = CometFallEvent(self)
# groupe de monstres
self.all_monsters = pygame.sprite.Group()
# gerer le son
self.sound_manager = SoundManager()
# mettre le score à 0
self.font = pygame.font.Font("assets/HanaleiFill-Regular.ttf", 25)
self.score = 0
self.pressed = {}
def __init__(self):
#definir le commencement du jeu
self.is_playing = False
#generate player
self.all_players = pygame.sprite.Group()
self.player = Player(self)
self.all_players.add(self.player)
#generer l'evenement
self.comet_event = CometFallEvent(self)
#groupe monstres
self.all_monsters = pygame.sprite.Group()
#gestion du son
self.sound_manager = SoundManager()
#METTRE score a zero
self.font = pygame.font.Font("assets/font.ttf", 25)
self.score = 0
self.pressed = {}
def __init__(self):
# Generer joueur
self.all_players = pygame.sprite.Group()
self.player = Player(self)
self.all_players.add(self.player)
# Groupe de Monstres
self.all_monsters = pygame.sprite.Group()
# Jeu a commencé ou non ?
self.isPlaying = False
# Comet
self.comet_event = CometFallEvent(self)
# Gérer le son
self.soundManager = SoundManager()
# Mettre score à 0
self.score = 0
self.pressed = {}
self.font = pygame.font.Font("assets/PottaOne-Regular.ttf", 25)
def __init__(self):
# définir si notre jeu a commencer ou non
self.is_playing = False
#générer notre joueur
self.all_player = pygame.sprite.Group()
self.player = Player(self) #appel de la fonction Player
self.all_player.add(self.player)
# generer l'evenement de comete
self.commet_event = CometFallEvent(self)
#groupe de monstre
self.all_monsters = pygame.sprite.Group()
# gérer le son
self.sound_manager = SoundManager()
# mettre le score a 0
self.font = pygame.font.Font("assets/my_custom_font.ttf", 25)
self.score = 0
self.pressed = {}
def __init__(self, screen_width, screen_height):
#le jeu a commencé T/F
self.is_playing = False
#taille de l'ecran de jeu
self.screen_width = screen_width
self.screen_height = screen_height
#groupe de monstre
self.all_monsters = pygame.sprite.Group()
#générer l'evenement
self.comet_event = CometFallEvent(self)
#touche pressee
self.pressed = {}
#score à 0
self.score = 0
#afficher le score sur l'écran
self.font = pygame.font.Font("assets/myfont.ttf", 30)
#gerer le son
self.sound_manager = SoundManager()
def __init__(self):
# Generer le jouer
self.all_players = pygame.sprite.Group()
self.player = Player(self)
self.all_players.add(self.player)
# Definir si le jeu a commence
self.is_playing = False
# groupe de monstre
self.all_monsters = pygame.sprite.Group()
self.pressed = {}
# generer l'evenement comet
self.comet_event = CometFallEvent(self)
# mettre le score a zero
self.font = pygame.font.SysFont('monospace', 25, True)
self.score = 0
# gerer le son
self.sound_manager = SoundManager()
class LevelTransition:
TRANSITION_CHANNEL = 4
def __init__(self, screen, score_controller, transition_time=5000):
self.screen = screen
self.score_controller = score_controller
self.sound = SoundManager(['pacman_beginning.wav'],
keys=['transition'],
channel=LevelTransition.TRANSITION_CHANNEL,
volume=0.6)
self.score_font = pygame.font.Font('fonts/emulogic.ttf', 24)
ready_pos = screen.get_width() // 2, int(screen.get_height() * 0.65)
self.level_msg = None
self.level_msg_rect = None
self.transition_time = transition_time # total time to wait until the transition ends
self.transition_begin = None
self.transition_show = False
def prep_level_msg(self):
text = 'level ' + str(self.score_controller.level)
self.level_msg = self.score_font.render(text, True,
ScoreBoard.SCORE_WHITE)
self.level_msg_rect = self.level_msg.get_rect()
level_pos = self.screen.get_width() // 2, self.screen.get_height() // 2
self.level_msg_rect.centerx, self.level_msg_rect.centery = level_pos
def set_show_transition(self):
self.prep_level_msg()
self.transition_begin = pygame.time.get_ticks()
self.transition_show = True
self.sound.play('transition')
def draw(self):
if abs(self.transition_begin -
pygame.time.get_ticks()) > self.transition_time:
self.transition_show = False
else:
self.screen.fill((0, 0, 0))
self.screen.blit(self.level_msg, self.level_msg_rect)
def __init__(self):
super().__init__()
self.key_pressed = {}
self.player = Ninja(self)
self.player_group = pygame.sprite.Group(self.player)
self.all_zombies_right = pygame.sprite.Group()
self.all_zombies_left = pygame.sprite.Group()
self.all_heart = pygame.sprite.Group()
self.all_flask = pygame.sprite.Group()
self.kill = 0
self.dismiss_monsters = False
self.total_points = 0
self.game_finish = False
self.finish_scene = True
self.kamehameha_mode = False
self.kill_before_kamehameha = 0
self.kill_after_kamehameha = 0
self.game_results = False
self.game_replay = False
self.game_time = 0
self.monster_counter = 0
self.round = 0
self.target_number = 0
self.sound_manager = SoundManager()
def update_logic(self):
"""
Update Logic runs through all player movement, controller inputs,
player attack_status, checks for game_over or map scroll advance.
Anything that involves changing numbers is done here.
"""
#Limit logic loop by frames per second
pygame.time.wait(int(1000/self.FPS))
#If all players are dead game over is enabled.
self.game_over = True
for Players in self.unit_roster.get("Players"):
if Players.dead == False:
self.game_over = False
# Update Script (Event Handler responsible for spawning monsters, printing quest text, enabling scroll)
self.script.update_script()
# Player Loop
for player in self.unit_roster.get("Players"):
# If scroll available and player at edge scroll change map
if player.xpos > 900 and self.script.scroll_available:
self.script.text_print = 0
self.maps.is_map_scrolling = 1
spawn_players(self.unit_roster.get("Players"))
# If player has died remove from Roster
for unit in self.unit_roster.get("Players"):
if unit.dead:
self.unit_roster.get("Players").remove(unit)
#Player is still alive
if player.get_health() > 0:
#Update Controller (Get input)
for control in self.controllers:
if control.player == player:
control.update()
#Check for defense
if player.defending:
player.defend_spell()
else:
player.armor = 1
#passive health/energy restore
player.gain_energy(0.3)
player.gain_health(0.1)
#If player has triggered attack in controller update
#but not yet dealt possible dmg to surroundings do it.
#Only if possible to dmg enemies, unless duel mode is active.
if not player.dmg_dealt:
SoundManager.play(player.atk1_sound)
player.check_dmg_done(self.unit_roster.get("Enemies"))
if self.script.duel_mode:
player.check_dmg_done(self.unit_roster.get("Players"))
player.dmg_dealt = True
#Player is not alive
else: # health < 0
player.dead = True
#Enemy Loop (Very similar to Player Loop)
for unit in self.unit_roster.get("Enemies"):
#Enemie is alive
if unit.get_health() > 0:
unit.gain_energy(0.3)
#This is basically AI version of Controller update
unit.AI_update(self.screen)
#If possible to deal dmg do it.
if not unit.dmg_dealt:
SoundManager.play(unit.atk1_sound)
unit.check_dmg_done(self.unit_roster.get("Players"))
unit.dmg_dealt = True
else: # Enemy is dead
#Remove from roster and feild after despawn time
despawn_time = 2000
if not unit.dead:
unit.dead_time = pygame.time.get_ticks()
unit.dead = True
if unit.dead_time + despawn_time < pygame.time.get_ticks():
self.unit_roster.get("Enemies").remove(unit)
class Game: #Créer la classe du jeu
"""Définir les attributs du jeu"""
def __init__(self): #Créer le constructeur de la classe
self.is_playing = False #Dire que le jeu n'as pas commencé
self.end_game = False #Signaler que le jeu n'est pas terminé
self.all_players = pygame.sprite.Group() #Créer le groupe du joueur
self.player = Player(self) #Ajouter le joueur au jeu
self.all_players.add(self.player) #Ajouter le joueur au groupe
self.all_monsters = pygame.sprite.Group(
) #Créer le groupe des monstres
self.pressed = {
} #Définir le dictionnaire pour savoir si des touches sont pressées
self.comet_event = CometFallEvent(self) #Stocker la classe des comètes
self.score = 0 #Définir la score initial
self.font = pygame.font.Font("assets/Righteous-Regular.ttf",
25) # Créer la police du texte du score
self.sound_manager = SoundManager() #Stocker la classe des sons
self.all_boss = pygame.sprite.Group() # Créer le groupe du monstre
self.boss = Boss(self) # Stocker la classe du boss
self.projectile = True
self.event = 1
self.paused = False
self.end_text = self.font.render(
"Congratulations ! You have completed the game !!!", 1,
(0, 0, 0)) # Créer le texte des vies globales
self.general_data = {}
self.infinite = False
self.recovback()
def register(self):
if self.infinite is False:
self.general_data["level"] = self.level
self.general_data["lives"] = self.life
with open("data.json", "w") as database:
json.dump(self.general_data, database)
def pause(self):
if self.paused is False:
self.paused = True
else:
self.paused = False
def recovback(self):
if self.infinite is False:
database = open("data.json").read()
data = json.loads(database)
self.level = data["level"]
self.life = data["lives"]
def spawn_boss(self):
self.all_boss.add(self.boss) # Ajouter un boss au groupe de boss
def spawn_monster(
self,
monster_name): #Définir la méthode pour faire spawner les monstres
"""Faire spawner les monstres"""
self.all_monsters.add(
monster_name.__call__(self)) #Ajouter des monstres au groupe
def start(self): #Méthode pour lancer le jeu
if self.infinite is False:
self.is_playing = True #Lancer le jeu
"""Faire spawner les monstres en fonction du niveau"""
if self.level == 1: # Action s'exécutant si on est au niveau 1
self.spawn_monster(Mummy)
elif self.level == 2: # Action s'exécutant si on est au niveau 2
self.spawn_monster(Mummy) # Faire apparaître une momie
self.spawn_monster(Mummy) # Faire apparaître un momie
elif self.level == 3: # Action s'exécutant si on est au niveau 3
self.spawn_monster(Alien) # Faire apparaître un alien
elif self.level == 10:
self.all_monsters = pygame.sprite.Group()
self.spawn_boss()
else:
self.spawn_monster(Mummy) # Faire apparaître un momie
self.spawn_monster(Mummy) # Faire apparaître un momie
self.spawn_monster(Alien) # Faire apparaître un alien
else:
self.is_playing = True
self.spawn_monster(Mummy) # Faire apparaître un momie
self.spawn_monster(Mummy) # Faire apparaître un momie
self.spawn_monster(Alien) # Faire apparaître un alien
def game_over(self): # Méthode pour réinitialiser le jeu
if self.life <= 0:
self.all_monsters = pygame.sprite.Group(
) # Supprimer tous les monstres
self.player.health = self.player.max_health # Réinitialiser les vies du joueur
self.is_playing = False # Afficher le menu du jeu
self.comet_event.all_comets = pygame.sprite.Group(
) # Supprimer les comètes
self.comet_event.reset_percent() # Réinitialiser le pourcentage
self.score = 0 # Réinitialiser le score
self.sound_manager.play_sound(
"game_over") # Jouer le son du Game Over
self.life = 3
self.level = 1
def block_projectile(self):
print(self.comet_event.fall_mode)
if self.boss.rect.x == 800:
self.projectile = False
elif self.boss.rect.x == 600:
self.projectile = True
def end(self):
self.end_game = True # Signaler que le jeu est terminé
self.all_monsters = pygame.sprite.Group(
) # Supprimer tous les monstres
self.player.health = self.player.max_health # Réinitialiser les vies du joueur
self.comet_event.all_comets = pygame.sprite.Group(
) # Supprimer les comètes
self.comet_event.reset_percent() # Réinitialiser le pourcentage
def remove_life(self):
self.life -= 1
self.player.health = self.player.max_health # Réinitialiser les vies du joueur
self.comet_event.all_comets = pygame.sprite.Group(
) # Supprimer les comètes
self.comet_event.reset_percent() # Réinitialiser le pourcentage
self.all_monsters = pygame.sprite.Group(
) # Supprimer tous les monstres
self.comet_event.game.start() # Faire apparaître les monstres
self.player.rect.x = 400 # Définir l'abcisse du joueur
def check_collision(self, sprite, group):
"""Vérifier les collisions"""
return pygame.sprite.spritecollide(
sprite, group, False,
pygame.sprite.collide_mask) #Vérifier les collisions
def game_over(self): #Méthode pour réinitialiser le jeu
self.all_monsters = pygame.sprite.Group() #Supprimer tous les monstres
self.player.health = self.player.max_health #Réinitialiser les vies du joueur
self.is_playing = False #Afficher le menu du jeu
self.comet_event.all_comets = pygame.sprite.Group(
) #Supprimer les comètes
self.comet_event.reset_percent() #Réinitialiser le pourcentage
self.score = 0 #Réinitialiser le score
self.sound_manager.play_sound("game_over") #Jouer le son du Game Over
self.level = 1
self.life = 3
def add_level(self):
self.level += 1
def add_score(
self, points
): #Définir une méthode pour définir le nombre de points à ajouter au score
self.score += points #Ajouter des points au score
def update(self, screen): #Mettre à jour le jeu quand il est lancé
"""Afficher le score sur l'écran"""
self.score_text = self.font.render(
f"Score: {self.score}", 1, (0, 0, 0)) # Créer le texte du score
self.level_text = self.font.render(
f"Level: {self.level}", 1, (0, 0, 0)) # Créer le texte du niveau
self.life_text = self.font.render(
f"Lifes: {self.life}", 1,
(0, 0, 0)) # Créer le texte des vies globales
"""Dessiner les éléments"""
screen.blit(self.player.image,
self.player.rect) # Afficher le joueur sur la fenêtre
self.player.all_projectiles.draw(
screen) # Dessiner les projectiles sur la fenêtre
self.all_monsters.draw(screen) # Afficher les monstres sur la fenêtre
self.comet_event.all_comets.draw(
screen) #Dessiner sur la fenêtre les comètes
if self.end_game is False:
screen.blit(self.score_text,
(20, 20)) # Dessiner le texte du score
if self.infinite:
screen.blit(self.life_text,
(20, 60)) # Dessiner le texte des vies globales
elif self.infinite is False:
screen.blit(self.level_text,
(20, 60)) # Dessiner le texte du niveau
screen.blit(self.life_text,
(20, 100)) # Dessiner le texte des vies globales
if self.level == 10:
screen.blit(self.boss.image,
self.boss.rect) # Afficher le joueur sur la fenêtre
"""Actualiser les barres"""
self.player.updade_health_bar(
screen) # Actualiser la barre de vies du joueur
self.comet_event.update_bar(screen) #Actualiser la barre des comètes
self.player.update_animation() #Mettre à jour l'animation du joueur
if self.level == 10:
self.boss.update_health_bar(
screen) # Actualiser la barre de vies du joueur
"""Déplacer les éléments"""
"""Déplacer le projectile"""
for projectile in self.player.all_projectiles: # Dans Projectile
projectile.move() # Faire déplacer les projectile
for comet in self.comet_event.all_comets: #Dans les comètes
comet.fall() #Faire tomber la pluie de comètes
"""Appeler les évènements d'action du boss"""
if self.level == 10:
self.boss.go_and_back()
self.boss.fly()
self.block_projectile()
if self.boss.rect.x == 800:
self.event += 1
if (self.event %
2) == 0 and self.comet_event.fall_mode is False:
self.spawn_monster(Mummy)
"""Récupérer les monstres dans le main"""
for monster in self.all_monsters: # Dans Projectile
monster.forward() # Faire déplacer les projectile
monster.updade_health_bar(
screen) # Dessiner la barre de vie sur la fenêtre
monster.update_animation(
) #Mettre à jour les animations du monstre
"""Vérifier la direction du joueur"""
if self.pressed.get(
pygame.K_RIGHT
) and self.player.rect.x + self.player.rect.width < screen.get_width(
) and self.paused is False: # Vérifier
# que la touche gauche est pressée et que le joueur ne dépasse pas la bordure
# droite et que le jeu n'est pas en pause
self.player.move_right(
) # Si c'est le cas déplacer le joueur à droite
elif self.pressed.get(
pygame.K_LEFT
) and self.player.rect.x > 0 and self.paused is False: # Vérifier que la touche gauche est pressée, que
#et que le joueur ne dépasse pas la bordure gauche
self.player.move_left(
) # Si c'est le cas déplacer le joueur à gauche
elif self.pressed.get(pygame.K_m):
if self.sound_manager.sound:
self.sound_manager.sound = False
else:
self.sound_manager.sound = True
class Game:
def __init__(self):
# Generer joueur
self.all_players = pygame.sprite.Group()
self.player = Player(self)
self.all_players.add(self.player)
# Groupe de Monstres
self.all_monsters = pygame.sprite.Group()
# Jeu a commencé ou non ?
self.isPlaying = False
# Comet
self.comet_event = CometFallEvent(self)
# Gérer le son
self.soundManager = SoundManager()
# Mettre score à 0
self.score = 0
self.pressed = {}
self.font = pygame.font.Font("assets/PottaOne-Regular.ttf", 25)
def start(self):
self.isPlaying = True
self.spawn_monster(Mummy)
self.spawn_monster(Mummy)
self.spawn_monster(Alien)
def game_over(self):
# Reinit le jeu
self.all_monsters = pygame.sprite.Group()
self.player.health = self.player.max_health
self.isPlaying = False
self.comet_event.all_comets = pygame.sprite.Group()
self.comet_event.reset_percent()
self.score = 0
self.soundManager.play('gameOver')
def update(self, screen):
# Afficher le score
#font = pygame.font.SysFont("monospace", 16)
scoreText = self.font.render(f"Score: {self.score}", 1, (0, 0, 0))
screen.blit(scoreText, (20, 20))
# Appliquer l'image du joueur
screen.blit(self.player.image, self.player.rect)
# Actualiser la barre de vie du joueur
self.player.update_health_bar(screen)
# Actualiser la barre d'événement du jeu
self.comet_event.update_bar(screen)
# Actualiser l'animation du joueur
self.player.update_animation()
# Recuperer projectile
for projectile in self.player.all_projectiles:
projectile.move()
# Récupérer les Monstres
for monster in self.all_monsters:
monster.forward()
monster.update_health_bar(screen)
monster.update_animation()
# Récupérer les comètes
for comet in self.comet_event.all_comets:
comet.fall()
# Dessiner Image projectiles
self.player.all_projectiles.draw(screen)
# Dessiner Groupe de monstre
self.all_monsters.draw(screen)
# Appliquer les comètes
self.comet_event.all_comets.draw(screen)
# Vérifier si à gauche ou à droite
if self.pressed.get(
pygame.K_RIGHT
) and self.player.rect.x + self.player.rect.width < screen.get_width():
self.player.move_right()
elif self.pressed.get(pygame.K_LEFT) and self.player.rect.x > 0:
self.player.move_left()
def check_collision(self, sprite, group):
return pygame.sprite.spritecollide(sprite, group, False,
pygame.sprite.collide_mask)
def spawn_monster(self, monsterClassName):
#monster = Mummy(self)
self.all_monsters.add(monsterClassName.__call__(self))
def on_click(self, e):
"""
This is called when a click event occurs.
e is the click event.
"""
# Don't react when in move, attack or game over mode.
if (self.mode == Modes.Moving or
self.mode == Modes.GameOver):
return
# make sure we have focus and that it was the left mouse button
if (e.type == pygame.MOUSEBUTTONUP
and e.button == 1
and pygame.mouse.get_focused()):
# If this is in the map, we're dealing with units or tiles
if self.map.rect.collidepoint(e.pos):
# Get the tile's position
to_tile_pos = self.map.tile_coords(e.pos)
# get the unit at the mouseclick
unit = self.get_unit_at_screen_pos(e.pos)
if unit:
# clicking the same unit again deselects it and, if
# necessary, resets select mode
if unit == self.sel_unit:
self.change_mode(Modes.Select)
self.sel_unit = None
# select a new unit
elif (self.mode == Modes.Select and
unit.team == self.cur_team):
self.sel_unit = unit
SoundManager.play(SELECT_SOUND)
# Attack
elif (self.mode == Modes.ChooseAttack and
self.sel_unit and
to_tile_pos in self._attackable_tiles):
# Attack the selected tile
self.sel_unit_attack(to_tile_pos)
else:
# No unit there, so a tile was clicked
if (self.mode == Modes.ChooseMove and
self.sel_unit and
to_tile_pos in self._movable_tiles):
# Move to the selected tile
self.sel_unit_move(to_tile_pos)
# Otherwise, the user is interacting with the GUI panel
else:
# Check which button was pressed
for button in self.buttons:
# If the button is enabled and has a click function, call
# the function
if ((not button.condition or button.condition()) and
self.get_button_rect(button).collidepoint(e.pos)):
button.onClick()
# Play the button sound
SoundManager.play(BUTTON_SOUND)
def __init__(self, gui) -> None:
self.gui = gui
self.sounds = SoundManager(self)
self.state = CSGOState(self)
class Game:
def __init__(self, screen_width, screen_height):
#le jeu a commencé T/F
self.is_playing = False
#taille de l'ecran de jeu
self.screen_width = screen_width
self.screen_height = screen_height
#groupe de monstre
self.all_monsters = pygame.sprite.Group()
#générer l'evenement
self.comet_event = CometFallEvent(self)
#touche pressee
self.pressed = {}
#score à 0
self.score = 0
#afficher le score sur l'écran
self.font = pygame.font.Font("assets/myfont.ttf", 30)
#gerer le son
self.sound_manager = SoundManager()
def start(self):
"""lance le jeu et les monstres"""
self.is_playing = True
self.spawn_monster(Mummy)
self.spawn_monster(Mummy)
self.spawn_monster(Alien)
#le joueur dans un groupe
self.all_players = pygame.sprite.Group()
#generer notre joueur
self.player = Player(self)
#ajoute le joueur au groupe
self.all_players.add(self.player)
def add_score(self, points=10):
"""ajout de points """
self.score += points
def game_over(self):
""" arret du jeu """
#groupe de monstre vide
self.all_monsters = pygame.sprite.Group()
#groupe de comètes vide
self.comet_event.all_comets = pygame.sprite.Group()
#vie du joueur
self.player.health = self.player.max_health
#jauge d'événement à 0
self.comet_event.reset_percent()
self.is_playing = False
#remise à 0 du score
self.score = 0
#son game over
self.sound_manager.play('game_over')
def update(self, screen):
"""mise à jour des evevenements """
score_text = self.font.render(f"Score : {self.score}", 1, (0, 0, 0))
screen.blit(score_text, (20, 20))
#appliquer l'image de mon joueur
screen.blit(self.player.image, self.player.rect)
#actualise la barre de vie du joueur
self.player.update_health_bar(screen)
#actualise la barre d'évènement du jeu
self.comet_event.update_bar(screen)
#actualiser l'animation du joeur
self.player.update_animation()
#boucle sur les projectiles
for projectile in self.player.all_projectiles:
#lance projectile
projectile.move(screen.get_width())
#boucle sur les monstres
for monster in self.all_monsters:
#fait avancer les monstres
monster.forward()
#affiche bar de vie
monster.update_health_bar(screen)
#anime le monstre
monster.update_animation()
#appliquer le projectile sur l'ecran
self.player.all_projectiles.draw(screen)
#boucle sur les cometes
for comet in self.comet_event.all_comets:
comet.fall()
#appliquer les monstres
self.all_monsters.draw(screen)
#appliquer les comètes
self.comet_event.all_comets.draw(screen)
#verifie le sens de deplacement du joueur
#print(self.pressed)
#si touche droite activée
if self.pressed.get(
pygame.K_RIGHT
) and self.player.rect.x + self.player.rect.width < screen.get_width():
#déplacement à droite
self.player.move_right()
#si touche gauche activée
elif self.pressed.get(pygame.K_LEFT) and self.player.rect.x > 0:
#déplacement à gauche
self.player.move_left()
def check_collision(self, sprite, group):
"""methode qui gere les collisions"""
return pygame.sprite.spritecollide(sprite, group, False,
pygame.sprite.collide_mask)
def spawn_monster(self, monster_class_name):
"""methode d'apparition du monstre"""
#création d'une liste de monstres
self.all_monsters.add(monster_class_name.__call__(self))
class Game:
def __init__(self):
self.is_playing = False
self.all_players = pygame.sprite.Group()
self.player = Player(self)
self.all_players.add(self.player)
self.all_monsters = pygame.sprite.Group()
#gerer le son
self.sound_manager = SoundManager()
#mettre le score a 0
self.font = pygame.font.Font("assets/my_custom_font.ttf", 25)
self.score = 0
self.pressed = {}
self.comet_event = CometFallEvent(self)
def start(self):
self.is_playing = True
self.spawn_monster(Mummy)
self.spawn_monster(Mummy)
self.spawn_monster(Mummy)
self.spawn_monster(Alien)
def add_score(self, points=10):
self.score += points
def game_over(self):
self.all_monsters = pygame.sprite.Group()
self.comet_event.all_comets = pygame.sprite.Group()
self.player.health = self.player.max_health
self.comet_event.reset_percent()
self.is_playing = False
self.score = 0
#jouerle son
self.sound_manager.play('game_over')
def update(self, screen):
#afficher le score sur l ecran
score_text = self.font.render(f"Score: {self.score}", 1, (0, 0, 0))
screen.blit(score_text, (20, 20))
screen.blit(self.player.image, self.player.rect)
self.player.update_health_bar(screen)
self.comet_event.update_bar(screen)
self.player.update_animation()
for projectile in self.player.all_projectiles:
projectile.move()
for monster in self.all_monsters:
monster.forward()
monster.update_health_bar(screen)
monster.update_animation()
for comet in self.comet_event.all_comets:
comet.fall()
self.player.all_projectiles.draw(screen)
self.all_monsters.draw(screen)
self.comet_event.all_comets.draw(screen)
if self.pressed.get(pygame.K_RIGHT) and \
self.player.rect.x + self.player.\
rect.width < screen.get_width():
self.player.move_right()
elif self.pressed.get(pygame.K_LEFT) and \
self.player.rect.x > 0:
self.player.move_left()
def check_collision(self, sprite, group):
return pygame.sprite.spritecollide(sprite, group, False,
pygame.sprite.collide_mask)
def spawn_monster(self, monster_class_name):
monster = Mummy(self)
self.all_monsters.add(monster_class_name.__call__(self))
class Game():
def __init__(self):
# definir si le jeu a commence ou non
self.is_playing = False
self.player = Player(self) # Generer joueur
self.all_player = pygame.sprite.Group()
self.all_player.add(self.player)
self.all_monster = pygame.sprite.Group() # groupe de monstre
self.sound_manager = SoundManager()
self.comet_event = CometFallEvent(self)
self.font = pygame.font.Font("./assets/PottaOne.ttf", 20)
self.score = 0
self.pressed = {}
def start(self):
self.is_playing = True
self.spawn_monster(Mummy)
self.spawn_monster(Mummy)
self.spawn_monster(Alien)
def spawn_monster(self, monster_name):
self.all_monster.add(monster_name.__call__(self))
def check_collision(self, sprite, group):
return pygame.sprite.spritecollide(sprite, group, False,
pygame.sprite.collide_mask)
def add_score(self, points=10):
# ajouter le nbr ptn au score
self.score += points
def game_over(self):
# remettre le jeu a neuf et en attente
self.all_monster = pygame.sprite.Group()
self.comet_event.all_comet = pygame.sprite.Group()
self.comet_event.reset_percent()
self.player.health = self.player.max_health
self.is_playing = False
self.score = 0
# jouer le son
self.sound_manager.play("game_over")
def update(self, screen):
# afficher le score sur l'ecran
score_text = self.font.render(f"Score : {self.score}", 1, (0, 0, 0))
screen.blit(score_text, (20, 20))
# Afficher l'image du joueur
screen.blit(self.player.image, self.player.rect)
# Acualiser la barre de vie du joueur
self.player.update_health_bar(screen)
# Actualiser l'animation du joueur
self.player.update_animation()
# Actualiser la barre d'event du jeu
self.comet_event.update_bar(screen)
# recuperer les projectile du joueur
for projectile in self.player.all_projectile:
projectile.move()
# Recuperer les monstres du jeu
for monster in self.all_monster:
monster.forward()
monster.update_health_bar(screen)
monster.update_animation()
# Recuperer les comets de notre jeu
for comet in self.comet_event.all_comet:
comet.fall()
# appliquer les images du groupe projectile
self.player.all_projectile.draw(screen)
# appliquer les images du groupe monstre
self.all_monster.draw(screen)
# appliquer le groupe des comets
self.comet_event.all_comet.draw(screen)
# mouvement du joueur a droite ou gauche
if self.pressed.get(
pygame.K_RIGHT
) and self.player.rect.x + self.player.rect.width < screen.get_width():
self.player.move_right()
elif self.pressed.get(pygame.K_LEFT) and self.player.rect.x > 0:
self.player.move_left()
