private static Monster ReadMonster(PacketDeserializer deserializer, int length = 0)
{
return(null);
/*
* var species = reader.Read<short>();
* var secretID = reader.Read<ushort>();
* var personalityValue = reader.Read<uint>();
* var nature = reader.Read<byte>();
*
* return new Monster(species, secretID, personalityValue, nature)
* {
* CatchInfo = reader.Read<CatchInfo>(),
* Experience = reader.Read<int>(),
* EggSteps = reader.Read<int>(),
* IV = reader.Read<Stats>(),
* EV = reader.Read<Stats>(),
* CurrentHP = reader.Read<short>(),
* StatusEffect = reader.Read<short>(),
* Affection = reader.Read<byte>(),
* Friendship = reader.Read<byte>(),
* Moves = reader.Read<Moves>(),
* HeldItem = reader.Read<short>(),
* };
*/
}
private static TileSetResponse ReadTileSetResponse(PacketDeserializer deserializer, int length = 0)
{
return(new TileSetResponse()
{
Name = deserializer.Read <string>(), TileSetData = deserializer.Read <string>()
});
}
protected NetworkerServerBase(ServerConfiguration configuration,
INetworkerLogger logger,
IList <INetworkerPacketHandlerModule> modules,
IContainerIoc container)
{
this.configuration = configuration;
this.Logger = logger;
this.container = container;
this.Connections = new List <TcpConnection>();
this.packetSerializer = new PacketSerializer();
this.packetDeserializer = new PacketDeserializer();
this.packetHandlers = new Dictionary <string, Type>();
this.packetHandlerSingletons = new Dictionary <string, IServerPacketHandler>();
foreach (var module in modules)
{
this.RegisterTypesFromModule(module);
}
this.container.RegisterSingleton <ITcpConnectionsProvider>(
new TcpConnectionsProvider(this.Connections));
this.container.RegisterSingleton(logger);
this.RegisterPacketHandler <PingRequestPacket, PingRequestPacketHandler>();
}
public void OnPreReceiveData(SocketClient socketClient, byte[] Buffer)
{
BasePacket basePacket = (BasePacket)PacketDeserializer.Deserialize(Buffer, PacketHeaderSize.HeaderSize);
if (basePacket.packetType == PacketType.ConnectionStat)
{
ConnectionPacket connectionpacket = (ConnectionPacket)basePacket;
if (socketServer.clientsManager.SocketClients.ContainsKey(connectionpacket.ClientId))
{
socketClient.SendPacket(new ConnectionPacket(false, 0, false, true));
socketClient.Dispose();
IGConsole.Instance.println("Same Client Already Connected");
}
else
{
socketServer.clientsManager.UpdatePreClient(connectionpacket.ClientId, connectionpacket.IsBot, socketClient);
if (connectionpacket.IsBot)
{
clientsManagerObj.clientsManager.AddClient(new HardwareClient(connectionpacket.ClientId, socketClient));
}
else
{
clientsManagerObj.clientsManager.AddClient(new ConsoleClient(connectionpacket.ClientId, socketClient, clientsManagerObj.clientsManager.Clients));
}
socketClient.SendPacket(new ConnectionPacket(true, 0, false));
IGConsole.Instance.println("Client Connected ID(" + connectionpacket.ClientId + ") ISBOT(" + connectionpacket.IsBot + ")");
}
}
else
{
IGConsole.Instance.println("Client Reset has Problem");
}
}
private static ImageResponse ReadImageResponse(PacketDeserializer deserializer, int length = 0)
{
return(new ImageResponse()
{
Name = deserializer.Read <string>(), ImageData = deserializer.Read <byte[]>()
});
}
private static FileHash ReadFileHash(PacketDeserializer deserializer, int length = 0)
{
return(new FileHash()
{
Name = deserializer.Read <string>(), Hash = deserializer.Read <string>()
});
}
private Task DispatchLoginPackets(UncompressedPacket packet)
{
var br = new SpanReader(packet.Data);
Task task;
switch (packet.PacketId)
{
// Login Start
case 0x00:
task = DispatchPacket(PacketDeserializer.Deserialize <LoginStart>(ref br));
break;
// Encryption Response
case 0x01:
task = DispatchPacket(PacketDeserializer.Deserialize <EncryptionResponse>(ref br));
break;
default:
throw new InvalidDataException($"Unrecognizable packet id: 0x{packet.PacketId:X2}.");
}
if (!br.IsCosumed)
{
throw new InvalidDataException($"Packet data is not fully consumed.");
}
return(task);
}
public PacketLogEntry(SerializationInfo info, StreamingContext context)
{
this.UnityTime = info.GetSingle("UnityTime");
this.In = info.GetBoolean("In");
this.Client = info.GetBoolean("Client");
byte[] packetData = info.GetValue("Packet", typeof(byte[])) as byte[];
this.Packet = PacketDeserializer.DeserializePacket(new PacketReader(packetData));
}
private void OnReceive(object sender, ReceiveData data)
{
var buffer = data.Packet.Payload;
OnDataReceived(new SocketDataReceived
{
Packet = PacketDeserializer.Deserialize(buffer, 0, buffer.Length),
Time = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds()
});
}
private static Stats ReadStats(PacketDeserializer deserializer, int length = 0)
{
return(new Stats(
deserializer.Read <short>(),
deserializer.Read <short>(),
deserializer.Read <short>(),
deserializer.Read <short>(),
deserializer.Read <short>(),
deserializer.Read <short>()));
}
private void OnMessage(object sender, MessageEventArgs message)
{
if (!message.IsText)
{
return;
}
OnDataReceived(new SocketDataReceived
{
Packet = PacketDeserializer.Deserialize(message.Data, Key, Type == GSLiveType.Command)
});
}
private async Task Receiving()
{
DebugUtil.LogNormal <GsTcpClient>(
Type == GSLiveType.TurnBased ? DebugLocation.TurnBased : DebugLocation.Command, "Receiving",
"GsTcpClient -> Start Receiving...");
while (IsConnected())
{
try
{
BufferReceivedBytes += await _clientStream.ReadAsync(Buffer, BufferOffset,
Buffer.Length - BufferOffset, OperationCancellationToken.Token);
if (!IsConnected())
{
break;
}
DataBuilder.Append(Encoding.UTF8.GetString(Buffer, BufferOffset, BufferReceivedBytes));
var packets = PacketValidator.ValidateDataAndReturn(DataBuilder);
foreach (var packet in packets)
{
OnDataReceived(new SocketDataReceived
{
Packet = PacketDeserializer.Deserialize(packet, Key, Type == GSLiveType.Command)
});
}
BufferReceivedBytes = 0;
}
catch (Exception e)
{
if (!(e is OperationCanceledException || e is ObjectDisposedException ||
e is ArgumentOutOfRangeException))
{
e.LogException <GsTcpClient>(
Type == GSLiveType.TurnBased ? DebugLocation.TurnBased : DebugLocation.Command,
"Receiving");
OnClosed(new ErrorArg {
Error = e.ToString()
});
}
break;
}
}
DebugUtil.LogNormal <GsTcpClient>(
Type == GSLiveType.TurnBased ? DebugLocation.TurnBased : DebugLocation.Command, "Receiving",
"GsTcpClient -> Receiving Done!");
}
protected byte GetByteVariable()
{
var index = _variableIndexes[_currentGetterIndex];
var value = PacketDeserializer.DeserializeByte(Data, index);
_currentGetterIndex++;
#if VOXCAKE_NET_DEBUG
HandleOutOfVariablesException();
#endif
return(value);
}
private static CatchInfo ReadCatchInfo(PacketDeserializer deserializer, int length = 0)
{
return(new CatchInfo
{
Method = deserializer.Read <string>(),
Location = deserializer.Read <string>(),
TrainerName = deserializer.Read <string>(),
TrainerID = deserializer.Read <ushort>(),
PokeballID = deserializer.Read <byte>(),
Nickname = deserializer.Read <string>()
});
}
public void AddSegment(byte[] segment, int offset)
{
segments.Write(segment, offset, segment.Length - offset);
AddCount++;
if (AddCount == SegmentCount)
{
BasePacket basePacket = (BasePacket)PacketDeserializer.Deserialize(segments);
OnDataInvoke?.Invoke(basePacket, SegmentID);
segments.Close();
segments.Dispose();
segments = null;
}
}
private Task DispatchHandshakingPackets(UncompressedPacket packet)
{
var br = new SpanReader(packet.Data);
switch (packet.PacketId)
{
// Handshake
case 0x00:
return(DispatchPacket(PacketDeserializer.Deserialize <Handshake>(ref br)));
default:
throw new InvalidDataException($"Unrecognizable packet id: 0x{packet.PacketId:X2}.");
}
}
private static TileSetResponse[] ReadTileSetResponseArray(PacketDeserializer deserializer, int length = 0)
{
if (length == 0)
{
length = deserializer.Read <VarInt>();
}
var array = new TileSetResponse[length];
for (var i = 0; i < length; i++)
{
array[i] = ReadTileSetResponse(deserializer);
}
return(array);
}
private static FileHash[] ReadFileHashArray(PacketDeserializer deserializer, int length = 0)
{
if (length == 0)
{
length = deserializer.Read <VarInt>();
}
var array = new FileHash[length];
for (var i = 0; i < length; i++)
{
array[i] = ReadFileHash(deserializer);
}
return(array);
}
protected NetworkerClientBase(ClientConfiguration clientConfiguration,
INetworkerLogger logger,
IList <INetworkerPacketHandlerModule> packetHandlerModules)
{
this.clientConfiguration = clientConfiguration;
this.logger = logger;
this.Container = new ServiceCollectionContainer(new ServiceCollection());
this.packetDeserializer = new PacketDeserializer();
this.Container.RegisterSingleton(logger);
this.packetHandlers = new Dictionary <string, Type>();
this.clientResponseStore = new ClientResponseStore();
foreach (var packetHandlerModule in packetHandlerModules)
{
this.RegisterTypesFromModule(packetHandlerModule);
}
}
private Task DispatchStatusPackets(UncompressedPacket packet)
{
var br = new SpanReader(packet.Data);
switch (packet.PacketId)
{
// Request
case 0x00:
return(DispatchPacket(PacketDeserializer.Deserialize <Request>(ref br)));
// Ping
case 0x01:
return(DispatchPacket(PacketDeserializer.Deserialize <Ping>(ref br)));
default:
throw new InvalidDataException($"Unrecognizable packet id: 0x{packet.PacketId:X2}.");
}
}
public void AddSegment(byte[] segment)
{
HeaderInfo headerInfo = PacketDeserializer.ParseHeader(segment);
if (headerInfo.CourrentSegmentID >= 1000)
{
if (segmentCollecters.Count > 0)
{
segmentCollecters.Clear();
}
if (LastCollecter == null)
{
LastCollecter = new SegmentCollecter(headerInfo.SegmentCount, headerInfo.CourrentSegmentID);
LastCollecter.OnDataInvoke += PacketReciver_OnDataInvoke;
}
LastCollecter.AddSegment(segment, PacketHeaderSize.HeaderSize);
return;
}
if (headerInfo.CourrentSegmentID == 1)
{
LastCollecter = null;
}
if (segmentCollecters.ContainsKey(headerInfo.CourrentSegmentID))
{
segmentCollecters[headerInfo.CourrentSegmentID].AddSegment(segment, PacketHeaderSize.HeaderSize);
}
else
{
SegmentCollecter segmentCollecter = new SegmentCollecter(headerInfo.SegmentCount, headerInfo.CourrentSegmentID);
segmentCollecter.OnDataInvoke += PacketReciver_OnDataInvoke;
segmentCollecter.AddSegment(segment, PacketHeaderSize.HeaderSize);
segmentCollecters.Add(headerInfo.CourrentSegmentID, segmentCollecter);
}
}
public int ReadStream()
{
if (TcpClient.Connected)
{
if (0 < TcpClient.Available)
{
ReadNetworkStreamToReadBuffer(0, PacketHeaderSize.HeaderSize);
HeaderInfo headerInfo = PacketDeserializer.ParseHeader(ReadBuffer);
ReadNetworkStreamToReadBuffer(PacketHeaderSize.HeaderSize, headerInfo.SegmentLength);
return(PacketHeaderSize.HeaderSize + headerInfo.SegmentLength);
}
else
{
return(-2);
}
}
else
{
Dispose();
return(-1);
}
}
private void InitSocket()
{
while (!StopTask)
{
if (tcpClient.Connected)
{
if (0 < tcpClient.Available)
{
ReadNetworkStreamToReadBuffer(0, PacketHeaderSize.HeaderSize);
HeaderInfo headerInfo = PacketDeserializer.ParseHeader(ReadBuffer);
ReadNetworkStreamToReadBuffer(PacketHeaderSize.HeaderSize, headerInfo.SegmentLength);
OnReceiveData(ReadBuffer, PacketHeaderSize.HeaderSize + headerInfo.SegmentLength);
}
}
else
{
StopTask = true;
}
}
tcpClient.Close();
networkStream.Close();
networkStream.Dispose();
}
public InputPacketBinding(byte id, Type packet, PacketDeserializer deserializer) : base(id, packet)
{
Deserializer = deserializer;
}
public void Connect(IPEndPoint endPoint)
{
DisconnectReason = null;
NetPeerConfiguration config = new NetPeerConfiguration("MulTUNG");
Client = new NetClient(config);
Client.Start();
var approval = Client.CreateMessage();
approval.Write(MulTUNG.Version.ToString());
approval.Write(Username);
var conn = Client.Connect(endPoint, approval);
ThreadPool.QueueUserWorkItem(o =>
{
var c = o as NetConnection;
int elapsed = 0;
while (true)
{
Thread.Sleep(50);
elapsed += 50;
if ((c.Status != NetConnectionStatus.Connected && elapsed >= Constants.WaitForConnection) || DisconnectReason != null)
{
Network.IsClient = false;
string status = MulTUNG.Status = "Couldn't connect to remote server." + (DisconnectReason != null ? " Check the console for more details." : "");
IGConsole.Error("Couldn't connect to remote server: " + DisconnectReason);
Thread.Sleep(3000);
MulTUNG.ShowMainMenuCanvases();
MulTUNG.ShowStatusWindow = false;
MulTUNG.Status = "";
break;
}
else if (c.Status == NetConnectionStatus.Connected)
{
Network.IsClient = true;
MulTUNG.SynchronizationContext.Send(_ =>
{
SaveManager.SaveName = MulTUNG.ForbiddenSaveName;
World.DeleteSave();
SceneManager.LoadScene("gameplay");
EverythingHider.HideEverything();
}, null);
while (ModUtilities.IsOnMainMenu)
{
Thread.Sleep(500);
}
Thread.Sleep(1000);
IsInGameplay = true;
EnterEvent.Set();
InitWorld();
break;
}
}
}, conn);
ThreadPool.QueueUserWorkItem(_ =>
{
NetIncomingMessage msg;
while (Client.Status == NetPeerStatus.Running)
{
msg = Client.WaitMessage(int.MaxValue);
if (msg == null)
{
continue;
}
switch (msg.MessageType)
{
case NetIncomingMessageType.Data:
var packet = PacketDeserializer.DeserializePacket(new MessagePacketReader(msg));
if (Network.ProcessPacket(packet, this.PlayerID))
{
PacketLog.LogReceive(packet);
}
break;
case NetIncomingMessageType.StatusChanged:
var status = (NetConnectionStatus)msg.ReadByte();
Log.WriteLine("Status: " + status);
if (status == NetConnectionStatus.Disconnected)
{
string reason = msg.ReadString();
if (!string.IsNullOrEmpty(reason))
{
DisconnectReason = reason;
}
Disconnect();
}
LastStatus = Client.ConnectionStatus;
break;
}
Client.Recycle(msg);
}
});
}
private static Attack ReadAttack(PacketDeserializer deserializer, int length = 0)
{
return(new Attack(deserializer.Read <short>(), deserializer.Read <byte>(), deserializer.Read <byte>()));
}
private void HandleMessage(NetIncomingMessage msg)
{
switch (msg.MessageType)
{
case NetIncomingMessageType.ConnectionApproval:
string verStr = msg.ReadString();
Version ver = new Version(verStr);
if (ver == MulTUNG.MulTUNG.Version)
{
msg.SenderConnection.Approve();
string username = msg.ReadString().Trim();
if (!Players.Any(o => o.Value.Username.Equals(username)))
{
IGConsole.Log($"{username.Length} {MaxUsernameLength}");
if (username.Length < MaxUsernameLength)
{
msg.SenderConnection.Approve();
}
else
{
msg.SenderConnection.Deny($"your username must be shorter than {MaxUsernameLength} characters.");
}
}
else
{
msg.SenderConnection.Deny("someone is already using that username.");
}
}
else
{
msg.SenderConnection.Deny($"wrong MulTUNG version, server has v{MulTUNG.MulTUNG.Version}.");
}
break;
case NetIncomingMessageType.Data:
var packet = PacketDeserializer.DeserializePacket(new MessagePacketReader(msg));
if (packet.SenderID == Network.ServerPlayerID)
{
break;
}
PacketLog.LogReceive(packet);
if (packet.ShouldBroadcast)
{
Broadcast(packet, packet.ReliableBroadcast ? NetDeliveryMethod.ReliableOrdered : NetDeliveryMethod.UnreliableSequenced);
}
else
{
Network.ProcessPacket(packet, Network.ServerPlayerID);
}
break;
case NetIncomingMessageType.StatusChanged:
var status = (NetConnectionStatus)msg.ReadByte();
if (status == NetConnectionStatus.Connected)
{
int id = PlayerIdCounter++;
msg.SenderConnection.SendMessage(new PlayerWelcomePacket
{
YourID = id,
ServerUsername = Network.Username,
Players = Players.Select(o => new Tuple <int, string>(o.Key, o.Value.Username)).ToList()
}.GetMessage(Server), NetDeliveryMethod.ReliableOrdered, 0);
var player = new Player(id, msg.SenderConnection);
Log.WriteLine("Connected player " + player.ID);
Players.Add(id, player);
}
else if (status == NetConnectionStatus.Disconnected)
{
var player = Players.SingleOrDefault(o => o.Value.Connection == msg.SenderConnection);
Players.Remove(player.Key);
PlayerManager.WaveGoodbye(player.Key);
}
break;
}
}
private static MonsterTeam ReadMonsterTeam(PacketDeserializer deserializer, int length = 0)
{
return(default);
private static Vector3 ReadVector3(PacketDeserializer deserializer, int length = 0) => new Vector3(deserializer.Read <float>(), deserializer.Read <float>(), deserializer.Read <float>());
private Task DispatchPacket(UncompressedPacket packet)
{
var br = new SpanReader(packet.Data);
Task task;
switch (packet.PacketId)
{
// Teleport Confirm
case 0x00:
task = DispatchPacket(PacketDeserializer.Deserialize <TeleportConfirm>(ref br));
break;
// Chat Message
case 0x03:
task = DispatchPacket(PacketDeserializer.Deserialize <ServerboundChatMessage>(ref br));
break;
// Client Settings
case 0x05:
task = DispatchPacket(PacketDeserializer.Deserialize <ClientSettings>(ref br));
break;
// Plugin Message
case 0x0B:
task = DispatchPacket(PacketDeserializer.Deserialize <ServerboundPluginMessage>(ref br));
break;
// Keep Alive
case 0x0F:
task = DispatchPacket(PacketDeserializer.Deserialize <ServerboundKeepAlive>(ref br));
break;
// Player On Ground
case 0x0D:
task = DispatchPacket(PacketDeserializer.Deserialize <PlayerOnGround>(ref br));
break;
// Player Position
case 0x11:
task = DispatchPacket(PacketDeserializer.Deserialize <PlayerPosition>(ref br));
break;
// Position And Look (In new wiki, it is Player Position And Rotation)
case 0x12:
task = DispatchPacket(PacketDeserializer.Deserialize <ServerboundPositionAndLook>(ref br));
break;
// Player Look (In new wiki, it is Player Rotation)
case 0x13:
task = DispatchPacket(PacketDeserializer.Deserialize <PlayerLook>(ref br));
break;
// Player Digging
case 0x1A:
task = DispatchPacket(PacketDeserializer.Deserialize <PlayerDigging>(ref br));
break;
// Entity Action
case 0x1B:
task = DispatchPacket(PacketDeserializer.Deserialize <EntityAction>(ref br));
break;
// Held Item Change
case 0x23:
task = DispatchPacket(PacketDeserializer.Deserialize <ServerboundHeldItemChange>(ref br));
break;
// Animation
case 0x2A:
task = DispatchPacket(PacketDeserializer.Deserialize <ServerboundAnimation>(ref br));
break;
// Player Block Placement
case 0x2C:
task = DispatchPacket(PacketDeserializer.Deserialize <PlayerBlockPlacement>(ref br));
break;
// Use Item
case 0x2D:
task = DispatchPacket(PacketDeserializer.Deserialize <UseItem>(ref br));
break;
// Click Window
case 0x09:
task = DispatchPacket(PacketDeserializer.Deserialize <ClickWindow>(ref br));
break;
// Close Window
case 0x0A:
task = DispatchPacket(PacketDeserializer.Deserialize <ServerboundCloseWindow>(ref br));
break;
default:
Logger.LogWarning($"Unrecognizable packet id: 0x{packet.PacketId:X2}.");
return(Task.CompletedTask);
}
// Logger.LogInformation($"Got packet id: 0x{packet.PacketId:X2}.");
if (!br.IsCosumed)
{
throw new InvalidDataException($"Packet data is not fully consumed, packet id: 0x{packet.PacketId:X2}.");
}
return(task);
}
