예제 #1
0
        protected override void loadChunks(ChunkPos occupiedChunkPos)
        {
            int  x, y, z;
            bool flagX, flagY, flagZ, isReadOnly;

            for (x = -this.loadRadius; x <= this.loadRadius; x++)
            {
                for (y = -this.loadRadius; y <= this.loadRadius; y++)
                {
                    for (z = -this.loadRadius; z <= this.loadRadius; z++)
                    {
                        flagX = Math.Abs(x) == loadRadius;
                        flagY = Math.Abs(y) == loadRadius;
                        flagZ = Math.Abs(z) == loadRadius;

                        isReadOnly = flagX || flagY || flagZ;
                        NewChunkInstructions instructions = new NewChunkInstructions(x + occupiedChunkPos.x, y + occupiedChunkPos.y, z + occupiedChunkPos.z, isReadOnly);
                        Chunk chunk = world.getChunk(instructions.chunkPos);

                        if (chunk == null)
                        {
                            if (!this.buildQueue.Contains(instructions))
                            {
                                this.buildQueue.Enqueue(instructions);
                            }
                        }
                        else
                        {
                            chunk.isReadOnly = isReadOnly;
                        }
                    }
                }
            }
        }
예제 #2
0
        /// <summary>
        /// Generates up to the passed number of chunks, or infinite if -1.  Then returns the total number generated.
        /// </summary>
        private int generateChunksFromInstructions(int max)
        {
            int builtChunks = 0;

            while (this.buildQueue.Count > 0 && (builtChunks < max || max == -1))
            {
                NewChunkInstructions instructions = this.buildQueue.Dequeue();
                Chunk chunk;
                if (this.cachedUnusedChunks.Count > 0)
                {
                    // Pull out and reset an old chunk.
                    chunk = this.cachedUnusedChunks.Dequeue();
                    chunk.gameObject.SetActive(true);
                    chunk.filter.mesh.Clear(); // TODO Large performance hit?
                }
                else
                {
                    // The cache queue is empty, create a new chunk from scratch.
                    chunk = GameObject.Instantiate(References.list.chunkPrefab, this.world.chunkWrapper).GetComponent <Chunk>();
                }

                chunk.transform.position = instructions.toChunkVector();

                this.world.loadChunk(chunk, instructions);

                builtChunks++;
            }
            return(builtChunks);
        }
        protected override void loadYAxis(ChunkPos occupiedChunkPos, int x, int z, bool isReadOnly)
        {
            for (int y = 0; y < this.worldHeight; y++)
            {
                NewChunkInstructions instructions = new NewChunkInstructions(x + occupiedChunkPos.x, y + occupiedChunkPos.y, z + occupiedChunkPos.z, isReadOnly);
                Chunk chunk = world.getChunk(instructions.chunkPos);

                if (chunk == null)
                {
                    if (!this.buildQueue.Contains(instructions))
                    {
                        this.buildQueue.Enqueue(instructions);
                    }
                }
                else
                {
                    chunk.isReadOnly = isReadOnly;
                }
            }
        }