Hydra-Game 1.0.0__tar.gz

hydra_game-1.0.0/Game/Body.py

@@ -0,0 +1,308 @@
+from __future__ import annotations
+import json
+import socket
+import shutil
+import sys
+import termios
+import threading
+import tty
+from dataclasses import dataclass, field
+from select import select
+from typing import Any, Dict, List, Optional, Protocol, Tuple, Union
+
+from .Plexus import GemName, Intent
+from .Pulse import CursorLeft, Flicker1, Flicker2, Flicker3, Flicker4, Green, HideCursor, PadLine, ReadKey, Reset, ShowCursor, Step, Teal
+
+class Heart(Protocol):
+    head: str
+    heads: List[str]
+    tail: Optional[Dict[str, Any]]
+    state: Any
+
+    def Snapshot(self) -> Dict[str, Any]: ...
+    def Emotions(self) -> Dict[str, Any]: ...
+    def Ingest(self, tailin: Dict[str, Any]) -> List[Intent]: ...
+    def Propose(self, tohead: str, amount: int) -> Dict[str, Any]: ...
+    def DreamState(self) -> Dict[str, Any]: ...
+
+PrintLock = threading.Lock()
+SeenMax = 4096
+Command = Union[str, Tuple[str, str, int]]
+WelcomeLines = [
+    "",
+    "",
+    f"  {Teal}It's feeding time{Green}...{Reset}",
+    "",
+    f"  {Teal}Go for it, let another set of jaws chomp on your tallies{Reset}",
+    f"  {Teal}and give of yourself freely{Green}. {Teal}Nothing here is lost{Green}.{Reset}",
+    f"  {Teal}If another takes too much, draw it back through the ichor{Green}.{Reset}",
+    f"  {Teal}Hydra feels no pain{Green}. {Teal}It has no memory{Green}...{Reset}",
+    "",
+    f"  {Teal}Use {Green}←{Teal} and {Green}→{Teal} to select a head, then {Green}↑{Teal} and {Green}↓{Teal} for an amount{Green}.{Reset}",
+    f"  {Green}Enter{Teal}({Green}Feed!{Teal})  {Green}Ctrl{Teal}+{Green}X{Teal}({Green}Sever{Teal})  {Green}Ctrl{Teal}+{Green}C{Teal}({Green}Cauterize{Teal}){Reset}",
+    "",
+    f"  {Teal}Heads that become {Green}Envious{Teal} must be {Green}Severed{Teal} and Rehydrated{Green}.{Reset}",
+    "",
+    "",
+]
+
+class ExitSignal(Exception):
+    pass
+
+
+def FirstTarget(head: str, heads: List[str]) -> str:
+    for item in heads:
+        if item != head:
+            return item
+    return heads[0]
+
+def NextTarget(head: str, heads: List[str], targethead: str, direction: int) -> str:
+    if not heads:
+        return targethead
+    index = heads.index(targethead)
+    for _ in range(len(heads)):
+        index = (index + direction) % len(heads)
+        candidate = heads[index]
+        if candidate != head or len(heads) == 1:
+            return candidate
+    return targethead
+
+@dataclass
+class Body:
+    head: str
+    heads: List[str]
+    sock: socket.socket
+    peers: List[Tuple[str, int]]
+    heart: Heart
+    lock: threading.Lock
+    targethead: str = ""
+    amount: int = 1
+    seen: Dict[str, None] = field(default_factory=dict)
+
+    def Crown(self) -> int:
+        return int(self.heart.state.crown)
+
+    def EnsureTarget(self) -> None:
+        if not self.targethead or self.targethead not in self.heads:
+            self.targethead = FirstTarget(self.head, self.heads)
+
+    def MoveTarget(self, direction: int) -> None:
+        self.EnsureTarget()
+        self.targethead = NextTarget(self.head, self.heads, self.targethead, direction)
+
+    def TailItems(self, tallies: Dict[str, Any]) -> str:
+        return f"{Reset}{Green}:{Reset}".join(
+            f"{Teal}{item}{Reset}{(Flicker3() if index % 2 == 0 else Flicker4())}{tallies.get(item, 'x')}{Reset}"
+            for index, item in enumerate(self.heads)
+        )
+
+    def HudLine(self, crown: int, tallies: Dict[str, Any], envy: bool) -> Tuple[str, int]:
+        headchunk = f"{Flicker2()}Head{Reset}{Green}:{Reset}{Flicker2()}{self.head}{Reset}" if envy else f"{Teal}Head{Green}:{Reset}{Teal}{self.head}{Reset}"
+        visible = f".::Head:{self.head}:::Crown:{GemName(crown)}:::{self.targethead}:{self.amount}:::Tails:" + ".".join(f"{item}{tallies.get(item, 'x')}" for item in self.heads) + "::."
+        line = (
+            f"  {Green}.::{Reset}{headchunk}{Green}:::{Reset}"
+            f"{Teal}Crown{Green}:{Reset}{Flicker1()}{GemName(crown)}{Reset}{Green}:::{Reset}"
+            f"{Flicker3()}{self.targethead}{Reset}{Green}:{Reset}{Flicker4()}{self.amount}{Reset}{Green}:::{Reset}"
+            f"{Teal}Tails{Green}:{Reset}{Flicker3()}{self.TailItems(tallies)}{Reset}{Green}::.{Reset}"
+        )
+        return line, len(visible)
+
+    def Paint(self, lines: List[str], cursorleft: int) -> None:
+        with PrintLock:
+            width, height = shutil.get_terminal_size(fallback=(80, 24))
+            built = [PadLine(line, max(1, width)) for line in lines]
+            if len(built) < height:
+                built.extend([" " * max(1, width)] * (height - len(built)))
+            sys.stdout.write("\x1b[H")
+            sys.stdout.write("\n".join(built[:height]))
+            sys.stdout.write(CursorLeft(cursorleft))
+            sys.stdout.flush()
+
+    def RenderStatus(self) -> None:
+        self.EnsureTarget()
+        snap = self.heart.Snapshot()
+        crown = int(snap.get("crown", 1) or 1)
+        tallies = dict(snap.get("tallies", {}) or {})
+        envy = bool(self.heart.Emotions().get("envy", False))
+        hudline, cursorleft = self.HudLine(crown, tallies, envy)
+        self.Paint(WelcomeLines + [hudline], cursorleft)
+
+    def SendMessage(self, message: Dict[str, Any], dstaddr: Optional[Tuple[str, int]] = None, skipaddr: Optional[Tuple[str, int]] = None) -> None:
+        payload = json.dumps(message, separators=(",", ":")).encode("utf-8")
+        if dstaddr is not None:
+            try:
+                self.sock.sendto(payload, dstaddr)
+            except Exception:
+                pass
+            return
+        for host, port in self.peers:
+            if skipaddr is not None and (host, port) == skipaddr:
+                continue
+            try:
+                self.sock.sendto(payload, (host, port))
+            except Exception:
+                pass
+
+    def SendTail(self, tail: Dict[str, Any], srcaddr: Optional[Tuple[str, int]] = None) -> None:
+        self.SendMessage(tail, skipaddr=srcaddr)
+
+    def SendHunger(self, crown: int, needtail: bool = True) -> None:
+        self.SendMessage({"type": "HUNGER", "head": self.head, "crown": int(crown), "needtail": bool(needtail)})
+
+    def SendRoster(self, dstaddr: Optional[Tuple[str, int]] = None) -> None:
+        self.SendMessage({"type": "ROSTER", "head": self.head, "heads": list(self.heads)}, dstaddr=dstaddr)
+
+    def SendDream(self, dstaddr: Tuple[str, int]) -> None:
+        with self.lock:
+            self.SendMessage(dict(self.heart.DreamState()), dstaddr=dstaddr)
+
+    def SoftReboot(self) -> None:
+        with self.lock:
+            self.SendHunger(self.Crown(), needtail=True)
+        self.RenderStatus()
+
+    def MarkSeen(self, message: Dict[str, Any]) -> bool:
+        try:
+            seenkey = json.dumps({
+                "head": message.get("head", ""),
+                "crown": int(message.get("crown", 1) or 1),
+                "tallies": dict(message.get("tallies", {}) or {}),
+            }, sort_keys=True, separators=(",", ":"))
+        except Exception:
+            return False
+        if not (message.get("is_dream") and self.heart.envy) and seenkey in self.seen:
+            return False
+        self.seen[seenkey] = None
+        if len(self.seen) > SeenMax:
+            self.seen.pop(next(iter(self.seen)))
+        return True
+
+    def HandleSignal(self, message: Dict[str, Any], addr: Tuple[str, int]) -> bool:
+        messagetype = str(message.get("type", "") or "")
+        if messagetype == "HUNGER":
+            self.SendDream(addr)
+        elif messagetype == "AWAKE":
+            self.SendRoster(dstaddr=addr)
+        elif messagetype != "ROSTER":
+            return False
+        return True
+
+    def IngestMessage(self, message: Dict[str, Any], addr: Tuple[str, int]) -> None:
+        if "tallies" not in message or "crown" not in message:
+            return
+        with self.lock:
+            if not self.MarkSeen(message):
+                return
+            intents = self.heart.Ingest(dict(message))
+        self.ExecuteIntents(intents, srcaddr=addr)
+
+    def ExecuteIntents(self, intents: List[Intent], srcaddr: Optional[Tuple[str, int]] = None) -> None:
+        for intent in intents:
+            if intent.type == "Propagate":
+                tail = dict(intent.payload.get("tail", {}))
+                if tail:
+                    self.SendTail(tail, srcaddr=srcaddr)
+            elif intent.type == "RequestSync":
+                crown = int(intent.payload.get("crown", 1) or 1)
+                if bool(intent.payload.get("needtail", False)) or bool(self.heart.envy):
+                    self.SendHunger(crown, needtail=True)
+        self.RenderStatus()
+
+class Receiver(threading.Thread):
+    def __init__(self, body: Body):
+        super().__init__(daemon=True)
+        self.body = body
+
+    def run(self) -> None:
+        while True:
+            try:
+                data, addr = self.body.sock.recvfrom(65535)
+                message = json.loads(data.decode("utf-8"))
+                if isinstance(message, dict) and self.body.HandleSignal(message, addr):
+                    continue
+                if isinstance(message, dict):
+                    self.body.IngestMessage(message, addr)
+            except Exception:
+                continue
+
+def ReadCommand(body: Body) -> Command:
+    body.EnsureTarget()
+    filedescriptor = sys.stdin.fileno()
+    original = termios.tcgetattr(filedescriptor)
+    body.RenderStatus()
+    try:
+        tty.setcbreak(filedescriptor)
+        laststep = None
+        while True:
+            step = Step()
+            if step != laststep:
+                body.RenderStatus()
+                laststep = step
+            ready, _, _ = select([sys.stdin], [], [], 1 / 60)
+            if not ready:
+                continue
+            key = ReadKey()
+            if key == "":
+                raise EOFError
+            if key in ("\n", "\r"):
+                target = body.targethead
+                if target == body.head and len(body.heads) > 1:
+                    body.MoveTarget(+1)
+                    target = body.targethead
+                    body.RenderStatus()
+                return ("FEED", target, body.amount)
+            if key == "\x03":
+                raise KeyboardInterrupt
+            if key == "\x18":
+                body.SoftReboot()
+                continue
+            if key in ("h", "H"):
+                return "HUNGER"
+            if key == "C":
+                body.MoveTarget(+1)
+            elif key == "D":
+                body.MoveTarget(-1)
+            elif key == "A":
+                body.amount = min(999, body.amount + 1)
+            elif key == "B":
+                body.amount = max(-999, body.amount - 1)
+            else:
+                continue
+            body.RenderStatus()
+    finally:
+        termios.tcsetattr(filedescriptor, termios.TCSADRAIN, original)
+
+def RunBody(*, heart: Heart, head: str, port: int, peers: List[Tuple[str, int]], heads: List[str]) -> None:
+    sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+    sock.setsockopt(socket.SOL_SOCKET, socket.SO_SNDBUF, 1 << 20)
+    sock.setsockopt(socket.SOL_SOCKET, socket.SO_RCVBUF, 1 << 20)
+    if any(host == "255.255.255.255" for host, _ in peers):
+        sock.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
+    sock.bind(("0.0.0.0", int(port)))
+    body = Body(head=str(head).upper(), heads=list(heads), sock=sock, peers=list(peers), heart=heart, lock=threading.Lock(), targethead=FirstTarget(head, heads))
+    Receiver(body).start()
+    with PrintLock:
+        sys.stdout.write("\x1b[2J\x1b[H")
+        sys.stdout.write(HideCursor)
+        sys.stdout.flush()
+    body.RenderStatus()
+    with body.lock:
+        body.SendHunger(body.Crown(), needtail=True)
+    try:
+        while True:
+            command = ReadCommand(body)
+            if command == "HUNGER":
+                with body.lock:
+                    body.SendHunger(body.Crown(), needtail=True)
+                continue
+            if isinstance(command, tuple) and command[0] == "FEED":
+                _, tohead, amount = command
+                with body.lock:
+                    intents = heart.Ingest(dict(heart.Propose(tohead, amount)))
+                body.ExecuteIntents(intents)
+    except (KeyboardInterrupt, EOFError) as exc:
+        raise ExitSignal() from exc
+    finally:
+        with PrintLock:
+            sys.stdout.write(ShowCursor)
+            sys.stdout.flush()

hydra_game-1.0.0/Game/Mutate.py

@@ -0,0 +1,288 @@
+from __future__ import annotations
+import json
+import socket
+import sys
+import termios
+import tty
+from select import select
+from typing import Dict, List, Optional, Set, Tuple
+
+from .Plexus import Plexus
+from .Body import ExitSignal, RunBody
+from .Pulse import AwakeField, Clear, ExitLine, HideCursor, Index, Now, Phase, ReadKey, RenderCentered, RenderField, ShowCursor
+
+BaseHeads = ["A", "B", "C", "D", "E"]
+Fields = ["environment", "depth", "mutation", "head", "awakening"]
+Labels = {
+    "environment": "ENVIRONMENT",
+    "depth": "DEPTH",
+    "mutation": "MUTATIONS",
+    "head": "HEADS",
+    "awakening": "AWAKENING",
+}
+Options = {
+    "environment": ["Den", "Swamp"],
+    "mutation": ["1", "2", "3", "4", "5"],
+    "head": list(BaseHeads),
+}
+RosterCache: Set[str] = set()
+AwakeInterval = 0.75
+
+
+def BuildDen(heads: List[str], depth: int, head: str) -> Tuple[int, List[Tuple[str, int]]]:
+    ports = {item: depth + index for index, item in enumerate(heads)}
+    return ports[head], [("127.0.0.1", ports[item]) for item in heads if item != head]
+
+
+def BuildSwamp(heads: List[str], depth: int, head: str) -> Tuple[int, List[Tuple[str, int]]]:
+    return depth, [("255.255.255.255", depth)]
+
+
+def ExitScreen() -> None:
+    filedescriptor = sys.stdin.fileno()
+    original = termios.tcgetattr(filedescriptor)
+    tty.setcbreak(filedescriptor)
+    start = Now()
+    lastpulse = None
+
+    try:
+        sys.stdout.write(HideCursor)
+        Clear()
+        while True:
+            phase = Phase(start)
+            pulse = Index(phase, 4)
+            if pulse != lastpulse:
+                RenderCentered([ExitLine(phase)], bias=0.5)
+                lastpulse = pulse
+            try:
+                ready, _, _ = select([sys.stdin], [], [], 1 / 60)
+            except KeyboardInterrupt:
+                return
+            if ready:
+                try:
+                    ReadKey()
+                except KeyboardInterrupt:
+                    pass
+                return
+    finally:
+        termios.tcsetattr(filedescriptor, termios.TCSADRAIN, original)
+        Clear()
+        sys.stdout.write(ShowCursor)
+        sys.stdout.flush()
+
+
+def MutateShell() -> Dict[str, str]:
+    state = {"environment": "Den", "depth": "12321", "mutation": "1", "head": "A"}
+    fieldstep = 0
+    awakensock: Optional[socket.socket] = None
+    awakeheads: Set[str] = set()
+    expectedheads: Set[str] = set()
+    awakevalue = ""
+    awakenready = False
+    lastawakesent = 0.0
+
+    def CurrentHeads() -> List[str]:
+        return BaseHeads[:int(state["mutation"])]
+
+    def ClampHead() -> None:
+        heads = CurrentHeads()
+        if state["head"] not in heads:
+            state["head"] = heads[0]
+
+    def Network() -> Tuple[int, List[Tuple[str, int]]]:
+        heads = CurrentHeads()
+        depth = int(state["depth"])
+        return BuildDen(heads, depth, state["head"]) if state["environment"] == "Den" else BuildSwamp(heads, depth, state["head"])
+
+    def AwakeSend() -> None:
+        if awakensock is None:
+            return
+        message = json.dumps({"type": "AWAKE", "head": state["head"], "heads": CurrentHeads()}, separators=(",", ":")).encode("utf-8")
+        _, peers = Network()
+        for host, peerport in peers:
+            try:
+                awakensock.sendto(message, (host, peerport))
+            except Exception:
+                pass
+
+    def OpenAwakening() -> None:
+        nonlocal awakensock, awakeheads, expectedheads, awakevalue, awakenready, lastawakesent
+        global RosterCache
+        if awakensock is not None:
+            return
+        port, _ = Network()
+        awakensock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+        awakensock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+        if state["environment"] == "Swamp":
+            awakensock.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
+        try:
+            awakensock.bind(("0.0.0.0", port))
+        except OSError as exc:
+            try:
+                awakensock.close()
+            except Exception:
+                pass
+            awakensock = None
+            raise ExitSignal() from exc
+        awakensock.setblocking(False)
+        expectedheads = set(CurrentHeads())
+        awakeheads = {item for item in RosterCache if item in expectedheads}
+        awakeheads.add(state["head"])
+        RosterCache = set(awakeheads)
+        awakevalue = AwakeField(awakeheads)
+        awakenready = False
+        lastawakesent = 0.0
+        for _ in range(3):
+            AwakeSend()
+        lastawakesent = Now()
+
+    def CloseAwakening() -> None:
+        nonlocal awakensock, awakeheads, expectedheads, awakevalue, awakenready, lastawakesent
+        global RosterCache
+        if awakeheads:
+            RosterCache = set(awakeheads)
+        if awakensock is not None:
+            try:
+                awakensock.close()
+            except Exception:
+                pass
+        awakensock = None
+        awakeheads = set()
+        expectedheads = set()
+        awakevalue = ""
+        awakenready = False
+        lastawakesent = 0.0
+
+    def PollAwakening() -> None:
+        nonlocal awakevalue, awakenready, lastawakesent, expectedheads, awakeheads
+        if awakensock is None:
+            return
+        now = Now()
+        if not awakenready and now - lastawakesent >= AwakeInterval:
+            AwakeSend()
+            lastawakesent = now
+        while True:
+            try:
+                data, _ = awakensock.recvfrom(1024)
+            except BlockingIOError:
+                break
+            except Exception:
+                break
+            try:
+                message = json.loads(data.decode("utf-8"))
+            except Exception:
+                continue
+            if not isinstance(message, dict):
+                continue
+            incoming = str(message.get("head", "") or "").strip().upper()
+            incomingheads = {str(item).upper() for item in list(message.get("heads", []) or []) if str(item).strip()}
+            messagetype = str(message.get("type", "") or "")
+            if messagetype == "AWAKE":
+                if incomingheads:
+                    expectedheads = set(incomingheads)
+                if incoming and incoming not in awakeheads:
+                    awakeheads.add(incoming)
+                    AwakeSend()
+                    lastawakesent = Now()
+                continue
+            if messagetype == "ROSTER":
+                if incomingheads:
+                    expectedheads = set(incomingheads)
+                    awakeheads.update(incomingheads)
+                if incoming:
+                    awakeheads.add(incoming)
+        awakevalue = AwakeField(awakeheads)
+        awakenready = bool(expectedheads) and awakeheads >= expectedheads
+
+    filedescriptor = sys.stdin.fileno()
+    original = termios.tcgetattr(filedescriptor)
+    tty.setcbreak(filedescriptor)
+    start = Now()
+    lastpulse = None
+    lastfield = None
+    lastvalue = None
+
+    try:
+        sys.stdout.write(HideCursor)
+        Clear()
+        while True:
+            field = Fields[fieldstep]
+            if field == "awakening":
+                OpenAwakening()
+                PollAwakening()
+            phase = Phase(start)
+            value = awakevalue if field == "awakening" else state[field]
+            pulse = Index(phase, 9)
+            if pulse != lastpulse or field != lastfield or value != lastvalue:
+                RenderField("Mutate", Labels[field], value, phase)
+                lastpulse = pulse
+                lastfield = field
+                lastvalue = value
+            if field == "awakening" and awakenready:
+                CloseAwakening()
+                return state
+            try:
+                ready, _, _ = select([sys.stdin], [], [], 1 / 60)
+            except KeyboardInterrupt:
+                raise ExitSignal
+            if not ready:
+                continue
+            try:
+                key = ReadKey()
+            except KeyboardInterrupt:
+                raise ExitSignal
+            field = Fields[fieldstep]
+            if key == "\x03" or field == "awakening":
+                raise ExitSignal
+            if key in ("\n", "\r", "C"):
+                fieldstep = min(len(Fields) - 1, fieldstep + 1)
+                continue
+            if key == "D":
+                fieldstep = max(0, fieldstep - 1)
+                continue
+            if key in ("A", "B"):
+                direction = 1 if key == "A" else -1
+                if field == "depth":
+                    state["depth"] = f"{max(0, min(99999, int(state['depth']) + direction)):05d}"
+                    continue
+                fieldoptions = Options.get(field)
+                if fieldoptions is not None:
+                    index = fieldoptions.index(state[field])
+                    if field == "head":
+                        direction = -direction
+                    state[field] = fieldoptions[(index + direction) % len(fieldoptions)]
+                    if field == "mutation":
+                        ClampHead()
+                continue
+            if not key.isprintable():
+                continue
+            if field == "mutation" and key in "12345":
+                state["mutation"] = key
+                ClampHead()
+            elif field == "head":
+                typed = key.upper()
+                if typed in BaseHeads:
+                    state["head"] = typed
+                    ClampHead()
+    finally:
+        CloseAwakening()
+        termios.tcsetattr(filedescriptor, termios.TCSADRAIN, original)
+        Clear()
+        sys.stdout.write(ShowCursor)
+        sys.stdout.flush()
+
+
+def Mutate() -> None:
+    try:
+        state = MutateShell()
+        heads = BaseHeads[:int(state["mutation"])]
+        head = state["head"] if state["head"] in heads else heads[0]
+        depth = int(state["depth"])
+        port, peers = BuildDen(heads, depth, head) if state["environment"] == "Den" else BuildSwamp(heads, depth, head)
+        RunBody(heart=Plexus(head=head, heads=heads), head=head, port=port, peers=peers, heads=heads)
+    except ExitSignal:
+        ExitScreen()
+
+
+if __name__ == "__main__":
+    Mutate()

hydra_game-1.0.0/Game/Plexus.py

@@ -0,0 +1,193 @@
+from __future__ import annotations
+from dataclasses import dataclass
+from typing import Any, Dict, List, Optional, Literal
+
+Gems = {1: "Onyx", 2: "Jade", 3: "Opal"}
+
+def GemName(g: int) -> str:
+    return Gems.get(int(g or 1), "G?")
+
+def CrownNext(c: int) -> int:
+    return 1 if int(c) >= 3 else int(c) + 1
+
+IntentType = Literal["Propagate", "RequestSync", "Envy"]
+
+@dataclass(frozen=True)
+class Intent:
+    type: IntentType
+    payload: Dict[str, Any]
+
+@dataclass
+class Tetron:
+    tallies: Dict[str, int]
+
+    def Snapshot(self) -> Dict[str, Any]:
+        return {
+            "tallies": dict(self.tallies),
+            "is_dream": True,
+        }
+
+@dataclass
+class PlexusState:
+    tallies: Dict[str, int]
+    crown: int
+    head: Optional[str] = None
+
+class Plexus:
+    def __init__(self, head: str, heads: List[str]) -> None:
+        self.head = str(head)
+        self.heads = list(heads)
+
+        tallies = {h: 10 for h in self.heads}
+
+        self.tetron = Tetron(tallies=dict(tallies))
+        self.state = PlexusState(
+            tallies=dict(tallies),
+            crown=1,
+            head=None,
+        )
+
+        self.tail: Optional[Dict[str, Any]] = None
+        self.envy: bool = False
+
+    def Snapshot(self) -> Dict[str, Any]:
+        return {
+            "head": self.head,
+            "tallies": dict(self.state.tallies),
+            "crown": int(self.state.crown),
+            "is_dream": False,
+        }
+
+    def Emotions(self) -> Dict[str, Any]:
+        return {"envy": bool(self.envy)}
+
+    def DreamState(self) -> Dict[str, Any]:
+        d = self.tetron.Snapshot()
+        d["crown"] = int(self.state.crown)
+        return d
+
+    def EnvyReanchor(self) -> Dict[str, Any]:
+        return {
+            "head": self.head,
+            "tallies": dict(self.tetron.tallies),
+            "crown": int(self.state.crown),
+            "is_dream": True,
+            "mode": "Envy",
+        }
+
+    def ExpectedTotal(self) -> int:
+        return 10 * len(self.heads)
+
+    def TalliesTotal(self, tallies: Dict[str, Any]) -> int:
+        return sum(int(value or 0) for value in dict(tallies or {}).values())
+
+    def ValidTotal(self, tallies: Dict[str, Any]) -> bool:
+        return self.TalliesTotal(tallies) == self.ExpectedTotal()
+
+    def Propose(self, tohead: str, amount: int) -> Dict[str, Any]:
+        if self.envy:
+            return self.EnvyReanchor()
+
+        tallies = dict(self.state.tallies)
+        tallies[self.head] = tallies.get(self.head, 0) - int(amount)
+        tallies[tohead] = tallies.get(tohead, 0) + int(amount)
+
+        return {
+            "head": self.head,
+            "tallies": tallies,
+            "crown": CrownNext(self.state.crown),
+        }
+
+    def Ingest(self, tailin: Dict[str, Any]) -> List[Intent]:
+        intents: List[Intent] = []
+
+        if tailin.get("is_dream"):
+            dreamtallies = dict(tailin.get("tallies", {}) or {})
+
+            # ================= LINCHPIN ================= #
+            if dreamtallies and not self.ValidTotal(dreamtallies):
+            # ============================================ #
+                if not self.envy:
+                    self.envy = True
+                    intents.append(Intent("Envy", {
+                        "expectedtotal": self.ExpectedTotal(),
+                        "incomingtotal": self.TalliesTotal(dreamtallies),
+                    }))
+
+                intents.append(Intent("RequestSync", {
+                    "crown": int(self.state.crown),
+                    "gem": GemName(self.state.crown),
+                    "needtail": True,
+                }))
+                return intents
+
+            if dreamtallies and dreamtallies != self.state.tallies:
+                self.state.tallies = dict(dreamtallies)
+                self.tetron.tallies = dict(dreamtallies)
+
+            if self.envy:
+                self.envy = False
+
+            return intents
+
+        incomingtallies = dict(tailin.get("tallies", {}))
+        inccrown = int(tailin.get("crown", self.state.crown))
+
+        cur = int(self.state.crown)
+        exp = CrownNext(cur)
+
+        # ================= LINCHPIN ================= #
+        if inccrown not in (cur, exp):
+        # ============================================ #
+            if not self.envy:
+                self.envy = True
+                intents.append(Intent("Envy", {
+                    "currentcrown": cur,
+                    "incomingcrown": inccrown,
+                }))
+
+            intents.append(Intent("RequestSync", {
+                "crown": cur,
+                "gem": GemName(cur),
+            }))
+            return intents
+
+        # ================= LINCHPIN ================= #
+        if not self.ValidTotal(incomingtallies):
+        # ============================================ #
+            if not self.envy:
+                self.envy = True
+                intents.append(Intent("Envy", {
+                    "expectedtotal": self.ExpectedTotal(),
+                    "incomingtotal": self.TalliesTotal(incomingtallies),
+                }))
+
+            intents.append(Intent("RequestSync", {
+                "crown": cur,
+                "gem": GemName(cur),
+                "needtail": True,
+            }))
+            return intents
+
+        if self.envy:
+            self.envy = False
+
+        if incomingtallies == self.state.tallies:
+            return intents
+
+        self.state.tallies = dict(incomingtallies)
+        self.state.crown = inccrown
+        self.state.head = str(tailin.get("head", "")) or None
+
+        self.tetron.tallies = dict(incomingtallies)
+        self.tail = dict(tailin)
+
+        intents.append(Intent("Propagate", {"tail": dict(self.tail)}))
+
+        if inccrown == exp:
+            intents.append(Intent("RequestSync", {
+                "crown": inccrown,
+                "gem": GemName(inccrown),
+            }))
+
+        return intents

hydra_game-1.0.0/Game/Pulse.py

@@ -0,0 +1,144 @@
+from __future__ import annotations
+import re
+import shutil
+import sys
+import time
+from typing import Iterable, Sequence, Set, Tuple
+
+Reset = "\x1b[0m"
+Ash = "\x1b[90m"
+Blue = "\x1b[36m"
+Green = "\x1b[92m"
+Teal = "\x1b[38;2;0;150;130m"
+HideCursor = "\x1b[?25l"
+ShowCursor = "\x1b[?25h"
+AnsiPattern = re.compile(r"\x1b\[[0-9;]*m")
+PulseRate = 7.0
+
+BubbleFrames = [
+    "",
+    "0",
+    "o0o",
+    ".o0o.",
+    "o.o0o.o",
+    "0o.o0o.o0",
+    "o0o.o0o.o0o",
+    ".o0o.o0o.o0o.",
+    "..o0o.o0o.o0o..",
+]
+
+ExitFrames = ["", ".", "..", "..."]
+
+def Now() -> float:
+    return time.monotonic()
+
+def Step(rate: float = PulseRate) -> int:
+    return int(Now() * float(rate or 0.0))
+
+def Phase(start: float, speed: float = PulseRate) -> float:
+    return (Now() - float(start or 0.0)) * float(speed or 0.0)
+
+def Index(phase: float, frames: int) -> int:
+    if frames <= 1:
+        return 0
+    span = (frames * 2) - 2
+    index = int(phase) % span
+    if index >= frames:
+        index = span - index
+    return index
+
+def FlickerCycle(sequence: Sequence[str], rate: float = PulseRate, fallback: str = Teal) -> str:
+    if not sequence:
+        return fallback
+    return sequence[Step(rate) % len(sequence)]
+
+def Flicker1() -> str:
+    return FlickerCycle((Green, Blue, Teal))
+
+def Flicker2() -> str:
+    return FlickerCycle((Green, Teal))
+
+def Flicker3() -> str:
+    return FlickerCycle((Teal, Blue))
+
+def Flicker4() -> str:
+    return FlickerCycle((Blue, Teal))
+
+def VisibleLength(text: str) -> int:
+    return len(AnsiPattern.sub("", str(text or "")))
+
+def PadLine(text: str, width: int) -> str:
+    built = str(text or "")
+    visible = VisibleLength(built)
+    if visible < width:
+        built += " " * (width - visible)
+    return built
+
+def Center(text: str, width: int = 80) -> str:
+    line = str(text or "")
+    gap = max(0, (width - VisibleLength(line)) // 2)
+    built = (" " * gap) + line
+    visible = VisibleLength(built)
+    if visible < width:
+        built += " " * (width - visible)
+    return built
+
+def TerminalSize() -> Tuple[int, int]:
+    size = shutil.get_terminal_size(fallback=(80, 24))
+    return size.columns, size.lines
+
+def VerticalOffset(lines: int, height: int = 24, bias: float = 0.35) -> int:
+    return max(0, int((height - lines) * bias))
+
+def Clear() -> None:
+    sys.stdout.write("\x1b[2J\x1b[H")
+    sys.stdout.flush()
+
+def CursorLeft(count: int) -> str:
+    return f"\x1b[{count}D" if count > 0 else ""
+
+def ReadKey() -> str:
+    key = sys.stdin.read(1)
+    if key == "\x1b" and sys.stdin.read(1) in ("[", "O"):
+        return sys.stdin.read(1)
+    return key
+
+def RenderCentered(lines: Iterable[str], *, width: int = 80, minimumheight: int = 24, bias: float = 0.35) -> None:
+    linelist = list(lines)
+    _, terminalheight = TerminalSize()
+    height = max(minimumheight, terminalheight)
+    topgap = VerticalOffset(len(linelist), height, bias)
+    sys.stdout.write("\x1b[H")
+    if topgap:
+        sys.stdout.write("\n" * topgap)
+    sys.stdout.write("\n".join(Center(line, width) for line in linelist))
+    sys.stdout.flush()
+
+def TitleLine(text: str) -> str:
+    return f"{Green}.:{Reset}{Teal}{text}{Reset}{Green}:.{Reset}"
+
+def LabelLine(text: str) -> str:
+    return f"{Ash}{text}{Reset}"
+
+def DotField(value: str) -> str:
+    return f"{Green}.{Reset}{Teal}{value}{Reset}{Green}.{Reset}"
+
+def AwakeField(heads: Set[str]) -> str:
+    return "" if not heads else f"{Teal}" + f"{Reset}{Green}.{Reset}{Teal}".join(sorted(heads))
+
+def RenderField(title: str, label: str, value: str, phase: float, bias: float = 0.35) -> None:
+    RenderCentered([
+        TitleLine(title),
+        "",
+        BubbleLine(phase),
+        LabelLine(label),
+        DotField(value),
+    ], bias=bias)
+
+def BubbleLine(phase: float) -> str:
+    return f"{Ash}{BubbleFrames[Index(phase, len(BubbleFrames))]}{Reset}"
+
+def ExitLine(phase: float) -> str:
+    dots = ExitFrames[Index(phase, len(ExitFrames))]
+    message = f"{Teal}Sniff{Green}.{Teal}Snort{Green}..{Teal}RAWR{Green}...{Teal}bye{Reset}"
+    return f"{Green}{dots}{Reset}{Teal}{message}{Reset}{Green}{dots}{Reset}"

hydra_game-1.0.0/Hydra.py

@@ -0,0 +1,7 @@
+from Game import Mutate
+
+def Hydra():
+    Mutate.Mutate()
+
+if __name__ == "__main__":
+    Hydra()

hydra_game-1.0.0/Hydra_Game.egg-info/PKG-INFO

@@ -0,0 +1,4 @@
+Metadata-Version: 2.4
+Name: Hydra-Game
+Version: 1.0.0
+Summary: Terminal entrypoint for Hydra

hydra_game-1.0.0/Hydra_Game.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+Hydra.py
+README.md
+pyproject.toml
+Game/Body.py
+Game/Mutate.py
+Game/Plexus.py
+Game/Pulse.py
+Hydra_Game.egg-info/PKG-INFO
+Hydra_Game.egg-info/SOURCES.txt
+Hydra_Game.egg-info/dependency_links.txt
+Hydra_Game.egg-info/entry_points.txt
+Hydra_Game.egg-info/top_level.txt

hydra_game-1.0.0/Hydra_Game.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

hydra_game-1.0.0/Hydra_Game.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+Hydra = Hydra:main

hydra_game-1.0.0/Hydra_Game.egg-info/top_level.txt

@@ -0,0 +1,2 @@
+Game
+Hydra

hydra_game-1.0.0/PKG-INFO

@@ -0,0 +1,4 @@
+Metadata-Version: 2.4
+Name: Hydra-Game
+Version: 1.0.0
+Summary: Terminal entrypoint for Hydra

hydra_game-1.0.0/README.md

@@ -0,0 +1,80 @@
+# 🐍 Hydra 🐍
+
+**Hands-on network toy where packets collide and state flows.**
+
+---
+
+<img src="../Relics/Awake.gif"/>
+
+---
+
+## 🪵 Swamp Thing
+
+In **Hydra**, the state is *fluid*. Nodes can leave, rejoin, and rehydrate instantly with almost no ceremony. Move between a **den** or a **swamp**, across machines or terminals.
+
+As long as your **head is unique** and you share the same **depth**, your node will simply **snap to what is**. *What holds is what remains.*
+
+Hydra is a distributed expression of the **Oblivious Compute system**. It is not a coordinated network, but a field of independent nodes sharing a single **admissible state**. Each node emits and each node observes, and what persists is simply what the network accepts.
+
+**There is no leader and no history—only convergence.**
+
+> Simply put, this is a distributed packet collider in under a thousand lines of code.
+
+---
+
+## ⬇️ Install
+
+To run Hydra, install it with:
+```bash
+pipx install Hydra-Braid  
+Hydra
+```
+You’ll need **Python 3.9 or newer** and an **80x24 UNIX-like terminal environment.**
+
+---
+
+## 🐧 Operating System Support
+
+- ✅ Linux  
+- ✅ macOS  
+- ❌ Windows *(sorry, but not sorry)*
+
+---
+
+## 🌐 Networking
+
+Hydra runs in two modes.
+
+**Den** is local—multiple terminals on the same machine. *(sandbox)*  
+**Swamp** runs across a LAN, allowing multiple machines to share the same **Braid**.
+
+> *All nodes must use the same depth (port), and the same number of mutated heads.*  
+> *Each node must use a unique head.*
+
+<img src="../Relics/Spam.gif"/>
+
+> *Run Hydra in a swamp if you want to use it as a packet collider.*  
+> *Push state with multiple machines and see what holds.*
+
+---
+
+🎯 **Intent**
+
+The Hydra Demo has been published as a **public technical disclosure**.
+
+This demo exists to show that **oblivious convergence through an admissability gate** is possible.
+
+If it fails, it fails cleanly.  
+If it works, it demonstrates a **new computational primitive**.
+
+<img src="../Relics/Alpha.png" width="400"/>
+
+<img src="../Relics/Bye.gif" width="400"/>
+
+---
+
+## 📜 License
+
+This project is released under the terms of the [LICENSE](../LICENSE).
+
+Use it, study it, modify it—just respect the terms outlined there.

hydra_game-1.0.0/pyproject.toml

@@ -0,0 +1,14 @@
+[project]
+name = "Hydra-Game"
+version = "1.0.0"
+description = "Terminal entrypoint for Hydra"
+
+[project.scripts]
+Hydra = "Hydra:main"
+
+[tool.setuptools]
+py-modules = ["Hydra"]
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["Game"]

hydra_game-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+