diff --git a/Projektgruppe_175/src/game/Player.java b/Projektgruppe_175/src/game/Player.java index 8c9dee6..d086866 100644 --- a/Projektgruppe_175/src/game/Player.java +++ b/Projektgruppe_175/src/game/Player.java @@ -22,10 +22,13 @@ public abstract class Player { this.remainingTroops = 0; } - public int getRemainingTroops() { - return this.remainingTroops; - } - + /** + * Creates a player + * @param playerType The type of player (human, AI, etc.) + * @param name The name of the player + * @param color The color of the player + * @return The new player + */ public static Player createPlayer(Class playerType, String name, Color color) { if(!Player.class.isAssignableFrom(playerType)) throw new IllegalArgumentException("Not a player class"); @@ -39,26 +42,54 @@ public abstract class Player { } } + /** + * Sets the color of this player + * @param c + */ public void setColor(Color c) { this.color = c; } + /** + * Gets the color of the player + * @return + */ public Color getColor() { return this.color; } + /** + * Gets the name of this player + * @return The name + */ public String getName() { return this.name; } + + public int getRemainingTroops() { + return this.remainingTroops; + } + /** + * Gets the current points of this player + * @return The current points + */ public int getPoints() { return points; } + /** + * Increases the score of this player + * @param points The number of points to add + */ public void addPoints(int points) { this.points += points; } + /** + * Adds troops to the player + * @param troops The number of troops to add + */ public void addTroops(int troops) { if(troops < 0) return; @@ -66,6 +97,10 @@ public abstract class Player { this.remainingTroops += troops; } + /** + * Removes troops from this player + * @param troops The number of troops to remove + */ public void removeTroops(int troops) { if(this.remainingTroops - troops < 0 || troops < 0) return; @@ -73,14 +108,27 @@ public abstract class Player { this.remainingTroops -= troops; } + /** + * Gets the number of castles this player has + * @param game The game object + * @return The number of castles + */ public int getNumRegions(Game game) { return this.getCastles(game).size(); } + /** + * Gets all the castles that belong to the player + * @param game The game object + * @return A list of castles + */ public List getCastles(Game game) { return game.getMap().getCastles().stream().filter(c -> c.getOwner() == this).collect(Collectors.toList()); } + /** + * Resets the player by resetting the troops and points + */ public void reset() { this.remainingTroops = 0; this.points = 0; diff --git a/Projektgruppe_175/src/game/goals/CaptureTheFlagGoal.java b/Projektgruppe_175/src/game/goals/CaptureTheFlagGoal.java index fa216ca..c2f63bd 100644 --- a/Projektgruppe_175/src/game/goals/CaptureTheFlagGoal.java +++ b/Projektgruppe_175/src/game/goals/CaptureTheFlagGoal.java @@ -1,31 +1,70 @@ package game.goals; +import java.util.List; + +import game.Game; import game.Goal; import game.Player; +import game.map.Castle; public class CaptureTheFlagGoal extends Goal { + final int ROUND_FOR_DISTRIBUTION = 2; + final int MIN_ROUND_FOR_WIN = 2; + + List flagCastles; + public CaptureTheFlagGoal() { - // TODO Auto-generated constructor stub super("Capture the flag", ""); } @Override public boolean isCompleted() { - // TODO Auto-generated method stub - return false; + + Game game = this.getGame(); + + // As this function is called every round, + // let's check if we can set the flag castles + if (flagCastles == null && game.getRound() > ROUND_FOR_DISTRIBUTION) { + distributeFlagCastles(); + } + + return this.getWinner() != null; } @Override public Player getWinner() { - // TODO Auto-generated method stub + + Game game = this.getGame(); + + if (game.getRound() < MIN_ROUND_FOR_WIN) + return null; + + // Check if all flag castles belong + // to exactly one player + + return null; + } @Override public boolean hasLost(Player player) { - // TODO Auto-generated method stub + + if (isCompleted()) + return player.equals(getWinner()); + return false; + + } + + /** + * Distribute the flag castles + */ + private void distributeFlagCastles() { + + + } } diff --git a/Projektgruppe_175/src/tests/student/GraphAlgorithmTest.java b/Projektgruppe_175/src/tests/student/GraphAlgorithmTest.java new file mode 100644 index 0000000..38ec510 --- /dev/null +++ b/Projektgruppe_175/src/tests/student/GraphAlgorithmTest.java @@ -0,0 +1,5 @@ +package tests.student; + +public class GraphAlgorithmTest { + +} diff --git a/doc/Dokumentation.tex b/doc/Dokumentation.tex index 1453dce..b7a9d65 100644 --- a/doc/Dokumentation.tex +++ b/doc/Dokumentation.tex @@ -24,7 +24,7 @@ Der Algorithmus für die Bildung der Kanten ist folgender: \begin{algorithm} - \caption{Bildung von Kanten}\label{euclid} + \caption{Bildung von Kanten}\label{generate} \begin{algorithmic}[1] \Procedure{generateEdges}{} \If{nodes is empty} return \EndIf @@ -73,7 +73,7 @@ Der Algorithmus, der prüft, ob alle Knoten erreichbar sind, ist folgender: \begin{algorithm} - \caption{Erreichbarkeit aller Knoten}\label{euclid} + \caption{Erreichbarkeit aller Knoten}\label{connected} \begin{algorithmic}[1] \Procedure{allNodesConnected}{} \State $\textit{firstNode} \gets \text{first element of }\textit{nodes}$ @@ -128,7 +128,7 @@ werden der ArrayDeque \texttt{nextVisitNodes} hinzugefügt. \subsubsection{Teil (a)} \begin{algorithm} - \caption{Berechnung der Distanzen}\label{euclid} + \caption{Berechnung der Distanzen}\label{path} \begin{algorithmic}[1] \Procedure{run}{} \State $v \gets$ getSmallestNode() @@ -151,7 +151,7 @@ werden der ArrayDeque \texttt{nextVisitNodes} hinzugefügt. \end{algorithm} -$$O(n) = $$ +$$O(n)$$ $n$ soll in diesem Fall die Anzahl an Knoten wiedergeben. @@ -161,6 +161,13 @@ Durchgehen der Liste jedes Element einzeln abgearbeitet werden. In der Funktion \texttt{getSmallestNode()} ist dies der Fall. +Das bedeutet, dass bei jeder Aufruf von \texttt{getSmallestNode()} +eine Komplexität von $O(n)$ hat, wenn $n$ die Anzahl +der Knoten darstellt. + +Bei jeder Iteration des Algorithmus wird zuerst der +Knoten mit dem kleinsten Wert gesucht. + \subsubsection{Teil (b)} Anstelle einer \texttt{LinkedList} braucht man eine @@ -174,7 +181,7 @@ Elemente beim Einfügen bereits sortiert, sodass der Zugriff auf das (in diesem Fall) kleinste Element in $O(1)$, also konstanter Zeit, gemacht werden kann. -$$O(n) = $$ +$$O(n)$$ \subsubsection{Teil (c)} @@ -199,6 +206,15 @@ Für alle abgearbeiteten Knoten gilt: \subsection{Missionen} +\subsubsection{Begrenzte Rundenanzahl} + +\subsubsection{Capture the Flag} + +In dieser Mission werden wichtige Burgen, sogenannte +Flags, gleichmäßig auf die Spieler verteilt. Es ist das +Ziel, zuerst vor allen anderen Spielern alle diese Burgen +zu erobern. + \subsection{Joker} \end{document}