gruppe06-hufflepuff-projekt3-catan/src/ch/zhaw/catan/SiedlerGame.java

package ch.zhaw.catan;

import ch.zhaw.catan.Config.Faction;
import ch.zhaw.catan.Config.Resource;

import java.awt.*;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;


/**
 * This class performs all actions related to modifying the game state.
 * <p>
 * TODO: (your documentation)
 *
 * @author TODO
 */
public class SiedlerGame {
    static final int FOUR_TO_ONE_TRADE_OFFER = 4;
    static final int FOUR_TO_ONE_TRADE_WANT = 1;

    private SiedlerBoard board;
    private ArrayList<Player> allPlayers;
    private int winPointsForWin;
    private Bank bank;
    private int activePlayer;

    /**
     * Constructs a SiedlerGame game state object.
     *
     * @param winPoints       the number of points required to win the game
     * @param numberOfPlayers the number of players
     * @throws IllegalArgumentException if winPoints is lower than
     *                                  three or players is not between two and four
     */
    public SiedlerGame(int winPoints, int numberOfPlayers) {
        if(winPoints < 3 || numberOfPlayers < 2 || numberOfPlayers > 4) {
            throw new IllegalArgumentException();
        }
        bank = new Bank();
        board = new SiedlerBoard();
        board.createFixGamefield();
        allPlayers = new ArrayList<>();
        createPlayer(numberOfPlayers);
        activePlayer = 0;
        this.winPointsForWin = winPoints;
    }

    private void createPlayer(int numberOfPlayers) {
        for (int i = 0; i < numberOfPlayers; i++) {
            allPlayers.add(new Player(Config.Faction.values()[i]));
        }
    }

    /**
     * Switches to the next player in the defined sequence of players.
     */
    public void switchToNextPlayer() {
        if (activePlayer < allPlayers.size() -1){
            activePlayer++;
        }
        else if (activePlayer == allPlayers.size() -1){
            activePlayer = 0;
        }
    }

    /**
     * Switches to the previous player in the defined sequence of players.
     */
    public void switchToPreviousPlayer() {
        if (activePlayer > 0){
            activePlayer--;
        }
        else if (activePlayer == 0){
            activePlayer = allPlayers.size()-1;
        }
    }

    /**
     * Returns the {@link Faction}s of the active players.
     *
     * <p>The order of the player's factions in the list must
     * correspond to the oder in which they play.
     * Hence, the player that sets the first settlement must be
     * at position 0 in the list etc.
     *
     * <strong>Important note:</strong> The list must contain the
     * factions of active players only.</p>
     *
     * @return the list with player's factions
     */
    public List<Faction> getPlayerFactions() {
        List<Faction> factions = new ArrayList<>();
        for (Player player: allPlayers ) {
            factions.add(player.getFaction());
        }

        return factions;
    }


    /**
     * Returns the game board.
     *
     * @return the game board
     */
    public SiedlerBoard getBoard() {
        return board;
    }

    /**
     * Returns the {@link Faction} of the current player.
     *
     * @return the faction of the current player
     */
    public Faction getCurrentPlayerFaction() {
        return allPlayers.get(activePlayer).getFaction();
    }

    /**
     * Returns how many resource cards of the specified type
     * the current player owns.
     *
     * @param resource the resource type
     * @return the number of resource cards of this type
     */
    public int getCurrentPlayerResourceStock(Resource resource) {
        return allPlayers.get(activePlayer).getSpecificResource(resource);
    }

    public HashMap<Resource, Integer> getCurruntPlayerResource() {
        return allPlayers.get(activePlayer).getResources();
    }

    /**
     * Places a settlement in the founder's phase (phase II) of the game.
     *
     * <p>The placement does not cost any resource cards. If payout is
     * set to true, for each adjacent resource-producing field, a resource card of the
     * type of the resource produced by the field is taken from the bank (if available) and added to
     * the players' stock of resource cards.</p>
     *
     * @param position the position of the settlement
     * @param payout   if true, the player gets one resource card per adjacent resource-producing field
     * @return true, if the placement was successful
     */
    public boolean placeInitialSettlement(Point position, boolean payout) {
        // TODO: Implement
        return true;
    }

    /**
     * Places a road in the founder's phase (phase II) of the game.
     * The placement does not cost any resource cards.
     *
     * @param roadStart position of the start of the road
     * @param roadEnd   position of the end of the road
     * @return true, if the placement was successful
     */
    public boolean placeInitialRoad(Point roadStart, Point roadEnd) {
        // TODO: Implement
        return true;
    }

    /**
     * This method takes care of actions depending on the dice throw result.
     * <p>
     * A key action is the payout of the resource cards to the players
     * according to the payout rules of the game. This includes the
     * "negative payout" in case a 7 is thrown and a player has more than
     * {@link Config#MAX_CARDS_IN_HAND_NO_DROP} resource cards.
     * <p>
     * If a player does not get resource cards, the list for this players'
     * {@link Faction} is <b>an empty list (not null)</b>!.
     *
     * <p>
     * The payout rules of the game take into account factors such as, the number
     * of resource cards currently available in the bank, settlement types
     * (settlement or city), and the number of players that should get resource
     * cards of a certain type (relevant if there are not enough left in the bank).
     * </p>
     *
     * @param dicethrow the resource cards that have been distributed to the players
     * @return the resource cards added to the stock of the different players
     */
    public Map<Faction, List<Resource>> throwDice(int dicethrow) {
        // TODO: Implement
        return null;
    }

    /**
     * Builds a settlement at the specified position on the board.
     *
     * <p>The settlement can be built if:
     * <ul>
     * <li> the player possesses the required resource cards</li>
     * <li> a settlement to place on the board</li>
     * <li> the specified position meets the build rules for settlements</li>
     * </ul>
     *
     * @param position the position of the settlement
     * @return true, if the placement was successful
     */
    public boolean buildSettlement(Point position) {
        //1. Check if position is corner && is empty && neighbour Corners are empty
        if(!validPositionForSettlement(position)) {
            return false;
        }
        //2. Check if neighbourEdge are Roads belong to active Player
        if(!checkAdjacentEdgesList(position)) {
            return false;
        }
        //3. Can Player build Settlement
        if (!allPlayers.get(activePlayer).buildSettlement()) {
            return false;
        }
        //4. Insert Settlement to map
        board.setCorner(position, new Settlement(allPlayers.get(activePlayer).getFaction()));
        //5. Give Resoure to bank
        bank.storeResourceToBank(Config.Structure.SETTLEMENT.getCosts());
        return true;
    }

    /**
     * Builds a city at the specified position on the board.
     *
     * <p>The city can be built if:
     * <ul>
     * <li> the player possesses the required resource cards</li>
     * <li> a city to place on the board</li>
     * <li> the specified position meets the build rules for cities</li>
     * </ul>
     *
     * @param position the position of the city
     * @return true, if the placement was successful
     */
    public boolean buildCity(Point position) {
        // TODO: OPTIONAL task - Implement
        return false;
    }

    /**
     * Builds a road at the specified position on the board.
     *
     * <p>The road can be built if:
     * <ul>
     * <li> the player possesses the required resource cards</li>
     * <li> a road to place on the board</li>
     * <li> the specified position meets the build rules for roads</li>
     * </ul>
     *
     * @param roadStart the position of the start of the road
     * @param roadEnd   the position of the end of the road
     * @return true, if the placement was successful
     */
    public boolean buildRoad(Point roadStart, Point roadEnd) {
        //1. Check if is edge && is empty && if neighbour Edge or Corners belong to Settlement of active Player
        if (!validPositionForRoad(roadStart,roadEnd)){
            return false;
        }
        //2. Can Player build road
        if (!allPlayers.get(activePlayer).buildRoad()) {
            // TODO: Error message
            return false;
        }
        //3. Insert Road to map
        board.setEdge(roadStart, roadEnd, new Road(allPlayers.get(activePlayer).getFaction()));
        //4. Give Resource to bank
        bank.storeResourceToBank(Config.Structure.ROAD.getCosts());
        return true;
    }


    /**
     * Can be used for both initial Settlement and normal Phase.
     * @param roadStart
     * @param roadEnd
     * @return
     */
    private boolean validPositionForRoad(Point roadStart, Point roadEnd){
        //1. Check if Edge
        if (!board.hasEdge(roadStart, roadEnd)) {
            return false;
        }
        //2. Check if Edge is empty
        if (board.getEdge(roadStart, roadEnd) != null) {
            return false;
        }
        //3. Check if NeighbourEdge are Roads
        boolean hasNeighbourRoad = (checkAdjacentEdgesList(roadStart) || checkAdjacentEdgesList(roadEnd));
        //4.Check if roadStart or roadEnd is Settlement of current player or if 3. is valid
        if(board.getCorner(roadStart).getFaction() == allPlayers.get(activePlayer).getFaction()
                || board.getCorner(roadEnd).getFaction() == allPlayers.get(activePlayer).getFaction()
                || hasNeighbourRoad){
            return true;
        }
        return false;
    }

    /**
     * Do not use for initial Settlement
     * @param position
     * @return
     */
    private boolean validPositionForSettlement(Point position){
        //1. Check if Corner
        if (!board.hasCorner(position)) {
            return false;
        }
        //2. Check if Corner is empty
        if(board.getCorner(position) != null) {
            return false;
        }
        //3. Check if neighbourCorners are empty
        if(!checkAdjacentCornerList(position)) {
            return false;
        }
        return true;
    }

    /**
     * This method checks if there are Roads build by active Player on adjacent edges
     * @param point
     * @return
     */
    private boolean checkAdjacentEdgesList(Point point) {
        List<Road> results = board.getAdjacentEdges(point);
        for(int i = 0; i < results.size(); i++) {
            if(results.get(i).getFaction() == allPlayers.get(activePlayer).getFaction()) {
                return true;
            }
        }
        return false;
    }

    /**
     * Checks if Adjacent Corners are empty
     * @param point Corner to check
     * @return true if all Neighbour Corners are emtpy
     */
    private boolean checkAdjacentCornerList(Point point) {
        List<Settlement> results = board.getNeighboursOfCorner(point);
        if(results.size() > 0) {
            return false;
        }
        return true;
    }

    /**
     * Trades in {@link #FOUR_TO_ONE_TRADE_OFFER} resource cards of the
     * offered type for {@link #FOUR_TO_ONE_TRADE_WANT} resource cards of the wanted type.
     * <p>
     * The trade only works when bank and player possess the resource cards
     * for the trade before the trade is executed.
     *
     * @param offer offered type
     * @param want  wanted type
     * @return true, if the trade was successful
     */
    public boolean tradeWithBankFourToOne(Resource offer, Resource want) {
        return bank.tradeWithBank(want, offer, FOUR_TO_ONE_TRADE_WANT, FOUR_TO_ONE_TRADE_OFFER);
    }

    /**
     * Returns the winner of the game, if any.
     *
     * @return the winner of the game or null, if there is no winner (yet)
     */
    public Faction getWinner() {
        HashMap<Faction, Integer> winPoints = getWinPoints();
        for(Faction faction : winPoints.keySet()){
            if(winPoints.get(faction) >= winPointsForWin){
                return faction;
            }
        }
        return null;
    }

    private HashMap<Faction, Integer> getWinPoints(){
        HashMap<Faction, Integer> winPoints = new HashMap<>();
        List<Settlement> structures = board.getCorners();
        for(Structure structure : structures) {

            int newWinPoints = 0;
            if(structure instanceof City){
                newWinPoints = 2;
            } else if(structure instanceof Settlement) {
                newWinPoints = 1;
            }

            Faction faction = structure.getFaction();
            if(winPoints.containsKey(faction)) {
               winPoints.put(faction, winPoints.get(faction) + newWinPoints);
            }
            else {
                winPoints.put(faction, newWinPoints);
            }

        }
        //todo add points for longest road
        return winPoints;
    }


    /**
     * Places the thief on the specified field and steals a random resource card (if
     * the player has such cards) from a random player with a settlement at that
     * field (if there is a settlement) and adds it to the resource cards of the
     * current player.
     *
     * @param field the field on which to place the thief
     * @return false, if the specified field is not a field or the thief cannot be
     * placed there (e.g., on water)
     */
    public boolean placeThiefAndStealCard(Point field) {
        //TODO: Implement (or longest road functionality)
        return false;
    }

}