gCycle Class Reference

#include <gCycle.h>

Inheritance diagram for gCycle:

[legend]

Collaboration diagram for gCycle:

[legend]

List of all members.

Public Member Functions
virtual void	Die (REAL time)
	dies at the specified time
void	KillAt (const eCoord &pos)
	kill this cycle at the given position and take care of scoring
int	WindingNumber () const
	returns the current winding number
virtual bool	Vulnerable () const
	returns whether the cycle can be killed
virtual void	InitAfterCreation ()
	shared initialization routine
	gCycle (eGrid *grid, const eCoord &pos, const eCoord &dir, ePlayerNetID *p=NULL)
REAL	MaxWallsLength () const
	the maximum total length of the walls (including max effect of rubber growth)
REAL	ThisWallsLength () const
	the maximum total length of this cycle's wall (including rubber shrink)
REAL	WallEndSpeed () const
	the speed the end of the trail is receeding with right now
bool	IsMe (eGameObject const *other) const
	checks whether the passed pointer is logically identical with this cycle
	gCycle (nMessage &m)
virtual void	WriteCreate (nMessage &m)
virtual void	WriteSync (nMessage &m)
virtual void	ReadSync (nMessage &m)
virtual void	RequestSyncOwner ()
	requests special syncs to the owner on important points (just passed an enemy trail end safely...)
virtual void	RequestSyncAll ()
	requests special syncs to everyone on important points (just passed an enemy trail end safely...)
virtual void	SyncEnemy (const eCoord &begWall)
	handle sync message for enemy cycles
virtual void	ReceiveControl (REAL time, uActionPlayer *Act, REAL x)
virtual void	PrintName (tString &s) const
virtual bool	ActionOnQuit ()
virtual nDescriptor &	CreatorDescriptor () const
virtual bool	SyncIsNew (nMessage &m)
virtual bool	Timestep (REAL currentTime)
	advance to the given time
virtual bool	TimestepCore (REAL currentTime, bool calculateAcceleration=true)
	core physics simulation routine
virtual void	InteractWith (eGameObject *target, REAL time, int recursion=1)
virtual bool	EdgeIsDangerous (const eWall *w, REAL time, REAL a) const
	returns whether a given wall is dangerous to this cycle
virtual void	PassEdge (const eWall *w, REAL time, REAL a, int recursion=1)
virtual REAL	PathfindingModifier (const eWall *w) const
virtual bool	Act (uActionPlayer *Act, REAL x)
virtual bool	DoTurn (int dir)
	turns the cycle in the given direction
void	DropWall (bool buildNew=true)
	Drops the current wall and builds a new one.
virtual void	Kill ()
	destroys the gameobject (in the game)
const eTempEdge *	Edge ()
const gPlayerWall *	CurrentWall ()
virtual void	Render (const eCamera *cam)
	draws object to the screen using OpenGL
virtual void	Render2D (tCoord scale) const
virtual void	RenderName (const eCamera *cam)
virtual bool	RenderCockpitFixedBefore (bool primary=true)
virtual eCoord	CamPos () const
virtual eCoord	PredictPosition () const
virtual eCoord	CamTop () const
virtual eCoord	CamDir () const
virtual eCoord	Direction () const
	returns the current driving direction
virtual void	RightBeforeDeath (int numTries)
	called when the cycle is very close to a wall and about to crash
Static Public Member Functions
static void	SetWallsStayUpDelay (REAL delay)
	the time the cycle walls stay up ( negative values: they stay up forever )
static void	SetWallsLength (REAL length)
	the maximum total length of the walls
static void	SetExplosionRadius (REAL radius)
	the radius of the holes blewn in by an explosion
static REAL	WallsStayUpDelay ()
	the time the cycle walls stay up ( negative values: they stay up forever )
static REAL	WallsLength ()
	the default total length of the walls
static REAL	ExplosionRadius ()
	the radius of the holes blewn in by an explosion
static void	PrivateSettings ()
Public Attributes
eCoord	lastGoodPosition_
REAL	skew
REAL	skewDot
bool	mp
rModel *	body
rModel *	front
rModel *	rear
rModel *	customModel
gTextureCycle *	wheelTex
gTextureCycle *	bodyTex
gTextureCycle *	customTexture
eCoord	rotationFrontWheel
eCoord	rotationRearWheel
REAL	heightFrontWheel
REAL	heightRearWheel
gCycleMemory	memory
gRealColor	color_
gRealColor	trailColor_
eCoord	correctPosSmooth
eCoord	predictPosition_
	the best guess of where the cycle is at at display time
REAL	correctDistanceSmooth
Static Public Attributes
static uActionPlayer	s_brake
Protected Member Functions
virtual	~gCycle ()
virtual void	OnRemoveFromGame ()
	called on RemoveFromGame(). Call base class implementation, too, in your implementation. Must keep the object alive.
virtual void	OnRoundEnd ()
	called when the round ends
virtual bool	DoIsDestinationUsed (const gDestination *dest) const
	returns whether the given destination is in active use
Private Member Functions
void	TransferPositionCorrectionToDistanceCorrection ()
	tCHECKED_PTR (gNetPlayerWall) currentWall
	the wall that currenly is attached to the cycle
	tCHECKED_PTR (gNetPlayerWall) lastWall
	the last wall that was attached to this cycle
	tCHECKED_PTR (gNetPlayerWall) lastNetWall
	the last wall received over the network
void	ResetExtrapolator ()
bool	Extrapolate (REAL dt)
void	SyncFromExtrapolator ()
virtual void	OnNotifyNewDestination (gDestination *dest)
	called when a destination is successfully inserted into the destination list
virtual void	OnDropTempWall (gPlayerWall *wall, eCoord const &position, eCoord const &direction)
	called when another cycle grinds a wall; this cycle should then drop its current wall if the grinding is too close.
void	MyInitAfterCreation ()
	private shared initialization code
void	SetCurrentWall (gNetPlayerWall *w)
void	PreparePredictPosition (gPredictPositionData &data)
	prepares CalculatePredictPosition() call, requesting a raycast to the front
REAL	CalculatePredictPosition (gPredictPositionData &data)
	Calculates predictPosition_.
Private Attributes
REAL	spawnTime_
	time the cycle spawned at
REAL	lastTimeAnim
	last time animation was simulated at
REAL	timeCameIntoView
std::auto_ptr< gCycleChatBot >	chatBot_
bool	dropWallRequested_
	flag indicating that someone requested a wall drop
gCycleWallsDisplayListManager	displayList_
	display list manager
SyncData	lastSyncMessage_
tJUST_CONTROLLED_PTR < gCycleExtrapolator >	extrapolator_
bool	resimulate_
nTimeRolling	nextSync
nTimeRolling	nextSyncOwner
gJoystick *	joystick_
	joystick control
Static Private Attributes
static REAL	wallsStayUpDelay = 8.0f
	the time the cycle walls stay up ( negative values: they stay up forever )
static REAL	wallsLength = -1.0f
	the maximum total length of the walls
static REAL	explosionRadius = 4.0f
	the radius of the holes blewn in by an explosion
Friends
class	gPlayerWall
class	gNetPlayerWall
class	gDestination
class	gCycleWallRenderer
class	gCycleChatBot

---

Detailed Description

Definition at line 149 of file gCycle.h.

---

Constructor & Destructor Documentation

gCycle::~gCycle

(

)

[protected, virtual]

Definition at line 2331 of file gCycle.cpp.

References body, bodyTex, customModel, customTexture, CYCLE_MOTOR, front, eSoundMixer::GetMixer(), mp, rear, eSoundMixer::RemoveContinuous(), eGameObject::RemoveFromGame(), and wheelTex.

               {
#ifdef DEBUG
    //  con << "deleting cylce...\n";
#endif
    // clear the destination list

    eSoundMixer* mixer = eSoundMixer::GetMixer();
    mixer->RemoveContinuous(CYCLE_MOTOR, this);

    this->RemoveFromGame();

    if (mp){
        delete customModel;
        delete customTexture;
    }
    else{
        delete body;
        delete front;
        delete rear;
        delete wheelTex;
        delete bodyTex;
    }
#ifdef DEBUG
    //con << "Deleted cycle.\n";
#endif
    /*
      delete currentPos;
      delete last_turn;
    */

Here is the call graph for this function:

gCycle::gCycle	(	eGrid *	grid,
		const eCoord &	pos,
		const eCoord &	dir,
		ePlayerNetID *	p = NULL
	)

Definition at line 2308 of file gCycle.cpp.

References eGameObject::deathTime, eGameObject::dir, gCycleMovement::dirDrive, eGrid::DirectionWinding(), eGrid::GetDirection(), eGameObject::Grid(), MyInitAfterCreation(), NULL, sg_ArchiveCoord(), sg_ArchiveReal(), gCycleMovement::windingNumber_, and gCycleMovement::windingNumberWrapped_.

        :gCycleMovement(grid, pos,d,p,false),
        skew(0),skewDot(0),
        rotationFrontWheel(1,0),rotationRearWheel(1,0),heightFrontWheel(0),heightRearWheel(0),
        currentWall(NULL),
        lastWall(NULL)
{
    windingNumberWrapped_ = windingNumber_ = Grid()->DirectionWinding(dirDrive);
    dirDrive = Grid()->GetDirection(windingNumberWrapped_);
    dir = dirDrive;

    deathTime=0;

    lastNetWall=lastWall=currentWall=NULL;

    MyInitAfterCreation();

    sg_ArchiveCoord( this->dirDrive, 1 );
    sg_ArchiveCoord( this->dir, 1 );
    sg_ArchiveCoord( this->pos, 1 );
    sg_ArchiveReal( this->verletSpeed_, 1 );

Here is the call graph for this function:

gCycle::gCycle

(

nMessage &

m

)

Definition at line 4878 of file gCycle.cpp.

References gRealColor::b, color_, correctDistanceSmooth, eGameObject::deathTime, eGameObject::dir, gCycleMovement::dirDrive, eGrid::DirectionWinding(), gCycleMovement::dirSpawn, EPS, gRealColor::g, eGrid::GetDirection(), eGameObject::Grid(), eGameObject::lastTime, lastTimeAnim, nextSync, nextSyncOwner, NULL, gRealColor::r, gCycleMovement::rubber, se_GameTime(), se_MakeColorValid(), spawnTime_, trailColor_, gCycleMovement::windingNumber_, and gCycleMovement::windingNumberWrapped_.

04878                          :
04879 gCycle::gCycle(nMessage &m)
04880         :gCycleMovement(m),
04881         skew(0),skewDot(0),
04882         rotationFrontWheel(1,0),rotationRearWheel(1,0),heightFrontWheel(0),heightRearWheel(0),
04883         currentWall(NULL),
04884         lastWall(NULL)
04885 {
04886     deathTime=0;
04887     lastNetWall=lastWall=currentWall=NULL;
04888     windingNumberWrapped_ = windingNumber_ = Grid()->DirectionWinding(dirDrive);
04889     dirDrive = Grid()->GetDirection(windingNumberWrapped_);
04890     dir = dirDrive;
04891 
04892     rubber=0;
04893     //correctTimeSmooth =0;
04894     correctDistanceSmooth =0;
04895     //correctSpeedSmooth =0;
04896 
04897     deathTime = 0;
04898     spawnTime_ = se_GameTime() + 100;
04899     dirSpawn = dirDrive;
04900 
04901 
04902     m >> color_.r;
04903     m >> color_.g;
04904     m >> color_.b;
04905 
04906     trailColor_ = color_;
04907 
04908     se_MakeColorValid( color_.r, color_.g, color_.b, 1.0f );
04909     se_MakeColorValid( trailColor_.r, trailColor_.g, trailColor_.b, .5f );
04910 
04911     // set last time so that the first read_sync will not think this is old
04912     lastTimeAnim = lastTime = -EPS;
04913 
04914     nextSync = nextSyncOwner = -1;
}

Here is the call graph for this function:

---

Member Function Documentation

void gCycle::TransferPositionCorrectionToDistanceCorrection

(

)

[private]

Definition at line 5158 of file gCycle.cpp.

References correctDistanceSmooth, correctPosSmooth, gCycleMovement::dirDrive, gCycleMovement::distance, and REAL.

Referenced by Die(), SyncFromExtrapolator(), and TimestepCore().

{
    REAL newCorrectDist = eCoord::F( correctPosSmooth, dirDrive );
    distance += newCorrectDist - correctDistanceSmooth;
    correctDistanceSmooth = newCorrectDist;

Here is the caller graph for this function:

gCycle::tCHECKED_PTR

(

gNetPlayerWall

)

[private]

the wall that currenly is attached to the cycle

gCycle::tCHECKED_PTR

(

gNetPlayerWall

)

[private]

the last wall that was attached to this cycle

gCycle::tCHECKED_PTR

(

gNetPlayerWall

)

[private]

the last wall received over the network

void gCycle::ResetExtrapolator

(

)

[private]

Definition at line 5055 of file gCycle.cpp.

References eGameObject::dir, extrapolator_, lastSyncMessage_, eGameObject::pos, resimulate_, and tNEW.

Referenced by PassEdge(), and Timestep().

{
    resimulate_ = false;
    if (!extrapolator_)
    {
        extrapolator_ = tNEW( gCycleExtrapolator )(grid, pos, dir );
    }

    extrapolator_->CopyFrom( lastSyncMessage_, *this );

    // simulate a bit, only to get current rubberSpeedFactor and acceleration
    extrapolator_->TimestepCore( extrapolator_->LastTime(), true );

Here is the caller graph for this function:

bool gCycle::Extrapolate

(

REAL

dt

)

[private]

Definition at line 5070 of file gCycle.cpp.

References eCoord, extrapolator_, eGameObject::lastTime, gDestination::list, REAL, tASSERT, and eGameObject::TimestepThis().

Referenced by PassEdge(), and Timestep().

{
    tASSERT( extrapolator_ );

    eCoord posBefore = extrapolator_->Position();

    // calculate target time
    REAL newTime = extrapolator_->LastTime() + dt;

    bool ret = false;

    // clamp: don't simulate further than our current time
    if ( newTime >= lastTime )
    {
        // simulate extrapolator until now
        eGameObject::TimestepThis( lastTime, extrapolator_ );

        // test if there are real (the check for list does that) destinations left; we cannot call it finished if there are.
        gDestination* unhandledDestination = extrapolator_->GetCurrentDestination();
        ret = !unhandledDestination || !unhandledDestination->list;

        newTime = lastTime;
    }
    else
    {
        // simulate extrapolator as requested
        eGameObject::TimestepThis( newTime, extrapolator_ );
    }

    //eCoord posAfter = extrapolator_->Position();
    //eDebugLine::SetTimeout( 1.0 );
    //eDebugLine::SetColor( 1,0,0 );
    //eDebugLine::Draw( posBefore, 8, posAfter, 4 );
    //eDebugLine::Draw( posBefore, 4, posAfter, 4 );

    return ret;

Here is the call graph for this function:

Here is the caller graph for this function:

void gCycle::SyncFromExtrapolator

(

)

[private]

Definition at line 5166 of file gCycle.cpp.

References gCycleMovement::CopyFrom(), correctDistanceSmooth, correctPosSmooth, gCycleMovement::distance, dt, eCoord, extrapolator_, eGameObject::LastTime(), gCycleMovement::lastTurnPos_, gPlayerWallCoord::Pos, eGameObject::pos, REAL, resimulate_, sg_cycleWallTime, spawnTime_, tASSERT, and TransferPositionCorrectionToDistanceCorrection().

Referenced by Timestep().

{
    // store old position
    eCoord oldPos = pos;

    // con << "Copy: " << LastTime() << ", " << extrapolator_->LastTime() << ", " << extrapolator_->Position() << ", " << pos << "\n";

    tASSERT( extrapolator_ );

    // delegate
    CopyFrom( *extrapolator_ );

    // adjust current wall (not essential, don't do it for the first wall)
    if ( currentWall && currentWall->tBeg > spawnTime_ + sg_cycleWallTime + .01f )
    {
        // update start position
        currentWall->beg = extrapolator_->GetLastTurnPos();

        // set begin distance as well
        REAL dBeg = extrapolator_->GetDistance() - eCoord::F( extrapolator_->Direction(), extrapolator_->Position() - extrapolator_->GetLastTurnPos() );

        currentWall->dbegin = dBeg;
        currentWall->coords_[0].Pos = dBeg;

        // and care for consistency
        int i;
        for ( i = currentWall->coords_.Len() -1 ; i>=0; --i )
        {
            gPlayerWallCoord & coord = currentWall->coords_( i );
            if ( coord.Pos <= dBeg )
                coord.Pos = dBeg;
        }
    }

    // transfer last turn position
    lastTurnPos_ = extrapolator_->GetLastTurnPos();

    // smooth position correction
    correctPosSmooth = correctPosSmooth + oldPos - pos;

#ifdef DEBUG
    if ( correctPosSmooth.NormSquared() > .1f )
    {
        std::cout << "Lag slide! " << correctPosSmooth << "\n";
        resimulate_ = true;
    }
#endif

    // calculate time difference between this cycle and extrapolator
    REAL dt = this->LastTime() - extrapolator_->LastTime();

    // extrapolate true distance ( the best estimate we have for the distance on the server )
    REAL trueDistance = extrapolator_->trueDistance_ + extrapolator_->Speed() * dt;

    // update distance correction
    // con <<   correctDistanceSmooth << "," << trueDistance << "," << distance << "\n";
    // correctDistanceSmooth = trueDistance - distance;
    distance = trueDistance;
    correctDistanceSmooth=0;

    // split away part in driving direction
    TransferPositionCorrectionToDistanceCorrection();

    // make sure correction does not bring us to the wrong side of a wall
    // se_SanifyDisplacement( this, correctPosSmooth );

    //eDebugLine::SetTimeout( 1.0 );
    //eDebugLine::SetColor( 0,1,0 );
    //eDebugLine::Draw( pos, 4, pos + dirDrive * 10, 14 );

    // delete extrapolator
    extrapolator_ = 0;

Here is the call graph for this function:

Here is the caller graph for this function:

void gCycle::OnNotifyNewDestination

(

gDestination *

dest

)

[private, virtual]

called when a destination is successfully inserted into the destination list

Reimplemented from gCycleMovement.

Definition at line 1428 of file gCycle.cpp.

References gCycleMovement::acceleration, BroadCastNewDestination(), gCycleMovement::dirDrive, gDestination::distance, gCycleMovement::distance, EPS, extrapolator_, gDestination::gameTime, eNetGameObject::Lag(), eGameObject::lastTime, nCLIENT, nSERVER, gCycleMovement::OnNotifyNewDestination(), nNetObject::Owner(), eNetGameObject::Player(), eGameObject::pos, gDestination::position, REAL, eLag::Report(), gCycleMovement::rubber, gCycleMovement::rubberSpeedFactor, se_GameTime(), sg_gnuplotDebug, sg_RubberValues(), sn_GetNetState(), sn_myNetID, st_Breakpoint(), eLag::TakeCredit(), TimestepCore(), tSysTimeFloat(), and gCycleMovement::verletSpeed_.

{
#ifdef DELAYEDTURN_DEBUG
    sg_turnReceivedTime = tSysTimeFloat();
#endif

#ifdef GNUPLOT_DEBUG
    if ( sg_gnuplotDebug && Player() )
    {
        std::ofstream f( Player()->GetUserName() + "_sync", std::ios::app );
        f << dest->position.x << " " << dest->position.y << "\n";
    }
#endif

    gCycleMovement::OnNotifyNewDestination( dest );

    //  if (sn_GetNetState()==nSERVER || ::sn_myNetID == owner)
    if (sn_GetNetState()==nCLIENT && ::sn_myNetID == Owner())
        BroadCastNewDestination(this,dest);

    if ( extrapolator_ )
    {
        // add destination and try to squeeze it into the schedule.
        extrapolator_->NotifyNewDestination( dest );
    }

    // start a new simulation in any case. The server may simulate the movement a bit differently at the turn.
    // resimulate_ = ( sn_GetNetState() == nCLIENT );

    // detect lag slides
    if( sn_GetNetState() == nSERVER )
    {
        // see how far we should be simulated in an ideal world
        REAL simTime=se_GameTime() - Lag();

        REAL lag = simTime - dest->gameTime;  // the real lag
        REAL lagOffset = simTime - lastTime;  // difference between real lag and practical lag (what we need to compensate)
        if ( lag > 0 && sn_GetNetState() == nSERVER )
        {
            eLag::Report( Owner(), lag );
            if ( currentWall && currentWall->Wall() && rubberSpeedFactor >= 1-EPS )
            {
                lag -= lagOffset; // switch to practical lag

                // no compensation? Just quit.
                if ( lag < 0 )
                    return;

                // see how much we can go back
                REAL minDist   = currentWall->Wall()->Pos(0);
                REAL maxGoBack = ( distance - minDist ) * .8;

                // see how much we should go back
                REAL stepBack = distance - dest->distance;

                if ( rubberSpeedFactor < 1-EPS )
                {
                    // make the correction distance based so we don't loosen a grind
                    maxGoBack = stepBack;
                }

                // clamp so we don't go back too far
                if ( stepBack > maxGoBack )
                {
                    stepBack = maxGoBack;
                    lag = rubberSpeedFactor*stepBack/verletSpeed_;
                }

                // ask lag compensation how much we are allowed to go back; switch to real lag
                // for the credit
                lag = eLag::TakeCredit( Owner(), lag + lagOffset ) - lagOffset;

                // no compensation? Just quit.
                if ( lag < 0 )
                    return;

                // go back in time
                if ( rubberSpeedFactor >= 1-EPS )
                {
                    // rubber is inactive, basic timestep is enough
                    TimestepCore( lastTime - lag );
                }
                else if ( 0 )
                {
                    // rubber is active. Take care!

                    // just extrapolate the movement backwards
                    REAL step = lag * verletSpeed_;
                    lastTime -= lag;

                    // rubber is a bit tricker, we need the effectiveness
                    REAL rubberGranted, rubberEffectiveness;
                    sg_RubberValues( player, verletSpeed_, rubberGranted, rubberEffectiveness );
                    if ( rubberEffectiveness > 0 )
                        rubber -= step/rubberEffectiveness;

                    if ( rubber < 0 )
                        rubber = 0;

                    // position and distance are easy
                    step *= rubberSpeedFactor;
                    distance -= step;
                    pos = pos - dirDrive * step;

                    // undo acceleration
                    verletSpeed_ -= acceleration * lag;
                }

                // see if we went back too far (should almost never happen)
                if ( distance < minDist )
                {
                    st_Breakpoint();
                    TimestepCore( lastTime + ( minDist - distance )/verletSpeed_ );
                }
            }
        }
    }
}

Here is the call graph for this function:

void gCycle::OnDropTempWall	(	gPlayerWall *	wall,
		eCoord const &	position,
		eCoord const &	dir
	)			[private, virtual]

called when another cycle grinds a wall; this cycle should then drop its current wall if the grinding is too close.

Parameters:

	wall	the wall the other cycle is grinding
	pos	the position of the grind
	dir	the direction the raycast triggering the gridding comes from

Reimplemented from gCycleMovement.

Definition at line 1560 of file gCycle.cpp.

References tRecorderSync< DATA >::Archive(), dropWallRequested_, nNetObject::ID(), gCycleMovement::lastDirDrive, gPlayerWall::NetWall(), REAL, sg_minDropInterval, tASSERT, and gCycleMovement::verletSpeed_.

{
    tASSERT( wall );

    unsigned short idrec = ID();
    tRecorderSync< unsigned short >::Archive( "_ON_DROP_WALL", 8, idrec );

    // determine if the grinded wall is current enough
    bool wallRight = ( currentWall && ( wall->NetWall() == currentWall || wall->NetWall() == currentWall ) );

    // don't drop if we already dropped a short time ago
    if ( wallRight && currentWall->Edge()->Vec().NormSquared() < verletSpeed_ * verletSpeed_ * sg_minDropInterval * sg_minDropInterval )
        wallRight = false;

    tRecorderSync< bool >::Archive( "_ON_DROP_WALL_RIGHT", 8, wallRight );

    // drop the current wall if eiter this or the last wall is grinded
    // gNetPlayerWall * nw = wall->NetWall();
    if ( wallRight )
    {
        // calculate relative position of grinding in wall; if alpha is positive, it's already too late
        REAL alpha = currentWall->Edge()->Edge(0)->Ratio( position );
        tRecorderSync< REAL >::Archive( "_ON_DROP_WALL_ALPHA", 8, alpha );
        if ( alpha > -.5 )
        {
            unsigned short idrec = ID();
            tRecorderSync< unsigned short >::Archive( "_ON_DROP_WALL_DROP", 8, idrec );

            // just request the drop, Timestep() will execute it later
            dropWallRequested_ = true;

            // bend last driving direction to -dir. That way, should the grinder overtake this cycle,
            // it will end up on the right side of his wall.
            lastDirDrive = -dir;
        }
    }
}

Here is the call graph for this function:

void gCycle::MyInitAfterCreation

(

void

)

[private]

private shared initialization code

Reimplemented from gCycleMovement.

Definition at line 2114 of file gCycle.cpp.

References eGameObject::AddToList(), gRealColor::b, body, gCycleVisuals::bodyModel, bodyTex, gCycleVisuals::bodyTexture, color_, con, correctDistanceSmooth, correctPosSmooth, gCycleVisuals::customModel, customModel, gCycleVisuals::customTexture, customTexture, CYCLE_MOTOR, eGameObject::dir, gCycleMovement::dirDrive, gCycleMovement::dirSpawn, dropWallRequested_, eCoord, front, gCycleVisuals::frontModel, gRealColor::g, gCycleWallRenderer, eSoundMixer::GetMixer(), joystick_, lastGoodPosition_, eGameObject::lastTime, lastTimeAnim, gCycleVisuals::LoadModel(), mp, gCycleVisuals::mpType, nCLIENT, nextSync, nextSyncOwner, NULL, eSoundMixer::PlayContinuous(), eNetGameObject::Player(), eGameObject::pos, predictPosition_, gRealColor::r, REAL, rear, gCycleVisuals::rearModel, gCycleMovement::RequestSync(), resimulate_, rotationFrontWheel, rotationRearWheel, se_MakeColorValid(), sg_cycleFirstSpawnProtection, sg_gnuplotDebug, sg_MoviePack(), skew, skewDot, sn_GetNetState(), spawnTime_, sqrt(), tASSERT, tERR_ERROR, timeCameIntoView, tNEW, trailColor_, tSysTimeFloat(), wheelTex, and gCycleVisuals::wheelTexture.

Referenced by gCycle(), and InitAfterCreation().

                                {
#ifndef DEDICATED
    joystick_ = tNEW( gJoystick( this ) );
#else
    joystick_ = NULL;
#endif

// create wall renderer
#ifndef DEDICATED
    new gCycleWallRenderer( this );
#endif

    dropWallRequested_ = false;
    lastGoodPosition_ = pos;

#ifdef DEBUG
    // con << "creating cycle.\n";
#endif
    eSoundMixer* mixer = eSoundMixer::GetMixer();
    mixer->PlayContinuous(CYCLE_MOTOR, this);

    //correctDistSmooth=correctTimeSmooth=correctSpeedSmooth=0;
    correctDistanceSmooth = 0;

    resimulate_ = false;

    mp=sg_MoviePack();

    lastTimeAnim = 0;
    timeCameIntoView = 0;

    customModel = NULL;
    body = NULL;
    front = NULL;
    rear = NULL;
    wheelTex = NULL;
    bodyTex = NULL;
    customTexture = NULL;

    correctPosSmooth=eCoord(0,0);

    rotationFrontWheel=rotationRearWheel=eCoord(1,0);

    skew=skewDot=0;

    {
        dir=dirDrive;
        REAL dirLen=dir.NormSquared();
        if ( dirLen > 0 )
        {
            dir = dir * (1/sqrt( dirLen ));
        }
    }

    if (sn_GetNetState()!=nCLIENT){
        if(!player)
        { // distribute AI colors
            // con << current_ai << ':' << take_ai << ':' << maxmindist <<  "\n\n\n";
            color_.r=1;
            color_.g=1;
            color_.b=1;

            trailColor_.r=1;
            trailColor_.g=1;
            trailColor_.b=1;
        }
        else
        {
            player->Color(color_.r,color_.g,color_.b);
            player->TrailColor(trailColor_.r,trailColor_.g,trailColor_.b);
        }

        se_MakeColorValid( color_.r, color_.g, color_.b, 1.0f );
        se_MakeColorValid( trailColor_.r, trailColor_.g, trailColor_.b, .5f );
    }

    // load model and texture
#ifndef DEDICATED
    gCycleVisuals visuals( color_ );
    if ( !visuals.LoadModel( mp ) )
    {
        tERR_ERROR( "Neither classic style nor moviepack style model and textures found. "
                    "The folders \"textures\" and \"moviepack\" need to contain either "
                    "cycle.ase and bike.png or body.mod, front.mod, rear.mod, cycle_body.png and cycle_wheel.png." );
    }

    mp = visuals.mpType;

    // transfer models and textures
    if ( mp )
    {
        // use moviepack style body and texture
        customModel = visuals.customModel;
        visuals.customModel = 0;
        customTexture = visuals.customTexture;
        visuals.customTexture = 0;
    }
    else
    {
        // use classic style body and texture
        body = visuals.bodyModel;
        visuals.bodyModel = 0;
        front = visuals.frontModel;
        visuals.frontModel = 0;
        rear = visuals.rearModel;
        visuals.rearModel = 0;
        bodyTex = visuals.bodyTexture;
        visuals.bodyTexture = 0;
        wheelTex = visuals.wheelTexture;
        visuals.wheelTexture = 0;

        tASSERT ( body && front && rear && bodyTex && wheelTex );

        mp = false;
    }
#endif // DEDICATED

    /*
      the old, less flexible, loading code

    if (mp)
    {
        customModel=new rModel("moviepack/cycle.ASE","moviepack/cycle.ase");
    }
    else{
        body=new rModel("models/cycle_body.mod");
        front=new rModel("models/cycle_front.mod");
        rear=new rModel("models/cycle_rear.mod");
    }

    if (mp)
    {
        // static rSurface bike(lala_bikeTexture);
        static rSurface bike("moviepack/bike.png");
        customTexture=new gTextureCycle(bike,color_,0,0);
    }
    else{
        static rSurface body("textures/cycle_body.png");
        static rSurface wheel("textures/cycle_wheel.png");
        //static rSurface body((const char*) lala_bodyTexture);
        //static rSurface wheel((const char*) lala_wheelTexture);
        wheelTex=new gTextureCycle(wheel,color_,0,0,true);
        bodyTex=new gTextureCycle(body,color_,0,0);
    }
    */

#ifdef DEBUG
    con << "Created cycle.\n";
#endif
    nextSyncOwner=nextSync=tSysTimeFloat()-1;

    if (sn_GetNetState()!=nCLIENT)
        RequestSync();

    grid->AddGameObjectInteresting(this);

    spawnTime_=lastTimeAnim=lastTime;
    // set spawn time to infinite past if this is the first spawn
    if ( !sg_cycleFirstSpawnProtection && spawnTime_ <= 1.0 )
    {
        spawnTime_ = -1E+20;
    }
    dirSpawn = dirDrive;

    // add to game grid
    this->AddToList();

    predictPosition_ = pos;

#ifdef GNUPLOT_DEBUG
    if ( sg_gnuplotDebug && Player() )
    {
        std::ofstream f( Player()->GetUserName() + "_step" );
        f << pos.x << " " << pos.y << "\n";
        std::ofstream g( Player()->GetUserName() + "_sync" );
        g << pos.x << " " << pos.y << "\n";
        std::ofstream h( Player()->GetUserName() + "_turn" );
        h << pos.x << " " << pos.y << "\n";
    }
#endif

Here is the call graph for this function:

Here is the caller graph for this function:

void gCycle::SetCurrentWall

(

gNetPlayerWall *

w

)

[private]

void gCycle::PreparePredictPosition

(

gPredictPositionData &

data

)

[private]

prepares CalculatePredictPosition() call, requesting a raycast to the front

Parameters:

data

data to be passed to CalculatePredictPosition() later

Definition at line 2442 of file gCycle.cpp.

References eGameObject::GetMaxLazyLag(), eGameObject::lastTime, eGameObject::MaxSimulateAhead(), gCycleMovement::maxSpaceMaxCast_, gPredictPositionData::maxSpaceReport, REAL, gCycleMovement::RubberSpeed(), gCycleMovement::rubberSpeedFactor, se_PredictTime(), sg_predictWalls, and gCycleMovement::verletSpeed_.

Referenced by Timestep().

{
    // don't cast a ray by default
    data.maxSpaceReport = 0;
#ifdef DEDICATED
    if ( sg_predictWalls )
    {
        // predict to the maximum time anyone else may be simulated up to
        REAL maxTime = lastTime + MaxSimulateAhead() + GetMaxLazyLag();
        REAL predictDT = maxTime - lastTime;
        REAL lookAhead = predictDT * verletSpeed_;

        // see how far we can go before rubber kicks in
        data.rubberStart = verletSpeed_ / RubberSpeed();

        // store max lookahead plus rubber safety
        data.maxSpaceReport = lookAhead + data.rubberStart;
    }
#else
    data.maxSpaceReport = verletSpeed_ * se_PredictTime() * rubberSpeedFactor;
#endif

    // request a raycast of the right length
    maxSpaceMaxCast_ = data.maxSpaceReport;

Here is the call graph for this function:

Here is the caller graph for this function:

REAL gCycle::CalculatePredictPosition

(

gPredictPositionData &

data

)

[private]

Calculates predictPosition_.

Parameters:

data

data from PreparePredictPosition()

Returns:

the time up to which the cycle's position was predicted

Definition at line 2479 of file gCycle.cpp.

References correctPosSmooth, gCycleMovement::dirDrive, gCycleMovement::GetMaxSpaceAhead(), eGameObject::lastTime, gPredictPositionData::maxSpaceReport, eGameObject::pos, predictPosition_, REAL, se_PredictTime(), sg_predictWalls, and gCycleMovement::verletSpeed_.

Referenced by Timestep().

{
    // predict position
    REAL predictTime = lastTime;
    {
#ifdef DEDICATED
        predictPosition_ = pos;

        if ( sg_predictWalls )
        {
            REAL spaceAhead = GetMaxSpaceAhead( data.maxSpaceReport );
            spaceAhead -= data.rubberStart;

            if ( spaceAhead > 0 )
            {
                // store consistent prediction position and  time
                predictPosition_ = pos + dirDrive * spaceAhead;
                predictTime = lastTime + spaceAhead/verletSpeed_;
            }
        }
#else
        // predict half a frame time
        predictTime += se_PredictTime();
        predictPosition_ = pos+correctPosSmooth + dirDrive * GetMaxSpaceAhead( data.maxSpaceReport );
#endif
    }

    return predictTime;

Here is the call graph for this function:

Here is the caller graph for this function:

void gCycle::OnRemoveFromGame

(

)

[protected, virtual]

called on RemoveFromGame(). Call base class implementation, too, in your implementation. Must keep the object alive.

Reimplemented from gCycleMovement.

Definition at line 2362 of file gCycle.cpp.

References gCycleMovement::Alive(), Die(), joystick_, eGameObject::lastTime, nSERVER, NULL, gCycleMovement::OnRemoveFromGame(), gCycleMovement::RequestSync(), sn_GetNetState(), and gCycleMovement::Turn().

{
    // keep this cycle alive during this function
    tJUST_CONTROLLED_PTR< gCycle > keep;

    if ( this->GetRefcount() > 0 )
    {
        keep = this;

        this->Turn(0);

        if ( sn_GetNetState() == nSERVER )
            RequestSync();
    }

    // make sure we're dead, so our walls know they need to time out.
    if ( Alive() )
    {
        Die( lastTime );
    }

    if (currentWall)
        currentWall->CopyIntoGrid(0);
    currentWall=NULL;
    lastWall=NULL;

    gCycleMovement::OnRemoveFromGame();

    delete joystick_;
    joystick_ = NULL;

Here is the call graph for this function:

void gCycle::OnRoundEnd

(

)

[protected, virtual]

called when the round ends

Reimplemented from eGameObject.

Definition at line 2395 of file gCycle.cpp.

References ePlayerNetID::AddScore(), gCycleMovement::Alive(), eNetGameObject::Player(), and score_survive.

{
    // give survival bonus
    if ( Alive() && player )
    {
        Player()->AddScore( score_survive, tOutput("$player_win_survive"), tOutput() );
    }

Here is the call graph for this function:

void gCycle::Die

(

REAL

time

)

[virtual]

dies at the specified time

Parameters:

time

the time of death

Reimplemented from gCycleMovement.

Definition at line 3097 of file gCycle.cpp.

References correctPosSmooth, gNetPlayerWall::Cycle(), gCycleMovement::Die(), eCoord, nSERVER, eGameObject::pos, predictPosition_, gNetPlayerWall::Preliminary(), gNetPlayerWall::real_CopyIntoGrid(), gCycleMovement::RequestSync(), sg_netPlayerWalls, sn_GetNetState(), and TransferPositionCorrectionToDistanceCorrection().

Referenced by Kill(), OnRemoveFromGame(), ReadSync(), Timestep(), and TimestepCore().

{
    if ( sn_GetNetState() == nSERVER )
    {
        // request one last sync
        RequestSync( true );
    }

    gCycleMovement::Die( time );

    // reset smoothing
    correctPosSmooth = eCoord();
    TransferPositionCorrectionToDistanceCorrection();
    predictPosition_ = pos;

    // delete all temporary walls of this cycle
    for ( int i = sg_netPlayerWalls.Len()-1; i >= 0; --i )
    {
        gNetPlayerWall * wall = sg_netPlayerWalls(i);
        if ( wall->Cycle() == this && wall->Preliminary() )
        {
            wall->real_CopyIntoGrid(grid);
        }
    }

Here is the call graph for this function:

Here is the caller graph for this function:

void gCycle::KillAt

(

const eCoord &

pos

)

kill this cycle at the given position and take care of scoring

Definition at line 3123 of file gCycle.cpp.

References gStatList::add(), ePlayerNetID::AddScore(), gCycleMovement::Alive(), tColoredString::ColorString(), ePlayerNetID::CurrentTeam(), gStatistics::deaths, gCycleMovement::enemyInfluence, gEnemyInfluence::GetEnemy(), ePlayerNetID::GetName(), gEnemyInfluence::GetTime(), ePlayerNetID::GetUserName(), gStats, ePlayerNetID::IsHuman(), Kill(), gStatistics::kills, eGameObject::LastTime(), eGameObject::lastTime, gCycleMovement::MoveSafely(), nCLIENT, NULL, ePlayerNetID::Object(), eNetGameObject::Player(), eGameObject::pos, score_die, score_kill, score_suicide, se_SaveToLadderLog(), se_sendEventNotification(), tOutput::SetTemplateParameter(), sg_suicideTimeout, sn_ConsoleOut(), sn_GetNetState(), and Vulnerable().

Referenced by PassEdge(), sg_TopologyPoliceCheck(), Timestep(), and TimestepCore().

                                          {
    // don't kill invulnerable cycles
    if ( !Vulnerable() )
    {
        MoveSafely( deathPos, lastTime, lastTime );
        return;
    }

    // find the killer from the enemy influence storage
    ePlayerNetID const * constHunter = enemyInfluence.GetEnemy();
    ePlayerNetID * hunter = Player();

    // cast away const the safe way
    if ( constHunter && constHunter->Object() )
        hunter = constHunter->Object()->Player();

    // only take it if it is not too old
    if ( LastTime() - enemyInfluence.GetTime() > sg_suicideTimeout )
        hunter = NULL;

    // suicide?
    if ( !hunter )
        hunter = Player();


    if (!Alive() || sn_GetNetState()==nCLIENT)
        return;

#ifdef KRAWALL_SERVER_LEAGUE
    if (    hunter           && Player()          &&
            !dynamic_cast<gAIPlayer*>(hunter)     &&
            !dynamic_cast<gAIPlayer*>(Player())             &&
            hunter->IsAuth() && Player()->IsAuth())
        nKrawall::ServerFrag(hunter->GetUserName(), Player()->GetUserName());
#endif

    if (hunter==Player())
    {
        if (hunter)
        {
            tString ladderLog;
            ladderLog << "DEATH_SUICIDE " << hunter->GetUserName() << "\n";
            se_SaveToLadderLog( ladderLog );
            tString notificationMessage(hunter->GetUserName());
            notificationMessage << " commited suicide";
            se_sendEventNotification(tString("Death suicide"), notificationMessage);

            if ( score_suicide )
                hunter->AddScore(score_suicide, tOutput(), "$player_lose_suicide" );
            else
            {
                tColoredString hunterName;
                hunterName << *hunter << tColoredString::ColorString(1,1,1);
                sn_ConsoleOut( tOutput( "$player_free_suicide", hunterName ) );
            }
        }
    }
    else{
        if (hunter)
        {
            tOutput lose;
            tOutput win;
            if (Player())
            {
                tColoredString preyName;
                preyName << *Player();
                preyName << tColoredString::ColorString(1,1,1);
                if (Player()->CurrentTeam() != hunter->CurrentTeam()) {
                    tString ladderLog;
                    ladderLog << "DEATH_FRAG " << Player()->GetUserName() << " " << hunter->GetUserName()  << "\n";
                    se_SaveToLadderLog( ladderLog );
                    tString notificationMessage(hunter->GetUserName());
                    notificationMessage << " core dumped " << Player()->GetUserName();
                    se_sendEventNotification(tString("Death frag"), notificationMessage);

                    win.SetTemplateParameter(3, preyName);
                    win << "$player_win_frag";
                    if ( score_kill != 0 )
                        hunter->AddScore(score_kill, win, lose );
                    else
                    {
                        tColoredString hunterName;
                        hunterName << *hunter << tColoredString::ColorString(1,1,1);
                        sn_ConsoleOut( tOutput( "$player_free_frag", hunterName, preyName ) );
                    }
                }
                else {
                    tString ladderLog;
                    ladderLog << "DEATH_TEAMKILL " << Player()->GetUserName() << " " << hunter->GetUserName()  << "\n";
                    se_SaveToLadderLog( ladderLog );
                    tString notificationMessage(hunter->GetUserName());
                    notificationMessage << " teamkilled " << Player()->GetUserName();
                    se_sendEventNotification(tString("Death teamkill"), notificationMessage);

                    tColoredString hunterName;
                    hunterName << *hunter << tColoredString::ColorString(1,1,1);
                    sn_ConsoleOut( tOutput( "$player_teamkill", hunterName, preyName ) );
                }
            }
            else
            {
                win << "$player_win_frag_ai";
                hunter->AddScore(score_kill, win, lose);
            }
        }
        //      if (prey->player && (prey->player->CurrentTeam() != hunter->player->CurrentTeam()))
        if (Player())
            Player()->AddScore(score_die,tOutput(),"$player_lose_frag");
    }

    //collect stats! huzzah!
    if (Player() && hunter && gStats)
    {
        //always a death
        if (Player()->IsHuman())
        {
            gStats->deaths->add(Player()->GetName(), 1);
        }
        if (hunter != Player() && hunter->IsHuman()) //but a kill too?
        {
            gStats->kills->add(hunter->GetName(), 1);
        }
    }

    // set position to death position so the explosion is at the right place (I dimly remember this caused problems in an earlier attempt)
    this->pos = deathPos;

    Kill();

Here is the call graph for this function:

Here is the caller graph for this function:

int gCycle::WindingNumber

(

void

)

const [inline]

returns the current winding number

Returns:

number of right turns taken minus the number of left turns

Reimplemented from gCycleMovement.

Definition at line 243 of file gCycle.h.

References gCycleMovement::windingNumber_.

Referenced by gAIPlayer::EmergencySurvive().

{return windingNumber_;}

Here is the caller graph for this function:

bool gCycle::Vulnerable

(

)

const [virtual]

returns whether the cycle can be killed

Returns:

the distance driven since the last turn

the distance driven since the last turn

true if the cycle is vulnerable

Reimplemented from gCycleMovement.

Definition at line 6076 of file gCycle.cpp.

References gCycleMovement::Alive(), eGameObject::lastTime, sg_cycleInvulnerableTime, and spawnTime_.

Referenced by EdgeIsDangerous(), KillAt(), PassEdge(), and Render().

{
    return Alive() && lastTime > spawnTime_ + sg_cycleInvulnerableTime;

Here is the call graph for this function:

Here is the caller graph for this function:

void gCycle::InitAfterCreation

(

void

)

[virtual]

shared initialization routine

Reimplemented from gCycleMovement.

Definition at line 2295 of file gCycle.cpp.

References gCycleMovement::InitAfterCreation(), MyInitAfterCreation(), gCycleMovement::Speed(), and st_Breakpoint().

                              {
#ifdef DEBUG
    if (!finite(Speed()))
        st_Breakpoint();
#endif
    gCycleMovement::InitAfterCreation();
#ifdef DEBUG
    if (!finite(Speed()))
        st_Breakpoint();
#endif
    MyInitAfterCreation();

Here is the call graph for this function:

void gCycle::SetWallsStayUpDelay

(

REAL

delay

)

[static]

the time the cycle walls stay up ( negative values: they stay up forever )

Definition at line 1607 of file gCycle.cpp.

References nConfItem< T >::Set().

Referenced by _wrap_GCycle_set_walls_stay_up_delay(), and sg_copySettings().

{
    c_pwsud->Set( delay );
}

Here is the call graph for this function:

Here is the caller graph for this function:

void gCycle::SetWallsLength

(

REAL

length

)

[static]

the maximum total length of the walls

Definition at line 1700 of file gCycle.cpp.

References c_pwl.

Referenced by _wrap_GCycle_set_walls_length(), and sg_copySettings().

{
    c_pwl->Set( length );
}

Here is the caller graph for this function:

void gCycle::SetExplosionRadius

(

REAL

radius

)

[static]

the radius of the holes blewn in by an explosion

Definition at line 1706 of file gCycle.cpp.

References c_per.

Referenced by _wrap_GCycle_set_explosion_radius(), and sg_copySettings().

{
    c_per->Set( radius );
}

Here is the caller graph for this function:

static REAL gCycle::WallsStayUpDelay

(

)

[inline, static]

the time the cycle walls stay up ( negative values: they stay up forever )

Definition at line 256 of file gCycle.h.

References wallsStayUpDelay.

Referenced by _wrap_GCycle_walls_stay_up_delay(), gCycleWallsDisplayListManager::CannotHaveList(), cWidget::Map::DrawWalls(), gNetPlayerWall::IsDangerousAnywhere(), gNetPlayerWall::IsDangerousApartFromHoles(), gNetPlayerWall::RenderBegin(), and gNetPlayerWall::RenderNormal().

Here is the caller graph for this function:

static REAL gCycle::WallsLength

(

)

[inline, static]

the default total length of the walls

Definition at line 257 of file gCycle.h.

References wallsLength.

Referenced by _wrap_GCycle_walls_length(), cWidget::Map::DrawWalls(), gNetPlayerWall::IsDangerousAnywhere(), gNetPlayerWall::IsDangerousApartFromHoles(), gNetPlayerWall::RenderList(), and sg_CycleWallLengthFromDist().

Here is the caller graph for this function:

REAL gCycle::MaxWallsLength

(

)

const

the maximum total length of the walls (including max effect of rubber growth)

Definition at line 1681 of file gCycle.cpp.

References gCycleMovement::distance, REAL, sg_cycleDistWallShrink, sg_cycleRubberWallShrink, sg_CycleWallLengthFromDist(), sg_rubberCycle, and wallsLength.

Referenced by gCycleWallsDisplayListManager::RenderAll().

{
    REAL len = sg_CycleWallLengthFromDist( distance );

    // exception: if the wall grows faster than it receeds, take the maximum, because the wall will
    // grow backwards
    if ( sg_cycleDistWallShrink > 1 )
    {
        len = wallsLength;
    }

    // if the wall grows from rubber use, add the maximal growth
    if ( sg_cycleRubberWallShrink >= 0 || sg_rubberCycle < 0 )
        return len;
    else
        return len - sg_cycleRubberWallShrink * sg_rubberCycle;
}

Here is the call graph for this function:

Here is the caller graph for this function:

REAL gCycle::ThisWallsLength

(

)

const

the maximum total length of this cycle's wall (including rubber shrink)

Definition at line 1649 of file gCycle.cpp.

References gCycleMovement::distance, gCycleMovement::GetRubber(), REAL, sg_cycleRubberWallShrink, and sg_CycleWallLengthFromDist().

Referenced by gCycleWallsDisplayListManager::CannotHaveList(), cWidget::Map::DrawWalls(), PassEdge(), and gCycleWallsDisplayListManager::RenderAll().

{
    // get distance influence
    REAL len = sg_CycleWallLengthFromDist( distance );

    // apply rubber shortening
    return len - GetRubber() * sg_cycleRubberWallShrink;
}

Here is the call graph for this function:

Here is the caller graph for this function:

REAL gCycle::WallEndSpeed

(

)

const

the speed the end of the trail is receeding with right now

Definition at line 1660 of file gCycle.cpp.

References d, gCycleMovement::distance, REAL, gCycleMovement::rubberSpeedFactor, sg_cycleDistWallShrink, sg_cycleDistWallShrinkOffset, sg_cycleRubberWallShrink, sg_RubberValues(), and gCycleMovement::Speed().

{
    REAL rubberMax, rubberEffectiveness;
    sg_RubberValues( player, Speed(), rubberMax, rubberEffectiveness );

    // basic speed from cycle movement
    REAL speed = rubberSpeedFactor * Speed();

    // take distance shrinking into account
    REAL d = sg_cycleDistWallShrinkOffset - distance;
    if ( d > 0 )
        speed *= ( 1 - sg_cycleDistWallShrink );

    // speed from rubber usage and shringing
    if ( rubberEffectiveness > 0 )
        speed += Speed() * ( 1 - rubberSpeedFactor ) * sg_cycleRubberWallShrink / rubberEffectiveness;

    return speed;
}

Here is the call graph for this function:

static REAL gCycle::ExplosionRadius

(

)

[inline, static]

the radius of the holes blewn in by an explosion

Definition at line 261 of file gCycle.h.

References explosionRadius.

Referenced by _wrap_GCycle_explosion_radius(), gExplosion::OnNewWall(), and gExplosion::Timestep().

Here is the caller graph for this function:

bool gCycle::IsMe

(

eGameObject const *

other

)

const

checks whether the passed pointer is logically identical with this cycle

Definition at line 1419 of file gCycle.cpp.

References extrapolator_.

Referenced by gSensor::PassEdge().

{
    return other == this || other == extrapolator_;
}

Here is the caller graph for this function:

void gCycle::WriteCreate

(

nMessage &

m

)

[virtual]

Reimplemented from eNetGameObject.

Definition at line 4917 of file gCycle.cpp.

References gRealColor::b, color_, gRealColor::g, gRealColor::r, and eNetGameObject::WriteCreate().

                                   {
    eNetGameObject::WriteCreate(m);
    m << color_.r;
    m << color_.g;
    m << color_.b;

Here is the call graph for this function:

void gCycle::WriteSync

(

nMessage &

m

)

[virtual]

Reimplemented from eNetGameObject.

Definition at line 4926 of file gCycle.cpp.

References gCycleMovement::Alive(), gCycleMovement::braking, gCycleMovement::brakingReservoir, compressZeroOne, eGameObject::deathTime, Direction(), gCycleMovement::distance, gCycleMovement::GetLastTurnPos(), gCycleMovement::lastDestination, eGameObject::lastTime, gDestination::messageID, eGameObject::Position(), REAL, gCycleMovement::rubber, gCycleMovement::rubberMalus, sg_rubberCycle, sg_verletIntegration, gCycleMovement::Speed(), nVersionFeature::Supported(), gCycleMovement::turns, gCycleMovement::verletSpeed_, gFloatCompressor::Write(), nMessage::Write(), and x.

                                 {
    //  eNetGameObject::WriteSync(m);

    if ( Alive() )
    {
        m << lastTime;
    }
    else
    {
        m << deathTime;
    }
    m << Direction();
    m << Position();

    REAL speed = verletSpeed_;
    // if the clients understand it, send them the real current speed
    if ( sg_verletIntegration.Supported() )
        speed = Speed();

    if ( speed > 15 )
    {
        int x;
        x = 0;
    }

    m << speed;
    m << short( Alive() ? 1 : 0 );
    m << distance;
    if (!currentWall || currentWall->preliminary)
        m.Write(0);
    else
        m.Write(currentWall->ID());

    m.Write(turns);
    m.Write(braking);

    // write last turn position
    m << GetLastTurnPos();

    // write rubber
    compressZeroOne.Write( m, rubber/( sg_rubberCycle + .1 ) );
    compressZeroOne.Write( m, 1/( 1 + rubberMalus ) );

    // write last clientside sync message ID
    unsigned short lastMessageID = 0;
    if ( lastDestination )
        lastMessageID = lastDestination->messageID;
    m.Write(lastMessageID);

    // write brake
    compressZeroOne.Write( m, brakingReservoir );

    // set new sync times
    // nextSync=tSysTimeFloat()+sg_syncIntervalEnemy;
    // nextSyncOwner=tSysTimeFloat()+sg_GetSyncIntervalSelf( this );

Here is the call graph for this function:

void gCycle::ReadSync

(

nMessage &

m

)

[virtual]

Reimplemented from eNetGameObject.

Definition at line 5254 of file gCycle.cpp.

References gCycleMovement::AccelerationDiscontinuity(), gCycleMovement::Alive(), eSensor::before_hit, gCycleMovement::braking, gCycleMovement::SyncData::braking, gCycleMovement::brakingReservoir, gCycleMovement::SyncData::brakingReservoir, ClampForward(), color_, compressZeroOne, con, correctDistanceSmooth, correctPosSmooth, eGameObject::deathTime, gCycleMovement::destinationList, eSensor::detect(), Die(), eGameObject::dir, gCycleMovement::SyncData::dir, gCycleMovement::dirDrive, Direction(), gCycleMovement::dirSpawn, gDestination::distance, gCycleMovement::distance, gCycleMovement::SyncData::distance, DropWall(), eCoord, nMessage::End(), extrapolator_, eGameObject::FindCurrentFace(), gDestination::gameTime, gCycleMovement::GetDestinationBefore(), eGrid::GetDirection(), eGameObject::GOID(), eGameObject::Grid(), gCycleMovement::lastDirDrive, lastGoodPosition_, lastSyncMessage_, eGameObject::lastTime, gCycleMovement::SyncData::lastTurn, gCycleMovement::lastTurnPos_, gCycleMovement::SyncData::messageID, gCycleMovement::MoveSafely(), gDestination::next, NULL, nNetObject::Owner(), gCycleMovement::SyncData::pos, eGameObject::pos, gDestination::position, predictPosition_, gFloatCompressor::Read(), nMessage::Read(), REAL, resimulate_, gCycleMovement::rubber, gCycleMovement::SyncData::rubber, gCycleMovement::SyncData::rubberMalus, gCycleMovement::SetWindingNumberWrapped(), sg_cycleFirstSpawnProtection, sg_rubberCycle, skew, skewDot, sn_myNetID, sn_Update(), spawnTime_, gCycleMovement::Speed(), gCycleMovement::SyncData::speed, sqrt(), SyncEnemy(), gCycleMovement::SyncData::time, tNEW, gCycleMovement::turns, gCycleMovement::SyncData::turns, gCycleMovement::verletSpeed_, gCycleMovement::windingNumberWrapped_, and x.

{
    // data from sync message
    SyncData sync;

    short sync_alive;               // is this cycle alive?
    unsigned short sync_wall=0;     // ID of wall

    eCoord new_pos = pos;       // the extrapolated position

    // warning: depends on the implementation of eNetGameObject::WriteSync
    // since we don't call eNetGameObject::ReadSync.
    m >> sync.time;

    // reset values not sent with old protocol messages
    sync.rubber = rubber;
    sync.turns = turns;
    sync.braking = braking;
    sync.messageID = 1;

    m >> sync.dir;
    m >> sync.pos;

    //eDebugLine::SetTimeout( 1.0 );
    //eDebugLine::SetColor( 1,1,1 );
    //eDebugLine::Draw( lastSyncMessage_.pos, 0, lastSyncMessage_.pos, 20 );

    m >> sync.speed;
    m >> sync_alive;
    m >> sync.distance;
    m.Read(sync_wall);
    if (!m.End())
        m.Read(sync.turns);
    if (!m.End())
        m.Read(sync.braking);

    if ( !m.End() )
    {
        m >> sync.lastTurn;
    }
    else if ( currentWall )
    {
        sync.lastTurn = currentWall->beg;
    }

    bool canUseExtrapolatorMethod = false;

    bool rubberSent = false;
    if ( !m.End() )
    {
        rubberSent = true;

        // read rubber
        REAL preRubber, preRubberMalus;
        preRubber = compressZeroOne.Read( m );
        preRubberMalus = compressZeroOne.Read( m );

        // read last message ID
        m.Read(sync.messageID);

        // read braking reservoir
        sync.brakingReservoir = compressZeroOne.Read( m );
        // std::cout << "sync: " << sync.brakingReservoir << ":" << sync.braking << "\n";

        // undo skewing
        sync.rubber = preRubber * ( sg_rubberCycle + .1 );
        sync.rubberMalus = 1/preRubberMalus - 1;

        // extrapolation is probably safe
        canUseExtrapolatorMethod = sg_useExtrapolatorSync && lastTime > 0;
    }
    else
    {
        // try to extrapolate brake status backwards in time
        sync.brakingReservoir = brakingReservoir;
        if ( brakingReservoir > 0 && sync.braking )
            sync.brakingReservoir += ( lastTime - sync.time ) * sg_cycleBrakeDeplete;
        else if ( brakingReservoir < 1 && !sync.braking )
            sync.brakingReservoir -= ( lastTime - sync.time ) * sg_cycleBrakeRefill;

        if ( sync.brakingReservoir < 0 )
            sync.brakingReservoir = 0;
        else if ( sync.brakingReservoir > 1 )
            sync.brakingReservoir = 1;
    }

    // abort if sync is not new
    if ( lastSyncMessage_.time >= sync.time && lastSyncMessage_.turns >= sync.turns && sync_alive > 0 )
    {
        //eDebugLine::SetTimeout( 5 );
        //eDebugLine::SetColor( 1,1,0);
        //eDebugLine::Draw( lastSyncMessage_.pos, 1.5, lastSyncMessage_.pos, 5.0 );
        return;
    }
    lastSyncMessage_ = sync;

    // store last known good position: a bit before the last position confirmed by the server
    lastGoodPosition_ = sync.pos + ( sync.lastTurn - sync.pos ) *.01;
    // offset it a tiny bit by our last driving direction
    if ( eCoord::F( dirDrive, sync.dir ) > .99f*dirDrive.NormSquared() )
        lastGoodPosition_ = lastGoodPosition_ - this->lastDirDrive * .0001;

    //eDebugLine::SetTimeout( 2 );
    //eDebugLine::SetColor( 0,1,0);
    //eDebugLine::Draw( lastSyncMessage_.pos, 1.5, lastSyncMessage_.pos, 5.0 );

    // con << "Sync: " << lastTime << ", " << lastSyncMessage_.time << ", " << lastSyncMessage_.pos << ", " << pos << "\n";

    if ( canUseExtrapolatorMethod )
    {
        // reset extrapolator if information from server is more up to date
        if ( extrapolator_ && extrapolator_->LastTime() < lastSyncMessage_.time )
        {
            extrapolator_ = 0;
        }
    }

    // killed?
    if (Alive() && sync_alive!=1 && GOID() >= 0 && grid )
    {
        Die( lastSyncMessage_.time );
        MoveSafely( lastSyncMessage_.pos, lastTime, deathTime );
        distance=lastSyncMessage_.distance;
        correctDistanceSmooth=0;
        DropWall( false );

        tNEW(gExplosion)( grid, lastSyncMessage_.pos, lastSyncMessage_.time ,color_, this );

        return;
    }

    // no point going on if you're not alive
    if (!Alive())
    {
#ifdef DEBUG
        con << "Received duplicate death sync message; those things confuse old clients!\n";
#endif
        return;
    }

    gDestination emergency_aft(*this);

    // all the data was read. check where it fits in our destination list:
    gDestination *bef= GetDestinationBefore( lastSyncMessage_, destinationList );
    gDestination *aft=NULL;
    if (bef){
        aft=bef->next;
        if (!aft)
            aft=&emergency_aft;

        //eDebugLine::SetTimeout(1);
        //eDebugLine::SetColor( 1,0,0 );
        //eDebugLine::Draw( bef->position, 1.5, lastSyncMessage_.pos, 3.0 );
        //eDebugLine::SetColor( 0,1,0 );
        //eDebugLine::Draw( lastSyncMessage_.pos, 3.0, aft->position, 5.0 );

    }


    // detect local tunneling by casting a ray from the server certified position
    // to the next known client position
    if ( lastTime > 0 )
    {
        eCoord position = pos;
        if ( bef )
            position = bef->position;
        eSensor tunnel( this, lastSyncMessage_.pos, position - lastSyncMessage_.pos );
        tunnel.detect( 1 );

        // use extrapolation to undo local tunneling
        if ( tunnel.ehit )
        {
            canUseExtrapolatorMethod = true;
            if ( 0 )
            {
                con << "possible local tunneling detected\n";
                eSensor tunnel( this, lastSyncMessage_.pos, position - lastSyncMessage_.pos );
                tunnel.detect( 1 );
            }
        }
    }
    else
    {
        // first sync. Accept the position without questioning it.
        pos = sync.pos;
        FindCurrentFace();
    }

    // determine whether we can use the distance based interpolating sync method here
    bool distanceBased = aft && aft != &emergency_aft && Owner() == sn_myNetID;

    if ( canUseExtrapolatorMethod && Owner()==sn_myNetID )
    {
        // exactlu resimulate from sync position for cycles controlled by this client
        resimulate_ = true;

        return;
    }

    rubber = lastSyncMessage_.rubber;

    // bool fullSync = false;

    // try to get a distance value closer to the client's data by calculating the distance from the sync position to the next destination
    REAL interpolatedDistance = lastSyncMessage_.distance;
    if ( aft )
    {
        interpolatedDistance = aft->distance - sqrt((lastSyncMessage_.pos-aft->position).NormSquared());
    }

    // determine true lag
    // REAL lag = 1;
    //if ( player )
    //    lag = player->ping;

    if ( distanceBased )
    {
        // new way: correct our time and speed

#ifdef DEBUG
        // destination *save = bef;
#endif

        REAL ratio = (interpolatedDistance - bef->distance)/
                     (aft->distance - bef->distance);

        if (!finite(ratio))
            ratio = 0;

        // interpolate when the cycle was at the position the sync message was sent
        REAL interpolatedTime = bef->gameTime * (1-ratio) + aft->gameTime * ratio;
        // REAL interpolatedSpeed = bef->speed   * (1-ratio) + aft->speed    * ratio;

        // calculate deltas
        REAL correctTime  = ( lastSyncMessage_.time     - interpolatedTime     );
        // REAL correctSpeed = ( lastSyncMessage_.speed    - interpolatedSpeed    );
        REAL correctDist  = ( lastSyncMessage_.distance - interpolatedDistance );

        // don't trust high ratios too much; they may be skewed by rubber application
        {
            REAL factor = (1 - ratio) * 5;
            if ( factor < 1 )
            {
                if ( factor < 0 )
                    factor = 0;
                correctTime *= factor;
                correctDist *= factor;
            }
        }

        //if (correctTime > 0)
        //{
        //    correctTime*=.5;
        //    correctSpeed*=.5;
        //    correctDist*=.5;
        //}

        //correctTimeSmooth       += correctTime;
        //correctSpeedSmooth      += correctSpeed;
        // correctDistanceSmooth   += correctDist;

        // correctDistanceSmooth   += correctDist;

        // con << ratio << ", " << correctDist << ", " << correctTime << "\n";

        // correct distances according to sync
        {
            distance += correctDist;
            gDestination * run = bef;
            while ( run )
            {
                run->distance += correctDist;
                run = run->next;
            }
        }

        // correct time by adapting position and distance
        eCoord newPos = pos - Direction() * Speed() * correctTime;
        if ( currentWall )
        {
            ClampForward( newPos, currentWall->beg, Direction() );
        }

        // don't tunnel through walls
        {
            const eCoord & safePos = pos; // aft->position
            gSensor test( this, safePos , newPos - safePos );
            test.detect(1);
            if ( test.ehit )
            {
                newPos = test.before_hit;

                // something bad must be going on, better recheck with accurate extrapolation
                resimulate_ = true;
            }
        }

        correctPosSmooth = correctPosSmooth + pos - newPos;
        distance += eCoord::F( newPos - pos, Direction() )/Direction().NormSquared();

        MoveSafely( newPos, lastTime, lastTime );

        /*
        REAL ts = lastSyncMessage_.time - lastTime;

        //        eCoord intPos = pos + dirDrive * (ts * speed + .5 * ts*ts*acceleration);
        eCoord intPos = pos + dirDrive * ( ts * ( speed + lastSyncMessage_.speed ) * .5 );
        REAL  int_speed = speed + acceleration*ts;

        dirDrive = lastSyncMessage_.dir;

        correctPosSmooth = lastSyncMessage_.pos - intPos;

        distance = lastSyncMessage_.distance - speed * ts - acceleration * ts*ts*.5;

        //correctTimeSmooth = 0;
        */
    }
    else
    {
        // direct sync
        if ( Owner() != sn_myNetID )
        {
            // direct extrapolation for cycles of other clients or if no turn is newer than the sync
            SyncEnemy( lastSyncMessage_.lastTurn );

            // update beginning of current wall
            if ( currentWall )
            {
                currentWall->beg = lastSyncMessage_.lastTurn;
            }

            // update brake status
            AccelerationDiscontinuity();
            braking = lastSyncMessage_.braking;

            // store last turn
            lastTurnPos_ = lastSyncMessage_.lastTurn;
        }
        else
        {
            // same algorithm, but update smooth position correction so that there is no immediate visual change
            eCoord oldPos = pos + correctPosSmooth;
            SyncEnemy( lastSyncMessage_.lastTurn );
            correctPosSmooth = oldPos - pos;
        }

        // restore rubber meter
        if ( !rubberSent )
        {
            rubber = lastSyncMessage_.rubber;
        }
    }

    // if this happens during creation, ignore position correction
    if ( this->ID() == 0 )
    {
        correctPosSmooth = eCoord();

        // some other stuff that should happen on the first sync

        // estimate time of spawning (HACK)
        spawnTime_=lastTime;
        if ( verletSpeed_ > 0 )
            spawnTime_ -= distance/verletSpeed_;

        // set spawn time to infinite past if this is the first spawn
        if ( !sg_cycleFirstSpawnProtection && spawnTime_ <= 1.0 )
        {
            spawnTime_ = -1E+20;
        }
        dirSpawn = dirDrive;

        // reset position and direction
        predictPosition_ = pos;
        dir = dirDrive;
        skew = skewDot = 0;
        lastDirDrive=dirDrive;
        lastTurnPos_=pos;
    }
#ifdef DEBUG
    else
        if ( correctPosSmooth.NormSquared() > .1f && lastTime > 0.0 )
        {
            std::cout << "Lag slide! " << correctPosSmooth << "\n";
            int x;
            x = 0;
        }
#endif

    sn_Update(turns,lastSyncMessage_.turns);

    //if (fabs(correctTimeSmooth > 5))
    //    st_Breakpoint();

    // calculate new winding number. Try to change it as little as possible.
    this->SetWindingNumberWrapped( Grid()->DirectionWinding(dirDrive) );

    // Resnap to the axis
    dirDrive = Grid()->GetDirection(windingNumberWrapped_);

Here is the call graph for this function:

void gCycle::RequestSyncOwner

(

)

[virtual]

requests special syncs to the owner on important points (just passed an enemy trail end safely...)

Definition at line 5012 of file gCycle.cpp.

References gCycleMovement::Alive(), nextSyncOwner, nSERVER, nNetObject::Owner(), REAL, gCycleMovement::RequestSync(), sg_GetSyncIntervalSelf(), sn_GetNetState(), and tSysTimeFloat().

Referenced by PassEdge(), and TimestepCore().

{
    // no more syncs when you're dead
    if ( !Alive() )
    {
        return;
    }

    // nothing to do on the client or if the cycle belongs to an AI
    if ( sn_GetNetState() != nSERVER || Owner() == 0 )
        return;

    REAL syncInterval = sg_GetSyncIntervalSelf( this );
    if ( nextSyncOwner < tSysTimeFloat() + syncInterval * 2.0 )
    {
        // postpone next sync so the notal number of syncs stays the same
        RequestSync( Owner(), false );
        nextSyncOwner += syncInterval;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

void gCycle::RequestSyncAll

(

)

[virtual]

requests special syncs to everyone on important points (just passed an enemy trail end safely...)

Definition at line 5033 of file gCycle.cpp.

References gCycleMovement::Alive(), nextSync, nSERVER, nNetObject::Owner(), REAL, gCycleMovement::RequestSync(), sg_syncIntervalEnemy, sn_GetNetState(), and tSysTimeFloat().

Referenced by PassEdge().

{
    // no more syncs when you're dead
    if ( !Alive() )
    {
        return;
    }

    // nothing to do on the client or if the cycle belongs to an AI
    if ( sn_GetNetState() != nSERVER || Owner() == 0 )
        return;

    REAL syncInterval = sg_syncIntervalEnemy;
    if ( nextSync < tSysTimeFloat() + syncInterval * 2.0 )
    {
        // postpone next sync so the notal number of syncs stays the same
        RequestSync( false );
        nextSync += syncInterval;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

void gCycle::SyncEnemy

(

const eCoord &

begWall

)

[virtual]

handle sync message for enemy cycles

Definition at line 5656 of file gCycle.cpp.

References b, gCycleMovement::SyncData::brakingReservoir, gCycleMovement::brakingReservoir, eNetGameObject::clientside_action(), correctDistanceSmooth, CYCLE_TURN, gCycleMovement::SyncData::dir, gCycleMovement::dirDrive, gCycleMovement::SyncData::distance, gCycleMovement::distance, eDebugLine::Draw(), eCoord, EPS, eSoundMixer::GetMixer(), gNetPlayerWall, eNetGameObject::laggometer, eNetGameObject::laggometerSmooth, gCycleMovement::lastDirDrive, lastSyncMessage_, eGameObject::lastTime, lastTimeAnim, gCycleMovement::lastTimestep_, gCycleMovement::MoveSafely(), nCLIENT, NULL, nNetObject::Owner(), eGameObject::pos, gCycleMovement::SyncData::pos, eSoundMixer::PushButton(), REAL, resimulate_, gCycleMovement::SyncData::rubber, gCycleMovement::rubber, se_GameTime(), eDebugLine::SetColor(), eDebugLine::SetTimeout(), sg_cycleWallTime, skewDot, sn_GetNetState(), sn_myNetID, spawnTime_, gCycleMovement::SyncData::speed, tASSERT, gCycleMovement::SyncData::time, eGameObject::TimestepThis(), gCycleMovement::SyncData::turns, gCycleMovement::turns, and gCycleMovement::verletSpeed_.

Referenced by ReadSync().

{
    // keep this cycle alive
    tJUST_CONTROLLED_PTR< gCycle > keep( this->GetRefcount()>0 ? this : 0 );

    resimulate_ = false;

    // calculate turning
    bool turned = false;
    REAL turnDirection=( dirDrive*lastSyncMessage_.dir );
    REAL notTurned=eCoord::F( dirDrive, lastSyncMessage_.dir )/dirDrive.NormSquared();

    // the last known time
    REAL lastKnownTime = lastTime;

    // calculate the position of the last turn from the sync data
    if ( distance > 0 && ( notTurned < .99 || this->turns < lastSyncMessage_.turns ) )
    {
        // update old wall as good as we can
        eCoord crossPos = lastSyncMessage_.pos;
        REAL crossDist = lastSyncMessage_.distance;
        REAL crossTime = lastSyncMessage_.time;

        // calculate intersection of old and new trajectory (if only one turn was made)
        // the second condition is for old servers that don't send the turn count; they
        // don't support multiple axes, so we can possibly detect missed turns if
        // the dot product of the current and last direction is negative.
        if (this->turns+1 >= lastSyncMessage_.turns && ( lastSyncMessage_.turns > 0 || notTurned > -.5 ) )
        {
            if ( fabs( turnDirection ) > .01 )
            {
                REAL b = ( crossPos - pos ) * dirDrive;
                REAL distplace = b/turnDirection;
                crossPos = crossPos + lastSyncMessage_.dir * distplace;
                crossDist += distplace;
                if ( lastSyncMessage_.speed > 0 )
                    crossTime += distplace / lastSyncMessage_.speed;

                tASSERT( fabs ( ( crossPos - pos ) * dirDrive ) < 1 );
                tASSERT( fabs ( ( crossPos - lastSyncMessage_.pos ) * lastSyncMessage_.dir ) < 1 );

                // update the old wall
                if (currentWall) {
                    currentWall->Update(crossTime,crossPos);

                    eSoundMixer* mixer = eSoundMixer::GetMixer();
                    mixer->PushButton(CYCLE_TURN, crossPos);
                }
            }
        }
        else
        {
            // a turn sync was dropped for whatever reason. The last wall is not reliable.
            // make it disappear immediately.
            if (currentWall)
            {
                currentWall->real_CopyIntoGrid(grid);
            }
        }

        eDebugLine::SetTimeout(5);
        eDebugLine::SetColor( 1,0,0 );
        eDebugLine::Draw( crossPos, 0, crossPos, 8 );

        // drop old wall
        if(currentWall){
            lastWall=currentWall;
            currentWall->CopyIntoGrid( grid );
            tControlledPTR< gNetPlayerWall > bounce( currentWall );
            currentWall=NULL;
        }

        // create new wall at sync location
        distance = lastSyncMessage_.distance;
        correctDistanceSmooth=0;

        REAL startBuildWallAt = spawnTime_ + sg_cycleWallTime;
        if ( crossTime > startBuildWallAt )
            currentWall=new gNetPlayerWall
                        (this,crossPos,lastSyncMessage_.dir,crossTime,crossDist);

        turned = true;

        // save last driving direction
        lastDirDrive = dirDrive;

        // move to cross position
        MoveSafely( crossPos, lastTime, crossTime );
        lastKnownTime = crossTime;
    }

    // side bending
    skewDot+=4*turnDirection;

    // calculate timestep
    // REAL ts = lastSyncMessage_.time - lastTime;

    // backup current time
    REAL oldTime = lastTime;

    // update position, speed, distance and direction
    MoveSafely( lastSyncMessage_.pos, lastKnownTime, lastSyncMessage_.time );
    verletSpeed_  = lastSyncMessage_.speed;
    lastTimestep_ = 0;
    distance = lastSyncMessage_.distance;
    correctDistanceSmooth=0;
    dirDrive = lastSyncMessage_.dir;
    rubber = lastSyncMessage_.rubber;
    brakingReservoir = lastSyncMessage_.brakingReservoir;

    // update time to values from sync
    lastTime = lastSyncMessage_.time;
    if ( oldTime < 0 )
        oldTime = lastTime;
    clientside_action();

    // bend last driving direction if it is antiparallel to the current one
    if ( lastDirDrive * dirDrive < EPS && eCoord::F( lastDirDrive, dirDrive ) < 0 )
    {
        lastDirDrive = dirDrive.Turn(0,1);
    }

    // correct laggometer to actual facts
    if (Owner() != sn_myNetID )
    {
        // calculate lag from sync delay
        REAL lag = se_GameTime() - lastSyncMessage_.time;
        if ( lag < 0 )
            lag = 0;

        // try not to let the lag jump
        REAL maxLag = laggometer * 1.2;
        REAL minLag = laggometer * .8;

        // store it
        laggometer = lag;

        // clamp smooth laggometer to it (or set it if a turn was made)
        //if ( laggometerSmooth > lag )
        //    laggometerSmooth = lag;

        // For the client and without prediction:
        // do not simulate if a turn was made, just accept sync as it is
        // (so turns don't look awkward)
        if (
            sn_GetNetState()==nCLIENT && turned )
        {
            laggometerSmooth = lag;

            // but at least update the current wall
            if ( currentWall )
                currentWall->Update(lastTime,pos);

            // and reset the animation time
            lastTimeAnim=lastTime;

            return;
        }
        else
        {
            // sanity check: the lag should not jump up suddenly
            // (and if it does, we'll catch up at the next turn)
            // REAL maxLag = 1.2 * laggometerSmooth;
            if ( laggometer > maxLag )
                laggometer = maxLag;
            if ( laggometer < minLag )
                laggometer = minLag;
        }
    }

    // simulate to extrapolate, but don't touch the smooth laggometer
    {
        REAL laggometerSmoothBackup = this->laggometerSmooth;
        TimestepThis(oldTime, this);
        this->laggometerSmooth = laggometerSmoothBackup;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

void gCycle::ReceiveControl	(	REAL	time,
		uActionPlayer *	Act,
		REAL	x
	)			[virtual]

Reimplemented from eNetGameObject.

Definition at line 5931 of file gCycle.cpp.

References Act(), and eGameObject::TimestepThis().

                                                              {
    //forceTime=true;
    TimestepThis(time,this);
    Act(act,x);
    //forceTime=false;

Here is the call graph for this function:

void gCycle::PrintName

(

tString &

s

)

const [virtual]

Reimplemented from nNetObject.

Definition at line 5938 of file gCycle.cpp.

References nNetObject::ID().

Referenced by sg_TopologyPoliceKill().

{
    s << "gCycle nr. " << ID();
    if ( this->player )
    {
        s << " owned by ";
        this->player->PrintName( s );
    }

Here is the call graph for this function:

Here is the caller graph for this function:

bool gCycle::ActionOnQuit

(

)

[virtual]

Reimplemented from eNetGameObject.

Definition at line 5948 of file gCycle.cpp.

References Kill(), nSERVER, sn_GetNetState(), and nNetObject::TakeOwnership().

Referenced by _wrap_GCycle_action_on_quit().

{
    //  currentWall = NULL;
    //  lastWall = NULL;
    if ( sn_GetNetState() == nSERVER )
    {
        TakeOwnership();
        Kill();
        return false;
    }
    else
    {
        return true;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

nDescriptor & gCycle::CreatorDescriptor

(

void

)

const [virtual]

Implements nNetObject.

Definition at line 5965 of file gCycle.cpp.

References cycle_init.

Referenced by _wrap_GCycle_creator_descriptor().

                                            {
    return cycle_init;

Here is the caller graph for this function:

bool gCycle::SyncIsNew

(

nMessage &

m

)

[virtual]

Reimplemented from eNetGameObject.

Definition at line 4983 of file gCycle.cpp.

References con, nMessage::Read(), REAL, and eNetGameObject::SyncIsNew().

                                 {
    bool ret=eNetGameObject::SyncIsNew(m);


    REAL dummy2;
    short al;
    unsigned short Turns;

    m >> dummy2;
    m >> al;
    m >> dummy2;
    m.Read(Turns);

#ifdef DEBUG_X
    con << "received sync for player " << player->GetName() << "  ";
    if (ret || al!=1){
        con << "accepting..\n";
        return true;
    }
    else
    {
        con << "rejecting..\n";
        return false;
    }
#endif

    return ret || al!=1;

Here is the call graph for this function:

bool gCycle::Timestep

(

REAL

currentTime

)

[virtual]

advance to the given time

Parameters:

currentTime

the time to simulate up to

Returns:

true if the cycle is to be deleted

Reimplemented from gCycleMovement.

Definition at line 2509 of file gCycle.cpp.

References gCycleChatBot::Activate(), gCycleMovement::Alive(), tRecorderSync< DATA >::Archive(), CalculatePredictPosition(), chatBot_, gCycleMovement::currentDestination, gCycleMovement::destinationList, Die(), gDestination::distance, dropWallRequested_, dt, Extrapolate(), extrapolator_, gCycleChatBot::Get(), nNetObject::ID(), gDestination::InsertIntoList(), KillAt(), eGameObject::lastTime, gCycleMovement::maxSpaceHit_, gDestination::messageID, nCLIENT, gCycleMovement::pendingTurns, eNetGameObject::Player(), eGameObject::pos, gCycleDeath::pos_, PredictPosition(), PreparePredictPosition(), REAL, ResetExtrapolator(), resimulate_, sg_ArchiveCoord(), sg_ArchiveReal(), sg_chatBotAlwaysActive, sg_gnuplotDebug, sg_minDropInterval, sg_syncFF, sg_syncFFSteps, sn_GetNetState(), sn_myNetID, SyncFromExtrapolator(), gCycleMovement::Timestep(), tNEW, tSysTimeFloat(), and gCycleMovement::verletSpeed_.

Referenced by sg_CreateWinDeathZone().

                                     {
    // clear out dangerous info when we're done
    gMaxSpaceAheadHitInfoClearer hitInfoClearer( maxSpaceHit_ );

    // if ( Owner() == sn_myNetID )
    //    con << pos << ',' << distance << ',' << eCoord::F( dirDrive, pos ) - distance << '\n';

    // request the right space ahead for wall extrapolation
    gPredictPositionData predictPositionData;
    PreparePredictPosition( predictPositionData );

    // drop current wall if it was requested
    if ( dropWallRequested_ )
    {
        // but don't do so too often globally (performance)
        static double nextDrop = 0;
        double time = tSysTimeFloat();
        if ( time >= nextDrop )
        {
            unsigned short idrec = ID();
            tRecorderSync< unsigned short >::Archive( "_PARTIAL_COPY_GRID", 8, idrec );

            nextDrop = time + sg_minDropInterval;
            if ( currentWall )
            {
                currentWall->Update(lastTime,pos);
                currentWall->PartialCopyIntoGrid( grid );
            }
            dropWallRequested_ = false;
        }
    }

#ifdef GNUPLOT_DEBUG
    if ( sg_gnuplotDebug && Player() )
    {
        std::ofstream f( Player()->GetUserName() + "_step", std::ios::app );
        f << pos.x << " " << pos.y << "\n";
    }
#endif
    // timewarp test debug code
    //if ( Player() && Player()->IsHuman() )
    //    currentTime -= .1;

    // don't timestep when you're dead
    if ( !Alive() )
    {
        // die completely
        Die( lastTime );

        // and let yourself be removed from the lists so we don't have to go
        // through this again.
        return true;
    }

    // Debug archive position and speed
    sg_ArchiveCoord( pos, 7 );
    sg_ArchiveReal( verletSpeed_, 7 );

    if ( !destinationList && sn_GetNetState() == nCLIENT )
    {
        // insert emergency first destination without broadcasting it
        gDestination* dest = tNEW(gDestination)(*this);
        dest->messageID = 0;
        dest->distance = -.001;
        dest->InsertIntoList(&destinationList);
    }

    // start new extrapolation
    if ( !extrapolator_ && resimulate_ )
        ResetExtrapolator();

    // extrapolate state from server and copy state when finished
    if ( extrapolator_ )
    {
        REAL dt = ( currentTime - lastTime ) * sg_syncFF / sg_syncFFSteps;
#ifdef DEBUG
        // dt *= 10.101;
        //if ( !resimulate_ )
        //      dt *= .1;
#endif
        for ( int i = sg_syncFFSteps - 1; i>= 0; --i )
        {
            if ( Extrapolate( dt ) )
            {
                SyncFromExtrapolator();
                break;
            }
        }
    }

    bool ret = false;

    // nothing special if simulating backwards
    if (currentTime < lastTime)
    {
        ret = gCycleMovement::Timestep(currentTime);
    }
    // no targets are given
    else if ( !currentDestination && pendingTurns.empty() )
    {
        // chatting? activate chatbot
        if ( bool(player) &&
                player->IsHuman() &&
                ( sg_chatBotAlwaysActive || player->IsChatting() ) &&
                player->Owner() == sn_myNetID )
        {
            gCycleChatBot & bot = gCycleChatBot::Get( this );
            bot.Activate( currentTime );
        }
        else if ( &(*chatBot_) )
        {
            chatBot_->nextChatAI_ = 0;
        }

        bool simulate=Alive();

        if ( !pendingTurns.empty() || currentDestination )
            simulate=true;

        if (simulate)
        {
            try
            {
                ret = gCycleMovement::Timestep(currentTime);
            }
            catch ( gCycleDeath const & death )
            {
                KillAt( death.pos_ );
                return false;
            }
        }
        else
            ret = !Alive();
    }
    else
    {
        // just basic movement to do: let base class handle that.
        try
        {
            gCycleMovement::Timestep(currentTime);
        }
        catch ( gCycleDeath const & death )
        {
            KillAt( death.pos_ );
            return false;
        }
    }

    // do the rest of the timestep
    try
    {
        if ( currentTime > lastTime )
            ret = gCycleMovement::Timestep(currentTime);
    }
    catch ( gCycleDeath const & death )
    {
        KillAt( death.pos_ );
        return false;
    }

    REAL predictTime = CalculatePredictPosition( predictPositionData );

    if ( Alive() && currentWall )
    {
        // z-man: the next two lines are a very bad idea. This lets walls stick out on the other side while you're using up your rubber.
        //if ( sn_GetNetState() != nSERVER )
        //    wallEndPos = pos + dirDrive * ( verletSpeed_ * se_PredictTime() );

        // but using the predicted position which halts at walls may work
        currentWall->Update(predictTime, PredictPosition() );
    }

    return ret;

Here is the call graph for this function:

Here is the caller graph for this function:

bool gCycle::TimestepCore	(	REAL	currentTime,
		bool	calculateAcceleration = true
	)			[virtual]

core physics simulation routine

Parameters:

currentTime

time to simulate up to

Returns:

true if the cycle is to be killed

Reimplemented from gCycleMovement.

Definition at line 2738 of file gCycle.cpp.

References gCycleMovement::Alive(), gRealColor::b, clamp(), ClampDisplacement(), color_, correctDistanceSmooth, correctPosSmooth, crash_sparks, gPlayerWall::Cycle(), DecaySmooth(), Die(), eGameObject::dir, gCycleMovement::dirDrive, gCycleMovement::dirSpawn, DropWall(), eCoord, EPS, fr, gRealColor::g, gCycleMovement::GetMaxSpaceAhead(), joystick_, KillAt(), eGameObject::lastTime, lastTimeAnim, gCycleMovement::lastTurnPos_, gCycleMovement::MoveSafely(), nextSync, nextSyncOwner, nSERVER, nNetObject::Owner(), eGameObject::pos, gCycleDeath::pos_, gRealColor::r, REAL, gCycleMovement::RequestSync(), RequestSyncOwner(), rotate(), rotationFrontWheel, rotationRearWheel, gCycleMovement::rubberSpeedFactor, sg_ArchiveCoord(), sg_ArchiveReal(), sg_avoidBadOldClientSync, sg_cycleSyncSmoothMinSpeed, sg_cycleSyncSmoothThreshold, sg_cycleSyncSmoothTime, sg_cycleWallTime, sg_GetSparksDistance(), sg_GetSyncIntervalSelf(), sg_NoLocalTunnelOnSync, sg_syncIntervalEnemy, skew, skewDot, sn_Connections, sn_GetNetState(), spawnTime_, gCycleMovement::Speed(), sqrt(), nVersionFeature::Supported(), gCycleMovement::TimestepCore(), TransferPositionCorrectionToDistanceCorrection(), ts, tSysTimeFloat(), gJoystick::Turn(), nBandwidthControl::Usage_Planning, and gCycleMovement::verletSpeed_.

Referenced by OnNotifyNewDestination().

                                                                      {
    if (!finite(skew))
        skew=0;
    if (!finite(skewDot))
        skewDot=0;

    eCoord oldpos=pos;

    // let the joystick execute delayed turns
    if ( joystick_ )
    {
        joystick_->Turn();
    }

    // archive rubber speed for later comparison
    REAL rubberSpeedFactorBack = rubberSpeedFactor;

    REAL ts=(currentTime-lastTime);

    clamp(ts, -10, 10);
    //clamp(correctTimeSmooth, -100, 100);
    clamp(correctDistanceSmooth, -100, 100);
    //clamp(correctSpeedSmooth, -100, 100);

    // scale factor for smoothing. It is always used as
    // value += smooth * smooth_correction;
    // smooth_correction -= smooth * smooth_correction;

    REAL smooth = 0;

    if ( ts > 0 )
    {
        // go a bit of the way
        smooth = 1 - 1/( 1 + ts / sg_cycleSyncSmoothTime );
    }

    //if ( smooth > 0)
    //{
    //    REAL scd = correctDistanceSmooth * smooth;
    //    distance += scd;
    //    correctDistanceSmooth -= scd;
    // }

    // handle distance correction
    TransferPositionCorrectionToDistanceCorrection();

    // apply smooth position correction
    // smooth = .5f;
    //correctPosSmooth = eCoord(0,0);

    // correctPosSmooth = correctPosSmooth * ( 1 - smooth );

    //if ( 0 )

    REAL animts=currentTime-lastTimeAnim;
    if (animts<0 || !finite(animts))
        animts=0;
    else
        lastTimeAnim=currentTime;

    // handle decaying of smooth position correction
    {
        // let components of smooth position correction decay
        REAL minSpeed = sg_cycleSyncSmoothMinSpeed * Speed() * animts;
        REAL clamp    = sg_cycleSyncSmoothThreshold * Speed();

        DecaySmooth( correctPosSmooth.x, smooth, minSpeed, clamp );
        DecaySmooth( correctPosSmooth.y, smooth, minSpeed, clamp );

        // do sanity checks
        if ( correctPosSmooth.NormSquared() > EPS )
        {
            // cast ray to make sure corrected position lies on the right side of walls
            ClampDisplacement( this, correctPosSmooth, correctPosSmooth * 2, pos );

            // same for negative direction, players should see it when they are close to a wall
            ClampDisplacement( this, correctPosSmooth, -correctPosSmooth, pos );

            // cast another some rays into the future
            eCoord lookahead = dirDrive * ( 2 * correctPosSmooth.Norm() );
            ClampDisplacement( this, correctPosSmooth, lookahead, pos );
        }
    }

    if (animts>.2)
        animts=.2;

    rotate(rotationFrontWheel,2*verletSpeed_*animts/.43);
    rotate(rotationRearWheel,2*verletSpeed_*animts/.73);

    REAL sparksDistance = sg_GetSparksDistance();
    REAL extension = .25;
    if ( extension < sparksDistance )
        extension = sparksDistance;

    //    REAL step=speed*ts; // +.5*acceleration*ts*ts;

    // animate cycle direction
    {
        // move it a bit closer to dirDrive
        dir=dir+dirDrive*animts*verletSpeed_*3;

        // if it's too far away from dirDrive, clamp it
        eCoord dirDistance = dir - dirDrive;
        REAL dist = dirDistance.NormSquared();
        const REAL maxDist = .8;
        if (dirDistance.NormSquared() > maxDist)
            dir = dirDrive + dirDistance* (1/sqrt(dist/maxDist));

        // normalize
        dir=dir*(1/sqrt(dir.NormSquared()));
    }

    {
        eCoord oldPos = pos;

        if ( Alive() ){
            // delegate core work to base class
            try
            {
                // start building wall
                REAL startBuildWallAt = spawnTime_ + sg_cycleWallTime;
                if ( !currentWall && currentTime > startBuildWallAt  )
                {
                    // simulate right to the spot where the wall should begin
                    if ( currentTime < startBuildWallAt )
                        if ( gCycleMovement::TimestepCore( startBuildWallAt, calculateAcceleration ) )
                            return true;
                    calculateAcceleration = true;

                    // build the wall, modifying the spawn time to make sure it happens
                    REAL lastSpawn = spawnTime_;
                    spawnTime_ += -1E+20;
                    DropWall();
                    spawnTime_ = lastSpawn;
                    dirSpawn = dirDrive;
                    lastTurnPos_ = pos; // hack last turn position to generate good wall
                }

                // simulate rest of frame
                if ( gCycleMovement::TimestepCore( currentTime, calculateAcceleration ) )
                    return true;
            }
            catch ( gCycleDeath const & death )
            {
                KillAt( death.pos_ );

                // death exceptions are precise; we can safely take over the position from it
                oldPos = death.pos_;
            }
        }

        // die where you started
        if ( !Alive() )
        {
            MoveSafely(oldPos,currentTime,currentTime);
            Die( currentTime );
        }
    }

    // Debug archive position and speed
    sg_ArchiveCoord( pos, 7 );
    sg_ArchiveReal( verletSpeed_, 7 );

    if (Alive()){
#ifndef DEDICATED
        // animate skew
        gSensor fl(this,pos,dirDrive.Turn(1,1));
        gSensor fr(this,pos,dirDrive.Turn(1,-1));

        fl.detect(extension*4);
        fr.detect(extension*4);

        if (fl.hit > extension)
            fl.hit = extension;

        if (fr.hit > extension)
            fr.hit = extension;

        REAL lr=(fl.hit-fr.hit)/extension;

        // ODE for skew
        const REAL skewrelax=24;
        skewDot-=128*(skew+lr/2)*animts;
        skewDot/=1+skewrelax*animts;
        if (skew*skewDot>4) skewDot=4/skew;
        skew+=skewDot*animts;

        REAL fac = 0.5f;
        if ( skew > fr.hit * fac )
        {
            skew = fr.hit * fac;
        }
        if ( skew < -fl.hit * fac )
        {
            skew = -fl.hit * fac;
        }

        // generate sparks
        eCoord sparkpos,sparkdir;

        if (fl.ehit && fl.hit<=sparksDistance){
            sparkpos=pos+dirDrive.Turn(1,1)*fl.hit;
            sparkdir=dirDrive.Turn(0,-1);
        }
        if (fr.ehit && fr.hit<=sparksDistance){
            sparkpos=pos+dirDrive.Turn(1,-1)*fr.hit;
            sparkdir=dirDrive.Turn(0,1);
        }

        if (fabs(skew)<fabs(lr*.8) ){
            skewDot-=lr*1000*animts;
            if (crash_sparks && animts>0)
            {
                gPlayerWall *tmpplayerWall=0;

                if(fl.ehit) tmpplayerWall=dynamic_cast<gPlayerWall*>(fl.ehit->GetWall());
                if(fr.ehit) tmpplayerWall=dynamic_cast<gPlayerWall*>(fr.ehit->GetWall());

                if(tmpplayerWall) {
                    gCycle *tmpcycle = tmpplayerWall->Cycle();

                    if( tmpcycle )
                        new gSpark(grid, sparkpos-dirDrive*.1,sparkdir,currentTime,color_.r,color_.g,color_.b,tmpcycle->color_.r,tmpcycle->color_.g,tmpcycle->color_.b);
                }
                else
                    new gSpark(grid, sparkpos-dirDrive*.1,sparkdir,currentTime,color_.r,color_.g,color_.b,1,1,1);
            }
        }

        if (fabs(skew)<fabs(lr*.9) ){
            skewDot-=lr*100*animts;
            if (crash_sparks && animts>0)
            {
                gPlayerWall *tmpplayerWall=0;

                if(fl.ehit) tmpplayerWall=dynamic_cast<gPlayerWall*>(fl.ehit->GetWall());
                if(fr.ehit) tmpplayerWall=dynamic_cast<gPlayerWall*>(fr.ehit->GetWall());

                if(tmpplayerWall) {
                    gCycle *tmpcycle = tmpplayerWall->Cycle();

                    if( tmpcycle )
                        new gSpark(grid, sparkpos-dirDrive*.1,sparkdir,currentTime,color_.r,color_.g,color_.b,tmpcycle->color_.r,tmpcycle->color_.g,tmpcycle->color_.b);
                }
                else
                    new gSpark(grid, sparkpos-dirDrive*.1,sparkdir,currentTime,color_.r,color_.g,color_.b,1,1,1);
            }
        }
#endif
        /*
          if (fl.hit+fr.hit<extension*.4)
          Kill();
        */
    }

    // clamp skew
    if (skew>.5){
        skew=.5;
        skewDot=0;
    }

    if (skew<-.5){
        skew=-.5;
        skewDot=0;
    }

    // checkpoint wall when rubber starts to get used
    if ( currentWall )
    {
        if ( rubberSpeedFactor >= .99 && rubberSpeedFactorBack < .99 )
        {
            currentWall->Checkpoint();
        }

        if ( rubberSpeedFactor < .99 && rubberSpeedFactorBack >= .99 )
        {
            currentWall->Checkpoint();
        }

        if ( rubberSpeedFactor < .1 && rubberSpeedFactorBack >= .1 )
        {
            currentWall->Checkpoint();
        }

        if ( rubberSpeedFactor < .01 && rubberSpeedFactorBack >= .01 )
        {
            currentWall->Checkpoint();
        }
    }


    if ( sn_GetNetState()==nSERVER )
    {
        // do an emergency sync when rubber starts to get used, it may come unexpected to clients
        if ( rubberSpeedFactor < .99 && rubberSpeedFactorBack >= .99 )
        {
            RequestSyncOwner();
        }

        if (nextSync < tSysTimeFloat() )
        {
            // delay syncs for old clients when there is a wall ahead; they would tunnel locally
            REAL lookahead = Speed() * sg_syncIntervalEnemy*.5;
            if ( !sg_avoidBadOldClientSync || sg_NoLocalTunnelOnSync.Supported( Owner() ) || GetMaxSpaceAhead( lookahead ) >= lookahead )
            {
                RequestSync(false);

                // checkpoint wall for better collision accuracy, only required on the server
                if ( currentWall )
                    currentWall->Checkpoint();
            }

            nextSync=tSysTimeFloat()+sg_syncIntervalEnemy;
            nextSyncOwner=tSysTimeFloat()+sg_GetSyncIntervalSelf( this );
        }
        else if ( nextSyncOwner < tSysTimeFloat() &&
                  Owner() != 0 &&
                  sn_Connections[Owner()].bandwidthControl_.Control( nBandwidthControl::Usage_Planning ) > 200 )
        {
            // sync only to the owner (provided there is enough bandwidth available)
            RequestSyncOwner();
        }
    }

    return (!Alive());

Here is the call graph for this function:

Here is the caller graph for this function:

void gCycle::InteractWith	(	eGameObject *	target,
		REAL	time,
		int	recursion = 1
	)			[virtual]

Reimplemented from eGameObject.

Definition at line 3067 of file gCycle.cpp.

                                                     {
    /*
      if (alive && target->type()==ArmageTron_CYCLE){
         gCycle *c=(gCycle *)target;
         if (c->alive){
      const eEdge *current_eEdge=Edge();
      const eEdge *other_eEdge=c->Edge();
      if(current_eEdge && other_eEdge){
      ePoint *meet=current_eEdge->IntersectWith(other_eEdge);
      if (meet){ // somebody is going to die!
      REAL ratio=current_eEdge->Ratio(*meet);
      REAL time=CurrentWall()->Time(ratio);
      PassEdge(other_eEdge,time,other_eEdge->Ratio(*meet),0);
      }
      }
         }
      }
    */

bool gCycle::EdgeIsDangerous	(	const eWall *	wall,
		REAL	time,
		REAL	alpha
	)			const [virtual]

returns whether a given wall is dangerous to this cycle

Parameters:

	wall	the wall to check for danger
	time	the time of the possible collision
	alpha	the local wall coordinate of the collision

Returns:

true if the wall is dangerous

Reimplemented from gCycleMovement.

Definition at line 3264 of file gCycle.cpp.

References gPlayerWall::Cycle(), gPlayerWall::CycleMovement(), gCycleMovement::EdgeIsDangerous(), gJustChecking::justChecking, gPlayerWall::NetWall(), nNetObject::Owner(), sn_myNetID, eGameObject::Team(), gPlayerWall::Time(), and Vulnerable().

Referenced by PassEdge().

                                                                    {
    gPlayerWall const * w = dynamic_cast< gPlayerWall const * >( ww );
    if ( w )
    {
        if ( !Vulnerable() )
            return false;

        gNetPlayerWall *nw = w->NetWall();

        // check whether the wall is one of the walls no real collision is
        // possible with. The lastNetWall is only checked for enemy cycles,
        // because it can be an arbitrary wall for your own cycle. But for
        // enemy cycles, it may be what lastWall should be, and the test
        // prevents enemy cycles from getting stuck right after a turn.
        if( nw == currentWall || nw == lastWall || ( nw == lastNetWall && Owner() != sn_myNetID ) )
            return false;

        // see if the wall is from another player and from the future.
        // if it is, it's not dangerous, this cycle was here first.
        // on passing the wall later, the other cycle will be pushed back
        // to the collision point or killed if that is no longer possible.
        // z-man notes: I've got the vaque feeling something like this was
        // here before, but got thrown out again for making problems.
        if ( gJustChecking::justChecking && w->CycleMovement() != static_cast< const gCycleMovement * >( this ) && w->Time(a) > time )
        {
            // One problem with this is that you kill teammates if they can't
            // be pushed back, whereas we'd just use our rubber to survive.
            // So we should first check whether the other player should be
            // protected.
            gCycle const * otherPlayer = w->Cycle();
            if ( !otherPlayer || // valididy
                    otherPlayer->Team() != this->Team() || // team protection
                    !otherPlayer->currentWall || w == otherPlayer->currentWall->Wall() // pushback protection, if the other player can be pushed back, it's all right as well
               )
                return false;
        }
    }

    return gCycleMovement::EdgeIsDangerous( ww, time, a );

Here is the call graph for this function:

Here is the caller graph for this function:

void gCycle::PassEdge	(	const eWall *	w,
		REAL	time,
		REAL	a,
		int	recursion = 1
	)			[virtual]

Reimplemented from eGameObject.

Definition at line 3338 of file gCycle.cpp.

References gExplosion::AccountForHole(), gEnemyInfluence::AddWall(), gCycleMovement::Alive(), ePlayerNetID::CurrentTeam(), gPlayerWall::Cycle(), d, gCycleMovement::dirDrive, gCycleMovement::distance, DropWall(), dropWallRequested_, dt, eCoord, EdgeIsDangerous(), gCycleMovement::enemyInfluence, EPS, Extrapolate(), extrapolator_, gCycleMovement::GetDistanceSinceLastTurn(), gCycleMovement::GetLastTurnPos(), eGameObject::GetMaxLazyLag(), gExplosion::GetOwner(), ePlayerNetID::GetUserName(), gPlayerWall::Holer(), KillAt(), eNetGameObject::Lag(), eGameObject::LastTime(), eGameObject::lastTime, max(), gCycleMovement::MoveSafely(), nCLIENT, eNetGameObject::Player(), eWall::Point(), eGameObject::pos, gPlayerWall::Pos(), REAL, RequestSyncAll(), RequestSyncOwner(), ResetExtrapolator(), gCycleMovement::rubber, score_hole, se_GameTime(), se_SaveToLadderLog(), sg_HoleScore(), sg_KillFutureWalls(), sg_RubberValues(), sn_GetNetState(), gCycleMovement::Speed(), ThisWallsLength(), gPlayerWall::Time(), gCycleMovement::verletSpeed_, and Vulnerable().

Referenced by sg_TopologyPoliceCheck().

                                                         {
    {
        // deactivate time check
        gJustChecking thisIsSerious;

        if (!EdgeIsDangerous(ww,time,a) || !Alive() )
        {
            // request a sync for everyone if this is a non-bogus wall passage, maybe not all clients know the wall is passable
            if ( ( !currentWall || ww != currentWall->Wall() ) && ( !lastWall || ww != lastWall->Wall() ) )
                RequestSyncAll();
            
            // check whether we drove through a hole in an enemy wall made by a teammate
            gPlayerWall const * w = dynamic_cast< gPlayerWall const * >( ww );
            if ( w && score_hole )
            {
                gExplosion * explosion = w->Holer( a, time );
                if ( explosion )
                {
                    gCycle * holer = explosion->GetOwner();
                    if ( holer && holer->Player() &&
                         Player() &&
                         w->Cycle() && w->Cycle()->Player() &&
                         holer->Player()->CurrentTeam() == Player()->CurrentTeam() &&       // holer must have been a teammate 
                         w->Cycle()->Player()->CurrentTeam() != Player()->CurrentTeam()  // wall must have been an enemy
                        )
                    {
                        // this test must come last, it resets the flag.
                        if ( explosion->AccountForHole() )
                        {
                            tString ladderLog;
                            ladderLog << "SACRIFICE " << Player()->GetUserName() << " " << holer->Player()->GetUserName() << " " << w->Cycle()->Player()->GetUserName() << "\n";
                            se_SaveToLadderLog( ladderLog );
                            if ( score_hole > 0 )
                            {
                                // positive hole score goes to the holer
                                sg_HoleScore( *holer );
                            }
                            else
                            {
                                // negative hole score to the driver
                                sg_HoleScore( *this );

                            }
                       }
                    }
                }
            }

            return;
        }

#ifdef DEBUG
        if (!EdgeIsDangerous(ww,time,a) || !Alive() )
            return;
#endif
    }

    // request a sync to bring everyone up to date about the cycle passing/getting stuck on this wall
    RequestSyncOwner();

#ifdef DEBUG_X
    // keep other cycle around
    tJUST_CONTROLLED_PTR<gCycleExtrapolator> keepOther( extrapolator_ );

    ResetExtrapolator();

    // extrapolate state from server and copy state when finished
    REAL dt = 1;
    for ( int i = 9; i>= 0; --i )
    {
        Extrapolate( dt );
    }

    extrapolator_ = keepOther;
#endif

    eCoord collPos = ww->Point( a );

    const gPlayerWall *w = dynamic_cast<const gPlayerWall*>(ww);

    enemyInfluence.AddWall( ww, collPos, 0, this );

    if (w)
    {
        gCycle *otherPlayer=w->Cycle();

        REAL otherTime = w->Time(a);
        if(otherPlayer && time < otherTime*(1-EPS) )
        {
            // also send updates about the other cylce
            otherPlayer->RequestSyncOwner();

            // get the distance of the wall
            REAL wallDist = w->Pos(a);
            // get the distance the cycle is simulated up to
            REAL cycleDist = w->Cycle()->distance;
            // comparing these two gives an accurate criterion whether the wall is extrapolated
            if ( wallDist > cycleDist * (1 + EPS ) )
            {
                static bool fix = false;
                // it's an extrapolation wall, don't simulate further.
                if ( fix && lastTime > se_GameTime() - 2 * Lag() - GetMaxLazyLag() )
                    throw gCycleStop();
                else
                    return;
            }

            // we were first!
            if ( otherPlayer->Vulnerable() )
            {
                static bool tryToSaveFutureWallOwner = true;
                bool saved = false;

                if ( tryToSaveFutureWallOwner && otherPlayer->currentWall && w == otherPlayer->currentWall->Wall() )
                {
                    // teleport the other cycle back to the point before the collision; its next timestep
                    // will simulate the collision again from the right viewpoint
                    // determine the distance of the pushback
                    REAL d = otherPlayer->GetDistanceSinceLastTurn() * .001;
                    if ( d < .01 )
                        d = .01;
                    REAL maxd = eCoord::F( otherPlayer->dirDrive, collPos - otherPlayer->GetLastTurnPos() ) * .5/otherPlayer->dirDrive.NormSquared();
                    if ( d > maxd )
                        d = maxd;
                    if ( d > 0 )
                    {
                        saved = true;

                        // do the move
                        otherPlayer->MoveSafely( collPos-otherPlayer->dirDrive*d, otherPlayer->LastTime(), otherTime - d/otherPlayer->Speed() );
                        otherPlayer->currentWall->Update( otherPlayer->lastTime, otherPlayer->pos );
                        otherPlayer->dropWallRequested_ = false;

                        // drop our wall so collisions are more accurate
                        dropWallRequested_ = true;
                    }
                }

                // another possibility: if the walls are very short compared to rubber, we could
                // get away with just accounding for some rubber on the cycle that we'd need to kill
                // otherwise.
                if ( !saved && verletSpeed_ >= 0 )
                {
                    REAL dt = otherTime - time;

                    // this long would the other cycle have to sit in front of our wall
                    // before he's released by the end
                    REAL wallTimeLeft = this->ThisWallsLength()/verletSpeed_ - dt;

                    if ( wallTimeLeft < 0 )
                    {
                        // isn't hit at all
                        return;
                    }

                    // check how much rubber would be used
                    REAL max, effectiveness;
                    sg_RubberValues( otherPlayer->Player(), otherPlayer->verletSpeed_, max, effectiveness );
                    if ( effectiveness > 0 )
                    {
                        REAL rubberToEat = wallTimeLeft * otherPlayer->Speed()/effectiveness;

                        otherPlayer->rubber += rubberToEat;
                        if ( otherPlayer->rubber > max )
                            otherPlayer->rubber = max; // too much rubber used
                        else
                            saved = true;              // within bounds, he may survive
                    }
                }

                if ( !saved && sn_GetNetState() != nCLIENT )
                {
                    // err, trouble. Can't push the other guy back far enough. Better kill him.
                    if ( currentWall )
                        otherPlayer->enemyInfluence.AddWall( currentWall->Wall(), lastTime, otherPlayer );
                    otherPlayer->distance = wallDist;
                    otherPlayer->DropWall();
                    otherPlayer->KillAt( collPos );

                    // get rid of future walls
                    sg_KillFutureWalls( otherPlayer );
                }
            }
        }
        else // sad but true
        {
            // this cycle has to die here unless it has rubber left or is invulnerable (checked on catching the exception, and besides, this code path isn't called for invulnerable cycles)
            throw gCycleDeath( collPos );

            //                  REAL dist = w->Pos( a );
            //                  const_cast<gPlayerWall*>(w)->BlowHole( dist - explosionRadius, dist + explosionRadius );
        }
    }
    else
    {
        if (bool(player) && sn_GetNetState()!=nCLIENT && Alive() )
        {
            throw gCycleDeath( collPos );
        }

    }

Here is the call graph for this function:

Here is the caller graph for this function:

REAL gCycle::PathfindingModifier

(

const eWall *

w

)

const [virtual]

Reimplemented from eGameObject.

Definition at line 3541 of file gCycle.cpp.

{
    if (!w)
        return 1;
    if (dynamic_cast<const gPlayerWall*>(w))
        return .9f;
    else
        return 1;

bool gCycle::Act	(	uActionPlayer *	Act,
		REAL	x
	)			[virtual]

Reimplemented from eGameObject.

Definition at line 3552 of file gCycle.cpp.

References gCycleMovement::AccelerationDiscontinuity(), gJoystick::Act(), gCycleMovement::AddDestination(), gCycleMovement::Alive(), gCycleMovement::braking, joystick_, nSERVER, gCycleMovement::RequestSync(), s_brake, s_brakeToggle, se_mainGameTimer, eGameObject::se_turnLeft, eGameObject::se_turnRight, sn_GetNetState(), eTimer::speed, eTimer::Time(), and gCycleMovement::Turn().

Referenced by ReceiveControl().

                                          {
    // delegate to joystick
    if ( joystick_ && joystick_->Act( Act, x ) )
    {
        return true;
    }

    // don't accept premature input
    if (se_mainGameTimer && ( se_mainGameTimer->speed <= 0 || se_mainGameTimer->Time() < -1 ) )
        return false;

    if (!Alive() && sn_GetNetState()==nSERVER)
        RequestSync(false);

    if(se_turnLeft==*Act && x>.5){
        //SendControl(lastTime,&se_turnLeft,1);
        Turn(-1);
        return true;
    }
    else if(se_turnRight==*Act && x>.5){
        //SendControl(lastTime,&se_turnRight,1);
        Turn(1);
        return true;
    }
    else if(s_brake==*Act){
        //SendControl(lastTime,&brake,x);
        unsigned short newBraking=(x>0);
        if ( braking != newBraking )
        {
            AccelerationDiscontinuity();
            braking = newBraking;
            AddDestination();
        }
        return true;
    }
    else if(s_brakeToggle==*Act){
        if ( x > 0 )
        {
            AccelerationDiscontinuity();
            braking = !braking;
            AddDestination();
        }
        return true;
    }
    return false;

Here is the call graph for this function:

Here is the caller graph for this function:

bool gCycle::DoTurn

(

int

dir

)

[virtual]

turns the cycle in the given direction

Parameters:

dir

+1 for right turns, -1 for left turns

Returns:

true of the turn could be executed right now, false if it was queued

Reimplemented from gCycleMovement.

Definition at line 3621 of file gCycle.cpp.

References gCycleMovement::AddDestination(), gCycleMovement::Alive(), eNetGameObject::clientside_action(), con, CYCLE_TURN, gCycleMovement::dirDrive, gCycleMovement::DoTurn(), DropWall(), eCoord, EPS, eGameObject::FindCurrentFace(), eSoundMixer::GetMixer(), gCycleMovement::lastDirDrive, nCLIENT, nSERVER, nNetObject::Owner(), eNetGameObject::Player(), eGameObject::pos, eGameObject::Position(), eSoundMixer::PushButton(), REAL, gCycleMovement::RequestSync(), sg_ArchiveCoord(), sg_gnuplotDebug, skewDot, sn_GetNetState(), sn_myNetID, tSysTimeFloat(), and gCycleMovement::turns.

{
#ifdef DELAYEDTURN_DEBUG
    REAL delay = tSysTimeFloat() - sg_turnReceivedTime;
    if ( delay > EPS && sn_GetNetState() == nSERVER && Owner() != 0 )
    {
        con << "Delayed turn execution! " << turns << "\n";
    }
#endif

#ifdef GNUPLOT_DEBUG
    if ( sg_gnuplotDebug && Player() )
    {
        std::ofstream f( Player()->GetUserName() + "_turn", std::ios::app );
        f << pos.x << " " << pos.y << "\n";
    }
#endif

    if (d >  1) d =  1;
    if (d < -1) d = -1;

    if (Alive()){
        eSoundMixer* mixer = eSoundMixer::GetMixer();
        mixer->PushButton(CYCLE_TURN, Position());

        clientside_action();

        if ( gCycleMovement::DoTurn( d ) )
        {
            sg_ArchiveCoord( pos, 1 );

            skewDot+=4*d;

            if (sn_GetNetState() == nCLIENT && Owner() == ::sn_myNetID)
                AddDestination();

            if (sn_GetNetState()!=nCLIENT)
            {
                RequestSync();
            }

            // hack: while dropping the wall, turn around dirDrive.
            // this makes FindCurrentFace work better.
            {
                FindCurrentFace();
                REAL factor = -16;
                eCoord dirDriveFake = dirDrive * factor;
                eCoord lastDirDriveBack = lastDirDrive;
                lastDirDrive = lastDirDrive * factor;
                gFakeDirDriveSetter fakeSetter( dirDriveFake );
                DropWall();
                lastDirDrive = lastDirDriveBack;
            }

            return true;
        }
    }

    return false;

Here is the call graph for this function:

void gCycle::DropWall

(

bool

buildNew = true

)

Drops the current wall and builds a new one.

Definition at line 3682 of file gCycle.cpp.

References c, eGameObject::CurrentFace(), gCycleMovement::dirDrive, gCycleMovement::distance, dropWallRequested_, eCoord, eGameObject::FindCurrentFace(), gNetPlayerWall, eDual::IsInGrid(), eGameObject::lastTime, NULL, eGameObject::pos, sg_cycleWallTime, sg_fakeDirDrive, and spawnTime_.

Referenced by DoTurn(), PassEdge(), ReadSync(), and TimestepCore().

{
    // keep this cycle alive
    tJUST_CONTROLLED_PTR< gCycle > keep( this->GetRefcount()>0 ? this : 0 );

    // drop last net wall if it is outdated
    if ( lastWall && lastNetWall && lastWall->Time(.5) > lastNetWall->Time(0) )
        lastNetWall = 0;

    // update and drop current wall
    if(currentWall)
    {
        lastWall=currentWall;
        currentWall->Update(lastTime,pos);
        currentWall->CopyIntoGrid( grid );
        currentWall=NULL;
    }

    if ( buildNew && lastTime >= spawnTime_ + sg_cycleWallTime )
        currentWall=new gNetPlayerWall(this,pos,dirDrive,lastTime,distance);

    // grid datastructures change on inserting a wall, better recheck
    // all game objects. Temporarily override this cycle's driving direction.
    eCoord dirDriveBack = dirDrive;
    if ( sg_fakeDirDrive )
        dirDrive = *sg_fakeDirDrive;

    if ( grid )
    {
        for(int i=grid->GameObjects().Len()-1;i>=0;i--)
        {
            eGameObject * c = grid->GameObjects()(i);
            if (c->CurrentFace() && !c->CurrentFace()->IsInGrid() )
                c->FindCurrentFace();
        }
    }
    dirDrive = dirDriveBack;

    // reset flag
    dropWallRequested_ = false;

Here is the call graph for this function:

Here is the caller graph for this function:

void gCycle::Kill

(

)

[virtual]

destroys the gameobject (in the game)

Reimplemented from eGameObject.

Definition at line 3724 of file gCycle.cpp.

References gCycleMovement::Alive(), color_, Die(), gCycleMovement::distance, eGameObject::GOID(), eGameObject::lastTime, nCLIENT, NULL, eGameObject::pos, gCycleMovement::RequestSync(), sn_GetNetState(), and tNEW.

Referenced by ActionOnQuit(), gGame::Analysis(), KillAt(), gDeathZoneHack::OnEnter(), and sg_TopologyPoliceKill().

                 {
    // keep this cycle alive
    tJUST_CONTROLLED_PTR< gCycle > keep( this->GetRefcount()>0 ? this : 0 );

    if (sn_GetNetState()!=nCLIENT){
        RequestSync(true);
        if (Alive() && grid && GOID() >= 0 ){
            Die( lastTime );
            tNEW(gExplosion)(grid, pos,lastTime, color_, this );
            //   eEdge::SeethroughHasChanged();

            if ( currentWall )
            {
                // z-man: updating the wall so it reflects exactly the position of death looks like
                // a good idea, but unfortunately, the collision position reported from above
                // is inaccurate. It's better not to use it at all, or the cycle's wall will stick out
                // a bit on the other side of the wall it crashed into.

                // but if prediction was active, do it anyway
                if ( currentWall->Pos(1) > distance || currentWall->Time(1) > lastTime )
                    currentWall->Update( lastTime, pos );

                // copy the wall into the grid, but not directly; the grid datastructures are probably currently traversed. Kill() is called from eGameObject::Move().
                currentWall->CopyIntoGrid( 0 );

                currentWall = NULL;
            }
        }
    }
    // z-man: another stupid idea. Why would we need a destination when we're dead?
    //    else if (Owner() == ::sn_myNetID)
    //        AddDestination();
    /*
      else if (owner!=::sn_myNetID)
      speed=-.01;
    */

Here is the call graph for this function:

Here is the caller graph for this function:

const eTempEdge * gCycle::Edge

(

)

Definition at line 1889 of file gCycle.cpp.

References eTempEdge::Edge(), and NULL.

                             {
    if (currentWall)
        return currentWall->Edge();
    else
        return NULL;
}

Here is the call graph for this function:

const gPlayerWall * gCycle::CurrentWall

(

)

Definition at line 1896 of file gCycle.cpp.

References NULL.

                                      {
    if (currentWall)
        return currentWall->Wall();
    else
        return NULL;
}

void gCycle::Render

(

const eCamera *

cam

)

[virtual]

draws object to the screen using OpenGL

Reimplemented from eGameObject.

Definition at line 4141 of file gCycle.cpp.

References gCycleMovement::Alive(), gRealColor::b, BeginLineLoop(), BeginQuads(), BeginTriangles(), body, bodyTex, c, eCamera::CameraZ(), eCamera::Center(), color_, cos(), customModel, customTexture, cycle_shad, cycleprograminited, eGameObject::dir, eCoord, front, gRealColor::g, gCycleMovement::GetTurnDelay(), glMatrixMode, headlights, IdentityMatrix(), eNetGameObject::Lag(), eGameObject::lastTime, M_PI, ModelMatrix(), mp, nSERVER, nSTANDALONE, eGameObject::pos, PredictPosition(), gRealColor::r, REAL, rear, rModel::Render(), RenderEnd(), RenderName(), rFLOOR_GRID, rotationFrontWheel, rotationRearWheel, se_GameTime(), rITexture::Select(), sg_axesIndicator, sg_blinkFrequency, sg_laggometerScale, sg_laggometerThreshold, sin(), gArena::SizeMultiplier(), skew, sn_GetNetState(), spawnTime_, sqrt(), sr_alphaBlend, sr_DepthOffset(), sr_floorDetail, sr_laggometer, sr_predictObjects, st_Breakpoint(), rTextureGroups::TEX_FLOOR, TexMatrix(), rTextureGroups::TextureMode, tSysTimeFloat(), gCycleMovement::verletSpeed_, void(), Vulnerable(), wheelTex, x, and eGameObject::z.

                                     {
    // are we blinking from invulnerability?
    bool blinking = false;
    if ( lastTime > spawnTime_ && !Vulnerable() )
    {
        double time = tSysTimeFloat();
        double wrap = time - floor(time);
        int pulse = int ( 2 * wrap * sg_blinkFrequency );
        blinking = pulse & 1;
    }

#ifdef USE_HEADLIGHT
#ifdef LINUX
    typedef void (*glProgramStringARB_Func)(GLenum, GLenum, GLsizei, const void*);
    glProgramStringARB_Func glProgramStringARB_ptr = 0;

    typedef void (*glProgramLocalParameter4fARB_Func)(GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
    glProgramLocalParameter4fARB_Func glProgramLocalParameter4fARB_ptr = 0;

    glProgramStringARB_ptr = (glProgramStringARB_Func) SDL_GL_GetProcAddress("glProgramStringARB");
    glProgramLocalParameter4fARB_ptr = (glProgramLocalParameter4fARB_Func) SDL_GL_GetProcAddress("glProgramLocalParameter4fARB");
#endif
#endif    
    if (!finite(z) || !finite(pos.x) ||!finite(pos.y)||!finite(dir.x)||!finite(dir.y)
            || !finite(skew))
        st_Breakpoint();
    if (Alive()){
        //con << "Drawing cycle at " << pos << '\n';

#ifdef DEBUG
        /*     {
                   gDestination *l = destinationList;
                   glDisable(GL_LIGHTING);
                   glColor3f(1,1,1);
                   while(l){
                   if (l == currentDestination)
                   glColor3f(0,1,0);

                   glBegin(GL_LINES);
                   glVertex3f(l->position.x, l->position.y, 0);
                   glVertex3f(l->position.x, l->position.y, 100);
                   glEnd();

                   if (l == currentDestination)
                   glColor3f(0,1,1);

                   l=l->next;
                   }
                   } */
#endif

        GLfloat color[4]={1,1,1,1};
        static GLfloat lposa[4] = { 320, 240, 200,0};
        static GLfloat lposb[4] = { -240, -100, 200,0};
        static GLfloat lighta[4] = { 1, .7, .7, 1 };
        static GLfloat lightb[4] = { .7, .7, 1, 1 };

        glMaterialfv(GL_FRONT_AND_BACK,GL_SPECULAR,color);
        glMaterialfv(GL_FRONT_AND_BACK,GL_DIFFUSE,color);

        glLightfv(GL_LIGHT0, GL_DIFFUSE, lighta);
        glLightfv(GL_LIGHT0, GL_SPECULAR, lighta);
        glLightfv(GL_LIGHT0, GL_POSITION, lposa);
        glLightfv(GL_LIGHT1, GL_DIFFUSE, lightb);
        glLightfv(GL_LIGHT1, GL_SPECULAR, lightb);
        glLightfv(GL_LIGHT1, GL_POSITION, lposb);


        ModelMatrix();
        glPushMatrix();
        eCoord p = PredictPosition();
        glTranslatef(p.x,p.y,0);
        glScalef(.5f,.5f,.5f);


        eCoord ske(1,skew);
        ske=ske*(1/sqrt(ske.NormSquared()));

        GLfloat m[4][4]={{dir.x,dir.y,0,0},
                         {-dir.y,dir.x,0,0},
                         {0,0,1,0},
                         {0,0,0,1}};
        glMultMatrixf(&m[0][0]);

        glPushMatrix();
        //glTranslatef(-1.84,0,0);
        if (!mp)
            glTranslatef(-1.5,0,0);

        glPushMatrix();

        GLfloat sk[4][4]={{1,0,0,0},
                          {0,ske.x,ske.y,0},
                          {0,-ske.y,ske.x,0},
                          {0,0,0,1}};

        glMultMatrixf(&sk[0][0]);


        glEnable(GL_LIGHT0);
        glEnable(GL_LIGHT1);
        glEnable(GL_LIGHTING);



        TexMatrix();
        IdentityMatrix();

        if (mp){

            ModelMatrix();
            if ( !blinking )
            {
                glPushMatrix();
                customTexture->Select();
                glColor3f(1,1,1);
                customModel->Render();
                glPopMatrix();
            }

            glPopMatrix();
            glTranslatef(-1.5,0,0);
        }
        else{
            glEnable(GL_TEXTURE_2D);

            ModelMatrix();

            if ( !blinking )
            {
                bodyTex->Select();
                body->Render();

                wheelTex->Select();
                
                glPushMatrix();
                glTranslatef(0,0,.73);
                
                GLfloat mr[4][4]={{rotationRearWheel.x,0,rotationRearWheel.y,0},
                                  {0,1,0,0},
                                  {-rotationRearWheel.y,0,rotationRearWheel.x,0},
                                  {0,0,0,1}};
                
                
                glMultMatrixf(&mr[0][0]);
                
                rear->Render();
                glPopMatrix();

                glPushMatrix();
                glTranslatef(1.84,0,.43);

                GLfloat mf[4][4]={{rotationFrontWheel.x,0,rotationFrontWheel.y,0},
                                  {0,1,0,0},
                                  {-rotationFrontWheel.y,0,rotationFrontWheel.x,0},
                                  {0,0,0,1}};
                
                glMultMatrixf(&mf[0][0]);

                front->Render();
                glPopMatrix();
            }
            
            glPopMatrix();
        }


        //     TexMatrix();
        //     IdentityMatrix();
        ModelMatrix();

        /*
          glDisable(GL_TEXTURE_GEN_S);
          glDisable(GL_TEXTURE_GEN_T);
          glDisable(GL_TEXTURE_GEN_Q);
          glDisable(GL_TEXTURE_GEN_R);
        */

        glDisable(GL_LIGHT0);
        glDisable(GL_LIGHT1);
        glDisable(GL_LIGHTING);

        //glDisable(GL_TEXTURE);
        glDisable(GL_TEXTURE_2D);
        glColor3f(1,1,1);

        {
            bool renderPyramid = false;
            gRealColor colorPyramid;
            REAL alpha = 1;
            const REAL timeout = .5f;

            if ( bool(player) )
            {
                if ( player->IsChatting() )
                {
                    renderPyramid = true;
                    colorPyramid.b = 0.0f;
                }
                else if ( !player->IsActive() )
                {
                    renderPyramid = true;
                    colorPyramid.b = 0.0f;
                    colorPyramid.g = 0.0f;
                }
                else if ( cam && cam->Center() == this && se_GameTime() < timeout && player->CurrentTeam() && player->CurrentTeam()->NumPlayers() > 1 )
                {
                    renderPyramid = true;
                    alpha = timeout - se_GameTime();
                }
            }

            if ( renderPyramid )
            {
                GLfloat s=sin(lastTime);
                GLfloat c=cos(lastTime);

                GLfloat m[4][4]={{c,s,0,0},
                                 {-s,c,0,0},
                                 {0,0,1,0},
                                 {0,0,1,1}};

                glPushMatrix();

                glMultMatrixf(&m[0][0]);
                glScalef(.5,.5,.5);


                BeginTriangles();

                glColor4f( colorPyramid.r,colorPyramid.g,colorPyramid.b, alpha );
                glVertex3f(0,0,3);
                glVertex3f(0,1,4.5);
                glVertex3f(0,-1,4.5);

                glColor4f( colorPyramid.r * .7f,colorPyramid.g * .7f,colorPyramid.b * .7f, alpha );
                glVertex3f(0,0,3);
                glVertex3f(1,0,4.5);
                glVertex3f(-1,0,4.5);

                RenderEnd();

                glPopMatrix();
            }
        }

#ifdef USE_HEADLIGHT
        // Headlight contributed by Jonathan
        if(headlights) {
            if(!cycleprograminited) { // set to false on every sr_InitDisplay, without it I lost my program when I switched to windowed
                const char *program =
                    "!!ARBfp1.0\
                    \
                    PARAM normal = program.local[0];\
                    ATTRIB texcoord = fragment.texcoord;\
                    TEMP final, diffuse, distance;\
                    \
                    DP3 distance, texcoord, texcoord;\
                    RSQ diffuse, distance.w;\
                    RCP distance, distance.w;\
                    MUL diffuse, texcoord, diffuse;\
                    DP3 diffuse, diffuse, normal;\
                    MUL final, diffuse, distance;\
                    MOV result.color.w, fragment.color;\
                    MUL result.color.xyz, fragment.color, final;\
                    \
                    END";
#ifdef LINUX
                glProgramStringARB_ptr(GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB, strlen(program), program);
#else
                glProgramStringARB(GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB, strlen(program), program);
#endif
                cycleprograminited = true;
            }
#ifdef LINUX
            glProgramLocalParameter4fARB_ptr(GL_FRAGMENT_PROGRAM_ARB, 0, 0, 0, verletSpeed_ * verletSpeed_, 0);
#else                   
            glProgramLocalParameter4fARB(GL_FRAGMENT_PROGRAM_ARB, 0, 0, 0, verletSpeed_ * verletSpeed_, 0);
#endif
            glPushAttrib(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // blend func and depth mask. Efficient or not, glPushAttrib/glPopAttrib is a quick way to manage state.
            glEnable(GL_FRAGMENT_PROGRAM_ARB); // doesn't check if it exists...

            const unsigned sensors = 32; // actually one more
            const double mul = 0.25 * M_PI / sensors;
            const double add = -0.125 * M_PI;

            double size = gArena::SizeMultiplier() * 500 * M_SQRT2; // is M_SQRT2 in your math.h?
            GLfloat array[sensors+2][5];

            array[0][0] = 0;
            array[0][1] = 0;
            array[0][2] = p.x;
            array[0][3] = p.y;
            array[0][4] = 0.125;

            for(unsigned i=0; i<=sensors; i++) {
                gSensor sensor(this, p, dir.Turn(cos(i * mul + add), sin(i * mul + add)));
                sensor.detect(size);
                array[i][5] = sensor.before_hit.x - p.x;
                array[i][6] = sensor.before_hit.y - p.y;
                array[i][7] = sensor.before_hit.x;
                array[i][8] = sensor.before_hit.y;
                array[i][9] = 0.125;
            }

            glPushMatrix();
            glLoadIdentity();

            glMatrixMode(GL_TEXTURE);
            glPushMatrix();
            glTranslatef(0, 0, 1);

            glBlendFunc(GL_ONE, GL_ONE);
            glDepthMask(GL_FALSE);

            glColor3fv(reinterpret_cast<GLfloat *>(&color_)); // 8-)
            glEnableClientState(GL_VERTEX_ARRAY);
            glEnableClientState(GL_TEXTURE_COORD_ARRAY);

            glInterleavedArrays(GL_T2F_V3F, 0, array);
            glDrawArrays(GL_TRIANGLE_FAN, 0, sensors+2);

            glDisableClientState(GL_VERTEX_ARRAY);
            glDisableClientState(GL_TEXTURE_COORD_ARRAY);

            glDisable(GL_FRAGMENT_PROGRAM_ARB);

            glPopMatrix();
            glMatrixMode(GL_MODELVIEW);

            glPopMatrix();
            glPopAttrib();
        }
#endif // USE_HEADLIGHT
        // Name
        RenderName( cam );


        // shadow:

        sr_DepthOffset(true);


        REAL h=0;//se_cameraZ*.005+.03;

        glEnable(GL_CULL_FACE);

        if(!blinking && sr_floorDetail>rFLOOR_GRID && rTextureGroups::TextureMode[rTextureGroups::TEX_FLOOR]>0 && sr_alphaBlend){
            glColor3f(0,0,0);
            cycle_shad.Select();
            BeginQuads();
            glTexCoord2f(0,1);
            glVertex3f(-.6,.4,h);

            glTexCoord2f(1,1);
            glVertex3f(-.6,-.4,h);

            glTexCoord2f(1,0);
            glVertex3f(2.1,-.4,h);

            glTexCoord2f(0,0);
            glVertex3f(2.1,.4,h);

            RenderEnd();
        }

        glDisable(GL_CULL_FACE);

        // sr_laggometer;


        REAL f=verletSpeed_;

        REAL l=Lag();

        glPopMatrix();

        h=cam->CameraZ()*.005+.03;

#ifdef ENABLE_OLD_LAG_O_METER
        if(sg_laggometerUseOld) {
            if (sn_GetNetState() != nSTANDALONE && sr_laggometer && f*l>.5) {
                //&& owner!=::sn_myNetID){
                glPushMatrix();

                glColor3f(1,1,1);
                //glDisable(GL_TEXTURE);
                glDisable(GL_TEXTURE_2D);

                glTranslatef(0,0,h);
                //glScalef(.5*f,.5*f,.5*f);

                // compensate for the .5 scaling further up
                f *= 2 * sg_laggometerScale;

                glScalef(f,f,f);

                // move the sr_laggometer ahead a bit
                if (!sr_predictObjects || sn_GetNetState()==nSERVER)
                    glTranslatef(l,0,0);


                BeginLineLoop();


                glVertex2f(-l,-l);
                glVertex2f(0,0);
                glVertex2f(-l,l);
                REAL delay = GetTurnDelay();
                if(l> 2*delay){
                    glVertex2f(-2*l+delay,delay);
                    glVertex2f(-2*l+2*delay,0);
                    glVertex2f(-2*l+delay,-delay);
                }
                else if (l>delay){
                    glVertex2f(-2*l+delay,delay);
                    glVertex2f(-l,2*delay-l);
                    glVertex2f(-l,-(2*delay-l));
                    glVertex2f(-2*l+delay,-delay);
                }

                RenderEnd();
                glPopMatrix();
            }
        } else
#endif
        {
            glPushMatrix();

            //glDisable(GL_TEXTURE);
            glDisable(GL_TEXTURE_2D);

            glTranslatef(0,0,h);
            //glScalef(.5*f,.5*f,.5*f);

            // compensate for the .5 scaling further up
            f *= 2 * sg_laggometerScale;

            glScalef(f,f,f);

            // move the sr_laggometer back a bit
            if (sr_predictObjects || sn_GetNetState()==nSERVER) {
                glTranslatef(-l,0,0);
            }

            if (f*l>sg_laggometerThreshold) {
                if (sr_laggometer) {
                    gLaggometer::LagOMeterRenderer(this).render(l);
                }
            } else if(sg_axesIndicator) {
                gLaggometer::AxesIndicator(this).render();
            }

            glPopMatrix();
        }
        sr_DepthOffset(false);

        glPopMatrix();

    }

Here is the call graph for this function:

void gCycle::Render2D

(

tCoord

scale

)

const [virtual]

Reimplemented from eGameObject.

Definition at line 4603 of file gCycle.cpp.

References gCycleMovement::Alive(), gRealColor::b, color_, eGameObject::DeathTime(), eGameObject::dir, Direction(), eCoord, gRealColor::g, glBegin, glEnd, eGameObject::pos, PredictPosition(), gRealColor::r, se_GameTime(), tCoord::x, and tCoord::y.

                                        {
    double alpha = 1;
    if(!Alive()) {
        alpha -= 2 * (se_GameTime() - DeathTime());
        if(alpha <= 0) return;
    }
    glColor4f(color_.r, color_.g, color_.b, alpha);
    eCoord pos = PredictPosition(), dir = Direction();
    tCoord p = pos;
    glPushMatrix();
    GLfloat m[16] = {
                        scale.x * dir.x, scale.y * dir.y, 0, 0,
                        -scale.x * dir.y, scale.y * dir.x, 0, 0,
                        0, 0, 1, 0,
                        pos.x, pos.y, 0, 1
                    };
    glMultMatrixf(m);
    glBegin(GL_TRIANGLES);
    glVertex2f(.5, 0);
    glVertex2f(-.5, .5);
    glVertex2f(-.5, -.5);
    glEnd();
    glPopMatrix();

Here is the call graph for this function:

void gCycle::RenderName

(

const eCamera *

cam

)

[virtual]

Definition at line 4641 of file gCycle.cpp.

References DisplayText(), ModelMatrix(), eCamera::Player(), ProjMatrix(), rCHEIGHT_NORMAL, REAL, cCockpit::Render(), eCamera::RenderingMain(), cCockpit::SetCycle(), sr_fontCycleLabel, timeCameIntoView, tSysTimeFloat(), cCockpit::VIEWPORT_CYCLE, x, and eGameObject::z.

Referenced by Render().

                                            {
    if ( !this->Player() )
        return;

    float modelviewMatrix[16], projectionMatrix[16];
    float x, y, z, w;
    float xp, yp, wp;
    float alpha = 0.75;

    if (fadeOutNameAfter == 0) return; /* XXX put that in ::Render() */
    if ( !cam->RenderingMain() ) return; // no name in mirrored image
    if ( !showOwnName && cam->Player() == this->player ) return; // don't show own name

    glPushMatrix();
    /* position sign above center of cycle */
    glTranslatef(0.8, 0, 2.0);
    glGetFloatv(GL_MODELVIEW_MATRIX, modelviewMatrix);
    glGetFloatv(GL_PROJECTION_MATRIX, projectionMatrix);
    glPopMatrix();

    /* get coordinates of sign */
    x = modelviewMatrix[12];
    y = modelviewMatrix[13];
    z = modelviewMatrix[14];
    w = modelviewMatrix[15];

    /* multiply by projection matrix */
    xp = projectionMatrix[0] * x + projectionMatrix[4] * y +
         projectionMatrix[8] * z + projectionMatrix[12] * w;
    yp = projectionMatrix[1] * x + projectionMatrix[5] * y +
         projectionMatrix[9] * z + projectionMatrix[13] * w;
    wp = projectionMatrix[3] * x + projectionMatrix[7] * y +
         projectionMatrix[11] * z + projectionMatrix[15] * w;

    if (wp <= 0) {
        /* behind camera */
        timeCameIntoView = 0;
        return;
    }

    xp /= wp;
    yp /= wp;
    yp += rCHEIGHT_NORMAL;// * 2.0;

    if (xp <= -1 || xp >= 1 || yp <= -1 || yp >= 1) {
        /* out of screen */
        timeCameIntoView = 0;
        return;
    }

    /* it is visible */

    bool doname = true;
    if (fadeOutNameAfter > 0) {
        REAL now = tSysTimeFloat();
        if (timeCameIntoView == 0)
            timeCameIntoView = now;

        if (now - timeCameIntoView > fadeOutNameAfter) {
            doname = false;
        } else if (now - timeCameIntoView > fadeOutNameAfter - 1) {
            /* start to fade out */
            alpha = 0.75 - (now - timeCameIntoView -
                            (fadeOutNameAfter - 1)) * 0.75;
        }
    }

    ModelMatrix();
    glPushMatrix();
    glLoadIdentity();

    ProjMatrix();
    glPushMatrix();
    glLoadIdentity();

    glTranslatef(xp, yp, 0.);
    if(doname) {
        glColor4f(1, 1, 1, alpha);
        tColoredString name;
        if(sg_displayColoredNameOverCycles)
            name << *this->player;
        else
            name << this->player->GetName();
        DisplayText(0, 0, rCHEIGHT_NORMAL, name, sr_fontCycleLabel, 0, 0);
    }
    static cCockpit cycleCockpit(cCockpit::VIEWPORT_CYCLE);
    cycleCockpit.SetCycle(*this);
    cycleCockpit.Render();

    ProjMatrix();
    glPopMatrix();

    ModelMatrix();
    glPopMatrix();

Here is the call graph for this function:

Here is the caller graph for this function:

bool gCycle::RenderCockpitFixedBefore

(

bool

primary = true

)

[virtual]

Reimplemented from eGameObject.

Definition at line 4738 of file gCycle.cpp.

                                         {
    /*
      if (alive)
      return true;
      else{
      REAL rd=se_GameTime()-deathTime;
      if (rd<1)
         return true;
      else{
         REAL d=1.25-rd;
         d*=8;
         if (d<0) d=0;
         glColor3f(d,d/2,d/4);
         glDisable(GL_TEXTURE_2D);
         glDisable(GL_TEXTURE);
         glDisable(GL_DEPTH_TEST);
         glRectf(-1,-1,1,1);
         glColor4f(1,1,1,rd*(2-rd/2));
         DisplayText(0,0,.05,.15,"You have been deleted.");
         return false;
      }
      }
    */
    return true;

eCoord gCycle::CamPos

(

)

const [virtual]

Reimplemented from eGameObject.

Definition at line 4800 of file gCycle.cpp.

References eGameObject::dir, PredictPosition(), skew, and eGameObject::z.

Referenced by _wrap_GCycle_cam_pos().

{
    return PredictPosition() + dir.Turn(0 ,-skew*z);

    //    gSensor s(this,pos, PredictPosition() - pos );
    //    s.detect(1);

    //    return s.before_hit + dir.Turn(0 ,-skew*z);

    // return pos + dir.Turn(0 ,-skew*z);

Here is the call graph for this function:

Here is the caller graph for this function:

eCoord gCycle::PredictPosition

(

)

const [virtual]

Reimplemented from eGameObject.

Definition at line 4793 of file gCycle.cpp.

References predictPosition_.

Referenced by _wrap_GCycle_predict_position(), CamPos(), Render(), Render2D(), and Timestep().

                                     {
    return predictPosition_;

    //    eCoord p = pos + dir * (speed * se_PredictTime());
    //    return p + correctPosSmooth;

Here is the caller graph for this function:

eCoord gCycle::CamTop

(

)

const [virtual]

Reimplemented from eGameObject.

Definition at line 4812 of file gCycle.cpp.

References eGameObject::dir, and skew.

Referenced by _wrap_GCycle_cam_top().

{
    return dir.Turn(0,-skew);

Here is the caller graph for this function:

eCoord gCycle::CamDir

(

)

const [virtual]

Reimplemented from eGameObject.

Definition at line 4817 of file gCycle.cpp.

References gJoystick::cameraDirection_, eGameObject::dir, joystick_, and tCoord::NormSquared().

Referenced by gCamera::CenterCycleDir().

{
    if ( joystick_ && joystick_->cameraDirection_.NormSquared() > .25 )
    {
        return joystick_->cameraDirection_;
    }
    else
    {
        return dir;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

eCoord gCycle::Direction

(

void

)

const [virtual]

returns the current driving direction

Returns:

the currend driving direction

Reimplemented from gCycleMovement.

Definition at line 4829 of file gCycle.cpp.

References gJoystick::cameraDirection_, gCycleMovement::dirDrive, gCycleMovement::Direction(), joystick_, and tCoord::NormSquared().

Referenced by cCockpit::cb_TimeToImpactFront(), cWidget::Map::DrawMap(), gAIPlayer::EmergencySurvive(), ReadSync(), Render2D(), gAIPlayer::RightBeforeDeath(), gAIPlayer::Think(), gAIPlayer::ThinkCloseCombat(), gAIPlayer::ThinkPath(), and WriteSync().

{
    return gCycleMovement::Direction();

    if ( joystick_ && joystick_->cameraDirection_.NormSquared() > .25 )
    {
        return joystick_->cameraDirection_;
    }
    else
    {
        return dirDrive;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

void gCycle::RightBeforeDeath

(

int

numTries

)

[virtual]

called when the cycle is very close to a wall and about to crash

Parameters:

numTries

number of times this function will be called approximately before the cycle will be killed

Reimplemented from gCycleMovement.

Definition at line 5994 of file gCycle.cpp.

References correctPosSmooth, nextSync, nextSyncOwner, nNetObject::Owner(), sg_avoidBadOldClientSync, sg_GetSyncIntervalSelf(), sg_NoLocalTunnelOnSync, sg_syncIntervalEnemy, nVersionFeature::Supported(), and tSysTimeFloat().

{
    if ( player )
    {
        player->RightBeforeDeath( numTries );
    }

    // delay syncs for old clients; they would tunnel locally
    if ( sg_avoidBadOldClientSync && !sg_NoLocalTunnelOnSync.Supported( Owner() ) )
    {
        nextSync=tSysTimeFloat()+sg_syncIntervalEnemy;
        nextSyncOwner=tSysTimeFloat()+sg_GetSyncIntervalSelf( this );
    }

    correctPosSmooth = correctPosSmooth * .5;

Here is the call graph for this function:

void gCycle::PrivateSettings

(

)

[static]

Definition at line 122 of file gCycle.cpp.

References c_per, c_pwl, explosionRadius, wallsLength, and wallsStayUpDelay.

Referenced by _wrap_GCycle_private_settings(), and main().

{
    static nSettingItem<REAL> c_wsud("CYCLE_WALLS_STAY_UP_DELAY",wallsStayUpDelay);
    static nSettingItem<REAL> c_wl("CYCLE_WALLS_LENGTH",wallsLength);
    static nSettingItem<REAL> c_er("CYCLE_EXPLOSION_RADIUS",explosionRadius);

    c_pwsud=&c_wsud;
    c_pwl  =&c_wl;
    c_per  =&c_er;
}

Here is the caller graph for this function:

bool gCycle::DoIsDestinationUsed

(

const gDestination *

dest

)

const [protected, virtual]

returns whether the given destination is in active use

Parameters:

dest

the destination to test

Returns:

true if the destination is still in active use

Reimplemented from gCycleMovement.

Definition at line 6022 of file gCycle.cpp.

References gCycleMovement::DoIsDestinationUsed(), and extrapolator_.

{
    return ( extrapolator_ && extrapolator_->IsDestinationUsed( dest ) ) || gCycleMovement::DoIsDestinationUsed( dest );

Here is the call graph for this function:

---

Friends And Related Function Documentation

friend class gPlayerWall [friend]

Definition at line 151 of file gCycle.h.

friend class gNetPlayerWall [friend]

Definition at line 152 of file gCycle.h.

Referenced by DropWall(), and SyncEnemy().

friend class gDestination [friend]

Definition at line 153 of file gCycle.h.

friend class gCycleWallRenderer [friend]

Definition at line 154 of file gCycle.h.

Referenced by MyInitAfterCreation().

friend class gCycleChatBot [friend]

Definition at line 161 of file gCycle.h.

---

Member Data Documentation

REAL gCycle::spawnTime_ [private]

time the cycle spawned at

Definition at line 156 of file gCycle.h.

Referenced by DropWall(), gCycle(), MyInitAfterCreation(), ReadSync(), Render(), SyncEnemy(), SyncFromExtrapolator(), TimestepCore(), and Vulnerable().

REAL gCycle::lastTimeAnim [private]

last time animation was simulated at

Definition at line 157 of file gCycle.h.

Referenced by gCycle(), MyInitAfterCreation(), SyncEnemy(), and TimestepCore().

REAL gCycle::timeCameIntoView [private]

Definition at line 159 of file gCycle.h.

Referenced by MyInitAfterCreation(), and RenderName().

std::auto_ptr< gCycleChatBot > gCycle::chatBot_ [private]

Definition at line 162 of file gCycle.h.

Referenced by gCycleChatBot::Get(), and Timestep().

bool gCycle::dropWallRequested_ [private]

flag indicating that someone requested a wall drop

Definition at line 164 of file gCycle.h.

Referenced by DropWall(), MyInitAfterCreation(), OnDropTempWall(), PassEdge(), and Timestep().

eCoord gCycle::lastGoodPosition_

Definition at line 166 of file gCycle.h.

Referenced by gCycleExtrapolator::CopyFrom(), MyInitAfterCreation(), and ReadSync().

REAL gCycle::skew

Definition at line 168 of file gCycle.h.

Referenced by CamPos(), CamTop(), MyInitAfterCreation(), ReadSync(), Render(), and TimestepCore().

REAL gCycle::skewDot

Definition at line 168 of file gCycle.h.

Referenced by DoTurn(), MyInitAfterCreation(), ReadSync(), SyncEnemy(), and TimestepCore().

bool gCycle::mp

Definition at line 170 of file gCycle.h.

Referenced by MyInitAfterCreation(), Render(), and ~gCycle().

rModel* gCycle::body

Definition at line 172 of file gCycle.h.

Referenced by MyInitAfterCreation(), Render(), and ~gCycle().

rModel * gCycle::front

Definition at line 172 of file gCycle.h.

Referenced by MyInitAfterCreation(), Render(), and ~gCycle().

rModel * gCycle::rear

Definition at line 172 of file gCycle.h.

Referenced by MyInitAfterCreation(), Render(), and ~gCycle().

rModel * gCycle::customModel

Definition at line 172 of file gCycle.h.

Referenced by gCycleVisuals::gCycleVisuals(), gCycleVisuals::LoadModel(), MyInitAfterCreation(), Render(), ~gCycle(), and gCycleVisuals::~gCycleVisuals().

gTextureCycle* gCycle::wheelTex

Definition at line 175 of file gCycle.h.

Referenced by MyInitAfterCreation(), Render(), and ~gCycle().

gTextureCycle * gCycle::bodyTex

Definition at line 175 of file gCycle.h.

Referenced by MyInitAfterCreation(), Render(), and ~gCycle().

gTextureCycle* gCycle::customTexture

Definition at line 176 of file gCycle.h.

Referenced by gCycleVisuals::gCycleVisuals(), gCycleVisuals::LoadTextures(), MyInitAfterCreation(), Render(), ~gCycle(), and gCycleVisuals::~gCycleVisuals().

eCoord gCycle::rotationFrontWheel

Definition at line 178 of file gCycle.h.

Referenced by MyInitAfterCreation(), Render(), and TimestepCore().

eCoord gCycle::rotationRearWheel

Definition at line 178 of file gCycle.h.

Referenced by MyInitAfterCreation(), Render(), and TimestepCore().

REAL gCycle::heightFrontWheel

Definition at line 179 of file gCycle.h.

REAL gCycle::heightRearWheel

Definition at line 179 of file gCycle.h.

uActionPlayer gCycle::s_brake [static]

Definition at line 183 of file gCycle.h.

Referenced by Act(), and gCycleChatBot::Activate().

gCycleMemory gCycle::memory

Definition at line 184 of file gCycle.h.

Referenced by CheckLoop(), and CycleBlocksWayHelper().

gRealColor gCycle::color_

Definition at line 186 of file gCycle.h.

Referenced by cWidget::Map::DrawWalls(), gCycle(), Kill(), MyInitAfterCreation(), ReadSync(), Render(), Render2D(), TimestepCore(), and WriteCreate().

gRealColor gCycle::trailColor_

Definition at line 187 of file gCycle.h.

Referenced by gCycle(), and MyInitAfterCreation().

eCoord gCycle::correctPosSmooth

Definition at line 192 of file gCycle.h.

Referenced by CalculatePredictPosition(), Die(), MyInitAfterCreation(), ReadSync(), RightBeforeDeath(), SyncFromExtrapolator(), TimestepCore(), and TransferPositionCorrectionToDistanceCorrection().

eCoord gCycle::predictPosition_

the best guess of where the cycle is at at display time

Definition at line 193 of file gCycle.h.

Referenced by CalculatePredictPosition(), Die(), MyInitAfterCreation(), PredictPosition(), and ReadSync().

REAL gCycle::correctDistanceSmooth

Definition at line 196 of file gCycle.h.

Referenced by gDestination::CopyFrom(), gCycle(), MyInitAfterCreation(), ReadSync(), SyncEnemy(), SyncFromExtrapolator(), TimestepCore(), and TransferPositionCorrectionToDistanceCorrection().

gCycleWallsDisplayListManager gCycle::displayList_ [private]

display list manager

Definition at line 202 of file gCycle.h.

Referenced by gNetPlayerWall::CanHaveDisplayList(), and gNetPlayerWall::HasDisplayList().

SyncData gCycle::lastSyncMessage_ [private]

Definition at line 210 of file gCycle.h.

Referenced by ReadSync(), ResetExtrapolator(), and SyncEnemy().

tJUST_CONTROLLED_PTR<gCycleExtrapolator> gCycle::extrapolator_ [private]

Definition at line 211 of file gCycle.h.

Referenced by DoIsDestinationUsed(), Extrapolate(), IsMe(), OnNotifyNewDestination(), PassEdge(), ReadSync(), ResetExtrapolator(), SyncFromExtrapolator(), and Timestep().

bool gCycle::resimulate_ [private]

Definition at line 212 of file gCycle.h.

Referenced by MyInitAfterCreation(), ReadSync(), ResetExtrapolator(), SyncEnemy(), SyncFromExtrapolator(), and Timestep().

nTimeRolling gCycle::nextSync [private]

Definition at line 223 of file gCycle.h.

Referenced by gCycle(), MyInitAfterCreation(), RequestSyncAll(), RightBeforeDeath(), and TimestepCore().

nTimeRolling gCycle::nextSyncOwner [private]

Definition at line 223 of file gCycle.h.

Referenced by gCycle(), MyInitAfterCreation(), RequestSyncOwner(), RightBeforeDeath(), and TimestepCore().

REAL gCycle::wallsStayUpDelay = 8.0f [static, private]

the time the cycle walls stay up ( negative values: they stay up forever )

Definition at line 338 of file gCycle.h.

Referenced by PrivateSettings(), and WallsStayUpDelay().

REAL gCycle::wallsLength = -1.0f [static, private]

the maximum total length of the walls

Definition at line 339 of file gCycle.h.

Referenced by MaxWallsLength(), PrivateSettings(), and WallsLength().

REAL gCycle::explosionRadius = 4.0f [static, private]

the radius of the holes blewn in by an explosion

Definition at line 340 of file gCycle.h.

Referenced by ExplosionRadius(), and PrivateSettings().

gJoystick* gCycle::joystick_ [private]

joystick control

Definition at line 341 of file gCycle.h.

Referenced by Act(), CamDir(), Direction(), MyInitAfterCreation(), OnRemoveFromGame(), and TimestepCore().

---

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

• src/tron/gCycle.h
• src/tron/gCycle.cpp

---