My Pastes
Public Pastes
Layout Width
Share Pastebin
Guest
Public paste!

CUpdateCollisionBucket

By: a guest | Mar 20th, 2010 | Syntax: C++ | Size: 16.13 KB | Hits: 101 | Expires: Never
Download | Raw | Embed | Report abuse
This paste has a previous version, view the difference. Copy text to clipboard
  1. //////////////////////////////////////////////////////////////////////////////////////
  2. //
  3. //   File:                      CCollisionBucket.cpp
  4. //   Date:                      10/15/2008
  5. //   Creator:           John Rodenburg
  6. //   Description:       Implementation of the CCollisionBucket
  7. //                                     
  8. //////////////////////////////////////////////////////////////////////////////////////
  9.  
  10. #ifndef _CUPDATECOLLISIONBUCKET_H_
  11.  
  12.         #define _CUPDATECOLLISIONBUCKET_H_
  13.        
  14.         #include "CBucket.h"
  15.         #include "CPlayer.h"
  16.         #include "CWalls.h"
  17.                
  18.         class CUpdateCollisionBucket : public CBucket
  19.         {
  20.        
  21.                         CUpdateCollisionBucket(const CUpdateCollisionBucket &);
  22.                         CUpdateCollisionBucket &operator=(const CUpdateCollisionBucket &);
  23.                
  24.                 public:
  25.                
  26.                         CUpdateCollisionBucket();
  27.                         ~CUpdateCollisionBucket();
  28.                        
  29.                         void Init();
  30.                         void Update(BUCKET_ID parentID);
  31.                         void Shutdown();
  32.         };
  33.                
  34. #endif
  35.  
  36.  
  37. ######################################################## END OF FILE ##############################################
  38.  
  39. //////////////////////////////////////////////////////////////////////////////////////
  40. //
  41. //   File:                      CUpdateCollisionBucket.cpp
  42. //   Date:                      10/15/2008
  43. //   Creator:           John Rodenburg
  44. //   Description:       Implementation of the CUpdateCollisionBucket
  45. //                                     
  46. //////////////////////////////////////////////////////////////////////////////////////
  47. #include <algorithm>
  48. using std::sort;
  49.  
  50. #include "CDispatchManager.h"
  51. #include "CGameManager.h"
  52. #include "CGameObject.h"
  53. #include "CSceneObject.h"
  54. #include "CPlayer.h"
  55. #include "CBullet.h"
  56. #include "CPickup.h"
  57. #include "CAIPlayer.h"
  58. #include "CSoundManager.h"
  59. #include "CCollisionManager.h"
  60. #include "CDragEffect.h"
  61. #include "CPlayer.h"
  62. #include "CRacer.h"
  63. #include "CUpdateCollisionBucket.h"
  64.  
  65. bool UDGreater(CBucketItem *item1, CBucketItem *item2)
  66. {
  67.         int value1;
  68.         int value2;
  69.        
  70.         item1->SortValue(UPDATE_COLLISION_BUCKET, value1);
  71.         item2->SortValue(UPDATE_COLLISION_BUCKET, value2);
  72.        
  73.         return value1 > value2;
  74. }
  75.  
  76. bool UDLesser(CBucketItem *item1, CBucketItem *item2)
  77. {
  78.         int value1;
  79.         int value2;
  80.        
  81.         item1->SortValue(UPDATE_COLLISION_BUCKET, value1);
  82.         item2->SortValue(UPDATE_COLLISION_BUCKET, value2);
  83.        
  84.         return value1 < value2;
  85. }
  86.  
  87. CUpdateCollisionBucket::CUpdateCollisionBucket()
  88. {
  89.         m_nID = UPDATE_COLLISION_BUCKET;
  90. }
  91.  
  92. CUpdateCollisionBucket::~CUpdateCollisionBucket()
  93. {
  94. }
  95.  
  96. void CUpdateCollisionBucket::Init()
  97. {
  98.         DispatchManager().RegisterBucket(m_nID, this);         
  99. }
  100.  
  101. void CUpdateCollisionBucket::Update(BUCKET_ID parentID)
  102. {
  103.         if (m_bLocked)
  104.                 return;
  105.  
  106.         if (!m_bSorted)
  107.         {
  108.                 std::sort(m_vBucketItems.begin(), m_vBucketItems.end(), UDLesser);
  109.                 m_bSorted = true;
  110.        
  111.         } // end if    
  112.  
  113.         for (size_t i = 0; i < m_vBucketItems.size() - 1; ++i)
  114.         {
  115.                 for (size_t j = i + 1; j < m_vBucketItems.size(); ++j)
  116.                 {
  117.                         //Check what kind of object we are checking (I)
  118.                         switch(((CGameObject*)m_vBucketItems[i])->GetType())
  119.                         {
  120.                                 case OBJECT_SHIP:
  121.  
  122.                                         //Once we have determined, Check what it is checking against
  123.                                         switch(((CGameObject*)m_vBucketItems[j])->GetType())
  124.                                         {
  125.                                                 ///////////////////////////////////////////////////////////////
  126.                                                 ///Collide with Ship, Weapon, Powerup, Wall
  127.                                                 ////////////////////////////////////////////////////////////////
  128.                                                 case OBJECT_SHIP:
  129.                                                         {
  130.                                                                 if(CollisionManager().Test( ((CGameObject*)m_vBucketItems[i])->Sphere(), ((CGameObject*)m_vBucketItems[j])->Sphere() ))
  131.                                                                 if (((CRacer*)m_vBucketItems[i])->ProcessCollision((CGameObject*)m_vBucketItems[j]))
  132.                                                                         continue;
  133.                                                                
  134.                                                         }
  135.                                                         break;
  136.  
  137.                                                 case OBJECT_WEAPON:
  138.                                                         {
  139.  
  140.                                                                 if(CollisionManager().Test( ((CGameObject*)m_vBucketItems[i])->Sphere(), ((CGameObject*)m_vBucketItems[j])->Sphere() ))
  141.                                                                 {
  142.                                                                        
  143.                                                                         if(((CRacer*)m_vBucketItems[i])->IsPlayer())
  144.                                                                         {
  145.                                                                                 ((CPlayer*)m_vBucketItems[i])->ProcessCollision((CBullet*)m_vBucketItems[j]);
  146.                                                                         }
  147.                                                                         else
  148.                                                                         {
  149.                                                                                 ((CAIPlayer*)m_vBucketItems[i])->ProcessCollision((CBullet*)m_vBucketItems[j]);
  150.                                                                         }
  151.                                                                         ((CBullet*)m_vBucketItems[j])->ProcessCollision((CRacer*)m_vBucketItems[i]);
  152.                                                                 }
  153.                                                         }
  154.                                                         break;
  155.                                                 case OBJECT_BOOSTRING:
  156.                                                         {
  157.                                                                 CRacer* currentShip = (CRacer*)m_vBucketItems[i];
  158.                                                                 CBoostRing* currentRing = (CBoostRing*)m_vBucketItems[j];
  159.                                                                
  160.                                                                
  161.                                                                 // Check if its the player
  162.                                                                 if (!GameManager().Player().IsStarting())
  163.                                                                 {
  164.                                                                         if (currentShip->IsPlayer())
  165.                                                                         {
  166.                                                                                 CPlayer* thePlayer = (CPlayer*)m_vBucketItems[i];
  167.                                                                                 // Check if the boost is active for the player - have they passed it already?
  168.                                                                                 if(currentShip->GetCurrentBoostRing() == currentRing->GetID())
  169.                                                                                 {
  170.                                                                                         float distanceFromRing = currentShip->DistanceFrom(currentRing);
  171.                                                                                         thePlayer->SetDistanceFromRing(distanceFromRing);
  172.                                                                                         currentRing->SetEffectColorByDistance(distanceFromRing);
  173.  
  174.                                                                                         if (distanceFromRing < MAX_DISTANCEFROMBOOST && !thePlayer->IsApproachingGate())
  175.                                                                                         {
  176.                                                                                                 thePlayer->TurnApproachingGateOn();
  177.                                                                                         }
  178.                                                                                        
  179.                                                                                         D3DXVECTOR3 toShip(currentShip->Transform().axis_pos - currentRing->Transform().axis_pos);
  180.  
  181.                                                                                         float result = D3DXVec3Dot(&(currentRing->Transform().axis_z), &toShip);
  182.                                                                                         // Apply the boost and rating if player is at buffer zone
  183.                                                                                         if (result < 0.0f)
  184.                                                                                         {
  185.                                                                                                 thePlayer->TurnApproachingGateOff();
  186.                                                                                                 currentRing->FireStarEffect();
  187.                                                                                                
  188.                                                                                                 int boostPressResult = thePlayer->ResultFromBoostGate();
  189.                                                                                                 float applyValue;
  190.  
  191.                                                                                                 switch(boostPressResult)
  192.                                                                                                 {
  193.                                                                                                 case (int)RESULT_POOR:
  194.                                                                                                         applyValue = 1.2f;
  195.                                                                                                         break;
  196.                                                                                                 case (int)RESULT_GOOD:
  197.                                                                                                         applyValue = 1.4f;
  198.                                                                                                         break;
  199.                                                                                                 case (int)RESULT_VERYGOOD:
  200.                                                                                                         applyValue = 1.7f;
  201.                                                                                                         break;
  202.                                                                                                 case (int)RESULT_PERFECT:
  203.                                                                                                         applyValue = 2.0f;
  204.                                                                                                         break;
  205.                                                                                                 default:
  206.                                                                                                         applyValue = 1.0f;
  207.                                                                                                         break;
  208.                                                                                                 }
  209.  
  210.                                                                                                 currentRing->SetEffectColorByDistance(MAX_DISTANCEFROMBOOST);
  211.                                                                                                 thePlayer->SetBoostRing(thePlayer->GetCurrentBoostRing() + 1);
  212.  
  213.                                                                                                 int maxRings = GameManager().GetMaxRings();
  214.                                                                                                 if (thePlayer->GetCurrentBoostRing() >= maxRings)
  215.                                                                                                 {
  216.                                                                                                         thePlayer->SetBoostRing(0);
  217.                                                                                                 }
  218.                                                                                                 thePlayer->Boost(thePlayer->BoostFactor() * applyValue);
  219.                                                                                                 thePlayer->AddBoost();
  220.                                                                                                 thePlayer->IncreaseBoostRingsRow();
  221.                                                                                         }
  222.                                                                                 }
  223.                                                                         }
  224.                                                                         else
  225.                                                                         {
  226.                                                                                 if(currentShip->GetCurrentBoostRing() == currentRing->GetID())
  227.                                                                                 {
  228.                                                                                         D3DXVECTOR3 toShip(currentShip->Transform().axis_pos - currentRing->Transform().axis_pos);
  229.  
  230.                                                                                        
  231.                                                                                         float result = D3DXVec3Dot(&(currentRing->Transform().axis_z), &toShip);
  232.  
  233.                                                                                         if (result < 0.0f)
  234.                                                                                         {
  235.                                                                                                 float applyValue;
  236.                                                                                                 int r = RAND_INT(0, 4);
  237.  
  238.                                                                                                 switch(r)
  239.                                                                                                 {
  240.                                                                                                 case (int)RESULT_POOR:
  241.                                                                                                         applyValue = 1.2f;
  242.                                                                                                         break;
  243.                                                                                                 case (int)RESULT_GOOD:
  244.                                                                                                         applyValue = 1.4f;
  245.                                                                                                         currentShip->AddBoost();
  246.                                                                                                         break;
  247.                                                                                                 case (int)RESULT_VERYGOOD:
  248.                                                                                                         applyValue = 1.7f;
  249.                                                                                                         currentShip->AddBoost();
  250.                                                                                                         break;
  251.                                                                                                 case (int)RESULT_PERFECT:
  252.                                                                                                         applyValue = 2.0f;
  253.                                                                                                         currentShip->AddBoost();
  254.                                                                                                         currentShip->AddBoost();
  255.                                                                                                         break;
  256.                                                                                                 default:
  257.                                                                                                         applyValue = 1.0f;
  258.                                                                                                         break;
  259.                                                                                                 }
  260.  
  261.                                                                                                 currentShip->SetBoostRing(currentShip->GetCurrentBoostRing() + 1);
  262.  
  263.                                                                                                 if (currentShip->GetCurrentBoostRing() > GameManager().GetMaxRings())
  264.                                                                                                 {
  265.                                                                                                         currentShip->SetBoostRing(0);
  266.                                                                                                 }
  267.                                                                                                 currentShip->Boost(currentShip->BoostFactor());
  268.                                                                                         }
  269.                                                                                 }
  270.                                                                         }
  271.                                                                 }
  272.                                                                
  273.                                                                 // Check if its the second player?
  274.                                                                 //else if
  275.                                                                 // Else it is an AI Ship
  276.                                                                 //else
  277.                                                                 //{
  278.  
  279.                                                                 //}
  280.                                                         }
  281.                                                         break;
  282.                                                 case OBJECT_POWERUP:
  283.                                                         {
  284.                                                                 if(CollisionManager().Test( ((CGameObject*)m_vBucketItems[i])->Sphere(), ((CGameObject*)m_vBucketItems[j])->Sphere() ))
  285.                                                                 if (((CRacer*)m_vBucketItems[i])->ProcessCollision((CGameObject*)m_vBucketItems[j]))
  286.                                                                         continue;
  287.                                                         }
  288.                                                         break;
  289.  
  290.                                                 case OBJECT_WALL:
  291.                                                         {
  292.  
  293.                                                                 ///////////////////////
  294.                                                                 // check update line //
  295.                                                                 ///////////////////////
  296.                                                                 unsigned int nCount = 0;
  297.                                                                 unsigned int nIndex = 0;
  298.                                                                 vector<tTriangle> vTris;
  299.                                                                 D3DXVECTOR3 vCollision;
  300.                                                                
  301.                                                                 D3DXVECTOR3 vBegin = ((CRacer*)m_vBucketItems[i])->OldPosition();
  302.                                                                 D3DXVECTOR3 vEnd = ((CRacer*)m_vBucketItems[i])->Transform().axis_pos;
  303.                                                                
  304.                                                                 CollisionManager().GetTriangles(((CGameObject*)m_vBucketItems[j])->Tree(), vTris, &nCount, vBegin, vEnd );
  305.  
  306.                                                                 if (!vTris.empty())
  307.                                                                 {
  308.                                                                         if(CollisionManager().LineSegment2Triangle(vCollision, nIndex, vTris, nCount, vBegin, vEnd))
  309.                                                                                 ((CRacer*)m_vBucketItems[i])->Transform().axis_pos  = vCollision;
  310.                                                                
  311.                                                                         vTris.empty();
  312.                                                                        
  313.                                                                         nCount = 0;
  314.                                                                        
  315.                                                                 } // end if    
  316.  
  317.                                                                 /////////////////////////
  318.                                                                 // check update sphere //
  319.                                                                 /////////////////////////
  320.                                                                 D3DXVECTOR3 vClosestPoint;
  321.  
  322.                                                                 CollisionManager().GetTriangles(((CGameObject*)m_vBucketItems[j])->Tree(),vTris, vClosestPoint, &nCount,&((CGameObject*)m_vBucketItems[i])->Sphere() );
  323.  
  324.                                                                 if (vTris.empty())
  325.                                                                         continue;
  326.  
  327.                                                                 float fRadius = ((CGameObject*)m_vBucketItems[i])->Sphere().GetRadius();
  328.  
  329.                                                                 int nNumTris = (int)vTris.size();
  330.  
  331.                                                                 for (int k = 0; k < nNumTris; ++k)
  332.                                                                 {
  333.                                                                         D3DXVECTOR3 vBegin = ((CGameObject*)m_vBucketItems[i])->Transform().axis_pos;
  334.                                                                         D3DXVECTOR3 toSphere(vBegin - vTris[k].vCentroid);
  335.  
  336.                                                                         float result = D3DXVec3Dot(&vTris[k].vNormal, &toSphere);
  337.                                                                        
  338.                                                                         if (result < fRadius)
  339.                                                                         {                                                                                              
  340.                                                                                 float fPenetration = fRadius - result;
  341.                                                                                
  342.                                                                                 D3DXVECTOR3 newPos = ((CGameObject*) m_vBucketItems[i])->Transform().axis_pos + vTris[k].vNormal * (fPenetration);
  343.                                                                                
  344.                                                                                 ((CGameObject*) m_vBucketItems[i])->Transform().axis_pos = newPos;
  345.                                                                                 ((CGameObject*)m_vBucketItems[i])->Sphere().SetCenter(newPos);
  346.                                                                                
  347.                                                                                 ((CRacer*)m_vBucketItems[i])->ProcessCollision((CGameObject*)m_vBucketItems[j]);
  348.                                                                         }
  349.                                                                                
  350.                                                                 }
  351.  
  352.                                                                 if (newSpeed <= 0.0f)
  353.                                                                 {
  354.                                                                         newSpeed = 0.0f;
  355.                                                                 }
  356.  
  357.                                                                 ((CRacer*)m_vBucketItems[i])->SetCurrentSpeed(newSpeed);*/
  358.                                                         }
  359.                                                         break;
  360.  
  361.                                                 case OBJECT_TRACK:
  362.                                                         {
  363.                                                                 /////////////////
  364.                                                                 // orient ship //
  365.                                                                 /////////////////
  366.                                                                 if (CollisionManager().ClampRacer(*((CGameObject*)m_vBucketItems[i]), ((CGameObject*)m_vBucketItems[j])->Tree(), 10.0f))
  367.                                                                 {
  368.                                                                         string sName = ((CSceneObject*)m_vBucketItems[j])->Name();
  369.                                                                        
  370.                                                                         if (sName.find("JumpTrack_") != string::npos)
  371.                                                                                 ((CRacer*)m_vBucketItems[i])->OnRail(true);
  372.                                                                         else
  373.                                                                                 ((CRacer*)m_vBucketItems[i])->OnRail(false);
  374.                                                                        
  375.                                                                         CollisionManager().TerrainFollow(*((CGameObject*)m_vBucketItems[i]), ((CGameObject*)m_vBucketItems[j])->Tree(), 10.0f);
  376.                                                        
  377.                                                                 } // end if                                                            
  378.                                                         }
  379.                                                         break;
  380.                                         }
  381.  
  382.                                         break;
  383.  
  384.                                 case OBJECT_WEAPON:
  385.                                         //Once we have determined, Check what it is checking against
  386.                                         switch(((CGameObject*)m_vBucketItems[j])->GetType())
  387.                                         {
  388.                                                 ///////////////////////////////////////////////////////////////
  389.                                                 ///Collide with Ship/Wall, continue if Weapon or Powerup
  390.                                                 ////////////////////////////////////////////////////////////////
  391.                                         case OBJECT_SHIP:
  392.                                                 {
  393.                                                         if(CollisionManager().Test( ((CGameObject*)m_vBucketItems[i])->Sphere(), ((CGameObject*)m_vBucketItems[j])->Sphere() ))
  394.                                                         {
  395.                                                                 if(((CRacer*)m_vBucketItems[j])->IsPlayer())
  396.                                                                 {
  397.                                                                         ((CPlayer*)m_vBucketItems[j])->ProcessCollision((CBullet*)m_vBucketItems[i]);
  398.                                                                 }
  399.                                                                 else
  400.                                                                 {
  401.                                                                         ((CAIPlayer*)m_vBucketItems[j])->ProcessCollision((CBullet*)m_vBucketItems[i]);
  402.                                                                 }
  403.  
  404.                                                                 ((CBullet*)m_vBucketItems[i])->ProcessCollision((CRacer*)m_vBucketItems[j]);                                                           
  405.                                                         }
  406.                                                 }
  407.                                                 break;
  408.                                         case OBJECT_WEAPON:
  409.                                                 {
  410.                                                         if(CollisionManager().Test( ((CGameObject*)m_vBucketItems[i])->Sphere(), ((CGameObject*)m_vBucketItems[j])->Sphere() ))
  411.                                                                 if (((CBullet*)m_vBucketItems[i])->ProcessCollision((CGameObject*)m_vBucketItems[j]))
  412.                                                                         continue;
  413.                                                         continue;
  414.                                                 }
  415.                                                 break;
  416.                                         case OBJECT_POWERUP:
  417.                                                 {
  418.                                                         continue;
  419.                                                 }
  420.                                                 break;
  421.                                         case OBJECT_BOOSTRING:
  422.                                                 {
  423.                                                         continue;
  424.                                                 }
  425.                                                 break;
  426.                                         case OBJECT_WALL:
  427.                                                 {
  428.                                                         unsigned int nCount, nIndex = 0;
  429.                                                         vector<tTriangle> vTris;
  430.                                                         D3DXVECTOR3 vClosestPoint;
  431.                                                         D3DXVECTOR3 vCollision;
  432.  
  433.                                                         CollisionManager().GetTriangles(((CGameObject*)m_vBucketItems[j])->Tree(),vTris, vClosestPoint, &nCount,&                               ((CGameObject*)m_vBucketItems[i])->Sphere() );
  434.  
  435.                                                         if (!vTris.empty())
  436.                                                         {       //continue;
  437.                                                                 vTris.clear();
  438.                                                                 if ( ((CBullet*)m_vBucketItems[i])->ProcessCollision( (CGameObject*)m_vBucketItems[j]) )
  439.                                                                 {
  440.                                                                         break;
  441.                                                                        
  442.                                                                 }
  443.                                                         }
  444.                                                         vTris.clear();
  445.  
  446.                                                 }
  447.                                         case OBJECT_TRACK:
  448.                                                 {
  449.                                                         // Clamping the bullet is causing problems
  450.                                                         // The bullet does not launch from the player correctly when facing forward
  451.                                                         // and when it hits certain points on the track it gets stuck
  452.                                                        
  453.                                                         if (CollisionManager().ClampRacer(*((CGameObject*)m_vBucketItems[i]), ((CGameObject*)m_vBucketItems[j])->Tree(), 10.0f))
  454.                                                                 CollisionManager().TerrainFollow(*((CGameObject*)m_vBucketItems[i]), ((CGameObject*)m_vBucketItems[j])->Tree(), 10.0f);
  455.  
  456.                                                 }
  457.                                                 break;
  458.                                         }
  459.                                         break;
  460.                                 case OBJECT_POWERUP:
  461.                                         //Once we have determined, Check what it is checking against
  462.                                         switch(((CGameObject*)m_vBucketItems[j])->GetType())
  463.                                         {
  464.                                                 ///////////////////////////////////////////////////////////////
  465.                                                 ///Collide only with the Player Ship
  466.                                                 ////////////////////////////////////////////////////////////////
  467.                                         case OBJECT_SHIP:
  468.                                                 if(CollisionManager().Test( ((CPickup*)m_vBucketItems[i])->Sphere(), ((CRacer*)m_vBucketItems[j])->Sphere() ))
  469.                                                 {
  470.                                                         ((CPickup*)m_vBucketItems[i])->ProcessCollision((CGameObject*)m_vBucketItems[j]);
  471.                                                         ((CRacer*)m_vBucketItems[j])->ProcessCollision((CGameObject*)m_vBucketItems[i]);
  472.                                                 }
  473.  
  474.                                                 break;
  475.                                         case OBJECT_WEAPON:
  476.                                                 continue;
  477.                                                 break;
  478.                                         case OBJECT_POWERUP:
  479.                                                 continue;
  480.                                                 break;
  481.                                         case OBJECT_BOOSTRING:
  482.                                                 {
  483.                                                         continue;
  484.                                                 }
  485.                                                 break;
  486.                                         case OBJECT_WALL:
  487.                                                 continue;
  488.                                                 break;
  489.                                         }
  490.                                         break;
  491.                                 case OBJECT_WALL:
  492.                                         //Once we have determined, Check what it is checking against
  493.                                         switch(((CGameObject*)m_vBucketItems[j])->GetType())
  494.                                         {
  495.                                                 ///////////////////////////////////////////////////////////////
  496.                                                 ///Collide only with the Player Ship
  497.                                                 ////////////////////////////////////////////////////////////////
  498.                                         case OBJECT_SHIP:
  499.                                                 //if(CollisionManager().Test( ((CGameObject*)m_vBucketItems[i])->Sphere(), ((CGameObject*)m_vBucketItems[j])->Sphere() ))
  500.                                                 //      if (((CRacer*)m_vBucketItems[i])->ProcessCollision((CGameObject*)m_vBucketItems[j]))
  501.                                                 continue;
  502.  
  503.                                                 break;
  504.                                         case OBJECT_WEAPON:
  505.                                                 //TODO: Removed HACK!
  506.                                                 break;
  507.                                         case OBJECT_POWERUP:
  508.                                                 continue;
  509.                                                 break;
  510.                                         case OBJECT_BOOSTRING:
  511.                                                 {
  512.                                                         continue;
  513.                                                 }
  514.                                                 break;
  515.                                         case OBJECT_WALL:
  516.                                                 continue;
  517.                                                 break;
  518.                                         }
  519.                                         break;
  520.  
  521.                                 default:
  522.                                         break;
  523.                         }
  524.                
  525.                 } // end for
  526.        
  527.                 switch(((CGameObject*)m_vBucketItems[i])->GetType())
  528.                 {
  529.                         case OBJECT_SHIP:
  530.                                 break;
  531.                                
  532.                 } // end switch
  533.                
  534.         } // end for
  535. }
  536.  
  537. void CUpdateCollisionBucket::Shutdown()
  538. {
  539.         m_vBucketItems.clear();
  540. }
create new paste | create new version of this paste RAW Paste Data