warrentyexpired/ModernUO
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Updates movement packets & Fastwalk (#324)

Browse source 
- [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
This commit is contained in:
Kamron Batman 2020-11-26 23:53:47 -08:00 • committed by GitHub
parent b6cd408623
commit 351611a23a
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
25 changed files with 781 additions and 490 deletions
Download patch file Download diff file Expand all files Collapse all files

58
Projects/Server/Buffers/CircularBufferReader.cs
View file

@ -182,6 +182,64 @@ namespace Server.Network
return value;
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public long ReadInt64()
{
long value;
if (Position < _first.Length)
{
if (!BinaryPrimitives.TryReadInt64BigEndian(_first.Slice(Position), out value))
{
// Not enough space. Split the spans
return ((long)ReadByte() >> 56) |
((long)ReadByte() >> 48) |
((long)ReadByte() >> 40) |
((long)ReadByte() >> 32) |
((long)ReadByte() >> 24) |
((long)ReadByte() >> 16) |
((long)ReadByte() >> 8) |
ReadByte();
}
}
else if (!BinaryPrimitives.TryReadInt64BigEndian(_second.Slice(Position - _first.Length), out value))
{
throw new OutOfMemoryException();
}
Position += 8;
return value;
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public ulong ReadUInt64()
{
ulong value;
if (Position < _first.Length)
{
if (!BinaryPrimitives.TryReadUInt64BigEndian(_first.Slice(Position), out value))
{
// Not enough space. Split the spans
return ((ulong)ReadByte() >> 56) |
((ulong)ReadByte() >> 48) |
((ulong)ReadByte() >> 40) |
((ulong)ReadByte() >> 32) |
((ulong)ReadByte() >> 24) |
((ulong)ReadByte() >> 16) |
((ulong)ReadByte() >> 8) |
ReadByte();
}
}
else if (!BinaryPrimitives.TryReadUInt64BigEndian(_second.Slice(Position - _first.Length), out value))
{
throw new OutOfMemoryException();
}
Position += 8;
return value;
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public string ReadString(Encoding encoding, bool safeString = false, int fixedLength = -1)
{

70
Projects/Server/Buffers/CircularBufferWriter.cs
View file

@ -220,6 +220,76 @@ namespace System.Buffers
}
}
/// <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)
{

22
Projects/Server/Configuration/ServerConfiguration.cs
View file

@ -45,6 +45,12 @@ namespace Server
return int.TryParse(strValue, out var value) ? value : defaultValue;
}
public static long GetSetting(string key, long defaultValue)
{
m_Settings.settings.TryGetValue(key, out var strValue);
return long.TryParse(strValue, out var value) ? value : defaultValue;
}
public static bool GetSetting(string key, bool defaultValue)
{
m_Settings.settings.TryGetValue(key, out var strValue);
@ -84,6 +90,22 @@ namespace Server
return value;
}
public static long GetOrUpdateSetting(string key, long defaultValue)
{
long value;
if (m_Settings.settings.TryGetValue(key, out var strValue))
{
value = long.TryParse(strValue, out value) ? value : defaultValue;
}
else
{
SetSetting(key, (value = defaultValue).ToString());
}
return value;
}
public static bool GetOrUpdateSetting(string key, bool defaultValue)
{
bool value;

11
Projects/Server/Events/FastwalkEvent.cs
View file

@ -18,22 +18,19 @@ using Server.Network;
namespace Server
{
public class FastWalkEventArgs : EventArgs
public class FastWalkEventArgs
{
public FastWalkEventArgs(NetState state)
{
NetState = state;
Blocked = false;
}
public FastWalkEventArgs(NetState state) => NetState = state;
public NetState NetState { get; }
public bool Blocked { get; set; }
public bool Blocked { get; set; } = true;
}
public static partial class EventSink
{
public static event Action<FastWalkEventArgs> FastWalk;
public static void InvokeFastWalk(FastWalkEventArgs e) => FastWalk?.Invoke(e);
}
}

2
Projects/Server/ExpansionInfo.cs
View file

@ -94,7 +94,7 @@ namespace Server
Unk3 = 0x00000800,
SeventhCharacterSlot = 0x00001000,
Unk4 = 0x00002000,
NewMovementSystem = 0x00004000,
NewMovementSystem = 0x00004000, // Doesn't seem to be used on OSI
NewFeluccaAreas = 0x00008000,
ExpansionNone = ContextMenus,

455
Projects/Server/Mobiles/Mobile.cs
View file

@ -18,6 +18,7 @@ using Server.Network;
using Server.Prompts;
using Server.Targeting;
using Server.Utilities;
using CalcMoves = Server.Movement.Movement;
namespace Server
{
@ -502,7 +503,6 @@ namespace Server
private Direction m_Direction;
private bool m_DisplayGuildTitle;
private long m_EndQueue;
private Timer m_ExpireAggrTimer;
private Timer m_ExpireCombatant;
private Timer m_ExpireCriminal;
@ -550,7 +550,6 @@ namespace Server
*/
private Item m_MountItem;
private Queue<MovementRecord> m_MoveRecords;
private string m_Name;
private string m_NameMod;
@ -1081,22 +1080,6 @@ namespace Server
public bool Pushing { get; set; }
public static int WalkFoot { get; set; } = 400;
public static int RunFoot { get; set; } = 200;
public static int WalkMount { get; set; } = 200;
public static int RunMount { get; set; } = 100;
public static AccessLevel FwdAccessOverride { get; set; } = AccessLevel.Counselor;
public static bool FwdEnabled { get; set; } = true;
public static bool FwdUOTDOverride { get; set; }
public static int FwdMaxSteps { get; set; } = 4;
public virtual bool IsDeadBondedPet => false;
public ISpell Spell
@ -2861,8 +2844,6 @@ namespace Server
{
ns.Send(new MobileUpdateOld(this));
}
ClearFastwalkStack();
}
if (ns != null)
@ -2873,7 +2854,6 @@ namespace Server
}
ns.Sequence = 0;
ClearFastwalkStack();
ns.Send(MobileIncoming.Create(ns, this, this));
@ -2897,7 +2877,6 @@ namespace Server
if (ns != null)
{
ns.Sequence = 0;
ClearFastwalkStack();
ns.Send(MobileIncoming.Create(ns, this, this));
@ -2997,8 +2976,6 @@ namespace Server
{
ns.Send(new MobileUpdateOld(this));
}
ClearFastwalkStack();
}
}
else
@ -3014,7 +2991,6 @@ namespace Server
}
ns.Sequence = 0;
ClearFastwalkStack();
ns.Send(MobileIncoming.Create(ns, this, this));
@ -3038,7 +3014,6 @@ namespace Server
if (ns != null)
{
ns.Sequence = 0;
ClearFastwalkStack();
ns.Send(MobileIncoming.Create(ns, this, this));
@ -3228,8 +3203,6 @@ namespace Server
{
ourState.Send(new MobileUpdateOld(m));
}
ClearFastwalkStack();
}
if (sendIncoming)
@ -4512,17 +4485,188 @@ namespace Server
return true;
}
public virtual void ClearFastwalkStack()
public virtual bool CheckMovement(Direction d, out int newZ) => Movement.Movement.CheckMovement(this, d, out newZ);
private bool CanMove(Direction d, Point3D oldLocation, ref Point3D newLocation)
{
if (m_MoveRecords != null && m_MoveRecords.Count > 0)
if (m_Spell?.OnCasterMoving(d) == false)
{
m_MoveRecords.Clear();
return false;
}
m_EndQueue = Core.TickCount;
}
if (m_Paralyzed || m_Frozen)
{
SendLocalizedMessage(500111); // You are frozen and can not move.
public virtual bool CheckMovement(Direction d, out int newZ) => Movement.Movement.CheckMovement(this, d, out newZ);
return false;
}
if (!CheckMovement(d, out var newZ))
{
return false;
}
int x = oldLocation.m_X, y = oldLocation.m_Y;
int oldX = x, oldY = y;
var oldZ = oldLocation.m_Z;
switch (d & Direction.Mask)
{
case Direction.North:
--y;
break;
case Direction.Right:
++x;
--y;
break;
case Direction.East:
++x;
break;
case Direction.Down:
++x;
++y;
break;
case Direction.South:
++y;
break;
case Direction.Left:
--x;
++y;
break;
case Direction.West:
--x;
break;
case Direction.Up:
--x;
--y;
break;
}
newLocation.m_X = x;
newLocation.m_Y = y;
newLocation.m_Z = newZ;
Pushing = false;
var map = m_Map;
if (map == null || !Region.CanMove(this, d, newLocation, oldLocation, map))
{
return false;
}
var oldSector = map.GetSector(oldX, oldY);
var newSector = map.GetSector(x, y);
if (oldSector != newSector)
{
for (var i = 0; i < oldSector.Mobiles.Count; ++i)
{
var m = oldSector.Mobiles[i];
if (m != this && m.X == oldX && m.Y == oldY && m.Z + 15 > oldZ && oldZ + 15 > m.Z &&
!m.OnMoveOff(this))
{
return false;
}
}
for (var i = 0; i < oldSector.Items.Count; ++i)
{
var item = oldSector.Items[i];
if (item.AtWorldPoint(oldX, oldY) &&
(item.Z == oldZ || item.Z + item.ItemData.Height > oldZ && oldZ + 15 > item.Z) &&
!item.OnMoveOff(this))
{
return false;
}
}
for (var i = 0; i < newSector.Mobiles.Count; ++i)
{
var m = newSector.Mobiles[i];
if (m.X == x && m.Y == y && m.Z + 15 > newZ && newZ + 15 > m.Z && !m.OnMoveOver(this))
{
return false;
}
}
for (var i = 0; i < newSector.Items.Count; ++i)
{
var item = newSector.Items[i];
if (item.AtWorldPoint(x, y) &&
(item.Z == newZ || item.Z + item.ItemData.Height > newZ && newZ + 15 > item.Z) &&
!item.OnMoveOver(this))
{
return false;
}
}
}
else
{
for (var i = 0; i < oldSector.Mobiles.Count; ++i)
{
var m = oldSector.Mobiles[i];
if (m != this && m.X == oldX && m.Y == oldY && m.Z + 15 > oldZ && oldZ + 15 > m.Z &&
!m.OnMoveOff(this))
{
return false;
}
if (m.X == x && m.Y == y && m.Z + 15 > newZ && newZ + 15 > m.Z && !m.OnMoveOver(this))
{
return false;
}
}
for (var i = 0; i < oldSector.Items.Count; ++i)
{
var item = oldSector.Items[i];
if (item.AtWorldPoint(oldX, oldY) &&
(item.Z == oldZ || item.Z + item.ItemData.Height > oldZ && oldZ + 15 > item.Z) &&
!item.OnMoveOff(this))
{
return false;
}
if (item.AtWorldPoint(x, y) &&
(item.Z == newZ || item.Z + item.ItemData.Height > newZ && newZ + 15 > item.Z) &&
!item.OnMoveOver(this))
{
return false;
}
}
}
if (!InternalOnMove(d))
{
return false;
}
if (
CalcMoves.EnableFastwalkPrevention &&
AccessLevel < CalcMoves.FastwalkExemptionLevel &&
m_NetState?.AddStep(d) == false
)
{
var fw = new FastWalkEventArgs(m_NetState);
EventSink.InvokeFastWalk(fw);
if (fw.Blocked)
{
return false;
}
}
LastMoveTime = Core.TickCount;
return true;
}
public virtual bool Move(Direction d)
{
@ -4538,227 +4682,13 @@ namespace Server
box.Close();
}
var newLocation = m_Location;
var oldLocation = newLocation;
var oldLocation = m_Location;
Point3D newLocation = oldLocation;
if ((m_Direction & Direction.Mask) == (d & Direction.Mask))
{
// We are actually moving (not just a direction change)
if (m_Spell?.OnCasterMoving(d) == false)
{
return false;
}
if (m_Paralyzed || m_Frozen)
{
SendLocalizedMessage(500111); // You are frozen and can not move.
return false;
}
if (CheckMovement(d, out var newZ))
{
int x = oldLocation.m_X, y = oldLocation.m_Y;
int oldX = x, oldY = y;
var oldZ = oldLocation.m_Z;
switch (d & Direction.Mask)
{
case Direction.North:
--y;
break;
case Direction.Right:
++x;
--y;
break;
case Direction.East:
++x;
break;
case Direction.Down:
++x;
++y;
break;
case Direction.South:
++y;
break;
case Direction.Left:
--x;
++y;
break;
case Direction.West:
--x;
break;
case Direction.Up:
--x;
--y;
break;
}
newLocation.m_X = x;
newLocation.m_Y = y;
newLocation.m_Z = newZ;
Pushing = false;
var map = m_Map;
if (map != null)
{
var oldSector = map.GetSector(oldX, oldY);
var newSector = map.GetSector(x, y);
if (oldSector != newSector)
{
for (var i = 0; i < oldSector.Mobiles.Count; ++i)
{
var m = oldSector.Mobiles[i];
if (m != this && m.X == oldX && m.Y == oldY && m.Z + 15 > oldZ && oldZ + 15 > m.Z &&
!m.OnMoveOff(this))
{
return false;
}
}
for (var i = 0; i < oldSector.Items.Count; ++i)
{
var item = oldSector.Items[i];
if (item.AtWorldPoint(oldX, oldY) &&
(item.Z == oldZ || item.Z + item.ItemData.Height > oldZ && oldZ + 15 > item.Z) &&
!item.OnMoveOff(this))
{
return false;
}
}
for (var i = 0; i < newSector.Mobiles.Count; ++i)
{
var m = newSector.Mobiles[i];
if (m.X == x && m.Y == y && m.Z + 15 > newZ && newZ + 15 > m.Z && !m.OnMoveOver(this))
{
return false;
}
}
for (var i = 0; i < newSector.Items.Count; ++i)
{
var item = newSector.Items[i];
if (item.AtWorldPoint(x, y) &&
(item.Z == newZ || item.Z + item.ItemData.Height > newZ && newZ + 15 > item.Z) &&
!item.OnMoveOver(this))
{
return false;
}
}
}
else
{
for (var i = 0; i < oldSector.Mobiles.Count; ++i)
{
var m = oldSector.Mobiles[i];
if (m != this && m.X == oldX && m.Y == oldY && m.Z + 15 > oldZ && oldZ + 15 > m.Z &&
!m.OnMoveOff(this))
{
return false;
}
if (m.X == x && m.Y == y && m.Z + 15 > newZ && newZ + 15 > m.Z && !m.OnMoveOver(this))
{
return false;
}
}
for (var i = 0; i < oldSector.Items.Count; ++i)
{
var item = oldSector.Items[i];
if (item.AtWorldPoint(oldX, oldY) &&
(item.Z == oldZ || item.Z + item.ItemData.Height > oldZ && oldZ + 15 > item.Z) &&
!item.OnMoveOff(this))
{
return false;
}
if (item.AtWorldPoint(x, y) &&
(item.Z == newZ || item.Z + item.ItemData.Height > newZ && newZ + 15 > item.Z) &&
!item.OnMoveOver(this))
{
return false;
}
}
}
if (!Region.CanMove(this, d, newLocation, oldLocation, m_Map))
{
return false;
}
}
else
{
return false;
}
if (!InternalOnMove(d))
{
return false;
}
if (FwdEnabled && m_NetState != null && m_AccessLevel < FwdAccessOverride &&
(!FwdUOTDOverride || !m_NetState.IsUOTDClient))
{
m_MoveRecords ??= new Queue<MovementRecord>(6);
while (m_MoveRecords.Count > 0)
{
var r = m_MoveRecords.Peek();
if (r.Expired())
{
m_MoveRecords.Dequeue();
}
else
{
break;
}
}
if (m_MoveRecords.Count >= FwdMaxSteps)
{
var fw = new FastWalkEventArgs(m_NetState);
EventSink.InvokeFastWalk(fw);
if (fw.Blocked)
{
return false;
}
}
var delay = ComputeMovementSpeed(d);
long end;
if (m_MoveRecords.Count > 0)
{
end = m_EndQueue + delay;
}
else
{
end = Core.TickCount + delay;
}
m_MoveRecords.Enqueue(MovementRecord.NewInstance(end));
m_EndQueue = end;
}
LastMoveTime = Core.TickCount;
}
else
if (!CanMove(d, oldLocation, ref newLocation))
{
return false;
}
@ -4766,12 +4696,7 @@ namespace Server
DisruptiveAction();
}
m_NetState?.Send(
MovementAck.Instantiate(
m_NetState.Sequence,
this
)
);
m_NetState?.SendMovementAck(m_NetState.Sequence, this);
SetLocation(newLocation, false);
SetDirection(d);
@ -4886,22 +4811,14 @@ namespace Server
public int ComputeMovementSpeed() => ComputeMovementSpeed(Direction, false);
public int ComputeMovementSpeed(Direction dir) => ComputeMovementSpeed(dir, true);
public virtual int ComputeMovementSpeed(Direction dir, bool checkTurning)
public virtual int ComputeMovementSpeed(Direction dir, bool checkTurning = true)
{
int delay;
if (Mounted)
{
delay = (dir & Direction.Running) != 0 ? RunMount : WalkMount;
}
else
{
delay = (dir & Direction.Running) != 0 ? RunFoot : WalkFoot;
return (dir & Direction.Running) != 0 ? CalcMoves.RunMountDelay : CalcMoves.WalkMountDelay;
}
return delay;
return (dir & Direction.Running) != 0 ? CalcMoves.RunFootDelay : CalcMoves.WalkFootDelay;
}
/// <summary>
@ -7856,8 +7773,6 @@ namespace Server
{
m_NetState.Send(new MobileUpdateOld(this));
}
ClearFastwalkStack();
}
var map = m_Map;

40
Projects/Server/Mobiles/Movement.cs
View file

@ -1,8 +1,48 @@
/*************************************************************************
* ModernUO *
* Copyright 2019-2020 - ModernUO Development Team *
* Email: hi@modernuo.com *
* File: Movement.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/>. *
*************************************************************************/
namespace Server.Movement
{
public static class Movement
{
// Movement implementation algorithm
public static IMovementImpl Impl { get; set; }
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;
public static void Configure()
{
EnableFastwalkPrevention = ServerConfiguration.GetOrUpdateSetting("movement.enableFastWalkPrevention", EnableFastwalkPrevention);
MaxSteps = ServerConfiguration.GetOrUpdateSetting("movement.maxSteps", MaxSteps);
FastwalkExemptionLevel = ServerConfiguration.GetOrUpdateSetting("movement.fastwalkExemptionLevel", FastwalkExemptionLevel);
WalkFootDelay = ServerConfiguration.GetOrUpdateSetting("movement.delay.walkFoot", WalkFootDelay);
RunFootDelay = ServerConfiguration.GetOrUpdateSetting("movement.delay.runFoot", RunFootDelay);
WalkMountDelay = ServerConfiguration.GetOrUpdateSetting("movement.delay.walkMount", WalkMountDelay);
RunMountDelay = ServerConfiguration.GetOrUpdateSetting("movement.delay.runMount", RunMountDelay);
// Testing
FastwalkExemptionLevel = (AccessLevel)((int)AccessLevel.Owner + 1);
}
public static bool CheckMovement(Mobile m, Direction d, out int newZ)
{

57
Projects/Server/Mobiles/MovementRecord.cs
View file

@ -1,57 +0,0 @@
/*************************************************************************
* ModernUO *
* Copyright 2019-2020 - ModernUO Development Team *
* Email: hi@modernuo.com *
* File: MovementRecord.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.Collections.Generic;
namespace Server.Mobiles
{
public class MovementRecord
{
private static readonly Queue<MovementRecord> m_InstancePool = new Queue<MovementRecord>();
private long m_End;
private MovementRecord(long end) => m_End = end;
public static MovementRecord NewInstance(long end)
{
MovementRecord r;
if (m_InstancePool.Count > 0)
{
r = m_InstancePool.Dequeue();
r.m_End = end;
}
else
{
r = new MovementRecord(end);
}
return r;
}
public bool Expired()
{
var v = Core.TickCount - m_End >= 0;
if (v)
{
m_InstancePool.Enqueue(this);
}
return v;
}
}
}

92
Projects/Server/Network/NetState/NetState.Fastwalk.cs Normal file
View file

@ -0,0 +1,92 @@
/*************************************************************************
* ModernUO *
* Copyright 2019-2020 - ModernUO Development Team *
* Email: hi@modernuo.com *
* File: NetState.Fastwalk.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 CalcMoves = Server.Movement.Movement;
namespace Server.Network
{
public partial class NetState
{
private int _stepIndex;
private int _stepCount;
private long _startDelay;
private long[] _stepDelays;
public bool AddStep(Direction d)
{
if (Mobile == null)
{
return false;
}
var maxSteps = CalcMoves.MaxSteps;
_stepDelays ??= new long[maxSteps];
var length = _stepDelays.Length;
var index = _stepIndex - _stepCount;
if (index < 0)
{
index += length;
}
var now = Core.TickCount;
var last = _startDelay;
// Discard old steps by decrementing the step counter
while (index != _stepIndex || _stepCount >= maxSteps)
{
var step = _stepDelays[index++];
if (now - last < step)
{
break;
}
last += step;
_stepCount--;
if (index >= length)
{
index = 0;
}
}
_startDelay = last;
// If we are out of steps, fail
if (_stepCount >= maxSteps)
{
return false;
}
var delay = Mobile.ComputeMovementSpeed(d);
// Add the delay
_stepDelays[_stepIndex++] = delay;
if (_stepIndex >= length)
{
_stepIndex = 0;
}
if (_stepCount == 0)
{
_startDelay = now;
}
_stepCount++;
return true;
}
}
}

2
Projects/Server/Network/Packets/IncomingAccountPackets.cs
View file

@ -392,8 +392,6 @@ namespace Server.Network
state.SendMapChange(m.Map);
EventSink.InvokeLogin(m);
m.ClearFastwalkStack();
}
private static int GenerateAuthID(this NetState state)

120
Projects/Server/Network/Packets/IncomingMovementPackets.cs Normal file
View file

@ -0,0 +1,120 @@
/*************************************************************************
* ModernUO *
* Copyright 2019-2020 - ModernUO Development Team *
* Email: hi@modernuo.com *
* File: IncomingMovementPackets.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/>. *
*************************************************************************/
namespace Server.Network
{
public static class IncomingMovementPackets
{
public static void Configure()
{
IncomingPackets.Register(0x02, 7, true, MovementReq);
IncomingPackets.Register(0xF0, 0, true, NewMovementReq);
IncomingPackets.Register(0xF1, 9, true, TimeSyncReq);
}
public static void NewMovementReq(NetState ns, CircularBufferReader reader)
{
var from = ns.Mobile;
if (from == null)
{
return;
}
var steps = reader.ReadByte();
for (int i = 0; i < steps; i++)
{
var t1 = reader.ReadUInt64(); // start time?
var t2 = reader.ReadUInt64(); // end time?
int seq = reader.ReadByte();
var dir = (Direction)reader.ReadByte();
var mode = reader.ReadInt32(); // 1 = walk, 2 = run
if (mode == 2)
{
dir |= Direction.Running;
}
// Location
reader.ReadInt32(); // x
reader.ReadInt32(); // y
reader.ReadInt32(); // z
if (ns.Sequence == 0 && seq != 0 || !from.Move(dir))
{
ns.SendMovementRej(seq, from);
ns.Sequence = 0;
}
else
{
++seq;
if (seq == 256)
{
seq = 1;
}
ns.Sequence = seq;
}
}
}
public static void TimeSyncReq(NetState ns, CircularBufferReader reader)
{
reader.ReadUInt64(); // Client Time?
ns.SendTimeSyncResponse();
}
public static void MovementReq(NetState state, CircularBufferReader reader)
{
var from = state.Mobile;
if (from == null)
{
return;
}
var dir = (Direction)reader.ReadByte();
int seq = reader.ReadByte();
var key = reader.ReadUInt32();
if (key != 0)
{
state.WriteConsole("OldMove w/ Key {0}", key);
}
else
{
state.WriteConsole("Old Movement!");
}
if (state.Sequence == 0 && seq != 0 || !from.Move(dir))
{
state.SendMovementRej(seq, from);
state.Sequence = 0;
}
else
{
++seq;
if (seq == 256)
{
seq = 1;
}
state.Sequence = seq;
}
}
}
}

37
Projects/Server/Network/Packets/IncomingPlayerPackets.cs
View file

@ -23,7 +23,6 @@ namespace Server.Network
public static void Configure()
{
IncomingPackets.Register(0x01, 5, false, Disconnect);
IncomingPackets.Register(0x02, 7, true, MovementReq);
IncomingPackets.Register(0x05, 5, true, AttackReq);
IncomingPackets.Register(0x12, 0, true, TextCommand);
IncomingPackets.Register(0x22, 3, true, Resynchronize);
@ -490,8 +489,6 @@ namespace Server.Network
from.SendEverything();
state.Sequence = 0;
from.ClearFastwalkStack();
}
public static void PingReq(NetState state, CircularBufferReader reader)
@ -504,40 +501,6 @@ namespace Server.Network
state.Send(ChangeUpdateRange.Instantiate(18));
}
// TODO: Change to OSI fastwalk stack
public static void MovementReq(NetState state, CircularBufferReader reader)
{
var from = state.Mobile;
if (from == null)
{
return;
}
var dir = (Direction)reader.ReadByte();
int seq = reader.ReadByte();
var key = reader.ReadInt32(); // Fastwalk stack key
if (state.Sequence == 0 && seq != 0 || !from.Move(dir))
{
state.Send(new MovementRej(seq, from));
state.Sequence = 0;
from.ClearFastwalkStack();
}
else
{
++seq;
if (seq == 256)
{
seq = 1;
}
state.Sequence = seq;
}
}
public static void MobileQuery(NetState state, CircularBufferReader reader)
{
var from = state.Mobile;

98
Projects/Server/Network/Packets/MovementPackets.cs
View file

@ -1,98 +0,0 @@
/*************************************************************************
* ModernUO *
* Copyright 2019-2020 - ModernUO Development Team *
* Email: hi@modernuo.com *
* File: MovementPackets.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/>. *
*************************************************************************/
namespace Server.Network
{
public sealed class SpeedControl : Packet
{
public static readonly Packet WalkSpeed = SetStatic(new SpeedControl(2));
public static readonly Packet MountSpeed = SetStatic(new SpeedControl(1));
public static readonly Packet Disable = SetStatic(new SpeedControl(0));
public SpeedControl(int speedControl) : base(0xBF)
{
EnsureCapacity(3);
Stream.Write((short)0x26);
Stream.Write((byte)speedControl);
}
}
/// <summary>
/// Causes the client to walk in a given direction. It does not send a movement request.
/// </summary>
public sealed class MovePlayer : Packet
{
public MovePlayer(Direction d) : base(0x97, 2)
{
Stream.Write((byte)d);
// @4C63B0
}
}
public sealed class MovementRej : Packet
{
public MovementRej(int seq, Mobile m) : base(0x21, 8)
{
Stream.Write((byte)seq);
Stream.Write((short)m.X);
Stream.Write((short)m.Y);
Stream.Write((byte)m.Direction);
Stream.Write((sbyte)m.Z);
}
}
public sealed class MovementAck : Packet
{
private static readonly MovementAck[] m_Cache = new MovementAck[8 * 256];
private MovementAck(int seq, int noto) : base(0x22, 3)
{
Stream.Write((byte)seq);
Stream.Write((byte)noto);
}
public static MovementAck Instantiate(int seq, Mobile m)
{
var noto = Notoriety.Compute(m, m);
var p = m_Cache[noto * seq];
if (p == null)
{
m_Cache[noto * seq] = p = new MovementAck(seq, noto);
p.SetStatic();
}
return p;
}
}
public sealed class NullFastwalkStack : Packet
{
public NullFastwalkStack() : base(0xBF)
{
EnsureCapacity(256);
Stream.Write((short)0x1);
Stream.Write(0x0);
Stream.Write(0x0);
Stream.Write(0x0);
Stream.Write(0x0);
Stream.Write(0x0);
Stream.Write(0x0);
}
}
}

145
Projects/Server/Network/Packets/OutgoingMovementPackets.cs Normal file
View file

@ -0,0 +1,145 @@
/*************************************************************************
* ModernUO *
* Copyright 2019-2020 - ModernUO Development Team *
* Email: hi@modernuo.com *
* File: OutgoingMovementPackets.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;
namespace Server.Network
{
public enum SpeedControlSetting
{
Disable,
Mount,
Walk
}
public static class OutgoingMovementPackets
{
public static void SendSpeedControl(this NetState ns, SpeedControlSetting speedControl)
{
if (ns == null || !ns.GetSendBuffer(out var buffer))
{
return;
}
var writer = new CircularBufferWriter(buffer);
writer.Write((byte)0xBF); // Packet ID
writer.Write((ushort)06);
writer.Write((ushort)0x26); // Subpacket
writer.Write((byte)speedControl);
ns.Send(ref buffer, writer.Position);
}
public static void SendMovePlayer(this NetState ns, Direction d)
{
if (ns == null || !ns.GetSendBuffer(out var buffer))
{
return;
}
buffer[0] = 0x97; // Packet ID
buffer[1] = (byte)d;
ns.Send(ref buffer, 2);
}
public static void SendMovementAck(this NetState ns, int seq, Mobile m) =>
ns.SendMovementAck(seq, Notoriety.Compute(m, m));
public static void SendMovementAck(this NetState ns, int seq, int noto)
{
if (ns == null || !ns.GetSendBuffer(out var buffer))
{
return;
}
buffer[0] = 0x22; // Packet ID
buffer[1] = (byte)seq;
buffer[2] = (byte)noto;
ns.Send(ref buffer, 3);
}
public static void SendMovementRej(this NetState ns, int seq, Mobile m)
{
if (ns == null || !ns.GetSendBuffer(out var buffer))
{
return;
}
var writer = new CircularBufferWriter(buffer);
writer.Write((byte)0x21); // Packet ID
writer.Write((byte)seq);
writer.Write((short)m.X);
writer.Write((short)m.Y);
writer.Write((byte)m.Direction);
writer.Write((sbyte)m.Z);
ns.Send(ref buffer, 8);
}
public static void SendInitialFastwalkStack(this NetState ns, uint[] keys)
{
if (ns == null || !ns.GetSendBuffer(out var buffer))
{
return;
}
var writer = new CircularBufferWriter(buffer);
writer.Write((byte)0xBF); // Packet ID
writer.Write((ushort)0x1); // Subpacket
writer.Write(keys[0]);
writer.Write(keys[1]);
writer.Write(keys[2]);
writer.Write(keys[3]);
writer.Write(keys[4]);
writer.Write(keys[5]);
ns.Send(ref buffer, writer.Position);
}
public static void SendFastwalkStackKey(this NetState ns, uint key = 0)
{
if (ns == null || !ns.GetSendBuffer(out var buffer))
{
return;
}
var writer = new CircularBufferWriter(buffer);
writer.Write((byte)0xBF); // Packet ID
writer.Write((ushort)0x2); // Subpacket
writer.Write(key);
ns.Send(ref buffer, writer.Position);
}
public static void SendTimeSyncResponse(this NetState ns)
{
if (ns == null || !ns.GetSendBuffer(out var buffer))
{
return;
}
var writer = new CircularBufferWriter(buffer);
writer.Write((byte)0xF2); // Packet ID
writer.Write(Core.TickCount); // ??
writer.Write(Core.TickCount); // ??
writer.Write(Core.TickCount); // ??
ns.Send(ref buffer, writer.Position);
}
}
}

2
Projects/Server/Network/Pipe.cs
View file

@ -59,7 +59,7 @@ namespace Server.Network
return;
}
for (int i = 0; i < Buffer.Length; i++)
for (int i = 0; i < 2; i++)
{
var buffer = Buffer[i];
var sz = Math.Min(remaining, buffer.Count);

17
Projects/Server/Utilities/Utility.cs
View file

@ -1185,6 +1185,23 @@ namespace Server
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool RandomBool() => RandomSources.Source.NextBool();
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static uint RandomMinMax(uint min, uint max)
{
if (min > max)
{
var copy = min;
min = max;
max = copy;
}
else if (min == max)
{
return min;
}
return min + RandomSources.Source.Next(max - min + 1);
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static int RandomMinMax(int min, int max)
{