2 * Copyright (C) 2008 Patrik Gornicz, Gornicz_P (at) hotmail (dot) com.
4 * This program is free software: you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation, either version 3 of the License, or
7 * (at your option) any later version.
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
14 * You should have received a copy of the GNU General Public License
15 * along with this program. If not, see <http://www.gnu.org/licenses/>.
18 #include "collisionManager.h"
23 #include "Entities/Ball.h"
24 #include "Entities/PhysicsEntity.h"
26 #include "CollisionInfo.h"
28 /// ***** Private Class Header *****
30 /// ***** Private Method Headers *****
33 void placeEntity(PhysicsEntity* p);
34 void updateEntities();
36 void applyCollision(PhysicsEntity* p1, PhysicsEntity* p2);
37 void applyCollision(Ball* b1, Ball* b2);
39 bool getInfo(Ball* b1, Ball* b2, CollisionInfo* cInfo);
41 /// ***** Private Variables *****
43 const int xDivisions = 20;
44 const int yDivisions = 16;
45 const int screenX = 800;
46 const int screenY = 600;
48 setPhys divisions[xDivisions][yDivisions];
50 /// ***** Initializers/Cleaners *****
52 void collision::init()
56 void collision::clean()
61 /// ***** Public Methods *****
63 void collision::update(setPhys& sp)
67 for( setPhys::iterator it = sp.begin();
77 /// ***** Private Methods *****
89 divisions[x][y].clear();
94 void placeEntity(PhysicsEntity* p)
96 Ball* b = dynamic_cast<Ball*>(p);
100 DPF(0, "ENTITY TYPE NOT SUPPORTED BY placeEntity()!!");
104 const float& xb = b->positionRaw().x;
105 const float& yb = b->positionRaw().y;
106 const float& rad = b->radius;
108 for( int x = static_cast<int>( (xb - rad) / (screenX / xDivisions) );
109 x <= static_cast<int>( (xb + rad) / (screenX / xDivisions) );
112 if(x < 0 || xDivisions <= x)
115 for( int y = static_cast<int>( (yb - rad) / (screenY / yDivisions) );
116 y <= static_cast<int>( (yb + rad) / (screenY / yDivisions) );
119 if(y < 0 || yDivisions <= y)
122 divisions[x][y].insert(p);
127 void updateEntities()
137 for( setPhys::iterator it1 = divisions[x][y].begin();
138 it1 != divisions[x][y].end();
141 for( setPhys::iterator it2 = divisions[x][y].begin();
142 it2 != divisions[x][y].end();
148 applyCollision(*it1, *it2);
155 void applyCollision(PhysicsEntity* p1, PhysicsEntity* p2)
157 Ball* b1 = dynamic_cast<Ball*>(p1);
158 Ball* b2 = dynamic_cast<Ball*>(p2);
160 if( b1 != NULL && b2 != NULL )
162 applyCollision(b1, b2);
166 DPF(0, "ENTITY TYPE NOT SUPPORTED BY applyCollision()!!");
169 void applyCollision(Ball* b1, Ball* b2)
173 if(!getInfo(b1, b2, &cInfo))
176 // a few values to simplify the equations
177 const Vector2& normal = cInfo.normal;
178 const Vector2& point = cInfo.point;
183 float e = (b1->CoR + b2->CoR) / 2;
185 Vector2 v1 = b1->velocityRaw();
186 Vector2 v2 = b2->velocityRaw();
189 float iTop = -(e + 1) * (v1 - v2).dot(normal);
191 // otherwise the collision happened and we do the math the below assumes
192 // collisions have no friction
194 float impulse = iTop / (normal.dot(normal) * (1 / m1 + 1 / m2));
196 b1->applyImpulse(impulse / m1 * normal, point);
197 b2->applyImpulse(-impulse / m2 * normal, point);
200 bool getInfo(Ball* b1, Ball* b2, CollisionInfo* pcInfo)
202 // a few values to simplify the equations
203 float r1 = b1->radius;
204 float r2 = b2->radius;
206 Vector2 p1 = b1->positionRaw();
207 Vector2 p2 = b2->positionRaw();
208 Vector2 v1 = b1->velocityRaw();
209 Vector2 v2 = b2->velocityRaw();
211 // quick binding box check
212 if (p1.x - r1 > p2.x + r2
213 || p1.x + r1 < p2.x - r2
214 || p1.y - r1 > p2.y + r2
215 || p1.y + r1 < p2.y - r2)
218 // test if not touching
219 if ((p1 - p2).sqrLength() >= (r1 + r2)*(r1 + r2))
222 // test if they are moving apart in some way if they aren't it's likely
223 // that they collided last frame and are still overlapping
225 if ((v1 - v2).dot(p1 - p2) >= 0)
228 pcInfo->point = p1 - (p1 - p2) * r1 / (r1 + r2);
229 pcInfo->normal = p1 - p2;