完全的新手入门_使用Unity做个单机二人小麻将(一)
小实习生一枚,利用一周的时间做了个单机简单的二人小麻将
先上成品图
因为公司都用比较稳定的版本,所以我是从比较老的版本unity 4.7上手学习的
刚开始学什么都不懂,参考了一个别人写的斗地主demo,所以代码比较累赘…你们可以改良一下
二人麻将介绍
牌型分为:条,筒,万(没有东西南北发) 共108张
玩家: 二人
吃,碰,杠,胡均为简单算法,没有分种类和牌型(因为我不会打牌所以写的时候没有考虑暗杠)
功能实现
1:发牌
2:桌面摆牌
3:AI实现吃,碰,杠,胡功能
4:自己的牌实现智能提示吃,碰,杠,胡
步骤
首先导入ngui,导入ngui还是非常简单的,百度上面教程贼多,我就不写了
新建一个GameObject,改名为GameControll
绑上我们新建的C#脚本,这个脚本就是我们整个项目核心的控制点了
我在这里简单设置了一下参数,比如底分和全场倍数 ,接下来就可以开始往里面填东西la
public class GameController : MonoBehaviour{
public int basePointPerMatch;//底分
private int multiples;//全场倍数
// Use this for initialization
void Start()
{
multiples = 1;
basePointPerMatch = 100;
InitStar();//初始化场景
}
}
可以看到我这里写了一个初始化场景的方法InitStar() 使用代码动态生成页面
动态生成页面要准备好预制体,也就是画UI, 可以看到这里我将主要的场景分为两个预制体,一个是专门放player的,一个是专门放置按钮的
这是我的StartPanel预制体做好的样子
这是我的buttonPanel预制体
这里还有一个重要的预制体需要画好,即卡牌的预制体,要绑定一个类,我这里取名为CardSprite,进行卡牌精灵的处理
注意,所有调用的预制体必须放置在Resources文件夹下!我调用预制体的方法为Resources.Load(“XXX”)
做好这些准备,可以开始在GameControll类里面写初始化代码了
///
/// 初始化面板
///
public void InitStar()
{
GameObject buttonpanel = NGUITools.AddChild(UICamera.mainCamera.gameObject, (GameObject)Resources.Load("ButtonPanel"));
buttonpanel.AddComponent();
buttonpanel.name = buttonpanel.name.Replace("(Clone)", "");//可以替换掉后缀（Clone）
GameObject mainpanel = NGUITools.AddChild(UICamera.mainCamera.gameObject, (GameObject)Resources.Load("StartPanel"));//加载StartPanel第一个场景
mainpanel.name = mainpanel.name.Replace("(Clone)", "");//可以替换掉后缀（Clone）
GameObject AI= mainpanel.transform.Find("AI").gameObject;
HandCards AI1Cards = AI.AddComponent();//处理手牌的类
AI1Cards.cType = CharacterType.AI;//设定角色的类型
AI.AddComponent();//ai自动出牌的类
AI.transform.Find("playpoint").gameObject.SetActive(false);//隐藏AI放手牌的点
AI.transform.Find("showType").gameObject.SetActive(false);//这里可以处理图片
GameObject Player = mainpanel.transform.Find("Player").gameObject;
HandCards playerCards = Player.AddComponent();
Player.AddComponent();//玩家出牌调用的类
playerCards.cType = CharacterType.Player;
Player.transform.Find("playpoint").gameObject.SetActive(false);
print("初始化" + "toStar()");
}
写完上面的代码,运行你会发现你写好的预制体被动态加载出来了
可以看到这里我给预制体绑定了很多处理的辅助类,我将这几个类直接贴出来吧,相信很容易看得懂
// 用于规定枚举类型
using UnityEngine;
using System.Collections;
///
/// 角色类型
///
public enum CharacterType
{
Library = 0,
Player,
AI,
Desk
}
///
/// 牌类
///
public enum Suits
{
Tiao,
Tong,
Wan,
}
///
/// 卡牌权值
///
public enum Weight
{
_1 = 0,
_2,
_3,
_4,
_5,
_6,
_7,
_8,
_9,
}
///
/// 身份
///
public enum Identity
{
loser,
fightui_host,
none
}
///
/// 出牌类型
///
public enum CardsType //enum 枚举关键字
{
//未知类型
None=0,
fightui_chi ,
fightui_peng,
fightui_gang,
fightui_angang,
fightui_hu,
}
///
/// 牌的元素
///
public enum Cardselement //enum 枚举关键字
{
//未知类型
None = 0,
Double,//一堆将
ThereCount,//三顺
ThereSame,//三连
Gang
}
using UnityEngine;
using System.Collections;
using System.Collections.Generic;
//封装卡牌
public class Card
{
private readonly string cardName;//牌名
private readonly Weight weight;//权重
private readonly Suits suits; //种类
private CharacterType belongTo;//牌的归属
private bool makedSprite;
public string CardName
{
get
{
return cardName;
}
}
public Weight Weight
{
get
{
return weight;
}
}
public Suits Suits
{
get
{
return suits;
}
}
public CharacterType BelongTo
{
get
{
return belongTo;
}
set
{
belongTo = value;
}
}
public bool MakedSprite
{
get
{
return makedSprite;
}
set
{
makedSprite = value;
}
}
public Card(string name, Weight weight, Suits suits, CharacterType belongTo)
{
MakedSprite = false;
cardName = name;
this.weight = weight;
this.suits = suits;
this.BelongTo = belongTo;
}
}
using System.Collections.Generic;
using UnityEngine;
//生成手牌的类
public class HandCards : MonoBehaviour
{
public CharacterType cType;
private List library;
private Identity identity;
private Card newCard=null;
private int multiples;//玩家倍数
private int integration=1000;//积分
private bool Once = true;
void Start()
{
multiples = 1;
identity = Identity.loser;
library = new List();
}
///
/// 积分
///
public int Integration
{
set { integration = value; }
get { return integration; }
}
///
/// 玩家倍数
///
public int Multiples
{
set { multiples *= value; }
get { return multiples; }
}
///
/// 手牌数
///
public int CardsCount
{
get { return library.Count; }
}
///
/// 访问身份
///
public Identity AccessIdentity
{
set
{
identity = value;
}
get { return identity; }
}
public Card NewCard
{
get
{
return newCard;
}
}
public bool theOnce
{
get
{
return Once;
}
set
{
Once = value;
}
}
///
/// 获取手牌
///
///
///
/// 获取值的索引 索引器.
///
///
///
/// 添加手牌
///
///
public void AddCard(Card card)
{
card.BelongTo = cType;
library.Add(card);
newCard = card;
}
///
/// 出牌
///
///
/// 手牌排序
///
public void Sort()
{
CardRules.SortCards(library, false);//CardRules类用于处理手牌,排序,判断胡,碰,杠等
}
}
一定要绑到牌的预制体上哟!
//给卡牌预制体绑定的处理精灵的方法
using UnityEngine;
using System.Collections;
using System.Collections.Generic;
public class CardSprite : MonoBehaviour
{
private Card card;
public UISprite sprite;
private bool isSelected=false;
private bool canSeeCard;
public Card Poker
{
set
{
card = value;
card.MakedSprite = true;
SetSprite(canSeeCard);//显示ui
}
get { return card; }
}
///
/// 是否被点击中
///
public bool Select
{
set { isSelected = value; }
get { return isSelected; }
}
public bool CanSeeCard
{
get
{
return canSeeCard;
}
set
{
canSeeCard = value;
}
}
private void Start()
{
isSelected = false;
}
///
/// 设置UISprite的显示
///
void SetSprite(bool canSeeCard )
{
if (canSeeCard)
{
//明牌
sprite.transform.FindChild("mypointS").GetComponent().spriteName = card.CardName;
}
else {
if (card.BelongTo == CharacterType.Player || card.BelongTo == CharacterType.Desk)
{
sprite.transform.FindChild("mypointS").GetComponent().spriteName = card.CardName;
}
else
{
sprite.spriteName = "Top_Back";
}
}
}
///
/// 销毁精灵
///
public void Destroy()
{
if (card!=null) {
if (card.MakedSprite) {
//精灵化false
card.MakedSprite = false;
//销毁对象
Destroy(this.gameObject);
}
}
}
///
/// 调整位置
///
public void GoToPosition(CharacterType who, int index,int cardmargin)
{
if (sprite != null)
{
GameObject parent = GameObject.Find(who.ToString());
if (card.BelongTo == CharacterType.Player)//如果牌是player的，那么把牌放在player的点
{
GameObject mycon = parent.transform.FindChild("cardpengpoint").gameObject;
CardSprite[] myconsp = mycon.GetComponentsInChildren();
transform.localPosition = new Vector3(0, 0, 0);
CardSprite[] mypoint = parent.GetComponentsInChildren();
int margin = 0;
switch (myconsp.Length)
{
case 4:
margin = 180;
break;
case 8:
margin = 200 * 2;
break;
case 12:
margin = 200 * 3;
break;
case 16:
margin =210 * 4;
break;
default:
break;
};
sprite.width = 78;
sprite.height = 115;
if (Select)
{
sprite.spriteName = "Bottom_Stand_Front_Light";
}
else {
sprite.spriteName = "Bottom_Stand_Front";
}
sprite.transform.FindChild("mypointS").GetComponent().spriteName = card.CardName;
sprite.transform.FindChild("mypointS").GetComponent().depth =2;
sprite.transform.localScale = new Vector3((float)1.2, (float)1.2, 1);
transform.localPosition = new Vector3(-550+cardmargin*index+margin, -80, 0);
}
else if (card.BelongTo == CharacterType.AI)
{
if (canSeeCard)
{
sprite.width = 78;
sprite.height = 115;
sprite.spriteName = "Bottom_Stand_Front";
sprite.transform.FindChild("mypointS").GetComponent().spriteName = card.CardName;
sprite.depth = 1;
sprite.transform.FindChild("mypointS").GetComponent().depth =2;
sprite.transform.localScale = new Vector3((float)0.6, (float)0.6, 1);
sprite.transform.localPosition =
GameObject.Find(who.ToString()).transform.FindChild("playpoint").transform.localPosition + Vector3.right * 45 * index;
}
else {
sprite.spriteName = "Top_Back";
sprite.depth = 3;
sprite.width = 45;
sprite.height = 70;
// sprite.transform.localScale = new Vector3((float)0.6, (float)0.6, 1);
sprite.transform.localPosition=
GameObject.Find(who.ToString()).transform.FindChild("playpoint").transform.localPosition + Vector3.right * 45 * index;
}
}
else if (card.BelongTo == CharacterType.Desk)
{
sprite.width = 88;
sprite.height = 120;
sprite.spriteName = "Bottom_Front";
transform.FindChild("mypointS").GetComponent().leftAnchor.target = sprite.transform;
transform.FindChild("mypointS").GetComponent().leftAnchor.relative = 0;
transform.FindChild("mypointS").GetComponent().leftAnchor.absolute = 0;
transform.FindChild("mypointS").GetComponent().rightAnchor.relative = 1;
transform.FindChild("mypointS").GetComponent().rightAnchor.absolute = -2;
transform.FindChild("mypointS").GetComponent().bottomAnchor.relative = 0;
transform.FindChild("mypointS").GetComponent().bottomAnchor.absolute = 29;
transform.FindChild("mypointS").GetComponent().topAnchor.relative = 1;
transform.FindChild("mypointS").GetComponent().topAnchor.absolute = 0;
sprite.depth = 1;
sprite.transform.FindChild("mypointS").GetComponent().spriteName = card.CardName;
sprite.width = 78;
sprite.height = 115;
sprite.transform.localScale = new Vector3((float)0.5, (float)0.5, 1);
sprite.transform.localPosition =
transform.localPosition = GameObject.Find("showpoint").transform.localPosition ;
}
//else if (card.BelongTo == CharacterType.Desk)
//{
// sprite.spriteName = card.CardName;
// sprite.width = 40;
// sprite.height = 50;
// transform.localPosition = GameObject.Find("showplayerpoint").transform.localPosition + Vector3.right * 40 * index;
//}
}
}
///
/// 碰，杠，吃的位置
///
public void Changeposition(CharacterType who,int index) {
GameObject point = GameObject.Find(who.ToString()).transform.FindChild("cardpengpoint").gameObject;
sprite.width = 88;
sprite.height = 120;
sprite.spriteName = "Bottom_Front";
transform.FindChild("mypointS").GetComponent().leftAnchor.target = sprite.transform;
transform.FindChild("mypointS").GetComponent().leftAnchor.relative = 0;
transform.FindChild("mypointS").GetComponent().leftAnchor.absolute = 0;
transform.FindChild("mypointS").GetComponent().rightAnchor.relative = 1;
transform.FindChild("mypointS").GetComponent().rightAnchor.absolute = -2;
transform.FindChild("mypointS").GetComponent().bottomAnchor.relative = 0;
transform.FindChild("mypointS").GetComponent().bottomAnchor.absolute = 29;
transform.FindChild("mypointS").GetComponent().topAnchor.relative = 1;
transform.FindChild("mypointS").GetComponent().topAnchor.absolute = 0;
if (!CanSeeCard)
{
sprite.spriteName = "Bottom_Back";
transform.Find("mypointS").GetComponent().spriteName = "Bottom_Back";
transform.Find("mypointS").GetComponent().depth = 3;
sprite.depth = 2;
}
else {
sprite.transform.FindChild("mypointS").GetComponent().spriteName = card.CardName;
}
sprite.transform.localScale = new Vector3((float)0.8, (float)0.8, 1);
}
///
/// 卡牌点击
///
void OnClick()
{
if (card.BelongTo == CharacterType.Player)//在这里判断是否当前出牌为player，否则取消卡牌点击事件
{
GameObject parent = GameObject.Find(CharacterType.Player.ToString());
CardSprite[] sp = parent.GetComponentsInChildren();
List list = new List();
list.Clear();
for (int i = 0; i < sp.Length; i++) {
if (sp[i].sprite!=sprite) {
if (sp[i].Select) {
sp[i].Select = false;
sp[i].sprite.spriteName = "Bottom_Stand_Front";
}
}
}
isSelected = true;
sprite.spriteName = "Bottom_Stand_Front_Light";
}
}
}
using UnityEngine;
using System.Collections;
using System.Collections.Generic;
//生成牌库
public class CardControl {
private List library ;//可以通过判断library中的牌数量为零时结束对局
private static CardControl instance;
private CharacterType ctype;
private bool isEnd = false;
public static CardControl Instance
{
get
{
if (instance == null)
{
instance = new CardControl();
}
return instance;
}
}
///
/// 获取牌库中牌的数量
///
public int CardsCount
{
get { return library.Count; }
}
public bool IsEnd
{
get
{
return isEnd;
}
set
{
isEnd = value;
}
}
///
/// 索引器
///
///
///
/// 私有构造
///
private CardControl()
{
library = new List();
ctype = CharacterType.Library;
CreateCards();
}
public void ReCreate() {
library = new List();
ctype = CharacterType.Library;
CreateCards();
}
///
/// 创建一副牌
///
void CreateCards()
{
//创建普通牌
for (int num=0;num<4;num++) {
for (int type = 0; type < 3; type++)
{
for (int value = 0; value < 9; value++)
{
Weight w = (Weight)value;
Suits s = (Suits)type;
string name = s.ToString() + w.ToString();
Card card = new Card(name, w, s, ctype);
library.Add(card);
}
}
}
}
///
/// 洗牌
/// foreach语句是c#中新增的循环语句，他对于处理数组及集合等数据类型特别方便。
// foreach语句的一般语法格式如下：
// foreach（数据类型 标识符 in 表达式）{ 循环体 }
public void Shuffle()
{
if (CardsCount == 108)
{
System.Random random = new System.Random();
List newList = new List();
foreach (Card item in library)
{
newList.Insert(random.Next(newList.Count + 1), item);//ListCount的意思为:表项个数,用于反回表项的总个数,但它的下标从零开始，如果需要获得list的总长度需要+1
}
library.Clear();
foreach (Card item in newList)
{
library.Add(item);
}
newList.Clear();
}
}
///
/// 发牌
///
public Card Deal()
{
Card ret = library[library.Count - 1];
library.Remove(ret);
return ret;
}
///
/// 向牌库中添加牌
///
///
public void AddCard(Card card)
{
card.BelongTo = ctype;
library.Add(card);
}
}
弹出框的两个类
using UnityEngine;
using System.Collections;
using System.Collections.Generic;
public class MyConSprite : MonoBehaviour {
private bool select;
private GameObject myCheck;
private CardSprite[] sp = null;
private int CarspCount;
public bool Select
{
get
{
return select;
}
set
{
select = value;
}
}
public int CarspCount1
{
get
{
return CarspCount;
}
set
{
CarspCount = value;
}
}
public CardSprite[] Sp
{
get
{
return sp;
}
set
{
sp = value;
}
}
// Use this for initialization
void Start () {
myCheck = GameObject.Find("myCheck").gameObject;
myCheck.GetComponent().repositionNow = true;
myCheck.GetComponent().enabled = true;
myCheck.transform.localPosition = new Vector3(-280, -21, 0);
}
public void OntoGo()
{
Sp = transform.GetComponentsInChildren();
CarspCount1 = Sp.Length;
ConSpCache.Instance.CardClear();
for (int i=0; i();
controller.getConSelect();
for (int k = 0; k < myCheck.transform.childCount; k++)
{
GameObject go = myCheck.transform.GetChild(k).gameObject;
Destroy(go);
}
myCheck.SetActive(false);
}
}
using System.Collections.Generic;
using UnityEngine;
public class ConSpCache
{
private List sp;
private static ConSpCache instance;
public static ConSpCache Instance
{
get
{
if (instance == null)
{
instance = new ConSpCache();
}
return instance;
}
}
///
/// 私有构造
///
private ConSpCache()
{
sp = new List();
}
public List Sp
{
get
{
return sp;
}
}
///
/// 向牌库中添加牌
///
///
public void AddCard(CardSprite card)
{
Sp.Add(card);
}
public void CardClear() {
if (sp!=null) {
sp.Clear();
}
}
}
在GameControll中写洗牌,发牌,生成精灵等的方法,第一次写博客真是不知道怎么循序渐进,我直接把GameControll脚本全部贴出来吧
using UnityEngine;
using System.Collections;
using System.Collections.Generic;
public class GameController : MonoBehaviour{
public int basePointPerMatch;//底分
private int multiples;//全场倍数
// Use this for initialization
void Start()
{
multiples = 1;
basePointPerMatch = 100;
InitStar();
}
///
/// 全场倍数
///
public int Multiples
{
set { multiples *= value; }
get { return multiples; }
}
public int BasePointPerMatch
{
set { basePointPerMatch = value; }
get { return basePointPerMatch; }
}
///
/// 初始化面板
///
public void InitStar()
{
GameObject buttonpanel = NGUITools.AddChild(UICamera.mainCamera.gameObject, (GameObject)Resources.Load("ButtonPanel"));
buttonpanel.AddComponent();
buttonpanel.name = buttonpanel.name.Replace("(Clone)", "");//可以替换掉后缀（Clone）
GameObject mainpanel = NGUITools.AddChild(UICamera.mainCamera.gameObject, (GameObject)Resources.Load("StartPanel"));//加载StartPanel第一个场景
mainpanel.name = mainpanel.name.Replace("(Clone)", "");//可以替换掉后缀（Clone）
GameObject AI= mainpanel.transform.Find("AI").gameObject;
HandCards AI1Cards = AI.AddComponent();
AI1Cards.cType = CharacterType.AI;
AI.AddComponent();
AI.transform.Find("playpoint").gameObject.SetActive(false);
AI.transform.Find("showType").gameObject.SetActive(false);//这里可以处理图片
GameObject Player = mainpanel.transform.Find("Player").gameObject;
HandCards playerCards = Player.AddComponent();
Player.AddComponent();
playerCards.cType = CharacterType.Player;
Player.transform.Find("playpoint").gameObject.SetActive(false);
print("初始化" + "toStar()");
}
///
/// 洗牌
///
public void DealCards(CharacterType Startperson )
{
Debug.Log("洗牌" + "DealCards()--");
//洗牌
CardControl.Instance.Shuffle();
//发牌
CharacterType currentCharacter = CharacterType.Player;
for (int i = 0; i < 26; i++)
{
if (currentCharacter == CharacterType.Desk)//循环到Desk的时候跳过，从player发
{
currentCharacter = CharacterType.Player;
}
DoSend(currentCharacter);
currentCharacter++;
Debug.Log("洗牌" + "DealCards()--" + "currentCharacter++:" + currentCharacter);
}
if (Startperson!=CharacterType.AI) {
//发一张给
DoSend(Startperson);
}
for (int i = 1; i < 4; i++)
{
MakeHandCardsSprite((CharacterType)i, false,false,false);
}
Readjust(CharacterType.Player,true);
}
///
/// 发牌
///
public Card DoSend(CharacterType person)
{
Card movedCard;
if (CardControl.Instance.CardsCount == 0)
{
movedCard = null;
CardControl.Instance.IsEnd = true;
}
else {
if (person == CharacterType.Desk)
{
movedCard = CardControl.Instance.Deal();
CardCache.Instance.AddCard(movedCard);
}
else
{
GameObject playerObj = GameObject.Find(person.ToString());
HandCards cards = playerObj.GetComponent();
movedCard = CardControl.Instance.Deal();
cards.AddCard(movedCard);
}
}
return movedCard;
}
///
/// 精灵化角色手牌
///
///
///
void MakeHandCardsSprite(CharacterType type, bool isSelected,bool canSeeCard,bool isSend)
{
print("精灵化角色手牌" + "MakeHandCardsSprite()+获得的type" + type);
if (type==CharacterType.AI||type==CharacterType.Player) {
GameObject parent = GameObject.Find(type.ToString());
parent.transform.Find("playpoint").gameObject.SetActive(true);
}
if (type == CharacterType.Desk)
{
CardCache instance = CardCache.Instance;
for (int i = 0; i < instance.CardsCount; i++)
{
MakeSprite(type, instance[i], isSelected,canSeeCard);
}
}
else
{
//这个牌是给player和电脑
GameObject parentObj = GameObject.Find(type.ToString());
HandCards cards = parentObj.GetComponent();
//排序
//cards.Sort();
//精灵化
for (int i = 0; i < cards.CardsCount; i++)
{
if (!cards[i].MakedSprite)
{
MakeSprite(type, cards[i], isSelected,canSeeCard);
}
}
}
//调整精灵位置
AdjustCardSpritsPosition(type,canSeeCard);
}
///
/// 使卡牌精灵化
///
///
///
///
void MakeSprite(CharacterType type, Card card, bool selected,bool canSeeCard)
{
print("使卡牌精灵化" + "MakeSprite()+type" + type+"card:"+card.Weight+"--"+card.Suits);
if (!card.MakedSprite)
{
GameObject obj = Resources.Load("thepoint") as GameObject;
GameObject myCard;
if (type == CharacterType.Desk)
{
myCard = NGUITools.AddChild(GameObject.Find("showpoint"), obj);
}
else
{
myCard = NGUITools.AddChild(GameObject.Find(type.ToString()).gameObject, obj);
}
CardSprite sprite = myCard.gameObject.GetComponent();//脚本需要手动添加
sprite.Poker = card;
sprite.Select = selected;
sprite.CanSeeCard = canSeeCard;
}
}
///
/// 调整手牌位置
///
///
public static void AdjustCardSpritsPosition(CharacterType type,bool canSeeCard)
{
print("调整手牌位置" + "AdjustCardSpritsPosition() type" + type);
if (type == CharacterType.Desk)
{
CardCache instance = CardCache.Instance;
CardSprite[] cs;
cs = GameObject.Find("showpoint").GetComponentsInChildren();
for (int i=0; i();
CardSprite[] cs = GameObject.Find(type.ToString()).GetComponentsInChildren();
for (int i = 0; i < hc.CardsCount; i++)
{
for (int j = 0; j < cs.Length; j++)
{
if (cs[j].Poker == hc[i])
{
if (cs[j].Poker == hc.NewCard)
{
cs[j].GoToPosition(type, index,95);
}
else {
cs[j].GoToPosition(type, index, 90);
}
cs[j].CanSeeCard = canSeeCard;
index++;
}
}
}
}
}
///
/// 出完牌后二次排序
///
public void Readjust(CharacterType type,bool cansee)
{
GameObject parentObj = GameObject.Find(type.ToString());
HandCards cards = parentObj.GetComponent();
//排序
cards.Sort();
HandCards hc = GameObject.Find(type.ToString()).GetComponent();
CardSprite[] cs = GameObject.Find(type.ToString()).GetComponentsInChildren();
for (int i = 0; i < hc.CardsCount; i++)
{
for (int j = 0; j < cs.Length; j++)
{
if (cs[j].Poker == hc[i])
{
cs[j].GoToPosition(type, i, 90);
cs[j].CanSeeCard = cansee;
}
}
}
}
///
/// 庄
///
public void DealWith() {
CharacterType Mainidentity,Normalidentity;
Identity identity_host,identity_normal;
identity_host = Identity.fightui_host;
identity_normal = Identity.loser;
Mainidentity= CharacterType.Player;
Normalidentity= CharacterType.AI;
//更新身份
IdentityUpdate(Mainidentity, identity_host);
IdentityUpdate(Normalidentity, identity_normal);
DealCards(Mainidentity);//洗牌
}
///
/// ///更新身份
///
///
///
public void IdentityUpdate(CharacterType type,Identity identity) {
GameObject parent=GameObject.Find(type.ToString());
parent.transform.FindChild("identity").GetComponent().spriteName = identity.ToString();
HandCards cards = GameObject.Find(type.ToString()).GetComponent();
cards.AccessIdentity = identity;
//更新积分信息
//int inte = cards.Multiples * Multiples * basePointPerMatch * (int)(cards.AccessIdentity + 1);
cards.Integration = cards.Integration ;
UpdateGrade(cards.Integration, type);
}
//更新积分信息
public void UpdateGrade(int inte,CharacterType type){
GameObject obj = GameObject.Find(type.ToString()).transform.FindChild("gradelabel").gameObject;
obj.GetComponent().text = "积分:" + inte;
HandCards cards = GameObject.Find(type.ToString()).GetComponent();
cards.Integration = cards.Integration + inte;
Debug.Log("积分----------------+inte:"+inte);
}
///
/// 统计积分信息
///
/// ();
int inte = cards.Multiples * Multiples * basePointPerMatch * (int)(cards.AccessIdentity + 1);
if (cards.AccessIdentity != winner)
inte = -inte;
cards.Integration = cards.Integration + inte;
GameObject obj = GameObject.Find(type.ToString()).transform.FindChild("gradelabel").gameObject;
obj.GetComponent().text = "积分:" + inte;
Debug.Log(type+""+winner+"inte"+inte);
return inte;
}
///
/// 获取指定卡牌
///
///
///
///
/// 下一位出牌
///
public void TrunNext(CharacterType person) {
person++;
bool auto=PlayerChache.Instance.Auto;
if (person==CharacterType.Desk) {
person = CharacterType.Player;
}
if (person == CharacterType.Player) {
AICache.Instance.Iscurrent1 = false;
PlayerChache.Instance.Iscurrent1 = true;
PlayCard playCard = GameObject.Find("Player").GetComponent();
//轮到玩家出牌，激活玩家出牌按钮
buttonControl bc = GameObject.Find("ButtonPanel").GetComponent();
if (auto)
{
//调用自动出牌的方法
playCard.StarAuto(true,CharacterType.Player);
}
else {
bc.Cando();
bc.checkSend();
}
}
if (person==CharacterType.AI) {
AICache.Instance.Iscurrent1 = true;
PlayerChache.Instance.Iscurrent1 = false;
if (CardControl.Instance.CardsCount == 0)
{
Debug.Log("在这里结束啦啦啦啦啦啊");
GameOver(Identity.none);
}
else {
//开启自动出牌
SimpleSmartCard smart = GameObject.Find("AI").GetComponent();
smart.startSend(true);
Debug.Log("CharacterType:zidognchupai------------------------");
//调用玩家出牌的方法
PlayCard playCard = GameObject.Find("Player").GetComponent();
if (auto)
{
playCard.StarAuto(true, CharacterType.AI);
}
}
}
}
///
/// 补牌 即发一张牌
///
public Card AddCard(CharacterType currentperson) {
if (currentperson==CharacterType.AI) {
Debug.Log("发一张给AI++++++++++++++++++");
}
GameObject parentObj = GameObject.Find(currentperson.ToString());
HandCards cards = parentObj.GetComponent();
buttonControl bc = GameObject.Find("ButtonPanel").GetComponent();
//排序
// cards.Sort();
if (CardControl.Instance.CardsCount!= 0) {
//发一张给
Card sendcard = DoSend(currentperson);
MakeHandCardsSprite(currentperson, false,false,true);
return sendcard;
}
if (CardCache.Instance.CardsCount!=0) {
bc.checkeCanhu();
}
return null;
}
///
/// 游戏结束 游戏结束 弹出游戏结束画面 删除所有按钮 激活快速开始按钮 电脑明牌 分数结算
///
public void GameOver(Identity winner)
{
Debug.Log("游戏结束！！！");
CardControl.Instance.IsEnd = true;
//结束界面
buttonControl bc = GameObject.Find("ButtonPanel").GetComponent();
//统计所有人的分数
int playerGrade= integration(CharacterType.Player, winner);
int AIGrade = integration(CharacterType.AI, winner);
bc.isOver(playerGrade,AIGrade);
//明牌
CardSprite[] sprites = GameObject.Find(CharacterType.AI.ToString()).GetComponentsInChildren();
MakeHandCardsSprite(CharacterType.AI, false,true,false);
AdjustCardSpritsPosition(CharacterType.AI,true);
}
public void GameRestart() {
//删除所有牌 将所有牌回到牌库 删除精灵
BackToDeck();
DestroyAllSprites();
//清除桌面缓存
AICache.Instance.ClearAll();
PlayerChache.Instance.ClearAll();
Destroy(GameObject.Find("ButtonPanel").gameObject);
CardCache.Instance.Clear();
CardControl.Instance.ReCreate();
Destroy(GameObject.Find("StartPanel").gameObject);
//GameObject mainpanel = NGUITools.AddChild(UICamera.mainCamera.gameObject, (GameObject)Resources.Load("StartPanel"));//加载StartPanel第一个场景
//mainpanel.AddComponent();
//mainpanel.name = mainpanel.name.Replace("(Clone)", "");//可以替换掉后缀（Clone）
//GameObject buttonpanel = NGUITools.AddChild(UICamera.mainCamera.gameObject, (GameObject)Resources.Load("ButtonPanel"));
//buttonpanel.AddComponent();
//buttonpanel.name = buttonpanel.name.Replace("(Clone)", "");//可以替换掉后缀（Clone）
//for (int i = 1; i < 4; i++)
//{
// if (GameObject.Find(((CharacterType)i).ToString()))
// {
// IdentityUpdate((CharacterType)i, Identity.loser);
// }
//}
InitStar();
}
///
/// 改变牌放的点
///
public void ChangePosition(CharacterType person, CardsType type,List clist)
{
Card deskCard = CardCache.Instance.TotalWeight;
//销毁牌精灵
// CardSprite[] sprites = GameObject.Find("showpoint").GetComponentsInChildren();
CardSprite[] sprites2 = GameObject.Find(person.ToString()).GetComponentsInChildren();
//for (int i = 0; i < sprites.Length; i++)
//{
// sprites[i].Destroy();
//}
for (int i = 0; i < sprites2.Length; i++){
for (int j=0; j().repositionNow = true;
parent.GetComponent().enabled = true;
//精灵化
for (int i = 0; i < 3; i++)
{
GameObject obj = Resources.Load("thepoint") as GameObject;
obj= NGUITools.AddChild(myCard, obj);
obj.GetComponent().enabled = false;//设置不能够点击
CardSprite sprite = obj.gameObject.GetComponent();//脚本需要手动添加
if (clist.Count == 4&& type== CardsType.fightui_gang)
{
if (i == 1)
{
sprite.Poker = clist[i];
sprite.CanSeeCard = false;
}
else
{
sprite.CanSeeCard = true;
sprite.Poker = clist[i];
}
}
else {
sprite.CanSeeCard = true;
sprite.Poker = clist[i];
}
sprite.Changeposition(person,i);
}
Debug.Log("精灵化成功---调整牌的位置");
//调整牌的位置
AdjustCardSpritsPosition(person,false);
}
///
/// 场上的所有牌回到牌库中
///
public void BackToDeck()
{
print("场上的所有牌回到牌库中" + "BackToDeck()");
HandCards[] handCards = new HandCards[2];
handCards[0] = GameObject.Find("Player").GetComponent();
handCards[1] = GameObject.Find("AI").GetComponent();
for (int i = 0; i < handCards.Length; i++)
{
while (handCards[i].CardsCount != 0)
{
Card last = handCards[i][handCards[i].CardsCount - 1];
CardControl.Instance.AddCard(last);
handCards[i].PopCard(last);
}
}
}
///
/// 销毁精灵
///
public void DestroyAllSprites()
{
print("销毁精灵" + "DestroyAllSprites()");
CardSprite[][] cardSprites = new CardSprite[2][];
cardSprites[0] = GameObject.Find("Player").GetComponentsInChildren();
cardSprites[1] = GameObject.Find("AI").GetComponentsInChildren();
// Destroy(GameObject.Find("showpoint").gameObject);
for (int i = 0; i < cardSprites.GetLength(0); i++)
{
for (int j = 0; j < cardSprites[i].Length; j++)
{
cardSprites[i][j].Destroy();
}
}
}
///
/// 创建桌面牌的精灵
///
///
///
public static void CreateSprites(CharacterType fromperson,Card card)
{
List cards=new List();
cards.Clear();
if (fromperson == CharacterType.AI)
{
AICache.Instance.AddCard(card);
cards = AICache.Instance.Library;
}
else {
cards = PlayerChache.Instance.Library;
PlayerChache.Instance.AddCard(card);
}
GameObject myCheck = GameObject.Find(fromperson.ToString()).transform.Find("showardpoint").gameObject;
for (int k = 0; k < myCheck.transform.childCount; k++)
{
GameObject go = myCheck.transform.GetChild(k).gameObject;
Destroy(go);
}
// Destroy(show1[i].gameObject);//.gameObject才会删除组件，否则只会删除脚本
//myCheck.transform.Find("showardpoint").GetComponent().RemoveChild();
for (int i=0; i< cards.Count;i++) {//最后添加的一张牌要高亮
bool light=false;
if (i==cards.Count-1) {
light = true;
}
ShowSprite(fromperson, cards[i], light);
}
}
///
/// 显示桌面上的牌
///
public static void ShowSprite(CharacterType fromperson,Card card,bool light) {
GameObject myCard=null;
GameObject obj = Resources.Load("thepoint") as GameObject;
myCard = NGUITools.AddChild(GameObject.Find(fromperson.ToString()).transform.FindChild("showardpoint").gameObject, obj);
GameObject.Find(fromperson.ToString()).transform.FindChild("showardpoint").GetComponent().enabled = true;
GameObject.Find(fromperson.ToString()).transform.FindChild("showardpoint").GetComponent().repositionNow = true;
CardSprite sp = myCard.gameObject.GetComponent();
sp.Poker = card;
sp.sprite.width = 88;
sp.sprite.height =120;
if (light)
{
sp.sprite.spriteName = "Bottom_Front_Light";
}
else {
sp.sprite.spriteName = "Bottom_Front";
}
sp.transform.localScale = new Vector3((float)0.7, (float)0.7, 1);
sp.transform.FindChild("mypointS").GetComponent().leftAnchor.target = sp.transform;
sp.transform.FindChild("mypointS").GetComponent().leftAnchor.relative = 0;
sp.transform.FindChild("mypointS").GetComponent().leftAnchor.absolute = 0;
sp.transform.FindChild("mypointS").GetComponent().rightAnchor.relative = 1;
sp.transform.FindChild("mypointS").GetComponent().rightAnchor.absolute =-2;
sp.transform.FindChild("mypointS").GetComponent().bottomAnchor.relative = 0;
sp.transform.FindChild("mypointS").GetComponent().bottomAnchor.absolute = 29;
sp.transform.FindChild("mypointS").GetComponent().topAnchor.relative = 1;
sp.transform.FindChild("mypointS").GetComponent().topAnchor.absolute = 0;
}
public static void MakeDialogCell(List clist) {
buttonControl bc = GameObject.Find("ButtonPanel").GetComponent();
bc.ShowmyCheck(clist);
bc.transform.Find("myCheck").GetComponent().Reposition();// 这个标记会让元素立即重新排列。
// GameObject root = GameObject.Find("UI Root");
// GameObject parent = root.transform.Find("Camera/StartPanel(Clone)/myCheck").gameObject;
//parent.active=true;
//MyConSprite myCardparent = parent.GetComponent();
//parent.active = false;
}
//获取选择事件
public void getConSelect() {
PlayCard playCard = GameObject.Find("Player").GetComponent();
playCard.GetMySelectList();//去吃
//吃完 删除桌面上面被吃的牌
AICache.Instance.DeleteCard(CardCache.Instance.TotalWeight);
//ReCreateSprites(CharacterType.Player, PlayerChache.Instance.Library);
ReCreateSprites(CharacterType.AI, AICache.Instance.Library);
}
//如果没有其他选择，只为单选项
public static void CometoEat(List card) {
PlayCard playCard = GameObject.Find("Player").GetComponent();
playCard.noChoice(card);//直接去吃
//吃完 删除桌面上面被吃的牌
GameController controller = GameObject.Find("GameControll").GetComponent();
AICache.Instance.DeleteCard(CardCache.Instance.TotalWeight);
//controller.ReCreateSprites(CharacterType.Player,PlayerChache.Instance.Library);
controller.ReCreateSprites(CharacterType.AI,AICache.Instance.Library);
}
public void ReCreateSprites(CharacterType fromperson, List cards)
{
if (cards.Count>3) {
Debug.Log("ReCreateSprites： type==" + fromperson.ToString() + "cards:" + cards[0].CardName + cards[1].CardName+cards[2].CardName);
}
GameObject myCheck = GameObject.Find(fromperson.ToString()).transform.Find("showardpoint").gameObject;
for (int k = 0; k < myCheck.transform.childCount; k++)
{
GameObject go = myCheck.transform.GetChild(k).gameObject;
Destroy(go);
}
// Destroy(show1[i].gameObject);//.gameObject才会删除组件，否则只会删除脚本
//myCheck.transform.Find("showardpoint").GetComponent().RemoveChild();
for (int i = 0; i < cards.Count; i++)
{
bool light = false;
ShowSprite(fromperson, cards[i], light);
}
}
///
/// 删除桌面上被吃/碰/杠的牌
///
public void deleteCardOnDestory(CharacterType person,List cards) {
GameObject myCheck = GameObject.Find(person.ToString()).transform.Find("showardpoint").gameObject;
for (int k = 0; k < myCheck.transform.childCount; k++)
{
GameObject go = myCheck.transform.GetChild(k).gameObject;
Destroy(go);
}
// Destroy(show1[i].gameObject);//.gameObject才会删除组件，否则只会删除脚本
//myCheck.transform.Find("showardpoint").GetComponent().RemoveChild();
for (int i = 0; i < cards.Count; i++)
{
ShowSprite(person, cards[i], false);
}
}
//private void Update()
//{
// StartCoroutine(Up1());
//}
//private IEnumerator Up1()
//{
// GameObject root = GameObject.Find("UI Root");
// GameObject parent = root.transform.Find("Camera/StartPanel(Clone)/myCheck").gameObject;
// parent.active = true;
// yield return new WaitForSeconds(5);
// parent.active = false;
//}
}
开始控制按钮了,建一个脚本,绑定各种按钮,里面是按钮绑定的事件
public class buttonControl : MonoBehaviour {
private GameObject Startbtn;//开始游戏
private GameObject sendbtn;//出牌
private GameObject addbtn;//补牌
private GameObject hubtn;//胡
private GameObject pengbtn;//碰
private GameObject eatbtn;//吃
private GameObject gangbtn;//杠
private GameObject IsEnd;//游戏结束图
private GameObject restarBtn;//重新开始
private GameController controller;
private GameObject myCheck;//弹出框
private GameObject spupSprite;//托管最上层的遮罩
private GameObject autoreSetBtn;//取消托管按钮
private GameObject autocontrolbtn;//托管
private GameObject cancelbtn;//取消按钮
// Use this for initialization
void Start()
{
Startbtn = gameObject.transform.Find("Startbtn").gameObject;
sendbtn = gameObject.transform.Find("sendbtn").gameObject;
addbtn = gameObject.transform.Find("addbtn").gameObject;
hubtn = gameObject.transform.Find("hubtn").gameObject;
pengbtn = gameObject.transform.Find("pengbtn").gameObject;
eatbtn = gameObject.transform.Find("eatbtn").gameObject;
gangbtn = gameObject.transform.Find("gangbtn").gameObject;
IsEnd = gameObject.transform.Find("IsEnd").gameObject;
restarBtn = gameObject.transform.Find("restarBtn").gameObject;
myCheck = gameObject.transform.Find("myCheck").gameObject;
controller = GameObject.Find("GameControll").GetComponent();
spupSprite = gameObject.transform.Find("spup").gameObject;
autoreSetBtn = gameObject.transform.Find("autoreSet").gameObject;
autocontrolbtn = gameObject.transform.Find("autocontrolbtn").gameObject;
Startbtn.GetComponent().onClick.Add(new EventDelegate(StartGameCallBack));
sendbtn.GetComponent().onClick.Add(new EventDelegate(SendCallBack));
addbtn.GetComponent().onClick.Add(new EventDelegate(addCallBack));
hubtn.GetComponent().onClick.Add(new EventDelegate(HuCallBack));
pengbtn.GetComponent().onClick.Add(new EventDelegate(PengCallBack));
eatbtn.GetComponent().onClick.Add(new EventDelegate(EatCallBack));
gangbtn.GetComponent().onClick.Add(new EventDelegate(GangCallBack));
restarBtn.GetComponent().onClick.Add(new EventDelegate(RestarCallBack));
autocontrolbtn.GetComponent().onClick.Add(new EventDelegate(AutoControlCallBack));
autoreSetBtn.GetComponent().onClick.Add(new EventDelegate(AutoCancel));
spupSprite.gameObject.SetActive(false);
autoreSetBtn.gameObject.SetActive(false);
autocontrolbtn.SetActive(false);
Startbtn.SetActive(true);
sendbtn.gameObject.active = false;
addbtn.gameObject.active = false;
hubtn.gameObject.active = false;
pengbtn.gameObject.active = false;
eatbtn.gameObject.active = false;
gangbtn.gameObject.active = false;
IsEnd.gameObject.active = false;
restarBtn.gameObject.active = false;
cancelbtn.gameObject.active = false;
myCheck.SetActive(false);
}
//按下开始游戏按钮
public void StartGameCallBack() {
Startbtn.gameObject.active = false;
controller.DealWith();//开启GameControll中的发牌方法
sendbtn.SetActive(true);
}
//出牌按钮
public void SendCallBack() {
PlayCard playCard = GameObject.Find("Player").GetComponent();
controller.Readjust(CharacterType.Player, true);
if (playCard.CheckSelectCards())
{
//轮到下一位出牌
controller.TrunNext(CharacterType.Player);
}
}
//过牌 过牌之后不能碰 杠 只能胡
public void addCallBack(){
addbtn.SetActive(false);
eatbtn.SetActive(false);
pengbtn.SetActive(false);
gangbtn.SetActive(false);
hubtn.SetActive(false);
PlayCard playCard = GameObject.Find("Player").GetComponent();
PlayerChache.Instance.Cando = false;
if (playCard.checkCardsLength())
{
controller.Readjust(CharacterType.Player, true);
controller.AddCard(CharacterType.Player);
if (checkeCanhu())
{
sendbtn.SetActive(false);
}
else { sendbtn.SetActive(true); }
}
else {
sendbtn.SetActive(true);
}
}
//轮到玩家出牌
public void Resend() {
PlayCard playCard = GameObject.Find("Player").GetComponent();
if (!checkeCanhu()) {
sendbtn.gameObject.active = true;
}
}
//吃牌
public void EatCallBack() {
PlayCard playCard = GameObject.Find("Player").GetComponent();
if (playCard.CheckCardsType(CardsType.fightui_chi, true))
{
eatbtn.gameObject.active = false;
addbtn.SetActive(false);
hubtn.SetActive(false);
pengbtn.SetActive(false);
gangbtn.SetActive(false);
controller.Readjust(CharacterType.Player,true);
}
}
///
/// 检查是否能吃
///
public bool checkeat()
{
PlayCard playCard = GameObject.Find("Player").GetComponent();
if (playCard.CheckCardsType(CardsType.fightui_chi,false))
{
eatbtn.gameObject.active = true;
addbtn.gameObject.active = true;
return true;
}
return false;
}
///
/// 吃
///
public void canEat() {//这时候才真正吃
PlayerChache.Instance.Cando = false;
eatbtn.gameObject.active = false;
PlayCard playCard = GameObject.Find("Player").GetComponent();
if (!checkeCanhu())
{
GameController controller = GameObject.Find("GameControll").GetComponent();
if (playCard.checkCardsLength())
{
controller.Readjust(CharacterType.Player, true);
controller.AddCard(CharacterType.Player);
if (checkeCanhu())
{
sendbtn.SetActive(false);
}
else { sendbtn.SetActive(true); }
}
else
{
controller.Readjust(CharacterType.Player, true);
sendbtn.SetActive(true);
}
}
}
//碰
public void PengCallBack() {
PlayCard playCard = GameObject.Find("Player").GetComponent();
if (playCard.CheckCardsType(CardsType.fightui_peng, true))
{
PlayerChache.Instance.Cando = false;
pengbtn.SetActive(false);
addbtn.SetActive(false);
gangbtn.gameObject.active = false;
eatbtn.gameObject.active = false;
hubtn.gameObject.active = false;
AICache.Instance.DeleteCard(CardCache.Instance.TotalWeight);
controller.ReCreateSprites(CharacterType.AI, AICache.Instance.Library);
controller.Readjust(CharacterType.Player, true);
if (playCard.checkCardsLength())
{
controller.Readjust(CharacterType.Player, true);
controller.AddCard(CharacterType.Player);
if (checkeCanhu())
{
sendbtn.SetActive(false);
}
else { sendbtn.SetActive(true); }
}
else
{
sendbtn.SetActive(true);
}
// controller.ReCreateSprites(CharacterType.AI, AICache.Instance.Library);
}
}
///
/// 查是否能碰
///
public bool checkPeng()
{
PlayCard playCard = GameObject.Find("Player").GetComponent();
controller.Readjust(CharacterType.Player, true);
if (playCard.CheckCardsType(CardsType.fightui_peng, false))
{
pengbtn.SetActive(true);
addbtn.gameObject.active = true;
return true;
}
return false;
}
//杠
public void GangCallBack() {
PlayCard playCard = GameObject.Find("Player").GetComponent();
if (playCard.CheckCardsType(CardsType.fightui_gang,true))
{
PlayerChache.Instance.Cando = false;
addbtn.SetActive(false);
gangbtn.gameObject.active = false;
eatbtn.gameObject.active = false;
pengbtn.gameObject.active = false;
hubtn.gameObject.active = false;
//杠完补牌
checkSend();
if (!checkeCanhu())
{
AICache.Instance.DeleteCard(CardCache.Instance.TotalWeight);
controller.deleteCardOnDestory(CharacterType.AI,AICache.Instance.Library);
//controller.ReCreateSprites(CharacterType.Player, PlayerChache.Instance.Library);
controller.ReCreateSprites(CharacterType.AI, AICache.Instance.Library);
controller.Readjust(CharacterType.Player, true);
}
}
}
///
/// 检查能否杠
///
public bool checkGang() {
PlayCard playCard = GameObject.Find("Player").GetComponent();
controller.Readjust(CharacterType.Player, true);
if (playCard.CheckCardsType(CardsType.fightui_gang, false))
{
gangbtn.SetActive(true);
addbtn.SetActive(true);
sendbtn.SetActive(false);
return true;
}
return false;
}
///
/// 胡的按钮
///
public void HuCallBack() {
hubtn.SetActive(false);
// cancelbtn.SetActive(false);
autocontrolbtn.SetActive(false);
PlayCard playCard = GameObject.Find("Player").GetComponent();
if (playCard.CheckCardsType(CardsType.fightui_hu,true))
{
GameController controller = GameObject.Find("GameControll").GetComponent();
controller.GameOver(Identity.fightui_host);
}
}
public void isOver(int playergrade, int AIgrade) {
addbtn.SetActive(false);
sendbtn.SetActive(false);
eatbtn.SetActive(false);
gangbtn.SetActive(false);
pengbtn.SetActive(false);
hubtn.SetActive(false);
Destroy(addbtn.gameObject);
Destroy(sendbtn.gameObject);
Destroy(eatbtn.gameObject);
Destroy(gangbtn.gameObject);
Destroy(pengbtn.gameObject);
Destroy(hubtn.gameObject);
restarBtn.gameObject.active = true;
IsEnd.gameObject.active = true;
// autocontrolbtn.SetActive ( false);
IsEnd.transform.Find("playergrade").gameObject.GetComponent().text=playergrade+"";
IsEnd.transform.Find("AIgrade").gameObject.GetComponent().text = AIgrade + "";
}
public void RestarCallBack() {
IsEnd.gameObject.active = false;
restarBtn.gameObject.active = false;
GameController controller = GameObject.Find("GameControll").GetComponent();
controller.GameRestart();
Startbtn.gameObject.active = true;
}
public bool checkeCanhu() {
PlayCard playCard = GameObject.Find("Player").GetComponent();
if (playCard.CheckCardsType(CardsType.fightui_hu,false))
{
hubtn.SetActive(true);
addbtn.SetActive(true);
// cancelbtn.SetActive(true);
sendbtn.gameObject.active = false;
return true;
}
return false;
}
public void ShowmyCheck(List clist) {
myCheck.SetActive(true);
GameObject myCard = NGUITools.AddChild(myCheck, Resources.Load("myCondia") as GameObject);
myCard.GetComponent().enabled = true;
myCard.GetComponent().repositionNow = true;
//精灵化
for (int i = 0; i < 3; i++)
{
GameObject obj = Resources.Load("thepoint") as GameObject;
obj = NGUITools.AddChild(myCard, obj);
obj.GetComponent().enabled = false;//设置不能够点击
CardSprite sprite = obj.gameObject.GetComponent();//脚本需要手动添加
sprite.Poker = clist[i];
sprite.sprite.width = 78;
sprite.sprite.height = 115;
sprite.transform.localScale = new Vector3((float)1, (float)1, 1);
}
}
///
/// 自动查牌
///
public void Cando() {
if (checkeCanhu())
{
sendbtn.SetActive(false);
PlayerChache.Instance.Cando = true;
}
PlayCard playCard = GameObject.Find("Player").GetComponent();
if (playCard.checkCardsLength()) {
if (checkeat())
{
sendbtn.SetActive(false);
PlayerChache.Instance.Cando = true;
}
if (checkGang())
{
sendbtn.SetActive(false);
PlayerChache.Instance.Cando = true;
}
if (checkPeng())
{
sendbtn.SetActive(false);
PlayerChache.Instance.Cando = true;
}
if (checkGang())
{
sendbtn.SetActive(false);
PlayerChache.Instance.Cando = true;
}
}
}
///
/// 检查是否能够发牌
///
/// ();
if (playCard.checkCardsLength())
{
controller.Readjust(CharacterType.Player,true);
controller.AddCard(CharacterType.Player);
}
if (!checkeCanhu())
{
if (PlayerChache.Instance.Iscurrent1)
{//查当前出牌者
sendbtn.SetActive(true);
}
}
}
}
}
数据处理的卡牌缓存和算法写在第二部分了