def game():
player_move = 0
print(
"Welcome to the TicTacToe game \'Kirby The Great\' created. This is a two(2) player game. Please enjoy!\n"
)
make_board()
player1, player2 = create_player()
print(
f'{player1.name} will play {player1.symbol} and {player2.name} will play {player2.symbol}'
)
while True:
while True:
p1_pos = input(
f"{player1.name}, please select your move in positions: ")
if p1_pos.isdigit() == False or int(p1_pos) > 9:
print("Please enter a number between 1 - 9.")
continue
elif loc[p1_pos] != " ":
print(
'This place is taken. Please select a different position.')
continue
else:
player_move += 1
loc[p1_pos] = player1.symbol
make_board()
break
check_1 = have_winner(player_move, player1, player2)
if check_1:
replay()
while True:
p2_pos = input(
f"{player2.name}, please select your move in positions.")
if p2_pos.isdigit() == False or int(p2_pos) > 9:
print("Please enter a number between 1 - 9.")
continue
elif loc[p2_pos] != " ":
print(
'This place is taken. Please select a different position.')
continue
else:
player_move += 1
loc[p2_pos] = player2.symbol
make_board()
break
check_2 = have_winner(player_move, player1, player2)
if check_2:
replay()
if player_move > 7 and (not check_1 and not check_2):
print('It\'s a tie! No winner.')
replay()
def _add_player(self):
room = random.choice(
self._layout.rooms) # TODO: refactor this to stairs up/down
self.player = create_player(room.x + room.grid.size_x / 2,
room.y + room.grid.size_y / 2)
self.player.add(MessageLogger(self.game.message_log))
self.player.listen('fov_updated', self._on_player_fov_update)
self.add_entity(self.player)
def initialize(self, player_race, player_class):
self.player = create_player(self, player_race, player_class)
sword = ItemRegistry.create(self, "WoodenSword")
self.player.inventory.add(sword)
self.map = RandomDungeon(self, "1", (200, 200))
self.map.generate()
self.player.pos = self.map.get_free_space()
self.current_view.on_activate()
def main_menu():
# - Menu principal du jeu -
print("\t\n\t\t=== Main menu ===\n\t")
print(
"\t| (1) : Créer nouveau joueur\n\t| (2) : Afficher liste des joueurs\n\t| (3) : Lancer une partie\n\t| (4) : Quitter"
)
choice = input("\nVotre choix --> ")
if choice == "1":
player.create_player()
main_menu()
elif choice == "2":
player.print_player_list()
main_menu()
elif choice == "3":
player.check_player()
elif choice == "4":
sys.exit("\n\n\t\t=== See you soon ===\n\n")
def start_game(self):
if self.black_player_name.get() == '' or self.white_player_name.get(
) == '':
messagebox.showerror(
title='Missing Player Info',
message='Please specify the name of both players')
return
self.players = dict()
self.current_player = 0
black_player_type = PlayerType(self.black_player_type.get())
white_player_type = PlayerType(self.white_player_type.get())
black_player_name = self.black_player_name.get()
white_player_name = self.white_player_name.get()
if black_player_type != PlayerType.human and white_player_type != PlayerType.human:
messagebox.showerror(
title='Player Type Error',
message='At least one of the players should be a human player')
return
self.game_started = True
self.start_timer()
self.stop_timer = False
self.players[BLACK] = create_player(black_player_type,
black_player_name)
self.players[WHITE] = create_player(white_player_type,
white_player_name)
self.current_player = BLACK
# Enable and disable widgets accordingly
self.start_game_button.config(state=DISABLED)
self.black_player_name_entry.config(state=DISABLED)
self.black_player_type_combo.config(state=DISABLED)
self.white_player_name_entry.config(state=DISABLED)
self.white_player_type_combo.config(state=DISABLED)
self.reset_button.config(state=NORMAL)
self.update()
def session(self):
""" Excecute a single game session, and return
the list of stakes
"""
stakes = list()
player = create_player(self.player_class, self.game.table,
self.init_stake, self.init_duration)
while player.playing():
stakes.append(player.stake)
self.game.cycle(player)
return stakes
def Choose_class(self):
name = input("What is your name? ")
choice = int(input("Choose a hero \n 1: Knight \n 2: Mage \n 3: Thief \n"))
global game_state_manager
game_state_manager = GameStateManager()
global game_state
game_state = game_state_manager.load(name)
global character
character = player.create_player(name, choice, game_state)
Map.map_choice()
Map.start_room()
Map.exit_map(Map)
walking(character)
def test_create_player (self):
#Cannot create duplicate Usernames:
assert not create_player("Username", "Password")
assert not create_player("Username2", "Password")
#Invalid input:
assert not create_player(None, None)
assert not create_player("TestUsername", None)
assert not create_player(None, "TestPassword")
#Mixed input:
assert not create_player(None, "Password")
#Valid innput:
assert create_player("TestUsername", "TestPassword")
def get_players_info(league_url, players=pl.create_player()):
html = get_html(league_url)
soup = BeautifulSoup(html, 'lxml')
table = soup.find('table', class_='tournament-table bordered')
if table != None:
for row in table.find_all('tr')[1:]:
player_info = []
for column in row.find_all('td')[1:]:
player_info.append(column.text.strip())
player = pl.create_player(*player_info)
if player['Name'] in players.keys():
players[player['Name']] = pl.merge_stats(
players[player['Name']],
player
)
else:
players[player['Name']] = player
return players
def main():
clubs = get_clubs(URL + '/?q=clubs_list')
players = {'Гость': pl.create_player()}
for club in clubs:
leagues = get_leagues(club)
for league in leagues:
try:
players = get_players_info(league, players)
except:
pass
print(club)
players = pl.to_df(players.values())
players.to_csv('Data/stats.csv')
def create_player():
# def __init__(self, hand_size=5, player_class='fighter', loot=0):
# self.player_class = player_class
# # player_deck = [val for key, val in PLAYER_STARTING_DECK.items()]
# # self.player_deck = player_deck
# self.player_deck = list(PLAYER_STARTING_DECK)
# self.hand_size = hand_size
# self.discard_pile = []
# self.current_hand = []
# self.loot = loot
mock_player = {
'draw_pile': [],
'discard_pile': [],
'hand_size': 3,
'current_hand': [],
'loot': 0,
'player_class': 'tank'
}
resp = player.create_player(mock_player)
test.test(resp.status_code, 200, 'Player should successfully create')
'type': 'dragon',
'spawn_chance': 100
}],
# list of actual enemies in the room
'enemies': [],
'exits': {
'inside': {
'require': [],
}
}
}
}
##### GAME STATE VARIABLES #####
CURRENT_ROOM = 'outside'
player = create_player('Frank', 'fighter')
##### GAME STATE VARIABLES #####
def command_go(to_room):
global CURRENT_ROOM
# is the destination room in the list of exists?
if to_room in world[CURRENT_ROOM]['exits']:
next_room = world[CURRENT_ROOM]['exits'][to_room]
# check to make sure that we have any required items to use this exit
for required_item in next_room['require']:
if required_item not in player['inventory']:
print_slowly("You do not have a " + required_item)
return
def choose_ai_class(self):
name = input("What is the name of the AI? ")
choice = int(input("Choose a hero \n 1: Knight \n 2: Mage \n 3: Thief \n"))
global ai
ai = player.create_player(name, choice, 0)
ai_map.map_choice(ai)
elapsed_time = end_time - start_time
final_message += ' (time: {:7.3}s)'.format(elapsed_time)
logger.info(final_message)
def print_final_results(self):
logger.info('\nFinal Results:')
logger.info('\t{:23} {}\n\t{:23} {}\n\t{:23} {}'.format(
'Number of black wins:', self.wins[BLACK], 'Number of white wins:',
self.wins[WHITE], 'Number of ties:', self.ties))
if __name__ == '__main__':
if args.black_player is None or args.white_player is None:
logger.info('You must specify both player types')
exit(1)
black_player_type = PlayerType(args.black_player)
white_player_type = PlayerType(args.white_player)
black = create_player(black_player_type, 'BLACK')
white = create_player(white_player_type, 'WHITE')
runner = OthelloRunner()
runner.play_series(black_player=black,
white_player=white,
min_level=args.min_level,
max_level=args.max_level,
time_out=args.time_out)
def init_players(self):
self.player1 = create_player('player1', 'X', self)
self.player2 = create_player('player2', 'O', self)
self.current_player, self.opponent = self.player1, self.player2
def _add_player(self):
room = random.choice(self._layout.rooms) # TODO: refactor this to stairs up/down
self.player = create_player(room.x + room.grid.size_x / 2, room.y + room.grid.size_y / 2)
self.player.add(MessageLogger(self.game.message_log))
self.player.listen('fov_updated', self._on_player_fov_update)
self.add_entity(self.player)
pygame.time.delay(100)
saida_oculta = []
rodada += 1
distance = 0
# capta acoes do botao
for event in pygame.event.get():
if event.type == pygame.QUIT:
display_open = False
# novo player
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_SPACE:
if len(players) < 1:
players = create_player()
# eventos do teclado
comandos = pygame.key.get_pressed()
if len(players) != 0: # se nao houver player, nao tera acao de botao
move_player(pygame, comandos, players[0])
# i.a jogando aqui
if len(players) != 0: # se nao houver player, nao tera acao de botao
for player in players:
distanceX = fruits[0][0] - player[0]
distanceY = fruits[0][1] - player[1]
player[0], player[1], saida_oculta = move_player_ia(
distanceX, distanceY, player, pesos, pesos_oculta)
# colisao do player + fruta
game_world = world.World2d()
game_world_debugger = world.World2dDebug(game_world)
fps_display = pyglet.window.FPSDisplay(window=graphics_director._window)
fps_display.label.color = (255, 255, 255, 255)
fps_display.label.y = game_height * game_scale - 20
fps_display.label.bold = False
fps_display.label.font_size = 10
fps_display.label.font_name = 'Verdana'
audio_director.attenuation_distance = 40
collision_sound = audio_director.load(
'audio/sfx/bass-drum-hit.wav', streaming=False)
(pickle, pickle_graphics_idle) = player.create_player(key_handler)
graphics_director.add_listeners(on_update=pickle.update)
game_world.add_collider(pickle)
def toggle_debug_state():
global debug_state
debug_state = not debug_state
debug_state = True
key_handler.on_key_press(pyglet.window.key.D, toggle_debug_state)
def create_floor_physics(**kwargs):
