New Strategy Submission: "Schwoba sen gnitz" (A 1985-inspired Reciprocal Hybrid)

.github/workflows/turniertest.yml

@@ -0,0 +1,26 @@
+name: Mein eigenes Axelrod Turnier
+
+on:
+  workflow_dispatch:
+
+jobs:
+  run-tournament:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Code ausleihen
+        uses: actions/checkout@v4
+
+      - name: Python vorbereiten
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.11'
+
+      - name: System-Abhängigkeiten und Axelrod installieren
+        run: |
+          pip install --upgrade pip setuptools wheel
+          # Das sind die fehlenden Pakete, die die KIs zum Überleben brauchen:
+          pip install numpy scipy
+          pip install -e .
+
+      - name: Turnier starten
+        run: python turniertest.py # Oder hier den Namen deiner großen Datei eintragen!

.github/workflows/turniertestvoll.yml

@@ -0,0 +1,26 @@
+name: Das große Axelrod Turnier
+
+on:
+  workflow_dispatch:
+
+jobs:
+  run-tournament:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Code ausleihen
+        uses: actions/checkout@v4
+
+      - name: Python vorbereiten
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.11'
+
+      - name: System-Abhängigkeiten und Axelrod installieren
+        run: |
+          pip install --upgrade pip setuptools wheel
+          # Unverzichtbar für die KIs im großen Feld:
+          pip install numpy scipy
+          pip install -e .
+
+      - name: Turnier starten
+        run: python turniertestvoll.py

axelrod/strategies/_strategies.py

@@ -284,6 +284,7 @@
     ZDMischief,
     ZDSet2,
 )
+from .schwoba_sen_gnitz import SchwobaSenGnitz
 
 # Note: Meta* strategies are handled in .__init__.py
 
@@ -438,6 +439,7 @@
     RevisedDowning,
     Ripoff,
     RiskyQLearner,
+    SchwobaSenGnitz,
     SecondByAppold,
     SecondByBlack,
     SecondByBorufsen,

axelrod/strategies/schwoba_sen_gnitz.py

@@ -0,0 +1,66 @@
+import random
+from axelrod.action import Action
+from axelrod.player import Player
+
+class SchwobaSenGnitz(Player):
+    """
+    Schwoba sen gnitz (Schwaben sind gerissen) - Python-Version 2026.
+    Autor: Georg 'HackyHackberger' Schmidt (1985 / 2026)
+    Ursprünglicher Code in Turbo Pascal, 1985
+    Startet 100 % friedlich. Nach dem ersten gegnerischen Verrat erwacht die 
+    optimierte gnitze Technik: 10,2 % Sondierung, 89,7 % Deeskalation.
+    Erkennt nach 10 Runden unversöhnliche Gegner und riegelt ab.
+    """
+
+    name = "Schwoba sen gnitz"
+    authors = ["Georg 'HackyHackberger' Schmidt"]
+    classifier = {
+        "memory_depth": float("inf"),
+        "stochastic": True,
+        "makes_use_of": set(),
+        "long_run_time": False,
+        "inspects_source": False,
+        "manipulates_state": False,
+        "manipulates_history": False,
+        "uses_length": False,
+        "uses_game": False,
+        "uses_tournament": False,
+        "uses_clones": False,
+    }
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.raubtier_erwacht = False
+        self.schutz_modus_aktiviert = False
+
+    def strategy(self, opponent: Player) -> Action:
+        runde = len(self.history)
+        if runde == 0:
+            return Action.C
+
+        if not self.raubtier_erwacht and opponent.history[-1] == Action.D:
+            self.raubtier_erwacht = True
+
+        if not self.raubtier_erwacht:
+            return Action.C
+
+        if runde >= 10:
+            letzte_10_gegner = opponent.history[-10:]
+            if all(zug == Action.D for zug in letzte_10_gegner):
+                self.schutz_modus_aktiviert = True
+
+        if self.schutz_modus_aktiviert:
+            return Action.D
+
+        if opponent.history[-1] == Action.D:
+            # 89,7 % Deeskalations-Bremse gegen KIs
+            if random.random() < 0.897:
+                return Action.C
+            else:
+                return Action.D
+
+        # 10,2 % gnitze Sondierung
+        if random.random() < 0.102:
+            return Action.D
+
+        return Action.C

turniertest.py

@@ -0,0 +1,25 @@
+import axelrod as axl
+from axelrod.strategies.schwoba_sen_gnitz import SchwobaSenGnitz
+
+# 1. Wir laden deine Strategie und ein paar offizielle Gegner
+players = [
+    SchwobaSenGnitz(),
+    axl.TitForTat(),
+    axl.Grudger(),            # Das ist der Grudger
+    axl.Cooperator(),      # AllC
+    axl.Defector(),        # AllD
+    axl.Alternator() if hasattr(axl, 'Altenator') else axl.Alternator(),
+    axl.Random()
+]
+
+# 2. Turnier starten: 1000 Runden, 5 Wiederholungen für stabile Zufallswerte
+tournament = axl.Tournament(players=players, turns=1000, repetitions=5)
+results = tournament.play()
+
+# 3. Ergebnis sauber im Terminal ausdrucken
+print("\n" + "="*40)
+print("     ERGEBNIS DES CT-RELOADED TURNIERS")
+print("="*40)
+for position, player in enumerate(results.ranked_names, start=1):
+    print(f"{position}. Platz: {player}")
+print("="*40 + "\n")

turniertestvoll.py

@@ -0,0 +1,23 @@
+import axelrod as axl
+
+# Wir erzeugen die Instanzen korrekt mit s()
+# Falls eine kaputte Fremd-Strategie dabei ist, filtert der try-except Block sie aus
+all_players = []
+for s in axl.all_strategies:
+    try:
+        all_players.append(s())
+    except Exception:
+        continue
+
+print(f"Starte das große Turnier mit {len(all_players)} Strategien...")
+
+# 1000 Runden, 1 Wiederholung. Keine Extrafunktionen, um den RAM zu schonen.
+tournament = axl.Tournament(players=all_players, turns=200, repetitions=1)
+results = tournament.play(progress_bar=False)
+
+print("\n" + "="*50)
+print("     DAS OFFIZIELLE AXELROD HAIFISCHBECKEN (TOP 20)")
+print("="*50)
+for position, player in enumerate(results.ranked_names[:20], start=1):
+    print(f"{position}. Platz: {player}")
+print("="*50 + "\n")