Exemplo n.º 1
0
    /// <summary>
    /// 行動結果を予測する
    /// </summary>
    /// <param name="state">実行前の状況</param>
    /// <param name="action">実行する行動</param>
    /// <returns>実行後の状況</returns>
    PlayerState ActionEnter(PlayerState state, AI_Action action)
    {
        state = new PlayerState(state);
        state.enterdAction = action;
        state.actionCount++;

        //なんか色々
        switch (action.actType)
        {
        case ActionType.Attack:
            if (action.target)
            {
                state.atkedCount++;
                Damage(state, action.target, state.atk);
            }
            break;

        case ActionType.cardPlay:
            state.hand.Remove(action.card);
            SupportDestTrigger(state, action);
            state.cost -= action.card.State.Cost;
            switch (action.card.State.cardType)
            {
            case ObjectType.Unit:
                state.AddUnit(action.card);        // unit.Add(action.card);
                state.atk   += action.card.State.atk;
                state.skill += action.card.State.skill;
                break;

            case ObjectType.Support:
                state.AddSupport(action.card);        //support.Add(action.card);
                state.atk   += action.card.State.atk;
                state.skill += action.card.State.skill;
                break;

            case ObjectType.Trap:
                state.AddSupport(action.card);        //support.Add(action.card);
                state.cost += action.card.State.Cost;
                break;

            case ObjectType.Skill:
                state.Dest.Add(action.card);
                break;

            default: break;
            }
            foreach (CardEffect ce in action.card.State.Effect)
            {
                if (ce.GetEffectPlayType() == EffectPlayType.triggerEffect)
                {
                    state.score_mod += GetTriggerEffectPoint(state, ce as TriggerEffect);
                    state.score_mod -= action.card.State.atk * ai.atk;
                    continue;
                }
                else if (ce.GetEffectPlayType() == EffectPlayType.activeEffect && action.card.State.cardType == ObjectType.Support)
                {
                    state.score_mod += 3;
                }
                if (ce.GetEffectPlayType() != EffectPlayType.playEffect)
                {
                    continue;
                }
                foreach (EffectState es in ce.effectState)
                {
                    switch (es.effectType)
                    {
                    case EffectType.AttackAdd:
                        if (es.Target.targetType == TargetType.friend)
                        {
                            state.atk += es.value;
                            //ターン終了で攻撃力が戻るので、継続的なスコアには加算しない
                            state.score_mod -= es.value * ai.atk;
                        }
                        else
                        {
                            state.enemy.atk += es.value;
                        }
                        break;

                    case EffectType.AttackTime:
                        state.atkCount = es.value;
                        break;

                    case EffectType.CardDest:
                        if (action.target)
                        {
                            Dest(state, action.target);
                        }
                        else if (es.Target.isAll)
                        {
                            Dest(state, es.GetTargets(state.p));
                        }
                        break;

                    case EffectType.CardDraft:
                        state.hand.Add(null);
                        break;

                    case EffectType.CardDraw:
                        for (int i = 0; i < es.value; i++)
                        {
                            state.hand.Add(null);
                        }
                        break;

                    case EffectType.CardUnDraft:
                        for (int i = 0; i < es.value - 1; i++)
                        {
                            state.hand.Add(null);
                        }
                        break;

                    case EffectType.CostAdd:
                        state.cost += es.value;
                        break;

                    case EffectType.Damage:
                        int damage = es.value + (action.card.State.cardType == ObjectType.Skill ? state.skill : 0);
                        //Debug.Log(action.card.State.cardName + ":" + damage);
                        if (action.target)
                        {
                            Damage(state, action.target, damage);
                        }
                        else if (es.Target.isAll)
                        {
                            Damage(state, es.Target.GetTargets(state.p), damage);
                        }
                        else
                        {
                            Debug.Log("対象が不明です");
                        }
                        break;

                    case EffectType.Counter:
                        state.score_mod += 2;
                        break;
                    }
                }
            }
            break;

        case ActionType.cardDisp:
            switch (action.card.State.cardType)
            {
            case ObjectType.Unit:
                state.RemoveUnit(action.card);        //.unit.Remove(action.card);
                state.atk   -= action.card.State.atk;
                state.skill -= action.card.State.skill;
                break;

            case ObjectType.Support:
                state.RemoveSupport(action.card);        //support.Remove(action.card);
                state.atk   -= action.card.State.atk;
                state.skill -= action.card.State.skill;
                break;

            case ObjectType.Trap:
                state.RemoveSupport(action.card);        //support.Remove(action.card);
                break;
            }
            state.score_mod -= 2;
            foreach (CardEffect ce in action.card.State.Effect)
            {
                if (ce.GetEffectPlayType() == EffectPlayType.triggerEffect)
                {
                    state.score_mod -= GetTriggerEffectPoint(state, ce as TriggerEffect);
                }
            }
            break;

        case ActionType.activeEffect:
            foreach (CardEffect ce in action.card.State.Effect)
            {
                ActiveEffect ae = ce as ActiveEffect;
                if (ae != null)
                {
                    state.cost -= ae.cost;
                    state.PlayActiveEffect(action.card);
                    foreach (EffectState es in ce.effectState)
                    {
                        switch (es.effectType)
                        {
                        case EffectType.AttackAdd:
                            state.atk += es.value;
                            break;

                        case EffectType.GetDisZoneCard:
                            if (action.target)
                            {
                                Card c = action.target.GetComponent <Card>();
                                state.hand.Add(c);
                                state.Dest.Remove(c);
                            }
                            break;
                        }
                    }
                }
            }
            break;
        }
        GetAllAction(state);
        return(state);
    }