init

Assets/Scripts/System/RandomPool/CommonRandomGroup.cs

@@ -0,0 +1,227 @@
+using System;
+using System.Collections.Generic;
+using System.RandomPool;
+
+namespace Game.Data
+{
+    /// <summary>
+    /// 通用随机池单元组，用于最终产生随机节点
+    /// </summary>
+    public class CommonRandomGroup<T> where T : class
+    {
+        private          int                 _poolId;
+        private          int                 _weightMax;
+        private readonly List<RandomNode<T>> _item;
+        private          int                 _curWeightSum;     //当前的总权重
+        private          int                 _curConditionMask; //当前条件阈值 ，必须大于此值
+        public           int                 ValidRofCount { get; private set; }
+
+        public CommonRandomGroup(int poolId)
+        {
+            this._poolId           = poolId;
+            this._item             = new List<RandomNode<T>>();
+            this._weightMax        = 0;
+            this._curWeightSum     = 0;
+            this._curConditionMask = -1;
+            this.ValidRofCount     = -2;
+        }
+
+        public bool SetMask(int exploreCount, IList<int> disableKeys = null , object customMask = null)
+        {
+            this.ValidRofCount = 0;
+            this._curWeightSum = 0;
+            var isSet = false;
+            
+            for (int i = 0; i < this._item.Count; i++)
+            {
+                var node = this._item[i];
+                
+                if (disableKeys != null && disableKeys.Contains(node.key))
+                {
+                    node.curWeight = -1;
+                    continue;
+                }
+
+                var isBound = this.IsBound(node, exploreCount);
+                if (!isBound)
+                {
+                    node.curWeight = -1;
+                    continue;
+                }
+
+                if (!this.OnCustomMask(node , customMask))
+                {
+                    node.curWeight = -1;
+                    continue;
+                }
+
+                isSet              =  true;
+                this._curWeightSum += node.weight;
+                node.curWeight     =  this._curWeightSum;
+                this.ValidRofCount += 1;
+            }
+            
+            this._curConditionMask = exploreCount;
+            return isSet;
+        }
+
+        protected virtual bool OnCustomMask(RandomNode<T> node, object customMask)
+        {
+            return true;
+        }
+
+        private bool IsBound(RandomNode<T> node, int maskCount)
+        {
+            if (!node.IsValid(RandomLogController.GetPoolLog(this._poolId, node.key)))
+            {
+                return false;
+            }
+
+            if (maskCount == -1)
+                return true;
+            if (node.weight <= 0)
+                return false;
+            if (node.maxRange == -1 && node.minRange == -1)
+                return true;
+
+            if (node.minRange == -1)
+            {
+                return maskCount <= node.maxRange;
+            }
+
+            if (node.maxRange == -1)
+            {
+                return maskCount >= node.minRange;
+            }
+
+            return maskCount >= node.minRange && maskCount <= node.maxRange;
+        }
+
+        public void PutItem(RandomNode<T> node)
+        {
+            //此处后续可增加数量限制判断
+            this._weightMax += node.weight;
+            this._item.Add(node);
+        }
+
+        public void PullItem(int node)
+        {
+            for (int i = 0; i < _item.Count; i++)
+            {
+                var randomNode = _item[i];
+                if (randomNode.key == node)
+                {
+                    RandomLogController.PoolPullLog (this._poolId , node);
+                    return;
+                }
+            }
+        }
+        
+        public void RemoveItem(int node)
+        {
+            for (int i = 0; i < _item.Count; i++)
+            {
+                var randomNode = _item[i];
+                if (randomNode.key == node)
+                {
+                    _item.RemoveAt(i);
+                    _weightMax -= randomNode.weight;
+                    return;
+                }
+            }
+        }
+
+        internal RandomNode<T> GetItem(int id)
+        {
+            for (int i = 0; i < this._item.Count; i++)
+            {
+                var node = this._item[i];
+                if (id == node.key)
+                {
+                    return node;
+                }
+            }
+
+            return null;
+        }
+
+        public float GetItemRate(int id)
+        {
+            var f    = 0f;
+            var item = this.GetItem(id);
+            if (item != null)
+            {
+                if (item.curWeight != -1)
+                {
+                    f = item.weight / (this._weightMax * 1.0f);
+                }
+            }
+
+            return f;
+        }
+
+        public T RandomItem(int poolId, int seedId)
+        {
+            if (this._item.Count == 0 || ValidRofCount == 0)
+            {
+                return null;
+            }
+
+            RandomNode<T> item = null;
+            var           p    = RandomUtils.RandomFloat () * this._curWeightSum;
+            for (int i = 0; i < this._item.Count; i++)
+            {
+                var randomNode = this._item[i];
+                if (p <= randomNode.curWeight)
+                {
+                    item = randomNode;
+                    RandomLogController.PoolPushLog(poolId, item.key);
+                    break;
+                }
+            }
+
+            return item?.value;
+        }
+        
+        public RandomNode<T> RandomNode(int poolId, int seedId)
+        {
+            if (this._item.Count == 0 || ValidRofCount == 0)
+            {
+                return null;
+            }
+            RandomNode<T> item = null;
+            var           p    = RandomUtils.RandomFloat () * this._curWeightSum;
+            for (int i = 0; i < this._item.Count; i++)
+            {
+                var randomNode = this._item[i];
+                if (p <= randomNode.curWeight)
+                {
+                    item = randomNode;
+                    RandomLogController.PoolPushLog(poolId, item.key);
+                    break;
+                }
+            }
+            return item;
+        }
+        
+        public static bool IsPush(int poolId, int id, int maskCount)
+        {
+            return RandomLogController.IsPush(poolId, id, maskCount);
+        }
+        
+        public void ResetItemWeight(int id, int weight)
+        {
+            for (int i = 0; i < this._item.Count; i++)
+            {
+                var randomNode = this._item[i];
+                if (randomNode.key == id)
+                {
+                    this._weightMax -= randomNode.weight;
+                    randomNode.weight = weight;
+                    this._weightMax += randomNode.weight;
+                    return;
+                }
+            }
+        }
+    }
+}