Пример #1
0
        public override IEnumerable Regenerate()
        {
            foreach (object result in base.Regenerate())
            {
                yield return(result);
            }
            Rand.PushState();
            Rand.Seed = Find.World.info.Seed;
            WorldGrid grid       = Find.WorldGrid;
            int       tilesCount = grid.TilesCount;
            int       i          = 0;

            while (i < tilesCount)
            {
                Tile       tile = grid[i];
                Material   material;
                FloatRange floatRange;
                switch (tile.hilliness)
                {
                case Hilliness.SmallHills:
                    material   = WorldMaterials.SmallHills;
                    floatRange = WorldLayer_Hills.BasePosOffsetRange_SmallHills;
                    goto IL_180;

                case Hilliness.LargeHills:
                    material   = WorldMaterials.LargeHills;
                    floatRange = WorldLayer_Hills.BasePosOffsetRange_LargeHills;
                    goto IL_180;

                case Hilliness.Mountainous:
                    material   = WorldMaterials.Mountains;
                    floatRange = WorldLayer_Hills.BasePosOffsetRange_Mountains;
                    goto IL_180;

                case Hilliness.Impassable:
                    material   = WorldMaterials.ImpassableMountains;
                    floatRange = WorldLayer_Hills.BasePosOffsetRange_ImpassableMountains;
                    goto IL_180;
                }
IL_25C:
                i++;
                continue;
IL_180:
                LayerSubMesh subMesh = base.GetSubMesh(material);
                Vector3 vector         = grid.GetTileCenter(i);
                Vector3 posForTangents = vector;
                float   magnitude      = vector.magnitude;
                vector = (vector + Rand.UnitVector3 * floatRange.RandomInRange * grid.averageTileSize).normalized * magnitude;
                WorldRendererUtility.PrintQuadTangentialToPlanet(vector, posForTangents, WorldLayer_Hills.BaseSizeRange.RandomInRange * grid.averageTileSize, 0.005f, subMesh, false, true, false);
                WorldRendererUtility.PrintTextureAtlasUVs(Rand.Range(0, WorldLayer_Hills.TexturesInAtlas.x), Rand.Range(0, WorldLayer_Hills.TexturesInAtlas.z), WorldLayer_Hills.TexturesInAtlas.x, WorldLayer_Hills.TexturesInAtlas.z, subMesh);
                goto IL_25C;
            }
            Rand.PopState();
            base.FinalizeMesh(MeshParts.All);
        }
Пример #2
0
        public override IEnumerable Regenerate()
        {
            foreach (object item in base.Regenerate())
            {
                yield return(item);
            }
            Rand.PushState();
            Rand.Seed = Find.World.info.Seed;
            WorldGrid worldGrid  = Find.WorldGrid;
            int       tilesCount = worldGrid.TilesCount;

            for (int i = 0; i < tilesCount; i++)
            {
                Material   material;
                FloatRange floatRange;
                switch (worldGrid[i].hilliness)
                {
                case Hilliness.SmallHills:
                    material   = WorldMaterials.SmallHills;
                    floatRange = BasePosOffsetRange_SmallHills;
                    break;

                case Hilliness.LargeHills:
                    material   = WorldMaterials.LargeHills;
                    floatRange = BasePosOffsetRange_LargeHills;
                    break;

                case Hilliness.Mountainous:
                    material   = WorldMaterials.Mountains;
                    floatRange = BasePosOffsetRange_Mountains;
                    break;

                case Hilliness.Impassable:
                    material   = WorldMaterials.ImpassableMountains;
                    floatRange = BasePosOffsetRange_ImpassableMountains;
                    break;

                default:
                    continue;
                }
                LayerSubMesh subMesh        = GetSubMesh(material);
                Vector3      tileCenter     = worldGrid.GetTileCenter(i);
                Vector3      posForTangents = tileCenter;
                float        magnitude      = tileCenter.magnitude;
                tileCenter = (tileCenter + Rand.UnitVector3 * floatRange.RandomInRange * worldGrid.averageTileSize).normalized * magnitude;
                WorldRendererUtility.PrintQuadTangentialToPlanet(tileCenter, posForTangents, BaseSizeRange.RandomInRange * worldGrid.averageTileSize, 0.005f, subMesh, counterClockwise: false, randomizeRotation: true, printUVs: false);
                WorldRendererUtility.PrintTextureAtlasUVs(Rand.Range(0, TexturesInAtlas.x), Rand.Range(0, TexturesInAtlas.z), TexturesInAtlas.x, TexturesInAtlas.z, subMesh);
            }
            Rand.PopState();
            FinalizeMesh(MeshParts.All);
        }
Пример #3
0
        public override IEnumerable Regenerate()
        {
            IEnumerator enumerator = this.< Regenerate > __BaseCallProxy0().GetEnumerator();

            try
            {
                while (enumerator.MoveNext())
                {
                    object result = enumerator.Current;
                    yield return(result);
                }
            }
            finally
            {
                IDisposable disposable;
                if ((disposable = (enumerator as IDisposable)) != null)
                {
                    disposable.Dispose();
                }
            }
            Rand.PushState();
            Rand.Seed = Find.World.info.Seed;
            WorldGrid grid       = Find.WorldGrid;
            int       tilesCount = grid.TilesCount;
            int       i          = 0;

            while (i < tilesCount)
            {
                Tile       tile = grid[i];
                Material   material;
                FloatRange floatRange;
                switch (tile.hilliness)
                {
                case Hilliness.SmallHills:
                    material   = WorldMaterials.SmallHills;
                    floatRange = WorldLayer_Hills.BasePosOffsetRange_SmallHills;
                    goto IL_185;

                case Hilliness.LargeHills:
                    material   = WorldMaterials.LargeHills;
                    floatRange = WorldLayer_Hills.BasePosOffsetRange_LargeHills;
                    goto IL_185;

                case Hilliness.Mountainous:
                    material   = WorldMaterials.Mountains;
                    floatRange = WorldLayer_Hills.BasePosOffsetRange_Mountains;
                    goto IL_185;

                case Hilliness.Impassable:
                    material   = WorldMaterials.ImpassableMountains;
                    floatRange = WorldLayer_Hills.BasePosOffsetRange_ImpassableMountains;
                    goto IL_185;
                }
IL_262:
                i++;
                continue;
IL_185:
                LayerSubMesh subMesh = base.GetSubMesh(material);
                Vector3 vector         = grid.GetTileCenter(i);
                Vector3 posForTangents = vector;
                float   magnitude      = vector.magnitude;
                vector = (vector + Rand.UnitVector3 * floatRange.RandomInRange * grid.averageTileSize).normalized * magnitude;
                WorldRendererUtility.PrintQuadTangentialToPlanet(vector, posForTangents, WorldLayer_Hills.BaseSizeRange.RandomInRange * grid.averageTileSize, 0.005f, subMesh, false, true, false);
                WorldRendererUtility.PrintTextureAtlasUVs(Rand.Range(0, WorldLayer_Hills.TexturesInAtlas.x), Rand.Range(0, WorldLayer_Hills.TexturesInAtlas.z), WorldLayer_Hills.TexturesInAtlas.x, WorldLayer_Hills.TexturesInAtlas.z, subMesh);
                goto IL_262;
            }
            Rand.PopState();
            base.FinalizeMesh(MeshParts.All);
            yield break;
        }
        public override IEnumerable Regenerate()
        {
            IEnumerator enumerator = base.Regenerate().GetEnumerator();

            try
            {
                if (enumerator.MoveNext())
                {
                    object result = enumerator.Current;
                    yield return(result);

                    /*Error: Unable to find new state assignment for yield return*/;
                }
            }
            finally
            {
                IDisposable disposable;
                IDisposable disposable2 = disposable = (enumerator as IDisposable);
                if (disposable != null)
                {
                    disposable2.Dispose();
                }
            }
            Rand.PushState();
            Rand.Seed = Find.World.info.Seed;
            WorldGrid grid       = Find.WorldGrid;
            int       tilesCount = grid.TilesCount;

            for (int i = 0; i < tilesCount; i++)
            {
                Tile         tile = grid[i];
                Material     material;
                FloatRange   floatRange;
                LayerSubMesh subMesh;
                Vector3      vector;
                Vector3      posForTangents;
                float        magnitude;
                IntVec2      texturesInAtlas;
                int          indexX;
                IntVec2      texturesInAtlas2;
                int          indexY;
                IntVec2      texturesInAtlas3;
                int          x;
                IntVec2      texturesInAtlas4;
                switch (tile.hilliness)
                {
                case Hilliness.SmallHills:
                    material   = WorldMaterials.SmallHills;
                    floatRange = WorldLayer_Hills.BasePosOffsetRange_SmallHills;
                    goto IL_0180;

                case Hilliness.LargeHills:
                    material   = WorldMaterials.LargeHills;
                    floatRange = WorldLayer_Hills.BasePosOffsetRange_LargeHills;
                    goto IL_0180;

                case Hilliness.Mountainous:
                    material   = WorldMaterials.Mountains;
                    floatRange = WorldLayer_Hills.BasePosOffsetRange_Mountains;
                    goto IL_0180;

                case Hilliness.Impassable:
                {
                    material   = WorldMaterials.ImpassableMountains;
                    floatRange = WorldLayer_Hills.BasePosOffsetRange_ImpassableMountains;
                    goto IL_0180;
                }
IL_0180:
                    subMesh        = base.GetSubMesh(material);
                    vector         = grid.GetTileCenter(i);
                    posForTangents = vector;
                    magnitude      = vector.magnitude;
                    vector        += Rand.UnitVector3 * floatRange.RandomInRange * grid.averageTileSize;
                    vector         = vector.normalized * magnitude;
                    WorldRendererUtility.PrintQuadTangentialToPlanet(vector, posForTangents, WorldLayer_Hills.BaseSizeRange.RandomInRange * grid.averageTileSize, 0.005f, subMesh, false, true, false);
                    texturesInAtlas  = WorldLayer_Hills.TexturesInAtlas;
                    indexX           = Rand.Range(0, texturesInAtlas.x);
                    texturesInAtlas2 = WorldLayer_Hills.TexturesInAtlas;
                    indexY           = Rand.Range(0, texturesInAtlas2.z);
                    texturesInAtlas3 = WorldLayer_Hills.TexturesInAtlas;
                    x = texturesInAtlas3.x;
                    texturesInAtlas4 = WorldLayer_Hills.TexturesInAtlas;
                    WorldRendererUtility.PrintTextureAtlasUVs(indexX, indexY, x, texturesInAtlas4.z, subMesh);
                    break;
                }
            }
            Rand.PopState();
            base.FinalizeMesh(MeshParts.All);
            yield break;
IL_0287:
            /*Error near IL_0288: Unexpected return in MoveNext()*/;
        }