def test_morse_to_sound(self, text, output):
"""This test checks if the message in Morse code will have have the correct length when it will be an audio
Morse code.
"""
object = SoundManager()
length_array = str(len(object.morse_text_to_sound(text_to_sound=text)))
assert length_array == output
def __init__(self, dimensions, game_model):
self.dimensions = dimensions
# The most important object for this instance:
# The game we want to display
self.game_model = game_model
# cell width and height are floats
self.cell_width = dimensions[0]/float(self.game_model.dimensions[0])
self.cell_height = dimensions[1]/float(self.game_model.dimensions[1])
pygame.Surface.__init__(self, self.dimensions)
# A timer in milliseconds
self.clock = 0
# The threshold (in milliseconds) indicating that the next step is due
self.drop_interval = 500
self.info_panel = InfoPanel((350, 600), self.game_model)
self.message_layover = TransparentLayover(self)
self.last_frame_before_death_rendered = False
# Plug the into game a sound manager to get notified
# of sound-worthy events.
self.sound_manager = SoundManager()
self.game_model.add_observer(self.sound_manager)
self.sound_manager.play_background_music()
def __init__(self):
# definir si le jeu a commencer ou non
self.is_playing = False
self.all_players = pygame.sprite.Group()
# generer notre joueur
self.player = Player(self)
self.all_players.add(self.player)
# generer l'evenement
self.comet_event = CometFallEvent(self)
# definir un groupe de monsters
self.all_monsters = pygame.sprite.Group()
# gerer le son
self.sound_manager = SoundManager()
# mettre le score à zero
self.score = 0
self.pressed = {}
def __init__(self, starting_level=None):
self.settings = Settings(constants.DEFAULT_SETTINGS, "game")
self.font_manager = FontManager()
self.sound_manager = SoundManager(self.settings)
self.sound_manager.trigger_music("movemovemove.ogg", 0.7)
self.levels = []
# this is dumb :P
for i in xrange(1, 10000):
try:
level = level_loader.load_level(i, self)
self.levels.append(level.name)
except:
break
if starting_level is not None:
self.current_level = starting_level
self.max_level = self.current_level
self.stage = STAGE_LEVEL
self.restart_level()
self.menu = None
else:
self.current_level = 1
self.max_level = self.current_level
self.stage = STAGE_MENU
self.level = None
self.menu = menu.MainMenu(self, None)
self.menu_stack = []
self.events = []
self.should_quit = False
self.victory = None
def __init__(self):
# Definir si notre jeu à 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)
# Générer l'évenement
self.comet_event = CometFallEvent(self)
# Creez un groupe de monstre
self.all_monsters = pygame.sprite.Group()
# gerer le son
self.sound_manager = SoundManager()
self.font = pygame.font.Font("assets/my_custom_font.ttf", 25)
#mettre le score à 0
self.score = 0
self.pressed = {}
def __init__(self, physics, renderer, levelFilePath):
self.physics = physics
self.physics.reset()
self.renderer = renderer
self.renderer.reset()
self.triggerManager = trigger.TriggerManager()
self.levelFilePath = levelFilePath
self.player = None
self.finished = False
self.map = map.Map(self.levelFilePath).getMapInstance()
self.entities = []
self.cutSceneState = False
self._loadEntityFile(self.map.entityFilePath)
SoundManager.playSound("background_theme", -1, 1500)
def __init__(self):
#definir si le jeu a commencé
self.is_playing = False
#générer le joueur
self.all_players = pygame.sprite.Group()
self.player = Player(self)
self.all_players.add(self.player)
#APPEL MESSAGERIE
self.message = Message(self)
#gérer l'event
self.comet_event = CometFallEvent(self)
#groupe de monstre
self.all_monsters = pygame.sprite.Group()
self.score = 0
self.pressed = {}
self.font = pygame.font.Font("assets/font.ttf", 25)
self.sound_manager = SoundManager()
def __init__(self):
ShowBase.__init__(self)
add_device_listener(
config_file='keybindings.toml',
assigner=SinglePlayerAssigner(),
)
base.disableMouse()
self.sound = SoundManager()
self.linefx = LineEffects()
self.cardmaker = CardMaker("card")
self.cardmaker.set_frame(-1,1,-1,1)
self.turn_speed = 0.3 #length of turn animation in seconds
self.sequence_player = SequencePlayer()
self.transition = Transitions(loader)
self.interface = Interface()
self.bg_color = VBase4(0, 0, 0, 1)
self.innitialize_fov()
card, scene, camera, self.buffer = self.make_render_card()
card.set_x(-0.25)
self.camera = camera
self.load_icons()
self.texts = Texts(camera)
self.pause = True
self.instruct = True
self.gameover = False
self.won = False
self.player = Player((0,0,0))
self.map = Map()
self.map.new_game()
camera.reparent_to(self.player.root)
camera.set_pos(4,-4,8)
camera.look_at(self.player.root)
camera.set_compass()
base.task_mgr.add(self.update)
card, scene, camera, buffer = self.make_render_card([3,7],[64,256],(0,100))
self.hudgun = Actor("assets/models/hand.bam")
self.hudgun.reparent_to(scene)
self.hudgun.find("**/hand_healthy").show()
self.hudgun.find("**/hand_hurt").hide()
self.hudgun.setLODAnimation(1, 0.1, 0.005)
self.player.weapon.set_hud_bullets()
camera.look_at(self.hudgun)
camera.set_pos(0.5,-1.5,10)
camera.set_p(-90)
card.set_scale(1/4,1,1)
card.set_x(1-(1/4))
self.quad = None
self.setup_post_effect()
def __init__(self, window):
self.is_playing = False
self.pressed = {}
self.pressed2 = {}
self.pressed3 = {}
self.sound_manager = SoundManager()
self.screen = window.screen
self.screen_width = self.screen.get_width()
self.screen_height = self.screen.get_height()
self.floor = 500
# player
self.all_sprites = pygame.sprite.Group()
self.player = Joueur()
self.player2 = Joueur2()
self.all_sprites.add(self.player)
self.all_sprites.add(self.player2)
class MorseInterface:
"""This class allows to handle the operations via graphical interface. Those operations can be such as: translation
messages from and to Morse code and save the messages, it allows to listen, stop listening and save audio Morse
file with different frequencies.
"""
def __init__(self):
"""Constructor method."""
self.language = LanguageManager()
self.sound = SoundManager()
self.window = Tk()
self.conversion = ConversionManager()
self.window.title("Fun with Morse")
self.window.geometry("1000x700")
self.window.resizable(False, False)
self.window.config(padx=40, pady=20, bg=BG_COLOUR)
self.window.iconbitmap('./images/morse_icon.ico')
self.language_to = StringVar(self.window)
self.language_to.set(self.language.translator)
self.options_list = [
self.language.to_language, self.language.from_language
]
self.options_menu = OptionMenu(self.window, self.language_to,
*self.options_list)
self.options_menu.config(width=16)
self.options_menu.place(x=750, y=215)
self.translated_text = None
# Add flags.
img_en = Image.open("./images/united_kingdom.png").resize(
(WIDTH_FLAG, HEIGHT_FLAG))
img_pl = Image.open("./images/poland.png").resize(
(WIDTH_FLAG, HEIGHT_FLAG))
img_fre = Image.open("./images/france.png").resize(
(WIDTH_FLAG, HEIGHT_FLAG))
img_ger = Image.open("./images/germany.png").resize(
(WIDTH_FLAG, HEIGHT_FLAG))
england_flag = ImageTk.PhotoImage(img_en)
poland_flag = ImageTk.PhotoImage(img_pl)
france_flag = ImageTk.PhotoImage(img_fre)
germany_flag = ImageTk.PhotoImage(img_ger)
# Add buttons.
self.button_en = Button(
self.window,
image=england_flag,
highlightthickness=0,
command=lambda: self.change_program_language('EN'))
self.button_en.place(x=780, y=0)
self.button_pl = Button(
self.window,
image=poland_flag,
highlightthickness=0,
command=lambda: self.change_program_language('PL'))
self.button_pl.place(x=820, y=0)
self.button_fre = Button(
self.window,
image=france_flag,
highlightthickness=0,
command=lambda: self.change_program_language('FRE'))
self.button_fre.place(x=860, y=0)
self.button_ger = Button(
self.window,
image=germany_flag,
highlightthickness=0,
command=lambda: self.change_program_language('GER'))
self.button_ger.place(x=900, y=0)
self.title_label = Label(self.window,
text=self.language.title,
bg=BG_COLOUR,
fg=FG_COLOUR,
font=("verdana", 35, "bold"),
pady=30)
self.title_label.place(x=100, y=20)
self.input_label = Label(self.window,
text=self.language.your_text,
fg=BG_ENTRY_COLOUR,
justify='left',
bg=BG_COLOUR,
font=('verdana', 12, 'bold'))
self.input_label.place(x=0, y=190)
self.input_entry = scrolledtext.ScrolledText(self.window,
font=('verdana', 12),
height=10,
width=60,
bg=BG_ENTRY_COLOUR,
cursor="pencil",
wrap=WORD)
self.input_entry.focus()
self.input_entry.place(x=110, y=130)
self.load_text_button = Button(self.window,
text=self.language.load_file,
font=('verdana', 15),
justify='center',
width=10,
command=self.load_file)
self.load_text_button.place(x=750, y=160)
self.apply_button = Button(self.window,
text=self.language.convert,
font=('verdana', 15),
justify='center',
width=10,
command=self.convert)
self.apply_button.place(x=750, y=250)
self.output_label = Label(self.window,
text=self.language.morse_message,
fg=BG_ENTRY_COLOUR,
justify='left',
bg=BG_COLOUR,
font=('verdana', 12, 'bold'))
self.output_label.place(x=0, y=390)
self.output = scrolledtext.ScrolledText(self.window,
font=('verdana', 12),
height=10,
width=60,
bg=BG_ENTRY_COLOUR,
wrap=WORD,
state='disabled')
self.output.place(x=110, y=330)
self.copy_button = Button(self.window,
text=self.language.copy_text,
font=('verdana', 15),
justify='center',
width=10,
command=self.copy_text_to_clipboard)
self.copy_button.place(x=750, y=350)
self.save_button = Button(self.window,
text=self.language.save,
font=('verdana', 15),
justify='center',
width=10,
command=self.save_text)
self.save_button.place(x=750, y=410)
self.delete_button = Button(self.window,
text=self.language.delete,
font=('verdana', 15),
justify='center',
width=10,
command=self.delete_text)
self.delete_button.place(x=750, y=470)
self.play_button = Button(self.window,
text=self.language.start,
font=('verdana', 15),
justify='center',
width=10,
command=self.play_morse_sound)
self.frequency_label = Label(self.window,
text=self.language.frequency,
fg=BG_ENTRY_COLOUR,
justify='left',
bg=BG_COLOUR,
font=('verdana', 12, 'bold'))
self.frequency_scale = Scale(self.window,
orient="horizontal",
bg=FG_COLOUR,
from_=400,
to=900,
resolution=50,
sliderlength=20,
length=150,
fg=BG_ENTRY_COLOUR,
font=('verdana', 10, 'bold'))
self.frequency_scale.set(self.sound.frequency)
self.stop_button = Button(self.window,
text=self.language.stop,
font=('verdana', 15),
justify='center',
width=10,
command=self.stop_playing)
self.save_sound_button = Button(self.window,
text=self.language.save_sound,
font=('verdana', 15),
justify='center',
width=20,
command=self.save_morse_sound)
self.window.mainloop()
def convert(self):
"""This method is used to program the action of the button responsible for choosing the translation of the text
from or to the Morse code.
"""
self.output.configure(state='normal')
self.output.delete("1.0", END)
text = self.input_entry.get("1.0", END)
text = text.replace("\n", " ")
if self.language_to.get() in list(
languages_words[item]["translator"]
for item in list(languages_words.keys())):
messagebox.showwarning(title="Error",
message=self.language.translator)
elif self.language_to.get() in list(
languages_words[item]["to_language"]
for item in list(languages_words.keys())):
self.show_widgets()
self.translated_text = self.conversion.convert_text_to_morse(
text[:-1])
self.output.insert(END, self.translated_text)
self.output.configure(state='disabled')
elif self.language_to.get() in list(
languages_words[item]["from_language"]
for item in list(languages_words.keys())):
self.hide_widgets()
self.translated_text = self.conversion.convert_morse_to_text(text)
self.output.insert(END, self.translated_text)
self.output.configure(state='disabled')
def delete_text(self):
"""Delete your text and Morse code from fields when the delete_button is clicked."""
self.output.configure(state='normal')
self.hide_widgets()
self.language_to.set(self.language.translator)
self.output.delete("1.0", END)
self.input_entry.delete("1.0", END)
self.input_entry.focus()
self.output.configure(state='disabled')
def copy_text_to_clipboard(self):
"""Copy converted text to clipboard when the copy_button is clicked."""
self.window.clipboard_clear()
self.window.clipboard_append(self.translated_text)
def save_text(self):
"""Save converted text to the computer when the save_button is clicked."""
text = self.output.get("1.0", END)
if text is not None:
files = [('Text Document', '*.txt')]
morse_file = asksaveasfile(title=self.language.save_in_direction,
filetypes=files,
defaultextension=files)
if morse_file is not None:
morse_file.write(text)
morse_file.close()
def load_file(self):
"""Load text for translation from the computer when the load_text_button is clicked."""
files = [('Text Document', '*.txt')]
text_file = askopenfile(mode='r',
title=self.language.load_from_direction,
filetypes=files,
defaultextension=files)
if text_file is not None:
text_inside = text_file.read()
text_file.close()
self.input_entry.insert("1.0", text_inside)
def change_program_language(self, program_language):
"""Change text version of the application when one of the flag buttons is clicked."""
self.language.change_language(program_language)
self.input_label.config(text=self.language.your_text)
self.title_label.config(text=self.language.title)
self.load_text_button.config(text=self.language.load_file)
self.apply_button.config(text=self.language.convert)
self.output_label.config(text=self.language.morse_message)
self.copy_button.config(text=self.language.copy_text)
self.save_button.config(text=self.language.save)
self.delete_button.config(text=self.language.delete)
self.frequency_label.config(text=self.language.frequency)
self.play_button.config(text=self.language.start)
self.stop_button.config(text=self.language.stop)
self.save_sound_button.config(text=self.language.save_sound)
self.options_list = [
self.language.to_language, self.language.from_language
]
self.language_to.set(self.language.translator)
languages_menu = self.options_menu["menu"]
languages_menu.delete(0, END)
for string in self.options_list:
languages_menu.add_command(
label=string,
command=lambda value=string: self.language_to.set(value))
def play_morse_sound(self):
"""Play the audio Morse code when the play_button is clicked."""
freq = self.frequency_scale.get()
self.sound.frequency = freq
text_to_sound = self.output.get("1.0", END)
self.sound.convert(self.sound.morse_text_to_sound(text_to_sound))
self.sound.play_audio()
def save_morse_sound(self):
"""Save the audio Morse code to audio file to the computer when the save_sound_button is clicked."""
files = [('Sound', '*.wav')]
morse_file = asksaveasfile(title=self.language.save_sound,
filetypes=files,
defaultextension=files)
if morse_file is not None:
freq = self.frequency_scale.get()
self.sound.frequency = freq
text_to_sound = self.output.get("1.0", END)
self.sound.convert(self.sound.morse_text_to_sound(text_to_sound))
self.sound.save(morse_file.name)
morse_file.close()
def stop_playing(self):
"""Stop audio Morse code playback when the stop_button is clicked."""
self.sound.playing_object.stop()
def show_widgets(self):
"""Show widgets supporting audio Morse code."""
self.play_button.place(x=300, y=560)
self.frequency_label.place(x=110, y=530)
self.frequency_scale.place(x=110, y=560)
self.frequency_scale.set(self.sound.frequency)
self.stop_button.place(x=460, y=560)
self.save_sound_button.place(x=630, y=560)
def hide_widgets(self):
"""Hide widgets supporting audio Morse code."""
self.play_button.place_forget()
self.frequency_label.place_forget()
self.frequency_scale.place_forget()
self.frequency_scale.place_forget()
self.stop_button.place_forget()
self.save_sound_button.place_forget()
def __init__(self):
"""Constructor method."""
self.language = LanguageManager()
self.sound = SoundManager()
self.window = Tk()
self.conversion = ConversionManager()
self.window.title("Fun with Morse")
self.window.geometry("1000x700")
self.window.resizable(False, False)
self.window.config(padx=40, pady=20, bg=BG_COLOUR)
self.window.iconbitmap('./images/morse_icon.ico')
self.language_to = StringVar(self.window)
self.language_to.set(self.language.translator)
self.options_list = [
self.language.to_language, self.language.from_language
]
self.options_menu = OptionMenu(self.window, self.language_to,
*self.options_list)
self.options_menu.config(width=16)
self.options_menu.place(x=750, y=215)
self.translated_text = None
# Add flags.
img_en = Image.open("./images/united_kingdom.png").resize(
(WIDTH_FLAG, HEIGHT_FLAG))
img_pl = Image.open("./images/poland.png").resize(
(WIDTH_FLAG, HEIGHT_FLAG))
img_fre = Image.open("./images/france.png").resize(
(WIDTH_FLAG, HEIGHT_FLAG))
img_ger = Image.open("./images/germany.png").resize(
(WIDTH_FLAG, HEIGHT_FLAG))
england_flag = ImageTk.PhotoImage(img_en)
poland_flag = ImageTk.PhotoImage(img_pl)
france_flag = ImageTk.PhotoImage(img_fre)
germany_flag = ImageTk.PhotoImage(img_ger)
# Add buttons.
self.button_en = Button(
self.window,
image=england_flag,
highlightthickness=0,
command=lambda: self.change_program_language('EN'))
self.button_en.place(x=780, y=0)
self.button_pl = Button(
self.window,
image=poland_flag,
highlightthickness=0,
command=lambda: self.change_program_language('PL'))
self.button_pl.place(x=820, y=0)
self.button_fre = Button(
self.window,
image=france_flag,
highlightthickness=0,
command=lambda: self.change_program_language('FRE'))
self.button_fre.place(x=860, y=0)
self.button_ger = Button(
self.window,
image=germany_flag,
highlightthickness=0,
command=lambda: self.change_program_language('GER'))
self.button_ger.place(x=900, y=0)
self.title_label = Label(self.window,
text=self.language.title,
bg=BG_COLOUR,
fg=FG_COLOUR,
font=("verdana", 35, "bold"),
pady=30)
self.title_label.place(x=100, y=20)
self.input_label = Label(self.window,
text=self.language.your_text,
fg=BG_ENTRY_COLOUR,
justify='left',
bg=BG_COLOUR,
font=('verdana', 12, 'bold'))
self.input_label.place(x=0, y=190)
self.input_entry = scrolledtext.ScrolledText(self.window,
font=('verdana', 12),
height=10,
width=60,
bg=BG_ENTRY_COLOUR,
cursor="pencil",
wrap=WORD)
self.input_entry.focus()
self.input_entry.place(x=110, y=130)
self.load_text_button = Button(self.window,
text=self.language.load_file,
font=('verdana', 15),
justify='center',
width=10,
command=self.load_file)
self.load_text_button.place(x=750, y=160)
self.apply_button = Button(self.window,
text=self.language.convert,
font=('verdana', 15),
justify='center',
width=10,
command=self.convert)
self.apply_button.place(x=750, y=250)
self.output_label = Label(self.window,
text=self.language.morse_message,
fg=BG_ENTRY_COLOUR,
justify='left',
bg=BG_COLOUR,
font=('verdana', 12, 'bold'))
self.output_label.place(x=0, y=390)
self.output = scrolledtext.ScrolledText(self.window,
font=('verdana', 12),
height=10,
width=60,
bg=BG_ENTRY_COLOUR,
wrap=WORD,
state='disabled')
self.output.place(x=110, y=330)
self.copy_button = Button(self.window,
text=self.language.copy_text,
font=('verdana', 15),
justify='center',
width=10,
command=self.copy_text_to_clipboard)
self.copy_button.place(x=750, y=350)
self.save_button = Button(self.window,
text=self.language.save,
font=('verdana', 15),
justify='center',
width=10,
command=self.save_text)
self.save_button.place(x=750, y=410)
self.delete_button = Button(self.window,
text=self.language.delete,
font=('verdana', 15),
justify='center',
width=10,
command=self.delete_text)
self.delete_button.place(x=750, y=470)
self.play_button = Button(self.window,
text=self.language.start,
font=('verdana', 15),
justify='center',
width=10,
command=self.play_morse_sound)
self.frequency_label = Label(self.window,
text=self.language.frequency,
fg=BG_ENTRY_COLOUR,
justify='left',
bg=BG_COLOUR,
font=('verdana', 12, 'bold'))
self.frequency_scale = Scale(self.window,
orient="horizontal",
bg=FG_COLOUR,
from_=400,
to=900,
resolution=50,
sliderlength=20,
length=150,
fg=BG_ENTRY_COLOUR,
font=('verdana', 10, 'bold'))
self.frequency_scale.set(self.sound.frequency)
self.stop_button = Button(self.window,
text=self.language.stop,
font=('verdana', 15),
justify='center',
width=10,
command=self.stop_playing)
self.save_sound_button = Button(self.window,
text=self.language.save_sound,
font=('verdana', 15),
justify='center',
width=20,
command=self.save_morse_sound)
self.window.mainloop()
class Game:
def __init__(self):
#definir si le jeu a commencé
self.is_playing = False
#générer le joueur
self.all_players = pygame.sprite.Group()
self.player = Player(self)
self.all_players.add(self.player)
#APPEL MESSAGERIE
self.message = Message(self)
#gérer l'event
self.comet_event = CometFallEvent(self)
#groupe de monstre
self.all_monsters = pygame.sprite.Group()
self.score = 0
self.pressed = {}
self.font = pygame.font.Font("assets/font.ttf", 25)
self.sound_manager = SoundManager()
def start(self):
self.is_playing = True
#self.spawn_monster(BadWorm)
#self.spawn_monster(BadWorm)
#self.spawn_monster(Boss)
def game_over(self):
#remettre le jeu à neuf, retirer les monstres, remettre le joeueur à 100 vie, jeu en attente
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
self.sound_manager.play('game_over')
def add_score(self, points=10):
self.score += points
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))
#AFFICHAGE MESSAGERIE
self.message.init_messagerie(screen)
#appliquer 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'event
self.comet_event.update_bar(screen)
#actualiser l'animation du joueur
self.player.update_animation()
#recup les projectiles du joueur
for projectile in self.player.all_projectiles:
projectile.move()
#recup les monstres du jeu
for monster in self.all_monsters:
monster.forward()
monster.update_health_bar(screen)
monster.update_animation()
#recup les comets
for comet in self.comet_event.all_comets:
comet.fall()
#appliquer les projectiles
self.player.all_projectiles.draw(screen)
#appliquer l'ensemble des images de mon groupe de monstre
self.all_monsters.draw(screen)
#appliquer l'ensemble des images de mon groupe de comettes
self.comet_event.all_comets.draw(screen)
#verfier si le joueur souhaite aller à gauche ou à droite ou sauter
if self.pressed.get(
pygame.K_RIGHT
) and self.player.rect.x + self.player.rect.width < screen.get_width():
self.player.move_right()
if self.pressed.get(pygame.K_LEFT) and self.player.rect.x > 0:
self.player.move_left()
#CODE JUMP
if self.pressed.get(pygame.K_UP):
self.player.jump()
def check_collision(self, sprite, group):
return pygame.sprite.spritecollide(sprite, group, False,
pygame.sprite.collide_mask)
def spawn_monster(self, monster_class_name):
self.all_monsters.add(monster_class_name.__call__(self))
from mumble import MumbleAdapter
from sound import SoundManager
def connected():
print('Mumble: Connected')
mumble = MumbleAdapter()
mumble.connect('192.168.1.104', 'test_client')
mumble.start()
mumble.on_connect(connected)
sound = SoundManager(mumble)
class GameWindow(pygame.Surface):
"""
The game window is the visualization of the game instance it is
responsible for.
"""
def __init__(self, dimensions, game_model):
self.dimensions = dimensions
# The most important object for this instance:
# The game we want to display
self.game_model = game_model
# cell width and height are floats
self.cell_width = dimensions[0]/float(self.game_model.dimensions[0])
self.cell_height = dimensions[1]/float(self.game_model.dimensions[1])
pygame.Surface.__init__(self, self.dimensions)
# A timer in milliseconds
self.clock = 0
# The threshold (in milliseconds) indicating that the next step is due
self.drop_interval = 500
self.info_panel = InfoPanel((350, 600), self.game_model)
self.message_layover = TransparentLayover(self)
self.last_frame_before_death_rendered = False
# Plug the into game a sound manager to get notified
# of sound-worthy events.
self.sound_manager = SoundManager()
self.game_model.add_observer(self.sound_manager)
self.sound_manager.play_background_music()
def get_total_width(self):
return self.get_width() + self.info_panel.get_width()
def tear_down(self):
self.sound_manager.stop_background_music()
def update_view(self, screen):
"""
Render self and status window. Screen object to
draw on is passed as an argument.
"""
self.render_game_window()
screen.blit(self, (0, 0))
self.render_status_window()
screen.blit(self.info_panel, (self.get_width(), 0))
def render_game_window(self):
"""
Game may either be in state
- over: display game over screen
- won: display winner screen
- waiting for other players: display waiting screen
- in progress: display game
"""
if self.game_model.gameover:
# We may need to render one last frame
if not self.last_frame_before_death_rendered:
self.render_game()
self.last_frame_before_death_rendered = True
else:
self.render_game_over_screen()
elif self.game_model.victorious:
self.render_winner_screen()
elif self.game_model.get_errors():
self.render_error_screen(self.game_model.get_errors())
elif not self.game_model.started:
self.render_waiting_screen()
else:
self.render_game()
def render_status_window(self):
"""
Render the status window depending on game type.
"""
if self.game_model.listener:
self.info_panel.renderMultiPlayerScreen()
else:
self.info_panel.renderSinglePlayerScreen()
def render_game(self):
"""
Visualizes the game model, i.e. paints the game grid
"""
self.fill((0, 0, 0))
for idx, cell_value in enumerate(self.game_model.cells):
if cell_value:
# cell is filled with dead matter
self.draw_cell(idx, cell_value)
elif idx in self.game_model.moving_piece_indexes:
# this cell is part of the moving piece
self.draw_cell(idx, self.game_model.moving_piece.color)
def draw_cell(self, index, color):
"""
Draws a single cell in the grid with a given index (i.e. position)
and the specified color.
"""
top, left = divmod(index, self.game_model.column_nr)
top = top * self.cell_height
left = left * self.cell_width
rect = pygame.Rect((left, top), (self.cell_width, self.cell_height))
self.fill(color, rect)
self.fill(self.darken(color), pygame.Rect((left, top), (self.cell_width, 2)))
self.fill(self.darken(color), pygame.Rect((left, top), (2, self.cell_height)))
self.fill(self.lighten(color), pygame.Rect((left, top + self.cell_height - 2), (self.cell_width, 2)))
self.fill(self.lighten(color), pygame.Rect((left + self.cell_width - 2, top), (2, self.cell_height)))
def lighten(self, color):
return [int(x * 0.2) for x in color]
def darken(self, color):
return [min(255, int(x * 1.3)) for x in color]
def render_waiting_screen(self):
"""
For multiplayer games: We might be waiting for other players.
"""
missing = self.game_model.listener.get_number_of_players_missing()
plural_s = 's' if missing != 1 else ''
text = "Waiting for %s more player%s ..." % (missing, plural_s)
self.message_layover.render_message(text, fontsize=14, fade=False)
def render_error_screen(self, msg):
"""
For multiplayer games: We might be waiting for other players.
"""
text = "ERROR: %s" % msg
self.message_layover.render_message(text, fontsize=14, fade=False)
def render_game_over_screen(self):
"""
Game's over. Draw a layover telling the player about his failure.
"""
self.message_layover.render_message("GAME OVER", fontsize=48, fade=True)
def render_winner_screen(self):
"""
Player wins the multiplayer match!
"""
self.message_layover.render_message("YOU WIN", fontsize=48, fade=True)
class Game:
def __init__(self):
# definir si le jeu a commencer ou non
self.is_playing = False
self.all_players = pygame.sprite.Group()
# generer notre joueur
self.player = Player(self)
self.all_players.add(self.player)
# generer l'evenement
self.comet_event = CometFallEvent(self)
# definir un groupe de monsters
self.all_monsters = pygame.sprite.Group()
# gerer le son
self.sound_manager = SoundManager()
# mettre le score à zero
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 add_score(self, score=10):
self.score += score
def game_over(self):
# remettre le jeu à neuf
# retirer le monstre
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
# joueur le son
self.sound_manager.play('game_over')
def update(self, surface):
# afficher le score sur l'ecran
font = pygame.font.SysFont("monospace", 16, bold=True)
score_text = font.render(
f"Score : {self.score}",
1,
(0, 0, 0),
)
surface.blit(score_text, (20, 20))
# appliquer l'image de mon joeur
surface.blit(self.player.image, self.player.rect)
# actualiser la barre de vie du joueur
self.player.update_health_bar(surface)
# actualiser la barre d'evenment du jeu
self.comet_event.update_ber(surface)
# actualiser l'animation du joueur
self.player.update_animation()
# recuperer les projectiles que le joueur lance
for projectile in self.player.all_projectille:
projectile.move()
# recuperer les monstres de notre jeu
for monster in self.all_monsters:
monster.forward()
monster.update_health_bar(surface)
monster.update_animation()
# recuperer le comet du jeu
for comet in self.comet_event.all_comets:
comet.fall()
# appliquer l'ensemble des image du projectile
self.player.all_projectille.draw(surface)
# appliquer l'ensemble des images du groupe monster
self.all_monsters.draw(surface)
# appliquer l'ensemble des image du groupe comet
self.comet_event.all_comets.draw(surface)
# pour verifier si le joueur souhaite aller à gauche ou à droite
if self.pressed.get(
pygame.K_RIGHT
) and self.player.rect.x < surface.get_width() - 200:
self.player.move_rigth()
elif self.pressed.get(pygame.K_LEFT) and self.player.rect.x > 0:
self.player.move_left()
def spawn_monster(self, monster_name):
self.all_monsters.add(monster_name.__call__(self))
def check_collision(self, sprite, groupe):
return pygame.sprite.spritecollide(sprite, groupe, False,
pygame.sprite.collide_mask)
def handleInput(self):
for event in pygame.event.get():
if event.type == pygame.QUIT:
self.stateManager.endGame()
elif event.type == pygame.KEYDOWN:
if event.key == pygame.K_ESCAPE:
self.stateManager.endGame()
elif event.key == pygame.K_UP:
self.menuManager.curMenu.moveUp()
elif event.key == pygame.K_DOWN:
self.menuManager.curMenu.moveDown()
elif event.key == pygame.K_RETURN:
self.menuManager.curMenu.execute()
elif event.key == pygame.K_m:
# only change if there is a level loaded
if self.stateManager.stateList[
StateManager.
GAMESTATE].levelManager.curLevel != None:
Event().raiseCstmEvent(
Event.SWITCHSTATE,
argDict={"state": StateManager.GAMESTATE})
#custom events
elif event.type == Event().NEWGAME:
self.stateManager.switchState(self.stateManager.GAMESTATE)
gameState = self.stateManager.getGameState()
gameState.levelManager.loadLevel(
gameState.levelManager.FIRSTLEVEL)
elif event.type == Event().SWITCHMENU:
self.menuManager.loadMenu(event.mIndex)
elif event.type == Event().SWITCHSTATE:
self.stateManager.switchState(event.state)
elif event.type == Event().SWITCHLEVEL:
self.stateManager.getGameState().levelManager.loadLevel(
event.levelIndex)
Event().raiseCstmEvent(Event().SWITCHSTATE, {"state": 0})
elif event.type == Event().OPTIONSWITCH:
itemChanged = False
if event.option == "ISFULLSCR" or event.option == "ISDEBUG" or event.option == "ISSOUND":
if Options.getOption(event.option) == False:
Options.setOption(event.option, True)
itemChanged = True
elif Options.getOption(event.option) == True:
Options.setOption(event.option, False)
itemChanged = True
elif event.option == "VOLUME" or event.option == "RESOLUTION":
list = []
if event.option == "VOLUME": list = Options.volumeList
elif event.option == "RESOLUTION":
list = Options.resolutionList
valFound = False
for i in range(0, len(list) - 1):
if list[i] == Options.getOption(event.option):
valFound = True
Options.setOption(event.option,
list[i + 1 % len(list)])
itemChanged = True
break
if not valFound:
Options.setOption(event.option, list[0])
itemChanged = True
if itemChanged:
if event.option == "ISFULLSCR" or event.option == "RESOLUTION":
if Options.getOption("ISFULLSCR"):
self.screen = pygame.display.set_mode(
Options.getOption("RESOLUTION"),
pygame.FULLSCREEN)
else:
self.screen = pygame.display.set_mode(
Options.getOption("RESOLUTION"))
elif event.option == "VOLUME":
SoundManager.updateVolumes()
def switchState(self, stateI):
if stateI == StateManager.GAMESTATE:
SoundManager.playSound("background_theme", loops=-1, fade_ms=1500)
else:
SoundManager.stopSound("background_theme", fade_ms=1500)
self.curState = self.stateList[stateI]
def _loadInfo(self, infoTree):
for infoNode in infoTree.childNodes:
if infoNode.nodeName == 'type':
pass
elif infoNode.nodeName == "points":
pass
elif infoNode.nodeName == "life":
self.life = int(infoNode.firstChild.data)
elif infoNode.nodeName == 'movespeed':
self.movespeed = Vector(int(infoNode.firstChild.data), 0)
elif infoNode.nodeName == 'jumpspeed':
self.jumpspeed = Vector(0, int(infoNode.firstChild.data))
elif infoNode.nodeName == 'jumpSound':
for cNode in infoNode.childNodes:
if cNode.nodeName == "soundFile":
SoundManager.addSound("player_jump",
str(cNode.firstChild.data))
elif infoNode.nodeName == 'sprite':
for animationNode in infoNode.childNodes:
if animationNode.nodeName == 'animation':
animationIndex = animationNode.getAttribute('index')
animationGraphics = []
for cNode in animationNode.childNodes:
if cNode.nodeName == 'type':
animationType = str(cNode.firstChild.data)
elif cNode.nodeName == "image":
for ccNode in cNode.childNodes:
if ccNode.nodeName == "graphic":
animationGraphics.append(
str(ccNode.firstChild.data))
self.sprite.addAnimation(animationType,
animationGraphics)
elif infoNode.nodeName == 'colShape':
for colRectNode in infoNode.childNodes:
if colRectNode.nodeName == 'colRect':
posUpperLeft = [0, 0]
dimensions = [0, 0]
isSpike = None
isBody = None
colRectIndex = int(colRectNode.getAttribute("index"))
for colRectInfoNode in colRectNode.childNodes:
if colRectInfoNode.nodeName == 'posUpperLeft':
for posUpperLeftNode in colRectInfoNode.childNodes:
if posUpperLeftNode.nodeName == 'horizontal':
posUpperLeft[0] = int(
posUpperLeftNode.firstChild.data)
elif posUpperLeftNode.nodeName == 'vertical':
posUpperLeft[1] = int(
posUpperLeftNode.firstChild.data)
elif colRectInfoNode.nodeName == 'dimensions':
for dimensionsNode in colRectInfoNode.childNodes:
if dimensionsNode.nodeName == 'horizontal':
dimensions[0] = int(
dimensionsNode.firstChild.data)
elif dimensionsNode.nodeName == 'vertical':
dimensions[1] = int(
dimensionsNode.firstChild.data)
elif colRectInfoNode.nodeName == 'isBody':
isBody = util.string2bool(
colRectInfoNode.firstChild.data)
elif colRectInfoNode.nodeName == 'isSpike':
isSpike = util.string2bool(
colRectInfoNode.firstChild.data)
self.colShape.addRect(posUpperLeft, dimensions, isBody,
isSpike)
self._calcDimensions()
class Game:
def __init__(self, starting_level=None):
self.settings = Settings(constants.DEFAULT_SETTINGS, "game")
self.font_manager = FontManager()
self.sound_manager = SoundManager(self.settings)
self.sound_manager.trigger_music("movemovemove.ogg", 0.7)
self.levels = []
# this is dumb :P
for i in xrange(1, 10000):
try:
level = level_loader.load_level(i, self)
self.levels.append(level.name)
except:
break
if starting_level is not None:
self.current_level = starting_level
self.max_level = self.current_level
self.stage = STAGE_LEVEL
self.restart_level()
self.menu = None
else:
self.current_level = 1
self.max_level = self.current_level
self.stage = STAGE_MENU
self.level = None
self.menu = menu.MainMenu(self, None)
self.menu_stack = []
self.events = []
self.should_quit = False
self.victory = None
# register an action to be executed before the next
# update cycle. Do this in order to prevent changing
# things in the middle of an update cycle which is Bad.
def register_event(self, event):
event.set_game(self)
self.events.append(event)
def resume(self):
self.stage = STAGE_LEVEL
def start_new_game(self):
self.current_level = 1
self.restart_level()
self.stage = STAGE_LEVEL
def quit(self):
self.should_quit = True
def advance_level(self):
self.current_level += 1
try:
self.restart_level()
self.max_level = max(self.max_level, self.current_level)
except:
self.level = None
self.victory = VictoryScreen(self)
self.stage = STAGE_VICTORY
def hot_swap(self, module):
if self.settings['hot_swap']:
pass
#import reloader.reloader as reloader
#reloader.reload(module)
def restart_level(self):
self.hot_swap(level_loader)
self.level = level_loader.load_level(self.current_level, self)
def go_to_level(self, level):
self.current_level = level
self.restart_level()
self.stage = STAGE_LEVEL
def enter_menu(self, sub_menu=None):
if sub_menu is None:
self.hot_swap(menu)
self.menu = menu.MainMenu(self, self.level)
self.menu_stack = []
self.stage = STAGE_MENU
else:
self.menu_stack.append(self.menu)
self.menu = sub_menu
def back_menu(self):
self.menu = self.menu_stack.pop()
def update(self, delta, pygame_events, pressed, mouse):
old_stage = self.stage
for event in self.events:
event.do()
self.events = []
if self.should_quit:
return True
for event in pygame_events:
if self.stage is STAGE_LEVEL:
if event.type == pygame.KEYDOWN and event.key == pygame.K_r and not self.level.is_finished():
self.restart_level()
elif event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE:
self.enter_menu()
elif self.stage is STAGE_VICTORY:
if event.type == pygame.KEYDOWN or event.type == pygame.MOUSEBUTTONDOWN:
if self.victory.cooldown == 0:
self.enter_menu()
# do this check so we don't accidentally update with
# unintentional input.
# this kind of sucks, maybe there's a purpose to
# update_controls() methods after all?
if old_stage is self.stage:
if self.stage is STAGE_LEVEL:
self.level.update(delta, pygame_events, pressed, mouse)
elif self.stage is STAGE_MENU:
self.menu.update(delta, pygame_events, pressed, mouse)
elif self.stage is STAGE_VICTORY:
self.victory.update(delta, pygame_events, pressed, mouse)
return False
def draw(self, screen):
if self.stage is STAGE_LEVEL:
self.level.draw(screen)
elif self.stage is STAGE_MENU:
self.menu.draw(screen)
elif self.stage is STAGE_VICTORY:
self.victory.draw(screen)
class Game:
def __init__(self):
# Definir si notre jeu à 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)
# Générer l'évenement
self.comet_event = CometFallEvent(self)
# Creez un groupe de monstre
self.all_monsters = pygame.sprite.Group()
# gerer le son
self.sound_manager = SoundManager()
self.font = pygame.font.Font("assets/my_custom_font.ttf", 25)
#mettre le score à 0
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 add_score(self, points=10):
self.score += points
def game_over(self):
# Remettre le jeu à neuf , retirer les monstre , remettre le joueur à 100 de vie , jeu en attente
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
# jouer le son
self.sound_manager.play('game_over')
def update(self, screen):
#Afficher le score sur l'écran
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)
# Actualiser la barre de vie de mon joueur
self.player.update_healht_bar(screen)
# Actualiser la barre d'évenement du jeu
self.comet_event.update_bar(screen)
# Actualiser l'animation du joueur
self.player.update_animation()
# Récupérer les porjectile du joueur
for projectile in self.player.all_projectiles:
projectile.move()
# Récupérer les monstre de notre jeu
for monster in self.all_monsters:
monster.forward()
monster.update_healht_bar(screen)
monster.update_animation()
# Récupérer les comets de notre jeu
for comet in self.comet_event.all_comets:
comet.fall()
# Appliquer l'enssemble des image de mon groupe de projectile
self.player.all_projectiles.draw(screen)
# Appliquer l'enssemble des images de mon groupe de monstre
self.all_monsters.draw(screen)
# Appliquer l'ensemble des image de mon groupe de comettes
self.comet_event.all_comets.draw(screen)
# verifier si le joueur souhaite allez à 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, monster_class_name):
self.all_monsters.add(monster_class_name.__call__(self))
def test_is_morse(self, text):
"""This test checks if the message in Morse is in Morse code."""
object = SoundManager()
with pytest.raises(Exception):
assert object.create_sound_array(text)
#!/usr/bin/env python
import logging
from lights import LightsManager
from sound import SoundManager
from sprak import SprakController
if __name__ == '__main__':
logging.basicConfig(level=logging.DEBUG)
sounds = SoundManager()
sounds.start()
lights = LightsManager()
sprak = SprakController(sounds, lights)
sprak.run()
def jump(self, ignoreJumpLock=False):
if not self.jumplock or ignoreJumpLock:
SoundManager.playSound("player_jump")
self.jumplock = True
self.velocity.y = self.jumpspeed.y
def _loadMapFile(self, mapFile):
xmlMapTree = minidom.parse(RessourceLoader.getCorrectLevelPath(mapFile))
docRoot = xmlMapTree.firstChild
for node in docRoot.childNodes:
#--------mapName--------
if node.nodeName == "name":
self.mapTitle = node.firstChild.data.strip()
#--------mapTiles--------
elif node.nodeName == 'tiles':
self.tiles[0] = Tile("blank", "blank", None, False, False)
self.tiles[1] = Tile("blocker", "blocker", None, True, False)
self.tileCount = len([cNode for cNode in node.childNodes if cNode.nodeName == 'tile'])
for cNode in node.childNodes:
if cNode.nodeName == "tile":
tileIndex = int(cNode.getAttribute('index'))
for ccNode in cNode.childNodes:
if ccNode.nodeName == "name":
tileName = str(ccNode.firstChild.data.strip())
elif ccNode.nodeName == 'type':
tileType = str(ccNode.firstChild.data.strip())
elif ccNode.nodeName == 'graphic':
tileGraphic = str(ccNode.firstChild.data.strip())
elif ccNode.nodeName == 'accessibility':
if ccNode.firstChild.data.strip() == 'true':
tileAccessibility = True
elif ccNode.firstChild.data.strip() == 'false':
tileAccessibility = False
elif ccNode.nodeName == 'dangerousness':
if ccNode.firstChild.data.strip() == 'true':
tileDangerousness = True
elif ccNode.firstChild.data.strip() == 'false':
tileDangerousness = False
self.tiles[tileIndex] = Tile(tileName, tileType, tileGraphic, tileAccessibility, tileDangerousness)
#--------mapBackground--------
elif node.nodeName == 'background':
self.bgLayerCount = len([cNode for cNode in node.childNodes if cNode.nodeName == 'bgLayer']) #Anzahl der bgLayer-nodes
for cNode in node.childNodes:
if cNode.nodeName == 'bgLayer':
bgLayerIndex = int(cNode.getAttribute('index'))
for ccNode in cNode.childNodes:
if ccNode.nodeName == 'speed':
bgLayerSpeed = int(ccNode.firstChild.data.strip()) #bgLayerSpeed
elif ccNode.nodeName == 'graphic':
bgLayerGraphic = str(ccNode.firstChild.data.strip()) #bgLayerImage
self.bgLayers[bgLayerIndex] = BgLayer(bgLayerSpeed, bgLayerGraphic) #0=position in px
#--------mapMusic--------
elif node.nodeName == 'music':
for cNode in node.childNodes:
if cNode.nodeName == 'backgroundTheme':
for ccNode in cNode.childNodes:
if ccNode.nodeName == 'soundFile':
SoundManager.addSound("background_theme",str(ccNode.firstChild.data.strip()))
#--------mapGrid--------
elif node.nodeName == 'grid':
self.gridLayerCount = len([cNode for cNode in node.childNodes if cNode.nodeName == 'gridLayer']) #Anzahl der gridlayer-nodes
self.dimensions = [0,0] #start counting from 1 not 0!!
#TODO: filter NOT rectangular grids and raise exception!
for cNode in node.childNodes:
if cNode.nodeName == 'gridLayer':
gridLayerIndex = int(cNode.getAttribute('index'))
self.mapGrid.append([])
for colNode in cNode.childNodes:
if colNode.nodeName == 'column':
columnIndex = int(colNode.getAttribute('index'))
if columnIndex+1 > self.dimensions[0]: self.dimensions[0] = columnIndex+1
self.mapGrid[gridLayerIndex].append([])
for rowNode in colNode.childNodes:
if rowNode.nodeName == 'row':
rowIndex = int(rowNode.getAttribute('index'))
if rowIndex+1 > self.dimensions[1]: self.dimensions[1] = rowIndex+1
self.mapGrid[gridLayerIndex][columnIndex].append(None)
for tileIndex in rowNode.childNodes:
if tileIndex.nodeName == 'tileIndex':
self.mapGrid[gridLayerIndex][columnIndex][rowIndex] = int(tileIndex.firstChild.data.strip()) #mapGrid
#--------entityFile--------
elif node.nodeName == 'entityFile':
self.entityFilePath = node.firstChild.data.strip() #entityFile Path
