public void Test_Confirm_Exchange()
{
_exchangeService.OpenExchange(1, 2);
_exchangeService.ConfirmExchange(1);
_exchangeService.ConfirmExchange(2);
var data1 = _exchangeService.GetData(1);
var data2 = _exchangeService.GetData(2);
Assert.IsTrue(data1.ExchangeConfirmed && data2.ExchangeConfirmed);
}
public void RequestExchange(ExchangeRequestPacket packet)
{
var target = Broadcaster.Instance.GetCharacter(s => s.VisualId == packet.VisualId && s.MapInstanceId == Session.Character.MapInstanceId) as Character;
ExcClosePacket closeExchange;
if (target != null && (packet.RequestType == RequestExchangeType.Confirmed || packet.RequestType == RequestExchangeType.Cancelled))
{
_logger.Error(LogLanguage.Instance.GetMessageFromKey(LogLanguageKey.CANT_FIND_CHARACTER));
return;
}
if (Session.Character.InShop || (target?.InShop ?? false))
{
_logger.Error(LogLanguage.Instance.GetMessageFromKey(LogLanguageKey.PLAYER_IN_SHOP));
return;
}
switch (packet.RequestType)
{
case RequestExchangeType.Requested:
if (_exchangeService.CheckExchange(Session.Character.CharacterId) || _exchangeService.CheckExchange(target.VisualId))
{
Session.SendPacket(new MsgPacket
{
Message = Language.Instance.GetMessageFromKey(LanguageKey.ALREADY_EXCHANGE,
Session.Account.Language),
Type = MessageType.White
});
return;
}
if (target.ExchangeBlocked)
{
Session.SendPacket(Session.Character.GenerateSay(
Language.Instance.GetMessageFromKey(LanguageKey.EXCHANGE_BLOCKED, Session.Account.Language),
SayColorType.Purple));
return;
}
if (Session.Character.IsRelatedToCharacter(target.VisualId, CharacterRelationType.Blocked))
{
Session.SendPacket(new InfoPacket
{
Message = Language.Instance.GetMessageFromKey(LanguageKey.BLACKLIST_BLOCKED,
Session.Account.Language)
});
return;
}
if (Session.Character.InShop || target.InShop)
{
Session.SendPacket(new MsgPacket
{
Message =
Language.Instance.GetMessageFromKey(LanguageKey.HAS_SHOP_OPENED, Session.Account.Language),
Type = MessageType.White
});
return;
}
Session.SendPacket(new ModalPacket
{
Message = Language.Instance.GetMessageFromKey(LanguageKey.YOU_ASK_FOR_EXCHANGE,
Session.Account.Language),
Type = 0
});
target.SendPacket(new DlgPacket
{
YesPacket = new ExchangeRequestPacket
{
RequestType = RequestExchangeType.List, VisualId = Session.Character.VisualId
},
NoPacket = new ExchangeRequestPacket
{
RequestType = RequestExchangeType.Declined, VisualId = Session.Character.VisualId
},
Question = Language.Instance.GetMessageFromKey(LanguageKey.INCOMING_EXCHANGE, Session.Account.Language)
});
return;
case RequestExchangeType.List:
if (!_exchangeService.OpenExchange(Session.Character.VisualId, target.CharacterId))
{
return;
}
Session.SendPacket(Session.Character.GenerateServerExcListPacket(null, null, null));
target.SendPacket(target.GenerateServerExcListPacket(null, null, null));
return;
case RequestExchangeType.Declined:
Session.SendPacket(Session.Character.GenerateSay(Language.Instance.GetMessageFromKey(LanguageKey.EXCHANGE_REFUSED, Session.Account.Language), SayColorType.Yellow));
target?.SendPacket(target.GenerateSay(target.GetMessageFromKey(LanguageKey.EXCHANGE_REFUSED), SayColorType.Yellow));
return;
case RequestExchangeType.Confirmed:
var targetId = _exchangeService.GetTargetId(Session.Character.CharacterId);
if (!targetId.HasValue)
{
_logger.Error(LogLanguage.Instance.GetMessageFromKey(LogLanguageKey.INVALID_EXCHANGE));
return;
}
var exchangeTarget = Broadcaster.Instance.GetCharacter(s => s.VisualId == targetId.Value && s.MapInstance == Session.Character.MapInstance);
if (exchangeTarget == null)
{
_logger.Error(LogLanguage.Instance.GetMessageFromKey(LogLanguageKey.CANT_FIND_CHARACTER));
return;
}
_exchangeService.ConfirmExchange(Session.Character.VisualId);
if (!_exchangeService.IsExchangeConfirmed(Session.Character.VisualId) || !_exchangeService.IsExchangeConfirmed(exchangeTarget.VisualId))
{
Session.SendPacket(new InfoPacket {
Message = Language.Instance.GetMessageFromKey(LanguageKey.IN_WAITING_FOR, Session.Account.Language)
});
return;
}
var success = _exchangeService.ValidateExchange(Session, exchangeTarget);
if (success.Item1 == ExchangeResultType.Success)
{
foreach (var infoPacket in success.Item2)
{
if (infoPacket.Key == Session.Character.CharacterId)
{
Session.SendPacket(infoPacket.Value);
}
else if (infoPacket.Key == exchangeTarget.VisualId)
{
exchangeTarget.SendPacket(infoPacket.Value);
}
}
}
else
{
var itemList = _exchangeService.ProcessExchange(Session.Character.VisualId, exchangeTarget.VisualId, Session.Character.Inventory, exchangeTarget.Inventory);
foreach (var item in itemList)
{
if (item.Key == Session.Character.CharacterId)
{
Session.SendPacket(item.Value);
}
else
{
exchangeTarget.SendPacket(item.Value);
}
}
var getSessionData = _exchangeService.GetData(Session.Character.CharacterId);
Session.Character.RemoveGold(getSessionData.Gold);
Session.Character.RemoveBankGold(getSessionData.BankGold * 1000);
exchangeTarget.AddGold(getSessionData.Gold);
exchangeTarget.AddBankGold(getSessionData.BankGold * 1000);
var getTargetData = _exchangeService.GetData(exchangeTarget.VisualId);
exchangeTarget.RemoveGold(getTargetData.Gold);
exchangeTarget.RemoveBankGold(getTargetData.BankGold * 1000);
Session.Character.AddGold(getTargetData.Gold);
Session.Character.AddBankGold(getTargetData.BankGold * 1000);
}
closeExchange = _exchangeService.CloseExchange(Session.Character.VisualId, success.Item1);
exchangeTarget?.SendPacket(closeExchange);
Session.SendPacket(closeExchange);
return;
case RequestExchangeType.Cancelled:
var cancelId = _exchangeService.GetTargetId(Session.Character.CharacterId);
if (!cancelId.HasValue)
{
_logger.Error(LogLanguage.Instance.GetMessageFromKey(LogLanguageKey.USER_NOT_IN_EXCHANGE));
return;
}
var cancelTarget = Broadcaster.Instance.GetCharacter(s => s.VisualId == cancelId.Value);
closeExchange = _exchangeService.CloseExchange(Session.Character.VisualId, ExchangeResultType.Failure);
cancelTarget?.SendPacket(closeExchange);
Session.SendPacket(closeExchange);
return;
default:
throw new ArgumentOutOfRangeException();
}
}