card版本二

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;

/// <summary>
/// 开心类型
/// </summary>
public enum HappyType
{
    Bull,
    Worker,
    Boss,
}

/// <summary>
/// 卡片分类
/// </summary>
public enum CardType
{
    /// <summary>
    /// 钻石王国
    /// </summary>
    Diamond,
    /// <summary>
    /// 三叶草王国
    /// </summary>
    Grass,
    /// <summary>
    /// 红桃王国
    /// </summary>
    Red,
    /// <summary>
    /// 黑心王国
    /// </summary>
    Black,
}

/// <summary>
/// 结果类型
/// </summary>
public enum ResultType
{
    /// <summary>
    /// 散的
    /// </summary>
    Usually,
    /// <summary>
    /// 普通连的
    /// </summary>
    UsuallyConnect,
    /// <summary>
    /// 两个一样的
    /// </summary>
    TwoSeam,
    /// <summary>
    /// 特殊连的
    /// </summary>
    SpecialConnect,
    /// <summary>
    /// 三个一样的
    /// </summary>
    ThreeSeam,
    /// <summary>
    /// 默认值
    /// </summary>
    Defaut,
}

/// <summary>
/// 输出类型
/// </summary>
public enum OutType
{
    Simple,
    SimpleContinuous,
    Double,
    DoubleContinuous,
    Tribe,
    TribleContinuous,
    Quadra,
    QuadraContinuous,
    Legendary,
}

/// <summary>
/// 卡片数据
/// </summary>
public class CardData
{

    private int value;

    private CardType type;

    private int id;

    public int Value
    {
        get
        {
            return value;
        }
    }

    public CardType CardType
    {
        get
        {
            return type;
        }
    }

    public int Id
    {
        get
        {
            return id;
        }
    }

    public CardData(int number)
    {
        number = Mathf.Clamp(number, 0, 54);
        id = number;
        value = number % 13 + 1;
        type = (CardType)(number / 13);
    }

    public CardData(int number,HappyType happyType)
    {
        number = Mathf.Clamp(number, 0, 54);
        id = number;
        value = number % 13 + 1;
        //boss 正常流
        if(happyType == HappyType.Boss)
        {
            if(value == 1 || value == 2)
            {
                value *= 100;
            }
        }
        //worker 1 刀流
        else if (happyType == HappyType.Worker)
        {
            if (value == 1)
            {
                value = 100 / value;
            }
        }
        type = (CardType)(number / 13);
    }

    public static int operator +(int value, CardData card)
    {
        return value + card.Value;
    }

    public static int operator +(CardData card, int value)
    {
        return value + card.Value;
    }

    public static int operator +(CardData card, CardData value)
    {
        return value.value + card.Value;
    }

    public static bool operator >(CardData card1, CardData card2)
    {
        return card1.value > card2.value ||(card1.value == card2.value && card1.type > card2.type);
    }

    public static bool operator <(CardData card1, CardData card2)
    {
        return card1.value < card2.value || (card1.value == card2.value && card1.type < card2.type);
    }

    public override bool Equals(object obj)
    {
        CardData card = obj as CardData;
        if (card != null && card.id == this.id)
        {
            return true;
        }
        return false;
    }

    public override int GetHashCode()
    {
        return id.GetHashCode();
    }

}

/// <summary>
/// 拥有者基地
/// </summary>
public class OwnerBase
{
    protected List<CardData> cardDatas = new List<CardData>();

    protected int max_count;

    private int id;

    public CardData max_card;

    public int ID { get { return id; } }

    public OwnerBase(int id,int max_count = 3)
    {
        this.id = id;
        this.max_count = max_count;
    }

    public virtual void AddCard(CardData cardData)
    {
        if (cardDatas.Count == max_count)
            return;
        cardDatas.Add(cardData);
    }

}

/// <summary>
/// 三张拥有者
/// </summary>
public class Owner:OwnerBase
{

    private ResultType result;

    public ResultType ResultType
    {
        get
        {
            return result;
        }
    }

    public Owner(int id):base(id)
    {
        result = ResultType.Defaut;
    }

    public new void AddCard(CardData cardData)
    {
        base.AddCard(cardData);
        if(cardDatas.Count == max_count)
        {
            cardDatas.Sort();
            max_card = cardDatas[cardDatas.Count - 1];
            GetResult();
        }
    }

    private void GetResult()
    {
        int the_seam_count = 1;
        int connect = 1;
        bool is_usually = false;
        bool is_usually_connect = false;
        bool is_special_connect = false;
        for (int i = 0; i < cardDatas.Count - 1; i++)
        {
            if (cardDatas[i] == cardDatas[i + 1])
            {
                the_seam_count += 1;
                max_card = cardDatas[i] > cardDatas[i + 1] ? cardDatas[i] : cardDatas[i + 1];
            }
            else if (cardDatas[i] + 1 == cardDatas[i + 1].Value)
            {
                connect += 1;
                if (cardDatas[i].CardType == cardDatas[i + 1].CardType)
                {
                    is_special_connect = !is_usually_connect;
                }
                else
                {
                    is_special_connect = false;
                    is_usually_connect = true;
                }
            }
            else
            {
                is_usually = true;
            }
        }
        if(the_seam_count == 2)
        {
            result = ResultType.TwoSeam;
        }else if(the_seam_count == 3)
        {
            result = ResultType.ThreeSeam;
        }else if (is_usually)
        {
            result = ResultType.Usually;
        }
        else if(is_usually_connect)
        {
            result = ResultType.UsuallyConnect;
        }else if (is_special_connect)
        {
            result = ResultType.SpecialConnect;
        }
    }

    public static bool operator >(Owner owner1, Owner owner2)
    {
        return owner1.result > owner2.result || (owner1.result == owner2.result && owner1.max_card > owner2.max_card);
    }

    public static bool operator <(Owner owner1, Owner owner2)
    {
        return owner1.result < owner2.result || (owner1.result == owner2.result && owner1.max_card < owner2.max_card);
    }

}

public class SuperOwner:OwnerBase
{
    public SuperOwner(int id, int max_count) : base(id, max_count) { }

    private Dictionary<int, int> card_counts = new Dictionary<int, int>();

    public new void AddCard(CardData cardData)
    {
        base.AddCard(cardData);
        if (card_counts.ContainsKey(cardData.Value))
        {
            card_counts[cardData.Value]++;
        }
        else
        {
            card_counts[cardData.Value] = 1;
        }
        if (cardDatas.Count == max_count)
        {
            cardDatas.Sort();
        }
    }

    public List<CardData> OutCard(OutType outType,CardData max_card)
    {
        CardData two = null;
        CardData three = null;
        switch (outType)
        {
            case OutType.Simple:
                for (int i = 0; i < cardDatas.Count; i++)
                {
                    if(cardDatas[i].Value > max_card.Value)
                    {
                        if (card_counts[cardDatas[i].Value] == 1)
                            return new List<CardData> { cardDatas[i] };
                        else if (card_counts[cardDatas[i].Value] == 2)
                            two = cardDatas[i];
                        else if (card_counts[cardDatas[i].Value] == 3)
                            three = cardDatas[i];
                    }
                }
                if (two != null)
                    return new List<CardData>() { two };
                if (three != null)
                    return new List<CardData>() { three };
                break;
            case OutType.SimpleContinuous:
                break;
            case OutType.Double:
                break;
            case OutType.DoubleContinuous:
                break;
            case OutType.Tribe:
                break;
            case OutType.TribleContinuous:
                break;
            case OutType.Quadra:
                break;
            case OutType.QuadraContinuous:
                break;
            case OutType.Legendary:
                return null;
        }
        return null;
    }

    private List<CardData> HaveBetterContinuous(List<CardData> array, CardData max, int length,int count)
    {
        Dictionary<CardData, int> containt_dec = new Dictionary<CardData, int>();
        int number = 0;
        //如果是有序队列很好处理 判断从大于 max开始 对应max_index - length对应的值是否合理即可
        for (int i = length - 1; i < array.Count; i++)
        {
            if (array[i].Value > max.Value)
            {
                //存字典计数
                if (containt_dec.ContainsKey(array[i]))
                {
                    containt_dec[array[i]]++;
                    if(containt_dec[array[i]]>count)
                        number++;
                }
                else
                {
                    containt_dec.Add(array[i], 1);
                }
                if (array[i - length + 1 - number].Value == array[i].Value - length + 1)
                {

                }
            }
        }
        return null;
    }


}

/// <summary>
/// 卡片资源
/// </summary>
public class CardSource
{
    public Transform card_obj;
    public Image[] images;
    public CardData card;
    private Vector3 angle;
    public CardSource(CardData card, Transform card_obj)
    {
        this.card_obj = card_obj;
        this.card = card;
        images = card_obj.GetComponentsInChildren<Image>();
        angle = new Vector3(0, 0, 45);
    }

    public void ShowCard()
    {
        switch (card.CardType)
        {
            case CardType.Diamond:
                ShowCard(null, Color.red);
                break;
            case CardType.Grass:
                ShowCard(SourceManager.instacne.grass, Color.green);
                break;
            case CardType.Red:
                ShowCard(SourceManager.instacne.heart, Color.red);
                break;
            case CardType.Black:
                ShowCard(SourceManager.instacne.heart, Color.black);
                break;
        }
    }

    private void ShowCard(Sprite sprite, Color color)
    {
        Vector3 angle = Vector3.zero;
        if (sprite == null)
            angle = this.angle;
        for (int i = 1; i < images.Length; i++)
        {
            images[i].color = color;
            images[i].sprite = sprite;
            images[i].transform.localEulerAngles = angle;
        }
        card_obj.gameObject.SetActive(true);
    }
}

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class CardFactory : MonoBehaviour
{

    /// <summary>
    /// 可以分配的id
    /// </summary>
    private List<int> assigned_id = new List<int>();

    /// <summary>
    /// 使用中的id
    /// </summary>
    private List<int> using_id = new List<int>();

    private int select_count = 4;

    private void Start()
    {
        Init();
    }

    private void Init()
    {
        for (int i = 0; i < 54; i++)
        {
            assigned_id.Add(i);
        }
    }

    private CardData GetCardData()
    {
        int id_index = Random.Range(0, assigned_id.Count);
        CardData cardData = new CardData(assigned_id[id_index]);
        using_id.Add(assigned_id[id_index]);
        assigned_id.Remove(assigned_id[id_index]);
        return cardData;
    }

    private CardData[] GetCardData(int length)
    {
        CardData[] cardDatas = new CardData[length];

        for (int i = 0; i < cardDatas.Length; i++)
        {
            cardDatas[i] = GetCardData();
        }

        return cardDatas;
    }

}

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class SourceManager : MonoBehaviour
{

    public static SourceManager instacne;

    public List<GameObject> card_gameObjects;

    public Sprite grass;

    public Sprite heart;

    private void Awake()
    {
        instacne = this;
    }

}