Beispiel #1
0
        public async Task RepairItemHandler(GameSession session, CRepairItemReqMessage message)
        {
            var shop = GameServer.Instance.ResourceCache.GetShop();

            foreach (var id in message.Items)
            {
                var item = session.Player.Inventory[id];
                if (item == null)
                {
                    Logger.ForAccount(session)
                    .Error("Item {id} not found", id);
                    session.SendAsync(new SRepairItemAckMessage {
                        Result = ItemRepairResult.Error0
                    });
                    return;
                }
                if (item.Durability == -1)
                {
                    Logger.ForAccount(session)
                    .Error("Item {item} can not be repaired", new { item.ItemNumber, item.PriceType, item.PeriodType, item.Period });
                    session.SendAsync(new SRepairItemAckMessage {
                        Result = ItemRepairResult.Error1
                    });
                    return;
                }

                var cost = item.CalculateRepair();
                if (session.Player.PEN < cost)
                {
                    session.SendAsync(new SRepairItemAckMessage {
                        Result = ItemRepairResult.NotEnoughMoney
                    });
                    return;
                }

                var price = shop.GetPrice(item);
                if (price == null)
                {
                    Logger.ForAccount(session)
                    .Error("No shop entry found for {item}", new { item.ItemNumber, item.PriceType, item.PeriodType, item.Period });
                    session.SendAsync(new SRepairItemAckMessage {
                        Result = ItemRepairResult.Error4
                    });
                    return;
                }
                if (item.Durability >= price.Durability)
                {
                    await session.SendAsync(new SRepairItemAckMessage { Result = ItemRepairResult.OK, ItemId = item.Id });

                    continue;
                }

                item.Durability     = price.Durability;
                session.Player.PEN -= cost;

                await session.SendAsync(new SRepairItemAckMessage { Result = ItemRepairResult.OK, ItemId = item.Id });

                await session.SendAsync(new SRefreshCashInfoAckMessage { PEN = session.Player.PEN, AP = session.Player.AP });
            }
        }
Beispiel #2
0
        public async Task <bool> OnHandle(MessageContext context, CRepairItemReqMessage message)
        {
            var session = context.GetSession <Session>();
            var plr     = session.Player;
            var logger  = plr.AddContextToLogger(_logger);

            foreach (var id in message.Items)
            {
                var item = session.Player.Inventory[id];
                if (item == null)
                {
                    logger.Warning("Item={ItemId} not found", id);
                    session.Send(new SRepairItemAckMessage(ItemRepairResult.Error0, 0));
                    return(true);
                }

                if (item.Durability == -1)
                {
                    logger.Warning("Item={ItemId} can not be repaired", id);
                    session.Send(new SRepairItemAckMessage(ItemRepairResult.Error1, 0));
                    return(true);
                }

                var cost = item.CalculateRepair();
                if (plr.PEN < cost)
                {
                    session.Send(new SRepairItemAckMessage(ItemRepairResult.NotEnoughMoney, 0));
                    return(true);
                }

                var price = item.GetShopPrice();
                if (price == null)
                {
                    logger.Warning("No shop entry found item={ItemId}", id);
                    session.Send(new SRepairItemAckMessage(ItemRepairResult.Error2, 0));
                    return(true);
                }

                if (item.Durability >= price.Durability)
                {
                    session.Send(new SRepairItemAckMessage(ItemRepairResult.OK, item.Id));
                    continue;
                }

                item.Durability = price.Durability;
                plr.PEN        -= cost;

                session.Send(new SRepairItemAckMessage(ItemRepairResult.OK, item.Id));
                plr.SendMoneyUpdate();
            }

            return(true);
        }
        public async Task RepairItemHandler(GameSession session, CRepairItemReqMessage message)
        {
            var shop = GameServer.Instance.ResourceCache.GetShop();

            foreach (var id in message.Items)
            {
                var item = session.Player.Inventory[id];
                if (item == null)
                {
                    _logger.Error()
                    .Account(session)
                    .Message("Item {0} not found", id)
                    .Write();
                    await session.SendAsync(new SRepairItemAckMessage { Result = ItemRepairResult.Error0 })
                    .ConfigureAwait(false);

                    return;
                }
                if (item.Durability == -1)
                {
                    _logger.Error()
                    .Account(session)
                    .Message("Item {0} {1} {2} {3} can not be repaired", item.ItemNumber, item.PriceType, item.PeriodType, item.Period)
                    .Write();
                    await session.SendAsync(new SRepairItemAckMessage { Result = ItemRepairResult.Error1 })
                    .ConfigureAwait(false);

                    return;
                }

                var cost = item.CalculateRepair();
                if (session.Player.PEN < cost)
                {
                    await session.SendAsync(new SRepairItemAckMessage { Result = ItemRepairResult.NotEnoughMoney })
                    .ConfigureAwait(false);

                    return;
                }

                var price = shop.GetPrice(item);
                if (price == null)
                {
                    _logger.Error()
                    .Account(session)
                    .Message("No shop entry found for {0} {1} {2} {3}", item.ItemNumber, item.PriceType, item.PeriodType, item.Period)
                    .Write();
                    await session.SendAsync(new SRepairItemAckMessage { Result = ItemRepairResult.Error4 })
                    .ConfigureAwait(false);

                    return;
                }
                if (item.Durability >= price.Durability)
                {
                    await session.SendAsync(new SRepairItemAckMessage { Result = ItemRepairResult.OK, ItemId = item.Id })
                    .ConfigureAwait(false);

                    continue;
                }

                item.Durability     = price.Durability;
                session.Player.PEN -= cost;

                using (var scope = new DataAccessScope())
                {
                    var playerDto = GameDatabase.Instance.Players.GetReference((int)session.Player.Account.Id);
                    playerDto.PEN = (int)session.Player.PEN;

                    var itemDto = GameDatabase.Instance.PlayerItems.GetReference((int)item.Id);
                    itemDto.Durability = item.Durability;

                    await scope.CompleteAsync()
                    .ConfigureAwait(false);
                }

                await session.SendAsync(new SRepairItemAckMessage { Result = ItemRepairResult.OK, ItemId = item.Id })
                .ConfigureAwait(false);

                await session.SendAsync(new SRefreshCashInfoAckMessage { PEN = session.Player.PEN, AP = session.Player.AP })
                .ConfigureAwait(false);
            }
        }