go
Kiejtés
- IPA: [ ˈɡo]
Főnév
go
- (játékok) Egy kínai eredetű (wéiqí) Japánból nyugatra is elterjedt táblás játék, szellemi sport, magyarul helyesírása: gó
Go játék leírása
Definíció
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.
Játékszabályok
1. A játékosok és a tábla
- A játékot általában egy 19×19-es táblán játsszák, de kisebb méretű táblák is használatosak (pl. 9×9 vagy 13×13).
- A két játékos fekete és fehér kövekkel játszik.
2. A lépések menete
- A játékosok felváltva helyeznek el egy-egy követ a tábla üres pontjaira (vonalak metszéspontjai).
- A fekete kezdi a játékot.
3. A területfoglalás
- A játékos célja, hogy a lehető legnagyobb területet foglalja el a táblán.
- A területet a játékos kövei által körbezárt üres pontok alkotják.
4. Elfogott kövek
- Egy követ vagy kőcsoportot akkor lehet elfogni, ha az összes „szabadságát” (szomszédos üres pontjait) elveszti.
- Az elfogott köveket eltávolítják a tábláról.
5. Tiltott lépések
- Ko szabály: Egy játékos nem léphet olyan helyre, amely azonnal megismétli az előző állapotot.
- Önmegsemmisítés: Egy játékos nem helyezhet követ olyan helyre, amely azonnal elveszti az összes szabadságát, kivéve, ha ezzel elfog egy ellenfél-követ.
6. Játék vége
- A játék akkor ér véget, amikor mindkét játékos passzol egymás után.
- A pontszámot a játékos által körbezárt terület és az elfogott kövek alapján számolják ki.
Go Python Implementáció Ötletek
1. Tábla reprezentáció
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 = [
[0, 0, 0, 0],
[0, 1, 2, 0],
[0, 2, 1, 0],
[0, 0, 0, 0]
]
2. Alapvető osztály a játékhoz
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 = [[0 for _ in range(size)] 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[x][y] == 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[x][y] = 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()
3. Szabadságok számítása
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[x][y] == 0:
liberties += 1
return
if board[x][y] != board[start[0]][start[1]]:
return
# Szomszédos pontok
directions = [(0, 1), (1, 0), (0, -1), (-1, 0)]
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 = [
[0, 0, 0, 0],
[0, 1, 2, 0],
[0, 2, 1, 0],
[0, 0, 0, 0]
]
liberties = get_liberties(board, 1, 1)
print("Szabadságok száma:", liberties)
4. Kövek elfogása
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[x][y] == 0:
liberties += 1
return
if board[x][y] != board[start[0]][start[1]]:
return
directions = [(0, 1), (1, 0), (0, -1), (-1, 0)]
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[px][py] = 0
# Példa
board = [
[0, 0, 0, 0],
[0, 1, 2, 0],
[0, 2, 1, 0],
[0, 0, 0, 0]
]
remove_captured_stones(board, 1, 2)
for row in board:
print(row)
Bonyolultabb Implementációk
- Játékállapot értékelése:
- Körbezárt területek meghatározása.
- Ko szabály implementációja:
- Tároljuk a korábbi állapotokat, hogy elkerüljük az ismétléseket.
- AI implementáció:
- Monte-Carlo Tree Search (MCTS): Nagyon hatékony algoritmus Go játékban.
- Heurisztikák: Az egyszerű értékelési függvények használata.
Alkalmazások
- Szórakoztatás: Emberi játék Go ellenfelekkel.
- AI fejlesztés: Stratégiai döntéshozó algoritmusok tesztelése.
- Oktatás: Programozás és algoritmusok tanítása.
Összegzés
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.
Fordítások
Kiejtés
Ige
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)
Vonzatok
Szókapcsolatok
Főnév
go (tsz. gos)
(го)
Melléknév
go
Etimológia
Rövidített alak, lásd a gol melléknevet.