public static void HandleExchangePlayerRequestMessage(WorldClient client, ExchangePlayerRequestMessage message)
{
switch ((ExchangeTypeEnum)message.exchangeType)
{
case ExchangeTypeEnum.PLAYER_TRADE:
var target = World.Instance.GetCharacter((int)message.target);
if (target == null)
{
SendExchangeErrorMessage(client, ExchangeErrorEnum.BID_SEARCH_ERROR);
return;
}
if (target.Map.Id != client.Character.Map.Id)
{
SendExchangeErrorMessage(client, ExchangeErrorEnum.REQUEST_CHARACTER_TOOL_TOO_FAR);
return;
}
if (target.IsBusy() || target.IsTrading())
{
SendExchangeErrorMessage(client, ExchangeErrorEnum.REQUEST_CHARACTER_OCCUPIED);
return;
}
if (target.FriendsBook.IsIgnored(client.Account.Id))
{
SendExchangeErrorMessage(client, ExchangeErrorEnum.REQUEST_CHARACTER_RESTRICTED);
return;
}
if (!target.IsAvailable(client.Character, false))
{
SendExchangeErrorMessage(client, ExchangeErrorEnum.REQUEST_CHARACTER_OCCUPIED);
return;
}
if (!client.Character.Map.AllowExchangesBetweenPlayers)
{
SendExchangeErrorMessage(client, ExchangeErrorEnum.REQUEST_IMPOSSIBLE);
return;
}
var request = new PlayerTradeRequest(client.Character, target);
client.Character.OpenRequestBox(request);
target.OpenRequestBox(request);
request.Open();
break;
default:
SendExchangeErrorMessage(client, ExchangeErrorEnum.REQUEST_IMPOSSIBLE);
break;
}
}
public static void HandleExchangePlayerRequestMessage(WorldClient client, ExchangePlayerRequestMessage message)
{
ExchangeTypeEnum exchangeType = (ExchangeTypeEnum)message.exchangeType;
if (exchangeType != ExchangeTypeEnum.PLAYER_TRADE)
{
InventoryHandler.SendExchangeErrorMessage(client, ExchangeErrorEnum.REQUEST_IMPOSSIBLE);
}
else
{
Character character = Singleton <World> .Instance.GetCharacter((int)message.target);
if (character == null)
{
InventoryHandler.SendExchangeErrorMessage(client, ExchangeErrorEnum.BID_SEARCH_ERROR);
}
else
{
if (character.Map.Id != client.Character.Map.Id)
{
InventoryHandler.SendExchangeErrorMessage(client, ExchangeErrorEnum.REQUEST_CHARACTER_TOOL_TOO_FAR);
}
else
{
if (character.IsInRequest() || character.IsTrading())
{
InventoryHandler.SendExchangeErrorMessage(client, ExchangeErrorEnum.REQUEST_CHARACTER_OCCUPIED);
}
else
{
if (character.IsAway)
{
InventoryHandler.SendExchangeErrorMessage(client, ExchangeErrorEnum.REQUEST_CHARACTER_OCCUPIED);
}
else
{
if (!client.Character.Map.AllowExchangesBetweenPlayers)
{
InventoryHandler.SendExchangeErrorMessage(client, ExchangeErrorEnum.REQUEST_IMPOSSIBLE);
}
else
{
PlayerTradeRequest playerTradeRequest = new PlayerTradeRequest(client.Character, character);
client.Character.OpenRequestBox(playerTradeRequest);
character.OpenRequestBox(playerTradeRequest);
playerTradeRequest.Open();
}
}
}
}
}
}
}
public static void HandleExchangePlayer(ExchangePlayerRequestMessage message, WorldClient client)
{
WorldClient target = WorldServer.Instance.GetOnlineClient((int)message.target);
if (target.Character.Busy)
{
client.Character.Reply("Impossible car le joueur est occupé.");
return;
}
target.Character.PlayerTradeInstance = new PlayerTradeExchange(target, client);
client.Character.PlayerTradeInstance = new PlayerTradeExchange(client, target);
client.Character.PlayerTradeInstance.Ask();
}
public static void HandleExchangePlayerRequest(ExchangePlayerRequestMessage message, WorldClient client)
{
Character target = client.Character.Map.Instance.GetEntity <Character>((long)message.target);
if (target == null)
{
client.Character.OnExchangeError(ExchangeErrorEnum.REQUEST_IMPOSSIBLE);
return;
}
if (target.Busy)
{
client.Character.OnExchangeError(ExchangeErrorEnum.REQUEST_CHARACTER_OCCUPIED);
return;
}
if (target.Map == null || target.Record.MapId != client.Character.Record.MapId)
{
client.Character.OnExchangeError(ExchangeErrorEnum.REQUEST_IMPOSSIBLE);
return;
}
if (!target.Map.Position.AllowExchangesBetweenPlayers)
{
client.Character.OnExchangeError(ExchangeErrorEnum.REQUEST_IMPOSSIBLE);
return;
}
switch ((ExchangeTypeEnum)message.exchangeType)
{
case ExchangeTypeEnum.PLAYER_TRADE:
target.OpenRequestBox(new PlayerTradeRequest(client.Character, target));
break;
default:
client.Send(new ExchangeErrorMessage((sbyte)ExchangeErrorEnum.REQUEST_IMPOSSIBLE));
break;
}
}
