def test_player(): from bd.bd_connect import Bd bd = Bd() from player.player import Player p = Player(bd, 9999) p.set_name('TEST') p.set_class_hero('class_test1') p.set_batle_id(9999) p.set_location('test_location') p.update_player() bd.commit() print(p.user_id) print(p.name) print(p.class_hero) print(p.batle_id) print(p.location) p = None p = Player(bd, 9999) print(p.user_id) print(p.name) print(p.class_hero) print(p.batle_id) print(p.location) p.del_player() bd.commit()
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 __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 __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): 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 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): 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 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 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 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 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 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 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 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 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 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 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 __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 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 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 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)
def handle_client_verification(private_socket, client_address): option = receive_message(private_socket)[0] if option == '1': while True: user_name = receive_message(private_socket)[0] password = receive_message(private_socket)[0] if Player.is_user_name_exist(user_name) or user_name == "": send_message( "Choose another user name. Already exists or blank.", client_address, private_socket) else: Player.add_user(user_name, password) send_message("Success", client_address, private_socket) print(user_name + " registered and login successfully") break elif option == '2': while True: user_name = receive_message(private_socket)[0] password = receive_message(private_socket)[0] if Player.is_login_correct(user_name, password): send_message("Success", client_address, private_socket) print(user_name + " login successfully") break else: send_message("Incorrect", client_address, private_socket) option = receive_message(private_socket)[0] if option == '1': pokecat_instance.add_player(client_address, user_name) elif option == '2': player = Player(user_name) if len(player.player_info["pokemons_info"]) >= 3: send_message("In player queue", client_address, private_socket) player_queue.put(Player(user_name)) player_address_queue.put(client_address) else: send_message("Not enough pokemon", client_address, private_socket) elif option == '3': edit_room.add_player(client_address, user_name) private_socket.close()
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 add_one_player(self): request_json = json.loads(request.data) name_player_to_add = request_json["add_one_player"] player = Player().get_one(name_player_to_add) if player: if player.get_price() > self.money: return jsonify({"error": "you don't have enough money"}), 400 else: if player.to_json() in self.players: return jsonify({"error": "You already have this player"}), 400 self.players.append(player.to_json()) self.money = self.money - player.get_price() return self.do_save() else: return jsonify({"error": "Add One Player Failed"}), 400
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 _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 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 __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 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)