public DiseaseVector(VectorBooter.Data data, Variant strain)
{
mGuid = data.Guid;
mNonPersistableData = data;
mStrain = new Variant(data, strain);
Start(Notices.None);
}
public DiseaseVector(DiseaseVector vector, SimDescription sim)
{
mGuid = vector.mGuid;
mNonPersistableData = vector.mNonPersistableData;
mStrain = new Variant(mNonPersistableData, vector.mStrain);
Start(Notices.None);
}
public static bool Inoculate(SimDescription sim, VectorBooter.Data vector, bool paid, bool testExisting)
{
DiseaseVector inoculate = new DiseaseVector(vector, Vector.Settings.GetCurrentStrain(vector));
inoculate.Inoculate(vector.InoculationStrain, paid);
return(Inoculate(sim, inoculate, paid, testExisting));
}
public DiseaseVector.Variant GetCurrentStrain(VectorBooter.Data vector)
{
DiseaseVector.Variant strain;
if (mVariants.TryGetValue(vector.Guid, out strain))
{
return(strain);
}
else
{
return(new DiseaseVector.Variant(vector));
}
}
public int Variation(VectorBooter.Data vector)
{
int result = Math.Abs(mStrength - vector.InitialStrength);
Dictionary <string, bool> mutables = vector.AllMutables;
foreach (KeyValuePair <string, int> pair in mCounters)
{
if (!mutables.ContainsKey(pair.Key))
{
continue;
}
result += Math.Abs(pair.Value);
}
return(result);
}
protected Variant(VectorBooter.Data vector, long strain, int strength, Dictionary <string, int> counters)
{
mStrain = strain;
mStrength = strength;
mMutated = false;
Dictionary <string, bool> mutables = vector.AllMutables;
foreach (KeyValuePair <string, int> pair in counters)
{
if (!mutables.ContainsKey(pair.Key))
{
continue;
}
mCounters.Add(pair.Key, pair.Value);
}
}
public override List <ISettingOption> GetOptions()
{
List <ISettingOption> results = new List <ISettingOption>();
results.Add(new EnabledSetting(mGuid));
results.Add(new WatchesSetting(mGuid));
results.Add(new MotiveAdjustmentRatioSetting(mGuid));
VectorBooter.Data vector = VectorBooter.GetVector(mGuid);
if (vector != null)
{
foreach (string setting in vector.CustomSettings)
{
results.Add(new CustomSetting(setting));
}
}
return(results);
}
public static void StartOutbreak(VectorBooter.Data vector, bool verbose)
{
DiseaseVector disease = new DiseaseVector(vector, Vector.Settings.GetNewStrain(vector));
ScoringLog.sLog.IncStat(disease.UnlocalizedName + " Attempt Outbreak");
List <Sim> sims = new List <Sim>(LotManager.Actors);
if (sims.Count > 0)
{
int count = 0;
while ((count < Vector.Settings.mNumPatientZero) && (sims.Count > 0))
{
Sim choice = RandomUtil.GetRandomObjectFromList(sims);
sims.Remove(choice);
if (choice.SimDescription.ToddlerOrBelow)
{
continue;
}
if (!Vector.Settings.mOutbreakAllowActive)
{
if (choice.Household == Household.ActiveHousehold)
{
continue;
}
}
if (disease.Infect(choice.SimDescription, true))
{
count++;
if (verbose)
{
ShowNotice(choice.SimDescription, disease, Common.kDebugging ? "Outbreak" : "");
}
ScoringLog.sLog.IncStat(disease.UnlocalizedName + " Outbreak");
}
}
}
}
public bool OnLoadFixup()
{
mNonPersistableData = VectorBooter.GetVector(Guid);
if (mNonPersistableData == null)
{
return(false);
}
if (mStrain == null)
{
mStrain = new Variant(mNonPersistableData, Vector.Settings.GetCurrentStrain(mNonPersistableData));
}
if (mStage > mNonPersistableData.NumStages)
{
mStage = 0;
}
return(true);
}
public Variant(VectorBooter.Data vector, Variant strain)
: this(vector, strain.Strain, strain.Strength, strain.mCounters)
{
}
public Variant(VectorBooter.Data vector)
: this(vector, 1, vector.InitialStrength, new Dictionary <string, int>())
{
}
public InstigatorListener(EventTypeId id, VectorBooter.Data vector, InstigatorBooter.Data instigator)
: base(id, null)
{
mVector = vector;
mInstigator = instigator;
}
public InstigatorListener(EventTypeId id, VectorBooter.Data vector, InstigatorBooter.Data instigator)
: base(id, null)
{
mVector = vector;
mInstigator = instigator;
}
protected DiseaseVector.Variant GetNewStrain(VectorBooter.Data vector, DiseaseVector.Variant strain, bool force)
{
DiseaseVector.Variant newStrain = new DiseaseVector.Variant(vector, strain);
if ((force) || (strain.Mutated))
{
// Doing this stops the previous strain from reentering this process
strain.Mutated = false;
long id = 1;
DiseaseVector.Variant oldStrain;
if (mVariants.TryGetValue(vector.Guid, out oldStrain))
{
if (oldStrain.Strain < strain.Strain)
{
oldStrain.Strain = strain.Strain;
}
id = oldStrain.Strain;
}
else
{
oldStrain = null;
}
if ((oldStrain == null) || (oldStrain.Variation(vector) < newStrain.Variation(vector)))
{
newStrain.Strain++;
oldStrain = new DiseaseVector.Variant(newStrain, id + 1);
mVariants.Remove(vector.Guid);
mVariants.Add(vector.Guid, oldStrain);
if (Common.kDebugging)
{
Common.DebugNotify("BETTER " + vector.Guid + " Strain:" + Common.NewLine + oldStrain);
}
}
else if (RandomUtil.RandomChance01(vector.StrainMutationRate * (force ? 2 : 1)))
{
newStrain.Strain = id + 1;
if (force)
{
oldStrain.Strain = newStrain.Strain;
if (Common.kDebugging)
{
Common.DebugNotify("OUTBREAK " + vector.Guid + " Strain:" + Common.NewLine + newStrain);
}
}
else
{
if (Common.kDebugging)
{
Common.DebugNotify("RANDOM " + vector.Guid + " Strain:" + Common.NewLine + newStrain);
}
}
}
}
return(newStrain);
}
public DiseaseVector.Variant GetNewStrain(VectorBooter.Data vector, DiseaseVector.Variant strain)
{
return(GetNewStrain(vector, strain, false));
}
public DiseaseVector.Variant GetNewStrain(VectorBooter.Data vector)
{
return(GetNewStrain(vector, GetCurrentStrain(vector), true));
}
