ZHAW-IT21b_WIN
/
gruppe06-hufflepuff-projekt3-catan
3
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Merge remote-tracking branch 'origin/main'

This commit is contained in:
Speedy Gonzalez 2021-12-09 16:13:11 +01:00
parent f0e8e20511 78ce0e43bc
commit 0e3fccb8d4
15 changed files with 250 additions and 300 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
.idea/misc.xml
View File

@ -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>

3
src/ch/zhaw/catan/Bank.java
View File

@ -1,11 +1,10 @@
package ch.zhaw.catan;
import java.util.HashMap;
import java.util.List;
public class Bank {
private HashMap<Config.Resource, Integer> resources = new HashMap<>();
private final HashMap<Config.Resource, Integer> resources = new HashMap<>();
public Bank(){
resources.putAll(Config.INITIAL_RESOURCE_CARDS_BANK);

2
src/ch/zhaw/catan/City.java
View File

@ -1,6 +1,6 @@
package ch.zhaw.catan;
import java.awt.*;
import java.awt.Point;
public class City extends Settlement {

5
src/ch/zhaw/catan/Command.java
View File

@ -1,12 +1,11 @@
package ch.zhaw.catan;
import org.beryx.textio.TextIO;
//TODO:JavaDoc
public enum Command {
NEXTPLAYER ("next player"), BUILDSETTLEMENT ("build settlement"), BUILDCITY("build city"),
BUILDROAD("build road"), TRADEWITHBANK("trade with bank"),QUIT("quit");
private String commandWord;
private final String commandWord;

58
src/ch/zhaw/catan/Dummy.java
View File

@ -1,58 +0,0 @@
package ch.zhaw.catan;
import ch.zhaw.catan.Config.Land;
import ch.zhaw.hexboard.Label;
import java.awt.Point;
import java.util.HashMap;
import java.util.Map;
import org.beryx.textio.TextIO;
import org.beryx.textio.TextIoFactory;
import org.beryx.textio.TextTerminal;
public class Dummy {
public enum Actions {
SHOW, QUIT
}
private void run() {
TextIO textIO = TextIoFactory.getTextIO();
TextTerminal<?> textTerminal = textIO.getTextTerminal();
SiedlerBoard board = new SiedlerBoard();
board.addField(new Point(2, 2), Land.FOREST);
board.setCorner(new Point(3, 3), new Settlement(Config.Faction.RED,new Point(3, 3)));
board.setEdge(new Point(2, 0), new Point(3, 1), new Road(Config.Faction.BLUE,new Point(2, 0),new Point(2, 0)));
board.addFieldAnnotation(new Point(2, 2), new Point(3, 1), "AA");
Map<Point, Label> lowerFieldLabel = new HashMap<>();
lowerFieldLabel.put(new Point(2, 2), new Label('0', '9'));
SiedlerBoardTextView view = new SiedlerBoardTextView(board);
for (Map.Entry<Point, Label> e : lowerFieldLabel.entrySet()) {
view.setLowerFieldLabel(e.getKey(), e.getValue());
}
boolean running = true;
while (running) {
switch (getEnumValue(textIO, Actions.class)) {
case SHOW:
textTerminal.println(view.toString());
break;
case QUIT:
running = false;
break;
default:
throw new IllegalStateException("Internal error found - Command not implemented.");
}
}
textIO.dispose();
}
public static <T extends Enum<T>> T getEnumValue(TextIO textIO, Class<T> commands) {
return textIO.newEnumInputReader(commands).read("What would you like to do?");
}
public static void main(String[] args) {
new Dummy().run();
}
}

2
src/ch/zhaw/catan/Field.java
View File

@ -5,7 +5,7 @@ import ch.zhaw.hexboard.Label;
public class Field {
private Config.Land land;
private Label label;
private final Label label;
public Field(Config.Land land, Label label){
this.land = land;

6
src/ch/zhaw/catan/Parser.java
View File

@ -4,11 +4,9 @@ import org.beryx.textio.TextIO;
import org.beryx.textio.TextIoFactory;
import org.beryx.textio.TextTerminal;
import java.awt.*;
import java.awt.Point;
import java.util.HashMap;
import static ch.zhaw.catan.Command.*;
/**
* This class performs all communication with the player, includes asking for input and showing the map.
*
@ -76,7 +74,7 @@ public class Parser {
*/
public HashMap<String, Integer> gameStart() {
HashMap<String, Integer> gameStartValues = new HashMap<>();
gameStartValues.put("NumberOfPlayers", textIO.newIntInputReader().withMinVal(2).withMaxVal(4).read("Number of players:"));
gameStartValues.put("NumberOfPlayers", textIO.newIntInputReader().withMinVal(Config.MIN_NUMBER_OF_PLAYERS).withMaxVal(4).read("Number of players:"));
gameStartValues.put("NumberOfWinPoints", textIO.newIntInputReader().withMinVal(5).withMaxVal(15).read("Winpoints needed for Victory:"));
return gameStartValues;
}

15
src/ch/zhaw/catan/Player.java
View File

@ -1,7 +1,8 @@
package ch.zhaw.catan;
import java.util.*;
import java.util.HashMap;
import java.util.List;
//TODO Java Doc bearbeiten
/**
* New Class PLayer
* This class is here in order to maintain the resources of the players, the amount of structures that they can build,
@ -9,9 +10,9 @@ import java.util.*;
*/
public class Player {
private Config.Faction faction;
private HashMap<Config.Resource, Integer> resources;
private HashMap<Config.Structure, Integer> structureToUse;
private final Config.Faction faction;
private final HashMap<Config.Resource, Integer> resources;
private final HashMap<Config.Structure, Integer> structureToUse;
/**
* The constructor creates a new instance of the player class that initializes the Hashmap resources and structureToUse.
@ -62,7 +63,7 @@ public class Player {
}
/**
* This method adds a specific resource to resourcess
* This method adds a specific resource to resources
*
* @param resource to add
* @param numberToAdd how much to add
@ -89,7 +90,7 @@ public class Player {
/**
* This method has to be used when a player wants to build a structure. It checks if a player has enough of the specific structure
* and resources to build one more. If the player is able to build, this method subtracts the buildcost from the resources
* and resources to build one more. If the player is able to build, this method subtracts the building cost from the resources
* in possession by the player.
* It reduces the amount of the specific structure a player can build by 1.
* @return true if the structure can be created false if the structure can't be created.

6
src/ch/zhaw/catan/Road.java
View File

@ -1,10 +1,10 @@
package ch.zhaw.catan;
import java.awt.*;
import java.awt.Point;
/// TODO: 09/12/2021 Java Doc
public class Road extends Structure {
private Point start,end;
private final Point start,end;
public Road(Config.Faction faction,Point start,Point end) {

4
src/ch/zhaw/catan/Settlement.java
View File

@ -1,7 +1,7 @@
package ch.zhaw.catan;
import java.awt.*;
import java.awt.Point;
//TODO Java Doc
public class Settlement extends Structure {
private Point position;

22
src/ch/zhaw/catan/Siedler.java
View File

@ -4,7 +4,7 @@ import java.util.HashMap;
import java.util.Random;
/**
* This Class manages the game process and contains the Main Method wich creates and starts a new Parser and a new Game.
* This Class manages the game process and contains the Main Method which creates and starts a new Parser and a new Game.
*/
public class Siedler {
/**
@ -20,7 +20,7 @@ public class Siedler {
/**
* The Method for the usual game Process. It contains the Main loop to get new commands from the players and calls the associated methods.
* @param parser The Parser Object which will interact with the player.
* @param game The Game object which is already created and has the foundig phase completed.
* @param game The Game object which is already created and has the founding phase completed.
*/
private static void gamePhase(Parser parser, SiedlerGame game) {
boolean running = true;
@ -33,7 +33,7 @@ public class Siedler {
throwDice(parser, game);
diceThrown = true;
}
parser.displayPlayerInfo(game.getCurrentPlayerResource(), game.getCurrentPlayerWinpoints());
parser.displayPlayerInfo(game.getCurrentPlayerResource(), game.getCurrentPlayerWinPoints());
switch (parser.getAction()) {
case NEXTPLAYER:
if(caseNextPlayer(parser, game)){
@ -145,7 +145,7 @@ public class Siedler {
}
}
//each Player bilds their second Settlement and second Road and gets a Payout for these Structures in usual order.
//each Player builds their second Settlement and second Road and gets a Payout for these Structures in usual order.
for(int player = 1; player <= gameInfo.get("NumberOfPlayers"); player++){
buildStructuresInFoundingPhase(parser, game, true);
game.switchToNextPlayer();
@ -157,7 +157,7 @@ public class Siedler {
* The Method is called by foundingPhase. It prompts the Player to build a Settlement and a Road.
* @param parser The parser Object which will interact with the player.
* @param game The game Object which will be used to execute the Method.
* @param payout true (for second Settlement in founding Phase): the Player gets a payout for the settlment. false (for first Settlement in founding Phase): The Player gets no payout.
* @param payout true (for second Settlement in founding Phase): the Player gets a payout for the settlement. false (for first Settlement in founding Phase): The Player gets no payout.
*/
private static void buildStructuresInFoundingPhase(Parser parser, SiedlerGame game, Boolean payout){
parser.displayGameboard(game.getBoard().getTextView());
@ -165,27 +165,27 @@ public class Siedler {
//build Settlement
parser.giveCoordinatesForStructures(Config.Structure.SETTLEMENT);
boolean sucessful = false;
boolean successful = false;
do{
if(game.placeInitialSettlement(parser.getPoint(), payout)) {
sucessful = true;
successful = true;
}
else{
parser.errorMessage();
}
} while(!sucessful);
} while(!successful);
//build Road
parser.displayGameboard(game.getBoard().getTextView());
parser.giveCoordinatesForStructures(Config.Structure.ROAD);
sucessful = false;
successful = false;
do{
if(game.placeInitialRoad(parser.getPoint(), parser.getPoint())) {
sucessful = true;
successful = true;
}
else{
parser.errorMessage();
}
} while(!sucessful);
} while(!successful);
}
}

181
src/ch/zhaw/catan/SiedlerBoard.java
View File

@ -5,21 +5,18 @@ import ch.zhaw.hexboard.HexBoard;
import ch.zhaw.hexboard.Label;
import java.awt.Point;
import java.util.List;
import java.util.HashMap;
import java.util.Map;
import java.util.ArrayList;
import java.util.Collections;
import java.util.*;
//TODO Enhance JavaDoc
/**
* Subclass of HexBoard
* Saves the fields wich are set and handels Methods with specific Dice Numbers
* Saves the fields which are set and handles Methods with specific Dice Numbers.
*/
public class SiedlerBoard extends HexBoard<Land, Settlement, Road, String> {
/**
* HashMap to save all Fields which are set yet.
* Key: Point with coordinates of the field
* //TODO Enhance JavaDoc
* Value: Field Object
*/
HashMap<Point, Field> fields = new HashMap<>();
@ -85,13 +82,13 @@ public class SiedlerBoard extends HexBoard<Land, Settlement, Road, String> {
}
/**
* Method to get the Resources which are payed to a specific faction for a specific field.
* Method to get the Resources which are paid to a specific faction for a specific field.
*
* @param point The Point with the Coordinates of the field, which should pay resources.
* @param faction The faction, which should get paied.
* @return a ArrayList with all resources, which will be paied to the specified faction.
* @param faction The faction, which should get paid.
* @return a ArrayList with all resources, which will be paid to the specified faction.
*/
public ArrayList<Config.Resource> getResourcesforFaction(Point point, Config.Faction faction){
public ArrayList<Config.Resource> getResourcesForFaction(Point point, Config.Faction faction){
List <Settlement> possibleSettlementField = super.getCornersOfField(point);
ArrayList<Config.Resource> resourcesToPlayer = new ArrayList<>();
for (Settlement settlement : possibleSettlementField) {
@ -130,4 +127,166 @@ public class SiedlerBoard extends HexBoard<Land, Settlement, Road, String> {
}
return List.of(lands);
}
/**
* This method checks for the player with the longest road according to the catan game rules.
* @return a HashMap<Faction,Integer> where faction is the player with the longest road longer according to catan game rules
* and the Integer representing the length of the road
*/
public void getLongestRoadFaction(HashMap<Config.Faction,Integer> currentLongestRoad,List<Config.Faction> factionList) {
List<Settlement> corners = getCorners();
HashMap<Config.Faction,Integer> players = new HashMap<>();
for(Config.Faction faction : factionList) {
int count = 0;
players.put(faction,count);
for(Settlement settlement : corners){
if(settlement.getFaction() == faction){
HashSet<Road> roads = new HashSet<>();
roads = countRoad(faction,settlement.getPosition(),roads,true);
count = roads.size();
int currentCount = players.get(faction);
if(count > currentCount) {
players.put(faction,count);
}
}
}
}
if(currentLongestRoad.size() == 0) {
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){
currentLongestRoad.put(currentFaction,currentRoad);
}
}else{
for(Config.Faction faction : players.keySet()) {
for(Config.Faction faction1 : currentLongestRoad.keySet()) {
if(players.get(faction) >= 5 && players.get(faction) > currentLongestRoad.get(faction1)) {
currentLongestRoad.remove(faction1);
currentLongestRoad.put(faction,players.get(faction));
}
}
}
}
}
/**
* This method is recursive and adds all roads which belongs to a specific players and stringing together to a HashSet.
* The length of the HashSet represents the length of the longest Road the player has.
* @param faction the faction of the player to check on
* @param position there has to be a starting point to start counting. In this case it's a corner where a settlement belonging to the players faction is build on.
* @param roads is the hashset with all roads belong to the player which are stringing together
* @param add if true branches needs to be count together. (for example if it is the starting point(first time of counting)) otherwise the longest branch is beeing added to roads.
* @return HashSet with all roads from a specific player which are string together.
*/
private HashSet<Road> countRoad(Config.Faction faction,Point position,HashSet<Road> roads,boolean add) {
List<Road> roadslist = getAdjacentEdges(position);
if(getCorner(position) != null && getCorner(position).getFaction() != faction) {
return roads;
}
Iterator<Road> it2 = roads.iterator();
while(it2.hasNext()) {
Road roadsroad = it2.next();
Iterator<Road> it3 = roadslist.iterator();
while (it3.hasNext()){
Road roadslistRoad = it3.next();
if(roadslistRoad == roadsroad || roadslistRoad.getFaction() != faction) {
it3.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);
if(add) {
for (Road road : listOne) {
listTwo.add(road);
}
roads = listTwo;
}else {
HashSet<Road> tallest;
if(listOne.size()>= listTwo.size()) {
tallest = listOne;
}else{
tallest = listTwo;
}
for (Road road : tallest) {
roads.add(road);
}
}
}
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);
HashSet<Road> tallest;
HashSet<Road> secondtallest;
if(listOne.size()>=listTwo.size()) {
tallest = listOne;
secondtallest = listTwo;
}else {
tallest = listTwo;
secondtallest = listOne;
}if(listThree.size() >= secondtallest.size()) {
secondtallest = listThree;
}
for(Road road : secondtallest) {
tallest.add(road);
}
roads = tallest;
}
return roads;
}
/**
* This method is beeing used to evaluate the next starting position to get the adjacent Roads from it.
* @param road the next road to check on
* @param position the current starting point
* @return return the oposite point of the current point.
*/
private Point getNextPoint(Road road,Point position) {
Point start = road.getStart();
Point end = road.getEnd();
if(position.equals(start)) {
position = end;
}else {
position = start;
}
return position;
}
}

5
src/ch/zhaw/catan/SiedlerBoardTextView.java
View File

@ -2,11 +2,8 @@ package ch.zhaw.catan;
import ch.zhaw.catan.Config.Land;
import ch.zhaw.hexboard.HexBoardTextView;
import ch.zhaw.hexboard.Label;
import java.awt.*;
import java.util.Set;
//TODO Java Docs
public class SiedlerBoardTextView extends HexBoardTextView<Land, Settlement, Road, String> {
public SiedlerBoardTextView(SiedlerBoard board) {

217
src/ch/zhaw/catan/SiedlerGame.java
View File

@ -3,9 +3,14 @@ package ch.zhaw.catan;
import ch.zhaw.catan.Config.Faction;
import ch.zhaw.catan.Config.Resource;
import java.awt.*;
import java.util.*;
import java.awt.Point;
import java.util.Map;
import java.util.HashMap;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.Iterator;
import java.util.HashSet;
/**
@ -35,7 +40,7 @@ public class SiedlerGame {
* three or players is not between two and four
*/
public SiedlerGame(int winPoints, int numberOfPlayers) {
if(winPoints < 3 || numberOfPlayers < 2 || numberOfPlayers > 4) {
if(winPoints < 3 || numberOfPlayers < Config.MIN_NUMBER_OF_PLAYERS || numberOfPlayers > 4) {
throw new IllegalArgumentException();
}
bank = new Bank();
@ -77,7 +82,7 @@ public class SiedlerGame {
activePlayer = allPlayers.size()-1;
}
}
//TODO JavaDoc
private boolean addResourcesToPlayer(Player player, Resource resource, int numberToAdd){
if(bank.getResourceFromBank(resource, numberToAdd)){
player.addResource(resource, numberToAdd);
@ -85,10 +90,10 @@ public class SiedlerGame {
}
return false;
}
private boolean substractResourceFromPlayer(Player player, Resource resource, int numberToSubstract){
if(player.substractResource(resource, numberToSubstract)){
bank.storeResourceToBank(resource, numberToSubstract);
//TODO JavaDoc
private boolean subtractResourceFromPlayer(Player player, Resource resource, int numberToSubtract){
if(player.substractResource(resource, numberToSubtract)){
bank.storeResourceToBank(resource, numberToSubtract);
return true;
}
return false;
@ -212,21 +217,21 @@ public class SiedlerGame {
* 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
* @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) {
if (dicethrow == 7) {
public Map<Faction, List<Resource>> throwDice(int diceThrow) {
if (diceThrow == 7) {
for(Player player : allPlayers) {
handleDiceThrow7(player);
}
} else {
Map<Faction,List<Resource>> returnMap= new HashMap<>();
List<Point> diceValueFields = board.getFieldsForDiceValue(dicethrow);
List<Point> diceValueFields = board.getFieldsForDiceValue(diceThrow);
for (Player player : allPlayers) {
returnMap.put(player.getFaction(), new ArrayList<>());
for (Point field : diceValueFields) {
List<Resource> resources = board.getResourcesforFaction(field,player.getFaction());
List<Resource> resources = board.getResourcesForFaction(field,player.getFaction());
for (Config.Resource resource : resources){
returnMap.get(player.getFaction()).add(resource);
addResourcesToPlayer(player, resource, 1);
@ -237,7 +242,7 @@ public class SiedlerGame {
}
return null;
}
//TODO JavaDoc
public void handleDiceThrow7(Player player) {
ArrayList<Config.Resource> resourceArrayList = new ArrayList<>();
HashMap<Resource, Integer> resources = player.getResources();
@ -246,11 +251,11 @@ public class SiedlerGame {
resourceArrayList.add(resource);
}
}
if(resourceArrayList.size() > 7){
if(resourceArrayList.size() > Config.MAX_CARDS_IN_HAND_NO_DROP){
int resourcesToRemove =resourceArrayList.size() - (resourceArrayList.size() / 2);
Random random = new Random();
for(int i = 0; i < resourcesToRemove; i++){
substractResourceFromPlayer(player, resourceArrayList.remove(random.nextInt(resourceArrayList.size())), 1);
subtractResourceFromPlayer(player, resourceArrayList.remove(random.nextInt(resourceArrayList.size())), 1);
}
}
}
@ -286,7 +291,7 @@ public class SiedlerGame {
List<Config.Resource> costs = Config.Structure.SETTLEMENT.getCosts();
for (Config.Resource resource : costs) {
substractResourceFromPlayer(allPlayers.get(activePlayer), resource, 1);
subtractResourceFromPlayer(allPlayers.get(activePlayer), resource, 1);
}
//4. Insert Settlement to map
@ -324,7 +329,7 @@ public class SiedlerGame {
List<Config.Resource> costs = Config.Structure.CITY.getCosts();
for (Config.Resource resource : costs) {
substractResourceFromPlayer(allPlayers.get(activePlayer), resource, 1);
subtractResourceFromPlayer(allPlayers.get(activePlayer), resource, 1);
}
//4.Insert City into the map.
@ -359,7 +364,7 @@ public class SiedlerGame {
List<Config.Resource> costs = Config.Structure.ROAD.getCosts();
for (Config.Resource resource : costs) {
substractResourceFromPlayer(allPlayers.get(activePlayer), resource, 1);
subtractResourceFromPlayer(allPlayers.get(activePlayer), resource, 1);
}
//3. Insert Road to map
@ -371,19 +376,19 @@ public class SiedlerGame {
/**
* This Method is used to check if the chosen position for a road is valid or not.
* @param roadStart the coordinates where the road begins.
* @param roadEnd the coordinates where the roads ends.
* @param roadEnd the coordinates where the road ends.
* @return true if road position is valid otherwise false
*/
private boolean validPositionForRoad(Point roadStart, Point roadEnd){
//1. Check if Edge
//1. Check if it is an edge
if (!board.hasEdge(roadStart, roadEnd)) {
return false;
}
//2. Check if Edge is empty
//2. Check if edge is empty
if (board.getEdge(roadStart, roadEnd) != null) {
return false;
}
//3. Check if NeighbourEdge are Roads
//3. Check if neighbouring edges are roads
boolean hasNeighbourRoad = (checkAdjacentEdgesList(roadStart) || checkAdjacentEdgesList(roadEnd));
if(hasNeighbourRoad) {
return true;
@ -399,7 +404,7 @@ public class SiedlerGame {
* @return true if valid position for settlement
*/
private boolean validPositionForSettlement(Point position){
//1. Check if Corner
//1. Check if corner
if (!board.hasCorner(position)) {
return false;
}
@ -407,11 +412,11 @@ public class SiedlerGame {
if(checkIfWater(position)) {
return false;
}
//3. Check if Corner is empty
//3. Check if corner is empty
if(board.getCorner(position) != null) {
return false;
}
//3. Check if neighbourCorners are empty
//3. Check if neighbouring corners are empty
return checkAdjacentCornerList(position);
}
@ -464,7 +469,7 @@ public class SiedlerGame {
public boolean tradeWithBankFourToOne(Resource offer, Resource want) {
Player player = allPlayers.get(activePlayer);
if(player.getSpecificResource(offer) >= FOUR_TO_ONE_TRADE_OFFER && addResourcesToPlayer(player, want, FOUR_TO_ONE_TRADE_WANT)){
substractResourceFromPlayer(player, offer, FOUR_TO_ONE_TRADE_OFFER);
subtractResourceFromPlayer(player, offer, FOUR_TO_ONE_TRADE_OFFER);
return true;
}
return false;
@ -476,13 +481,13 @@ public class SiedlerGame {
* @return the winner of the game or null, if there is no winner (yet)
*/
public Faction getWinner() {
if(getCurrentPlayerWinpoints() >= winPointsForWin){
if(getCurrentPlayerWinPoints() >= winPointsForWin){
return getCurrentPlayerFaction();
}
return null;
}
public int getCurrentPlayerWinpoints(){
//Todo Java Doc
public int getCurrentPlayerWinPoints(){
int winPoints = 0;
List<Settlement> settlements = board.getCorners();
for(Structure structure : settlements) {
@ -497,161 +502,13 @@ public class SiedlerGame {
winPoints += newWinPoints;
}
}
longestRoadFaction = getLongestRoadFaction(longestRoadFaction);
board.getLongestRoadFaction(longestRoadFaction,getPlayerFactions());
if(longestRoadFaction.get(getCurrentPlayerFaction()) != null){
winPoints += 2;
}
return winPoints;
}
/**
* This method checks for the player with the longest road according to the catan game rules.
* @return a HashMap<Faction,Integer> where faction is the player with the longest road longer according to catan game rules
* and the Integer representing the length of the road
*/
private HashMap<Config.Faction, Integer> getLongestRoadFaction(HashMap<Config.Faction,Integer> currentLongestRoad) {
List<Settlement> corners = board.getCorners();
List<Config.Faction> factionList = getPlayerFactions();
HashMap<Config.Faction,Integer> players = new HashMap<>();
for(Config.Faction faction : factionList) {
int count = 0;
players.put(faction,count);
for(Settlement settlement : corners){
HashSet<Road> roads = new HashSet<>();
roads = countRoad(faction,settlement.getPosition(),roads,true);
count = roads.size();
int currentCount = players.get(faction);
if(count > currentCount) {
players.put(faction,count);
}
}
}
for(Config.Faction faction : players.keySet()) {
for(Config.Faction faction1 : currentLongestRoad.keySet()) {
if(players.get(faction) >= 5 && players.get(faction) > currentLongestRoad.get(faction1)) {
currentLongestRoad.remove(faction1);
currentLongestRoad.put(faction,players.get(faction));
}
}
}
return currentLongestRoad;
}
/**
* This method is recursive and adds all roads which belongs to a specific players and stringing together to a HashSet.
* The length of the HashSet represents the length of the longest Road the player has.
* @param faction the faction of the player to check on
* @param position there has to be a starting point to start counting. In this case it's a corner where a settlement belonging to the players faction is build on.
* @param roads is the hashset with all roads belong to the player which are stringing together
* @param add if true branches needs to be count together. (for example if it is the starting point(first time of counting)) otherwise the longest branch is beeing added to roads.
* @return HashSet with all roads from a specific player which are string together.
*/
private HashSet<Road> countRoad(Config.Faction faction,Point position,HashSet<Road> roads,boolean add) {
List<Road> roadslist = board.getAdjacentEdges(position);
if(board.getCorner(position) != null || board.getCorner(position).getFaction() != faction) {
return roads;
}
Iterator<Road> it2 = roads.iterator();
while(it2.hasNext()) {
Road roadsroad = it2.next();
Iterator<Road> it3 = roadslist.iterator();
while (it3.hasNext()){
Road roadslistRoad = it3.next();
if(roadslistRoad == roadsroad || roadslistRoad.getFaction() != faction) {
it3.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);
if(add) {
for (Road road : listOne) {
listTwo.add(road);
}
roads = listTwo;
}else {
HashSet<Road> tallest;
if(listOne.size()>= listTwo.size()) {
tallest = listOne;
}else{
tallest = listTwo;
}
for (Road road : tallest) {
roads.add(road);
}
}
}
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);
HashSet<Road> tallest;
HashSet<Road> secondtallest;
if(listOne.size()>=listTwo.size()) {
tallest = listOne;
secondtallest = listTwo;
}else {
tallest = listTwo;
secondtallest = listOne;
}if(listThree.size() >= secondtallest.size()) {
secondtallest = listThree;
}
for(Road road : secondtallest) {
tallest.add(road);
}
roads = tallest;
}
return roads;
}
/**
* This method is beeing used to evaluate the next starting position to get the adjacent Roads from it.
* @param road the next road to check on
* @param position the current starting point
* @return return the oposite point of the current point.
*/
private Point getNextPoint(Road road,Point position) {
Point start = road.getStart();
Point end = road.getEnd();
if(position.equals(start)) {
position = end;
}else {
position = start;
}
return position;
}
/**
* 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
@ -663,7 +520,7 @@ public class SiedlerGame {
* placed there (e.g., on water)
*/
public boolean placeThiefAndStealCard(Point field) {
//TODO: Implement (or longest road functionality)
// Implemented longest road.
return false;
}

22
test/ch/zhaw/catan/SiedlerGameTest.java
View File

@ -13,9 +13,8 @@ import org.junit.jupiter.api.Nested;
import org.junit.jupiter.api.Test;
import java.awt.*;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.*;
import java.util.List;
/***
@ -50,18 +49,15 @@ public class SiedlerGameTest {
));
/**
* To Test getLongestRoad in SiedlerGame isolatet do:
* 1. make SiedlerGame.getLongestRoadFaction, Siedlergame.countRoad && Siedlergame.getNextPoint static
* 2. make SiedlerGame.getLongestRoadFaction public
* 3. add Parameter Board to SiedlerGame.getLongestRoadFaction and SiedlerGame.countRoad.
* 4. add Parameter faction to SiedlerGame.getLongestRoadFaction
* 5. Create Board in testLongestRoad() and Hashmap with faction
* Tipp: Logic Equivalent classes are: start counting at settlements with 0 or 1 or 2 or 3 own roads attached to it
* Make branches in between the road with diffrent lengths.
* To Test getLongestRoad in SiedlerBoard
*
*/
@Test
public void testLongestRoad() {
HashMap<Config.Faction,Integer> currentLongestRoad = new HashMap<>();
//currentLongestRoad.put(Config.Faction.RED,5);
List<Config.Faction> factionList = Arrays.asList(Config.Faction.values());
SiedlerBoard board = new SiedlerBoard();
board.createFixGamefield();
board.setEdge(new Point(6, 6), new Point(5, 7), new Road(Config.Faction.BLUE,new Point(6, 6),new Point(5, 7)));
@ -72,7 +68,9 @@ public class SiedlerGameTest {
board.setEdge(new Point(3, 9), new Point(4, 10), new Road(Config.Faction.BLUE,new Point(3, 9),new Point(4, 10)));
board.setEdge(new Point(4, 10), new Point(5, 9), new Road(Config.Faction.BLUE,new Point(4, 10),new Point(5, 9)));
board.setCorner(new Point(3,7),new Settlement(Config.Faction.BLUE,new Point(3,7)));
//SiedlerGame.getLongestRoadFaction(board,faction);
board.getLongestRoadFaction(currentLongestRoad,factionList);
assertEquals(6,currentLongestRoad.get(Config.Faction.BLUE));
}
/**