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); }
public override void SetInfo() { base.SetInfo(); _attackingCreature = GameAction.Parameters[0] as BoardUnit; _attackingDamage = (int)GameAction.Parameters[1]; _attackedCreature = GameAction.Parameters[2] as BoardUnit; _attackedDamage = (int)GameAction.Parameters[3]; PreviewImage.sprite = _attackingCreature.Sprite; _attackingCreatureObj = CreateCardPreview(_attackingCreature.Card, Vector3.zero); _attackedCreatureObj = CreateCardPreview(_attackedCreature.Card, Vector3.right * 6); AttackingPictureObject.SetActive(true); GameObject attackViewPlayer = _attackedCreatureObj.transform.Find("AttackingHealth").gameObject; attackViewPlayer.SetActive(true); TextMeshPro damageText = attackViewPlayer.transform.Find("AttackText").GetComponent <TextMeshPro>(); damageText.text = (-_attackingDamage).ToString(); attackViewPlayer.transform.localPosition = -Vector3.up * 3; if (_attackedDamage > 0) { GameObject attackViewCreature = _attackingCreatureObj.transform.Find("AttackingHealth").gameObject; attackViewCreature.SetActive(true); TextMeshPro damageTextCreature = attackViewCreature.transform.Find("AttackText").GetComponent <TextMeshPro>(); damageTextCreature.text = (-_attackedDamage).ToString(); attackViewCreature.transform.localPosition = -Vector3.up * 3; } }
public override void SetInfo() { base.SetInfo(); _callerPlayer = GameAction.Parameters[0] as Player; _usedSkill = GameAction.Parameters[1] as HeroSkill; _skillValue = (int)GameAction.Parameters[2]; _skillUsedOnUnit = GameAction.Parameters[3] as BoardUnit; PreviewImage.sprite = LoadObjectsManager.GetObjectByPath <Sprite>("Images/Heroes/CZB_2D_Hero_Portrait_" + _callerPlayer.SelfHero.HeroElement + "_EXP"); AttackingPictureObject.SetActive(true); _attackedCreatureObj = CreateCardPreview(_skillUsedOnUnit.Card, Vector3.right * 6); _attackingPlayerObj = CreatePlayerPreview(_callerPlayer, Vector3.zero); GameObject cardView = _attackedCreatureObj.transform.Find("AttackingHealth").gameObject; cardView.SetActive(true); TextMeshPro damageText = cardView.transform.Find("AttackText").GetComponent <TextMeshPro>(); damageText.text = (-_skillValue).ToString(); cardView.transform.localPosition = -Vector3.up * 3; }
private void HealingTouchAction(Player owner, BoardSkill boardSkill, HeroSkill skill, object target) { if (target is Player) { Player player = target as Player; _battleController.HealPlayerBySkill(owner, skill, player); _vfxController.CreateVfx( _loadObjectsManager.GetObjectByPath <GameObject>("Prefabs/VFX/Skills/HealingTouchVFX"), player); _soundManager.PlaySound(Enumerators.SoundType.OVERLORD_ABILITIES, skill.OverlordSkill.ToString().ToLower(), Constants.OverlordAbilitySoundVolume, Enumerators.CardSoundType.NONE); } else { BoardUnit unit = target as BoardUnit; _battleController.HealUnitBySkill(owner, skill, unit); _vfxController.CreateVfx( _loadObjectsManager.GetObjectByPath <GameObject>("Prefabs/VFX/Skills/HealingTouchVFX"), unit); _soundManager.PlaySound(Enumerators.SoundType.OVERLORD_ABILITIES, skill.OverlordSkill.ToString().ToLower(), Constants.OverlordAbilitySoundVolume, Enumerators.CardSoundType.NONE); } }
public void AttackUnitByAbility( object attacker, AbilityData ability, BoardUnit attackedUnit, int damageOverride = -1) { int damage = ability.Value; if (damageOverride > 0) { damage = damageOverride; } if (attackedUnit != null) { if (damage > 0 && attackedUnit.HasBuffShield) { damage = 0; attackedUnit.UseShieldFromBuff(); } attackedUnit.CurrentHp -= damage; _vfxController.SpawnGotDamageEffect(attackedUnit, -damage); _actionsQueueController.PostGameActionReport(_actionsQueueController.FormatGameActionReport( Enumerators.ActionType.ATTACK_CREATURE_BY_ABILITY, new[] { attacker, ability, damage, attackedUnit })); } }
public override void Action(object info = null) { base.Action(info); BoardUnit unit = info as BoardUnit; int targetIndex = -1; for (int i = 0; i < unit.OwnerPlayer.BoardCards.Count; i++) { if (unit.OwnerPlayer.BoardCards[i] == unit) { targetIndex = i; break; } } if (targetIndex > -1) { if (targetIndex - 1 > -1) { TakeDamageToUnit(unit.OwnerPlayer.BoardCards[targetIndex - 1]); } if (targetIndex + 1 < unit.OwnerPlayer.BoardCards.Count) { TakeDamageToUnit(unit.OwnerPlayer.BoardCards[targetIndex + 1]); } } }
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 override void OnCardSelected(BoardUnit unit) { if (unit.CurrentHp <= 0) { return; } if (PossibleTargets.Contains(Enumerators.AbilityTargetType.PLAYER_CARD) && unit.GameObject.CompareTag(SRTags.PlayerOwned) || PossibleTargets.Contains(Enumerators.AbilityTargetType.OPPONENT_CARD) && unit.GameObject.CompareTag(SRTags.OpponentOwned) || PossibleTargets.Contains(Enumerators.AbilityTargetType.ALL)) { if (TargetUnitType == Enumerators.CardType.NONE || unit.InitialUnitType == TargetUnitType) { if (TargetUnitStatusType == Enumerators.UnitStatusType.NONE || unit.UnitStatus == TargetUnitStatusType) { if (SelfBoardCreature != unit) { SelectedCard?.SetSelectedUnit(false); SelectedCard = unit; SelectedPlayer?.SetGlowStatus(false); SelectedPlayer = null; SelectedCard.SetSelectedUnit(true); CardSelected?.Invoke(unit); } } } } }
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); }
public override void OnCardUnselected(BoardUnit creature) { if (SelectedCard == creature) { SelectedCard.SetSelectedUnit(false); SelectedCard = null; } }
private void PointerEventSolverEndedHandler() { _delayTimerOfClick = 0f; _startedOnClickDelay = false; _topmostBoardCard = null; _selectedBoardUnit = null; }
public override void Action(object info = null) { base.Action(info); BoardUnit unit = info as BoardUnit; BattlegroundController.DestroyBoardUnit(unit); }
public override void Action(object info = null) { base.Action(info); BoardUnit unit = info as BoardUnit; Player playerOwner = unit.OwnerPlayer; BoardUnit leftAdjustment = null, rightAdjastment = null; int targetIndex = -1; List <BoardUnit> list = null; for (int i = 0; i < playerOwner.BoardCards.Count; i++) { if (playerOwner.BoardCards[i] == unit) { targetIndex = i; list = playerOwner.BoardCards; break; } } object caller = AbilityUnitOwner != null ? AbilityUnitOwner : (object)BoardSpell; if (targetIndex > -1) { if (targetIndex - 1 > -1) { leftAdjustment = list[targetIndex - 1]; } if (targetIndex + 1 < list.Count) { rightAdjastment = list[targetIndex + 1]; } } if (leftAdjustment != null) { CreateAndMoveParticle( () => { BattleController.AttackUnitByAbility(caller, AbilityData, leftAdjustment); }, leftAdjustment.Transform.position); } if (rightAdjastment != null) { CreateAndMoveParticle( () => { BattleController.AttackUnitByAbility(caller, AbilityData, rightAdjastment); }, rightAdjastment.Transform.position); } }
public void KillBoardCard(BoardUnit cardToDestroy) { if (cardToDestroy == null) { return; } if (_lastBoardUntilOnPreview != null && cardToDestroy == _lastBoardUntilOnPreview) { DestroyCardPreview(); } cardToDestroy.Transform.position = new Vector3(cardToDestroy.Transform.position.x, cardToDestroy.Transform.position.y, cardToDestroy.Transform.position.z + 0.2f); _timerManager.AddTimer( x => { cardToDestroy.Transform.DOShakePosition(.7f, 0.25f, 10, 90, false, false); string cardDeathSoundName = cardToDestroy.Card.LibraryCard.Name.ToLower() + "_" + Constants.CardSoundDeath; float soundLength = 0f; if (!cardToDestroy.OwnerPlayer.Equals(_gameplayManager.CurrentTurnPlayer)) { _soundManager.PlaySound(Enumerators.SoundType.CARDS, cardDeathSoundName, Constants.ZombieDeathVoDelayBeforeFadeout, Constants.ZombiesSoundVolume, Enumerators.CardSoundType.DEATH); soundLength = _soundManager.GetSoundLength(Enumerators.SoundType.CARDS, cardDeathSoundName); } _timerManager.AddTimer( t => { cardToDestroy.OwnerPlayer.BoardCards.Remove(cardToDestroy); cardToDestroy.OwnerPlayer.RemoveCardFromBoard(cardToDestroy.Card); cardToDestroy.OwnerPlayer.AddCardToGraveyard(cardToDestroy.Card); cardToDestroy.InvokeUnitDied(); cardToDestroy.Transform.DOKill(); Object.Destroy(cardToDestroy.GameObject); _timerManager.AddTimer( f => { UpdatePositionOfBoardUnitsOfOpponent(); UpdatePositionOfBoardUnitsOfPlayer(_gameplayManager.CurrentPlayer.BoardCards); }, null, Time.deltaTime); }, null, soundLength); }); }
public void HideCardPreview() { StopHandTimer(); _battlegroundController.DestroyCardPreview(); _delayTimerOfClick = 0f; _startedOnClickDelay = false; _topmostBoardCard = null; _selectedBoardUnit = null; }
public BoardUnit GetBoardUnitFromHisObject(GameObject unitObject) { BoardUnit unit = PlayerBoardCards.Find(x => x.GameObject.Equals(unitObject)); if (unit == null) { unit = OpponentBoardCards.Find(x => x.GameObject.Equals(unitObject)); } return(unit); }
public override void SetInfo() { base.SetInfo(); _callerPlayer = GameAction.Parameters[0] as Player; _playedCard = GameAction.Parameters[1] as BoardUnit; PreviewImage.sprite = _playedCard.Sprite; _playedCardPreviewObject = CreateCardPreview(_playedCard.Card, Vector3.zero); }
public void AttackUnitByUnit(BoardUnit attackingUnit, BoardUnit attackedUnit, int additionalDamage = 0) { int damageAttacked = 0; int damageAttacking; if (attackingUnit != null && attackedUnit != null) { int additionalDamageAttacker = _abilitiesController.GetStatModificatorByAbility(attackingUnit, attackedUnit, true); int additionalDamageAttacked = _abilitiesController.GetStatModificatorByAbility(attackedUnit, attackingUnit, false); damageAttacking = attackingUnit.CurrentDamage + additionalDamageAttacker + additionalDamage; if (damageAttacking > 0 && attackedUnit.HasBuffShield) { damageAttacking = 0; attackedUnit.HasUsedBuffShield = true; } attackedUnit.CurrentHp -= damageAttacking; _vfxController.SpawnGotDamageEffect(attackedUnit, -damageAttacking); attackedUnit.InvokeUnitDamaged(attackingUnit); attackingUnit.InvokeUnitAttacked(attackedUnit, damageAttacking, true); if (attackedUnit.CurrentHp > 0 && attackingUnit.AttackAsFirst || !attackingUnit.AttackAsFirst) { damageAttacked = attackedUnit.CurrentDamage + additionalDamageAttacked; if (damageAttacked > 0 && attackingUnit.HasBuffShield) { damageAttacked = 0; attackingUnit.HasUsedBuffShield = true; } attackingUnit.CurrentHp -= damageAttacked; _vfxController.SpawnGotDamageEffect(attackingUnit, -damageAttacked); attackingUnit.InvokeUnitDamaged(attackedUnit); attackedUnit.InvokeUnitAttacked(attackingUnit, damageAttacked, false); } _actionsQueueController.PostGameActionReport(_actionsQueueController.FormatGameActionReport( Enumerators.ActionType.ATTACK_CREATURE_BY_CREATURE, new object[] { attackingUnit, damageAttacking, attackedUnit, damageAttacked })); _tutorialManager.ReportAction(Enumerators.TutorialReportAction.ATTACK_CARD_CARD); } }
private void ReturnBoardUnitToDeck(BoardUnit unit) { if (AbilityUnitOwner != null && unit == AbilityUnitOwner || unit == null) { return; } // implement animation unit.OwnerPlayer.AddCardToDeck(new WorkingCard(unit.Card.LibraryCard.Clone(), unit.OwnerPlayer)); unit.MoveUnitFromBoardToDeck(); }
private void ReturnBoardUnitToHand(BoardUnit unit) { CreateVfx(unit.Transform.position, true, 3f, true); CardsController.ReturnCardToHand(unit); ActionsQueueController.PostGameActionReport(ActionsQueueController.FormatGameActionReport( Enumerators.ActionType.RETURN_TO_HAND_CARD_ABILITY, new object[] { PlayerCallerOfAbility, AbilityData, unit })); }
public override void SetInfo() { base.SetInfo(); _callerPlayer = GameAction.Parameters[0] as Player; _skillUsedOnUnit = GameAction.Parameters[1] as BoardUnit; PreviewImage.sprite = _skillUsedOnUnit.Sprite; _skillOwnerObject = CreatePlayerPreview(_callerPlayer, Vector3.zero); _stunnedUnitPreviewObject = CreateCardPreview(_skillUsedOnUnit.Card, Vector3.right * 6); }
public void End(BoardUnit creature) { if (!StartedDrag) { return; } StartedDrag = false; creature.DoCombat(SelectedCard ?? (object)SelectedPlayer); Dispose(); }
public override void SetInfo() { base.SetInfo(); _abilityUnitOwner = GameAction.Parameters[0] as BoardUnit; _abilityUsedOnUnit = GameAction.Parameters[1] as BoardUnit; PreviewImage.sprite = _abilityUnitOwner.Sprite; _abilityOwnerObject = CreateCardPreview(_abilityUnitOwner.Card, Vector3.zero); _stunnedUnitPreviewObject = CreateCardPreview(_abilityUsedOnUnit.Card, Vector3.zero); }
public void UpdatePositionOfBoardUnitsOfOpponent(Action onComplete = null) { if (_gameplayManager.IsGameEnded) { return; } if (_rearrangingTopRealTimeSequence != null) { _rearrangingTopRealTimeSequence.Kill(); _rearrangingTopRealTimeSequence = null; } List <BoardUnit> opponentBoardCards = _gameplayManager.OpponentPlayer.BoardCards; float boardWidth = 0.0f; float spacing = 0.2f; float cardWidth = 0.0f; for (int i = 0; i < opponentBoardCards.Count; i++) { cardWidth = 2.5f; boardWidth += cardWidth; boardWidth += spacing; } boardWidth -= spacing; List <Vector2> newPositions = new List <Vector2>(opponentBoardCards.Count); Vector3 pivot = OpponentBoardObject.transform.position; for (int i = 0; i < opponentBoardCards.Count; i++) { newPositions.Add(new Vector2(pivot.x - boardWidth / 2 + cardWidth / 2, pivot.y + 0.0f)); pivot.x += boardWidth / opponentBoardCards.Count; } Sequence sequence = DOTween.Sequence(); for (int i = 0; i < opponentBoardCards.Count; i++) { BoardUnit card = opponentBoardCards[i]; sequence.Insert(0, card.Transform.DOMove(newPositions[i], 0.4f).SetEase(Ease.OutSine)); } _rearrangingTopRealTimeSequence = sequence; sequence.OnComplete( () => { onComplete?.Invoke(); }); }
public void ResetPlayerCardsOnBattlegroundPosition() { if (_indexOfCard != -1) { _battlegroundController.UpdatePositionOfBoardUnitsOfPlayer(_gameplayManager.CurrentPlayer.BoardCards); _indexOfCard = -1; if (_fakeBoardCard != null) { Object.Destroy(_fakeBoardCard.GameObject); _fakeBoardCard = null; } } }
private void RabiesAction(Player owner, BoardSkill boardSkill, HeroSkill skill, object target) { if (target != null && target is BoardUnit) { BoardUnit unit = target as BoardUnit; unit.SetAsFeralUnit(); _vfxController.CreateVfx( _loadObjectsManager.GetObjectByPath <GameObject>("Prefabs/VFX/Skills/RabiesVFX"), unit); _soundManager.PlaySound(Enumerators.SoundType.OVERLORD_ABILITIES, skill.OverlordSkill.ToString().ToLower(), Constants.OverlordAbilitySoundVolume, Enumerators.CardSoundType.NONE); } }
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 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); } } }
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 HealUnitBySkill(Player healingPlayer, HeroSkill skill, BoardUnit healedCreature) { if (healedCreature != null) { healedCreature.CurrentHp += skill.Value; if (healedCreature.CurrentHp > healedCreature.MaxCurrentHp) { healedCreature.CurrentHp = healedCreature.MaxCurrentHp; } } _actionsQueueController.PostGameActionReport(_actionsQueueController.FormatGameActionReport( Enumerators.ActionType.HEAL_CREATURE_BY_SKILL, new object[] { healingPlayer, skill, healedCreature })); }