def __init__(self, token, playerBlack, playerWhite):
self.token = token
self.black = playerBlack
self.white = playerWhite
self.turn = playerBlack
self.columns = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']
self.board = Grid(self.columns)
def test_SettingField():
grid = Grid(columns)
grid.set(4, 'd', FieldValue.BLACK)
valueGrid = [[0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, -1, -1, 0, 0, 0],
[0, 0, 0, -1, 1, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0]]
assert valueGrid == grid.valueGrid
def test_GridConstructor():
gridStr = str([[0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 1, -1, 0, 0, 0],
[0, 0, 0, -1, 1, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0]])
grid = Grid(columns)
assert gridStr == str(grid)
def init_display():
pygame.init()
display = pygame.display.set_mode((WINDOW_WIDTH, WINDOW_HEIGHT))
pygame.display.set_caption("Number Predictor")
display.fill(pygame.Color("White"))
pygame.display.update()
grid = Grid()
return display, grid
import numpy as np
from Board import Grid
from AI import IntelligentAgent
import random
import time
start = time.time()
grid = Grid()
IA = IntelligentAgent()
grid.print()
while True:
available_cells = grid.getAvailableCells()
if len(available_cells) > 0:
new_tile = random.choice(available_cells), np.random.choice([2, 4],
p=[.8, .2])
grid.insertTile(new_tile[0], new_tile[1])
print("Game:")
grid.print()
else:
break
move = IA.get_move(grid.clone())
if move is not None and 0 <= move < 4 and grid.canMove([move]):
grid.move(move)
print("AI:")
grid.print()
else:
break
class Game:
def __init__(self, token, playerBlack, playerWhite):
self.token = token
self.black = playerBlack
self.white = playerWhite
self.turn = playerBlack
self.columns = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']
self.board = Grid(self.columns)
def addGrid(self, grid):
for row in self.board.grid:
for field in row:
i = field.row - 1
c = self.columns.index(field.col)
if grid[i][c] == FieldValue.BLACK.value:
field.playedBy = FieldValue.BLACK
elif grid[i][c] == FieldValue.WHITE.value:
field.playableBy = FieldValue.WHITE
else:
field.playableBy = FieldValue.NONE
@property
def playerValue(self):
return FieldValue.WHITE if self.turn == self.white else FieldValue.BLACK
@property
def opponentValue(self):
return FieldValue.WHITE if self.playerValue == FieldValue.BLACK else FieldValue.BLACK
def __str__(self):
gameDict = {}
gameDict['gameToken'] = self.token
gameDict['gameGrid'] = str(self.board)
return str(gameDict).replace("'", '"')
def set(self, row, col, value):
"""Set field value in field in grid
Arguments:
row {int} -- row number
col {string} -- column name
value {FieldValue} -- -1 for black, 1 for white, 0 for neither
"""
self.board.set(row, col, value)
def get(self, row, col):
"""Get field value in grid
Arguments:
row {int} -- row numner
col {string} -- column name
Returns:
int -- Value of field
"""
return self.board.get(row, col).playedBy
def addPlayer(self, newPlayerToken):
"""Add new played togame
Arguments:
newPlayerToken {string} -- playertoken
"""
if self.black is None:
self.black = newPlayerToken
elif self.white is None:
self.white = newPlayerToken
else:
raise ("Something is wrong here.")
def update(self, playerToken, row, col):
"""Updates the grid when a move is made
Arguments:
playerToken {string} -- Token of the player who made the move
row {int} -- Row in which the move was done
col {str} -- Column in which the move was done
Returns:
bool -- True if move went through, False if it didn't
"""
try:
if (playerToken == self.turn
and self.checkBorderedToStone(row, col)):
self.flipValues(row, col)
else:
raise ('Illegal move')
return True
except Exception as exception:
return False
### ####################################### ###
### Helpers ###
### ####################################### ###
def checkBorderedToStone(self, row, col):
"""Checks wether a move is legal or not
Arguments:
row {int} -- Row in which the move was made
col {str} -- Column which the move was made in
Returns:
Boolean -- True if move is legal
"""
col = col.lower()
rowIdx = row - 1
colIdx = self.columns.index(col)
if (self.get(row, col) == FieldValue.NONE):
surroundingValues = [
# row above desired field to fill
self.getFieldValue(rowIdx - 1, colIdx - 1),
self.getFieldValue(rowIdx - 1, colIdx),
self.getFieldValue(rowIdx - 1, colIdx + 1),
# row at desired field to fill
self.getFieldValue(rowIdx, colIdx - 1),
self.getFieldValue(rowIdx, colIdx + 1),
# row below desired field to fill
self.getFieldValue(rowIdx + 1, colIdx - 1),
self.getFieldValue(rowIdx + 1, colIdx),
self.getFieldValue(rowIdx + 1, colIdx + 1)
]
return any(x == FieldValue.WHITE or x == FieldValue.BLACK
for x in surroundingValues)
else: # user tries to fill field that's already filled
return False
def getFieldValue(self, rowIdx, colIdx):
"""Returns the played value of a field based on row Index and Column index
!!Look out!!
Arguments:
rowIdx {int} -- row index
colIdx {int} -- column index
Returns:
Field -- Field of grind in requested row index and column index.
"""
if (rowIdx < 0 or rowIdx > 7 or colIdx < 0
or colIdx > 7): # out of bounds
return FieldValue.NONE
else:
col = self.columns[colIdx]
return self.get(rowIdx + 1, col)
def flipValues(self, row, col):
"""Flips the values after a legal move came through
Arguments:
row {int} -- Row of the move resulting in the flippin'
col {str} -- Col of the move resulting in the flippin'
Returns:
Boolean -- True if flipped any values, False is not
"""
playerValue = FieldValue.WHITE if self.turn == self.white else FieldValue.BLACK
star = [
self.getHorizontal_Left(row, col),
self.getHorizontal_Right(row, col),
self.getVertical_top(row, col),
self.getVertical_bot(row, col),
self.getDiagonal_topLeft(row, col),
self.getDiagonal_topRight(row, col),
self.getDiagonal_botLeft(row, col),
self.getDiagonal_botRight(row, col),
]
try:
# flip values for move
fieldsFlipped = 0
for arr in star:
fieldsFlipped += self.flipFieldArray(arr)
if (fieldsFlipped > 0):
self.set(row, col, playerValue)
self.turn = self.white if self.turn == self.black else self.black
# flip turn value
# flip playability values
# for row in self.board.grid:
# for field in row:
# field.playableBy = CanBePlayedBy.NONE
# if self.checkBorderedToStone(field.row, field.col):
# canflip = [
# self.canFlip(self.getHorizontal_Left(field.row, field.col)),
# self.canFlip(self.getHorizontal_Right(field.row, field.col)),
# self.canFlip(self.getVertical_top(field.row, field.col)),
# self.canFlip(self.getVertical_bot(field.row, field.col)),
# self.canFlip(self.getDiagonal_topLeft(field.row, field.col)),
# self.canFlip(self.getDiagonal_topRight(field.row, field.col)),
# self.canFlip(self.getDiagonal_botLeft(field.row, field.col)),
# self.canFlip(self.getDiagonal_botRight(field.row, field.col)),
# ]
# if any(canflip):
# playabalityValue = CanBePlayedBy.BLACK if self.playerValue == FieldValue.BLACK else CanBePlayedBy.WHITE
# field.addPlayability(playabalityValue)
except:
pass
def flipFieldArray(self, fields):
"""Flips the fields based on the reversi rules
Returns True if at least one field was flipped
Arguments:
fields {Field[]} -- Array of fields to flip
Returns:
Boolean -- canflip
"""
fieldsFlipped = 0
if self.canFlip(fields):
i = 0
while (i < len(fields)) & (fields[i].playedBy != self.playerValue
) & (fields[i].playedBy != 0):
if fields[i].playedBy == self.opponentValue:
fields[i].playedBy = self.playerValue
fieldsFlipped += 1
i += 1
return fieldsFlipped
def canFlip(self, fields):
canFlip = False
if len(fields) != 0:
if fields[0].playedBy == self.opponentValue:
for f in range(1, len(fields)):
if fields[f].playedBy == self.playerValue:
canFlip = True
break
return canFlip
def createFieldArray(self, row, col, directionalCallback):
f = self.board.get(row, col)
currentField = directionalCallback(f)
fields = []
if currentField != None:
if currentField.playedBy != 0:
fields.append(currentField)
while (directionalCallback(currentField) != None):
currentField = directionalCallback(currentField)
fields.append(currentField)
return fields
def getHorizontal_Left(self, row, col):
"""Flips stones left of the move made
!!! look out !!! have to know what you're doing !!!
Arguments:
row {int} -- Row
col {str} -- col
Returns:
Field[] -- Array of fields to check and flip
"""
return self.createFieldArray(row, col, self.board.left)
def getHorizontal_Right(self, row, col):
"""Flips stones right of the move made
!!! look out !!! have to know what you're doing !!!
Arguments:
row {int} -- Row
col {str} -- col
Returns:
Field[] -- Array of fields to check and flip
"""
return self.createFieldArray(row, col, self.board.right)
def getVertical_top(self, row, col):
"""Flips stones above the move made
!!! look out !!! have to know what you're doing !!!
Arguments:
row {int} -- Row
col {str} -- col
Returns:
Field[] -- Array of fields to check and flip
"""
return self.createFieldArray(row, col, self.board.top)
def getVertical_bot(self, row, col):
"""Flips stones belowthe move made
!!! look out !!! have to know what you're doing !!!
Arguments:
row {int} -- Row
col {str} -- col
Returns:
Field[] -- Array of fields to check and flip
"""
return self.createFieldArray(row, col, self.board.bottom)
def getDiagonal_topLeft(self, row, col):
"""Flips stones top left of the move made
!!! look out !!! have to know what you're doing !!!
Arguments:
row {int} -- Row
col {str} -- col
Returns:
Field[] -- Array of fields to check and flip
"""
return self.createFieldArray(row, col, self.board.topLeft)
def getDiagonal_topRight(self, row, col):
"""Flips stones top right of the move made
!!! look out !!! have to know what you're doing !!!
Arguments:
row {int} -- Row
col {str} -- col
Returns:
Field[] -- Array of fields to check and flip
"""
return self.createFieldArray(row, col, self.board.topRight)
def getDiagonal_botLeft(self, row, col):
"""Flips stones bot left of the move made
!!! look out !!! have to know what you're doing !!!
Arguments:
row {int} -- Row
col {str} -- col
Returns:
Field[] -- Array of fields to check and flip
"""
return self.createFieldArray(row, col, self.board.botLeft)
def getDiagonal_botRight(self, row, col):
"""Flips stones bot right of the move made
!!! look out !!! have to know what you're doing !!!
Arguments:
row {int} -- Row
col {str} -- col
Returns:
Field[] -- Array of fields to check and flip
"""
return self.createFieldArray(row, col, self.board.botRight)
def test_GettingField():
grid = Grid(columns)
assert grid.get(4, 'd').playedBy == FieldValue.WHITE
assert grid.get(4, 'e').playedBy == FieldValue.BLACK
def test_GridColumnsShouldBeLowerCased():
grid = Grid(columns)
assert all(col.islower() for col in grid.columns)
def receive_data():
global turn
while True:
data_recv = str(my_socket.recv(1024).decode()).split("-")
x, y = int(data_recv[0]), int(data_recv[1])
turn = True
if grid.get_cell_value(x, y == '-'):
grid.set_cell_value(x, y, 'x')
create_thread(receive_data)
surface = pygame.display.set_mode((600, 600))
pygame.display.set_caption("Tic Tac Toe")
grid = Grid()
running = True
player = '0'
turn = False
playing = 'True'
while running:
win = False
surface.fill((0, 0, 0)) # black
grid.draw(surface)
if not turn:
font = pygame.font.Font('freesansbold.ttf', 15)
text = font.render("waiting for player 1", True, (0, 255, 255))
surface.blit(text, (15, 600 - 25))
for event in pygame.event.get():
if event.type == pygame.QUIT: