gAIPlayer Class Reference

#include <gAIBase.h>

Inheritance diagram for gAIPlayer:

[legend]

Collaboration diagram for gAIPlayer:

[legend]

List of all members.

Public Member Functions
gAICharacter *	Character () const
	gAIPlayer ()
	~gAIPlayer ()
void	ClearTarget ()
virtual void	ControlObject (eNetGameObject *c)
virtual void	ClearObject ()
virtual REAL	Think ()
bool	Alive ()
virtual bool	IsHuman () const
gCycle *	Object ()
void	Timestep (REAL time)
virtual void	NewObject ()
virtual void	RightBeforeDeath (int triesLeft)
virtual void	Color (REAL &r, REAL &g, REAL &b) const
virtual nDescriptor &	CreatorDescriptor () const
	gAIPlayer (nMessage &m)
Static Public Member Functions
static void	ClearAll ()
	remove all AI players
static void	CycleBlocksWay (const gCycleMovement *a, const gCycleMovement *b, int aDir, int bDir, REAL bDist, int winding)
static void	CycleBlocksRim (const gCycleMovement *a, int aDir)
static void	BreakWall (const gCycleMovement *a, REAL aDist)
static void	ConfigureAIs ()
static void	SetNumberOfAIs (int num, int minPlayers, int iq, int tries=3)
Protected Member Functions
void	SetTraceSide (int side)
void	SwitchToState (gAI_STATE nextState, REAL minTime=10)
virtual void	ThinkSurvive (ThinkData &data)
virtual void	ThinkTrace (ThinkData &data)
virtual void	ThinkPath (ThinkData &data)
virtual void	ThinkCloseCombat (ThinkData &data)
virtual bool	EmergencySurvive (ThinkData &data, int enemyEvade=-1, int preferedSide=0)
virtual void	EmergencyTrace (ThinkData &data)
virtual void	EmergencyPath (ThinkData &data)
virtual void	EmergencyCloseCombat (ThinkData &data)
virtual void	ActOnData (ThinkData &data)
virtual void	ActOnData (ThinkDataBase &data)
Protected Attributes
gSimpleAI *	simpleAI_
gAICharacter *	character
nObserverPtr< gCycle >	target
ePath	path
REAL	lastPath
int	traceSide
REAL	lastChangeAttempt
REAL	lazySideChange
gAI_STATE	state
REAL	nextStateChange
bool	emergency
int	triesLeft
REAL	freeSide
REAL	lastTime
REAL	nextTime
REAL	concentration
gAILog *	log
Private Attributes
tReproducibleRandomizer	randomizer_
Friends
class	gAITeam
Classes
struct	ThinkData
struct	ThinkDataBase

---

Detailed Description

Definition at line 90 of file gAIBase.h.

---

Constructor & Destructor Documentation

gAIPlayer::gAIPlayer

(

)

Definition at line 1098 of file gAIBase.cpp.

References ePlayerNetID::b, character, ClearTarget(), exp(), freeSide, ePlayerNetID::g, G, GrowingArrayBase::Len(), log, MAXAI_COLOR, NewObject(), NULL, ePlayerNetID::ping, ePlayerNetID::pingCharity, ePlayerNetID::r, REAL, ePlayerNetID::score, se_FloorColor(), se_PlayerNetIDs, and traceSide.

                    :
        simpleAI_(NULL),
        character(NULL),
        //      target(NULL),
        lastPath(se_GameTime()-100),
        lastTime(se_GameTime()),
        nextTime(0),
        concentration(1),
        log(NULL)
{
    character = NULL;
    ClearTarget();
    traceSide = 1;
    freeSide  = 0;
    log       = NULL;

    // find a good color

    current_ai=(current_ai+1) % MAXAI_COLOR;
    int take_ai=current_ai;
    int try_ai=current_ai;

    REAL maxmindist=-10000;

    for(int i=MAXAI_COLOR-1;i>=0;i--){
        REAL mindist=4;
        REAL score=0;
        for (int j=se_PlayerNetIDs.Len()-1;j>=-1;j--){
            REAL R, G, B; // the color we want to avoid

            if (j >= 0)
            {
                ePlayerNetID *p=se_PlayerNetIDs(j);
                if (p && p != this)
                {
                    R = p->r/15.0;
                    G = p->g/15.0;
                    B = p->b/15.0;
                }
                else
                    continue;
            }
            else // last case: j = -1. Test against floor color
            {
                se_FloorColor(R, G, B);
            }
            REAL dist=
                fabs(R - rgb_ai[try_ai][0])+
                fabs(G - rgb_ai[try_ai][1])+
                fabs(B - rgb_ai[try_ai][2]);

            score+=exp(-dist*dist*4);

            if (dist<mindist){
                mindist=dist;
                /*         con << c->r << ":" << rgb_ai[try_ai][0] << '\t'
                           << c->g << ":" << rgb_ai[try_ai][1] << '\t'
                           << c->b << ":" << rgb_ai[try_ai][2] << '\t' << dist << '\n'; */
            }
        }
        //con << "md=" << mindist << "\n\n";
        if (mindist>2)
            mindist=2;

        mindist=-score;

        if (mindist>maxmindist){
            maxmindist=mindist;
            take_ai=try_ai;
        }



        try_ai = ((try_ai+1) % MAXAI_COLOR);
    }


    r = static_cast<int>(rgb_ai[take_ai][0] * 15);
    g = static_cast<int>(rgb_ai[take_ai][1] * 15);
    b = static_cast<int>(rgb_ai[take_ai][2] * 15);


    ping = 0;
    pingCharity = 300;

    NewObject();
}

Here is the call graph for this function:

gAIPlayer::~gAIPlayer

(

)

Definition at line 2985 of file gAIBase.cpp.

References ClearObject(), log, NULL, target, and tCHECK_DEST.

{
    target=NULL;
    ClearObject();
    tCHECK_DEST;

    delete log;
    log = NULL;
}

Here is the call graph for this function:

gAIPlayer::gAIPlayer

(

nMessage &

m

)

Definition at line 1085 of file gAIBase.cpp.

                                :
        ePlayerNetID(m),
        character(NULL),
        //      target(NULL),
        lastPath(se_GameTime()-100),
        lastTime(se_GameTime()),
        nextTime(0),
        concentration(1),
        log(NULL)
{
}

---

Member Function Documentation

void gAIPlayer::SetTraceSide

(

int

side

)

[protected]

Definition at line 1349 of file gAIBase.cpp.

References lastChangeAttempt, lazySideChange, REAL, se_GameTime(), traceSide, and ts.

Referenced by CycleBlocksWay(), EmergencySurvive(), ThinkCloseCombat(), and ThinkTrace().

{
    REAL time = se_GameTime();
    REAL ts   = time - lastChangeAttempt + 1;
    lastChangeAttempt = time;

    lazySideChange += ts * side;
    if (lazySideChange * traceSide <= 0)
    {
        // state change!
        traceSide = lazySideChange > 0 ? 1 : -1;
        lazySideChange = 10 * traceSide;
    }

    if (lazySideChange > 10)
        lazySideChange = 10;
    if (lazySideChange < -10)
        lazySideChange = -10;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void gAIPlayer::SwitchToState	(	gAI_STATE	nextState,
		REAL	minTime = 10
	)			[protected]

Definition at line 1370 of file gAIBase.cpp.

References AI_CLOSECOMBAT, AI_PATH, AI_STATE_CLOSECOMBAT, AI_STATE_PATH, AI_STATE_TRACE, AI_SURVIVE, AI_TRACE, character, con, nextStateChange, gAICharacter::properties, Random(), se_GameTime(), and state.

Referenced by CycleBlocksWay(), EmergencySurvive(), RightBeforeDeath(), Think(), ThinkCloseCombat(), ThinkPath(), ThinkSurvive(), and ThinkTrace().

{
    int thisAbility = 10 - character->properties[AI_STATE_TRACE];
    switch (state)
    {
    case AI_TRACE:
        thisAbility = character->properties[AI_STATE_TRACE];
        break;
    case AI_CLOSECOMBAT:
        thisAbility = character->properties[AI_STATE_CLOSECOMBAT];
        break;
    case AI_PATH:
        thisAbility = character->properties[AI_STATE_PATH];
        break;
    case AI_SURVIVE:
        break;
    };

    int nextAbility = 10;
    switch (nextState)
    {
    case AI_TRACE:
        nextAbility = character->properties[AI_STATE_TRACE];
        break;
    case AI_CLOSECOMBAT:
        nextAbility = character->properties[AI_STATE_CLOSECOMBAT];
        break;
    case AI_PATH:
        nextAbility = character->properties[AI_STATE_PATH];
        break;
    case AI_SURVIVE:
        break;
    };


    if (nextAbility > thisAbility && Random() * 10 > nextAbility)
        return;

#ifdef DEBUG
    if (state != nextState)
        con << "Switching to state " << nextState << "\n";
#endif

    state           = nextState;
    nextStateChange = se_GameTime() + minTime;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void gAIPlayer::ThinkSurvive

(

ThinkData &

data

)

[protected, virtual]

Definition at line 1418 of file gAIBase.cpp.

References AI_CLOSECOMBAT, character, eSensor::detect(), eCoord, EmergencySurvive(), gAISensor::front, eGrid::GameObjects(), eGameObject::Grid(), gSENSOR_RIM, eSensor::hit, IsTrapped(), gAIPlayer::ThinkData::left, GrowingArrayBase::Len(), nextStateChange, NULL, Object(), eGameObject::Position(), Random(), REAL, gAIPlayer::ThinkData::right, se_GameTime(), st_Breakpoint(), SwitchToState(), target, eGameObject::Team(), gAIPlayer::ThinkDataBase::thinkAgain, and gHitData::wallType.

Referenced by Think().

{
    if (!character)
    {
        st_Breakpoint();
        return;
    }

    REAL random = 0;
    // do nothing much. Rely on the emergency program.
    /*
      random=10*(Random()/float(1));
      if (random < .2)
      EmergencySurvive(front, left, right, -1, 1);
      else if (random > 9.8)
      EmergencySurvive(front, left, right, -1, -1);
      else
      if (front.front.wallType == gSENSOR_RIM && front.distance < 10)
      st_Breakpoint();


    */

    if (data.left.front.wallType == gSENSOR_RIM)
        EmergencySurvive( data, 1);
    else if (data.right.front.wallType == gSENSOR_RIM)
        EmergencySurvive( data, -1);
    else
        EmergencySurvive( data );



    if (nextStateChange > se_GameTime())
    {
        data.thinkAgain = .5f;
        return;
    }

    // switch from Survival to close combat if surviving is too boring
    random=10*Random();
    if (random < 5)
    {
        // find a new victim:
        eCoord enemypos=eCoord(1000,100);

        const tList<eGameObject>& gameObjects = Object()->Grid()->GameObjects();
        gCycle *secondbest = NULL;

        // find the closest enemy
        for (int i=gameObjects.Len()-1;i>=0;i--){
            gCycle *other=dynamic_cast<gCycle *>(gameObjects(i));

            if (other && other->Team()!=Object()->Team() &&
                    !IsTrapped(other, Object())){
                // then, enemy is realy an enemy
                eCoord otherpos=other->Position()-Object()->Position();
                if (otherpos.NormSquared()<enemypos.NormSquared()){
                    // check if the path is clear
                    gSensor p(Object(),Object()->Position(),otherpos);
                    p.detect(REAL(.98));
                    secondbest = dynamic_cast<gCycle *>(other);
                    if (p.hit>=.98){
                        enemypos = otherpos;
                        target = secondbest;
                    }
                }
            }
        }

        if (!target)
            target = secondbest;

        if (target)
            SwitchToState(AI_CLOSECOMBAT, 1);
    }

    data.thinkAgain = 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void gAIPlayer::ThinkTrace

(

ThinkData &

data

)

[protected, virtual]

Definition at line 1497 of file gAIBase.cpp.

References a, AI_CLOSECOMBAT, ePlayerNetID::b, Conj, Delay(), eSensor::detect(), gAISensor::distance, eCoord, gHitData::edge, EmergencySurvive(), gAISensor::front, gAIPlayer::ThinkData::front, eGrid::GameObjects(), eGameObject::Grid(), gSENSOR_RIM, eSensor::hit, gAISensor::Hit(), IsTrapped(), gAIPlayer::ThinkData::left, GrowingArrayBase::Len(), nextStateChange, NULL, Object(), eHalfEdge::Other(), eHalfEdge::Point(), eGameObject::Position(), REAL, gAIPlayer::ThinkData::right, se_GameTime(), SetTraceSide(), gCycleMovement::Speed(), SwitchToState(), target, eGameObject::Team(), gAIPlayer::ThinkDataBase::thinkAgain, traceSide, and gHitData::wallType.

Referenced by Think().

{
    gAISensor const & front = data.front;
    gAISensor const & left = data.left;
    gAISensor const & right = data.right;

    bool inverse = front.Hit() && front.distance < Object()->Speed() * Delay();

    if (left.front.wallType == gSENSOR_RIM)
        SetTraceSide(1);

    if (right.front.wallType == gSENSOR_RIM)
        SetTraceSide(-1);

    bool success = EmergencySurvive(data, 0, traceSide * ( inverse ? -1 : 1));

    REAL & nextTurn = data.thinkAgain;
    nextTurn = 100;
    if (left.front.edge)
    {
        REAL a = eCoord::F(Object()->Direction(), *left.front.edge->Point() - Object()->Position());
        REAL b = eCoord::F(Object()->Direction(), *left.front.edge->Other()->Point() - Object()->Position());

        if (a < b)
            a = b;
        if ( a > 0 )
            nextTurn = a;
    }

    if (right.front.edge)
    {
        REAL a = eCoord::F(Object()->Direction(), *right.front.edge->Point() - Object()->Position());
        REAL b = eCoord::F(Object()->Direction(), *right.front.edge->Other()->Point() - Object()->Position());

        if (a < b)
            a = b;
        if ( a > 0 && a < nextTurn || !left.front.edge)
            nextTurn = a;
    }

    nextTurn/= Object()->Speed() * .98f;

    REAL delay = Delay() * 1.5f;
    if ((!Object()->CanMakeTurn(1) || !Object()->CanMakeTurn(-1) || success) && nextTurn > delay)
        nextTurn = delay;

    if (nextTurn > .3f)
        nextTurn = .3f;

    if (nextStateChange > se_GameTime())
        return;

    // find a new victim:
    eCoord enemypos=eCoord(1000,100);

    const tList<eGameObject>& gameObjects = Object()->Grid()->GameObjects();
    gCycle *secondbest = NULL;

    // find the closest enemy
    for (int i=gameObjects.Len()-1;i>=0;i--){
        gCycle *other=dynamic_cast<gCycle *>(gameObjects(i));

        if (other && other->Team()!=Object()->Team() &&
                !IsTrapped(other, Object())){
            // then, enemy is realy an enemy
            eCoord otherpos=other->Position()-Object()->Position();
            if (otherpos.NormSquared()<enemypos.NormSquared()){
                // check if the path is clear
                gSensor p(Object(),Object()->Position(),otherpos);
                p.detect(REAL(.98));
                secondbest = dynamic_cast<gCycle *>(other);

                if (!target)
                    enemypos = otherpos;

                if (p.hit>=.98){
                    enemypos = otherpos;
                    target = secondbest;
                }
            }
        }
    }

    eCoord relpos=enemypos.Turn(Object()->Direction().Conj()).Turn(0,1);


    if (!target)
        target = secondbest;
    else
        SwitchToState(AI_CLOSECOMBAT, 1);

    if (target)
        SetTraceSide((relpos.x  > 0 ? 10 : -10) *
                     (target->Speed() > Object()->Speed() ? -1 : 1));

    nextStateChange = se_GameTime() + 10;

    //  SwitchToState(AI_SURVIVE, 1);
    return;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void gAIPlayer::ThinkPath

(

ThinkData &

data

)

[protected, virtual]

Definition at line 1599 of file gAIBase.cpp.

References AI_CLOSECOMBAT, AI_SURVIVE, con, ePath::CurrentOffset(), ePath::CurrentPosition(), d, eSensor::detect(), gCycle::Direction(), gAISensor::distance, eCoord, EmergencySurvive(), eGameObject::FindCurrentFace(), eHalfEdge::FindPath(), ePath::GoBack(), eSensor::hit, IsTrapped(), lastPath, gAIPlayer::ThinkData::left, ls, nextStateChange, Object(), path, pos, eGameObject::Position(), ePath::Proceed(), REAL, gAIPlayer::ThinkData::right, se_GameTime(), gCycleMovement::Speed(), sqrt(), SwitchToState(), target, gAIPlayer::ThinkDataBase::thinkAgain, ePath::Valid(), and z.

Referenced by Think().

{
    int lr = 0;
    REAL mindist = 10;

    eCoord dir = Object()->Direction();
    // REAL fs=front.distance;
    REAL ls=data.left.distance;
    REAL rs=data.right.distance;


    if (!target->CurrentFace() || IsTrapped(target, Object()))
    {
        SwitchToState(AI_SURVIVE, 1);
        EmergencySurvive( data );

        data.thinkAgain = 4;
        return;
    }

    eCoord tDir = target->Position() - Object()->Position();

    if ( nextStateChange < se_GameTime() )
    {
        gSensor p(Object(),Object()->Position(), tDir);
        p.detect(REAL(.9999999));
        if (p.hit >=  .9999999)  // free line of sight to victim. Switch to close combat.
        {
            SwitchToState(AI_CLOSECOMBAT, 5);
            EmergencySurvive( data );

            return;
        }
    }



    // find a new path if the one we got is outdated:
    if (lastPath < se_GameTime() - 10)
        if (target->CurrentFace())
        {
            Object()->FindCurrentFace();
            eHalfEdge::FindPath(Object()->Position(), Object()->CurrentFace(),
                                target->Position(), target->CurrentFace(),
                                Object(),
                                path);
            lastPath = se_GameTime();
        }

    if (!path.Valid())
    {
        data.thinkAgain = 1;
        return;
    }

    // find the most advanced path point that is in our viewing range:

    for (int z = 10; z>=0; z--)
        path.Proceed();

    bool goon   = path.Proceed();
    bool nogood = false;

    do
    {
        if (goon)
            goon = path.GoBack();
        else
            goon = true;

        eCoord pos   = path.CurrentPosition() + path.CurrentOffset() * 0.1f;
        eCoord opos  = Object()->Position();
        eCoord odir  = pos - opos;

        eCoord intermediate = opos + dir * eCoord::F(odir, dir);

        gSensor p(Object(), opos, intermediate - opos);
        p.detect(1.1f);
        nogood = (p.hit <= .999999999 || eCoord::F(path.CurrentOffset(), odir) < 0);

        if (!nogood)
        {
            gSensor p(Object(), intermediate, pos - intermediate);
            p.detect(1);
            nogood = (p.hit <= .99999999 || eCoord::F(path.CurrentOffset(), odir) < 0);
        }

    }
    while (goon && nogood);

    if (goon)
    {
        // now we have found our next goal. Try to get there.
        eCoord pos    = Object()->Position();
        eCoord target = path.CurrentPosition();

        // look how far ahead the target is:
        REAL ahead = eCoord::F(target - pos, dir)
                     + eCoord::F(path.CurrentOffset(), dir);

        if ( ahead > 0)
        {         // it is still before us. just wait a while.
            mindist = ahead;
        }
        else
        { // we have passed it. Make a turn towards it.
            REAL side = (target - pos) * dir;

            if ( !((side > 0 && ls < 3) || (side < 0 && rs < 3))
                    && (fabs(side) > 3 || ahead < -10) )
            {
#ifdef DEBUG
                con << "Following path...\n";
#endif
                lr += (side > 0 ? 1 : -1);
            }
        }
    }
    else // nogood
    {
        lastPath -= 1;
        SwitchToState(AI_SURVIVE);
    }

    EmergencySurvive( data, 1, -lr );

    REAL d = sqrt(tDir.NormSquared()) * .2f;
    if (d < mindist)
        mindist = d;

    data.thinkAgain = mindist / Object()->Speed();
    if (data.thinkAgain > .4)
        data.thinkAgain *= .7;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void gAIPlayer::ThinkCloseCombat

(

ThinkData &

data

)

[protected, virtual]

Definition at line 1735 of file gAIBase.cpp.

References AI_PATH, AI_TRACE, con, gCycle::Direction(), gAISensor::distance, eCoord, EmergencySurvive(), gAIPlayer::ThinkData::front, gAISensor::Hit(), IsTrapped(), gAIPlayer::ThinkData::left, nCLIENT, nextStateChange, Object(), eGameObject::Position(), Random(), REACTION, REAL, gAIPlayer::ThinkData::right, se_GameTime(), SetTraceSide(), sn_GetNetState(), gCycleMovement::Speed(), sr_predictObjects, SwitchToState(), target, and gAIPlayer::ThinkDataBase::thinkAgain.

Referenced by Think().

{
    int lr=0;

    REAL nextThought = 0;

    const gAISensor* sides[2];
    sides[0] = &data.left;
    sides[1] = &data.right;

    eCoord dir = Object()->Direction();
    REAL fs=data.front.distance;
    //  REAL ls=left.hit;
    //  REAL rs=right.hit;

    if ( bool( target ) && !IsTrapped(target, Object()) && nextStateChange < se_GameTime() )
    {
        gSensor p(Object(),Object()->Position(),target->Position() - Object()->Position());
        p.detect(REAL(1));
        if (p.hit <=  .999999)  // no free line of sight to victim. Switch to path mode.
        {
            SwitchToState(AI_PATH, 5);
            EmergencySurvive( data );
            return;
        }
    }

    REAL ed = 0;

    const REAL fear=REAL(.01);
    const REAL caution=.001;
    const REAL evasive=100;
    const REAL attack=100;
    const REAL seek=REAL(1);
    const REAL trap=REAL(.01);
    const REAL ffar=20;
    //    const REAL close=1000;

    REAL random=10*Random()*Random();

    if ( bool( target ) && target->Alive()){

        eCoord enemypos=target->Position()-Object()->Position();
        eCoord enemydir=target->Direction();
        REAL enemyspeed=target->Speed();

        ed=REAL(fabs(enemypos.x)+fabs(enemypos.y));
        ed/=enemyspeed;

        // transform coordinates relative to us:
        enemypos=enemypos.Turn(dir.Conj()).Turn(0,1);
        enemydir=enemydir.Turn(dir.Conj()).Turn(0,1);

        // now we are at the center of the coordinate system facing
        // in direction (0,1).

        // rules are symmetrical: exploit that.
        int side=1;
        if (enemypos.x<0){
            side*=-1;
            enemypos.x*=-1;
            enemydir.x*=-1;

            sides[1] = &data.left;
            sides[0] = &data.right;
            //      Swap(ls,rs);
        }
        // now we can even assume the enemy is on our right side.

        // consider his ping and our reaction time
#define REACTION .2


        //REAL enemyspeed=target->speed;
        REAL ourspeed=Object()->Speed();

        REAL enemydist=target->Lag()*enemyspeed;

        // redo the prediction
#ifndef DEDICATED
        if (sn_GetNetState()==nCLIENT && !sr_predictObjects)
#endif
            enemypos=enemypos-enemydir*enemydist;
        enemydist+=2*REACTION *enemyspeed;

        REAL ourdist=REACTION*ourspeed;;


        // now we consider the worst case: we drive straight on,
        enemypos.y-=ourdist;
        // while the enemy cuts us: he goes in front of us
        REAL forward=-enemypos.y+.01;
        if (forward<0) // no need to go to much ahead
            forward=0;
        if (forward>enemydist)
            forward=enemydist;

        enemypos.y+=forward;
        enemydist-=forward;

        // and then he turns left.
        enemypos.x-=enemydist;

        if (enemypos.y*enemyspeed>enemypos.x*ourspeed){ // he is right ahead of us.
            if (random<fear){ // evade him
#ifdef DEBUG
                con << "fear!\n";
#endif
                lr+=side;

                nextThought += 1;
            }
            if (enemypos.y<=ffar &&
                    ((enemydir.x<0 && random<evasive) ||
                     (enemydir.y>0 && random<caution) ||
                     (enemydir.y<0 && random<attack))){
#ifdef DEBUG
                con << "caution!\n";
#endif
                lr+=side;

                nextThought += 1;

                if (enemyspeed > ourspeed)
                {
                    SetTraceSide(-side);
                    SwitchToState(AI_TRACE, 10);
                }
            }
        }
        else if (enemypos.y*ourspeed<-enemypos.x*enemyspeed){
            /*
              // good attack position
              if (enemypos.x<rs && rs < range*.99){
              #ifdef DEBUG
              con << "BOX!\n";
              #endif
              turn+=10;
              lr-=side;
              }

            */

            REAL canCutIfDriveOn = enemypos.x*ourspeed - fs * (enemyspeed - ourspeed);
            canCutIfDriveOn -= enemypos.y*enemyspeed;

            REAL canCutIfAttack  = - sides[1]->distance * enemyspeed
                                   - (sides[1]->distance - enemypos.x -enemypos.y*ourspeed) * ourspeed;

            if (random<attack && (!(data.front.Hit() && data.front.distance < 20) || canCutIfAttack > canCutIfDriveOn)){
#ifdef DEBUG
                con << "attack!\n";
#endif
                lr-=side;

                nextThought += 1;
            }
        }
        else if(enemypos.x>ffar*4){
            if(random<seek){
#ifdef DEBUG
                con << "seek!\n";
#endif
                lr-=side;

                nextThought += 1;
            }
        }
        else if (enemypos.x<ffar*2 && fabs(enemypos.y)<ffar){
            if(random<trap){
#ifdef DEBUG
                con << "trap!\n";
#endif
                lr+=side;

                nextThought += 1;
            }
        }
    }

    if (!EmergencySurvive(data, 1, -lr))
        nextThought = 0;

    data.thinkAgain = ed/2 + nextThought;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool gAIPlayer::EmergencySurvive	(	ThinkData &	data,
		int	enemyEvade = -1,
		int	preferedSide = 0
	)			[protected, virtual]

Definition at line 2019 of file gAIBase.cpp.

References AI_EMERGENCY, AI_ENEMY, AI_LOOP, AI_TRACE, gCycleMovement::Alive(), character, ePlayerNetID::Chat(), CheckLoop(), gLoopData::closedIn, COLIDELEVEL, gAILog::current, DANGERLEVELS, Delay(), gAILog::DeleteEntry(), eSensor::detect(), gCycle::Direction(), gAISensor::distance, eDebugLine::Draw(), eCoord, emergency, gAILog::entries, freeSide, gAISensor::front, gAIPlayer::ThinkData::front, gAILogEntry::frontDanger, gAISensor::frontLoop, eGrid::GameObjects(), eGameObject::Grid(), gSENSOR_RIM, eSensor::hit, gAISensor::Hit(), tRecorderBase::IsRunning(), IsTrapped(), gAIPlayer::ThinkData::left, GrowingArrayBase::Len(), log, gLoopData::loop, LOOPLEVEL, gHitData::lr, gAILog::NextEntry(), NULL, Object(), gHitData::otherCycle, eGameObject::Position(), gAILog::Print(), gAICharacter::properties, REAL, gAIPlayer::ThinkData::right, se_GameTime(), eDebugLine::SetColor(), eDebugLine::SetTimeout(), SetTraceSide(), gAILogEntry::sideDanger, gAISensor::sideLoop, gArena::SizeMultiplier(), SPACELEVEL, gCycleMovement::Speed(), sqrt(), st_Breakpoint(), SwitchToState(), target, eGameObject::Team(), TEAMLEVEL, gAILogEntry::time, tNEW, TOL, TRAPLEVEL, gAILogEntry::tries, triesLeft, gAIPlayer::ThinkDataBase::turn, gAILogEntry::turn, gHitData::wallType, gCycle::WindingNumber(), and x.

Referenced by EmergencyCloseCombat(), EmergencyPath(), EmergencyTrace(), RightBeforeDeath(), ThinkCloseCombat(), ThinkPath(), ThinkSurvive(), and ThinkTrace().

{
    if (!character)
    {
        st_Breakpoint();
        return false;
    }

    gAISensor const & front = data.front;
    gAISensor const & left = data.left;
    gAISensor const & right = data.right;

    if (!log)
        log = tNEW(gAILog);

#ifdef DEBUG
    static int last = 0;
    if (log->current >= 4
            && log->entries[log->current-2].time > se_GameTime() - .2
            && log->entries[log->current-1].turn * last <= 0
            && log->entries[log->current-1].turn * log->entries[log->current-2].turn < 0
            //      && log->entries[log->current-3].turn * log->entries[log->current-2].turn < 0
            //      && log->entries[log->current-3].turn * log->entries[log->current-4].turn < 0
       )
    {
        log->Print();
        //      st_Breakpoint();
    }
    if ( log->current > 0 )
        last = log->entries[log->current-1].turn;
#endif

    triesLeft = (triesLeft * character->properties[AI_EMERGENCY])/10;

    freeSide *= .95;

    int i, j;

    // don't do a thing if there may be a better way out of we drive on:
    if (triesLeft > 0 &&
            front.front.otherCycle &&
            front.front.otherCycle != Object() &&
            ((front.frontLoop[1].loop && front.front.otherCycle != left .front.otherCycle && left .front.otherCycle)||
             (front.frontLoop[0].loop && front.front.otherCycle != right.front.otherCycle && right.front.otherCycle ) )
       )
        return false;

    // get the delay between two turns
    REAL delay = Delay();
    REAL range = Object()->Speed() * delay;

    // nothing we can do if we cannot make a turn immediately
    if (!Object()->CanMakeTurn(1) || !Object()->CanMakeTurn(-1))
        return false;

    //  bool dontCheckForLoop[2] = { false, false };


    // look out if there is anything bad going on in one of the directions:
    // [signifficance: danger level of n: You'll be (as good as) dead in [10/n delay times] if you drive that way
    int sideDanger[DANGERLEVELS][2];
    int frontDanger[DANGERLEVELS];
    for(i = DANGERLEVELS-1; i>=0; i--)
    {
        sideDanger[i][0] = 0;
        sideDanger[i][1] = 0;
        frontDanger[i]   = 0;
    }

    bool canTrapEnemy = false;

    if (emergency)
    {
        frontDanger[SPACELEVEL] += 40;
    }

    const gAISensor* sides[2];
    sides[0] = &left;
    sides[1] = &right;

    // avoid loops:

    bool isTrapped = IsTrapped(Object(), NULL);

    /*
      if (front.front.wallType == gSENSOR_ENEMY)
      sideDanger[LOOPLEVEL][(1-front.front.lr*enemyevade) >> 1] += 5;
    */  

    if (!isTrapped)
        for (i = 1; i>=0; i--)
        {
            if (front.frontLoop[i].loop && front.distance < 5*sides[i]->distance)
            {
                // if we would close ourself in, make the danger bigger
                if (front.front.otherCycle == Object() && i+i-1 == front.front.lr)
                    sideDanger[LOOPLEVEL][i]+=40;

                sideDanger[LOOPLEVEL][i]+=40;
                for (j = front.frontLoop[i].closedIn.Len()-1; j>=0; j--)
                    if (front.frontLoop[i].closedIn(j) == target)
                        canTrapEnemy = true;
            }

            for (j = 1; j>=0; j--)
                if (front.sideLoop[i][j].loop)
                    sideDanger[LOOPLEVEL][j]++;

            // if we would close ourselfs in by a zigzag in direction i,
            // but not by a u-turn and there is enough space for a u-turn,
            // do it.
            if (sides[i]->frontLoop[1-i].loop  &&
                    !sides[i]->frontLoop[i].loop)
            {
                if (sides[i]->distance > range)
                {
                    frontDanger[LOOPLEVEL]     += 20;
                    sideDanger[LOOPLEVEL][1-i] += 10;
                }
                else // try to make some room so we can evade:
                {
                    frontDanger[LOOPLEVEL]     += 20;

                    sideDanger[LOOPLEVEL][i]   += 10;
                }
            }

            // if we would close ourselves in by a U-Turn, don't do it.
            //  if (sides[i]->frontLoop[i].loop && sides[i].distance < range * 2)
            //    sideDanger[LOOPLEVEL][i] += 40;
        }

    // try to trap the enemy
    if (character->properties[AI_LOOP] >= 10 && canTrapEnemy && !emergency)
        return false;


    /*
      // avoid closing yourself or a teammate in.
      if (front.type == gSENSOR_SELF || front.type == gSENSOR_TEAMMATE)
      {
         if (front.lr > 0)
      sideDanger[][1] +=2;
         else
      sideDanger[][0] +=2;
      }
    */



    {
        if (front.Hit() &&
                ( front.distance + range < sides[0]->distance ||
                  front.distance + range < sides[1]->distance) )
        {
            if ( front.front.wallType == gSENSOR_RIM)
                frontDanger[SPACELEVEL] += static_cast<int>(100 * range * gArena::SizeMultiplier() / (front.distance + range * .1));

            frontDanger[SPACELEVEL] += static_cast<int>(5 * range / (front.distance + range *.2));

            if (front.distance < range)
                frontDanger[SPACELEVEL] += static_cast<int>(20 * range / (front.distance + range *.2)) + 1;
        }


        // avoid close corners:
        for (i = 1; i>=0; i--)
        {
            if (sides[i]->Hit() && //sides[i]->distance < range * 3 &&
                    sides[i]->distance < front.distance + range)
            {
                if ( sides[i]->front.wallType == gSENSOR_RIM)
                    sideDanger[SPACELEVEL][i] += static_cast<int>(150 * range * gArena::SizeMultiplier() / (sides[i]->distance + range * .1));

                sideDanger[SPACELEVEL][i] += static_cast<int>
                                             (range * 5 / (sides[i]->distance + range * .1));

                if (sides[i]->distance < range)
                    sideDanger[SPACELEVEL][i] += static_cast<int>
                                                 (range * 20 / (sides[i]->distance + range * .1));
            }

            // give us a chance to turn around:
            if (frontDanger[SPACELEVEL] * 2 < sideDanger[SPACELEVEL][i])
                sideDanger[LOOPLEVEL][i-i] -= sideDanger[SPACELEVEL][i] * 2;
        }
    }

    // avoid close proximity to other cycles
    const gCycle* target = NULL;
    const tList<eGameObject>& gameObjects = Object()->Grid()->GameObjects();
    gCycle *secondbest = NULL;
    REAL closest = 1000000;
    eCoord dir     = Object()->Direction();

    // find the closest enemy
    for (i=gameObjects.Len()-1;i>=0;i--){
        gCycle *other=dynamic_cast<gCycle *>(gameObjects(i));

        if (other && other->Alive() && other != Object())
        {
            eCoord otherpos=other->Position()-Object()->Position();
            REAL otherNorm = otherpos.NormSquared();

            bool nothit = false;
            if (otherNorm < closest * 4)
            {
                gSensor p(other, other->Position(), -otherpos);
                p.detect(REAL(.9999));
                gSensor q(Object(), Object()->Position(), otherpos);
                q.detect(REAL(.9999));

                nothit = p.hit>=.999 && q.hit >=.999;
            }

            if (other->Team() != Object()->Team())
            {
                // then, enemy is realy an enemy
                //      REAL s = Object()->Speed() * 50;
                if (/* otherNorm < s*s && */ otherNorm < closest)
                {
                    // check if the path is clear
                    secondbest = dynamic_cast<gCycle *>(other);
                    if (nothit){
                        closest = otherNorm;
                        target = secondbest;
                    }
                }
            }
            else if (nothit)
            {
                // he is a teammate. Avoid him.

                eCoord friendpos=other->Position() - Object()->Position();

                // transform coordinates relative to us:
                friendpos=friendpos.Turn(dir.Conj()).Turn(0,1);

                if (friendpos.y > fabs(friendpos.x) * 1.5f)
                    frontDanger[TEAMLEVEL] += 10;
                if (friendpos.x * 2 > -friendpos.y)
                    sideDanger[TEAMLEVEL][1] += 10;
                else if (-friendpos.x * 2 > -friendpos.y)
                    sideDanger[TEAMLEVEL][0] += 10;
            }
        }
    }

    //  if (!target)
    //target = secondbest;

    if (target && character->properties[AI_ENEMY] > 0)
    {
        bool sdanger = false;
        for (i = DANGERLEVELS-1; i>=0; i--)
            sdanger |= sideDanger[i][0] > 4 || sideDanger[i][1] > 4;

        eCoord enemypos=target->Position() - Object()->Position();
        eCoord enemydir=target->Direction();
        REAL enemyspeed=target->Speed();


        // transform coordinates relative to us:
        enemypos=enemypos.Turn(dir.Conj()).Turn(0,1);
        enemydir=enemydir.Turn(dir.Conj()).Turn(0,1);

        if (character->properties[AI_ENEMY] > 7)
        {
            // would he be able to trap us if we drive straight on?
            bool trap[2] = {false, false};

            if (!isTrapped)
                for (i = 1; i>=0; i--)
                {
                    // if the enemy comes racing towards us, check if he could
                    // close us in by touching our own line ON THE OPPOSITE side of i
                    tArray<const gCycle*> closedIn;
                    int winding = 0;

                    bool loop = CheckLoop(target, Object(),
                                          Object()->GetDistance() + 4 * TOL, i, 0,
                                          closedIn, winding);

                    winding -= Object()->WindingNumber();
                    winding += target->WindingNumber();


                    // yes! we shoult turn in direction 1-i to get the target
                    // to the other side.
                    if (loop)
                        if (winding * (i+i-1) < 0)
                        {
                            trap[i] = true;
                            REAL x = enemypos.x * (i+i-1);
                            REAL y = enemypos.y;

                            bool canAccelerateByTurning =
                                ( sides[1-i]->Hit() &&
                                  sides[1-i]->distance < Object()->Speed() * delay * 5 &&
                                  sides[i-i]->distance > Object()->Speed() * delay &&
                                  !sides[i-i]->frontLoop[i].loop) ;

                            bool ohShit = target->Speed() > Object()->Speed() + sqrt(closest);

                            if (ohShit)
                            {
                                SetTraceSide(-(i+i-1));
                                SwitchToState(AI_TRACE, 10);
                            }

                            bool turningIsFutile =
                                front.front.otherCycle == Object() &&
                                sides[1-i]->front.otherCycle == Object() &&
                                front.distance < sides[1-1]->distance * 10 ;

                            if (
                                x < 0 &&
                                (
                                    x * Object()->Speed() < -y * target->Speed() + 1000 ||
                                    canAccelerateByTurning || ohShit
                                )
                                &&
                                !turningIsFutile
                            )
                            {
                                if (enemydir.y < -.2f && y < 0)
                                    SetTraceSide(-(i+i-1));

                                frontDanger[TRAPLEVEL]    += 10;
                            }

                            if ( y > 0 || x < 0 || ohShit
                                    //                     ( y * Object()->Speed() > x * target->Speed()*.9 - 200 || enemyspeed.x * (i+i-1)
                               )
                                sideDanger[TRAPLEVEL][i] += 20;
                            // sideDanger[TRAPLEVEL][i] ++;
                        }
                }
        }

        if (character->properties[AI_ENEMY] > 0)
        {
            // imminent collision check
            REAL totalspeed = enemyspeed + Object()->Speed();

            if ((fabs(enemypos.y) < totalspeed * .3f && fabs(enemypos.x) < totalspeed * .3f))
            {
                REAL diffSpeed  = -enemydir.y * enemyspeed + Object()->Speed();
                if (diffSpeed > 0 && enemydir.y <= .2)
                {
                    REAL enemyFront = enemypos.y / diffSpeed;
                    REAL enemySide  = fabs(enemypos.x) / diffSpeed;
                    if (enemyFront > 0 && enemyFront < .4 + enemySide && fabs(enemypos.y) > fabs(enemypos.x))
                    {
                        frontDanger[COLIDELEVEL] += 1 + int(4 / (enemyFront + .01));
                        //                    SwitchToState( AI_SURVIVE, enemyFront * 4 + 2 );
                    }
                }

                int side = enemypos.x > 0 ? 1 : 0;

                // can we cut him instead of evade him?
                if (Object()->Team() != target->Team() &&
                        ( ( enemydir.y <= -.2 &&
                            enemypos.y*target->Speed()*1.1 > fabs(enemypos.x) * Object()->Speed() ) ||
                          sideDanger[COLIDELEVEL][side] > 0))
                    sideDanger[COLIDELEVEL][1-side]+=5;
                else if ( -(enemypos.y + .3f) * Object()->Speed() < fabs(enemypos.x) * target->Speed()*1.2)
                    sideDanger[COLIDELEVEL][side]+=10;
            }
        }
    }

    eDebugLine::SetTimeout(.5);
    eDebugLine::SetColor  (1, 0, 1);
    eCoord p = Object()->Position();
    eDebugLine::Draw(p, .5, p, 8.5);
    eDebugLine::SetTimeout(0);



    // determine the total danger levels by taking the max of the individual experts:
    int fDanger = 0;
    int sDanger[2] = { 0, 0 };
    for (i = 0; i<DANGERLEVELS; i++)
        // for (i = 1; i< 2; i++)
    {
        if (!fDanger || frontDanger[i] > fDanger + 2)
            fDanger = frontDanger[i];

        for (int j=1; j>=0; j--)
            if (!sDanger[j] || sideDanger[i][j] > sDanger[j] + 2)
                sDanger[j] = sideDanger[i][j];
    }

    // nothing to do if we are not in immediate danger.
    if (!fDanger && !preferedSide)
        return false;


    // decide about your direction:
    int turn = 0;

    turn += sDanger[0];
    turn -= sDanger[1];

    if (!turn)
        turn = (int) freeSide;

    if (!turn && front.front.wallType != gSENSOR_RIM)
        turn = front.front.lr * enemyevade;

    if (!turn)
        turn = (sides[0]->distance > sides[1]->distance ? -1 : 1);

    if (!turn && log->current)
        turn = log->entries[log->current-1].turn;



    // switch to survival mode if we just trapped an enemy
    if (canTrapEnemy)
    {
#ifdef DEBUG
        if ( !tRecorder::IsRunning() )
            Chat(tString( "Hehe! Got you!" ) );
#endif
        SwitchToState(AI_TRACE, 10);

        if (turn)
            this->SetTraceSide(-turn);
    }

    gAILogEntry&e = log->NextEntry();
    e.turn = 0;
    e.tries = triesLeft;
    for (i = DANGERLEVELS-1; i>=0; i--)
    {
        e.frontDanger[i]   = frontDanger[i];
        e.sideDanger[i][0] = sideDanger[i][0];
        e.sideDanger[i][1] = sideDanger[i][1];
    }


    int side = 1;
    if (preferedSide < 0)
    {
        for (i = DANGERLEVELS-1; i>=0; i--)
        {
            int dSwap = sideDanger[i][0];
            sideDanger[i][0] = sideDanger[i][1];
            sideDanger[i][1] = dSwap;
        }

        int dSwap = sDanger[0];
        sDanger[0] = sDanger[1];
        sDanger[1] = dSwap;

        sides[1] = &left;
        sides[0] = &right;
        side     = -1;
        preferedSide = 1;
    }


    // no problem in the preferred direction. Just take it.
    if (preferedSide)
    {
        if( fDanger  * 3 >= sDanger[1] * 2 - 5 &&
                sDanger[0] * 3 >= sDanger[1] * 2 - 5)
        {
            freeSide -= side*100;
            e.turn = side;
            data.turn = side;
            return true;
        }

        if (fDanger * 2 <= sDanger[0] * 3 + 3)
        {
            log->DeleteEntry();
            return false;
        }
    }

    // it is safer driving straight on
    if (fDanger <= sDanger[0] + 3 && fDanger <= sDanger[1] + 3 && fDanger < 20)
    {
        log->DeleteEntry();
        return false;
    }


    if (turn)
    {
        freeSide -= side*100;
        e.turn = turn;
        data.turn = turn;
    }
    else
        log->DeleteEntry();

    return turn;

    eDebugLine::SetTimeout(0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void gAIPlayer::EmergencyTrace

(

ThinkData &

data

)

[protected, virtual]

Definition at line 2526 of file gAIBase.cpp.

References EmergencySurvive(), and traceSide.

Referenced by RightBeforeDeath().

{
    EmergencySurvive( data, -1, -traceSide );
}

Here is the call graph for this function:

Here is the caller graph for this function:

void gAIPlayer::EmergencyPath

(

ThinkData &

data

)

[protected, virtual]

Definition at line 2532 of file gAIBase.cpp.

References EmergencySurvive().

Referenced by RightBeforeDeath().

{
    EmergencySurvive( data );
}

Here is the call graph for this function:

Here is the caller graph for this function:

void gAIPlayer::EmergencyCloseCombat

(

ThinkData &

data

)

[protected, virtual]

Definition at line 2537 of file gAIBase.cpp.

References EmergencySurvive().

Referenced by RightBeforeDeath().

{
    EmergencySurvive( data );

    /*
      int dir = 0;

      if (target)
      {
         eCoord enemyPos = target->Position() - Object()->Position();
         eCoord dirRel   = Object()->Direction();
         if (enemyPos * dirRel < 0)
      dir --;
         else
      dir ++;
      }


      EmergencySurvive(front, left, right, 1, dir);
    */
}

Here is the call graph for this function:

Here is the caller graph for this function:

void gAIPlayer::ActOnData

(

ThinkData &

data

)

[protected, virtual]

Definition at line 2890 of file gAIBase.cpp.

References eSensor::detect(), eSensor::hit, Object(), REAL, gCycleMovement::Speed(), and gAIPlayer::ThinkDataBase::thinkAgain.

Referenced by RightBeforeDeath(), and Think().

{
    // delegate
    ThinkDataBase & base = data;
    ActOnData( base );

    // sanitize next think time so it will be before we hit the next wall
    if ( Object()->Speed() > 0 && data.thinkAgain > 0 )
    {
        gSensor front( Object(), Object()->Position(), Object()->Direction() );
        front.detect( Object()->Speed() * data.thinkAgain * 1.5 );
        if ( front.ehit )
        {
            REAL thinkAgain = ( front.hit / Object()->Speed() ) * .8;
            if ( data.thinkAgain > thinkAgain )
                data.thinkAgain = thinkAgain;
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void gAIPlayer::ActOnData

(

ThinkDataBase &

data

)

[protected, virtual]

Definition at line 2910 of file gAIBase.cpp.

References EPS, Object(), tRecorder::Playback(), REAL, tRecorder::Record(), st_Breakpoint(), gAIPlayer::ThinkDataBase::thinkAgain, gCycleMovement::Turn(), and gAIPlayer::ThinkDataBase::turn.

{
    // archive decision
    ThinkDataBase copy = data;
    if ( tRecorder::Playback( section, data ) )
    {
        if ( copy.turn != data.turn )
        {
            // AI made a different decision than recorded, better let a programmer have a look at it
            std::cout << "AI turn decision changed!\n";
            st_Breakpoint();
        }

        REAL difference =  fabs( copy.thinkAgain - data.thinkAgain );
        static REAL minReport = EPS;
        if ( difference > minReport )
        {
            minReport = difference * 2;
            std::cout << "AI timing decision changed by " << difference
            << " from " << data.thinkAgain << " to " << copy.thinkAgain <<"!\n";
            st_Breakpoint();
        }
    }
    tRecorder::Record( section, data );

    // execute turn
    if ( data.turn )
        Object()->Turn( data.turn );
}

Here is the call graph for this function:

gAICharacter* gAIPlayer::Character

(

)

const [inline]

Definition at line 178 of file gAIBase.h.

References character.

Referenced by gAITeam::BalanceWithAIs(), BestIQ(), CycleBlocksWay(), and gAISensor::gAISensor().

{return character;}

Here is the caller graph for this function:

void gAIPlayer::ClearAll

(

)

[static]

remove all AI players

Reimplemented from ePlayerNetID.

Definition at line 2995 of file gAIBase.cpp.

References AITeam(), ClearAITeam(), and tReferenceHolder< T >::ReleaseAll().

{
    sg_AIReferences.ReleaseAll();

    // remove empty AI team
    if ( 0 == AITeam()->NumPlayers() )
    {
        ClearAITeam();
    }
}

Here is the call graph for this function:

void gAIPlayer::CycleBlocksWay	(	const gCycleMovement *	a,
		const gCycleMovement *	b,
		int	aDir,
		int	bDir,
		REAL	bDist,
		int	winding
	)			[static]

Definition at line 981 of file gAIBase.cpp.

References a, ai, AI_DETECTTRACE, AI_TRACE, ePlayerNetID::b, Character(), CycleBlocksWayHelper(), gCycleMovement::GetDistance(), lastChangeAttempt, nextStateChange, eNetGameObject::Player(), gAICharacter::properties, REAL, se_GameTime(), SetTraceSide(), gCycleMovement::Speed(), SwitchToState(), target, tASSERT, and eGameObject::Team().

Referenced by blocks().

{


    tASSERT(aa && bb);
    gCycle * a = dynamic_cast< gCycle * >( const_cast< gCycleMovement * > ( aa ) );
    gCycle * b = dynamic_cast< gCycle * >( const_cast< gCycleMovement * > ( bb ) );

    REAL aDist = a->GetDistance();
    aDir = (aDir > 0 ? 1 : 0);
    bDir = (bDir > 0 ? 1 : 0);

    int w = winding + aDir * 2 + bDir * 2;
    while (w < 0)
        w+=400;
    if (w % 4 != 2)
        return;

    CycleBlocksWayHelper(a,b,aDir,bDir,aDist,bDist,  winding);
    CycleBlocksWayHelper(b,a,bDir,aDir,bDist,aDist, -winding);

    // what to do if cylce a tries to trace cylce b?
    if (a->Team() != b->Team())
    {
        gAIPlayer* ai = dynamic_cast<gAIPlayer*>(b->Player());
        if (ai && ai->Character() && ai->Character()->properties[AI_DETECTTRACE] > 5)
            if(aDir != bDir && ai->nextStateChange < se_GameTime() + 5 &&
                    ai->lastChangeAttempt < se_GameTime() - 5 )
            {
                REAL behind = b->GetDistance() - bDist;
                if (a->Speed() > b->Speed() * 1.2f && behind < (a->Speed() - b->Speed()) * 10)
                { // a is faster. Try to escape.
                    ai->SetTraceSide(aDir > 0 ? 1 : -1);
                    ai->SwitchToState(AI_TRACE, 10);
                    ai->target = const_cast< gCycle * >( a );
                }
                else// if (a->Speed() < b->Speed() * 1.1f)
                { // b is faster. Attack.
                    ai->SetTraceSide(aDir > 0 ? -1 : 1);
                    ai->SwitchToState(AI_TRACE, 10 + behind / ( a->Speed() + b->Speed() ) );
                    ai->target = const_cast< gCycle * >( a );
                }
            }

        // what to do if the AI player traces his opponent by accident? Trace On!
        ai = dynamic_cast<gAIPlayer*>(a->Player());
        if (ai && ai->Character() && ai->Character()->properties[AI_DETECTTRACE] > 0)
            if(aDir != bDir && ai->nextStateChange < se_GameTime() + 5 &&
                    ai->lastChangeAttempt < se_GameTime() - 5 )
            {
                REAL behind = b->GetDistance() - bDist;
                ai->SetTraceSide(aDir > 0 ? 1 : -1);
                ai->SwitchToState(AI_TRACE, 10 + 4 * behind / a->Speed());
                ai->target = const_cast< gCycle * >( b );
            }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void gAIPlayer::CycleBlocksRim	(	const gCycleMovement *	a,
		int	aDir
	)			[static]

Definition at line 1041 of file gAIBase.cpp.

Referenced by blocks().

{
}

Here is the caller graph for this function:

void gAIPlayer::BreakWall	(	const gCycleMovement *	a,
		REAL	aDist
	)			[static]

Definition at line 1046 of file gAIBase.cpp.

{}

void gAIPlayer::ConfigureAIs

(

)

[static]

Definition at line 1186 of file gAIBase.cpp.

{

}

void gAIPlayer::SetNumberOfAIs	(	int	num,
		int	minPlayers,
		int	iq,
		int	tries = 3
	)			[static]

Definition at line 1193 of file gAIBase.cpp.

References tReferenceHolder< T >::Add(), ai, AITeam(), gAITeam::BalanceWithAIs(), BestIQ(), character, ClearAITeam(), nNetObject::GetRefcount(), gAICharacter::iq, ePlayerNetID::IsSpectating(), GrowingArrayBase::Len(), gAICharacter::name, ePlayerNetID::NextTeam(), NULL, tReferenceHolder< T >::Remove(), ePlayerNetID::RemoveFromGame(), se_PlayerNetIDs, ePlayerNetID::SetName(), ePlayerNetID::SetTeam(), st_Breakpoint(), tNEW, and ePlayerNetID::UpdateTeam().

Referenced by init_game_objects().

{
    // balance the human teams with AI players
    gAITeam::BalanceWithAIs();

    // remove AI players that got kicked out of their team
    for (int i = se_PlayerNetIDs.Len()-1; i>=0; i--)
    {
        // count the active AIs
        ePlayerNetID *p = se_PlayerNetIDs(i);
        gAIPlayer  *ai  = dynamic_cast<gAIPlayer*>(p);
        if ( ai && !bool( ai->NextTeam() ) )
        {
            ai->RemoveFromGame();

#ifdef DEBUG
            if ( ai->GetRefcount() > 1 )
            {
                st_Breakpoint();
            }
#endif

            sg_AIReferences.Remove( ai );
        }
    }

    int count = 0;

    bool iqperfect = false;

    // repeat until we run out of tries or the total amount of AIs is correct
    do
    {
        count = 0;

        int i;
        gAIPlayer* worstIQ = NULL; // worst fitting AI player that is in the game

        //              static tArray<bool> inGame(gAICharacter::s_Characters.Len());
        //              for (i = gAICharacter::s_Characters.Len()-1; i>=0; i--)
        //                      inGame(i) = false;

        for (i = se_PlayerNetIDs.Len()-1; i>=0; i--)
        {
            // count the active AIs
            ePlayerNetID *p = se_PlayerNetIDs(i);
            gAIPlayer  *ai  = dynamic_cast<gAIPlayer*>(p);
            if (ai && ai->NextTeam() == sg_AITeam )
            {
                //                              int index = ((int)ai->character - (int)&gAICharacter::s_Characters(0))/sizeof(gAICharacter);
                //                              inGame(index) = true;

                if (!worstIQ || !worstIQ->character || fabs(worstIQ->character->iq - iq) < fabs(ai->character->iq - iq) )
                    worstIQ = ai;

                count++;
            }
        }

        gAICharacter* bestIQ = BestIQ( iq );

        // count = numberOfAIs to add / remove(numberofAIs - requestedNumAIs)
        count -= num;

        // pcount = numberPlayers above minPlayers
        int pcount = - minPlayers;
        // check if more AIs are required (because there are less than minPlayers players)
        for (i = se_PlayerNetIDs.Len()-1; i>=0; i--)
        {
            ePlayerNetID *p = se_PlayerNetIDs(i);
            if ( !p->IsSpectating() )
                ++pcount;
        }

        if (pcount < count)
            count = pcount;

        iqperfect = true;
        if (bestIQ && worstIQ && worstIQ->character )
            iqperfect = (fabs(bestIQ->iq - iq) > fabs(worstIQ->character->iq - iq) * .9f);


        // count complete. Do something!
        if (worstIQ && (count > 0 || (count >= 0 && !iqperfect)))
        {
            // too many AIs. Delete the one with the least fitting intelligence.
            worstIQ->RemoveFromGame();
            //                  worstIQ->ReleaseOwnership();

#ifdef DEBUG
            if ( worstIQ->GetRefcount() > 1 )
            {
                st_Breakpoint();
            }
#endif

            sg_AIReferences.Remove( worstIQ );
            count--;

            // remove empty AI team
            if ( 0 == AITeam()->NumPlayers() )
            {
                ClearAITeam();
            }
        }
        if (bestIQ && count < 0)
        {
            // too litte AIs. Create one.
            gAIPlayer *ai = tNEW(gAIPlayer)();
            ai->SetName( bestIQ->name );
            ai->character = bestIQ;

            sg_AIReferences.Add( ai );

            ai->SetTeam ( AITeam() );
            ai->UpdateTeam();

            /*
            {
                tOutput mess;
                tColoredString printname;
                printname << *(ePlayerNetID*)ai << tColoredString::ColorString(.5,1,.5);

                mess.SetTemplateParameter(1, printname);
                mess << "$player_entered_game";

                sn_ConsoleOut( mess );
            }
            */

            count++;
        }

    }
    while ((count != 0 ||
            !iqperfect) &&
            tries-- != 0);

}

Here is the call graph for this function:

Here is the caller graph for this function:

void gAIPlayer::ClearTarget

(

)

[inline]

Definition at line 206 of file gAIBase.h.

References NULL, and target.

Referenced by gAIPlayer(), and NewObject().

{target=NULL;}

Here is the caller graph for this function:

virtual void gAIPlayer::ControlObject

(

eNetGameObject *

c

)

[inline, virtual]

Reimplemented from ePlayerNetID.

Definition at line 208 of file gAIBase.h.

References ePlayerNetID::ControlObject(), NULL, and simpleAI_.

{ ePlayerNetID::ControlObject( c ); simpleAI_ = NULL; }

Here is the call graph for this function:

virtual void gAIPlayer::ClearObject

(

)

[inline, virtual]

Reimplemented from ePlayerNetID.

Definition at line 209 of file gAIBase.h.

References ePlayerNetID::ClearObject(), NULL, and simpleAI_.

Referenced by ~gAIPlayer().

{ ePlayerNetID::ClearObject(); simpleAI_ = NULL; }

Here is the call graph for this function:

Here is the caller graph for this function:

REAL gAIPlayer::Think

(

)

[virtual]

Definition at line 2722 of file gAIBase.cpp.

References ActOnData(), AI_CLOSECOMBAT, AI_PATH, AI_SURVIVE, AI_TRACE, Alive(), gSimpleAIFactory::Create(), Delay(), gCycle::Direction(), eGrid::DirectionWinding(), gAISensor::distance, eDebugLine::Draw(), eCoord, emergency, eGrid::GameObjects(), gSimpleAIFactory::Get(), eGameObject::Grid(), gAISensor::Hit(), GrowingArrayBase::Len(), log, nextStateChange, NULL, Object(), eGameObject::Position(), gAILog::Print(), REAL, se_GameTime(), eDebugLine::SetColor(), eDebugLine::SetTimeout(), sg_GetSensor(), simpleAI_, gCycleMovement::Speed(), sqrt(), st_Breakpoint(), state, SwitchToState(), target, gSimpleAI::Think(), gAIPlayer::ThinkDataBase::thinkAgain, ThinkCloseCombat(), ThinkPath(), ThinkSurvive(), ThinkTrace(), triesLeft, gCycleMovement::Turn(), and x.

Referenced by Timestep().

                     {
    if ( !simpleAI_ )
    {
        gSimpleAIFactory * factory = gSimpleAIFactory::Get();
        if ( factory )
        {
            simpleAI_ = factory->Create( Object() );
        }
    }

    if ( simpleAI_ )
    {
        return simpleAI_->Think();
    }

    // get the delay between two turns
    REAL delay = Delay();

#ifdef DEBUG_X  
    if (log && !Object()->Alive())
    {
        log->Print();
        st_Breakpoint();
        delete log;
        log = NULL;
    }
#endif

    if (!Object()->Alive())
        return 100;

    emergency = false;
    //  return 1;

    // first, find close eWalls and evade them.
    REAL speed=Object()->Speed();
    REAL range=speed;
    eCoord dir=Object()->Direction();
    REAL side=speed*delay;

    REAL corridor = range;
    if (corridor < side * 2)
        corridor = side * 2;

    gAISensor front(Object(),Object()->Position(),dir, side * 2, range, corridor, 0);

#ifdef DEBUG_X
    if (front.Hit())
    {
        gRandomController noRandom;

        if (front.distance < 1)
        {
            int x;
            x = 1;
        }
        gAISensor front(Object(),Object()->Position(),dir, side, range, corridor, 0);
    }
#endif

    // get the sensors to the left and right with the most free space
    int currentDirectionNumber = Object()->Grid()->DirectionWinding( dir );
    REAL mindistLeft = 1E+30, mindistRight = 1E+30;
    std::auto_ptr< gAISensor > left  ( sg_GetSensor( currentDirectionNumber, *Object(), -1, side, range, corridor, mindistLeft ) );
    std::auto_ptr< gAISensor > right ( sg_GetSensor( currentDirectionNumber, *Object(), 1, side, range, corridor, mindistRight ) );

    // count intermediate walls to the left and right as if they were in front
    {
        REAL mindistFront = mindistLeft > mindistRight ? mindistLeft : mindistRight;
        if ( mindistFront < front.distance )
        {
            front.distance = mindistFront;
        }
    }

#ifdef TESTSTATE  
    state = TESTSTATE;
    nextStateChange = se_GameTime() + 100;
#else
    // switch to survival state if our victim died:
    if (state != AI_SURVIVE && state != AI_TRACE && (!target || !target->Alive()))
        SwitchToState(AI_SURVIVE, 1);
#endif

    {
        eDebugLine::SetTimeout(.5);
        eDebugLine::SetColor  (0, 1, 0);
        eCoord p = Object()->Position();
        eDebugLine::Draw(p, .5, p, 5.5);
        eDebugLine::SetTimeout(0);
    }

    triesLeft = 10;

    REAL ret = 1;

    //not the best solution, but still better than segfault...
    if(left.get() != 0 && right.get() != 0) {
        ThinkData data( front, *left, *right);
        switch (state)
        {
        case AI_SURVIVE:
            ThinkSurvive(data);
            break;
        case AI_PATH:
            ThinkPath(data);
            break;
        case AI_TRACE:
            ThinkTrace(data);
            break;
        case AI_CLOSECOMBAT:
            ThinkCloseCombat(data);
            break;
        }
        ActOnData( data );
        ret = data.thinkAgain;
    }

#ifdef DEBUG_X
    {
        gAISensor front(Object(),Object()->Position(),dir, side, range, range*.3, 0);
        gAISensor left(Object(),Object()->Position(),dir.Turn(eCoord(0,1)), side, range, range*.3, -1);
        gAISensor right(Object(),Object()->Position(),dir.Turn(eCoord(0,-1)), side, range, range*.3, 1);
    }
#endif

    REAL mindist = front.distance * front.distance * 8;

    const tList<eGameObject>& gameObjects = Object()->Grid()->GameObjects();

    // find the closest enemy
    for (int i=gameObjects.Len()-1;i>=0;i--){
        gCycle *other=dynamic_cast<gCycle *>(gameObjects(i));

        if (other && other != Object()){
            // then, enemy is realy an enemy
            eCoord otherpos=other->Position()-Object()->Position();
            REAL dist = otherpos.NormSquared();

            if (dist < mindist)
                mindist = dist;
        }
    }

    mindist = sqrt(mindist) / (3 * Object()->Speed());

    if (ret > mindist)
        ret = mindist;

    return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool gAIPlayer::Alive

(

)

[inline]

Definition at line 214 of file gAIBase.h.

References gCycleMovement::Alive(), and Object().

Referenced by RightBeforeDeath(), and Think().

                {
        return bool(Object()) && Object()->Alive();
    }

Here is the call graph for this function:

Here is the caller graph for this function:

virtual bool gAIPlayer::IsHuman

(

)

const [inline, virtual]

Reimplemented from ePlayerNetID.

Definition at line 218 of file gAIBase.h.

Referenced by gAITeam::BalanceWithAIs().

{ return false; }

Here is the caller graph for this function:

gCycle* gAIPlayer::Object

(

)

[inline]

Definition at line 220 of file gAIBase.h.

References NULL, ePlayerNetID::Object(), and tASSERT.

Referenced by ActOnData(), Alive(), EmergencySurvive(), RightBeforeDeath(), Think(), ThinkCloseCombat(), ThinkPath(), ThinkSurvive(), ThinkTrace(), and Timestep().

    {
        eGameObject* go = ePlayerNetID::Object();
        if ( !go )
        {
            return NULL;
        }
        else
        {
            tASSERT(dynamic_cast<gCycle*>(go));
            return static_cast<gCycle*>(go);
        }
    }

Here is the call graph for this function:

Here is the caller graph for this function:

void gAIPlayer::Timestep

(

REAL

time

)

Definition at line 2942 of file gAIBase.cpp.

References AI_REACTION, gCycleMovement::Alive(), character, concentration, EPS, lastTime, nextTime, Object(), gAICharacter::properties, randomizer_, REAL, st_Breakpoint(), Think(), and ts.

Referenced by gGame::GameLoop().

                                 {
    if (!character)
    {
        st_Breakpoint();
        return;
    }

    // don't think if the object is not up to date
    if ( Object() && Object()->LastTime() < time - EPS )
        return;

    REAL ts=time-lastTime;
    lastTime=time;

    if (concentration < 0)
        concentration = 0;

    concentration += 4*(character->properties[AI_REACTION]+1) * ts/relax;
    concentration=concentration/(1+ts/relax);

    if (bool(Object()) && Object()->Alive() && nextTime<time){
        gRandomController random( randomizer_ );

        REAL nextthought=Think();
        //    if (nextthought>.9) nextthought=REAL(.9);

        if (nextthought<REAL(.6-concentration)) nextthought=REAL(.6-concentration);

        nextTime=nextTime+nextthought;

        //con << concentration << "\t" << nextthought << '\t' << ts << '\n';

        if(.1+4*nextthought<1)
            concentration*=REAL(.1+4*nextthought);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void gAIPlayer::NewObject

(

)

[virtual]

Reimplemented from ePlayerNetID.

Definition at line 2649 of file gAIBase.cpp.

References AI_STARTSTATE, AI_STARTSTRAIGHT, AI_STATECHANGE, AI_TRACE, character, ePath::Clear(), ClearTarget(), lastChangeAttempt, lastPath, lastTime, lazySideChange, log, nextStateChange, nextTime, NULL, path, gAICharacter::properties, gArena::SizeMultiplier(), gCycleMovement::SpeedMultiplier(), and state.

Referenced by gAIPlayer().

{
    lastTime = 0;
    lastPath = 0;
    lastChangeAttempt = 0;
    lazySideChange = 0;
    path.Clear();

    if (character)
    {
        nextTime        = character->properties[AI_STARTSTRAIGHT] * gArena::SizeMultiplier()/gCycleMovement::SpeedMultiplier();
        nextStateChange = character->properties[AI_STATECHANGE];
        state           = (gAI_STATE)character->properties[AI_STARTSTATE];
    }
    else
    {
        nextTime        = 10;
        nextStateChange = 30;
        state           = AI_TRACE;
    }

    if (log)
        delete log;
    log = NULL;

    ClearTarget();
}

Here is the call graph for this function:

Here is the caller graph for this function:

void gAIPlayer::RightBeforeDeath

(

int

triesLeft

)

[virtual]

Reimplemented from ePlayerNetID.

Definition at line 2562 of file gAIBase.cpp.

References ActOnData(), AI_CLOSECOMBAT, AI_EMERGENCY, AI_PATH, AI_SURVIVE, AI_TRACE, Alive(), character, Delay(), gCycle::Direction(), eCoord, emergency, EmergencyCloseCombat(), EmergencyPath(), EmergencySurvive(), EmergencyTrace(), lastTime, log, nCLIENT, nextStateChange, nextTime, NULL, Object(), gAILog::Print(), gAICharacter::properties, Random(), randomizer_, REAL, se_GameTime(), simpleAI_, sn_GetNetState(), gCycleMovement::Speed(), st_Breakpoint(), state, SwitchToState(), target, and gCycleMovement::Turn().

{
    if ( nCLIENT == sn_GetNetState() )
        return;

    if ( simpleAI_ )
        return;

    if (!character)
    {
        st_Breakpoint();
        return;
    }

    gRandomController random( randomizer_ );

    // think again immediately after this
    nextTime = lastTime;

#ifdef DEBUG_X
    if (log && !Object()->Alive())
    {
        log->Print();
        //      st_Breakpoint();
        delete log;
        log = NULL;
    }
#endif

    if (!Object()->Alive() || ( character && Random() * 10 > character->properties[AI_EMERGENCY] ) )
        return;


    // get the delay between two turns
    REAL delay = Delay();

    this->triesLeft = triesLeft;
    this->emergency = (triesLeft < 2);

    REAL speed=Object()->Speed();
    REAL range=speed;
    eCoord dir=Object()->Direction();
    REAL  side = speed*delay;

    gAISensor front(Object(),Object()->Position(),dir, side, range, range*.3, 0);
    gAISensor left(Object(),Object()->Position(),dir.Turn(eCoord(0,1)), side, range, range*.3, -1);
    gAISensor right(Object(),Object()->Position(),dir.Turn(eCoord(0,-1)), side, range, range*.3, 1);




#ifdef TESTSTATE  
    state = TESTSTATE;
    nextStateChange = se_GameTime() + 100;
#else
    // switch to survival state if our victim died:
    if ((!target || !target->Alive()) && state != AI_TRACE)
        SwitchToState(AI_SURVIVE, 1);
#endif

    ThinkData data( front, left, right);
    switch (state)
    {
    case AI_SURVIVE:
        EmergencySurvive(data);
        break;
    case AI_PATH:
        EmergencyPath(data);
        break;
    case AI_TRACE:
        EmergencyTrace(data);
        break;
    case AI_CLOSECOMBAT:
        EmergencyCloseCombat(data);
        break;
    }
    ActOnData( data );

#ifdef DEBUG_X
    {
        gAISensor front(Object(),Object()->Position(),dir, side, range, range*.3, 0);
        gAISensor left(Object(),Object()->Position(),dir.Turn(eCoord(0,1)), side, range, range*.3, -1);
        gAISensor right(Object(),Object()->Position(),dir.Turn(eCoord(0,-1)), side, range, range*.3, 1);
    }
#endif
}

Here is the call graph for this function:

void gAIPlayer::Color	(	REAL &	r,
		REAL &	g,
		REAL &	b
	)			const [virtual]

Reimplemented from ePlayerNetID.

Definition at line 2980 of file gAIBase.cpp.

References ePlayerNetID::Color().

{
    ePlayerNetID::Color( a_r, a_g, a_b );
}

Here is the call graph for this function:

nDescriptor & gAIPlayer::CreatorDescriptor

(

void

)

const [virtual]

Reimplemented from ePlayerNetID.

Definition at line 1081 of file gAIBase.cpp.

References gAIPlayer_init.

                                               {
    return gAIPlayer_init;
}

---

Friends And Related Function Documentation

friend class gAITeam [friend]

Definition at line 91 of file gAIBase.h.

---

Member Data Documentation

tReproducibleRandomizer gAIPlayer::randomizer_ [private]

Definition at line 93 of file gAIBase.h.

Referenced by RightBeforeDeath(), and Timestep().

gSimpleAI* gAIPlayer::simpleAI_ [protected]

Definition at line 95 of file gAIBase.h.

Referenced by ClearObject(), ControlObject(), RightBeforeDeath(), and Think().

gAICharacter* gAIPlayer::character [protected]

Definition at line 96 of file gAIBase.h.

Referenced by gAITeam::BalanceWithAIs(), Character(), EmergencySurvive(), gAIPlayer(), NewObject(), RightBeforeDeath(), SetNumberOfAIs(), SwitchToState(), ThinkSurvive(), and Timestep().

nObserverPtr< gCycle > gAIPlayer::target [protected]

Definition at line 99 of file gAIBase.h.

Referenced by ClearTarget(), CycleBlocksWay(), EmergencySurvive(), RightBeforeDeath(), Think(), ThinkCloseCombat(), ThinkPath(), ThinkSurvive(), ThinkTrace(), and ~gAIPlayer().

ePath gAIPlayer::path [protected]

Definition at line 102 of file gAIBase.h.

Referenced by NewObject(), and ThinkPath().

REAL gAIPlayer::lastPath [protected]

Definition at line 103 of file gAIBase.h.

Referenced by NewObject(), and ThinkPath().

int gAIPlayer::traceSide [protected]

Definition at line 106 of file gAIBase.h.

Referenced by EmergencyTrace(), gAIPlayer(), SetTraceSide(), and ThinkTrace().

REAL gAIPlayer::lastChangeAttempt [protected]

Definition at line 107 of file gAIBase.h.

Referenced by CycleBlocksWay(), NewObject(), and SetTraceSide().

REAL gAIPlayer::lazySideChange [protected]

Definition at line 108 of file gAIBase.h.

Referenced by NewObject(), and SetTraceSide().

gAI_STATE gAIPlayer::state [protected]

Definition at line 111 of file gAIBase.h.

Referenced by NewObject(), RightBeforeDeath(), SwitchToState(), and Think().

REAL gAIPlayer::nextStateChange [protected]

Definition at line 112 of file gAIBase.h.

Referenced by CycleBlocksWay(), NewObject(), RightBeforeDeath(), SwitchToState(), Think(), ThinkCloseCombat(), ThinkPath(), ThinkSurvive(), and ThinkTrace().

bool gAIPlayer::emergency [protected]

Definition at line 114 of file gAIBase.h.

Referenced by EmergencySurvive(), RightBeforeDeath(), and Think().

int gAIPlayer::triesLeft [protected]

Definition at line 115 of file gAIBase.h.

Referenced by EmergencySurvive(), and Think().

REAL gAIPlayer::freeSide [protected]

Definition at line 117 of file gAIBase.h.

Referenced by EmergencySurvive(), and gAIPlayer().

REAL gAIPlayer::lastTime [protected]

Definition at line 120 of file gAIBase.h.

Referenced by NewObject(), RightBeforeDeath(), and Timestep().

REAL gAIPlayer::nextTime [protected]

Definition at line 121 of file gAIBase.h.

Referenced by NewObject(), RightBeforeDeath(), and Timestep().

REAL gAIPlayer::concentration [protected]

Definition at line 123 of file gAIBase.h.

Referenced by Timestep().

gAILog* gAIPlayer::log [protected]

Definition at line 126 of file gAIBase.h.

Referenced by EmergencySurvive(), gAIPlayer(), NewObject(), RightBeforeDeath(), Think(), and ~gAIPlayer().

---

The documentation for this class was generated from the following files:

• src/tron/gAIBase.h
• src/tron/gAIBase.cpp

---