Merge remote-tracking branch 'origin/main'
This commit is contained in:
		
						commit
						c9757f22fc
					
				| 
						 | 
				
			
			@ -1,6 +1,6 @@
 | 
			
		|||
<?xml version="1.0" encoding="UTF-8"?>
 | 
			
		||||
<project version="4">
 | 
			
		||||
  <component name="ProjectRootManager" version="2" languageLevel="JDK_17" default="true" project-jdk-name="openjdk-17" project-jdk-type="JavaSDK">
 | 
			
		||||
  <component name="ProjectRootManager" version="2" languageLevel="JDK_X" default="true" project-jdk-name="openjdk-17" project-jdk-type="JavaSDK">
 | 
			
		||||
    <output url="file://$PROJECT_DIR$/out" />
 | 
			
		||||
  </component>
 | 
			
		||||
</project>
 | 
			
		||||
| 
						 | 
				
			
			@ -2,19 +2,39 @@ package ch.zhaw.catan;
 | 
			
		|||
 | 
			
		||||
import java.util.HashMap;
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
/**
 | 
			
		||||
 * Bank Class that stores Resources when not being owned by a player,
 | 
			
		||||
 * and the needed functions to take and give resources to it.
 | 
			
		||||
 *
 | 
			
		||||
 * @author Leonardo Brandenberger
 | 
			
		||||
 */
 | 
			
		||||
public class Bank {
 | 
			
		||||
    private final HashMap<Config.Resource, Integer> resources = new HashMap<>();
 | 
			
		||||
 | 
			
		||||
    /**
 | 
			
		||||
     * Construct a Bank Object and stores Config Values in own HashMap.
 | 
			
		||||
     */
 | 
			
		||||
    public Bank() {
 | 
			
		||||
        resources.putAll(Config.INITIAL_RESOURCE_CARDS_BANK);
 | 
			
		||||
 | 
			
		||||
    }
 | 
			
		||||
 | 
			
		||||
    /**
 | 
			
		||||
     * Stores a desired resource in desired quantity in the bank.
 | 
			
		||||
     *
 | 
			
		||||
     * @param resource          the resource type that gets added to the bank
 | 
			
		||||
     * @param numberOfResources the quantity of resources of the chosen type get added
 | 
			
		||||
     */
 | 
			
		||||
    public void storeResourceToBank(Config.Resource resource, int numberOfResources) {
 | 
			
		||||
        resources.put(resource, resources.get(resource) + numberOfResources);
 | 
			
		||||
    }
 | 
			
		||||
 | 
			
		||||
    /**
 | 
			
		||||
     * Checks if a Resource is available in the quantity desired. and then deducts it from the bank inventory.
 | 
			
		||||
     *
 | 
			
		||||
     * @param resource          the resource type that has to be deducted
 | 
			
		||||
     * @param numberOfResources the quantity of the resource that gets deducted from the inventory
 | 
			
		||||
     * @return true if resources available and deducted false if not enough resources are in the bank
 | 
			
		||||
     */
 | 
			
		||||
    public boolean getResourceFromBank(Config.Resource resource, int numberOfResources) {
 | 
			
		||||
        if (resources.get(resource) >= numberOfResources) {
 | 
			
		||||
            Integer newResourceNumber = resources.get(resource) - numberOfResources;
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
| 
						 | 
				
			
			@ -26,8 +26,8 @@ public class SiedlerBoard extends HexBoard<Config.Land, Settlement, Road, String
 | 
			
		|||
     * Value: Field Object
 | 
			
		||||
     */
 | 
			
		||||
    private final HashMap<Point, Field> fields = new HashMap<>();
 | 
			
		||||
    Config.Faction longestRoadFaction = null;
 | 
			
		||||
    int longestRoadLenth = 0;
 | 
			
		||||
    private Config.Faction longestRoadFaction = null;
 | 
			
		||||
    private int longestRoadLenth = 0;
 | 
			
		||||
 | 
			
		||||
    /**
 | 
			
		||||
     * Method to create the predefined game field from Config.
 | 
			
		||||
| 
						 | 
				
			
			@ -162,25 +162,10 @@ public class SiedlerBoard extends HexBoard<Config.Land, Settlement, Road, String
 | 
			
		|||
            }
 | 
			
		||||
        }
 | 
			
		||||
 | 
			
		||||
        if (longestRoadFaction == null) {
 | 
			
		||||
            Config.Faction currentFaction = null;
 | 
			
		||||
            int currentRoad = 4;
 | 
			
		||||
            for (Config.Faction factionA : players.keySet()) {
 | 
			
		||||
                if (players.get(factionA) > currentRoad) {
 | 
			
		||||
                    currentFaction = factionA;
 | 
			
		||||
                    currentRoad = players.get(factionA);
 | 
			
		||||
                }
 | 
			
		||||
            }
 | 
			
		||||
            if (currentFaction != null) {
 | 
			
		||||
                longestRoadFaction = currentFaction;
 | 
			
		||||
                longestRoadLenth = currentRoad;
 | 
			
		||||
            }
 | 
			
		||||
        } else {
 | 
			
		||||
            for (Config.Faction faction : players.keySet()) {
 | 
			
		||||
                if (players.get(faction) >= 5 && players.get(faction) > longestRoadLenth) {
 | 
			
		||||
                    longestRoadFaction = faction;
 | 
			
		||||
                    longestRoadLenth = players.get(faction);
 | 
			
		||||
                }
 | 
			
		||||
        for (Config.Faction factionA : players.keySet()) {
 | 
			
		||||
            if (players.get(factionA) > longestRoadLenth && players.get(factionA) > 4) {
 | 
			
		||||
                longestRoadFaction = factionA;
 | 
			
		||||
                longestRoadLenth = players.get(factionA);
 | 
			
		||||
            }
 | 
			
		||||
        }
 | 
			
		||||
        return longestRoadFaction;
 | 
			
		||||
| 
						 | 
				
			
			@ -203,75 +188,55 @@ public class SiedlerBoard extends HexBoard<Config.Land, Settlement, Road, String
 | 
			
		|||
     */
 | 
			
		||||
    private HashSet<Road> countRoad(Config.Faction faction, Point position, HashSet<Road> roads, boolean add) {
 | 
			
		||||
        List<Road> roadsList = getAdjacentEdges(position);
 | 
			
		||||
        //Checks if roads is interrupted by other players settlement
 | 
			
		||||
        if (getCorner(position) != null && getCorner(position).getFaction() != faction) {
 | 
			
		||||
            return roads;
 | 
			
		||||
        }
 | 
			
		||||
 | 
			
		||||
        //removes roads from roadsList which doesn't belong to the same player or which are allready added to roads.
 | 
			
		||||
        for (Road roadsRoad : roads) {
 | 
			
		||||
            Iterator<Road> it3 = roadsList.iterator();
 | 
			
		||||
            while (it3.hasNext()) {
 | 
			
		||||
                Road roadsListRoad = it3.next();
 | 
			
		||||
            Iterator<Road> it = roadsList.iterator();
 | 
			
		||||
            while (it.hasNext()) {
 | 
			
		||||
                Road roadsListRoad = it.next();
 | 
			
		||||
                if (roadsListRoad == roadsRoad || roadsListRoad.getFaction() != faction) {
 | 
			
		||||
                    it3.remove();
 | 
			
		||||
                    it.remove();
 | 
			
		||||
                }
 | 
			
		||||
            }
 | 
			
		||||
        }
 | 
			
		||||
 | 
			
		||||
        if (roadsList.size() == 1) {
 | 
			
		||||
            roads.add(roadsList.get(0));
 | 
			
		||||
            position = getNextPoint(roadsList.get(0), position);
 | 
			
		||||
            roads = countRoad(faction, position, roads, false);
 | 
			
		||||
        } else if (roadsList.size() == 2) {
 | 
			
		||||
            HashSet<Road> listOne = (HashSet<Road>) roads.clone();
 | 
			
		||||
            HashSet<Road> listTwo = (HashSet<Road>) roads.clone();
 | 
			
		||||
            listOne.add(roadsList.get(0));
 | 
			
		||||
            Point positionOne = getNextPoint(roadsList.get(0), position);
 | 
			
		||||
            listTwo.add(roadsList.get(1));
 | 
			
		||||
            Point positionTwo = getNextPoint(roadsList.get(1), position);
 | 
			
		||||
            listOne = countRoad(faction, positionOne, listOne, false);
 | 
			
		||||
            listTwo = countRoad(faction, positionTwo, listTwo, false);
 | 
			
		||||
            ArrayList<HashSet<Road>> possibleRoads = checkRoadsSwitch(faction,2,roadsList,position);
 | 
			
		||||
            if (add) {
 | 
			
		||||
                listTwo.addAll(listOne);
 | 
			
		||||
                roads = listTwo;
 | 
			
		||||
                possibleRoads.get(1).addAll(possibleRoads.get(0));
 | 
			
		||||
                roads.addAll(possibleRoads.get(1));
 | 
			
		||||
            } else {
 | 
			
		||||
                HashSet<Road> tallest;
 | 
			
		||||
                if (listOne.size() >= listTwo.size()) {
 | 
			
		||||
                    tallest = listOne;
 | 
			
		||||
                if (possibleRoads.get(0).size() >= possibleRoads.get(1).size()) {
 | 
			
		||||
                    tallest = possibleRoads.get(0);
 | 
			
		||||
                } else {
 | 
			
		||||
                    tallest = listTwo;
 | 
			
		||||
                    tallest = possibleRoads.get(1);
 | 
			
		||||
                }
 | 
			
		||||
                roads.addAll(tallest);
 | 
			
		||||
            }
 | 
			
		||||
 | 
			
		||||
        } else if (roadsList.size() == 3) {
 | 
			
		||||
            HashSet<Road> listOne = (HashSet<Road>) roads.clone();
 | 
			
		||||
            HashSet<Road> listTwo = (HashSet<Road>) roads.clone();
 | 
			
		||||
            HashSet<Road> listThree = (HashSet<Road>) roads.clone();
 | 
			
		||||
            listOne.add(roadsList.get(0));
 | 
			
		||||
            Point positionOne = getNextPoint(roadsList.get(0), position);
 | 
			
		||||
            listTwo.add(roadsList.get(1));
 | 
			
		||||
            Point positionTwo = getNextPoint(roadsList.get(1), position);
 | 
			
		||||
            listThree.add(roadsList.get(2));
 | 
			
		||||
            Point positionThree = getNextPoint(roadsList.get(2), position);
 | 
			
		||||
            listOne = countRoad(faction, positionOne, listOne, false);
 | 
			
		||||
            listTwo = countRoad(faction, positionTwo, listTwo, false);
 | 
			
		||||
            listThree = countRoad(faction, positionThree, listThree, false);
 | 
			
		||||
 | 
			
		||||
            ArrayList<HashSet<Road>> possibleRoads = checkRoadsSwitch(faction,3,roadsList,position);
 | 
			
		||||
            HashSet<Road> tallest;
 | 
			
		||||
            HashSet<Road> secondTallest;
 | 
			
		||||
 | 
			
		||||
            if (listOne.size() >= listTwo.size()) {
 | 
			
		||||
                tallest = listOne;
 | 
			
		||||
                secondTallest = listTwo;
 | 
			
		||||
            if (possibleRoads.get(0).size() >= possibleRoads.get(1).size()) {
 | 
			
		||||
                tallest = possibleRoads.get(0);
 | 
			
		||||
                secondTallest = possibleRoads.get(1);
 | 
			
		||||
            } else {
 | 
			
		||||
                tallest = listTwo;
 | 
			
		||||
                secondTallest = listOne;
 | 
			
		||||
                tallest = possibleRoads.get(1);
 | 
			
		||||
                secondTallest = possibleRoads.get(0);
 | 
			
		||||
            }
 | 
			
		||||
            if (listThree.size() >= secondTallest.size()) {
 | 
			
		||||
                secondTallest = listThree;
 | 
			
		||||
            if (possibleRoads.get(2).size() >= secondTallest.size()) {
 | 
			
		||||
                secondTallest = possibleRoads.get(2);
 | 
			
		||||
            }
 | 
			
		||||
            tallest.addAll(secondTallest);
 | 
			
		||||
            roads = tallest;
 | 
			
		||||
            roads.addAll(tallest);
 | 
			
		||||
        }
 | 
			
		||||
        return roads;
 | 
			
		||||
    }
 | 
			
		||||
| 
						 | 
				
			
			@ -293,4 +258,24 @@ public class SiedlerBoard extends HexBoard<Config.Land, Settlement, Road, String
 | 
			
		|||
        }
 | 
			
		||||
        return position;
 | 
			
		||||
    }
 | 
			
		||||
 | 
			
		||||
    /**
 | 
			
		||||
     * This method checks at a roads switch, which road starting at the switch will be the longest possibility.
 | 
			
		||||
     * @param faction the faction of the player to check on
 | 
			
		||||
     * @param numberOfSwitches how many adjacent roads there are at the corner
 | 
			
		||||
     * @param roadsList the list of adjacent roads
 | 
			
		||||
     * @param position the current corner from where to count further.
 | 
			
		||||
     * @return ArrayList of HashSet with all possible forks.
 | 
			
		||||
     */
 | 
			
		||||
    private ArrayList<HashSet<Road>> checkRoadsSwitch(Config.Faction faction,int numberOfSwitches,List<Road> roadsList,Point position) {
 | 
			
		||||
        ArrayList<HashSet<Road>> possibleRoads = new ArrayList<>();
 | 
			
		||||
        for (int i = 0;i<numberOfSwitches;i++) {
 | 
			
		||||
            HashSet<Road> list = new HashSet<>();
 | 
			
		||||
            list.add(roadsList.get(i));
 | 
			
		||||
            Point nextPosition = getNextPoint(roadsList.get(i),position);
 | 
			
		||||
            list = countRoad(faction, nextPosition, list, false);
 | 
			
		||||
            possibleRoads.add(list);
 | 
			
		||||
        }
 | 
			
		||||
        return possibleRoads;
 | 
			
		||||
    }
 | 
			
		||||
}
 | 
			
		||||
| 
						 | 
				
			
			
 | 
			
		|||
		Loading…
	
		Reference in New Issue