//determine the random placetype based on available options
public PlaceType determineOrbitalPlaceType(Random rando, GridTile.GridTerrain gridTerrain)
{
List <PlaceType> possiblePlaceTypes = new List <PlaceType>();
possiblePlaceTypes.AddRange(new PlaceType[] { PlaceType.Graveyard, PlaceType.Cave, PlaceType.Encampment, PlaceType.Ruins, PlaceType.Farm });
//check for terrain specific possibilities
if (gridTerrain == GridTile.GridTerrain.Beach)
{
}
else if (gridTerrain == GridTile.GridTerrain.Forest)
{
}
else if (gridTerrain == GridTile.GridTerrain.Hills)
{
}
else if (gridTerrain == GridTile.GridTerrain.Grass)
{
}
PlaceType thisType = possiblePlaceTypes[rando.Next(0, possiblePlaceTypes.Count)];
return(thisType);
}
public void GetEstimationsForTravel(WorldMap world)
{
for (int i = 0; i < travelPath.Count; ++i)
{
//road
if (world.IsGridRoad(travelPath[i].routeLocation))
{
AssignEstimateValueToPath(5, i);
}
//water
else if (world.IsGridLakeOrWater(travelPath[i].routeLocation))
{
AssignEstimateValueToPath(30, i);
}
//node
else if (world.IsGridNodeType(travelPath[i].routeLocation) != GridTile.GridNode.None)
{
AssignEstimateValueToPath(10, i);
}
//terrains
else
{
GridTile.GridTerrain terraintype = world.GridNodeTerrainType(travelPath[i].routeLocation);
if (terraintype == GridTile.GridTerrain.Beach)
{
AssignEstimateValueToPath(15, i);
}
else if (terraintype == GridTile.GridTerrain.Forest)
{
AssignEstimateValueToPath(20, i);
}
else if (terraintype == GridTile.GridTerrain.Grass)
{
AssignEstimateValueToPath(10, i);
}
else if (terraintype == GridTile.GridTerrain.Hills)
{
AssignEstimateValueToPath(20, i);
}
else if (terraintype == GridTile.GridTerrain.Swamp)
{
AssignEstimateValueToPath(25, i);
}
}
}
}
public Boolean CheckForGridRequirements(GridTile.GridTerrain terraintype, Boolean isonroad)
{
if (requiresRoad == false && requiresTerrain == false)
{
return(true);
}
else if (requiresRoad == true && isonroadrequirement == isonroad)
{
return(true);
}
else if (requiresTerrain == true && requiredTerrainType == terraintype)
{
return(true);
}
else
{
return(false);
}
}
//world event builder
public WorldEvent(String thisEventBaseTypeString, int percentChance, String eventTitleText, String[] eventDescriptionText,
EventOption[] eventoptions, String requiredterrainString, String requiredroadString)
{
thisWorldEventBaseType = (WorldEventBase)Enum.Parse(typeof(WorldEventBase), thisEventBaseTypeString);
eventChance = percentChance;
//text
thisEventTitle = eventTitleText;
foreach (String t in eventDescriptionText)
{
thisEventTextPossibilities.Add(t);
}
//event options
foreach (EventOption o in eventoptions)
{
eventOptions.Add(o);
}
//requirements
if (requiredterrainString != "")
{
requiresTerrain = true;
requiredTerrainType = (GridTile.GridTerrain)Enum.Parse(typeof(GridTile.GridTerrain), requiredterrainString);
}
if (requiredroadString != "")
{
requiresRoad = true;
if (requiredroadString == "true")
{
isonroadrequirement = true;
}
else if (requiredroadString == "false")
{
isonroadrequirement = false;
}
}
}
//passive event builder
public Event(String thisEventBaseString, int percentChance, String[] eventText,
String requiredSkillString, String requireSkillRankingString, String requiredTraitString,
String itemType, String[] listOfItems, int stammin, int stammax, int stressmin, int stressmax, int healthmin, int healthmax,
String requiredTerrain, String requiredRoad, int staminaeffect, int stresseffect, int healtheffect, int partysizemin,
Boolean occurswhentravelling, Boolean occurswhensleeping, Boolean occurswhenwakingup)
{
//properties
thisEventBaseType = (PassiveEventBase)Enum.Parse(typeof(PassiveEventBase), thisEventBaseString);
eventChance = percentChance;
//text
foreach (String t in eventText)
{
thisEventTextPossibilities.Add(t);
}
eventStaminaEffect = staminaeffect;
eventStressEffect = stresseffect;
eventHealthEffect = healtheffect;
//requirements
if (requiredSkillString != "")
{
requiresSkill = true;
requiredSkill = (PersonSkill.SkillType)Enum.Parse(typeof(PersonSkill.SkillType), requiredSkillString);
}
if (requireSkillRankingString != "")
{
requiredRanking = (PersonSkill.SkillRanking)Enum.Parse(typeof(PersonSkill.SkillRanking), requireSkillRankingString);
}
if (requiredTraitString != "")
{
requiresTrait = true;
requiredTraitType = (Person.TraitType)Enum.Parse(typeof(Person.TraitType), requiredTraitString);
}
if (requiredTerrain != "")
{
requiresTerrain = true;
requiredTerrainType = (GridTile.GridTerrain)Enum.Parse(typeof(GridTile.GridTerrain), requiredTerrain);
}
if (requiredRoad != "")
{
requiresRoad = true;
if (requiredRoad == "true")
{
isonroadrequirement = true;
}
else if (requiredRoad == "false")
{
isonroadrequirement = false;
}
}
eventStaminaRequirementMin = stammin;
eventStaminaRequirementMax = stammax;
eventStressRequirementMin = stressmin;
eventStressRequirementMax = stressmax;
eventHealthRequirementMin = healthmin;
eventHealthRequirementMax = healthmax;
eventPartySizeMinimum = partysizemin;
occursWhenTravelling = occurswhentravelling;
occursWhileSleeping = occurswhensleeping;
occursWhenWakingUp = occurswhenwakingup;
//items
if (itemType != "")
{
hasItem = true;
eventItemType = (Item.ItemType)Enum.Parse(typeof(Item.ItemType), itemType);
foreach (String i in listOfItems)
{
eventItemPosibilities.Add(i);
}
}
}
public void CheckForValidSleepEvents(PlayerHandler player, DataManager datamanager, Random rando, GridTile.GridTerrain terraintype, Boolean isonroad, WorldMap world, int hour, UI_Helper uihelper)
{
List <Event> possibleEvents = new List <Event>();
RestSafeTick();
//check for valid sleep events
foreach (KeyValuePair <String, Event> e in datamanager.passiveEventData)
{
//check if this is a sleep specific event
if ((e.Value.CanOccurWhenSleeping() == true && e.Value.CanOccurWhenSleeping() == false) ||
(e.Value.OccursWhenWakingUp() == true && currentWakeEvent == null))
{
//add any eligible people to event
Event newevent = CheckIfPeopleEligible(e.Value, player);
//determine the text used
newevent.DetermineValidText(rando);
//if eligible people exist, add to event
if (newevent.IsEligibleExists() == true && newevent.CheckForGridRequirements(terraintype, isonroad) == true &&
newevent.CheckForPartySizeRequirements(player.partyMembers.Count) == true)
{
possibleEvents.Add(newevent);
}
}
}
for (int i = 0; i < possibleEvents.Count; ++i)
{
int rand = rando.Next(0, 101);
if (rand < possibleEvents[i].ReturnEventChance())
{
if (possibleEvents[i].OccursWhenWakingUp() == true)
{
SetCurrentWakeEventEvent(possibleEvents[i], true, rando, player, "");
}
else if (restSafeTilesRemaining == 0)
{
SetCurrentPassiveEvent(possibleEvents[i], true, rando, player, "");
RunCurrentPassiveEvent(player, rando, uihelper);
RestSafeSet();
}
break;
}
}
}
//returns minutes to tick down
//this performs all checks/stat changes, etc for travelling
public int TravelTick(PlayerHandler player, DataManager datamanager, Random rando, UI_Helper uihelper, GridTile.GridTerrain gridTerrainType, Boolean isOnRoad, WorldMap world, int hour)
{
int value = 0;
//if at destination
if (currentTravelDistance == totalTravelDistance)
{
//check for event
if (currentGridLocation != travelStartingLocation &&
safeTilesRemaining == 0)
{
CheckForValidEvents(player, datamanager, rando, gridTerrainType, isOnRoad, world, hour);
}
//if world event
if (currentWorldEvent != null)
{
safeTilesRemaining = worldEventSafeTiles;
uihelper.CreateEventUI(currentWorldEvent);
}
//if passive event
else if (currentEvent != null)
{
RunCurrentPassiveEvent(player, rando, uihelper);
//safeTilesRemaining = passiveEventSafeTiles;
//currentEvent.PerformPassiveEventActivity(player, rando);
//CreateTravelFeed(currentEvent.ReturnEventText(), uihelper);
// ConsoleLogEvent();
//ClearEvent();
}
//if no event
else
{
if (safeTilesRemaining > 0)
{
safeTilesRemaining -= 1;
}
//player basic ticks
player.LoseStamina(PlayerHandler.StaminaDrainType.Travel);
player.LoseRested(PlayerHandler.RestedLossType.Travel);
}
//get next distance
currentGridLocation += new Point((int)(totalTravelDistance.X / 64), (int)(totalTravelDistance.Y / 64));
for (int i = 0; i < travelPath.Count; ++i)
{
if (travelPath[i].routeLocation == currentGridLocation)
{
totalTravelDistance = travelPath[i].getDirection();
currentTravelDistance = Vector2.Zero;
if (totalTravelDistance == Vector2.Zero)
{
value = -1;
}
else
{
value = travelPath[i].GetTravelEstimate();
}
break;
}
}
}
//move
currentTravelDistance.X += totalTravelDistance.X / 64;
currentTravelDistance.Y += totalTravelDistance.Y / 64;
return(value);
}
void CheckForValidEvents(PlayerHandler player, DataManager datamanager, Random rando, GridTile.GridTerrain terraintype, Boolean isonroad, WorldMap world, int hour)
{
List <Event> possibleEvents = new List <Event>();
List <WorldEvent> possibleWorldEvents = new List <WorldEvent>();
//check for world events
foreach (KeyValuePair <String, WorldEvent> e in datamanager.worldEventData)
{
WorldEvent worldevent = e.Value;
//check if the mark is eligible to make a decision for options
//party members aren't checked, but are affected by the mark's choice
worldevent.DetermineEventOptionAvailability(player);
//check grid and other reqs, then add to possible events
if (worldevent.CheckForGridRequirements(terraintype, isonroad) == true &&
worldevent.ValidCreatureIfApplicable(world, currentGridLocation, rando, hour) == true)
{
//determine the text used
worldevent.DetermineValidText(rando);
//add to possible events
possibleWorldEvents.Add(worldevent);
}
}
//check for passive events
foreach (KeyValuePair <String, Event> e in datamanager.passiveEventData)
{
//check if can occur when travelling
if (e.Value.CanOccurWhenTravelling() == true)
{
//add any eligible people to event
Event newevent = CheckIfPeopleEligible(e.Value, player);
//determine the item
newevent.DetermineValidItem(datamanager, rando);
//determine the text used
newevent.DetermineValidText(rando);
//if eligible people exist, add to event
if (newevent.IsEligibleExists() == true && newevent.CheckForGridRequirements(terraintype, isonroad) == true &&
newevent.CheckForPartySizeRequirements(player.partyMembers.Count) == true)
{
possibleEvents.Add(newevent);
}
}
}
//check against list of posible world events
for (int i = 0; i < possibleWorldEvents.Count; ++i)
{
int rand = rando.Next(0, 101);
if (rand < possibleWorldEvents[i].ReturnEventChance())
{
currentWorldEvent = possibleWorldEvents[i];
break;
}
}
//check against list of possible passive events, only if a world event isn't going on
if (currentWorldEvent == null)
{
for (int i = 0; i < possibleEvents.Count; ++i)
{
int rand = rando.Next(0, 101);
if (rand < possibleEvents[i].ReturnEventChance())
{
SetCurrentPassiveEvent(possibleEvents[i], true, rando, player, "");
break;
}
}
}
}
