Exemple #1
0
        public void TestDestroyUnit()
        {
            var  testCard     = new RPSCardsEngine.Cards.Card(CardType.Rock);
            var  ownGraveyard = new Graveyard();
            Hand hand         = TestHelpers.GetFilledHand(
                new List <Card> {
                testCard,
                new RPSCardsEngine.Cards.Card(CardType.Water),
            },
                ownGraveyard);

            var enemyGraveyard = new Graveyard();
            var enemyBoard     = new Board(enemyGraveyard);


            hand.PlayCard(0, enemyBoard, 2);

            Assert.AreEqual(enemyBoard[2], testCard);
            Assert.AreEqual(enemyBoard.Count, 1);

            hand.PlayCard(1, enemyBoard, 2);

            Assert.AreEqual(enemyBoard[2], testCard);
            Assert.IsTrue(testCard.IsDestroyed);
            Assert.AreEqual(ownGraveyard.Count, 1);

            Assert.AreEqual(enemyBoard.Count, 1);
            enemyBoard.RemoveDestroyed();
            Assert.AreEqual(enemyBoard.Count, 0);

            Assert.AreEqual(enemyGraveyard.Count, 1);
        }
        public void ReturnSuccessMessageIfItIsNight()
        {
            //Arrange
            var graveyard = new Graveyard();

            graveyard.IsDay = false;
            //Setup
            var dotMock        = new Mock <IEffect>();
            var heroMock       = new Mock <IHero>();
            var appliedEffects = new List <IEffect>();

            appliedEffects.Add(dotMock.Object);

            dotMock.SetupGet(dot => dot.Type).Returns(EffectType.DOT);

            heroMock
            .SetupGet(hero => hero.AppliedEffects)
            .Returns(appliedEffects);

            heroMock
            .SetupGet(hero => hero.Name)
            .Returns("Gosho");

            string result = graveyard.ContinuousEffect(heroMock.Object);

            Assert.AreEqual("Gosho's duration of all applied DOT effects increased by 1", result);
        }
Exemple #3
0
 // 시작 셋팅
 private void StartSet()
 {
     Instance         = this;
     cardScale        = graveCard.transform.localScale;
     cardAddScale     = cardScale;
     cardAddScale.x  *= 1.25f;
     cardAddScale.y  *= 1.25f;
     cardViewScale    = cardScale;
     cardViewScale.x *= 1.1f;
     cardViewScale.y *= 1.1f;
     gravePosList     = new List <GameObject>();
     graveCardList    = new List <GraveCard>();
     for (int i = 0; i < graveGroup.transform.childCount; i++)
     {
         gravePosList.Add(graveGroup.transform.GetChild(i).gameObject);
     }
     if (GameManager.Instance.player)
     {
         graveViewF = graveViewAQ;
     }
     else
     {
         graveViewF = graveViewBQ;
     }
 }
Exemple #4
0
        private void ClearDeaths()
        {
            Dictionary <IMinion, int> deaths = new Dictionary <IMinion, int>();

            for (int i = 0; i < PlayedMinions.Count; i++)
            {
                var minion = PlayedMinions[i];
                if (minion.IsDead)
                {
                    deaths[minion] = i;
                    int index = PlayedMinions.IndexOf(minion);
                    Remove(minion);
                    Graveyard.Add(minion);
                }
            }

            foreach (var kv in deaths)
            {
                int auraLevel = BoardAuras.Where(a => a.Value == AuraType.Deathrattle).Select(b => b.Key.Level).DefaultIfEmpty().Max() + 1;
                for (int i = 0; i < auraLevel; i++)
                {
                    kv.Key.OnDeath(new TriggerParams()
                    {
                        Activator = kv.Key, Board = this, RivalBoard = RivalBoard, Index = kv.Value
                    });
                }

                OnMinionDied(kv.Key);
            }
        }
Exemple #5
0
        public Player(PlayerSeat seat, TeamData teamData = null, LibraryData deckData = null,
                      Configurations configurations      = null)
        {
            Configurations = configurations;
            Seat           = seat;
            Hand           = new Collection <IRuntimeCard>();

            if (teamData != null)
            {
                Team = new Team(this, teamData);
            }

            if (deckData != null)
            {
                Library = new Library(this, deckData, configurations);
            }

            Graveyard = new Graveyard(this);

            #region Mechanics

            DrawMechanics       = new DrawMechanics(this);
            DiscardMechanics    = new DiscardMechanics(this);
            PlayCardMechanics   = new PlayCardMechanics(this);
            StartTurnMechanics  = new StartTurnMechanics(this);
            FinishTurnMecahnics = new FinishTurnMecahnics(this);
            SpawnMechanics      = new SpawnMechanics(this);
            ManaMechanics       = new ManaMechanics(this);

            #endregion
        }
Exemple #6
0
        void InitializeGameDataStructures(GameArgs args)
        {
            {
                //Create Players
                var userId = args.GameParameters.Profiles.UserPlayer.id;
                var aiId   = args.GameParameters.Profiles.AiPlayer.id;
                var user   = new Player(userId, args.GameParameters, args.Dispatcher);
                var ai     = new Player(aiId, args.GameParameters, args.Dispatcher);
                Players = new IPlayer[] { user, ai };

                //Create Hands
                Hands = new IHand[]
                {
                    new Hand(user.Id, args.GameParameters, Dispatcher),
                    new Hand(ai.Id, args.GameParameters, Dispatcher)
                };
            }

            {
                //Create Library
                var libData = new Dictionary <PlayerId, CardData[]>
                {
                    { PlayerId.User, args.GameParameters.library.GetLibrary() },
                    { PlayerId.Ai, args.GameParameters.library.GetLibrary() }
                };

                Library = new Library(libData, Dispatcher);
            }

            Graveyard = new Graveyard(Dispatcher);
        }
Exemple #7
0
        public void CanFillDeckFromGraveyard()
        {
            Deck      deck      = new Deck();
            Graveyard graveyard = new Graveyard();

            Player[] dummyPlayers = new Player[]
            {
                new Player("testPlayer1", 0),
                new Player("testPlayer2", 0)
            };

            foreach (Player player in dummyPlayers)
            {
                player.graveyard = graveyard;
            }

            // Deck är 51 count
            graveyard.graveYardCards.Add(deck.deck[0]);
            deck.DrawTopCard();
            Assert.AreEqual(51, deck.deck.Count);

            //Deck är 52 count igen
            deck.ReturnCard(dummyPlayers);
            Assert.AreEqual(52, deck.deck.Count);
        }
Exemple #8
0
    public bool ReturnFromGraveyard(CardListFilter filter, int numToCreate, bool isDeploy, bool isRedeploy, bool isCopy, string createdBy, bool isChoice)
    {
        var filteredCardList = Graveyard.FilterCardList(filter);

        if (filteredCardList.ListCount == 0)
        {
            return(false);
        }

        var cardList = filteredCardList.GetRandomCards(numToCreate);

        if (!isChoice)
        {
            if (isDeploy)
            {
                var unitList = cardList.Cast <Unit>().ToList();
                if (isRedeploy)
                {
                    AddToRedeploy(unitList);
                }
                else
                {
                    GameManager.instance.effectManager.SetDeployUnits(unitList);
                }
            }
            else
            {
                if (isCopy)
                {
                    cardList = cardList.Select(x => GameManager.instance.libraryManager.CreateCard(x.CardData, this)).ToList();
                    cardList.ForEach(x => x.CreatedByName = createdBy);
                }

                foreach (var card in cardList)
                {
                    AddToHand(card);
                }
            }


            if (!isCopy)
            {
                Graveyard.RemoveCard(cardList);
            }
        }
        else
        {
            if (isDeploy)
            {
                GameManager.instance.effectManager.SetGraveyardToDeployChoiceMode(cardList);
            }
            else
            {
                GameManager.instance.effectManager.SetGraveyardToHandChoiceMode(cardList, isCopy, createdBy);
            }
        }

        return(true);
    }
Exemple #9
0
    /* 回合結束,被Battle manager呼叫 */
    public override void EndTurn(BattleContext mgr)
    {
        //放棄手牌
        Graveyard.AddItems(HandheldSet.GetAll());
        HandheldSet.Clear();

        base.EndTurn(mgr);
    }
 void Awake()
 {
     if(graveyard == null) {
         graveyard = this;
     } else {
         Destroy(gameObject);
     }
 }
Exemple #11
0
 /// <summary>
 /// Choose card will find and remove card
 /// from the Players card set and place it
 /// into the player's graveyard
 /// </summary>
 /// <param name="card">player's card played</param>
 public void ChooseCard(Card card)
 {
     this.Cardset.Remove(card); //we ned to remove the card from the cardsset picturebox to display it to the cards being played picturebox
     Graveyard.Add(card);       //graveyard list to hold the played cards, and restore it when cardsset is less than 2
     this.LastPlayedCard = card;
     card.Render(CardsDeposit); //draw the card on the picturebox
     this.Update();
 }
Exemple #12
0
        public static Hand GetFilledHand(List <RPSCardsEngine.Cards.Card> cards, Graveyard graveyard = null)
        {
            var hand = new Hand(cards.Count, graveyard);

            new Deck(cards).Draw(cards.Count, hand);

            return(hand);
        }
Exemple #13
0
        public void SummonFromGraveyard(MinionType type, int index, Direction direction = Direction.InPlace, int amount = 1)
        {
            var revive = Graveyard.Where(m => m.MinionType == type).Take(amount);

            foreach (var minion in revive)
            {
                Summon(minion.Name, index, direction);
            }
        }
 public void Update(Duel duel, Player player)
 {
     Hand.Update(duel, player.Hand);
     ManaZone.Update(duel, player.ManaZone);
     BattleZone.Update(duel, player.BattleZone);
     Deck.Update(duel, player.Deck);
     ShieldZone.Update(duel, player.ShieldZone);
     Graveyard.Update(duel, player.Graveyard);
 }
Exemple #15
0
 public void Clear()
 {
     Deck.Clear();
     ExtraDeck.Clear();
     Hand.Clear();
     Banished.Clear();
     Graveyard.Clear();
     MonsterZone = new ClientCard[7];
     SpellZone   = new ClientCard[8];
 }
Exemple #16
0
        public int GetRemainingCount(int cardId, int initialCount)
        {
            int remaining = initialCount;

            remaining = remaining - Hand.Count(card => card != null && card.IsCode(cardId));
            remaining = remaining - SpellZone.Count(card => card != null && card.IsCode(cardId));
            remaining = remaining - Graveyard.Count(card => card != null && card.IsCode(cardId));
            remaining = remaining - Banished.Count(card => card != null && card.IsCode(cardId));
            return((remaining < 0) ? 0 : remaining);
        }
Exemple #17
0
        public virtual void Discard(Card card)
        {
            if (!Hand.Contains(card))
            {
                return;
            }

            Hand.Remove(card);
            Graveyard.Add(card);
        }
 private void FateOf(Gladiator gladiator)
 {
     if (gladiator.IsAlive())
     {
         Combatants.Add(gladiator);
     }
     else
     {
         Graveyard.Add(gladiator);
     }
 }
Exemple #19
0
    public void AddToGraveyard(Card deadCard, string createdBy = "")
    {
        deadCard.InitCard(deadCard.CardData, this);

        if (!string.IsNullOrWhiteSpace(createdBy))
        {
            deadCard.CreatedByName = createdBy;
        }

        Graveyard.AddCard(deadCard);
    }
Exemple #20
0
 public bool GetGraveyard(out List <string> graveyard)
 {
     graveyard = Graveyard.ToList();
     if (graveyard.Count == Graveyard.Count)
     {
         return(true);
     }
     else
     {
         return(false);
     }
 }
Exemple #21
0
 public void CombineToLibrary(bool hand, bool graveyard)
 {
     if (graveyard)
     {
         Graveyard.Remove(TargetZone.Library);
     }
     if (hand)
     {
         Hand.Remove(TargetZone.Library);
     }
     Library.Shuffle();
 }
Exemple #22
0
    public Estate(SaveCampaignData saveData)
    {
        RosterIds = new List <int>();
        for (int i = 1; i < 100; i++)
        {
            RosterIds.Add(i);
        }

        EstateTitle = saveData.HamletTitle;

        Currencies = new Dictionary <string, int>();
        Currencies.Add("gold", saveData.GoldAmount);
        Currencies.Add("bust", saveData.BustsAmount);
        Currencies.Add("deed", saveData.DeedsAmount);
        Currencies.Add("portrait", saveData.PortraitsAmount);
        Currencies.Add("crest", saveData.CrestsAmount);

        HeroPurchases = saveData.InstancedPurchases;
        TownPurchases = saveData.BuildingUpgrades;

        Buildings = new Dictionary <BuildingType, Building>();
        Abbey     = DarkestDungeonManager.Data.Buildings["abbey"] as Abbey;
        Buildings.Add(BuildingType.Abbey, Abbey);
        Tavern = DarkestDungeonManager.Data.Buildings["tavern"] as Tavern;
        Buildings.Add(BuildingType.Tavern, Tavern);
        Sanitarium = DarkestDungeonManager.Data.Buildings["sanitarium"] as Sanitarium;
        Buildings.Add(BuildingType.Sanitarium, Sanitarium);
        Blacksmith = DarkestDungeonManager.Data.Buildings["blacksmith"] as Blacksmith;
        Buildings.Add(BuildingType.Blacksmith, Blacksmith);
        Guild = DarkestDungeonManager.Data.Buildings["guild"] as Guild;
        Buildings.Add(BuildingType.Guild, Guild);
        NomadWagon = DarkestDungeonManager.Data.Buildings["nomad_wagon"] as NomadWagon;
        Buildings.Add(BuildingType.NomadWagon, NomadWagon);
        StageCoach = DarkestDungeonManager.Data.Buildings["stage_coach"] as StageCoach;
        Buildings.Add(BuildingType.StageCoach, StageCoach);
        CampingTrainer = DarkestDungeonManager.Data.Buildings["camping_trainer"] as CampingTrainer;
        Buildings.Add(BuildingType.CampingTrainer, CampingTrainer);
        Graveyard = new Graveyard();
        Buildings.Add(BuildingType.Graveyard, Graveyard);
        Statue = new Statue();
        Buildings.Add(BuildingType.Statue, Statue);

        Abbey.InitializeBuilding(TownPurchases);
        Tavern.InitializeBuilding(TownPurchases);
        Sanitarium.InitializeBuilding(TownPurchases);
        Blacksmith.InitializeBuilding(TownPurchases);
        Guild.InitializeBuilding(TownPurchases);
        CampingTrainer.InitializeBuilding(TownPurchases);
        NomadWagon.InitializeBuilding(TownPurchases);
        StageCoach.InitializeBuilding(TownPurchases);
        Graveyard.Records.AddRange(saveData.DeathRecords);
    }
 // Use this for initialization
 void Start()
 {
     Instance = this;
     GraveTemplate.gameObject.SetActive(false);
     SurvivalTimer.Instance.OnPlayerDeath += Instance_OnPlayerDeath;
     if (Base.Current.Graves != null && Base.Current.Graves.Length > 0)
     {
         foreach (var grave in Base.Current.Graves)
         {
             AddGrave(grave);
         }
     }
 }
Exemple #24
0
        /// <summary>
        /// Create a new player object.
        /// </summary>
        /// <param name="game">The game instance.</param>
        internal Player(GameInstance game)
        {
            Id           = idNext++;
            GameInstance = game;

            Board       = new Board();
            Deck        = new Deck();
            DiscardPile = new DiscardPile();
            Equipped    = new Equipped();
            FaceUp      = new FaceUp();
            Graveyard   = new Graveyard();
            Hand        = new Hand();
        }
Exemple #25
0
    // Use this for initialization
    void Start()
    {
        cardImage.sprite = cardSO.art;
        atkTxt.GetComponent <TextMeshPro>();
        atkTxt.text  = cardSO.attack.ToString();
        manaTxt.text = cardSO.manaCost.ToString();

        grave  = FindObjectOfType <Graveyard>();
        player = FindObjectOfType <Player>();

        attackdmg = cardSO.attack;
        mana      = cardSO.manaCost;
    }
Exemple #26
0
    public override void Initialize()
    {
        Graveyard           = DarkestDungeonManager.Campaign.Estate.Graveyard;
        ExistingRecordSlots = new List <DeathRecordSlot>();

        foreach (var deathRecord in Graveyard.Records)
        {
            var newRecordSlot = Instantiate(recordTemplate);
            newRecordSlot.transform.SetParent(recordsRect, false);
            var newSlot = newRecordSlot.GetComponent <DeathRecordSlot>();
            newSlot.UpgdateRecord(deathRecord, this);
            ExistingRecordSlots.Add(newSlot);
        }
    }
Exemple #27
0
        public Board(Graveyard blackGraveyard, History blackHistory, Graveyard whiteGraveyard, History whiteHistory)
        {
            m_blackGraveyard = blackGraveyard;
            m_blackHistory   = blackHistory;
            m_whiteGraveyard = whiteGraveyard;
            m_whiteHistory   = whiteHistory;

            m_activeColor = ChessColor.White;

            m_validMovePositions = new List <BoardPosition>();
            m_validSpecialMove   = SpecialMove.None;

            ResetBoard();
        }
Exemple #28
0
    private void Awake()
    {
        // there can only be one
        if (instance == null)
        {
            instance = this;
        }
        else
        {
            Destroy(this.gameObject);
        }

        deadUnits = new List <Unit>();
    }
Exemple #29
0
 public void SetCurrentEnvironment(EnvironmentCardView card)
 {
     if (currentEnvCard != null && currentEnvCard != card)
     {
         Graveyard.Engrave(currentEnvCard);
     }
     currentEnvCard            = card;
     currentFraction           = currentEnvCard.data.fraction;
     currentFractionMultiplier = currentEnvCard.data.fractionMultiplier;
     NotificationManager.instance.ShowNotification("Environment changed, bonus: " + currentFractionMultiplier, Color.white);
     if (currentFraction >= 0)
     {
         cam.backgroundColor = fractionAccents[currentFraction];
         background.color    = fractionImageAccents[currentFraction];
     }
 }
Exemple #30
0
 protected virtual void Dispose(bool disposing)
 {
     if (disposing)
     {
         BattleZone?.Dispose();
         BattleZone = null;
         Deck?.Dispose();
         Deck = null;
         Graveyard?.Dispose();
         Graveyard = null;
         Hand?.Dispose();
         Hand = null;
         ManaZone?.Dispose();
         ManaZone = null;
         ShieldZone?.Dispose();
         ShieldZone = null;
     }
 }
Exemple #31
0
    public Card DrawFromLibrary()
    {
        if (cardBox.Count > 0)
        {
            Card card = cardBox.Last();
            cardBox.RemoveAt(cardBox.Count - 1);

            //Reload library: if lib.count == 0, then put graveyard in reverse order back to library
            Graveyard.ReloadLibrary();

            return(card);
        }
        else
        {
            Debug.Log("There are no more cards in the library!");
            return(null);
        }
    }
Exemple #32
0
 void Awake()
 {
     instance = this;
 }