Raum (Engine Alpha)

java.lang.Object
- ea.Raum

All Implemented Interfaces:

java.io.Serializable, java.lang.Comparable<Raum>

Direct Known Subclasses:

ActionFigur, Bild, CombiFigur, Figur, Geometrie, Knoten, Text
```
public abstract class Raum
extends java.lang.Object
implements java.io.Serializable, java.lang.Comparable<Raum>
```
Raum bezeichnet alles, was sich auf der Zeichenebene befindet.
Dies ist die absolute Superklasse aller grafischen Objekte. Umgekehrt kann somit jedes grafische Objekt die folgenden Methoden nutzen.

Author:

Michael Andonie, Niklas Keller

See Also:

Serialized Form

Field Summary

Fields
Modifier and Type	Field and Description
`static java.awt.Color[]`	`farbzyklus` Ein einfacher Farbzyklus, der fuer die Leucht-Animationen genommen wird
`protected Punkt`	`position` Die absolute Position des Raum-Objekts.
`protected static boolean`	`roh` Ob die Kollisionstests Roh oder fein ablaufen sollen.

Constructor Summary

Constructors
Constructor and Description

Raum()

Constructors
Constructor and Description
`Raum()`

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`afterRender(java.awt.Graphics2D g, BoundingRechteck r)` Dreht die Zeichenfläche wieder zurück in den Ausgangszustand.
`void`	`aktivMachen()` Macht dieses Objekt zu einem Aktiv-Objekt. Ab dem Aufruf dieser Methode laesst es sich von Passiv-Objekten aufhalten und wird - solange dies nicht ueber den Methodenaufruf `schwerkraftAktivSetzen(false)` deaktiviert wird - von einer kuenstlichen Schwerkraft angezogen.
`Collider`	`aktuellerCollider()` Gibt den aktuellen Collider dieses `Raum`-Objekts zurück.
`void`	`beeinflussbarSetzen(boolean beeinflussbar)` Physik-Methode - funktioniert nur bei Newton'schen Raum-Objekten Setzt, ob dieses `Raum`-Objekt beeinflussbar sein soll für Impulse von anderen Objekten, die mit diesem Kollidieren.
`void`	`beforeRender(java.awt.Graphics2D g, BoundingRechteck r)` Dreht die Zeichenfläche um den Mittelpunkt des Raumes um die gegebenen Grad, bevor mit dem Zeichenn begonnen wird. *Diese Methode sollte nicht außerhalb der Engine verwendet werden.*
`boolean`	`beinhaltet(Punkt p)` Prueft, ob ein bestimmter Punkt innerhalb des Raum-Objekts liegt.
`void`	`bewegen(float dX, float dY)` Bewegt dieses `Raum`-Objekt.
`boolean`	`bewegen(Vektor v)` Bewegt dieses `Raum`-Objekt.
`void`	`boundsUebernehmen(Raum boundHilfe)` Übernimmt für die Collision Detection die Bounds eines anderen `Raum`-Objektes.
`void`	`colliderSetzen(Collider collider)` Setzt einen neuen Collider für dieses `Raum`-Objekt.
`int`	`compareTo(Raum r)` Hilfsmethode für die Sortierung der Räume nach dem Z-Index.
`abstract BoundingRechteck`	`dimension()` Methode zum Beschreiben der rechteckigen Fläche, die dieses Objekt einnimmt. Diese Methode wird zentral für die Trefferkollisionen innerhalb der Engine benutzt und gehört zu den wichtigsten Methoden der Klasse und der Engine.
`void`	`drehenAbsolut(double grad)` Dreht ein Objekt auf die angegebene Gradzahl um den Mittelpunkt des Raumes.
`void`	`drehenRelativ(double grad)` Dreht ein Objekt um die angegebene Gradzahl um den Mittelpunkt des Raumes.
`void`	`einfluesseZuruecksetzen()` Physik-Methode - funktioniert nur bei Newton'schen Raum-Objekten Setzt alle Einflüsse auf dieses `Raum`-Objekt zurück.
`abstract Collider`	`erzeugeCollider()` Erzeugt einen neuen Collider für dieses Objekt.
`protected Collider`	`erzeugeLazyCollider()` Erzeugt einen Collider auf Lazy Art: Es wird das durch die `dimension()`-Methode berechnete `BoundingRechteck` benutzt, um einen simplen Box-Collider zu erstellen.
`void`	`fallReagierbarAnmelden(FallReagierbar f, int kritischeTiefe)` Meldet einen `FallReagierbar`-Listener an.
`BoundingRechteck[]`	`flaechen()` Berechnet exakter alle Rechteckigen Flaechen, auf denen dieses Objekt liegt. Diese Methode wird von komplexeren Gebilden, wie geometrischen oder Listen ueberschrieben.
`void`	`geschwindigkeitHinzunehmen(Vektor geschwindigkeit)` Physik-Methode - funktioniert nur bei Newton'schen Raum-Objekten Addiert hart (also ohne Rücksicht auf das Gewicht des Objekts) eine neue Geschwindigkeit auf die aktuelle Geschwindigkeit dieses `Raum`-Objektes.
`void`	`geschwindigkeitSetzen(Vektor geschwindigkeit)` Physik-Methode - funktioniert nur bei Newton'schen Raum-Objekten Setzt die Geschwindigkeit, die dieses `Raum`-Objekt haben soll.
`float`	`getBreite()` Gibt die Breite des Objekts zurück.
`Vektor`	`getForce()` Physik-Methode - funktioniert nur bei Newton'schen Raum-Objekten Gibt aus die Kraft aus, die auf dieses `Raum`-Objekt dauerhaft wirkt.
`float`	`getHoehe()` Gibt die Höhe des Objekts zurück.
`float`	`getMasse()` Physik-Methode - funktioniert nur bei Newton'schen Raum-Objekten Gibt aus die Masse dieses `Raum`-Objektes aus.
`float`	`getOpacity()` Gibt die aktuelle Opacity des Raumes zurück.
`float`	`getX()` Gibt die x-Koordinate der linken oberen Ecke zurück.
`float`	`getY()` Gibt die y-Koordinate der linken oberen Ecke zurück.
`double`	`gibDrehung()` Gibt die aktuelle Drehung des Raumes in Grad zurück.
`static java.awt.Color`	`halbesAlpha(java.awt.Color c)` Erstellt eine Halbdurchsichtige Farbe mit den selben RGB-Werten, wie die eingegebene. Diese Methode wird intern verwendet.
`static void`	`heavyComputingSetzen(boolean heavy)` Setzt, ob sämtliche Kollisionstests in der Engine Alpha grob oder fein sein sollen.
`int`	`hoehenUnterschied(Raum m)` Berechnet den Höhenunterschied zwischen dem Fuß des höheren und dem Kopf des tieferen Raum-Objekts.
`void`	`impulsHinzunehmen(Vektor impuls)` Physik-Methode - funktioniert nur bei Newton'schen Raum-Objekten Wirkt einen Impuls auf das `Raum`-Objekt aus.
`boolean`	`inFlaeche(BoundingRechteck r)` Prüft, ob dieses Raum-Objekt in ener bestimmten festen Fläche ist.
`boolean`	`istBeeinflussbar()` Physik-Methode - funktioniert nur bei Newton'schen Raum-Objekten Gibt aus, ob dieses `Raum`-Objekt beeinflussbar, also durch Impulse beweglich ist.
`void`	`konstanteKraftSetzen(Vektor kraft)` Physik-Methode - funktioniert nur bei Newton'schen Raum-Objekten Setzt die Kraft, die auf dieses `Raum`-Objekt dauerhaft wirken soll.
`void`	`kraftAnwenden(Vektor kraft, float t_kraftuebertrag)` Physik-Methode - funktioniert nur bei Newton'schen Raum-Objekten Setzt einen neuen Impuls auf dieses `Raum`-Objekt, indem eine bestimmte Kraft für eine bestimmte Zeit auf dieses Objekt wirkt.
`void`	`kritischeTiefeSetzen(int tiefe)` Setzt die kritische Tiefe neu.
`protected void`	`leuchterAbmelden(Leuchtend l)` Meldet ein Leuchtend-Objekt am vorgesehenen LeuchtMacher-Objekt ab. Prinzipiell sollte diese Methode nur innerhalb der Engine aufgerufen werden
`protected void`	`leuchterAnmelden(Leuchtend l)` Meldet ein Leuchtend-Objekt an dem vorgesehenen LeuchtErsteller Objekt an. Diese Methode ist dafür vorgesehen, dass sie nur im Konstruktor der dieses Interface implementierenden Instanz aufgerufen wird, und zwar mit dem `this`-Pointer, sprich: :`super.leuchterAnmelden(this);` Prinzipiell sollte diese Methode nur innerhalb der Engine aufgerufen werden
`void`	`loeschen()` Diese Methode loescht alle eventuell vorhandenen Referenzen innerhalb der Engine auf dieses Objekt, damit es problemlos geloescht werden kann. Achtung: zwar werden hierdurch alle Referenzen geloescht, die nur innerhalb der Engine liegen (dies betrifft vor allem Animationen etc), jedoch nicht die innerhalb eines `Knoten`-Objektes!!!!!!!!! Das heisst, wenn das Objekt an einem Knoten liegt (was immer der Fall ist, wenn es auch gezeichnet wird (siehe die Wurzel des Fensters)), muss es trotzdem selbst geloescht werden, dies erledigt diese Methode nicht!!.
`float`	`luftwiderstandskoeffizient()` Physik-Methode - funktioniert nur bei Newton'schen Raum-Objekten Gibt den Luftwiderstandskoeffizienten dieses `Raum-Objektes` aus.
`void`	`luftwiderstandskoeffizientSetzen(float luftwiderstandskoeffizient)` Physik-Methode - funktioniert nur bei Newton'schen Raum-Objekten Setzt den Luftwiderstandskoeffizienten für dieses `Raum`-Objekt.
`void`	`masseSetzen(float masse)` Physik-Methode - funktioniert nur bei Newton'schen Raum-Objekten Setzt die Masse für dieses `Raum`-Objekt.
`Punkt`	`mittelPunkt()` Methode zum schnellen Herausfinden des Mittelpunktes des Raum-Objektes.
`void`	`mittelpunktSetzen(int x, int y)` Verschiebt die Raum-Figur so, dass ihr Mittelpunkt die eingegebenen Koordinaten hat.
`void`	`mittelpunktSetzen(Punkt p)` Verschiebt die Raum-Figur so, dass ihr Mittelpunkt die eingegebenen Koordinaten hat. Diese Methode Arbeitet nach dem Mittelpunkt des das Objekt abdeckenden BoundingRechtecks durch den Aufruf der Methode `zentrum()`.
`void`	`neutralMachen()` Macht dieses `Raum`-Objekt fuer die Physik zu einem Neutralen Objekt, also einem Objekt das per se nicht an der Physik teilnimmt.
`void`	`newtonschMachen()` TODO: Dokumentation
`void`	`passivMachen()` Macht dieses Objekt zu einem Passiv-Objekt.
`Punkt`	`position()` Gibt die Position der linken oberen Ecke zurück.
`void`	`positionSetzen(float x, float y)` Setzt die Position des Objektes gänzlich neu auf der Zeichenebene.
`void`	`positionSetzen(Punkt p)` Setzt die Position des Objektes gänzlich neu auf der Zeichenebene.
`int`	`positionX()` Einfache Methode, die die X-Koordinate der linken oberen Ecke des das `Raum`-Objekt exakt umrandenden `BoundingRechteck`'s auf der Zeichenebene zurueckgibt.
`int`	`positionY()` Einfache Methode, die die Y-Koordinate der linken oberen Ecke des das `Raum`-Objekt exakt umrandenden `BoundingRechteck`'s auf der Zeichenebene zurueckgibt.
`protected static boolean`	`problem(int z1, int z2)` Interne Testmethode, die ein mathematisch simples Konzept hat. Es gibt kein Problem, wenn die Zahlen das selbe Vorzeichen haben oder wenn eine der beiden Zahlen gleich 0 ist.
`boolean`	`schneidet(Raum r)` Test, ob ein anderes Raum-Objekt von diesem geschnitten wird.
`void`	`schwerkraftAktivSetzen(boolean aktiv)` Setzt, ob dieses `Raum`-Objekt von Schwerkraft beeinflusst wird.
`void`	`schwerkraftSetzen(int schwerkraft)` Setzt die Schwerkraft fuer dieses spezielle Objekt. Achtung: Standardwert: 4 Groesserer Wert = langsamer Fallen Kleinerer Wert = schneller Fallen Negativer Wert : Moege Gott uns allen gnaedig sein...
`void`	`setOpacity(float opacity)` Setzt die Opacity des Raumes.
`void`	`setX(float x)` Setzt die x-Koordinate der Position des Objektes gänzlich neu auf der Zeichenebene.
`void`	`setY(float y)` Setzt die y-Koordinate der Position des Objektes gänzlich neu auf der Zeichenebene.
`void`	`setzeMeterProPixel(float mpp)` Setzt die Meter pro Pixel für die Zeichenebene.
`boolean`	`sichtbar()` Gibt an, ob das Raum-Objekt sichtbar ist.
`void`	`sichtbarSetzen(boolean sichtbar)` Setzt die Sichtbarkeit des Objektes.
`boolean`	`sprung(int kraft)` Laesst das `Raum`-Objekt einen Sprung von variabler Kraft machen.
`void`	`stehReagierbarAnmelden(StehReagierbar s)` Diese Methode meldet einen `StehReagierbar`-Listener neu an. Dieser wird nach der Anmeldung immer dann einmalig durch den Aufruf seiner `stehReagieren()`-Methode informiert, wenn dieses `Raum`-Objekt nach dem Fall/Sprung wieder auf einem Passiv-Objekt zu stehen kommt. ACHTUNG! Ein `Raum`-Objekt kann hoechstens einen `StehReagierbar`-Listener besitzen! Diese Methode mach natuerlich nur Sinn, wenn sie an einem Aktiv-Objekt ausgefuehrt wird.
`boolean`	`steht()` Prueft, ob dieses Objekt als Aktiv-Objekt steht. Diese Methode steht nicht in direktem Zusammenhang mit dem Interface `StehReagierbar`, denn durch diese Methode laesst sich zu jedem beliebigen Zeitpunkt erfragen, ob das `Raum`-Objekt steht, nicht jedoch - wie durch `StehReagierbar` - am genauen Zeitpunkt des zum Stehen kommens hierauf reagieren. Diese Methode macht natuerlich nur dann sinn, wenn sie an einem Aktiv-Objekt ausgefuehrt wird.
`boolean`	`stehtAuf(Raum m)` Berechnet, ob dieses Raum-Objekt exakt ueber einem zweiten steht. Dies waere fuer die Engine ein Stehen auf diesem.
`void`	`verschieben(float dX, float dY)` Verschiebt das Objekt. Hierbei wird nichts anderes gemacht, als `verschieben(new Vektor(dX, dY))` auszufuehren.
`void`	`verschieben(Vektor v)` Verschiebt das Objekt ohne Bedingungen auf der Zeichenebene.
`abstract void`	`zeichnen(java.awt.Graphics2D g, BoundingRechteck r)` Zeichnet das Objekt.
`void`	`zeichnenBasic(java.awt.Graphics2D g, BoundingRechteck r)` Die Basiszeichenmethode. Sie schließt eine Fallabfrage zur Sichtbarkeit ein.
`Punkt`	`zentrum()` Berechnet das Zentrum des Raum-Objekts als Punkt auf der Zeichenebene.
`void`	`zIndex(int z)` Setzt den Z-Index dieses Raumes.
`static java.awt.Color`	`zuFarbeKonvertieren(java.lang.String t)` Diese Methode ordnet einem String ein Color-Objekt zu. Hierdurch ist in den Klassen außerhalb der Engine keine awt-Klasse nötig.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - farbzyklus
```
public static final java.awt.Color[] farbzyklus
```
    Ein einfacher Farbzyklus, der fuer die Leucht-Animationen genommen wird
  - roh
```
protected static boolean roh
```
    Ob die Kollisionstests Roh oder fein ablaufen sollen.
  - position
```
protected Punkt position
```
    Die absolute Position des Raum-Objekts. Die Interpretation dieses Parameters hängt von den sich ableitenden Klassen ab. Er kann komplett irrelevant sein (Knoten), oder - im Regelfall - die linke obere Ecke des Objektes bezeichnen. Default
- Constructor Detail
  - Raum
```
public Raum()
```
- Method Detail
  - heavyComputingSetzen
```
public static void heavyComputingSetzen(boolean heavy)
```
    Setzt, ob sämtliche Kollisionstests in der Engine Alpha grob oder fein sein sollen.
    
    Parameters:
    
    heavy - Ist dieser Wert true, werden intern Kollisionstests genauer, aber rechenintensiver. Ist er false, werden diese Kollisionstests schneller, aber ungenauer.
    
    See Also:
    
    Game.rechenintensiveArbeitSetzen(boolean)
  - zuFarbeKonvertieren
```
public static java.awt.Color zuFarbeKonvertieren(java.lang.String t)
```
    Diese Methode ordnet einem String ein Color-Objekt zu.
    Hierdurch ist in den Klassen außerhalb der Engine keine awt-Klasse nötig.
    
    Parameters:
    
    t - Der Name der Farbe.
    Ein Katalog mit allen moeglichen Namen findet sich im Handbuch
    
    Returns:
    
    Das Farbobjekt zum String; ist Color.black bei unzuordnembaren String
  - halbesAlpha
```
public static final java.awt.Color halbesAlpha(java.awt.Color c)
```
    Erstellt eine Halbdurchsichtige Farbe mit den selben RGB-Werten, wie die eingegebene.
    Diese Methode wird intern verwendet.
    
    Parameters:
    
    c - Die Farbe, deren im Alphawert gesenkte Instanz erstellt werden soll.
  - problem
```
protected static boolean problem(int z1,
                                 int z2)
```
    Interne Testmethode, die ein mathematisch simples Konzept hat.
    Es gibt kein Problem, wenn die Zahlen das selbe Vorzeichen haben oder wenn eine der beiden Zahlen gleich 0 ist.
    
    Returns:
    
    true, falls diese Zahlenkonstellation ein Problem ist, sonst false.
  - zIndex
```
public void zIndex(int z)
```
    Setzt den Z-Index dieses Raumes. Je größer, desto weiter vorne wird ein Raum gezeichnet. Diese Methode muss ausgeführt werden, bevor der Raum zu einem Knoten hinzugefügt wird.
    
    Parameters:
    
    z - zu setzender Index
  - neutralMachen
```
public void neutralMachen()
```
    Macht dieses Raum-Objekt fuer die Physik zu einem Neutralen Objekt, also einem Objekt das per se nicht an der Physik teilnimmt.
  - passivMachen
```
public void passivMachen()
```
    Macht dieses Objekt zu einem Passiv-Objekt.
    Ab dem Aufruf dieser Methode verhaelt es sich als Boden-/Wand- bzw. Deckenelement und haelt Aktiv-Objekte auf.
  - aktivMachen
```
public void aktivMachen()
```
    Macht dieses Objekt zu einem Aktiv-Objekt.
    Ab dem Aufruf dieser Methode laesst es sich von Passiv-Objekten aufhalten und wird - solange dies nicht ueber den Methodenaufruf schwerkraftAktivSetzen(false) deaktiviert wird - von einer kuenstlichen Schwerkraft angezogen.
    
    See Also:
    
    schwerkraftAktivSetzen(boolean)
  - newtonschMachen
```
public void newtonschMachen()
```
    TODO: Dokumentation
  - sprung
```
public boolean sprung(int kraft)
```
    Laesst das Raum-Objekt einen Sprung von variabler Kraft machen. Dies funktioniert jedoch nur dann, wenn das Objekt auch ein Aktiv-Objekt ist. Ansonsten ist wird hier eine Fehlermeldung ausgegeben.
    
    Parameters:
    
    kraft - Die Kraft dieses Sprunges. Je hoeher dieser Wert, desto hoeher der Sprung.
    
    Returns:
    
    true, wenn das Raum-Objekt erfolgreich springen konnte. false, wenn das Raum-Objekt nicht springen konnte.
    Zweiteres ist automatisch immer dann der Fall, wenn
    - das Raum-Objekt kein Aktiv-Objekt mit aktivierter Schwerkraft (Standard) ist oder
    - das Raum-Objekt als Aktiv-Objekt nicht auf einem Passiv-Objekt steht.
  - schwerkraftAktivSetzen
```
public void schwerkraftAktivSetzen(boolean aktiv)
```
    Setzt, ob dieses Raum-Objekt von Schwerkraft beeinflusst wird. Macht nur dann Sinn, wenn das Objekt, an dem diese Methode ausgefuehrt wird, ein Aktiv-Objekt ist.
    
    Parameters:
    
    aktiv - true, wenn Schwerkraft aktiv sein soll, sonst false.
    
    See Also:
    
    aktivMachen()
  - schwerkraftSetzen
```
public void schwerkraftSetzen(int schwerkraft)
```
    Setzt die Schwerkraft fuer dieses spezielle Objekt.
    Achtung: Standardwert: 4
    Groesserer Wert = langsamer Fallen
    Kleinerer Wert = schneller Fallen
    Negativer Wert : Moege Gott uns allen gnaedig sein...
    
    Parameters:
    
    schwerkraft - Der Wert fuer die Schwerkraft der Physik.
    Wichtig: Dies repraesentiert keinen Wert fuer die (Erd-) Beschleunigungszahl "g" aus der Physik. Schon allein deshalb, weil die Zahl umgekehrt wirkt (s. oben).
    
    See Also:
    
    aktivMachen()
  - fallReagierbarAnmelden
```
public void fallReagierbarAnmelden(FallReagierbar f,
                                   int kritischeTiefe)
```
    Meldet einen FallReagierbar-Listener an.
    Dieser wird ab sofort immer dann informiert, wenn dieses Raum-Objekt unter eine bestimmte Höhe faellt. Diese wird als kritische Tiefe bezeichnet. Der Listener wird ab diesem Zeitpunkt dauerhaft aufgerufen, solange das Objekt unterhalb dieser Toleranzgrenze ist. Deshalb sollte in der implementierten Reaktionsmethode des FallReagierbar-Interfaces die Höhe so neu gesetzt werden, dass das Raum-Objekt nicht mehr unterhalb der kritischen Tiefe ist.
    ACHTUNG!
    Jedes Raum-Objekt hat HÖCHSTENS einen FallReagierbar-Listener. Das bedeutet, dass es nicht möglich ist, dass mehrere FallReagierbar-Listener über ein Objekt informiert werden.
    Die kritische Tiefe jedoch lässt sich problemlos immer wieder neu setzen, über die Methode kritischeTiefeSetzen(int tiefe).
    Diese Methode mach natürlich nur Sinn, wenn sie an einem Aktiv-Objekt ausgeführt wird. Andernfalls gibt es eine Fehlermeldung!
    
    Parameters:
    
    f - Das anzumeldende FallReagierbar
    
    kritischeTiefe - Die Tiefe ab der der Listener dauerhaft durch den Aufruf seiner Reaktionsmethode informiert wird, solange das Raum-Objekt hierunter ist.
    
    See Also:
    
    FallReagierbar, kritischeTiefeSetzen(int)
  - kritischeTiefeSetzen
```
public void kritischeTiefeSetzen(int tiefe)
```
    Setzt die kritische Tiefe neu. Ab dieser Tiefe wird der FallReagierbar-Listener dieses Raum-Objektes aufgerufen - dauerhaft so lange, bis das Raum-Objekt nicht mehr unterhalb dieser Tiefe ist.
    
    Parameters:
    
    tiefe - Die neue kritische Tiefe. Die Tiefe ab der der Listener dauerhaft durch den Aufruf seiner Reaktionsmethode informiert wird, solange das Raum-Objekt hierunter ist.
    
    See Also:
    
    FallReagierbar, fallReagierbarAnmelden(FallReagierbar, int)
  - stehReagierbarAnmelden
```
public void stehReagierbarAnmelden(StehReagierbar s)
```
    Diese Methode meldet einen StehReagierbar-Listener neu an.
    Dieser wird nach der Anmeldung immer dann einmalig durch den Aufruf seiner stehReagieren()-Methode informiert, wenn dieses Raum-Objekt nach dem Fall/Sprung wieder auf einem Passiv-Objekt zu stehen kommt.
    
    ACHTUNG!
    Ein Raum-Objekt kann hoechstens einen StehReagierbar-Listener besitzen!
    
    Diese Methode mach natuerlich nur Sinn, wenn sie an einem Aktiv-Objekt ausgefuehrt wird. Andernfalls gibt es eine Fehlermeldung!
    
    Parameters:
    
    s - Der StehReagierbar-Listener, der ab sofort bei jedem neuen zum Stehen kommen dieses Raum-Objekts informiert wird.
    
    See Also:
    
    StehReagierbar
  - steht
```
public boolean steht()
```
    Prueft, ob dieses Objekt als Aktiv-Objekt steht.
    Diese Methode steht nicht in direktem Zusammenhang mit dem Interface StehReagierbar, denn durch diese Methode laesst sich zu jedem beliebigen Zeitpunkt erfragen, ob das Raum-Objekt steht, nicht jedoch - wie durch StehReagierbar - am genauen Zeitpunkt des zum Stehen kommens hierauf reagieren.
    
    Diese Methode macht natuerlich nur dann sinn, wenn sie an einem Aktiv-Objekt ausgefuehrt wird. Andernfalls gibt es eine Fehlermeldung!
    
    Returns:
    
    true, wenn dieses Raum-Objekt als Aktiv-Objekt auf einem Passiv-Objekt steht. Steht dieses Raum-Objekt als Aktiv-Objekt nicht auf einem Passiv-Objekt, oder ist dieses Raum-Objekt kein Aktiv-Objekt, so ist die Rueckgabe false.
  - bewegen
```
public boolean bewegen(Vektor v)
```
    Bewegt dieses Raum-Objekt. Der Unterschied zum Verschieben ist folgender:
    Ist dieses Objekt in der Physik beteiligt, so ist dies eine Bewegung innerhalb der Physik und kein Stumpfes Verschieben.
    Ist dieses Objekt fuer die Physik neutral ist dies genauso wie verschieben.
    
    Parameters:
    
    v - Die Bewegung beschreibender Vektor
    
    Returns:
    
    true, wenn sich dieses Raum-Objekt ohne Probleme bewegen liess. Konnte es wegen der Physik (Aktiv-Objekt von Passiv-Objekt geblockt) nicht vollstaendig verschoben werden, so wird false zurueckgegeben.
    Die Rueckgabe ist bei Passiv-Objekten und neutralen Objekten immer true, da diese Problemlos verschoben werden können.
    
    See Also:
    
    bewegen(float, float), verschieben(Vektor), verschieben(float, float)
  - bewegen
```
public void bewegen(float dX,
                    float dY)
```
    Bewegt dieses Raum-Objekt. Der Unterschied zum Verschieben ist folgender:
    Ist dieses Objekt in der Physik beteiligt, so ist dies eine Bewegung innerhalb der Physik und kein Stumpfes Verschieben.
    Ist dieses Objekt fuer die Physik neutral ist dies genauso wie verschieben.
    
    Parameters:
    
    dX - Der X-Anteil der Verschiebung (Delta-X)
    
    dY - Der Y-Anteil der Verschiebung (Delta-Y)
    
    See Also:
    
    bewegen(Vektor), verschieben(Vektor), verschieben(float, float)
  - setzeMeterProPixel
```
public void setzeMeterProPixel(float mpp)
```
    Setzt die Meter pro Pixel für die Zeichenebene. Dies ist das dynamische Bindeglied zwischen der physikalisch möglichst korrekten Berechnung innerhalb der Engine sowie der freien Wählbarkeit der Zeichenebene.
    Parameters:
    mpp - Die Anzahl an Metern, die auf einen Pixel fallen.
    Beispiele:
    
    10(.0f) => Auf einen Pixel fallen 10 Meter. => Ein Meter = 0,1 Pixel
    
    0.1f => Auf einen Pixel fallen 0,1 Meter. => Ein Meter = 10 Pixel
    See Also:
    
    newtonschMachen()
  - impulsHinzunehmen
```
public void impulsHinzunehmen(Vektor impuls)
```
    Physik-Methode - funktioniert nur bei Newton'schen Raum-Objekten
    Wirkt einen Impuls auf das Raum-Objekt aus. Dieser ändert - abhängig von seiner Richtung, Intensität sowie von der Mass des Raum-Objekts eine Geschwindigkeitsänderung.
    
    Parameters:
    
    impuls - Der Impuls, der diesem Raum-Objekt zugeführt werden soll.
    WICHTIG: Die Einheiten für physikalische Größen innerhalb der Engine entsprechen denen aus der klassischen Mechanik. Die Einheit für Impuls ist [kg * (m / s)]
    
    See Also:
    
    masseSetzen(float), konstanteKraftSetzen(Vektor), setzeMeterProPixel(float), newtonschMachen()
  - geschwindigkeitHinzunehmen
```
public void geschwindigkeitHinzunehmen(Vektor geschwindigkeit)
```
    Physik-Methode - funktioniert nur bei Newton'schen Raum-Objekten
    Addiert hart (also ohne Rücksicht auf das Gewicht des Objekts) eine neue Geschwindigkeit auf die aktuelle Geschwindigkeit dieses Raum-Objektes. Die neue Geschwidig
    
    Parameters:
    
    geschwindigkeit - die Geschwindigkeit, die zu der aktuellen Geschwindigkeit von diesem Raum-Objekt. hinzuaddiert werden soll. Die neue Geschwindigkeit ist damit v1 + v2.
    WICHTIG: Die Einheiten für physikalische Größen innerhalb der Engine entsprechen denen aus der klassischen Mechanik. Die Einheit für Geschwindigkeit ist [m / s]
    
    See Also:
    
    masseSetzen(float), konstanteKraftSetzen(Vektor), setzeMeterProPixel(float), luftwiderstandskoeffizientSetzen(float), newtonschMachen()
  - luftwiderstandskoeffizient
```
public float luftwiderstandskoeffizient()
```
    Physik-Methode - funktioniert nur bei Newton'schen Raum-Objekten
    Gibt den Luftwiderstandskoeffizienten dieses Raum-Objektes aus.
    
    See Also:
    
    luftwiderstandskoeffizientSetzen(float), newtonschMachen()
  - istBeeinflussbar
```
public boolean istBeeinflussbar()
```
    Physik-Methode - funktioniert nur bei Newton'schen Raum-Objekten
    Gibt aus, ob dieses Raum-Objekt beeinflussbar, also durch Impulse beweglich ist. Was das heisst, kannst Du in der Setter-Methode nachlesen.
    
    Returns:
    
    true, falls dieses Raum-Objekt beeinflussbar ist, sonst false.
    
    See Also:
    
    beeinflussbarSetzen(boolean), newtonschMachen()
  - getMasse
```
public float getMasse()
```
    Physik-Methode - funktioniert nur bei Newton'schen Raum-Objekten
    Gibt aus die Masse dieses Raum-Objektes aus. Diese ist relevant Impulsrechnungen, z.B. wenn 2 Objekte kollidieren.
    
    Returns:
    
    die Masse dieses Raum-Objektes in korrekter Einheit. WICHTIG: Die Einheiten für physikalische Größen innerhalb der Engine entsprechen denen aus der klassischen Mechanik. Die Einheit für Masse ist [kg]
    
    See Also:
    
    masseSetzen(float), newtonschMachen()
  - getForce
```
public Vektor getForce()
```
    Physik-Methode - funktioniert nur bei Newton'schen Raum-Objekten
    Gibt aus die Kraft aus, die auf dieses Raum-Objekt dauerhaft wirkt. So lässt sich z.B. eine dynamische Schwerkraft realisieren.
    
    Returns:
    
    die Kraft, die auf dieses Raum-Objektes konstant wirkt. WICHTIG: Die Einheiten für physikalische Größen innerhalb der Engine entsprechen denen aus der klassischen Mechanik. Die Einheit für Kraft ist [N] = [kg * (m / s^2)]
    
    See Also:
    
    beeinflussbarSetzen(boolean), newtonschMachen()
  - luftwiderstandskoeffizientSetzen
```
public void luftwiderstandskoeffizientSetzen(float luftwiderstandskoeffizient)
```
    Physik-Methode - funktioniert nur bei Newton'schen Raum-Objekten
    Setzt den Luftwiderstandskoeffizienten für dieses Raum-Objekt. Je größer dieser Wert ist, desto stärker ist der Luftwiderstand auf das Raum-Objekt.
    Der Luftwiderstand nicht über die vollständige Luftwiderstandsformel (u.a. mit Querschnittsfläche des Körpers) berechnet. Der Luftwiderstand berechnet sich ausschließlich aus der Geschwindigkeit und dieses Luftwiderstandskoeffizienten:
    (F_w = luftwiderstandskoeffizient * v^2)
    
    Parameters:
    
    luftwiderstandskoeffizient - Der Luftwiderstandskoeffizient, der für dieses Raum-Objekt gelten soll. Ist dieser Wert 0, so wirkt kein Luftwiderstand auf das Objekt.
    
    See Also:
    
    luftwiderstandskoeffizient(), newtonschMachen()
  - beeinflussbarSetzen
```
public void beeinflussbarSetzen(boolean beeinflussbar)
```
    Physik-Methode - funktioniert nur bei Newton'schen Raum-Objekten
    Setzt, ob dieses Raum-Objekt beeinflussbar sein soll für Impulse von anderen Objekten, die mit diesem Kollidieren. Ist es nicht beeinflussbar, so prallen (beeinflussbare) Objekte einfach an ihm ab. Typische unbeeinflussbare Objekte sind:
    - Böden
    - Wände
    - Decken
    - bewegliche Plattformen
    Ist ein Raum-Objekt beeinflussbar, so kann es an anderen Objekten abprallen bzw. von ihnen blockiert werden. Es kann sie nicht verschieben. Typische beeinflussbare Objekte sind:
    - Spielfiguren
    Diese Eigenschaft kann beliebig oft durchgewechselt werden.
    Parameters:
    
    beeinflussbar - ist dieser Wert true, so ist dieses Objekt ab sofort beeinflussbar. Sonst ist es ab sofort nicht beeinflussbar.
    
    See Also:
    
    istBeeinflussbar(), newtonschMachen()
  - masseSetzen
```
public void masseSetzen(float masse)
```
    Physik-Methode - funktioniert nur bei Newton'schen Raum-Objekten
    Setzt die Masse für dieses Raum-Objekt. Es hat ab sofort diese Masse. Diese hat Auswirkungen auf Impulsrechnung und die Dynamik dieses Objekts..
    
    Parameters:
    
    masse - die Mass, die dieses Raum-Objekt ab sofort haben soll. WICHTIG: Die Einheiten für physikalische Größen innerhalb der Engine entsprechen denen aus der klassischen Mechanik. Die Einheit für Masse ist [kg]
    
    See Also:
    
    getMasse(), newtonschMachen()
  - konstanteKraftSetzen
```
public void konstanteKraftSetzen(Vektor kraft)
```
    Physik-Methode - funktioniert nur bei Newton'schen Raum-Objekten
    Setzt die Kraft, die auf dieses Raum-Objekt dauerhaft wirken soll. So lässt sich z.B. eine dynamische Schwerkraft realisieren:
    Die Schwerkraft, wäre eine Kraft, die dauerhaft nach unten wirkt, also zum Beispiel:
    Kreis ball = ... [...] ball.kraftSetzen(new Vektor(0,9.81)); // Setze eine Schwerkraft mit 9,81 kg * m/s^2
    
    Parameters:
    
    kraft - die Kraft, die auf dieses Raum-Objekt konstant wirken soll. WICHTIG: Die Einheiten für physikalische Größen innerhalb der Engine entsprechen denen aus der klassischen Mechanik. Die Einheit für Kraft ist [N] = [kg * (m / s^2)]
    
    See Also:
    
    getForce(), newtonschMachen()
  - geschwindigkeitSetzen
```
public void geschwindigkeitSetzen(Vektor geschwindigkeit)
```
    Physik-Methode - funktioniert nur bei Newton'schen Raum-Objekten
    Setzt die Geschwindigkeit, die dieses Raum-Objekt haben soll.
    
    Parameters:
    
    geschwindigkeit - die Geschwindikeit, die auf dieses Raum-Objekt mit sofortiger Wirkung annehmen soll. WICHTIG: Die Einheiten für physikalische Größen innerhalb der Engine entsprechen denen aus der klassischen Mechanik. Die Einheit für Geschwindigkeit ist [m / s]
    
    See Also:
    
    newtonschMachen()
  - einfluesseZuruecksetzen
```
public void einfluesseZuruecksetzen()
```
    Physik-Methode - funktioniert nur bei Newton'schen Raum-Objekten
    Setzt alle Einflüsse auf dieses Raum-Objekt zurück. Dies bedeutet: * die auf dieses Objekt einwirkende, konstante Kraft wird 0. * die Geschwindigkeit dieses Objekts wird 0.
    
    See Also:
    
    newtonschMachen()
  - kraftAnwenden
```
public void kraftAnwenden(Vektor kraft,
                          float t_kraftuebertrag)
```
    Physik-Methode - funktioniert nur bei Newton'schen Raum-Objekten
    Setzt einen neuen Impuls auf dieses Raum-Objekt, indem eine bestimmte Kraft für eine bestimmte Zeit auf dieses Objekt wirkt.
    Es gilt für ausreichend kleines t: p = F * t
    Dies ist die grundlegende Berechnung für den Impuls.
    
    Parameters:
    
    kraft - Eine Kraft, die (modellhaft) auf dieses Raum-Objekt wirken soll. WICHTIG: Die Einheiten für physikalische Größen innerhalb der Engine entsprechen denen aus der klassischen Mechanik. Die Einheit für Kraft ist [N] = [kg * (m / s^2)]
    
    t_kraftuebertrag - Die Zeit, über die die obige Kraft auf dieses Raum-Objekt wirken soll. WICHTIG: Die Einheiten für physikalische Größen innerhalb der Engine entsprechen denen aus der klassischen Mechanik. Die Einheit für Zeit ist [s]
    
    See Also:
    
    newtonschMachen()
  - sichtbarSetzen
```
public final void sichtbarSetzen(boolean sichtbar)
```
    Setzt die Sichtbarkeit des Objektes.
    
    Parameters:
    
    sichtbar - Ob das Objekt sichtbar sein soll oder nicht.
    Ist dieser Wert false, so wird es nicht im Fenster gezeichnet.
    Aber: Es existiert weiterhin ohne Einschraenkungen. Allerdings gilt ein Treffer mit einem unsichtbaren Raum-Objekt in der Klasse Physik nicht als Kollision. Unsichtbare Raum-Objekte werden somit bei Trefferkollisionen ausgelassen.
    
    See Also:
    
    sichtbar(), Physik
  - sichtbar
```
public final boolean sichtbar()
```
    Gibt an, ob das Raum-Objekt sichtbar ist.
    
    Returns:
    
    Ist true, wenn das Raum-Objekt zur Zeit sichtbar ist.
    
    See Also:
    
    sichtbarSetzen(boolean)
  - leuchterAnmelden
```
protected final void leuchterAnmelden(Leuchtend l)
```
    Meldet ein Leuchtend-Objekt an dem vorgesehenen LeuchtErsteller Objekt an.
    Diese Methode ist dafür vorgesehen, dass sie nur im Konstruktor der dieses Interface implementierenden Instanz aufgerufen wird, und zwar mit dem this-Pointer, sprich:
    :super.leuchterAnmelden(this);
    Prinzipiell sollte diese Methode nur innerhalb der Engine aufgerufen werden
    
    Parameters:
    
    l - Der anzumeldende Leuchter
  - leuchterAbmelden
```
protected final void leuchterAbmelden(Leuchtend l)
```
    Meldet ein Leuchtend-Objekt am vorgesehenen LeuchtMacher-Objekt ab.
    Prinzipiell sollte diese Methode nur innerhalb der Engine aufgerufen werden
    
    Parameters:
    
    l - Der abzumeldende Leuchter
  - zeichnenBasic
```
public final void zeichnenBasic(java.awt.Graphics2D g,
                                BoundingRechteck r)
```
    Die Basiszeichenmethode.
    Sie schließt eine Fallabfrage zur Sichtbarkeit ein. Diese Methode wird bei den einzelnen Gliedern eines Knotens aufgerufen.
    
    Parameters:
    
    g - Das zeichnende Graphics-Objekt
    
    r - Das BoundingRechteck, dass die Kameraperspektive Repraesentiert.
    Hierbei soll zunaechst getestet werden, ob das Objekt innerhalb der Kamera liegt, und erst dann gezeichnet werden.
    
    See Also:
    
    zeichnen(Graphics2D, BoundingRechteck)
  - zeichnen
```
public abstract void zeichnen(java.awt.Graphics2D g,
                              BoundingRechteck r)
```
    Zeichnet das Objekt.
    
    Parameters:
    
    g - Das zeichnende Graphics-Objekt
    
    r - Das BoundingRechteck, dass die Kameraperspektive Repraesentiert.
    Hierbei soll zunaechst getestet werden, ob das Objekt innerhalb der Kamera liegt, und erst dann gezeichnet werden.
  - positionSetzen
```
public void positionSetzen(float x,
                           float y)
```
    Setzt die Position des Objektes gänzlich neu auf der Zeichenebene. Das Setzen ist technisch gesehen eine Verschiebung von der aktuellen Position an die neue.
    
    Achtung!
    Bei allen Objekten ist die eingegebene Position die linke, obere Ecke des Rechtecks, das die Figur optimal umfasst. Das heißt, dass dies bei Kreisen z.B. nicht der Mittelpunkt ist! Hierfür gibt es die Sondermethode mittelpunktSetzen(int x, int y).
    
    Parameters:
    
    x - neue x-Koordinate
    
    y - neue y-Koordinate
    
    See Also:
    
    positionSetzen(Punkt), mittelpunktSetzen(int, int), setX(float), setY(float)
  - positionSetzen
```
public void positionSetzen(Punkt p)
```
    Setzt die Position des Objektes gänzlich neu auf der Zeichenebene. Das Setzen ist technisch gesehen eine Verschiebung von der aktuellen Position an die neue.
    
    Achtung!
    Bei allen Objekten ist die eingegebene Position die linke, obere Ecke des Rechtecks, das die Figur optimal umfasst. Das heißt, dass dies bei Kreisen z.B. nicht der Mittelpunkt ist! Hierfür gibt es die Sondermethode mittelpunktSetzen(int x, int y).
    
    Parameters:
    
    p - Der neue Zielpunkt
    
    See Also:
    
    positionSetzen(float, float), mittelpunktSetzen(int, int), setX(float), setY(float)
  - dimension
```
public abstract BoundingRechteck dimension()
```
    Methode zum Beschreiben der rechteckigen Fläche, die dieses Objekt einnimmt.
    Diese Methode wird zentral für die Trefferkollisionen innerhalb der Engine benutzt und gehört zu den wichtigsten Methoden der Klasse und der Engine.
    
    Returns:
    
    Ein BoundingRechteck mit minimal nötigen Umfang, um das Objekt voll einzuschliessen.
  - verschieben
```
public void verschieben(Vektor v)
```
    Verschiebt das Objekt ohne Bedingungen auf der Zeichenebene. Dies ist die zentrale Methode zum
    
    Parameters:
    
    v - Der Vektor, der die Verschiebung des Objekts angibt.
    
    See Also:
    
    Vektor, verschieben(float, float), bewegen(Vektor), bewegen(float, float)
  - mittelpunktSetzen
```
public void mittelpunktSetzen(int x,
                              int y)
```
    Verschiebt die Raum-Figur so, dass ihr Mittelpunkt die eingegebenen Koordinaten hat.
    Diese Methode arbeitet nach dem Mittelpunkt des das Objekt abdeckenden BoundingRechtecks durch den Aufruf der Methode zentrum(). Daher ist diese Methode in der Anwendung auf ein Knoten-Objekt nicht unbedingt sinnvoll.
    
    Parameters:
    
    x - Die x-Koordinate des neuen Mittelpunktes des Objektes
    
    y - Die y-Koordinate des neuen Mittelpunktes des Objektes
    
    See Also:
    
    mittelpunktSetzen(Punkt), verschieben(Vektor), positionSetzen(float, float), zentrum()
  - mittelpunktSetzen
```
public void mittelpunktSetzen(Punkt p)
```
    Verschiebt die Raum-Figur so, dass ihr Mittelpunkt die eingegebenen Koordinaten hat.
    Diese Methode Arbeitet nach dem Mittelpunkt des das Objekt abdeckenden BoundingRechtecks durch den Aufruf der Methode zentrum(). Daher ist diese Methode im Anwand auf ein Knoten-Objekt nicht unbedingt sinnvoll.
    Macht dasselbe wie mittelPunktSetzen(p.x, p.y).
    
    Parameters:
    
    p - Der neue Mittelpunkt des Raum-Objekts
    
    See Also:
    
    mittelpunktSetzen(int, int), verschieben(Vektor), positionSetzen(float, float), zentrum()
  - getX
```
public float getX()
```
    Gibt die x-Koordinate der linken oberen Ecke zurück. Sollte das Raumobjekt nicht rechteckig sein, so wird die Position der linken oberen Ecke des umschließenden Rechtecks genommen.
    TODO: Deprecate positionX() in favor of this new method?
    
    Returns:
    
    x-Koordinate
    
    See Also:
    
    getY(), position()
  - zentrum
```
public Punkt zentrum()
```
    Berechnet das Zentrum des Raum-Objekts als Punkt auf der Zeichenebene.
    Das Zentrum wird über die Methode dimension() berechnet, und zwar über die Methode des resultierenden BoundingRechtecks:
    dimension().zentrum()
    
    Returns:
    
    Zentrum dieses Raumobjekts
  - getBreite
```
public float getBreite()
```
    Gibt die Breite des Objekts zurück. Entspricht einem Aufruf von raum.dimension().breite.
    
    Returns:
    
    Breite des Objekts
    
    See Also:
    
    dimension()
  - setX
```
public void setX(float x)
```
    Setzt die x-Koordinate der Position des Objektes gänzlich neu auf der Zeichenebene. Das Setzen ist technisch gesehen eine Verschiebung von der aktuellen Position an die neue.
    
    Achtung!
    Bei allen Objekten ist die eingegebene Position die linke, obere Ecke des Rechtecks, das die Figur optimal umfasst. Das heißt, dass dies bei Kreisen z.B. nicht der Mittelpunkt ist! Hierfür gibt es die Sondermethode mittelpunktSetzen(int x, int y).
    
    Parameters:
    
    x - neue x-Koordinate
    
    See Also:
    
    positionSetzen(float, float), mittelpunktSetzen(int, int), setY(float)
  - getHoehe
```
public float getHoehe()
```
    Gibt die Höhe des Objekts zurück. Entspricht einem Aufruf von raum.dimension().hoehe.
    
    Returns:
    
    Höhe des Objekts
    
    See Also:
    
    dimension()
  - positionX
```
public int positionX()
```
    Einfache Methode, die die X-Koordinate der linken oberen Ecke des das Raum-Objekt exakt umrandenden BoundingRechteck's auf der Zeichenebene zurueckgibt.
    
    Returns:
    
    Die die X-Koordinate der linken oberen Ecke auf der Zeichenebene
  - getY
```
public float getY()
```
    Gibt die y-Koordinate der linken oberen Ecke zurück. Sollte das Raumobjekt nicht rechteckig sein, so wird die Position der linken oberen Ecke des umschließenden Rechtecks genommen.
    TODO: Deprecate positionX() in favor of this new method?
    
    Returns:
    
    y-Koordinate
    
    See Also:
    
    getX(), position()
  - positionY
```
public int positionY()
```
    Einfache Methode, die die Y-Koordinate der linken oberen Ecke des das Raum-Objekt exakt umrandenden BoundingRechteck's auf der Zeichenebene zurueckgibt.
    
    Returns:
    
    Die die Y-Koordinate der linken oberen Ecke auf der Zeichenebene
  - schneidet
```
public final boolean schneidet(Raum r)
```
    Test, ob ein anderes Raum-Objekt von diesem geschnitten wird.
    
    Parameters:
    
    r - Das Objekt, das auf Kollision mit diesem getestet werden soll.
    
    Returns:
    
    TRUE, wenn sich beide Objekte schneiden.
  - setY
```
public void setY(float y)
```
    Setzt die y-Koordinate der Position des Objektes gänzlich neu auf der Zeichenebene. Das Setzen ist technisch gesehen eine Verschiebung von der aktuellen Position an die neue.
    
    Achtung!
    Bei allen Objekten ist die eingegebene Position die linke, obere Ecke des Rechtecks, das die Figur optimal umfasst. Das heißt, dass dies bei Kreisen z.B. nicht der Mittelpunkt ist! Hierfür gibt es die Sondermethode mittelpunktSetzen(int x, int y).
    
    Parameters:
    
    y - neue y-Koordinate
    
    See Also:
    
    positionSetzen(float, float), mittelpunktSetzen(int, int), setX(float)
  - aktuellerCollider
```
public final Collider aktuellerCollider()
```
    Gibt den aktuellen Collider dieses Raum-Objekts zurück.
    
    Returns:
    
    der aktuelle Collider dieses Raum-Objekts, der für die Collision Detection verwendet wird.
    
    See Also:
    
    colliderSetzen(Collider), schneidet(Raum)
  - erzeugeCollider
```
public abstract Collider erzeugeCollider()
```
    Erzeugt einen neuen Collider für dieses Objekt. Diese Methode approximiert für das Objekt der jeweils implementierenden Raum-Klasse einen möglichst "guten" Collider; also einen solchen, der das tatsächliche Objekt möglichst genau umfängt, aber auch möglichst wenig Rechenarbeit beansprucht.
    
    Returns:
    
    Ein möglichst optimaler Collider für dieses Raum-Objekt.
    
    See Also:
    
    colliderSetzen(Collider)
  - beforeRender
```
@NoExternalUse
public final void beforeRender(java.awt.Graphics2D g,
                                              BoundingRechteck r)
```
    Dreht die Zeichenfläche um den Mittelpunkt des Raumes um die gegebenen Grad, bevor mit dem Zeichenn begonnen wird.
    Diese Methode sollte nicht außerhalb der Engine verwendet werden.
    
    See Also:
    
    drehung, gibDrehung(), zeichnen(Graphics2D, BoundingRechteck), afterRender(Graphics2D, BoundingRechteck)
  - mittelPunkt
```
public Punkt mittelPunkt()
```
    Methode zum schnellen Herausfinden des Mittelpunktes des Raum-Objektes.
    
    Returns:
    
    Die Koordinaten des Mittelpunktes des Objektes
    
    See Also:
    
    dimension(), position()
  - afterRender
```
@NoExternalUse
public final void afterRender(java.awt.Graphics2D g,
                                             BoundingRechteck r)
```
    Dreht die Zeichenfläche wieder zurück in den Ausgangszustand. Diese Methode sollte nicht außerhalb der Engine verwendet werden.
    
    See Also:
    
    drehung, gibDrehung(), zeichnen(Graphics2D, BoundingRechteck), beforeRender(Graphics2D, BoundingRechteck)
  - beinhaltet
```
public final boolean beinhaltet(Punkt p)
```
    Prueft, ob ein bestimmter Punkt innerhalb des Raum-Objekts liegt.
    
    Parameters:
    
    p - Der Punkt, der auf Inhalt im Objekt getestet werden soll.
    
    Returns:
    
    TRUE, wenn der Punkt innerhalb des Objekts liegt.
  - flaechen
```
public BoundingRechteck[] flaechen()
```
    Berechnet exakter alle Rechteckigen Flaechen, auf denen dieses Objekt liegt.
    Diese Methode wird von komplexeren Gebilden, wie geometrischen oder Listen ueberschrieben.
    
    Returns:
    
    Alle Rechtecksflaechen, auf denen dieses Objekt liegt. Ist standartisiert ein Array der Groesse 1 mit der dimension() als Inhalt.
    
    See Also:
    
    Knoten
  - erzeugeLazyCollider
```
protected Collider erzeugeLazyCollider()
```
    Erzeugt einen Collider auf Lazy Art: Es wird das durch die dimension()-Methode berechnete BoundingRechteck benutzt, um einen simplen Box-Collider zu erstellen.
  - verschieben
```
public void verschieben(float dX,
                        float dY)
```
    Verschiebt das Objekt.
    Hierbei wird nichts anderes gemacht, als verschieben(new Vektor(dX, dY)) auszufuehren. Insofern ist diese Methode dafuer gut, sich nicht mit der Klasse Vektor auseinandersetzen zu muessen.
    
    Parameters:
    
    dX - Die Verschiebung in Richtung X
    
    dY - Die Verschiebung in Richtung Y
    
    See Also:
    
    verschieben(Vektor), bewegen(Vektor), bewegen(float, float)
  - colliderSetzen
```
public void colliderSetzen(Collider collider)
```
    Setzt einen neuen Collider für dieses Raum-Objekt. Nach Aufruf dieser Methode ist der standardisierte Collider, der intern automatisch gesetzt wird (jedoch meist nicht optimal ist), außer Kraft und nur noch der hier übergebene Collider ist für die Collision Detection relevant.
    
    Parameters:
    
    collider - Der neue Collider, der für die Schnitt-Überprüfung verwendet wird.
    
    See Also:
    
    schneidet(Raum), boundsUebernehmen(Raum)
  - boundsUebernehmen
```
public void boundsUebernehmen(Raum boundHilfe)
```
    Übernimmt für die Collision Detection die Bounds eines anderen Raum-Objektes.
    
    Parameters:
    
    boundHilfe - Ein weiteres Raum-Objekt, dessen prinzipiellen Bounds übernommen werden sollen.
    
    WICHTIG! Die Entfernung des als Parameter übergebenen Raum-Objektes vom Ursprung der Zeichenebene aus entspricht dem Offset des Colliders relativ zu diesem Raum-Objekt.
    
    See Also:
    
    colliderSetzen(Collider)
  - position
```
public Punkt position()
```
    Gibt die Position der linken oberen Ecke zurück. Sollte das Raumobjekt nicht rechteckig sein, so wird die Position der linken oberen Ecke des umschließenden Rechtecks genommen.
    
    Mehr Informationen liefert die Methode dimension().
    
    Returns:
    
    Die Koordinaten des Punktes der linken, oberen Ecke in Form eines Punkt-Objektes
    
    See Also:
    
    dimension()
  - stehtAuf
```
public boolean stehtAuf(Raum m)
```
    Berechnet, ob dieses Raum-Objekt exakt ueber einem zweiten steht.
    Dies waere fuer die Engine ein Stehen auf diesem.
    
    Parameters:
    
    m - Das Raum-Objekt, fuer das getestet werden soll, ob dieses auf ihm steht,
    
    Returns:
    
    true, wenn dieses Objekt auf dem eingegeben steht, sonst false
  - hoehenUnterschied
```
public int hoehenUnterschied(Raum m)
```
    Berechnet den Höhenunterschied zwischen dem Fuß des höheren und dem Kopf des tieferen Raum-Objekts.
    
    Parameters:
    
    m - Das Raum-Objekt, dessen Höhenunterschied zu diesem gefunden werden soll
    
    Returns:
    
    Der absolute (also niemals negative) Unterschied in der Höhe zwiscchen den beiden Objekten. Überlagern sie sich, so ist der Rückgabewert 0!
  - loeschen
```
public void loeschen()
```
    Diese Methode loescht alle eventuell vorhandenen Referenzen innerhalb der Engine auf dieses Objekt, damit es problemlos geloescht werden kann.
    Achtung: zwar werden hierdurch alle Referenzen geloescht, die nur innerhalb der Engine liegen (dies betrifft vor allem Animationen etc), jedoch nicht die innerhalb eines Knoten-Objektes!!!!!!!!!
    Das heisst, wenn das Objekt an einem Knoten liegt (was immer der Fall ist, wenn es auch gezeichnet wird (siehe die Wurzel des Fensters)), muss es trotzdem selbst geloescht werden, dies erledigt diese Methode nicht!!.
  - inFlaeche
```
public boolean inFlaeche(BoundingRechteck r)
```
    Prüft, ob dieses Raum-Objekt in ener bestimmten festen Fläche ist.
    
    Parameters:
    
    r - Die kritische Fläche, auf deren schneiden mit diesem Raum-Objekt getestet werden soll.
    
    Returns:
    
    true, wenn dieses Raum-Objekt sich mit dem BoundingRechteck schneidet, sonst false.
  - gibDrehung
```
public double gibDrehung()
```
    Gibt die aktuelle Drehung des Raumes in Grad zurück.
    
    Returns:
    
    Gibt die aktuelle Drehung des Raumes in Grad zurück.
  - drehenAbsolut
```
public void drehenAbsolut(double grad)
```
    Dreht ein Objekt auf die angegebene Gradzahl um den Mittelpunkt des Raumes.
    
    Parameters:
    
    grad - Grad, auf die gedreht werden soll.
  - drehenRelativ
```
public void drehenRelativ(double grad)
```
    Dreht ein Objekt um die angegebene Gradzahl um den Mittelpunkt des Raumes.
    
    Parameters:
    
    grad - Grad, um die gedreht werden soll.
  - getOpacity
```
@API
public float getOpacity()
```
    Gibt die aktuelle Opacity des Raumes zurück.
    
    Returns:
    
    Gibt die aktuelle Opacity des Raumes zurück.
  - setOpacity
```
@API
public void setOpacity(float opacity)
```
    Setzt die Opacity des Raumes.
    - 0.0f entspricht einem komplett durchsichtigen Raum.
    - 1.0f entspricht einem undurchsichtigem Raum.
  - compareTo
```
@NoExternalUse
public int compareTo(Raum r)
```
    Hilfsmethode für die Sortierung der Räume nach dem Z-Index. Diese Methode sollte nicht außerhalb der Engine verwendet werden.
    
    Specified by:
    
    compareTo in interface java.lang.Comparable<Raum>
    
    See Also:
    
    zIndex, zIndex(int)

Class Raum

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

farbzyklus

roh

position

Constructor Detail

Raum

Method Detail

heavyComputingSetzen

zuFarbeKonvertieren

halbesAlpha

problem

zIndex

neutralMachen

passivMachen

aktivMachen

newtonschMachen

sprung

schwerkraftAktivSetzen

schwerkraftSetzen

fallReagierbarAnmelden

kritischeTiefeSetzen

stehReagierbarAnmelden

steht

bewegen

bewegen

setzeMeterProPixel

impulsHinzunehmen

geschwindigkeitHinzunehmen

luftwiderstandskoeffizient

istBeeinflussbar

getMasse

getForce

luftwiderstandskoeffizientSetzen

beeinflussbarSetzen

masseSetzen

konstanteKraftSetzen

geschwindigkeitSetzen

einfluesseZuruecksetzen

kraftAnwenden

sichtbarSetzen

sichtbar

leuchterAnmelden

leuchterAbmelden

zeichnenBasic

zeichnen

positionSetzen

positionSetzen

dimension

verschieben

mittelpunktSetzen

mittelpunktSetzen

getX

zentrum

getBreite

setX

getHoehe

positionX

getY

positionY

schneidet

setY

aktuellerCollider

erzeugeCollider

beforeRender

mittelPunkt

afterRender

beinhaltet

flaechen

erzeugeLazyCollider

verschieben

colliderSetzen

boundsUebernehmen

position

stehtAuf

hoehenUnterschied