chain_reaction.py

import numpy as np
print("--- Chain Reaction ---")

class chain_reaction:
    def __init__(self, row_count, column_count):
        self.row_count = row_count
        self.column_count = column_count
        self.cell_count = self.row_count * self.column_count
        self.move_limit = (3 * self.cell_count) - (2 * self.row_count) - (2 * self.column_count) + 1
        self.move_count = 0
        self.unstable_count = 0
        self.infinite_loop = False
        self.full_state = self.get_full_state()
        
    def get_initial_state(self):
        return np.zeros((self.row_count, self.column_count), dtype=int)
        
    def get_full_state(self):
        state = np.zeros((self.row_count, self.column_count), dtype=int)
        # 1 cells - corners
        state[0,0] = 1
        state[0,self.column_count-1] = 1
        state[self.row_count-1,0] = 1
        state[self.row_count-1,self.column_count-1] = 1
        # 2 cells - edges
        for col in range(1, self.column_count-1):
            state[0,col] = 2   
            state[self.row_count-1,col] = 2
        for row in range(1, self.row_count-1):
            state[row, 0] = 2
            state[row, self.column_count-1] = 2 
        # 3 cells - middle
        for row in range(1, self.row_count-1):
            for col in range(1, self.column_count-1):
                state[row,col] = 3
        return state
        
    def check_move_validity(self, state, player, move):
        row, column = move
        if row < 0 or row >= self.row_count:
            print("Error: Index out of bounds")
            return False
        if column < 0 or column >= self.column_count:
            print("Error: Index out of bounds")
            return False
        if state[row, column] * player < 0:
            print("Error: Cell belongs to opponent")
            return False 
        return True
        
    def get_next_state(self, state, player, move):
        self.move_count += 1
        row, column = move
        state[row,column] += player
        # call nuclear_fission() only if current cell becomes unstable
        if abs(state[row,column]) > self.full_state[row,column]:
            self.unstable_count += 1
            self.nuclear_fission(state, player, move)
            self.unstable_count = 0
        return state
        
    def nuclear_fission(self, state, player, move):
        if self.unstable_count > self.cell_count:
            self.infinite_loop = True
            return
        row, column = move
        state[row,column] -= (self.full_state[row,column] + 1)*player
        # cell above
        if row-1 >= 0:
            state[row-1,column] = state[row-1,column]*(-1,1)[int(state[row-1,column] * player >= 0)] + player
            if abs(state[row-1,column]) > self.full_state[row-1,column]:
                self.unstable_count += 1
                self.nuclear_fission(state, player, (row-1,column))
        # cell below
        if row+1 < self.row_count:
            state[row+1,column] = state[row+1,column]*(-1,1)[int(state[row+1,column] * player >= 0)] + player
            if abs(state[row+1,column]) > self.full_state[row+1,column]:
                self.unstable_count += 1
                self.nuclear_fission(state, player, (row+1,column))
        # cell to left
        if column-1 >= 0:
            state[row,column-1] = state[row,column-1]*(-1,1)[int(state[row,column-1] * player >= 0)] + player
            if abs(state[row,column-1]) > self.full_state[row,column-1]:
                self.unstable_count += 1
                self.nuclear_fission(state, player, (row,column-1))
        # cell to right
        if column+1 < self.column_count:
            state[row,column+1] = state[row,column+1]*(-1,1)[int(state[row,column+1] * player >= 0)] + player
            if abs(state[row,column+1]) > self.full_state[row,column+1]:
                self.unstable_count += 1
                self.nuclear_fission(state, player, (row,column+1))
                  
    def get_value_and_terminated(self, state, player):
        if self.infinite_loop:
            return 1, True
        elif self.move_count < self.move_limit:
            return 0, False
        else:
            if self.check_win(state, player):
                return 1, True
            else:
                return 0, True
                
    def check_win(self, state, player):
        player_cells = [0,0]
        for row in range(self.row_count):
            for col in range(self.column_count):
                if state[row,col] > 0:
                    player_cells[0] += 1
                else:
                    player_cells[1] += 1
        # player wins if opponent has no cells
        if player == 1:
            return (player_cells[1] == 0)
        else:
            return (player_cells[0] == 0)
        
    def get_opponent(self, player):
        return -player
        

# main code
cr = chain_reaction(6,6)
player = 1
state = cr.get_initial_state()

while True:
    print(state)
    move = tuple(map(int, input(f"{player}:").split(',')))
    if not cr.check_move_validity(state, player, move):
        continue
    state = cr.get_next_state(state, player, move)  
    value, terminated = cr.get_value_and_terminated(state, player)
    
    if terminated:
        print(state)
        if value == 1:
            print(f"Player {player} won")
        else:
            print("Game Drawn")
        break
        
    player = cr.get_opponent(player)