go
A Go egy kétszemélyes stratégiai táblajáték, amelynek célja, hogy a játékosok köveik segítségével területet foglaljanak a táblán. A játék a kínai eredetű táblajátékok egyik legrégebbi formája, és széles körben ismert a mély stratégiai elemeiről.
A Go tábla egy 2D-s mátrixként ábrázolható, ahol: - 0 jelöli az üres mezőt. - 1 jelöli a fekete követ. - 2 jelöli a fehér követ.
Példa:
board = [
,
,
,
]
Egy egyszerű osztály, amely kezeli a tábla állapotát és a lépéseket:
class GoGame:
def __init__(self, size=19):
self.size = size
self.board = for _ in range(size)]
self.current_player = 1 # 1: fekete, 2: fehér
def print_board(self):
for row in self.board:
print(" ".join(str(cell) for cell in row))
print()
def is_valid_move(self, x, y):
"""
Ellenőrzi, hogy egy lépés érvényes-e.
"""
if 0 <= x < self.size and 0 <= y < self.size and self.board == 0:
return True
return False
def place_stone(self, x, y):
"""
Elhelyez egy követ a táblán, ha a lépés érvényes.
"""
if not self.is_valid_move(x, y):
print("Érvénytelen lépés!")
return False
self.board = self.current_player
self.current_player = 3 - self.current_player # Váltás a másik játékosra
return True
# Példa használat
game = GoGame(size=9)
game.print_board()
game.place_stone(4, 4)
game.print_board()
game.place_stone(4, 5)
game.print_board()
A szomszédos üres mezők (szabadságok) számítására:
def get_liberties(board, x, y):
"""
Megszámolja egy kő szabadságait.
"""
size = len(board)
visited = set()
liberties = 0
def dfs(x, y):
nonlocal liberties
if (x, y) in visited:
return
visited.add((x, y))
if board == 0:
liberties += 1
return
if board != board]]:
return
# Szomszédos pontok
directions =
for dx, dy in directions:
nx, ny = x + dx, y + dy
if 0 <= nx < size and 0 <= ny < size:
dfs(nx, ny)
start = (x, y)
dfs(x, y)
return liberties
# Példa
board = [
,
,
,
]
liberties = get_liberties(board, 1, 1)
print("Szabadságok száma:", liberties)
Ha egy kő vagy kőcsoport szabadságai elfogynak, eltávolítjuk őket a tábláról:
def remove_captured_stones(board, x, y):
"""
Eltávolítja a szabadság nélküli köveket a tábláról.
"""
size = len(board)
visited = set()
group =
liberties = 0
def dfs(x, y):
nonlocal liberties
if (x, y) in visited:
return
visited.add((x, y))
group.append((x, y))
if board == 0:
liberties += 1
return
if board != board]]:
return
directions =
for dx, dy in directions:
nx, ny = x + dx, y + dy
if 0 <= nx < size and 0 <= ny < size:
dfs(nx, ny)
start = (x, y)
dfs(x, y)
if liberties == 0:
for px, py in group:
board = 0
# Példa
board = [
,
,
,
]
remove_captured_stones(board, 1, 2)
for row in board:
print(row)
A Go játék szabályai egyszerűek, de a játék stratégiai mélysége miatt rendkívül izgalmas projekt lehet egy programozónak. Pythonban a Go játék megvalósítása remek kihívás, amely a mátrixkezelést, rekurziót és játéklogikát kombinálja. A fejlettebb AI megközelítések, mint a MCTS, tovább növelhetik a projekt kihívásait és tanulságait.
go (alapjelen, egyes szám harmadik személy goes, folyamatos melléknévi igenév going, második alak went vagy (archaic) yode, harmadik alak gone)
go (tsz. gos)
(го)
go
Rövidített alak, lásd a gol melléknevet.