diff --git a/.github/workflows/turniertest.yml b/.github/workflows/turniertest.yml new file mode 100644 index 000000000..b63a7c390 --- /dev/null +++ b/.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! diff --git a/.github/workflows/turniertestvoll.yml b/.github/workflows/turniertestvoll.yml new file mode 100644 index 000000000..49c089854 --- /dev/null +++ b/.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 diff --git a/axelrod/strategies/_strategies.py b/axelrod/strategies/_strategies.py index bc80eeccc..d800aa46c 100644 --- a/axelrod/strategies/_strategies.py +++ b/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, diff --git a/axelrod/strategies/schwoba_sen_gnitz.py b/axelrod/strategies/schwoba_sen_gnitz.py new file mode 100644 index 000000000..6b8415803 --- /dev/null +++ b/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 diff --git a/turniertest.py b/turniertest.py new file mode 100644 index 000000000..93d1e0a8b --- /dev/null +++ b/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") diff --git a/turniertestvoll.py b/turniertestvoll.py new file mode 100644 index 000000000..e658e6d1a --- /dev/null +++ b/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")