def __init__(self): self.sp = SoundPlayer( sound_dir='/home/thanh/catkinws/src/mira_sound/data') rospy.init_node('mira_sound', anonymous=True) rospy.Subscriber("/mira_sound/input", Int8, self.callback) rospy.Subscriber('/mira_sound/exit', Int8, self.exit_callback) # rospy.loginfo("Sound handler ready!") rospy.spin()
def __init__(self, fullscreen=False, resolution=None, display_fps=False, sound=True): """Initialize Game""" gloss.GlossGame.__init__(self, 'Satellife') pygame.init() pygame.display.set_caption('Game') if fullscreen: self._set_fullscreen() else: self._change_resolution(resolution) self._screen_center = self.resolution / 2 self._display_fps = display_fps self.speed = 1 self.zoom = 1 self._zoom_level = 3.9 self.changed_scale = True self.gcamera = GVector(0, 0) # load sounds if sound: self.soundplayer = SoundPlayer() else: self.soundplayer = MutePlayer() # event handlers self.on_mouse_down = self._mouse_click self.on_mouse_motion = lambda x: x self.on_key_down = self._keypress self._menu = Menu(self) self.vdebugger = VectorDisplay()
async def sound(ctx: Context, *search_terms: str): if len(search_terms) == 0: await ctx.send("Nothing is not a sound, sorry!") return sound_player = SoundPlayer.get_or_create(ctx.guild) if 'skip' == search_terms[0].lower(): await sound_player.skip() elif 'stop' == search_terms[0].lower(): await sound_player.stop() else: await queue_sound(ctx, *search_terms)
class MiraSoundHandler(): def __init__(self): self.sp = SoundPlayer( sound_dir='/home/thanh/catkinws/src/mira_sound/data') rospy.init_node('mira_sound', anonymous=True) rospy.Subscriber("/mira_sound/input", Int8, self.callback) rospy.Subscriber('/mira_sound/exit', Int8, self.exit_callback) # rospy.loginfo("Sound handler ready!") rospy.spin() def exit_callback(self, data): if (data.data == EXIT_SIGNAL): rospy.loginfo('Exit signal [%d] received!' % data.data) rospy.signal_shutdown('Exit signal received') def callback(self, data): if (data.data != -1): # rospy.loginfo("Received emotion id: %s", (data.data)) self.sp.change_to_emotion(data.data) else: rospy.loginfo("Stop playing sound")
def _validate_inputs(dialog_graph: DialogGraph, images: Dict[str, Surface], sound_player: SoundPlayer): for node in dialog_graph.nodes(): if node.graphics.image_ids: for image_id in node.graphics.image_ids: if image_id not in images: raise ValueError( f"Invalid config! Graph node '{node.node_id}' refers to missing image: '{image_id}'" ) if node.sound_id: if not sound_player.has_sound(node.sound_id): raise ValueError( f"Invalid config! Graph node '{node.node_id}' refers to missing sound: '{node.sound_id}" ) background_id = dialog_graph.background_image_id if background_id and background_id not in images: raise ValueError( f"Invalid config! Graph refers to missing background image: '{background_id}'" )
def start(dialog_filepath: Optional[str] = None, image_dir: Optional[str] = None, sound_dir: Optional[str] = None): pygame.init() dialog_font = Font(f"{FONT_DIR}/Monaco.dfont", 17) choice_font = Font(f"{FONT_DIR}/Monaco.dfont", 15) dialog_graph = load_dialog_from_file(dialog_filepath) image_ids = [] animation_ids = [] if dialog_graph.background_image_id: image_ids.append(dialog_graph.background_image_id) for node in dialog_graph.nodes(): graphics = node.graphics if graphics.image_ids: image_ids += graphics.image_ids if graphics.animation_id: animation_ids.append(graphics.animation_id) images, animations = load_images(image_dir, image_ids, animation_ids) text_blip_sound_id = "text_blip.ogg" select_blip_sound_id = "select_blip.ogg" sound_ids = [ n.sound_id for n in dialog_graph.nodes() if n.sound_id is not None ] sounds = load_sounds(sound_dir, sound_ids) sounds[text_blip_sound_id] = load_sound_file( str(Path(SOUND_DIR).joinpath(text_blip_sound_id))) sounds[select_blip_sound_id] = load_sound_file( str(Path(SOUND_DIR).joinpath(select_blip_sound_id))) sound_player = SoundPlayer(sounds, sounds[text_blip_sound_id]) screen = pygame.display.set_mode(SCREEN_SIZE) pygame.display.set_caption(dialog_graph.title or dialog_filepath) app = App(screen, dialog_font, choice_font, images, animations, sound_player, dialog_graph, select_blip_sound_id) app.run()
def __init__(self, screen): self.screen = screen self.save = SaveGame() self.sound = SoundPlayer() self.menu_font = pygame.font.Font('fonts/GROTESKIA.ttf', 50) self.small_font = pygame.font.Font('fonts/C&C Red Alert [INET].ttf', 13) self.intro_graphic = pygame.image.load('graphics/background_intro.png').convert() self.background = pygame.image.load('graphics/background.png').convert() self.background_menu = pygame.image.load('graphics/background_menu.png').convert() #self.overlay_won = pygame.image.load('graphics/overlay_background.png').convert() self.overlay_won = pygame.Surface(screen.get_size()) self.overlay_won.fill((0, 0, 0)) self.overlay_won.set_alpha(128) self.won_animation = Animation('graphics/victory.json') self.quitting = False self.clock = pygame.time.Clock() self.menu_options = (Label('Play'), Label('Select Level'), Label('Help'), Label('Credits'), Label('Quit')) self.menu_widths = [self.menu_font.size(opt.name)[0] for opt in self.menu_options] self.mode = MODE_INTRO self.intro_frame = 0
class Launcher(object): def __init__(self, screen): self.screen = screen self.save = SaveGame() self.sound = SoundPlayer() self.menu_font = pygame.font.Font('fonts/GROTESKIA.ttf', 50) self.small_font = pygame.font.Font('fonts/C&C Red Alert [INET].ttf', 13) self.intro_graphic = pygame.image.load('graphics/background_intro.png').convert() self.background = pygame.image.load('graphics/background.png').convert() self.background_menu = pygame.image.load('graphics/background_menu.png').convert() #self.overlay_won = pygame.image.load('graphics/overlay_background.png').convert() self.overlay_won = pygame.Surface(screen.get_size()) self.overlay_won.fill((0, 0, 0)) self.overlay_won.set_alpha(128) self.won_animation = Animation('graphics/victory.json') self.quitting = False self.clock = pygame.time.Clock() self.menu_options = (Label('Play'), Label('Select Level'), Label('Help'), Label('Credits'), Label('Quit')) self.menu_widths = [self.menu_font.size(opt.name)[0] for opt in self.menu_options] self.mode = MODE_INTRO self.intro_frame = 0 @property def mode(self): return self._mode @mode.setter def mode(self, value): self._mode = value pygame.key.set_repeat() if value == MODE_SELECT_LEVEL: world = self.select_list[self.current_menu_item] self.select_list = world.levels self.current_menu_item = 0 elif value == MODE_SELECT_WORLD: self.current_menu_item = 0 self.read_level_info() self.select_list = sorted(self.worlds.values()) elif value == MODE_MAIN_MENU: self.current_menu_item = 0 self.select_list = self.menu_options elif value == MODE_PLAYING: self.screen.fill((0, 0, 0)) pygame.key.set_repeat(1, 150) def select_menu(self): option = self.select_list[self.current_menu_item] if self.mode == MODE_MAIN_MENU: name = option.name if name == 'Play': self.read_level_info() self.current_world, self.level_id = self.save.current() self.play() elif name == 'Select Level': self.mode = MODE_SELECT_WORLD elif name == 'Help': return False elif name == 'Quit': self.quitting = True elif self.mode == MODE_SELECT_WORLD: self.current_world = option.name self.mode = MODE_SELECT_LEVEL elif self.mode == MODE_SELECT_LEVEL: if self.save.available(self.current_world, self.current_menu_item): self.level_id = self.current_menu_item self.play() else: return False return True def read_level_info(self): filenames = glob(os.path.join('levels', '*.txt')) self.worlds = {} for filename in filenames: try: world = LevelSet(filename) except IOError: continue self.worlds[world.name] = world def play(self): self.save.set_current(self.current_world, self.level_id) self.mode = MODE_PLAYING if self.current_world == 'Tutorials': if self.level_id == 0: self.game = TutorialOne() elif self.level_id == 1: self.game = TutorialTwo() else: self.game = game.Game() else: self.game = game.Game() self.renderer = Renderer() self.game.loc_from_screen_coords = self.renderer.loc_from_screen_coords self.game.load_level(self.worlds[self.current_world].levels[self.level_id].value) self.game.start() def back(self): if self.mode == MODE_MAIN_MENU: self.quitting = True elif self.mode == MODE_SELECT_WORLD: self.mode = MODE_MAIN_MENU elif self.mode == MODE_SELECT_LEVEL: self.mode = MODE_SELECT_WORLD def start(self): self.draw() while not self.quitting: self.clock.tick(game.FRAME_RATE) if self.mode == MODE_PLAYING: self.game.main_loop() if self.game.stopping: if self.game.won: self.mode = MODE_WON self.won_animation.start() continue self.mode = MODE_MAIN_MENU self.draw() elif self.game.quitting: self.quitting = True elif not self.process_events(): continue self.draw() def draw(self): if self.mode == MODE_INTRO: self.screen.blit(self.intro_graphic, (0, 0)) alpha = int(max(0, (self.intro_frame - INTRO_DELAY) * 255.0 / (INTRO_FRAMES - INTRO_DELAY))) self.background_menu.set_alpha(alpha) self.screen.blit(self.background_menu, (0, 0)) self.intro_frame += 1 if self.intro_frame > INTRO_FRAMES: self.mode = MODE_MAIN_MENU self.draw() elif self.mode == MODE_MAIN_MENU: #self.screen.blit(self.background, (0, 0)) self.draw_main_menu() elif self.mode == MODE_SELECT_WORLD: self.screen.blit(self.background, (0, 0)) self.draw_select_list() elif self.mode == MODE_SELECT_LEVEL: self.screen.fill((0, 0, 0)) self.draw_level_list() elif self.mode == MODE_PLAYING: self.renderer.render(self.game, self.screen) elif self.mode == MODE_WON: self.renderer.render(self.game, self.screen) self.draw_won_overlay() pygame.display.flip() def draw_won_overlay(self): self.screen.blit(self.overlay_won, (0, 0)) frame = self.won_animation.get_frame() if not frame: frame = self.won_animation.images[-1] w, h = frame.get_rect().size x = WINDOW_W / 2 - w / 2 y = WINDOW_H / 2 - h / 2 self.screen.blit(frame, (x, y)) margin = 12 text = self.menu_font.render('Level complete! Yay!', True, (255, 255, 255)) text_pos = text.get_rect() text_pos.x = WINDOW_W / 2 - text_pos.width / 2 text_pos.y = y - text_pos.height - margin self.screen.blit(text, text_pos) def draw_main_menu(self): self.screen.blit(self.background_menu, (0, 0)) height = self.current_menu_item * MENU_ITEM_H + MENU_ITEM_TOP width = self.menu_widths[self.current_menu_item] self.draw_option_selector(height, width) def draw_level_list(self): margin = 8 w = (WINDOW_W - margin) / GRID_COLS - margin h = (WINDOW_H - margin) / GRID_COLS - margin y = -h for i, item in enumerate(self.select_list): if i % GRID_COLS == 0: x = -w y += margin + h x += margin + w thickness = 4 if i == self.current_menu_item else 1 completed = self.save.completed(self.current_world, i) available = self.save.available(self.current_world, i) stats = self.save.stats(self.current_world, i) colour = (172, 172, 172) if available else (64, 64, 64) if i == self.current_menu_item: border = (255, 255, 255) if available else (96, 96, 96) else: border = colour self.screen.fill(border, (x, y, w, h)) self.screen.fill(colour, (x + thickness, y + thickness, w - 2*thickness, h - 2*thickness)) id_text = self.menu_font.render(str(i+1), True, (0, 0, 0)) id_pos = id_text.get_rect() id_pos.y = y + margin/2 id_pos.centerx = x + w/2 name_text = self.small_font.render(item.name, False, (0, 0, 0)) name_pos = name_text.get_rect() name_pos.bottom = y + h - margin/2 name_pos.centerx = x + w/2 if stats: turns_text = self.small_font.render('Turns: %d' % stats['turns'], False, (64, 64, 64)) turns_pos = turns_text.get_rect() turns_pos.bottom = id_pos.bottom + margin/2 turns_pos.centerx = x + w/2 doors_text = self.small_font.render('Door uses: %d' % stats.get('uses', 0), False, (64, 64, 64)) doors_pos = doors_text.get_rect() doors_pos.top = turns_pos.bottom doors_pos.centerx = x + w/2 self.screen.blit(turns_text, turns_pos) self.screen.blit(doors_text, doors_pos) self.screen.blit(id_text, id_pos) self.screen.blit(name_text, name_pos) def draw_select_list(self): rendered_items = [] menu_height = 0 max_height = 0 for item in self.select_list: rendered_items.append(self.menu_font.render(item.name, True, (255, 255, 255))) height = rendered_items[-1].get_height() menu_height += height max_height = max(height, max_height) margin = 3 menu_top = WINDOW_H / 2 - menu_height / 2 + MENU_OFFSET for i, item in enumerate(rendered_items): x = WINDOW_W / 2 - item.get_width() / 2 self.screen.blit(item, (x, menu_top)) if i == self.current_menu_item: #x -= 8 + triangle_x self.draw_option_selector(menu_top, item.get_width()) menu_top += max_height + margin def draw_option_selector(self, y, width): x = WINDOW_W / 2 - width / 2 - 8 - SELECTOR_W pygame.draw.polygon(self.screen, (196, 196, 196), ((x-12, y+SELECTOR_H-12), (x-12, y+SELECTOR_H+12), (x, y+SELECTOR_H))) pygame.draw.aalines(self.screen, (255, 255, 255), True, ((x-12, y+SELECTOR_H-12), (x-12, y+SELECTOR_H+12), (x, y+SELECTOR_H))) x = WINDOW_W - x - SELECTOR_W pygame.draw.polygon(self.screen, (196, 196, 196), ((x+12, y+SELECTOR_H-12), (x+12, y+SELECTOR_H+12), (x, y+SELECTOR_H))) pygame.draw.aalines(self.screen, (255, 255, 255), True, ((x+12, y+SELECTOR_H-12), (x+12, y+SELECTOR_H+12), (x, y+SELECTOR_H))) def process_events(self): if self.mode == MODE_PLAYING: return True if self.mode == MODE_INTRO: for e in pygame.event.get(): if e.type == pygame.KEYDOWN: self.intro_frame = INTRO_FRAMES return True if self.mode == MODE_WON: for e in pygame.event.get(): if e.type == pygame.KEYDOWN: self.mode = MODE_SELECT_WORLD self.save.set_completed(self.current_world, self.level_id) self.save.set_stats(self.current_world, self.level_id, self.game.turn, self.game.used_doors()) next_level = self.level_id + 1 if next_level < len(self.worlds[self.current_world].levels): self.level_id = next_level self.play() elif self.worlds[self.current_world].next: self.current_world = self.worlds[self.current_world].next self.level_id = 0 self.play() break return True for e in pygame.event.get(): if e.type == pygame.QUIT: self.quitting = True return False if e.type == pygame.KEYDOWN: if e.key in game.UP_KEYS: if self.mode == MODE_SELECT_LEVEL: if self.current_menu_item - GRID_COLS >= 0: self.current_menu_item -= GRID_COLS elif self.current_menu_item < len(self.select_list) % GRID_COLS: self.current_menu_item -= len(self.select_list) % GRID_COLS else: self.current_menu_item -= len(self.select_list) % GRID_COLS + GRID_COLS else: self.current_menu_item -= 1 self.current_menu_item %= len(self.select_list) self.sound.step() return True if e.key in game.DOWN_KEYS: if self.mode == MODE_SELECT_LEVEL: if self.current_menu_item + GRID_COLS < len(self.select_list): self.current_menu_item += GRID_COLS else: self.current_menu_item %= GRID_COLS else: self.current_menu_item += 1 self.current_menu_item %= len(self.select_list) self.sound.step() return True if e.key in game.LEFT_KEYS and self.mode == MODE_SELECT_LEVEL: self.current_menu_item -= 1 self.current_menu_item %= len(self.select_list) self.sound.step() return True if e.key in game.RIGHT_KEYS and self.mode == MODE_SELECT_LEVEL: self.current_menu_item += 1 self.current_menu_item %= len(self.select_list) self.sound.step() return True if e.key in game.ACTION_KEYS: if self.select_menu(): self.sound.throw() else: self.sound.land() return True if e.key in game.QUIT_KEYS: self.back() self.sound.undo() return True if e.key in game.CHEAT_KEYS and self.mode == MODE_SELECT_LEVEL: for id in range(len(self.worlds[self.current_world].levels)): self.save.set_completed(self.current_world, id) return True
state = 0x1F last_state = 0x1F # Function to init SPI. def initSPI(): spi = spidev.SpiDev() spi.open(0,0) return spi # Start spi and init Sensors. spi = initSPI() sensors = [LaserSensor(port, spi, level) for port in range(5)] # Init sound player = SoundPlayer() try: print 'Ready to play...' while True: state = 0x00 for sensor in sensors: if (sensor.getState()): # Laser on. state = state | (1 << sensor.getPort()) # If any bits have been trun off (laser beam breaked). if ((0x1F ^ state) & last_state): # New sound should be played with the new state (if non change to off expression is false). #'{0:08b}'.format((int('00011111',2) ^ int('00011010', 2)) & int('00000111',2)) = '00000101' # 31 state prev
else: #print("bad event key!!") pass return action # Starting the game components pygame.init() pygame.display.set_caption(F.game_name) board_0 = Board() board_1 = RightBoard() status_bar = StatusBar() gen_ui = GenUI() DISPLAYSUR = pygame.display.set_mode((F.window_w, F.window_h)) controller = Controller(DISPLAYSUR) sound_player = SoundPlayer(pygame) clock = pygame.time.Clock() # setup a font for displaying block numbers GFONT = pygame.font.Font('freesansbold.ttf', F.block_font_size) GFONT_GG = pygame.font.Font('freesansbold.ttf', 66) GFONTS = [ pygame.font.Font('freesansbold.ttf', int(F.block_font_size * F.block_font_size_perc[0])), pygame.font.Font('freesansbold.ttf', int(F.block_font_size * F.block_font_size_perc[1])), pygame.font.Font('freesansbold.ttf', int(F.block_font_size * F.block_font_size_perc[2])), pygame.font.Font('freesansbold.ttf', int(F.block_font_size * F.block_font_size_perc[3])), pygame.font.Font('freesansbold.ttf',
def main(): pygame.init() directory = Path(__file__).parent font = Font(str(directory.joinpath("demo_font.dfont")), 13) screen_size = (500, 500) dialog_margin = 30 dialog_padding = 5 outer_dialog_size = (screen_size[0] - dialog_margin * 2, 330) dialog_size = (outer_dialog_size[0] - dialog_padding * 2, outer_dialog_size[1] - dialog_padding * 2) picture_component_size = (dialog_size[0], 200) screen = pygame.display.set_mode(screen_size) dialog_surface = Surface(dialog_size) dialog_pos = (dialog_margin + dialog_padding, dialog_margin + dialog_padding) dialog_rect = Rect(dialog_pos, dialog_size) images = { "demo1_background": filled_surface(picture_component_size, (0, 50, 35)) } animations = {"demo1_animation": create_animation(picture_component_size)} text_blip_sound = load_sound("blip.ogg") select_blip_sound = load_sound("blip_2.ogg") select_blip_sound_id = "blip" sound_player = SoundPlayer( sounds={select_blip_sound_id: select_blip_sound}, text_blip_sound=text_blip_sound) dialog_closed_node_id = "DIALOG_CLOSED" dialog_graph = DialogGraph( root_node_id="ROOT", nodes=[ DialogNode( node_id="ROOT", text= "This is a minimal demo app. Let this text slowly appear or click any key to skip it. " "Use the UP/DOWN keys to switch between your dialog choices, and click RETURN to go " "for that choice. Or you could just use the mouse!", choices=[ DialogChoice("See this dialog again", "ROOT"), DialogChoice("Close dialog", dialog_closed_node_id) ], graphics=NodeGraphics(animation_id="demo1_animation")), DialogNode(node_id=dialog_closed_node_id, text="", choices=[], graphics=NodeGraphics(animation_id="demo1_animation")), ], title="DEMO 1", background_image_id="demo1_background") pygame.display.set_caption(dialog_graph.title) dialog_component = DialogComponent( surface=dialog_surface, dialog_font=font, choice_font=font, images=images, animations=animations, sound_player=sound_player, dialog_graph=dialog_graph, picture_size=picture_component_size, select_blip_sound_id=select_blip_sound_id) clock = Clock() is_dialog_shown = True while True: elapsed_time = Millis(clock.tick()) for event in pygame.event.get(): if event.type == pygame.QUIT: _exit_game() elif event.type == pygame.KEYDOWN: if is_dialog_shown: dialog_component.skip_text() if event.key == pygame.K_RETURN: dialog_component.commit_selected_choice() if dialog_component.current_node_id( ) == dialog_closed_node_id: is_dialog_shown = False elif event.key == pygame.K_DOWN: dialog_component.move_choice_selection(1) elif event.key == pygame.K_UP: dialog_component.move_choice_selection(-1) elif event.type == pygame.MOUSEBUTTONDOWN: ui_coordinates = translate_screen_to_ui_coordinates( dialog_rect, pygame.mouse.get_pos()) if ui_coordinates: dialog_component.commit_choice_at_position(ui_coordinates) if dialog_component.current_node_id( ) == dialog_closed_node_id: is_dialog_shown = False elif event.type == pygame.MOUSEMOTION: ui_coordinates = translate_screen_to_ui_coordinates( dialog_rect, pygame.mouse.get_pos()) if ui_coordinates: dialog_component.select_choice_at_position(ui_coordinates) if is_dialog_shown: dialog_component.update(elapsed_time) dialog_component.redraw() screen.fill(BLACK) if is_dialog_shown: screen.blit(dialog_component.surface, dialog_pos) pygame.draw.rect(screen, (255, 100, 100), Rect((dialog_margin, dialog_margin), outer_dialog_size), width=1) fps_string = str(int(clock.get_fps())).rjust(3, ' ') rendered_fps = font.render(f"FPS: {fps_string}", True, WHITE, (0, 0, 0)) screen.blit(rendered_fps, (5, 5)) screen.blit( font.render( "The dialog library is confined to the red rectangle above.", True, WHITE), (15, 400)) screen.blit( font.render("This text is handled separately from the dialog.", True, WHITE), (15, 430)) if not is_dialog_shown: screen.blit( font.render( "Oops, you closed the dialog. Restart app to see it again.", True, (255, 150, 150)), (15, 460)) pygame.display.update()
import time from soundfile import SoundFile from sound import SoundPlayer blocksize = 1024 player = SoundPlayer(44100, 1) for block in SoundFile("Mann_short.wav").blocks(blocksize): player.play(block) while player.isplaying: time.sleep(0.1)
def main(): try: # LED settings stand = BallStand() stand.run() print "stand run" led = FullColorLED(stand) led.run() print "led run" # soud settings mixer.init(frequency = 22050, size = -16, channels = 2, buffer = 512) se = SoundPlayer() game = Game() print "soud init ok" # ble connect sm = medal.SensorMedal(ROHM_RAW) sm.getData() print "sensor medal run" # motion detect m = MotionDetecter(sm) m.run() print "motion run" # start LED color change led.standby = False # start OK voice se.playMotion("kidou") cnt = 0 while True: # volume setting if se.volume != stand.volume: se.volume = stand.volume if game.volume != stand.volume: game.volume = stand.volume if stand.mode == 0: # ? mode if sm.ang_x > 100 or sm.ang_y > 100 or sm.ang_z > 100: se.playSE("byun_w") sleep(1) if sm.ang_x < -100 or sm.ang_y < -100 or sm.ang_z < -100: se.playSE("byun_s") sleep(1) sleep(SLEEP_SEC) if stand.mode == 1: # music mode if medal.ang_x > 100: se.playSE("do") if medal.ang_y > 100: se.playSE("re") if medal.ang_z > 100: se.playSE("mi") if medal.ang_x < -100: se.playSE("fa") if medal.ang_y < -100: se.playSE("so") if medal.ang_z < -100: se.playSE("ra") sleep(SLEEP_SEC) elif stand.mode == 2: motion mode if m.motion == 1: se.playSE("roll") elif m.motion == 2: se.playMotion("hyaa", 1.2) elif m.motion == 3: se.playMotion("kyaa", 1.5) elif m.motion == 4: se.playMotion("gyaa", 2.0) sleep(0.15) elif stand.mode == 3: # game mode while stand.mode == 3: if not game.gaming: if sm.ang_x < 100.0: game.gameStart() else: if game.isLimit(): break if game.volume != stand.volume: game.changeVolume(stand.volume) sleep(0.2) if game.gaming: game.gameStop() except KeyboardInterrupt: print "Ctl - c" except: traceback.print_exc() finally: if game.gaming: game.gameStop() mixer.quit() if not m is None: m.stop() if not led is None: led.stop() print "led is stopped" if not stand is None: stand.stop() print "stand is stopped" if not sm is None: sm.stop() print "getData thread is stop" sm.disconnect()
def __init__(self): self.sound = SoundPlayer()
class Game: def __init__(self): self.sound = SoundPlayer() #self.font = pygame.font.SysFont('Sans', 18) def load_level(self, filename): self.level_file = filename self.level = load_level(self, filename) if not self.level: self.stopping = True self.player = self.level.player def can_move_to(self, obj, location): tile = self.level[location] if not tile: return False if obj.flag('player') and self.cheating: return True if obj.special: for thing in tile: if thing.blocks(obj): return False return True if tile[0].solid: # If the terrain is solid and there is a special object on the tile, use its state. for thing in tile[:0:-1]: if thing.special: if obj.flag('player'): # Don't allow the player to walk through if they're carrying something # that the special object blocks for c in obj.contained: if thing.blocks(c): return False return not thing.solid return False else: for thing in tile[1:]: if thing.solid: return False return True def get_objects_at(self, location, test=None): #First item at a location is always terrain if test is None: return self.level[location][1:] else: return [obj for obj in self.level[location][1:] if test(obj)] @staticmethod def coords_in_dir(loc, dir, dist): if loc is None: return None loc = list(loc) if dir == LEFT: loc[0] -= dist elif dir == RIGHT: loc[0] += dist elif dir == UP: loc[1] -= dist elif dir == DOWN: loc[1] += dist return tuple(loc) def used_doors(self): return sum([obj.used for obj in self.level.objects if obj.flag('door')]) def failed_move(self, location): pass def action(self, direction): if self.player.contained: if not self.throw(direction): self.sound.cancel() elif self.pickup(direction): pass elif self.close(direction): pass else: # Took no action return False return True def pickup(self, direction): pickup_loc = self.coords_in_dir(self.player.location, direction, 1) self.player.direction = direction success = False for obj in self.get_objects_at(pickup_loc)[::-1]: if obj.flag('door'): if self.level[pickup_loc][0].solid and not self.level[self.player.location][0].pickup: continue if self.player.add(obj): success = True if success: self.sound.pickup() return success def close(self, direction): self.player.direction = direction close_loc = self.coords_in_dir(self.player.location, direction, 1) for obj in self.get_objects_at(close_loc): if obj.flag('door') and not obj.solid: obj.close() return True def throw(self, direction): self.player.direction = direction success = False for obj in self.player.contained: nextloc = self.coords_in_dir(self.player.location, direction, 1) if not self.can_move_to(obj, nextloc): continue self.player.remove(obj) obj.impulse(3, direction) self.schedule_update() self.player_turn = False success = True if success: self.sound.throw() return success def win(self): #self.quitting = True self.player.animate('descending', self.end) self.block() self.won = True def end(self): self.stopping = True def display_message(self, source, message): if message != self.message: if message: self.msg_anim_frame = 0 else: self.msg_anim_frame = -20 self.message = message self.message_src = source def msg_anim_pos(self): if self.msg_anim_frame < 24: self.msg_anim_frame += 1 return self.msg_anim_frame / 24.0 def start(self): self.turn = 0 self.messages = [] self.msg_anim_frame = 0 self.state = STATE_NORMAL self.cheating = False self.player_turn = True self.next_turn = 0 self.next_update = 0 self.won = False self.message = None self.stopping = False self.quitting = False for obj in self.level.objects: obj.location = obj.location obj.record_state(self.turn) if not self.quitting: self.update() #while not self.quitting: # self.main_loop() def main_loop(self): self.player_turn = pygame.time.get_ticks() > self.next_turn took_turn = self.process_events() if took_turn: self.next_turn = pygame.time.get_ticks() + TURN_DELAY if took_turn or (not self.player_turn and pygame.time.get_ticks() > self.next_update): self.update() def process_events(self): took_turn = False if pygame.event.get(pygame.QUIT): self.quitting = True return False if not self.player_turn: return False held_keys = [key for key in HOLDABLE_KEYS if pygame.key.get_pressed()[key]] held_buttons = [button for button in HOLDABLE_BUTTONS if pygame.mouse.get_pressed()[button]] if held_keys: took_turn = self.keyheld(held_keys) elif held_buttons: took_turn = self.mouseheld(held_buttons) if not took_turn: for e in pygame.event.get(): if e.type == pygame.KEYDOWN: took_turn = self.keypressed(e) elif e.type == pygame.MOUSEBUTTONUP: took_turn = self.clicked(e) if took_turn: self.turn += 1 for obj in self.level.dynamics: obj.record_state(self.turn) return took_turn def keyheld(self, keys): took_turn = False if self.state == STATE_NORMAL: dirs = [DIR_MAP[key] for key in keys if key in DIR_MAP] if len(set(dirs)) == 1: dir = dirs[0] newloc = self.coords_in_dir(self.player.location, dir, 1) self.player.direction = dir if newloc != self.player.location: if self.can_move_to(self.player, newloc): self.player.location = newloc self.sound.step() took_turn = True else: self.failed_move(newloc) for thing in self.level[newloc]: if thing.bumped(self.player): took_turn = True break return took_turn if self.state == STATE_NORMAL or self.state == STATE_LOCKED: if filter(keys.__contains__, UNDO_KEYS): self.undo() self.sound.undo() self.state = STATE_NORMAL self.next_turn = pygame.time.get_ticks() + TURN_DELAY return took_turn def mouseheld(self, buttons): if len(buttons) == 1 and MOVE_BUTTON in buttons: # To move with the mouse, just pretend a key is being held dir = self.get_mouse_direction() if dir is not None: key = I_DIR_MAP[dir] return self.keyheld((key,)) return False def keypressed(self, e): took_turn = False if self.state == STATE_PICK: try: took_turn = self.pick_direction_done(DIR_MAP[e.key]) except KeyError: self.sound.cancel() self.state = STATE_NORMAL elif self.state == STATE_NORMAL: if e.key in ACTION_KEYS: self.pick_direction(self.action) elif e.key in CHEAT_KEYS: self.cheating = not self.cheating elif self.state == STATE_READING: if e.key in ACTION_KEYS: self.display_message(None, None) if self.state != STATE_PICK: if e.key in UNDO_KEYS: pass elif e.key in QUIT_KEYS: if self.message: self.display_message(None, None) else: self.stopping = True elif e.key in RESTART_KEYS: self.restart() return took_turn def clicked(self, e): button = e.button - 1 if self.state == STATE_PICK: # Pick state can be entered only with the keyboard; use movement key to pick direction dir = self.get_mouse_direction() if button == MOVE_BUTTON and dir: return self.pick_direction_done(dir) else: self.sound.cancel() self.state = STATE_NORMAL elif self.state == STATE_NORMAL: if button == ACTION_BUTTON: return self.action(self.get_mouse_direction()) return False def pick_direction(self, handler): """Enter targeting mode""" self.state = STATE_PICK self.pick_handler = handler self.sound.action() def pick_direction_done(self, direction): self.state = STATE_NORMAL return self.pick_handler(direction) def get_mouse_direction(self): if not self.player.location: return None mouse_x, mouse_y = self.loc_from_screen_coords(*(pygame.mouse.get_pos())) x, y = self.player.location dx, dy = mouse_x - x, mouse_y - y if abs(dx) <= 0.5 and abs(dy) <= 0.5: return None elif dy < 0 and -dy > abs(dx): return UP elif dy > 0 and dy > abs(dx): return DOWN elif dx < 0 and -dx >= abs(dy): return LEFT elif dx > 0 and dx >= abs(dy): return RIGHT def block(self): self.state = STATE_LOCKED def unblock(self): self.state = STATE_NORMAL def schedule_update(self, time=UPDATE_DELAY): self.next_update = pygame.time.get_ticks() + time self.next_turn = self.next_update + TURN_DELAY def update(self): # level.objects is a set, so the order of evaluation is undefined #self.player_turn = True for obj in self.level.dynamics: if obj.resolve_movement(): obj.record_state(self.turn) self.schedule_update() def restart(self): self.load_level(self.level_file) self.start() #self.turn = 0 #for obj in self.level.objects: # obj.restore_state(self.turn) def undo(self): if self.turn == 0: return False self.turn -= 1 for obj in self.level.dynamics: obj.restore_state(self.turn)