XiuXianProject/GameClient/Assets/Game/HotUpdate/Views/TurnTable/TurnTableView.cs

using FairyGUI;
using UnityEngine;
using UI.TurnTable;
using System.Collections;
using System.Collections.Generic;
using ET;
using System.Threading.Tasks;
using System.Linq;
using System.Text.RegularExpressions;
using cfg.GfgCfg;

namespace GFGGame
{
    public class TurnTableView : BaseWindow
    {
        private UI_TurnTableUI _ui;
        private ValueBarController _valueBarController;
        private int activityID;
        private int propID;
        private int WaitTime;

        private float duratio;

        //这里固定旋转
        private float endValue;

        //这里获得偏移量
        private List<float> normalEndValue = new List<float>();

        public List<GLoader> pointerList = new List<GLoader>();

        //转盘物品
        public List<DropOutCfg> rewardItemList = new List<DropOutCfg>();

        //下面奖励物品
        public List<TurntableRewardCfg> rewardList = new List<TurntableRewardCfg>();
        public List<float> angleList = new List<float>() { 0, 39, 74, 109, 145, 180, 215, 250, 288, 325 };
        public int wishType = 0;

        private EffectUI _effectUI1;

        // private EffectUI _effectUI2;
        private EffectUI _effectUI3;
        private EffectUI _effectUI4;
        private EffectUI _effectUI5;
        private EffectUI _effectUI6;
        private EffectUI _effectUI7;
        private EffectUI _effectUISpecial;
        private Dictionary<string, EffectUI> _effectUIDic = new Dictionary<string, EffectUI>();
        private Dictionary<string, EffectUI> _effectTableUIDic = new Dictionary<string, EffectUI>();

        public override void Dispose()
        {
            EffectUIPool.Recycle(_effectUI1);
            _effectUI1 = null;
            // EffectUIPool.Recycle(_effectUI2);
            // _effectUI2 = null;
            EffectUIPool.Recycle(_effectUI3);
            _effectUI3 = null;
            EffectUIPool.Recycle(_effectUI4);
            _effectUI4 = null;
            EffectUIPool.Recycle(_effectUI5);
            _effectUI5 = null;
            EffectUIPool.Recycle(_effectUI6);
            _effectUI6 = null;
            EffectUIPool.Recycle(_effectUISpecial);
            _effectUISpecial = null;
            foreach (var v in _effectUIDic)
            {
                EffectUIPool.Recycle(v.Value);
            }

            _effectUIDic.Clear();
            foreach (var v in _effectTableUIDic)
            {
                EffectUIPool.Recycle(v.Value);
            }

            _effectTableUIDic.Clear();
            if (_valueBarController != null)
            {
                _valueBarController.Dispose();
                _valueBarController = null;
            }

            if (_ui != null)
            {
                _ui.Dispose();
            }

            _ui = null;

            base.Dispose();
        }

        protected override void Init()
        {
            base.Init();
            packageName = UI_TurnTableUI.PACKAGE_NAME;
            _ui = UI_TurnTableUI.Create();
            viewCom = _ui.target;
            isfullScreen = true;
            isReturnView = true;

            _valueBarController = new ValueBarController(_ui.m_valueBar);
            _ui.m_btnBack.onClick.Add(OnClickBtnClose);
            _ui.m_btnStartOne.onClick.Add(OnClickBtnStartOne);
            _ui.m_btnStartThree.onClick.Add(OnClickBtnStartThree);
            _ui.m_rewardIcon.onClick.Add(OnClickBtnReward);
            _ui.m_shopBtn.onClick.Add(OnClickBtnShop);
            _ui.m_giftBtn.onClick.Add(OnClickBtnGift);
            _ui.m_ruleBtn.onClick.Add(RuleController.ShowRuleView);
            endValue = 1080;
            duratio = 2.0f;
            WaitTime = 2700;
            AddEffect();
        }

        private void AddEffect()
        {
            EffectUIPool.CreateEffectUI(_ui.m_bgEffect, "ui_Activity", "HHYY_BG_TX/HHYY_BG_TX",
                onComplete: (effect) =>
                {
                    if (effect != null)
                    {
                        _effectUI1 = effect;
                    }
                });
            //_effectUI2 = EffectUIPool.CreateEffectUI(_ui.m_titleEffect, "ui_Activity", "HHYY_Text_TX/HHYY_Text_TX");
            EffectUIPool.CreateEffectUI(_ui.m_btnEffectOne, "ui_Activity", "HHYY_Button/HHYY_Button",
                onComplete: (effect) =>
                {
                    if (effect != null)
                    {
                        _effectUI3 = effect;
                    }
                });
            EffectUIPool.CreateEffectUI(_ui.m_btnEffectThree, "ui_Activity", "HHYY_Button/HHYY_Button",
                onComplete: (effect) =>
                {
                    if (effect != null)
                    {
                        _effectUI4 = effect;
                    }
                });
            EffectUIPool.CreateEffectUI(_ui.m_bgEffec1, "ui_Activity", "HHYY_BG_TX/HHYY_BG_TX",
                onComplete: (effect) =>
                {
                    if (effect != null)
                    {
                        _effectUI5 = effect;
                    }
                });
            EffectUIPool.CreateEffectUI(_ui.m_bgEffec2, "ui_Activity", "HHYY_BG_TX/HHYY_BG_TX",
                onComplete: (effect) =>
                {
                    if (effect != null)
                    {
                        _effectUI6 = effect;
                    }
                });
            EffectUIPool.CreateEffectUI(_ui.m_specialEffect, "ui_Activity",
                "HHYY_Select_Special/HHYY_Select_Special",
                onComplete: (effect) =>
                {
                    if (effect != null)
                    {
                        _effectUISpecial = effect;
                    }
                });
        }

        protected override void OnShown()
        {
            base.OnShown();
            _ui.m_bg.url = ResPathUtil.GetBgImgPath("zqzp_bg");
            pointerList.Clear();
            if (pointerList == null || pointerList.Count < 3)
            {
                pointerList.Add(_ui.m_pointer0);
                pointerList.Add(_ui.m_pointer1);
                pointerList.Add(_ui.m_pointer2);
            }

            normalEndValue.Clear();
            activityID =
                ActivityDataManager.Instance.GetCurOpenActiveByType(ActivityDataManager.Instance.TurnTableActivityType);
            propID = CommonDataManager.Tables.TblTurntableLuckyBoxCfg.GetByActivityId(activityID).CostID;
            int dropId = CommonDataManager.Tables.TblTurntableLuckyBoxCfg.GetByActivityId(activityID).DropId;
            rewardItemList = CommonDataManager.Tables.TblDropOutCfg.DataList.Where(a => a.Id == dropId).ToList();

            rewardList = CommonDataManager.Tables.TblTurntableRewardCfg.DataList.Where(a => a.ActivityId == activityID)
                .ToList();

            _valueBarController.OnShown();
            _valueBarController.UpdateList(new List<int>()
                { propID, ConstItemID.DIAMOND_RED, ConstItemID.DIAMOND_PURPLE });
            UpdateView();
            UpdateRewardItem();
            UpdateReward();
            UpdateTime(null);
            _ui.m_ruleBtn.data = 300038;
            Timers.inst.Add(1, 0, UpdateTime);
        }

        protected override void OnHide()
        {
            base.OnHide();
            Timers.inst.Remove(UpdateTime);
            _ui.m_btnStartOne.touchable = true;
            _ui.m_btnStartThree.touchable = true;
            _valueBarController.OnHide();
            //pointerList.Clear();
            ActivityDataManager.Instance.threeTurnResult.Clear();
            ActivityDataManager.Instance.TurnRewardList.Clear();
        }

        protected override void AddEventListener()
        {
            base.AddEventListener();
            EventAgent.AddEventListener(ConstMessage.SHOP_BUY, UpdateView);
            EventAgent.AddEventListener(ConstMessage.TurnTable_DateCHANGE, UpdateReward);
            EventAgent.AddEventListener(ConstMessage.REWARDVIEW_CLOTHER, ShowReward);
        }

        protected override void RemoveEventListener()
        {
            base.RemoveEventListener();
            EventAgent.RemoveEventListener(ConstMessage.SHOP_BUY, UpdateView);
            EventAgent.RemoveEventListener(ConstMessage.TurnTable_DateCHANGE, UpdateReward);
            EventAgent.RemoveEventListener(ConstMessage.REWARDVIEW_CLOTHER, ShowReward);
        }

        private void ShowReward()
        {
            if (ActivityDataManager.Instance.TurnSpecialRewardList != null &&
                ActivityDataManager.Instance.TurnSpecialRewardList.Count > 0)
            {
                ViewManager.Show<TurnTableTipsRewardView>(new object[]
                    { ItemUtil.CreateItemDataList(ActivityDataManager.Instance.TurnSpecialRewardList), null });
                ActivityDataManager.Instance.TurnSpecialRewardList = null;
            }
        }

        private void UpdateTime(object param = null)
        {
            //=====限时礼包倒计时
            var activityInfoByTypeList = ActivityGlobalDataManager.Instance.GetActivityInfoByType(ActivityType.XSLB3);
            if (activityInfoByTypeList.Count == 0)
            {
                Timers.inst.Remove(UpdateTime);
                _ui.m_gift.visible = false;
            }
            else
            {
                _ui.m_giftTimeText.text =
                    TimeUtil.GetTimeLeft(TimeInfo.Instance.ServerNow(), activityInfoByTypeList[0].EndTime);
            }
            //=====限时礼包倒计时END
        }

        private void UpdateView()
        {
            ActivityOpenCfg activiyCfg = CommonDataManager.Tables.TblActivityOpenCfg.GetOrDefault(activityID);
            if (activiyCfg != null)
            {
                _ui.m_timeText.text = "活动结束时间：" + GetTImeText(activiyCfg.EndTime);
            }

            //还要判断是否已购买,和时间
            var activityInfoByTypeList = ActivityGlobalDataManager.Instance.GetActivityInfoByType(ActivityType.XSLB3);
            if (activityInfoByTypeList.Count == 0)
            {
                return;
            }

            ActivityOpenCfg activityOpenCfg =
                CommonDataManager.Tables.TblActivityOpenCfg.GetOrDefault(activityInfoByTypeList[0].ActivityId);
            var shopCfgId = activityOpenCfg.Params1[0];
            var shopCfg = CommonDataManager.Tables.TblShopCfg.GetOrDefault(shopCfgId);
            if (shopCfg == null)
            {
                return;
            }

            var remainBuyNum = shopCfg.MaxBuyNum - ShopDataManager.Instance.GetGoodsBuyNumById(shopCfg.Id);
            if (activityInfoByTypeList.Count == 0)
            {
                _ui.m_gift.visible = false;
            }
            else if (remainBuyNum != 0)
            {
                _ui.m_gift.visible = true;
            }
            else
            {
                _ui.m_gift.visible = false;
            }
        }

        //更新转盘上物品
        private void UpdateRewardItem()
        {
            if (rewardItemList.Count < 10)
            {
                //现在转盘上只有十个item
                Debug.LogError("奖励不足10个");
                return;
            }

            for (int i = 0; i < 10; i++)
            {
                GComponent comProBonus = _ui.target.GetChild("item" + i).asCom;
                UI_rewardItem rewardItem = UI_rewardItem.Proxy(comProBonus);
                ItemCfg itemCfg = CommonDataManager.Tables.TblItemCfg.GetOrDefault(rewardItemList[i].Item);
                if (!_effectTableUIDic.ContainsKey("item" + i))
                {
                    EffectUIPool.CreateEffectUI(rewardItem.m_effect, "ui_Activity", "HHYY_Select/HHYY_Select",
                        onComplete: (effect) =>
                        {
                            if (effect != null)
                            {
                                _effectTableUIDic.Add("item" + i, effect);
                            }
                        });
                }

                rewardItem.m_icon.url = ResPathUtil.GetIconPath(itemCfg);
                rewardItem.m_numText.text = string.Format("x{0}", rewardItemList[i].MaxNum);
                rewardItem.m_c1.selectedIndex = 0;
                rewardItem.m_effect.visible = false;
                if (rewardItem.target.data == null)
                {
                    rewardItem.target.onClick.Add(OnClickTableRewardItem);
                }

                rewardItem.target.data = itemCfg.Id;
                UI_rewardItem.ProxyEnd();
            }
        }

        //更新下面次数的物品
        private void UpdateReward()
        {
            if (ActivityDataManager.Instance.TurnSpecialRewardList != null &&
                ActivityDataManager.Instance.TurnSpecialRewardList.Count > 0)
            {
                _ui.m_specialEffect.visible = true;
            }
            else
            {
                _ui.m_specialEffect.visible = false;
            }

            _ui.m_numberText.text = ActivityDataManager.Instance.TurnTableTimes.ToString();
            _ui.m_reward.m_bar.max = rewardList.Count;
            _ui.m_reward.m_bar.value = GetRewardIndex();
            float value = (float)GetRewardIndex() / (float)rewardList.Count;
            _ui.m_reward.target.scrollPane.SetPercX(value, false);
            for (int i = 0; i < rewardList.Count; i++)
            {
                GComponent comProBonus = _ui.m_reward.target.GetChild("itemj" + i).asCom;
                UI_reward rewardItem = UI_reward.Proxy(comProBonus);
                if (!_effectUIDic.ContainsKey("itemj" + i))
                {
                    EffectUIPool.CreateEffectUI(rewardItem.m_effect, "ui_Activity",
                        "HHYY_Line_Full/HHYY_Line_Full",
                        onComplete: (effect) =>
                        {
                            if (effect != null)
                            {
                                _effectUIDic.Add("itemj" + i, effect);
                            }
                        });
                }

                rewardItem.m_effect.SetScale(1, 1);
                ItemCfg itemCfg = CommonDataManager.Tables.TblItemCfg.GetOrDefault(rewardList[i].Bonus[0].ItemId);
                rewardItem.m_icon.url = ResPathUtil.GetIconPath(itemCfg);
                rewardItem.m_numText.text = rewardList[i].Num.ToString();
                if (ActivityDataManager.Instance.TurnRewardStateDic.ContainsKey(rewardList[i].Id))
                {
                    if (i > (GetRewardIndex() - 1) ||
                        ActivityDataManager.Instance.TurnRewardStateDic[rewardList[i].Id] == 2)
                    {
                        rewardItem.m_effect.visible = false;
                        rewardItem.m_c1.selectedIndex = 0;
                        RedDotController.Instance.SetComRedDot(rewardItem.target, false, "");
                    }
                    else
                    {
                        rewardItem.m_effect.visible = true;
                        rewardItem.m_c1.selectedIndex = 1;
                        RedDotController.Instance.SetComRedDot(rewardItem.target, true, "");
                    }

                    if (ActivityDataManager.Instance.TurnRewardStateDic[rewardList[i].Id] == 2)
                    {
                        rewardItem.m_effect.visible = false;
                        rewardItem.m_c1.selectedIndex = 2;
                        RedDotController.Instance.SetComRedDot(rewardItem.target, false, "");
                    }
                }

                //if (i == rewardList.Count - 1)
                //{
                //    comProBonus.x = ((float)rewardList[i].num / (float)rewardList[rewardList.Count - 1].num) * _ui.m_reward.m_bar.width - 30;
                //}
                //else
                {
                    comProBonus.x = ((float)(i + 1) / (float)rewardList.Count) * _ui.m_reward.m_bar.width - 20;
                }
                if (rewardItem.target.data == null)
                {
                }

                rewardItem.target.onClick.Add(OnClickRewardItem);

                List<int> dateList = new List<int>() { itemCfg.Id, rewardList[i].Id };
                rewardItem.target.data = dateList;
                UI_rewardItem.ProxyEnd();
            }
        }

        private void OnClickTableRewardItem(EventContext context)
        {
            int id = (int)(context.sender as GObject).data;
            GoodsItemTipsController.ShowItemTips(id);
        }

        private async void OnClickRewardItem(EventContext context)
        {
            List<int> idList = (List<int>)(context.sender as GObject).data;
            //判断是否可领取
            if (ActivityDataManager.Instance.TurnRewardStateDic.ContainsKey(idList[1]))
            {
                //if (ActivityDataManager.Instance.TurnRewardStateDic[idList[1]] != 1)
                if (ActivityDataManager.Instance.TurnRewardStateDic[idList[1]] != 1)
                {
                    GoodsItemTipsController.ShowItemTips(idList[0]);
                }
                else
                {
                    bool result = await ActivitySProxy.ReqGetTurnTableReward(idList[1]);
                    if (result)
                    {
                    }
                }
            }
        }

        private void OnClickBtnClose(object param)
        {
            ViewManager.GoBackFrom(typeof(TurnTableView).FullName);
        }

        private async void OnClickBtnStartOne()
        {
            ItemData item;
            if (BagDataManager.Instance.GetBagData().TryGetValue(propID, out item))
            {
                if (item.num >= 1)
                {
                    bool result = await ActivitySProxy.ReqTurnTableWish(1);
                    if (result)
                    {
                        wishType = 0;
                        _ui.m_btnStartOne.touchable = false;
                        _ui.m_btnStartThree.touchable = false;
                        _ui.m_btnBack.touchable = false;
                        _ui.m_valueBar.touchable = false;
                        _ui.m_shopBtn.touchable = false;
                        await TurnStart(0);
                        await Task.Delay(WaitTime);
                        BonusController.TryShowBonusList(
                            ItemUtil.CreateItemDataList(ActivityDataManager.Instance.TurnRewardList));
                        ActivityDataManager.Instance.TurnRewardList.Clear();
                        UpdateReward();
                        _ui.m_btnStartOne.touchable = true;
                        _ui.m_btnStartThree.touchable = true;
                        _ui.m_btnBack.touchable = true;
                        _ui.m_valueBar.touchable = true;
                        _ui.m_shopBtn.touchable = true;
                    }
                    else
                    {
                        //Debug.LogError("许愿失败");
                    }
                }
                else
                {
                    if (ActivityDataManager.Instance.CHECK_TIPS_OPEN == false)
                        TurnTipsController.Show(propID, 1, null, true);
                    else
                    {
                        OnBuyItem(propID, 1);
                    }
                }
            }
            else
            {
                if (ActivityDataManager.Instance.CHECK_TIPS_OPEN == false)
                    TurnTipsController.Show(propID, 1, null, true);
                else
                {
                    OnBuyItem(propID, 1);
                }
            }
        }

        private async void OnClickBtnStartThree()
        {
            ItemData item;
            if (BagDataManager.Instance.GetBagData().TryGetValue(propID, out item))
            {
                if (item.num >= 3)
                {
                    bool result = await ActivitySProxy.ReqTurnTableWish(2);
                    if (result)
                    {
                        _ui.m_btnStartOne.touchable = false;
                        _ui.m_btnStartThree.touchable = false;
                        _ui.m_btnBack.touchable = false;
                        _ui.m_valueBar.touchable = false;
                        _ui.m_shopBtn.touchable = false;
                        await TurnStart(0);
                        await Task.Delay(WaitTime);
                        await TurnStart(1);
                        await Task.Delay(WaitTime);
                        await TurnStart(2);
                        await Task.Delay(WaitTime);
                        BonusController.TryShowBonusList(
                            ItemUtil.CreateItemDataList(ActivityDataManager.Instance.TurnRewardList));
                        ActivityDataManager.Instance.TurnRewardList.Clear();
                        _ui.m_btnStartOne.touchable = true;
                        _ui.m_btnStartThree.touchable = true;
                        _ui.m_btnBack.touchable = true;
                        _ui.m_valueBar.touchable = true;
                        _ui.m_shopBtn.touchable = true;
                        UpdateReward();
                    }
                    else
                    {
                        //Debug.LogError("许愿失败");
                    }
                }
                else
                {
                    if (ActivityDataManager.Instance.CHECK_TIPS_OPEN == false)
                        TurnTipsController.Show(propID, 3, null, true);
                    else
                    {
                        OnBuyItem(propID, 3);
                    }
                }
            }
            else
            {
                if (ActivityDataManager.Instance.CHECK_TIPS_OPEN == false)
                    TurnTipsController.Show(propID, 3, null, true);
                else
                {
                    OnBuyItem(propID, 3);
                }
            }
        }

        private async void OnBuyItem(int itemId, long count)
        {
            var _result = await ItemExchangeSProxy.ItemExchange(itemId, count);
            if (_result)
                BonusController.TryShowBonusList(ItemUtil.CreateItemDataList(itemId, count));
        }

        private void OnClickBtnShop()
        {
            ViewManager.Show<StoreView>(new object[]
                { ConstStoreTabId.STORE_GIFT_BAG, ConstStoreSubId.STORE_ACTIVITY_EXCHANGE });
        }

        private void OnClickBtnReward()
        {
            ViewManager.Show<TurnSpecialTipsView>();
        }

        private void OnClickBtnGift()
        {
            var activityInfoByTypeList =
                ActivityGlobalDataManager.Instance.GetActivityInfoByType(ActivityType.XSLB3);

            var list = activityInfoByTypeList
                .Where(a => a.EndTime > TimeInfo.Instance.ServerNow()).ToList();
            if (list.Count == 0)
                PromptController.Instance.ShowFloatTextPrompt("活动已结束");
            else
                ViewManager.Show<RushSaleGiftBoxView>(new object[] { ActivityType.XSLB3, this.viewData });
        }

        private async ETTask TurnStart(int Round)
        {
            UpdateRewardItem();
            GetOffSetValue(Round);
            if (normalEndValue.Count >= 3)
            {
                TurnTable(0, normalEndValue[0], Round);
            }

            await Task.Delay(200);
            if (normalEndValue.Count >= 2)
            {
                TurnTable(1, normalEndValue[1], Round);
            }

            await Task.Delay(200);
            if (normalEndValue.Count >= 3)
            {
                TurnTable(2, normalEndValue[2], Round);
            }
        }

        private void TurnTable(int index, float OffValue, int Round)
        {
            pointerList[index].rotation = pointerList[index].rotation % 360;
            float selfEndValue = pointerList[index].rotation;
            selfEndValue += endValue + OffValue;
            pointerList[index].TweenRotate(selfEndValue, duratio).OnComplete(() => SetItemSelect(index, Round));
        }

        private void SetItemSelect(int index, int Round)
        {
            int id = ActivityDataManager.Instance.threeTurnResult[Round][index].ConfigId;
            int i = GetItemIndexRota(id);
            GComponent comProBonus = _ui.target.GetChild("item" + i).asCom;
            UI_rewardItem rewardItem = UI_rewardItem.Proxy(comProBonus);
            rewardItem.m_c1.selectedIndex = 1;
            rewardItem.m_effect.visible = true;
            UI_rewardItem.ProxyEnd();
        }

        private void GetOffSetValue(int index)
        {
            normalEndValue.Clear();
            if (ActivityDataManager.Instance.threeTurnResult.ContainsKey(index))
            {
                normalEndValue.Add(GetOffSet(ActivityDataManager.Instance.threeTurnResult[index][0].ConfigId, 0));
                normalEndValue.Add(GetOffSet(ActivityDataManager.Instance.threeTurnResult[index][1].ConfigId, 1));
                normalEndValue.Add(GetOffSet(ActivityDataManager.Instance.threeTurnResult[index][2].ConfigId, 2));
            }
            else
            {
                ET.Log.Error("未获得奖励");
            }
        }

        //通过获得的物品id和当前指针位置获得偏移角度
        private float GetOffSet(int itemID, int index)
        {
            float currentRota = pointerList[index].rotation % 360;
            float OffSetOne = 360 - currentRota;
            float OffSetTwo = angleList[GetItemIndexRota(itemID)];
            float OffSet;
            if (currentRota > OffSetTwo)
            {
                OffSet = OffSetTwo + OffSetOne;
            }
            else if (currentRota < OffSetTwo)
            {
                OffSet = OffSetTwo - currentRota;
            }
            else
            {
                OffSet = 0;
            }

            return OffSet;
        }

        private int GetItemIndexRota(int id)
        {
            for (int i = 0; i < rewardItemList.Count; i++)
            {
                if (id == rewardItemList[i].Item)
                {
                    return i;
                }
            }

            return 0;
        }

        private int GetRewardIndex()
        {
            for (int i = 0; i < rewardList.Count - 1; i++)
            {
                if (ActivityDataManager.Instance.TurnTableTimes < rewardList[0].Num)
                {
                    return 0;
                }
                else if (ActivityDataManager.Instance.TurnTableTimes >= rewardList[rewardList.Count - 1].Num)
                {
                    return rewardList.Count;
                }

                if (ActivityDataManager.Instance.TurnTableTimes >= rewardList[i].Num &&
                    ActivityDataManager.Instance.TurnTableTimes < rewardList[i + 1].Num)
                {
                    return i + 1;
                }
            }

            return 0;
        }

        private string GetTImeText(string time)
        {
            string pattern = @"\[(.*?)\]";

            // 创建一个Regex对象
            Regex regex = new Regex(pattern);

            // 匹配输入字符串中的所有内容
            MatchCollection matches = Regex.Matches(time, pattern);
            // 存储所有提取的内容
            string TimeText = matches[0].Groups[1].Value;
            for (int i = 1; i < matches.Count; i++)
            {
                TimeText += "-" + matches[i].Groups[1].Value;
            }

            return TimeText;
        }
    }
}