def Run(self,fh=None,**kwargs):
if self.mode == 'n' or self.mode == 'network' :
if kwargs['mode'] == 'host':
self.ai_list.append(
IOAI(self.col, self.row, self.p, ai_path=kwargs['ai_path'], time=kwargs['time']))
self.ai_list.append(
NetworkAI(self.col, self.row, self.p, mode=kwargs['mode'], info=kwargs['info']))
else:
self.ai_list.append(
NetworkAI(self.col, self.row, self.p, mode=kwargs['mode'], info=kwargs['info']))
self.ai_list.append(
IOAI(self.col, self.row, self.p, ai_path=kwargs['ai_path'], time=kwargs['time']))
self.gameloop(fh)
elif self.mode == 'm' or self.mode == 'manual' :
if kwargs['order'] == '1':
self.ai_list.append(
ManualAI(self.col, self.row, self.p))
self.ai_list.append(
StudentAI(self.col, self.row, self.p))
else:
self.ai_list.append(
StudentAI(self.col, self.row, self.p))
self.ai_list.append(
ManualAI(self.col, self.row, self.p))
self.gameloop(fh)
def __init__(self, manualAI=False, filename=None):
self.__score = 0
self.__numMines = 0
#self.__numFlags = 0
self.__gameover = False
self.__score = 0
if manualAI:
self.__agent = ManualAI()
# If file is provided
if filename != None:
with open(filename, 'r') as file:
self.__colDimension, self.__rowDimension = [
int(x) for x in file.readline().split()
]
self.__board = [[
self.__Tile() for i in range(self.__rowDimension)
] for j in range(self.__colDimension)]
self.__addFeatures(file)
self.__findFirst()
# If file not provided (default)
else:
self.__colDimension = 25 # Default sizes
self.__rowDimension = 25 # Default size
self.__totalMines = 99 # Default number of mines
self.__board = [[
self.__Tile() for i in range(self.__rowDimension)
] for j in range(self.__colDimension)]
self.__addFeatures()
self.__findFirst()
self.__numFlags = self.__numMines
def __init__ ( self, debug = False, randomAI = False, manualAI = False, file = None ):
# Operation Flags
self.__debug = debug
self.__manualAI = manualAI
# Agent Initialization
self.__goldLooted = False
self.__hasArrow = True
self.__bump = False
self.__scream = False
self.__score = 0
self.__agentDir = 0
self.__agentX = 0
self.__agentY = 0
self.__lastAction = Agent.Action.CLIMB
if randomAI:
self.__agent = RandomAI()
elif manualAI:
self.__agent = ManualAI()
else:
self.__agent = MyAI()
if file != None:
self.__colDimension, self.__rowDimension = [int(x) for x in next(file).split()]
self.__board = [[self.__Tile() for j in range(self.__rowDimension)] for i in range(self.__colDimension)]
self.__addFeatures(file)
else:
self.__colDimension = 4
self.__rowDimension = 4
self.__board = [[self.__Tile() for j in range(self.__colDimension)] for i in range(self.__rowDimension)]
self.__addFeatures()
def __init__(self, filename=None, aiType="myai", verbose=False, debug=False):
self.__verbose = verbose
self.__debug = debug
self.__colDimension = 0
self.__rowDimension = 0
self.__score = 0
self.__board = None
self.__totalMines = 0
self.__flagsLeft = 0
self.__coveredTiles = 0
self.__movesMade = 0
self.__movesLimit = 0
self.__perceptNumber = 0
self.__lastTile = None
self.__lastAction = None
try:
# If file is provided, construct board based on file
if filename != None:
with open(filename, 'r') as file:
self.__createBoard(file)
firstMoveCoords = self.__getFirstMove(file)
self.__addMines(file)
self.__addNumbers()
self.__coveredTiles = self.__colDimension * self.__rowDimension
self.__flagsLeft = self.__totalMines
self.__uncoverTile(firstMoveCoords[0], firstMoveCoords[1])
self.__lastTile = (firstMoveCoords[0]+1, firstMoveCoords[1]+1)
self.__lastAction = "UNCOVER"
# If file not provided, construct board using defaults
else:
self.__createBoard()
self.__addMines()
self.__addNumbers()
firstMoveCoords = self.__getFirstMove()
self.__coveredTiles = self.__colDimension * self.__rowDimension
self.__flagsLeft = self.__totalMines
self.__uncoverTile(firstMoveCoords[0], firstMoveCoords[1])
self.__lastTile = (firstMoveCoords[0]+1, firstMoveCoords[1]+1)
self.__lastAction = "UNCOVER"
except ValueError as e:
print("Error: Cannot create board!")
if aiType == "manual":
self.__ai = ManualAI()
elif aiType == "random":
self.__ai = RandomAI(self.__rowDimension, self.__colDimension, self.__totalMines, firstMoveCoords[0], firstMoveCoords[1])
elif aiType == "myai":
self.__ai = MyAI(self.__rowDimension, self.__colDimension, self.__totalMines, firstMoveCoords[0], firstMoveCoords[1])
if (self.__verbose and filename):
print("Running on world: " + filename)
def Run(self, fh=None, **kwargs):
if self.mode == 'n' or self.mode == 'network':
if kwargs['mode'] == 'host':
self.ai_list.append(
IOAI(self.col,
self.row,
self.k,
self.g,
ai_path=kwargs['ai_path'],
time=kwargs['time']))
self.ai_list.append(
NetworkAI(self.col,
self.row,
self.k,
self.g,
mode=kwargs['mode'],
info=kwargs['info']))
else:
self.ai_list.append(
NetworkAI(self.col,
self.row,
self.k,
self.g,
mode=kwargs['mode'],
info=kwargs['info']))
self.ai_list.append(
IOAI(self.col,
self.row,
self.k,
self.g,
ai_path=kwargs['ai_path'],
time=kwargs['time']))
self.gameloop(fh)
elif self.mode == 'm' or self.mode == 'manual':
if kwargs['order'] == '1':
self.ai_list.append(
ManualAI(self.col, self.row, self.k, self.g))
self.ai_list.append(
StudentAI(self.col, self.row, self.k, self.g))
else:
self.ai_list.append(
StudentAI(self.col, self.row, self.k, self.g))
self.ai_list.append(
ManualAI(self.col, self.row, self.k, self.g))
self.gameloop(fh)
elif self.mode == 's' or self.mode == 'self':
if kwargs['order'] == '1':
self.ai_list.append(
StudentAI(self.col, self.row, self.k, self.g))
self.ai_list.append(
StudentAI(self.col, self.row, self.k, self.g))
else:
self.ai_list.append(
StudentAI(self.col, self.row, self.k, self.g))
self.ai_list.append(
StudentAI(self.col, self.row, self.k, self.g))
self.gameloop(fh)
elif self.mode == 'l' or self.mode == 'local':
self.ai_list.append(
IOAI(self.col,
self.row,
self.k,
self.g,
ai_path=kwargs['ai_path_1'],
time=kwargs['time']))
self.ai_list.append(
IOAI(self.col,
self.row,
self.k,
self.g,
ai_path=kwargs['ai_path_2'],
time=kwargs['time']))
return self.gameloop(fh)
elif self.mode == 't':
self.TournamentInterface()
class World():
# Tiles
class __Tile():
mine = False
covered = True
flag = False
number = 0
def __init__(self, manualAI=False, filename=None):
self.__score = 0
self.__numMines = 0
#self.__numFlags = 0
self.__gameover = False
self.__score = 0
if manualAI:
self.__agent = ManualAI()
# If file is provided
if filename != None:
with open(filename, 'r') as file:
self.__colDimension, self.__rowDimension = [
int(x) for x in file.readline().split()
]
self.__board = [[
self.__Tile() for i in range(self.__rowDimension)
] for j in range(self.__colDimension)]
self.__addFeatures(file)
self.__findFirst()
# If file not provided (default)
else:
self.__colDimension = 25 # Default sizes
self.__rowDimension = 25 # Default size
self.__totalMines = 99 # Default number of mines
self.__board = [[
self.__Tile() for i in range(self.__rowDimension)
] for j in range(self.__colDimension)]
self.__addFeatures()
self.__findFirst()
self.__numFlags = self.__numMines
def run(self):
""" Engine of the game """
while (not self.__gameover):
self.__printBoard()
try:
move = self.__agent.getAction()
action = move.getMove()
coordX = move.getX()
coordY = move.getY()
if action == "l":
self.__handleGameover()
break
self.__doMove(action, coordX, coordY)
except ValueError as error:
print("Error: Invalid action!")
except IndexError:
print("Error: Move is out of bounds!")
###############################################
# ACTIONS ON BOARD #
###############################################
def __doMove(self, action, x, y):
""" Perform a move on the game board based on given action and x, y coords """
if action not in ["l", "u", "f"]:
raise ValueError
elif x < 0 or y < 0:
raise IndexError
else:
if action == "f":
if not self.__board[x][y].flag: # Flag tile if not yet flagged
self.__board[x][y].flag = True
self.__numFlags -= 1
else: # Unflag tile if already flagged
self.__board[x][y].flag = False
self.__numFlags += 1
if self.__board[x][
y].mine: # If correctly flag a mine tile, score+1
self.__score += 1
else: # If incorrectly flag a tile, score-1
self.__score -= 1
elif action == "u":
if self.__board[x][
y].mine == True: # If uncover a mine, trigger gameover
self.__handleGameover()
else: # If uncover a regular tile, score+1
self.__score += 1
self.__board[x][y].covered = False
#####################################################
# SETTING UP THE GAME BOARD #
#####################################################
def __addFeatures(self, open_file=None):
""" Add mines and numbers to tiles """
# If no file is provided (default)
if open_file == None:
currentMines = 0
while currentMines < self.__totalMines:
r = self.__randomInt(self.__rowDimension)
c = self.__randomInt(self.__colDimension)
if not self.__board[c][r].mine:
self.__addMine(c, r)
currentMines += 1
# If file is provided
else:
for r, line in zip(range(self.__rowDimension - 1, -1, -1),
open_file.readlines()):
for c, tile in zip(range(self.__colDimension), line.split()):
if tile == "1":
self.__addMine(c, r)
def __addMine(self, c, r):
""" Add mine to tile located at c, r """
# Set attributes
self.__board[c][r].mine = True
self.__numMines += 1
# Increment number values according to mines
self.__addHintNumber(c, r + 1)
self.__addHintNumber(c, r - 1)
self.__addHintNumber(c + 1, r)
self.__addHintNumber(c - 1, r)
self.__addHintNumber(c - 1, r + 1)
self.__addHintNumber(c + 1, r + 1)
self.__addHintNumber(c - 1, r - 1)
self.__addHintNumber(c + 1, r - 1)
def __addHintNumber(self, c, r):
""" Makes sure tile is in bounds before updating the number value
Avoids out of bounds IndexError
"""
if c < self.__colDimension and c >= 0 and r < self.__rowDimension and r >= 0:
self.__board[c][r].number += 1
def __findFirst(self):
""" Finds random tile with number 0 and gives it to the player """
x = self.__randomInt(self.__colDimension)
y = self.__randomInt(self.__rowDimension)
while (self.__board[y][x].number != 0):
x = self.__randomInt(self.__colDimension)
y = self.__randomInt(self.__rowDimension)
self.__board[y][x].number = 0
self.__board[y][x].covered = False
#############################################
# BOARD REPRESENTATION #
#############################################
def __printBoard(self):
""" Print board for debugging """
print("\nNumber of mines: " + str(self.__numMines))
print("Number of flags left: " + str(self.__numFlags))
board_as_string = ""
for r in range(self.__rowDimension - 1, -1, -1):
board_as_string += str(r).ljust(2) + "|"
for c in range(self.__colDimension):
if not self.__board[c][r].covered:
board_as_string += " " + str(
self.__board[c][r].number) + " "
elif self.__board[c][r].flag:
board_as_string += " ? "
elif self.__board[c][r].covered:
board_as_string += " . "
"""
# Used for debugging
if self.__board[c][r].mine:
board_as_string += " B "
else:
board_as_string += " " + str(self.__board[c][r].number) + " "
"""
if (r != 0):
board_as_string += "\n"
column_label = " "
column_border = " "
for c in range(self.__colDimension):
column_border += "---"
column_label += str(c).ljust(3)
print(board_as_string)
print(column_border)
print(column_label)
def __handleGameover(self):
""" When a mine is uncovered, end the game and reveal the entire board """
print("Gameover!")
for r in range(self.__rowDimension - 1, -1, -1):
for c in range(self.__colDimension):
if self.__board[c][r].mine:
self.__board[c][r].number = "B"
self.__board[c][r].covered = False
self.__gameover = True
self.__printBoard()
print("Score: " + str(self.__score))
#####################################################
# HELPER FUNCTIONS #
#####################################################
def __randomInt(self, limit):
""" Return a random int within the range from 0 to limit """
return random.randrange(limit)
from Game import Game
from ManualAI import ManualAI
AIs = []
for i in range(4):
AIs.append(ManualAI(i))
num_games = 1000
total_score = [0] * 4
debug = True
for game_count in range(0, num_games):
g = Game(AIs, debug=debug)
score = [0] * 4
try:
score = g.run_game()
except RuntimeError as e:
score = e.args[0]
print(">>> Error: %r <<<" % e.args[1])
total_score = [sum(x) for x in zip(score, total_score)]
print("score is %r" % score)
print("total score is %r" % total_score)
