public MainMenu(ContentManager content)
        {
            ColouredButtonParams buttonParms = new ColouredButtonParams();

            buttonParms.Font            = ResourceManager.getInstance().Font;
            buttonParms.Height          = 25;
            buttonParms.LinesTexture    = ResourceManager.getInstance().ButtonLineTexture;
            buttonParms.MouseOverColour = ResourceManager.MOUSE_OVER_COLOUR;
            buttonParms.RegularColour   = ResourceManager.TEXT_COLOUR;
            buttonParms.StartX          = 640;
            buttonParms.Width           = 150;

            // play button
            buttonParms.StartY        = 473;
            buttonParms.Text          = "Play";
            buttonParms.TextsPosition = new Vector2(690f, buttonParms.StartY - 2f);
            this.playButton           = new ColouredButton(buttonParms);

            // instructions button
            buttonParms.StartY        = 515;
            buttonParms.Text          = "Instructions";
            buttonParms.TextsPosition = new Vector2(650f, buttonParms.StartY - 2f);
            this.instructionsButton   = new ColouredButton(buttonParms);

            // exit button
            buttonParms.StartY        = 557;
            buttonParms.Text          = "Exit";
            buttonParms.TextsPosition = new Vector2(690f, buttonParms.StartY - 2);
            this.exitButton           = new ColouredButton(buttonParms);

            // title
            StaticDrawable2DParams staticParms = new StaticDrawable2DParams();

            staticParms.Position = new Vector2(0f, -20f);
            staticParms.Texture  = LoadingUtils.load <Texture2D>(content, "Title");
            this.title           = new StaticDrawable2D(staticParms);

            // background
            staticParms.Position = new Vector2(0f, 0f);
            staticParms.Texture  = LoadingUtils.load <Texture2D>(content, "MainMenu");
            this.backGround      = new StaticDrawable2D(staticParms);

            // load sound effects
            this.introSfx    = LoadingUtils.load <SoundEffect>(content, "Introduction");
            this.outroSfx    = LoadingUtils.load <SoundEffect>(content, "LetsGo");
            this.idleSfxs    = new SoundEffect[3];
            this.idleSfxs[0] = LoadingUtils.load <SoundEffect>(content, "Rules");
            this.idleSfxs[1] = LoadingUtils.load <SoundEffect>(content, "HaventGotAllDay");
            this.idleSfxs[2] = LoadingUtils.load <SoundEffect>(content, "LetsRobSomething");
            // tired of hearing this when debugging and not starting in this state
            if (StateManager.getInstance().CurrentGameState == StateManager.GameState.MainMenu)
            {
                SoundManager.getInstance().sfxEngine.playSoundEffect(this.introSfx);
            }
#if WINDOWS
#if DEBUG
            ScriptManager.getInstance().registerObject(((ColouredButton)this.playButton).Text, "playText");
#endif
#endif
        }
 public void render(SpriteBatch spriteBatch)
 {
     if (this.ring != null && StateManager.getInstance().CurrentGameState == StateManager.GameState.Active)
     {
         this.ring.render(spriteBatch);
     }
 }
        public static bool resetTransitionTimes()
        {
            bool reset = false;

            // reset our current transition time in certain scenarios
            if (StateManager.getInstance().CurrentTransitionState == StateManager.TransitionState.None)
            {
                reset = true;
            }
            else if (StateManager.getInstance().CurrentTransitionState == StateManager.TransitionState.TransitionIn &&
                     StateManager.getInstance().PreviousTransitionState == StateManager.TransitionState.TransitionOut)
            {
                // if we went straight from a transition out to transition in we need to reset our transition timer as well
                reset = true;
            }
            return(reset);
        }
 public override void render(SpriteBatch spriteBatch)
 {
     if (StateManager.getInstance().TypeOfGameOver == StateManager.GameOverType.Guards ||
         StateManager.getInstance().TypeOfGameOver == StateManager.GameOverType.None)
     {
         this.looseBackGround.render(spriteBatch);
     }
     else
     {
         if (this.winBackGround != null)
         {
             this.winBackGround.render(spriteBatch);
         }
     }
     this.replayButton.render(spriteBatch);
     this.mapSelectionButton.render(spriteBatch);
     this.gameOverText.render(spriteBatch);
 }
        public static void loadLevelInformation(XmlDocument doc, ref Color wallColour, ref Color floorColour, ref float time)
        {
            string[] rgb = new string[] { MapEditor.XML_R, MapEditor.XML_G, MapEditor.XML_B };
            try {
                int[] result = (int[])loadObject <Int32>(doc, MapEditor.XML_WALL_COLOUR, rgb);
                wallColour = new Color(result[0], result[1], result[2]);

                result      = (int[])loadObject <Int32>(doc, MapEditor.XML_FLOOR_COLOUR, rgb);
                floorColour = new Color(result[0], result[1], result[2]);
            } catch (Exception) {
                // do nothign else with the error as the map is obviously in development stages
            }

            if (StateManager.getInstance().GameMode == StateManager.Mode.TimeAttack)
            {
                try {
                    time = (float)(((float[])loadObject <float>(doc, MapEditor.XML_TIME, new string[] { MapEditor.XML_MINUTES }))[0]);
                } catch (Exception) {
                    // do nothing else with the error as the map is obviously in development stages
                }
            }
        }
        public virtual void update(float elapsed)
        {
            if (resetTransitionTimes())
            {
                this.currentTransitionTime = 0f;
            }
            else
            {
                this.currentTransitionTime += elapsed;
            }
            StateManager.getInstance().PreviousTransitionState = StateManager.getInstance().CurrentTransitionState;

            // XBox controller support
            if (StateManager.getInstance().CurrentGameState != StateManager.GameState.Active)
            {
                Vector2 stickValue;
                if (InputManager.getInstance().isLeftStickMoved(PlayerIndex.One, out stickValue))
                {
                    int multiplier = 10;
                    InputManager.getInstance().updateMousePosition((int)stickValue.X * multiplier, (int)stickValue.Y * multiplier);
                }
            }
        }
Example #7
0
        /// <summary>
        /// Allows the game to run logic such as updating the world,
        /// checking for collisions, gathering input, and playing audio.
        /// </summary>
        /// <param name="gameTime">Provides a snapshot of timing values.</param>
        protected override void Update(GameTime gameTime)
        {
#if DEBUG
            base.Window.Title = "Rob, The Dumb Ass Robber...FPS: " + FrameRate.getInstance().calculateFrameRate(gameTime) + "    X:" +
                                InputManager.getInstance().MouseX + " Y:" + InputManager.getInstance().MouseY;
#endif

            // Allows the game to exit
            if (StateManager.getInstance().CurrentGameState == StateManager.GameState.MainMenu)
            {
                if (InputManager.getInstance().wasKeyPressed(Keys.Escape) ||
                    InputManager.getInstance().wasButtonPressed(PlayerIndex.One, Buttons.B))
                {
                    this.Exit();
                }
            }
            else if (StateManager.getInstance().CurrentGameState == StateManager.GameState.Exit)
            {
                this.Exit();
            }

            // Transition code
            #region Transitions
            if (StateManager.getInstance().CurrentGameState == StateManager.GameState.MainMenu)
            {
                if (StateManager.getInstance().PreviousGameState == StateManager.GameState.MainMenu &&
                    StateManager.getInstance().CurrentTransitionState == StateManager.TransitionState.TransitionOut)
                {
                    this.activeDisplay = this.mainMenu;
                }
                else if (StateManager.getInstance().PreviousGameState == StateManager.GameState.InGameMenu &&
                         StateManager.getInstance().CurrentTransitionState == StateManager.TransitionState.TransitionIn)
                {
                    this.activeDisplay = this.mainMenu;
                }
                else if (StateManager.getInstance().PreviousGameState == StateManager.GameState.InGameMenu &&
                         StateManager.getInstance().CurrentTransitionState == StateManager.TransitionState.TransitionOut)
                {
                    this.activeDisplay = this.inGameMenu;
                }
                else if (StateManager.getInstance().PreviousGameState == StateManager.GameState.ModeSelect &&
                         StateManager.getInstance().CurrentTransitionState == StateManager.TransitionState.TransitionOut)
                {
                    this.activeDisplay = this.modeSelectMenu;
                }
                else if (StateManager.getInstance().PreviousGameState == StateManager.GameState.Instructions &&
                         StateManager.getInstance().CurrentTransitionState == StateManager.TransitionState.TransitionOut)
                {
                    this.activeDisplay = this.instructionMenu;
                }
                else
                {
                    this.activeDisplay = this.mainMenu;
                }
            }
            else if (StateManager.getInstance().CurrentGameState == StateManager.GameState.Instructions)
            {
                if (StateManager.getInstance().PreviousGameState == StateManager.GameState.MainMenu &&
                    StateManager.getInstance().CurrentTransitionState == StateManager.TransitionState.TransitionOut)
                {
                    this.activeDisplay = this.mainMenu;
                }
                else
                {
                    this.activeDisplay = this.instructionMenu;
                }
            }
            else if (StateManager.getInstance().CurrentGameState == StateManager.GameState.ModeSelect)
            {
                if (StateManager.getInstance().PreviousGameState == StateManager.GameState.MainMenu &&
                    StateManager.getInstance().CurrentTransitionState == StateManager.TransitionState.TransitionOut)
                {
                    this.activeDisplay = this.mainMenu;
                }
                else if (StateManager.getInstance().PreviousGameState == StateManager.GameState.MapSelection &&
                         StateManager.getInstance().CurrentTransitionState == StateManager.TransitionState.TransitionOut)
                {
                    this.activeDisplay = this.mapSelectionMenu;
                }
                else
                {
                    this.activeDisplay = this.modeSelectMenu;
                }
            }
            else if (StateManager.getInstance().CurrentGameState == StateManager.GameState.Waiting ||
                     StateManager.getInstance().CurrentGameState == StateManager.GameState.Active)
            {
                if (StateManager.getInstance().PreviousGameState == StateManager.GameState.MapSelection &&
                    StateManager.getInstance().CurrentTransitionState == StateManager.TransitionState.TransitionIn)
                {
                    this.activeDisplay = this.gameDisplay;
                }
                else if (StateManager.getInstance().PreviousGameState == StateManager.GameState.MapSelection &&
                         StateManager.getInstance().CurrentTransitionState == StateManager.TransitionState.TransitionOut)
                {
                    this.activeDisplay = this.mapSelectionMenu;
                }
                else if (StateManager.getInstance().PreviousGameState == StateManager.GameState.Active &&
                         StateManager.getInstance().CurrentTransitionState == StateManager.TransitionState.TransitionOut)
                {
                    this.activeDisplay = this.mainMenu;
                }
                else if (StateManager.getInstance().PreviousGameState == StateManager.GameState.Active &&
                         StateManager.getInstance().CurrentTransitionState == StateManager.TransitionState.TransitionIn)
                {
                    this.activeDisplay = this.gameDisplay;
                }
                else if (StateManager.getInstance().PreviousGameState == StateManager.GameState.InGameMenu &&
                         StateManager.getInstance().CurrentTransitionState == StateManager.TransitionState.TransitionIn)
                {
                    this.activeDisplay = gameDisplay;
                }
                else if (StateManager.getInstance().PreviousGameState == StateManager.GameState.InGameMenu &&
                         StateManager.getInstance().CurrentTransitionState == StateManager.TransitionState.TransitionOut)
                {
                    this.activeDisplay = this.inGameMenu;
                }
                else
                {
                    this.activeDisplay = this.gameDisplay;
                }
            }
            else if (StateManager.getInstance().CurrentGameState == StateManager.GameState.InGameMenu)
            {
                if (StateManager.getInstance().PreviousGameState == StateManager.GameState.Active &&
                    StateManager.getInstance().CurrentTransitionState == StateManager.TransitionState.TransitionOut)
                {
                    this.activeDisplay = this.gameDisplay;
                }
                else if (StateManager.getInstance().PreviousGameState == StateManager.GameState.Active &&
                         StateManager.getInstance().CurrentTransitionState == StateManager.TransitionState.TransitionIn)
                {
                    this.activeDisplay = this.inGameMenu;
                }
                else if (StateManager.getInstance().PreviousGameState == StateManager.GameState.Waiting &&
                         StateManager.getInstance().CurrentTransitionState == StateManager.TransitionState.TransitionOut)
                {
                    this.activeDisplay = this.gameDisplay;
                }
                else if (StateManager.getInstance().PreviousGameState == StateManager.GameState.Waiting &&
                         StateManager.getInstance().CurrentTransitionState == StateManager.TransitionState.TransitionIn)
                {
                    this.activeDisplay = this.inGameMenu;
                }
                else if (StateManager.getInstance().PreviousGameState == StateManager.GameState.GameOver &&
                         StateManager.getInstance().CurrentTransitionState == StateManager.TransitionState.TransitionIn)
                {
                    this.activeDisplay = this.gameDisplay;
                }
                else if (StateManager.getInstance().PreviousGameState == StateManager.GameState.GameOver &&
                         StateManager.getInstance().CurrentTransitionState == StateManager.TransitionState.TransitionOut)
                {
                    this.activeDisplay = this.gameDisplay;
                }
                else
                {
                    this.activeDisplay = this.inGameMenu;
                }
            }
            else if (StateManager.getInstance().CurrentGameState == StateManager.GameState.MapSelection)
            {
                if (StateManager.getInstance().PreviousGameState == StateManager.GameState.ModeSelect &&
                    StateManager.getInstance().CurrentTransitionState == StateManager.TransitionState.TransitionOut)
                {
                    this.activeDisplay = this.modeSelectMenu;
                }
                else if (StateManager.getInstance().PreviousGameState == StateManager.GameState.GameOver &&
                         StateManager.getInstance().CurrentTransitionState == StateManager.TransitionState.TransitionOut)
                {
                    this.activeDisplay = this.gameOverDisplay;
                }
                else
                {
                    this.activeDisplay = this.mapSelectionMenu;
                }
            }
            else if (StateManager.getInstance().CurrentGameState == StateManager.GameState.GameOver)
            {
                if (StateManager.getInstance().PreviousGameState == StateManager.GameState.Active &&
                    StateManager.getInstance().CurrentTransitionState == StateManager.TransitionState.TransitionOut)
                {
                    this.activeDisplay = this.gameDisplay;
                }
                else
                {
                    this.activeDisplay = this.gameOverDisplay;
                }
            }
            else if (StateManager.getInstance().CurrentGameState == StateManager.GameState.Reset)
            {
                if (StateManager.getInstance().PreviousGameState == StateManager.GameState.GameOver &&
                    StateManager.getInstance().CurrentTransitionState == StateManager.TransitionState.TransitionOut)
                {
                    this.activeDisplay = this.gameOverDisplay;
                }
                else
                {
                    this.activeDisplay = this.gameDisplay;
                }
            }
            else
            {
                if (StateManager.getInstance().CurrentGameState == StateManager.GameState.InitGame)
                {
                    this.activeDisplay = this.mapSelectionMenu;
                    ((GameDisplay)this.gameDisplay).reset();
                    StateManager.getInstance().CurrentGameState  = StateManager.GameState.Waiting;
                    StateManager.getInstance().PreviousGameState = StateManager.GameState.MapSelection;
                }
                else
                {
                    this.activeDisplay = this.gameDisplay;
                }
            }
            #endregion Transitions

            float elapsed = gameTime.ElapsedGameTime.Milliseconds;
            this.activeDisplay.update(elapsed);
            SoundManager.getInstance().update();
            base.Update(gameTime);
        }
Example #8
0
        protected override void updateLocation(float elapsed)
        {
            this.ring.updatePosition(base.activeSprite.Position);
            Point endNode = AIManager.getInstance().findEndNode();

            if (this.closestsPoint == endNode)
            {
                StateManager.getInstance().CurrentGameState = StateManager.GameState.GameOver;
                StateManager.getInstance().TypeOfGameOver   = StateManager.GameOverType.Guards;
                SoundManager.getInstance().sfxEngine.playSoundEffect(this.prisonCellSfx);
            }

            if (this.direction != Direction.None)
            {
                float moveDistanceX = (this.movementSpeed * elapsed);
                float moveDistanceY = (this.movementSpeed * elapsed);
                if (withinDestinationSquare())
                {
                    // check if the center is less of a distance than the default via the elapsed * moevment speed
                    Vector2 currentSquaresMid = getMiddleOfCurrentSquare();
                    Vector2 middleOfSprite    = getMiddleOfSprite();
                    Vector2 max        = Vector2.Max(currentSquaresMid, middleOfSprite);
                    Vector2 min        = Vector2.Min(currentSquaresMid, middleOfSprite);
                    Vector2 difference = Vector2.Subtract(max, min);

                    if (base.direction == Direction.Up)
                    {
                        if (difference.Y < moveDistanceY)
                        {
                            moveDistanceY = difference.Y;
                        }
                    }
                    else if (base.direction == Direction.Down)
                    {
                        if (difference.Y < moveDistanceY)
                        {
                            moveDistanceY = difference.Y;
                        }
                    }
                    else if (base.direction == Direction.Left)
                    {
                        if (difference.X < moveDistanceX)
                        {
                            moveDistanceX = difference.X;
                        }
                    }
                    else if (base.direction == Direction.Right)
                    {
                        if (difference.X < moveDistanceX)
                        {
                            moveDistanceX = difference.X;
                        }
                    }
                }
                Vector2 newPos = base.activeSprite.Position;
                if (this.direction == Direction.Up)
                {
                    newPos = new Vector2(this.activeSprite.Position.X, this.activeSprite.Position.Y - moveDistanceY);
                }
                else if (this.direction == Direction.Right)
                {
                    newPos = new Vector2(this.activeSprite.Position.X + moveDistanceX, this.activeSprite.Position.Y);
                }
                else if (this.direction == Direction.Down)
                {
                    newPos = new Vector2(this.activeSprite.Position.X, this.activeSprite.Position.Y + moveDistanceY);
                }
                else if (this.direction == Direction.Left)
                {
                    newPos = new Vector2(this.activeSprite.Position.X - moveDistanceX, this.activeSprite.Position.Y);
                }
                base.activeSprite.Position = newPos;
            }

            // call the generic code before continuing
            base.updateLocation(elapsed);

            if (base.previousPlacement.index != base.Placement.index)
            {
                // if we are a door tile play the sfx
                if (AIManager.getInstance().Board[base.Placement.index.Y, base.Placement.index.X] == BasePathFinder.TypeOfSpace.VariableTerrainLowCost)
                {
                    SoundManager.getInstance().sfxEngine.playSoundEffect(this.openDoorSfx);
                }
            }
        }
        public override void update(float elapsed)
        {
            Vector2 mousePos = InputManager.getInstance().MousePosition;

            foreach (MapSelection selection in this.mapSelections)
            {
                selection.update(elapsed);
            }
            this.returnToModeSelectButton.processActorsMovement(mousePos);
            // mouse over sfx
            if (this.returnToModeSelectButton.isActorOver(mousePos))
            {
                if (!base.previousMouseOverButton)
                {
                    SoundManager.getInstance().sfxEngine.playSoundEffect(ResourceManager.getInstance().MouseOverSfx);
                }
                base.previousMouseOverButton = true;
            }
            else
            {
                bool foundInLoop = false;
                foreach (MapSelection selection in this.mapSelections)
                {
                    if (selection.PreviewButton.isActorOver(mousePos))
                    {
                        if (!base.previousMouseOverButton)
                        {
                            SoundManager.getInstance().sfxEngine.playSoundEffect(ResourceManager.getInstance().MouseOverSfx);
                        }
                        foundInLoop = true;
                        base.previousMouseOverButton = true;
                        break;
                    }
                }
                if (!foundInLoop)
                {
                    base.previousMouseOverButton = false;
                }
            }
            if (StateManager.getInstance().CurrentTransitionState == StateManager.TransitionState.None)
            {
                if (InputManager.getInstance().wasLeftButtonPressed() ||
                    InputManager.getInstance().wasButtonPressed(PlayerIndex.One, Buttons.A))
                {
                    if (this.returnToModeSelectButton.isActorOver(mousePos))
                    {
                        StateManager.getInstance().CurrentGameState       = StateManager.GameState.ModeSelect;
                        StateManager.getInstance().CurrentTransitionState = StateManager.TransitionState.TransitionOut;
                    }
                    else
                    {
                        foreach (MapSelection selection in this.mapSelections)
                        {
                            if (selection.PreviewButton.isActorOver(mousePos))
                            {
                                // Need a call back to load the correct map here
                                StateManager.getInstance().CurrentGameState       = StateManager.GameState.InitGame;
                                StateManager.getInstance().CurrentTransitionState = StateManager.TransitionState.TransitionOut;
                                StateManager.getInstance().MapInformation         = selection.MapName;
                                break;
                            }
                        }
                    }
                }
            }
            else if (StateManager.getInstance().CurrentTransitionState == StateManager.TransitionState.TransitionIn)
            {
                this.title.LightColour = base.fadeIn(Color.White);
                this.returnToModeSelectButton.updateColours(base.fadeIn(ResourceManager.TEXT_COLOUR));
                this.noPreviewImage.LightColour = base.fadeIn(ResourceManager.TEXT_COLOUR);
                if (this.returnToModeSelectButton.isActorOver(mousePos))
                {
                    this.returnToModeSelectButton.updateColours(base.fadeIn(ResourceManager.MOUSE_OVER_COLOUR));
                }
                foreach (MapSelection selection in this.mapSelections)
                {
                    if (selection.PreviewButton.isActorOver(mousePos))
                    {
                        selection.updateColours(base.fadeIn(ResourceManager.MOUSE_OVER_COLOUR), base.fadeIn(Color.White));
                    }
                    else
                    {
                        selection.updateColours(base.fadeIn(ResourceManager.TEXT_COLOUR), base.fadeIn(Color.White));
                    }
                }
            }
            else if (StateManager.getInstance().CurrentTransitionState == StateManager.TransitionState.TransitionOut)
            {
                this.title.LightColour = base.fadeOut(Color.White);
                this.returnToModeSelectButton.updateColours(base.fadeOut(ResourceManager.TEXT_COLOUR));
                this.noPreviewImage.LightColour = base.fadeOut(ResourceManager.TEXT_COLOUR);
                if (this.returnToModeSelectButton.isActorOver(mousePos))
                {
                    this.returnToModeSelectButton.updateColours(base.fadeOut(ResourceManager.MOUSE_OVER_COLOUR));
                }
                foreach (MapSelection selection in this.mapSelections)
                {
                    if (selection.PreviewButton.isActorOver(mousePos))
                    {
                        selection.updateColours(base.fadeOut(ResourceManager.MOUSE_OVER_COLOUR), base.fadeOut(Color.White));
                    }
                    else
                    {
                        selection.updateColours(base.fadeOut(ResourceManager.TEXT_COLOUR), base.fadeOut(Color.White));
                    }
                }
            }
            // if our transition time is up change our state
            if (base.transitionTimeElapsed())
            {
                if (StateManager.getInstance().CurrentTransitionState == StateManager.TransitionState.TransitionIn)
                {
                    StateManager.getInstance().CurrentTransitionState = StateManager.TransitionState.None;
                }
                else if (StateManager.getInstance().CurrentTransitionState == StateManager.TransitionState.TransitionOut)
                {
                    StateManager.getInstance().CurrentTransitionState = StateManager.TransitionState.TransitionIn;
                }
            }
            if (StateManager.getInstance().CurrentTransitionState == StateManager.TransitionState.None)
            {
                if (InputManager.getInstance().wasKeyPressed(Keys.Escape) ||
                    InputManager.getInstance().wasButtonPressed(PlayerIndex.One, Buttons.B))
                {
                    StateManager.getInstance().CurrentGameState       = StateManager.GameState.ModeSelect;
                    StateManager.getInstance().CurrentTransitionState = StateManager.TransitionState.TransitionOut;
                }
            }
            base.update(elapsed);
        }
        public override void update(float elapsed)
        {
            Vector2 mousePos = InputManager.getInstance().MousePosition;

            this.returnToMainButton.processActorsMovement(mousePos);
            // mouse over sfx
            if (this.returnToMainButton.isActorOver(mousePos))
            {
                if (!base.previousMouseOverButton)
                {
                    SoundManager.getInstance().sfxEngine.playSoundEffect(ResourceManager.getInstance().MouseOverSfx);
                }
                base.previousMouseOverButton = true;
            }
            else
            {
                base.previousMouseOverButton = false;
            }
            if (StateManager.getInstance().CurrentTransitionState == StateManager.TransitionState.None)
            {
                if (InputManager.getInstance().wasLeftButtonPressed() ||
                    InputManager.getInstance().wasButtonPressed(PlayerIndex.One, Buttons.A))
                {
                    if (this.returnToMainButton.isActorOver(mousePos))
                    {
                        StateManager.getInstance().CurrentGameState       = StateManager.GameState.MainMenu;
                        StateManager.getInstance().CurrentTransitionState = StateManager.TransitionState.TransitionOut;
                    }
                }
            }
            else if (StateManager.getInstance().CurrentTransitionState == StateManager.TransitionState.TransitionIn)
            {
                this.backGround.LightColour = base.fadeIn(Color.White);
                this.title.LightColour      = base.fadeIn(Color.White);
                this.returnToMainButton.updateColours(base.fadeIn(ResourceManager.TEXT_COLOUR));
                if (this.returnToMainButton.isActorOver(mousePos))
                {
                    this.returnToMainButton.updateColours(base.fadeIn(ResourceManager.MOUSE_OVER_COLOUR));
                }
            }
            else if (StateManager.getInstance().CurrentTransitionState == StateManager.TransitionState.TransitionOut)
            {
                this.backGround.LightColour = base.fadeOut(Color.White);
                this.title.LightColour      = base.fadeOut(Color.White);
                this.returnToMainButton.updateColours(base.fadeOut(ResourceManager.TEXT_COLOUR));
                if (this.returnToMainButton.isActorOver(mousePos))
                {
                    this.returnToMainButton.updateColours(base.fadeOut(ResourceManager.MOUSE_OVER_COLOUR));
                }
            }
            // if our transition time is up change our state
            if (base.transitionTimeElapsed())
            {
                if (StateManager.getInstance().CurrentTransitionState == StateManager.TransitionState.TransitionIn)
                {
                    StateManager.getInstance().CurrentTransitionState = StateManager.TransitionState.None;
                }
                else if (StateManager.getInstance().CurrentTransitionState == StateManager.TransitionState.TransitionOut)
                {
                    StateManager.getInstance().CurrentTransitionState = StateManager.TransitionState.TransitionIn;
                }
            }
            if (StateManager.getInstance().CurrentTransitionState == StateManager.TransitionState.None)
            {
                if (InputManager.getInstance().wasKeyPressed(Keys.Escape) ||
                    InputManager.getInstance().wasButtonPressed(PlayerIndex.One, Buttons.B))
                {
                    StateManager.getInstance().CurrentGameState       = StateManager.getInstance().PreviousGameState;
                    StateManager.getInstance().CurrentTransitionState = StateManager.TransitionState.TransitionOut;
                }
            }
            base.update(elapsed);
        }
Example #11
0
        public override void render(SpriteBatch spriteBatch)
        {
            // render the floor, treasure, than walls
            this.mapFloor.render(spriteBatch);
            this.treasureText.render(spriteBatch);
            this.treasure.render(spriteBatch);
            foreach (Treasure treasure in this.treasures)
            {
                treasure.render(spriteBatch);
            }
            this.mapWalls.render(spriteBatch);
            foreach (Dumpster dumpster in this.dumpsters)
            {
                dumpster.render(spriteBatch);
            }
            this.player.render(spriteBatch);
            foreach (Guard guard in this.guards)
            {
                guard.render(spriteBatch);
            }
            this.timer.render(spriteBatch);
            if (StateManager.getInstance().CurrentGameState == StateManager.GameState.Reset || StateManager.getInstance().CurrentGameState == StateManager.GameState.Waiting ||
                (StateManager.getInstance().CurrentGameState == StateManager.GameState.InGameMenu && StateManager.getInstance().PreviousGameState == StateManager.GameState.Waiting))
            {
                this.startButton.render(spriteBatch);
            }
            this.dustEmitter.render(spriteBatch);
#if DEBUG
            if (this.showCD)
            {
                Color debugColour = Color.Green;
                DebugUtils.drawBoundingBox(spriteBatch, this.player.BoundingBox, debugColour, ResourceManager.getInstance().ButtonLineTexture);
                foreach (Guard guard in this.guards)
                {
                    DebugUtils.drawBoundingBox(spriteBatch, guard.BoundingBox, debugColour, ResourceManager.getInstance().ButtonLineTexture);
                    DebugUtils.drawBoundingSphere(spriteBatch, guard.Ring.BoundingSphere, debugColour, ResourceManager.getInstance().DebugRing);
                }
                foreach (BoundingBox box in CollisionManager.getInstance().MapBoundingBoxes)
                {
                    DebugUtils.drawBoundingBox(spriteBatch, box, debugColour, ResourceManager.getInstance().ButtonLineTexture);
                }
                foreach (Treasure treasure in this.treasures)
                {
                    DebugUtils.drawBoundingBox(spriteBatch, treasure.BoundingBox, debugColour, ResourceManager.getInstance().ButtonLineTexture);
                }
                foreach (Dumpster dumpster in this.dumpsters)
                {
                    DebugUtils.drawBoundingBox(spriteBatch, dumpster.BoundingBox, debugColour, ResourceManager.getInstance().ButtonLineTexture);
                }
            }
            if (this.showWayPoints)
            {
                List <Point> wayPoints = AIManager.getInstance().WayPoints;
                foreach (Point wayPoint in wayPoints)
                {
                    spriteBatch.Draw(ResourceManager.getInstance().DebugChip, new Placement(wayPoint).worldPosition, Color.Purple);
                }
            }
            if (this.showAI)
            {
                // draw where we cannot walk
                for (int y = 0; y < 18; y++)
                {
                    for (int x = 0; x < 21; x++)
                    {
                        if (AIManager.getInstance().Board[y, x] == BasePathFinder.TypeOfSpace.Unwalkable)
                        {
                            spriteBatch.Draw(ResourceManager.getInstance().DebugChip, new Placement(new Point(x, y)).worldPosition, Color.Red);
                        }
                    }
                }
            }
#endif
        }
Example #12
0
        public override void update(float elapsed)
        {
            if (this.player != null)
            {
                this.treasureText.WrittenText = " x " + this.player.CapturedTreasures;
            }
            if (this.mapWalls != null)
            {
                this.mapWalls.update(elapsed);
            }
            this.dustEmitter.update(elapsed);
            Vector2 mousePos = InputManager.getInstance().MousePosition;

            if (StateManager.getInstance().CurrentGameState == StateManager.GameState.Waiting)
            {
                this.startButton.processActorsMovement(mousePos);
                // mouse over sfx
                if (this.startButton.isActorOver(mousePos))
                {
                    if (!base.previousMouseOverButton)
                    {
                        SoundManager.getInstance().sfxEngine.playSoundEffect(ResourceManager.getInstance().MouseOverSfx);
                    }
                    base.previousMouseOverButton = true;
                }
                else
                {
                    base.previousMouseOverButton = false;
                }
                if (InputManager.getInstance().wasLeftButtonPressed() ||
                    InputManager.getInstance().wasButtonPressed(PlayerIndex.One, Buttons.A))
                {
                    if (this.startButton.isActorOver(mousePos))
                    {
                        StateManager.getInstance().CurrentGameState = StateManager.GameState.Active;
                    }
                }
            }
            else if (StateManager.getInstance().CurrentGameState == StateManager.GameState.Active)
            {
                // check if the player won
                foreach (Point point in this.entryExitPoints)
                {
                    if (point == this.player.Placement.index)
                    {
                        StateManager.getInstance().CurrentGameState = StateManager.GameState.GameOver;
                        if (this.player.CapturedTreasures >= 1)
                        {
                            StateManager.getInstance().TypeOfGameOver = StateManager.GameOverType.Player;
                            SoundManager.getInstance().sfxEngine.playSoundEffect(this.payDaySfx);
                        }
                        else
                        {
                            StateManager.getInstance().TypeOfGameOver = StateManager.GameOverType.None;
                        }
                        break;
                    }
                }
                this.timer.update(elapsed);
                this.player.update(elapsed);
                foreach (Guard guard in this.guards)
                {
                    guard.update(elapsed);
                    if (guard.Ring.BoundingSphere.Intersects(this.player.BoundingBox) && !this.player.Hiding)
                    {
                        // did we JUST get detected?
                        if (!AIManager.getInstance().PlayerDetected)
                        {
                            SoundManager.getInstance().sfxEngine.playSoundEffect(this.guardDetectedSfx);
                        }
                        AIManager.getInstance().PlayerDetected = true;
                    }
                }
                foreach (Treasure treasure in this.treasures)
                {
                    treasure.update(elapsed);
                    if (treasure.BoundingBox.Intersects(this.player.BoundingBox))
                    {
                        treasure.PickedUp = true;
                        this.player.CapturedTreasures++;
                        SoundManager.getInstance().sfxEngine.playSoundEffect(this.treasureSfx, .5f);
                        break;
                    }
                }

                // are we trying to enter a dumpster
                if (InputManager.getInstance().wasKeyPressed(Keys.Space) ||
                    InputManager.getInstance().wasButtonPressed(PlayerIndex.One, Buttons.A))
                {
                    // check if we are close to a dumpster
                    foreach (Dumpster dumpster in dumpsters)
                    {
                        if (dumpster.BoundingBox.Intersects(this.player.BoundingBox) && dumpster.AcceptingOccupants)
                        {
                            this.player.Hiding = !this.player.Hiding;                            // reverse the bool
                            if (!this.player.Hiding)
                            {
                                // make this dumpster unusable again
                                dumpster.AcceptingOccupants = false;
                                SoundManager.getInstance().sfxEngine.playSoundEffect(this.dumpsterCloseSfx);
                            }
                            else
                            {
                                SoundManager.getInstance().sfxEngine.playSoundEffect(this.dumpsterCrashSfx);
                            }
                            break;
                        }
                    }
                }
            }

            // Transitions
            #region Transitions
            if (StateManager.getInstance().CurrentTransitionState == StateManager.TransitionState.TransitionIn)
            {
                // start our intro sound effect if we just started to transition
                if (StateManager.getInstance().PreviousGameState == StateManager.GameState.MapSelection &&
                    !SoundManager.getInstance().sfxEngine.isPlaying(LEVEL_ENTRY_SFX_NAME))
                {
                    StateManager.getInstance().CurrentGameState = StateManager.GameState.Waiting;
                    SoundManager.getInstance().sfxEngine.playSoundEffect(this.introSfx);
                    // initially create some particles
                    for (int i = 0; i < 40; i++)
                    {
                        this.dustEmitter.createParticle();
                    }
                }
                Color colour = base.fadeIn(Color.White);
                this.mapWalls.updateColours(base.fadeIn(this.mapWalls.Colour));
                this.mapFloor.updateColours(base.fadeIn(this.mapFloor.Colour));
                foreach (Treasure treasure in this.treasures)
                {
                    treasure.updateColours(colour);
                }
                foreach (Dumpster dumpster in this.dumpsters)
                {
                    dumpster.updateColours(colour);
                }
                this.player.updateColours(colour);
                foreach (Guard guard in this.guards)
                {
                    guard.updateColours(colour);
                }
                this.startButton.updateColours(base.fadeIn(ResourceManager.TEXT_COLOUR));
                if (this.startButton.isActorOver(mousePos))
                {
                    this.startButton.updateColours(base.fadeIn(ResourceManager.MOUSE_OVER_COLOUR));
                }

                // HUD
                this.treasure.LightColour     = colour;
                this.treasureText.LightColour = base.fadeIn(ResourceManager.TEXT_COLOUR);
                this.timer.updateColours(base.fadeIn(ResourceManager.TEXT_COLOUR), base.fadeIn(this.timer.ActiveTimeColour));
            }
            else if (StateManager.getInstance().CurrentTransitionState == StateManager.TransitionState.TransitionOut)
            {
                Color colour = base.fadeOut(Color.White);
                this.mapWalls.updateColours(base.fadeOut(this.mapWalls.Colour));
                this.mapFloor.updateColours(base.fadeOut(this.mapFloor.Colour));
                foreach (Treasure treasure in this.treasures)
                {
                    treasure.updateColours(colour);
                }
                foreach (Dumpster dumpster in this.dumpsters)
                {
                    dumpster.updateColours(colour);
                }
                this.player.updateColours(colour);
                foreach (Guard guard in this.guards)
                {
                    guard.updateColours(colour);
                }
                this.startButton.updateColours(base.fadeOut(ResourceManager.TEXT_COLOUR));
                if (this.startButton.isActorOver(mousePos))
                {
                    this.startButton.updateColours(base.fadeOut(ResourceManager.MOUSE_OVER_COLOUR));
                }

                this.dustEmitter.updateColours(base.fadeOut(DustParticleEmitter.COLOUR));

                // HUD
                this.treasure.LightColour     = colour;
                this.treasureText.LightColour = base.fadeOut(ResourceManager.TEXT_COLOUR);
                this.timer.updateColours(base.fadeOut(ResourceManager.TEXT_COLOUR), base.fadeOut(this.timer.ActiveTimeColour));

                // if the alarm is blaring, turn it off
                if (SoundManager.getInstance().sfxEngine.isPlaying(Timer.DETECTED_SFX_NAME))
                {
                    SoundManager.getInstance().sfxEngine.stop(Timer.DETECTED_SFX_NAME);
                }
            }

            // if our transition is up
            if (base.transitionTimeElapsed())
            {
                if (StateManager.getInstance().CurrentTransitionState == StateManager.TransitionState.TransitionIn)
                {
                    StateManager.getInstance().CurrentTransitionState = StateManager.TransitionState.None;
                    if (StateManager.getInstance().PreviousGameState == StateManager.GameState.MapSelection)
                    {
                        StateManager.getInstance().CurrentGameState = StateManager.GameState.Waiting;
                    }
                }
                else if (StateManager.getInstance().CurrentTransitionState == StateManager.TransitionState.TransitionOut)
                {
                    StateManager.getInstance().CurrentTransitionState = StateManager.TransitionState.TransitionIn;
                    // clear out the particles
                    this.dustEmitter.Particles.Clear();
                }
            }

            if (StateManager.getInstance().CurrentTransitionState == StateManager.TransitionState.None &&
                StateManager.getInstance().CurrentGameState == StateManager.GameState.Waiting ||
                StateManager.getInstance().CurrentGameState == StateManager.GameState.Active)
            {
                if (InputManager.getInstance().wasKeyPressed(Keys.Escape) ||
                    InputManager.getInstance().wasButtonPressed(PlayerIndex.One, Buttons.Start))
                {
                    StateManager.getInstance().CurrentGameState       = StateManager.GameState.InGameMenu;
                    StateManager.getInstance().CurrentTransitionState = StateManager.TransitionState.TransitionOut;
                }
            }
            #endregion Transitions
#if DEBUG
            if (InputManager.getInstance().wasKeyPressed(Keys.D1))
            {
                this.showAI = !this.showAI;
            }
            else if (InputManager.getInstance().wasKeyPressed(Keys.D2))
            {
                this.showCD = !this.showCD;
            }
            else if (InputManager.getInstance().wasKeyPressed(Keys.D3))
            {
                this.showWayPoints = !this.showWayPoints;
            }
            else if (InputManager.getInstance().wasKeyPressed(Keys.R))
            {
                reset();
            }
            // map editor
            MapEditor.getInstance().update();
#endif
            base.update(elapsed);
        }
Example #13
0
        public void reset()
        {
            string mapInformation = Directory.GetCurrentDirectory() + "\\" + ResourceManager.MAP_FOLDER + StateManager.getInstance().MapInformation;

            XmlReader xmlReader = XmlReader.Create(mapInformation + "Identifiers.xml");

            this.entryExitPoints = new List <Point>();
            Point         playersLocation   = new Point();
            Color         floorColour       = Color.White;
            Color         wallColour        = Color.Black;
            List <Point>  guardLocations    = new List <Point>();
            List <string> guardDirectins    = new List <string>();
            List <string> guardStates       = new List <string>();
            List <Point>  treasureLocations = new List <Point>();
            List <Point>  dumpsterLocations = new List <Point>();
            List <Point>  wayPoints         = new List <Point>();
            float         time = 5f;    //default of 5 minutes

            try {
                XmlDocument doc = new XmlDocument();
                doc.Load(xmlReader);

                // load the map information
                MapLoader.loadLevelInformation(doc, ref wallColour, ref floorColour, ref time);

                // load the player information
                MapLoader.loadPlayerInformation(doc, ref playersLocation);

                // load the treasure information
                MapLoader.loadGenericPointList(doc, MapEditor.MappingState.Treasure, out treasureLocations);

                // load the dumpster information
                MapLoader.loadGenericPointList(doc, MapEditor.MappingState.Dumpster, out dumpsterLocations);

                // load the entry information
                MapLoader.loadGenericPointList(doc, MapEditor.MappingState.GuardEntry, out entryExitPoints);

                // load the guard information
                MapLoader.loadGuardInformation(doc, ref guardLocations, ref guardDirectins, ref guardStates);

                // load the waypoint information
                MapLoader.loadGenericPointList(doc, MapEditor.MappingState.WayPoint, out wayPoints);
            } finally {
                xmlReader.Close();
            }
            // load our map
            MapLoader.load(content, mapInformation + Constants.FILE_EXTENSION, floorColour, wallColour, out mapWalls, out mapFloor);

            // let our AI manager know about the maps way points
            AIManager.getInstance().WayPoints = wayPoints;

            // load player at starting point
            this.player = new Player(this.content, new Placement(playersLocation));

            // load treasure at starting points
            int treasureSize = treasureLocations.Count;

            this.treasures = new Treasure[treasureSize];
            string treasureFileName;
            Random random = new Random();

            for (int i = 0; i < treasureSize; i++)
            {
                treasureFileName  = "Treasure" + random.Next(1, 3);
                this.treasures[i] = new Treasure(this.content, treasureFileName, new Placement(treasureLocations[i]));
            }

            // load dumpsters at starting points
            int dumpsterSize = dumpsterLocations.Count;

            this.dumpsters = new Dumpster[dumpsterSize];
            for (int i = 0; i < dumpsterSize; i++)
            {
                this.dumpsters[i] = new Dumpster(this.content, "DumpsterOpen", "DumpsterClosed", new Placement(dumpsterLocations[i]));
                // ensure these places are unwalkable by the guards
                AIManager.getInstance().Board[dumpsterLocations[i].Y, dumpsterLocations[i].X] = BasePathFinder.TypeOfSpace.Unwalkable;
            }

            // load guard(s) at starting points
            int guardSize = guardLocations.Count;

            this.guards = new Person[guardSize];
            Placement placement;

            for (int i = 0; i < guardSize; i++)
            {
                placement      = new Placement(guardLocations[i]);
                this.guards[i] = new Guard(this.content, placement, guardStates[i], guardDirectins[i]);
            }
            this.timer.reset(time);
            this.treasureText.WrittenText   = "x " + this.player.CapturedTreasures;
            this.dustEmitter.PlayerPosition = Vector2.Add(this.player.Placement.worldPosition, new Vector2(ResourceManager.TILE_SIZE / 2, 0f));
            StateManager.getInstance().CurrentGameState = StateManager.GameState.Waiting;
        }
        public override void update(float elapsed)
        {
            Vector2 mousePos = InputManager.getInstance().MousePosition;

            if (StateManager.getInstance().CurrentGameState == StateManager.GameState.GameOver)
            {
                this.replayButton.processActorsMovement(mousePos);
                this.mapSelectionButton.processActorsMovement(mousePos);
                // mouse over sfx
                if (this.replayButton.isActorOver(mousePos) || this.mapSelectionButton.isActorOver(mousePos))
                {
                    if (!base.previousMouseOverButton)
                    {
                        SoundManager.getInstance().sfxEngine.playSoundEffect(ResourceManager.getInstance().MouseOverSfx);
                    }
                    base.previousMouseOverButton = true;
                }
                else
                {
                    base.previousMouseOverButton = false;
                }
                if (InputManager.getInstance().wasLeftButtonPressed() ||
                    InputManager.getInstance().wasButtonPressed(PlayerIndex.One, Buttons.A))
                {
                    if (this.replayButton.isActorOver(mousePos))
                    {
                        StateManager.getInstance().CurrentGameState       = StateManager.GameState.Reset;
                        StateManager.getInstance().CurrentTransitionState = StateManager.TransitionState.TransitionOut;
                    }
                    else if (this.mapSelectionButton.isActorOver(mousePos))
                    {
                        StateManager.getInstance().CurrentGameState       = StateManager.GameState.MapSelection;
                        StateManager.getInstance().CurrentTransitionState = StateManager.TransitionState.TransitionOut;
                    }
                }
                if (StateManager.getInstance().TypeOfGameOver == StateManager.GameOverType.Guards)
                {
                    this.gameOverText.Position    = new Vector2(200f, this.gameOverText.Position.Y);
                    this.gameOverText.WrittenText = "You loose; you have to be quick";
                }
                else if (StateManager.getInstance().TypeOfGameOver == StateManager.GameOverType.Player)
                {
                    this.gameOverText.Position    = new Vector2(125f, this.gameOverText.Position.Y);
                    this.gameOverText.WrittenText = "Congratulations you won, you score is " + this.scoreCalculatorCallBack.Invoke();
                }
                else if (StateManager.getInstance().TypeOfGameOver == StateManager.GameOverType.None)
                {
                    this.gameOverText.Position    = new Vector2(75f, this.gameOverText.Position.Y);
                    this.gameOverText.WrittenText = "You loose, you need to capture at least 1 piece of treasure";
                }
            }

            // Transitions
            #region Transitions
            if (StateManager.getInstance().CurrentTransitionState == StateManager.TransitionState.TransitionIn)
            {
                Color colour = base.fadeIn(Color.White);
                this.looseBackGround.LightColour = colour;
                this.winBackGround.LightColour   = colour;
                this.gameOverText.LightColour    = colour;
                this.replayButton.updateColours(base.fadeIn(ResourceManager.TEXT_COLOUR));
                if (this.replayButton.isActorOver(mousePos))
                {
                    this.replayButton.updateColours(base.fadeIn(ResourceManager.MOUSE_OVER_COLOUR));
                }
                this.mapSelectionButton.updateColours(base.fadeIn(ResourceManager.TEXT_COLOUR));
                if (this.mapSelectionButton.isActorOver(mousePos))
                {
                    this.mapSelectionButton.updateColours(base.fadeIn(ResourceManager.MOUSE_OVER_COLOUR));
                }
            }
            else if (StateManager.getInstance().CurrentTransitionState == StateManager.TransitionState.TransitionOut)
            {
                Color colour = base.fadeOut(Color.White);
                this.looseBackGround.LightColour = colour;
                this.winBackGround.LightColour   = colour;
                this.gameOverText.LightColour    = colour;
                this.replayButton.updateColours(base.fadeOut(ResourceManager.TEXT_COLOUR));
                if (this.replayButton.isActorOver(mousePos))
                {
                    this.replayButton.updateColours(base.fadeOut(ResourceManager.MOUSE_OVER_COLOUR));
                }
                this.mapSelectionButton.updateColours(base.fadeOut(ResourceManager.TEXT_COLOUR));
                if (this.mapSelectionButton.isActorOver(mousePos))
                {
                    this.mapSelectionButton.updateColours(base.fadeOut(ResourceManager.MOUSE_OVER_COLOUR));
                }
            }

            // if our transition is up
            if (base.transitionTimeElapsed())
            {
                if (StateManager.getInstance().CurrentTransitionState == StateManager.TransitionState.TransitionIn)
                {
                    StateManager.getInstance().CurrentTransitionState = StateManager.TransitionState.None;
                }
                else if (StateManager.getInstance().CurrentTransitionState == StateManager.TransitionState.TransitionOut)
                {
                    StateManager.getInstance().CurrentTransitionState = StateManager.TransitionState.TransitionIn;
                    if (StateManager.getInstance().CurrentGameState == StateManager.GameState.Reset)
                    {
                        this.resetCallBack.Invoke();
                        Console.WriteLine("Reset");
                    }
                }
            }
            #endregion Transitions
            base.update(elapsed);
        }
        public override void update(float elapsed)
        {
            Vector2 mousePos = InputManager.getInstance().MousePosition;

            this.playButton.processActorsMovement(mousePos);
            this.instructionsButton.processActorsMovement(mousePos);
            this.exitButton.processActorsMovement(mousePos);
            // mouse over sfx
            if (this.playButton.isActorOver(mousePos) || this.exitButton.isActorOver(mousePos))
            {
                if (!base.previousMouseOverButton)
                {
                    SoundManager.getInstance().sfxEngine.playSoundEffect(ResourceManager.getInstance().MouseOverSfx);
                }
                base.previousMouseOverButton = true;
            }
            else
            {
                base.previousMouseOverButton = false;
            }
            if (StateManager.getInstance().CurrentTransitionState == StateManager.TransitionState.None)
            {
                if (InputManager.getInstance().wasLeftButtonPressed() ||
                    InputManager.getInstance().wasButtonPressed(PlayerIndex.One, Buttons.A))
                {
                    if (this.playButton.isActorOver(mousePos))
                    {
                        StateManager.getInstance().CurrentTransitionState = StateManager.TransitionState.TransitionOut;
                        StateManager.getInstance().CurrentGameState       = StateManager.GameState.ModeSelect;
                        SoundManager.getInstance().sfxEngine.playSoundEffect(this.outroSfx);
                    }
                    else if (this.instructionsButton.isActorOver(mousePos))
                    {
                        StateManager.getInstance().CurrentTransitionState = StateManager.TransitionState.TransitionOut;
                        StateManager.getInstance().CurrentGameState       = StateManager.GameState.Instructions;
                    }
                    else if (this.exitButton.isActorOver(mousePos))
                    {
                        StateManager.getInstance().CurrentGameState = StateManager.GameState.Exit;
                    }
                }
            }
            else if (StateManager.getInstance().CurrentTransitionState == StateManager.TransitionState.TransitionIn)
            {
                if (this.playButton.isActorOver(mousePos))
                {
                    this.playButton.updateColours(base.fadeIn(ResourceManager.MOUSE_OVER_COLOUR));
                    this.instructionsButton.updateColours(base.fadeIn(ResourceManager.TEXT_COLOUR));
                    this.exitButton.updateColours(base.fadeIn(ResourceManager.TEXT_COLOUR));
                }
                else if (this.exitButton.isActorOver(mousePos))
                {
                    this.exitButton.updateColours(base.fadeIn(ResourceManager.MOUSE_OVER_COLOUR));
                    this.instructionsButton.updateColours(base.fadeIn(ResourceManager.TEXT_COLOUR));
                    this.playButton.updateColours(base.fadeIn(ResourceManager.TEXT_COLOUR));
                }
                else if (this.instructionsButton.isActorOver(mousePos))
                {
                    this.instructionsButton.updateColours(base.fadeIn(ResourceManager.MOUSE_OVER_COLOUR));
                    this.playButton.updateColours(base.fadeIn(ResourceManager.TEXT_COLOUR));
                    this.exitButton.updateColours(base.fadeIn(ResourceManager.TEXT_COLOUR));
                }
                else
                {
                    this.playButton.updateColours(base.fadeIn(ResourceManager.TEXT_COLOUR));
                    this.exitButton.updateColours(base.fadeIn(ResourceManager.TEXT_COLOUR));
                    this.instructionsButton.updateColours(base.fadeIn(ResourceManager.TEXT_COLOUR));
                }
                this.backGround.LightColour = base.fadeIn(Color.White);
                this.title.LightColour      = base.fadeIn(Color.White);
            }
            else if (StateManager.getInstance().CurrentTransitionState == StateManager.TransitionState.TransitionOut)
            {
                if (this.playButton.isActorOver(mousePos))
                {
                    this.playButton.updateColours(base.fadeOut(ResourceManager.MOUSE_OVER_COLOUR));
                    this.exitButton.updateColours(base.fadeOut(ResourceManager.TEXT_COLOUR));
                    this.instructionsButton.updateColours(base.fadeOut(ResourceManager.TEXT_COLOUR));
                }
                else if (this.exitButton.isActorOver(mousePos))
                {
                    this.exitButton.updateColours(base.fadeOut(ResourceManager.MOUSE_OVER_COLOUR));
                    this.playButton.updateColours(base.fadeOut(ResourceManager.TEXT_COLOUR));
                    this.instructionsButton.updateColours(base.fadeOut(ResourceManager.TEXT_COLOUR));
                }
                else if (this.instructionsButton.isActorOver(mousePos))
                {
                    this.playButton.updateColours(base.fadeOut(ResourceManager.TEXT_COLOUR));
                    this.exitButton.updateColours(base.fadeOut(ResourceManager.TEXT_COLOUR));
                    this.instructionsButton.updateColours(base.fadeOut(ResourceManager.MOUSE_OVER_COLOUR));
                }
                else
                {
                    this.playButton.updateColours(base.fadeOut(ResourceManager.TEXT_COLOUR));
                    this.exitButton.updateColours(base.fadeOut(ResourceManager.TEXT_COLOUR));
                    this.instructionsButton.updateColours(base.fadeOut(ResourceManager.TEXT_COLOUR));
                }
                this.backGround.LightColour = base.fadeOut(Color.White);
                this.title.LightColour      = base.fadeOut(Color.White);
                //reset the idle timer
                this.timeIdle = 0f;
            }
            // if our transition time is up change our state
            if (base.transitionTimeElapsed())
            {
                if (StateManager.getInstance().CurrentTransitionState == StateManager.TransitionState.TransitionIn)
                {
                    StateManager.getInstance().CurrentTransitionState = StateManager.TransitionState.None;
                }
                else if (StateManager.getInstance().CurrentTransitionState == StateManager.TransitionState.TransitionOut)
                {
                    StateManager.getInstance().CurrentTransitionState = StateManager.TransitionState.TransitionIn;
                }
            }

            this.timeIdle += elapsed;
            if (this.timeIdle >= PLAY_IDLE_AT)
            {
                Random rand       = new Random();
                int    idleToPlay = this.idleLastPlayed;
                do
                {
                    idleToPlay = rand.Next(this.idleSfxs.Length);
                } while (idleToPlay == this.idleLastPlayed);
                SoundManager.getInstance().sfxEngine.playSoundEffect(this.idleSfxs[idleToPlay]);
                this.idleLastPlayed = idleToPlay;
                this.timeIdle       = 0f;
            }
            base.update(elapsed);
        }