Driver_Settings_Enums.hpp

Go to the documentation of this file.

#pragma once
#ifndef WORLDSIM_DRIVER_SETTINGS_ENUMS_CPP
#define WORLDSIM_DRIVER_SETTINGS_ENUMS_CPP

/* WorldSim: Driver_Settings_Enums
#include "Driver_Settings_Enums.cpp"

   Lists of values go here. Functions and sets related to the enums also go here.
*/

#include <Container/Vector/Vector.hpp>

#include <unordered_map>


// MAIN MENU ENUMS
enum enumMenu
{
   MENU_UNKNOWN,
   MENU_TITLE,
   MENU_OPTIONS,
   MENU_LOADGAME,
   MENU_WORLDGENERATOR,
   MENU_WORLDSIMULATOR,
   MENU_ADVENTUREMODE
};

// Should be MENU_TITLE but I'm bypassing it for now because the main menu has no function atm.
enumMenu activeMenu = MENU_WORLDGENERATOR;

// DIRECTION ENUMS
enum enumDirection
{
   NORTH,
   EAST,
   SOUTH,
   WEST
};

// RACE ENUM
enum enumRace
{
   NONE=0,
   HUMAN=1,
   DWARVEN=2,
   ELVEN=3
};

// BASE TERRAIN ENUM (I DON'T KNOW IF THIS IS BEING USED)
enum class eLocalTerrain
{
   G=0,
   GRASS=1,
   WATER=2
};

enum enumCauseOfDeath
{
   UNKNOWN=0,
   STARVATION=1,
   MASSACRE=2,
   COMBAT=3,
   OLD_AGE=4,
   SMITED=5
};

const std::string enumCauseOfDeathStr [5] =
{
   "unknown",
   "starvation",
   "massacre",
   "combat",
   "old age"
};

enum enumLocation
{
   LOCATION_UNKNOWN,
   LOCATION_NONE,
   LOCATION_OUTSIDE,
   LOCATION_WALLS,
   LOCATION_HALL,
   LOCATION_MAIN_HALL,
   LOCATION_MINE,
   LOCATION_DWELLING,
   LOCATION_FARM,
   LOCATION_WILDERNESS,
   LOCATION_WEAPONSMITH,
   LOCATION_COUNT
};

const std::string enumLocationStr[LOCATION_COUNT] =
{
   "unknown",
   "none",
   "outside",
   "walls",
   "hall",
   "main hall",
   "mine",
   "dwelling",
   "farm",
   "wilderness"
};

// Function to convert enumLocation to a string
const std::string locationToString(enumLocation location)
{
   switch (location)
   {
      case LOCATION_NONE: return "None";
      case LOCATION_OUTSIDE: return "Outside";
      case LOCATION_WALLS: return "Walls";
      case LOCATION_HALL: return "Hall";
      case LOCATION_MAIN_HALL: return "Main Hall";
      case LOCATION_MINE: return "Mine";
      case LOCATION_DWELLING: return "Dwelling";
      case LOCATION_FARM: return "Farm";
      case LOCATION_WILDERNESS: return "Wilderness";
      case LOCATION_WEAPONSMITH: return "Weaponsmith";
      default: return "Unknown";
   }
}

enum enumResource
{
   RESOURCE_UNKNOWN,
   RESOURCE_IRON,
   RESOURCE_GOLD,
   RESOURCE_SILVER,
   RESOURCE_GEM,
   RESOURCE_DIAMOND,
   RESOURCE_ADAMANTINE,
   RESOURCE_COAL,
   RESOURCE_STONE,
   RESOURCE_WOOD,
   RESOURCE_MAGICKA_CRYSTAL,
   RESOURCE_STEEL,
   RESOURCE_BRONZE,
   RESOURCE_ADAMANTIUM,
   RESOURCE_FOOD,
   RESOURCE_COUNT
};

const std::string enumResourceStr[RESOURCE_COUNT] =
{
   "unknown",
   "iron",
   "gold",
   "silver",
   "gem",
   "diamond",
   "adamantine",
   "coal",
   "stone",
   "wood",
   "magicka crystal",
   "steel",
   "bronze",
   "adamantium",
   "food"
};

enum enumIntermediate
{
   INTERMEDIATE_NONE,
   INTERMEDIATE_FIBRE,
   INTERMEDIATE_GUT,
   INTERMEDIATE_MEAT,
   INTERMEDIATE_BONE,
   INTERMEDIATE_COUNT
};

const std::string enumIntermediateStr[INTERMEDIATE_COUNT] =
{
   "none",
   "fibre",
   "gut",
   "meat",
   "bone"
};

const std::string intermediateToString(enumIntermediate intermediate)
{
   if (intermediate >= 0 && intermediate < INTERMEDIATE_COUNT)
   {
      return enumIntermediateStr[intermediate];
   }
   return "Unknown";
}


const std::string resourceToString(enumResource resource)
{
   switch (resource)
   {
      case RESOURCE_FOOD: return "Food";
      case RESOURCE_IRON: return "Iron";
      case RESOURCE_GOLD: return "Gold";
      case RESOURCE_SILVER: return "Silver";
      case RESOURCE_GEM: return "Gem";
      case RESOURCE_DIAMOND: return "Diamond";
      case RESOURCE_ADAMANTINE: return "Adamantine";
      case RESOURCE_COAL: return "Coal";
      case RESOURCE_STONE: return "Stone";
      case RESOURCE_WOOD: return "Wood";
      case RESOURCE_MAGICKA_CRYSTAL: return "Magicka Crystal";
      case RESOURCE_STEEL: return "Steel";
      case RESOURCE_BRONZE: return "Bronze";
      case RESOURCE_ADAMANTIUM: return "Adamantium";
      default: return "Unknown";
   }
}

enum enumJob
{
   JOB_UNKNOWN,
   JOB_FARMING,
   JOB_MINING,
   JOB_PRODUCTION,
   JOB_WOODCUTTING,
   JOB_PROSPECTING,
   JOB_HUNTING,
   JOB_COUNT
};

const std::string enumJobStr[JOB_COUNT] =
{
   "unknown",
   "farming",
   "mining",
   "production",
   "woodcutting",
   "prospecting",
   "hunting"
};

// Item Category needs to be changed to Item Action, and then Item objects need to have a table of their value at each
// action.

// Melee hunting - Can only catch certain animals which can be ambushed or will approach

enum ItemAction
{
   ITEM_ACTION_NONE,
   ITEM_ACTION_HUNTING_MELEE,
   ITEM_ACTION_HUNTING_RANGED,
   ITEM_ACTION_FARMING,
   ITEM_ACTION_WOODCUTTING,
   ITEM_ACTION_MINING,
   ITEM_ACTION_COUNT
};

const std::string actionToString(ItemAction action)
{
   switch (action)
   {
      case ITEM_ACTION_NONE: return "None";
      case ITEM_ACTION_HUNTING_MELEE: return "Hunting melee";
      case ITEM_ACTION_HUNTING_RANGED: return "Hunting ranged";
      case ITEM_ACTION_FARMING: return "Farming";
      // Add more cases as needed
      default: return "Unknown";
   }
}


enum ItemType
{
   ITEM_NONE,
   ITEM_HAND,
   ITEM_HOE,
   ITEM_SWORD,
   ITEM_KNIFE,
   ITEM_LONGBOW,
   ITEM_SPEAR,
   ITEM_PICKAXE,
   ITEM_FISHROD,
   ITEM_SHOVEL,
   ITEM_AXE,
   ITEM_LOG,
   ITEM_FISH,
   ITEM_CAMPFIRE,
   ITEM_PLANK,
   ITEM_WALL,
   ITEM_FLOOR,
   ITEM_PLANTFIBRE,
   ITEM_DEERPELT,
   ITEM_DEERMEAT,
   ITEM_HUMANSKIN,
   ITEM_HUMANMEAT,
   ITEM_LEATHERCLOTHES,
   ITEM_WATERSKIN,
   ITEM_SHELTER,
   ITEM_MARKER_RED,
   ITEM_MARKER_GREEN_SMALL,
   ITEM_COUNT
};

const std::string enumItemTypeStr[ITEM_COUNT] =
{
   "none",
   "hand",
   "hoe",
   "sword",
   "knife",
   "longbow",
   "spear",
   "pickaxe",
   "fishrod",
   "shovel",
   "axe",
   "log",
   "fish",
   "campfire",
   "plank",
   "wall",
   "floor",
   "plantfibre",
   "deerpelt",
   "deermeat",
   "humanskin",
   "humanmeat",
   "leatherclothes",
   "waterskin",
   "shelter",
   "marker_red",
   "marker_green_small"
};

const std::string itemToString(ItemType itemType)
{
   switch (itemType)
   {
      case ITEM_NONE: return "None";
      case ITEM_HAND: return "Hand";
      case ITEM_HOE: return "Hoe";
      case ITEM_SWORD: return "Sword";
      case ITEM_KNIFE: return "Knife";
      case ITEM_LONGBOW: return "Longbow";
      case ITEM_SPEAR: return "Spear";
      case ITEM_PICKAXE: return "Pickaxe";
      case ITEM_FISHROD: return "Fishrod";
      case ITEM_SHOVEL: return "Shovel";
      case ITEM_AXE: return "Axe";
      case ITEM_LOG: return "Log";
      case ITEM_FISH: return "Fish";
      case ITEM_CAMPFIRE: return "Campfire";
      case ITEM_PLANK: return "Plank";
      case ITEM_WALL: return "Wall";
      case ITEM_FLOOR: return "Floor";
      case ITEM_PLANTFIBRE: return "Plantfibre";
      case ITEM_DEERPELT: return "Deerpelt";
      case ITEM_DEERMEAT: return "Deermeat";
      case ITEM_HUMANSKIN: return "Humanskin";
      case ITEM_HUMANMEAT: return "Humanmeat";
      case ITEM_LEATHERCLOTHES: return "Leatherclothes";
      case ITEM_WATERSKIN: return "Waterskin";
      case ITEM_SHELTER: return "Shelter";
      case ITEM_MARKER_RED: return "Marker Red";
      case ITEM_MARKER_GREEN_SMALL: return "Marker Green Small";
      // Add more cases as needed
      default: return "Unknown";
   }
}

// Define a mapping from ItemType to ItemAction
std::unordered_map<ItemType, ItemAction> ItemActionMap =
{
   {ITEM_HOE, ITEM_ACTION_FARMING},
   {ITEM_SWORD, ITEM_ACTION_HUNTING_MELEE},
   {ITEM_KNIFE, ITEM_ACTION_HUNTING_MELEE},
   {ITEM_LONGBOW, ITEM_ACTION_HUNTING_RANGED},
   // ... Add other item to category mappings
};

// Function to determine if an item is in a particular category
bool isItemInAction(ItemType itemType, ItemAction ItemAction)
{
   auto it = ItemActionMap.find(itemType);
   if (it != ItemActionMap.end())
   {
      return it->second == ItemAction;
   }
   return false; // Item type not found in the map, or not associated with any category
}

// Function to determine the category of an item
ItemAction getActionOfItem(ItemType itemType)
{
   auto it = ItemActionMap.find(itemType);
   if (it != ItemActionMap.end())
   {
      return it->second; // Return the found category
   }
   return ITEM_ACTION_NONE; // Return default category if not found
}

// Assuming ItemType and ItemAction are defined enums
// and ItemActionMap is a predefined map from ItemType to ItemAction

Vector <ItemType> getItemsInAction(ItemAction category)
{
   Vector<ItemType> itemsInCategory;

   for (const auto& itemPair : ItemActionMap)
   {
      if (itemPair.second == category)
      {
         itemsInCategory.push(itemPair.first);
      }
   }

   return itemsInCategory;
}



#define COUT_COLOURS

// black        30         40
// red          31         41
// green        32         42
// yellow       33         43
// blue         34         44
// magenta      35         45
// cyan         36         46
// white        37         47

enum enumColour
{
   BLACK,
   RED,
   GREEN,
   YELLOW,
   BLUE,
   MAGENTA,
   CYAN,
   WHITE,
   DEFAULT
};

std::unordered_map<enumColour, std::string> colourMap =
{
   {BLACK,   "\033[30m"},
   {RED,     "\033[31m"},
   {GREEN,   "\033[32m"},
   {YELLOW,  "\033[33m"},
   {BLUE,    "\033[34m"},
   {MAGENTA, "\033[35m"},
   {CYAN,    "\033[36m"},
   {WHITE,   "\033[37m"},
   {DEFAULT,   "\033[0m"}
};

void colour(enumColour colour)
{
   #ifdef COUT_COLOURS
   auto it = colourMap.find(colour);
   if (it != colourMap.end())
   {
      // Set colour
      std::cout << it->second;
   }
   #endif
}



#endif // WORLDSIM_DRIVER_SETTINGS_ENUMS_CPP