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