3335 符印修改

client_linchunjie

2019-03-19 03fd13a40f729f12851b971f027806120a186e03

3335 符印修改

 System/GatheringSoul/VirtualPackModel.cs

@@ -99,6 +99,19 @@
            return count;

        }



        public void GetItemIndexs(PackType packType, ref List<int> list)

        {

            list.Clear();

            List<VirtualPackItem> _list;

            if (virtualPackItems.TryGetValue(packType, out _list))

            {

                for (int i = 0; i < _list.Count; i++)

                {

                    list.Add(_list[i].index);

                }

            }

        }



        public bool TryGetItems(PackType packType, out List<int> list)

        {

            list = new List<int>();


 System/Rune/RuneResolveModel.cs

New file
@@ -0,0 +1,118 @@
using System;

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
namespace Snxxz.UI

{

    public class RuneResolveModel : Model, IBeforePlayerDataInitialize, IPlayerLoginOk

    {

        Dictionary<int, float> m_RuneBaseResolveSplinters;



        bool specialItemColorSign = false;



        RuneNewModel runeModel { get { return ModelCenter.Instance.GetModel<RuneNewModel>(); } }



        public override void Init()

        {

            StageLoad.Instance.onStageLoadFinish += OnStageLoadFinish;

        }



        public void OnBeforePlayerDataInitialize()

        {

        }



        public void OnPlayerLoginOk()

        {

        }



        public override void UnInit()

        {

            StageLoad.Instance.onStageLoadFinish -= OnStageLoadFinish;

        }



        private void OnStageLoadFinish()

        {

            if (!(StageLoad.Instance.currentStage is DungeonStage))

            {

                specialItemColorSign = false;

            }

        }



        void ParseConfig()

        {

            var config = FuncConfigConfig.Get("RuneExp");

            m_RuneBaseResolveSplinters = ConfigParse.GetDic<int, float>(config.Numerical4);

        }



        public bool IsQualitySign(int itemColor)

        {

            if (itemColor == 4)

            {

                return specialItemColorSign;

            }

            var playerId = PlayerDatas.Instance.baseData.PlayerID;

            return LocalSave.GetBool(StringUtility.Contact("RuneBreakSelect_", playerId, "_", itemColor), itemColor == 1);

        }



        public bool IsComposeSource(int sourceType)

        {

            if (sourceType == 0 || sourceType == 2)

            {

                return true;

            }

            return false;

        }



        public float GetRuneResolveGetSplinters(int id, int level, bool fromCompose = false)

        {

            var result = 0f;

            var config = ItemConfig.Get(id);

            var _treasureSoul = ModelCenter.Instance.GetModel<TreasureSoulModel>();

            var _upper = (float)_treasureSoul.GetTreasureSoulValue((int)TreasurePrivilege.RuneBreakExpAdd) / 10000;

            if (config.Type == RuneNewModel.RUNE_CREAMTYPE)

            {

                return config.EffectValueA1 + config.EffectValueA1 * _upper;

            }

            for (int i = 1; i <= level; i++)

            {

                if (i == 1 && !fromCompose)

                {

                    result += m_RuneBaseResolveSplinters[config.ItemColor] +

                        m_RuneBaseResolveSplinters[config.ItemColor] * _upper;

                }

                else

                {

                    result += runeModel.GetLevelUpRequireRuneEssence(id, i - 1);

                }

            }

            return result;

        }



        public float GetRuneResolveGetSouls(int id)

        {

            ItemConfig config = ItemConfig.Get(id);

            var _treasureSoul = ModelCenter.Instance.GetModel<TreasureSoulModel>();

            var _upper = (float)_treasureSoul.GetTreasureSoulValue((int)TreasurePrivilege.RuneBreakExpAdd) / 10000;

            if (config.Type == RuneNewModel.RUNE_CREAMTYPE)

            {

                return config.EffectValueA1 * _upper;

            }

            else

            {

                return m_RuneBaseResolveSplinters[config.ItemColor] * _upper;

            }

        }



        public void SetQualityMark(int itemColor, bool mark)

        {

            if (itemColor == 4)

            {

                specialItemColorSign = mark;

                return;

            }

            var playerId = PlayerDatas.Instance.baseData.PlayerID;

            LocalSave.SetBool(StringUtility.Contact("RuneBreakSelect_", playerId, "_", itemColor), mark);

        }

    }

}


 System/Rune/RuneResolveModel.cs.meta

New file
@@ -0,0 +1,12 @@
fileFormatVersion: 2
guid: 89a6ca1ecdbe4244dbcd205c9827f083
timeCreated: 1552985089
licenseType: Pro
MonoImporter:
  serializedVersion: 2
  defaultReferences: []
  executionOrder: 0
  icon: {instanceID: 0}
  userData: 
  assetBundleName: 
  assetBundleVariant: 

 System/Rune/RuneResolveWin.cs

@@ -17,7 +17,7 @@
        [SerializeField] Button m_Resolve;

        [SerializeField] ScrollerController m_Controller;

        [SerializeField] List<Button> m_CheckBtns;

        [SerializeField] List<Image> m_CheckMarks;

        [SerializeField] Transform[] m_CheckSigns;

        [SerializeField] UIEffect m_FlutterEffect;

        [SerializeField] UIEffect m_AbsorbEffect;

        [SerializeField] Button m_JumpBtn0;

@@ -27,10 +27,13 @@


        List<ushort> resolveItems = new List<ushort>();

        List<Transform> resolveObjs = new List<Transform>();

        List<int> itemIndexs = new List<int>();

        Dictionary<int, bool> resolveSigns = new Dictionary<int, bool>();



        bool doResolveItem = false;



        RuneNewModel model { get { return ModelCenter.Instance.GetModel<RuneNewModel>(); } }



        RuneResolveModel runeResolveModel { get { return ModelCenter.Instance.GetModel<RuneResolveModel>(); } }

        VirtualPackModel virtualPackModel { get { return ModelCenter.Instance.GetModel<VirtualPackModel>(); } }



        TreasureSoulModel treasureSoulModel { get { return ModelCenter.Instance.GetModel<TreasureSoulModel>(); } }

@@ -43,13 +46,13 @@


        protected override void AddListeners()

        {

            m_Resolve.onClick.AddListener(OnBreakBtn);

            m_Resolve.onClick.AddListener(OnResolve);

            for (int i = 0; i < m_CheckBtns.Count; i++)

            {

                int _type = i + 1;

                int itemColor = i + 1;

                m_CheckBtns[i].onClick.AddListener(() =>

                {

                    OnClickCheck(_type);

                    OnClickCheck(itemColor);

                });

            }

            m_JumpBtn0.onClick.AddListener(OnJumpRuneTower);

@@ -59,8 +62,6 @@
        protected override void OnPreOpen()

        {

            virtualPackModel.virtualPackRefresh += VirtualPackRefresh;

            model.OnRefreshRuneExp += OnUpdateItemNum;

            model.OnRefreshBreakRune += OnUpdateItemNum;

            PlayerDatas.Instance.playerDataRefreshEvent += PlayerDataRefreshInfoEvent;



            doResolveItem = false;

@@ -79,8 +80,6 @@
        {

            doResolveItem = false;

            virtualPackModel.virtualPackRefresh -= VirtualPackRefresh;

            model.OnRefreshRuneExp -= OnUpdateItemNum;

            model.OnRefreshBreakRune -= OnUpdateItemNum;

            PlayerDatas.Instance.playerDataRefreshEvent -= PlayerDataRefreshInfoEvent;



            StopAllCoroutines();

@@ -100,15 +99,19 @@
            }

        }



        private void OnBreakBtn()

        private void OnResolve()

        {

            resolveItems.Clear();

            for (int i = 0; i < model.runeBreakEnableDict.Count; i++)

            foreach (var key in resolveSigns.Keys)

            {

                if (model.runeBreakEnableDict[i])

                if (key < itemIndexs.Count)

                {

                    RuneData data = model.runeBreakList[i];

                    resolveItems.Add((ushort)data.index);

                    var index = itemIndexs[key];

                    RuneItem item;

                    if (virtualPackModel.TryGetItem(PackType.RunePack, index, out item))

                    {

                        resolveItems.Add((ushort)item.index);

                    }

                }

            }

            if (resolveItems.Count < 1)

@@ -116,56 +119,52 @@
                ServerTipDetails.DisplayNormalTip(Language.Get("L1059"));

                return;

            }

            ushort[] placeIndexs = null;

            while (resolveItems.Count > 0)



            var page = Mathf.CeilToInt((float)resolveItems.Count / 50);

            doResolveItem = true;

            for (int i = 0; i < page; i++)

            {

                doResolveItem = true;

                CA566_tagCMRuneDecompose resolve = new CA566_tagCMRuneDecompose();

                resolve.QualityCnt = 0;

                resolve.QualityList = new byte[0];

                if (resolveItems.Count > 50)

                {

                    placeIndexs = new ushort[50];

                    resolve.Count = 50;

                    resolveItems.CopyTo(0, placeIndexs, 0, 50);

                    resolveItems.RemoveRange(0, 50);

                }

                else

                {

                    placeIndexs = new ushort[resolveItems.Count];

                    resolve.Count = (byte)placeIndexs.Length;

                    resolveItems.CopyTo(placeIndexs);

                    resolveItems.Clear();

                }

                resolve.PlaceIndexList = placeIndexs;

                GameNetSystem.Instance.SendInfo(resolve);

                ushort[] resolves = resolveItems.Skip(i * 50).Take((i < page - 1) ? 50 : (resolveItems.Count - i * 50)).ToArray();

                var pak = new CA566_tagCMRuneDecompose();

                pak.QualityCnt = 0;

                pak.QualityList = new byte[0];

                pak.PlaceIndexList = resolves;

                pak.Count = (byte)resolves.Length;

                GameNetSystem.Instance.SendInfo(pak);

            }

        }

        private void OnClickCheck(int type)



        void OnClickCheck(int itemColor)

        {

            bool check = model.IsQualityMark(type);

            OnCheck(type, !check);

            bool check = runeResolveModel.IsQualitySign(itemColor);

            OnCheck(itemColor, !check);

        }

        private void OnCheck(int type, bool check)



        private void OnCheck(int itemColor, bool check)

        {

            model.SetQualityMark(type, check);

            m_CheckMarks[type - 1].gameObject.SetActive(model.IsQualityMark(type));

            for (int i = 0; i < model.runeBreakList.Count; i++)

            runeResolveModel.SetQualityMark(itemColor, check);



            var checkSign = GetCheckSign(itemColor);



            if (checkSign != null)

            {

                RuneData _data = model.runeBreakList[i];

                var _itemCfg = ItemConfig.Get(_data.id);

                if (_itemCfg.ItemColor == type && _itemCfg.Type == RuneModel.RUNE_TYPE)

                checkSign.gameObject.SetActive(runeResolveModel.IsQualitySign(itemColor));

            }



            for (int i = 0; i < itemIndexs.Count; i++)

            {

                var index = itemIndexs[i];

                RuneItem item;

                if (virtualPackModel.TryGetItem(PackType.RunePack, index, out item))

                {

                    if (!model.runeBreakEnableDict.ContainsKey(i))

                    var config = ItemConfig.Get(item.id);

                    if (config.ItemColor == itemColor && config.Type == RuneNewModel.RUNE_TYPE)

                    {

                        model.runeBreakEnableDict.Add(i, check);

                    }

                    else

                    {

                        model.runeBreakEnableDict[i] = check;

                        resolveSigns[i] = check;

                    }

                }

            }



            m_Controller.m_Scorller.RefreshActiveCellViews();

            RefreshResolveGetItems();

        }

@@ -189,48 +188,43 @@
            }

            else

            {

                RefreshBreak();

                DisplayResolveItems();

            }

        }



        IEnumerator Co_PlayEffect(float _t)

        {

            yield return WaitingForSecondConst.GetWaitForSeconds(_t);

            RefreshBreak();

            DisplayResolveItems();

            m_FlutterEffect.Play();

            m_FlutterEffect.OnComplete = OnFlutterComplete;

        }



        void RefreshBreak()

        void DisplayResolveItems()

        {

            resolveObjs.Clear();

            DisplayRunes();

            SetBreakDefault();

            ResetResolveSelect();

        }



        void SetBreakDefault()

        void ResetResolveSelect()

        {

            model.runeBreakEnableDict.Clear();

            for (int i = 0; i < model.runeBreakList.Count; i++)

            resolveSigns.Clear();



            for (int i = 0; i < itemIndexs.Count; i++)

            {

                if (!model.runeBreakEnableDict.ContainsKey(i))

                var index = itemIndexs[i];

                RuneItem item;

                if (virtualPackModel.TryGetItem(PackType.RunePack, index, out item))

                {

                    RuneData _data = model.runeBreakList[i];

                    var _itemCfg = ItemConfig.Get(_data.id);

                    if (_itemCfg.Type == RuneModel.RUNE_CREAMTYPE)

                    {

                        model.runeBreakEnableDict.Add(i, true);

                    }

                    else

                    {

                        model.runeBreakEnableDict.Add(i, false);

                    }

                    resolveSigns[i] = item.itemType == RuneModel.RUNE_CREAMTYPE;

                }

            }

            OnCheck(1, model.IsQualityMark(1));

            OnCheck(2, model.IsQualityMark(2));

            OnCheck(3, model.IsQualityMark(3));

            OnCheck(4, model.IsQualityMark(4));



            OnCheck(1, runeResolveModel.IsQualitySign(1));

            OnCheck(2, runeResolveModel.IsQualitySign(2));

            OnCheck(3, runeResolveModel.IsQualitySign(3));

            OnCheck(4, runeResolveModel.IsQualitySign(4));

        }



        private void OnFlutterComplete()

@@ -241,16 +235,15 @@
        void DisplayRunes()

        {

            m_Controller.Refresh();

            model.runeBreakList = model.GetPackRune().Values.ToList();

            if (model.runeBreakList != null && model.runeBreakList.Count > 0)



            virtualPackModel.GetItemIndexs(PackType.RunePack, ref itemIndexs);

            itemIndexs.Sort(Compare);

            int _line = Mathf.CeilToInt((float)itemIndexs.Count / 4);

            for (int i = 0; i < _line; i++)

            {

                model.runeBreakList.Sort(Compare);

                int _line = Mathf.CeilToInt((float)model.runeBreakList.Count / 4);

                for (int i = 0; i < _line; i++)

                {

                    m_Controller.AddCell(ScrollerDataType.Normal, i);

                }

                m_Controller.AddCell(ScrollerDataType.Normal, i);

            }



            m_Controller.Restart();

        }



@@ -259,23 +252,31 @@
            float _itemCnt = 0;

            float _magicCnt = 0;

            float _soulCnt = 0;

            foreach (int key in model.runeBreakEnableDict.Keys)

            foreach (int key in resolveSigns.Keys)

            {

                if (!model.runeBreakEnableDict[key])

                if (!resolveSigns[key])

                {

                    continue;

                }

                var _data = model.runeBreakList[key];

                _itemCnt += model.GetRuneBreakExp(_data);

                _soulCnt += model.GetRuneSoulBreakExp(_data);

                if (runeComposeModel.m_RuneBothPropertys.Contains(_data.id)

                    && model.ResolveFusionStone(_data.sourceType))



                if (key < itemIndexs.Count)

                {

                    var _composeCfg = RuneComposeConfig.Get(_data.id);

                    _magicCnt += (_composeCfg == null ? 0 : _composeCfg.NeedMJ);

                    var index = itemIndexs[key];

                    RuneItem item;

                    if (virtualPackModel.TryGetItem(PackType.RunePack, index, out item))

                    {

                        _itemCnt += runeResolveModel.GetRuneResolveGetSplinters(item.id, item.level);

                        _soulCnt += runeResolveModel.GetRuneResolveGetSouls(item.id);

                        if (model.IsMultiPropertyRune(item.id)

                            && runeResolveModel.IsComposeSource(item.sourceType))

                        {

                            var composeConfig = RuneComposeConfig.Get(item.id);

                            _magicCnt += (composeConfig == null ? 0 : composeConfig.NeedMJ);

                        }

                    }

                }

            }

            m_ItemCount1.text = UIHelper.ReplaceLargeNum(model.RuneSplinters);

            m_ItemCount1.text = UIHelper.ReplaceLargeNum(PlayerDatas.Instance.extersion.runeEssence);

            m_ItemCount0.text = UIHelper.ReplaceLargeNum(PlayerDatas.Instance.extersion.magicEssence);

            m_ItemResolveCount1.gameObject.SetActive(_itemCnt != 0);

            m_ItemResolveCount0.gameObject.SetActive(_magicCnt != 0);

@@ -291,7 +292,8 @@


        private void PlayerDataRefreshInfoEvent(PlayerDataType type)

        {

            if (type == PlayerDataType.MagicEssence)

            if (type == PlayerDataType.MagicEssence

                || type == PlayerDataType.RuneSplinters)

            {

                RefreshResolveGetItems();

            }

@@ -306,27 +308,49 @@
            }

        }



        private int Compare(RuneData x, RuneData y)

        Transform GetCheckSign(int itemColor)

        {

            ItemConfig xItemCfg = ItemConfig.Get(x.id);

            ItemConfig yItemCfg = ItemConfig.Get(y.id);

            if (xItemCfg.Type.CompareTo(yItemCfg.Type) != 0)

            switch (itemColor)

            {

                return xItemCfg.Type.CompareTo(yItemCfg.Type);

                case 1:

                    return m_CheckSigns.Length > 0 ? m_CheckSigns[0] : null;

                case 2:

                    return m_CheckSigns.Length > 1 ? m_CheckSigns[1] : null;

                case 3:

                    return m_CheckSigns.Length > 2 ? m_CheckSigns[2] : null;

                case 4:

                    return m_CheckSigns.Length > 3 ? m_CheckSigns[3] : null;

            }

            if (xItemCfg.ItemColor.CompareTo(yItemCfg.ItemColor) != 0)

            return null;

        }



        int Compare(int lhs, int rhs)

        {

            RuneItem lhsItem = null;

            RuneItem rhsItem = null;

            if (virtualPackModel.TryGetItem(PackType.RunePack, lhs, out lhsItem)

                && virtualPackModel.TryGetItem(PackType.RunePack, rhs, out rhsItem))

            {

                return -xItemCfg.ItemColor.CompareTo(yItemCfg.ItemColor);

                var lhsConfig = ItemConfig.Get(lhsItem.id);

                var rhsConfig = ItemConfig.Get(rhsItem.id);

                if (lhsConfig.Type != rhsConfig.Type)

                {

                    return lhsConfig.Type.CompareTo(rhsConfig.Type);

                }

                if (lhsConfig.ItemColor != rhsConfig.ItemColor)

                {

                    return -lhsConfig.ItemColor.CompareTo(rhsConfig.ItemColor);

                }

                if (lhsItem.level != rhsItem.level)

                {

                    return -lhsItem.level.CompareTo(rhsItem.level);

                }

                if (lhsItem.id != rhsItem.id)

                {

                    return -lhsItem.id.CompareTo(rhsItem.id);

                }

            }

            else if (x.lv.CompareTo(y.lv) != 0)

            {

                return -x.lv.CompareTo(y.lv);

            }

            else if (x.id.CompareTo(y.id) != 0)

            {

                return -x.id.CompareTo(y.id);

            }

            else return 1;

            return 1;

        }

    }

}


 System/WindowBase/ModelCenter.cs

@@ -230,6 +230,7 @@
            RegisterModel<EquipTrainModel>();

            RegisterModel<EquipStrengthModel>();

            RegisterModel<RuneNewModel>();

            RegisterModel<RuneResolveModel>();

            inited = true;

        }