public static bool RestrictionCheckTerrain(TerrainComp __instance, string restriction)
        {
            TerrainComp p = __instance;

            // Are we in a zone? if so select that zone.
            if (ZoneHandler.Zones.Count() == 0)
            {
                return(false);
            }
            ZoneHandler.Zone        z     = new ZoneHandler.Zone();
            ZoneHandler.ZoneTypes   zt    = new ZoneHandler.ZoneTypes();
            List <ZoneHandler.Zone> zlist = ZoneHandler.ListOccupiedZones(p.transform.position);

            if (zlist.Count == 0)
            {
                zt = ZoneHandler.FindZoneType("wilderness");
            }
            else
            {
                z  = ZoneHandler.TopZone(zlist);
                zt = ZoneHandler.FindZoneType(z.Type);
            }
            string key    = "";
            string admins = "";

            // Lets set our admin list and keys...
            admins = zt.Admins;
            key    = zt.Configurations;
            if (key.ToLower().Contains(restriction))
            {
                return(true);
            }
            else
            {
                return(false);
            }
        }
Exemplo n.º 2
0
        private static int ResetTerrain(Vector3 center, float radius)
        {
            int resets            = 0;
            List <Heightmap> list = new List <Heightmap>();


            Heightmap.FindHeightmap(center, radius + 100, list);


            List <TerrainModifier> allInstances = TerrainModifier.GetAllInstances();

            foreach (TerrainModifier terrainModifier in allInstances)
            {
                Vector3  position = terrainModifier.transform.position;
                ZNetView nview    = terrainModifier.GetComponent <ZNetView>();
                if (nview != null && nview.IsValid() && nview.IsOwner() && Utils.DistanceXZ(position, center) <= radius)
                {
                    //Dbgl($"TerrainModifier {position}, player {playerPos}, distance: {Utils.DistanceXZ(position, playerPos)}");
                    resets++;
                    foreach (Heightmap heightmap in list)
                    {
                        if (heightmap.TerrainVSModifier(terrainModifier))
                        {
                            heightmap.Poke(true);
                        }
                    }
                    nview.Destroy();
                }
            }
            Dbgl($"Reset {resets} mod edits");

            using (List <Heightmap> .Enumerator enumerator = list.GetEnumerator())
            {
                while (enumerator.MoveNext())
                {
                    TerrainComp terrainComp = TerrainComp.FindTerrainCompiler(enumerator.Current.transform.position);
                    if (!terrainComp)
                    {
                        continue;
                    }
                    Traverse traverse = Traverse.Create(terrainComp);

                    if (!traverse.Field("m_initialized").GetValue <bool>())
                    {
                        continue;
                    }

                    enumerator.Current.WorldToVertex(center, out int x, out int y);

                    bool[]  m_modifiedHeight = traverse.Field("m_modifiedHeight").GetValue <bool[]>();
                    float[] m_levelDelta     = traverse.Field("m_levelDelta").GetValue <float[]>();
                    float[] m_smoothDelta    = traverse.Field("m_smoothDelta").GetValue <float[]>();
                    bool[]  m_modifiedPaint  = traverse.Field("m_modifiedPaint").GetValue <bool[]>();
                    Color[] m_paintMask      = traverse.Field("m_paintMask").GetValue <Color[]>();

                    int m_width = traverse.Field("m_width").GetValue <int>();

                    Dbgl($"Checking heightmap at {terrainComp.transform.position}");
                    int  thisResets = 0;
                    bool thisReset  = false;
                    int  num        = m_width + 1;
                    for (int h = 0; h < num; h++)
                    {
                        for (int w = 0; w < num; w++)
                        {
                            int idx = h * num + w;

                            if (!m_modifiedHeight[idx])
                            {
                                continue;
                            }

                            //Dbgl($"Player coord {x},{y} coord {w},{h}, distance {CoordDistance(x, y, w, h)} has edits. ");

                            if (CoordDistance(x, y, w, h) > radius)
                            {
                                continue;
                            }

                            //Dbgl("In range, resetting");

                            resets++;
                            thisResets++;
                            thisReset = true;

                            m_modifiedHeight[idx] = false;
                            m_levelDelta[idx]     = 0;
                            m_smoothDelta[idx]    = 0;
                        }
                    }

                    num = m_width;
                    for (int h = 0; h < num; h++)
                    {
                        for (int w = 0; w < num; w++)
                        {
                            int idx = h * num + w;

                            if (!m_modifiedPaint[idx])
                            {
                                continue;
                            }

                            if (CoordDistance(x, y, w, h) > radius)
                            {
                                continue;
                            }

                            thisReset            = true;
                            m_modifiedPaint[idx] = false;
                            m_paintMask[idx]     = Color.clear;
                        }
                    }

                    if (thisReset)
                    {
                        Dbgl($"\tReset {thisResets} comp edits");

                        traverse.Field("m_modifiedHeight").SetValue(m_modifiedHeight);
                        traverse.Field("m_levelDelta").SetValue(m_levelDelta);
                        traverse.Field("m_smoothDelta").SetValue(m_smoothDelta);
                        traverse.Field("m_modifiedPaint").SetValue(m_modifiedPaint);
                        traverse.Field("m_paintMask").SetValue(m_paintMask);

                        traverse.Method("Save").GetValue();
                        enumerator.Current.Poke(true);
                    }
                }
            }

            if (resets > 0 && ClutterSystem.instance)
            {
                ClutterSystem.instance.ResetGrass(center, radius);
            }

            return(resets);
        }