ankh-ppo / ankh_map.py
heitorvcm's picture
Ankh PPO agent (round 40) + rules, encoder and local game
12c9315 verified
Raw History Blame Contribute Delete
20.2 kB
"""
ankh_map.py - Mapa e cenarios do Ankh em forma extensa (para editar a mao).
LAYOUT
------
Hexagonos "flat-top" organizados em COLUNAS, exatamente como no seu codigo:
coordenada publica = (col, linha_na_coluna), ambas a partir de 0,
linha_na_coluna 0 = topo da coluna.
As colunas ficam centralizadas na vertical, entao colunas com menos celulas
sao deslocadas (COLUMN_COUNTS [8,9,10,9,...] -> colunas de 9 ficam meia
celula abaixo das de 10; as de 8 sobram 1 celula em cima e 1 embaixo).
Internamente usa-se "coordenadas dobradas": r2 = 2*linha + (max - n_da_coluna).
COMO EDITAR
-----------
1) GRID_COLUMNS: uma string por coluna, uma letra por celula, de cima p/ baixo.
F fertil D deserto W agua
O tamanho de cada string define quantas celulas a coluna tem.
2) RIVER: lados com rio, como (col, linha, direcao).
direcoes: N, S, NE, SE, NW, SW
(c, r, 'SE') = rio no lado sudeste da celula (c, r), isto e, entre ela e a
vizinha a sudeste. Declare cada lado uma vez.
Confira o numero de regioes que o validador imprime: ele e o teste de que
o rio realmente separa (vazamento por um lado faltando e facil de cometer).
3) SCENARIOS: monumentos, figuras, camelos e Conflict Order iniciais.
Rode `python ankh_map.py` para validar e ver o mapa em ASCII.
"""
from collections import deque
import numpy as np
# ---------------------------------------------------------------------------
# 1) GRADE POR COLUNAS (traduzida das listas water_hexes / fertile_hexes)
# ATENCAO: no codigo original o deserto vinha de _initialize_desert();
# aqui assumi "deserto = toda celula que nao e agua nem fertil".
# ---------------------------------------------------------------------------
GRID_COLUMNS = [
"FFDDDDDD", # col 0 (8)
"FFFDDDDDD", # col 1 (9)
"FFFFDWWDDD", # col 2 (10)
"FFFFDDWDD", # col 3 (9)
"WFFFFDWFFF", # col 4 (10)
"WFFFFFFFF", # col 5 (9)
"WFFFFFFDDD", # col 6 (10)
"WFFFDDDDD", # col 7 (9)
"WFFFDDDWDD", # col 8 (10)
"WFFWDDWDD", # col 9 (9)
"WFDWWWWW", # col 10 (8)
]
# Deslocamento vertical de cada coluna em meias celulas. None = centralizar.
COLUMN_OFFSET_HALF = None
# ---------------------------------------------------------------------------
# 2) RIOS: (col, linha, direcao) -- preencher
# ---------------------------------------------------------------------------
RIVER = [
(0, 0, 'NE'),
(0, 0, 'SE'), # estava 'E' na sua lista (nao existe em flat-top); lido como SE
(0, 1, 'NE'),
(1, 1, 'S'),
(2, 2, 'SW'),
(2, 2, 'S'),
(3, 2, 'SW'),
(3, 2, 'S'),
(4, 3, 'SW'),
(4, 3, 'S'),
(4, 7, 'NE'),
(4, 7, 'SE'),
(4, 8, 'NE'),
(4, 8, 'SE'),
(4, 9, 'NE'),
(4, 9, 'SE'), # na borda do mapa: ignorado pelo carregador
(5, 3, 'S'),
(5, 3, 'SW'),
(5, 3, 'SE'),
(5, 4, 'NE'),
(5, 4, 'SE'),
(5, 5, 'NE'),
(5, 5, 'SE'),
(5, 5, 'S'),
(6, 3, 'S'),
(6, 3, 'SE'),
(7, 2, 'S'),
(7, 2, 'SE'),
(8, 2, 'S'),
(8, 2, 'SE'),
(9, 1, 'S'),
(9, 1, 'SE'),
]
# ---------------------------------------------------------------------------
# 3) CENARIOS
# ---------------------------------------------------------------------------
SCENARIOS = {
"basic_2p": {
"n_players": 2,
# (tipo, (col, linha), dono) tipo: 'obelisk' | 'temple' | 'pyramid'
# dono: None (neutro) ou 0..n_players-1
"monuments": [
("obelisk", (0, 4), 0),
("pyramid", (1, 8), None),
("temple", (3, 0), None),
("pyramid", (5, 2), None),
("temple", (5, 6), 1),
("obelisk", (8, 1), None),
("pyramid", (8, 5), None),
],
# jogador -> lista de (tipo, (col, linha)) tipo: 'god' | 'warrior'
"figures": {
0: [
("god", (1, 5)),
("warrior", (1, 4)),
],
1: [
("god", (6, 7)),
("warrior", (6, 6)),
],
},
# lados com camelo no inicio: (col, linha, direcao)
"camels": [],
# numero do Conflict Order token -> qualquer celula (col, linha) da regiao
"conflict_order": {
1: (0, 0),
2: (5, 6),
3: (1, 0),
},
},
"basic_3p": {
"n_players": 3,
"monuments": [
("pyramid", (0, 2), None),
("obelisk", (2, 7), None),
("pyramid", (3, 1), 2),
("temple", (4, 5), 0),
("temple", (5, 3), None),
("obelisk", (5, 6), 1),
("pyramid", (7, 3), None),
("obelisk", (8, 1), None),
("temple", (9, 5), None),
],
"figures": {
0: [
("god", (3, 4)),
("warrior", (4, 4)),
],
1: [
("god", (6, 7)),
("warrior", (6, 6)),
],
2: [
("god", (4, 2)),
("warrior", (3, 2)),
],
},
"camels": [],
"conflict_order": {
1: (0, 0),
2: (5, 6),
3: (1, 0),
},
},
"basic_4p": {
"n_players": 4,
"monuments": [
("pyramid", (0, 6), None),
("obelisk", (1, 4), None),
("temple", (2, 4), 0),
("temple", (3, 1), None),
("temple", (4, 8), 1),
("obelisk", (5, 3), 2),
("pyramid", (5, 5), None),
("temple", (6, 8), None),
("pyramid", (7, 5), 3),
("pyramid", (8, 2), None),
("obelisk", (8, 3), None),
],
"figures": {
0: [
("god", (1, 3)),
("warrior", (2, 3)),
],
1: [
("god", (3, 7)),
("warrior", (4, 7)),
],
2: [
("god", (5, 2)),
("warrior", (4, 3)),
],
3: [
("god", (7, 4)),
("warrior", (6, 5)),
],
},
"camels": [(0, 2, "S"),
(1, 3, "SW"),
(1, 3, "S"),
(2, 4, "SW"),
],
"conflict_order": {
1: (0, 0),
2: (0, 3),
3: (1, 0),
4: (5, 6),
},
},
"basic_5p": {
"n_players": 5,
"monuments": [
("temple", (1, 2), 0),
("obelisk", (1, 4), None),
("pyramid", (1, 7), 4),
("obelisk", (2, 0), None),
("temple", (4, 8), None),
("pyramid", (5, 3), 3),
("pyramid", (5, 4), None),
("temple", (6, 1), None),
("pyramid", (6, 6), None),
("obelisk", (6, 7), None),
("obelisk", (8, 3), 1),
("temple", (8, 9), 2),
],
"figures": {
0: [
("god", (1, 3)),
("warrior", (2, 3)),
],
1: [
("god", (8, 4)),
("warrior", (7, 3)),
],
2: [
("god", (8, 8)),
("warrior", (7, 8)),
],
3: [
("god", (4, 3)),
("warrior", (5, 2)),
],
4: [
("god", (1, 6)),
("warrior", (2, 7)),
],
},
"camels": [(0, 2, "S"),
(1, 3, "SW"),
(1, 3, "S"),
(2, 4, "SW"),
(5, 6, "S"),
(5, 6, "SE"),
(6, 6, "S"),
(6, 6, "SE"),
(7, 5, "S"),
(8, 6, "SW"),
],
"conflict_order": {
1: (0, 0),
2: (5, 6),
3: (5, 7),
4: (1, 0),
5: (0, 3),
},
},
}
# ===========================================================================
# Geometria (flat-top, coordenadas dobradas internamente)
# ===========================================================================
AXIAL_DIRS = [(1, 0), (1, -1), (0, -1), (-1, 0), (-1, 1), (0, 1)]
# (d_r2, d_col) em coordenadas dobradas
_DELTA = {"N": (-2, 0), "S": (2, 0), "NE": (-1, 1), "SE": (1, 1), "NW": (-1, -1), "SW": (1, -1)}
DIRECTIONS = tuple(_DELTA)
TERRAIN_CHARS = {"F", "D", "W"}
MONUMENT_TYPES = {"obelisk", "temple", "pyramid"}
FIGURE_TYPES = {"god", "warrior"}
def nbrs(ax):
"""Vizinhas em coordenadas axiais (funciona tambem fora do mapa)."""
return {(ax[0] + dq, ax[1] + dr) for dq, dr in AXIAL_DIRS}
def edge(a, b):
"""Lado de hexagono entre duas celulas (coordenadas axiais)."""
return frozenset((a, b))
def components(land, blocked_edges):
"""Regioes: componentes conexos de celulas de terra, sem cruzar rio/camelo."""
seen, comps = set(), []
for s in land:
if s in seen:
continue
stack, comp = [s], {s}
seen.add(s)
while stack:
u = stack.pop()
for v in nbrs(u) & land:
if v not in seen and edge(u, v) not in blocked_edges:
seen.add(v)
comp.add(v)
stack.append(v)
comps.append(frozenset(comp))
return comps
# ===========================================================================
# Tabuleiro
# ===========================================================================
class Board:
"""Estrutura estatica do tabuleiro.
terrain dict (col,linha) -> 'F'|'D'|'W'
cells lista ordenada de (col,linha); indice = id da celula
idx dict (col,linha) -> indice
land, water conjuntos de coords AXIAIS (para regioes e camelos)
river_edges frozenset de lados (frozenset de 2 coords axiais)
move_dist np.int8 [N,N]: distancia de movimento (atravessa tudo no mapa)
axial(rc) (col,linha) -> coord axial
step(rc, d) vizinha de rc na direcao d, ou None se fora do mapa
"""
def __init__(self, grid_columns, offsets_half, river, warnings):
self.counts = [len(s) for s in grid_columns]
self.ncols = len(grid_columns)
self.warnings = warnings
self.terrain = {}
self._pos, self._inv = {}, {}
for c, col in enumerate(grid_columns):
for r, ch in enumerate(col):
if ch not in TERRAIN_CHARS:
raise ValueError(f"caractere invalido {ch!r} em {(c, r)}")
r2 = 2 * r + offsets_half[c]
if (r2 + c) % 2:
raise ValueError(
f"coluna {c}: deslocamento incompativel (paridade); "
"colunas vizinhas precisam alternar meia celula")
self.terrain[(c, r)] = ch
self._pos[(c, r)] = (r2, c)
self._inv[(r2, c)] = (c, r)
self.max_r2 = max(p[0] for p in self._pos.values())
self.cells = sorted(self.terrain)
self.idx = {rc: i for i, rc in enumerate(self.cells)}
self.land = {self.axial(rc) for rc, t in self.terrain.items() if t != "W"}
self.water = {self.axial(rc) for rc, t in self.terrain.items() if t == "W"}
edges = set()
for (c, r, d) in river:
if d not in DIRECTIONS:
raise ValueError(f"direcao invalida {d!r} em rio {(c, r, d)}")
a, b = (c, r), self.step((c, r), d)
if a not in self.terrain:
raise ValueError(f"rio {(c, r, d)}: celula {a} nao existe")
if b is None:
# lado na borda do mapa: nao separa nada, so ignorar
warnings.append(f"rio {(c, r, d)} fica na borda do mapa (ignorado)")
continue
if "W" in (self.terrain[a], self.terrain[b]):
warnings.append(f"rio {(c, r, d)} toca agua; rios normalmente separam terra de terra")
edges.add(edge(self.axial(a), self.axial(b)))
self.river_edges = frozenset(edges)
self.move_dist = self._distances()
def axial(self, rc):
r2, c = self._pos[rc]
return (c, (r2 - c) // 2)
def step(self, rc, d):
r2, c = self._pos[rc]
dr, dc = _DELTA[d]
return self._inv.get((r2 + dr, c + dc))
def _distances(self):
n = len(self.cells)
dist = np.full((n, n), 99, dtype=np.int8)
for s in range(n):
dist[s, s] = 0
q = deque([self.cells[s]])
while q:
u = q.popleft()
du = dist[s, self.idx[u]]
for d in DIRECTIONS:
v = self.step(u, d)
if v is not None and dist[s, self.idx[v]] == 99:
dist[s, self.idx[v]] = du + 1
q.append(v)
return dist
def selfcheck(self):
"""Vizinhas por direcao == vizinhas axiais (garante a geometria)."""
for rc in self.cells:
got = {self.axial(v) for v in (self.step(rc, d) for d in DIRECTIONS) if v}
want = nbrs(self.axial(rc)) & {self.axial(x) for x in self.cells}
assert got == want, f"geometria inconsistente em {rc}"
def build_board(grid_columns=None, river=None, offsets_half=None):
grid_columns = GRID_COLUMNS if grid_columns is None else grid_columns
river = RIVER if river is None else river
offsets_half = COLUMN_OFFSET_HALF if offsets_half is None else offsets_half
if not grid_columns or not any(grid_columns):
raise ValueError("GRID_COLUMNS vazio")
if offsets_half is None:
m = max(len(s) for s in grid_columns)
offsets_half = [m - len(s) for s in grid_columns]
return Board(grid_columns, offsets_half, river, [])
# ===========================================================================
# Cenario
# ===========================================================================
class Setup:
"""Estado inicial validado.
monuments : lista de (tipo, (col,linha), dono)
figures : dict jogador -> lista de (tipo, (col,linha))
camel_edges: frozenset de lados (axiais)
regions : lista de frozensets de coords axiais
region_of : dict coord axial -> indice da regiao
conflict_order: dict indice da regiao -> numero do token
errors : lista de mensagens de erro
"""
def load_scenario(board, sc):
errors = []
n_players = sc["n_players"]
camel_edges = set()
for (c, r, d) in sc.get("camels", []):
a, b = (c, r), board.step((c, r), d) if (c, r) in board.terrain else None
if b is None or "W" in (board.terrain[a], board.terrain[b]):
errors.append(f"camelo {(c, r, d)} deve ficar entre duas celulas de terra")
continue
camel_edges.add(edge(board.axial(a), board.axial(b)))
regions = components(board.land, board.river_edges | camel_edges)
region_of = {ax: i for i, comp in enumerate(regions) for ax in comp}
occupied = {}
def occupy(rc, what):
if rc not in board.terrain:
errors.append(f"{what} em {rc}: fora do mapa")
elif board.terrain[rc] == "W":
errors.append(f"{what} em {rc}: celula de agua")
elif rc in occupied:
errors.append(f"{what} em {rc}: ja ocupada por {occupied[rc]}")
else:
occupied[rc] = what
monuments = []
for (kind, rc, owner) in sc.get("monuments", []):
if kind not in MONUMENT_TYPES:
errors.append(f"tipo de monumento invalido {kind!r}")
if owner is not None and not (0 <= owner < n_players):
errors.append(f"dono invalido {owner} no monumento em {rc}")
occupy(rc, f"monumento {kind}")
monuments.append((kind, rc, owner))
figures = {}
for p, figs in sc.get("figures", {}).items():
if not (0 <= p < n_players):
errors.append(f"jogador invalido {p} em figures")
continue
figures[p] = list(figs)
n_god = sum(1 for k, _ in figs if k == "god")
n_war = sum(1 for k, _ in figs if k == "warrior")
if n_god > 1:
errors.append(f"jogador {p} tem {n_god} deuses")
if n_war > 6:
errors.append(f"jogador {p} tem {n_war} guerreiros (max 6)")
for kind, rc in figs:
if kind not in FIGURE_TYPES:
errors.append(f"tipo de figura invalido {kind!r}")
occupy(rc, f"figura {kind} do jogador {p}")
conflict_order = {}
tokens = sc.get("conflict_order", {})
for token, rc in tokens.items():
if rc not in board.terrain or board.terrain[rc] == "W":
errors.append(f"token {token} em {rc}: nao e celula de terra")
continue
ri = region_of[board.axial(rc)]
if ri in conflict_order:
errors.append(f"regiao de {rc} recebeu mais de um token")
conflict_order[ri] = token
missing = [i for i in range(len(regions)) if i not in conflict_order]
if missing:
errors.append(f"regioes sem Conflict Order token: {missing}")
s = Setup()
s.monuments, s.figures = monuments, figures
s.camel_edges, s.regions, s.region_of = frozenset(camel_edges), regions, region_of
s.conflict_order, s.errors = conflict_order, errors
return s
# ===========================================================================
# Visualizacao ASCII
# ===========================================================================
def render(board, setup=None, show_regions=False, labels=False):
"""Mapa em layout escalonado (uma linha de texto por meia celula).
Cada celula ocupa 4 colunas: terreno, simbolo, dono. Ex.: 'FT0 '.
Simbolos: O/T/P = obelisco/templo/piramide (dono '-' = neutro);
g/w = deus/guerreiro (dono = jogador).
labels=True mostra 'col:linha' de cada celula (util para escrever rios).
show_regions=True troca o terreno pela letra da regiao."""
overlay = {}
if setup is not None:
for kind, rc, owner in setup.monuments:
overlay[rc] = kind[0].upper() + ("-" if owner is None else str(owner))
for p, figs in setup.figures.items():
for kind, rc in figs:
overlay[rc] = ("g" if kind == "god" else "w") + str(p)
w = 6 if labels else 4
out = [" " + "".join(f"{c:<{w}d}" for c in range(board.ncols))]
for r2 in range(board.max_r2 + 1):
line = f"{r2 / 2:>4.1f} "
for c in range(board.ncols):
rc = board._inv.get((r2, c))
if rc is None:
line += " " * w
elif labels:
line += f"{rc[0]}:{rc[1]}".ljust(w)
else:
ch = board.terrain[rc]
if show_regions and setup is not None and ch != "W":
ch = chr(ord("A") + setup.region_of[board.axial(rc)] % 26)
line += ch + overlay.get(rc, " ") + " "
out.append(line.rstrip())
return "\n".join(out)
def validate_all(verbose=True):
try:
board = build_board()
board.selfcheck()
except (ValueError, AssertionError) as e:
print("ERRO:", e)
return False
for w in board.warnings:
print("AVISO:", w)
n_land, n_water = len(board.land), len(board.water)
print(f"{len(board.cells)} celulas ({n_land} terra, {n_water} agua); "
f"{len(board.river_edges)} lados de rio")
ok = True
for name, sc in SCENARIOS.items():
setup = load_scenario(board, sc)
sizes = sorted((len(r) for r in setup.regions), reverse=True)
if verbose:
print(f"\n=== {name} ===")
print(f"{len(setup.regions)} regioes, tamanhos (so terra): {sizes}")
print(render(board, setup))
print("\nRegioes:")
print(render(board, setup, show_regions=True))
for e in setup.errors:
print("ERRO:", e)
ok = False
return ok
if __name__ == "__main__":
raise SystemExit(0 if validate_all() else 1)