public bool Tick()
{
if ((flags & ChunkFlags.Awake) == 0x00)
{
return(false);
}
if ((flags & ChunkFlags.StartedBlocks) == 0x00)
{
ThreadManager.CreateBlockBuilderThread(this);
flags |= ChunkFlags.StartedBlocks;
}
if ((flags & ChunkFlags.HasBlocks) != 0x00 && (flags & ChunkFlags.StartedMesh) == 0x00)
{
ThreadManager.CreateMeshBuilderThread(this);
flags |= ChunkFlags.StartedMesh;
}
if ((flags & ChunkFlags.chunkLoaded) != 0x00)
{
//Debug.Log("loaded" + position.ToString());
}
return(true);
}
public Chunk(int x, int y, int z)
{
position.x = x;
position.y = y;
position.z = z;
flags |= ChunkFlags.Awake;
}
public override bool QueueChunk(ChunkFlags flags, byte[] data, int dataSize)
{
if (flags.HasFlag(ChunkFlags.Vital))
{
Sequence = (Sequence + 1) % NetworkHelper.MaxSequence;
}
return(QueueChunkEx(flags, data, dataSize, Sequence));
}
public override bool QueueChunk(ChunkFlags flags, byte[] data, int dataSize)
{
if (flags.HasFlag(ChunkFlags.VITAL))
{
Sequence = (Sequence + 1) % NetworkCore.MAX_SEQUENCE;
}
return(QueueChunkEx(flags, dataSize, data, Sequence));
}
/// <summary>
/// Causes the chunk to detect access paths.
/// </summary>
public void ChunkDetect()
{
if (!Flags.HasFlag(ChunkFlags.NEEDS_DETECT))
{
DetectChunkAccess();
Flags &= ~ChunkFlags.NEEDS_DETECT;
}
}
internal ChunkHeader(string chunkName, int chunkType, ChunkFlags chunkFlag, string mimeType, short version, long chunkSize)
{
m_chunkName = chunkName;
m_chunkType = chunkType;
m_chunkFlags = chunkFlag;
m_mimeType = mimeType;
m_version = version;
m_chunkSize = chunkSize;
}
public ChunkHeader(string chunkName, int chunkType, ChunkFlags chunkFlag, string mimeType, short version, long chunkSize)
{
this.m_chunkName = chunkName;
this.m_chunkType = chunkType;
this.m_chunkFlags = chunkFlag;
this.m_mimeType = mimeType;
this.m_version = version;
this.m_chunkSize = chunkSize;
}
public void OnBlockDataFinished(Block[,,] blocks, bool isAir = false) //public void OnBlockDataFinished (ChunkData blocks, List<int> lightSourceIndices, bool isAir = false) {
{
this.blockData = blocks;
if (isAir == true)
{
flags &= ~ChunkFlags.Awake;
}
flags |= ChunkFlags.HasBlocks;
}
public void ChunkDetect()
{
if (!Flags.HasFlag(ChunkFlags.NEEDS_DETECT))
{
DetectChunkAccess();
//chunkAccessDetection = chunkAccessDetection == null ? OwningRegion.TheWorld.Schedule.StartASyncTask(DetectChunkAccess)
// : chunkAccessDetection.ReplaceOrFollowWith(OwningRegion.TheWorld.Schedule.AddASyncTask(DetectChunkAccess));
Flags &= ~ChunkFlags.NEEDS_DETECT;
}
}
public Chunk(string signature, short version, ChunkFlags flags, ISerializable <BinaryStream> payload)
{
Contract.Requires <ArgumentNullException>(signature != null && payload != null);
Contract.Requires(Encoding.UTF8.GetByteCount(signature) == 4);
_signature = signature;
_version = version;
_flags = (short)flags;
_payload = payload;
}
protected override bool QueueChunkEx(ChunkFlags flags, byte[] data, int dataSize,
int sequence)
{
if (ResendChunkConstruct.DataSize + dataSize + NetworkHelper.MaxChunkHeaderSize >
ResendChunkConstruct.Data.Length ||
ResendChunkConstruct.NumChunks >= NetworkHelper.MaxPacketChunks)
{
Flush();
}
var header = new ChunkHeader
{
Flags = flags,
Size = dataSize,
Sequence = sequence
};
var dataOffset = ResendChunkConstruct.DataSize;
dataOffset = header.Pack(ResendChunkConstruct.Data, dataOffset);
Buffer.BlockCopy(data, 0, ResendChunkConstruct.Data, dataOffset, dataSize);
ResendChunkConstruct.NumChunks++;
ResendChunkConstruct.DataSize = dataOffset + dataSize;
if (flags.HasFlag(ChunkFlags.Vital) && !flags.HasFlag(ChunkFlags.Resend))
{
SizeOfChunksForResends += 32 + dataSize;
if (SizeOfChunksForResends >= NetworkHelper.ConnectionBufferSize)
{
Disconnect("too weak connection (out of buffer)");
return(false);
}
var resend = new ChunkResend
{
Sequence = sequence,
Flags = flags,
DataSize = dataSize,
Data = new byte[dataSize],
FirstSendTime = Time.Get(),
LastSendTime = Time.Get()
};
Buffer.BlockCopy(data, 0, resend.Data, 0, dataSize);
ChunksForResends.Add(resend);
}
return(true);
}
public override bool QueueChunkEx(ChunkFlags flags, int dataSize, byte[] data, int sequence)
{
if (ResendQueueConstruct.DataSize +
dataSize + NetworkCore.PACKET_HEADER_SIZE > NetworkCore.MAX_PAYLOAD)
{
Flush();
}
var header = new NetworkChunkHeader
{
Flags = flags,
Size = dataSize,
Sequence = sequence
};
var chunkDataOffset = ResendQueueConstruct.DataSize;
chunkDataOffset = header.Pack(ResendQueueConstruct.Data, chunkDataOffset);
Buffer.BlockCopy(data, 0, ResendQueueConstruct.Data, chunkDataOffset, dataSize);
chunkDataOffset += dataSize;
ResendQueueConstruct.NumChunks++;
ResendQueueConstruct.DataSize = chunkDataOffset;
if (flags.HasFlag(ChunkFlags.VITAL) && !flags.HasFlag(ChunkFlags.RESEND))
{
BufferSize += SIZEOF_NETWORK_CHUNK_RESEND + dataSize;
if (BufferSize >= BUFFERSIZE)
{
Disconnect("too weak connection (out of buffer)");
return(false);
}
var resend = new NetworkChunkResend
{
Sequence = sequence,
Flags = flags,
DataSize = dataSize,
Data = new byte[dataSize],
FirstSendTime = Time.Get(),
LastSendTime = Time.Get()
};
Buffer.BlockCopy(data, 0, resend.Data, 0, dataSize);
ResendQueue.Enqueue(resend);
}
return(true);
}
/// <summary>
/// Loads the chunk from save data.
/// </summary>
/// <param name="det">The block data.</param>
/// <param name="ents">The entity data.</param>
public void LoadFromSaveData(ChunkDetails det, ChunkDetails ents)
{
if (det.Version != 2 || ents.Version != 2)
{
throw new Exception("invalid save data VERSION: " + det.Version + " and " + ents.Version + "!");
}
Flags = det.Flags & ~(ChunkFlags.POPULATING);
SetBlockAt(0, 0, 0, BlockInternal.AIR); // Ensure generated
if (det.Blocks.Length > 0)
{
for (int i = 0; i < BlocksInternal.Length; i++)
{
BlocksInternal[i]._BlockMaterialInternal = Utilities.BytesToUShort(Utilities.BytesPartial(det.Blocks, i * 2, 2));
BlocksInternal[i].BlockData = det.Blocks[BlocksInternal.Length * 2 + i];
BlocksInternal[i].BlockLocalData = det.Blocks[BlocksInternal.Length * 3 + i];
BlocksInternal[i]._BlockPaintInternal = det.Blocks[BlocksInternal.Length * 4 + i];
}
FromFile = true;
}
for (int i = 0; i < Reachability.Length; i++)
{
Reachability[i] = det.Reachables[i] == 1;
}
if (ents.Blocks != null && ents.Blocks.Length > 0 && entsToSpawn.Count == 0)
{
BsonDocument bsd = BsonSerializer.Deserialize(ents.Blocks);
if (bsd.ContainsKey("list"))
{
List <BsonValue> docs = bsd["list"];
for (int i = 0; i < docs.Count; i++)
{
BsonDocument ent = (BsonDocument)docs[i];
EntityType etype = (EntityType)Enum.Parse(typeof(EntityType), ent["ENTITY_TYPE"].AsString);
try
{
Entity e = OwningRegion.ConstructorFor(etype).Create(OwningRegion, ent);
e.EID = ent["ENTITY_ID"].AsInt64;
entsToSpawn.Add(e);
}
catch (Exception ex)
{
Utilities.CheckException(ex);
SysConsole.Output("Spawning an entity of type " + etype, ex);
}
}
}
}
}
public int Unpack(byte[] inputData, int inputOffset)
{
Flags = (ChunkFlags)((inputData[inputOffset + 0] >> 6) & 0b11);
Size = ((inputData[inputOffset + 0] & 0b111111) << 4) |
((inputData[inputOffset + 1] & 0b1111));
Sequence = -1;
if (Flags.HasFlag(ChunkFlags.VITAL))
{
Sequence = ((inputData[inputOffset + 1] & 0b1111_0000) << 2) |
((inputData[inputOffset + 2]));
return(inputOffset + 3);
}
return(inputOffset + 2);
}
public void OnMeshDataFinished(Mesh graphics, Mesh physics)
{
if (graphics.vertexCount == 0)
{
flags &= ~ChunkFlags.Awake;
}
mesh = graphics;
flags |= ChunkFlags.HasMesh;
if (physics == null)
{
return;
}
world.CreateChunkGameObject(this, graphics, physics);
//Debug.Log( Vector3Int.DecimalToBinary(((int) flags).ToString()));
}
public void SetBlockAt(int x, int y, int z, Block block)
{
if ((flags & ChunkFlags.HasBlocks) == 0)
{
return;
}
x = negToPos((Mathf.FloorToInt(x)) - (position.x * ChuchMaxWidth));
y = negToPos((Mathf.FloorToInt(y)) - (position.y * ChuchMaxHight));
z = negToPos((Mathf.FloorToInt(z)) - (position.z * ChuchMaxWidth));
//
//if is out of Bounds look for other chunk to brake it in.................9
//
if (IsWithInBounds(x, y, z))
{
blockData[x, y, z] = block;
flags &= ~ChunkFlags.StartedMesh;
}
}
public void ChunkDetect()
{
if (!Flags.HasFlag(ChunkFlags.NEEDS_DETECT))
{
DetectChunkAccess();
//chunkAccessDetection = chunkAccessDetection == null ? OwningRegion.TheWorld.Schedule.StartASyncTask(DetectChunkAccess)
// : chunkAccessDetection.ReplaceOrFollowWith(OwningRegion.TheWorld.Schedule.AddASyncTask(DetectChunkAccess));
Flags &= ~ChunkFlags.NEEDS_DETECT;
}
}
public ChunkAttributes(ICollection <uint> chunkTypes, ChunkFlags chunkFlags, ICollection <AviChunkName> suitableParents)
{
ChunkTypes = chunkTypes;
SuitableParents = suitableParents;
ChunkFlags = chunkFlags;
}
/// <summary>
/// Returns whether the given <paramref name="chunkFlag"/> is set for
/// the given <paramref name="chunkName"/>.
/// </summary>
/// <param name="chunkName">the chunk name</param>
/// <param name="chunkFlag">the flag to test</param>
/// <returns>true if the flag is set, false otherwise</returns>
public static bool IsFlagSet(this AviChunkName chunkName, ChunkFlags chunkFlag)
{
return((chunkName.GetChunkFlags() & chunkFlag) == chunkFlag);
}
public virtual void RemoveFlag(ChunkFlags flag)
{
this.flags &= ~flag;
}
public virtual void AddFlag(ChunkFlags flag)
{
this.flags |= flag;
}
public virtual bool HasFlag(ChunkFlags flag)
{
return((this.flags & flag) == flag);
}
protected abstract bool QueueChunkEx(ChunkFlags flags,
byte[] data, int dataSize, int sequence);
public abstract bool QueueChunk(ChunkFlags flags, byte[] data, int dataSize);
/// <summary>
/// Creates a new chunk attribute.
/// </summary>
/// <remarks>
/// Use an empty list for <param name="suitableParents"/> to specify
/// all container chunks.
/// </remarks>
/// <param name="chunkType">the chunk type field 4CC as string</param>
/// <param name="suitableParents">the suitable parent for the chunk</param>
/// <param name="flags">the chunk type flags</param>
public AviAttribute(string chunkType, AviChunkName[] suitableParents, ChunkFlags flags)
{
ChunkType = chunkType;
SuitableParents = suitableParents;
ChunkFlags = flags;
}
protected void BeginChunk(BinaryReader br)
{
flags = (ChunkFlags)br.ReadUInt32();
Debug.Assert(flags != 0);
chunkID = (uint)(flags & ChunkFlags.ChunkIndexMask);
chunkType = (D3D11Chunk)chunkID;
chunkFlags = SDChunkFlags.NoFlags;
if ((flags & ChunkFlags.ChunkCallstack) != 0)
{
uint numFrames = br.ReadUInt32();
if (numFrames < 4096)
{
chunkFlags |= SDChunkFlags.HasCallstack;
callstack = new ulong[numFrames];
br.Read(callstack, 0, callstack.Length);
}
else
{
Console.WriteLine($"Read invalid number of callstack frames:{numFrames}");
br.BaseStream.Position += numFrames * sizeof(ulong);
}
}
if ((flags & ChunkFlags.ChunkThreadID) != 0)
{
threadID = br.ReadUInt64();
}
else
{
threadID = 0;
}
if ((flags & ChunkFlags.ChunkDuration) != 0)
{
durationMicro = br.ReadInt64();
}
else
{
durationMicro = -1;
}
if ((flags & ChunkFlags.ChunkTimestamp) != 0)
{
timestampMicro = br.ReadUInt64();
}
else
{
timestampMicro = 0;
}
if ((flags & ChunkFlags.Chunk64BitSize) != 0)
{
length = br.ReadUInt64();
}
else
{
length = br.ReadUInt32();
}
headerLength = br.BaseStream.Position - offset;
}
public void LoadFromSaveData(ChunkDetails det, ChunkDetails ents)
{
if (det.Version != 2 || ents.Version != 2)
{
throw new Exception("invalid save data VERSION: " + det.Version + " and " + ents.Version + "!");
}
Flags = det.Flags & ~(ChunkFlags.POPULATING);
for (int i = 0; i < BlocksInternal.Length; i++)
{
BlocksInternal[i]._BlockMaterialInternal = Utilities.BytesToUshort(Utilities.BytesPartial(det.Blocks, i * 2, 2));
BlocksInternal[i].BlockData = det.Blocks[BlocksInternal.Length * 2 + i];
BlocksInternal[i].BlockLocalData = det.Blocks[BlocksInternal.Length * 3 + i];
BlocksInternal[i]._BlockPaintInternal = det.Blocks[BlocksInternal.Length * 4 + i];
}
for (int i = 0; i < Reachability.Length; i++)
{
Reachability[i] = det.Reachables[i] == 1;
}
if (ents.Blocks != null && ents.Blocks.Length > 0 && entsToSpawn.Count == 0)
{
BsonDocument bsd = BsonSerializer.Deserialize(ents.Blocks);
if (bsd.ContainsKey("list"))
{
List<BsonValue> docs = bsd["list"];
for (int i = 0; i < docs.Count; i++)
{
BsonDocument ent = (BsonDocument)docs[i];
EntityType etype = (EntityType)Enum.Parse(typeof(EntityType), ent["ENTITY_TYPE"].AsString);
try
{
Entity e = OwningRegion.ConstructorFor(etype).Create(OwningRegion, ent);
e.EID = ent["ENTITY_ID"].AsInt64;
entsToSpawn.Add(e);
}
catch (Exception ex)
{
Utilities.CheckException(ex);
SysConsole.Output("Spawning an entity of type " + etype, ex);
}
}
}
}
}
public abstract bool QueueChunkEx(ChunkFlags flags, int dataSize, byte[] data, int sequence);
