def SudokuFileReader(filePath):
"""Read from input file and generate gameboard."""
with open(filePath) as f:
lines = f.readlines()
if len(lines) == 0:
raise ValueError("Input file \"" + filePath + "\" was empty")
elif len(lines) < int(lines[0].split()[0]) + 1:
raise ValueError("Incomplete or Emtpy board for file \""
+ filePath + "\".Please be advised.")
else:
board = []
for i in range(len(lines)):
if i == 0:
checkGameBoardParameters(lines[i])
N = int(lines[i].split()[0])
p = int(lines[i].split()[1])
q = int(lines[i].split()[2])
else:
tempLine = []
for n in lines[i].split():
# print(num)
# print(type(num)
tempLine.append(ODOMETERTOINT[n])
board.append(tempLine)
return gameboard.GameBoard(N, p, q, board)
def ReadFile(filePath):
"""Read from input file and generate gameboard."""
with open(filePath, 'r') as f:
lines = f.readlines()
if len(lines) == 0:
raise ValueError("Input file " + filePath + " was empty")
elif len(lines) < int(lines[0].split()[0]) + 1:
raise ValueError("Incomplete or Emtpy board for file " + filePath)
else:
board = []
for i in range(len(lines)):
if i == 0:
if len(lines[0].split()) != 3:
raise ValueError("Params invalid in file.")
N = int(lines[i].split()[0])
p = int(lines[i].split()[1])
q = int(lines[i].split()[2])
else:
tempLine = []
for n in lines[i].split():
# print(num)
# print(type(num)
tempLine.append(int(n))
board.append(tempLine)
return gameboard.GameBoard(N, p, q, board)
def generateRandomBoard(moves=2):
board = gameboard.GameBoard()
for i in xrange(moves):
x, y = choice(board.possibleMoves())
player = gameboard.GameBoard.O if i % 2 else gameboard.GameBoard.X
board.addMove(player, x, y)
return board
def _doEndOfGame(trace, player):
final_board = gameboard.GameBoard(trace[-1])
features = final_board.getFeatures(player)
if final_board.isDraw():
return (features, 0)
elif final_board.hasWon(player):
return (features, 100)
return (features, -100)
def __init__(self):
self.window_w = 400
self.window_h = 500
self.window = pygame.display.set_mode((self.window_w, self.window_h))
self.num_rows = 9
self.num_cols = 9
self.num_mines = 10
self.game_board = gameboard.GameBoard(self.num_rows, self.num_cols,
self.num_mines)
self.game_board_x = 25
self.game_board_y = 125
self.game_board_w = 350
self.game_board_h = 350
self.tile_w = self.game_board_w // self.num_cols
self.tile_h = self.game_board_h // self.num_rows
self.screen = "main_menu_screen"
self.difficulty = "easy"
self.openWindow = True
self.firstTurn = True
"""
dictionary of predefined colors
"""
self.colors = {
"white": (255, 255, 255),
"black": (0, 0, 0),
"gray1": (200, 200, 200),
"gray2": (175, 175, 175),
"blue1": (0, 0, 215),
"blue2": (0, 0, 255),
"blue3": (0, 0, 235),
"red1": (215, 0, 0),
"red2": (255, 0, 0),
"red3": (235, 0, 0),
"green1": (0, 135, 0),
"green2": (0, 175, 0),
"green3": (0, 155, 0)
}
"""
dictionary of button objects from the Button class
"""
self.buttons = {
"start": button.Button(100, "Start"),
"help": button.Button(175, "Help"),
"settings": button.Button(250, "Settings"),
"high_scores": button.Button(325, "High Scores"),
"help_back": button.Button(400, "Back"),
"settings_back": button.Button(400, "Back"),
"high_scores_back": button.Button(400, "Back"),
"easy": button.Button(100, "Easy"),
"medium": button.Button(175, "Medium"),
"hard": button.Button(250, "Hard"),
"play-again": button.Button(215, "Play Again")
}
def main():
game_board = gameboard.GameBoard()
def init():
game_board.reset()
# initcursor=game_board.move()
# initcursor.init_cursor()
return 'Game'
def not_game(state):
game_board.draw()
action = useraction.get_user_action()
response = defaultdict(lambda: state)
response['Restart']
def game():
game_board.draw()
action = useraction.get_user_action()
if action == 'Init':
return 'Init'
elif action == 'Exit':
return 'Exit'
#
if action != 'Spawn':
try:
game_board.move(action)
except:
print("Out of range right now,Try again please")
action = useraction.get_user_action()
game_board.move(action)
else:
game_board.spawn(action)
if game_board.Judge():
return 'Win'
# break
return 'Game'
state = 'Init'
state_actions = {
'Init': init,
'Win': lambda: not_game('Win'),
'Game': game
}
while state != 'Exit':
state = state_actions[state]()
def ConstraintNetworkToGameBoard(cn, n, p, q):
# gb = gameboard.GameBoard()
board = [[0 for j in range(n)] for i in range(n)]
row = 0
col = 0
for v in cn.variables:
board[row][col] = v.getAssignment()
col += 1
if col == n:
col = 0
row += 1
# gb.board = board
# gb.N = n
# gb.p = p
# gb.q = q
return gameboard.GameBoard(n, p, q, board)
def gameLoop(self):
"""
- menu system and game loop
"""
while (self.openWindow):
if (self.firstTurn):
self.game_board = gameboard.GameBoard(self.num_rows,
self.num_cols,
self.num_mines)
self.game_board.createBoard()
self.game_board.placeMines()
self.game_board.fillBoard()
self.tile_w = self.game_board_w // self.num_cols
self.tile_h = self.game_board_h // self.num_rows
# main menu screen
if (self.screen == "main_menu_screen"):
self.mainMenu()
# help screen
elif (self.screen == "help_screen"):
self.helpScreen()
# settings screen
elif (self.screen == "settings_screen"):
self.settingsScreen()
# high scores screen
elif (self.screen == "high_scores_screen"):
self.highScoreScreen()
# play game screen
elif (self.screen == "play_game_screen"):
self.playGameScreen()
# lose screen
elif (self.screen == "lose_screen"):
self.loseScreen()
# win screen
elif (self.screen == "win_screen"):
self.winScreen()
pygame.quit()
quit()
def test_is_board_finished_true(self):
board_size = 18
gb = gameboard.GameBoard(18, self._game_colors, self._colors_color)
# create a mock board with only red elements
mock_board = []
for i in range(board_size):
row = []
for j in range(board_size):
row.append("r")
mock_board.append(row)
gb._set_board(mock_board)
self.assertTrue(gb.is_game_finished())
def test_is_board_finished_false(self):
board_size = 18
gb = gameboard.GameBoard(18, self._game_colors, self._colors_color)
# create a mock board with only red elements
mock_board = []
for i in range(board_size):
row = []
for j in range(board_size):
row.append("r")
mock_board.append(row)
# set one different element
mock_board[0][0] = "y"
gb._set_board(mock_board)
self.assertFalse(gb.is_game_finished())
def __init__(self, parent):
wx.Frame.__init__(self,
parent,
size=(450, 750),
style=wx.DEFAULT_FRAME_STYLE ^ wx.RESIZE_BORDER
^ wx.MAXIMIZE_BOX)
self.Bind(wx.EVT_CLOSE, self.on_close)
#init board.
#load previous config if exist.
try:
with open(save_file, mode="rb") as f:
config, counter_total = pickle.load(f)
except (FileNotFoundError, EOFError, TypeError, ValueError):
config = ge.Config()
counter_total = 0
#Read config about counter
self.counter_total = counter_total
self.counter_current = 0
self.board = gameboard.GameBoard(self, config)
self.board.SetFocus()
self.SetTitle("Next Color Practice")
#init UI
self.sb = self.CreateStatusBar()
self.sb.SetFieldsCount(2)
self.sb.SetStatusWidths([-1, -1])
self.sb.SetStatusText("Counter: " + str(self.counter_current), 0)
self.sb.SetStatusText("Total: " + str(self.counter_total), 1)
toolbar = self.CreateToolBar()
ctool = toolbar.AddTool(
wx.ID_ANY, "", wx.Bitmap(os.path.join(icon_dir, "config.png")))
toolbar.Realize()
self.Bind(wx.EVT_TOOL, self.on_config, ctool)
def __init__(self, parent=None):
QMainWindow.__init__(self, parent)
loadUi('gameboard.ui', self)
self.setStyle(QStyleFactory.create('Fusion'))
#___ Logs
self.log = log.Log('Welcome to Hexapawn!')
self.debug_log = log.Log('Hexapawn Debug -')
self.btn_debug.clicked.connect(lambda: self.update_log(self.debug_log))
self.btn_log_clear.clicked.connect(lambda: self.clear_logs)
self.update_log('Player Moves First')
#___ Tallies
self.win_count_player = 0
self.win_count_computer = 0
self.win_count_draw = 0
self.game_state = 'player turn'
#___ Buttons and their Signals
self.btn0.clicked.connect(lambda: self.onclick_board_btn(0))
self.btn1.clicked.connect(lambda: self.onclick_board_btn(1))
self.btn2.clicked.connect(lambda: self.onclick_board_btn(2))
self.btn3.clicked.connect(lambda: self.onclick_board_btn(3))
self.btn4.clicked.connect(lambda: self.onclick_board_btn(4))
self.btn5.clicked.connect(lambda: self.onclick_board_btn(5))
self.btn6.clicked.connect(lambda: self.onclick_board_btn(6))
self.btn7.clicked.connect(lambda: self.onclick_board_btn(7))
self.btn8.clicked.connect(lambda: self.onclick_board_btn(8))
self.btn_list = [
self.btn0, self.btn1, self.btn2, self.btn3, self.btn4, self.btn5,
self.btn6, self.btn7, self.btn8
]
self.btn_new_game.clicked.connect(self.new_game)
self.btn_play_again.clicked.connect(self.play_again)
self.btn_new_ai.clicked.connect(self.reset_ai)
#___ Setup
self.game_board = gameboard.GameBoard(self.btn_list)
self.computer = AI(self.game_board, self.log, self.debug_log)
self.play_again()
import gameboard
import player
print("Welcome to the game!")
print("Instructions: ")
print("To move up: w")
print("To move down: s")
print("To move left: a")
print("To move right: d")
print("Try to get to the end! Good Luck!")
print("-----------------------------")
# TODO
# Create a new GameBoard called board
board = gameboard.GameBoard()
# Create a new Player called player starting at position 3,2
player = player.Player(3, 2)
while True:
board.printBoard(player.rowPosition, player.columnPosition)
selection = input("Make a move: ")
# TODO
# Move the player through the board
if selection == "w":
player.moveUp()
elif selection == "s":
player.moveDown()
elif selection == "a":
player.moveLeft()
elif selection == "d":
pp = 1
for i in range(pp):
start_time = time.time()
alg.solve(csp, True, False, False,
True) #lookahead, mcv, ac3, find only one solution
totalTime = totalTime + time.time() - start_time
print totalTime / pp
#print the board and ready to write into a file
n = sudokudata.N
def getnum(i, j):
return (i - 1) / int(n**0.5) * int(n**0.5) + (j - 1) / int(n**
0.5) + 1
board = []
for i in range(1, sudokudata.N + 1):
table = []
for j in range(1, sudokudata.N + 1):
table.append(str(alg.optimalAssignment[i, j, getnum(i, j)]))
board.append(table)
sudokudataoutput = gameboard.GameBoard(sudokudata.N, sudokudata.p,
sudokudata.q, board)
#print(sudokudataoutput)
# with open(sys.argv[2], "w") as outfile:
# for line in board:
# for num in line:
# outfile.write('{}'.format(num))
# outfile.write(' ')
# outfile.write('\n')
def __init__(self):
self.gameBoard = gameboard.GameBoard()
def mainMenu(self):
# update pygame frame
pygame.display.update()
# GUI display
self.window.fill(self.colors["gray1"])
self.text("Minesweeper", self.window_w / 2, 50, "Impact", 48, self.colors["white"], "center")
self.displayButton(self.buttons["start"])
self.displayButton(self.buttons["help"])
self.displayButton(self.buttons["settings"])
self.displayButton(self.buttons["high_scores"])
self.text("Created by Kevin Henneberger, Adam Wiener,", self.window_w / 2, 425, "Impact", 16, self.colors["white"], "center")
self.text("Matt Aber, and Baptiste Saliba", self.window_w / 2, 450, "Impact", 16, self.colors["white"], "center")
# event handling
for event in pygame.event.get():
# check if the user clicked the mouse
if (event.type == pygame.MOUSEBUTTONDOWN):
# get mouse x and y coordinates
mousePosition = pygame.mouse.get_pos()
mouseX = mousePosition[0]
mouseY = mousePosition[1]
# change screen
if (self.buttons["start"].mouseOver(mouseX, mouseY)):
self.screen = "play_game_screen"
# set up the board
self.firstTurn = True
if (self.difficulty == "easy"):
self.num_rows = 9
self.num_cols = 9
self.num_mines = 10
self.mines_remaining = 10
elif (self.difficulty == "medium"):
self.num_rows = 12
self.num_cols = 12
self.num_mines = 24
self.mines_remaining = 24
elif (self.difficulty == "hard"):
self.num_rows = 16
self.num_cols = 16
self.num_mines = 40
self.mines_remaining = 40
self.game_board = gameboard.GameBoard(self.num_rows, self.num_cols, self.num_mines)
self.game_board.createBoard()
self.game_board.placeMines()
self.game_board.fillBoard()
self.tile_w = self.game_board_w // self.num_cols
self.tile_h = self.game_board_h // self.num_rows
self.start_time = time.time()
elif (self.buttons["help"].mouseOver(mouseX, mouseY)):
self.screen = "help_screen"
elif (self.buttons["settings"].mouseOver(mouseX, mouseY)):
self.screen = "settings_screen"
elif (self.buttons["high_scores"].mouseOver(mouseX, mouseY)):
self.screen = "high_scores_screen"
# allow the user to exit the window
if (event.type == pygame.QUIT):
self.openWindow = False
print("Failed Color Test")
print("=" * 50)
print("### Testing the Button Module (button.py) ###")
print("=" * 50)
button_test = button.Button(0, "Test")
print(button_test.mouseOver(121, 1)) # should equal True
print(button_test.mouseOver(1000, 1000)) # should equal False
print("=" * 50)
print("### Testing the GameBoard module (game board.py) ###")
print("=" * 50)
tests = [(10,10,9), (12,12,24), (16,16,40)] # the three difficulties: Easy, Medium, and Hard.
for t in tests:
print("Attempt to create a board with {} rows, {} columns, and {} mines.".format(t[0], t[1], t[2]))
gameboard_test = gameboard.GameBoard(t[0], t[1], t[2])
gameboard_test.createBoard()
gameboard_test.placeMine()
gameboard_test.placeMines()
gameboard_test.fillBoard()
gameboard_test.clearEmptyCells(0, 1)
gameboard_test.guaranteeEmptyCell(0, 1)
gameboard_test.revealMines()
gameboard_test.hasLost(0, 1)
gameboard_test.hasWon()
print("Successfully created board!")
def copyGameState(Board):
NewBoard = gameboard.GameBoard(Board.board, Board.width, Board.height,
Board.spawnPool, Board.moveHistory,
Board.Goal)
return NewBoard
output += str(j) + ","
output = output[:-1]
output += ")"
output += "\nCOUNT_NODES=" + str(solverObj.numAssignments)
output += "\nCOUNT_DEADENDS=" + str(solverObj.numBacktracks)
output += "\n" + str(solverObj.gameboard)
return output
if __name__ == '__main__':
# Check command-line arguments.
#print('Python version:',sys.version)
GB = gameboard.GameBoard(12,3,4,[[0 for j in range(12)] for i in range(12)])
print(GB)
TOTAL_START = time.time()
sudokudata = filereader.SudokuFileReader(sys.argv[1])
print(sudokudata)
# cn = filereader.GameBoardToConstraintNetwork(sudokudata)
# print(cn)
solver = btsolver.BTSolver(sudokudata)
#three examples of how you would change the various aspects of solver
# solver.setConsistencyChecks(btsolver.ConsistencyCheck['None'])
# solver.setValueSelectionHeuristic(btsolver.ValueSelectionHeuristic['None'])
# solver.setVariableSelectionHeuristic(btsolver.VariableSelectionHeuristic['None'])
tokens = sys.argv[4:]
solver.setTokens(tokens)
if __name__ == '__main__':
DEFAULT_STRATEGY = (0.5, 1, -1, 2, -2, 3)
strategy = DEFAULT_STRATEGY
for _ in xrange(50):
wins, losses, draws = 0, 0, 0
for _ in xrange(20):
initial_board = generateRandomBoard()
#trace = PerformanceSystem(
# initial_board, strategy, DEFAULT_STRATEGY).playGame()
trace = playGame(initial_board, strategy, DEFAULT_STRATEGY)
if O_won(trace[-1]):
wins += 1
elif X_won(trace[-1]):
losses += 1
else:
draws += 1
print("With strategy %s, machine won %d games, lost %d, drew %d" %
(str(strategy), wins, losses, draws))
empty_board = gameboard.GameBoard()
#trace = PerformanceSystem(
# initial_board, strategy, DEFAULT_STRATEGY).
trace = playGame(initial_board, strategy, DEFAULT_STRATEGY)
training_examples = produceTrainingExamples(trace, strategy,
gameboard.GameBoard.O)
strategy = computeNewStrategy(training_examples, strategy)
def create_game_board(self):
"""Create and open a gameboard window."""
self.gameboard = gameboard.GameBoard(self.main_app,
self.level)
self.open_window(self.gameboard.get_top_widget())
def _successorRule(trace, player, strategy, i):
successor_board = gameboard.GameBoard(trace[i + 2])
return (gameboard.GameBoard(trace[i]).getFeatures(player),
successor_board.evaluateBoard(strategy, player))
def O_won(board):
return gameboard.GameBoard(board).hasWon(gameboard.GameBoard.O)
def start():
p1_board = g.GameBoard()
p2_board = g.GameBoard()
turn = 0
row = 0
col = 0
# player_selection=[row,col]
p1_ships = ['S','S','S','S']
p2_ships = ['S','S','S','S']
while p1_ships != [] and p2_ships != []:
if turn % 2 == 0:
#os.system('clear')
print('P1s Turn')
print('P1s Board:')
v.show_board(p1_board)
if p1_ships == []:
print('Select Target')
row = int(input('Enter row num (top row = 1): '))
col = int(input('Enter col num (leftmost col = 1): '))
else:
print('Place A Ship')
row = int(input('Enter row num (top row = 1): '))
col = int(input('Enter col num (leftmost col = 1): '))
if p1_board[row, col] == ' ':
p1_board[row, col] = p1_ships.pop()
else:
print('Please choose another location.')
row = int(input('Enter row num (top row = 1): '))
col = int(input('Enter col num (leftmost col = 1): '))
if p1_board[row, col] == ' ':
p1_board[row, col] = 'S'
v.show_board(p1_board)
print('Ending turn')
turn += 1
if turn % 2 != 0:
#os.system('clear')
print('P2s Turn')
print('P2s Board:')
v.show_board(p2_board)
if p2_ships == []:
print('Select Target')
row = int(input('Enter row num (top row = 1): '))
col = int(input('Enter col num (leftmost col = 1): '))
else:
print('Place A Ship')
row = int(input('Enter row num (top row = 1): '))
col = int(input('Enter col num (leftmost col = 1): '))
if p2_board[row, col] == ' ':
p2_board[row, col] = p2_ships.pop()
else:
print('Please choose another location.')
row = int(input('Enter row num (top row = 1): '))
col = int(input('Enter col num (leftmost col = 1): '))
if p2_board[row, col] == ' ':
p2_board[row, col] = 'S'
v.show_board(p2_board)
print('Ending turn')
turn += 1
print "##testing to see if '' returtns false for isMine and True for is Empty##"
if i == '1':
print "##testing to see if '1' returns false for both is mine and is empty##"
print(tile_test.isMine())
print(tile_test.isEmpty())
# print False
print "flip test should equal false"
print(tile_test.isFlipped)
tile_test.flip()
# print True
print "after flip should equal true"
print(tile_test.isFlipped)
tile_test.flip()#should return true
tile_test.flag()#should return true
print("###Testing Gameboard Model##")
alltests = [(5,5,3), (4,4,4), (9,9,9), (7,7,15)]
for testn in alltests:
testboard1 = gameboard.GameBoard(testn[0],testn[1],testn[2])
testboard1.createBoard()
testboard1.placeMines()
testboard1.fillBoard()
