protected override void HandlePacket(Client client, MarketRemove packet)
        {
            client.Manager.Logic.AddPendingAction(t =>
            {
                var player = client.Player;
                if (player == null || IsTest(client))
                {
                    return;
                }


                DbMarketData data = player.Manager.Database.GetMarketData(packet.Id);
                if (data == null) /* Incase the item was removed by MarketSweeper or someone bought it */
                {
                    client.SendPacket(new MarketRemoveResult
                    {
                        Code        = MarketRemoveResult.ITEM_DOESNT_EXIST,
                        Description = "This item was already bought or removed."
                    });
                    return;
                }

                if (data.SellerId != player.AccountId) /* Incase someone tries to remove someone else' item */
                {
                    client.SendPacket(new MarketRemoveResult
                    {
                        Code        = MarketRemoveResult.NOT_YOUR_ITEM,
                        Description = "You cannot remove an item that isnt yours."
                    });
                    return;
                }

                /* Remove it from the market */
                player.Manager.Database.RemoveMarketData(client.Account, data.Id);
                player.Manager.Database.AddGift(client.Account, data.ItemType);

                List <MarketData> myOffers = new List <MarketData>();
                for (var i = 0; i < client.Account.MarketOffers.Length; i++)
                {
                    DbMarketData result = player.Manager.Database.GetMarketData(client.Account.MarketOffers[i]);
                    myOffers.Add(new MarketData
                    {
                        Id         = result.Id,
                        ItemType   = result.ItemType,
                        SellerName = result.SellerName,
                        SellerId   = result.SellerId,
                        Currency   = (int)result.Currency,
                        Price      = result.Price,
                        StartTime  = result.StartTime,
                        TimeLeft   = result.TimeLeft
                    });
                }

                client.SendPacket(new MarketMyOffersResult
                {
                    Results = myOffers.ToArray()
                });
            });
        }
示例#2
0
        protected override void HandlePacket(Client client, MarketSearch packet)
        {
            client.Manager.Logic.AddPendingAction(t =>
            {
                var player = client.Player;
                if (player == null || IsTest(client))
                {
                    return;
                }

                DbMarketData[] query = DbMarketData.Get(player.Manager.Database.Conn, (ushort)packet.ItemType); /* Get all offers based on given type */

                /* There should probably be a max limit of how many items we can send, though since client does all the sorting
                 * its harder to add the limit. Though, if you were to make sorting client sided (prevents the user from choosing sorttypes)
                 * then yes, you could add a limit */
                List <MarketData> results = new List <MarketData>();
                foreach (var i in query)
                {
                    if (i.SellerId == player.AccountId)
                    {
                        continue; /* Dont send our own items */
                    }

                    results.Add(new MarketData
                    {
                        Id         = i.Id,
                        ItemType   = i.ItemType,
                        SellerName = i.SellerName,
                        SellerId   = i.SellerId,
                        Price      = i.Price,
                        TimeLeft   = i.TimeLeft,
                        StartTime  = i.StartTime,
                        Currency   = (int)i.Currency
                    });
                }

                if (results.Count == 0) /* No items found */
                {
                    client.SendPacket(new MarketSearchResult
                    {
                        Results     = new MarketData[0],
                        Description = "There is no items currently being sold with this type."
                    });
                    return;
                }

                client.SendPacket(new MarketSearchResult
                {
                    Results     = results.ToArray(),
                    Description = "" /* Has to be empty, if not client will count it as an error */
                });
            });
        }
        protected override void HandlePacket(Client client, MarketMyOffers packet)
        {
            client.Manager.Logic.AddPendingAction(t =>
            {
                var player = client.Player;
                if (player == null || IsTest(client))
                {
                    return;
                }

                List <MarketData> myOffers = new List <MarketData>();
                for (var i = 0; i < client.Account.MarketOffers.Length; i++)
                {
                    DbMarketData result = player.Manager.Database.GetMarketData(client.Account.MarketOffers[i]);
                    if (result == null) /* This will only happend if someone bought our item */
                    {
                        continue;
                    }

                    myOffers.Add(new MarketData
                    {
                        Id         = result.Id,
                        ItemType   = result.ItemType,
                        SellerName = result.SellerName,
                        SellerId   = result.SellerId,
                        Currency   = (int)result.Currency,
                        Price      = result.Price,
                        StartTime  = result.StartTime,
                        TimeLeft   = result.TimeLeft
                    });
                }

                client.SendPacket(new MarketMyOffersResult
                {
                    Results = myOffers.ToArray()
                });
            });
        }
示例#4
0
        protected override void HandlePacket(Client client, MarketBuy packet)
        {
            client.Manager.Logic.AddPendingAction(t =>
            {
                var acc = client.Account;
                if (client.Player == null || IsTest(client))
                {
                    return;
                }

                DbMarketData data = client.Manager.Database.GetMarketData(packet.Id);
                if (data == null) /* Make sure the item exist before buying it */
                {
                    client.SendPacket(new MarketBuyResult
                    {
                        Code        = MarketBuyResult.ITEM_DOESNT_EXIST,
                        Description = "Item was taken down or bought."
                    });
                    return;
                }

                if (data.SellerId == client.Player.AccountId) /* If we somehow try to buy our own item */
                {
                    client.SendPacket(new MarketBuyResult
                    {
                        Code        = MarketBuyResult.MY_ITEM,
                        Description = "You cannot buy your own item."
                    });
                    return;
                }

                int currencyAmount = data.Currency == CurrencyType.Fame ? acc.Fame : acc.Credits;
                if (currencyAmount < data.Price) /* Make sure we have enough to buy the item */
                {
                    client.SendPacket(new MarketBuyResult
                    {
                        Code        = MarketBuyResult.CANT_AFFORD,
                        Description = "You cannot afford this item."
                    });
                    return;
                }

                string currency = data.Currency == CurrencyType.Fame ? "fame" : "gold";
                Item item       = client.Manager.Resources.GameData.Items[data.ItemType];

                /* Update the sellers currency */
                var sellerAccount = client.Manager.Database.GetAccount(data.SellerId);
                client.Manager.Database.UpdateCurrency(sellerAccount, data.Price, data.Currency).ContinueWith(r =>
                {
                    /* Incase he is online, we let him know someone bought his item */
                    var seller = client.Manager.Clients.Keys.SingleOrDefault(_ => _.Account != null && _.Account.AccountId == data.SellerId);
                    if (seller != null)
                    {
                        seller.Player.SendInfo($"{client.Player.Name} has just bought your {item.ObjectId} for {data.Price} {currency}!");

                        /* Dynamically update his currency if hes online */
                        seller.Player.CurrentFame = sellerAccount.Fame;
                        seller.Player.Credits     = sellerAccount.Credits;
                    }
                    client.Manager.Database.ReloadAccount(sellerAccount);
                });
                client.Manager.Database.RemoveMarketData(sellerAccount, data.Id);


                /* Update the buyers currency */
                client.Manager.Database.UpdateCurrency(acc, -data.Price, data.Currency).ContinueWith(_ =>
                {
                    client.Player.CurrentFame = acc.Fame;
                    client.Player.Credits     = acc.Credits;
                    client.Manager.Database.ReloadAccount(acc);
                });
                client.Manager.Database.AddGift(acc, data.ItemType);

                client.SendPacket(new MarketBuyResult
                {
                    Code        = -1,
                    Description = $"Successfully bought {item.ObjectId} for {data.Price} {currency}!",
                    OfferId     = data.Id /* We send back the ID we bought, so we can remove it from the list */
                });
            });
        }