Platformer game hit test

Question

Ok, so I have an object on the stage that moves on the "world" movieclip. I'm trying to make it so that when you're moving right. If the movieclip inside the moving movieclip("dude") called hitD collides with the walls in world, the dude stops moving forward.

Screen shots if it might help. General stage dude object selected http://prntscr.com/5bgjfq the world is everything but the ball

http://prntscr.com/5bgjuh hitD

If anyone has any way they can modify these collision physics since my current code is sketchy as hell, all suggestions and ideas are welcome.

var started:Boolean;
const NUMLEVELS = 3;
var status:String;
stage.focus = stage;
if (! started)
{// Only ever do this once!
    status = "falling";
    started = true;
    var speedX:Number = 5;
    var speedY:Number = 0;
    var topSpeedY:Number = 50;
    var start_x:Number = dude.x;
    var start_y:Number = dude.y;
    var keysDown:Object = new Object();
    stage.addEventListener(KeyboardEvent.KEY_DOWN, keyPressed);
    stage.addEventListener(KeyboardEvent.KEY_UP, keyReleased);
    stage.addEventListener( Event.DEACTIVATE, appDeactivate );
    dude.addEventListener(Event.ENTER_FRAME, moveDude);
    var W:Number = 15;
    var snows:Array = new Array();

}
for (var b:int = 0; b < 50; b++)
{
    var snow:Snow = new Snow();

    snows.push(snow);
    addChild(snow);
}


function cleanup()
{
    stage.removeEventListener(KeyboardEvent.KEY_DOWN, keyPressed);
    stage.removeEventListener(KeyboardEvent.KEY_UP, keyReleased);
    stage.removeEventListener( Event.DEACTIVATE, appDeactivate );
    dude.removeEventListener(Event.ENTER_FRAME, moveDude);
}
function keyIsDown(key:uint):Boolean
{
    return Boolean(key in keysDown);
}
function keyPressed(e:KeyboardEvent):void
{
    keysDown[e.keyCode] = true;
}
function keyReleased(e:KeyboardEvent):void
{
    delete keysDown[e.keyCode];
}
function appDeactivate( event:Event ):void
{
    // Get rid of all keypress info when app loses focus
    keysDown=new Object();
}

function moveDude(e:Event):void
{

    var obj:Object = e.target; //setting dude as object
    // for now, if you get off the top of the screen you win
    if (obj.y < 0)
    {
        cleanup();
        nextScene();
        return;
    }
    // if character dies, restart
    if (obj.y > stage.stageHeight + 100)
    {
        gotoAndStop(1);
        obj.x = start_x;
        obj.y = start_y;
    }
    if (death!=null)
    {
        if (obj.hitTestObject(death))
        {
            trace("Dead");
        }
    }

    if (status=="falling")
    {
        speedY++;
        if (speedY>topSpeedY)
        {
            speedY = topSpeedY;
        }
        for (i = 0; i<2*speedY; i++)
        {
            obj.y++;
            if (world.hitTestPoint(obj.x - obj.width / 2,obj.y,true) || world.hitTestPoint(obj.x + obj.width / 2,obj.y,true))
            {
                status = "ground";
                break;
            }
        }

    }
    else if (status == "jumping")
    {
        speedY--;
        for (i = 0; i<2*speedY; i++)
        {
            obj.y--;
            if (world.hitTestPoint(obj.x - obj.width / 2,obj.y - obj.height,true) || world.hitTestPoint(obj.x + obj.width / 2,obj.y - obj.height,true))
            {
                speedY = 0;
                break;
            }
        }

        if (speedY==0)
        {
            status = "falling";
        }
    }
    else if (status == "ground")
    {
        if (! world.hitTestPoint(obj.x - 8,obj.y,true) && ! world.hitTestPoint(obj.x + 8,obj.y + 4,true))
        {
            speedY = 0;
            status = "falling";
        }

        if (keyIsDown(Keyboard.UP))
        {
            status = "jumping";
            speedY = 10;
        }
    }
    if (keyIsDown(Keyboard.DOWN)&&status=="ground")
    {
        dude.gotoAndStop("duck");
    }
    else
    {
        if (keyIsDown(Keyboard.SHIFT))
        {
            speedX = 10;
        }
        else
        {
            speedX = 5;
        }
        if (keyIsDown(Keyboard.LEFT))
        {
            for (i = 0; i<speedX; i++)
            {
                obj.x--;
                dude.ball.rotation--; //dude.ball is a movieclip similar to dude.hitD, it spins when you move.
                if (world.hitTestPoint(obj.x - obj.width / 2 + 4,obj.y - 8,true) || world.hitTestPoint(obj.x - obj.width / 2,obj.y - obj.height + 8,true))  
                {
                    dude.ball.rotation++;

                    obj.x++;
                    break;
                }
            }

        }
        else if (keyIsDown(Keyboard.RIGHT))
        {
            //dude.gotoAndStop("right");
            //obj.scaleX = 1;
            for (i = 0; i<speedX; i++)
            {
                obj.x++;
                dude.ball.rotation++;
                // The number in obj.y-4 affects the climbing ability
                if (status == "ground")
                {
                    //dude.height+= 0.1;
                    //dude.width += 0.1;
                }//so here I'm checking if it hits the lower corner or top right corner or hitD
                if (world.hitTestPoint(dude.hitD.x + obj.hitD.width/2 , obj.hitD.y,true) || world.hitTestPoint(obj.hitD.x + obj.hitD.width/2,obj.hitD.y - obj.hitD.height ,true))
                //if (world.hitTestObject(obj))
                {

                    dude.ball.rotation--;
                    obj.x--;
                    break;
                }
            }
        }
        dude.gotoAndStop(1);

    }
    while (status == "ground" && (world.hitTestPoint(obj.x-8, obj.y-1, true) || world.hitTestPoint(obj.x+8, obj.y-1, true)))
    {
        obj.y--;
    }

    const BORDER = 50;
    var diff:int;
    // Check right border:
    diff = obj.x + BORDER - stage.stageWidth;
    if (diff>0 && world.x>=stage.stageWidth-world.width)
    {
        obj.x -=  diff;
        world.x -=  diff;
        background1.x -=  diff;
        if (death != null)
        {
            death.x -=  diff;
        }
    }
    // Check left border:
    diff = obj.x - BORDER;
    if (diff<0 && world.x<=0)
    {
        obj.x -=  diff;
        world.x -=  diff;
        background1.x -=  diff;
        if (death != null)
        {
            death.x -=  diff;
        }
    }
    // Check bottom border:
    diff = obj.y + BORDER - stage.stageHeight;
    if (diff>0)
    {
        obj.y -=  diff;
        world.y -=  diff;
        background1.y -=  diff;
        if (death != null)
        {
            death.y -=  diff;
        }
    }
    // Check top border:
    diff = obj.y - BORDER;
    if (diff<0)
    {
        obj.y -=  diff;
        world.y -=  diff;
        background1.y -=  diff;
        if (death != null)
        {
            death.y -=  diff;
        }
    }
    if (obj.x > stage.stageWidth - 25)
    {
        if (currentFrame<NUMLEVELS)
        {
            gotoAndStop(currentFrame+1);
            obj.x = 25;
        }
        else
        {
            obj.x = stage.stageWidth - 25;
        }
    }
    else if (obj.x<25)
    {
        if (currentFrame>1)
        {
            gotoAndStop(currentFrame-1);
            obj.x = stage.stageWidth - 25;
        }
        else
        {
            obj.x = 25;
        }
    }

}

Thanks in advance for any help you can provide :)

Answer 1

For player physics, it's more clear approach to make a central ENTER_FRAME handler function that just for calculating the transformations to be applied to player.

You can still get information from out, but you just process the final output there. Else, it could be problematic, especially when things gets more complex and when you want to add some more feature.(e.g. Imagine in the future, you wanted to add fans on the ground that blows air up, and player have to rise when on them. There you have a lot to change, and probably with many problems.

For collision detection, this function will provide you this information: to which direction(s) the player can't go with variables 'UpColl', 'DownColl', 'Right Coll' and 'LeftColl'. Then you can refer to this information from your main function that applies the transformation to your player. I'll give example to that also below.

function collEveryFrame(event:Event):void
{
    // capture player positions
    player_x = WORLD.player.x;
    player_y = WORLD.player.y;

    // the movie clip object where you store your solid objects. Remember, ALL MovieClip objets inside this MovieClip will taken as solid objects in your game, and regardless their shape, their boundingBox will be taken as collison. So they will all be square.
    collContainer = WORLD.cW;
    // your player's collision object
    playerColl = WORLD.player;

    // RIGHT SQUARE COLLISION DETECTION
    for (var i:int; i < collContainer.numChildren; i++)
    {
        // Check if any collision object colliding with player
        if (playerColl.hitTestObject(collContainer.getChildAt(i)))
        {
        // One collision detected. Check 'from which side' does the player colliding with the object;
        if (collContainer.getChildAt(i).y > playerColl.y + playerColl.height - p1MoveSpeed)
        {
            playerColl.y = collContainer.getChildAt(i).y - playerColl.height;
            DownColl = true;
        }
        else if (collContainer.getChildAt(i).y + collContainer.getChildAt(i).height < playerColl.y + p1MoveSpeed)
        {
            playerColl.y = collContainer.getChildAt(i).y + collContainer.getChildAt(i).height;
            UpColl = true;
        }
        else if (collContainer.getChildAt(i).x + collContainer.getChildAt(i).width < playerColl.x + p1MoveSpeed)
        {
            playerColl.x =  +  collContainer.getChildAt(i).x + collContainer.getChildAt(i).width;
            LeftColl = true;
        }
        else if (collContainer.getChildAt(i).x > playerColl.x + playerColl.width - p1MoveSpeed)
        {
            playerColl.x =  +  collContainer.getChildAt(i).x - playerColl.width;
            RightColl = true;
        }
        }
    }
    // RIGHT SQUARE COLLISION DETECTION [End]
}

Transformation function;

function playerMovement(event:Event):void
{
    // (apply this for all sides)
    // if nothing keeps player from going right; 
    if (! RightColl)
    {
        // Apply everything currently pushing the player to right
        if (keyIsDown(Keyboard.RIGHT))
        {
            movement_Right = 15;
        }else{
            movement_Right = 0;
        }
        // example fictional wind function returns wind speed
        windSpeed = getWindSpeed();

        player.x +=  movement_Right + windSpeed + etc + etc;
        // say windSpeed is -5 (Wind is coming from right, so pushing the player to left)
        // so if user pressing right arrow key, player will move to right 10px for every frame, else 5px to left, etc.
    }
}

In this way, everything about physics will be easy to implement. For example, when calculating the movement to down, add gravity and jump etc.