Hallo zusammen,
ich bin momentan dabei Spieler eines Teams in 2 unterschiedlichen Runden auf Tische zu verteilen.
Es geht um eine Verwaltung für ein Turnier!
Das Turnier kann unterschiedlich strukturiert sein: 0,1, oder 2
0 = 4 Spieler in einem Team (Team mit meisten Punkten gewinnt)
1 = 4 oder 8 Spieler pro Team (Team mit höchstem Ø gewinnt)
2 = 4 oder 8 Spieler pro Team (8er Teams werden in 2x 4er geteilt, Team mit meisten Punkten gewinnt. Die aufgeteilten 8er Teams werden unabhängig voneinander gewertet, allerdings dürfen keine Spieler der beiden Teams gegeneinander spielen, sprich in einer Spielrunden am selben Tisch sitzen).
Ich habe einfach mal ein Testprojekt erstellt. Ich hoffe, dass mir der ein oder andere damit vielleicht helfen kann.
Was passiert:
Die Turniervarianten 0 und 1 passen perfekt! Alles läuft problemlos.
Die Variante 2 klappt nicht 100%ig, wenn das Turnier nur aus 4 Teams besteht, die jeweils 8 Spieler haben.
Da kommt es öfters mal zu Endlosschleifen, oft klappt die Verwaltung auch! Ich muss die Endlosschleife beim Generieren der 2. Spielrunde irgendwie da rausbekommen, nur komm ich echt irgendwie nicht weiter ;/
Die 1. Runde wird auch problemlos erstellt.
ich bin momentan dabei Spieler eines Teams in 2 unterschiedlichen Runden auf Tische zu verteilen.
Es geht um eine Verwaltung für ein Turnier!
Das Turnier kann unterschiedlich strukturiert sein: 0,1, oder 2
0 = 4 Spieler in einem Team (Team mit meisten Punkten gewinnt)
1 = 4 oder 8 Spieler pro Team (Team mit höchstem Ø gewinnt)
2 = 4 oder 8 Spieler pro Team (8er Teams werden in 2x 4er geteilt, Team mit meisten Punkten gewinnt. Die aufgeteilten 8er Teams werden unabhängig voneinander gewertet, allerdings dürfen keine Spieler der beiden Teams gegeneinander spielen, sprich in einer Spielrunden am selben Tisch sitzen).
Ich habe einfach mal ein Testprojekt erstellt. Ich hoffe, dass mir der ein oder andere damit vielleicht helfen kann.
Was passiert:
Die Turniervarianten 0 und 1 passen perfekt! Alles läuft problemlos.
Die Variante 2 klappt nicht 100%ig, wenn das Turnier nur aus 4 Teams besteht, die jeweils 8 Spieler haben.
Da kommt es öfters mal zu Endlosschleifen, oft klappt die Verwaltung auch! Ich muss die Endlosschleife beim Generieren der 2. Spielrunde irgendwie da rausbekommen, nur komm ich echt irgendwie nicht weiter ;/
Die 1. Runde wird auch problemlos erstellt.
Java:
package rundengenerierenteilen;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Random;
/**
*
* @author Jakob Bennemann
*/
public class TestKlasse {
/**
* Testprojekt, um den richtigen Sourcecode nicht zu zerstören :D
*/
/*
Aufbau des Turniers:
- Jedes Team hat entweder 4 oder 8 Spieler
- Daraus ergeben sich die Anzahl der Tische = Anzahl Teams 8 Spieler * 2 + Anzahl der Teams 4 Spieler
- 4 Spieler pro Tisch
- 2 Spielrunden
- In keiner Runde dürfen 2+ Spieler dessellben Teams gegeneinander spielen
- 8er Teams werden geteilt in 2x 4er Team (beide Teams werden unabhängig von einander gewertet)
- keine Spieler der 2x 4er Teams dürfen gegeneinander spielen, da eigentlich gleiches Team
- Spieler die in Runde 1 bereits gegeneinander gespielt haben, dürfen dies in der 2. Runde nicht und v.v.!
Aufbau Tische/Teams:
Teams 1-4 besitzen 8 Spieler Team-IDs: 1,2,3,4,5,6,7,8 denn die Teams werden in 4er geteilt
Teams 5-8 besitzen 4 Spieler Team-ID:s 9,10,11,12 denn die Teams haben bereits 4 Spieler
Das 1. 8er Team besteht also aus den IDs: 1,2 dabei hat das Team mit der ID: 2 als mainID: 1
da das Hauptteam das Team mit der ID: 1 ist
Beispielverteilung:
Tisch 1| Spieler | Team Tisch 2| Spieler | Team Tisch 3| Spieler | Team
------------------------------ ------------------------------ ------------------------------
+++++++ Spieler 4 Team 1 +++++++ Spieler 3 Team 1 +++++++ Spieler 1 Team 9
+++++++ Spieler 1 Team 5 +++++++ Spieler 3 Team 3 +++++++ Spieler 2 Team 10
+++++++ Spieler 2 Team 3 +++++++ Spieler 3 Team 5 +++++++ Spieler 3 Team 11
+++++++ Spieler 1 Team 7 +++++++ Spieler 3 Team 11 +++++++ Spieler 4 Team 12
..... Die Tische werden .....
..... dann automatisch generiert .....
*/
static ArrayList<Team> teams; // Liste der Teams des Turniers
static ArrayList<Tisch> desksRound1, desksRound2; // Listen der Tische in Runde 1/2 mit den Spielern
static HashMap mapping1, mapping2; // HashMaps zur Zurordnung der Tische/Spieler in Runde 1/2
static int tournamentType = 2; // Turniertyp 0=4Spieler im Team, 1=4 oder 8 Spieler, wobei die
// Durchschnittspunkte gewertet werden, 2=4 oder 8 Spieler pro
// Team, wobei die 8er Teams in 2x 4er aufgeteilt werden und als
// eigenes Team gewertet werden, jedoch immer noch ein Teil des
// 8er Teams sind und auch nicht gegen Spieler des anderen
// 4er Teams spielen dürfen
public static void main(String[] args){
teams = new ArrayList<>(); // Turnierteams initialisieren
desksRound1 = new ArrayList<>(); // Tische der Runde 1 initialisieren
desksRound2 = new ArrayList<>(); // Tische der Runde 2 initialisieren
addTeamsEightPlayers(4); // 4 Teams mit 8 Spielern hinzufügen
//addTeamsFourPlayers(4); // 4 Teams mit 4 Spielern hinzufügen
//ausgabeTeams(getOriginalTeams()); // Ausgabe der Originalteams (8er Teams werden ausgegeben)
//ausgabeTeams(); // Ausgabe der Teams im Turnier
// Hier werden die Teams in 4er Teams ausgegeben, da 8er Teams
// geteilt wurden (Turniertype=2)
generate1(); // Runde 1 passt immer!
int m = 0;
while(generate2() == false){m++;} // HIER KOMME ICH OFT IN EINE ENDLOS-SCHLEIFE, WENN
// ICH NUR 4x 8er Teams IM GESAMTEN TURNIER HABE,
// DIE MUSS WEG!!
System.out.println("Runde 2 ungültig: " + m + "x");
//ausgabe1(); // Ausgabe der Tische in Runde 1
//ausgabe2(); // Ausgabe der Tische in Runde 2
System.out.println("Erstellte Spielrunden regelkonform: " + ((TestKlasse.roundsValid() == true) ? "ja" : "nein"));
}
/*
* Hier werden die 2 Spielrunden auf ihre Richtigkeit hin überprüft, ob diese so überhaupt existieren dürfen, oder
* ob bspw. Spieler aus demselben Team an einem Tisch sitzen.
*
* @return Runden regelkonform generiert
*/
private static boolean roundsValid() {
int i = 0;
for (Tisch r1 : desksRound1) {
for (Spieler s : r1.getSpieler()) {
for (Tisch r2 : desksRound2) {
for (Spieler s2 : r2.getSpieler()) {
if (s.getName().equalsIgnoreCase(s2.getName()) && s.getTeamnummer() == s2.getTeamnummer()) {
s.setTischnummerRunde2(r2.getTischnummer());
s.setTischnummerRunde1(r1.getTischnummer());
s2.setTischnummerRunde2(r2.getTischnummer());
s2.setTischnummerRunde1(r1.getTischnummer());
}
}
}
}
}
for (Tisch t1 : desksRound1) {
for (Spieler sp : t1.getSpieler()) {
for (Tisch t2 : desksRound2) {
//System.out.println("Tischnummer: " + sp.getTischnummerRunde2() + " sp:" + sp.getName() + " - tid:" + sp.getTeamnummer());
if (sp.getTischnummerRunde2() == t2.getTischnummer()) {
//System.out.println(i++ + "test");
for (Spieler tSpieler : t2.getSpieler()) {
if (tSpieler.getTeamnummer() == sp.getTeamnummer() && !tSpieler.getName().equalsIgnoreCase(sp.getName())) {
i++;
}
if (sp.getTeamnummer() == getTeamByID(tSpieler.getTeamnummer()).getMainID() && getTeamByID(tSpieler.getTeamnummer()).getMainID() != 0) {
i++;
}
if (tSpieler.getTeamnummer() == getTeamByID(sp.getTeamnummer()).getMainID() && getTeamByID(sp.getTeamnummer()).getMainID() != 0) {
i++;
}
}
}
}
}
}
for (Tisch t : desksRound2) {
for (Spieler sp : t.getSpieler()) {
ArrayList<Spieler> gegner = new ArrayList<>();
for (int j = 0; j < 4; j++) {
gegner.add(t.getSpieler().get(j));
}
gegner.remove(sp);
// System.out.println("Gegner von: " + sp.getName() + " (" + sp.getTeamnummer() + ")");
// for (Spieler spieler : gegner) {
// System.out.println(spieler.getName() + " - " + spieler.getTeamnummer());
// }
// System.out.println("");
for (Tisch t1 : desksRound1) {
if (sp.getTischnummerRunde1() == t1.getTischnummer()) {
for (Spieler gegnRunde1 : t1.getSpieler()) {
if (!gegnRunde1.getName().equals(sp.getName()) && sp.getTeamnummer() != gegnRunde1.getTeamnummer()) {
for (Spieler gegnerListe : gegner) {
if (gegnRunde1.getName().equalsIgnoreCase(gegnerListe.getName()) && gegnRunde1.getTeamnummer() == gegnerListe.getTeamnummer()) {
i++;
}
}
}
}
}
}
gegner.clear();
}
}
if (i == 0 && desksRound1.size() == desksRound2.size()) {
return true;
} else {
return false;
}
}
/*
* Hier werden aus den vorhandenen Teams die "Originalteams" wieder zusammengesetzt. Diese Methode wird bei dem
* 4er/8er Turniertyp (typ=2) benötigt, da hierbei die 8er Teams in 2x 4er Teams geteilt werden, allerdings für die
* Auswertung trotzdem ein Team bilden und somit auch nicht gegeneinander spielen dürfen.
*
*@return Rückgabe der originalen 4er und 8er Teams
*/
private static ArrayList<Team> getOriginalTeams() {
ArrayList<Team> teams = new ArrayList<>();
Team tVorher = null;
for (Team t : TestKlasse.teams) {
Team tmp = null;
if (t.getMainID() == 0) {
tmp = new Team(t.getTeamID(), t.getTeamname(), t.getMainID(), t.getSpieler());
teams.add(tmp);
} else {
for (Team team : teams) {
if (team.getTeamID() == t.getMainID()) {
for (Spieler sp : t.getSpieler()) {
team.addSpieler(new Spieler(sp.getName(), sp.getTeamnummer()));
}
}
}
}
}
return teams;
}
/*
* Hier wird die erste Spielrunde erstellt.
*
*@return Spieler wurden erfolgreich auf die Tische verteilt.
*/
private static boolean generate1() {
desksRound1 = new ArrayList();
mapping1 = new HashMap();
Random r = new Random();
ArrayList<Team> tmp = null;
if (tournamentType == 2) {
tmp = getOriginalTeams();
} else {
tmp = new ArrayList();
for (Team t : teams) {
tmp.add(new Team(t.getTeamID(), t.getTeamname(), t.getMainID(), t.getSpieler()));
}
}
//ausgabeTeams(tmp);
Collections.shuffle(tmp);
int i = 1;
while (!tmp.isEmpty()) {
List<Team> tischTeams = new ArrayList();
tischTeams.addAll(tmp);
Collections.shuffle(tischTeams);
Tisch tisch = new Tisch(i);
for (int j = 0; j < 4 && !tischTeams.isEmpty(); j++) {
Team team = null;
team = findBiggestTeam(tischTeams);
//System.out.println("Spieler im Team: " + team.getSpieler().size());
Spieler s = team.getSpieler().get(r.nextInt(team.getSpieler().size()));
s.setTischnummerRunde1(i);
mapping1.put(s, tisch);
tisch.getSpieler().add(s);
team.getSpieler().remove(s);
tischTeams.remove(team);
if (team.getSpieler().isEmpty()) {
tmp.remove(team);
}
}
desksRound1.add(tisch);
i++;
}
return true;
}
/*
* Hier wird die zweite Spielrunde erstellt.
*
*@return Spieler wurden erfolgreich auf die Tische verteilt.
*/
private static boolean generate2() {
mapping2 = new HashMap();
desksRound2 = new ArrayList<>();
List<Team> tmp = new ArrayList();
if (tournamentType == 2) {
tmp = getOriginalTeams();
//System.out.println(tmp.get(0).getSpieler().size() + " -...");
//System.out.println("größe: " + tmp.size());
} else {
for (Team t : TestKlasse.teams) {
tmp.add(new Team(t.getTeamID(), t.getTeamname(), t.getMainID(), t.getSpieler()));
}
}
int i = 1;
//System.out.println("test");
while (!tmp.isEmpty()) {
List<Team> tischTeams = new ArrayList();
Collections.shuffle(tmp);
tischTeams.addAll(tmp);
Collections.shuffle(tischTeams);
Tisch tisch = new Tisch(i);
for (int j = 0; j < 4 && j <= TestKlasse.teams.size(); j++) {
Team team = findBiggestTeam(tischTeams);
//System.out.println(team);
// System.out.println("TeamID: " + team.getTeamID());
boolean letzteRundeOk = true;
for (Spieler s : team.getSpieler()) {
Tisch letzterTisch = null;
if (tournamentType == 2) {
for (Tisch r1 : desksRound1) {
for (Spieler sp : r1.getSpieler()) {
if (sp.getName().equalsIgnoreCase(s.getName()) && sp.getTeamnummer() == s.getTeamnummer()) {
letzterTisch = r1;
}
}
}
} else {
letzterTisch = (Tisch) mapping1.get(s);
}
letzteRundeOk = true;
for (Spieler sp : tisch.getSpieler()) {
if (tournamentType == 2) {
for (Spieler spi : letzterTisch.getSpieler()) {
if (spi.getName().equalsIgnoreCase(sp.getName()) && spi.getTeamnummer() == sp.getTeamnummer()) {
letzteRundeOk = false;
}
}
} else {
if (letzterTisch.getSpieler().contains(sp)) {
letzteRundeOk = false;
} else {
System.out.println(letzterTisch);
}
}
}
if (letzteRundeOk) {
mapping2.put(s, tisch);
tisch.getSpieler().add(s);
s.setTischnummerRunde2(i);
team.getSpieler().remove(s);
tischTeams.remove(team);
break;
} else {
letzteRundeOk = false;
}
}
if (!letzteRundeOk) {
return false;
}
if (team.getSpieler().isEmpty()) {
tmp.remove(team);
}
}
desksRound2.add(tisch);
i++;
}
return true;
}
/*
* Hilfsmethode, um ein Team bei gegebener Teamnummer zu erhalten.
*
*@param teamnummer Teamnummer des Teams
*
*@return Team mit der übergebenen Teamnummer
*/
private static Team getTeamByID(int teamnummer) {
for (Team t : TestKlasse.teams) {
if (t.getTeamID() == teamnummer) {
return t;
}
}
return null;
}
/*
* Hilfsmethode, um das Team mit den meisten Spielern zu erhalten.
*
*@param teams Liste der im Turnier vorhandenen Teams
*
*@return Team mit der höchsten Anzahl an Spielern
*/
private static Team findBiggestTeam(List<Team> teams) {
int max = -1;
Team team = null;
for (Team t : teams) {
if (t.getSpieler().size() > max) {
team = t;
max = t.getSpieler().size();
}
}
return team;
}
/*
* Initialisierungsmethode, um eine Anzahl von Teams mit 8 Spielern dem Turnier hinzuzufügen. Hierbei wird das 8er Team
* direkt in 2x 4er Teams aufgeteilt. Das 2. 4er Team bekommt die Teamnummer des 1. 4er Teams als mainID übergeben.
*
*@param anzahl Anzahl an Teams die hinzugefügt werden sollen
*/
public static void addTeamsEightPlayers(int anzahl) {
for (int i = 0; i < anzahl * 2; i = i + 2) {
teams.add(new Team((i + 1), 0));
teams.add(new Team((i + 2), (i + 1)));
}
for (Team t : teams) {
t.addSpieler(new Spieler("Spieler 1", t.getTeamID()));
t.addSpieler(new Spieler("Spieler 2", t.getTeamID()));
t.addSpieler(new Spieler("Spieler 3", t.getTeamID()));
t.addSpieler(new Spieler("Spieler 4", t.getTeamID()));
}
}
/*
* Initialisierungsmethode, um eine Anzahl von Teams mit 4 Spielern dem Turnier hinzuzufügen.
*
*@param anzahl Anzahl an Teams die hinzugefügt werden sollen
*/
private static void addTeamsFourPlayers(int anzahl) {
int nextId = 0;
if (teams.size() > 0) {
nextId = teams.get(teams.size() - 1).getTeamID();
}
nextId++;
for (int i = 0; i < anzahl; i++) {
teams.add(new Team(nextId));
nextId++;
}
for (int i = 0; i < anzahl; i++) {
teams.get(teams.size() - 1 - i).addSpieler(new Spieler("Spieler 1", teams.get(teams.size() - 1 - i).getTeamID()));
teams.get(teams.size() - 1 - i).addSpieler(new Spieler("Spieler 2", teams.get(teams.size() - 1 - i).getTeamID()));
teams.get(teams.size() - 1 - i).addSpieler(new Spieler("Spieler 3", teams.get(teams.size() - 1 - i).getTeamID()));
teams.get(teams.size() - 1 - i).addSpieler(new Spieler("Spieler 4", teams.get(teams.size() - 1 - i).getTeamID()));
}
}
/*
* Ausgabe der im Turnier vorhandenen Teams.
*
*/
private static void ausgabeTeams() {
for (Team t : teams) {
System.out.println("## Team " + t.getTeamID() + " (" + t.mainID + ") ##");
int i = 1;
for (Spieler s : t.getSpieler()) {
System.out.println(i + ". " + s.getName() + " - tID:" + s.getTeamnummer());
i++;
}
System.out.println("");
}
}
/*
* Ausgabe einer Liste mit Teams
*
*@param teams Liste der Teams, die ausgegeben werden sollen
*/
private static void ausgabeTeams(List<Team> teams) {
for (Team t : teams) {
System.out.println("## Team " + t.getTeamID() + " (" + t.mainID + ") ##");
int i = 1;
for (Spieler s : t.getSpieler()) {
System.out.println(i + ". " + s.getName() + " - tID:" + s.getTeamnummer());
i++;
}
System.out.println("");
}
}
/*
* Ausgabe der ersten Spielrunde
*/
private static void ausgabe1() {
System.out.println("Runde1");
for (Tisch t : desksRound1) {
System.out.println("## Tisch " + t.getTischnummer() + " ##");
int i = 1;
for (Spieler s : t.getSpieler()) {
System.out.println(i + ". " + s.getName() + " - tID:" + s.getTeamnummer());
i++;
}
System.out.println("");
}
}
/*
* Ausgabe der ersten Spielrunde
*/
private static void ausgabe2() {
System.out.println("Runde2");
for (Tisch t : desksRound2) {
System.out.println("## Tisch " + t.getTischnummer() + " ##");
int i = 1;
for (Spieler s : t.getSpieler()) {
System.out.println(i + ". " + s.getName() + " - tID:" + s.getTeamnummer());
i++;
}
System.out.println("");
}
}
}
Java:
package rundengenerierenteilen;
public class Spieler {
int id; //Datenbank
public String name = "";
int teamnummer = -1;
int punkte1 = 0, punkte2 = 0, gesamtpunkte = 0, outs1 = 0, outs2 = 0, einzelPunkte = 0, einzelOuts = 0;
private int tischnummerRunde1;
private int tischnummerRunde2;
public Spieler(String name, int teamnummer, int id) {
this.name = name;
this.id = id;
this.teamnummer = teamnummer;
}
public Spieler(String name, int teamnummer) {
this.name = name;
this.teamnummer = teamnummer;
}
public Spieler(String name) {
this.name = name;
}
public Spieler() {
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getTeamnummer() {
return teamnummer;
}
public void setTeamnummer(int teamnummer) {
this.teamnummer = teamnummer;
}
public int getOuts1() {
return outs1;
}
public int getOutsEinzel() {
return einzelOuts;
}
public int getPunkteEinzel() {
return einzelPunkte;
}
public void setOuts1(int outs) {
this.outs1 = outs;
}
public void setOutsEinzel(int outs) {
this.einzelOuts = outs;
}
public void setPunkteEinzel(int punkte) {
this.einzelPunkte = punkte;
}
public int getOuts2() {
return outs2;
}
public void setOuts2(int outs) {
this.outs2 = outs;
}
public int getPunkte1() {
return punkte1;
}
public void setPunkte1(int punkte1) {
this.punkte1 = punkte1;
}
public int getPunkte2() {
return punkte2;
}
public void setPunkte2(int punkte2) {
this.punkte2 = punkte2;
}
public void setGesamtpunkte(int punkte) {
this.gesamtpunkte = punkte;
}
public int getGesamtpunkte() {
return (this.punkte1 + this.punkte2);
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public int getTischnummerRunde1() {
return tischnummerRunde1;
}
public void setTischnummerRunde1(int tischnummerRunde1) {
this.tischnummerRunde1 = tischnummerRunde1;
}
public int getTischnummerRunde2() {
return tischnummerRunde2;
}
public void setTischnummerRunde2(int tischnummerRunde2) {
this.tischnummerRunde2 = tischnummerRunde2;
}
}
Java:
package rundengenerierenteilen;
import java.util.ArrayList;
public class Team {
int teamID; //Datenbank
public int mainID; // ID des Hauptteams, wichtig für 4/8er mit Teams teilen!!
int teamnummer; //Benutzer
String teamname, abkz;
int punkte1 = 0, punkte2 = 0, outs1 = 0, outs2 = 0;
ArrayList<Spieler> spieler;
public Team(String teamname, int teamnummer)
{
this.teamname = teamname;
this.teamnummer = teamnummer;
spieler = new ArrayList<Spieler>();
}
public Team(int teamnummer)
{
spieler = new ArrayList<Spieler>();
this.teamnummer = teamnummer;
}
public Team(int teamnummer, String teamname, ArrayList<Spieler> spieler)
{
this.teamnummer = teamnummer;
this.teamname = teamname;
this.spieler = new ArrayList<Spieler>();
this.spieler.addAll(spieler);
}
public Team()
{
spieler = new ArrayList<Spieler>();
}
public Team(int id, int mainID){
this.teamnummer = id;
this.mainID = mainID;
this.spieler = new ArrayList<>();
}
public Team(int teamnummer, String teamname, int mainID, ArrayList<Spieler> list)
{
this.teamnummer = teamnummer;
this.teamname = teamname;
this.mainID = mainID;
this.spieler = new ArrayList<Spieler>();
spieler.addAll(list);
}
public int getTeamID()
{
return teamnummer;
}
public void setTeamID(int teamnummer)
{
this.teamID = teamnummer;
}
public void setTeamnummer(int teamnummer)
{
this.teamnummer = teamnummer;
}
public int getMainID(){return this.mainID;}
public void setMainID(int m){this.mainID = m;}
public String getTeamname()
{
return teamname;
}
public void setTeamname(String teamname)
{
this.teamname = teamname;
}
public String getAbkz()
{
return abkz;
}
public void setAbkz(String abkz)
{
this.abkz = abkz;
}
public int getPunkte1()
{
return punkte1;
}
public void addSpieler(Spieler spieler)
{
this.spieler.add(spieler);
}
public void setPunkte1(int punkte1)
{
this.punkte1 = punkte1;
}
public int getPunkte2()
{
return punkte2;
}
public void setPunkte2(int punkte2)
{
this.punkte2 = punkte2;
}
public int getGesamtpunkte()
{
return (this.punkte1 + this.punkte2);
}
public int getOuts1() { return this.outs1; }
public int getOuts2() { return this.outs2; }
public int getOutsGesamt() { return (outs1 + outs2); }
public void setOuts1(int anzahl) { this.outs1 = anzahl; }
public void setOuts2(int anzahl) { this.outs2 = anzahl; }
public ArrayList<Spieler> getSpieler()
{
return spieler;
}
public void setSpieler(ArrayList<Spieler> spieler)
{
this.spieler = spieler;
}
}
Java:
package rundengenerierenteilen;
import java.util.ArrayList;
public class Tisch {
private int tischnummer;
private ArrayList<Spieler> spieler;
private ArrayList<Spieler> spielerRunde2;
private ArrayList<Integer> vorhandeneTeams;
public Tisch(int pT, ArrayList<Spieler> spieler)
{
vorhandeneTeams = new ArrayList<Integer>();
spieler = new ArrayList<Spieler>();
spieler.addAll(spieler);
spielerRunde2 = new ArrayList<Spieler>();
this.tischnummer = pT;
}
public Tisch(int pT)
{
vorhandeneTeams = new ArrayList<Integer>();
spieler = new ArrayList<Spieler>();
spielerRunde2 = new ArrayList<Spieler>();
this.tischnummer = pT;
}
public int getTischnummer()
{
return tischnummer;
}
public void add(Spieler sp)
{
vorhandeneTeams.add(sp.getTeamnummer());
spieler.add(sp);
}
public void add2(Spieler sp)
{
vorhandeneTeams.add(sp.getTeamnummer());
spielerRunde2.add(sp);
}
public ArrayList<Spieler> getSpieler()
{
return spieler;
}
}
