def __init__(self, agent, end_score=10): self.agent = agent self.score1 = 0 self.score2 = 0 self.end_score = end_score pygame.init() self.screen = pygame.display.set_mode([SCREEN_WIDTH, SCREEN_HEIGHT]) pygame.display.set_caption('Pong') pygame.mouse.set_visible(1) self.font = pygame.font.Font(None, 36) self.background = pygame.Surface(self.screen.get_size()) self.ball = Ball(WHITE) self.balls = pygame.sprite.Group() self.balls.add(self.ball) self.player_bottom = Player(580, PLAYER_WIDTH, WHITE) self.player_top = Player(25, PLAYER_WIDTH, WHITE) self.movingsprites = pygame.sprite.Group() self.movingsprites.add(self.player_bottom) self.movingsprites.add(self.player_top) self.movingsprites.add(self.ball) self.clock = pygame.time.Clock()
def handle_client_connected_message(self, msg): player = Player(msg.clientid, msg.clientaddress, msg.clientport, login_server=self) player.set_state(UnauthenticatedState) self.players[msg.clientid] = player
def __init__(self): super(Game, self).__init__() # the game neighborhood self.neighborhood = Neighborhood() # the game player self.player = Player() # current player location row self.current_row = 0 # current player location column self.current_col = 0 # current home the player is in self.current_home = self.neighborhood.get_homes()[self.current_row][ self.current_col] # total monster population self.total_num_monsters = self.count_monsters() # total people population self.total_num_people = 0 # game over status self.game_over = 0
def __init__(self, player_one: Player = None, player_two: Player = None, verbose: bool = True) -> None: self._move_counter = 0 self._board = Board(MAX_ROWS, MAX_COLUMNS) self._players = ( player_one if player_one is not None else Player( SIGN_PLAYER_ONE, 'magenta'), player_two if player_two is not None else Player( SIGN_PLAYER_TWO, 'cyan') ) self._verbose = verbose
def execute(self): if not Utils.has_internet(): player = Player() player.play_local() else: if Alarm.serverHandler is not None: Alarm.serverHandler.emit(RequestHandler('music:discovering')) if not self.repeat: self.enable = False Alarm.serverHandler.emit(RequestHandler('alarm:update', {"alarm": {"_id": self._id, "update": {"enable": False}}}))
def handle(self, *args): arg = args[0] if args else '' if not arg: if self.player and self.player.is_paused: self.player.play() return self.INDENT + colorize( Colors.BLUE, '\u25B6 ' + self.client.active_station['name']) self.stdout_print(self.INDENT + colorize(Colors.GRAY, 'Pick random genre...')) arg = random.choice( [genre.get('title', '') for genre in self.client.genres]) genre = self.client.search_genre(arg) genre_id = genre.get('id') if genre else None if genre_id is None: return self.INDENT + colorize(Colors.RED, 'Genre ') + arg + colorize( Colors.RED, ' not found.') self.stdout_print(self.INDENT + colorize(Colors.GREEN, 'Tuning in...')) self.stdout_print(self.INDENT + colorize(Colors.GREEN, 'Starting genre: ') + genre.get('title', '')) num_of_tries = 0 while num_of_tries < 3: num_of_tries += 1 stream = self.client.get_stream(genre_id, renew_active_station=True) if not stream: return self.INDENT + colorize( Colors.RED, 'No active stations found... Please, try another genre.') if self.player: self.player.stop() self.player = Player(stream) self.player.play() num_of_checks = 0 while num_of_checks < 5: num_of_checks += 1 time.sleep(1) if self.player.is_playing: return self.INDENT + colorize( Colors.BLUE, '\u25B6 ' + self.client.active_station['name']) return self.INDENT + colorize( Colors.RED, 'No active stations found... Please, try another genre.')
def __init__(self): pg.init() pg.mouse.set_cursor(*CURSOR) self._camera = Camera() self._hotbar = Hotbar() self._world = World() self._main_player = Player("main_player", spawn_pos=PLAYER_DEFAULT_SPAWN_POS) self._action = GameAction.play
def on_new_level(self): # Physics stuff self.space = pymunk.Space() self.space.gravity = Vec2d(0.0, -1200.0) self.player = Player(x=100, y=600, group=self.background, space=self.space, game=self) self.window.push_handlers(self.player.key_handler) self.current_level().create(self.space, self.background)
def editPlayer(self, player_info): ''' Replaces given player with the player specified ''' if player_info.get('id', None): player_info['player_id'] = player_info['id'] player_info.pop('id') player_info = Player(**player_info) player_info: Player player_info = player_info.to_specified_db_format(Player.PLAYER_UPDATE_FORMAT) p_dao = PlayerDAO() player_result = PlayerDAO().edit(player_info) if player_result: return player_result else: return None
def _build_force(self, ship_type, amount, playr, attack_mode): playr = Player(name=playr, planetary=Planetary(playr)) flt = fleet.Fleet(owner=playr) ships = [] for i in range(amount): ships.append(ship.Ship(**ship.TYPES[ship_type])) playr.add_ships(ships, 0) flt.assign_ships(ships) flt.set_attack_mode(attack_mode) frc = force.Force(flt) frc._player = playr return frc
def add_player(self, address, username): self.address_player[address] = Player(username) send_message(self.address_player[address].get_pokemon_info(), address, self.sock) self.pokemon_count[address], message = self.address_player[ address].get_number_of_each_pokemon() send_message(message, address, self.sock)
def execute(self): player1 = Player(Alliance.RED, PlayerType.HUMAN, name="Dia") player2 = Player(Alliance.YELLOW, PlayerType.COMPUTER) SelectDifficultyCommand().execute() gm = GameManager(player1, player2) care_taker = Caretaker(gm) winner = None while not gm.game_over and not gm.draw: self.__print_format_table(gm) move = gm.state.next_player.get_move if isinstance(move, str): UndoCommand(gm, care_taker).execute() care_taker.backup() winner = self.__handle_move(move, gm, care_taker) self.__print_format_game_over(gm, winner)
def __init__(self, redis_client): self.redis = redis_client self.games = [] self.user = User() self.player = Player() GameManagerParsing(self.redis).start() GameManagerInitGame(self.redis, self.user).start()
def __init__(self): self.state = GameState.State.NEW_GAME self.Player = Player() self.Labyrinth = Labyrinth() self.TextData = TextData() self.Player.current_location = self.Labyrinth.find_start_room().id print(self.Player.current_location)
def setup(self): #O jogo se inicia pausado, afim de faciliar para o jogador na hora da passagem de fase, dando a opção de lançar a bola. self.jogo_pausado = True #Para que a bola permaneça pausada no inicio de cada fase, colocamos esse atributo especifico para essa tarefa. self.pausa_bola = 0 #Aqui se encontram as listas do jogo, onde ficarão os sprites. self.lista_bola = arcade.SpriteList() self.lista_blocos = arcade.SpriteList() self.lista_power_up = arcade.SpriteList() self.lista_jogador = arcade.SpriteList() self.lista_jogador2 = arcade.SpriteList() #O aleatorio_powerup é um atributo que determinara os power_ups aleatoriamentes, quando um bloco power_up for quebrado. self.aleatorio_powerup = 0 #Ambos os contadores de colisao_paredes servem para garantir que a bola não saia do campo de visão do jogador. self.contador_colisao_paredes_vertical = 0 self.contador_colisao_paredes_horizontal = 0 #O bloco delay serve para amenizar o contato da bola com os blocos, afim de que minimize os bugs de colisão. self.bloco_delay = -1 #Para pôr tempo nos power_ups escolhemos manualmente fazer os contadores, sendo o contador_tempo o tempo total do power_up #e o contador variador o qual ira zerar o tempo do powerup. Temos dois de cada, pois há a opção de dois players. self.contador_tempo_power_up_1 = 600 self.contador_variador_1 = 0 self.contador_tempo_power_up_2 = 600 self.contador_variador_2 = 0 #A função run serve para realizar ações dependendo do estado do jogo. self.run(self.estado_jogo) #Se o modo de jogo for 1, ira ser posto apenas 1 player, se for dois, dois players. if self.modo_de_jogo == 1: self.lista_jogador.append( Player('jogo/player/imagens/barra_normal.png', 1, 8, arcade.key.LEFT, arcade.key.RIGHT, LARGURA_TELA / 2, 64)) if self.modo_de_jogo == 2: self.lista_jogador.append( Player('jogo/player/imagens/barra_normal.png', 1, 8, arcade.key.LEFT, arcade.key.RIGHT, 64, 64)) self.lista_jogador2.append( Player('jogo/player/imagens/barra_normal.png', 1, 8, arcade.key.A, arcade.key.D, LARGURA_TELA - 64, 64)) #Se o jogo não estiver no menu,game_over,tela de ajuda, ou tela final haverá a bola no jogo. if self.estado_jogo != MENU and self.estado_jogo != GAME_OVER and self.estado_jogo != AJUDA and self.estado_jogo != TELA_FINAL: for player in self.lista_jogador: self.lista_bola.append( Bola(player.center_x + player.width / 4, 96)) break #Cada nova fase ira iniciar com 3 vidas. self.set_vida(3)
def setup(self): game_object.add(Background()) generate_map("assets/maps/map.json") player = Player(35 * 16, 27 * 16, global_input_manager) game_object.add(player) create_enemy.create_enemy() create_gift.create_gift() create_coin.create_coin()
def build_player(self, settings_dict, game_env): player = Player(game_env, settings_dict['AGENT_HISTORY_LENGTH'], settings_dict['MEMORY_SIZE'], settings_dict['BS'], settings_dict['LEARNING_RATE'], settings_dict['INI_EPSILON'], settings_dict['END_EPSILON'], settings_dict['MIN_OBSERVE_EPISODE'], settings_dict['NETW_UPDATE_FREQ'], settings_dict['UPDATE_FREQ'], settings_dict['DISCOUNT_FACTOR'], settings_dict['REPLAY_MEMORY_START_SIZE'], settings_dict['PUNISH'], settings_dict['REWARD_EXTRAPOLATION_EXPONENT'], settings_dict['LINEAR_EXPLORATION_EXPONENT'], settings_dict['USE_DOUBLE_MODEL']) return player
def __init__(self, height, width, difficulty): self.height = height self.width = width self.window = curses.newwin(self.height, self.width, 0, 0) self.sky_height = round(self.height // 2.7) self.water_height = round(self.height // 2.1) self.beach_height = self.height // 6 self.sky = Sky(self.window.subwin(self.sky_height, self.width, 0, 0)) self.water = Water(self.window.subwin(self.water_height, self.width, self.sky_height, 0)) self.beach = Beach(self.window.subwin(self.beach_height, self.width, self.sky_height+self.water_height, 0)) self.difficulty = ['easy', 'medium', 'hard'][difficulty] self.obstacles = Obstacles(self.water, self.difficulty) self.player = Player(self.water) # self.score = 0 self.connect()
def fim_powerup(self): for player in self.lista_jogador: if self.contador_tempo_power_up_1 < 0: self.lista_jogador.append( Player('jogo/player/imagens/barra_normal.png', 1, 8, arcade.key.LEFT, arcade.key.RIGHT, player.center_x, 64)) player.kill() self.contador_variador_1 = 0 self.contador_tempo_power_up_1 = 600 for player in self.lista_jogador2: if self.contador_tempo_power_up_2 < 0: self.lista_jogador2.append( Player('jogo/player/imagens/barra_normal.png', 1, 8, arcade.key.A, arcade.key.D, player.center_x, 64)) player.kill() self.contador_variador_2 = 0 self.contador_tempo_power_up_2 = 600
def registerPlayer(self, playerDescription): if self.getPlayer(playerDescription.name) is None: if len(self.playerRegister) < 8: position = len(self.playerRegister) self.playerRegister.append( Player(playerDescription.name, position)) else: raise ValueError('Players are already registerd') else: raise ValueError('Player already registered')
def get_players(self): car_img = pg.image.load('graphics/car.png') player_list = [] for i in range(self.NUM_PLAYERS): x_min = i * DISPLAY_WIDTH / self.NUM_PLAYERS x_max = (i + 1) * DISPLAY_WIDTH / self.NUM_PLAYERS - 1 # -1 cause its inclusive and we want it exclusive car = Car(x_min, x_max, 8, car_img) player = Player(i, LIVES, car, KEYS[i]['left'], KEYS[i]['right']) player_list.append(player) return player_list
def test_messages_0(self): player = Player("PlayerA") player.sends("A") # First test count. self.assertEqual(1, player.messages_count(), "1 message") # Now test message contents. self.assertEqual(["A"], player.messages) player.sends("B") # First test count. self.assertEqual(2, player.messages_count(), "2 messages") # Now test message contents. self.assertEqual(["A", "B"], player.messages) player.sends("C") # First test count. self.assertEqual(3, player.messages_count(), "3 messages") # Now test message contents. self.assertEqual(["A", "B", "C"], player.messages)
def __init__(self): super().__init__() w = int(self.screen.get_width() / 1.7) h = convert.scale_h([5504, 3808], w) x = int(self.screen.get_width() / 2 - w / 2) y = int(self.screen.get_height() / 2 - h / 2) self.platform_rect = [x, y, w, h] self.player = Player( self.screen, [self.platform_rect[0], self.platform_rect[1], 25, 25], self.platform_rect, 150, name='player', save_entity=False) self.inventory = Inventory() self.inventory_display = InventoryDisplay(self.screen, [self.player]) self.inventory_open = False
def do_startup(self): Gtk.Application.do_startup(self) self.settings = Settings(self) self.discoverer = Discoverer() self.player = Player(self) self.equalizer = Equalizer(self) self.queue = Queue(self) self.history = History(self) self.integration = Integration(self) self.win = MainWindow(self)
def add_player(self, address, user_name): self.ip_players[address] = Player(user_name) while True: x = randint(0, self.world_size) y = randint(0, self.world_size) if self.world_map[x][y] == 0 and self.is_player_not_in_location( (x, y)): self.player_locations[address] = (x, y) break send_message(address=address, sock=self.sock, message=self.player_status(address))
def test_deaths_0(self): player = Player("PlayerA") player.dies("A") self.assertEqual(1, player.died_count(), "1 death") self.assertEqual(["A"], player.deaths) player.dies("B") self.assertEqual(2, player.died_count(), "2 deaths") self.assertEqual(["A", "B"], player.deaths)
def setup(self): player = Player(50, 400) game_object.add(player) game_event = GameEvent() game_object.add(game_event) # background = Background(640, 320) # game_object.game_objects.insert(0, background) for i in range(22): platform2 = Platform(32 + i * 64, 650) game_object.add(platform2)
class TestPlayer(unittest.TestCase): def setUp(self): self.gmap = GameMap(db = DataMap(), input_map = {(-1, -1):1, (-1, 0):1, (-1, 1): 1, (0, -1): 2, (0, 0): 0, (0, 1): 0, (1, -1): 1, (1, 0): 0, (1, 1): 1}) self.player = Player(local_map = self.gmap) def tearDown(self): pass def testSetLocationIfOpen(self): loc = (1, 0) self.player.set_location(loc) self.assertEqual(self.player.location, loc) def testMoveSuccess(self): p = self.player dir = "e" p.move(dir) self.assertEqual(self.player.location, (1, 0)) def testMoveFail(self): p = self.player dir = "w" p.move(dir) self.assertEqual(self.player.location, (0, 0)) def testDigSuccess(self): p = self.player dir = "d" p.dig(dir) self.assertEqual(self.player.location, (0, -1)) self.assertEqual(self.gmap.get((0, -1)), 0) self.assertEqual(p.inventory, [2])
def run_match_competition(date, competition): player_list = [] match_details = [] for match in os.listdir(os.environ["TENNIS_HOME"] + "matches//year " + date[:4] + "//" + competition): if match[-10:] == date: with open(os.environ["TENNIS_HOME"] + "matches//year " + date[:4] + "//" + competition + "//" + match) as \ file: match_details.append(yaml.safe_load(file)) for player in match_details[len(match_details) - 1]["player_ids"]: player_list.append(Player(file=os.environ["TENNIS_HOME"] + "//players//players/Player_" + player + ".yaml")) pass pass
def save_my_team(self): request_json = json.loads(request.data) _selected_players = request_json["_selected_players"] for key, value in _selected_players.items(): if value in [player['name'] for player in self.players]: if self.my_team[key] and value != self.my_team[key].name: self.my_team[key] = Player().get_one(value) if self.players_selected_by_position[key] != value: self.players_selected_by_position[key] = value elif value == "": continue else: return jsonify({ "error": "The players selected are not in list of my players." }), 401 return self.do_save()
def play_game(self): players = [Player(i) for i in range(1, self.player_amount + 1)] game_on = True round = 1 while game_on: print(f"Round: {round}\n") for player in players: self.round(player) self.check_winner(player) if player.winner: print(f"\n{player} wins the game!\n") game_on = False break print("-" * 20) round += 1 print("LeaderBoard\n") self.print_score(players) self.reset_game(players)
def setup(self): generate_map("image/map/map.json") enemy = Enemy(368, 608) game_objects.add(enemy) enemy1 = Enemy(640, 300) game_objects.add(enemy1) black_slave = BlackSlave(768, 240) game_objects.add(black_slave) main_door = MainDoor(16, 320) game_objects.add(main_door) black_screen = BlackScreen(0, 0) game_objects.add(black_screen) player = Player(64, 320) game_objects.add(player)
def on_init(self): pg.display.set_caption("PyMario") self.display_surf = pg.display.set_mode( self.WIN_SIZE, pg.HWSURFACE | pg.DOUBLEBUF ) self._running = True # timer fps self.timer = pg.time.Clock() # camera # self.camera = Camera(level_width=len(Level.MAP[0]) * 30, # level_height=len(Level.MAP) * 30) self.camera = Camera(level_width=100 * 30, level_height=20 * 30) # create level self.level = Level(surface=self.display_surf, camera=self.camera) # create player self.player = Player(60, 60, surface=self.display_surf, camera=self.camera)
class GameCore: def __init__(self, _main): self.main = _main ## Set parent nodes in the scenegraph self.physicsParentNode = render.attachNewNode("physicsParentNode") self.levelParentNode = render.attachNewNode("levelParentNode") self.objectsParentNode = render.attachNewNode("objectsParentNode") self.lightsParentNode = render.attachNewNode("lightsParentNode") self.aiParentNode = render.attachNewNode("aiParentNode") ## Start Event Manager self.eventMgr = EventMgr(self) def startGame(self, _playerName="DefaultPlayer"): self.autoShader() self.eventMgr.start() print "---> Started EventSystem" self.loadPhysicsSystem() print "---> Loaded Physics System" self.loadInputSystem() print "---> Loaded Input System" self.loadLevelSystem() print "---> Loaded Level System" self.loadPlayerSystem() print "---> Loaded Player System" self.loadCameraSystem() print "---> Loaded Camera System" def stopGame(self): pass ##------- SUB SYSTEMS -------## def loadPhysicsSystem(self): self.physicsMgr = PhysicsMgr(self) self.physicsMgr.startPhysics() self.physicsMgr.setPhysicsDebug() def loadInputSystem(self): self.input = Input(self) #self.input.start() def loadLevelSystem(self): self.level = Level(self) self.level.buildLevel("assets/level/intro") self.level.start() def loadPlayerSystem(self): self.player = Player(self, "Main Man") self.player.start() def loadCameraSystem(self): self.camera = Camera(self) self.camera.start() def autoShader(self): render.setShaderAuto()
def loadPlayerSystem(self): self.player = Player(self, "Main Man") self.player.start()
def main(): f = Player(base_dir) f.main()
from player.player import Player from flaskr.models import sess from functions.songs import get_all_songs for song in get_all_songs(): song.playing = 0 sess.commit() player = Player() player.start()
from pygame import sprite from settings import BLACK_COLOR, DISPLAY_SIZE, WHITE_COLOR from ship.ship import Ship from zergling.zergling import Zergling from brutalisk.brutalisk import Brutalisk from hydralisk.hydralisk import Hydralisk from player.player import Player from collision.collision import Collision clock = pygame.time.Clock() screen = pygame.display.set_mode(DISPLAY_SIZE) pygame.mouse.set_visible(0) # Create Player player = Player() collision = Collision() # Create Ship ship = sprite.Group() ship.add(Ship(screen)) # Init Bullet bullet = sprite.Group() # Create Enemies zerglings = sprite.Group() # Font Creations pygame.init() font = pygame.font.Font(None, 36)
def init_player(self, data, address, pl_id): #check if name already exists name = data.player.chat i = 1 namegen = chain(self.players.itervalues(), self.specs.itervalues()) while name in [p.name for p in namegen]: name = data.player.chat + '_' + str(i) i += 1 player = Player(True, self.projectiles.add_projectile, pl_id) player.timer = 0 player.address = address player.name = name player.colstring = data.input.name print ' '.join((str(datetime.now()), player.name, str(pl_id), 'joined the server', str(address))) player.time = 0 self.specs[pl_id] = player tosendplayer = proto.Player() tosendplayer.id = pl_id tosendplayer.chat = player.name #send info do newly connected player own = proto.Message() player = proto.Player() own.type = proto.connectResponse player.id = pl_id player.chat = self.specs[pl_id].name inpt = proto.Input() inpt.time = 0 inpt.name = self.map.name own.input.CopyFrom(inpt) own.player.CopyFrom(player) self.ackman.send_rel(own, address) #send other players to player for idx, p in self.players.iteritems(): if idx != pl_id: #other players other = proto.Message() player = self.players_pack[idx] player.chat = p.name other.type = proto.newPlayer other.player.CopyFrom(player) other.gameState = proto.wantsJoin inpt = proto.Input() inpt.name = p.colstring other.input.CopyFrom(inpt) self.ackman.send_rel(other, address) #other.type = proto.playerUpdate new = proto.Message() new.type = proto.newPlayer #player = self.players_pack[pl_id] new.gameState = proto.goesSpec new.player.CopyFrom(tosendplayer) inpt = proto.Input() inpt.name = self.specs[pl_id].colstring new.input.CopyFrom(inpt) self.ackman.send_rel(new, p.address) for idx, p in self.specs.iteritems(): if idx != pl_id: other = proto.Message() player = proto.Player() player.id = idx player.chat = p.name other.type = proto.newPlayer other.player.CopyFrom(player) other.gameState = proto.goesSpec inpt = proto.Input() inpt.name = p.colstring other.input.CopyFrom(inpt) self.ackman.send_rel(other, address) new = proto.Message() new.type = proto.newPlayer #player = self.players_pack[pl_id] new.gameState = proto.goesSpec new.player.CopyFrom(tosendplayer) inpt = proto.Input() inpt.name = self.specs[pl_id].colstring new.input.CopyFrom(inpt) self.ackman.send_rel(new, p.address) #TODO: send map status self.map.items.send_mapstate(self.gamestate.send_mapupdate, address)
def setUp(self): self.gmap = GameMap(db = DataMap(), input_map = {(-1, -1):1, (-1, 0):1, (-1, 1): 1, (0, -1): 2, (0, 0): 0, (0, 1): 0, (1, -1): 1, (1, 0): 0, (1, 1): 1}) self.player = Player(local_map = self.gmap)
class App(object): WIN_SIZE = conf.WIN_SIZE def __init__(self): pg.init() # joy stick pg.joystick.init() try: self.joystick = pg.joystick.Joystick(0) self.joystick.init() print 'Enabled joystick: ' + self.joystick.get_name() except pg.error: print 'no joystick found.' self.joystick = None self._running = True self.display_surf = None self.level = None self.player = None self.timer = None def on_init(self): pg.display.set_caption("PyMario") self.display_surf = pg.display.set_mode( self.WIN_SIZE, pg.HWSURFACE | pg.DOUBLEBUF ) self._running = True # timer fps self.timer = pg.time.Clock() # camera # self.camera = Camera(level_width=len(Level.MAP[0]) * 30, # level_height=len(Level.MAP) * 30) self.camera = Camera(level_width=100 * 30, level_height=20 * 30) # create level self.level = Level(surface=self.display_surf, camera=self.camera) # create player self.player = Player(60, 60, surface=self.display_surf, camera=self.camera) def on_execute(self): if self.on_init() == False: self._running = False while self._running: self.timer.tick(conf.FPS) for event in pg.event.get(): self.on_event(event) self.on_loop() self.on_render() self._on_cleanup() def on_event(self, event): self._listen_event(event) self.player.listen_event(event, joystick=self.joystick) def on_loop(self): # center camera on player self.camera.update(self.player) # update mario self.player.update(self.level.get_elements()) def on_render(self): # render level self.level.render() self.player.render() pg.display.update() def _on_cleanup(self): pg.quit() def _listen_event(self, event): if event.type == pg.QUIT: self._running = False
def __init__(self,id, cards): Player.__init__(self,id,cards)
# -*- coding: utf-8 -*- """ Created on Wed Jun 29 22:11:53 2016 @author: alexis """ from interfacage.lylipond_parser import LyParser from instruments.timbre import Timbre from music.scale import Scale from player.player import Player player = Player() interface = player.playRealTime() player.enableLearning() instrument = Timbre('orgue') # Defining an instrument player.instrument = instrument # giving an instrument to the player tempo = 200 # Defining a scale majorScale = Scale('major',LyParser().getNote('c,').height) #player.playScale(majorScale, tempo) # Asking the player to play the scale to a specific tempo # Defining a sheet #sheet="{ a,4 ais, b, c, cis, d, dis, e, f, fis, g, gis, a4 ais b c cis d dis e f fis g gis a'4 ais' b' c' cis' d' dis' e' f' fis' g' gis' }" #sheet="{ ais8 ais a g,16 f, f, d,8. c,4 f,2 }" sheet="{ r2 c,8 c, a4 g, f, g,2 e,4 f, r f, g,2 c,4 a b c g,2 e,8 e, f,4 e, d, c,2. r2. }" #sheet="{ c4 c c d e2 d c4 e d d c2 c4 c c d e2 d c4 e d d c2 d4 d d d a2 a d4 c b a g,2 c4 c c d e2 d c4 e d d c2 }" #parsedSheet = player.playLySheet(sheet, tempo, majorScale) # Asking the player to play the sheet to a specific tempo
def __init__(self, id, cards, nrCards): Player.__init__(self, id, cards) self.beliefs = np.ones(nrCards)/nrCards self.currentCards = np.zeros(nrCards) self.initNFQ()