bool Action1(CardActionParameters parameters)
{
ValidateParameters(parameters);
//Score your top green card.
var topGreenCard = parameters.TargetPlayer.Tableau.Stacks[Color.Green].GetTopCard();
if (topGreenCard != null)
{
Score.Action(topGreenCard, parameters.TargetPlayer);
parameters.TargetPlayer.Tableau.Stacks[Color.Green].RemoveCard(topGreenCard);
}
//Draw and meld a [10]
var drawnCard = Draw.Action(10, parameters.Game);
if (drawnCard == null)
{
return(true);
}
Meld.Action(drawnCard, parameters.TargetPlayer);
foreach (var cardAction in drawnCard.Actions)
{
if (cardAction.ActionType != ActionType.Demand)
{
cardAction.ActionHandler(new CardActionParameters {
ActivePlayer = parameters.TargetPlayer, TargetPlayer = parameters.TargetPlayer, Game = parameters.Game, PlayerSymbolCounts = parameters.PlayerSymbolCounts
});
}
}
return(true);
}
public void TestMeldsEqualEmpty()
{
Meld meldA = new Meld();
Meld meldB = new Meld();
Assert.IsTrue(meldA.Equals(meldB));
}
public static List <Meld> GetKongableMelds(IEnumerable <Tile> tiles, Tile lastDraw)
{
var output = new List <Meld>();
var list = tiles.ToList();
list.Add(lastDraw);
list = list.OrderBy(q => q.Suit).ThenBy(q => q.Rank).ToList();
foreach (var item in list.Distinct())
{
var count = list.Count(q => q.Equals(item));
if (count == 4)
{
var meld = new Meld(new List <Tile>
{
item,
item,
item,
item
}, MeldType.Kong, lastDraw.Equals(item)? item: null);
output.Add(meld);
}
}
return(output);
}
public void Meld_PlayerDoesNotHaveAllCards()
{
var cards = new[]
{
new Card(1, Suit.Clubs),
new Card(1, Suit.Diamonds),
new Card(3, Suit.Diamonds),
new Card(1, Suit.Spades),
new Card(12, Suit.Diamonds),
new Card(12, Suit.Hearts),
new Card(12, Suit.Clubs),
new Card(3, Suit.Spades),
new Card(9, Suit.Spades),
new Card(8, Suit.Spades),
};
GameState gs =
CreateGamesStateWithPlayerOneHaving(cards, State.Player1Draw);
gs.DrawCard(Player.One, PileName.Stock);
var m = new Meld(new[] { Suit.Clubs, Suit.Diamonds, Suit.Hearts }, 9);
Assert.That(() => gs.Meld(Player.One, m), Throws.ArgumentException);
Assert.AreEqual(gs.CurrentError, ErrorMessage.NotPlayerCard);
}
private bool Action1(CardActionParameters parameters)
{
ValidateParameters(parameters);
if (parameters.TargetPlayer.Hand.Count < 3)
{
return(false);
}
List <ICard> cardsToReturn = parameters.TargetPlayer.PickMultipleCards(parameters.TargetPlayer.Hand, 3, 3).ToList();
if (cardsToReturn.Count == 0)
{
return(false);
}
foreach (ICard card in cardsToReturn)
{
parameters.TargetPlayer.Hand.Remove(card);
Return.Action(card, parameters.Game);
}
Meld.Action(Draw.Action(3, parameters.Game), parameters.TargetPlayer);
return(true);
}
public void TestEquals()
{
IList <Suit> lSuit = new List <Suit>();
lSuit.Add(Suit.Diamonds);
lSuit.Add(Suit.Clubs);
lSuit.Add(Suit.Hearts);
Meld meld1 = new Meld(lSuit, 8);
IList <Suit> lSuit2 = new List <Suit>();
lSuit2.Add(Suit.Diamonds);
lSuit2.Add(Suit.Hearts);
lSuit2.Add(Suit.Clubs);
Meld meld2 = new Meld(lSuit2, 8);
Meld meld3 = new Meld(lSuit2, 2);
var m1 = new MeldMove(Player.One, meld1);
var m2 = new MeldMove(Player.Two, meld1);
var m3 = new MeldMove(Player.One, meld2);
var m4 = new MeldMove(Player.Two, meld3);
Assert.True(m1.Equals(m1));
Assert.True(m1.Equals(m3));
Assert.True(m3.Equals(m1));
Assert.False(m1.Equals(null));
Assert.False(m1.Equals(m2));
Assert.False(m4.Equals(m3));
Assert.False(m4.Equals(m3));
}
public void TestDoMeldsOverlapNegativeEmpty()
{
Meld meldA = new Meld();
Meld meldB = new Meld();
Assert.IsFalse(meldA.DoesOverlap(meldB));
}
public void Meld_Player1MeldGetCard()
{
var cards = new[]
{
new Card(1, Suit.Clubs),
new Card(1, Suit.Diamonds),
new Card(3, Suit.Diamonds),
new Card(1, Suit.Spades),
new Card(12, Suit.Diamonds),
new Card(12, Suit.Hearts),
new Card(12, Suit.Clubs),
new Card(3, Suit.Spades),
new Card(9, Suit.Spades),
new Card(8, Suit.Spades),
};
GameState gs =
CreateGamesStateWithPlayerOneHaving(cards, State.Player1Draw);
gs.DrawCard(Player.One, PileName.Stock);
Meld m = new Meld(new[] { Suit.Clubs, Suit.Diamonds, Suit.Spades }, 1);
Assert.AreEqual(gs.Player1Melds.Count, 0);
gs.Meld(Player.One, m);
Assert.AreEqual(gs.Player1Melds.Count, 1);
}
public List <Meld> GetAllPossibleMelds(List <Card> cards)
{
var melds = new List <Meld>();
int count = (int)Math.Pow(2, cards.Count);
for (int i = 1; i <= count - 1; i++)
{
string bitMask = Convert.ToString(i, 2).PadLeft(cards.Count, '0');
Meld nextMeld = new Meld();
for (int j = 0; j < bitMask.Length; j++)
{
if (bitMask[j] == '1')
{
nextMeld.AddCard(cards[j]);
}
}
if (IsValid(nextMeld))
{
melds.Add(nextMeld);
}
}
return(melds);
}
public void TestGetBestMeldSet()
{
Hand hand = new Hand();
hand.AddCard(new Card("As"));
hand.AddCard(new Card("2s"));
hand.AddCard(new Card("3s"));
hand.AddCard(new Card("3d"));
hand.AddCard(new Card("Ks"));
hand.AddCard(new Card("3c"));
hand.AddCard(new Card("Qs"));
hand.AddCard(new Card("Qc"));
hand.AddCard(new Card("Qd"));
var meldSet = new List <Meld>();
Meld meldA = new Meld();
meldA.AddCard(new Card("Qs"));
meldA.AddCard(new Card("Qc"));
meldA.AddCard(new Card("Qd"));
meldSet.Add(meldA);
Meld meldB = new Meld();
meldB.AddCard(new Card("3c"));
meldB.AddCard(new Card("3d"));
meldB.AddCard(new Card("3s"));
meldSet.Add(meldB);
var bestMeldSet = _checker.GetBestMeldSet(hand);
Assert.IsTrue(bestMeldSet.Except(meldSet, new MeldEqualityComparerDefault()).Count() == 0 && meldSet.Except(bestMeldSet, new MeldEqualityComparerDefault()).Count() == 0);
}
public void MyHandHasTwoPossibleLayOff_GiveMeThatLayOffsAndTheDiscardMoves()
{
var cards = new[]
{
new Card(6, Suit.Clubs),
new Card(10, Suit.Clubs),
new Card(12, Suit.Spades)
};
List <Meld> playerOneMelds = new List <Meld>();
Meld m = new Meld(Suit.Clubs, 7, 3);
playerOneMelds.Add(m);
GameState gs = CreateGamesStateWithPlayerOneHavingCardsAndMelds(cards, playerOneMelds, State.Player1MeldLayDiscard);
var pa = new PossibleMoves(Player.One, gs);
var moves = pa.Moves();
Assert.AreEqual(5, moves.Count);
CollectionAssert.Contains(moves,
new LayOffMove(Player.One, new Card(10, Suit.Clubs), m));
CollectionAssert.Contains(moves,
new LayOffMove(Player.One, new Card(6, Suit.Clubs), m));
}
public void AddCard_ConsecutiveRank_NotConsecutive_ThrowException()
{
Meld m = new Meld(Suit.Spades, 5, 3);
Card c = new Card(2, Suit.Spades);
Assert.IsFalse(m.CanAddACard(c));
}
public void TestGetDeadWoodTwoMelds()
{
var cards = new List <Card>();
cards.Add(new Card("As"));
cards.Add(new Card("Qh"));
cards.Add(new Card("5d"));
cards.Add(new Card("6d"));
cards.Add(new Card("7d"));
cards.Add(new Card("7c"));
cards.Add(new Card("Tc"));
cards.Add(new Card("Jc"));
cards.Add(new Card("Qc"));
var meldSet = new List <Meld>();
Meld meldA = new Meld();
meldA.AddCard(new Card("5d"));
meldA.AddCard(new Card("6d"));
meldA.AddCard(new Card("7d"));
meldSet.Add(meldA);
Meld meldB = new Meld();
meldB.AddCard(new Card("Tc"));
meldB.AddCard(new Card("Jc"));
meldB.AddCard(new Card("Qc"));
meldSet.Add(meldB);
Assert.AreEqual(3, _checker.GetDeadWood(meldSet, cards).Count);
}
public void AddCard_ConsecutiveRank_DifferentSuit_ThrowException()
{
Meld m = new Meld(Suit.Spades, 5, 3);
Card c = new Card(4, Suit.Clubs);
Assert.IsFalse(m.CanAddACard(c));
}
public void Meld_StateDoesNotChange()
{
var cards = new[]
{
new Card(1, Suit.Clubs),
new Card(1, Suit.Diamonds),
new Card(3, Suit.Diamonds),
new Card(1, Suit.Spades),
new Card(12, Suit.Diamonds),
new Card(12, Suit.Hearts),
new Card(12, Suit.Clubs),
new Card(3, Suit.Spades),
new Card(9, Suit.Spades),
new Card(8, Suit.Spades),
};
GameState gs =
CreateGamesStateWithPlayerOneHaving(cards, State.Player1Draw);
gs.DrawCard(Player.One, PileName.Stock);
Meld m = new Meld(new[] { Suit.Clubs, Suit.Diamonds, Suit.Spades }, 1);
gs.Meld(Player.One, m);
Assert.AreEqual(State.Player1MeldLayDiscard, gs.CurrentState);
}
public void Meld_PlayerLoseCard()
{
var cards = new[]
{
new Card(1, Suit.Clubs),
new Card(1, Suit.Diamonds),
new Card(3, Suit.Diamonds),
new Card(1, Suit.Spades),
new Card(12, Suit.Diamonds),
new Card(12, Suit.Hearts),
new Card(12, Suit.Clubs),
new Card(3, Suit.Spades),
new Card(9, Suit.Spades),
new Card(8, Suit.Spades),
};
GameState gs =
CreateGamesStateWithPlayerOneHaving(cards, State.Player1Draw);
gs.DrawCard(Player.One, PileName.Stock);
int playerCardBeforeLayOff = gs.Player1Cards.Count;
Meld m = new Meld(new[] { Suit.Clubs, Suit.Diamonds, Suit.Spades }, 1);
gs.Meld(Player.One, m);
Assert.AreEqual(playerCardBeforeLayOff - 3, gs.Player1Cards.Count);
CollectionAssert.DoesNotContain(gs.Player1Cards, new Card(1, Suit.Clubs));
CollectionAssert.DoesNotContain(gs.Player1Cards, new Card(1, Suit.Diamonds));
CollectionAssert.DoesNotContain(gs.Player1Cards, new Card(1, Suit.Spades));
Assert.AreEqual(gs.CurrentError, ErrorMessage.NoError);
}
public void LayOff_InvalidCombinations_ThrowException()
{
var cards = new[]
{
new Card(1, Suit.Clubs),
new Card(1, Suit.Diamonds),
new Card(3, Suit.Diamonds),
new Card(1, Suit.Spades),
new Card(12, Suit.Diamonds),
new Card(12, Suit.Hearts),
new Card(12, Suit.Clubs),
new Card(3, Suit.Spades),
new Card(4, Suit.Diamonds),
new Card(8, Suit.Spades),
};
GameState gs =
CreateGamesStateWithPlayerOneHaving(cards, State.Player1Draw);
gs.DrawCard(Player.One, PileName.Stock);
Meld m = new Meld(Suit.Diamonds, 5, 3);
Assert.That(() => gs.LayOff(Player.One, new Card(1, Suit.Diamonds), m), Throws.ArgumentException);
Assert.AreEqual(gs.CurrentError, ErrorMessage.InvalidLayoff);
Assert.AreNotEqual(gs.CurrentError, ErrorMessage.InvalidMeld);
}
private bool Action1(CardActionParameters parameters)
{
ValidateParameters(parameters);
var cardsWithTowers = parameters.TargetPlayer.Hand.Where(c => c.HasSymbol(Symbol.Tower)).ToList();
if (cardsWithTowers.Count == 0)
{
return(false);
}
var selectedCards = parameters.TargetPlayer.PickMultipleCards(cardsWithTowers, 0, cardsWithTowers.Count).ToList();
foreach (var card in selectedCards)
{
parameters.TargetPlayer.Hand.Remove(card);
Meld.Action(card, parameters.TargetPlayer);
}
if (selectedCards.Count > 4)
{
throw new NotImplementedException("Monument Achievement"); // TODO::achieve Monument. Special achievements need a larger framework and some discussion
}
return(selectedCards.Count > 0);
}
public void LayOff_ValidateCardMovement()
{
var cards = new[]
{
new Card(6, Suit.Clubs),
new Card(2, Suit.Clubs),
new Card(12, Suit.Spades)
};
Meld m = new Meld(Suit.Clubs, 7, 3);
GameState gs = CreateGamesStateWithPlayerOneHaving(cards, State.Player1MeldLayDiscard);
int playerCardBeforeLayOff = gs.Player1Cards.Count;
gs.LayOff(Player.One, new Card(6, Suit.Clubs), m);
Assert.AreEqual(playerCardBeforeLayOff - 1, gs.Player1Cards.Count);
//meld contains that card
CollectionAssert.Contains(m, new Card(6, Suit.Clubs));
//player no longer has that card
CollectionAssert.DoesNotContain(gs.Player1Cards, new Card(6, Suit.Clubs));
Assert.AreEqual(gs.CurrentError, ErrorMessage.NoError);
}
/// <summary>
/// Khi có người chơi gửi phỏm
/// </summary>
/// <param name="index">Người gửi phỏm</param>
/// <param name="indexTo">Gửi phỏm đến người chơi</param>
/// <param name="cardValue">Card sẽ gửi</param>
/// <param name="melds">Phỏm ké gửi vào</param>
public static void AddMeld(int index, int indexTo, int cardValue, int[] melds)
{
Meld meld = GetPlayer(indexTo).GetMeld(melds);
if (meld != null)
{
ECard card = GetCard_FromHandPlayer(index, cardValue);
GetPlayer(index).mCardHand.Remove(card);
meld.meld.Add(card);
game.UpdateHand(index, 0.5f);
game.UpdateHand(indexTo, 0.5f);
CheckRemoveGiveCard(index);
card.UpdateParent(indexTo);
return;
}
if (YourController.slotServer == index)
{
game.canRequestSort = true;
}
Debug.Log(index);
Debug.Log(indexTo);
foreach (Meld m in GameModelTLMN.GetPlayer(indexTo).mCardMelds)
{
Debug.Log(m.meld);
}
Debug.Log(cardValue);
Debug.Log(melds);
Debug.LogError("LỖI: Không thể tìm thấy phỏm để gửi");
}
public void AddCard_ConsecutiveRank()
{
Meld m = new Meld(Suit.Spades, 5, 3);
Card c = new Card(4, Suit.Spades);
Assert.IsTrue(m.CanAddACard(c));
}
public void MeldAction_Base()
{
Meld.Action(testCard, testPlayer);
Assert.AreEqual(testCard, testPlayer.Tableau.Stacks[Color.Blue].GetTopCard());
Assert.AreEqual(6, testPlayer.Tableau.GetSymbolCount(Symbol.Tower));
Assert.AreEqual(0, testPlayer.Tableau.GetSymbolCount(Symbol.Leaf));
}
private bool Action1(CardActionParameters parameters)
{
ValidateParameters(parameters);
Meld.Action(Draw.Action(1, parameters.Game), parameters.TargetPlayer);
return(true);
}
public void LayOff_NotPlayerTurn()
{
GameState gs = new GameState();
Card justSomethingToLayOff = gs.Player2Cards[0];
Meld m = new Meld(Suit.Clubs, 3, 3);
Assert.That(() => gs.LayOff(Player.Two, justSomethingToLayOff, m), Throws.ArgumentException);
Assert.AreEqual(gs.CurrentError, ErrorMessage.NotPlayerTurn);
}
public void TestMeldsEqualOneCard()
{
Meld meldA = new Meld();
Meld meldB = new Meld();
meldA.AddCard(new Card("Ah"));
meldB.AddCard(new Card("Ah"));
Assert.IsTrue(meldA.Equals(meldB));
}
public void AddCard_SameRank()
{
IList <Suit> lSuit = new List <Suit>();
lSuit.Add(Suit.Diamonds);
lSuit.Add(Suit.Clubs);
lSuit.Add(Suit.Hearts);
Meld m = new Meld(lSuit, 8);
Card c = new Card(8, Suit.Diamonds);
Assert.IsTrue(m.CanAddACard(c));
}
public void Create_SameRank()
{
IList <Suit> lSuit = new List <Suit>();
lSuit.Add(Suit.Diamonds);
lSuit.Add(Suit.Clubs);
lSuit.Add(Suit.Hearts);
Meld m = new Meld(lSuit, 8);
CollectionAssert.AreEquivalent(new[] { new Card(8, Suit.Clubs), new Card(8, Suit.Diamonds), new Card(8, Suit.Hearts) }, m);
}
public void TestMeldsNotEqualCardCount()
{
Meld meldA = new Meld();
Meld meldB = new Meld();
meldA.AddCard(new Card("Ah"));
meldB.AddCard(new Card("Ah"));
meldB.AddCard(new Card("As"));
Assert.IsFalse(meldA.Equals(meldB));
}
public void AddCard_SameRank_AddDifferentRank_ThrowException()
{
IList <Suit> lSuit = new List <Suit>();
lSuit.Add(Suit.Diamonds);
lSuit.Add(Suit.Clubs);
lSuit.Add(Suit.Hearts);
Meld m = new Meld(lSuit, 8);
Card c = new Card(9, Suit.Diamonds);
Assert.IsFalse(m.CanAddACard(c));
}
public void TestFromMeldCode()
{
var m = new Meld("42570", 0);
Assert.AreEqual(0, m.OwnerId, "Wrong owner of meld.");
Assert.AreEqual(2, m.FromPlayerId, "Wrong player that the tile was called from.");
Assert.AreEqual(MeldType.Koutsu, m.Type, "Wrong meld type.");
Assert.IsTrue(m.Tiles.Any(t => t.Tile.Id == 111), "Missing tile 111.");
Assert.IsTrue(m.Tiles.Any(t => t.Tile.Id == 109), "Missing tile 109.");
Assert.IsTrue(m.Tiles.Any(t => t.Tile.Id == 108), "Missing tile 108.");
Assert.AreEqual(MeldTileType.Called, m.Tiles.First(t => t.Tile.Id == 111).Type, "Wrong type of tile 111.");
Assert.AreEqual(MeldTileType.Normal, m.Tiles.First(t => t.Tile.Id == 109).Type, "Wrong type of tile 109");
Assert.AreEqual(MeldTileType.Normal, m.Tiles.First(t => t.Tile.Id == 108).Type, "Wrong type of tile 108");
}
private static int GetTripletFu(Meld meld, bool revealed)
{
int triplet = revealed ? 2 : 4;
if (meld.IsKong)
{
triplet *= 4;
}
if (meld.IsYaojiu)
{
triplet *= 2;
}
return(triplet);
}
