/// <summary>
/// Causes the chunk to detect access paths.
/// </summary>
public void ChunkDetect()
{
if (!Flags.HasFlag(ChunkFlags.NEEDS_DETECT))
{
DetectChunkAccess();
Flags &= ~ChunkFlags.NEEDS_DETECT;
}
}
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;
}
}
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);
}
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));
}
public int Pack(byte[] inputData, int inputOffset)
{
inputData[inputOffset + 0] = (byte)((((int)Flags & 3) << 6) | ((Size >> 4) & 0x3F));
inputData[inputOffset + 1] = (byte)(Size & 0xf);
if (Flags.HasFlag(ChunkFlags.VITAL))
{
inputData[inputOffset + 1] |= (byte)((Sequence >> 2) & 0b1111_0000);
inputData[inputOffset + 2] = (byte)(Sequence & 0b1111_1111);
return(inputOffset + 3);
}
return(inputOffset + 2);
}
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);
}
