Alvaro Cassinelli / Mbed 2 deprecated skinGames_forktest

just a test

Dependencies:   mbed

Fork of scoreLight_Advanced by Alvaro Cassinelli

classPointMass.cpp@2:34157ebbf56b, 2012-03-31 (annotated)

Committer:
mbedalvaro
Date:
Sat Mar 31 12:50:32 2012 +0000
Revision:
2:34157ebbf56b
Parent:
1:a4050fee11f7
Child:
3:b44ff6de81bd
- Debugged some subtle problem that made the motion of the rigidLoops strange (when damping factor was too small, the blobs would start moving faster and faster sometimes, and oscillate - the reason being the VERLET integration and the fact that the up...

Who changed what in which revision?

UserRevisionLine numberNew contents of line
mbedalvaro 0:345b3bc7a0ea 1 /*
mbedalvaro 0:345b3bc7a0ea 2 * pointMass.cpp
mbedalvaro 0:345b3bc7a0ea 3 * laserBlob
mbedalvaro 0:345b3bc7a0ea 4 *
mbedalvaro 0:345b3bc7a0ea 5 * Created by CASSINELLI ALVARO on 5/19/11.
mbedalvaro 0:345b3bc7a0ea 6 * Copyright 2011 TOKYO UNIVERSITY. All rights reserved.
mbedalvaro 0:345b3bc7a0ea 7 *
mbedalvaro 0:345b3bc7a0ea 8 */
mbedalvaro 0:345b3bc7a0ea 9
mbedalvaro 0:345b3bc7a0ea 10 #include "classPointMass.h"
mbedalvaro 0:345b3bc7a0ea 11
mbedalvaro 0:345b3bc7a0ea 12 //------------------------------------------------------------
mbedalvaro 0:345b3bc7a0ea 13 pointMass::pointMass(){
mbedalvaro 0:345b3bc7a0ea 14 setIntegrationStep(.01); // default in case we don't call integration step setting
mbedalvaro 0:345b3bc7a0ea 15 // NOTE: it is important to set dt before inital conditions in case of VERLET integration, because we need the integration
mbedalvaro 0:345b3bc7a0ea 16 // step for properly setting the initial speed.
mbedalvaro 0:345b3bc7a0ea 17 setInitialCondition(0,0,0,0);// default in case we don't call to initial conditions.
mbedalvaro 0:345b3bc7a0ea 18 setWallLimits(100,100,4000,4000);
mbedalvaro 0:345b3bc7a0ea 19 mass=1.0;
mbedalvaro 0:345b3bc7a0ea 20 dampMotion = 0.0175;//0.025 was good for bigger blobs;//2f;//0.07f;
mbedalvaro 0:345b3bc7a0ea 21 dampBorder = 0.013f; //0.07f
mbedalvaro 0:345b3bc7a0ea 22 bFixed = false;
mbedalvaro 0:345b3bc7a0ea 23 bWallCollision=false;
mbedalvaro 0:345b3bc7a0ea 24 }
mbedalvaro 0:345b3bc7a0ea 25
mbedalvaro 0:345b3bc7a0ea 26 //------------------------------------------------------------
mbedalvaro 0:345b3bc7a0ea 27 void pointMass::resetForce(){
mbedalvaro 0:345b3bc7a0ea 28 totalForce.set(0,0);
mbedalvaro 0:345b3bc7a0ea 29 }
mbedalvaro 0:345b3bc7a0ea 30
mbedalvaro 0:345b3bc7a0ea 31 //------------------------------------------------------------
mbedalvaro 0:345b3bc7a0ea 32 void pointMass::addForce(float x, float y){
mbedalvaro 0:345b3bc7a0ea 33 totalForce.x = totalForce.x + x;
mbedalvaro 0:345b3bc7a0ea 34 totalForce.y = totalForce.y + y;
mbedalvaro 0:345b3bc7a0ea 35 }
mbedalvaro 0:345b3bc7a0ea 36
mbedalvaro 0:345b3bc7a0ea 37 //------------------------------------------------------------
mbedalvaro 0:345b3bc7a0ea 38 void pointMass::addForce(vector2D forceToAdd){
mbedalvaro 0:345b3bc7a0ea 39 totalForce+=forceToAdd;
mbedalvaro 0:345b3bc7a0ea 40 }
mbedalvaro 0:345b3bc7a0ea 41
mbedalvaro 0:345b3bc7a0ea 42 //------------------------------------------------------------
mbedalvaro 0:345b3bc7a0ea 43 void pointMass::addInvSquareForce(float x, float y, float radiusMin, float radiusMax, float scale){
mbedalvaro 0:345b3bc7a0ea 44
mbedalvaro 0:345b3bc7a0ea 45 vector2D posOfForce;
mbedalvaro 0:345b3bc7a0ea 46 posOfForce.set(x,y);
mbedalvaro 0:345b3bc7a0ea 47
mbedalvaro 0:345b3bc7a0ea 48 vector2D diff = pos - posOfForce; // note: we use the position AT TIME T, so this force is at time t
mbedalvaro 0:345b3bc7a0ea 49 float length = diff.length();
mbedalvaro 0:345b3bc7a0ea 50
mbedalvaro 0:345b3bc7a0ea 51 // check close enough and far enough (to avoid singularities for example):
mbedalvaro 0:345b3bc7a0ea 52 if ((length>radiusMin)&&(length<radiusMax)) {
mbedalvaro 0:345b3bc7a0ea 53 diff.normalize();
mbedalvaro 0:345b3bc7a0ea 54 totalForce += diff * scale * 1.0/(length*length+1);
mbedalvaro 0:345b3bc7a0ea 55 }
mbedalvaro 0:345b3bc7a0ea 56 }
mbedalvaro 0:345b3bc7a0ea 57
mbedalvaro 0:345b3bc7a0ea 58 void pointMass::addInterInvSquareForce(pointMass &theOtherParticle, float radiusMin, float radiusMax, float scale){
mbedalvaro 0:345b3bc7a0ea 59
mbedalvaro 0:345b3bc7a0ea 60 vector2D posOfForce;
mbedalvaro 0:345b3bc7a0ea 61 posOfForce.set(theOtherParticle.pos);
mbedalvaro 0:345b3bc7a0ea 62
mbedalvaro 0:345b3bc7a0ea 63 vector2D diff = pos - posOfForce; // note: we use the position AT TIME T, so this force is at time t
mbedalvaro 0:345b3bc7a0ea 64 float length = diff.length();
mbedalvaro 0:345b3bc7a0ea 65
mbedalvaro 0:345b3bc7a0ea 66 // check close enough and far enough (to avoid singularities for example):
mbedalvaro 0:345b3bc7a0ea 67 if ((length>radiusMin)&&(length<radiusMax)) {
mbedalvaro 0:345b3bc7a0ea 68 diff.normalize();
mbedalvaro 0:345b3bc7a0ea 69 totalForce += diff * scale * 1.0/(length*length+1);
mbedalvaro 0:345b3bc7a0ea 70 theOtherParticle.totalForce -= diff * scale * 1.0/(length*length+1);
mbedalvaro 0:345b3bc7a0ea 71 }
mbedalvaro 0:345b3bc7a0ea 72 }
mbedalvaro 0:345b3bc7a0ea 73
mbedalvaro 0:345b3bc7a0ea 74
mbedalvaro 0:345b3bc7a0ea 75 //------------------------------------------------------------
mbedalvaro 0:345b3bc7a0ea 76 void pointMass::addSpringForce(float centerx, float centery, float radius, float scale){
mbedalvaro 0:345b3bc7a0ea 77
mbedalvaro 0:345b3bc7a0ea 78 // ----------- (1) make a vector of where this particle p is:
mbedalvaro 0:345b3bc7a0ea 79 vector2D posOfForce;
mbedalvaro 0:345b3bc7a0ea 80 posOfForce.set(centerx, centery);
mbedalvaro 0:345b3bc7a0ea 81
mbedalvaro 0:345b3bc7a0ea 82 // ----------- (2) calculate the difference & length
mbedalvaro 0:345b3bc7a0ea 83
mbedalvaro 0:345b3bc7a0ea 84 vector2D diff = pos - posOfForce;
mbedalvaro 0:345b3bc7a0ea 85 float length = diff.length();
mbedalvaro 0:345b3bc7a0ea 86
mbedalvaro 0:345b3bc7a0ea 87 // ----------- (3) check close enough
mbedalvaro 0:345b3bc7a0ea 88
mbedalvaro 0:345b3bc7a0ea 89 bool bAmCloseEnough = true;
mbedalvaro 0:345b3bc7a0ea 90 if (radius > 0){
mbedalvaro 0:345b3bc7a0ea 91 if (length > radius){
mbedalvaro 0:345b3bc7a0ea 92 bAmCloseEnough = false;
mbedalvaro 0:345b3bc7a0ea 93 }
mbedalvaro 0:345b3bc7a0ea 94 }
mbedalvaro 0:345b3bc7a0ea 95
mbedalvaro 0:345b3bc7a0ea 96 // ----------- (4) if so, update force
mbedalvaro 0:345b3bc7a0ea 97
mbedalvaro 0:345b3bc7a0ea 98 if (bAmCloseEnough == true){
mbedalvaro 0:345b3bc7a0ea 99 float pct = 1 - (length / radius); // stronger on the inside
mbedalvaro 0:345b3bc7a0ea 100 diff.normalize();
mbedalvaro 0:345b3bc7a0ea 101 totalForce += diff * scale * pct;
mbedalvaro 0:345b3bc7a0ea 102 }
mbedalvaro 0:345b3bc7a0ea 103 }
mbedalvaro 0:345b3bc7a0ea 104
mbedalvaro 0:345b3bc7a0ea 105 void pointMass::addInterSpringForce(pointMass &theOtherParticle, float radius, float scale){
mbedalvaro 0:345b3bc7a0ea 106
mbedalvaro 0:345b3bc7a0ea 107 // ----------- (1) make a vector of where this particle p is:
mbedalvaro 0:345b3bc7a0ea 108 vector2D posOfForce;
mbedalvaro 0:345b3bc7a0ea 109 posOfForce.set(theOtherParticle.pos);
mbedalvaro 0:345b3bc7a0ea 110
mbedalvaro 0:345b3bc7a0ea 111 // ----------- (2) calculate the difference & length
mbedalvaro 0:345b3bc7a0ea 112
mbedalvaro 0:345b3bc7a0ea 113 vector2D diff = pos - posOfForce;
mbedalvaro 0:345b3bc7a0ea 114 float length = diff.length();
mbedalvaro 0:345b3bc7a0ea 115
mbedalvaro 0:345b3bc7a0ea 116 // ----------- (3) check close enough
mbedalvaro 0:345b3bc7a0ea 117
mbedalvaro 0:345b3bc7a0ea 118 bool bAmCloseEnough = true;
mbedalvaro 0:345b3bc7a0ea 119 if (radius > 0){
mbedalvaro 0:345b3bc7a0ea 120 if (length > radius){
mbedalvaro 0:345b3bc7a0ea 121 bAmCloseEnough = false;
mbedalvaro 0:345b3bc7a0ea 122 }
mbedalvaro 0:345b3bc7a0ea 123 }
mbedalvaro 0:345b3bc7a0ea 124
mbedalvaro 0:345b3bc7a0ea 125 // ----------- (4) if so, update REPULSIVE force
mbedalvaro 0:345b3bc7a0ea 126
mbedalvaro 0:345b3bc7a0ea 127 if (bAmCloseEnough == true){
mbedalvaro 0:345b3bc7a0ea 128 float pct = 1 - (length / radius);
mbedalvaro 0:345b3bc7a0ea 129 diff.normalize();
mbedalvaro 0:345b3bc7a0ea 130 totalForce += diff * scale * pct;
mbedalvaro 0:345b3bc7a0ea 131 theOtherParticle.totalForce -= diff * scale * pct;
mbedalvaro 0:345b3bc7a0ea 132 //theOtherParticle.frc.x = p.frc.x - diff.x * scale * pct;
mbedalvaro 0:345b3bc7a0ea 133 //theOtherParticle.frc.y = p.frc.y - diff.y * scale * pct;
mbedalvaro 0:345b3bc7a0ea 134 }
mbedalvaro 0:345b3bc7a0ea 135 }
mbedalvaro 0:345b3bc7a0ea 136
mbedalvaro 0:345b3bc7a0ea 137
mbedalvaro 0:345b3bc7a0ea 138
mbedalvaro 0:345b3bc7a0ea 139 //------------------------------------------------------------
mbedalvaro 0:345b3bc7a0ea 140 void pointMass::addDampingForce(){ // NOTE: use only in case of EULER intgration!
mbedalvaro 0:345b3bc7a0ea 141 totalForce-= speed* dampMotion;
mbedalvaro 0:345b3bc7a0ea 142 }
mbedalvaro 0:345b3bc7a0ea 143
mbedalvaro 0:345b3bc7a0ea 144 //------------------------------------------------------------
mbedalvaro 0:345b3bc7a0ea 145 void pointMass::setIntegrationStep(float _dt){
mbedalvaro 0:345b3bc7a0ea 146 dt=_dt;
mbedalvaro 0:345b3bc7a0ea 147 }
mbedalvaro 0:345b3bc7a0ea 148
mbedalvaro 0:345b3bc7a0ea 149 //------------------------------------------------------------
mbedalvaro 0:345b3bc7a0ea 150 void pointMass::setInitialCondition(float px, float py, float vx, float vy){
mbedalvaro 0:345b3bc7a0ea 151 #ifndef VERLET_METHOD
mbedalvaro 0:345b3bc7a0ea 152 pos.set(px,py);
mbedalvaro 0:345b3bc7a0ea 153 speed.set(vx,vy);
mbedalvaro 0:345b3bc7a0ea 154 #else
mbedalvaro 0:345b3bc7a0ea 155 // In case of Verlet method, setting the speed is a little more complicated. It involves in particular the integration step
mbedalvaro 0:345b3bc7a0ea 156 // through the approximation formula:
mbedalvaro 0:345b3bc7a0ea 157 // speed = (posNew-posOld)/(2*dt), or speed=(pos-posOld)/dt. Hence:
mbedalvaro 0:345b3bc7a0ea 158 posOld.set(px, py);
mbedalvaro 0:345b3bc7a0ea 159 setSpeed(vx, vy); // this assumes posOld known
mbedalvaro 0:345b3bc7a0ea 160 #endif
mbedalvaro 0:345b3bc7a0ea 161 }
mbedalvaro 0:345b3bc7a0ea 162
mbedalvaro 0:345b3bc7a0ea 163 //-------------------------------------------------------
mbedalvaro 0:345b3bc7a0ea 164 vector2D pointMass::getSpeed() {
mbedalvaro 0:345b3bc7a0ea 165 // this will give an estimate of the speed (not computed explicitly using the Verlet integration):
mbedalvaro 0:345b3bc7a0ea 166 //speed=(posNew-posOld)/(2*dt); // the variable speed is also updated (note: it is private)
mbedalvaro 1:a4050fee11f7 167 speed=(pos-posOld)/dt; // less approximate than the above, but we avoid having a global posNew variable (remember we will have many particles...)
mbedalvaro 0:345b3bc7a0ea 168 return(speed);
mbedalvaro 0:345b3bc7a0ea 169 }
mbedalvaro 0:345b3bc7a0ea 170
mbedalvaro 1:a4050fee11f7 171 void pointMass::setSpeed(const vector2D& vel) { // VERY IMPORTANT! in the case of verlet integration, we need to set dt BEFORE setting the initial speed.
mbedalvaro 0:345b3bc7a0ea 172 speed.set(vel); // enough for EULER METHOD
mbedalvaro 2:34157ebbf56b 173
mbedalvaro 2:34157ebbf56b 174 // NECESSARY for VERLET METHOD (we assume posOld known):
mbedalvaro 2:34157ebbf56b 175 // pos=speed*dt+posOld; // when dampMotion=0 (no damping)
mbedalvaro 2:34157ebbf56b 176 // With damping:
mbedalvaro 2:34157ebbf56b 177 // we have: speed=(posNew-posOld)/(2*dt) and posNew=pos*(2.0-dampMotion)-posOld*(1.0-dampMotion), so:
mbedalvaro 2:34157ebbf56b 178 // pos=(speed*2*dt+posOld+posOld*(1.0-dampMotion))/(2.0-dampMotion);
mbedalvaro 2:34157ebbf56b 179 pos=speed*2*dt/(2.0-dampMotion)+posOld;
mbedalvaro 2:34157ebbf56b 180
mbedalvaro 0:345b3bc7a0ea 181 // no need to compute newPos
mbedalvaro 0:345b3bc7a0ea 182 }
mbedalvaro 0:345b3bc7a0ea 183
mbedalvaro 1:a4050fee11f7 184 void pointMass::setSpeed(float vx, float vy) { // VERY IMPORTANT! in the case of verlet integration, we need to set dt BEFORE setting the initial speed.
mbedalvaro 0:345b3bc7a0ea 185 speed.set(vx, vy); // enough for EULER METHOD
mbedalvaro 2:34157ebbf56b 186
mbedalvaro 2:34157ebbf56b 187 // NECESSARY for VERLET METHOD (we assume posOld known):
mbedalvaro 2:34157ebbf56b 188 // pos=speed*dt+posOld; // when dampMotion=0 (no damping)
mbedalvaro 2:34157ebbf56b 189 // With damping:
mbedalvaro 2:34157ebbf56b 190 // we have: speed=(posNew-posOld)/(2*dt) and posNew=pos*(2.0-dampMotion)-posOld*(1.0-dampMotion), so:
mbedalvaro 2:34157ebbf56b 191 // pos=(speed*2*dt+posOld+posOld*(1.0-dampMotion))/(2.0-dampMotion);
mbedalvaro 2:34157ebbf56b 192 pos=speed*2*dt/(2.0-dampMotion)+posOld;
mbedalvaro 2:34157ebbf56b 193
mbedalvaro 0:345b3bc7a0ea 194 // no need to compute newPos
mbedalvaro 0:345b3bc7a0ea 195 }
mbedalvaro 0:345b3bc7a0ea 196
mbedalvaro 0:345b3bc7a0ea 197 void pointMass::setPos(float px, float py) { // assuming the speed is unchanged (must do some tweaking in case of Verlet integration)
mbedalvaro 0:345b3bc7a0ea 198 pos.set(px, py);
mbedalvaro 2:34157ebbf56b 199 posOld=pos-speed*dt;// no damping! attn...
mbedalvaro 0:345b3bc7a0ea 200 }
mbedalvaro 0:345b3bc7a0ea 201
mbedalvaro 0:345b3bc7a0ea 202 //------------------------------------------------------------
mbedalvaro 0:345b3bc7a0ea 203 void pointMass::update(){
mbedalvaro 0:345b3bc7a0ea 204 if (bFixed == false){
mbedalvaro 0:345b3bc7a0ea 205 acc=totalForce/mass; // this is the acceleration at time t
mbedalvaro 1:a4050fee11f7 206
mbedalvaro 0:345b3bc7a0ea 207 #ifndef VERLET_METHOD
mbedalvaro 0:345b3bc7a0ea 208 // The following equations (Euler integration) assume acceleration constant during time dt:
mbedalvaro 0:345b3bc7a0ea 209 speed = speed + acc*dt;
mbedalvaro 0:345b3bc7a0ea 210 pos = pos + speed*dt ;//+acc*dt*dt*0.5;
mbedalvaro 0:345b3bc7a0ea 211 #else
mbedalvaro 1:a4050fee11f7 212
mbedalvaro 0:345b3bc7a0ea 213 // The following equations are for VERLET integration with pseudo-damping:
mbedalvaro 2:34157ebbf56b 214 //Without damping this is just:
mbedalvaro 2:34157ebbf56b 215 //vector2D posNew=posOld*2 - pos + acc*dt*dt; // i.e., dampMotion=0;
mbedalvaro 2:34157ebbf56b 216 // With damping:
mbedalvaro 2:34157ebbf56b 217 // vector2D posNew=(pos*(2.0-dampMotion)-posOld*(1.0-dampMotion)+acc*dt*dt); // BAD!!! THIS NOTATION will introduce precision artefacts!!!
mbedalvaro 2:34157ebbf56b 218 vector2D posNew=pos+(pos-posOld)*(1-dampMotion)+acc*dt*dt;
mbedalvaro 0:345b3bc7a0ea 219
mbedalvaro 2:34157ebbf56b 220 // ATTENTION: because of the precision of the float or double used, it may be that (pos - posNew) is not 0, when it should ( this produces VERY strange motion artefacts).
mbedalvaro 2:34157ebbf56b 221 // So, I will test if that difference is smaller than an arbitrary tollerance in this numerical implementation (for each coordinate), and if so, will FORCE posNew to be equal to pos.
mbedalvaro 2:34157ebbf56b 222 // Note: no need to compute the norm of the difference (in fact, we need the abs difference for each component of the difference vector). Fortunately, nothing is needed here, because we can put the
mbedalvaro 2:34157ebbf56b 223 // expression in a better way that automatically makes 0 the contribution of something smaller than the precision (so the following is not really necessary)
mbedalvaro 2:34157ebbf56b 224 // vector2D diff=(pos-posOld)*(1-dampMotion);
mbedalvaro 2:34157ebbf56b 225 // Precision correction (separate axis or not):
mbedalvaro 2:34157ebbf56b 226 // if (abs(diff.x)<0.00001) diff.x=diff.x;
mbedalvaro 2:34157ebbf56b 227 // if (abs(diff.y)<0.00001) diff.y=diff.y;
mbedalvaro 2:34157ebbf56b 228 // if (posOld.match(pos, 0.001)==true) {posNew=pos; speed.set(0,0);}
mbedalvaro 2:34157ebbf56b 229 // vector2D posNew=pos+diff+acc*dt*dt;
mbedalvaro 2:34157ebbf56b 230
mbedalvaro 0:345b3bc7a0ea 231 posOld=pos;
mbedalvaro 0:345b3bc7a0ea 232 pos=posNew;
mbedalvaro 0:345b3bc7a0ea 233
mbedalvaro 0:345b3bc7a0ea 234 // NOTE: we can also estimate the speed if we want. But this may be unnecessary (call getSpeed() for that).
mbedalvaro 0:345b3bc7a0ea 235
mbedalvaro 0:345b3bc7a0ea 236 #endif
mbedalvaro 0:345b3bc7a0ea 237
mbedalvaro 0:345b3bc7a0ea 238 }
mbedalvaro 0:345b3bc7a0ea 239 }
mbedalvaro 0:345b3bc7a0ea 240
mbedalvaro 0:345b3bc7a0ea 241 void pointMass::setWallLimits(float Minx, float Miny, float Maxx, float Maxy) {
mbedalvaro 0:345b3bc7a0ea 242 maxWall.set(Maxx, Maxy);
mbedalvaro 0:345b3bc7a0ea 243 minWall.set(Minx, Miny);
mbedalvaro 0:345b3bc7a0ea 244 }
mbedalvaro 0:345b3bc7a0ea 245
mbedalvaro 0:345b3bc7a0ea 246 //------------------------------------------------------------
mbedalvaro 0:345b3bc7a0ea 247 void pointMass::bounceOffWalls(){
mbedalvaro 0:345b3bc7a0ea 248 // NOTE: bounce is easy in case of EULER method; in case of VERLET, we need to do some hack on the positions.
mbedalvaro 0:345b3bc7a0ea 249 //Note: the walls are in (vector2D) horizontalLimits and verticalLimits
mbedalvaro 0:345b3bc7a0ea 250
mbedalvaro 0:345b3bc7a0ea 251 bWallCollision=false;
mbedalvaro 0:345b3bc7a0ea 252 innerCollitionDirection.set(0,0);
mbedalvaro 0:345b3bc7a0ea 253 #ifndef VERLET_METHOD // EULER METHOD!!
mbedalvaro 0:345b3bc7a0ea 254
mbedalvaro 0:345b3bc7a0ea 255 if (pos.x > maxWall.x){
mbedalvaro 0:345b3bc7a0ea 256 pos.x = maxWall.x;
mbedalvaro 0:345b3bc7a0ea 257 speed.x *= -1;
mbedalvaro 0:345b3bc7a0ea 258 bWallCollision = true;
mbedalvaro 0:345b3bc7a0ea 259 innerCollitionDirection.x=-1;
mbedalvaro 0:345b3bc7a0ea 260 } else if (pos.x < minWall.x){
mbedalvaro 0:345b3bc7a0ea 261 pos.x = minWall.x;
mbedalvaro 0:345b3bc7a0ea 262 speed.x *= -1;
mbedalvaro 0:345b3bc7a0ea 263 bWallCollision = true;
mbedalvaro 0:345b3bc7a0ea 264 innerCollitionDirection.x=1;
mbedalvaro 0:345b3bc7a0ea 265 }
mbedalvaro 0:345b3bc7a0ea 266
mbedalvaro 0:345b3bc7a0ea 267 if (pos.y > maxWall.y){
mbedalvaro 0:345b3bc7a0ea 268 pos.y = maxWall.y;
mbedalvaro 0:345b3bc7a0ea 269 speed.y *= -1;
mbedalvaro 0:345b3bc7a0ea 270 bWallCollision = true;
mbedalvaro 0:345b3bc7a0ea 271 innerCollitionDirection.y=-1;
mbedalvaro 0:345b3bc7a0ea 272 } else if (pos.y < minWall.y){
mbedalvaro 0:345b3bc7a0ea 273 pos.y = minWall.y;
mbedalvaro 0:345b3bc7a0ea 274 speed.y *= -1;
mbedalvaro 0:345b3bc7a0ea 275 bWallCollision = true;
mbedalvaro 0:345b3bc7a0ea 276 innerCollitionDirection.y=1;
mbedalvaro 0:345b3bc7a0ea 277 }
mbedalvaro 0:345b3bc7a0ea 278
mbedalvaro 0:345b3bc7a0ea 279 if (bWallCollision) {
mbedalvaro 0:345b3bc7a0ea 280 // damping:
mbedalvaro 0:345b3bc7a0ea 281 speed *=(1-dampBorder);
mbedalvaro 0:345b3bc7a0ea 282 // normalization of collision direction:
mbedalvaro 0:345b3bc7a0ea 283 innerCollitionDirection.normalize();
mbedalvaro 0:345b3bc7a0ea 284 }
mbedalvaro 0:345b3bc7a0ea 285
mbedalvaro 0:345b3bc7a0ea 286 #else // THIS IS FOR VERLET METHOD:
mbedalvaro 0:345b3bc7a0ea 287 // we need to estimate the inverted, damped vector for bumping::
mbedalvaro 1:a4050fee11f7 288 vector2D bumpVector=getSpeed()*dt*(dampBorder-1.0); // assuming dampBorder<1 of course
mbedalvaro 0:345b3bc7a0ea 289 if (pos.x > maxWall.x){
mbedalvaro 0:345b3bc7a0ea 290 //posOld.x=pos.x;
mbedalvaro 0:345b3bc7a0ea 291 //pos.x=pos.x+bumpVector.x;
mbedalvaro 0:345b3bc7a0ea 292 posOld.x=maxWall.x;
mbedalvaro 0:345b3bc7a0ea 293 pos.x=maxWall.x+bumpVector.x;
mbedalvaro 0:345b3bc7a0ea 294 bWallCollision = true; // this is just computed here to detect bumps
mbedalvaro 0:345b3bc7a0ea 295 innerCollitionDirection.x=-1;
mbedalvaro 0:345b3bc7a0ea 296 } else if (pos.x < minWall.x){
mbedalvaro 0:345b3bc7a0ea 297 posOld.x=minWall.x;
mbedalvaro 0:345b3bc7a0ea 298 pos.x=minWall.x+bumpVector.x;
mbedalvaro 0:345b3bc7a0ea 299 innerCollitionDirection.x=1;
mbedalvaro 0:345b3bc7a0ea 300 bWallCollision = true;
mbedalvaro 0:345b3bc7a0ea 301 }
mbedalvaro 0:345b3bc7a0ea 302
mbedalvaro 0:345b3bc7a0ea 303 if (pos.y > maxWall.y){
mbedalvaro 0:345b3bc7a0ea 304 posOld.y=maxWall.y;
mbedalvaro 0:345b3bc7a0ea 305 pos.y=maxWall.y+bumpVector.y;
mbedalvaro 0:345b3bc7a0ea 306 innerCollitionDirection.y=-1;
mbedalvaro 0:345b3bc7a0ea 307 bWallCollision = true;
mbedalvaro 0:345b3bc7a0ea 308 } else if (pos.y < minWall.y){
mbedalvaro 0:345b3bc7a0ea 309 posOld.y=minWall.y;
mbedalvaro 0:345b3bc7a0ea 310 pos.y=minWall.y+bumpVector.y;
mbedalvaro 0:345b3bc7a0ea 311 innerCollitionDirection.y=1;
mbedalvaro 0:345b3bc7a0ea 312 bWallCollision = true;
mbedalvaro 0:345b3bc7a0ea 313 }
mbedalvaro 0:345b3bc7a0ea 314 #endif
mbedalvaro 0:345b3bc7a0ea 315
mbedalvaro 0:345b3bc7a0ea 316 }