def main():
# 1st human player is created.
score_keeper = Score()
h1 = HumanPlayer(score_keeper, 'x', "Reuven")
# h2 = HumanPlayer(score_keeper, 'o', "Shimon")
# a1 = AIPlayer(score_keeper, 'x')
# a2 = AIPlayer(score_keeper, 'o', "Bot2")
while True:
"""
You need to create 2nd 'o' player, either Human or AI, and select its name.
For details see GameManager docs
"""
opponent = GameManager.get_opponent_player(score_keeper)
board_size = GameManager.input_board_size()
game_manager = GameManager(h1, opponent, board_size)
board = game_manager.board
while not game_manager.game_over():
game_manager.print_board()
try:
current_player = game_manager.current_player()
next_move = current_player.next_move(board)
print(next_move)
if game_manager.is_valid_move(next_move):
game_manager.play(next_move)
except exceptions.ParseMoveError as err:
print(err)
continue
except exceptions.OutOfBoardError as err:
print(f"Illegal move, {err.row, err.col} is out of board!")
continue
finally:
print('Try again')
continue
game_manager.print_board()
winner = game_manager.get_winner()
if winner is not None:
print(f"{winner.value}! {winner.name} won")
winner.sign_victory()
else:
print("No winner, game over...")
score_keeper.print()
next_game = input("Want to play again? Y/N ?")
if next_game == 'Y':
continue
else:
print("Bye!")
break
def _build(self, mod, Log):
''' Builds application using variables provided by user '''
if Log == None:
Log = Log()
if (self._seed < 1):
random.seed(time.time())
self._seed = random.random()
self.Log = Log
self.Scorer = Score(mod, self.Log)
self.Encoder = Encoder(seed=self._seed, probability=self._probability)
self.GPT = GPT2LanguageModel(model_name=self.model)
def setUp(self):
self.pw_map = Mapa("test")
self.score = Score()
self.hcriat = CreaturesHandler()
self.hcriat.jugadores = {}
self.hcriat.pw_map = self.pw_map
self.hcriat.score = self.score
def _build(self, Log, Scorer):
if Log == None:
Log = Logger()
if Scorer == None:
Scorer = Score()
self.Log = Log
self.Scorer = Scorer
self.Encoder = Encoder()
self.GPT = GPT2LanguageModel(model_name=self.model)
def __render_score(self):
for sprite in self.score_group.sprites():
self.score_group.remove(sprite)
i = 0
score_points = f"{self.score}"
spacing = SCREEN_SIZE[1] / 24
size = len(score_points)
margin_left = int((SCREEN_SIZE[0] / 2) -
(size * spacing + size * 2) / 2)
for num in score_points:
score = Score(num=num,
pos=(margin_left + (i * (spacing + 2)),
SCREEN_SIZE[1] / 10))
self.score_group.add(score)
i += 1
def update(self, game_time):
time_delta = (game_time - self.game_time)
self.coin_box_time += time_delta
self.transition_time = self.coin_box_time
self.game_time = game_time
if self.num_coins == 0:
self.display_frame = self.empty_frame
else:
if 0 < self.coin_box_time <= 400:
self.frame_idx = 0
elif 400 < self.coin_box_time <= 600:
self.frame_idx = 1
elif 600 < self.coin_box_time <= 700:
self.frame_idx = 2
elif self.coin_box_time > 700:
self.frame_idx = 0
self.coin_box_time = 0
self.display_frame = self.coin_box_frames[self.frame_idx]
if self.in_transition is True:
if self.transition_time > 10:
self.y_offset -= 1
self.transition_time = 0
if self.y_offset == 0:
self.in_transition = False
else:
self.transition_time = 0
for item in self.coin_score_group:
item.update(game_time)
if isinstance(item, Coin):
if not item.is_bouncing:
item.kill()
score = Score(self.rect.x + 5, self.rect.y - 25, c.SCORE_COIN)
self.coin_score_group.add(score)
def setUp(self):
self.score_keeper = Score()
self.h1 = HumanPlayer(self.score_keeper, 'x', "Reuven")
self.h2 = HumanPlayer(self.score_keeper, 'o', "Shimon")
self.a1 = AIPlayer(self.score_keeper, 'x')
self.a2 = AIPlayer(self.score_keeper, 'o', "Bot2")
def kill_enemy(self, score_group):
self.state = c.ENEMY_STATE_DEAD
score = Score(self.rect.x + 5, self.rect.y - 25, self.kill_score)
score_group.add(score)
return self.kill_score
def main():
pg.init()
pg.font.init()
screen = pg.display.set_mode((WINDOW_WIDTH, WINDOW_HEIGHT))
pg.display.set_caption('My_game')
clock = pg.time.Clock()
# sprites
img = load_image('player.png')
Player.images = [img]
img = load_image('player_shot.png')
Player_shot.images = [img]
img = load_image('enemy_new.png')
Enemy.images = [img]
# sounds
crow_sound = load_sound('crow.wav')
shot_sound = load_sound('shot.wav')
shot_sound.set_volume(0.1)
background = pg.Surface(SCREEN_RECT.size)
background.fill(BACKGROUND_COLOR)
screen.blit(background, (0, 0))
pg.display.flip()
# Создание контейнеров
all = pg.sprite.RenderUpdates()
shots = pg.sprite.Group()
enemies = pg.sprite.Group()
# Присвоение контейнеров
Player.containers = all
Player_shot.containers = all, shots
Enemy.containers = all, enemies
player = Player()
# Таймеры появлений объектов
gun_timer = 0
enemy_spawn_timer = 0
crow_sound_timer = 0
score_delta = 0
score = Score()
game_over = False
def check_quit_keys():
for event in pg.event.get():
if event.type == QUIT or \
(event.type == KEYDOWN and event.key == K_ESCAPE):
return True
if pg.font:
all.add(score)
# initialiaing fonts
pg.font.init()
my_font = pg.font.SysFont('Comic Sans MS', 40)
my_font_bot = pg.font.SysFont('Comic Sans MS', 20)
text_over = my_font.render('Game over', False, (0, 0, 0))
text_score = my_font.render('Score: ' + str(score.score), False, (0, 0, 0))
instruction = my_font_bot.render('Press S to start a new game ', False,
(0, 0, 0))
while player.alive():
if check_quit_keys():
break
key_state = pg.key.get_pressed()
horiz_direction = key_state[K_RIGHT] - key_state[K_LEFT]
vert_direction = key_state[K_DOWN] - key_state[K_UP]
player.move(horiz_direction, vert_direction)
score_delta = 0
for shot in shots:
enemies_hit_list = pg.sprite.spritecollide(shot, enemies, True)
if len(enemies_hit_list) > 0:
if crow_sound_timer <= 0:
crow_sound.play()
crow_sound_timer = Enemy.CROW_SOUND_COOLDOWN
shot.kill()
score_delta += len(enemies_hit_list)
crow_sound_timer -= 1
if score_delta > 0:
score.set_score_delta(score_delta)
d = pg.sprite.spritecollide(player, enemies, True)
if len(d) > 0:
player.kill()
text_score = my_font.render('Score: ' + str(score.score), False,
(0, 0, 0))
game_over = True
if key_state[K_x]:
if gun_timer != 0:
gun_timer = gun_timer - 1
else:
Player_shot(player.get_guns()[0])
Player_shot(player.get_guns()[1])
shot_sound.play()
gun_timer = Player_shot.GUN_RELOAD
if enemy_spawn_timer != 0:
enemy_spawn_timer = enemy_spawn_timer - 1
else:
Enemy()
enemy_spawn_timer = Enemy.SPAWN_COOLDOWN
all.clear(screen, background)
all.update()
pg.display.update(all.draw(screen))
clock.tick(60)
while game_over:
if check_quit_keys():
break
key_state = pg.key.get_pressed()
if key_state[K_s]:
main()
break
screen.blit(background, (0, 0))
screen.blit(text_over, (100, 0))
screen.blit(text_score, (125, 100))
screen.blit(instruction, (50, 600))
pg.display.update()
clock.tick(60)
pg.quit()
class ActionsTest(TestCase):
def setUp(self):
self.pw_map = Mapa("test")
self.score = Score()
self.hcriat = CreaturesHandler()
self.hcriat.jugadores = {}
self.hcriat.pw_map = self.pw_map
self.hcriat.score = self.score
def tearDown(self):
"""Cancel all the pending calls to avoid problems"""
pending = reactor.getDelayedCalls()
for p in pending:
if p.active():
p.cancel()
def test_main(self):
server = Server()
self.assertTrue(isinstance(server.pw_map, Mapa))
self.assertTrue(isinstance(server.score, Score))
self.assertTrue(isinstance(server.hcriat, CreaturesHandler))
def test_login_blue(self):
player, _, _, _ = create_player(Team.BLUE, self.hcriat)
self.assertEqual(player.get_team(), 1)
def test_login_red(self):
player, _, _, _ = create_player(Team.RED, self.hcriat)
self.assertEqual(player.get_team(), 2)
def test_player_get_data(self):
player, _, _, _ = create_player(Team.BLUE, self.hcriat)
self.assertEqual(player.get_data(), [2, 1, 34, 2, 100, 100])
def test_wrong_player_uid(self):
self.assertRaises(PlayerDoesNotExist, self.hcriat.get_creature_by_uid, 157)
def test_lost_connection_handler(self):
player, _, _, _ = create_player(Team.BLUE, self.hcriat)
uid = player.uid
self.hcriat.del_creature_by_uid(uid)
self.assertRaises(PlayerDoesNotExist, self.hcriat.get_creature_by_uid, uid)
def test_teleport_player(self):
player, _, _, _ = create_player(Team.BLUE, self.hcriat)
teleport_player(player.uid, 1, 1, self.hcriat)
self.assertEqual((player.x, player.y), (1, 1))
def test_move_valid(self):
player, _, _, _ = create_player(Team.BLUE, self.hcriat)
for d in ('n', 's', 'o', 'e'):
before_x, before_y = player.get_coor()
moved_player = move_player(player.get_uid(), d, self.hcriat)
self.assertTrue(before_x != moved_player.x or before_y != moved_player.y)
player.bloqM.unblock()
def test_move_invalid(self):
player, _, _, _ = create_player(Team.BLUE, self.hcriat)
self.assertRaises(
InvalidMovementDirection, move_player, player.get_uid(), 'bad_direction', self.hcriat)
def test_cant_move_exception(self):
player, _, _, _ = create_player(Team.BLUE, self.hcriat)
player.vivo = False
self.assertRaises(
CantMove, move_player, player.get_uid(), 'n', self.hcriat)
def test_blocking_position(self):
player, _, _, _ = create_player(Team.BLUE, self.hcriat)
for d in ('o', 'o', 'o'):
move_player(player.get_uid(), d, self.hcriat)
player.bloqM.unblock()
self.assertRaises(BlockedPosition, move_player, player.get_uid(), 'o', self.hcriat)
def test_multiple_players_blue(self):
_, others, _, _ = create_player(Team.BLUE, self.hcriat)
self.assertEqual(others, [])
_, others, _, _ = create_player(Team.BLUE, self.hcriat)
self.assertEqual(len(others), 1)
def test_multiple_players_red(self):
_, others, _, _ = create_player(Team.RED, self.hcriat)
self.assertEqual(others, [])
_, others, _, _ = create_player(Team.RED, self.hcriat)
self.assertEqual(len(others), 1)
def test_full_team_base(self):
for _ in range(9):
create_player(Team.RED, self.hcriat)
self.assertRaises(TeamBasePositionNotFound, create_player, Team.RED, self.hcriat)
def test_shoot_directions(self):
player, _, _, _ = create_player(Team.BLUE, self.hcriat)
for d in ('n', 's', 'o', 'e', 'no', 'ne', 'so', 'se'):
player, shoot_handler = shoot_action(player.get_uid(), d, self.hcriat, None, None)
self.assertIsNot(shoot_handler, None)
player.bloqD.unblock()
def test_shoot_bad_direction(self):
player, _, _, _ = create_player(Team.BLUE, self.hcriat)
self.assertRaises(
InvalidShootDirection, shoot_action, player.get_uid(), 'bad_dir', self.hcriat, None,
None)
def test_shoot_update(self):
player, _, _, _ = create_player(Team.BLUE, self.hcriat)
_, shoot_handler = shoot_action(player.get_uid(), 'n', self.hcriat, None, None)
before_y = shoot_handler.bala.y
shoot_handler.loop()
self.assertEqual(before_y - 1, shoot_handler.bala.y)
def test_shoot_hit_wall(self):
player, _, _, _ = create_player(Team.BLUE, self.hcriat)
_, shoot_handler = shoot_action(player.get_uid(), 'o', self.hcriat, None, None)
for _ in range(3):
self.assertTrue(shoot_handler.update())
self.assertFalse(shoot_handler.update())
def test_shoot_friend(self):
player1, _, _, pw_map = create_player(Team.BLUE, self.hcriat)
player2, _, _, pw_map = create_player(Team.BLUE, self.hcriat)
pw_map.move_player(player2, player1.x+2, player1.y)
_, shoot_handler = shoot_action(player1.get_uid(), 'e', self.hcriat, None, None)
for _ in range(3):
self.assertTrue(shoot_handler.update())
def test_shoot_enemy(self):
player1, _, _, pw_map = create_player(Team.BLUE, self.hcriat)
player2, _, _, pw_map = create_player(Team.RED, self.hcriat)
pw_map.move_player(player2, player1.x+2, player1.y)
_, shoot_handler = shoot_action(player1.get_uid(), 'e', self.hcriat, callback, None)
health_before = player2.vida
self.assertTrue(shoot_handler.update()) # move 1 sqm
self.assertFalse(shoot_handler.update()) # hit the enemy
self.assertLess(player2.vida, health_before)
def test_cant_shoot_exception(self):
player1, _, _, _ = create_player(Team.BLUE, self.hcriat)
player1.vivo = False
self.assertRaises(
CantShoot, shoot_action, player1.get_uid(), 'e', self.hcriat, callback, None)
def test_kill_and_revive_enemy(self):
player1, _, _, pw_map = create_player(Team.BLUE, self.hcriat)
player2, _, _, pw_map = create_player(Team.RED, self.hcriat)
pw_map.move_player(player2, player1.x+1, player1.y)
_, shoot_handler = shoot_action(
player1.get_uid(), 'e', self.hcriat, callback, callback)
player2.vida = 1
shoot_handler.loop()
self.assertFalse(player2.vivo)
revive_player(player2.uid, self.hcriat)
self.assertTrue(player2.vivo)
self.assertEqual(player2.vida, CreaturesHandler.VIDA_MAX)
def test_score_from_blue(self):
player1, _, _, pw_map = create_player(Team.BLUE, self.hcriat)
player2, _, _, pw_map = create_player(Team.RED, self.hcriat)
def die_callback(uid):
return increase_score(uid, self.hcriat)
pw_map.move_player(player2, player1.x+1, player1.y)
_, shoot_handler = shoot_action(
player1.get_uid(), 'e', self.hcriat, callback, die_callback)
player2.vida = 1
self.assertEqual(self.score.blue_score, 0)
shoot_handler.loop()
self.assertEqual(self.score.blue_score, 1)
def test_score_from_red(self):
player1, _, _, pw_map = create_player(Team.RED, self.hcriat)
player2, _, _, pw_map = create_player(Team.BLUE, self.hcriat)
def die_callback(uid):
return increase_score(uid, self.hcriat)
pw_map.move_player(player2, player1.x+1, player1.y)
_, shoot_handler = shoot_action(
player1.get_uid(), 'e', self.hcriat, callback, die_callback)
player2.vida = 1
self.assertEqual(self.score.red_score, 0)
shoot_handler.loop()
self.assertEqual(self.score.red_score, 1)
def test_restart_round(self):
# wrong player trying to restart
self.assertIsNone(restart_round(153, self.hcriat))
# real case
player1, _, _, pw_map = create_player(Team.BLUE, self.hcriat)
player2, _, _, pw_map = create_player(Team.RED, self.hcriat)
# move both once place
teleport_player(player1.uid, player1.x+1, player1.y+1, self.hcriat)
teleport_player(player2.uid, player2.x+1, player2.y+1, self.hcriat)
# change life
player1.vida = 1
player2.vida = 1
# change score
self.score.murio_azul()
self.score.murio_rojo()
# restart
players, new_score = restart_round(player1.uid, self.hcriat)
# base positions
new_blue = players.pop(0) if players[0].team == Team.BLUE else players.pop()
new_red = players.pop()
# blue
self.assertEqual(new_blue.x, pw_map.x_azul)
self.assertEqual(new_blue.y, pw_map.y_azul)
self.assertEqual(new_blue.vida, self.hcriat.VIDA_MAX)
# red
self.assertEqual(new_red.x, pw_map.x_rojo)
self.assertEqual(new_red.y, pw_map.y_rojo)
self.assertEqual(new_red.vida, self.hcriat.VIDA_MAX)
# score
self.assertEqual(new_score[0], 0)
self.assertEqual(new_score[1], 0)
class pyReadability():
'''
Main class for the applicaiton. Loads the data, encodes it and runs scoring algortim.
'''
def __init__(self,
model,
interact,
topK,
seed,
mod,
probability,
Log=None):
''' Take in variables and starts the program. See readme for inputs'''
self.model = model
self.topK = topK
self.interact = interact
self._seed = seed
self._probability = probability
self._score = -1
self._build(mod, Log)
def _build(self, mod, Log):
''' Builds application using variables provided by user '''
if Log == None:
Log = Log()
if (self._seed < 1):
random.seed(time.time())
self._seed = random.random()
self.Log = Log
self.Scorer = Score(mod, self.Log)
self.Encoder = Encoder(seed=self._seed, probability=self._probability)
self.GPT = GPT2LanguageModel(model_name=self.model)
def _run(self, text):
''' Runs GTP and gets results '''
logits = self.GPT.predict(text, "")
probabilities = torch.nn.functional.softmax(logits)
best_indices = logits.topk(self.topK)[1]
self.best_words = [self.GPT[idx.item()] for idx in best_indices]
self.best_probabilities = probabilities[best_indices].tolist()
def _getWords(self):
''' returns Top-K Words from GPT-2 '''
return self.best_words
def _getPropability(self):
''' returns top-k Propabilities from GPT-2 '''
return [round(p * 100, 2) for p in self.best_probabilities]
def _process(self, text, guess):
''' scores inputted text and logs it '''
self._run(text)
outputLst = self._output()
self.Log.Trace(("Answer List : {}".format(outputLst)))
score = self.Scorer.score(outputLst, guess)
self.Log.Trace(score)
self.Log.Info("Score of \'{}\': {}".format(score[0], score[1]))
def start(self, text=""):
'''
starts program
text = Text to be inputted
'''
if text == "" and not self.interact:
raise EnvironmentError(
"Please input valid text or use the --interact flag")
if text != "":
encoded = self.Encoder.encode(text=text)
for item in encoded:
if item[0] == '':
continue
self._process(item[0], item[1])
# Code for Manual Input, meant for debugging not for production use
else:
while self.interact:
text = self.Log.Input("Input Text >> ")
if text == "":
self.Log.Info("Please provide a valid input")
continue
if text == "#?":
self.Log.Info(
"Available Commands: \n#?: Shows available commands\n#end: Ends Execution"
)
continue
if text == "#end":
self.Log.Info("Ending Program")
break
guess = self.Log.Input("What will the next word be >> ")
self._process(text, guess)
self._score = self.Scorer.calcScore()
self.Log.Info("Normalized Score: {} | Unnormalized Score: {}".format(
self.getNormScore(), self.getUnNormScore()))
def getNormScore(self):
''' returns the normalized score '''
return self._score[0]
def getUnNormScore(self):
''' returns the unormalized score '''
return self._score[1]
def getSeed(self):
''' returns the seed used '''
return self._seed
def getEncoder(self):
''' returns the encoder object '''
return self.Encoder
def _output(self):
''' returns top-k words and propabilities '''
return [(self._getWords()[i], self._getPropability()[i])
for i in range(self.topK)]
