joachim/fop-projekt
1
0
Fork 0
Code Issues 1 Pull requests Projects Releases Packages Wiki Activity Actions

Solution to 3.1.6

Browse source 
- Added solution to 3.1.6
- Added highscores.txt file to temporarily resolve errors
This commit is contained in:
Jonas Suess 2019-02-23 15:04:40 +01:00
parent db6e70ebaf
commit 4677283164
3 changed files with 208 additions and 115 deletions
Download patch file Download diff file Expand all files Collapse all files

0
Projektgruppe_175/res/highscores.txt Normal file
View file

152
Projektgruppe_175/src/game/map/Clustering.java
View file

@ -1,40 +1,112 @@
package game.map; package game.map;
import java.util.ArrayList; import java.awt.Point;
import java.util.Collections; import java.util.ArrayList;
import java.util.List; import java.util.Collections;
import java.util.Random; import java.util.List;
import java.util.Random;
/**
* Diese Klasse teilt Burgen in Königreiche auf /**
*/ * Diese Klasse teilt Burgen in Königreiche auf
public class Clustering { */
public class Clustering {
private Random random;
private final List<Castle> allCastles; private Random random;
private final int kingdomCount; private final List<Castle> allCastles;
private final int kingdomCount;
/**
* Ein neues Clustering-Objekt erzeugen. /**
* @param castles Die Liste von Burgen, die aufgeteilt werden sollen * Ein neues Clustering-Objekt erzeugen.
* @param kingdomCount Die Anzahl von Königreichen die generiert werden sollen * @param castles Die Liste von Burgen, die aufgeteilt werden sollen
*/ * @param kingdomCount Die Anzahl von Königreichen die generiert werden sollen
public Clustering(List<Castle> castles, int kingdomCount) { */
if (kingdomCount < 2) public Clustering(List<Castle> castles, int kingdomCount) {
throw new IllegalArgumentException("Ungültige Anzahl an Königreichen"); if (kingdomCount < 2)
throw new IllegalArgumentException("Ungültige Anzahl an Königreichen");
this.random = new Random();
this.kingdomCount = kingdomCount; this.random = new Random();
this.allCastles = Collections.unmodifiableList(castles); this.kingdomCount = kingdomCount;
} this.allCastles = Collections.unmodifiableList(castles);
}
/**
* Gibt eine Liste von Königreichen zurück. /**
* Jedes Königreich sollte dabei einen Index im Bereich 0-5 bekommen, damit die Burg richtig angezeigt werden kann. * Gibt eine Liste von Königreichen zurück.
* Siehe auch {@link Kingdom#getType()} * Jedes Königreich sollte dabei einen Index im Bereich 0-5 bekommen, damit die Burg richtig angezeigt werden kann.
*/ * Siehe auch {@link Kingdom#getType()}
public List<Kingdom> getPointsClusters() { */
// TODO Clustering#getPointsClusters() public List<Kingdom> getPointsClusters() {
return new ArrayList<>(); List<Kingdom> kingdoms = new ArrayList<>();
}
} // Erzeuge Königreiche mit zufälligen Zentren
for(int i = 0; i < kingdomCount; i++) {
kingdoms.add(new Kingdom(i, allCastles.get(random.nextInt(allCastles.size()))));
}
boolean changed;
Kingdom lastKingdom;
// Wiederhole, solange sich die Zuordnungen der Burgen zu den Königreichen ändern
do {
changed = false;
// Ordne jede Burg dem nächstgelegenen Königreich zu
for(Castle c : allCastles) {
lastKingdom = c.getKingdom();
c.setKingdom(this.getNearestKingdom(c, kingdoms));
if(c.getKingdom() != lastKingdom) changed = true; // Eine Zuordnung hat sich geändert
}
// Setze die Zentren der Königreiche neu
for(Kingdom k : kingdoms) {
double meanX=0, meanY=0, sumX=0, sumY=0;
double numCastles = k.getCastles().size();
for(Castle c : k.getCastles()) {
sumX += c.getLocationOnMap().getX();
sumY += c.getLocationOnMap().getY();
}
meanX = sumX/numCastles;
meanY = sumY/numCastles;
Point p = new Point();
p.setLocation(meanX, meanY);
k.setCenter(getNearestCastle(p, allCastles));
}
}while(changed);
return kingdoms;
}
/**
* Gibt die dem übergebenen Punkt nächstgelegene Burg zurück
* @param point der Punkt auf der Karte
* @param castles die Liste aller Burgen
* @return die nächstgelegene Burg
*/
protected Castle getNearestCastle(Point point, List<Castle> castles) {
Castle nearest = castles.get(0);
for(Castle c : castles) {
if(c.distance(point) < nearest.distance(point)) {
nearest = c;
}
}
return nearest;
}
/**
* Gibt das zur übergebenen Burg nächstgelegene Königreich zurück
* @param castle die Burg
* @param kingdoms die Liste aller Königreiche
* @return das nächstgelegene Königreich
*/
protected Kingdom getNearestKingdom(Castle castle, List<Kingdom> kingdoms) {
Kingdom nearest = kingdoms.get(0);
double dist = castle.distance(nearest.getCenter());
for(Kingdom k : kingdoms) {
if(castle.distance(k.getCenter()) < dist) {
nearest = k;
dist = castle.distance(nearest.getCenter());
}
}
return nearest;
}
}

171
Projektgruppe_175/src/game/map/Kingdom.java
View file

@ -1,75 +1,96 @@
package game.map; package game.map;
import game.Player; import game.Player;
import java.util.LinkedList; import java.util.LinkedList;
import java.util.List; import java.util.List;
/** /**
* Diese Klasse representiert ein Königreich. Jedes Königreich hat eine Liste von Burgen sowie einen Index {@link #type} im Bereich von 0-5 * Diese Klasse representiert ein Königreich. Jedes Königreich hat eine Liste von Burgen sowie einen Index {@link #type} im Bereich von 0-5
* *
*/ */
public class Kingdom { public class Kingdom {
private List<Castle> castles; private List<Castle> castles;
private int type; private Castle center;
private int type;
/**
* Erstellt ein neues Königreich /**
* @param type der Typ des Königreichs (im Bereich 0-5) * Erstellt ein neues Königreich
*/ * @param type der Typ des Königreichs (im Bereich 0-5)
public Kingdom(int type) { * @param center das Zentrum des Königreichs
this.castles = new LinkedList<>(); */
this.type = type; public Kingdom(int type, Castle center) {
} this.castles = new LinkedList<>();
this.type = type;
/** this.center = center;
* Eine Burg zum Königreich hinzufügen center.setKingdom(this);
* @param castle die Burg, die hinzugefügt werden soll this.castles.add(center);
*/ }
public void addCastle(Castle castle) {
this.castles.add(castle); /**
} * Eine Burg zum Königreich hinzufügen
* @param castle die Burg, die hinzugefügt werden soll
/** */
* Gibt den Typen des Königreichs zurück. Dies wird zur korrekten Anzeige benötigt public void addCastle(Castle castle) {
* @return der Typ des Königreichs. this.castles.add(castle);
*/ }
public int getType() {
return this.type; /**
} * Eine Burg als Zentrum des Königreichs festlegen
* @param castle die Burg, die als Zentrum festgelegt werden soll
/** */
* Eine Burg aus dem Königreich entfernen public void setCenter(Castle castle) {
* @param castle die zu entfernende Burg this.center = castle;
*/ }
public void removeCastle(Castle castle) {
this.castles.remove(castle); /**
} * Gibt das Zentrum des Königreichs zurück
* @param castle die Burg, die das Zentrum des Königreichs darstellt
/** */
* Gibt den Spieler zurück, der alle Burgen in dem Köngreich besitzt. public Castle getCenter() {
* Sollte es keinen Spieler geben, der alle Burgen besitzt, wird null zurückgegeben. return this.center;
* @return der Besitzer oder null }
*/
public Player getOwner() { /**
if(castles.isEmpty()) * Gibt den Typen des Königreichs zurück. Dies wird zur korrekten Anzeige benötigt
return null; * @return der Typ des Königreichs.
*/
Player owner = castles.get(0).getOwner(); public int getType() {
for(Castle castle : castles) { return this.type;
if(castle.getOwner() != owner) }
return null;
} /**
* Eine Burg aus dem Königreich entfernen
return owner; * @param castle die zu entfernende Burg
} */
public void removeCastle(Castle castle) {
/** this.castles.remove(castle);
* Gibt alle Burgen zurück, die in diesem Königreich liegen }
* @return Liste von Burgen im Königreich
*/ /**
public List<Castle> getCastles() { * Gibt den Spieler zurück, der alle Burgen in dem Köngreich besitzt.
return this.castles; * Sollte es keinen Spieler geben, der alle Burgen besitzt, wird null zurückgegeben.
} * @return der Besitzer oder null
} */
public Player getOwner() {
if(castles.isEmpty())
return null;
Player owner = castles.get(0).getOwner();
for(Castle castle : castles) {
if(castle.getOwner() != owner)
return null;
}
return owner;
}
/**
* Gibt alle Burgen zurück, die in diesem Königreich liegen
* @return Liste von Burgen im Königreich
*/
public List<Castle> getCastles() {
return this.castles;
}
}