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;
}
}
//-------------------------------------------------------------------------
async void c2sPlayerTradeRequest(PlayerTradeRequest player_trade_request)
{
IRpcSession s = EntityMgr.LastRpcSession;
ClientInfo client_info = CoApp.getClientInfo(s);
if (client_info == null)
{
return;
}
var task = await Task.Factory.StartNew <Task <MethodData> >(async() =>
{
MethodData method_data = new MethodData();
method_data.method_id = MethodType.c2sPlayerTradeRequest;
method_data.param1 = EbTool.protobufSerialize <PlayerTradeRequest>(player_trade_request);
MethodData r = null;
try
{
var grain_playerproxy = GrainClient.GrainFactory.GetGrain <ICellPlayer>(new Guid(client_info.et_player_guid));
r = await grain_playerproxy.c2sRequest(method_data);
}
catch (Exception ex)
{
EbLog.Error(ex.ToString());
}
return(r);
});
if (task.Status == TaskStatus.Faulted || task.Result == null)
{
if (task.Exception != null)
{
EbLog.Error(task.Exception.ToString());
}
return;
}
MethodData result = task.Result;
if (result.method_id == MethodType.None)
{
return;
}
lock (CoApp.RpcLock)
{
var player_trade_response = EbTool.protobufDeserialize <PlayerTradeResponse>(result.param1);
CoApp.rpcBySession(s, (ushort)MethodType.s2cPlayerTradeResponse, player_trade_response);
}
}
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();
}
}
}
}
}
}
}
