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); }