Rpg Maker Developers Group

View attachment 134172
View attachment 134173
View attachment 134174
View attachment 134175
View attachment 134176

Place the file in your game's data folder and tell the plugin through the Plugin Manager its name and how to read its objects. While using this option, ignore the parameter "Plugin Manager Skills" should be ignored, as it won't be used.

You can find below basic instructions as to how to setup your JSON file. You must follow the same structure, but you can change each object name to your liking through the plugins parameters.


"xpType" must be used to identify how the skill gains xp. There are three possible values:

1. Skill uses
2. Battles won
3. Battles survived

If no value is provided, the plugin will assume "Skill uses" as default.

The "default" tag includes what are the default values if no level specific data is found (so if these are set, you probably won't need to define data for the skill's first level). The plugin will always search first for specific level data, then defaults, and if none are found it will use the values set through RPG Maker's interface.

The "formulas" array is optional, and must be used only if you want to set formulas for MP and TP cost, TP gain or a custom XP curve formula. If setting a formula, the word "level" will be replaced by the plugin with the current skill level.

The "levels" array is used to include specific changes introduced by each level. You don't need to defined all tags for each level if their values are not changed. For example, if MP cost remains constant until level 5, you can omit the mpCost tag from levels 1 to 4 and use it only on the default array, or defined it only on levels 1 and 5.

The "requirements" tag work different than the others, as it is cumulative. So a higher level requirement is the sum of all previous level requirements. That is to prevent inconsistencies if a character tries to learn a skill at a higher level without meeting the requirements for its weaker versions.

The "levels" array must list level object in order. If you want to skip changes on a level, simply replace the object with "null" or an empty object "{}", like the example below:


If a skill has no data defined in the JSON file, skill levels will be disabled (the skill will always be listed as being at the starting level).

The tags "dmgMods" and "customEffects" are arrays of specific plugin code that allows you to program damage modifiers and special custom effects for each level. For a list of supported tags, please refer to the proper section below.

Configuring skills through the plugin manager follows a similar structure as doing that from a JSON file. The same options are applied, but a few details are handled differently:

• Whenever MP Cost, TP Cost or TP Gain are set as -1, the value is ignored by the plugin;
• Blank descriptions, requirements, or damage formulas on a specific skill level won't override the previous level value, contrary to what happens when using a JSON file;

Just keep those rules in mind and follow the parameter windows. Remember that a parameter set in one level overwrites the value set in a previous level, but Custom Effects and Damage Modifiers must be set for each level for it to take effect (those two are not incremental like the rest).

Skill requirements are treated as eval statements. To make use of the user's data (be it an enemy or an actor), use the suffix "a". For example, to define a requirement where agility is higher than 80, use:
a.agi > 80

You can add more conditions with && (and) or || (or). For example: a skill level that requires agility higher than 80, and also have the skill with id 10 already learned:
a.agi > 80 && a.hasSkill(10)

If you want to set a requirement for having a skill at a specific level, just use the function hasSkill with two parameters, being the first the skill id and the second the required level:
a.agi>80 && a.hasSkill(10, 2)

Damage Modifiers are special codes that changes the skill damage formula. Any specific skill can have multiple modifiers. If a level specific modifier is set, it replaces any previous modifiers for the skill. This makes it easier to manage damage progression from one level to another.

Currently, the following modifiers are supported:

CRITICAL: <TYPE>
Replace <TYPE> with one of the options below:
- 0 or NORMAL: Fall back to MVs default critical hit formula;
- 1, NEVER or DISABLE: Remove any chance of the skill resulting in a critical hit;
- 2, ALWAYS, ENABLE or FORCE: Force critical hits on all skill uses;
Examples:
CRITICAL: 0
CRITICAL: ENABLE
CRITICAL: NEVER

DAMAGE MOD: <mod>
DAMAGE MODIFIER: <mod>
Use one of "<mod>" formats to change the skill damage formula:
- <oper> x, <oper> x%: Replace <oper> by +, -, * or /. This will apply the specified operand to add, remove, multiply or divide the damage formula result by the specified number;
Examples:
DAMAGE MOD: +10
DAMAGE MOD: *2
DAMAGE MOD: -5
DAMAGE MODIFIER: +2%
DAMAGE MODIFIER: *10%
- EVAL <expression>: Applies an eval to <expression> to append a clause to the damage formula results;
Examples:
DAMAGE MOD: EVAL * (a.hp/a.mhp)
DAMAGE MOD: EVAL + (a.mp/5)

Despite all examples being listed in upper case, the plugin is case insensitive.

While damage modifiers are applied before the skill is performed, changing the damage output, custom effects are applied AFTER the skill use.

Currently, the following tags are supported:

ADD STATE: <state> <who>
REMOVE STATE: <state> <who>
Use this effect to add or remove a state effect after the skill is used. Replace <state> with the state ID or state name enclosed in double quotes, while <who> must be replaced by one of the following clauses, specifying who will be affected:

• USER: Affects the skill user;
• PARTY: Affects the user's whole party (or troop, if used by an enemy);
• TARGET, or TARGETS: Affects the skill target, be it one or many;
• DEAD ALLIES: Affects all KOed party, or troop, members;
• DEAD ENEMIES: Affects all KOed enemies, or party members;
• ALIVE ALLIES: Affects all alive party, or troop, members;
• ALIVE ENEMIES: Affects all alive enemies, or party members;
• PARTY BUT USER: Affects the whole party, except the user;
• ENEMIES BUT TARGET: Affects all enemies, except the skill targets;

Examples:
ADD STATE: 10 USER
REMOVE STATE: "Poison" ALIVE ALLIES
ADD STATE: "Bleed" ENEMIES BUT TARGET
REMOVE STATE: 15 PARTY

SWITCH n: <action>
SWITCH n - m: <action>
SWITCH n to m: <action>
Changes one or a series of switches states (replace n and m to specify your range). The tag <action> can be replaced with one of the following effects:

• on: Set the switch to TRUE;
• off: Set the switch to FALSE;
• toggle: Toggle switch value;
• switch x: Copy switch x value;

Examples:
SWITCH 1: on
SWITCH 5 - 10: off
SWITCH 2 - 4: toggle
SWITCH 10: switch 1

SWITCH n: EVAL <expression>
SWITCH n - m: EVAL <expression>
Changes one or a series o switches states (replace n and m to specify your range) according to the result of an eval operation. The tag <expression> must be replaced with a script that returns true or false, or integers (where anything greater than zero will become true, and less or equal to zero false).
Examples:
SWITCH 1: EVAL a.hp/a.mhp > 0.5
SWITCH 2 - 8: EVAL a.hasSkill(4, 5) && a.mp > 150

VAR x <action>
VAR x - y <action>
VARIABLE x <action>
VARIABLE x to y <action>
Changes one or a series of variable values (replace x and y to specify your range). The tag <action> can be replaced with one of the following effects:

• = N: Sets the variable or range to value N. You can also set to the same value of the variable N using "= v[N]" instead;
• += N: Add N to the value of the variable. You can also add the value of the variable N using "+= v[N]" instead;
• -= N: Subtract N from the value of the variable. You can also subtract the value of the variable N using "-= v[N]" instead;
• *= N: Multiply the variable's value by N. You can also multiply by the the value of the variable N using "*= v[N]" instead;
• /= N: Divide the variable's value by N. You can also divide by the value of the variable N using "/= v[N]" instead;
• %= N: Replace the variable's value by the rest of the division of its current value by N. You may also use "%= v[N]" to divide by the value of the variable N;

Examples:
VAR 1 = 10
VARIABLE 7 += v[8]
VAR 2 - 7 *= 2
VAR 1 to 4 /= 3

VAR x: EVAL <expression>
VAR x - y: EVAL <expression>
VARIABLE x: EVAL <expression>
VARIABLE x - y: EVAL <expression>
Changes one or a series of variable values (replace x and y to specify your range) according to the result of an eval operation. The tag <expression> must be replaced with a script that returns integers greater or equal to zero.
Examples:
VAR 1: EVAL Math.floor((a.hp / a.mhp) * 100)
VARIABLE 6 - 11: EVAL Math.round(a.mp / a.hp)
VARIABLE 3: EVAL $gameVariables.value(1) + a.hp

EVAL: <eval clause>
Runs an eval on the <eval clause>. You can access the skill user data using the object "a" (a.hp, a.mp, a.hasSkill(<skillId>), a.actorId(), ...).
Examples:
EVAL: $gameVariables.setValue(1, a.actorId())
EVAL: a.hp > 100 ? $gameVariables.setValue(1, a.hp) : $gameVariables.setValue(1, 100)
EVAL: $gameVariables.setValue(1, Math.min(100, a.hp))

COMMON EVENT: N
Call common event of number N. One important limitation though, is that a multiple Common Event calls as custom effects of the same skill is not currently supported. If you try to insert two or more COMMON EVENT effect, only the last one will be run. You can have one for each level, but not more than one by level.
Examples:
COMMON EVENT: 10

ON CRITICAL
Add this clause to the start of any of the previous custom effect tags so that it will only take effect if the skill has landed a critical hit.
Examples:
ON CRITICAL ADD STATE: 5 USER
ON CRITICAL SWITCH 3: on
ON CRITICAL VAR 7 += 1
ON CRITICAL COMMON EVENT: 2

Note tags can be applied to classes, actors or enemies to define starting skill levels. You can set it one at a time using the full tag, or enclose a list of skills between skill mastery tags:

<TAA_SKM: S[1], L[1], X[10]>

or

<TAA_SKM>
S[1], L[1]
S[2], L[2], X[11]
</TAA_SKM>

You can also specify an interval for L and X, like this:

<TAA_SKM: S[1], L[1,3], X[0,5]>

or

<TAA_SKM>
S[1], L[1,3], X[0,5]
</TAA_SKM>

"S" stands for skill, so the number inside the square brackets must be a valid skill id. "L" means level, and defines the starting level. "X" is xp and is an optional tag. It defines that the skill starts with an amount of xp already gained. This allows you to setup enemies and make it more likely that their skills can level up during battle, or that a playable character included to the party have a skill halfway to the next level.

If you specify an interval for L or X instead of a fixed number, the plugin will calculate a random number inside the interval. This way you can have, for example, enemies in a troop with random experience in the same skill, so that each one may level up at different times. The goal here is to create a layer of unpredictability and make things a bit more interesting to the player!

$gameSystem.getSkillMpCost(skillId, level)

$gameSystem.getSkillTpCost(skillId, level)

$gameSystem.getSkillTpGain(skillId, level)

$gameSystem.getSkillDescription(skillId, level)

$gameSystem.getDamageFormula(skillId, level)

$gameSystem.actorMeetsRequirements(skillId, level, actorId)

$gameSystem.getSkillXpType(skillId)

$gameSystem.getSkillLevel(skillId, actorId)

$gameSystem.learnSkill(actorId, skillId, customLevel, customXp)

$gameSystem.getSkillProgression(actorId, skillId)

$gameSystem.isSkillKnown(actorId, skillId)

$gameSystem.hasSkill(actorId, skillId, skillLevel)

$gameSystem.getCurrentSkillXp(actorId, skillId)

$gameSystem.getSkillXpToNextLevel(actorId, skillId)

$gameSystem.getSkillUses(actorId, skillId)

$gameSystem.gainSkillXp(actorId, skillId, xp)

$gameSystem.setSkillLevel(actorId, skillId, level)

Learn Skill

Learn Multiple Skills

Gain Skill XP

Change Level