public override void Initialize(bool addToManagers)
        {
            LoadStaticContent(ContentManagerName);
            BulletList               = new FlatRedBall.Math.PositionedObjectList <RockBlaster.Entities.Bullet>();
            BulletList.Name          = "BulletList";
            RockList                 = new FlatRedBall.Math.PositionedObjectList <RockBlaster.Entities.Rock>();
            RockList.Name            = "RockList";
            MainShipList             = new FlatRedBall.Math.PositionedObjectList <RockBlaster.Entities.MainShip>();
            MainShipList.Name        = "MainShipList";
            EndGameUIInstance        = new RockBlaster.Entities.EndGameUI(ContentManagerName, false);
            EndGameUIInstance.Name   = "EndGameUIInstance";
            HudInstance              = new RockBlaster.Entities.Hud(ContentManagerName, false);
            HudInstance.Name         = "HudInstance";
            MainShipInstance         = new RockBlaster.Entities.MainShip(ContentManagerName, false);
            MainShipInstance.Name    = "MainShipInstance";
            RockSpawnerInstance      = new RockBlaster.Entities.RockSpawner(ContentManagerName, false);
            RockSpawnerInstance.Name = "RockSpawnerInstance";


            PostInitialize();
            base.Initialize(addToManagers);
            if (addToManagers)
            {
                AddToManagers();
            }
        }
        public override void Initialize(bool addToManagers)
        {
            LoadStaticContent(ContentManagerName);
            MapScreenGumInstance       = MapScreenGum.GetGraphicalUiElementByName("this") as AbbatoirIntergrade.GumRuntimes.MapScreenGumRuntime;
            MenuWindowInstance         = MapScreenGum.GetGraphicalUiElementByName("MenuWindowInstance") as AbbatoirIntergrade.GumRuntimes.MenuWindowRuntime;
            ChatHistoryInstance        = MapScreenGum.GetGraphicalUiElementByName("ChatHistoryInstance") as AbbatoirIntergrade.GumRuntimes.ChatHistoryRuntime;
            TowerSelectionBoxInstance  = MapScreenGum.GetGraphicalUiElementByName("TowerSelectionBoxInstance") as AbbatoirIntergrade.GumRuntimes.TowerSelectionBoxRuntime;
            StructureList              = new FlatRedBall.Math.PositionedObjectList <AbbatoirIntergrade.Entities.BaseEntities.BaseStructure>();
            StructureList.Name         = "StructureList";
            StructureLayer             = new FlatRedBall.Graphics.Layer();
            StructureLayer.Name        = "StructureLayer";
            ProjectileList             = new FlatRedBall.Math.PositionedObjectList <AbbatoirIntergrade.Entities.BaseEntities.BasePlayerProjectile>();
            ProjectileList.Name        = "ProjectileList";
            OkMessageInstance          = MapScreenGum.GetGraphicalUiElementByName("OkMessageInstance") as AbbatoirIntergrade.GumRuntimes.infodisplays.OkMessageRuntime;
            ConfirmationWindowInstance = MapScreenGum.GetGraphicalUiElementByName("ConfirmationWindowInstance") as AbbatoirIntergrade.GumRuntimes.ConfirmationWindowRuntime;
            HUDLayer      = new FlatRedBall.Graphics.Layer();
            HUDLayer.Name = "HUDLayer";
            CurrentMusicDisplayInstance = MapScreenGum.GetGraphicalUiElementByName("CurrentMusicDisplayInstance") as AbbatoirIntergrade.GumRuntimes.infodisplays.CurrentMusicDisplayRuntime;


            PostInitialize();
            base.Initialize(addToManagers);
            if (addToManagers)
            {
                AddToManagers();
            }
        }
        public override void Initialize(bool addToManagers)
        {
			// Generated Initialize
			LoadStaticContent(ContentManagerName);
			if (!FlatRedBall.FlatRedBallServices.IsLoaded<FlatRedBall.Scene>(@"content/screens/mundosmith/scenefile.scnx", ContentManagerName))
			{
			}
			SceneFile = FlatRedBall.FlatRedBallServices.Load<FlatRedBall.Scene>(@"content/screens/mundosmith/scenefile.scnx", ContentManagerName);
			if (!FlatRedBall.FlatRedBallServices.IsLoaded<FlatRedBall.Math.Geometry.ShapeCollection>(@"content/screens/mundosmith/limitesmundo.shcx", ContentManagerName))
			{
			}
			LimitesMundo = FlatRedBall.FlatRedBallServices.Load<FlatRedBall.Math.Geometry.ShapeCollection>(@"content/screens/mundosmith/limitesmundo.shcx", ContentManagerName);
			Fondo = SceneFile.Sprites.FindByName("ship painting1");
			SmithInstance = new TesisEconoFight.Entities.Smith(ContentManagerName, false);
			SmithInstance.Name = "SmithInstance";
			PauseTextInstance = new TesisEconoFight.Entities.PauseText(ContentManagerName, false);
			PauseTextInstance.Name = "PauseTextInstance";
			P2WinTextInstance = new TesisEconoFight.Entities.P2WinText(ContentManagerName, false);
			P2WinTextInstance.Name = "P2WinTextInstance";
			P1WinTextInstance = new TesisEconoFight.Entities.P1WinText(ContentManagerName, false);
			P1WinTextInstance.Name = "P1WinTextInstance";
			DoubleKOTextInstance = new TesisEconoFight.Entities.DoubleKOText(ContentManagerName, false);
			DoubleKOTextInstance.Name = "DoubleKOTextInstance";
			ListaJugadores = new FlatRedBall.Math.PositionedObjectList<TesisEconoFight.Entities.Player>();
			ListaJugadores.Name = "ListaJugadores";
			
			
			PostInitialize();
			base.Initialize(addToManagers);
			if (addToManagers)
			{
				AddToManagers();
			}

        }
        public override void Initialize(bool addToManagers)
        {
            LoadStaticContent(ContentManagerName);
            // Not instantiating for LayeredTileMap Map in Screens\GameScreen (Screen) because properties on the object prevent it
            SolidCollisions = new FlatRedBall.TileCollisions.TileShapeCollection();
            PlayerList      = new FlatRedBall.Math.PositionedObjectList <MyNewGame.Entities.Player>();
            PlayerList.Name = "PlayerList";
            DoorList        = new FlatRedBall.Math.PositionedObjectList <MyNewGame.Entities.Door>();
            DoorList.Name   = "DoorList";
            gumIdb          = new FlatRedBall.Gum.GumIdb();
            // normally we wait to set variables until after the object is created, but in this case if the
            // TileShapeCollection doesn't have its Visible set before creating the tiles, it can result in
            // really bad performance issues, as shapes will be made visible, then invisible. Really bad perf!
            if (SolidCollisions != null)
            {
                SolidCollisions.Visible = false;
            }
            FlatRedBall.TileCollisions.TileShapeCollectionLayeredTileMapExtensions.AddCollisionFromTilesWithProperty(SolidCollisions, Map, "SolidCollision");


            PostInitialize();
            base.Initialize(addToManagers);
            if (addToManagers)
            {
                AddToManagers();
            }
        }
Exemple #5
0
        protected virtual void InitializeEntity(bool addToManagers)
        {
            LoadStaticContent(ContentManagerName);
            HealthBarList      = new FlatRedBall.Math.PositionedObjectList <RockBlaster.Entities.HealthBar>();
            HealthBarList.Name = "HealthBarList";

            PostInitialize();
            if (addToManagers)
            {
                AddToManagers(null);
            }
        }
        public override void Initialize(bool addToManagers)
        {
            LoadStaticContent(ContentManagerName);
            PlayerInstance                    = new Platformer.Entities.Player(ContentManagerName, false);
            PlayerInstance.Name               = "PlayerInstance";
            PositionedObjectListInstance      = new FlatRedBall.Math.PositionedObjectList <Platformer.Entities.HealthPoint>();
            PositionedObjectListInstance.Name = "PositionedObjectListInstance";


            PostInitialize();
            base.Initialize(addToManagers);
            if (addToManagers)
            {
                AddToManagers();
            }
        }
Exemple #7
0
        public override void Initialize(bool addToManagers)
        {
            LoadStaticContent(ContentManagerName);
            PlayerShipInstance      = new Frbcon2019.Entities.SpaceInvaders.PlayerShip(ContentManagerName, false);
            PlayerShipInstance.Name = "PlayerShipInstance";
            BulletList          = new FlatRedBall.Math.PositionedObjectList <Frbcon2019.Entities.SpaceInvaders.Bullet>();
            BulletList.Name     = "BulletList";
            AlienList           = new FlatRedBall.Math.PositionedObjectList <Frbcon2019.Entities.SpaceInvaders.Alien>();
            AlienList.Name      = "AlienList";
            RightGuardRail      = new Frbcon2019.Entities.SpaceInvaders.GuardRail(ContentManagerName, false);
            RightGuardRail.Name = "RightGuardRail";
            LeftGuardRail       = new Frbcon2019.Entities.SpaceInvaders.GuardRail(ContentManagerName, false);
            LeftGuardRail.Name  = "LeftGuardRail";


            base.Initialize(addToManagers);
        }
Exemple #8
0
        protected virtual void InitializeEntity(bool addToManagers)
        {
            LoadStaticContent(ContentManagerName);
            BoatSpriteInstance      = new FlatRedBall.Sprite();
            BoatSpriteInstance.Name = "BoatSpriteInstance";
            mHitbox                   = new FlatRedBall.Math.Geometry.Polygon();
            mHitbox.Name              = "mHitbox";
            AnchorSpriteInstance      = new FlatRedBall.Sprite();
            AnchorSpriteInstance.Name = "AnchorSpriteInstance";
            CannonballList            = new FlatRedBall.Math.PositionedObjectList <Pirates.Entities.Cannonball>();
            CannonballList.Name       = "CannonballList";

            PostInitialize();
            if (addToManagers)
            {
                AddToManagers(null);
            }
        }
Exemple #9
0
        public override void Initialize(bool addToManagers)
        {
            LoadStaticContent(ContentManagerName);
            TankList                  = new FlatRedBall.Math.PositionedObjectList <GreasyPlatypusSlapper.Entities.Tank>();
            TankList.Name             = "TankList";
            BulletList                = new FlatRedBall.Math.PositionedObjectList <GreasyPlatypusSlapper.Entities.Bullet>();
            BulletList.Name           = "BulletList";
            CameraEntityInstance      = new GreasyPlatypusSlapper.Entities.CameraEntity(ContentManagerName, false);
            CameraEntityInstance.Name = "CameraEntityInstance";
            TreadEffects              = new FlatRedBall.Math.PositionedObjectList <GreasyPlatypusSlapper.Entities.Effects.TreadEffect>();
            TreadEffects.Name         = "TreadEffects";
            PlayerSelectionUIInstance = GameScreenGum.GetGraphicalUiElementByName("PlayerSelectionUIInstance") as GreasyPlatypusSlapper.GumRuntimes.PlayerSelectionUIRuntime;


            PostInitialize();
            base.Initialize(addToManagers);
            if (addToManagers)
            {
                AddToManagers();
            }
        }
        public override void Initialize(bool addToManagers)
        {
            LoadStaticContent(ContentManagerName);
            RectsList             = new FlatRedBall.Math.PositionedObjectList <FlatRedBall.Math.Geometry.AxisAlignedRectangle>();
            RectsList.Name        = "RectsList";
            mRectMain             = new FlatRedBall.Math.Geometry.AxisAlignedRectangle();
            mRectMain.Name        = "mRectMain";
            mRectSide1            = new FlatRedBall.Math.Geometry.AxisAlignedRectangle();
            mRectSide1.Name       = "mRectSide1";
            mRectSide2            = new FlatRedBall.Math.Geometry.AxisAlignedRectangle();
            mRectSide2.Name       = "mRectSide2";
            mRectBelow            = new FlatRedBall.Math.Geometry.AxisAlignedRectangle();
            mRectBelow.Name       = "mRectBelow";
            mRectBelow2           = new FlatRedBall.Math.Geometry.AxisAlignedRectangle();
            mRectBelow2.Name      = "mRectBelow2";
            mRectTop              = new FlatRedBall.Math.Geometry.AxisAlignedRectangle();
            mRectTop.Name         = "mRectTop";
            mRectTop2             = new FlatRedBall.Math.Geometry.AxisAlignedRectangle();
            mRectTop2.Name        = "mRectTop2";
            RectsListUnused       = new FlatRedBall.Math.PositionedObjectList <FlatRedBall.Math.Geometry.AxisAlignedRectangle>();
            RectsListUnused.Name  = "RectsListUnused";
            mRectTopCenter        = new FlatRedBall.Math.Geometry.AxisAlignedRectangle();
            mRectTopCenter.Name   = "mRectTopCenter";
            mRectBelowCenter      = new FlatRedBall.Math.Geometry.AxisAlignedRectangle();
            mRectBelowCenter.Name = "mRectBelowCenter";
            ArrowsInstance        = new TestBed.Entities.Arrows(ContentManagerName, false);
            ArrowsInstance.Name   = "ArrowsInstance";
            mRectLeftCenter       = new FlatRedBall.Math.Geometry.AxisAlignedRectangle();
            mRectLeftCenter.Name  = "mRectLeftCenter";
            mRectRightCenter      = new FlatRedBall.Math.Geometry.AxisAlignedRectangle();
            mRectRightCenter.Name = "mRectRightCenter";


            PostInitialize();
            base.Initialize(addToManagers);
            if (addToManagers)
            {
                AddToManagers();
            }
        }
        public override void Initialize(bool addToManagers)
        {
            LoadStaticContent(ContentManagerName);
            mCenterH                     = new FlatRedBall.Math.Geometry.Polygon();
            mCenterH.Name                = "mCenterH";
            mCenterV                     = new FlatRedBall.Math.Geometry.Polygon();
            mCenterV.Name                = "mCenterV";
            RectsList                    = new FlatRedBall.Math.PositionedObjectList <FlatRedBall.Math.Geometry.AxisAlignedRectangle>();
            RectsList.Name               = "RectsList";
            mRect1Main                   = new FlatRedBall.Math.Geometry.AxisAlignedRectangle();
            mRect1Main.Name              = "mRect1Main";
            mRect2InnerTouching          = new FlatRedBall.Math.Geometry.AxisAlignedRectangle();
            mRect2InnerTouching.Name     = "mRect2InnerTouching";
            mRectOuterTouching2          = new FlatRedBall.Math.Geometry.AxisAlignedRectangle();
            mRectOuterTouching2.Name     = "mRectOuterTouching2";
            mRect3InnerTouching          = new FlatRedBall.Math.Geometry.AxisAlignedRectangle();
            mRect3InnerTouching.Name     = "mRect3InnerTouching";
            mRect4InnerTouching          = new FlatRedBall.Math.Geometry.AxisAlignedRectangle();
            mRect4InnerTouching.Name     = "mRect4InnerTouching";
            mRect5InnerTouching          = new FlatRedBall.Math.Geometry.AxisAlignedRectangle();
            mRect5InnerTouching.Name     = "mRect5InnerTouching";
            mRect6OuterTouching          = new FlatRedBall.Math.Geometry.AxisAlignedRectangle();
            mRect6OuterTouching.Name     = "mRect6OuterTouching";
            mRect7OuterTouching          = new FlatRedBall.Math.Geometry.AxisAlignedRectangle();
            mRect7OuterTouching.Name     = "mRect7OuterTouching";
            mRect8OuterNotTouching       = new FlatRedBall.Math.Geometry.AxisAlignedRectangle();
            mRect8OuterNotTouching.Name  = "mRect8OuterNotTouching";
            mRect8OuterNotTouching2      = new FlatRedBall.Math.Geometry.AxisAlignedRectangle();
            mRect8OuterNotTouching2.Name = "mRect8OuterNotTouching2";
            mRect6OuterTouching2         = new FlatRedBall.Math.Geometry.AxisAlignedRectangle();
            mRect6OuterTouching2.Name    = "mRect6OuterTouching2";


            PostInitialize();
            base.Initialize(addToManagers);
            if (addToManagers)
            {
                AddToManagers();
            }
        }
Exemple #12
0
        public override void Initialize(bool addToManagers)
        {
            LoadStaticContent(ContentManagerName);
            BackgroundInstance      = new SpaceShooter.Entities.Background(ContentManagerName, false);
            BackgroundInstance.Name = "BackgroundInstance";
            PlayerInstance          = new SpaceShooter.Entities.Player(ContentManagerName, false);
            PlayerInstance.Name     = "PlayerInstance";
            BulletList              = new FlatRedBall.Math.PositionedObjectList <SpaceShooter.Entities.Bullet>();
            BulletList.Name         = "BulletList";
            EnemyList               = new FlatRedBall.Math.PositionedObjectList <SpaceShooter.Entities.Enemy>();
            EnemyList.Name          = "EnemyList";
            ScoreboardInstance      = new SpaceShooter.Entities.Scoreboard(ContentManagerName, false);
            ScoreboardInstance.Name = "ScoreboardInstance";


            PostInitialize();
            base.Initialize(addToManagers);
            if (addToManagers)
            {
                AddToManagers();
            }
        }
        public override void Initialize(bool addToManagers)
        {
			// Generated Initialize
			LoadStaticContent(ContentManagerName);
			if (!FlatRedBall.FlatRedBallServices.IsLoaded<FlatRedBall.Math.Geometry.ShapeCollection>(@"content/screens/menuglosario/altsglosario.shcx", ContentManagerName))
			{
			}
			AltsGlosario = FlatRedBall.FlatRedBallServices.Load<FlatRedBall.Math.Geometry.ShapeCollection>(@"content/screens/menuglosario/altsglosario.shcx", ContentManagerName);
			if (!FlatRedBall.FlatRedBallServices.IsLoaded<FlatRedBall.Scene>(@"content/screens/menuglosario/scenefile.scnx", ContentManagerName))
			{
			}
			SceneFile = FlatRedBall.FlatRedBallServices.Load<FlatRedBall.Scene>(@"content/screens/menuglosario/scenefile.scnx", ContentManagerName);
			Cursores = new FlatRedBall.Math.PositionedObjectList<TesisEconoFight.Entities.Kursor>();
			Cursores.Name = "Cursores";
			
			
			PostInitialize();
			base.Initialize(addToManagers);
			if (addToManagers)
			{
				AddToManagers();
			}

        }
        public override void Initialize(bool addToManagers)
        {
            LoadStaticContent(ContentManagerName);
            PlayerBoat          = new Pirates.Entities.Boat(ContentManagerName, false);
            PlayerBoat.Name     = "PlayerBoat";
            BoatList            = new FlatRedBall.Math.PositionedObjectList <Pirates.Entities.Boat>();
            BoatList.Name       = "BoatList";
            DockList            = new FlatRedBall.Math.PositionedObjectList <Pirates.Entities.Dock>();
            DockList.Name       = "DockList";
            PlayerInstance      = new Pirates.Entities.Player(ContentManagerName, false);
            PlayerInstance.Name = "PlayerInstance";
            UIBoatLayer         = new FlatRedBall.Graphics.Layer();
            UIBoatLayer.Name    = "UIBoatLayer";
            SandCollision       = new FlatRedBall.TileCollisions.TileShapeCollection();
            SandCollision.Name  = "SandCollision";
            WaterCollision      = new FlatRedBall.TileCollisions.TileShapeCollection();
            WaterCollision.Name = "WaterCollision";
            DirtCollision       = new FlatRedBall.TileCollisions.TileShapeCollection();
            DirtCollision.Name  = "DirtCollision";
            HulkCollision       = new FlatRedBall.TileCollisions.TileShapeCollection();
            HulkCollision.Name  = "HulkCollision";
            RockCollision       = new FlatRedBall.TileCollisions.TileShapeCollection();
            RockCollision.Name  = "RockCollision";
            CannonballList      = new FlatRedBall.Math.PositionedObjectList <Pirates.Entities.Cannonball>();
            CannonballList.Name = "CannonballList";
            SpeedMeter          = new Pirates.Entities.UI.SpeedMeter(ContentManagerName, false);
            SpeedMeter.Name     = "SpeedMeter";
            ExplosionList       = new FlatRedBall.Math.PositionedObjectList <Pirates.Entities.Animations.Explosion>();
            ExplosionList.Name  = "ExplosionList";
            ButtonPistol        = GameScreenGum.GetGraphicalUiElementByName("ButtonPistol") as Pirates.GumRuntimes.ButtonRuntime;
            ButtonShotgun       = GameScreenGum.GetGraphicalUiElementByName("ButtonShotgun") as Pirates.GumRuntimes.ButtonRuntime;
            BulletList          = new FlatRedBall.Math.PositionedObjectList <Pirates.Entities.Bullet>();
            BulletList.Name     = "BulletList";
            EnemyList           = new FlatRedBall.Math.PositionedObjectList <Pirates.Entities.Skeleton>();
            EnemyList.Name      = "EnemyList";
            InventoryBar        = GameScreenGum.GetGraphicalUiElementByName("InventoryBarInstance") as Pirates.GumRuntimes.InventoryForms.InventoryBarRuntime;
            InventoryGui        = GameScreenGum.GetGraphicalUiElementByName("InventoryGui") as Pirates.GumRuntimes.InventoryForms.InventoryGuiRuntime;
            // normally we wait to set variables until after the object is created, but in this case if the
            // TileShapeCollection doesn't have its Visible set before creating the tiles, it can result in
            // really bad performance issues, as shapes will be made visible, then invisible. Really bad perf!
            SandCollision.Visible = false;
            FlatRedBall.TileCollisions.TileShapeCollectionLayeredTileMapExtensions.AddCollisionFromTilesWithType(SandCollision, Terrain, "Sand");
            // normally we wait to set variables until after the object is created, but in this case if the
            // TileShapeCollection doesn't have its Visible set before creating the tiles, it can result in
            // really bad performance issues, as shapes will be made visible, then invisible. Really bad perf!
            WaterCollision.Visible = false;
            FlatRedBall.TileCollisions.TileShapeCollectionLayeredTileMapExtensions.AddCollisionFromTilesWithType(WaterCollision, Terrain, "Water");
            // normally we wait to set variables until after the object is created, but in this case if the
            // TileShapeCollection doesn't have its Visible set before creating the tiles, it can result in
            // really bad performance issues, as shapes will be made visible, then invisible. Really bad perf!
            DirtCollision.Visible = false;
            FlatRedBall.TileCollisions.TileShapeCollectionLayeredTileMapExtensions.AddCollisionFromTilesWithType(DirtCollision, Terrain, "Dirt");
            // normally we wait to set variables until after the object is created, but in this case if the
            // TileShapeCollection doesn't have its Visible set before creating the tiles, it can result in
            // really bad performance issues, as shapes will be made visible, then invisible. Really bad perf!
            HulkCollision.Visible = false;
            FlatRedBall.TileCollisions.TileShapeCollectionLayeredTileMapExtensions.AddCollisionFromTilesWithType(HulkCollision, Terrain, "Hulk");
            // normally we wait to set variables until after the object is created, but in this case if the
            // TileShapeCollection doesn't have its Visible set before creating the tiles, it can result in
            // really bad performance issues, as shapes will be made visible, then invisible. Really bad perf!
            RockCollision.Visible = false;
            FlatRedBall.TileCollisions.TileShapeCollectionLayeredTileMapExtensions.AddCollisionFromTilesWithType(RockCollision, Terrain, "Rock");


            PostInitialize();
            base.Initialize(addToManagers);
            if (addToManagers)
            {
                AddToManagers();
            }
        }
        public override void Initialize(bool addToManagers)
        {
            LoadStaticContent(ContentManagerName);
            // Not instantiating for FlatRedBall.TileGraphics.LayeredTileMap Map in Screens\GameScreen (Screen) because properties on the object prevent it
            // Not instantiating for FlatRedBall.TileCollisions.TileShapeCollection SolidCollision in Screens\GameScreen (Screen) because properties on the object prevent it
            // Not instantiating for FlatRedBall.TileCollisions.TileShapeCollection CloudCollision in Screens\GameScreen (Screen) because properties on the object prevent it
            A_BrickList                      = new FlatRedBall.Math.PositionedObjectList <Super_Marios_Bros.Entities.A_Brick>();
            A_BrickList.Name                 = "A_BrickList";
            MarioInstance                    = new Super_Marios_Bros.Entities.Mario(ContentManagerName, false);
            MarioInstance.Name               = "MarioInstance";
            Lucky_blockList                  = new FlatRedBall.Math.PositionedObjectList <Super_Marios_Bros.Entities.Lucky_block>();
            Lucky_blockList.Name             = "Lucky_blockList";
            GumbaList                        = new FlatRedBall.Math.PositionedObjectList <Super_Marios_Bros.Entities.Gumba>();
            GumbaList.Name                   = "GumbaList";
            A_Brick_being_destroyedList      = new FlatRedBall.Math.PositionedObjectList <Super_Marios_Bros.Entities.A_Brick_being_destroyed>();
            A_Brick_being_destroyedList.Name = "A_Brick_being_destroyedList";
            CombinedShapeCollection          = new FlatRedBall.TileCollisions.TileShapeCollection();
            MushroomList                     = new FlatRedBall.Math.PositionedObjectList <Super_Marios_Bros.Entities.Mushroom>();
            MushroomList.Name                = "MushroomList";
            TurtleList                       = new FlatRedBall.Math.PositionedObjectList <Super_Marios_Bros.Entities.Turtle>();
            TurtleList.Name                  = "TurtleList";
            DeadMarioInstance                = new Super_Marios_Bros.Entities.DeadMario(ContentManagerName, false);
            DeadMarioInstance.Name           = "DeadMarioInstance";
            CoinList      = new FlatRedBall.Math.PositionedObjectList <Super_Marios_Bros.Entities.Coin>();
            CoinList.Name = "CoinList";
            MarioInstanceVsGumbaListAxisAlignedRectangleInstance = FlatRedBall.Math.Collision.CollisionManager.Self.CreateRelationship(MarioInstance, GumbaList);
            MarioInstanceVsGumbaListAxisAlignedRectangleInstance.SetSecondSubCollision(item => item.AxisAlignedRectangleInstance);
            MarioInstanceVsGumbaListAxisAlignedRectangleInstance.Name = "MarioInstanceVsGumbaListAxisAlignedRectangleInstance";
            MarioInstanceVsGumbaListAxisAlignedRectangleInstance.SetMoveCollision(1f, 1f);

            {
                var temp    = new FlatRedBall.Math.Collision.DelegateCollisionRelationship <Super_Marios_Bros.Entities.Mario, FlatRedBall.TileCollisions.TileShapeCollection>(MarioInstance, SolidCollision);
                var isCloud = false;
                temp.CollisionFunction = (first, second) =>
                {
                    return(first.CollideAgainst(second, isCloud));
                }
                ;
                FlatRedBall.Math.Collision.CollisionManager.Self.Relationships.Add(temp);
                MarioInstanceVsSolidCollision = temp;
            }
            MarioInstanceVsSolidCollision.Name = "MarioInstanceVsSolidCollision";

            {
                var temp    = new FlatRedBall.Math.Collision.DelegateSingleVsListRelationship <Super_Marios_Bros.Entities.Mario, Entities.Lucky_block>(MarioInstance, Lucky_blockList);
                var isCloud = false;
                temp.CollisionFunction = (first, second) =>
                {
                    return(first.CollideAgainst(second, isCloud));
                }
                ;
                FlatRedBall.Math.Collision.CollisionManager.Self.Relationships.Add(temp);
                MarioInstanceVsLucky_blockList = temp;
            }
            MarioInstanceVsLucky_blockList.Name = "MarioInstanceVsLucky_blockList";

            GumbaListAxisAlignedRectangleInstanceVsSolidCollision = FlatRedBall.Math.Collision.CollisionManagerTileShapeCollectionExtensions.CreateTileRelationship(FlatRedBall.Math.Collision.CollisionManager.Self, GumbaList, SolidCollision);
            GumbaListAxisAlignedRectangleInstanceVsSolidCollision.SetFirstSubCollision(item => item.AxisAlignedRectangleInstance);
            GumbaListAxisAlignedRectangleInstanceVsSolidCollision.Name = "GumbaListAxisAlignedRectangleInstanceVsSolidCollision";
            GumbaListAxisAlignedRectangleInstanceVsSolidCollision.SetMoveCollision(0f, 1f);

            {
                var temp    = new FlatRedBall.Math.Collision.DelegateSingleVsListRelationship <Super_Marios_Bros.Entities.Mario, Entities.A_Brick>(MarioInstance, A_BrickList);
                var isCloud = false;
                temp.CollisionFunction = (first, second) =>
                {
                    return(first.CollideAgainst(second, isCloud));
                }
                ;
                FlatRedBall.Math.Collision.CollisionManager.Self.Relationships.Add(temp);
                MarioInstanceVsA_BrickList = temp;
            }
            MarioInstanceVsA_BrickList.Name = "MarioInstanceVsA_BrickList";

            MarioInstanceAxisAlignedRectangleInstanceVsGumbaListLeftMarioDead = FlatRedBall.Math.Collision.CollisionManager.Self.CreateRelationship(MarioInstance, GumbaList);
            MarioInstanceAxisAlignedRectangleInstanceVsGumbaListLeftMarioDead.SetFirstSubCollision(item => item.AxisAlignedRectangleInstance);
            MarioInstanceAxisAlignedRectangleInstanceVsGumbaListLeftMarioDead.SetSecondSubCollision(item => item.LeftMarioDead);
            MarioInstanceAxisAlignedRectangleInstanceVsGumbaListLeftMarioDead.Name = "MarioInstanceAxisAlignedRectangleInstanceVsGumbaListLeftMarioDead";

            MarioInstanceAxisAlignedRectangleInstanceVsGumbaListRightMarioDead = FlatRedBall.Math.Collision.CollisionManager.Self.CreateRelationship(MarioInstance, GumbaList);
            MarioInstanceAxisAlignedRectangleInstanceVsGumbaListRightMarioDead.SetFirstSubCollision(item => item.AxisAlignedRectangleInstance);
            MarioInstanceAxisAlignedRectangleInstanceVsGumbaListRightMarioDead.SetSecondSubCollision(item => item.RightMarioDead);
            MarioInstanceAxisAlignedRectangleInstanceVsGumbaListRightMarioDead.Name = "MarioInstanceAxisAlignedRectangleInstanceVsGumbaListRightMarioDead";

            MarioInstanceAxisAlignedRectangleInstanceVsMushroomListAxisAlignedRectangleInstance = FlatRedBall.Math.Collision.CollisionManager.Self.CreateRelationship(MarioInstance, MushroomList);
            MarioInstanceAxisAlignedRectangleInstanceVsMushroomListAxisAlignedRectangleInstance.SetFirstSubCollision(item => item.AxisAlignedRectangleInstance);
            MarioInstanceAxisAlignedRectangleInstanceVsMushroomListAxisAlignedRectangleInstance.SetSecondSubCollision(item => item.AxisAlignedRectangleInstance);
            MarioInstanceAxisAlignedRectangleInstanceVsMushroomListAxisAlignedRectangleInstance.Name = "MarioInstanceAxisAlignedRectangleInstanceVsMushroomListAxisAlignedRectangleInstance";
            MarioInstanceAxisAlignedRectangleInstanceVsMushroomListAxisAlignedRectangleInstance.SetMoveCollision(1f, 1f);

            {
                var temp    = new FlatRedBall.Math.Collision.DelegateListVsSingleRelationship <Entities.Mushroom, FlatRedBall.TileCollisions.TileShapeCollection>(MushroomList, SolidCollision);
                var isCloud = false;
                temp.CollisionFunction = (first, second) =>
                {
                    return(first.CollideAgainst(second, isCloud));
                }
                ;
                FlatRedBall.Math.Collision.CollisionManager.Self.Relationships.Add(temp);
                MushroomListVsSolidCollision = temp;
            }
            MushroomListVsSolidCollision.Name = "MushroomListVsSolidCollision";

            {
                var temp    = new FlatRedBall.Math.Collision.DelegateListVsListRelationship <Entities.Mushroom, Entities.A_Brick>(MushroomList, A_BrickList);
                var isCloud = false;
                temp.CollisionFunction = (first, second) =>
                {
                    return(first.CollideAgainst(second, isCloud));
                }
                ;
                FlatRedBall.Math.Collision.CollisionManager.Self.Relationships.Add(temp);
                MushroomListVsA_BrickList = temp;
            }
            MushroomListVsA_BrickList.CollisionLimit = FlatRedBall.Math.Collision.CollisionLimit.All;
            MushroomListVsA_BrickList.Name           = "MushroomListVsA_BrickList";

            {
                var temp    = new FlatRedBall.Math.Collision.DelegateListVsListRelationship <Entities.Mushroom, Entities.Lucky_block>(MushroomList, Lucky_blockList);
                var isCloud = false;
                temp.CollisionFunction = (first, second) =>
                {
                    return(first.CollideAgainst(second, isCloud));
                }
                ;
                FlatRedBall.Math.Collision.CollisionManager.Self.Relationships.Add(temp);
                MushroomListVsLucky_blockList = temp;
            }
            MushroomListVsLucky_blockList.CollisionLimit = FlatRedBall.Math.Collision.CollisionLimit.All;
            MushroomListVsLucky_blockList.Name           = "MushroomListVsLucky_blockList";

            {
                var temp    = new FlatRedBall.Math.Collision.DelegateListVsSingleRelationship <Entities.Turtle, FlatRedBall.TileCollisions.TileShapeCollection>(TurtleList, SolidCollision);
                var isCloud = false;
                temp.CollisionFunction = (first, second) =>
                {
                    return(first.CollideAgainst(second, first.AxisAlignedRectangleInstance, isCloud));
                }
                ;
                FlatRedBall.Math.Collision.CollisionManager.Self.Relationships.Add(temp);
                TurtleListAxisAlignedRectangleInstanceVsSolidCollision = temp;
            }
            TurtleListAxisAlignedRectangleInstanceVsSolidCollision.Name = "TurtleListAxisAlignedRectangleInstanceVsSolidCollision";

            {
                var temp    = new FlatRedBall.Math.Collision.DelegateListVsListRelationship <Entities.Gumba, Entities.Turtle>(GumbaList, TurtleList);
                var isCloud = false;
                temp.CollisionFunction = (first, second) =>
                {
                    return(first.CollideAgainst(second, isCloud));
                }
                ;
                FlatRedBall.Math.Collision.CollisionManager.Self.Relationships.Add(temp);
                GumbaListVsTurtleList = temp;
            }
            GumbaListVsTurtleList.CollisionLimit = FlatRedBall.Math.Collision.CollisionLimit.All;
            GumbaListVsTurtleList.Name           = "GumbaListVsTurtleList";

            MarioInstanceAxisAlignedRectangleInstanceVsTurtleListAxisAlignedRectangleInstance = FlatRedBall.Math.Collision.CollisionManager.Self.CreateRelationship(MarioInstance, TurtleList);
            MarioInstanceAxisAlignedRectangleInstanceVsTurtleListAxisAlignedRectangleInstance.SetFirstSubCollision(item => item.AxisAlignedRectangleInstance);
            MarioInstanceAxisAlignedRectangleInstanceVsTurtleListAxisAlignedRectangleInstance.SetSecondSubCollision(item => item.AxisAlignedRectangleInstance);
            MarioInstanceAxisAlignedRectangleInstanceVsTurtleListAxisAlignedRectangleInstance.Name = "MarioInstanceAxisAlignedRectangleInstanceVsTurtleListAxisAlignedRectangleInstance";
            MarioInstanceAxisAlignedRectangleInstanceVsTurtleListAxisAlignedRectangleInstance.SetMoveCollision(0f, 1f);

            {
                var temp    = new FlatRedBall.Math.Collision.DelegateListVsSingleRelationship <Entities.Turtle, FlatRedBall.TileCollisions.TileShapeCollection>(TurtleList, CombinedShapeCollection);
                var isCloud = false;
                temp.CollisionFunction = (first, second) =>
                {
                    return(first.CollideAgainst(second, first.AxisAlignedRectangleInstance, isCloud));
                }
                ;
                FlatRedBall.Math.Collision.CollisionManager.Self.Relationships.Add(temp);
                TurtleListAxisAlignedRectangleInstanceVsCombinedShapeCollection = temp;
            }
            TurtleListAxisAlignedRectangleInstanceVsCombinedShapeCollection.Name = "TurtleListAxisAlignedRectangleInstanceVsCombinedShapeCollection";

            MarioInstanceVsCoinList      = FlatRedBall.Math.Collision.CollisionManager.Self.CreateRelationship(MarioInstance, CoinList);
            MarioInstanceVsCoinList.Name = "MarioInstanceVsCoinList";

            Forms = new Super_Marios_Bros.FormsControls.Screens.Mario_Main_GUIForms(Mario_Main_GUI);
            // normally we wait to set variables until after the object is created, but in this case if the
            // TileShapeCollection doesn't have its Visible set before creating the tiles, it can result in
            // really bad performance issues, as shapes will be made visible, then invisible. Really bad perf!
            if (SolidCollision != null)
            {
                SolidCollision.Visible = false;
            }
            FlatRedBall.TileCollisions.TileShapeCollectionLayeredTileMapExtensions.AddCollisionFromTilesWithType(SolidCollision, Map, "SolidCollision", false);
            // normally we wait to set variables until after the object is created, but in this case if the
            // TileShapeCollection doesn't have its Visible set before creating the tiles, it can result in
            // really bad performance issues, as shapes will be made visible, then invisible. Really bad perf!
            if (CloudCollision != null)
            {
                CloudCollision.Visible = false;
            }
            FlatRedBall.TileCollisions.TileShapeCollectionLayeredTileMapExtensions.AddCollisionFromTilesWithType(CloudCollision, Map, "CloudCollision", false);
            // normally we wait to set variables until after the object is created, but in this case if the
            // TileShapeCollection doesn't have its Visible set before creating the tiles, it can result in
            // really bad performance issues, as shapes will be made visible, then invisible. Really bad perf!
            if (CombinedShapeCollection != null)
            {
                CombinedShapeCollection.Visible = false;
            }


            PostInitialize();
            base.Initialize(addToManagers);
            if (addToManagers)
            {
                AddToManagers();
            }
        }
        public override void Initialize(bool addToManagers)
        {
			// Generated Initialize
			LoadStaticContent(ContentManagerName);
			if (!FlatRedBall.FlatRedBallServices.IsLoaded<FlatRedBall.Math.Geometry.ShapeCollection>(@"content/screens/charselect/escogerchar.shcx", ContentManagerName))
			{
			}
			EscogerChar = FlatRedBall.FlatRedBallServices.Load<FlatRedBall.Math.Geometry.ShapeCollection>(@"content/screens/charselect/escogerchar.shcx", ContentManagerName);
			if (!FlatRedBall.FlatRedBallServices.IsLoaded<FlatRedBall.Scene>(@"content/screens/charselect/scenefile.scnx", ContentManagerName))
			{
			}
			SceneFile = FlatRedBall.FlatRedBallServices.Load<FlatRedBall.Scene>(@"content/screens/charselect/scenefile.scnx", ContentManagerName);
			if (!FlatRedBall.FlatRedBallServices.IsLoaded<FlatRedBall.Graphics.Animation.AnimationChainList>(@"content/screens/charselect/seleccionpersonaje.achx", ContentManagerName))
			{
			}
			SeleccionPersonaje = FlatRedBall.FlatRedBallServices.Load<FlatRedBall.Graphics.Animation.AnimationChainList>(@"content/screens/charselect/seleccionpersonaje.achx", ContentManagerName);
			Cursores = new FlatRedBall.Math.PositionedObjectList<TesisEconoFight.Entities.Kursor>();
			Cursores.Name = "Cursores";
			Sprite1 = SceneFile.Sprites.FindByName("cara hayek1");
			Sprite2 = SceneFile.Sprites.FindByName("cara hayek2");
			
			
			PostInitialize();
			base.Initialize(addToManagers);
			if (addToManagers)
			{
				AddToManagers();
			}

        }
Exemple #17
0
		protected override void InitializeEntity(bool addToManagers)
		{
			// Generated Initialize
			LoadStaticContent(ContentManagerName);
			Cuerpo = new FlatRedBall.Math.Geometry.AxisAlignedRectangle();
			Cuerpo.Name = "Cuerpo";
			Sprite = SceneFile.Sprites.FindByName("keynes 131").Clone();
			Shield = new FlatRedBall.Math.Geometry.AxisAlignedRectangle();
			Shield.Name = "Shield";
			mListaAtaques = new FlatRedBall.Math.PositionedObjectList<TesisEconoFight.Entities.Especial>();
			mListaAtaques.Name = "mListaAtaques";
			Golpe = new FlatRedBall.Math.Geometry.AxisAlignedRectangle();
			Golpe.Name = "Golpe";
			mListaAtaqueSuper = new FlatRedBall.Math.PositionedObjectList<TesisEconoFight.Entities.SuperAtaque>();
			mListaAtaqueSuper.Name = "mListaAtaqueSuper";
			
			base.InitializeEntity(addToManagers);


		}
Exemple #18
0
 public GameScreen()
     : base("GameScreen")
 {
     BulletList      = new FlatRedBall.Math.PositionedObjectList <Parme.Frb.Example.Entities.Bullet>();
     BulletList.Name = "BulletList";
 }
        public override void Initialize(bool addToManagers)
        {
			// Generated Initialize
			LoadStaticContent(ContentManagerName);
			if (!FlatRedBall.FlatRedBallServices.IsLoaded<FlatRedBall.Math.Geometry.ShapeCollection>(@"content/screens/stageselect/seleccionstage.shcx", ContentManagerName))
			{
			}
			SeleccionStage = FlatRedBall.FlatRedBallServices.Load<FlatRedBall.Math.Geometry.ShapeCollection>(@"content/screens/stageselect/seleccionstage.shcx", ContentManagerName);
			if (!FlatRedBall.FlatRedBallServices.IsLoaded<FlatRedBall.Scene>(@"content/screens/stageselect/scenefile.scnx", ContentManagerName))
			{
			}
			SceneFile = FlatRedBall.FlatRedBallServices.Load<FlatRedBall.Scene>(@"content/screens/stageselect/scenefile.scnx", ContentManagerName);
			if (!FlatRedBall.FlatRedBallServices.IsLoaded<FlatRedBall.Graphics.Animation.AnimationChainList>(@"content/screens/stageselect/animarseleccion.achx", ContentManagerName))
			{
			}
			AnimarSeleccion = FlatRedBall.FlatRedBallServices.Load<FlatRedBall.Graphics.Animation.AnimationChainList>(@"content/screens/stageselect/animarseleccion.achx", ContentManagerName);
			Cursores = new FlatRedBall.Math.PositionedObjectList<TesisEconoFight.Entities.Kursor>();
			Cursores.Name = "Cursores";
			Sprite = SceneFile.Sprites.FindByName("universitätfreiburg1");
			
			
			PostInitialize();
			base.Initialize(addToManagers);
			if (addToManagers)
			{
				AddToManagers();
			}

        }
 public static void SetTowerList(FlatRedBall.Math.PositionedObjectList <BaseStructure> allTowers)
 {
     _allTowers = allTowers;
 }
Exemple #21
0
 public void SetEnemiesAndLayer(FlatRedBall.Math.PositionedObjectList <BaseEnemy> enemyList)
 {
     _enemyList = enemyList;
 }
Exemple #22
0
        public override void Initialize(bool addToManagers)
        {
            LoadStaticContent(ContentManagerName);
            SolidCollision      = new FlatRedBall.TileCollisions.TileShapeCollection();
            PlayerInstance      = new Soccer.Entities.Player(ContentManagerName, false);
            PlayerInstance.Name = "PlayerInstance";
            {
                var temp    = new FlatRedBall.Math.Collision.DelegateCollisionRelationship <Soccer.Entities.Player, FlatRedBall.TileCollisions.TileShapeCollection>(PlayerInstance, SolidCollision);
                var isCloud = false;
                temp.CollisionFunction = (first, second) =>
                {
                    return(first.CollideAgainst(second, first.AxisAlignedRectangleInstance, isCloud));
                }
                ;
                FlatRedBall.Math.Collision.CollisionManager.Self.Relationships.Add(temp);
                PlayerInstanceAxisAlignedRectangleInstanceVsSolidCollision = temp;
            }
            PlayerInstanceAxisAlignedRectangleInstanceVsSolidCollision.Name = "PlayerInstanceAxisAlignedRectangleInstanceVsSolidCollision";

            // Not instantiating for LayeredTileMap Map in Screens\GameScreen (Screen) because properties on the object prevent it
            BallList      = new FlatRedBall.Math.PositionedObjectList <Soccer.Entities.Ball>();
            BallList.Name = "BallList";
            BallListVsPlayerInstanceAxisAlignedRectangleInstance = FlatRedBall.Math.Collision.CollisionManager.Self.CreateRelationship(BallList, PlayerInstance);
            BallListVsPlayerInstanceAxisAlignedRectangleInstance.SetSecondSubCollision(item => item.AxisAlignedRectangleInstance);
            BallListVsPlayerInstanceAxisAlignedRectangleInstance.Name = "BallListVsPlayerInstanceAxisAlignedRectangleInstance";
            BallListVsPlayerInstanceAxisAlignedRectangleInstance.SetBounceCollision(0f, 1f, 0.5f);

            BallListVsSolidCollision      = FlatRedBall.Math.Collision.CollisionManagerTileShapeCollectionExtensions.CreateTileRelationship(FlatRedBall.Math.Collision.CollisionManager.Self, BallList, SolidCollision);
            BallListVsSolidCollision.Name = "BallListVsSolidCollision";
            BallListVsSolidCollision.SetBounceCollision(0f, 1f, 0.8f);

            GoalCollision = new FlatRedBall.TileCollisions.TileShapeCollection();
            {
                var temp    = new FlatRedBall.Math.Collision.DelegateCollisionRelationship <Soccer.Entities.Player, FlatRedBall.TileCollisions.TileShapeCollection>(PlayerInstance, GoalCollision);
                var isCloud = false;
                temp.CollisionFunction = (first, second) =>
                {
                    return(first.CollideAgainst(second, first.AxisAlignedRectangleInstance, isCloud));
                }
                ;
                FlatRedBall.Math.Collision.CollisionManager.Self.Relationships.Add(temp);
                PlayerInstanceAxisAlignedRectangleInstanceVsGoalCollision = temp;
            }
            PlayerInstanceAxisAlignedRectangleInstanceVsGoalCollision.Name = "PlayerInstanceAxisAlignedRectangleInstanceVsGoalCollision";

            BallListCollisionCircleVsGoalCollision = FlatRedBall.Math.Collision.CollisionManagerTileShapeCollectionExtensions.CreateTileRelationship(FlatRedBall.Math.Collision.CollisionManager.Self, BallList, GoalCollision);
            BallListCollisionCircleVsGoalCollision.SetFirstSubCollision(item => item.CollisionCircle);
            BallListCollisionCircleVsGoalCollision.Name = "BallListCollisionCircleVsGoalCollision";

            GoalDisplay      = new FlatRedBall.Sprite();
            GoalDisplay.Name = "GoalDisplay";
            PlayerInstanceBallCatchAreaVsBallListCollisionCircle = FlatRedBall.Math.Collision.CollisionManager.Self.CreateRelationship(PlayerInstance, BallList);
            PlayerInstanceBallCatchAreaVsBallListCollisionCircle.SetFirstSubCollision(item => item.BallCatchArea);
            PlayerInstanceBallCatchAreaVsBallListCollisionCircle.SetSecondSubCollision(item => item.CollisionCircle);
            PlayerInstanceBallCatchAreaVsBallListCollisionCircle.Name = "PlayerInstanceBallCatchAreaVsBallListCollisionCircle";

            UpSpringCollision = new FlatRedBall.TileCollisions.TileShapeCollection();
            PlayerInstanceAxisAlignedRectangleInstanceVsUpSpringCollision = FlatRedBall.Math.Collision.CollisionManagerTileShapeCollectionExtensions.CreateTileRelationship(FlatRedBall.Math.Collision.CollisionManager.Self, PlayerInstance, UpSpringCollision);
            PlayerInstanceAxisAlignedRectangleInstanceVsUpSpringCollision.SetFirstSubCollision(item => item.AxisAlignedRectangleInstance);
            PlayerInstanceAxisAlignedRectangleInstanceVsUpSpringCollision.Name = "PlayerInstanceAxisAlignedRectangleInstanceVsUpSpringCollision";

            BallListCollisionCircleVsUpSpringCollision = FlatRedBall.Math.Collision.CollisionManagerTileShapeCollectionExtensions.CreateTileRelationship(FlatRedBall.Math.Collision.CollisionManager.Self, BallList, UpSpringCollision);
            BallListCollisionCircleVsUpSpringCollision.SetFirstSubCollision(item => item.CollisionCircle);
            BallListCollisionCircleVsUpSpringCollision.Name = "BallListCollisionCircleVsUpSpringCollision";

            // normally we wait to set variables until after the object is created, but in this case if the
            // TileShapeCollection doesn't have its Visible set before creating the tiles, it can result in
            // really bad performance issues, as shapes will be made visible, then invisible. Really bad perf!
            if (SolidCollision != null)
            {
                SolidCollision.Visible = false;
            }
            FlatRedBall.TileCollisions.TileShapeCollectionLayeredTileMapExtensions.AddCollisionFromTilesWithType(SolidCollision, Map, "Solid");
            // normally we wait to set variables until after the object is created, but in this case if the
            // TileShapeCollection doesn't have its Visible set before creating the tiles, it can result in
            // really bad performance issues, as shapes will be made visible, then invisible. Really bad perf!
            if (GoalCollision != null)
            {
                GoalCollision.Visible = false;
            }
            FlatRedBall.TileCollisions.TileShapeCollectionLayeredTileMapExtensions.AddCollisionFromTilesWithType(GoalCollision, Map, "Goal");
            // normally we wait to set variables until after the object is created, but in this case if the
            // TileShapeCollection doesn't have its Visible set before creating the tiles, it can result in
            // really bad performance issues, as shapes will be made visible, then invisible. Really bad perf!
            if (UpSpringCollision != null)
            {
                UpSpringCollision.Visible = false;
            }
            FlatRedBall.TileCollisions.TileShapeCollectionLayeredTileMapExtensions.AddCollisionFromTilesWithType(UpSpringCollision, Map, "Spring");


            PostInitialize();
            base.Initialize(addToManagers);
            if (addToManagers)
            {
                AddToManagers();
            }
        }