public Dealer(rules.RulesFactory a_rulesFactory)
{
m_newGameRule = a_rulesFactory.GetNewGameRule();
m_hitRule = a_rulesFactory.GetHitRule();
m_winnerRule = a_rulesFactory.GetWinnerRule();
m_deckFactory = new DeckFactory();
}
public static Game CreateGame(IEnumerable <IPlayer> players)
{
var dice = new MonopolyDice();
var banker = new Banker(players);
var realEstateHandler = new OwnableHandler(BoardFactory.CreateRealEstate(dice), banker);
var spaces = BoardFactory.CreateNonRealEstateSpaces(banker);
var spaceHandler = new UnownableHandler(spaces);
var boardHandler = new BoardHandler(players, realEstateHandler, spaceHandler, banker);
var jailHandler = new JailHandler(dice, boardHandler, banker);
var turnHandler = new TurnHandler(dice, boardHandler, jailHandler, realEstateHandler, banker);
var deckFactory = new DeckFactory(players, jailHandler, boardHandler, realEstateHandler, banker);
var communityChest = deckFactory.BuildCommunityChestDeck();
var chance = deckFactory.BuildChanceDeck(dice);
foreach (var space in spaces.Values.OfType <DrawCard>())
{
if (space.ToString() == "Community Chest")
{
space.AddDeck(communityChest);
}
else
{
space.AddDeck(chance);
}
}
return(new Game(players, turnHandler, banker));
}
// Use this for initialization
void Start()
{
var bytes = new byte[10];
new RNGCryptoServiceProvider().GetBytes(bytes);
_shuffleSeeds = bytes.Select(a => (int)a).ToList();
var deckFactory = new DeckFactory(new MBCardFactory(CardPrefab));
_handFactory = new HandFactory(deckFactory, _shuffleSeeds);
FourPlayer.OnPlayerJoined += player =>
{
DebugConsole.Log(String.Format("player {0} joined", player.Id));
_players.Add(player);
};
FourPlayer.OnPlayerLeft += player =>
{
DebugConsole.Log(String.Format("player {0} left", player.Id));
_players.Remove(player);
};
SeatManager.OnAllPlayersSeated += () =>
{
DebugConsole.Log("All Players Seated, starting game.");
_firstPlayerToBid = _players.Shuffle(new Random()).First().Id;
_playersSeated = true;
};
}
private bool IsDeckShuffled(Deck deck)
{
// a quick and dirty check for randomization; this will fail on average once every couple thousand
// times through pure chance, even if the cards have been shuffled correctly
bool isShuffled = true;
ICard card1 = deck.GetNextCard();
ICard card2 = deck.GetNextCard();
Deck unshuffledDeck = DeckFactory.CreateBasicDeck();
try
{
Assert.IsFalse(card1.Name == unshuffledDeck.Cards[0].Name && card1.Suit == unshuffledDeck.Cards[0].Suit);
}
catch (AssertFailedException)
{
try
{
Assert.IsFalse(card2.Name == unshuffledDeck.Cards[1].Name && card2.Suit == unshuffledDeck.Cards[1].Suit);
}
catch (AssertFailedException)
{
isShuffled = false;
}
}
return(isShuffled);
}
public void DealTest_PokerDeck()
{
// arrange
Deck deck = DeckFactory.CreatePokerDeck();
Player player = new Player();
// arrange/act
Assert.AreEqual(deck.Size, 54);
ICard card = deck.GetNextCard();
Assert.IsInstanceOfType(card, typeof(Card));
player.Hand.AddCard(card);
Assert.AreEqual(player.Hand.Size, 1);
Assert.AreEqual(deck.Size, 53);
card = deck.GetNextCard();
Assert.IsInstanceOfType(card, typeof(Card));
player.Hand.AddCard(card);
Assert.AreEqual(player.Hand.Size, 2);
Assert.AreEqual(deck.Size, 52);
card = deck.GetNextCard();
Assert.IsInstanceOfType(card, typeof(Card));
player.Hand.AddCard(card);
Assert.AreEqual(player.Hand.Size, 3);
Assert.AreEqual(deck.Size, 51);
}
public void CreateStartingDeck(AbilityCardDeckConfig deckConfig)
{
Debug.Log("Building starting Ability deck");
AbilityCardDeck = DeckFactory.CreateDeck(deckConfig.Cards);
Debug.Log("Ability Deck count after build: " + AbilityCardDeck.Count);
AbilityCardDeck.Emptied += OnAbilityDeckEmptied;
}
public void BlackjackShuffleTransactionTest_PokerDeck()
{
// arrange
Deck.Instance = DeckFactory.CreatePokerDeck();
List <Player> players = new List <Player>();
Player alex = new Player {
Name = "Alex"
};
Player bill = new Player {
Name = "Bill"
};
Player charlie = new Player {
Name = "Charlie"
};
players.Add(alex);
players.Add(bill);
players.Add(charlie);
Shuffle shuffle = new Shuffle(bill);
// act
shuffle.Execute();
// assert
Assert.IsTrue(IsDeckShuffled(Deck.Instance));
}
private bool HasHighestKnownInHand(string suit)
{
var cards = DeckFactory.CreateCardDeck()
.Where(x => x.Suit == suit)
.Where(x => !Logic.PlayedCards.Contains(x))
.OrderByDescending(x => x.Rank)
.ToList();
return(cards.Count != 0 && Logic.HandCards.Contains(cards.First()));
}
public Board(IDice dice)
{
var deckFactory = new DeckFactory();
var utilityFactory = new UtilityFactory(this, dice);
var railroadFactory = new RailroadFactory(this);
var realEstateFactory = new RealEstateFactory(this);
var cardLocationFactory = new CardLocationFactory(deckFactory);
var nullLocationFactory = new NullLocationFactory();
var genericLocationFactory = new GenericLocationFactory();
Locations = new[]
{
genericLocationFactory.Create(LocationConstants.GoIndex, new DepositAction(MonopolyConstants.GoPayoutAmount), new DepositAction(MonopolyConstants.GoPayoutAmount)),
realEstateFactory.Create(LocationConstants.MediterraneanAveIndex),
cardLocationFactory.CreateCommunityChestLocation(LocationConstants.CommunityChestIndex1),
realEstateFactory.Create(LocationConstants.BalticAveIndex),
genericLocationFactory.Create(LocationConstants.IncomeTaxIndex, new IncomeTaxAction(MonopolyConstants.IncomeTaxRate, MonopolyConstants.IncomeTaxMaximumAmount)),
railroadFactory.Create(LocationConstants.ReadingRailroadIndex),
realEstateFactory.Create(LocationConstants.OrientalAveIndex),
cardLocationFactory.CreateChanceLocation(LocationConstants.ChanceIndex1),
realEstateFactory.Create(LocationConstants.VermontAveIndex),
realEstateFactory.Create(LocationConstants.ConnecticutAveIndex),
nullLocationFactory.Create(10),
realEstateFactory.Create(LocationConstants.StCharlesPlaceIndex),
utilityFactory.Create(LocationConstants.ElectricCompanyIndex),
realEstateFactory.Create(LocationConstants.StatesAveIndex),
realEstateFactory.Create(LocationConstants.VirginiaAveIndex),
railroadFactory.Create(LocationConstants.PennsylvaniaRailroadIndex),
realEstateFactory.Create(LocationConstants.StJamesPlaceIndex),
cardLocationFactory.CreateCommunityChestLocation(LocationConstants.CommunityChestIndex2),
realEstateFactory.Create(LocationConstants.TennesseeAveIndex),
realEstateFactory.Create(LocationConstants.NewYorkAveIndex),
nullLocationFactory.Create(20),
realEstateFactory.Create(LocationConstants.KentuckyAveIndex),
cardLocationFactory.CreateChanceLocation(LocationConstants.ChanceIndex2),
realEstateFactory.Create(LocationConstants.IndianaAveIndex),
realEstateFactory.Create(LocationConstants.IllinoisAveIndex),
railroadFactory.Create(LocationConstants.BAndORailroadIndex),
realEstateFactory.Create(LocationConstants.AtlanticAveIndex),
realEstateFactory.Create(LocationConstants.VentnorAveIndex),
utilityFactory.Create(LocationConstants.WaterWorksIndex),
realEstateFactory.Create(LocationConstants.MarvinGardensIndex),
genericLocationFactory.Create(LocationConstants.GoToJailIndex, new GoToJailAction()),
realEstateFactory.Create(LocationConstants.PacificAveIndex),
realEstateFactory.Create(LocationConstants.NorthCarolinaAveIndex),
cardLocationFactory.CreateCommunityChestLocation(LocationConstants.CommunityChestIndex3),
realEstateFactory.Create(LocationConstants.PennsylvaniaAveIndex),
railroadFactory.Create(LocationConstants.ShortLineRailroadIndex),
cardLocationFactory.CreateChanceLocation(LocationConstants.ChanceIndex3),
realEstateFactory.Create(LocationConstants.ParkPlaceIndex),
genericLocationFactory.Create(LocationConstants.LuxuryTaxIndex, new WithdrawAction(MonopolyConstants.LuxuryTaxAmount)),
realEstateFactory.Create(LocationConstants.BoardwalkIndex)
};
}
public void Setup()
{
var players = new[] { new Player("Player") };
var banker = new Banker(players);
var realEstateHandler = new OwnableHandler(new Dictionary <Int32, OwnableSpace>(), banker);
var boardHandler = FakeHandlerFactory.CreateBoardHandlerForFakeBoard(players, realEstateHandler, banker);
var dice = new ControlledDice();
var jailHandler = new JailHandler(dice, boardHandler, banker);
var deckFactory = new DeckFactory(players, jailHandler, boardHandler, realEstateHandler, banker);
deck = deckFactory.BuildChanceDeck(dice);
}
public void Setup()
{
var players = new[] { new Player("Player") };
var dice = new ControlledDice();
var realEstateHandler = FakeHandlerFactory.CreateEmptyRealEstateHandler(players);
var banker = new Banker(players);
var boardHandler = FakeHandlerFactory.CreateBoardHandlerForFakeBoard(players, realEstateHandler, banker);
var jailHandler = new JailHandler(dice, boardHandler, banker);
var deckFactory = new DeckFactory(players, jailHandler, boardHandler, realEstateHandler, banker);
deck = deckFactory.BuildCommunityChestDeck();
}
public void ShuffleTest_PokerDeck()
{
// arrange
Deck deck = DeckFactory.CreatePokerDeck();
// act
deck.Shuffle();
// assert
CollectionAssert.AllItemsAreNotNull(deck.Cards);
CollectionAssert.AllItemsAreUnique(deck.Cards);
Assert.AreEqual(deck.Cards.Count, deck.Size);
}
protected override void Seed(BlackJack.DataAccess.ApplicationDbContext context)
{
// This method will be called after migrating to the latest version.
// You can use the DbSet<T>.AddOrUpdate() helper extension method
// to avoid creating duplicate seed data.
List <Card> deck = DeckFactory.CreateDeck();
foreach (var card in deck)
{
context.Cards.AddOrUpdate(card);
}
context.SaveChanges();
}
public void ShuffleTest_BasicDeck()
{
// arrange
var deck = DeckFactory.CreateBasicDeck();
// act
deck.Shuffle();
// assert
CollectionAssert.AllItemsAreNotNull(deck.Cards);
CollectionAssert.AllItemsAreUnique(deck.Cards);
Assert.AreEqual(deck.Cards.Count, deck.Size);
Assert.IsTrue(IsDeckShuffled(deck));
}
private void button_Click(object sender, RoutedEventArgs e)
{
players = new List <Player>();
currentDealerCards = new List <Card>();
currentDeck = DeckFactory.CreateDeck().Shuffle();
button.IsEnabled = false;
publisher.Publish(publishTopic, Event.GameStart, TimeSpan.FromSeconds(10));
Task.Factory.StartNew(() =>
{
Thread.Sleep(10000);
Dispatcher.Invoke(HandoutCards);
});
}
public Board()
{
mBoardSize = 12;
mDeck = DeckFactory.BuildDeck();
Random random = new Random();
Cards = new List <CardModel>();
for (int ctr = 0; ctr < mBoardSize; ctr++)
{
int index = random.Next(mDeck.Size);
Cards.Add(mDeck.Cards[index]);
}
}
private Dictionary <int, List <string> > Deal()
{
var deck = DeckFactory.CreateStringDeck();
var result = new Dictionary <int, List <string> >();
for (var p = 1; p <= 4; p++)
{
result[p] = deck.OrderBy(x => Guid.NewGuid()).Take(13).ToList();
foreach (var card in result[p])
{
deck.Remove(card);
}
}
return(result);
}
public void Setup()
{
player = new Player("name");
var players = new[] { player };
var realEstateHandler = FakeHandlerFactory.CreateEmptyRealEstateHandler(players);
var boardHandler = FakeHandlerFactory.CreateBoardHandlerForFakeBoard(players, realEstateHandler, banker);
var dice = new ControlledDice();
banker = new Banker(players);
var jailHandler = new JailHandler(dice, boardHandler, banker);
var deckFactory = new DeckFactory(players, jailHandler, boardHandler, realEstateHandler, banker);
deck = deckFactory.BuildCommunityChestDeck();
drawCard = new DrawCard("draw card");
drawCard.AddDeck(deck);
}
private string createDatabase(string path)
{
try
{
connection = new SQLiteConnection(new SQLitePlatformAndroid(), path);
connection.DropTable <Deck>();
connection.DropTable <SubDeck>();
connection.DropTable <Card>();
connection.CreateTable <Deck>();
connection.CreateTable <SubDeck>();
connection.CreateTable <Card>();
var d = DeckFactory.CreateTestDeck(connection);
return("Database created");
}
catch (SQLiteException ex)
{
return(ex.Message);
}
}
void Temp_SetupSinglePlayer()
{
var match = container.GetMatch();
match.players [0].mode = ControlModes.Local;
match.players [1].mode = ControlModes.Computer;
foreach (Player p in match.players)
{
var deck = DeckFactory.CreateDeck("DemoDeck", p.index);
p [Zones.Deck].AddRange(deck);
var hero = new Hero();
hero.hitPoints = hero.maxHitPoints = 30;
hero.allowedAttacks = 1;
hero.ownerIndex = p.index;
hero.zone = Zones.Hero;
p.hero.Add(hero);
}
}
public void ShuffleDrawPile()
{
DrawPile = DeckFactory.CreateDrawableDeck(DiscardPile.Cards);
DiscardPile = DeckFactory.CreateDefaultPlayableDeck();
}
public void BlackjackDealTransactionTest_PokerDeck()
{
Deck.Instance = DeckFactory.CreatePokerDeck();
BlackjackDealTransactionTest();
}
public static void Main(string[] args)
{
try {
Console.WriteLine("WildCards ..");
Console.WriteLine();
Deck deck = DeckFactory.buildFrench52();
Stack stack = deck.Stack;
Console.WriteLine("Fresh deck:");
Console.WriteLine();
foreach (Card card in stack)
{
Console.Write(card.ID + " ");
// Console.Write( card.Color + " " );
// Console.Write( card.Value + " " );
// Console.Write( card.XML );
// Console.WriteLine();
} // loop
Console.WriteLine();
Console.WriteLine();
Console.WriteLine("Shuffled deck:");
Console.WriteLine();
Shuffler shuffler = new Shuffler();
Behaviours behaviours = Cards.Shuffling.Factory.buildRandomly( );
foreach (Cards.Shuffling.Behaviour behaviour in behaviours)
{
shuffler.add(behaviour);
} // loop
stack = shuffler.shuffle(stack);
foreach (Card card in stack)
{
Console.Write(card.ID + " ");
// Console.Write( card.Color + " " );
// Console.Write( card.Value + " " );
// Console.Write( card.XML );
// Console.WriteLine();
} // loop
Console.WriteLine();
Console.WriteLine();
Console.WriteLine("Sorted deck:");
Console.WriteLine();
stack.sort();
foreach (Card card in stack)
{
Console.Write(card.ID + " ");
// Console.Write( card.Color + " " );
// Console.Write( card.Value + " " );
// Console.Write( card.XML );
// Console.WriteLine();
} // loop
Console.WriteLine();
Console.WriteLine();
} catch (Exception e) {
Console.WriteLine();
Console.WriteLine(e.StackTrace);
Console.WriteLine(e.Message);
} // try
} // method
public DeckServiceTests()
{
_shuffler = Substitute.For <IShuffler>();
_factory = new DeckFactory(_shuffler);
}
