Esempio n. 1
0
 private void OnInterruptableTarget(Obj_AI_Hero sender, Interrupter2.InterruptableTargetEventArgs args)
 {
     try
     {
         if (sender.IsEnemy && args.DangerLevel == Interrupter2.DangerLevel.High &&
             UltimateManager.Interrupt(sender))
         {
             Utility.DelayAction.Add(DelayManager.Get("ultimate-interrupt-delay"), () => R.Cast(sender.Position));
         }
     }
     catch (Exception ex)
     {
         Global.Logger.AddItem(new LogItem(ex));
     }
 }
Esempio n. 2
0
    public IEnumerator MoveTo(Tile toMoveTile)
    {
        int currentTileKey = FieldTileUtility.GetKeyFromTile(toMoveTile);

        UpdateTileKey(currentTileKey);

        //iTween.MoveTo(
        Vector3 nextTilePosition = new Vector3(
            toMoveTile.transform.position.x,
            toMoveTile.transform.position.y,
            transform.position.z);
        Vector3 currentPosition = transform.position;
        Vector3 diff            = currentPosition - nextTilePosition;
        float   moveTime        = diff.magnitude / DelayManager.Get().playerMoveSpeed;

        iTween.MoveTo(gameObject,
                      iTween.Hash("position", nextTilePosition, "time", moveTime, "easeType", DelayManager.Get().moveEaseType)
                      );
        yield return(Run.WaitSeconds(moveTime).WaitFor);
    }
Esempio n. 3
0
    public void OnRollClicked()
    {
        BattleCalculator calculator = new BattleCalculator();

        if (attackOrDefense == AttackOrDefense.Attack)
        {
            playerCalcResult = calculator.GetAttackDiceResult(player);
            enemyCalcResult  = calculator.GetDefenseDiceResult(enemy);
        }
        else
        {
            playerCalcResult = calculator.GetDefenseDiceResult(player);
            enemyCalcResult  = calculator.GetAttackDiceResult(enemy);
        }

        Run.After(DelayManager.Get().battleDiceRollToDiceResultDelay, () => {
            state = State.ShowRoll;
            AnimateDice();
        });
    }
Esempio n. 4
0
    IEnumerator AnimateDamage(int totalPlayerDice, int totalEnemyDice)
    {
        damage = CalculateDamage(totalPlayerDice, totalEnemyDice);
        target = CompareDamageAndSelectTarget(totalPlayerDice, totalEnemyDice);

        Debug.Log("PlayerDice : " + totalPlayerDice + ", EnemyDice : " + totalEnemyDice);
        //show animation with calculation result.
        //apply damage.
        MultiAudioClip multiAudioClip = GetComponent <MultiAudioClip>();

        yield return(new WaitForSeconds(DelayManager.Get().battleDiceResultToAttackDelay));

        if (target != null)
        {
//----------Dodge item.
            if (useItemsInBattle.Contains(Character.Item.Dodge))
            {
                Run dodgeEffect = Dodge();
                yield return(dodgeEffect.WaitFor);

                useItemsInBattle.Remove(Character.Item.Dodge);
                UpdateBuffUI();
            }

            if (damage > target.GetHp())
            {
                damage = target.GetHp();
            }

            for (int i = 1; i <= damage; i++)
            {
                target.ApplyDamage(1);
                UpdateRemainHP();
                if (target.ui == leftPlayerUI)
                {
                    rightPlayerUI.unitRenderer.transform.parent.gameObject.SendMessage("Attack");
                }
                else if (target.ui == rightPlayerUI)
                {
                    leftPlayerUI.unitRenderer.transform.parent.gameObject.SendMessage("Attack");
                }
                target.ui.unitRenderer.transform.parent.gameObject.SendMessage("Hit");
                multiAudioClip.audioSources[0].Play();
                yield return(new WaitForSeconds(DelayManager.Get().battleHpMinusDelay));
            }
        }
        else
        {
            multiAudioClip.audioSources[1].Play();
            if (useItemsInBattle.Contains(Character.Item.Dodge))
            {
                Run dodgeEffect = Dodge();
                yield return(dodgeEffect.WaitFor);

                useItemsInBattle.Remove(Character.Item.Dodge);
            }
            else
            {
                player.ApplyDamage(1);
                player.ui.unitRenderer.transform.parent.gameObject.SendMessage("Hit");
            }
            enemy.ApplyDamage(1);
            UpdateRemainHP();
            enemy.ui.unitRenderer.transform.parent.gameObject.SendMessage("Hit");
            yield return(new WaitForSeconds(DelayManager.Get().battleHpMinusDelay));

            Debug.Log("Each player is Damaged 1");
        }

        if (target == enemy)
        {
            Debug.Log("Enemy is Damaged " + damage);
        }
        else if (target == player)
        {
            Debug.Log("Player is Damaged " + damage);
        }

        if (enemy.IsDie())
        {
            enemy.ui.unitRenderer.transform.parent.gameObject.SendMessage("Fade");
            yield return(new WaitForSeconds(DelayManager.Get().batttleLoseShowDelay));

            state = State.BattleEnd;
        }
        else if (player.IsDie())
        {
            player.ui.unitRenderer.transform.parent.gameObject.SendMessage("Fade");
            yield return(new WaitForSeconds(DelayManager.Get().batttleLoseShowDelay));

            state = State.BattleEnd;
        }
        else
        {
            var changeAnimation = ChangeAttackOrDefense();
            changeAnimation.ExecuteWhenDone(() => {
                state = State.WaitingRoll;
                Debug.Log(
                    "PlayerHP : " + player.GetHp() + "/" + player.maxHp +
                    " EnemyHP : " + enemy.GetHp() + "/" + enemy.maxHp
                    );
            });
        }
    }