MancalaModel.java

import java.util.*;
import javax.swing.event.*;

/**
 * The class that represents teh Model of the MVC design pattern. Stores game data and views.
 * @author: Hung Phan
 * @author: Lien Cao
 * @author: Wendy Ta
 * @version: 1.0 11/28/25
 */
public class MancalaModel {
    private ArrayList<ChangeListener> listeners; //store views
    private ArrayList<Pit> allPits; 
    private HashMap<String, Pit> nameToPit; //map the name of each pit to each Pit object
    private HashMap<String, String> oppositePits;
    private int number;
    private String curPlayer = "A"; // 11/16
    private String winner = "None";
    private boolean freeTurn = false;
    private Stack<CurrentGameInfo> stack = new Stack<>();
    private BoardStyle boardStyle; //for different board styles 11/26/2025
    private int undoA = 0, undoB = 0;
    private boolean lastMoveUndo = false;

    /**
     * Constructs a model of the game
     */
    public MancalaModel() {
        this.listeners = new ArrayList<>();
        this.allPits = new ArrayList<>(); 
        for (int i=0; i<14; i++) {
            allPits.add(i, null); //initialize with null elements
        }

        nameToPit = new HashMap<>();
        oppositePits = new HashMap<>();

        oppositePits.put("A1", "B6"); //initialize opposite pits
        oppositePits.put("A2", "B5");
        oppositePits.put("A3", "B4");
        oppositePits.put("A4", "B3");
        oppositePits.put("A5", "B2");
        oppositePits.put("A6", "B1");
        oppositePits.put("B1", "A6"); 
        oppositePits.put("B2", "A5");
        oppositePits.put("B3", "A4");
        oppositePits.put("B4", "A3");
        oppositePits.put("B5", "A2");
        oppositePits.put("B6", "A1");

        this.boardStyle = new BoardStyleDefault();
    }

    /**
     * Method to reset the board game, set the number of stones for each pit
     */
    public void resetBoard() {
        for( Pit pit : allPits) {
            if (pit != null && !pit.getName().equals("leftStore") && !pit.getName().equals("rightStore")) {
                pit.setNumStones(number);
            }
        }
        notifyViews();
    }


    /**
     * The method that allows user to undo their move in the game
     * @param p the stack of pits that keep track pits when playing
     */
    public void undo() {
        if(curPlayer.equals("A") && undoA >= 3 || curPlayer.equals("B") && undoB >=3 || lastMoveUndo) {
            System.out.println("Cannot undo again.");
            return;
        }

        if (stack.isEmpty()) { //nothing to undo if nothing in stack
            return;
        } 
        CurrentGameInfo lastInfo = stack.pop(); //retrieve the info from the last move
        allPits = lastInfo.getAllPitsCopy(); //update pits/player/turn to the info from the last move
        curPlayer = lastInfo.getCurrentPlayer();
        freeTurn = lastInfo.getFreeTurn(); 
        
        for (Pit pit : allPits) { 
            //Update 11/28/2025
            Pit curr = nameToPit.get(pit.getName()); 
            if(curr != null){
                curr.setNumStones(pit.getNumStones());
                allPits.set(allPits.indexOf(pit), curr);
            }
        }

        if(curPlayer.equals("A")) {
            undoA++;
        } else {
            undoB++;
        }
        
        lastMoveUndo = true;
        notifyViews();
    }

    /**
     * The methods that show how the game changes after a pit is clicked
     * @param p a pit that is being to clicked
     */
    public void gameRun(Pit p) { //p = the pit that was clicked
        stack.push(new CurrentGameInfo(allPits, curPlayer, freeTurn));

        int numStones = p.getNumStones();
        if (numStones == 0) { //do nothing if no stones
            return;
        }
        p.setNumStones(0); //empty current pit

        Pit currentPit = p;
        while (numStones > 0) {
            Pit nextPit = getNextPit(currentPit);

            // If there are more stones to go past your own Mancala, 
            // continue placing them into the opponent's pits. 
            // However, skip your opponent's Mancala
            if ((curPlayer.equals("A") && nextPit.getName().equals("leftStore")) ||
                (curPlayer.equals("B") && nextPit.getName().equals("rightStore"))) {
                nextPit = getNextPit(nextPit); 
            }
        
            // If the last stone you drop is in an empty pit on your side
            // you get to take that stone and all of your opponents stones 
            // that are in the opposite pit
            if (numStones == 1) { //check if last stone --> only 1 stone

                String nextPitLetter = nextPit.getName().substring(0, 1);
                if (nextPit.getNumStones() == 0 && nextPitLetter.equals(curPlayer)) { //check if in empty pit on your side
                    
                    Pit oppositePit = getOppositePit(nextPit);
                    int num = oppositePit.getNumStones();
                    oppositePit.setNumStones(0);
                    nextPit.setNumStones(0);

                    Pit store;
                    if(curPlayer.equals("A")) {
                        store = nameToPit.get("rightStore");
                    } else {
                        store = nameToPit.get("leftStore");
                    }
                    store.setNumStones(store.getNumStones() + num + 1);
                    setFreeTurn(false);
                    break;
                }
                else if ((curPlayer.equals("A") && nextPit.getName().equals("rightStore")) ||
                        (curPlayer.equals("B") && nextPit.getName().equals("leftStore"))) {

                    // If the last stone you drop is in your own Mancala, you get a free turn
                    setFreeTurn(true);
                }
                else {
                    setFreeTurn(false);
                }
            }

            lastMoveUndo = false;
            nextPit.addStone();
            numStones--;
            currentPit = nextPit;

        }

            //The player who still has stones on his side of the board when the game ends 
            //captures all of those pieces and place them in his Mancala.
            //The player who has the most stones in his Mancala wins.
            String captureSide = checkEmpty();
            if (captureSide.equals("None")) {
                //do nothing, just continue playing
            }
            else {
                setWinner(capturePieces(captureSide)); //player whose side is not empty captures remaining pieces, set the winner
            }

        //change players after each move
        if (curPlayer.equals("A") && !getFreeTurn()) {
            setCurrentPlayer("B");
        } else if (curPlayer.equals("B") && !getFreeTurn()) {
            setCurrentPlayer("A");
        } else {
            setCurrentPlayer(curPlayer);
        }

        notifyViews();
    }

    /**
     * Sets winner of the game
     * @param winner the winner
     */
    public void setWinner(String winner) {
        this.winner = winner;
    }

    /**
     * Gets winner of the game
     * @return the winner
     */
    public String getWinner() {
        return this.winner;
    }

    /**
     * The method that check who is the winner
     * @param captureSide the side of the board game
     * @return the winner
     */
    public String capturePieces(String captureSide) {
        String storeToUpdate = "";
        String otherStore = "";

        if (captureSide.equals("A")) { //A's store = right store
            storeToUpdate = "rightStore";
            otherStore = "leftStore";
        }
        else {
            storeToUpdate = "leftStore";
            otherStore = "rightStore";
        }

        int totalStones = 0;
        for (Pit p : allPits) { //get the total number of stones left on the board, excluding the stores
            if (!p.getName().equals("leftStore") && !p.getName().equals("rightStore")) {
                totalStones += p.getNumStones();
                p.setNumStones(0); //set everything to 0
            }
        }

        Pit store1 = nameToPit.get(storeToUpdate); 
        Pit store2 = nameToPit.get(otherStore); 
        store1.setNumStones(store1.getNumStones() + totalStones); //update the store

        if (store1.getNumStones() > store2.getNumStones() && store1.getName().equals("rightStore") || 
            store1.getNumStones() < store2.getNumStones() && store2.getName().equals("rightStore")) { //A has more stones --> A wins
            System.out.println("Player A wins!");
            return "A";
        }
        else {
            System.out.println("Player B wins!");
            return "B";
        }

    }
    
    /**
     * Checks if either side of the board is empty
     * @return the side that is not empty, or none if both sides are not empty
     */
    public String checkEmpty() {
        boolean AEmpty = true;
        boolean BEmpty = true;

        for (Pit p : allPits) {
            String pitLetter = p.getName().substring(0,1);

            if (pitLetter.equals("A") && p.getNumStones() != 0) { //check if any of A's pits are not empty 
                AEmpty = false; 
            }
            else if (pitLetter.equals("B") && p.getNumStones() != 0) { //check if any of B's pits are not empty 
                BEmpty = false; 
            }
        }

        if (AEmpty) {
            return "B"; //return the side that is NOT empty, the side that gets to capture remaining pieces
        }
        else if (BEmpty) {
            return "A";
        }
        return "None"; //neither side is empty
    }

    /**
     * Gets the opposite pit
     * @param p the pit that being checked
     * @return the opposite pit
     */
    public Pit getOppositePit(Pit p) {
        // index: 00   01 02 03 04 05 06 07    08 09 10 11 12 13
        // pit:   left A1 A2 A3 A4 A5 A6 right B1 B2 B3 B4 B5 B6

        int index = allPits.indexOf(p);
        if (index == 0 || index == 7) { //check if pit is a store
            return null;
        }

        String oppositeName = this.oppositePits.get(p.getName());
        int oppositeIndex = allPits.indexOf(nameToPit.get(oppositeName));
        return allPits.get(oppositeIndex);
    }

    /**
     * The method that assign each pit with a name
     * @param name the name is being assigned to a pit
     * @param pit the pit that match with that name
     */
    public void addToNameMap(String name, Pit pit) { 
        nameToPit.put(name, pit);
    }

    /**
     * The method that assign peach pit with an index
     * @param idx an index
     * @param pit the pit
     */
    public void addToAllPits(int idx, Pit pit) { 
        allPits.set(idx, pit);
    }

    /**
     * The method to get all pits in the game
     * @return a list of the pits
     */
    public ArrayList<Pit> getAllPits() {
        return this.allPits;
    }

    /**
     * Gets a pit using its name
     * Used when drawing the board to get the number of stones using its name
     * @return a map that has connection between the pit and its name
     */
    public HashMap<String, Pit> getNameToPit() { 
        return this.nameToPit;
    }

    /**
     * Set initial number of stones
     * @param n the number of stones
     */
    public void setNumber(int n) { 
        this.number = n;
        resetBoard();
        notifyViews();
    }

    /**
     * Gets initial number of stones to draw
     * @return the number of stones
     */
    public int getNumber() { 
        return number;
    }

    /**
     * Gets the next pit
     * @param current the current pit
     * @return the next pit
     */
    public Pit getNextPit(Pit current) { 
        if(current == null){
            return null;
        }
        int index = allPits.indexOf(current);
        if(index == -1){
            return null;
            
        }
        return allPits.get((index + 1) % allPits.size());
    }

    /**
     * Add listener views
     * @param listener
     */
    public void addChangeListener(ChangeListener listener) { 
        listeners.add(listener);
    }

    /**
     * Notify each view of the change in this model
     */
    public void notifyViews() { 
        ChangeEvent event = new ChangeEvent(this);
        for (ChangeListener listener : listeners) {
            listener.stateChanged(event);
        }
    }

    /**
     * Gets the current player
     * @return the current player
     */
    public String getCurrentPlayer() {
        return curPlayer;
    }

    /**
     * Sets the current player
     * @param player the current player
     */
    public void setCurrentPlayer(String player) {
        this.curPlayer = player;
        notifyViews();
    }

    /**
     * Gets the free turn
     * @return true, false otherwise
     */
    public boolean getFreeTurn() {
        return this.freeTurn;
    }

    /**
     * Set free turn for the player
     * @param value true or false
     */
    public void setFreeTurn(boolean value) {
        this.freeTurn = value;
    }
    
    /**
     * Sets the board style
     * @param style the style that being choose
     */
    public void setBoardStyle(BoardStyle style) {
        if(style == null){
            boardStyle = new BoardStyleDefault(); // default style
            return;
        }
        this.boardStyle = style;
        notifyViews();
    }

    /**
     * Gets the board style
     * @return the new board style
     */
    public BoardStyle getBoardStyle() {
        return this.boardStyle;
    }
}