/// <summary>
/// Calls the ClearList method and Adds elements to the list
/// </summary>
/// <param name="leafList">lsit of leaves</param>
/// <param name="flowerList">list of flowers</param>
/// <param name="rockList">list of rocks</param>
/// <param name="jaguarList">list of jaguars</param>
/// <param name="viewPortRect">rectangle the size of the screen</param>
/// <param name="rand">random integer passed in to determine sprite placement</param>
/// <param name="spriteDict">key to pass in to access the sprite image</param>
/// <param name="roomClass">room class</param>
public void ClearAndPopulate(List<Leaf> leafList, List<Flower> flowerList, List<Rock> rockList, List<Jaguar> jaguarList, Rectangle viewPortRect, Random rand, Dictionary<string, Texture2D> spriteDict, Room roomClass)
{
ListClear(leafList,flowerList,rockList,jaguarList);
LeafPopulate(leafList, viewPortRect, rand, spriteDict, roomClass);
FlowerPopulate(flowerList, viewPortRect, rand, spriteDict, roomClass);
RockPopulate(rockList, viewPortRect, rand, spriteDict, roomClass);
JaguarPopulate(jaguarList, viewPortRect, rand, spriteDict, roomClass);
}
/// <summary>
/// Loads the game from the save file.
/// </summary>
public void LoadGame(Room roomClass)
{
TextReader XMLReader = new StreamReader("RoomSave.xml"); // creates new StreamReader which reads in the file path
XmlSerializer deserializer = new XmlSerializer(typeof(RoomData));
saveRoomData = (RoomData)deserializer.Deserialize(XMLReader);
roomClass.RoomNumber = saveRoomData.roomNumber;
XMLReader.Close();
}
public void Stats(SpriteBatch spriteBatch, Dictionary<string, SpriteFont> fontDict, Sloth slothClass, Room roomClass)
{
// Displaying Sloth Attributes (Health, Attack, Room#, Experience)
spriteBatch.DrawString(fontDict["Small"], "Health: " + slothClass.Health, new Vector2(20, 20), Color.Crimson);
spriteBatch.DrawString(fontDict["Small"], "Claw Sharpness: " + slothClass.Attack, new Vector2(20, 40), Color.BurlyWood);
spriteBatch.DrawString(fontDict["Small"], "Room Number: " + (roomClass.RoomNumber + 1), new Vector2(20, 60), Color.Ivory);
spriteBatch.DrawString(fontDict["Small"], "Experience: " + slothClass.Experience, new Vector2(20, 80), Color.Gainsboro);
}
/// <summary>
/// Update
/// </summary>
/// <param name="gameTime">current game time</param>
/// <param name="roomClass">room reference</param>
public void Update(GameTime gameTime, Room roomClass)
{
if (spritePosition.X > -50) // if the x coord of net is displayed on screen
{
spritePosition.X -= 5; // net flies to the right of the screen
}
base.Update(gameTime);
}
/// <summary>
/// Pop's a net off the net stack
/// </summary>
/// <param name="gameTime">current time of the game</param>
/// <param name="netCount">the total net count</param>
/// <param name="netStack">the stack data structure</param>
public void RemoveNet(Room roomClass, Stack<Net> netStack)
{
// every time the net reaches the left side of the screen, pop it off the stack
foreach (Net net in netStack)
{
if (net.spritePosition.X <= 0)
{
netStack.Pop();
roomClass.NetNumber++;
}
}
}
/// <summary>
/// Saves the game in the same directory as the executable.
/// </summary>
private void SaveGame(Room roomClass)
{
saveRoomData = new RoomData() // prime SaveData for saving game info
{
roomNumber = roomClass.RoomNumber,
};
DeleteExisting(); // Deletes old files if they exist
System.IO.StreamWriter file = new System.IO.StreamWriter("RoomSave.xml");
XmlSerializer serializer = new XmlSerializer(typeof(RoomData));
serializer.Serialize(file, saveRoomData);
file.Close();
}
/// <summary>
/// Checks every frame for a new request to save
/// </summary>
public void Update(GameTime gameTime, Room roomClass)
{
if (roomSaveRequest)
{
SaveGame(roomClass);
roomSaveRequest = false;
}
else if (roomLoadRequest)
{
LoadGame(roomClass);
roomLoadRequest = false;
}
}
/// <summary>
/// Adds elements to list
/// </summary>
/// <param name="leafList">list of leaves</param>
/// <param name="viewPortRect">size of the screen</param>
/// <param name="rand">random number to determine pickup location</param>
/// <param name="spriteDict">value to access the dictonary of sprites where leaf is located</param>
/// <param name="roomClass">room class</param>
public void LeafPopulate(List<Leaf> leafList, Rectangle viewPortRect, Random rand, Dictionary<string, Texture2D> spriteDict, Room roomClass)
{
for (int leavesToAdd = 0; leavesToAdd < roomClass.LeafNumber; leavesToAdd++)
leafList.Add(new Leaf(spriteDict["leaf"], (int)rand.Next(viewPortRect.Width - spriteDict["leaf"].Width),
(int)rand.Next(viewPortRect.Height - spriteDict["leaf"].Height)));
}
/// <summary>
/// Adds elements to list
/// </summary>
/// <param name="leafList">list of jaguars</param>
/// <param name="viewPortRect">size of the screen</param>
/// <param name="rand">random number to determine pickup location</param>
/// <param name="spriteDict">value to access the dictonary of sprites where jaguar is located</param>
/// <param name="roomClass">room class</param>
public void JaguarPopulate(List<Jaguar> jaguarList, Rectangle viewPortRect, Random rand, Dictionary<string, Texture2D> spriteDict, Room roomClass)
{
for (int jaguarsToAdd = 0; jaguarsToAdd < roomClass.JaguarNumber; jaguarsToAdd++)
jaguarList.Add(new Jaguar(spriteDict["jaguar"], (int)rand.Next(viewPortRect.Width - spriteDict["jaguar"].Width),
(int)rand.Next(viewPortRect.Height - spriteDict["jaguar"].Height)));
}
/// <summary>
/// Adds elements to list
/// </summary>
/// <param name="leafList">list of flowers</param>
/// <param name="viewPortRect">size of the screen</param>
/// <param name="rand">random number to determine pickup location</param>
/// <param name="spriteDict">value to access the dictonary of sprites where flower is located</param>
/// <param name="roomClass">room class</param>
public void FlowerPopulate(List<Flower> flowerList, Rectangle viewPortRect, Random rand, Dictionary<string, Texture2D> spriteDict, Room roomClass)
{
for (int flowersToAdd = 0; flowersToAdd < roomClass.FlowerNumber; flowersToAdd++)
flowerList.Add(new Flower(spriteDict["flower"], (int)rand.Next(viewPortRect.Width - spriteDict["flower"].Width),
(int)rand.Next(viewPortRect.Height - spriteDict["flower"].Height)));
}
/// <summary>
/// Adds elements to list
/// </summary>
/// <param name="leafList">list of rocks</param>
/// <param name="viewPortRect">size of the screen</param>
/// <param name="rand">random number to determine pickup location</param>
/// <param name="spriteDict">value to access the dictonary of sprites where rock is located</param>
/// <param name="roomClass">room class</param>
public void RockPopulate(List<Rock> rockList, Rectangle viewPortRect, Random rand, Dictionary<string, Texture2D> spriteDict, Room roomClass)
{
for (int rocksToAdd = 0; rocksToAdd < roomClass.RockNumber; rocksToAdd++)
rockList.Add(new Rock(spriteDict["sharpeningRock"], (int)rand.Next(viewPortRect.Width - spriteDict["sharpeningRock"].Width),
(int)rand.Next(viewPortRect.Height - spriteDict["sharpeningRock"].Height)));
}
/// <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)
{
KeyboardState currentKeyboardState = Keyboard.GetState(); // gets the current state of the keyboard
if (currentKeyboardState.IsKeyDown(Keys.Escape)) // will close program if escape key is pressed
Environment.Exit(0);
// All Logic that occurs during a menu is open (main screen, info screen, and game over)
if (menuOpen)
{
// Getting Past Initial Menus
if (menuClass.MenuNumber == 0)
{
if (currentKeyboardState.IsKeyDown(Keys.Enter))
{
menuClass = menus[1]; // sets menu class to the info screen
roomClass = levels[0] = new Room(spriteDict["darkJungle"], viewPortRect, 0, PICKUP_NUMBER, PICKUP_NUMBER, PICKUP_NUMBER, JAGUAR_NUMBER, NET_NUMBER); // loads the level and pickups into the 0th index of the level array
levels[1] = new Room(spriteDict["greenJungle"], viewPortRect, 1, PICKUP_NUMBER, PICKUP_NUMBER, PICKUP_NUMBER, JAGUAR_NUMBER, NET_NUMBER); // loads the level and pickups into the 0th index of the level array
levels[2] = new Room(spriteDict["jungleTree"], viewPortRect, 2, PICKUP_NUMBER, PICKUP_NUMBER, PICKUP_NUMBER, JAGUAR_NUMBER, NET_NUMBER); // loads the level and pickups into the 0th index of the level array
levels[3] = new Room(spriteDict["waterfall"], viewPortRect, 3, PICKUP_NUMBER, PICKUP_NUMBER, PICKUP_NUMBER, JAGUAR_NUMBER, NET_NUMBER); // loads the level and pickups into the 0th index of the level array
roomClass.InitializeRoom();
slothClass.InitializeSloth();
listManagement.ClearAndPopulate(leaves, flowers, rocks, jaguars, viewPortRect, rand, spriteDict, roomClass);
writeOutConsts.RoomConsts();
writeOutConsts.SlothConsts();
writeOutConsts.ItemConsts();
}
}
// Enter the game
if (menuClass.MenuNumber == 1)
if (currentKeyboardState.IsKeyDown(Keys.B))
menuOpen = false;
// Goes back to main screen
if (menuClass.MenuNumber == 2 || menuClass.MenuNumber == 3)
if (currentKeyboardState.IsKeyDown(Keys.A))
menuClass = menus[0];
}
else
{
spawnNet.SpawnANet(gameTime, 1, nets, spriteDict); // Call SpawnNet to send net across screen, pass in GameTime
spawnNet.RemoveNet(roomClass, nets); // Call SpawnNet to remove net
#region Clamping Movement
slothClass.spritePosition.Y = MathHelper.Clamp(slothClass.SpritePosition.Y, 0.0f, graphics.GraphicsDevice.Viewport.Height - (slothClass.SpriteImage.Height - 40)); // Restricting vertical sloth movement
if (roomClass.RoomNumber == 0)
slothClass.spritePosition.X = MathHelper.Clamp(slothClass.SpritePosition.X, 0.0f, graphics.GraphicsDevice.Viewport.Width); // Disallowing to walk back into the title screen
#endregion
// Game Over, sets menu to game over screen
if (slothClass.Health <= 0)
{
menuClass = menus[2];
menuOpen = true;
soundDict["jaguarCry"].Play(.25f, 0, 0);
}
// Accessing Help Screen
if (roomClass.RoomNumber >= 0)
if (currentKeyboardState.IsKeyDown(Keys.H))
menuOpen = true;
// XML Saving stats
if (currentKeyboardState.IsKeyDown(Keys.X))
{
SaveSloth.slothSaveRequest = true;
SaveRoom.roomSaveRequest = true;
}
// XML Loading stats
if (currentKeyboardState.IsKeyDown(Keys.L))
{
SaveSloth.slothLoadRequest = true;
SaveRoom.roomLoadRequest = true;
}
// Read in XML files
if (currentKeyboardState.IsKeyDown(Keys.R))
{
// Try to read in xml files, if errors assign constants to values
try
{
ReadIn.RoomPassIn();
ReadIn.ItemPassIn();
ReadIn.SlothPassIn();
}
catch
{
assignConsts.Assign();
}
}
#region Sloth Collision with Objects
// Pickup Collision with Sloth
// remove element from list, detract 1 from number of elements for that room, add health or experience to sloth
foreach (Leaf leaf in leaves)
if (slothClass.SpriteRectangle.Intersects(leaf.SpriteRectangle))
{
leaves.Del(leaf);
roomClass.LeafNumber--;
slothClass.Health += Leaf.HEALTH;
soundDict["leafCrunch"].Play(.25f, 0, 0);
}
foreach (Flower flower in flowers)
if (slothClass.SpriteRectangle.Intersects(flower.SpriteRectangle))
{
flowers.Del(flower);
roomClass.FlowerNumber--;
slothClass.Health += Flower.HEALTH;
}
foreach (Rock rock in rocks)
if (slothClass.SpriteRectangle.Intersects(rock.SpriteRectangle))
{
rocks.Del(rock);
roomClass.RockNumber--;
slothClass.Experience += Rock.EXPERIENCE;
soundDict["rockScrape"].Play(.25f, 0, 0);
}
foreach (Net net in nets)
if (slothClass.SpriteRectangle.Intersects(net.SpriteRectangle))
{
slothClass.Health = 0;
soundDict["netWoosh"].Play(.25f,0,0);
}
#endregion
#region Combat
// Combat, jaguar health subtracts from sloth attack when C is pressed and there is overlap between the 2
for (int jaguar = 0; jaguar < jaguars.Count; jaguar++)
{
if (slothClass.SpriteRectangle.Intersects(jaguars[jaguar].SpriteRectangle) && !currentKeyboardState.IsKeyDown(Keys.D))
{
if (currentKeyboardState.IsKeyDown(Keys.C))
jaguars[jaguar].Health -= slothClass.Attack;
else
{
slothClass.Health -= jaguars[jaguar].Attack;
}
// if jaguar health is less than or equal to 0, remove element from list, detract 1 from number of elements for that room, experience to sloth
if (jaguars[jaguar].Health <= 0)
{
jaguars.Del(jaguars[jaguar]);
roomClass.JaguarNumber--;
slothClass.Experience += Jaguar.EXPERIENCE;
}
}
}
#endregion
// Loading Next Level
foreach (Room level in levels)
{
#region Moving to Next Level, Right Side of Screen
if (slothClass.SpriteCenter.X >= viewPortRect.Width)
{
if (roomClass.RoomNumber < levels.Count() - 1)
{
roomClass = levels[roomClass.RoomNumber + 1];
slothClass.SpritePosition = new Vector2(Sloth.X_START, Sloth.Y_START);
listManagement.ClearAndPopulate(leaves, flowers, rocks, jaguars, viewPortRect, rand, spriteDict, roomClass);
}
else
{
menuOpen = true;
menuClass = menus[3]; // win screen
menuClass.MenuNumber = 3;
}
}
#endregion
#region Moving to Previous Level, Left Side of Screen
if (slothClass.SpriteCenter.X < -1)
{
if (roomClass.RoomNumber >= 1) // when sloth touches left side of screen
{
slothClass.SpritePosition = new Vector2(Sloth.X_PREVIOUS, slothClass.SpritePosition.Y); // moves sloth to a new position
roomClass = levels[roomClass.RoomNumber - 1];
listManagement.ClearAndPopulate(leaves, flowers, rocks, jaguars, viewPortRect, rand, spriteDict, roomClass);
}
}
#endregion
}
}
#region Object Update
foreach (Leaf leaf in leaves)
leaf.Update(gameTime);
foreach (Flower flower in flowers)
flower.Update(gameTime);
foreach (Rock rock in rocks)
rock.Update(gameTime);
foreach (Jaguar jaguar in jaguars)
jaguar.Update(gameTime);
foreach (Net net in nets)
net.Update(gameTime, roomClass);
#endregion
slothClass.Update(gameTime, currentKeyboardState); // calls sloth's update
saveSloth.Update(gameTime, slothClass);
saveRoom.Update(gameTime, roomClass);
base.Update(gameTime);
}
/// <summary>
/// LoadContent will be called once per game and is the place to load all of your content.
/// </summary>
protected override void LoadContent()
{
#region Dictonary Loading
// Loads all sprites into their respective dictonary keys
spriteDict.Add("darkJungle", Content.Load<Texture2D>("Sprites\\Backgrounds\\darkJungle"));
spriteDict.Add("gameOver", Content.Load<Texture2D>("Sprites\\Backgrounds\\gameOver"));
spriteDict.Add("winScreen", Content.Load<Texture2D>("Sprites\\Backgrounds\\winScreen"));
spriteDict.Add("greenJungle", Content.Load<Texture2D>("Sprites\\Backgrounds\\greenJungle"));
spriteDict.Add("infoScreen", Content.Load<Texture2D>("Sprites\\Backgrounds\\infoScreen"));
spriteDict.Add("jungleTree", Content.Load<Texture2D>("Sprites\\Backgrounds\\jungleTree"));
spriteDict.Add("smallTitle", Content.Load<Texture2D>("Sprites\\Backgrounds\\smallTitle"));
spriteDict.Add("waterfall", Content.Load<Texture2D>("Sprites\\Backgrounds\\waterfall"));
spriteDict.Add("jaguar", Content.Load<Texture2D>("Sprites\\Characters\\jaguarFinal"));
spriteDict.Add("slothathor", Content.Load<Texture2D>("Sprites\\Characters\\finalSloth1"));
spriteDict.Add("slothathorClaws", Content.Load<Texture2D>("Sprites\\Characters\\sloth2"));
spriteDict.Add("slothathorDefend", Content.Load<Texture2D>("Sprites\\Characters\\slothathorDefend"));
spriteDict.Add("flower", Content.Load<Texture2D>("Sprites\\Pickups\\smallFlower"));
spriteDict.Add("leaf", Content.Load<Texture2D>("Sprites\\Pickups\\leafFinal"));
spriteDict.Add("sharpeningRock", Content.Load<Texture2D>("Sprites\\Pickups\\rockFinal"));
spriteDict.Add("zap", Content.Load<Texture2D>("Sprites\\Characters\\smallNet"));
// Adds fonts to their keys
fontDict.Add("Medium", Content.Load<SpriteFont>("Fonts\\MediumFont"));
fontDict.Add("Small", Content.Load<SpriteFont>("Fonts\\SmallFont"));
fontDict.Add("Title", Content.Load<SpriteFont>("Fonts\\TitleFont"));
// Adds sounds to their keys
soundDict.Add("intro", Content.Load<SoundEffect>("Sounds\\beginningGame"));
soundDict.Add("jaguarCry", Content.Load<SoundEffect>("Sounds\\jaguarCry"));
soundDict.Add("leafCrunch", Content.Load<SoundEffect>("Sounds\\leafCrunch"));
soundDict.Add("rockScrape", Content.Load<SoundEffect>("Sounds\\rockScrape"));
soundDict.Add("netWoosh", Content.Load<SoundEffect>("Sounds\\netWoosh"));
soundDict.Add("slothScratch", Content.Load<SoundEffect>("Sounds\\slothScratch"));
// Populates arrays with new Rooms and Menus
levels[0] = new Room(spriteDict["darkJungle"], viewPortRect, 0, 1, rand.Next(3), rand.Next(3), rand.Next(2), 1);
levels[1] = new Room(spriteDict["greenJungle"], viewPortRect, 1, 1, rand.Next(4), rand.Next(2), rand.Next(2), 1);
levels[2] = new Room(spriteDict["jungleTree"], viewPortRect, 2, 1, rand.Next(2), rand.Next(4), rand.Next(2), 1);
levels[3] = new Room(spriteDict["waterfall"], viewPortRect, 3, 1, rand.Next(2), rand.Next(2), rand.Next(2), 1);
menus[0] = new Menu(spriteDict["smallTitle"], viewPortRect, 0);
menus[1] = new Menu(spriteDict["infoScreen"], viewPortRect, 1);
menus[2] = new Menu(spriteDict["gameOver"], viewPortRect, 2);
menus[3] = new Menu(spriteDict["winScreen"], viewPortRect, 2);
fonts[0] = fontDict["Medium"];
fonts[1] = fontDict["Title"];
fonts[2] = fontDict["Small"];
#endregion
menuOpen = true; // initial screen will be the title screen (a menu)
menuClass = menus[0]; // loads the first menu into the menu class
roomClass = levels[0]; // load first level into the room class
slothClass = new Sloth(spriteDict["slothathor"], spriteDict["slothathor"], spriteDict["slothathorClaws"], spriteDict["slothathorDefend"]); // loads all sloth sprites into sloth classes
soundDict["intro"].Play(.25f,0,0);
}