public void TestChatClient(ClientEntity sender, byte channel, string content, uint instance_id)
{
if (sender is null)
{
throw new ArgumentNullException(nameof(sender));
}
if (channel < 0)
{
throw new ArgumentOutOfRangeException(nameof(channel));
}
if (content is null)
{
throw new ArgumentNullException(nameof(content));
}
if (instance_id < 0)
{
throw new ArgumentOutOfRangeException(nameof(instance_id));
}
NetworkElement element = BotofuProtocolManager.Protocol[ProtocolKeyEnum.Messages, x => x.name == "ChatClientMultiMessage"];
NetworkContentElement element_content = new NetworkContentElement()
{
fields =
{
{ "channel", channel },
{ "content", content }
}
};
Send(true, sender, element, element_content, instance_id);
}
private void _parse_super(BigEndianReader reader)
{
if (_network_base.super_serialize)
{
_network_content += new MessageDataBufferReader(_super).Parse(reader);
}
}
public static NetworkContentElement BaseHardcoreInformation(this PlayerData player, int protocolId)
{
NetworkContentElement base_information = player.BaseInformation(protocolId);
base_information["deathState"] = 0; // byte -> PlayerLifeStatusEnum
base_information["deathCount"] = 0; // short
base_information["deathMaxLevel"] = 1; // short
return(base_information);
}
public override void Handle()
{
DofusServerWorldClientReceiveCallback _world_callback = _casted_callback <DofusServerWorldClientReceiveCallback>();
if (DofusServer._server_api.GetData(x => x.Port == _world_callback._server.Port) is ServerData server_data &&
DofusServer._server_api.GetData <PlayerData>(x => x.AccountToken == _world_callback._client.CurrentToken && x.ServerId == server_data.ServerId) is IEnumerable <PlayerData> players)
{
NetworkContentElement characters_list_content = _characters_list_content(players, server_data);
Send(false, _callback._client, _characters_list_message, characters_list_content);
}
}
// if no error
public override void EndHandle()
{
Send(false, _callback._client, _character_creation_result, _character_creation_result_content("OK"));
DofusServerWorldClientReceiveCallback _world_callback = _casted_callback <DofusServerWorldClientReceiveCallback>();
if (DofusServer._server_api.GetData(x => x.Port == _world_callback._server.Port) is ServerData server_data &&
DofusServer._server_api.GetData <PlayerData>(x => x.AccountToken == _world_callback._client.CurrentToken && x.ServerId == server_data.ServerId) is IEnumerable <PlayerData> players)
{
NetworkContentElement characters_list = CharactersListRequestMessageHandler._characters_list_content(players, server_data);
Send(false, _callback._client, CharactersListRequestMessageHandler._characters_list_message, characters_list);
// connect client
}
}
public byte[] Parse(NetworkContentElement content)
{
_network_content = content ?? throw new ArgumentNullException(nameof(content));
using (BigEndianWriter writer = new BigEndianWriter())
{
_parse_super(writer);
_parse_bool(writer);
_parse_var(writer);
return(writer.Data);
}
}
public virtual void Send(bool fromClient, ClientEntity sender, NetworkElement element, NetworkContentElement content, uint?instance_id = null)
{
if (fromClient && instance_id is null)
{
throw new ArgumentNullException(nameof(instance_id));
}
byte[] _data = new MessageDataBufferWriter(element).Parse(content);
byte[] _final_data = new MessageBufferWriter(fromClient).Build((ushort)(element.protocolID == 6253 ? 8892 /*rdm*/ : element.protocolID), instance_id, _data).Data;
_callback._client_sender.Handle(sender, _final_data);
logger.Info($"fake message sent : {element.BasicString} {(instance_id.HasValue ? instance_id.Value : 0)}");
}
public CharacterCreationRequestMessageHandler(AbstractClientReceiveCallback callback, NetworkElement element, NetworkContentElement content)
: base(callback, element, content)
{
}
public IdentificationSuccessMessageHandler(AbstractClientReceiveCallback callback, NetworkElement element, NetworkContentElement content)
: base(callback, element, content)
{
}
public AuthenticationTicketMessageHandler(AbstractClientReceiveCallback callback,
NetworkElement element,
NetworkContentElement content)
: base(callback, element, content)
{
}
public ProtocolRequiredHandler(AbstractClientReceiveCallback callback, NetworkElement element, NetworkContentElement content)
: base(callback, element, content)
{
}
public ExchangeStartedWithStorageMessageHandler(AbstractClientReceiveCallback callback, NetworkElement element, NetworkContentElement content)
: base(callback, element, content)
{
}
public MapComplementaryInformationsDataMessageHandler(AbstractClientReceiveCallback callback,
NetworkElement element,
NetworkContentElement content)
: base(callback, element, content)
{
}
public ReloginTokenRequestMessageHandler(AbstractClientReceiveCallback callback,
NetworkElement element,
NetworkContentElement content)
: base(callback, element, content)
{
}
public MessageDataBufferReader(NetworkElement network)
{
_network_content = new NetworkContentElement();
_network_base = network ?? throw new ArgumentNullException(nameof(network));
}
public async Task <bool> Handle(AbstractClientReceiveCallback callback, NetworkElement element, NetworkContentElement content)
{
IEnumerable <Type> _handlers = _handlers_type.Where(x => x.GetCustomAttribute <Attribute>().BaseMessage.protocolID == element.protocolID);
bool _all_true = true;
foreach (Type _handler in _handlers)
{
_all_true = _all_true && await _handle(_handler, callback, element, content);
}
return(_all_true);
}
public ServersListMessageHandler(AbstractClientReceiveCallback callback,
NetworkElement element,
NetworkContentElement content)
: base(callback, element, content)
{
}
private async Task <bool> _handle(Type handler_type, AbstractClientReceiveCallback callback, NetworkElement element, NetworkContentElement content)
{
if (!GetHandler(element.protocolID))
{
return(true);
}
if (handler_type is null)
{
return(true);
}
AbstractMessageHandler handler = Activator.CreateInstance(handler_type, new object[] { callback, element, content }) as AbstractMessageHandler;
await AsyncExtension.ExecuteAsync(handler.Handle, handler.EndHandle, handler.Error);
return(handler.IsForwardingData);
}
public override void Handle()
{
DofusServerWorldClientReceiveCallback _world_callback = _casted_callback <DofusServerWorldClientReceiveCallback>();
string token = _content["ticket"];
if (DofusServer._server_api.GetData <ServerAccountInformationData>(x => x.Token == token).FirstOrDefault() is ServerAccountInformationData _account)
{
ClientEntity connected = _world_callback._client_repository.GetResult(x => x.CurrentToken == token && x.IsRunning && x != _world_callback._client);
if (connected != null)
{
_world_callback._client_disconnector.Handle(connected);
}
_world_callback._client.CurrentToken = token;
NetworkElement authentication_accepted_message = BotofuProtocolManager.Protocol[ProtocolKeyEnum.Messages, x => x.name == "AuthenticationTicketAcceptedMessage"];
NetworkElement account_capabilities_message = BotofuProtocolManager.Protocol[ProtocolKeyEnum.Messages, x => x.name == "AccountCapabilitiesMessage"];
NetworkContentElement account_capabilities_content = new NetworkContentElement()
{
fields =
{
{ "tutorialAvailable", true },
{ "canCreateNewCharacter", true },
{ "accountId", _account.Id },
{ "breedsVisible", 262143 },
{ "breedsAvailable", 262143 },
{ "status", 0 }
}
};
Send(false, _callback._client, authentication_accepted_message, new NetworkContentElement());
Send(false, _callback._client, account_capabilities_message, account_capabilities_content);
}
else
{
// create account
byte[] ticket_bytes = Convert.FromBase64String(token);
// to do
byte[] id = new byte[]
{
ticket_bytes[1],
ticket_bytes[3],
ticket_bytes[7],
ticket_bytes[15],
};
ServerAccountInformationData new_account = new ServerAccountInformationData()
{
Id = Math.Abs(BitConverter.ToInt32(id, 0)),
Token = token,
CreationDateTime = DateTime.Now,
LastConnectionDateTime = DateTime.Now,
TotalTimeSpentInGame = TimeSpan.FromMilliseconds(0),
FriendsToken = new List <string>(),
IgnoredsToken = new List <string>()
};
DofusServer._server_api.UpdateData(new_account);
Handle();
}
}
public AbstractMessageHandler(AbstractClientReceiveCallback callback, NetworkElement element, NetworkContentElement content)
{
_callback = callback ?? throw new ArgumentNullException(nameof(callback));
_element = element ?? throw new ArgumentNullException(nameof(element));
_content = content ?? throw new ArgumentNullException(nameof(content));
}
