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);
}
}
