public static Danger ResolveMaxDanger(Pawn pawn, Danger secondPriority, Danger thirdPriority)
{
Danger danger = PawnUtility.ResolveMaxDanger(pawn, secondPriority);
if (danger != Danger.Unspecified)
{
return(danger);
}
return(thirdPriority);
}
void DangerEffectContinuous(Danger danger)
{
if (dead)
{
return;
}
float damage = Time.deltaTime * danger.DamageOnStay;
health.Hurt(damage);
}
public static TraverseParms For(TraverseMode mode, Danger maxDanger = Danger.Deadly, bool canBash = false)
{
TraverseParms result = default(TraverseParms);
result.pawn = null;
result.mode = mode;
result.maxDanger = maxDanger;
result.canBash = canBash;
return(result);
}
void DangerEffect(Danger danger)
{
if (dead)
{
return;
}
health.Hurt(danger.DamageOnTouch);
hurt = true;
}
public static Building_Bed FindSuitableSurgeryBed(this Pawn sleeper, Pawn traveler)
{
bool sleeperWillBePrisoner = sleeper.IsPrisoner;
if (sleeper.InBed() /* && sleeper.CurrentBed().Medical*/)
{
Building_Bed bedThing = sleeper.CurrentBed();
if (RestUtility.IsValidBedFor(bedThing, sleeper, traveler, sleeperWillBePrisoner, false))
{
return(sleeper.CurrentBed());
}
}
for (int i = 0; i < bedDefsBestToWorst_Medical.Count; i++)
{
ThingDef thingDef = bedDefsBestToWorst_Medical[i];
if (RestUtility.CanUseBedEver(sleeper, thingDef))
{
for (int j = 0; j < 2; j++)
{
Danger maxDanger = (j != 0) ? Danger.Deadly : Danger.None;
Building_Bed building_Bed = (Building_Bed)GenClosest.ClosestThingReachable(sleeper.Position, sleeper.Map, ThingRequest.ForDef(thingDef), PathEndMode.OnCell, TraverseParms.For(traveler, Danger.Deadly, TraverseMode.ByPawn, false), 9999f, delegate(Thing b)
{
//Log.Message("Bed=" + b.ThingID + "; def=" + thingDef.defName);
Building_Bed bed = b as Building_Bed;
bool result;
if (/*((Building_Bed)b).Medical &&*/ b.Position.GetDangerFor(sleeper, sleeper.Map) <= maxDanger)
{
/*result =
* RestUtility.CanUseBedEver(sleeper, thingDef) &&
* traveler.CanReserveAndReach(bed, PathEndMode.OnCell, Danger.Deadly) &&
* bed.AnyUnoccupiedSleepingSlot &&
* !bed.IsForbidden(sleeper) &&
* !bed.IsBurning() &&
* (sleeperWillBePrisoner ? bed.ForPrisoners : bed.Faction == null || bed.Faction == sleeper.Faction);*/
result = RestUtility.IsValidBedFor(b, sleeper, traveler, sleeperWillBePrisoner, false);
}
else
{
result = false;
}
return(result);
}, null, 0, -1, false, RegionType.Set_Passable, false);
if (building_Bed != null)
{
return(building_Bed);
}
}
}
}
return(null);
}
public static IntVec3 GetFleeDestToolUser(Pawn pawn, List <Thing> threats, float distance = 23f)
{
IntVec3 bestPos = pawn.Position;
float bestScore = -1f;
TraverseParms traverseParms = TraverseParms.For(pawn);
RegionTraverser.BreadthFirstTraverse(pawn.GetRegion(), (Region from, Region reg) => reg.Allows(traverseParms, isDestination : false), delegate(Region reg)
{
Danger danger = reg.DangerFor(pawn);
Map map = pawn.Map;
foreach (IntVec3 cell in reg.Cells)
{
if (cell.Standable(map) && !reg.IsDoorway)
{
Thing thing = null;
float num = 0f;
for (int i = 0; i < threats.Count; i++)
{
float num2 = cell.DistanceToSquared(threats[i].Position);
if (thing == null || num2 < num)
{
thing = threats[i];
num = num2;
}
}
float num3 = Mathf.Sqrt(num);
float num4 = Mathf.Pow(Mathf.Min(num3, distance), 1.2f);
num4 *= Mathf.InverseLerp(50f, 0f, (cell - pawn.Position).LengthHorizontal);
if (cell.GetRoom(map) != thing.GetRoom())
{
num4 *= 4.2f;
}
else if (num3 < 8f)
{
num4 *= 0.05f;
}
if (!map.pawnDestinationReservationManager.CanReserve(cell, pawn))
{
num4 *= 0.5f;
}
if (danger == Danger.Deadly)
{
num4 *= 0.8f;
}
if (num4 > bestScore)
{
bestPos = cell;
bestScore = num4;
}
}
}
return(false);
}, 20);
return(bestPos);
}
public bool Allows(TraverseParms tp, bool isDestination)
{
if (tp.mode == TraverseMode.PassAllDestroyableThings || tp.mode == TraverseMode.PassAllDestroyableThingsNotWater || type.Passable())
{
if ((int)tp.maxDanger < 3 && tp.pawn != null)
{
Danger danger = DangerFor(tp.pawn);
if (isDestination || danger == Danger.Deadly)
{
Region region = tp.pawn.GetRegion(RegionType.Set_All);
if ((region == null || (int)danger > (int)region.DangerFor(tp.pawn)) && (int)danger > (int)tp.maxDanger)
{
return(false);
}
}
}
switch (tp.mode)
{
case TraverseMode.ByPawn:
if (door != null)
{
ByteGrid avoidGrid = tp.pawn.GetAvoidGrid();
if (avoidGrid != null && avoidGrid[door.Position] == 255)
{
return(false);
}
if (tp.pawn.HostileTo(door))
{
return(door.CanPhysicallyPass(tp.pawn) || tp.canBash);
}
return(door.CanPhysicallyPass(tp.pawn) && !door.IsForbiddenToPass(tp.pawn));
}
return(true);
case TraverseMode.NoPassClosedDoors:
return(door == null || door.FreePassage);
case TraverseMode.PassDoors:
return(true);
case TraverseMode.PassAllDestroyableThings:
return(true);
case TraverseMode.NoPassClosedDoorsOrWater:
return(door == null || door.FreePassage);
case TraverseMode.PassAllDestroyableThingsNotWater:
return(true);
default:
throw new NotImplementedException();
}
}
return(false);
}
private static IntVec3 GetRestSpot(IntVec3 originCell, Danger maxDanger, Pawn me)
{
if (!(me is PawnConverted))
{
return(originCell);
}
var currentDanger = me.Position.GetDangerFor(me);
var danger = (Danger)Math.Max((int)maxDanger, (int)currentDanger);
Predicate <IntVec3> validator = c => c.Standable() && Find.RoofGrid.Roofed(c) &&
CoverUtility.TotalSurroundingCoverScore(c) > 2.5f && !NextToDoor(c, me) &&
originCell.CanReach(c, PathEndMode.OnCell, TraverseMode.PassDoors, danger);
if (validator(originCell) && InRange(originCell, me, 20))
{
return(originCell);
}
for (int i = 0; i < 50; i++)
{
Thing thing = GetRandom(Find.ListerBuildings.allBuildingsColonist);
if (thing == null)
{
thing = GetRandom(Find.ListerBuildings.allBuildingsColonistCombatTargets);
}
if (thing == null)
{
thing = GetRandom(Find.ListerPawns.FreeColonists);
}
if (thing == null)
{
thing = GetRandom(Find.ListerPawns.ColonistsAndPrisoners);
}
if (thing == null)
{
break;
}
IntVec3 result;
if (CellFinder.TryFindRandomCellNear(thing.Position, 10, validator, out result))
{
return(result);
}
}
Predicate <IntVec3> simpleValidator = c => c.Standable() &&
CoverUtility.TotalSurroundingCoverScore(c) > 1 && !NextToDoor(c, me) &&
originCell.CanReach(c, PathEndMode.OnCell, TraverseMode.PassDoors, danger);
IntVec3 randomCell;
return(CellFinder.TryFindRandomCellNear(originCell, 20, simpleValidator, out randomCell) ? randomCell : originCell);
}
public (PawnPath path, bool found) FindVehiclePath(IntVec3 start, LocalTargetInfo dest, VehiclePawn pawn, CancellationToken token, PathEndMode peMode = PathEndMode.OnCell)
{
if (pawn.LocationRestrictedBySize(dest.Cell))
{
Messages.Message("VehicleCannotFit".Translate(), MessageTypeDefOf.RejectInput);
return(PawnPath.NotFound, false);
}
Danger maxDanger = Danger.Deadly;
return(FindVehiclePath(start, dest, TraverseParms.For(pawn, maxDanger, TraverseMode.ByPawn, false), token, peMode, pawn.IsBoat()));
}
public async Task <IActionResult> Create([Bind("Id,Descr,Variable")] Danger danger)
{
if (ModelState.IsValid)
{
_context.Add(danger);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(danger));
}
private void Start()
{
var prefab = _attackMappingConfig.GetAttackPrefab(_key);
if (prefab == null)
{
return;
}
_danger = Instantiate(prefab, gameObject.transform, false);
}
internal static void Postfix(Pawn p, Region __instance, ref Danger __result)
{
if (p.GetStatValue(CE_StatDefOf.SmokeSensitivity) > 0)
{
int smokeCount = __instance?.ListerThings?.AllThings?.Where(t => t is Smoke)?.Count() ?? 0;
if (smokeCount > 0)
{
__result = Danger.Deadly;
}
}
}
public async Task <int> AddDanger(Danger danger)
{
try {
danger.Id = await _db.QueryFirstAsync <int>("SELECT Id FROM Dangers ORDER BY Id DESC");
await _db.ExecuteAsync("INSERT INTO Dangers VALUES (@id, @label, @value, 0)", new { id = danger.Id, label = danger.Label, value = danger.Value });
return(danger.Id);
} catch (Exception) {
return(0);
}
}
public void Add(MessageBag other)
{
if (other == null)
{
throw new ArgumentException("other");
}
Danger.AddRange(other.Danger);
Info.AddRange(other.Info);
Success.AddRange(other.Success);
Warning.AddRange(other.Warning);
}
void DangerImpact(Danger danger)
{
if (dead)
{
return;
}
GetComponent <Rigidbody2D>().AddForce(new Vector2(danger.HorizontalForce, danger.VerticalForce));
if (danger.HorizontalForce != 0)
{
Disable(0.3f);
}
}
public static bool TryFindRandomExitSpot(Pawn pawn, out IntVec3 spot, TraverseMode mode = TraverseMode.ByPawn)
{
Danger danger = Danger.Some;
int num = 0;
IntVec3 intVec;
while (true)
{
num++;
if (num > 40)
{
break;
}
if (num > 15)
{
danger = Danger.Deadly;
}
intVec = CellFinder.RandomCell(pawn.Map);
int num2 = Rand.RangeInclusive(0, 3);
if (num2 == 0)
{
intVec.x = 0;
}
if (num2 == 1)
{
intVec.x = pawn.Map.Size.x - 1;
}
if (num2 == 2)
{
intVec.z = 0;
}
if (num2 == 3)
{
intVec.z = pawn.Map.Size.z - 1;
}
if (intVec.Standable(pawn.Map))
{
LocalTargetInfo dest = intVec;
PathEndMode peMode = PathEndMode.OnCell;
Danger maxDanger = danger;
if (pawn.CanReach(dest, peMode, maxDanger, false, mode))
{
goto IL_E5;
}
}
}
spot = pawn.Position;
return(false);
IL_E5:
spot = intVec;
return(true);
}
public static bool TryFindExitSpotNear(Pawn pawn, IntVec3 near, float radius, out IntVec3 spot, TraverseMode mode = TraverseMode.ByPawn)
{
return((mode == TraverseMode.PassAllDestroyableThings && CellFinder.TryFindRandomEdgeCellNearWith(near, radius, pawn.Map, (IntVec3 x) => pawn.CanReach(x, PathEndMode.OnCell, Danger.Deadly, false, TraverseMode.ByPawn), out spot)) || CellFinder.TryFindRandomEdgeCellNearWith(near, radius, pawn.Map, delegate(IntVec3 x)
{
Pawn pawn2 = pawn;
LocalTargetInfo dest = x;
PathEndMode peMode = PathEndMode.OnCell;
Danger maxDanger = Danger.Deadly;
TraverseMode mode2 = mode;
return pawn2.CanReach(dest, peMode, maxDanger, false, mode2);
}, out spot));
}
void OnTriggerEnter2D(Collider2D collider)
{
if (!hurt)
{
if (collider.transform.tag == "Danger")
{
Danger danger = collider.gameObject.GetComponent <Danger>();
DangerEffect(danger);
DangerImpact(danger);
}
}
}
void OnCollisionStay2D(Collision2D collision)
{
if (!hurt)
{
if (collision.transform.tag == "Danger")
{
Danger danger = collision.gameObject.GetComponent <Danger>();
DangerEffectContinuous(danger);
DangerImpact(danger);
}
}
}
public PawnPath FindShipPath(IntVec3 start, LocalTargetInfo dest, Pawn pawn, PathEndMode peMode = PathEndMode.OnCell)
{
/*bool flag = false;
* if(!(pawn is null) && PawnIsShip(pawn) && !(pawn.CurJob is null))
* {
* flag = true;
* }*/
//can bash?
Danger maxDanger = Danger.Deadly;
return(this.FindShipPath(start, dest, TraverseParms.For(pawn, maxDanger, TraverseMode.ByPawn, false), peMode));
}
internal bool <> m__1(Region reg)
{
Danger danger = reg.DangerFor(this.pawn);
Map map = this.pawn.Map;
foreach (IntVec3 intVec in reg.Cells)
{
if (intVec.Standable(map))
{
if (!reg.IsDoorway)
{
Thing thing = null;
float num = 0f;
for (int i = 0; i < this.threats.Count; i++)
{
float num2 = (float)intVec.DistanceToSquared(this.threats[i].Position);
if (thing == null || num2 < num)
{
thing = this.threats[i];
num = num2;
}
}
float num3 = Mathf.Sqrt(num);
float f = Mathf.Min(num3, this.distance);
float num4 = Mathf.Pow(f, 1.2f);
num4 *= Mathf.InverseLerp(50f, 0f, (intVec - this.pawn.Position).LengthHorizontal);
if (intVec.GetRoom(map, RegionType.Set_Passable) != thing.GetRoom(RegionType.Set_Passable))
{
num4 *= 4.2f;
}
else if (num3 < 8f)
{
num4 *= 0.05f;
}
if (!map.pawnDestinationReservationManager.CanReserve(intVec, this.pawn, false))
{
num4 *= 0.5f;
}
if (danger == Danger.Deadly)
{
num4 *= 0.8f;
}
if (num4 > this.bestScore)
{
this.bestPos = intVec;
this.bestScore = num4;
}
}
}
}
return(false);
}
public PawnPath FindPath(IntVec3 start, LocalTargetInfo dest, Pawn pawn, PathEndMode peMode = PathEndMode.OnCell)
{
bool flag = false;
if (pawn != null && pawn.CurJob != null && pawn.CurJob.canBash)
{
flag = true;
}
Danger maxDanger = Danger.Deadly;
bool canBash = flag;
return(this.FindPath(start, dest, TraverseParms.For(pawn, maxDanger, TraverseMode.ByPawn, canBash), peMode));
}
public void ClearLists()
{
Hunt.Clear();
Caution.Clear();
Danger.Clear();
Alert.Clear();
GlobalHunt.Clear();
GlobalCaution.Clear();
GlobalDanger.Clear();
GlobalAlert.Clear();
EmailAlert.Clear();
WieldedItems.Clear();
}
private IEnumerator Start()
{
while (true)
{
yield return(new WaitForSeconds(dangerPingInterval));
SphereCollider sphereCollider = GetComponent <SphereCollider>();
if (sphereCollider != null)
{
Danger.OnDangerInvoke(gameObject, null, sphereCollider.radius, 10000f);
}
}
}
private void DrawRoom(int x, int y, Danger danger, int number, List <int>[] graph, List <bool>[] Active, bool StartRoom)
{
if (IsBatAnimated && !IsAnimated)
{
if (StartRoom && danger != Danger.Pit)
{
Graphics.DrawImage(CaveRoom[TypeImageRoom[number]].CompressedImage, x, y, length, length);
}
else if (StartRoom)
{
Graphics.DrawImage(PitRoom.CompressedImage, x, y, length, length);
}
else
{
Graphics.DrawImage(DarkRoom.CompressedImage, x, y, length, length);
}
}
else
{
if (StartRoom && danger != Danger.Pit)
{
CaveRoom[TypeImageRoom[number]].Draw(Graphics, x, y);
}
else if (StartRoom)
{
PitRoom.Draw(Graphics, x, y);
}
else
{
DarkRoom.Draw(Graphics, x, y);
}
}
for (int i = 0; i < 6; i++)
{
if (StartRoom && Active[number][i])
{
if (IsBatAnimated && !IsAnimated)
{
Graphics.DrawImage(room[i].CompressedImage, x + (int)(length * StownPosX[i]), y + (int)(length * StownPosY[i]), length / 3, length / 3);
}
else
{
room[i].Draw(Graphics, x + (int)(length * StownPosX[i]), y + (int)(length * StownPosY[i]));
}
}
}
if (StartRoom && danger == Danger.Wumpus)
{
WumpusImg.Draw(Graphics, x + length / 4, y + length / 4);
}
}
public bool Allows(TraverseParms tp, bool isDestination)
{
if (tp.mode != TraverseMode.PassAllDestroyableThings && !this.type.Passable())
{
return(false);
}
if (tp.maxDanger < Danger.Deadly && tp.pawn != null)
{
Danger danger = this.DangerFor(tp.pawn);
if (isDestination || danger == Danger.Deadly)
{
Region region = tp.pawn.GetRegion(RegionType.Set_All);
if ((region == null || danger > region.DangerFor(tp.pawn)) && danger > tp.maxDanger)
{
return(false);
}
}
}
switch (tp.mode)
{
case TraverseMode.ByPawn:
{
if (this.portal == null)
{
return(true);
}
ByteGrid avoidGrid = tp.pawn.GetAvoidGrid();
if (avoidGrid != null && avoidGrid[this.portal.Position] == 255)
{
return(false);
}
if (tp.pawn.HostileTo(this.portal))
{
return(this.portal.CanPhysicallyPass(tp.pawn) || tp.canBash);
}
return(this.portal.CanPhysicallyPass(tp.pawn) && !this.portal.IsForbiddenToPass(tp.pawn));
}
case TraverseMode.PassDoors:
return(true);
case TraverseMode.NoPassClosedDoors:
return(this.portal == null || this.portal.FreePassage);
case TraverseMode.PassAllDestroyableThings:
return(true);
default:
throw new NotImplementedException();
}
}
private static bool canReserve(Pawn traveler, Building_Bed building_Bed)
{
LocalTargetInfo target = building_Bed;
PathEndMode peMode = PathEndMode.OnCell;
Danger maxDanger = Danger.Some;
int sleepingSlotsCount = building_Bed.SleepingSlotsCount;
if (!traveler.CanReserveAndReach(target, peMode, maxDanger, sleepingSlotsCount, -1, null, false))
{
return(false);
}
return(true);
}
public static Danger ResolveMaxDanger(Pawn pawn, Danger secondPriority)
{
Danger result;
if (!pawn.Dead && pawn.mindState.duty != null && pawn.mindState.duty.maxDanger != Danger.Unspecified)
{
result = pawn.mindState.duty.maxDanger;
}
else
{
result = secondPriority;
}
return(result);
}
public static Job HandleBlockingThingJob(Thing constructible, Pawn worker, bool forced = false)
{
Thing thing = GenConstruct.FirstBlockingThing(constructible, worker);
if (thing == null)
{
return(null);
}
if (thing.def.category == ThingCategory.Plant)
{
LocalTargetInfo target = thing;
PathEndMode peMode = PathEndMode.ClosestTouch;
Danger maxDanger = worker.NormalMaxDanger();
if (worker.CanReserveAndReach(target, peMode, maxDanger, 1, -1, null, forced))
{
return(new Job(JobDefOf.CutPlant, thing));
}
}
else if (thing.def.category == ThingCategory.Item)
{
if (thing.def.EverHaulable)
{
return(HaulAIUtility.HaulAsideJobFor(worker, thing));
}
Log.ErrorOnce(string.Concat(new object[]
{
"Never haulable ",
thing,
" blocking ",
constructible.ToStringSafe <Thing>(),
" at ",
constructible.Position
}), 6429262);
}
else if (thing.def.category == ThingCategory.Building)
{
LocalTargetInfo target = thing;
PathEndMode peMode = PathEndMode.Touch;
Danger maxDanger = worker.NormalMaxDanger();
if (worker.CanReserveAndReach(target, peMode, maxDanger, 1, -1, null, forced))
{
return(new Job(JobDefOf.Deconstruct, thing)
{
ignoreDesignations = true
});
}
}
return(null);
}
internal static IntVec3 ClosestLocationReachable(WorkGiver_GrowerHarvest workGiver_GrowerHarvest, Pawn pawn)
{
Danger maxDanger = pawn.NormalMaxDanger();
//bool forced = false;
Map map = pawn.Map;
ZoneManager zoneManager = pawn.Map.zoneManager;
foreach (IntVec3 actionableLocation in PlantHarvest_Cache.GetClosestActionableLocations(pawn, map, PlantHarvest_Cache.awaitingHarvestCellsMapDict))
{
List <Thing> thingsAtLocation = GridsUtility.GetThingList(actionableLocation, map);
foreach (Thing thingAtLocation in thingsAtLocation)
{
if (thingAtLocation is Building_PlantGrower building_PlantGrower)
{
if (building_PlantGrower == null || !workGiver_GrowerHarvest.ExtraRequirements(building_PlantGrower, pawn) ||
building_PlantGrower.IsForbidden(pawn) ||
!pawn.CanReach(building_PlantGrower, PathEndMode.OnCell, maxDanger)
)
{
continue;
}
return(actionableLocation);
}
}
if (!(zoneManager.ZoneAt(actionableLocation) is Zone_Growing growZone))
{
continue;
}
if (!workGiver_GrowerHarvest.ExtraRequirements(growZone, pawn))
{
continue;
}
//if (!JobOnCellTest(workGiver_GrowerHarvest, pawn, actionableLocation, forced))
//{
// continue;
//}
if (!workGiver_GrowerHarvest.HasJobOnCell(pawn, actionableLocation))
{
PlantHarvest_Cache.ReregisterObject(pawn.Map, actionableLocation, PlantHarvest_Cache.awaitingHarvestCellsMapDict);
continue;
}
if (!pawn.CanReach(actionableLocation, PathEndMode.OnCell, maxDanger))
{
continue;
}
return(actionableLocation);
}
return(IntVec3.Invalid);
}
