public static bool ComparePlayerTraitsToAttributeRequirement(Character.Models.Character player, AttributeRequirement requirement)
{
switch (requirement.RelevantCharacterAttribute)
{
case AttributeStrings.Defense:
return(player.Attributes.Defense >= requirement.MinimumAttributeValue);
case AttributeStrings.Dexterity:
return(player.Attributes.Dexterity >= requirement.MinimumAttributeValue);
case AttributeStrings.Luck:
return(player.Attributes.Luck >= requirement.MinimumAttributeValue);
case AttributeStrings.Stamina:
return(player.Attributes.Stamina >= requirement.MinimumAttributeValue);
case AttributeStrings.Strength:
return(player.Attributes.Strength >= requirement.MinimumAttributeValue);
case AttributeStrings.Wisdom:
return(player.Attributes.Wisdom >= requirement.MinimumAttributeValue);
}
return(false);
}
public static InventoryItem HandleItemTrade(Character.Models.Character player, Character.Models.Character character, Items foundItem, Room.Models.Room currentRoom)
{
if (foundItem.InventoryItems.Any())
{
AttributeHandler.UpdatePlayerAttributesFromInventoryItem(player, foundItem.InventoryItems.First(), true);
player.Attributes.CarriedItemsCount -= foundItem.InventoryItems.First().InventorySpaceConsumed;
character.CarriedItems.Add(foundItem.InventoryItems.First());
player.CarriedItems.Remove(foundItem.InventoryItems.First());
if (character.DesiredItem != null &&
player.Attributes.CarriedItemsCount + character.OfferedItem.InventorySpaceConsumed <= player.Attributes.MaximumCarryingCapacity)
{
AttributeHandler.UpdatePlayerAttributesFromInventoryItem(player, character.OfferedItem);
player.Attributes.CarriedItemsCount += character.OfferedItem.InventorySpaceConsumed;
player.CarriedItems.Add(character.OfferedItem);
character.CarriedItems.Remove(character.OfferedItem);
character.DesiredItem = new InventoryItem();
return(character.OfferedItem);
}
}
return(new InventoryItem {
ItemName = ""
});
}
// Used when user types 'items' or similar command
public static string CreateStringOfItemDescriptions(Character.Models.Character player, List <InventoryItem> roomItems)
{
var itemDescriptions = "";
if (roomItems != null)
{
foreach (var item in roomItems)
{
if (item?.AttributeRequirementToSee != null && !InventoryHandler.PlayerMeetsRequirementForItem(player, false, item))
{
itemDescriptions += $"{ConsoleStrings.LackingRequirementItemDescription} (<{item.AttributeRequirementToSee.RequirementName}> needed) \n\n";
}
else if (item.InOriginalLocation)
{
itemDescriptions += item.OriginalPlacementDescription + "\n\n";
}
else
{
itemDescriptions += item.GenericPlacementDescription + "\n\n";
}
}
}
return(itemDescriptions);
}
// Used when user types 'weapons' or similar command
public static string CreateStringOfWeaponDescriptions(Character.Models.Character player, List <WeaponItem> roomWeapons)
{
var weaponDescriptions = "";
if (roomWeapons != null)
{
foreach (var weapon in roomWeapons)
{
if (weapon?.AttributeRequirementToSee != null && !InventoryHandler.PlayerMeetsRequirementForItem(player, false, weaponItem: weapon))
{
weaponDescriptions += $"{ConsoleStrings.LackingRequirementItemDescription} (<{weapon.AttributeRequirementToSee.RequirementName}> needed) \n\n";
}
else if (weapon.InOriginalLocation)
{
weaponDescriptions += weapon.OriginalPlacementDescription + "\n\n";
}
else
{
weaponDescriptions += weapon.GenericPlacementDescription + "\n\n";
}
}
}
return(weaponDescriptions);
}
private static bool CanPlayerEnterRoom(Character.Models.Character player, Models.Room foundRoom, ItemRequirement itemReq = null, AttributeRequirement attrReq = null)
{
if (itemReq != null)
{
foreach (var item in player.CarriedItems)
{
if (item.ItemName == itemReq.RelevantItem.ItemName)
{
return(true);
}
}
Console.WriteLine($"You need: <{itemReq.RequirementName}> to enter {foundRoom.RoomName}. \n", Color.DarkGoldenrod);
}
if (attrReq != null)
{
if (PlayerAttributeComparer.ComparePlayerTraitsToAttributeRequirement(player, attrReq))
{
return(true);
}
Console.WriteLine($"You need: <{attrReq.RequirementName}> to enter {foundRoom.RoomName}. \n", Color.DarkGoldenrod);
}
return(false);
}
// This is the logic for prompting the user for input continuously
// until the user enters keywords to get to another room.
// (Calls into a separate method to act on the input)
public static Models.Room EnterRoom(Character.Models.Character player, Models.Room room)
{
Models.Room nextRoom = null;
// Implement this while loop such that:
// 1. It runs forever until the user enters a room keyword (one from a room connected to current room - RoomKeywords.cs)
// 2. Prints the current room description to the console every time the loop runs
// 3. Ask for user input, and calls PlayerActionHandler.HandlePlayerInput to handle the input
// - Note that the PlayerActionHandler returns null, unless the input matches a room keyword (then it returns the next room)
// 4. If the PlayerActionHandler returns null, the loop iterates again. Otherwise, returns the next room
while (nextRoom == null)
{
// Print out the current Room's Room.InitialRoomDescription to the console if Room.RoomEntered is false,
// Otherwise print Room.GenericRoomDescription to the console
// E.C.: Use TypingAnimation.Animate to print to console
// Now write to the console the ConsoleStrings.PlayerInputPrompt to ask the user for input
// Call ReadLine to get the input from the user; store this in a variable
//Set nextRoom to the return value of PlayerActionHandler.HandlePlayerInput (otherwise we loop forever!)
}
return(nextRoom);
}
public static void DropItemInRoom(Character.Models.Character player, Room.Models.Room room,
InventoryItem itemBeingDropped)
{
AttributeHandler.UpdatePlayerAttributesFromInventoryItem(player, itemBeingDropped, true);
player.Attributes.CarriedItemsCount -= itemBeingDropped.InventorySpaceConsumed;
room.RoomItems.InventoryItems.Add(itemBeingDropped);
player.CarriedItems.Remove(itemBeingDropped);
}
public static void DropItemInRoom(Character.Models.Character player, Room.Models.Room room,
InventoryItem itemToDrop)
{
player.Attributes.CarriedItemsCount -= 1;
room.RoomItems.InventoryItems.Add(itemToDrop);
AttributeHandler.UpdatePlayerAttributesFromInventoryItem(player, itemToDrop, true);
player.CarriedItems.Remove(itemToDrop);
}
public static bool PickupOrDropItemIsOk(Character.Models.Character player, Items foundItem, bool pickingUpItem = true)
{
if (foundItem?.WeaponItems != null)
{
return(true);
}
if (foundItem?.InventoryItems == null)
{
return(false);
}
if (pickingUpItem &&
player.Attributes.CarriedItemsCount + foundItem.InventoryItems.First().InventorySpaceConsumed >
player.Attributes.MaximumCarryingCapacity)
{
return(false);
}
if (foundItem.InventoryItems?.First()?.ItemTraits == null &&
player.Attributes.CarriedItemsCount + foundItem.InventoryItems.First().InventorySpaceConsumed <=
player.Attributes.MaximumCarryingCapacity)
{
return(true);
}
foreach (var itemTrait in foundItem.InventoryItems.First().ItemTraits)
{
if (pickingUpItem)
{
if (itemTrait.RelevantCharacterAttribute != AttributeStrings.MaxCarryingCapacity &&
player.Attributes.CarriedItemsCount + foundItem.InventoryItems.First().InventorySpaceConsumed > player.Attributes.MaximumCarryingCapacity)
{
return(false);
}
if (itemTrait.RelevantCharacterAttribute == AttributeStrings.MaxCarryingCapacity &&
player.Attributes.MaximumCarryingCapacity + itemTrait.TraitValue < player.Attributes.CarriedItemsCount)
{
return(false);
}
return(itemTrait.RelevantCharacterAttribute != AttributeStrings.CarriedItemsCount ||
player.Attributes.CarriedItemsCount + itemTrait.TraitValue <= player.Attributes.MaximumCarryingCapacity);
}
if (itemTrait.RelevantCharacterAttribute != AttributeStrings.MaxCarryingCapacity)
{
return(true);
}
if (player.Attributes.MaximumCarryingCapacity - itemTrait.TraitValue <
player.Attributes.CarriedItemsCount)
{
return(false);
}
}
return(true);
}
public static bool GiveItemIsOk(Character.Models.Character player, Character.Models.Character character, Items foundItem)
{
if (foundItem.InventoryItems.Any())
{
return(character.DesiredItem != null &&
character.DesiredItem.ItemName == foundItem.InventoryItems.First().ItemName);
}
return(false);
}
public static void DropWeaponAndPickupNew(Character.Models.Character player, Room.Models.Room room,
WeaponItem weaponToAddToPlayer)
{
room.RoomItems.WeaponItems.Add(player.WeaponItem);
AttributeHandler.UpdatePlayerAttributesFromWeaponItem(player, player.WeaponItem, true);
AttributeHandler.UpdatePlayerAttributesFromWeaponItem(player, weaponToAddToPlayer);
weaponToAddToPlayer.InOriginalLocation = false;
player.WeaponItem = weaponToAddToPlayer;
room.RoomItems.WeaponItems.Remove(weaponToAddToPlayer);
}
// Used when user types 'status' or similar command
public static string CreateStringOfPlayerInfo(Character.Models.Character player)
{
return(player.Name + "'s Status: \n" +
"\t - Health points: \t" + player.HealthPoints + "/" + player.MaximumHealthPoints + "\n" +
"\t - Inventory Space: \t" + player.Attributes.CarriedItemsCount + "/" + player.Attributes.MaximumCarryingCapacity + "\n" +
"\t - Defense: \t\t" + player.Attributes.Defense + "\n" +
"\t - Dexterity: \t\t" + player.Attributes.Dexterity + "\n" +
"\t - Luck: \t\t" + player.Attributes.Luck + "\n" +
"\t - Stamina: \t\t" + player.Attributes.Stamina + "\n" +
"\t - Strength: \t\t" + player.Attributes.Strength + "\n" +
"\t - Wisdom: \t\t" + player.Attributes.Wisdom + "\n");
}
// This is the main game loop, and only stops when the player enters a 'null' room
private static void TheAdventure(Character.Models.Character player, Room.Models.Room room)
{
var currentRoom = room;
while (true)
{
currentRoom = RoomHandler.EnterRoom(player, currentRoom);
if (currentRoom == null)
{
break;
}
}
}
// Used when user types 'inventory' or similar command
public static string CreateStringOfPlayerInventory(Character.Models.Character player, bool displayDescription)
{
var weaponName = player.WeaponItem?.WeaponName;
var inventoryItems = player.CarriedItems;
var inventory = player.Name + "'s Inventory (" + player.Attributes.CarriedItemsCount + "/" + player.Attributes.MaximumCarryingCapacity + "): \n";
if (!string.IsNullOrEmpty(weaponName))
{
inventory += "\n\tHeld Weapon: " + player.WeaponItem.WeaponName + "\n";
if (displayDescription)
{
inventory += "\t\t" + player.WeaponItem.WeaponDescription + "\n" +
"\t\tAttack Power: \t" + player.WeaponItem.AttackPower + "\n";
if (player.WeaponItem?.WeaponTraits != null)
{
foreach (var trait in player.WeaponItem.WeaponTraits)
{
inventory += "\t\tTrait: \t" + trait.TraitName + "\n";
}
}
}
}
if (player.CarriedItems.Count != 0)
{
foreach (var item in inventoryItems)
{
inventory += "\n\t - " + item.ItemName + "\n";
if (displayDescription)
{
inventory += "\t\t" + item.ItemDescription + "\n";
}
if (item.ItemTraits != null)
{
foreach (var trait in item.ItemTraits)
{
inventory += "\t\tTrait: \t" + trait.TraitName + "\n";
}
}
}
}
if (string.IsNullOrEmpty(player.WeaponItem?.WeaponName) && player.Attributes.CarriedItemsCount == 0)
{
inventory += "\n\t<empty> \n";
}
return(inventory);
}
public static bool HandlePlayerTradingItem(string fullInput, Character.Models.Character player, Room.Models.Room currentRoom,
string inputWord, bool inputResolved)
{
if (currentRoom.RoomCharacters.Any())
{
var substring = PlayerActionHandler.CreateSubstringOfActionInput(fullInput, inputWord);
var character =
RoomHandler.FindAnyMatchingCharacterByKeywords(substring.Trim(), currentRoom);
var inventoryKeywords = GetAllInventoryItemKeywords(player);
var foundItem = FindAnyMatchingItemsByKeywords(substring.Trim(), inventoryKeywords,
player.CarriedItems, new List <WeaponItem> {
player.WeaponItem
});
if (foundItem != null && character != null)
{
if (GiveItemIsOk(player, character, foundItem))
{
var tradedItem = HandleItemTrade(player, character, foundItem, currentRoom);
if (!string.IsNullOrEmpty(tradedItem.ItemName))
{
TypingAnimation.Animate("\nYou give the " + foundItem.InventoryItems.First().ItemName + " to " +
character.Name + ".\n" + character.Name + " gives you the " + tradedItem.ItemName + ".\n", Color.Gold);
}
else
{
TypingAnimation.Animate("Your inventory is full... You cannot take the " +
tradedItem.ItemName + ".\n", Color.DarkOliveGreen);
}
inputResolved = true;
}
else
{
Colorful.Console.WriteLine();
TypingAnimation.Animate(character.Name + " doesn't want that item.\n", Color.DarkOliveGreen);
inputResolved = true;
}
}
}
else
{
Colorful.Console.WriteLine("\nThere is no one here to give that to...", Color.DarkOliveGreen);
inputResolved = true;
}
return(inputResolved);
}
public static List <string> GetAllInventoryItemKeywords(Character.Models.Character player)
{
var keywords = new List <string>();
if (player?.CarriedItems != null)
{
foreach (var item in player.CarriedItems)
{
keywords.AddRange(item.KeywordsForPickup.Where(k => !string.IsNullOrEmpty(k)));
}
}
if (!string.IsNullOrEmpty(player?.WeaponItem?.WeaponName))
{
keywords.AddRange(player.WeaponItem.KeywordsForPickup.Where(k => !string.IsNullOrEmpty(k)));
}
return(keywords);
}
// This is the main game loop, and only stops when the player goes into a 'null' room (or saves)
public static void TheAdventure(Character.Models.Character player, Room.Models.Room room, bool firstRoomEntered)
{
var firstRoom = firstRoomEntered;
var currentRoom = room;
while (true)
{
currentRoom = RoomHandler.EnterRoom(player, currentRoom, firstRoom);
firstRoom = false;
if (currentRoom == null)
{
break;
}
if (currentRoom.RoomName == ConsoleStrings.SaveGame)
{
SaveGame();
break;
}
}
}
public static bool CanPickupItemWithAttributeRequirement(Character.Models.Character player, InventoryItem inventoryItem = null, WeaponItem weaponItem = null)
{
if (weaponItem != null)
{
Console.WriteLine();
if (PlayerMeetsRequirementForItem(player, weaponItem: weaponItem))
{
TypingAnimation.Animate($"<{weaponItem.AttributeRequirementToTake.RequirementName}>!", Color.Gold);
weaponItem.AttributeRequirementToSee = null;
weaponItem.AttributeRequirementToTake = null;
return(true);
}
TypingAnimation.Animate($"You need: <{weaponItem.AttributeRequirementToTake.RequirementName}> to take the {weaponItem.WeaponName}. \n",
Color.DarkGoldenrod);
return(false);
}
if (inventoryItem != null)
{
Console.WriteLine();
if (PlayerMeetsRequirementForItem(player, inventoryItem: inventoryItem))
{
TypingAnimation.Animate($"<{inventoryItem.AttributeRequirementToTake.RequirementName}>!",
Color.Gold);
inventoryItem.AttributeRequirementToSee = null;
inventoryItem.AttributeRequirementToTake = null;
return(true);
}
TypingAnimation.Animate($"You need: <{inventoryItem.AttributeRequirementToTake.RequirementName}> to take the {inventoryItem.ItemName}. \n",
Color.DarkGoldenrod);
return(false);
}
return(false);
}
public static bool PlayerMeetsRequirementForItem(Character.Models.Character player, bool takeItem = true, InventoryItem inventoryItem = null, WeaponItem weaponItem = null)
{
if (inventoryItem != null)
{
if (takeItem)
{
return(PlayerAttributeComparer.ComparePlayerTraitsToAttributeRequirement(player, inventoryItem.AttributeRequirementToTake));
}
return(PlayerAttributeComparer.ComparePlayerTraitsToAttributeRequirement(player, inventoryItem.AttributeRequirementToSee));
}
if (weaponItem != null)
{
if (takeItem)
{
return(PlayerAttributeComparer.ComparePlayerTraitsToAttributeRequirement(player, weaponItem.AttributeRequirementToTake));
}
return(PlayerAttributeComparer.ComparePlayerTraitsToAttributeRequirement(player, weaponItem.AttributeRequirementToSee));
}
return(false);
}
// This is the logic for prompting the user for input continuously
// until the user enters keywords to get to another room.
// (Calls into a separate method to act on the input)
public static Models.Room EnterRoom(Character.Models.Character player, Models.Room room, bool firstRoomEntered = false)
{
var redisplayRoomDesc = false;
Models.Room nextRoom = null;
Program.CharacterCreator.Player.CurrentRoomName = room.RoomName;
while (nextRoom == null)
{
Console.Clear();
Console.ReplaceAllColorsWithDefaults();
// Print out the current Room description to the console (animate the first time)
if (redisplayRoomDesc)
{
Console.WriteLine(room.RoomEntered ? room.GenericRoomDescription : room.InitialRoomDescription,
Color.Bisque);
if (room.RoomCharacters.Any())
{
foreach (var character in room.RoomCharacters)
{
Console.WriteLine();
Console.WriteLine(character.OnMeetDescription + "\n", Color.Gold);
}
}
if (player.PersistDisplayedItems)
{
PlayerActionHandler.PrintItemsToConsole(player, room);
}
else if (player.PersistDisplayedWeapons)
{
PlayerActionHandler.PrintWeaponsToConsole(player, room);
}
else if (player.PersistDisplayedExits)
{
PlayerActionHandler.PrintExitsToConsole(player, room);
}
else
{
Console.WriteLine();
}
}
else
{
TypingAnimation.Animate(room.RoomEntered ? room.GenericRoomDescription : room.InitialRoomDescription,
Color.Bisque);
Console.WriteLine();
if (room.RoomCharacters.Any())
{
foreach (var character in room.RoomCharacters)
{
TypingAnimation.Animate(character.OnMeetDescription + "\n", Color.Gold);
}
}
}
Thread.Sleep(50);
if (firstRoomEntered)
{
Console.Write("TUTORIAL: ", Color.MediumPurple);
if (player.CarriedItems.Count == 0 || string.IsNullOrEmpty(player.WeaponItem.WeaponName))
{
Console.WriteLine("Collect the item and weapon in this room\n", Color.Aquamarine);
Console.WriteLineStyled(ConsoleStrings.ItemsHints, ConsoleStringStyleSheets.GameHelpStyleSheet(Color.AliceBlue));
Console.WriteLineStyled(ConsoleStrings.InfoHints, ConsoleStringStyleSheets.GameHelpStyleSheet(Color.AliceBlue));
}
else
{
Console.WriteLine("Exit this room\n", Color.Red);
Console.WriteLineStyled(ConsoleStrings.RoomHints, ConsoleStringStyleSheets.GameHelpStyleSheet(Color.AliceBlue));
}
Console.WriteLine(ConsoleStrings.FirstRoomHelpHint, Color.MediumPurple);
}
if (player.ShowInputHelp && !firstRoomEntered)
{
Console.WriteLineStyled(ConsoleStrings.InputHelper, RoomStyleSheets.InputHelperStyleSheet());
}
Console.WriteWithGradient(ConsoleStrings.PlayerInputPrompt, Color.SpringGreen, Color.NavajoWhite, 4);
Console.WriteLine();
Console.Write("> ");
var playerInput = Console.ReadLine();
nextRoom = PlayerActionHandler.HandlePlayerInput(playerInput.ToLower(), player, room);
redisplayRoomDesc = true;
}
return(nextRoom);
}
public static bool DoesPlayerMeetRequirementsToEnter(Character.Models.Character player, Models.Room currentRoom, Models.Room foundRoom)
{
Console.WriteLine();
var meetsRequirements = foundRoom?.AttributeRequirementToEnter == null && foundRoom?.ItemRequirementToEnter == null;
if (!meetsRequirements)
{
if (foundRoom?.AttributeRequirementToEnter != null && foundRoom?.ItemRequirementToEnter == null &&
CanPlayerEnterRoom(player, foundRoom, attrReq: foundRoom.AttributeRequirementToEnter))
{
Console.WriteLine($"<{foundRoom.AttributeRequirementToEnter.RequirementName}>! \n", Color.Gold);
meetsRequirements = true;
}
else if (foundRoom?.ItemRequirementToEnter != null && foundRoom?.AttributeRequirementToEnter == null &&
CanPlayerEnterRoom(player, foundRoom, foundRoom.ItemRequirementToEnter))
{
if (foundRoom.ItemRequirementToEnter.RelevantItem.ItemName == Program.ItemCreator.Flashlight.ItemName && Program.ItemCreator.Flashlight.ItemTraits.First().TraitValue == 0)
{
Console.WriteLine($"It's too dark. Your flashlight battery is dead... \nPut in a new battery to enter {foundRoom.RoomName}.\n", Color.DarkGoldenrod);
return(false);
}
Console.WriteLine($"Carrying: <{foundRoom.ItemRequirementToEnter.RequirementName}>! \n", Color.Gold);
meetsRequirements = true;
}
else
{
if (CanPlayerEnterRoom(player, foundRoom, attrReq: foundRoom.AttributeRequirementToEnter) &&
CanPlayerEnterRoom(player, foundRoom, itemReq: foundRoom.ItemRequirementToEnter))
{
if (foundRoom.ItemRequirementToEnter.RelevantItem.ItemName == Program.ItemCreator.Flashlight.ItemName)
{
foreach (var item in Program.CharacterCreator.Player.CarriedItems)
{
if (item.ItemName == Program.ItemCreator.Flashlight.ItemName &&
item.ItemTraits.First().TraitValue == 0)
{
Console.WriteLine($"It's too dark. Your flashlight battery is dead... \nPut in a new battery to enter {foundRoom.RoomName}.\n", Color.DarkGoldenrod);
return(false);
}
}
}
Console.WriteLine($"<{foundRoom.AttributeRequirementToEnter.RequirementName}>! \n", Color.Gold);
Console.WriteLine($"Carrying: <{foundRoom.ItemRequirementToEnter.RequirementName}>! \n", Color.Gold);
meetsRequirements = true;
}
}
}
if (meetsRequirements)
{
TypingAnimation.Animate("You go to " + foundRoom.RoomName + "... \n", Color.Chartreuse, 40);
if (foundRoom.ItemRequirementToEnter?.RelevantItem.ItemName == Program.ItemCreator.Flashlight.ItemName)
{
var consoleInfo = "Used Flashlight: battery dropped by 2% \n";
var light = player.CarriedItems.Single(i => i.ItemName == Program.ItemCreator.Flashlight.ItemName);
var batteryBefore = light.ItemTraits.First().TraitValue;
var hasBattery = FlashlightBatteryUpdate.FlashlightBatteryChange(light, batteryBefore, 2);
if (!hasBattery)
{
consoleInfo = "Used Flashlight: now the battery is dead! \n";
}
TypingAnimation.Animate(consoleInfo, Color.Chartreuse, 40);
}
Console.WriteWithGradient(ConsoleStrings.PressEnterPrompt, Color.Yellow, Color.DarkRed, 4);
Console.ReadLine();
if (!currentRoom.RoomEntered)
{
currentRoom.RoomEntered = true;
}
foundRoom.AttributeRequirementToEnter = null;
foundRoom.AttributeRequirementToSee = null;
foundRoom.ItemRequirementToEnter = null;
foundRoom.ItemRequirementToSee = null;
}
return(meetsRequirements);
}
// Used when user types 'exits' or similar command
public static string CreateStringOfExitDescriptions(Character.Models.Character player, RoomExit roomExits)
{
var allRoomExits = "";
if (roomExits?.NorthRoom != null)
{
if (roomExits.NorthRoom?.AttributeRequirementToSee != null &&
!PlayerAttributeComparer.ComparePlayerTraitsToAttributeRequirement(player, roomExits.NorthRoom.AttributeRequirementToSee))
{
allRoomExits += $"{ConsoleStrings.LackingRequirementRoomDescription} (<{roomExits.NorthRoom.AttributeRequirementToSee.RequirementName}> needed) \n\n";
}
else if (roomExits.NorthRoom?.ItemRequirementToSee != null)
{
var hasItem = false;
foreach (var item in player.CarriedItems)
{
if (item.ItemName == roomExits.NorthRoom.ItemRequirementToSee.RelevantItem.ItemName)
{
hasItem = true;
}
}
if (hasItem)
{
allRoomExits += roomExits.NorthRoomDescription + "\n\n";
}
else
{
allRoomExits += $"{ConsoleStrings.LackingRequirementRoomDescription} (<{roomExits.NorthRoom.ItemRequirementToSee.RequirementName}> needed) \n\n";
}
}
else
{
if (roomExits.NorthRoom.RoomEntered)
{
allRoomExits += roomExits.NorthRoomDescription + " \t(entered)\n\n";
}
else
{
allRoomExits += roomExits.NorthRoomDescription + "\n\n";
}
}
}
if (roomExits?.EastRoom != null)
{
if (roomExits.EastRoom?.AttributeRequirementToSee != null &&
!PlayerAttributeComparer.ComparePlayerTraitsToAttributeRequirement(player, roomExits.EastRoom.AttributeRequirementToSee))
{
allRoomExits += $"{ConsoleStrings.LackingRequirementRoomDescription} (<{roomExits.EastRoom.AttributeRequirementToSee.RequirementName}> needed) \n\n";
}
else if (roomExits.EastRoom?.ItemRequirementToSee != null)
{
var hasItem = false;
foreach (var item in player.CarriedItems)
{
if (item.ItemName == roomExits.EastRoom.ItemRequirementToSee.RelevantItem.ItemName)
{
hasItem = true;
}
}
if (hasItem)
{
allRoomExits += roomExits.EastRoomDescription + "\n\n";
}
else
{
allRoomExits += $"{ConsoleStrings.LackingRequirementRoomDescription} (<{roomExits.EastRoom.ItemRequirementToSee.RequirementName}> needed) \n\n";
}
}
else
{
if (roomExits.EastRoom.RoomEntered)
{
allRoomExits += roomExits.EastRoomDescription + " \t(entered)\n\n";
}
else
{
allRoomExits += roomExits.EastRoomDescription + "\n\n";
}
}
}
if (roomExits?.SouthRoom != null)
{
if (roomExits.SouthRoom?.AttributeRequirementToSee != null &&
!PlayerAttributeComparer.ComparePlayerTraitsToAttributeRequirement(player, roomExits.SouthRoom.AttributeRequirementToSee))
{
allRoomExits += $"{ConsoleStrings.LackingRequirementRoomDescription} (<{roomExits.SouthRoom.AttributeRequirementToSee.RequirementName}> needed) \n\n";
}
else if (roomExits.SouthRoom?.ItemRequirementToSee != null)
{
var hasItem = false;
foreach (var item in player.CarriedItems)
{
if (item.ItemName == roomExits.SouthRoom.ItemRequirementToSee.RelevantItem.ItemName)
{
hasItem = true;
}
}
if (hasItem)
{
allRoomExits += roomExits.SouthRoomDescription + "\n\n";
}
else
{
allRoomExits += $"{ConsoleStrings.LackingRequirementRoomDescription} (<{roomExits.SouthRoom.ItemRequirementToSee.RequirementName}> needed) \n\n";
}
}
else
{
if (roomExits.SouthRoom.RoomEntered)
{
allRoomExits += roomExits.SouthRoomDescription + " \t(entered)\n\n";
}
else
{
allRoomExits += roomExits.SouthRoomDescription + "\n\n";
}
}
}
if (roomExits?.WestRoom != null)
{
if (roomExits.WestRoom?.AttributeRequirementToSee != null &&
!PlayerAttributeComparer.ComparePlayerTraitsToAttributeRequirement(player, roomExits.WestRoom.AttributeRequirementToSee))
{
allRoomExits += $"{ConsoleStrings.LackingRequirementRoomDescription} (<{roomExits.WestRoom.AttributeRequirementToSee.RequirementName}> needed) \n\n";
}
else if (roomExits.WestRoom?.ItemRequirementToSee != null)
{
var hasItem = false;
foreach (var item in player.CarriedItems)
{
if (item.ItemName == roomExits.WestRoom.ItemRequirementToSee.RelevantItem.ItemName)
{
hasItem = true;
}
}
if (hasItem)
{
allRoomExits += roomExits.WestRoomDescription + "\n\n";
}
else
{
allRoomExits += $"{ConsoleStrings.LackingRequirementRoomDescription} (<{roomExits.WestRoom.ItemRequirementToSee.RequirementName}> needed) \n\n";
}
}
else
{
if (roomExits.WestRoom.RoomEntered)
{
allRoomExits += roomExits.WestRoomDescription + " \t(entered)\n\n";
}
else
{
allRoomExits += roomExits.WestRoomDescription + "\n\n";
}
}
}
return(allRoomExits);
}
public static void BeginAdventure(Character.Models.Character player, Room.Models.Room room)
{
DisplayGameIntro();
TheAdventure(player, room);
}
// Used when user types 'inventory' or similar command
public static string CreateStringOfPlayerInventory(Character.Models.Character player, bool displayDescription)
{
var weaponName = player.WeaponItem?.WeaponName;
var inventoryItems = player.CarriedItems;
var inventory = player.Name + "'s Inventory (" + player.Attributes.CarriedItemsCount + "/" + player.Attributes.MaximumCarryingCapacity + "): \n";
if (!string.IsNullOrEmpty(weaponName))
{
inventory += "\n\tHeld Weapon: " + player.WeaponItem.WeaponName + "\n";
if (displayDescription)
{
inventory += "\t\t" + player.WeaponItem.WeaponDescription + "\n" +
"\t\tAttack Power: \t" + player.WeaponItem.AttackPower + "\n";
if (player.WeaponItem?.AmmunitionAmount >= 0)
{
inventory += "\t\tAmmo: \t" + player.WeaponItem.AmmunitionAmount + "\n";
}
if (player.WeaponItem?.WeaponTraits != null)
{
foreach (var trait in player.WeaponItem.WeaponTraits)
{
inventory += "\t\tTrait: \t" + trait.TraitName + "\n";
}
}
}
}
if (player.CarriedItems.Count != 0)
{
inventory += "\n\tWorn Items (these do not consume space): \n";
var carriedItems = "\n\tCarried Items: \n";
foreach (var item in inventoryItems)
{
if (item.TreatItemAs == ItemUseTypes.Bag || item.TreatItemAs == ItemUseTypes.Wearable)
{
inventory += "\n\t\t-" + item.ItemName + "\n";
if (displayDescription)
{
inventory += "\t\t\t" + item.ItemDescription + "\n";
}
if (item.ItemTraits != null)
{
foreach (var trait in item.ItemTraits)
{
if (trait.TraitName != "")
{
inventory += "\t\t\tTrait: \t" + trait.TraitName + "\n";
}
}
}
}
else
{
carriedItems += "\n\t\t-" + item.ItemName + "\n";
if (displayDescription)
{
carriedItems += "\t\t\t" + item.ItemDescription + "\n";
}
if (item.ItemTraits != null)
{
foreach (var trait in item.ItemTraits)
{
if (trait.TraitName != "")
{
carriedItems += "\t\t\tTrait: \t" + trait.TraitName + "\n";
}
}
}
}
}
inventory += carriedItems;
}
if (string.IsNullOrEmpty(player.WeaponItem?.WeaponName) && player.CarriedItems.Count == 0)
{
inventory += "\n\t<empty> \n";
}
return(inventory);
}
// This updates the room and/or player when the exchange of an item occurs
public static void HandleItemAddOrRemove(Character.Models.Character player, Room.Models.Room currentRoom,
Items foundItem, bool removeItemFromRoom = false)
{
switch (removeItemFromRoom)
{
// We are removing an item from a room, adding it to player inventory
case true:
if (foundItem?.InventoryItems?.First() != null)
{
var meetsAnyRequirement = false;
var needsToDropSameTypeItemFirst = false;
InventoryItem carriedItemOfSameType = null;
var inventoryItemToAddToPlayer = foundItem.InventoryItems.First();
if (inventoryItemToAddToPlayer?.AttributeRequirementToTake == null)
{
meetsAnyRequirement = true;
}
else if (inventoryItemToAddToPlayer?.AttributeRequirementToTake != null &&
CanPickupItemWithAttributeRequirement(player, inventoryItemToAddToPlayer))
{
meetsAnyRequirement = true;
}
if (inventoryItemToAddToPlayer.TreatItemAs == ItemUseTypes.Bag ||
inventoryItemToAddToPlayer.TreatItemAs == ItemUseTypes.Wearable)
{
foreach (var item in player.CarriedItems)
{
if (item.TreatItemAs == ItemUseTypes.Bag && inventoryItemToAddToPlayer.TreatItemAs == ItemUseTypes.Bag ||
item.WearableType != "" && item.WearableType == inventoryItemToAddToPlayer.WearableType)
{
carriedItemOfSameType = item;
needsToDropSameTypeItemFirst = true;
break;
}
}
}
if (PickupOrDropItemIsOk(player, foundItem) && meetsAnyRequirement)
{
Console.WriteLine();
if (needsToDropSameTypeItemFirst)
{
TypingAnimation.Animate("You need to drop your " + carriedItemOfSameType.ItemName + " before you can take the " + inventoryItemToAddToPlayer?.ItemName + ".\n",
Color.ForestGreen);
}
else
{
AttributeHandler.UpdatePlayerAttributesFromInventoryItem(player, inventoryItemToAddToPlayer);
inventoryItemToAddToPlayer.InOriginalLocation = false;
player.CarriedItems.Add(inventoryItemToAddToPlayer);
player.Attributes.CarriedItemsCount += inventoryItemToAddToPlayer.InventorySpaceConsumed;
currentRoom.RoomItems.InventoryItems.Remove(inventoryItemToAddToPlayer);
TypingAnimation.Animate("You take the " + inventoryItemToAddToPlayer.ItemName + ".\n", Color.ForestGreen);
}
}
else
{
if (meetsAnyRequirement)
{
Console.WriteLine();
TypingAnimation.Animate("Your inventory is full! \n" +
"Drop or use an item to pick up the " + inventoryItemToAddToPlayer?.ItemName + ".\n", Color.DarkOliveGreen);
}
}
}
else
if (foundItem?.WeaponItems != null)
{
var weaponItemToAddToPlayer = foundItem.WeaponItems.First();
if (string.IsNullOrEmpty(player.WeaponItem.WeaponName))
{
AttributeHandler.UpdatePlayerAttributesFromWeaponItem(player, weaponItemToAddToPlayer);
weaponItemToAddToPlayer.InOriginalLocation = false;
player.WeaponItem = weaponItemToAddToPlayer;
currentRoom.RoomItems.WeaponItems.Remove(weaponItemToAddToPlayer);
Console.WriteLine();
TypingAnimation.Animate("You take the " + weaponItemToAddToPlayer?.WeaponName + ".\n", Color.ForestGreen);
}
else
{
var oldWeapon = player.WeaponItem.WeaponName.Clone();
DropWeaponAndPickupNew(player, currentRoom, weaponItemToAddToPlayer);
player.WeaponItem = weaponItemToAddToPlayer;
currentRoom.RoomItems.WeaponItems.Remove(weaponItemToAddToPlayer);
Console.WriteLine();
TypingAnimation.Animate("You drop your " + oldWeapon + " for the " + weaponItemToAddToPlayer?.WeaponName + ".\n",
Color.ForestGreen);
}
}
break;
// We are adding an item to a room, removing/dropping it from player inventory
case false:
if (foundItem?.InventoryItems != null)
{
var inventoryItemToRemoveFromPlayer = foundItem.InventoryItems.First();
DropItemInRoom(player, currentRoom, inventoryItemToRemoveFromPlayer);
Console.WriteLine();
TypingAnimation.Animate("You drop the " + inventoryItemToRemoveFromPlayer?.ItemName + ".\n", Color.ForestGreen);
}
else if (foundItem?.WeaponItems != null)
{
var weaponItemToRemoveFromPlayer = foundItem.WeaponItems.First();
DropWeaponInRoom(player, currentRoom);
Console.WriteLine();
TypingAnimation.Animate("You drop the " + weaponItemToRemoveFromPlayer?.WeaponName + ".\n", Color.ForestGreen);
}
break;
}
}
public static void DropWeaponInRoom(Character.Models.Character player, Room.Models.Room room)
{
room.RoomItems.WeaponItems.Add(player.WeaponItem);
AttributeHandler.UpdatePlayerAttributesFromWeaponItem(player, player.WeaponItem, true);
player.WeaponItem = new WeaponItem();
}
public static bool HandleItemBeingUsed(Character.Models.Character player, Items foundItem, string playerInput)
{
if (foundItem?.WeaponItems?.First() != null)
{
Console.WriteLine();
TypingAnimation.Animate($"You swing your {foundItem.WeaponItems.First().WeaponName} around wildly.\n", Color.ForestGreen);
return(true);
}
if (foundItem?.InventoryItems?.First() != null)
{
var item = foundItem.InventoryItems.First();
if (item.TreatItemAs == ItemUseTypes.Default || item.TreatItemAs == ItemUseTypes.Key)
{
Console.WriteLine();
TypingAnimation.Animate($"You {playerInput} the {item.ItemName} but nothing happens...\n",
Color.ForestGreen);
return(true);
}
if (item.TreatItemAs == ItemUseTypes.Wearable)
{
Console.WriteLine();
TypingAnimation.Animate($"You're already wearing the {item.ItemName}...\n", Color.ForestGreen);
return(true);
}
if (item.TreatItemAs == ItemUseTypes.Document)
{
var traitsAdded = "";
foreach (var trait in item.ItemTraits)
{
if (!string.IsNullOrEmpty(trait.RelevantCharacterAttribute))
{
if (trait.TraitValue > 0)
{
traitsAdded += $"\n\t{trait.RelevantCharacterAttribute} + ({trait.TraitValue})!";
AttributeHandler.AddCharacterAttributesByTrait(player, trait);
trait.TraitName = "";
trait.TraitValue = 0;
}
}
}
Console.WriteLine();
TypingAnimation.Animate($"You read the {item.ItemName}: {traitsAdded}\n \n\n{item.DocumentText}\n",
Color.GhostWhite);
return(true);
}
if (item.TreatItemAs == ItemUseTypes.ConsumableAttribute)
{
var traitsAdded = "";
foreach (var trait in item.ItemTraits)
{
if (!string.IsNullOrEmpty(trait.RelevantCharacterAttribute))
{
traitsAdded += $"\n\t{trait.RelevantCharacterAttribute} + ({trait.TraitValue})!";
AttributeHandler.AddCharacterAttributesByTrait(player, trait);
}
}
player.Attributes.CarriedItemsCount -= item.InventorySpaceConsumed;
player.CarriedItems.Remove(item);
Console.WriteLine();
TypingAnimation.Animate($"You use the {item.ItemName}: \n{traitsAdded}\n", Color.ForestGreen);
return(true);
}
if (item.TreatItemAs == ItemUseTypes.ConsumableBattery)
{
var flashlight = player.CarriedItems.SingleOrDefault(i =>
i.ItemName == Program.ItemCreator.Flashlight.ItemName);
var traitsAdded = "";
foreach (var trait in item.ItemTraits)
{
if (!string.IsNullOrEmpty(flashlight?.ItemName))
{
traitsAdded += $"\n\tFlashlight battery: ({trait.TraitValue}%)!";
FlashlightBatteryUpdate.FlashlightBatteryChange(flashlight,
percentToSet: trait.TraitValue);
}
}
if (!string.IsNullOrEmpty(flashlight?.ItemName))
{
player.Attributes.CarriedItemsCount -= item.InventorySpaceConsumed;
player.CarriedItems.Remove(item);
Console.WriteLine();
TypingAnimation.Animate($"You use the {item.ItemName}: \n{traitsAdded}\n", Color.ForestGreen);
return(true);
}
Console.WriteLine();
TypingAnimation.Animate($"You don't have anything to use the {item.ItemName} on...\n",
Color.DarkOliveGreen);
return(true);
}
if (item.TreatItemAs == ItemUseTypes.ConsumableHealth)
{
var traitsAdded = "";
if (player.HealthPoints < player.MaximumHealthPoints)
{
foreach (var trait in item.ItemTraits)
{
if (string.IsNullOrEmpty(trait.RelevantCharacterAttribute))
{
if (player.HealthPoints + trait.TraitValue > player.MaximumHealthPoints)
{
player.HealthPoints = player.MaximumHealthPoints;
}
else
{
player.HealthPoints += trait.TraitValue;
}
traitsAdded += $"\n\tHealth Points: + ({trait.TraitValue})!";
}
else
{
traitsAdded += trait.TraitValue >= 0 ? $"\n\t{trait.RelevantCharacterAttribute} + ({trait.TraitValue})!" : $"\n\t{trait.RelevantCharacterAttribute} - ({-1 * trait.TraitValue})";
AttributeHandler.AddCharacterAttributesByTrait(player, trait);
}
}
}
if (!string.IsNullOrEmpty(traitsAdded))
{
player.Attributes.CarriedItemsCount -= item.InventorySpaceConsumed;
player.CarriedItems.Remove(item);
Console.WriteLine();
TypingAnimation.Animate($"You consume the {item.ItemName}: \n{traitsAdded}\n",
Color.ForestGreen);
return(true);
}
Console.WriteLine();
TypingAnimation.Animate(
$"You don't need to use the {item.ItemName}, you have full Health Points...\n",
Color.DarkOliveGreen);
return(true);
}
if (item.TreatItemAs == ItemUseTypes.ConsumableAmmo)
{
var traitsAdded = "";
if (!string.IsNullOrEmpty(player.WeaponItem?.WeaponName) &&
!string.IsNullOrEmpty(player.WeaponItem?.AmmunitionType) &&
player.WeaponItem.AmmunitionType == item.AmmunitionType)
{
player.WeaponItem.AmmunitionAmount += item.AmmunitionAmount;
traitsAdded += $"\n\t{player.WeaponItem.WeaponName} Ammo + ({item.AmmunitionAmount}) = ({player.WeaponItem.AmmunitionAmount})!";
player.Attributes.CarriedItemsCount -= item.InventorySpaceConsumed;
player.CarriedItems.Remove(item);
Console.WriteLine();
TypingAnimation.Animate($"You use the {item.ItemName}: \n{traitsAdded}\n", Color.ForestGreen);
return(true);
}
Console.WriteLine();
TypingAnimation.Animate($"You don't have a weapon that uses {item.AmmunitionType}...\n",
Color.DarkOliveGreen);
return(true);
}
}
return(false);
}
// This updates the room and/or player when the exchange of an item occurs
public static void HandleItemAddOrRemove(Character.Models.Character player, Room.Models.Room currentRoom,
Items foundItem, bool removeItemFromRoom = false)
{
switch (removeItemFromRoom)
{
// We are removing an item from a room, adding it to player inventory
case true:
if (foundItem?.InventoryItems != null)
{
var inventoryItemToAdd = foundItem.InventoryItems.First();
if (player.Attributes.CarriedItemsCount + 1 <= player.Attributes.MaximumCarryingCapacity)
{
AttributeHandler.UpdatePlayerAttributesFromInventoryItem(player, inventoryItemToAdd);
inventoryItemToAdd.InOriginalLocation = false;
player.CarriedItems.Add(inventoryItemToAdd);
player.Attributes.CarriedItemsCount += 1;
currentRoom.RoomItems.InventoryItems.Remove(inventoryItemToAdd);
Console.WriteLine();
TypingAnimation.Animate("You take the " + inventoryItemToAdd.ItemName + ".\n", Color.ForestGreen);
}
else
{
Console.WriteLine();
TypingAnimation.Animate("Your inventory is full! \n" +
"Drop an item to pick up the " + inventoryItemToAdd?.ItemName + ".\n", Color.DarkOliveGreen);
}
}
else if (foundItem?.WeaponItems != null)
{
var weaponItemToAdd = foundItem.WeaponItems.First();
if (string.IsNullOrEmpty(player.WeaponItem.WeaponName))
{
AttributeHandler.UpdatePlayerAttributesFromWeaponItem(player, weaponItemToAdd);
weaponItemToAdd.InOriginalLocation = false;
player.WeaponItem = weaponItemToAdd;
currentRoom.RoomItems.WeaponItems.Remove(weaponItemToAdd);
Console.WriteLine();
TypingAnimation.Animate("You take the " + weaponItemToAdd?.WeaponName + ".\n", Color.ForestGreen);
}
else
{
var oldWeapon = player.WeaponItem.WeaponName.Clone();
DropWeaponAndPickupNew(player, currentRoom, weaponItemToAdd);
AttributeHandler.UpdatePlayerAttributesFromWeaponItem(player, weaponItemToAdd);
player.WeaponItem = weaponItemToAdd;
currentRoom.RoomItems.WeaponItems.Remove(weaponItemToAdd);
Console.WriteLine();
TypingAnimation.Animate("You drop your " + oldWeapon + " for the " + weaponItemToAdd?.WeaponName + ".\n",
Color.ForestGreen);
}
}
break;
// We are adding an item to a room, removing/dropping it from player inventory
case false:
if (foundItem?.InventoryItems != null)
{
var inventoryItemToRemove = foundItem.InventoryItems.First();
DropItemInRoom(player, currentRoom, inventoryItemToRemove);
Console.WriteLine();
TypingAnimation.Animate("You drop the " + inventoryItemToRemove?.ItemName + ".\n", Color.ForestGreen);
}
else if (foundItem?.WeaponItems != null)
{
var weaponItemToRemove = foundItem.WeaponItems.First();
DropWeaponInRoom(player, currentRoom);
Console.WriteLine();
TypingAnimation.Animate("You drop the " + weaponItemToRemove?.WeaponName + ".\n", Color.ForestGreen);
}
break;
}
}
