private static bool IsValidTarget(Building_TurretGun __instance, Thing t) { Building_Turret building_Turret = __instance; Pawn pawn = t as Pawn; if (pawn != null) { if (__instance.AttackVerb.ProjectileFliesOverhead()) { RoofDef roofDef = building_Turret.Map.roofGrid.RoofAt(t.Position); if (roofDef != null && roofDef.isThickRoof) { return(false); } } if (mannableComp == null) { return(!GenAI.MachinesLike(building_Turret.Faction, pawn)); } if (pawn.RaceProps.Animal && pawn.Faction == Faction.OfPlayer) { return(false); } } return(true); }
public static string ShotCalculationTipString(Thing target) { StringBuilder stringBuilder = new StringBuilder(); if (Find.Selector.SingleSelectedThing != null) { Verb verb = null; Pawn pawn = Find.Selector.SingleSelectedThing as Pawn; if (pawn != null && pawn != target && pawn.equipment != null && pawn.equipment.Primary != null && pawn.equipment.PrimaryEq.PrimaryVerb is Verb_LaunchProjectile) { verb = pawn.equipment.PrimaryEq.PrimaryVerb; } Building_TurretGun building_TurretGun = Find.Selector.SingleSelectedThing as Building_TurretGun; if (building_TurretGun != null && building_TurretGun != target) { verb = building_TurretGun.AttackVerb; } if (verb != null) { stringBuilder.Append("ShotBy".Translate(new object[] { Find.Selector.SingleSelectedThing.LabelShort }) + ": "); if (verb.CanHitTarget(target)) { stringBuilder.Append(ShotReport.HitReportFor(verb.caster, verb, target).GetTextReadout()); } else { stringBuilder.Append("CannotHit".Translate()); } } } return(stringBuilder.ToString()); }
public static void Postfix(Building_TurretGun __instance, ref bool __result) { // If the turret isn't mannable, is player-controlled and is set to be able to force target, do so if (__instance.Faction != Faction.OfPlayer) { return; } var extensionValues = TurretFrameworkExtension.Get(__instance.def); var upgradableComp = __instance.TryGetComp <CompUpgradable>(); // Upgradable comp doesn't exist/isn't upgraded and can force attack, or exists and upgraded and can force attack if (upgradableComp == null || upgradableComp.Props.canForceAttack != null && (upgradableComp.upgraded || !extensionValues.canForceAttack) && (!upgradableComp.upgraded || !upgradableComp.Props.canForceAttack.Value)) { return; } if (!__instance.def.HasComp(typeof(CompMannable))) { __result = true; } else { Log.Warning($"Turret (defName={__instance.def.defName}) has canForceAttack set to true and CompMannable; canForceAttack is redundant in this case."); } }
public static void Postfix(Building_TurretGun __instance, ref float __result) { if (__instance.IsUpgraded(out CompUpgradable upgradableComp)) { __result *= upgradableComp.Props.turretBurstCooldownTimeFactor; } }
public static void Postfix(Building_TurretGun __instance, TurretTop ___top) { // Determine which way the turret initially faces when spawned var turretFrameworkExtension = TurretFrameworkExtension.Get(__instance.def); switch (turretFrameworkExtension.gunFaceDirectionOnSpawn) { case TurretGunFaceDirection.North: NonPublicProperties.TurretTop_set_CurRotation(___top, Rot4.North.AsAngle); break; case TurretGunFaceDirection.East: NonPublicProperties.TurretTop_set_CurRotation(___top, Rot4.East.AsAngle); break; case TurretGunFaceDirection.South: NonPublicProperties.TurretTop_set_CurRotation(___top, Rot4.South.AsAngle); break; case TurretGunFaceDirection.West: NonPublicProperties.TurretTop_set_CurRotation(___top, Rot4.West.AsAngle); break; default: NonPublicProperties.TurretTop_set_CurRotation(___top, __instance.Rotation.AsAngle); break; } }
static void Prefix(Pawn pawn, Building_TurretGun gun) { #if DEBUG Log.Warning("Find Ammo"); #endif if (pawn.IsColonist && pawn.Map == gun.Map) { StorageSettings allowedShellsSettings = gun.gun.TryGetComp <CompChangeableProjectile>().allowedShellsSettings; foreach (Building_InfiniteStorage storage in WorldComp.GetInfiniteStorages(gun.Map)) { #if DEBUG Log.Warning(" Storeage: " + storage.Label); #endif List <Thing> l; if (storage.TryRemove(allowedShellsSettings.filter, out l)) { foreach (Thing t in l) { #if DEBUG Log.Warning(" Ammo fouynd: " + t.Label); #endif List <Thing> dropped = new List <Thing>(); BuildingUtil.DropThing(t, t.stackCount, storage, storage.Map, dropped); } } } } }
public static Mote ThrowCasingTurret(Thing caster, Map map, int weaponDamage, ThingDef moteDef) { if (!caster.Position.ShouldSpawnMotesAt(map) || map.moteCounter.Saturated) { return(null); } Building_TurretGun turret = caster as Building_TurretGun; TurretTop turrettop = Traverse.Create(turret).Field("top").GetValue <TurretTop>(); float angle = Traverse.Create(turrettop).Field("curRotationInt").GetValue <float>(); MoteThrownCasing moteThrown = (MoteThrownCasing)ThingMaker.MakeThing(moteDef, null); if (BulletCasingMoteSettings.uncapCasingSize) { moteThrown.Scale = GenMath.LerpDouble(5f, 50f, 0.2f, 0.5f, weaponDamage); } else { moteThrown.Scale = GenMath.LerpDoubleClamped(5f, 75f, 0.2f, 0.5f, weaponDamage); } moteThrown.exactPosition = caster.TrueCenter(); moteThrown.rotationRate = Rand.Range(-360f, 360f); moteThrown.speed = Rand.Range(BulletCasingMoteSettings.velocityFactor.min, BulletCasingMoteSettings.velocityFactor.max); moteThrown.rotation = angle; moteThrown.velocityRandom = new Vector3(Rand.Range(-4f, 4f), 0f, Rand.Range(-4f, 4f)); GenSpawn.Spawn(moteThrown, caster.Position, map, WipeMode.Vanish); return(moteThrown); }
private static void GenerateAvoidGridInternal(ByteGrid grid, Faction faction, Map map, AvoidGridMode mode) { List <TrapMemory> list = faction.TacticalMemory.TrapMemories(); for (int i = 0; i < list.Count; i++) { if (list[i].map == map) { AvoidGridMaker.PrintAvoidGridAroundTrapLoc(list[i], grid); } } if (mode == AvoidGridMode.Smart) { List <Building> allBuildingsColonist = map.listerBuildings.allBuildingsColonist; for (int j = 0; j < allBuildingsColonist.Count; j++) { if (allBuildingsColonist[j].def.building.ai_combatDangerous) { Building_TurretGun building_TurretGun = allBuildingsColonist[j] as Building_TurretGun; if (building_TurretGun != null) { AvoidGridMaker.PrintAvoidGridAroundTurret(building_TurretGun, grid); } } } } AvoidGridMaker.ExpandAvoidGridIntoEdifices(grid, map); }
public static void Postfix(Building_TurretGun __instance) { var artilleryComp = __instance.TryGetComp <CompLongRangeArtillery>(); if (artilleryComp != null && artilleryComp.targetedTile != TargetInfo.Invalid) { var edgeCell = artilleryComp.FacingEdgeCell; // Warmup pie if (artilleryComp.CanLaunch) { if (artilleryComp.warmupTicksLeft > 0) { GenDraw.DrawAimPie(__instance, edgeCell, (int)(artilleryComp.warmupTicksLeft * 0.5f), __instance.def.size.x * 0.5f); } } // Targeting lines var a = __instance.TrueCenter(); var b = edgeCell.CenterVector3; a.y = AltitudeLayer.MetaOverlays.AltitudeFor(); b.y = a.y; GenDraw.DrawLineBetween(a, b, Building_TurretGun.ForcedTargetLineMat); } }
public static void Postfix(Building_TurretGun __instance) { if (__instance.GetComp <CompLongRangeArtillery>() is CompLongRangeArtillery artilleryComp) { artilleryComp.ResetForcedTarget(); } }
public static void TurretPostLoadInit(Building_TurretGun turret) { if (turret.gun == null) { turret.MakeGun(); } }
public static bool ShotCalculationTipStringPrefix(ref string __result, Thing target) { StringBuilder stringBuilder = new StringBuilder(); if (Find.Selector.SingleSelectedThing != null) { Thing singleSelectedThing = Find.Selector.SingleSelectedThing; Verb verb = null; Pawn pawn = singleSelectedThing as Pawn; if (pawn != null && pawn != target && pawn.equipment != null && pawn.equipment.Primary != null) { Comp_VerbSaveable compsav = pawn.equipment.Primary.GetComp <Comp_VerbSaveable>(); if (compsav != null && compsav.tempVerb != null && compsav.tempVerb is Verb_LaunchProjectile) { verb = compsav.tempVerb; } else { verb = pawn.equipment.PrimaryEq.PrimaryVerb; } } Building_TurretGun building_TurretGun = singleSelectedThing as Building_TurretGun; if (building_TurretGun != null && building_TurretGun != target) { verb = building_TurretGun.AttackVerb; } if (verb != null) { stringBuilder.Append("ShotBy".Translate(Find.Selector.SingleSelectedThing.LabelShort, Find.Selector.SingleSelectedThing) + ": "); if (verb.CanHitTarget(target)) { stringBuilder.Append(ShotReport.HitReportFor(verb.caster, verb, target).GetTextReadout()); } else { stringBuilder.AppendLine("CannotHit".Translate()); } Pawn pawn2 = target as Pawn; if (pawn2 != null && pawn2.Faction == null && !pawn2.InAggroMentalState) { float manhunterOnDamageChance; if (verb.IsMeleeAttack) { manhunterOnDamageChance = PawnUtility.GetManhunterOnDamageChance(pawn2, 0f, singleSelectedThing); } else { manhunterOnDamageChance = PawnUtility.GetManhunterOnDamageChance(pawn2, singleSelectedThing); } if (manhunterOnDamageChance > 0f) { stringBuilder.AppendLine(); stringBuilder.AppendLine(string.Format("{0}: {1}", "ManhunterPerHit".Translate(), manhunterOnDamageChance.ToStringPercent())); } } } } __result = stringBuilder.ToString(); return(false); }
public RangedWeaponStats(Building_TurretGun turret) { weapon = turret.gun; shootVerb = GetShootVerb(weapon.def); // Get the damage from the loaded projectile if the weapon is loadable or the default projectile otherwise var projectile = weapon.TryGetComp <CompChangeableProjectile>()?.Projectile?.projectile ?? shootVerb?.defaultProjectile?.projectile; // Default to zero damage if we can't find a projectile. // Not an error as unloaded mortars don't have projectiles shotDamage = projectile?.GetDamageAmount(weapon) ?? 0; // Note that turrets completely ignore the warmup and cooldown stat of the weapon warmup = turret.def.building.turretBurstWarmupTime; // Logic duplicated from Building_TurretGun.BurstCooldownTime() if (turret.def.building.turretBurstCooldownTime >= 0f) { cooldown = turret.def.building.turretBurstCooldownTime; } else { cooldown = turret.AttackVerb.verbProps.defaultCooldownTime; } }
public static void Postfix(Building_TurretGun __instance, Thing t, ref bool __result) { // Cone of fire check if (__result && !t.Position.WithinFiringArcOf(__instance)) { __result = false; } }
public static IAttackTargetSearcher TargSearcher(Building_TurretGun __instance) { if (mannableComp(__instance) != null && mannableComp(__instance).MannedNow) { return(mannableComp(__instance).ManningPawn); } return(__instance); }
public static bool Prefix(Building_TurretGun __instance, ref bool __result, Thing t) { bool result; if (__instance?.Faction == PurpleIvyData.AlienFaction && t is Pawn pawn && pawn.health.hediffSet.GetFirstHediffOfDef(PurpleIvyDefOf.PI_MaskingSprayHigh) != null) { __result = false; result = false; }
// Token: 0x06000007 RID: 7 RVA: 0x00002089 File Offset: 0x00000289 public static void Postfix(Building_TurretGun __instance, ref bool __result) { if (__result) { return; } __result = __instance.def.defName == "Ra2_Bunker"; }
/// <summary> /// Calculates a stats breakdown of the given turret. /// Logs an error and returns null if the thing is null. /// </summary> /// <returns>The stats of the passed-in turret.</returns> /// <param name="turret">The turret to get stats for.</param> protected static RangedWeaponStats GetTurretStats(Building_TurretGun turret) { if (turret == null) { Log.Error($"[RangedDPS] Tried to get the ranged weapon stats of a null turret"); return(null); } return(new RangedWeaponStats(turret)); }
public static bool AcceptsShell(Building_TurretGun artillery, ThingDef shellDef) { var changeableProjComp = artillery.gun.TryGetComp <CompChangeableProjectile>(); if (changeableProjComp == null) { return(false); } return(changeableProjComp.allowedShellsSettings.AllowedToAccept(shellDef)); }
static void Postfix(Building_TurretGun __instance, ref bool __result) { if (Base.Instance.GetExtendedDataStorage().GetExtendedDataFor(__instance.Map).rogueAI is Building_RogueAI rogueAI) { if (rogueAI.controlledTurrets.Contains(__instance)) { __result = true; } } }
static void Postfix(Building_TurretGun __instance) { if (Base.Instance.GetExtendedDataStorage().GetExtendedDataFor(__instance.Map).rogueAI is Building_RogueAI controller) { if (controller.controlledTurrets.Contains(__instance)) { GenDraw.DrawLineBetween(__instance.Position.ToVector3Shifted(), controller.Position.ToVector3Shifted(), SimpleColor.Green); } } }
public static bool Prefix(Building_TurretGun __instance, LocalTargetInfo targ) { // Cone of fire check if (targ.IsValid && !targ.Cell.WithinFiringArcOf(__instance)) { Messages.Message("TurretExtensions.MessageTargetOutsideFiringArc".Translate(), MessageTypeDefOf.RejectInput, false); return(false); } return(true); }
public static bool Prefix(Building_TurretGun __instance) { // Don't try and automatically target if targeting a world tile var artilleryComp = __instance.GetComp <CompLongRangeArtillery>(); if (artilleryComp != null && artilleryComp.targetedTile.IsValid) { return(false); } return(true); }
public override string GetStatDrawEntryLabel(StatDef stat, float value, ToStringNumberSense numberSense, StatRequest optionalReq, bool finalized = true) { Building_TurretGun turret = GetTurret(optionalReq); RangedWeaponStats weaponStats = GetTurretStats(optionalReq); int optimalRange = (int)weaponStats.FindOptimalRange(turret); return(string.Format("{0} ({1})", value.ToStringByStyle(stat.toStringStyle, numberSense), string.Format("StatsReport_RangedDPSOptimalRange".Translate(), optimalRange))); }
public override string GetExplanationUnfinalized(StatRequest req, ToStringNumberSense numberSense) { if (!ShouldShowFor(req)) { return(""); } Building_TurretGun turret = GetTurret(req); RangedWeaponStats weaponStats = GetTurretStats(req); return(DPSRangeBreakdown(weaponStats, turret)); }
public override void Initialize(Verse.CompProperties props) { base.Initialize(props); Building_TurretGun turret = parent as Building_TurretGun; if (turret != null && turret.gun == null) { gun = (Thing)ThingMaker.MakeThing(parent.def.building.turretGunDef); turret.gun = gun; turret.GunCompEq.verbTracker.InitVerbs(); } }
// prefix // - wants instance, result and count // - wants to change count // - returns a boolean that controls if original is executed (true) or not (false) public static Boolean CanSetForcedTargetPrefix(ref bool __result, ref Building_TurretGun __instance) { //Allow for all Turrets belonging to the Player if (__instance.Faction == Faction.OfPlayer) { //Set result to true so targeting can be used and return fasle to stop origional check. __result = true; return(false); } //Retuen true so the origional method is executed. return(true); }
static void Postfix(Building_TurretGun __instance, TurretTop ___top) { if (__instance.GetComp <CompMountable>() is CompMountable comp && comp.Active) { //TODO: look into performance of this. Try to avoid Traverse. float curRotation = Traverse.Create(___top).Property("CurRotation").GetValue <float>(); if (__instance.Rotation != comp.mountedTo.Rotation) { Traverse.Create(___top).Property("CurRotation").SetValue(comp.mountedTo.Rotation.AsAngle); __instance.Rotation = comp.mountedTo.Rotation; } } }
public static void Listener(Building_TurretGun __instance, ref bool __result) { var crt = __instance.TryGetComp <CompRemotelyControlledTurret>(); if (crt?.controller == null) { return; } var mannable = (CompMannable)mannableComp.GetValue(__instance); __result = __result || mannable == null; }
private static void PrintAvoidGridAroundTurret(Building_TurretGun tur, ByteGrid avoidGrid) { int num = GenRadial.NumCellsInRadius((float)(tur.GunCompEq.PrimaryVerb.verbProps.range + 4.0)); for (int i = 0; i < num; i++) { IntVec3 intVec = tur.Position + GenRadial.RadialPattern[i]; if (intVec.InBounds(tur.Map) && intVec.Walkable(tur.Map) && GenSight.LineOfSight(intVec, tur.Position, tur.Map, true, null, 0, 0)) { AvoidGridMaker.IncrementAvoidGrid(avoidGrid, intVec, 12); } } }