def create_db(size=DB_SIZE, townhall_level=4):
# using the same main base for all simulations - no problem with 1 simulator
game_board = board.GameBoard(
generate_base.generate_base_by_level(townhall_level))
sim = simulator.Simulator(game_board)
# Create filepaths
seed = random.randint(1, 10000)
x_path = DATABASES + str(townhall_level) + "/X_" + str(
size) + "_TH_LVL_" + str(townhall_level) + "_" + str(seed) + ".csv"
y_path = DATABASES + str(townhall_level) + "/Y_" + str(
size) + "_TH_LVL_" + str(townhall_level) + "_" + str(seed) + ".csv"
# Write Headers
with open(x_path, "a+") as f_army:
with open(y_path, "a+") as f_res:
# write headers
f_res.write(game_board.get_titles() + ",total" + "\n")
f_army.write(
generate_army.generate_army_by_level(townhall_level)[1] + "\n")
# Run "size" simulations
for i in range(size):
print("Current Row:\t", i)
army, titles = generate_army.generate_army_by_level(townhall_level)
stats = sim.run(army, save_end_state=True, debug=False)
# Open and write in files for every iteration. Append.
with open(x_path, "a") as f_army:
with open(y_path, "a") as f_res:
f_army.write(get_writable_army(army) + "\n")
f_res.write(stats["end_state"] + "\n")
print("Finished DB of size:\t", size)
def plot_single_barb_mat_3d(armies):
# Make data.
X = []
Y = []
Z = []
gb = board.GameBoard(
base_from_html.html_to_game_board("bases/base_th4_2.html"))
sim = simulator.Simulator(gb)
for army in armies:
stats = sim.run(army)
x, y = army[0].get_pos()
X.append(x)
Y.append(y)
Z.append(stats["percent"])
# plot 3d
fig = plt.figure()
ax = fig.gca(projection='3d')
# Plot the surface.
surf = ax.scatter(X,
Y,
Z,
cmap=cm.coolwarm,
linewidth=0,
antialiased=False)
plt.show()
def html_to_game_board(html_file="bases/base1.html", viz=True):
html_doc = get_html(html_file)
soup = BeautifulSoup(html_doc, 'html.parser')
buildings = soup.find_all("div", class_=["coc-b", "wall"])
building_infos = []
for b in buildings:
try:
# get level and class
if b["class"][0] == "wall":
class_str = "wall"
level = int(b["class"][1][3:])
else:
class_str = b["class"][1].split('-')[1]
level = int(b["class"][2][3:])
# get position
pos = b["style"].split("px")[:2]
pos = tuple([int(coord.split(" ")[-1]) // 20 for coord in pos])
pos = (pos[1], pos[0])
# create object from said parameters
if class_str in board.BUILDINGS_MAP_NAME.keys():
building_infos.append((class_str, level, pos))
except Exception as e:
print(e)
# set all positions to align to (0, 0)
min_x = min(building_infos, key=lambda x: x[2][0])[2][0]
min_y = min(building_infos, key=lambda x: x[2][1])[2][1]
max_x = max(building_infos, key=lambda x: x[2][1])[2][0]
max_y = max(building_infos, key=lambda x: x[2][1])[2][1]
board_length = max(max_x - min_x, max_y - min_y) + 1
to_center = max(0, (BOARD_SIZE - board_length) // 2)
building_infos = [(c, l, (p[0] - min_x, p[1] - min_y)) for c, l, p in building_infos]
building_infos = [(c, l, (p[0] + to_center, p[1] + to_center)) for c, l, p in building_infos]
# create objects
building_objs = []
for class_str, level, pos in building_infos:
building_objs.append(board.create_obj_from_name(class_str)(level=level, pos=pos))
# visualize if necessary
if viz:
gb = board.GameBoard(building_objs)
gb.update_viz()
return building_objs
def __init__(self):
'''
Attributes are defined here
Game Initialization is delegated to init_game()
Attributes:
self.board : Pubilc Decks
self.players : List of Player Infomations
self.pack_num : Numbers of Pack of Cards
'''
self.board = board.GameBoard()
self.players = []
self.pack_num = 0
card.FullDeck() # initial card.FullDeck
self.init_game()
self.run_game()
def plot_single_barb_mat(armies):
# Make data.
mat = np.zeros((BOARD_SIZE + 2 * MARGIN, BOARD_SIZE + 2 * MARGIN))
gb = board.GameBoard(generate_base.generate_main_base())
sim = simulator.Simulator(gb)
for army in armies:
stats = sim.run(army)
x, y = army[0].get_pos()
mat[x + MARGIN][y + MARGIN] = stats["percent"]
# plot 3d
plt.title("Attacking Heatmap of 1 super soldier")
plt.xlabel("X")
plt.ylabel("Y")
plt.imshow(mat)
plt.show()
def __init__(self, player_x_turn: bool, player_x, player_y):
super().__init__()
player_x.attach_game(self)
player_y.attach_game(self)
# Initialize the board
self.game_board = board.GameBoard(3)
# Initialize the game state
self.player_x_turn = player_x_turn
self.player_x_wins = False
self.player_y_wins = False
self.game_over = False
self.previous_move_successful = True
# Initialize the players
self.player_x = player_x
self.player_y = player_y
def main():
gb = board.GameBoard(
base_from_html.html_to_game_board("bases/base_th4_1.html"))
row3 = [
-11.0, -8.0, 11.0, -3.0, -5.0, 9.0, 8.0, -1.0, 9.0, -5.0, 6.0, 9.0,
11.0, 10.0, 11.0, 8.0, -20.0, 11.0, 10.0, 10.0, 8.0, -3.0, 8.0, -5.0,
8.0, 8.0, -0.0, -12.0, 10.0, 9.0, 8.0, 8.0, -14.0, 8.0, 8.0, 8.0, -0.0,
-4.0, 9.0, -6.0, -20.0, -4.0, -1.0, -0.0, 8.0, -0.0, 8.0, 9.0, 10.0,
10.0, 8.0, -0.0, -6.0, 6.0, 7.0, -0.0, 10.0, 13.0, -0.0, 10.0, 7.0,
7.0, 8.0, 9.0, 6.0, 10.0, -2.0, 11.0, 10.0, 8.0, 10.0, 11.0, 10.0, 9.0,
9.0, 9.0
]
army = generate_army.generate_army_from_row(row=row3, quants=[13, 13, 5])
# visualize
board_viz.viz_board(gb, army)
gb.update_viz()
# create simulator
sim = simulator.Simulator(gb)
stats = sim.run(army, viz=True, save_end_state=True)
print(stats)
def makeMove(move, hand=0):
if not hand:
hand = game.pop(playerTurn, move)
while hand > 0:
move = nextPos(move)
game.increment(playerTurn, move, 1)
hand -= 1
if game.getValue(playerTurn, move) != 1:
makeMove(move)
else:
captureStones(move)
game = board.GameBoard()
turnNumber = 1
playerTurn = 1
while not game.done():
print('Turn {num}'.format(num=turnNumber))
game.output(playerTurn)
makeMove(getMove())
turnNumber += 1
playerTurn = nextTurn(playerTurn)
print('Player {playerName} wins!'.format(playerName=game.done()))
import pandas as pd
import generate_army
import generate_base
import board_viz
import board
TOP_K = 3
MAIN_BOARD = board.GameBoard(generate_base.generate_main_base())
df_x = pd.read_csv("./databases/X_10000.csv")
df_y = pd.read_csv("./databases/Y_10000.csv")["total"]
merged = pd.concat([df_x, df_y], axis=1, sort=False)
print(merged)
top_k = merged.nlargest(TOP_K, 'total')
print(top_k)
armies = [
generate_army.generate_army_from_row(top_k.iloc[i, :])
for i in range(TOP_K)
]
board_viz.viz_board(army=armies[0], game_board=MAIN_BOARD, viz=True)
def generate_main_base():
armys = []
elixirs = []
walls = []
barrackses = []
archers = []
elixir_storages = []
gold_storages = []
cannons = []
golds = []
mortars = []
builders = []
armys.append(ArmyCamps(pos=(0, 4), level=3))
armys.append(ArmyCamps(pos=(0, 10), level=3))
elixirs.append(ElixirCollector(pos=(3, 16), level=6))
elixirs.append(ElixirCollector(pos=(12, 16), level=6))
for i in range(5, 16):
walls.append(Wall(pos=(5, i), level=4))
barrackses.append(Barracks(pos=(6, 2), level=5))
barrackses.append(Barracks(pos=(7, 16), level=5))
archers.append(ArcherTower(pos=(6, 6), level=3))
elixir_storages.append(ElixirStorage(pos=(6, 9), level=6))
cannons.append(Cannon(pos=(6, 12), level=4))
for i in range(3, 16):
walls.append(Wall(pos=(9, i), level=4))
for i in range(6, 9):
walls.append(Wall(pos=(i, 5), level=4))
walls.append(Wall(pos=(i, 15), level=4))
golds.append(GoldCollector(pos=(11, 0), level=6))
for i in range(10, 14):
walls.append(Wall(pos=(i, 3), level=4))
walls.append(Wall(pos=(i, 11), level=4))
for i in range(10, 16):
walls.append(Wall(pos=(i, 15), level=4))
gold_storages.append(GoldStorage(pos=(11, 4), level=6))
TH = TownHall(pos=(10, 7), level=4)
mortars.append(Mortar(pos=(10, 12), level=1))
elixir_storages.append(ElixirStorage(pos=(13, 12), level=6))
builders.append(Builder(pos=(14, 0), level=2))
for i in range(3, 12):
walls.append(Wall(pos=(14, i), level=4))
golds.append(GoldCollector(pos=(14, 19), level=6))
barrackses.append(Barracks(pos=(15, 2), level=5))
for i in range(15, 18):
walls.append(Wall(pos=(i, 5), level=4))
walls.append(Wall(pos=(17, 12), level=4))
for i in range(5, 13):
walls.append(Wall(pos=(18, i), level=4))
archers.append(ArcherTower(pos=(15, 6), level=3))
gold_storages.append(GoldStorage(pos=(15, 9), level=6))
cannons.append(Cannon(pos=(17, 13), level=4))
Lab = Labratory(pos=(17, 17), level=1)
golds.append(GoldCollector(pos=(19, 2), level=6))
elixirs.append(ElixirStorage(pos=(19, 5), level=6))
Castle = ClanCastle(pos=(19, 10), level=1)
walls.append(Wall(pos=(20, 15), level=4))
for i in range(17, 21):
walls.append(Wall(pos=(i, 16), level=4))
for i in range(12, 17):
walls.append(Wall(pos=(16, i), level=4))
elixirs.append(ElixirCollector(pos=(21, 13), level=6))
golds.append(GoldCollector(pos=(21, 16), level=6))
buildings = walls + cannons + archers + armys + gold_storages + elixir_storages + barrackses + \
mortars + builders + golds + elixirs
buildings.append(TH)
buildings.append(Lab)
buildings.append(Castle)
for b in buildings:
x, y = b.get_pos()
b.set_pos((y, x))
board.GameBoard(buildings).is_legal()
return buildings
return final_path, G[loc] # Done!
# Mark the current vertex as closed
closedVertices.append(current)
# Update scores for vertices near the current position
for neighbour in graph.get_vertex_neighbours(current):
if neighbour in closedVertices:
continue # We have already processed this node exhaustively
candidateG = G[current] + graph.move_cost(current, neighbour)
if (neighbour not in G.keys()
or (neighbour in G.keys() and candidateG < G[neighbour])):
heapq.heappush(openVertices, (candidateG, neighbour))
cameFrom[neighbour] = current
G[neighbour] = candidateG
print("shouldnt be here ever")
print("barriers", graph.barriers)
print("start", start)
print("targets", targets)
return [], 0
if __name__ == "__main__":
gb = board.GameBoard(main.generate_random_base_3())
graph = AStarGraph(gb)
print(graph.barriers)
start = (0, 0)
targets = [(1, 7), (7, 7), (7, 1)]
result, cost = AStarSearch(start, targets, graph)
board_viz.viz_path(result, graph, targets)
import board
pygame.init()
Screen = pygame.display.set_mode((500, 500))
pygame.display.set_icon(pygame.image.load("Icon.png"))
pygame.event.set_allowed(None) # PyGame will now not check for any inputs
allowed_events = (pygame.MOUSEMOTION, pygame.MOUSEBUTTONDOWN, pygame.KEYDOWN,
pygame.KEYUP, pygame.QUIT)
for event in allowed_events: # PyGame will now only check inputs for things used in the
pygame.event.set_allowed(
event) # program, increasing speed and efficiency.
Sim = set_up.Sim() # Setting up
SimBoard = board.SimBoard(Sim)
SimBoard.set_up(Sim.SetUpChances)
Game = set_up.Game()
GameBoard = board.GameBoard(Game, players=True)
GameBoard.set_up(Game.SetUpChances, rotational_symmetry=Game.NoOfPlayers)
Help = set_up.Help()
Menu = set_up.Menu()
MenuChoice = Menu.get_choice(Screen)
while MenuChoice in (Menu.Buttons[:3]
): # If a button that wasn't the Quit button was pressed
if MenuChoice == Menu.Buttons[0]: # If the Simulator button was pressed
Sim.run(Screen, SimBoard)
elif MenuChoice == Menu.Buttons[1]: # If the Game button was pressed
if Game.run(
Screen, GameBoard
): # Runs the game; value returned is boolean value which is
Game = set_up.Game(
) # True if the game has ended and if it did the game is
# allowed events
allowed_events = (pygame.MOUSEMOTION, pygame.MOUSEBUTTONDOWN, pygame.KEYDOWN,
pygame.KEYUP, pygame.QUIT)
for event in allowed_events:
pygame.event.set_allowed(event)
# Simulation
Sim = utils.Sim()
SimBoard = board.SimBoard(Sim)
SimBoard.utils(Sim.SetUpChances)
# Game
Game = utils.Game()
GameBoard = board.GameBoard(Game, players=True)
GameBoard.utils(Game.SetUpChances, rotational_symmetry=Game.NoOfPlayers)
# Help
Help = utils.Help()
# Main Menu
Menu = utils.Menu()
MenuChoice = Menu.get_choice(Screen)
while MenuChoice in (Menu.Buttons[:3]): # Ff non-quit button was pressed.
if MenuChoice == Menu.Buttons[0]: # If the Simulator button was pressed
Sim.run(Screen, SimBoard)
elif MenuChoice == Menu.Buttons[1]: # If the Game button was pressed
if Game.run(Screen, GameBoard): # Run Game
Game = utils.Game() # End Game
from random import randint
# Setup the game
game_ended = False
player_color = ""
# Get which color the player wants to be
player_color = str(
raw_input("Welcome to Pentago\n\nPlease choose a color (b, w) : "))
if player_color != "b" and player_color != "w":
print("Error: Please choose w or b for your color.")
exit()
move_order = randint(1, 2)
# Create the gameboard
gb = board.GameBoard()
if move_order == 1:
# Player turn
gb.turn = player_color
else:
# AI turn
gb.turn = "b" if player_color != "b" else "w"
# Create the AI
ai_color = "b" if player_color == "w" else "w"
ai = ai.AI(ai_color)
print("=> You are " + str(player_color) + "\n=> AI is " + str(ai_color))
# GAME INTERFACE METHODS
