TAA_SkillMastery (v1.0.1)


Jan 27, 2017
Reaction score
First Language
Primarily Uses
TAA_SkillMastery - v1.0.1
Created by taaspider

Terms of Use
Free for noncommercial use only. For commercial use, please contact me through a private message or my facebook page.
When properly authorized (commercially or noncommercially), you whill be allowed to edit the plugin to suit your needs as long as I'm credited for the original version. You're not allowed to reuse or sell part or the whole of this plugin on your own code without prior written consent from the author.
You're not allowed to repost the plugin, always link back to this thread please.
Also, let me know when you publish your game so I can check it out! ;)

Disclaimer (read this before proceding, please)
This plugin was created to achieve some specific goals I have on my own projects. Although there were already some plugins that provide skill levels, I realised I would need too much editing to get what I wanted and decided to code it all from scratch.
The final product may be complicated for some with no programming knowledge. I did my best to make it simple, but please read the instructions carefully before using it.

Although there are a few plugins out there to provide skill levels, I had an specific vision I wanted to achieve both aiming at how the plugin will work in a game and how to make my work as a developer simpler. With that in mind, I decided to create my own plugin from scratch considering the following main requirements:

  • Allow me to load skill level data through a JSON file, allowing me to work on it outside of the engine and make it easier to evolve and edit it throughout the game development (yes, sometimes I find it easier to work directly on a file than through the engine interface);
  • Provide different ways to affect skill data with levels. I wanted the choice of using specific formulas, but also have a more refined control over the parameters whenever I choose;
  • Allow TP gain to be easily affected by skill level progression;
  • Have skill descriptions change as it levels up;
  • Have specific effects (like applying a state or setting a variable) change as the skill progresses;
  • Allow skill levels to have specific requirements that must be met before skill XP can be gained to achieve the next level, or even prevent a character from learning a skill if they're not met;
  • Allow skills to only gain XP for each battle won, or even restricting it to only when the actor survive the battle;
  • Allow enemy skills to progress as well;
Even though I had a specific requirement to allow me to load skill data through a JSON file, I realize that not all people here shares this preference. So I've also included the option of inputing this data through the Plugin Manager.

Warning: I'm yet to test the plugin with large numbers of skills, both using a JSON file or the Plugin Manager as source. Although I don't expect that to be a problem while playing the game, I'm worried that its initial setup may affect game load time. If you do test it out before I do please let me know the results so I can act on it faster!



How to Use

This plugin requires RPG Maker MV 1.5.0 or above! Please make sure your RPG Maker MV software is up to date before using this plugin.

You can download the plugin here, and here you can find a simple demo showcasing its main functions.

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.

"id": <skill id>,​
"xpType": 1,​
"default": {​
"mpCost": <cost>,​
"tpCost": <cost>,​
"tpGain": <gain>,​
"damage": "<damage formula>",​
"req": "<requirement, if any>",​
"description": "<skill description>",​
"dmgMods": [ "<damage modifier tags here", "<dmgMods>", ... ],​
"customEffects": [ "<effects tags here>", "<effects>", ... ]​
"formulas": {​
"mpCost": "<cost formula>",​
"tpCost": "<cost formula>",​
"tpGain": "<gain formula>",​
"xp": "<xp formula>"​
"levels": [​
"mpCost": <cost>,​
"tpCost": <cost>,​
"tpGain": <gain>,​
"damage": "<damage formula>",​
"req": "<requirement, if any>",​
"description": "<skill description>",​
"dmgMods": [ "<damage modifier tags here", "<dmgMods>", ... ],​
"customEffects": [ "<effects tags here>", "<effects>", ... ]​
"mpCost": <cost>,​
"id": <skill id>,​

"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:

"mpCost": 100​
"tpCost": 10​

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:

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;​

DAMAGE MOD: <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;​
- EVAL <expression>: Applies an eval to <expression> to append a clause to the damage formula results;​
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;
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;
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).​
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;
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.​
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(), ...).​
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))​
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.​
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.​

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]>


S[1], L[1]
S[2], L[2], X[11]

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

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


S[1], L[1,3], X[0,5]

"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)
Based on a skill ID and level, returns the skill MP cost. If level is omitted, returns the cost for the skill's first level.

$gameSystem.getSkillTpCost(skillId, level)
Based on a skill ID and level, returns the skill TP cost. If level is omitted, returns the cost for the skill's first level.

$gameSystem.getSkillTpGain(skillId, level)
Based on a skill ID and level, returns the skill base TP gain. If level is omitted, returns the base gain for the skill's first level.

$gameSystem.getSkillDescription(skillId, level)
Based on a skill ID and level, returns the skill's description. If level is omitted, returns the description for the skill's first level.

$gameSystem.getDamageFormula(skillId, level)
Based on a skill ID and level, returns the skill's damage formula as text. If level is omitted, returns de formula for the skill's first level.

$gameSystem.actorMeetsRequirements(skillId, level, actorId)
Checks if the actor meets the specific requirements to the referenced skill at the specified level. If level is undefined or out of the allowed level range, returns analysis for the skill's first level.

Based on a skill ID, returns the XP type for the skill: 1 for skill uses, 2 for battles won and 3 for battles survived.

$gameSystem.getSkillLevel(skillId, actorId)
Based on the skill and actor IDs, returns the skill level. If the actor doesn't know the skill, returns 0.

$gameSystem.learnSkill(actorId, skillId, customLevel, customXp)
Teaches an actor the referenced skill. You can use parameters customLevel and customXp to start the skill at a specific level, and/or halfway to the next level. These two can be ignored if you wish the actor to learn the skill at its initial level and with no previous experience.

$gameSystem.getSkillProgression(actorId, skillId)
Returns a number between 0 and 1, where 1 means the next level has been achieved (or the maximum level has been reached).

$gameSystem.isSkillKnown(actorId, skillId)
Returns true if the actor knows the skill, or false if he doesn't.

$gameSystem.hasSkill(actorId, skillId, skillLevel)
Return true if actor has skill with level greater or equal to skillLevel. If skillLevel is omitted, return true if has skill with level greater or equal to minimum level.

$gameSystem.getCurrentSkillXp(actorId, skillId)
Returns the current XP for the skill.

$gameSystem.getSkillXpToNextLevel(actorId, skillId)
Returns how much XP the actor must gain to reach the next skill level.

$gameSystem.getSkillUses(actorId, skillId)
Returns the number of times the skill has been used by the actor.

$gameSystem.gainSkillXp(actorId, skillId, xp)
Adds the specified amount of XP to actor skill.

$gameSystem.setSkillLevel(actorId, skillId, level)
Set skill level for actor capped at the maximum allowed value.

SKM learnSkill <actorId> <skillId> <level>
Teach skill referenced by skillId to actor. The third parameter defines at which level the skill will be learned. If the level parameter is left blank, the skill will be learned at the initial level.

SKM learnMultiSkill <actorId> <skillId_1> <skillId_2> ... <skillId_N>
Teaches a number of specified skills to actor at the initial level.

SKM gainXp <actorId> <skillId> <xpAmount>
Increases skill XP for actor (as long as requirements for the next level are met).

SKM setLevel <actorId> <skillId> <level>
Set skill level to a specified value, capped inside the minimum and maximum range.

  • Obviously this plugin is not compatible with any other that provide skill levels. If the plugin do not customize skill structure, it should be compatible. But at least for now I cannot garantee plugin compatibility.
  • Version 1.0.1:
    • Included new custom effects:
      • EVAL clause;
      • Setting variables with eval clauses;
      • Setting switches with eval clauses;
    • Included the option to use intervals for level and xp note tags;
  • Version 1.0.0: Initial release!
Last edited:


Aug 3, 2012
Reaction score
First Language
Primarily Uses
@taaspider You might like to edit your terms of use to indicate if people can repost the plugin or if they must link back to this thread. I know a lot of plugin writers don't want people to repost as it means there could be out of date versions floating around the internet.


Jan 27, 2017
Reaction score
First Language
Primarily Uses
Thanks for the tip @Kes !
And you're right, I prefer people always link back here and don't repost it anywhere (I've added that to the terms of use).

Users Who Are Viewing This Thread (Users: 0, Guests: 1)

Latest Threads

Latest Profile Posts

Yaaay! My second public script is out and approved! A VX Ace Final Fantasy IX styled Throw Script!

I look forward to all the constructive feedback I get but most importantly I hope everyone who ends up using it enjoys!

Yaaaay! Making scripts is fun lol. :D
When you're lost out therrrrre and you're alllll alone, ahwahwah waitin, to carry you hooooommmme, uhhheverywhere you look! (someone hit me with those backing vocals)
X.X cant focus... too many thing want do... help!
Day 2 of teaching MV, student can move cat across the map.
Got inspired and started writing a simple tower defence battle system last night :o

Forum statistics

Latest member