/// <inheritdoc/>
public async Task PerformTestAsync(CloudTableClient client, TableDataStoreConfiguration configuration, CancellationToken cancellationToken = default)
{
EnsureArg.IsNotNull(client, nameof(client));
EnsureArg.IsNotNull(configuration, nameof(configuration));
CloudTable table = client.GetTableReference(TestTable);
await table.CreateIfNotExistsAsync();
HealthEntity entity = new HealthEntity(TestPartitionKey, TestRowKey);
entity.Data = TestData;
TableOperation insertOrMergeOperation = TableOperation.InsertOrMerge(entity);
TableResult result = await table.ExecuteAsync(insertOrMergeOperation, cancellationToken);
TableOperation retrieveOperation = TableOperation.Retrieve <HealthEntity>(TestPartitionKey, TestRowKey);
result = await table.ExecuteAsync(retrieveOperation, cancellationToken);
TableOperation deleteOperation = TableOperation.Delete(entity);
result = await table.ExecuteAsync(deleteOperation, cancellationToken);
await table.DeleteAsync(cancellationToken);
}
public void DamageEntity(HealthEntity damaged, HealthEntity attacker)
{
damaged.anim.SetTrigger("Damaged");
damaged.health--;
if (damaged.health <= 0)
{
if (attacker == gm.player)
{
HealEntity(gm.player);
}
damaged.health = 0;
StartCoroutine(Death(damaged));
}
if (damaged.npc)
{
damaged.npc.canMove = false;
if (damaged.npc.projectileToFire != null)
{
gm.attackSystem.DestroyProjectile(damaged.npc.projectileToFire);
damaged.npc.projectileToFire = null;
}
damaged.npc.tmpHealth.text = damaged.health.ToString();
}
if (damaged == gm.player)
{
UpdateHearts();
}
}
public void _Update()
{
for (int i = healthEntities.Count - 1; i >= 0; i--)
{
HealthEntity he = healthEntities[i];
if (he.health > 0)
{
if (he.actionCooldown > 0)
{
he.actionCooldown -= Time.deltaTime;
}
else
{
if (he.npc)
{
gm.movementSystem.NpcMove(he.npc);
gm.attackSystem.NpcAttack(he.npc);
}
else if (he.proj)
{
print("here");
gm.attackSystem.MoveProjectile(he.proj);
}
he.actionCooldown = he.actionCooldownMax;
}
}
}
}
public List <HealthEntity> GetAllRelativeAllies(HealthEntity entity, bool selfIncluded)
{
List <HealthEntity> entities = new List <HealthEntity>();
if (entity.alignment == HealthEntity.Alignment.Evil)
{
foreach (var p in enemies)
{
entities.Add(p);
}
}
if (entity.alignment == HealthEntity.Alignment.Good)
{
foreach (var p in players)
{
if ((entity as Player) == p)
{
if (selfIncluded)
{
entities.Add(p);
}
}
else
{
entities.Add(p);
}
}
}
return(entities);
}
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>
/// Modifies the healt service.
/// </summary>
/// <param name="healthEntity">The health heartBeatEntity.</param>
public void ModifyHealthInfo(HealthEntity healthEntity)
{
if (!IdentitySpec.Instance.IsSatisfiedBy(healthEntity.Identification))
{
return;
}
SaveHealthInfo(healthEntity);
}
void CheckDamage()
{
if (projectiles.Count > 0)
{
for (int i = projectiles.Count - 1; i >= 0; i--)
{
if (projectiles[i] != null && !projectiles[i].telegraphTurn)
{
HealthEntity damaged = null;
foreach (Animator tile in projectiles[i].dangerousSprites)
{
if (tile.gameObject.tag == dangerousTag)
{
foreach (HealthEntity he in gm.entityList.healthEntities)
{
if (he.health > 0 && he != projectiles[i].master)
{
if (Vector3.Distance(tile.transform.position, he.transform.position) < 0.5f)
{
damaged = he;
break;
}
}
}
if (damaged != null)
{
break;
}
}
}
if (damaged != null)
{
// damage entity
gm.healthSystem.DamageEntity(damaged, projectiles[i].master);
projectiles[i].damagedObject = damaged;
projectiles[i].deathPosition = damaged.transform.position;
}
if (projectiles[i].stepsLast <= 0)
{
print("stepLast");
DestroyProjectile(projectiles[i]);
}
else if (projectiles[i].damagedObject)
{
print("damagedObject");
DestroyProjectile(projectiles[i]);
}
else if (projectiles[i].wallOnWay)
{
print("wallOnwWAy");
DestroyProjectile(projectiles[i]);
}
}
}
}
}
/// <summary>
/// Spawn a model and initialize the combat entity.
/// </summary>
/// <param name="entity"></param>
protected HealthEntityCombatObject Init(HealthEntity entity, System.Action <HealthEntityCombatObject> OnDeathCallback)
{
if (entity == null)
{
Debug.LogError("Entity is null.");
Destroy(gameObject);
return(null);
}
Entity = entity;
// Instantiate the model.
// TODO: Need to clean up this part.
GameObject go = GameObject.Instantiate(entity.Model, transform.Find("Graphics"));
go.name = "Flesh Holder";
go.transform.localPosition = Vector3.zero;
// Let's load the Model Info.
ModelInfo = go.GetComponent <ModelSetup>();
if (ModelInfo == null)
{
Debug.LogWarning("Model " + go.name + " does not contain ModelSetup. Setting default values.");
ModelInfo = go.AddComponent <ModelSetup>();
ModelInfo.modelHeight = 1f;
ModelInfo.dropables = new GameObject[0];
}
// Let's load the animator.
Animator = go.GetComponent <Animator>();
if (Animator == null)
{
Animator = go.AddComponent <Animator>();
}
Animator.Rebind();
// Let's find the clicking area.
ClickableTile = gameObject.GetComponentInChildren <ClickableArea>();
if (ClickableTile == null)
{
Debug.LogError("Combat entity prefab does not contain Clicking Area.");
Destroy(gameObject);
return(null);
}
AllowTargetable(false);
// Let's set up the callback.
if (OnDeathCallback != null)
{
OnDeath += OnDeathCallback;
}
// Let's set up the rest.
Stats = entity.stats;
StatusEffects = entity.statusEffects;
return(this);
}
/// <summary>
/// Saves the health info.
/// </summary>
/// <param name="healthEntity">The health entity.</param>
private void SaveHealthInfo(HealthEntity healthEntity)
{
var repository = GetReopsitory(healthEntity);
var serviceInfo = GetServiceInfo(healthEntity.Identification, repository);
UpdateEntity(serviceInfo, healthEntity, (s => s.MemoryWorkingSet = healthEntity.MemoryWorkingSet));
Save(serviceInfo, repository, bd => bd.SetValue(be => be.MemoryWorkingSet, serviceInfo.MemoryWorkingSet));
}
public override OnPlayResult OnPlay(params object[] parameters)
{
OnPlayResult onPlayResult = new OnPlayResult();
HealthEntity summoned = FindObjectOfType <BattleManager>().SummonOnEnemySide(summonables[Random.Range(0, summonables.Length)]);
onPlayResult.summonedEntity = summoned;
return(onPlayResult);
}
// Use this for initialization
void Awake()
{
_healthEntity = mainEntity.GetComponent <HealthEntity>();
if (healthEntity == null)
{
Debug.LogError("DamageablePart: entity does not have health");
}
else
{
_healthEntity.RegisterSubpart(this);
}
}
public void SelectTarget(HealthEntity entity)
{
// Break if there is no selected card.
if (currentSelectedCard == null)
{
return;
}
HideTargettingButtons();
chosenTargets.Add(entity);
targetFound = true;
}
public void PushObject(HealthEntity he, Vector3 pushOrigin)
{
SavePosition(he.npc);
Vector3 newPos = he.transform.position;
if (pushOrigin.x < he.transform.position.x)
{
// push right
newPos += Vector3.right;
}
else if (pushOrigin.x > he.transform.position.x)
{
// push left
newPos += Vector3.left;
}
else if (pushOrigin.z > he.transform.position.z)
{
newPos += Vector3.back;
}
else if (pushOrigin.z < he.transform.position.z)
{
newPos += Vector3.forward;
}
GameObject targetObj = CanMove(newPos);
if (targetObj != null)
{
if (targetObj.layer == 8) // tile
{
SavePosition(he.npc);
he.transform.LookAt(newPos);
//he.anim.SetTrigger("Move"); //animate damaged push
StartCoroutine(NpcMoveSmooth(he.npc, newPos));
}
else if (targetObj.layer == 10) // other unit
{
foreach (HealthEntity hee in gm.entityList.healthEntities)
{
if (hee.gameObject == targetObj)
{
gm.healthSystem.DamageEntity(hee, he);
break;
}
}
}
else if (targetObj.layer == 9) // wall
{
gm.healthSystem.DamageEntity(he, he);
}
}
}
IEnumerator Death(HealthEntity he)
{
/*
* gm.entityList.healthEntities.Remove(he);
* if (he.npc)
* gm.entityList.npcEntities.Remove(he.npc);
*/
he.anim.SetBool("Death", true);
he.gameObject.layer = 8;
yield return(null);
}
void HealEntity(HealthEntity he)
{
if (he == gm.player)
{
he.health++;
if (he.health > he.healthMax)
{
he.health = he.healthMax;
}
UpdateHearts();
}
}
void UpdateHearts()
{
HealthEntity he = gm.player;
for (int i = 1; i <= he.healthMax; i++)
{
if (he.health >= i)
{
StartCoroutine(SetActive(hearts[i - 1].gameObject, true, 0));
}
else
{
StartCoroutine(SetActive(hearts[i - 1].gameObject, false, 0));
}
}
}
/// <inheritdoc/>
public async Task PerformTestAsync(CancellationToken cancellationToken = default)
{
await _testServiceClient.CreateTableIfNotExistsAsync(TestTable, cancellationToken : cancellationToken);
var tableClient = _testServiceClient.GetTableClient(TestTable);
var entity = new HealthEntity(TestPartitionKey, TestRowKey)
{
Data = TestData
};
await tableClient.UpsertEntityAsync(entity, cancellationToken : cancellationToken);
await tableClient.GetEntityAsync <HealthEntity>(TestPartitionKey, TestRowKey, cancellationToken : cancellationToken);
await tableClient.DeleteEntityAsync(TestPartitionKey, TestRowKey, cancellationToken : cancellationToken);
await _testServiceClient.DeleteTableAsync(TestTable, cancellationToken);
}
public List <HealthEntity> GetAllRelativeEnemies(HealthEntity entity)
{
List <HealthEntity> entities = new List <HealthEntity>();
if (entity.alignment == HealthEntity.Alignment.Evil)
{
foreach (var p in players)
{
entities.Add(p);
}
}
if (entity.alignment == HealthEntity.Alignment.Good)
{
foreach (var p in enemies)
{
entities.Add(p);
}
}
return(entities);
}
public void RemoveEntity(HealthEntity he)
{
healthEntities.Remove(he);
}
public void AddObject(HealthEntity he)
{
healthEntities.Add(he);
}
public void NpcAttack(NpcEntity npc) // NPC
{
if (npc.health.health <= 0)
{
// do nothing
}
else // NPC ACT
{
gm.movementSystem.SavePosition(npc);
var he = npc.health;
// enemies attack
if (he.npc && he.npc.weaponEntity)
{
he.npc.attackTarget = gm.player;
if (he.npc.weaponEntity.aimType == WeaponEntity.AimType.Cross)
{
if (Mathf.Round(he.transform.position.x) == Mathf.Round(gm.player.transform.position.x) || Mathf.Round(he.transform.position.z) == Mathf.Round(gm.player.transform.position.z))
{
ProjectileEntity projectile = Instantiate(he.npc.weaponEntity.projectile, he.transform.position, Quaternion.identity);
projectile.master = he;
HealthEntity projectileHealth = projectile.GetComponent <HealthEntity>();
projectile.health = projectileHealth;
projectileHealth.proj = projectile;
gm.entityList.AddObject(projectileHealth);
if (gm.player.transform.position.x > projectile.transform.position.x)
{
projectile.direction = new Vector3(1, 0, 0);
}
else if (gm.player.transform.position.x < projectile.transform.position.x)
{
projectile.direction = new Vector3(-1, 0, 0);
}
else if (gm.player.transform.position.z < projectile.transform.position.z)
{
projectile.direction = new Vector3(0, 0, -1);
}
else if (gm.player.transform.position.z > projectile.transform.position.z)
{
projectile.direction = new Vector3(0, 0, 1);
}
projectile.newPos = projectile.transform.position;
he.npc.shotCooldownCurrent = he.npc.shotCooldownMax;
projectiles.Add(projectile);
projectile.telegraphTurn = true;
npc.projectileToFire = projectile;
for (int i = 0; i <= projectile.movementSpeed; i++)
{
Animator newDangerousSprite = Instantiate(projectile.dangerousSprite, projectile.transform.position, Quaternion.identity);
projectile.dangerousSprites.Add(newDangerousSprite);
}
npc.moveCooldown = 1;
StartCoroutine(CalculateDangerousTiles(projectile));
}
}
}
}
}
List <List <HealthEntity> > SelectAbilityTargetEnemy(Enemy enemy)
{
List <List <HealthEntity> > targetsPerAbilityStep = new List <List <HealthEntity> >();
AbilityStepsWithTargetingData_Enemy[] abilityStepsWithTargetingData = enemy.nextAbility.abilityStepsWithTargetingData;
// Let's cycle through all ability steps in order to determine targets.
foreach (var abilityStepWithTargetingData in abilityStepsWithTargetingData)
{
List <HealthEntity> selectedTargets = new List <HealthEntity>();
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 <HealthEntity> st = new List <HealthEntity>(selectedTargets);
for (int i = 0; i < abilityStepWithTargetingData.targetingData.numberOfTargets; i++)
{
HealthEntity 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)
{
Enemy chosenTarget = (Enemy)targetsPerAbilityStep[i][0];
List <Enemy> nearbyEnemies = GetNearbyEnemies(chosenTarget, targetingData.numberOfTargets);
foreach (var e in nearbyEnemies)
{
targetsPerAbilityStep[i].Add(e);
}
}
}
}
return(targetsPerAbilityStep);
}
TargetData GetValidTargets(HealthEntity caster, TargetingData_Base targetingData)
{
TargetData targetData = new TargetData();
targetData.previousStepTargets = -1;
List <HealthEntity> targets = new List <HealthEntity>();
if (targetingData.targetingType == TargetingData_Base.TargetingType.NoTargeting)
{
// There is no targeting. Don't bother.
}
// We will use other step's targets.
else if (targetingData.targetingType == TargetingData_Base.TargetingType.PreviousStep)
{
targetData.previousStepTargets = targetingData.useTargetsFromStepNumber;
}
// If the target is only self, do not check for anything else.
else if (targetingData.onlySelf)
{
targets.Add(caster);
targetData.targetDecided = true;
}
else
{
// Can we add self?
bool selfIncluded = targetingData.selfIncluded;
// Let's skip the check if we can only target ourselves.
if (targetingData.onlySelf)
{
targets.Add(caster);
}
// We can target more than ourselves. Let's first check if we can target at all.
else if (targetingData.targets != TargetingData_Base.Target.All)
{
switch (targetingData.targetAlignment)
{
case TargetingData_Base.TargetAlignment.Both:
switch (targetingData.targets)
{
case TargetingData_Base.Target.One:
// Select one from friendlies or from enemies.
// Select one from friendlies taking into account whether to add self.
foreach (var f in GetAllRelativeAllies(caster, selfIncluded))
{
targets.Add(f);
}
// Select one from enemies.
foreach (var e in GetAllRelativeEnemies(caster))
{
targets.Add(e);
}
break;
case TargetingData_Base.Target.MultipleSpecific:
// Select multiple specific from friendlies or enemies.
// Add ourselves to the list.
if (targetingData.selfIncluded)
{
}
break;
}
break;
case TargetingData_Base.TargetAlignment.Friendly:
switch (targetingData.targets)
{
case TargetingData_Base.Target.One:
// Select one from friendlies taking into account whether to add self.
foreach (var f in GetAllRelativeAllies(caster, selfIncluded))
{
targets.Add(f);
}
break;
case TargetingData_Base.Target.MultipleSpecific:
// Select multiple specific friendlies taking into account whether to add self.
break;
case TargetingData_Base.Target.Multiple:
// Select multiple friendlies taking into account whether to add self.
foreach (var f in GetAllRelativeAllies(caster, selfIncluded))
{
targets.Add(f);
}
break;
}
break;
case TargetingData_Base.TargetAlignment.Hostile:
switch (targetingData.targets)
{
case TargetingData_Base.Target.One:
// Select one from enemies.
foreach (var e in GetAllRelativeEnemies(caster))
{
targets.Add(e);
}
break;
case TargetingData_Base.Target.MultipleSpecific:
// Select multiple specific from enemies.
break;
case TargetingData_Base.Target.Multiple:
// Select multiple from enemies.
foreach (var e in GetAllRelativeEnemies(caster))
{
targets.Add(e);
}
break;
}
break;
}
}
// We cannot target so we choose all.
else
{
switch (targetingData.targetAlignment)
{
case TargetingData_Base.TargetAlignment.Both:
// Select all targets.
// Select all allies taking into account if self included
foreach (var a in GetAllRelativeAllies(caster, selfIncluded))
{
targets.Add(a);
}
// Select all enemies.
foreach (var e in GetAllRelativeEnemies(caster))
{
targets.Add(e);
}
break;
case TargetingData_Base.TargetAlignment.Friendly:
// Select all allies taking into account if self included
foreach (var a in GetAllRelativeAllies(caster, selfIncluded))
{
targets.Add(a);
}
break;
case TargetingData_Base.TargetAlignment.Hostile:
// Select all enemies.
foreach (var e in GetAllRelativeEnemies(caster))
{
targets.Add(e);
}
break;
}
targetData.targetDecided = true;
}
}
targetData.entities = targets;
return(targetData);
}
IEnumerator SelectCardCoro(CardGameObject cardGO)
{
Player playerOnTurn = currentCardOwner;
HealthEntity caster = playerOnTurn;
targetsPerAbilityStep = new List <List <HealthEntity> >();
AbilityStepsWithTargetingData_Player[] abilities = cardGO.card.abilityStepsWithTargetingData;
// Let's cycle through all ability steps in order to determine targets.
foreach (var abilityStepWithTargetingData in abilities)
{
chosenTargets = new List <HealthEntity>();
targetFound = false;
TargetData targetData = GetValidTargets(caster, abilityStepWithTargetingData.targetingData);
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 Player)
{
targetFound = true;
chosenTargets.Add(targetData.entities[0]);
}
else
{
infoText.text = abilityStepWithTargetingData.targetingData.textForChoosing;
ShowTargetingButton(targetData.entities);
}
}
while (targetFound == false)
{
stayUp = false;
yield return(null);
}
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 = cardGO.card.abilityStepsWithTargetingData[i].targetingData;
if (targetingData.targetAlignment == TargetingData_Base.TargetAlignment.Hostile)
{
if (targetingData.targets == TargetingData_Base.Target.Multiple)
{
Enemy chosenTarget = (Enemy)targetsPerAbilityStep[i][0];
List <Enemy> 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.
DoCardTrick();
yield return(null);
}
