public void AddPositions() { var a = new ChunkPosition(5, 10, 15); var b = new ChunkPosition(2, 3, 4); Assert.AreEqual(new ChunkPosition(7, 13, 19), a + b); }
private void RemoveChunk(ChunkPosition at) { if (!chunks.ContainsKey(at)) { GD.PushError("Error! Expected a chunk at (" + at.x + ", " + at.y + ", " + at.z + ") but none exist." ); } else { var chunk = chunks[at]; for (int i = 0; i < 6; i++) { var direction = (Direction)i; var opposite = (Direction)(i % 2 == 0 ? i + 1 : i - 1); WithChunk(at.Step(direction), other => { chunk.RemoveNeighbour(direction, other); other.RemoveNeighbour(opposite, chunk); }); } chunks.Remove(at); } }
public static int GetChebyshevDistance(ChunkPosition a, ChunkPosition b) { int dX = a.X - b.X; int dZ = a.Z - b.Z; return(Math.Max(Math.Abs(dX), Math.Abs(dZ))); }
ChunkPosition FindLongest(int buf_begin, int buf_end) { buf_end = Math.Min(buf_begin + MaxMatchSize, buf_end); ChunkPosition pos = new ChunkPosition { Offset = 0, Length = 0 }; for (int i = 0; i < 32; ++i) { int offset = buf_begin + m_shift_table[i]; if (offset < 0) { continue; } if (m_input[offset] != m_input[buf_begin]) { continue; } var last = Mismatch(buf_begin + 1, buf_end, offset + 1); int weight = last - offset; if (weight > pos.Length) { pos.Offset = (ushort)i; pos.Length = (ushort)weight; } } return(pos); }
public Chunk GetChunk(ChunkPosition position) { if (!_chunks.TryGetValue(position, out var chunk)) { //var air = _directBlockPalette.blockLookup["minecraft:air"].DefaultState; chunk = new Chunk(this, position); chunk._sections = _templateChunk._sections; _chunkInfos.Add(chunk, new ChunkInfo()); var section0 = chunk.Sections.Span[0]; //int y = 0; //section0.FillLevelBlock(_directBlockPalette.blockLookup["minecraft:bedrock"].DefaultState, y++); // //for (int j = 0; j < 3; j++) // section0.FillLevelBlock(_directBlockPalette.blockLookup["minecraft:dirt"].DefaultState, y++); // //section0.FillLevelBlock(_directBlockPalette.blockLookup["minecraft:grass_block"].DefaultState, y++); _chunks.Add(position, chunk); } var chunkInfo = _chunkInfos[chunk]; chunkInfo.Age = 0; return(chunk); }
public void SetBlock_GetBlock() { // Arrange var blockType1 = new Mock <IMeshBlockDetails>(); var blockType2 = new Mock <IMeshBlockDetails>(); var blockType3 = new Mock <IMeshBlockDetails>(); var blockPos1 = new BlockPosition(1, 1, 4); var blockPos2 = new BlockPosition(2, 2, 3); var blockPos3 = new BlockPosition(3, 3, 2); var blockPos4 = new BlockPosition(4, 4, 1); var chunkSize = new GridSize(3); var chunkPos = new ChunkPosition(1, 3, 6); var props = new ChunkProperties(); // Act props.Reset(chunkPos, chunkSize); props.SetBlock(blockPos1, blockType1.Object); props.SetBlock(blockPos2, blockType2.Object); props.SetBlock(blockPos3, blockType3.Object); // Assert Assert.AreEqual(blockType1.Object, props.GetBlock(blockPos1)); Assert.AreEqual(blockType2.Object, props.GetBlock(blockPos2)); Assert.AreEqual(blockType3.Object, props.GetBlock(blockPos3)); Assert.AreEqual(null, props.GetBlock(blockPos4)); }
void Shift(ChunkPosition position) { var difference = _previousPosition - position; if (difference == new ChunkPosition(0, 0)) { return; } var shiftedChunks = new bool[_viewDistance * 2 + 1, _viewDistance * 2 + 1]; // shift the array in the opposite way the observer is going. var minX = Math.Max(difference.ChunkX, 0); var minY = Math.Max(difference.ChunkZ, 0); var maxX = _generatedChunks.GetLength(0) + Math.Min(difference.ChunkX, 0); var maxY = _generatedChunks.GetLength(1) + Math.Min(difference.ChunkZ, 0); for (var i = minX; i < maxX; i++) { for (var j = minY; j < maxY; j++) { shiftedChunks[i, j] = _generatedChunks[i - difference.ChunkX, j - difference.ChunkZ]; } } _generatedChunks = shiftedChunks; _previousPosition = position; _firstNonGenerated = 0; }
/// <summary> /// Creates a new chunk object. /// </summary> /// <param name="chunkSize">The chunk size.</param> /// <param name="position">The size of this chunk in the world.</param> internal Chunk(GridSize chunkSize, ChunkPosition position) { Size = chunkSize; Position = position; m_Blocks = new ushort[Size.Volume]; }
/** * Generates a new random map around a point * @param Vector3 offset The offset position */ public bool generateMap(Vector3 playerPos) { ChunkPosition cp = closestNullChunk(playerPos); if (cp == null) { return(false); } Chunk chunk = new Chunk(cp.position, this); storeChunk(chunk); return(true); /** * * Random.InitState (Seed.MineralSeed); * for (int offsetY = 0; offsetY >= -1; offsetY--) { * //Generate mineral layer * Vector3 mineralVec = new Vector3 (chunkPos.x, chunkPos.y + (offsetY * Chunk.CHUNK_SIZE), chunkPos.z); * * Dictionary<Mineral.Type, Vector3[]> minerals = this.calculateMinerals ((int)mineralVec.y); * * if (chunkExists (mineralVec) == false) { * Chunk earth = new Chunk(mineralVec, this, true); * earth.GenMinerals (minerals); * * storeChunk (earth); * return true; * } * } * */ }
/// <summary> /// Called whenever this item is equipped and the right mouse button is pressed. Args: itemStack, world, entityPlayer /// </summary> public override ItemStack OnItemRightClick(ItemStack par1ItemStack, World par2World, EntityPlayer par3EntityPlayer) { MovingObjectPosition movingobjectposition = GetMovingObjectPositionFromPlayer(par2World, par3EntityPlayer, false); if (movingobjectposition != null && movingobjectposition.TypeOfHit == EnumMovingObjectType.TILE) { int i = par2World.GetBlockId(movingobjectposition.BlockX, movingobjectposition.BlockY, movingobjectposition.BlockZ); if (i == Block.EndPortalFrame.BlockID) { return(par1ItemStack); } } if (!par2World.IsRemote) { ChunkPosition chunkposition = par2World.FindClosestStructure("Stronghold", (int)par3EntityPlayer.PosX, (int)par3EntityPlayer.PosY, (int)par3EntityPlayer.PosZ); if (chunkposition != null) { EntityEnderEye entityendereye = new EntityEnderEye(par2World, par3EntityPlayer.PosX, (par3EntityPlayer.PosY + 1.6200000000000001F) - par3EntityPlayer.YOffset, par3EntityPlayer.PosZ); entityendereye.Func_40090_a(chunkposition.x, chunkposition.y, chunkposition.z); par2World.SpawnEntityInWorld(entityendereye); par2World.PlaySoundAtEntity(par3EntityPlayer, "random.bow", 0.5F, 0.4F / (ItemRand.NextFloat() * 0.4F + 0.8F)); par2World.PlayAuxSFXAtEntity(null, 1002, (int)par3EntityPlayer.PosX, (int)par3EntityPlayer.PosY, (int)par3EntityPlayer.PosZ, 0); if (!par3EntityPlayer.Capabilities.IsCreativeMode) { par1ItemStack.StackSize--; } } } return(par1ItemStack); }
/// <summary> /// Returns the closest non-generated chunk from position. /// </summary> /// <param name="eyePosition">The position of the observer in chunk space.</param> /// <param name="point">the point in chunk-space of the chunk.</param> /// <returns>If not all chunks are generated.</returns> public bool GetNextDesiredChunk(ChunkPosition eyePosition, out ChunkPosition point) { lock (_lock) { Shift(eyePosition); for (var i = _firstNonGenerated; i < _closestChunks.Length; i++) { var chunkPoint = _closestChunks[i]; if (_generatedChunks[chunkPoint.ChunkX, chunkPoint.ChunkZ]) { continue; } // transform position to world space, return it point = eyePosition + chunkPoint - ViewDistance; // set it to the index ahead, so when this loop is called again, it will start where it left off. _firstNonGenerated = i + 1; // assume it gets generated. _generatedChunks[chunkPoint.ChunkX, chunkPoint.ChunkZ] = true; return(true); } point = new ChunkPosition(); return(false); } }
public void ScalePosition() { var a = new ChunkPosition(10, 20, 40); var b = 2; Assert.AreEqual(new ChunkPosition(20, 40, 80), a * b); }
public IBlockState GetBlock(Vector3Int position) { var chunkPos = ChunkPosition.FromWorld(position); if (!ChunkManager.IsLoaded(chunkPos)) { return(null); } var chunk = ChunkManager.GetChunk(chunkPos); var index = Chunk.SectionIndex(position.Y); if (!chunk.HasSection(index)) { return(null); } var section = chunk[index]; return(section.BlockStorage.GetBlock( position.X % Minecraft.Units.Chunk.Size, position.Y % Minecraft.Units.Chunk.SectionHeight, position.Z % Minecraft.Units.Chunk.Size )); }
public bool SpawnEntity(IEntity entity) { var player = _client.Player; if (player.Id == entity.Id) { return(false); } var chunkManager = _world.ChunkManager; var chunkPosition = ChunkPosition.FromWorld(entity.Position); if (!chunkManager.IsLoaded(chunkPosition)) { Logger.Warn("Trying to spawn {0} in an unloaded chunk", entity); return(false); } if (!_loadedEntities.Add(entity)) { return(false); } Logger.Info("Spawning entity #{0} on {1}", entity.Id, _client); var connection = _client.Connection; connection.SpawnEntity(entity); return(true); }
private void WithChunk(ChunkPosition at, Action <Chunk> action) { if (chunks.TryGetValue(at, out Chunk found)) { action(found); } }
public Chunk(ChunkPosition pos) { position = pos; neighbours = new Chunk[6]; densities = new float[Point.CUBE_SIZE]; luminance = new Luminance(this); triangles = new List <Triangle>(); }
public Message(ChunkPosition chunkPosition, bool fullChunk, int sectionMask, NBitsArray heightMap, IByteBuffer data) { ChunkPosition = chunkPosition; FullChunk = fullChunk; SectionMask = sectionMask; HeightMap = heightMap; Data = data; }
public async ValueTask <IChunk> GetOrAddChunk(ChunkPosition position) { IChunkColumn chunkColumn = await GetOrAddChunkColumn(position.Column).Unchain(); IChunk chunk = await chunkColumn.GetOrAddChunk(position.Y).Unchain(); return(chunk); }
public ChunkTraceData(ChunkPosition chunkPosition, ChunkSize size, [CanBeNull] List <LocalBlockPosition> positions = null, [CanBeNull] List <AlphaBlock> blocks = null) { ChunkPosition = chunkPosition; Size = size; Positions = positions; Blocks = blocks; }
private void UpdateChunkMesh(ChunkPosition chunkPosition) { Chunk chunk = this.TryGetChunk(chunkPosition); if (chunk != null) { chunk.UpdateMesh(); } }
/// <summary> /// Retrieve the chunk at the passed position /// </summary> /// <param name="position">Position of chunk</param> /// <returns>ChunkOld or null if not found</returns> Chunk GetChunkAtPosition(ChunkPosition position) { foreach (Chunk chunk in chunks) { if (chunk.position.Equals(position)) return chunk; } return null; }
/// <summary> /// Converts a local block position into a world block position. /// </summary> /// <param name="chunkSize">The size of the chunk the block is in.</param> /// <param name="chunkPos">The position of the chunk the block is in.</param> public BlockPosition LocalToWorld(GridSize chunkSize, ChunkPosition chunkPos) { return(new BlockPosition { X = X + chunkPos.X * chunkSize.Value, Y = Y + chunkPos.Y * chunkSize.Value, Z = Z + chunkPos.Z * chunkSize.Value, }); }
public Chunk TryGetChunk(ChunkPosition chunkPosition) { if (!chunkPosition.InRange) { return(null); } return(this.chunks[chunkPosition.X, chunkPosition.Y, chunkPosition.Z]); }
/// <summary> /// Checks if chunk exists at passed position /// </summary> /// <param name="position">Position of chunk</param> /// <returns>true or false</returns> bool ChunkExistsAtPosition(ChunkPosition position) { foreach (Chunk chunk in chunks) { if (chunk.position.Equals(position)) return true; } return false; }
public bool TryGetChunk(ChunkPosition position, [MaybeNullWhen(false)] out IChunk chunk) { if (TryGetChunkColumn(position.Column, out IChunkColumn? column)) { return(column.TryGetChunk(position.Y, out chunk)); } chunk = default; return(false); }
public Chunk(GenerationSetting settings, ChunkPosition position) { this.settings = settings; this.position = position; meshObj = new TerrainMesh(75, settings.meshSize, settings.meshSize).GetMeshGameObject(); vertices = meshObj.GetComponent<MeshFilter>().mesh.vertices; size = meshObj.GetComponent<MeshFilter>().mesh.bounds.size; }
public void Init() { Size = new GridSize(4); Position = new ChunkPosition(15, 30, -77); var world = new World(Size); Chunk = world.CreateChunk(Position); }
private void GenerateChunk(float cx, float cy) { if (!generateChunkOnce) { _generateChunkOnceTriggerd = false; } if (_generateChunkOnceTriggerd) { return; } if (generateChunkOnce) { _generateChunkOnceTriggerd = true; } GameObject Chunk = new GameObject(); ChunkPosition chunkPosition = Chunk.gameObject.AddComponent <ChunkPosition>(); chunkPosition.Position = new Vector2(cx, cy); Chunk.transform.parent = ChunkParentTransform; Chunk.name = "Chunk X" + chunkPosition.Position.x + " Y" + chunkPosition.Position.y; Chunk.transform.position = chunkPosition.ActualPosition; Chunk.AddComponent <BoxCollider2D>().offset = new Vector2(7.5f, 7.5f); Chunk.GetComponent <BoxCollider2D>().size = new Vector2(16, 16); Chunk.GetComponent <BoxCollider2D>().isTrigger = true; Chunk.AddComponent <ChunkInfo>().chunkPosition = chunkPosition; Chunk.gameObject.tag = "Chunk"; Chunk.AddComponent <Rigidbody2D>().gravityScale = 0; Chunk.GetComponent <Rigidbody2D>().constraints = RigidbodyConstraints2D.FreezeAll; ChunkRemoval chunkRemoval = Chunk.AddComponent <ChunkRemoval>(); chunkRemoval.ChunkControllerGameObject = gameObject; for (int bx = 0 + (int)Chunk.transform.position.x; bx < 16 + (int)Chunk.transform.position.x; bx++) { for (int by = 0 + (int)Chunk.transform.position.y; by < 16 + (int)Chunk.transform.position.y; by++) { GameObject o = new GameObject(); o.AddComponent <SpriteRenderer>().sprite = sprites[Convert.ToInt32(Mathf.PerlinNoise(bx * perlinMod + perlinOffset, by * perlinMod + perlinOffset) * 10)]; o.transform.parent = Chunk.transform; o.transform.position = new Vector3(bx, by, 0); o.name = "X" + bx + " Y" + by; } } }
public WorldPosition(int x, int y, int z) { var chunkX = Mathf.FloorToInt((float)x / ChunkSize); var chunkY = Mathf.FloorToInt((float)y / ChunkSize); var chunkZ = Mathf.FloorToInt((float)z / ChunkSize); chunkPosition = new ChunkPosition(chunkX, chunkY, chunkZ); localPosition = new LocalPosition((uint)(x - chunkX * ChunkSize), (uint)(y - chunkY * ChunkSize), (uint)(z - chunkX * ChunkSize)); }
public void Generate(ChunkPosition position, IChunk chunk, Random random) { for (var x = 0; x < Minecraft.Units.Chunk.Size; x++) { for (var z = 0; z < Minecraft.Units.Chunk.Size; z++) { chunk.SetBlock(x, 0, z, _blockState); } } }
public override bool Equals(object obj) { if (!(obj is ChunkPosition)) { return(false); } ChunkPosition target = (ChunkPosition)obj; return(this.x == target.x && this.y == target.y && this.z == target.z); }
private Chunk World_ChunkRequest(World sender, ChunkPosition position) { if (!_requests.TryGetValue(position, out var chunk)) { var request = new ChunkRequest(position); _client.RequestChunk(request); _requests.Add(position, null); return(null); } return(chunk); }
private void OnEntitySpawned(object sender, EntityEventArgs e) { var entity = e.Entity; var position = ChunkPosition.FromWorld(entity.Position); var chunkManager = _world.ChunkManager; if (chunkManager.IsLoaded(position)) { SpawnEntity(entity); } }
/// <summary> /// Takes the passed chunk position and returns all other chunk positions in <code>generationRadius</code> /// </summary> /// <param name="startPos">ChunkOld position to start</param> /// <returns></returns> List<ChunkPosition> GetChunkPositionsFromRadius(ChunkPosition startPos) { var result = new List<ChunkPosition>(); for (var zCircle = -generationRadius; zCircle <= generationRadius; zCircle++) { for (var xCircle = -generationRadius; xCircle <= generationRadius; xCircle++) { if (xCircle * xCircle + zCircle * zCircle < generationRadius * generationRadius) result.Add(new ChunkPosition(startPos.x + xCircle, startPos.z + zCircle)); } } return result; }
void WritePos(ChunkPosition pos) { int code = (pos.Offset << 2) | 0x80; if (pos.Length > 3) code |= 3; else code |= pos.Length - 1; m_out.Write ((byte)code); if (pos.Length > 3) m_out.Write ((ushort)(pos.Length - 4)); }
ChunkPosition FindLongest(int buf_begin, int buf_end) { buf_end = Math.Min (buf_begin + MaxMatchSize, buf_end); ChunkPosition pos = new ChunkPosition { Offset = 0, Length = 0 }; for (int i = 0; i < 32; ++i) { int offset = buf_begin + m_shift_table[i]; if (offset < 0) continue; if (m_input[offset] != m_input[buf_begin]) continue; var last = Mismatch (buf_begin+1, buf_end, offset+1); int weight = last - offset; if (weight > pos.Length) { pos.Offset = (ushort)i; pos.Length = (ushort)weight; } } return pos; }
public void AddChunkToSend(ChunkPosition position) { chunksToSend.Add(position); }