structs.cpp

Go to the documentation of this file.

//
// Das Tank - Copyright (C) 2006, 2007 Windsor Schmidt <windsor@windsorworld.net>
//
// This program is free software; you can redistribute it and/or modify it
// under the terms of the GNU General Public License as published by the Free
// Software Foundation; either version 2 of the License, or (at your option)
// any later version.
//
// This program is distributed in the hope that it will be useful, but WITHOUT
// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
// more details.
//
// You should have received a copy of the GNU General Public License along with
// this program; if not, write to the Free Software Foundation, Inc., 59 Temple
// Place, Suite 330, Boston, MA 02111-1307 USA
//


#ifndef STDAFX
#include "stdafx.h"
#endif


CVector2D::CVector2D(void)
{
       x = 0;
       y = 0;
}


CEffect::~CEffect(void)
{
       if(PSys) { delete PSys; }
       if(SWave) { delete SWave; }
}


CEffect::CEffect(int type)
{
       bExpired = false;
       
       PSys = NULL;
       SWave = NULL;
       MShock = NULL;
       TAnim = NULL;
       TStorm = NULL;

       Previous = NULL;
       Next = NULL;

       // the effect object is just a flyweight, here we init the object it points to
       switch(type)
       {
       case EFFECTID_NULL:
              iType = EFFECTID_NULL;
              break;

       case EFFECTID_PSYSTEM:
              iType = EFFECTID_PSYSTEM;
              break;

       case EFFECTID_SHOCKWAVE:
              iType = EFFECTID_SHOCKWAVE;
              break;

       case EFFECTID_TILESTORM:
              iType = EFFECTID_TILESTORM;
              break;

       case EFFECTID_TILEANIM:
              iType = EFFECTID_TILEANIM;
              break;

       case EFFECTID_MINISHOCK:
              iType = EFFECTID_MINISHOCK;
       }
}


void CEffect::Draw(void)
{
       // the effect object is just a flyweight, here we draw the object it points to
       switch(iType)
       {
       case EFFECTID_NULL:
              break;

       case EFFECTID_PSYSTEM:
              PSys->Draw();
              break;

       case EFFECTID_SHOCKWAVE:
              SWave->Draw();
              break;

       case EFFECTID_TILESTORM:
              TStorm->Draw();
              break;

       case EFFECTID_TILEANIM:
              TAnim->Draw();
              break;

       case EFFECTID_MINISHOCK:
              MShock->Draw();
              break;
       }
}


bool CEffect::Step(float timeDelta)
{
       bool rVal = false;

       // the effect object is just a flyweight, here we time-step the object it points to
       switch(iType)
       {
       case EFFECTID_NULL:
              break;

       case EFFECTID_PSYSTEM:
              rVal = PSys->Step(timeDelta);
              break;

       case EFFECTID_SHOCKWAVE:
              rVal = SWave->Step(timeDelta);
              break;

       case EFFECTID_TILESTORM:
              rVal = TStorm->Step(timeDelta);
              break;

       case EFFECTID_TILEANIM:
              rVal = TAnim->Step(timeDelta);
              break;
              
       case EFFECTID_MINISHOCK:
              rVal = MShock->Step(timeDelta);
       }

       return rVal;
}


CWorld::CWorld(void)
{
       Objects = NULL; // important to ground the list pointers!
       PSystems = NULL;
       Effects = NULL;

       int iX;
       for(iX = 0; iX < NUM_PLAYERS; iX++)
       {
              Player[iX] = NULL;
       }
       bGameOver = false;
       bTakeInput = true;
       iStartingState = STARTINGSTATE_IDLE;
       iRenderStyle = DEFAULT_RENDERSTYLE;
       fZoomBias = 0.5;
       iObjectCount = 0;
       iEffectCount = 0;
       iNumCollisions = 0;
       Uint32 iCurrentTime = 0; // milliseconds since SDL init
       Uint32 iOldTime = 0;
       musicFile = (char *) malloc(sizeof(char) * 256);
}


int CWorld::AddObject(CObject * Obj)
{
       if (Objects == NULL) // add the first object in the list
       {
              Objects = Obj;
       }
       else // add to the end of the list
       {
              CObject * Current = Objects;
              while(Current->Next != NULL)
              {
                     Current = Current->Next; // traverse the list
              }
              Current->Next = Obj; // add this object to the end of the list
              Obj->Previous = Current; // and create a back-link from the current object
       }

       iObjectCount++;

       return 0; // success
}


int CWorld::RemoveObject(CObject * Obj)
{
       if(Obj == NULL) return DAS_ERROR; // error!

       if(Obj->Owner != NULL) Obj->Owner->iOwnCount--; // owner doesn't own this after it's gone

       CObject * Current = Obj;

       if((Obj->Previous == NULL) && (Obj->Next == NULL)) // deleting only object in the list
       {
              Objects = NULL;
              delete Obj;
              iObjectCount--;
              return 0;
       }

       if(Obj->Previous == NULL) // deleting the object at the beginning of the list
       {
              Objects = Obj->Next;
              Obj->Next->Previous = NULL;
              delete Obj;
              iObjectCount--;
              return 0;
       }

       if(Obj->Next == NULL) // deleting the object at the end of the list
       {
              Obj->Previous->Next = NULL;
              delete Obj;
              iObjectCount--;
              return 0;
       }

       // deleting an object somewhere in the middle of the list
       Obj->Previous->Next = Obj->Next;
       Obj->Next->Previous = Obj->Previous;
       delete Obj;

       iObjectCount--;

       return 0; // success
}


int CWorld::AddEffect(CEffect * Effect)
{
       if (Effects == NULL) // add the first PSystem in the list
       {
              Effects = Effect;
       }
       else // add to the end of the list
       {
              CEffect * Current = Effects;
              while(Current->Next != NULL)
              {
                     Current = Current->Next; // traverse the list
              }
              Current->Next = Effect; // add this object to the end of the list
              Effect->Previous = Current; // and create a back-link from the current object
              Effect->Next = NULL; // should already be null on construct, but hey
       }

       iEffectCount++;

       return 0; // success
}


int CWorld::RemoveEffect(CEffect * Effect)
{
       if(Effect == NULL) return DAS_ERROR; // error!

       CEffect * Current = Effects;

       if((Effect->Previous == NULL) && (Effect->Next == NULL)) // deleting only object in the list
       {
              Effects = NULL;
              delete Effect;
              iEffectCount--;
              return 0;
       }

       if(Effect->Previous == NULL) // deleting the object at the beginning of the list
       {
              Effects = Effect->Next;
              Effects->Previous = NULL;
              delete Effect;
              iEffectCount--;
              return 0;
       }

       if(Effect->Next == NULL) // deleting the object at the end of the list
       {
              Effect->Previous->Next = NULL;
              delete Effect;
              iEffectCount--;
              return 0;
       }

       // deleting an object somewhere in the middle of the list
       Effect->Previous->Next = Effect->Next;
       Effect->Next->Previous = Effect->Previous;
       delete Effect;

       iEffectCount--;

       return 0; // success
}


void CWorld::UpdateEffects(float timeDelta)
{
       CEffect * Current = Effects;
       CEffect * Temp = NULL;

       while(Current != NULL)
       {
              if(Current->bExpired) // particle system is dead, remove it
              {
                     Temp = Current->Next;
                     RemoveEffect(Current);
                     Current = Temp; // move down the list
              }
              else
              {
                     Current->bExpired = Current->Step(timeDelta);
                     Current = Current->Next; // move down the list
              }
       }
}


void CWorld::DrawEffects(void)
{
       CEffect * Current = Effects;

       while(Current != NULL)
       {
              if(!Current->bExpired)
              {
                     Current->Draw();
              }

              Current = Current->Next;
       }
}


int CWorld::LoadLevel(const char * filename)
{
       char string[256];
       char currentChar = NULL;
       int charsRead = 0;
       FILE * file = NULL;
       int cellType = 0;
       int iX, iY, iZ = 0; // index vars
       CObject * NewObj = NULL;

       // open level file
       fopen_s(&file, filename, "r" );
       if(file == NULL) return DAS_ERROR;

       // read in tile map
       for(iY = MAP_SIZE-1; iY>=0; iY--) // for each row (read these in backwards for correct placement)
       {
              for(iX = 0; iX < MAP_SIZE; iX++) // for each cell on that row
              {
                     for(iZ=0; iZ<256; iZ++) // read in this cell's data
                     {
                            fread(&currentChar, 1, 1, file);

                            if(currentChar == 9 || currentChar == 10) // tab or newline
                            {
                                   string[iZ] = 0;
                                   break;
                            }
                            else // another character
                            {
                                   string[iZ] = currentChar;
                            }

                            cellType = atoi(string);
                     }

                     switch(cellType)
                     {
                     case TILEID_NULL:
                            this->tiles[(iY * MAP_SIZE) + iX].iType = TILEID_NULL;
                            this->tiles[(iY * MAP_SIZE) + iX].iTexture = TEXID_NULL;
                            break;

                     case TILEID_BLANK:
                            this->tiles[(iY * MAP_SIZE) + iX].iType = TILEID_BLANK;
                            this->tiles[(iY * MAP_SIZE) + iX].iTexture = TEXID_GRID;
                            break;

                     case TILEID_DIRT:
                            this->tiles[(iY * MAP_SIZE) + iX].iType = TILEID_DIRT;
                            this->tiles[(iY * MAP_SIZE) + iX].iTexture = TEXID_DIRT;
                            break;

                     case TILEID_SAND:
                            this->tiles[(iY * MAP_SIZE) + iX].iType = TILEID_SAND;
                            this->tiles[(iY * MAP_SIZE) + iX].iTexture = TEXID_SAND;
                            break;

                     case TILEID_MUD:
                            this->tiles[(iY * MAP_SIZE) + iX].iType = TILEID_MUD;
                            this->tiles[(iY * MAP_SIZE) + iX].iTexture = TEXID_MUD;
                            break;

                     case TILEID_WATER:
                            this->tiles[(iY * MAP_SIZE) + iX].iType = TILEID_WATER;
                            this->tiles[(iY * MAP_SIZE) + iX].iTexture = TEXID_WATER;
                            this->tiles[(iY * MAP_SIZE) + iX].bPassable = false;
                            break;

                     case TILEID_LAVA:
                            this->tiles[(iY * MAP_SIZE) + iX].iType = TILEID_LAVA;
                            this->tiles[(iY * MAP_SIZE) + iX].iTexture = TEXID_LAVA;
                            this->tiles[(iY * MAP_SIZE) + iX].iTileEffect = TILE_EFFECT_DAMAGE;
                            this->tiles[(iY * MAP_SIZE) + iX].iDamage = TILE_DAMAGE_LAVA;
                            break;

                     case TILEID_ICE:
                            this->tiles[(iY * MAP_SIZE) + iX].iType = TILEID_ICE;
                            this->tiles[(iY * MAP_SIZE) + iX].iTexture = TEXID_ICE;
                            break;

                     case TILEID_TARMAC:
                            this->tiles[(iY * MAP_SIZE) + iX].iType = TILEID_TARMAC;
                            this->tiles[(iY * MAP_SIZE) + iX].iTexture = TEXID_TARMAC;
                            break;

                     case TILEID_GRASS:
                            this->tiles[(iY * MAP_SIZE) + iX].iType = TILEID_GRASS;
                            this->tiles[(iY * MAP_SIZE) + iX].iTexture = TEXID_GRASS;
                            break;
                     }
              }
       }

       // skip the following newline (blank line)
       //fread(&currentChar, 1, 1, file); // newline

       // read in object map
       for(iY = 0; iY < MAP_SIZE; iY++) // for each row
       {
              for(iX = MAP_SIZE -1; iX >= 0; iX--) // for each cell on that row
              {
                     for(iZ=0; iZ<256; iZ++) // read in this cell's data
                     {
                            fread(&currentChar, 1, 1, file);

                            if(currentChar == 9 || currentChar == 10) // tab or newline
                            {
                                   string[iZ] = 0;
                                   break;
                            }
                            else // another char
                            {
                                   string[iZ] = currentChar;
                                   string[iZ+1] = 0;
                            }

                            cellType = atoi(string);
                     }

                     switch(cellType)
                     {
                     case TYPEID_POWERUP_HEALTH:
                            NewObj = new CObject(TYPEID_POWERUP_HEALTH, this);
                            NewObj->Position.x = iX * CELL_SIZE + CELL_SIZE / 2;
                            NewObj->Position.y = iY * CELL_SIZE + CELL_SIZE / 2;
                            NewObj->iRemovalEffects = 2;
                            NewObj->iRemovalEffect[0] = EFFECTID_TILEANIM;
                            NewObj->iRemovalEffect[1] = EFFECTID_SHOCKWAVE;
                            NewObj->iRemovalAnim = ANIMID_CRATECRUSH;
                            this->AddObject(NewObj);
                            break;

                     case TYPEID_POWERUP_PS:
                            NewObj = new CObject(TYPEID_POWERUP_PS, this);
                            NewObj->Position.x = iX * CELL_SIZE + CELL_SIZE / 2;
                            NewObj->Position.y = iY * CELL_SIZE + CELL_SIZE / 2;
                            NewObj->iRemovalEffects = 2;
                            NewObj->iRemovalEffect[0] = EFFECTID_TILEANIM;
                            NewObj->iRemovalEffect[1] = EFFECTID_SHOCKWAVE;
                            NewObj->iRemovalAnim = ANIMID_CRATECRUSH;
                            this->AddObject(NewObj);
                            break;

                     case TYPEID_POWERUP_BS:
                            NewObj = new CObject(TYPEID_POWERUP_BS, this);
                            NewObj->Position.x = iX * CELL_SIZE + CELL_SIZE / 2;
                            NewObj->Position.y = iY * CELL_SIZE + CELL_SIZE / 2;
                            NewObj->iRemovalEffects = 2;
                            NewObj->iRemovalEffect[0] = EFFECTID_TILEANIM;
                            NewObj->iRemovalEffect[1] = EFFECTID_SHOCKWAVE;
                            NewObj->iRemovalAnim = ANIMID_CRATECRUSH;
                            this->AddObject(NewObj);
                            break;

                     case TYPEID_POWERUP_SB:
                            NewObj = new CObject(TYPEID_POWERUP_SB, this);
                            NewObj->Position.x = iX * CELL_SIZE + CELL_SIZE / 2;
                            NewObj->Position.y = iY * CELL_SIZE + CELL_SIZE / 2;
                            NewObj->iRemovalEffects = 2;
                            NewObj->iRemovalEffect[0] = EFFECTID_TILEANIM;
                            NewObj->iRemovalEffect[1] = EFFECTID_SHOCKWAVE;
                            NewObj->iRemovalAnim = ANIMID_CRATECRUSH;
                            this->AddObject(NewObj);
                            break;

                     case TYPEID_POWERUP_LM:
                            NewObj = new CObject(TYPEID_POWERUP_LM, this);
                            NewObj->Position.x = iX * CELL_SIZE + CELL_SIZE / 2;
                            NewObj->Position.y = iY * CELL_SIZE + CELL_SIZE / 2;
                            NewObj->iRemovalEffects = 2;
                            NewObj->iRemovalEffect[0] = EFFECTID_TILEANIM;
                            NewObj->iRemovalEffect[1] = EFFECTID_SHOCKWAVE;
                            NewObj->iRemovalAnim = ANIMID_CRATECRUSH;
                            this->AddObject(NewObj);
                            break;

                     case TYPEID_POWERUP_HS:
                            NewObj = new CObject(TYPEID_POWERUP_HS, this);
                            NewObj->Position.x = iX * CELL_SIZE + CELL_SIZE / 2;
                            NewObj->Position.y = iY * CELL_SIZE + CELL_SIZE / 2;
                            NewObj->iRemovalEffects = 2;
                            NewObj->iRemovalEffect[0] = EFFECTID_TILEANIM;
                            NewObj->iRemovalEffect[1] = EFFECTID_SHOCKWAVE;
                            NewObj->iRemovalAnim = ANIMID_CRATECRUSH;
                            this->AddObject(NewObj);
                            break;

                     case TYPEID_TNT_BLOCK:
                            NewObj = new CObject(TYPEID_TNT_BLOCK, this);
                            NewObj->Position.x = iX * CELL_SIZE + CELL_SIZE / 2;
                            NewObj->Position.y = iY * CELL_SIZE + CELL_SIZE / 2;
                            NewObj->iRemovalEffects = 1;
                            NewObj->iRemovalEffect[0] = EFFECTID_PSYSTEM;
                            NewObj->iRemovalSound = SOUNDID_EXPLOSION;
                            NewObj->iDamageSound = SOUNDID_HIT;
                            this->AddObject(NewObj);
                            break;

                     case TYPEID_WALL_BLOCK:
                            NewObj = new CObject(TYPEID_WALL_BLOCK, this);
                            NewObj->Position.x = iX * CELL_SIZE + CELL_SIZE / 2;
                            NewObj->Position.y = iY * CELL_SIZE + CELL_SIZE / 2;
                            NewObj->iDamageSound = SOUNDID_HIT;
                            this->AddObject(NewObj);
                            break;

                     case TYPEID_WOOD_BLOCK:
                            NewObj = new CObject(TYPEID_WOOD_BLOCK, this);
                            NewObj->Position.x = iX * CELL_SIZE + CELL_SIZE / 2;
                            NewObj->Position.y = iY * CELL_SIZE + CELL_SIZE / 2;
                            NewObj->iRemovalSound = SOUNDID_HIT;
                            NewObj->iDamageSound = SOUNDID_HIT;
                            NewObj->iRemovalEffects = 1;
                            NewObj->iRemovalEffect[0] = EFFECTID_TILEANIM;
                            NewObj->iRemovalAnim = ANIMID_CRATECRUSH;
                            this->AddObject(NewObj);
                            break;
                     }
              }
       }

       // read in the music file name for this level
       for(iX=0; iX < 256; iX++) // read in a line
       {
              charsRead = fread(&currentChar, 1, 1, file);
              if(charsRead < 1)
              {
                     return DAS_ERROR; // couldn't read from file? return error
              }

              if(currentChar == 10)
              {
                     musicFile[iX] = 0; // terminate string and exit loop
                     break;
              }
              else
              {
                     musicFile[iX] = currentChar;  // add current char string
              }
       }

       fclose(file);

       return 0; //success
}


CTile::CTile(void)
{
       iType = TILEID_NULL;
       iTexture = TEXID_NULL;
       iTileEffect = TILE_EFFECT_NULL;
       bPassable = true;
       iDamage = 0;
       Previous = NULL;
       Next = NULL;
}


CObject::CObject(void)
{
       ParentWorld = NULL;
       Geometry = NULL;
       Effects = NULL;
       Previous = NULL;
       Next = NULL;
       Owner = NULL;

       fBBLeft = DEFAULT_BB_LEFT;
       fBBRight = DEFAULT_BB_RIGHT;
       fBBBottom = DEFAULT_BB_BOTTOM;
       fBBTop = DEFAULT_BB_TOP;

       fDrawLeft = DEFAULT_DRAW_LEFT;
       fDrawRight = DEFAULT_DRAW_RIGHT;
       fDrawBottom = DEFAULT_DRAW_BOTTOM;
       fDrawTop = DEFAULT_DRAW_TOP;

       fAngle = DEFAULT_ANGLE;
       fSubAngle = DEFAULT_SUB_ANGLE;

       iOwnCount = 0;
       iHealth = DEFAULT_HEALTH;
       bDying = false;
       bVisible = true;
       iDamage = DEFAULT_DAMAGE;
       iType = TYPEID_NULL;
       iLives = DEFAULT_LIVES;
       iTexture = TEXID_NULL;
       iTint = TINTID_NULL;
       iRemovalEffects = 0;
       iRemovalSound = SOUNDID_NULL;
       iDamageSound = SOUNDID_NULL;
       iWeapon = WEAPONID_PEA_SHOT;
       iAmmo = -1; // start with infinite pea-shooter ammo

       // animation variables
       iCreationAnim = ANIMID_NULL;
       iCreationAnimSpeed = 100;
       iNormalAnim = ANIMID_NULL;
       iNormalAnimSpeed = 100;
       iRemovalAnim = ANIMID_NULL;
       iRemovalAnimSpeed = 100;
       bAnimCycle = ANIM_CYCLE_CYCLE;
       bAnimating = false;
       iCurrentFrame = 0;
       iAnimTimeStamp = 0;
       iLingerTime = DEFAULT_LINGER_TIME;

       // collision variables
       bCheckedForCollision = false;

       for(int iX=0; iX<8; iX++)
       {
              iInput[iX] = false;
       }

}

CObject::CObject(int typeID, CWorld * ThisWorld)
{
       iType = typeID;
       ParentWorld = ThisWorld;
       Geometry = NULL;
       Effects = NULL;
       Previous = NULL;
       Next = NULL;
       Owner = NULL;

       fBBLeft = DEFAULT_BB_LEFT;
       fBBRight = DEFAULT_BB_RIGHT;
       fBBBottom = DEFAULT_BB_BOTTOM;
       fBBTop = DEFAULT_BB_TOP;

       fDrawLeft = DEFAULT_DRAW_LEFT;
       fDrawRight = DEFAULT_DRAW_RIGHT;
       fDrawBottom = DEFAULT_DRAW_BOTTOM;
       fDrawTop = DEFAULT_DRAW_TOP;

       fAngle = DEFAULT_ANGLE;
       fSubAngle = DEFAULT_SUB_ANGLE;

       iOwnCount = 0;
       iHealth = DEFAULT_HEALTH;
       bDying = false;
       bVisible = true;
       iDamage = DEFAULT_DAMAGE;
       iLives = DEFAULT_LIVES;
       iTexture = TEXID_NULL;
       iTint = TINTID_NULL;
       iRemovalEffects = 0;
       iRemovalSound = NULL;
       iDamageSound = SOUNDID_NULL;
       iWeapon = WEAPONID_NULL;
       iAmmo = 0;

       // animation variables
       iCreationAnim = ANIMID_NULL;
       iCreationAnimSpeed = 100;
       iNormalAnim = ANIMID_NULL;
       iNormalAnimSpeed = 100;
       iRemovalAnim = ANIMID_NULL;
       iRemovalAnimSpeed = 100;
       bAnimCycle = ANIM_CYCLE_CYCLE;
       bAnimating = false;
       iCurrentFrame = 0;
       iAnimTimeStamp = 0;
       iLingerTime = DEFAULT_LINGER_TIME;

       bCheckedForCollision = false;

       for(int iX=0; iX<8; iX++)
       {
              iInput[iX] = false;
       }

       switch(iType)
       {
       case TYPEID_PEA_SHOT:
              iDamage = 10;
              fBBLeft = -.3;
              fBBRight = .3;
              fBBBottom = -.3;
              fBBTop = .3;
              fDrawLeft = -.6;
              fDrawRight = .6;
              fDrawBottom = -.6;
              fDrawTop = .6;
              iTexture = TEXID_PEA_SHOT;
              break;

       case TYPEID_BOUNCY_SHOT:
              iHealth = 100;
              iDamage = 10;
              fBBLeft = -.3;
              fBBRight = .3;
              fBBBottom = -.3;
              fBBTop = .3;
              fDrawLeft = -.5;
              fDrawRight = .5;
              fDrawBottom = -.5;
              fDrawTop = .5;
              iTexture = TEXID_BOUNCY_SHOT;
              break;

       case TYPEID_SUPER_BULLET:
              iHealth = 100;
              iDamage = 15;
              fBBLeft = -.3;
              fBBRight = .3;
              fBBBottom = -.3;
              fBBTop = .3;
              fDrawLeft = -.5;
              fDrawRight = .5;
              fDrawBottom = -.5;
              fDrawTop = .5;
              iTexture = TEXID_SUPER_BULLET;
              break;

       case TYPEID_LAND_MINE:
              iDamage = 100;
              fBBLeft = -.5;
              fBBRight = .5;
              fBBBottom = -.5;
              fBBTop = .5;
              fDrawLeft = -.8;
              fDrawRight = .8;
              fDrawBottom = -.8;
              fDrawTop = .8;
              iTexture = TEXID_LAND_MINE;
              break;

       case TYPEID_HEAT_SEEKER:
              iDamage = 50;
              fBBLeft = -.3;
              fBBRight = .3;
              fBBBottom = -.3;
              fBBTop = .3;
              fDrawLeft = -1;
              fDrawRight = 1;
              fDrawBottom = -1;
              fDrawTop = 1;
              iTexture = TEXID_HEAT_SEEKER;
              break;

       case TYPEID_POWERUP_HEALTH:
              iDamage = -30;
              iTexture = TEXID_POWERUP_HEALTH;
              break;

       case TYPEID_POWERUP_PS:
              iTexture = TEXID_POWERUP_PS;
              break;

       case TYPEID_POWERUP_BS:
              iTexture = TEXID_POWERUP_BS;
              break;

       case TYPEID_POWERUP_SB:
              iTexture = TEXID_POWERUP_SB;
              break;

       case TYPEID_POWERUP_LM:
              iTexture = TEXID_POWERUP_LM;
              break;

       case TYPEID_POWERUP_HS:
              iTexture = TEXID_POWERUP_HS;
              break;

       case TYPEID_TNT_BLOCK:
              iHealth = 10;
              iDamage = 20;
              iTexture = TEXID_TNT_BLOCK;
              break;

       case TYPEID_WALL_BLOCK:
              iHealth = 1000;
              iDamage = 10;
              iTexture = TEXID_WALL_BLOCK;
              break;

       case TYPEID_WOOD_BLOCK:
              iHealth = 40;
              iDamage = 25;
              iTexture = TEXID_CRATE;
              break;

       case TYPEID_TANK:
              iHealth = 100;
              iDamage = 50;
              iWeapon = WEAPONID_PEA_SHOT;
              iAmmo = -1; // start with infinite pea-shooter ammo
              iLives = 3;
              iTexture = TEXID_TANK;
              break;
       }
}

int CObject::Draw(void)
{
       // draw object
       glPushMatrix(); // save matrix state
       glTranslatef(Position.x, Position.y, 0.0f); // position in WCS
       switch(iTint)
       {
       case TINTID_ARMYGREEN:
              glColor4f(0.67,0.82,0.45,1.0);
              break;
       case TINTID_ARMYBROWN:
              glColor4f(0.65,0.53,0.17,1.0);
              break;
       case TINTID_NULL:
              glColor4f(1.0,1.0,1.0,1.0);
              break;
       case TINTID_RED:
              glColor4f(1.0,0.4,0.4,1.0);
              break;
       case TINTID_ORANGE:
              glColor4f(1.0,0.8,0.4,1.0);
              break;
       case TINTID_YELLOW:
              glColor4f(1.0,1.0,0.4,1.0);
              break;
       case TINTID_GREEN:
              glColor4f(0.4,1.0,0.4,1.0);
              break;
       case TINTID_BLUE:
              glColor4f(0.4,0.8,1.0,1.0);
              break;
       case TINTID_PURPLE:
              glColor4f(1.0,0.4,1.0,1.0);
              break;
       }

       glRotatef(fAngle,0,0,1);
       
       if (!bAnimating) // draw the objects regular tile
       {
              glBindTexture( GL_TEXTURE_2D, GetTexture(this->iTexture));
       }
       else // otherwise draw it's current animation frame
       {
              glBindTexture( GL_TEXTURE_2D, GetFrame(ANIMID_CRATECRUSH, iCurrentFrame));
       }

       glBegin(GL_QUADS);                        // start drawing a polygon (4 sided)
       glTexCoord2d(0.0,1.0); glVertex3f(fDrawLeft, fDrawTop, 0.1f);         // top left
       glTexCoord2d(1.0,1.0); glVertex3f(fDrawRight, fDrawTop, 0.1f);        // top right
       glTexCoord2d(1.0,0.0); glVertex3f(fDrawRight, fDrawBottom, 0.1f);     // bottom right
       glTexCoord2d(0.0,0.0); glVertex3f(fDrawLeft, fDrawBottom, 0.1f);      // bottom left       
       glEnd(); // done with the polygon

       glPopMatrix();

       // draw bounding box if flag is set
       if(DRAW_BOUNDING_BOXES)
       {
              glDisable( GL_TEXTURE_2D );                      // enable texture mapping   
              glPushMatrix(); // save the state (CYA)
              glTranslatef(Position.x, Position.y, 0.0f); // position in WCS
              glColor3f(1.0,0.0,1.0);
              glBegin(GL_LINE_LOOP);                                  // start drawing a polygon (4 sided)
              glVertex3f(fBBLeft, fBBTop, 0.1f);        // Top Left
              glVertex3f(fBBRight, fBBTop, 0.1f);              // Top Right
              glVertex3f(fBBRight, fBBBottom, 0.1f);    // Bottom Right
              glVertex3f(fBBLeft, fBBBottom, 0.1f);     // Bottom Left       
              glEnd();                                                       // done with the polygon
              glPopMatrix();
              glEnable( GL_TEXTURE_2D );                       // enable texture mapping
       }

       return 0; // success
}

void CObject::StartAnimating(void)
{
       iCurrentFrame = 0;
       bAnimating = true;
       iAnimTimeStamp = this->ParentWorld->iCurrentTime;
}

void CObject::StopAnimating(void)
{
       bAnimating = false;
}

void CObject::SetBB(float left, float right, float bottom, float top)
{
       fBBLeft = left;
       fBBRight = right;
       fBBBottom = bottom;
       fBBTop = top;
}

 

Copyright Windsor Schmidt 2006 - All rights reserved.