WordGame/game.py

import random, string, json
from tracemalloc import start

global word_list
global letters_dict

with open("wordlist.txt", "r") as f:
    word_list = [i.strip() for i in f.readlines()]

with open("letters.json", "r") as f:
    letters_dict = json.load(f)


def randomword(length):
    letters = string.ascii_lowercase
    return "".join(random.choice(letters) for i in range(length))


class Player:
    def __init__(self, name):
        self.id = randomword(10)
        self.name = name
        self.tiles = []
        self.score = 0


class Game:
    def __init__(self, name, hand_size, match_amount, turns, id=None):
        self.id = id or randomword(5)
        self.player1 = Player(name)
        self.tile_pile = []
        self.discard_pile = []
        self.current_word = ""
        self.hand_size = hand_size
        self.match_amount = match_amount
        self.turns = turns

        for key, value in letters_dict.items():
            for i in range(value["occurrence"]):
                self.tile_pile.append(key)

    def player_join(self, name):
        self.player2 = Player(name)

    def start_game(self):
        for i in range(self.hand_size):
            tile = random.choice(self.tile_pile)
            self.player1.tiles.append(tile)
            self.tile_pile.remove(tile)

            tile = random.choice(self.tile_pile)
            self.player2.tiles.append(tile)
            self.tile_pile.remove(tile)

        starting_player = random.choice([self.player1, self.player2])
        self.current_player = starting_player
        self.starting_player = starting_player
        return starting_player

    def change_turn(self):
        if self.current_player != self.starting_player:
            self.turns -= 1
            if not self.turns:
                return False

        self.current_player = (
            self.player1
            if self.current_player == self.player2
            else self.player2
        )

        while len(self.current_player.tiles) < self.hand_size:
            tile = random.choice(self.tile_pile)
            self.current_player.tiles.append(tile)
            self.tile_pile.remove(tile)

            if not self.tile_pile:
                self.tile_pile = self.discard_pile
                self.discard_pile = []

        return True

    def check_word(self, word):
        final_word = {
            "valid": False,
            "word": [{"letter": letter, "status": 0} for letter in list(word)],
        }

        score = 0
        for letter in list(word):
            score += int(letters_dict[letter]["tile_value"])
        final_word["score"] = score

        if word not in word_list:
            return final_word

        temp_player_tiles = self.current_player.tiles.copy()
        remaining_letters = []

        for item in final_word["word"]:
            if item["letter"] in temp_player_tiles:
                item["status"] = 1
                temp_player_tiles.remove(item["letter"])
            else:
                remaining_letters.append(item["letter"])

        match_count = 0

        previous_word = list(self.current_word)
        for letter in remaining_letters.copy():
            if letter in previous_word:
                remaining_letters.remove(letter)
                previous_word.remove(letter)
                for item in final_word["word"]:
                    if item["letter"] == letter and not item["status"]:
                        item["status"] = 2
                match_count += 1

        # TODO: Somehow remain invalid if there's anything left in the remaining_letters list

        if match_count < self.match_amount:
            for item in final_word["word"]:
                if item["letter"] in previous_word and item["status"] == 1:
                    item["status"] = 2
                    match_count += 1
                    temp_player_tiles.append(item["letter"])
                    if match_count == self.match_amount:
                        break

        if (
            match_count == self.match_amount or not self.current_word
        ) and not remaining_letters:
            final_word["valid"] = True

        if final_word["valid"]:
            self.current_player.score += final_word["score"]
            self.current_word = word
            self.current_player.tiles = temp_player_tiles
        return final_word

    def discard_letter(self, letter):
        if letter not in self.current_player.tiles:
            return False

        self.current_player.remove(letter)
        self.change_turn()
        return True


if __name__ == "__main__":
    game = Game("testplayer", 7, 2, 2)
    game.player_join("testplayer2")
    game.start_game()
    while True:
        print("Turns: " + str(game.turns))
        print(game.current_player.tiles)
        word = game.check_word(input("Word: "))
        print(word)
        if word["valid"]:
            if not game.change_turn():
                break
    pass