let AddStateTarget = function (atkENo, waitFlame, stateData, shakeSkipFlg) {
    shakeSkipFlg = typeof shakeSkipFlg !== 'undefined' ? shakeSkipFlg : false; 
    for (let i = 0; i <= TargetArr.length - 1; i++) {
        DmgESet_SkipFlg = shakeSkipFlg;
        let setTurn = GetAddStateTurn(atkENo, stateData._No, stateData._Turn);
        SetDmgStac_State(stateData._No, TargetArr[i], waitFlame, setTurn);
        if (TargetArr[i] == -1) $gameActors.actor(1).addState_N(stateData._No);
    }
    DmgESet_SkipFlg = false;
}
let GetAddStateTurn = function (attackENo, stateId, stateTurn) {
    switch (stateId) {
        case StOneType.CelDmg:
            let stValue = GetStateTypeSumValue_ENo(attackENo, StType.CelDmgBai);
            let bairitu = (stValue + 100) / 100;
            return Math.floor(stateTurn * bairitu);
    }
    return stateTurn;
}
let DmgESet_SkipFlg = false;
let SetDmgStac_State = function (stateId, targetENo, waitFlame, setTurn) {
    let _SetStac = new StacDmgData();
    _SetStac._Type = DType.SetState; 
    _SetStac._StId = stateId; 
    _SetStac._CNo = targetENo;   
    _SetStac._Flame = waitFlame; 
    _SetStac._Turn = setTurn; 
    _SetStac._ShakeSkipFlg = DmgESet_SkipFlg;
    _SetStac._Kouka = CopyArr(CardKoukaArr); 
    EnemyDmgStac.push(_SetStac);    
    DmgESet_SkipFlg = false;
}
let GetSkillCalcValue = function (atkENo, skillId) {
    let sikiStr = $dataSkills[skillId].damage.formula;
    let a = null; 
    try {
        if (atkENo == -1) {
            let _TurnCount = NPlayer[(-atkENo - 1)]._TurnCount;
            a = new CardStatus(UseCard.CardData, _TurnCount); 
        }
        if (atkENo < -1) a = new EnemyStatus(NPlayer[(-atkENo - 1)]);
        if (atkENo >= 0) a = new EnemyStatus(NEnemy[atkENo]);
    } catch (e) {
        let _TcCard = $dataWeapons[atkENo];
        a = new CardStatus(_TcCard, 0); 
    }
    if (sikiStr == "") return 0;
    return Math.floor(ReUseBtlFunc(sikiStr)(a));
}
let N_FuncArr = [];
let ReUseBtlFunc = function (_Siki) {
    for (let i = 0; i <= N_FuncArr.length - 1; i++) {
        if (N_FuncArr[i]._Siki == _Siki) {
            return N_FuncArr[i]._Func 
        }
    }
    N_FuncArr.push(new N_Func(_Siki, new Function('a', 'return (' + _Siki + ");")));
    return N_FuncArr[N_FuncArr.length - 1]._Func;
}
let GetChangeDamage_ENo = function (ENo) { 
    try {
        if (ENo <= -1) {
            let _rtnVar = NPlayer[(-ENo - 1)]._DmgCng;
            if (ENo == -1) _rtnVar += _手札AtkChange;
            return _rtnVar;
        }
        if (ENo >= 0) return NEnemy[ENo]._DmgCng;
    } catch (e) {
        return 0;
    }
}
let CardEditSkill; 
let UseCardId = -1; 
let SetDmgStac_Damage = function (atkENo, skillId, waitFlame, cardId, shakeSkipFlg) { 
    cardId = typeof cardId !== 'undefined' ? cardId : -1; 
    shakeSkipFlg = typeof shakeSkipFlg !== 'undefined' ? shakeSkipFlg : false; 
    DmgESet_SkipFlg = shakeSkipFlg 
    if (atkENo > 5) cardId = atkENo;
    UseCardId = cardId;
    let baseDmgType = $dataSkills[skillId].damage.type;
    if (baseDmgType == 0) return;
    let setDmgType = $dataSkills[skillId].damage.elementId;
    let ckNState = GetNState_ENo(atkENo);
    let changeDmgValue = GetChangeDamage_ENo(atkENo); 
    if (befTurnType == EnBefTurn.Skill) {
        ckNState = [];
        changeDmgValue = 0;
    }
    let baseDmgValue = GetSkillCalcValue(atkENo, skillId);
    let setDmgValue = baseDmgValue + changeDmgValue; 
    if (skillId == KSkill.妖刀ムラマサ) { 
        setDmgValue = NPlayer[0].mhp - NPlayer[0]._hp ;
        if (setDmgValue < 0) setDmgValue = 0;
        let _HpBairitu = 1 + (1 - (NPlayer[0]._hp / NPlayer[0].mhp)) * 2;
        setDmgValue = Math.floor(setDmgValue * _HpBairitu);
    }
    if (skillId != KSkill.自傷ダメージ) {
        setDmgValue = GetDmgValue_AtkState(setDmgType, setDmgValue, ckNState); 
    }
    CardEditSkillSetting(setDmgType, cardId, baseDmgValue); 
    switch (setDmgType) { 
        case DType.DefGet: 
            SetDmgStac_State(StOneType.Defense, atkENo, waitFlame, setDmgValue);
            break;
        case DType.Draw:    
        case DType.MpRecv:  
        case DType.DeckCAdd: 
        case DType.TrashAdd: 
        case DType.HandAdd: 
        case DType.HandCRecv: 
        case DType.Reload:  
        case DType.HandSute: 
        case DType.ItemAdd: 
        case DType.CmnEv:   
        case DType.SWCng:   
        case DType.Hirumi:  
        case DType.TCDelay: 
        case DType.HCostCng: 
        case DType.HCostHrfRnd: 
        case DType.HCostZeroRnd: 
        case DType.Bit_TurnCng: 
        case DType.Bit_VarCng: 
        case DType.SknCng: 
        case DType.ItemCoolTurnCng: 
            SetEnemyDmgStac(setDmgType, -1, waitFlame, setDmgValue, cardId, skillId);
            break;
        case DType.StateDel: 
            for (let i = 0; i <= TargetArr.length - 1; i++) {
                SetEnemyDmgStac(setDmgType, TargetArr[i], waitFlame, setDmgValue, cardId, skillId);
            }
            break;
        default:
            let _AtkToCelDmgVar = GetAtkToCellValue(ckNState);
            let _emCnt = 0;
            for (let i = 0; i <= NEnemy.length - 1; i++) {
                if (NEnemy[i]._hp > 0) _emCnt++;
            }
            if (_Skill狙撃Dmg > 0 && _emCnt > 1) {
                setDmgValue += _Skill狙撃Dmg; 
                //setDmgValue += GetDmgValue_AtkState(setDmgType, _Skill狙撃Dmg, ckNState);
            }
            for (let i = 0; i <= TargetArr.length - 1; i++) {
                if (setDmgType == DType.CelAtkDmg) {
                    setDmgValue = GetNStateTurn_ENo(TargetArr[i], StOneType.CelDmg);
                    setDmgValue = GetDmgValue_AtkState(setDmgType, setDmgValue, ckNState); 
                    setDmgType = DType.Dmg;
                }
                if (ENo_StateCk_Type(TargetArr[i], StType.CelDmg)) { 
                    if (_CellDmg倍化Flg) {
                        setDmgValue *= _CellDmg倍率;
                        _CellDmg倍化Flg = false; 
                    }
                }
                if (ENo_StateCk_Type(TargetArr[i], StType.CelBaria)) { 
                    if (GetNStateTurn_ENo(TargetArr[i], StOneType.Defense) > 0) {
                        let _TgtDef = GetNStateTurn_ENo(TargetArr[i], StOneType.Defense);
                        if (setDmgValue > 0) {
                            let ckDmg = setDmgValue;
                            if (ENo_StateCk_Type(TargetArr[i], StType.BaseDef)) {
                                ckDmg = Math.floor(ckDmg / 2);
                            }
                            if (_TgtDef < ckDmg) ckDmg = _TgtDef;
                            if (setDmgType == DType.Dmg) {
                                ckDmg = GetAddStateTurn(atkENo, StOneType.CelDmg, ckDmg);
                                SetDmgStac_State(StOneType.CelDmg, atkENo, waitFlame, ckDmg);
                            }
                        }
                    }
                }
                if (ENo_StateCk_Type(TargetArr[i], StType.Reflect)) { 
                    if (setDmgValue > 0) {
                        if (setDmgType == DType.Dmg) {
                            let refAtkENo = atkENo;
                            if (refAtkENo >= 0 && refAtkENo >= NEnemy.length) {
                                for (let j = 0; j < NEnemy.length; j++) {
                                    if (NEnemy[i]._hp != 0) {
                                        refAtkENo = j;
                                        break;
                                    }
                                }
                            }
                            SetEnemyDmgStac(setDmgType, refAtkENo, waitFlame, setDmgValue, cardId, skillId);
                        }
                    }
                }
                if (ENo_StateCk_Type(TargetArr[i], StType.Counter)) { 
                    if (setDmgValue > 0) {
                        if (setDmgType == DType.Dmg) {
                            let _HangekiVar = GetStateTypeSumValue_ENo(TargetArr[i], StType.Counter);
                            SetEnemyDmgStac(setDmgType, atkENo, waitFlame, _HangekiVar, cardId, skillId);
                        }
                    }
                }
                if (setDmgType == DType.Dmg) _St_攻撃解除Flg = true;
                if (atkENo == -1 && setDmgValue > 0) {
                    setDmgValue += _手札AtkCng;
                    if (setDmgValue < 0) setDmgValue = 0;
                }
                SetEnemyDmgStac(setDmgType, TargetArr[i], waitFlame, setDmgValue, cardId, skillId);
                if (_AtkToCelDmgVar > 0 && setDmgValue >= 0 && setDmgType == DType.Dmg) {
                    _AtkToCelDmgVar = GetAddStateTurn(atkENo, StOneType.CelDmg, _AtkToCelDmgVar);
                    SetDmgStac_State(StOneType.CelDmg, TargetArr[i], waitFlame, _AtkToCelDmgVar);
                }
            }
            _CellDmg倍率 = 1; 
            break;
    }
    UseStateCk(atkENo);
}
let UseStateCk = function (_ENo) {
    try {
        let _CkState;
        if (_ENo <= -1) _CkState = NPlayer[(-_ENo - 1)]._NState;
        if (_ENo > -1) _CkState = NEnemy[_ENo]._NState;
        for (let i = 0; i <= _CkNState.length - 1; i++) {
        }
    } catch (e) {
    }
}
let GetDmgValue_AtkState = function (dmgType, dmgValue, ckNState) {
    for (let i = 0; i <= ckNState.length - 1; i++) {
        let stateTraits = $dataStates[ckNState[i]._No].traits; 
        for (let j = 0; j <= stateTraits.length - 1; j++) {
            if (stateTraits[j].code != 11) continue; 
            switch (dmgType) {
                case DType.Dmg: 
                    dmgValue = ChangeDmgValue_Traits(dmgValue, stateTraits[j], ckNState[i]);
                    break;
            }
        }
    }
    return dmgValue;
}
let GetAtkToCellValue = function (ckNState) {
    let rtnDmgValue = 0;
    for (let i = 0; i <= ckNState.length - 1; i++) {
        let _ckTraits = $dataStates[ckNState[i]._No].traits; 
        for (let j = 0; j <= _ckTraits.length - 1; j++) {
            if (_ckTraits[j].code != 11) continue; 
            switch (_ckTraits[j].dataId) {
                case StType.AtkToCel:
                    rtnDmgValue += Math.floor(_ckTraits[j].value * 100 - 100);
                    break;
            }
        }
    }
    return rtnDmgValue;
}
let ChangeDmgValue_Traits = function (dmgValue, traits, ckNState) {
    ckNState = typeof ckNState !== 'undefined' ? ckNState : null;
    let _StVar = Math.round((traits.value - 1) * 100); 
    switch (traits.dataId) {
        case StType.ADmgCng: 
            dmgValue += _StVar;
            break;
        case StType.ADmgDbl: 
            dmgValue += (_StVar / 100) * dmgValue;
            dmgValue = Math.floor(dmgValue);
            break;
        case StType.CardBaika: 
            if (ckNState != null) {
                if (UseCardId == $dataStates[ckNState._No].stepsToRemove) {
                    dmgValue *= _StVar;
                }
            }
            break;
    }
    return dmgValue;
}
let CardEditSkillSetting = function (dmgType, cardId, dmgValue) {
    cardId = typeof cardId !== 'undefined' ? cardId : -1; 
    CardEditSkill = null; 
    switch (dmgType) {
        case DType.DeckCAdd:    
        case DType.TrashAdd:    
        case DType.HandAdd:     
            CardEditSkill = new CardEditSkillData();
            CardEditSkill._CardId = Number(memoSkillArr[1]);    
            CardEditSkill._Maisu = Number(memoSkillArr[2]);     
            break;
        case DType.SWCng:    
        case DType.CmnEv:    
            CardEditSkill = new CardEditSkillData();
            if (cardId != -1) {
                let _CdData = new CardStatus($dataWeapons[cardId]);
                if (dmgType == DType.SWCng) CardEditSkill._SWNo = dmgValue; 
                if (dmgType == DType.CmnEv) CardEditSkill._CmnNo = dmgValue;  
            } else {
                if (dmgType == DType.SWCng) CardEditSkill._SWNo = Number(memoSkillArr[1]); 
                if (dmgType == DType.CmnEv) CardEditSkill._CmnNo = Number(memoSkillArr[1]); 
            }
            break;
    }
}
let DmgMotionSkipFlg = false;
let SetEnemyDmgStac = function (dmgType, targetENo, waitFlame, dmgValue, cardId, skillId) {
    cardId = typeof cardId !== 'undefined' ? cardId : -1;
    skillId = typeof skillId !== 'undefined' ? skillId : -1;
    let _SetStac = new StacDmgData();
    _SetStac._Type = dmgType;     
    _SetStac._CNo = targetENo;        
    _SetStac._Flame = waitFlame; 
    _SetStac._Var = dmgValue;     
    _SetStac._CardId = cardId;  
    _SetStac._SkillId = skillId;  
    _SetStac._ShakeSkipFlg = DmgESet_SkipFlg;
    _SetStac._DmgMotionSkipFlg = DmgMotionSkipFlg;
    _SetStac._CardEditSkill = CardEditSkill; 
    _SetStac._Kouka = CopyArr(CardKoukaArr); 
    EnemyDmgStac.push(_SetStac);
    DmgESet_SkipFlg = false;
    DmgMotionSkipFlg = false;
}
Game_Interpreter.prototype.TextPopUp_ENo = function (ENo, textStr, textSize) {
    textSize = typeof textSize !== 'undefined' ? textSize : 25;
    let PopUpPosX = -50;
    if (ENo <= -1) {
        _C_Str = NPlayer[-ENo - 1]._name;
        _SSetX = NPlayer[-ENo - 1]._screenX + PopUpPosX;
        _SSetY = NPlayer[-ENo - 1]._screenY;
        _APosX = NPlayer[-ENo - 1]._screenX;
        _APosY = NPlayer[-ENo - 1]._screenY;
    } else {
        _C_Str = NEnemy[ENo]._name; 
        _SSetX = NEnemy[ENo]._screenX + NEnemy[ENo]._IcX - 40;
        _SSetY = NEnemy[ENo]._screenY - (NEnemy[ENo]._pHeight / 2) + NEnemy[ENo]._IcY;
        _APosX = NEnemy[ENo]._screenX;
        _APosY = NEnemy[ENo]._screenY;
    }
    this.SetDmgPicture(_SSetX, _SSetY, textStr, textSize);
}
Game_Interpreter.prototype.ChangeDmgValue_DefENo = function (targetENo, dmgValue, _防御貫通Flg) {
    _防御貫通Flg = typeof _防御貫通Flg !== 'undefined' ? _防御貫通Flg : false; 
    let _ckNState;
    if (targetENo <= -1) {
        _ckNState = NPlayer[-targetENo - 1]._NState;
    } else {
        _ckNState = NEnemy[targetENo]._NState;
    }
    for (let i = 0; i <= _ckNState.length - 1; i++) {
        let _Traits = $dataStates[_ckNState[i]._No].traits;
        for (let j = 0; j <= _Traits.length - 1; j++) {
            if (_Traits[j].code != 11) continue;
            switch (_Traits[j].dataId) {
                case StType.BaseDef: 
                    let _TVald = Math.round(dmgValue / 2);
                    if (dmgValue > 0) dmgValue -= _TVald;
                    break;
                case StType.HiDmgCng: 
                    let _TVal = Math.round(((_Traits[j].value - 1) * 100));
                    if (_TVal < 0 && _防御貫通Flg) _TVal = 0; 
                    dmgValue += _TVal;
                    break;
                case StType.CelHiDmgCng: 
                    let _CellTnVar = GetNStateTurn_ENo(targetENo, StOneType.CelDmg);
                    dmgValue -= Math.floor(_CellTnVar / 4);
            }
        }
    }
    if (dmgValue <= 0) dmgValue = 0;
    return dmgValue;
}
/**
 * 同じ位置にポップアップが出ないようにするための配列
 * @type {PopUpPosCheckData[]}　*/
let PopUpPosCheckArr = [];
class PopUpPosCheckData {
    constructor(setX , setY , ckFrame) {
        this.setX = setX;
        this.setY = setY;
        this.ckFrame = ckFrame; 
    }
}
let EnemyDmgStac = []; 
let DmgAnimeFlame = 0; 
let DmgAnimeName = "";
Game_Interpreter.prototype.DmgEffectUpdate = function () {
    for (let i = 0; i < PopUpPosCheckArr.length; i++) {
        if (PopUpPosCheckArr[i].ckFrame > 0) {
            PopUpPosCheckArr[i].ckFrame--;
            if (PopUpPosCheckArr[i].ckFrame <= 0) {
                PopUpPosCheckArr.splice(i, 1);
                i--;
            }
        }
    }
    if (DmgAnimeFlame > 0) {
        DmgAnimeFlame--; 
        if (DmgAnimeFlame <= 0) DmgAnimeName = "";
    }
    let popUpPosX = -50;
    for (let i = 0; i <= EnemyDmgStac.length - 1; i++) {
        EnemyDmgStac[i]._Flame--;
        if (EnemyDmgStac[i]._Flame <= 0) {
            let dmgType = EnemyDmgStac[i]._Type; 
            let targetENo = EnemyDmgStac[i]._CNo; //攻撃対象: 味方(-1以下) < 主人公(-1) < 敵(0以降)
            let dmgKouka = EnemyDmgStac[i]._Kouka; 
            this.SetPicStrFont("Arial Black");
            let continueFlg = false; 
            switch (dmgType) {
                case DType.Draw:    
                    let DrCounter = 0;
                    for (let j = 0; j <= EnemyDmgStac[i]._Var - 1; j++) {
                        if (CardData.length < BtlStatic._手札最大枚数) { 
                            AddCardDrawStac(); 
                            DrCounter++;
                        }
                    }
                    this.BLogAdd(180, "Drew " + DrCounter + " card(s)");
                    this.HandCardPicSort(-1); 
                    this.CardDrawMove(); 
                    continueFlg = true;
                    break; 
                case DType.DeckCAdd: 
                case DType.TrashAdd: 
                case DType.HandAdd:  
                    let cardId = EnemyDmgStac[i]._CardEditSkill._CardId;
                    let maisuValue = EnemyDmgStac[i]._CardEditSkill._Maisu;
                    if (dmgType == DType.DeckCAdd) this.DeckCardAdd(cardId, maisuValue);
                    if (dmgType == DType.TrashAdd) this.DeckTrashAdd(cardId, maisuValue);
                    if (dmgType == DType.HandAdd) this.DeckHandAdd(cardId, maisuValue);
                    continueFlg = true;
                    break; 
                case DType.HandCRecv:  
                    for (let j = 0; j <= CardData.length - 1; j++) {
                        if (CardData[j].CardData.wtypeId == CType.異常) {
                            this.HandCard_TrashMove(CardData[j].setPNo); 
                            CardData.splice(j, 1);
                            j--;
                        }
                    }
                    continueFlg = true;
                    break; 
                case DType.Reload:  
                    this.AllCardTrash_Move();
                    let drawCount = CardData.length;
                    for (let j = 0; j <= CardData.length - 1; j++) {
                        CardData.splice(j, 1);
                        j--;
                    }
                    SetEnemyDmgStac(DType.Draw, -1, 1, drawCount);
                    continueFlg = true;
                    break; 
                case DType.HandSute: 
                    this.AllCardTrash_Move();
                    for (let j = 0; j <= CardData.length - 1; j++) {
                        CardData.splice(j, 1);
                        j--;
                    }
                    continueFlg = true;
                    break; 
                case DType.SWCng:   
                    $gameSwitches.setValue(EnemyDmgStac[i]._CardEditSkill._SWNo, true)
                    continueFlg = true;
                    break; 
                case DType.CmnEv:   
                    console.log("Battle action common event activated: " + EnemyDmgStac[i]._CardEditSkill._CmnNo);
                    this.SetCmnEventSc(EnemyDmgStac[i]._CardEditSkill._CmnNo);
                    continueFlg = true;
                    break; 
                case DType.TCDelay:  
                    this.SetTCPlayerSkill(EnemyDmgStac[i]._CardId, EnemyDmgStac[i]._Var);
                    continueFlg = true;
                    break; 
                case DType.Hirumi:  
                    this.PlayerHirumiEffect(); 
                    continueFlg = true;
                    break; 
                case DType.ItemAdd: 
                    let itemID = EnemyDmgStac[i]._Var;
                    let itemData = GetBtlItemData(itemID);
                    this.BtlItemAdd(itemID, 1);
                    this.BLogAdd(180, "Obtained " + itemData._name);
                    this.BtlItemBtnDraw(); 
                    continueFlg = true;
                    break; 
                case DType.HCostCng:   
                    this.HandCardCost_Change(EnemyDmgStac[i]._Var);
                    continueFlg = true;
                    break; 
                case DType.HCostHrfRnd: 
                    this.HandCardCost_HrfRndCost(EnemyDmgStac[i]._Var);
                    continueFlg = true;
                    break; 
                case DType.HCostZeroRnd: 
                    this.HandCardCost_HrfRndCost(EnemyDmgStac[i]._Var, true); 
                    continueFlg = true;
                    break; 
                case DType.StateDel: 
                    let ckState = GetNState_ENo(targetENo);
                    for (let j = 0; j <= ckState.length - 1; j++) {
                        if (MetaChecker($dataStates[ckState[j]._No] , "有利" , false) != false) {
                            if (MetaChecker($dataStates[ckState[j]._No] , "剥がれない" , false) == false) {
                                this.BLogAdd(180, GetEnemyName_ENo(targetENo) + "'s \\state[" + ckState[j]._No + "] was removed");
                                ckState.splice(j, 1);
                                j--;
                            }
                        }
                    }
                    continueFlg = true;
                    break; 
                case DType.SknCng: 
                    if ($gameVariables._data[VN_Seikan] == undefined) $gameVariables._data[VN_Seikan] = 0;
                    let _CngVar = EnemyDmgStac[i]._Var;
                    if (CheckStateInType(NPlayer[0]._NState, StType.SeikanJoso)) { 
                        let _cngVar = GetStateTypeSumValue(NPlayer[0]._NState, StType.SeikanJoso); 
                        _CngVar = EnemyDmgStac[i]._Var * (1 + (_cngVar / 100));
                        _CngVar = Math.floor(_CngVar);
                    }
                    if (BtlCard_性感位置Str != "") {
                        let ck開発Mode = -1;
                        if (BtlCard_性感位置Str == "口") ck開発Mode = 0;
                        if (BtlCard_性感位置Str == "乳") ck開発Mode = 1;
                        if (BtlCard_性感位置Str == "尻") ck開発Mode = 2;
                        if (BtlCard_性感位置Str == "膣") ck開発Mode = 3;
                        if (ck開発Mode != -1) {
                            let _Keiken = $gameVariables.value(VN_Kaihatu + ck開発Mode); 
                            let _開発Rank = 1; 
                            if (_Keiken >= $Nupu_PSData.hStData.cRankValue) _開発Rank++; 
                            if (_Keiken >= $Nupu_PSData.hStData.bRankValue) _開発Rank++; 
                            if (_Keiken >= $Nupu_PSData.hStData.aRankValue) _開発Rank++; 
                            if (_Keiken >= H_MaxRank経験値) _開発Rank++; 
                            if (_開発Rank == 1) _CngVar *= 0.25;
                            if (_開発Rank == 2) _CngVar *= 0.5;
                            if (_開発Rank == 3) _CngVar *= 1;
                            if (_開発Rank == 4) _CngVar *= 2;
                            if (_開発Rank == 5) _CngVar *= 3;
                            _CngVar = Math.floor(_CngVar);
                        }
                    }
                    $gameVariables._data[VN_Seikan] = $gameVariables._data[VN_Seikan] + _CngVar;
                    if ($gameVariables._data[VN_Seikan] < 0) $gameVariables._data[VN_Seikan] = 0;
                    if ($gameVariables._data[VN_Seikan] > 100) $gameVariables._data[VN_Seikan] = 100;
                    continueFlg = true;
                    break; 
                case DType.Bit_TurnCng: 
                    this.Bit_TurnCng(EnemyDmgStac[i]._Var);
                    continueFlg = true;
                    break; 
                case DType.Bit_VarCng:  
                    this.Bit_VarCng(EnemyDmgStac[i]._Var);
                    continueFlg = true;
                    break; 
                case DType.BitSet_Atk:  
                    this.BtlBit_Set(EnemyDmgStac[i]._SkillId);
                    continueFlg = true;
                    break; 
                case DType.ItemCoolTurnCng:  
                    for (let i = 0; i < $gameSystem.AdSysCT.length; i++) {
                        if ($gameSystem.AdSysCT[i].ct > 0) {
                            $gameSystem.AdSysCT[i].ct--;
                        }
                    }
                    continueFlg = true;
                    this.BtlItemBtnDraw(); 
                    break; 
            }
            if (continueFlg) {  
                EnemyDmgStac.splice(i, 1);
                i--; 
                continue; 
            }
            let DmgShakeFlg = true; 
            let _C_Str = ""; 
            let _I_Str = ""; 
            let _B_Str = ""; 
            let _SSetX = 0;
            let _SSetY = 0;
            let _APosX = 0;
            let _APosY = 0;
            if (targetENo <= -1) { 
                if (NPlayer[-targetENo - 1] == undefined) return; 
                _C_Str = NPlayer[-targetENo - 1]._name;
                _SSetX = NPlayer[-targetENo - 1]._screenX + popUpPosX;
                _SSetY = NPlayer[-targetENo - 1]._screenY;
                _APosX = NPlayer[-targetENo - 1]._screenX;
                _APosY = NPlayer[-targetENo - 1]._screenY;
            } else {
                if (NEnemy[targetENo] == undefined) {
                    EnemyDmgStac.splice(i, 1); 
                    i--;
                    continue;
                }
                _C_Str = NEnemy[targetENo]._name; 
                _SSetX = NEnemy[targetENo]._screenX + NEnemy[targetENo]._IcX - 40;
                _SSetY = NEnemy[targetENo]._screenY - (NEnemy[targetENo]._pHeight / 2) + NEnemy[targetENo]._IcY;
                _APosX = NEnemy[targetENo]._screenX;
                _APosY = NEnemy[targetENo]._screenY;
            }
            if (dmgType == DType.SetState) { 
                _SSetY -= 40; 
                let _ckStId = EnemyDmgStac[i]._StId;
                let _ckSTurn = EnemyDmgStac[i]._Turn;
                let _StateMsg = $dataStates[_ckStId].message1;
                _I_Str = "\\I[" + $dataStates[_ckStId].iconIndex + "]"; 
                _B_Str = EnemyDmgStac[i]._Turn; 
                _StateMsg = _StateMsg.replace("<C>", _C_Str).replace("<I>", _I_Str).replace("<B>", _B_Str);
                this.BLogAdd(180, _StateMsg);
                let _PosStr = ""; 
                if ($dataStates[_ckStId].meta["有利"]) {
                    _PosStr = "\\state[" + _ckStId + "]"
                    this.SetDmgPicture(_SSetX, _SSetY, _PosStr);
                    DmgShakeFlg = false;
                } else {
                    switch (_ckStId) { 
                        case StOneType.Defense: 
                            _PosStr = "\\I[" + $dataStates[_ckStId].iconIndex + "] DEF+" + EnemyDmgStac[i]._Turn;
                            this.SetDmgPicture(_SSetX, _SSetY, _PosStr);
                            DmgShakeFlg = false;
                            break;
                        case StOneType.CelDmg: 
                            this.SetDmgPicture(_SSetX, _SSetY, _ckSTurn, 31);
                            break;
                        default: 
                            _PosStr = "\\state[" + _ckStId + "]"
                            this.SetDmgPicture(_SSetX, _SSetY, _PosStr);
                    }
                }
                if (targetENo <= -1) {
                    sateAddPlayerFlg = -targetENo - 1 == 0;
                    AddNState(NPlayer[-targetENo - 1]._NState, _ckStId, _ckSTurn);
                    if (-targetENo - 1 == 0) {
                        $gameActors.actor(1).addState(_ckStId);
                    }
                } else {
                    AddNState(NEnemy[targetENo]._NState, _ckStId, _ckSTurn);
                }
            } else {
                let setDmgValue = EnemyDmgStac[i]._Var; 
                let _BLogStr = "";
                let _SetCol = 29;
                let _dmgSkipFlg = false; 
                switch (dmgType) {
                    case DType.HpRecv:  
                    case DType.HpKyuketu:  
                        if (dmgType == DType.HpKyuketu)
                            setDmgValue = _Skill吸血Dmg;
                        DmgShakeFlg = false;
                        _BLogStr = _C_Str + " recovered " + setDmgValue + " HP";
                        this.BLogAdd(180, _BLogStr, _SetCol);
                        this.SetDmgPicture(_SSetX, _SSetY, setDmgValue, _SetCol);
                        setDmgValue *= -1;
                        break;
                    case DType.MpRecv:  
                        DmgShakeFlg = false;
                        _BLogStr = _C_Str + " recovered " + setDmgValue + " MP";
                        this.BLogAdd(180, _BLogStr, _SetCol);
                        this.MPKaihuku(setDmgValue);
                        _SetCol = 23;
                        this.SetDmgPicture(_SSetX, _SSetY, setDmgValue, _SetCol);
                        setDmgValue = 0;
                        break;
                    case DType.HPMstCng:  
                        var _grvdFlg = false;
                        try {
                            if (MetaChecker($dataSkills[EnemyDmgStac[i]._SkillId] , "グラビデ" , false) != false) {
                                _grvdFlg = true;
                            }
                        } catch (e) { }
                        if (targetENo <= -1) {
                            if (_grvdFlg)
                                NPlayer[(-targetENo - 1)]._hp = Math.round(NPlayer[(-targetENo - 1)]._hp / setDmgValue);
                            else
                                NPlayer[(-targetENo - 1)]._hp = setDmgValue; 
                        } else {
                            if (_grvdFlg)
                                NEnemy[targetENo]._hp = Math.round(NEnemy[targetENo]._hp / setDmgValue);
                            else
                                NEnemy[targetENo]._hp = setDmgValue; 
                        }
                        _dmgSkipFlg = true; 
                        break;
                    default:            
                        let _DefBrakeFlg = (dmgKouka.indexOf(KSkill.防御貫通) != -1); 
                        setDmgValue = this.ChangeDmgValue_DefENo(targetENo, setDmgValue, _DefBrakeFlg);
                        let _DefPoint = GetNStateTurn_ENo(targetENo, StOneType.Defense); 
                        if (_DefPoint != -1) { 
                            _DefPoint -= setDmgValue; 
                            CngStateTurn_ENo(targetENo, StOneType.Defense, -setDmgValue); 
                            if (dmgType == DType.DefBrake) { 
                                this.BLogAdd(180, "Reduced " + _C_Str + "'s Defense by " + setDmgValue);
                                EnemyDmgStac.splice(i, 1);
                                i--; 
                                continue;
                            }
                            if (_DefPoint >= 0 && !_DefBrakeFlg) { 
                                _DefCmpFlg = true;
                                this.BLogAdd(180, _C_Str + " mitigated " + setDmgValue + " damage");
                                this.PlayAnime(GardAnimeId, _APosX, _APosY); 
                                EnemyDmgStac.splice(i, 1);
                                i--;
                                continue;
                            } else {
                                if (!_DefBrakeFlg) { 
                                    setDmgValue = -_DefPoint; 
                                }
                            }
                        }
                        if (dmgType == DType.DefBrake) {
                            EnemyDmgStac.splice(i, 1);
                            i--;
                            continue;
                        }
                        this.BLogAdd(180, _C_Str + " took " + setDmgValue + " damage!!");
                        this.SetDmgPicture(_SSetX, _SSetY, setDmgValue);
                        if (setDmgValue > 0) _Skill吸血Dmg += setDmgValue; 
                }
                if (!_dmgSkipFlg) {
                    if (targetENo <= -1) {
                        NPlayer[-targetENo - 1]._hp -= setDmgValue;
                        if (targetENo == -1) {
                            if (NPlayer[0]._hp > NPlayer[0].mhp) NPlayer[0]._hp = NPlayer[0].mhp;
                            if (NPlayer[0]._hp <= 0) {
                                NPlayer[0]._hp = 0;
                                if (ENo_StateCk_Type(targetENo, StType.Kuisibari)) {
                                    this.BLogAdd(180, _C_Str + " endured " + setDmgValue + " damage!!");
                                    NPlayer[0]._hp = 1;
                                    DelStateType_ENo(-1 , StType.Kuisibari);
                                }
                            }
                        } else {
                            this.DownCheck_Mikata(EnemyDmgStac[i]);
                        }
                    } else {
                        NEnemy[targetENo]._hp -= setDmgValue;
                        if ($gameSwitches.value(BtlStatic.SW_ラスボス演出)) {
                            let par50_1 = 0.5;
                            if (NEnemy[targetENo]._hp < Math.floor(NEnemy[targetENo].mhp * par50_1) && !$gameSwitches.value(841)
                                && !$gameSwitches.value(1346)) {
                                NEnemy[targetENo]._hp = Math.floor(NEnemy[targetENo].mhp * par50_1);
                                NEnemy[targetENo]._NState = []; 
                            }
                            let par60 = 0.6;
                            if (NEnemy[targetENo]._hp < Math.floor(NEnemy[targetENo].mhp * par60) && $gameSwitches.value(841)
                                && !$gameSwitches.value(1344)) {
                                NEnemy[targetENo]._hp = Math.floor(NEnemy[targetENo].mhp * par60); 
                                NEnemy[targetENo]._NState = []; 
                            }
                            let par25 = 0.25;
                            if (NEnemy[targetENo]._hp < Math.floor(NEnemy[targetENo].mhp * par25) && $gameSwitches.value(1344)
                                && !$gameSwitches.value(1345)) {
                                NEnemy[targetENo]._hp = Math.floor(NEnemy[targetENo].mhp * par25); 
                                NEnemy[targetENo]._NState = []; 
                            }
                        }
                        if (NEnemy[targetENo]._hp > NEnemy[targetENo].mhp) NEnemy[targetENo]._hp = NEnemy[targetENo].mhp;
                        if (setDmgValue > 0) this.DownCheck_Enemy(EnemyDmgStac[i]);
                    }
                }
            }
            if (DmgShakeFlg && StateSyoriEnd && (targetENo == -1)) {
                if (!EnemyDmgStac[i]._DmgMotionSkipFlg) this.PlayerHirumiEffect();
            }
            if (DmgShakeFlg && !EnemyDmgStac[i]._ShakeSkipFlg) { 
                $gameScreen.startShake(3, 20, 5); 
            }
        }
        if (EnemyDmgStac[i]._Flame <= 0) {
            EnemyDmgStac.splice(i, 1);
            i--;
        }
    }
    this.DmgPicMove_Update();
}
Game_Interpreter.prototype.HandCardCost_Change = function (cngValue) {
    for (let i = 0; i <= CardData.length - 1; i++) {
        if (CardData[i].Cost != "All") {
            CardData[i].Cost += cngValue;
        }
        if (cngValue < 0) CardData[i].MoveAftPtc = "BtlCostCng_Up";
        if (cngValue > 0) CardData[i].MoveAftPtc = "BtlCostCng_Down";
        if (CardData[i].Cost < 0) CardData[i].Cost = 0;
        if (CardData[i].Cost > 9) CardData[i].Cost = 9;
        this.CardReDrawC(i);
        CardData[i].KeepPicData = this.PicObjGet(CardData[i].setPNo);
    }
}
Game_Interpreter.prototype.HandCardCost_HrfRndCost = function (_CngVar, _ZeroFlg) {
    _ZeroFlg = typeof _ZeroFlg !== 'undefined' ? _ZeroFlg : false;
    let _HarfArr = [];
    for (let i = 0; i <= _CngVar - 1; i++) {
        if (_HarfArr.length >= CardData.length) break;
        let _SetNo = NRandGet(CardData.length - 1);
        if (_HarfArr.indexOf(_SetNo) != -1) {
            i--;
            continue;
        }
        _HarfArr.push(_SetNo);
    }
    for (let i = 0; i <= _HarfArr.length - 1; i++) {
        let _ckNo = _HarfArr[i];
        if (CardData[_ckNo].Cost != "All") {
            if (_ZeroFlg) {
                CardData[_ckNo].Cost = 0;
            } else {
                CardData[_ckNo].Cost = Math.floor(CardData[_ckNo].Cost / 2);
            }
        }
        if (CardData[_ckNo].Cost < 0) CardData[_ckNo].Cost = 0;
        CardData[_ckNo].MoveAftPtc = "BtlCostCng_Up";
        this.CardReDrawC(_ckNo);
        CardData[_ckNo].KeepPicData = this.PicObjGet(CardData[_ckNo].setPNo);
    }
}
let _SetBitType = "";
Game_Interpreter.prototype.BtlBit_Set = function (_SkillId) {
    let _SetTurn = 3;
    let _BitFType = MetaChecker($dataSkills[_SkillId], "FType", "Atk");
    if (_所持レリック確認(Itm_Reric.ビットTn増加)) _SetTurn += 4;
    NPlayer[0]._BtlBit.unshift(new BtlBitData(_BitFType, 10, _SetTurn));
}
Game_Interpreter.prototype.PlayerHirumiEffect = function (voiceOffFlg) {
    voiceOffFlg = typeof voiceOffFlg !== 'undefined' ? voiceOffFlg : false;
    if (plNotHirumi) return;
    Live2D_WaitSetTime = 40;
    spainWaitAnimeFlame = 30;
    if (!this.IsPlayerメタル化()) this.SetSpineAnime(PN_CharacterPL, "Dmg", false);
    if (BtlRomashaFlg && !this.IsPlayerメタル化()) {
        if (!voiceOffFlg) {
            if (NPlayer[0].hp <= 0) {
                this.PRandVoice("romasha",["h1_505_tuuan","h1_506_nnfuu","h1_510_hiiuu","h1_511_kufuu","h1_514_afuu"]);
            } else {
                this.PRandVoice("romasha",["btl_395_kyaa","btl_396_ngu","btl_397","btl_398_ita","btl_398_ita_2","btl_399_au","btl_400_damee","btl_401_iyaaa"]);
            }
        }
        if (DmgAnimeName != "") {
            // let nowPlayAnime = PlayL2DAnimeName(MdlRomashaBattle , 0);
            // if (nowPlayAnime != "battale_bottomdamage" && nowPlayAnime != "battale_topdamage") {
            //     L2dSetMotion(MdlRomashaBattle, DmgAnimeName);
            if (!this.IsPlayerメタル化()) L2dSetMotion(MdlRomashaBattle, DmgAnimeName);
        } else {
            DmgAnimeFlame = 20;
            if (Math.random() >= 0.5) { 
                L2dSetMotion(MdlRomashaBattle, "battale_bottomdamage");
                DmgAnimeName = "battale_bottomdamage";
            } else {
                L2dSetMotion(MdlRomashaBattle, "battale_topdamage");
                DmgAnimeName = "battale_topdamage";
            }
        }
        this.BtlLive2DParamSet_State();
    }
}
Game_Interpreter.prototype.DownCheck_Mikata = function (dmgStacData) {
    let charaNo = -dmgStacData._CNo - 1;
    let pictureNo = NPlayer[charaNo]._PicNo;
    if (NPlayer[charaNo].SpineFlg) {
        let idlName = GetEnemyIdlName(NPlayer[charaNo]);
        this.SetSpineAnime(PN_CharacterPL + pictureNo, "Dmg", false, 0, 100);
        this.AddSpineAnime(PN_CharacterPL + pictureNo, idlName, true, 0, 100);
    }
    if (btl味方VoiceData.isVoice) {
        if (NPlayer[charaNo]._hp <= 0) { 
            if (btl味方VoiceData.DownVoice.length > 0) {
                this.PRandVoice(btl味方VoiceData.charaName, btl味方VoiceData.DownVoice);
            }
        } else {
            if (btl味方VoiceData.DmgVoice.length > 0) {
                this.PRandVoice(btl味方VoiceData.charaName, btl味方VoiceData.DmgVoice);
            }
        }
    }
    if (NPlayer[charaNo]._hp <= 0) { 
        NPlayer[charaNo]._hp = 0;
        this.PicCngColor(PN_CharacterPL + pictureNo, [220, 220, 220, 0], 20);
        this.MovePict(PN_CharacterPL + pictureNo,
            NPlayer[charaNo]._screenX, NPlayer[charaNo]._screenY - 10, 25, 0 ,
            -100 * NPlayer[charaNo].SpineXScale , 100 * Math.abs(NPlayer[charaNo].SpineXScale)); 
        this.DelSprite(PN_NextIcoPL + pictureNo);
        this.DelSprite(PN_NextPicPL + pictureNo);
        let enemyData = GetEnemyData_ENo(-charaNo - 1);
        if (MetaChecker(enemyData, "残骸", "Not") != "Not") {
            this.SetPictC(PN_CharacterPL + pictureNo, "enemies/" + enemyData.battlerName + "_Down",
                NPlayer[charaNo]._screenX, NPlayer[charaNo]._screenY, 255, -100);
        }
        let metaStr = MetaChecker(enemyData, "死時SW", "");
        if (metaStr != "") $gameSwitches.setValue(BtlSwCk(metaStr), true);
        let deadAnime = MetaChecker(enemyData, "SpineDead", false);
        if (deadAnime != false) {
            this.SetSpineAnime(PN_CharacterPL + pictureNo, deadAnime, false, 0, 100);
        }
        this.BLogAdd(180, NPlayer[charaNo]._name + " was defeated!!");
        this.RemoveTCData_ENo(dmgStacData._CNo); 
        N_Sprite_DLayer = 1;
        this.DelSprite(PN_DifNum_PL + pictureNo);
        N_Sprite_DLayer = 0;
    }
    if (NPlayer[charaNo]._hp > NPlayer[charaNo].mhp) {
        NPlayer[charaNo]._hp = NPlayer[charaNo].mhp;
    }
}
Game_Interpreter.prototype.DownCheck_Enemy = function (dmgStacData) {
    let ENo = dmgStacData._CNo;
    let pictureNo = NEnemy[ENo]._PicNo;
    if (NEnemy[ENo].SpineFlg) {
        let idlName = GetEnemyIdlName(NEnemy[ENo]);
        this.SetSpineAnime(PN_Character + pictureNo, "Dmg", false, 0, 100);
        this.AddSpineAnime(PN_Character + pictureNo, idlName, true, 0, 100);
    }
    if (NEnemy[ENo]._hp <= 0) this.EnemyDown_ENo(ENo);
    if (NEnemy[ENo]._hp > NEnemy[ENo].mhp) {
        NEnemy[ENo]._hp = NEnemy[ENo].mhp;
    }
}
var bラスボス撃破 = false;
Game_Interpreter.prototype.EnemyDown_ENo = function (ENo) {
    let pictureNo = NEnemy[ENo]._PicNo;
    NEnemy[ENo]._hp = 0;
    var _第２形態BtlSw = MetaChecker(NEnemy[ENo].enemy() , "第２形態BtlSw" , false);
    if (_第２形態BtlSw != false) {
        $gameSwitches.setValue(BtlStatic.SW_戦闘用SW - 1 + Number(_第２形態BtlSw) , true);
        NEnemy[ENo]._hp = 1;
        return;
    }
    if ($gameSwitches.value(BtlStatic.SW_ラスボス演出)) {
        bラスボス撃破 = true;
        return;
    }
    this.SpriteCngColor(PN_Character + pictureNo, [220, 220, 220, 0], 20);
    if (NEnemy[ENo].SpineFlg) {
        this.MovePict(PN_Character + pictureNo,
            NEnemy[ENo]._screenX, NEnemy[ENo]._screenY - 10, 25, 0, true, true);
    } else {
        this.MoveSprite(PN_Character + pictureNo,
            NEnemy[ENo]._screenX, NEnemy[ENo]._screenY - 10, 25, 0, true, true);
    }
    let enemyData = GetEnemyData_ENo(ENo);
    if (MetaChecker(enemyData, "残骸", "Not") != "Not") {
        this.SetSpriteC(PN_Character + pictureNo, "enemies/" + enemyData.battlerName + "_Down",
            NEnemy[ENo]._screenX, NEnemy[ENo]._screenY);
    } else {
        this.DelSprite(PN_NextIco + pictureNo); 
        this.DelSprite(PN_NextDmg + pictureNo);
    }
    let deathStr = MetaChecker(enemyData, "死時SW", "Not");
    if (deathStr != "Not") $gameSwitches.setValue(Number(deathStr), true);
    let deadAnime = MetaChecker(enemyData, "SpineDead", false);
    if (deadAnime != false) {
        this.SetSpineAnime(PN_Character + pictureNo, deadAnime, false, 0, 100);
    }
    this.DelSprite(PN_NextPic + pictureNo); 
    this.BLogAdd(180, NEnemy[ENo]._name + " was defeated!!");
    this.RemoveTCData_ENo(ENo); 
    if (BtlEnemyCellDmgFlg) {
        BtlEnemyCellDmgFlg = false;
        NextTurnCardMoveSkip = true; 
    }
    N_Sprite_DLayer = 1;
    this.DelSprite(PN_DifNum + pictureNo);
    N_Sprite_DLayer = 0;
}
class DmgPicMover {
    constructor() {
        this._x = 0; 
        this._y = 0; 
        this._colId = 0; 
        this._flame = 0; 
        this._Val = 0; 
        this._MStr = []; 
        this._MStrC = 0;
        this._CSpace = 30; 
        this._StrSize = 25; 
    }
}
let _DmgPicArr = [
    new DmgPicMover(), new DmgPicMover(), new DmgPicMover(),
    new DmgPicMover(), new DmgPicMover(), new DmgPicMover(),
    new DmgPicMover(), new DmgPicMover(), new DmgPicMover()
];
let DmCounter = 0;
Game_Interpreter.prototype.SetDmgPicture = function (setX, setY, dmgValue, colorId) {
    colorId = typeof colorId !== 'undefined' ? colorId : 0;
    if (dmgValue == undefined) {
        return;
    }
    if (dmgValue.indexOf != undefined) {
        if (dmgValue.indexOf("\\state[") != -1) {
            for (let i = 0; i < PopUpPosCheckArr.length; i++) {
                if (PopUpPosCheckArr[i].setX == setX && PopUpPosCheckArr[i].setY == setY) {
                    setY -= 32;
                    i = 0; 
                }
            }
            PopUpPosCheckArr.push(new PopUpPosCheckData(setX, setY, 15));
        }
    }
    let randHani = 50;
    let randX = Math.random() * randHani - (randHani / 2);
    let randY = Math.random() * randHani - (randHani / 2);
    _DmgPicArr[DmCounter]._colId = colorId;
    _DmgPicArr[DmCounter]._Val = dmgValue;
    _DmgPicArr[DmCounter]._MStr = []; 
    if (dmgValue.length > 3) { 
        randX = 0;
        randY = 0;
        _DmgPicArr[DmCounter]._StrSize = 25; 
        _DmgPicArr[DmCounter]._MStr.push(dmgValue);
    } else {
        if (dmgValue < 10) _DmgPicArr[DmCounter]._StrSize = 25; 
        if (dmgValue >= 10) { 
            _DmgPicArr[DmCounter]._StrSize = 30;
            _DmgPicArr[DmCounter]._CSpace = 23
        }
        if (dmgValue > 60) { 
            _DmgPicArr[DmCounter]._StrSize = 40;
            _DmgPicArr[DmCounter]._CSpace = 30;
            if (_DmgPicArr[DmCounter]._colId == 0) _DmgPicArr[DmCounter]._colId = 6;
        }
        if (dmgValue > 100) {
            _DmgPicArr[DmCounter]._StrSize = 50; 
            _DmgPicArr[DmCounter]._CSpace = 40;
            if (_DmgPicArr[DmCounter]._colId == 0) _DmgPicArr[DmCounter]._colId = 14;
        }
        for (let i = 0; i <= String(dmgValue).length - 1; i++) {
            _DmgPicArr[DmCounter]._MStr.push(String(dmgValue).substr(i, 1));
        }
    }
    _DmgPicArr[DmCounter]._x = setX + randX;
    _DmgPicArr[DmCounter]._y = setY + randY;
    _DmgPicArr[DmCounter]._MStrC = 0; 
    _DmgPicArr[DmCounter]._flame = 1; 
    DmCounter++;
    if (DmCounter >= 8) DmCounter = 0;
}
const OneMojiFlame = 5; 
Game_Interpreter.prototype.DmgPicMove_Update = function () {
    for (di = 0; di <= _DmgPicArr.length - 1; di++) {
        if (_DmgPicArr[di]._flame != 0) { 
            let strSpace = _DmgPicArr[di]._CSpace; 
            if (_DmgPicArr[di]._flame == 1) {
                let outLineCng = "\\oc[rgb(0,0,0)]\\ow[6] "; 
                let colCng = ""; 
                if (_DmgPicArr[di]._colId != 0) colCng = "\\C[" + _DmgPicArr[di]._colId + "]";
                for (let mi = 0; mi <= _DmgPicArr[di]._MStr.length - 1; mi++) {
                    this.SetPicStrFont("Arial Black");
                    this.SpriteStr(PN_DmgTxtE + mi + (3 * di), outLineCng + colCng + _DmgPicArr[di]._MStr[mi] + "　",
                        _DmgPicArr[di]._StrSize, _DmgPicArr[di]._x + mi * strSpace, _DmgPicArr[di]._y, 0);
                }
            }
            if (_DmgPicArr[di]._flame < 60) { 
                if (_DmgPicArr[di]._flame % 6 == 2 && _DmgPicArr[di]._MStrC != _DmgPicArr[di]._MStr.length) {
                    this.EMoveSet("easeOutBack");
                    this.MoveSprite(PN_DmgTxtE + _DmgPicArr[di]._MStrC + (3 * di),
                        _DmgPicArr[di]._x + _DmgPicArr[di]._MStrC * strSpace, _DmgPicArr[di]._y - 20, 10, 255);
                    _DmgPicArr[di]._MStrC++;
                    this.EMoveSet("");
                }
            } else {
                if (_DmgPicArr[di]._flame == 61) {
                    _DmgPicArr[di]._MStrC = 0;
                }
                if (_DmgPicArr[di]._flame % 6 == 2 && _DmgPicArr[di]._MStrC != _DmgPicArr[di]._MStr.length) {
                    this.EMoveSet("easeOutBack");
                    this.MoveSprite(PN_DmgTxtE + _DmgPicArr[di]._MStrC + (3 * di),
                        _DmgPicArr[di]._x + _DmgPicArr[di]._MStrC * strSpace, _DmgPicArr[di]._y - 40, 10, 0);
                    _DmgPicArr[di]._MStrC++;
                    this.EMoveSet("");
                }
                if (_DmgPicArr[di]._flame == 90) {
                    _DmgPicArr[di]._flame = 0; 
                    continue; 
                }
            }
            _DmgPicArr[di]._flame++;
        }
    }
}