class Skills

Die Fähigkeiten des Agenten

Public Fields

const int AVOID_OBSTACLES
Konstante zur Steuerung des Verhaltens f"ur gotoRegion
const double MIN_TURN_ANGLE_IN_DEGREE
Minimale Drehung, die ausgeführt werden soll
const int RUN_BACKWARDS
Konstante zur Steuerung des Verhaltens f"ur gotoRegion
const int STANDARD_BEHAVIOR
Konstante zur Steuerung des Verhaltens f"ur gotoRegion

Public Methods

Plan beamToPosition( const Vector& position )
Erzeugt einen Plan um den Spieler auf die angegebene Position zu beamen
Plan doNothing(int steps = UNDEF_INT )
Berechnet einen leeren Plan
Plan dribble( const double staminaLimit, const double direction, const int side )
Berechnet den Plan fuer ein Dribbel-Manoever
Vector findEmptySector( const Situation& aSituation )
Sucht einen freien Sektor auf dem Weg zu einem Ziel
Plan gainBallControl()
Berechnet einen Plan, um die alleinige Ballkontrolle zu erlangen
Plan gotoRegion( const Vector& centerOfTarget, double targetRadius = TRIANGULATION_ACCURACY, const double staminaLimit = 0, const int specialBehavior = AVOID_OBSTACLES, int desiredMaxLengthOfPlan = UNDEF_INT )
Berechnet den Plan, um zu einer gegebenen Region zu gelangen
void initEmptySectorSearch( const Vector& aFinalTarget, const double aSectorAngle, const double aSectorLength, const double aMaxDeviation, const double aStepAngle )
Setzt die Rahmenparameter für die Suche nach einem freien Sektor
Plan kickBall( const double power, const double direction )
Berechnet den Plan, um einen gegebenen Kick auszufuehren
void resetSituation( Situation scenario = globalWorldModel->situation() )
Setzt die Ausgangssituation für die einzelnen Skills zurück
Plan sayWorldModel()
Berechnet den Plan fuer den WorldModell-Ruf
Plan setViewWidth( const desiredViewWidth )
Erzeugt einen Plan zum Umstellen der Breite des Blickwinkels
Action simpleCatch( const double angle )
Liefert die Aktion fuer das Greifen nach dem Ball (nur fuer Torwart)
Action simpleChangeView( const int width, const int quality )
Liefert die Aktion fuer eine Sichtaenderung
Action simpleDash( const double power )
Liefert die Aktion fuer eine Beschleunigung um die angegebene Staerke
Action simpleEmptyAction( )
Liefert eine leere Aktion
Action simpleKick( const double power, const double angle )
Liefert die Aktion fuer ein Kick
Action simpleMoveTo( const Vector& position )
Liefert die Aktion fuer ein Move auf die angegebene Position
Action simpleSay( const String& message )
Liefert die Aktion fuer das Rufen einer Nachricht
Action simpleSenseBody( )
Liefert die Aktion zur Anfrage ueber den Koerper
Action simpleTurn( const double angle )
Liefert den Plan fuer eine Drehung um den angegebenen Winkel
Skills()
Initialisiert ein Skills-Objekt
Plan turnBy( double turnAngle )
Berechnet den Plan fuer eine Drehung um einen Winkel
Plan turnTo( double finalDirection )
Berechnet den Plan fuer eine Drehung auf einen Winkel

Private Fields

double innerKickCircleTolerance
Maximale Abweichung/Toleranz f"ur Kickroutine am Innenradius
double intermediateKickTolerance
Maximale Abweichung/Toleranz f"ur Kickroutine für Zwischenziele
double kickPowerRate
KickPowerRate
double maxKickRadius
obere Grenze fuer Kick-Entfernung (kickRange)
int maxLengthOfPlan
maximale Laenge eines Planes
double maxSpeedOfBall
maximale Geschwindigkeit des Balls
double maxSpeedOfPlayer
maximale Geschwindigkeit eines Spielers
double minKickRadius
untere Grenze fuer Kick-Entfernung (playerRadius + ballRadius)
double optimalKickRadius
optimale Entfernung von Ball und Spieler fuer kick (optimalKickDist)
double outerKickCircleTolerance
Maximale Abweichung/Toleranz f"ur Kickroutine am Außenradius
Vector theFinalTarget
Ziel fuer die Suche nach einem freien Sektor
double theMaxDeviation
Maximaler Winkel, um den der gefundene Sektor von der Zielrichtung abweichen darf (im Bogenmaß)
double theSectorAngle
Breite des freien Sektor im Bogenmaß
double theSectorLength
Länge des freien Sektor in Metern
Situation theSituation
Situation, auf der die einzelnen Skills arbeiten
double theStepAngle
Schrittweite, in der nach einem Sektorwinkel gesucht wird

Private Methods

const ModelledBall& ball()
Liefert den ball der Situation
Vector bestKickVector(const Vector& desiredKick, const Vector& calculatedKick, const ModelledBall& cBall, const ModelledPlayer& cPlayer)
Beste Alternative wenn der urspr"ungliche Kickvektor zur Kollision fuehrt
Vector calcKickToRelPos( const Vector& aRelativeVector, const ModelledBall& aBall, const ModelledPlayer& aPlayer, int steps = 1)
Berechnet den KickVector aus dem Entfernungsvector, den der Ball in steps Schritten zuruecklegen soll, unter Zuhilfenahme von getKickVector
bool checkBallInDribbleKickRange( const Vector& desiredKick, const ModelledBall& cBall, const ModelledPlayer& cPlayer, int side)
YES wenn im naechsten Schritt bei Kick mit desiredKick, der Ball noch im Kickbereich und auf richtiger Seite und nicht hinter dem Spieler
bool checkBallInKickRange( const Vector& desiredKick, const ModelledBall& cBall, const ModelledPlayer& cPlayer )
YES wenn im naechsten Schritt bei Kick mit desiredKick Ball noch im Kickbereich
bool checkBodyContact(const Vector& desiredKick, const ModelledBall& cBall, const ModelledPlayer& cPlayer)
Test ob im n"achsten Takt eine Kollision stattfindet
Vector desiredBallPos( int apos, const int aside )
Liefert beim dribbeln den relativen Vector zur gewuenschten Ballposition pos
const Vector& finalTarget()
Ziel fuer die Suche nach einem freien Sektor
Vector getKickVector(const Vector& desiredKick, const ModelledBall& ball, const ModelledPlayer& player)
Liefert einen wahren Schußvektor, d
Vector getPassVector(const Vector& desiredKick, const ModelledBall& ball, const ModelledPlayer& player)
Liefert den f"ur einen Pass aus den Zielvektor desiredKick n"otigen wahren Kickvektor
Vector makeRelativeKick( const Vector& desiredKick, const ModelledBall& ball, const ModelledPlayer& player )
Macht den Kick relativ zum Spieler
double maxDeviation()
Maximaler Winkel, um den der gefundene Sektor von der Zielrichtung abweichen darf (im Bogenmaß)
const ModelledPlayer& player()
Liefert den ModelledPlayer des Agenten der Situation
double sectorAngle()
Breite des freien Sektor im Bogenmaß
double sectorLength()
Länge des freien Sektor in Metern
Situation& situation()
Liefert die Situation, von der die nächste Skill-Routine ausgeht
Vector Skills::getKickToRadius( const Vector& desiredKick, const ModelledBall& aBall, const ModelledPlayer& aPlayer )
Ermittelt einen Kick, der am Kickradius endet
double stepAngle()
Schrittweite, in der nach einem Sektorwinkel gesucht wird

Documentation

Die Fähigkeiten des Agenten. Options verwendet Skills, um Plaene zu erzeugen. Ein Plan ist dabei eine Folge von konkreten Aktionen, die an den SoccerServer geschickt werden koennen.

Im Skills-Objekt gibt es eine Ausgangssituation, die anfänglich auf die aktuelle Situation des Weltmodells gesetzt ist. Jeder Aufruf einer Fähigkeit führt zu Änderungen an dieser Situation, so daß der beim Aufruf der nächsten Fähigkeit die neue, modifizierte Situation als Ausgangssituation genomment werden kann. Vor der Berechnung jedes Plans muß die Ausgangssituation mit resetSituation() auf die Gegenwart zurückgesetzt werden. Eine Referenz auf die Situation ist intern über die private Methode situation() verfügbar.

Quelltext

[Header | [Implementierung]

CVS Informationen zum Interface

  **************************************************
  *
  * Aktueller Stand
  *
  *   $RCSfile: Skills.h,v $
  *   $Revision: 1.30 $
  *   $Date: 1998/08/14 13:21:17 $
  *   $Author: myritz $ 
  *
  **************************************************
  
const double MIN_TURN_ANGLE_IN_DEGREE
Minimale Drehung, die ausgeführt werden soll

const int STANDARD_BEHAVIOR
Konstante zur Steuerung des Verhaltens f"ur gotoRegion. Die Konstanten können addiert werden, um mehrere Verhaltensweisen gleichzeitig angeben zu können.
See Also:
gotoRegion

const int AVOID_OBSTACLES
Konstante zur Steuerung des Verhaltens f"ur gotoRegion
See Also:
gotoRegion

const int RUN_BACKWARDS
Konstante zur Steuerung des Verhaltens f"ur gotoRegion
See Also:
gotoRegion

Skills()
Initialisiert ein Skills-Objekt. Es ist nicht sinnvoll mehrere Skills-Objekte zu haben.

Plan beamToPosition( const Vector& position )
Erzeugt einen Plan um den Spieler auf die angegebene Position zu beamen. Das Sichtfeld wird dabei wieder auf das maximal moegliche Sichtfeld eingestellt.
Parameters:
position - Posistion auf die gebeamt werden soll.

Plan gotoRegion( const Vector& centerOfTarget, double targetRadius = TRIANGULATION_ACCURACY, const double staminaLimit = 0, const int specialBehavior = AVOID_OBSTACLES, int desiredMaxLengthOfPlan = UNDEF_INT )
Berechnet den Plan, um zu einer gegebenen Region zu gelangen. Diese Region ist kreisfoermig und wird durch einen Mittelpunkt und einen Radius bestimmt. Der Radius darf nicht kleiner als TRIANGULATION_ACCURACY sein.
Parameters:
centerOfTarget - Mittelpunkt der Zielregion.
targetRadius - Der Radius der Zielregion.
staminaLimit - die untere Staminagrenze (default 0)
specialBehavior. - Hier kann eine Summe von Verhaltenskonstanten angegeben werden. Möglich sind bisher: AVOID_OBSTACLES; wenn dieser Wert angegeben ist, werden Hindernisse (also andere Spieler) umgangen (default). RUN_BACKWARDS; ist dieser Wert angegeben, rennt der Spieler rückwärts (was wesentlich langsamer ist). STANDARD_BEHAVIOR: Halt nix besondres.
desiredMaxLengthOfPlan - gewünschte Länge des Planes. (default UNDEF_INT was dann maxLengthOfPlan ergibt).

Plan kickBall( const double power, const double direction )
Berechnet den Plan, um einen gegebenen Kick auszufuehren. Kraft und Richtung sind absolute Werte.

Plan gainBallControl()
Berechnet einen Plan, um die alleinige Ballkontrolle zu erlangen. Dabei wird einfach um 90 Grad gedreht, dann in die Richtung geschossen, und dann hinterhergerannt. Durch die vorherige Drehung in die Laufrichtung erhalten wir (hoffentlich) einen Vorsprung, der der InterceptBallOption genügen sollte, um zuerst am Ball zu sein.

Plan dribble( const double staminaLimit, const double direction, const int side )
Berechnet den Plan fuer ein Dribbel-Manoever. Die Richtung ist ein absoluter Wert.
Parameters:
staminaLimit - Der Staminawert, der nicht unterschritten werden darf.
direction - Die Richtung, in die gedribbelt werden soll.
side - Die Seite des Spielers (in Blickrichtung), auf der der Ball gehalten werden soll. Mögliche Werte sind LEFT_SIDE_ID, RIGHT_SIDE_ID, UNDEF_SIDE_ID.

Plan turnTo( double finalDirection )
Berechnet den Plan fuer eine Drehung auf einen Winkel
Returns:
Ein Plan, der aus mehreren Turn-Aktionen besteht.
Parameters:
finalDirection - Die gewuenschte neue Blickrichtung. Das ist der Winkel eines Vektors von der absoluten Spielerposition zu einer absoluten Zielposition. direction ist also unabhängig von der momentanen Blickrichtung des Spielers.
See Also:
turnBy

Plan turnBy( double turnAngle )
Berechnet den Plan fuer eine Drehung um einen Winkel
Returns:
Ein Plan, der aus mehreren Turn-Aktionen besteht.
Parameters:
direction - Die gewuenschte neue Blickrichtung. Das ist der Winkel eines Vektors von der absoluten Spielerposition zu einer absoluten Zielposition. direction ist also unabhängig von der momentanen Blickrichtung des Spielers.
See Also:
turnTo

Plan setViewWidth( const desiredViewWidth )
Erzeugt einen Plan zum Umstellen der Breite des Blickwinkels. Der Plan kann auch leer sein.

void initEmptySectorSearch( const Vector& aFinalTarget, const double aSectorAngle, const double aSectorLength, const double aMaxDeviation, const double aStepAngle )
Setzt die Rahmenparameter für die Suche nach einem freien Sektor. Es können mehrere Suchen mit denselben Rahmenparametern (z.B. in verschiedenen Situationen, also auch mit verschiedenen eigenen Positionen durchgeführt werden.
Parameters:
aFinalTarget - Die absolute Zielposition. Hier ist ein Absolutwert notwendig, damit das Ziel unabhängig von der eigenen Position angegeben werden kann.
aSectorAngle - die gewünschte Breite des freien Sektors im Bogenmaß.
aSectorLength - die gewünschte Laenge des Sektors in Metern.
aMaxDeviation - die maximal akzeptable Abweichung der Sektorrichtung von der Richtung zum Ziel.
aStepAngle - die gewünschte Genauigkeit, mit der gesucht werden soll, im Bogenmaß. Ist der Wert klein, wird evtl. ein Sektor gefunden, der mehr zum Ziel hinzeigt als bei größeren Werten. Eine höhere Genauigkeit (also kleinere stepAngle-Werte) führt allerdings auch zu einer längeren Rechenzeit.

Vector findEmptySector( const Situation& aSituation )
Sucht einen freien Sektor auf dem Weg zu einem Ziel. Vor der Suche müssen die Rahmenparameter mit der Funktion initEmptySectorSearch gesetzt werden. Es wird ein Sektor gesucht, in dem keine Spieler stehen. Die abgeschnittene Spitze des Sektors liegt beim Spieler und ist dort so breit wie der Spieler. Die Mitte des Sektors zeigt so weit wie möglich zum Ziel hin.
Returns:
Vektor, der einem Dash- oder Kick-Kommando üebergeben werden muß, damit der Spieler durch die Mitte des freien Sektors läuft/schießt. Gibt es keinen freien Sektor, wird ein Vektor zurückgegeben, dessen isValid-Methode NO liefert.
Parameters:
Die - Situation, in der der Sektor gesucht wird.

Plan sayWorldModel()
Berechnet den Plan fuer den WorldModell-Ruf

Plan doNothing(int steps = UNDEF_INT )
Berechnet einen leeren Plan.
Parameters:
steps - Länge des Plans. (default: maxLengthOfPlan )

Action simpleChangeView( const int width, const int quality )
Liefert die Aktion fuer eine Sichtaenderung

Action simpleMoveTo( const Vector& position )
Liefert die Aktion fuer ein Move auf die angegebene Position

Action simpleTurn( const double angle )
Liefert den Plan fuer eine Drehung um den angegebenen Winkel

Action simpleDash( const double power )
Liefert die Aktion fuer eine Beschleunigung um die angegebene Staerke

Action simpleKick( const double power, const double angle )
Liefert die Aktion fuer ein Kick. Der angegebene Winkel ist relativ zum Spieler.

Action simpleSay( const String& message )
Liefert die Aktion fuer das Rufen einer Nachricht

Action simpleCatch( const double angle )
Liefert die Aktion fuer das Greifen nach dem Ball (nur fuer Torwart)

Action simpleSenseBody( )
Liefert die Aktion zur Anfrage ueber den Koerper

Action simpleEmptyAction( )
Liefert eine leere Aktion

void resetSituation( Situation scenario = globalWorldModel->situation() )
Setzt die Ausgangssituation für die einzelnen Skills zurück. Nach dem Aufruf dieser Routine ist die Ausgangssituation die aktuelle Situation des Weltmodells.

Diese Routine muß unbedingt jedesmal aufgerufen werden, bevor ein Plan erstellt wird, der von der Gegenwart ausgeht. Jeder Aufruf einer Fähigkeit ändert dann die Ausgangssituation.

Parameters:
scenario - Szenario welches die Ausgangssituation auf ein anderes als das aktuelle Weltbildszenario setzt.

Situation& situation()
Liefert die Situation, von der die nächste Skill-Routine ausgeht. Der simStep dieser Situation ist grösser/gleich der aktuellen Situation im Weltmodell.
Returns:
eine Referenz auf die Ausgangssituation. Sie darf modifiziert werden.

const ModelledPlayer& player()
Liefert den ModelledPlayer des Agenten der Situation

const ModelledBall& ball()
Liefert den ball der Situation

Vector getKickVector(const Vector& desiredKick, const ModelledBall& ball, const ModelledPlayer& player)
Liefert einen wahren Schußvektor, d.h. einen Vektor der die wahre Zielrichtung ergibt.

Vector getPassVector(const Vector& desiredKick, const ModelledBall& ball, const ModelledPlayer& player)
Liefert den f"ur einen Pass aus den Zielvektor desiredKick n"otigen wahren Kickvektor

bool checkBodyContact(const Vector& desiredKick, const ModelledBall& cBall, const ModelledPlayer& cPlayer)
Test ob im n"achsten Takt eine Kollision stattfindet

Vector bestKickVector(const Vector& desiredKick, const Vector& calculatedKick, const ModelledBall& cBall, const ModelledPlayer& cPlayer)
Beste Alternative wenn der urspr"ungliche Kickvektor zur Kollision fuehrt

Vector calcKickToRelPos( const Vector& aRelativeVector, const ModelledBall& aBall, const ModelledPlayer& aPlayer, int steps = 1)
Berechnet den KickVector aus dem Entfernungsvector, den der Ball in steps Schritten zuruecklegen soll, unter Zuhilfenahme von getKickVector

bool checkBallInDribbleKickRange( const Vector& desiredKick, const ModelledBall& cBall, const ModelledPlayer& cPlayer, int side)
YES wenn im naechsten Schritt bei Kick mit desiredKick, der Ball noch im Kickbereich und auf richtiger Seite und nicht hinter dem Spieler. NO sonst

bool checkBallInKickRange( const Vector& desiredKick, const ModelledBall& cBall, const ModelledPlayer& cPlayer )
YES wenn im naechsten Schritt bei Kick mit desiredKick Ball noch im Kickbereich. NO sonst

Vector desiredBallPos( int apos, const int aside )
Liefert beim dribbeln den relativen Vector zur gewuenschten Ballposition pos

Vector Skills::getKickToRadius( const Vector& desiredKick, const ModelledBall& aBall, const ModelledPlayer& aPlayer )
Ermittelt einen Kick, der am Kickradius endet
Parameters:
desiredKick - Vector, der die gewuenschte Kickrichtung enthaelt

Vector makeRelativeKick( const Vector& desiredKick, const ModelledBall& ball, const ModelledPlayer& player )
Macht den Kick relativ zum Spieler. Die Laenge des Vektors ist der Power-Wert, der simpleKick uebergeben werden kann.

double minKickRadius
untere Grenze fuer Kick-Entfernung (playerRadius + ballRadius)

double maxKickRadius
obere Grenze fuer Kick-Entfernung (kickRange)

double optimalKickRadius
optimale Entfernung von Ball und Spieler fuer kick (optimalKickDist)

double maxSpeedOfPlayer
maximale Geschwindigkeit eines Spielers

double maxSpeedOfBall
maximale Geschwindigkeit des Balls

int maxLengthOfPlan
maximale Laenge eines Planes

double kickPowerRate
KickPowerRate

double outerKickCircleTolerance
Maximale Abweichung/Toleranz f"ur Kickroutine am Außenradius

double innerKickCircleTolerance
Maximale Abweichung/Toleranz f"ur Kickroutine am Innenradius

double intermediateKickTolerance
Maximale Abweichung/Toleranz f"ur Kickroutine für Zwischenziele

Vector theFinalTarget
Ziel fuer die Suche nach einem freien Sektor

double theSectorAngle
Breite des freien Sektor im Bogenmaß

double theSectorLength
Länge des freien Sektor in Metern

double theStepAngle
Schrittweite, in der nach einem Sektorwinkel gesucht wird

double theMaxDeviation
Maximaler Winkel, um den der gefundene Sektor von der Zielrichtung abweichen darf (im Bogenmaß)

const Vector& finalTarget()
Ziel fuer die Suche nach einem freien Sektor

double sectorAngle()
Breite des freien Sektor im Bogenmaß

double sectorLength()
Länge des freien Sektor in Metern

double stepAngle()
Schrittweite, in der nach einem Sektorwinkel gesucht wird

double maxDeviation()
Maximaler Winkel, um den der gefundene Sektor von der Zielrichtung abweichen darf (im Bogenmaß)

Situation theSituation
Situation, auf der die einzelnen Skills arbeiten


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