private void ReviveUnit(WorkingCard workingCard) { Player playerOwner = workingCard.Owner; if (playerOwner.BoardCards.Count >= Constants.MaxBoardUnits) { return; } Card libraryCard = workingCard.LibraryCard.Clone(); WorkingCard card = new WorkingCard(libraryCard, playerOwner); BoardUnit unit = BattlegroundController.CreateBoardUnit(playerOwner, card); playerOwner.RemoveCardFromGraveyard(workingCard); playerOwner.AddCardToBoard(card); playerOwner.BoardCards.Add(unit); if (playerOwner.IsLocalPlayer) { BattlegroundController.PlayerBoardCards.Add(unit); BattlegroundController.UpdatePositionOfBoardUnitsOfPlayer(GameplayManager.CurrentPlayer.BoardCards); } else { BattlegroundController.OpponentBoardCards.Add(unit); BattlegroundController.UpdatePositionOfBoardUnitsOfOpponent(); } }
public void DrawCardInfo(WorkingCard card) { GameObject go; BoardCard boardCard; switch (card.LibraryCard.CardKind) { case Enumerators.CardKind.CREATURE: go = Object.Instantiate( _loadObjectsManager.GetObjectByPath <GameObject>("Prefabs/Gameplay/Cards/CreatureCard")); boardCard = new UnitBoardCard(go); break; case Enumerators.CardKind.SPELL: go = Object.Instantiate( _loadObjectsManager.GetObjectByPath <GameObject>("Prefabs/Gameplay/Cards/SpellCard")); boardCard = new SpellBoardCard(go); break; default: throw new ArgumentOutOfRangeException(); } boardCard.Init(card); go.transform.position = new Vector3(-6, 0, 0); go.transform.localScale = Vector3.one * .3f; boardCard.SetHighlightingEnabled(false); Object.Destroy(go, 2f); }
public void AddCardToHand(Player player, WorkingCard card = null) { if (card == null) { if (player.CardsInDeck.Count == 0) { if (!_tutorialManager.IsTutorial) { player.DamageByNoMoreCardsInDeck++; player.Health -= player.DamageByNoMoreCardsInDeck; _vfxController.SpawnGotDamageEffect(player, -player.DamageByNoMoreCardsInDeck); } return; } card = player.CardsInDeck[0]; } if (CheckIsMoreThanMaxCards(card, player)) { return; } player.RemoveCardFromDeck(card); player.AddCardToHand(card); }
public GameObject AddCardToHand(WorkingCard card, bool silent = false) { BoardCard boardCard = CreateBoardCard(card); if (_battlegroundController.CurrentTurn == 0) { boardCard.SetDefaultAnimation(boardCard.WorkingCard.Owner.CardsInHand.Count); } _battlegroundController.PlayerHandCards.Add(boardCard); if (silent) { boardCard.HandBoardCard.Enabled = false; _timerManager.AddTimer( x => { boardCard.HandBoardCard.Enabled = true; boardCard.HandBoardCard.CheckStatusOfHighlight(); }, null, 2f); } else { boardCard.HandBoardCard.CheckStatusOfHighlight(); } return(boardCard.GameObject); }
public void ReturnCardToHand(BoardUnit unit) { Player unitOwner = unit.OwnerPlayer; WorkingCard returningCard = unit.Card; returningCard.InitialCost = returningCard.LibraryCard.Cost; returningCard.RealCost = returningCard.InitialCost; Vector3 unitPosition = unit.Transform.position; _timerManager.AddTimer( x => { // STEP 1 - REMOVE UNIT FROM BOARD unitOwner.BoardCards.Remove(unit); // STEP 2 - DESTROY UNIT ON THE BOARD OR ANIMATE unit.Die(true); Object.Destroy(unit.GameObject); // STEP 3 - REMOVE WORKING CARD FROM BOARD unitOwner.RemoveCardFromBoard(returningCard); // STEP 4 - RETURN CARD TO HAND ReturnToHandBoardUnit(returningCard, unitOwner, unitPosition); // STEP 4 - REARRANGE HANDS _gameplayManager.RearrangeHands(); }, null, 2f); }
private BoardUnit CreateBoardUnit(WorkingCard card, Player owner) { GameObject playerBoard = owner.IsLocalPlayer ? BattlegroundController.PlayerBoardObject : BattlegroundController.OpponentBoardObject; BoardUnit boardUnit = new BoardUnit(playerBoard.transform); boardUnit.Transform.tag = owner.IsLocalPlayer ? SRTags.PlayerOwned : SRTags.OpponentOwned; boardUnit.Transform.parent = playerBoard.transform; boardUnit.Transform.position = new Vector2(2f * owner.BoardCards.Count, owner.IsLocalPlayer ? -1.66f : 1.66f); boardUnit.OwnerPlayer = owner; boardUnit.SetObjectInfo(card); if (!owner.Equals(GameplayManager.CurrentTurnPlayer)) { boardUnit.IsPlayable = true; } boardUnit.PlayArrivalAnimation(); GameplayManager.CanDoDragActions = true; return(boardUnit); }
private bool CardCanBePlayable(WorkingCard card) { #if !DEV_MODE return(card.LibraryCard.Cost <= _gameplayManager.OpponentPlayer.Goo && _gameplayManager.OpponentPlayer.Turn > MinTurnForAttack); #else return(true); #endif }
public GameObject AddCardToOpponentHand(WorkingCard card, bool silent = false) { GameObject go = CreateOpponentBoardCard(); _battlegroundController.OpponentHandCards.Add(go); _abilitiesController.CallAbilitiesInHand(null, card); return(go); }
public void AddCardToDistributionState(Player player, WorkingCard card) { BoardCard boardCard = CreateBoardCard(card); SortingGroup sortingGroup = boardCard.GameObject.GetComponent <SortingGroup>(); sortingGroup.sortingLayerID = SRSortingLayers.GameUI1; player.CardsPreparingToHand.Add(boardCard); boardCard.HandBoardCard.Enabled = false; boardCard.MoveCardFromDeckToCenter(); }
private void CardPlayedHandler(WorkingCard card) { if (!card.Equals(MainWorkingCard)) { return; } PlayerCallerOfAbility.HandChanged -= HandChangedHandler; PlayerCallerOfAbility.CardPlayed -= CardPlayedHandler; }
private bool CheckIsMoreThanMaxCards(WorkingCard workingCard, Player player) { if (player.CardsInHand.Count >= Constants.MaxCardsInHand) { // IMPROVE ANIMATION return(true); } return(false); }
public BoardSpell(GameObject obj, WorkingCard card) { GameObject = obj; Transform = obj.transform; Card = card; _eventHandler = GameObject.GetComponent <OnBehaviourHandler>(); _eventHandler.Destroying += DestroyingHandler; }
public void CallAbilitiesInHand(BoardCard boardCard, WorkingCard card) { List <AbilityData> handAbilities = card.LibraryCard.Abilities.FindAll(x => x.AbilityCallType.Equals(Enumerators.AbilityCallType.IN_HAND)); foreach (AbilityData ability in handAbilities) { CreateActiveAbility(ability, card.LibraryCard.CardKind, boardCard, card.Owner, card.LibraryCard, card) .Ability.Activate(); } }
public virtual void Init(WorkingCard card) { WorkingCard = card; LibraryCard = WorkingCard.LibraryCard; NameText.text = LibraryCard.Name; BodyText.text = LibraryCard.Description; CostText.text = LibraryCard.Cost.ToString(); IsNewCard = true; InitialCost = WorkingCard.InitialCost; ManaCost = InitialCost; WorkingCard.Owner.PlayerGooChanged += PlayerGooChangedHandler; string rarity = Enum.GetName(typeof(Enumerators.CardRank), WorkingCard.LibraryCard.CardRank); string setName = LibraryCard.CardSetType.ToString(); string frameName = string.Format("Images/Cards/Frames/frame_{0}_{1}", setName, rarity); if (!string.IsNullOrEmpty(LibraryCard.Frame)) { frameName = "Images/Cards/Frames/" + LibraryCard.Frame; } BackgroundSprite.sprite = LoadObjectsManager.GetObjectByPath <Sprite>(frameName); PictureSprite.sprite = LoadObjectsManager.GetObjectByPath <Sprite>(string.Format( "Images/Cards/Illustrations/{0}_{1}_{2}", setName.ToLower(), rarity.ToLower(), WorkingCard.LibraryCard.Picture.ToLower())); AmountText.transform.parent.gameObject.SetActive(false); DistibuteCardObject.SetActive(false); if (LibraryCard.CardKind == Enumerators.CardKind.CREATURE) { ParentOfLeftBlockOfCardInfo = Transform.Find("Group_LeftBlockInfo"); ParentOfRightBlockOfCardInfo = Transform.Find("Group_RightBlockInfo"); if (!InternalTools.IsTabletScreen()) { ParentOfLeftBlockOfCardInfo.transform.localScale = new Vector3(.7f, .7f, .7f); ParentOfLeftBlockOfCardInfo.transform.localPosition = new Vector3(10f, 6.8f, 0f); ParentOfRightBlockOfCardInfo.transform.localScale = new Vector3(.7f, .7f, .7f); ParentOfRightBlockOfCardInfo.transform.localPosition = new Vector3(17f, 6.8f, 0f); } } }
public void CreateNewCardByNameAndAddToHand(Player player, string name) { float animationDuration = 1.5f; Card card = _dataManager.CachedCardsLibraryData.GetCardFromName(name).Clone(); WorkingCard workingCard = new WorkingCard(card, player); if (CheckIsMoreThanMaxCards(workingCard, player)) { return; } if (player.IsLocalPlayer) { BoardCard boardCard = CreateBoardCard(workingCard); boardCard.Transform.position = Vector3.zero; boardCard.Transform.localScale = Vector3.zero; boardCard.Transform.DOScale(Vector3.one * .3f, animationDuration); _timerManager.AddTimer( x => { _battlegroundController.PlayerHandCards.Add(boardCard); player.CardsInHand.Add(workingCard); _battlegroundController.UpdatePositionOfCardsInPlayerHand(true); }, null, animationDuration); } else { GameObject boardCard = AddCardToOpponentHand(workingCard); boardCard.transform.position = Vector3.zero; boardCard.transform.localScale = Vector3.zero; boardCard.transform.DOScale(Vector3.one, animationDuration); _timerManager.AddTimer( x => { player.CardsInHand.Add(workingCard); _battlegroundController.UpdatePositionOfCardsInOpponentHand(true); }, null, animationDuration); } }
public void PlayOpponentCard( Player player, WorkingCard card, object target, Action <WorkingCard, object> completePlayCardCallback) { GameObject randomCard = _battlegroundController.OpponentHandCards[ Random.Range(0, _battlegroundController.OpponentHandCards.Count)]; _battlegroundController.OpponentHandCards.Remove(randomCard); _tutorialManager.ReportAction(Enumerators.TutorialReportAction.MOVE_CARD); _soundManager.PlaySound(Enumerators.SoundType.CARD_FLY_HAND_TO_BATTLEGROUND, Constants.CardsMoveSoundVolume); player.ThrowPlayCardEvent(card); randomCard.transform.DOMove(Vector3.up * 2.5f, 0.6f).OnComplete( () => { randomCard.transform.Find("RemoveCardParticle").GetComponent <ParticleSystem>().Play(); randomCard.transform.DOScale(Vector3.one * 1.2f, 0.6f).OnComplete( () => { RemoveOpponentCard(new object[] { randomCard }); _timerManager.AddTimer( x => { completePlayCardCallback?.Invoke(card, target); }, null, 0.1f); _ranksController.UpdateRanksByElements(player.BoardCards, card.LibraryCard); _timerManager.AddTimer( x => { player.GraveyardCardsCount++; }); }); }); randomCard.transform.DORotate(Vector3.zero, 0.5f); _battlegroundController.UpdatePositionOfCardsInOpponentHand(true); }
public bool HasSpecialUnitOnBoard(WorkingCard workingCard, AbilityData ability) { if (ability.AbilityTargetTypes.Count == 0) { return(false); } Player opponent = workingCard.Owner.Equals(_gameplayManager.CurrentPlayer) ? _gameplayManager.OpponentPlayer : _gameplayManager.CurrentPlayer; Player player = workingCard.Owner; foreach (Enumerators.AbilityTargetType target in ability.AbilityTargetTypes) { switch (target) { case Enumerators.AbilityTargetType.PLAYER_CARD: { List <BoardUnit> units = player.BoardCards.FindAll(x => x.InitialUnitType == ability.TargetCardType && x.UnitStatus == ability.TargetUnitStatusType); if (units.Count > 0) { return(true); } break; } case Enumerators.AbilityTargetType.OPPONENT_CARD: { List <BoardUnit> units = opponent.BoardCards.FindAll(x => x.InitialUnitType == ability.TargetCardType && x.UnitStatus == ability.TargetUnitStatusType); if (units.Count > 0) { return(true); } break; } } } return(false); }
private void PlayCardOnBoard(WorkingCard card) { bool needTargetForAbility = false; if (card.LibraryCard.Abilities != null && card.LibraryCard.Abilities.Count > 0) { needTargetForAbility = card.LibraryCard.Abilities.FindAll(x => x.AbilityTargetTypes.Count > 0).Count > 0; } object target = null; if (needTargetForAbility) { target = GetAbilityTarget(card); } switch (card.LibraryCard.CardKind) { case Enumerators.CardKind.CREATURE when _battlegroundController.OpponentBoardCards.Count < Constants.MaxBoardUnits: _gameplayManager.OpponentPlayer.RemoveCardFromHand(card); _gameplayManager.OpponentPlayer.AddCardToBoard(card); _cardsController.PlayOpponentCard(_gameplayManager.OpponentPlayer, card, target, PlayCardCompleteHandler); _cardsController.DrawCardInfo(card); break; case Enumerators.CardKind.SPELL: { if (target != null && needTargetForAbility || !needTargetForAbility) { _gameplayManager.OpponentPlayer.RemoveCardFromHand(card); _gameplayManager.OpponentPlayer.AddCardToBoard(card); _cardsController.PlayOpponentCard(_gameplayManager.OpponentPlayer, card, target, PlayCardCompleteHandler); _cardsController.DrawCardInfo(card); } break; } } _gameplayManager.OpponentPlayer.Goo -= card.LibraryCard.Cost; }
public BoardUnit CreateBoardUnit(Player owner, WorkingCard card) { GameObject playerBoard = owner.IsLocalPlayer ? PlayerBoardObject : OpponentBoardObject; BoardUnit boardUnit = new BoardUnit(playerBoard.transform); boardUnit.Transform.tag = owner.IsLocalPlayer ? SRTags.PlayerOwned : SRTags.OpponentOwned; boardUnit.Transform.SetParent(playerBoard.transform); boardUnit.Transform.position = new Vector2(1.9f * owner.BoardCards.Count, 0); boardUnit.OwnerPlayer = owner; boardUnit.SetObjectInfo(card); boardUnit.PlayArrivalAnimation(); return(boardUnit); }
public void SetGooCostOfCardInHand(Player player, WorkingCard card, int value, BoardCard boardCard = null) { if (player.IsLocalPlayer) { if (boardCard == null) { boardCard = _battlegroundController.PlayerHandCards.Find(x => x.WorkingCard.Equals(card)); } boardCard.SetCardCost(value); } else { card.RealCost = Mathf.Clamp(value, 0, 99); } }
private void PushAction(Player owner, BoardSkill boardSkill, HeroSkill skill, object target) { BoardUnit targetUnit = target as BoardUnit; Player unitOwner = targetUnit.OwnerPlayer; WorkingCard returningCard = targetUnit.Card; returningCard.InitialCost = returningCard.LibraryCard.Cost; returningCard.RealCost = returningCard.InitialCost; Vector3 unitPosition = targetUnit.Transform.position; _vfxController.CreateVfx(_loadObjectsManager.GetObjectByPath <GameObject>("Prefabs/VFX/Skills/PushVFX"), targetUnit); _soundManager.PlaySound(Enumerators.SoundType.OVERLORD_ABILITIES, skill.Skill.Trim().ToLower(), Constants.OverlordAbilitySoundVolume, Enumerators.CardSoundType.NONE); _timerManager.AddTimer( x => { // STEP 1 - REMOVE UNIT FROM BOARD unitOwner.BoardCards.Remove(targetUnit); // STEP 2 - DESTROY UNIT ON THE BOARD OR ANIMATE; targetUnit.Die(true); Object.Destroy(targetUnit.GameObject); // STEP 3 - REMOVE WORKING CARD FROM BOARD unitOwner.RemoveCardFromBoard(returningCard); // STEP 4 - RETURN CARD TO HAND _cardsController.ReturnToHandBoardUnit(returningCard, unitOwner, unitPosition); // STEP 4 - REARRANGE HANDS _gameplayManager.RearrangeHands(); _actionsQueueController.PostGameActionReport(_actionsQueueController.FormatGameActionReport( Enumerators.ActionType.RETURN_TO_HAND_CARD_SKILL, new object[] { owner, skill, targetUnit })); // _gameplayManager.GetController<RanksController>().UpdateRanksBuffs(unitOwner); }, null, 2f); }
public void ReturnToHandBoardUnit(WorkingCard workingCard, Player player, Vector3 cardPosition) { if (CheckIsMoreThanMaxCards(workingCard, player)) { return; } GameObject cardObject = player.AddCardToHand(workingCard, true); cardObject.transform.position = cardPosition; if (player.IsLocalPlayer) { cardObject.transform.localScale = new Vector3(0.25f, 0.25f, 0.25f); // size of the cards in hand } }
public ActiveAbility CreateActiveAbility( AbilityData ability, Enumerators.CardKind kind, object boardObject, Player caller, Card cardOwner, WorkingCard workingCard) { lock (_lock) { ActiveAbility activeAbility = new ActiveAbility { Id = _castedAbilitiesIds++, Ability = CreateAbilityByType(kind, ability) }; activeAbility.Ability.ActivityId = activeAbility.Id; activeAbility.Ability.PlayerCallerOfAbility = caller; activeAbility.Ability.CardOwnerOfAbility = cardOwner; activeAbility.Ability.MainWorkingCard = workingCard; if (boardObject != null) { if (boardObject is BoardCard) { activeAbility.Ability.BoardCard = boardObject as BoardCard; } else { if (kind == Enumerators.CardKind.CREATURE) { activeAbility.Ability.AbilityUnitOwner = boardObject as BoardUnit; } else { activeAbility.Ability.BoardSpell = boardObject as BoardSpell; } } } _activeAbilities.Add(activeAbility); return(activeAbility); } }
private bool CheckSpecialCardRules(WorkingCard card) { if (card.LibraryCard.Abilities != null) { foreach (AbilityData ability in card.LibraryCard.Abilities) { if (ability.AbilityType == Enumerators.AbilityType.ATTACK_OVERLORD) { // smart enough HP to use goo carriers if (ability.Value * 2 >= _gameplayManager.OpponentPlayer.Health) { return(false); } } } } return(true); }
public void RemoveOpponentCardFromBoardToGraveyard(WorkingCard card) { Vector3 graveyardPos = OpponentGraveyardObject.transform.position + new Vector3(0.0f, -0.2f, 0.0f); BoardUnit boardCard = OpponentBoardCards.Find(x => x.Card == card); if (boardCard != null) { if (boardCard.Transform != null) { boardCard.Transform.localPosition = new Vector3(boardCard.Transform.localPosition.x, boardCard.Transform.localPosition.y, -0.2f); } OpponentBoardCards.Remove(boardCard); boardCard.SetHighlightingEnabled(false); boardCard.StopSleepingParticles(); if (boardCard.GameObject != null) { boardCard.GameObject.GetComponent <SortingGroup>().sortingLayerID = SRSortingLayers.BoardCards; Object.Destroy(boardCard.GameObject.GetComponent <BoxCollider2D>()); } Debug.Log("Destroy = " + boardCard.CurrentHp + "_" + boardCard.Card.LibraryCard.Name); } else if (_aiController.CurrentSpellCard != null && card == _aiController.CurrentSpellCard.WorkingCard) { _aiController.CurrentSpellCard.SetHighlightingEnabled(false); _aiController.CurrentSpellCard.GameObject.GetComponent <SortingGroup>().sortingLayerID = SRSortingLayers.BoardCards; Object.Destroy(_aiController.CurrentSpellCard.GameObject.GetComponent <BoxCollider2D>()); Sequence sequence = DOTween.Sequence(); sequence.PrependInterval(2.0f); sequence.Append(_aiController.CurrentSpellCard.Transform.DOMove(graveyardPos, 0.5f)); sequence.Append(_aiController.CurrentSpellCard.Transform.DOScale(new Vector2(0.6f, 0.6f), 0.5f)); sequence.OnComplete( () => { _aiController.CurrentSpellCard = null; }); } }
public void RemovePlayerCardFromBoardToGraveyard(WorkingCard card) { BoardUnit boardCard = PlayerBoardCards.Find(x => x.Card == card); if (boardCard == null) { return; } boardCard.Transform.localPosition = new Vector3(boardCard.Transform.localPosition.x, boardCard.Transform.localPosition.y, -0.2f); PlayerBoardCards.Remove(boardCard); PlayerGraveyardCards.Add(boardCard); boardCard.SetHighlightingEnabled(false); boardCard.StopSleepingParticles(); boardCard.GameObject.GetComponent <SortingGroup>().sortingLayerID = SRSortingLayers.BoardCards; Object.Destroy(boardCard.GameObject.GetComponent <BoxCollider2D>()); }
public void LowGooCostOfCardInHand(Player player, WorkingCard card = null, int value = 1) { if (card == null && player.CardsInHand.Count > 0) { card = player.CardsInHand[Random.Range(0, player.CardsInHand.Count)]; } if (card == null) { return; } if (player.IsLocalPlayer) { BoardCard boardCard = _battlegroundController.PlayerHandCards.Find(x => x.WorkingCard.Equals(card)); boardCard.ChangeCardCostOn(value, true); } else { card.RealCost = Mathf.Clamp(card.LibraryCard.Cost - value, 0, card.LibraryCard.Cost); } }
public override void Action(object info = null) { base.Action(info); if (AbilityUnitOwner.IsReanimated) { return; } Player owner = AbilityUnitOwner.OwnerPlayer; Card libraryCard = AbilityUnitOwner.Card.LibraryCard.Clone(); WorkingCard card = new WorkingCard(libraryCard, owner); BoardUnit unit = CreateBoardUnit(card, owner); unit.IsReanimated = true; AbilityUnitOwner.IsReanimated = true; owner.AddCardToBoard(card); owner.BoardCards.Add(unit); if (!owner.IsLocalPlayer) { BattlegroundController.OpponentBoardCards.Add(unit); BattlegroundController.UpdatePositionOfBoardUnitsOfOpponent(); } else { BattlegroundController.PlayerBoardCards.Add(unit); BattlegroundController.UpdatePositionOfBoardUnitsOfPlayer(GameplayManager.CurrentPlayer.BoardCards); } ActionsQueueController.PostGameActionReport(ActionsQueueController.FormatGameActionReport( Enumerators.ActionType.REANIMATE_UNIT_BY_ABILITY, new object[] { owner, unit })); }
public GameObject CreateCardPreview(WorkingCard card, Vector3 pos) { BoardCard boardCard; GameObject currentBoardCard; CardsController.GetSetOfCard(card.LibraryCard); switch (card.LibraryCard.CardKind) { case Enumerators.CardKind.CREATURE: currentBoardCard = Object.Instantiate(CardsController.CreatureCardViewPrefab, _reportActionPreviewPanel.transform, false); boardCard = new UnitBoardCard(currentBoardCard); break; case Enumerators.CardKind.SPELL: currentBoardCard = Object.Instantiate(CardsController.SpellCardViewPrefab, _reportActionPreviewPanel.transform, false); boardCard = new SpellBoardCard(currentBoardCard); break; default: throw new ArgumentOutOfRangeException(); } boardCard.Init(card); boardCard.SetHighlightingEnabled(false); boardCard.IsPreview = true; currentBoardCard.transform.localPosition = pos; currentBoardCard.transform.localRotation = Quaternion.Euler(Vector3.zero); currentBoardCard.transform.localScale = new Vector2(.4f, .4f); currentBoardCard.GetComponent <SortingGroup>().sortingOrder = 1000; currentBoardCard.layer = LayerMask.NameToLayer("Ignore Raycast"); return(currentBoardCard); }
public BoardUnit SpawnUnitOnBoard(Player owner, string name) { if (owner.BoardCards.Count >= Constants.MaxBoardUnits) { return(null); } Card libraryCard = _dataManager.CachedCardsLibraryData.GetCardFromName(name).Clone(); WorkingCard card = new WorkingCard(libraryCard, owner); BoardUnit unit = CreateBoardUnitForSpawn(card, owner); owner.AddCardToBoard(card); owner.BoardCards.Add(unit); _abilitiesController.ResolveAllAbilitiesOnUnit(unit, true); if (!owner.IsLocalPlayer) { _battlegroundController.OpponentBoardCards.Add(unit); _battlegroundController.UpdatePositionOfBoardUnitsOfOpponent(); } else { _battlegroundController.PlayerBoardCards.Add(unit); _battlegroundController.UpdatePositionOfBoardUnitsOfPlayer(owner.BoardCards); } _actionsQueueController.PostGameActionReport(_actionsQueueController.FormatGameActionReport( Enumerators.ActionType.SUMMON_UNIT_CARD, new object[] { owner, unit })); return(unit); }