Merge branch 'master' of http://192.168.0.87:10010/r/snxxz_scripts

client_Hale

2019-04-02 9ebcbb13743209e85d0b154df2a0d7f991abedb3

Merge branch 'master' of http://192.168.0.87:10010/r/snxxz_scripts

 System/Equip/EquipFightPower.cs

New file
@@ -0,0 +1,368 @@
using System.Collections;
using System.Collections.Generic;
using UnityEngine;


namespace Snxxz.UI
{

    public class EquipFightPower : Singleton<EquipFightPower>
    {

        PackModel packModel { get { return ModelCenter.Instance.GetModel<PackModel>(); } }
        EquipModel equipModel { get { return ModelCenter.Instance.GetModel<EquipModel>(); } }
        EquipStarModel starModel { get { return ModelCenter.Instance.GetModel<EquipStarModel>(); } }
        EquipTrainModel trainModel { get { return ModelCenter.Instance.GetModel<EquipTrainModel>(); } }
        EquipStrengthModel strengthenModel { get { return ModelCenter.Instance.GetModel<EquipStrengthModel>(); } }
        EquipGemModel gemModel { get { return ModelCenter.Instance.GetModel<EquipGemModel>(); } }

        string scoreFormula;
        string propertyFormula;

        public EquipFightPower()
        {
            var config = FuncConfigConfig.Get("FightpowerFormula");
            propertyFormula = config.Numerical1;
            scoreFormula = config.Numerical2;
        }

        public int CalculatePower(int level)
        {
            Equation.Instance.Clear();
            Equation.Instance.AddKeyValue("equipScoreTotal", CountEquipScore(level));
            var power = 0;
            power = Equation.Instance.Eval<int>(scoreFormula);

            var propertyContainer = new Properties();
            CountProperties(level, ref propertyContainer);

            Equation.Instance.Clear();
            var keys = propertyContainer.keys;
            for (int i = 0; i < keys.Count; i++)
            {
                var id = keys[i];
                var value = propertyContainer[id];
                var config = PlayerPropertyConfig.Get(id);
                Equation.Instance.AddKeyValue(config.Parameter, value);
            }

            power += Equation.Instance.Eval<int>(propertyFormula);

            var skillIds = CountEightSuitSkills(level);
            if (!skillIds.IsNullOrEmpty())
            {
                foreach (var skillId in skillIds)
                {
                    var config = SkillConfig.Get(skillId);
                    power += config.FightPower;
                }
            }

            return power;
        }

        private int CountEquipScore(int level)
        {
            var score = 0;
            for (int i = 1; i <= 12; i++)
            {
                var equipPosition = new Int2(level, i);
                var guid = equipModel.GetEquip(equipPosition);
                if (string.IsNullOrEmpty(guid))
                {
                    continue;
                }

                var equip = packModel.GetItemByGuid(guid);
                if (equip == null)
                {
                    continue;
                }

                score += equip.score;
            }

            return score;
        }

        private List<int> CountEightSuitSkills(int level)
        {
            var skills = new List<int>();

            var eightSuitLevel = equipModel.GetSuitLevel(level, EquipSuitType.EightSuit);
            List<EquipSuitConfig> eightConfigs = null;
            if (eightSuitLevel >= 0)
            {
                eightConfigs = EquipSuitConfig.GetConfigs(PlayerDatas.Instance.baseData.Job, level, EquipSuitType.EightSuit);
            }

            for (int i = 9; i >= 0; i--)
            {
                if (i % 3 != 0)
                {
                    continue;
                }

                if (eightSuitLevel >= i)
                {
                    var config = eightConfigs.Find(x => { return x.star == i; });
                    if (config.skillID > 0)
                    {
                        skills.Add(config.skillID);
                    }
                }
            }

            return skills;
        }

        private void CountProperties(int level, ref Properties container)
        {
            CountSuitProperties(level, ref container);
            CountStrengthenProperties(level, ref container);
            CountStarProperties(level, ref container);
            CountGemProperties(level, ref container);
            CountTrainProperties(level, ref container);
        }

        private void CountSuitProperties(int level, ref Properties container)
        {
            var twoSuitLevel = equipModel.GetSuitLevel(level, EquipSuitType.TwoSuit);
            var fiveSuitLevel = equipModel.GetSuitLevel(level, EquipSuitType.FiveSuit);
            var eightSuitLevel = equipModel.GetSuitLevel(level, EquipSuitType.EightSuit);

            List<EquipSuitConfig> twoConfigs = null;
            if (twoSuitLevel >= 0)
            {
                twoConfigs = EquipSuitConfig.GetConfigs(PlayerDatas.Instance.baseData.Job, level, EquipSuitType.TwoSuit);
            }

            List<EquipSuitConfig> fiveConfigs = null;
            if (fiveSuitLevel >= 0)
            {
                fiveConfigs = EquipSuitConfig.GetConfigs(PlayerDatas.Instance.baseData.Job, level, EquipSuitType.FiveSuit);
            }

            List<EquipSuitConfig> eightConfigs = null;
            if (eightSuitLevel >= 0)
            {
                eightConfigs = EquipSuitConfig.GetConfigs(PlayerDatas.Instance.baseData.Job, level, EquipSuitType.EightSuit);
            }

            for (int i = 9; i >= 0; i--)
            {
                if (i % 3 != 0)
                {
                    continue;
                }

                if (twoSuitLevel >= i)
                {
                    var config = twoConfigs.Find(x => { return x.star == i; });
                    foreach (var property in config.attr)
                    {
                        container.Add(property.x, property.y);
                    }
                }

                if (fiveSuitLevel >= i)
                {
                    var config = fiveConfigs.Find(x => { return x.star == i; });
                    foreach (var property in config.attr)
                    {
                        container.Add(property.x, property.y);
                    }
                }

                if (eightSuitLevel >= i)
                {
                    var config = eightConfigs.Find(x => { return x.star == i; });
                    foreach (var property in config.attr)
                    {
                        container.Add(property.x, property.y);
                    }
                }
            }

        }

        private void CountStrengthenProperties(int level, ref Properties container)
        {
            for (int i = 1; i <= 12; i++)
            {
                var equipPosition = new Int2(level, i);
                var equip = equipModel.GetEquip(equipPosition);
                if (string.IsNullOrEmpty(equip))
                {
                    continue;
                }

                var values = strengthenModel.GetEquipValueList(level, i);
                foreach (var item in values)
                {
                    container.Add(item.AttType, item.AttValue);
                }
            }
        }

        private void CountStarProperties(int level, ref Properties container)
        {
            for (int i = 1; i <= 12; i++)
            {
                var equipPosition = new Int2(level, i);
                var equip = equipModel.GetEquip(equipPosition);
                if (string.IsNullOrEmpty(equip))
                {
                    continue;
                }

                var star = starModel.GetEquipStarLevel(equipPosition);
                var config = EquipStarConfig.Get(equipPosition.x, equipPosition.y, star);
                if (config == null)
                {
                    continue;
                }

                foreach (var property in config.BaseAttrInfo)
                {
                    container.Add(property.x, property.y);
                }

                foreach (var property in config.StarAttrInfo)
                {
                    container.Add(property.x, property.y);
                }
            }

        }

        private void CountGemProperties(int level, ref Properties container)
        {
            for (int i = 1; i <= 12; i++)
            {
                var equipPosition = new Int2(level, i);
                var equip = equipModel.GetEquip(equipPosition);
                if (string.IsNullOrEmpty(equip))
                {
                    continue;
                }

                for (int holeIndex = 0; holeIndex < 4; holeIndex++)
                {
                    if (gemModel.IsEquipGemHoleOpen(equipPosition.x, equipPosition.y, holeIndex))
                    {
                        continue;
                    }

                    var gem = 0;
                    if (!gemModel.TryGetEquipGem(equipPosition.x, equipPosition.y, holeIndex, out gem))
                    {
                        continue;
                    }

                    var itemConfig = ItemConfig.Get(gem);
                    if (itemConfig.Effect2 > 0)
                    {
                        container.Add(itemConfig.Effect2, itemConfig.EffectValueA2);
                    }

                    if (itemConfig.Effect3 > 0)
                    {
                        container.Add(itemConfig.Effect3, itemConfig.EffectValueA3);
                    }

                    if (itemConfig.Effect4 > 0)
                    {
                        container.Add(itemConfig.Effect4, itemConfig.EffectValueA4);
                    }

                    if (itemConfig.Effect5 > 0)
                    {
                        container.Add(itemConfig.Effect5, itemConfig.EffectValueA5);
                    }

                }
            }

        }

        private void CountTrainProperties(int level, ref Properties container)
        {
            for (int i = 1; i <= 12; i++)
            {
                var equipPosition = new Int2(level, i);
                var equip = equipModel.GetEquip(equipPosition);
                if (string.IsNullOrEmpty(equip))
                {
                    continue;
                }

                var trainLevel = trainModel.GetTrainLevel(equipPosition);
                if (trainLevel <= 0)
                {
                    continue;
                }

                var type = EquipTrainModel.GetTrainType(equipPosition.y);
                var data = EquipWashConfig.Get(type, trainLevel);
                if (data == null)
                {
                    continue;
                }

                var trainedProperties = trainModel.GetTrainedProperties(equipPosition);
                container.Add(data.config.attType1, Mathf.Min(data.config.attMax1, trainedProperties.x));
                container.Add(data.config.attType2, Mathf.Min(data.config.attMax2, trainedProperties.y));
                container.Add(data.config.attType3, Mathf.Min(data.config.attMax3, trainedProperties.z));
            }

        }

        class Properties
        {
            Dictionary<int, int> tables = new Dictionary<int, int>();

            public List<int> keys { get { return new List<int>(tables.Keys); } }

            public int this[int id] { get { return tables[id]; } }

            public void Add(int id, int value)
            {
                if (id == 7)
                {
                    Add(65, value);
                    Add(66, value);
                }
                else
                {
                    if (tables.ContainsKey(id))
                    {
                        tables[id] = tables[id] + value;
                    }
                    else
                    {
                        tables[id] = value;
                    }
                }
            }

            public void AddRange(List<int> ids, List<int> values)
            {
                if (ids.IsNullOrEmpty() || values.IsNullOrEmpty())
                {
                    return;
                }

                var count = Mathf.Min(ids.Count, values.Count);
                for (int i = 0; i < count; i++)
                {
                    Add(ids[i], values[i]);
                }
            }

        }

    }

}


 System/Equip/EquipFightPower.cs.meta

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

 System/Equip/EquipModel.cs

@@ -50,7 +50,6 @@
            packModel.refrechPackEvent += OnItemPackRefresh;
            packModel.refreshItemCountEvent += OnItemCountRefresh;
            PlayerDatas.Instance.playerDataRefreshEvent += OnPlayerDataRefresh;
            particularModel.PowerUpdate += OnPowerUpdate;
        }

        public override void UnInit()
@@ -58,7 +57,6 @@
            packModel.refrechPackEvent -= OnItemPackRefresh;
            packModel.refreshItemCountEvent -= OnItemCountRefresh;
            PlayerDatas.Instance.playerDataRefreshEvent -= OnPlayerDataRefresh;
            particularModel.PowerUpdate -= OnPowerUpdate;
        }

        public void OnAfterPlayerDataInitialize()
@@ -171,6 +169,7 @@
                selectedStarLevel.dirty = true;

                appearance.value = GetAppearance(level);
                UpdateFightPower(level);
                fightPoint.value = GetFightPoint(level);
            }

@@ -516,7 +515,14 @@

        public int GetFightPoint(int level)
        {
            return (int)particularModel.GetFuncFightPower(level + 25);
            if (equipSets.ContainsKey(level))
            {
                return equipSets[level].fightPower;
            }
            else
            {
                return 0;
            }
        }

        public void RefreshGetWays(Int2 equipPosition)
@@ -747,13 +753,8 @@
            {
                UpdateSuitPlaces(selectedLevel.value);
                UpdateSuitProperty(selectedLevel.value, selectedStarLevel.value);
            }
        }

        private void OnPowerUpdate()
        {
            if (selectedLevel.value != 0)
            {
                UpdateFightPower(selectedLevel.value);
                fightPoint.value = GetFightPoint(selectedLevel.value);
            }
        }
@@ -881,6 +882,14 @@
            this.suitActive.value = suitActive;
        }

        private void UpdateFightPower(int level)
        {
            if (equipSets.ContainsKey(level))
            {
                equipSets[level].fightPower = EquipFightPower.Instance.CalculatePower(level);
            }
        }

        private void ParseConfig()
        {
            var configs = EquipControlConfig.GetValues();

 System/Equip/EquipSet.cs

@@ -11,8 +11,9 @@
        public readonly int realm;
        public bool unLocked { get { return PlayerDatas.Instance.baseData.realmLevel >= realm; } }
        public readonly LogicBool selected = new LogicBool();

        public int fightPower { get; set; }
        public readonly Redpoint redpoint;

        Dictionary<int, EquipSlot> equipSlots = new Dictionary<int, EquipSlot>();

        PackModel packModel { get { return ModelCenter.Instance.GetModel<PackModel>(); } }

 System/EquipTrain/EquipTrainModel.cs

@@ -684,9 +684,9 @@
            trainTypes = ConfigParse.GetDic<int, int>(config.Numerical1);
        }

        public static int GetTrainType(int equipType)
        public static int GetTrainType(int place)
        {
            return trainTypes.ContainsKey(equipType) ? trainTypes[equipType] : 0;
            return trainTypes.ContainsKey(place) ? trainTypes[place] : 0;
        }

        public enum TrainOperateType