Merge remote-tracking branch 'refs/remotes/origin/master' into Ast
Update des Branches erfolgt, um das Debugging zu erleichtern.master
@ -1,14 +1,17 @@
|
||||
// Place your settings in this file to overwrite default and user settings.
|
||||
{
|
||||
"files.exclude": {
|
||||
// IDE Einstellungen
|
||||
"**/.git": true,
|
||||
"**/.DS_Store": true,
|
||||
"**/.vscode": true,
|
||||
// Greenfoot Dateien
|
||||
"project.greenfoot": true,
|
||||
"*.class": true,
|
||||
"*.ctxt": true,
|
||||
"project.greenfoot": true,
|
||||
"**/.vscode": true,
|
||||
"*.ods": true,
|
||||
"*.xls": true,
|
||||
"*.xlsx": true
|
||||
// Excel Tabellen
|
||||
"**/*.ods": true,
|
||||
"**/*.xls": true,
|
||||
"**/*.xlsx": true
|
||||
}
|
||||
}
|
@ -0,0 +1,95 @@
|
||||
import greenfoot.*; // (World, Actor, GreenfootImage, Greenfoot and MouseInfo)
|
||||
import greenfoot.MouseInfo.*;
|
||||
import javax.swing.JOptionPane;
|
||||
|
||||
/**
|
||||
* Schubst Einheiten umher.
|
||||
*
|
||||
* @author MaxiJohl, GruenerWal
|
||||
* @version 0.3.0
|
||||
*/
|
||||
|
||||
public class ArmySchubser extends Map_World
|
||||
{
|
||||
static Province savedProvince = null;
|
||||
|
||||
/**
|
||||
* Konstruktor für ArmySchubser.
|
||||
*
|
||||
* NICHT BENUTZEN!
|
||||
* Sämtliche benötigten Methoden sind static!
|
||||
*/
|
||||
public ArmySchubser(String[] playerList, int[] colorList)
|
||||
{
|
||||
super(playerList,colorList);
|
||||
}
|
||||
|
||||
/**
|
||||
* Nimmt zwei Provinzen entgegen, und fragt, wieviele Einheiten vom ersten zum zweiten Eintrag verschoben werden sollen.
|
||||
* Überprüft, ob eine Verschiebung möglich ist und führt sie bei Erfolg aus.
|
||||
*/
|
||||
public static void moveEntities(Province sourceProvince, Province destinationProvince)
|
||||
{
|
||||
String toMoveString = JOptionPane.showInputDialog(null, "Wieviele Einheiten willst du verschieben?");
|
||||
Integer entitiesToMove = Integer.valueOf(toMoveString);
|
||||
|
||||
if ( (sourceProvince.getEntityCount() - entitiesToMove) > 0)
|
||||
{
|
||||
sourceProvince.removeFromEntities(entitiesToMove);
|
||||
destinationProvince.addToEntities(entitiesToMove);
|
||||
}
|
||||
|
||||
if ( (sourceProvince.getEntityCount() - entitiesToMove) <= 0 )
|
||||
{
|
||||
JOptionPane.showMessageDialog(null,"Du hast nicht genügend Einheiten, um die gewünschte Anzahl von " + sourceProvince.getDisplayName() + " nach " + destinationProvince.getDisplayName() + " zu verschieben, Köhler.");
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Speichert ein gegebene Provinz als savedProvince ein, insofern dieser Platz nicht bereits belegt ist.
|
||||
* Ist er das, so wird überprüft, ob eine neue, an savedProvince angrenzende Provinz angeklickt wurde.
|
||||
* Ist dies der Fall, werden beide Provinzen an moveEntities übergeben.
|
||||
*/
|
||||
public static void useProvincesToMove(Province givenProvince)
|
||||
{
|
||||
if (savedProvince == null)
|
||||
{
|
||||
savedProvince = givenProvince;
|
||||
}
|
||||
|
||||
if (savedProvince != null && givenProvince != savedProvince)
|
||||
{
|
||||
if (givenProvince.isProvinceNear(savedProvince.getID()) == true)
|
||||
{
|
||||
moveEntities(savedProvince,givenProvince);
|
||||
}
|
||||
|
||||
else
|
||||
{
|
||||
savedProvince = null;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Überprüft, ob eine Provinz angeklickt wurde.
|
||||
* Wenn ja, wird diese als clickedProvince eingespeichert und useProvincesToMove aufgerufen.
|
||||
*
|
||||
* Kommt nachher in die GeneralMap!
|
||||
*/
|
||||
public void act()
|
||||
{
|
||||
Province clickedProvince = null;
|
||||
|
||||
for ( int i = 1; i <= provinceCount; i++)
|
||||
{
|
||||
if (provinces[i].hasClicked() == true)
|
||||
{
|
||||
clickedProvince = provinces[i];
|
||||
useProvincesToMove(clickedProvince);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -1,19 +1,166 @@
|
||||
import greenfoot.*; // (World, Actor, GreenfootImage, Greenfoot and MouseInfo)
|
||||
import java.awt.Color;
|
||||
|
||||
/**
|
||||
* Write a description of class Menue_Button here.
|
||||
*
|
||||
* @author (your name)
|
||||
* @version (a version number or a date)
|
||||
*/
|
||||
public class Button extends GUI_Interface
|
||||
{
|
||||
/**
|
||||
* Act - do whatever the Menue_Button wants to do. This method is called whenever
|
||||
* the 'Act' or 'Run' button gets pressed in the environment.
|
||||
*/
|
||||
public void act()
|
||||
{
|
||||
// Add your action code here.
|
||||
}
|
||||
Diese Klasse stellt einen Button dar.
|
||||
Als funktionelles Vorbild dafür hält der Button aus dem .NET-Framework für UWP-Apps dar.
|
||||
|
||||
@author Felix Stupp
|
||||
@version 20.05.2016
|
||||
*/
|
||||
public class Button extends GUI_Interface {
|
||||
|
||||
private boolean autoSize = false;
|
||||
private int textSize = 32; // as default text size
|
||||
private String text = "";
|
||||
|
||||
private ButtonEvent handler;
|
||||
|
||||
/**
|
||||
Erstellt einen Button mit dem gegebenen Text und der zugehörigen Textgröße.
|
||||
@param txt Der Text, den der Button darstellen soll.
|
||||
@param size Die Textgröße, in der der Button den Text darstellen soll.
|
||||
*/
|
||||
public Button(String txt, int size) {
|
||||
text = txt;
|
||||
textSize = size;
|
||||
redraw();
|
||||
}
|
||||
/**
|
||||
Erstellt einen Button mit dem gegebenen Objekt als Event-Handler.
|
||||
@param h Der Handler mit dem Interface ButtonEvent implementiert.
|
||||
*/
|
||||
public Button(ButtonEvent h) {
|
||||
handler = h;
|
||||
redraw();
|
||||
}
|
||||
/**
|
||||
Erstellt einen Button mit dem gegebenen Text, der zugehörigen Textgröße und dem gegebenen Objekt als Event-Handler.
|
||||
@param txt Der Text, den der Button darstellen soll.
|
||||
@param size Die Textgröße, in der der Button den Text darstellen soll.
|
||||
@param h Der Handler mit dem Interface ButtonEvent implementiert.
|
||||
*/
|
||||
public Button(String txt, int size, ButtonEvent h) {
|
||||
text = txt;
|
||||
textSize = size;
|
||||
handler = h;
|
||||
redraw();
|
||||
}
|
||||
|
||||
/**
|
||||
Fragt ab, ob ein Klick auf den Button gekommen ist.
|
||||
Wird intern von Greenfoot benötigt.
|
||||
*/
|
||||
public void act() {
|
||||
if(Greenfoot.mouseClicked(this) && handler != this) {
|
||||
handler.buttonClicked(this);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
Gibt zurück, ob die Größe des Buttons von dem Text bestimmt werden soll.
|
||||
@return Wert der AutoSize-Eigenschaft
|
||||
*/
|
||||
public boolean getAutoSize() {
|
||||
return autoSize;
|
||||
}
|
||||
/**
|
||||
Legt fest, ob die Größe des Buttons von dem Text bestimmt werden soll.
|
||||
Wird der Wert auf TRUE geändert, erfolgt automatisch ein Redraw des Objekts.
|
||||
@param b Der neue Wert der AutoSize-Eigenschaft.
|
||||
*/
|
||||
public void setAutoSize(boolean b) {
|
||||
autoSize = b;
|
||||
if(autoSize) {
|
||||
redraw();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
Gibt die aktelle Textgröße zurück.
|
||||
@return Aktuelle Textgröße
|
||||
*/
|
||||
public int getTextSize() {
|
||||
return textSize;
|
||||
}
|
||||
/**
|
||||
Legt eine neue Textgröße fest.
|
||||
@param s Neue Textgröße
|
||||
@return Gibt an, ob sich die Textgröße geändert hat. Bei TRUE erfolgte bereits ein Redraw.
|
||||
*/
|
||||
public boolean setTextSize(int s) {
|
||||
if(textSize != s && s > 0) {
|
||||
textSize = s;
|
||||
redraw();
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
Gibt den aktuellen Text zurück.
|
||||
@return Der aktuelle Text
|
||||
*/
|
||||
public String getText() {
|
||||
return text;
|
||||
}
|
||||
/**
|
||||
Setzt den darzustellenden Text auf den neuen Wert.
|
||||
@param s Der neue Text
|
||||
@return Gibt an, ob sich der Text geändert hat. Bei TRUE erfolgte bereits ein Redraw.
|
||||
*/
|
||||
public boolean setText(String s) {
|
||||
if(text != s) {
|
||||
text = s;
|
||||
redraw();
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
Gibt den aktuellen EventHandler des Buttons zurück.
|
||||
@return Der Handler als ButtonEvent
|
||||
*/
|
||||
public ButtonEvent getHandler() {
|
||||
return handler;
|
||||
}
|
||||
/**
|
||||
Setzt den EventHandler auf ein neues Objekt.
|
||||
@param h Der Handler mit implementiertem ButtonEvent-Interface
|
||||
*/
|
||||
public void setHandler(ButtonEvent h) {
|
||||
handler = h;
|
||||
}
|
||||
/**
|
||||
Entfernt den aktuellen EventHandler, um die Ausführung zukünftiger Events zu verhindern.
|
||||
*/
|
||||
public void removeHandler() {
|
||||
handler = null;
|
||||
}
|
||||
|
||||
/**
|
||||
Zeichnet das GreenfootImage des Buttons erneut und zeigt es an.
|
||||
*/
|
||||
public void redraw() {
|
||||
GreenfootImage tI = new GreenfootImage(text,textSize,foreC,backC);
|
||||
if(autoSize) {
|
||||
sx = tI.getWidth() + (6 * 2) + 4;
|
||||
sy = tI.getHeight() + (6 * 2) + 4;
|
||||
}
|
||||
GreenfootImage all = new GreenfootImage(sx,sy);
|
||||
Color gray = new Color(133,133,133,255);
|
||||
Color black = new Color(0,0,0,255);
|
||||
Color trans = new Color(0,0,0,0);
|
||||
Utils.drawInsideRectangle(all,gray,0);
|
||||
Utils.drawInsideRectangle(all,black,2);
|
||||
Utils.drawInsideRectangle(all,gray,6);
|
||||
Utils.drawInsideRectangle(all,black,7);
|
||||
all.setColorAt(0,0,trans);
|
||||
all.setColorAt(sx-1,0,trans);
|
||||
all.setColorAt(0,sy-1,trans);
|
||||
all.setColorAt(sx-1,sy-1,trans);
|
||||
all.drawImage(tI,(sx-tI.getWidth())/2,(sy-tI.getHeight())/2);
|
||||
setImage(all);
|
||||
}
|
||||
}
|
||||
|
@ -0,0 +1,14 @@
|
||||
import greenfoot.*;
|
||||
|
||||
/**
|
||||
* Dieses Interface stellt einen Zugriff auf Methoden für die Eventverarbeitung bei Buttons.
|
||||
* Jede Klasse, die als Event-Handler dienen will, muss dieses Interface implementieren.
|
||||
*
|
||||
* @author Felix Stupp
|
||||
* @version 26.04.2016
|
||||
*/
|
||||
public interface ButtonEvent {
|
||||
|
||||
public void buttonClicked(Button obj);
|
||||
|
||||
}
|
@ -1,38 +0,0 @@
|
||||
import greenfoot.*; // (World, Actor, GreenfootImage, Greenfoot and MouseInfo)
|
||||
|
||||
/**
|
||||
* Write a description of class CurrentPlayerArrow here.
|
||||
*
|
||||
* @author (your name)
|
||||
* @version (a version number or a date)
|
||||
*/
|
||||
public class CurrentPlayerArrow extends GUI_Interface
|
||||
{
|
||||
/**
|
||||
* Act - do whatever the CurrentPlayerArrow wants to do. This method is called whenever
|
||||
* the 'Act' or 'Run' button gets pressed in the environment.
|
||||
*/
|
||||
public void act()
|
||||
{
|
||||
// Add your action code here.
|
||||
}
|
||||
|
||||
public void CurrentPlayerArrow(int currentPlayer, int playerNumber)
|
||||
{
|
||||
switch (currentPlayer) {
|
||||
case 1 :
|
||||
setLocation(120,100);
|
||||
break;
|
||||
case 2 :
|
||||
setLocation(120,100 + (825 / playerNumber));
|
||||
break;
|
||||
case 3 :
|
||||
setLocation(120,100 + (825 / playerNumber)*2);
|
||||
break;
|
||||
case 4 :
|
||||
setLocation(120,100 + (825 / playerNumber)*3);
|
||||
break;
|
||||
|
||||
}
|
||||
}
|
||||
}
|
@ -0,0 +1,17 @@
|
||||
import greenfoot.*;
|
||||
import java.util.Arrays; // (World, Actor, GreenfootImage, Greenfoot and MouseInfo)
|
||||
import java.awt.Color;
|
||||
|
||||
/**
|
||||
Erstellt eine gegebene Anzahl an DefenderDice's, welche dann nebeneinander eingereiht werden.
|
||||
|
||||
@author Felix Stupp
|
||||
@version 15.06.2016
|
||||
*/
|
||||
public class DefenderDices extends DicesList {
|
||||
|
||||
public DefenderDices(int count) {
|
||||
super(count, 2, new Color(0,0,0), (new Color(255,255,255)));
|
||||
}
|
||||
|
||||
}
|
@ -1,19 +1,89 @@
|
||||
import greenfoot.*; // (World, Actor, GreenfootImage, Greenfoot and MouseInfo)
|
||||
|
||||
/**
|
||||
* Write a description of class Dice here.
|
||||
*
|
||||
* @author (your name)
|
||||
* @version (a version number or a date)
|
||||
Stellt einen Würfel (von 1-6) dar, welcher in der Welt sichtbar dargestellt werden soll.
|
||||
|
||||
@author Felix Stupp
|
||||
@version 13.06.2016
|
||||
*/
|
||||
public class Dice extends Actor
|
||||
{
|
||||
/**
|
||||
* Act - do whatever the Dice wants to do. This method is called whenever
|
||||
* the 'Act' or 'Run' button gets pressed in the environment.
|
||||
*/
|
||||
public void act()
|
||||
{
|
||||
// Add your action code here.
|
||||
}
|
||||
}
|
||||
public class Dice extends GUI_Interface {
|
||||
|
||||
private int number = 0;
|
||||
|
||||
/**
|
||||
Erstellt einen Würfel mit dem Startwert 0 (für noch nicht verwendet).
|
||||
*/
|
||||
public Dice() {
|
||||
redraw();
|
||||
}
|
||||
|
||||
/**
|
||||
Erstellt einen Würfel mit einem bestimmten Startwert, welcher sofort sichtbar ist.
|
||||
*/
|
||||
public Dice(int startNumber) {
|
||||
number = startNumber;
|
||||
redraw();
|
||||
}
|
||||
|
||||
/**
|
||||
Gibt die aktuelle Zahl, die der Würfel anzeigt, aus. Gibt die Methode 0 zurück, heißt dies, dass der Würfel noch nicht gewürfelt wurde.
|
||||
@return Die aktuelle Augenzahl oder 0
|
||||
*/
|
||||
public int getNumber() {
|
||||
return number;
|
||||
}
|
||||
|
||||
/**
|
||||
Legt die Größe des Würfels als Quadrat fest.
|
||||
*/
|
||||
public void setSizeAsSquare(int l) {
|
||||
setSize(l,l);
|
||||
}
|
||||
|
||||
/**
|
||||
Würfelt den Würfel, erneuert die Darstellung und gibt die neue Augenzahl zurück.
|
||||
*/
|
||||
public int roll() {
|
||||
number = (int) (Math.floor(Math.random()*6)+1);
|
||||
redraw();
|
||||
return number;
|
||||
}
|
||||
|
||||
/**
|
||||
Zeichnet auf dem gegebenen GreenfootImage ein Oval an der gegebenen Stelle multipliziert mit der einheitlichen Größe.
|
||||
*/
|
||||
private void fO(GreenfootImage i, int eX, int eY, int x, int y) {
|
||||
i.fillOval(eX*x,eY*y,eX*2,eY*2);
|
||||
}
|
||||
|
||||
/**
|
||||
Erneuert die Darstellung des Würfels.
|
||||
*/
|
||||
public void redraw() {
|
||||
// einheitliche Größe X und Y (ein Vierzehntel der gesamten Breite und Höhe)
|
||||
int eX = (int) Math.round(sx/8);
|
||||
int eY = (int) Math.round(sy/8);
|
||||
// Vereinfachung für die Augenzahl
|
||||
int a = number;
|
||||
GreenfootImage i = new GreenfootImage(sx,sy);
|
||||
i.setColor(new java.awt.Color(0,0,0,0));
|
||||
i.clear();
|
||||
i.setColor(backC);
|
||||
i.fillShape(new java.awt.geom.RoundRectangle2D.Double(0,0,sx,sy,eX,eY));
|
||||
i.setColor(foreC);
|
||||
// das "else" fehlt absichtlich
|
||||
if(a==1||a==3||a==5) { //Mittlerer Punkt
|
||||
fO(i,eX,eY,3,3);
|
||||
} if(a>1) { //Punkte links-oben und rechts-unten
|
||||
fO(i,eX,eY,1,1);
|
||||
fO(i,eX,eY,5,5);
|
||||
} if(a>3) { //Punkte links-unten und rechts-oben
|
||||
fO(i,eX,eY,1,5);
|
||||
fO(i,eX,eY,5,1);
|
||||
} if(a>5) { //Punkte links-mitte und rechts-mitte
|
||||
fO(i,eX,eY,1,3);
|
||||
fO(i,eX,eY,5,3);
|
||||
}
|
||||
setImage(i);
|
||||
}
|
||||
}
|
@ -0,0 +1,63 @@
|
||||
import greenfoot.*;
|
||||
|
||||
/**
|
||||
Erstellt eine gegebene Anzahl an Dices's, welche dann nebeneinander eingereiht werden.
|
||||
|
||||
@author Felix Stupp
|
||||
@version 15.06.2016
|
||||
*/
|
||||
public abstract class DicesList extends Actor {
|
||||
|
||||
private final static int SQUARESIZE = 100; // Anpassbar
|
||||
private Dice[] dices;
|
||||
|
||||
public DicesList(int count, int max, java.awt.Color bC, java.awt.Color fC) {
|
||||
setImage(new GreenfootImage(2,2));
|
||||
if(count < 1) {
|
||||
count = 1;
|
||||
} else if (count > max) {
|
||||
count = max;
|
||||
}
|
||||
for(int i = 1; i < count; i++) {
|
||||
Dice d = new Dice();
|
||||
d.setBackColor(bC);
|
||||
d.setForeColor(fC);
|
||||
d.setSizeAsSquare(SQUARESIZE);
|
||||
dices[i] = d;
|
||||
}
|
||||
}
|
||||
|
||||
protected void addedToWorld(World w) {
|
||||
for(int i = 0; i < dices.length; i++) {
|
||||
w.addObject(dices[i],getX()+(SQUARESIZE*(6/5)*i),getY());
|
||||
}
|
||||
//w.removeObject(this); // Zeile auskommentieren, wenn die Debug-Phase vorbei ist.
|
||||
}
|
||||
|
||||
public int[] getNumbers() {
|
||||
int[] n = new int[dices.length];
|
||||
for(int i = 0; i < dices.length; i++) {
|
||||
n[i] = dices[i].getNumber();
|
||||
}
|
||||
Utils.sortDesc(n);
|
||||
return n;
|
||||
}
|
||||
|
||||
public int[] roll() {
|
||||
int[] n = new int[dices.length];
|
||||
for(int i = 0; i < dices.length; i++) {
|
||||
n[i] = dices[i].roll();
|
||||
}
|
||||
Utils.sortDesc(n);
|
||||
return n;
|
||||
}
|
||||
|
||||
public void removeAll() {
|
||||
for(int i = 0; i < dices.length; i++) {
|
||||
dices[i].getWorld().removeObject(dices[i]);
|
||||
}
|
||||
getWorld().removeObject(this);
|
||||
dices = new Dice[0];
|
||||
}
|
||||
|
||||
}
|
@ -1,19 +1,106 @@
|
||||
import greenfoot.*; // (World, Actor, GreenfootImage, Greenfoot and MouseInfo)
|
||||
import java.awt.Color;
|
||||
|
||||
/**
|
||||
* Write a description of class GUI_Interface here.
|
||||
*
|
||||
* @author (your name)
|
||||
* @version (a version number or a date)
|
||||
*/
|
||||
public class GUI_Interface extends Actor
|
||||
Oberklasse für sämtliche GUI Objekte, wie Labels und Buttons
|
||||
|
||||
@author Felix Stupp
|
||||
@version 04.06.2016
|
||||
*/
|
||||
public abstract class GUI_Interface extends Actor
|
||||
{
|
||||
/**
|
||||
* Act - do whatever the GUI_Interface wants to do. This method is called whenever
|
||||
* the 'Act' or 'Run' button gets pressed in the environment.
|
||||
*/
|
||||
public void act()
|
||||
{
|
||||
// Add your action code here.
|
||||
}
|
||||
/**
|
||||
Die Breite des Objektes
|
||||
*/
|
||||
protected int sx = 20;
|
||||
/**
|
||||
Die Höhe des Objektes
|
||||
*/
|
||||
protected int sy = 20;
|
||||
/**
|
||||
Die Hintergrundfarbe des Objektes
|
||||
*/
|
||||
protected Color backC = Color.BLACK;
|
||||
/**
|
||||
Die Vordergrundfarbe (meist die Textfarbe) des Objektes
|
||||
*/
|
||||
protected Color foreC = Color.WHITE;
|
||||
|
||||
/**
|
||||
Gibt die Breite des Objektes zurück.
|
||||
@return Die aktuelle Breite
|
||||
*/
|
||||
public int getWidth() {
|
||||
return sx;
|
||||
}
|
||||
/**
|
||||
Gibt die Höhe des Objektes zurück.
|
||||
@return Die aktuelle Höhe
|
||||
*/
|
||||
public int getHeight() {
|
||||
return sy;
|
||||
}
|
||||
/**
|
||||
Legt die Größe des Objektes neu fest und zeichnet es danach damit neu.
|
||||
Je nach Objekttyp kann diese Größe wieder vom Objekt selbst angepasst werden, falls nötig.
|
||||
@param w Die neue Breite
|
||||
@param h Die neue Höhe
|
||||
*/
|
||||
public void setSize(int w, int h) {
|
||||
if(w < 1 || h < 1) {
|
||||
return;
|
||||
}
|
||||
sx = w;
|
||||
sy = h;
|
||||
redraw();
|
||||
}
|
||||
|
||||
/**
|
||||
Gibt die aktuelle Hintergrundfarbe des Objektes zurück.
|
||||
@return Die aktuelle Hintergrundfarbe als System.awt.Color
|
||||
*/
|
||||
public Color getBackColor() {
|
||||
return backC;
|
||||
}
|
||||
/**
|
||||
Legt die Hintergrundfarbe des Objektes fest.
|
||||
@param c Die neue Hintergrundfarbe als System.awt.Color
|
||||
@return Gibt an, ob diese Farbe unterschiedlich zur bisherig genutzten Farbe wahr. Bei TRUE erfolgte bereits ein Redraw.
|
||||
*/
|
||||
public boolean setBackColor(Color c) {
|
||||
if(!c.equals(backC)) {
|
||||
backC = c;
|
||||
redraw();
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
Gibt die aktuelle Vordergrundfarbe (meist die Textfarbe) des Objektes zurück.
|
||||
@return Die aktuelle Vordergrundfarbe als System.awt.Color
|
||||
*/
|
||||
public Color getForeColor() {
|
||||
return foreC;
|
||||
}
|
||||
/**
|
||||
Legt die Vordergrundfarbe (meist die Textfarbe) des Objektes fest.
|
||||
@param c Die neue Vordergrundfarbe als System.awt.Color
|
||||
@return Gibt an, ob diese Farbe unterschiedlich zur bisherig genutzten Farbe wahr. Bei TRUE erfolgte bereits ein Redraw.
|
||||
*/
|
||||
public boolean setForeColor(Color c) {
|
||||
if(!c.equals(foreC)) {
|
||||
foreC = c;
|
||||
redraw();
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
public void act() {}
|
||||
|
||||
/**
|
||||
Diese Funktion soll die erneute Zeichnung des Objekts erzwingen und wird daher auch von (fast) allen set-Methoden aufgerufen, sollte der neue Wert sich von dem alten unterscheiden.
|
||||
*/
|
||||
public abstract void redraw();
|
||||
}
|
||||
|
@ -1,104 +1,134 @@
|
||||
import greenfoot.*; // (World, Actor, GreenfootImage, Greenfoot and MouseInfo)
|
||||
|
||||
/**
|
||||
* Oberklasse für verschiedene Maps;
|
||||
* neue Maps werden als Unterklasse dieser Klasse eingefügt.
|
||||
*
|
||||
* @author GruenerWal, MaxiJohl
|
||||
* @version 0.2.0
|
||||
*/
|
||||
public class GeneralMap extends World
|
||||
{
|
||||
/**
|
||||
* Felder, im Moment nur Anzahl der Provinzen
|
||||
* Später evtl. weitere Werte wie Schwierigkeit denkbar
|
||||
*/
|
||||
|
||||
protected int provinzen;
|
||||
|
||||
/** Konstruktor für nicht weiter definierte Map, sollte im Moment nicht benutzt werden.
|
||||
* Später als Konstruktor für Default-Map denkbar.
|
||||
*/
|
||||
public GeneralMap(int x, int y, int p)
|
||||
{
|
||||
/**
|
||||
* Erstellt eine leere Karte mit den übergebenen Eigenschaften
|
||||
* @param x X-Ausdehnung der Welt
|
||||
* @param y Y-Ausdehnung
|
||||
* @param p Kantenlänge der Felder in Pixeln
|
||||
*/
|
||||
super(1600, 900, 1);
|
||||
addObject(new Menue_Button(),100,38);
|
||||
addObject(new Roll_Button(),84,835);
|
||||
addObject(new Roll_Button(),1513,835);
|
||||
}
|
||||
|
||||
static GeneralMap generateMap(int mapID)
|
||||
{
|
||||
//Platzhalter
|
||||
return null;
|
||||
}
|
||||
|
||||
int getPlayerCount()
|
||||
{
|
||||
//Platzhalter
|
||||
return 4;
|
||||
}
|
||||
|
||||
String getPlayerName()
|
||||
{
|
||||
//Platzhalter
|
||||
return null;
|
||||
}
|
||||
|
||||
String getPlayerName(int plID)
|
||||
{
|
||||
//Platzhalter
|
||||
return null;
|
||||
}
|
||||
|
||||
int getPlayerStars()
|
||||
{
|
||||
//Platzhalter
|
||||
return 0;
|
||||
}
|
||||
|
||||
int getProvinceOwner(int prID)
|
||||
{
|
||||
//Platzhalter
|
||||
return 0;
|
||||
}
|
||||
|
||||
int[] getProvinceOwners()
|
||||
{
|
||||
//Platzhalter; viel Arbeit :3
|
||||
int[] provinceOwners = new int[1];
|
||||
provinceOwners[0] = 0;
|
||||
return provinceOwners;
|
||||
}
|
||||
|
||||
int getProvinceEntityCount(int prID)
|
||||
{
|
||||
//Platzhalter
|
||||
return 0;
|
||||
}
|
||||
|
||||
int getProvincesEntityCounts(int[] prArr)
|
||||
{
|
||||
//Platzhalter
|
||||
return 0;
|
||||
}
|
||||
|
||||
int getProvincesEntityCounts(boolean[] prArr)
|
||||
{
|
||||
//Platzhalter
|
||||
return 0;
|
||||
}
|
||||
|
||||
int getProvincesEntityCounts(int plID)
|
||||
{
|
||||
//Platzhalter
|
||||
return 0;
|
||||
}
|
||||
|
||||
}
|
||||
import greenfoot.*; // (World, Actor, GreenfootImage, Greenfoot and MouseInfo)
|
||||
import java.lang.Math;
|
||||
|
||||
/**
|
||||
Oberklasse für verschiedene Maps;
|
||||
neue Maps werden als Unterklasse dieser Klasse eingefügt.
|
||||
|
||||
@author GruenerWal, MaxiJohl, Felix Stupp
|
||||
@version 0.3.0
|
||||
*/
|
||||
public abstract class GeneralMap extends World
|
||||
{
|
||||
/*
|
||||
Felder, im Moment nur Anzahl der Provinzen
|
||||
Später evtl. weitere Werte wie Schwierigkeit denkbar
|
||||
*/
|
||||
|
||||
private final int X_OFFSET = 0; // Verschiebt die Provinzen nach rechts
|
||||
private final int Y_OFFSET = 0; // Verschiebt die Provinzen nach unten
|
||||
|
||||
/*
|
||||
Die einzelnen Positionen der Provinzen wird mit SCALE_VALUE/10000 multipliziert.
|
||||
Dies ist nützlich, wenn die Karte beispielsweise nur noch 80% der Originalgröße bei ihrer Darstellung groß ist.
|
||||
Bei diesem Beispiel wäre hier, neben dem Offset oben, der Wert 0.8 einzutragen.
|
||||
*/
|
||||
private final double SCALE_VALUE = 1;
|
||||
|
||||
protected Province[] provinces;
|
||||
protected Player[] players;
|
||||
|
||||
protected int currentPlayer = 0;
|
||||
|
||||
/**
|
||||
Erstellt eine GeneralMap mit allen Eigenschaften und initialisiert die Arrays für Provinzen und Spieler.
|
||||
@param backImage Das Hintergrundbild, welches von dieser Klasse geladen und dargestellt wird.
|
||||
@param playerList Die Liste mit den Namen der Spieler
|
||||
@param colorList Die Liste mit den Farben der Spieler
|
||||
*/
|
||||
public GeneralMap(String backImage, String[] playerList, int[] colorList)
|
||||
{
|
||||
super(1600,900,1);
|
||||
players = new Player[playerList.length];
|
||||
for (int i = 0; i < playerList.length; i++) {
|
||||
players[i] = new Player(i,playerList[i],colorList[i]);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
Fügt alle Provinzen aus dem Array der Welt an der entsprechden Stelle zu.
|
||||
*/
|
||||
protected void initProvinces() {
|
||||
for(int i = 1; i < provinces.length; i++) {
|
||||
addObject(provinces[i],((int) Math.floor(provinces[i].getXPos() * SCALE_VALUE)) + X_OFFSET,((int) Math.floor(provinces[i].getYPos() * SCALE_VALUE)) + Y_OFFSET);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
Gibt die Anzahl der vorhandenen Spieler aus.
|
||||
*/
|
||||
public int getPlayerCount()
|
||||
{
|
||||
return players.length;
|
||||
}
|
||||
|
||||
/**
|
||||
Gibt den Namen des aktuellen Spielers aus.
|
||||
@return Der Name des aktuellen Spielers
|
||||
*/
|
||||
public String getPlayerName()
|
||||
{
|
||||
return players[currentPlayer].getDisplayName();
|
||||
}
|
||||
|
||||
/**
|
||||
Gibt den Namen des Spielers aus, dem dessen ID gehört.
|
||||
@param plID Die ID des zu findenden Spielers
|
||||
@return Der Name des Spielers
|
||||
*/
|
||||
public String getPlayerName(int plID)
|
||||
{
|
||||
return players[plID].getDisplayName();
|
||||
}
|
||||
|
||||
/**
|
||||
Gibt die Anzahl der Sterne des aktuellen Spielers zurück.
|
||||
@return Die Anzahl der Sterne des aktuellen Spielers
|
||||
*/
|
||||
public int getPlayerStars()
|
||||
{
|
||||
return players[currentPlayer].getStars();
|
||||
}
|
||||
|
||||
/**
|
||||
Gibt die ID des Spielers zurück, dem die gefragte Provinz gehört.
|
||||
@param prID Die gefragte Provinz
|
||||
*/
|
||||
public int getProvinceOwner(int prID)
|
||||
{
|
||||
if(prID < 1 || prID > provinces.length) {
|
||||
return -1;
|
||||
}
|
||||
return provinces[prID].getOwner();
|
||||
}
|
||||
|
||||
/**
|
||||
Gibt eine Liste mit allen Provinzen und deren Besitzern zurück.
|
||||
@return Array mit der Provinz-ID als Index und dem Besitzer als Wert
|
||||
*/
|
||||
public int[] getProvinceOwners()
|
||||
{
|
||||
int[] prOwners = new int[provinces.length];
|
||||
for (int i = 1; i > provinces.length; i++) {
|
||||
prOwners[i] = provinces[i].getOwner();
|
||||
}
|
||||
return prOwners;
|
||||
}
|
||||
|
||||
/**
|
||||
Zählt die Anzahl der Einheiten von allen Provinzen zusammen, die einem bestimmten Spieler gehört.
|
||||
@param playerID Die ID des Spielers, für den die Einheiten gezählt werden sollen.
|
||||
@return Die Anzahl der Einheiten, die dem Spieler gehören.
|
||||
*/
|
||||
public int getProvinceEntityCount(int playerID)
|
||||
{
|
||||
int c = 0;
|
||||
for (int i = 1; i > provinces.length; i++) {
|
||||
if(provinces[i].getOwner() == playerID) {
|
||||
c = c + provinces[i].getEntityCount();
|
||||
}
|
||||
}
|
||||
return c;
|
||||
}
|
||||
|
||||
}
|
||||
|
@ -0,0 +1,103 @@
|
||||
import greenfoot.*; // (World, Actor, GreenfootImage, Greenfoot and MouseInfo)
|
||||
import java.awt.Color;
|
||||
|
||||
/**
|
||||
Zeigt einen Text an.
|
||||
|
||||
@author Felix Stupp
|
||||
@version 13.05.2016
|
||||
*/
|
||||
public class Label extends GUI_Interface {
|
||||
|
||||
private boolean autoSize = true;
|
||||
private int textSize = 32; // as default text size
|
||||
private String text = "";
|
||||
|
||||
/**
|
||||
Erstellt ein neues Label mit dem gegebenen Text und der zugehörigen Textgröße.
|
||||
@param txt Der darzustellende Text
|
||||
@param size Die dazugehörige Textgröße
|
||||
*/
|
||||
public Label(String txt, int size) {
|
||||
text = txt;
|
||||
textSize = size;
|
||||
redraw();
|
||||
}
|
||||
|
||||
/**
|
||||
Gibt zurück, ob die Größe des Buttons von dem Text bestimmt werden soll.
|
||||
@return Wert der AutoSize-Eigenschaft
|
||||
*/
|
||||
public boolean getAutoSize() {
|
||||
return autoSize;
|
||||
}
|
||||
/**
|
||||
Legt fest, ob die Größe des Buttons von dem Text bestimmt werden soll.
|
||||
Wird der Wert auf TRUE geändert, erfolgt automatisch ein Redraw des Objekts.
|
||||
@param b Der neue Wert der AutoSize-Eigenschaft.
|
||||
*/
|
||||
public void setAutoSize(boolean b) {
|
||||
autoSize = b;
|
||||
if(autoSize) {
|
||||
redraw();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
Gibt die aktelle Textgröße zurück.
|
||||
@return Aktuelle Textgröße
|
||||
*/
|
||||
public int getTextSize() {
|
||||
return textSize;
|
||||
}
|
||||
/**
|
||||
Legt eine neue Textgröße fest.
|
||||
@param s Neue Textgröße
|
||||
@return Gibt an, ob sich die Textgröße geändert hat. Bei TRUE erfolgte bereits ein Redraw.
|
||||
*/
|
||||
public boolean setTextSize(int s) {
|
||||
if(textSize != s && s > 0) {
|
||||
textSize = s;
|
||||
redraw();
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
Gibt den aktuellen Text zurück.
|
||||
@return Der aktuelle Text
|
||||
*/
|
||||
public String getText() {
|
||||
return text;
|
||||
}
|
||||
/**
|
||||
Setzt den darzustellenden Text auf den neuen Wert.
|
||||
@param s Der neue Text
|
||||
@return Gibt an, ob sich der Text geändert hat. Bei TRUE erfolgte bereits ein Redraw.
|
||||
*/
|
||||
public boolean setText(String s) {
|
||||
if(text != s) {
|
||||
text = s;
|
||||
redraw();
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
Zeichnet das GreenfootImage des Labels erneut und zeigt es an.
|
||||
*/
|
||||
public void redraw() {
|
||||
GreenfootImage tI = new GreenfootImage(text,textSize,foreC,backC);
|
||||
if(autoSize) {
|
||||
sx = tI.getWidth();
|
||||
sy = tI.getHeight();
|
||||
}
|
||||
GreenfootImage all = new GreenfootImage(sx,sy);
|
||||
all.setColor(backC);
|
||||
all.fill();
|
||||
all.drawImage(tI,(sx-tI.getWidth())/2,(sy-tI.getHeight())/2);
|
||||
setImage(all);
|
||||
}
|
||||
}
|
@ -1,126 +1,108 @@
|
||||
import greenfoot.*; // (World, Actor, GreenfootImage, Greenfoot and MouseInfo)
|
||||
|
||||
/**
|
||||
* Klasse der Standard-Welt
|
||||
* (Also die normale Weltkarte mit allen Kontinenten)
|
||||
*
|
||||
* @author GruenerWal, MaxiJohl
|
||||
* @version 0.3.0
|
||||
Klasse der Standard-Welt
|
||||
(Also die normale Weltkarte mit allen Kontinenten)
|
||||
|
||||
@author GruenerWal, MaxiJohl
|
||||
@version 0.3.0
|
||||
*/
|
||||
|
||||
public class Map_World extends GeneralMap
|
||||
{
|
||||
/**
|
||||
* Anzahl der Provinzen.
|
||||
*/
|
||||
|
||||
int provinceCount = 42;
|
||||
/**
|
||||
Anzahl der Provinzen.
|
||||
*/
|
||||
|
||||
/**
|
||||
* Konstruktor der Weltkarte;
|
||||
* konstruiert eine GeneralMap mit den Ausmassen 1600 auf 900 Pixel.
|
||||
*/
|
||||
int provinceCount = 42;
|
||||
|
||||
public Map_World()
|
||||
{
|
||||
super();
|
||||
|
||||
Province[] provinces;
|
||||
/**
|
||||
Konstruktor der Weltkarte;
|
||||
konstruiert eine GeneralMap mit den Ausmassen 1600 auf 900 Pixel.
|
||||
*/
|
||||
|
||||
/**
|
||||
* Hier werden später sämtliche Provinzen der Standard-Map erstellt.
|
||||
* Dies funktioniert folgendermassen:
|
||||
* =================================================================
|
||||
*
|
||||
* VERALTETER KOMMENTAR VON GruenerWal:
|
||||
* Im Folgenden wird nun jede Provinz einzeln erstellt:
|
||||
* |---
|
||||
* nextProvinces = new int[<Anzahl angrenzende Provinzen>];
|
||||
* <Zuweisung der angrenzenden Provinzen>
|
||||
* provinces[<Provinz-ID>] = new Province(<Provinz-ID>,<Kontinent-ID>,<X-Position>,<Y-Position>,<Anzahl Sterne>,"<Anzeigename>",nextProvinces);
|
||||
* addObject(provinces[<Provinz-ID>],<x-Position>,<y-Position>);
|
||||
* ---|
|
||||
*
|
||||
* =================================================================
|
||||
*
|
||||
* NEUES FORMAT VON FELIX STUPP:
|
||||
* Dieses kürzere Format ersetzt den langen Code und sorgt eventuell sogar für einen Geschwindigkeitsschub. Dabei sollte diesselbe Funktionalität erhalten bleiben.
|
||||
*
|
||||
* provinces[<Provinz-ID>] = new Province(<Provinz-ID>,<Kontinent-ID>,<X-Position>,<Y-Position>,<Anzahl Sterne>,"<Anzeigename>", new int[] { <Liste aller Nachbarprovinzen> });
|
||||
*
|
||||
* =================================================================
|
||||
* Der Speicherplatz für provinces[0] bleibt leer, da es keine Provinz mit der ID 0 gibt!
|
||||
*
|
||||
* Und ja, ich weiss, dass das scheisse viel Schreibarbeit ist.
|
||||
* Aber da muss man durch, wir habens auch hinbekommen :P
|
||||
*
|
||||
* ~GruenerWal
|
||||
*/
|
||||
public Map_World(String[] playerList, int[] colorList)
|
||||
{
|
||||
super("",playerList,colorList);
|
||||
/*
|
||||
Hier werden später sämtliche Provinzen der Standard-Map erstellt.
|
||||
Dies funktioniert folgendermassen:
|
||||
=================================================================
|
||||
|
||||
Dieses kürzere Format ersetzt den langen Code und sorgt eventuell sogar für einen Geschwindigkeitsschub. Dabei sollte diesselbe Funktionalität erhalten bleiben.
|
||||
|
||||
provinces[<Provinz-ID>] = new Province(<Provinz-ID>,<Kontinent-ID>,<X-Position>,<Y-Position>,<Anzahl Sterne>,"<Anzeigename>", new int[] { <Liste aller Nachbarprovinzen> });
|
||||
|
||||
=================================================================
|
||||
Der Speicherplatz für provinces[0] bleibt leer, da es keine Provinz mit der ID 0 gibt!
|
||||
|
||||
Und ja, ich weiss, dass das scheisse viel Schreibarbeit ist.
|
||||
Aber da muss man durch, wir habens auch hinbekommen :P
|
||||
|
||||
~GruenerWal
|
||||
*/
|
||||
|
||||
// Festlegung der Provinz-Anzahl
|
||||
// Festlegung der Provinz-Anzahl
|
||||
|
||||
provinces = new Province[provinceCount + 1];
|
||||
provinces = new Province[provinceCount + 1];
|
||||
|
||||
// Implementierung sämtlicher Provinzen
|
||||
// ACHTUNG! Gaaaaanz viel Code!
|
||||
// Implementierung sämtlicher Provinzen
|
||||
// ACHTUNG! Gaaaaanz viel Code!
|
||||
|
||||
// cID 1 - Nordamerika
|
||||
provinces[1] = new Province( 1 , 1 , 64 , 106 , 1 , "Alaska" , new int[] {2 , 3 , 36});
|
||||
provinces[2] = new Province( 2 , 1 , 162 , 106 , 1 , "NW-Territorien" , new int[] {1 , 3 , 4 , 9});
|
||||
provinces[3] = new Province( 3 , 1 , 53 , 170 , 1 , "Alberta" , new int[] {1 , 2 , 4 , 5});
|
||||
provinces[4] = new Province( 4 , 1 , 223 , 177 , 2 , "Ontario" , new int[] {2 , 3 , 5 , 6 , 7 , 9});
|
||||
provinces[5] = new Province( 5 , 1 , 160 , 236 , 2 , "Weststaaten" , new int[] {3 , 4 , 6 , 8});
|
||||
provinces[6] = new Province( 6 , 1 , 232 , 273 , 2 , "Oststaaten" , new int[] {4 , 5 , 7 , 8});
|
||||
provinces[7] = new Province( 7 , 1 , 300 , 180 , 2 , "Quebec" , new int[] {4 , 6 , 9});
|
||||
provinces[8] = new Province( 8 , 1 , 181 , 347 , 1 , "Mittelamerika" , new int[] {5 , 6 , 17});
|
||||
provinces[9] = new Province( 9 , 1 , 365 , 55 , 1 , "Groenland" , new int[] {2 , 4 , 7 , 10});
|
||||
// cID 1 - Nordamerika
|
||||
provinces[1] = new Province( 1 , 1 , 64 , 106 , 1 , "Alaska" , new int[] {2 , 3 , 36});
|
||||
provinces[2] = new Province( 2 , 1 , 162 , 106 , 1 , "NW-Territorien" , new int[] {1 , 3 , 4 , 9});
|
||||
provinces[3] = new Province( 3 , 1 , 53 , 170 , 1 , "Alberta" , new int[] {1 , 2 , 4 , 5});
|
||||
provinces[4] = new Province( 4 , 1 , 223 , 177 , 2 , "Ontario" , new int[] {2 , 3 , 5 , 6 , 7 , 9});
|
||||
provinces[5] = new Province( 5 , 1 , 160 , 236 , 2 , "Weststaaten" , new int[] {3 , 4 , 6 , 8});
|
||||
provinces[6] = new Province( 6 , 1 , 232 , 273 , 2 , "Oststaaten" , new int[] {4 , 5 , 7 , 8});
|
||||
provinces[7] = new Province( 7 , 1 , 300 , 180 , 2 , "Quebec" , new int[] {4 , 6 , 9});
|
||||
provinces[8] = new Province( 8 , 1 , 181 , 347 , 1 , "Mittelamerika" , new int[] {5 , 6 , 17});
|
||||
provinces[9] = new Province( 9 , 1 , 365 , 55 , 1 , "Groenland" , new int[] {2 , 4 , 7 , 10});
|
||||
|
||||
// cID 2 - Europa
|
||||
provinces[10] = new Province(10 , 2 , 454 , 142 , 1 , "Island" , new int[] {9 , 11 , 12});
|
||||
provinces[11] = new Province(11 , 2 , 424 , 221 , 2 , "Grossbritannien" , new int[] {10 , 12 , 14 , 15});
|
||||
provinces[12] = new Province(12 , 2 , 520 , 153 , 1 , "Skandinavien" , new int[] {10 , 11 , 13 , 14});
|
||||
provinces[13] = new Province(13 , 2 , 636 , 180 , 2 , "Russland" , new int[] {12 , 14 , 16 , 27 , 31 , 32});
|
||||
provinces[14] = new Province(14 , 2 , 528 , 232 , 2 , "Nordeuropa" , new int[] {11 , 12 , 13 , 15 , 16});
|
||||
provinces[15] = new Province(15 , 2 , 449 , 335 , 2 , "Westeuropa" , new int[] {11 , 14 , 16 , 25});
|
||||
provinces[16] = new Province(16 , 2 , 537 , 296 , 2 , "Suedeuropa" , new int[] {13 , 14 , 15 , 25 , 26 , 27});
|
||||
// cID 2 - Europa
|
||||
provinces[10] = new Province(10 , 2 , 454 , 142 , 1 , "Island" , new int[] {9 , 11 , 12});
|
||||
provinces[11] = new Province(11 , 2 , 424 , 221 , 2 , "Grossbritannien" , new int[] {10 , 12 , 14 , 15});
|
||||
provinces[12] = new Province(12 , 2 , 520 , 153 , 1 , "Skandinavien" , new int[] {10 , 11 , 13 , 14});
|
||||
provinces[13] = new Province(13 , 2 , 636 , 180 , 2 , "Russland" , new int[] {12 , 14 , 16 , 27 , 31 , 32});
|
||||
provinces[14] = new Province(14 , 2 , 528 , 232 , 2 , "Nordeuropa" , new int[] {11 , 12 , 13 , 15 , 16});
|
||||
provinces[15] = new Province(15 , 2 , 449 , 335 , 2 , "Westeuropa" , new int[] {11 , 14 , 16 , 25});
|
||||
provinces[16] = new Province(16 , 2 , 537 , 296 , 2 , "Suedeuropa" , new int[] {13 , 14 , 15 , 25 , 26 , 27});
|
||||
|
||||
// cID 3 - Suedamerika
|
||||
provinces[17] = new Province(17 , 3 , 245 , 396 , 1 , "Venezuela" , new int[] {8 , 18 , 19});
|
||||
provinces[18] = new Province(18 , 3 , 255 , 498 , 1 , "Peru" , new int[] {17 , 19 , 20});
|
||||
provinces[19] = new Province(19 , 3 , 327 , 467 , 2 , "Brasilien" , new int[] {17 , 18 , 20 , 25});
|
||||
provinces[20] = new Province(20 , 3 , 274 , 572 , 1 , "Argentinien" , new int[] {18 , 19});
|
||||
|
||||
// cID 4 - Afrika
|
||||
provinces[21] = new Province(21 , 4 , 680 , 630 , 1 , "Madagaskar" , new int[] {24 , 22});
|
||||
provinces[22] = new Province(22 , 4 , 580 , 624 , 1 , "Südafrika" , new int[] {21 , 23 , 24});
|
||||
provinces[23] = new Province(23 , 4 , 572 , 537 , 2 , "Zentralafrika" , new int[] {22 , 25 , 24});
|
||||
provinces[24] = new Province(24 , 4 , 632 , 500 , 2 , "Ostafrika" , new int[] {21 , 22 , 25 , 23 , 26});
|
||||
provinces[25] = new Province(25 , 4 , 491 , 444 , 1 , "Nordafrika" , new int[] {15 , 16 , 26 , 23 , 24});
|
||||
provinces[26] = new Province(26 , 4 , 574 , 414 , 1 , "Aegypten" , new int[] {27 , 25 , 24 , 16});
|
||||
|
||||
// cID 5 - Asien
|
||||
provinces[27] = new Province(27 , 5 , 664 , 345 , 2 , "Mittlerer Osten" , new int[] {24 , 26 , 16 , 23 , 31 , 28});
|
||||
provinces[28] = new Province(28 , 5 , 784 , 370 , 2 , "Indien" , new int[] {29 , 31 , 27 , 30});
|
||||
provinces[29] = new Province(29 , 5 , 863 , 322 , 2 , "China" , new int[] {30 , 28 , 31 , 32 , 33 , 37});
|
||||
provinces[30] = new Province(30 , 5 , 867 , 400 , 1 , "Südost Asien" , new int[] {29 , 39 , 28});
|
||||
provinces[31] = new Province(31 , 5 , 724 , 262 , 1 , "Afganistan" , new int[] {29 , 28 , 27 , 13 , 32});
|
||||
provinces[32] = new Province(32 , 5 , 740 , 163 , 1 , "Ural" , new int[] {29 , 33 , 31 , 13});
|
||||
provinces[33] = new Province(33 , 5 , 802 , 128 , 1 , "Sibirien" , new int[] {34 , 35 , 37 , 29 , 32});
|
||||
provinces[34] = new Province(34 , 5 , 884 , 82 , 1 , "Jakutien" , new int[] {36 , 35 , 33});
|
||||
provinces[35] = new Province(35 , 5 , 867 , 176 , 2 , "Irkutsk" , new int[] {34 , 36 , 37 , 33});
|
||||
provinces[36] = new Province(36 , 5 , 973 , 89 , 1 , "Kamtschatka" , new int[] {1 , 38 , 37 , 35 , 34});
|
||||
provinces[37] = new Province(37 , 5 , 882 , 243 , 1 , "Mongolei" , new int[] {29 , 33 , 35 , 36 , 38});
|
||||
provinces[38] = new Province(38 , 5 , 994 , 249 , 2 , "Japan" , new int[] {37 , 36});
|
||||
|
||||
// cID 6 - Ozeanien
|
||||
provinces[39] = new Province(39 , 6 , 889 , 519 , 1 , "Indonesien" , new int[] {30 , 40 , 42});
|
||||
provinces[40] = new Province(40 , 6 , 983 , 492 , 2 , "Neuguinea" , new int[] {39 , 41 , 42});
|
||||
provinces[41] = new Province(41 , 6 , 1000, 595 , 1 , "Ost Australien" , new int[] {40 , 42});
|
||||
provinces[42] = new Province(42 , 6 , 934 , 628 , 1 , "West Australien" , new int[] {40 , 41 , 39});
|
||||
// cID 3 - Suedamerika
|
||||
provinces[17] = new Province(17 , 3 , 245 , 396 , 1 , "Venezuela" , new int[] {8 , 18 , 19});
|
||||
provinces[18] = new Province(18 , 3 , 255 , 498 , 1 , "Peru" , new int[] {17 , 19 , 20});
|
||||
provinces[19] = new Province(19 , 3 , 327 , 467 , 2 , "Brasilien" , new int[] {17 , 18 , 20 , 25});
|
||||
provinces[20] = new Province(20 , 3 , 274 , 572 , 1 , "Argentinien" , new int[] {18 , 19});
|
||||
|
||||
// cID 4 - Afrika
|
||||
provinces[21] = new Province(21 , 4 , 680 , 630 , 1 , "Madagaskar" , new int[] {24 , 22});
|
||||
provinces[22] = new Province(22 , 4 , 580 , 624 , 1 , "Südafrika" , new int[] {21 , 23 , 24});
|
||||
provinces[23] = new Province(23 , 4 , 572 , 537 , 2 , "Zentralafrika" , new int[] {22 , 25 , 24});
|
||||
provinces[24] = new Province(24 , 4 , 632 , 500 , 2 , "Ostafrika" , new int[] {21 , 22 , 25 , 23 , 26});
|
||||
provinces[25] = new Province(25 , 4 , 491 , 444 , 1 , "Nordafrika" , new int[] {15 , 16 , 26 , 23 , 24});
|
||||
provinces[26] = new Province(26 , 4 , 574 , 414 , 1 , "Aegypten" , new int[] {27 , 25 , 24 , 16});
|
||||
|
||||
// cID 5 - Asien
|
||||
provinces[27] = new Province(27 , 5 , 664 , 345 , 2 , "Mittlerer Osten" , new int[] {24 , 26 , 16 , 23 , 31 , 28});
|
||||
provinces[28] = new Province(28 , 5 , 784 , 370 , 2 , "Indien" , new int[] {29 , 31 , 27 , 30});
|
||||
provinces[29] = new Province(29 , 5 , 863 , 322 , 2 , "China" , new int[] {30 , 28 , 31 , 32 , 33 , 37});
|
||||
provinces[30] = new Province(30 , 5 , 867 , 400 , 1 , "Südost Asien" , new int[] {29 , 39 , 28});
|
||||
provinces[31] = new Province(31 , 5 , 724 , 262 , 1 , "Afganistan" , new int[] {29 , 28 , 27 , 13 , 32});
|
||||
provinces[32] = new Province(32 , 5 , 740 , 163 , 1 , "Ural" , new int[] {29 , 33 , 31 , 13});
|
||||
provinces[33] = new Province(33 , 5 , 802 , 128 , 1 , "Sibirien" , new int[] {34 , 35 , 37 , 29 , 32});
|
||||
provinces[34] = new Province(34 , 5 , 884 , 82 , 1 , "Jakutien" , new int[] {36 , 35 , 33});
|
||||
provinces[35] = new Province(35 , 5 , 867 , 176 , 2 , "Irkutsk" , new int[] {34 , 36 , 37 , 33});
|
||||
provinces[36] = new Province(36 , 5 , 973 , 89 , 1 , "Kamtschatka" , new int[] {1 , 38 , 37 , 35 , 34});
|
||||
provinces[37] = new Province(37 , 5 , 882 , 243 , 1 , "Mongolei" , new int[] {29 , 33 , 35 , 36 , 38});
|
||||
provinces[38] = new Province(38 , 5 , 994 , 249 , 2 , "Japan" , new int[] {37 , 36});
|
||||
|
||||
// cID 6 - Ozeanien
|
||||
provinces[39] = new Province(39 , 6 , 889 , 519 , 1 , "Indonesien" , new int[] {30 , 40 , 42});
|
||||
provinces[40] = new Province(40 , 6 , 983 , 492 , 2 , "Neuguinea" , new int[] {39 , 41 , 42});
|
||||
provinces[41] = new Province(41 , 6 , 1000, 595 , 1 , "Ost Australien" , new int[] {40 , 42});
|
||||
provinces[42] = new Province(42 , 6 , 934 , 628 , 1 , "West Australien" , new int[] {40 , 41 , 39});
|
||||
|
||||
for (int c = 1; c <= provinceCount; c++)
|
||||
{
|
||||
addObject(provinces[c],provinces[c].getXPos(),provinces[c].getYPos());
|
||||
}
|
||||
}
|
||||
initProvinces();
|
||||
}
|
||||
}
|
||||
|
@ -0,0 +1,17 @@
|
||||
import greenfoot.*;
|
||||
import java.util.Arrays; // (World, Actor, GreenfootImage, Greenfoot and MouseInfo)
|
||||
import java.awt.Color;
|
||||
|
||||
/**
|
||||
Erstellt eine gegebene Anzahl an OffenderDice's, welche dann nebeneinander eingereiht werden.
|
||||
|
||||
@author Felix Stupp
|
||||
@version 15.06.2016
|
||||
*/
|
||||
public class OffenderDices extends DicesList {
|
||||
|
||||
public OffenderDices(int count) {
|
||||
super(count, 3, new Color(255,0,0), (new Color(255,255,255)));
|
||||
}
|
||||
|
||||
}
|
@ -0,0 +1,200 @@
|
||||
import greenfoot.*;
|
||||
|
||||
/**
|
||||
* Write a description of class Player here.
|
||||
*
|
||||
* @author (Genosse Betakevin und Genosse Julien)
|
||||
* @version (version 666)
|
||||
*/
|
||||
public class Player extends Actor
|
||||
{
|
||||
@Override public GeneralMap getWorld(){
|
||||
return (GeneralMap) super.getWorld();
|
||||
}
|
||||
int stars=0;
|
||||
int add=0;
|
||||
int id=0;
|
||||
int provZahl=0;
|
||||
int provVgl=0;
|
||||
int [] stats = new int [6];
|
||||
boolean [] pBesitzer = new boolean [42];
|
||||
boolean gotProv = false;
|
||||
boolean lostProv = false;
|
||||
|
||||
private String n;
|
||||
private int c;
|
||||
//definiert die ID und Namens Variable
|
||||
public Player( int identity,String name, int color)
|
||||
{
|
||||
n = name;
|
||||
id = identity;
|
||||
c = color;
|
||||
}
|
||||
//gibt die Spieler ID zurück
|
||||
public int getID()
|
||||
{
|
||||
return id;
|
||||
}
|
||||
// gibt den Spielernamen zurück
|
||||
public String getDisplayName ()
|
||||
{
|
||||
return n;
|
||||
}
|
||||
//gibt die Sternenanzahl zurück
|
||||
public int getStars ()
|
||||
{
|
||||
return stars;
|
||||
}
|
||||
// erhöht die Sternenzahl um eine random ausgewählte Anzahl von 1-3
|
||||
public void addToStars ()
|
||||
{
|
||||
|
||||
int rand;
|
||||
int pre;
|
||||
rand = (int)(1+6*Math.random());
|
||||
if (rand == 1 || rand == 2|| rand == 3)
|
||||
{
|
||||
add = 1;
|
||||
}
|
||||
if (rand == 4|| rand == 5)
|
||||
{
|
||||
add = 2;
|
||||
}
|
||||
if (rand == 6)
|
||||
{
|
||||
add = 3;
|
||||
}
|
||||
if (gotProv== true)
|
||||
{
|
||||
pre = stars;
|
||||
stars+=add;
|
||||
System.out.println("Deine vorherige Sternenanzahl betrug " + pre + ".");
|
||||
System.out.println("Du hast " + add + " Sterne erhalten.");
|
||||
System.out.println("Deine aktuelle Sternenanzahl beträgt " + stars + ".");
|
||||
|
||||
}
|
||||
}
|
||||
//eine Methode um addToStars zu testen
|
||||
public void add ()
|
||||
{
|
||||
addToStars();
|
||||
}
|
||||
//eine für das Testen gedachte Methode, die die Anzahl der Sterne auf ein gewünschtes Maß setzt
|
||||
public int setStars (int set)
|
||||
{
|
||||
stars = set;
|
||||
return stars;
|
||||
}
|
||||
//eine Methode, die das Abziehen von Sternen testet und, wenn das Ergebnis >= 0 ist, die Sternenanzahl um eine gewählte Anzahl verringert
|
||||
public int removeFromStars(int sub)
|
||||
{
|
||||
int s;
|
||||
|
||||
s = stars - sub;
|
||||
if (s>=0)
|
||||
{
|
||||
stars = s;
|
||||
}
|
||||
else
|
||||
{
|
||||
System.out.println ("Du hast nur " + stars + " Sterne, du kannst also nicht " + sub + " Sterne abziehen");
|
||||
}
|
||||
return stars;
|
||||
}
|
||||
|
||||
public int getProvinceCount ()
|
||||
{
|
||||
GeneralMap w= getWorld();
|
||||
int[] provinces = w.getProvinceOwners();
|
||||
for (int x=0; x<=42; x++ )
|
||||
{
|
||||
if ( provinces [x] ==id)
|
||||
{
|
||||
provZahl++;
|
||||
|
||||
}
|
||||
}
|
||||
if(stats[2] < provZahl)
|
||||
{
|
||||
stats[2]=provZahl;
|
||||
|
||||
}
|
||||
return provZahl;
|
||||
}
|
||||
|
||||
public void gotEntities(int gotEnt)
|
||||
{
|
||||
stats[3]+= gotEnt;
|
||||
}
|
||||
public void lostEntity()
|
||||
{
|
||||
stats[4]+=1;
|
||||
}
|
||||
private void maxEntities(int entNumber)
|
||||
{
|
||||
if (stats[5]< entNumber)
|
||||
{
|
||||
stats[5]=entNumber;
|
||||
}
|
||||
}
|
||||
public boolean[] getMyProvinces()
|
||||
{
|
||||
GeneralMap w= getWorld();
|
||||
int[] provinces = w.getProvinceOwners();
|
||||
for (int x=0; x<=42; x++)
|
||||
{
|
||||
if (provinces[x]== id)
|
||||
{
|
||||
pBesitzer[x]=true;
|
||||
}
|
||||
else
|
||||
{
|
||||
pBesitzer[x]=false;
|
||||
}
|
||||
|
||||
}
|
||||
return pBesitzer;
|
||||
}
|
||||
|
||||
private void gotlostProvince()
|
||||
{
|
||||
if (provVgl== provZahl)
|
||||
{
|
||||
gotProv = false;
|
||||
lostProv =false;
|
||||
|
||||
}
|
||||
if(provVgl< provZahl)
|
||||
{
|
||||
gotProv = true;
|
||||
lostProv = false;
|
||||
stats[0]+=1;
|
||||
}
|
||||
if (provVgl > provZahl)
|
||||
{
|
||||
gotProv = false;
|
||||
lostProv = true;
|
||||
stats[1]+=1;
|
||||
}
|
||||
provVgl = provZahl;
|
||||
}
|
||||
|
||||
public boolean getGotProvince ()
|
||||
{
|
||||
return gotProv;
|
||||
}
|
||||
|
||||
public boolean getLostProvince()
|
||||
{
|
||||
return lostProv;
|
||||
}
|
||||
public int[] getStatistics()
|
||||
{
|
||||
return stats;
|
||||
}
|
||||
private void redrawPlayer()
|
||||
{
|
||||
//Platzhalter
|
||||
int x=0;
|
||||
}
|
||||
}
|
@ -1,34 +1,75 @@
|
||||
import greenfoot.*;
|
||||
import java.awt.Color;
|
||||
import java.util.*;
|
||||
|
||||
/**
|
||||
* Diese Klasse enthält nur statische Funktionen, welche für euch als Unterstützung gedacht sind. Damit könnt ihr dann hoffentlich viele Code-Zeilen sparen. :)
|
||||
*
|
||||
* @author Zocker1999_NET
|
||||
* @version 1
|
||||
Diese Klasse enthält nur statische Funktionen, welche für euch als Unterstützung gedacht sind. Damit könnt ihr dann hoffentlich viele Code-Zeilen sparen. :)
|
||||
|
||||
@author Zocker1999_NET
|
||||
@version 15.06.2016
|
||||
*/
|
||||
public final class Utils {
|
||||
|
||||
//Kopiert ein Array eines (annäherend) beliebigen Types.
|
||||
/**
|
||||
Kopiert ein boolean-Array und übergibt diese.
|
||||
@param a Das zu kopierende Array
|
||||
@return Die Kopie des Arrays
|
||||
*/
|
||||
public static boolean[] copyArray(boolean[] a) {
|
||||
boolean[] b = new boolean[a.length];
|
||||
for(int i = 0; i >= a.length; i++) {
|
||||
for(int i = 0; i < a.length; i++) {
|
||||
b[i] = a[i];
|
||||
}
|
||||
return b;
|
||||
}
|
||||
/**
|
||||
Kopiert ein int-Array und übergibt diese.
|
||||
@param a Das zu kopierende Array
|
||||
@return Die Kopie des Arrays
|
||||
*/
|
||||
public static int[] copyArray(int[] a) {
|
||||
int[] b = new int[a.length];
|
||||
for(int i = 0; i >= a.length; i++) {
|
||||
for(int i = 0; i < a.length; i++) {
|
||||
b[i] = a[i];
|
||||
}
|
||||
return b;
|
||||
}
|
||||
/**
|
||||
Kopiert ein String-Array und übergibt diese.
|
||||
@param a Das zu kopierende Array
|
||||
@return Die Kopie des Arrays
|
||||
*/
|
||||
public static String[] copyArray(String[] a) {
|
||||
String[] b = new String[a.length];
|
||||
for(int i = 0; i >= a.length; i++) {
|
||||
for(int i = 0; i < a.length; i++) {
|
||||
b[i] = a[i];
|
||||
}
|
||||
return b;
|
||||
}
|
||||
|
||||
/**
|
||||
Zeichnet innerhalb eines GreenfootImage ein gefülltes Rechteck in der gegebenen Farbe und mit dem gegebenen Abstand zum Rand.
|
||||
@param i Das GreenfootImage, in dem gezeichnet werden soll.
|
||||
@param c Die Farbe, in der das gefüllte Rechteck gezeichnet werden soll.
|
||||
@param b Der Abstand zum Rand der Grafik.
|
||||
*/
|
||||
public static void drawInsideRectangle(GreenfootImage i, Color c, int b) {
|
||||
int sx = i.getWidth();
|
||||
int sy = i.getHeight();
|
||||
i.setColor(c);
|
||||
i.fillRect(b,b,sx-(2*b),sy-(2*b));
|
||||
}
|
||||
|
||||
/**
|
||||
Sortiert ein int[]-Array absteigend.
|
||||
@param a Das zu sortierende Array
|
||||
*/
|
||||
public static void sortDesc(int[] a) {
|
||||
Arrays.sort(a);
|
||||
int[] b = copyArray(a);
|
||||
for(int i = (a.length - 1); i >= 0; i--) {
|
||||
a[i] = b[i];
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
Before Width: | Height: | Size: 292 KiB After Width: | Height: | Size: 292 KiB |
After Width: | Height: | Size: 173 B |
After Width: | Height: | Size: 166 B |
After Width: | Height: | Size: 164 B |
After Width: | Height: | Size: 148 B |
Before Width: | Height: | Size: 216 KiB After Width: | Height: | Size: 216 KiB |
Before Width: | Height: | Size: 198 KiB After Width: | Height: | Size: 198 KiB |
Before Width: | Height: | Size: 188 KiB After Width: | Height: | Size: 188 KiB |
Before Width: | Height: | Size: 336 KiB After Width: | Height: | Size: 336 KiB |
Before Width: | Height: | Size: 146 KiB After Width: | Height: | Size: 146 KiB |
@ -1,92 +1,165 @@
|
||||
# Funktionsliste Zweiundvierzig
|
||||
|
||||
**Version: 2**
|
||||
|
||||
**Stand: 10.04.2016** (TT.MM.JJJJ / DD.MM.YYYY)
|
||||
|
||||
[Hier die neuste offizielle Version vom Master-Branch sehen](https://github.com/HGE-IT-Course-2016/zweiundvierzig/blob/master/planung/funktionsliste.md)
|
||||
|
||||
[Hier zum gesamten Architekturplan](https://github.com/HGE-IT-Course-2016/zweiundvierzig/blob/master/planung/architektur.md)
|
||||
|
||||
Hier einfach eine grobe Übersicht über alle Funktionen, die jede Klasse als Public / Protected besitzen soll.
|
||||
|
||||
Dies könnt auch als Checkliste nehmen, um zu sehen, ob ihr bereits alle Funktionen im Code präsent habt.
|
||||
|
||||
## GeneralMap
|
||||
|
||||
- **static GeneralMap generateMap(int mapID, ...)**
|
||||
|
||||
- **int getPlayerCount()**
|
||||
- **String getPlayerName()**
|
||||
- **String getPlayerName(int)**
|
||||
- **int getPlayerStars()**
|
||||
- **int getProvinceOwner(int)**
|
||||
- **int[] getProvinceOwners()**
|
||||
- **int getProvinceEntityCount(int)**
|
||||
- **int getProvincesEntityCounts(int[])**
|
||||
- **int getProvincesEntityCounts(boolean[])**
|
||||
- **int getProvincesEntityCounts(int)**
|
||||
|
||||
## Province
|
||||
|
||||
- **Province(int, int, int, int, int, String, int[])**
|
||||
- **Province(int, int, int, int, int, String, boolean[])**
|
||||
|
||||
- **int getID()**
|
||||
- **int getContinentID()**
|
||||
- **boolean isProvinceNear(int)**
|
||||
- **String getDisplayName()**
|
||||
- **int getStars()**
|
||||
- **int getOwner()**
|
||||
- **setOwner(int)**
|
||||
- **int getEntityCount()**
|
||||
- **int addToEntities(int)**
|
||||
- **int removeFromEntities(int)**
|
||||
- **int setEntityCount(int)**
|
||||
|
||||
- **redrawProvince()**
|
||||
|
||||
## Player
|
||||
|
||||
- **Player(int, String)**
|
||||
|
||||
- **int getID()**
|
||||
- **String getDisplayName()**
|
||||
- **int getStars()**
|
||||
- **int addToStars(int)**
|
||||
- **int removeFromStars(int)**
|
||||
- **int setStars(int)**
|
||||
- **boolean cnaStarsRemoved(int)**
|
||||
|
||||
- **int[] getStatistics()**
|
||||
- **gotProvince()**
|
||||
- **lostProvince()**
|
||||
- **gotEntities(int)**
|
||||
- **lostEntity()**
|
||||
|
||||
- **boolean[] getMyProvinces()**
|
||||
- **int getProvinceCount()**
|
||||
- **redrawPlayer()**
|
||||
|
||||
## Dice
|
||||
|
||||
- **Dice()**
|
||||
|
||||
- **int getNumber()**
|
||||
|
||||
- **int roll()**
|
||||
|
||||
## GUI_Interface
|
||||
|
||||
*Noch unvollständig*
|
||||
|
||||
## Label
|
||||
|
||||
*Noch unvollständig*
|
||||
|
||||
- **String getText()**
|
||||
- **String setText(String)**
|
||||
|
||||
## Button
|
||||
|
||||
*Noch unvollständig*
|
||||
# Funktionsliste Zweiundvierzig
|
||||
|
||||
**Letztes Update: 15.06.2016** (TT.MM.JJJJ / DD.MM.YYYY)
|
||||
|
||||
[Hier die offizielle Version vom Master-Branch sehen](https://github.com/HGE-IT-Course-2016/zweiundvierzig/blob/master/planung/funktionsliste.md)
|
||||
|
||||
[Hier zum gesamten Architekturplan auf dem aktuellen Branch](architektur.md)
|
||||
|
||||
Hier einfach eine grobe Übersicht über alle Methoden und eventuellen Variabled, die jede Klasse als *public* oder *protected* besitzen soll beziehungsweise bereits besitzt.
|
||||
Weitere Informationen zu den Methoden findet ihr in der Architektur oder, falls die Methoden bereits vorhanden ist, in der Dokumentation, die von Greenfoot automatisch erstellt wird (durch die InCode Dokumentation).
|
||||
|
||||
Falls euere Aufgabe die Umsetzung einer Methode ist, die hier bereits beschrieben wird, müsst ihr nicht diesselben Parameterbezeichner verwenden, wie sie hier verwendet wurden. Falls aus diesem Bezeichner jedoch nicht mehr die Bedeutung des Parameters ausgeht, muss dies in einem Java-Documentation Kommentar erklärt werden.
|
||||
|
||||
Dies könnt auch als Checkliste verwenden, um zu sehen, ob ihr bereits alle Methodenn im Code präsent habt.
|
||||
|
||||
## GeneralMap (extends World)
|
||||
|
||||
- *GeneralMap* ( *String* backgroundImage, *String[]* playerList, *int[]* colorList )
|
||||
|
||||
- protected *void* **initProvinces** ()
|
||||
|
||||
- *int* **getPlayerCount** ()
|
||||
- *String* **getPlayerName** ()
|
||||
- *String* **getPlayerName** ( *int* playerID )
|
||||
- *int* **getPlayerStars** ()
|
||||
|
||||
- *int* **getProvinceOwner** ( *int* provinceID )
|
||||
- *int[]* **getProvinceOwners** ()
|
||||
- *int* **getProvinceEntityCount** ( *int* playerID )
|
||||
|
||||
## Province (extends Actor)
|
||||
|
||||
- *Province* ( *int* provinceID, *int* continentID, *int* xPos, *int* yPos, *String* displayName, *int* stars, *int[]* neighbourProvinces )
|
||||
|
||||
- *int* **getXPos** ()
|
||||
- *int* **getYPos** ()
|
||||
- *int* **getID** ()
|
||||
- *int* **getContinentID** ()
|
||||
- *String* **getDisplayName** ()
|
||||
- *int* **getStars** ()
|
||||
|
||||
- *boolean* **isProvinceNear** ( *int* provinceID )
|
||||
|
||||
- *int* **getOwner** ()
|
||||
- *boolean* **setOwner** ( *int* playerID )
|
||||
|
||||
- *int* **getEntityCount** ()
|
||||
- *int* **addToEntities** ( *int* entityCountToAdd )
|
||||
- *int* **removeFromEntities** ( *int* entityCountToRemove )
|
||||
- *int* **setEntityCount** ( *int* newEntityCount)
|
||||
|
||||
- *boolean* **hasClicked** ()
|
||||
|
||||
- *void* **redrawProvince** ()
|
||||
|
||||
## Player (extends Actor)
|
||||
|
||||
- *Player* ( *int* playerID, *String* displayName, *int* playerColor )
|
||||
|
||||
- *int* **getID** ()
|
||||
- *String* **getDisplayName** ()
|
||||
|
||||
- *int* **getStars** ()
|
||||
- *int* **addToStars** ( *int* starsToAdd )
|
||||
- *int* **removeFromStars** ( *int* starsToRemove )
|
||||
- *int* **setStars** ( *int* newStarsCount )
|
||||
- *boolean* **canStarsRemoved** ( *int* requiredStarsCount )
|
||||
|
||||
- *int[]* **getStatistics** ()
|
||||
- *void* **gotProvince** ()
|
||||
- *void* **lostProvince** ()
|
||||
- *void* **gotEntities** ( *int* addedEntities )
|
||||
- *void* **lostEntity** ()
|
||||
|
||||
- *boolean[]* **getMyProvinces** ()
|
||||
- *int* **getProvinceCount** ()
|
||||
- *void* **redrawPlayer** ()
|
||||
|
||||
## DicesList (extends Actor)
|
||||
|
||||
- *DicesList* ( *int* count, *int* maxCount, *java.awt.Color* backColor, *java.awt.Color* foreColor )
|
||||
|
||||
- *int[]* **getNumbers** ()
|
||||
- *int[]* **roll** ()
|
||||
|
||||
- *void* **removeAll** ()
|
||||
|
||||
## OffenderDices (extends Actor)
|
||||
|
||||
- *OffenderDices* ( *int* count )
|
||||
|
||||
## DefenderDices (extends Actor)
|
||||
|
||||
- *DefenderDices* ( *int* count )
|
||||
|
||||
## GUI_Interface (extends Actor)
|
||||
|
||||
- protected *int* **sx**
|
||||
- protected *int* **sy**
|
||||
|
||||
- *int* **getWidth** ()
|
||||
- *int* **getHeight** ()
|
||||
- *void* **setSize** ( *int* width , *int* height )
|
||||
|
||||
- *java.awt.Color* **getBackColor** ()
|
||||
- *boolean* **setBackColor** ( *java.awt.Color* newBackColor)
|
||||
- *java.awt.Color* **getForeColor** ()
|
||||
- *boolean* **setForeColor** ( *java.awt.Color* newForeColor)
|
||||
|
||||
- abstract *void* **redraw** ()
|
||||
|
||||
## Label (extends GUI_Interface)
|
||||
|
||||
- *Label* ( *String* text, *int* textSize )
|
||||
|
||||
- *boolean* **getAutoSize** ()
|
||||
- *void* **setAutoSize** ( *boolean* newValue )
|
||||
- *int* **getTextSize** ()
|
||||
- *boolean* **setTextSize** ( *int* newSize )
|
||||
- *String* **getText** ()
|
||||
- *boolean* **setText** ( *String* newText )
|
||||
|
||||
- *void* **redraw** ()
|
||||
|
||||
## Button (extends GUI_Interface)
|
||||
|
||||
- *Button* ( *String* text, *int* textSize )
|
||||
- *Button* ( *ButtonEvent* eventHandler )
|
||||
- *Button* ( *String* text, *int* textSize, *ButtonEvent* eventHandler )
|
||||
|
||||
- *boolean* **getAutoSize** ()
|
||||
- *void* **setAutoSize** ( *boolean* newValue )
|
||||
- *int* **getTextSize** ()
|
||||
- *boolean* **setTextSize** ( *int* newSize )
|
||||
- *String* **getText** ()
|
||||
- *boolean* **setText** ( *String* newText )
|
||||
|
||||
- *ButtonEvent* **getHandler** ()
|
||||
- *void* **setHandler** ( *ButtonEvent* newEventHandler )
|
||||
- *void* **removeHandler** ()
|
||||
|
||||
- *void* **redraw** ()
|
||||
|
||||
## Dice (extends GUI_Interface)
|
||||
|
||||
- *Dice* ()
|
||||
- *Dice* ( *int* startNumber )
|
||||
|
||||
- *int* **getNumber** ()
|
||||
|
||||
- *void* **setSizeAsSquare** ( *int* length )
|
||||
|
||||
- *int* **roll** ()
|
||||
|
||||
- *void* **redraw** ()
|
||||
|
||||
## Utils
|
||||
|
||||
- static *boolean[]* **copyArray** ( *boolean[]* array )
|
||||
- static *int[]* **copyArray** ( *int[]* array )
|
||||
- static *String[]* **copyArray** ( *String[]* array )
|
||||
|
||||
- static *void* **drawInsideRectangle** ( *GreenfootImage* i, *Color* c, *int* b )
|
||||
|
||||
- static *void* **sortDesc** ( **int[]** array )
|
@ -1,8 +1,147 @@
|
||||
#Greenfoot project file
|
||||
#Greenfoot properties
|
||||
#Sun May 29 22:05:35 CEST 2016
|
||||
editor.fx.0.height=700
|
||||
target2.width=100
|
||||
target8.name=Map_World
|
||||
target11.y=190
|
||||
target11.x=10
|
||||
class.GUI_Interface.superclass=greenfoot.Actor
|
||||
target1.type=ClassTarget
|
||||
target7.showInterface=false
|
||||
mainWindow.height=600
|
||||
target6.typeParameters=
|
||||
target1.height=50
|
||||
class.Dice_Offender.superclass=Dice
|
||||
target8.y=70
|
||||
target8.x=170
|
||||
dependency2.type=UsesDependency
|
||||
target5.type=ClassTarget
|
||||
target6.y=10
|
||||
target6.x=120
|
||||
target1.showInterface=false
|
||||
target4.y=310
|
||||
target4.x=10
|
||||
target4.showInterface=false
|
||||
target9.type=ClassTarget
|
||||
target2.y=250
|
||||
target2.x=10
|
||||
target10.type=ClassTarget
|
||||
target8.height=50
|
||||
target11.height=50
|
||||
target10.typeParameters=
|
||||
dependency4.from=Map_World
|
||||
class.Weltenauswahl.superclass=Spieloptionen
|
||||
target1.name=Dice
|
||||
target10.showInterface=false
|
||||
class.Map_World.superclass=GeneralMap
|
||||
target4.typeParameters=
|
||||
target5.name=Province
|
||||
world.lastInstantiated=Map_World
|
||||
class.Dice.superclass=greenfoot.Actor
|
||||
mainWindow.width=800
|
||||
mainWindow.x=10
|
||||
readme.width=47
|
||||
class.Dice_Defender.superclass=Dice
|
||||
class.GeneralMap.superclass=greenfoot.World
|
||||
class.CurrentPlayerArrow.superclass=GUI_Interface
|
||||
target9.name=Button
|
||||
target5.height=50
|
||||
target10.name=Dice_Offender
|
||||
target2.type=ClassTarget
|
||||
dependency1.to=Utils
|
||||
dependency3.type=UsesDependency
|
||||
target2.height=50
|
||||
target2.typeParameters=
|
||||
target6.type=ClassTarget
|
||||
editor.swing.0.height=700
|
||||
class.Spieloptionen.superclass=greenfoot.World
|
||||
target9.typeParameters=
|
||||
target11.type=ClassTarget
|
||||
version=2.8.0
|
||||
editor.fx.0.y=0
|
||||
editor.fx.0.x=0
|
||||
target2.showInterface=false
|
||||
dependency1.from=Province
|
||||
mainWindow.y=10
|
||||
editor.swing.0.y=0
|
||||
mainWindow.x=10
|
||||
editor.swing.0.x=78
|
||||
target5.showInterface=false
|
||||
target8.showInterface=false
|
||||
target7.typeParameters=
|
||||
target2.name=GUI_Interface
|
||||
readme.name=@README
|
||||
class.Menue_Button.superclass=Button
|
||||
editor.swing.0.width=701
|
||||
target6.name=CurrentPlayerArrow
|
||||
target9.height=50
|
||||
target12.y=190
|
||||
target12.x=190
|
||||
editor.fx.0.width=700
|
||||
target11.showInterface=false
|
||||
target10.y=130
|
||||
target10.x=100
|
||||
dependency2.to=Menue_Button
|
||||
target12.width=90
|
||||
target11.name=Utils
|
||||
target12.height=50
|
||||
class.Province.superclass=greenfoot.Actor
|
||||
target9.y=130
|
||||
target9.x=10
|
||||
target3.type=ClassTarget
|
||||
target6.height=50
|
||||
target7.y=70
|
||||
target7.x=70
|
||||
target11.typeParameters=
|
||||
target5.y=310
|
||||
target5.x=130
|
||||
dependency4.type=UsesDependency
|
||||
target7.type=ClassTarget
|
||||
target10.width=110
|
||||
target3.y=250
|
||||
target3.x=120
|
||||
target11.width=80
|
||||
target3.height=50
|
||||
target1.y=190
|
||||
target1.x=100
|
||||
target12.type=ClassTarget
|
||||
target5.typeParameters=
|
||||
dependency2.from=GeneralMap
|
||||
project.charset=UTF-8
|
||||
version=2.8.0
|
||||
world.lastInstantiated=GUI_Ingame
|
||||
target3.showInterface=false
|
||||
class.Spieleranzahl.superclass=Spieloptionen
|
||||
target3.name=Menue_Button
|
||||
target6.showInterface=false
|
||||
target3.typeParameters=
|
||||
target9.showInterface=false
|
||||
dependency3.to=Roll_Button
|
||||
target7.name=GeneralMap
|
||||
package.numDependencies=4
|
||||
package.numTargets=12
|
||||
target12.name=Roll_Button
|
||||
dependency1.type=UsesDependency
|
||||
target4.type=ClassTarget
|
||||
target12.showInterface=false
|
||||
target8.width=90
|
||||
target9.width=80
|
||||
target7.height=50
|
||||
target8.type=ClassTarget
|
||||
class.Button.superclass=GUI_Interface
|
||||
target6.width=140
|
||||
target10.height=50
|
||||
target7.width=90
|
||||
class.Roll_Button.superclass=Button
|
||||
dependency3.from=GeneralMap
|
||||
target1.typeParameters=
|
||||
target3.width=110
|
||||
target4.width=110
|
||||
target8.typeParameters=
|
||||
target5.width=80
|
||||
dependency4.to=Province
|
||||
class.Utils.superclass=
|
||||
target4.name=Dice_Defender
|
||||
readme.y=10
|
||||
readme.x=10
|
||||
target4.height=50
|
||||
readme.height=58
|
||||
target12.typeParameters=
|
||||
target1.width=80
|
||||
|