private static void DropRoofInCellPhaseOne(IntVec3 c, Map map, List <Thing> outCrushedThings)
{
RoofDef roofDef = map.roofGrid.RoofAt(c);
if (roofDef != null)
{
if (roofDef.collapseLeavingThingDef != null && roofDef.collapseLeavingThingDef.passability == Traversability.Impassable)
{
for (int i = 0; i < 2; i++)
{
List <Thing> thingList = c.GetThingList(map);
for (int j = thingList.Count - 1; j >= 0; j--)
{
Thing thing = thingList[j];
RoofCollapserImmediate.TryAddToCrushedThingsList(thing, outCrushedThings);
Pawn pawn = thing as Pawn;
DamageInfo dinfo;
if (pawn != null)
{
DamageDef crush = DamageDefOf.Crush;
float amount = 99999f;
float armorPenetration = 999f;
BodyPartRecord brain = pawn.health.hediffSet.GetBrain();
dinfo = new DamageInfo(crush, amount, armorPenetration, -1f, null, brain, null, DamageInfo.SourceCategory.Collapse, null);
}
else
{
dinfo = new DamageInfo(DamageDefOf.Crush, 99999f, 999f, -1f, null, null, null, DamageInfo.SourceCategory.Collapse, null);
dinfo.SetBodyRegion(BodyPartHeight.Top, BodyPartDepth.Outside);
}
BattleLogEntry_DamageTaken battleLogEntry_DamageTaken = null;
if (i == 0 && pawn != null)
{
battleLogEntry_DamageTaken = new BattleLogEntry_DamageTaken(pawn, RulePackDefOf.DamageEvent_Ceiling, null);
Find.BattleLog.Add(battleLogEntry_DamageTaken);
}
thing.TakeDamage(dinfo).AssociateWithLog(battleLogEntry_DamageTaken);
if (!thing.Destroyed && thing.def.destroyable)
{
thing.Destroy(DestroyMode.Vanish);
}
}
}
}
else
{
List <Thing> thingList2 = c.GetThingList(map);
for (int k = thingList2.Count - 1; k >= 0; k--)
{
Thing thing2 = thingList2[k];
if (thing2.def.category == ThingCategory.Item || thing2.def.category == ThingCategory.Plant || thing2.def.category == ThingCategory.Building || thing2.def.category == ThingCategory.Pawn)
{
RoofCollapserImmediate.TryAddToCrushedThingsList(thing2, outCrushedThings);
float num = (float)RoofCollapserImmediate.ThinRoofCrushDamageRange.RandomInRange;
if (thing2.def.building != null)
{
num *= thing2.def.building.roofCollapseDamageMultiplier;
}
BattleLogEntry_DamageTaken battleLogEntry_DamageTaken2 = null;
if (thing2 is Pawn)
{
battleLogEntry_DamageTaken2 = new BattleLogEntry_DamageTaken((Pawn)thing2, RulePackDefOf.DamageEvent_Ceiling, null);
Find.BattleLog.Add(battleLogEntry_DamageTaken2);
}
DamageInfo dinfo2 = new DamageInfo(DamageDefOf.Crush, (float)GenMath.RoundRandom(num), 0f, -1f, null, null, null, DamageInfo.SourceCategory.Collapse, null);
dinfo2.SetBodyRegion(BodyPartHeight.Top, BodyPartDepth.Outside);
thing2.TakeDamage(dinfo2).AssociateWithLog(battleLogEntry_DamageTaken2);
}
}
}
if (roofDef.collapseLeavingThingDef != null)
{
Thing thing3 = GenSpawn.Spawn(roofDef.collapseLeavingThingDef, c, map, WipeMode.Vanish);
if (thing3.def.rotatable)
{
thing3.Rotation = Rot4.Random;
}
}
for (int l = 0; l < 1; l++)
{
Vector3 vector = c.ToVector3Shifted();
vector += Gen.RandomHorizontalVector(0.6f);
MoteMaker.ThrowDustPuff(vector, map, 2f);
}
}
}
protected void MakeMote(TargetInfo A, TargetInfo B)
{
Vector3 vector = Vector3.zero;
switch (this.def.spawnLocType)
{
case MoteSpawnLocType.OnSource:
vector = A.CenterVector3;
break;
case MoteSpawnLocType.BetweenPositions:
{
Vector3 vector2 = (!A.HasThing) ? A.Cell.ToVector3Shifted() : A.Thing.DrawPos;
Vector3 vector3 = (!B.HasThing) ? B.Cell.ToVector3Shifted() : B.Thing.DrawPos;
if (A.HasThing && !A.Thing.Spawned)
{
vector = vector3;
}
else if (B.HasThing && !B.Thing.Spawned)
{
vector = vector2;
}
else
{
vector = vector2 * this.def.positionLerpFactor + vector3 * (1f - this.def.positionLerpFactor);
}
break;
}
case MoteSpawnLocType.BetweenTouchingCells:
vector = A.Cell.ToVector3Shifted() + (B.Cell - A.Cell).ToVector3().normalized * 0.5f;
break;
case MoteSpawnLocType.RandomCellOnTarget:
{
CellRect cellRect;
if (B.HasThing)
{
cellRect = B.Thing.OccupiedRect();
}
else
{
cellRect = CellRect.CenteredOn(B.Cell, 0);
}
vector = cellRect.RandomCell.ToVector3Shifted();
break;
}
}
if (this.parent != null)
{
Rand.PushState(this.parent.GetHashCode());
if (A.CenterVector3 != B.CenterVector3)
{
vector += (B.CenterVector3 - A.CenterVector3).normalized * this.parent.def.offsetTowardsTarget.RandomInRange;
}
vector += Gen.RandomHorizontalVector(this.parent.def.positionRadius);
Rand.PopState();
}
Map map = A.Map ?? B.Map;
float num = (!this.def.absoluteAngle) ? (B.Cell - A.Cell).AngleFlat : 0f;
if (map != null && vector.ShouldSpawnMotesAt(map))
{
int randomInRange = this.def.burstCount.RandomInRange;
for (int i = 0; i < randomInRange; i++)
{
Mote mote = (Mote)ThingMaker.MakeThing(this.def.moteDef, null);
GenSpawn.Spawn(mote, vector.ToIntVec3(), map, WipeMode.Vanish);
mote.Scale = this.def.scale.RandomInRange;
mote.exactPosition = vector + Gen.RandomHorizontalVector(this.def.positionRadius);
mote.rotationRate = this.def.rotationRate.RandomInRange;
mote.exactRotation = this.def.rotation.RandomInRange + num;
MoteThrown moteThrown = mote as MoteThrown;
if (moteThrown != null)
{
moteThrown.airTimeLeft = this.def.airTime.RandomInRange;
moteThrown.SetVelocity(this.def.angle.RandomInRange + num, this.def.speed.RandomInRange);
}
}
}
}
public void FinalizeLoading()
{
List <Thing> list = this.compressor.ThingsToSpawnAfterLoad().ToList <Thing>();
this.compressor = null;
DeepProfiler.Start("Merge compressed and non-compressed thing lists");
List <Thing> list2 = new List <Thing>(this.loadedFullThings.Count + list.Count);
foreach (Thing current in this.loadedFullThings.Concat(list))
{
list2.Add(current);
}
this.loadedFullThings.Clear();
DeepProfiler.End();
DeepProfiler.Start("Spawn everything into the map");
BackCompatibility.PreCheckSpawnBackCompatibleThingAfterLoading(this);
foreach (Thing current2 in list2)
{
if (!(current2 is Building))
{
try
{
if (!BackCompatibility.CheckSpawnBackCompatibleThingAfterLoading(current2, this))
{
GenSpawn.Spawn(current2, current2.Position, this, current2.Rotation, WipeMode.FullRefund, true);
}
}
catch (Exception ex)
{
Log.Error(string.Concat(new object[]
{
"Exception spawning loaded thing ",
current2.ToStringSafe <Thing>(),
": ",
ex
}), false);
}
}
}
foreach (Building current3 in from t in list2.OfType <Building>()
orderby t.def.size.Magnitude
select t)
{
try
{
GenSpawn.SpawnBuildingAsPossible(current3, this, true);
}
catch (Exception ex2)
{
Log.Error(string.Concat(new object[]
{
"Exception spawning loaded thing ",
current3.ToStringSafe <Building>(),
": ",
ex2
}), false);
}
}
BackCompatibility.PostCheckSpawnBackCompatibleThingAfterLoading(this);
DeepProfiler.End();
this.FinalizeInit();
}
protected override bool TryCastShot()
{
if (this.currentTarget.HasThing && this.currentTarget.Thing.Map != this.caster.Map)
{
return(false);
}
// ThingDef projectile = this.Projectile;
ThingDef projectile = this.Projectile;
// projectile.projectileWhenLoaded.
if (projectile == null)
{
return(false);
}
ShootLine shootLine;
bool flag = base.TryFindShootLineFromTo(this.caster.Position, this.currentTarget, out shootLine);
if (this.verbProps.stopBurstWithoutLos && !flag)
{
return(false);
}
if (this.EquipmentSource != null)
{
CompChangeableProjectile comp = this.EquipmentSource.GetComp <CompChangeableProjectile>();
if (comp != null)
{
comp.Notify_ProjectileLaunched();
}
}
Thing launcher = this.caster;
Thing equipment = this.EquipmentSource;
CompMannable compMannable = this.caster.TryGetComp <CompMannable>();
if (compMannable != null && compMannable.ManningPawn != null)
{
launcher = compMannable.ManningPawn;
equipment = this.caster;
}
Vector3 drawPos = this.caster.DrawPos;
Projectile projectile2 = (Projectile)GenSpawn.Spawn(projectile, shootLine.Source, this.caster.Map);
//---------------
int pellets = this.PelletsPerShot(projectile);
if (pellets < 1)
{
pellets = 1;
}
Projectile[] projectiles = new Projectile[pellets];
ShootLine[] shootLines = new ShootLine[pellets];
for (int i = 0; i < pellets; i++)
{
base.TryFindShootLineFromTo(this.caster.Position, this.currentTarget, out shootLines[i]);
projectiles[i] = (Projectile)GenSpawn.Spawn(projectile, shootLines[i].Source, this.caster.Map);
//projectiles[i].FreeIntercept = (this.canFreeInterceptNow && !projectiles[i].def.projectile.flyOverhead);
}
//projectile2.FreeIntercept = (this.canFreeInterceptNow && !projectile2.def.projectile.flyOverhead);
//projectile3.FreeIntercept = (this.canFreeInterceptNow && !projectile2.def.projectile.flyOverhead);
//projectile4.FreeIntercept = (this.canFreeInterceptNow && !projectile2.def.projectile.flyOverhead);
float distance = (float)(this.currentTarget.Cell - this.caster.Position).LengthHorizontal;
float scatter = ScatterRadiusAt10tilesAway(projectile) * distance / 10.0f;
float missRadius = this.verbProps.forcedMissRadius + ForsedScatterRadius(projectile) + scatter;
for (int i = 0; i < pellets; i++)
{
if (missRadius > 0.5f)
{
float num = (float)(this.currentTarget.Cell - this.caster.Position).LengthHorizontalSquared;
float num2;
if (num < 9f)
{
num2 = 0f;
}
else if (num < 25f)
{
num2 = missRadius * 0.5f;
}
else if (num < 49f)
{
num2 = missRadius * 0.8f;
}
else
{
num2 = missRadius * 1f;
}
if (num2 > 0.5f)
{
int max = GenRadial.NumCellsInRadius(missRadius);
//int num3 = Rand.Range(0, max);
int num3 = Rand.Range(0, max);
if (num3 > 0)
{
if (DebugViewSettings.drawShooting)
{
MoteMaker.ThrowText(this.caster.DrawPos, this.caster.Map, "ToForRad", -1f);
}
//if (this.currentTarget.HasThing)
//{
// // projectile2.ThingToNeverIntercept = this.currentTarget.Thing;
// projectiles[i].ThingToNeverIntercept = this.currentTarget.Thing;
//}
//if (!projectiles[i].def.projectile.flyOverhead)
//{
// projectiles[i].InterceptWalls = true;
//}
IntVec3 c = this.currentTarget.Cell + GenRadial.RadialPattern[num3];
projectiles[i].Launch(launcher, origin: drawPos, usedTarget: new LocalTargetInfo(c), intendedTarget: currentTarget, hitFlags: projectiles[i].HitFlags, equipment: equipment);
//projectile2.Launch(launcher, drawPos, c, equipment, this.currentTarget.Thing);
//projectile3.Launch(launcher, drawPos, c, equipment, this.currentTarget.Thing);
//projectile4.Launch(launcher, drawPos, c, equipment, this.currentTarget.Thing);
continue;// return true;
}
else
{
projectiles[i].Launch(launcher, origin: drawPos, usedTarget: new LocalTargetInfo(this.currentTarget.Cell), intendedTarget: currentTarget, hitFlags: projectiles[i].HitFlags, equipment: equipment);
//projectiles[i].Launch(launcher, drawPos, this.currentTarget.Cell, equipment, this.currentTarget.Thing);
continue;
}
}
}
ShotReport shotReport = ShotReport.HitReportFor(this.caster, this, this.currentTarget);
if (Rand.Value > shotReport.AimOnTargetChance_IgnoringPosture)
{
if (DebugViewSettings.drawShooting)
{
MoteMaker.ThrowText(this.caster.DrawPos, this.caster.Map, "ToWild", -1f);
}
shootLines[i].ChangeDestToMissWild(shotReport.AimOnTargetChance);
// shootLine2.ChangeDestToMissWild();
if (this.currentTarget.HasThing)
{
projectiles[i].HitFlags = ProjectileHitFlags.All;
// projectile2.ThingToNeverIntercept = this.currentTarget.Thing;
}
if (!projectiles[i].def.projectile.flyOverhead)
{
projectiles[i].HitFlags = ProjectileHitFlags.IntendedTarget;
}
projectiles[i].Launch(launcher, origin: drawPos, usedTarget: new LocalTargetInfo(shootLines[i].Dest), intendedTarget: currentTarget, hitFlags: projectiles[i].HitFlags, equipment: equipment);
//projectiles[i].Launch(launcher, drawPos, shootLines[i].Dest, equipment, this.currentTarget.Thing);
//projectile2.Launch(launcher, drawPos, shootLine2.Dest, equipment, this.currentTarget.Thing);
continue;//return true;
}
if (Rand.Value > shotReport.PassCoverChance)
{
if (DebugViewSettings.drawShooting)
{
MoteMaker.ThrowText(this.caster.DrawPos, this.caster.Map, "ToCover", -1f);
}
if (this.currentTarget.Thing != null && this.currentTarget.Thing.def.category == ThingCategory.Pawn)
{
Thing randomCoverToMissInto = shotReport.GetRandomCoverToMissInto();
if (!projectiles[i].def.projectile.flyOverhead)
{
projectiles[i].HitFlags = ProjectileHitFlags.IntendedTarget;
}
projectiles[i].Launch(launcher, origin: drawPos, usedTarget: new LocalTargetInfo(randomCoverToMissInto), intendedTarget: currentTarget, hitFlags: projectiles[i].HitFlags, equipment: equipment);
//projectiles[i].Launch(launcher, drawPos, randomCoverToMissInto, equipment, this.currentTarget.Thing);
//projectile2.Launch(launcher, drawPos, randomCoverToMissInto, equipment, this.currentTarget.Thing);
continue;//return true;
}
}
if (DebugViewSettings.drawShooting)
{
MoteMaker.ThrowText(this.caster.DrawPos, this.caster.Map, "ToHit", -1f);
}
if (!projectiles[i].def.projectile.flyOverhead && (!this.currentTarget.HasThing || this.currentTarget.Thing.def.Fillage == FillCategory.Full))
{
projectiles[i].HitFlags = ProjectileHitFlags.IntendedTarget;
}
if (this.currentTarget.Thing != null)
{
projectiles[i].Launch(launcher, origin: drawPos, usedTarget: currentTarget, intendedTarget: currentTarget, hitFlags: projectiles[i].HitFlags, equipment: equipment);
//projectiles[i].Launch(launcher, drawPos, this.currentTarget, equipment, this.currentTarget.Thing);
}
else
{
projectiles[i].Launch(launcher, origin: drawPos, usedTarget: new LocalTargetInfo(shootLines[i].Dest), intendedTarget: currentTarget, hitFlags: projectiles[i].HitFlags, equipment: equipment);
//projectiles[i].Launch(launcher, drawPos, shootLines[i].Dest, equipment, this.currentTarget.Thing);
}
}
return(true);
}
protected override bool TryCastShot()
{
if (currentTarget.HasThing && currentTarget.Thing.Map != caster.Map)
{
return(false);
}
ThingDef projectile = Projectile;
if (projectile == null)
{
return(false);
}
ShootLine resultingLine;
bool flag = TryFindShootLineFromTo(caster.Position, currentTarget, out resultingLine);
if (verbProps.stopBurstWithoutLos && !flag)
{
return(false);
}
if (base.EquipmentSource != null)
{
base.EquipmentSource.GetComp <CompChangeableProjectile>()?.Notify_ProjectileLaunched();
}
Thing launcher = caster;
Thing equipment = base.EquipmentSource;
CompMannable compMannable = caster.TryGetComp <CompMannable>();
if (compMannable != null && compMannable.ManningPawn != null)
{
launcher = compMannable.ManningPawn;
equipment = caster;
}
Vector3 drawPos = caster.DrawPos;
Projectile projectile2 = (Projectile)GenSpawn.Spawn(projectile, resultingLine.Source, caster.Map);
if (verbProps.forcedMissRadius > 0.5f)
{
float num = VerbUtility.CalculateAdjustedForcedMiss(verbProps.forcedMissRadius, currentTarget.Cell - caster.Position);
if (num > 0.5f)
{
int max = GenRadial.NumCellsInRadius(num);
int num2 = Rand.Range(0, max);
if (num2 > 0)
{
IntVec3 c = currentTarget.Cell + GenRadial.RadialPattern[num2];
ThrowDebugText("ToRadius");
ThrowDebugText("Rad\nDest", c);
ProjectileHitFlags projectileHitFlags = ProjectileHitFlags.NonTargetWorld;
if (Rand.Chance(0.5f))
{
projectileHitFlags = ProjectileHitFlags.All;
}
if (!canHitNonTargetPawnsNow)
{
projectileHitFlags &= ~ProjectileHitFlags.NonTargetPawns;
}
projectile2.Launch(launcher, drawPos, c, currentTarget, projectileHitFlags, equipment);
return(true);
}
}
}
ShotReport shotReport = ShotReport.HitReportFor(caster, this, currentTarget);
Thing randomCoverToMissInto = shotReport.GetRandomCoverToMissInto();
ThingDef targetCoverDef = randomCoverToMissInto?.def;
if (!Rand.Chance(shotReport.AimOnTargetChance_IgnoringPosture))
{
resultingLine.ChangeDestToMissWild(shotReport.AimOnTargetChance_StandardTarget);
ThrowDebugText("ToWild" + (canHitNonTargetPawnsNow ? "\nchntp" : ""));
ThrowDebugText("Wild\nDest", resultingLine.Dest);
ProjectileHitFlags projectileHitFlags2 = ProjectileHitFlags.NonTargetWorld;
if (Rand.Chance(0.5f) && canHitNonTargetPawnsNow)
{
projectileHitFlags2 |= ProjectileHitFlags.NonTargetPawns;
}
projectile2.Launch(launcher, drawPos, resultingLine.Dest, currentTarget, projectileHitFlags2, equipment, targetCoverDef);
return(true);
}
if (currentTarget.Thing != null && currentTarget.Thing.def.category == ThingCategory.Pawn && !Rand.Chance(shotReport.PassCoverChance))
{
ThrowDebugText("ToCover" + (canHitNonTargetPawnsNow ? "\nchntp" : ""));
ThrowDebugText("Cover\nDest", randomCoverToMissInto.Position);
ProjectileHitFlags projectileHitFlags3 = ProjectileHitFlags.NonTargetWorld;
if (canHitNonTargetPawnsNow)
{
projectileHitFlags3 |= ProjectileHitFlags.NonTargetPawns;
}
projectile2.Launch(launcher, drawPos, randomCoverToMissInto, currentTarget, projectileHitFlags3, equipment, targetCoverDef);
return(true);
}
ProjectileHitFlags projectileHitFlags4 = ProjectileHitFlags.IntendedTarget;
if (canHitNonTargetPawnsNow)
{
projectileHitFlags4 |= ProjectileHitFlags.NonTargetPawns;
}
if (!currentTarget.HasThing || currentTarget.Thing.def.Fillage == FillCategory.Full)
{
projectileHitFlags4 |= ProjectileHitFlags.NonTargetWorld;
}
ThrowDebugText("ToHit" + (canHitNonTargetPawnsNow ? "\nchntp" : ""));
if (currentTarget.Thing != null)
{
projectile2.Launch(launcher, drawPos, currentTarget, currentTarget, projectileHitFlags4, equipment, targetCoverDef);
ThrowDebugText("Hit\nDest", currentTarget.Cell);
}
else
{
projectile2.Launch(launcher, drawPos, resultingLine.Dest, currentTarget, projectileHitFlags4, equipment, targetCoverDef);
ThrowDebugText("Hit\nDest", resultingLine.Dest);
}
return(true);
}
private static void DropRoofInCellPhaseOne(IntVec3 c, Map map)
{
RoofDef roofDef = map.roofGrid.RoofAt(c);
if (roofDef != null)
{
if (roofDef.collapseLeavingThingDef != null && roofDef.collapseLeavingThingDef.passability == Traversability.Impassable)
{
for (int i = 0; i < 2; i++)
{
List <Thing> thingList = c.GetThingList(map);
for (int num = thingList.Count - 1; num >= 0; num--)
{
Thing thing = thingList[num];
map.roofCollapseBuffer.Notify_Crushed(thing);
Pawn pawn = thing as Pawn;
DamageInfo dinfo = default(DamageInfo);
if (pawn != null)
{
DamageDef crush = DamageDefOf.Crush;
int amount = 99999;
BodyPartRecord brain = pawn.health.hediffSet.GetBrain();
dinfo = new DamageInfo(crush, amount, -1f, null, brain, null, DamageInfo.SourceCategory.Collapse);
}
else
{
dinfo = new DamageInfo(DamageDefOf.Crush, 99999, -1f, null, null, null, DamageInfo.SourceCategory.Collapse);
dinfo.SetBodyRegion(BodyPartHeight.Top, BodyPartDepth.Outside);
}
BattleLogEntry_DamageTaken battleLogEntry_DamageTaken = null;
if (i == 0 && pawn != null)
{
battleLogEntry_DamageTaken = new BattleLogEntry_DamageTaken(pawn, RulePackDefOf.DamageEvent_Ceiling, null);
Find.BattleLog.Add(battleLogEntry_DamageTaken);
}
thing.TakeDamage(dinfo).InsertIntoLog(battleLogEntry_DamageTaken);
if (!thing.Destroyed && thing.def.destroyable)
{
thing.Destroy(DestroyMode.Vanish);
}
}
}
}
else
{
List <Thing> thingList2 = c.GetThingList(map);
for (int num2 = thingList2.Count - 1; num2 >= 0; num2--)
{
Thing thing2 = thingList2[num2];
if (thing2.def.category == ThingCategory.Item || thing2.def.category == ThingCategory.Plant || thing2.def.category == ThingCategory.Building || thing2.def.category == ThingCategory.Pawn)
{
map.roofCollapseBuffer.Notify_Crushed(thing2);
float num3 = (float)RoofCollapserImmediate.ThinRoofCrushDamageRange.RandomInRange;
if (thing2.def.building != null)
{
num3 *= thing2.def.building.roofCollapseDamageMultiplier;
}
BattleLogEntry_DamageTaken battleLogEntry_DamageTaken2 = null;
if (thing2 is Pawn)
{
battleLogEntry_DamageTaken2 = new BattleLogEntry_DamageTaken(thing2 as Pawn, RulePackDefOf.DamageEvent_Ceiling, null);
Find.BattleLog.Add(battleLogEntry_DamageTaken2);
}
DamageInfo dinfo2 = new DamageInfo(DamageDefOf.Crush, GenMath.RoundRandom(num3), -1f, null, null, null, DamageInfo.SourceCategory.Collapse);
dinfo2.SetBodyRegion(BodyPartHeight.Top, BodyPartDepth.Outside);
thing2.TakeDamage(dinfo2).InsertIntoLog(battleLogEntry_DamageTaken2);
}
}
}
if (roofDef.collapseLeavingThingDef != null)
{
Thing thing3 = GenSpawn.Spawn(roofDef.collapseLeavingThingDef, c, map);
if (thing3.def.rotatable)
{
thing3.Rotation = Rot4.Random;
}
}
for (int j = 0; j < 1; j++)
{
Vector3 a = c.ToVector3Shifted();
a += Gen.RandomHorizontalVector(0.6f);
MoteMaker.ThrowDustPuff(a, map, 2f);
}
}
}
public static Thing Spawn(ThingDef def, IntVec3 loc, Map map)
{
return(GenSpawn.Spawn(ThingMaker.MakeThing(def, null), loc, map));
}
public static Thing Spawn(Thing newThing, IntVec3 loc, Map map)
{
return(GenSpawn.Spawn(newThing, loc, map, Rot4.North, false));
}
public static Thing Spawn(Thing newThing, IntVec3 loc, Map map, WipeMode wipeMode = WipeMode.Vanish)
{
return(GenSpawn.Spawn(newThing, loc, map, Rot4.North, wipeMode, false));
}
public static Thing Spawn(ThingDef def, IntVec3 loc, Map map, WipeMode wipeMode = WipeMode.Vanish)
{
return(GenSpawn.Spawn(ThingMaker.MakeThing(def, null), loc, map, wipeMode));
}
