CardFilter.cs

using System;
using System.Collections.Generic;
 
// Token: 0x020004F2 RID: 1266
[Serializable]
public class CardFilter : EClass
{
    // Token: 0x060021C3 RID: 8643 RVA: 0x000BAC1C File Offset: 0x000B8E1C
    public override string ToString()
    {
        return this.id;
    }
 
    // Token: 0x060021C4 RID: 8644 RVA: 0x000BAC24 File Offset: 0x000B8E24
    protected virtual bool _ShouldPass(CardRow source)
    {
        return true;
    }
 
    // Token: 0x060021C5 RID: 8645 RVA: 0x000BAC27 File Offset: 0x000B8E27
    public virtual bool ContainsTag(CardRow source, string str)
    {
        return source.tag.Contains(str);
    }
 
    // Token: 0x060021C6 RID: 8646 RVA: 0x000BAC38 File Offset: 0x000B8E38
    public void Init()
    {
        this.BuildList(this.tags, this.strTag);
        this.BuildList(this.filters, this.strFilter);
        if (!this.filterCategory.IsEmpty())
        {
            foreach (string text in this.filterCategory)
            {
                bool flag = text.StartsWith('-');
                SourceCategory.Row row = EClass.sources.categories.map[flag ? text.Remove(0, 1) : text];
                this.categories.Add(new CardFilter.FilterCategory
                {
                    exclude = flag,
                    row = row
                });
                if (!flag)
                {
                    this.categoriesInclude.Add(row);
                }
            }
        }
        this.isInitialied = true;
    }
 
    // Token: 0x060021C7 RID: 8647 RVA: 0x000BACF4 File Offset: 0x000B8EF4
    public bool Pass(CardRow source)
    {
        if (!this.isInitialied)
        {
            this.Init();
        }
        if (source.chance == 0 || source.isOrigin)
        {
            return false;
        }
        for (int i = 0; i < this.tags.Count; i++)
        {
            CardFilter.FilterItem filterItem = this.tags[i];
            if (filterItem.exclude)
            {
                if (this.ContainsTag(source, filterItem.name))
                {
                    return false;
                }
            }
            else if (!this.ContainsTag(source, filterItem.name))
            {
                return false;
            }
        }
        for (int j = 0; j < this.filters.Count; j++)
        {
            CardFilter.FilterItem filterItem2 = this.filters[j];
            if (filterItem2.exclude)
            {
                if (source.filter.Contains(filterItem2.name))
                {
                    return false;
                }
            }
            else if (!source.filter.Contains(filterItem2.name))
            {
                return false;
            }
        }
        if ((this.isChara && !source.isChara) || (!this.isChara && source.isChara))
        {
            return false;
        }
        if (this.categories.Count > 0)
        {
            bool flag = false;
            foreach (CardFilter.FilterCategory filterCategory in this.categories)
            {
                if ((!flag || filterCategory.exclude) && EClass.sources.categories.map[source.category].IsChildOf(filterCategory.row))
                {
                    if (filterCategory.exclude)
                    {
                        return false;
                    }
                    flag = true;
                }
            }
            if (!flag)
            {
                return false;
            }
        }
        return this._ShouldPass(source);
    }
 
    // Token: 0x060021C8 RID: 8648 RVA: 0x000BAE98 File Offset: 0x000B9098
    public void BuildList(List<CardFilter.FilterItem> list, string[] strs)
    {
        if (strs == null)
        {
            return;
        }
        foreach (string text in strs)
        {
            list.Add(CardFilter.GetFilterItem(text));
        }
    }
 
    // Token: 0x060021C9 RID: 8649 RVA: 0x000BAECC File Offset: 0x000B90CC
    public static CardFilter.FilterItem GetFilterItem(string text)
    {
        bool flag = text.StartsWith("-");
        return new CardFilter.FilterItem
        {
            exclude = flag,
            name = (flag ? text.Substring(1) : text)
        };
    }
 
    // Token: 0x0400113E RID: 4414
    public string id;
 
    // Token: 0x0400113F RID: 4415
    public string[] strTag;
 
    // Token: 0x04001140 RID: 4416
    public string[] strFilter;
 
    // Token: 0x04001141 RID: 4417
    public string[] filterCategory;
 
    // Token: 0x04001142 RID: 4418
    public string[] idCard;
 
    // Token: 0x04001143 RID: 4419
    public List<CardFilter.FilterItem> tags = new List<CardFilter.FilterItem>();
 
    // Token: 0x04001144 RID: 4420
    public List<CardFilter.FilterItem> filters = new List<CardFilter.FilterItem>();
 
    // Token: 0x04001145 RID: 4421
    public List<CardFilter.FilterCategory> categories = new List<CardFilter.FilterCategory>();
 
    // Token: 0x04001146 RID: 4422
    public List<SourceCategory.Row> categoriesInclude = new List<SourceCategory.Row>();
 
    // Token: 0x04001147 RID: 4423
    private bool isInitialied;
 
    // Token: 0x04001148 RID: 4424
    public bool isChara;
 
    // Token: 0x020009F3 RID: 2547
    public class FilterItem
    {
        // Token: 0x04002923 RID: 10531
        public bool exclude;
 
        // Token: 0x04002924 RID: 10532
        public string name;
    }
 
    // Token: 0x020009F4 RID: 2548
    public class FilterCategory
    {
        // Token: 0x04002925 RID: 10533
        public bool exclude;
 
        // Token: 0x04002926 RID: 10534
        public SourceCategory.Row row;
    }
 
    // Token: 0x020009F5 RID: 2549
    public enum FilterMode
    {
        // Token: 0x04002928 RID: 10536
        None,
        // Token: 0x04002929 RID: 10537
        Exclude,
        // Token: 0x0400292A RID: 10538
        Match,
        // Token: 0x0400292B RID: 10539
        Equipped
    }
}