class Situation : public StorableObject

Eine Spielsituation

Inheritance:


Public

Abfragen zum Abseits
bool isOffsideWithIndex( int index )
Testet, ob ein Teammate im Abseits steht
bool isOffsideWithId( int playerId )
Testet, ob ein Teammate im Abseits steht
double offsideLineX()
Liefert die X-Koordinate der Abseitslinie
const Reliability& Situation::offsideLineXReliability()
Verlaesslichkeit der Abseitsdaten
Abfragen zur Erreichbarkeit des Balls
int indexOfNearestPlayer( int teamId = BOTH_TEAMS_ID )
Gibt den Index des Spielers zurück, der den Ball am schnellsten erreichen kann
const ModelledPlayer& nearestPlayer( int teamId = BOTH_TEAMS_ID )
Gibt den nächsten Spieler zurück, der den Ball am schnellsten erreichen kann
int stepsOfNearestPlayer( int teamId = BOTH_TEAMS_ID )
Gibt die benötigten Schritte zum Ball des Spielers zurück der den Ball am schnellsten erreichen kann
bool isOneOfTheNearestTeammatesToBall( int id )
Sagt aus, ob der angegebene Spieler einer derjenigen ist, der den Ball als schnellstes erreichen kann
const Array <int> & getOurTeamSorted()
Gibt das nearestTeammatesSorted-Array als const zurueck
const Array <int> & getTheirTeamSorted()
Gibt das nearestEnemiesSorted-Array als const zurueck
const Array <int> & getStepstoBall()
Gibt das stepsToBallOfPlayers-Array als const zurueck
const int playerStepsToBall(int index)
Gibt die Entfernung des besten Spielers in Takten zum Ball zurueck
Abfragen zur Erreichbarkeit einer Position
int indexOfNearestPlayerToPos( const Vector& otherPos, const int teamId = BOTH_TEAMS_ID )
Gibt den Index des Spielers zurück, der eine Position am schnellsten erreichen kann
double distOfNearestPlayerToPos( const Vector& otherPos, const int teamId = BOTH_TEAMS_ID )
Gibt die Entfernung des nächsten Spielers zu einer Position zurück
Fehlerklassen
class NoPlayerWithThisIdException: public Exception
Interne Fehlerklasse
Situationen anlegen und zerstören
Situation( int aSimStep = UNDEF_INT)
Neue Situation
virtual StorableObject* copy()
Legt eine Kopie des Objekts auf dem Heap an und liefert einen Zeiger darauf zurueck
Werte ändern
void setSimStep(int newSimStep)
Setzt den Zeittakt, auf den sich die Simulation bezieht
void setBall( const ModelledBall& newBall )
Setzt den Ball
void setPlayer( const ModelledPlayer& newPlayer )
Setzt die Daten des Spielers
void setPlayer( const ModelledPlayer& newPlayer, int index )
Ersetzt den index-ten Spieler durch newPlayer
void addPlayer( const ModelledPlayer& newPlayer )
Fuegt einen Spieler hinzu
void removePlayerWithId( int aPlayerId )
Entfernt einen Spieler aus der Situation
void removePlayerWithIndex( int index )
Entfernt einen Spieler aus der Situation
void simulateSteps( unsigned int stepCount = 1)
Simuliert das Verstreichen von Simulationszeit
Werte abfragen
int simStep()
Liefert den Zeittakt, auf den sich die Simulation bezieht
const ModelledBall& ball()
Gibt den Ball zurueck
const ModelledPlayer& playerWithId( int aPlayerId )
Liefert den Spieler mit der Id aPlayerId
const int stepsOfPlayerWithId( int aPlayerId )
Liefert die benötigten Schritte zum Ball des Spielers mit der Id aPlayerId
const ModelledPlayer& playerWithIndex( int index )
Liefert den index-ten Player in der Situation
int indexOfPlayerWithId( int aPlayerId )
Liefert den index, ueber den mit playerWithIndex( index ) auf einen Spieler zugegriffen werden kann
bool containsPlayerWithId( int aPlayerId )
Checkt, ob die Situation einen Spieler mit der angegebenen Id enthaelt
int playerCount()
Zahl der Spieler in der Situation
virtual String toString()
Beschreibung als String fuer die Ausgabe auf einem Terminal

Private Fields

mutable bool areStepsToBallEstimated
Zustand, ob die Anzahl der Schritte, die die Spieler zum Ball brauchen, bereits geschätzt wurden
mutable Array <int> nearestAllPlayerSorted
Array, welches die Indizes aller Spieler enthält
mutable Array <int> nearestEnemiesSorted
Array, welches die Indizes aller Spieler des gegnerischen Teams enthält
mutable Array <int> nearestTeammatesSorted
Array, welches die Indizes aller Spieler des eigenen Teams enthält
mutable Array <int> stepsToBallOfPlayers
Array, welches die Anzahl der Schritte der Spieler zum Ball enthält
ModelledBall theBall
Der Ball
static double theMinDistPlayerBall
Der Mindestabstand, der zwischen den Mittelpunkten von Spielern und Ball eingehalten werden muß
mutable double theOffsideLineX
X-Koordinate der Abseitslinie
mutable Reliability theOffsideLineXReliability
Verlaesslichkeit der X-Koordinate der Abseitslinie
Array <ModelledPlayer> thePlayers
Array mit den Spielern
int theSimStep
Der Simulationstakt der Situation

Private Methods

double computeOffsideLineX()
Führt die eigentliche Berechnung der Abseitslinie durch
void estimateForAllStepsToBall()
Für alle Spieler wird gschätzt, wieviele Schritte sie brauchen, um zum Ball zu gelangen, wenn sie sich optimal verhalten
void sortIntoField( int playerIndex, Array<int>& sortedField )
Sortiert den playerIndex in das sortedField ein

Inherited from StorableObject:

Public

Ausgabe auf dem Terminal

void printOn(ostream& = cout)
Ausgabe der Beschreibung auf einen Stream
virtual String toString()
Beschreibung als String fuer die Ausgabe auf einem Terminal

Objekte anlegen und zerstören

virtual StorableObject* copy()
Legt eine Kopie des Objekts auf dem Heap an und liefert einen Zeiger darauf zurück
virtual ~StorableObject()
Der virtuelle Destruktor

Documentation

Eine Spielsituation. Eine Situation besteht aus bis zu 22 Spieler-Objekten (ModelledPlayer) und evtl. einem Ball-Objekt (ModelledBall). Eine Situation bezieht sich immer auf einen Zeittakt (simStep).

Das Weltmodell erzeugt jeden SimStep eine neue Situation (per Simulation bzw. durch Auswerten von Sensorinformationen). Es verwendet Situationen, um den Ablauf des Spielgeschehens aufzuzeichnen.

Eine Situation kann auch das Verstreichen von Zeittakten simulieren, wobei davon ausgegangen wird, dass keine Aktionen der Spieler mehr erfolgen. Dabei erhoeht sich auch der Zeittakt, auf den sich die Situation bezieht.

Quelltext

[Header | [Implementierung]

CVS Informationen zum Interface

  **************************************************
  *
  * Aktueller Stand
  *
  *   $RCSfile: Situation.h,v $
  *   $Revision: 1.35 $
  *   $Date: 1998/08/14 13:21:14 $
  *   $Author: myritz $ 
  *
  **************************************************
  
Fehlerklassen

class NoPlayerWithThisIdException: public Exception
Interne Fehlerklasse

Situationen anlegen und zerstören

Situation( int aSimStep = UNDEF_INT)
Neue Situation. Objekte muessen spaeter hinzugefuegt werden.

virtual StorableObject* copy()
Legt eine Kopie des Objekts auf dem Heap an und liefert einen Zeiger darauf zurueck

Werte abfragen

int simStep()
Liefert den Zeittakt, auf den sich die Simulation bezieht

const ModelledBall& ball()
Gibt den Ball zurueck. Enthaelt die Situation keinen Ball, wird ein BallObjekt mit undefinierten Werten zurueckgegeben.

const ModelledPlayer& playerWithId( int aPlayerId )
Liefert den Spieler mit der Id aPlayerId. Enthaelt die Situation keinen Spieler mit dieser Id, wird eine NoPlayerWithThisIdException erzeugt.

Enthaelt die Situation (fehlerhafterweise) mehrere Spieler mit derselben PlayerId, wird der erste Spieler zurueckgegeben.

Diese Routine ist langsam, d.h. die Laufzeit waechst linear mit der Anzahl der Spieler in der Situation.

Throws:
NoPlayerWithThisIdException wenn kein Spieler mit dieser Id in der Situation vorkommt.
Parameters:
aPlayerId - Die PlayerId des gesuchten Spielers.

const int stepsOfPlayerWithId( int aPlayerId )
Liefert die benötigten Schritte zum Ball des Spielers mit der Id aPlayerId. Enthaelt die Situation keinen Spieler mit dieser Id, wird eine NoPlayerWithThisIdException erzeugt.
Diese Routine ist langsam, d.h. die Laufzeit waechst linear mit der Anzahl der Spieler in der Situation.
Throws:
NoPlayerWithThisIdException wenn kein Spieler mit dieser Id in der Situation vorkommt.
Parameters:
aPlayerId - Die PlayerId des Spielers.

const ModelledPlayer& playerWithIndex( int index )
Liefert den index-ten Player in der Situation. Ruft man diese Methode nacheinander mit allen Indizes zwischen 0 und playerCount()-1 auf, so werden insgesamt alle Spieler der Situation geliefert. Die Reihenfolge ist die, in der Spieler der Situation hinzugefuegt werden.

Ist index < 0 oder >= playerCount(), wird eine Array::IndexOutOfBoundsException erzeugt.

Diese Routine ist schnell, d.h. die Laufzeit ist unabhaengig von der Zahl der Spieler in der Situation.

int indexOfPlayerWithId( int aPlayerId )
Liefert den index, ueber den mit playerWithIndex( index ) auf einen Spieler zugegriffen werden kann. Enthaelt die Situation keinen Spieler mit dieser Id, wird eine NoPlayerWithThisIdException erzeugt.

Diese Routine ist langsam, d.h. die Laufzeit waechst linear mit der Anzahl der Spieler in der Situation.

Throws:
NoPlayerWithThisIdException wenn kein Spieler mit dieser Id in der Situation vorkommt.
Parameters:
aPlayerId - Die PlayerId des Spielers mit dem gesuchten Index.

bool containsPlayerWithId( int aPlayerId )
Checkt, ob die Situation einen Spieler mit der angegebenen Id enthaelt. Diese Routine ist langsam, d.h. die Laufzeit waechst linear mit der Anzahl der Spieler in der Situation.
Parameters:
aPlayerId - Die PlayerId des gesuchten Spielers.

int playerCount()
Zahl der Spieler in der Situation

virtual String toString()
Beschreibung als String fuer die Ausgabe auf einem Terminal

Werte ändern

void setSimStep(int newSimStep)
Setzt den Zeittakt, auf den sich die Simulation bezieht

void setBall( const ModelledBall& newBall )
Setzt den Ball

void setPlayer( const ModelledPlayer& newPlayer )
Setzt die Daten des Spielers. Ist bereits ein Spieler mit derselben PlayerId enthalten, wird er durch newPlayer ausgetauscht. Ist er noch nicht in der Situation enthalten, wird er hinzugefuegt.

Diese Routine ist langsam, d.h. die Laufzeit waechst linear mit der Anzahl der Spieler in der Situation.

void setPlayer( const ModelledPlayer& newPlayer, int index )
Ersetzt den index-ten Spieler durch newPlayer. Ist der index playerCount(), wird der Spieler ohne weitere Tests (auf bereits vorhandene Id hinzugefuegt.

Diese Routine ist schnell, d.h. die Laufzeit ist unabhaengig von der Zahl der Spieler in der Situation.

Parameters:
newPlayer - Spieler-Objekt, das in die Situation eingefuegt wird.
index - Stelle, an der abgelegt werden soll. index darf Werte zwischen 0 und playerCount() enthalten.

void addPlayer( const ModelledPlayer& newPlayer )
Fuegt einen Spieler hinzu. Dies ist dasselbe wie setPlayer( newPlayer, playerCount() )

void removePlayerWithId( int aPlayerId )
Entfernt einen Spieler aus der Situation. Alle Spieler mit einem hoeheren Index werden um 1 nach unten verschoben. D.h. evtl. vorher ermittelte Spielerindex-Werte sind nicht mehr gültig.
Throws:
NoPlayerWithThisIdException , wenn kein Spieler mit dieser Id in der Situation vorkommt.
Parameters:
playerId - Die Id des Spielers, der entfernt werden soll.

void removePlayerWithIndex( int index )
Entfernt einen Spieler aus der Situation. Alle Spieler mit einem hoeheren Index werden um 1 nach unten verschoben. D.h. evtl. vorher ermittelte Spielerindex-Werte sind nicht mehr gültig.
Parameters:
index - Der Index des Spielers, der entfernt werden soll.

void simulateSteps( unsigned int stepCount = 1)
Simuliert das Verstreichen von Simulationszeit. Die Routine geht davon aus, dass kein Spieler waehrend dieser Zeit Aktionen unternimmt. Es wird also nur die Positonsaenderung und die Gesschwindigkeitsabnahme von Spielern und Ball berechnet.
Parameters:
stepCount - Zahl der Simulationsschritte.

Abfragen zur Erreichbarkeit des Balls

int indexOfNearestPlayer( int teamId = BOTH_TEAMS_ID )
Gibt den Index des Spielers zurück, der den Ball am schnellsten erreichen kann.
Throws:
NoPlayerWithThisIdException () falls es keinen Spieler in der Situation gibt, der den Anforderungen genügt.
InvalidIdException , wenn die teamId einen ungültigen Wert hat.
Returns:
indexOfPlayer index des Spielers der den Ball am schnellsten erreichen kann.
Parameters:
teamId - TeamId des Teams dessen schnellster Spieler gefragt ist. Zulässige Werte sind OUR_TEAM_ID, THEIR_TEAM_ID und BOTH_TEAMS_ID. Letzterer Wert gilt per Default.

const ModelledPlayer& nearestPlayer( int teamId = BOTH_TEAMS_ID )
Gibt den nächsten Spieler zurück, der den Ball am schnellsten erreichen kann.
Throws:
NoPlayerWithThisIdException () falls es keinen Spieler in der Situation gibt, der den Anforderungen genügt.
InvalidIdException , wenn die teamId einen ungültigen Wert hat.
Returns:
ModelledPlayer Spieler der den Ball am schnellsten erreichen kann.
Parameters:
teamId - TeamId des Teams dessen schnellster Spieler gefragt ist. Zulässige Werte sind OUR_TEAM_ID, THEIR_TEAM_ID und BOTH_TEAMS_ID. Letzterer Wert gilt per Default.

int stepsOfNearestPlayer( int teamId = BOTH_TEAMS_ID )
Gibt die benötigten Schritte zum Ball des Spielers zurück der den Ball am schnellsten erreichen kann.
Throws:
InvalidIdException , wenn die teamId einen ungültigen Wert hat.
Returns:
stepsOfPlayer Schritte des Spielers der den Ball am schnellsten erreichen kann. Wenn es keinen Spieler in der Situation gibt, der den Anforderungen genügt wird ModelledPlayer::MAX_STEPS_TO_BALL zurückgegeben.
Parameters:
teamId - TeamId des Teams dessen schnellster Spieler gefragt ist. Zulässige Werte sind OUR_TEAM_ID, THEIR_TEAM_ID und BOTH_TEAMS_ID. Letzterer Wert gilt per Default.

bool isOneOfTheNearestTeammatesToBall( int id )
Sagt aus, ob der angegebene Spieler einer derjenigen ist, der den Ball als schnellstes erreichen kann. YES wird zurückgeben, wenn er der Spieler des eigenen Teams mit den wenigsten Schritten zum Ball ist oder er nur globalConf->interceptionTolerance Schritte langsamer, als der schnellste Teamkamerad ist.
Throws:
NoPlayerWithThisIdException wenn kein Spieler mit dieser Id in der Situation vorkommt.
Returns:
YES oder NO.
Parameters:
id - Id des Spielers

const Array <int> & getOurTeamSorted()
Gibt das nearestTeammatesSorted-Array als const zurueck

const Array <int> & getTheirTeamSorted()
Gibt das nearestEnemiesSorted-Array als const zurueck

const Array <int> & getStepstoBall()
Gibt das stepsToBallOfPlayers-Array als const zurueck

const int playerStepsToBall(int index)
Gibt die Entfernung des besten Spielers in Takten zum Ball zurueck

Abfragen zur Erreichbarkeit einer Position

int indexOfNearestPlayerToPos( const Vector& otherPos, const int teamId = BOTH_TEAMS_ID )
Gibt den Index des Spielers zurück, der eine Position am schnellsten erreichen kann
Throws:
NoPlayerWithThisIdException () falls es keinen Spieler in der Situation gibt, der den Anforderungen genügt.
InvalidIdException , wenn die teamId einen ungültigen Wert hat.
Returns:
indexOfPlayer index des Spielers der die Position am schnellsten erreichen kann.
Parameters:
teamId - TeamId des Teams dessen schnellster Spieler gefragt ist. Zulässige Werte sind OUR_TEAM_ID, THEIR_TEAM_ID und BOTH_TEAMS_ID. Letzterer Wert gilt per Default.
pos - Die Position, zu der der nächste Spieler gesucht ist.

double distOfNearestPlayerToPos( const Vector& otherPos, const int teamId = BOTH_TEAMS_ID )
Gibt die Entfernung des nächsten Spielers zu einer Position zurück
Throws:
NoPlayerWithThisIdException () falls es keinen Spieler in der Situation gibt, der den Anforderungen genügt.
InvalidIdException , wenn die teamId einen ungültigen Wert hat.
Returns:
Entfernung des Spielers. der die Position am schnellsten erreichen kann, zu der Position.
Parameters:
teamId - TeamId des Teams dessen nächster Spieler gefragt ist. Zulässige Werte sind OUR_TEAM_ID, THEIR_TEAM_ID und BOTH_TEAMS_ID. Letzterer Wert gilt per Default.
pos - Die Position, zu der der nächste Spieler gesucht ist.

Abfragen zum Abseits

bool isOffsideWithIndex( int index )
Testet, ob ein Teammate im Abseits steht. Die Routine liefert YES, wenn sich der angegebene Spieler jenseits der Abseitslinie befindet, sonst NO.

Hinweis: Diese Routine kann unkorrekte Werte liefern. So kann sie YES liefern, obwohl der Spieler nicht im Abseits steht, wenn die Situation unvollständig ist, also Spieler fehlen oder nicht als Gegner erkannt sind. Andererseits kann es sein, daß Abseits gepfiffen wird, weil ein Spieler dem Ball zu nahe kommt, für den diese Routine NO liefert. Das passiert dann, wenn sich seit der Ballabgabe die Abseitslinie über den Spieler hinweg nach vorne (auf das eigene Tor zu) bewegt hat. In der Klasse Situation kann diese Abseitsfalle nicht erkannt werden.

Throws:
Array <ModelledPlayer>::IndexOutOfBoundsException, wenn der Index zu groß oder zu klein ist.
InvalidIdException , wenn team() des Spielers THEIR_TEAM_ID
Returns:
YES oder NO
Parameters:
index - Der Index des Spielers, von dem bestimmt werden soll, ob er im Abseits steht. Dieser Spieler darf nicht vom gegnerischen Team sein.
See Also:
offsideLineX

bool isOffsideWithId( int playerId )
Testet, ob ein Teammate im Abseits steht
Throws:
InvalidIdException , wenn team() des Spielers THEIR_TEAM_ID ist oder nicht in der Situation enthalten ist.
Returns:
YES oder NO
Parameters:
index - Die Id des Spielers, von dem bestimmt werden soll, ob er im Abseits steht. Dieser Spieler darf nicht vom gegnerischen Team sein.
See Also:
offsideLineX
isOffsideWithIndex

double offsideLineX()
Liefert die X-Koordinate der Abseitslinie. Die Abseitslinie ist diejenige der beiden Geraden, die parallel zur Mittellinie verlaufen und durch den Ball bzw. durch den vorletzten Spieler des gegnerischen Teams gehen, die näher am gegnerischen Tor liegt. Dabei werden nur die als Gegner identifizierten Spieler berücksichtigt. Die Abseitslinie darf allerdings nicht näher am eigenen Tor liegen als die Mittellinie.

Der Wert wird intern zwischengespeichert und eigentlich von computeOffsideX berechnet.

Hinweis: Diese Routine kann unkorrekte Werte liefern. Der Wert kann zu nahe an der Mittellinie liegen, wenn die Situation unvollständig ist, also Spieler fehlen oder nicht als Gegner erkannt sind. Der Wert kann zu weit an der gegnerischen Torlinie liegen, wenn sich seit der Ballabgabe die wahre Abseitslinie nach vorne (auf das eigene Tor zu) bewegt hat. In der Klasse Situation kann diese Abseitsfalle nicht erkannt werden.

Returns:
x-Koordinate der Abseitslinie, ein Wert zwischen 0 (Mittellinie) und 52.5 (gegnerische Torlinie).

const Reliability& Situation::offsideLineXReliability()
Verlaesslichkeit der Abseitsdaten. Es wird die schlechtere der Positionsverlaesslichkeiten der letzten beiden Spieler zurueckgegeben, wenn die fuer die Berechnung relevant waren, ist der Ball relevant, wird die Ballverlaesslichkeit, andernfalls die eigene Positionsverlaesslichkeit zurueckgegeben.

int theSimStep
Der Simulationstakt der Situation

Array <ModelledPlayer> thePlayers
Array mit den Spielern.

ModelledBall theBall
Der Ball

mutable bool areStepsToBallEstimated
Zustand, ob die Anzahl der Schritte, die die Spieler zum Ball brauchen, bereits geschätzt wurden. Wird von den Methoden, die die Situation verändern auf NO gesetzt und von estimateForAllStepsToBall auf YES gestzt

mutable Array <int> stepsToBallOfPlayers
Array, welches die Anzahl der Schritte der Spieler zum Ball enthält. Die Indizes entsprechen dabei, den der Spieler im Array thePlayers.

mutable Array <int> nearestAllPlayerSorted
Array, welches die Indizes aller Spieler enthält. Die Indizes sind dabei nach den Werten, die in stepsToBallOfPlayers stehen sortiert, d.h. der erste Index im Array entspricht dem Spieler, der den Ball am schnellsten erreichen kann (am wenigsten Schritte zu ihm benötigt).

mutable Array <int> nearestTeammatesSorted
Array, welches die Indizes aller Spieler des eigenen Teams enthält. Die Indizes sind dabei nach den Werten, die in stepsToBallOfPlayers stehen sortiert, d.h. der erste Index im Array entspricht dem Spieler des eigenen Teams, der den Ball am schnellsten erreichen kann (am wenigsten Schritte zu ihm benötigt).

mutable Array <int> nearestEnemiesSorted
Array, welches die Indizes aller Spieler des gegnerischen Teams enthält. Die Indizes sind dabei nach den Werten, die in stepsToBallOfPlayers stehen sortiert, d.h. der erste Index im Array entspricht dem Spieler des gegnerischen Teams, der den Ball am schnellsten erreichen kann (am wenigsten Schritte zu ihm benötigt).

mutable double theOffsideLineX
X-Koordinate der Abseitslinie

mutable Reliability theOffsideLineXReliability
Verlaesslichkeit der X-Koordinate der Abseitslinie

static double theMinDistPlayerBall
Der Mindestabstand, der zwischen den Mittelpunkten von Spielern und Ball eingehalten werden muß

void estimateForAllStepsToBall()
Für alle Spieler wird gschätzt, wieviele Schritte sie brauchen, um zum Ball zu gelangen, wenn sie sich optimal verhalten. Es werden die entsprechenden Arrays mit den geschätzten Daten gefüllt. Diese Methode setzt die Variable computeForAllStepsToBall auf YES

void sortIntoField( int playerIndex, Array<int>& sortedField )
Sortiert den playerIndex in das sortedField ein. Sortiert wird dabei nach der Anzahl der Schritte, die die Spieler zum Ball brauchen.
Parameters:
playerIndex - index des Spielers der eingefügt werden soll
sortedField - in das Feld in das einsortiert werden soll

double computeOffsideLineX()
Führt die eigentliche Berechnung der Abseitslinie durch
Returns:
X-Koordinate der Abseitslinie.
See Also:
offsideLineX


This class has no child classes.

alphabetic index hierarchy of classes


Hauptseite

Einleitung | Architektur | Dynamische Zusammenhänge | Referenzhandbuch | FAQ | Anhang A | Anhang B

generated by doc++