warrentyexpired/ModernUO
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions 1
ModernUO/Projects/Server/Buffers/CircularBufferWriter.cs
Kamron Batman 351611a23a
Updates movement packets & Fastwalk (#324) 
- [X] Updates Movement packets
- [X] Adds OSI fastwalk packets. These aren't used on OSi anymore.
- [X] Adds new movement handling, but looks like the client doesn't use it. (Also leaving the 0x4000 Character List Flag off)
- [X] Adds time sync request handler, but also looks like the client doesn't use it.
- [X] Adds time sync response for time sync, just in case, but it isn't used, so not sure about the arguments.
- [X] Reimplements RunUO's fastwalk to use a circular array on the netstate instead of every mobile
- [X] Removes ClearFastwalkStack from RunUO implementation. This shouldn't be needed anymore

Changed fastwalk settings:
```cs
        public static int WalkFootDelay { get; set; } = 440;
        public static int RunFootDelay { get; set; } = 220;
        public static int WalkMountDelay { get; set; } = 220;
        public static int RunMountDelay { get; set; } = 110;

        public static bool EnableFastwalkPrevention { get; set; } = true;
        public static AccessLevel FastwalkExemptionLevel { get; set; } = AccessLevel.Counselor;

        // If this is changed during runtime, then the steps array needs resizing.
        public static int MaxSteps { get; private set; } = 4;
```

modernuo.json
```json
{
  "settings": {
    "movement.delay.runFoot": "220",
    "movement.delay.runMount": "110",
    "movement.delay.walkFoot": "440",
    "movement.delay.walkMount": "220",
    "movement.enableFastWalkPrevention": "True",
    "movement.fastwalkExemptionLevel": "Counselor",
    "movement.maxSteps": "4"
  }
}
```

Notes about OSI fastwalk:
While it does work, I can't find a benefit in using it because of the variable speeds. If players moved at a single speed then we could refill the stack every X milliseconds with 6 keys and use a naive token bucket implementation.
Unfortunately variable speeds mount/run/walk/etc means we would have to use a leaky bucket algorithm.
If we are using a leaky bucket algorithm with a variable leak, then we don't need to send tokens because we are already tracking it on the server side.

ModernUO vs OSI Fastwalk:
When the fastwalk was implemented on OSI, it used up to 6 tokens. These tokens were probably distributed every 600-750 milliseconds. To get the same effect, the new fastwalk settings might need to be adjusted. I would tweak them and feel free to let me know what worked for you!

Bumps release version
2020-11-26 23:53:47 -08:00

474 lines
15 KiB
C#
Raw Blame History

/*************************************************************************
* ModernUO *
* Copyright 2019-2020 - ModernUO Development Team *
* Email: hi@modernuo.com *
* File: CircularBufferWriter.cs *
* *
* This program is free software: you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation, either version 3 of the License, or *
* (at your option) any later version. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program. If not, see <http://www.gnu.org/licenses/>. *
*************************************************************************/
using System.Buffers.Binary;
using System.IO;
using System.Runtime.CompilerServices;
using System.Text;
using Server;
namespace System.Buffers
{
public ref struct CircularBufferWriter
{
private readonly Span<byte> _first;
private readonly Span<byte> _second;
public int Length { get; }
public int Position { get; private set; }
public CircularBufferWriter(CircularBuffer<byte> buffer) : this(buffer.GetSpan(0), buffer.GetSpan(1))
{
}
public CircularBufferWriter(ArraySegment<byte>[] buffer) : this(buffer[0], buffer[1])
{
}
public CircularBufferWriter(Span<byte> first, Span<byte> second)
{
_first = first;
_second = second;
Position = 0;
Length = first.Length + second.Length;
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public void Write(byte value)
{
if (Position < _first.Length)
{
_first[Position++] = value;
}
else if (Position < Length)
{
_second[Position++ - _first.Length] = value;
}
else
{
throw new OutOfMemoryException();
}
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public void Write(bool value)
{
if (value)
{
Write((byte)1);
}
else
{
Write((byte)0);
}
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public void Write(sbyte value)
{
Write((byte)value);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public void Write(short value)
{
if (Position < _first.Length)
{
if (!BinaryPrimitives.TryWriteInt16BigEndian(_first.Slice(Position), value))
{
// Not enough space. Split the spans
Write((byte)(value >> 8));
Write((byte)value);
}
else
{
Position += 2;
}
}
else if (BinaryPrimitives.TryWriteInt16BigEndian(_second.Slice(Position - _first.Length), value))
{
Position += 2;
}
else
{
throw new OutOfMemoryException();
}
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public void Write(ushort value)
{
if (Position < _first.Length)
{
if (!BinaryPrimitives.TryWriteUInt16BigEndian(_first.Slice(Position), value))
{
// Not enough space. Split the spans
Write((byte)(value >> 8));
Write((byte)value);
}
else
{
Position += 2;
}
}
else if (BinaryPrimitives.TryWriteUInt16BigEndian(_second.Slice(Position - _first.Length), value))
{
Position += 2;
}
else
{
throw new OutOfMemoryException();
}
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public void Write(int value)
{
if (Position < _first.Length)
{
if (!BinaryPrimitives.TryWriteInt32BigEndian(_first.Slice(Position), value))
{
// Not enough space. Split the spans
Write((byte)(value >> 24));
Write((byte)(value >> 16));
Write((byte)(value >> 8));
Write((byte)value);
}
else
{
Position += 4;
}
}
else if (BinaryPrimitives.TryWriteInt32BigEndian(_second.Slice(Position - _first.Length), value))
{
Position += 4;
}
else
{
throw new OutOfMemoryException();
}
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public void WriteLE(int value)
{
if (Position < _first.Length)
{
if (!BinaryPrimitives.TryWriteInt32LittleEndian(_first.Slice(Position), value))
{
// Not enough space. Split the spans
Write((byte)(value >> 24));
Write((byte)(value >> 16));
Write((byte)(value >> 8));
Write((byte)value);
}
else
{
Position += 4;
}
}
else if (BinaryPrimitives.TryWriteInt32LittleEndian(_second.Slice(Position - _first.Length), value))
{
Position += 4;
}
else
{
throw new OutOfMemoryException();
}
}
/// <summary>
/// Writes a 4-byte unsigned integer value to the underlying stream.
/// </summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public void Write(uint value)
{
if (Position < _first.Length)
{
if (!BinaryPrimitives.TryWriteUInt32BigEndian(_first.Slice(Position), value))
{
// Not enough space. Split the spans
Write((byte)(value >> 24));
Write((byte)(value >> 16));
Write((byte)(value >> 8));
Write((byte)value);
}
else
{
Position += 4;
}
}
else if (BinaryPrimitives.TryWriteUInt32BigEndian(_second.Slice(Position - _first.Length), value))
{
Position += 4;
}
else
{
throw new OutOfMemoryException();
}
}
/// <summary>
/// Writes a 8-byte signed integer value to the underlying stream.
/// </summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public void Write(long value)
{
if (Position < _first.Length)
{
if (!BinaryPrimitives.TryWriteInt64BigEndian(_first.Slice(Position), value))
{
// Not enough space. Split the spans
Write((byte)(value >> 56));
Write((byte)(value >> 48));
Write((byte)(value >> 40));
Write((byte)(value >> 32));
Write((byte)(value >> 24));
Write((byte)(value >> 16));
Write((byte)(value >> 8));
Write((byte)value);
}
else
{
Position += 8;
}
}
else if (BinaryPrimitives.TryWriteInt64BigEndian(_second.Slice(Position - _first.Length), value))
{
Position += 8;
}
else
{
throw new OutOfMemoryException();
}
}
/// <summary>
/// Writes a 8-byte unsigned integer value to the underlying stream.
/// </summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public void Write(ulong value)
{
if (Position < _first.Length)
{
if (!BinaryPrimitives.TryWriteUInt64BigEndian(_first.Slice(Position), value))
{
// Not enough space. Split the spans
Write((byte)(value >> 56));
Write((byte)(value >> 48));
Write((byte)(value >> 40));
Write((byte)(value >> 32));
Write((byte)(value >> 24));
Write((byte)(value >> 16));
Write((byte)(value >> 8));
Write((byte)value);
}
else
{
Position += 8;
}
}
else if (BinaryPrimitives.TryWriteUInt64BigEndian(_second.Slice(Position - _first.Length), value))
{
Position += 8;
}
else
{
throw new OutOfMemoryException();
}
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public void Write(ReadOnlySpan<byte> buffer)
{
if (Position + buffer.Length > Length)
{
throw new OutOfMemoryException();
}
if (Position < _first.Length)
{
var sz = Math.Min(buffer.Length, _first.Length - Position);
buffer.CopyTo(_first.Slice(Position));
buffer.Slice(sz).CopyTo(_second);
Position += buffer.Length;
}
else if (Position < Length)
{
buffer.CopyTo(_second.Slice(Position - _first.Length));
}
else
{
throw new OutOfMemoryException();
}
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public void WriteString(ReadOnlySpan<char> value, Encoding encoding)
{
var byteCount = encoding.GetByteCount(value);
if (Position + byteCount > Length)
{
throw new OutOfMemoryException();
}
Span<byte> bytes = stackalloc byte[byteCount];
encoding.GetBytes(value, bytes);
int count;
if (Position < _first.Length)
{
count = Math.Min(_first.Length - Position, byteCount);
bytes.Slice(0, count).CopyTo(_first.Slice(Position));
byteCount -= count;
Position += count;
}
else
{
count = 0;
}
if (byteCount > 0)
{
bytes.Slice(count).CopyTo(_second.Slice(Math.Max(0, Position - _first.Length)));
Position += byteCount;
}
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public void WriteLittleUni(string value, int fixedLength = -1)
{
if (fixedLength < 0) { fixedLength = value.Length; }
WriteString(value.AsSpan(0, Math.Min(fixedLength, value.Length)), Utility.UnicodeLE);
var count = fixedLength - value.Length;
if (count > 0)
{
Clear(count * 2);
}
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public void WriteLittleUniNull(string value)
{
WriteString(value, Utility.UnicodeLE);
Write((ushort)0);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public void WriteBigUni(string value, int fixedLength = -1)
{
if (fixedLength < 0) { fixedLength = value.Length; }
WriteString(value.AsSpan(0, Math.Min(fixedLength, value.Length)), Utility.Unicode);
var count = fixedLength - value.Length;
if (count > 0)
{
Clear(count * 2);
}
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public void WriteBigUniNull(string value)
{
WriteString(value, Utility.Unicode);
Write((ushort)0);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public void WriteUTF8(string value) => WriteString(value, Utility.UTF8);
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public void WriteUTF8Null(string value)
{
WriteString(value, Utility.UTF8);
Write((byte)0);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public void WriteAscii(string value, int fixedLength = -1)
{
if (fixedLength < 0) { fixedLength = value.Length; }
WriteString(value.AsSpan(0, Math.Min(fixedLength, value.Length)), Encoding.ASCII);
var count = fixedLength - value.Length;
if (count > 0)
{
Clear(count);
}
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public void WriteAsciiNull(string value)
{
WriteString(value, Encoding.ASCII);
Write((byte)0);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public void Clear()
{
if (Position < _first.Length)
{
_first.Slice(Position).Clear();
_second.Clear();
}
else
{
_second.Slice(Position - _first.Length).Clear();
}
Position = Length;
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public void Clear(int amount)
{
if (Position + amount > Length)
{
throw new OutOfMemoryException();
}
int count;
if (Position < _first.Length)
{
count = Math.Min(amount, _first.Length - Position);
_first.Slice(Position, count).Clear();
count = amount - count;
}
else
{
count = amount;
}
if (count > 0)
{
_second.Slice(Position - _first.Length, count).Clear();
}
Position += amount;
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public int Seek(int offset, SeekOrigin origin) =>
Position = origin switch
{
SeekOrigin.Begin => offset,
SeekOrigin.End => Length - offset,
_ => Position + offset // Current
};
}
}
Reference in a new issue View git blame Copy permalink