public void SelectCard(CardGameObject cardGO, PlayerCombatObject player, System.Action <CardInHand> SelectCardCallback, System.Action RecalculateCardsPositionCallback)
{
// Player has selected a card from the hand.
// Ignore if it is not player's turn.
if (turn != TurnSelection.Players)
{
infoText.text = "It's not players' turn.";
return;
}
// From here on, it's player's turn.
// Ignore if the player is dead.
if (player.IsDead)
{
infoText.text = "Player is knocked out.";
return;
}
// Ignore if the player is disabled.
if (!player.IsAbleToAct())
{
infoText.text = "Player cannot act.";
return;
}
// Ignore if the player is disarmed and the card is attack.
if (cardGO.card.data.type == CardPlayerScriptableObject.Type.Attack && !player.IsAbleToAttack())
{
infoText.text = "Player is disarmed.";
return;
}
// Ignore if the player is silenced and the card is spell.
if (cardGO.card.data.type == CardPlayerScriptableObject.Type.Spell && !player.IsAbleToCast())
{
infoText.text = "Player is silenced.";
return;
}
// Ignore if the player does not have enough mana to play the card.
if (cardGO.card.manaCost > player.Mana)
{
infoText.text = "Not enough mana.";
return;
}
infoText.text = "";
stayUp = true;
currentCardOwner = player;
currentSelectedCard = cardGO;
foreach (var c in coroutines)
{
StopCoroutine(c);
}
coroutines.Add(StartCoroutine(SelectTargets(cardGO, SelectCardCallback, RecalculateCardsPositionCallback)));
}
HealthEntityCombatObject SpawnEntity(HealthEntity entity, Transform entityHolder, PlayerHand hand = null, GameObject ui = null)
{
GameObject newHealthEntityGO = GameObject.Instantiate(entityPrefab, entityHolder);
newHealthEntityGO.name = entity.Name;
if (entity is Player)
{
PlayerCombatObject player = newHealthEntityGO.gameObject.AddComponent <PlayerCombatObject>();
player.ui = GameObject.Instantiate(floatingPlayerUiPrefab, newHealthEntityGO.transform).GetComponent <PlayerUI>();
player.ui.gameObject.name = "UI";
player.ui.player = player;
player.Init((Player)entity, hand, ui, OnEntityDeath);
return(player);
}
else if (entity is Enemy)
{
Enemy enemyEntity = entity as Enemy;
EnemyCombatObject enemy = newHealthEntityGO.gameObject.AddComponent <EnemyCombatObject>();
enemy.ui = GameObject.Instantiate(floatingEnemyUiPrefab, newHealthEntityGO.transform).GetComponent <EnemyUI>();
enemy.ui.gameObject.name = "UI";
enemy.ui.enemy = enemy;
enemy.Init(enemyEntity, 0, OnEntityDeath);
return(enemy);
}
return(null);
}
public void Init(List <Card> startCombatCards, PlayerCombatObject player, System.Action UIRefreshCallback)
{
drawPile = new Pile(startCombatCards, true);
discardPile = new Pile();
cardsInHand = new List <CardInHand>();
OnUIRefresh += UIRefreshCallback;
this.player = player;
nativePowerSelector.Init(player);
}
public void SelectNativePower(NativePowerScriptableObject nativePower, PlayerCombatObject player)
{
// Player has selected a native power.
// Ignore if it is not player's turn.
if (turn != TurnSelection.Players)
{
infoText.text = "It's not players' turn.";
return;
}
// From here on, it's player's turn.
// Ignore if the player is dead.
if (player.IsDead)
{
infoText.text = "Player is knocked out.";
return;
}
// Ignore if the player is disabled.
if (!player.IsAbleToAct())
{
infoText.text = "Player cannot act.";
return;
}
// Ignore if the player does not have enough mana to activate the power.
if (nativePower.manaCost > player.Mana)
{
infoText.text = "Not enough mana.";
return;
}
infoText.text = "";
currentCardOwner = player;
currentPower = nativePower;
foreach (var c in coroutines)
{
StopCoroutine(c);
}
StartCoroutine(SelectTargets_Power(nativePower));
}
public void StartCombat(EncounterScriptableObject encounterSO, List <Player> players, System.Action <bool> callback)
{
//List<EnemyScriptableObject> enemyList = new List<EnemyScriptableObject>();
int i = 0;
foreach (var enemy in encounterSO.enemies)
{
EnemyCombatObject newEnemy = SpawnEntity(enemy, enemyManager.enemyPanel) as EnemyCombatObject;
newEnemy.enemyIndex = this.enemies.Count;
newEnemy.transform.localPosition = new Vector3(-encounterSO.enemies.Length / 2 + i, 0f, 0f);
newEnemy.transform.localEulerAngles = new Vector3(0, 180f, 0);
this.enemies.Add(newEnemy);
i++;
}
enemyManager.SpawnEnemies(this.enemies, OnEnemyDeath);
currentEncounter = encounterSO;
combatOver = false;
i = 0;
foreach (var p in players)
{
if (p.Health < 1)
{
p.Health = 1;
}
PlayerCombatObject newPlayer = SpawnEntity(p, playersLocation.transform, hands[i], uis[i]) as PlayerCombatObject;
newPlayer.transform.localPosition = new Vector3(-1 + i * 2, 0, 0);
this.players.Add(newPlayer);
i++;
}
foreach (var p in this.players)
{
p.RefreshUI();
}
OnCombatEnd += callback;
turn = TurnSelection.Players;
StartTurn();
}
public void ButtonInput_SelectCard(CardGameObject cardGO, PlayerCombatObject player)
{
// Player has selected a card from the hand.
// Let's first unselect all player's cards.
foreach (var p in battleManager.players)
{
p.hand.UnselectCard();
p.hand.RecalculateCardsPosition();
}
// Ignore if the player does not have control over the card.
if (!playersToManage.Contains(player))
{
//return;
}
// Pass the info to Battle Manager.
battleManager.SelectCard(cardGO, player, player.hand.SelectCard, player.hand.RecalculateCardsPosition);
}
IEnumerator SelectTargets_Power(NativePowerScriptableObject nativePower)
{
PlayerCombatObject playerOnTurn = currentCardOwner;
HealthEntityCombatObject caster = playerOnTurn;
stepNumber = 0;
targetsPerAbilityStep = new List <List <HealthEntityCombatObject> >();
AbilityStepsWithTargetingData_Player[] abilities = nativePower.abilityStepsWithTargetingData;
// Let's cycle through all ability steps in order to determine targets.
foreach (var abilityStepWithTargetingData in abilities)
{
chosenTargets = new List <HealthEntityCombatObject>();
targetFound = false;
TargetData targetData = GetValidTargets(caster, abilityStepWithTargetingData.targetingData);
if (targetData.multipleSpecificMode)
{
multipleSpecificMode = true;
numberOfSpecificTargets = targetData.multipleSpecificNumber;
multipleSpecificModeList = new List <HealthEntityCombatObject>();
}
else
{
multipleSpecificMode = false;
}
if (targetData.previousStepTargets > -1)
{
targetFound = true;
foreach (var entity in targetsPerAbilityStep[targetData.previousStepTargets])
{
chosenTargets.Add(entity);
}
}
else if (targetData.targetDecided)
{
targetFound = true;
foreach (var e in targetData.entities)
{
chosenTargets.Add(e);
}
}
else
{
if (targetData.entities.Count == 1 && targetData.entities[0] is PlayerCombatObject)
{
targetFound = true;
chosenTargets.Add(targetData.entities[0]);
}
else
{
infoText.text = abilityStepWithTargetingData.targetingData.textForChoosing;
ShowTargetingButton(targetData.entities);
}
}
while (targetFound == false)
{
yield return(null);
}
stepNumber++;
targetsPerAbilityStep.Add(chosenTargets);
}
// We have all chosen targets.
// We now have to check whether any of those are multiple hits.
for (int i = 0; i < targetsPerAbilityStep.Count; i++)
{
TargetingData_Base targetingData = nativePower.abilityStepsWithTargetingData[i].targetingData;
if (targetingData.targetAlignment == TargetingData_Base.TargetAlignment.Hostile)
{
if (targetingData.targets == TargetingData_Base.Target.Multiple)
{
EnemyCombatObject chosenTarget = (EnemyCombatObject)targetsPerAbilityStep[i][0];
List <EnemyCombatObject> nearbyEnemies = GetNearbyEnemies(chosenTarget, targetingData.numberOfTargets);
foreach (var e in nearbyEnemies)
{
targetsPerAbilityStep[i].Add(e);
}
}
}
}
// Now we have full lists of all targets for each attribute.
// Let's do the card trick.
DoPowerTrick();
yield return(null);
}
public void Init(PlayerCombatObject player)
{
this.player = player;
}
public void DisplayDrawPile(PlayerCombatObject player)
{
DisplayPile(player.hand.drawPile.Cards, player.Entity.Name + "'s Draw Pile (random order)");
}
public void Input_DisplayDiscardPile(PlayerCombatObject p)
{
ShowPanel(cardViewerMenu);
cardViewerMenu.DisplayDiscardPile(p);
}
