Tim/zulda
1
0
Fork 0
forked from IF-LK-2020/zulda
Code Issues Pull Requests Releases Wiki Activity

Iniital commit

Browse Source
This commit is contained in:
Jonas Neugebauer
2021-06-10 08:52:17 +02:00
commit 562738007c
66 changed files with 141285 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

349
Karte.java Normal file
View File

@@ -0,0 +1,349 @@
import ea.*;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
/**
* Eine Karte besteht aus 20 mal 15 {@link Feld}ern und stellt einen Ausschnitt
* der {@link Welt} dar. Eine Karte hat bis zu vier Nachbarkarten zu denen man
* kommt, wenn man den Rand der Karte zu einer der Himmelsrichtungen überschreitet.
*
* Die Karten im Prototyp werden zufällig ohne Sinn erstellt. Für ein richtiges
* Spiel sollten die Karten "von Hand" gebaut werden, indem Felder mit passendem
* Untergrund gezielt positioniert werden. (Siehe das Beispiel {@link Karte_0}.)
*/
public class Karte extends Knoten {
// Referenz auf die Welt, zu der die Karte gehört
protected Welt welt;
// Die Felder, aus denen die Karte besteht
protected Feld[][] felder;
// Der X-Index der Karte in der Welt
private int weltX;
// Der Y-Index der Karte in der Welt
private int weltY;
// Liste aller Gegenstände, die sich auf der Karte befinden.
protected ArrayList<Gegenstand> gegenstaende;
// Liste aller Gegner, die sich auf der Karte befinden.
protected ArrayList<Gegner> gegner;
/**
* Konstruktor der Karte.
* @param pX x-Koordinate in der Welt
* @param pY y-Koordinate in der Welt
*/
public Karte( int pX, int pY, Welt pWelt ) {
welt = pWelt;
weltX = pX;
weltY = pY;
felder = new Feld[20][15];
gegner = new ArrayList<>();
gegenstaende = new ArrayList<>();
// Erstelle eine Karte nur aus Grasfeldern
for( int i = 0; i < felder.length; i++ ) {
for (int j = 0; j < felder[0].length; j++) {
felder[i][j] = new Feld(i*48,j*48, "gras");
add(felder[i][j]);
}
}
}
/**
* Gibt die Welt zurück, zu der diese Karte gehört.
* @return
*/
public Welt getWelt() {
return welt;
}
/**
* Gibt die x-Position der Karte im Welt-Array zurück.
* @return
*/
public int getWeltX() {
return weltX;
}
/**
* Gibt die y-Position der Karte im Welt-Array zurück.
* @return
*/
public int getWeltY() {
return weltY;
}
/**
* Gibt das Array aller Felder zurück.
* @return
*/
public Feld[][] getFelder() {
return felder;
}
/**
* Gibt das Feld zurück, dass in der Karte am angegeben Index liegt. Ist der
* Index außerhalb der Karte, wird {@code null} zurück gegeben.
* @param i
* @param j
* @return
*/
public Feld feldAnIndex( int i, int j ) {
if( i >= 0 && i < felder.length && j >= 0 && j < felder[0].length ) {
return felder[i][j];
} else {
return null;
}
}
/**
* Gibt das Feld zurück, in dem die angegebenen Koordinaten liegen. Sind die
* Koordinaten außerhalb der Karte, wird {@code null} zurück gegeben.
* @param x
* @param y
* @return
*/
public Feld feldAnKoordinate( float x, float y ) {
int i = (int) (x/48);
int j = (int) (y/48);
return feldAnIndex(i, j);
}
/**
* Ermittelt das Feld an den Koordinaten des angegebenen Punktes.
* @see #feldAnKoordinate(float, float)
* @param p
* @return
*/
public Feld feldAnKoordinate( Punkt p ) {
return feldAnKoordinate(p.x, p.y);
}
/**
* Verschiebt den angegebenen {@link Raum} (Bild, Knoten, Gegner, ...) auf
* das angegebene Feld.
* @param pRaum Das zu verschiebene Objekt
* @param pFeld Das Zielfeld
*/
public void verschiebeZuFeld( Raum pRaum, Feld pFeld ) {
pRaum.mittelpunktSetzen(
pFeld.zentrum()
);
}
/**
* Verschiebt den angegebenen {@link Raum} (Bild, Knoten, Gegner, ...) auf
* das Feld am Index (i|j). Gibt es an diesem Index kein Feld,
* passiert nichts.
* @param pRaum
* @param i
* @param j
*/
public void verschiebeZuFeldAnIndex( Raum pRaum, int i, int j ) {
Feld feld = feldAnIndex(i, j);
if( feld != null ) {
verschiebeZuFeld(pRaum, feld);
}
}
/**
* Verschiebt den angegebenen {@link Raum} (Bild, Knoten, Gegner, ...) auf
* das Feld an den Koordinaten (x|y). Gibt es zu diesen Koordinaten kein Feld,
* passiert nichts.
* @param pRaum
* @param x
* @param y
*/
public void verschiebeZuFeldAnKoordinate( Raum pRaum, float x, float y ) {
Feld feld = feldAnKoordinate(x, y);
if( feld != null ) {
verschiebeZuFeld(pRaum, feld);
}
}
/**
* Bewegt das angegebene {@link Raum Objekt} ein Feld nach links. Ist das
* Objekt am Rand der Karte oder ist das Zielfeld nicht
* {@link Feld#istPassierbar() passierbar}, passiert nichts.
*/
public void bewegeLinks( Gegner pGegner ) {
if (pGegner.zentrum().x > 0) {
Feld feld = feldAnKoordinate(pGegner.zentrum().x-48, pGegner.zentrum().y);
if( feld != null && feld.istPassierbar() ) {
verschiebeZuFeld(pGegner, feld);
}
}
}
/**
* Bewegt das angegebene {@link Raum Objekt} ein Feld nach rechts. Ist das
* Objekt am Rand der Karte oder ist das Zielfeld nicht
* {@link Feld#istPassierbar() passierbar}, passiert nichts.
*/
public void bewegeRechts( Gegner pGegner ) {
if (pGegner.zentrum().x < 19*48) {
Feld feld = feldAnKoordinate(pGegner.zentrum().x+48, pGegner.zentrum().y);
if( feld != null && feld.istPassierbar() ) {
verschiebeZuFeld(pGegner, feld);
}
}
}
/**
* Bewegt das angegebene {@link Raum Objekt} ein Feld nach oben. Ist das
* Objekt am Rand der Karte oder ist das Zielfeld nicht
* {@link Feld#istPassierbar() passierbar}, passiert nichts.
*/
public void bewegeHoch( Gegner pGegner ) {
if (pGegner.zentrum().y > 0) {
Feld feld = feldAnKoordinate(pGegner.zentrum().x, pGegner.zentrum().y-48);
if( feld != null && feld.istPassierbar() ) {
verschiebeZuFeld(pGegner, feld);
}
}
}
/**
* Bewegt das angegebene {@link Raum Objekt} ein Feld nach unten. Ist das
* Objekt am Rand der Karte oder ist das Zielfeld nicht
* {@link Feld#istPassierbar() passierbar}, passiert nichts.
*/
public void bewegeRunter( Gegner pGegner ) {
if (pGegner.zentrum().y < 14*48) {
Feld feld = feldAnKoordinate(pGegner.zentrum().x, pGegner.zentrum().y+48);
if( feld != null && feld.istPassierbar() ) {
verschiebeZuFeld(pGegner, feld);
}
}
}
/**
* Wird aufgerufen, wenn die Karte von der {@link Welt} angezeigt wird. Also
* dann, wenn {@link Lunk} sich über den Rand der aktuellen Karte hinaus
* auf diese Karte bewegt.
* <p>
* Hier kann z.B. die Bewegung der Monster gestartet werden, oder die
* Karte auf einen Startzustand zurückgesetzt werden.
*/
public void karteAnzeigen() {
// Starte die Gegner
for( Gegner g: gegner ) {
g.start();
}
}
/**
* Wird aufgerufen, wenn die Karte von der {@link Welt} versteckt wird. Also
* dann, wenn dies die aktuelle Karte ist und {@link Lunk} sich über den Rand
* der Karte hinaus auf eine andere Karte bewegt.
* <p>
* hier kann zum Beispiel die Bewegung der Monster gestoppt werden, etc.
*/
public void karteVerstecken() {
// StStoppe die Gegner
for( Gegner g: gegner ) {
g.stopp();
}
}
/**
* Fügt den Gegenstand dieser Karte auf dem Feld mit dem angegbenen Index hinzu.
* @param pGegenstand
*/
public void addGegenstand( int i, int j, Gegenstand pGegenstand ) {
verschiebeZuFeldAnIndex(pGegenstand, i, j);
add(pGegenstand);
gegenstaende.add(pGegenstand);
}
/**
* Fügt den Gegner dieser Karte auf dem dem Feld mit dem angegbenen Index hinzu.
* @param pGegener
*/
public void addGegner( int i, int j, Gegner pGegener ) {
verschiebeZuFeldAnIndex(pGegener, i, j);
add(pGegener);
gegner.add(pGegener);
}
/**
* Entfernt einen Gegenstand aus der Karte. Der Gegenstand wird nicht
* zerstört oder anderweitig modifiziert. Falls dies gewünscht ist,
* muss explizit im Programm passieren.
* @param pGegenstand
*/
public void entferneGegenstand( Gegenstand pGegenstand ) {
entfernen(pGegenstand);
gegenstaende.remove(pGegenstand);
}
/**
* Entfernt einen Gegner aus der Karte und dem Spiel. Der Ticker
* des Gegners wird gestoppt.
* @param pGegner
*/
public void entferneGegner( Gegner pGegner ) {
pGegner.stopp();
entfernen(pGegner);
gegner.remove(pGegner);
}
/**
* Gibt eine Liste aller Gegenstände zurück, die sich auf dieser Karte
* befinden.
* @return
*/
public ArrayList<Gegenstand> getGegenstaende() {
return this.gegenstaende;
}
/**
* Gibt eine Liste aller Gegner zurück, die sich auf dieser Karte befinden.
* @return
*/
public ArrayList<Gegner> getGegner() {
return this.gegner;
}
/**
* Gibt eine Liste aller {@link Gegner} zurück, die sich aktuell auf dem
* angegebenen Feld befinden.
* @param pFeld
* @return
*/
public ArrayList<Gegner> getGegnerAufFeld( Feld pFeld ) {
ArrayList<Gegner> list = new ArrayList<>(gegner.size());
for( Gegner g: gegner ) {
if (pFeld.beinhaltet(g.zentrum())) {
list.add(g);
}
}
return list;
}
/**
* Gibt eine Liste aller {@link Gegenstand Gegenstände} zurück, die sich
* aktuell auf dem angegebenen Feld befinden.
* @param pFeld
* @return
*/
public ArrayList<Gegenstand> getGegenstaendeAufFeld( Feld pFeld ) {
ArrayList<Gegenstand> list = new ArrayList<>(gegenstaende.size());
for( Gegenstand g: gegenstaende ) {
if (pFeld.beinhaltet(g.zentrum())) {
list.add(g);
}
}
return list;
}
}