private void LoadTraitSpecialCaseData(PersonalityTraitData inTrait, DatabaseEntry inEntry)
{
inTrait.specialCases.Clear();
string stringValue1 = inEntry.GetStringValue("Special Case");
if (!string.IsNullOrEmpty(stringValue1) && stringValue1 != "0")
{
string str1 = stringValue1;
char[] chArray = new char[1] {
';'
};
foreach (string str2 in str1.Split(chArray))
{
string inSpecialCaseString = str2.Trim();
if (!string.IsNullOrEmpty(inSpecialCaseString) && inSpecialCaseString != "0")
{
inTrait.specialCases.Add(this.GetSpecialCaseType(inSpecialCaseString));
}
}
}
string stringValue2 = inEntry.GetStringValue("Special Case Description");
if (string.IsNullOrEmpty(stringValue2) || !(stringValue2 != "0"))
{
return;
}
inTrait.specialCaseDescriptionID = stringValue2;
}
public void LoadNationalitiesFromDatabase(List <DatabaseEntry> databaseEntryList)
{
for (int index = 0; index < databaseEntryList.Count; ++index)
{
DatabaseEntry databaseEntry = databaseEntryList[index];
string stringValue1 = databaseEntry.GetStringValue("Sprite Reference");
if (!this.mNationalitiesDict.ContainsKey(stringValue1))
{
this.mNationalitiesDict[stringValue1] = new Nationality();
this.mNationalitiesDict[stringValue1].continent = NationalityManager.GetContinent(databaseEntry.GetStringValue("Continent"));
this.mNationalitiesDict[stringValue1].SetKey(stringValue1);
this.mNationalities.Add(this.mNationalitiesDict[stringValue1]);
}
string stringValue2 = databaseEntry.GetStringValue("ID");
string stringValue3 = databaseEntry.GetStringValue("Type");
if (stringValue3.Equals("Country"))
{
this.mNationalitiesDict[stringValue1].SetCountry(stringValue2);
}
else if (stringValue3.Equals("Nationality"))
{
this.mNationalitiesDict[stringValue1].SetNationality(stringValue2);
}
try
{
var uri = new Uri(string.Format("pack://application:,,,/Assets/Flags/{0}.png", this.mNationalitiesDict[stringValue1].localisedCountry));
System.Windows.Resources.StreamResourceInfo resourceStream = Application.GetResourceStream(uri);
}
catch (Exception ex)
{
Console.WriteLine("Could not find flag " + this.mNationalitiesDict[stringValue1].localisedCountry + ".png");
}
}
}
public void LoadVotesFromDatabase(List <DatabaseEntry> votesData)
{
for (int index = 0; index < votesData.Count; ++index)
{
DatabaseEntry databaseEntry = votesData[index];
PoliticalVote inVote = new PoliticalVote();
if (Enum.IsDefined(typeof(CarPart.PartType), (object)databaseEntry.GetStringValue("Object Type")))
{
inVote.currentPartType = (CarPart.PartType)Enum.Parse(typeof(CarPart.PartType), databaseEntry.GetStringValue("Object Type"));
}
inVote.displayRule = databaseEntry.GetBoolValue("Display Rule");
inVote.group = databaseEntry.GetStringValue("Rule Group");
inVote.nameID = databaseEntry.GetStringValue("Rule Name ID");
inVote.descriptionID = databaseEntry.GetStringValue("Rule Description ID");
inVote.ID = databaseEntry.GetIntValue("ID");
inVote.lockedToPlayerVote = databaseEntry.GetBoolValue("Locked To Player Vote");
inVote.effectType = databaseEntry.GetStringValue("Effect Type");
inVote.impacts = VotesManager.GetImpacts(inVote.effectType, inVote);
inVote.messageCriteria = VotesManager.GetMessageCriteria(databaseEntry.GetStringValue("Message Trigger"));
string stringValue1 = databaseEntry.GetStringValue("Benefits");
char[] chArray1 = new char[1] {
';'
};
foreach (string str1 in stringValue1.Split(chArray1))
{
string str2 = str1.Trim();
if (!Enum.IsDefined(typeof(PoliticalVote.TeamCharacteristics), (object)str2))
{
Console.WriteLine(34.ToString() + str2 + (object)'"' + " does not exist in the teamCharacteristicsEnum");
}
else
{
inVote.benificialCharacteristics.Add((PoliticalVote.TeamCharacteristics)Enum.Parse(typeof(PoliticalVote.TeamCharacteristics), str2));
}
}
string stringValue2 = databaseEntry.GetStringValue("Challenges");
char[] chArray2 = new char[1] {
';'
};
foreach (string str1 in stringValue2.Split(chArray2))
{
string str2 = str1.Trim();
if (!Enum.IsDefined(typeof(PoliticalVote.TeamCharacteristics), (object)str2))
{
Console.WriteLine(34.ToString() + str2 + (object)'"' + " does not exist in the teamCharacteristicsEnum");
}
else
{
inVote.detrimentalCharacteristics.Add((PoliticalVote.TeamCharacteristics)Enum.Parse(typeof(PoliticalVote.TeamCharacteristics), str2));
}
}
if (this.votes.ContainsKey(inVote.ID))
{
Console.WriteLine("Rule Changes database contains rules with duplicate IDs: {0}", (object)inVote.ID);
}
this.votes.Add(inVote.ID, inVote);
this.voteIDs.Add(inVote.ID);
}
Console.WriteLine("RulesLoaded");
}
public void LoadCircuitsFromDatabase(List <DatabaseEntry> locationData, ClimateManager climateManager)
{
Debug.Assert(this.mCircuits.Count == 0, "Loading from database when content is already loaded; this will work but indicates that the game is loading in a strange unintended way.");
this.mCircuits.Clear();
for (int index = 0; index < locationData.Count; ++index)
{
DatabaseEntry databaseEntry = locationData[index];
Circuit circuit = new Circuit();
this.mCircuits.Add(circuit);
circuit.circuitID = databaseEntry.GetIntValue("Circuit ID");
circuit.locationName = databaseEntry.GetStringValue("Location");
circuit.travelCost = (long)((double)databaseEntry.GetFloatValue("Travel Cost") * (double)GameStatsConstants.millionScalar);
circuit.locationNameID = databaseEntry.GetStringValue("Location ID");
circuit.nationalityKey = databaseEntry.GetStringValue("Country");
circuit.countryNameID = databaseEntry.GetStringValue("Country ID");
circuit.spriteName = databaseEntry.GetStringValue("Sprite Name");
circuit.trackRubberModifier = databaseEntry.GetFloatValue("Track Rubber Modifier");
circuit.safetyCarFlagProbability = databaseEntry.GetFloatValue("Safety Car Flag Chance");
circuit.virtualSafetyCarProbability = databaseEntry.GetFloatValue("Virtual Safety Car Chance");
circuit.minimapRotation = databaseEntry.GetIntValue("Minimap Rotation");
circuit.minimapAxisX = databaseEntry.GetStringValue("Minimap Axis") == "x";
circuit.trackStatsCharacteristics.SetStat(CarStats.StatType.TopSpeed, databaseEntry.GetFloatValue("TS"));
circuit.trackStatsCharacteristics.SetStat(CarStats.StatType.Acceleration, databaseEntry.GetFloatValue("ACC"));
circuit.trackStatsCharacteristics.SetStat(CarStats.StatType.Braking, databaseEntry.GetFloatValue("DEC"));
circuit.trackStatsCharacteristics.SetStat(CarStats.StatType.HighSpeedCorners, databaseEntry.GetFloatValue("HSC"));
circuit.trackStatsCharacteristics.SetStat(CarStats.StatType.MediumSpeedCorners, databaseEntry.GetFloatValue("MSC"));
circuit.trackStatsCharacteristics.SetStat(CarStats.StatType.LowSpeedCorners, databaseEntry.GetFloatValue("LSC"));
circuit.isInNorthHemisphere = databaseEntry.GetStringValue("Hemisphere") == "North";
circuit.trackLayout = CircuitManager.GetTrackLayoutFromString(databaseEntry.GetStringValue("Track Layout"));
circuit.trackLengthMiles = databaseEntry.GetFloatValue("Track Length");
circuit.firstTyreOption = (TyreSet.Compound)Enum.Parse(typeof(TyreSet.Compound), databaseEntry.GetStringValue("First Tyre Option"));
circuit.secondTyreOption = (TyreSet.Compound)Enum.Parse(typeof(TyreSet.Compound), databaseEntry.GetStringValue("Second Tyre Option"));
circuit.thirdTyreOption = (TyreSet.Compound)Enum.Parse(typeof(TyreSet.Compound), databaseEntry.GetStringValue("Third Tyre Option"));
circuit.tyreWearRate = (Circuit.Rate)Enum.Parse(typeof(Circuit.Rate), databaseEntry.GetStringValue("Tyre Wear Rate"));
circuit.fuelBurnRate = (Circuit.Rate)Enum.Parse(typeof(Circuit.Rate), databaseEntry.GetStringValue("Fuel Burn Rate"));
float num1 = 120f;
float num2 = 90f;
float inMinutes1 = (float)((double)circuit.trackLengthMiles / (double)num1 * 60.0);
float inMinutes2 = (float)((double)circuit.trackLengthMiles / (double)num2 * 60.0);
circuit.bestPossibleLapTime = GameUtility.MinutesToSeconds(inMinutes1);
circuit.worstPossibleLapTime = GameUtility.MinutesToSeconds(inMinutes2);
circuit.scene = databaseEntry.GetStringValue("Scene");
circuit.climate = CircuitManager.GetClimateFromString(databaseEntry.GetStringValue("Climate"), climateManager);
circuit.driverStats = Game.instance.driverStatsProgressionManager.GetDriverStatsProgression(circuit.locationName);
}
}
private void LoadIsRepeatableFlag(PersonalityTraitData inTrait, DatabaseEntry inEntry)
{
if (inEntry.GetStringValue("Repeatable") == "Yes")
{
inTrait.isRepeatable = true;
}
else
{
inTrait.isRepeatable = false;
}
}
private void LoadTriatShownType(PersonalityTraitData inTrait, DatabaseEntry inEntry)
{
if (inEntry.GetStringValue("Shown") == "PlayerDriverOnly")
{
inTrait.shownType = PersonalityTraitData.TriggerShownType.PlayerDriverOnly;
}
else
{
inTrait.shownType = PersonalityTraitData.TriggerShownType.AllDrivers;
}
}
public void LoadPersonalityTraitsFromDatabase(List <DatabaseEntry> personalityTraitsData)
{
for (int index = 0; index < personalityTraitsData.Count; ++index)
{
bool flag = false;
DatabaseEntry inEntry = personalityTraitsData[index];
int intValue = inEntry.GetIntValue("ID");
PersonalityTraitData inTrait;
if (this.personalityTraits.ContainsKey(intValue))
{
inTrait = this.personalityTraits[intValue];
}
else
{
inTrait = new PersonalityTraitData();
flag = true;
}
inTrait.ID = intValue;
inTrait.SetNameID(inEntry.GetStringValue("Trait Name ID"));
inTrait.SetDescriptionID(inEntry.GetStringValue("Description ID"));
inTrait.customTraitName = inEntry.GetStringValue("Trait Name");
inTrait.customTraitDescription = inEntry.GetStringValue("Trait Description");
this.LoadTraitType(inTrait, inEntry);
inTrait.possibleLength = this.ParseStringToIntegerArray(inEntry, "Length");
this.LoadTraitRequirements(inTrait, inEntry);
inTrait.probability = (float)(1.0 - (double)inEntry.GetFloatValue("Probability") / 100.0);
inTrait.evolvesInto = this.ParseStringToIntegerArray(inEntry, "Evolves Into");
inTrait.opposites = this.ParseStringToIntegerArray(inEntry, "Opposites");
inTrait.removesTraits = this.ParseStringToIntegerArray(inEntry, "Removes Traits");
this.LoadTraitTriggerSource(inTrait, inEntry);
this.LoadTriatShownType(inTrait, inEntry);
this.LoadTraitModifiers(inTrait, inEntry);
this.LoadTraitSpecialCaseData(inTrait, inEntry);
this.LoadEventTriggerType(inTrait, inEntry);
this.LoadIsRepeatableFlag(inTrait, inEntry);
if (flag)
{
this.personalityTraits.Add(inTrait.ID, inTrait);
}
}
}
private void SetComponentData(CarPartComponent inComponent, DatabaseEntry data)
{
inComponent.nameID = data.GetStringValue("Name ID");
inComponent.iconID = data.GetIntValue("Icon");
inComponent.iconPath = data.GetStringValue("Icon Path");
inComponent.agressiveTeamWeightings = data.GetFloatValue("AggressiveTeamWeightings");
inComponent.nonAgressiveTeamWeightings = data.GetFloatValue("PassiveTeamWeightings");
inComponent.componentType = (CarPartComponent.ComponentType)Enum.Parse(typeof(CarPartComponent.ComponentType), data.GetStringValue("Type"));
inComponent.riskLevel = data.GetFloatValue("Risk Level");
inComponent.statBoost = data.GetFloatValue("Stat Boost");
inComponent.maxStatBoost = data.GetFloatValue("Max Stat Boost");
inComponent.reliabilityBoost = data.GetFloatValue("Reliability Boost") / 100f;
inComponent.maxReliabilityBoost = data.GetFloatValue("Max Reliability Boost") / 100f;
inComponent.productionTime = data.GetFloatValue("Production Time");
inComponent.cost = data.GetFloatValue("Cost");
inComponent.redZone = data.GetFloatValue("Red Zone") / 100f;
inComponent.customComponentName = data.GetStringValue("Custom Trait Name");
this.AddPartAvailability(inComponent, data.GetStringValue("Part"));
this.AddRequirements(inComponent, data.GetStringValue("Activation Requirement"));
this.AddBonus(inComponent, data);
inComponent.level = data.GetIntValue("Level");
inComponent.id = data.GetIntValue("ID");
}
private void LoadEventTriggerType(PersonalityTraitData inTrait, DatabaseEntry inEntry)
{
string stringValue = inEntry.GetStringValue("EventTrigger");
if (string.IsNullOrEmpty(stringValue))
{
return;
}
if (stringValue == "PostRace")
{
inTrait.eventTriggerType = PersonalityTraitData.EventTriggerType.PostRace;
}
else
{
inTrait.eventTriggerType = PersonalityTraitData.EventTriggerType.None;
}
}
private void LoadTraitType(PersonalityTraitData inTrait, DatabaseEntry inEntry)
{
string stringValue = inEntry.GetStringValue("Type");
if (stringValue == "Permanent")
{
inTrait.type = PersonalityTraitData.TraitType.Permanent;
}
else
{
if (!(stringValue == "Temp"))
{
return;
}
inTrait.type = PersonalityTraitData.TraitType.Temporary;
}
}
private int[] ParseStringToIntegerArray(DatabaseEntry inEntry, string fieldName)
{
string[] strArray = inEntry.GetStringValue(fieldName).Split(new char[2] {
';', '-'
});
List <int> intList = new List <int>();
for (int index = 0; index < strArray.Length; ++index)
{
string s = strArray[index].Trim();
if (!(s == string.Empty))
{
int num = int.Parse(s);
if (num != 0)
{
intList.Add(num);
}
}
}
return(intList.ToArray());
}
private void LoadTraitRequirements(PersonalityTraitData inTrait, DatabaseEntry inEntry)
{
List <DialogCriteria> dialogCriteriaList = new List <DialogCriteria>();
string stringValue = inEntry.GetStringValue("Requirement");
if (!string.IsNullOrEmpty(stringValue))
{
string str = stringValue;
char[] chArray = new char[1] {
';'
};
foreach (string inString in str.Split(chArray))
{
DialogCriteria personalityCriteria = this.GetPersonalityCriteria(inTrait, inString);
if (personalityCriteria != null)
{
dialogCriteriaList.Add(personalityCriteria);
}
}
}
inTrait.requirements = dialogCriteriaList;
}
private void LoadTraitTriggerSource(PersonalityTraitData inTrait, DatabaseEntry inEntry)
{
inTrait.triggerCriteria.Clear();
string stringValue = inEntry.GetStringValue("Triggers");
if (string.IsNullOrEmpty(stringValue))
{
return;
}
string[] strArray1 = stringValue.Split(';');
for (int index = 0; index < strArray1.Length; ++index)
{
if (!string.IsNullOrEmpty(strArray1[index]) && !(strArray1[index] == "0"))
{
string[] strArray2 = strArray1[index].Split('=');
if (strArray2.Length == 2)
{
inTrait.triggerCriteria.Add(new DialogCriteria("Type", "Header"));
inTrait.triggerCriteria.Add(new DialogCriteria(strArray2[0].Trim(), strArray2[1].Trim()));
}
}
}
}
public void LoadDriverProgressionFromDatabase(List <DatabaseEntry> statProgressionData)
{
this.statsProgressionDictionary = new Dictionary <string, DriverStatsProgression>();
for (int index = 0; index < statProgressionData.Count; ++index)
{
DatabaseEntry inEntry = statProgressionData[index];
string stringValue = inEntry.GetStringValue("Type");
if (stringValue.Contains("/"))
{
int num = int.Parse(stringValue[1].ToString());
string inType = stringValue.Substring(3);
for (int inIndex = 0; inIndex < num; ++inIndex)
{
DriverStatsProgression statsProgression = new DriverStatsProgression(inEntry, inIndex, inType);
this.statsProgressionDictionary.Add(inType + (object)inIndex, statsProgression);
}
}
else
{
DriverStatsProgression statsProgression = new DriverStatsProgression(inEntry, stringValue);
this.statsProgressionDictionary.Add(stringValue, statsProgression);
}
}
}
private void AddBonus(CarPartComponent inComponent, DatabaseEntry inData)
{
inComponent.bonuses.Clear();
string stringValue = inData.GetStringValue("Bonus Type");
string text = stringValue;
switch (text)
{
case "NoConditionLossFirstRace":
inComponent.AddBonuses(new BonusNoConditionLossFirstSession
{
session = SessionDetails.SessionType.Race,
name = stringValue
});
break;
case "SecondPartFree":
inComponent.AddBonuses(new BonusCreateTwoParts
{
name = stringValue
});
break;
case "NoConditionLossEver":
inComponent.AddBonuses(new BonusNoConditionLoss
{
name = stringValue
});
break;
case "TimeReductionPerMillionSpent":
inComponent.AddBonuses(new BonusTimeReductionPerMillionSpent
{
bonusValue = inData.GetFloatValue("Bonus"),
name = stringValue
});
break;
case "SlotsLevelAddNoDays":
inComponent.AddBonuses(new BonusSpecificLevelSlotAddNoDays
{
bonusValue = inData.GetFloatValue("Bonus"),
name = stringValue
});
break;
case "AddRandomLevelComponent":
inComponent.AddBonuses(new BonusAddRandomLevelComponent
{
bonusValue = inData.GetFloatValue("Bonus"),
name = stringValue
});
break;
case "ReliabilityPerDayInProduction":
inComponent.AddBonuses(new BonusExtraReliabilityPerDayInProduction
{
bonusValue = inData.GetFloatValue("Bonus"),
name = stringValue
});
break;
case "UnlockExtraSlotOfLevel":
inComponent.AddBonuses(new BonusUnlockExtraSlot
{
bonusValue = inData.GetFloatValue("Bonus"),
name = stringValue
});
break;
case "PerformanceAutoImproved":
inComponent.AddBonuses(new BonusPerformanceAutoImproved
{
name = stringValue
});
break;
case "ComponentLevelAddNoDays":
inComponent.AddBonuses(new BonusSpecificLevelComponentAddNoDays
{
name = stringValue,
bonusValue = inData.GetFloatValue("Bonus")
});
break;
case "ReliabilityBonusPerComponentOfLevel":
{
BonusPerSpecificLevelComponentUsed bonusPerSpecificLevelComponentUsed = new BonusPerSpecificLevelComponentUsed();
bonusPerSpecificLevelComponentUsed.stat = CarPartStats.CarPartStat.Reliability;
bonusPerSpecificLevelComponentUsed.statBoost = inComponent.reliabilityBoost;
bonusPerSpecificLevelComponentUsed.bonusValue = inData.GetFloatValue("Bonus");
bonusPerSpecificLevelComponentUsed.name = stringValue;
inComponent.reliabilityBoost = 0f;
inComponent.AddBonuses(bonusPerSpecificLevelComponentUsed);
break;
}
}
}
public DriverStatsProgression(DatabaseEntry inEntry, int inIndex, string inType)
{
if (inEntry == null)
{
return;
}
string stringValue1 = inEntry.GetStringValue("Braking");
string stringValue2 = inEntry.GetStringValue("Cornering");
string stringValue3 = inEntry.GetStringValue("Smoothness");
string stringValue4 = inEntry.GetStringValue("Overtaking");
string stringValue5 = inEntry.GetStringValue("Consistency");
string stringValue6 = inEntry.GetStringValue("Adaptability");
string stringValue7 = inEntry.GetStringValue("Fitness");
string stringValue8 = inEntry.GetStringValue("Feedback");
string stringValue9 = inEntry.GetStringValue("Focus");
string[] strArray1 = stringValue1.Split(';');
string[] strArray2 = stringValue2.Split(';');
string[] strArray3 = stringValue3.Split(';');
string[] strArray4 = stringValue4.Split(';');
string[] strArray5 = stringValue5.Split(';');
string[] strArray6 = stringValue6.Split(';');
string[] strArray7 = stringValue7.Split(';');
string[] strArray8 = stringValue8.Split(';');
string[] strArray9 = stringValue9.Split(';');
this.progressionType = inType + (object)inIndex;
if (strArray1.Length > inIndex)
{
this.braking = Convert.ToSingle(strArray1[inIndex]) / 100f;
}
if (strArray2.Length > inIndex)
{
this.cornering = Convert.ToSingle(strArray2[inIndex]) / 100f;
}
if (strArray3.Length > inIndex)
{
this.smoothness = Convert.ToSingle(strArray3[inIndex]) / 100f;
}
if (strArray4.Length > inIndex)
{
this.overtaking = Convert.ToSingle(strArray4[inIndex]) / 100f;
}
if (strArray5.Length > inIndex)
{
this.consistency = Convert.ToSingle(strArray5[inIndex]) / 100f;
}
if (strArray6.Length > inIndex)
{
this.adaptability = Convert.ToSingle(strArray6[inIndex]) / 100f;
}
if (strArray7.Length > inIndex)
{
this.fitness = Convert.ToSingle(strArray7[inIndex]) / 100f;
}
if (strArray8.Length > inIndex)
{
this.feedback = Convert.ToSingle(strArray8[inIndex]) / 100f;
}
if (strArray9.Length <= inIndex)
{
return;
}
this.focus = Convert.ToSingle(strArray9[inIndex]) / 100f;
}