private void OnSicknessTrigger(GameObject target, TriggerInfo trigger)
{
int num = UnityEngine.Random.Range(0, trigger.sickness_ids.Length);
string text = trigger.sickness_ids[num];
Sickness sickness = null;
Database.Sicknesses sicknesses = Db.Get().Sicknesses;
for (int i = 0; i < sicknesses.Count; i++)
{
if (sicknesses[i].Id == text)
{
sickness = sicknesses[i];
break;
}
}
if (sickness != null)
{
string infection_source_info = trigger.sourceCallback(base.gameObject, target);
SicknessExposureInfo exposure_info = new SicknessExposureInfo(sickness.Id, infection_source_info);
Klei.AI.Sicknesses sicknesses2 = target.GetComponent <MinionModifiers>().sicknesses;
sicknesses2.Infect(exposure_info);
}
else
{
DebugUtil.DevLogErrorFormat(base.gameObject, "Couldn't find sickness with id [{0}]", text);
}
}
protected override void InternalBegin()
{
var sickness = new SicknessExposureInfo(Db.Get().Sicknesses.Sunburn.Id,
UVCleanerConfig.DISPLAY_NAME);
reactor.GetSicknesses().Infect(sickness);
cleaner.CreateNewReactable();
}
public object[] Infect(GameObject go, SicknessInstance diseaseInstance, SicknessExposureInfo exposure_info)
{
object[] array = new object[components.Count];
for (int i = 0; i < components.Count; i++)
{
array[i] = components[i].OnInfect(go, diseaseInstance);
}
return(array);
}
public void Infect(SicknessExposureInfo exposure_info)
{
Sickness modifier = Db.Get().Sicknesses.Get(exposure_info.sicknessID);
if (!Has(modifier))
{
SicknessInstance sicknessInstance = CreateInstance(modifier);
sicknessInstance.ExposureInfo = exposure_info;
}
}
public void InfectImmediately(ExposureType exposure_type)
{
if (exposure_type.infection_effect != null)
{
Effects component = base.master.GetComponent <Effects>();
component.Add(exposure_type.infection_effect, true);
}
if (exposure_type.sickness_id != null)
{
string lastDiseaseSource = GetLastDiseaseSource(exposure_type.germ_id);
SicknessExposureInfo exposure_info = new SicknessExposureInfo(exposure_type.sickness_id, lastDiseaseSource);
sicknesses.Infect(exposure_info);
}
}
public override object OnInfect(GameObject go, SicknessInstance diseaseInstance)
{
if (go != null)
{
GameScheduler.Instance.Schedule("InfectWith" + sickness_id, 0.5f, (_) =>
{
var effects = go.GetComponent <Effects>();
// Do not inflict the symptoms if the excluded effect is present
if (effects == null || string.IsNullOrEmpty(excluded_effect) || !effects.
HasEffect(excluded_effect))
{
var exposure_info = new SicknessExposureInfo(sickness_id,
infection_source_info);
go.GetComponent <MinionModifiers>()?.sicknesses?.Infect(exposure_info);
}
});
}
return(null);
}
public void OnSleepFinished()
{
ExposureType[] tYPES = GERM_EXPOSURE.TYPES;
foreach (ExposureType exposureType in tYPES)
{
if (!exposureType.infect_immediately)
{
ExposureState exposureState = GetExposureState(exposureType.germ_id);
if (exposureState == ExposureState.Exposed)
{
SetExposureState(exposureType.germ_id, ExposureState.None);
}
if (exposureState == ExposureState.Contracted)
{
SetExposureState(exposureType.germ_id, ExposureState.Sick);
string lastDiseaseSource = GetLastDiseaseSource(exposureType.germ_id);
SicknessExposureInfo exposure_info = new SicknessExposureInfo(exposureType.sickness_id, lastDiseaseSource);
sicknesses.Infect(exposure_info);
}
SetExposureTier(exposureType.germ_id, 0f);
}
}
}
public void Sim200ms(float dt)
{
if (mobileLamp)
{
lampXY = Grid.PosToXY(gameObject.transform.position);
}
if (alwaysOn || (operational != null && operational.IsOperational))
{
if (operational != null)
{
operational.SetActive(true);
}
HashSet <GameObject> buildingsAlreadySeen = new HashSet <GameObject>();
// Delete germs in area
for (int dy = aoeBottom; dy < aoeBottom + aoeHeight; dy++)
{
int y = lampXY.Y + dy;
for (int dx = aoeLeft; dx < aoeLeft + aoeWidth; dx++)
{
int x = lampXY.X + dx;
if (FlashReachesCell(x, y))
{
int cell = Grid.XYToCell(x, y);
// Delete germs in the cell
byte cellGermIndex = Grid.DiseaseIdx[cell];
if (diseasesKilled.Contains(cellGermIndex))
{
int cellGermCount = Grid.DiseaseCount[cell];
int cellGermsToKill = GermsToKill(cellGermCount);
SimMessages.ModifyDiseaseOnCell(cell, cellGermIndex, -cellGermsToKill);
}
// Delete germs on pickupables in the cell
var pickupablesInCell = Grid.Objects[cell, (int)ObjectLayer.Pickupables];
if (pickupablesInCell != null)
{
var currentPickupable = pickupablesInCell.GetComponent <Pickupable>().objectLayerListItem;
while (currentPickupable != null)
{
var pickupable = currentPickupable.gameObject.GetComponent <Pickupable>();
currentPickupable = currentPickupable.nextItem;
if (pickupable != null)
{
byte pickupableDiseaseIndex = pickupable.PrimaryElement.DiseaseIdx;
if (diseasesKilled.Contains(pickupableDiseaseIndex))
{
int pickupableGermCount = pickupable.PrimaryElement.DiseaseCount;
int pickupableGermsToKill = GermsToKill(pickupableGermCount);
pickupable.PrimaryElement.ModifyDiseaseCount(-pickupableGermsToKill, GermicideLampConfig.ID);
}
if (applySunburn)
{
var minion = pickupable.GetComponent <MinionIdentity>();
if (minion != null)
{
var sunburn = new SicknessExposureInfo(Db.Get().Sicknesses.Sunburn.Id, ModStrings.STRINGS.BUILDINGS.GERMICIDELAMP.NAME);
var sicknesses = minion.GetSicknesses();
bool hasSunburn = false;
if (sicknesses.IsInfected())
{
foreach (SicknessInstance item in sicknesses)
{
if (item.ExposureInfo.sicknessID == Db.Get().Sicknesses.Sunburn.Id)
{
hasSunburn = true;
break;
}
}
}
if (!hasSunburn)
{
sicknesses.Infect(sunburn);
}
}
}
}
}
}
// Delete germs on solid conduit items in the cell
var conduit = Game.Instance.solidConduitFlow.GetConduit(cell);
if (!conduit.Equals(SolidConduitFlow.Conduit.Invalid()))
{
var conduitContents = conduit.GetContents(Game.Instance.solidConduitFlow);
var conduitPickupable = Game.Instance.solidConduitFlow.GetPickupable(conduitContents.pickupableHandle);
if (conduitPickupable != null)
{
byte conduitDiseaseIndex = conduitPickupable.PrimaryElement.DiseaseIdx;
if (diseasesKilled.Contains(conduitDiseaseIndex))
{
int cpuCount = conduitPickupable.PrimaryElement.DiseaseCount;
int cpuGermsToKill = GermsToKill(cpuCount);
conduitPickupable.PrimaryElement.ModifyDiseaseCount(-cpuGermsToKill, GermicideLampConfig.ID);
}
}
}
// Delete germs on buildings in the cell
var buildingInCell = Grid.Objects[cell, (int)ObjectLayer.Building];
if (buildingInCell != null && !buildingsAlreadySeen.Contains(buildingInCell))
{
var buildingElement = buildingInCell.GetComponent <PrimaryElement>();
if (buildingElement != null)
{
byte buildingDiseaseIndex = buildingElement.DiseaseIdx;
if (diseasesKilled.Contains(buildingDiseaseIndex))
{
int buildingGermCount = buildingElement.DiseaseCount;
int buildingGermsToKill = GermsToKill(buildingGermCount);
buildingElement.ModifyDiseaseCount(-buildingGermsToKill, GermicideLampConfig.ID);
}
}
buildingsAlreadySeen.Add(buildingInCell);
}
}
}
}
}
else
{
if (operational != null)
{
operational.SetActive(false);
}
}
}
