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


void PhysicsUpdate(CWorld * ThisWorld)
{
       Vector vTemp(0,0,0);

       // we'll be using a couple of object pointers for loops / comparison frequently here, so use these:
       CObject * Current = ThisWorld->Objects;
       CObject * Other = ThisWorld->Objects;

       // save the object positions
       while(Current != NULL)
       {
              Current->OldPosition = Current->Position; // save last position in case we need to move back

              Current = Current->Next;
       }

       // handle input from player(s)
       static int iX;
       for(iX = 0; iX < NUM_PLAYERS; iX++)
       {
              // only fire if the player doesn't own any other objects
              if(ThisWorld->Player[iX]->iInput[INPUT_FIRE] == true && ThisWorld->Player[iX]->iOwnCount == 0)
              {
                     GameLogicFire(ThisWorld->Player[iX]);
                     ThisWorld->Player[iX]->iInput[INPUT_FIRE] = false;
              }

              if(ThisWorld->Player[iX]->iInput[INPUT_LEFT] == true)
              {
                     ThisWorld->Player[iX]->fAngle += 2;
                     ThisWorld->Player[iX]->fSubAngle += 2; // rotate turret also
              }

              if(ThisWorld->Player[iX]->iInput[INPUT_RIGHT] == true)
              {
                     ThisWorld->Player[iX]->fAngle -= 2;
                     ThisWorld->Player[iX]->fSubAngle -= 2; // rotate turret also
              }

              if(ThisWorld->Player[iX]->iInput[INPUT_UP] == true)
              {
                     vTemp.x = 0.002;
                     vTemp.y = 0.0;
                     ThisWorld->Player[iX]->Velocity += VRotate2D(DegreesToRadians(ThisWorld->Player[iX]->fAngle),vTemp);
              }

              if(ThisWorld->Player[iX]->iInput[INPUT_DOWN] == true)
              {
                     vTemp.x = 0.002;
                     vTemp.y = 0.0;
                     ThisWorld->Player[iX]->Velocity -= VRotate2D(DegreesToRadians(ThisWorld->Player[iX]->fAngle),vTemp);
              }
       }

       // update position of world objects
       Current = ThisWorld->Objects;
       while(Current != NULL)
       {
              UpdateBody(Current, .1);

              // move object based on velocity **THIS IS A HACK - FIX ME**
              Current->Position.x += Current->Velocity.x;
              Current->Position.y += Current->Velocity.y;

              // bounce objects as they hit the playfield bounds **THIS IS A HACK - FIX ME**
              if(Current->Position.x + Current->fBBLeft < 0) // left wall
              {
                     Current->Position.x = Current->fBBRight;
                     Current->Velocity.x = Current->Velocity.x * -1;
                     if(Current->iType != TYPEID_TANK) PlaySound(SOUNDID_REFLECT); // play a sound effect
              }

              if(Current->Position.x + Current->fBBRight > PLAYFIELD_SIZE) // right wall
              {
                     Current->Position.x = PLAYFIELD_SIZE + Current->fBBLeft;
                     Current->Velocity.x = Current->Velocity.x * -1;
                     if(Current->iType != TYPEID_TANK) PlaySound(SOUNDID_REFLECT); // play a sound effect
              }

              if(Current->Position.y  + Current->fBBBottom < 0) // bottom wall
              {
                     Current->Position.y = Current->fBBTop;
                     Current->Velocity.y = Current->Velocity.y * -1;
                     if(Current->iType != TYPEID_TANK) PlaySound(SOUNDID_REFLECT); // play a sound effect
              }

              if(Current->Position.y + Current->fBBTop > PLAYFIELD_SIZE) // top wall
              {
                     Current->Position.y = PLAYFIELD_SIZE + Current->fBBBottom;
                     Current->Velocity.y = Current->Velocity.y * -1;
                     if(Current->iType != TYPEID_TANK) PlaySound(SOUNDID_REFLECT); // play a sound effect
              }

              Current = Current->Next; // traverse the list to operate on the next object
       }
}


void PhysicsDampedCollision(CObject * ObjA, CObject * ObjB)
{
}


void PhysicsElasticCollision(CObject * ObjA, CObject * ObjB)
{
}


void PhysicsStop(CObject * ObjA, CObject * ObjB)
{
       int biteX, biteY; // X and Y delta of the object's positions. reflect whichever is greater
       biteX = biteY = 0;

       if(ObjA->Velocity.x < 0) // ObjA going left
       {
              biteX = ObjA->Position.x - ObjB->Position.x;
       }
       
       if(ObjA->Velocity.x > 0) // ObjA going right
       {
              biteX = ObjB->Position.x - ObjA->Position.x;
       }
       
       if(ObjA->Velocity.y > 0) // ObjA going up
       {
              biteY = ObjB->Position.y - ObjA->Position.y;
       }
       
       if(ObjA->Velocity.y < 0) // ObjA going down
       {
              biteY = ObjA->Position.y - ObjB->Position.y;
       }

       if(biteX >= biteY)
       {
              ObjA->Velocity.x = 0;
              ObjA->Position.x = ObjA->OldPosition.x;
              return;
       }
       else
       {
              ObjA->Velocity.y = 0;
              ObjA->Position.y = ObjA->OldPosition.y;
              return;
       }
}


void PhysicsReflect(CWorld * ThisWorld, CObject * ObjA, CObject * ObjB)
{
       CEffect * NewEffect;

       // special cases based on object type
       switch(ObjA->iType)
       {
       case TYPEID_BOUNCY_SHOT:
              NewEffect = new CEffect(EFFECTID_MINISHOCK);
              NewEffect->MShock = new MiniShock(ObjA->Position, 1);
              NewEffect->MShock->SetColor(0.8, 0.3, 0.6);
              ThisWorld->AddEffect(NewEffect);
              break;
       }

       int biteX, biteY; // X and Y delta of the object's positions. reflect whichever is greater
       biteX = biteY = 0;

       if(ObjA->Velocity.x < 0) // ObjA going left
       {
              biteX = ObjA->Position.x - ObjB->Position.x;
       }
       
       if(ObjA->Velocity.x > 0) // ObjA going right
       {
              biteX = ObjB->Position.x - ObjA->Position.x;
       }
       
       if(ObjA->Velocity.y > 0) // ObjA going up
       {
              biteY = ObjB->Position.y - ObjA->Position.y;
       }
       
       if(ObjA->Velocity.y < 0) // ObjA going down
       {
              biteY = ObjA->Position.y - ObjB->Position.y;
       }

       if(biteX > biteY)
       {
              ObjA->Velocity.x *= -1;
              return;
       }
       else
       {
              ObjA->Velocity.y *= -1;
              return;
       }
       
       if(biteX == biteY) // hit a corner
       {
              ObjA->Velocity.x *= -1;
              ObjA->Velocity.y *= -1;
              return;
       }
}


void UpdateBody(CObject * body, float timeDelta)
{
       float xproj = 0;
       float yproj = 0;
       Vector perp;
       Vector medialFriction;
       Vector lateralFriction;
       Vector heading(1,0,0);

       switch(body->iType)
       {
       case TYPEID_TANK:
              heading = VRotate2D(DegreesToRadians(body->fAngle), heading);
              xproj = body->Velocity * heading;
              medialFriction = heading * -(xproj * TANK_FCR_MEDIAL);

              perp.x = -heading.y;
              perp.y = heading.x;
              perp.z = 0;

              yproj = body->Velocity * perp;
              
              lateralFriction = perp * -(yproj * TANK_FCR_LATERAL);

              body->Velocity += medialFriction + lateralFriction;

              if(body->Velocity.Magnitude() > MAX_TANK_SPEED)
              {
                     body->Velocity *= .9;
              }
              break;

       case TYPEID_WOOD_BLOCK:
              body->Velocity *= .95;
              break;
       }
}


void DamageRadius(CWorld * ThisWorld, Vector pos, float rad, float dam)
{
       CObject * Current = ThisWorld->Objects;
       Vector vDist(0,0,0);

       while(Current != NULL)
       {
              if(Current->iType != TYPEID_WALL_BLOCK)
              {
                     vDist = Current->Position - pos;
                     if(vDist.Magnitude() < rad)
                     {
                            Current->iHealth -= (dam - (vDist.Magnitude()/dam));
                            Current->Velocity += vDist * (dam - (vDist.Magnitude()/dam)) * .002;
                     }
              }
              Current = Current->Next;
       }
}

 

Copyright Windsor Schmidt 2006 - All rights reserved.