We can set any size for the game table, and many players for the game

• AI and the list of winning combinations for players are adjusted automatically

We will use this. Instead of the classic 3×3 table — let's create 7×7, and 3 players Let the bots play with each other this time. Let's look at it.

from titato.client import GameConsole
from titato.core.player import Player, Players, Symbol
from titato.core.table import Table, TableParam


if __name__ == "__main__":
    p1 = Player(name="PETROS_ANDROID:1", symbol=Symbol('X'), role=Player.Role.ANDROID)
    p2 = Player(name="AMIGOS_ANDROID:2", symbol=Symbol('O'), role=Player.Role.ANDROID)
    p3 = Player(name="GENTOS_ANDROID:3", symbol=Symbol('K'), role=Player.Role.ANDROID)

    # p4 = Player(name="PLAYER", symbol=Symbol('P'), role=Player.Role.USER)

    players = Players(players=[p1, p2, p3])
    table = Table(param=TableParam(ROW=7, COLUMN=7, COMBINATION=5))

    game = GameConsole(players=players, table=table)
    game.start_game()

WIN: PETROS_ANDROID:1 < X > | COMB: < ((1, 1), (2, 2), (3, 3), (4, 4), (5, 5)) >
+-----+---+---+---+---+---+---+---+
| ↓/→ | 0 | 1 | 2 | 3 | 4 | 5 | 6 |
+-----+---+---+---+---+---+---+---+
|  0: | O | * | * | * | K | X | K |
|  1: | K | X | * | * | O | * | X |
|  2: | X | K | X | O | K | O | X |
|  3: | K | O | K | X | X | K | O |
|  4: | K | O | X | X | X | O | X |
|  5: | O | O | K | O | O | X | X |
|  6: | * | * | O | K | * | K | K |
+-----+---+---+---+---+---+---+---+

PEACE: ALL USED CELLS
+-----+---+---+---+---+---+---+---+
| ↓/→ | 0 | 1 | 2 | 3 | 4 | 5 | 6 |
+-----+---+---+---+---+---+---+---+
|  0: | X | K | K | O | O | O | X |
|  1: | K | X | X | K | X | O | K |
|  2: | X | K | O | O | O | X | K |
|  3: | O | X | K | K | O | K | X |
|  4: | X | O | K | O | O | X | O |
|  5: | X | X | O | X | X | K | K |
|  6: | K | K | X | O | K | O | X |
+-----+---+---+---+---+---+---+---+

WIN: AMIGOS_ANDROID:2 < O > | COMB: < ((3, 1), (3, 2), (3, 3), (3, 4), (3, 5)) >
+-----+---+---+---+---+---+---+---+
| ↓/→ | 0 | 1 | 2 | 3 | 4 | 5 | 6 |
+-----+---+---+---+---+---+---+---+
|  0: | * | * | * | * | K | * | * |
|  1: | * | * | * | * | K | * | * |
|  2: | * | X | * | * | * | * | * |
|  3: | * | O | O | O | O | O | X |
|  4: | * | * | * | * | K | * | * |
|  5: | * | * | * | * | * | * | * |
|  6: | K | X | X | X | O | X | K |
+-----+---+---+---+---+---+---+---+

If you want to load the processor with a hundred bots in a 1000×1000 field — no one will interfere!

Let's go further.

- Take a step. game.step:

def step(self, index_row: int, index_column: int, player: PlayerBase)

# input
game.step(index_row=1, index_column=0, player=p2)  
game.step(index_row=1, index_column=2, player=p2)  
game.step(index_row=1, index_column=1, player=p2) 

# output
+-----+---+---+---+   ->   +-----+---+---+---+   ->   +-----+---+---+---+  
| ↓/→ | 0 | 1 | 2 |   ->   | ↓/→ | 0 | 1 | 2 |   ->   | ↓/→ | 0 | 1 | 2 |
+-----+---+---+---+   ->   +-----+---+---+---+   ->   +-----+---+---+---+
|  0: | * | * | * |   ->   |  0: | * | * | * |   ->   |  0: | * | * | * |
|  1: | O | * | * |   ->   |  1: | O | * | O |   ->   |  1: | O | O | O |
|  2: | * | * | * |   ->   |  2: | * | * | * |   ->   |  2: | * | * | * |
+-----+---+---+---+   ->   +-----+---+---+---+   ->   +-----+---+---+---+

The function sets the player symbol player.symbol in the cell at the specified indices. After successful installation, the player.count_steps counter is incremented by +1, and game.table.count_free_cells is decreased by -1

Note:

• If the transferred indexes do not match the possible ones in the table — an error TableIndexError
• If you try to set a new symbol on an already occupied cell — error CellAlreadyUsedError

- Get the result. game.result:

def result(self, player: PlayerBase) -> GameStateT

Let's check the result of our previous 3 steps (in the block above), we expect winnings

# input
res = game.result(player=p2)
    
match res.code:
    case ResultCode.NO_RESULT:
        print('STATUS: NO RESULT')
    case ResultCode.WINNER:
        print(f'STATUS: WINNER. Player: {res.win_player.name}, Win comb: {res.win_combination}')
    case ResultCode.ALL_CELLS_USED:
        print('STATUS: DRAW')

# output
STATUS: WINNER. Player: BOGDAN_PLAYER, Win comb: ((1, 0), (1, 1), (1, 2))

For a given player, the function performs 2 checks:

• Check for winnings. Compares player moves with winning combinations game.table.combinations
• Checking for a tie. Checks with free cell count game.table.count_free_cells

When one of the two probabilities is valid, the game.set_winner or game.set_draw method is automatically called
After checks and possible modifications — returns the object: game.game_state

Note:

• assert res == game.game_state # True
• To check that one of the triggers that logically ends the game worked — call the game_state method: .is_finished, if True — you have a win or a draw. You can also use .is_winner or .is_draw.
  For more details, see GameState section

- Take a step and return the result. game.step_result:

def step_result(self, index_row: int, index_column: int, player: PlayerBase) -> GameStateT

• Unifying function. Replaces the successive call of game.step and game.result, returns the result

- AI. Get the index of the best cell for the player. game.ai_get_step:

def ai_get_step(self, player: PlayerBase) -> CellIndex

AI returns a tuple with the two indices (index_row: int, index_column: int) of the cell

• For more details, see AI section

- AI. Make a move for a player. game.ai_step:

def ai_step(self, player: PlayerBase)

• Unifying function. Replaces the successive call of game.ai_get_step and game.step

- AI. Make a move for the player and return the result. game.ai_step_result:

def ai_step_result(self, player: PlayerBase) -> GameStateT

• Unifying function. Replaces the successive call of game.ai_get_step and game.step_result, returns the result

- Set the winner. game.set_winner:

def set_winner(self, player: PlayerBase, win_combination)

Updates the game result in the game.game_state object, replacing game.game_state.code with ResultCode.WINNER, and adds the winning result to the game.game_state.win_player and game.game_state.win_combination fields

Note:

• This method is automatically called in the game.result method if the win trigger fires
• The result is updated via the game.game_result.update method

- Set a draw game.set_draw:

def set_draw(self)

Updates the game result in the game.game_state, object, replacing game.game_state.code with ResultCode.ALL_CELLS_USED

Note:

• This method is automatically called in the game.result method if a draw trigger fires
• The result is updated via the game.game_result.update method

table = game.table

- Get a playing field. table.game_field:

@property
def game_field(self) -> GameFieldType

Returns a 2D list of the playing field

Note:

• It is also available in: game.game_field

- Get a list of winning combinations. table.combinations:

@property
def combinations(self) -> CombsType

Returns a list of all winning combinations for this table

• Combinations are created automatically according to the parameters of the table, or manually passed to the constructor of the Table class instance

- Get the number of free cells. table.count_free_cells:

@property
def count_free_cells(self) -> int

Returns the number of free cells in the game filed

- Set the symbol in the cell. table.set_symbol_cell:

@property
def set_symbol_cell(self, index_row: int, index_column: int, symbol: SymbolBase)

Sets the passed character at the specified indices of the playing field. Decreases the number of free cells by -1

Note:

• It is this method that is automatically called in game.step

players = game.players

- Get a list of players. players.player_list:

@property
def players_list(self) -> list[PlayerT]:

Returns a list of all players

Note:

• This list changes after using the players.shuffle_players method

- Get the current player. players.current_player:

@property
def current_player(self) -> PlayerT

Returns the current player from the queue

- Set and get the next player. players.set_get_next_player:

def set_get_next_player(self) -> PlayerT

Replaces the current player with the next player in the queue and returns it

Note:

• After that, this player is available in the `players.current_player' method

- Shuffle the players list. players.shuffle_players:

def shuffle_players(self)

Shuffles the player list and replaces the current queue with a new one.

Note:

• The first player from the new queue will be set as the current one, and is available in players.current_player

# titato.core.player.player.py

class Role(Enum):
    USER = 1
    ANDROID = 2

player = game.current_player

- Get a role.. player.role:

@property
def role(self) -> Role

- Get a symbol. player.symbol:

@property
def symbol(self) -> SymbolBase

Returns an object of class Symbol of the player

- Get the player step count player.count_steps:

@property
def count_steps(self) -> int

Returns the number of steps taken by the player

- Is this an android? player.is_android:

@property
def is_android(self) -> bool

Returns True if the player has role Role.ANDROID Otherwise — False

- Is this a user? player.is_user:

@property
def is_user(self) -> bool

Returns True if the player has role Role.USER
Otherwise — False

- Add step for player. player.add_count_step:

def add_count_step(self)

Adds +1 to the player's step counter

Note:

• This method is automatically called in table.set_symbol_cell

# titato.core.game.result.py

class ResultCode(Enum):
    NO_RESULT = 0
    ALL_CELLS_USED = 1
    WINNER = 2

game_state = game.game_state

- Get game status code. game_result.code:

@property
def code(self) -> ResultCode

Returns the status code of the game

Note:

• The initial value is set to Result Code.NO_RESULT

- Get the winning player. game_result.win_player:

@property
def win_player(self) -> Optional[PlayerBase]

Returns the winning player if it was added by the game_result.update method

- Get a winning combination. game_result.win_combination:

@property
def win_combination(self) -> Optional[CombType]

Returns the winning combination if it was added by the game_result.update method

- Game is over? game_result.is_finished:

@property
def is_finished(self) -> bool

Returns True if game_result.code is ResultCode.ALL_CELLS_USED or ResultCode.WINNER
Otherwise — False

- Is the game still on? game_result.is_continues:

@property
def is_continues(self) -> bool

Returns True if game_result.code is ResultCode.NO_RESULT
Otherwise — False

- Is there a win? game_result.is_winner:

@property
def is_winner(self) -> bool

Returns True if game_result.code is ResultCode.WINNER
Otherwise — False

- Is there a draw? game_result.is_draw:

@property
def is_draw(self) -> bool

Returns True if game_result.code is ResultCode.ALL_CELLS_USED
Otherwise — False

- Update result. game_result.update:

def update(self,
           code: Optional[ResultCode] = None,
           win_player: Optional[PlayerBase] = None,
           win_combination: Optional[CombType] = None)

Updates data about the current game result.

Note:

• game_result.code - automatically updated when the game.set_draw or game.set_winner method is used
• game_result.win_player and game_result.win_combination -
  automatically updated when the game.set_winner method is used
  For more details, see section Game, methods: game.set_draw and game.set_winner

p1 = Player(name="PLAYER", symbol=Symbol('X'))
p2 = Player(name="ANDROID", symbol=Symbol('O'))
...

game.step(2, 2, player=p1)
game.step(0, 0, player=p1)

game.ai_step(p2)  # result in second table

+-----+---+---+---+   ->   +-----+---+---+---+
| ↓/→ | 0 | 1 | 2 |   ->   | ↓/→ | 0 | 1 | 2 |
+-----+---+---+---+   ->   +-----+---+---+---+
|  0: | X | * | * |   ->   |  0: | X | * | * |
|  1: | * | * | * |   ->   |  1: | * | O | * |
|  2: | * | * | X |   ->   |  2: | * | * | X |
+-----+---+---+---+   ->   +-----+---+---+---+

• The AI algorithm understands that the opponent's next move is likely to collect a winning combination, so it blocks it

Let's consider the second situation

game.step(0, 0, player=p1)  # X
game.step(2, 0, player=p1)  # X

game.step(0, 2, player=p2)  # O
game.step(2, 2, player=p2)  # O

game.ai_step(p2)  # result in second table

+-----+---+---+---+   ->   +-----+---+---+---+
| ↓/→ | 0 | 1 | 2 |   ->   | ↓/→ | 0 | 1 | 2 |
+-----+---+---+---+   ->   +-----+---+---+---+
|  0: | X | * | O |   ->   |  0: | X | * | O |
|  1: | * | * | * |   ->   |  1: | * | * | O |
|  2: | X | * | O |   ->   |  2: | X | * | O |
+-----+---+---+---+   ->   +-----+---+---+---+

• The AI algorithm prioritizes its own winnings, with the understanding that there will be no next winning move for the opponent

Знайомство з бібліотекою

Старт швидкої гри в консолі. GameConsole

Демо гра в консолі

from titato.client import GameConsole
from titato.core.player import Player, Players, Symbol
from titato.core.table import Table, TableParam


if __name__ == "__main__":
    p1 = Player(name="PETROS_ANDROID:1", symbol=Symbol('X'), role=Player.Role.ANDROID)
    p2 = Player(name="AMIGOS_ANDROID:2", symbol=Symbol('O'), role=Player.Role.ANDROID)
    p3 = Player(name="GENTOS_ANDROID:3", symbol=Symbol('K'), role=Player.Role.ANDROID)

    # p4 = Player(name="PLAYER", symbol=Symbol('P'), role=Player.Role.USER)

    players = Players(players=[p1, p2, p3])
    table = Table(param=TableParam(ROW=7, COLUMN=7, COMBINATION=5))

    game = GameConsole(players=players, table=table)
    game.start_game()

WIN: PETROS_ANDROID:1 < X > | COMB: < ((1, 1), (2, 2), (3, 3), (4, 4), (5, 5)) >
+-----+---+---+---+---+---+---+---+
| ↓/→ | 0 | 1 | 2 | 3 | 4 | 5 | 6 |
+-----+---+---+---+---+---+---+---+
|  0: | O | * | * | * | K | X | K |
|  1: | K | X | * | * | O | * | X |
|  2: | X | K | X | O | K | O | X |
|  3: | K | O | K | X | X | K | O |
|  4: | K | O | X | X | X | O | X |
|  5: | O | O | K | O | O | X | X |
|  6: | * | * | O | K | * | K | K |
+-----+---+---+---+---+---+---+---+

PEACE: ALL USED CELLS
+-----+---+---+---+---+---+---+---+
| ↓/→ | 0 | 1 | 2 | 3 | 4 | 5 | 6 |
+-----+---+---+---+---+---+---+---+
|  0: | X | K | K | O | O | O | X |
|  1: | K | X | X | K | X | O | K |
|  2: | X | K | O | O | O | X | K |
|  3: | O | X | K | K | O | K | X |
|  4: | X | O | K | O | O | X | O |
|  5: | X | X | O | X | X | K | K |
|  6: | K | K | X | O | K | O | X |
+-----+---+---+---+---+---+---+---+

WIN: AMIGOS_ANDROID:2 < O > | COMB: < ((3, 1), (3, 2), (3, 3), (3, 4), (3, 5)) >
+-----+---+---+---+---+---+---+---+
| ↓/→ | 0 | 1 | 2 | 3 | 4 | 5 | 6 |
+-----+---+---+---+---+---+---+---+
|  0: | * | * | * | * | K | * | * |
|  1: | * | * | * | * | K | * | * |
|  2: | * | X | * | * | * | * | * |
|  3: | * | O | O | O | O | O | X |
|  4: | * | * | * | * | K | * | * |
|  5: | * | * | * | * | * | * | * |
|  6: | K | X | X | X | O | X | K |
+-----+---+---+---+---+---+---+---+

API:

from titato.core.game import Game
from titato.core.player import Player, Players, Symbol
from titato.core.table import Table, TableParam

p1 = Player(name="VERA_ANDROID", symbol=Symbol('X'), role=Player.Role.ANDROID)
p2 = Player(name="BOGDAN_PLAYER", symbol=Symbol('O'), role=Player.Role.USER)

players = Players(players=[p1, p2])
table = TableDefault(param=TableParam(ROW=3, COLUMN=3, COMBINATION=3))

game = Game(players=players, table=table)

• Ці змінні будуть використовуватись при описі методів

GAME

Головний. Процес гри, обробка ходів, видача результату.

def step(self, index_row: int, index_column: int, player: PlayerBase)

# input
game.step(index_row=1, index_column=0, player=p2)  
game.step(index_row=1, index_column=2, player=p2)  
game.step(index_row=1, index_column=1, player=p2) 

# output
+-----+---+---+---+   ->   +-----+---+---+---+   ->   +-----+---+---+---+  
| ↓/→ | 0 | 1 | 2 |   ->   | ↓/→ | 0 | 1 | 2 |   ->   | ↓/→ | 0 | 1 | 2 |
+-----+---+---+---+   ->   +-----+---+---+---+   ->   +-----+---+---+---+
|  0: | * | * | * |   ->   |  0: | * | * | * |   ->   |  0: | * | * | * |
|  1: | O | * | * |   ->   |  1: | O | * | O |   ->   |  1: | O | O | O |
|  2: | * | * | * |   ->   |  2: | * | * | * |   ->   |  2: | * | * | * |
+-----+---+---+---+   ->   +-----+---+---+---+   ->   +-----+---+---+---+

def result(self, player: PlayerBase) -> GameStateT

# input
res = game.result(player=p2)
    
match res.code:
    case ResultCode.NO_RESULT:
        print('STATUS: NO RESULT')
    case ResultCode.WINNER:
        print(f'STATUS: WINNER. Player: {res.win_player.name}, Win comb: {res.win_combination}')
    case ResultCode.ALL_CELLS_USED:
        print('STATUS: DRAW')

# output
STATUS: WINNER. Player: BOGDAN_PLAYER, Win comb: ((1, 0), (1, 1), (1, 2))

def step_result(self, index_row: int, index_column: int, player: PlayerBase) -> GameStateT

def ai_get_step(self, player: PlayerBase) -> CellIndex

def ai_step(self, player: PlayerBase)

def ai_step_result(self, player: PlayerBase) -> GameStateT

def set_winner(self, player: PlayerBase, win_combination)

def set_draw(self)

TABLE

Виставляння ходів, комбінації для таблиці

table = game.table

@property
def game_field(self) -> GameFieldType

@property
def combinations(self) -> CombsType

@property
def count_free_cells(self) -> int

@property
def set_symbol_cell(self, index_row: int, index_column: int, symbol: SymbolBase)

PLAYERS

Список гравців і черга

players = game.players

@property
def players_list(self) -> list[PlayerT]:

@property
def current_player(self) -> PlayerT

def set_get_next_player(self) -> PlayerT

def shuffle_players(self)

PLAYER

Гравець, його данні

# titato.core.player.player.py

class Role(Enum):
    USER = 1
    ANDROID = 2

player = game.current_player

@property
def role(self) -> Role

@property
def symbol(self) -> SymbolBase

@property
def count_steps(self) -> int

@property
def is_android(self) -> bool

@property
def is_user(self) -> bool

def add_count_step(self)

GAME STATE

Поточний результат гри

# titato.core.game.result.py

class ResultCode(Enum):
    NO_RESULT = 0
    ALL_CELLS_USED = 1
    WINNER = 2

game_state = game.game_state

@property
def code(self) -> ResultCode

@property
def win_player(self) -> Optional[PlayerBase]

@property
def win_combination(self) -> Optional[CombType]

@property
def is_finished(self) -> bool

@property
def is_continues(self) -> bool

@property
def is_winner(self) -> bool

@property
def is_draw(self) -> bool

def update(self,
           code: Optional[ResultCode] = None,
           win_player: Optional[PlayerBase] = None,
           win_combination: Optional[CombType] = None)

AI

Короткий приклад роботи

p1 = Player(name="PLAYER", symbol=Symbol('X'))
p2 = Player(name="ANDROID", symbol=Symbol('O'))
...

game.step(2, 2, player=p1)
game.step(0, 0, player=p1)

game.ai_step(p2)  # result in second table

+-----+---+---+---+   ->   +-----+---+---+---+
| ↓/→ | 0 | 1 | 2 |   ->   | ↓/→ | 0 | 1 | 2 |
+-----+---+---+---+   ->   +-----+---+---+---+
|  0: | X | * | * |   ->   |  0: | X | * | * |
|  1: | * | * | * |   ->   |  1: | * | O | * |
|  2: | * | * | X |   ->   |  2: | * | * | X |
+-----+---+---+---+   ->   +-----+---+---+---+

game.step(0, 0, player=p1)  # X
game.step(2, 0, player=p1)  # X

game.step(0, 2, player=p2)  # O
game.step(2, 2, player=p2)  # O

game.ai_step(p2)  # result in second table

+-----+---+---+---+   ->   +-----+---+---+---+
| ↓/→ | 0 | 1 | 2 |   ->   | ↓/→ | 0 | 1 | 2 |
+-----+---+---+---+   ->   +-----+---+---+---+
|  0: | X | * | O |   ->   |  0: | X | * | O |
|  1: | * | * | * |   ->   |  1: | * | * | O |
|  2: | X | * | O |   ->   |  2: | X | * | O |
+-----+---+---+---+   ->   +-----+---+---+---+