class ModelledPlayer : public ModelledObject

Die interne Repraesentation eines Spielers im Weltmodell

Inheritance:


Public Fields

static const int MAX_STEPS_TO_BALL
Maximale Schrittzahl die ein Spieler braucht um zum Ball zu gelangen.

Public

Dash-Berechnung
double effectiveDashPower( double power )
Es wird die tatsaechlich verfuegbare Kraft fuer einen dash (effectiveDashPower) ausgerechnet
double dashPowerForSend( double power )
Es wird die Kraft bestimmt, die dem SoccerServer geschickt werden muss, damit man effektiv mit der Kraft power beschleunigt
double maxEffectiveDashPower()
Liefert den maximalen sinnvollen effektiven Dash mit dem der Spieler zur derzeitigen Situation beschleunigen kann
double normalizeDashPower(double power)
Normalisiert die Kraft fuer einen dash
Entfernunsberechnungen
double distTo( const Vector& position )
Gibt den Abstand des Spielers von der angegebenen Position zurueck
int estimatedStepsToBall( ModelledBall ball )
Schaetzt die Schritte, die der Spieler braucht, um den angegebenen Ball zu erreichen
int calculatedStepsToBall( ModelledBall& ball, int estimatedSteps )
Bestimmt die Schritte, die der Spieler braucht, um den angegebenen Ball zu erreichen
Erzeugen und Zerstören
ModelledPlayer( int id = UNDEF_ID, const Vector& aPos = Vector(), const Vector& aSpeed = Vector(), double aFaceDir = UNDEF_DOUBLE, const Reliability& aPosReliability = Reliability(Reliability::RANDOM), const Reliability& aSpeedReliability = Reliability(Reliability::RANDOM), const Reliability& aFaceDirReliability = Reliability(Reliability::RANDOM), int aViewWidth = VIEW_WIDTH_WIDE, double stamina = UNDEF_DOUBLE, double effort = UNDEF_DOUBLE, double recovery = UNDEF_DOUBLE, const Reliability& aStaminaReliability = Reliability(Reliability::RANDOM) )
Neuer Spieler mit Daten und Default-Konstruktor
ModelledPlayer( const MovingPlayer& aMovingPlayer, const Reliability& aPosReliability = Reliability(Reliability::RANDOM), const Reliability& aSpeedReliability = Reliability(Reliability::RANDOM), const Reliability& aFaceDirReliability = Reliability(Reliability::RANDOM), int aViewWidth = VIEW_WIDTH_WIDE, double stamina = UNDEF_DOUBLE, double effort = UNDEF_DOUBLE, double recovery = UNDEF_DOUBLE, const Reliability& aStaminaReliability = Reliability(Reliability::RANDOM) )
Modellierung eines wahrgenommenen Spielers
virtual StorableObject* copy()
Legt eine Kopie des Objekts auf dem Heap an und liefert einen Zeiger darauf zurueck
Interne Fehlerklassen.
class ModelledPlayerException: public ModelledObjectException
Allgemeine Fehlerklasse
Konfigurierbare Werte erfragen
double size()
double maxSpeed()
double decay()
double staminaIncMax()
double staminaMax()
double recoverDecThr()
double recoverDec()
double recoverMin()
double effortDecThr()
double effortDec()
double effortIncThr()
double effortInc()
double effortMin()
double dashPowerRate()
double maxPower()
double minPower()
double maxMoment()
double minMoment()
double normVisibleAngle()
double inertiaMomentOfTurn()
Konfigurierbare Werte setzen
void setClassVars()
liest die Werte aller Klassenvariablen aus dem Konfigurationsfile ein
void setSize(double aPlayerSize)
void setMaxSpeed(double aPlayerMaxSpeed)
void setDecay(double aPlayerDecay)
void setStaminaIncMax(double aStaminaIncMax)
void setStaminaMax(double aStaminaMax)
void setRecoverDecThr(double aRecoverDecThr)
void setRecoverDec(double aRecoverDec)
void setRecoverMin(double aRecoverMin)
void setEffortDecThr(double aEffortDecThr)
void setEffortDec(double aEffortDec)
void setEffortIncThr(double aEffortIncThr)
void setEffortInc(double aEffortInc)
void setEffortMin(double aEffortMin)
void setDashPowerRate(double aDashPowerRate)
void setMaxPower(double aMaxPower)
void setMinPower(double aMinPower)
void setMaxMoment(double aMaxMoment)
void setMinMoment(double aMinMoment)
void setNormVisibleAngle(double aNormVisibleAngle)
void setInertiaMomentOfTurn(double inertiaMoment)
Simulation
void simulateSteps( unsigned int simSteps = 1 )
Simuliert das Verstreichen von Simulationszeit
void recover( int simSteps = 1 )
Baut die Kraftreserven wieder auf
void accelerate( double aPower )
Beschleunigt
void turn( double angle )
Dreht die Blickrichtung
Turn-Berechnung
double effectiveTurnAngle( double angle )
Es wird die tatsaechlich ausgefuehrte Drehung (effectiveTurnAngle) ausgerechnet
double turnAngleForSend( double angle )
Es wird der Winkel bestimmt, der dem SoccerServer geschickt werden muss, damit sich der Spieler effektiv um den angegebenen Winkel dreht
double maxEffectiveTurnAngle()
Liefert den vom Betrag her maximalen sinnvollen Turn um dessen Winkel sich der Spieler in der gegebenen Situation drehen kann
double normalizeTurnAngle(double angle)
Normalisiert die Drehung fuer einen turn
Werte abfragen
double stamina()
Liefert den Stamina-Wert
double effort()
Liefert den Effort-Wert
double recovery()
Liefert den Recovery-Wert
const Reliability& staminaReliability()
Liefert Verläßlichkeit der Stamina-Werte
double faceDir()
Liefert Blickrichtung
const Reliability& faceDirReliability()
Liefert die Verläßlichkeit der Blickrichtung
int viewWidth()
Liefert die Groesse des Gesichtsfeldes
double visibleAngle()
Liefert den Wert des Winkels des sichtbaren Bereiches
int team()
Liefert die TeamId des Teams, zu dem der Spieler gehört
bool isPlayerNumberKnown()
Liefert YES wenn die Nummer des Spielers bekannt ist, sonst NO
virtual String toString()
Beschreibung als String fuer die Ausgabe auf einem Terminal
Werte setzen
void setStaminaValues( double newStamina = UNDEF_DOUBLE, double newEffortFactor = UNDEF_DOUBLE, double newRecoveryFactor = UNDEF_DOUBLE, const Reliability& aStaminaReliability = Reliability(Reliability::PERFECT) )
Setzt Stamina-Modell
void setStamina( double newStamina )
Setzt den Stamina-Wert
void setEffort( double newEffortFactor )
Setzt den Effort-Wert
void setRecovery( double newRecoveryFactor )
Setzt die Recovery
void setStaminaReliability( const Reliability& newStaminaReliability )
Setzt die Verläßlichkeit der Stamina-Werte
void setFaceDir( double newFaceDir )
Setzt Blickrichtung neu
void setFaceDirReliability( const Reliability& newFaceDirReliability )
Setzt Verläßlichkeit der Blickrichtung
void setViewWidth( int newViewWidth )
Setzt die Groesse des Gesichtsfeldes
void setVisibleAngle( int viewWidth )
Setzt den Sichtwinkel
Winkelbezogene Hilfsfunktionen
double angleTo( const Vector& point )
Ermittelt den Winkel unter dem der Spieler den angegebenen Punkt sieht
bool isInFieldOfView( const StableObject& pos )
Ermittelt ob sich das angegeben Objekt im Sichtbereich des Spielers befindet
bool isInFieldOfFeel( const StableObject& pos )
Ermittelt ob sich das angegeben Objekt in unmittelbarer Nähe des Spielers befindet
bool isInFieldOfSense( const StableObject& pos )
Ermittelt ob sich das angegeben Objekt im Wahrnehmungsbereich des Spielers befindet

Private Fields

static short isSetOnce
static double theDashPowerRate
double theEffort
Leistungsfaktor, der aktuelle Leistungsfaehigkeit repraesentiert
static double theEffortDec
static double theEffortDecThr
static double theEffortInc
static double theEffortIncThr
static double theEffortMin
double theFaceDir
Die Blickrichtung als absoluter Winkel im Bogenmass
Reliability theFaceDirReliability
Die Verläßlichkeit der Blickrichtung
static double theInertiaMomentOfTurn
static double theMaxMoment
static double theMaxPower
static double theMinMoment
static double theMinPower
static double theNormVisibleAngle
static double thePlayerDecay
static double thePlayerMaxSpeed
static double thePlayerSize
static double theRecoverDec
static double theRecoverDecThr
static double theRecoverMin
double theRecovery
Erholungsfaktor, der die Langzeitausdauer repraesentiert
double theStamina
Die aktuelle Kraftreserve
static double theStaminaIncMax
static double theStaminaMax
Reliability theStaminaReliability
Die Verläßlichkeit der Stamina-Werte
int theViewWidth
Die der aktuellen Sichtfeldgroesse entsprechende Konstante
double theVisibleAngle
Der sichtbare Bereich als Winkel im Bogenmass

Private Methods

double normalizeEffort(double effort)
Normalisiert den Effort-Wert
double normalizeRecovery(double recovery)
Normalisiert den Recovery-Wert
double normalizeStamina(double stamina)
Normalisiert den Stamina-Wert
double turnAngleMult()
Formel mit der der Drehwinkel modifiziert wird

Inherited from ModelledObject:

Private Fields

Reliability thePosReliability
Reliability theSpeedReliability

Inherited from MovingObject:

Private Fields

Vector theSpeed

Inherited from StableObject:

Private Fields

int theId
Vector thePos

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

Die interne Repraesentation eines Spielers im Weltmodell. Ein ModelledPlayer hat zusaetzlich zu den Eigenschaften eines ModelledObject noch eine Blickrichtung und eine Kraftreserve. Die Kraftreserve setzt sich aus den Werten stamina, effort und recovery zusammen. Dazu kommen entsprechende Verlässlichkeitsinformationen.

Quelltext

[Header | [Implementierung]

CVS Informationen zum Interface

  **************************************************
  *
  * Aktueller Stand
  *
  *   $RCSfile: ModelledPlayer.h,v $
  *   $Revision: 1.43 $
  *   $Date: 1998/08/14 13:20:55 $
  *   $Author: myritz $ 
  *
  **************************************************
  
Interne Fehlerklassen.

class ModelledPlayerException: public ModelledObjectException
Allgemeine Fehlerklasse

Erzeugen und Zerstören

ModelledPlayer( int id = UNDEF_ID, const Vector& aPos = Vector(), const Vector& aSpeed = Vector(), double aFaceDir = UNDEF_DOUBLE, const Reliability& aPosReliability = Reliability(Reliability::RANDOM), const Reliability& aSpeedReliability = Reliability(Reliability::RANDOM), const Reliability& aFaceDirReliability = Reliability(Reliability::RANDOM), int aViewWidth = VIEW_WIDTH_WIDE, double stamina = UNDEF_DOUBLE, double effort = UNDEF_DOUBLE, double recovery = UNDEF_DOUBLE, const Reliability& aStaminaReliability = Reliability(Reliability::RANDOM) )
Neuer Spieler mit Daten und Default-Konstruktor
Parameters:
id - Die Id des Spielers
aPos - Die Position. Als Default wird unbekannt angenommen.
aSpeed - Die Geschwindigkeit. Als Default wird unbekannt angenommen.
aFaceDir - Die Blickrichtung. Als Default wird unbekannt angenommen.
aPosReliability - Die Verlaesslichkeit der Position. Als Default wird RANDOM angenommen.
aSpeedReliability - Die Verlaesslichkeit der Geschwindikeit. Als Default wird RANDOM angenommen.
aFaceDirReliability - Die Verläßlichkeit der Blickrichtung. Als Delault wird RANDOM angenommen.
aViewWidth - Sichtbreite darf nur die Werte VIEW_WIDTH_NARROW, VIEW_WIDTH_NORMAL oder VIEW_WIDTH_WIDE annehmen. Als Default wird VIEW_WIDTH_WIDE angenommen.
stamina - die Kraftreserve des Spielers. Gueltige Werte: 0 bis theStaminaMax. Kleinere Werte werden auf 0 gesetzt, groessere Werte (UNDEF_DOUBLE) auf theStaminaMax.
effort - der Leistungsfaktor des Spielers. Gueltige Werte: theEffortMin bis 1.0. Kleinere Werte werden auf theEffortMin gesetzt, groessere Werte (UNDEF_DOUBLE) auf 1.0.
recovery - der Erholungsfactor des Spielers. Gueltige Werte theRecoveryMin bis 1.0. Kleinere Werte werden auf theRecoveryMin gesetzt, groessere Werte (UNDEF_DOUBLE) auf 1.0.
aStaminaReliability - Die Verlässlichkeit der Stamina-Werte. Als Default wird RANDOM angenommen.

ModelledPlayer( const MovingPlayer& aMovingPlayer, const Reliability& aPosReliability = Reliability(Reliability::RANDOM), const Reliability& aSpeedReliability = Reliability(Reliability::RANDOM), const Reliability& aFaceDirReliability = Reliability(Reliability::RANDOM), int aViewWidth = VIEW_WIDTH_WIDE, double stamina = UNDEF_DOUBLE, double effort = UNDEF_DOUBLE, double recovery = UNDEF_DOUBLE, const Reliability& aStaminaReliability = Reliability(Reliability::RANDOM) )
Modellierung eines wahrgenommenen Spielers
Parameters:
aMovingPlayer - Der gesehene Spieler.
aPosReliability - Die Verlaesslichkeit der Position. Als Default wird RANDOM angenommen.
aSpeedReliability - Die Verlaesslichkeit der Geschwindikeit. Als Default wird RANDOM angenommen.
aFaceDirReliability - Die Verläßlichkeit der Blickrichtung. Als Deafault wird RANDOM angenommen.
aViewWidth - Sichtbreite darf nur die Werte VIEW_WIDTH_NARROW, VIEW_WIDTH_NORMAL oder VIEW_WIDTH_WIDE annehmen. Als Default wird VIEW_WIDTH_WIDE angenommen.
stamina - die Kraftreserve des Spielers. Gueltige Werte: 0 bis theStaminaMax. Kleinere Werte werden auf 0 gesetzt, groessere Werte (UNDEF_DOUBLE) auf theStaminaMax.
effort - der Leistungsfaktor des Spielers. Gueltige Werte: theEffortMin bis 1.0. Kleinere Werte werden auf theStaminaMin gesetzt, groessere Werte (UNDEF_DOUBLE) auf 1.0.
recovery - der Erholungsfactor des Spielers. Gueltige Werte theRecoveryMin bis 1.0. Kleinere Werte werden auf theRecoveryMin gesetzt, groessere Werte (UNDEF_DOUBLE) auf 1.0.
aStaminaReliability - Die Verlässlichkeit der Stamina-Werte. Als Default wird RANDOM angenommen.

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

Werte abfragen

double stamina()
Liefert den Stamina-Wert

double effort()
Liefert den Effort-Wert

double recovery()
Liefert den Recovery-Wert

const Reliability& staminaReliability()
Liefert Verläßlichkeit der Stamina-Werte

double faceDir()
Liefert Blickrichtung

const Reliability& faceDirReliability()
Liefert die Verläßlichkeit der Blickrichtung

int viewWidth()
Liefert die Groesse des Gesichtsfeldes.
Returns:
VIEW_WIDTH_NARROW, VIEW_WIDTH_NORMAL oder VIEW_WIDTH_WIDE

double visibleAngle()
Liefert den Wert des Winkels des sichtbaren Bereiches

int team()
Liefert die TeamId des Teams, zu dem der Spieler gehört
Returns:
OUR_TEAM_ID, THEIR_TEAM_ID oder UNDEF_TEAM_ID

bool isPlayerNumberKnown()
Liefert YES wenn die Nummer des Spielers bekannt ist, sonst NO

virtual String toString()
Beschreibung als String fuer die Ausgabe auf einem Terminal. Es werden ID, Position, Geschwindigkeit, Zuverlaessigkeitswerte, FaceDir, Sichtrichtung und -winkel (in Grad), sowie die Staminawerte ausgegeben.

Werte setzen

void setStaminaValues( double newStamina = UNDEF_DOUBLE, double newEffortFactor = UNDEF_DOUBLE, double newRecoveryFactor = UNDEF_DOUBLE, const Reliability& aStaminaReliability = Reliability(Reliability::PERFECT) )
Setzt Stamina-Modell.
Parameters:
newStamina - Die Kraftreserve. Gueltige Werte: 0 bis theStaminaMax
newEffortFactor - Der Leistungsfaktor. Gueltige Werte: theEffortMin bis 1.0
newRecoveryFactor - Der Erholungsfaktor. Gueltige Werte: theRecoveryMin bis 1.0
aStaminaReliability - Die Verlässlichkeit der Stamina-Werte. Als Default wird PERFECT angenommen.

void setStamina( double newStamina )
Setzt den Stamina-Wert

void setEffort( double newEffortFactor )
Setzt den Effort-Wert

void setRecovery( double newRecoveryFactor )
Setzt die Recovery

void setStaminaReliability( const Reliability& newStaminaReliability )
Setzt die Verläßlichkeit der Stamina-Werte

void setFaceDir( double newFaceDir )
Setzt Blickrichtung neu

void setFaceDirReliability( const Reliability& newFaceDirReliability )
Setzt Verläßlichkeit der Blickrichtung

void setViewWidth( int newViewWidth )
Setzt die Groesse des Gesichtsfeldes. Es wird nicht auf Gueltigkeit getestet.
Parameters:
newViewWidth - Neue Gesichtsfeldgroesse. Moegliche Werte sind VIEW_WIDTH_NARROW, VIEW_WIDTH_NORMAL, VIEW_WIDTH_WIDE.

void setVisibleAngle( int viewWidth )
Setzt den Sichtwinkel. Dieser ist abhaengig vom Paramter viewWidth und von den normalen Sichtwinkel der aus der Datei server.conf entnommen wird.
Throws:
ModelledPlayerException bei undefinierter viewWidth
Parameters:
viewWidth - Sichtbreite darf nur die Werte VIEW_WIDTH_NARROW, VIEW_WIDTH_NORMAL oder VIEW_WIDTH_WIDE annehmen.

Simulation

void simulateSteps( unsigned int simSteps = 1 )
Simuliert das Verstreichen von Simulationszeit. Die Routine geht davon aus, dass der Spieler waehrend dieser Zeit keine Aktionen unternimmt. Es wird simuliert: Die Geschwindigkeitsaenderung, die Positionsaenderung und die Staminaaenderung. Die Verlaesslichkeit wird herabgesetzt.
Parameters:
stepCount - Zahl der Simulationsschritte.

void recover( int simSteps = 1 )
Baut die Kraftreserven wieder auf.
Parameters:
simSteps - Die Zahl der Simulationsschritte, die zur Erholung zur Verfuegung stehen. Wird von simulateSteps() aufgerufen.

void accelerate( double aPower )
Beschleunigt. Wie stark sich die Kraft auf die Beschleunigung auswirkt, haengt vom Kraftfaktor (powerRate) und einem Objektbeschleunigungsfaktor (maxPowerRate) ab. Dabei wird auch die Kraftreserve herabgesetzt.
Throws:
ModelledPlayerException bei undefinierter Geschwindigkeit
Parameters:
aPower - Die Kraft, mit der beschleunigt wird.

void turn( double angle )
Dreht die Blickrichtung. Die naechste Beschleunigung geht standardmaessig in diese Richtung.
Parameters:
angle - Ein Winkel relativ zur bisherigen Blickrichtung.

Winkelbezogene Hilfsfunktionen

double angleTo( const Vector& point )
Ermittelt den Winkel unter dem der Spieler den angegebenen Punkt sieht
Throws:
ModelledPlayerException bei undefinierter Blickrichtung

bool isInFieldOfView( const StableObject& pos )
Ermittelt ob sich das angegeben Objekt im Sichtbereich des Spielers befindet. Wenn sich das Objekt im Sichtbereich befindet wird YES zurueckgegeben, andernfalls NO.

bool isInFieldOfFeel( const StableObject& pos )
Ermittelt ob sich das angegeben Objekt in unmittelbarer Nähe des Spielers befindet. Wenn sich das Objekt in unmittelbarer Nähe des Spielers befindet (der Spieler das Objekt fühlen kann) wird YES zurueckgegeben, andernfalls NO.

bool isInFieldOfSense( const StableObject& pos )
Ermittelt ob sich das angegeben Objekt im Wahrnehmungsbereich des Spielers befindet. Wenn sich das Objekt im Wahrnehmungsbereich befindet wird YES zurueckgegeben, andernfalls NO. Ein Objekt befindet sich im Wahrnehmungsbereich des Spielers, wenn es entweder in dessen Sichtbereich ist, oder in unmittelbarer Nähe des Spielers ist
See Also:
isInFieldOfView
isInFieldOfFeel

Dash-Berechnung

double effectiveDashPower( double power )
Es wird die tatsaechlich verfuegbare Kraft fuer einen dash (effectiveDashPower) ausgerechnet. Diese ist abhaengig vom Effort und vom noch zur Verfuegung stehenden Stamina.
Returns:
effectiveDashPower Die Kraft, mit der man tatsaechlich beschleunigt.
Parameters:
power - Die Kraft, mit der man beschleunigen will.

double dashPowerForSend( double power )
Es wird die Kraft bestimmt, die dem SoccerServer geschickt werden muss, damit man effektiv mit der Kraft power beschleunigt. Diese Funktion ist also genau die Umkehrfunktion von effectiveDashPower. Es gilt also: dashPowerForSend(effectiveDashPower( power )) == power, wenn power normalisiert ist (im definierten Bereich liegt). Liegt das zu sendene Kommando nicht im definierten Bereich, wird normalisiert und eine Warnung ins Log geschrieben.
Returns:
powerForSend Die Kraft die man den SoccerServer senden muss.
Parameters:
power - Die Kraft mit der der Spieler beschleunigen soll.

double maxEffectiveDashPower()
Liefert den maximalen sinnvollen effektiven Dash mit dem der Spieler zur derzeitigen Situation beschleunigen kann
Throws:
ModelledPlayerException bei undefiniertet Geschwindigkeit

double normalizeDashPower(double power)
Normalisiert die Kraft fuer einen dash.
Throws:
ModelledPlayerException falls der Power-Wert undefiniert ist

Turn-Berechnung

double effectiveTurnAngle( double angle )
Es wird die tatsaechlich ausgefuehrte Drehung (effectiveTurnAngle) ausgerechnet. Diese ist abhaengig von der aktuellen Geschwindigkeit des Spielers.
Returns:
effectiveTurnAngle Der Winkel, um den man sich tatsaechlich dreht.
Parameters:
angle - Der Winkel, um die man sich drehen will.

double turnAngleForSend( double angle )
Es wird der Winkel bestimmt, der dem SoccerServer geschickt werden muss, damit sich der Spieler effektiv um den angegebenen Winkel dreht. Diese Funktion ist als genau die Umkehrfunktion von effectiveTurnAngle. Es gilt also: turnAngleForSend(effectiveTurnAngle( angle )) == angle, wenn angle normalisiert ist (im definierten Bereich liegt). Liegt das zu sendene Kommando nicht im definierten Bereich, wird normalisiert und eine Warnung ins Log geschrieben.
Returns:
angleForSend Den Winkel, den man dem Server uebermitteln muss.
Parameters:
angle - Der Winkel um den sich der Spieler drehen soll.

double maxEffectiveTurnAngle()
Liefert den vom Betrag her maximalen sinnvollen Turn um dessen Winkel sich der Spieler in der gegebenen Situation drehen kann

double normalizeTurnAngle(double angle)
Normalisiert die Drehung fuer einen turn

Entfernunsberechnungen

double distTo( const Vector& position )
Gibt den Abstand des Spielers von der angegebenen Position zurueck. Dieser Abstand wird vom Mittelpunkt des Spielers gemessen.
Returns:
distance Abstand des Spielers zur Position position.
Parameters:
position - Die Position zu der Abstand ermittelt werden soll.

int estimatedStepsToBall( ModelledBall ball )
Schaetzt die Schritte, die der Spieler braucht, um den angegebenen Ball zu erreichen.
Returns:
steps Schritte die der Spieler braucht.
Parameters:
ball - Der Ball der erreicht werden soll.

int calculatedStepsToBall( ModelledBall& ball, int estimatedSteps )
Bestimmt die Schritte, die der Spieler braucht, um den angegebenen Ball zu erreichen. Diese Berechnung geschieht mittels Simulation und ist daher sehr zeitaufwendig. Der zweite Parameter gibt daher an, ab wieviel Takten erst richtig simuliert werden soll. Diese Routine simuliert den Ball soviele Schritte, wie der Spieler zum Ball braucht. Bei Schrittzahlen größer als {\Ref globalConf->maxStepsToCalculate} wird die Simulation abgebrochen und die derzeitige Schrittzahl zurückgegeben. Nach 5 durchgeführten Iterationen, um die Shrittzahl zum Ball zu bestimmen, wird ebenfalls abgebrochen und die derzeitige Schrittzahl zur"uckgegeben.
Returns:
steps Schritte die der Spieler braucht.
Parameters:
ball - Der Ball der erreicht werden soll.
estimatedSteps - Geschätzte Zahl der Schritte.

Konfigurierbare Werte erfragen

double size()

double maxSpeed()

double decay()

double staminaIncMax()

double staminaMax()

double recoverDecThr()

double recoverDec()

double recoverMin()

double effortDecThr()

double effortDec()

double effortIncThr()

double effortInc()

double effortMin()

double dashPowerRate()

double maxPower()

double minPower()

double maxMoment()

double minMoment()

double normVisibleAngle()

double inertiaMomentOfTurn()

Konfigurierbare Werte setzen

void setClassVars()
liest die Werte aller Klassenvariablen aus dem Konfigurationsfile ein

void setSize(double aPlayerSize)

void setMaxSpeed(double aPlayerMaxSpeed)

void setDecay(double aPlayerDecay)

void setStaminaIncMax(double aStaminaIncMax)

void setStaminaMax(double aStaminaMax)

void setRecoverDecThr(double aRecoverDecThr)

void setRecoverDec(double aRecoverDec)

void setRecoverMin(double aRecoverMin)

void setEffortDecThr(double aEffortDecThr)

void setEffortDec(double aEffortDec)

void setEffortIncThr(double aEffortIncThr)

void setEffortInc(double aEffortInc)

void setEffortMin(double aEffortMin)

void setDashPowerRate(double aDashPowerRate)

void setMaxPower(double aMaxPower)

void setMinPower(double aMinPower)

void setMaxMoment(double aMaxMoment)

void setMinMoment(double aMinMoment)

void setNormVisibleAngle(double aNormVisibleAngle)

void setInertiaMomentOfTurn(double inertiaMoment)

static const int MAX_STEPS_TO_BALL
Maximale Schrittzahl die ein Spieler braucht um zum Ball zu gelangen.

static double thePlayerSize

static double thePlayerMaxSpeed

static double thePlayerDecay

static double theStaminaIncMax

static double theStaminaMax

static double theRecoverDecThr

static double theRecoverDec

static double theRecoverMin

static double theEffortDecThr

static double theEffortDec

static double theEffortIncThr

static double theEffortInc

static double theEffortMin

static double theDashPowerRate

static double theMaxPower

static double theMinPower

static double theMaxMoment

static double theMinMoment

static double theNormVisibleAngle

static double theInertiaMomentOfTurn

static short isSetOnce

double theFaceDir
Die Blickrichtung als absoluter Winkel im Bogenmass

int theViewWidth
Die der aktuellen Sichtfeldgroesse entsprechende Konstante

double theVisibleAngle
Der sichtbare Bereich als Winkel im Bogenmass

double theStamina
Die aktuelle Kraftreserve. Sie sinkt beim Beschleunigen und beim Aufruf von usePower. Die Kraftreserve liegt anfangs bei MAX_STAMINA.

double theEffort
Leistungsfaktor, der aktuelle Leistungsfaehigkeit repraesentiert. Er gibt an, wieviel Kraft in einem Simulationsschritt tatsaechlich zur Verfuegung steht. Er sinkt, wenn die Kraftreserve unter einen Schwellwert faellt und steigt wieder, wenn sich der Spieler praktisch ganz erholt hat.

double theRecovery
Erholungsfaktor, der die Langzeitausdauer repraesentiert. Er gibt an, wie stark die Kraftreserve in einer Ruhepause wieder ansteigt. Er wird waehrend eines Spiels nicht erhoeht und sinkt, wenn die Kraftreserve unter einen Schwellwert faellt.

Reliability theStaminaReliability
Die Verläßlichkeit der Stamina-Werte. Sie haengt von der anfaenglichen Verlaesslichkeit und von der Zahl der durchgefuehrten Simulationsschritte ab.

Reliability theFaceDirReliability
Die Verläßlichkeit der Blickrichtung. Sie haengt von der anfaenglichen Verlaesslichkeit und von der Zahl der durchgefuehrten Simulationsschritte ab.

double turnAngleMult()
Formel mit der der Drehwinkel modifiziert wird

double normalizeStamina(double stamina)
Normalisiert den Stamina-Wert

double normalizeEffort(double effort)
Normalisiert den Effort-Wert

double normalizeRecovery(double recovery)
Normalisiert den Recovery-Wert


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++