private async Task OnUserGatherItemRequest(IPacket packet)
{
packet.Decode <int>();
var inventoryType = (ItemInventoryType)packet.Decode <byte>();
var inventoryCopy = Character.GetInventory(inventoryType).Items
.Where(i => i.Position > 0)
.OrderBy(i => i.Position)
.ToList();
short pos = 1;
await ModifyInventory(i =>
{
inventoryCopy.ForEach(s => i.Remove(s));
inventoryCopy.ForEach(item => item.Position = pos++);
inventoryCopy.ForEach(i.Set);
}, true);
using (var p = new Packet(SendPacketOperations.GatherItemResult))
{
p.Encode <bool>(false);
p.Encode <byte>((byte)inventoryType);
await SendPacket(p);
}
}
public override Task OnPacket(IPacket packet)
{
var operation = (RecvPacketOperations)packet.Decode <short>();
switch (operation)
{
case RecvPacketOperations.CheckPassword:
return(OnCheckPassword(packet));
case RecvPacketOperations.WorldInfoRequest:
case RecvPacketOperations.WorldRequest:
return(OnWorldInfoRequest(packet));
case RecvPacketOperations.SelectWorld:
return(OnSelectWorld(packet));
case RecvPacketOperations.CheckUserLimit:
return(OnCheckUserLimit(packet));
case RecvPacketOperations.SetGender:
return(OnSetGender(packet));
case RecvPacketOperations.CheckPinCode:
return(OnCheckPinCode(packet));
case RecvPacketOperations.CheckDuplicatedID:
return(OnCheckDuplicatedID(packet));
case RecvPacketOperations.CreateNewCharacter:
return(OnCreateNewCharacter(packet));
case RecvPacketOperations.EnableSPWRequest:
return(OnEnableSPWRequest(packet, false));
case RecvPacketOperations.CheckSPWRequest:
return(OnCheckSPWRequest(packet, false));
case RecvPacketOperations.EnableSPWRequestByACV:
return(OnEnableSPWRequest(packet, true));
case RecvPacketOperations.CheckSPWRequestByACV:
return(OnCheckSPWRequest(packet, true));
default:
Logger.Warn($"Unhandled packet operation {operation}");
return(Task.CompletedTask);
}
}
private async Task OnUserSelectNPC(IPacket packet)
{
var npc = Field.GetObject <FieldNPC>(packet.Decode <int>());
if (npc == null)
{
return;
}
var template = npc.Template;
if (template.Trunk)
{
await Interact(new TrunkDialog(
template.ID,
Character.Data.Trunk,
template.TrunkGet,
template.TrunkPut
));
return;
}
var shop = Socket.WvsGame.TemplateManager.Get <NPCShopTemplate>(template.ID);
var script = template.Scripts.FirstOrDefault()?.Script;
if (shop != null)
{
await Interact(new ShopDialog(shop));
return;
}
if (script == null)
{
return;
}
var context = new ConversationContext(Socket);
var conversation = Socket.WvsGame.ConversationManager.Get(
script,
context,
new FieldNPCSpeaker(context, npc),
new FieldUserSpeaker(context, this)
);
await Converse(conversation);
}
public static IPacket PacketAnalyzer(Byte[] packetByte)
{
Int32 offset = 0;
Int64 packetType = PacketUtil.DecodePacketType(packetByte, ref offset);
IPacket packet = PacketFactory.GetPacket(packetType);
if (packet == null)
{
return(null);
}
if (offset < packetByte.Length)
{
packet.Decode(packetByte, ref offset);
}
return(packet);
}
private void OnEncapsulatedPacket(EncapsulatedPacket encapsulatedPacket)
{
byte[] buf = encapsulatedPacket.Payload;
IPacket packet = _client.GetPacketFactory().GetPacket(buf[0]);
packet.Decode(buf);
switch (packet)
{
case ConnectionEstablishmentPacket _:
Console.WriteLine($"[{EndPoint}] ConnectionEstablishment!");
break;
case CustomDataPacket customDataPacket:
_receiveCustomDataPacketCallback?.Invoke(new ReceiveCustomDataPacketData(this, customDataPacket));
break;
}
}
public override Task OnPacket(IPacket packet)
{
var operation = (RecvPacketOperations)packet.Decode <short>();
switch (operation)
{
case RecvPacketOperations.MigrateIn:
return(OnMigrateIn(packet));
case RecvPacketOperations.UserTransferFieldRequest:
return(OnTransferFieldRequest(packet));
default:
Logger.Warn($"Unhandled packet operation {operation}");
return(Task.CompletedTask);
}
}
public override async Task Handle(RecvPacketOperations operation, IPacket packet, FieldUser user)
{
var templateID = packet.Decode <int>();
if (!user.Character.HasItem(templateID))
{
return;
}
user.PortableChairID = templateID;
await user.ModifyStats(exclRequest : true);
using var p = new Packet(SendPacketOperations.UserSetActivePortableChair);
p.Encode <int>(user.ID);
p.Encode <int>(templateID);
await user.Field.BroadcastPacket(user, p);
}
public override Task Handle(RecvPacketOperations operation, IPacket packet, FieldUser user)
{
packet.Decode <byte>();
packet.Decode <int>();
packet.Decode <short>();
packet.Decode <short>();
var objectID = packet.Decode <int>();
packet.Decode <int>();
return(Handle(operation, packet, user, user.Field.GetObject <AbstractFieldDrop>(objectID)));
}
private async Task OnMigrateIn(IPacket packet)
{
var characterID = packet.Decode <int>();
try
{
using (var store = Service.DataStore.OpenSession())
{
var character = store
.Query <Character>()
.First(c => c.ID == characterID);
var data = store
.Query <AccountData>()
.First(d => d.ID == character.AccountDataID);
var account = store
.Query <Account>()
.First(a => a.ID == data.AccountID);
await TryMigrateFrom(account, character);
Account = account;
AccountData = data;
Character = character;
using (var p = new Packet(SendPacketOperations.SetITC))
{
character.EncodeData(p);
p.Encode <string>(Account.Username); // m_sNexonClubID
p.Encode <int>(Service.Info.RegisterFeeMeso);
p.Encode <int>(Service.Info.CommissionRate);
p.Encode <int>(Service.Info.CommissionBase);
p.Encode <int>(Service.Info.AuctionDurationMin);
p.Encode <int>(Service.Info.AuctionDurationMax);
p.Encode <long>(0);
await SendPacket(p);
}
}
}
catch
{
await Close();
}
}
private Task OnDropPickUpRequest(IPacket packet)
{
packet.Decode <byte>();
packet.Decode <int>();
packet.Decode <short>();
packet.Decode <short>();
var objectID = packet.Decode <int>();
packet.Decode <int>();
var drop = Field.GetObject <AbstractFieldDrop>(objectID);
return(drop?.PickUp(this));
}
public override async Task Handle(RecvPacketOperations operation, IPacket packet, FieldUser user)
{
var npc = user.Field.GetObject <FieldNPC>(packet.Decode <int>());
if (npc == null)
{
return;
}
var template = npc.Template;
if (template.Trunk)
{
await user.Interact(new TrunkDialog(user, template, user.AccountData.Trunk));
return;
}
var shop = user.Service.TemplateManager.Get <NPCShopTemplate>(template.ID);
if (shop != null)
{
await user.Interact(new ShopDialog(user, shop));
return;
}
var script = template.Scripts.FirstOrDefault()?.Script;
if (script == null)
{
return;
}
var context = new ConversationContext(user.Socket);
var conversation = await user.Service.ConversationManager.Build(
script,
context,
new FieldNPCSpeaker(context, npc),
new FieldUserSpeaker(context, user)
);
await user.Converse(conversation);
}
public override async Task Handle(RecvPacketOperations operation, IPacket packet, FieldUser user)
{
var channel = packet.Decode <byte>();
try
{
var service = user.Service.Peers
.OfType <GameServiceInfo>()
.Where(g => g.WorldID == user.Service.Info.WorldID)
.OrderBy(g => g.ID)
.ToList()[channel];
await user.Socket.TryMigrateTo(user.Account, user.Character, service);
}
catch
{
using var p = new Packet(SendPacketOperations.TransferChannelReqIgnored);
p.Encode <byte>(0x1);
await user.SendPacket(p);
}
}
private async Task OnCheckDuplicatedID(IPacket packet)
{
var name = packet.Decode <string>();
await WvsLogin.LockProvider.AcquireAsync("characterCreationLock");
using (var db = WvsLogin.DataContextFactory.Create())
{
var isDuplicatedID = db.Characters.Any(c => c.Name.Equals(name));
using (var p = new Packet(SendPacketOperations.CheckDuplicatedIDResult))
{
p.Encode <string>(name);
p.Encode <bool>(isDuplicatedID);
await SendPacket(p);
}
}
await WvsLogin.LockProvider.ReleaseAsync("characterCreationLock");
}
public override async Task Handle(RecvPacketOperations operation, IPacket packet, FieldUser user)
{
packet.Decode <long>();
packet.Decode <byte>();
packet.Decode <long>();
packet.Decode <int>();
packet.Decode <int>();
packet.Decode <int>();
var path = user.Move(packet);
using var p = new Packet(SendPacketOperations.UserMove);
p.Encode <int>(user.ID);
path.Encode(p);
await user.Field.BroadcastPacket(user, p);
}
public override async Task Handle(RecvPacketOperations operation, IPacket packet, FieldUser user)
{
var templateID = packet.Decode <int>();
var template = user.Service.TemplateManager.Get <SkillTemplate>(templateID);
if (template == null)
{
return;
}
if (SkillConstants.IsKeydownSkill(templateID))
{
using var p = new Packet(SendPacketOperations.UserSkillCancel);
p.Encode <int>(user.ID);
p.Encode <int>(templateID);
await user.Field.BroadcastPacket(user, p);
}
else
{
await user.ModifyTemporaryStats(ts => ts.Reset(templateID));
}
}
private async Task OnUserTransferChannelRequest(IPacket packet)
{
byte result = 0x0;
var channel = packet.Decode <byte>();
var service = Socket.WvsGame.Peers
.OfType <GameServiceInfo>()
.Where(g => g.WorldID == Socket.WvsGame.Info.WorldID)
.OrderBy(g => g.ID)
.ToList()[channel];
if (Field.Template.Limit.HasFlag(FieldOpt.MigrateLimit))
{
return;
}
if (service == null)
{
result = 0x1;
}
else if (service.AdultChannel)
{
result = 0x1;
}
else if (!await Socket.WvsGame.TryMigrateTo(Socket, Character, service))
{
result = 0x1;
}
if (result == 0x0)
{
return;
}
using (var p = new Packet(SendPacketOperations.TransferChannelReqIgnored))
{
p.Encode <byte>(result);
await SendPacket(p);
}
}
private Task OnCashShopCashItemRequest(IPacket packet)
{
var type = (CashItemRequest)packet.Decode <byte>();
switch (type)
{
case CashItemRequest.Buy:
return(OnBuy(packet));
case CashItemRequest.Gift:
return(OnGift(packet));
case CashItemRequest.SetWish:
return(OnSetWish(packet));
case CashItemRequest.IncCharSlotCount:
return(OnIncCharSlotCount(packet));
case CashItemRequest.MoveLtoS:
return(OnMoveLtoS(packet));
case CashItemRequest.MoveStoL:
return(OnMoveStoL(packet));
case CashItemRequest.BuyPackage:
return(OnBuyPackage(packet));
default:
Logger.Warn($"Unhandled cash item operation {type}");
using (var p = new Packet(SendPacketOperations.CashShopCashItemResult))
{
p.Encode <byte>((byte)CashItemResult.SetWish_Failed);
p.Encode <byte>(0);
return(SendPacket(p));
}
}
}
private async Task OnSetGender(IPacket packet)
{
var gender = (byte)(packet.Decode <bool>() ? 0 : 1);
try
{
using var p = new Packet(SendPacketOperations.SetAccountResult);
using var store = Service.DataStore.OpenSession();
Account.Gender = gender;
await store.UpdateAsync(Account);
p.Encode <byte>(gender);
p.Encode <bool>(true);
await SendPacket(p);
}
catch
{
using var p = new Packet(SendPacketOperations.SetAccountResult);
p.Encode <bool>(false);
p.Encode <bool>(false);
await SendPacket(p);
}
}
public override Task OnPacket(IPacket packet)
{
var operation = (RecvPacketOperations)packet.Decode <short>();
return(operation switch {
RecvPacketOperations.CheckPassword => OnCheckPassword(packet),
RecvPacketOperations.WorldInfoRequest => OnWorldInfoRequest(packet),
RecvPacketOperations.SelectWorld => OnSelectWorld(packet),
RecvPacketOperations.CheckUserLimit => OnCheckUserLimit(packet),
RecvPacketOperations.SetGender => OnSetGender(packet),
RecvPacketOperations.CheckPinCode => OnCheckPinCode(packet),
RecvPacketOperations.WorldRequest => OnWorldInfoRequest(packet),
RecvPacketOperations.LogoutWorld => OnLogoutWorld(packet),
RecvPacketOperations.CheckDuplicatedID => OnCheckDuplicatedID(packet),
RecvPacketOperations.CreateNewCharacter => OnCreateNewCharacter(packet),
RecvPacketOperations.DeleteCharacter => OnDeleteCharacter(packet),
RecvPacketOperations.AliveAck => TryProcessHeartbeat(Account, Character),
RecvPacketOperations.EnableSPWRequest => OnEnableSPWRequest(packet, false),
RecvPacketOperations.CheckSPWRequest => OnCheckSPWRequest(packet, false),
RecvPacketOperations.EnableSPWRequestByACV => OnEnableSPWRequest(packet, true),
RecvPacketOperations.CheckSPWRequestByACV => OnCheckSPWRequest(packet, true),
_ => Task.Run(() => Logger.Warn($"Unhandled packet operation {operation}"))
});
private async Task OnPutMoney(FieldUser user, IPacket packet)
{
if (Users.Count < 2)
{
return;
}
if (_locked)
{
return;
}
var pair = Users.FirstOrDefault(kv => kv.Value == user);
var amount = packet.Decode <int>();
if (user.Character.Money < amount)
{
return;
}
_money[pair.Key] += amount;
await user.ModifyStats(s => s.Money -= amount, true);
IPacket GetPutMoneyPacket(byte position, int money)
{
using (var p = new Packet(SendPacketOperations.MiniRoom))
{
p.Encode <byte>((byte)MiniRoomAction.TRP_PutMoney);
p.Encode <byte>(position);
p.Encode <int>(money);
return(p);
}
}
await user.SendPacket(GetPutMoneyPacket(0x0, _money[pair.Key]));
await BroadcastPacket(user, GetPutMoneyPacket(0x1, _money[pair.Key]));
}
private async Task OnUserMove(IPacket packet)
{
packet.Decode <long>();
packet.Decode <byte>();
packet.Decode <long>();
packet.Decode <int>();
packet.Decode <int>();
packet.Decode <int>();
var path = Move(packet);
using (var p = new Packet(SendPacketOperations.UserMove))
{
p.Encode <int>(ID);
path.Encode(p);
await Field.BroadcastPacket(p);
}
}
public Task OnPacket(RecvPacketOperations operation, FieldUser user, IPacket packet)
{
var type = (TrunkRequest)packet.Decode <byte>();
switch (type)
{
case TrunkRequest.GetItem:
return(OnTrunkGetItemRequest(user, packet));
case TrunkRequest.PutItem:
return(OnTrunkPutItemRequest(user, packet));
case TrunkRequest.SortItem:
return(OnTrunkSortItemRequest(user, packet));
case TrunkRequest.Money:
return(OnTrunkMoneyRequest(user, packet));
case TrunkRequest.CloseDialog:
return(user.Interact(this, true));
}
return(Task.CompletedTask);
}
public override async Task Handle(RecvPacketOperations operation, IPacket packet, FieldUser user)
{
if (user.ConversationContext == null)
{
return;
}
var type = (ConversationMessageType)packet.Decode <byte>();
if (type != user.ConversationContext.LastRequestType)
{
return;
}
if (type == ConversationMessageType.AskQuiz ||
type == ConversationMessageType.AskSpeedQuiz)
{
await user.ConversationContext.Respond(packet.Decode <string>());
return;
}
var answer = packet.Decode <byte>();
if (
type != ConversationMessageType.Say &&
type != ConversationMessageType.AskYesNo &&
type != ConversationMessageType.AskAccept &&
answer == byte.MinValue ||
(type == ConversationMessageType.Say ||
type == ConversationMessageType.AskYesNo ||
type == ConversationMessageType.AskAccept) && answer == byte.MaxValue
)
{
user.ConversationContext.TokenSource.Cancel();
return;
}
switch (type)
{
case ConversationMessageType.AskText:
case ConversationMessageType.AskBoxText:
await user.ConversationContext.Respond(packet.Decode <string>());
break;
case ConversationMessageType.AskNumber:
case ConversationMessageType.AskMenu:
case ConversationMessageType.AskSlideMenu:
await user.ConversationContext.Respond(packet.Decode <int>());
break;
case ConversationMessageType.AskAvatar:
case ConversationMessageType.AskMemberShopAvatar:
await user.ConversationContext.Respond(packet.Decode <byte>());
break;
case ConversationMessageType.AskYesNo:
case ConversationMessageType.AskAccept:
await user.ConversationContext.Respond(Convert.ToBoolean(answer));
break;
default:
await user.ConversationContext.Respond(answer);
break;
}
}
private void Decode(IPacket packet)
{
packet.Decode <byte>(); // fieldKey
packet.Decode <int>(); // pDrInfo
packet.Decode <int>(); // pDrInfo
var v6 = packet.Decode <byte>();
DamagePerMob = v6 & 0xF;
MobCount = v6 >> 4;
packet.Decode <int>(); // pDrInfo
packet.Decode <int>(); // pDrInfo
SkillID = packet.Decode <int>();
packet.Decode <byte>(); // combatOrders
if (_type == AttackType.Magic)
{
packet.Decode <int>();
packet.Decode <int>();
packet.Decode <int>();
packet.Decode <int>();
packet.Decode <int>();
packet.Decode <int>();
}
packet.Decode <int>(); // rand
packet.Decode <int>(); // crc?
packet.Decode <int>();
packet.Decode <int>();
if (SkillConstants.IsKeydownSkill(SkillID))
{
KeyDown = packet.Decode <int>();
}
Option = packet.Decode <byte>();
if (_type == AttackType.Shoot)
{
packet.Decode <byte>(); // m_bNextShootExJablin
}
var v17 = packet.Decode <short>();
Left = Convert.ToBoolean((v17 >> 15) & 1);
Action = v17 & 0x7FFF;
packet.Decode <int>();
AttackActionType = packet.Decode <byte>();
AttackSpeed = packet.Decode <byte>();
AttackTime = packet.Decode <int>();
packet.Decode <int>(); // phase
if (_type == AttackType.Shoot)
{
packet.Decode <short>();
packet.Decode <short>();
packet.Decode <byte>();
// if ( v459 && !is_shoot_skill_not_consuming_bullet(nSkillID) )
// packet.Decode<int>();
}
DamageInfo = new DamageInfo[MobCount];
for (var i = 0; i < MobCount; i++)
{
var info = new DamageInfo(_type, _user);
info.Decode(packet, DamagePerMob);
DamageInfo[i] = info;
}
}
public void Decode(IPacket packet)
{
X = packet.Decode <short>();
Y = packet.Decode <short>();
VX = packet.Decode <short>();
VY = packet.Decode <short>();
var size = packet.Decode <byte>();
for (var i = 0; i < size; i++)
{
var m = new Movement();
m.Attr = packet.Decode <byte>();
switch (m.Attr)
{
case 0x0:
case 0x5:
case 0xC:
case 0xE:
case 0x23:
case 0x24:
m.X = packet.Decode <short>();
m.Y = packet.Decode <short>();
m.VX = packet.Decode <short>();
m.VY = packet.Decode <short>();
m.FH = packet.Decode <short>();
FHLast = m.FH;
if (m.Attr == 0xC)
{
m.FHFallStart = packet.Decode <short>();
}
m.XOffset = packet.Decode <short>();
m.YOffset = packet.Decode <short>();
goto default;
default:
m.MoveAction = packet.Decode <byte>();
m.Elapse = packet.Decode <short>();
MoveActionLast = m.MoveAction;
X = m.X;
Y = m.Y;
VX = m.VX;
VY = m.VY;
break;
case 0x1:
case 0x2:
case 0xD:
case 0x10:
case 0x12:
case 0x1F:
case 0x20:
case 0x21:
case 0x22:
m.X = X;
m.Y = Y;
m.FH = 0;
m.VX = packet.Decode <short>();
m.VY = packet.Decode <short>();
goto default;
case 0x14:
case 0x15:
case 0x16:
case 0x17:
case 0x18:
case 0x19:
case 0x1A:
case 0x1B:
case 0x1C:
case 0x1D:
case 0x1E:
m.X = X;
m.Y = Y;
m.VX = VX;
m.VY = VY;
goto default;
case 0x3:
case 0x4:
case 0x6:
case 0x7:
case 0x8:
case 0xA:
m.X = packet.Decode <short>();
m.Y = packet.Decode <short>();
m.FH = packet.Decode <short>();
FHLast = m.FH;
m.VY = 0;
m.VX = 0;
goto default;
case 0xB:
m.X = X;
m.Y = Y;
m.FH = 0;
m.VX = packet.Decode <short>();
m.VY = packet.Decode <short>();
m.FHFallStart = packet.Decode <short>();
goto default;
case 0x11:
m.X = packet.Decode <short>();
m.Y = packet.Decode <short>();
m.VX = packet.Decode <short>();
m.VY = packet.Decode <short>();
goto default;
case 0x9:
m.Stat = packet.Decode <bool>();
m.VY = 0;
m.VX = 0;
m.X = X;
m.Y = Y;
m.Elapse = 0;
MoveActionLast = 0;
m.MoveAction = 0;
FHLast = 0;
m.FH = 0;
break;
}
_path.Add(m);
}
}
public async Task Handle(RecvPacketOperations operation, IPacket packet, GameSocket socket)
{
var characterID = packet.Decode <int>();
try
{
using var store = socket.Service.DataStore.OpenSession();
var character = store
.Query <Character>()
.First(c => c.ID == characterID);
var data = store
.Query <AccountData>()
.First(d => d.ID == character.AccountDataID);
var account = store
.Query <Account>()
.First(a => a.ID == data.AccountID);
await socket.TryMigrateFrom(account, character);
socket.Account = account;
socket.AccountData = data;
socket.Character = character;
var field = socket.Service.FieldManager.Get(character.FieldID);
var fieldUser = new FieldUser(socket);
await fieldUser.ValidateStat();
socket.FieldUser = fieldUser;
await field.Enter(fieldUser);
if (socket.SocialService != null)
{
await socket.Service.SendMessage(socket.SocialService, new SocialStateMessage
{
CharacterID = character.ID,
State = MigrationState.LoggedIn,
Service = socket.Service.Info.Name
});
}
using (var p = new Packet(SendPacketOperations.FuncKeyMappedInit))
{
p.Encode <bool>(false);
for (var i = 0; i < 90; i++)
{
var key = character.FunctionKeys[i];
p.Encode <byte>(key?.Type ?? 0);
p.Encode <int>(key?.Action ?? 0);
}
await socket.SendPacket(p);
}
using (var p = new Packet(SendPacketOperations.QuickslotMappedInit))
{
p.Encode <bool>(true);
for (var i = 0; i < 8; i++)
{
p.Encode <int>(character.QuickSlotKeys[i]);
}
await socket.SendPacket(p);
}
if (SkillConstants.HasEvanDragon(fieldUser.Character.Job))
{
var dragon = new FieldDragon(fieldUser);
fieldUser.Owned.Add(dragon);
await fieldUser.Field.Enter(dragon);
}
}
catch
{
await socket.Close();
}
}
private async Task OnTrunkPutItemRequest(FieldUser user, IPacket packet)
{
var pos = packet.Decode <short>();
var templateID = packet.Decode <int>();
var number = packet.Decode <short>();
var inventory = user.Character.GetInventory((ItemInventoryType)(templateID / 1000000));
var item = inventory.Items.FirstOrDefault(i => i.Position == pos);
using (var p = new Packet(SendPacketOperations.TrunkResult))
{
var result = TrunkResult.PutSuccess;
switch (item)
{
case null:
case ItemSlotBundle bundle when bundle.Number < number:
result = TrunkResult.PutUnknown;
break;
}
if (user.Character.Money < _putFee)
{
result = TrunkResult.GetNoMoney;
}
if (_trunk.Items.Count >= _trunk.SlotMax)
{
result = TrunkResult.PutNoSpace;
}
p.Encode <byte>((byte)result);
if (result == TrunkResult.PutSuccess)
{
await user.ModifyStats(s => s.Money -= _putFee);
await user.ModifyInventory(i =>
{
if (!ItemConstants.IsTreatSingly(item.TemplateID))
{
if (!(item is ItemSlotBundle bundle))
{
return;
}
if (bundle.Number < number)
{
return;
}
item = i.Take(bundle, number);
}
else
{
i.Remove(item);
}
});
_trunk.Items.Add(item);
EncodeData(user, p);
}
await user.SendPacket(p);
}
}
public override async Task Handle(RecvPacketOperations operation, IPacket packet, FieldMob mob)
{
var mobCtrlSN = packet.Decode <short>();
var v7 = packet
.Decode <byte>(); //v85 = nDistance | 4 * (v184 | 2 * ((unsigned __int8)retaddr | 2 * v72)); [ CONFIRMED ]
var oldSplit = (v7 & 0xF0) != 0; //this is a type of CFieldSplit
var mobMoveStartResult = (v7 & 0xF) != 0;
var curSplit = packet.Decode <byte>();
var illegalVelocity = packet.Decode <int>();
var v8 = packet.Decode <byte>();
var cheatedRandom = (v8 & 0xF0) != 0;
var cheatedCtrlMove = (v8 & 0xF) != 0;
var multiTargetForBall = packet.Decode <int>();
for (var i = 0; i < multiTargetForBall; i++)
{
packet.Decode <long>(); // int, int
}
var randTimeForAreaAttack = packet.Decode <int>();
for (var i = 0; i < randTimeForAreaAttack; i++)
{
packet.Decode <int>();
}
packet.Decode <int>(); // HackedCode
packet.Decode <int>(); // idk
packet.Decode <int>(); // HackedCodeCrc
packet.Decode <int>(); // idk
using (var p = new Packet(SendPacketOperations.MobCtrlAck))
{
p.Encode <int>(mob.ID);
p.Encode <short>(mobCtrlSN);
p.Encode <bool>(mobMoveStartResult);
p.Encode <short>(0); // nMP
p.Encode <byte>(0); // SkillCommand
p.Encode <byte>(0); // SLV
await mob.Controller.SendPacket(p);
}
using (var p = new Packet(SendPacketOperations.MobMove))
{
p.Encode <int>(mob.ID);
p.Encode <bool>(mobMoveStartResult);
p.Encode <byte>(curSplit);
p.Encode <byte>(0); // not sure
p.Encode <byte>(0); // not sure
p.Encode <int>(illegalVelocity);
p.Encode <int>(0); // MultiTargetForBall
p.Encode <int>(0); // RandTimeForAreaAttack
mob.Move(packet).Encode(p);
await mob.Field.BroadcastPacket(mob.Controller, p);
}
}
public override void DecodeData(IPacket packet)
{
VPosition = packet.Decode <Point>();
base.DecodeData(packet);
}
private async Task OnMigrateIn(IPacket packet)
{
var characterID = packet.Decode <int>();
try
{
using (var store = Service.DataStore.OpenSession())
{
var character = store
.Query <Character>()
.First(c => c.ID == characterID);
var data = store
.Query <AccountData>()
.First(d => d.ID == character.AccountDataID);
var account = store
.Query <Account>()
.First(a => a.ID == data.AccountID);
await TryMigrateFrom(account, character);
Account = account;
AccountData = data;
Character = character;
using (var p = new Packet(SendPacketOperations.SetCashShop))
{
character.EncodeData(p);
p.Encode <bool>(true); // m_bCashShopAuthorized
p.Encode <string>(Account.Username); // m_sNexonClubID
var templates = Service.TemplateManager;
var notSales = templates.GetAll <NotSaleTemplate>().ToList();
p.Encode <int>(notSales.Count);
notSales.ForEach(n => p.Encode <int>(n.ID));
var modifiedCommodities = templates.GetAll <ModifiedCommodityTemplate>().ToList();
p.Encode <short>((short)modifiedCommodities.Count);
modifiedCommodities.ForEach(m =>
{
var flag = 0;
if (m.ItemID.HasValue)
{
flag |= 0x1;
}
if (m.Count.HasValue)
{
flag |= 0x2;
}
if (m.Priority.HasValue)
{
flag |= 0x10;
}
if (m.Price.HasValue)
{
flag |= 0x4;
}
if (m.Bonus.HasValue)
{
flag |= 0x8;
}
if (m.Period.HasValue)
{
flag |= 0x20;
}
if (m.ReqPOP.HasValue)
{
flag |= 0x20000;
}
if (m.ReqLEV.HasValue)
{
flag |= 0x40000;
}
if (m.MaplePoint.HasValue)
{
flag |= 0x40;
}
if (m.Meso.HasValue)
{
flag |= 0x80;
}
if (m.ForPremiumUser.HasValue)
{
flag |= 0x100;
}
if (m.Gender.HasValue)
{
flag |= 0x200;
}
if (m.OnSale.HasValue)
{
flag |= 0x400;
}
if (m.Class.HasValue)
{
flag |= 0x800;
}
if (m.Limit.HasValue)
{
flag |= 0x1000;
}
if (m.PbCash.HasValue)
{
flag |= 0x2000;
}
if (m.PbPoint.HasValue)
{
flag |= 0x4000;
}
if (m.PbGift.HasValue)
{
flag |= 0x8000;
}
if (m.PackageSN != null)
{
flag |= 0x10000;
}
p.Encode <int>(m.ID);
p.Encode <int>(flag);
if ((flag & 0x1) != 0)
{
p.Encode <int>(m.ItemID.Value);
}
if ((flag & 0x2) != 0)
{
p.Encode <short>(m.Count.Value);
}
if ((flag & 0x10) != 0)
{
p.Encode <byte>(m.Priority.Value);
}
if ((flag & 0x4) != 0)
{
p.Encode <int>(m.Price.Value);
}
if ((flag & 0x8) != 0)
{
p.Encode <byte>(m.Bonus.Value);
}
if ((flag & 0x20) != 0)
{
p.Encode <short>(m.Period.Value);
}
if ((flag & 0x20000) != 0)
{
p.Encode <short>(m.ReqPOP.Value);
}
if ((flag & 0x40000) != 0)
{
p.Encode <short>(m.ReqLEV.Value);
}
if ((flag & 0x40) != 0)
{
p.Encode <int>(m.MaplePoint.Value);
}
if ((flag & 0x80) != 0)
{
p.Encode <int>(m.Meso.Value);
}
if ((flag & 0x100) != 0)
{
p.Encode <bool>(m.ForPremiumUser.Value);
}
if ((flag & 0x200) != 0)
{
p.Encode <byte>(m.Gender.Value);
}
if ((flag & 0x400) != 0)
{
p.Encode <bool>(m.OnSale.Value);
}
if ((flag & 0x800) != 0)
{
p.Encode <byte>(m.Class.Value);
}
if ((flag & 0x1000) != 0)
{
p.Encode <byte>(m.Limit.Value);
}
if ((flag & 0x2000) != 0)
{
p.Encode <short>(m.PbCash.Value);
}
if ((flag & 0x4000) != 0)
{
p.Encode <short>(m.PbPoint.Value);
}
if ((flag & 0x8000) != 0)
{
p.Encode <short>(m.PbGift.Value);
}
if ((flag & 0x10000) == 0)
{
return;
}
p.Encode <byte>((byte)m.PackageSN.Length);
m.PackageSN.ForEach(sn => p.Encode <int>(sn));
});
var categoryDiscounts = templates.GetAll <CategoryDiscountTemplate>().ToList();
p.Encode <byte>((byte)categoryDiscounts.Count);
categoryDiscounts.ForEach(d =>
{
p.Encode <byte>(d.Category);
p.Encode <byte>(d.CategorySub);
p.Encode <byte>(d.DiscountRate);
});
const int bestLimit = 90;
var best = templates.GetAll <BestTemplate>().ToList();
best.Take(bestLimit).ForEach(b =>
{
p.Encode <int>(b.Category);
p.Encode <int>(b.Gender);
p.Encode <int>(b.CommoditySN);
});
if (best.Count < bestLimit)
{
Enumerable.Repeat(0, bestLimit - best.Count).ForEach(i =>
{
p.Encode <int>(0);
p.Encode <int>(0);
p.Encode <int>(0);
});
}
// DecodeStock
p.Encode <short>(0);
// DecodeLimitGoods
p.Encode <short>(0);
// DecodeZeroGoods
p.Encode <short>(0);
p.Encode <bool>(false); // m_bEventOn
p.Encode <int>(0); // m_nHighestCharacterLevelInThisAccount
await SendPacket(p);
}
}
await SendLockerData();
await SendWishListData();
await SendCashData();
}
catch
{
await Close();
}
}
