Exemplo n.º 1
0
        public void InitWASD(MarioGame mainGame, Level inUse)
        {
            Mario mainMario = (Mario)inUse.Player;

            press.Add(Keys.W, new UpCommand(mainMario));
            release.Add(Keys.W, new ManageJump(mainMario));
            keyList.Add(Keys.W);

            press.Add(Keys.S, new DownCommand(mainMario));
            release.Add(Keys.S, new ReleaseCrouch(mainMario));
            keyList.Add(Keys.S);

            press.Add(Keys.A, new LeftCommand(mainMario));
            release.Add(Keys.A, new LeftMovementFlagCommand(mainMario));
            keyList.Add(Keys.A);

            press.Add(Keys.D, new RightCommand(mainMario));
            release.Add(Keys.D, new RightMovementFlagCommand(mainMario));
            keyList.Add(Keys.D);

            press.Add(Keys.Q, new QuitCommand(mainGame));
            keyList.Add(Keys.Q);

            press.Add(Keys.R, new ResetCommand());
            keyList.Add(Keys.R);

            press.Add(Keys.L, new ShootFireCommand(mainMario, inUse));
            release.Add(Keys.L, new EnablePowerAttack(mainMario));
            keyList.Add(Keys.L);

            press.Add(Keys.P, new PauseGameCommand());
            release.Add(Keys.P, new EnablePauseCommand());
            keyList.Add(Keys.P);
        }
Exemplo n.º 2
0
        public void LoadLevelContent(String fileName, MarioGame game)
        {
            levelReader = new XmlTextReader(fileName);
            levelReader.MoveToContent();
            Type[] ConstructorTypes = new Type[2];
            ConstructorTypes[0] = typeof(int);
            ConstructorTypes[1] = typeof(int);

            while (levelReader.ReadToFollowing("item"))
            {
                String   MovementType;
                String   ObjectType;
                Object[] Position = new Object[2];

                levelReader.ReadToDescendant("Type");
                levelReader.MoveToFirstAttribute();
                MovementType = levelReader.Value;
                levelReader.MoveToElement();
                levelReader.ReadToNextSibling("Object");
                levelReader.MoveToFirstAttribute();
                ObjectType = levelReader.Value;
                levelReader.MoveToElement();
                levelReader.ReadToNextSibling("Location");
                levelReader.MoveToFirstAttribute();
                Position[0] = Convert.ToInt32(levelReader.Value);
                levelReader.MoveToNextAttribute();
                Position[1] = Convert.ToInt32(levelReader.Value);

                IGameObject CurrentObject = (IGameObject)Type.GetType("SuperMario." + ObjectType).GetConstructor(ConstructorTypes).Invoke(Position);
                if (MovementType.Equals("Background"))
                {
                    backgroundObjects.Add(CurrentObject);
                }
                else if (MovementType.Equals("Dynamic"))
                {
                    dynamicObjects.Add(CurrentObject);
                }
                else
                {
                    int ListPos = CurrentObject.XCoordinate / GlobalVariables.BlockSize;
                    if (staticObjects.ContainsKey(ListPos))
                    {
                        staticObjects[ListPos].Add(CurrentObject);
                    }
                    else
                    {
                        staticObjects.Add(ListPos, new List <IGameObject>());
                        staticObjects[ListPos].Add(CurrentObject);
                    }
                }

                if (CurrentObject is Mario)
                {
                    player = CurrentObject;
                }
            }
            //load collision dictionary once the level is loaded
            handler = new CollisionHandler(this, game);
        }
Exemplo n.º 3
0
        public MarioWarpPipeHandler(CollisionObject collision, Level level, MarioGame game)
        {
            if (collision.LeftSlot is IMario)
            {
                mario = (IMario)collision.LeftSlot;
                pipe  = (WarpPipe)collision.RightSlot;
            }
            else
            {
                mario = (IMario)collision.RightSlot;
                pipe  = (WarpPipe)collision.LeftSlot;
            }
            direction   = (int)collision.CollisionType;
            commandList = new List <ICommand>();

            Rectangle MarioRectangle = new Rectangle(mario.XCoordinate, mario.YCoordinate, mario.Width, mario.Height);
            Rectangle PipeRectangle  = new Rectangle(pipe.XCoordinate, pipe.YCoordinate, pipe.Width, pipe.Height);
            Rectangle result         = Rectangle.Intersect(MarioRectangle, PipeRectangle);
            int       deltaX         = result.Right - result.Left;
            int       deltaY         = result.Bottom - result.Top;

            if (direction == 0)
            {
                commandList.Add(new PushMarioRightCommand(mario, deltaX));
            }
            else if (direction == 1)
            {
                commandList.Add(new PushMarioLeftCommand(mario, deltaX));
            }
            else if (direction == 2 && !GlobalVariables.FlipGravity)
            {
                commandList.Add(new PushMarioUpCommand(mario, deltaY));

                if (mario.Warpable)
                {
                    game.SwapLevel();
                    commandList.Add(new WarpMarioCommand(mario, WarpPipe.ExitX, WarpPipe.ExitY));
                    MusicPlayer.EffectList("pipe").Play();
                }
            }
            else if (direction == 3 && !GlobalVariables.FlipGravity)
            {
                commandList.Add(new PushMarioUpCommand(mario, deltaY));
            }
            else if (direction == 3 && GlobalVariables.FlipGravity)
            {
                commandList.Add(new PushMarioUpCommand(mario, deltaY));

                if (mario.Warpable)
                {
                    game.SwapLevel();
                    commandList.Add(new WarpMarioCommand(mario, WarpPipe.ExitX, WarpPipe.ExitY));
                    MusicPlayer.EffectList("pipe").Play();
                }
            }
        }
        public CollisionHandler(Level level, MarioGame game)
        {
            this.level       = level;
            this.game        = game;
            collisionMatrix  = new Dictionary <CollisionObject, ConstructorInfo>();
            handlerParams    = new Type[2];
            handlerParams[0] = typeof(CollisionObject);
            handlerParams[1] = typeof(Level);

            Type[] WarpParams = new Type[3];
            WarpParams[0] = typeof(CollisionObject);
            WarpParams[1] = typeof(Level);
            WarpParams[2] = typeof(MarioGame);

            //Mario and Blocks
            collisionInfo = new CollisionObject(typeof(CoinBlock), typeof(Mario));
            handlerInfo   = typeof(MarioCoinBlockHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(ItemBlock), typeof(Mario));
            handlerInfo   = typeof(MarioItemBlockHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(HiddenBlock), typeof(Mario));
            handlerInfo   = typeof(MarioHiddenBlockHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(BrickBlock), typeof(Mario));
            handlerInfo   = typeof(MarioBlockHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(UsedBlock), typeof(Mario));
            handlerInfo   = typeof(MarioBlockHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(CrackedBlock), typeof(Mario));
            handlerInfo   = typeof(MarioBlockHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(SolidBlock), typeof(Mario));
            handlerInfo   = typeof(MarioBlockHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(CoinBrick), typeof(Mario));
            handlerInfo   = typeof(MarioCoinBrickHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(Pipe), typeof(Mario));
            handlerInfo   = typeof(MarioBlockHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(HalfPipe), typeof(Mario));
            handlerInfo   = typeof(MarioBlockHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(StarBrick), typeof(Mario));
            handlerInfo   = typeof(MarioStarBrickHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(WarpPipe), typeof(Mario));
            handlerInfo   = typeof(MarioWarpPipeHandler).GetConstructor(WarpParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);


            //Mario and Enemies
            collisionInfo = new CollisionObject(typeof(Mario), typeof(Goomba));
            handlerInfo   = typeof(MarioEnemyHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(Mario), typeof(Koopa));
            handlerInfo   = typeof(MarioEnemyHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            //Mario and Items
            collisionInfo = new CollisionObject(typeof(Mario), typeof(Mushroom));
            handlerInfo   = typeof(MarioMushroomHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(FireFlower), typeof(Mario));
            handlerInfo   = typeof(MarioFireFlowerHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(SuperCrown), typeof(Mario));
            handlerInfo   = typeof(MarioSuperCrown).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(Mario), typeof(GravityOrb));
            handlerInfo   = typeof(MarioGravityOrb).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(Mario), typeof(Star));
            handlerInfo   = typeof(MarioStarHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(Coin), typeof(Mario));
            handlerInfo   = typeof(MarioCoinHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(Mario), typeof(ExtraLifeMushroom));
            handlerInfo   = typeof(MarioExtraLifeMushroomHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            //StarMario and Blocks
            collisionInfo = new CollisionObject(typeof(CoinBlock), typeof(StarMario));
            handlerInfo   = typeof(MarioCoinBlockHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(ItemBlock), typeof(StarMario));
            handlerInfo   = typeof(MarioItemBlockHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(HiddenBlock), typeof(StarMario));
            handlerInfo   = typeof(MarioHiddenBlockHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(BrickBlock), typeof(StarMario));
            handlerInfo   = typeof(MarioBlockHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(UsedBlock), typeof(StarMario));
            handlerInfo   = typeof(MarioBlockHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(CrackedBlock), typeof(StarMario));
            handlerInfo   = typeof(MarioBlockHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(SolidBlock), typeof(StarMario));
            handlerInfo   = typeof(MarioBlockHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(CoinBrick), typeof(StarMario));
            handlerInfo   = typeof(MarioCoinBrickHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(Pipe), typeof(StarMario));
            handlerInfo   = typeof(MarioBlockHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(HalfPipe), typeof(StarMario));
            handlerInfo   = typeof(MarioBlockHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(StarBrick), typeof(StarMario));
            handlerInfo   = typeof(MarioStarBrickHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(WarpPipe), typeof(StarMario));
            handlerInfo   = typeof(MarioWarpPipeHandler).GetConstructor(WarpParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);


            //StarMario and Enemies
            collisionInfo = new CollisionObject(typeof(StarMario), typeof(Goomba));
            handlerInfo   = typeof(MarioEnemyHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(StarMario), typeof(Koopa));
            handlerInfo   = typeof(MarioEnemyHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            //StarMario and Items
            collisionInfo = new CollisionObject(typeof(StarMario), typeof(Mushroom));
            handlerInfo   = typeof(MarioMushroomHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(FireFlower), typeof(StarMario));
            handlerInfo   = typeof(MarioFireFlowerHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(StarMario), typeof(Star));
            handlerInfo   = typeof(MarioStarHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(SuperCrown), typeof(StarMario));
            handlerInfo   = typeof(MarioSuperCrown).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(StarMario), typeof(GravityOrb));
            handlerInfo   = typeof(MarioGravityOrb).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);


            collisionInfo = new CollisionObject(typeof(Coin), typeof(StarMario));
            handlerInfo   = typeof(MarioCoinHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(StarMario), typeof(ExtraLifeMushroom));
            handlerInfo   = typeof(MarioExtraLifeMushroomHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            //GoombaBlockHandlers
            collisionInfo = new CollisionObject(typeof(CoinBlock), typeof(Goomba));
            handlerInfo   = typeof(EnemyBlockHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(ItemBlock), typeof(Goomba));
            handlerInfo   = typeof(EnemyBlockHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(BrickBlock), typeof(Goomba));
            handlerInfo   = typeof(EnemyBlockHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(UsedBlock), typeof(Goomba));
            handlerInfo   = typeof(EnemyBlockHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(CrackedBlock), typeof(Goomba));
            handlerInfo   = typeof(EnemyBlockHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(SolidBlock), typeof(Goomba));
            handlerInfo   = typeof(EnemyBlockHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(CoinBrick), typeof(Goomba));
            handlerInfo   = typeof(EnemyBlockHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(Pipe), typeof(Goomba));
            handlerInfo   = typeof(EnemyBlockHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(HalfPipe), typeof(Goomba));
            handlerInfo   = typeof(EnemyBlockHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(StarBrick), typeof(Goomba));
            handlerInfo   = typeof(EnemyBlockHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(WarpPipe), typeof(Goomba));
            handlerInfo   = typeof(EnemyBlockHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            //KoopaBlockhandler
            collisionInfo = new CollisionObject(typeof(CoinBlock), typeof(Koopa));
            handlerInfo   = typeof(EnemyBlockHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(ItemBlock), typeof(Koopa));
            handlerInfo   = typeof(EnemyBlockHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(BrickBlock), typeof(Koopa));
            handlerInfo   = typeof(EnemyBlockHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(UsedBlock), typeof(Koopa));
            handlerInfo   = typeof(EnemyBlockHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(CrackedBlock), typeof(Koopa));
            handlerInfo   = typeof(EnemyBlockHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(SolidBlock), typeof(Koopa));
            handlerInfo   = typeof(EnemyBlockHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(CoinBrick), typeof(Koopa));
            handlerInfo   = typeof(EnemyBlockHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(Pipe), typeof(Koopa));
            handlerInfo   = typeof(EnemyBlockHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(HalfPipe), typeof(Koopa));
            handlerInfo   = typeof(EnemyBlockHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(StarBrick), typeof(Koopa));
            handlerInfo   = typeof(EnemyBlockHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(WarpPipe), typeof(Koopa));
            handlerInfo   = typeof(EnemyBlockHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            //StarBlockHandlers
            collisionInfo = new CollisionObject(typeof(CoinBlock), typeof(Star));
            handlerInfo   = typeof(ItemBlockHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(ItemBlock), typeof(Star));
            handlerInfo   = typeof(ItemBlockHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(BrickBlock), typeof(Star));
            handlerInfo   = typeof(ItemBlockHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(UsedBlock), typeof(Star));
            handlerInfo   = typeof(ItemBlockHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(CrackedBlock), typeof(Star));
            handlerInfo   = typeof(ItemBlockHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(SolidBlock), typeof(Star));
            handlerInfo   = typeof(ItemBlockHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(CoinBrick), typeof(Star));
            handlerInfo   = typeof(ItemBlockHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(Pipe), typeof(Star));
            handlerInfo   = typeof(ItemBlockHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(HalfPipe), typeof(Star));
            handlerInfo   = typeof(ItemBlockHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(WarpPipe), typeof(Star));
            handlerInfo   = typeof(ItemBlockHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);



            //MushroomBlockHandlers
            collisionInfo = new CollisionObject(typeof(CoinBlock), typeof(Mushroom));
            handlerInfo   = typeof(ItemBlockHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(ItemBlock), typeof(Mushroom));
            handlerInfo   = typeof(ItemBlockHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(BrickBlock), typeof(Mushroom));
            handlerInfo   = typeof(ItemBlockHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(UsedBlock), typeof(Mushroom));
            handlerInfo   = typeof(ItemBlockHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(CrackedBlock), typeof(Mushroom));
            handlerInfo   = typeof(ItemBlockHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(SolidBlock), typeof(Mushroom));
            handlerInfo   = typeof(ItemBlockHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(CoinBrick), typeof(Mushroom));
            handlerInfo   = typeof(ItemBlockHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(Pipe), typeof(Mushroom));
            handlerInfo   = typeof(ItemBlockHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(HalfPipe), typeof(Mushroom));
            handlerInfo   = typeof(ItemBlockHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(StarBrick), typeof(Mushroom));
            handlerInfo   = typeof(ItemBlockHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(WarpPipe), typeof(Mushroom));
            handlerInfo   = typeof(ItemBlockHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
            //Gravity Orb Collisions
            collisionInfo = new CollisionObject(typeof(CoinBlock), typeof(GravityOrb));
            handlerInfo   = typeof(ItemBlockHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(ItemBlock), typeof(GravityOrb));
            handlerInfo   = typeof(ItemBlockHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(BrickBlock), typeof(GravityOrb));
            handlerInfo   = typeof(ItemBlockHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(UsedBlock), typeof(GravityOrb));
            handlerInfo   = typeof(ItemBlockHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(CrackedBlock), typeof(GravityOrb));
            handlerInfo   = typeof(ItemBlockHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(SolidBlock), typeof(GravityOrb));
            handlerInfo   = typeof(ItemBlockHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(CoinBrick), typeof(GravityOrb));
            handlerInfo   = typeof(ItemBlockHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(Pipe), typeof(GravityOrb));
            handlerInfo   = typeof(ItemBlockHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(HalfPipe), typeof(GravityOrb));
            handlerInfo   = typeof(ItemBlockHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(StarBrick), typeof(GravityOrb));
            handlerInfo   = typeof(ItemBlockHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(WarpPipe), typeof(GravityOrb));
            handlerInfo   = typeof(ItemBlockHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);
            ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////


            //ExtraLifeMushroom
            collisionInfo = new CollisionObject(typeof(CoinBlock), typeof(ExtraLifeMushroom));
            handlerInfo   = typeof(ItemBlockHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(ItemBlock), typeof(ExtraLifeMushroom));
            handlerInfo   = typeof(ItemBlockHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(BrickBlock), typeof(ExtraLifeMushroom));
            handlerInfo   = typeof(ItemBlockHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(UsedBlock), typeof(ExtraLifeMushroom));
            handlerInfo   = typeof(ItemBlockHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(CrackedBlock), typeof(ExtraLifeMushroom));
            handlerInfo   = typeof(ItemBlockHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(SolidBlock), typeof(ExtraLifeMushroom));
            handlerInfo   = typeof(ItemBlockHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(CoinBrick), typeof(ExtraLifeMushroom));
            handlerInfo   = typeof(ItemBlockHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(Pipe), typeof(ExtraLifeMushroom));
            handlerInfo   = typeof(ItemBlockHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(HalfPipe), typeof(ExtraLifeMushroom));
            handlerInfo   = typeof(ItemBlockHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(StarBrick), typeof(ExtraLifeMushroom));
            handlerInfo   = typeof(ItemBlockHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(WarpPipe), typeof(ExtraLifeMushroom));
            handlerInfo   = typeof(ItemBlockHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            //EnemyEnemyHandler
            collisionInfo = new CollisionObject(typeof(Goomba), typeof(Koopa));
            handlerInfo   = typeof(EnemyEnemyHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(Koopa), typeof(Goomba));
            handlerInfo   = typeof(EnemyEnemyHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(Goomba), typeof(Goomba));
            handlerInfo   = typeof(EnemyEnemyHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(Koopa), typeof(Koopa));
            handlerInfo   = typeof(EnemyEnemyHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            //FireBallHandlers
            collisionInfo = new CollisionObject(typeof(CoinBlock), typeof(FireBall));
            handlerInfo   = typeof(FireballBlockHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(ItemBlock), typeof(FireBall));
            handlerInfo   = typeof(FireballBlockHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(BrickBlock), typeof(FireBall));
            handlerInfo   = typeof(FireballBlockHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(UsedBlock), typeof(FireBall));
            handlerInfo   = typeof(FireballBlockHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(CrackedBlock), typeof(FireBall));
            handlerInfo   = typeof(FireballBlockHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(SolidBlock), typeof(FireBall));
            handlerInfo   = typeof(FireballBlockHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(CoinBrick), typeof(FireBall));
            handlerInfo   = typeof(FireballBlockHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(Pipe), typeof(FireBall));
            handlerInfo   = typeof(FireballBlockHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(HalfPipe), typeof(FireBall));
            handlerInfo   = typeof(FireballBlockHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(StarBrick), typeof(FireBall));
            handlerInfo   = typeof(FireballBlockHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(Koopa), typeof(FireBall));
            handlerInfo   = typeof(FireballEnemyHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(Goomba), typeof(FireBall));
            handlerInfo   = typeof(FireballEnemyHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(WarpPipe), typeof(FireBall));
            handlerInfo   = typeof(FireballBlockHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            //Flagpole

            collisionInfo = new CollisionObject(typeof(FlagPole), typeof(Mario));
            handlerInfo   = typeof(MarioFlagPoleHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            //Flag

            collisionInfo = new CollisionObject(typeof(Flag), typeof(Mario));
            handlerInfo   = typeof(MarioFlagHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            // Enemies and items

            collisionInfo = new CollisionObject(typeof(FireFlower), typeof(Goomba));
            handlerInfo   = typeof(EnemyMushroomHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(Mushroom), typeof(Goomba));
            handlerInfo   = typeof(EnemyMushroomHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(SuperCrown), typeof(Goomba));
            handlerInfo   = typeof(EnemyJumpHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(GravityOrb), typeof(Goomba));
            handlerInfo   = typeof(EnemyJumpHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(Goomba), typeof(SuperCrown));
            handlerInfo   = typeof(EnemyJumpHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(Goomba), typeof(GravityOrb));
            handlerInfo   = typeof(EnemyJumpHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(Star), typeof(Goomba));
            handlerInfo   = typeof(EnemyStarHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(FireFlower), typeof(Koopa));
            handlerInfo   = typeof(EnemyJumpHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(Mushroom), typeof(Koopa));
            handlerInfo   = typeof(EnemyMushroomHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(Star), typeof(Koopa));
            handlerInfo   = typeof(EnemyStarHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(SuperCrown), typeof(Koopa));
            handlerInfo   = typeof(EnemyJumpHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(GravityOrb), typeof(Koopa));
            handlerInfo   = typeof(EnemyJumpHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(Koopa), typeof(SuperCrown));
            handlerInfo   = typeof(EnemyJumpHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(Koopa), typeof(GravityOrb));
            handlerInfo   = typeof(EnemyJumpHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            //Enemies and items backwards
            collisionInfo = new CollisionObject(typeof(Goomba), typeof(FireFlower));
            handlerInfo   = typeof(EnemyJumpHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(Goomba), typeof(Mushroom));
            handlerInfo   = typeof(EnemyMushroomHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(Goomba), typeof(Star));
            handlerInfo   = typeof(EnemyStarHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(Koopa), typeof(FireFlower));
            handlerInfo   = typeof(EnemyJumpHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(Koopa), typeof(Mushroom));
            handlerInfo   = typeof(EnemyMushroomHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);

            collisionInfo = new CollisionObject(typeof(Koopa), typeof(Star));
            handlerInfo   = typeof(EnemyStarHandler).GetConstructor(handlerParams);
            collisionMatrix.Add(collisionInfo, handlerInfo);
        }
Exemplo n.º 5
0
 static void Main()
 {
     using (var game = new MarioGame())
         game.Run();
 }