private IEnumerable <Stone> FillAsset()
{
for (var i = 0; i < 6; i++)
{
yield return(GameDeck.GetStone());
}
}
private void player_OnCardDiscarded(object sender, CardEventArgs e)
{
// Update the discard pile by making the specified card the available card.
CurrentAvailableCard = e.Card;
// Determine the index of the next player. If the current player is the last player,
// then the first player is the next player.
var nextIndex = CurrentPlayer.Index + 1 >= _gameOptions.NumberOfPlayers ? 0 : CurrentPlayer.Index + 1;
// If the game deck is empty, the discarded cards need to be reshuffled.
if (GameDeck.CardsInDeck == 0)
{
// Get a list of all the cards that are in play. This includes all the cards in
// players' hands, and the top card on the discard pile.
var cardsInPlay = new List <Card>();
foreach (var player in Players)
{
cardsInPlay.AddRange(player.GetCards());
}
cardsInPlay.Add(CurrentAvailableCard);
// Reshuffle all the cards *except* for the list of cards that are in play.
GameDeck.ReshuffleDiscarded(cardsInPlay);
}
// Finally, set the next player.
AssignCurrentPlayer(nextIndex);
}
public void SerializationTestMethod1()
{
GameCardManager gameCardManager = new GameCardManager();
GamePlayer gamePlayer = new GamePlayer(null, new Hero(1, 25, 30), new GameDeck(1, CardManager.Instance.Cards.Select(x => gameCardManager.CreateCardRecord(x).CardRecordID).ToList()));
byte[] serializedData = SerializationHelper.Serialize(gamePlayer);
GamePlayer deserializedGamePlayer = SerializationHelper.Deserialize <GamePlayer>(serializedData);
Assert.IsNotNull(deserializedGamePlayer);
Hero hero = deserializedGamePlayer.Hero;
Assert.IsNotNull(hero);
Assert.AreEqual(1, hero.HeroID);
Assert.AreEqual(25, hero.RemainedHP);
Assert.AreEqual(30, hero.HP);
deserializedGamePlayer.ChangeHand(new int[0]);
Assert.AreEqual(true, deserializedGamePlayer.HasChangedHand);
GameDeck deck = deserializedGamePlayer.Deck;
Assert.IsNotNull(deck);
Assert.AreEqual(CardManager.Instance.Cards.Count(), deck.CardRecordIDs.Count());
foreach (var cardRecordID in deck.CardRecordIDs)
{
CardRecord record;
Assert.IsTrue(gameCardManager.FindCard(cardRecordID, out record));
Card settingCard;
Assert.IsTrue(CardManager.Instance.FindCard(record.Card.CardID, out settingCard));
Assert.AreEqual(settingCard.CardID, record.Card.CardID);
Assert.AreEqual(settingCard.CardName, record.Card.CardName);
}
}
//Players Place Bet and receive new cards
public void StartNewTurn()
{
foreach (var player in Players)
{
player.CardsInHand = (GameDeck.DealCards(2));
}
}
public void StartGame()
{
ResetData();
_CardCounter = FULL_DECK;
_CardPicker = new Random();
GameDeck = new GameDeck();
_IsGameOn = true;
PlayerInstance = new PlayerVM(this);
DealerInstance = new DealerVM(this);
PlayerInstance.Hand.Add(Draw());
PlayerInstance.Hand.Add(Draw());
DealerInstance.Hand.Add(Draw());
DealerInstance.Hand.Add(Draw());
///
///set up inital scores for
///initial hand
foreach (var card in _PlayerInstance.Hand)
{
_PlayerScore += card.CardWorth;
}
foreach (var card in _DealerInstance.Hand)
{
_DealerScore += card.CardWorth;
}
RaisePropertyChanged("IsGameOn");
RaisePropertyChanged("PlayerInstance");
RaisePropertyChanged("DealerInstance");
RaisePropertyChanged("PlayerScore");
RaisePropertyChanged("DealerScore");
}
public DurakGameClass(int deckSize, HumanPlayer playerData)
{
// Deck Setup
this.GameDeck = new Deck(true, true, deckSize);
// Setup Trump
this.TrumpCard = GameDeck.GetCard((PLAYER_COUNT * 6) + 1);
Card.trump = this.TrumpCard.suit;
GameDeck.RemoveCard((PLAYER_COUNT * 6) + 1);
// Player Setup
regularPlayer = playerData;
regularPlayer.dealPlayerHand(this.GameDeck);
//WriteLog("Player Hand:\n" + regularPlayer.Hand.ToString());
// Ai Setup
aiPlayer = new AIPlayer();
aiPlayer.dealPlayerHand(this.GameDeck);
//WriteLog("AI Hand:\n" + aiPlayer.Hand.ToString());
//Bout Setup
currentBout = new Bout();
// Determine First Attack
Random rand = new Random();
currentBout.playerTurn = rand.Next(0, 1);
}
public void NewGame()
{
while (CommunityCards.Size != 0)
{
GameDeck.Return(CommunityCards.Draw());
}
foreach (Player player in Players)
{
while (player.Hand.Size != 0)
{
GameDeck.Return(player.Hand.Draw());
}
}
for (int i = 0; i < ActivePlayers.Count; i++)
{
if (Players[i].Money > -500)
{
ActivePlayers[i] = true;
}
}
GameDeck.Shuffle();
for (int i = 0; i < ActivePlayers.Count; i++)
{
if (ActivePlayers[i])
{
Players[i].Hand.Return(GameDeck.Draw());
Players[i].Hand.Return(GameDeck.Draw());
}
}
IncrementBlindLocations();
}
async Task <GameDeckData> IGameDeckRepository.AddGameDeckAsync(int gameUserId, string name, string description, int[] cardIds, CancellationToken cancellationToken)
{
var gameDeck = new GameDeck
{
CreatedTime = DateTime.UtcNow,
Description = description,
GameUserFk = gameUserId,
Name = name,
};
if (cardIds != null)
{
gameDeck.GameDeckCardCollection = cardIds.Select(x => new GameDeckCardCollection
{
CardFk = x,
}).ToArray();
}
_context.GameDeck.Add(gameDeck);
await _context.SaveChangesAsync(cancellationToken : cancellationToken);
var data = new GameDeckData
{
CreatedTime = gameDeck.CreatedTime,
Description = description,
GameUserId = gameUserId,
Id = gameDeck.GameDeckPk,
Name = name,
};
return(data);
}
public static bool IsNearMMR(this GameDeck d1, GameDeck d2, double margin = 0.3)
{
var d1MMR = d1.MatachMakingRatio;
var mDown = d2.MatachMakingRatio - margin;
var mUp = d2.MatachMakingRatio + (margin * 1.2);
return(d1MMR >= mDown && d1MMR <= mUp);
}
public void shuffleGameDeck()
{
var rand = new Random();
GameDeck = GameDeck.OrderBy(x => rand.Next()).ToList();
//printDeck();
}
public void Shuffle()
{
ShuffledDeck = GameDeck.OrderBy(c => Guid.NewGuid()).ToList();
//foreach (Card card in ShuffledDeck)
//{
// Console.WriteLine(card.ShowCard());
//}
}
public static void RemoveCardFromWishList(this GameDeck deck, ulong id)
{
var en = deck.Wishes.FirstOrDefault(x => x.Type == WishlistObjectType.Card && x.ObjectId == id);
if (en != null)
{
deck.Wishes.Remove(en);
}
}
public GameStack(GameDeck b, string n, Canvas c, Rectangle r)
{
this.b = b;
Name = n;
PlayingCanvas = c;
BaseRect = r;
r.Width = MainWindow.cardWidth;
r.Height = MainWindow.cardHeight;
PlayingCards = new List <PlayingCard>();
}
public void DealFirstCards()
{
for (int i = 0; i < 2; i++)
{
foreach (Player player in Players)
{
player.Hand.Push(GameDeck.DrawCard());
}
}
}
public GamePlayer(Player player, Hero hero, GameDeck deck)
{
Player = player;
Hero = hero;
HasChangedHand = false;
RemainedManaCrystal = 0;
ManaCrystal = 0;
Deck = deck;
EventManager = new GamePlayerEventManager(this);
}
public void ProcessHouseTurn()
{
int handValue = GetHandValue(house.HouseHand);
if (handValue < 17)
{
Card card = GameDeck.Draw();
house.HouseHand.Return(card);
}
}
/// <summary>
/// Immutable Single player game.
/// Shuffles the deck of cards
/// Creates a list of players
/// Adds Dealer as player[0]
/// Adds another player
/// Deals initial cards
/// </summary>
public void InitializeNewGame()
{
GameDeck.Shuffle();
Players = new Players();
Dealer = new Player();
Dealer.Name = "Dealer";
Players.Add(Dealer);
Players.Add(new Player());
DealFirstRound();
}
public GameTable(IPlayer player, int minBet = 5)
{
NumberOfDecks = 8;
SizeOfDeck = 52;
MinBet = minBet;
Dealer = new Dealer();
GameDeck = new GameDeck(NumberOfDecks);
GameDeck.Shuffle();
Player = player;
}
public void SyncDeckCardsChanged(GameDeck deck, int cardRecordID, DataChangeCode changeCode)
{
Dictionary <byte, object> eventData = new Dictionary <byte, object>
{
{ (byte)SyncDeckCardsChangedParameterCode.DataChangeCode, (byte)changeCode },
{ (byte)SyncDeckCardsChangedParameterCode.CardRecordID, cardRecordID }
};
SendSyncData(GamePlayerSyncDataCode.DeckCardsChanged, eventData);
}
/*CONSTRUCTORS ----------------------------------------------------------------------------------------------------*/
/*Constructor: Default
* 1) Creates a default, shuffled PlayingDeck object */
public Fortune()
{
this.Id = 3;
this.GameType = "Fortune";
this.GameDeck = new TarotDeck();
GameDeck.Shuffle();
this.Players = new List <Player>();
this.Spread = new List <Card>();
this.DateToday = DateTime.Today;
}// end Default constructor
public void Hit()
{
Hand.Add(GameDeck.GiveCard());
Sum += (int)Hand[(Hand.Count - 1)];
if ((Sum > 21) && (Hand.IndexOf(CardsValue.Ace) >= 0))
{
Hand[Hand.IndexOf(CardsValue.Ace)] = Hand[Hand.IndexOf(CardsValue.Ace)] - 10;
Sum -= 10;
}
}
public void DrawCardTest()
{
// preparation
var dealer = new Dealer();
var gameDeck = new GameDeck(numberOfDecks);
// checking
Assert.IsNotNull(dealer.DrawCard(gameDeck));
}
public void Play(GameDeck gameDeck)
{
Cards[1].Flag = Visibility.Visible;
Points += Cards[1].GetPoints(Points);
while (Points < 17)
{
Cards.Add(DrawCard(gameDeck));
Points += Cards.Last()
.GetPoints(Points);
}
}
public GameDeck CreateGameDeck(int gameDeckID, Deck deck)
{
List <int> cardRecordIDs = new List <int>();
foreach (Card card in deck.Cards)
{
cardRecordIDs.Add(GameCardManager.CreateCardRecord(card).CardRecordID);
}
GameDeck gameDeck = new GameDeck(gameDeckID, cardRecordIDs);
gameDeck.Shuffle(100);
return(gameDeck);
}
public void ResetGameDeckTest()
{
// preparation
var dealer = new Dealer();
var gameDeck = new GameDeck(numberOfDecks);
var oldCards = gameDeck.Cards;
// checking
dealer.ResetGameDeck(gameDeck);
Assert.AreNotSame(oldCards, gameDeck.Cards);
}
public void InitializeNewGame(int NumberOfPlayers = 1)
{
GameDeck.Shuffle();
Players = new Players();
Dealer = new Player();
Dealer.Name = "Dealer";
Players.Add(Dealer);
for (int i = 0; i < NumberOfPlayers; i++)
{
Players.Add(new Player());
}
DealFirstCards();
}
public void ConstructorTest()
{
// preparation
int amountOfDecks = 8;
var deck = new GameDeck(amountOfDecks);
// checking
Assert.IsNotNull(deck);
Assert.IsNotNull(deck.Cards);
Assert.IsTrue(deck.Cards.Count == amountOfDecks * 52);
}
public static long GetPVPCoinsFromDuel(this GameDeck deck, FightResult res)
{
var step = (ExperienceManager.CalculateLevel(deck.SeasonalPVPRank, PVPRankMultiplier) / 10);
if (step > 5)
{
step = 5;
}
var coinCnt = 40 + (20 * step);
return((res == FightResult.Win) ? coinCnt : coinCnt / 2);
}
public void DrawTestMethod1()
{
GameDeck deck = new GameDeck(1, new List <int> {
1, 2
});
int cardRecordID;
Assert.IsTrue(deck.Draw(out cardRecordID));
Assert.AreEqual(1, cardRecordID);
Assert.IsTrue(deck.Draw(out cardRecordID));
Assert.AreEqual(2, cardRecordID);
Assert.IsFalse(deck.Draw(out cardRecordID));
Assert.AreEqual(0, cardRecordID);
}
/*PROPERTIES ------------------------------------------------------------------------------------------------------*/
/*CONSTRUCTORS ----------------------------------------------------------------------------------------------------*/
/*Constructor: Default
* 1) Creates a default, shuffled PlayingDeck object
* 2) Adds Player and Bot to List<Player> */
public GoFish()
{
this.Id = 2;
this.GameType = "GoFish";
this.GameDeck = new PlayingDeck();
GameDeck.Shuffle();
this.DateToday = DateTime.Today;
// can pass the selected Player to this list when creating the game window
this.Players = new List <Player>();
Player bot = new Player("Botty"); // adding a Bot to play against for now
Players.Add(bot);
}// end Default constructor
