public void Change(bool enabled, CharacterModel caster, IAbility ability)
        {
            targetArea.gameObject.SetActive(false);
            targetLine.gameObject.SetActive(false);
            ClearAbilityRange();

            this.enabled = enabled;
            this.caster  = caster;
            this.ability = ability;

            if (enabled == false)
            {
                return;
            }

            Vector2 casterPosition = caster.Position.ToUnityVector();

            targetArea.localScale = new Vector2(1, 1);
            targetArea.GetComponent <SpriteRenderer>().color = inRangeColor;
            targetLine.SetPosition(0, casterPosition);

            if (ability is AreaAbility)
            {
                AreaAbility areaAbility = (AreaAbility)ability;
                targetArea.localScale = new Vector2(areaAbility.TargetWidth, areaAbility.TargetHeight);
                DrawAbilityRange(casterPosition, ability.Range);
            }
            else if (ability is ProjectileAbility)
            {
                DrawAbilityRange(casterPosition, ability.Range);
            }
        }
Exemple #2
0
    /// <summary>
    /// Gets, damages and influences targets within area of effect
    /// </summary>
    private void ApplyAoEEffects(float damageToDo, Transform objectPosition, AreaAbility AoEUsed)
    {
        List <Enemy> enemies = new List <Enemy>();

        //Influence enemies within AoE sphere
        Collider[] cols = Physics.OverlapSphere(objectPosition.position,
                                                AoEUsed.effectRadius); //prefab is scaled down - scale up

        foreach (Collider c in cols)
        {
            if (c.name.Split('(')[0].Equals(AoEUsed.name) || c.tag.Equals(gameObject.tag))
            {
                continue;
            }

            Enemy e = c.GetComponentInParent <Enemy>();
            if (e != null)
            {
                e.Influence(gameObject, Emotion.Anger, statComponent.agro);
            }
            enemies.Add(e);

            AgentStats eS = c.GetComponentInParent <AgentStats>();
            if (eS != null)
            {
                StartCoroutine(eS.DoTDamage(damageToDo, AoEUsed.duration));
            }
        }
    }
        private IEnumerator Test_DamageSelf()
        {
            CharacterView  character      = Instantiate(characterPrefab).GetComponent <CharacterView>();
            CharacterClass characterClass = new CharacterClass()
            {
                Name = "TestCharacterClass", HealthPoints = 10, CharacterSprite = "Character_Example_8"
            };

            character.Model = new CharacterModel(new CharacterData(), characterClass, null, true);
            yield return(new WaitForSeconds(1));

            IAbility ability = new AreaAbility()
            {
                Power       = 2, TargetWidth = 1, TargetHeight = 1,
                TargetTypes = new List <TargetType>()
                {
                    TargetType.Self
                }
            };

            ability.Cast(new UnityCharacterFinder(targetLayerMask), character.Model, character.Model.Position);
            yield return(new WaitForSeconds(1));

            Destroy(character.gameObject);
            yield return(new WaitForSeconds(1));
        }
Exemple #4
0
    private void AoE(GameObject spellPrefab, ref bool aoePlaced, Abilities abil)
    {
        AreaAbility deployed = null;

        if (aiming == false)
        {
            aiming = true;
            instantiatedAimingDisc = Instantiate(aimingDisc);
        }
        else
        {
            GameObject areaObject = Instantiate(spellPrefab,
                                                instantiatedAimingDisc.position + new Vector3(0f, instantiatedAimingDisc.localScale.y / 2, 0f), Quaternion.identity);

            deployed = spellPrefab.GetComponent <AreaAbility>();

            if (instantiatedAimingDisc.gameObject != null)
            {
                Destroy(instantiatedAimingDisc.gameObject);
            }
            aiming = false;

            float damage = 0f;
            if (statComponent.TryUseAbility(abil, out damage))
            {
                ApplyAoEEffects(damage, areaObject.transform, deployed);

                aoePlaced     = true;
                aoeFinishTime = Time.time + aoeCooldown;
            }
            ;
        }
    }
        private Vector2 AdjustTargetPosition(Vector2 targetPosition, IAbility ability)
        {
            if (ability != null)
            {
                if (ability is AreaAbility)
                {
                    AreaAbility areaAbility = (AreaAbility)ability;
                    return(new Vector2(
                               areaAbility.TargetWidth % 2 != 0 ? Mathf.Round(targetPosition.x) : Mathf.Floor(targetPosition.x) + 0.5f,
                               areaAbility.TargetHeight % 2 != 0 ? Mathf.Round(targetPosition.y) : Mathf.Floor(targetPosition.y) + 0.5f));
                }
            }

            return(GameView.GetTilePosition(targetPosition));
        }