def __init__(self, name: str, config: gymdata.SelfPlayConfig,
gympath: gymdata.GymPath, monitoring_q: mpq.Queue,
endevent: multiprocessing.Event, logging_q: mpq.Queue,
predict_request_q: mpq.Queue, predict_response_q: mpq.Queue,
graph: GameGraph):
super().__init__()
graph.truncate_to_roots()
self.name = name
self._mcts_graph = graph.deepcopy()
self._mcts_searchtable = dict()
self._mcts_current_expansions = set()
self.config = config
self.endevent = endevent
self.logging_q = logging_q
self.predict_request_q = predict_request_q
self.predict_response_q = predict_response_q
self.gympath = gympath
self.monitoring_q = monitoring_q
self.logger: logging.Logger
self.debug_stats = {
'searches': 0,
'select_wait': [],
'predict_wait': []
}
self._gamelogs = deque(())
self.modeliteration: int
with open(self.gympath.modelinfo_file) as f:
self.modeliteration = gymdata.ModelInfo.from_json(
f.read()).iterationNr
def __init__(self, name: str, config: gymdata.EvaluateConfig,
gympath: gymdata.GymPath, monitoring_q: mpq.Queue,
endevent: multiprocessing.Event, logging_q: mpq.Queue,
predict_request_qs: 'list[mpq.Queue]',
predict_response_q: mpq.Queue, graph: GameGraph):
super().__init__()
graph.truncate_to_roots()
self.name = name
self._mcts_graphs = [graph.deepcopy(), graph.deepcopy()]
self._mcts_searchtables = [dict(), dict()]
self._mcts_current_expansions = set()
self.config = config
self.endevent = endevent
self.logging_q = logging_q
self.predict_request_qs = predict_request_qs
self.predict_response_q = predict_response_q
self.gympath = gympath
self.monitoring_q = monitoring_q
self.logger: logging.Logger
self.debug_stats = {
'searches': 0,
'select_wait': [],
'predict_wait': []
}
self.scores: 'list[int]' = []
def test_tojson_fromjsom(Graph: GameGraph):
G = Graph.__class__.from_json(Graph.as_json())
assert G.description == Graph.description
assert G.roots == Graph.roots
for v, c in G._childrentable.items():
Graph._childrentable[v] == c
for v, c in Graph._childrentable.items():
G._childrentable[v] == c
def test_attributetypes(Graph: GameGraph):
assert isinstance(Graph.description, str)
assert isinstance(Graph.edges, set)
assert isinstance(Graph.outdegree_max, int)
assert isinstance(Graph.roots, tuple)
assert isinstance(Graph.vertices, set)
assert isinstance(Graph._childrentable, dict)
for v in sample(Graph.vertices,
k=min(MAX_VERTEX_CHECK, len(Graph.vertices))):
if not Graph.open_at(v):
children = Graph.children_at(v)
assert isinstance(children, tuple)
for c in children:
assert isinstance(c, type(v))
for e in Graph.edges:
assert isinstance(e, tuple)
for v, c in Graph._childrentable.items():
assert isinstance(c, tuple) or c == None
def __init__(self,width,height,name,nodes,nodepos,edges,party,team):
self.width = width
self.height = height
self.screen = pygame.display.set_mode((self.width,self.height))
pygame.display.set_caption(name)
self.mode = Modes.Map
self.nodes = nodes
self.nodepos = nodepos
self.edges = edges
self.map = GameGraph(nodes,nodepos,edges,self.screen)
self.party = party
self.team = team
self.show_min = None
def test_raise_open_nonopen(Graph: GameGraph):
for v in sample(Graph.vertices,
k=min(MAX_VERTEX_CHECK, len(Graph.vertices))):
if Graph.open_at(v):
with pytest.raises(VertexOpen):
Graph.children_at(v)
with pytest.raises(VertexOpen):
Graph.terminal_at(v)
else:
with pytest.raises(VertexNotOpen):
Graph.expand_at(v)
class Interface():
"""
Graphical User Interface for the Game
"""
def __init__(self,width,height,name,nodes,nodepos,edges,party,team):
self.width = width
self.height = height
self.screen = pygame.display.set_mode((self.width,self.height))
pygame.display.set_caption(name)
self.mode = Modes.Map
self.nodes = nodes
self.nodepos = nodepos
self.edges = edges
self.map = GameGraph(nodes,nodepos,edges,self.screen)
self.party = party
self.team = team
self.show_min = None
def change_mode(self, newmode):
"""
Changes the Interface mode to newmode
"""
self.mode = newmode
pygame.draw.rect(self.screen,BLACK,pygame.Rect(0,0,self.width,self.height))
def auto_team(self):
"""
Creates the strongest possible team of minions based on the party
composition and maximum team size
"""
cap = self.team.maxsize - self.team.size
poss_min = []
num_guys = []
num_types = 4
type_costs = [1,2,3,4]
for i in range(num_types):
num_guys.append(cap//type_costs[i])
costs = list()
values = list()
index = 0
for i in range(num_types):
for k in range(num_guys[i]):
poss_min.append(None)
poss_min[index] = Minion()
poss_min[index].set_type(i)
costs.append(poss_min[index].cost)
values.append(poss_min[index].Value(self.party))
index += 1
best_team = max_val_group(cap,costs,values)
for h, val in enumerate(best_team):
if val == 1:
self.team.add(poss_min[h])
def draw_info(self,minion):
pygame.Rect(625,200,150,150)
if minion.type == "Goblin":
NameText = Font.render(minion.type, True, WHITE)
HealthText = Font.render("Health: {}".format(minion.health), True, WHITE)
StrengthText = Font.render("Low Damage", True, WHITE)
self.screen.blit(NameText, pygame.Rect(630,200,150,20))
self.screen.blit(HealthText, pygame.Rect(630,220,150,20))
self.screen.blit(StrengthText, pygame.Rect(630,240,150,20))
if minion.type == "Ork":
NameText = Font.render(minion.type, True, WHITE)
HealthText = Font.render("Health: {}".format(minion.health), True, WHITE)
StrengthText = Font.render("Med Damage", True, WHITE)
self.screen.blit(NameText, pygame.Rect(630,200,150,20))
self.screen.blit(HealthText, pygame.Rect(630,220,150,20))
self.screen.blit(StrengthText, pygame.Rect(630,240,150,20))
if minion.type == "Skeleton":
NameText = Font.render(minion.type, True, WHITE)
HealthText = Font.render("Health: {}".format(minion.health), True, WHITE)
StrengthText = Font.render("Med Damage", True, WHITE)
RangedText = Font.render("2 Attacks", True, WHITE)
self.screen.blit(NameText, pygame.Rect(630,200,150,20))
self.screen.blit(HealthText, pygame.Rect(630,220,150,20))
self.screen.blit(StrengthText, pygame.Rect(630,240,150,20))
self.screen.blit(RangedText, pygame.Rect(630,260,80,20))
if minion.type == "Troll":
NameText = Font.render(minion.type, True, WHITE)
HealthText = Font.render("Health: {}".format(minion.health), True, WHITE)
StrengthText = Font.render("High Damage", True, WHITE)
self.screen.blit(NameText, pygame.Rect(630,200,150,20))
self.screen.blit(HealthText, pygame.Rect(630,220,150,20))
self.screen.blit(StrengthText, pygame.Rect(630,240,150,20))
def on_hover(self,event):
"""
Certain events to occur if the cursor is located over certain areas of
the screen
"""
if self.mode == Modes.MakeTeam:
if(pygame.Rect(610,450,80,50).collidepoint(event.pos)):
self.show_min = 1
elif(pygame.Rect(710,450,80,50).collidepoint(event.pos)):
self.show_min = 2
elif(pygame.Rect(610,525,80,50).collidepoint(event.pos)):
self.show_min = 3
elif(pygame.Rect(710,525,80,50).collidepoint(event.pos)):
self.show_min = 4
else:
self.show_min = None
def on_click(self,event):
"""
Certain events to occur if the cursor is clicked based on the location
of the click
"""
if self.mode == Modes.Map:
if (pygame.Rect(625,25,150,50).collidepoint(event.pos)):
self.change_mode(Modes.MakeTeam)
return
if self.mode == Modes.MakeTeam:
if (pygame.Rect(625,25,150,50).collidepoint(event.pos)):
self.change_mode(Modes.Combat)
return
if (pygame.Rect(625,125,150,50).collidepoint(event.pos)):
self.auto_team()
if(pygame.Rect(610,450,80,50).collidepoint(event.pos)):
minion = Minion()
minion.set_type(0)
self.team.add(minion)
return
if(pygame.Rect(710,450,80,50).collidepoint(event.pos)):
minion = Minion()
minion.set_type(1)
self.team.add(minion)
return
if(pygame.Rect(610,525,80,50).collidepoint(event.pos)):
minion = Minion()
minion.set_type(2)
self.team.add(minion)
return
if(pygame.Rect(710,525,80,50).collidepoint(event.pos)):
minion = Minion()
minion.set_type(3)
self.team.add(minion)
return
for i in self.team.members:
if(i.rect.collidepoint(event.pos)):
self.team.remove(i)
if self.mode == Modes.Combat:
if (pygame.Rect(625,25,150,50).collidepoint(event.pos)):
self.change_mode(Modes.Map)
if self.mode == Modes.GameOver:
pass
def screen_update(self):
"""
Updates what is shown on the display based on the mode
"""
global sim_fight
global win
#draw sidebar
pygame.draw.rect(self.screen,GREY2,pygame.Rect(600,0,200,600))
#Drawn if in Map mode
if self.mode == Modes.Map:
#draw top button
pygame.draw.rect(self.screen,GREY3,pygame.Rect(625,25,150,50))
text = Font.render("Create Team", True, WHITE)
self.screen.blit(text, (630, 40))
for i, member in enumerate(self.party.members):
rect = pygame.Rect(625,150+(i*100),150,80)
pygame.draw.rect(self.screen,member.color,rect)
# Draw the health text of each units blocks
name_text = Font.render(member.type, True, WHITE)
self.screen.blit(name_text, rect)
#Draw the Unit's Picture on the Block
self.screen.blit(member.image, (670, 150+(i*100)))
health_text = Font.render("{}".format(member.health), True, WHITE)
rect.x += 125 - ((member.health//100) * 10)
self.screen.blit(health_text, rect)
self.map.draw_graph()
self.map.draw_group(self.party.node)
#Drawn if in MakeTeam mode
if self.mode == Modes.MakeTeam:
#draw top button
pygame.draw.rect(self.screen,GREY3,pygame.Rect(625,25,150,50))
text = Font.render("Fight", True, WHITE)
self.screen.blit(text, (630, 40))
self.party.drawGroup(self.screen)
self.team.drawGroup(self.screen)
pygame.draw.rect(self.screen,GREY3,pygame.Rect(625,125,150,50))
text = Font.render("Generate Team", True, WHITE)
self.screen.blit(text, (625,130))
pygame.draw.rect(self.screen,GREY3,pygame.Rect(625,200,150,150))
pygame.draw.rect(self.screen,GREY3,pygame.Rect(625,375,150,50))
text0 = Font.render("Capacity: {}".format(self.team.maxsize), True, WHITE)
self.screen.blit(text0, (630, 375))
texta = Font.render("Used: {}".format(self.team.size), True, WHITE)
self.screen.blit(texta, (630, 400))
testmin = Minion()
testmin.Goblin()
pygame.draw.rect(self.screen,(testmin.color),pygame.Rect(610,450,85,50))
nametext = Font.render(testmin.type, True, WHITE)
self.screen.blit(nametext, (610, 450))
costtext = Font.render("Cost: {}".format(testmin.cost), True, WHITE)
self.screen.blit(costtext, (610, 475))
if self.show_min == 1:
self.screen.blit(testmin.image, (695,270))
self.draw_info(testmin)
testmin.Ork()
pygame.draw.rect(self.screen,(testmin.color),pygame.Rect(705,450,85,50))
nametext = Font.render(testmin.type, True, WHITE)
self.screen.blit(nametext, (710, 450))
costtext = Font.render("Cost: {}".format(testmin.cost), True, WHITE)
self.screen.blit(costtext, (710, 475))
if self.show_min == 2:
self.screen.blit(testmin.image, (695,270))
self.draw_info(testmin)
testmin.Skeleton()
pygame.draw.rect(self.screen,(testmin.color),pygame.Rect(610,525,85,50))
nametext = Font.render(testmin.type, True, WHITE)
self.screen.blit(nametext, (610, 525))
costtext = Font.render("Cost: {}".format(testmin.cost), True, WHITE)
self.screen.blit(costtext, (610, 550))
if self.show_min == 3:
self.screen.blit(testmin.image, (695,270))
self.draw_info(testmin)
testmin.Troll()
pygame.draw.rect(self.screen,testmin.color,pygame.Rect(705,525,85,50))
nametext = Font.render(testmin.type, True, WHITE)
self.screen.blit(nametext, (710, 525))
costtext = Font.render("Cost: {}".format(testmin.cost), True, WHITE)
self.screen.blit(costtext, (710, 550))
if self.show_min == 4:
self.screen.blit(testmin.image, (695,270))
self.draw_info(testmin)
#Drawn if in Combat mode
if self.mode == Modes.Combat:
self.party.drawGroup(self.screen)
self.team.drawGroup(self.screen)
#draw top button
pygame.draw.rect(self.screen,GREY3,pygame.Rect(625,25,150,50))
text = Font.render("Skip Fight", True, WHITE)
self.screen.blit(text, (630, 40))
sim_fight = True
while self.team.status() and self.party.status():
fight(self.team, self.party, self.screen)
fight(self.party, self.team, self.screen)
self.team.reset()
if self.party.status():
nex = self.map.neighbours(self.party.node)
self.party.move_party(nex[rollDie(len(nex))-1])
if self.party.node >= 19:
self.change_mode(Modes.GameOver)
else:
self.change_mode(Modes.Map)
else:
win = True
self.change_mode(Modes.GameOver)
#Drawn if in GameOver mode
if self.mode == Modes.GameOver:
if win:
pygame.draw.rect(self.screen,(50,50,200),pygame.Rect(0,0,self.width,self.height))
wintext = BigFont.render("YOU WIN!", True, WHITE)
self.screen.blit(wintext, (200, 200))
else:
pygame.draw.rect(self.screen,(200,50,50),pygame.Rect(0,0,self.width,self.height))
losetext = BigFont.render("Sorry, You Lost", True, WHITE)
self.screen.blit(losetext, (50, 200))
#refresh screen
pygame.display.update()
def test_returntypes(Graph: GameGraph):
assert isinstance(Graph.as_json(), str)
assert Graph.truncate_to_roots() == None
for v in sample(Graph.vertices,
k=min(MAX_VERTEX_CHECK, len(Graph.vertices))):
assert isinstance(Graph.children_at(v, autoexpand=True), tuple)
assert isinstance(Graph.edges_at(v), set)
assert isinstance(Graph.equivalenceclass_of(v), set)
assert isinstance(Graph.representative_of(v), type(v))
assert isinstance(Graph.score_at(v), float)
if not Graph.open_at(v):
assert isinstance(Graph.terminal_at(v), bool)
assert isinstance(Graph.numpify(v), ndarray)
assert isinstance(Graph.deepcopy(), Graph.__class__)
def test_numpify_unnumpify(Graph: GameGraph):
for v in Graph.vertices:
assert Graph.unnumpify(Graph.numpify(v)) == v
def runExploration(numGames):
history = GameGraph()
metaHistory = GameGraph()
print('Start exploration, numGame:%i' % (numGames))
for i in tqdm(range(numGames)):
seed = random.randrange(999999)
random.seed(seed)
session = TriadGameSession()
session.seed = seed
state, metaState = session.getState()
history.storeMatchStart(state)
metaHistory.storeMatchStart(metaState)
while not session.isFinished():
session.playRandomMove()
state, metaState = session.getState()
history.storeMatchStep(state)
metaHistory.storeMatchStep(metaState)
print('Exploration finished, history:%s, meta:%s' %
(history.descState(), metaHistory.descState()))