st-minecraft 1.1.0__py3-none-any.whl

st_minecraft/__about__.py

@@ -0,0 +1,3 @@
+__version__ = "1.1.0"
+__author__ = "Chris Geron"
+__email__ = "git@chris-ge.de"

st_minecraft/__init__.py

@@ -0,0 +1 @@
+""" st_minecraft package """

st_minecraft/core/__init__.py

@@ -0,0 +1,3 @@
+""" st_minecraft package """
+
+from st_minecraft.core.core import *  # noqa: unused-import

st_minecraft/core/core.py

@@ -0,0 +1,126 @@
+"""
+Core of the library, here communication with the server happens
+this file also provides some helper functions
+"""
+
+import os
+import socket
+from enum import Enum
+from typing import Any
+from typing import Optional
+from typing import Type
+from typing import TypeVar
+
+# Global variable for the connection
+connection: Optional[socket.socket] = None
+
+ARG_SEPARATOR = "𝇉"
+
+DEFAULT_PORT = 25595
+
+
+def connect(ip: str = "0.0.0.0", port: int = DEFAULT_PORT) -> None:
+    """
+    Establishes a connection to the Minecraft server.
+
+    Args:
+        ip (str): The IP address of the server (default is "0.0.0.0" - equivalent to "localhost")
+        port (int): The port of the server.
+    """
+    # needed internally
+    global connection
+    if connection is not None:
+        connection.close()
+
+    # this allows us to develop more easily without having to adjust everything temporarily each time
+    _ip = os.getenv("SK_SERVER_OVERWRITE")
+    if _ip is not None:
+        spacer = "#" * 100
+        print(
+            f"{spacer}\n"
+            f"IP was overwritten by environment variable from '{ip}' to '{_ip}', "
+            f"(env var name: 'SK_SERVER_OVERWRITE')\n"
+            f"{spacer}"
+        )
+        ip = _ip
+
+    connection = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+    connection.connect((ip, port))
+
+
+def _receive(timeout: float = 2.0) -> bytes | None:
+    # needed internally
+
+    # this allows us to develop more easily without having to adjust everything temporarily each time
+    _timeout = os.getenv("SK_TIMEOUT_OVERWRITE")
+    if _timeout is not None:
+        if _timeout == "None":
+            _timeout = None
+        else:
+            _timeout = float(_timeout)
+
+        spacer = "#" * 100
+        print(
+            f"{spacer}\n"
+            f"Timeout was overwritten by environment variable from '{timeout}' to '{_timeout}', "
+            f"(env var name: 'SK_TIMEOUT_OVERWRITE')\n"
+            f"{spacer}"
+        )
+        timeout = _timeout
+
+    if timeout:
+        connection.settimeout(timeout)  # Timeout in seconds
+
+    try:
+        data = connection.recv(1024)
+    except socket.timeout:
+        raise NoDataError(f"Timeout: After {timeout} seconds no response was received from the server.")
+
+    return data
+
+
+def _build_command(*args: Any) -> str:
+    """
+    Takes all arguments, converts them to strings and builds the finished command from them
+    """
+    return ARG_SEPARATOR.join(map(str, args))
+
+
+def _bytes_to_text(b: bytes) -> str:
+    # needed internally
+    # bytes to text :)
+    return b.decode("utf-8").strip()
+
+
+def _send_command(command: str) -> None:
+    """
+    Sends a command over the global connection.
+
+    Args:
+        command (str): The command to send.
+    """
+    # needed internally
+    if connection is None:
+        raise RuntimeError("No connection to server. Please connect first.")
+
+    command = f"{command}\n"
+    connection.sendall(command.encode("utf-8"))
+
+
+E = TypeVar("E", bound=Enum)
+
+
+def _to_enum(enum: Type[E], value: Any) -> Optional[E]:
+    return enum._value2member_map_.get(value)
+
+
+class NoDataError(ValueError):
+    """Raised when we receive nothing from the API"""
+
+
+class WertFehler(ValueError):
+    """ValueError aber deutsch :clown face:"""
+
+
+class InventoryFieldEmptyError(KeyError):
+    """Raised when trying to access an inventory field that is empty."""

st_minecraft/de/__init__.py

@@ -0,0 +1,14 @@
+from st_minecraft.core import connect as verbinden  # noqa: unused-import
+from st_minecraft.de.boss_leiste import *  # noqa: unused-import
+from st_minecraft.de.daten_modelle import *  # noqa: unused-import
+from st_minecraft.de.main import *  # noqa: unused-import
+
+try:
+    from st_minecraft.de.entity import *  # noqa: unused-import
+    from st_minecraft.de.material import *  # noqa: unused-import
+
+except ModuleNotFoundError as e:
+    raise RuntimeError(
+        f"Es ist nicht möglich die auto-generierten Enums für Material und/oder Entity zu importieren."
+        f"Bitte überprüfe, ob diese vorliegen, falls nicht siehe bitte ressourcen/generate_enums.py im git repo."
+    ) from e

st_minecraft/de/boss_leiste.py

@@ -0,0 +1,134 @@
+"""Ermöglicht das erstellen und konfigurieren von Bossleisten"""
+
+from enum import Enum
+
+from pydantic import BaseModel
+
+import st_minecraft.en as __st_minecraft_en
+import st_minecraft.en.boss_bar as _st_minecraft_en_boss_bar
+from st_minecraft.core.core import WertFehler
+
+
+class BossLeisteStil(Enum):
+    """Möglichkeiten in denen der Stil einer Bossleiste angezeigt werden kann"""
+
+    DURCHGEZOGEN = "solid"
+    SEGMENTE_6 = "segmented_6"
+    SEGMENTE_10 = "segmented_10"
+    SEGMENTE_12 = "segmented_12"
+    SEGMENTE_20 = "segmented_20"
+
+    @staticmethod
+    def von_englisch(boss_bar_stil: _st_minecraft_en_boss_bar.BossBarStyle) -> "BossLeisteStil":
+        return BossLeisteStil._value2member_map_[boss_bar_stil.value]
+
+    def zu_englisch(self) -> _st_minecraft_en_boss_bar.BossBarStyle:
+        return _st_minecraft_en_boss_bar.BossBarStyle._value2member_map_[self.value]
+
+
+class BossLeisteFarben(Enum):
+    """Farben in denen eine Bossleiste angezeigt werden kann"""
+
+    BLAU = "blue"
+    GRÜN = "green"
+    PINK = "pink"
+    LILA = "purple"
+    ROT = "red"
+    WEIß = "white"
+    GELB = "yellow"
+
+    @staticmethod
+    def von_englisch(boss_bar_farbe: _st_minecraft_en_boss_bar.BossBarColor) -> "BossLeisteFarben":
+        return BossLeisteFarben._value2member_map_[boss_bar_farbe.value]
+
+    def zu_englisch(self) -> _st_minecraft_en_boss_bar.BossBarColor:
+        return _st_minecraft_en_boss_bar.BossBarColor._value2member_map_[self.value]
+
+
+class BossLeiste(BaseModel):
+    """Modell einer Bossleiste"""
+
+    name: str
+    """ Der von dir für die Leiste gesetze Name """
+    anzeige_text: str
+    """ Der Text der auf der Leiste angezeigt wird """
+    wert: float  # zwischen 0 und 1
+    """ Wie viel von der Leiste gefüllt sein soll (zwischen 0 und 1) """
+    stil: BossLeisteStil
+    """ Anzeige Stil der Leiste (siehe BossLeisteStil) """
+    farbe: BossLeisteFarben
+    """ Anzeige Farbe der Leiste (siehe BossLeisteFarbe) """
+
+    def __repr__(self):
+        return (
+            f"BossLeiste(name={self.name}, "
+            f"anzeige_text={self.anzeige_text}, "
+            f"wert={self.wert:.2f}, "
+            f"stil={self.stil}, "
+            f"farbe={self.farbe})"
+        )
+
+    @staticmethod
+    def von_englisch(boss_bar: _st_minecraft_en_boss_bar.BossBar) -> "BossLeiste":
+        return BossLeiste(
+            name=boss_bar.name,
+            anzeige_text=boss_bar.display_text,
+            wert=boss_bar.value,
+            stil=BossLeisteStil.von_englisch(boss_bar.style),
+            farbe=BossLeisteFarben.von_englisch(boss_bar.color),
+        )
+
+    def zu_englisch(self) -> _st_minecraft_en_boss_bar.BossBar:
+        return _st_minecraft_en_boss_bar.BossBar(
+            name=self.name,
+            display_text=self.anzeige_text,
+            value=self.wert,
+            style=self.stil.zu_englisch(),
+            color=self.farbe.zu_englisch(),
+        )
+
+
+def erzeuge_leiste(name: str, anzeige_text: str) -> BossLeiste:
+    """
+    Erstelle eine Bossleiste
+    Args:
+        name: Ein von dir gewählter Name, wie die Bossleiste für dich heißen soll
+        anzeige_text: Text der an der Leiste angezeigt werden soll
+
+    Returns:
+        Ein BossLeisten Objekt mit dessen Hilfe du die Leiste weiter konfigurieren kannst
+    """
+    b = __st_minecraft_en.create_bar(name, anzeige_text)
+    return BossLeiste.von_englisch(b)
+
+
+def setze_text(boss_leiste: BossLeiste, anzeige_text: str) -> BossLeiste:
+    """Setze den Text der Leiste"""
+    b = __st_minecraft_en.set_text(boss_leiste.zu_englisch(), anzeige_text)
+    return BossLeiste.von_englisch(b)
+
+
+def setze_farbe(boss_leiste: BossLeiste, farbe: BossLeisteFarben) -> BossLeiste:
+    """Setze die Farbe der Leiste"""
+    b = __st_minecraft_en.set_color(boss_leiste.zu_englisch(), farbe.zu_englisch())
+    return BossLeiste.von_englisch(b)
+
+
+def setze_wert(boss_leiste: BossLeiste, wert: float) -> BossLeiste:
+    """Setze zu welchem Anteil die leiste gefüllt sein soll (zwischen 0 und 1)"""
+    if not 0 <= wert <= 1:
+        raise WertFehler(f"Der Wert der Bossleiste muss zwischen 0 und 1 liegen. Du hast '{wert}' angegeben.")
+
+    b = __st_minecraft_en.set_value(boss_leiste.zu_englisch(), wert)
+    return BossLeiste.von_englisch(b)
+
+
+def setze_stil(boss_leiste: BossLeiste, stil: BossLeisteStil) -> BossLeiste:
+    """Setze den Stil der Leiste"""
+    b = __st_minecraft_en.set_style(boss_leiste.zu_englisch(), stil.zu_englisch())
+    return BossLeiste.von_englisch(b)
+
+
+def loesche_leiste(boss_leiste: BossLeiste):
+    """Lösche eine Leiste"""
+    __st_minecraft_en.delete_bar(boss_leiste.zu_englisch())

st_minecraft/de/daten_modelle.py

@@ -0,0 +1,309 @@
+from enum import Enum
+from typing import Optional
+
+from pydantic import BaseModel
+
+from st_minecraft.core.core import InventoryFieldEmptyError
+from st_minecraft.core.core import _to_enum
+from st_minecraft.de.entity import EntitySammlung
+from st_minecraft.de.material import MaterialSammlung
+from st_minecraft.en import Dimension
+from st_minecraft.en import DirectionCollection as _DirectionCollection
+from st_minecraft.en import Entity as _EntityEN
+from st_minecraft.en import Inventory as _InventoryEN
+from st_minecraft.en import InventoryField as _InventoryFieldEN
+from st_minecraft.en import Item as _ItemEN
+from st_minecraft.en import Material as _MaterialEN
+from st_minecraft.en import Message as _MessageEN
+from st_minecraft.en import Player as _PlayerEN
+
+
+class RichtungSammlung(Enum):
+    """
+    Arten, wie Geschwindigkeiten verändert werden können
+    Wird u.A. in spieler_geschwindigkeit_setzen() verwendet.
+    """
+
+    Hoch = "UP"
+    Runter = "DOWN"
+    Zurück = "BACK"
+    Vorwärts = "LOOKING"
+
+    @staticmethod
+    def von_englisch(e: _DirectionCollection) -> "RichtungSammlung":
+        return RichtungSammlung._value2member_map_[e.value]
+
+    def zu_englisch(self) -> _DirectionCollection:
+        return _DirectionCollection._value2member_map_[self.value]
+
+
+class Material(BaseModel):
+    """
+    Modelliert einen Block in Minecraft, der sich zum Zeitpunkt der Abfrage an einer bestimmten Koordinate befindet.
+    """
+
+    typ: MaterialSammlung | None
+    """ Block Typ """
+    x: int | None = None
+    y: int | None = None
+    z: int | None = None
+    dimension: Dimension | None = None
+
+    def __repr__(self):
+        return f"Block(typ={self.typ}, x={self.x}, y={self.y}, z={self.z}, dimension={self.dimension})"
+
+    @staticmethod
+    def von_englisch(m: _MaterialEN | None) -> Optional["Material"]:
+        if m is None:
+            return None
+
+        return Material(
+            typ=MaterialSammlung.von_englisch(m.type),
+            x=m.x,
+            y=m.y,
+            z=m.z,
+            dimension=m.dimension,
+        )
+
+    def zu_englisch(self) -> _MaterialEN:
+        if self.typ is None:
+            return None
+
+        return _MaterialEN(
+            type=self.typ.zu_englisch(),
+            x=self.x,
+            y=self.y,
+            z=self.z,
+            dimension=self.dimension,
+        )
+
+
+class Spieler(BaseModel):
+    """Momentaufnahme zum Zeitpunkt der Abfrage, die Daten werden NICHT dauerhaft aktualisiert!"""
+
+    id: int
+    """ Eindeutige ID des Spielers """
+    name: str
+    """ Name des Spielers """
+    x: int
+    y: int
+    z: int
+    dimension: Dimension
+    rotation: int
+    """ Rotation des Spielers von -180 bis 180 """
+    schaut_auf: Material | None
+    """ Der nächste Block auf den Spieler schaut (maximal 100 Blöcke weit entfernt) """
+    sneaked: bool
+    """ True wenn Player sneaked """
+    max_leben: float
+    leben: float
+    hunger: float
+    sättigung: float
+    xp_level: float
+    xp_fortschritt: float
+
+    @staticmethod
+    def von_englisch(p: _PlayerEN):
+        return Spieler(
+            id=p.id,
+            name=p.name,
+            x=p.x,
+            y=p.y,
+            z=p.z,
+            dimension=p.dimension,
+            rotation=p.rotation,
+            schaut_auf=Material.von_englisch(p.looking_at),
+            sneaked=p.sneaked,
+            max_leben=p.max_health,
+            leben=p.health,
+            hunger=p.hunger,
+            sättigung=p.saturation,
+            xp_level=p.xp_level,
+            xp_fortschritt=p.xp_progress,
+        )
+
+    def zu_englisch(self) -> _PlayerEN:
+        return _PlayerEN(
+            id=self.id,
+            name=self.name,
+            x=self.x,
+            y=self.y,
+            z=self.z,
+            dimension=self.dimension,
+            rotation=self.rotation,
+            looking_at=self.schaut_auf.zu_englisch(),
+            sneaked=self.sneaked,
+            max_health=self.max_leben,
+            health=self.leben,
+            hunger=self.hunger,
+            saturation=self.sättigung,
+            xp_level=self.xp_level,
+            xp_progress=self.xp_fortschritt,
+        )
+
+    def __repr__(self):
+        return (
+            f"Spieler("
+            f"id={self.id}, "
+            f"name={self.name}, "
+            f"x={self.x}, "
+            f"y={self.y}, "
+            f"z={self.z}, "
+            f"dimension={self.dimension}, "
+            f"rotation={self.rotation}, "
+            f"leben={self.leben}, "
+            f"max_leben={self.max_leben}, "
+            f"hunger={self.hunger}, "
+            f"sättigung={self.sättigung}, "
+            f"xp_level={self.xp_level}, "
+            f"xp_fortschritt={self.xp_fortschritt}, "
+            f"sneaked={self.sneaked}, "
+            f"schaut_auf={self.schaut_auf}, "
+            ")"
+        )
+
+
+class Entity(BaseModel):
+    """Modelliert ein Entity. Viele der Informationen können leer (None) sein"""
+
+    typ: EntitySammlung
+    """ Typ des Entity's """
+    id: str | None = None
+    """ Einzigartige ID für dieses Entity """
+    name: str | None = None
+    x: float | None = None
+    y: float | None = None
+    z: float | None = None
+    dimension: Dimension | None = None
+    leben: float | None = None
+    ai: bool | None = None
+
+    def __repr__(self):
+        return (
+            f"Entity("
+            f"typ={self.typ}, "
+            f"name={self.name}, "
+            f"x={self.x}, "
+            f"y={self.y}, "
+            f"z={self.z}, "
+            f"dimension={self.dimension}, "
+            f"leben={self.leben}, "
+            f"ai={self.ai}, "
+            f"id={self.id}, "
+            ")"
+        )
+
+    @staticmethod
+    def von_string(typ: str):
+        # TODO: brauchen wir das? falls nein können wir die default-Nones entfernen
+        return Entity(typ=_to_enum(EntitySammlung, typ))
+
+    @staticmethod
+    def von_englisch(e: _EntityEN):
+        return Entity(
+            typ=EntitySammlung.von_englisch(e.type),
+            id=e.id,
+            name=e.name,
+            x=e.x,
+            y=e.y,
+            z=e.z,
+            dimension=e.dimension,
+            leben=e.health,
+            ai=e.ai,
+        )
+
+    def zu_englisch(self) -> _EntityEN:
+        return _EntityEN(
+            type=self.typ.zu_englisch(),
+            id=self.id,
+            name=self.name,
+            x=self.x,
+            y=self.y,
+            z=self.z,
+            dimension=self.dimension,
+            health=self.leben,
+            ai=self.ai,
+        )
+
+
+class Item(BaseModel):
+    """Modelliert ein Item"""
+
+    typ: MaterialSammlung
+    anzeige_name: str | None
+
+    def __repr__(self):
+        return f"Item(typ={self.typ}, anzeige_name={self.anzeige_name})"
+
+    @staticmethod
+    def von_englisch(i: _ItemEN):
+        return Item(typ=MaterialSammlung.von_englisch(i.type), anzeige_name=i.display_name)
+
+
+class InventarFeld(BaseModel):
+    """Ein Feld im Inventar eine:r Spieler:in"""
+
+    index: int
+    """ Index wo das Feld im Inventar liegt """
+    item: Item
+    """ Item Objekt, welches Item in dem Feld liegt """
+    anzahl: int
+    """ Wie viele von dem Item in diesem Feld liegen """
+
+    def __repr__(self):
+        return f"InventarFeld(index={self.index}, item={self.item!r}, anzahl={self.anzahl})"
+
+    @staticmethod
+    def von_englisch(i: _InventoryFieldEN):
+        return InventarFeld(index=i.index, item=Item.von_englisch(i.item), anzahl=i.amount)
+
+    def zu_englisch(self) -> _InventoryFieldEN:
+        return _InventoryFieldEN(index=self.index, item=self.item.zu_englisch(), amount=self.anzahl)
+
+
+class Inventar(dict[int, InventarFeld]):
+    """
+    Enthält das gesamte Inventar eines Spielers.
+    Die Struktur ist ein dict.
+    Das dict zeigt von Index des Inventars auf ein Objekt vom Typ InventarFeld, welcher die Infos über das Element in dem Feld enthält.
+    Hinweis: Felder, die Leer sind, sind nicht in dem dict enthalten!
+    """
+
+    def __contains__(self, item: Item):
+        """Überprüfe, ob ein Item im Inventar ist"""
+        for _, v in self.items():
+            if v.item == item:
+                return True
+        return False
+
+    def __getitem__(self, item: int):
+        try:
+            super().__getitem__(item)
+        # ich glaube, hier ist der peak der library. ein nicht-generischer wrapper um den KeyError.
+        except KeyError:
+            raise InventoryFieldEmptyError(f"Das Feld {item} ist leer. Daher kannst du hier nicht drauf zugreifen.")
+
+    @staticmethod
+    def von_englisch(i: _InventoryEN):
+        return Inventar({index: InventarFeld.von_englisch(field) for index, field in i.items()})
+
+    def zu_englisch(self) -> _InventoryEN:
+        return _InventoryEN({index: field.zu_englisch() for index, field in self.items()})
+
+
+class Nachricht(BaseModel):
+    """
+    Repräsentiert eine Nachricht, die vom Nutzer an den Chat gesendet wurde
+    """
+
+    text: str
+    """Der in den Chat gesendete Text"""
+    sender_name: str
+    """Name des Spielers, der diese Nachricht gesendet hat"""
+
+    @staticmethod
+    def von_englisch(m: _MessageEN):
+        return Nachricht(text=m.text, absender_name=m.sender_name)
+
+    def zu_englisch(self) -> _MessageEN:
+        return _MessageEN(text=self.text, sender_name=self.absender_name)