Beispiel #1
0
        async public void ShouldPlay()
        {
            var runnerCards = new List <Card>();

            for (int i = 0; i < 5; i++)
            {
                runnerCards.Add(new SureGamble());
            }
            var sureGamble = runnerCards.First();
            var game       = new MockGames().WithRunnerCards(runnerCards);

            game.Start();
            await new PassiveCorp(game).SkipTurn();
            var balance = new LastBalanceObserver();
            var clicks  = new SpentClicksObserver();
            var grip    = new GripObserver();
            var heap    = new HeapObserver();

            game.runner.credits.Observe(balance);
            game.runner.clicks.Observe(clicks);
            game.runner.zones.grip.zone.ObserveRemovals(grip);
            game.runner.zones.heap.zone.ObserveAdditions(heap);

            await game.runner.actionCard.TakeAction();

            await game.runner.actionCard.Play(sureGamble).Trigger(game);

            Assert.AreEqual(9, balance.LastBalance);
            Assert.AreEqual(1, clicks.Spent);
            Assert.AreEqual(sureGamble, grip.LastRemoved);
            Assert.AreEqual(sureGamble, heap.LastAdded);
        }
Beispiel #2
0
        async public void ShouldPopHopper()
        {
            game.Start();
            await passiveCorp.SkipTurn();

            var zones = game.runner.zones;

            hopper.MoveTo(zones.grip.zone);
            var gripObserver = new GripObserver();
            var rigObserver  = new RigObserver();
            var heapObserver = new HeapObserver();

            zones.grip.zone.ObserveAdditions(gripObserver);
            zones.rig.zone.ObserveRemovals(rigObserver);
            zones.heap.zone.ObserveAdditions(heapObserver);
            ffRunner.FastForwardToActionPhase();
            await game.runner.actionCard.Install(hopper).Trigger(game); // TODO `GenericInstall` refactoring broke this

            var popHopper = paidAbilityObserver.NewestPaidAbility;

            await popHopper.Trigger(game);

            Assert.AreEqual(3, gripObserver.TotalAdded);
            Assert.AreEqual(hopper, rigObserver.LastUninstalled);
            Assert.AreEqual(hopper, heapObserver.LastAdded);
        }
        async public void ShouldDiscard()
        {
            var runnerCards = new List <Card>();

            for (int i = 0; i < 20; i++)
            {
                runnerCards.Add(new Diesel());
            }
            var game = new MockGames().WithRunnerCards(runnerCards);

            game.Start();
            var passiveCorp = new PassiveCorp(game);
            await passiveCorp.SkipTurn();

            var grip           = game.runner.zones.grip;
            var heap           = game.runner.zones.heap;
            var actionCard     = game.runner.actionCard;
            var gripObserver   = new GripObserver();
            var heapObserver   = new HeapObserver();
            var clicksObserver = new SpentClicksObserver();

            grip.zone.ObserveRemovals(gripObserver);
            heap.zone.ObserveAdditions(heapObserver);
            game.runner.clicks.Observe(clicksObserver);
            for (int i = 0; i < 3; i++)
            {
                var diesel = grip.Find <Diesel>();
                await actionCard.TakeAction();

                await actionCard.Play(diesel).Trigger(game);
            }
            await actionCard.draw.Trigger(game);

            for (int i = 0; i < 7; i++)
            {
                var card = grip.Find <Diesel>();
                game.runner.zones.grip.Discard(card, heap);
            }
            await passiveCorp.SkipTurn();

            Assert.AreEqual(0, clicksObserver.Spent);
            Assert.AreEqual(10, gripObserver.TotalRemoved);
            Assert.AreEqual(10, heapObserver.TotalAdded);
        }