gExplosion Class Reference

#include <gExplosion.h>

Inheritance diagram for gExplosion:

[legend]

Collaboration diagram for gExplosion:

[legend]

List of all members.

Public Member Functions
	gExplosion (eGrid *grid, const eCoord &pos, REAL time, gRealColor &color, gCycle *owner)
virtual	~gExplosion ()
virtual bool	Timestep (REAL currentTime)
virtual void	InteractWith (eGameObject *target, REAL time, int recursion=1)
virtual void	PassEdge (const eWall *w, REAL time, REAL a, int recursion=1)
virtual void	Kill ()
	destroys the gameobject (in the game)
virtual void	Render (const eCamera *cam)
	draws object to the screen using OpenGL
virtual void	Render2D (tCoord scale) const
bool	AccountForHole ()
gCycle *	GetOwner () const
Static Public Member Functions
static void	OnNewWall (eWall *w)
Public Attributes
int	particle_handle_circle
int	particle_handle_cylinder
Protected Member Functions
virtual void	OnRemoveFromGame ()
	called on RemoveFromGame(). Call base class implementation, too, in your implementation. Must keep the object alive.
Private Attributes
REAL	createTime
REAL	explosion_r
REAL	explosion_g
REAL	explosion_b
int	expansion
bool	holeAccountedFor_
	flag indicating whether we already gave the player credit for making a hole for his teammates
int	listID
tJUST_CONTROLLED_PTR< gCycle >	owner_
Static Private Attributes
static int	expansionSteps = 5
static REAL	expansionTime = 0.2f

---

Detailed Description

Definition at line 36 of file gExplosion.h.

---

Constructor & Destructor Documentation

gExplosion::gExplosion	(	eGrid *	grid,
		const eCoord &	pos,
		REAL	time,
		gRealColor &	color,
		gCycle *	owner
	)

Definition at line 141 of file gExplosion.cpp.

References tList< T, MALLOC, REFERENCE >::Add(), eGameObject::AddToList(), gRealColor::b, CYCLE_EXPLOSION, explosion_b, explosion_g, explosion_r, gRealColor::g, eSoundMixer::GetMixer(), holeAccountedFor_, eGameObject::lastTime, listID, eSoundMixer::PushButton(), gRealColor::r, and eGameObject::z.

        :eReferencableGameObject(grid, pos, eCoord(0,0), NULL, true),
        createTime(time),
        expansion(0),
        listID(-1),
        owner_(owner) 
{
    eSoundMixer* mixer = eSoundMixer::GetMixer();
    mixer->PushButton(CYCLE_EXPLOSION, pos);
    //std::cout << "explosion sound effect\n";
    holeAccountedFor_ = false;

    lastTime = time;
    explosion_r = color.r;
    explosion_g = color.g;
    explosion_b = color.b;
    //std::cout << "about to do sg_Explosions.Add\n";
    sg_Explosions.Add( this, listID );
    z=0;
    //std::cout << "explosion constructed\n";
#ifdef USEPARTICLES
    //std::cout << "Using particle explosion\n";
    //    particle_handle_circle = pGenParticleGroups(1, 10);
    //    particle_handle_cylinder = pGenParticleGroups(1, 1000);

    //    pCurrentGroup(particle_handle_circle);
    // Generate particles along a very small line in the nozzle.
    //    pSource(1000, PDSphere(pVec(pos.x, pos.y, 0.3), 0.2));
    //    pCurrentGroup(particle_handle_cylinder);
    // Generate particles along a very small line in the nozzle.
    //    pSource(1000, PDSphere(pVec(Position().x, Position().y, 0.3), 0.2));
#endif

    // add to game object lists
    AddToList();
    //std::cout << "Last line of constructor\n";
}

Here is the call graph for this function:

gExplosion::~gExplosion

(

)

[virtual]

Definition at line 179 of file gExplosion.cpp.

References listID, tList< T, MALLOC, REFERENCE >::Remove(), and s_explosionRadius.

                       {
    sg_Explosions.Remove( this, listID );

    if ( s_explosionRadius > 0 )
    {
        /*
        s_explosionCoord  = pos;
        s_explosionRadius = gCycle::ExplosionRadius()*1.5f;

        grid->ProcessWallsInRange( &S_Sync,
                                                           s_explosionCoord,
                                                           s_explosionRadius,
                                                           this->CurrentFace() );
        */
    }
}

Here is the call graph for this function:

---

Member Function Documentation

bool gExplosion::Timestep

(

REAL

currentTime

)

[virtual]

Reimplemented from eGameObject.

Definition at line 199 of file gExplosion.cpp.

References createTime, expansion, expansionSteps, expansionTime, gCycle::ExplosionRadius(), eGameObject::lastTime, eGameObject::pos, REAL, S_BlowHoles(), s_explosionCoord, s_explosionRadius, s_explosionTime, and sqrt().

                                         {
    lastTime=currentTime;

    int currentExpansion = int(REAL( expansionSteps )*((currentTime - createTime)/expansionTime)) + 1;
    if ( currentExpansion > expansionSteps )
        currentExpansion = expansionSteps;

    if ( currentExpansion > expansion )
    {
        expansion = currentExpansion;

        s_explosionCoord  = pos;
        REAL factor = expansion / REAL( expansionSteps );
        s_explosionRadius = gCycle::ExplosionRadius() * sqrt(factor);
        s_explosionTime = currentTime;
        s_holer = this;

        if ( s_explosionRadius > 0 && (currentTime < createTime+4) )
        {
            grid->ProcessWallsInRange( &S_BlowHoles,
                                       s_explosionCoord,
                                       s_explosionRadius,
                                       this->CurrentFace() );
        }

        s_holer = 0;
    }
#ifndef USEPARTICLES

    /*
        // see every once in a while if all cycles did a turn since the expl was created
        if ( expansion >= expansionSteps )
        {
                currentExpansion = expansionSteps + 1 + int( REAL( expansion ) * ( currentTime - createTime ) );
        }
        if ( currentExpansion > expansion )
        {
                expansion = currentExpansion;
                REAL time = createTime + 5.0f;

                const tList<eGameObject>& gameObjects = this->Grid()->GameObjects();
                for ( int i = gameObjects.Len() - 1; i>=0; --i )
                {
                        eGameObject* o = gameObjects( i );

                        gCycle* c = dynamic_cast< gCycle* >( o );
                        if ( c && c->Alive() )
                        {
                                const gPlayerWall* w = c->CurrentWall();

                                if ( !w || w->BegTime() < time || w->EndTime() < time )
                                {
                                        // c has not made a turn; we need to stay around some more
                                        return false;
                                }
                        }
                }
        }
    */
    if (currentTime>createTime+4)
        return true;
    else
        return false;
#else
    /*    pCurrentGroup(particle_handle_circle);
    // Set up the state.
    pExplosion(Position().x, Position().y, 0.3, 20.0, 20.0, 1.0);
    //pVelocityD(PDCylinder(pVec(0.0, 0.0, 0.0), pVec(0.0, 0.0, 0.01), 0.01, 0.007));
    pColorD(PDLine(pVec(1.0, 1.0, 1.0), pVec(1.0, 1.0, 1.0)));
    pSize(40.0);
    //pStartingAge(0);

    //pRandomAccel(PDSphere(pVec(Position().x, Position().y, 0.0), 100.0));

    // Bounce particles off the grid floor.
    pBounce(-0.05, 1.0, 0.1, PDDisc(pVec(0, 0, 0), pVec(0, 0, 1), 5000000));

    pKillOld(400.0);

    // Move particles to their new positions.
    pMove();

    // Finished when there are less than 1/10 of the original particles
    if (pGetGroupCount() < 100) {
    pDeleteParticleGroups(particle_handle_circle, particle_handle_circle);
    return true;
    } else
    return false;*/
    //std::cout << "returning from timestep\n";
    if (currentTime>createTime+4)
        return true;
    else
        return false;
#endif

Here is the call graph for this function:

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

Reimplemented from eGameObject.

Definition at line 295 of file gExplosion.cpp.

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

Reimplemented from eGameObject.

Definition at line 297 of file gExplosion.cpp.

void gExplosion::Kill

(

)

[virtual]

destroys the gameobject (in the game)

Reimplemented from eGameObject.

Definition at line 299 of file gExplosion.cpp.

References createTime, and eGameObject::lastTime.

                     {
    createTime=lastTime-100;

void gExplosion::Render

(

const eCamera *

cam

)

[virtual]

draws object to the screen using OpenGL

Reimplemented from eGameObject.

Definition at line 364 of file gExplosion.cpp.

References BeginLines(), createTime, explosion_b, explosion_g, explosion_r, eGameObject::lastTime, GrowingArrayBase::Len(), ModelMatrix(), eGameObject::pos, REAL, RenderEnd(), sg_crashExplosion, and x.

                                         {
    //std::cout << "Starting render\n";
#ifdef USEPARTICLES
    /*if(sg_crashExplosion){
        ModelMatrix();
        glPushMatrix();
        pCurrentGroup(particle_handle_circle);
        int cnt = (int)pGetGroupCount();
        if(cnt < 1) return;

        float *ptr;
        size_t flstride, pos3Ofs, posB3Ofs, size3Ofs, vel3Ofs, velB3Ofs, color3Ofs, alpha1Ofs, age1Ofs;

        cnt = (int)pGetParticlePointer(ptr, flstride, pos3Ofs, posB3Ofs,
            size3Ofs, vel3Ofs, velB3Ofs, color3Ofs, alpha1Ofs, age1Ofs);
        if(cnt < 1) return;

        glEnableClientState(GL_COLOR_ARRAY);
        glColorPointer(4, GL_FLOAT, int(flstride) * sizeof(float), ptr + color3Ofs);

        glEnableClientState(GL_VERTEX_ARRAY);
        glVertexPointer(3, GL_FLOAT, int(flstride) * sizeof(float), ptr + pos3Ofs);

        glDrawArrays(GL_POINTS, 0, cnt);
        glDisableClientState(GL_VERTEX_ARRAY);
        glDisableClientState(GL_COLOR_ARRAY);
        glPopMatrix();
    }*/
#else
    if (sg_crashExplosion){
        REAL a1=(lastTime-createTime)+.01f;//+.2;
        REAL e=a1-1;

        if (e<0) e=0;

        REAL fade=(2-a1);
        if (fade<0) fade=0;
        if (fade>1) fade=1;

        a1*=100;
        e*=100;

        ModelMatrix();
        glPushMatrix();
        glTranslatef(pos.x,pos.y,0);

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

        glColor4f(explosion_r,explosion_g,explosion_b,fade);
        BeginLines();
        for (int i=expvec.Len()-1;i>=0;i--){
            glVertex3f(a1*expvec[i].x[0],a1*expvec[i].x[1],a1*expvec[i].x[2]);
            glVertex3f( e*expvec[i].x[0], e*expvec[i].x[1], e*expvec[i].x[2]);
        }
        RenderEnd();
        glPopMatrix();
    }
    /*
    if(sr_alphaBlend)
    for(int i=2;i>=0;i--){
    REAL age=a1-i*.1;
    if (0<age && age<.5){
    REAL alpha=(3-i)*.5*(1-age*2)*(1-age*2);
    glColor4f(r,g,b,alpha);
    glDisable(GL_LIGHTING);
    glDisable(GL_TEXTURE_2D);
    glMatrixMode(GL_MODELVIEW);
    glPushMatrix();
    glTranslatef(pos.x,pos.y,age*pow((age+1),3)*(age+.5)*100);
    y

    GLUquadricObj* q= gluNewQuadric();

    gluSphere(q,(age*pow((age+1),3)*(age+.5))*100,5,5);

    gluDeleteQuadric( q );

    glPopMatrix();
    }
    }
    */
#endif
    //std::cout << "Finishing render\n";

Here is the call graph for this function:

void gExplosion::Render2D

(

tCoord

scale

)

const [virtual]

Reimplemented from eGameObject.

Definition at line 450 of file gExplosion.cpp.

References BeginLines(), createTime, explosion_b, explosion_g, explosion_r, eGameObject::lastTime, GrowingArrayBase::Len(), ModelMatrix(), eGameObject::pos, REAL, RenderEnd(), sg_crashExplosionHud, and x.

                                            {
#ifndef DEDICATED
    if(sg_crashExplosionHud){
        REAL a1=(lastTime-createTime)+.01f;//+.2;
        REAL e=a1-1;

        if (e<0) e=0;

        REAL fade=(2-a1);
        if (fade<0) fade=0;
        if (fade>1) fade=1;

        a1*=100;
        e*=100;

        ModelMatrix();
        glPushMatrix();
        glTranslatef(pos.x,pos.y,0);

        glDisable(GL_TEXTURE_2D);

        glColor4f(explosion_r,explosion_g,explosion_b,fade);
        BeginLines();
        for(int i=expvec.Len()-1;i>=0;i--){
            glVertex2f(a1*expvec[i].x[0],a1*expvec[i].x[1]);
            glVertex2f( e*expvec[i].x[0], e*expvec[i].x[1]);
        }
        RenderEnd();
        glPopMatrix();
    }
#endif
    //std::cout << "Finishing render\n";

Here is the call graph for this function:

bool gExplosion::AccountForHole

(

)

Definition at line 303 of file gExplosion.cpp.

References holeAccountedFor_.

Referenced by gCycle::PassEdge().

{
    bool ret = !holeAccountedFor_;
    holeAccountedFor_ = true;
    return ret;

Here is the caller graph for this function:

void gExplosion::OnNewWall

(

eWall *

w

)

[static]

Definition at line 310 of file gExplosion.cpp.

References createTime, expansion, expansionSteps, gCycle::ExplosionRadius(), GrowingArrayBase::Len(), eGameObject::pos, S_BlowHoles(), s_explosionCoord, s_explosionRadius, s_explosionTime, and sg_Explosions.

{
    for ( int i = sg_Explosions.Len() - 1; i>=0; --i )
    {
        const gExplosion* e = sg_Explosions(i);
        if ( e->expansion >= expansionSteps )
        {
            // e is a already completed explosion
            s_explosionCoord  = e->pos;
            s_explosionRadius = gCycle::ExplosionRadius();
            s_explosionTime = e->createTime;

            S_BlowHoles( w );
        }
    }

Here is the call graph for this function:

gCycle* gExplosion::GetOwner

(

)

const [inline]

Definition at line 67 of file gExplosion.h.

References owner_.

Referenced by gCycle::PassEdge().

    {
        return owner_;
    }

Here is the caller graph for this function:

void gExplosion::OnRemoveFromGame

(

)

[protected, virtual]

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

Reimplemented from eGameObject.

Definition at line 495 of file gExplosion.cpp.

References listID, eGameObject::OnRemoveFromGame(), and tList< T, MALLOC, REFERENCE >::Remove().

{
    // remove from list to avoid costy checks whenever a new wall appears
    sg_Explosions.Remove( this, listID );

    // delegate to base
    eReferencableGameObject::OnRemoveFromGame();

Here is the call graph for this function:

---

Member Data Documentation

int gExplosion::particle_handle_circle

Definition at line 62 of file gExplosion.h.

int gExplosion::particle_handle_cylinder

Definition at line 63 of file gExplosion.h.

REAL gExplosion::createTime [private]

Definition at line 76 of file gExplosion.h.

Referenced by Kill(), OnNewWall(), Render(), Render2D(), and Timestep().

REAL gExplosion::explosion_r [private]

Definition at line 79 of file gExplosion.h.

Referenced by gExplosion(), Render(), and Render2D().

REAL gExplosion::explosion_g [private]

Definition at line 80 of file gExplosion.h.

Referenced by gExplosion(), Render(), and Render2D().

REAL gExplosion::explosion_b [private]

Definition at line 81 of file gExplosion.h.

Referenced by gExplosion(), Render(), and Render2D().

int gExplosion::expansion [private]

Definition at line 83 of file gExplosion.h.

Referenced by OnNewWall(), and Timestep().

int gExplosion::expansionSteps = 5 [static, private]

Definition at line 85 of file gExplosion.h.

Referenced by OnNewWall(), and Timestep().

REAL gExplosion::expansionTime = 0.2f [static, private]

Definition at line 86 of file gExplosion.h.

Referenced by Timestep().

bool gExplosion::holeAccountedFor_ [private]

flag indicating whether we already gave the player credit for making a hole for his teammates

Definition at line 88 of file gExplosion.h.

Referenced by AccountForHole(), and gExplosion().

int gExplosion::listID [private]

Definition at line 90 of file gExplosion.h.

Referenced by gExplosion(), OnRemoveFromGame(), and ~gExplosion().

tJUST_CONTROLLED_PTR< gCycle > gExplosion::owner_ [private]

Definition at line 92 of file gExplosion.h.

Referenced by GetOwner().

---

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

• src/tron/gExplosion.h
• src/tron/gExplosion.cpp

---