예제 #1
0
 private void generateMove()
 {
     if (AIManager.getInstance().PlayerDetected)
     {
         updateState(State.Chase);
     }
     // patrol can just generate the waypoint once
     if (this.currentState == State.Patrol)
     {
         if (base.Placement.index == this.destinationWayPoint)
         {
             this.destinationWayPoint = AIManager.getInstance().getNextWayPoint(base.Placement.index, this.movementDirection);
             AIManager.getInstance().requestPath(base.Placement.index, this.destinationWayPoint, this.callBackDelegate);
         }
         else if (base.Placement.index == this.closestsPoint)
         {
             if (this.path.Count >= 1)
             {
                 this.closestsPoint = path.Pop();
             }
         }
     }
     else if (this.currentState == State.Chase)
     {
         // chase should regenerate the waypoint all the time
         if (this.closestsPoint == base.Placement.index)
         {
             AIManager.getInstance().requestPath(base.Placement.index, delegate(Stack <Point> path) {
                 this.callBackDelegate.Invoke(path);
                 if (this.path.Count >= 1)
                 {
                     this.closestsPoint = path.Pop();
                 }
             });
         }
     }
 }
예제 #2
0
        public Person(ContentManager content, string fileStartsWith, Placement startingLocation, float movementSpeed)
        {
            BaseAnimationManagerParams animationParams = new BaseAnimationManagerParams();

            animationParams.AnimationState  = AnimationState.PlayForward;
            animationParams.FrameRate       = FRAME_RATE;
            animationParams.TotalFrameCount = 4;
            BaseAnimated2DSpriteParams spriteParams = new Animated2DSpriteLoadSingleRowBasedOnTexture();

            spriteParams.Origin          = new Vector2(ResourceManager.TILE_SIZE / 2, ResourceManager.TILE_SIZE / 2);
            spriteParams.Texture         = LoadingUtils.load <Texture2D>(content, fileStartsWith + "Right");
            spriteParams.AnimationParams = animationParams;;
            // we actually want his feet in the middle, not his chest which is where the origin is
            spriteParams.Position     = new Vector2(startingLocation.worldPosition.X + spriteParams.Origin.X, startingLocation.worldPosition.Y);
            this.rightSprite          = new Animated2DSprite(spriteParams);
            spriteParams.SpriteEffect = SpriteEffects.FlipHorizontally;
            this.leftSprite           = new Animated2DSprite(spriteParams);
            this.Placement            = startingLocation;
            this.direction            = Direction.None;
            this.movementSpeed        = movementSpeed;
            this.activeSprite         = this.rightSprite;
            this.BoundingBox          = Helper.getPersonBBox(this.activeSprite.Position);
            this.previousTypeOfSpace  = AIManager.getInstance().Board[this.Placement.index.Y, this.Placement.index.X];
        }
예제 #3
0
        public Guard(ContentManager content, Placement startingLocation, string state, string movementDirection)
            : base(content, "Guard", startingLocation, MOVEMENT_SPEED_WALK)
        {
            this.callBackDelegate = delegate(Stack <Point> path) {
                if (this != null)
                {
                    this.path = path;
                }
            };
            // figure out our direction
            if (movementDirection == MovementDirection.Clockwise.ToString())
            {
                this.movementDirection = MovementDirection.Clockwise;
            }
            else
            {
                this.movementDirection = MovementDirection.CounterClockwise;
            }
            // figure out our starting state
            State initalState;

            if (state == State.Chase.ToString())
            {
                initalState = State.Chase;
            }
            else if (state == State.Patrol.ToString())
            {
                initalState = State.Patrol;
            }
            else if (state == State.Standing.ToString())
            {
                initalState = State.Standing;
            }
            else
            {
                initalState = State.NotSpawned;
            }
            updateState(initalState);

            if (this.currentState == State.Patrol && !AIManager.getInstance().PlayerDetected)
            {
                this.destinationWayPoint = AIManager.getInstance().getNextWayPoint(base.Placement.index, this.movementDirection);
                AIManager.getInstance().requestPath(base.Placement.index, this.destinationWayPoint, delegate(Stack <Point> path) {
                    this.callBackDelegate.Invoke(path);
                    if (this.path != null && this.path.Count >= 1)
                    {
                        this.closestsPoint = this.path.Pop();
                    }
                });
            }
            else if (this.currentState == State.Chase || AIManager.getInstance().PlayerDetected)
            {
                AIManager.getInstance().requestPath(base.Placement.index, delegate(Stack <Point> path) {
                    this.callBackDelegate.Invoke(path);
                    if (this.path != null && this.path.Count >= 1)
                    {
                        this.closestsPoint = this.path.Pop();
                    }
                });
            }
            else if (this.currentState == State.Standing || this.currentState == State.NotSpawned)
            {
                // set the closest point to our guards location
                this.closestsPoint = base.Placement.index;
            }

            this.ring          = new RadiusRing(content, base.activeSprite.Position);
            this.openDoorSfx   = LoadingUtils.load <SoundEffect>(content, "OpenDoor");
            this.prisonCellSfx = LoadingUtils.load <SoundEffect>(content, "CellDoor");
        }
예제 #4
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);
                }
            }
        }
예제 #5
0
        public override void dispose()
        {
            if (this.mapWalls != null)
            {
                this.mapWalls.dispose();
            }
            if (this.mapFloor != null)
            {
                this.mapFloor.dispose();
            }
            if (this.player != null)
            {
                this.player.dispose();
            }
            if (this.guards != null)
            {
                foreach (Guard guard in this.guards)
                {
                    guard.dispose();
                }
            }
            if (this.treasures != null)
            {
                foreach (Treasure treasure in this.treasures)
                {
                    treasure.dispose();
                }
            }
            if (this.dumpsters != null)
            {
                foreach (Dumpster dumpster in this.dumpsters)
                {
                    dumpster.dispose();
                }
            }
            if (this.treasure != null)
            {
                this.treasure.dispose();
            }
            this.timer.dispose();
            this.dustEmitter.dispose();

            // sfxs

            /*
             * if (this.introSfx != null) {
             *      this.introSfx.Dispose();
             * }
             * if (this.payDaySfx != null) {
             *      this.payDaySfx.Dispose();
             * }
             * if (this.treasureSfx != null) {
             *      this.treasureSfx.Dispose();
             * }
             * if (this.guardDetectedSfx != null) {
             *      this.guardDetectedSfx.Dispose();
             * }
             * if (this.dumpsterCrashSfx != null) {
             *      this.dumpsterCrashSfx.Dispose();
             * }
             * if (this.dumpsterCloseSfx != null) {
             *      this.dumpsterCloseSfx.Dispose();
             * }*/

            // AI
            AIManager.getInstance().dispose();
        }
예제 #6
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
        }
예제 #7
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);
        }
예제 #8
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;
        }