public void ReturnCardToDeck(BoardCard card, Action callback) { card.WorkingCard.Owner.CardsPreparingToHand.Remove(card); Object.Destroy(card.GameObject); callback?.Invoke(); }
private void CardSelected(BoardCard card) { GameObject go = card.GameObject; if (!go.transform.Find("Back").gameObject.activeSelf) { return; } Sequence animationSequence3 = DOTween.Sequence(); animationSequence3.Append( go.transform.DORotate(new Vector3(go.transform.eulerAngles.x, 90, go.transform.eulerAngles.z), .4f)); animationSequence3.Join(go.transform.DOScale(new Vector3(.4f, .4f, .4f), .2f)); animationSequence3.OnComplete( () => { go.transform.Find("Back").gameObject.SetActive(false); Sequence animationSequence4 = DOTween.Sequence(); animationSequence4.Append( go.transform.DORotate(new Vector3(go.transform.eulerAngles.x, 0, go.transform.eulerAngles.z), .3f)); animationSequence4.Join(go.transform.DOScale(new Vector3(.35f, .35f, .35f), .2f)); animationSequence4.AppendInterval(2f); _cardsTurned++; _dataManager.CachedCollectionData.ChangeAmount(card.LibraryCard.Name, 1); }); }
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); }
private void PointerEventSolverEndedHandler() { _delayTimerOfClick = 0f; _startedOnClickDelay = false; _topmostBoardCard = null; _selectedBoardUnit = null; }
private void PackItemAnimationComplete() { CardPack cardPack = new CardPack(Enumerators.CardPackType.DEFAULT); if (!_dataManager.CachedUserLocalData.OpenedFirstPack) { _activatedTemporaryPack = true; _dataManager.CachedUserLocalData.OpenedFirstPack = true; _dataManager.SaveCache(Enumerators.CacheDataType.USER_LOCAL_DATA); } List <Card> cardsInPack = cardPack.OpenPack(_activatedTemporaryPack); _activatedTemporaryPack = false; for (int i = 0; i < Constants.CardsInPack; i++) { Card card = cardsInPack[i]; GameObject go; switch (card.CardKind) { case Enumerators.CardKind.CREATURE: go = Object.Instantiate(_cardCreaturePrefab); break; case Enumerators.CardKind.SPELL: go = Object.Instantiate(_cardSpellPrefab); break; default: throw new ArgumentOutOfRangeException(); } go.transform.SetParent(_cardsContainer); go.transform.Find("Back").gameObject.SetActive(true); go.transform.Find("Amount").gameObject.SetActive(false); // todo imrpoveE!!!! BoardCard boardCard = new BoardCard(go); boardCard.Init(card); boardCard.SetHighlightingEnabled(false); boardCard.Transform.position = _centerPos; boardCard.GameObject.GetComponent <SortingGroup>().sortingLayerID = SRSortingLayers.Default.id; boardCard.GameObject.GetComponent <SortingGroup>().sortingOrder = 1; Vector3 pos = _cardPlaceholders.transform.GetChild(i).position; Vector3 rotation = _cardPlaceholders.transform.GetChild(i).eulerAngles; go.transform.localScale = Vector3.one * .28f; go.transform.DOMove(pos, 1.0f); go.transform.DORotate(rotation, 1.0f); _createdBoardCards.Add(boardCard); } }
public void SelectCard(BoardCard card) { _uiManager.GetPopup <CardInfoPopup>().Hide(); ClearPreviewCard(); Opening?.Invoke(); _blockedClosing = true; SetIsStateChanging(true); _selectedCollectionCard = card; if (_previewCard != null && _previewCard.GameObject != null) { Object.DestroyImmediate(_previewCard.GameObject); } _previewCard = new BoardCard(Object.Instantiate(card.GameObject)); _previewCard.GameObject.name = "CardPreview"; _previewCard.GameObject.transform.position = card.GameObject.transform.position; _previewCard.GameObject.transform.localScale = card.GameObject.transform.lossyScale; _previewCard.GameObject.GetComponent <SortingGroup>().sortingLayerID = SRSortingLayers.GameUI2; PreviewCardInstantiated?.Invoke(_previewCard); Sequence mySequence = DOTween.Sequence(); mySequence.Append(_previewCard.Transform.DORotate(new Vector3(-20, 30, -20), .2f)); mySequence.Append(_previewCard.Transform.DORotate(new Vector3(0, 0, 0), .4f)); Sequence mySequence2 = DOTween.Sequence(); mySequence2.Append(_previewCard.Transform.DOMove(new Vector3(-4.3f, 1.2f, 5), .4f)); mySequence2.Append(_previewCard.Transform.DOMove(new Vector3(-4.3f, .8f, 5), .2f)); Sequence mySequence3 = DOTween.Sequence(); mySequence3.Append(_previewCard.Transform.DOScale(new Vector3(.9f, .9f, .9f), .4f)); mySequence3.Append(_previewCard.Transform.DOScale(new Vector3(.72f, .72f, .72f), .2f)); mySequence3.OnComplete( () => { SetIsStateChanging(false); }); _uiManager.GetPopup <CardInfoPopup>().BlockedClosing = true; _uiManager.GetPopup <CardInfoPopup>().CardTransform = _previewCard.Transform; _uiManager.DrawPopup <CardInfoPopup>(card.LibraryCard); GameClient.Get <ITimerManager>().AddTimer( x => { _blockedClosing = false; _uiManager.GetPopup <CardInfoPopup>().BlockedClosing = false; }); }
public void UpdatePositionOfCardsInPlayerHand(bool isMove = false) { float handWidth = 0.0f; float spacing = -1.5f; float scaling = 0.25f; Vector3 pivot = new Vector3(6f, -7.5f, 0f); int twistPerCard = -5; if (CardsZoomed) { spacing = -2.6f; scaling = 0.31f; pivot = new Vector3(-1.3f, -6.5f, 0f); twistPerCard = -3; } for (int i = 0; i < PlayerHandCards.Count; i++) { handWidth += spacing; } handWidth -= spacing; if (PlayerHandCards.Count == 1) { twistPerCard = 0; } int totalTwist = twistPerCard * PlayerHandCards.Count; float startTwist = (totalTwist - twistPerCard) / 2f; float scalingFactor = 0.04f; Vector3 moveToPosition = Vector3.zero; for (int i = 0; i < PlayerHandCards.Count; i++) { BoardCard card = PlayerHandCards[i]; float twist = startTwist - i * twistPerCard; float nudge = Mathf.Abs(twist); nudge *= scalingFactor; moveToPosition = new Vector3(pivot.x - handWidth / 2, pivot.y - nudge, (PlayerHandCards.Count - i) * 0.1f); if (isMove) { card.IsNewCard = false; } card.UpdateCardPositionInHand(moveToPosition, Vector3.forward * twist, Vector3.one * scaling); pivot.x += handWidth / PlayerHandCards.Count; card.GameObject.GetComponent <SortingGroup>().sortingLayerID = SRSortingLayers.HandCards; card.GameObject.GetComponent <SortingGroup>().sortingOrder = i; } }
public void HideCardPreview() { StopHandTimer(); _battlegroundController.DestroyCardPreview(); _delayTimerOfClick = 0f; _startedOnClickDelay = false; _topmostBoardCard = null; _selectedBoardUnit = null; }
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(); }
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 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 HoverPlayerCardOnBattleground(Player player, BoardCard card, HandBoardCard handCard) { Card libraryCard = card.WorkingCard.LibraryCard; if (libraryCard.CardKind == Enumerators.CardKind.CREATURE) { int newIndexOfCard = 0; float newCreatureCardPosition = card.Transform.position.x; // set correct position on board depends from card view position for (int i = 0; i < player.BoardCards.Count; i++) { if (newCreatureCardPosition > player.BoardCards[i].Transform.position.x) { newIndexOfCard = i + 1; } else { break; } } if (player.BoardCards.Count > 0 && _indexOfCard != newIndexOfCard) { _indexOfCard = newIndexOfCard; List <BoardUnit> playerCards = _gameplayManager.CurrentPlayer.BoardCards; List <BoardUnit> toArrangeList = new List <BoardUnit>(); for (int i = 0; i < playerCards.Count; i++) { toArrangeList.Add(playerCards[i]); } if (_fakeBoardCard != null) { Object.Destroy(_fakeBoardCard.GameObject); _fakeBoardCard = null; } _fakeBoardCard = new BoardUnit(_playerBoard.transform); toArrangeList.Insert(_indexOfCard, _fakeBoardCard); _battlegroundController.UpdatePositionOfBoardUnitsOfPlayer(toArrangeList); } } }
public override void SetInfo() { base.SetInfo(); _callerPlayer = GameAction.Parameters[0] as Player; if (GameAction.Parameters.Length > 1) { _playedCard = GameAction.Parameters[1] as BoardCard; string rarity = Enum.GetName(typeof(Enumerators.CardRank), _playedCard.WorkingCard.LibraryCard.CardRank); string cardSetName = CardsController.GetSetOfCard(_playedCard.WorkingCard.LibraryCard); PreviewImage.sprite = LoadObjectsManager.GetObjectByPath <Sprite>( string.Format("Images/Cards/Illustrations/{0}_{1}_{2}", cardSetName.ToLower(), rarity.ToLower(), _playedCard.WorkingCard.LibraryCard.Picture.ToLower())); _playedCardPreviewObject = CreateCardPreview(_playedCard.WorkingCard, Vector3.zero); } }
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 void DrawTooltipInfoOfCard(BoardCard boardCard) { GameClient.Get <ICameraManager>().FadeIn(0.8f, 1); if (boardCard.WorkingCard.LibraryCard.CardKind == Enumerators.CardKind.SPELL) { return; } BuffOnCardInfoObjects = new List <BuffOnCardInfoObject>(); const float offset = 0f; const float spacing = -6.75f; BuffOnCardInfoObject buff; List <BuffTooltipInfo> buffs = new List <BuffTooltipInfo>(); // left block info ------------------------------------ if (boardCard.WorkingCard.LibraryCard.CardRank != Enumerators.CardRank.MINION) { TooltipContentData.RankInfo rankInfo = DataManager.GetRankInfoByType(boardCard.WorkingCard.LibraryCard.CardRank.ToString()); if (rankInfo != null) { TooltipContentData.RankInfo.RankDescription rankDescription = rankInfo.Info.Find(y => y.Element.ToLower() .Equals(CardsController.GetSetOfCard(boardCard.WorkingCard.LibraryCard).ToLower())); buffs.Add( new BuffTooltipInfo { Title = rankInfo.Name, Description = rankDescription.Tooltip, TooltipObjectType = Enumerators.TooltipObjectType.RANK, Value = -1 }); } } if (boardCard.WorkingCard.Type != Enumerators.CardType.WALKER && boardCard.WorkingCard.Type != Enumerators.CardType.NONE) { TooltipContentData.BuffInfo buffInfo = DataManager.GetBuffInfoByType(boardCard.WorkingCard.Type.ToString()); if (buffInfo != null) { buffs.Add( new BuffTooltipInfo { Title = buffInfo.Name, Description = buffInfo.Tooltip, TooltipObjectType = Enumerators.TooltipObjectType.UNIT_TYPE, Value = -1 }); } } if (boardCard.WorkingCard.LibraryCard.Abilities != null) { foreach (AbilityData abil in boardCard.WorkingCard.LibraryCard.Abilities) { TooltipContentData.BuffInfo buffInfo = DataManager.GetBuffInfoByType(abil.BuffType); if (buffInfo != null) { buffs.Add( new BuffTooltipInfo { Title = buffInfo.Name, Description = buffInfo.Tooltip, TooltipObjectType = Enumerators.TooltipObjectType.ABILITY, Value = GetValueOfAbilityByType(abil) }); } } } for (int i = 0; i < buffs.Count; i++) { if (i >= 3) { break; } if (BuffOnCardInfoObjects.Find(x => x.BuffTooltipInfo.Title.Equals(buffs[i].Title)) != null) { continue; } buff = new BuffOnCardInfoObject(buffs[i], ParentOfLeftBlockOfCardInfo, offset + spacing * i); BuffOnCardInfoObjects.Add(buff); } buffs.Clear(); float cardSize = 7.2f; float centerOffset = -7f; if (!InternalTools.IsTabletScreen()) { cardSize = 6.6f; centerOffset = -10f; } InternalTools.GroupVerticalObjects(ParentOfLeftBlockOfCardInfo, 0f, centerOffset, cardSize); }
public void MoveCardFromPlayerDeckToPlayerHandAnimation(Player fromDeck, Player toHand, BoardCard boardCard) { boardCard.DrawCardFromOpponentDeckToPlayer(); }
public void RemoveCard(object[] param) { _soundManager.PlaySound(Enumerators.SoundType.CARD_BATTLEGROUND_TO_TRASH, Constants.CardsMoveSoundVolume); BoardCard card = param[0] as BoardCard; GameObject go = card.GameObject; SortingGroup sortingGroup = card.GameObject.GetComponent <SortingGroup>(); Sequence animationSequence3 = DOTween.Sequence(); animationSequence3.Append(go.transform.DORotate(new Vector3(0, 90, 90), .3f)); go.transform.DOScale(new Vector3(.195f, .195f, .195f), .2f); animationSequence3.OnComplete( () => { go.transform.Find("Back").gameObject.SetActive(true); Sequence animationSequence4 = DOTween.Sequence(); animationSequence4.Append(go.transform.DORotate(new Vector3(0, 180, 0f), .45f)); // Changing layers to all child objects to set them Behind the Graveyard Card sortingGroup.sortingLayerID = SRSortingLayers.Foreground; sortingGroup.sortingOrder = 7; sortingGroup.gameObject.layer = 0; for (int i = 0; i < sortingGroup.transform.childCount; i++) { Transform child = sortingGroup.transform.GetChild(i); if (child.name != "Back") { child.gameObject.SetActive(false); } else { child.gameObject.layer = 0; } } }); Sequence animationSequence2 = DOTween.Sequence(); animationSequence2.Append(go.transform.DOMove(new Vector3(-7.74f, -1, 0), 0.7f)); animationSequence2.OnComplete( () => { for (int i = 0; i < sortingGroup.transform.childCount; i++) { Transform child = sortingGroup.transform.GetChild(i); if (child.name == "Back") { child.GetComponent <SpriteRenderer>().maskInteraction = SpriteMaskInteraction.VisibleOutsideMask; } } Sequence animationSequence5 = DOTween.Sequence(); animationSequence5.Append(go.transform.DOMove(new Vector3(-7.74f, -4.352f, 0), .5f)); animationSequence5.OnComplete( () => { Object.Destroy(go); }); }); }
private void CallSpellCardPlay(BoardCard card) { }
private void CallPermanentAbilityAction( bool isPlayer, Action <BoardCard> action, BoardCard card, object target, ActiveAbility activeAbility, Enumerators.CardKind kind) { if (isPlayer) { if (kind == Enumerators.CardKind.SPELL) { card.WorkingCard.Owner.Goo -= card.ManaCost; _tutorialManager.ReportAction(Enumerators.TutorialReportAction.MOVE_CARD); card.GameObject.SetActive(true); card.RemoveCardParticle.Play(); // move it when card should call hide action card.WorkingCard.Owner.RemoveCardFromHand(card.WorkingCard); card.WorkingCard.Owner.AddCardToBoard(card.WorkingCard); GameClient.Get <ITimerManager>().AddTimer(_cardsController.RemoveCard, new object[] { card }, 0.5f); GameClient.Get <ITimerManager>().AddTimer( create => { card.WorkingCard.Owner.GraveyardCardsCount++; _actionsQueueController.PostGameActionReport(_actionsQueueController.FormatGameActionReport( Enumerators.ActionType.PLAY_SPELL_CARD, new object[] { card.WorkingCard.Owner, card })); }, null, 1.5f); } action?.Invoke(card); } else { if (activeAbility == null) { return; } switch (target) { case BoardUnit unit: activeAbility.Ability.TargetUnit = unit; break; case Player player: activeAbility.Ability.TargetPlayer = player; break; } activeAbility.Ability.SelectedTargetAction(true); } _battlegroundController.UpdatePositionOfBoardUnitsOfPlayer(_gameplayManager.CurrentPlayer.BoardCards); _battlegroundController.UpdatePositionOfBoardUnitsOfOpponent(); }
private void HandleInput() { if (_boardArrowController.IsBoardArrowNowInTheBattle || !_gameplayManager.CanDoDragActions) { return; } Vector3 mousePos = Camera.main.ScreenToWorldPoint(Input.mousePosition); if (Input.GetMouseButtonDown(0)) { RaycastHit2D[] hits = Physics2D.RaycastAll(mousePos, Vector2.zero); List <GameObject> hitCards = new List <GameObject>(); bool hitHandCard = false; bool hitBoardCard = false; foreach (RaycastHit2D hit in hits) { if (hit.collider != null && hit.collider.gameObject != null && _battlegroundController.GetBoardCardFromHisObject(hit.collider.gameObject) != null) { hitCards.Add(hit.collider.gameObject); hitHandCard = true; } } if (!hitHandCard) { foreach (RaycastHit2D hit in hits) { if (hit.collider != null && hit.collider.name.Contains("BoardCreature")) { hitCards.Add(hit.collider.gameObject); hitBoardCard = true; } } } if (hitHandCard) { if (hitCards.Count > 0) { hitCards = hitCards.OrderBy(x => x.GetComponent <SortingGroup>().sortingOrder).ToList(); BoardCard topmostBoardCard = _battlegroundController.GetBoardCardFromHisObject(hitCards[hitCards.Count - 1]); if (topmostBoardCard != null && !topmostBoardCard.IsPreview) { float delta = Application.isMobilePlatform ? Constants.PointerMinDragDelta * 2f : Constants.PointerMinDragDeltaMobile; _pointerEventSolver.PushPointer(delta); _startedOnClickDelay = true; _isPreviewHandCard = true; _topmostBoardCard = topmostBoardCard; } } } else if (hitBoardCard) { if (hitCards.Count > 0) { StopHandTimer(); hitCards = hitCards.OrderBy(x => x.GetComponent <SortingGroup>().sortingOrder).ToList(); BoardUnit selectedBoardUnit = _battlegroundController.GetBoardUnitFromHisObject(hitCards[hitCards.Count - 1]); if (selectedBoardUnit != null && (!_battlegroundController.IsPreviewActive || selectedBoardUnit.Card.InstanceId != _battlegroundController.CurrentPreviewedCardId)) { float delta = Application.isMobilePlatform ? Constants.PointerMinDragDelta * 2f : Constants.PointerMinDragDeltaMobile; _pointerEventSolver.PushPointer(delta); _startedOnClickDelay = true; _isPreviewHandCard = false; _selectedBoardUnit = selectedBoardUnit; } } } else { if (_battlegroundController.IsPreviewActive) { HideCardPreview(); } else { _timerManager.StopTimer(SetStatusZoomingFalse); _cardsZooming = true; _timerManager.AddTimer(SetStatusZoomingFalse); _battlegroundController.CardsZoomed = false; _battlegroundController.UpdatePositionOfCardsInPlayerHand(); } } } if (_startedOnClickDelay) { _delayTimerOfClick += Time.deltaTime; } if (Input.GetMouseButtonUp(0)) { _pointerEventSolver.PopPointer(); } if (_boardArrowController.CurrentBoardArrow != null && _boardArrowController.CurrentBoardArrow.IsDragging()) { _battlegroundController.DestroyCardPreview(); } }
public void CallAbility( Card libraryCard, BoardCard card, WorkingCard workingCard, Enumerators.CardKind kind, object boardObject, Action <BoardCard> action, bool isPlayer, Action onCompleteCallback, object target = null, HandBoardCard handCard = null) { ResolveAllAbilitiesOnUnit(boardObject, false); bool canUseAbility = false; ActiveAbility activeAbility = null; foreach (AbilityData item in libraryCard.Abilities) { // todo improve it bcoz can have queue of abilities with targets activeAbility = CreateActiveAbility(item, kind, boardObject, workingCard.Owner, libraryCard, workingCard); if (IsAbilityCanActivateTargetAtStart(item)) { canUseAbility = true; } else { activeAbility.Ability.Activate(); } } if (kind == Enumerators.CardKind.SPELL) { } else { workingCard.Owner.RemoveCardFromHand(workingCard); workingCard.Owner.AddCardToBoard(workingCard); } if (kind == Enumerators.CardKind.SPELL) { if (handCard != null && isPlayer) { handCard.GameObject.SetActive(false); } } if (canUseAbility) { AbilityData ability = libraryCard.Abilities.Find(x => IsAbilityCanActivateTargetAtStart(x)); if (ability.TargetCardType != Enumerators.CardType.NONE && !HasSpecialUnitOnBoard(workingCard, ability) || ability.TargetUnitStatusType != Enumerators.UnitStatusType.NONE && !HasSpecialUnitStatusOnBoard(workingCard, ability)) { CallPermanentAbilityAction(isPlayer, action, card, target, activeAbility, kind); onCompleteCallback?.Invoke(); ResolveAllAbilitiesOnUnit(boardObject); return; } if (CheckActivateAvailability(kind, ability, workingCard.Owner)) { activeAbility.Ability.Activate(); if (isPlayer) { activeAbility.Ability.ActivateSelectTarget( callback: () => { if (kind == Enumerators.CardKind.SPELL && isPlayer) { card.WorkingCard.Owner.Goo -= card.ManaCost; _tutorialManager.ReportAction(Enumerators.TutorialReportAction.MOVE_CARD); handCard.GameObject.SetActive(true); card.RemoveCardParticle.Play(); // move it when card should call hide action workingCard.Owner.RemoveCardFromHand(workingCard, true); workingCard.Owner.AddCardToBoard(workingCard); GameClient.Get <ITimerManager>().AddTimer(_cardsController.RemoveCard, new object[] { card }, 0.5f); GameClient.Get <ITimerManager>().AddTimer( creat => { workingCard.Owner.GraveyardCardsCount++; _actionsQueueController.PostGameActionReport( _actionsQueueController.FormatGameActionReport( Enumerators.ActionType.PLAY_SPELL_CARD, new object[] { workingCard.Owner, card })); }, null, 1.5f); } action?.Invoke(card); onCompleteCallback?.Invoke(); ResolveAllAbilitiesOnUnit(boardObject); }, failedCallback: () => { if (kind == Enumerators.CardKind.SPELL && isPlayer) { handCard.GameObject.SetActive(true); handCard.ResetToHandAnimation(); handCard.CheckStatusOfHighlight(); workingCard.Owner.CardsInHand.Add(card.WorkingCard); _battlegroundController.PlayerHandCards.Add(card); _battlegroundController.UpdatePositionOfCardsInPlayerHand(); _playerController.IsCardSelected = false; } else { Debug.Log("RETURN CARD TO HAND MAYBE.. SHOULD BE CASE !!!!!"); action?.Invoke(card); } onCompleteCallback?.Invoke(); ResolveAllAbilitiesOnUnit(boardObject); }); } else { switch (target) { case BoardUnit unit: activeAbility.Ability.TargetUnit = unit; break; case Player player: activeAbility.Ability.TargetPlayer = player; break; } activeAbility.Ability.SelectedTargetAction(true); _battlegroundController.UpdatePositionOfBoardUnitsOfPlayer(_gameplayManager.CurrentPlayer .BoardCards); _battlegroundController.UpdatePositionOfBoardUnitsOfOpponent(); onCompleteCallback?.Invoke(); ResolveAllAbilitiesOnUnit(boardObject); } } else { CallPermanentAbilityAction(isPlayer, action, card, target, activeAbility, kind); onCompleteCallback?.Invoke(); ResolveAllAbilitiesOnUnit(boardObject); } } else { CallPermanentAbilityAction(isPlayer, action, card, target, activeAbility, kind); onCompleteCallback?.Invoke(); ResolveAllAbilitiesOnUnit(boardObject); } }
private void ClearPreviewCard() { Object.Destroy(_previewCard?.GameObject); _previewCard = null; }
public BoardCard GetBoardCardFromHisObject(GameObject cardObject) { BoardCard card = PlayerHandCards.Find(x => x.GameObject.Equals(cardObject)); return(card); }
public void PlayPlayerCard(Player player, BoardCard card, HandBoardCard handCard) { if (card.CanBePlayed(card.WorkingCard.Owner)) { Card libraryCard = card.WorkingCard.LibraryCard; card.Transform.DORotate(Vector3.zero, .1f); card.HandBoardCard.Enabled = false; _soundManager.PlaySound(Enumerators.SoundType.CARD_FLY_HAND_TO_BATTLEGROUND, Constants.CardsMoveSoundVolume); player.ThrowPlayCardEvent(card.WorkingCard); switch (libraryCard.CardKind) { case Enumerators.CardKind.CREATURE: { int indexOfCard = 0; float newCreatureCardPosition = card.Transform.position.x; // set correct position on board depends from card view position for (int i = 0; i < player.BoardCards.Count; i++) { if (newCreatureCardPosition > player.BoardCards[i].Transform.position.x) { indexOfCard = i + 1; } else { break; } } BoardUnit boardUnit = new BoardUnit(_playerBoard.transform); boardUnit.Transform.tag = SRTags.PlayerOwned; boardUnit.Transform.parent = _playerBoard.transform; boardUnit.Transform.position = new Vector2(1.9f * player.BoardCards.Count, 0); boardUnit.OwnerPlayer = card.WorkingCard.Owner; boardUnit.SetObjectInfo(card.WorkingCard); _battlegroundController.PlayerHandCards.Remove(card); _battlegroundController.PlayerBoardCards.Add(boardUnit); player.AddCardToBoard(card.WorkingCard); player.RemoveCardFromHand(card.WorkingCard); player.BoardCards.Insert(indexOfCard, boardUnit); _timerManager.AddTimer( creat => { card.WorkingCard.Owner.GraveyardCardsCount++; }); card.RemoveCardParticle.Play(); _actionsQueueController.PostGameActionReport(_actionsQueueController.FormatGameActionReport( Enumerators.ActionType.PLAY_UNIT_CARD, new object[] { boardUnit.OwnerPlayer, boardUnit })); UpdateCardsStatusEvent?.Invoke(player); Sequence animationSequence = DOTween.Sequence(); animationSequence.Append(card.Transform.DOScale(new Vector3(.27f, .27f, .27f), 1f)); animationSequence.OnComplete( () => { RemoveCard(new object[] { card }); _timerManager.AddTimer( param => { boardUnit.PlayArrivalAnimation(); _battlegroundController.UpdatePositionOfBoardUnitsOfPlayer( _gameplayManager.CurrentPlayer.BoardCards, () => { _abilitiesController.CallAbility(libraryCard, card, card.WorkingCard, Enumerators.CardKind.CREATURE, boardUnit, CallCardPlay, true, null); }); }, null, 0.1f); }); player.Goo -= card.ManaCost; _tutorialManager.ReportAction(Enumerators.TutorialReportAction.MOVE_CARD); break; } case Enumerators.CardKind.SPELL: { player.CardsInHand.Remove(card.WorkingCard); _battlegroundController.PlayerHandCards.Remove(card); _battlegroundController.UpdatePositionOfCardsInPlayerHand(); card.GameObject.GetComponent <SortingGroup>().sortingLayerID = SRSortingLayers.BoardCards; card.GameObject.GetComponent <SortingGroup>().sortingOrder = 1000; BoardSpell boardSpell = new BoardSpell(card.GameObject, card.WorkingCard); boardSpell.Transform.position = Vector3.zero; _abilitiesController.CallAbility(libraryCard, card, card.WorkingCard, Enumerators.CardKind.SPELL, boardSpell, CallSpellCardPlay, true, null, handCard: handCard); break; } default: throw new ArgumentOutOfRangeException(); } } else { card.HandBoardCard.ResetToInitialPosition(); } }
private void PlayCardCompleteHandler(WorkingCard card, object target) { WorkingCard workingCard = _gameplayManager.OpponentPlayer.CardsOnBoard[_gameplayManager.OpponentPlayer.CardsOnBoard.Count - 1]; switch (card.LibraryCard.CardKind) { case Enumerators.CardKind.CREATURE: { BoardUnit boardUnitElement = new BoardUnit(GameObject.Find("OpponentBoard").transform); GameObject boardCreature = boardUnitElement.GameObject; boardCreature.tag = SRTags.OpponentOwned; boardCreature.transform.position = Vector3.zero; boardUnitElement.OwnerPlayer = card.Owner; boardUnitElement.SetObjectInfo(workingCard); _battlegroundController.OpponentBoardCards.Add(boardUnitElement); boardCreature.transform.position += Vector3.up * 2f; // Start pos before moving cards to the opponents board // PlayArrivalAnimation(boardCreature, libraryCard.cardType); _gameplayManager.OpponentPlayer.BoardCards.Add(boardUnitElement); _actionsQueueController.PostGameActionReport(_actionsQueueController.FormatGameActionReport( Enumerators.ActionType.PLAY_UNIT_CARD, new object[] { boardUnitElement.OwnerPlayer, boardUnitElement })); boardUnitElement.PlayArrivalAnimation(); _battlegroundController.UpdatePositionOfBoardUnitsOfOpponent( () => { bool createTargetArrow = false; if (card.LibraryCard.Abilities != null && card.LibraryCard.Abilities.Count > 0) { createTargetArrow = _abilitiesController.IsAbilityCanActivateTargetAtStart( card.LibraryCard.Abilities[0]); } if (target != null) { CreateOpponentTarget( createTargetArrow, false, boardCreature.gameObject, target, () => { _abilitiesController.CallAbility(card.LibraryCard, null, workingCard, Enumerators.CardKind.CREATURE, boardUnitElement, null, false, null, target); }); } else { _abilitiesController.CallAbility(card.LibraryCard, null, workingCard, Enumerators.CardKind.CREATURE, boardUnitElement, null, false, null); } }); break; } case Enumerators.CardKind.SPELL: { GameObject spellCard = Object.Instantiate(_cardsController.SpellCardViewPrefab); spellCard.transform.position = GameObject.Find("OpponentSpellsPivot").transform.position; CurrentSpellCard = new SpellBoardCard(spellCard); CurrentSpellCard.Init(workingCard); CurrentSpellCard.SetHighlightingEnabled(false); BoardSpell boardSpell = new BoardSpell(spellCard, workingCard); spellCard.gameObject.SetActive(false); bool createTargetArrow = false; if (card.LibraryCard.Abilities != null && card.LibraryCard.Abilities.Count > 0) { createTargetArrow = _abilitiesController.IsAbilityCanActivateTargetAtStart(card.LibraryCard.Abilities[0]); } if (target != null) { CreateOpponentTarget( createTargetArrow, false, _gameplayManager.OpponentPlayer.AvatarObject, target, () => { _abilitiesController.CallAbility(card.LibraryCard, null, workingCard, Enumerators.CardKind.SPELL, boardSpell, null, false, null, target); }); } else { _abilitiesController.CallAbility(card.LibraryCard, null, workingCard, Enumerators.CardKind.SPELL, boardSpell, null, false, null); } break; } } }
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); } }