MV - SRPG Engine MV - Plugins for creating Tactical Battle System

// Get Active events skill range.
$gameSystem.EventToUnit($gameTemp.activeEvent().eventId())[1].srpgSkillRange($gameSystem.EventToUnit($gameTemp.activeEvent().eventId())[1].action(0).item());

//Get Target events skiil range (if target has counterattack).
$gameSystem.EventToUnit($gameTemp.targetEvent().eventId())[1].srpgSkillRange($gameSystem.EventToUnit($gameTemp.targetEvent().eventId())[1].action(0).item());

Window_SrpgPrediction.prototype.drawContents = function() {
        var windowWidth = this.windowWidth();
        var lineHeight = this.lineHeight();
        var x = 40;
        // action data
        var actor = this._actionArray[1];
        var target = this._targetArray[1];
        var action = actor.currentAction();
        var damage = action.srpgPredictionDamage(target);
        var hit = action.itemHit(target);
        var eva = action.itemEva(target);
       // var cri = action.itemCri(target);
        this.drawSrpgBattleActionName(actor, action, windowWidth / 2 + x, lineHeight * 0, true);
        this.drawSrpgBattleHit(hit, eva, windowWidth / 2 + x, lineHeight * 1);
        //this.drawSrpgBattleCri(cri, windowWidth / 2 + 160 + x, lineHeight * 1);
        this.drawSrpgBattleDistance(actor, action, windowWidth / 2 + 160 + x, lineHeight * 1);
        this.drawSrpgBattleDamage(damage, windowWidth / 2 + x, lineHeight * 2);
        // reaction data
        var actor = this._targetArray[1];
        var target = this._actionArray[1];
        var userActionMeta = target.currentAction().item().meta;
        var counter = this._targetArray[1].cnt * 100;
        // EDITED BY ADRA
        var counterSkill = actor.counterSkillId();
        var action = new Game_Action(actor);
        action.setSkill(counterSkill);
        action.setSubject(actor);
        if (counterSkill > 0) {
            var isCounterInRange = $gameSystem.srpgCntInRange(target.event()._eventId, actor.event()._eventId);
        }  
        if (!this._targetArray[1].canUse(action.item()) && counterSkill === 0) {
            action = null;
        }
        // if no reaction or actingUnit = targetUnit
        if ((!action && counterSkill === 0) || actor == target || counter === 0 || !isCounterInRange) {
            this.drawSrpgBattleActionName(actor, action, x, lineHeight * 0, false);
            return;
        }
       
        // if counter
        if (counter !== 0 && !userActionMeta.srpgUncounterable) {
            this.changeTextColor(this.systemColor());
            this.drawText('Counter', x + 160, lineHeight * 0, 96, 'right');
            this.resetTextColor();
            this.drawText(counter + '%', x + 220, lineHeight * 0, 96, 'right');
            // display target crit
            this.changeTextColor(this.systemColor());
            //this.drawText('Crit', x + 160, lineHeight * 2);
            this.resetTextColor();
            this.drawText(targetCrit + '%', x + 220, lineHeight * 2);
        }
        // EDITED BY ADRA
        var target = $gameSystem.EventToUnit($gameTemp.targetEvent().eventId())[1];
        var counterSkill = target.counterSkillId();

        // Check if there's a counter skill and draw its details
        if (counterSkill > 0 && !userActionMeta.srpgUncounterable) {
            var counterAction = $dataSkills[counterSkill]; // Get the skill data
            var actor = this._targetArray[1];
            var target = this._actionArray[1];
            var action = new Game_Action(actor);
            action.setSkill(counterSkill);
            action.setSubject(actor);
            //draw the counter attack name
            this.drawText(counterAction.name, x, lineHeight * 0);
            //calculate the damage , hit, eva and crit
            var counterDamage = action.srpgPredictionDamage(target);
            var counterHit = action.itemHit(target);
            var counterEva = action.itemEva(target);
            var counterCri = action.itemCri(target);
            //draw the damage, hit, eva and crit
            this.drawSrpgBattleHit(counterHit, counterEva, x, lineHeight * 1);
            //this.drawSrpgBattleCri(counterCri, 160 + x, lineHeight * 1);
            this.drawSrpgBattleDamage(counterDamage, x, lineHeight * 2);
            this._targetArray[1].clearActions();          
        } else {
            var action = actor.currentAction();
            var damage = action.srpgPredictionDamage(target);
            var hit = action.itemHit(target);
            var eva = action.itemEva(target);
            var cri = action.itemCri(target);
            this.drawSrpgBattleActionName(actor, action, x, lineHeight * 0, true);
            this.drawSrpgBattleHit(hit, eva, x, lineHeight * 1);
            //this.drawSrpgBattleCri(cri, 160 + x, lineHeight * 1);
            this.drawSrpgBattleDistance(actor, action, 160 + x, lineHeight * 1);
            this.drawSrpgBattleDamage(damage, x, lineHeight * 2);
            this._targetArray[1].clearActions();
        }
    };

Game_System.prototype.srpgCntInRange = function(userEID, targetEID) {
    var user = $gameSystem.EventToUnit(userEID);
    var target = $gameSystem.EventToUnit(targetEID);
    var skill = 1;
    //if (target[1].attackSkillId() !== 0) skill = target[1].attackSkillId();
    if (target[1].counterSkillId() !== 0) skill = target[1].counterSkillId();
    if ($gameSystem.srpgBattlerDistance(userEID, targetEID) > $gameSystem.srpgUnitSkillRange(target, skill)) {
        return false
    } else {return true};
};
Game_System.prototype.srpgBattlerDistance = function(userEID, targetEID) {
    // unit event id
    if (userEID > 0) var user = $gameSystem.EventToUnit(userEID);
    if (targetEID > 0) var target = $gameSystem.EventToUnit(targetEID);
    // active/target event
    if (userEID === 0) var user = $gameSystem.EventToUnit($gameTemp.activeEvent().eventId());
    if (targetEID === 0) var target = $gameSystem.EventToUnit($gameTemp.targetEvent().eventId());
    var xUser = user[1].event().x;
    var xTarget = target[1].event().x;
    var yUser = user[1].event().y;
    var yTarget = target[1].event().y;
    return $gameMap.distance(xUser, yUser, xTarget, yTarget);
};
Game_System.prototype.srpgUnitSkillRange = function(userUnit, skillId) {
      var skill = $dataSkills[skillId];
      var range = 1;
      if (userUnit[1].isActor()) {
        if (skill && skill.meta.srpgRange == Number(-1)) {
            if (!userUnit[1].hasNoWeapons()) {
                var weapon = userUnit[1].weapons()[0];
                if (weapon.meta.weaponRange) range = Number(weapon.meta.weaponRange);
                // States
                userUnit[1].states().forEach(function(state) {
                    if (state && state.meta.srpgWRangePlus) {
                        range += Number(state.meta.srpgWRangePlus);
                    }
                }, userUnit[1]);
                // Equip
                userUnit[1].armors().forEach(function(armor) {
                    if (armor && armor.meta.srpgWRangePlus) {
                        range += Number(armor.meta.srpgWRangePlus);
                    }
                }, userUnit[1]);
            }
        } else if (skill.meta.srpgRange) {
            range = skill.meta.srpgRange;
        } else {
            range = 1;
        }
      };
      if (userUnit[1].isEnemy()) {
        if (skill && skill.meta.srpgRange == -1) {
            if (!userUnit[1].hasNoWeapons()) {
                var weapon = userUnit[1].weapons()[0];
                if (weapon.meta.weaponRange) range = Number(weapon.meta.weaponRange);
            } else {
                range = Number(userUnit[1].enemy().meta.weaponRange);
            }
            // states
            userUnit[1].states().forEach(function(state) {
                if (state && state.meta.srpgWRangePlus) {
                    range += Number(state.meta.srpgWRangePlus);
                }
            }, userUnit[1]);
        } else if (skill.meta.srpgRange) {
            range = skill.meta.srpgRange;
        } else {
            range = 1;
        }
      };
return Number(range);
};

// apply effects or trigger a counter
                if (!data.counter && user != target && Math.random() < action.itemCnt(target)) {
                    if ($gameSystem.srpgCntInRange(user.event()._eventId, target.event()._eventId) == true) {
                        var attackSkill = $dataSkills[target.attackSkillId()];
                        if (target.canUse(attackSkill) == true) {
                                                target.performCounter();
                                this.srpgAddCounterAttack(user, target);
                                             } else {action.apply(target)};      
                        } else {action.apply(target)};
                    } else {action.apply(target)};

//replaced counter text
        if (counter !== 0 && !userActionMeta.srpgUncounterable) {
            this.changeTextColor(this.systemColor());
            this.drawText('Counter', x + 160, lineHeight * 0, 96, 'right');
            this.resetTextColor();
            this.drawSrpgBattleCnt(counter, x + 220, lineHeight * 0, 96, 'right');
            // Display target crit
            this.changeTextColor(this.systemColor());
            this.resetTextColor();
        }

//draw counter function
    Window_SrpgPrediction.prototype.drawSrpgBattleCnt = function(counter, x, y) {
        var val = counter;
        this.changeTextColor(this.systemColor());
        this.drawText(TextManager.param(14), x, y, 98);
        this.resetTextColor();
        if ($gameTemp.getAttackDirection) {
            if ($gameTemp.getAttackDirection() === 'side') {
                this.drawText(Math.floor(val * sideR_cnt) + '%', x + 64, y, 64, 'right');
            }
            else if ($gameTemp.getAttackDirection() === 'back') {
                this.drawText(Math.floor(val * backR_cnt) + '%', x + 64, y, 64, 'right');

            }else this.drawText(Math.floor(val) + '%', x + 64, y, 64, 'right');
        }
    };

var _Game_Action_evalDamageFormula = Game_Action.prototype.evalDamageFormula;
    Game_Action.prototype.evalDamageFormula = function(target) {
        var value = _Game_Action_evalDamageFormula.call(this, target);
        // Check if in SRPG mode and active/target events exist
        if ($gameSystem.isSRPGMode() && $gameTemp.activeEvent() && $gameTemp.targetEvent()) {
            // Get the skill being used
            var skill = this.item();
  
            // Get default modifiers from plugin parameters
            var sideDmg = side_dmg;
            var backDmg = back_dmg;

            // Check if the skill has note tags for side and back damage modifiers
            if (skill.meta.side_dmg !== undefined) {
                sideDmg += parseFloat(skill.meta.side_dmg);
            }
            if (skill.meta.back_dmg !== undefined) {
                backDmg += parseFloat(skill.meta.back_dmg);
            }

            // Check if the attacker has any states with side_dmg or back_dmg modifiers
            var attackerStates = this.subject().states();
            for (var i = 0; i < attackerStates.length; i++) {
                var state = attackerStates[i];
                if (state.meta.side_dmg !== undefined) {
                    sideDmg += parseFloat(state.meta.side_dmg);
                }
                if (state.meta.back_dmg !== undefined) {
                    backDmg += parseFloat(state.meta.back_dmg);
                }
            }
  
            // Determine attack direction
            if ($gameSystem.isSubBattlePhase() == 'battle_window') {
                decideAttackdirection();
            }
  
            // Check if attacker and target are from different groups
            if (this.subject() == $gameSystem.EventToUnit($gameTemp.activeEvent().eventId())[1] &&
                $gameSystem.EventToUnit($gameTemp.activeEvent().eventId())[0] !=
                $gameSystem.EventToUnit($gameTemp.targetEvent().eventId())[0]) {
                // Apply damage modifier based on attack direction
                if ($gameTemp.getAttackDirection() == 'side') {
                    value *= sideDmg;
                } else if ($gameTemp.getAttackDirection() == 'back') {
                    value *= backDmg;
                }
            }
        }
        return value;
    };

var _Game_Action_itemHit = Game_Action.prototype.itemHit;
    Game_Action.prototype.itemHit = function(target) {
        var value = _Game_Action_itemHit.call(this, target);
        // Check if in SRPG mode and active/target events exist
        if ($gameSystem.isSRPGMode() && $gameTemp.activeEvent() && $gameTemp.targetEvent()) {
            // Get the skill being used
            var skill = this.item();
            // Get default hit rate modifiers from plugin parameters
            var sideHit = side_hit;
            var backHit = back_hit;
            // Check if the skill has note tags for hit rate modifiers
            if (skill.meta.side_hit !== undefined) {
                sideHit += parseFloat(skill.meta.side_hit);
            }
            if (skill.meta.back_hit !== undefined) {
                backHit += parseFloat(skill.meta.back_hit);
            }
            var attackerStates = this.subject().states();
            for (var i = 0; i < attackerStates.length; i++) {
                var state = attackerStates[i];
                if (state.meta.side_hit !== undefined) {
                    sideHit += parseFloat(state.meta.side_hit);
                }
                if (state.meta.back_dmg !== undefined) {
                    backHit += parseFloat(state.meta.back_hit);
                }
            }
            // Check if attacker and target are from different groups
            if (this.subject() == $gameSystem.EventToUnit($gameTemp.activeEvent().eventId())[1] &&
                $gameSystem.EventToUnit($gameTemp.activeEvent().eventId())[0] !=
                $gameSystem.EventToUnit($gameTemp.targetEvent().eventId())[0]) {
                // Apply hit rate modifier based on attack direction
                if ($gameTemp.getAttackDirection() == 'side') {
                    value *= sideHit;
                } else if ($gameTemp.getAttackDirection() == 'back') {
                    value *= backHit;
                }
            }
        }
        return value;
    };

    var _Game_Action_itemEva = Game_Action.prototype.itemEva;
    Game_Action.prototype.itemEva = function(target) {
        var value = _Game_Action_itemEva.call(this, target);
        // Check if in SRPG mode and active/target events exist
        if ($gameSystem.isSRPGMode() == true) {
            if ($gameTemp.activeEvent() && $gameTemp.targetEvent()) {
                // Check if attacker and target are from different groups
                if (this.subject() == $gameSystem.EventToUnit($gameTemp.activeEvent().eventId())[1] &&
                    $gameSystem.EventToUnit($gameTemp.activeEvent().eventId())[0] !=
                    $gameSystem.EventToUnit($gameTemp.targetEvent().eventId())[0]) {
                    // Apply evasion rate modifier based on attack direction
                    if ($gameTemp.getAttackDirection() == 'side') {
                        value *= side_eva;
                    } else if ($gameTemp.getAttackDirection() == 'back') {
                        value *= back_eva;
                    }
                    // If the hit rate is 100% or more, set the target's evasion rate to 0
                    var hitRate = this.itemHit();
                    if (hitRate >= 1.0) {
                        value = 0;
                        console.log("Eva rate adjusted for guaranteed hit:", value);
                    }
                  
                }
            }
        }
        console.log("Eva rate for hit:", value);
        return value;
    };

var differenceX = $gameTemp.activeEvent().posX() - $gameTemp.targetEvent().posX();
var differenceY = $gameTemp.activeEvent().posY() - $gameTemp.targetEvent().posY();
if (Math.abs(differenceX) > Math.abs(differenceY)) {
    if (differenceX > 0) { $gameTemp.activeEvent().setDirection(4); $gameTemp.targetEvent().setDirection(6);
    } else { $gameTemp.activeEvent().setDirection(6); $gameTemp.targetEvent().setDirection(4);}
} else {if (differenceY >= 0) {$gameTemp.activeEvent().setDirection(8);$gameTemp.targetEvent().setDirection(2);
    } else {$gameTemp.activeEvent().setDirection(2);$gameTemp.targetEvent().setDirection(8);}
};