/// <summary>
/// Returns the card object that contains the value searched for
/// </summary>
/// <param name="value">The value of the card</param>
/// <returns></returns>
public Card GetCardbyValue(CardValues value)
{
Card searchedCard = null;
foreach (var player in PlayerList)
{
var cards = player.Cards.Where(card => card.CardValue == value);
if (cards.Any())
{
searchedCard = cards.First();
}
foreach (var stich in player.Stiche)
{
var s = stich.Where(card => card.CardValue == value);
if (s.Any())
{
searchedCard = s.First();
}
}
}
if (searchedCard == null)
{
throw new Exception("Card not found");
}
else
{
return(searchedCard);
}
}
public IEnumerable <CardValues> PullOutBooks()
{
List <CardValues> books = new List <CardValues>();
for (int i = 0; i <= 13; i++)
{
CardValues cardValue = (CardValues)i;
int howMany = 0;
for (int card = 0; card < cards.Count; card++)
{
if (cards.Peek(card).CardValue == cardValue)
{
howMany++;
}
}
if (howMany != 4)
{
continue;
}
books.Add(cardValue);
cards.PullOutValues(cardValue);
}
return(books);
}
public void AskForACard(List <Player> players, int myIndex, Deck stock, CardValues cardValue)
{
textBoxOnForm.Text += Name + " asks if anyone has a " + cardValue + Environment.NewLine;
int totalCardsGiven = 0;
for (int i = 0; i < players.Count; i++)
{
if (i != myIndex)
{
Player player = players[i];
Deck CardsGiven = player.DoYouHaveAny(cardValue);
totalCardsGiven += CardsGiven.Count;
while (CardsGiven.Count > 0)
{
cards.Add(CardsGiven.Deal());
}
}
}
if (totalCardsGiven != 0 || stock.Count <= 0)
{
return;
}
textBoxOnForm.Text += Name + " must draw from the stock." + Environment.NewLine;
cards.Add(stock.Deal());
}
public Card(CardTypes color, CardValues value, int trumpvalue, int nonTrumpvalue)
{
Color = color;
Value = value;
Trumpvalue = trumpvalue;
NonTrumpvalue = nonTrumpvalue;
}
public void PlayTimedSfx(CardValues currentCard)
{
if (currentCard.sfx == null)
{
GameController.gameController.SFXFadesDone();
}
else
{
if (timedSfxSource.isPlaying)
{
timedSfxSource.Stop();
}
timedSfxSource.clip = currentCard.sfx;
timedSfxSource.volume = 1f;
currentTimedVolume = 1f;
if (currentCard.sfxPrewait == 0)
{
timedIsWaiting = false;
timedSfxPlaying = true;
timedSfxSource.Play();
}
else
{
timedIsWaiting = true;
timeUntilStart = currentCard.sfxPrewait;
}
if (currentCard.sfxFadeOutAt == 0)
{
timedSfxHasFadeOut = false;
}
else
{
timedSfxHasFadeOut = true;
timeUntilFadeOut = currentCard.sfxFadeOutAt;
if (timeUntilFadeOut < timeUntilStart)
{
timeUntilFadeOut += timeUntilStart;
}
if (currentCard.fadeOutSpeed == 0)
{
fadeOutAmount = 1f / 30f;
}
else
{
fadeOutAmount = currentCard.fadeOutSpeed / 60f;
}
if (currentCard.sfxAfterWait == 0)
{
timedHasAfterWait = false;
}
else
{
timedHasAfterWait = true;
afterWaitTime = currentCard.sfxAfterWait;
}
}
}
}
public static string Plural(CardValues cardValue)
{
if (cardValue == CardValues.Six)
{
return("Sixes");
}
return(cardValue + "s");
}
public Card(CardSuits suit, CardValues cardVal)
{
cardSuit = suit;
cardValue = cardVal;
faceImage = ImageHelper.GetFaceImageForCard(this);
backImage = ImageHelper.GetBackImage();
}
public void TestSetter()
{
CardValues currentCard4Value = card4.Value;
card4.Value = CardValues.Ace;
Assert.NotEqual(currentCard4Value, card4.Value);
}
public void CompareHandsTest(List <string> hand1, List <string> hand2)
{
var cardValues = new CardValues();
var handData = new HandCalculator(cardValues, new HandValues(cardValues));
var hand1WithData = handData.Calculate(hand1);
var hand2WithData = handData.Calculate(hand2);
Assert.True(hand1WithData.Value > hand2WithData.Value);
}
private void FillDeck()
{
for (int i = 0; i < cardsAsInt.Count; i++)
{
Suit suit = ((Suit)(cardsAsInt[i] % 4));
CardValues value = (CardValues)(cardsAsInt[i] % 13 + 1);
deckOfCards.Enqueue(new Card(suit, value));
}
}
public Deck DoYouHaveAny(CardValues cardValue)
{
Deck ownedCards = cards.PullOutValues(cardValue);
textBoxOnForm.Text += Name + " has " + ownedCards.Count + " " + Card.Plural(cardValue) + "\r\n";
return(ownedCards);
// This is where an opponent asks if I have any cards of a certain cardValue
// Use Deck.PullOutValues() to pull out the values. Add a line to the TextBox
// that says, "Joe has 3 sixes"—use the new Card.Plural() static method
}
public bool ContainsValue(CardValues cardValue)
{
foreach (Card card in _cards)
{
if (card.CardValue == cardValue)
{
return(true);
}
}
return(false);
}
public void AskForACard(List <Player> players, int myIndex, Deck stock)
{
if (stock.Count > 0)
{
if (cards.Count == 0)
{
cards.Add(stock.Deal());
}
CardValues randomCardValue = GetRandomValue();
AskForACard(players, myIndex, stock, randomCardValue);
}
}
private static Card SearchCard(SchafkopfGame game, CardValues cardValue)
{
foreach (var player in game.PlayerList)
{
var searchCard = player.Cards.Where(k => k.CardValue == cardValue);
if (searchCard.Count() != 0)
{
return(searchCard.First());
}
}
throw new InvalidOperationException("Card not Found");
}
public Card GetCard(CardValues cardValue, CardSuits suit)
{
foreach (Card c in this.Cards)
{
if (c.Value == cardValue && c.Suit == suit)
{
this.Cards.Remove(c);
return c;
}
}
return null;
}
public void StartTextCoroutine()
{
if (typeTextRunning) // Failsafe, incase two typetexts were called at the sametime.
{
StopCoroutine(typeTextCoroutine); // Stop currently running typetext..
cardText.text = ""; // ..replace the text with blank
typeTextRunning = false;
}
currentCard = GameController.gameController.currentCard; // Get reference to the new card from gamecontroller
typeTextNewTextDone = false; // trigger the donetyping boolean to false
typeTextCoroutine = TypeText(currentCard.cardText); // Update the text from new card
StartCoroutine(typeTextCoroutine); // Start printing the new text
}
public Deck PullOutValues(CardValues cardValue)
{
Deck deckToReturn = new Deck(new Card[] { });
for (int i = _cards.Count - 1; i >= 0; i--)
{
if (_cards[i].CardValue == cardValue)
{
deckToReturn.Add(Deal(i));
}
}
return(deckToReturn);
}
private GameObject InstantiateCard(Player player, CardValues cardvalue, GameObject CardPrefab, Transform fieldPos, float xOffset, float zOffset)
{
var card = GameObject.Instantiate(
CardPrefab,
new Vector3(fieldPos.position.x + xOffset, fieldPos.position.y, fieldPos.position.z - zOffset),
Quaternion.identity,
fieldPos
);
card.GetComponent <UnityCard>().Owner = player;
card.GetComponent <UnityCard>().CardValue = cardvalue;
card.GetComponent <UnityCard>().SchafKopfController = this;
return(card);
}
public bool HasBook(CardValues cardValue)
{
int numberOfCards = 0;
foreach (Card card in _cards)
{
if (card.CardValue == cardValue)
{
numberOfCards++;
}
}
return(numberOfCards == 4);
}
public Card(string valueSuitString)
{
try
{
var splited = valueSuitString.Split(" ");
Value = splited[0].ToEnum <CardValues>();
Suit = splited[1].ToEnum <CardSuits>();
}
catch
{
throw new Exception("Value or suit is not correct");
}
}
private static bool IsCardOnTable(List <Hand> hands, CardSuits suit, CardValues value)
{
foreach (var hand in hands)
{
foreach (var card in hand.Cards)
{
if (card.Suit == suit && card.Value == value)
{
return(true);
}
}
}
return(false);
}
public static string GenerateCardKey(CardValues value)
{
string tickStr = DateTime.UtcNow.Ticks.ToString();
byte[] tickBytes = Encoding.UTF8.GetBytes(tickStr.Substring(tickStr.Length - 16));
string displayStr = GetDisplayTick(tickBytes);
byte[] key = GetKey(tickBytes);
byte[] vi = GetVi(key);
string encrypted = FormatEncryptedPayload(EncryptionHelper.Encrypt($"{(int)value}", key, vi));
return(displayStr + encrypted);
}
// constructor 1 - this code is excuted when a CardDeck object is created from this class
public Cards()
{
DeckOfCards = new List <Card>();
for (Suits suitsEnum = 0; suitsEnum < Suits.OverTheMaxValue; suitsEnum++)
{
for (CardValues cardValuesEnum = CardValues.Ace; cardValuesEnum < CardValues.OverTheMaxValue; cardValuesEnum++)
{
Card card = new Card()
{
SuitsEnum = suitsEnum, CardValuesEnum = cardValuesEnum
};
this.DeckOfCards.Add(card);
}
}
}
public void AddCard(string str)
{
GameObject temp = Instantiate(card, new Vector3(0, 0, 0), quaternion);
temp.transform.SetParent(this.gameObject.transform);
temp.gameObject.GetComponent <Image>().sprite = CardSprites.sprites[str];
CardValues cardValues = temp.GetComponent <CardValues>();
if (str != "back")
{
cardValues.setValues(str);
}
cardValues.owner = this;
cards.Add(temp);
}
public Card this[CardColor color, CardValues value]
{
get
{
Card c = null;
for (int i = 0; i < _cards.Count && c is null; i++)
{
if (_cards[i].Color == color && _cards[i].Value == value)
{
c = _cards[i];
}
}
_cards.Remove(c);
return(c);
}
}
private static Schlag Schlag(CardValues card)
{
var cardString = card.ToString();
char[] cardList = { '7', '8', '9', 'U', 'O', 'K', '1', 'A' };
Schlag[] schlaege = Enum.GetValues(typeof(Schlag)).Cast <Schlag>().ToArray();
for (int c = 0; c < cardList.Length; c++)
{
if (cardString[1] == cardList[c])
{
return(schlaege[c]);
}
}
throw new InvalidOperationException("Schlag nicht gefunden");
}
public void UpdateCardDisplay()
{
UpdatePopUpField(); // Update the previouscard text pop up field.
if (currentCard != previousCard)
{
previousCard = currentCard;
currentCard = GameController.gameController.currentCard; // Update the current to a new one
UpdateImages(); // Update to new images, hide the field if there is no image.
}
SiblingIndexSwitch(); // Switches foreground images if needed.
RefreshButtonTextFields(); // Update the textfield to current ones, does NOT affect cardText.
UpdateButtonFunctions(); // Update the CardDisplay button listeners.
RefreshOptions(); // Refresh options, if options are off, enable option 5.
SkipScene(); //Asks if you want to skip if there is skipcard
}
private static CardValues SelectSau(SchafkopfGame spiel)
{
Console.Write("Sau auf die gespielt werden soll: (E/G/H/S): ");
string sauFarbeInputLetter = Console.ReadLine();
CardValues[] kartenWerte = new CardValues[] { CardValues.EA, CardValues.GA, CardValues.HA, CardValues.SA };
string[] buchStabenWerte = new string[] { "E", "G", "H", "S" };
for (int i = 0; i < buchStabenWerte.Length; i++)
{
if (sauFarbeInputLetter == buchStabenWerte[i])
{
return(kartenWerte[i]);
}
}
throw new KeyNotFoundException("Sau nicht gefunden");
}
public bool StoryEvent(int nextCardtTime, int nextCardDay)
{
CardValues next = null;
bool isEvent = false;
if (nextCardDay == 2 && nextCardtTime == 0)
{
next = day2MorningCard;
isEvent = true;
}
else if (nextCardDay == 2 && nextCardtTime == 3)
{
next = day2EveningCard;
isEvent = true;
}
else if (nextCardDay == 3 && nextCardtTime == 0)
{
next = day3MorningCard;
isEvent = true;
}
else if (nextCardDay == 3 && nextCardtTime == 3)
{
next = day3EveningCard;
isEvent = true;
}
else if (nextCardDay == 4 && nextCardtTime == 0)
{
if (allSwitches[7])
{
next = day4MorKowGone;
}
else
{
next = day4MorKowHere;
}
isEvent = true;
}
if (isEvent)
{
SetCurrentCard(next);
cardDisplay.typeTextNewTextDone = false;
}
return(isEvent);
}
public void DoFadeOut(CardValues card)
{
fadingOut = true;
if (card.ppsFadeMode == 1)
{
leftToRight = true;
}
else
{
leftToRight = false;
}
if (card.fadeOutSpeed == 0)
{
fadeOutAmount = 1f / 60f;
}
else
{
fadeOutAmount = 1f / (60f * card.fadeOutSpeed);
}
}
public CardValues GetRandomValue()
{
List <CardValues> valuesInTheDeck = new List <CardValues>();
for (int i = 1; i <= 13; i++)
{
CardValues cardValue = (CardValues)i;
for (int card = 0; card < cards.Count; card++)
{
if (cards.Peek(card).CardValue == cardValue && !valuesInTheDeck.Contains(cardValue))
{
valuesInTheDeck.Add(cardValue);
}
}
}
int randomValueInt = random.Next(valuesInTheDeck.Count);
CardValues randomCardValue = valuesInTheDeck[randomValueInt];
return(randomCardValue);
// This method gets a random cardValue—but it has to be a cardValue that's in the deck!
}
private Color Farben(CardValues card)
{
var cardId = card.ToString();
if (cardId[0] == 'E')
{
return(Color.Eichel);
}
if (cardId[0] == 'G')
{
return(Color.Gras);
}
if (cardId[0] == 'H')
{
return(Color.Herz);
}
if (cardId[0] == 'S')
{
return(Color.Schellen);
}
throw new ArgumentException("Wrong Card");
}
public Card(CardValues value, CardSuit suit)
{
this.value = value;
this.suit = suit;
}
public void setCard(CardSuits suit, CardValues values)
{
this.card = new CardLib.Card(suit, values);
card.Flip();
pictureBox1.Image = card.FacingImage;
}
private byte[] OnGetAccountInfo(GameSession session, byte[] body)
{
GetAccountInfo request = new GetAccountInfo();
using(Stream stream = new MemoryStream(body)) {
request.Deserialize(stream);
}
Debug.WriteLine("LOG " + request.Request_);
if(request.Request_ == GetAccountInfo.Request.CAMPAIGN_INFO) {
ProfileProgress response = new ProfileProgress() {
Progress = 6,
BestForge = 0
};
return response.EncodeResponse(233);
}
if(request.Request_ == GetAccountInfo.Request.BOOSTERS) {
BoosterList response = new BoosterList();
response.List.Add(new BoosterInfo() {
Type = (int)BoosterType.Classic,
Count = 10
});
response.List.Add(new BoosterInfo() {
Type = (int)BoosterType.GvG,
Count = 10
});
response.List.Add(new BoosterInfo() {
Type = (int)BoosterType.TGT,
Count = 10
});
return response.EncodeResponse(224);
}
if(request.Request_ == GetAccountInfo.Request.FEATURES) {
GuardianVars response = new GuardianVars() {
ShowUserUI = 1
};
return response.EncodeResponse(264);
}
if(request.Request_ == GetAccountInfo.Request.MEDAL_INFO) {
MedalInfo response = new MedalInfo() {
SeasonWins = 0,
Stars = 0,
Streak = 0,
StarLevel = 1,
LevelStart = 1,
LevelEnd = 3,
CanLose = false
};
return response.EncodeResponse(232);
}
if(request.Request_ == GetAccountInfo.Request.NOTICES) {
ProfileNotices response = new ProfileNotices();
return response.EncodeResponse(212);
}
if(request.Request_ == GetAccountInfo.Request.DECK_LIST) {
DeckList response = new DeckList();
foreach(Deck deck in session.Server.Database.Table<Deck>().Where(d => d.DeckType == DeckType.PRECON_DECK)) {
response.Decks.Add(deck.ToDeckInfo());
}
foreach(Deck deck in session.Server.Database.Table<Deck>().Where(d => d.DeckType == DeckType.NORMAL_DECK && d.AccountID == session.Account.ID)) {
response.Decks.Add(deck.ToDeckInfo());
}
return response.EncodeResponse(202);
}
if(request.Request_ == GetAccountInfo.Request.COLLECTION) {
Collection response = new Collection();
foreach(DbfCard card in session.Server.Database.Table<DbfCard>().Where(c => c.Collectible)) {
response.Stacks.Add(new CardStack() {
LatestInsertDate = DateTime.Now.ToPegasusDate(),
NumSeen = 2,
Count = 2,
CardDef = new PegasusShared.CardDef() {
Asset = card.ID,
Premium = 0
}
});
}
return response.EncodeResponse(207);
}
if(request.Request_ == GetAccountInfo.Request.DECK_LIMIT) {
ProfileDeckLimit response = new ProfileDeckLimit() {
DeckLimit = 9
};
return response.EncodeResponse(231);
}
if(request.Request_ == GetAccountInfo.Request.CARD_VALUES) {
CardValues response = new CardValues() {
CardNerfIndex = 0
};
return response.EncodeResponse(260);
}
if(request.Request_ == GetAccountInfo.Request.ARCANE_DUST_BALANCE) {
ArcaneDustBalance response = new ArcaneDustBalance() {
Balance = 10000
};
return response.EncodeResponse(262);
}
if(request.Request_ == GetAccountInfo.Request.NOT_SO_MASSIVE_LOGIN) {
NotSoMassiveLoginReply response = new NotSoMassiveLoginReply();
return response.EncodeResponse(300);
}
if(request.Request_ == GetAccountInfo.Request.REWARD_PROGRESS) {
RewardProgress response = new RewardProgress() {
SeasonEnd = new DateTime(DateTime.UtcNow.AddMonths(1).Year, DateTime.UtcNow.AddMonths(1).Month, 1, 7, 0, 0).ToPegasusDate(),
WinsPerGold = 3,
GoldPerReward = 10,
MaxGoldPerDay = 100,
SeasonNumber = 1,
XpSoloLimit = 60,
MaxHeroLevel = 60,
NextQuestCancel = DateTime.UtcNow.ToPegasusDate(),
EventTimingMod = 0.291667f
};
return response.EncodeResponse(271);
}
if(request.Request_ == GetAccountInfo.Request.GOLD_BALANCE) {
GoldBalance response = new GoldBalance() {
Cap = 999999,
CapWarning = 2000,
CappedBalance = 9999,
BonusBalance = 0
};
return response.EncodeResponse(278);
}
if(request.Request_ == GetAccountInfo.Request.HERO_XP) {
HeroXP response = new HeroXP();
for(int i = 2; i < 11; i++) {
response.XpInfos.Add(new HeroXPInfo() {
ClassId = i,
Level = 30,
CurrXp = 420,
MaxXp = 840
});
}
return response.EncodeResponse(283);
}
if(request.Request_ == GetAccountInfo.Request.PLAYER_RECORD) {
PlayerRecords response = new PlayerRecords();
return response.EncodeResponse(270);
}
if(request.Request_ == GetAccountInfo.Request.CARD_BACKS) {
CardBacks response = new CardBacks() {
DefaultCardBack = 0
};
foreach(DbfCardBack cardBack in session.Server.Database.Table<DbfCardBack>()) {
response.CardBacks_.Add(cardBack.ID);
}
return response.EncodeResponse(236);
}
if(request.Request_ == GetAccountInfo.Request.FAVORITE_HEROES) {
FavoriteHeroesResponse response = new FavoriteHeroesResponse();
foreach(FavoriteHero hero in session.Server.Database.Table<FavoriteHero>().Where(h => h.AccountID == session.Account.ID)) {
response.FavoriteHeroes.Add(new PegasusShared.FavoriteHero() {
ClassId = hero.ClassID,
Hero = new PegasusShared.CardDef() {
Asset = hero.CardID,
Premium = hero.Premium,
}
});
}
return response.EncodeResponse(318);
}
if(request.Request_ == GetAccountInfo.Request.ACCOUNT_LICENSES) {
AccountLicensesInfoResponse response = new AccountLicensesInfoResponse();
return response.EncodeResponse(325);
}
if(request.Request_ == GetAccountInfo.Request.BOOSTER_TALLY) {
BoosterTallyList response = new BoosterTallyList();
return response.EncodeResponse(313);
}
if(request.Request_ == GetAccountInfo.Request.MEDAL_HISTORY) {
MedalHistory response = new MedalHistory();
response.Medals.Add(new MedalHistoryInfo() {
LegendRank = 1,
LevelEnd = 0,
LevelStart = 0,
Season = 1,
StarLevel = 0,
Stars = 0,
When = new DateTime(DateTime.UtcNow.AddMonths(-1).Year, DateTime.UtcNow.AddMonths(-1).Month, 1, 7, 0, 0).ToPegasusDate()
});
return response.EncodeResponse(234);
}
if(request.Request_ == GetAccountInfo.Request.PVP_QUEUE) {
PlayQueue response = new PlayQueue() {
Queue = new PlayQueueInfo() {
GameType = BnetGameType.BGT_NORMAL
}
};
return response.EncodeResponse(286);
}
Debug.WriteLine("ERR AccountHandler.OnGetAccountInfo missing " + request.Request_);
return null;
}
