gNetPlayerWall Class Reference

#include <gWall.h>

Inheritance diagram for gNetPlayerWall:

[legend]

Collaboration diagram for gNetPlayerWall:

[legend]

List of all members.

Public Types
enum	gWallRenderMode { gWallRenderMode_Lines = 1, gWallRenderMode_Quads = 2, gWallRenderMode_All = 3 }
Public Member Functions
virtual void	InitAfterCreation ()
	gNetPlayerWall (gCycle *c, const eCoord &beg, const eCoord &dir, REAL tBeg, REAL dbeg)
void	Update (REAL tEnd, const eCoord &pend)
void	CopyIntoGrid (eGrid *grid, bool force=false)
void	RealWallReceived (gNetPlayerWall *realwall)
void	Checkpoint ()
	marks the current distance and time for more accurate interpolation
	gNetPlayerWall (nMessage &m)
eCoord	Vec ()
	returns the vector from the beginning to the end of the wall
tArray< gPlayerWallCoord > &	Coords ()
void	SetEndTime (REAL et)
void	SetEndPos (REAL ep)
int	IndexAlpha (REAL a) const
int	IndexPos (REAL d) const
REAL	Time (REAL a) const
REAL	Pos (REAL a) const
REAL	Alpha (REAL pos) const
bool	IsDangerousAnywhere (REAL time) const
bool	IsDangerousApartFromHoles (REAL a, REAL time) const
bool	IsDangerous (REAL a, REAL time) const
gExplosion *	Holer (REAL a, REAL time) const
void	BlowHole (REAL dbeg, REAL dend, gExplosion *holer)
REAL	BegPos () const
REAL	EndPos () const
REAL	BegTime () const
REAL	EndTime () const
const eCoord &	EndPoint (int i) const
virtual void	Render (const eCamera *cam)
void	RenderList (bool list, gWallRenderMode mode=gWallRenderMode_All)
virtual void	RenderNormal (const eCoord &x1, const eCoord &x2, REAL ta, REAL te, REAL r, REAL g, REAL b, REAL a, gWallRenderMode mode)
virtual void	RenderBegin (const eCoord &x1, const eCoord &x2, REAL ta, REAL te, REAL ra, REAL rb, REAL r, REAL g, REAL b, REAL a)
virtual bool	ActionOnQuit ()
virtual bool	ClearToTransmit (int user) const
virtual void	WriteSync (nMessage &m)
virtual void	ReadSync (nMessage &m)
virtual void	WriteCreate (nMessage &m)
virtual nDescriptor &	CreatorDescriptor () const
virtual void	PrintName (tString &s) const
virtual bool	SyncIsNew (nMessage &m)
eTempEdge *	Edge ()
gPlayerWall *	Wall ()
gCycle *	Cycle () const
gCycleMovement *	CycleMovement () const
bool	Preliminary () const
bool	InGrid () const
void	Check () const
bool	HasDisplayList ()
bool	CanHaveDisplayList ()
void	ClearDisplayList (int inhibitThis=2, int inhibitCycle=0)
	clears the display list
Static Public Member Functions
static void	s_CopyIntoGrid ()
static void	Clear ()
Protected Member Functions
virtual	~gNetPlayerWall ()
void	ReleaseData ()
Private Member Functions
	tCONTROLLED_PTR (gCycle) cycle_
	tCONTROLLED_PTR (eTempEdge) edge_
void	CreateEdge ()
void	InitArray ()
void	MyInitAfterCreation ()
void	real_CopyIntoGrid (eGrid *grid)
void	PartialCopyIntoGrid (eGrid *grid)
void	real_Update (REAL tEnd, const eCoord &pend, bool force)
Private Attributes
int	id
int	griddedid
gPlayerWall *	lastWall_
eCoord	dir
	the last wall that was dropped into the grid by PartialCopyIntoGrid()
REAL	dbegin
eCoord	beg
eCoord	end
REAL	tBeg
REAL	tEnd
unsigned short	inGrid
REAL	gridding
bool	preliminary:1
REAL	obsoleted_
tArray< gPlayerWallCoord >	coords_
rDisplayList	displayList_
Friends
class	gCycle

---

Detailed Description

Definition at line 151 of file gWall.h.

---

Member Enumeration Documentation

enum gNetPlayerWall::gWallRenderMode

should the whole wall be rendered or just the line/quad segnemts? indivisual segments will be rendered without the glBegin/End block.

Enumerator:

gWallRenderMode_Lines
gWallRenderMode_Quads
gWallRenderMode_All

Definition at line 236 of file gWall.h.

    {
        gWallRenderMode_Lines = 1,
        gWallRenderMode_Quads = 2,
        gWallRenderMode_All =   3
    };

---

Constructor & Destructor Documentation

gNetPlayerWall::gNetPlayerWall	(	gCycle *	c,
		const eCoord &	beg,
		const eCoord &	dir,
		REAL	tBeg,
		REAL	dbeg
	)

Definition at line 1572 of file gWall.cpp.

References dir, gridding, MyInitAfterCreation(), nCLIENT, obsoleted_, preliminary, and sn_GetNetState().

        :nNetObject(cyc->Owner()),
        id(-1),griddedid(-1),
        cycle_(cyc),lastWall_(NULL),dir(d),dbegin(dbeg),
        beg(begi),end(begi),tBeg(tBegi),tEnd(tBegi),
        inGrid(false){
    dir=dir; // Don't normalize: *REAL(1/sqrt(dir.NormSquared()));
    preliminary=(sn_GetNetState()==nCLIENT);
    obsoleted_=-100;
    gridding=1E+20;
    MyInitAfterCreation();

Here is the call graph for this function:

gNetPlayerWall::gNetPlayerWall

(

nMessage &

m

)

Definition at line 1945 of file gWall.cpp.

References beg, dbegin, dir, end, gridding, InitArray(), nNetObject::Object(), obsoleted_, preliminary, nMessage::Read(), and tBeg.

        :nNetObject(m),
        id(-1),griddedid(-1),
        cycle_(NULL),edge_(NULL), lastWall_(NULL),
        dir(0,0),dbegin(0),
        beg(0,0),end(0,0),
        tBeg(0),tEnd(0),
        inGrid(0)
{
    unsigned short cid;
    gridding=1E+20;
    m.Read(cid);
    cycle_=static_cast<gCycle *>(Object(cid));

    m >> beg;
    end=beg;
    m >> dir;
    m >> dbegin;

    m >> tBeg;
    {
        int preliminary;
        m >> preliminary;
        this->preliminary = preliminary;
    }

    obsoleted_=-100;

    this->InitArray();

Here is the call graph for this function:

gNetPlayerWall::~gNetPlayerWall

(

)

[protected, virtual]

Definition at line 2024 of file gWall.cpp.

References ClearDisplayList(), and ReleaseData().

{
    ReleaseData();
    ClearDisplayList();

Here is the call graph for this function:

---

Member Function Documentation

gNetPlayerWall::tCONTROLLED_PTR

(

gCycle

)

[private]

gNetPlayerWall::tCONTROLLED_PTR

(

eTempEdge

)

[private]

void gNetPlayerWall::CreateEdge

(

)

[private]

Definition at line 1477 of file gWall.cpp.

References beg, end, NULL, and tNEW.

Referenced by MyInitAfterCreation(), and ReadSync().

{
    if ( this->edge_ )
        return;

    if (this->cycle_)
    {
        gPlayerWall* w = tNEW(gPlayerWall)(this,
                                           this->cycle_);

        this->edge_=tNEW(eTempEdge)(beg,
                                    end,
                                    w );
    }
    else
    {
        this->edge_ = NULL;
        return;
    }

Here is the caller graph for this function:

void gNetPlayerWall::InitArray

(

)

[private]

Definition at line 1504 of file gWall.cpp.

References beg, coords_, dbegin, end, REAL, tArray< T, MALLOC >::SetLen(), sqrt(), tBeg, and tEnd.

Referenced by gNetPlayerWall(), and MyInitAfterCreation().

{
    REAL ep = dbegin+sqrt((beg-end).NormSquared());
    REAL sp = dbegin;

    if ( ep < sp )
    {
        ep = sp;
    }

    if ( tEnd < tBeg )
    {
        tEnd = tBeg;
    }

    coords_.SetLen(2);
    coords_[0].Pos              = sp;
    coords_[0].Time             = tBeg;
    coords_[0].IsDangerous   = true;
    coords_[1].Pos              = ep;
    coords_[1].Time             = tEnd;
    coords_[1].IsDangerous   = true;

Here is the call graph for this function:

Here is the caller graph for this function:

void gNetPlayerWall::MyInitAfterCreation

(

void

)

[private]

Definition at line 1528 of file gWall.cpp.

References tList< T, MALLOC, REFERENCE >::Add(), beg, rDisplayList::Clear(), coords_, CreateEdge(), displayList_, end, griddedid, InitArray(), tListItem< gNetPlayerWall >::Insert(), GrowingArrayBase::Len(), MAX_VIEWERS, eWall::Remove(), eWall::SetVisHeight(), st_Breakpoint(), tASSERT, and Wall().

Referenced by gNetPlayerWall(), and InitAfterCreation().

{
#ifndef DEDICATED
    // put yourself into rendering list
    if ( cycle_ )
    {
        Insert( cycle_->displayList_.wallList_ );
    }
#endif

    //w=
#ifdef DEBUG
    if (!finite(end.x) || !finite(end.y))
        st_Breakpoint();

    if (!finite(beg.x) || !finite(beg.y))
        st_Breakpoint();
#endif

    if ( coords_.Len() < 2 )
    {
        InitArray();
    }

    CreateEdge();

    id=-1;
    griddedid=-1;
    sg_netPlayerWalls.Add(this,id);

    if ( !Wall() )
        return;
    tASSERT( Wall()->Splittable() );

    for (int i=MAX_VIEWERS-1;i>=0;i--)
        Wall()->SetVisHeight(i,0);

    Wall()->Remove();

    displayList_.Clear(2);

Here is the call graph for this function:

Here is the caller graph for this function:

void gNetPlayerWall::real_CopyIntoGrid

(

eGrid *

grid

)

[private]

Definition at line 1744 of file gWall.cpp.

References tList< T, MALLOC, REFERENCE >::Add(), eGrid::Check(), ClearDisplayList(), griddedid, gPlayerWall::Insert(), NULL, preliminary, ReleaseData(), tList< T, MALLOC, REFERENCE >::Remove(), tASSERT, and Wall().

Referenced by CopyIntoGrid(), gCycle::Die(), RealWallReceived(), and s_CopyIntoGrid().

                                                 {
    //  con << "Gridding " << ID() << " : ";
    //con << "from " << *e->Point(0) << " to " << *e->Point(1) << '\n';

    tJUST_CONTROLLED_PTR< gNetPlayerWall > keep( this );

#ifdef DEBUG
    grid->Check();
#endif

    if (griddedid<0){
        if ( this->cycle_ )
        {
            tASSERT( static_cast< bool >(this->edge_) );
            tASSERT(Wall());
            tASSERT(Wall()->Splittable());

            if (preliminary){
                //delete this; // get rid of it
                tControlledPTR< nNetObject > bounce( this );

                sg_netPlayerWalls.Remove(this,id);
                sg_netPlayerWallsGridded.Add(this,griddedid);
                Wall()->Insert();
                this->ReleaseData();
                ClearDisplayList();
            }
            else{
                sg_netPlayerWallsGridded.Add(this,griddedid);
                sg_netPlayerWalls.Remove(this,id);
                if ( this->edge_ ){
                    Wall()->Insert();
                    this->edge_->CopyIntoGrid(this->cycle_->Grid());
                    this->edge_ = NULL;
                }
            }
        }
    }

#ifdef DEBUG
    grid->Check();
#endif

Here is the call graph for this function:

Here is the caller graph for this function:

void gNetPlayerWall::PartialCopyIntoGrid

(

eGrid *

grid

)

[private]

Definition at line 1789 of file gWall.cpp.

References gPlayerWall::begDist_, eGrid::Check(), end, gPlayerWall::endDist_, griddedid, gPlayerWall::Insert(), lastWall_, NULL, preliminary, eWall::Remove(), tNEW, and Wall().

                                                   {
    //  con << "Gridding " << ID() << " : ";
    //con << "from " << *e->Point(0) << " to " << *e->Point(1) << '\n';

    tJUST_CONTROLLED_PTR< gNetPlayerWall > keep( this );

#ifdef DEBUG
    grid->Check();
#endif

    if (griddedid<0 && bool(this->cycle_) && !preliminary ){

        // just copy the current edge into the grid
        if ( this->edge_ ){
            lastWall_ = Wall();
            Wall()->Insert();
            this->edge_->CopyIntoGrid(grid);
            this->edge_ = NULL;
        }

        // and create a new one just at the end bit
        gPlayerWall* w = tNEW(gPlayerWall)(this,
                                           this->cycle_);
        this->edge_=tNEW(eTempEdge)(end,
                                    end,
                                    w );

        // insert it into the list of not yet gridded walls
        w->Remove();

        // hack the beginning distance to be the same as the starting distance
        w->begDist_ = w->endDist_;
    }

    // add a new segment as a copy of the current one
    // int newCoord = coords_.Len();
    // coords_[newCoord]=coords_[newCoord-1];

#ifdef DEBUG
    grid->Check();
#endif

Here is the call graph for this function:

void gNetPlayerWall::real_Update	(	REAL	tEnd,
		const eCoord &	pend,
		bool	force
	)			[private]

Definition at line 1623 of file gWall.cpp.

References beg, gPlayerWall::begDist_, eWall::CalcLen(), gPlayerWall::Check(), Checkpoint(), coords_, dbegin, dir, eCoord, end, gPlayerWall::endDist_, EndPos(), IsDangerous(), lastWall_, GrowingArrayBase::Len(), Pos(), REAL, SetEndPos(), SetEndTime(), tArray< T, MALLOC >::SetLen(), st_Breakpoint(), tBeg, tEnd, and Wall().

Referenced by ReadSync(), and Update().

{
    // duplicate last coords entry if its dangerousness disagrees with the previous entry.
    if ( coords_.Len() >= 2 && coords_[ coords_.Len()-2 ].IsDangerous != coords_[ coords_.Len()-1 ].IsDangerous )
    {
        Checkpoint();
    }

    tEnd=Tend;
    end=pend;

    // make sure the wall points forward
    REAL forward = eCoord::F( end-beg, dir )/dir.NormSquared();
    if ( forward < 0 )
    {
        end = beg;
        tEnd = tBeg;
    }

#ifdef DEBUG
    if (!finite(end.x) || !finite(end.y))
        st_Breakpoint();
#endif

    eCoord odir=dir.Turn(0,1);
    REAL x=eCoord::F(odir,(end-beg))/dir.NormSquared();
    beg=beg+odir*x;

    if (bool( this->edge_ ) && this->edge_->Point(0) && this->edge_->Point(1)){
        this->edge_->Coord(1) = end;
        if ( !lastWall_ )
            this->edge_->Coord(0) = beg;
    }

    // determine the correct end position
    REAL endPos = 0;
    //if ( bool( this->cycle_ ) && !force )
    //{
    //    endPos =  this->cycle_->GetDistance();
    //}
    //else
    {
        endPos = dbegin + eCoord::F(dir, end - beg )/dir.NormSquared();
    }

    // delete coords_ entries that lie after the last one according to their distance; they're invalidated.
    {
        int len = coords_.Len();
        while ( len >= 3 && coords_[len-2].IsDangerous == coords_[len-1].IsDangerous && coords_[len-2].Pos > endPos )
        {
            coords_[len-2] = coords_[len-1];
            coords_.SetLen(len - 1);
            len = coords_.Len();
        }
    }

    // set end position and time
    SetEndTime(tEnd);
    SetEndPos(endPos);


    gPlayerWall *w = Wall();

    if ( w )
    {
        w->CalcLen();
        if ( !lastWall_ )
            w->begDist_ = dbegin;
        w->endDist_ = EndPos();
#ifdef DEBUG
        w->Check();
#endif
    }

Here is the call graph for this function:

Here is the caller graph for this function:

void gNetPlayerWall::InitAfterCreation

(

void

)

[virtual]

Reimplemented from nNetObject.

Definition at line 1498 of file gWall.cpp.

References nNetObject::InitAfterCreation(), and MyInitAfterCreation().

{
    nNetObject::InitAfterCreation();
    MyInitAfterCreation();

Here is the call graph for this function:

void gNetPlayerWall::Update	(	REAL	tEnd,
		const eCoord &	pend
	)

Definition at line 1611 of file gWall.cpp.

References CHECKWALL, inGrid, nCLIENT, preliminary, real_Update(), and sn_GetNetState().

{
    CHECKWALL;

    if (!inGrid && ( preliminary || sn_GetNetState() != nCLIENT ) )
    {
        real_Update( Tend, pend, false );
    }

    CHECKWALL;

Here is the call graph for this function:

void gNetPlayerWall::CopyIntoGrid	(	eGrid *	grid,
		bool	force = false
	)

Definition at line 1711 of file gWall.cpp.

References gridding, inGrid, nCLIENT, obsoleted_, nConnectionInfo::ping, preliminary, REAL, real_CopyIntoGrid(), nNetObject::RequestSync(), se_GameTime(), sn_Connections, sn_GetNetState(), and tEnd.

Referenced by ReadSync().

                                                         {
    tJUST_CONTROLLED_PTR< gNetPlayerWall > keep( this );

    if (!inGrid && (force ||
                    (sn_GetNetState()!=nCLIENT || preliminary))){
        inGrid=true;
        gridding=REAL(se_GameTime()+1.0);
        if (sn_GetNetState()==nCLIENT)
        {
            // leave the wall lingering around for some time on the client
            gridding=se_GameTime()+40*sn_Connections[0].ping+10;

            // unless it is already obsoleted by a final wall or IS a final wall. Delete/grid it immediately then.
            if ( obsoleted_ > tEnd - .003f || !preliminary )
            {
                if ( grid )
                    real_CopyIntoGrid( grid );
                else
                    gridding=REAL(se_GameTime()+.000001);
            }
        }
        else
        {
            // copy it into the grid at the next opportunity for server/standalone mode
            RequestSync();
            if ( grid )
                real_CopyIntoGrid( grid );
            else
                gridding=REAL(se_GameTime()+.000001);
        }
    }

Here is the call graph for this function:

Here is the caller graph for this function:

void gNetPlayerWall::s_CopyIntoGrid

(

)

[static]

Definition at line 1833 of file gWall.cpp.

References con, griddedid, gridding, inGrid, GrowingArrayBase::Len(), real_CopyIntoGrid(), se_GameTime(), and sg_netPlayerWalls.

Referenced by s_Timestep().

{
#ifdef DEBUG
    static int maxw=20;
    if (sg_netPlayerWalls.Len()>maxw)
        con << "Many walls: " << (maxw=sg_netPlayerWalls.Len()) << '\n';
#endif

    for (int i=sg_netPlayerWalls.Len()-1;i>=0;i--){
        gNetPlayerWall *w=sg_netPlayerWalls(i);
        if (w->inGrid && w->griddedid<0 && se_GameTime()>w->gridding)
            w->real_CopyIntoGrid(w->cycle_->Grid());
    }

Here is the call graph for this function:

Here is the caller graph for this function:

void gNetPlayerWall::RealWallReceived

(

gNetPlayerWall *

realwall

)

Definition at line 1848 of file gWall.cpp.

References dir, EPS, gridding, obsoleted_, nNetObject::Owner(), nConnectionInfo::ping, preliminary, REAL, real_CopyIntoGrid(), se_GameTime(), sn_Connections, sn_myNetID, sr_predictObjects, tASSERT, tBeg, and tEnd.

Referenced by ReadSync().

{
    if (this->cycle_ )
    {
        tASSERT( realWall );
        tASSERT( preliminary && !realWall->preliminary );

        // accelerate gridding if the real wall is newer than this
        if ( tBeg + tEnd < 2 * realWall->tEnd )
        {
            REAL maxGridding=se_GameTime() + 2*sn_Connections[0].ping;
            if ( gridding > maxGridding )
                gridding = maxGridding;
        }

        // calculate the overlap between the real wall and this wall
        REAL overlap = 0;
        {
            REAL tEndThis = tEnd;
            // cut from the end if we're in prediction mode and this is an enemy wall
            if ( sr_predictObjects && this->cycle_->currentWall == this && Owner() != sn_myNetID )
            {
                tEndThis -= this->cycle_->Lag();
            }

            REAL tBegMin = tBeg;
            REAL tBegMax = realWall->tBeg;
            if ( tBegMin > tBegMax )
            {
                tBegMin = realWall->tBeg;
                tBegMax = tBeg;
            }

            REAL tEndMin = tEndThis;

            REAL tEndMax = realWall->tEnd;
            if ( tEndMin > tEndMax )
            {
                tEndMin = realWall->tEnd;
                tEndMax = tEndThis;
            }

            REAL denominator = tEndMax - tBegMin;
            if ( denominator > 0 )
                overlap = ( tEndMin - tBegMax ) / denominator;
        }

        // no overlap if directions don't match
        if ( overlap > 0 && fabs( dir * realWall->dir ) > 10 * EPS )
            overlap = 0;

        // no good overlap? Go home.
        if ( overlap < .8 )
            return;

        // mark current walls as to be deleted immediately after the cycle does no longer need it
        obsoleted_ = realWall->tEnd;

        // copy non-current walls into the grid immediately
        if (this->cycle_->currentWall!=this )
        {
            // replace pointer in cycle
            if (this->cycle_->lastWall==this)
            {
                this->cycle_->lastWall=realWall;

                /*
                // close seams (does not help, deactivated)
                if ( this->cycle_->currentWall && this->cycle_->currentWall->preliminary )
                {
                    this->cycle_->currentWall->tBeg   = realWall->tEnd;
                    this->cycle_->currentWall->coords_[0].Time   = realWall->tEnd;
                    this->cycle_->currentWall->dbegin = realWall->EndPos();
                }
                */
            }

            // delete this wall, it is no longer needed
            this->real_CopyIntoGrid( this->cycle_->Grid() );
        }
    }

Here is the call graph for this function:

Here is the caller graph for this function:

void gNetPlayerWall::Checkpoint

(

)

marks the current distance and time for more accurate interpolation

Definition at line 1698 of file gWall.cpp.

References CHECKWALL, coords_, and GrowingArrayBase::Len().

Referenced by real_Update().

{
    CHECKWALL;

    // copy the last coordinate entry
    int len = coords_.Len();

    // temporary is required to compensate for growing array nightmare
    coords_[len] = gPlayerWallCoord( coords_[len-1] );

    CHECKWALL;

Here is the call graph for this function:

Here is the caller graph for this function:

eCoord gNetPlayerWall::Vec

(

)

returns the vector from the beginning to the end of the wall

Definition at line 1976 of file gWall.cpp.

References eCoord.

{
    if ( edge_ ) return edge_->Vec();
    else return eCoord();

tArray<gPlayerWallCoord>& gNetPlayerWall::Coords

(

)

[inline]

Definition at line 194 of file gWall.h.

Referenced by cWidget::Map::DrawWalls().

{ return coords_; }

Here is the caller graph for this function:

void gNetPlayerWall::ReleaseData

(

)

[protected]

Definition at line 1993 of file gWall.cpp.

References griddedid, NULL, and tList< T, MALLOC, REFERENCE >::Remove().

Referenced by ActionOnQuit(), Clear(), real_CopyIntoGrid(), and ~gNetPlayerWall().

{
    if (this->cycle_){
        if (this->cycle_->currentWall==this)
            this->cycle_->currentWall=NULL;
        if (this->cycle_->lastWall==this)
            this->cycle_->lastWall=NULL;
        if (this->cycle_->lastNetWall==this)
            this->cycle_->lastNetWall=NULL;
    }

    // tDESTROY(w);

    if (this->edge_)
    {
        if ( this->edge_->Wall() )
            this->edge_->Wall()->Insert();

        this->edge_ = NULL;  // w will be deleted with e
        //    tDESTROY_PTR(p1);
        //    tDESTROY_PTR(p2);
    }

    this->cycle_=NULL;
    this->edge_=NULL;
    //w=NULL;

    sg_netPlayerWalls.Remove(this,id);
    sg_netPlayerWallsGridded.Remove(this,griddedid);

Here is the call graph for this function:

Here is the caller graph for this function:

void gNetPlayerWall::SetEndTime

(

REAL

et

)

Definition at line 1240 of file gWall.cpp.

References BegTime(), CHECKWALL, coords_, GrowingArrayBase::Len(), REAL, and Time().

Referenced by real_Update().

                                     {
    CHECKWALL;

    REAL BegTime = coords_( coords_.Len() -2 ).Time;
    if ( t < BegTime )
    {
        t = BegTime;
    }

    coords_(coords_.Len()-1).Time = t;

    CHECKWALL;

Here is the call graph for this function:

Here is the caller graph for this function:

void gNetPlayerWall::SetEndPos

(

REAL

ep

)

Definition at line 1255 of file gWall.cpp.

References BegPos(), CHECKWALL, coords_, GrowingArrayBase::Len(), Pos(), and REAL.

Referenced by real_Update().

                                     {
    CHECKWALL;

    REAL BegPos = coords_( coords_.Len() -2 ).Pos;
    if ( ep < BegPos )
    {
        ep = BegPos;
    }

    coords_(coords_.Len()-1).Pos = ep;

    CHECKWALL;

Here is the call graph for this function:

Here is the caller graph for this function:

int gNetPlayerWall::IndexAlpha

(

REAL

a

)

const

Definition at line 2280 of file gWall.cpp.

References CHECKWALL, d, IndexPos(), Pos(), and REAL.

Referenced by Holer(), IsDangerous(), and Time().

{
    CHECKWALL;

    REAL d = Pos( a );

    return IndexPos( d );

Here is the call graph for this function:

Here is the caller graph for this function:

int gNetPlayerWall::IndexPos

(

REAL

d

)

const

Definition at line 2260 of file gWall.cpp.

References CHECKWALL, coords_, GrowingArrayBase::Len(), Pos(), and st_Breakpoint().

Referenced by BlowHole(), and IndexAlpha().

{
    CHECKWALL;


    // get the first coord with smaller alpha than a
    int i = coords_.Len() - 2;
    while ( i >= 1 && coords_(i).Pos >= d)
        --i;

#ifdef DEBUG
    if (!( i >= 0 && i < coords_.Len() - 1 ))
    {
        st_Breakpoint();
    }
#endif

    return i;

Here is the call graph for this function:

Here is the caller graph for this function:

REAL gNetPlayerWall::Time

(

REAL

a

)

const

Definition at line 2289 of file gWall.cpp.

References CHECKWALL, coords_, good(), IndexAlpha(), Pos(), gPlayerWallCoord::Pos, REAL, tASSERT, and gPlayerWallCoord::Time.

Referenced by BlowHole(), Check(), EndTime(), and SetEndTime().

{
    tASSERT( good( a ) );

    CHECKWALL;

    const gPlayerWallCoord* coord = &coords_(IndexAlpha(a));
    REAL div = ( coord[1].Pos - coord[0].Pos );
    REAL alpha = 0.0f;
    if ( div > 0 )
    {
        alpha = ( Pos(a) - coord[0].Pos ) / div;
    }

    REAL ret = coord[0].Time + alpha*(coord[1].Time-coord[0].Time);

    tASSERT( good( ret ) );

    return ret;

Here is the call graph for this function:

Here is the caller graph for this function:

REAL gNetPlayerWall::Pos

(

REAL

a

)

const

Definition at line 2310 of file gWall.cpp.

References BegPos(), CHECKWALL, EndPos(), good(), REAL, and tASSERT.

Referenced by Check(), EndPos(), IndexAlpha(), IndexPos(), IsDangerousApartFromHoles(), real_Update(), SetEndPos(), sg_KillFutureWall(), and Time().

{
    CHECKWALL;

    tASSERT( good( a ) );

    REAL ret = BegPos() + a * ( EndPos()  - BegPos() );

    tASSERT( good( ret ) );

    return ret;

Here is the call graph for this function:

Here is the caller graph for this function:

REAL gNetPlayerWall::Alpha

(

REAL

pos

)

const

Definition at line 2323 of file gWall.cpp.

References a, BegPos(), CHECKWALL, EndPos(), REAL, and tASSERT.

Referenced by BlowHole(), and RenderList().

{
    CHECKWALL;

    REAL diff = ( EndPos()  - BegPos() );
    REAL a = pos - BegPos();

    if ( diff > 0 )
        a /= diff;

    tASSERT ( -.001 < a );
    tASSERT ( 1.001 > a );

    return a;

Here is the call graph for this function:

Here is the caller graph for this function:

bool gNetPlayerWall::IsDangerousAnywhere

(

REAL

time

)

const

Definition at line 2339 of file gWall.cpp.

References BegPos(), CHECKWALL, EndPos(), REAL, tASSERT, gCycle::WallsLength(), and gCycle::WallsStayUpDelay().

{
    CHECKWALL;

    if ( !cycle_ )
        return false;

    // is the player dead?
    if ( gCycle::WallsStayUpDelay() >= 0 )
    {
        if ( !cycle_->Alive() && time - cycle_->deathTime > .2f + gCycle::WallsStayUpDelay() )
            return false;
    }

    // is the wall behind the wall end?
    if ( gCycle::WallsLength() > 0 )
    {
        tASSERT( cycle_->MaxWallsLength() >= cycle_->ThisWallsLength() );
        REAL maxDist = cycle_->GetDistance() - cycle_->MaxWallsLength();
        if ( maxDist > EndPos()  && maxDist > BegPos() )
        {
            return false;
        }
    }

    return true;

Here is the call graph for this function:

bool gNetPlayerWall::IsDangerousApartFromHoles	(	REAL	a,
		REAL	time
	)			const

Definition at line 2367 of file gWall.cpp.

References CHECKWALL, dt, Pos(), REAL, gCycle::WallsLength(), and gCycle::WallsStayUpDelay().

Referenced by Holer(), and IsDangerous().

{
    CHECKWALL;

    // test for disappearing after death
    if ( gCycle::WallsStayUpDelay() >= 0.0f )
    {
        // walls disappeear after death
        if (!cycle_ || !cycle_->Alive() && cycle_->deathTime+ gCycle::WallsStayUpDelay()+0.2f<=time)
            return false;
    }

    // the time from the last simulation to the time the query shall be made;
    // cycleDistance is valid at cycle_->lastTime, we need it at time.
    REAL dt = ( time - cycle_->lastTime );

    // the distance value at the spot we hit
    REAL wallDistance = Pos( a );

    // test for finite wall lenght
    if ( gCycle::WallsLength() > 0 )
    {
        // the distance the cycle traveled so far
        REAL cycleDistance = cycle_->GetDistance();

        // extrapolate it, taking rubber slowdown into account
        if ( cycle_->Alive() )
        {
            // cycle movement
            cycleDistance += cycle_->WallEndSpeed() * dt;
        }

        if ( wallDistance + cycle_->ThisWallsLength() < cycleDistance )
            return false;       // hit was after the wall length
    }

    // check whether it is an extrapolated bit
    {
        // the distance the cycle traveled so far
        REAL cycleDistance = cycle_->GetDistance();

        // extrapolate it if the test time lies in the cycle's future.
        if ( cycle_->Alive() && dt > 0 )
        {
            // cycle movement
            cycleDistance += cycle_->Speed() * cycle_->rubberSpeedFactor * dt;
        }

        // is the wall ahead of the cycle?
        if ( wallDistance > cycleDistance )
            return false;
    }

    return true;

Here is the call graph for this function:

Here is the caller graph for this function:

bool gNetPlayerWall::IsDangerous	(	REAL	a,
		REAL	time
	)			const

Definition at line 2423 of file gWall.cpp.

References CHECKWALL, coords_, IndexAlpha(), gPlayerWallCoord::IsDangerous, and IsDangerousApartFromHoles().

Referenced by BlowHole(), real_Update(), and RenderList().

{
    CHECKWALL;

    if ( !IsDangerousApartFromHoles( a, time ) )
    {
        return false;
    }

    const gPlayerWallCoord* coord = &coords_(IndexAlpha(a));
    return coord->IsDangerous;

Here is the call graph for this function:

Here is the caller graph for this function:

gExplosion * gNetPlayerWall::Holer	(	REAL	a,
		REAL	time
	)			const

Definition at line 2437 of file gWall.cpp.

References CHECKWALL, coords_, gPlayerWallCoord::holer, IndexAlpha(), and IsDangerousApartFromHoles().

{
    CHECKWALL;

    // it does not count as a hole if the wall has expired already
    // for other reasons
    if ( !IsDangerousApartFromHoles( a, time ) )
    {
        return false;
    }

    const gPlayerWallCoord* coord = &coords_(IndexAlpha(a));
    return coord->holer;

Here is the call graph for this function:

void gNetPlayerWall::BlowHole	(	REAL	dbeg,
		REAL	dend,
		gExplosion *	holer
	)

Definition at line 2480 of file gWall.cpp.

References Alpha(), BegPos(), CHECKWALL, ClearDisplayList(), coords_, EndPos(), IndexPos(), IsDangerous(), GrowingArrayBase::Len(), nCLIENT, nSERVER, preliminary, REAL, nNetObject::RequestSync(), tArray< T, MALLOC >::SetLen(), sn_GetNetState(), tASSERT, and Time().

Referenced by sg_KillFutureWall().

{
    CHECKWALL;

#ifndef DEDICATED
    ClearDisplayList(60);
#endif

#ifdef DEBUG
    /*
    for ( int i = 0; i < coords_.Len(); ++i )
    {
        std::cout << "[" << coords_(i).IsDangerous << ',' << coords_(i).Pos << "]";
    }

    static int count=0;
    ++count;

    std::cout << " hole " << count << " : " << beg << ',' << end << '(' << BegPos() << ',' << EndPos() << ")\n";
    */
#endif

    // don't touch anything if the server concluded it is his business
    if ( sn_GetNetState() != nSERVER && sg_ServerSentHoles && !preliminary )
    {
        return;
    }

#ifdef DEBUG
    tASSERT (coords_.Len() < 1000 );
#endif

    // find the last index that will stay before the hole:
    int begind = IndexPos( beg );

    // skip ahead if the holing would create redunant non-dangerous blocks
    while ( begind >= 1 && !coords_[begind].IsDangerous )
    {
        beg = coords_[begind].Pos;
        begind--;
    }

    // find the last index in the hole:
    int endind = IndexPos( end );

    // skip ahead if the holing would create redunant non-dangerous blocks
    while ( endind < coords_.Len() - 2 && !coords_[endind].IsDangerous )
    {
        endind++;
        end = coords_[endind].Pos;
    }

    if ( beg < BegPos() )
    {
        begind = -1;

        beg = BegPos();
    }

    if ( end > EndPos() )
    {
        if ( bool(cycle_) && ( EndPos() < cycle_->GetDistance()-10 || this != cycle_->currentWall ) )
            endind = coords_.Len() - 1;

        end = EndPos();
    }

    // out of range
    if ( end < beg )
    {
        return;
    }

    if ( sn_GetNetState() != nCLIENT )
    {
        this->RequestSync();
    }

    // find the alpha at the hole begin and end:
    REAL begalph = Alpha( beg );
    REAL endalph = Alpha( end );

    // find the time at the hole begin and end:
    REAL begtime = Time( begalph );
    REAL endtime = Time( endalph );

    int insert = begind + 2 - endind;

#ifdef DEBUG
    tASSERT (insert < 40 );
#endif

    // remove positions inside the hole:
    if ( insert < 0 )
    {
        for ( int i = begind+1; i - insert < coords_.Len(); ++i )
            coords_(i) = coords_( i - insert );
        coords_.SetLen( coords_.Len() + insert );
    }

    // make room for the new points of the hole:
    else if ( insert > 0 )
    {
        coords_.SetLen( coords_.Len() + insert );

        for ( int i = coords_.Len() - 1; i >= begind + insert && i >= insert ; --i )
            coords_( i ) = coords_( i - insert );
    }

    // clamp times
    {
        if ( begind >= 0 )
        {
            REAL beforetime = coords_(begind).Time;
            if ( begtime < beforetime )
            {
                begtime = beforetime;
            }
        }

        if ( begind +3 < coords_.Len() )
        {
            REAL afttime = coords_(begind + 3).Time;
            if ( endtime > afttime )
            {
                endtime = afttime;
            }
        }
    }

    // enter the hole
    coords_(begind+1).IsDangerous = false;
    coords_(begind+1).Time        = begtime;
    coords_(begind+1).holer       = holer;
    coords_(begind+1).Pos         = beg;
    coords_(begind+2).Time        = endtime;
    coords_(begind+2).Pos         = end;

#ifdef DEBUG
    /*
    for ( int i = 0; i < coords_.Len(); ++i )
    {
        std::cout << "[" << coords_(i).IsDangerous << ',' << coords_(i).Pos << "]";
    }
    std::cout << "\n";
    */
#endif

    CHECKWALL;

Here is the call graph for this function:

Here is the caller graph for this function:

REAL gNetPlayerWall::BegPos

(

)

const

Definition at line 2459 of file gWall.cpp.

References CHECKWALL, and coords_.

Referenced by Alpha(), BlowHole(), cWidget::Map::DrawWalls(), IsDangerousAnywhere(), Pos(), gCycleWallsDisplayListManager::RenderAll(), and SetEndPos().

{
    CHECKWALL;

    return coords_(0).Pos;

Here is the caller graph for this function:

REAL gNetPlayerWall::EndPos

(

)

const

Definition at line 2452 of file gWall.cpp.

References CHECKWALL, coords_, GrowingArrayBase::Len(), and Pos().

Referenced by Alpha(), BlowHole(), cWidget::Map::DrawWalls(), IsDangerousAnywhere(), Pos(), real_Update(), and gCycleWallsDisplayListManager::RenderAll().

{
    CHECKWALL;

    return coords_(coords_.Len()-1).Pos;

Here is the call graph for this function:

Here is the caller graph for this function:

REAL gNetPlayerWall::BegTime

(

)

const

Definition at line 2473 of file gWall.cpp.

References CHECKWALL, and coords_.

Referenced by SetEndTime().

{
    CHECKWALL;

    return coords_(0).Time;

Here is the caller graph for this function:

REAL gNetPlayerWall::EndTime

(

)

const

Definition at line 2466 of file gWall.cpp.

References CHECKWALL, coords_, GrowingArrayBase::Len(), and Time().

{
    CHECKWALL;

    return coords_(coords_.Len()-1).Time;

Here is the call graph for this function:

const eCoord& gNetPlayerWall::EndPoint

(

int

i

)

const [inline]

Definition at line 220 of file gWall.h.

Referenced by cWidget::Map::DrawWalls(), and RenderList().

    {
        switch ( i )
        {
        case 0:
            return beg;
        case 1:
        default:
            return end;
        }
    }

Here is the caller graph for this function:

void gNetPlayerWall::Render

(

const eCamera *

cam

)

[virtual]

Definition at line 826 of file gWall.cpp.

References RenderList().

Referenced by gCycleWallsDisplayListManager::RenderAll().

                                              {
    if (!cycle_)
        return;
    RenderList(true);

Here is the call graph for this function:

Here is the caller graph for this function:

void gNetPlayerWall::RenderList	(	bool	list,
		gWallRenderMode	mode = gWallRenderMode_All
	)

Definition at line 859 of file gWall.cpp.

References a, Alpha(), b, rDisplayList::Call(), gCycleWallsDisplayListManager::CannotHaveList(), ClearDisplayList(), coords_, dbegin, displayList_, eCoord, EndPoint(), gBEG_LEN, gWallRenderMode_All, IsDangerous(), GrowingArrayBase::Len(), gPlayerWallCoord::Pos, REAL, RenderBegin(), RenderNormal(), se_GameTime(), SEGLEN, sr_CheckGLError(), Swap(), gCycle::WallsLength(), and x.

Referenced by Render(), and gCycleWallsDisplayListManager::RenderAll().

                                                                     {
    if ( !cycle_ )
    {
        return;
    }

#ifdef DEBUG_X
    if ( cycle_->Player()->GetName().StartsWith("B") && dbegin < .1 )
    {
        int x;
        x = 1;
    }
#endif
    // clear list if walls are vanishing
    // or if the wall end was reached
    // or this is the cycle's first wall
    if ( gCycleWallsDisplayListManager::CannotHaveList( dbegin, cycle_ ) ||
         this == cycle_->currentWall )
    {
        ClearDisplayList(2);
    }

    if ( !displayList_.Call() )
    {   
        //static gPerformanceCounter counter;
        //counter.Count();

        rDisplayListFiller filler( displayList_ );

        REAL r,g,b;
        if (cycle_){
            r=cycle_->trailColor_.r;
            g=cycle_->trailColor_.g;
            b=cycle_->trailColor_.b;
        }
        else
            r=g=b=1;

        eCoord P1=EndPoint(0);
        eCoord P2=EndPoint(1);

        {
            eCoord vec = P2-P1;
            REAL xs = vec.x*vec.x;
            REAL ys = vec.y*vec.y;
            REAL intensity = .7 + .3 * xs/(xs+ys);
            r *= intensity;
            g *= intensity;
            b *= intensity;
        }

        REAL a=1;

#define SEGLEN 2.5
        //REAL ta=startTime*3;
        //REAL te=endTime*3;
        for ( int i = coords_.Len()-2; i>=0; --i )
        {
            const gPlayerWallCoord* coord = &coords_(i);

            if ( !coord[0].IsDangerous )
                continue;

            REAL pa = coord[0].Pos;
            REAL pe = coord[1].Pos;

            REAL aa = Alpha( pa );
            REAL ae = Alpha( pe );

            eCoord p1 = P1 + ( P2 - P1 ) * aa;
            eCoord p2 = P1 + ( P2 - P1 ) * ae;

            REAL ta=pa/SEGLEN;
            REAL te=pe/SEGLEN;
            //REAL shift=REAL(floor((ta+te)/20)*10);

            //REAL time=ArmageTronTimer*3;
            REAL time;
            if (cycle_)
            {
                if ( cycle_->currentWall )
                    time = cycle_->currentWall->EndPos()/SEGLEN;
                else
                    time=cycle_->GetDistance()/SEGLEN;
                if ( !cycle_->Alive() )
                    time += se_GameTime() - cycle_->deathTime;
            }
            else
                time=0;

            //ta-=shift;
            //te-=shift;
            //time-=shift;

            if (ta>te){
                Swap(ta,te);
                Swap(p1,p2);
                Swap(pa,pe);
            }

            // cut the end of the wall
            if ( bool(cycle_) && gCycle::WallsLength() > 0 )
            {
                REAL cut = (cycle_->GetDistance() - cycle_->ThisWallsLength() - pe) / ( pa - pe );
                if ( cut < 0 )
                    continue;
                if ( cut < 1 )
                {
                    p1 = p2 + (p1-p2)*cut;
                    ta = te + (ta-te)*cut;
                }
            }

            if (te+gBEG_LEN<=time){
                RenderNormal(p1,p2,ta,te,r,g,b,a,renderMode);
                sr_CheckGLError();
            }

            else{ // complicated
                // can't squeeze that into a display list
                ClearDisplayList();

                if (ta+gBEG_LEN>=time){
                    sr_CheckGLError();
                    RenderBegin(p1,p2,ta,te,
                                1+(ta-time)/gBEG_LEN,
                                1+(te-time)/gBEG_LEN,
                                r,g,b,a);
                    sr_CheckGLError();
                }
                else{
                    sr_CheckGLError();
                    REAL s=((time-gBEG_LEN)-ta)/(te-ta);
                    eCoord pm=p1+(p2-p1)*s;
                    RenderBegin(pm,p2,
                                ta+(te-ta)*s,te,0,
                                1+(te-time)/gBEG_LEN,
                                r,g,b,a);
                    RenderNormal(p1,pm,ta,ta+(te-ta)*s,r,g,b,a, gWallRenderMode_All );
                    sr_CheckGLError();
                }
            }
        }
    }

Here is the call graph for this function:

Here is the caller graph for this function:

void gNetPlayerWall::RenderNormal	(	const eCoord &	x1,
		const eCoord &	x2,
		REAL	ta,
		REAL	te,
		REAL	r,
		REAL	g,
		REAL	b,
		REAL	a,
		gWallRenderMode	mode
	)			[virtual]

Definition at line 1026 of file gWall.cpp.

References BeginLines(), BeginQuads(), dt, gWallRenderMode_All, gWallRenderMode_Lines, gWallRenderMode_Quads, REAL, tListItemBase::Remove(), RenderEnd(), se_GameTime(), sr_DepthOffset(), rTextureGroups::TEX_WALL, rTextureGroups::TextureMode, upperlinecolor(), and gCycle::WallsStayUpDelay().

Referenced by RenderList().

                                                                                                                                     {
    REAL hfrac=1;

    if (bool(cycle_) && !cycle_->Alive() && gCycle::WallsStayUpDelay() >= 0 ){
        REAL dt=(se_GameTime()-cycle_->deathTime-gCycle::WallsStayUpDelay())*2;

        if (dt>1)
        {
            // remove from rendering lists
            Remove();
            return;
        }

        if (dt>=0)
        {
            REAL ca=REAL(.5/(dt+.5));
            REAL alpha=1-dt;
            if (alpha>1) alpha=1;
            hfrac=1-dt;

            r+=ca;
            b+=ca;
            g+=ca;

            a*=alpha;
        }
    }
    REAL h=1;


    if (hfrac>0){
        if ( ( mode & gWallRenderMode_Lines ) ){

            // draw additional upper line
            if ( mode == gWallRenderMode_All )
            {
                sr_DepthOffset(true);
                if ( rTextureGroups::TextureMode[rTextureGroups::TEX_WALL] != 0 )
                {
                    RenderEnd();
                    glDisable(GL_TEXTURE_2D);
                }
            }

            BeginLines();
            upperlinecolor(r,g,b,a);
            glVertex3f(p1.x,p1.y,h*hfrac);
            upperlinecolor(r,g,b,a);
            glVertex3f(p2.x,p2.y,h*hfrac);

            // in the other modes, the caller is responsible for
            // calling RenderEnd() and resetting the states.
            if ( mode == gWallRenderMode_All )
            {
                RenderEnd();
                sr_DepthOffset(false);
                if ( rTextureGroups::TextureMode[rTextureGroups::TEX_WALL] != 0 )
                    glEnable(GL_TEXTURE_2D);
            }
        }

        //glColor4f(r,g,b,a);

#ifdef XDEBUG
        REAL extrarise = 0;
        if ( this->id >= 0 )
        {
            extrarise = 1;
        }
#else
        static const REAL extrarise = 0;
#endif
        if ( mode & gWallRenderMode_Quads )
        {
            BeginQuads();

            glColor3f(r,g,b);
            glTexCoord2f(ta,hfrac);
            glVertex3f(p1.x,p1.y,extrarise);
            
            glColor3f(r,g,b);
            glTexCoord2f(ta,0);
            glVertex3f(p1.x,p1.y,extrarise + h*hfrac);
            
            glColor3f(r,g,b);
            glTexCoord2f(te,0);
            glVertex3f(p2.x,p2.y,extrarise + h*hfrac);
            
            glColor3f(r,g,b);
            glTexCoord2f(te,hfrac);
            glVertex3f(p2.x,p2.y,extrarise);

                        // in the other modes, the caller is responsible for
                        // calling RenderEnd().
                        if ( mode == gWallRenderMode_All )
                        {
                                RenderEnd();
                        }
        }
    }

Here is the call graph for this function:

Here is the caller graph for this function:

void gNetPlayerWall::RenderBegin	(	const eCoord &	x1,
		const eCoord &	x2,
		REAL	ta,
		REAL	te,
		REAL	ra,
		REAL	rb,
		REAL	r,
		REAL	g,
		REAL	b,
		REAL	a
	)			[virtual]

Definition at line 1137 of file gWall.cpp.

References afunc(), BeginLineStrip(), BeginQuadStrip(), cfunc(), dt, eCoord, gCYCLE_LEN, H, hfunc(), REAL, RenderEnd(), se_GameTime(), segs, sfunc(), sr_CheckGLError(), sr_DepthOffset(), rTextureGroups::TEX_WALL, rTextureGroups::TextureMode, upperlinecolor(), gCycle::WallsStayUpDelay(), and xfunc().

Referenced by RenderList().

                                                                                                                              {
    if ( !cycle_ )
    {
        return;
    }

    REAL hfrac=1;

    eCoord p2 = pp2;

    if (re > 1){
        if (re > 2)
            return;

        REAL ratio = (1-ra)/(re-ra);
        p2 = p1 + (pp2-p1)*ratio;
        te = ta + (te-ta)*ratio;
        re= 1;
    }

    if (bool(cycle_) && !cycle_->Alive()){
        REAL dt=(se_GameTime()-cycle_->deathTime-gCycle::WallsStayUpDelay())*2;
        if (dt>1) dt=1;
        if (dt>0)
        {
            REAL ca=REAL(.5/(dt+.5));
            REAL alpha=1-dt;
            if (alpha>1) alpha=1;
            hfrac=1-dt;

            r+=ca;
            b+=ca;
            g+=ca;
        }
        //a*=alpha;
    }

    REAL h=1;

    eCoord ppos=cycle_->PredictPosition() - cycle_->dir*REAL(gCYCLE_LEN);

    if ( hfrac>0 ){
        sr_DepthOffset(true);  
        //REAL H=h*hfrac;
#define segs 5
        upperlinecolor(r,g,b,a);//a*afunc(rat));

        if ( rTextureGroups::TextureMode[rTextureGroups::TEX_WALL] != 0 )
            glDisable(GL_TEXTURE_2D);
        
        BeginLineStrip();

        for (int i=0;i<=segs;i++){
            REAL frag=i/float(segs);
            REAL rat=ra+frag*(re-ra);
            REAL x=(p1.x+frag*(p2.x-p1.x))*(1-xfunc(rat))+ppos.x*xfunc(rat);
            REAL y=(p1.y+frag*(p2.y-p1.y))*(1-xfunc(rat))+ppos.y*xfunc(rat);

            REAL H=h*hfrac*hfunc(rat);
            upperlinecolor(r,g,b,a*afunc(rat));
            glVertex3f(x+H*cycle_->skew*sfunc(rat)*cycle_->dir.y,
                       y-H*cycle_->skew*sfunc(rat)*cycle_->dir.x,
                       H);//+se_cameraZ*.005);
        }
        RenderEnd();

        sr_DepthOffset(false);
        if ( rTextureGroups::TextureMode[rTextureGroups::TEX_WALL] != 0 )
            glEnable(GL_TEXTURE_2D);
    }

    sr_CheckGLError();
    BeginQuadStrip();

    //REAL H=h*hfrac;

    //ppos=ePlayer->pos-ePlayer->dir*gCYCLE__LEN;

    for (int i=0;i<=segs;i++){
        REAL frag=i/float(segs);
        REAL rat=ra+frag*(re-ra);
        REAL x=(p1.x+frag*(p2.x-p1.x))*(1-xfunc(rat))+ppos.x*xfunc(rat);
        REAL y=(p1.y+frag*(p2.y-p1.y))*(1-xfunc(rat))+ppos.y*xfunc(rat);

        // bottom
        glColor4f(r+cfunc(rat),g+cfunc(rat),b+cfunc(rat),a*afunc(rat));
        glTexCoord2f(ta+(te-ta)*frag,hfrac);
        glVertex3f(x,y,0);

        // top

        //glTexCoord2f(ta+(te-ta)*frag,hfrac*(1-hfunc(rat)));
        glTexCoord2f(ta+(te-ta)*frag,0);
        REAL H=h*hfrac*hfunc(rat);
        glVertex3f(x+H*cycle_->skew*sfunc(rat)*cycle_->dir.y,
                   y-H*cycle_->skew*sfunc(rat)*cycle_->dir.x,
                   H);
    }
    RenderEnd();
    sr_CheckGLError();

Here is the call graph for this function:

Here is the caller graph for this function:

bool gNetPlayerWall::ActionOnQuit

(

)

[virtual]

Reimplemented from nNetObject.

Definition at line 2030 of file gWall.cpp.

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

{
    if ( sn_GetNetState() == nSERVER )
    {
        TakeOwnership();
        return false;
    }
    else
    {
        ReleaseData();

        return true;
    }

Here is the call graph for this function:

bool gNetPlayerWall::ClearToTransmit

(

int

user

)

const [virtual]

Reimplemented from nNetObject.

Definition at line 2045 of file gWall.cpp.

References nNetObject::ClearToTransmit(), con, nNetObject::DoDebugPrint(), GridIsReady(), nNetObject::ID(), and inGrid.

                                                  {
#ifdef DEBUG
    if (nNetObject::DoDebugPrint() && bool( this->cycle_ ) )
    {
        if (!GridIsReady(user))
            con << "Not transfering gNetPlayerWall " << ID()
            << " for user " << user << " because the grid is not ready yet.\n";
        else if (!this->cycle_)
            con << "Not transfering gNetPlayerWall " << ID()
            << " for user " << user << " because it has no cycle!\n";
        else if (!this->cycle_->HasBeenTransmitted(user))
        {
            tString s;
            s << "No transfering gNetPlayerWall " << ID()
            << " for user " << user << " because ";
            this->cycle_->PrintName(s);
            s << " has not been transmitted.\n";
            con << s;
        }
    }
#endif

    return GridIsReady(user) && nNetObject::ClearToTransmit(user)
           && bool(this->cycle_) && this->cycle_->HasBeenTransmitted(user) && inGrid;

Here is the call graph for this function:

void gNetPlayerWall::WriteSync

(

nMessage &

m

)

[virtual]

Reimplemented from nNetObject.

Definition at line 2071 of file gWall.cpp.

References beg, coords_, end, inGrid, gPlayerWallCoord::IsDangerous, GrowingArrayBase::Len(), gPlayerWallCoord::Pos, tBeg, tEnd, gPlayerWallCoord::Time, nMessage::Write(), and nNetObject::WriteSync().

                                         {
    nNetObject::WriteSync(m);

    if (inGrid){
        m << end; // the far end of the eWall
        m << tEnd; // the endTime
    }
    else{
        m << beg;
        m << tBeg;
    }
    m.Write(inGrid);

    if ( coords_.Len() > 2 || !coords_(0).IsDangerous || !coords_(1).IsDangerous )
    {
        unsigned short len = coords_.Len();
        m.Write( len );
        for ( int i = len-1; i>=0; --i )
        {
            const gPlayerWallCoord& coord = coords_(i);
            m << coord.IsDangerous;
            m << coord.Pos;
            m << coord.Time;
        }
    }

Here is the call graph for this function:

void gNetPlayerWall::ReadSync

(

nMessage &

m

)

[virtual]

Reimplemented from nNetObject.

Definition at line 2106 of file gWall.cpp.

References gPlayerWall::Check(), ClearDisplayList(), coords_, CopyIntoGrid(), CreateEdge(), eCoord, nMessage::End(), griddedid, inGrid, gPlayerWallCoord::IsDangerous, GrowingArrayBase::Len(), NULL, gPlayerWallCoord::Pos, preliminary, nMessage::Read(), nNetObject::ReadSync(), REAL, real_Update(), RealWallReceived(), tArray< T, MALLOC >::SetLen(), tBeg, gPlayerWallCoord::Time, and Wall().

                                        {
    nNetObject::ReadSync(m);

    ClearDisplayList();

    REAL tEnd_new;
    eCoord end_new;

    m >> end_new;
    m >> tEnd_new;

    if ( tEnd_new < tBeg )
    {
        tEnd_new = tBeg;
    }

    unsigned short new_inGrid;
    m.Read(new_inGrid);

    if ( griddedid < 0 )
        CreateEdge();

    if ( ! m.End() )
    {
        unsigned short len;
        m.Read( len );

        coords_.SetLen( len );

        for ( int i = len-1; i>=0; --i )
        {
            gPlayerWallCoord& coord = coords_(i);
            m >> coord.IsDangerous;
            m >> coord.Pos;
            m >> coord.Time;
        }

        sg_ServerSentHoles = true;
    }

    real_Update(tEnd_new,end_new, true);

    if (Wall() && new_inGrid && !inGrid)
    {
        /*
                        if ( ( beg - end ).NormSquared() > 0.01f )
                        {
                                gExplosion::OnNewWall( Wall() );
                        }
        */

        CopyIntoGrid( NULL, true );

        if (!preliminary)
        {
            // inform preliminary walls
            for (int i=sg_netPlayerWalls.Len()-1;i>=0;i--)
            {
                gNetPlayerWall *o=sg_netPlayerWalls[i];
                if ( o != this && o->preliminary && o->cycle_ == this->cycle_ )
                {
                    o->RealWallReceived( this );
                }
            }

            // test whether this wall is newer than the last received wall in the cycle
            if ( ( 0 != this->cycle_ ) && ( !this->cycle_->lastNetWall || this->cycle_->lastNetWall->tBeg < this->tBeg ) )
            {
                this->cycle_->lastNetWall = this;
            }
        }
    }
    else
    {
        //              st_Breakpoint();
    }

#ifdef DEBUG
    if ( Wall() )
        Wall()->Check();
#endif

Here is the call graph for this function:

void gNetPlayerWall::WriteCreate

(

nMessage &

m

)

[virtual]

Reimplemented from nNetObject.

Definition at line 1932 of file gWall.cpp.

References beg, dbegin, dir, preliminary, tASSERT, tBeg, nMessage::Write(), and nNetObject::WriteCreate().

{
    tASSERT( this->cycle_ );

    nNetObject::WriteCreate(m);
    m.Write(this->cycle_->ID());
    m << beg;
    m << dir;
    m << dbegin;
    m << tBeg;
    m << static_cast<int>(preliminary);

Here is the call graph for this function:

nDescriptor & gNetPlayerWall::CreatorDescriptor

(

void

)

const [virtual]

Implements nNetObject.

Definition at line 2191 of file gWall.cpp.

References gNetPlayerWall_init.

{
    return gNetPlayerWall_init;

void gNetPlayerWall::PrintName

(

tString &

s

)

const [virtual]

Reimplemented from nNetObject.

Definition at line 2196 of file gWall.cpp.

References id.

{
    s << "gNetPlayerWall nr. " << id;
    if ( this->cycle_ )
    {
        s       << " owned by ";
        this->cycle_->PrintName( s );
    }

bool gNetPlayerWall::SyncIsNew

(

nMessage &

m

)

[virtual]

Reimplemented from nNetObject.

Definition at line 2098 of file gWall.cpp.

References nNetObject::SyncIsNew().

{
    //  return (nNetObject::SyncIsNew(m) && !inGrid);
    return nNetObject::SyncIsNew(m);

Here is the call graph for this function:

eTempEdge* gNetPlayerWall::Edge

(

)

[inline]

Definition at line 263 of file gWall.h.

{return this->edge_;}

gPlayerWall * gNetPlayerWall::Wall

(

)

Definition at line 1982 of file gWall.cpp.

References NULL.

Referenced by Clear(), MyInitAfterCreation(), PartialCopyIntoGrid(), ReadSync(), real_CopyIntoGrid(), and real_Update().

                                 {
    if (this->edge_)
    {
        eWall *w = this->edge_->Wall();

        return reinterpret_cast<gPlayerWall *>(w);
    }
    else
        return NULL;

Here is the caller graph for this function:

gCycle* gNetPlayerWall::Cycle

(

)

const [inline]

Definition at line 265 of file gWall.h.

Referenced by gCycle::Die(), cWidget::Map::DrawWalls(), and sg_KillFutureWall().

{return this->cycle_;}

Here is the caller graph for this function:

gCycleMovement * gNetPlayerWall::CycleMovement

(

)

const

Definition at line 2206 of file gWall.cpp.

                                                    {
    return cycle_;

bool gNetPlayerWall::Preliminary

(

)

const [inline]

Definition at line 268 of file gWall.h.

Referenced by gCycle::Die(), and gCycleExtrapolator::EdgeIsDangerous().

{return preliminary;}

Here is the caller graph for this function:

bool gNetPlayerWall::InGrid

(

)

const [inline]

Definition at line 269 of file gWall.h.

{return inGrid;}

void gNetPlayerWall::Clear

(

void

)

[static]

Definition at line 2210 of file gWall.cpp.

References griddedid, id, gPlayerWall::Insert(), GrowingArrayBase::Len(), ReleaseData(), tList< T, MALLOC, REFERENCE >::Remove(), sg_netPlayerWalls, sg_netPlayerWallsGridded, and Wall().

Referenced by exit_game_objects().

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

    int i;
    for (i=sg_netPlayerWalls.Len()-1;i>=0;i--){
        // sg_netPlayerWalls(i)->owner=sn_myNetID;
        //delete sg_netPlayerWalls(i);
        gNetPlayerWall* w = sg_netPlayerWalls(i);
        tControlledPTR< nNetObject > bounce( w );
        w->ReleaseData();

        sg_netPlayerWalls.Remove( w, w->id );

        if ( w->edge_ )
            w->edge_->Wall()->Insert();

    }
    for (i=sg_netPlayerWallsGridded.Len()-1;i>=0;i--){
        // sg_netPlayerWallsGridded(i)->owner=sn_myNetID;
        gNetPlayerWall* w = sg_netPlayerWallsGridded(i);
        tControlledPTR< nNetObject > bounce( w );
        w->ReleaseData();

        sg_netPlayerWallsGridded.Remove( w, w->griddedid );
    }

Here is the call graph for this function:

Here is the caller graph for this function:

void gNetPlayerWall::Check

(

)

const

Definition at line 2240 of file gWall.cpp.

References coords_, GrowingArrayBase::Len(), Pos(), tASSERT, and Time().

{
#ifdef DEBUG
    int i;
    for ( i = coords_.Len() -2 ; i>=0; --i )
    {
        gPlayerWallCoord* coords = &( coords_( i ) );
        tASSERT( coords[0].Pos <= coords[1].Pos );
        tASSERT( coords[0].Time <= coords[1].Time );
    }

    for ( i = coords_.Len() -1 ; i>=0; --i )
    {
        gPlayerWallCoord* coords = &( coords_( i ) );
        tASSERT( finite( coords[0].Pos ) );
        tASSERT( finite( coords[0].Time ) );
    }
#endif

Here is the call graph for this function:

bool gNetPlayerWall::HasDisplayList

(

)

[inline]

Definition at line 275 of file gWall.h.

References gCycle::displayList_.

    {
        return displayList_.IsSet();
    }

bool gNetPlayerWall::CanHaveDisplayList

(

)

[inline]

Definition at line 280 of file gWall.h.

References gCycle::displayList_.

Referenced by ClearDisplayList(), and gCycleWallsDisplayListManager::RenderAll().

    {
        return !displayList_.IsInhibited();
    }

Here is the caller graph for this function:

void gNetPlayerWall::ClearDisplayList	(	int	inhibitThis = 2,
		int	inhibitCycle = 0
	)

clears the display list

Definition at line 1317 of file gWall.cpp.

References CanHaveDisplayList(), rDisplayList::Clear(), and displayList_.

Referenced by BlowHole(), ReadSync(), real_CopyIntoGrid(), gCycleWallsDisplayListManager::RenderAll(), RenderList(), and ~gNetPlayerWall().

{
#ifndef DEDICATED
    if ( CanHaveDisplayList() && cycle_ && inhibitCycle >= 0 )
    {
        cycle_->displayList_.Clear( inhibitCycle );
    }
    displayList_.Clear( inhibitThis );
#endif

Here is the call graph for this function:

Here is the caller graph for this function:

---

Friends And Related Function Documentation

friend class gCycle [friend]

Definition at line 152 of file gWall.h.

---

Member Data Documentation

int gNetPlayerWall::id [private]

Reimplemented from nNetObject.

Definition at line 153 of file gWall.h.

Referenced by Clear(), and PrintName().

int gNetPlayerWall::griddedid [private]

Definition at line 153 of file gWall.h.

Referenced by Clear(), MyInitAfterCreation(), PartialCopyIntoGrid(), ReadSync(), real_CopyIntoGrid(), ReleaseData(), and s_CopyIntoGrid().

gPlayerWall* gNetPlayerWall::lastWall_ [private]

Definition at line 157 of file gWall.h.

Referenced by PartialCopyIntoGrid(), and real_Update().

eCoord gNetPlayerWall::dir [private]

the last wall that was dropped into the grid by PartialCopyIntoGrid()

Definition at line 159 of file gWall.h.

Referenced by gNetPlayerWall(), real_Update(), RealWallReceived(), and WriteCreate().

REAL gNetPlayerWall::dbegin [private]

Definition at line 160 of file gWall.h.

Referenced by gNetPlayerWall(), InitArray(), real_Update(), RenderList(), and WriteCreate().

eCoord gNetPlayerWall::beg [private]

Definition at line 161 of file gWall.h.

Referenced by CreateEdge(), gNetPlayerWall(), InitArray(), MyInitAfterCreation(), real_Update(), WriteCreate(), and WriteSync().

eCoord gNetPlayerWall::end [private]

Definition at line 161 of file gWall.h.

Referenced by CreateEdge(), gNetPlayerWall(), InitArray(), MyInitAfterCreation(), PartialCopyIntoGrid(), real_Update(), and WriteSync().

REAL gNetPlayerWall::tBeg [private]

Definition at line 162 of file gWall.h.

Referenced by gNetPlayerWall(), InitArray(), ReadSync(), real_Update(), RealWallReceived(), WriteCreate(), and WriteSync().

REAL gNetPlayerWall::tEnd [private]

Definition at line 162 of file gWall.h.

Referenced by CopyIntoGrid(), InitArray(), real_Update(), RealWallReceived(), and WriteSync().

unsigned short gNetPlayerWall::inGrid [private]

Definition at line 164 of file gWall.h.

Referenced by ClearToTransmit(), CopyIntoGrid(), ReadSync(), s_CopyIntoGrid(), Update(), and WriteSync().

REAL gNetPlayerWall::gridding [private]

Definition at line 165 of file gWall.h.

Referenced by CopyIntoGrid(), gNetPlayerWall(), RealWallReceived(), and s_CopyIntoGrid().

bool gNetPlayerWall::preliminary [private]

Definition at line 166 of file gWall.h.

Referenced by BlowHole(), CopyIntoGrid(), gNetPlayerWall(), PartialCopyIntoGrid(), ReadSync(), real_CopyIntoGrid(), RealWallReceived(), Update(), and WriteCreate().

REAL gNetPlayerWall::obsoleted_ [private]

Definition at line 167 of file gWall.h.

Referenced by CopyIntoGrid(), gNetPlayerWall(), and RealWallReceived().

tArray<gPlayerWallCoord> gNetPlayerWall::coords_ [private]

Definition at line 288 of file gWall.h.

Referenced by BegPos(), BegTime(), BlowHole(), Check(), Checkpoint(), EndPos(), EndTime(), Holer(), IndexPos(), InitArray(), IsDangerous(), MyInitAfterCreation(), ReadSync(), real_Update(), RenderList(), SetEndPos(), SetEndTime(), Time(), and WriteSync().

rDisplayList gNetPlayerWall::displayList_ [private]

Definition at line 290 of file gWall.h.

Referenced by ClearDisplayList(), MyInitAfterCreation(), and RenderList().

---

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

• src/tron/gWall.h
• src/tron/gWall.cpp

---