/* * public void loaderMoved2(Vector2I centre) * { * int dimension = _properties.worldDimension; * * // Work out the new bottom left corner position * int half = (dimension - 1) / 2; * Vector2I newCorner = centre + new Vector2I(-half, -half); * _position = newCorner; * * // Tell the sector map to update its loaded sectors incase we're going out of its bounds * _mapHandler.updatePosition(_position); * * List<Vector2I> newPoints = new List<Vector2I>(); * * // Determine where the new chunks are going to be * for(int i = 0; i < dimension; i++) * { * for(int j = 0; j < dimension; j++) * { * newPoints.Add(newCorner + new Vector2I(i, j)); * } * } * * List<ChunkWorldObject> preservedChunks = new List<ChunkWorldObject>(); * List<ChunkWorldObject> replacedChunks = new List<ChunkWorldObject>(); * * // Find all chunks which will be preserved * for (int i = 0; i < _activeChunks.Count; i++) * { * ChunkWorldObject obj = _activeChunks[i]; * Chunk chunk = obj.chunk; * * // Does the chunk actually exist? * if (chunk != null) * { * Vector2I pos = chunk.position; * // Will this chunk be in the new set of chunks? * if (newPoints.Contains(pos)) * { * preservedChunks.Add(_activeChunks[i]); * } * else // This chunk will be unloaded * { * replacedChunks.Add(_activeChunks[i]); * } * } * else // The chunk is NULL, queue it for re-use in-case * { * replacedChunks.Add(_activeChunks[i]); * } * } * * for(int i = 0; i < newPoints.Count; i++) * { * Vector2I pos = newPoints[i]; * * for(int j = 0; j < preservedChunks.Count; j++) * { * * } * * Chunk chunk = _mapHandler.getChunk(pos); * * if(chunk != null) * { * * } * } * * // determine chunks to be loaded * . * * }*/ /// <summary> /// Called when the loader has moved to a different chunk, re-adjust the chunks /// to fit the zone around it. /// </summary> /// <param name="centre"></param> public void loaderMoved2(Vector2I centre) { // add chunk behaviour here // adjust chunks // tell sectors to load if need be // Work out the new bottom left corner position int half = (_properties.worldDimension - 1) / 2; Vector2I newCorner = centre + new Vector2I(-half, -half); _position = newCorner; // Tell the sector map to update its loaded sectors incase we're going out of its bounds _mapHandler.updatePosition(_position); // Re-adjust the chunks for (int i = 0; i < _properties.worldDimension; i++) { for (int j = 0; j < _properties.worldDimension; j++) { // Load the desired chunk from the mapping handler Chunk chunk = _mapHandler.getChunk(newCorner + new Vector2I(i, j)); ChunkWorldObject container = _localChunks[i, j]; // Check whether or not the desired chunk exists yet if (chunk != null) { // Debug.Log("Loading chunk at pos " + (newCorner + new Vector2I(i, j)) + " which is" + chunk.position); container.setChunk(chunk); chunk.setContainer(container); // Flag the chunk as dirty as its moved chunk.setDirtyState(true); } else // The chunk is NULL (not inside the map) { container.name = "Empty Chunk"; container.setChunk(null); // Debug.Log("Chunk is NULL at " + (new Vector2I(i, j) + newCorner)); } } } }
/// <summary> /// Generate the worlds chunks at a loaded position /// </summary> public void createWorld() { int dimension = _properties.worldDimension; _localChunks = new ChunkWorldObject[dimension, dimension]; _activeChunks = new List <ChunkWorldObject>(); Material material = Resources.Load <Material>(_path); material.mainTexture = Atlas.atlas; // Iterate and create the initial chunks for (int i = 0; i < dimension; i++) { for (int j = 0; j < dimension; j++) { // Create the chunk container object Vector2I pos = _position + new Vector2I(i, j); GameObject obj = new GameObject(string.Format("Chunk {0}", pos)); ChunkWorldObject container = obj.AddComponent <ChunkWorldObject>(); container.setMaterial(material); _activeChunks.Add(container); Chunk chunk = _mapHandler.getChunk(pos); if (chunk != null) { chunk.setContainer(container); container.setChunk(chunk); chunk.setDirtyState(true); // Update the collision map // CollisionGrid.setChunk(chunk); } else { container.name = "Empty Chunk"; container.setChunk(null); } } } return; // Create all the chunks and initialize them for (int i = 0; i < _properties.worldDimension; i++) { for (int j = 0; j < _properties.worldDimension; j++) { GameObject obj = new GameObject(); ChunkWorldObject container = obj.AddComponent <ChunkWorldObject>(); container.setMaterial(material); _localChunks[i, j] = container; // Load the desired chunk and set its data Chunk chunk = _mapHandler.getChunk(_position + new Vector2I(i, j)); // Only attach the container if the chunk requested isn't NULL if (chunk != null) { chunk.setContainer(container); chunk.setDirtyState(true); container.setChunk(chunk); } else { container.name = "Empty Chunk"; container.setChunk(null); } } } }
public void loaderMoved(Vector2I centre) { int dimension = _properties.worldDimension; // Work out the new bottom left corner position int half = (dimension - 1) / 2; Vector2I newCorner = centre + new Vector2I(-half, -half); // Tell the sector map to update its loaded sectors incase we're going out of its bounds _mapHandler.updatePosition(centre); List <Vector2I> newPoints = new List <Vector2I>(); List <Vector2I> oldPoints = new List <Vector2I>(); List <ChunkWorldObject> unallocated = new List <ChunkWorldObject>(); List <ChunkWorldObject> cache = new List <ChunkWorldObject>(); List <ChunkWorldObject> final = new List <ChunkWorldObject>(); // Collect all the initial and new chunk positions for (int i = 0; i < dimension; i++) { for (int j = 0; j < dimension; j++) { newPoints.Add(newCorner + new Vector2I(i, j)); oldPoints.Add(_position + new Vector2I(i, j)); } } // Set the new position _position = newCorner; // Determine which chunks need to be unloaded and which need to be kept // by intersecting the two sets to find the matching chunks for (int i = 0; i < _activeChunks.Count; i++) { ChunkWorldObject chunkObj = _activeChunks[i]; Chunk chunk = chunkObj.chunk; // Ideally chunks shouldn't be loaded NULL like this but catch the case where it for some // reason happens if (chunk != null) { if (newPoints.Contains(chunk.position)) // Check for intersection { cache.Add(chunkObj); final.Add(chunkObj); } else // The chunk is going to be unloaded { // Clear the mesh and store it chunkObj.clearMesh(); storeContainer(chunkObj); } } else // The current chunk isn't loaded so it can be re-pooled { chunkObj.clearMesh(); storeContainer(chunkObj); } } // Figure out which chunks need to be loaded and re-use the previous NULL chunks // for the new chunk data to be loaded into for (int i = 0; i < newPoints.Count; i++) { Vector2I pos = newPoints[i]; // The new point isn't already loaded so it needs to be generated if (!oldPoints.Contains(pos)) { // Fetch the chunk data Chunk chunk = _mapHandler.getChunk(pos); // Make sure the chunk is not NULL if (chunk != null) { // Get a spare chunk container ChunkWorldObject obj = getContainer(); obj.setChunk(chunk); chunk.setContainer(obj); chunk.setDirtyState(true); // Update the collision map // CollisionGrid.setChunk(chunk); // Store the container final.Add(obj); } } } // Overwrite the active chunks _activeChunks = final; //// Re-add the cached chunks to the final list //for (int i = 0; i < cache.Count; i++) //{ // final.Add(cache[i]); //} //// Re-add any unallocated chunks //for (int i = 0; i < unallocated.Count; i++) //{ // _activeChunks.Add(unallocated[i]); //} //// Check for lost chunks //if(final.Count != _activeChunks.Count) //{ // throw new System.Exception("Mismatching chunk count detected " + final.Count + " chunks were found but expected " + _activeChunks.Count); //} //_activeChunks = final; // Set the position after chunk data has been re-arranged }