//control demanding options
private bool CheckDemandPossibilities(CardRanks rank, CardSuits suit, int playerNumber)
{
CardsDemandingHandler Handler = new CardsDemandingHandler();
return(Handler.CheckDemandPossibilities(rank, suit, playerNumber, ref demandedRank,
ref demandedSuit, ref status, ref PlayersCurrentData));
}
//sorting cards with the same rank
private List <PlayingCard> SortOneRank(CardRanks rank)
{
List <PlayingCard> sameRankList = GetCardsWithSameRank(rank);
List <PlayingCard> sordetList = SortByColors(sameRankList);
return(sordetList);
}
private int GetPower()
{
CardRanks rank = (CardRanks)Enum.Parse(typeof(CardRanks), this.Rank);
CardSuits suit = (CardSuits)Enum.Parse(typeof(CardSuits), this.Suit);
return((int)rank + (int)suit);
}
public void Test_Card_Constructor(string strCard, CardRanks rank, CardSuits suit)
{
var card2h = new Card(strCard);
Assert.AreEqual(rank, card2h.Rank);
Assert.AreEqual(suit, card2h.Suit);
}
//Confirming of putting card on the table
private void BattleWindow_ConfirmButtonClick(object sender, ConfirmPutBattleCardOnTheTableEventArgs e)
{
//demanding options
demandedRankRequest = e.DemandedRank;
demandedSuitRequest = e.DemandedSuit;
if (MatchingCardInBattleMode.CompareTo(new PlayingCard(e.NewSuit, e.NewRank, MatchingCardInBattleMode.DeckNumber)) == 0)
{
SendMovementDataToHost(GeneratePerformingAMoveRequestData(true,
new List <PlayingCard>()
{
MatchingCardInBattleMode
}, false));
}
else
{
losingBattleCardAutoResponse = true;
autoresponseCard = new PlayingCard(MatchingCardInBattleMode.Suit, MatchingCardInBattleMode.Rank, MatchingCardInBattleMode.DeckNumber);
autoresponseCard.ChangeCardFromJocker(e.NewSuit, e.NewRank);
EngineHostDataOperator Operator = new EngineHostDataOperator();
Operator.ResponseArrived += Operator_ResponseArrived;
Operator.ChangeJokerIntoAnotherCard(GenerateJokerChangeRequest(
MatchingCardInBattleMode, e.NewRank, e.NewSuit), ThisPlayerControl, SynchCont);
}
}
private void AssignContentOfCardsDescriptionTab()
{
//CardsDescriptionFrame.Content = null;
CardsDescriptionFrame.Content = cardDescriptionPageContent;
currentCardDescriptionRank = CardRanks.Two;
CardsDescriptionBckButton.Visibility = Visibility.Collapsed;
}
//control demanding options
public bool CheckDemandPossibilities(CardRanks newDemRank, CardSuits newDemSuit, int playerNumber,
ref CardRanks demandedRank, ref CardSuits demandedSuit, ref GameStatus status,
ref Dictionary <int, SinglePlayerData> PlayersCurrentData)
{
var logger = NLog.LogManager.GetCurrentClassLogger();
string demandingType = "";
if (Engine.ExtendedLogging)
{
logger.Info($"+++++++++++++++++++++++++++++++++++++++++++++++++++++++");
logger.Info($"+++++++++++++++++++++++++++++++++++++++++++++++++++++++");
logger.Info($"Demand possibilities checker current gme state: {status.ToString()}.");
logger.Info($"+++++++++++++++++++++++++++++++++++++++++++++++++++++++");
logger.Info($"+++++++++++++++++++++++++++++++++++++++++++++++++++++++");
}
//can't demand rank and suit at the same time
if (newDemRank != CardRanks.None && newDemSuit != CardSuits.None)
{
string text = "Rank and Suit can not be demanded both at the same time";
logger.Error(text);
throw new ArgumentException(text);
}
//set demanding after placing the card on the table
if (newDemRank == CardRanks.None && newDemSuit == CardSuits.None)
{
demandingType = "none";
demandedRank = CardRanks.None;
demandedSuit = CardSuits.None;
//status
if (status != GameStatus.Battle && status != GameStatus.Stops &&
status != GameStatus.StopsAndBattle)
{
status = GameStatus.Standard;
}
ResetDemandingOptionsForAllPlayers(ref PlayersCurrentData, false);
}
else if (newDemRank != CardRanks.None && newDemSuit == CardSuits.None)
{
demandingType = "rank";
SetRankDemandOption(playerNumber, newDemRank, ref demandedRank, ref demandedSuit, ref PlayersCurrentData);
//status
status = GameStatus.RankDemanding;
}
else if (newDemRank == CardRanks.None && newDemSuit != CardSuits.None)
{
demandingType = "suit";
SetSuitDemandOption(playerNumber, newDemSuit, ref demandedRank, ref demandedSuit, ref PlayersCurrentData);
//status
status = GameStatus.SuitDemanding;
}
if (Engine.ExtendedLogging)
{
logger.Info($"Demand possibilities checking done. Demanded rank: {demandedRank.ToString()}, demanded suit: {demandedSuit.ToString()}, type: {demandingType}.");
}
return(true);
}
//method for checkin if card can stop move = if it is four
private void CheckIfCardCanStopMove(CardRanks cardRank)
{
if (cardRank == CardRanks.Four)
{
stopsMove = true;
}
}
protected virtual void OnConfirmButtonClick(CardSuits suit, CardRanks rank, CardRanks demRank, CardSuits demDuit)
{
ConfirmButtonClick?.Invoke(this, new ConfirmPutBattleCardOnTheTableEventArgs()
{
NewRank = rank, NewSuit = suit, DemandedRank = demRank, DemandedSuit = demandedSuit
});
}
//method for checking if the card is Brave
private void CheckIfCardIsBrave(CardRanks cardRank, CardSuits cardSuit)
{
if (cardRank == CardRanks.Two || cardRank == CardRanks.Three ||
(cardRank == CardRanks.King && (cardSuit == CardSuits.Spade || cardSuit == CardSuits.Heart)))
{
brave = true;
}
}
//method for checking if the card can be demanded
private void CheckIfThisCardCanBeDemanded(CardRanks cardRank)
{
if (cardRank == CardRanks.Five || cardRank == CardRanks.Six || cardRank == CardRanks.Seven || cardRank == CardRanks.Eight ||
cardRank == CardRanks.Nine || cardRank == CardRanks.Ten || cardRank == CardRanks.Queen)
{
canBeDemanded = true;
}
}
//method for establishing demanded suit
private void SetSuitDemandOption(int playerNumber, CardSuits demSuit, ref CardRanks demandedRank,
ref CardSuits demandedSuit, ref Dictionary <int, SinglePlayerData> PlayersCurrentData)
{
ResetDemandingOptionsForAllPlayers(ref PlayersCurrentData, true);
demandedRank = CardRanks.None;
demandedSuit = demSuit;
PlayersCurrentData[playerNumber].ThisPlayerStartedSuitDemanding = true;
}
//change one jocker card into any other card
public bool ChangeJockerIntoAnotherCard(int playerNumber, PlayingCard card, CardRanks newRank, CardSuits newSuit,
bool calledByEngine)
{
JokerChanger jokerChanger = new JokerChanger(playerNumber, card, newRank, newSuit,
currentPlayer, calledByEngine);
return(jokerChanger.ChangeJockerIntoAnotherCard(ref PlayersCurrentData));
}
public void ToStringTest()
{
CardSuits suit = CardSuits.Spade;
CardRanks rank = CardRanks.Ace;
Card card = new(suit, rank);
Assert.AreEqual(card.ToString(), ((char)suit).ToString() + ((char)rank).ToString());
}
private void CreatingPageCommonMethod(CardRanks newRank)
{
rank = newRank;
InitializeComponent();
AssignTextSources();
AssignTextsToTextBlocks();
AssignCardsPictures();
LogOpeningOfNewPage();
}
public void RetainingValueTest()
{
CardSuits suit = CardSuits.Club;
CardRanks rank = CardRanks.Eight;
Card card = new(suit, rank);
Assert.True(card.Suit == suit &&
card.Rank == rank);
}
//clicking proper game suit - selection of card suit
private void RankButton_Click(object sender, RoutedEventArgs e)
{
thisRank = (CardRanks)(sender as WrapPanelSelectableItem).Tag;
ResetSelectionOfRanks();
(sender as WrapPanelSelectableItem).ItemSelected = Visibility.Visible;
var logger = NLog.LogManager.GetCurrentClassLogger();
logger.Info($"New choosen Card rank: {thisRank.ToString()}.");
}
public CardCorrectnessChecker(PlayingCard cardToCheck, PlayingCard topCard,
CardRanks demandedRank, CardSuits demandedSuit, GameStatus status)
{
this.cardToCheck = cardToCheck;
this.topCard = topCard;
this.demandedRank = demandedRank;
this.demandedSuit = demandedSuit;
this.status = status;
logger = LogManager.GetCurrentClassLogger();
}
private void ResetInternalDemandOptions()
{
jackOrAceInCardsToPutOnTheTable = false;
demandedRankRequest = CardRanks.None;
IsPlayerDemandingRank = false;
RankDemandedByThisPlayer = RankAndSuitNameProvider.GetRankName(CardRanks.None, "pl");
demandedSuitRequest = CardSuits.None;
IsPlayerDemandingSuit = false;
SuitDemandedByThisPlayer = RankAndSuitNameProvider.GetSuitName(CardSuits.None, "pl");
}
//method for checking next move direction
private void EstablishNextMoveDirection(CardRanks cardRank, CardSuits cardSuit)
{
if (cardRank == CardRanks.King && cardSuit == CardSuits.Spade)
{
nextMove = CardMoveDirections.Backward;
}
else
{
nextMove = CardMoveDirections.Forward;
}
}
private bool ChackIfPassedCardHasSpecificRank(PlayingCard card, CardRanks rank)
{
if (card.Rank == rank)
{
return(true);
}
else
{
return(false);
}
}
//static method for determining if passed rank can be demanded
public static bool CanRankBeDemanded(CardRanks rank)
{
if (rank == CardRanks.Five || rank == CardRanks.Six || rank == CardRanks.Seven || rank == CardRanks.Eight ||
rank == CardRanks.Nine || rank == CardRanks.Ten || rank == CardRanks.Queen)
{
return(true);
}
else
{
return(false);
}
}
//clicking proper game suit - selection of card suit
private void SuitButton_Click(object sender, RoutedEventArgs e)
{
thisSuit = (CardSuits)(sender as WrapPanelSelectableItem).Tag;
thisRank = CardRanks.None;
var logger = NLog.LogManager.GetCurrentClassLogger();
logger.Info($"New choosen Card suit: {thisSuit.ToString()}.");
ResetSelectionOfSuits();
(sender as WrapPanelSelectableItem).ItemSelected = Visibility.Visible;
RemoveAllChildrenFromRankScrllView();
PopulateRankWrapPanel();
}
public JokerChanger(int playerNumber, PlayingCard card, CardRanks newRank, CardSuits newSuit,
int curremtPlayerNumber, bool calledByEngine)
{
this.playerNumber = playerNumber;
this.curremtPlayerNumber = curremtPlayerNumber;
this.card = card;
this.newRank = newRank;
this.newSuit = newSuit;
this.calledByEngine = calledByEngine;
var logger = NLog.LogManager.GetCurrentClassLogger();
logger.Info($"Joker changed class - constructor. Passed card created by joker: {card.CreatedByJocker}.");
}
//method for getting cards with the same rank from all cards in control
private List <PlayingCard> GetCardsWithSameRank(CardRanks rank)
{
List <PlayingCard> cards = new List <PlayingCard>();
foreach (PlayingCard item in currentCards)
{
if (item.Rank == rank)
{
cards.Add(item);
}
}
return(cards);
}
//constructor
public JokerChange()
{
InitializeComponent();
thisRank = CardRanks.None;
thisSuit = CardSuits.None;
PopulateSuitsWrapPanel();
var logger = NLog.LogManager.GetCurrentClassLogger();
logger.Info("Joker changing window initialized");
}
//used for counting the number of specific ranked cards there are in the hand.
static int CardRankCounter(Card[] setOfCards, CardRanks crdrnk)
{
int setLength = 5;
int returnValue = 0;
for (int n = 0; n < setLength; n++)
{
if (setOfCards[n].CardRank == crdrnk)
{
returnValue++;
}
}
return returnValue;
}
//used for counting the number of specific ranked cards there are in the hand.
static int CardRankCounter(Card[] setOfCards, CardRanks crdrnk)
{
int setLength = 5;
int returnValue = 0;
for (int n = 0; n < setLength; n++)
{
if (setOfCards[n].CardRank == crdrnk)
{
returnValue++;
}
}
return(returnValue);
}
//method for checking if car can demand AnotherCards
private void CheckIfCardCanDemandAnotherCards(CardRanks cardRank)
{
if (cardRank == CardRanks.Jack)
{
canDemand = true;
demands = DemandOptions.Ranks;
}
if (cardRank == CardRanks.Ace)
{
canDemand = true;
demands = DemandOptions.Suits;
}
}
private static string GenerateResourceName(CardSuits suit, CardRanks rank)
{
if (rank == CardRanks.Joker)
{
return($"{rank.ToString()}_of_none");
}
else if (rank != CardRanks.Joker && rank != CardRanks.None)
{
return($"{rank.ToString()}_of_{suit.ToString()}");
}
else
{
return("");
}
}
public static void Main()
{
string input = Console.ReadLine();
string[] cards = typeof(CardRanks).GetEnumNames();
Console.WriteLine("Card Ranks:");
foreach (var card in cards)
{
CardRanks parsed = (CardRanks)Enum.Parse(typeof(CardRanks), card);
Console.WriteLine($"Ordinal value: {(int)parsed}; Name value: {parsed}");
}
}
/// <summary>
/// Constructor to instantiate Card.
/// </summary>
/// <param name="suite">Suite of the card</param>
/// <param name="rank">Rank of the card</param>
public Card(CardSuites suite, CardRanks rank)
{
this.Suite = suite;
this.Rank = rank;
}
