Esempio n. 1
0
 public WvsShopSocket(
     IChannel channel,
     uint seqSend,
     uint seqRecv,
     WvsShop wvsShop
     ) : base(channel, seqSend, seqRecv)
     => WvsShop = wvsShop;
Esempio n. 2
0
        private void PingUpdater()
        {
            WvsLogin.OnKeepAlive();
            WvsShop.OnKeepAlive();

            for (int i = 0; i < WvsGames.Length; i++)
            {
                WvsGames[i].OnKeepAlive();
            }
        }
Esempio n. 3
0
        private async Task OnTransferFieldRequest(IPacket packet)
        {
            var service = WvsShop.Peers
                          .OfType <GameServiceInfo>()
                          .Where(g => g.WorldID == Character.Data.WorldID)
                          .FirstOrDefault(g => g.Name == Character.Data.Account.PreviousConnectedService);

            if (service != null &&
                !await WvsShop.TryMigrateTo(this, Character, service))
            {
                await Disconnect();
            }
        }
Esempio n. 4
0
        public void Stop()
        {
            TimerUpdate.Stop();
            TimerPing.Stop();

            WvsLogin.Stop();
            WvsShop.Stop();

            for (int i = 0; i < WvsGames.Length; i++)
            {
                WvsGames[i].Stop();
            }

            Log.Info("[WvsCenter] Stopped");
        }
Esempio n. 5
0
        //-----------------------------------------------------------------------------
        public WvsCenter(IConfiguration config)
        {
            Config = config;

            var channels = config.GetValue <int>("channels");

            WvsLogin = new WvsLogin(this);
            WvsShop  = new WvsShop(this);

            WvsGames = new WvsGame[channels];

            for (int i = 0; i < WvsGames.Length; i++)
            {
                var channel = (byte)i;
                WvsGames[i] = new WvsGame(this, channel);
            }
        }
Esempio n. 6
0
        //-----------------------------------------------------------------------------

        public void Start()
        {
            if (StartupHealthCheck())
            {
                MasterManager.Load(0);
                //EmojiManager.Instance.LoadAll();

                WvsLogin.Start();
                WvsGames.ToList().ForEach(x => x.Start());

                MasterManager.SetEventManager(WvsGames[0]);

                WvsShop.Start();

                TimerUpdate          = WvsLogin.CreateTimer();        //Temp
                TimerUpdate.Interval = Constants.GlobalUpdateDelay;
                TimerUpdate.Elapsed  = GlobalUpdater;
                TimerUpdate.Start();

                TimerPing          = WvsLogin.CreateTimer();        //Temp
                TimerPing.Interval = Constants.KeepAliveDelay;
                TimerPing.Elapsed  = PingUpdater;
                TimerPing.Start();

                //FetchLastDailyQuestRecordReset();

                Log.Info("[WvsCenter] Started");

                if (Constants.AllowAccountLoginOverride)
                {
                    Log.Info("[WARNING] Be advised, account login override is enabled.");
                }
            }
            else
            {
                Log.Error("[WvsCenter] Failed startup health check.");
            }
        }
Esempio n. 7
0
 public WvsShopSocketFactory(WvsShop wvsShop)
 => _wvsShop = wvsShop;
Esempio n. 8
0
 public WvsShopClient(WvsShop login, Socket socket) : base(socket)
 {
     Server = login;
 }
Esempio n. 9
0
        private async Task OnMigrateIn(IPacket packet)
        {
            var characterID = packet.Decode <int>();

            using (var db = WvsShop.DataContextFactory.Create())
            {
                var character = db.Characters
                                .Include(c => c.Data)
                                .ThenInclude(a => a.Account)
                                .Include(c => c.Data)
                                .ThenInclude(c => c.Locker)
                                .ThenInclude(c => c.Items)
                                .Include(c => c.Data)
                                .ThenInclude(c => c.Trunk)
                                .Include(c => c.Inventories)
                                .ThenInclude(c => c.Items)
                                .Include(c => c.WishList)
                                .Single(c => c.ID == characterID);

                if (!await WvsShop.TryMigrateFrom(character, WvsShop.Info))
                {
                    await Disconnect();
                }
                Character = character;

                using (var p = new Packet(SendPacketOperations.SetCashShop))
                {
                    character.EncodeData(p);

                    p.Encode <bool>(true);                              // m_bCashShopAuthorized
                    p.Encode <string>(character.Data.Account.Username); // m_sNexonClubID

                    var templates = WvsShop.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);
                }

                var gifts = db.GiftList
                            .Where(g => g.CharacterID == characterID)
                            .ToList();

                AvailableNotes = gifts.Count;
                gifts
                .Select(g =>
                {
                    var commodity = WvsShop.CommodityManager.Get(g.CommoditySN);
                    var template  = WvsShop.TemplateManager.Get <ItemTemplate>(commodity.ItemID);
                    return(commodity.ToItemSlot(template, g.SN));
                })
                .ForEach(i => character.Data.Locker.Items.Add(i));
                db.GiftList.RemoveRange(gifts);
                db.SaveChanges();

                using (var p = new Packet(SendPacketOperations.CashShopCashItemResult))
                {
                    p.Encode <byte>((byte)CashItemResult.LoadGift_Done);
                    p.Encode <short>((short)gifts.Count);
                    gifts.ForEach(g =>
                    {
                        var commodity = WvsShop.CommodityManager.Get(g.CommoditySN);

                        p.Encode <long>(g.SN);
                        p.Encode <int>(commodity.ItemID);
                        p.EncodeFixedString(g.BuyCharacterName, 13);
                        p.EncodeFixedString(g.Text, 73);
                    });
                    await SendPacket(p);
                }

                await SendLockerData();
                await SendWishListData();
                await SendCashData();
            }
        }