Example #1
0
        public void CarSizeTest()
        {
            Player player = new Player();
            player.Initialize();
            const int carSize = 5;
            Transport car = new Transport(TransportType.Car, String.Empty, 100, null, null, 10000);
            Assert.AreEqual(AssetResponse.AddedSuccessfully, player.Accept(car));
            Asset wife = new Partner();
            Assert.AreEqual(AssetResponse.AddedSuccessfully, player.Accept(wife));
            Asset[] carTravellers = {
                                       new Child(),
                                       new Pet()
                                   };

            // Start from 1 as we already added wife asset
            for (var i = 1; i < player.CarSize; i++) {
                Assert.AreEqual(AssetResponse.AddedSuccessfully,
                                player.Accept(carTravellers[RandomHelper.Next(0, carTravellers.Length)]));
            }

            Assert.AreEqual(player.CarSize, player.Assets[AssetType.Transportable].Count);

            for (var i = 0; i < player.CarSize; i++) {
                Assert.AreEqual(AssetResponse.CarFull,
                                player.Accept(carTravellers[RandomHelper.Next(0, carTravellers.Length)]));
            }
        }
        public Transport GetTransport(TransportType type)
        {
            // A BoatPlane is worth 500k, otherwise it is worth 100k
            var transportValue = type == TransportType.BoatPlane ? 500000 : 100000;
            const int carSize = 6;

            var transportString = type.ToString();
            var normalGraphic = _content.Load<Texture2D>(String.Concat("Images/Transport/", transportString));
            var glowGraphic = _content.Load<Texture2D>(String.Concat("Images/Transport/", transportString, "_glow"));
            var newTransport = new Transport(type, transportString, carSize, normalGraphic, glowGraphic, transportValue);

            return newTransport;
        }
Example #3
0
        public void CarTest()
        {
            Player player = new Player();
            player.Initialize();
            const int carSize = 5;
            const int carValue = 123111;
            Transport car = new Transport(TransportType.Car, String.Empty, 100, null, null, carValue);
            Assert.AreEqual(AssetResponse.AddedSuccessfully, player.Accept(car));

            Assert.AreEqual(carValue, player.TotalValue);
            Assert.AreEqual(AssetResponse.AddedSuccessfully, player.Accept(car));
            Assert.AreEqual(carValue, player.TotalValue);

            const int secondCarValue = 1000;
            Transport car2 = new Transport(TransportType.Car, String.Empty, 100, null, null, secondCarValue);

            Assert.AreEqual(AssetResponse.AddedSuccessfully, player.Accept(car2));

            Assert.AreEqual(secondCarValue, player.TotalValue);
            Assert.AreEqual(AssetResponse.AddedSuccessfully, player.Accept(car2));
            Assert.AreEqual(secondCarValue, player.TotalValue);
        }
Example #4
0
        public void WiveTest()
        {
            Player player = new Player();
            player.Initialize();
            Transport worthlessCar = new Transport(TransportType.Car, String.Empty, 100, null, null, 0);
            Assert.AreEqual(AssetResponse.AddedSuccessfully, player.Accept(worthlessCar));

            Asset wive = new Partner();

            Assert.AreEqual(AssetResponse.AddedSuccessfully, player.Accept(wive));
            Assert.AreEqual(AssetResponse.HasPartnerAlready, player.Accept(wive));
        }
Example #5
0
        public void TotalValueTest()
        {
            int playerCash = RandomHelper.Next(0, 500000);
            int houseValue = RandomHelper.Next(0, 500000);
            int peopleValue = Constants.GameRules.TransportableValue;
            int carValue = RandomHelper.Next(0, 500000);

            Player player = new Player();
            player.Initialize();
            player.Cash += playerCash;

            Transport car = new Transport(TransportType.Car, String.Empty, 100, null, null, carValue);
            Assert.AreEqual(AssetResponse.AddedSuccessfully, player.Accept(car));
            Assert.AreEqual(playerCash + carValue, player.TotalValue);

            Assert.AreEqual(playerCash, player.Cash);

            Asset asset1 = new House(houseValue, "testing house", String.Empty);
            Asset asset2 = new Partner();

            // make sure the player can afford the house
            player.Cash += asset1.Value;
            Assert.AreEqual(playerCash + houseValue, player.Cash);
            Assert.AreEqual(AssetResponse.AddedSuccessfully, player.Accept(asset1));
            Assert.AreEqual(playerCash + houseValue + carValue, player.TotalValue);

            Assert.AreEqual(AssetResponse.AddedSuccessfully, player.Accept(asset2));

            Assert.AreEqual( playerCash + houseValue + peopleValue + carValue, player.TotalValue);
        }
Example #6
0
        public void CashTest()
        {
            const int cash = 12312;
            Vector2 location = Vector2.Zero;

            Player player = new Player();
            player.Initialize();
            player.Cash += cash;
            Transport worthlessCar = new Transport(TransportType.Car, String.Empty, 100, null, null, 0);
            Assert.AreEqual(AssetResponse.AddedSuccessfully, player.Accept(worthlessCar));

            Asset asset1 = new House(15212, "testing house", String.Empty);
            Asset asset2 = new Partner();

            Assert.AreEqual(AssetResponse.AddedSuccessfully, player.Accept(asset1));
            Assert.AreEqual(AssetResponse.AddedSuccessfully, player.Accept(asset2));

            int expected = cash;
            int actual;
            player.Cash = expected;
            actual = player.Cash;
            Assert.AreEqual(expected, actual);
        }