Example #1
0
        public override void Execute(PclPacket getGiftPacket, ClientSession clientSession)
        {
            var isCopy = getGiftPacket.Type == 2;
            var mail   = _mailHttpClient.GetGift(getGiftPacket.GiftId, clientSession.Character.VisualId, isCopy);

            if (mail == null)
            {
                return;
            }

            if ((getGiftPacket.Type == 4) && (mail.ItemInstance != null))
            {
                var itemInstance = _itemInstanceDao.FirstOrDefault(s => s.Id == mail.ItemInstance.Id);
                var item         = _itemProvider.Convert(itemInstance);
                item.Id = Guid.NewGuid();
                var newInv = clientSession.Character.InventoryService
                             .AddItemToPocket(InventoryItemInstance.Create(item, clientSession.Character.CharacterId))
                             .FirstOrDefault();
                if (newInv != null)
                {
                    clientSession.SendPacket(clientSession.Character.GenerateSay(
                                                 string.Format(
                                                     Language.Instance.GetMessageFromKey(LanguageKey.ITEM_RECEIVED,
                                                                                         clientSession.Account.Language),
                                                     newInv.ItemInstance.Item.Name, newInv.ItemInstance.Amount), SayColorType.Green));
                    clientSession.SendPacket(
                        new ParcelPacket {
                        Type = 2, Unknown = 1, Id = (short)getGiftPacket.GiftId
                    });
                    _mailHttpClient.DeleteGift(getGiftPacket.GiftId, clientSession.Character.VisualId, isCopy);
                }
                else
                {
                    clientSession.SendPacket(new ParcelPacket {
                        Type = 5, Unknown = 1, Id = 0
                    });
                    clientSession.SendPacket(new MsgPacket
                    {
                        Message = Language.Instance.GetMessageFromKey(LanguageKey.NOT_ENOUGH_PLACE,
                                                                      clientSession.Account.Language),
                        Type = 0
                    });
                }
            }
            else if (getGiftPacket.Type == 5)
            {
                clientSession.SendPacket(new ParcelPacket {
                    Type = 7, Unknown = 1, Id = (short)getGiftPacket.GiftId
                });
                _mailHttpClient.DeleteGift(getGiftPacket.GiftId, clientSession.Character.VisualId, isCopy);
            }
        }
        public List <WarehouseItem> GetWarehouseItems(long characterId, WarehouseType warehouse)
        {
            var client   = Connect();
            var response = client
                           .GetAsync($"{ApiUrl}?id=null&ownerId={characterId}&warehouseType={warehouse}&slot=null")
                           .Result;

            if (response.IsSuccessStatusCode)
            {
                var warehouseItems = new List <WarehouseItem>();
                var warehouselinks =
                    JsonConvert.DeserializeObject <List <WarehouseLink> >(response.Content.ReadAsStringAsync().Result);
                foreach (var warehouselink in warehouselinks)
                {
                    var warehouseItem = warehouselink.Warehouse.Adapt <WarehouseItem>();
                    var itemInstance  = _itemInstanceDao.FirstOrDefault(s => s.Id == warehouselink.ItemInstance.Id);
                    warehouseItem.ItemInstance = _itemProvider.Convert(itemInstance);
                    warehouseItems.Add(warehouseItem);
                }
            }

            throw new ArgumentException();
        }
Example #3
0
        public void SelectCharacter(SelectPacket selectPacket)
        {
            try
            {
                if (Session?.Account == null || Session.HasSelectedCharacter)
                {
                    return;
                }

                var characterDto =
                    _characterDao.FirstOrDefault(s =>
                                                 s.AccountId == Session.Account.AccountId && s.Slot == selectPacket.Slot &&
                                                 s.State == CharacterState.Active);
                if (characterDto == null)
                {
                    return;
                }

                var character = _adapter.Adapt <Character>(characterDto);

                character.MapInstanceId = _mapInstanceProvider.GetBaseMapInstanceIdByMapId(character.MapId);
                character.MapInstance   = _mapInstanceProvider.GetMapInstance(character.MapInstanceId);
                character.PositionX     = character.MapX;
                character.PositionY     = character.MapY;
                character.Direction     = 2;
                character.Account       = Session.Account;
                character.Group.JoinGroup(character);
                Session.SetCharacter(character);

                var inventories = _itemInstanceDao
                                  .Where(s => s.CharacterId == character.CharacterId)
                                  .ToList();
                inventories.ForEach(k => character.Inventory[k.Id] = _itemProvider.Convert(k));
#pragma warning disable CS0618
                Session.SendPackets(Session.Character.GenerateInv());
#pragma warning restore CS0618

                if (Session.Character.Hp > Session.Character.HpLoad())
                {
                    Session.Character.Hp = (int)Session.Character.HpLoad();
                }

                if (Session.Character.Mp > Session.Character.MpLoad())
                {
                    Session.Character.Mp = (int)Session.Character.MpLoad();
                }

                //var relations =
                //    _characterRelationDao.Where(s => s.CharacterId == Session.Character.CharacterId);
                //var relationsWithCharacter =
                //    _characterRelationDao.Where(s => s.RelatedCharacterId == Session.Character.CharacterId);

                //var characters = _characterDao
                //    .Where(s => relations.Select(v => v.RelatedCharacterId).Contains(s.CharacterId)).ToList();
                //var relatedCharacters = _characterDao.Where(s =>
                //    relationsWithCharacter.Select(v => v.RelatedCharacterId).Contains(s.CharacterId)).ToList();

                //foreach (var relation in _adapter.Adapt<IEnumerable<CharacterRelation>>(relations))
                //{
                //    relation.CharacterName = characters.Find(s => s.CharacterId == relation.RelatedCharacterId)?.Name;
                //    Session.Character.CharacterRelations[relation.CharacterRelationId] = relation;
                //}

                //foreach (var relation in _adapter.Adapt<IEnumerable<CharacterRelation>>(relationsWithCharacter))
                //{
                //    relation.CharacterName =
                //        relatedCharacters.Find(s => s.CharacterId == relation.RelatedCharacterId)?.Name;
                //    Session.Character.RelationWithCharacter[relation.CharacterRelationId] = relation;
                //}

                Session.SendPacket(new OkPacket());
            }
            catch (Exception ex)
            {
                _logger.Error("Select character failed.", ex);
            }
        }
        public override async Task ExecuteAsync(CScalcPacket packet, ClientSession clientSession)
        {
            var bz = await _bazaarHttpClient.GetBazaarLinkAsync(packet.BazaarId).ConfigureAwait(false);

            if ((bz != null) && (bz.SellerName == clientSession.Character.Name))
            {
                var soldedamount = bz.BazaarItem !.Amount - bz.ItemInstance !.Amount;
                var taxes        = bz.BazaarItem.MedalUsed ? (short)0 : (short)(bz.BazaarItem.Price * 0.10 * soldedamount);
                var price        = bz.BazaarItem.Price * soldedamount - taxes;
                if (clientSession.Character.InventoryService.CanAddItem(bz.ItemInstance.ItemVNum))
                {
                    if (clientSession.Character.Gold + price <= _worldConfiguration.MaxGoldAmount)
                    {
                        clientSession.Character.Gold += price;
                        await clientSession.SendPacketAsync(clientSession.Character.GenerateGold()).ConfigureAwait(false);

                        await clientSession.SendPacketAsync(clientSession.Character.GenerateSay(string.Format(
                                                                                                    GameLanguage.Instance.GetMessageFromKey(LanguageKey.REMOVE_FROM_BAZAAR,
                                                                                                                                            clientSession.Account.Language), price), SayColorType.Yellow)).ConfigureAwait(false);

                        var itemInstance = await _itemInstanceDao.FirstOrDefaultAsync(s => s !.Id == bz.ItemInstance.Id).ConfigureAwait(false);

                        if (itemInstance == null)
                        {
                            return;
                        }
                        var item = _itemProvider.Convert(itemInstance);
                        item.Id = Guid.NewGuid();

                        var newInv =
                            clientSession.Character.InventoryService.AddItemToPocket(
                                InventoryItemInstance.Create(item, clientSession.Character.CharacterId));
                        await clientSession.SendPacketAsync(newInv !.GeneratePocketChange()).ConfigureAwait(false);

                        var remove = await _bazaarHttpClient.RemoveAsync(packet.BazaarId, bz.ItemInstance.Amount,
                                                                         clientSession.Character.Name).ConfigureAwait(false);

                        if (remove)
                        {
                            await clientSession.SendPacketAsync(new RCScalcPacket
                            {
                                Type            = VisualType.Player,
                                Price           = bz.BazaarItem.Price,
                                RemainingAmount = (short)(bz.BazaarItem.Amount - bz.ItemInstance.Amount),
                                Amount          = bz.BazaarItem.Amount,
                                Taxes           = taxes,
                                Total           = price + taxes
                            }).ConfigureAwait(false);

                            await clientSession.HandlePacketsAsync(new[]
                                                                   { new CSListPacket {
                                                                         Index = 0, Filter = BazaarStatusType.Default
                                                                     } }).ConfigureAwait(false);

                            return;
                        }

                        _logger.Error(LogLanguage.Instance.GetMessageFromKey(LogLanguageKey.BAZAAR_DELETE_ERROR));
                    }
                    else
                    {
                        await clientSession.SendPacketAsync(new MsgPacket
                        {
                            Message = GameLanguage.Instance.GetMessageFromKey(LanguageKey.MAX_GOLD,
                                                                              clientSession.Account.Language),
                            Type = MessageType.Whisper
                        }).ConfigureAwait(false);
                    }
                }
                else
                {
                    await clientSession.SendPacketAsync(new InfoPacket
                    {
                        Message = GameLanguage.Instance.GetMessageFromKey(LanguageKey.NOT_ENOUGH_PLACE,
                                                                          clientSession.Account.Language)
                    }).ConfigureAwait(false);
                }

                await clientSession.SendPacketAsync(new RCScalcPacket
                {
                    Type   = VisualType.Player, Price = bz.BazaarItem.Price, RemainingAmount = 0,
                    Amount = bz.BazaarItem.Amount, Taxes = 0, Total = 0
                }).ConfigureAwait(false);
            }
            else
            {
                await clientSession.SendPacketAsync(new RCScalcPacket
                                                    { Type = VisualType.Player, Price = 0, RemainingAmount = 0, Amount = 0, Taxes = 0, Total = 0 }).ConfigureAwait(false);
            }
        }
Example #5
0
        public override void Execute(SelectPacket packet, ClientSession clientSession)
        {
            try
            {
                if ((clientSession?.Account == null) || clientSession.HasSelectedCharacter)
                {
                    return;
                }

                var characterDto =
                    _characterDao.FirstOrDefault(s =>
                                                 (s.AccountId == clientSession.Account.AccountId) && (s.Slot == packet.Slot) &&
                                                 (s.State == CharacterState.Active));
                if (characterDto == null)
                {
                    return;
                }

                var character = _adapter.Adapt <Character>(characterDto);

                character.MapInstanceId = _mapInstanceProvider.GetBaseMapInstanceIdByMapId(character.MapId);
                character.MapInstance   = _mapInstanceProvider.GetMapInstance(character.MapInstanceId);
                character.PositionX     = character.MapX;
                character.PositionY     = character.MapY;
                character.Direction     = 2;
                character.Account       = clientSession.Account;
                character.Group.JoinGroup(character);

                var inventories = _inventoryItemInstanceDao
                                  .Where(s => s.CharacterId == character.CharacterId)
                                  .ToList();
                var ids   = inventories.Select(o => o.ItemInstanceId).ToArray();
                var items = _itemInstanceDao.Where(s => ids.Contains(s.Id)).ToList();
                inventories.ForEach(k => character.InventoryService[k.ItemInstanceId] =
                                        InventoryItemInstance.Create(_itemProvider.Convert(items.First(s => s.Id == k.ItemInstanceId)),
                                                                     character.CharacterId, k));
                clientSession.SetCharacter(character);

#pragma warning disable CS0618
                clientSession.SendPackets(clientSession.Character.GenerateInv());
#pragma warning restore CS0618
                clientSession.SendPacket(clientSession.Character.GenerateMlobjlst());
                if (clientSession.Character.Hp > clientSession.Character.HpLoad())
                {
                    clientSession.Character.Hp = (int)clientSession.Character.HpLoad();
                }

                if (clientSession.Character.Mp > clientSession.Character.MpLoad())
                {
                    clientSession.Character.Mp = (int)clientSession.Character.MpLoad();
                }

                clientSession.Character.QuicklistEntries = _quickListEntriesDao
                                                           .Where(s => s.CharacterId == clientSession.Character.CharacterId).ToList();
                clientSession.Character.StaticBonusList = _staticBonusDao
                                                          .Where(s => s.CharacterId == clientSession.Character.CharacterId).ToList();
                clientSession.Character.Titles = _titleDao
                                                 .Where(s => s.CharacterId == clientSession.Character.CharacterId).ToList();
                clientSession.SendPacket(new OkPacket());
            }
            catch (Exception ex)
            {
                _logger.Error("Select character failed.", ex);
            }
        }
Example #6
0
        public override void Execute(CBuyPacket packet, ClientSession clientSession)
        {
            if (clientSession.Character.InExchangeOrTrade)
            {
                return;
            }

            var bz = _bazaarHttpClient.GetBazaarLink(packet.BazaarId);

            if ((bz != null) && (bz.SellerName != clientSession.Character.Name) &&
                (packet.Price == bz.BazaarItem.Price) && (bz.ItemInstance.Amount >= packet.Amount))
            {
                if (bz.BazaarItem.IsPackage && (bz.BazaarItem.Amount != packet.Amount))
                {
                    return;
                }

                var price = bz.BazaarItem.Price * packet.Amount;
                if (clientSession.Character.InventoryService.CanAddItem(bz.ItemInstance.ItemVNum))
                {
                    if (clientSession.Character.Gold - price > 0)
                    {
                        clientSession.Character.Gold -= price;
                        clientSession.SendPacket(clientSession.Character.GenerateGold());

                        var itemInstance = _itemInstanceDao.FirstOrDefault(s => s.Id == bz.ItemInstance.Id);
                        var item         = _itemProvider.Convert(itemInstance);
                        item.Id = Guid.NewGuid();
                        var newInv =
                            clientSession.Character.InventoryService.AddItemToPocket(
                                InventoryItemInstance.Create(item, clientSession.Character.CharacterId));
                        clientSession.SendPacket(newInv.GeneratePocketChange());

                        var remove = _bazaarHttpClient.Remove(packet.BazaarId, packet.Amount,
                                                              clientSession.Character.Name);
                        if (remove)
                        {
                            clientSession.HandlePackets(new[]
                                                        { new CBListPacket {
                                                              Index = 0, ItemVNumFilter = new List <short>()
                                                          } });
                            clientSession.SendPacket(new RCBuyPacket
                            {
                                Type     = VisualType.Player,
                                VNum     = bz.ItemInstance.ItemVNum,
                                Owner    = bz.BazaarItem.SellerId,
                                Amount   = packet.Amount,
                                Price    = packet.Price,
                                Unknown1 = 0,
                                Unknown2 = 0,
                                Unknown3 = 0
                            });
                            clientSession.SendPacket(clientSession.Character.GenerateSay(
                                                         $"{Language.Instance.GetMessageFromKey(LanguageKey.ITEM_ACQUIRED, clientSession.Account.Language)}: {item.Item.Name[clientSession.Account.Language]} x {packet.Amount}"
                                                         , SayColorType.Yellow
                                                         ));

                            return;
                        }

                        _logger.Error(LogLanguage.Instance.GetMessageFromKey(LogLanguageKey.BAZAAR_BUY_ERROR));
                    }
                    else
                    {
                        clientSession.SendPacket(clientSession.Character.GenerateSay(
                                                     Language.Instance.GetMessageFromKey(LanguageKey.NOT_ENOUGH_MONEY,
                                                                                         clientSession.Account.Language), SayColorType.Yellow
                                                     ));
                        clientSession.SendPacket(new ModalPacket
                        {
                            Message = Language.Instance.GetMessageFromKey(LanguageKey.NOT_ENOUGH_MONEY,
                                                                          clientSession.Account.Language),
                            Type = 1
                        });
                        return;
                    }
                }
                else
                {
                    clientSession.SendPacket(new InfoPacket
                    {
                        Message = Language.Instance.GetMessageFromKey(LanguageKey.NOT_ENOUGH_PLACE,
                                                                      clientSession.Account.Language)
                    });
                    return;
                }
            }

            clientSession.SendPacket(new ModalPacket
            {
                Message = Language.Instance.GetMessageFromKey(LanguageKey.STATE_CHANGED_BAZAAR,
                                                              clientSession.Account.Language),
                Type = 1
            });
        }
        public override Task ExecuteAsync(SelectPacket packet, ClientSession clientSession)
        {
            try
            {
                if ((clientSession?.Account == null) || clientSession.HasSelectedCharacter)
                {
                    return(Task.CompletedTask);
                }

                var characterDto =
                    _characterDao.FirstOrDefault(s =>
                                                 (s.AccountId == clientSession.Account.AccountId) && (s.Slot == packet.Slot) &&
                                                 (s.State == CharacterState.Active));
                if (characterDto == null)
                {
                    return(Task.CompletedTask);
                }

                var character = characterDto.Adapt <Character>();

                character.MapInstanceId = _mapInstanceProvider.GetBaseMapInstanceIdByMapId(character.MapId);
                character.MapInstance   = _mapInstanceProvider.GetMapInstance(character.MapInstanceId) !;
                character.PositionX     = character.MapX;
                character.PositionY     = character.MapY;
                character.Direction     = 2;
                character.Script        = character.CurrentScriptId != null?_scriptDao.FirstOrDefault(s => s.Id == character.CurrentScriptId) : null;

                character.Group !.JoinGroup(character);

                var inventories = _inventoryItemInstanceDao
                                  .Where(s => s.CharacterId == character.CharacterId)
                                  .ToList();
                var ids   = inventories.Select(o => o.ItemInstanceId).ToArray();
                var items = _itemInstanceDao.Where(s => ids.Contains(s.Id)).ToList();
                inventories.ForEach(k => character.InventoryService[k.ItemInstanceId] =
                                        InventoryItemInstance.Create(_itemProvider.Convert(items.First(s => s.Id == k.ItemInstanceId)),
                                                                     character.CharacterId, k));
                clientSession.SetCharacter(character);

#pragma warning disable CS0618
                clientSession.SendPacketsAsync(clientSession.Character.GenerateInv());
#pragma warning restore CS0618
                clientSession.SendPacketAsync(clientSession.Character.GenerateMlobjlst());
                if (clientSession.Character.Hp > clientSession.Character.HpLoad())
                {
                    clientSession.Character.Hp = (int)clientSession.Character.HpLoad();
                }

                if (clientSession.Character.Mp > clientSession.Character.MpLoad())
                {
                    clientSession.Character.Mp = (int)clientSession.Character.MpLoad();
                }

                clientSession.Character.Quests = new ConcurrentDictionary <Guid, CharacterQuest>(_characterQuestDao
                                                                                                 .Where(s => s.CharacterId == clientSession.Character.CharacterId).ToDictionary(x => x.Id, x =>
                {
                    var charquest   = x.Adapt <CharacterQuest>();
                    charquest.Quest = _quests.First(s => s.QuestId == charquest.QuestId).Adapt <GameObject.Quest>();
                    charquest.Quest.QuestObjectives =
                        _questObjectives.Where(s => s.QuestId == charquest.QuestId).ToList();
                    return(charquest);
                }));
                clientSession.Character.QuicklistEntries = _quickListEntriesDao
                                                           .Where(s => s.CharacterId == clientSession.Character.CharacterId).ToList();
                clientSession.Character.StaticBonusList = _staticBonusDao
                                                          .Where(s => s.CharacterId == clientSession.Character.CharacterId).ToList();
                clientSession.Character.Titles = _titleDao
                                                 .Where(s => s.CharacterId == clientSession.Character.CharacterId).ToList();
                clientSession.SendPacketAsync(new OkPacket());
            }
            catch (Exception ex)
            {
                _logger.Error("Select character failed.", ex);
            }
            return(Task.CompletedTask);
        }