def main(boards):
types = {}
cvals = calibrate(boards)
for i in range(len(boards)):
# s1, s2 =
board.board_init(boards[i])
addr = boards[i]
#print s1, s2
types[addr] = str(s1), str(s2)
print types[addr]
#be.com
iteration = 0
while True:
#if iteration < 5:
#cvals = dbcalibrate(boards)
#subprocess
iteration = iteration + 1
#print iteration
try:
#cvals = calibrate(boards)
dataline = []
#print boards
for i in range(len(boards)):
#print types[boards[i]][0], types[boards[i]][1]
data = readSensors(boards[i], types[boards[i]][0], types[boards[i]][1], cvals)
dataline.append(data)
writeSocket(dataline)
except Exception as ex:
print ex
raise
def parseSgfHeader(header, filename=None):
""" Returns a board initialized based on the header information (e.g
size, handicap stones).
filename gets passed through to the Board object that gets returned."""
size_match = re.search('SZ\\[(.+?)\\]', header)
if size_match:
try:
board_size = size_match.group(1)
board_size = int(board_size)
except ValueError:
raise SgfParsingError("Non-integer board size \"" + str(board_size) + \
"\" found while parsing SGF file.")
else:
board_size = 19
board = Board(board_size, filename)
starting_black_stones = re.search('AB((?:\\[.+?\\])*)', header)
if starting_black_stones:
tokens = starting_black_stones.group(1)
for i in range(0, len(tokens), 4):
board.applyIntersections([SgfParser.parseSgfToken('B'+tokens[i:i+4], board_size)])
starting_white_stones = re.search('AW((?:\\[.+?\\])*)', header)
if starting_white_stones:
tokens = starting_white_stones.group(1)
for i in range(0, len(tokens), 4):
board.applyIntersections([SgfParser.parseSgfToken('W'+tokens[i:i+4], board_size)])
return board
def main():
print "Welcome to King Saul Checkers! [5x5, two Kings each]"
# test default CTOR
B = Board()
print B
# test setting up an initial board
B.initializeBoard()
print B
# test iterating over all the pieces (kings) on the board
# whichKing is hash: key: name, value: King object
for nextKing in B.whichKing.keys():
print B.whichKing[nextKing]
# test making (potential) moves of each King on board B
nextMoves = []
for moveThisKing in B.whichKing.keys():
newBoards = B.getNextMoves( B.whichKing[moveThisKing] )
print "----------------------------------------------"
print "Potential Moves for King: ", moveThisKing
for nextBoard in newBoards:
print "\tFROM", B.whichKing[ moveThisKing ].chinookNum, "TO", nextBoard.whichKing[ moveThisKing ].chinookNum
def _approach (self, enemy, faceTorsoEnemy):
i = 0
x = 0
while True:
x = Board.adjacent_cells(enemy, (faceTorsoEnemy+i)%6, self.board)
i += 1
if (not x in self.mechs.enemys_cell()) and x != 0: break
pf = pathfinder.PathFinder(self.board.successors, self.board.move_cost, self.board.heuristic_to_goal)
A = Pos(self.playerCell, self.playerFace)
B = Pos(x, Board.facing_side(x, enemy))
if A == B: return ([], 3)
path, can, cost = pf.compute_path_until_PM (A, B, 0, self.player.walk)
if can == False and self.player.run != 0:
path2, can2, cost2 = pf.compute_path_until_PM(A, B, 1, self.player.run)
if can2 == True:
return (path2, 1)
if can == False and self.player.jump != 0:
print "ESTO K ES!: walk then jump"
print self.player.walk
print self.player.jump
path3, can3, cost3 = pf.compute_path_until_PM(A, B, 2, self.player.jump)
if (can3 == True) or (self.player.jump >= self.player.walk):
return (path3,2)
return (path, 0)
def evaluateBoard(self, board, color, combined, start_row = 0, start_col = 0, end_row = 7, end_col = 7):
value = 0
for row in range(start_row, end_row + 1):
for col in range (start_col, end_col + 1):
piece = board[row][col]
# If it's my piece, then add to my total.
if color == Piece.pieceColor(piece):
value = value + self.__getMaterialValue(board, color, piece)
value = value + self.__getPositionValue(color, piece, row, col)
if Board.isFrozen(board, piece, row, col):
value = value + self.__getFrozenValue(color, piece, row, col)
# Else, it's the opponent's piece, the value goes down.
elif combined == True:
value = value - self.__getMaterialValue(board, color, piece)
value = value - self.__getPositionValue(color, piece, row, col)
if Board.isFrozen(board, piece, row, col):
value = value - self.__getFrozenValue(color, piece, row, col)
return value
def buttonStandardBoard():
GameState.s.setGameState(2)
for row in range(8):
for column in range(8):
if (0<= row <= 2) and (((row+column) %2) == 1):
Board.insertPiece(row,column,"B")
if (5<=row<=8) and (((row+column) %2) == 1):
Board.insertPiece(row,column,"W")
class Game:
def set_new_game_id(self):
previous_ids = []
for filename in os.listdir("games"):
previous_ids.append(int(filename))
if len(previous_ids) == 0:
self.game_id = 1
else:
self.game_id = max(previous_ids) + 1
def is_game_in_progress(gid):
for filename in os.listdir("games"):
if str(gid) == filename:
return True
return False
def start_new_game(self,player):
self.set_new_game_id()
# Create the board
self.board = Board(400,400,player,Player("Player 2",""))
self.board.refill(player)
self.board.display_tiles()
# Set up the rest of the current game state
self.current_player = player # Default to the first person
self.prev_result = None
def run(self):
self.players = []
# Read the players from the database
self.db = Database("db.txt")
self.db.read()
# From our tic-tac-toe game, we need to have the user login
start_screen = StartScreen()
while True:
result = start_screen.login(self.db)
if result == "new":
self.start_new_game(start_screen.getPlayer())
break
elif result == "quit": # Quit was hit, so end the game
return
else: # Must be a game id
self.load(result,start_screen.getPlayer())
while True:
self.result = self.board.take_turn(self.current_player)
if self.result == "pass" and self.prev_result == "pass":
break # Show result
if self.result == "quit":
return
if self.result == "submit":
self.current_player.refill()
self.prev_result = self.result
def load(self,game_id,player):
return
def main():
print "\nWelcome to King Saul Checkers! [6x6, two Kings each]\n"
B = Board() # get new board
B.initializeBoard() # set up starting board
playGame(B)
def main():
domain = "http://localhost:8080" # domain al que nos vamos a conectar
pid = int(input("Ingrese el id del jugador: "))
name = input("Ingrese el nombre del jugador: ")
taquin.create_player(domain, pid, name)
option = int(input("1) Single player, 2) Resolver un reto (Multiplayer), 3) Retar a un jugador, -1) salir\n"))
while option != -1:
if option == 1:
size = int(input("Ingrese el tamaño N del tablero: "))
matrix = taquin.generate_matrix(size) # generamos una matriz de size * size
board = Board(matrix, size, size-1, size-1)
# -------------- PARA PROBAR 2x2 ------------
#matrix = [[3, 1],
# [2, None]]
#board = Board(matrix, 2, 1, 1)
# -------------------------------------------
# -------------- PARA PROBAR 3x3 ------------
#matrix = [[1, 3, 4],
# [2, 5, 6],
# [7, 8, None]]
#board = Board(matrix, 3, 2, 2)
# -------------------------------------------
while not board.is_solvable():
matrix = taquin.generate_matrix(size) # generamos una matriz de size * size
board = Board(matrix, size, size - 1, size - 1)
taquin.generateBoard(domain, matrix, size-1, size-1) # mandamos la matriz para que se display en la pagina
if board.is_solvable():
print("El tablero SI se puede resolver")
solver = Solver(board)
movements = solver.solve()
print("Movimientos: ", movements)
if len(movements) != 0:
send_movements(domain, pid, movements)
else:
print("El tablero NO se puede resolver")
elif option == 2: # todavia no sirve
taquin.get_challenge(domain, pid)
elif option == 3:
opponent = input("Ingrese el id del oponente: ")
opponent = int(opponent)
size = int(input("Ingrese el tamaño N del tablero: "))
matrix_challenge = taquin.generate_matrix(size)
taquin.challenge(domain, matrix_challenge, size-1, size-1, opponent)
print("Reto enviado: ")
print(matrix_challenge)
option = int(input("1) Single player, 2) Resolver un reto (Multiplayer), 3) Retar a un jugador, -1) salir\n"))
def main():
numPlayers = -1
#test Ben
#sublime text can't work with stdin, so hardcoded it as a 2 player game while on sublime
while(True):
try:
response = raw_input('How many players do you want? ')
numPlayers = int(response)
except ValueError:
print "Please enter a number"
continue
if (numPlayers >= 0 and numPlayers <= 4):
break
else:
print "Please enter a number betweeen 0 and 4"
players = []
for i in range (0, numPlayers):
players.append(Player.player(i))
AiNum = -1
try:
response = raw_input("Add an Ai player?")
if response == "Yes" or response == "yes" or response == "y":
AiNum = len(players)
players.append(Ai.ai(AiNum))
numPlayers +=1
except EOFError:
print " Not building, on sublime"
if AiNum != -1 and numPlayers == 1:
numRuns = input('How many runs? ')
else:
numRuns = 1
if numRuns > 1:
stats = []
for x in xrange(numRuns):
numPlayers = 1
players = []
AiNum = len(players)
players.append(Ai.ai(AiNum))
board = Board.board()
devCardsDeck = Devcards.devcards()
#board.createBatchCSV(players)
#board.batchUpdate()
#print board.printBoard()
firstPlacement(numPlayers, players, board, AiNum)
stats.append(playMainGame(numPlayers, players, board, devCardsDeck, AiNum))
print stats
print "average turns (excluding robber) = ", sum(stats)/float(numRuns)
else:
board = Board.board()
devCardsDeck = Devcards.devcards()
board.createBatchCSV(players)
board.batchUpdate()
print board.printBoard()
firstPlacement(numPlayers, players, board, AiNum)
playMainGame(numPlayers, players, board, devCardsDeck, AiNum)
def test_if_game_has_finnished_by_user_winning(self):
b = Board(3)
p = {"andy": "X", "nick": "O"}
g = Game(b, p)
for i in range(3):
for j in range(3):
b.fill_position(i, j, "X")
self.assertTrue(g.is_game_finnished(), "game is not finnished")
def test_if_game_has_finnished_by_board_completion(self):
b = Board(3)
p = {"andy": "X", "nick": "O"}
g = Game(b, p)
for i in range(3):
for j in range(3):
b.fill_position(i, j, choice(ascii_uppercase))
self.assertTrue(g.is_game_finnished(), "game is not finnished")
def setup():
global board,players
win = GraphWin("Search", widthSize, heightSize)
win.setBackground("black")
player1 = Player(2, p1Color, p1Pos)
player2 = Player(3, p2Color, p2Pos)
players = [player1, player2]
board = Board(players)
board.drawGrid(win, "white")
board.drawPlayer(win, *p1Pos, player1)
board.drawPlayer(win, *p2Pos, player2)
while True:
pos = win.getMouse()
if win.checkKey():
break
pos = (pos.x//rectSize, pos.y//rectSize)
board.createObstacle(win, *pos)
board.drawGrid(win, "black")
executePlayer(win, board, players[0])
win.getMouse()
def __updateBoard(self, steps):
# Needs to be called before using updateHashkey so that hashkey can reinitialize itself
# Only needs to be reinitialized when not currently in a push
if not self.__nextMoveTypeStr(steps) == Step.Step.MUST_PUSH:
self.hash.initTempHashKey()
# The steps with any traps done.
final_steps = ""
for step in steps.split():
final_steps = final_steps + " " + step
step = Step.Step(step)
# The piece we are trying to move
piece = self.board[step.start_row][step.start_col]
# Update the hash for this position.
self.hash.updateHashKey(step.start_row, step.start_col, piece, " ")
# Delete the pieces starting position
if (step.start_row == 2 and step.start_col == 2) or \
(step.start_row == 2 and step.start_col == 5) or \
(step.start_row == 5 and step.start_col == 2) or \
(step.start_row == 5 and step.start_col == 5):
self.board[step.start_row][step.start_col] = "X"
else:
self.board[step.start_row][step.start_col] = " "
# Put this piece in its new place
self.board[step.end_row][step.end_col] = step.piece
trapped_piece = ""
# Is the piece in a trap square?
if not Board.isSafe(self.board, 2, 2):
trapped_piece = self.board[2][2] + "c6x"
self.board[2][2] = "X"
elif not Board.isSafe(self.board, 2, 5):
trapped_piece = self.board[2][5] + "f6x"
self.board[2][5] = "X"
elif not Board.isSafe(self.board, 5, 2):
trapped_piece = self.board[5][2] + "c3x"
self.board[5][2] = "X"
elif not Board.isSafe(self.board, 5, 5):
trapped_piece = self.board[5][5] + "f3x"
self.board[5][5] = "X"
piece = self.board[step.end_row][step.end_col]
self.hash.updateHashKey(step.end_row, step.end_col, " ", piece)
if trapped_piece != "":
final_steps = final_steps + " " + trapped_piece
return final_steps
def test_if_can_mark_in_out_of_bound_position(self):
b = Board(3)
p = {"andy": "X", "nick": "O"}
g = Game(b, p)
for i in range(3):
for j in range(3):
b.fill_position(i, j, "X")
self.assertFalse(b.can_mark(3, 3), "can mark in 3, 3")
self.assertFalse(b.can_mark(4, 4), "can mark in 4, 4")
self.assertFalse(b.can_mark(-1, -1), "can mark in -1, -1")
def test_feature_planes():
board = Board(5)
moves = [(0,0), (1,1), (2,2), (3,3), (4,4)]
play_color = Color.Black
for x,y in moves:
board.show()
feature_planes = make_feature_planes(board, play_color)
move_arr = make_move_arr(x, y)
show_feature_planes_and_move(feature_planes, move_arr)
print
board.play_stone(x, y, play_color)
play_color = flipped_color[play_color]
def __init__(self, size = 9):
"""Connect 4 game for a given size board."""
try:
Menu() #Display the menu as soon as the program is run
gman = GraphicsManager(size)
playertypenames = ['Player vs. Player','Player vs Computer', 'Computer vs Player','Computer vs. Computer'] #Different combinations of games to play in Connect4
playertypes = [HumanPlayer,ComputerPlayer] #Different types of players
wantstoplay = True
while wantstoplay:
gametype = gman.selectFromList(playertypenames)
#Depending on the user click, choose the type of game to play.
if gametype == 0:
players = [playertypes[gametype]('Red'),playertypes[gametype]('Blue')] #Player1 vs. Player2
if gametype == 1:
players = [playertypes[gametype-1]('Red'),playertypes[gametype]('Blue')] #Player vs. Computer (Player goes first)
if gametype == 2:
players = [playertypes[gametype-1]('Red'),playertypes[gametype-2]('Blue')] #Computer vs. Plyer (Computer goes first)
if gametype == 3:
players = [playertypes[gametype-2]('Red'),playertypes[gametype-2]('Blue')] #Computer vs. Computer
#Game Play
board = Board(size)
movesleft = (size-1)*(size-1) #Number of moves until board is full
gameOver = False
while not gameOver:
#Alternates turns among two players
for p in players:
(x,y) = p.drop(board,gman) #Get the player's move
winner = board.wouldMoveWin(x,y,p.getColor()) #Test for win
board.setSquare(x,y,p.getColor()) #Play the move
movesleft -= 1 #Subtract 1 every time a player makes a move
gman.displayMove(x,y,p.getColor())
#Exit the loop if either player has won, or if it is a draw
if winner or movesleft == 0:
gameOver = True
break
#Report the result of the game
if winner:
result = 'W I N N E R !'
gman.displayResult(result, p.getColor())
else:
result = "D R A W"
gman.displayResult(result, 'green')
except AttributeError:
print 'Congratulations to the Winner!'
class Game(object): def __init__(self, r_id): super(Game, self).__init__() self.roomId = r_id self.board = Board() # board for a game self.playerList = [] # player enlisted in game self.turn = 0 # player turn self.isStarted = False self.gameWinner = -1 def isGameStarted(self): return self.isStarted def startGame(self): # pre-condition: player signed to the game are more than 3 self.isStarted = True def endGame(self): self.isStarted = False def getWinner(self): return self.gameWinner def setWinner(self, _player): self.gameWinner = _player def getPlayerList(self): return self.playerList def addPlayerToGame(self, _player): self.playerList.append(_player) def deletePlayerFromGame(self, _player): self.playerList.remove(_player) def placePlayerPawn(self, x, y, _player): if self.board.isCellEmpty(x, y): self.board.placeBoard(x, y, _player.getPawn()) if self.board.fiveRows(x, y, _player.getPawn()): self.endGame() self.setWinner(_player.getPlayerId()) else: turn = (turn + 1) % len(playerList) return True else: return False def getTurn(self): return self.turn
def read(self, config_file):
config=open("ConfigFiles/"+config_file)
board=Board()
row=0
col=0
for line in config:
for item in line:
if item !="\n":
if item != ".":
board.setValue(row,col,int(item))
col+=1
row+=1
col=0
return board
def readSensors(boardAdr, s1, s2, cvals):
# parameters = {}
# parameters[boardAdr] = {"spec1": eeprom.realSensorData(boardAdr,1), "spec2": eeprom.realSensorData(boardAdr,2)}
# print parameters
# cvals = parameters#calibrate(boardAdr)
#print boardAdr, s1, s2, cvals
temperature, humidity, pressure = other_sensor()
board.call_pca(boardAdr)
time.sleep(0.4)
time.sleep(0.4)
time.sleep(0.4)
ads.get_ads_config0(0x70)
time.sleep(0.4)
#print "sensor 1"
val2 = float(conf_sensor1())
time.sleep(0.4)
ads.get_ads_config0(0x60)
time.sleep(0.4)
#print "sensor2"
val1 = float(conf_sensor2())
time.sleep(0.4)
time.sleep(0.39)
#print cvals
type1 = str(cvals[boardAdr]['spec1'][0])
type2 = str(cvals[boardAdr]['spec2'][0])
sensitivity1 = float(cvals[boardAdr]['spec1'][1])
sensitivity2 = float(cvals[boardAdr]['spec2'][1])
baseline1 = float(cvals[boardAdr]['spec1'][2])
baseline2 = float(cvals[boardAdr]['spec2'][2])
zero1 = float(cvals[boardAdr]['spec1'][3])
zero2 = float(cvals[boardAdr]['spec2'][3])
span1 = float(cvals[boardAdr]['spec1'][4])
span2 = float(cvals[boardAdr]['spec2'][4])
unit1 = cvals[boardAdr]['spec1'][5]
unit2 = cvals[boardAdr]['spec2'][5]
#print val1, val2
#con1 = transform(temperature, val1, sensitivity1, baseline1, zero1, span1, type1)
#con2 = transform(temperature, val2, sensitivity2, baseline2, zero2, span2, type2)
con1 = val1
con2 = val2
print str("Concentration " + str(type1)+ ":" + str(con1)+", " + "Concentration " + str(type2)+ ":" + str(con2))
#if boardAdr=='87':
dataline = {"temperature": temperature, "humidity": humidity, "pressure": pressure, "address": boardAdr, "typeSensor1": str(str(type1)+"("+str(boardAdr)+")"), "valueSensor1": val1, "concentrationSensor1": str(con1), "unit1": str(unit1), "typeSensor2":str(str(type2)+"("+str(boardAdr)+")"), "valueSensor2": val2, "unit2": str(unit2), "concentrationSensor2": str(con2)}
print dataline
return dataline
def __init__(self, *args, **kwargs):
if len(args) == 4:
#col, row, p1_symbol, p2_symbol
self.board = Board(args[0], args[1])
self._p1_symbol = args[2]
self._p2_symbol = args[3]
self.currentTurn = True
elif len(args) == 1:
#OthelloBoard
self.board = Board(args[0].board)
self._p1_symbol = args[0]._p1_symbol
self._p2_symbol = args[0]._p2_symbol
self.currentTurn = args[0].currentTurn
else:
sys.exit("OthelloBoard: Incorrect __init__ usage")
class TestValidationFunctions(unittest.TestCase):
def setUp(self):
self.board=Board()
#fill the board with values that will
#make for both valid and invalid situations
self.board.setValue(0,0,4)
self.board.setValue(0,1,5)
def test_horizontal1(self):
self.assertTrue(self.board.horizontal_validation(0,6))
def test_horizontal2(self):
self.assertFalse(self.board.horizontal_validation(0,4))
def main():
global FPSCLOCK, DISPLAYSURF, FONTOBJ
pygame.init() #initialize the game
FPSCLOCK = pygame.time.Clock()
DISPLAYSURF = pygame.display.set_mode((WINDOWWIDTH, WINDOWHEIGHT))
FONTOBJ = pygame.font.Font('freesansbold.ttf', 18)
pygame.display.set_caption('Tetrisss?')
#set up initial pieces
board = Board(DISPLAYSURF, FONTOBJ)
queue = Queue(DISPLAYSURF)
splashscreen = Splashscreen(DISPLAYSURF, FONTOBJ)
DISPLAYSURF.fill(WINDOWCOLOR)
start = False
lastEventTime = time.time()
lastDropTime = time.time()
soundOn = True
pygame.mixer.music.load('tetrisb.mid')
pygame.mixer.music.play(-1, 0.0)
while True: #main game loop
#speed up the game as you level up
fallspeed = generateSpeed(board.level)
listenForQuit()
soundOn = toggleSound(soundOn)
start = listenForStart(start)
if not start:
splashscreen.draw()
else:
board.checkGameState()
board.draw()
drawScorePanel(board)
drawInstructions()
if board.gameState == ACTIVE:
queue.draw()
#if its been longer than the fallspeed and the down key is not pressed, move the piece down
keystate = pygame.key.get_pressed()
if time.time() - lastDropTime > fallspeed and not keystate[K_DOWN]:
move(board, queue, DOWN)
lastDropTime = time.time()
lastEventTime = listenForKeyEvents(board,queue,lastEventTime)
#update screen
pygame.display.update()
FPSCLOCK.tick(FPS)
def setUp(self):
self.board=Board()
#fill the board with values that will
#make for both valid and invalid situations
self.board.setValue(0,0,4)
self.board.setValue(4,0,7)
self.board.setValue(0,1,5)
def __init__(self, screen, size, users, end):
self.screen = screen
self.size = size
self.winner = None
self.phase = None
self.width = size[0]
self.height = size[1]
self.board = Board(self.screen, (self.width/2, self.height/2), "Ground_War")
self.bars = []
self.buttons = []
self.board_drag = False
self.deploy = None
self.users = users
self.doors = None
self.end = end
self.teams = []
for u in self.users:
self.teams.append(Ground_Team(u))
self.active_team = self.teams[0]
self.dormant_teams = []
for t in self.teams:
if(t != self.active_team):
t.dormant()
self.dormant_teams.append(t)
t.LKBP = self.board.pos
self.active_team.active()
self.bars.append(Acc_Bar(self.screen, (self.width - 150, self.height - 75), self.active_team.user))
def __init__(self, player): self.board = Board() self.curMino = choice(Tetrominoes.minoes) self.linesCleared = 0 self.streak = 0 self.player = player gameOver = False
def __init__(self, player):
self.board = Board()
self.player = player
sig = Image.open("sig.png")
sig = ImageOps.grayscale(sig)
sigp = sig.load()
n = []
for i in range(sig.size[0]):
n.append(sigp[i, 0])
# Assinatura em formato de string
n = ' '.join(map(str, n))
raw_input("Posicione a janela e pressione enter para comecar...")
sleep(2)
scp = self.screenCapture()
w = scp[1]
h = scp[2]
scp = scp[0]
for j in range(h):
cl = []
for i in range(w):
cl.append(scp[i, j])
h = ' '.join(map(str, cl))
m = h.find(n)
if m >= 0:
m = len(h[0:m].split(" "))
print "Signature found on %d, %d" % (m, j)
#self.offset = (m, j-18)
self.offset = (m+1, j+4)
break
def __hasPiecesFrozen(self, board, row, col, piece):
value = 0
piecesFrozen = 0
# Generate all the occupied adjacent positions.
adj_occ_pos = Board.getAdjacentPositions(board, row, col, True)
for pos in adj_occ_pos:
adj_row = pos[0]
adj_col = pos[1]
adj_piece = board[adj_row][adj_col]
# Make sure you're not looking at piece that
# you're friends with.
if not Piece.areFriends(piece, adj_piece):
# If you're stronger than the adjacent piece,
# then you've frozen it.
if Piece.isStronger(piece, adj_piece):
piecesFrozen = piecesFrozen + 1
# Return a value now based on the number of pieces frozen.
# If it has too many pieces frozen, then it has potential
# to being trapped. So it needs to be careful.
if piecesFrozen == 1:
value = 100
elif piecesFrozen == 2:
value = 1000
elif piecesFrozen == 3:
value = -100
if piecesFrozen == 4:
value = -1000
return value
def __init__(self, screen, size, users, end):
self.screen = screen
self.size = size
self.users = users
self.teamA = Strat_Team(users[0])
self.teamB = Strat_Team(users[1])
self.active_team = self.teamA
self.dormant_team = self.teamB
self.winner = None
self.phase = None
self.width = size[0]
self.height = size[1]
self.board = Board(self.screen, (self.width/2, self.height/2), "Stratego")
self.bars = []
self.buttons = []
self.doors = None
self.end = end
'''self.teamB.troops.append(Strat_Piece(screen, 11, (9,9)))
self.teamB.troops.append(Strat_Piece(screen, 0, (8,9)))'''
self.active_team.active()
self.dormant_team.dormant()
self.bars.append(Acc_Bar(self.screen, (self.width - 150, self.height - 75), self.active_team.user))
def Draw(self):
self.board, bonus = Board().check_filled_rows(self.board)
self.score += bonus
#self.timer = pygame.time.Clock()
self.scoreLabel = self.screen.blit(self.scoreImage, (60, self.res[1]-60))
self.font_size = 48
self.font = pygame.font.SysFont("arial", self.font_size)
self.w, self.h = self.font.size(str(self.score))
self.font_image = self.font.render(str(self.score), 1, (255, 255, 255))
self.screen.blit(self.font_image, (200, self.res[1]-65))
#print(self.block.shape, self.block.x, self.block.y)
print("NSHAPE: ", self.block.nshape, self.block.nx, self.block.ny)
self.draw_next_block(self.block.nshape)
# check collision
if not self.endgame:
if self.defs.check_collision(self.board, self.block.shape, (self.block.x, self.block.y)):
self.set_block(self.board, self.block.shape, (self.block.prevX, self.block.prevY))
# if collides => make a new block
self.block.new_block()
print("collision!")
if self.defs.check_collision(self.board, self.block.shape, (self.block.x, self.block.y)):
print("endgame!")
self.endgame = True
else:
# draw a block
if not self.endgame:
self.draw_matrix(self.block.shape, (self.block.x, self.block.y))
# draw a board
self.draw_matrix(self.board, (0,0))
def initialize(intext):
# Create a board with the specified size
size = intext.readline().rstrip()
board = Board.Board(int(size))
# Remove whitespace and pick up, create only ships with valid orientations
ships = intext.readline().replace(" ", "").rstrip()
list_of_ships = re.findall("\([0-9]+,[0-9]+,[NESW]\)", ships)
# The create_Ship() method is written to forbid the creation of superimposed Ship objects.
for cotup in list_of_ships:
board.create_Ship(cotup)
return board
def minimax_h2(d,board,flag):
out = Board.createObject()
inp = Board.createObject()
if(d==0):
white_count = 0
black_count = 0
total_count = 0
count = 0
for position in range(0,len(board)):
if(board[position]=="W"):
white_count+=1
if(board[position]=="B"):
black_count+=1
total_count = white_count-black_count
for i in range(0,len(board)):
if(board[i]=="x"):
if(Board.forms_mill(i,board,"W")==True):
count+=1
l = Board.generate_moves_midgameEndgame_black(board)
listsize = len(l)
if(black_count<=2):
out.value = 10000
elif(white_count<=2):
out.value = -10000
elif(listsize==0):
out.value = 10000
else:
out.value = 1000*(total_count+count)-listsize
out.stateCount = out.stateCount+1
return out
listofMoves = list()
if(flag==1):
listofMoves = Board.generate_moves_midgameEndgame(board)
out.value = minimum
else:
listofMoves = Board.generate_moves_midgameEndgame_black(board)
out.value = maximum
for b in listofMoves:
if(flag==1):
inp = minimax_h2(d-1,b,0)
if(inp.value> out.value):
out.value = inp.value
out.boardState = b
out.stateCount = out.stateCount + inp.stateCount
else:
inp = minimax_h2(d-1,b,1)
if(inp.value< out.value):
out.value = inp.value
out.boardState = b
out.stateCount = out.stateCount + inp.stateCount
return out
def main(order):
size = order * order
board = Board.Board(order)
stop_after_n_failures = 50
failures = 0
successes = 0
clues = []
while not board.is_done() and failures < stop_after_n_failures:
r, c = random.randint(1, size), random.randint(1, size)
vs = board.get_cell(r, c)
if len(vs) > 1:
ix = random.randrange(1, len(vs))
try:
clue = (r, c, list(vs)[ix])
board.set_cell(*clue)
failures = 0
successes = successes + 1
clues.append(clue)
except Exception as e:
failures = failures + 1
print e
else:
failures = failures + 1
board.show()
print
print "solved with %d clues" % successes
print
board_with_clues_only = Board.Board(order)
for c in clues:
board_with_clues_only.set_cell_without_update(*c)
board_with_clues_only.show()
class DummyController:
board = None
curMino = None
linesCleared = None
gameOver = None
player = None
streak = None
def __init__(self, player):
self.board = Board()
self.curMino = choice(Tetrominoes.minoes)
self.linesCleared = 0
self.streak = 0
self.player = player
gameOver = False
def tick(self):
self.player.makeMove(self)
def getMino(self):
return Mino(self.curMino)
def getBoard(self):
return Board(self.board)
def makeMove(self, move):
mino = Mino(self.curMino)
for i in range(move[1]):
mino.rotate()
newBoard = self.board.placeMino(mino, move[0])
if newBoard:
self.board = newBoard
else:
print
"Controller: invalid move received"
raise
clearedLines = self.board.clearAndReturnLines()
if clearedLines == 0:
self.streak = 0
else:
self.streak += clearedLines
self.linesCleared += clearedLines
self.curMino = choice(Tetrominoes.minoes)
def gameIsOver(self):
self.gameOver = True
def addLines(self, num):
self.board.addLines(num)
def draw(self):
self.board.draw()
def __init__(self, init_board=Board(False, 0), name="2048"):
'''
Initializer method that creates the MDP and assigns the other fields
according to the 2048 game.
'''
self.step_cost = 0.0
self.gamma = 0.99
self.name = name
self.current_state = TFEState((init_board.addTile()).addTile().board)
# Initializing the actual Markov Decision Process:
MDP.__init__(tfeMDP.ACTIONS, self._transition_func, self._reward_func,
init_state=TFEState(
(init_board.addTile()).addTile().board),
gamma=gamma)
def rook(f, t, board):
f_column = f[0]
f_row = f[1]
t_column = t[0]
t_row = t[1]
current_color = Board.get_peice_color(board, f)
if (f_column == t_column and f_row != t_row) \
or (f_column != t_column and f_row == t_row):
return True
if f_column > t_column and f_row == t_row:
for x in range(1, abs(f_column - f_column)):
if Board.get_peice(board, (f_column - x, f_row)) > -1:
return False
elif f_column < t_column and f_row == t_row:
for x in range(1, abs(f_column - f_column)):
if Board.get_peice(board, (f_column + x, f_row)) > -1:
return False
elif f_column == t_column and f_row > t_row:
for x in range(1, abs(f_row - f_row)):
if Board.get_peice(board, (f_column, f_row - x)) > -1:
return False
elif f_column == t_column and f_row < t_row:
for x in range(1, abs(f_row - f_row)):
if Board.get_peice(board, (f_column, f_row + x)) > -1:
return False
# FIX castling
return False
def startGame(self):
req = requests.get(self.url, params=self.startPayload)
response = json.loads(req.text)
self.board = Board.Board()
self.board.setSession(response['session'])
self.board.setPlayerNumber(response['player_num'])
self.board.setCpuNumber(2)
if (self.board.getPlayerNumber() == 2):
self.board.setCpuNumber(1)
self.board.setPosition(
(response['cpu_move'][0], response['cpu_move'][1]),
self.board.getCpuNumber())
self.board.showBoard()
def __init__(self, root):
a = 60
b = 80
l = 50
self.choose = False
self.choosed_chess = False
self.xing_qi = True
self.root = root
self.Board = Board.Board(root, a, b, l)
self.front_display()
self.Board.canvas.bind('<Button-1>', self.move)
self.che_record = Record.CHE_Record(self.Board)
self.log_record = Record.FEN_Record()
self.fen = ''
def new_game(sender_username, client, command):
message = 'Gre zainicjowal ' + sender_username + ': \n'
receiver = command[1]
message += Board.printBoard(find_board(sender_username))
receiver_is_logged_in = False
for user_tuple in logged_in_users:
if user_tuple[0] == receiver or user_tuple[0] == sender_username:
#user_tuple[1].sendall(message)
send_to_client(user_tuple[1], str(message), "\r\n\r\n")
receiver_is_logged_in = True
if not receiver_is_logged_in:
#client.sendall(receiver + ' nie jest obecnie zalogowany ')
send_to_client(client, str(receiver) + ' nie jest obecnie zalogowany ', "\r\n\r\n")
def test_Highest_Score__Single_Disk_No_Explosions(score, max_score):
"""Function highest_score: Single disk, no explosions."""
max_score.value += 4
try:
set_up()
test_board_4_copy = Board.get_board_copy(test_board_4)
highest_score, columns = Drop7.highest_score(test_board_4,
[visible_disk_value_4])
assert highest_score == 0
assert columns == [1]
assert are_identical_boards(test_board_4, test_board_4_alias)
assert are_equal_boards(test_board_4, test_board_4_copy)
score.value += 4
except:
pass
def test_is_positionning_possible(self):
b_test = Board.Board(4)
ship_test = Ship.Ship(b_test, 3)
assert b_test.is_positionning_possible(ship_test)
b_test.array_occupied = numpy.ones((4, 4), dtype=int)
b_test.array_occupied[0][3] = 0
b_test.array_occupied[2][3] = 0
assert not b_test.is_positionning_possible(ship_test)
b_test.array_occupied[1][3] = 0
assert b_test.is_positionning_possible(ship_test)
ship_test.forbidden_position.append((0, 3))
assert not b_test.is_positionning_possible(ship_test)
def start_game(self):
try:
rows = int(input("Enter number of rows: "))
columns = int(input("Enter number of columns: "))
except ValueError:
print("[ERROR] Try again")
return None
if rows < 3 or columns < 3:
print("[ERROR] Try again")
return None
table = Board(rows, columns)
game = Game(table)
printtable = True
while True:
if printtable:
print(game)
else:
printtable = True
try:
row = int(input("row >> "))
column = int(input("column >> "))
except ValueError:
print("[ERROR] Invalid input!")
printtable = False
continue
try:
game.move(row, column)
except ValueError as e:
print(e)
printtable = False
continue
if game.game_end():
print("You WIN!")
return
game.move_computer()
if game.game_end():
print(game)
print("Computer wins, you lose!")
return
def buildBoard(agentLocations: list, opponentLocations: list):
newBoard = Board()
for location in agentLocations:
newBoard.putPiece(location, 0)
for location in opponentLocations:
newBoard.putPiece(location, 1)
return newBoard
def main():
pg.init()
allgroups = pg.sprite.LayeredUpdates()
boardGroup = pg.sprite.Group()
pawn_groups = pg.sprite.Group()
screen = pg.display.set_mode((WIDTH, HEIGHT), 0, 32)
for i in range(0, 9):
whitePawn = pawn.WhitePawn(pg.mouse.get_pos(), [30 * (i + 1), 290],
allgroups, pawn_groups)
for i in range(0, 10):
WhitePawn = pawn.WhitePawn(pg.mouse.get_pos(),
[(30 * (i + 1)) - 15, 260], allgroups,
pawn_groups)
for i in range(0, 9):
blackPawn = pawn.BlackPawn(pg.mouse.get_pos(), [30 * (i + 1), 50],
allgroups, pawn_groups)
for i in range(0, 10):
blackPawn = pawn.BlackPawn(pg.mouse.get_pos(),
[(30 * (i + 1)) - 15, 20], allgroups,
pawn_groups)
gameboard = Board(allgroups, boardGroup)
clock = pg.time.Clock()
running = True
while running:
screen.fill((100, 100, 100))
time = clock.tick() / 1000.0
for event in pg.event.get():
if event.type == pg.QUIT:
running = False
if event.type == pg.KEYDOWN:
if event.key == pg.K_ESCAPE:
running = False
allgroups.update(time)
allgroups.draw(screen)
pg.display.flip()
def battle(p1: Player, p2: Player, num_games=10000, show=True):
"""
Fully plays `num_games` (new) games between agent `p1` and agent `p2`
NOTE : if you directly put `battle(NewPlayer1(), NewPlayer2())`,
those players can no longer be accessed later,
so what they have learned will be lost after the battle !
"""
# Initializing the board
board = Board()
# Let's count the number of wins/draws
draw_count = 0
cross_count = 0
naught_count = 0
# For the duration of computation
t0 = time()
for _ in range(num_games):
result = play_game(board, p1, p2)
if result == GameResult.CROSS_WIN:
cross_count += 1
elif result == GameResult.NAUGHT_WIN:
naught_count += 1
else:
draw_count += 1
if show:
print()
print("Computation time : {}s\n".format(time() - t0))
print("First player : {}".format(p1.name()))
print("Second player : {}".format(p2.name()))
print(
"After {} game we have : \ncross wins: {}, naught wins: {}, draws: {}"
.format(num_games, cross_count, naught_count, draw_count))
print(
"Which gives percentages of : \ncross wins: {:.2%}, naught wins: {:.2%}, draws : {:.2%}"
.format(cross_count / num_games, naught_count / num_games,
draw_count / num_games))
else:
return (cross_count / num_games, naught_count / num_games,
draw_count / num_games)
def test_en_passant_2():
board = Board.Board()
# Kings are needed for check testing when calling valid_moves
wk = Piece.King([7, 7], "w")
bk = Piece.King([0, 7], "b")
board.add_piece(wk)
board.add_piece(bk)
wp = Piece.Pawn([2, 1], "w")
bp = Piece.Pawn([3, 3], "b")
board.add_piece(wp)
board.add_piece(bp)
wp.move([2, 3], board)
wp.clear_passant() # Clear en passant flag so it can't be taken that way
assert not [2, 2] in bp.valid_moves(board)
def test_Get_All_Positions_To_Explode__No_Disks_To_Explode(score, max_score):
"""Function mark_all_positions_to_explode: no disks to explode."""
max_score.value += 4
try:
board = Board.init_board \
(dimension=6, given_disks= \
((Disk.init_disk(Disk.WRAPPED,3),),
[Disk.init_disk(Disk.WRAPPED,3), Disk.init_disk(Disk.WRAPPED, 2)],
(Disk.init_disk(Disk.VISIBLE,5), Disk.init_disk(Disk.VISIBLE, 4), Disk.init_disk(Disk.WRAPPED, 1)),
(Disk.init_disk(Disk.VISIBLE, 1), Disk.init_disk(Disk.CRACKED, 1), Disk.init_disk(Disk.VISIBLE, 3), Disk.init_disk(Disk.VISIBLE, 3)),
([]),
[Disk.init_disk(Disk.WRAPPED,3), Disk.init_disk(Disk.VISIBLE, 3)]))
assert Board.get_all_positions_to_explode(board) == frozenset()
score.value += 4
except:
pass
def hit(self, board: Board, x, y, z):
if (self.floating == False):
return "Destroyer" + str(self.id) + " ALREADY SUNK"
if ((x, y, z) in self.hitted):
return "Destroyer" + str(self.id) + " hitted there already"
self.hitted.append((x, y, z))
if (sorted(self.hitted) != sorted(self.coordinates)):
return "Destroyer" + str(self.id) + " hit"
self.floating = False
board.Destroyer = board.Destroyer - 1
return "Destroyer" + str(self.id) + " SUNK"
def test_occupy_area(self):
b_test = Board.Board(4)
ship = Ship.Ship(b_test, 3)
ship.position = [(1, 0), (1, 1), (1, 2)]
b_test.occupy_area(ship.position)
assert not numpy.sum(ship.board.array_occupied > 1)
ship2 = Ship.Ship(b_test, 3)
ship2.position = [(1, 2), (1, 3)]
b_test.occupy_area(ship2.position)
assert numpy.sum(ship.board.array_occupied == 2) == 9
ship2.remove_ship()
assert not numpy.sum(ship.board.array_occupied > 1)
def init_board(self):
self.canvas = tk.Canvas(self, height=canvas_size, width=canvas_size, background='#c98003')
for x in range(size):
self.canvas.create_line(30 + x*30, 30, 30 + x*30, canvas_size-30)
for y in range(size):
self.canvas.create_line(30, 30 + y*30, canvas_size-30, 30 + y*30)
r = 2
for x in range(3, size, 6):
for y in range(3, size, 6):
self.canvas.create_oval(30 + x*30-r, 30 + y*30-r, 30 + x*30+r, 30 + y*30+r, fill='black')
self.board = Board(size)
if self.human == 2:
self.doMove([size//2, size//2])
self.canvas.bind('<Button-1>', self.getXY)
self.canvas.pack()
def main():
goalBoard = Board.Board([[1, 2, 3], [4, 5, 6], [7, 8, 0]])
# test case for uninformed expansion
board1 = Board.Board([[1, 3, 5], [4, 2, 6], [7, 8, 0]])
frontier = []
Node1 = Node.Node(board1, None, 0, 0)
uninformedExpansion(Node1, frontier, goalBoard)
assert Node.Node(board1.slideBlank((-1, 0)), Node1, 0, 0) in frontier
assert Node.Node(board1.slideBlank((0, -1)), Node1, 0, 0) in frontier
assert Node.Node(board1.slideBlank((1, 0)), Node1, 0, 0) not in frontier
assert Node.Node(board1.slideBlank((0, 1)), Node1, 0, 0) not in frontier
# test case for informed expansion
Node1 = Node.Node(board1, None, 0, 0)
board1_1 = board1.slideBlank((-1, 0))
Node2 = Node.Node(board1_1, Node1, 0, 1)
frontier = [Node2]
explored = set([Node1])
uniformCostExpansion(Node2, frontier, goalBoard, explored)
assert Node.Node(board1_1.slideBlank((-1, 0)), Node2, 0, 0) in frontier
assert Node.Node(board1_1.slideBlank((1, 0)), Node2, 0, 0) not in frontier
# test case for BFS
start_time1 = time.time()
board1 = Board.Board([[1, 3, 5], [4, 2, 6], [7, 8, 0]])
board1_result = uninformedClient(board1, 5000, goalBoard, False)
assert board1_result is not None
assert type(board1_result) is Node.Node
assert board1_result.depth == 6
# test case for UCS
board2 = Board.Board([[1, 3, 6], [5, 7, 2], [0, 4, 8]])
board2_result = fastSearchClient(
board2, 1000, Board.Board([[1, 2, 3], [4, 5, 6], [7, 8, 0]]), False)
assert board2_result is not None
assert type(board2_result) is Node.Node
assert board2_result.depth == 10
# test case for A*
board3 = Board.Board([[7, 3, 0], [1, 2, 6], [8, 4, 5]])
board3_result = fastSearchClient(
board3, 1000, Board.Board([[1, 2, 3], [4, 5, 6], [7, 8, 0]]), True)
assert board3_result is not None
assert type(board3_result) is Node.Node
assert board3_result.depth == 20
print("\n--- %s seconds ---\n\n" % (time.time() - start_time1))
def static_estimation_function(board):
white_count = 0
black_count = 0
total_count = 0
count = 0
for position in range(0, len(board)):
if (board[position] == "W"):
white_count += 1
if (board[position] == "B"):
black_count += 1
total_count = white_count - black_count
for i in range(0, len(board)):
if (board[i] == "x"):
if (Board.forms_mill(i, board, "W") == True):
count += 1
return total_count + count
def play_game():
"""
Play the game.
"""
the_board = Board.make_board(5)
score = 0
current_block = Block.select_standard_block()
print("Score: ", score)
print()
print("Next block to drop:")
Block.print_block(current_block)
print()
Board.print_board(the_board)
print()
while len(Board.get_droppable_positions(the_board, current_block)) > 0:
position = input("Enter the position to drop the block: ")
if position == "":
position = \
random.choice(Board.get_droppable_positions(the_board, current_block))
print(" Using position: ", position[0], ",", position[1])
else:
position = eval(position)
if not isinstance(position, tuple):
print("Not a valid position")
continue
if not Board.can_be_dropped_at(the_board, current_block, position):
print("Block cannot be dropped at the given position")
continue
score += game_move(the_board, current_block, position)
current_block = Block.select_standard_block()
print("Score: ", score)
print()
print("Next block to drop:")
Block.print_block(current_block)
print()
Board.print_board(the_board)
print()
print("End of game!")
print(" Final score: ", score)
def explore_tree(board: Board, path: List[Piece], position,
remaining_pieces: List[Piece]):
global max_len
if len(path) > max_len:
board.print()
print()
board.print_numbers()
print(len(path))
print("\n" * 5)
max_len = len(path)
next_position, pieces_that_fit = explore(board, position, remaining_pieces)
for piece in pieces_that_fit:
board.place(piece, piece.position)
remaining_now = remove(remaining_pieces, piece)
explore_tree(board, path + [piece], next_position, remaining_now)
board.free(position)
def __init__(self):
pygame.init()
self.resolution = (1280, 960)
self.fps_clock = pygame.time.Clock()
self.screen = pygame.display.set_mode(self.resolution,
pygame.DOUBLEBUF)
self.title = "Get To An Exit!"
self.desired_frame_rate = 60
self.currentMousePos = None
self.mouseIsDown = False
self.mouseJustWentDown = False
self.mouseJustWentUp = False
pygame.display.set_caption(self.title)
self.timer_tick_period = 10
self.spawn_new_piece_time = 1000 # Time (ms) before a new piece is spawned.
self.last_spawn_new_piece_time = pygame.time.get_ticks()
self.road = collections.namedtuple('road', 'filename exits')
self.roads = [
self.road(os.path.join("resources", "straight.png"), 'NS'),
self.road(os.path.join("resources", "turnLeft.png"), 'SW'),
self.road(os.path.join("resources", "turnRight.png"), 'SE'),
self.road(os.path.join("resources", "teeJunction.png"), 'SEW'),
self.road(os.path.join("resources", "crossJunction.png"), 'NEWS'),
self.road(os.path.join("resources", "culDeSac.png"), 'S')
]
self.objects_to_draw = pygame.sprite.LayeredUpdates()
self.beingDraggedPiece = None
self.beingDraggedIndex = -1
self.available_pieces = AvailablePieces.AvailablePieces(self)
board_ypos = (
int(self.available_pieces.rect.height / RoadPiece.RoadPiece.size) +
1
) * RoadPiece.RoadPiece.size # Ensure is a multiple of 32, and further down than available pieces.
self.board = Board.Board(
self,
[ # Bounds of the board are everything but the available pieces area.
0, # Left
board_ypos, # Top
self.resolution[0], # Width
self.resolution[1] - board_ypos
]) # Height
# Create timer tick.
pygame.time.set_timer(Game.TIMER_TICK, self.timer_tick_period)
def test_Get_Top_Moves__Minimal_Score_Out_Of_Reach(score, max_score):
"""Function get_top_moves: minimal score is out of reach in given number of steps."""
max_score.value += 18
try:
the_board = Board.make_board((8, 10))
block1_1 = Block.make_block(3, color=Color.MAGENTA)
block1_2 = Block.make_block(2, color=Color.MAGENTA)
block1_3 = Block.make_block(1, color=Color.MAGENTA)
block1_4 = Block.make_block(1, color=Color.RED)
block2_1 = Block.make_block(4, Block.FRAGILE, color=Color.GREEN)
block2_2 = Block.make_block(3, color=Color.GREEN)
block3_1 = Block.make_block(3, Block.ELECTRIFIED, color=Color.BLUE)
block3_2 = Block.make_block(1, color=Color.BLUE)
block3_3 = Block.make_block(2, Block.ELECTRIFIED, color=Color.BLUE)
block3_4 = Block.make_block(1, color=Color.YELLOW)
block4_1 = Block.make_block(2, color=Color.RED)
block4_2 = Block.make_block(3, color=Color.RED)
block4_3 = Block.make_block(2, color=Color.GREEN)
blocks_to_fill = \
[[(("a", 1), block1_1), (("a", 5), block1_2), (("a", 8), block1_3), (("a", 10), block1_4)],
[(("a", 1), block2_1), (("a", 7), block2_2)],
[(("a", 3), block3_1), (("a", 6), block3_2), (("a", 7), block3_3), (("a", 10), block3_4)],
[(("a", 1), block4_1), (("a", 4), block4_2), (("a", 9), block4_3)]
]
# Moving block1_1 one step to the right results in a full row after the second rwo
# has been added. The second move cannot result in an additional score.
# If a third move would be possible, a score of 32 would be possible.
best_moves = Game.get_top_moves(the_board, blocks_to_fill, min_score=15, max_nb_moves=2)
if best_moves is not None:
raise Exception
best_moves = Game.get_top_moves(the_board, blocks_to_fill, min_score=32, max_nb_moves=3)
# if best_moves != [(("a",1), block1_1, 1),
# (("a",3), Block.make_block(2, Block.FRAGILE, Color.GREEN), 2),
# (("b",8), block1_3, 1)]:
# raise Exception
# Check above changed because some students introduce a unique id for each block.
if len(best_moves) != 3:
raise Exception
if best_moves[0] != (("a",1), block1_1, 1):
raise Exception
if (best_moves[1][0] != ("a",3)) or (best_moves[1][2] != 2):
raise Exception
if best_moves[2] != (("b",8), block1_3, 1):
raise Exception
score.value += 18
except:
pass
def __init__(self, num_players, size):
self.num_players = num_players
self.game_board = Board.Board(size)
self.turn_count = 0
self.size = size
self.game_over = False
self.players = []
self.times = []
for i in range(num_players):
self.times.append([])
# graphic settings
pygame.init()
# Where your .py file is located
current_path = os.path.dirname(__file__)
# The image folder path
image_path = os.path.join(current_path, 'assets')
self.SCREEN_WIDTH = int((size)*50)
self.SCREEN_HEIGHT = int((size)*50)
self.BLACK = (0, 0, 0)
self.all_sprite_list = pygame.sprite.Group()
self.all_walls_list = []
self.screen = pygame.display.set_mode(
[self.SCREEN_WIDTH, self.SCREEN_HEIGHT])
self.background = pygame.image.load(
os.path.join(image_path, 'board.png'))
self.background = pygame.transform.scale(
self.background, (self.SCREEN_WIDTH, self.SCREEN_HEIGHT))
self.Game_Over_background = pygame.image.load(
os.path.join(image_path, 'gameover.png'))
self.Game_Over_background = pygame.transform.scale(
self.Game_Over_background, (self.SCREEN_WIDTH, self.SCREEN_HEIGHT))
# player instance
names = ['red', 'blue', 'yellow', 'green']
images = [pygame.image.load(os.path.join(image_path, 'red.png')), pygame.image.load(os.path.join(image_path, 'blue.png')),
pygame.image.load(os.path.join(image_path, 'yellow.png')), pygame.image.load(os.path.join(image_path, 'green.png'))]
xpos = [int(size/2), int(size/2), 0, size-1]
ypos = [0, size-1, int(size/2), int(size/2)]
for i in range(num_players):
goal = self.get_goal(i)
self.players.append(Player.Player(
names[i], images[i], xpos[i], ypos[i], goal))
self.all_sprite_list = pygame.sprite.Group()
# first draw_screen:
self.draw_screen()
def __init__(self,
gameType=1,
rows=20,
cols=20,
density=0.2,
file="",
items=0,
eTups=list()):
self.gameType = gameType
self.rows = rows
self.cols = cols
self.density = density
self.collisions = 0
self.movesMade = 0
self.board = Board.Board(self.rows, self.cols)
self.carrying = False
self.totalItems = items
self.itemsRetrieved = 0
self.enemyList = list()
self.enemyCollisions = 0
if file != "":
self.enemyList = self.board.readBoard(file)
self.cols = self.board.col
self.rows = self.board.row
self.totalItems = self.board.totalItems
else:
self.board.buildBoard(bType=self.gameType,
density=density,
items=items)
if gameType == 3:
for i in range(len(eTups)):
tact = eTups[i][0]
start = eTups[i][1]
if len(eTups[i]) > 2:
moves = eTups[2]
en = Enemy.Enemy(self.board,
startRow=start[0],
startCol=start[1],
tactic=tact,
squares=moves)
self.board.updateSpace(start[0], start[1], 5)
self.enemyList.append(en)
self.currentRow, self.currentCol = self.board.getStart()
def run():
global path
for i in range(lenB):
for j in range(lenB):
if (field[i][j] > 0):
Board.render_block(
(i, j), "gray" +
str(100 - field[i][j])) #send gradient color information
time.sleep(0.01)
Board.render_block(finishB, "red") #mark the end point
Board.render_path(path)
def test_findForces(self): test1 = Board() pairs = [] self.assertEqual(test1.findForces(1),pairs) test1.b = self.twoMoveBoard pairs = [[[0,0,0],[0,0,2]]] self.assertEqual(test1.findForces(1),pairs) test1.b = self.fourMoveBoard pairs = [] self.assertEqual(test1.findForces(1),pairs) self.assertEqual(test1.findForces(2),pairs) test1.b = self.forcingBoard pairs = [[[i,j,0],[i,j,2]] for i in range(4) for j in range(4)] pairs += [[[i,0,0],[i,2,2]] for i in range(4)] pairs += [[[i,1,2],[i,3,0]] for i in range(4)] pairs += [[[0,i,0],[2,i,2]] for i in range(4)] pairs += [[[1,i,2],[3,i,0]] for i in range(4)] pairs += [[[0,0,0],[2,2,2]],[[1,1,2],[3,3,0]],[[0,3,0],[2,1,2]],[[3,0,0],[1,2,2]]] self.assertEqual(test1.findForces(1),pairs)
