edmand46/Ragon
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

wip

Browse Source
This commit is contained in:
edmand46
2024-09-28 20:11:56 +03:00
parent 5136f08dab
commit 672bb1ff6d
95 changed files with 741 additions and 601 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Ragon.Client/Sources/Handler/AuthorizeFailedHandler.cs
+1 -1
View File
@@ -27,7 +27,7 @@ internal class AuthorizeFailedHandler: IHandler
_listenerList = list;
}
public void Handle(RagonBuffer reader)
public void Handle(RagonStream reader)
{
var message = reader.ReadString();
_listenerList.OnAuthorizationFailed(message);
Ragon.Client/Sources/Handler/AuthorizeSuccessHandler.cs
+1 -1
View File
@@ -32,7 +32,7 @@ internal class AuthorizeSuccessHandler: IHandler
_listenerList = listenerList;
}
public void Handle(RagonBuffer reader)
public void Handle(RagonStream reader)
{
var playerId = reader.ReadString();
var playerName = reader.ReadString();
Ragon.Client/Sources/Handler/IHandler.cs
+1 -1
View File
@@ -21,5 +21,5 @@ namespace Ragon.Client;
public interface IHandler
{
public void Handle(RagonBuffer reader);
public void Handle(RagonStream reader);
}
Ragon.Client/Sources/Handler/JoinFailedHandler.cs
+1 -1
View File
@@ -28,7 +28,7 @@ internal class JoinFailedHandler: IHandler
_listenerList = listenerList;
}
public void Handle(RagonBuffer reader)
public void Handle(RagonStream reader)
{
var message = reader.ReadString();
_listenerList.OnFailed(message);
Ragon.Client/Sources/Handler/JoinSuccessHandler.cs
+3 -8
View File
@@ -41,23 +41,20 @@ internal class JoinSuccessHandler : IHandler
{
private readonly RagonListenerList _listenerList;
private readonly RagonPlayerCache _playerCache;
private readonly RagonEntityCache _entityCache;
private readonly RagonClient _client;
public JoinSuccessHandler(
RagonClient client,
RagonListenerList listenerList,
RagonPlayerCache playerCache,
RagonEntityCache entityCache
RagonPlayerCache playerCache
)
{
_client = client;
_listenerList = listenerList;
_entityCache = entityCache;
_playerCache = playerCache;
}
public void Handle(RagonBuffer reader)
public void Handle(RagonStream reader)
{
var roomId = reader.ReadString();
var min = reader.ReadUShort();
@@ -68,9 +65,8 @@ internal class JoinSuccessHandler : IHandler
_playerCache.SetOwnerAndLocal(ownerId, localId);
var scene = new RagonScene(_client, _playerCache, _entityCache, sceneName);
var roomInfo = new RoomParameters(roomId, localId, ownerId, min, max);
var room = new RagonRoom(_client, _entityCache, _playerCache, roomInfo, scene);
var room = new RagonRoom(_client, _playerCache, roomInfo);
room.UserData.Read(reader);
@@ -93,6 +89,5 @@ internal class JoinSuccessHandler : IHandler
_client.SetStatus(RagonStatus.ROOM);
_listenerList.OnJoined();
_listenerList.OnSceneRequest(sceneName);
}
}
Ragon.Client/Sources/Handler/LeaveRoomHandler.cs
+2 -6
View File
@@ -23,22 +23,18 @@ internal class LeaveRoomHandler : IHandler
{
private readonly RagonClient _client;
private readonly RagonListenerList _listenerList;
private readonly RagonEntityCache _entityCache;
public LeaveRoomHandler(
RagonClient client,
RagonListenerList listenerList,
RagonEntityCache entityCache)
RagonListenerList listenerList)
{
_client = client;
_listenerList = listenerList;
_entityCache = entityCache;
}
public void Handle(RagonBuffer reader)
public void Handle(RagonStream reader)
{
_listenerList.OnLeft();
_entityCache.Cleanup();
_client.Room.Cleanup();
}
}
Ragon.Client/Sources/Handler/OwnershipRoomHandler.cs
+2 -5
View File
@@ -23,19 +23,16 @@ internal class OwnershipRoomHandler : IHandler
{
private readonly RagonListenerList _listenerList;
private readonly RagonPlayerCache _playerCache;
private readonly RagonEntityCache _entityCache;
public OwnershipRoomHandler(
RagonListenerList listenerList,
RagonPlayerCache playerCache,
RagonEntityCache entityCache)
RagonPlayerCache playerCache)
{
_listenerList = listenerList;
_playerCache = playerCache;
_entityCache = entityCache;
}
public void Handle(RagonBuffer reader)
public void Handle(RagonStream reader)
{
var newOwnerId = reader.ReadUShort();
var player = _playerCache.GetPlayerByPeer(newOwnerId);
Ragon.Client/Sources/Handler/PlayerJoinHandler.cs
+1 -1
View File
@@ -33,7 +33,7 @@ internal class PlayerJoinHandler : IHandler
_listenerList = listenerList;
}
public void Handle(RagonBuffer reader)
public void Handle(RagonStream reader)
{
var playerPeerId = reader.ReadUShort();
var playerId = reader.ReadString();
Ragon.Client/Sources/Handler/PlayerLeftHandler.cs
+4 -7
View File
@@ -22,21 +22,18 @@ namespace Ragon.Client;
internal class PlayerLeftHandler : IHandler
{
private RagonPlayerCache _playerCache;
private RagonEntityCache _entityCache;
private RagonListenerList _listenerList;
public PlayerLeftHandler(
RagonEntityCache entityCache,
RagonPlayerCache playerCache,
RagonListenerList listenerList
)
{
_entityCache = entityCache;
_playerCache = playerCache;
_listenerList = listenerList;
}
public void Handle(RagonBuffer reader)
public void Handle(RagonStream reader)
{
var playerId = reader.ReadString();
var player = _playerCache.GetPlayerById(playerId);
@@ -53,9 +50,9 @@ internal class PlayerLeftHandler : IHandler
toDeleteIds[i] = entityId;
}
var emptyPayload = new RagonPayload(0);
foreach (var id in toDeleteIds)
_entityCache.OnDestroy(id, emptyPayload);
// var emptyPayload = new RagonPayload(0);
// foreach (var id in toDeleteIds)
// _entityCache.OnDestroy(id, emptyPayload);
}
else
{
Ragon.Client/Sources/Handler/PlayerUserDataHandler.cs
+1 -1
View File
@@ -32,7 +32,7 @@ namespace Ragon.Client
_playerCache = playerCache;
_listenerList = listenerList;
}
public void Handle(RagonBuffer reader)
public void Handle(RagonStream reader)
{
var playerPeerId = reader.ReadUShort();
var player = _playerCache.GetPlayerByPeer(playerPeerId);
Ragon.Client/Sources/Handler/RoomDataHandler.cs
+2 -2
View File
@@ -32,9 +32,9 @@ internal class RoomDataHandler: IHandler
_listeners = listeners;
}
public void Handle(RagonBuffer reader)
public void Handle(RagonStream reader)
{
var rawData = reader.RawData;
var rawData = reader.ReadBinary(reader.Lenght);
var peerId = (ushort)(rawData[1] + (rawData[2] << 8));
RagonPlayer player = null;
Ragon.Client/Sources/Handler/RoomEventHandler.cs
+1 -1
View File
@@ -32,7 +32,7 @@ public class RoomEventHandler : IHandler
_playerCache = playerCache;
}
public void Handle(RagonBuffer buffer)
public void Handle(RagonStream buffer)
{
var eventCode = buffer.ReadUShort();
var peerId = buffer.ReadUShort();
Ragon.Client/Sources/Handler/RoomListHandler.cs
+1 -1
View File
@@ -13,7 +13,7 @@ internal class RoomListHandler: IHandler
_listenerList = list;
}
public void Handle(RagonBuffer reader)
public void Handle(RagonStream reader)
{
var roomCount = reader.ReadUShort();
var roomList = new RagonRoomInformation[roomCount];
Ragon.Client/Sources/Handler/RoomUserDataHandler.cs
+1 -1
View File
@@ -29,7 +29,7 @@ namespace Ragon.Client
_listenerList = listenerList;
}
public void Handle(RagonBuffer reader)
public void Handle(RagonStream reader)
{
var changes = _client.Room?.UserData.Read(reader);
_listenerList.OnRoomUserData(changes);
Ragon.Client/Sources/Handler/TimestampHandler.cs
+3 -3
View File
@@ -10,10 +10,10 @@ public class TimestampHandler: IHandler
_client = client;
}
public void Handle(RagonBuffer buffer)
public void Handle(RagonStream buffer)
{
var timestamp0 = buffer.Read(32);
var timestamp1 = buffer.Read(32);
var timestamp0 = (uint)buffer.ReadInt();
var timestamp1 = (uint)buffer.ReadInt();
var value = new DoubleToUInt { Int0 = timestamp0, Int1 = timestamp1 };
_client.SetTimestamp(value.Double);
Ragon.Client/Sources/IUserData.cs
+2 -2
View File
@@ -22,6 +22,6 @@ public interface IUserData
{
public byte[] this[string key] { get; set; }
bool Dirty { get; }
IReadOnlyList<string> Read(RagonBuffer buffer);
void Write(RagonBuffer buffer);
IReadOnlyList<string> Read(RagonStream buffer);
void Write(RagonStream buffer);
}
Ragon.Client/Sources/RagonClient.cs
+13 -55
View File
@@ -22,16 +22,14 @@ namespace Ragon.Client
{
private readonly INetworkConnection _connection;
private readonly NetworkStatistics _stats;
private IRagonEntityListener _entityListener;
private IRagonSceneCollector _sceneCollector;
private IHandler[] _handlers;
private RagonBuffer _readBuffer;
private RagonBuffer _writeBuffer;
private RagonStream _readBuffer;
private RagonStream _writeBuffer;
private RagonRoom _room;
private RagonSession _session;
private RagonListenerList _listeners;
private RagonPlayerCache _playerCache;
private RagonEntityCache _entityCache;
private RagonEventCache _eventCache;
private RagonStatus _status;
@@ -44,11 +42,10 @@ namespace Ragon.Client
public RagonStatus Status => _status;
public RagonSession Session => _session;
public RagonEventCache Event => _eventCache;
public RagonEntityCache Entity => _entityCache;
public NetworkStatistics Statistics => _stats;
public RagonRoom Room => _room;
internal RagonBuffer Buffer => _writeBuffer;
internal RagonStream Buffer => _writeBuffer;
internal INetworkChannel Reliable => _connection.Reliable;
internal INetworkChannel Unreliable => _connection.Unreliable;
@@ -72,58 +69,23 @@ namespace Ragon.Client
}
public void Configure(IRagonSceneCollector sceneCollector)
{
_sceneCollector = sceneCollector;
}
public void Configure(IRagonEntityListener listener)
{
_entityListener = listener;
}
public void Connect(string address, ushort port, string protocol)
{
if (_sceneCollector == null)
{
RagonLog.Error("Scene collector is not defined!");
return;
}
if (_entityListener == null)
{
RagonLog.Error("Entity Listener is not defined!");
return;
}
_writeBuffer = new RagonBuffer();
_readBuffer = new RagonBuffer();
_writeBuffer = new RagonStream();
_readBuffer = new RagonStream();
_playerCache = new RagonPlayerCache();
_session = new RagonSession(this, _writeBuffer);
_entityCache = new RagonEntityCache(this, _playerCache, _sceneCollector);
_handlers = new IHandler[byte.MaxValue];
_handlers[(byte)RagonOperation.AUTHORIZED_SUCCESS] = new AuthorizeSuccessHandler(this, _listeners);
_handlers[(byte)RagonOperation.AUTHORIZED_FAILED] = new AuthorizeFailedHandler(_listeners);
_handlers[(byte)RagonOperation.JOIN_SUCCESS] =
new JoinSuccessHandler(this, _listeners, _playerCache, _entityCache);
_handlers[(byte)RagonOperation.JOIN_SUCCESS] = new JoinSuccessHandler(this, _listeners, _playerCache);
_handlers[(byte)RagonOperation.JOIN_FAILED] = new JoinFailedHandler(_listeners);
_handlers[(byte)RagonOperation.LEAVE_ROOM] = new LeaveRoomHandler(this, _listeners, _entityCache);
_handlers[(byte)RagonOperation.OWNERSHIP_ROOM_CHANGED] =
new OwnershipRoomHandler(_listeners, _playerCache, _entityCache);
_handlers[(byte)RagonOperation.OWNERSHIP_ENTITY_CHANGED] =
new EntityOwnershipHandler(_listeners, _playerCache, _entityCache);
_handlers[(byte)RagonOperation.LEAVE_ROOM] = new LeaveRoomHandler(this, _listeners);
_handlers[(byte)RagonOperation.OWNERSHIP_ROOM_CHANGED] = new OwnershipRoomHandler(_listeners, _playerCache);
_handlers[(byte)RagonOperation.PLAYER_JOINED] = new PlayerJoinHandler(_playerCache, _listeners);
_handlers[(byte)RagonOperation.PLAYER_LEAVED] = new PlayerLeftHandler(_entityCache, _playerCache, _listeners);
_handlers[(byte)RagonOperation.LOAD_SCENE] = new SceneLoadHandler(this, _listeners);
_handlers[(byte)RagonOperation.CREATE_ENTITY] =
new EntityCreateHandler(this, _playerCache, _entityCache, _entityListener);
_handlers[(byte)RagonOperation.REMOVE_ENTITY] = new EntityRemoveHandler(_entityCache);
_handlers[(byte)RagonOperation.REPLICATE_ENTITY_STATE] = new StateEntityHandler(_entityCache);
_handlers[(byte)RagonOperation.REPLICATE_ENTITY_EVENT] = new EntityEventHandler(_playerCache, _entityCache);
_handlers[(byte)RagonOperation.PLAYER_LEAVED] = new PlayerLeftHandler(_playerCache, _listeners);
_handlers[(byte)RagonOperation.REPLICATE_ROOM_EVENT] = new RoomEventHandler(this, _playerCache);
_handlers[(byte)RagonOperation.SNAPSHOT] =
new SnapshotHandler(this, _listeners, _entityCache, _playerCache, _entityListener);
_handlers[(byte)RagonOperation.TIMESTAMP_SYNCHRONIZATION] = new TimestampHandler(this);
_handlers[(byte)RagonOperation.REPLICATE_RAW_DATA] = new RoomDataHandler(_playerCache, _listeners);
_handlers[(byte)RagonOperation.ROOM_LIST_UPDATED] = new RoomListHandler(_session, _listeners);
@@ -151,7 +113,7 @@ namespace Ragon.Client
if (_replicationTime >= _replicationRate)
{
_replicationTime = 0;
_entityCache.WriteState(_writeBuffer);
// _entityCache.WriteState(_writeBuffer);
SendTimestamp();
SendRoomUserData();
@@ -185,8 +147,6 @@ namespace Ragon.Client
public void AddListener(IRagonOwnershipChangedListener listener) => _listeners.Add(listener);
public void AddListener(IRagonPlayerJoinListener listener) => _listeners.Add(listener);
public void AddListener(IRagonPlayerLeftListener listener) => _listeners.Add(listener);
public void AddListener(IRagonSceneListener listener) => _listeners.Add(listener);
public void AddListener(IRagonSceneRequestListener listener) => _listeners.Add(listener);
public void AddListener(IRagonDataListener listener) => _listeners.Add(listener);
public void AddListener(IRagonRoomListListener listener) => _listeners.Add(listener);
public void AddListener(IRagonPlayerUserDataListener listener) => _listeners.Add(listener);
@@ -200,8 +160,6 @@ namespace Ragon.Client
public void RemoveListener(IRagonOwnershipChangedListener listener) => _listeners.Remove(listener);
public void RemoveListener(IRagonPlayerJoinListener listener) => _listeners.Remove(listener);
public void RemoveListener(IRagonPlayerLeftListener listener) => _listeners.Remove(listener);
public void RemoveListener(IRagonSceneListener listener) => _listeners.Remove(listener);
public void RemoveListener(IRagonSceneRequestListener listener) => _listeners.Remove(listener);
public void RemoveListener(IRagonDataListener listener) => _listeners.Remove(listener);
public void RemoveListener(IRagonRoomListListener listener) => _listeners.Remove(listener);
public void RemoveListener(IRagonRoomUserDataListener listener) => _listeners.Remove(listener);
@@ -241,8 +199,8 @@ namespace Ragon.Client
_writeBuffer.Clear();
_writeBuffer.WriteOperation(RagonOperation.TIMESTAMP_SYNCHRONIZATION);
_writeBuffer.Write(value.Int0, 32);
_writeBuffer.Write(value.Int1, 32);
_writeBuffer.WriteInt((int)value.Int0);
_writeBuffer.WriteInt((int)value.Int1);
}
private void SendRoomUserData()
Ragon.Client/Sources/RagonListenerList.cs
-36
View File
@@ -26,8 +26,6 @@ namespace Ragon.Client
private readonly List<IRagonFailedListener> _failedListeners = new();
private readonly List<IRagonJoinListener> _joinListeners = new();
private readonly List<IRagonLeftListener> _leftListeners = new();
private readonly List<IRagonSceneListener> _sceneListeners = new();
private readonly List<IRagonSceneRequestListener> _sceneRequestListeners = new();
private readonly List<IRagonOwnershipChangedListener> _ownershipChangedListeners = new();
private readonly List<IRagonPlayerJoinListener> _playerJoinListeners = new();
private readonly List<IRagonPlayerLeftListener> _playerLeftListeners = new();
@@ -49,7 +47,6 @@ namespace Ragon.Client
_failedListeners.Add(listener);
_joinListeners.Add(listener);
_leftListeners.Add(listener);
_sceneListeners.Add(listener);
_ownershipChangedListeners.Add(listener);
_playerJoinListeners.Add(listener);
_playerLeftListeners.Add(listener);
@@ -66,7 +63,6 @@ namespace Ragon.Client
_failedListeners.Remove(listener);
_joinListeners.Remove(listener);
_leftListeners.Remove(listener);
_sceneListeners.Remove(listener);
_ownershipChangedListeners.Remove(listener);
_playerJoinListeners.Remove(listener);
_playerLeftListeners.Remove(listener);
@@ -93,11 +89,6 @@ namespace Ragon.Client
_authorizationListeners.Add(listener);
}
public void Add(IRagonSceneRequestListener listener)
{
_sceneRequestListeners.Add(listener);
}
public void Add(IRagonConnectionListener listener)
{
_connectionListeners.Add(listener);
@@ -118,11 +109,6 @@ namespace Ragon.Client
_leftListeners.Add(listener);
}
public void Add(IRagonSceneListener listener)
{
_sceneListeners.Add(listener);
}
public void Add(IRagonOwnershipChangedListener listener)
{
_ownershipChangedListeners.Add(listener);
@@ -158,11 +144,6 @@ namespace Ragon.Client
_delayedActions.Add(() => _dataListeners.Remove(listener));
}
public void Remove(IRagonSceneRequestListener listener)
{
_delayedActions.Add(() => _sceneRequestListeners.Remove(listener));
}
public void Remove(IRagonAuthorizationListener listener)
{
_delayedActions.Add(() => _authorizationListeners.Remove(listener));
@@ -188,11 +169,6 @@ namespace Ragon.Client
_delayedActions.Add(() => _leftListeners.Remove(listener));
}
public void Remove(IRagonSceneListener listener)
{
_delayedActions.Add(() => _sceneListeners.Remove(listener));
}
public void Remove(IRagonOwnershipChangedListener listener)
{
_delayedActions.Add(() => _ownershipChangedListeners.Remove(listener));
@@ -265,18 +241,6 @@ namespace Ragon.Client
listener.OnPlayerJoined(_client, player);
}
public void OnSceneLoaded()
{
foreach (var listener in _sceneListeners)
listener.OnSceneLoaded(_client);
}
public void OnSceneRequest(string sceneName)
{
foreach (var listener in _sceneRequestListeners)
listener.OnRequestScene(_client, sceneName);
}
public void OnJoined()
{
foreach (var listener in _joinListeners)
Ragon.Client/Sources/RagonRoom.cs
+72 -31
View File
@@ -47,11 +47,9 @@ namespace Ragon.Client
}
}
private delegate void OnEventDelegate(RagonPlayer player, RagonBuffer serializer);
private delegate void OnEventDelegate(RagonPlayer player, RagonStream serializer);
private readonly RagonClient _client;
private readonly RagonScene _scene;
private readonly RagonEntityCache _entityCache;
private readonly RagonPlayerCache _playerCache;
private readonly RoomParameters _parameters;
private readonly RagonUserData _userData;
@@ -59,47 +57,40 @@ namespace Ragon.Client
public string Id => _parameters.RoomId;
public int MinPlayers => _parameters.Min;
public int MaxPlayers => _parameters.Max;
public string Scene => _scene.Name;
public string Scene => "none";
public IReadOnlyList<RagonPlayer> Players => _playerCache.Players;
public RagonPlayer Local => _playerCache.Local;
public RagonPlayer Owner => _playerCache.Owner;
public RagonUserData UserData => _userData;
private readonly Dictionary<int, OnEventDelegate> _events = new Dictionary<int, OnEventDelegate>();
private readonly Dictionary<int, OnEventDelegate> _events = new();
private readonly Dictionary<int, List<Action<RagonPlayer, IRagonEvent>>> _localListeners =
new Dictionary<int, List<Action<RagonPlayer, IRagonEvent>>>();
private readonly Dictionary<int, List<Action<RagonPlayer, IRagonEvent>>> _localListeners = new();
private readonly Dictionary<int, List<Action<RagonPlayer, IRagonEvent>>> _listeners =
new Dictionary<int, List<Action<RagonPlayer, IRagonEvent>>>();
private readonly Dictionary<int, List<Action<RagonPlayer, IRagonEvent>>> _listeners = new();
public RagonRoom(RagonClient client,
RagonEntityCache entityCache,
RagonPlayerCache playerCache,
RoomParameters parameters,
RagonScene scene)
RoomParameters parameters)
{
_client = client;
_parameters = parameters;
_entityCache = entityCache;
_playerCache = playerCache;
_scene = scene;
_userData = new RagonUserData();
}
internal void Cleanup()
{
_entityCache.Cleanup();
_playerCache.Cleanup();
}
internal void Update(string sceneName)
{
_scene.Update(sceneName);
// _scene.Update(sceneName);
}
internal void HandleEvent(ushort eventCode, RagonPlayer caller, RagonBuffer buffer)
internal void HandleEvent(ushort eventCode, RagonPlayer caller, RagonStream buffer)
{
if (_events.TryGetValue(eventCode, out var evnt))
evnt?.Invoke(caller, buffer);
@@ -107,11 +98,11 @@ namespace Ragon.Client
RagonLog.Warn($"Handler event {Id} with eventCode {eventCode} not defined");
}
internal void HandleUserData(RagonBuffer buffer)
internal void HandleUserData(RagonStream buffer)
{
_userData.Read(buffer);
}
public IDisposable OnEvent<TEvent>(Action<RagonPlayer, TEvent> callback) where TEvent : IRagonEvent, new()
{
var t = new TEvent();
@@ -147,23 +138,73 @@ namespace Ragon.Client
return new EventSubscription(callbacks, localCallbacks, action);
}
public void LoadScene(string sceneName) => _scene.Load(sceneName);
public void SceneLoaded() => _scene.SceneLoaded();
public void ReplicateEvent<TEvent>(TEvent evnt, RagonTarget target, RagonReplicationMode replicationMode)
where TEvent : IRagonEvent, new()
{
var evntId = _client.Event.GetEventCode(evnt);
var buffer = _client.Buffer;
public void ReplicateEvent<TEvent>(TEvent evnt, RagonTarget target, RagonReplicationMode mode)
where TEvent : IRagonEvent, new() => _scene.ReplicateEvent(evnt, target, mode);
{
if (replicationMode == RagonReplicationMode.Local &&
_localListeners.TryGetValue(evntId, out var localListeners))
{
foreach (var listener in localListeners)
listener.Invoke(_client.Room.Local, evnt);
return;
}
}
public void ReplicateEvent<TEvent>(TEvent evnt, RagonPlayer target, RagonReplicationMode mode)
where TEvent : IRagonEvent, new() => _scene.ReplicateEvent(evnt, target, mode);
{
if (replicationMode == RagonReplicationMode.LocalAndServer &&
_localListeners.TryGetValue(evntId, out var localListeners))
{
foreach (var listener in localListeners)
listener.Invoke(_client.Room.Local, evnt);
}
}
public void ReplicateData(byte[] data, bool reliable = false) => _scene.ReplicateData(data, reliable);
buffer.Clear();
buffer.WriteOperation(RagonOperation.REPLICATE_ROOM_EVENT);
buffer.WriteUShort(evntId);
buffer.WriteByte((byte)replicationMode);
buffer.WriteByte((byte)target);
public void CreateEntity(RagonEntity entity) => CreateEntity(entity, null);
public void CreateEntity(RagonEntity entity, RagonPayload payload) => _entityCache.Create(entity, payload);
public void TransferEntity(RagonEntity entity, RagonPlayer player) => _entityCache.Transfer(entity, player);
evnt.Serialize(buffer);
public void DestroyEntity(RagonEntity entityId) => DestroyEntity(entityId, null);
public void DestroyEntity(RagonEntity entityId, RagonPayload payload) => _entityCache.Destroy(entityId, payload);
var sendData = buffer.ToArray();
_client.Reliable.Send(sendData);
}
public void ReplicateEvent<TEvent>(TEvent evnt, RagonPlayer target, RagonReplicationMode replicationMode)
where TEvent : IRagonEvent, new()
{
var evntId = _client.Event.GetEventCode(evnt);
var buffer = _client.Buffer;
buffer.Clear();
buffer.WriteOperation(RagonOperation.REPLICATE_ROOM_EVENT);
buffer.WriteUShort(evntId);
buffer.WriteByte((byte)replicationMode);
buffer.WriteByte((byte)RagonTarget.Player);
buffer.WriteUShort(target.PeerId);
evnt.Serialize(buffer);
var sendData = buffer.ToArray();
_client.Reliable.Send(sendData);
}
public void ReplicateData(byte[] data, bool reliable)
{
var sendData = new byte[data.Length + 1];
sendData[0] = (byte)RagonOperation.REPLICATE_RAW_DATA;
Array.Copy(data, 0, sendData, 1, data.Length);
if (reliable)
_client.Reliable.Send(sendData);
else
_client.Unreliable.Send(sendData);
}
public void Dispose()
{
Ragon.Client/Sources/RagonSession.cs
+2 -2
View File
@@ -21,9 +21,9 @@ namespace Ragon.Client
public class RagonSession
{
private readonly RagonClient _client;
private readonly RagonBuffer _buffer;
private readonly RagonStream _buffer;
public RagonSession(RagonClient client, RagonBuffer buffer)
public RagonSession(RagonClient client, RagonStream buffer)
{
_client = client;
_buffer = buffer;
Ragon.Client/Sources/RagonUserData.cs
+4 -4
View File
@@ -57,7 +57,7 @@ namespace Ragon.Client
{
}
public IReadOnlyList<string> Read(RagonBuffer buffer)
public IReadOnlyList<string> Read(RagonStream buffer)
{
var len = buffer.ReadUShort();
var changes = new List<string>(len);
@@ -67,7 +67,7 @@ namespace Ragon.Client
var valueSize = buffer.ReadUShort();
if (valueSize > 0)
{
var value = buffer.ReadBytes(valueSize);
var value = buffer.ReadBinary(valueSize);
_properties[key] = value;
}
else
@@ -81,7 +81,7 @@ namespace Ragon.Client
return changes;
}
public void Write(RagonBuffer buffer)
public void Write(RagonStream buffer)
{
buffer.WriteUShort((ushort)_localChanges.Count);
foreach (var propertyChanged in _localChanges)
@@ -90,7 +90,7 @@ namespace Ragon.Client
if (_properties.TryGetValue(propertyChanged, out var property))
{
buffer.WriteUShort((ushort)property.Length);
buffer.WriteBytes(property);
buffer.WriteBinary(property);
}
else
{
Ragon.Client/Sources/RagonUserDataReadOnly.cs
+3 -3
View File
@@ -35,12 +35,12 @@ public class RagonUserDataReadOnly : IUserData
{
}
public void Write(RagonBuffer buffer)
public void Write(RagonStream buffer)
{
}
public IReadOnlyList<string> Read(RagonBuffer buffer)
public IReadOnlyList<string> Read(RagonStream buffer)
{
var len = buffer.ReadUShort();
var changes = new List<string>(len);
@@ -50,7 +50,7 @@ public class RagonUserDataReadOnly : IUserData
var valueSize = buffer.ReadUShort();
if (valueSize > 0)
{
var value = buffer.ReadBytes(valueSize);
var value = buffer.ReadBinary(valueSize);
_properties[key] = value;
}
Ragon.Client/Sources/Utils/CompressorExtension.cs → Ragon.Client/Sources/Replication/Compressor/Extensions.cs
View File
Ragon.Client/Sources/Compressor/FloatCompressor.cs → Ragon.Client/Sources/Replication/Compressor/FloatCompressor.cs
View File
Ragon.Client/Sources/Compressor/IntCompressor.cs → Ragon.Client/Sources/Replication/Compressor/IntCompressor.cs
View File
Ragon.Client/Sources/Entity/RagonEntity.cs → Ragon.Client/Sources/Replication/Entity/RagonEntity.cs
+4 -4
View File
@@ -17,7 +17,7 @@
using Ragon.Protocol;
namespace Ragon.Client
namespace Ragon.Client.Replication
{
public sealed class RagonEntity : IDisposable
{
@@ -118,9 +118,9 @@ namespace Ragon.Client
var buffer = new RagonBuffer();
data.Write(buffer);
// data.Write(buffer);
payload.Deserialize(buffer);
// payload.Deserialize(buffer);
return payload;
}
@@ -251,7 +251,7 @@ namespace Ragon.Client
{
_events.Add(eventCode, (player, serializer) =>
{
t.Deserialize(serializer);
// t.Deserialize(serializer);
foreach (var callbackListener in callbacks)
callbackListener.Invoke(player, t);
Ragon.Client/Sources/Entity/RagonEntityState.cs → Ragon.Client/Sources/Replication/Entity/RagonEntityState.cs
+1 -1
View File
@@ -17,7 +17,7 @@
using Ragon.Protocol;
namespace Ragon.Client;
namespace Ragon.Client.Replication;
public sealed class RagonEntityState
{
Ragon.Client/Sources/Entity/RagonPayload.cs → Ragon.Client/Sources/Replication/Entity/RagonPayload.cs
+6 -6
View File
@@ -17,13 +17,13 @@
using Ragon.Protocol;
namespace Ragon.Client;
namespace Ragon.Client.Replication;
public class RagonPayload
{
public static RagonPayload Empty = new RagonPayload(0);
private readonly uint[] _data = new uint[128];
private byte[] _data = new byte[128];
private readonly int _size = 0;
public RagonPayload(int capacity)
@@ -32,14 +32,14 @@ public class RagonPayload
}
public int Size => _size;
public void Read(RagonBuffer buffer)
public void Read(RagonStream buffer)
{
buffer.ReadArray(_data, _size);
_data = buffer.ReadBinary(_size);
}
public void Write(RagonBuffer buffer)
public void Write(RagonStream buffer)
{
buffer.WriteArray(_data, _size);
buffer.WriteBinary(_data);
}
public override string ToString()
Ragon.Client/Sources/Entity/RagonProperty.cs → Ragon.Client/Sources/Replication/Entity/RagonProperty.cs
+1 -1
View File
@@ -16,7 +16,7 @@
using Ragon.Protocol;
namespace Ragon.Client
namespace Ragon.Client.Replication
{
[Serializable]
public class RagonProperty
Ragon.Client/Sources/Handler/EntityCreateHandler.cs → Ragon.Client/Sources/Replication/Handler/EntityCreateHandler.cs
+6 -6
View File
@@ -16,9 +16,9 @@
using Ragon.Protocol;
namespace Ragon.Client;
namespace Ragon.Client.Replication;
internal class EntityCreateHandler : IHandler
internal class EntityCreateHandler
{
private readonly RagonClient _client;
private readonly RagonPlayerCache _playerCache;
@@ -38,15 +38,15 @@ internal class EntityCreateHandler : IHandler
_entityListener = entityListener;
}
public void Handle(RagonBuffer reader)
public void Handle(RagonStream reader)
{
var attachId = reader.ReadUShort();
var entityType = reader.ReadUShort();
var entityId = reader.ReadUShort();
var ownerId = reader.ReadUShort();
var player = _playerCache.GetPlayerByPeer(ownerId);
var payload = new RagonPayload(reader.Capacity);
payload.Read(reader);
// var payload = new RagonPayload(reader.Capacity);
// payload.Read(reader);
if (player == null)
{
@@ -59,7 +59,7 @@ internal class EntityCreateHandler : IHandler
var hasAuthority = _playerCache.Local.Id == player.Id;
var entity = _entityCache.TryGetEntity(attachId, entityType, 0, entityId, hasAuthority, out var hasCreated);
entity.Prepare(_client, entityId, entityType, hasAuthority, player, payload);
// entity.Prepare(_client, entityId, entityType, hasAuthority, player, payload);
if (hasCreated)
_entityListener.OnEntityCreated(entity);
Ragon.Client/Sources/Handler/EntityEventHandler.cs → Ragon.Client/Sources/Replication/Handler/EntityEventHandler.cs
+2 -2
View File
@@ -16,9 +16,9 @@
using Ragon.Protocol;
namespace Ragon.Client;
namespace Ragon.Client.Replication;
internal class EntityEventHandler : IHandler
internal class EntityEventHandler
{
private readonly RagonPlayerCache _playerCache;
private readonly RagonEntityCache _entityCache;
Ragon.Client/Sources/Handler/EntityOwnershipHandler.cs → Ragon.Client/Sources/Replication/Handler/EntityOwnershipHandler.cs
+2 -2
View File
@@ -17,9 +17,9 @@
using Ragon.Protocol;
namespace Ragon.Client;
namespace Ragon.Client.Replication;
internal class EntityOwnershipHandler: IHandler
internal class EntityOwnershipHandler
{
private readonly RagonListenerList _listenerList;
private readonly RagonPlayerCache _playerCache;
Ragon.Client/Sources/Handler/EntityRemoveHandler.cs → Ragon.Client/Sources/Replication/Handler/EntityRemoveHandler.cs
+5 -5
View File
@@ -17,9 +17,9 @@
using Ragon.Protocol;
namespace Ragon.Client;
namespace Ragon.Client.Replication;
internal class EntityRemoveHandler: IHandler
internal class EntityRemoveHandler
{
private readonly RagonEntityCache _entityCache;
@@ -31,9 +31,9 @@ internal class EntityRemoveHandler: IHandler
public void Handle(RagonBuffer reader)
{
var entityId = reader.ReadUShort();
var payload = new RagonPayload(reader.Capacity);
payload.Read(reader);
// var payload = new RagonPayload(reader.Capacity);
// payload.Read(reader);
_entityCache.OnDestroy(entityId, payload);
// _entityCache.OnDestroy(entityId, payload);
}
}
Ragon.Client/Sources/Handler/EntityStateHandler.cs → Ragon.Client/Sources/Replication/Handler/EntityStateHandler.cs
+2 -2
View File
@@ -16,9 +16,9 @@
using Ragon.Protocol;
namespace Ragon.Client;
namespace Ragon.Client.Replication;
internal class StateEntityHandler: IHandler
internal class StateEntityHandler
{
private readonly RagonEntityCache _entityCache;
Ragon.Client/Sources/Handler/LoadSceneHandler.cs → Ragon.Client/Sources/Replication/Handler/LoadSceneHandler.cs
+3 -3
View File
@@ -16,9 +16,9 @@
using Ragon.Protocol;
namespace Ragon.Client;
namespace Ragon.Client.Replication;
internal class SceneLoadHandler: IHandler
internal class SceneLoadHandler
{
private readonly RagonClient _client;
private readonly RagonListenerList _listenerList;
@@ -40,6 +40,6 @@ internal class SceneLoadHandler: IHandler
room.Cleanup();
room.Update(sceneName);
_listenerList.OnSceneRequest(sceneName);
// _listenerList.OnSceneRequest(sceneName);
}
}
Ragon.Client/Sources/Handler/SnapshotHandler.cs → Ragon.Client/Sources/Replication/Handler/SnapshotHandler.cs
+5 -7
View File
@@ -14,13 +14,11 @@
* limitations under the License.
*/
using System.Diagnostics;
using Ragon.Protocol;
namespace Ragon.Client;
namespace Ragon.Client.Replication;
internal class SnapshotHandler : IHandler
internal class SnapshotHandler
{
private readonly IRagonEntityListener _entityListener;
private readonly RagonClient _client;
@@ -69,8 +67,8 @@ internal class SnapshotHandler : IHandler
var payload = RagonPayload.Empty;
if (payloadSize > 0)
{
payload = new RagonPayload(payloadSize);
payload.Read(buffer);
// payload = new RagonPayload(payloadSize);
// payload.Read(buffer);
}
entity.Prepare(_client, entityId, entityType, hasAuthority, player, payload);
@@ -113,6 +111,6 @@ internal class SnapshotHandler : IHandler
foreach (var entity in entities)
entity.Attach();
_listenerList.OnSceneLoaded();
// _listenerList.OnSceneLoaded();
}
}
Ragon.Client/Sources/IRagonEntityListener.cs → Ragon.Client/Sources/Replication/IRagonEntityListener.cs
+1 -1
View File
@@ -14,7 +14,7 @@
* limitations under the License.
*/
namespace Ragon.Client;
namespace Ragon.Client.Replication;
public interface IRagonEntityListener
{
Ragon.Client/Sources/IRagonPayload.cs → Ragon.Client/Sources/Replication/IRagonPayload.cs
+3 -2
View File
@@ -18,8 +18,9 @@ using Ragon.Protocol;
namespace Ragon.Client
{
public interface IRagonPayload: IRagonSerializable
public interface IRagonPayload
{
public void Serialize(RagonStream buffer);
public void Deserialize(RagonStream buffer);
}
}
Ragon.Client/Sources/IRagonSceneCollector.cs → Ragon.Client/Sources/Replication/IRagonSceneCollector.cs
+1 -1
View File
@@ -14,7 +14,7 @@
* limitations under the License.
*/
namespace Ragon.Client;
namespace Ragon.Client.Replication;
public interface IRagonSceneCollector
{
Ragon.Client/Sources/RagonEntityCache.cs → Ragon.Client/Sources/Replication/RagonEntityCache.cs
+2 -2
View File
@@ -16,7 +16,7 @@
using Ragon.Protocol;
namespace Ragon.Client;
namespace Ragon.Client.Replication;
public sealed class RagonEntityCache
{
@@ -58,7 +58,7 @@ public sealed class RagonEntityCache
buffer.WriteUShort(entity.Type);
buffer.WriteByte((byte)entity.Authority);
entity.State.WriteInfo(buffer);
// entity.State.WriteInfo(buffer);
spawnPayload?.Write(buffer);
Ragon.Client/Sources/RagonScene.cs → Ragon.Client/Sources/Replication/RagonScene.cs
+20 -20
View File
@@ -16,20 +16,20 @@
using Ragon.Protocol;
namespace Ragon.Client;
namespace Ragon.Client.Replication;
public class RagonScene
{
public string Name { get; private set; }
private readonly RagonClient _client;
private readonly RagonEntityCache _entityCache;
private readonly RagonPlayerCache _playerCache;
public RagonScene(RagonClient client, RagonPlayerCache playerCache, RagonEntityCache entityCache, string sceneName)
{
Name = sceneName;
_client = client;
_playerCache = playerCache;
_entityCache = entityCache;
@@ -39,11 +39,11 @@ public class RagonScene
{
Name = scene;
}
internal void Load(string sceneName)
{
var buffer = _client.Buffer;
buffer.Clear();
buffer.WriteOperation(RagonOperation.LOAD_SCENE);
buffer.WriteString(sceneName);
@@ -55,38 +55,38 @@ public class RagonScene
internal void SceneLoaded()
{
var buffer = _client.Buffer;
buffer.Clear();
buffer.WriteOperation(RagonOperation.SCENE_LOADED);
if (_playerCache.IsRoomOwner)
_entityCache.WriteScene(buffer);
else
_entityCache.CacheScene();
// if (_playerCache.IsRoomOwner)
// _entityCache.WriteScene(buffer);
// else
// _entityCache.CacheScene();
var sendData = buffer.ToArray();
_client.Reliable.Send(sendData);
}
internal void ReplicateEvent<TEvent>(TEvent evnt, RagonTarget target, RagonReplicationMode replicationMode)
public void ReplicateEvent<TEvent>(TEvent evnt, RagonTarget target, RagonReplicationMode replicationMode)
where TEvent : IRagonEvent, new()
{
var evntId = _client.Event.GetEventCode(evnt);
var buffer = _client.Buffer;
buffer.Clear();
buffer.WriteOperation(RagonOperation.REPLICATE_ROOM_EVENT);
buffer.WriteUShort(evntId);
buffer.WriteByte((byte)replicationMode);
buffer.WriteByte((byte)target);
evnt.Serialize(buffer);
var sendData = buffer.ToArray();
_client.Reliable.Send(sendData);
}
internal void ReplicateEvent<TEvent>(TEvent evnt, RagonPlayer target, RagonReplicationMode replicationMode)
public void ReplicateEvent<TEvent>(TEvent evnt, RagonPlayer target, RagonReplicationMode replicationMode)
where TEvent : IRagonEvent, new()
{
var evntId = _client.Event.GetEventCode(evnt);
@@ -108,9 +108,9 @@ public class RagonScene
public void ReplicateData(byte[] data, bool reliable)
{
var sendData = new byte[data.Length + 1];
sendData[0] = (byte) RagonOperation.REPLICATE_RAW_DATA;
sendData[0] = (byte)RagonOperation.REPLICATE_RAW_DATA;
Array.Copy(data, 0, sendData, 1, data.Length);
if (reliable)
_client.Reliable.Send(sendData);
else