public override void PostMake()
{
base.PostMake();
powerComp = GetComp <CompPowerTrader>();
refuelableComp = GetComp <CompRefuelable>();
outputComp = GetComp <CompOutputAdjustable>();
}
protected override bool TryCastShot()
{
if (burstShotsLeft > 1)
{
RatkinSoundDefOf.RK_Charge.PlayOneShot(new TargetInfo(caster.Position, caster.Map, false));
if (verbProps.consumeFuelPerShot > 0f)
{
CompRefuelable compGunlance = EquipmentSource.TryGetComp <CompGunlanceFuel>();
if (compGunlance != null)
{
compGunlance.ConsumeFuel(verbProps.consumeFuelPerShot);
}
}
AttachableThing_GunlanceIgnition ignition = ThingMaker.MakeThing(GunlanceDefOf.GunlancePreIgnition, null) as AttachableThing_GunlanceIgnition;
ignition.AttachTo(CasterPawn);
GenSpawn.Spawn(ignition, CasterPawn.Position, CasterPawn.Map, caster.Rotation, WipeMode.Vanish, false);
}
else
{
CasterPawn.GetAttachment(GunlanceDefOf.GunlancePreIgnition).Destroy();
AttachableThing_AfterIgnition ignition = ThingMaker.MakeThing(GunlanceDefOf.GunlanceAfterIgnition, null) as AttachableThing_AfterIgnition;
ignition.AttachTo(CasterPawn);
GenSpawn.Spawn(ignition, CasterPawn.Position, CasterPawn.Map, caster.Rotation, WipeMode.Vanish, false);
RatkinSoundDefOf.RK_WyvernFire.PlayOneShot(new TargetInfo(caster.Position, caster.Map, false));
MakeExplosion();
}
return(true);
}
public override void PostSpawnSetup(bool respawningAfterLoad)
{
base.PostSpawnSetup(respawningAfterLoad);
if (Props.dependsOnPower)
{
powerComp = this.parent.GetComp <CompPowerTrader>();
}
if (Props.dependsOnFuel)
{
fuelComp = this.parent.GetComp <CompRefuelable>();
}
if (Props.dependsOnGas)
{
gasComp = GetGasComp();
}
if (Props.flickable)
{
compFlickable = this.parent.GetComp <CompFlickable>();
}
if (!Props.dependsOnFuel && !Props.dependsOnPower)
{
active = true;
}
tempControlComp = this.parent.GetComp <CompTempControl>();
this.position = this.parent.Position;
this.map = this.parent.Map;
this.proxyHeatManager = this.map.GetComponent <ProxyHeatManager>();
if (Props.dependsOnPower || Props.dependsOnFuel || Props.dependsOnGas || Props.flickable)
{
this.proxyHeatManager.compTemperaturesToTick.Add(this);
}
this.MarkDirty();
}
public override void SpawnSetup(Map map, bool respawningAfterLoad)
{
base.SpawnSetup(map, respawningAfterLoad);
powerComp = GetComp <CompPowerTrader>();
refuelableComp = GetComp <CompRefuelable>();
outputComp = GetComp <CompOutputAdjustable>();
}
public override void Resolve(ResolveParams rp)
{
Map map = BaseGen.globalSettings.map;
refuelables.Clear();
foreach (IntVec3 item in rp.rect)
{
List <Thing> thingList = item.GetThingList(map);
for (int i = 0; i < thingList.Count; i++)
{
CompRefuelable compRefuelable = thingList[i].TryGetComp <CompRefuelable>();
if (compRefuelable != null && !refuelables.Contains(compRefuelable))
{
refuelables.Add(compRefuelable);
}
}
}
for (int j = 0; j < refuelables.Count; j++)
{
float fuelCapacity = refuelables[j].Props.fuelCapacity;
float amount = Rand.Range(fuelCapacity / 2f, fuelCapacity);
refuelables[j].Refuel(amount);
}
refuelables.Clear();
}
public override void PostSpawnSetup(bool respawningAfterLoad)
{
base.PostSpawnSetup(respawningAfterLoad);
this.stoneComp = this.parent.GetComp <CompExtinguishable>();
this.refuelableComp = this.parent.GetComp <CompRefuelable>();
this.breakdownableComp = this.parent.GetComp <CompBreakdownable>();
}
private void checkRefuelNeeded()
{
refuelNeeded = false;
refuelNeededNow = false;
List <Thing> list = this.map.listerThings.ThingsInGroup(ThingRequestGroup.Refuelable);
foreach (Thing thing in list)
{
CompRefuelable refuel = thing.TryGetComp <CompRefuelable>();
if (refuel == null)
{
continue;
}
if (!refuel.HasFuel)
{
refuelNeeded = true;
refuelNeededNow = true;
return;
}
if (!refuel.IsFull)
{
refuelNeeded = true;
continue;
}
}
}
static void Prefix(CompRefuelable __instance, ref Thing fuelThing)
{
if (Util.IsCarbonThing(fuelThing))
{
fuelThing.stackCount *= 3;
}
}
public override void SpawnSetup(Map map, bool respawningAfterLoad)
{
//this needs to be called before base.SpawnSetup for the init implementation of droneSkillsRecord in Building_DroneStation
refuelableComp = GetComp <CompRefuelable>();
base.SpawnSetup(map, respawningAfterLoad);
}
private static bool CanRefuel(Pawn pawn, Thing t, bool forced)
{
CompRefuelable compRefuelable = t.TryGetComp <CompRefuelable>();
if (compRefuelable == null || compRefuelable.IsFull || !compRefuelable.allowAutoRefuel || !compRefuelable.ShouldAutoRefuelNow)
{
return(false);
}
if (t.IsForbiddenForPrisoner(pawn) || !pawn.CanReserve(t, 1, -1, null, forced))
{
return(false);
}
if (Traverse.Create(typeof(RefuelWorkGiverUtility)).Method("FindBestFuel", new[] { pawn, t }).GetValue <Thing>() == null)
{
ThingFilter fuelFilter = t.TryGetComp <CompRefuelable>().Props.fuelFilter;
JobFailReason.Is("NoFuelToRefuel".Translate(fuelFilter.Summary));
return(false);
}
if (t.TryGetComp <CompRefuelable>().Props.atomicFueling&& Traverse.Create(typeof(RefuelWorkGiverUtility)).Method("FindAllFuel", new[] { pawn, t }).GetValue <List <Thing> >() == null)
{
ThingFilter fuelFilter2 = t.TryGetComp <CompRefuelable>().Props.fuelFilter;
JobFailReason.Is("NoFuelToRefuel".Translate(fuelFilter2.Summary));
return(false);
}
return(true);
}
public override void PostMake()
{
base.PostMake();
refuelableComp = GetComp <CompRefuelable>();
refuelableComp.Refuel(extension.GetDronesOnSpawn(refuelableComp));
}
public override void PostSpawnSetup(bool respawningAfterLoad)
{
base.PostSpawnSetup(respawningAfterLoad);
this.powerComp = this.parent.GetComp <CompPowerTrader>();
this.refuelableComp = this.parent.GetComp <CompRefuelable>();
this.breakdownableComp = this.parent.GetComp <CompBreakdownable>();
}
public override void PostMake()
{
base.PostMake();
extension = def.GetModExtension <DefModExtension_DroneStation>();
refuelableComp = GetComp <CompRefuelable>();
compPowerTrader = GetComp <CompPowerTrader>();
}
public override void SpawnSetup(Map map, bool respawningAfterLoad)
{
base.SpawnSetup(map, respawningAfterLoad);
powerComp = GetComp <CompPowerTrader>();
refuelableComp = GetComp <CompRefuelable>();
breakdownableComp = GetComp <CompBreakdownable>();
}
public static bool Prefix(CompRefuelable __instance, List <Thing> fuelThings)
{
if (__instance is CompTowerFoodRefuelable)
{
if (__instance.Props.atomicFueling)
{
Log.Error("Refuel in Tower shouldn't be atomic");
}
float remains = (__instance.TargetFuelLevel - __instance.Fuel) / __instance.Props.FuelMultiplierCurrentDifficulty;
while (remains > float.Epsilon && fuelThings.Count > 0)
{
Thing thing = fuelThings.Pop <Thing>();
float nutrition = FoodUtility.GetNutrition(thing, thing.def);
if (nutrition < float.Epsilon)
{
continue;
}
int curNum = Mathf.CeilToInt(remains / nutrition);
curNum = Math.Min(curNum, thing.stackCount);
ForceAddFuel(__instance, curNum * nutrition);
thing.SplitOff(curNum).Destroy(DestroyMode.Vanish);
remains -= curNum * nutrition;
}
return(false);
}
return(true);
}
private void DoDestroyDestroyable()
{
foreach (var itemPos in destroyableItems)
{
List <Thing> items = itemPos.GetThingList(Site.Map);
foreach (var item in items)
{
CompRefuelable compRefuelable = item.TryGetComp <CompRefuelable>();
if (compRefuelable != null)
{
float refuelInt = Mathf.Clamp(compRefuelable.Fuel - compRefuelable.Props.fuelCapacity, 0, compRefuelable.Props.fuelCapacity);
compRefuelable.Refuel(refuelInt);
}
CompBreakdownable compBreakdownable = item.TryGetComp <CompBreakdownable>();
if (compBreakdownable != null)
{
compBreakdownable.DoBreakdown();
}
if (item.def.CanHaveFaction)
{
item.SetFaction(Faction.OfPlayer);
}
}
}
}
public static void ShouldBeLitNow_Postfix(ref bool __result, CompGlower __instance)
{
if (__result)
{
return;
}
if (!__instance.parent.Spawned)
{
return;
}
if (!FlickUtility.WantsToBeOn(__instance.parent))
{
return;
}
Comp.VoidNetPort compPowerTrader = __instance.parent.TryGetComp <Comp.VoidNetPort>();
if (compPowerTrader != null && !compPowerTrader.PowerOn)
{
__result = true;
return;
}
CompRefuelable compRefuelable = __instance.parent.TryGetComp <CompRefuelable>();
if (compRefuelable != null && !compRefuelable.HasFuel)
{
return;
}
CompSendSignalOnCountdown compSendSignalOnCountdown = __instance.parent.TryGetComp <CompSendSignalOnCountdown>();
if (compSendSignalOnCountdown != null && compSendSignalOnCountdown.ticksLeft <= 0)
{
return;
}
return;
}
public override void Resolve(ResolveParams rp)
{
Map map = BaseGen.globalSettings.map;
SymbolResolver_Refuel.refuelables.Clear();
CellRect.CellRectIterator iterator = rp.rect.GetIterator();
while (!iterator.Done())
{
List <Thing> thingList = iterator.Current.GetThingList(map);
for (int i = 0; i < thingList.Count; i++)
{
CompRefuelable compRefuelable = thingList[i].TryGetComp <CompRefuelable>();
if (compRefuelable != null && !SymbolResolver_Refuel.refuelables.Contains(compRefuelable))
{
SymbolResolver_Refuel.refuelables.Add(compRefuelable);
}
}
iterator.MoveNext();
}
for (int j = 0; j < SymbolResolver_Refuel.refuelables.Count; j++)
{
float fuelCapacity = SymbolResolver_Refuel.refuelables[j].Props.fuelCapacity;
float amount = Rand.Range(fuelCapacity / 2f, fuelCapacity);
SymbolResolver_Refuel.refuelables[j].Refuel(amount);
}
SymbolResolver_Refuel.refuelables.Clear();
}
private void UnburrowTurret()
{
SoundDefOf.DropPod_Open.PlayOneShot(new TargetInfo(this.Position, this.Map, false));
Map map = base.Map;
IntVec3 loc = this.Position;
float HPp = (float)this.HitPoints / (float)this.MaxHitPoints;
if (insideStuff)
{
Thing thing = GenSpawn.Spawn(ThingMaker.MakeThing(ThingDef.Named(insideman), this.Stuff), loc, map, WipeMode.Vanish);
thing.SetFaction(Faction.OfPlayer, null);
thing.HitPoints = (int)Math.Ceiling(thing.MaxHitPoints * HPp);
if (insidefuel >= 0)
{
CompRefuelable refuelableComp = ((ThingWithComps)thing).GetComp <CompRefuelable>();
refuelableComp.ConsumeFuel(9999);
refuelableComp.Refuel((insidefuel / refuelableComp.Props.FuelMultiplierCurrentDifficulty));
}
}
else
{
Thing thing = GenSpawn.Spawn(ThingMaker.MakeThing(ThingDef.Named(insideman), null), loc, map, WipeMode.Vanish);
thing.SetFaction(Faction.OfPlayer, null);
thing.HitPoints = (int)Math.Ceiling(thing.MaxHitPoints * HPp);
if (insidefuel >= 0)
{
CompRefuelable refuelableComp = ((ThingWithComps)thing).GetComp <CompRefuelable>();
refuelableComp.ConsumeFuel(9999);
refuelableComp.Refuel((insidefuel / refuelableComp.Props.FuelMultiplierCurrentDifficulty));
}
}
}
private bool CanRefuel(Pawn pawn, Thing t, bool mustBeAutoRefuelable)
{
CompRefuelable compRefuelable = t.TryGetComp <CompRefuelable>();
if (compRefuelable == null || compRefuelable.IsFull)
{
return(false);
}
if (mustBeAutoRefuelable && !compRefuelable.ShouldAutoRefuelNow)
{
return(false);
}
if (t.IsForbidden(pawn) || !pawn.CanReserveAndReach(t, PathEndMode.Touch, pawn.NormalMaxDanger(), 1))
{
return(false);
}
if (this.FindBestFuel(pawn, t) == null)
{
ThingFilter fuelFilter = t.TryGetComp <CompRefuelable>().Props.fuelFilter;
JobFailReason.Is("NoFuelToRefuel".Translate(new object[]
{
fuelFilter.Summary
}));
return(false);
}
CompMountable compMountable = t.TryGetComp <CompMountable>();
if (compMountable != null && compMountable.IsMounted)
{
return(false);
}
return(true);
}
public override void SpawnSetup(Map map, bool respawningAfterLoad)
{
base.SpawnSetup(map, respawningAfterLoad);
flick = GetComp <CompFlickable>();
power = GetComp <CompPowerTrader>();
fuel = GetComp <CompRefuelable>();
}
public override Job JobOnThing(Pawn pawn, Thing thing, bool forced = false)
{
IBillGiver billGiver = thing as IBillGiver;
if (billGiver != null && ThingIsUsableBillGiver(thing) && billGiver.BillStack.AnyShouldDoNow && billGiver.UsableForBillsAfterFueling())
{
LocalTargetInfo target = thing;
bool ignoreOtherReservations = forced;
if (pawn.CanReserve(target, 1, -1, null, ignoreOtherReservations) && !thing.IsBurning() && !thing.IsForbidden(pawn))
{
CompRefuelable compRefuelable = thing.TryGetComp <CompRefuelable>();
if (compRefuelable != null && !compRefuelable.HasFuel)
{
if (!RefuelWorkGiverUtility.CanRefuel(pawn, thing, forced))
{
return(null);
}
return(RefuelWorkGiverUtility.RefuelJob(pawn, thing, forced));
}
billGiver.BillStack.RemoveIncompletableBills();
return(StartOrResumeBillJob(pawn, billGiver));
}
}
return(null);
}
public static void ForceAddFuel(CompRefuelable __instance, float value)
{
var fuelField = typeof(CompRefuelable).GetField("fuel", BindingFlags.NonPublic | BindingFlags.Instance);
fuelField.SetValue(__instance, (float)fuelField.GetValue(__instance) + value * __instance.Props.FuelMultiplierCurrentDifficulty);
__instance.parent.BroadcastCompSignal("Refueled");
}
public override void CompTick()
{
base.CompTick();
ticker++;
if (ticker >= Props.scuttlePollInTicks)
{
ticker = 0;
if (compRefuelable == null)
{
compRefuelable = parent.TryGetComp <CompRefuelable>();
}
if (compRefuelable == null || !BlackFuelUtil.CarbonThingsExist || compRefuelable.IsFull)
{
return;
}
if (parent.IsForbidden(parent.Faction))
{
return;
}
CompFlickable compFlickable = parent.GetComp <CompFlickable>();
if (compFlickable != null && !compFlickable.SwitchIsOn)
{
return;
}
if (!compRefuelable.ShouldAutoRefuelNow)
{
return;
}
Thing fuelThing = FindFuelInAnyScuttle();
if (fuelThing != null)
{
// should I check if the item is forbidden first? Core hopper logic doesn't seem to...
int fuelNeeded = compRefuelable.GetFuelCountToFullyRefuel();
int fuelThingValue = fuelThing.stackCount;
if (BlackFuelUtil.IsCarbonThing(fuelThing))
{
fuelNeeded /= 3;
fuelThingValue *= 3;
}
if (fuelThingValue <= fuelNeeded)
{
compRefuelable.Refuel(fuelThingValue);
fuelThing.Destroy();
}
else
{
compRefuelable.Refuel(fuelThingValue);
fuelThing.stackCount -= fuelNeeded;
}
}
}
}
// Methods
public override void Initialize(CompProperties props)
{
base.Initialize(props);
refuelComp = parent.GetComp <CompRefuelable>();
powerTradeComp = parent.GetComp <CompPowerTrader>();
flickComp = parent.GetComp <CompFlickable>();
defaultTexPath = parent.def.graphicData.texPath;
}
public void ReplaceFuelProps(CompRefuelable comp)
{
var props = comp.Props;
var newProps = props.CloneObject();
newProps.fuelFilter = new ThingFilter();
comp.props = newProps;
}
static void Postfix(CompRefuelable __instance)
{
Refueling = false;
if (__instance is CompRefuelable_Multi)
{
(__instance as CompRefuelable_Multi).controller.CheckFuelList();
}
}
private static void FuelRemove20Percent()
{
foreach (Thing item in Find.CurrentMap.thingGrid.ThingsAt(UI.MouseCell()))
{
CompRefuelable compRefuelable = item.TryGetComp <CompRefuelable>();
compRefuelable?.ConsumeFuel(compRefuelable.Props.fuelCapacity * 0.2f);
}
}
/// <summary>
/// Returns the number of Drones that should be availibale on Spawn.
/// </summary>
public int GetDronesOnSpawn(CompRefuelable fuelcomp = null)
{
if (spawnWithFullDrones)
{
return((int)(fuelcomp?.Props.fuelCapacity ?? maxNumDrones));
}
return(Mathf.Clamp(spawnWithDrones, 0, (int)(fuelcomp?.Props.fuelCapacity ?? maxNumDrones)));
}
public override void SpawnSetup(Map map, bool blabla)
{
base.SpawnSetup(map, blabla);
powerComp = GetComp <CompPowerTrader>();
refuelableComp = GetComp <CompRefuelable>();
breakdownableComp = GetComp <CompBreakdownable>();
powerComp = GetComp <CompPowerTrader>();
consoleDef = DefDatabase <ThingDef> .GetNamed("ET_Console");
}
