예제 #1
0
        public static AnvilWorldProvider GetLevelProvider(LevelManager levelManager, string levelDir, bool readOnly = true, bool insulate = true, bool cache = true)
        {
            ProviderCache.TryGetValue(levelDir, out var provider);

            if (provider != null)
            {
                return(readOnly ? provider : (AnvilWorldProvider)provider.Clone());
            }

            provider = new AnvilWorldProvider(levelDir);

            var level = new CacheLevel(levelManager, "cache", provider, new EntityManager(), viewDistance: 20)
            {
                EnableBlockTicking = false,
                EnableChunkTicking = false
            };

            level.Initialize();

            RecalculateLight(level, provider);

            level.Close();

            provider.PruneAir();
            provider.MakeAirChunksAroundWorldToCompensateForBadRendering();

            if (insulate)
            {
                InsulateChunks(provider);
            }
            if (cache)
            {
                ProviderCache.Add(levelDir, provider);
            }

            return(readOnly ? provider : (AnvilWorldProvider)provider.Clone());
        }
예제 #2
0
        public virtual Level GetLevel(Player player, string name)
        {
            Level level = Levels.FirstOrDefault(l => l.LevelId.Equals(name, StringComparison.InvariantCultureIgnoreCase));

            if (level == null)
            {
                GameMode   gameMode           = Config.GetProperty("GameMode", GameMode.Survival);
                Difficulty difficulty         = Config.GetProperty("Difficulty", Difficulty.Normal);
                int        viewDistance       = Config.GetProperty("ViewDistance", 11);
                bool       enableBlockTicking = Config.GetProperty("EnableBlockTicking", false);
                bool       enableChunkTicking = Config.GetProperty("EnableChunkTicking", false);
                bool       isWorldTimeStarted = Config.GetProperty("IsWorldTimeStarted", false);

                IWorldProvider worldProvider = null;

                switch (Config.GetProperty("WorldProvider", "flat").ToLower().Trim())
                {
                case "flat":
                case "flatland":
                    worldProvider = new FlatlandWorldProvider();
                    break;

                case "cool":
                    worldProvider = new CoolWorldProvider();
                    break;

                case "experimental":
                    worldProvider = new ExperimentalWorldProvider();
                    break;

                case "anvil":
                    worldProvider = new AnvilWorldProvider()
                    {
                        MissingChunkProvider = new FlatlandWorldProvider()
                    };
                    break;

                default:
                    worldProvider = new FlatlandWorldProvider();
                    break;
                }

                level = new Level(name, worldProvider, EntityManager, gameMode, difficulty, viewDistance)
                {
                    EnableBlockTicking = enableBlockTicking,
                    EnableChunkTicking = enableChunkTicking,
                    IsWorldTimeStarted = isWorldTimeStarted
                };
                level.Initialize();

                if (Config.GetProperty("CalculateLights", false))
                {
                    {
                        AnvilWorldProvider wp = level._worldProvider as AnvilWorldProvider;
                        if (wp != null)
                        {
                            wp.PruneAir();
                            wp.MakeAirChunksAroundWorldToCompensateForBadRendering();

                            SkyLightCalculations.Calculate(level);

                            Stopwatch sw = new Stopwatch();

                            int count = wp.LightSources.Count;
                            sw.Restart();
                            RecalculateBlockLight(level, wp);

                            var chunkCount = wp._chunkCache.Where(chunk => chunk.Value != null).ToArray().Length;
                            Log.Debug($"Recalc light for {chunkCount} chunks, {chunkCount*16*16*256} blocks and {count} light sources. Time {sw.ElapsedMilliseconds}ms");
                        }
                    }

                    {
                        FlatlandWorldProvider wp = level._worldProvider as FlatlandWorldProvider;
                        if (wp != null)
                        {
                            SkyLightCalculations.Calculate(level);
                        }
                    }
                }
                Levels.Add(level);

                OnLevelCreated(new LevelEventArgs(null, level));
            }

            return(level);
        }