Elysian Shadows

Code: Select all

 void circleToCircleCollision(Entity* circleA, Entity* circleB)
   {
      //Determines the strength of reflection, this will be expanded on later.
      float bounce=1.0f;
      //Note: i store the deltaX and deltaY in a vector for convenience.
      vector2<float> delta(circleA->x-circleB->x,circleA->y-circleB->y);

      float  distance=delta.magnitude();

      //entities have a width and a height, from this we can create a radius by using the one that is larger (this is a temporary way of getting the combined radius of each entity)
      float totalRadius=0.0f;
      circleA->sizeX>circleA->sizeY?totalRadius+=circleA->sizeX:totalRadius+=circleA->sizeY;
      circleB->sizeX>circleB->sizeY?totalRadius+=circleB->sizeX:totalRadius+=circleB->sizeY;

      //simple circle to circle collision detection
      if(distance <= totalRadius)
      {
         delta.normalise();

         float  velocityA = (circleA->motion.x*delta.x) + (circleA->motion.y*delta.y);
         float  velocityB = (circleB->motion.x*delta.x) + (circleB->motion.y*delta.y);
         
         if((velocityA-velocityB)!=0.0f)
         {
            float  deltatime = (totalRadius - distance)/(velocityA - velocityB);
            //Move the circles so they are in the position where they had just touched.
            circleA->x-=circleA->motion.x*deltatime;
            circleA->y-=circleA->motion.y*deltatime;
            
            circleB->x-=circleB->motion.x* deltatime;
            circleB->y-=circleB->motion.y* deltatime;
            
            //
            float  projectionA=(circleA->motion.x*delta.x) + (circleA->motion.y*delta.y);
            float  _projectionA=(circleA->motion.y*delta.x) - (circleA->motion.x*delta.y);
            
            float  projectionB=(circleB->motion.x*delta.x) + (circleB->motion.y*delta.y);
            float  _projectionB=(circleB->motion.y*delta.x) - (circleB->motion.x*delta.y);
            
            //new velocity
            float vA=(projectionA+bounce*(projectionB - projectionA))/(1.0f+(circleA->mass/circleB->mass));
            
            float vB=(projectionB+bounce*(projectionA - projectionB))/(1.0f+(circleA->mass/circleB->mass));
            
            //Use the attained data to assign the new motion vector
            circleA->motion.x =((vA*delta.x) - (_projectionA*delta.y));
            circleA->motion.y =((vA*delta.y) + (_projectionA*delta.x));
            
            circleB->motion.x =((vB*delta.x) - (_projectionB*delta.y));
            circleB->motion.y =((vB*delta.y) + (_projectionB*delta.x));
            
            //The balls position was shifted 'back in time' so we shift it once more to account for this.
            circleA->x+=circleA->motion.x* deltatime;
            circleA->y+=circleA->motion.y* deltatime;
            
            circleB->x+=circleB->motion.x* deltatime;
            circleB->y+=circleB->motion.y* deltatime;
         }
      }

Code: Select all

vec2 reflect_vector( vec2 incoming, vec2 normal )
{
       return incoming - 2.0 * normal * dot_product( normal, incoming );
}

Code: Select all

if( collision )
{  
       float dampingFactor = 1.0F;

       vec2 collisionNormal = vec2( circleB.Center - circleA.center );
       vec2 circleAVel = circleA.GetVelocity();
       vec2 circleBVel = circleB.GetVelocity();

       // Obtain resultant vector for Circle A //
       circleAVel = reflect_vector( circleAVel, collisionNormal ) * dampingFactor;
    
       // Flip the normal //
       collisionNormal *= -1.0F;

      // Obtain resultant vector fir Circle B //
      circleBVel = reflect_vector( circleBVel, collisionNormal ) * dampingFactor;

      // Update positions & shit //
}

Code: Select all

bool collide(Circle& a, Circle& b)
{
    // separation vector
    Vector d(b.pos - a.pos);

    // distance between circle centres, squared
    float distance_squared = d.DotProduct(d);

    // combined radius squared
    float radius = b.rad + a.rad;
    float radius_squared = radius * radius;
 
    // circles too far apart
    if(distance_squared > radius_squared) 
        return false;

    // distance between circle centres
    float distance = (float) sqrt(distance_squared);

    // normal of collision
    Vector ncoll = (d / distance);

    // penetration distance
    float dcoll = (radius - d);

    // inverse masses (0 means, infinite mass, object is static).
    float ima = (a.mass > 0.0f)? 1.0f / a.mass : 0.0f;
    float imb = (b.mass > 0.0f)? 1.0f / b.mass : 0.0f;

    // separation vector
    Vector separation_vector = ncoll * (dcoll / (ima + imb));

    // separate the circles
    a.pos -= separation_vector * ima;
    b.pos += separation_vector * imb;

    // combines velocity
    Vector vcoll = (b.vel - a.vel);
   
    // impact speed 
    vector vn = vcoll.DotProduct(ncoll);
    
    // obejcts are moving away. dont reflect velocity
    if(vn > 0.0f) 
        return true; // we did collide

    // coefficient of restitution in range [0, 1].
    const float cor = 0.95f; // air hockey -> high cor

    // collision impulse
    float j = -(1.0f + cor) * (vn) / (ima + imb);

    // collision impusle vector
    Vector impulse = j * ncoll;

    // change momentum of the circles
    a.vel -= impulse * ima;
    b.vel += impulse * imb;

    // collision reported
    return true;
}