This was originally a forum post so I hope you guys don't mind it being 2 questions in one.

I am making a game and I got some basic physics implemented. I have 2 problems, 1 with particles being drawn in the wrong place and one with going through walls while jumping in corners.

Skip over to about 15 sec video showing the 2 problems : http://youtube.com/watch?v=Tm9nfWsWfiM

So the problem with the particles seems to be coming from the removal, as soon as I remove that piece of code it instantly works, but there shouldn't be a problem since they shouldn't even draw when their energy gets to 0 (and then they get removed)

So my first question is, how are these particles getting warped all over the screen ?

Relevant code :

Particle class :

class Particle
{
    //Physics
    public Vector2 position = new Vector2(0,0);
    public float direction = 180;
    public float speed = 100;
    public float energy = 1;
    protected float startEnergy = 1;

    //Visual
    public Sprite sprite;
    public float rotation = 0;
    public float scale = 1;
    public byte alpha = 255;
    public BlendMode blendMode
    {
        get
        {
            return sprite.BlendMode;
        }
        set
        {
            sprite.BlendMode = value;
        }
    }


    public Particle()
    {  
    }

    public virtual void Think(float frameTime)
    {
        if (energy - frameTime < 0)
            energy = 0;
        else
            energy -= frameTime;

        position += new Vector2((float)Math.Cos(MathHelper.DegToRad(direction)), (float)Math.Sin(MathHelper.DegToRad(direction))) * speed * frameTime;
        alpha = (byte)(255 * energy / startEnergy);
        sprite.Rotation = rotation;
        sprite.Position = position;
        sprite.Color = new Color(sprite.Color.R, sprite.Color.G, sprite.Color.B, alpha);
    }

    public virtual void Draw(float frameTime)
    {
        if (energy > 0)
        {
            World.camera.DrawSprite(sprite);
        }
    }
// Basic particle implementation
    class BasicSprite : Particle
    {
        public BasicSprite(Sprite _sprite)
        {
            sprite = _sprite;
        }
    }

Emitter :

    class Emitter
{
    protected static Random rand = new Random();
    protected List<Particle> particles = new List<Particle>();

    public BaseEntity target = null;
    public Vector2 position = new Vector2(0, 0);
    public bool Active = true;
    public float timeAlive = 0;
    public int particleCount = 0;
    public int ParticlesPerSeccond
    {
        get
        {
            return (int)(1 / particleSpawnTime);
        }
        set
        {
            particleSpawnTime = 1 / (float)value;
        }
    }
    public float dieTime = float.MaxValue;

    float particleSpawnTime = 0.05f;
    float spawnTime = 0;

    public Emitter()
    {

    }

    public virtual void Think(float frametime)
    {
            spawnTime += frametime;

            if (dieTime != float.MaxValue)
            {
                timeAlive += frametime;
                if (timeAlive >= dieTime)
                    Active = false;
            }

            if (Active)
            {

                if (target != null)
                    position = target.Position;

                while (spawnTime > particleSpawnTime)
                {
                    spawnTime -= particleSpawnTime;
                    AddParticle();
                    particleCount++;
                }

            }
            for (int i = 0; i < particles.Count; i++)
            {
                particles[i].Think(frametime);
                if (particles[i].energy <= 0)
                {
                    particles.Remove(particles[i]); // As soon as this is removed, it works
                    particleCount--;
                }
            }
    }

    public virtual void AddParticle()
    {

    }

    public virtual void Draw(float frametime)
    {
        foreach (Particle particle in particles)
        {
            particle.Draw(frametime);
        }
    }
}
class BloodEmitter : Emitter
{
    Image image;

    public BloodEmitter()
    {
        image = new Image(@"Content/Particles/TinyCircle.png");
        image.CreateMaskFromColor(new Color(255, 0, 255, 255));
        this.dieTime = 0.5f;
        this.ParticlesPerSeccond = 100;
    }

    public override void AddParticle()
    {
        Sprite sprite = new Sprite(image);
        sprite.Color = new Color((byte)(rand.NextDouble() * 255), (byte)(rand.NextDouble() * 255), (byte)(rand.NextDouble() * 255));

        BasicSprite particle = new BasicSprite(sprite);
        particle.direction = (float)rand.NextDouble() * 360;
        particle.position = position;
        particle.blendMode = BlendMode.Alpha;
        particles.Add(particle);
    }
}

The seccond problem is the physics problem, for some reason I can get through the right bottom corner while jumping. I think this is coming from me switching animations but I thought I made it compensate for that.

Relevant code : PhysicsEntity :

    class PhysicsEntity : BaseEntity
{
    // Horizontal movement constants
    protected const float maxHorizontalSpeed = 1000;
    protected const float horizontalAcceleration = 15;
    protected const float horizontalDragAir = 0.95f;
    protected const float horizontalDragGround = 0.95f;

    // Vertical movement constants
    protected const float maxVerticalSpeed = 1000;
    protected const float verticalAcceleration = 20;

    // Everything needed for movement and correct animations
    protected float movement = 0;
    protected bool onGround = false;
    protected Vector2 Velocity = new Vector2(0, 0);
    protected float maxSpeed = 0;
    float lastThink = 0;
    float thinkTime = 1f/60f;

    public PhysicsEntity(Vector2 position, Sprite sprite) :
        base(position, sprite)
    {

    }

    public override void Draw(float frameTime)
    {
        base.Draw(frameTime);
    }

    public override void Think(float frameTime)
    {
        CalculateMovement(frameTime);
        base.Think(frameTime);
    }

    protected void CalculateMovement(float frameTime)
    {
        lastThink += frameTime;

        while (lastThink > thinkTime)
        {
            onGround = false;

            Velocity.X = MathHelper.Clamp(Velocity.X + horizontalAcceleration * movement, -maxHorizontalSpeed, maxHorizontalSpeed);
            if (onGround)
                Velocity.X *= horizontalDragGround;
            else
                Velocity.X *= horizontalDragAir;

            if (maxSpeed < Velocity.X)
                maxSpeed = Velocity.X;

            Velocity.Y = MathHelper.Clamp(Velocity.Y + verticalAcceleration, -maxVerticalSpeed, maxVerticalSpeed);

            lastThink -= thinkTime;
            DoCollisions(thinkTime);
            DoAnimations(thinkTime);
        }
    }
    public virtual void DoAnimations(float frameTime)
    {

    }
    public void DoCollisions(float frameTime)
    {
        Position.Y += Velocity.Y * frameTime;
        Vector2 tileCollision = GetTileCollision();
        if (tileCollision.X != -1 || tileCollision.Y != -1)
        {
            Vector2 collisionDepth = CollisionRectangle.DepthIntersection(
                new Rectangle(
                    tileCollision.X * World.tileEngine.TileWidth,
                    tileCollision.Y * World.tileEngine.TileHeight,
                    World.tileEngine.TileWidth,
                    World.tileEngine.TileHeight
                )
            );
            Position.Y += collisionDepth.Y;
            if (collisionDepth.Y < 0)
                onGround = true;

            Velocity.Y = 0;
        }

        Position.X += Velocity.X * frameTime;
        tileCollision = GetTileCollision();
        if (tileCollision.X != -1 || tileCollision.Y != -1)
        {
            Vector2 collisionDepth = CollisionRectangle.DepthIntersection(
                new Rectangle(
                    tileCollision.X * World.tileEngine.TileWidth,
                    tileCollision.Y * World.tileEngine.TileHeight,
                    World.tileEngine.TileWidth,
                    World.tileEngine.TileHeight
                )
            );
            Position.X += collisionDepth.X;
            Velocity.X = 0;
        }
    }
    public void DoCollisions(Vector2 difference)
    {
        CollisionRectangle.Y = Position.Y - difference.Y;
        CollisionRectangle.Height += difference.Y;
        Vector2 tileCollision = GetTileCollision();
        if (tileCollision.X != -1 || tileCollision.Y != -1)
        {
            Vector2 collisionDepth = CollisionRectangle.DepthIntersection(
                new Rectangle(
                    tileCollision.X * World.tileEngine.TileWidth,
                    tileCollision.Y * World.tileEngine.TileHeight,
                    World.tileEngine.TileWidth,
                    World.tileEngine.TileHeight
                )
            );
            Position.Y += collisionDepth.Y;
            if (collisionDepth.Y < 0)
                onGround = true;

            Velocity.Y = 0;
        }

        CollisionRectangle.X = Position.X - difference.X;
        CollisionRectangle.Width += difference.X;
        tileCollision = GetTileCollision();
        if (tileCollision.X != -1 || tileCollision.Y != -1)
        {
            Vector2 collisionDepth = CollisionRectangle.DepthIntersection(
                new Rectangle(
                    tileCollision.X * World.tileEngine.TileWidth,
                    tileCollision.Y * World.tileEngine.TileHeight,
                    World.tileEngine.TileWidth,
                    World.tileEngine.TileHeight
                )
            );
            Position.X += collisionDepth.X;
            Velocity.X = 0;
        }
    }

    Vector2 GetTileCollision()
    {
        int topLeftTileX = (int)(CollisionRectangle.TopLeft.X / World.tileEngine.TileWidth);
        int topLeftTileY = (int)(CollisionRectangle.TopLeft.Y / World.tileEngine.TileHeight);
        int BottomRightTileX = (int)(CollisionRectangle.DownRight.X / World.tileEngine.TileWidth);
        int BottomRightTileY = (int)(CollisionRectangle.DownRight.Y / World.tileEngine.TileHeight);

        if (CollisionRectangle.DownRight.Y % World.tileEngine.TileHeight == 0) // If your exactly against the tile don't count that as being inside the tile
            BottomRightTileY -= 1;
        if (CollisionRectangle.DownRight.X % World.tileEngine.TileWidth == 0) // If your exactly against the tile don't count that as being inside the tile
            BottomRightTileX -= 1;

        for (int i = topLeftTileX; i <= BottomRightTileX; i++)
        {
            for (int j = topLeftTileY; j <= BottomRightTileY; j++)
            {
                if (World.tileEngine.TileIsSolid(i, j))
                {
                    return new Vector2(i, j);
                }
            }
        }

        return new Vector2(-1, -1);
    }
}

Player :

   enum State
{
    Standing,
    Running,
    Jumping,
    Falling,
    Sliding,
    WallSlide
}

class Player : PhysicsEntity
{
    private State state
    {
        get
        {
            return currentState;
        }
        set
        {
            if (currentState != value)
            {
                currentState = value;
                animationChanged = true;
            }
        }
    }

    private State currentState = State.Standing;
    private BasicEmitter basicEmitter = new BasicEmitter();
    public bool flipped;
    public bool animationChanged = false;

    protected const float jumpPower = 600;

    AnimationManager animationManager;
    Rectangle DrawRectangle;
    public override Rectangle CollisionRectangle
    {
        get
        {
            return new Rectangle(
                Position.X - DrawRectangle.Width / 2f,
                Position.Y - DrawRectangle.Height / 2f,
                DrawRectangle.Width,
                DrawRectangle.Height
            );
        }
    }

    public Player(Vector2 position, Sprite sprite) :
        base(position, sprite)
    {
        // Only posted the relevant bit
        DrawRectangle = animationManager.currentAnimation.drawingRectangle;
    }

    public override void Draw(float frameTime)
    {
        World.camera.DrawSprite(
            Sprite, 
            Position + new Vector2(DrawRectangle.X, DrawRectangle.Y),
            animationManager.currentAnimation.drawingRectangle
        );
    }

    public override void Think(float frameTime)
    {
        //I only posted the relevant stuff
        if (animationChanged)  
        {
            // if the animation has changed make sure we compensate for the change in with and height
            animationChanged = false;
            DoCollisions(animationManager.getSizeDifference());
        }
        DoCustomMovement();
        base.Think(frameTime);
        if (!onGround && Velocity.Y > 0)
        {
            state = State.Falling;
        }
    }

    void DoCustomMovement()
    {
        if (onGround)
        {
            if (World.renderWindow.Input.IsKeyDown(KeyCode.W))
            {
                Velocity.Y = -jumpPower;
                state = State.Jumping;
            }
        }
    }
    public override void DoAnimations(float frameTime)
    {
        string stateName = Enum.GetName(typeof(State), state);

        if (!animationManager.currentAnimationIs(stateName))
        {
            animationManager.PlayAnimation(stateName);
        }

        animationManager.Think(frameTime);

        DrawRectangle = animationManager.currentAnimation.drawingRectangle;
        Sprite.Center = new Vector2(
            DrawRectangle.X + DrawRectangle.Width / 2,
            DrawRectangle.Y + DrawRectangle.Height / 2
        );
        Sprite.FlipX(flipped);
    }

So why am I warping through walls ?

I have given this some thought but I just can't seem to find out why this is happening.

Full source if needed : source : http://www.mediafire.com/?rc7ddo09gnr68zd (download link)