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);
}
