From 1f11ca9009d3579291c9b6d862e40e2f6790419c Mon Sep 17 00:00:00 2001 From: Adrian Gunnar Lauterer Date: Sat, 6 Apr 2024 22:13:22 +0200 Subject: [PATCH] add main.py Signed-off-by: Adrian Gunnar Lauterer --- main.py | 299 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 299 insertions(+) create mode 100644 main.py diff --git a/main.py b/main.py new file mode 100644 index 0000000..c974682 --- /dev/null +++ b/main.py @@ -0,0 +1,299 @@ +from time import sleep +import requests +import numpy as np +import random +import argparse + +ozai_url = 'http://localhost:8000/api/' + + +# ozai classes (some are just storing json data because i am ) + +class Player: + def __init__(self, name, gamedata_player_json): + self.name = name + self.ready = gamedata_player_json['ready'] + self.points = gamedata_player_json['points'] + self.pattern_lines = gamedata_player_json['pattern_lines'] #'pattern_lines': [{'color': None, 'number': 0}, {'color': None, 'number': 0}, {'color': None, 'number': 0}, {'color': None, 'number': 0}, {'color': None, 'number': 0}], + self.wall = gamedata_player_json['wall'] # 'wall': [[False, False, False, False, False], [False, False, False, False, False], [False, False, False, False, False], [False, False, False, False, False], [False, False, False, False, False]] + self.floor = gamedata_player_json['floor'] + + def __str__(self): + return f"Player(name={self.name}, ready={self.ready}, points={self.points}, pattern_lines={self.pattern_lines}, wall={self.wall}, floor={self.floor})" + +class Bag: + def __init__(self, bag_json): + self.blue = bag_json['blue'] + self.yellow = bag_json['yellow'] + self.red = bag_json['red'] + self.black = bag_json['black'] + self.white = bag_json['white'] + + def __str__(self): + return f"Bag(blue={self.blue}, yellow={self.yellow}, red={self.red}, black={self.black}, white={self.white})" + +class Factory: + def __init__(self, factory_json): + self.blue = factory_json['blue'] + self.yellow = factory_json['yellow'] + self.red = factory_json['red'] + self.black = factory_json['black'] + self.white = factory_json['white'] + + def __str__(self): + return f"Factory(blue={self.blue}, yellow={self.yellow}, red={self.red}, black={self.black}, white={self.white})" + +class Market: + def __init__(self, market_json): + self.start = market_json['start'] + self.blue = market_json['blue'] + self.yellow = market_json['yellow'] + self.red = market_json['red'] + self.black = market_json['black'] + self.white = market_json['white'] + + def __str__(self): + return f"Market(start={self.start}, blue={self.blue}, yellow={self.yellow}, red={self.red}, black={self.black}, white={self.white})" + +class PatternLine: + def __init__(self, pattern_line_json): + self.color = pattern_line_json['color'] + self.number = pattern_line_json['number'] + + def __str__(self): + return f"PatternLine(color={self.color}, number={self.number})" + +class Wall: + def __init__(self, wall_json): + self.wall = wall_json + def __str__(self): + return f"Wall(wall={self.wall})" + +class Floor: + def __init__(self, floor_json): + self.start = floor_json['start'] + self.blue = floor_json['blue'] + self.yellow = floor_json['yellow'] + self.red = floor_json['red'] + self.black = floor_json['black'] + self.white = floor_json['white'] + + def __str__(self): + return f"Floor(start={self.start}, blue={self.blue}, yellow={self.yellow}, red={self.red}, black={self.black}, white={self.white})" + +class GameState: + def __init__(self, gamedata_json): + json = gamedata_json + self.n_players = json['n_players'] + self.current_player = json['current_player'] + self.starting_player = json['starting_player'] + self.player_names = json['player_names'] + self.game_end = json['game_end'] + self.rounds = json['rounds'] + self.days = json['days'] + self.bag = Bag(json['bag']) + self.lid = Bag(json['lid']) # Assuming lid has the same structure as bag + self.factories = [Factory(factory_json) for factory_json in json['factories']] + self.market = Market(json['market']) + self.players = [Player(name, player_json) for name, player_json in json['players'].items()] + def __str__(self): + return f"GameState(n_players={self.n_players}, current_player={self.current_player}, starting_player={self.starting_player}, player_names={self.player_names}, game_end={self.game_end}, rounds={self.rounds}, days={self.days}, bag={self.bag}, lid={self.lid}, factories={self.factories}, market={self.market}, players={self.players})" + +def init_game(names=["a", "b"]): + #initialize a game with the given names and return the game_id + player_names = {"player_names": names} + response = requests.post(ozai_url + 'game', json=player_names) + if response.status_code == 200: + game_id = response.json() + print("Game ID:", game_id) + return game_id + else: + return None + +def join_game(game_id, player_name): + #gets a initialized game and joins the game with the given player name + response = requests.get(ozai_url + 'game/' + game_id + '?player=' + player_name) + if response.status_code != 200: + return None + players = response.json().get('players') + return players + +def create_game(names=["a", "b"]): + # Create a game with the players given in names, by initializing it and joining the players + game_id = init_game(names) + for name in names: + join_game(game_id, name) + return game_id + +def submit_action(game_id, player_name, source=0, destination=0, color="start", policy="strict"): + # Submit an action to the game. The action is a dictionary with the keys being the action type and the values being the arguments. + # Example: {"player": 0, "market": true, "factory": 0, "color": "blue", "patternLine": 0} + if source != "market": + if source < 0 or source > 4: + return False + if destination != "floor": + if destination < 0 or destination > 4: + return False + action = { + 'player': str(player_name), + 'policy': policy, + 'color': str(color).lower(), + 'source': source, + 'destination': destination + } + response = requests.put(ozai_url + 'game/' + game_id, json=action) + if response.status_code == 200: + return True + else: + return False + +def get_gamestate(game_id) -> GameState: + response = requests.get(ozai_url + 'game/' + game_id) + if response.status_code == 200: + game_state = response.json() + game_state = GameState(game_state) + return game_state + else: + return None + +def get_score(game_id, player_name): + GameState = get_gamestate(game_id) + for player in GameState.players: + if player_name == player.name: + return player.points + +def game_over(game_id): + try: + GameState = get_gamestate(game_id) + return GameState.game_end + except: + return False + +def get_all_valid_moves(game_id, player_name): + # Get the game state + GameState = get_gamestate(game_id) + # Generate a list of all possible moves + sources = ["market"] + [i for i, factory in enumerate(GameState.factories) if any([factory.blue, factory.yellow, factory.red, factory.black, factory.white])] + colors = ["blue", "yellow", "red", "black", "white"] + destinations = ["floor"] + list(range(len(GameState.factories))) + valid_moves = [] + for source in sources: + for color in colors: + for destination in destinations: + # Check if the source has the color we want to move + if source == "market": + amount = getattr(GameState.market, color) + if amount > 0: + valid_moves.append((source, destination, color, amount)) + else: + amount = getattr(GameState.factories[source], color) + if amount > 0: + valid_moves.append((source, destination, color, amount)) + + # Filter out invalid destinations if the destinaiton is a pattern line, and the wall contains the color + wall_colors = [ + ['blue', 'yellow', 'red', 'black', 'white'], + ['white', 'blue', 'yellow', 'red', 'black'], + ['black', 'white', 'blue', 'yellow', 'red'], + ['red', 'black', 'white', 'blue', 'yellow'], + ['yellow', 'red', 'black', 'white', 'blue'], + ] + moves = [] + player = [player for player in GameState.players if player.name == player_name][0] + for move in valid_moves: + if move[1] == "floor": + moves.append(move) + else: + # print(player.pattern_lines[move[1]]) + #if element in wall is tru convert it to the correct color + player.wall = [[wall_colors[i][j] if player.wall[i][j] else False for j in range(5)] for i in range(5)] + #check that the wall does not contain the color on the same row as the pattern line, and that the pattern line does not contain another color + if not move[2] in player.wall[move[1]]: + if player.pattern_lines[move[1]]['color'] == move[2] or player.pattern_lines[move[1]]['color'] == None: + moves.append(move) + valid_moves = moves + return valid_moves + + +### +# strategies for filtering in the do_move solution. +### +def strategy_1(move, GameState,player): + #strategy 1 most fit always 530points 27-3 + if move[1] == 'floor': + return True + remaining_space = move[1] + 1 - player.pattern_lines[move[1]]['number'] + if move[3] >= remaining_space-1 and move[3] <= remaining_space +1: + return True + else: + return False + +def strategy_2(move,GameState,player): + #strategy 2 tierdoff fitting. 983 30-0 + if move[1] == 'floor': + return True + remaining_space = move[1] + 1 - player.pattern_lines[move[1]]['number'] + + if move[1] == 4: + if move[3] <= remaining_space and move[3] >= remaining_space -2: + return True + if move[1] == 3: + if move[3] <= remaining_space and move[3] >= remaining_space -1: + return True + if move[1] < 3: + if move[3] <= remaining_space and move[3] >= remaining_space: + return True + return False + +def strategy_random(move, GameState,player): + return True #do not filter any moves + +def do_move(game_id, player_name, filter_strategy=strategy_random): + moves = get_all_valid_moves(game_id, player_name) + try: + GameState = get_gamestate(game_id) + player = [player for player in GameState.players if player.name == player_name][0] + filtered_moves = [] + for move in moves: + if filter_strategy(move,GameState,player): + filtered_moves.append(move) + # Submit a random move, of the filtered ones. + move = random.choice(filtered_moves) + submit_action(game_id, player_name, move[0], move[1], move[2]) + return move + except: + #if filtered all moves, just submit a random move from the moves + result = random.choice(moves) + return result + +def play_game(gameid, players, strategy): + print(f"Playing game {gameid} with players {players} and strategy {strategy.__name__}") + while not game_over(gameid): + for player in players: + mov = do_move(gameid, player, filter_strategy=strategy) + if game_over(game_id): + print(f"Game Over {player} won") + break + +if __name__ == "__main__": + parser = argparse.ArgumentParser(description='Play a game with specified strategies.') + parser.add_argument('--game_id', type=int, default=0, help='The id of the game to play.') + parser.add_argument('--players', nargs='+', default=["a", "b"], help='The names of the players.') + parser.add_argument('--strategy', type=str, default="", help='The strategy to use. Can be "1", "2", or "" for random.') + parser.add_argument('--ozai_url', type=str, default='http://localhost:8000/api/', help='The url to the ozai server.') + + args = parser.parse_args() + game_id = args.game_id + players = args.players + strategy = args.strategy + #use global ozai url and update it + ozai_url = args.ozai_url + + if game_id == 0: + game_id = create_game(names=players) + if strategy == "1": + play_game(game_id, players, strategy_1) + elif strategy == "2": + play_game(game_id, players, strategy_2) + else: + play_game(game_id, players, strategy_random) \ No newline at end of file