socha

Subpackages

Submodules

Package Contents

Classes

Card

Eine Karte, die im Spiel verwendet werden kann.

Advance

Eine Klasse, die einen Vorwärtszug im Spiel darstellt.

EatSalad

ExchangeCarrots

FallBack

Field

Generic enumeration.

Board

Ein Spielbrett, das die Felder des Spiels enthält.

TeamEnum

Generic enumeration.

Hare

Repräsentiert einen Hasen im Spiel.

Move

Repräsentiert einen Zug im Spiel.

GameState

Repräsentiert den aktuellen Zustand des Spiels.

RulesEngine

Dient zur Überprüfung der Spielregeln.

PluginConstants

class socha.Card

Bases: enum.Enum

Eine Karte, die im Spiel verwendet werden kann.

Attributes:

FallBack (int): Die Karte, die den Spieler zurückfallen lässt. HurryAhead (int): Die Karte, die den Spieler vorrücken lässt. EatSalad (int): Die Karte, die den Spieler Salat essen lässt. SwapCarrots (int): Die Karte, die die Karotten der Spieler tauscht.

FallBack: int = 0
HurryAhead: int = 1
EatSalad: int = 2
SwapCarrots: int = 3
moves() → bool

Gibt an, ob die Karte den Spieler bewegt.

Args:

None

Returns:

bool: True, wenn die Karte den Spieler bewegt, False sonst.

perform(state: GameState, remaining_cards: List[Card]) → None

Führt die Karte aus.

Diese Methode kann den GameState mutieren, unabhängig vom Erfolg des Zuges.

Args:

state (GameState): Der aktuelle Spielzustand. remaining_cards (List[Card]): Die verbleibenden Karten.

Raises:

HUIError: Ein Fehler, wenn die Karte nicht ausgeführt werden kann.

class socha.Advance(distance: int, cards: List[Card])

Eine Klasse, die einen Vorwärtszug im Spiel darstellt.

Attributes:

distance (int): Die Anzahl der Felder, die der Spieler vorrücken soll. cards (List[Card]): Die Karten, die während des Vorgangs gespielt werden.

distance: int
cards: List[Card]
perform(state: GameState) → None

Führt den Vorwärtszug aus.

Diese Methode kann den GameState mutieren, unabhängig vom Erfolg des Zuges.

Args:

state (GameState): Der aktuelle Zustand des Spiels.

Raises:

HUIError: Wenn der Vorwärtszug nicht erfolgreich ausgeführt werden kann.

class socha.EatSalad
perform(state: GameState) → None

Führt die Salat-Fressen Aktion aus.

Diese Methode kann den GameState mutieren, unabhängig vom Erfolg des Zuges.

Args:

state (GameState): Der aktuelle Zustand des Spiels.

Raises:

HUIError: Wenn der Salat nicht erfolgreich gegessen werden kann.

class socha.ExchangeCarrots(amount: int)
amount: int
perform(state: GameState) → None

Führt die Karotten-Tausch-Aktion aus.

Diese Methode kann den GameState mutieren, unabhängig vom Erfolg des Zuges.

Args:

state (GameState): Der aktuelle Zustand des Spiels.

Raises:

HUIError: Wenn die Karotten nicht erfolgreich getauscht werden können.

class socha.FallBack
perform(state: GameState) → None
class socha.Field

Bases: enum.Enum

Generic enumeration.

Derive from this class to define new enumerations.

Position1: int = 0

Zahlfeld

Position2: int = 1

Flaggenfeld

Hedgehog: int = 2

Igelfeld: Hierauf kann nur rückwärts gezogen werden.

Salad: int = 3

Salatfeld: Beim Betreten wird im nächsten Zug ein Salat gegessen.

Carrots: int = 4

Karottenfeld: Hier dürfen Karotten getauscht werden.

Hare: int = 5

Hasenfeld: Hier wird sofort eine Hasenkarte gespielt.

Market: int = 6

Marktfeld: Hier wird eine Hasenkarte gekauft (Variation).

Goal: int = 7

Zielfeld

Start: int = 8

Startfeld

class socha.Board(track: list[Field])

Ein Spielbrett, das die Felder des Spiels enthält.

Attributes:

track (List[Field]): Die Liste der Felder, die das Spielbrett darstellen

track: list[Field]
get_field(index: int) → Field | None

Gibt das Feld am angegebenen Index zurück.

Args:

index (int): Der Index des Feldes, das abgerufen werden soll.

Returns:

Field: Das Feld am angegebenen Index, oder None, wenn außerhalb des gültigen Bereichs.

find_field(field: Field, start: int, end: int) → int | None

Findet den ersten Index des angegebenen Feldes innerhalb des angegebenen Bereichs.

Args:

field (Field): Das Feld, nach dem gesucht werden soll. start (int): Der Startindex des Bereichs, in dem gesucht werden soll. end (int): Der Endindex des Bereichs, in dem gesucht werden soll.

Returns:

int: Der Index des Feldes, wenn gefunden, oder None, wenn nicht gefunden.

get_previous_field(field: Field, index: int) → int | None

Findet die vorherige Vorkommen des angegebenen Feldes vor dem angegebenen Index.

Args:

field (Field): Das Feld, nach dem gesucht werden soll. index (int): Der Index, von dem aus gesucht werden soll.

Returns:

int: Der Index des vorherigen Vorkommens des Feldes, oder None, wenn nicht gefunden.

get_next_field(field: Field, index: int) → int | None

Findet das nächste Vorkommen des angegebenen Feldes nach dem angegebenen Index.

Args:

field (Field): Das Feld, nach dem gesucht werden soll. index (int): Der Index, von dem aus gesucht werden soll.

Returns:

int: Der Index des nächsten Vorkommens des Feldes, oder None, wenn nicht gefunden.

class socha.TeamEnum

Bases: enum.Enum

Generic enumeration.

Derive from this class to define new enumerations.

One: int = 0

Team 1

Two: int = 1

Team 2

__repr__() → str

Return repr(self).

class socha.Hare(team: TeamEnum, cards: List[Card] | None = None, carrots: int | None = None, salads: int | None = None, last_move: Move | None = None, position: int | None = None)

Repräsentiert einen Hasen im Spiel.

Attribute:

team (TeamEnum): Das Team, dem der Hase angehört. position (int): Die aktuelle Position des Hasen auf dem Brett. salads (int): Die Anzahl der Salate, die der Hase hat. carrots (int): Die Anzahl der Karotten, die der Hase hat. last_move (Optional[Move]): Der letzte Zug, den der Hase gemacht hat. cards (List[Card]): Die Karten, die der Hase hat.

team: TeamEnum
position: int
salads: int
carrots: int
last_move: Move | None
cards: List[Card]
is_in_goal() → bool

Überprüft, ob der Hase im Ziel ist.

Returns:

bool: True, wenn der Hase im Ziel ist, False sonst.

can_enter_goal() → bool

Überprüft, ob der Hase das Ziel betreten kann.

Returns:

bool: True, wenn der Hase das Ziel betreten kann, False sonst.

advance_by(state: GameState, distance: int, cards: List[Card]) → None

Rückt den Hasen um eine bestimmte Entfernung vor.

Args:

state (GameState): Der aktuelle Spielzustand. distance (int): Die Entfernung, um die der Hase vorrücken soll. cards (List[Card]): Die Karten, die während des Vorgangs gespielt werden.

Raises:

HUIError: Wenn der Hase nicht vorrücken kann.

exchange_carrots(state: GameState, carrots: int) → None

Tauscht Karotten mit dem Hasen.

Args:

state (GameState): Der aktuelle Spielzustand. carrots (int): Die Anzahl der Karotten, die getauscht werden sollen.

Raises:

HUIError: Wenn die Karotten nicht getauscht werden können.

consume_carrots(state: GameState, carrots: int) → None

Verbraucht Karotten vom Hasen.

Args:

state (GameState): Der aktuelle Spielzustand. carrots (int): Die Anzahl der Karotten, die verbraucht werden sollen.

Raises:

HUIError: Wenn die Karotten nicht verbraucht werden können.

eat_salad(state: GameState) → None

Lässt den Hasen einen Salat essen.

Args:

state (GameState): Der aktuelle Spielzustand.

get_fall_back(state: GameState) → int | None

Gibt den nächsten möglich Index zurück, an dem der Hase zurückfallen kann.

Args:

state (GameState): Der aktuelle Spielzustand.

Returns:

Optional[int]: Die Rückfallposition des Hasen, oder None, wenn nicht gefunden.

fall_back(state: GameState) → None

Lässt den Hasen zu einer vorherigen Position zurückfallen.

Args:

state (GameState): Der aktuelle Spielzustand.

Raises:

HUIError: Wenn der Hase nicht zurückfallen kann.

is_ahead(state: GameState) → bool

Überprüft, ob der Hase vor dem anderen Spieler ist.

Args:

state (GameState): Der aktuelle Spielzustand.

Returns:

bool: True, wenn der Hase vor dem anderen Spieler ist, False sonst.

class socha.Move(action: Advance | EatSalad | ExchangeCarrots | FallBack)

Repräsentiert einen Zug im Spiel.

Attribute:

action (Advance | EatSalad | ExchangeCarrots | FallBack): Die Aktion, die der Zug ausführt.

action: Advance | EatSalad | ExchangeCarrots | FallBack
perform(state: GameState) → None

Führt den Zug aus.

Args:

state (GameState): Der aktuelle Spielzustand.

Raises:

HUIError: Wenn der Zug nicht ausgeführt werden kann.

__repr__() → str

Return repr(self).

__eq__() → bool

Return self==value.

class socha.GameState(board: Board, turn: int, player_one: Hare, player_two: Hare, last_move: Move | None)

Repräsentiert den aktuellen Zustand des Spiels.

Attribute:

board (Board): Das Spielbrett. turn (int): Die aktuelle Runde.

board: Board
turn: int
last_move: Move | None
perform_move(move: Move) → GameState

Führt einen Zug aus und gibt den neuen Spielzustand zurück.

Args:

move (Move): Der Zug, der ausgeführt werden soll.

Returns:

GameState: Der neue Spielzustand.

Raises:

HUIError: Wenn der Zug nicht ausgeführt werden kann.

clone_current_player() → Hare

Gibt eine Kopie des aktuellen Spielers zurück.

Returns:

Hare: Eine Kopie des aktuellen Spielers.

clone_other_player() → Hare

Gibt eine Kopie des anderen Spielers zurück.

Returns:

Hare: Eine Kopie des anderen Spielers.

update_player(player: Hare) → None

Aktualisiert den Spieler.

Args:

player (Hare): Der Spieler, der aktualisiert werden soll.

is_over() → bool

Überprüft, ob das Spiel vorbei ist.

Returns:

bool: True, wenn das Spiel vorbei ist, False sonst.

possible_moves_old() → List[Move]

Gibt eine Liste aller möglichen Züge zurück.

Returns:

List[Move]: Eine Liste aller möglichen Züge.

possible_moves() → List[Move]

Gibt eine Liste aller möglichen Züge zurück.

Returns:

List[Move]: Eine Liste aller möglichen Züge.

class socha.RulesEngine

Dient zur Überprüfung der Spielregeln.

static calculates_carrots(distance: int) → int

Berechnet die Anzahl der Karotten, die für einen Zug benötigt werden.

Args:

distance (int): Die Entfernung, die zurückgelegt werden soll.

Returns:

int: Die Anzahl der Karotten, die benötigt werden.

static can_exchange_carrots(board: Board, player: Hare, count: int) → None

Überprüft, ob ein Spieler Karotten tauschen kann.

Args:

board (Board): Das Spielbrett. player (Hare): Der Spieler, der Karotten tauschen möchte. count (int): Die Anzahl der Karotten, die getauscht werden sollen.

Raises:

HUIError: Wenn der Spieler nicht genug Karotten hat oder wenn das Feld nicht ein Karottenfeld ist.

static can_eat_salad(board: Board, player: Hare) → None

Überprüft, ob ein Spieler einen Salat essen kann.

Args:

board (Board): Das Spielbrett. player (Hare): Der Spieler, der einen Salat essen möchte.

Raises:

HUIError: Wenn der Spieler keinen Salat hat oder wenn das Feld nicht ein Salatfeld ist.

static has_to_eat_salad(board: Board, player: Hare) → None

Überprüft, ob ein Spieler einen Salat essen muss.

Args:

board (Board): Das Spielbrett. player (Hare): Der Spieler, der einen Salat essen muss.

Raises:

Exception: Wenn der Spieler nicht genug Salate hat oder wenn das Feld nicht ein Salatfeld ist.

static can_move_to(board: Board, new_position: int, player: Hare, other_player: Hare, cards: List[Card]) → None

Überprüft, ob ein Spieler zu einem bestimmten Feld ziehen kann.

Args:

board (Board): Das Spielbrett. new_position (int): Die neue Position, zu der der Spieler ziehen möchte. player (Hare): Der Spieler, der ziehen möchte. other_player (Hare): Der andere Spieler. cards (List[Card]): Die Karten, die der Spieler spielen möchte.

Raises:

Exception: Wenn das Feld besetzt ist oder wenn der Spieler nicht genug Karotten hat.

class socha.PluginConstants
NUM_FIELDS: int
INITIAL_SALADS: int
INITIAL_CARROTS: int
ROUND_LIMIT: int