Exemple #1
0
 public override void DrawWorker(Vector3 loc, Rot4 rot, ThingDef thingDef, Thing thing, float extraRotation)
 {
     DrawMoteInternal(loc, rot, thingDef, thing, 0);
 }
Exemple #2
0
        public Material HairMatAt(Rot4 facing)
        {
            Material baseMat = hairGraphic.MatAt(facing);

            return(flasher.GetDamagedMat(baseMat));
        }
Exemple #3
0
        public static Vector3 TrueCenter(IntVec3 loc, Rot4 rotation, IntVec2 thingSize, float altitude)
        {
            Vector3 result = loc.ToVector3ShiftedWithAltitude(altitude);

            if (thingSize.x != 1 || thingSize.z != 1)
            {
                if (rotation.IsHorizontal)
                {
                    int x = thingSize.x;
                    thingSize.x = thingSize.z;
                    thingSize.z = x;
                }
                switch (rotation.AsInt)
                {
                case 0:
                    if (thingSize.x % 2 == 0)
                    {
                        result.x += 0.5f;
                    }
                    if (thingSize.z % 2 == 0)
                    {
                        result.z += 0.5f;
                    }
                    break;

                case 1:
                    if (thingSize.x % 2 == 0)
                    {
                        result.x += 0.5f;
                    }
                    if (thingSize.z % 2 == 0)
                    {
                        result.z -= 0.5f;
                    }
                    break;

                case 2:
                    if (thingSize.x % 2 == 0)
                    {
                        result.x -= 0.5f;
                    }
                    if (thingSize.z % 2 == 0)
                    {
                        result.z -= 0.5f;
                    }
                    break;

                case 3:
                    if (thingSize.x % 2 == 0)
                    {
                        result.x -= 0.5f;
                    }
                    if (thingSize.z % 2 == 0)
                    {
                        result.z += 0.5f;
                    }
                    break;
                }
            }
            return(result);
        }
Exemple #4
0
 public static bool TryFindRandomAdjacentCell8WayWithRoomGroup(IntVec3 center, Rot4 rot, IntVec2 size, Map map, out IntVec3 result)
 {
     GenAdj.AdjustForRotation(ref center, ref size, rot);
     GenAdj.validCells.Clear();
     foreach (IntVec3 item in GenAdj.CellsAdjacent8Way(center, rot, size))
     {
         if (item.InBounds(map) && item.GetRoomGroup(map) != null)
         {
             GenAdj.validCells.Add(item);
         }
     }
     return(((IEnumerable <IntVec3>)GenAdj.validCells).TryRandomElement <IntVec3>(out result));
 }
Exemple #5
0
 public static CellRect OccupiedRect(IntVec3 center, Rot4 rot, IntVec2 size)
 {
     GenAdj.AdjustForRotation(ref center, ref size, rot);
     return(new CellRect(center.x - (size.x - 1) / 2, center.z - (size.z - 1) / 2, size.x, size.z));
 }
 public override Material MatAt(Rot4 rot, Thing thing = null)
 {
     return(this.mat);
 }
Exemple #7
0
        public static IEnumerable <IntVec3> CellsAdjacentAlongEdge(IntVec3 thingCent, Rot4 thingRot, IntVec2 thingSize, LinkDirections dir)
        {
            GenAdj.AdjustForRotation(ref thingCent, ref thingSize, thingRot);
            int minX = thingCent.x - (thingSize.x - 1) / 2 - 1;
            int minZ = thingCent.z - (thingSize.z - 1) / 2 - 1;
            int maxX = minX + thingSize.x + 1;
            int maxZ = minZ + thingSize.z + 1;

            if (dir == LinkDirections.Down)
            {
                int x2 = minX;
                if (x2 <= maxX)
                {
                    yield return(new IntVec3(x2, thingCent.y, minZ - 1));

                    /*Error: Unable to find new state assignment for yield return*/;
                }
            }
            if (dir == LinkDirections.Up)
            {
                int x = minX;
                if (x <= maxX)
                {
                    yield return(new IntVec3(x, thingCent.y, maxZ + 1));

                    /*Error: Unable to find new state assignment for yield return*/;
                }
            }
            if (dir == LinkDirections.Left)
            {
                int z2 = minZ;
                if (z2 <= maxZ)
                {
                    yield return(new IntVec3(minX - 1, thingCent.y, z2));

                    /*Error: Unable to find new state assignment for yield return*/;
                }
            }
            if (dir == LinkDirections.Right)
            {
                int z = minZ;
                if (z <= maxZ)
                {
                    yield return(new IntVec3(maxX + 1, thingCent.y, z));

                    /*Error: Unable to find new state assignment for yield return*/;
                }
            }
        }
        public static Thing Spawn(Thing newThing, IntVec3 loc, Map map, Rot4 rot, WipeMode wipeMode = WipeMode.Vanish, bool respawningAfterLoad = false)
        {
            if (map == null)
            {
                Log.Error("Tried to spawn " + newThing.ToStringSafe() + " in a null map.");
                return(null);
            }
            if (!loc.InBounds(map))
            {
                Log.Error(string.Concat("Tried to spawn ", newThing.ToStringSafe(), " out of bounds at ", loc, "."));
                return(null);
            }
            if (newThing.def.randomizeRotationOnSpawn)
            {
                rot = Rot4.Random;
            }
            CellRect occupiedRect = GenAdj.OccupiedRect(loc, rot, newThing.def.Size);

            if (!occupiedRect.InBounds(map))
            {
                Log.Error(string.Concat("Tried to spawn ", newThing.ToStringSafe(), " out of bounds at ", loc, " (out of bounds because size is ", newThing.def.Size, ")."));
                return(null);
            }
            if (newThing.Spawned)
            {
                Log.Error(string.Concat("Tried to spawn ", newThing, " but it's already spawned."));
                return(newThing);
            }
            switch (wipeMode)
            {
            case WipeMode.Vanish:
                WipeExistingThings(loc, rot, newThing.def, map, DestroyMode.Vanish);
                break;

            case WipeMode.FullRefund:
                WipeAndRefundExistingThings(loc, rot, newThing.def, map);
                break;

            case WipeMode.VanishOrMoveAside:
                CheckMoveItemsAside(loc, rot, newThing.def, map);
                WipeExistingThings(loc, rot, newThing.def, map, DestroyMode.Vanish);
                break;
            }
            if (newThing.def.category == ThingCategory.Item)
            {
                foreach (IntVec3 item in occupiedRect)
                {
                    foreach (Thing item2 in item.GetThingList(map).ToList())
                    {
                        if (item2 != newThing && item2.def.category == ThingCategory.Item)
                        {
                            item2.DeSpawn();
                            if (!GenPlace.TryPlaceThing(item2, item, map, ThingPlaceMode.Near, null, (IntVec3 x) => !occupiedRect.Contains(x)))
                            {
                                item2.Destroy();
                            }
                        }
                    }
                }
            }
            newThing.Rotation = rot;
            newThing.Position = loc;
            if (newThing.holdingOwner != null)
            {
                newThing.holdingOwner.Remove(newThing);
            }
            newThing.SpawnSetup(map, respawningAfterLoad);
            if (newThing.Spawned && newThing.stackCount == 0)
            {
                Log.Error("Spawned thing with 0 stackCount: " + newThing);
                newThing.Destroy();
                return(null);
            }
            if (newThing.def.passability == Traversability.Impassable)
            {
                foreach (IntVec3 item3 in occupiedRect)
                {
                    foreach (Thing item4 in item3.GetThingList(map).ToList())
                    {
                        if (item4 != newThing)
                        {
                            (item4 as Pawn)?.pather.TryRecoverFromUnwalkablePosition(error: false);
                        }
                    }
                }
                return(newThing);
            }
            return(newThing);
        }
 public static bool WouldWipeAnythingWith(IntVec3 thingPos, Rot4 thingRot, BuildableDef thingDef, Map map, Predicate <Thing> predicate)
 {
     return(WouldWipeAnythingWith(GenAdj.OccupiedRect(thingPos, thingRot, thingDef.Size), thingDef, map, predicate));
 }
Exemple #10
0
        public static bool TryFindRandomEdgeCellWith(Predicate <IntVec3> validator, Map map, Rot4 dir, float roadChance, out IntVec3 result)
        {
            if (Rand.Value < roadChance)
            {
                bool flag = (from c in map.roadInfo.roadEdgeTiles
                             where validator(c) && c.OnEdge(map, dir)
                             select c).TryRandomElement(out result);
                if (flag)
                {
                    return(flag);
                }
            }
            for (int i = 0; i < 100; i++)
            {
                result = CellFinder.RandomEdgeCell(dir, map);
                if (validator(result))
                {
                    return(true);
                }
            }
            int asInt = dir.AsInt;

            if (CellFinder.mapSingleEdgeCells[asInt] == null || map.Size != CellFinder.mapSingleEdgeCellsSize)
            {
                CellFinder.mapSingleEdgeCellsSize    = map.Size;
                CellFinder.mapSingleEdgeCells[asInt] = new List <IntVec3>();
                foreach (IntVec3 item in CellRect.WholeMap(map).GetEdgeCells(dir))
                {
                    CellFinder.mapSingleEdgeCells[asInt].Add(item);
                }
            }
            List <IntVec3> list = CellFinder.mapSingleEdgeCells[asInt];

            list.Shuffle <IntVec3>();
            int j     = 0;
            int count = list.Count;

            while (j < count)
            {
                try
                {
                    if (validator(list[j]))
                    {
                        result = list[j];
                        return(true);
                    }
                }
                catch (Exception ex)
                {
                    Log.Error(string.Concat(new object[]
                    {
                        "TryFindRandomEdgeCellWith exception validating ",
                        list[j],
                        ": ",
                        ex.ToString()
                    }), false);
                }
                j++;
            }
            result = IntVec3.Invalid;
            return(false);
        }
Exemple #11
0
        public static IntVec3 FindNoWipeSpawnLocNear(IntVec3 near, Map map, ThingDef thingToSpawn, Rot4 rot, int maxDist = 2, Predicate <IntVec3> extraValidator = null)
        {
            int     num    = GenRadial.NumCellsInRadius((float)maxDist);
            IntVec3 intVec = IntVec3.Invalid;
            float   num2   = 0f;

            for (int i = 0; i < num; i++)
            {
                IntVec3 intVec2 = near + GenRadial.RadialPattern[i];
                if (intVec2.InBounds(map))
                {
                    CellRect cellRect = GenAdj.OccupiedRect(intVec2, rot, thingToSpawn.size);
                    if (cellRect.InBounds(map))
                    {
                        if (GenSight.LineOfSight(near, intVec2, map, true, null, 0, 0))
                        {
                            if (extraValidator == null || extraValidator(intVec2))
                            {
                                if (thingToSpawn.category != ThingCategory.Building || GenConstruct.CanBuildOnTerrain(thingToSpawn, intVec2, map, rot, null))
                                {
                                    bool flag  = false;
                                    bool flag2 = false;
                                    CellFinder.tmpUniqueWipedThings.Clear();
                                    CellRect.CellRectIterator iterator = cellRect.GetIterator();
                                    while (!iterator.Done())
                                    {
                                        if (iterator.Current.Impassable(map))
                                        {
                                            flag2 = true;
                                        }
                                        List <Thing> thingList = iterator.Current.GetThingList(map);
                                        for (int j = 0; j < thingList.Count; j++)
                                        {
                                            if (thingList[j] is Pawn)
                                            {
                                                flag = true;
                                            }
                                            else if (GenSpawn.SpawningWipes(thingToSpawn, thingList[j].def) && !CellFinder.tmpUniqueWipedThings.Contains(thingList[j]))
                                            {
                                                CellFinder.tmpUniqueWipedThings.Add(thingList[j]);
                                            }
                                        }
                                        iterator.MoveNext();
                                    }
                                    if (flag && thingToSpawn.passability == Traversability.Impassable)
                                    {
                                        CellFinder.tmpUniqueWipedThings.Clear();
                                    }
                                    else if (flag2 && thingToSpawn.category == ThingCategory.Item)
                                    {
                                        CellFinder.tmpUniqueWipedThings.Clear();
                                    }
                                    else
                                    {
                                        float num3 = 0f;
                                        for (int k = 0; k < CellFinder.tmpUniqueWipedThings.Count; k++)
                                        {
                                            if (CellFinder.tmpUniqueWipedThings[k].def.category == ThingCategory.Building && !CellFinder.tmpUniqueWipedThings[k].def.costList.NullOrEmpty <ThingDefCountClass>() && CellFinder.tmpUniqueWipedThings[k].def.costStuffCount == 0)
                                            {
                                                List <ThingDefCountClass> list = CellFinder.tmpUniqueWipedThings[k].CostListAdjusted();
                                                for (int l = 0; l < list.Count; l++)
                                                {
                                                    num3 += list[l].thingDef.GetStatValueAbstract(StatDefOf.MarketValue, null) * (float)list[l].count * (float)CellFinder.tmpUniqueWipedThings[k].stackCount;
                                                }
                                            }
                                            else
                                            {
                                                num3 += CellFinder.tmpUniqueWipedThings[k].MarketValue * (float)CellFinder.tmpUniqueWipedThings[k].stackCount;
                                            }
                                            if (CellFinder.tmpUniqueWipedThings[k].def.category == ThingCategory.Building || CellFinder.tmpUniqueWipedThings[k].def.category == ThingCategory.Item)
                                            {
                                                num3 = Mathf.Max(num3, 0.001f);
                                            }
                                        }
                                        CellFinder.tmpUniqueWipedThings.Clear();
                                        if (!intVec.IsValid || num3 < num2)
                                        {
                                            if (num3 == 0f)
                                            {
                                                return(intVec2);
                                            }
                                            intVec = intVec2;
                                            num2   = num3;
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
            return((!intVec.IsValid) ? near : intVec);
        }
        public static Thing Spawn(Thing newThing, IntVec3 loc, Map map, Rot4 rot, WipeMode wipeMode = WipeMode.Vanish, bool respawningAfterLoad = false)
        {
            if (map == null)
            {
                Log.Error("Tried to spawn " + newThing.ToStringSafe <Thing>() + " in a null map.", false);
                return(null);
            }
            if (!loc.InBounds(map))
            {
                Log.Error(string.Concat(new object[]
                {
                    "Tried to spawn ",
                    newThing.ToStringSafe <Thing>(),
                    " out of bounds at ",
                    loc,
                    "."
                }), false);
                return(null);
            }
            if (newThing.def.randomizeRotationOnSpawn)
            {
                rot = Rot4.Random;
            }
            CellRect occupiedRect = GenAdj.OccupiedRect(loc, rot, newThing.def.Size);

            if (!occupiedRect.InBounds(map))
            {
                Log.Error(string.Concat(new object[]
                {
                    "Tried to spawn ",
                    newThing.ToStringSafe <Thing>(),
                    " out of bounds at ",
                    loc,
                    " (out of bounds because size is ",
                    newThing.def.Size,
                    ")."
                }), false);
                return(null);
            }
            if (newThing.Spawned)
            {
                Log.Error("Tried to spawn " + newThing + " but it's already spawned.", false);
                return(newThing);
            }
            if (wipeMode == WipeMode.Vanish)
            {
                GenSpawn.WipeExistingThings(loc, rot, newThing.def, map, DestroyMode.Vanish);
            }
            else if (wipeMode == WipeMode.FullRefund)
            {
                GenSpawn.WipeAndRefundExistingThings(loc, rot, newThing.def, map);
            }
            if (newThing.def.category == ThingCategory.Item)
            {
                foreach (IntVec3 intVec in occupiedRect)
                {
                    foreach (Thing thing in intVec.GetThingList(map).ToList <Thing>())
                    {
                        if (thing != newThing)
                        {
                            if (thing.def.category == ThingCategory.Item)
                            {
                                thing.DeSpawn(DestroyMode.Vanish);
                                if (!GenPlace.TryPlaceThing(thing, intVec, map, ThingPlaceMode.Near, null, (IntVec3 x) => !occupiedRect.Contains(x)))
                                {
                                    thing.Destroy(DestroyMode.Vanish);
                                }
                            }
                        }
                    }
                }
            }
            newThing.Rotation = rot;
            newThing.Position = loc;
            if (newThing.holdingOwner != null)
            {
                newThing.holdingOwner.Remove(newThing);
            }
            newThing.SpawnSetup(map, respawningAfterLoad);
            if (newThing.Spawned && newThing.stackCount == 0)
            {
                Log.Error("Spawned thing with 0 stackCount: " + newThing, false);
                newThing.Destroy(DestroyMode.Vanish);
                return(null);
            }
            if (newThing.def.passability == Traversability.Impassable)
            {
                foreach (IntVec3 c in occupiedRect)
                {
                    foreach (Thing thing2 in c.GetThingList(map).ToList <Thing>())
                    {
                        if (thing2 != newThing)
                        {
                            Pawn pawn = thing2 as Pawn;
                            if (pawn != null)
                            {
                                pawn.pather.TryRecoverFromUnwalkablePosition(false);
                            }
                        }
                    }
                }
            }
            return(newThing);
        }
 public override void DrawWorker(Vector3 loc, Rot4 rot, ThingDef thingDef, Thing thing, float extraRotation)
 {
     Log.ErrorOnce("Graphic_Scatter cannot draw realtime.", 9432243);
 }
Exemple #14
0
 public virtual AcceptanceReport AllowsPlacing(BuildableDef checkingDef, IntVec3 loc, Rot4 rot, Map map, Thing thingToIgnore = null)
 {
     return(AcceptanceReport.WasAccepted);
 }
Exemple #15
0
 public virtual void DrawGhost(ThingDef def, IntVec3 center, Rot4 rot, Color ghostCol)
 {
 }
Exemple #16
0
 public virtual void PostPlace(Map map, BuildableDef def, IntVec3 loc, Rot4 rot)
 {
 }