gBaseZoneHack Class Reference

base zone: belongs to a team, enemy players who manage to stay inside win the round (will be replaced More...

#include <gWinZone.h>

Inheritance diagram for gBaseZoneHack:

[legend]

Collaboration diagram for gBaseZoneHack:

[legend]

List of all members.

Public Member Functions
	gBaseZoneHack (eGrid *grid, const eCoord &pos)
	local constructor
	gBaseZoneHack (nMessage &m)
	network constructor
	~gBaseZoneHack ()
	destructor
Private Types
enum	State { State_Safe, State_Conquering, State_Conquered }
	possible states More...
typedef std::vector < tJUST_CONTROLLED_PTR< eTeam > >	TeamArray
Private Member Functions
virtual bool	Timestep (REAL currentTime)
	simulates behaviour up to currentTime
virtual void	OnEnter (gCycle *target, REAL time)
	reacts on objects inside the zone
virtual void	OnVanish ()
	called when the zone vanishes
virtual void	OnConquest ()
	called when the zone gets conquered
virtual void	CheckSurvivor ()
	checks for the only surviving zone
Static Private Member Functions
static void	CountZonesOfTeam (eGrid const *grid, eTeam *otherTeam, int &count, gBaseZoneHack *&farthest)
	counts the zones belonging to the given team.
Private Attributes
REAL	conquered_
	conquest status; zero if it is free, 1 if it has been completely conquered by the enemy
int	enemiesInside_
	count of enemies currently inside the zone
int	ownersInside_
	count of owners currently inside the zone
bool	onlySurvivor_
	flag set if this zone is the only survivor
TeamArray	enemies_
	list of teams that currently have a player in the zone
REAL	lastEnemyContact_
	last time an enemy player was in the zone
REAL	teamDistance_
	distance to the closest member of the owning team
bool	touchy_
	flag set when the zone is "touchy", which makes it get conquered on the slightest enemy touch
State	currentState_
	the current state
REAL	lastSync_
	time of the last sync request

---

Detailed Description

base zone: belongs to a team, enemy players who manage to stay inside win the round (will be replaced

Definition at line 146 of file gWinZone.h.

---

Member Typedef Documentation

typedef std::vector< tJUST_CONTROLLED_PTR< eTeam > > gBaseZoneHack::TeamArray [private]

Definition at line 169 of file gWinZone.h.

---

Member Enumeration Documentation

enum gBaseZoneHack::State [private]

possible states

Enumerator:

State_Safe	not yet conquered
State_Conquering	conquering in this frame
State_Conquered	conquered

Definition at line 178 of file gWinZone.h.

    {
        State_Safe,        
        State_Conquering,  
        State_Conquered    
    };

---

Constructor & Destructor Documentation

gBaseZoneHack::gBaseZoneHack	(	eGrid *	grid,
		const eCoord &	pos
	)

local constructor

Parameters:

	grid	Grid to put the zone into
	pos	Position to spawn the zone at

Definition at line 729 of file gWinZone.cpp.

References conquered_, enemiesInside_, lastEnemyContact_, lastSync_, ownersInside_, se_GameTime(), and teamDistance_.

        :gZone( grid, pos), onlySurvivor_( false ), currentState_( State_Safe )
{
    enemiesInside_ = ownersInside_ = 0;
    conquered_ = 0;
    lastSync_ = -10;
    teamDistance_ = 0;
    lastEnemyContact_ = se_GameTime();
}

Here is the call graph for this function:

gBaseZoneHack::gBaseZoneHack

(

nMessage &

m

)

network constructor

Parameters:

m

Message to read creation data from

Definition at line 749 of file gWinZone.cpp.

References conquered_, enemiesInside_, lastEnemyContact_, lastSync_, ownersInside_, se_GameTime(), and teamDistance_.

        : gZone( m ), onlySurvivor_( false ), currentState_( State_Safe )
{
    enemiesInside_ = ownersInside_ = 0;
    conquered_ = 0;
    lastSync_ = -10;
    teamDistance_ = 0;
    lastEnemyContact_ = se_GameTime();
}

Here is the call graph for this function:

gBaseZoneHack::~gBaseZoneHack

(

void

)

destructor

Definition at line 768 of file gWinZone.cpp.

{
}

---

Member Function Documentation

bool gBaseZoneHack::Timestep

(

REAL

time

)

[private, virtual]

simulates behaviour up to currentTime

Parameters:

time

the current time

Reimplemented from gZone.

Definition at line 837 of file gWinZone.cpp.

References tColor::b_, gZone::color_, conquered_, CountZonesOfTeam(), currentState_, ePlayerNetID::CurrentTeam(), gCycleMovement::distance, dt, eCoord, enemies_, enemiesInside_, tColor::g_, eGrid::GameObjects(), gZone::GetRadius(), gZone::GetRotationAcceleration(), gZone::GetRotationSpeed(), eGameObject::Grid(), lastEnemyContact_, lastSync_, eGameObject::lastTime, GrowingArrayBase::Len(), nCLIENT, nSERVER, NULL, OnConquest(), onlySurvivor_, ownersInside_, eNetGameObject::Player(), eGameObject::pos, eGameObject::Position(), tColor::r_, REAL, nNetObject::RequestSync(), gZone::SetExpansionSpeed(), gZone::SetReferenceTime(), gZone::SetRotationAcceleration(), gZone::SetRotationSpeed(), sg_baseZonesPerTeam, sg_conquestDecayRate, sg_conquestRate, sg_conquestTimeout, sg_DeclareWinner(), sg_defendRate, sg_onConquestScore, sg_segments, sn_ConsoleOut(), sn_GetNetState(), State_Conquered, State_Conquering, State_Safe, eGameObject::team, teamDistance_, eTeam::teams, and gZone::Timestep().

{
    if ( currentState_ == State_Conquering )
    {
        // let zone vanish
        SetReferenceTime();
        SetExpansionSpeed( -GetRadius()*.5 );
        SetRotationAcceleration( -GetRotationSpeed()*.4 );
        RequestSync();

        currentState_ = State_Conquered;
    }

    REAL dt = time - lastTime;

    // conquest going on
    REAL conquest = sg_conquestRate * enemiesInside_ - sg_defendRate * ownersInside_ - sg_conquestDecayRate;
    conquered_ += dt * conquest;

    // clamp
    if ( conquered_ < 0 )
    {
        conquered_ = 0;
        conquest = 0;
    }
    if ( conquered_ > 1.01 )
    {
        conquered_ = 1.01;
        conquest = 0;
    }

    // set speed according to conquest status
    if ( currentState_ == State_Safe )
    {
        REAL maxSpeed = 10 * ( 2 * 3.141 ) / sg_segments;
        REAL omega = .3 + conquered_ * conquered_ * maxSpeed;
        REAL omegaDot = 2 * conquered_ * conquest * maxSpeed;

        // determine the time since the last sync (exaggerate for smoother motion in local games)
        REAL timeStep = lastTime - lastSync_;
        if ( sn_GetNetState() != nSERVER )
            timeStep *= 100;

        if ( sn_GetNetState() != nCLIENT &&
                ( ( fabs( omega - GetRotationSpeed() ) + fabs( omegaDot - GetRotationAcceleration() ) ) * timeStep > .5 ) )
        {
            SetRotationSpeed( omega );
            SetRotationAcceleration( omegaDot );
            SetReferenceTime();
            RequestSync();
            lastSync_ = lastTime;
        }


        // check for enemy contact timeout
        if ( sg_conquestTimeout > 0 && lastEnemyContact_ + sg_conquestTimeout < time )
        {
            enemies_.clear();

            // if the zone would collapse without defenders, let it collapse now. A smart defender would
            // have left the zone to let it collapse anyway.
            if ( sg_conquestDecayRate < 0 )
            {
                if ( team )
                    sn_ConsoleOut( tOutput( "$zone_collapse_harmless", team->Name()  ) );
                conquered_ = 1.0;
            }
        }

        // check whether the zone got conquered
        if ( conquered_ >= 1 )
        {
            currentState_ = State_Conquering;
            OnConquest();
        }
    }


    // reset counts
    enemiesInside_ = ownersInside_ = 0;

    // determine the owning team: the one that has a player spawned closest

    // find the closest player
    if ( !team )
    {
        teamDistance_ = 0;
        const tList<eGameObject>& gameObjects = Grid()->GameObjects();
        gCycle * closest = NULL;
        REAL closestDistance = 0;
        for (int i=gameObjects.Len()-1;i>=0;i--)
        {
            gCycle *other=dynamic_cast<gCycle *>(gameObjects(i));

            if (other )
            {
                eTeam * otherTeam = other->Player()->CurrentTeam();
                eCoord otherpos = other->Position() - pos;
                REAL distance = otherpos.NormSquared();
                if ( !closest || distance < closestDistance )
                {
                    // check whether other zones are already registered to that team
                    gBaseZoneHack * farthest = NULL;
                    int count = 0;
                    if ( sg_baseZonesPerTeam > 0 )
                        CountZonesOfTeam( Grid(), otherTeam, count, farthest );

                    // only set team if not too many closer other zones are registered
                    if ( sg_baseZonesPerTeam == 0 || count < sg_baseZonesPerTeam || farthest->teamDistance_ > distance )
                    {
                        closest = other;
                        closestDistance = distance;
                    }
                }
            }
        }

        if ( closest )
        {
            // take over team and color
            team = closest->Player()->CurrentTeam();
            color_.r_ = team->R()/15.0;
            color_.g_ = team->G()/15.0;
            color_.b_ = team->B()/15.0;
            teamDistance_ = closestDistance;

            RequestSync();
        }

        // if this zone does not belong to a team, discard it.
        if ( !team )
        {
            return true;
        }

        // check other zones owned by the same team. Discard the one farthest away
        // if the max count is exceeded
        if ( team && sg_baseZonesPerTeam > 0 )
        {
            gBaseZoneHack * farthest = 0;
            int count = 0;
            CountZonesOfTeam( Grid(), team, count, farthest );

            // discard team of farthest zone
            if ( count > sg_baseZonesPerTeam )
                farthest->team = NULL;
        }
    }


    // delegate
    bool ret = gZone::Timestep( time );

    // reward survival
    if ( !ret && onlySurvivor_ )
    {
        const char* message= ( eTeam::teams.Len() > 2 || sg_onConquestScore ) ? "$player_win_survive" : "$player_win_conquest";
        sg_DeclareWinner( team, message );
    }

    return ret;
}

Here is the call graph for this function:

void gBaseZoneHack::OnEnter	(	gCycle *	target,
		REAL	time
	)			[private, virtual]

reacts on objects inside the zone

Parameters:

	target	the cycle that has been found inside the zone
	time	the current time

Reimplemented from gZone.

Definition at line 1167 of file gWinZone.cpp.

References currentState_, ePlayerNetID::CurrentTeam(), enemies_, enemiesInside_, lastEnemyContact_, ownersInside_, eNetGameObject::Player(), State_Safe, tASSERT, and eGameObject::team.

{
    // determine the team of the player
    tASSERT( target );
    if ( !target->Player() )
        return;
    tJUST_CONTROLLED_PTR< eTeam > otherTeam = target->Player()->CurrentTeam();
    if (!otherTeam)
        return;
    if ( currentState_ != State_Safe )
        return;

    // remember who is inside
    if ( team == otherTeam )
    {
        ++ ownersInside_;
    }
    else if ( team )
    {
        if ( enemiesInside_ == 0 )
            enemies_.clear();

        ++ enemiesInside_;
        if ( std::find( enemies_.begin(), enemies_.end(), otherTeam ) == enemies_.end() )
            enemies_.push_back( otherTeam );

        lastEnemyContact_ = time;
    }
}

Here is the call graph for this function:

void gBaseZoneHack::OnVanish

(

void

)

[private, virtual]

called when the zone vanishes

Reimplemented from gZone.

Definition at line 1009 of file gWinZone.cpp.

References eGameObject::Alive(), CheckSurvivor(), currentState_, gCycleMovement::distance, eCoord, enemies_, ePlayerNetID::GetName(), eGameObject::Kill(), NULL, ePlayerNetID::Object(), eGameObject::pos, REAL, sg_defendRate, sg_onConquestKillMin, sg_onConquestKillRatio, sn_ConsoleOut(), State_Safe, and eGameObject::team.

{
    if (!team)
        return;

    CheckSurvivor();

    // kill the closest owners of the zone
    if ( currentState_ != State_Safe && ( enemies_.size() > 0 || sg_defendRate < 0 ) )
    {
        int kills = int( sg_onConquestKillRatio * team->NumPlayers() );
        kills = kills > sg_onConquestKillMin ? kills : sg_onConquestKillMin;

        while ( kills > 0 )
        {
            -- kills;

            ePlayerNetID * closest = NULL;
            REAL closestDistance = 0;

            // find the closest living owner
            for ( int i = team->NumPlayers()-1; i >= 0; --i )
            {
                ePlayerNetID * player = team->Player(i);
                eNetGameObject * object = player->Object();
                if ( object && object->Alive() )
                {
                    eCoord otherpos = object->Position() - pos;
                    REAL distance = otherpos.NormSquared();
                    if ( !closest || distance < closestDistance )
                    {
                        closest = player;
                        closestDistance = distance;
                    }
                }
            }

            if ( closest )
            {
                sn_ConsoleOut( tOutput("$player_kill_collapse", closest->GetName() ) );
                closest->Object()->Kill();
            }
        }
    }
}

Here is the call graph for this function:

void gBaseZoneHack::OnConquest

(

void

)

[private, virtual]

called when the zone gets conquered

Definition at line 1064 of file gWinZone.cpp.

References eTeam::Alive(), CheckSurvivor(), enemies_, enemiesInside_, score, tOutput::SetTemplateParameter(), sg_DeclareWinner(), sg_onConquestScore, sg_onConquestWin, and eGameObject::team.

Referenced by Timestep().

{
    // calculate score. If nobody really was inside the zone any more, half it.
    int totalScore = sg_onConquestScore;
    if ( 0 == enemiesInside_ )
        totalScore /= 2;

    // eliminate dead enemies
    TeamArray enemiesAlive;
    for ( TeamArray::iterator iter = enemies_.begin(); iter != enemies_.end(); ++iter )
    {
        eTeam* team = *iter;
        if ( team->Alive() )
            enemiesAlive.push_back( team );
    }
    enemies_ = enemiesAlive;

    // add score for successful conquest, divided equally between the teams that are
    // inside the zone
    if ( totalScore && enemies_.size() > 0 )
    {
        tOutput win;
        if ( team )
        {
            win.SetTemplateParameter( 3, team->Name() );
            win << "$player_win_conquest_specific";
        }
        else
        {
            win << "$player_win_conquest";
        }

        int score = totalScore / enemies_.size();
        for ( TeamArray::iterator iter = enemies_.begin(); iter != enemies_.end(); ++iter )
        {
            (*iter)->AddScore( score, win, tOutput() );
        }
    }

    // trigger immediate win
    if ( sg_onConquestWin && enemies_.size() > 0 )
    {
        static const char* message="$player_win_conquest";
        sg_DeclareWinner( enemies_[0], message );
    }

    CheckSurvivor();
}

Here is the call graph for this function:

Here is the caller graph for this function:

void gBaseZoneHack::CheckSurvivor

(

void

)

[private, virtual]

checks for the only surviving zone

Definition at line 1126 of file gWinZone.cpp.

References currentState_, eGrid::GameObjects(), eGameObject::Grid(), GrowingArrayBase::Len(), onlySurvivor_, sg_onSurviveWin, State_Safe, and eGameObject::team.

Referenced by OnConquest(), and OnVanish().

{
    // test if there is only one team with non-conquered zones left
    if ( sg_onSurviveWin )
    {
        // find surviving team and test whether it is the only one
        gBaseZoneHack * survivor = 0;
        bool onlySurvivor = true;

        const tList<eGameObject>& gameObjects = Grid()->GameObjects();
        for (int i=gameObjects.Len()-1;i>=0 && onlySurvivor;i--){
            gBaseZoneHack *other=dynamic_cast<gBaseZoneHack *>(gameObjects(i));

            if ( other && other->currentState_ == State_Safe && other->team )
            {
                if ( survivor && survivor->team != other->team )
                    onlySurvivor = false;
                else
                    survivor = other;
            }
        }

        // reward it later
        if ( onlySurvivor && survivor )
        {
            survivor->onlySurvivor_ = true;
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void gBaseZoneHack::CountZonesOfTeam	(	eGrid const *	grid,
		eTeam *	otherTeam,
		int &	count,
		gBaseZoneHack *&	farthest
	)			[static, private]

counts the zones belonging to the given team.

Definition at line 806 of file gWinZone.cpp.

References eGrid::GameObjects(), GrowingArrayBase::Len(), NULL, eGameObject::Team(), and teamDistance_.

Referenced by Timestep().

{
    count = 0;
    farthest = NULL;

    // check whether other zones are already registered to that team
    const tList<eGameObject>& gameObjects = grid->GameObjects();
    for (int j=gameObjects.Len()-1;j>=0;j--)
    {
        gBaseZoneHack *otherZone=dynamic_cast<gBaseZoneHack *>(gameObjects(j));

        if ( otherZone && otherTeam == otherZone->Team() )
        {
            count++;
            if ( !farthest || otherZone->teamDistance_ > farthest->teamDistance_ )
                farthest = otherZone;
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

---

Member Data Documentation

REAL gBaseZoneHack::conquered_ [private]

conquest status; zero if it is free, 1 if it has been completely conquered by the enemy

Definition at line 163 of file gWinZone.h.

Referenced by gBaseZoneHack(), and Timestep().

int gBaseZoneHack::enemiesInside_ [private]

count of enemies currently inside the zone

Definition at line 164 of file gWinZone.h.

Referenced by gBaseZoneHack(), OnConquest(), OnEnter(), and Timestep().

int gBaseZoneHack::ownersInside_ [private]

count of owners currently inside the zone

Definition at line 165 of file gWinZone.h.

Referenced by gBaseZoneHack(), OnEnter(), and Timestep().

bool gBaseZoneHack::onlySurvivor_ [private]

flag set if this zone is the only survivor

Definition at line 167 of file gWinZone.h.

Referenced by CheckSurvivor(), and Timestep().

TeamArray gBaseZoneHack::enemies_ [private]

list of teams that currently have a player in the zone

Definition at line 170 of file gWinZone.h.

Referenced by OnConquest(), OnEnter(), OnVanish(), and Timestep().

REAL gBaseZoneHack::lastEnemyContact_ [private]

last time an enemy player was in the zone

Definition at line 171 of file gWinZone.h.

Referenced by gBaseZoneHack(), OnEnter(), and Timestep().

REAL gBaseZoneHack::teamDistance_ [private]

distance to the closest member of the owning team

Definition at line 173 of file gWinZone.h.

Referenced by CountZonesOfTeam(), gBaseZoneHack(), and Timestep().

bool gBaseZoneHack::touchy_ [private]

flag set when the zone is "touchy", which makes it get conquered on the slightest enemy touch

Definition at line 175 of file gWinZone.h.

State gBaseZoneHack::currentState_ [private]

the current state

Definition at line 184 of file gWinZone.h.

Referenced by CheckSurvivor(), OnEnter(), OnVanish(), and Timestep().

REAL gBaseZoneHack::lastSync_ [private]

time of the last sync request

Definition at line 186 of file gWinZone.h.

Referenced by gBaseZoneHack(), and Timestep().

---

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

• src/tron/gWinZone.h
• src/tron/gWinZone.cpp

---