def player_hit(self): """Method called when the player is hit by an ennemy ship or bullet. Make a recovery time for the ship after collision""" if not(self.playership.recover): AudioManager.play_sound("explosion") self.life -= 1 self.playership.recover = True self.score_multiplier = 1
def destroy(self): """Called when the ennemy is destroyed. Might spawn a bonus.""" AudioManager.play_sound("explosion2") if random.random() < POWERUP_SPAWN_RATE: ef = get_random_powerup()() hitbox = Rectangle(self.hitbox.x, self.hitbox.y, 32, 32) pw = WorldPowerUp(hitbox, ef, random.random() < POWERUP_MYSTERY_RATE) self.world.powerups.append(pw)
def apply_effect(self, effect): AudioManager.play_sound("powerup") if effect.effecttype is not None and effect.effecttype in self.powerup_sockets: self.powerup_sockets[effect.effecttype].remove(self) self.powerup_sockets.pop(effect.effecttype) effect.apply(self) self.powerup_sockets[effect.effecttype] = effect if effect.time > 0: print("BITE") self.time_effects[effect] = effect.time
def handle_event(self, event): if event.type == SDL_QUIT: sys.exit("Closing the game...") self.running = False elif event.type == SDL_KEYDOWN and event.key.repeat == 0: key = event.key.keysym.sym if key == SDLK_UP: self.world.playership.vely = -self.playership.maxspeed elif key == SDLK_DOWN: self.world.playership.vely = self.playership.maxspeed elif key == SDLK_LEFT: self.world.playership.velx = -self.playership.maxspeed elif key == SDLK_RIGHT: self.world.playership.velx = self.playership.maxspeed elif key == SDLK_SPACE: self.shooting = True elif key == SDLK_p and self.playership.shootingdelay > 0: self.playership.shootingdelay /= 2 elif key == SDLK_m: self.playership.shootingdelay *= 2 elif key == SDLK_ESCAPE: self.running = False elif key == SDLK_F1: self.debug_info = not self.debug_info elif key == SDLK_F2: # self.pause = not self.pause AudioManager.play_sound("bleep") pauseState = Pause(self.graphics, self) pauseState.run() AudioManager.play_sound("bleep") self.clock.tick() elif key == SDLK_e: self.test_effect1.apply(self.playership) elif key == SDLK_r: self.test_effect2.apply(self.playership) elif event.type == SDL_KEYUP: key = event.key.keysym.sym if key == SDLK_RIGHT: if self.playership.velx > 0: self.playership.velx = 0 elif key == SDLK_LEFT: if self.playership.velx < 0: self.playership.velx = 0 elif key == SDLK_DOWN: if self.playership.vely > 0: self.playership.vely = 0 elif key == SDLK_UP: if self.playership.vely < 0: self.playership.vely = 0 elif key == SDLK_SPACE: self.shooting = False
def __init__(self, window, view, parent_object = None): QGraphicsScene.__init__(self, window) self.application = window.application self.window = window self.view = view self.parent_object = parent_object if parent_object is None: self.update_timer = QTimer(self) self.update_timer.timeout.connect(self.update_loop) # MMF 1.5 is 50 FPS self.update_timer.start((1 / 50.0) * 1000) self.values = {} self.strings = {} self.players = [Player(START_LIVES) for _ in xrange(4)] self.audio = AudioManager() start_index = 0 if FAST_CONNECT: start_index = 4 self.set_frame(start_index, True) else: scene = parent_object.scene self.values = scene.values self.strings = scene.strings self.players = scene.players self.audio = scene.audio self.key_presses = [] self.key_downs = [] self.mouse_downs = []
def __init__(self): """Create the main menu.""" super(Bombercan, self).__init__('BomberCan', 500, 500, 80) # Play BGM self.audio = AudioManager() self.audio.play('bombercan.wav', loop=True) # Display the main menu self.menu = MenuScene( parent=self, style={}, audio=self.audio, key_up=self.key_up, key_down=self.key_down, on_game_start=self.game_start ) # Prepare the end scene self.end = EndScene( parent=self, style={}, key_up=self.key_up, key_down=self.key_down, on_game_reset=self.game_reset ) self.game_reset()
def update(self, delta): if self.pause: AudioManager.set_music_volume(0.1) return if self.shooting: self.world.playership.shoot() if not(self.pause): AudioManager.set_music_volume(1) self.world.update(delta) self.running = self.running and not self.world.gameover self.debug_fps = 1 / delta if self.world.standby_ennemies == [] and self.world.active_ennemies == [] and self.world.bullets == []: self.timerEnd += delta if self.timerEnd >= 3: self.score.add_score(self.world.score) self.score.save() self.running = False
def update(self, delta): if self.pause: AudioManager.set_music_volume(0.1) return if self.shooting: self.world.playership.shoot() if not(self.pause): AudioManager.set_music_volume(1) self.world.update(delta) self.running = self.running and not self.world.gameover self.debug_fps = 1 / delta # new ennemies if self.world.active_ennemies == [] and self.world.standby_ennemies == [] and self.currentlevel < 4: self.currentlevel += 1 level = Level(self.currentlevel, self.world, self.world.camera.y, 20) self.world.standby_ennemies = level.level elif self.world.active_ennemies == [] and self.world.standby_ennemies == [] and self.currentlevel == 4: level = Level(self.currentlevel, self.world, self.world.camera.y, 20) self.world.standby_ennemies = level.level
def __init__(self): ShowBase.__init__(self) self.camera.setPosHpr(0, -12, 8, 0, -35, 0) self.disableMouse() self.tourBlanc = True self.Plateau = Plateau(self.render, self.loader) self.IA = bloc_IA(self.Plateau) self.son = AudioManager(self.loader) self.menu = Menu(self.loader, self.Plateau, self.son, self.IA) #mise en place des raccourcis self.accept('1', lambda: self.Plateau.jouerMouvement(0)) self.accept('2', lambda: self.Plateau.jouerMouvement(1)) self.accept('3', lambda: self.Plateau.jouerMouvement(2)) self.accept('4', lambda: self.Plateau.jouerMouvement(3)) self.accept('5', lambda: self.Plateau.jouerMouvement(4)) self.accept('6', lambda: self.Plateau.jouerMouvement(5)) self.accept('7', lambda: self.Plateau.jouerMouvement(6)) self.accept('8', lambda: self.Plateau.jouerMouvement(7)) self.accept('9', lambda: self.Plateau.jouerMouvement(8)) self.accept('r', self.Plateau.reset) self.accept('a', self.Plateau.annulerMouvement) self.accept('d', self.Plateau.dechargerGraphismes) self.accept('c', self.Plateau.chargerGraphismes) self.accept('t', self.test)
def __init__(self, token=None, cs=BrianCS, use_voice_receive_hooks=False): """ Create a new bot instance. token is the bot token to authenticate with. If it is None, the token will be read from the configuration file instead. cs is the class of the conversation simulator to use. It must be a subclass of conversation.ConversationSimulator(). Defaults to conversation.BrianCS(). """ super().__init__() self._autosave_active = False self._connected_futures = [] self.event(self.on_message) self.event(self.on_ready) self.command_parser = cmdsys.CommandParser() self.config = ConfigManager(path=self.CFG_PATH / "bot.xml", requireVersion=2) self.db = DatabaseManager(path=self.CFG_PATH / "db") self.db.register_model(BlockedUser) self.db.register_model(BlockedChannel) self.db.register_model(PinChannel) self.db.register_model(AuditLogChannel) self.db.register_model(TimeoutRole) self.db.register_model(TimeoutCount) self.db.register_model(PinReactionSettings) self.db.register_model(VoiceClientSettings) self.audio = AudioManager(self) self.cs = cs(self, self.config) self.voice_receive = None if use_voice_receive_hooks: rhasspy_address = (self.config.getElementText("bot.network.rhasspy.host"), self.config.getElementInt("bot.network.rhasspy.port")) self.voice_receive = ConnectionListener(self, RhasspyRE(rhasspy_address)) self.logger.warn("Voice receive hooks have been ENABLED. This is considered an experimental feature and should be used with great caution.") self.cidsl_parser = interaction.DSLParser() self.cidsl = interaction.DSLInterpreter(self) self.cidsl.registerAudioEngine(self.audio) for i in os.listdir("chat/scripts"): p = os.path.join("chat/scripts", i) if (not os.path.isfile(p)) or (not p.endswith(".ci")): continue f = open(p, "r") self.logger.debug("Loading CIDSL script at %s..." % p) try: self.cidsl.compile(self.cidsl_parser.parse("\n".join(f.readlines()))) except: self.logger.exception("Exception occured while loading CIDSL script at %s: " % p) f.close() cmdsys.environment.update_environment({ "client": self, "config": self.config, "database": self.db, "audio": self.audio, "conversation_simulator": self.cs, "voice_receive": self.voice_receive, "cidsl": self.cidsl }) self.load_commands() self.token = token or self.config.getElementText("bot.token")
class ProtosBot(Client): """ ProtOS Discord Bot """ logger = logging.getLogger("Bot") CMD_PATH = Path("commands") CFG_PATH = Path("config") SOUND_DIR = Path("sounds") def __init__(self, token=None, cs=BrianCS, use_voice_receive_hooks=False): """ Create a new bot instance. token is the bot token to authenticate with. If it is None, the token will be read from the configuration file instead. cs is the class of the conversation simulator to use. It must be a subclass of conversation.ConversationSimulator(). Defaults to conversation.BrianCS(). """ super().__init__() self._autosave_active = False self._connected_futures = [] self.event(self.on_message) self.event(self.on_ready) self.command_parser = cmdsys.CommandParser() self.config = ConfigManager(path=self.CFG_PATH / "bot.xml", requireVersion=2) self.db = DatabaseManager(path=self.CFG_PATH / "db") self.db.register_model(BlockedUser) self.db.register_model(BlockedChannel) self.db.register_model(PinChannel) self.db.register_model(AuditLogChannel) self.db.register_model(TimeoutRole) self.db.register_model(TimeoutCount) self.db.register_model(PinReactionSettings) self.db.register_model(VoiceClientSettings) self.audio = AudioManager(self) self.cs = cs(self, self.config) self.voice_receive = None if use_voice_receive_hooks: rhasspy_address = (self.config.getElementText("bot.network.rhasspy.host"), self.config.getElementInt("bot.network.rhasspy.port")) self.voice_receive = ConnectionListener(self, RhasspyRE(rhasspy_address)) self.logger.warn("Voice receive hooks have been ENABLED. This is considered an experimental feature and should be used with great caution.") self.cidsl_parser = interaction.DSLParser() self.cidsl = interaction.DSLInterpreter(self) self.cidsl.registerAudioEngine(self.audio) for i in os.listdir("chat/scripts"): p = os.path.join("chat/scripts", i) if (not os.path.isfile(p)) or (not p.endswith(".ci")): continue f = open(p, "r") self.logger.debug("Loading CIDSL script at %s..." % p) try: self.cidsl.compile(self.cidsl_parser.parse("\n".join(f.readlines()))) except: self.logger.exception("Exception occured while loading CIDSL script at %s: " % p) f.close() cmdsys.environment.update_environment({ "client": self, "config": self.config, "database": self.db, "audio": self.audio, "conversation_simulator": self.cs, "voice_receive": self.voice_receive, "cidsl": self.cidsl }) self.load_commands() self.token = token or self.config.getElementText("bot.token") def load_commands(self): """ (Re)loads commands. """ self.commands = cmdsys.load_commands(self.CMD_PATH) for command in self.commands: command.client = self def run(self): """ Run the bot instance. This call will block. """ self.logger.debug("Starting...") super().run(self.token) def wait_for_connection(self): if self.is_ready(): f = asyncio.Future() f.set_result(True) return f f = asyncio.Future() self._connected_futures.append(f) return f def log_message(self, msg: Message): """ Logs the message to the console window. Includes pretty printer options for server, channel, names/nicknames and role color """ logger = self.logger.getChild("MessageLog") s = cmdutils.translateString(msg.content) a = cmdutils.translateString(msg.author.name) if hasattr(msg.author, "nick") and msg.author.nick: a = cmdutils.translateString(msg.author.nick) + "/" + a for i in msg.attachments: #display attachments s += "\n => with attachment:" for j in i.items(): s += "\n " + j[0] + ": " + str(j[1]) if isinstance(msg.channel, discord.abc.PrivateChannel): #We received a DM instead of a server message, this means most of our code is not required if isinstance(msg.channel, discord.DMChannel): name = msg.channel.recipient.name else: name = getattr(msg.channel, "name", msg.channel.recipients[0].name) logger.info("[DM][%s](%s): %s" % (name, a, s)) return color = msg.author.colour.to_rgb() if hasattr(msg.author, "colour") else (0, 0, 0) logger.info("[%s][%s](%s): %s" % (msg.guild.name, msg.channel.name, cmdutils.colorText(a, color), s)) async def on_ready(self): """ Event handler for ready events. Finishes initialization and schedules periodic tasks. """ self.logger.info(S_TITLE_VERSION) self.logger.info("-"*50) self.logger.info("Ready.") await asyncio.sleep(3) #wait a short amount of time until we have received all data self.logger.debug("Starting autosave scheduler...") self.loop.create_task(self._autosave()) game = Game(name= "%s | %s%s" % (S_VERSION, self.config.getElementText("bot.prefix"), "about")) await self.change_presence(activity=game) for f in self._connected_futures: f.set_result(True) async def on_message(self, msg: Message): """ Event handler for messages. Handles command dispatch through text chat as well as interaction with CIDSL and conversation simulators. """ self.log_message(msg) if msg.content.startswith(self.config.getElementText("bot.prefix")): responseHandle = ChatResponse(self, msg) await self.command_parser.parse_command(responseHandle, self.commands, self) else: if self.user.mentioned_in(msg) and not msg.author.id == self.user.id: await msg.channel.trigger_typing() #makes it seem more real (TODO: we need a way to terminate this if the following code throws an error) if self.cidsl.run(msg): return #use our MegaHal implementation to get a response if self.config.getElementText("bot.chat.aistate") == "off": #AI turned off await msg.channel.send(msg.author.mention + ", Sorry, this feature is unavailable right now. Please try again later.") return if msg.guild: #Check if this channel is blocked for AI if len(self.db.get_db_by_message(msg).query(BlockedChannel).filter(channel_id=msg.channel.id)) > 0: #YOU'RE BANNED await msg.channel.send(msg.author.mention + ", " + interaction.confused.getRandom()) return if not ("<@" + str(self.user.id) + ">" in msg.content or "<@!" + str(self.user.id) + ">" in msg.content): #cheking for group mentions #must be either @here or @everyone... make this a rare occurance if random.random() > 0.01: #only process every 100th message return response = await self.cs.respond(msg) if self.config.getElementText("bot.chat.aistate") == "passive": #AI in passive mode return if isinstance(response, bytes): await msg.channel.send(msg.author.mention + ", " + response.decode()) #post our answer else: await msg.channel.send(msg.author.mention + ", " + response) elif len(msg.content) > 0 and (not msg.author.id == self.user.id): #we don't want the bot to listen to its own messages if self.config.getElementText("bot.chat.aistate") == "off": #AI turned off return if msg.guild: #Check if this channel is blocked for AI if len(self.db.get_db_by_message(msg).query(BlockedChannel).filter(channel_id=msg.channel.id)) > 0: #YOU'RE BANNED return await self.cs.observe(msg) c = msg.content.lower() if " ram " in c or c.startswith("ram ") or c.endswith(" ram") or c == "ram": #Make the bot sometimes respond to its name when it comes up for i in msg.guild.emojis: #Always try to add a "Ram" emoji if available if i.name.lower() == "ram": await msg.add_reaction(i) break if random.random() <= 0.001: #Responds with a probability of 1:1000 await msg.channel.send(interaction.mentioned.getRandom()) #IT HAS BECOME SELF AWARE!!! async def on_voice_state_update(self, what, before, after): before_channel = before.channel after_channel = after.channel #Voice line handling if (after_channel and after_channel != before_channel): #if the user is connected and has changed his voice channel (this may mean he just joined) if what.guild.voice_client and (after_channel == what.guild.voice_client.channel): #we are in the same channel as our target #Use new dynamic voiceline handling (voicelines are compared by User ID / Filename instead of a dictionary lookup #This isn't necessarily any faster but it is more convenient and doesn't require a restart to assign voicelines dir = os.listdir(self.SOUND_DIR / "voicelines") for i in dir: if os.path.isdir(self.SOUND_DIR / "voicelines" / i) and i == str(what.id): #we have a voiceline folder for this member files = os.listdir(self.SOUND_DIR / "voicelines" / i) if not files: #no voicelines found, return return filepath = self.SOUND_DIR / "voicelines" / i / random.choice(files) sound = FFMPEGSound(filepath.as_posix()) self.audio.playSound(sound, after_channel, sync=False) return async def _autosave(self): """ Periodic autosave task. Runs every 5 minutes and writes changes made to the config and the CS to the filesystem. """ logger = self.logger.getChild("Autosave") if self._autosave_active: logger.warn("Autosave task was triggered but is already running!") return self._autosave_active = True while not self.is_closed(): await asyncio.sleep(300) logger.info("Periodic backup task triggered.") await self.save() self._autosave_active = False async def save(self): """ Save the current configuration. """ self.logger.debug("Saving data...") self.config.save() await self.cs.setOpt("SAVE", None) self.logger.debug("Backup complete!") async def shutdown(self, reason=""): """ Shut down the bot. This coroutine will correctly deinitialize all submodules and run all cleanup functions before shutting down the event loop and exiting. reason specifies an optional string to log when shutting the bot down. """ self.logger.info("Shutting down with reason: %s" % reason) await cmdsys.cleanUp() await self.save() await self.logout() await self.close()
def __init__(self, x, y, velx=0, vely=-900, damage=8): self.hitbox = Rectangle(x, y, 8, 8) self.velx = velx # px/s self.vely = vely self.damage = damage AudioManager.play_sound("laser")
def handle_event(self, event): if event.type == SDL_QUIT: self.running = False elif event.type == SDL_DROPFILE: self.clock.tick() elif event.type == SDL_KEYDOWN and event.key.repeat == 0: if event.key.keysym.sym == SDLK_ESCAPE: self.running = False elif event.key.keysym.sym == SDLK_F1: self.debug_info = not self.debug_info def draw(self): pass def stop(self): self.running = False if __name__ == "__main__": ext.init() graphics = Graphics(SCREEN_WIDTH, SCREEN_HEIGHT) AllSprite.load_sprites(graphics) AudioManager.init_audio() load_audio() FontManager.load_font("ressources/Rebellion.ttf", "rebel", 28) FontManager.load_font("ressources/DejaVuSansMono.ttf", "dejavu", 20) game = Menu(graphics) game.run() ext.quit()
if AUDIO: s.shutdown() quit() if FULLSCREEN: screen = pg.display.set_mode((WIDTH, HEIGHT), pg.FULLSCREEN) else: screen = pg.display.set_mode((WIDTH, HEIGHT)) FONT = pg.font.Font(load_resource("JetBrainsMono-Medium.ttf"), 12) BACKGROUND = pg.image.load(load_resource("gameboard.jpg")).convert() pg.display.set_caption(f"ALTAR CLIENT username = {USERNAME}") if AUDIO: audio = AudioManager() def main(): clock = pg.time.Clock() ########### # GUI ITEMS ########### drop_c = DropZone(ZONE_COORS[0]) drop_r = DropZone(ZONE_COORS[1]) drop_l = DropZone(ZONE_COORS[2]) hand = HandZone((685, 850)) discard = DiscardSpace((50, 50)) draw = DrawSpace((WIDTH - 150, 50))
class MainScene(QGraphicsScene): frame = None loop_count = 0 parent_scene = None current_dt = 0.0 next_frame = None def __init__(self, window, view, parent_object = None): QGraphicsScene.__init__(self, window) self.application = window.application self.window = window self.view = view self.parent_object = parent_object if parent_object is None: self.update_timer = QTimer(self) self.update_timer.timeout.connect(self.update_loop) # MMF 1.5 is 50 FPS self.update_timer.start((1 / 50.0) * 1000) self.values = {} self.strings = {} self.players = [Player(START_LIVES) for _ in xrange(4)] self.audio = AudioManager() start_index = 0 if FAST_CONNECT: start_index = 4 self.set_frame(start_index, True) else: scene = parent_object.scene self.values = scene.values self.strings = scene.strings self.players = scene.players self.audio = scene.audio self.key_presses = [] self.key_downs = [] self.mouse_downs = [] def update_loop(self): try: if self.next_frame is not None: self.set_frame(self.next_frame, True) self.next_frame = None return self.loop_count += 1 current_time = get_time() dt = current_time - self.current_time self.current_time = current_time self.audio.update(dt) self.make_update(dt) except: import traceback traceback.print_exc() self.exit() def make_update(self, dt): self.current_dt = dt self.frame.update(dt) for instance in self.frame.instances: instance.update(dt) self.update() self.key_presses = [] def exit(self): if self.parent_object is not None: self.parent_object.on_exit(self) return self.audio.delete() self.application.quit() def set_frame(self, index, force = False): if not force: self.next_frame = index return if self.frame: self.frame.destroy() self.frame = FRAMES[index](self) self.current_time = get_time() def drawBackground(self, painter, rect): frame = self.frame painter.beginNativePainting() painter.setRenderHint(QPainter.Antialiasing) r, g, b = frame.background GL.glClearColor(r / 255.0, g / 255.0, b / 255.0, 1.0) GL.glClear(GL.GL_COLOR_BUFFER_BIT) width, height = int(self.width()), int(self.height()) GL.glViewport(0, 0, width, height) GL.glMatrixMode(GL.GL_PROJECTION) GL.glLoadIdentity() GL.glOrtho(0, width, height, 0, -1, 1) GL.glMatrixMode(GL.GL_MODELVIEW) GL.glLoadIdentity() frame.draw(painter) painter.endNativePainting() def get_mouse_position(self): p = self.view.mapToScene(self.view.mapFromGlobal(QCursor.pos())) return p.x(), p.y() def keyPressEvent(self, event): key = event.key() QGraphicsScene.keyPressEvent(self, event) self.key_presses.append(key) self.key_downs.append(key) def keyReleaseEvent(self, event): QGraphicsScene.keyReleaseEvent(self, event) self.key_downs.remove(event.key()) def mousePressEvent(self, event): QGraphicsScene.mousePressEvent(self, event) pos = event.scenePos() button = event.button() self.frame.on_mouse_press(pos.x(), pos.y(), button) self.mouse_downs.append(button) def mouseDoubleClickEvent(self, event): QGraphicsScene.mouseDoubleClickEvent(self, event) self.mouse_downs.append(event.button()) def mouseReleaseEvent(self, event): QGraphicsScene.mouseReleaseEvent(self, event) button = event.button() self.mouse_downs.remove(button)
class Bombercan(Game): """The main class of this game.""" def __init__(self): """Create the main menu.""" super(Bombercan, self).__init__('BomberCan', 500, 500, 80) # Play BGM self.audio = AudioManager() self.audio.play('bombercan.wav', loop=True) # Display the main menu self.menu = MenuScene( parent=self, style={}, audio=self.audio, key_up=self.key_up, key_down=self.key_down, on_game_start=self.game_start ) # Prepare the end scene self.end = EndScene( parent=self, style={}, key_up=self.key_up, key_down=self.key_down, on_game_reset=self.game_reset ) self.game_reset() def game_reset(self): """Show the main menu.""" self.top_node=self.menu self.top_node.do_resize_recursive() def game_end(self): """Show the end roll.""" self.top_node=self.end self.top_node.do_resize_recursive() def game_start(self, mode, stage_num=0): """Setup the stage to start the game. @param mode: 0 for story mode, 1 for free game @param stage_num: specify the number of stage in story mode """ if mode == 0: def _goto_next_stage(): # After the player won this stage, start the next stage, # or show the end roll if all stage are cleared. if stage_num + 1 >= len(stagesetting.stage): self.game_end() else: self.game_start(0, stage_num + 1) settings = stagesetting.stage[stage_num] self.stage = StageScene( parent=self, style={}, audio=self.audio, map_size=settings['size'], margin=(20, 20, 20, 20), key_up=self.key_up, key_down=self.key_down, on_game_reset=self.game_reset, on_game_win=_goto_next_stage ) # Parse the setting self.stage.parse(settings['str'], settings['blocks']) elif mode == 1: self.stage = StageScene( parent=self, style={}, audio=self.audio, map_size=(15, 15), margin=(20, 20, 20, 20), key_up=self.key_up, key_down=self.key_down, on_game_reset=self.game_reset, on_game_win=self.game_reset ) # Randomly generate a stage self.stage.generate(20, 60) # Show the stage self.top_node=self.stage self.top_node.do_resize_recursive() @printfps() def on_tick(self, interval): """Do nothing but print the fps.""" pass