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)
