public void Execute()
        {
            firstEntity.Location         = new Vector2(firstEntity.Location.X, firstEntity.Location.Y - collision.Overlap.Height);
            collision.FirstEntity.Hitbox = new Rectangle((int)firstEntity.Location.X, (int)firstEntity.Location.Y, collision.FirstEntity.Hitbox.Width, collision.FirstEntity.Hitbox.Height);
            IPhysics physicsFirstEntity = (IPhysics)firstEntity;

            physicsFirstEntity.Velocity = new Vector2(physicsFirstEntity.Velocity.X, 0);
            if (firstEntity is IMario player && (player.MovementState is MarioLeftJumpState || player.MovementState is MarioRightJumpState))
            {
                if (physicsFirstEntity.Velocity.X < 0)
                {
                    player.MovementState = new MarioLeftRunState(player);
                }
                else if (physicsFirstEntity.Velocity.X > 0)
                {
                    player.MovementState = new MarioRightRunState(player);
                }
                else
                {
                    player.Idle();
                }
            }
            if ((firstEntity.MovementState is MarioLeftCrouchState || firstEntity.MovementState is MarioRightCrouchState) && (firstEntity.Location.X > (secondEntity.Location.X + 7)) && (firstEntity.Location.X < (secondEntity.Location.X + secondEntity.Hitbox.Width - 32)))
            {
                WarpPipe pipe = (WarpPipe)collision.SecondEntity;
                PlayerLevel.Instance.Warp(firstEntity, pipe.WarpDestination);
            }
        }
        private static void LoadLevel(XmlReader reader)
        {
            Random         random       = new Random();
            string         objectType   = "";
            string         objectName   = "";
            string         location     = "";
            bool           typeFlag     = false;
            bool           nameFlag     = false;
            bool           locationFlag = false;
            IList <IBlock> blockList    = new List <IBlock>();
            IList <IEnemy> enemyList    = new List <IEnemy>();
            IList <IItem>  itemList     = new List <IItem>();

            while (reader.Read())
            {
                if (reader.IsStartElement())
                {
                    switch (reader.Name.ToString())
                    {
                    case "ObjectType":
                        objectType = reader.ReadString();
                        typeFlag   = true;
                        break;

                    case "ObjectName":
                        objectName = reader.ReadString();
                        nameFlag   = true;
                        break;

                    case "Location":
                        location     = reader.ReadString();
                        locationFlag = true;
                        break;
                    }

                    if (typeFlag && nameFlag && locationFlag)
                    {
                        switch (objectType)
                        {
                        case "Player":
                            string[] coordinates = location.Split(' ');
                            Mario.Instance.ConditionState = new SmallMarioState(Mario.Instance);
                            Mario.Instance.Location       = new Vector2(Int32.Parse(coordinates[0]), Int32.Parse(coordinates[1]));
                            break;

                        case "Block":
                            switch (objectName)
                            {
                            case "HiddenBlock":
                                string[] blockCoordinates = location.Split(' ');
                                IBlock   block            = new HiddenBlock();
                                block.Location = new Vector2(Int32.Parse(blockCoordinates[0]), Int32.Parse(blockCoordinates[1]));
                                blockList.Add(block);
                                break;

                            case "HiddenBlockEmpty":
                                blockCoordinates = location.Split(' ');
                                block            = new HiddenBlockEmpty();
                                block.Location   = new Vector2(Int32.Parse(blockCoordinates[0]), Int32.Parse(blockCoordinates[1]));
                                blockList.Add(block);
                                break;

                            case "HiddenBlockCoin":
                                blockCoordinates = location.Split(' ');
                                block            = new HiddenBlockCoin();
                                block.Location   = new Vector2(Int32.Parse(blockCoordinates[0]), Int32.Parse(blockCoordinates[1]));
                                blockList.Add(block);
                                break;

                            case "HiddenBlockStar":
                                blockCoordinates = location.Split(' ');
                                block            = new HiddenBlockStar();
                                block.Location   = new Vector2(Int32.Parse(blockCoordinates[0]), Int32.Parse(blockCoordinates[1]));
                                blockList.Add(block);
                                break;

                            case "BrickBlock":
                                blockCoordinates = location.Split(' ');
                                block            = new BrickBlock();
                                block.Location   = new Vector2(Int32.Parse(blockCoordinates[0]), Int32.Parse(blockCoordinates[1]));
                                blockList.Add(block);
                                break;

                            case "BrickBlockEmpty":
                                blockCoordinates = location.Split(' ');
                                block            = new BrickBlockEmpty();
                                block.Location   = new Vector2(Int32.Parse(blockCoordinates[0]), Int32.Parse(blockCoordinates[1]));
                                blockList.Add(block);
                                break;

                            case "ItemBrick":
                                blockCoordinates = location.Split(' ');
                                block            = new BrickBlockWithItem();
                                block.Location   = new Vector2(Int32.Parse(blockCoordinates[0]), Int32.Parse(blockCoordinates[1]));
                                blockList.Add(block);
                                break;

                            case "ItemBrickCoin":
                                blockCoordinates = location.Split(' ');
                                block            = new BrickBlockWithCoin();
                                block.Location   = new Vector2(Int32.Parse(blockCoordinates[0]), Int32.Parse(blockCoordinates[1]));
                                blockList.Add(block);
                                break;

                            case "ItemBrickStar":
                                blockCoordinates = location.Split(' ');
                                block            = new BrickBlockWithStar();
                                block.Location   = new Vector2(Int32.Parse(blockCoordinates[0]), Int32.Parse(blockCoordinates[1]));
                                blockList.Add(block);
                                break;

                            case "QuestionBlock":
                                blockCoordinates = location.Split(' ');
                                block            = new QuestionBlock();
                                block.Location   = new Vector2(Int32.Parse(blockCoordinates[0]), Int32.Parse(blockCoordinates[1]));
                                blockList.Add(block);
                                break;

                            case "QuestionBlockEmpty":
                                blockCoordinates = location.Split(' ');
                                block            = new QuestionBlockEmpty();
                                block.Location   = new Vector2(Int32.Parse(blockCoordinates[0]), Int32.Parse(blockCoordinates[1]));
                                blockList.Add(block);
                                break;

                            case "QuestionBlockStar":
                                blockCoordinates = location.Split(' ');
                                block            = new QuestionBlockStar();
                                block.Location   = new Vector2(Int32.Parse(blockCoordinates[0]), Int32.Parse(blockCoordinates[1]));
                                blockList.Add(block);
                                break;

                            case "QuestionBlockCoin":
                                blockCoordinates = location.Split(' ');
                                block            = new QuestionBlockCoin();
                                block.Location   = new Vector2(Int32.Parse(blockCoordinates[0]), Int32.Parse(blockCoordinates[1]));
                                blockList.Add(block);
                                break;

                            case "UnbreakableBlock":
                                blockCoordinates = location.Split(' ');
                                block            = new UnbreakableBlock();
                                block.Location   = new Vector2(Int32.Parse(blockCoordinates[0]), Int32.Parse(blockCoordinates[1]));
                                blockList.Add(block);
                                break;

                            case "UsedBlock":
                                blockCoordinates = location.Split(' ');
                                block            = new UsedBlock();
                                block.Location   = new Vector2(Int32.Parse(blockCoordinates[0]), Int32.Parse(blockCoordinates[1]));
                                blockList.Add(block);
                                break;

                            case "GroundBlock":
                                blockCoordinates = location.Split(' ');
                                block            = new GroundBlock();
                                block.Location   = new Vector2(Int32.Parse(blockCoordinates[0]), Int32.Parse(blockCoordinates[1]));
                                blockList.Add(block);
                                break;

                            case "Pipe":
                                blockCoordinates = location.Split(' ');
                                block            = new Pipe();
                                block.Location   = new Vector2(Int32.Parse(blockCoordinates[0]), Int32.Parse(blockCoordinates[1]));
                                blockList.Add(block);
                                break;

                            case "PipeBottom":
                                blockCoordinates = location.Split(' ');
                                block            = new PipeBottom();
                                block.Location   = new Vector2(Int32.Parse(blockCoordinates[0]), Int32.Parse(blockCoordinates[1]));
                                blockList.Add(block);
                                break;

                            case "WarpPipe":
                                blockCoordinates = location.Split(' ');
                                WarpPipe pipe = new WarpPipe();
                                pipe.Location = new Vector2(Int32.Parse(blockCoordinates[0]), Int32.Parse(blockCoordinates[1]));
                                switch (pipe.Location.X)
                                {
                                case 1760:
                                    pipe.WarpDestination = new Vector2(8000, 384);
                                    break;

                                case 8736:
                                    pipe.WarpDestination = new Vector2(2080, 352);
                                    break;
                                }
                                blockList.Add((IBlock)pipe);
                                break;

                            case "FlagPole":
                                blockCoordinates = location.Split(' ');
                                block            = new FlagPole();
                                block.Location   = new Vector2(Int32.Parse(blockCoordinates[0]), Int32.Parse(blockCoordinates[1]));
                                blockList.Add(block);
                                break;
                            }
                            break;

                        case "Enemy":
                            switch (objectName)
                            {
                            case "Goomba":
                                string[] enemyCoordinates = location.Split(' ');
                                IEnemy   enemy            = new Goomba();
                                enemy.RowId    = random.Next(0, 160);
                                enemy.Location = new Vector2(Int32.Parse(enemyCoordinates[0]), Int32.Parse(enemyCoordinates[1]));
                                enemyList.Add(enemy);
                                break;

                            case "Koopa":
                                enemyCoordinates = location.Split(' ');
                                enemy            = new Koopa();
                                enemy.RowId      = random.Next(0, 160);
                                enemy.Location   = new Vector2(Int32.Parse(enemyCoordinates[0]), Int32.Parse(enemyCoordinates[1]));
                                enemyList.Add(enemy);
                                break;
                            }
                            break;

                        case "Item":
                            switch (objectName)
                            {
                            case "Coin":
                                string[] itemCoordinates = location.Split(' ');
                                IItem    item            = new Coin();
                                item.Location = new Vector2(Int32.Parse(itemCoordinates[0]), Int32.Parse(itemCoordinates[1]));
                                itemList.Add(item);
                                break;

                            case "FireFlower":
                                itemCoordinates = location.Split(' ');
                                item            = new FireFlower();
                                item.Location   = new Vector2(Int32.Parse(itemCoordinates[0]), Int32.Parse(itemCoordinates[1]));
                                itemList.Add(item);
                                break;

                            case "OneUpMush":
                                itemCoordinates = location.Split(' ');
                                item            = new OneUpMushroom();
                                item.Location   = new Vector2(Int32.Parse(itemCoordinates[0]), Int32.Parse(itemCoordinates[1]));
                                itemList.Add(item);
                                break;

                            case "SuperMush":
                                itemCoordinates = location.Split(' ');
                                item            = new SuperMushroom();
                                item.Location   = new Vector2(Int32.Parse(itemCoordinates[0]), Int32.Parse(itemCoordinates[1]));
                                itemList.Add(item);
                                break;

                            case "Star":
                                itemCoordinates = location.Split(' ');
                                item            = new Star();
                                item.Location   = new Vector2(Int32.Parse(itemCoordinates[0]), Int32.Parse(itemCoordinates[1]));
                                itemList.Add(item);
                                break;
                            }
                            break;
                        }
                        typeFlag     = false;
                        nameFlag     = false;
                        locationFlag = false;
                    }
                }
            }
            PlayerLevel.Instance.BlockArray = blockList;
            PlayerLevel.Instance.EnemyArray = enemyList;
            PlayerLevel.Instance.ItemArray  = itemList;
        }
Exemple #3
0
 public AscendCommand(Peach peach, WarpPipe pipe)
 {
     Peach    = peach;
     WarpPipe = pipe;
 }
 public MarioWithWarpPipeTopCollisionResponse(ICollision collision)
 {
     firstEntity    = (IMario)collision.FirstEntity;
     secondEntity   = (WarpPipe)collision.SecondEntity;
     this.collision = collision;
 }
Exemple #5
0
        public IEntity AddBlock(XmlNode x, ContentManager content, GraphicsDevice graphics, CollisionDetection collisions)
        {
            bool isUnderworld = false;

            switch (type)
            {
            case ("questionblock"):
                QuestionBlock questionBlock = new QuestionBlock(content, graphics);
                if (x.HasChildNodes)
                {
                    for (int m = Constants.ZERO; m < x.ChildNodes.Count; m++)
                    {
                        IEntity childEntity = null;
                        XmlNode y           = x.ChildNodes[m];
                        GetAttributes(y);
                        if (tag.Equals("item"))
                        {
                            childEntity = AddItem(content, graphics);
                        }
                        else if (tag.Equals("block"))
                        {
                            childEntity = AddBlock(y, content, graphics, collisions);
                        }
                        entity = childEntity;
                        SetProperties(collisions);
                        questionBlock.AddContainedItem(childEntity);
                    }
                }
                GetAttributes(x);
                entity = questionBlock;
                break;

            case ("floorblock"):
                isUnderworld = false;
                entity       = new FloorBlock(content, graphics, isUnderworld);
                break;

            case ("underworldFloor"):
                isUnderworld = true;
                entity       = new FloorBlock(content, graphics, isUnderworld);
                break;

            case ("glassblock"):
                GlassBlock glassBlock = new GlassBlock(content, graphics);
                isGlass = true;
                if (x.HasChildNodes)
                {
                    for (int m = Constants.ZERO; m < x.ChildNodes.Count; m++)
                    {
                        IEntity childEntity = null;
                        XmlNode y           = x.ChildNodes[m];
                        GetAttributes(y);
                        if (tag.Equals("block"))
                        {
                            childEntity = AddBlock(y, content, graphics, collisions);
                        }
                        entity = childEntity;
                        SetProperties(collisions);
                        glassBlock.AddContainedItem(childEntity);
                    }
                }
                GetAttributes(x);
                entity = glassBlock;
                break;

            case ("brickblock"):
                isUnderworld = false;
                BrickBlock brickBlock = new BrickBlock(content, graphics, isUnderworld);
                if (x.HasChildNodes)
                {
                    for (int m = Constants.ZERO; m < x.ChildNodes.Count; m++)
                    {
                        IEntity childEntity = null;
                        XmlNode y           = x.ChildNodes[m];
                        GetAttributes(y);
                        if (tag.Equals("item"))
                        {
                            childEntity = AddItem(content, graphics);
                        }
                        else if (tag.Equals("block"))
                        {
                            childEntity = AddBlock(y, content, graphics, collisions);
                        }
                        entity = childEntity;
                        SetProperties(collisions);
                        brickBlock.AddContainedItem(childEntity);
                    }
                }
                GetAttributes(x);
                entity = brickBlock;
                break;

            case ("underworldBrick"):
                Underworld = true;
                BrickBlock underworldBrickBlock = new BrickBlock(content, graphics, Underworld);
                if (x.HasChildNodes)
                {
                    for (int m = Constants.ZERO; m < x.ChildNodes.Count; m++)
                    {
                        IEntity childEntity = null;
                        XmlNode y           = x.ChildNodes[m];
                        GetAttributes(y);
                        if (tag.Equals("item"))
                        {
                            childEntity = AddItem(content, graphics);
                        }
                        else if (tag.Equals("block"))
                        {
                            childEntity = AddBlock(y, content, graphics, collisions);
                        }
                        entity = childEntity;
                        SetProperties(collisions);
                        underworldBrickBlock.AddContainedItem(childEntity);
                    }
                }
                GetAttributes(x);
                entity = underworldBrickBlock;
                break;

            case ("warpPipe"):
                WarpPipe warpPipe = new WarpPipe(content, graphics, ExitPipe, Underworld, MiniGame);
                if (x.HasChildNodes)
                {
                    for (int m = Constants.ZERO; m < x.ChildNodes.Count; m++)
                    {
                        IEntity childEntity = null;
                        XmlNode y           = x.ChildNodes[m];
                        GetAttributes(y);
                        if (tag.Equals("enemy"))
                        {
                            childEntity = AddEnemy(content, graphics, peach);
                        }
                        else if (tag.Equals("block"))
                        {
                            childEntity = AddBlock(y, content, graphics, collisions);
                        }
                        entity = childEntity;
                        SetProperties(collisions);
                        warpPipe.AddContainedItem(childEntity);
                    }
                }
                GetAttributes(x);
                entity = warpPipe;
                break;

            case ("stairblock"):
                entity = new StairBlock(content, graphics);
                break;

            case ("usedblock"):
                entity = new UsedBlock(content, graphics);
                break;

            case ("hiddenblock"):
                isUnderworld = false;
                HiddenBlock hiddenBlock = new HiddenBlock(content, graphics);
                if (x.HasChildNodes)
                {
                    for (int m = Constants.ZERO; m < x.ChildNodes.Count; m++)
                    {
                        IEntity childEntity = null;
                        XmlNode y           = x.ChildNodes[m];
                        GetAttributes(y);
                        if (tag.Equals("item"))
                        {
                            childEntity = AddItem(content, graphics);
                        }
                        else if (tag.Equals("block"))
                        {
                            childEntity = AddBlock(y, content, graphics, collisions);
                        }
                        entity = childEntity;
                        SetProperties(collisions);
                        hiddenBlock.AddContainedItem(childEntity);
                    }
                }
                GetAttributes(x);
                entity = hiddenBlock;
                break;

            case ("pipe"):
                entity = new Pipe(content, graphics);
                break;

            case ("explodingBlock"):
                entity = new ExplodingBlock(content, graphics, isGlass);
                break;

            case ("exitPipe"):
                entity = new WarpPipe(content, graphics, ExitPipe, Underworld, MiniGame);
                break;

            default:
                break;
            }
            return(entity);
        }