public override bool IsClaimingDiscardedTileToCompleteWinningHand(Tile discardedTile)
{
var uncalledTilesWithClaimedDiscard = new List <Tile>(Hand.UncalledTiles)
{
discardedTile
};
if (!TileGrouper.CanGroupTilesIntoLegalHand(uncalledTilesWithClaimedDiscard))
{
return(false);
}
while (true)
{
WriteOptionChoiceIntroductoryText();
Console.WriteLine($"\tW: Claim the discarded {discardedTile} to form a [w]inning hand.");
Console.WriteLine("\tP: [P]ass.");
var choice = TakeInputAsLowercase();
if (choice == "w")
{
return(true);
}
if (choice == "p")
{
return(false);
}
WriteUnrecognizedInputText();
}
}
public override bool IsWinningHand()
{
var uncalledTilesWithoutBonusTiles = new List <Tile>();
var bonusTileSets = new List <TileGrouping>(BonusSets);
foreach (var tile in UncalledTiles)
{
if (tile.GetType() == typeof(BonusTile))
{
bonusTileSets.Add(new TileGrouping(tile));
}
else
{
uncalledTilesWithoutBonusTiles.Add(tile);
}
}
if (GetAdjustedCountOfPassedTiles(uncalledTilesWithoutBonusTiles, CalledSets) != WinningHandBaseTileCount)
{
return(false);
}
return(IsThirteenOrphans(uncalledTilesWithoutBonusTiles, CalledSets) ||
IsSevenPairs(uncalledTilesWithoutBonusTiles, CalledSets) ||
TileGrouper.CanGroupTilesIntoLegalHand(uncalledTilesWithoutBonusTiles));
}
public override TurnAction GetTurnActionAgainstDiscardedTile(Tile discardedTile, Player discardingPlayer)
{
RecentlySelectedTileGrouping = null;
var isNextInTurnOrder = IsPlayerNextInTurnOrder(discardingPlayer);
var canMakeWinningHand = CanClaimDiscardedTileToCompleteWinningHand(discardedTile);
var potentialHandTiles = new List <Tile>(Hand.UncalledTiles)
{
discardedTile
};
var groupsInvolvingDiscardedTile = TileGrouper.FindAllGroupsInTiles(potentialHandTiles)
.Where(group => group.Contains(discardedTile)).ToList();
var allowedGroups = FilterUnallowedGroups(groupsInvolvingDiscardedTile,
x => x.IsSequence() && !isNextInTurnOrder);
while (true)
{
WriteOptionChoiceIntroductoryText();
for (int i = 0; i < allowedGroups.Count; i++)
{
Console.WriteLine($"\t{i + 1}. Claim the discarded {discardedTile} to make: " +
$"[{allowedGroups[i]}].");
}
if (canMakeWinningHand)
{
Console.WriteLine($"\tW: Claim the discarded {discardedTile} to form a [w]inning hand.");
}
Console.WriteLine($"\tP: [P]ass.");
var choice = TakeInputAsLowercase();
if (choice == "w" && canMakeWinningHand)
{
return(TurnAction.DeclareWin);
}
if (choice == "p")
{
return(TurnAction.Pass);
}
int.TryParse(choice, out int numericChoice);
if (numericChoice > 0 && numericChoice < allowedGroups.Count + 1)
{
RecentlySelectedTileGrouping = allowedGroups[numericChoice - 1];
var action = RecentlySelectedTileGrouping.IsTriplet() ? TurnAction.FormTriplet :
(RecentlySelectedTileGrouping.IsQuad() ? TurnAction.FormQuad :
(RecentlySelectedTileGrouping.IsSequence() ? TurnAction.FormSequence : TurnAction.Pass));
return(action);
}
WriteUnrecognizedInputText();
}
}
public bool CanClaimDiscardedTileToCompleteGroup(Tile discardedTile, bool canBeSequence)
{
var potentialHandTiles = new List <Tile>(Hand.UncalledTiles)
{
discardedTile
};
var groupsInvolvingDiscardedTile = TileGrouper.FindAllGroupsInTiles(potentialHandTiles)
.Where(group => group.Contains(discardedTile)).ToList();
if (!canBeSequence)
{
groupsInvolvingDiscardedTile = groupsInvolvingDiscardedTile.Where(group => !group.IsSequence()).ToList();
}
return(groupsInvolvingDiscardedTile.Count > 0);
}
public IList <TileGrouping> GetAllGroupsThatCanBeMadeWithDiscardedTile(Tile discardedTile, bool canBeSequence)
{
var potentialHandTiles = new List <Tile>(Hand.UncalledTiles)
{
discardedTile
};
var groupsInvolvingDiscardedTile = TileGrouper.FindAllGroupsInTiles(potentialHandTiles)
.Where(group => group.Contains(discardedTile)).ToList();
if (!canBeSequence)
{
groupsInvolvingDiscardedTile = groupsInvolvingDiscardedTile.Where(group => !group.IsSequence()).ToList();
}
return(groupsInvolvingDiscardedTile);
}
public override bool IsClaimingDiscardedTileToCompleteGroup(Tile discardedTile, bool canBeSequence)
{
if (!CanClaimDiscardedTileToCompleteGroup(discardedTile, canBeSequence))
{
return(false);
}
var potentialHandTiles = new List <Tile>(Hand.UncalledTiles)
{
discardedTile
};
var groupsInvolvingDiscardedTile = TileGrouper.FindAllGroupsInTiles(potentialHandTiles)
.Where(group => group.Contains(discardedTile)).ToList();
if (!canBeSequence)
{
groupsInvolvingDiscardedTile = groupsInvolvingDiscardedTile.Where(group => !group.IsSequence()).ToList();
}
while (true)
{
WriteOptionChoiceIntroductoryText();
for (int i = 0; i < groupsInvolvingDiscardedTile.Count; i++)
{
Console.WriteLine($"\t{i + 1}. Claim the discarded {discardedTile} to make: " +
$"[{groupsInvolvingDiscardedTile[i]}].");
}
Console.WriteLine("\tP: [P]ass.");
var choice = TakeInputAsLowercase();
if (choice == "p")
{
return(false);
}
int.TryParse(choice, out int numericChoice);
if (numericChoice > 0 && numericChoice <= groupsInvolvingDiscardedTile.Count)
{
return(true);
}
WriteUnrecognizedInputText();
}
}
public IList <IList <TileGrouping> > FindAllWaysToParseWinningHand()
{
var allWaysToSplitTiles = TileGrouper.FindAllWaysToGroupTilesAfterRemovingAPair(UncalledTiles);
if (IsThirteenOrphans(UncalledTiles, CalledSets))
{
allWaysToSplitTiles.Add(new List <TileGrouping> {
new TileGrouping(UncalledTiles.ToArray())
});
}
if (IsSevenPairs(UncalledTiles, CalledSets))
{
allWaysToSplitTiles.Add(new List <TileGrouping> {
new TileGrouping(UncalledTiles.ToArray())
});
}
var waysToSplitTilesThatUseAllTiles = allWaysToSplitTiles.Where(
allGroups => allGroups.Sum(t => t.Count()) == UncalledTiles.Count() ||
allGroups.All(group => group.IsBonus())).ToList();
return(waysToSplitTilesThatUseAllTiles);
}
public override TileGrouping GetClosedOrPromotedQuadMade()
{
var closedQuads = TileGrouper.FindAllGroupsInTiles(Hand.UncalledTiles)
.Where(group => group.IsQuad()).ToList();
var promotedQuads = new List <TileGrouping>(Hand.CalledSets.Where(
group => group.IsTriplet() && Hand.UncalledTiles.Contains(group.First())));
var allQuads = closedQuads.Concat(promotedQuads).ToList();
while (true)
{
WriteOptionChoiceIntroductoryText();
for (int i = 0; i < closedQuads.Count; i++)
{
Console.WriteLine($"\t{i + 1}. Create a closed quad with the four " +
$"{closedQuads[i].First()} tiles in your hand.");
}
for (int i = 0; i < promotedQuads.Count; i++)
{
Console.WriteLine($"\t{i + closedQuads.Count() + 1}. Create a promoted quad with the " +
$"{promotedQuads[i].First()} tile in your hand.");
}
Console.WriteLine($"\tP: [P]ass.");
var choice = TakeInputAsLowercase();
if (choice == "p")
{
return(null);
}
int.TryParse(choice, out int numericChoice);
if (numericChoice > 0 && numericChoice < allQuads.Count + 1)
{
return(allQuads[numericChoice - 1]);
}
WriteUnrecognizedInputText();
}
}
