0312 节日祝福-游历

hch

2021-02-24 dfdc5785c20d938884a39fddfa32474ebeb648c0

0312 节日祝福-游历

 Core/GameEngine/DataToCtl/PackageRegedit.cs

@@ -530,6 +530,8 @@
        Register(typeof(HAA43_tagMCFeastWishInfo), typeof(DTCAA43_tagMCFeastWishInfo));

        Register(typeof(HAA44_tagMCFeastWishPlayerInfo), typeof(DTCAA44_tagMCFeastWishPlayerInfo));

        Register(typeof(HAA45_tagMCFeastWishResult), typeof(DTCAA45_tagMCFeastWishResult));

        Register(typeof(HAA46_tagMCFeastTravelInfo), typeof(DTCAA46_tagMCFeastTravelInfo));

        Register(typeof(HAA47_tagMCFeastTravelPlayerInfo), typeof(DTCAA47_tagMCFeastTravelPlayerInfo));

        #endregion

    }




 Core/GameEngine/Model/Config/ActFeastTravelTaskConfig.cs

New file
@@ -0,0 +1,212 @@
//--------------------------------------------------------
//    [Author]:           Fish
//    [  Date ]:           2021年2月23日
//--------------------------------------------------------

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

[XLua.LuaCallCSharp]
public partial class ActFeastTravelTaskConfig
{

    public readonly int TraveTasklD;
    public readonly string TaskDes;
    public readonly int FuncID;
    public readonly int JumpId;
    public readonly string IconKey;

    public ActFeastTravelTaskConfig()
    {
    }

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

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

            TaskDes = tables[1];

            int.TryParse(tables[2],out FuncID); 

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

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

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

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

        return config;
    }

    public static ActFeastTravelTaskConfig 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<ActFeastTravelTaskConfig> GetValues()
    {
        var values = new List<ActFeastTravelTaskConfig>();
        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 +"/ActFeastTravelTask.txt";
        }
        else
        {
            path = AssetVersionUtility.GetAssetFilePath("config/ActFeastTravelTask.txt");
        }

        configs.Clear();
        var tempConfig = new ActFeastTravelTaskConfig();
        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 ActFeastTravelTaskConfig(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 ActFeastTravelTaskConfig(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/ActFeastTravelTaskConfig.cs.meta

New file
@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 0e8f016e7a9d6c441b35c4545ba503e3
MonoImporter:
  externalObjects: {}
  serializedVersion: 2
  defaultReferences: []
  executionOrder: 0
  icon: {instanceID: 0}
  userData: 
  assetBundleName: 
  assetBundleVariant: 

 Core/NetworkPackage/DTCFile/ServerPack/HAA_SaleActivity/DTCAA46_tagMCFeastTravelInfo.cs

New file
@@ -0,0 +1,14 @@
using UnityEngine;
using System.Collections;
using Snxxz.UI;

// AA 46 节日游历活动信息 #tagMCFeastTravelInfo

public class DTCAA46_tagMCFeastTravelInfo : DtcBasic {
    public override void Done(GameNetPackBasic vNetPack) {
        base.Done(vNetPack);
        HAA46_tagMCFeastTravelInfo vNetData = vNetPack as HAA46_tagMCFeastTravelInfo;

        OperationTimeHepler.Instance.UpdateHolidayTravel(vNetData);
    }
}

 Core/NetworkPackage/DTCFile/ServerPack/HAA_SaleActivity/DTCAA46_tagMCFeastTravelInfo.cs.meta

New file
@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 4d05cc65418f5a24fa1de5a55683b240
MonoImporter:
  externalObjects: {}
  serializedVersion: 2
  defaultReferences: []
  executionOrder: 0
  icon: {instanceID: 0}
  userData: 
  assetBundleName: 
  assetBundleVariant: 

 Core/NetworkPackage/DTCFile/ServerPack/HAA_SaleActivity/DTCAA47_tagMCFeastTravelPlayerInfo.cs

New file
@@ -0,0 +1,15 @@
using UnityEngine;
using System.Collections;
using Snxxz.UI;
// AA 47 节日游历活动玩家信息 #tagMCFeastTravelPlayerInfo

public class DTCAA47_tagMCFeastTravelPlayerInfo : DtcBasic {

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

    public override void Done(GameNetPackBasic vNetPack) {
        base.Done(vNetPack);
        HAA47_tagMCFeastTravelPlayerInfo vNetData = vNetPack as HAA47_tagMCFeastTravelPlayerInfo;
        model.OnPlayerTravelInfo(vNetData);
    }
}

 Core/NetworkPackage/DTCFile/ServerPack/HAA_SaleActivity/DTCAA47_tagMCFeastTravelPlayerInfo.cs.meta

New file
@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 6c2d194c7901ed544aa0579c4f8a825a
MonoImporter:
  externalObjects: {}
  serializedVersion: 2
  defaultReferences: []
  executionOrder: 0
  icon: {instanceID: 0}
  userData: 
  assetBundleName: 
  assetBundleVariant: 

 Core/NetworkPackage/ServerPack/HAA_SaleActivity/HAA46_tagMCFeastTravelInfo.cs

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

// AA 46 节日游历活动信息 #tagMCFeastTravelInfo

public class HAA46_tagMCFeastTravelInfo : GameNetPackBasic {
    public string StartDate;    // 开始日期 y-m-d
    public string EndtDate;    // 结束日期 y-m-d
    public byte ResetType;    // 重置类型，0-0点重置；1-5点开，5点重置；2-5点开，0点重置
    public byte TravelTaskCount;    // 游历任务数
    public  tagMCFeastTravelTask[] TravelTaskList;    //游历任务信息列表
    public byte TravelAwardCount;    // 游历奖励数
    public  tagMCFeastTravelAward[] TravelAwardList;    //游历奖励信息列表

    public HAA46_tagMCFeastTravelInfo () {
        _cmd = (ushort)0xAA46;
    }

    public override void ReadFromBytes (byte[] vBytes) {
        TransBytes (out StartDate, vBytes, NetDataType.Chars, 10);
        TransBytes (out EndtDate, vBytes, NetDataType.Chars, 10);
        TransBytes (out ResetType, vBytes, NetDataType.BYTE);
        TransBytes (out TravelTaskCount, vBytes, NetDataType.BYTE);
        TravelTaskList = new tagMCFeastTravelTask[TravelTaskCount];
        for (int i = 0; i < TravelTaskCount; i ++) {
            TravelTaskList[i] = new tagMCFeastTravelTask();
            TransBytes (out TravelTaskList[i].TravelTaskID, vBytes, NetDataType.BYTE);
            TransBytes (out TravelTaskList[i].FinishNeedValue, vBytes, NetDataType.WORD);
            TransBytes (out TravelTaskList[i].FinishTimeMax, vBytes, NetDataType.BYTE);
            TransBytes (out TravelTaskList[i].AddTravelPoint, vBytes, NetDataType.BYTE);
        }
        TransBytes (out TravelAwardCount, vBytes, NetDataType.BYTE);
        TravelAwardList = new tagMCFeastTravelAward[TravelAwardCount];
        for (int i = 0; i < TravelAwardCount; i ++) {
            TravelAwardList[i] = new tagMCFeastTravelAward();
            TransBytes (out TravelAwardList[i].AwardIndex, vBytes, NetDataType.BYTE);
            TransBytes (out TravelAwardList[i].NeedTravelPoint, vBytes, NetDataType.WORD);
            TransBytes (out TravelAwardList[i].AwardCountMax, vBytes, NetDataType.BYTE);
            TransBytes (out TravelAwardList[i].AwardItemCount, vBytes, NetDataType.BYTE);
            TravelAwardList[i].AwardItemList = new tagMCFeastTravelAwardItem[TravelAwardList[i].AwardItemCount];
            for (int j = 0; j < TravelAwardList[i].AwardItemCount; j ++) {
                TravelAwardList[i].AwardItemList[j] = new tagMCFeastTravelAwardItem();
                TransBytes (out TravelAwardList[i].AwardItemList[j].ItemID, vBytes, NetDataType.DWORD);
                TransBytes (out TravelAwardList[i].AwardItemList[j].ItemCount, vBytes, NetDataType.WORD);
                TransBytes (out TravelAwardList[i].AwardItemList[j].IsBind, vBytes, NetDataType.BYTE);
            }
        }
    }

    public struct tagMCFeastTravelTask {
        public byte TravelTaskID;        //游历任务ID
        public ushort FinishNeedValue;        //单次完成所需进度
        public byte FinishTimeMax;        //最大可完成次数，0代表不限
        public byte AddTravelPoint;        //单次完成获得游历值
    }

    public struct tagMCFeastTravelAwardItem {
        public uint ItemID;
        public ushort ItemCount;
        public byte IsBind;
    }

    public struct tagMCFeastTravelAward {
        public byte AwardIndex;        //游历奖励索引
        public ushort NeedTravelPoint;        //单次领奖所需游历值
        public byte AwardCountMax;        //最大可领取次数，0代表不限
        public byte AwardItemCount;        //奖励物品数
        public  tagMCFeastTravelAwardItem[] AwardItemList;        //奖励物品列表
    }

}

 Core/NetworkPackage/ServerPack/HAA_SaleActivity/HAA46_tagMCFeastTravelInfo.cs.meta

New file
@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 841617357b5f2c54e8c09cf49436217f
MonoImporter:
  externalObjects: {}
  serializedVersion: 2
  defaultReferences: []
  executionOrder: 0
  icon: {instanceID: 0}
  userData: 
  assetBundleName: 
  assetBundleVariant: 

 Core/NetworkPackage/ServerPack/HAA_SaleActivity/HAA47_tagMCFeastTravelPlayerInfo.cs

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

// AA 47 节日游历活动玩家信息 #tagMCFeastTravelPlayerInfo

public class HAA47_tagMCFeastTravelPlayerInfo : GameNetPackBasic {
    public uint TravelPoint;    //当前总游历值，一直累加，不会扣的
    public byte TravelPlayerTaskCount;    // 游历任务数，不一定有同步，有同步数据则替换即可
    public  tagMCFeastTravelPlayerTask[] TravelPlayerTaskList;    //游历任务信息列表
    public byte TravelPlayerAwardCount;    // 游历奖励数，不一定有同步，有同步数据则替换即可
    public  tagMCFeastTravelPlayerAward[] TravelPlayerAwardList;    //游历奖励信息列表

    public HAA47_tagMCFeastTravelPlayerInfo () {
        _cmd = (ushort)0xAA47;
    }

    public override void ReadFromBytes (byte[] vBytes) {
        TransBytes (out TravelPoint, vBytes, NetDataType.DWORD);
        TransBytes (out TravelPlayerTaskCount, vBytes, NetDataType.BYTE);
        TravelPlayerTaskList = new tagMCFeastTravelPlayerTask[TravelPlayerTaskCount];
        for (int i = 0; i < TravelPlayerTaskCount; i ++) {
            TravelPlayerTaskList[i] = new tagMCFeastTravelPlayerTask();
            TransBytes (out TravelPlayerTaskList[i].TravelTaskID, vBytes, NetDataType.BYTE);
            TransBytes (out TravelPlayerTaskList[i].TravelValue, vBytes, NetDataType.DWORD);
            TransBytes (out TravelPlayerTaskList[i].FinishCount, vBytes, NetDataType.BYTE);
        }
        TransBytes (out TravelPlayerAwardCount, vBytes, NetDataType.BYTE);
        TravelPlayerAwardList = new tagMCFeastTravelPlayerAward[TravelPlayerAwardCount];
        for (int i = 0; i < TravelPlayerAwardCount; i ++) {
            TravelPlayerAwardList[i] = new tagMCFeastTravelPlayerAward();
            TransBytes (out TravelPlayerAwardList[i].AwardIndex, vBytes, NetDataType.BYTE);
            TransBytes (out TravelPlayerAwardList[i].GetAwardCount, vBytes, NetDataType.BYTE);
        }
    }

    public struct tagMCFeastTravelPlayerAward {
        public byte AwardIndex;        //游历奖励索引
        public byte GetAwardCount;        //已领取次数；前端判断是否可领取: 总游历值 >=  (已领取次数 + 1)  * 单次所需游历值
    }

    public struct tagMCFeastTravelPlayerTask {
        public byte TravelTaskID;        //游历任务ID
        public uint TravelValue;        //当前进度值，一直累加
        public byte FinishCount;        //当前已完成次数; 前端计算未完成次数的进度值=max(0, 当前进度值 - (完成次数 * 单次所需进度))
    }

}

 Core/NetworkPackage/ServerPack/HAA_SaleActivity/HAA47_tagMCFeastTravelPlayerInfo.cs.meta

New file
@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 620a5671b06eb5a40aa7caaab6c077b4
MonoImporter:
  externalObjects: {}
  serializedVersion: 2
  defaultReferences: []
  executionOrder: 0
  icon: {instanceID: 0}
  userData: 
  assetBundleName: 
  assetBundleVariant: 

 System/HolidayWishes/HolidayTravelAwardCell.cs

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

using UnityEngine;
using UnityEngine.UI;

namespace Snxxz.UI
{
   
    public class HolidayTravelAwardCell : CellView
    {
        [SerializeField] Text titleText;
        [SerializeField] Text remindText;
        [SerializeField] Button receiveBtn;
        [SerializeField] GameObject noReachImg;
        [SerializeField] GameObject alreadyImg;
        [SerializeField] List<ItemCell> itemBaiscs = new List<ItemCell>();

        PackModel playerPack { get { return ModelCenter.Instance.GetModel<PackModel>(); } }
        HolidayTravelModel model { get { return ModelCenter.Instance.GetModel<HolidayTravelModel>(); } }

        private void OnEnable()
        {
        }

        private void OnDisable()
        {
        }
        public void Init(byte awardIndex)
        {
            OperationHolidayTravel holiday;
            if (!OperationTimeHepler.Instance.TryGetOperation(model.operationType, out holiday))
            {
                return;
            }
            titleText.text = Language.Get("HolidayTravel1", holiday.travelAwards[awardIndex].NeedTravelPoint);

            //maxCnt 0 无限制 1 只有1次不需要显示 大于1显示剩余次数
            //剩余次数为0 不显示
            var maxCnt = holiday.travelAwards[awardIndex].AwardCountMax;
            if (maxCnt == 1)
            {
                remindText.text = string.Empty;
            }
            else if (maxCnt == 0)
            {
                remindText.text = Language.Get("HolidayTravel3", model.GetRemindTravelPoint(holiday, awardIndex), holiday.travelAwards[awardIndex].NeedTravelPoint);
            }
            else
            {
                var remindCnt = model.GetAwardRemindTimes(holiday, awardIndex);
                if (remindCnt == 0)
                {
                    remindText.text = string.Empty;
                }
                else
                { 
                    remindText.text = Language.Get("HolidayTravel2", remindCnt, model.GetRemindTravelPoint(holiday, awardIndex), holiday.travelAwards[awardIndex].NeedTravelPoint);
                }
            }

            for (int i = 0; i < itemBaiscs.Count; i++)
            {
                if (i < holiday.travelAwards[awardIndex].AwardItemCount)
                {
                    itemBaiscs[i].gameObject.SetActive(true);
                    var item = holiday.travelAwards[awardIndex].AwardItemList[i];
                    ItemCellModel cellModel = new ItemCellModel((int)item.ItemID, false, item.ItemCount);
                    itemBaiscs[i].Init(cellModel);
                    itemBaiscs[i].auctionIcon.gameObject.SetActive(item.IsBind > 0 ? true : false);
                    itemBaiscs[i].button.AddListener(() =>
                    {
                        ItemTipUtility.Show((int)item.ItemID);
                    });
                }
                else
                {
                    itemBaiscs[i].gameObject.SetActive(false);
                }
            }

            RefreshAwardStateUI(holiday, awardIndex);
        }

        

        private void RefreshAwardStateUI(OperationHolidayTravel holiday, byte awardIndex)
        {
            int state = model.GetAwardState(holiday, awardIndex);
            switch (state)
            {
                case 0:
                    noReachImg.SetActive(true);
                    alreadyImg.SetActive(false);
                    receiveBtn.gameObject.SetActive(false);
                    break;
                case 1:
                    noReachImg.SetActive(false);
                    alreadyImg.SetActive(false);
                    receiveBtn.gameObject.SetActive(true);
                    receiveBtn.AddListener(()=> {
                        if (playerPack.GetEmptyGridCount(PackType.Item) >= holiday.travelAwards[awardIndex].AwardItemCount)
                        {
                            model.SendGetAward(awardIndex);
                        }
                        else
                        {
                            SysNotifyMgr.Instance.ShowTip("BagFull");
                        }
                    });
                    break;
                case 2:
                    noReachImg.SetActive(false);
                    alreadyImg.SetActive(true);
                    receiveBtn.gameObject.SetActive(false);
                    break;
            }
        }


    }
}

 System/HolidayWishes/HolidayTravelAwardCell.cs.meta

New file
@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 11f55337171b68b4aa7f0dead27fd277
MonoImporter:
  externalObjects: {}
  serializedVersion: 2
  defaultReferences: []
  executionOrder: 0
  icon: {instanceID: 0}
  userData: 
  assetBundleName: 
  assetBundleVariant: 

 System/HolidayWishes/HolidayTravelModel.cs

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


namespace Snxxz.UI
{
    public class HolidayTravelModel : Model, IBeforePlayerDataInitialize, IPlayerLoginOk, IOpenServerActivity
    {
        public event Action<int> onStateUpdate;
        public const int redPointID = 28004;
        public Redpoint redPoint = new Redpoint(MainRedDot.RedPoint_HolidayWishes, redPointID);
        public Operation operationType = Operation.HolidayTravel;

        //节日祝福 id从101开始和精彩活动区分
        public const int activityType = (int)OpenServerActivityCenter.ActivityType.AT_JRZF;
        public const int activityID = 104;

        public int travelPoint;  //当前获得的总游历值
        //奖励索引：此任务奖励已领取次数
        public Dictionary<byte, byte> playerTravelAwards = new Dictionary<byte, byte>();
        //【任务ID，此任务总进度，完成次数】
        public Dictionary<byte, List<int>> travelTaskProcess = new Dictionary<byte, List<int>>();
        //记录收包时的任务顺序 用于排序参考
        List<byte> taskPackSort = new List<byte>();
        //排序后
        public List<byte> travelTaskSort = new List<byte>();

        public event Action onTravelAwards;
        public event Action onTaskProcess;

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

        public override void Init()
        {
            OperationTimeHepler.Instance.operationStartEvent += OperationStartEvent;
            OperationTimeHepler.Instance.operationEndEvent += OperationEndEvent;
            OperationTimeHepler.Instance.operationAdvanceEvent += OperationAdvanceEvent;
            OpenServerActivityCenter.Instance.Register(activityID, this, activityType);

        }



        public void OnBeforePlayerDataInitialize()
        {
            travelTaskProcess.Clear();
            travelTaskSort.Clear();
            taskPackSort.Clear();
            playerTravelAwards.Clear();
            travelPoint = 0;
        }

        public void OnPlayerLoginOk()
        {
        }

        public override void UnInit()
        {
            OperationTimeHepler.Instance.operationStartEvent -= OperationStartEvent;
            OperationTimeHepler.Instance.operationEndEvent -= OperationEndEvent;
            OperationTimeHepler.Instance.operationAdvanceEvent -= OperationAdvanceEvent;
        }

        public bool IsOpen
        {
            get
            {
                return OperationTimeHepler.Instance.SatisfyOpenCondition(operationType);
            }
        }

        public bool priorityOpen
        {
            get
            {
                return redPoint.state == RedPointState.Simple;
            }
        }

        public bool IsAdvance
        {
            get
            {
                return OperationTimeHepler.Instance.SatisfyAdvanceCondition(operationType);
            }
        }

        private void OperationEndEvent(Operation type, int state)
        {
            if (type == operationType && state == 0)
            {
                if (onStateUpdate != null)
                {
                    onStateUpdate(activityID);
                }
            }
        }

        private void OperationAdvanceEvent(Operation type)
        {
            if (type == operationType)
            {
                if (onStateUpdate != null)
                {
                    onStateUpdate(activityID);
                }
            }
        }

        private void OperationStartEvent(Operation type, int state)
        {
            if (type == operationType && state == 0)
            {

                if (onStateUpdate != null)
                {
                    onStateUpdate(activityID);
                }
            }
        }



        void UpdateRedpoint()
        {
            redPoint.state = RedPointState.None;

            if (GetCanGetAwardIndex() != -1)
            {
                redPoint.state = RedPointState.Simple;
            }
        }


        public void SendGetAward(uint index)
        {
            CA504_tagCMPlayerGetReward getReward = new CA504_tagCMPlayerGetReward();
            getReward.RewardType = (byte)GotServerRewardType.Def_RewardType_HolidayTravel;
            getReward.DataEx = index;
            getReward.DataExStrLen = 0;
            getReward.DataExStr = string.Empty;
            GameNetSystem.Instance.SendInfo(getReward);
        }

        public void OnPlayerTravelInfo(HAA47_tagMCFeastTravelPlayerInfo netPack)
        {
            travelPoint = (int)netPack.TravelPoint;
            if (netPack.TravelPlayerAwardCount != 0)
            {
                foreach (var award in netPack.TravelPlayerAwardList)
                {
                    if (playerTravelAwards.ContainsKey(award.AwardIndex))
                    {
                        playerTravelAwards[award.AwardIndex] = award.GetAwardCount;
                    }
                    else
                    { 
                        playerTravelAwards.Add(award.AwardIndex, award.GetAwardCount);
                    }
                }

                if (onTravelAwards != null)
                {
                    //刷新领奖信息（打开界面比较少能完成任务不做及时刷新）
                    onTravelAwards();
                }
            }

            if (netPack.TravelPlayerTaskCount != 0)
            {
                foreach (var task in netPack.TravelPlayerTaskList)
                {
                    if (travelTaskProcess.ContainsKey(task.TravelTaskID))
                    {
                        travelTaskProcess[task.TravelTaskID] = new List<int> { (int)task.TravelValue, (int)task.FinishCount };
                    }
                    else
                    { 
                        travelTaskProcess.Add(task.TravelTaskID, new List<int> { (int)task.TravelValue, (int)task.FinishCount });
                        taskPackSort.Add(task.TravelTaskID);
                        travelTaskSort.Add(task.TravelTaskID);
                    }
                }
                travelTaskSort.Sort(CompareState);

                if (onTaskProcess != null)
                {
                    onTaskProcess();
                }
            }

            UpdateRedpoint();
        }


        // 已完成往后排
        int CompareState(byte x, byte y)
        {
            OperationHolidayTravel holiday;
            if (OperationTimeHepler.Instance.TryGetOperation(operationType, out holiday))
            {
                bool xfinish = IsTaskFinish(holiday, x);
                bool yfinish = IsTaskFinish(holiday, y);
                if (xfinish != yfinish)
                    return xfinish.CompareTo(yfinish);

                return taskPackSort.IndexOf(x).CompareTo(taskPackSort.IndexOf(y));
            }
            return 0;
        }

        public bool IsTaskFinish(OperationHolidayTravel holiday, byte taskID)
        {
            return holiday.travelTasks[taskID].FinishTimeMax <= travelTaskProcess[taskID][1];
        }


        //指定任务的单次进度
        public int GetTaskProcess(OperationHolidayTravel holiday, byte taskID)
        {
            return Math.Max(0, travelTaskProcess[taskID][0] - travelTaskProcess[taskID][1]*holiday.travelTasks[taskID].FinishNeedValue);
        }


        //指定档位的剩余领取次数,-1不限制
        public int GetAwardRemindTimes(OperationHolidayTravel holiday, byte awardIndex)
        {
            var maxCnt = holiday.travelAwards[awardIndex].AwardCountMax;
            if (maxCnt == 0)
            {
                return -1;
            }

            return maxCnt - playerTravelAwards[awardIndex];
        }

        //指定档位的剩余游历值
        public int GetRemindTravelPoint(OperationHolidayTravel holiday, byte awardIndex)
        {
            return travelPoint - playerTravelAwards[awardIndex]*holiday.travelAwards[awardIndex].NeedTravelPoint;
        }


        // 指定档位领取状态0 未达成 1 可领取 2 已领取
        public int GetAwardState(OperationHolidayTravel holiday, byte awardIndex)
        {
            var maxCnt = holiday.travelAwards[awardIndex].AwardCountMax;
            if (maxCnt == 0 || maxCnt > playerTravelAwards[awardIndex])
            {
                if (travelPoint >= (playerTravelAwards[awardIndex] + 1) * holiday.travelAwards[awardIndex].NeedTravelPoint)
                {
                    return 1;
                }
                else
                {
                    return 0;
                }
            }
            

            return 2;

        }

        //获取第几个档位可领取
        public int GetCanGetAwardIndex()
        {
            OperationHolidayTravel holiday;
            if (OperationTimeHepler.Instance.TryGetOperation(operationType, out holiday))
            {
                int index = 0;
                foreach (var award in holiday.travelAwards)
                {
                    if (GetAwardState(holiday, award.Value.AwardIndex) == 1)
                    {
                        return index;
                    }
                    index++;
                }
            }
            return -1;
        }
    }
}

 System/HolidayWishes/HolidayTravelModel.cs.meta

New file
@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: afe0851cfc564284e865e0b9cfd03987
MonoImporter:
  externalObjects: {}
  serializedVersion: 2
  defaultReferences: []
  executionOrder: 0
  icon: {instanceID: 0}
  userData: 
  assetBundleName: 
  assetBundleVariant: 

 System/HolidayWishes/HolidayTravelTaskCell.cs

New file
@@ -0,0 +1,66 @@
using UnityEngine;
using UnityEngine.UI;

using System;

namespace Snxxz.UI
{
    public class HolidayTravelTaskCell : CellView
    {
        [SerializeField] Image activeIcon;
        [SerializeField] Text activeNameText;
        [SerializeField] Text activeDesText;
        [SerializeField] Text progressText;
        [SerializeField] Button gobtn;
        [SerializeField] GameObject completeImg;

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

        ActFeastTravelTaskConfig taskConfig;
        private void OnEnable()
        {
        }

        private void OnDisable()
        {
        }

        public void Init(byte taskID)
        {
            OperationHolidayTravel holiday;
            if (!OperationTimeHepler.Instance.TryGetOperation(model.operationType, out holiday))
            {
                return;
            }

            activeNameText.gameObject.SetActive(false);
            taskConfig = ActFeastTravelTaskConfig.Get(taskID);
            activeIcon.SetSprite(taskConfig.IconKey);
            //改成总进度显示 非单次
            SetTaskState(holiday, taskID, model.travelTaskProcess[taskID][0], holiday.travelTasks[taskID].FinishTimeMax*holiday.travelTasks[taskID].FinishNeedValue);
            activeDesText.text = string.Format(taskConfig.TaskDes, holiday.travelTasks[taskID].FinishNeedValue, holiday.travelTasks[taskID].AddTravelPoint);
        }

        public void SetTaskState(OperationHolidayTravel holiday, byte taskID, int curProgress, int sumProgress)
        {
            gobtn.RemoveAllListeners();
            progressText.text = StringUtility.Contact(curProgress, "/", sumProgress);
            if (model.IsTaskFinish(holiday, taskID))
            {
                gobtn.gameObject.SetActive(false);
                completeImg.SetActive(true);
                progressText.color = UIHelper.GetUIColor(TextColType.Green);
            }
            if (curProgress < sumProgress)
            {
                gobtn.gameObject.SetActive(true);
                completeImg.SetActive(false);
                progressText.color = UIHelper.GetUIColor(TextColType.Red);
                gobtn.AddListener(()=>
                {
                    WindowJumpMgr.Instance.WindowJumpTo((JumpUIType)taskConfig.JumpId);
                });
            }
        }
    }
}

 System/HolidayWishes/HolidayTravelTaskCell.cs.meta

New file
@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: e3786010e0a58f1498f31d4561f7ecd0
MonoImporter:
  externalObjects: {}
  serializedVersion: 2
  defaultReferences: []
  executionOrder: 0
  icon: {instanceID: 0}
  userData: 
  assetBundleName: 
  assetBundleVariant: 

 System/HolidayWishes/HolidayTravelTaskWin.cs

New file
@@ -0,0 +1,121 @@
using System;
using UnityEngine;
using UnityEngine.UI;

using System.Collections.Generic;

namespace Snxxz.UI
{
    public class HolidayTravelTaskWin : Window
    {
        ScrollerController awardCtrl;
        ScrollerController taskCtrl;
        Text travelPointText;
        Text OpenTime;

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


        protected override void BindController()
        {
            awardCtrl = GetWidgt<ScrollerController>("AwardCellCtrl");
            taskCtrl = GetWidgt<ScrollerController>("TaskCellCtrl");
            travelPointText = GetWidgt<Text>("valueText");
            OpenTime = GetWidgt<Text>("ActivityDesText");

            awardCtrl.OnRefreshCell += RefreshAwardCell;
            taskCtrl.OnRefreshCell += RefreshTaskCell;
        }

        protected override void AddListeners()
        {
           
        }

        protected override void OnPreOpen()
        {
            model.onTravelAwards += CreateAwardCell;
            model.onTaskProcess += CreateTaskCell;
            Init();
        }
        protected override void OnAfterOpen()
        {
           
        }

        protected override void OnPreClose()
        {
            model.onTravelAwards -= CreateAwardCell;
            model.onTaskProcess -= CreateTaskCell;
        }

        protected override void OnAfterClose()
        {

        }

        private void Init()
        {
            travelPointText.text = model.travelPoint.ToString();
            CreateAwardCell();
            CreateTaskCell();
            DisplayOpenTime();
            taskCtrl.JumpIndex(0);
            awardCtrl.JumpIndex(model.GetCanGetAwardIndex());
        }

        private void CreateTaskCell()
        {

            taskCtrl.Refresh();
            foreach(var taskID in model.travelTaskSort)
            {
                taskCtrl.AddCell(ScrollerDataType.Header, taskID);
            }
            taskCtrl.Restart();
            
        }

        private void RefreshTaskCell(ScrollerDataType type, CellView cell)
        {
            HolidayTravelTaskCell taskCell = cell.GetComponent<HolidayTravelTaskCell>();
            if (taskCell == null) return;

            taskCell.Init((byte)cell.index);
        }

        private void CreateAwardCell()
        {
            if (awardCtrl.GetNumberOfCells(awardCtrl.m_Scorller) > 0)
            {
                awardCtrl.m_Scorller.RefreshActiveCellViews();
            }
            else
            {
                awardCtrl.Refresh();
                foreach(var award in model.playerTravelAwards)
                {
                    awardCtrl.AddCell(ScrollerDataType.Header, award.Key);
                }
                awardCtrl.Restart();
            }
        }

        private void RefreshAwardCell(ScrollerDataType type, CellView cell)
        {
            HolidayTravelAwardCell awardCell = cell.GetComponent<HolidayTravelAwardCell>();
            if (awardCell == null) return;

            awardCell.Init((byte)cell.index);
        }

        void DisplayOpenTime()
        {
            OperationHolidayTravel operation;
            if (OperationTimeHepler.Instance.TryGetOperation(model.operationType, out operation))
            {
                OpenTime.text = StringUtility.Contact(Language.Get("ExpActivity_Text1"), operation.ToDisplayTime());
            }
        }
    }
}

 System/HolidayWishes/HolidayTravelTaskWin.cs.meta

New file
@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 5047759803bd2a1489dbf2e1abf1085e
MonoImporter:
  externalObjects: {}
  serializedVersion: 2
  defaultReferences: []
  executionOrder: 0
  icon: {instanceID: 0}
  userData: 
  assetBundleName: 
  assetBundleVariant: 

 System/HolidayWishes/HolidayWishesWin.cs

@@ -25,7 +25,7 @@
            SetFunctionListener(0, ShowLoginWin);
            SetFunctionListener(1, ShowHolidayWishPoolWin);
            SetFunctionListener(2, ShowHolidayRechargeGiftWin);
            SetFunctionListener(3, ShowAlchemyFairyDrug);
            SetFunctionListener(3, ShowHolidayTravelTaskWin);
        }

        protected override void OnActived()
@@ -59,8 +59,11 @@
            }
            else
            {
                //默认打开充值大礼界面
                functionOrder = 2;
                if (wishOrder == 0)
                { 
                    //默认打开充值大礼界面
                    functionOrder = 2;
                }
            }

            if (!OpenServerActivityCenter.Instance.IsActivityOpen(104, (int)OpenServerActivityCenter.ActivityType.AT_JRZF))
@@ -117,10 +120,10 @@
            functionOrder = 2;
        }

        private void ShowAlchemyFairyDrug()
        private void ShowHolidayTravelTaskWin()
        {
            CloseSubWindows();
            WindowCenter.Instance.Open<AlchemyFairyUseDrugWin>();
            WindowCenter.Instance.Open<HolidayTravelTaskWin>();
            functionOrder = 3;
        }
    }

 System/HolidayWishes/OperationHolidayTravel.cs

New file
@@ -0,0 +1,52 @@
using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
namespace Snxxz.UI
{
    public class OperationHolidayTravel : OperationBase
    {
        //游历任务ID：任务信息
        public Dictionary<byte, HAA46_tagMCFeastTravelInfo.tagMCFeastTravelTask> travelTasks = new Dictionary<byte, HAA46_tagMCFeastTravelInfo.tagMCFeastTravelTask>();
        //奖励索引：奖励信息
        public Dictionary<byte, HAA46_tagMCFeastTravelInfo.tagMCFeastTravelAward> travelAwards = new Dictionary<byte, HAA46_tagMCFeastTravelInfo.tagMCFeastTravelAward>();
        public override bool SatisfyOpenCondition()
        {
            return PlayerDatas.Instance.baseData.LV >= limitLv;
        }

        public override string ToDisplayTime()
        {
            var textBuilder = OperationTimeHepler.textBuilder;
            textBuilder.Length = 0;
            textBuilder.Append(startDate.ToDisplay());
            if (startDate != endDate)
            {
                textBuilder.Append("—");
                textBuilder.Append(endDate.ToDisplay());
            }
            return textBuilder.ToString();
        }

        public override void Reset()
        {
            base.Reset();
        }

        public void ParsePackage(HAA46_tagMCFeastTravelInfo package)
        {
            travelTasks.Clear();
            travelAwards.Clear();
            for (int i = 0; i < package.TravelAwardCount; i++)
            {
                travelAwards.Add(package.TravelAwardList[i].AwardIndex, package.TravelAwardList[i]);
            }

            for (int i = 0; i < package.TravelTaskCount; i++)
            {
                travelTasks.Add(package.TravelTaskList[i].TravelTaskID, package.TravelTaskList[i]);
            }
        }
    }
}


 System/HolidayWishes/OperationHolidayTravel.cs.meta

New file
@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 7a6f5638c4bfe7842ad9ca7a12688700
MonoImporter:
  externalObjects: {}
  serializedVersion: 2
  defaultReferences: []
  executionOrder: 0
  icon: {instanceID: 0}
  userData: 
  assetBundleName: 
  assetBundleVariant: 

 System/HolidayWishes/WishBottleAwardWin.cs

@@ -27,6 +27,7 @@
        Operation operationType = Operation.HolidayWish;

        HolidayWishPoolModel model { get { return ModelCenter.Instance.GetModel<HolidayWishPoolModel>(); } }
        PackModel playerPack { get { return ModelCenter.Instance.GetModel<PackModel>(); } }

        #region Built-in

@@ -147,6 +148,12 @@
                }
            }

            var needNum = holiday.wishBottles[model.bottleNumSelect].NeedWishValue;
            var curNum = model.bottleDict[model.bottleNumSelect].x;
            string curNumStr = UIHelper.AppendColor(curNum >= needNum ? TextColType.DarkGreen:TextColType.Red, curNum.ToString());

            m_Text.text = Language.Get("SubWishInfo7", curNumStr, needNum);

            m_OKButton.SetListener(() => {
                if (SelectIndex == -1)
                {
@@ -159,6 +166,18 @@
                    return;
                }

                if (playerPack.GetEmptyGridCount(PackType.Item) <= 0)
                {
                    SysNotifyMgr.Instance.ShowTip("BagFull");
                    return;
                }

                if (curNum < needNum)
                {
                    SysNotifyMgr.Instance.ShowTip("WishBottle2");
                    return;
                }

                int recordIndex = holiday.wishBottles[model.bottleNumSelect].ChoosePrizeList[SelectIndex].RecordIndex;

                CAA10_tagCMFeastWishBottleChooseItem wish = new CAA10_tagCMFeastWishBottleChooseItem();
@@ -167,11 +186,6 @@
                GameNetSystem.Instance.SendInfo(wish);
            });

            var needNum = holiday.wishBottles[model.bottleNumSelect].NeedWishValue;
            var curNum = model.bottleDict[model.bottleNumSelect].x;
            string curNumStr = UIHelper.AppendColor(curNum >= needNum ? TextColType.DarkGreen:TextColType.Red, curNum.ToString());

            m_Text.text = Language.Get("SubWishInfo7", curNumStr, needNum);
        }

    }

 System/Welfare/OperationTimeHepler.cs

@@ -507,6 +507,34 @@
        }





        public void UpdateHolidayTravel(HAA46_tagMCFeastTravelInfo package)

        {

            OperationBase operationBase = null;

            operationDict.TryGetValue(Operation.HolidayTravel, out operationBase);

            if (string.IsNullOrEmpty(package.StartDate) || string.IsNullOrEmpty(package.EndtDate))

            {

                ForceStopOperation(Operation.HolidayTravel);

            }

            else

            {

                if (operationBase == null)

                {

                    operationBase = new OperationHolidayTravel();

                    operationDict.Add(Operation.HolidayTravel, operationBase);

                }

                var operation = operationBase as OperationHolidayTravel;

                operation.Reset();

                operation.startDate = ParseOperationDate(package.StartDate);

                operation.endDate = ParseOperationDate(package.EndtDate);

                operation.resetType = package.ResetType;

                operation.ParsePackage(package);

                if (operationTimeUpdateEvent != null)

                {

                    operationTimeUpdateEvent(Operation.HolidayTravel);

                }

            }

        }



        public void UpdateMultiRechargePackage(HAA27_tagMCActRechargePrizeInfo package)

        {

            OperationBase operationBase = null;

@@ -1148,6 +1176,7 @@
        HolidayLogin,   //节日登录

        HolidayWish,   //节日祝福

        HolidayMultiRecharge,//节日祝福的多日累计充值

        HolidayTravel,      //节日游历

        max,

    }

}


 System/WindowBase/ModelCenter.cs

@@ -246,6 +246,7 @@
            RegisterModel<HolidayLoginModel>();

            RegisterModel<HolidayWishPoolModel>();

            RegisterModel<HolidayMultiRechargeModel>();

            RegisterModel<HolidayTravelModel>();



            inited = true;

        }


 Utility/ConfigInitiator.cs

@@ -315,6 +315,7 @@
        normalTasks.Add(new ConfigInitTask("HorseLVUpConfig", () => { HorseLVUpConfig.Init(); }, () => { return HorseLVUpConfig.inited; }));
        normalTasks.Add(new ConfigInitTask("HorseSkinPlusConfig", () => { HorseSkinPlusConfig.Init(); }, () => { return HorseSkinPlusConfig.inited; }));
        normalTasks.Add(new ConfigInitTask("FirstGoldConfig", () => { FirstGoldConfig.Init(); }, () => { return FirstGoldConfig.inited; }));
        normalTasks.Add(new ConfigInitTask("ActFeastTravelTaskConfig", () => { ActFeastTravelTaskConfig.Init(); }, () => { return ActFeastTravelTaskConfig.inited; }));
    }

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

 Utility/EnumHelper.cs

@@ -1127,6 +1127,7 @@
    Def_RewardType_ActivityPlace = 30,//活跃放置奖励



    Def_RewardType_HolidayLogin = 37,//节日登录奖励

    Def_RewardType_HolidayTravel = 38,//节日游历奖励

}



[XLua.LuaCallCSharp]