public static void DeconstructDropStuff(Thing oldThing) { if (Current.ProgramState != ProgramState.Playing) { return; } ThingDef oldDef = oldThing.def; ThingDef stuffDef = oldThing.Stuff; //preferably GenLeaving.DoLeavingsFor here, but don't want to drop non-stuff things. if (GenLeaving.CanBuildingLeaveResources(oldThing, DestroyMode.Deconstruct)) { int count = TotalStuffNeeded(oldDef, stuffDef); int leaveCount = GetBuildingResourcesLeaveCalculator(oldThing, DestroyMode.Deconstruct)(count); if (leaveCount > 0) { Thing leftThing = ThingMaker.MakeThing(stuffDef); leftThing.stackCount = leaveCount; #pragma warning disable CS0618 // Type or member is obsolete GenDrop.TryDropSpawn(leftThing, oldThing.Position, oldThing.Map, ThingPlaceMode.Near, out Thing dummyThing); #pragma warning restore CS0618 // Type or member is obsolete } } }
//public static System.Reflection.MethodInfo removeRes = typeof(Thing).GetMethod("RemoveAllReservationsAndDesignationsOnThis", BindingFlags.Instance | BindingFlags.NonPublic); //public static System.Reflection.MethodInfo notifyMethod = typeof(RegionDirtyer).GetMethod("Notify_ThingAffectingRegionsDespawned", BindingFlags.Instance | BindingFlags.NonPublic); public static bool TakeDamage(Thing __instance, ref DamageWorker.DamageResult __result, DamageInfo dinfo) { if (__instance.Destroyed) { __result = new DamageWorker.DamageResult(); return(false); } if ((double)dinfo.Amount == 0.0) { __result = new DamageWorker.DamageResult(); return(false); } if (__instance.def.damageMultipliers != null) { for (int index = 0; index < __instance.def.damageMultipliers.Count; ++index) { if (__instance.def.damageMultipliers[index].damageDef == dinfo.Def) { int num = UnityEngine.Mathf.RoundToInt(dinfo.Amount * __instance.def.damageMultipliers[index].multiplier); dinfo.SetAmount((float)num); } } } //__result = new DamageWorker.DamageResult(); //if (__instance is Plant) if (true) { bool absorbed; __instance.PreApplyDamage(ref dinfo, out absorbed); if (absorbed) { __result = new DamageWorker.DamageResult(); return(false); } bool anyParentSpawned = __instance.SpawnedOrAnyParentSpawned; Map mapHeld = __instance.MapHeld; DamageWorker.DamageResult damageResult = Apply(dinfo, __instance); if (dinfo.Def.harmsHealth & anyParentSpawned) { mapHeld.damageWatcher.Notify_DamageTaken(__instance, damageResult.totalDamageDealt); } if (dinfo.Def.ExternalViolenceFor(__instance)) { GenLeaving.DropFilthDueToDamage(__instance, damageResult.totalDamageDealt); if (dinfo.Instigator != null && dinfo.Instigator is Pawn instigator) { instigator.records.AddTo(RecordDefOf.DamageDealt, damageResult.totalDamageDealt); instigator.records.AccumulateStoryEvent(StoryEventDefOf.DamageDealt); } } __instance.PostApplyDamage(dinfo, damageResult.totalDamageDealt); __result = damageResult; } return(false); }
public static void PostFix(ref Func <int, int> __result, Thing destroyedThing, ref DestroyMode mode) { if (destroyedThing.def.defName != "MSRecoveryPod" || mode != DestroyMode.Deconstruct || !(destroyedThing.def.resourcesFractionWhenDeconstructed >= 1f)) { return; } if (!GenLeaving.CanBuildingLeaveResources(destroyedThing, mode)) { __result = _ => 0; return; } if (mode == DestroyMode.Deconstruct && destroyedThing is Frame) { mode = DestroyMode.Cancel; return; } if (mode == DestroyMode.Deconstruct) { __result = count => count; } }
// Token: 0x06000003 RID: 3 RVA: 0x00002290 File Offset: 0x00000490 public static Func <int, int> GBRLC(Thing t, DestroyMode d) { bool flag = !GenLeaving.CanBuildingLeaveResources(t, d); if (!flag) { switch (d) { case DestroyMode.Vanish: return((int count) => 0); case DestroyMode.KillFinalize: return((int count) => GenMath.RoundRandom((float)count * 0.5f)); case DestroyMode.Deconstruct: return((int count) => GenMath.RoundRandom(Mathf.Min((float)count * t.def.resourcesFractionWhenDeconstructed, (float)count))); case DestroyMode.FailConstruction: return((int count) => GenMath.RoundRandom((float)count * 0.5f)); case DestroyMode.Cancel: return((int count) => GenMath.RoundRandom((float)count * 1f)); case DestroyMode.Refund: return((int count) => count); } throw new ArgumentException("Unknown destroy mode " + d + " (Deconstruct Return Fix error)"); } return((int count) => 0); }
}//end DoLeavingsForPrefix public static Func <int, int> GBRLC(Thing t) { if (!GenLeaving.CanBuildingLeaveResources(t, DestroyMode.Deconstruct)) { return((int count) => 0); } return((int count) => GenMath.RoundRandom(Mathf.Min((float)count * t.def.resourcesFractionWhenDeconstructed, (float)(count)))); //other destroy modes deleted because I always know the mode }
public static void ThingDestroy(Thing __instance, DestroyMode mode = DestroyMode.Vanish) { if (!Thing.allowDestroyNonDestroyable && !__instance.def.destroyable) { Log.Error("Tried to destroy non-destroyable thing " + __instance); return; } if (__instance.Destroyed) { Log.Error("Tried to destroy already-destroyed thing " + __instance); return; } bool spawned = __instance.Spawned; Map map = __instance.Map; if (__instance.Spawned) { __instance.DeSpawn(mode); } mapIndexOrState(__instance) = -2; if (__instance.def.DiscardOnDestroyed) { __instance.Discard(); } CompExplosive compExplosive = __instance.TryGetComp <CompExplosive>(); if (spawned) { List <Thing> list = (compExplosive != null) ? new List <Thing>() : null; GenLeaving.DoLeavingsFor(__instance, map, mode, list); compExplosive?.AddThingsIgnoredByExplosion(list); } if (__instance.holdingOwner != null) { __instance.holdingOwner.Notify_ContainedItemDestroyed(__instance); } RemoveAllReservationsAndDesignationsOnThis(__instance); if (!(__instance is Pawn)) { __instance.stackCount = 0; } if (mode != DestroyMode.QuestLogic) { QuestUtility.SendQuestTargetSignals(__instance.questTags, "Destroyed", __instance.Named("SUBJECT")); } if (mode == DestroyMode.KillFinalize) { QuestUtility.SendQuestTargetSignals(__instance.questTags, "Killed", __instance.Named("SUBJECT")); } }
public static bool Prefix(TerrainGrid __instance, IntVec3 c, bool doLeavings, Map ___map, ref TerrainDef[] ___underGrid) { try { var ZTracker = ZUtils.ZTracker; if (ZTracker.GetZIndexFor(___map) > 0) { int num = ___map.cellIndices.CellToIndex(c); if (doLeavings) { GenLeaving.DoLeavingsFor(__instance.topGrid[num], c, ___map); } if (___underGrid[num] != null) { __instance.topGrid[num] = ___underGrid[num]; ___underGrid[num] = null; Traverse.Create(__instance).Method("DoTerrainChangedEffects", new object[] { c }).GetValue(); } if (c.GetTerrain(___map) == TerrainDefOf.Sand) { __instance.SetTerrain(c, ZLevelsDefOf.ZL_OutsideTerrain); } Map lowerMap = ZTracker.GetLowerLevel(___map.Tile, ___map); bool firstTime = false; if (lowerMap == null) { return(false); //lowerMap = ZTracker.CreateLowerLevel(___map, c); firstTime = true; } var thingList = c.GetThingList(___map); if (thingList.Where(x => x is Blueprint || x is Frame).Count() == 0) { for (int i = thingList.Count - 1; i >= 0; i--) { if (!(thingList[i] is Mineable || thingList[i] is Blueprint || thingList[i] is Frame)) { //Log.Message(thingList[i] + " going down 1"); ZTracker.SimpleTeleportThing(thingList[i], c, lowerMap, firstTime, 10); } } } return(false); } } catch (Exception ex) { Log.Error("[Z-Levels] DestroyedTerrain patch produced an error. That should not happen and will break things. Send a Hugslib log to the Z-Levels developers. Error message: " + ex, true); } return(true); }
private static Func <int, int> GetBuildingResourcesLeaveCalculator(Thing destroyedThing, DestroyMode mode) { if (!GenLeaving.CanBuildingLeaveResources(destroyedThing, mode)) { return(_ => 0); } if (mode == DestroyMode.Deconstruct && destroyedThing is Frame) { mode = DestroyMode.Cancel; } switch (mode) { case DestroyMode.Vanish: { return(_ => 0); } case DestroyMode.WillReplace: { return(_ => 0); } case DestroyMode.KillFinalize: { return(count => GenMath.RoundRandom(count * 0.5f)); } case DestroyMode.Deconstruct: { return(count => GenMath.RoundRandom(Math.Min(count * destroyedThing.def.resourcesFractionWhenDeconstructed, count - 1))); } case DestroyMode.FailConstruction: { return(count => GenMath.RoundRandom(count * 0.5f)); } case DestroyMode.Cancel: { return(count => GenMath.RoundRandom(count * 1f)); } case DestroyMode.Refund: { return(count => count); } } throw new ArgumentException(string.Concat("Unknown destroy mode ", mode)); }
public static void DamagePart(Pawn p, int damage, BodyPartRecord part) { HediffDef hediffDefFromDamage = HealthUtility.GetHediffDefFromDamage(DamageDefOf.SurgicalCut, p, part); Hediff_Injury injury = (Hediff_Injury)HediffMaker.MakeHediff(hediffDefFromDamage, p, part); injury.Severity = damage; p.health.AddHediff(injury, part, new DamageInfo(DamageDefOf.SurgicalCut, damage, 999f, -1f, null, part)); GenLeaving.DropFilthDueToDamage(p, damage); }
public static void SpawnBuildingAsPossible(Building building, Map map, bool respawningAfterLoad = false) { bool flag = false; foreach (IntVec3 item in building.OccupiedRect()) { List <Thing> thingList = item.GetThingList(map); int num = 0; while (num < thingList.Count) { if (!(thingList[num] is Pawn) || building.def.passability != Traversability.Impassable) { if ((thingList[num].def.category == ThingCategory.Building || thingList[num].def.category == ThingCategory.Item) && GenSpawn.SpawningWipes(building.def, thingList[num].def)) { flag = true; break; } num++; continue; } flag = true; break; } if (flag) { break; } } if (flag) { bool flag2 = false; if (building.def.Minifiable) { MinifiedThing minifiedThing = building.MakeMinified(); if (GenPlace.TryPlaceThing(minifiedThing, building.Position, map, ThingPlaceMode.Near, null)) { flag2 = true; } else { minifiedThing.GetDirectlyHeldThings().Clear(); minifiedThing.Destroy(DestroyMode.Vanish); } } if (!flag2) { GenLeaving.DoLeavingsFor(building, map, DestroyMode.Refund, building.OccupiedRect()); } } else { GenSpawn.Spawn(building, building.Position, map, building.Rotation, respawningAfterLoad); } }
public DamageWorker.DamageResult TakeDamage(DamageInfo dinfo) { if (this.Destroyed) { return(DamageWorker.DamageResult.MakeNew()); } if (dinfo.Amount == 0) { return(DamageWorker.DamageResult.MakeNew()); } if (this.def.damageMultipliers != null) { for (int i = 0; i < this.def.damageMultipliers.Count; i++) { if (this.def.damageMultipliers[i].damageDef == dinfo.Def) { int amount = Mathf.RoundToInt((float)dinfo.Amount * this.def.damageMultipliers[i].multiplier); dinfo.SetAmount(amount); } } } bool flag = default(bool); this.PreApplyDamage(dinfo, out flag); if (flag) { return(DamageWorker.DamageResult.MakeNew()); } bool spawnedOrAnyParentSpawned = this.SpawnedOrAnyParentSpawned; Map mapHeld = this.MapHeld; DamageWorker.DamageResult result = dinfo.Def.Worker.Apply(dinfo, this); if (dinfo.Def.harmsHealth && spawnedOrAnyParentSpawned) { mapHeld.damageWatcher.Notify_DamageTaken(this, result.totalDamageDealt); } if (dinfo.Def.externalViolence) { GenLeaving.DropFilthDueToDamage(this, result.totalDamageDealt); if (dinfo.Instigator != null) { Pawn pawn = dinfo.Instigator as Pawn; if (pawn != null) { pawn.records.AddTo(RecordDefOf.DamageDealt, result.totalDamageDealt); pawn.records.AccumulateStoryEvent(StoryEventDefOf.DamageDealt); } } } this.PostApplyDamage(dinfo, result.totalDamageDealt); return(result); }
public virtual void Destroy(DestroyMode mode = DestroyMode.Vanish) { if (!allowDestroyNonDestroyable && !def.destroyable) { Log.Error("Tried to destroy non-destroyable thing " + this); return; } if (Destroyed) { Log.Error("Tried to destroy already-destroyed thing " + this); return; } bool spawned = Spawned; Map map = Map; if (Spawned) { DeSpawn(mode); } mapIndexOrState = -2; if (def.DiscardOnDestroyed) { Discard(); } CompExplosive compExplosive = this.TryGetComp <CompExplosive>(); if (spawned) { List <Thing> list = ((compExplosive != null) ? new List <Thing>() : null); GenLeaving.DoLeavingsFor(this, map, mode, list); compExplosive?.AddThingsIgnoredByExplosion(list); } if (holdingOwner != null) { holdingOwner.Notify_ContainedItemDestroyed(this); } RemoveAllReservationsAndDesignationsOnThis(); if (!(this is Pawn)) { stackCount = 0; } if (mode != DestroyMode.QuestLogic) { QuestUtility.SendQuestTargetSignals(questTags, "Destroyed", this.Named("SUBJECT")); } if (mode == DestroyMode.KillFinalize) { QuestUtility.SendQuestTargetSignals(questTags, "Killed", this.Named("SUBJECT")); } }
public DamageWorker.DamageResult TakeDamage(DamageInfo dinfo) { if (Destroyed) { return(new DamageWorker.DamageResult()); } if (dinfo.Amount == 0f) { return(new DamageWorker.DamageResult()); } if (def.damageMultipliers != null) { for (int i = 0; i < def.damageMultipliers.Count; i++) { if (def.damageMultipliers[i].damageDef == dinfo.Def) { int num = Mathf.RoundToInt(dinfo.Amount * def.damageMultipliers[i].multiplier); dinfo.SetAmount(num); } } } PreApplyDamage(ref dinfo, out var absorbed); if (absorbed) { return(new DamageWorker.DamageResult()); } bool spawnedOrAnyParentSpawned = SpawnedOrAnyParentSpawned; Map mapHeld = MapHeld; DamageWorker.DamageResult damageResult = dinfo.Def.Worker.Apply(dinfo, this); if (dinfo.Def.harmsHealth && spawnedOrAnyParentSpawned) { mapHeld.damageWatcher.Notify_DamageTaken(this, damageResult.totalDamageDealt); } if (dinfo.Def.ExternalViolenceFor(this)) { GenLeaving.DropFilthDueToDamage(this, damageResult.totalDamageDealt); if (dinfo.Instigator != null) { Pawn pawn = dinfo.Instigator as Pawn; if (pawn != null) { pawn.records.AddTo(RecordDefOf.DamageDealt, damageResult.totalDamageDealt); pawn.records.AccumulateStoryEvent(StoryEventDefOf.DamageDealt); } } } PostApplyDamage(dinfo, damageResult.totalDamageDealt); return(damageResult); }
public static void ChangeStuff(this Thing thing, ThingDef stuff) { thing.SetStuffDirect(stuff); thing.HitPoints = thing.MaxHitPoints; //Deconstruction/construction implicitly repairs if (thing is Frame frame) { GenLeaving.DoLeavingsFor(thing, thing.Map, DestroyMode.Cancel); frame.workDone = 0; } thing.Notify_ColorChanged(); thing.Map.reservationManager.ReleaseAllForTarget(thing); }
public override void Generate(Map map, GenStepParams parms) { var decay = this.decay.RandomInRange; var corpseChance = this.corpseChance.RandomInRange; var maxItemValue = this.maxItemValue.RandomInRange; var _currentThing = (Thing)null; foreach (var pos in map.cellsInRandomOrder.GetAll()) { try { var things = pos.GetThingList(map); for (var i = things.Count - 1; i >= 0; i--) { var thing = things[i]; _currentThing = thing; if ((thing.MarketValue > maxItemValue || ShouldDestroy(thing, decay)) && !thing.Destroyed) { if (thing is Pawn pawn && !pawn.Faction.IsPlayer && Rand.Chance(corpseChance)) { pawn.equipment.DestroyAllEquipment(); foreach (var apparel in pawn.apparel.WornApparel) { if (apparel.MarketValue > maxItemValue * 2) { pawn.apparel.Remove(apparel); } } pawn.Kill(null); pawn.Corpse.timeOfDeath -= Rand.RangeInclusive(10, 500) * 1000; } else { thing.Destroy(); } GenLeaving.DropFilthDueToDamage(thing, thing.MaxHitPoints); } else { if (thing is Building_Bed bed) { bed.SetFactionDirect(null); } if (Rand.Chance(decay * decay)) { thing.HitPoints = (int)(thing.MaxHitPoints * (1 - Rand.Value * decay)); } } } }
public void RemoveTopLayer(IntVec3 c, bool doLeavings = true) { int num = this.map.cellIndices.CellToIndex(c); if (doLeavings) { GenLeaving.DoLeavingsFor(this.topGrid[num], c, this.map); } if (this.underGrid[num] != null) { this.topGrid[num] = this.underGrid[num]; this.underGrid[num] = null; this.DoTerrainChangedEffects(c); } }
public void RemoveTopLayer(IntVec3 c, bool doLeavings = true) { int index = this.map.cellIndices.CellToIndex(c); if (doLeavings) { GenLeaving.DoLeavingsFor(this.topGrid[index], c, this.map); } if (this.underGrid[index] == null) { return; } this.topGrid[index] = this.underGrid[index]; this.underGrid[index] = (TerrainDef)null; this.DoTerrainChangedEffects(c); }
public new void FailConstruction(Pawn worker) { Log.Message($"Failed replace frame! work was {workDone}, Decon is {WorkToDeconstruct(def, oldStuff)}, total is {WorkToBuild}"); workDone = Mathf.Min(workDone, WorkToDeconstruct(def, oldStuff)); if (workDone < WorkToDeconstruct(def, oldStuff)) { return; //Deconstruction doesn't fail } GenLeaving.DoLeavingsFor(this, Map, DestroyMode.FailConstruction); MoteMaker.ThrowText(this.DrawPos, Map, "TextMote_ConstructionFail".Translate()); if (base.Faction == Faction.OfPlayer && this.WorkToReplace > 1400f) { Messages.Message("MessageConstructionFailed".Translate(this.LabelEntityToBuild, worker.LabelShort, worker.Named("WORKER")), new TargetInfo(base.Position, Map), MessageTypeDefOf.NegativeEvent); } }
public override void Destroy() { base.Destroy(); GenLeaving.DoLeavingsFor(this, destroyMode); if (def.MakeFog) { Find.FogGrid.Notify_FogBlockerDestroyed(Position); } if (def.holdsRoof) { RoofCollapseChecker.Notify_RoofHolderDestroyed(this); } if (def.leaveTerrain != null && Map.Initialized) { foreach (IntVec3 loc in GenAdj.SquaresOccupiedBy(this)) { Find.TerrainGrid.SetTerrain(loc, def.leaveTerrain); } } Find.ListerBuildings.Remove(this); if (TransmitsPower || def.ConnectToPower) { if (TransmitsPower) { PowerNetManager.Notify_TransmitterDespawned(this); } if (def.ConnectToPower) { PowerNetManager.Notify_ConnectorDespawned(this); } Find.MapDrawer.MapChanged(Position, MapChangeType.PowerGrid, true, false); } }
public virtual void Destroy(DestroyMode mode = DestroyMode.Vanish) { if (!Thing.allowDestroyNonDestroyable && !this.def.destroyable) { Log.Error("Tried to destroy non-destroyable thing " + this); return; } if (this.Destroyed) { Log.Error("Tried to destroy already-destroyed thing " + this); return; } bool spawned = this.Spawned; Map map = this.Map; if (this.Spawned) { this.DeSpawn(); } this.mapIndexOrState = -2; if (this.def.DiscardOnDestroyed) { this.Discard(false); } CompExplosive compExplosive = this.TryGetComp <CompExplosive>(); bool flag = compExplosive != null && compExplosive.destroyedThroughDetonation; if (spawned && !flag) { GenLeaving.DoLeavingsFor(this, map, mode); } if (this.holdingOwner != null) { this.holdingOwner.Notify_ContainedItemDestroyed(this); } this.RemoveAllReservationsAndDesignationsOnThis(); if (!(this is Pawn)) { this.stackCount = 0; } }
public static void PostFix(ref Func <int, int> __result, Thing destroyedThing, DestroyMode mode) { if (destroyedThing.def.defName.StartsWith("MSMedicalMat") && mode == DestroyMode.Deconstruct && destroyedThing.def.resourcesFractionWhenDeconstructed >= 1f) { if (!GenLeaving.CanBuildingLeaveResources(destroyedThing, mode)) { __result = ((int count) => 0); return; } if (mode == DestroyMode.Deconstruct && typeof(Frame).IsAssignableFrom(destroyedThing.GetType())) { mode = DestroyMode.Cancel; return; } if (mode == DestroyMode.Deconstruct) { __result = ((int count) => count); return; } } }
public virtual void Destroy(DestroyMode mode = DestroyMode.Vanish) { if (!allowDestroyNonDestroyable && !def.destroyable) { Log.Error("Tried to destroy non-destroyable thing " + this); } else if (Destroyed) { Log.Error("Tried to destroy already-destroyed thing " + this); } else { bool spawned = Spawned; Map map = Map; if (Spawned) { DeSpawn(mode); } mapIndexOrState = -2; if (def.DiscardOnDestroyed) { Discard(); } bool flag = this.TryGetComp <CompExplosive>()?.destroyedThroughDetonation ?? false; if (spawned && !flag) { GenLeaving.DoLeavingsFor(this, map, mode); } if (holdingOwner != null) { holdingOwner.Notify_ContainedItemDestroyed(this); } RemoveAllReservationsAndDesignationsOnThis(); if (!(this is Pawn)) { stackCount = 0; } } }
public static void Refund(Thing thing, Map map, CellRect avoidThisRect) { bool flag = false; if (thing.def.Minifiable) { MinifiedThing minifiedThing = thing.MakeMinified(); if (GenPlace.TryPlaceThing(minifiedThing, thing.Position, map, ThingPlaceMode.Near, null, (IntVec3 x) => !avoidThisRect.Contains(x))) { flag = true; } else { minifiedThing.GetDirectlyHeldThings().Clear(); minifiedThing.Destroy(DestroyMode.Vanish); } } if (!flag) { GenLeaving.DoLeavingsFor(thing, map, DestroyMode.Refund, thing.OccupiedRect(), (IntVec3 x) => !avoidThisRect.Contains(x)); thing.Destroy(DestroyMode.Vanish); } }
// Token: 0x060000F0 RID: 240 RVA: 0x00008874 File Offset: 0x00006A74 public static void Destroy_Prefix(Thing __instance, DestroyMode mode = DestroyMode.Vanish) { bool flag = !Thing.allowDestroyNonDestroyable && !__instance.def.destroyable; if (!flag) { bool destroyed = __instance.Destroyed; if (!destroyed) { bool spawned = __instance.Spawned; Map map = __instance.Map; bool spawned2 = __instance.Spawned; if (spawned2) { __instance.DeSpawn(mode); } sbyte value = Traverse.Create(typeof(Thing)).Field("mapIndexOrState").GetValue <sbyte>(); bool discardOnDestroyed = __instance.def.DiscardOnDestroyed; if (discardOnDestroyed) { __instance.Discard(false); } CompExplosive compExplosive = __instance.TryGetComp <CompExplosive>(); bool flag2 = compExplosive != null && compExplosive.destroyedThroughDetonation; bool flag3 = spawned && !flag2; if (flag3) { GenLeaving.DoLeavingsFor(__instance, map, mode, null); } bool flag4 = __instance.holdingOwner != null; if (flag4) { __instance.holdingOwner.Notify_ContainedItemDestroyed(__instance); } List <Map> maps = Find.Maps; for (int i = 0; i < maps.Count; i++) { bool flag5 = __instance.def.category == ThingCategory.Mote; if (flag5) { return; } bool flag6 = __instance.def.category != ThingCategory.Mote; if (flag6) { maps[i].reservationManager.ReleaseAllForTarget(__instance); maps[i].physicalInteractionReservationManager.ReleaseAllForTarget(__instance); IAttackTarget attackTarget = __instance as IAttackTarget; bool flag7 = attackTarget != null; if (flag7) { maps[i].attackTargetReservationManager.ReleaseAllForTarget(attackTarget); } maps[i].designationManager.RemoveAllDesignationsOn(__instance, false); } } bool flag8 = !(__instance is Pawn); if (flag8) { __instance.stackCount = 0; } } } }
public static bool TakeDamage_Prefix(Thing __instance, DamageInfo dinfo, ref DamageWorker.DamageResult __result) { if (__instance as Pawn == null) { return(true); } else { //Log.Message("Own TakeDamage"); //Log.Message("Log1"); if (__instance.Destroyed) { __result = DamageWorker.DamageResult.MakeNew(); } //Log.Message("Log2"); if (dinfo.Amount == 0) { __result = DamageWorker.DamageResult.MakeNew(); } //Log.Message("Log3"); if (__instance.def.damageMultipliers != null) { for (int i = 0; i < __instance.def.damageMultipliers.Count; i++) { if (__instance.def.damageMultipliers[i].damageDef == dinfo.Def) { int amount = Mathf.RoundToInt((float)dinfo.Amount * __instance.def.damageMultipliers[i].multiplier); dinfo.SetAmount(amount); } } } //Log.Message("Log4"); bool flag; __instance.PreApplyDamage(dinfo, out flag); if (flag) { __result = DamageWorker.DamageResult.MakeNew(); } //Log.Message("Log5"); bool spawnedOrAnyParentSpawned = __instance.SpawnedOrAnyParentSpawned; Map mapHeld = __instance.MapHeld; DamageWorker.DamageResult result = dinfo.Def.Worker.Apply(dinfo, __instance); if (dinfo.Def.harmsHealth && spawnedOrAnyParentSpawned) { mapHeld.damageWatcher.Notify_DamageTaken(__instance, result.totalDamageDealt); } //Log.Message("Log6"); if (dinfo.Def.externalViolence) { GenLeaving.DropFilthDueToDamage(__instance, result.totalDamageDealt); if (dinfo.Instigator != null) { Pawn pawn = dinfo.Instigator as Pawn; if (pawn != null) { pawn.records.AddTo(RecordDefOf.DamageDealt, result.totalDamageDealt); pawn.records.AccumulateStoryEvent(StoryEventDefOf.DamageDealt); } } } //Log.Message("Log7"); __instance.PostApplyDamage(dinfo, result.totalDamageDealt); __result = result; return(false); //return true; } }
public static bool DoLeavingsForPrefix(Thing diedThing, Map map, DestroyMode mode, CellRect leavingsRect, Predicate <IntVec3> nearPlaceValidator = null, List <Thing> listOfLeavingsOut = null) { bool flag = mode == DestroyMode.Deconstruct; bool result; if (flag) { ThingOwner <Thing> thingOwner = new ThingOwner <Thing>(); bool flag2 = GenLeaving.CanBuildingLeaveResources(diedThing, mode); if (flag2) { Frame frame = diedThing as Frame; bool flag3 = frame != null; if (flag3) { for (int i = frame.resourceContainer.Count - 1; i >= 0; i--) { int num = DeconstructReturnFix.CalcFix.GBRLC(diedThing, mode)(frame.resourceContainer[i].stackCount); bool flag4 = num > 0; if (flag4) { frame.resourceContainer.TryTransferToContainer(frame.resourceContainer[i], thingOwner, num, true); } } frame.resourceContainer.ClearAndDestroyContents(mode); } else { List <ThingDefCountClass> list = diedThing.CostListAdjusted(); for (int j = 0; j < list.Count; j++) { ThingDefCountClass thingDefCountClass = list[j]; int num2 = DeconstructReturnFix.CalcFix.GBRLC(diedThing, mode)(thingDefCountClass.count); bool flag5 = num2 > 0; if (flag5) { Thing thing = ThingMaker.MakeThing(thingDefCountClass.thingDef, null); thing.stackCount = num2; thingOwner.TryAdd(thing, true); } } } } List <IntVec3> list2 = leavingsRect.Cells.InRandomOrder(null).ToList <IntVec3>(); int num3 = 0; for (;;) { bool flag6 = thingOwner.Count > 0; if (!flag6) { goto IL_1B4; } ThingOwner <Thing> thingOwner2 = thingOwner; Thing thing2 = thingOwner[0]; IntVec3 dropLoc = list2[num3]; ThingPlaceMode mode2 = ThingPlaceMode.Near; Thing thing3 = null; bool flag7 = thingOwner2.TryDrop(thing2, dropLoc, map, mode2, out thing3, null, nearPlaceValidator); if (!flag7) { break; } num3++; bool flag8 = num3 >= list2.Count; if (flag8) { num3 = 0; } } Log.Warning(string.Concat(new object[] { "Deconstruct Return Fix: Failed to place all leavings for destroyed thing ", diedThing, " at ", leavingsRect.CenterCell }), false); return(false); IL_1B4: result = false; } else { result = true; } return(result); }
public static bool DoLeavingsForPrefix(Thing diedThing, Map map, DestroyMode mode, CellRect leavingsRect, Predicate <IntVec3> nearPlaceValidator = null) { if (mode != DestroyMode.Deconstruct) { return(true); //just to make it more readable } ThingOwner <Thing> thingOwner = new ThingOwner <Thing>(); if (GenLeaving.CanBuildingLeaveResources(diedThing, mode)) { Frame frame = diedThing as Frame; if (frame != null) { for (int frameResCt = frame.resourceContainer.Count - 1; frameResCt >= 0; frameResCt--) { int gblrc; if ((gblrc = GBRLC(diedThing)(frame.resourceContainer[frameResCt].stackCount)) > 0) { frame.resourceContainer.TryTransferToContainer(frame.resourceContainer[frameResCt], thingOwner, gblrc, true); } } frame.resourceContainer.ClearAndDestroyContents(mode); } else { // TODO: ModExtension specifying drop rates per ThingDef. Needs to be relatively optimized. List <ThingDefCountClass> list = diedThing.CostListAdjusted(); for (int l = 0; l < list.Count; l++) { ThingDefCountClass tdcc = list[l]; int gblrc; if ((gblrc = GBRLC(diedThing)(tdcc.count)) > 0) { Thing thing = ThingMaker.MakeThing(tdcc.thingDef, null); thing.stackCount = gblrc; thingOwner.TryAdd(thing, true); } } } } List <IntVec3> cellList = leavingsRect.Cells.InRandomOrder(null).ToList(); int cellInd = 0; while (true) { if (thingOwner.Count > 0) { ThingOwner <Thing> thingOwner2 = thingOwner; Thing thing = thingOwner[0]; IntVec3 dropLoc = cellList[cellInd]; ThingPlaceMode mode2 = ThingPlaceMode.Near; Thing thing4 = default(Thing); if (thingOwner2.TryDrop(thing, dropLoc, map, mode2, out thing4, null, nearPlaceValidator)) { cellInd++; if (cellInd >= cellList.Count) { cellInd = 0; } continue; } break; } return(false); } ULog.Warning("Deconstruct Return Fix: Failed to place all leavings for destroyed thing " + diedThing + " at " + leavingsRect.CenterCell, false); return(false); }//end DoLeavingsForPrefix
public override void Resolve(ResolveParams rp) { SpawnDescriptor[] array = new SpawnDescriptor[30] { new SpawnDescriptor { offset = new IntVec3(0, 0, 0), def = ThingDefOf.Ship_Reactor, rot = Rot4.North }, new SpawnDescriptor { offset = new IntVec3(0, 0, 12), def = ThingDefOf.Ship_Beam, rot = Rot4.North }, new SpawnDescriptor { offset = new IntVec3(0, 0, 6), def = ThingDefOf.Ship_Beam, rot = Rot4.North }, new SpawnDescriptor { offset = new IntVec3(-4, 0, -2), def = ThingDefOf.Ship_Beam, rot = Rot4.North }, new SpawnDescriptor { offset = new IntVec3(4, 0, -2), def = ThingDefOf.Ship_Beam, rot = Rot4.North }, new SpawnDescriptor { offset = new IntVec3(0, 0, -7), def = ThingDefOf.Ship_Beam, rot = Rot4.North }, new SpawnDescriptor { offset = new IntVec3(0, 0, 16), def = ThingDefOf.Ship_SensorCluster, rot = Rot4.North }, new SpawnDescriptor { offset = new IntVec3(3, 0, -7), def = ThingDefOf.Ship_ComputerCore, rot = Rot4.North }, new SpawnDescriptor { offset = new IntVec3(-1, 0, 15), def = ThingDefOf.Ship_CryptosleepCasket, rot = Rot4.West }, new SpawnDescriptor { offset = new IntVec3(-1, 0, 13), def = ThingDefOf.Ship_CryptosleepCasket, rot = Rot4.West }, new SpawnDescriptor { offset = new IntVec3(-1, 0, 11), def = ThingDefOf.Ship_CryptosleepCasket, rot = Rot4.West }, new SpawnDescriptor { offset = new IntVec3(-1, 0, 9), def = ThingDefOf.Ship_CryptosleepCasket, rot = Rot4.West }, new SpawnDescriptor { offset = new IntVec3(-1, 0, 7), def = ThingDefOf.Ship_CryptosleepCasket, rot = Rot4.West }, new SpawnDescriptor { offset = new IntVec3(-1, 0, 5), def = ThingDefOf.Ship_CryptosleepCasket, rot = Rot4.West }, new SpawnDescriptor { offset = new IntVec3(-4, 0, 2), def = ThingDefOf.Ship_CryptosleepCasket, rot = Rot4.North }, new SpawnDescriptor { offset = new IntVec3(-5, 0, 1), def = ThingDefOf.Ship_CryptosleepCasket, rot = Rot4.West }, new SpawnDescriptor { offset = new IntVec3(2, 0, 15), def = ThingDefOf.Ship_CryptosleepCasket, rot = Rot4.East }, new SpawnDescriptor { offset = new IntVec3(2, 0, 13), def = ThingDefOf.Ship_CryptosleepCasket, rot = Rot4.East }, new SpawnDescriptor { offset = new IntVec3(2, 0, 11), def = ThingDefOf.Ship_CryptosleepCasket, rot = Rot4.East }, new SpawnDescriptor { offset = new IntVec3(2, 0, 9), def = ThingDefOf.Ship_CryptosleepCasket, rot = Rot4.East }, new SpawnDescriptor { offset = new IntVec3(2, 0, 7), def = ThingDefOf.Ship_CryptosleepCasket, rot = Rot4.East }, new SpawnDescriptor { offset = new IntVec3(2, 0, 5), def = ThingDefOf.Ship_CryptosleepCasket, rot = Rot4.East }, new SpawnDescriptor { offset = new IntVec3(5, 0, 2), def = ThingDefOf.Ship_CryptosleepCasket, rot = Rot4.North }, new SpawnDescriptor { offset = new IntVec3(6, 0, 1), def = ThingDefOf.Ship_CryptosleepCasket, rot = Rot4.East }, new SpawnDescriptor { offset = new IntVec3(-6, 0, -3), def = ThingDefOf.Ship_Engine, rot = Rot4.North }, new SpawnDescriptor { offset = new IntVec3(7, 0, -3), def = ThingDefOf.Ship_Engine, rot = Rot4.North }, new SpawnDescriptor { offset = new IntVec3(3, 0, -11), def = ThingDefOf.Ship_Engine, rot = Rot4.North }, new SpawnDescriptor { offset = new IntVec3(-2, 0, -11), def = ThingDefOf.Ship_Engine, rot = Rot4.North }, new SpawnDescriptor { offset = new IntVec3(-1, 0, -8), def = ThingDefOf.Ship_CryptosleepCasket, rot = Rot4.West }, new SpawnDescriptor { offset = new IntVec3(-1, 0, -6), def = ThingDefOf.Ship_CryptosleepCasket, rot = Rot4.West } }; IntVec3 centerCell = rp.rect.CenterCell; IntVec3 b = new IntVec3(-1, 0, -3); SpawnDescriptor[] array2 = array; for (int i = 0; i < array2.Length; i++) { SpawnDescriptor spawnDescriptor = array2[i]; Thing thing = ThingMaker.MakeThing(spawnDescriptor.def, null); thing.SetFaction(rp.faction, null); if (rp.hpPercentRange.HasValue) { thing.HitPoints = Mathf.Clamp(Mathf.RoundToInt((float)thing.MaxHitPoints * rp.hpPercentRange.Value.RandomInRange), 1, thing.MaxHitPoints); GenLeaving.DropFilthDueToDamage(thing, (float)(thing.MaxHitPoints - thing.HitPoints)); } CompHibernatable compHibernatable = thing.TryGetComp <CompHibernatable>(); if (compHibernatable != null) { compHibernatable.State = HibernatableStateDefOf.Hibernating; } GenSpawn.Spawn(thing, centerCell + b + spawnDescriptor.offset, BaseGen.globalSettings.map, spawnDescriptor.rot, false); } }
public static bool TakeDamage(Thing __instance, ref DamageWorker.DamageResult __result, DamageInfo dinfo) { //---START change--- Map mapHeld = __instance.MapHeld; //moved if (mapHeld == null) { __result = new DamageWorker.DamageResult(); return(false); } //---END change--- if (__instance.Destroyed) { __result = new DamageWorker.DamageResult(); return(false); } if ((double)dinfo.Amount == 0.0) { __result = new DamageWorker.DamageResult(); return(false); } if (__instance.def.damageMultipliers != null) { for (int index = 0; index < __instance.def.damageMultipliers.Count; ++index) { if (__instance.def.damageMultipliers[index].damageDef == dinfo.Def) { int num = Mathf.RoundToInt(dinfo.Amount * __instance.def.damageMultipliers[index].multiplier); dinfo.SetAmount((float)num); } } } bool absorbed; __instance.PreApplyDamage(ref dinfo, out absorbed); if (absorbed) { __result = new DamageWorker.DamageResult(); return(false); } bool anyParentSpawned = __instance.SpawnedOrAnyParentSpawned; // Map mapHeld = __instance.MapHeld; //moved DamageWorker.DamageResult damageResult = dinfo.Def.Worker.Apply(dinfo, __instance); if (dinfo.Def.harmsHealth & anyParentSpawned) { mapHeld.damageWatcher.Notify_DamageTaken(__instance, damageResult.totalDamageDealt); } if (dinfo.Def.ExternalViolenceFor(__instance)) { #if RW13 if (dinfo.SpawnFilth) #endif GenLeaving.DropFilthDueToDamage(__instance, damageResult.totalDamageDealt); if (dinfo.Instigator != null && dinfo.Instigator is Pawn instigator2) { if (instigator2 != null) { instigator2.records.AddTo(RecordDefOf.DamageDealt, damageResult.totalDamageDealt); #if RW12 instigator2.records.AccumulateStoryEvent(StoryEventDefOf.DamageDealt); #endif } } } __instance.PostApplyDamage(dinfo, damageResult.totalDamageDealt); __result = damageResult; return(false); }