Alvaro Cassinelli / Mbed 2 deprecated skinGames_forktest

just a test

Dependencies:   mbed

Fork of scoreLight_Advanced by Alvaro Cassinelli

classPointMass.cpp@4:f9d364f10335, 2012-04-04 (annotated)

Committer:
mbedalvaro
Date:
Wed Apr 04 10:05:25 2012 +0000
Revision:
4:f9d364f10335
Parent:
3:b44ff6de81bd
Child:
5:73cd58b58f95
- the new optimized laser output buffer has not been tested, but it compiles; - I am commiting here, because I am planning to change the structure of the classes: soundSpot will not contain an object of type classLaserSensingTrajectory, but be a CHILD o...

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 4:f9d364f10335 150 void pointMass::setInitialCondition(vector2D _pos, vector2D _speed) {
mbedalvaro 4:f9d364f10335 151 setInitialCondition(_pos.x, _pos.y, _speed.x, _speed.y);
mbedalvaro 4:f9d364f10335 152 }
mbedalvaro 0:345b3bc7a0ea 153 void pointMass::setInitialCondition(float px, float py, float vx, float vy){
mbedalvaro 0:345b3bc7a0ea 154 #ifndef VERLET_METHOD
mbedalvaro 0:345b3bc7a0ea 155 pos.set(px,py);
mbedalvaro 0:345b3bc7a0ea 156 speed.set(vx,vy);
mbedalvaro 0:345b3bc7a0ea 157 #else
mbedalvaro 0:345b3bc7a0ea 158 // In case of Verlet method, setting the speed is a little more complicated. It involves in particular the integration step
mbedalvaro 0:345b3bc7a0ea 159 // through the approximation formula:
mbedalvaro 0:345b3bc7a0ea 160 // speed = (posNew-posOld)/(2*dt), or speed=(pos-posOld)/dt. Hence:
mbedalvaro 0:345b3bc7a0ea 161 posOld.set(px, py);
mbedalvaro 0:345b3bc7a0ea 162 setSpeed(vx, vy); // this assumes posOld known
mbedalvaro 0:345b3bc7a0ea 163 #endif
mbedalvaro 0:345b3bc7a0ea 164 }
mbedalvaro 0:345b3bc7a0ea 165
mbedalvaro 0:345b3bc7a0ea 166 //-------------------------------------------------------
mbedalvaro 0:345b3bc7a0ea 167 vector2D pointMass::getSpeed() {
mbedalvaro 0:345b3bc7a0ea 168 // this will give an estimate of the speed (not computed explicitly using the Verlet integration):
mbedalvaro 0:345b3bc7a0ea 169 //speed=(posNew-posOld)/(2*dt); // the variable speed is also updated (note: it is private)
mbedalvaro 1:a4050fee11f7 170 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 171 return(speed);
mbedalvaro 0:345b3bc7a0ea 172 }
mbedalvaro 0:345b3bc7a0ea 173
mbedalvaro 1:a4050fee11f7 174 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 175 speed.set(vel); // enough for EULER METHOD
mbedalvaro 2:34157ebbf56b 176
mbedalvaro 2:34157ebbf56b 177 // NECESSARY for VERLET METHOD (we assume posOld known):
mbedalvaro 2:34157ebbf56b 178 // pos=speed*dt+posOld; // when dampMotion=0 (no damping)
mbedalvaro 2:34157ebbf56b 179 // With damping:
mbedalvaro 2:34157ebbf56b 180 // we have: speed=(posNew-posOld)/(2*dt) and posNew=pos*(2.0-dampMotion)-posOld*(1.0-dampMotion), so:
mbedalvaro 2:34157ebbf56b 181 // pos=(speed*2*dt+posOld+posOld*(1.0-dampMotion))/(2.0-dampMotion);
mbedalvaro 2:34157ebbf56b 182 pos=speed*2*dt/(2.0-dampMotion)+posOld;
mbedalvaro 2:34157ebbf56b 183
mbedalvaro 0:345b3bc7a0ea 184 // no need to compute newPos
mbedalvaro 0:345b3bc7a0ea 185 }
mbedalvaro 0:345b3bc7a0ea 186
mbedalvaro 1:a4050fee11f7 187 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 188 speed.set(vx, vy); // enough for EULER METHOD
mbedalvaro 2:34157ebbf56b 189
mbedalvaro 2:34157ebbf56b 190 // NECESSARY for VERLET METHOD (we assume posOld known):
mbedalvaro 2:34157ebbf56b 191 // pos=speed*dt+posOld; // when dampMotion=0 (no damping)
mbedalvaro 2:34157ebbf56b 192 // With damping:
mbedalvaro 2:34157ebbf56b 193 // we have: speed=(posNew-posOld)/(2*dt) and posNew=pos*(2.0-dampMotion)-posOld*(1.0-dampMotion), so:
mbedalvaro 2:34157ebbf56b 194 // pos=(speed*2*dt+posOld+posOld*(1.0-dampMotion))/(2.0-dampMotion);
mbedalvaro 2:34157ebbf56b 195 pos=speed*2*dt/(2.0-dampMotion)+posOld;
mbedalvaro 2:34157ebbf56b 196
mbedalvaro 0:345b3bc7a0ea 197 // no need to compute newPos
mbedalvaro 0:345b3bc7a0ea 198 }
mbedalvaro 0:345b3bc7a0ea 199
mbedalvaro 0:345b3bc7a0ea 200 void pointMass::setPos(float px, float py) { // assuming the speed is unchanged (must do some tweaking in case of Verlet integration)
mbedalvaro 0:345b3bc7a0ea 201 pos.set(px, py);
mbedalvaro 2:34157ebbf56b 202 posOld=pos-speed*dt;// no damping! attn...
mbedalvaro 0:345b3bc7a0ea 203 }
mbedalvaro 0:345b3bc7a0ea 204
mbedalvaro 0:345b3bc7a0ea 205 //------------------------------------------------------------
mbedalvaro 0:345b3bc7a0ea 206 void pointMass::update(){
mbedalvaro 0:345b3bc7a0ea 207 if (bFixed == false){
mbedalvaro 0:345b3bc7a0ea 208 acc=totalForce/mass; // this is the acceleration at time t
mbedalvaro 1:a4050fee11f7 209
mbedalvaro 0:345b3bc7a0ea 210 #ifndef VERLET_METHOD
mbedalvaro 0:345b3bc7a0ea 211 // The following equations (Euler integration) assume acceleration constant during time dt:
mbedalvaro 0:345b3bc7a0ea 212 speed = speed + acc*dt;
mbedalvaro 0:345b3bc7a0ea 213 pos = pos + speed*dt ;//+acc*dt*dt*0.5;
mbedalvaro 0:345b3bc7a0ea 214 #else
mbedalvaro 3:b44ff6de81bd 215 // acc=0;//
mbedalvaro 0:345b3bc7a0ea 216 // The following equations are for VERLET integration with pseudo-damping:
mbedalvaro 2:34157ebbf56b 217 //Without damping this is just:
mbedalvaro 2:34157ebbf56b 218 //vector2D posNew=posOld*2 - pos + acc*dt*dt; // i.e., dampMotion=0;
mbedalvaro 2:34157ebbf56b 219 // With damping:
mbedalvaro 2:34157ebbf56b 220 // vector2D posNew=(pos*(2.0-dampMotion)-posOld*(1.0-dampMotion)+acc*dt*dt); // BAD!!! THIS NOTATION will introduce precision artefacts!!!
mbedalvaro 2:34157ebbf56b 221 vector2D posNew=pos+(pos-posOld)*(1-dampMotion)+acc*dt*dt;
mbedalvaro 0:345b3bc7a0ea 222
mbedalvaro 2:34157ebbf56b 223 // 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 224 // 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 225 // 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 226 // 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 227 // vector2D diff=(pos-posOld)*(1-dampMotion);
mbedalvaro 2:34157ebbf56b 228 // Precision correction (separate axis or not):
mbedalvaro 2:34157ebbf56b 229 // if (abs(diff.x)<0.00001) diff.x=diff.x;
mbedalvaro 2:34157ebbf56b 230 // if (abs(diff.y)<0.00001) diff.y=diff.y;
mbedalvaro 2:34157ebbf56b 231 // if (posOld.match(pos, 0.001)==true) {posNew=pos; speed.set(0,0);}
mbedalvaro 2:34157ebbf56b 232 // vector2D posNew=pos+diff+acc*dt*dt;
mbedalvaro 2:34157ebbf56b 233
mbedalvaro 0:345b3bc7a0ea 234 posOld=pos;
mbedalvaro 0:345b3bc7a0ea 235 pos=posNew;
mbedalvaro 0:345b3bc7a0ea 236
mbedalvaro 0:345b3bc7a0ea 237 // NOTE: we can also estimate the speed if we want. But this may be unnecessary (call getSpeed() for that).
mbedalvaro 0:345b3bc7a0ea 238
mbedalvaro 0:345b3bc7a0ea 239 #endif
mbedalvaro 0:345b3bc7a0ea 240
mbedalvaro 0:345b3bc7a0ea 241 }
mbedalvaro 0:345b3bc7a0ea 242 }
mbedalvaro 0:345b3bc7a0ea 243
mbedalvaro 0:345b3bc7a0ea 244 void pointMass::setWallLimits(float Minx, float Miny, float Maxx, float Maxy) {
mbedalvaro 0:345b3bc7a0ea 245 maxWall.set(Maxx, Maxy);
mbedalvaro 0:345b3bc7a0ea 246 minWall.set(Minx, Miny);
mbedalvaro 0:345b3bc7a0ea 247 }
mbedalvaro 0:345b3bc7a0ea 248
mbedalvaro 0:345b3bc7a0ea 249 //------------------------------------------------------------
mbedalvaro 0:345b3bc7a0ea 250 void pointMass::bounceOffWalls(){
mbedalvaro 0:345b3bc7a0ea 251 // 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 252 //Note: the walls are in (vector2D) horizontalLimits and verticalLimits
mbedalvaro 0:345b3bc7a0ea 253
mbedalvaro 0:345b3bc7a0ea 254 bWallCollision=false;
mbedalvaro 0:345b3bc7a0ea 255 innerCollitionDirection.set(0,0);
mbedalvaro 0:345b3bc7a0ea 256 #ifndef VERLET_METHOD // EULER METHOD!!
mbedalvaro 0:345b3bc7a0ea 257
mbedalvaro 0:345b3bc7a0ea 258 if (pos.x > maxWall.x){
mbedalvaro 0:345b3bc7a0ea 259 pos.x = maxWall.x;
mbedalvaro 0:345b3bc7a0ea 260 speed.x *= -1;
mbedalvaro 0:345b3bc7a0ea 261 bWallCollision = true;
mbedalvaro 0:345b3bc7a0ea 262 innerCollitionDirection.x=-1;
mbedalvaro 0:345b3bc7a0ea 263 } else if (pos.x < minWall.x){
mbedalvaro 0:345b3bc7a0ea 264 pos.x = minWall.x;
mbedalvaro 0:345b3bc7a0ea 265 speed.x *= -1;
mbedalvaro 0:345b3bc7a0ea 266 bWallCollision = true;
mbedalvaro 0:345b3bc7a0ea 267 innerCollitionDirection.x=1;
mbedalvaro 0:345b3bc7a0ea 268 }
mbedalvaro 0:345b3bc7a0ea 269
mbedalvaro 0:345b3bc7a0ea 270 if (pos.y > maxWall.y){
mbedalvaro 0:345b3bc7a0ea 271 pos.y = maxWall.y;
mbedalvaro 0:345b3bc7a0ea 272 speed.y *= -1;
mbedalvaro 0:345b3bc7a0ea 273 bWallCollision = true;
mbedalvaro 0:345b3bc7a0ea 274 innerCollitionDirection.y=-1;
mbedalvaro 0:345b3bc7a0ea 275 } else if (pos.y < minWall.y){
mbedalvaro 0:345b3bc7a0ea 276 pos.y = minWall.y;
mbedalvaro 0:345b3bc7a0ea 277 speed.y *= -1;
mbedalvaro 0:345b3bc7a0ea 278 bWallCollision = true;
mbedalvaro 0:345b3bc7a0ea 279 innerCollitionDirection.y=1;
mbedalvaro 0:345b3bc7a0ea 280 }
mbedalvaro 0:345b3bc7a0ea 281
mbedalvaro 0:345b3bc7a0ea 282 if (bWallCollision) {
mbedalvaro 0:345b3bc7a0ea 283 // damping:
mbedalvaro 0:345b3bc7a0ea 284 speed *=(1-dampBorder);
mbedalvaro 0:345b3bc7a0ea 285 // normalization of collision direction:
mbedalvaro 0:345b3bc7a0ea 286 innerCollitionDirection.normalize();
mbedalvaro 0:345b3bc7a0ea 287 }
mbedalvaro 0:345b3bc7a0ea 288
mbedalvaro 0:345b3bc7a0ea 289 #else // THIS IS FOR VERLET METHOD:
mbedalvaro 0:345b3bc7a0ea 290 // we need to estimate the inverted, damped vector for bumping::
mbedalvaro 1:a4050fee11f7 291 vector2D bumpVector=getSpeed()*dt*(dampBorder-1.0); // assuming dampBorder<1 of course
mbedalvaro 0:345b3bc7a0ea 292 if (pos.x > maxWall.x){
mbedalvaro 0:345b3bc7a0ea 293 //posOld.x=pos.x;
mbedalvaro 0:345b3bc7a0ea 294 //pos.x=pos.x+bumpVector.x;
mbedalvaro 0:345b3bc7a0ea 295 posOld.x=maxWall.x;
mbedalvaro 0:345b3bc7a0ea 296 pos.x=maxWall.x+bumpVector.x;
mbedalvaro 0:345b3bc7a0ea 297 bWallCollision = true; // this is just computed here to detect bumps
mbedalvaro 0:345b3bc7a0ea 298 innerCollitionDirection.x=-1;
mbedalvaro 0:345b3bc7a0ea 299 } else if (pos.x < minWall.x){
mbedalvaro 0:345b3bc7a0ea 300 posOld.x=minWall.x;
mbedalvaro 0:345b3bc7a0ea 301 pos.x=minWall.x+bumpVector.x;
mbedalvaro 0:345b3bc7a0ea 302 innerCollitionDirection.x=1;
mbedalvaro 0:345b3bc7a0ea 303 bWallCollision = true;
mbedalvaro 0:345b3bc7a0ea 304 }
mbedalvaro 0:345b3bc7a0ea 305
mbedalvaro 0:345b3bc7a0ea 306 if (pos.y > maxWall.y){
mbedalvaro 0:345b3bc7a0ea 307 posOld.y=maxWall.y;
mbedalvaro 0:345b3bc7a0ea 308 pos.y=maxWall.y+bumpVector.y;
mbedalvaro 0:345b3bc7a0ea 309 innerCollitionDirection.y=-1;
mbedalvaro 0:345b3bc7a0ea 310 bWallCollision = true;
mbedalvaro 0:345b3bc7a0ea 311 } else if (pos.y < minWall.y){
mbedalvaro 0:345b3bc7a0ea 312 posOld.y=minWall.y;
mbedalvaro 0:345b3bc7a0ea 313 pos.y=minWall.y+bumpVector.y;
mbedalvaro 0:345b3bc7a0ea 314 innerCollitionDirection.y=1;
mbedalvaro 0:345b3bc7a0ea 315 bWallCollision = true;
mbedalvaro 0:345b3bc7a0ea 316 }
mbedalvaro 0:345b3bc7a0ea 317 #endif
mbedalvaro 0:345b3bc7a0ea 318
mbedalvaro 0:345b3bc7a0ea 319 }