Forums » Help » Advanced Collision?

ig.Entity.checkPair = function( a, b ) {

        // Do these entities want checks?
        if( a.checkAgainst & b.type ) {
            a.check( b );
        }

        if( b.checkAgainst & a.type ) {
            b.check( a );
        }

        // If this pair allows collision, solve it! At least one entity must
        // collide ACTIVE or FIXED, while the other one must not collide NEVER.
        if (a.collides && b.collides) {
            ig.Entity.solveCollision( a, b );
        }
    };
    
    ig.Entity.solveCollision = function( a, b ) {

        // If one entity is FIXED, or the other entity is LITE, the weak
        // (FIXED/NON-LITE) entity won't move in collision response
        var weak = null;
        
        if (-1 * a.collides == b.collides) {
            weak = "none";
        } else if (a.collides == 9 || Math.abs(a.collides) > Math.abs(b.collides)) {
            weak = b;
        } else if (b.collides == 9 || Math.abs(a.collides) < Math.abs(b.collides)) {
            weak = a;
        }

        // Did they already overlap on the X-axis in the last frame? If so,
        // this must be a vertical collision!
        if(
            a.last.x + a.size.x > b.last.x &&
            a.last.x < b.last.x + b.size.x
        ) {
            // Which one is on top?
            if( a.last.y < b.last.y ) {
                if (weak != "none") {
                    ig.Entity.seperateOnYAxis( a, b, weak );
                }
            }
            else {
                if (weak != "none") {
                    ig.Entity.seperateOnYAxis( b, a, weak );
                }
            }
            a.collideWith( b, 'y' );
            b.collideWith( a, 'y' );
        }

        // Horizontal collision
        else if(
            a.last.y + a.size.y > b.last.y &&
            a.last.y < b.last.y + b.size.y
        ){
            // Which one is on the left?
            if( a.last.x < b.last.x ) {
                if (weak != "none") {
                    ig.Entity.seperateOnXAxis( a, b, weak );
                }
            }
            else {
                if (weak != "none") {
                    ig.Entity.seperateOnXAxis( b, a, weak );
                }
            }
            a.collideWith( b, 'x' );
            b.collideWith( a, 'x' );
        }
    };
    
    ig.Entity.seperateOnXAxis = function( left, right, weak ) {
        var nudge = (left.pos.x + left.size.x - right.pos.x);

        // We have a weak entity, so just move this one
        if( weak ) {
            var strong = left === weak ? right : left;
            weak.vel.x = -weak.vel.x * weak.bounciness + strong.vel.x;

            var resWeak = ig.game.collisionMap.trace( 
                weak.pos.x, weak.pos.y, weak == left ? -nudge : nudge, 0, weak.size.x, weak.size.y
            );
            weak.pos.x = resWeak.pos.x;
        }

        // Normal collision - both move
        else {
            /*var v2 = (left.vel.x - right.vel.x)/2;
            left.vel.x = -v2;
            right.vel.x = v2;

            var resLeft = ig.game.collisionMap.trace( 
                left.pos.x, left.pos.y, -nudge/2, 0, left.size.x, left.size.y
            );
            left.pos.x = Math.floor(resLeft.pos.x);

            var resRight = ig.game.collisionMap.trace( 
                right.pos.x, right.pos.y, nudge/2, 0, right.size.x, right.size.y
            );
            right.pos.x = Math.ceil(resRight.pos.x);*/
            
            var vel = 0;
            
            if (Math.abs(left.vel.x) > Math.abs(right.vel.x)) {
                vel = left.vel.x
            }
            
            if (Math.abs(left.vel.x) < Math.abs(right.vel.x)) {
                vel = right.vel.x
            }
            
            left.vel.x = vel;
            right.vel.x = vel;
        }
    };

    ig.Entity.seperateOnYAxis = function( top, bottom, weak ) {
        var nudge = (top.pos.y + top.size.y - bottom.pos.y);

        // We have a weak entity, so just move this one
        if( weak ) {
            var strong = top === weak ? bottom : top;
            weak.vel.y = -weak.vel.y * weak.bounciness + strong.vel.y;

            // Riding on a platform?
            var nudgeX = 0;
            if( weak == top && Math.abs(weak.vel.y - strong.vel.y) < weak.minBounceVelocity ) {
                weak.standing = true;
                nudgeX = strong.vel.x * ig.system.tick;
            }

            var resWeak = ig.game.collisionMap.trace( 
                weak.pos.x, weak.pos.y, nudgeX, weak == top ? -nudge : nudge, weak.size.x, weak.size.y
            );
            weak.pos.y = resWeak.pos.y;
            weak.pos.x = resWeak.pos.x;
        }

        // Bottom entity is standing - just bounce the top one
        else if( ig.game.gravity && (bottom.standing || top.vel.y > 0) ) {	
            var resTop = ig.game.collisionMap.trace( 
                top.pos.x, top.pos.y, 0, -(top.pos.y + top.size.y - bottom.pos.y), top.size.x, top.size.y
            );
            top.pos.y = resTop.pos.y;

            if( top.bounciness > 0 && top.vel.y > top.minBounceVelocity ) {
                top.vel.y *= -top.bounciness;		
            }
            else {
                top.standing = true;
                top.vel.y = 0;
            }
        }

        // Normal collision - both move
        else {
            /*var v2 = (top.vel.y - bottom.vel.y)/2;
            top.vel.y = -v2;
            bottom.vel.y = v2;

            var nudgeX = bottom.vel.x * ig.system.tick;
            var resTop = ig.game.collisionMap.trace( 
                top.pos.x, top.pos.y, nudgeX, -nudge/2, top.size.x, top.size.y
            );
            top.pos.y = resTop.pos.y;

            var resBottom = ig.game.collisionMap.trace( 
                bottom.pos.x, bottom.pos.y, 0, nudge/2, bottom.size.x, bottom.size.y
            );
            bottom.pos.y = resBottom.pos.y;*/
            
            var vel = 0;
            
            if (Math.abs(top.vel.x) > Math.abs(bottom.vel.x)) {
                vel = top.vel.x
            }
            
            if (Math.abs(top.vel.x) < Math.abs(bottom.vel.x)) {
                vel = bottom.vel.x
            }
            
            top.vel.x = vel;
            bottom.vel.x = vel;
        }
    };

9 years ago by Joncom