Beispiel #1
0
    private void TryAttack()
    {
        for (int i = 0; i < skillObjects.Count; i++)
        {
            SkillObject skillObject = (SkillObject)skillObjects[i];

            Vector2 v = BattleUtils.PositionToGrid(skillObject.transform.position);

            ArrayList gameObjects = BattleControllor.GetGameObjectsByPosition(v);

            for (int j = 0; j < gameObjects.Count; j++)
            {
                Charactor c = (Charactor)gameObjects[j];

                if (c.GetType() != this.attackOne.GetType() && c.IsActive() == true)
                {
                    bool  crit   = BattleControllor.Crit(skillConfig.crit);
                    float damage = BattleControllor.Attack(attackOne.GetAttribute(), c.GetAttribute(), skillConfig.demageratio, skillConfig.b, crit);

                    c.ChangeHP(damage, crit);

                    if (c.GetAttribute().hp > 0)
                    {
                        c.PlayAttacked();
                    }
                    else
                    {
                        c.PlayDead();
                    }
                }
            }
        }
    }
Beispiel #2
0
    public void Update()
    {
        if (Constance.SPEC_RUNNING == false && Constance.RUNNING == false)
        {
            return;
        }
        else if (Constance.SPEC_RUNNING == true && this.specSign == false)
        {
            return;
        }


        if (attackOne.IsActive() == false)
        {
            this.end = true;
            return;
        }


        if (this.end == true)
        {
            return;
        }

        if (this.attackOne.IsInAttIndex() == false)
        {
            return;
        }

        bool  crit   = BattleControllor.Crit(skillConfig.crit);
        float damage = BattleControllor.Attack(attackOne.GetAttribute(), attackedOne.GetAttribute(), skillConfig.demageratio, skillConfig.b, crit);

        attackedOne.ChangeHP(damage, crit);

        if (attackedOne.GetAttribute().hp > 0)
        {
            attackedOne.PlayAttacked();
        }
        else
        {
            attackedOne.PlayDead();
        }


        attackOne.audio.clip = Resources.Load <AudioClip>("Audio/Skill/7");
        if (attackOne.audio.clip != null)
        {
            attackOne.audio.Play();
        }

        end = true;
    }
Beispiel #3
0
    public void Update()
    {
        if (Constance.SPEC_RUNNING == false && Constance.RUNNING == false)
        {
            return;
        }
        else if (Constance.SPEC_RUNNING == true && this.specSign == false)
        {
            return;
        }

        if (end == true)
        {
            return;
        }


        singTime -= Time.deltaTime;

        if (singTime > 0)
        {
            return;
        }


        while (alertBlocks.Count > 0)
        {
            GameObject gameObject = alertBlocks[0] as GameObject;
            MonoBehaviour.Destroy(gameObject);

            alertBlocks.RemoveAt(0);
        }



        if (this.attackOne.IsInAttIndex() == true && attacked == false)
        {
            Attribute attribute = attackOne.GetAttribute();

            for (int i = 0; i < range.Count; i++)
            {
                GameObject gameObject = (GameObject)MonoBehaviour.Instantiate(SkillObject_pre);

                SkillObject skillObject = gameObject.GetComponent <SkillObject>();
                skillObject.res  = 8;
                skillObject.loop = 1;
                skillObject.transform.localScale = new Vector3(0.5f, 0.5f, 0);

                skillObject.sound = 2;

                skillObject.transform.position = BattleUtils.GridToPosition((Vector2)range[i]);

                skillObjects.Add(skillObject);

                ArrayList objects = BattleControllor.GetGameObjectsByPosition((Vector2)range[i]);

                for (int j = 0; j < objects.Count; j++)
                {
                    Charactor c = objects[j] as Charactor;

                    if (c.GetType() != this.attackOne.GetType() && c.IsActive() == true)
                    {
                        bool  crit   = BattleControllor.Crit(skillConfig.crit);
                        float damage = BattleControllor.Attack(attackOne.GetAttribute(), c.GetAttribute(), skillConfig.demageratio, skillConfig.b, crit);

                        c.ChangeHP(damage, crit);


                        if (c.GetAttribute().hp > 0)
                        {
                            c.PlayAttacked();
                        }
                        else
                        {
                            c.PlayDead();
                        }
                    }
                }
            }

            attacked = true;
        }

        if (attacked == false)
        {
            return;
        }

        if (attacked == false)
        {
            return;
        }

        for (int i = 0; i < skillObjects.Count; i++)
        {
            SkillObject skillObject = skillObjects[i] as SkillObject;

            if (skillObject.IsSpritePlayEnd() == true)
            {
                MonoBehaviour.Destroy(skillObject.gameObject);

                skillObjects.Remove(skillObjects);

                end = true;
                this.attackOne.SetPlayLock(false);
            }
        }
    }
Beispiel #4
0
    public void Update()
    {
        if (Constance.SPEC_RUNNING == false && Constance.RUNNING == false)
        {
            return;
        }
        else if (Constance.SPEC_RUNNING == true && this.specSign == false)
        {
            return;
        }


        if (end == true)
        {
            return;
        }

        singTime -= Time.deltaTime;

        if (singTime > 0)
        {
            return;
        }

        while (alertBlocks.Count > 0)
        {
            GameObject gameObject = alertBlocks[0] as GameObject;
            MonoBehaviour.Destroy(gameObject);

            alertBlocks.RemoveAt(0);
        }


        if (this.attackOne.IsInAttIndex() == true && attacked == false)
        {
            Attribute attribute = attackOne.GetAttribute();

            GameObject gameObject = (GameObject)MonoBehaviour.Instantiate(SkillObject_pre);

            skillObject      = gameObject.GetComponent <SkillObject>();
            skillObject.res  = 6;
            skillObject.loop = 1;
            skillObject.spriteAnimation.renderer.sortingLayerID = 3;
            skillObject.transform.position = attackOne.transform.localPosition;
            skillObject.sound = 5;

            skillObject.transform.localScale = new Vector2(skillConfig.range / 16f, attribute.volume / 4f);

            switch (attackOne.GetDirection())
            {
            case MoveDirection.DOWN:
                skillObject.SetSpriteEulerAngles(new Vector3(0, 0, 270));
                skillObject.transform.position += new Vector3(0, -0.2f, 0);
                break;

            case MoveDirection.UP:
                skillObject.SetSpriteEulerAngles(new Vector3(0, 0, 90));
                skillObject.transform.position += new Vector3(0, 0.2f, 0);
                break;

            case MoveDirection.LEFT:
                skillObject.SetSpriteEulerAngles(new Vector3(0, 0, 180));
                skillObject.transform.position += new Vector3(-0.2f, 0.2f, 0);
                break;

            case MoveDirection.RIGHT:
                skillObject.transform.position += new Vector3(0.2f, 0.2f, 0);
                break;
            }


            for (int i = 0; i < range.Count; i++)
            {
                ArrayList objects = BattleControllor.GetGameObjectsByPosition((Vector2)range[i]);

                for (int j = 0; j < objects.Count; j++)
                {
                    Charactor c = objects[j] as Charactor;

                    if (c.GetType() != this.attackOne.GetType() && c.IsActive() == true)
                    {
                        bool  crit   = BattleControllor.Crit(skillConfig.crit);
                        float damage = BattleControllor.Attack(attackOne.GetAttribute(), c.GetAttribute(), skillConfig.demageratio, skillConfig.b, crit);

                        c.ChangeHP(damage, crit);

                        if (c.GetAttribute().hp > 0)
                        {
                            c.PlayAttacked();
                        }
                        else
                        {
                            c.PlayDead();
                        }
                    }
                }
            }

            attacked = true;
        }

        if (attacked == false)
        {
            return;
        }


        if (skillObject.IsSpritePlayEnd() == true)
        {
            MonoBehaviour.Destroy(skillObject.gameObject);
            this.attackOne.SetPlayLock(false);
            end = true;
        }
    }
    public void Update()
    {
        if (Constance.SPEC_RUNNING == false && Constance.RUNNING == false)
        {
            return;
        }
        else if (Constance.SPEC_RUNNING == true && this.specSign == false)
        {
            return;
        }

        if (this.end == true)
        {
            return;
        }

        singTime -= Time.deltaTime;

        if (singTime > 0)
        {
            return;
        }



        while (alertBlocks.Count > 0)
        {
            GameObject gameObject = alertBlocks[0] as GameObject;
            MonoBehaviour.Destroy(gameObject);

            alertBlocks.RemoveAt(0);
        }



        if (attackOne.IsInAttIndex() == true && attacked == false)
        {
            Attribute attribute = attackOne.GetAttribute();
            beginPosition = attackOne.transform.position + attackOff;


            for (int i = 0; i < directions.Count; i++)
            {
                MoveDirection dirction = (MoveDirection)directions[i];

                GameObject gameObject = (GameObject)MonoBehaviour.Instantiate(SkillObject_pre);
                gameObject.transform.localScale = new Vector3(attribute.volume / 4f, attribute.volume / 4f, 0);

                SkillObject skillObject = gameObject.GetComponent <SkillObject>();
                skillObject.res = this.skillConfig.res;
                if (this.specSign == true)
                {
                    skillObject.spriteAnimation.renderer.sortingLayerID = 7;
                }
                else
                {
                    skillObject.spriteAnimation.renderer.sortingLayerID = 1;
                }

                skillObject.transform.position = attackOne.transform.position + attackOff;

                switch (dirction)
                {
                case MoveDirection.DOWN:
                    skillObject.SetSpriteEulerAngles(new Vector3(0, 0, 270));
                    break;

                case MoveDirection.UP:
                    skillObject.SetSpriteEulerAngles(new Vector3(0, 0, 90));
                    break;

                case MoveDirection.LEFT:
                    skillObject.SetSpriteOff(new Vector2(0, 0.15f));
                    skillObject.gameObject.transform.localScale += new Vector3(-skillObject.gameObject.transform.localScale.x * 2, 0, 0);
                    break;

                case MoveDirection.RIGHT:
                    skillObject.SetSpriteOff(new Vector2(0, 0.15f));
                    break;
                }

                skillObjects.Add(skillObject);
            }

            attacked = true;
        }

        if (attacked == false)
        {
            return;
        }


        for (int i = 0; i < skillObjects.Count; i++)
        {
            SkillObject   skillObject = (SkillObject)skillObjects[i];
            MoveDirection direction   = (MoveDirection)directions[i];

            if (skillObject == null)
            {
                continue;
            }

            if (Vector3.Distance(beginPosition, skillObject.transform.position) > distance)
            {
                MonoBehaviour.Destroy(skillObject.gameObject);
                skillObjects[i] = null;
                continue;
            }


            float d1 = Time.deltaTime * speed;

            Vector3 newPosition = Vector3.zero;

            switch (direction)
            {
            case MoveDirection.DOWN:
                newPosition = skillObject.transform.position + new Vector3(0, -d1, 0);
                break;

            case MoveDirection.UP:
                newPosition = skillObject.transform.position + new Vector3(0, d1, 0);
                break;

            case MoveDirection.LEFT:
                newPosition = skillObject.transform.position + new Vector3(-d1, 0, 0);
                break;

            case MoveDirection.RIGHT:
                newPosition = skillObject.transform.position + new Vector3(d1, 0, 0);
                break;
            }

            bool inNewGrid = false;

            if (BattleUtils.PositionToGrid(newPosition) != BattleUtils.PositionToGrid(skillObject.transform.position))
            {
                //in diffrenet grid
                inNewGrid = true;
            }

            skillObject.transform.position = newPosition;

            if (inNewGrid == false)
            {
                continue;
            }


            //Try attack
            Vector2 v = BattleUtils.PositionToGrid(skillObject.transform.position);

            ArrayList objects     = BattleControllor.GetGameObjectsByPosition(v);
            Charactor attackedOne = null;

            for (int j = 0; j < objects.Count; j++)
            {
                Charactor c = objects[j] as Charactor;

                if (c.GetType() != this.attackOne.GetType() && c.IsActive() == true)
                {
                    attackedOne = c;
                    break;
                }
            }


            if (attackedOne != null)
            {
                bool  crit   = BattleControllor.Crit(skillConfig.crit);
                float damage = BattleControllor.Attack(attackOne.GetAttribute(), attackedOne.GetAttribute(), skillConfig.demageratio, skillConfig.b, crit);

                attackedOne.ChangeHP(damage, crit);

                if (attackedOne.GetAttribute().hp > 0)
                {
                    attackedOne.PlayAttacked();
                }
                else
                {
                    attackedOne.PlayDead();
                }

                return;
            }
        }


        for (int i = 0; i < skillObjects.Count; i++)
        {
            if (skillObjects[i] != null)
            {
                return;
            }
        }

        end = true;
    }
    public void Update()
    {
        if (Constance.SPEC_RUNNING == false && Constance.RUNNING == false)
        {
            return;
        }
        else if (Constance.SPEC_RUNNING == true && this.specSign == false)
        {
            return;
        }

        if (end == true)
        {
            return;
        }


        if (this.attackOne.IsInAttIndex() == true && attacked == false)
        {
            Vector2 v = BattleUtils.PositionToGrid(attackOne.transform.position.x, attackOne.transform.position.y);

            Attribute attribute = attackOne.GetAttribute();

            MoveDirection direction = attackOne.GetDirection();

            ArrayList range = AttRange.GetRangeByAttType(skillConfig.attack_type, skillConfig.range, attribute.volume, v, direction);

            GameObject gameObject = (GameObject)MonoBehaviour.Instantiate(SkillObject_pre);

            skillObject      = gameObject.GetComponent <SkillObject>();
            skillObject.res  = this.skillConfig.res;
            skillObject.loop = 1;

            skillObject.transform.position = attackOne.transform.position;

            switch (direction)
            {
            case MoveDirection.DOWN:
                skillObject.SetSpriteEulerAngles(new Vector3(0, 0, 270));
                break;

            case MoveDirection.UP:
                skillObject.SetSpriteEulerAngles(new Vector3(0, 0, 90));
                break;

            case MoveDirection.LEFT:
                skillObject.SetSpriteEulerAngles(new Vector3(0, 0, 180));
                break;

            case MoveDirection.RIGHT:
                break;
            }


            for (int i = 0; i < range.Count; i++)
            {
                ArrayList objects = BattleControllor.GetGameObjectsByPosition((Vector2)range[i]);

                for (int j = 0; j < objects.Count; j++)
                {
                    Charactor c = objects[j] as Charactor;

                    if (c.GetType() != this.attackOne.GetType() && c.IsActive() == true)
                    {
                        bool  crit   = BattleControllor.Crit(skillConfig.crit);
                        float damage = BattleControllor.Attack(attackOne.GetAttribute(), c.GetAttribute(), skillConfig.demageratio, skillConfig.b, crit);

                        c.ChangeHP(damage, crit);

                        if (c.GetAttribute().hp > 0)
                        {
                            c.PlayAttacked();
                        }
                        else
                        {
                            c.PlayDead();
                        }
                    }
                }
            }

            attacked = true;
        }

        if (attacked == false)
        {
            return;
        }



        if (skillObject.IsSpritePlayEnd() == true)
        {
            MonoBehaviour.Destroy(skillObject.gameObject);

            end = true;
        }
    }
Beispiel #7
0
    public void Update()
    {
        if (Constance.SPEC_RUNNING == false && Constance.RUNNING == false)
        {
            return;
        }
        else if (Constance.SPEC_RUNNING == true && this.specSign == false)
        {
            return;
        }


        if (this.end == true)
        {
            return;
        }


        if (attackedOne.IsActive() == true)
        {
            targetPoint = attackedTransfrom.position + attackedOff;
        }

        if (skillObject == null && this.attackOne.IsInAttIndex())
        {
            if (attackOne.IsActive() == false)
            {
                end = true;
                return;
            }

            GameObject gameObject = (GameObject)MonoBehaviour.Instantiate(SkillObject_pre);

            skillObject = gameObject.GetComponent <SkillObject>();
            skillObject.spriteAnimation.renderer.sortingLayerID = 3;
            skillObject.res = skillConfig.res;
            skillObject.transform.position = attackOne.transform.position + attackOff;

            skillTransfrom = skillObject.transform;

            skillTransfrom.eulerAngles = new Vector3(0, 0, GetAngle());
        }

        if (skillObject == null)
        {
            return;
        }

        float d1 = Time.deltaTime * speed;
        float d2 = Vector3.Distance(skillTransfrom.position, targetPoint);


        if (d1 > d2)
        {
            MonoBehaviour.Destroy(this.skillObject.gameObject);
            this.end = true;

            bool  crit   = BattleControllor.Crit(skillConfig.crit);
            float damage = BattleControllor.Attack(attackOne.GetAttribute(), attackedOne.GetAttribute(), skillConfig.demageratio, skillConfig.b, crit);

            attackedOne.ChangeHP(damage, crit);

//			if(skillConfig.sound2 != 0){
//				AudioClip ac = Resources.Load<AudioClip>("Audio/Skill/" + skillConfig.sound2);
//				attackedOne.audio.clip = ac;
//				attackedOne.audio.Play();
//			}

            if (attackedOne.GetAttribute().hp > 0)
            {
                attackedOne.PlayAttacked();
            }
            else
            {
                attackedOne.PlayDead();
            }

            return;
        }

        skillTransfrom.eulerAngles = new Vector3(0, 0, GetAngle());
        skillTransfrom.position    = Vector3.MoveTowards(skillTransfrom.position, targetPoint, d1);
    }