Exemplo n.º 1
0
        /// <summary>
        /// Produces a secondary explosion on impact using the explosion values from the projectile's projectile def. Requires the projectile's launcher to be passed on due to protection level,
        /// only works when parent can be cast as ProjectileCR. Intended use is for HEAT and similar weapons that spawn secondary explosions while also penetrating, NOT explosive ammo of
        /// anti-materiel rifles as the explosion just spawns on top of the pawn, not inside the hit body part.
        ///
        /// Additionally handles fragmentation effects if defined.
        /// </summary>
        /// <param name="instigator">Launcher of the projectile calling the method</param>
        public virtual void Explode(Thing instigator, Verse.IntVec3 pos)
        {
            // Regular explosion stuff
            if (this.Props.explosionRadius > 0 && this.Props.explosionDamage > 0)
            {
                Explosion explosion = new Explosion();
                explosion.position   = pos;
                explosion.radius     = Props.explosionRadius;
                explosion.damType    = Props.explosionDamageDef;
                explosion.instigator = instigator;
                explosion.damAmount  = GenMath.RoundRandom(Props.explosionDamage);
                explosion.source     = parent.def;
                explosion.preExplosionSpawnThingDef            = Props.preExplosionSpawnThingDef;
                explosion.preExplosionSpawnChance              = Props.explosionSpawnChance;
                explosion.postExplosionSpawnThingDef           = Props.postExplosionSpawnThingDef;
                explosion.postExplosionSpawnChance             = Props.explosionSpawnChance;
                explosion.applyDamageToExplosionCellsNeighbors = Props.damageAdjacentTiles;
                Find.Map.GetComponent <ExplosionManager>().StartExplosion(explosion, Props.soundExplode == null ? Props.explosionDamageDef.soundExplosion : Props.soundExplode);
            }

            // Fragmentation stuff
            if (!Props.fragments.NullOrEmpty())
            {
                if (Props.fragRange <= 0)
                {
                    Log.Error(this.parent.LabelCap + " has fragments but no fragRange");
                }

                else
                {
                    Vector3 exactOrigin = new Vector3(0, 0, 0);
                    exactOrigin.x = this.parent.DrawPos.x;
                    exactOrigin.z = this.parent.DrawPos.z;

                    foreach (ThingCount fragment in Props.fragments)
                    {
                        for (int i = 0; i < fragment.count; i++)
                        {
                            ProjectileCR projectile = (ProjectileCR)ThingMaker.MakeThing(fragment.thingDef, null);
                            projectile.canFreeIntercept = true;
                            Vector3    exactTarget = exactOrigin + (new Vector3(1, 0, 1) * UnityEngine.Random.Range(0, Props.fragRange)).RotatedBy(UnityEngine.Random.Range(0, 360));
                            TargetInfo targetCell  = exactTarget.ToIntVec3();
                            GenSpawn.Spawn(projectile, this.parent.Position);
                            projectile.Launch(instigator, exactOrigin, targetCell, exactTarget, null);
                        }
                    }
                }
            }
        }
Exemplo n.º 2
0
 public void Set(IntVec3 prioritizedCell, WorkTypeDef prioritizedWorkType)
 {
     this.prioritizedCell     = prioritizedCell;
     this.prioritizedWorkType = prioritizedWorkType;
     this.prioritizeTick      = Find.TickManager.TicksGame;
 }
Exemplo n.º 3
0
        public static FloodUnfogResult FloodUnfog(IntVec3 root, Map map)
        {
            FloodFillerFog.cellsToUnfog.Clear();
            FloodUnfogResult result = default(FloodUnfogResult);

            bool[]         fogGridDirect      = map.fogGrid.fogGrid;
            FogGrid        fogGrid            = map.fogGrid;
            List <IntVec3> newlyUnfoggedCells = new List <IntVec3>();
            int            numUnfogged        = 0;
            bool           expanding          = false;
            CellRect       viewRect           = CellRect.ViewRect(map);

            result.allOnScreen = true;
            Predicate <IntVec3> predicate = delegate(IntVec3 c)
            {
                if (!fogGridDirect[map.cellIndices.CellToIndex(c)])
                {
                    return(false);
                }
                Thing edifice = c.GetEdifice(map);
                return((edifice == null || !edifice.def.MakeFog) && (!FloodFillerFog.testMode || expanding || numUnfogged <= 500));
            };
            Action <IntVec3> processor = delegate(IntVec3 c)
            {
                fogGrid.Unfog(c);
                newlyUnfoggedCells.Add(c);
                List <Thing> thingList = c.GetThingList(map);
                for (int l = 0; l < thingList.Count; l++)
                {
                    Pawn pawn = thingList[l] as Pawn;
                    if (pawn != null)
                    {
                        pawn.mindState.Active = true;
                        if (pawn.def.race.IsMechanoid)
                        {
                            result.mechanoidFound = true;
                        }
                    }
                }
                if (!viewRect.Contains(c))
                {
                    result.allOnScreen = false;
                }
                result.cellsUnfogged++;
                if (FloodFillerFog.testMode)
                {
                    numUnfogged++;
                    map.debugDrawer.FlashCell(c, (float)numUnfogged / 200f, numUnfogged.ToStringCached(), 50);
                }
            };

            map.floodFiller.FloodFill(root, predicate, processor, 2147483647, false, null);
            expanding = true;
            for (int i = 0; i < newlyUnfoggedCells.Count; i++)
            {
                IntVec3 a = newlyUnfoggedCells[i];
                for (int j = 0; j < 8; j++)
                {
                    IntVec3 intVec = a + GenAdj.AdjacentCells[j];
                    if (intVec.InBounds(map) && fogGrid.IsFogged(intVec))
                    {
                        if (!predicate(intVec))
                        {
                            FloodFillerFog.cellsToUnfog.Add(intVec);
                        }
                    }
                }
            }
            for (int k = 0; k < FloodFillerFog.cellsToUnfog.Count; k++)
            {
                fogGrid.Unfog(FloodFillerFog.cellsToUnfog[k]);
                if (FloodFillerFog.testMode)
                {
                    map.debugDrawer.FlashCell(FloodFillerFog.cellsToUnfog[k], 0.3f, "x", 50);
                }
            }
            FloodFillerFog.cellsToUnfog.Clear();
            return(result);
        }
Exemplo n.º 4
0
        public bool TryFindShootLineFromTo(IntVec3 root, LocalTargetInfo targ, out ShootLine resultingLine)
        {
            if (targ.HasThing && targ.Thing.Map != this.caster.Map)
            {
                resultingLine = default(ShootLine);
                return(false);
            }
            if (this.verbProps.IsMeleeAttack || this.verbProps.range <= 1.42f)
            {
                resultingLine = new ShootLine(root, targ.Cell);
                return(ReachabilityImmediate.CanReachImmediate(root, targ, this.caster.Map, PathEndMode.Touch, null));
            }
            CellRect cellRect = (!targ.HasThing) ? CellRect.SingleCell(targ.Cell) : targ.Thing.OccupiedRect();
            float    num      = this.verbProps.EffectiveMinRange(targ, this.caster);
            float    num2     = cellRect.ClosestDistSquaredTo(root);

            if (num2 > this.verbProps.range * this.verbProps.range || num2 < num * num)
            {
                resultingLine = new ShootLine(root, targ.Cell);
                return(false);
            }
            if (!this.verbProps.requireLineOfSight)
            {
                resultingLine = new ShootLine(root, targ.Cell);
                return(true);
            }
            if (this.CasterIsPawn)
            {
                IntVec3 dest;
                if (this.CanHitFromCellIgnoringRange(root, targ, out dest))
                {
                    resultingLine = new ShootLine(root, dest);
                    return(true);
                }
                ShootLeanUtility.LeanShootingSourcesFromTo(root, cellRect.ClosestCellTo(root), this.caster.Map, Verb.tempLeanShootSources);
                for (int i = 0; i < Verb.tempLeanShootSources.Count; i++)
                {
                    IntVec3 intVec = Verb.tempLeanShootSources[i];
                    if (this.CanHitFromCellIgnoringRange(intVec, targ, out dest))
                    {
                        resultingLine = new ShootLine(intVec, dest);
                        return(true);
                    }
                }
            }
            else
            {
                CellRect.CellRectIterator iterator = this.caster.OccupiedRect().GetIterator();
                while (!iterator.Done())
                {
                    IntVec3 current = iterator.Current;
                    IntVec3 dest;
                    if (this.CanHitFromCellIgnoringRange(current, targ, out dest))
                    {
                        resultingLine = new ShootLine(current, dest);
                        return(true);
                    }
                    iterator.MoveNext();
                }
            }
            resultingLine = new ShootLine(root, targ.Cell);
            return(false);
        }
Exemplo n.º 5
0
        private bool CheckForFreeInterceptBetween(Vector3 lastExactPos, Vector3 newExactPos)
        {
            if (lastExactPos == newExactPos)
            {
                return(false);
            }
            List <Thing> list = base.Map.listerThings.ThingsInGroup(ThingRequestGroup.ProjectileInterceptor);

            for (int i = 0; i < list.Count; i++)
            {
                if (list[i].TryGetComp <CompProjectileInterceptor>().CheckIntercept(this, lastExactPos, newExactPos))
                {
                    Destroy();
                    return(true);
                }
            }
            IntVec3 intVec  = lastExactPos.ToIntVec3();
            IntVec3 intVec2 = newExactPos.ToIntVec3();

            if (intVec2 == intVec)
            {
                return(false);
            }
            if (!intVec.InBounds(base.Map) || !intVec2.InBounds(base.Map))
            {
                return(false);
            }
            if (intVec2.AdjacentToCardinal(intVec))
            {
                return(CheckForFreeIntercept(intVec2));
            }
            if (VerbUtility.InterceptChanceFactorFromDistance(origin, intVec2) <= 0f)
            {
                return(false);
            }
            Vector3 vect   = lastExactPos;
            Vector3 v      = newExactPos - lastExactPos;
            Vector3 vector = v.normalized * 0.2f;
            int     num    = (int)(v.MagnitudeHorizontal() / 0.2f);

            checkedCells.Clear();
            int     num2 = 0;
            IntVec3 intVec3;

            do
            {
                vect   += vector;
                intVec3 = vect.ToIntVec3();
                if (!checkedCells.Contains(intVec3))
                {
                    if (CheckForFreeIntercept(intVec3))
                    {
                        return(true);
                    }
                    checkedCells.Add(intVec3);
                }
                num2++;
                if (num2 > num)
                {
                    return(false);
                }
            }while (!(intVec3 == intVec2));
            return(false);
        }
Exemplo n.º 6
0
        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);
        }
Exemplo n.º 7
0
 public SnowCategory GetCategory(IntVec3 c)
 {
     return(SnowUtility.GetSnowCategory(this.GetDepth(c)));
 }
Exemplo n.º 8
0
 public static int ManhattanDistanceFlat(IntVec3 a, IntVec3 b)
 {
     return(Math.Abs(a.x - b.x) + Math.Abs(a.z - b.z));
 }
Exemplo n.º 9
0
 public static void DrawTargetingHightlight_Explosion(IntVec3 c, float Radius)
 {
     GenDraw.DrawRadiusRing(c, Radius);
 }
Exemplo n.º 10
0
        private static void DrawTargetingHighlight_Cell(IntVec3 c)
        {
            Vector3 position = c.ToVector3ShiftedWithAltitude(AltitudeLayer.Building);

            Graphics.DrawMesh(MeshPool.plane10, position, Quaternion.identity, GenDraw.CurTargetingMat, 0);
        }
Exemplo n.º 11
0
        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);
                }
            }
        }
Exemplo n.º 12
0
 public void SetRegionAt(IntVec3 c, Region reg)
 {
     this.regionGrid[this.map.cellIndices.CellToIndex(c)] = reg;
 }
Exemplo n.º 13
0
 public Region GetRegionAt_NoRebuild_InvalidAllowed(IntVec3 c)
 {
     return(this.regionGrid[this.map.cellIndices.CellToIndex(c)]);
 }
Exemplo n.º 14
0
        public static bool CanReachImmediate(IntVec3 start, CellRect rect, Map map, PathEndMode peMode, Pawn pawn)
        {
            IntVec3 c = rect.ClosestCellTo(start);

            return(ReachabilityImmediate.CanReachImmediate(start, c, map, peMode, pawn));
        }
Exemplo n.º 15
0
 public void Clear()
 {
     this.prioritizedCell     = IntVec3.Invalid;
     this.prioritizedWorkType = null;
     this.prioritizeTick      = 0;
 }
Exemplo n.º 16
0
 public static float DistanceTo(this IntVec3 a, IntVec3 b)
 {
     return((a - b).LengthHorizontal);
 }
Exemplo n.º 17
0
 public static int DistanceToSquared(this IntVec3 a, IntVec3 b)
 {
     return((a - b).LengthHorizontalSquared);
 }
Exemplo n.º 18
0
        public static void EqualizeTemperaturesThroughBuilding(Building b, float rate, bool twoWay)
        {
            int   num  = 0;
            float num2 = 0f;

            if (twoWay)
            {
                for (int i = 0; i < 2; i++)
                {
                    IntVec3 intVec = (i != 0) ? (b.Position - b.Rotation.FacingCell) : (b.Position + b.Rotation.FacingCell);
                    if (intVec.InBounds(b.Map))
                    {
                        RoomGroup roomGroup = intVec.GetRoomGroup(b.Map);
                        if (roomGroup != null)
                        {
                            num2 += roomGroup.Temperature;
                            beqRoomGroups[num] = roomGroup;
                            num++;
                        }
                    }
                }
            }
            else
            {
                for (int j = 0; j < 4; j++)
                {
                    IntVec3 intVec2 = b.Position + GenAdj.CardinalDirections[j];
                    if (intVec2.InBounds(b.Map))
                    {
                        RoomGroup roomGroup2 = intVec2.GetRoomGroup(b.Map);
                        if (roomGroup2 != null)
                        {
                            num2 += roomGroup2.Temperature;
                            beqRoomGroups[num] = roomGroup2;
                            num++;
                        }
                    }
                }
            }
            if (num != 0)
            {
                float     num3       = num2 / (float)num;
                RoomGroup roomGroup3 = b.GetRoomGroup();
                if (roomGroup3 != null)
                {
                    roomGroup3.Temperature = num3;
                }
                if (num != 1)
                {
                    float num4 = 1f;
                    for (int k = 0; k < num; k++)
                    {
                        if (!beqRoomGroups[k].UsesOutdoorTemperature)
                        {
                            float temperature = beqRoomGroups[k].Temperature;
                            float num5        = num3 - temperature;
                            float num6        = num5 * rate;
                            float num7        = num6 / (float)beqRoomGroups[k].CellCount;
                            float num8        = beqRoomGroups[k].Temperature + num7;
                            if (num6 > 0f && num8 > num3)
                            {
                                num8 = num3;
                            }
                            else if (num6 < 0f && num8 < num3)
                            {
                                num8 = num3;
                            }
                            float num9 = Mathf.Abs((num8 - temperature) * (float)beqRoomGroups[k].CellCount / num6);
                            if (num9 < num4)
                            {
                                num4 = num9;
                            }
                        }
                    }
                    for (int l = 0; l < num; l++)
                    {
                        if (!beqRoomGroups[l].UsesOutdoorTemperature)
                        {
                            float temperature2 = beqRoomGroups[l].Temperature;
                            float num10        = num3 - temperature2;
                            float num11        = num10 * rate * num4;
                            float num12        = num11 / (float)beqRoomGroups[l].CellCount;
                            beqRoomGroups[l].Temperature += num12;
                        }
                    }
                    for (int m = 0; m < beqRoomGroups.Length; m++)
                    {
                        beqRoomGroups[m] = null;
                    }
                }
            }
        }
Exemplo n.º 19
0
 public void Notify_WarmingCastAlongLine(ShootLine newShootLine, IntVec3 ShootPosition)
 {
     this.shootSourceOffset = newShootLine.Source - this.pawn.Position;
 }
Exemplo n.º 20
0
 public static float GetTemperatureForCell(IntVec3 c, Map map)
 {
     TryGetTemperatureForCell(c, map, out float tempResult);
     return(tempResult);
 }
Exemplo n.º 21
0
        public static List <Thing> ThingsUnderMouse(Vector3 clickPos, float pawnWideClickRadius, TargetingParameters clickParams)
        {
            IntVec3      c    = IntVec3.FromVector3(clickPos);
            List <Thing> list = new List <Thing>();

            GenUI.clickedPawns.Clear();
            List <Pawn> allPawnsSpawned = Find.CurrentMap.mapPawns.AllPawnsSpawned;

            for (int i = 0; i < allPawnsSpawned.Count; i++)
            {
                Pawn pawn = allPawnsSpawned[i];
                if ((pawn.DrawPos - clickPos).MagnitudeHorizontal() < 0.4f && clickParams.CanTarget(pawn))
                {
                    GenUI.clickedPawns.Add(pawn);
                }
            }
            List <Pawn> list2 = GenUI.clickedPawns;

            if (GenUI.< > f__mg$cache0 == null)
            {
                GenUI.< > f__mg$cache0 = new Comparison <Pawn>(GenUI.CompareThingsByDistanceToMousePointer);
            }
            list2.Sort(GenUI.< > f__mg$cache0);
            for (int j = 0; j < GenUI.clickedPawns.Count; j++)
            {
                list.Add(GenUI.clickedPawns[j]);
            }
            List <Thing> list3 = new List <Thing>();

            foreach (Thing thing in Find.CurrentMap.thingGrid.ThingsAt(c))
            {
                if (!list.Contains(thing) && clickParams.CanTarget(thing))
                {
                    list3.Add(thing);
                }
            }
            List <Thing> list4 = list3;

            if (GenUI.< > f__mg$cache1 == null)
            {
                GenUI.< > f__mg$cache1 = new Comparison <Thing>(GenUI.CompareThingsByDrawAltitude);
            }
            list4.Sort(GenUI.< > f__mg$cache1);
            list.AddRange(list3);
            GenUI.clickedPawns.Clear();
            List <Pawn> allPawnsSpawned2 = Find.CurrentMap.mapPawns.AllPawnsSpawned;

            for (int k = 0; k < allPawnsSpawned2.Count; k++)
            {
                Pawn pawn2 = allPawnsSpawned2[k];
                if ((pawn2.DrawPos - clickPos).MagnitudeHorizontal() < pawnWideClickRadius && clickParams.CanTarget(pawn2))
                {
                    GenUI.clickedPawns.Add(pawn2);
                }
            }
            List <Pawn> list5 = GenUI.clickedPawns;

            if (GenUI.< > f__mg$cache2 == null)
            {
                GenUI.< > f__mg$cache2 = new Comparison <Pawn>(GenUI.CompareThingsByDistanceToMousePointer);
            }
            list5.Sort(GenUI.< > f__mg$cache2);
            for (int l = 0; l < GenUI.clickedPawns.Count; l++)
            {
                if (!list.Contains(GenUI.clickedPawns[l]))
                {
                    list.Add(GenUI.clickedPawns[l]);
                }
            }
            list.RemoveAll((Thing t) => !t.Spawned);
            GenUI.clickedPawns.Clear();
            return(list);
        }
Exemplo n.º 22
0
        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);
        }
Exemplo n.º 23
0
 public ShootLine(IntVec3 source, IntVec3 dest)
 {
     this.source = source;
     this.dest   = dest;
 }
 public static List <DamageOverlay> GetAvailableOverlays(Building b)
 {
     availableOverlays.Clear();
     if (GetScratchMats(b).Any())
     {
         int   num        = 3;
         Rect  damageRect = GetDamageRect(b);
         float num2       = damageRect.width * damageRect.height;
         if (num2 > 4f)
         {
             num += Mathf.RoundToInt((num2 - 4f) * 0.54f);
         }
         for (int i = 0; i < num; i++)
         {
             availableOverlays.Add(DamageOverlay.Scratch);
         }
     }
     if (UsesLinkableCornersAndEdges(b))
     {
         if (b.def.graphicData != null && b.def.graphicData.damageData != null)
         {
             IntVec3           position   = b.Position;
             DamageGraphicData damageData = b.def.graphicData.damageData;
             if (damageData.edgeTopMat != null && DifferentAt(b, position.x, position.z + 1) && SameAndDamagedAt(b, position.x + 1, position.z) && DifferentAt(b, position.x + 1, position.z + 1))
             {
                 availableOverlays.Add(DamageOverlay.TopEdge);
             }
             if (damageData.edgeRightMat != null && DifferentAt(b, position.x + 1, position.z) && SameAndDamagedAt(b, position.x, position.z + 1) && DifferentAt(b, position.x + 1, position.z + 1))
             {
                 availableOverlays.Add(DamageOverlay.RightEdge);
             }
             if (damageData.edgeBotMat != null && DifferentAt(b, position.x, position.z - 1) && SameAndDamagedAt(b, position.x + 1, position.z) && DifferentAt(b, position.x + 1, position.z - 1))
             {
                 availableOverlays.Add(DamageOverlay.BotEdge);
             }
             if (damageData.edgeLeftMat != null && DifferentAt(b, position.x - 1, position.z) && SameAndDamagedAt(b, position.x, position.z + 1) && DifferentAt(b, position.x - 1, position.z + 1))
             {
                 availableOverlays.Add(DamageOverlay.LeftEdge);
             }
             if (damageData.cornerTLMat != null && DifferentAt(b, position.x - 1, position.z) && DifferentAt(b, position.x, position.z + 1))
             {
                 availableOverlays.Add(DamageOverlay.TopLeftCorner);
             }
             if (damageData.cornerTRMat != null && DifferentAt(b, position.x + 1, position.z) && DifferentAt(b, position.x, position.z + 1))
             {
                 availableOverlays.Add(DamageOverlay.TopRightCorner);
             }
             if (damageData.cornerBRMat != null && DifferentAt(b, position.x + 1, position.z) && DifferentAt(b, position.x, position.z - 1))
             {
                 availableOverlays.Add(DamageOverlay.BotRightCorner);
             }
             if (damageData.cornerBLMat != null && DifferentAt(b, position.x - 1, position.z) && DifferentAt(b, position.x, position.z - 1))
             {
                 availableOverlays.Add(DamageOverlay.BotLeftCorner);
             }
         }
     }
     else
     {
         GetCornerMats(out Material topLeft, out Material topRight, out Material botRight, out Material botLeft, b);
         if (topLeft != null)
         {
             availableOverlays.Add(DamageOverlay.TopLeftCorner);
         }
         if (topRight != null)
         {
             availableOverlays.Add(DamageOverlay.TopRightCorner);
         }
         if (botLeft != null)
         {
             availableOverlays.Add(DamageOverlay.BotLeftCorner);
         }
         if (botRight != null)
         {
             availableOverlays.Add(DamageOverlay.BotRightCorner);
         }
     }
     return(availableOverlays);
 }
Exemplo n.º 25
0
        private bool CheckForFreeIntercept(IntVec3 c)
        {
            if (destination.ToIntVec3() == c)
            {
                return(false);
            }
            float num = VerbUtility.InterceptChanceFactorFromDistance(origin, c);

            if (num <= 0f)
            {
                return(false);
            }
            bool         flag      = false;
            List <Thing> thingList = c.GetThingList(base.Map);

            for (int i = 0; i < thingList.Count; i++)
            {
                Thing thing = thingList[i];
                if (!CanHit(thing))
                {
                    continue;
                }
                bool flag2 = false;
                if (thing.def.Fillage == FillCategory.Full)
                {
                    Building_Door building_Door = thing as Building_Door;
                    if (building_Door == null || !building_Door.Open)
                    {
                        ThrowDebugText("int-wall", c);
                        Impact(thing);
                        return(true);
                    }
                    flag2 = true;
                }
                float num2 = 0f;
                Pawn  pawn = thing as Pawn;
                if (pawn != null)
                {
                    num2 = 0.4f * Mathf.Clamp(pawn.BodySize, 0.1f, 2f);
                    if (pawn.GetPosture() != 0)
                    {
                        num2 *= 0.1f;
                    }
                    if (launcher != null && pawn.Faction != null && launcher.Faction != null && !pawn.Faction.HostileTo(launcher.Faction))
                    {
                        num2 *= 0.4f;
                    }
                }
                else if (thing.def.fillPercent > 0.2f)
                {
                    num2 = (flag2 ? 0.05f : ((!DestinationCell.AdjacentTo8Way(c)) ? (thing.def.fillPercent * 0.15f) : (thing.def.fillPercent * 1f)));
                }
                num2 *= num;
                if (num2 > 1E-05f)
                {
                    if (Rand.Chance(num2))
                    {
                        ThrowDebugText("int-" + num2.ToStringPercent(), c);
                        Impact(thing);
                        return(true);
                    }
                    flag = true;
                    ThrowDebugText(num2.ToStringPercent(), c);
                }
            }
            if (!flag)
            {
                ThrowDebugText("o", c);
            }
            return(false);
        }
Exemplo n.º 26
0
 private static bool <Erode> m__0(IntVec3 x)
 {
     return(GenMorphology.cellsSet.Contains(x));
 }
Exemplo n.º 27
0
 private bool CanHitFromCellIgnoringRange(IntVec3 sourceCell, LocalTargetInfo targ, out IntVec3 goodDest)
 {
     if (targ.Thing != null)
     {
         if (targ.Thing.Map != this.caster.Map)
         {
             goodDest = IntVec3.Invalid;
             return(false);
         }
         ShootLeanUtility.CalcShootableCellsOf(Verb.tempDestList, targ.Thing);
         for (int i = 0; i < Verb.tempDestList.Count; i++)
         {
             if (this.CanHitCellFromCellIgnoringRange(sourceCell, Verb.tempDestList[i], targ.Thing.def.Fillage == FillCategory.Full))
             {
                 goodDest = Verb.tempDestList[i];
                 return(true);
             }
         }
     }
     else if (this.CanHitCellFromCellIgnoringRange(sourceCell, targ.Cell, false))
     {
         goodDest = targ.Cell;
         return(true);
     }
     goodDest = IntVec3.Invalid;
     return(false);
 }
Exemplo n.º 28
0
 private static bool <Dilate> m__1(IntVec3 x)
 {
     return(true);
 }
Exemplo n.º 29
0
 internal bool <> m__0(IntVec3 x)
 {
     return(GenMorphology.cellsSet.Contains(x) && this.extraPredicate(x));
 }
 public void StartDrag()
 {
     this.dragging      = true;
     this.startDragCell = UI.MouseCell();
 }