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);
}
/// <summary>
/// Returns list with nearby enemies to the referenced enemy. Can only calculate for odd numbers.
/// </summary>
/// <param name="enemy">Referenced enemy</param>
/// <param name="enemyNumber">Number of enemies</param>
/// <returns></returns>
public List <EnemyCombatObject> GetNearbyEnemies(EnemyCombatObject enemy, int enemyNumber)
{
if (enemyNumber % 2 == 0)
{
Debug.LogError("Only odd numbers for now.");
return(null);
}
if (enemyNumber < 3)
{
Debug.LogError("No point calculating this for less than 3 enemies.");
return(null);
}
List <EnemyCombatObject> nearbyEnemies = new List <EnemyCombatObject>();
List <EnemyCombatObject> enemiesAsEnemy = new List <EnemyCombatObject>();
foreach (var entity in enemies)
{
enemiesAsEnemy.Add(entity as EnemyCombatObject);
}
int enemiesRemaining = enemies.Count;
int enemyIndex = enemy.enemyIndex;
if (enemiesRemaining <= enemyNumber)
{
nearbyEnemies = new List <EnemyCombatObject>(enemiesAsEnemy);
}
else
{
if (enemyIndex < enemyNumber / 2 + 1)
{
for (int i = 0; i < enemyNumber; i++)
{
nearbyEnemies.Add(enemiesAsEnemy[i]);
}
}
else if (enemyIndex > (enemiesRemaining - enemyNumber))
{
for (int i = enemiesRemaining - enemyNumber; i < enemiesRemaining; i++)
{
nearbyEnemies.Add(enemiesAsEnemy[i]);
}
}
else
{
int startingIndex = enemyNumber / 2;
for (int i = -startingIndex; i <= startingIndex; i++)
{
nearbyEnemies.Add(enemiesAsEnemy[enemyIndex + i]);
}
}
}
nearbyEnemies.Remove(enemy);
return(nearbyEnemies);
}
public List <EnemyCombatObject> SpawnEnemies(List <EnemyCombatObject> enemiesSO, System.Action <HealthEntityCombatObject> OnEnemyDeathCallback)
{
List <EnemyCombatObject> enemies = new List <EnemyCombatObject>();
for (int i = 0; i < enemiesSO.Count; i++)
{
EnemyCombatObject enemy = enemiesSO[i];
enemy.gameObject.name = "Enemy " + i;
enemies.Add(enemy);
}
return(enemies);
}
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();
}
void OnEnemyDeath(HealthEntityCombatObject entity)
{
EnemyCombatObject enemy = entity as EnemyCombatObject;
FindObjectOfType <AudioManager>().PlayRandomClip(enemy.deathSounds);
enemies.Remove(enemy);
int i = 0;
foreach (var e in enemies)
{
e.enemyIndex = i;
i++;
}
if (enemies.Count == 0)
{
FindObjectOfType <AudioManager>().PlayClip(VictorySound);
combatOver = true;
StartCoroutine(EndBattleCoroutine(false));
}
}
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);
}
List <List <HealthEntityCombatObject> > SelectAbilityTargetEnemy(EnemyCombatObject enemy)
{
List <List <HealthEntityCombatObject> > targetsPerAbilityStep = new List <List <HealthEntityCombatObject> >();
AbilityStepsWithTargetingData_Enemy[] abilityStepsWithTargetingData = enemy.NextAbility.abilityStepsWithTargetingData;
// Let's cycle through all ability steps in order to determine targets.
foreach (var abilityStepWithTargetingData in abilityStepsWithTargetingData)
{
List <HealthEntityCombatObject> selectedTargets = new List <HealthEntityCombatObject>();
TargetData targetData = GetValidTargets(enemy, abilityStepWithTargetingData.targetingData);
if (targetData.previousStepTargets > -1)
{
foreach (var entity in targetsPerAbilityStep[targetData.previousStepTargets])
{
selectedTargets.Add(entity);
}
}
else if (targetData.targetDecided)
{
foreach (var e in targetData.entities)
{
selectedTargets.Add(e);
}
}
else
{
switch (abilityStepWithTargetingData.targetingData.targets)
{
case TargetingData_Base.Target.One:
// Choose a random target for now
selectedTargets.Add(targetData.entities[Random.Range(0, targetData.entities.Count)]);
break;
case TargetingData_Base.Target.Multiple:
// Choose a random target for now
selectedTargets.Add(targetData.entities[Random.Range(0, targetData.entities.Count)]);
break;
case TargetingData_Base.Target.MultipleSpecific:
// Choose a random target for now
// If it happens that there are less available targets than our ability wants us to target,
// add them all.
if (abilityStepWithTargetingData.targetingData.numberOfTargets < targetData.entities.Count)
{
foreach (var entity in targetData.entities)
{
selectedTargets.Add(entity);
}
}
else
{
List <HealthEntityCombatObject> st = new List <HealthEntityCombatObject>(selectedTargets);
for (int i = 0; i < abilityStepWithTargetingData.targetingData.numberOfTargets; i++)
{
HealthEntityCombatObject entity = targetData.entities[Random.Range(0, targetData.entities.Count)];
selectedTargets.Add(entity);
st.Remove(entity);
}
}
break;
}
}
targetsPerAbilityStep.Add(selectedTargets);
}
// 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 = enemy.NextAbility.abilityStepsWithTargetingData[i].targetingData;
if (targetingData.targetAlignment == TargetingData_Base.TargetAlignment.Friendly)
{
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);
}
}
}
}
return(targetsPerAbilityStep);
}
