Init TEngine4.0.0

Init TEngine4.0.0

UnityProject/Assets/GameScripts/HotFix/GameLogic/Common/UI/SuperScrollView.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 0615e8b32d534bc48a60e42c973053ad
+timeCreated: 1695289443

UnityProject/Assets/GameScripts/HotFix/GameLogic/Common/UI/SuperScrollView/Scripts.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: f0e67891bd0f0c7449b345c622ed6b0e
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

UnityProject/Assets/GameScripts/HotFix/GameLogic/Common/UI/SuperScrollView/Scripts/Common.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 0fcee77031f85f84dbc6735c875d64b8
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

UnityProject/Assets/GameScripts/HotFix/GameLogic/Common/UI/SuperScrollView/Scripts/Common/ClickEventListener.cs

@@ -0,0 +1,84 @@
+using UnityEngine;
+using UnityEngine.EventSystems;
+
+namespace GameLogic
+{
+    public class ClickEventListener : MonoBehaviour, IPointerClickHandler, IPointerDownHandler, IPointerUpHandler
+    {
+        public static ClickEventListener Get(GameObject obj)
+        {
+            ClickEventListener listener = obj.GetComponent<ClickEventListener>();
+            if (listener == null)
+            {
+                listener = obj.AddComponent<ClickEventListener>();
+            }
+
+            return listener;
+        }
+
+        private System.Action<GameObject> _clickedHandler = null;
+        private System.Action<GameObject> _doubleClickedHandler = null;
+        private System.Action<GameObject> _onPointerDownHandler = null;
+        private System.Action<GameObject> _onPointerUpHandler = null;
+        bool _isPressed = false;
+
+        public bool IsPressed => _isPressed;
+
+        public void OnPointerClick(PointerEventData eventData)
+        {
+            if (eventData.clickCount == 2)
+            {
+                if (_doubleClickedHandler != null)
+                {
+                    _doubleClickedHandler(gameObject);
+                }
+            }
+            else
+            {
+                if (_clickedHandler != null)
+                {
+                    _clickedHandler(gameObject);
+                }
+            }
+        }
+
+        public void SetClickEventHandler(System.Action<GameObject> handler)
+        {
+            _clickedHandler = handler;
+        }
+
+        public void SetDoubleClickEventHandler(System.Action<GameObject> handler)
+        {
+            _doubleClickedHandler = handler;
+        }
+
+        public void SetPointerDownHandler(System.Action<GameObject> handler)
+        {
+            _onPointerDownHandler = handler;
+        }
+
+        public void SetPointerUpHandler(System.Action<GameObject> handler)
+        {
+            _onPointerUpHandler = handler;
+        }
+
+
+        public void OnPointerDown(PointerEventData eventData)
+        {
+            _isPressed = true;
+            if (_onPointerDownHandler != null)
+            {
+                _onPointerDownHandler(gameObject);
+            }
+        }
+
+        public void OnPointerUp(PointerEventData eventData)
+        {
+            _isPressed = false;
+            if (_onPointerUpHandler != null)
+            {
+                _onPointerUpHandler(gameObject);
+            }
+        }
+    }
+}

UnityProject/Assets/GameScripts/HotFix/GameLogic/Common/UI/SuperScrollView/Scripts/Common/ClickEventListener.cs.meta

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

UnityProject/Assets/GameScripts/HotFix/GameLogic/Common/UI/SuperScrollView/Scripts/Common/CommonDefine.cs

@@ -0,0 +1,86 @@
+using System;
+using System.Collections.Generic;
+
+namespace GameLogic
+{
+
+    public enum SnapStatus
+    {
+        NoTargetSet = 0,
+        TargetHasSet = 1,
+        SnapMoving = 2,
+        SnapMoveFinish = 3
+    }
+
+
+    public enum ItemCornerEnum
+    {
+        LeftBottom = 0,
+        LeftTop,
+        RightTop,
+        RightBottom,
+    }
+
+
+    public enum ListItemArrangeType
+    {
+        TopToBottom = 0,
+        BottomToTop,
+        LeftToRight,
+        RightToLeft,
+    }
+
+    public enum GridItemArrangeType
+    {
+        TopLeftToBottomRight = 0,
+        BottomLeftToTopRight,
+        TopRightToBottomLeft,
+        BottomRightToTopLeft,
+    }
+    public enum GridFixedType
+    {
+        ColumnCountFixed = 0,
+        RowCountFixed,
+    }
+
+    public struct RowColumnPair
+    {
+        public RowColumnPair(int row1, int column1)
+        {
+            mRow = row1;
+            mColumn = column1;
+        }
+
+        public bool Equals(RowColumnPair other)
+        {
+            return this.mRow == other.mRow && this.mColumn == other.mColumn;
+        }
+
+        public static bool operator ==(RowColumnPair a, RowColumnPair b)
+        {
+            return (a.mRow == b.mRow)&&(a.mColumn == b.mColumn);
+        }
+        public static bool operator !=(RowColumnPair a, RowColumnPair b)
+        {
+            return (a.mRow != b.mRow) || (a.mColumn != b.mColumn); ;
+        }
+
+        public override int GetHashCode()
+        {
+            return 0;
+        }
+
+        public override bool Equals(object obj)
+        {
+            if (ReferenceEquals(null, obj))
+            {
+                return false;
+            }
+            return (obj is RowColumnPair) && Equals((RowColumnPair)obj);
+        }
+
+
+        public int mRow;
+        public int mColumn;
+    }
+}

UnityProject/Assets/GameScripts/HotFix/GameLogic/Common/UI/SuperScrollView/Scripts/Common/CommonDefine.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 19e4e487f35877f4b9bb864eb43484d6
+timeCreated: 1534508353
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

UnityProject/Assets/GameScripts/HotFix/GameLogic/Common/UI/SuperScrollView/Scripts/Common/ItemPosMgr.cs

@@ -0,0 +1,326 @@
+using System;
+using System.Collections.Generic;
+
+namespace GameLogic
+{
+    public class ItemSizeGroup
+    {
+        public float[] ItemSizeArray = null;
+        public float[] ItemStartPosArray = null;
+        public int ItemCount = 0;
+        private int _dirtyBeginIndex = ItemPosMgr.ItemMaxCountPerGroup;
+        public float GroupSize = 0;
+        public float GroupStartPos = 0;
+        public float GroupEndPos = 0;
+        public int GroupIndex = 0;
+        public float ItemDefaultSize = 0;
+
+        public ItemSizeGroup(int index, float itemDefaultSize)
+        {
+            GroupIndex = index;
+            ItemDefaultSize = itemDefaultSize;
+            Init();
+        }
+
+        public void Init()
+        {
+            ItemSizeArray = new float[ItemPosMgr.ItemMaxCountPerGroup];
+            if (ItemDefaultSize != 0)
+            {
+                for (int i = 0; i < ItemSizeArray.Length; ++i)
+                {
+                    ItemSizeArray[i] = ItemDefaultSize;
+                }
+            }
+
+            ItemStartPosArray = new float[ItemPosMgr.ItemMaxCountPerGroup];
+            ItemStartPosArray[0] = 0;
+            ItemCount = ItemPosMgr.ItemMaxCountPerGroup;
+            GroupSize = ItemDefaultSize * ItemSizeArray.Length;
+            if (ItemDefaultSize != 0)
+            {
+                _dirtyBeginIndex = 0;
+            }
+            else
+            {
+                _dirtyBeginIndex = ItemPosMgr.ItemMaxCountPerGroup;
+            }
+        }
+
+        public float GetItemStartPos(int index)
+        {
+            return GroupStartPos + ItemStartPosArray[index];
+        }
+
+        public bool IsDirty
+        {
+            get { return (_dirtyBeginIndex < ItemCount); }
+        }
+
+        public float SetItemSize(int index, float size)
+        {
+            float old = ItemSizeArray[index];
+            if (Math.Abs(old - size) < 0.001f)
+            {
+                return 0;
+            }
+
+            ItemSizeArray[index] = size;
+            if (index < _dirtyBeginIndex)
+            {
+                _dirtyBeginIndex = index;
+            }
+
+            float ds = size - old;
+            GroupSize = GroupSize + ds;
+            return ds;
+        }
+
+        public void SetItemCount(int count)
+        {
+            if (ItemCount == count)
+            {
+                return;
+            }
+
+            ItemCount = count;
+            RecalcGroupSize();
+        }
+
+        public void RecalcGroupSize()
+        {
+            GroupSize = 0;
+            for (int i = 0; i < ItemCount; ++i)
+            {
+                GroupSize += ItemSizeArray[i];
+            }
+        }
+
+        public int GetItemIndexByPos(float pos)
+        {
+            if (ItemCount == 0)
+            {
+                return -1;
+            }
+
+            int low = 0;
+            int high = ItemCount - 1;
+            while (low <= high)
+            {
+                int mid = (low + high) / 2;
+                float startPos = ItemStartPosArray[mid];
+                float endPos = startPos + ItemSizeArray[mid];
+                if (startPos <= pos && endPos >= pos)
+                {
+                    return mid;
+                }
+                else if (pos > endPos)
+                {
+                    low = mid + 1;
+                }
+                else
+                {
+                    high = mid - 1;
+                }
+            }
+
+            return -1;
+        }
+
+        public void UpdateAllItemStartPos()
+        {
+            if (_dirtyBeginIndex >= ItemCount)
+            {
+                return;
+            }
+
+            int startIndex = (_dirtyBeginIndex < 1) ? 1 : _dirtyBeginIndex;
+            for (int i = startIndex; i < ItemCount; ++i)
+            {
+                ItemStartPosArray[i] = ItemStartPosArray[i - 1] + ItemSizeArray[i - 1];
+            }
+
+            _dirtyBeginIndex = ItemCount;
+        }
+    }
+
+    public class ItemPosMgr
+    {
+        public const int ItemMaxCountPerGroup = 100;
+        readonly List<ItemSizeGroup> _itemSizeGroupList = new List<ItemSizeGroup>();
+        public int _dirtyBeginIndex = int.MaxValue;
+        public float TotalSize = 0;
+        public float ItemDefaultSize = 20;
+
+        public ItemPosMgr(float itemDefaultSize)
+        {
+            ItemDefaultSize = itemDefaultSize;
+        }
+
+        public void SetItemMaxCount(int maxCount)
+        {
+            _dirtyBeginIndex = 0;
+            TotalSize = 0;
+            int st = maxCount % ItemMaxCountPerGroup;
+            int lastGroupItemCount = st;
+            int needMaxGroupCount = maxCount / ItemMaxCountPerGroup;
+            if (st > 0)
+            {
+                needMaxGroupCount++;
+            }
+            else
+            {
+                lastGroupItemCount = ItemMaxCountPerGroup;
+            }
+
+            int count = _itemSizeGroupList.Count;
+            if (count > needMaxGroupCount)
+            {
+                int d = count - needMaxGroupCount;
+                _itemSizeGroupList.RemoveRange(needMaxGroupCount, d);
+            }
+            else if (count < needMaxGroupCount)
+            {
+                int d = needMaxGroupCount - count;
+                for (int i = 0; i < d; ++i)
+                {
+                    ItemSizeGroup tGroup = new ItemSizeGroup(count + i, ItemDefaultSize);
+                    _itemSizeGroupList.Add(tGroup);
+                }
+            }
+
+            count = _itemSizeGroupList.Count;
+            if (count == 0)
+            {
+                return;
+            }
+
+            for (int i = 0; i < count - 1; ++i)
+            {
+                _itemSizeGroupList[i].SetItemCount(ItemMaxCountPerGroup);
+            }
+
+            _itemSizeGroupList[count - 1].SetItemCount(lastGroupItemCount);
+            for (int i = 0; i < count; ++i)
+            {
+                TotalSize = TotalSize + _itemSizeGroupList[i].GroupSize;
+            }
+        }
+
+        public void SetItemSize(int itemIndex, float size)
+        {
+            int groupIndex = itemIndex / ItemMaxCountPerGroup;
+            int indexInGroup = itemIndex % ItemMaxCountPerGroup;
+            ItemSizeGroup tGroup = _itemSizeGroupList[groupIndex];
+            float changedSize = tGroup.SetItemSize(indexInGroup, size);
+            if (changedSize != 0f)
+            {
+                if (groupIndex < _dirtyBeginIndex)
+                {
+                    _dirtyBeginIndex = groupIndex;
+                }
+            }
+
+            TotalSize += changedSize;
+        }
+
+        public float GetItemPos(int itemIndex)
+        {
+            Update(true);
+            int groupIndex = itemIndex / ItemMaxCountPerGroup;
+            int indexInGroup = itemIndex % ItemMaxCountPerGroup;
+            return _itemSizeGroupList[groupIndex].GetItemStartPos(indexInGroup);
+        }
+
+        public void GetItemIndexAndPosAtGivenPos(float pos, ref int index, ref float itemPos)
+        {
+            Update(true);
+            index = 0;
+            itemPos = 0f;
+            int count = _itemSizeGroupList.Count;
+            if (count == 0)
+            {
+                return;
+            }
+
+            ItemSizeGroup hitGroup = null;
+
+            int low = 0;
+            int high = count - 1;
+            while (low <= high)
+            {
+                int mid = (low + high) / 2;
+                ItemSizeGroup tGroup = _itemSizeGroupList[mid];
+                if (tGroup.GroupStartPos <= pos && tGroup.GroupEndPos >= pos)
+                {
+                    hitGroup = tGroup;
+                    break;
+                }
+                else if (pos > tGroup.GroupEndPos)
+                {
+                    low = mid + 1;
+                }
+                else
+                {
+                    high = mid - 1;
+                }
+            }
+
+            int hitIndex = -1;
+            if (hitGroup != null)
+            {
+                hitIndex = hitGroup.GetItemIndexByPos(pos - hitGroup.GroupStartPos);
+            }
+            else
+            {
+                return;
+            }
+
+            if (hitIndex < 0)
+            {
+                return;
+            }
+
+            index = hitIndex + hitGroup.GroupIndex * ItemMaxCountPerGroup;
+            itemPos = hitGroup.GetItemStartPos(hitIndex);
+        }
+
+        public void Update(bool updateAll)
+        {
+            int count = _itemSizeGroupList.Count;
+            if (count == 0)
+            {
+                return;
+            }
+
+            if (_dirtyBeginIndex >= count)
+            {
+                return;
+            }
+
+            int loopCount = 0;
+            for (int i = _dirtyBeginIndex; i < count; ++i)
+            {
+                loopCount++;
+                ItemSizeGroup tGroup = _itemSizeGroupList[i];
+                _dirtyBeginIndex++;
+                tGroup.UpdateAllItemStartPos();
+                if (i == 0)
+                {
+                    tGroup.GroupStartPos = 0;
+                    tGroup.GroupEndPos = tGroup.GroupSize;
+                }
+                else
+                {
+                    tGroup.GroupStartPos = _itemSizeGroupList[i - 1].GroupEndPos;
+                    tGroup.GroupEndPos = tGroup.GroupStartPos + tGroup.GroupSize;
+                }
+
+                if (!updateAll && loopCount > 1)
+                {
+                    return;
+                }
+            }
+        }
+    }
+}

UnityProject/Assets/GameScripts/HotFix/GameLogic/Common/UI/SuperScrollView/Scripts/Common/ItemPosMgr.cs.meta

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

UnityProject/Assets/GameScripts/HotFix/GameLogic/Common/UI/SuperScrollView/Scripts/GridView.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: d7f738dc5a266e94d9e9870fc76009c2
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

UnityProject/Assets/GameScripts/HotFix/GameLogic/Common/UI/SuperScrollView/Scripts/GridView/GridItemGroup.cs

@@ -0,0 +1,173 @@
+namespace GameLogic
+{
+    //if GridFixedType is GridFixedType.ColumnCountFixed, then the GridItemGroup is one row of the gridview
+    //if GridFixedType is GridFixedType.RowCountFixed, then the GridItemGroup is one column of the gridview
+    public class GridItemGroup
+    {
+        private int _count = 0;
+        private int _groupIndex = -1;//the row index or the column index of this group
+        private LoopGridViewItem _first = null;
+        private LoopGridViewItem _last = null;
+        public int Count => _count;
+
+        public LoopGridViewItem First => _first;
+
+        public LoopGridViewItem Last => _last;
+
+        public int GroupIndex
+        {
+            get => _groupIndex;
+            set => _groupIndex = value;
+        }
+
+
+        public LoopGridViewItem GetItemByColumn(int column)
+        {
+            LoopGridViewItem cur = _first;
+            while(cur != null)
+            {
+                if(cur.Column == column)
+                {
+                    return cur;
+                }
+                cur = cur.NextItem;
+            }
+            return null;
+        }
+        public LoopGridViewItem GetItemByRow(int row)
+        {
+            LoopGridViewItem cur = _first;
+            while (cur != null)
+            {
+                if (cur.Row == row)
+                {
+                    return cur;
+                }
+                cur = cur.NextItem;
+            }
+            return null;
+        }
+
+
+        public void ReplaceItem(LoopGridViewItem curItem,LoopGridViewItem newItem)
+        {
+            newItem.PrevItem = curItem.PrevItem;
+            newItem.NextItem = curItem.NextItem;
+            if(newItem.PrevItem != null)
+            {
+                newItem.PrevItem.NextItem = newItem;
+            }
+            if(newItem.NextItem != null)
+            {
+                newItem.NextItem.PrevItem = newItem;
+            }
+            if(_first == curItem)
+            {
+                _first = newItem;
+            }
+            if(_last == curItem)
+            {
+                _last = newItem;
+            }
+        }
+
+        public void AddFirst(LoopGridViewItem newItem)
+        {
+            newItem.PrevItem = null;
+            newItem.NextItem = null;
+            if (_first == null)
+            {
+                _first = newItem;
+                _last = newItem;
+                _first.PrevItem = null;
+                _first.NextItem = null;
+                _count++;
+            }
+            else
+            {
+                _first.PrevItem = newItem;
+                newItem.PrevItem = null;
+                newItem.NextItem = _first;
+                _first = newItem;
+                _count++;
+            }
+        }
+
+        public void AddLast(LoopGridViewItem newItem)
+        {
+            newItem.PrevItem = null;
+            newItem.NextItem = null;
+            if (_first == null)
+            {
+                _first = newItem;
+                _last = newItem;
+                _first.PrevItem = null;
+                _first.NextItem = null;
+                _count++;
+            }
+            else
+            {
+                _last.NextItem = newItem;
+                newItem.PrevItem = _last;
+                newItem.NextItem = null;
+                _last = newItem;
+                _count++;
+            }
+        }
+
+        public LoopGridViewItem RemoveFirst()
+        {
+            LoopGridViewItem ret = _first;
+            if (_first == null)
+            {
+                return ret;
+            }
+            if(_first == _last)
+            {
+                _first = null;
+                _last = null;
+                --_count;
+                return ret;
+            }
+            _first = _first.NextItem;
+            _first.PrevItem = null;
+            --_count;
+            return ret;
+        }
+        public LoopGridViewItem RemoveLast()
+        {
+            LoopGridViewItem ret = _last;
+            if (_first == null)
+            {
+                return ret;
+            }
+            if (_first == _last)
+            {
+                _first = null;
+                _last = null;
+                --_count;
+                return ret;
+            }
+            _last = _last.PrevItem;
+            _last.NextItem = null;
+            --_count;
+            return ret;
+        }
+
+
+        public void Clear()
+        {
+            LoopGridViewItem current = _first;
+            while (current != null)
+            {
+                current.PrevItem = null;
+                current.NextItem = null;
+                current = current.NextItem;
+            }
+            _first = null;
+            _last = null;
+            _count = 0;
+        }
+
+    }
+}

UnityProject/Assets/GameScripts/HotFix/GameLogic/Common/UI/SuperScrollView/Scripts/GridView/GridItemGroup.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: f7e7eb25fe1319d4b8773ddfab7a240e
+timeCreated: 1554538573
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

UnityProject/Assets/GameScripts/HotFix/GameLogic/Common/UI/SuperScrollView/Scripts/GridView/LoopGridItemPool.cs

@@ -0,0 +1,113 @@
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+
+
+namespace GameLogic
+{
+    public class GridItemPool
+    {
+        private GameObject _prefabObj;
+        private string _prefabName;
+        private int _initCreateCount = 1;
+        private readonly List<LoopGridViewItem> _tmpPooledItemList = new List<LoopGridViewItem>();
+        private readonly List<LoopGridViewItem> _pooledItemList = new List<LoopGridViewItem>();
+        private static int _curItemIdCount = 0;
+        private RectTransform _itemParent = null;
+        public GridItemPool()
+        {
+
+        }
+        public void Init(GameObject prefabObj, int createCount, RectTransform parent)
+        {
+            _prefabObj = prefabObj;
+            _prefabName = _prefabObj.name;
+            _initCreateCount = createCount;
+            _itemParent = parent;
+            _prefabObj.SetActive(false);
+            for (int i = 0; i < _initCreateCount; ++i)
+            {
+                LoopGridViewItem tViewItem = CreateItem();
+                RecycleItemReal(tViewItem);
+            }
+        }
+        public LoopGridViewItem GetItem()
+        {
+            _curItemIdCount++;
+            LoopGridViewItem tItem = null;
+            if (_tmpPooledItemList.Count > 0)
+            {
+                int count = _tmpPooledItemList.Count;
+                tItem = _tmpPooledItemList[count - 1];
+                _tmpPooledItemList.RemoveAt(count - 1);
+                tItem.gameObject.SetActive(true);
+            }
+            else
+            {
+                int count = _pooledItemList.Count;
+                if (count == 0)
+                {
+                    tItem = CreateItem();
+                }
+                else
+                {
+                    tItem = _pooledItemList[count - 1];
+                    _pooledItemList.RemoveAt(count - 1);
+                    tItem.gameObject.SetActive(true);
+                }
+            }
+            tItem.ItemId = _curItemIdCount;
+            return tItem;
+
+        }
+
+        public void DestroyAllItem()
+        {
+            ClearTmpRecycledItem();
+            int count = _pooledItemList.Count;
+            for (int i = 0; i < count; ++i)
+            {
+                GameObject.DestroyImmediate(_pooledItemList[i].gameObject);
+            }
+            _pooledItemList.Clear();
+        }
+        public LoopGridViewItem CreateItem()
+        {
+
+            GameObject go = GameObject.Instantiate<GameObject>(_prefabObj, Vector3.zero, Quaternion.identity, _itemParent);
+            go.SetActive(true);
+            RectTransform rf = go.GetComponent<RectTransform>();
+            rf.localScale = Vector3.one;
+            rf.anchoredPosition3D = Vector3.zero;
+            rf.localEulerAngles = Vector3.zero;
+            LoopGridViewItem tViewItem = go.GetComponent<LoopGridViewItem>();
+            tViewItem.ItemPrefabName = _prefabName;
+            tViewItem.GoId = go.GetHashCode();
+            return tViewItem;
+        }
+        void RecycleItemReal(LoopGridViewItem item)
+        {
+            item.gameObject.SetActive(false);
+            _pooledItemList.Add(item);
+        }
+        public void RecycleItem(LoopGridViewItem item)
+        {
+            item.PrevItem = null;
+            item.NextItem = null;
+            _tmpPooledItemList.Add(item);
+        }
+        public void ClearTmpRecycledItem()
+        {
+            int count = _tmpPooledItemList.Count;
+            if (count == 0)
+            {
+                return;
+            }
+            for (int i = 0; i < count; ++i)
+            {
+                RecycleItemReal(_tmpPooledItemList[i]);
+            }
+            _tmpPooledItemList.Clear();
+        }
+    }
+}

UnityProject/Assets/GameScripts/HotFix/GameLogic/Common/UI/SuperScrollView/Scripts/GridView/LoopGridItemPool.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: c1eb92a17e8cee642a2245950dfaabea
+timeCreated: 1554538573
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

UnityProject/Assets/GameScripts/HotFix/GameLogic/Common/UI/SuperScrollView/Scripts/GridView/LoopGridView.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 17e9881a7bce8124a8f855b96a8ca11a
+timeCreated: 1554538573
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

UnityProject/Assets/GameScripts/HotFix/GameLogic/Common/UI/SuperScrollView/Scripts/GridView/LoopGridViewItem.cs

@@ -0,0 +1,184 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace GameLogic
+{
+
+    public class LoopGridViewItem : MonoBehaviour
+    {
+        // indicates the item’s index in the list the mItemIndex can only be from 0 to itemTotalCount -1.
+        int mItemIndex = -1;
+        // the row index, the item is in. starting from 0.
+        int mRow = -1;
+        // the column index, the item is in. starting from 0.
+        int mColumn = -1;
+        //indicates the item’s id. 
+        //This property is set when the item is created or fetched from pool, 
+        //and will no longer change until the item is recycled back to pool.
+        int mItemId = -1;
+        
+        private int _goId = 0;
+        
+        public int GoId
+        {
+            set => _goId = value;
+            get => _goId;
+        }
+        
+        LoopGridView mParentGridView = null;
+        bool mIsInitHandlerCalled = false;
+        string mItemPrefabName;
+        RectTransform mCachedRectTransform;
+        int mItemCreatedCheckFrameCount = 0;
+
+        object mUserObjectData = null;
+        int mUserIntData1 = 0;
+        int mUserIntData2 = 0;
+        string mUserStringData1 = null;
+        string mUserStringData2 = null;
+
+        LoopGridViewItem mPrevItem;
+        LoopGridViewItem mNextItem;
+
+        public object UserObjectData
+        {
+            get { return mUserObjectData; }
+            set { mUserObjectData = value; }
+        }
+        public int UserIntData1
+        {
+            get { return mUserIntData1; }
+            set { mUserIntData1 = value; }
+        }
+        public int UserIntData2
+        {
+            get { return mUserIntData2; }
+            set { mUserIntData2 = value; }
+        }
+        public string UserStringData1
+        {
+            get { return mUserStringData1; }
+            set { mUserStringData1 = value; }
+        }
+        public string UserStringData2
+        {
+            get { return mUserStringData2; }
+            set { mUserStringData2 = value; }
+        }
+
+        public int ItemCreatedCheckFrameCount
+        {
+            get { return mItemCreatedCheckFrameCount; }
+            set { mItemCreatedCheckFrameCount = value; }
+        }
+
+
+        public RectTransform CachedRectTransform
+        {
+            get
+            {
+                if (mCachedRectTransform == null)
+                {
+                    mCachedRectTransform = gameObject.GetComponent<RectTransform>();
+                }
+                return mCachedRectTransform;
+            }
+        }
+
+        public string ItemPrefabName
+        {
+            get
+            {
+                return mItemPrefabName;
+            }
+            set
+            {
+                mItemPrefabName = value;
+            }
+        }
+
+        public int Row
+        {
+            get
+            {
+                return mRow;
+            }
+            set
+            {
+                mRow = value;
+            }
+        }
+        public int Column
+        {
+            get
+            {
+                return mColumn;
+            }
+            set
+            {
+                mColumn = value;
+            }
+        }
+
+        public int ItemIndex
+        {
+            get
+            {
+                return mItemIndex;
+            }
+            set
+            {
+                mItemIndex = value;
+            }
+        }
+        public int ItemId
+        {
+            get
+            {
+                return mItemId;
+            }
+            set
+            {
+                mItemId = value;
+            }
+        }
+
+
+        public bool IsInitHandlerCalled
+        {
+            get
+            {
+                return mIsInitHandlerCalled;
+            }
+            set
+            {
+                mIsInitHandlerCalled = value;
+            }
+        }
+
+        public LoopGridView ParentGridView
+        {
+            get
+            {
+                return mParentGridView;
+            }
+            set
+            {
+                mParentGridView = value;
+            }
+        }
+
+        public LoopGridViewItem PrevItem
+        {
+            get { return mPrevItem; }
+            set { mPrevItem = value; }
+        }
+        public LoopGridViewItem NextItem
+        {
+            get { return mNextItem; }
+            set { mNextItem = value; }
+        }
+
+    }
+}

UnityProject/Assets/GameScripts/HotFix/GameLogic/Common/UI/SuperScrollView/Scripts/GridView/LoopGridViewItem.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: ec0432517adfcb84bb6163d7a44ab8c1
+timeCreated: 1554538573
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

UnityProject/Assets/GameScripts/HotFix/GameLogic/Common/UI/SuperScrollView/Scripts/ListView.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: e9bbd48a4abc45c46a92b92d0df3ae07
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

UnityProject/Assets/GameScripts/HotFix/GameLogic/Common/UI/SuperScrollView/Scripts/ListView/LoopListView.cs.meta

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

UnityProject/Assets/GameScripts/HotFix/GameLogic/Common/UI/SuperScrollView/Scripts/ListView/LoopListViewItem.cs

@@ -0,0 +1,216 @@
+using UnityEngine;
+
+namespace GameLogic
+{
+    public class LoopListViewItem : MonoBehaviour
+    {
+        public float Padding;
+        
+        private int _itemIndex = -1;
+        private int _itemId = -1;
+        private LoopListView _parentListView = null;
+        private bool _isInitHandlerCalled = false;
+        private string _itemPrefabName;
+        private RectTransform _cachedRectTransform;
+        private float _padding;
+        private float _distanceWithViewPortSnapCenter = 0;
+        private int _itemCreatedCheckFrameCount = 0;
+        private float _startPosOffset = 0;
+
+        private object _userObjectData = null;
+        private int _userIntData1 = 0;
+        private int _userIntData2 = 0;
+        private string _userStringData1 = null;
+        private string _userStringData2 = null;
+
+        private int _goId = 0;
+        
+        public int GoId
+        {
+            set => _goId = value;
+            get => _goId;
+        }
+
+        public object UserObjectData
+        {
+            get => _userObjectData;
+            set => _userObjectData = value;
+        }
+
+        public int UserIntData1
+        {
+            get => _userIntData1;
+            set => _userIntData1 = value;
+        }
+
+        public int UserIntData2
+        {
+            get => _userIntData2;
+            set => _userIntData2 = value;
+        }
+
+        public string UserStringData1
+        {
+            get => _userStringData1;
+            set => _userStringData1 = value;
+        }
+
+        public string UserStringData2
+        {
+            get => _userStringData2;
+            set => _userStringData2 = value;
+        }
+
+        public float DistanceWithViewPortSnapCenter
+        {
+            get => _distanceWithViewPortSnapCenter;
+            set => _distanceWithViewPortSnapCenter = value;
+        }
+
+        public float StartPosOffset
+        {
+            get => _startPosOffset;
+            set => _startPosOffset = value;
+        }
+
+        public int ItemCreatedCheckFrameCount
+        {
+            get => _itemCreatedCheckFrameCount;
+            set => _itemCreatedCheckFrameCount = value;
+        }
+
+        public RectTransform CachedRectTransform
+        {
+            get
+            {
+                if (_cachedRectTransform == null)
+                {
+                    _cachedRectTransform = gameObject.GetComponent<RectTransform>();
+                }
+
+                return _cachedRectTransform;
+            }
+        }
+
+        public string ItemPrefabName
+        {
+            get => _itemPrefabName;
+            set => _itemPrefabName = value;
+        }
+
+        public int ItemIndex
+        {
+            get => _itemIndex;
+            set => _itemIndex = value;
+        }
+
+        public int ItemId
+        {
+            get => _itemId;
+            set => _itemId = value;
+        }
+
+
+        public bool IsInitHandlerCalled
+        {
+            get => _isInitHandlerCalled;
+            set => _isInitHandlerCalled = value;
+        }
+
+        public LoopListView ParentListView
+        {
+            get => _parentListView;
+            set => _parentListView = value;
+        }
+
+        public float TopY
+        {
+            get
+            {
+                ListItemArrangeType arrageType = ParentListView.ArrangeType;
+                if (arrageType == ListItemArrangeType.TopToBottom)
+                {
+                    return CachedRectTransform.localPosition.y;
+                }
+                else if (arrageType == ListItemArrangeType.BottomToTop)
+                {
+                    return CachedRectTransform.localPosition.y + CachedRectTransform.rect.height;
+                }
+
+                return 0;
+            }
+        }
+
+        public float BottomY
+        {
+            get
+            {
+                ListItemArrangeType arrageType = ParentListView.ArrangeType;
+                if (arrageType == ListItemArrangeType.TopToBottom)
+                {
+                    return CachedRectTransform.localPosition.y - CachedRectTransform.rect.height;
+                }
+                else if (arrageType == ListItemArrangeType.BottomToTop)
+                {
+                    return CachedRectTransform.localPosition.y;
+                }
+
+                return 0;
+            }
+        }
+
+
+        public float LeftX
+        {
+            get
+            {
+                ListItemArrangeType arrageType = ParentListView.ArrangeType;
+                if (arrageType == ListItemArrangeType.LeftToRight)
+                {
+                    return CachedRectTransform.localPosition.x;
+                }
+                else if (arrageType == ListItemArrangeType.RightToLeft)
+                {
+                    return CachedRectTransform.localPosition.x - CachedRectTransform.rect.width;
+                }
+
+                return 0;
+            }
+        }
+
+        public float RightX
+        {
+            get
+            {
+                ListItemArrangeType arrageType = ParentListView.ArrangeType;
+                if (arrageType == ListItemArrangeType.LeftToRight)
+                {
+                    return CachedRectTransform.localPosition.x + CachedRectTransform.rect.width;
+                }
+                else if (arrageType == ListItemArrangeType.RightToLeft)
+                {
+                    return CachedRectTransform.localPosition.x;
+                }
+
+                return 0;
+            }
+        }
+
+        public float ItemSize
+        {
+            get
+            {
+                if (ParentListView.IsVertList)
+                {
+                    return CachedRectTransform.rect.height;
+                }
+                else
+                {
+                    return CachedRectTransform.rect.width;
+                }
+            }
+        }
+
+        public float ItemSizeWithPadding => ItemSize + _padding;
+    }
+}

UnityProject/Assets/GameScripts/HotFix/GameLogic/Common/UI/SuperScrollView/Scripts/ListView/LoopListViewItem.cs.meta

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

UnityProject/Assets/GameScripts/HotFix/GameLogic/Common/UI/SwitchPage.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 4f3fbd5ce2514056b72986a6dea2aec2
+timeCreated: 1695289443

UnityProject/Assets/GameScripts/HotFix/GameLogic/Common/UI/SwitchPage/ChildPageBase.cs

@@ -0,0 +1,71 @@
+using TEngine;
+
+namespace GameLogic
+{
+    /// <summary>
+    /// 子界面之间共享的数据。
+    /// </summary>
+    public class ChildPageSharData
+    {
+        private object[] m_arrParams = new object[3];    // 共享参数列表
+
+        public object Param1 { get { return m_arrParams[0]; } }
+        public object Param2 { get { return m_arrParams[1]; } }
+        public object Param3 { get { return m_arrParams[2]; } }
+
+        /// <summary>
+        /// 设置指定索引的参数。
+        /// </summary>
+        /// <param name="paramIdx"></param>
+        /// <param name="param"></param>
+        public void SetParam(int paramIdx, object param)
+        {
+            if (paramIdx >= m_arrParams.Length)
+                return;
+
+            m_arrParams[paramIdx] = param;
+        }
+    }
+
+    public class ChildPageBase : UIWidget
+    {
+
+        protected ChildPageSharData m_shareObjData;     // 共享数据
+
+        // 初始化数据
+        public void InitData(ChildPageSharData shareObjData)
+        {
+            m_shareObjData = shareObjData;
+        }
+
+        public virtual void OnPageShowed(int oldShowType, int newShowType)
+        {
+
+        }
+
+        // 无参数刷新当前子界面
+        // 收到那些数据变动的消息的时候使用
+        public virtual void RefreshPage()
+        {
+
+        }
+
+        public object ShareData1
+        {
+            get => m_shareObjData.Param1;
+            set => m_shareObjData.SetParam(0, value);
+        }
+
+        public object ShareData2
+        {
+            get => m_shareObjData.Param2;
+            set => m_shareObjData.SetParam(1, value);
+        }
+
+        public object ShareData3
+        {
+            get => m_shareObjData.Param3;
+            set => m_shareObjData.SetParam(2, value);
+        }
+    }
+}

UnityProject/Assets/GameScripts/HotFix/GameLogic/Common/UI/SwitchPage/ChildPageBase.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: e4b742d9af72478b9d6f7ebd2fa493a0
+timeCreated: 1687859782

UnityProject/Assets/GameScripts/HotFix/GameLogic/Common/UI/SwitchPage/SwitchPageMgr.cs

@@ -0,0 +1,457 @@
+using System;
+using System.Collections.Generic;
+using TEngine;
+using UnityEngine;
+
+namespace GameLogic
+{
+    public class SwitchPageMgr
+    {
+        private event Action<int, int> SwitchTabAction;
+
+        public delegate bool SwitchTabCondition(int selectId);
+
+        private SwitchTabCondition _switchTabCondition;
+
+        /// <summary>
+        /// 页签Grid。
+        /// </summary>
+        protected Transform m_tabGrid;
+
+        /// <summary>
+        /// 子UI父节点。
+        /// </summary>
+        public Transform ChildPageParent;
+
+        /// <summary>
+        /// 存储子UI。
+        /// </summary>
+        private readonly Dictionary<int, List<string>> _switchPageDic = new Dictionary<int, List<string>>();
+
+        /// <summary>
+        /// 子页签名字。
+        /// </summary>
+        private readonly List<string> _childPageNames = new List<string>();
+
+        /// <summary>
+        /// 子页签字典。
+        /// </summary>
+        private readonly Dictionary<string, ChildPageBase> _childPageDic = new Dictionary<string, ChildPageBase>();
+
+        /// <summary>
+        /// 存储页签。
+        /// </summary>
+        private readonly Dictionary<int, SwitchTabItem> _tabDic = new Dictionary<int, SwitchTabItem>();
+
+        private readonly Dictionary<int, string> _tabName = new Dictionary<int, string>();
+
+        protected readonly List<int> IDList = new List<int>();
+
+        private readonly UIBase _owner;
+
+        protected int CurrentChildID = -100;
+
+        /// <summary>
+        /// 需要设置显示隐藏。
+        /// </summary>
+        private readonly bool _needSetActive;
+
+        /// <summary>
+        /// 子界面的共享数据。
+        /// </summary>
+        private readonly ChildPageSharData _shareData = new ChildPageSharData();
+
+        public object ShareData1 => _shareData.Param1;
+        public object ShareData2 => _shareData.Param2;
+        public object ShareData3 => _shareData.Param3;
+
+        public SwitchPageMgr(Transform grid, Transform childPageParent, UIBase owner, bool needSetActive = true)
+        {
+            m_tabGrid = grid;
+            ChildPageParent = childPageParent;
+            _owner = owner;
+            _needSetActive = needSetActive;
+        }
+
+        public void AddSwitchAction(Action<int, int> action)
+        {
+            SwitchTabAction += action;
+        }
+
+        public void RemoveSwitchAction(Action<int, int> action)
+        {
+            SwitchTabAction -= action;
+        }
+
+        public void AddSwitchCondition(SwitchTabCondition action)
+        {
+            _switchTabCondition = action;
+        }
+
+        public void BindChildPage<T>(int childID) where T : ChildPageBase, new()
+        {
+            BindChildPage<T>(childID, string.Empty);
+        }
+
+        public void BindChildPage<T>(int childID, string tabName) where T : ChildPageBase, new()
+        {
+            var pageName = typeof(T).Name;
+
+            if (IDList.IndexOf(childID) < 0)
+            {
+                IDList.Add(childID);
+            }
+
+            if (!_childPageDic.ContainsKey(pageName))
+            {
+                _childPageDic[pageName] = new T();
+                _childPageNames.Add(pageName);
+            }
+
+            if (!_switchPageDic.ContainsKey(childID))
+            {
+                _switchPageDic[childID] = new List<string>();
+            }
+
+            if (_switchPageDic[childID].IndexOf(pageName) < 0)
+            {
+                _switchPageDic[childID].Add(pageName);
+            }
+
+            _tabName[childID] = tabName;
+        }
+
+        public T CreatTab<T>(int initChildID, GameObject tabTemp = null) where T : SwitchTabItem, new()
+        {
+            T tab = null;
+            for (var index = 0; index < IDList.Count; index++)
+            {
+                var childID = IDList[index];
+                if (!_tabDic.ContainsKey(childID))
+                {
+                    if (tabTemp != null)
+                    {
+                        tab = _owner.CreateWidgetByPrefab<T>(tabTemp, m_tabGrid);
+                    }
+                    else
+                    {
+                        tab = _owner.CreateWidgetByType<T>(m_tabGrid);
+                    }
+
+                    tab.UpdateTabName(_tabName[childID]);
+                    tab.BindClickEvent(TabOnClick, childID);
+                    _tabDic[childID] = tab;
+                    break;
+                }
+            }
+
+            SwitchPage(initChildID);
+            return tab;
+        }
+
+        public void CreatTabByItem<T>(int initChildID, GameObject go) where T : SwitchTabItem, new()
+        {
+            if (!_tabDic.ContainsKey(initChildID))
+            {
+                T tab = _owner.CreateWidgetByPrefab<T>(go, m_tabGrid);
+                tab.UpdateTabName(_tabName[initChildID]);
+                tab.BindClickEvent(TabOnClick, initChildID);
+                _tabDic[initChildID] = tab;
+            }
+        }
+
+        // 设置页签的自定义点击行为
+        public void SetCustomTabClickAction(int tabIdx, Action<SwitchTabItem> clickAction, object param1 = null,
+            object param2 = null, object param3 = null)
+        {
+            _tabDic[tabIdx].BindClickEvent(clickAction, param1, param2, param3);
+        }
+
+        public int TabCount => _tabDic.Count;
+
+        public void SetTabRedNode(int tabId, bool isShow)
+        {
+            if (_tabDic.TryGetValue(tabId, out var value))
+            {
+                value.SetRedNote(isShow);
+            }
+        }
+
+        public void SetTabFontSize(int fontSize)
+        {
+            for (int i = 0; i < IDList.Count; i++)
+            {
+                var tabId = IDList[i];
+                _tabDic[tabId].SetITabTextFontSize(fontSize);
+            }
+        }
+
+        private void TabOnClick(SwitchTabItem tab)
+        {
+            var childID = (int)tab.EventParam1;
+            SwitchPage(childID);
+        }
+
+        public virtual void SwitchPage(int selectID)
+        {
+            if (_switchTabCondition != null && !_switchTabCondition(selectID))
+            {
+                return;
+            }
+
+            if (CurrentChildID != selectID)
+            {
+                if (_switchPageDic.TryGetValue(selectID, out var pageLs))
+                {
+                    for (int i = 0; i < pageLs.Count; i++)
+                    {
+                        var pageName = pageLs[i];
+                        ChildPageBase page = GetChildPageByName(pageName);
+                        if (page != null && page.gameObject == null)
+                        {
+                            page.CreateByPath(pageName, _owner, ChildPageParent);
+                            page.InitData(_shareData);
+                        }
+                    }
+
+                    for (int i = 0; i < _childPageNames.Count; i++)
+                    {
+                        string pageName = _childPageNames[i];
+                        ChildPageBase page = GetChildPageByName(pageName);
+                        bool beShow = pageLs.IndexOf(pageName) >= 0;
+                        if (page != null && page.gameObject != null)
+                        {
+                            if (_needSetActive)
+                            {
+                                //page.Show(beShow);
+                                if (beShow)
+                                {
+                                    page.gameObject.SetActive(true);
+                                    // page.Visible = true;
+                                }
+                                else
+                                {
+                                    page.gameObject.SetActive(false);
+                                    // page.Visible = false;
+                                }
+                            }
+                        }
+
+                        // if (page != null && beShow)
+                        if (page != null)
+                        {
+                            page.OnPageShowed(CurrentChildID, selectID);
+                        }
+                    }
+                }
+
+                for (var index = 0; index < IDList.Count; index++)
+                {
+                    var childID = IDList[index];
+                    SwitchTabItem tab;
+                    if (_tabDic.TryGetValue(childID, out tab))
+                    {
+                        tab.SetState(selectID == childID);
+                    }
+                }
+            }
+
+            var oldID = CurrentChildID;
+            CurrentChildID = selectID;
+            if (SwitchTabAction != null)
+            {
+                SwitchTabAction(oldID, selectID);
+            }
+        }
+
+        public virtual void ShowPage(int selectID)
+        {
+            if (_switchPageDic.TryGetValue(selectID, out var pageLs))
+            {
+                for (int i = 0; i < pageLs.Count; i++)
+                {
+                    var pageName = pageLs[i];
+                    ChildPageBase page = GetChildPageByName(pageName);
+                    if (page != null && page.gameObject == null)
+                    {
+                        page.CreateByPath(pageName, _owner, ChildPageParent);
+                        page.InitData(_shareData);
+                    }
+                }
+
+                for (int i = 0; i < _childPageNames.Count; i++)
+                {
+                    string pageName = _childPageNames[i];
+                    ChildPageBase page = GetChildPageByName(pageName);
+                    bool beShow = pageLs.IndexOf(pageName) >= 0;
+                    if (page != null && page.gameObject != null)
+                    {
+                        if (beShow)
+                        {
+                            page.gameObject.SetActive(true);
+                            // page.Visible = true;
+                        }
+                        else
+                        {
+                            page.gameObject.SetActive(false);
+                            // page.Visible = false;
+                        }
+                    }
+                }
+            }
+
+            for (var index = 0; index < IDList.Count; index++)
+            {
+                var childID = IDList[index];
+                SwitchTabItem tab;
+                if (_tabDic.TryGetValue(childID, out tab))
+                {
+                    tab.SetState(selectID == childID);
+                }
+            }
+        }
+
+        public void RefreshCurrentChildPage()
+        {
+            if (_switchPageDic.TryGetValue(CurrentChildID, out var pageNames))
+            {
+                for (int i = 0; i < pageNames.Count; i++)
+                {
+                    ChildPageBase page = GetChildPageByName(pageNames[i]);
+                    if (page != null && page.gameObject != null)
+                    {
+                        page.RefreshPage();
+                    }
+                }
+            }
+        }
+
+        public void RefreshChildPage(int childID)
+        {
+            if (_switchPageDic.TryGetValue(childID, out var pageNames))
+            {
+                for (int i = 0; i < pageNames.Count; i++)
+                {
+                    ChildPageBase page = GetChildPageByName(pageNames[i]);
+                    if (page != null && page.gameObject != null)
+                    {
+                        page.RefreshPage();
+                    }
+                }
+            }
+        }
+
+        public bool TryGetChildPage<T>(out T t) where T : ChildPageBase
+        {
+            t = GetChildPage<T>();
+            return t != null;
+        }
+
+        public int GetCurShowType()
+        {
+            return CurrentChildID;
+        }
+
+        public void ReductionShowType()
+        {
+            CurrentChildID = -100;
+        }
+
+        #region 没有ChildPage，可通过m_switchTabAction来处理切页事件(也可以光展示用)
+
+        public SwitchTabItem GetTabItem(int childId)
+        {
+            _tabDic.TryGetValue(childId, out var item);
+            return item;
+        }
+
+        public void CreateJumpTab<T>(int initChildID, string tabName, GameObject tabTemp = null)
+            where T : SwitchTabItem, new()
+        {
+            if (IDList.IndexOf(initChildID) < 0)
+            {
+                IDList.Add(initChildID);
+            }
+
+            _tabName[initChildID] = tabName;
+
+            for (var index = 0; index < IDList.Count; index++)
+            {
+                var childID = IDList[index];
+                if (!_tabDic.ContainsKey(childID))
+                {
+                    T tab;
+                    if (tabTemp != null)
+                    {
+                        tab = _owner.CreateWidgetByPrefab<T>(tabTemp, m_tabGrid);
+                    }
+                    else
+                    {
+                        tab = _owner.CreateWidgetByType<T>(m_tabGrid);
+                    }
+
+                    tab.UpdateTabName(_tabName[childID]);
+                    tab.BindClickEvent(TabOnClick, childID);
+                    _tabDic[childID] = tab;
+                }
+            }
+
+            SwitchPage(initChildID);
+        }
+
+        #endregion
+
+        /// <summary>
+        /// 设置共享参数。
+        /// </summary>
+        /// <param name="paramIdx"></param>
+        /// <param name="param"></param>
+        public void SetShareParam(int paramIdx, object param)
+        {
+            _shareData.SetParam(paramIdx, param);
+        }
+
+        public T GetChildPage<T>() where T : ChildPageBase
+        {
+            var pageName = typeof(T).Name;
+            _childPageDic.TryGetValue(pageName, out var page);
+            return page as T;
+        }
+
+        public ChildPageBase GetChildPageByName(string pageName)
+        {
+            _childPageDic.TryGetValue(pageName, out var page);
+            return page;
+        }
+
+        public void BindChildPage<T, U>(int childID, string tabName)
+            where T : ChildPageBase, new()
+            where U : ChildPageBase, new()
+        {
+            BindChildPage<T>(childID, tabName);
+            BindChildPage<U>(childID, tabName);
+        }
+
+        public void BindChildPage<T, U, V>(int childID, string tabName)
+            where T : ChildPageBase, new()
+            where U : ChildPageBase, new()
+            where V : ChildPageBase, new()
+        {
+            BindChildPage<T>(childID, tabName);
+            BindChildPage<U>(childID, tabName);
+            BindChildPage<V>(childID, tabName);
+        }
+
+        public void BindChildPage<T, U, V, W>(int childID, string tabName)
+            where T : ChildPageBase, new()
+            where U : ChildPageBase, new()
+            where V : ChildPageBase, new()
+            where W : ChildPageBase, new()
+        {
+            BindChildPage<T>(childID, tabName);
+            BindChildPage<U>(childID, tabName);
+            BindChildPage<V>(childID, tabName);
+            BindChildPage<W>(childID, tabName);
+        }
+    }
+}

UnityProject/Assets/GameScripts/HotFix/GameLogic/Common/UI/SwitchPage/SwitchPageMgr.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: e04155ae1ce3448587a5e322477d0076
+timeCreated: 1687859725

UnityProject/Assets/GameScripts/HotFix/GameLogic/Common/UI/SwitchPage/SwitchTabItem.cs

@@ -0,0 +1,263 @@
+using System;
+using TMPro;
+using UnityEngine;
+using UnityEngine.UI;
+
+namespace GameLogic
+{
+    public class SwitchTabItem : UIEventItem<SwitchTabItem>
+    {
+        //选中时的文本
+        protected TextMeshProUGUI m_selectText;
+        //未选中时的文本
+        protected TextMeshProUGUI m_noSelectText;
+        //选中时的图片
+        protected Image m_selectImage;
+        //未选中时的图片
+        protected Image m_noSelectImage;
+        //选中时的节点
+        protected Transform m_selectNode;
+        //未选中时的节点
+        protected Transform m_noSelectNode;
+        
+        //选中时的Icon
+        protected Image m_selectIcon;
+        //未选中时的Icon
+        protected Image m_noSelectIcon;
+
+        protected GameObject m_goRedNote;
+
+        //是否选中
+        public bool IsSelect
+        {
+            get { return m_isSelect; }
+            set { SetState(value); }
+        }
+
+        protected bool m_isSelect = false;
+
+        //private RedNoteBehaviour m_redNote;
+        public RedNoteWidget m_redNote { get; private set; }
+
+        public virtual Vector2 SelectRedPointPos
+        {
+            get
+            {
+                return Vector2.zero;
+            }
+        }
+
+        public virtual Vector2 NoSelectRedPointPos
+        {
+            get
+            {
+                return Vector2.zero;
+            }
+        }
+
+        public override void BindMemberProperty()
+        {
+            m_selectNode = FindChild("SelectNode");
+            m_noSelectNode = FindChild("NoSelectNode");
+            if (m_selectNode != null)
+            {
+                m_selectText = FindChildComponent<TextMeshProUGUI>(m_selectNode, "SelectText");
+                m_selectImage = FindChildComponent<Image>(m_selectNode, "SelectImage");
+                m_selectIcon = FindChildComponent<Image>(m_selectNode, "SelectIcon");
+            }
+            if (m_noSelectNode != null)
+            {
+                m_noSelectText = FindChildComponent<TextMeshProUGUI>(m_noSelectNode, "NoSelectText");
+                m_noSelectImage = FindChildComponent<Image>(m_noSelectNode, "NoSelectImage");
+                m_noSelectIcon = FindChildComponent<Image>(m_noSelectNode, "NoSelectIcon");
+            }
+            
+            var tf = FindChild("m_goRedNote");
+            if (tf != null)
+            {
+                m_goRedNote = tf.gameObject;
+                m_redNote = CreateWidgetByType<RedNoteWidget>(tf);
+                m_redNote.rectTransform.anchoredPosition = Vector2.zero;
+                SetRedNote(false);
+                //CreateDefaultRedNote();
+            }
+        }
+
+        #region 红点相关
+        public void SetRedNoteType(RedNoteNotify type)
+        {
+            if (m_redNote != null)
+            {
+                m_redNote.m_redNote.SetNotifyType(type);
+            }
+            SetRedNote(true);
+        }
+
+        public void SetRedNoteType(RedNoteNotify type, ulong param1)
+        {
+            if (m_redNote != null)
+            {
+                m_redNote.m_redNote.SetNotifyType(type, param1);
+            }
+            SetRedNote(true);
+        }
+
+        public void SetRedNoteType(RedNoteNotify type, ulong param1, ulong param2)
+        {
+            if (m_redNote != null)
+            {
+                m_redNote.m_redNote.SetNotifyType(type, param1, param2);
+            }
+            SetRedNote(true);
+        }
+
+        public void SetRedNoteType(RedNoteNotify type, ulong param1, ulong param2, ulong param3)
+        {
+            if (m_redNote != null)
+            {
+                m_redNote.m_redNote.SetNotifyType(type, param1, param2, param3);
+            }
+            SetRedNote(true);
+        }
+
+        public void SetRedNoteState(bool state)
+        {
+            if (m_redNote != null)
+            {
+                m_redNote.m_redNote.SetRedNoteState(state);
+            }
+            SetRedNote(state);
+        }
+
+        #endregion
+
+        public void UpdateTabName(string tabName)
+        {
+            if (m_selectText != null)
+            {
+                m_selectText.text = tabName;
+                m_selectText.rectTransform.sizeDelta = new Vector2(m_selectText.preferredWidth, m_selectText.rectTransform.sizeDelta.y);
+            }
+            if (m_noSelectText != null)
+            {
+                m_noSelectText.text = tabName;
+                m_noSelectText.rectTransform.sizeDelta = new Vector2(m_noSelectText.preferredWidth, m_noSelectText
+                   .rectTransform.sizeDelta.y);
+            }
+        }
+
+        // public void UpdateTabImage(string selectImageName,string noSelectImageName)
+        // {
+        //     if (m_selectImage != null)
+        //     {
+        //         UISpriteHelper.Instance.SetSprite(m_selectImage, selectImageName);
+        //     }
+        //     if (m_noSelectImage != null)
+        //     {
+        //         UISpriteHelper.Instance.SetSprite(m_noSelectImage, noSelectImageName);
+        //     }
+        // }
+        //
+        // public void UpdateIcon(string selectIconName, string noSelectIconName)
+        // {
+        //     if (m_selectIcon != null)
+        //     {
+        //         DUISpriteHelper.Instance.SetSprite(m_selectIcon, selectIconName, true);
+        //     }
+        //     if (m_noSelectIcon != null)
+        //     {
+        //         DUISpriteHelper.Instance.SetSprite(m_noSelectIcon, noSelectIconName, true);
+        //     }
+        // }
+        //
+        // public virtual void CreateDefaultRedNote()
+        // {
+        //     if (m_goRedNote != null)
+        //     {
+        //         UIEffectHelper.CreateUIEffectGoById((uint)CommonEffectID.EffectRedPoint, m_goRedNote.transform);
+        //     }
+        // }
+
+        public void SetRedNote(bool show)
+        {
+            if (m_goRedNote != null)
+            {
+                m_goRedNote.SetActive(show);
+            }
+        }
+
+        public virtual void SetState(bool select)
+        {
+            m_isSelect = select;
+            if (m_selectNode != null)
+            {
+                m_selectNode.gameObject.SetActive(select);
+            }
+            if (m_noSelectNode != null)
+            {
+                m_noSelectNode.gameObject.SetActive(!select);
+            }
+
+            if (m_goRedNote != null)
+            {
+                if (select)
+                {
+                    if (SelectRedPointPos != Vector2.zero)
+                    {
+                        ((RectTransform)m_goRedNote.transform).anchoredPosition = SelectRedPointPos;
+                    }
+                }
+                else
+                {
+                    if (NoSelectRedPointPos != Vector2.zero)
+                    {
+                        ((RectTransform)m_goRedNote.transform).anchoredPosition = NoSelectRedPointPos;
+                    }
+                }
+            }
+        }
+
+        public void SetITabTextFontSize(int fontSize)
+        {
+            if (m_selectText != null)
+            {
+                m_selectText.fontSize = fontSize;
+            }
+            if (m_noSelectText != null)
+            {
+                m_noSelectText.fontSize = fontSize;
+            }
+        }
+
+        #region UI-ID
+        /// <summary>
+        /// UI-ID
+        /// </summary>
+        public uint uiID;
+
+        /// <summary>
+        /// UI标识
+        /// </summary>
+        protected string m_uiFlag;
+
+        /// <summary>
+        /// 检查方法
+        /// </summary>
+        protected Func<bool> m_funcCheck;
+
+        /// <summary>
+        /// 页签索引
+        /// </summary>
+        public int tabIndex = -1;
+
+        /// <summary>
+        /// UI标识
+        /// </summary>
+        /// <returns></returns>
+        public virtual string GetUiFlag()
+        {
+            return string.IsNullOrEmpty(m_uiFlag) ? uiID.ToString() : m_uiFlag;
+        }
+        #endregion
+    }
+}

UnityProject/Assets/GameScripts/HotFix/GameLogic/Common/UI/SwitchPage/SwitchTabItem.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 498417b8785d47249da952f77d069c33
+timeCreated: 1687667780

UnityProject/Assets/GameScripts/HotFix/GameLogic/Common/UI/UGUIExtension.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: b50cf85b0f0d4e43b12cb694f6c07979
+timeCreated: 1695289335

UnityProject/Assets/GameScripts/HotFix/GameLogic/Common/UI/UGUIExtension/EmptyGraph.cs

@@ -0,0 +1,18 @@
+using UnityEngine.UI;
+
+public class EmptyGraph : Graphic
+{
+    public bool m_debug = false;
+
+    protected override void OnPopulateMesh(VertexHelper vbo)
+    {
+        vbo.Clear();
+
+#if UNITY_EDITOR
+        if (m_debug)
+        {
+            base.OnPopulateMesh(vbo);
+        }
+#endif
+    }
+}

UnityProject/Assets/GameScripts/HotFix/GameLogic/Common/UI/UGUIExtension/EmptyGraph.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 21df3dfa358b498e8da3d169d736df58
+timeCreated: 1695289370

UnityProject/Assets/GameScripts/HotFix/GameLogic/Common/UI/UGUIExtension/TScrollRect.cs

@@ -0,0 +1,138 @@
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.EventSystems;
+using UnityEngine.UI;
+
+namespace GameLogic
+{
+    [AddComponentMenu("UI/TScrollRect Rect", 37)]
+    [SelectionBase]
+    [ExecuteAlways]
+    [DisallowMultipleComponent]
+    [RequireComponent(typeof (RectTransform))]
+    public class TScrollRect : ScrollRect
+    {
+        private event Action ActionBeginDrag;
+        private event Action ActionOnDrag;
+        private event Action ActionEndDrag;
+
+        public List<ScrollRect> parentScrollRectList;
+
+        protected override void Awake()
+        {
+            base.Awake();
+            if (parentScrollRectList != null && parentScrollRectList.Count > 0)
+            {
+                for (int i = 0; i < parentScrollRectList.Count; i++)
+                {
+                    AddParentScrollRect(parentScrollRectList[i]);
+                }
+            }
+        }
+
+        private List<ScrollRect> m_listParentScrollRect;
+
+        public void AddParentScrollRect(ScrollRect parentScrollRect)
+        {
+            if (parentScrollRect == null)
+            {
+                return;
+            }
+
+            if (m_listParentScrollRect == null)
+            {
+                m_listParentScrollRect = new List<ScrollRect>();
+            }
+
+            if (!m_listParentScrollRect.Contains(parentScrollRect))
+            {
+                m_listParentScrollRect.Add(parentScrollRect);
+            }
+        }
+
+        public void AddBeginDragListener(Action action)
+        {
+            ActionBeginDrag += action;
+        }
+
+        public void RemoveBeginDragListener(Action action)
+        {
+            ActionBeginDrag -= action;
+        }
+
+        public void AddOnDragListener(Action action)
+        {
+            ActionOnDrag += action;
+        }
+
+        public void RemoveOnDragListener(Action action)
+        {
+            ActionOnDrag -= action;
+        }
+
+        public void AddEndDragListener(Action action)
+        {
+            ActionEndDrag += action;
+        }
+
+        public void RemoveEndDragListener(Action action)
+        {
+            ActionEndDrag -= action;
+        }
+
+        public override void OnBeginDrag(PointerEventData eventData)
+        {
+            base.OnBeginDrag(eventData);
+            if (ActionBeginDrag != null)
+            {
+                ActionBeginDrag();
+            }
+
+            if (m_listParentScrollRect != null)
+            {
+                for (int i = 0; i < m_listParentScrollRect.Count; i++)
+                {
+                    var parentScrollRect = m_listParentScrollRect[i];
+                    parentScrollRect.OnBeginDrag(eventData);
+                }
+            }
+        }
+
+        public override void OnDrag(PointerEventData eventData)
+        {
+            base.OnDrag(eventData);
+            if (ActionOnDrag != null)
+            {
+                ActionOnDrag();
+            }
+
+            if (m_listParentScrollRect != null)
+            {
+                for (int i = 0; i < m_listParentScrollRect.Count; i++)
+                {
+                    var parentScrollRect = m_listParentScrollRect[i];
+                    parentScrollRect.OnDrag(eventData);
+                }
+            }
+        }
+
+        public override void OnEndDrag(PointerEventData eventData)
+        {
+            base.OnEndDrag(eventData);
+            if (ActionEndDrag != null)
+            {
+                ActionEndDrag();
+            }
+
+            if (m_listParentScrollRect != null)
+            {
+                for (int i = 0; i < m_listParentScrollRect.Count; i++)
+                {
+                    var parentScrollRect = m_listParentScrollRect[i];
+                    parentScrollRect.OnEndDrag(eventData);
+                }
+            }
+        }
+    }
+}

UnityProject/Assets/GameScripts/HotFix/GameLogic/Common/UI/UGUIExtension/TScrollRect.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: d322e77e03014f65a9ec277d50bd12f8
+timeCreated: 1695289370

UnityProject/Assets/GameScripts/HotFix/GameLogic/Common/UI/UGUIExtension/UIButtonSound.cs

@@ -0,0 +1,26 @@
+using System;
+using UnityEngine;
+using UnityEngine.EventSystems;
+
+namespace GameLogic
+{
+    public class UIButtonSound : MonoBehaviour, IPointerClickHandler
+    {
+        private static Action<int> _playSoundAction = null;
+
+        public int clickSound = 2;
+
+        public void OnPointerClick(PointerEventData eventData)
+        {
+            if (_playSoundAction != null)
+            {
+                _playSoundAction(clickSound);
+            }
+        }
+
+        public static void AddPlaySoundAction(Action<int> onClick)
+        {
+            _playSoundAction += onClick;
+        }
+    }
+}

UnityProject/Assets/GameScripts/HotFix/GameLogic/Common/UI/UGUIExtension/UIButtonSound.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: bb272eb1eec94625884e6e83889daa9a
+timeCreated: 1695289370

UnityProject/Assets/GameScripts/HotFix/GameLogic/Common/UI/UIEventItem.cs

@@ -0,0 +1,226 @@
+using System;
+using TEngine;
+using UnityEngine.EventSystems;
+using UnityEngine.UI;
+
+namespace GameLogic
+{
+    public class UIEventItem<T> : UIWidget where T : UIEventItem<T>
+    {
+        private object m_eventParam1;
+        private object m_eventParam2;
+        private object m_eventParam3;
+        public object EventParam1 => m_eventParam1;
+
+        public object EventParam2 => m_eventParam2;
+
+        public object EventParam3 => m_eventParam3;
+        private Action<T> m_clickAction;
+        private Action<T, bool> m_pressAction;
+        private Action<T, PointerEventData> m_beginDragAction;
+        private Action<T, PointerEventData> m_dragAction;
+        private Action<T, PointerEventData> m_endDragAction;
+
+        public void BindClickEvent(Action<T> clickAction, object eParam1 = null, object eParam2 = null, object eParam3 = null,
+            Selectable.Transition transition = Selectable.Transition.ColorTint)
+        {
+            if (m_clickAction != null)
+            {
+                m_clickAction = clickAction;
+            }
+            else
+            {
+                m_clickAction = clickAction;
+                var button = gameObject.GetOrAddComponent<Button>();
+                button.transition = transition;
+                button.onClick.AddListener(() =>
+                {
+                    if (m_clickAction != null)
+                    {
+                        m_clickAction(this as T);
+                    }
+                });
+            }
+
+            SetEventParam(eParam1, eParam2, eParam3);
+        }
+
+        public void BindClickEventEx(Action<T> clickAction, object eParam1 = null, object eParam2 = null, object eParam3 = null)
+        {
+            if (m_clickAction != null)
+            {
+                m_clickAction = clickAction;
+            }
+            else
+            {
+                m_clickAction = clickAction;
+                var button = gameObject.GetOrAddComponent<Button>();
+                button.onClick.AddListener(() =>
+                {
+                    if (m_clickAction != null)
+                    {
+                        m_clickAction(this as T);
+                    }
+                });
+            }
+
+            SetEventParam(eParam1, eParam2, eParam3);
+        }
+
+        public void BindBeginDragEvent(Action<T, PointerEventData> dragAction, object eParam1 = null, object eParam2 = null, object eParam3 = null)
+        {
+            if (m_beginDragAction != null)
+            {
+                m_beginDragAction = dragAction;
+            }
+            else
+            {
+                m_beginDragAction = dragAction;
+                var trigger = gameObject.GetOrAddComponent<EventTrigger>();
+                EventTrigger.Entry entry = new EventTrigger.Entry();
+                entry.eventID = EventTriggerType.BeginDrag;
+                entry.callback = new EventTrigger.TriggerEvent();
+                entry.callback.AddListener((data) =>
+                {
+                    var pointerEventData = (PointerEventData)data;
+                    if (m_beginDragAction != null)
+                    {
+                        m_beginDragAction(this as T, pointerEventData);
+                    }
+                });
+                trigger.triggers.Add(entry);
+            }
+
+            SetEventParam(eParam1, eParam2, eParam3);
+        }
+
+        public void BindDragEvent(Action<T, PointerEventData> dragAction, object eParam1 = null, object eParam2 = null, object eParam3 = null)
+        {
+            if (m_dragAction != null)
+            {
+                m_dragAction = dragAction;
+            }
+            else
+            {
+                m_dragAction = dragAction;
+                var trigger = gameObject.GetOrAddComponent<EventTrigger>();
+                EventTrigger.Entry entry = new EventTrigger.Entry();
+                entry.eventID = EventTriggerType.Drag;
+                entry.callback = new EventTrigger.TriggerEvent();
+                entry.callback.AddListener((data) =>
+                {
+                    var pointerEventData = (PointerEventData)data;
+                    if (m_dragAction != null)
+                    {
+                        m_dragAction(this as T, pointerEventData);
+                    }
+                });
+                trigger.triggers.Add(entry);
+            }
+
+            SetEventParam(eParam1, eParam2, eParam3);
+        }
+
+        public void BindEndDragEvent(Action<T, PointerEventData> dragendAction, object eParam1 = null, object eParam2 = null, object eParam3 = null)
+        {
+            if (m_endDragAction != null)
+            {
+                m_endDragAction = dragendAction;
+            }
+            else
+            {
+                m_endDragAction = dragendAction;
+                var trigger = gameObject.GetOrAddComponent<EventTrigger>();
+                EventTrigger.Entry entry = new EventTrigger.Entry();
+                entry.eventID = EventTriggerType.EndDrag;
+                entry.callback = new EventTrigger.TriggerEvent();
+                entry.callback.AddListener((data) =>
+                {
+                    if (m_endDragAction != null)
+                    {
+                        m_endDragAction(this as T, (PointerEventData)data);
+                    }
+                });
+                trigger.triggers.Add(entry);
+            }
+
+            SetEventParam(eParam1, eParam2, eParam3);
+        }
+
+        public void BindPressEvent(Action<T, bool> pressAction, object eParam1 = null, object eParam2 = null, object eParam3 = null)
+        {
+            if (m_pressAction != null)
+            {
+                m_pressAction = pressAction;
+            }
+            else
+            {
+                m_pressAction = pressAction;
+                var trigger = gameObject.GetOrAddComponent<EventTrigger>();
+                EventTrigger.Entry entry = new EventTrigger.Entry();
+                entry.eventID = EventTriggerType.PointerDown;
+                entry.callback = new EventTrigger.TriggerEvent();
+                entry.callback.AddListener((data) =>
+                {
+                    if (m_pressAction != null)
+                    {
+                        m_pressAction(this as T, true);
+                    }
+                });
+                trigger.triggers.Add(entry);
+                entry = new EventTrigger.Entry();
+                entry.eventID = EventTriggerType.PointerUp;
+                entry.callback = new EventTrigger.TriggerEvent();
+                entry.callback.AddListener((data) =>
+                {
+                    if (m_pressAction != null)
+                    {
+                        m_pressAction(this as T, false);
+                    }
+                });
+                trigger.triggers.Add(entry);
+            }
+
+            SetEventParam(eParam1, eParam2, eParam3);
+        }
+
+        public void BindPressEventEx(Action<T, bool> pressAction, object eParam1 = null, object eParam2 = null, object eParam3 = null,
+            float durationThreshold = 1)
+        {
+            if (m_pressAction != null)
+            {
+                m_pressAction = pressAction;
+            }
+            else
+            {
+                m_pressAction = pressAction;
+                var button = gameObject.GetOrAddComponent<UIButtonSuper>();
+                button.m_LongPressDurationTime = durationThreshold;
+                button.onPress.AddListener(() =>
+                {
+                    if (m_pressAction != null)
+                    {
+                        m_pressAction(this as T, true);
+                    }
+                });
+            }
+
+            SetEventParam(eParam1, eParam2, eParam3);
+        }
+
+        public void SetEventParam(object eParam1, object eParam2 = null, object eParam3 = null)
+        {
+            m_eventParam1 = eParam1;
+            m_eventParam2 = eParam2;
+            m_eventParam3 = eParam3;
+        }
+
+        public void OnTriggerBtnEvent()
+        {
+            if (m_clickAction != null)
+            {
+                m_clickAction(this as T);
+            }
+        }
+    }
+}

UnityProject/Assets/GameScripts/HotFix/GameLogic/Common/UI/UIEventItem.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: c9972ff1d1514807bbd21d6bc4c035f4
+timeCreated: 1695289504

UnityProject/Assets/GameScripts/HotFix/GameLogic/Common/UI/Widget.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 2d3f2e9ab868464da947f3d52aa9c3f6
+timeCreated: 1695289443

UnityProject/Assets/GameScripts/HotFix/GameLogic/Common/UI/Widget/UIListBase.cs

@@ -0,0 +1,337 @@
+using System;
+using System.Collections.Generic;
+using TEngine;
+using UnityEngine;
+using UnityEngine.UI;
+
+namespace GameLogic
+{
+    /// <summary>
+    /// UI列表Item
+    /// </summary>
+    /// <typeparam name="DataT"></typeparam>
+    public interface IListDataItem<in DataT>
+    {
+        void SetItemData(DataT d);
+    }
+
+    /// <summary>
+    /// UI列表Item
+    /// </summary>
+    public interface IListSelectItem
+    {
+        /// <summary>
+        /// 获取索引。
+        /// </summary>
+        /// <returns></returns>
+        int GetItemIndex();
+
+        /// <summary>
+        /// 设置索引。
+        /// </summary>
+        /// <param name="i"></param>
+        void SetItemIndex(int i);
+
+        /// <summary>
+        /// 是否被选中。
+        /// </summary>
+        /// <returns></returns>
+        bool IsSelected();
+
+        /// <summary>
+        /// 设置是否选中。
+        /// </summary>
+        /// <param name="v"></param>
+        void SetSelected(bool v);
+    }
+
+    public class SelectItemBase : UIEventItem<SelectItemBase>, IListSelectItem
+    {
+        /// <summary>
+        /// 索引。
+        /// </summary>
+        protected int m_itemIndex;
+
+        public int GetItemIndex()
+        {
+            return m_itemIndex;
+        }
+
+        public void SetItemIndex(int i)
+        {
+            m_itemIndex = i;
+        }
+
+        /// <summary>
+        /// 是否被选中。
+        /// </summary>
+        protected bool m_isSelected;
+
+        public virtual bool IsSelected()
+        {
+            return m_isSelected;
+        }
+
+        public virtual void SetSelected(bool v)
+        {
+            if (m_isSelected == v) return;
+            m_isSelected = v;
+            UpdateSelect();
+        }
+
+        /// <summary>
+        /// 刷新选中状态。
+        /// </summary>
+        public virtual void UpdateSelect()
+        {
+        }
+
+        public override void RegisterEvent()
+        {
+            base.RegisterEvent();
+            AddSelectEvt();
+        }
+
+        /// <summary>
+        /// 监听选中事件。
+        /// </summary>
+        protected virtual void AddSelectEvt()
+        {
+            if (Parent == null || !(Parent is IUISelectList)) return;
+            var btn = gameObject.GetOrAddComponent<Button>();
+            if (btn != null)
+            {
+                btn.onClick.AddListener(OnSelectClick);
+            }
+        }
+
+        /// <summary>
+        /// 选中点击
+        /// </summary>
+        protected virtual void OnSelectClick()
+        {
+            var p = Parent as IUISelectList;
+            if (p != null)
+            {
+                p.OnItemClick(this, GetItemIndex());
+            }
+        }
+    }
+
+    interface IUISelectList
+    {
+        void OnItemClick(object item, int i);
+    }
+
+    /// <summary>
+    /// UI列表
+    /// </summary>
+    public class UIListBase<ItemT, DataT> : UIWidget, IUISelectList where ItemT : UIWidget, new()
+    {
+        /// <summary>
+        /// item模板
+        /// </summary>
+        public GameObject itemBase;
+
+        /// <summary>
+        /// 数据列表
+        /// </summary>
+        protected List<DataT> m_datas;
+
+        /// <summary>
+        /// 数据列表
+        /// </summary>
+        public List<DataT> datas => m_datas;
+
+        /// <summary>
+        /// 数据数量
+        /// </summary>
+        public int DataNum => m_datas?.Count ?? 0;
+
+        /// <summary>
+        /// 数量
+        /// </summary>
+        protected int m_num;
+
+        /// <summary>
+        /// 数量
+        /// </summary>
+        public int num => m_num;
+
+        /// <summary>
+        /// 设置数据数量
+        /// </summary>
+        /// <param name="n"></param>
+        /// <param name="funcItem"></param>
+        public void SetDataNum(int n, Action<ItemT, int> funcItem = null)
+        {
+            AdjustItemNum(n, null, funcItem);
+        }
+
+        /// <summary>
+        /// 数据起始索引
+        /// </summary>
+        public int dataStartOffset = 0;
+
+        /// <summary>
+        /// 设置数据
+        /// </summary>
+        /// <param name="dataList"></param>
+        /// <param name="n"></param>
+        public void SetDatas(List<DataT> dataList, int n = -1)
+        {
+            AdjustItemNum(Mathf.Max(0, n >= 0 ? n : (dataList == null ? 0 : (dataList.Count - dataStartOffset))),
+                dataList);
+        }
+
+        /// <summary>
+        /// 设置显示数据
+        /// </summary>
+        /// <param name="n"></param>
+        /// <param name="datas"></param>
+        /// <param name="funcItem"></param>
+        protected virtual void AdjustItemNum(int n, List<DataT> datas = null, Action<ItemT, int> funcItem = null)
+        {
+            m_num = n;
+            m_datas = datas;
+            if (itemBase != null)
+            {
+                itemBase.SetActive(false);
+            }
+        }
+
+        /// <summary>
+        /// 刷新列表ITEM
+        /// </summary>
+        /// <param name="item"></param>
+        /// <param name="i"></param>
+        /// <param name="func"></param>
+        protected virtual void UpdateListItem(ItemT item, int i, Action<ItemT, int> func)
+        {
+            if (item == null) return;
+            if (func != null)
+            {
+                func.Invoke(item, i);
+                return;
+            }
+
+            var listDataItem = item as IListDataItem<DataT>;
+            if (listDataItem != null)
+            {
+                listDataItem.SetItemData(GetData(i));
+            }
+        }
+
+        /// <summary>
+        /// 选中索引
+        /// </summary>
+        protected int m_selectIndex = -1;
+
+        /// <summary>
+        /// Item点击
+        /// </summary>
+        public Action<int> funcOnItemClick;
+
+        /// <summary>
+        /// 选中变化回调函数
+        /// </summary>
+        public Action funcOnSelectChange;
+
+        /// <summary>
+        /// 点击无选中变化回调
+        /// </summary>
+        public Action funcNoSelectChange;
+
+        /// <summary>
+        /// 选中索引
+        /// </summary>
+        public int selectIndex
+        {
+            get => m_selectIndex;
+            set => SetSelectIndex(value);
+        }
+
+        /// <summary>
+        /// 设置选中索引
+        /// </summary>
+        /// <param name="i"></param>
+        /// <param name="forceUpdate"></param>
+        /// <param name="triggerEvt"></param>
+        public void SetSelectIndex(int i, bool forceUpdate = false, bool triggerEvt = true)
+        {
+            if (!forceUpdate && m_selectIndex == i)
+            {
+                if (funcNoSelectChange != null)
+                {
+                    funcNoSelectChange.Invoke();
+                }
+
+                return;
+            }
+
+            var preIndex = selectIndex;
+            m_selectIndex = i;
+            var item = GetItem(preIndex) as IListSelectItem;
+            if (item != null)
+            {
+                item.SetSelected(false);
+            }
+
+            item = GetItem(selectIndex) as IListSelectItem;
+            if (item != null)
+            {
+                item.SetSelected(true);
+            }
+
+            if (triggerEvt && funcOnSelectChange != null)
+            {
+                funcOnSelectChange.Invoke();
+            }
+        }
+
+        /// <summary>
+        /// 获取当前选中的数据
+        /// </summary>
+        /// <returns></returns>
+        public DataT GetSelectData()
+        {
+            return GetData(selectIndex);
+        }
+
+        /// <summary>
+        /// 获取数据
+        /// </summary>
+        /// <param name="i"></param>
+        /// <returns></returns>
+        public DataT GetData(int i)
+        {
+            i += dataStartOffset;
+            return m_datas == null || i < 0 || i >= m_datas.Count ? default(DataT) : m_datas[i];
+        }
+
+        /// <summary>
+        /// 获取item
+        /// </summary>
+        /// <param name="i"></param>
+        /// <returns></returns>
+        public virtual ItemT GetItem(int i)
+        {
+            return null;
+        }
+
+        /// <summary>
+        /// item被点击
+        /// </summary>
+        /// <param name="item"></param>
+        /// <param name="i"></param>
+        public void OnItemClick(object item, int i)
+        {
+            if (funcOnItemClick != null)
+            {
+                funcOnItemClick.Invoke(i);
+            }
+
+            selectIndex = i;
+        }
+    }
+}

UnityProject/Assets/GameScripts/HotFix/GameLogic/Common/UI/Widget/UIListBase.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 9d3742a744bb4934a4848b54bb6910a2
+timeCreated: 1691679426

UnityProject/Assets/GameScripts/HotFix/GameLogic/Common/UI/Widget/UILoopGridItemWidget.cs

@@ -0,0 +1,14 @@
+namespace GameLogic
+{
+    public class UILoopGridItemWidget: SelectItemBase
+    {
+        public LoopGridViewItem LoopItem { set; get; }
+
+        public int Index { private set; get; }
+
+        public virtual void UpdateItem(int index)
+        {
+            Index = index;
+        }
+    }
+}

UnityProject/Assets/GameScripts/HotFix/GameLogic/Common/UI/Widget/UILoopGridItemWidget.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 47ee457a0d7549b3a3b5d23f4ac048cd
+timeCreated: 1692346002

UnityProject/Assets/GameScripts/HotFix/GameLogic/Common/UI/Widget/UILoopGridWidget.cs

@@ -0,0 +1,171 @@
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace GameLogic
+{
+    /// <summary>
+    /// UI列表。
+    /// </summary>
+    public class UILoopGridWidget<TItem, TData> : UIListBase<TItem, TData> where TItem : UILoopGridItemWidget, new()
+    {
+        /// <summary>
+        /// LoopRectView
+        /// </summary>
+        public LoopGridView LoopRectView { private set; get; }
+
+        /// <summary>
+        /// Item字典
+        /// </summary>
+        private Dictionary<int, TItem> m_itemCache = new Dictionary<int, TItem>();
+
+        /// <summary>
+        /// 计算偏差后的ItemList
+        /// </summary>
+        private List<TItem> m_items = new List<TItem>();
+
+        /// <summary>
+        /// 计算偏差后的ItemList
+        /// </summary>
+        public List<TItem> items => m_items;
+
+        public override void BindMemberProperty()
+        {
+            base.BindMemberProperty();
+            LoopRectView = rectTransform.GetComponent<LoopGridView>();
+        }
+
+        public override void OnCreate()
+        {
+            base.OnCreate();
+            LoopRectView.InitGridView(0, OnGetItemByIndex);
+        }
+
+        public override void OnDestroy()
+        {
+            base.OnDestroy();
+            m_itemCache.Clear();
+        }
+
+        /// <summary>
+        /// Item回调函数
+        /// </summary>
+        protected Action<TItem, int> m_tpFuncItem;
+
+        /// <summary>
+        /// 设置显示数据
+        /// </summary>
+        /// <param name="n"></param>
+        /// <param name="datas"></param>
+        /// <param name="funcItem"></param>
+        protected override void AdjustItemNum(int n, List<TData> datas = null, Action<TItem, int> funcItem = null)
+        {
+            base.AdjustItemNum(n, datas, funcItem);
+            m_tpFuncItem = funcItem;
+            LoopRectView.SetListItemCount(n);
+            LoopRectView.RefreshAllShownItem();
+            m_tpFuncItem = null;
+        }
+
+        /// <summary>
+        /// 获取Item
+        /// </summary>
+        /// <param name="listView"></param>
+        /// <param name="itemIndex"></param>
+        /// <param name="row"></param>
+        /// <param name="column"></param>
+        /// <returns></returns>
+        protected LoopGridViewItem OnGetItemByIndex(LoopGridView listView, int itemIndex,int row,int column)
+        {
+            if (itemIndex < 0 || itemIndex >= num) return null;
+            var item = itemBase == null ? CreateItem() : CreateItem(itemBase);
+            if (item == null) return null;
+            item.SetItemIndex(itemIndex);
+            UpdateListItem(item, itemIndex, m_tpFuncItem);
+            return item.LoopItem;
+        }
+
+        /// <summary>
+        /// 创建Item
+        /// </summary>
+        /// <returns></returns>
+        public TItem CreateItem()
+        {
+            return CreateItem(typeof(TItem).Name);
+        }
+
+        /// <summary>
+        /// 创建Item
+        /// </summary>
+        /// <param name="itemName"></param>
+        /// <returns></returns>
+        public TItem CreateItem(string itemName)
+        {
+            TItem widget = null;
+            LoopGridViewItem item = LoopRectView.AllocOrNewListViewItem(itemName);
+            if (item != null)
+            {
+                widget = CreateItem(item);
+            }
+            return widget;
+        }
+
+        /// <summary>
+        /// 创建Item
+        /// </summary>
+        /// <param name="prefab"></param>
+        /// <returns></returns>
+        public TItem CreateItem(GameObject prefab)
+        {
+            TItem widget = null;
+            LoopGridViewItem item = LoopRectView.AllocOrNewListViewItem(prefab);
+            if (item != null)
+            {
+                widget = CreateItem(item);
+            }
+            return widget;
+        }
+
+        /// <summary>
+        /// 创建Item
+        /// </summary>
+        /// <param name="item"></param>
+        /// <returns></returns>
+        private TItem CreateItem(LoopGridViewItem item)
+        {
+            TItem widget;
+            if (!m_itemCache.TryGetValue(item.GoId, out widget))
+            {
+                widget = CreateWidget<TItem>(item.gameObject);
+                widget.LoopItem = item;
+                m_itemCache.Add(item.GoId, widget);
+            }
+
+            return widget;
+        }
+
+       /// <summary>
+       /// 获取item
+       /// </summary>
+       /// <param name="i"></param>
+       /// <returns></returns>
+        public override TItem GetItem(int i)
+        {
+            return i >= 0 && i < m_items.Count ? m_items[i] : null;
+        }
+
+       /// <summary>
+        /// 获取itemList
+        /// </summary>
+        /// <returns></returns>
+        public List<TItem> GetItemList()
+        {
+            m_items.Clear();
+            for (int i = 0; i < m_itemCache.Count; i++)
+            {
+                m_items.Add(m_itemCache[i]);
+            }
+            return m_items;
+        }
+    }
+}

UnityProject/Assets/GameScripts/HotFix/GameLogic/Common/UI/Widget/UILoopGridWidget.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 0930448d067145dfb0428b248f1086ae
+timeCreated: 1692346037

UnityProject/Assets/GameScripts/HotFix/GameLogic/Common/UI/Widget/UILoopItemWidget.cs

@@ -0,0 +1,14 @@
+namespace GameLogic
+{
+    public class UILoopItemWidget : SelectItemBase
+    {
+        public LoopListViewItem LoopItem { set; get; }
+
+        public int Index { private set; get; }
+
+        public virtual void UpdateItem(int index)
+        {
+            Index = index;
+        }
+    }
+}

UnityProject/Assets/GameScripts/HotFix/GameLogic/Common/UI/Widget/UILoopItemWidget.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: b39b2f052eec4a4a97256e5aeee9e7dc
+timeCreated: 1691679577

UnityProject/Assets/GameScripts/HotFix/GameLogic/Common/UI/Widget/UILoopListViewWidget.cs

@@ -0,0 +1,95 @@
+using System.Collections.Generic;
+using TEngine;
+using UnityEngine;
+
+namespace GameLogic
+{
+    public class UILoopListViewWidget<T> : UIWidget where T : UILoopItemWidget, new()
+    {
+        public LoopListView LoopRectView { private set; get; }
+
+        private Dictionary<int, T> m_itemCache = new Dictionary<int, T>();
+
+        public override void BindMemberProperty()
+        {
+            base.BindMemberProperty();
+            LoopRectView = this.rectTransform.GetComponent<LoopListView>();
+        }
+
+        public override void OnDestroy()
+        {
+            base.OnDestroy();
+            m_itemCache.Clear();
+        }
+
+        public T CreateItem()
+        {
+            string typeName = typeof(T).Name;
+            return CreateItem(typeName);
+            ;
+        }
+
+        public T CreateItem(string itemName)
+        {
+            T widget = null;
+            var item = LoopRectView.AllocOrNewListViewItem(itemName);
+            if (item != null)
+            {
+                widget = CreateItem(item);
+            }
+
+            return widget;
+        }
+
+        public T CreateItem(GameObject prefab)
+        {
+            T widget = null;
+            var item = LoopRectView.AllocOrNewListViewItem(prefab);
+            if (item != null)
+            {
+                widget = CreateItem(item);
+            }
+
+            return widget;
+        }
+
+        private T CreateItem(LoopListViewItem item)
+        {
+            T widget;
+            if (!m_itemCache.TryGetValue(item.GoId, out widget))
+            {
+                widget = CreateWidget<T>(item.gameObject);
+                widget.LoopItem = item;
+                m_itemCache.Add(item.GoId, widget);
+            }
+
+            return widget;
+        }
+
+        public List<T> GetItemList()
+        {
+            List<T> list = new List<T>();
+            for (int i = 0; i < m_itemCache.Count; i++)
+            {
+                list.Add(m_itemCache[i]);
+            }
+
+            return list;
+        }
+
+        public int GetItemCount()
+        {
+            return m_itemCache.Count;
+        }
+
+        /// <summary>
+        /// 获取Item。
+        /// </summary>
+        /// <param name="index"></param>
+        /// <returns></returns>
+        public T GetItemByIndex(int index)
+        {
+            return m_itemCache[index];
+        }
+    }
+}

UnityProject/Assets/GameScripts/HotFix/GameLogic/Common/UI/Widget/UILoopListViewWidget.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 9b87126ba47740708bc82eb0bb9e414e
+timeCreated: 1691679617

UnityProject/Assets/GameScripts/HotFix/GameLogic/Common/UI/Widget/UILoopListWidget.cs

@@ -0,0 +1,178 @@
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace GameLogic
+{
+    /// <summary>
+    /// UI列表。
+    /// </summary>
+    public class UILoopListWidget<TItem, TData> : UIListBase<TItem, TData> where TItem : UILoopItemWidget, new()
+    {
+        /// <summary>
+        /// LoopRectView
+        /// </summary>
+        public LoopListView LoopRectView { private set; get; }
+
+        /// <summary>
+        /// Item字典
+        /// </summary>
+        private Dictionary<int, TItem> m_itemCache = new Dictionary<int, TItem>();
+
+        /// <summary>
+        /// 计算偏差后的ItemList
+        /// </summary>
+        private List<TItem> m_items = new List<TItem>();
+
+        /// <summary>
+        /// 计算偏差后的ItemList
+        /// </summary>
+        public List<TItem> items => m_items;
+
+        public override void BindMemberProperty()
+        {
+            base.BindMemberProperty();
+            LoopRectView = rectTransform.GetComponent<LoopListView>();
+        }
+
+        public override void OnCreate()
+        {
+            base.OnCreate();
+            LoopRectView.InitListView(0, OnGetItemByIndex);
+        }
+
+        public override void OnDestroy()
+        {
+            base.OnDestroy();
+            m_itemCache.Clear();
+        }
+
+        /// <summary>
+        /// Item回调函数
+        /// </summary>
+        protected Action<TItem, int> m_tpFuncItem;
+
+        /// <summary>
+        /// 设置显示数据
+        /// </summary>
+        /// <param name="n"></param>
+        /// <param name="datas"></param>
+        /// <param name="funcItem"></param>
+        protected override void AdjustItemNum(int n, List<TData> datas = null, Action<TItem, int> funcItem = null)
+        {
+            base.AdjustItemNum(n, datas, funcItem);
+            m_tpFuncItem = funcItem;
+            LoopRectView.SetListItemCount(n);
+            LoopRectView.RefreshAllShownItem();
+            m_tpFuncItem = null;
+        }
+
+        /// <summary>
+        /// 获取Item
+        /// </summary>
+        /// <param name="listView"></param>
+        /// <param name="index"></param>
+        /// <returns></returns>
+        protected LoopListViewItem OnGetItemByIndex(LoopListView listView, int index)
+        {
+            if (index < 0 || index >= num) return null;
+            var item = itemBase == null ? CreateItem() : CreateItem(itemBase);
+            if (item == null) return null;
+            item.SetItemIndex(index);
+            UpdateListItem(item, index, m_tpFuncItem);
+            return item.LoopItem;
+        }
+
+        /// <summary>
+        /// 创建Item
+        /// </summary>
+        /// <returns></returns>
+        public TItem CreateItem()
+        {
+            return CreateItem(typeof(TItem).Name);
+        }
+
+        /// <summary>
+        /// 创建Item
+        /// </summary>
+        /// <param name="itemName"></param>
+        /// <returns></returns>
+        public TItem CreateItem(string itemName)
+        {
+            TItem widget = null;
+            LoopListViewItem item = LoopRectView.AllocOrNewListViewItem(itemName);
+            if (item != null)
+            {
+                widget = CreateItem(item);
+            }
+            return widget;
+        }
+
+        /// <summary>
+        /// 创建Item
+        /// </summary>
+        /// <param name="prefab"></param>
+        /// <returns></returns>
+        public TItem CreateItem(GameObject prefab)
+        {
+            TItem widget = null;
+            LoopListViewItem item = LoopRectView.AllocOrNewListViewItem(prefab);
+            if (item != null)
+            {
+                widget = CreateItem(item);
+            }
+            return widget;
+        }
+
+        /// <summary>
+        /// 创建Item
+        /// </summary>
+        /// <param name="item"></param>
+        /// <returns></returns>
+        private TItem CreateItem(LoopListViewItem item)
+        {
+            TItem widget;
+            if (!m_itemCache.TryGetValue(item.GoId, out widget))
+            {
+                widget = CreateWidget<TItem>(item.gameObject);
+                widget.LoopItem = item;
+                m_itemCache.Add(item.GoId, widget);
+            }
+
+            return widget;
+        }
+
+       /// <summary>
+       /// 获取item
+       /// </summary>
+       /// <param name="i"></param>
+       /// <returns></returns>
+        public override TItem GetItem(int i)
+        {
+            return i >= 0 && i < m_items.Count ? m_items[i] : null;
+        }
+
+       /// <summary>
+        /// 获取itemList
+        /// </summary>
+        /// <returns></returns>
+        public List<TItem> GetItemList()
+        {
+            m_items.Clear();
+            for (int i = 0; i < m_itemCache.Count; i++)
+            {
+                m_items.Add(m_itemCache[i]);
+            }
+            return m_items;
+        }
+       
+        /// <summary>
+        /// 获取当前起始索引
+        /// </summary>
+        /// <returns></returns>
+        public int GetItemStartIndex()
+        {
+            return LoopRectView.GetItemStartIndex();
+        }
+    }
+}

UnityProject/Assets/GameScripts/HotFix/GameLogic/Common/UI/Widget/UILoopListWidget.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 72b7444fb04642039aacc2db27dd002a
+timeCreated: 1691679907