thewar_server/Server/Manager/ItemManager.cs

using NLog;
using Server.SQL;
using Server.System;

namespace Server.Manager
{
    public class ItemManager
    {
        private static readonly NLog.ILogger logger = LogManager.GetCurrentClassLogger();

        User user;

        public ItemBox box;

        public ItemManager(User user)
        {
            this.user = user;
            box = new ItemBox(user);
        }

        public void addReward(long reward)
        {
            RewardData rewardData;

            //아이템 획득 처리
            if (reward == 0)
            {
                //따로 처리가 필요함.
            }
            else
            {
                rewardData = Statics.rewardExcel.getRewardData(reward);
                switch (rewardData.reward_item_type)
                {
                    case eRewardItemType.gold:
                        user.gold += rewardData.return_count;
                        break;
                    case eRewardItemType.freecash:
                        user.free_cash += rewardData.return_count;
                        break;
                    case eRewardItemType.paycash:
                        user.pay_cash += rewardData.return_count;
                        break;
                    case eRewardItemType.character:
                        for (int n = 0; n < rewardData.return_count; n++)
                        {
                            DeckUnitInfo deckUnitInfo = new DeckUnitInfo();
                            deckUnitInfo.user_id = user.id;
                            deckUnitInfo.unit_data_id = rewardData.return_item;
                            box.Add(deckUnitInfo);
                        }
                        break;
                    case eRewardItemType.equipment:
                        Random rand = new Random();
                        for (int n = 0; n < rewardData.return_count; n++)
                        {
                            Equipment equipment = new Equipment();
                            equipment.user_id = user.id;
                            equipment.equip_unit = 0;
                            equipment.rand_stats = rand.Next(5);
                            equipment.equipment_data_id = rewardData.return_item;
                            box.Add(equipment);
                        }
                        break;
                    case eRewardItemType.consumable:
                        ConsumableItem consumableItem = new ConsumableItem();
                        consumableItem.user_id = user.id;
                        consumableItem.consumable_item_data_id = rewardData.return_item;
                        consumableItem.count = rewardData.return_count;
                        box.Add(consumableItem);
                        break;
                    case eRewardItemType.etc:
                        EtcItem etcItem = new EtcItem();
                        etcItem.user_id = user.id;
                        etcItem.etc_item_data_id = rewardData.return_item;
                        etcItem.count = rewardData.return_count;
                        box.Add(etcItem);
                        break;
                    default:
                        throw new RuntimeException("Not case", Error.nodata);


                }
            }
        }

        public void addUnit(long unitDataId)
        {
            DeckUnitInfo deckUnitInfo = new DeckUnitInfo();
            deckUnitInfo.user_id = user.id;
            deckUnitInfo.unit_data_id = unitDataId;
            box.Add(deckUnitInfo);
        }

        //리워드 아이탬 획득 코드 작성
        //패키지 구매시 패키지를 전부 풀어서 아이탬을 획득하는 코드 작성
    }

    public class ItemBox
    {
        //유닛
        List<DeckUnitInfo> _deckUnitInfo;
        public List<DeckUnitInfo> deckUnitInfo { get { return _deckUnitInfo; } }
        public List<DeckUnitInfo> addDeckUnitInfo;

        //장비
        List<Equipment> _equipment;
        public List<Equipment> equipment { get { return _equipment; } }
        public List<Equipment> addEquipment;
        
        //소모품
        List<ConsumableItem> _consumableItem;
        public List<ConsumableItem> consumableItem { get { return _consumableItem; } }
        public List<ConsumableItem> addConsumableItem;

        //기타
        List<EtcItem> _etcItem;
        public List<EtcItem> etcItem { get { return _etcItem; } }
        public List<EtcItem> addEtcItem;

        User user;
        public ItemBox(User user)
        {
            this.user = user;
            _deckUnitInfo = Statics.deckUnitInfoSQL.SelectUid(user.id);
            _equipment = Statics.equipmentrSQL.SelectUid(user.id);
            _consumableItem = Statics.consumableItemSQL.SelectUid(user.id);
            _etcItem = Statics.etcItemSQL.SelectUid(user.id);
            addDeckUnitInfo = new List<DeckUnitInfo>();
            addEquipment = new List<Equipment>();
            addConsumableItem = new List<ConsumableItem>();
            addEtcItem = new List<EtcItem>();
        }

        public void SaveSQL()
        {
            Statics.userSQL.Update(user);
            Statics.userSQL.SaveChanges();
            if (addDeckUnitInfo.Count != 0)
            {
                Statics.deckUnitInfoSQL.Insert(addDeckUnitInfo);
                Statics.deckUnitInfoSQL.SaveChanges();
            }
            if (addEquipment.Count != 0)
            {
                Statics.equipmentrSQL.Insert(addEquipment);
                Statics.equipmentrSQL.SaveChanges();
            }
            if (addConsumableItem.Count != 0)
            {
                for (int n = 0; n < addConsumableItem.Count; n++)
                {
                    if (addConsumableItem[n].id == 0)
                        Statics.consumableItemSQL.Insert(addConsumableItem[n]);
                    else
                        Statics.consumableItemSQL.Update(_consumableItem[_consumableItem.FindIndex(item => item.id == addConsumableItem[n].id)]);

                }
                Statics.consumableItemSQL.SaveChanges();
            }
            if (addEtcItem.Count != 0)
            {
                for (int n = 0; n < addEtcItem.Count; n++)
                {
                    if (addEtcItem[n].id == 0)
                        Statics.etcItemSQL.Insert(addEtcItem[n]);
                    else
                        Statics.etcItemSQL.Update(_etcItem[_etcItem.FindIndex(item => item.id == addEtcItem[n].id)]);
                }
                Statics.etcItemSQL.SaveChanges();
            }
        }

        public bool Add(DeckUnitInfo item)
        {
            int index = _deckUnitInfo.FindIndex(n => n.unit_data_id == item.unit_data_id);
            int addIndex = addDeckUnitInfo.FindIndex(n => n.unit_data_id == item.unit_data_id);
            if (index == -1)
            {
                _deckUnitInfo.Add(item);
            }
            else
            {
                _deckUnitInfo[index].count += item.count;
                item.id = _deckUnitInfo[index].id;
            }
            if (addIndex == -1)
            {
                addDeckUnitInfo.Add(item);
            }
            else
            {
                addDeckUnitInfo[index].count += item.count;
            }

            return true;
        }

        public bool Add(List<DeckUnitInfo> items)
        {
            foreach (DeckUnitInfo item in items)
            {
                if (!Add(item))
                    return false;
            }
            return true;
        }

        public bool Add(Equipment item)
        {
            _equipment.Add(item);
            addEquipment.Add(item);
            return true;
        }

        public bool Add(List<Equipment> items)
        {
            foreach (Equipment item in items)
            {
                if (!Add(item))
                    return false;
            }
            return true;
        }

        public bool Add(ConsumableItem item)
        {
            int index = _consumableItem.FindIndex(n => n.consumable_item_data_id == item.consumable_item_data_id);
            int addIndex = addConsumableItem.FindIndex(n => n.consumable_item_data_id == item.consumable_item_data_id);
            if (index == -1)
            {
                _consumableItem.Add(item);
            }
            else
            {
                _consumableItem[index].count += item.count;
                item.id = _consumableItem[index].id;
            }
            if (addIndex == -1)
            {
                addConsumableItem.Add(item);
            }
            else
            {
                addConsumableItem[index].count += item.count;
            }
            return true;
        }

        public bool Add(List<ConsumableItem> items)
        {
            foreach(ConsumableItem item in items)
            {
                if (!Add(item))
                    return false;
            }
            return true;
        }

        public bool Add(EtcItem item)
        {
            int index = _etcItem.FindIndex(n => n.etc_item_data_id == item.etc_item_data_id);
            int addIndex = addEtcItem.FindIndex(n => n.etc_item_data_id == item.etc_item_data_id);
            if (index == -1)
            {
                _etcItem.Add(item);
            }
            else
            {
                _etcItem[index].count += item.count;
                item.id = _etcItem[index].id;
            }
            if (addIndex == -1)
            {
                addEtcItem.Add(item);
            }
            else
            {
                addEtcItem[index].count += item.count;
            }
            return true;
        }

        public bool Add(List<EtcItem> items)
        {
            foreach (EtcItem item in items)
            {
                if (!Add(item))
                    return false;
            }
            return true;
        }
    }

}