Rock, Paper, Scissors bot for tournament at Recurse Center

rps_bot_v4.py

"""
Gianluca V4: Markov model ++
"""
from skeleton.actions import RockAction, PaperAction, ScissorsAction
from skeleton.bot import Bot
from skeleton.runner import parse_args, run_bot
import math
import random
from collections import defaultdict


class Player(Bot):
    def __init__(self):
        self.actions = [RockAction(), PaperAction(
        ), ScissorsAction()]  # Available actions
        self.order = 3  # Change this to increase pattern length
        self.transition_count = defaultdict(lambda: defaultdict(lambda: 1))
        self.opponent_history = []
        self.my_history = []
        self.payoff_history = []

    def handle_results(self, *, my_action, their_action, my_payoff, match_clock):
        if len(self.opponent_history) >= self.order:
            last_patterns = tuple(self.opponent_history[-self.order:])
            self.transition_count[last_patterns][their_action] += 1

        self.opponent_history.append(their_action)
        self.my_history.append(my_action)
        self.payoff_history.append(my_payoff)

    def predict_next_action(self):
        if len(self.opponent_history) < self.order:
            # Not enough history to use the Markov model
            return random.choice(self.actions)

        last_patterns = tuple(self.opponent_history[-self.order:])
        probabilities = self.transition_count[last_patterns]

        if not probabilities:
            # No data for this pattern, choose an action randomly
            return random.choice(self.actions)

        most_likely_action = max(probabilities, key=probabilities.get)
        return most_likely_action

    def get_action(self, *, match_clock):

        if len(self.payoff_history) > 50 and sum(self.payoff_history) < -5:
            print("this case", len(self.payoff_history),
                  sum(self.payoff_history))
            return random.choice(self.actions)

        # Employ reactive change if consistently losing
        if len(self.payoff_history) > 4 and sum(self.payoff_history[-5:]) < -2:
            return random.choice(self.actions)  # Switch tactics randomly

        # Normal prediction and counter measure
        if len(self.opponent_history) >= self.order:
            prediction = self.predict_next_action()
            return self.counter_action(prediction)

        return random.choice(self.actions)  # Initial fallback

    def counter_action(self, action):
        # Counter moves
        if isinstance(action, RockAction):
            return PaperAction()
        elif isinstance(action, PaperAction):
            return ScissorsAction()
        elif isinstance(action, ScissorsAction):
            return RockAction()


if __name__ == '__main__':
    run_bot(Player(), parse_args())