static protected bool checkNoMoreBigger(CardVO card)
{
CardVO historyCard;
if (card.Rank == Config.ACE_RANK)
{
return(true);
}
for (int rank = card.Rank + 1; rank <= Config.ACE_RANK; rank++)
{
bool isFindedInHistory = false;
for (int j = 0; j < GameModel.inst.level.History.Count; j++)
{
historyCard = GameModel.inst.level.History[j] as CardVO;
if (historyCard.Suit == card.Suit && historyCard.Rank == rank)
{
isFindedInHistory = true;
break;
}
}
if (!isFindedInHistory)
{
return(false);
}
}
return(true);
}
void OnMouseDown()
{
for (int i = 0; i < GameModel.inst.cardsOnDeck.Count; i++)
{
CardVO cardInDeck = GameModel.inst.cardsOnDeck[i] as CardVO;
if (cardInDeck.Owner.Id == Config.PLAYER_ME)
{
return; // мы уже ходили в этом ходу
}
}
if (Disabled ||
GameModel.inst.currentPlayer.Id != Config.PLAYER_ME ||
AnimationHelper.isAnimated ||
GameModel.inst.GameStatus == Config.GAME_STATUS_SELECT_LEVEL)
{
return;
}
if (GameController.inst.checkIfTurnValid(card))
{
AnimationHelper.makeTurn(card);
}
else
{
AudioManager.inst.playError();
Debug.LogError("You can't make turn with this card!");
}
}
public static CardVO getCardByTricksLogic(ArrayList deck)
{
CardVO playingCard = null;
if (isFirstTurn)
{
ArrayList sorted = sortCardsByDecrease(deck);
playingCard = sorted[sorted.Count - 1] as CardVO;
if (!checkNoMoreBigger(playingCard)) // если в игре есть карты больше, то ходим с самой маленькой
{
playingCard = sorted[0] as CardVO;
}
}
else
{
CardVO maxCard = getMaxCard();
CardVO card;
for (int a = 0; a < deck.Count; a++)
{
card = deck[a] as CardVO;
if (card.Suit == maxCard.Suit)
{
if (playingCard == null)
{
playingCard = card; // первая карта такой масти
}
else
{
if (card.Rank > maxCard.Rank && checkNoMoreBigger(card))
{
playingCard = card;
}
else
{
if (card.Rank < playingCard.Rank) // если больше максимальной, но меньше текущей
{
playingCard = card;
}
}
if (isLastTurn && card.Rank > maxCard.Rank)
{
if (card.Rank < playingCard.Rank || playingCard.Rank < maxCard.Rank)
{
playingCard = card; // если ходим последними, то все равно забираем
}
}
}
}
}
if (playingCard == null)
{
playingCard = sortCardsByDecrease(deck)[0] as CardVO; // если нужной масти не найдено, ходим самой меньшей
}
}
return(playingCard);
}
public bool checkIfTurnValid(CardVO card)
{
if (GameModel.inst.level.Strategy == GameStrategy.NO_HEARTS || GameModel.inst.level.Strategy == GameStrategy.NO_ANY ||
GameModel.inst.level.Strategy == GameStrategy.TAKE_HEARTS || GameModel.inst.level.Strategy == GameStrategy.TAKE_ANY ||
GameModel.inst.level.Strategy == GameStrategy.NO_KING || GameModel.inst.level.Strategy == GameStrategy.TAKE_KING)
{
if (GameModel.inst.cardsOnDeck.Count == 0 && card.Suit == Config.HEARTS_SUIT &&
(card.Owner.hasSuit(Config.DIAMONDS_SUIT) || card.Owner.hasSuit(Config.CLUBS_SUIT) || card.Owner.hasSuit(Config.SPADES_SUIT)) // если есть какая-то масть кроме чирвы, то с чирвы ходить нельзя
)
{
return(false);
}
}
if (GameModel.inst.level.Strategy == GameStrategy.NO_KING || GameModel.inst.level.Strategy == GameStrategy.NO_ANY || GameModel.inst.level.Strategy == GameStrategy.TAKE_KING || GameModel.inst.level.Strategy == GameStrategy.TAKE_ANY)
{
bool hasKingCard = false;
bool hasSameSuite = false;
CardVO playerCard;
if (GameModel.inst.cardsOnDeck.Count > 0)
{
for (int i = 0; i < GameModel.inst.Players[Config.PLAYER_ME].Deck.Count; i++)
{
playerCard = GameModel.inst.Players[Config.PLAYER_ME].Deck[i] as CardVO;
if (playerCard.Suit == Config.HEARTS_SUIT && playerCard.Rank == Config.KING_RANK)
{
hasKingCard = true;
}
if (playerCard.Suit == (GameModel.inst.cardsOnDeck[0] as CardVO).Suit)
{
hasSameSuite = true;
}
}
if ((GameModel.inst.cardsOnDeck[0] as CardVO).Suit != card.Suit && !hasSameSuite && hasKingCard)
{
return(card.Suit == Config.HEARTS_SUIT && card.Rank == Config.KING_RANK);
}
}
}
if (GameModel.inst.cardsOnDeck.Count == 0)
{
return(true);
}
CardVO firstCatd = GameModel.inst.cardsOnDeck[0] as CardVO;
if (card.Suit == firstCatd.Suit || !card.Owner.hasSuit(firstCatd.Suit))
{
return(true);
}
else
{
return(false);
}
}
void removeCard(CardVO card)
{
if (card.gameObject)
{
Destroy(card.gameObject);
}
card.Owner.Deck.Remove(card);
GameModel.inst.cardsOnDeck.Remove(card);
}
public static void makeDistribution(CardVO card, float delay)
{
Vector3 startPosotion = GameObject.Find(Config.CREATE_CARD_POSITION).transform.position;
//SpriteRenderer renderer = card.gameObject.GetComponent<SpriteRenderer>();
//renderer.sprite = Resources.Load<Sprite>("Cards/" + card.ImageName);
//isAnimated = true;
Vector3 position = card.gameObject.transform.position;
card.gameObject.transform.position = new Vector3(startPosotion.x, startPosotion.y, 1);
iTween.MoveTo(card.gameObject, iTween.Hash("x", position.x, "y", position.y, "delay", delay, "time", Config.SPEED_DISTRIBUTION, "oncomplete", "endDistribution")); // callback is in CardMediator
// Debug.Log("select card # " + card.Id);
}
public static void grabCards(PlayerVO grabber)
{
string namePositionPoint = grabber.Container;
Vector3 position = GameObject.Find(namePositionPoint).transform.position;
AudioManager.inst.playGrab();
for (int i = 0; i < GameModel.inst.cardsOnDeck.Count; i++)
{
CardVO card = GameModel.inst.cardsOnDeck[i] as CardVO;
iTween.MoveTo(card.gameObject, iTween.Hash("x", position.x, "y", position.y, "time", 0.7, "oncomplete", "endGrab")); // callback is in CardMediator
Debug.Log("grab card # " + card.Id);
}
}
public static void makeTurn(CardVO card)
{
SpriteRenderer renderer = card.gameObject.GetComponent <SpriteRenderer>();
renderer.sprite = Resources.Load <Sprite>("Cards/" + card.ImageName);
isAnimated = true;
string namePositionPoint = Config.NameOfPlayersPointsOnTable[card.Owner.Id];
Vector3 position = GameObject.Find(namePositionPoint).transform.position;
AudioManager.inst.playEndTurn();
iTween.MoveTo(card.gameObject, iTween.Hash("x", position.x, "y", position.y, "time", 0.5, "oncomplete", "endTurn")); // callback is in CardMediator
// Debug.Log("select card # " + card.Id);
}
static protected CardVO getMaxCard()
{
CardVO maxCard = GameModel.inst.cardsOnDeck[0] as CardVO;
CardVO card;
for (int m = 0; m < GameModel.inst.cardsOnDeck.Count; m++) // находим самую сильную играющую карту
{
card = GameModel.inst.cardsOnDeck[m] as CardVO;
if (card.Suit == maxCard.Suit && card.Rank > maxCard.Rank)
{
maxCard = card;
}
}
return(maxCard);
}
void createCard(int number, CardVO card)
{
GameObject go = new GameObject("card");
SpriteRenderer renderer = go.AddComponent <SpriteRenderer>();
GameObject container = GameObject.Find(card.Owner.Container);
Vector3 position = container.transform.Find("CardPlace").gameObject.transform.position;
CardMediator cardMediator;
if (card.Owner.Id == Config.PLAYER_ME)
{
go.transform.position = new Vector3(position.x + number * Config.DISTANCE_BETWEEN_CARDS_FOR_PLAYER, position.y, 1);
//renderer.sprite = Resources.Load<Sprite>("Cards/" + card.ImageName);
renderer.sprite = Resources.Load <Sprite>("Cards/CardBack");
go.AddComponent <BoxCollider>();
cardMediator = go.AddComponent <CardMediator>();
cardMediator.card = card;
}
else
{
if (Config.IS_AI_CARDS_OPEN)
{
renderer.sprite = Resources.Load <Sprite>("Cards/" + card.ImageName);
}
else
{
renderer.sprite = Resources.Load <Sprite>("Cards/CardBack");
}
go.transform.position = new Vector3(position.x + number * Config.DISTANCE_BETWEEN_CARDS, position.y, 1);
cardMediator = go.AddComponent <CardMediator>();
cardMediator.card = card;
}
card.gameObject = go;
float delay = number * 4 * Config.SPEED_DISTRIBUTION;
int playerNumber = card.Owner.Id;
if (playerNumber == Config.PLAYER_C && number == 7) // last card
{
cardMediator.IsLast = true;
}
AnimationHelper.makeDistribution(card, (Config.SPEED_DISTRIBUTION * playerNumber + delay) / 2);
}
private void OnSubSendCard(byte[] tmpBuf, int size)
{
MyDebug.Log("OnSubSendCard");
var pSpendCard = NetUtil.BytesToStruct <CMD_S_SendCard>(tmpBuf); //发送扑克？
if (pSpendCard.wCurrentUser == GlobalDataScript.loginResponseData.chairID) //自己摸牌
{
var cvo = new CardVO
{
cardPoint = MaJiangHelper.MaJiangCardChange((MJ_PAI)pSpendCard.cbCardData)
};
SetClientResponse(APIS.PICKCARD_RESPONSE, NetUtil.ObjToJson(cvo));
var mahjongMotion = new MahjongMotion();
MyDebug.Log(pSpendCard.cbActionMask);
MyDebug.Log((byte)WIK.WIK_GANG);
MyDebug.Log((byte)WIK.WIK_CHI_HU);
if (pSpendCard.cbActionMask != (int)WIK.WIK_NULL)
{
mahjongMotion.cardID = cvo.cardPoint;
if ((pSpendCard.cbActionMask & (byte)WIK.WIK_GANG) > 0)
{
mahjongMotion.isGangMotion = true;
}
if ((pSpendCard.cbActionMask & (Byte)WIK.WIK_CHI_HU) > 0)
{
mahjongMotion.isChiHuMotion = true;
}
SetClientResponse(APIS.RETURN_INFO_RESPONSE, NetUtil.ObjToJson(mahjongMotion));
}
}
else //他人摸牌
{
var cvo = new CardVO
{
avatarIndex = pSpendCard.wCurrentUser
};
MyDebug.Log("当前摸牌用户用户：" + cvo.avatarIndex);
SetClientResponse(APIS.OTHER_PICKCARD_RESPONSE_NOTICE, NetUtil.ObjToJson(cvo));
}
}
static CardVO getMaxValueOfStack()
{
CardVO maxCard = null;
if (GameModel.inst.cardsOnDeck.Count > 0)
{
maxCard = GameModel.inst.cardsOnDeck[0] as CardVO;
for (int m = 0; m < GameModel.inst.cardsOnDeck.Count; m++) // находим самую большую играющую карту
{
CardVO card = GameModel.inst.cardsOnDeck[m] as CardVO;
if (card.Suit == maxCard.Suit && card.Rank > maxCard.Rank)
{
maxCard = card;
}
}
}
return(maxCard);
}
public void click()
{
CardVO cardvo = new CardVO();
cardvo.cardPoint = card;
cardvo.onePoint = one;
cardvo.twoPoint = two;
CustomSocket.getInstance().sendMsg(new ChiRequest(cardvo));
GameObject passButton = GameObject.Find("Canvas/container/Panel_GamePlay(Clone)/PassButton2");
if (passButton != null)
{
passButton.SetActive(false);
}
for (int i = 0; i < this.transform.parent.childCount; i++)
{
GameObject go = this.transform.parent.GetChild(i).gameObject;
Destroy(go);
}
}
public static CardVO getCardByLastTricksLogic(ArrayList deck)
{
CardVO playingCard = null;
CardVO card = null;
CardVO smallestPlayingCard = null;
ArrayList sorted = sortCardsByDecrease(deck);
if (isFirstTurn)
{
if (isLastOfTwoTurns(deck))
{
playingCard = sorted[sorted.Count - 1] as CardVO;
if (!checkNoMoreBigger(playingCard)) // если в игре есть карты больше, то ходим с самой маленькой
{
playingCard = sorted[0] as CardVO;
}
}
else
{
playingCard = sorted[0] as CardVO;
}
}
else
{
CardVO maxCard = getMaxCard();
for (int a = 0; a < sorted.Count; a++)
{
card = sorted[a] as CardVO;
if (isLastOfTwoTurns(deck))
{
if (card.Suit == maxCard.Suit && card.Rank > maxCard.Rank && checkNoMoreBigger(card)) // карта той же масти, и больше нее в игре сейчас нет
{
playingCard = card;
break;
}
if (isLastTurn && card.Rank > maxCard.Rank) // мы ходим последними, поэтому достаточно чтоб карта была больше максимальной
{
playingCard = card;
break;
}
}
else
{
if (card.Suit == maxCard.Suit)
{
playingCard = card;
break;
}
}
if (smallestPlayingCard == null && card.Suit == maxCard.Suit)
{
smallestPlayingCard = card;
}
}
}
if (smallestPlayingCard == null)
{
smallestPlayingCard = sorted[0] as CardVO;
for (int b = 0; b < sorted.Count; b++)
{
card = sorted[b] as CardVO;
if (!isQueenCard(card))
{
smallestPlayingCard = card;
break;
}
}
}
if (playingCard == null)
{
playingCard = smallestPlayingCard; // если карты не найдено, ходим самой меньшей
}
return(playingCard);
}
public static CardVO getCardForPlay(ArrayList deck)
{
CardVO playingCard = null;
if (GameModel.inst.cardsOnDeck.Count == 0)
{
playingCard = sortCardsByDecrease(deck)[0] as CardVO;
}
else
{
CardVO maxCard = getMaxCard();
CardVO card;
for (int a = 0; a < deck.Count; a++)
{
card = deck[a] as CardVO;
if (card.Suit == maxCard.Suit)
{
if (playingCard == null)
{
playingCard = card; // первая карта такой масти
}
else
{
if (playingCard.Rank > maxCard.Rank && isQueenCard(playingCard) && !isQueenCard(card))
{
playingCard = card; // заменяем даму, если это возможно
}
if (card.Rank < maxCard.Rank)
{
if (!isQueenCard(playingCard))
{
playingCard = card;
}
else
{
if (isQueenCard(card))
{
playingCard = card;
}
}
}
if (GameModel.inst.cardsOnDeck.Count == 3 && playingCard.Rank > maxCard.Rank && !isQueenCard(card) && card.Rank > maxCard.Rank)
{
playingCard = card; // если ходим последними и забираем, то сбрасываем самую большую карту
}
}
}
}
if (playingCard == null) // если нужной масти нет, то в первую очередь сбрасываем даму
{
for (int i = 0; i < deck.Count; i++)
{
card = deck[i] as CardVO;
if (isQueenCard(card))
{
playingCard = card;
}
}
}
if (playingCard == null)
{
playingCard = sortCardsByDecrease(deck)[deck.Count - 1] as CardVO; // если нужной масти не найдено, ходим самой большой из тех, что есть
}
}
return(playingCard);
}
public static CardVO getCardForPlay(ArrayList deck)
{
CardVO playingCard = null;
if (GameModel.inst.cardsOnDeck.Count == 0)
{
for (int k = 0; k < deck.Count; k++)
{
CardVO card = deck[k] as CardVO;
if (playingCard == null)
{
playingCard = card;
}
else
{
if (card.Rank < playingCard.Rank) // отдаем самую меншьую карту
{
playingCard = card;
}
}
}
}
else
{
CardVO maxCard = GameModel.inst.cardsOnDeck[0] as CardVO;
for (int m = 0; m < GameModel.inst.cardsOnDeck.Count; m++) // находим самую сильную играющую карту
{
CardVO card = GameModel.inst.cardsOnDeck[m] as CardVO;
if (card.Suit == maxCard.Suit && card.Rank > maxCard.Rank)
{
maxCard = card;
}
}
for (int i = 0; i < deck.Count; i++)
{
CardVO card = deck[i] as CardVO;
if (card.Suit == maxCard.Suit)
{
if (playingCard == null)
{
playingCard = card;
}
else
{
if (card.Rank < maxCard.Rank)
{
if (playingCard.Rank > maxCard.Rank && card.Rank > playingCard.Rank) // если меньших нет, то отдаем самую крупную карту
{
playingCard = card;
}
if (card.Rank > playingCard.Rank) // если больше текущей, то отдаем ее
{
playingCard = card;
}
if (playingCard.Rank > maxCard.Rank) // если текущая карта той же масти, но больше максимальной, то берем ту что помешье
{
playingCard = card;
}
}
else
{
if (card.Rank < playingCard.Rank) // если больше максимальной, но меньше текущей
{
playingCard = card;
}
}
}
}
}
if (playingCard == null) // карт той же масти не нашлось
{
for (int j = 0; j < deck.Count; j++)
{
CardVO card = deck[j] as CardVO;
if (playingCard == null)
{
playingCard = card;
}
else
{
if (card.Rank > playingCard.Rank) // отдаем самую крупную карту
{
playingCard = card;
}
}
}
}
}
return(playingCard);
}
public void execute()
{
CardVO playingCard = CardStrategy.getCardForPlay(GameModel.inst.currentPlayer.Deck);
AnimationHelper.makeTurn(playingCard);
}
public static CardVO getCardForPlay(ArrayList deck)
{
CardVO playingCard = null;
CardVO card;
if (GameModel.inst.cardsOnDeck.Count == 0)
{
int i;
ArrayList sortedDeck = sortCardsByDecrease(deck);
for (i = 0; i < sortedDeck.Count; i++)
{
card = sortedDeck[i] as CardVO;
if (card.Suit != Config.HEARTS_SUIT)
{
playingCard = card;
break;
}
}
if (playingCard == null)
{
playingCard = sortedDeck[0] as CardVO;
}
}
else
{
CardVO maxCard = getMaxCard();
for (int a = 0; a < deck.Count; a++)
{
card = deck[a] as CardVO;
if (card.Suit == maxCard.Suit)
{
if (playingCard == null)
{
playingCard = card; // первая карта такой масти
}
else
{
if (card.Rank < maxCard.Rank)
{
if (card.Rank > playingCard.Rank) // если больше текущей, то отдаем ее
{
playingCard = card;
}
if (playingCard.Rank > maxCard.Rank) // если текущая карта той же масти, но больше максимальной, то берем ту что помешье
{
playingCard = card;
}
}
}
}
}
if (playingCard == null)
{
for (int j = 0; j < deck.Count; j++)
{
card = deck[j] as CardVO;
if (card.Rank == Config.KING_RANK && card.Suit == Config.HEARTS_SUIT) // если в колоде есть Кинг, то обязательно сбрасываем его
{
playingCard = card;
break;
}
}
}
if (playingCard == null)
{
playingCard = sortCardsByDecrease(deck)[deck.Count - 1] as CardVO; // если нужной масти не найдено, ходим самой большой из тех, что есть
}
}
return(playingCard);
}
static protected bool isQueenCard(CardVO card)
{
return(card.Rank == Config.QUEEN_RANK);
}
static protected bool isJackOrKing(CardVO card)
{
return(card.Rank == Config.JACK_RANK || card.Rank == Config.KING_RANK);
}
public static CardVO getCardForPlay(ArrayList deck)
{
CardVO playingCard = null;
if (GameModel.inst.cardsOnDeck.Count == 0)
{
playingCard = sortCardsByDecrease(deck)[0] as CardVO;
}
else
{
CardVO maxCard = GameModel.inst.cardsOnDeck[0] as CardVO;
CardVO card;
for (int m = 0; m < GameModel.inst.cardsOnDeck.Count; m++) // находим самую сильную играющую карту
{
card = GameModel.inst.cardsOnDeck[m] as CardVO;
if (card.Suit == maxCard.Suit && card.Rank > maxCard.Rank)
{
maxCard = card;
}
}
for (int a = 0; a < deck.Count; a++)
{
card = deck[a] as CardVO;
if (card.Suit == maxCard.Suit)
{
if (playingCard == null)
{
playingCard = card; // первая карта такой масти
}
else
{
if (playingCard.Rank > maxCard.Rank && isJackOrKing(playingCard) && !isJackOrKing(card))
{
playingCard = card; // заменяем короля или вальта, если это возможно
}
if (card.Rank < maxCard.Rank)
{
if (!isJackOrKing(playingCard))
{
playingCard = card;
}
else
{
if (card.Rank == Config.KING_RANK)
{
playingCard = card;
}
}
}
if (GameModel.inst.cardsOnDeck.Count == 3 && playingCard.Rank > maxCard.Rank && !isJackOrKing(card) && card.Rank > maxCard.Rank)
{
playingCard = card;
}
}
}
}
if (playingCard == null) // если нужной масти нет, то в первую очередь сбрасываем короля или валета
{
for (int i = 0; i < deck.Count; i++)
{
card = deck[i] as CardVO;
if (card.Rank == Config.JACK_RANK)
{
playingCard = card;
}
if (card.Rank == Config.KING_RANK) // короля сбрасываем в первую очередь
{
playingCard = card;
}
}
}
if (playingCard == null)
{
playingCard = sortCardsByDecrease(deck)[deck.Count - 1] as CardVO; // если нужной масти не найдено, ходим самой большой из тех, что есть
}
}
return(playingCard);
}
void endRound()
{
PlayerVO grabber;
CardVO maxCard = GameModel.inst.cardsOnDeck[0] as CardVO;
string[] goals = new string[4];
for (int i = 0; i < GameModel.inst.cardsOnDeck.Count; i++)
{
CardVO currentCard = GameModel.inst.cardsOnDeck[i] as CardVO;
string goalType = currentCard.Suit + "_" + currentCard.Rank;
Debug.Log("num card " + i + " card " + goalType);
goals[i] = goalType;
if (maxCard.Suit == currentCard.Suit && currentCard.Rank > maxCard.Rank)
{
maxCard = GameModel.inst.cardsOnDeck[i] as CardVO;
}
}
grabber = maxCard.Owner;
// Count results
int numIndex;
numIndex = Array.IndexOf(GameModel.inst.level.Goals, RuleModel.GOAL_TRICK);
if (numIndex > -1)
{
grabber.Goals.Add(RuleModel.GOAL_TRICK);
grabber.LevelScore += GameModel.inst.level.GoalCost;
grabber.Score += GameModel.inst.level.GoalCost;
GameModel.inst.level.Goals = GameModel.inst.level.Goals.Where((val, idx) => idx != numIndex).ToArray();
}
for (int j = 0; j < goals.Length; j++)
{
numIndex = Array.IndexOf(GameModel.inst.level.Goals, goals[j]);
if (numIndex > -1)
{
grabber.Goals.Add(goals[j]);
grabber.LevelScore += GameModel.inst.level.GoalCost;
grabber.Score += GameModel.inst.level.GoalCost;
GameModel.inst.level.Goals = GameModel.inst.level.Goals.Where((val, idx) => idx != numIndex).ToArray();
}
}
// check last tricks
numIndex = Array.IndexOf(GameModel.inst.level.Goals, RuleModel.TRICK_7);
if (grabber.Deck.Count == 2 && numIndex > -1)
{
grabber.Goals.Add(RuleModel.TRICK_7);
grabber.LevelScore += GameModel.inst.level.GoalCost;
grabber.Score += GameModel.inst.level.GoalCost;
GameModel.inst.level.Goals = GameModel.inst.level.Goals.Where((val, idx) => idx != numIndex).ToArray();
}
numIndex = Array.IndexOf(GameModel.inst.level.Goals, RuleModel.TRICK_8);
if (grabber.Deck.Count == 1 && numIndex > -1)
{
grabber.Goals.Add(RuleModel.TRICK_8);
grabber.LevelScore += GameModel.inst.level.GoalCost;
grabber.Score += GameModel.inst.level.GoalCost;
GameModel.inst.level.Goals = GameModel.inst.level.Goals.Where((val, idx) => idx != numIndex).ToArray();
}
// all rules together
numIndex = Array.IndexOf(GameModel.inst.level.Goals, RuleModel.ANY);
if (numIndex > -1)
{
int scoreForAdd;
grabber.Goals.Add(goals);
GameModel.inst.level.Goals = GameModel.inst.level.Goals.Where((val, idx) => idx != numIndex).ToArray();
// обычная взятка
scoreForAdd = GameModel.inst.LevelsData[0].GoalCost;
if (!GameModel.inst.level.isNegative)
{
scoreForAdd = -scoreForAdd;
}
grabber.LevelScore += scoreForAdd;
grabber.Score += scoreForAdd;
// check last tricks
if (grabber.Deck.Count <= 2)
{
scoreForAdd = GameModel.inst.LevelsData[4].GoalCost;
if (!GameModel.inst.level.isNegative)
{
scoreForAdd = -scoreForAdd;
}
grabber.LevelScore += scoreForAdd;
grabber.Score += scoreForAdd;
}
for (int a = 0; a < goals.Length; a++)
{
for (int b = 1; b < 7; b++)
{
numIndex = Array.IndexOf(GameModel.inst.LevelsDataForCount[b].Goals, goals[a]);
if (numIndex > -1)
{
scoreForAdd = GameModel.inst.LevelsDataForCount[b].GoalCost;
if (!GameModel.inst.level.isNegative)
{
scoreForAdd = -scoreForAdd;
}
grabber.LevelScore += scoreForAdd;
grabber.Score += scoreForAdd;
}
}
}
}
GameModel.inst.currentPlayer = grabber;
Debug.Log("max card " + maxCard.Id + " grabber " + grabber.Id + " left cards " + grabber.Deck.Count);
AnimationHelper.grabCards(grabber);
}
static protected bool isKingCard(CardVO card)
{
return(card.Rank == Config.KING_RANK && card.Suit == Config.HEARTS_SUIT);
}
public static CardVO getCardForPlay(ArrayList deck)
{
CardVO playingCard = null;
CardVO playingHeartCard = null;
if (GameModel.inst.cardsOnDeck.Count == 0)
{
for (int k = 0; k < deck.Count; k++)
{
CardVO card = deck[k] as CardVO;
if (card.Suit != Config.HEARTS_SUIT)
{
if (playingCard == null)
{
playingCard = card;
}
else
{
if (card.Rank < playingCard.Rank) // отдаем самую меншьую карту
{
playingCard = card;
}
}
}
else
{
if (playingHeartCard == null)
{
playingHeartCard = card;
}
else
{
if (card.Rank < playingHeartCard.Rank) // отдаем самую меншьую карту
{
playingHeartCard = card;
}
}
}
}
if (playingCard == null)
{
playingCard = playingHeartCard; // если нет никаких других карт, то ходим с чирвы
}
}
else
{
CardVO maxCard = getMaxCard();
CardVO card;
for (int a = 0; a < deck.Count; a++)
{
card = deck[a] as CardVO;
if (card.Suit == maxCard.Suit)
{
if (playingCard == null)
{
playingCard = card; // первая карта такой масти
}
else
{
if (card.Rank < maxCard.Rank)
{
if (card.Rank > playingCard.Rank) // если больше текущей, то отдаем ее
{
playingCard = card;
}
if (playingCard.Rank > maxCard.Rank) // если текущая карта той же масти, но больше максимальной, то берем ту что помешье
{
playingCard = card;
}
}
else
{
if (card.Rank < playingCard.Rank) // если больше максимальной, но меньше текущей
{
playingCard = card;
}
}
if (GameModel.inst.cardsOnDeck.Count == 3 && playingCard.Rank > maxCard.Rank && card.Rank > playingCard.Rank)
{
playingCard = card; // если ходим последними и забираем, то сбрасываем самую большую карту
}
}
}
}
if (playingCard == null)
{
for (int j = 0; j < deck.Count; j++)
{
card = deck[j] as CardVO;
if (card.Rank == Config.KING_RANK && card.Suit == Config.HEARTS_SUIT) // если в колоде есть Кинг, то обязательно сбрасываем его
{
playingCard = card;
break;
}
}
}
if (playingCard == null)
{
playingCard = sortCardsByDecrease(deck)[deck.Count - 1] as CardVO; // если нужной масти не найдено, ходим самой большой из тех, что есть
}
}
return(playingCard);
}
public static CardVO getCardByHeartsLogic(ArrayList deck)
{
CardVO playingCard = null;
CardVO smallestPlayingCard = null;
CardVO card;
ArrayList sorted = sortCardsByDecrease(deck);
if (isFirstTurn)
{
for (int i = 0; i < sorted.Count; i++)
{
card = sorted[i] as CardVO;
if (card.Suit != Config.HEARTS_SUIT)
{
playingCard = card; // ходим с самой меньшей карты, но не чирвы
break;
}
}
if (playingCard == null)
{
playingCard = sorted[sorted.Count - 1] as CardVO;
if (!checkNoMoreBigger(playingCard)) // если это самая крупная чирва, ходим с нее, если нет, то сбрасываем самую маленькую
{
playingCard = sorted[0] as CardVO;
}
}
}
else
{
CardVO maxCard = getMaxCard();
bool hasHearts = false;
for (int j = 0; j < GameModel.inst.cardsOnDeck.Count; j++)
{
card = GameModel.inst.cardsOnDeck[j] as CardVO;
if (card.Suit == Config.HEARTS_SUIT)
{
hasHearts = true;
break;
}
}
for (int a = 0; a < sorted.Count; a++)
{
card = sorted[a] as CardVO;
if (hasHearts)
{
if (card.Suit == maxCard.Suit && card.Rank > maxCard.Rank && checkNoMoreBigger(card)) // карта той же масти, и больше нее в игре сейчас нет
{
playingCard = card;
break;
}
if (isLastTurn && card.Rank > maxCard.Rank) // мы ходим последними, поэтому достаточно чтоб карта была больше максимальной
{
playingCard = card;
break;
}
}
else
{
if (card.Suit == maxCard.Suit)
{
playingCard = card;
break;
}
}
if (smallestPlayingCard == null && card.Suit == maxCard.Suit)
{
smallestPlayingCard = card;
}
}
if (smallestPlayingCard == null)
{
smallestPlayingCard = sorted[0] as CardVO;
for (int b = 0; b < sorted.Count; b++)
{
card = sorted[b] as CardVO;
if (card.Suit != Config.HEARTS_SUIT)
{
smallestPlayingCard = card;
break;
}
}
}
if (playingCard == null)
{
playingCard = smallestPlayingCard; // если карты не найдено, ходим самой меньшей
}
}
return(playingCard);
}
public static CardVO getCardByTakeAllLogic(ArrayList deck)
{
CardVO playingCard = null;
CardVO card = null;
CardVO kingCard = null;
CardVO smallestPlayingCard = null;
ArrayList sorted = sortCardsByDecrease(deck);
if (isFirstTurn)
{
for (int i = 0; i < sorted.Count; i++)
{
card = sorted[i] as CardVO;
if (card.Suit != Config.HEARTS_SUIT)
{
if (checkNoMoreBigger(card))
{
playingCard = card;
}
if (smallestPlayingCard == null || smallestPlayingCard.Suit == Config.HEARTS_SUIT)
{
smallestPlayingCard = card;
}
}
else
{
if (smallestPlayingCard == null && !isKingCard(card))
{
smallestPlayingCard = card;
}
if (isKingCard(card) && checkNoMoreBigger(card))
{
smallestPlayingCard = card;
}
}
}
if (playingCard == null)
{
if (smallestPlayingCard == null)
{
playingCard = sorted[0] as CardVO;
}
else
{
playingCard = smallestPlayingCard;
}
}
}
else
{
CardVO maxCard = getMaxCard();
for (int a = 0; a < sorted.Count; a++)
{
card = sorted[a] as CardVO;
if (isKingCard(card))
{
kingCard = card;
}
if (card.Suit == maxCard.Suit)
{
if (playingCard == null)
{
playingCard = card; // первая карта такой масти
}
else
{
if (card.Rank > maxCard.Rank && checkNoMoreBigger(card))
{
playingCard = card;
}
if (isLastTurn && card.Rank > maxCard.Rank)
{
if (card.Rank < playingCard.Rank || playingCard.Rank < maxCard.Rank)
{
playingCard = card; // если ходим последними, то все равно забираем
}
}
}
}
if (smallestPlayingCard == null && !isKingCard(card))
{
smallestPlayingCard = card;
}
}
if (smallestPlayingCard == null)
{
smallestPlayingCard = sorted[0] as CardVO;
}
if (playingCard == null)
{
if (kingCard == null)
{
playingCard = smallestPlayingCard;
}
else
{
playingCard = kingCard;
}
}
}
return(playingCard);
}
public static CardVO getCardByKingLogic(ArrayList deck)
{
CardVO playingCard = null;
CardVO card = null;
CardVO kingCard = null;
CardVO smallestPlayingCard = null;
ArrayList sorted = sortCardsByDecrease(deck);
if (isFirstTurn)
{
for (int i = 0; i < sorted.Count; i++)
{
card = sorted[i] as CardVO;
if (card.Suit != Config.HEARTS_SUIT)
{
playingCard = card;
break;
}
else
{
if (smallestPlayingCard == null && !isKingCard(card))
{
smallestPlayingCard = card;
}
if (isKingCard(card) && checkNoMoreBigger(card))
{
smallestPlayingCard = card;
}
}
}
if (playingCard == null)
{
if (smallestPlayingCard == null)
{
playingCard = sorted[0] as CardVO;
}
else
{
playingCard = smallestPlayingCard;
}
}
}
else
{
CardVO maxCard = getMaxCard();
bool hasKing = false;
for (int j = 0; j < GameModel.inst.cardsOnDeck.Count; j++)
{
card = GameModel.inst.cardsOnDeck[j] as CardVO;
if (isKingCard(card))
{
hasKing = true;
break;
}
}
for (int j = 0; j < sorted.Count; j++)
{
card = sorted[j] as CardVO;
if (card.Suit == maxCard.Suit)
{
if (playingCard == null)
{
playingCard = card;
}
if (hasKing)
{
if ((isLastTurn && card.Rank > maxCard.Rank) || checkNoMoreBigger(card))
{
playingCard = card;
}
}
}
if (smallestPlayingCard == null && !isKingCard(card))
{
smallestPlayingCard = card;
}
if (isKingCard(card))
{
kingCard = card;
}
}
if (smallestPlayingCard == null)
{
smallestPlayingCard = sorted[0] as CardVO;
}
if (playingCard == null)
{
if (kingCard == null)
{
playingCard = smallestPlayingCard;
}
else
{
playingCard = kingCard;
}
}
}
return(playingCard);
}
public static CardVO getCardForPlay(ArrayList deck)
{
CardVO playingCard = null;
if (GameModel.inst.cardsOnDeck.Count == 0)
{
if (isLastTricks(deck)) // если это не последний ход, то ходим самой большой картой
{
playingCard = sortCardsByDecrease(deck)[0] as CardVO;
}
else
{
playingCard = sortCardsByDecrease(deck)[deck.Count - 1] as CardVO;
}
}
else
{
CardVO maxCard = getMaxCard();
CardVO card;
for (int a = 0; a < deck.Count; a++)
{
card = deck[a] as CardVO;
if (card.Suit == maxCard.Suit)
{
if (playingCard == null)
{
playingCard = card; // первая карта такой масти
}
else
{
if (isLastTricks(deck))
{
if (card.Rank < maxCard.Rank && playingCard.Rank < card.Rank)
{
playingCard = card;
}
}
else
{
if (card.Rank > playingCard.Rank)
{
playingCard = card;
}
}
if (GameModel.inst.cardsOnDeck.Count == 3 && playingCard.Rank > maxCard.Rank && card.Rank > playingCard.Rank)
{
playingCard = card; // если ходим последними и забираем, то сбрасываем самую большую карту
}
}
}
}
if (playingCard == null)
{
playingCard = sortCardsByDecrease(deck)[deck.Count - 1] as CardVO; // если нужной масти не найдено, ходим самой большой из тех, что есть
}
}
return(playingCard);
}
public static CardVO getCardByBoysLogic(ArrayList deck)
{
CardVO playingCard = null;
CardVO card = null;
CardVO smallestPlayingCard = null;
ArrayList sorted = sortCardsByDecrease(deck);
if (isFirstTurn)
{
playingCard = sorted[sorted.Count - 1] as CardVO;
if (!checkNoMoreBigger(playingCard)) // если в игре есть карты больше, то ходим с самой маленькой
{
playingCard = sorted[0] as CardVO;
}
}
else
{
CardVO maxCard = getMaxCard();
bool hasBoys = false;
for (int j = 0; j < GameModel.inst.cardsOnDeck.Count; j++)
{
card = GameModel.inst.cardsOnDeck[j] as CardVO;
if (isJackOrKing(card))
{
hasBoys = true;
break;
}
}
for (int a = 0; a < sorted.Count; a++)
{
card = sorted[a] as CardVO;
if (hasBoys)
{
if (card.Suit == maxCard.Suit && card.Rank > maxCard.Rank && checkNoMoreBigger(card)) // карта той же масти, и больше нее в игре сейчас нет
{
playingCard = card;
break;
}
if (isLastTurn && card.Rank > maxCard.Rank) // мы ходим последними, поэтому достаточно чтоб карта была больше максимальной
{
playingCard = card;
break;
}
}
else
{
if (card.Suit == maxCard.Suit)
{
playingCard = card;
break;
}
}
if (smallestPlayingCard == null && card.Suit == maxCard.Suit)
{
smallestPlayingCard = card;
}
}
if (smallestPlayingCard == null)
{
smallestPlayingCard = sorted[0] as CardVO;
for (int b = 0; b < sorted.Count; b++)
{
card = sorted[b] as CardVO;
if (!isJackOrKing(card))
{
smallestPlayingCard = card;
break;
}
}
}
if (playingCard == null)
{
playingCard = smallestPlayingCard; // если карты не найдено, ходим самой меньшей
}
}
return(playingCard);
}
