6585 【2.0】【开发】人族法宝界面优化

client_linchunjie

2019-04-23 31c570686bcaf7526b968d7e22cc914c7bd890ed

6585 【2.0】【开发】人族法宝界面优化

 Core/GameEngine/Model/Config/TaskListConfig.cs

@@ -1,6 +1,6 @@
//--------------------------------------------------------
//    [Author]:           Fish
//    [  Date ]:           Saturday, April 20, 2019
//    [  Date ]:           Tuesday, April 23, 2019
//--------------------------------------------------------

using System.Collections.Generic;
@@ -23,7 +23,8 @@
    public readonly int[] CollectNPC;

    public readonly int FabaoID;

    public readonly int clue;

    public readonly string clueName;
    public readonly string clueName;

    public readonly int induction;

    public TaskListConfig()
    {
@@ -60,7 +61,9 @@


            int.TryParse(tables[9],out clue); 



            clueName = tables[10];
            clueName = tables[10];



            int.TryParse(tables[11],out induction); 
        }
        catch (Exception ex)
        {

 Core/GameEngine/Model/Config/TaskListConfig.cs.meta

@@ -1,6 +1,6 @@
fileFormatVersion: 2
guid: f73c099fbaf92ca46b2efc87300b8342
timeCreated: 1555731989
timeCreated: 1555984003
licenseType: Pro
MonoImporter:
  serializedVersion: 2

 Core/GameEngine/Model/Config/TreasureChapterConfig.cs

New file
@@ -0,0 +1,211 @@
//--------------------------------------------------------
//    [Author]:           Fish
//    [  Date ]:           Monday, April 22, 2019
//--------------------------------------------------------

using System.Collections.Generic;
using System.IO;
using System.Threading;
using System;
using UnityEngine;

[XLua.LuaCallCSharp]
public partial class TreasureChapterConfig
{

    public readonly int id;

    public readonly int taskId;

    public readonly string taskTitle;

    public readonly int chapterIndex;

    public readonly string description;

    public TreasureChapterConfig()
    {
    }

    public TreasureChapterConfig(string input)
    {
        try
        {
            var tables = input.Split('\t');

            int.TryParse(tables[0],out id); 


            int.TryParse(tables[1],out taskId); 


            taskTitle = tables[2];



            int.TryParse(tables[3],out chapterIndex); 


            description = tables[4];
        }
        catch (Exception ex)
        {
            DebugEx.Log(ex);
        }
    }

    static Dictionary<string, TreasureChapterConfig> configs = new Dictionary<string, TreasureChapterConfig>();
    public static TreasureChapterConfig Get(string id)
    {   
        if (!inited)
        {
            Debug.Log("TreasureChapterConfig 还未完成初始化。");
            return null;
        }
		
        if (configs.ContainsKey(id))
        {
            return configs[id];
        }

        TreasureChapterConfig config = null;
        if (rawDatas.ContainsKey(id))
        {
            config = configs[id] = new TreasureChapterConfig(rawDatas[id]);
            rawDatas.Remove(id);
        }

        return config;
    }

    public static TreasureChapterConfig Get(int id)
    {
        return Get(id.ToString());
    }

    public static List<string> GetKeys()
    {
        var keys = new List<string>();
        keys.AddRange(configs.Keys);
        keys.AddRange(rawDatas.Keys);
        return keys;
    }

    public static List<TreasureChapterConfig> GetValues()
    {
        var values = new List<TreasureChapterConfig>();
        values.AddRange(configs.Values);

        var keys = new List<string>(rawDatas.Keys);
        foreach (var key in keys)
        {
            values.Add(Get(key));
        }

        return values;
    }

    public static bool Has(string id)
    {
        return configs.ContainsKey(id) || rawDatas.ContainsKey(id);
    }

    public static bool Has(int id)
    {
        return Has(id.ToString());
    }

    public static bool inited { get; private set; }
    protected static Dictionary<string, string> rawDatas = new Dictionary<string, string>();
    public static void Init(bool sync=false)
    {
        inited = false;
        var path = string.Empty;
        if (AssetSource.refdataFromEditor)
        {
            path = ResourcesPath.CONFIG_FODLER +"/TreasureChapter.txt";
        }
        else
        {
            path = AssetVersionUtility.GetAssetFilePath("config/TreasureChapter.txt");
        }

        var tempConfig = new TreasureChapterConfig();
        var preParse = tempConfig is IConfigPostProcess;

        if (sync)
        {
            var lines = File.ReadAllLines(path);
            if (!preParse)
            {
                rawDatas = new Dictionary<string, string>(lines.Length - 3);
            }
            for (int i = 3; i < lines.Length; i++)
            {
                try 
                {
                    var line = lines[i];
                    var index = line.IndexOf("\t");
                    if (index == -1)
                    {
                        continue;
                    }
                    var id = line.Substring(0, index);

                    if (preParse)
                    {
                        var config = new TreasureChapterConfig(line);
                        configs[id] = config;
                        (config as IConfigPostProcess).OnConfigParseCompleted();
                    }
                    else
                    {
                        rawDatas[id] = line;
                    }
                }
                catch (System.Exception ex)
                {
                    Debug.LogError(ex);
                }
            }
            inited = true;
        }
        else
        {
            ThreadPool.QueueUserWorkItem((object _object) =>
            {
                var lines = File.ReadAllLines(path);
                if (!preParse)
                {
                    rawDatas = new Dictionary<string, string>(lines.Length - 3);
                }
                for (int i = 3; i < lines.Length; i++)
                {
                    try 
                    {
                       var line = lines[i];
                        var index = line.IndexOf("\t");
                        if (index == -1)
                        {
                            continue;
                        }
                        var id = line.Substring(0, index);

                        if (preParse)
                        {
                            var config = new TreasureChapterConfig(line);
                            configs[id] = config;
                            (config as IConfigPostProcess).OnConfigParseCompleted();
                        }
                        else
                        {
                            rawDatas[id] = line;
                        }
                    }
                    catch (System.Exception ex)
                    {
                        Debug.LogError(ex);
                    }
                }

                inited = true;
            });
        }
    }

}





 Core/GameEngine/Model/Config/TreasureChapterConfig.cs.meta

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

 Core/NetworkPackage/DTCFile/ServerPack/H08_Event/DTC0827_tagMissionDesc.cs

@@ -16,6 +16,9 @@
            return m_TaskModel ?? (m_TaskModel = ModelCenter.Instance.GetModel<TaskModel>());
        }
    }

    TreasureModel treasureModel { get { return ModelCenter.Instance.GetModel<TreasureModel>(); } }

    public override void Done(GameNetPackBasic vNetPack)
    {
        base.Done(vNetPack);
@@ -26,6 +29,7 @@

            taskmodel.RefreshMissionState((int)vNetData.MissionID, vNetData.MissionState, vNetData.DiscriptionIndex);
            PreFightMission.Instance.HandleUpdatePackage(vNetData);
            treasureModel.ReceivePackage(vNetData);
        }

    }

 System/Treasure/HumanTreasureWin.cs

@@ -27,13 +27,9 @@
        [SerializeField] Image m_SkillIcon;

        [SerializeField] Text m_SkillName;

        [SerializeField] Text m_SkillDescription;

        [SerializeField] Transform m_ContainerCollect;

        [SerializeField] Button m_Challenge;

        [SerializeField] Button m_Goto;

        [SerializeField] Slider m_TaskSlider;

        [SerializeField] Text m_TaskProgress;

        [SerializeField] Transform m_ContainerCollected;

        [SerializeField] Transform m_ContainerUnknown;



        [SerializeField] ScrollerController m_TaskController;



@@ -53,7 +49,6 @@
        protected override void AddListeners()

        {

            m_Challenge.AddListener(Challenge);

            m_Goto.AddListener(GotoTask);

            m_Preview.SetListener(Preview);



            m_TaskController.OnRefreshCell += OnRefreshCell;

@@ -125,41 +120,57 @@
            Treasure treasure;

            if (model.TryGetTreasure(model.selectedTreasure, out treasure))

            {

                m_ContainerCollect.gameObject.SetActive(treasure.state == TreasureState.Collecting);

                m_ContainerCollected.gameObject.SetActive(treasure.state == TreasureState.Collected);

                m_ContainerUnknown.gameObject.SetActive(treasure.state == TreasureState.Locked);

                var satisfyChallenge = model.SatisfyChallenge(model.selectedTreasure);



                if (treasure.state == TreasureState.Collecting)

                m_Challenge.gameObject.SetActive(satisfyChallenge);



                var progress = 1f;



                Dictionary<int, List<int>> clues;

                if (model.TryGetTreasureClues(model.selectedTreasure, out clues))

                {

                    var satisfyChallenge = model.SatisfyChallenge(model.selectedTreasure);



                    //m_Goto.gameObject.SetActive(!satisfyChallenge);

                    m_Challenge.gameObject.SetActive(satisfyChallenge);



                    var progress = 1f;



                    Dictionary<int, List<int>> clues;

                    if (model.TryGetTreasureClues(model.selectedTreasure, out clues))

                    {

                        var count = model.GetCompleteTaskCount(model.selectedTreasure);

                        m_TaskProgress.text = StringUtility.Contact(count, "/", clues.Count);

                        progress = Mathf.Clamp01((float)count / clues.Count);

                    }



                    m_TaskSlider.value = progress;

                    var count = model.GetCompleteTaskCount(model.selectedTreasure);

                    progress = Mathf.Clamp01((float)count / clues.Count);

                    m_TaskProgress.text = StringUtility.Contact((int)(progress * 100), "%");

                }



                m_TaskSlider.value = progress;

            }

        }



        void DisplayTasks()

        {

            var inductionTaskId = 0;

            model.TryGetInductionTask(model.selectedTreasure, out inductionTaskId);



            var inductionState = model.GetTreasureInductionState(model.selectedTreasure);



            m_TaskController.Refresh();

            Dictionary<int, List<int>> clues;

            if (model.TryGetTreasureClues(model.selectedTreasure, out clues))

            {

                foreach (var clue in clues.Keys)

                {

                    m_TaskController.AddCell(ScrollerDataType.Header, clue);

                    var display = false;

                    var tasks = clues[clue];

                    switch (inductionState)

                    {

                        case -1:

                        case 0:

                            display = inductionTaskId > tasks[tasks.Count - 1];

                            break;

                        case 1:

                            display = true;

                            break;

                    }

                    if (display)

                    {

                        m_TaskController.AddCell(ScrollerDataType.Header, clue);

                    }

                }

                if (inductionState == 0)

                {

                    m_TaskController.AddCell(ScrollerDataType.Normal, inductionTaskId);

                }

            }

            m_TaskController.Restart();

@@ -205,15 +216,6 @@
                    ModelCenter.Instance.GetModel<DungeonModel>().SingleChallenge(TreasureModel.TREASURE_DATAMAPID, config.LineId);

                }

            }

        }



        private void GotoTask()

        {

            WindowJumpMgr.Instance.ClearJumpData();

            WindowCenter.Instance.Close<TreasureBaseWin>();

            WindowCenter.Instance.Open<MainInterfaceWin>();

            var taskId = taskModel.GetLatestMainTaskId();

            taskModel.TaskMove(taskId);

        }



        private bool AllowSelectTreasure(int treasureId)


 System/Treasure/TreasureChapterWin.cs

New file
@@ -0,0 +1,49 @@
//--------------------------------------------------------

//    [Author]:           第二世界

//    [  Date ]:           Monday, April 22, 2019

//--------------------------------------------------------



using System;

using System.Collections;

using System.Collections.Generic;

using UnityEngine;

using UnityEngine.UI;



namespace Snxxz.UI {



    public class TreasureChapterWin : Window

    {



        #region Built-in

        protected override void BindController()

        {

        }



        protected override void AddListeners()

        {

        }



        protected override void OnPreOpen()

        {

        }



        protected override void OnAfterOpen()

        {

        }



        protected override void OnPreClose()

        {

        }



        protected override void OnAfterClose()

        {

        }

        #endregion

   
    }



}










 System/Treasure/TreasureChapterWin.cs.meta

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

 System/Treasure/TreasureModel.cs

@@ -24,6 +24,7 @@
        Dictionary<TreasureCategory, int> treasureUnlockShowDict = new Dictionary<TreasureCategory, int>();

        Dictionary<int, int> treasureTaskCompletedCounts = new Dictionary<int, int>();

        Dictionary<int, int> treasureSignInPropertys = new Dictionary<int, int>();

        Dictionary<int, int> treasureInductionTasks = new Dictionary<int, int>();

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

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



@@ -142,6 +143,8 @@
        public int exitRecord { get; set; }

        public int entranceOpenCondition { get; private set; }



        public int treasureChapterId { get; private set; }



        TaskModel taskModel { get { return ModelCenter.Instance.GetModel<TaskModel>(); } }



        VIPKillNPCTreasure m_VIPKillNPCTreasure;

@@ -233,6 +236,7 @@
            if (!(StageLoad.Instance.currentStage is DungeonStage))

            {

                exitRecord = 0;

                treasureChapterId = 0;

            }

        }



@@ -341,6 +345,11 @@
                    treasureTasks.Add(config.FabaoID, tasks);

                }

                tasks.Add(config.TaskID);



                if (config.induction == 1)

                {

                    treasureInductionTasks.Add(config.FabaoID, config.TaskID);

                }

            }



            funcConfig = FuncConfigConfig.Get("MWSignDayAttr");

@@ -973,6 +982,50 @@
                demonDungeonChallengeNext();

            }

        }



        public void ReceivePackage(H0827_tagMissionDesc vNetData)

        {

            if (isServerReady)

            {

                if (vNetData.MissionState == 3)

                {

                    TryShowTreasureChapter((int)vNetData.MissionID);

                }

            }

        }



        public bool TryGetInductionTask(int id, out int taskId)

        {

            return treasureInductionTasks.TryGetValue(id, out taskId);

        }



        public int GetTreasureInductionState(int treasurId)

        {

            if (treasures[treasurId].state == TreasureState.Collected)

            {

                return 1;

            }

            var latestTask = taskModel.GetLatestMainTaskId();

            if (treasureInductionTasks.ContainsKey(treasurId))

            {

                var inductionTask = treasureInductionTasks[treasurId];

                return latestTask.CompareTo(inductionTask);

            }

            return 1;

        }



        void TryShowTreasureChapter(int taskId)

        {

            var configs = TreasureChapterConfig.GetValues();

            foreach (var config in configs)

            {

                if (config.taskId == taskId)

                {

                    treasureChapterId = config.id;

                    //PopupWindowsProcessor.Instance.Add()

                }

            }

        }

    }



}


 Utility/ConfigInitiator.cs

@@ -292,7 +292,8 @@
        normalTasks.Add(new ConfigInitTask("MapNpcRefreshConfig", () => { MapNpcRefreshConfig.Init(); }, () => { return MapNpcRefreshConfig.inited; }));

        normalTasks.Add(new ConfigInitTask("DungeonUseBuffConfig", () => { DungeonUseBuffConfig.Init(); }, () => { return DungeonUseBuffConfig.inited; }));

        normalTasks.Add(new ConfigInitTask("AlchemyCountConfig", () => { AlchemyCountConfig.Init(); }, () => { return AlchemyCountConfig.inited; }));

        normalTasks.Add(new ConfigInitTask("CollectNpcConfig", () => { CollectNpcConfig.Init(); }, () => { return CollectNpcConfig.inited; }));
        normalTasks.Add(new ConfigInitTask("CollectNpcConfig", () => { CollectNpcConfig.Init(); }, () => { return CollectNpcConfig.inited; }));

        normalTasks.Add(new ConfigInitTask("TreasureChapterConfig", () => { TreasureChapterConfig.Init(); }, () => { return TreasureChapterConfig.inited; }));
    }

    static List<ConfigInitTask> doingTasks = new List<ConfigInitTask>();