collision.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

// use to hold all the interaction logic responses for various collisions / interactions
int collisionInteract[INTERACTION_MATRIX_SIZE * INTERACTION_MATRIX_SIZE];
int damageInteract[INTERACTION_MATRIX_SIZE * INTERACTION_MATRIX_SIZE];
int effectInteract[INTERACTION_MATRIX_SIZE * INTERACTION_MATRIX_SIZE];


void DoCollisions(CWorld * ThisWorld)
{
       CObject * Current = ThisWorld->Objects;
       CObject * Other = ThisWorld->Objects;

       // A little speed optimization, this flag changes state each time through the colllision routine.
       // The outer collision loop flags each object with the current 'checked' state as it's checked for
       // collision, and so later iterations will skip a 'reverse check' of the same two objects. When the
       // outer loop is complete and all the objects have been tested for colision, the check flag changes
       // polarity on the next collision routine run, and all the nodes are now considered 'unchecked' again.
       static bool bCheckState = true;
       if (bCheckState == true) bCheckState = false; // these two lines toggle the flag each pass
       else bCheckState = true;

       while(Current != NULL)
       {
              Other = ThisWorld->Objects; // reset the 'other' object each time

              // check against every other object
              while(Other != NULL)
              {
                     if(Current == Other) goto no_collision; // checking collision with ourself, duh

                     if(Other->bCheckedForCollision == bCheckState) goto no_collision; // already tested this pair; skip

                     // check bounding boxes and bail out with goto if we find a 'can't be touching' situation
                     if(Current->Position.y + Current->fBBBottom > Other->Position.y + Other->fBBTop) goto no_collision;
                     if(Current->Position.y + Current->fBBTop < Other->Position.y + Other->fBBBottom) goto no_collision;
                     if(Current->Position.x + Current->fBBRight < Other->Position.x + Other->fBBLeft) goto no_collision;
                     if(Current->Position.x + Current->fBBLeft > Other->Position.x + Other->fBBRight) goto no_collision;

                     // bounding boxes occured, so process a hit.
                     Collide(ThisWorld, Current, Other);

                     ThisWorld->iNumCollisions ++; // update total # of collisions for debug info

no_collision: // handy goto jump-point

                     // done checking this object, so flag it
                     Current->bCheckedForCollision = bCheckState;

                     Other = Other->Next; // check next 'other' object next time around loop, if there is one
              }
              Current = Current->Next; // check next object for collisions, if there is one
       }
}


void Collide(CWorld * ThisWorld, CObject * ObjA, CObject * ObjB)
{
       int response = 0;

       // find out which collision reponse is appropriate for this collision
       response = getInteraction(MATRIXID_COLLISION, ObjA->iType, ObjB->iType);

       switch(response)
       {
       case RESPONSE_NULL:
              break;

       case RESPONSE_COL_REFLECT_A:
              PlaySound(SOUNDID_BOUNCE); // play a sound effect
              PhysicsReflect(ThisWorld, ObjA, ObjB);
              break;

       case RESPONSE_COL_REFLECT_B:
              PlaySound(SOUNDID_BOUNCE); // play a sound effect
              PhysicsReflect(ThisWorld, ObjB, ObjA);
              break;

       case RESPONSE_COL_REFLECT_BOTH:
              PlaySound(SOUNDID_BOUNCE); // play a sound effect
              PhysicsReflect(ThisWorld, ObjA, ObjB);
              PhysicsReflect(ThisWorld, ObjB, ObjA);
              break;

       case RESPONSE_COL_STOP_A:
              PhysicsStop(ObjA, ObjB);
              break;

       case RESPONSE_COL_STOP_B:
              PhysicsStop(ObjB, ObjA);
              break;

       case RESPONSE_COL_STOP_BOTH:
              PhysicsStop(ObjA, ObjB);
              PhysicsStop(ObjB, ObjA);
              break;

       case RESPONSE_COL_ELASTIC:
              PhysicsElasticCollision(ObjA, ObjB);
              break;

       case RESPONSE_COL_DAMPED:
              PhysicsDampedCollision(ObjA, ObjB);
              break;
       }

       // find out which damage reponse is appropriate for this collision
       response = getInteraction(MATRIXID_DAMAGE, ObjA->iType, ObjB->iType);

       switch(response)
       {
       case RESPONSE_NULL:
              break;

       case RESPONSE_DMG_A:
              GameLogicDamage(ObjA, ObjB);
              break;

       case RESPONSE_DMG_B:
              GameLogicDamage(ObjB, ObjA);
              break;

       case RESPONSE_DMG_BOTH:
              GameLogicDamage(ObjA, ObjB);
              GameLogicDamage(ObjB, ObjA);
              break;

       case RESPONSE_DMG_KILL_A:
              ObjA->iHealth = 0;
              break;

       case RESPONSE_DMG_KILL_B:
              ObjB->iHealth = 0;
              break;

       case RESPONSE_DMG_KILL_BOTH:
              ObjA->iHealth = 0;
              ObjB->iHealth = 0;
              break;

       }

       // find out which effect reponse is appropriate for this collision
       response = getInteraction(MATRIXID_EFFECT, ObjA->iType, ObjB->iType);
              
       switch(response)
       {
       case RESPONSE_NULL:
              break;
       case RESPONSE_EFF_EQUIP_A:
              GameLogicEquip(ObjA, ObjB);
              break;
       case RESPONSE_EFF_EQUIP_B:
              GameLogicEquip(ObjB, ObjA);
              break;
       }
}


int InitCollision(void)
{
       // load interaction data from disk
       if(DAS_ERROR == loadInteractionMatrix(collisionInteract, "dat\\collision_interact")) { return DAS_ERROR; }
       if(DAS_ERROR == loadInteractionMatrix(damageInteract, "dat\\damage_interact")) { return DAS_ERROR; }
       if(DAS_ERROR == loadInteractionMatrix(effectInteract, "dat\\effect_interact")) { return DAS_ERROR; }

       return 0; // looks good
}


int loadInteractionMatrix(int * matrix, const char * filename)
{
       FILE * file;
       char string[256];
       char currentChar = 0;
       int iX, iY, iZ;
       iX = iY = iZ = 0;

       fopen_s(&file, filename, "r");
       if(NULL == file) { return DAS_ERROR; }

       // read in matrix
       for(iY = 0; iY < INTERACTION_MATRIX_SIZE; iY++) // for each row
       {
              for(iX = 0; iX < INTERACTION_MATRIX_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;
                            }

                            matrix[iY * INTERACTION_MATRIX_SIZE + iX] = atoi(string);
                     }
              }
       }

       fclose(file);

       return 0;
}


int getInteraction(int matrixID, int typeID_A, int typeID_B)
{
       switch(matrixID)
       {
       case MATRIXID_COLLISION:
              return(collisionInteract[typeID_A * INTERACTION_MATRIX_SIZE + typeID_B]);
              break;

       case MATRIXID_DAMAGE:
              return(damageInteract[typeID_A * INTERACTION_MATRIX_SIZE + typeID_B]);
              break;

       case MATRIXID_EFFECT:
              return(effectInteract[typeID_A * INTERACTION_MATRIX_SIZE + typeID_B]);
              break;
       }

       return(DAS_ERROR); // error, probably was passed an invalid matrixID
}


void ProcessTileCollisions(CWorld * ThisWorld)
{
       int iX, iY, iZ;
       bool doPeriodicEffect = false;
       bool doPeriodicSound = false;
       static Uint32 tileEffectTimer = SDL_GetTicks();
       static Uint32 tileSoundTimer = SDL_GetTicks();
       CObject * Current;
       CEffect * NewEffect = NULL;

       if(SDL_GetTicks() - tileEffectTimer > TILE_EFFECT_TIMER)
       {
              doPeriodicEffect = true;
              tileEffectTimer = SDL_GetTicks();
       }

       if(SDL_GetTicks() - tileSoundTimer > TILE_SOUND_TIMER)
       {
              doPeriodicSound = true;
              tileSoundTimer = SDL_GetTicks();
       }

       for(iZ = 0; iZ < NUM_PLAYERS; iZ++)
       {
              Current = ThisWorld->Player[iZ];

              for(iY = 0; iY < MAP_SIZE; iY++)
              {
                     for(iX = 0; iX < MAP_SIZE; iX++)
                     {
                            if(Current->Position.y + Current->fBBBottom > iY * CELL_SIZE + CELL_SIZE) continue;
                            if(Current->Position.y + Current->fBBTop < iY * CELL_SIZE) continue;
                            if(Current->Position.x + Current->fBBRight < iX * CELL_SIZE) continue;
                            if(Current->Position.x + Current->fBBLeft > iX * CELL_SIZE + CELL_SIZE) continue;

                            // player is on the current tile, so do something about it
                            switch(ThisWorld->tiles[(iY * MAP_SIZE) + iX].iTileEffect)
                            {
                            case TILE_EFFECT_DAMAGE:
                                   if(doPeriodicEffect)
                                   {
                                          Current->iHealth -= ThisWorld->tiles[(iY * MAP_SIZE) + iX].iDamage;

                                          NewEffect = new CEffect(EFFECTID_PSYSTEM);
                                          NewEffect->PSys = new PSystem(Current->Position, Vector(0.0015,0,0), 2*PI, 1.00, 2, 10);
                                          NewEffect->PSys->SetColor(1.0, 0.6, 0.2);
                                          ThisWorld->AddEffect(NewEffect);

                                   }

                                   if(doPeriodicSound)
                                   {
                                          PlaySound(SOUNDID_BURNING);
                                   }
                                   break;

                            default:
                                   break;
                            }
                     }
              }
       }

       doPeriodicEffect = false;
       doPeriodicSound = false;
}

 

Copyright Windsor Schmidt 2006 - All rights reserved.