Esempio n. 1
0
 public TransactionalProperty(Int32 boardLocation, IBanker bank, String name, Int32 price, Int32?rent)
     : base(boardLocation, name)
 {
     this.banker = bank;
     this.Price  = price;
     this.Rent   = rent;
 }
Esempio n. 2
0
        public void TestInitialize()
        {
            dice   = new Dice();
            banker = new Banker();
            board  = new Board(banker, dice);
            player = new Player("test");
            owner  = new Player("Owner");
            banker.AddAccount(owner, 1500);

            railRoad1 = new RailRoadProperty(5, banker, "railRoad1", 200);
            railRoad2 = new RailRoadProperty(15, banker, "railRoad2", 200);
            railRoad3 = new RailRoadProperty(25, banker, "railRoad3", 200);
            railRoad4 = new RailRoadProperty(35, banker, "railRoad4", 200);
            var groupedSpaces = new List <IOwnableProperty>()
            {
                railRoad1, railRoad2, railRoad3, railRoad4
            };

            railRoad1.GroupedSpaces = groupedSpaces;
            railRoad2.GroupedSpaces = groupedSpaces;
            railRoad3.GroupedSpaces = groupedSpaces;
            railRoad4.GroupedSpaces = groupedSpaces;

            dice.Roll();
        }
        public void Setup()
        {
            player = new Player("Player");
            var players = new[] { player };

            dice = new ControlledDice();
            var realEstateHandler = FakeHandlerFactory.CreateEmptyRealEstateHandler(players);

            landableSpaces = new Dictionary <Int32, UnownableSpace>();

            for (var i = 0; i < BoardConstants.BOARD_SIZE; i++)
            {
                landableSpaces.Add(i, new LandableSpace());
            }

            space6  = landableSpaces[6] as LandableSpace;
            space10 = landableSpaces[10] as LandableSpace;

            var spaceHandler = new UnownableHandler(landableSpaces);

            banker       = new Banker(players);
            boardHandler = new BoardHandler(players, realEstateHandler, spaceHandler, banker);
            jailHandler  = new JailHandler(dice, boardHandler, banker);
            turnHandler  = new TurnHandler(dice, boardHandler, jailHandler, realEstateHandler, banker);
        }
Esempio n. 4
0
        public void Setup()
        {
            player = new Player("name");
            banker = new Banker(new[] { player });

            collectCard = new FlatCollectCard("collect", 10, banker);
        }
        public void Setup()
        {
            player = new Player("name");
            banker = new Banker(new[] { player });

            collectCard = new FlatCollectCard("collect", 10, banker);
        }
Esempio n. 6
0
 public TaskHandler(IRealtor realtor, List<IPlayer> players, IMovementHandler movementHandler, IBanker banker, IDice dice)
 {
     this.movementHandler = movementHandler;
     this.players = players;
     this.banker = banker;
     this.dice = dice;
 }
Esempio n. 7
0
        public void Setup()
        {
            player = new Player("name");
            banker = new Banker(new[] { player });

            payCard = new FlatPayCard("pay", 10, banker);
        }
Esempio n. 8
0
        public void Setup()
        {
            player = new Player("name");
            player.OwnableStrategy = new RandomlyBuyOrMortgage();
            var owner = new Player("owner");

            owner.OwnableStrategy = new RandomlyBuyOrMortgage();

            var players = new[] { player, owner };

            var dice       = new ControlledDice();
            var realEstate = BoardFactory.CreateRealEstate(dice);

            banker = new Banker(players);
            var realEstateHandler = new OwnableHandler(realEstate, banker);

            boardHandler = FakeHandlerFactory.CreateBoardHandlerForFakeBoard(players, realEstateHandler, banker);

            foreach (var rxr in realEstate.Values.OfType <Railroad>())
            {
                realEstateHandler.Land(owner, realEstate.Keys.First(k => realEstate[k] == rxr));
            }

            railroadCard = new MoveToNearestRailroadCard(boardHandler);
        }
Esempio n. 9
0
 public Utility(Int32 index, String name, Int32 cost, Int32 rent, IBanker banker,
                IEnumerable<Utility> utilities, IDice dice)
     : base(index, name, cost, rent, banker)
 {
     this.utilities = utilities;
     this.dice = dice;
 }
Esempio n. 10
0
        public void TestInitiaize()
        {
            banker = new Banker();
            player = new Player("test");

            banker.AddAccount(player, playerDefaultBalance);
        }
Esempio n. 11
0
 public Utility(Int32 index, String name, Int32 cost, Int32 rent, IBanker banker,
                IEnumerable <Utility> utilities, IDice dice)
     : base(index, name, cost, rent, banker)
 {
     this.utilities = utilities;
     this.dice      = dice;
 }
        public void Setup()
        {
            player = new Player("name");
            banker = new Banker(new[] { player });

            payCard = new FlatPayCard("pay", 10, banker);
        }
Esempio n. 13
0
        public void TestInitialize()
        {
            banker = new Banker();
            go     = new Go(0, banker, "Go");
            player = new Player("player");

            banker.AddAccount(player, 1500);
        }
Esempio n. 14
0
 public Property(Int32 index, String name, Int32 cost, Int32 rent, IBanker banker)
     : base(index, name)
 {
     this.rent = rent;
     this.cost = cost;
     this.banker = banker;
     IsOwned = false;
 }
Esempio n. 15
0
        public void TestInitialize()
        {
            player    = new Player("player");
            banker    = new Banker();
            luxuryTax = new LuxuryTax(2, banker, "LuxuryTax");

            banker.AddAccount(player, 500);
        }
Esempio n. 16
0
 public Property(Int32 index, String name, Int32 cost, Int32 rent, IBanker banker)
     : base(index, name)
 {
     this.rent   = rent;
     this.cost   = cost;
     this.banker = banker;
     IsOwned     = false;
 }
 public HousesAndHotelsCard(String name, Int32 houseCost, Int32 hotelCost, IOwnableHandler realEstateHandler, IBanker banker)
 {
     this.name = name;
     this.houseCost = houseCost;
     hotelPremium = hotelCost - houseCost;
     this.realEstateHandler = realEstateHandler;
     this.banker = banker;
 }
Esempio n. 18
0
 public ChanceFactory(IBanker banker, IJailRoster jailRoster, 
     GameBoard board, IDice dice)
 {
     this.banker = banker;
     this.jailRoster = jailRoster;
     this.board = board;
     this.dice = dice;
 }
Esempio n. 19
0
 public HousesAndHotelsCard(String name, Int32 houseCost, Int32 hotelCost, IOwnableHandler realEstateHandler, IBanker banker)
 {
     this.name              = name;
     this.houseCost         = houseCost;
     hotelPremium           = hotelCost - houseCost;
     this.realEstateHandler = realEstateHandler;
     this.banker            = banker;
 }
Esempio n. 20
0
        public void TestInitialize()
        {
            player    = new Player("player");
            banker    = new Banker();
            incomeTax = new IncomeTax(2, banker, "IncomeTax");

            banker.AddAccount(player, 500);
        }
        public static IOwnableHandler CreateRealEstateHandler(IEnumerable<OwnableSpace> realEstate, IEnumerable<IPlayer> players, IBanker banker)
        {
            var dict = new Dictionary<Int32, OwnableSpace>();
            for (var i = 0; i < realEstate.Count(); i++)
                dict.Add(i, realEstate.ElementAt(i));

            return new OwnableHandler(dict, banker);
        }
Esempio n. 22
0
 public ChanceFactory(IBanker banker, IJailRoster jailRoster,
                      GameBoard board, IDice dice)
 {
     this.banker     = banker;
     this.jailRoster = jailRoster;
     this.board      = board;
     this.dice       = dice;
 }
Esempio n. 23
0
 public GoToJail(Int32 index, String name, Int32 jailIndex, IBanker banker,
                 IJailRoster jailRoster, IBoard board)
     : base(index, name)
 {
     this.jailIndex  = jailIndex;
     this.jailRoster = jailRoster;
     this.board      = board;
 }
Esempio n. 24
0
 public GoToJail(Int32 index, String name, Int32 jailIndex, IBanker banker,
                 IJailRoster jailRoster, IBoard board)
     : base(index, name)
 {
     this.jailIndex = jailIndex;
     this.jailRoster = jailRoster;
     this.board = board;
 }
Esempio n. 25
0
 public TurnHandler(IDice dice, IBoardHandler boardHandler, IJailHandler jailHandler, IOwnableHandler realEstateHandler, IBanker banker)
 {
     this.dice = dice;
     this.boardHandler = boardHandler;
     this.jailHandler = jailHandler;
     this.realEstateHandler = realEstateHandler;
     this.banker = banker;
 }
Esempio n. 26
0
        public void TestInitialize()
        {
            player = new Player("test");

            dice   = new Dice();
            banker = new Banker();
            board  = new Board(banker, dice);
        }
Esempio n. 27
0
 public TurnHandler(IDice dice, IBoardHandler boardHandler, IJailHandler jailHandler, IOwnableHandler realEstateHandler, IBanker banker)
 {
     this.dice              = dice;
     this.boardHandler      = boardHandler;
     this.jailHandler       = jailHandler;
     this.realEstateHandler = realEstateHandler;
     this.banker            = banker;
 }
Esempio n. 28
0
        public JailHandler(IDice dice, IBoardHandler boardHandler, IBanker banker)
        {
            this.dice = dice;
            this.boardHandler = boardHandler;
            this.banker = banker;

            turnsInJail = new Dictionary<IPlayer, Int16>();
            cards = new Dictionary<GetOutOfJailFreeCard, IPlayer>(2);
        }
Esempio n. 29
0
        public JailHandler(IDice dice, IBoardHandler boardHandler, IBanker banker)
        {
            this.dice         = dice;
            this.boardHandler = boardHandler;
            this.banker       = banker;

            turnsInJail = new Dictionary <IPlayer, Int16>();
            cards       = new Dictionary <GetOutOfJailFreeCard, IPlayer>(2);
        }
Esempio n. 30
0
 public TurnHandler(IJailer jailer, IBanker banker, IMovementHandler movementHandler, IDice dice,
     ICardHandler cardHandler)
 {
     this.jailer = jailer;
     this.banker = banker;
     this.movementHandler = movementHandler;
     this.dice = dice;
     this.cardHandler = cardHandler;
 }
Esempio n. 31
0
 public void SetUp()
 {
     playerId = 0;
     var faker = new MotherFaker();
     banker = faker.Banker;
     board = new GameBoard(banker);
     board.SetLocations(faker.LocationFactory.GetLocations(), faker.LocationFactory.GetRailroads(),
         faker.LocationFactory.GetUtilities());
 }
Esempio n. 32
0
        public CommandInterpreter(IBanker banker, IDialogConsole dialogConsole)
        {
            _availableActions = Enum.GetValues(typeof(ActionEnum)).Cast <ActionEnum>().ToList();

            _interpreterMapping = new Dictionary <ActionEnum, Func <AbstractDialogInterpreter> >();
            _interpreterMapping.Add(ActionEnum.Withdraw, () => new WithdrawDialogInterpreter(banker, dialogConsole));
            _interpreterMapping.Add(ActionEnum.Deposit, () => new DepositDialogInterpreter(banker, dialogConsole));
            _interpreterMapping.Add(ActionEnum.Balance, () => new BalanceDialogInterpreter(banker, dialogConsole));
            _interpreterMapping.Add(ActionEnum.History, () => new HistoryDialogInterpreter(banker, dialogConsole));
        }
Esempio n. 33
0
        public void TestInitialize()
        {
            banker = new Banker();
            dice   = new Dice();
            board  = new Board(banker, dice);
            deck   = new Deck(banker, board);

            chanceCards         = new Queue <ICard>(16);
            communityChestCards = new Queue <ICard>(16);
        }
        public void Setup()
        {
            player = new Player("name");
            var players = new[] { player };
            banker = new Banker(players);
            var realEstateHandler = FakeHandlerFactory.CreateEmptyRealEstateHandler(players);
            boardHandler = FakeHandlerFactory.CreateBoardHandlerForFakeBoard(players, realEstateHandler, banker);

            passGoCard = new MoveAndPassGoCard("move", BoardConstants.ATLANTIC_AVENUE, boardHandler);
        }
Esempio n. 35
0
        public void SetUp()
        {
            playerId = 0;
            var faker = new MotherFaker();

            banker = faker.Banker;
            board  = new GameBoard(banker);
            board.SetLocations(faker.LocationFactory.GetLocations(), faker.LocationFactory.GetRailroads(),
                               faker.LocationFactory.GetUtilities());
        }
        public static IBoardHandler CreateBoardHandlerForFakeBoard(IEnumerable<IPlayer> players, IOwnableHandler realEstateHandler, IBanker banker)
        {
            var normalSpaces = new Dictionary<Int32, UnownableSpace>();
            for (var i = 0; i < BoardConstants.BOARD_SIZE; i++)
                normalSpaces.Add(i, new NormalSpace("space " + i));

            var spaceHandler = new UnownableHandler(normalSpaces);

            return new BoardHandler(players, realEstateHandler, spaceHandler, banker);
        }
Esempio n. 37
0
        public Deck(IBanker banker, IBoard board)
        {
            this.banker = banker;
            this.board  = board;

            ChanceCards         = new Queue <ICard>(16);
            CommunityChestCards = new Queue <ICard>(16);

            InitializeCards();
        }
Esempio n. 38
0
 public DeckFactory(IEnumerable<IPlayer> players, 
                    IJailHandler jailHandler, IBoardHandler boardHandler, IOwnableHandler realEstateHandler, IBanker banker)
 {
     random = new Random();
     this.jailHandler = jailHandler;
     this.players = players;
     this.boardHandler = boardHandler;
     this.realEstateHandler = realEstateHandler;
     this.banker = banker;
 }
Esempio n. 39
0
        public BoardHandler(IEnumerable<IPlayer> players, IOwnableHandler realEstateHandler, IUnownableHandler spaceHandler, IBanker banker)
        {
            this.realEstateHandler = realEstateHandler;
            this.spaceHandler = spaceHandler;
            this.banker = banker;

            PositionOf = new Dictionary<IPlayer, Int32>();
            foreach (var player in players)
                PositionOf.Add(player, 0);
        }
Esempio n. 40
0
 public DeckFactory(IEnumerable <IPlayer> players,
                    IJailHandler jailHandler, IBoardHandler boardHandler, IOwnableHandler realEstateHandler, IBanker banker)
 {
     random                 = new Random();
     this.jailHandler       = jailHandler;
     this.players           = players;
     this.boardHandler      = boardHandler;
     this.realEstateHandler = realEstateHandler;
     this.banker            = banker;
 }
        public OwnableHandler(Dictionary<Int32, OwnableSpace> ownableSpaces, IBanker banker)
        {
            allOwnableSpaces = ownableSpaces;
            this.banker = banker;
            NO_OWNER = new Player("NOT AN OWNER");

            ownedSpaces = new Dictionary<OwnableSpace, IPlayer>();
            foreach (var ownableSpace in ownableSpaces.Values)
                ownedSpaces.Add(ownableSpace, NO_OWNER);
        }
Esempio n. 42
0
 public void SetUp()
 {
     playerOneId = 0;
     playerTwoId = 1;
     dice = new FakeDice(new [] { new FakeRoll(7, 3) });
     banker = new TraditionalBanker(new [] { playerOneId, playerTwoId });
     var utilities = new List<Utility>();
     electric = new Utility(12, "Electric Company", 150, 0, banker, utilities, dice);
     waterWorks = new Utility(28, "Water Works", 150, 0, banker, utilities, dice);
     utilities.AddRange(new Utility[] { electric, waterWorks });
 }
        public void Setup()
        {
            player = new Player("name");
            renter = new Player("renter");
            var players = new[] { player, renter };

            var property = new Property("property", 1, 0, GROUPING.DARK_BLUE, 1, new[] { 1, 2, 3, 4, 5 });

            banker            = new Banker(players);
            realEstateHandler = FakeHandlerFactory.CreateRealEstateHandler(new[] { property }, players, banker);
        }
Esempio n. 44
0
        public void SetUp()
        {
            playerOneId = 0;
            playerTwoId = 1;
            banker = new TraditionalBanker(new[] { playerOneId, playerTwoId });
            var purpleStreets = new List<Street>();
            mediterranean = new Street(1, "Mediterranean Avenue", 60, 2, banker, purpleStreets);
            baltic = new Street(3, "Baltic Avenue", 60, 4, banker, purpleStreets);

            purpleStreets.AddRange(new Street[] { mediterranean, baltic });
        }
Esempio n. 45
0
        public void TestInitialize()
        {
            dice   = new Dice();
            banker = new Banker();
            board  = new Board(banker, dice);
            var turnHandler  = new TurnHandler(board, banker, dice);
            var roundHandler = new RoundHandler(turnHandler);

            game   = new Game(banker, roundHandler);
            player = game.CreatePlayerAccount("Test");
        }
Esempio n. 46
0
        public void Setup()
        {
            player = new Player("name");
            var players = new[] { player };

            banker = new Banker(players);
            var realEstateHandler = FakeHandlerFactory.CreateEmptyRealEstateHandler(players);

            boardHandler = FakeHandlerFactory.CreateBoardHandlerForFakeBoard(players, realEstateHandler, banker);

            passGoCard = new MoveAndPassGoCard("move", BoardConstants.ATLANTIC_AVENUE, boardHandler);
        }
Esempio n. 47
0
        public void SetUp()
        {
            playerOneId = 0;
            playerTwoId = 1;
            dice        = new FakeDice(new [] { new FakeRoll(7, 3) });
            banker      = new TraditionalBanker(new [] { playerOneId, playerTwoId });
            var utilities = new List <Utility>();

            electric   = new Utility(12, "Electric Company", 150, 0, banker, utilities, dice);
            waterWorks = new Utility(28, "Water Works", 150, 0, banker, utilities, dice);
            utilities.AddRange(new Utility[] { electric, waterWorks });
        }
Esempio n. 48
0
        public void Setup()
        {
            player = new Player("name");
            player.OwnableStrategy = new AlwaysBuyOrMortgage();
            renter = new Player("renter");
            renter.OwnableStrategy = new RandomlyBuyOrMortgage();
            var players = new[] { player, renter };

            banker         = new Banker(players);
            property       = new Property("name", 10, 1, GROUPING.DARK_BLUE, 2, new[] { 4, 5, 6, 7, 8 });
            ownableHandler = FakeHandlerFactory.CreateRealEstateHandler(new[] { property }, players, banker);
        }
Esempio n. 49
0
        public BoardHandler(IEnumerable <IPlayer> players, IOwnableHandler realEstateHandler, IUnownableHandler spaceHandler, IBanker banker)
        {
            this.realEstateHandler = realEstateHandler;
            this.spaceHandler      = spaceHandler;
            this.banker            = banker;

            PositionOf = new Dictionary <IPlayer, Int32>();
            foreach (var player in players)
            {
                PositionOf.Add(player, 0);
            }
        }
        public void Setup()
        {
            player = new Player("name");
            var players = new[] { player };

            var dice = new ControlledDice();
            banker = new Banker(players);
            var realEstateHandler = FakeHandlerFactory.CreateEmptyRealEstateHandler(players);
            var boardHandler = FakeHandlerFactory.CreateBoardHandlerForFakeBoard(players, realEstateHandler, banker);
            jailHandler = new JailHandler(dice, boardHandler, banker);
            getOutOfJailCard = new GetOutOfJailFreeCard(jailHandler);
        }
        public void SetupPlayerWithStrategy()
        {
            dice = new ControlledDice();

            player = new Player("name");

            var players = new[] { player };
            banker = new Banker(players);
            var realEstateHandler = FakeHandlerFactory.CreateEmptyRealEstateHandler(players);
            boardHandler = FakeHandlerFactory.CreateBoardHandlerForFakeBoard(players, realEstateHandler, banker);
            jailHandler = new JailHandler(dice, boardHandler, banker);
        }
Esempio n. 52
0
        public void SetUp()
        {
            playerOneId = 0;
            playerTwoId = 1;
            banker      = new TraditionalBanker(new[] { playerOneId, playerTwoId });
            var purpleStreets = new List <Street>();

            mediterranean = new Street(1, "Mediterranean Avenue", 60, 2, banker, purpleStreets);
            baltic        = new Street(3, "Baltic Avenue", 60, 4, banker, purpleStreets);

            purpleStreets.AddRange(new Street[] { mediterranean, baltic });
        }
Esempio n. 53
0
        public Game(IEnumerable<IPlayer> newPlayers, ITurnHandler turnHandler, IBanker banker)
        {
            CheckNumberOfPlayers(newPlayers);

            var randomizer = new PlayerOrderRandomizer();
            var randomizedPlayers = randomizer.Execute(newPlayers);
            players = new LinkedList<IPlayer>(randomizedPlayers);

            this.turnHandler = turnHandler;
            this.banker = banker;
            currentPlayerPointer = players.First;
            Round = 1;
        }
Esempio n. 54
0
        public void SetUp()
        {
            playerOneId = 0;
            playerTwoId = 1;
            banker = new TraditionalBanker(new [] { playerOneId, playerTwoId });
            var railroads = new List<Railroad>();
            readingRailroad = new Railroad(5, "Reading Railroad", 250, 25, banker, railroads);
            pennsylvaniaRailroad = new Railroad(15, "Pennsylvania Railroad", 250, 25, banker, railroads);
            boRailroad = new Railroad(25, "B. & O. Railroad", 250, 25, banker, railroads);
            shortLineRailroad = new Railroad(35, "Short Line Railroad", 250, 25, banker, railroads);

            railroads.AddRange(new Railroad[]
                { readingRailroad, pennsylvaniaRailroad, boRailroad, shortLineRailroad });
        }
        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);
        }
        public void Setup()
        {
            player = new Player("name");
            loser = new Player("loser");

            var players = new List<IPlayer>();
            for (var i = 0; i < 8; i++)
                players.Add(new Player("player " + i));
            players.Add(player);
            players.Add(loser);

            banker = new Banker(players);

            payCard = new PayAllPlayersCard(players, banker);
        }
        public void Setup()
        {
            player = new Player("name");
            var players = new[] { player };

            banker = new Banker(players);
            var realEstateHandler = new OwnableHandler(new Dictionary<Int32, OwnableSpace>(), banker);

            var normalSpaces = new Dictionary<Int32, UnownableSpace>();
            for(var i = 0; i < BoardConstants.BOARD_SIZE; i++)
                normalSpaces.Add(i, new NormalSpace("space " + i));

            var spaceHandler = new UnownableHandler(normalSpaces);

            boardHandler = new BoardHandler(players, realEstateHandler, spaceHandler, banker);
        }
        public void Setup()
        {
            property = new Property("property", 0, 0, GROUPING.PURPLE, 0, new[] { 0, 0, 0, 0, 0 });
            otherProperty = new Property("property", 0, 0, GROUPING.PURPLE, 0, new[] { 0, 0, 0, 0, 0 });

            var dict = new Dictionary<Int32, OwnableSpace>();
            dict.Add(0, property);
            dict.Add(1, otherProperty);

            player = new Player("name");
            player.OwnableStrategy = new AlwaysBuyOrMortgage();
            var players = new[] { player };
            banker = new Banker(players);
            var realEstateHandler = new OwnableHandler(dict, banker);
            housesAndHotelsCard = new HousesAndHotelsCard("card", 40, 115, realEstateHandler, banker);

            realEstateHandler.Land(player, 0);
            realEstateHandler.Land(player, 1);
        }
Esempio n. 59
0
        public static Dictionary<Int32, UnownableSpace> CreateNonRealEstateSpaces(IBanker banker)
        {
            var spaces = new Dictionary<Int32, UnownableSpace>();

            spaces.Add(BoardConstants.GO, new NormalSpace("GO"));
            spaces.Add(2, new DrawCard("Community Chest"));
            spaces.Add(BoardConstants.INCOME_TAX, new IncomeTax(banker));
            spaces.Add(7, new DrawCard("Chance"));
            spaces.Add(BoardConstants.JAIL_OR_JUST_VISITING, new NormalSpace("Jail/Just Visiting"));
            spaces.Add(17, new DrawCard("Community Chest"));
            spaces.Add(BoardConstants.FREE_PARKING, new NormalSpace("Free Parking"));
            spaces.Add(22, new DrawCard("Chance"));
            spaces.Add(BoardConstants.GO_TO_JAIL, new NormalSpace("Go To Jail"));
            spaces.Add(33, new DrawCard("Community Chest"));
            spaces.Add(36, new DrawCard("Chance"));
            spaces.Add(BoardConstants.LUXURY_TAX, new LuxuryTax(banker));

            return spaces;
        }
 public void Setup()
 {
     player = new Player("name");
     player.OwnableStrategy = new AlwaysBuyOrMortgage();
     renter = new Player("renter");
     renter.OwnableStrategy = new RandomlyBuyOrMortgage();
     var players = new[] { player, renter };
     banker = new Banker(players);
     property = new Property("name", 10, 1, GROUPING.DARK_BLUE, 2, new[] { 4, 5, 6, 7, 8 });
     ownableHandler = FakeHandlerFactory.CreateRealEstateHandler(new[] { property }, players, banker);
 }