def main():
pos = (5, 5)
posHistory = [pos]
for i in range(10):
pos = GeneticTrainer.randomAdjacentPosition(pos)
posHistory.append(pos)
from Models.Board import Board
board = Board()
for pos in posHistory:
board.place('X', pos)
print()
posSet = set(posHistory)
print(f"Same length? {len(posHistory) == len(posSet)}")
if not len(posHistory) == len(posSet):
print("History:")
print(posHistory)
print("\nSet:")
print(posSet)
# Ensure that crossover works properly.
# There should be a mix of 1's, 2's, and potentially a random number or more.
dict1 = {'weights': torch.Tensor([[1, 1, 1], [1, 1, 1], [1, 1, 1]])}
dict2 = {'weights': torch.Tensor([[2, 2, 2], [2, 2, 2], [2, 2, 2]])}
crossover = GeneticTrainer.crossover(dict1, dict2, mutation_rate=0.4)
print(crossover.get('weights'))
# Randomize the weights
print(dict1.get('weights'))
GeneticTrainer.randomize(dict1, mutation_rate=0.5)
print(dict1.get('weights'))
def _initNew( self, player1, player2 ):
## Create empty board
self.board = Board()
## Save player info
self.player1 = int( player1 )
self.player2 = int( player2 )
## Save status
self.status = "CHALLENGE"
self.winner = None
self.turn = 1
## Create new Game instance
self.game = Game( player1 = self.player1, player2 = self.player2,
status = self.status, board = self.board.serialize(),
turn = self.turn, winner = self.winner, parent = Game.games_key() )
## Save new game to database
key = self.game.put()
self.gameid = key.id()
## Send an email to player 2
player1_name = User.get_user_name( self.player1 )
player2_user = User.by_id( self.player2 )
HexEmail.sendChallenge( player2_user.email, player1_name )
def __init__(self, width, height, checkersToWin):
self.width = width
self.height = height
self.checkersToWin = 3
self.board = Board(width, height)
self.boardView = BoardView(6)
def validDirections(board: Board, snake: Snake,
point: Tuple[int, int]) -> List[Direction]:
return [
direction for direction in Direction.moves()
if board.isEmpty(snake.adjusted(snake.head(), direction))
or snake.adjusted(snake.head(), direction) == point
]
def main():
word = RandomWord(choice(JsonWords().get_words()))
while "-" in word.random_word or " " in word.random_word: # avoids words like "water-based" or entries with spaces
word = RandomWord(choice(JsonWords().get_words()))
board = Board(player, word)
view = View()
controller = Controller(board, view)
controller.hint()
while True:
controller.take_guess()
controller.handle_guess()
controller.result()
controller.check_winner()
if controller.winner is not None:
if play_again():
main()
else:
controller.close()
quit()
def __init__(self, board: Board = None, snakes: List[Snake] = None):
self.board = board if board is not None else Board()
self.snakeDict: Dict[str, Snake] = {}
self.point = None
if snakes is not None:
for snake in snakes:
self.addSnake(snake)
self.generatePoint()
def _initExisting( self, gameid ):
self.gameid = gameid
## Retrieve game from database
self.game = Game.by_id( int( gameid ) )
## Load up player info
self.player1 = self.game.player1
self.player2 = self.game.player2
self.status = self.game.status
self.turn = self.game.turn
self.winner = self.game.winner
## Create a new board instance
self.board = Board( self.game.board )
def __init__(self):
rows = 3
columns = 3
cellSize = 6
self.checkersToWin = 3
self.humanIsBlack = False
self.humanTurn = True
self.board = Board(rows, columns)
self.boardView = BoardView(cellSize)
print ("Welcome to Tic Tac Toe :)")
t = Tests(rows, columns, self.checkersToWin)
t.runTests()
print ("*** Game Start ***")
self._gameLoop()
class Engine:
def __init__(self, state, game_over, board_instance=None):
self.state = state
self.game_over = game_over
self.board_instance = board_instance
def _init_game(self):
self.init_board()
self.board_instance.print_board()
def init_board(self):
columns = input("Nombre de colonnes : ")
rows = input("Nombre de lignes : ")
self.board_instance = Board(columns, rows)
self.board_instance.add_building()
self.init_player()
def init_player(self):
player_name = input("Quel est le pseudo du joueur 1: ")
player = self.board_instance.create_new_player(player_name)
self.create_hero_for_user(player)
player_name = input("Quel est le pseudo du joueur 2: ")
player = self.board_instance.create_new_player(player_name)
self.create_hero_for_user(player)
def create_hero_for_user(self, player):
with open("conf/heroes.json") as f:
config = json.load(f)
heroes = {}
i = 0
for hero in config:
print('[ ' + str(i) + ' ]' + ' ' + hero)
heroes[i] = hero
i += 1
print(heroes)
while True:
hero_id = input('Choisissez le personnage ? ')
hero = Hero.get_by_conf(heroes[int(hero_id)])
if hero is None:
print('Invalid Hero')
else:
print('LA')
print(hero)
self.board_instance.set_player(player.get_name(), hero)
return True
def new_game(cls, board_size, rule_set):
assert isinstance(board_size, int)
board_size = (board_size, board_size)
board = Board(*board_size)
return State(board, rule_set, Color.black, None, None, rule_set.komi)
class Tests(object):
def __init__(self, width, height, checkersToWin):
self.width = width
self.height = height
self.checkersToWin = 3
self.board = Board(width, height)
self.boardView = BoardView(6)
def runTests(self):
print("Running tests...")
self._checkVerticals()
self._checkHorizontals()
self._checkPositiveDiagonals()
self._checkNegativeDiagonals()
self._checkForCatsGame()
self.board.reset()
def _checkHorizontals(self):
print("Checking horizontal win states")
for r in range(0, self.height):
self.board.reset()
for c in range(0, self.width):
self.board.checkers[c][r] = Checker(True)
self.boardView.showBoard(self.board)
self._checkWinState()
def _checkVerticals(self):
print("Checking vertical win states")
for c in range(0, self.width):
self.board.reset()
for r in range(0, self.height):
self.board.checkers[c][r] = Checker(True)
self._checkWinState()
self.boardView.showBoard(self.board)
def _checkPositiveDiagonals(self):
print("Checking positive diaganol win states")
for c in range(0, self.width):
for r in range(0, self.height):
self.board.reset()
if (c + self.checkersToWin -1 < self.width):
if (r + self.checkersToWin - 1 < self.height):
for n in range(0, self.checkersToWin):
self.board.setChecker(c+n, r+n, True)
self._checkWinState()
self.boardView.showBoard(self.board)
def _checkNegativeDiagonals(self):
print("Checking negative diaganol win states")
for c in range(0, self.width):
for r in range(0, self.height):
self.board.reset()
if (c + self.checkersToWin <= self.width):
if (1 + r - self.checkersToWin >= 0):
for n in range(0, self.checkersToWin):
self.board.setChecker(c+n, r -n, True)
self._checkWinState()
self.boardView.showBoard(self.board)
def _checkForCatsGame(self):
print("Checking if cats game is detected")
pieces = [(0,0, True), (1,0, True), (2, 0, False),
(0, 1, False), (1,1, False), (2, 1, True),
(0,2, True), (1, 2 ,False), (2, 2, True)]
for p in range(0, len(pieces)):
column, row, color = pieces[p]
self.board.setChecker(column, row, color)
cats = self.board.isCatsGame(self.checkersToWin)
if (cats) :
print("* Pass")
else :
print("Fail")
def _checkWinState(self):
hasWin = self.board.hasWinner(3)
if (hasWin > -1):
print("* Pass")
else :
print("Fail")
def init_board(self):
columns = input("Nombre de colonnes : ")
rows = input("Nombre de lignes : ")
self.board_instance = Board(columns, rows)
self.board_instance.add_building()
self.init_player()
class GameView():
def __init__( self, **kwargs ):
## If a game id was provided, initialize the existing game
if "gameid" in kwargs:
self._initExisting( kwargs[ "gameid" ] )
## Otherwise, intialize a new game between the two given players
else:
self._initNew( kwargs[ "player1" ], kwargs[ "player2" ] )
def _initNew( self, player1, player2 ):
## Create empty board
self.board = Board()
## Save player info
self.player1 = int( player1 )
self.player2 = int( player2 )
## Save status
self.status = "CHALLENGE"
self.winner = None
self.turn = 1
## Create new Game instance
self.game = Game( player1 = self.player1, player2 = self.player2,
status = self.status, board = self.board.serialize(),
turn = self.turn, winner = self.winner, parent = Game.games_key() )
## Save new game to database
key = self.game.put()
self.gameid = key.id()
## Send an email to player 2
player1_name = User.get_user_name( self.player1 )
player2_user = User.by_id( self.player2 )
HexEmail.sendChallenge( player2_user.email, player1_name )
def _initExisting( self, gameid ):
self.gameid = gameid
## Retrieve game from database
self.game = Game.by_id( int( gameid ) )
## Load up player info
self.player1 = self.game.player1
self.player2 = self.game.player2
self.status = self.game.status
self.turn = self.game.turn
self.winner = self.game.winner
## Create a new board instance
self.board = Board( self.game.board )
def update_game( self, user, row, col ):
## Make sure the correct user is making the move
player_to_move = self.player_to_move()
## If the wrong player moved, raise an exception
if str( user.key().id() ) != str( player_to_move ):
raise WrongTurnException( "It is not your turn to move" )
## If this game is already complete, raise an exception
if self.status == "COMPLETE":
raise AlreadyCompleteException( "The game is already finished" )
## Update the board
self.board.update_board( row, col, self.turn )
## Check if game is now finished
if self.board.is_finished( self.turn ):
self.winner = self.player_to_move()
self.status = "COMPLETE"
else:
## Flip who's turn it is to move
self.turn = ( self.turn % 2 ) + 1
## Update the underlying Game
self.game.update_state( self.turn, self.board.serialize(), self.status, self.winner )
## Save underlying Game to the database
self.game.put()
def update_status( self, new_status ):
self.status = new_status
self.game.status = new_status
self.game.put()
def player_to_move( self ):
## Make sure the correct user is making the move
return self.player1 if self.turn == 1 else self.player2
def is_my_turn( self, user_id ):
to_move = self.player_to_move()
return self.status == "ACTIVE" and to_move == user_id
def get_detailed_status( self, user_id ):
## Pending games
if self.status == "CHALLENGE":
player2_name = User.get_user_name( self.player2 )
return "Waiting for %s to accept challenge" % player2_name
## Active games
if self.is_my_turn( user_id ):
return "My move"
if self.status == "ACTIVE":
return "Opponent's turn"
## Completed games
if self.status == "COMPLETE":
winner_name = User.get_user_name( self.winner )
return "%s has won" % winner_name
class TicTacToe(object):
def __init__(self):
rows = 3
columns = 3
cellSize = 6
self.checkersToWin = 3
self.humanIsBlack = False
self.humanTurn = True
self.board = Board(rows, columns)
self.boardView = BoardView(cellSize)
print ("Welcome to Tic Tac Toe :)")
t = Tests(rows, columns, self.checkersToWin)
t.runTests()
print ("*** Game Start ***")
self._gameLoop()
# responsible for running the game
# gives turn to the approproate player
# checks state after turn is completed
def _gameLoop(self):
if self.humanTurn:
self._humanTurn()
else:
self._computerTurn()
self.boardView.showBoard(self.board)
# check for winning state
winner = self.board.hasWinner(self.checkersToWin)
if winner != -1:
self._handleGameOver(winner)
return
if self.board.isCatsGame(self.checkersToWin):
print ("Cat's game: ")
print (cat())
return
self.humanTurn = not self.humanTurn
self._gameLoop()
# handles game over
def _handleGameOver(self, winner):
# there is a winner
self.boardView.showBoard(self.board)
if winner == 1:
print ("You won! ")
else:
print ("You lost :( ... Better luck next time!")
# human turn logic
def _humanTurn(self):
print ("It's your turn. You are O's!")
self.boardView.showBoard(self.board)
self._requestHumanMove()
def _requestHumanMove(self):
column = self._getInputInRange("Enter column for you move: ", self.board.height)
row = self._getInputInRange("Enter row for you move: ", self.board.height)
if self.board.isEmptyAtColumnRow(column, row):
self.board.setChecker(column, row, self.humanIsBlack)
else:
print ("Looks like the square at column: " + str(column) + ", row: " + str(row) + " is occupied!")
print ("Please pick a different location!")
self._requestHumanMove()
def _getInputInRange(self, string, range):
while True:
try:
row = int(raw_input(string))
if row >= range:
print (str(row) + " is not less than " + str(range))
return self._getInputInRange(string, range)
return row
except ValueError:
print "Whoops that doesn't look like a valid number. Try again..."
# computer turn logic
def _computerTurn(self):
print ("It's the computer's turn!")
column, row = getAIMoveTuple(self.board, self.checkersToWin, not self.humanIsBlack)
self.board.setChecker(column, row, not self.humanIsBlack)
print ("The computer played at column: " + str(column) + " and at row: " + str(row))
