コード例 #1
0
        /// <summary>
        /// Generate background above our walkable layer and add them to our LevelScreen
        /// </summary>
        private void GenerateBackgroundAboveWalkableLayer()
        {
            int backgroundHeight = 4;
            int minY             = walkingLayerPoints[0].Key.Y;

            string background = "Level\\Tiles\\BGTile (3)";

            while (walkingLayerPoints.Exists(x => x.Key.Y < minY))
            {
                minY = walkingLayerPoints.Find(x => x.Key.Y < minY).Key.Y;
            }

            for (int index = 0; index < walkingLayerPoints.Count; index++)
            {
                KeyValuePair <Point, Type> info = walkingLayerPoints[index];

                // Want to create a background image behind our hazard so need to increment the currentPoint y by 1 so we start underneath our hazard
                Point currentPoint = info.Key;
                if (info.Value == Type.kHazard)
                {
                    currentPoint.Y++;
                }

                for (int y = currentPoint.Y - 1; y > minY - 1 - backgroundHeight; y--)
                {
                    Image addedObject = LevelScreen.AddEnvironmentObject(new Image(new Vector2(currentPoint.X, y) * TileDimensions, background));
                    addedObject.UsesCollider = false;
                }

                if (index % 3 == 0)
                {
                    LevelScreen.AddLight(new PointLight(new Vector2(750, 750), new Vector2(currentPoint.X * TileDimensions.X, (minY - 1) * TileDimensions.Y), Color.White));
                }
            }
        }
コード例 #2
0
ファイル: NosamGame.cs プロジェクト: Mason11987/Nosam
        public NosamGame()
        {
            graphics = new GraphicsDeviceManager(this);
            graphics.PreferredBackBufferWidth       = screenWidth;
            graphics.PreferredBackBufferHeight      = screenHeight;
            graphics.SynchronizeWithVerticalRetrace = true;

            device = graphics.GraphicsDevice;

            Mouse.WindowHandle  = Window.Handle;
            this.IsMouseVisible = true;

            Content.RootDirectory = "Content";

            ScreenRectangle = new Rectangle(0, 0, screenWidth, screenHeight);

            Components.Add(new InputHandler(this));

            stateManager = new GameStateManager(this);
            Components.Add(stateManager);

            StartMenuScreen = new StartMenuScreen(this, stateManager);
            NewGameScreen   = new NewGameScreen(this, stateManager);
            LevelScreen     = new LevelScreen(this, stateManager);

            stateManager.ChangeState(StartMenuScreen);

            this.IsFixedTimeStep = false;
            graphics.SynchronizeWithVerticalRetrace = false;
        }
コード例 #3
0
ファイル: Player.cs プロジェクト: zdepav/into-the-blaze
 public void Initialize(LevelScreen levelScreen, IntoTheBlaze game)
 {
     this.levelScreen = levelScreen;
     this.game        = game;
     Position         = Vector2.Zero;
     rotation         = 90;
     Reset();
 }
コード例 #4
0
        public void endDialogue(string levelUid)
        {
            ScreenSystem screenSystem = _systemManager.getSystem(SystemType.Screen) as ScreenSystem;
            LevelScreen  levelScreen  = screenSystem.getScreen(ScreenType.Level) as LevelScreen;

            _entityManager.removeComponent(levelUid, _currentEntityA, ComponentType.InDialogue);
            _entityManager.removeComponent(levelUid, _currentEntityB, ComponentType.InDialogue);
            levelScreen.removeDialoguePane(_currentDialogueComponent);
        }
コード例 #5
0
        public override void Initialize(GameScreen parentScreen)
        {
            base.Initialize(parentScreen);

            LevelScreen screen = (LevelScreen)parentScreen;

            Behaviour = screen.BehaviourFactory.Create <AIControlledEntity>(
                Settings.BehaviourName);
        }
コード例 #6
0
    // Checks if the collision is a new screen and moves appropriately
    public void UpdateCameraScreen(Collider2D collision)
    {
        LevelScreen newScreen = collision.gameObject.GetComponentInParent <LevelScreen>();

        if (newScreen != currentScreen)
        {
            currentScreen = newScreen;
        }
    }
コード例 #7
0
    private void Awake()
    {
        levelScreen = FindObjectOfType <LevelScreen>();

        controller = new Controller(1.85f);

        wFront = wheelFront.transform.GetComponent <Wheel>();
        wBack  = wheelBack.transform.GetComponent <Wheel>();

        carpet = FindObjectOfType <Carpet>();
    }
コード例 #8
0
        public void beginDialogue(string levelUid, int entityA, int entityB, CharacterDialogueComponent dialogueComponent)
        {
            ScreenSystem screenSystem = _systemManager.getSystem(SystemType.Screen) as ScreenSystem;
            LevelScreen  levelScreen  = screenSystem.getScreen(ScreenType.Level) as LevelScreen;

            _currentEntityA           = entityA;
            _currentEntityB           = entityB;
            _currentDialogueComponent = dialogueComponent;
            _entityManager.addComponent(levelUid, entityA, new InDialogueComponent());
            _entityManager.addComponent(levelUid, entityB, new InDialogueComponent());
            levelScreen.addDialoguePane(dialogueComponent);
        }
コード例 #9
0
 /// <summary>
 /// Adds the hazards and walkable layers to our LevelScreen Environment manager - this should happen after we add our background objects so the draw order is correct
 /// </summary>
 private void AddObjectsInFrontOfBackground()
 {
     for (int y = 0; y < GenerationData.Height; y++)
     {
         for (int x = 0; x < GenerationData.Width; x++)
         {
             if (LevelObjects[y, x] != null)
             {
                 // Do we want to add environment objects for these guys?
                 // Or should it be game objects?
                 LevelScreen.AddEnvironmentObject(LevelObjects[y, x]);
             }
         }
     }
 }
コード例 #10
0
ファイル: SpinelessEntity.cs プロジェクト: enjame/GGJ13
        public override void Initialize(GameScreen parentScreen)
        {
            base.Initialize(parentScreen);

            if (Settings.Physics != null)
            {
                var body = BodyFactory.CreateRectangle(
                    parentScreen.Physics.World,
                    Settings.Physics.Width * Settings.Scale.X,
                    Settings.Physics.Height * Settings.Scale.Y,
                    Settings.Physics.Density,
                    ConvertUnits.ToSimUnits(Settings.Position),
                    Settings.Physics.Offset);

                body.Enabled = false;

                body.FixtureList[0].CollidesWith        = (Category)Settings.Physics.CollidesWith;
                body.FixtureList[0].CollisionCategories = (Category)Settings.Physics.Category;
                body.FixtureList[0].CollisionGroup      = Settings.Physics.CollisionGroup;

                if (Settings.PhysicsFixture2 != null)
                {
                    Fixture fix2 = FixtureFactory.AttachRectangle(
                        Settings.PhysicsFixture2.Width,
                        Settings.PhysicsFixture2.Height,
                        Settings.PhysicsFixture2.Density,
                        Settings.PhysicsFixture2.Offset,
                        body);

                    fix2.CollidesWith        = (Category)Settings.PhysicsFixture2.CollidesWith;
                    fix2.CollisionCategories = (Category)Settings.PhysicsFixture2.Category;
                    fix2.CollisionGroup      = Settings.PhysicsFixture2.CollisionGroup;
                }

                body.BodyType = BodyType.Dynamic;
                body.Inertia  = Settings.Physics.RotationalInertia;

                physics = new PhysicsStructure
                {
                    Bodies = { body }
                };

                physics.Enabled = Settings.ActivateByDefault;
            }

            this.LevelScreen = (LevelScreen)parentScreen;
        }
コード例 #11
0
ファイル: HideOutGame.cs プロジェクト: CodeEdelmann/HideOut
        /// <summary>
        /// Allows the game to perform any initialization it needs to before starting to run.
        /// This is where it can query for any required services and load any non-graphic
        /// related content.  Calling base.Initialize will enumerate through any components
        /// and initialize them as well.
        /// </summary>
        protected override void Initialize()
        {
            graphics.ApplyChanges();

            titleScreen = new TitleScreen();
            levelScreen = new LevelScreen();
            endScreen   = new EndScreen();
            if (LEVEL_DESIGN_MODE)
            {
                currentScreen = levelScreen;
            }
            else
            {
                currentScreen = titleScreen; // Choose starting screen;
            }
            titleScreen.Initialize();
            levelScreen.Initialize();
            endScreen.Initialize();

            base.Initialize();
        }
コード例 #12
0
ファイル: IntoTheBlaze.cs プロジェクト: zdepav/into-the-blaze
 public IntoTheBlaze()
 {
     graphics = new GraphicsDeviceManager(this)
     {
         PreferredBackBufferWidth  = 1024,
         PreferredBackBufferHeight = 640
     };
     Window.Title = "Into The Blaze";
     graphics.ApplyChanges();
     Content.RootDirectory = "Content";
     MenuScreen            = new MenuScreen();
     LevelSelectScreen     = new LevelSelectScreen();
     CreditsScreen         = new CreditsScreen();
     LevelScreen           = new LevelScreen();
     LevelEndScreen        = new LevelEndScreen();
     screen    = null;
     updateFps = new Queue <float>();
     updateFps.Enqueue(0);
     drawFps = new Queue <float>();
     drawFps.Enqueue(0);
 }
コード例 #13
0
ファイル: Game1.cs プロジェクト: amtrak115/MG-EyesOfTheDragon
        public Game1()
        {
            _graphics       = new GraphicsDeviceManager(this);
            ScreenRectangle = new Rectangle(
                0,
                0,
                ScreenWidth,
                ScreenHeight);
            IsMouseVisible = true;

            Content.RootDirectory = "Content";

            Components.Add(new InputHandler(this));

            _gameStateManager = new GameStateManager(this);
            Components.Add(_gameStateManager);

            _ = new TextureManager();

            TitleScreen              = new TitleScreen(this, _gameStateManager);
            StartMenuScreen          = new StartMenuScreen(this, _gameStateManager);
            GamePlayScreen           = new GamePlayScreen(this, _gameStateManager);
            CharacterGeneratorScreen = new CharacterGeneratorScreen(this, _gameStateManager);
            SkillScreen              = new SkillScreen(this, _gameStateManager);
            LoadGameScreen           = new LoadGameScreen(this, _gameStateManager);
            ConversationScreen       = new ConversationScreen(this, _gameStateManager);
            ShopScreen         = new ShopState(this, _gameStateManager);
            InventoryScreen    = new InventoryScreen(this, _gameStateManager);
            CombatScreen       = new CombatScreen(this, _gameStateManager);
            GameOverScreen     = new GameOverScreen(this, _gameStateManager);
            LootScreen         = new LootScreen(this, _gameStateManager);
            StatsScreen        = new StatsScreen(this, _gameStateManager);
            LevelScreen        = new LevelScreen(this, _gameStateManager);
            QuestCompleteState = new QuestCompleteState(this, _gameStateManager);

            _gameStateManager.ChangeState(TitleScreen);

            IsFixedTimeStep = false;
            _graphics.SynchronizeWithVerticalRetrace = false;
        }
コード例 #14
0
        /// <summary>
        /// Generate background below our walkable layer and add them to our LevelScreen
        /// </summary>
        private void GenerateBackgroundBelowWalkableLayer()
        {
            Dictionary <Position, string> belowWalkableLayer = new Dictionary <Position, string>()
            {
                //{ Position.kLeft, "Level\\Tiles\\Tile (4)" },
                { Position.kLeft, GenerationData.AboveWalkableLayerTextureAsset },
                { Position.kMiddle, GenerationData.AboveWalkableLayerTextureAsset },
                { Position.kRight, GenerationData.AboveWalkableLayerTextureAsset },
                //{ Position.kRight, "Level\\Tiles\\Tile (6)" },
            };

            for (int index = 0; index < walkingLayerPoints.Count; index++)
            {
                Point    point        = walkingLayerPoints[index].Key;
                Position positionType = (Position)LevelObjects[point.Y, point.X].StoredObject;

                for (int y = point.Y + 1; y < GenerationData.Height; y++)
                {
                    Image addedObject = LevelScreen.AddEnvironmentObject(new Image(new Vector2(point.X * TileDimensions.X, y * TileDimensions.Y), belowWalkableLayer[positionType]));
                    addedObject.UsesCollider = false;
                }
            }
        }
コード例 #15
0
        protected override void Update(GameTime gameTime)
        {
            switch (_gameState)
            {
            case GameState.Initializing:
                Logger.log("Initializing in LoderGame.Update");
                _gameState = GameState.Intro;
                handleArgs();
                break;

            case GameState.Intro:
                Logger.log("In Intro game state in LoderGame.Update");

                // TODO: Do some sort of intro, and then open the main menu

                Logger.log("Creating background object.");
                Background background = new Background(ResourceManager.getResource("main_menu_background"));

                Logger.log("Creating main menu screen.");
                _mainMenuScreen = new MainMenuScreen(this);

                Logger.log("Loading background textures.");
                background.loadTextures();
                _menuBackgroundRenderer.background = background;

                Logger.log("Changing game state to MainMenu.");
                openMainMenu(true);
                _gameState = GameState.MainMenu;
                break;

            case GameState.MainMenu:
                _menuBackgroundScreenOffset += new Vector2(0.005f, 0f);
                _menuBackgroundRenderer.update(35f, _menuBackgroundScreenOffset);
                _systemManager.process(gameTime);
                break;

            case GameState.WorldMap:
                _systemManager.process(gameTime);
                break;

            case GameState.LoadingLevel:
                _systemManager.process(gameTime);
                if (!_levelSystem.isFinishedLoading)
                {
                    _levelSystem.load();
                }
                else if (_levelSystem.isFinishedLoading && !_levelSystem.finalized)
                {
                    _levelSystem.relax();
                    _levelSystem.clean();
                    _levelSystem.callScripts();
                    _levelSystem.finalized = true;
                    _levelSystem.switchToLevel(_levelSystem.lastLevelUidLoaded, _levelSystem.getPlayerSpawn(_levelSystem.lastLevelUidLoaded));
                    _loadingScreen.message = "Starting level!";
                    _screenSystem.addTransition(new ScreenFadeOutTransition(_loadingScreen, Color.Black, true, 0.05f, null, () =>
                    {
                        _screenSystem.removeScreen(_loadingScreen);
                        _gameState          = GameState.Level;
                        IsFixedTimeStep     = true;
                        _levelSystem.paused = false;
                        _levelScreen        = new LevelScreen(this, _systemManager, _entityManager);
                        _screenSystem.addScreen(_levelScreen);
                        _screenSystem.addTransition(new ScreenFadeInTransition(_levelScreen, Color.Black, true, 0.025f));
                    }));
                }
                break;

            case GameState.Level:
                _systemManager.process(gameTime);
                break;
            }

            base.Update(gameTime);
        }
コード例 #16
0
 static void Main()
 {
     Logger.Log(Logger.LogLevel.DEBUG, "Beginning of the graphic application");
     using (var game = new LevelScreen())
         game.Run();
 }