开启辅助访问
 找回密码
 注册帐号

扫一扫,访问微社区

教程分享

关注:715

当前位置:游戏蛮牛 技术专区 教程分享

查看: 191|回复: 5

[自学总结] unity 实现自定义条件,并可以获得在某种特定情况下条件是否符合要求

[复制链接]  [移动端链接]
排名
24285
昨日变化
23

3

主题

26

帖子

71

积分

Rank: 2Rank: 2

UID
146770
好友
0
蛮牛币
118
威望
0
注册时间
2016-4-26
在线时间
30 小时
最后登录
2017-12-11
发表于 2017-12-4 17:48:26 | 显示全部楼层 |阅读模式

马上注册,结交更多好友,享用更多功能,让你轻松玩转社区。

您需要 登录 才可以下载或查看,没有帐号?注册帐号

x
现在在做一个推送的逻辑,策划案上面的推送条件非常复杂,以至于稍有修改就可能会出现一些bug。下面我写一个条件类,把策划案中的条件给列出来,这样的话我就不必关注怎么符合条件了
符合条件因为情况复杂,所以要用树结构,下面我定义一个树状结构,不多说上代码
[C#] 纯文本查看 复制代码
/*
脚本名称:Tree
脚本作者:#AuthorName#
建立时间:#CreateTime#
脚本功能:
版本号:
*/

using System.Collections.Generic;

namespace Push
{
    public class Tree<T> where T : new()
    {
        private List<Tree<T>> Nodes;

        /// <summary>
        /// 节点key值
        /// </summary>
        public string NodeKey { get; set; }

        /// <summary>
        /// tree对应的泛型类型对象
        /// </summary>
        public T Value { get; private set; }

        /// <summary>
        /// 当前节点的父类
        /// </summary>
        public Tree<T> Parent { private set; get; }

        /// <summary>
        /// 根节点
        /// </summary>
        public Tree<T> RootTree
        {
            get
            {
                Tree<T> parent = new Tree<T>();
                parent = this;
                while (true)
                {
                    if (parent.IsRoot)
                    {
                        return Parent;
                    }
                    else
                    {
                        parent = parent.Parent;
                    }
                }
            }
        }

        /// <summary>
        /// 是否是
        /// </summary>
        public bool IsRoot
        {
            get
            {
                if (Parent == null)
                {
                    return true;
                }
                else
                {
                    return false;
                }
            }
        }

        /// <summary>
        /// 当前节点的子节点的数目
        /// </summary>
        public int Count
        {
            get { return Nodes.Count; }
        }

        /// <summary>
        /// 当前节点总共的加点数目
        /// </summary>
        public int TotalCount
        {
            get
            {
                int temp = 0;
                for (int i = 0; i < Nodes.Count; i++)
                {
                    temp++;
                    temp += Nodes[i].TotalCount;
                }

                return temp;
            }
        }

        /// <summary>
        /// 索引器
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public Tree<T> this[string key]
        {
            get
            {
                int length = Nodes.Count;
                for (int i = 0; i < length; i++)
                {
                    if (Nodes[i].NodeKey.Equals(key))
                    {
                        return Nodes[i];
                    }
                }

                return null;
            }

            set
            {
                int length = Nodes.Count;
                for (int i = 0; i < length; i++)
                {
                    if (Nodes[i].NodeKey.Equals(key))
                    {
                        Nodes[i] = value;
                    }
                }
            }
        }

        public Tree(string key)
        {
            Nodes = new List<Tree<T>>();
            Value = new T();
            NodeKey = key;
        }

        public Tree()
        {
            Nodes = new List<Tree<T>>();
            Value = new T();
        }

        public void Add(Tree<T> data)
        {
            if (!ContainValue(data))
            {
                Nodes.Add(data);
                data.Parent = this;
            }
        }

        public void Add(List<Tree<T>> data)
        {
            int length = data.Count;
            for (int i = 0; i < length; i++)
            {
                Add(data[i]);
            }
        }

        public void Remove(string key)
        {
            if (ContainKey(key))
            {
                Nodes.Remove(GetValue(key));
            }
        }

        public void Remove(Tree<T> data)
        {
            if (ContainValue(data))
            {
                Nodes.Remove(data);
            }
        }

        public void Clear()
        {
            Nodes.Clear();
        }

        public bool ContainKey(string key)
        {
            int length = Nodes.Count;
            for (int i = 0; i < length; i++)
            {
                if (Nodes[i].NodeKey.Equals(key))
                {
                    return true;
                }
            }

            return false;
        }
        public bool ContainValue(Tree<T> value)
        {
            int length = Nodes.Count;
            for (int i = 0; i < length; i++)
            {
                if (Nodes[i].Equals(value))
                {
                    return true;
                }
            }

            return false;
        }

        private Tree<T> GetValue(string key)
        {
            int length = Nodes.Count;
            for (int i = 0; i < length; i++)
            {
                if (Nodes[i].NodeKey.Equals(key))
                {
                    return Nodes[i];
                }
            }

            return null;
        }
    }
}



这样我就可以定义一个树状结构,把所有条件通过树状条件来做,首先必须符合上一个条件,上一个条件不行,下一个条件就返回false,如果上一个条件可以,那就再看下一个条件,这样一直到树状的最顶端,上代码

[C#] 纯文本查看 复制代码
/*
脚本名称:Predicate
脚本作者:#AuthorName#
建立时间:#CreateTime#
脚本功能:
版本号:
*/

using System.Collections.Generic;

namespace Push
{
    public delegate bool dPredicate();

    public class Predicate
    {
        private Tree<List<dPredicate>> predicateTree;
        private string defaultKey;

        public Predicate()
        {
            defaultKey = "RootKey";
        }

        /// <summary>
        /// 添加条件
        /// </summary>
        /// <param name="key">键值</param>
        /// <param name="Predicate">条件</param>
        public void AddPredicate(dPredicate Predicate, params string[] key)
        {
            if (key == null || key.Length == 0)
            {
                key = new[]
                {
                    defaultKey
                };
            }

            if (predicateTree == null)
            {
                predicateTree = new Tree<List<dPredicate>>(key[0]);
            }

            int length = key.Length;

            Tree<List<dPredicate>> parentTree = new Tree<List<dPredicate>>();

            for (int i = 0; i < length; i++)
            {
                if (i == 0)
                {
                    parentTree = predicateTree;
                }
                if (i < length - 1)
                {
                    if (!parentTree.ContainKey(key[i + 1]))
                    {
                        Tree<List<dPredicate>> childTree = new Tree<List<dPredicate>>(key[i + 1]);
                        parentTree.Add(childTree);
                        parentTree = childTree;
                    }
                    else
                    {
                        parentTree = parentTree[key[i + 1]];
                    }
                }
                else
                {
                    parentTree.Value.Add(Predicate);
                }

            }
        }

        /// <summary>
        /// 获取在key下的条件是否成立
        /// </summary>
        /// <param name="key">键值对</param>
        /// <returns></returns>
        public bool GetPredicate(params string[] key)
        {
            if (key == null || key.Length == 0)
            {
                key = new[]
                {
                    defaultKey
                };
            }
            if (!GetCurrentNode(predicateTree.Value))
            {
                return false;
            }

            int length = key.Length;
            Tree<List<dPredicate>> childNode = new Tree<List<dPredicate>>();
            for (int i = 1; i < length; i++)
            {
                if (i == 1)
                {
                    childNode = predicateTree;
                }

                if (!GetCurrentNode(childNode[key[i]].Value))
                {
                    return false;
                }
                else
                {
                    childNode = childNode[key[i]];
                }
            }

            return GetCurrentNode(childNode.Value);
        }

        /// <summary>
        /// 获取条件能否成立
        /// </summary>
        /// <param name="predicates"></param>
        /// <returns></returns>
        private bool GetCurrentNode(List<dPredicate> predicates)
        {
            if (predicates == null || predicates.Count == 0)
            {
                return true;
            }
            int length = predicates.Count;
            bool temp = false;
            for (int i = 0; i < length; i++)
            {
                if (predicates[i] != null)
                {
                    temp = temp || predicates[i].Invoke();
                }
            }

            return temp;
        }

        /// <summary>
        /// 对条件树清空
        /// </summary>
        public void Clear()
        {
            predicateTree.Clear();
        }

        /// <summary>
        /// 删除某条件
        /// </summary>
        /// <param name="Predicate"></param>
        public void RemovePredicate(dPredicate Predicate)
        {
            RemovePredicate(Predicate,defaultKey);
        }

        /// <summary>
        /// 删除某键值对下的条件
        /// </summary>
        /// <param name="Predicate"></param>
        /// <param name="keys"></param>
        public void RemovePredicate(dPredicate Predicate, params string[] keys)
        {
            if (predicateTree == null)
            {
                return;
            }

            int length = keys.Length;
            Tree<List<dPredicate>> parentTree = new Tree<List<dPredicate>>();
            for (int i = 0; i < length; i++)
            {
                if (i == 0)
                {
                    parentTree = predicateTree;
                }

                parentTree = parentTree[keys[i]];
            }

            parentTree.Value.Remove(Predicate);
        }

        /// <summary>
        /// 从条件树中删除某键
        /// </summary>
        /// <param name="key"></param>
        public void RemoveKey(params string[] key)
        {

            if (key == null || key.Length == 0)
            {
                key = new[]
                {
                    defaultKey
                };
            }

            if (predicateTree == null)
            {
                return;
            }

            int length = key.Length;
            Tree<List<dPredicate>> parentTree = new Tree<List<dPredicate>>();
            for (int i = 0; i < length - 1; i++)
            {
                if (i == 0)
                {
                    parentTree = predicateTree;
                }
                parentTree = parentTree[key[i]];
            }

            parentTree.Remove(key[length - 1]);
        }

    }

   
}





测试代码
可以new 一个predicate,然后通过add方法添加条件,然后通过get方法得到是否符合条件,测试代码我就不上了,很简单

回复

使用道具 举报

7日久生情
3280/5000
排名
4934
昨日变化
36

4

主题

2740

帖子

3280

积分

Rank: 7Rank: 7Rank: 7Rank: 7

UID
209186
好友
5
蛮牛币
3787
威望
0
注册时间
2017-3-1
在线时间
306 小时
最后登录
2017-12-13
发表于 2017-12-5 08:48:32 | 显示全部楼层
谢谢分享

回复

使用道具 举报

3偶尔光临
261/300
排名
10701
昨日变化
167

8

主题

86

帖子

261

积分

Rank: 3Rank: 3Rank: 3

UID
208404
好友
0
蛮牛币
1527
威望
0
注册时间
2017-2-24
在线时间
93 小时
最后登录
2017-12-13
发表于 7 天前 | 显示全部楼层
感谢分享

回复

使用道具 举报

5熟悉之中
729/1000
排名
4247
昨日变化
31

1

主题

282

帖子

729

积分

Rank: 5Rank: 5

UID
122160
好友
0
蛮牛币
1339
威望
0
注册时间
2015-9-10
在线时间
174 小时
最后登录
2017-12-13
发表于 7 天前 | 显示全部楼层
感谢分享

回复

使用道具 举报

5熟悉之中
596/1000
排名
4771
昨日变化
31

13

主题

168

帖子

596

积分

Rank: 5Rank: 5

UID
231610
好友
3
蛮牛币
1083
威望
0
注册时间
2017-7-11
在线时间
209 小时
最后登录
2017-12-13
发表于 4 天前 | 显示全部楼层
感谢分享

回复

使用道具 举报

2初来乍到
115/150
排名
18672
昨日变化
742

0

主题

76

帖子

115

积分

Rank: 2Rank: 2

UID
250350
好友
0
蛮牛币
129
威望
0
注册时间
2017-10-23
在线时间
17 小时
最后登录
2017-12-12
发表于 昨天 19:07 | 显示全部楼层

感谢分享

回复

使用道具 举报

您需要登录后才可以回帖 登录 | 注册帐号

本版积分规则

快速回复 返回顶部 返回列表