/// <summary>
    /// 相手を選択
    /// </summary>
    /// <param name="monster"></param>
    private void SelectOpponent(BattleMapMonster monster)
    {
        BattleMapActionStatus actionStatus = holder.BattleMapStatus.BattleMapActionStatus;
        MonsterSkill          skill        = actionStatus.SelectedSkill;

        // ステータスを移動
        statusGenerator.ShowStatus(
            actionStatus.TargetMonster, BattleMapStatusPanelType.SKILL1, BattleMapStatusPanelPositionType.ON_RESERVE);
        statusGenerator.SetSkill(skill);

        // 相手のステータスを表示
        statusGenerator.ShowStatusReserve(monster, BattleMapStatusPanelType.SKILL1);

        // 距離を計算
        BattleMapTile from  = holder.BattleMap.GetByMonster(actionStatus.TargetMonster);
        BattleMapTile to    = holder.BattleMap.GetByMonster(monster);
        int           range = MapUtils.GetRange(from, to);

        // カウンタースキルを取得
        MonsterSkill counterSkill = monster.GetCounterSkill(range);

        statusGenerator.SetSkillReserve(counterSkill);

        // ステータスの更新
        actionStatus.BattleMapActionStatusType = BattleMapActionStatusType.CONFIRM_OPPONENT_SELECT;
        actionStatus.OpponentMonster           = monster;
        actionStatus.CounterSkill = counterSkill;
    }
    /// <summary>
    /// スキル選択の取り消し
    /// </summary>
    public void CloseSelectSkill()
    {
        BattleMapActionStatus actionStatus = holder.BattleMapStatus.BattleMapActionStatus;

        // 相手選択まで行ってたら
        if (actionStatus.BattleMapActionStatusType != BattleMapActionStatusType.BEFORE_SKILL_SELECT &&
            actionStatus.BattleMapActionStatusType != BattleMapActionStatusType.CONFIRM_SKILL_SELECT)
        {
            // 相手選択のキャンセル
            CancelOpponentSelect();
        }

        // スキルを非表示
        skillSelectGenerator.HideSkillSelect();

        // ステータスを非表示
        statusGenerator.HideStatus();

        // 枠があれば削除
        holder.RemoveIcons(BattleMapIconType.FRAME_AQUA);

        // 強調表示の終了
        iconController.UnHighlightMarker(holder.BattleMapStatus.BattleMapActionStatus.TargetMonster);

        // ステータスを更新
        holder.BattleMapStatus.BattleMapActionStatus = null;
    }
    /// <summary>
    /// 戦闘の終了
    /// </summary>
    public void FinishBattle()
    {
        BattleMapActionStatus actionStatus = holder.BattleMapStatus.BattleMapActionStatus;

        // 強調表示の終了
        // TODO: Down後の場合は処理しない、ダウン後かどうかの判定方法?
        if (holder.BattleMapMonsters.MonsterList.Contains(actionStatus.TargetMonster))
        {
            iconController.UnHighlightMarker(actionStatus.TargetMonster);
        }

        // ステータスを消す
        statusGenerator.HideStatus();
        statusGenerator.HideStatusReserve();

        // TODO: ボードの表示、いずれアニメーション化
        holder.BattleMapTeams.TeamList[0].CommandBoard.GameObject.SetActive(true);

        // コマンドを減らす
        BattleMapCommand command = holder.GetCurrentCommand();

        command.Count = command.Count - 1;

        // ボードの更新
        commandController.UpdateActionBoard();

        holder.BattleMapStatus.BattleMapActionStatus = null;
    }
Example #4
0
    /// <summary>
    /// 戦闘の実行
    /// </summary>
    /// <param name="actionStatus"></param>
    /// <returns></returns>
    public BattleResultSet Battle(BattleMapActionStatus actionStatus)
    {
        // 順番を作成
        List <BattleResult> orderList = orderListCreator.Create(actionStatus);

        // 戦闘処理
        BattleResultSet battleResultSet = Battle(actionStatus, orderList);

        return(battleResultSet);
    }
    /// <summary>
    /// 相手選択の解除
    /// </summary>
    public void CancelOpponentSelect()
    {
        // 相手のステータスを隠す
        statusGenerator.HideStatusReserve();

        BattleMapActionStatus actionStatus = holder.BattleMapStatus.BattleMapActionStatus;
        BattleMapMonster      monster      = actionStatus.TargetMonster;
        MonsterSkill          skill        = actionStatus.SelectedSkill;

        // ステータスを表示
        statusGenerator.ShowStatus(monster, BattleMapStatusPanelType.SKILL1);
        statusGenerator.SetSkill(skill);

        // ステータスの更新
        actionStatus.BattleMapActionStatusType = BattleMapActionStatusType.BEFORE_OPPONENT_SELECT;
        actionStatus.OpponentMonster           = null;
    }
Example #6
0
    /// <summary>
    /// 戦闘処理
    /// </summary>
    /// <param name="actionStatus"></param>
    /// <param name="orderList"></param>
    /// <returns></returns>
    private BattleResultSet Battle(BattleMapActionStatus actionStatus, List <BattleResult> orderList)
    {
        BattleResultSet result = new BattleResultSet();

        result.TargetMonster   = actionStatus.TargetMonster;
        result.OpponentMonster = actionStatus.OpponentMonster;

        List <BattleResult> resultList = new List <BattleResult>();

        foreach (BattleResult battleResult in orderList)
        {
            // TODO: スキルの威力未考慮
            // TODO:

            // 攻撃力
            int atk = battleResult.FromMonster.BattleStatus.Atk;

            // ダメージ
            int hp = battleResult.ToMonster.BattleStatus.Hp - atk;
            battleResult.ToDamage = atk;

            if (hp <= 0)
            {
                hp = 0;
                battleResult.ToDown = true;
            }

            // 結果を反映
            battleResult.ToMonster.BattleStatus.Hp = hp;

            resultList.Add(battleResult);

            // どちらかが倒れていれば終了
            if (battleResult.FromDown || battleResult.ToDown)
            {
                break;
            }
        }

        result.ResultList = resultList;

        return(result);
    }
    /// <summary>
    /// スキルを選択
    /// </summary>
    /// <param name="skill"></param>
    public void SelectSkill(MonsterSkill skill)
    {
        BattleMapActionStatus actionStatus = holder.BattleMapStatus.BattleMapActionStatus;

        // スキル選択前、もしくは選択されたスキルが異なる場合
        if (actionStatus.BattleMapActionStatusType == BattleMapActionStatusType.BEFORE_SKILL_SELECT ||
            actionStatus.SelectedSkill != skill)
        {
            // スキルの確認
            BattleMapMonster monster = actionStatus.TargetMonster;
            skillSelectGenerator.ConfirmSkill(monster, skill);

            // ステータスの更新
            actionStatus.SelectedSkill             = skill;
            actionStatus.BattleMapActionStatusType = BattleMapActionStatusType.CONFIRM_SKILL_SELECT;
        }

        // スキル確認中、かつ選択されたスキルが同じ場合
        else if (actionStatus.BattleMapActionStatusType == BattleMapActionStatusType.CONFIRM_SKILL_SELECT &&
                 actionStatus.SelectedSkill == skill)
        {
            // スキルを非表示
            skillSelectGenerator.HideSkillSelect();

            // スキル範囲の描画
            BattleMapMonster monster = actionStatus.TargetMonster;
            DrawRange(skill, monster);

            // ステータスを表示
            statusGenerator.ShowStatus(monster, BattleMapStatusPanelType.SKILL1);
            statusGenerator.SetSkill(skill);

            // ステータスの更新
            actionStatus.BattleMapActionStatusType = BattleMapActionStatusType.BEFORE_OPPONENT_SELECT;
        }

        // TODO: ここに来ることはない?
        else
        {
        }
    }
    /// <summary>
    /// アクションの実行
    /// </summary>
    /// <param name="bmt"></param>
    public void Action(BattleMapTile bmt)
    {
        BattleMapActionStatus actionStatus = holder.BattleMapStatus.BattleMapActionStatus;

        BattleMapMonster monster = holder.BattleMapMonsters.GetMonster(bmt);

        // スキル選択前
        if (actionStatus == null ||
            actionStatus.BattleMapActionStatusType == BattleMapActionStatusType.BEFORE_TARGET_SELECT)
        {
            // モンスターがいないなら終了
            if (monster == null)
            {
                return;
            }

            // ターゲット選択
            SelectTarget(monster);
        }

        // スキル選択中にモンスターの変更
        else if (actionStatus.BattleMapActionStatusType == BattleMapActionStatusType.BEFORE_SKILL_SELECT ||
                 actionStatus.BattleMapActionStatusType == BattleMapActionStatusType.CONFIRM_SKILL_SELECT)
        {
            // モンスターがいない
            if (monster == null)
            {
                CloseSelectSkill();
                return;
            }

            // モンスターが異なる場合はターゲットの変更
            if (actionStatus.TargetMonster != monster)
            {
                // 選択中キャラの強調表示を解除
                iconController.UnHighlightMarker(actionStatus.TargetMonster);

                // ターゲットの選択しなおし
                SelectTarget(monster);
            }
        }

        // 敵を選択
        else if (actionStatus.BattleMapActionStatusType == BattleMapActionStatusType.BEFORE_OPPONENT_SELECT)
        {
            MonsterSkill skill = actionStatus.SelectedSkill;

            // スキルのタイプが敵のみ
            if (skill.MonsterSkillTargetType == MonsterSkillTargetType.ONLY_ENEMY)
            {
                // モンスターがいない、同じチームならなにもしない
                if (monster == null ||
                    actionStatus.TargetMonster.Team == monster.Team)
                {
                    return;
                }

                // 相手を選択
                SelectOpponent(monster);
            }
        }

        // 選択確認
        else if (actionStatus.BattleMapActionStatusType == BattleMapActionStatusType.CONFIRM_OPPONENT_SELECT)
        {
            MonsterSkill skill = actionStatus.SelectedSkill;

            // スキルのタイプが敵のみ
            if (skill.MonsterSkillTargetType == MonsterSkillTargetType.ONLY_ENEMY)
            {
                // モンスターがいない、同じチームならキャンセル
                if (monster == null ||
                    actionStatus.TargetMonster.Team == monster.Team)
                {
                    // キャンセル
                    CancelOpponentSelect();
                    return;
                }

                // さっきの敵と違う
                else if (monster != actionStatus.OpponentMonster)
                {
                    // キャンセル
                    CancelOpponentSelect();

                    // 選択
                    SelectOpponent(monster);
                }

                // さっきの敵と同じなら戦闘の実行
                else if (monster == actionStatus.OpponentMonster)
                {
                    // 戦闘
                    Battle();
                }
            }
        }
    }
    /// <summary>
    /// 戦闘順を作成
    /// </summary>
    /// <param name="actionStatus"></param>
    /// <returns></returns>
    public List <BattleResult> Create(BattleMapActionStatus actionStatus)
    {
        List <BattleResult> orderList = new List <BattleResult>();

        BattleMapMonster monster1 = actionStatus.TargetMonster;
        BattleMapMonster monster2 = actionStatus.OpponentMonster;

        // まず速度が速い方
        BattleMapMonster fast = monster1;
        BattleMapMonster slow = monster2;

        if (monster1.BattleStatus.Spd < monster2.BattleStatus.Spd)
        {
            fast = monster2;
            slow = monster1;
        }

        // とりあえず作成
        BattleResult result1 = new BattleResult();

        result1.FromMonster = fast;
        result1.ToMonster   = slow;
        orderList.Add(result1);

        // 速度の倍率
        float magTmp = (float)fast.BattleStatus.Spd / (float)slow.BattleStatus.Spd;
        int   mag    = (int)Math.Floor(magTmp);

        // 反撃不可の場合
        if (actionStatus.CounterSkill == null)
        {
            // 二倍以上ならもう一度
            if (2 <= mag)
            {
                BattleResult result2 = new BattleResult();
                result2.FromMonster = fast;
                result2.ToMonster   = slow;
                orderList.Add(result2);
            }

            // 反撃不可はここで終了
            return(orderList);
        }

        // 一倍、二倍は逆が攻撃
        if (mag == 1 || mag == 2)
        {
            BattleResult result2 = new BattleResult();
            result2.FromMonster = slow;
            result2.ToMonster   = fast;
            orderList.Add(result2);
        }

        // 三倍以上は連続
        else
        {
            BattleResult result2 = new BattleResult();
            result2.FromMonster = fast;
            result2.ToMonster   = slow;
            orderList.Add(result2);
        }

        // 一倍は終了
        if (mag == 1)
        {
            return(orderList);
        }

        // 二倍は攻撃
        else if (mag == 2)
        {
            BattleResult result3 = new BattleResult();
            result3.FromMonster = fast;
            result3.ToMonster   = slow;
            orderList.Add(result3);
        }

        // 三倍以上は逆
        else
        {
            BattleResult result3 = new BattleResult();
            result3.FromMonster = slow;
            result3.ToMonster   = fast;
            orderList.Add(result3);
        }

        return(orderList);
    }