Open your project and add in the new SRPG Maker plugins in this order;
1. SRPF-core.js
2. SRPG_AoE.js
3. SRPG_RangeControl.js
4. SRPG_PositionEffects.js
5. SRPG_AIControl.js
6. SRPG_MoveMethod.js
7. SRPG_BattlePrepare.js
8. SRPG_BattleUI.js
9. DisplayHPonMap.js
10. SRPG_AuraSkill.js
11. SRPG_Summon.js
12. SRPG_ShowPath.js
13. SRPG_UX_Cursor.js
14. SRPG_UX_Windows.js
15. SRPG_MouseOperation.js

Place at the bottom of your game’s Plugin List.

Technically speaking, you only really need the first three, but the other just add more options to make your game play and look better so there is no reason not to add them!

We also need the following picture files from the provided “img” folder;

1. From the “characters” folder;
a. !srpg_set-type1.png
b. !srpg_set-type2.png
c. srpg_set-type1.png

2. From “pictures”;
a. EnemyTurn.png
b. PlayerTurn.png

3. From “system”;
a. srpgPath.png

We can customise these later on. For now, we need to put each into the corresponding folder of your project (put characters into characters, etc.). These files can be obtained from the “SampleGame\img\...” if not readily available. These will create the various selectors and icons needed to make the SRPG engine work.

With these PNGS now in our new project folder, we need to link them to the game engine.

1. Inside your game project, open the Plugins tab (green puzzle piece icon on the top taskbar).
2. Go into the SRPG_core.
3. Under “Parameters”, scroll down the list to find the “SRPG Files” section, and in srpgSet, enter the location of “!srpg_set_type1 OR 2” (whichever you prefer).
4. Go into the “SRPG_ShowPath” plugin, and in “Path Image”, enter location of “srpgPath.png”.
5. Apply and Save your project.

First thing we need is to do is set up some switches and variables, and link them to the SRPG Engine.

You don’t need to put these in order but it’ll help, the switches we need to create are;
• “Battle Start”
• “Map Battle”

And the variables we need to create are;
• “Number of Actors Present”
• “Number of Enemies Present”
• “Number of Elapsed turns”
• “Active Event ID”
• “Target Event ID”
• “Distance from opponent”

With these created, we need to link them to the game engine.
1. First things first, we need to go into the “Troops database (gear symbol on the task bar).
2. Create a blank “troop” and name it “For SRPG Gear” – this is a simple reference the SRPG engine will use to set up a battle. Make sure to leave it blank, as the SRPG engine will fill in the details.
3. Open the Plugins tab (green puzzle piece icon on the top taskbar).
4. Open up the SRPG_core plugin.
5. On the side menu, under “BasicParam” – make sure “srpgTroopId” is set to the id number of our created troop event.
6. Under this, find the “srpgBattleSwitchID”, which is set to a default of “1”. Link this to the “Battle Start” switch we made.
7. Below it, link the “existActorVarID” to our “Number of Actors Present” variable, and the “existEnemyVarID” to “Number of Enemies Present” variable.
8. Below that, we link “turnVarID” to the “Number of Turns Elapsed” variable.
9. Link the “activeEventID” to the “Active Event ID” variable, and “targetEventID” to the “Target Event ID” variable.
10. Link the “battleDistanceID” to the “Distance from opponent” variable.
11. Below this will be “Map Battle Switch” – link this to your created “Map Battle” Switch ID number.

Now the SRPG engine is linked to the variables and switches in the game, and most importantly, we get it out of the way now so that we don’t need to set this all up later.

You can also take the time to go through your core plugin and set the parameters, although you can return to this at any time.

Then, we create two maps – one for exploration, and one for battling.

In the exploration map, we need to make an event (a character usually) which will start the fight when the player interacts with them/it. Then we set up the following;
1. Fadeout screen.
2. Transfer the player to the Battle map (aim for the spot the player will be on the battle map). Always transport to a battle map before using the next step!
3. Plugin Command: SRPGBattle Start
4. Note: if we want to skip the “Preparation stage” we can use the plugin command: DisableSRPGPrepare
Don’t forget to turn it back on with: EnableSRPGPrepare
If you use this and keep getting a black screen during the fight, don’t forget to set up the Battle Back on the battlemap settings!


On the battle map, first thing we need is a brand new event. Put this out of the way somewhere, top left corner is fine.

1. Name this event as “Battle Start”. This will be the information displayed before the fight starts (and only happens once per battle obviously). We can use this to inform the player of victory conditions or even have the characters talk/story beats happen. Remember, we aren’t using the “Troops tab” which would be the normal use.
2. In the Note section of the Battle Start event, add in: <type:battleStart>
This informs the SRPG engine that this is the “pre battle” event and must play first.
3. Create a BGM for the battle music. (Play BGM)
4. Use the option “Change the Battle BGM”, and match it to the music you just selected. Otherwise, the game will use whatever Music settings you use in the Battle Map’s setting/game system settings/last fight when using the Side View Battlers option, and jump back and forth between the two.
5. Fade-in Screen
6. Optional! Set the control variable “Number of Actors Present” to 0.
This way, when you add party members to the battle map, the count will go up for each member added.
Do the same for “Number of Enemies Present” variable, and the “Number of Turns Elapsed” and set both at 0.
8. We then can show the victory conditions.
9. If we have custom victory conditions, such as “collect x amount of herbs”, be sure to include a new variable that tracks whatever custom victory condition you make and set it to 0. (More on this later).
10. We then want to add some basic scripting;
$gameSystem.clearSrpgWinLoseCondition();
$gameSystem.setSrpgWinCondition('WRITE VICTORY CONDITION HERE');
$gameSystem.setSrpgLoseCondition('WRITE DEFEAT CONDITION HERE’);

You can probably guess but these also tell the SRPG engine what the victory and loss, as well as allowing the plugin to update as the battle goes along.
The first line clears the old Victory and Loss data, so the game can now “concentrate” on the upcoming fight. We include this even if we haven’t set up a fight before.
Line 2 is the victory condition, where we can write in exactly what the player needs to do.
Line 3 is the defeat condition.

11. Make sure to write both within the brackets “()” and within the apostrophes ‘ ‘. We can also add “quotation marks” if we are looking for a named item or character as part of the victory or defeat, but keep these within both the brackets and apostrophise. E.g.;
$gameSystem.setSrpgWinCondition('Collect 5 “Herbs”’)

12. We can also add optional Character conversation if needed. Again, just text boxes, nothing fancy needed.
13. Keep the trigger as “Action Button”, in fact keep all default settings for the event as they are ignored by the engine thanks to step 2.
14. NOTE: don’t forget that any switches or variables associated with the current battlemap should be set to 0 or off, or whatever is related to your current victory/defeat scenario.


Still on the battle map, create a second event next to the Battle Start. Do not use the same event as Battle Start, we need to create a new one!
1. Name this new event as “Actor Turn Start”.
2. In the notes section add in: <type:actorTurn>
This informs the SRPG engine that this is the start of the player’s turn.
3. We then create a common event called “Actor Turn Start”.
4. In this common event, we want to show that it’s the player’s turn, so we show the “PlayerTurn.png”.
5. It never hurts to be flashy and make the picture “move” onto the screen and then off using the “Move Picture” command.
6. Delete the picture when done moving or after a set amount of time (Wait: 60 frames).
7. Back to the battle map and “Actor Turn Start” event; we now call upon the common event we just created.
8. Again, keep all event settings the same.


Create a third blank event on the battle map next to Actor Turn start, and name this one “Enemy Turn Start”. This will be exactly the same as the above but for the enemy.
1. In the notes section add in : <type:enemyTurn>
2. Create and use a common event like the above but this time called “Enemy Turn Start”, using the “EnemyTurn.png”


We need a fourth blank event on the battle map – remember not to add “New Event Pages” we want a separate event for each of these.
1. Call this fourth event “Turn End”.
2. We then add in the note: <type:turnEnd>
This tells the SRPG engine to play this when the turn is now over.
3. We can use this event if we wish to place in something to happen after X turns, like a conversation, or even victory/defeat conditions (if you’re on a “survive x-rounds” type mission), etc.
4. Otherwise, leave blank.


Create a fifth event, and name it “Process Before”.
1. Add in the note: <type:beforeBattle>
2. This can be used for extended conversations or scenes before battle.


Finally we need to create a sixth blank event, which will keep track of the battle itself as each unit finishes their turn, specifically tracking the victory and defeat conditions, but can be used for other events too.
1. Name this “Process After Unit Action”.
2. Add in the note: <type:afterAction>
This is designed to check after each unit takes an action to see if the victory/defeat conditions are completed.
3. we check the “Switch” options under Conditions, and also link it to the “Battle Start” switch.
This will make sure that the SRPG engine is constantly checking this event page rather than once like the other events we have made.
4. Now we set up the victory and defeat conditions.

Let’s check the defeat conditions, firstly with the most simple defeat condition – having all players defeated (which should be on all of the fights by the by).

1. In the “Progress After Unit Action” event, create a “Conditional Branch” and link it to the “Active Player Count” variable, making sure the condition is:
≤ Constant 0
This will make sure the below only activates when the Player count is less than or equal to zero – as in no players remaining.
2. Play a defeat sound effect, and show a message saying “All players have been defeated” or whatever is relevant to your game.
3. Fadeout the BGM
4. Fadeout the screen
5. Plugin command: SRPGBattle End
6. Then teleport your player back to the exploration map or wherever you need them to go, and Fade in.
Note: This is assuming you don’t want an instant game over at defeat, otherwise just add in the GAME OVER event.


If we want the players to lose after a certain number of rounds have passed;
1. Go into the “Turn End” event on the battle map (the fourth we created).
2. Create a Conditional Branch
3. Variable: Number of Elapsed Turns, and check for
> Constant X
(change X to the number of turns passed).
Note: SRPG Maker counts 0 as a number so if you want the event to happen on turn 5, you need to set the condition for 6!

4. Play defeat music, use text box to inform the player of the loss.
5. Fadeout the BGM
6. Fadeout the screen
7. Plugin command: SRPGBattle End
8. Then teleport your player back to the exploration map
9. Don’t forget to inform the player of the “time limit” in the victory conditions (“Battle Start” event on battle map)


If we want players to lose when a certain party member is defeated (protection missions);
1. Create a switch and name it “This Character is Dead”
2. Go to the “Process after Unit Action” Event.
3. Create a “Script” (In “Advanced” tab on page 3) – we will go into Script writing and functions later.
4. In the script write the following;
this.isUnitDead(X, Y)
5. The above is a basic script call that will check to see if a certain event has no HP left (added in by the functions of the SRPG engine).
“X” is the “switch ID”, which we want to put the number associated with the switch we just made (e.g.: “This Character is Dead” is switch #015, so we so we change X to 15: this.isUnitDead(15, Y)

6. Next we want to change Y to the specific event ID showing the character on the battlemap. We will go more into setting up the actual combatants later, but each will need an event created to represent them.
For example, the six blank events we have created on the battle map already are obviously numbered 1-6, so our first character created would be Event #7.
We create the “team” before the enemies, which in this example will be events #7, #8, and #9 – a three person squad. We want to ensure that #8 doesn’t die.

So we change Y to Event ID Number 8: this.isUnitDead(15, 8)
Now every turn the game will be checking to see if Event Number 8 is still alive, and if not, will turn the switch “on”.

7. Create a Conditional Branch
8. This time we link to the switch we just created;
Switch: This Character is Dead
9. Have Text of the defeated character saying “oh no!” or whatever is relevant.
10. Play defeat music, use text box to inform the player of the loss.
11. Fadeout the BGM
12. Fadeout the screen
13. Plugin command: SRPGBattle End
14. Then teleport your player back to the exploration map
15. Don’t forget to inform the player of the protection mission in the victory conditions (“Battle Start” event on battle map)


Those are three highly customisable defeat conditions, and wouldn’t you know it, the victory conditions are basically the same, but reversed;


Check and see if all enemies are dead (although, I believe that this is automatically applied to fights, as once all the enemies are dead what’s the point of continuing, but it’s good to know anyway);
1. Create a “Conditional Branch” and link it to the “Active Enemy Count” variable, making sure the condition is:
≤ Constant 0
2. Play a victory sound effect, and show a message saying “Huzzah we win!” or whatever is relevant to your game.
3. Fadeout the BGM
4. Fadeout the screen
5. Plugin command: SRPGBattle End
6. Then teleport your player back to the exploration map or wherever you need them to go, and Fade in.


If we want the players to win after a certain number of rounds have passed;
1. Go into the “Turn End” event on the battle map (the fourth we created).
2. Create a Conditional Branch
3. Variable: Number of Elapsed Turns, and check for
> Constant X
(change X to the number of turns passed).
4. Play victory music, “huzzah, we survived!”
5. Fadeout the BGM
6. Fadeout the screen
7. Plugin command: SRPGBattle End
8. Then teleport your player back to the exploration map
9. Don’t forget to inform the player of the “time limit” in the victory conditions (“Battle Start” event on battle map)


If we want players to win when a certain character is dead (such as a boss with lots of minions).
1. Create a switch and name it “This Character is Dead” – we can use this switch over and over again.
2. Go to the “Process after Unit Action” Event.
3. Create a “Script” (In “Advanced” tab on page 3) – we will go into Script writing and functions later.
4. In the script write the following;
this.isUnitDead(X, Y)
5. Remember “X” is the “switch ID”, which we want to put the number associated with the switch we just made (e.g.: “This Character is Dead” is switch #015, so we put: this.isUnitDead(15, Y)
Change Y to the unit on the battle map we want killed.
6. Create a Conditional Branch
7. This time we link to the switch we just created;
Switch: This Character is Dead
8. Have Text of the defeated character saying “oh no!” or whatever is relevant.
9. Play victory music, use text box to inform the player that all the goons gave up and ran away.
10. Fadeout the BGM
11. Fadeout the screen
12. Plugin command: SRPGBattle End
13. Then teleport your player back to the exploration map
14. Don’t forget to inform the player of the mission objectives in the victory conditions (“Battle Start” event on battle map)


We can also make “capture the flag”-style objectives. For example, say the player needs to find five herbs.
1. Create a Variable, e.g. “Herbs found”
2. Go to the “Battle Start” Event, and add the variable in, setting it to 0.
3. On the map, we will create an event that reacts whenever an player touches it (see below).
4. Then, we go into the “Process after Unit Action” event.
Add a Conditional Branch and check for the “Herbs found” Variable. Set the condition to however many herbs there are (e.g. ≥ Constant 3)
5. Play victory music, and get the player out of there!
6. Fadeout the BGM
7. Fadeout the screen
8. Plugin command: SRPGBattle End
9. Then teleport your player back to the exploration map
Be aware that the enemies cannot activate battle map events!

We do this to keep our battles interesting as well as to keep player’s attention, as just killing everything over and over would get boring.

Don’t forget, after each battle ends, we need to call upon the Plugin Command: SRPGBattle End – otherwise the game will still think the battle is going and crash!!!

Also, a fun note, remember that you can still use the default Pokémon style-battle system, though certain things like objectives won’t be anything more than “kill ‘em all” obviously.

We can also take some of these victory/defeat conditions and make it so that the consequences don’t end the battle. First thing we need is a bit of scripting magic.
1. Go to the Battle Start Event.
2. Use the following Script;
this.mapSelfSwitchesControl('D', 'off');
3. This will turn off all of the “Self-Switch D” of the units on the map. We will use this to affect certain elements in our side objectives. Naturally, we can change D to A, B, or C – but D is a good one to set as it is the last and won’t interfere with any other events we make.
Add this near the top of the event for best results!


Waiting X number of turns before a reinforcement turns up.
1. Create a blank event on the battle map and name it “Harold (Reinforcement).” No tags required, but remember the ID number of the event.
2. Leave the rest of the event blank apart from the speed which will be the sprite’s movement speed of the reinforcement.
3. Go into the “Turn End” battle event.
4. Create a Conditional branch for the “Number of Elapsed Turns” variable, and after 5 turns, have the following happen.
5. Have a text box appearing announcing that something is happening, so the player knows.
6. Set up the following script
this.addActor(eventId, actorId); OR this.addEnemy(eventId, enemyId);

Actor adds in a new party member (don’t add someone who is already on the field or the game will glitch after the battle!), and enemy adds in a new enemy. Make sure to link the eventID to that of our blank event we created in step 1, as this is where the character will appear, and then the actor/enemy ID to the right number in the actor/ enemy database for the correct character stats/abilities.

7. Add a script: this.playerMoveTo(X, Y);
This is a simple “camera movement” script, which will jump to a set location on the map using the X and Y coordinates. When you select anything on the battle map in the editor, on the bottom right of the screen there is the information!
8. Add another text box to introduce or have a character reaction.



Now we apply the same idea to draw the Boss out of hiding by killing 3 “officers”;
1. Go to the “Process after Unit Action” Event.
2. Create a Conditional Branch that searches for “Self Switch D is Off”.
3. Create the Script for this.isUnitDead(X, Y)

Link this to the “This Character is Dead” switch and the first officer’s event ID number. We also want to place this officer closer to the Player’s starting position.

4. Right under this, create ANOTHER Conditional branch (within the above), but this time searching for “Switch: This Character is Dead is On”.
5. Create the Script for this.isUnitDead(X, Y) within our newest Conditional branch, and link this to the “This Character is Dead” switch and the second officer’s event ID.
6. And for a third time, create the above, another conditional branch within the one we just created for step 4, with a script: this.isUnitDead(X, Y)
7. You guessed it, we’re linking it to the “This Character is Dead” Switch, and the third Officer’s event ID.
8. We do this for however many officers we need the player to defeat before the boss will show up – so keep it low, don’t want 30 of these! You can, but it will be easier to write the script for less.
9. Finally, we add another Conditional Branch, this time checking if “This Character is Dead” is on.
10. Within this final conditional branch, we want to add a “Fadeout BGM” and set it to 1 second. This will stop the music and so we can then play the boss theme.
11. Add a wait: 60 Frames
12. Add a script: this.playerMoveTo(X, Y);
13. Play a sound effect/ the Boss Theme.
14. Have an optional text box with character reaction.
15. Set up the following script
this.addEnemy(eventId, enemyId);

The Script will add the enemy, but we need to add in the Event Id, and the Enemy Id (from the enemy database within the game).
We can also extend this script to add multiple enemies, if the boss has some backup/ bodyguards.
this.addEnemy(20, 3);
this.addEnemy(21, 2);
this.addEnemy(22, 2);

So in this example, the Boss will be Enemy Id number 3, and he has two underlings with him, both being Enemy ID Number 2

16. Finally, add in “Control Self Switch D is On” – to stop the event from repeating itself indefinably.
17. The whole thing will look something like this;













Reminder that the switch “This Character is Dead” is repeatable, so long as it is following a Script call, as the Script limits it to a specific event ID. This is why multiple characters can use it per battle map.



Using the above victory and defeats, we can add other effects using the script functions;
this.unitGainHp(eventId, value, allowDeath); Recovers health. Replace Event Id with the event’s id number that is going to heal, Value with the amount it is going to heal, and then replace allow death with true or false to allow them to be defeated.

this.unitGainMp(eventId, value); Same as the above, but for regaining MP
this.unitGainTp(eventId, value); Same as the above, but for regaining TP

this.unitRecoverAll(eventId); Fully recovers the unit linked to the Event ID Number

this.unitAddState(eventId, stateId); Adds a state to the unit, replace stateID with the State’s ID number from the database.

this.unitRemoveState(eventId, stateId); The opposite to the above.

this.unitRevive(eventId); Revives the unit linked to the event ID.

this.addActor(eventId, actorId); Makes the event ID number linked to this spawn in as the selected actor (replaced actorID with the Actor’s Id number from the Actor database).


We can also change/update the Victory and Defeat conditions anytime during battle.
1. Open up the Actor Turn Start Event – Or the Enemy Turn Start event, depending on what your battle has going on.
2. Set a conditional Branch based on your current victory/defeat conditions.
3. Instead of ending the fight, have a text box/ scene displaying what is going on – usually a new enemy appears.
4. Then when the scene is done, have a text box with the updated victory conditions.
5. Use a Script command:
$gameSystem.clearSrpgWinLoseCondition();
$gameSystem.setSrpgWinCondition(‘New Win Condition!');
$gameSystem.setSrpgLoseCondition('New Defeat Condition!');

Now that the battle map is all set up - and yes, we DO have to do all the above for each battle map, deal with it – we need to add in the actors, enemies, and even objects.


Let’s start with adding in the Actors, the player team.
1. First create a new event where you want the player to spawn.
2. Select a sprite, though this will be replaced on the battlemap in-game, so I recommend Actor 1, Sprite 1 for all your “players”.
3. Name this event “Actor 1” and in the Note section add, <type:actor><id:1>
This tells the SRPG engine that this event will be an Actor, and is Number 1 on the Actor Database.
4. Note that naming the actor events this way will make them “Key” actors, meaning this event spot will ALWAYS be taken by the first Actor in the database.
If we name them as Actor 2 and ID 2, it will be the second actor in the database always appearing there.
5. Make sure that you set the “Speed” and the “Frequency” of the event as x2 faster/normal, so it moves normally on the battlemap.
6. Make as many Events for actors as you like, I think the cap is 10 but I’m not certain.
7. For additional fun, name the event as Actor 0, and ID as 0, this will allow the player to pick which of their team enters the battle and in what position! If you have more “free spaces” than actors in the party, the player will be able to select wherever they like for combat!


Next we add in the enemies.
1. Again, create a blank event.
It is best to keep a note within the Event itself as a textbox or even a comment on the event’s ID number, just to keep track of who is who. For reference there’s a literal identifier tag in the top left when opening any event, in case you missed it.
2. Name it as whatever enemy it is and pick another random sprite – remember this will be changed in-game.
With the enemies, as we can have multiple of the same, it is a good idea to keep the sprites for each all of the same TYPE of enemy the same and then switch for each different type, for example, all the “bats” should look the same, whereas all the “slimes” should be a different sprite.
Again, this is just for our reference as players will only see the actual sprite linked to the event.
3. After you’ve sorted out what enemy it is, add in <type:enemy><id:X> to let the SRPG engine know.
4. Then we need to set the enemy’s AI behaviour;

<mode:normal> - Will move towards the nearest opponent (this is the default behaviour and will be used if nothing is typed).
<mode:stand> - Will stand and do nothing until attacked or “notices” an opponent (comes into range).
<mode:aimingActor> - Will aim for a specific Actor.
<mode:random> - allows random movement until an opponent comes into range.
<mode:avoidOpponents> - Will run away until an actor comes into its attacking distance.
<mode:mostOpponents> - Moves to the centre of the enemy group until attacking distance is reached. (good for suicide bomb type enemies)
<mode:regionUp> - will move up the screen until an enemy comes into attacking range.
<mode:regionDown> - will move down the screen until an enemy comes into attacking range.

5. You can copy and paste enemies to help fill up the battle map faster, but keep aware of the Event IDs!!!



Objects can be placed on the battlemap, such as obstacles.
1. In that case, we create a blank event, and in the notes we put: <type:object>
2. The Sprite does matter here, so pick an appropriate one. This can be a rock or a tree or whatever.
You can add them normally via the map editor, this method is for if you want say, an avalanche to appear after turn X or something, then it will spawn this object.
3. Make sure that the “Priority” is the same as characters, else people will step through it.



We can also create events that can be interacted with during battle.

The first is a simple, “click on me” style event, helpful for tutorials and information, as well as giving the player an option to exit the battle!
1. Create a new Blank Event, and name it “Player Event”
2. In the notes, we add;
<type:playerEvent>
This means that only the player can interact with it, and only with their selector/mouse, so giving them a heads up would be a good idea (before the battle have a character say “click on me if you need assistance!” etc.).
3. Then we can open up the text boxes to start the conversation.
4. If you give the player the ability to leave the battle via this “helpful character”, make sure to include the plugin command SRPGBattle End!



Next up, we want to add in things that units themselves can interact with on the battlemap, by stepping on them!
1. Create a blank event, and name it “Unit Event”. In the notes add in: <type:unitEvent>
2. For this example, we’re going to give the player an Herb when they step on the event. Pick a sprite that will show the player that there is something here, a sparkle etc. Then in the options (bottom left) untick Walking, and tick Stepping and Direction fix. This will make it animate to catch the player’s attention.
3. Also, make sure that “Priority” is set to “Below Characters”.
4. When the Player steps on the event, we want to move the camera to the unit itself:
this.playerMoveToEvent(X);
Change X to the Event ID we want to see, or just use “0” for “This Event”.
5. Then we want to have a text box to inform the player they have acquired an item.
6. If this is part of the Victory conditions, make sure to update the linked variable by 1.
7. Then add a Control Self Switch: D = On
8. Create a “New Event Page” at the top of this Event. This will create a blank event on page 2.
9. Tick the Self Switch on the left and set it to D – leaving the rest of the event page blank
This will make it so that after a player has activated the event, it will disappear – as far as the player knows anyway.


This can also be used for treasure on the battle map.
1. Create a blank event with a treasure chest as its sprite. Have only “Direction Fix” ticked in the options.
2. Have a text box appear that says something along the lines of “It’s locked a character needs to open it!”
This is just to stop the player opening it with their mouse during the pre-battle phase!
3. At the top of the event, click “Copy Event Page, and then Paste Event Page, giving you a duplicate on “page 2”.
4. Switch over to phase 2 and delete the “Contents” so it is a blank Event Page with just the treasure chest sprite.
5. Make sure under “Conditions” the switch SPRGBattle Start is linked.
6. Then make sure that “Priority” is changed to “Below characters”. This will allow players to “walk” over the treasure.
7. Enter a Script command: this.playerMoveToEvent(0);
This will snap the camera to the treasure chest when it is being opened.
8. Play a SFX for the chest opening.
9. You can set up a movement route to animate the chest opening.
10. Give the players whatever item is inside, and inform them via textbox.
11. Add “Control Self Switch: A = On”. Make sure it is any Self Switch BUT “D” as Self SwitchD will always be reset when the map is replayed, but we don’t want to keep giving out treasure.
12. Create a “New Event Page” (this will be number 3) now with the sprite changed to an open chest.
13. Put the priority back to “Same as Characters”, and under Conditions, tick the “Self Switch” and set it to A.
This will make the chest appear opened every time the player returns to the map.
14. Copy this event page and paste it to create the fourth and final page.
15. Put the priority back to “Below Characters”, and also link the “SRPGBattle Start” switch in the Conditions. Make sure that “Self Switch A” is still ticked.
This will allow players to walk over the treasure chest so it doesn’t block them but not give any treasure!

The above can also be used for switches and help with custom victory conditions!

Now that we have created the battle map, and added in all the events, we finally need to set up the databases that each event links to, namely the Actors, Enemies, and the items.

1. Open up the Actor database (gear symbol).
2. In the Note section for your actor, add in:
<srpgReactionSkill:1>
This will give the character a chance to counterattack whenever they are hit (based on agility) – with X being the Skill ID we want the character to use. Generally, 1 (the default “Attack”) is the best option, but we can set up anything, such as a basic attack with an electrical animation for a wizard just to distinguish the character, as an example. Set to 0 if you want no counter attack for the character.
3. We can also add unique skills to characters as a “quick select move”, appearing right under the “Attack” option rather than separating into the usual categories in combat. This is just for player convenience and is showing off but looks good.
4. Say we have a Magic character that can only recharge MP via a move. We create a skill called “Recharge Magic”. Assume the Skill Id is 041.
5. On our magic character, we add: <srpgActorCommandOriginalId:41>
This gives the Magical Character the recharge Magic ability as one of their skills under Attack, rather than having to go into Skills>Magic>Select Skill (in battle)
6. We can also define what skills the character has access to using: <srpgActorCommandList:X>
We can change “X” for attack, skill, item, equip, wait, original (separated by “,” but NO SPACES!)
This allows us to customise character’s attacking options. For example, if a character is holding a gun and has no melee attack, we simply remove “attack” from <srpgActorCommandList:skill,item,equip,wait,>
this means the actor will have to be stay at range!
7. Again, just showing off really – most actors only need Step 2.

Into Classes, we get to set up how far a player character can move;

1. Go into notes and add: <srpgMove:X>
2. Change X to the number of tiles you want a character to be able to move. Recommended is 4 for “average”, then slower characters can have less, faster characters can have more.

Now we set the tags for the Skills;
1. Click on the basic Attack Skill (0001).
2. In the notes, enter: <srpgRange:-1>
<specialRange:weapon>
This will set the range of the basic attack to be “less than 0”, and instead to default to the “weapon’s range”. As characters can equip different weapons with different ranges, we want the basic attack to reflect this, for example a spear will have longer reach than a sword – and this will be reflected in the character’s basic attack.
3. Please note that “Guard” doesn’t work with the SRPG engine!


We can now set up the range of other skills.
1. In the notes of a skill, put: <srpgRange:X>
2. We change the X to the number of tiles this has a “range of”. Remember, if we want to default range to be that of a weapon being used, create a -1.
3. If we want the skill to target itself (the person casting), then change X to 0. This is for healing, or self-power boosts, etc.
Ideally, the further an attack can go, the more MP it should cost, to balance it.
4. We can also put a “minimum range”: <srpgMinRange:X>
This would be used to stop spells or throwing weapons being used at close range, or AOE attacks hitting the user.
5. Then we need to add the special range. This dictates the shape of the attacking area.
In the Notes, put: <specialRange:X>
6. We can change X to weapon to reflect the weapon’s properties as before, or we have other options;
a. queen : the attack can be launched in all 8 directions
b. rook : the attack can only be straight of the user
c. bishop : the attack can only be diagonally from the user
d. knight : The attack can only be two ahead and one across (like how a Knight on a chessboard moves)
e. king : the attack can be launched in a square around the user
f. allActor : hits all actors on the map
g. allEnemy : hits all enemies on the map

7. Add in: <mapBattle:true>
If you want that the skill to only be used on the SRPG battlemap – and not in the standard battle view.
8. <notUseAfterMove>
This will make a skill unusable if the player moves first!
9. <addActionTimes: X>
On the other hand this will allow the user to have extra moves (based on X) before their turn is over!
10. <doubleAction:false>
Will stop attacks landing more than once (useful for spells/overpowered skill balancing)
11. <srpgVariableRange>
This will allow the skill’s range to be affected by srpgRangePlus tags if an armour or weapon has them, increasing the overall range!
12. We can also add area of effect to attacks! Not recommended for Enemy attacks as it confuses AI.
<srpgAreaRange:x> (creates an AoE of size x)
<srpgAreaMinRange:x> (adjusts the minimum AoE size, creating a hole in the middle)
<srpgAreaTargets:x> (set the maximum number of targets the skill can hit)
<srpgAreaType:y> (changes the shape of the AoE – change Y to circle, square, line, cone, split (diagonal), arc, side (either side of user), Tee (a t shape), plus (a plus shape), cross (a X shape), star, checker)
Defaults to circle if nothing written.
13. <srpgAreaType:allEnemy>
This will hit all the enemies in the target area. Change to “Allies” for the same result for party members.
14. <srpgUncounterable>
Gives us an attack that can’t be countered. Useful for ranged.



Now we have our ranges, we can also add movement effects to really heavy attacks. Again, not needed, just makes the game play better!
1. In the formula box, before we put the damage we can add;
a.push(b, distance, type)

This pushes b (the defender) away from a (the attacker), by whatever number distance is replaced by. Recommend keeping it low to avoid the game stuttering.
Type can be set to "normal" (stepping backwards), "jump" (a jump animation), or "instant" (no animation) and defaults to "normal" if not specified!

a.pull(b, distance, type) pulls the defender TOWARDS the attacker.
a.pushRight(b, distance, type) moves b right (clockwise) around a
a.pushLeft(b, distance, type) moves b left (counter-clockwise) around a
a.forward(distance, type) moves a in the direction they're facing
a.back(distance, type) moves a in the opposite direction they're facing
a.pushAoE(b, distance, type) pushes b away from the centre of the AoE!
a.pullAoE(b, distance, type) pulls b toward the centre of the AoE!
a.pushRightAoE(b, distance, type) moves b clockwise around the centre of the AoE
a.pushLeftAoE(b, distance, type) moves b counter-clockwise around the centre of the AoE
a.approach(b, type) moves a to the open space nearest to b (best for linear-only effects)

2. Example damage formulas:
a.push(b, 1); a.atk - b.def
This will push the target 1 space and deal damage

3. a.forward(5) + a.atk - b.def
This will move the user up to 5 spaces forward. If they hit an obstacle (probably the target) before moving all five spaces, they deal an additional 1 damage per remaining space.

4. And of course, if we have a big guy that can’t be pushed about, add this into the Note section of an actor/enemy: <srpgImmovable>
This makes the character in question unable to be moved by an attack, but will not affect their own movements around the battlefield.

These formulas go IN FRONT of the damage (if there is additional damage), and are separated by a “;”.

Make sure not to go too crazy with these skill attributes, but also inform the players of what skills do what range/affects using the Description box!

We can also use these for offensive one time use items, such as bombs or throwing weapons!

Speaking of weapons;
1. Make sure all of your weapons have a Note tag with <weaponRange:1>
2. This allows the player to have weapons that can actually hit, as well as increasing this to give players more choice in their favourite weapon beyond pure damage.
3. We can also give the weapons benefits to the player when it is equipped with : <srpgMovePlus:1>
This gives +1 to the character who equips the weapon’s movement range.

4. Or attach a skill to the weapon instead of the basic attack: <srpgWeaponSkill:X>
5. We can also add <srpgReactionSkill:X>
This will link a Skill to the weapon, allowing for a unique counterattack. This will overwrite the Character’s own tag, so we only want to use this if the weapon gives a counterattack that isn’t the basic attack (such as a fire based counterattack, etc.). Setting this to 0 will make it so the character can’t counterattack, even if the character has it set up, as the weapon overwrites the character!

6. We can also add in a tag to change the attack shape of the weapon: <specialRange:X>
Again, this overwrites the Character’s own.
And even give the weapon a minimum range – if it a thrown for example: <weaponMinRange:X>
Make sure to combine either (or both) with the tag to tell how far the weapon range is or they won’t work.


The armour is the same as the weapons, we add the tags so that a benefit will be given to the player when equipped.
1. We can also add in a tag to the armour that buffs the weapon instead of the player: <srpgWRangePlus:X>
2. This gives additional range to the weapon NOT the player. Good for using with Weapon/Armour combinations.

The enemy tags are also required, but we need to set up ALL of the above into a single Note on each enemy in the database.

1. First we enter: <characterName:X>
This links the enemy to the .PNG file in the “GameName\img\characters” folder. On the battlemap, Actors will be automatically replaced by the Actor ID linked to them, the same is true for the Enemy ID, but we need to be more specific due to how the enemy database is more simplistic.
This is only used during the SRPG battle Maps (when the plugin “SPRGBattle Start” is activated).

2. <characterIndex:X>
Then links the sprite inside of the .PNG to the enemy ID.
Remember, RPG Maker uses character sprite sheets of 12 x 8, which makes up 8 character sprite “groups” on the sheet. For the link to work, we need to link them based on;
0 | 1 | 2 | 3
4 | 5 | 6 | 7

3. Say we want to use sprite number 5 in the “Monster” PNG file. We will use;
<characterName:Monster>
<characterIndex:5>
Remember, the first group of sprites is 0, then the second is 1, and so on. Also, make sure to use the correct filename for the PNG, including the right Capital letters, spelling, and any numbers.
NOTE: The sprite located in the Enemy database (under General Settings) will be used for the “Side Battler” view in combat.

4. Then we want to add in the “Face Art” for the battlers. This is the same idea, but this time we want to look in the “GameName\img\faces” folder:
<faceName:X>
<faceIndex:X>

5. Following the above example, we would want the face art for Monster #5. Just for the example, I’m going to say that the filename is MonsterFace (just to avoid confusion);
<faceName:MonsterFace>
<faceIndex:5>

We still use this grid as before
0 | 1 | 2 | 3
4 | 5 | 6 | 7

6. We can then add in some optional information;
<srpgClass:X>
<srpgLevel:X>
This is purely cosmetic information but can be used to distinguish enemies using the same art but are stronger.
E.G: We have a Goblin, but this one is a more difficult enemy, so we give him a “rank”.
<srpgClass:Officer>
<srpgLevel:12>
This will show the Goblin as having a subtext of “Officer” and being “Level 12”. Again, this is purely cosmetic, and not linked to any stats or files.

7. For clarity, this is how it will look so far using a made-up example, as in these aren’t the assets in the game files we’re just using made up ones.

8. We have “Goblin” in #002 in the enemy database, who has an attack of 12. His tags are;
<characterName:Monster> (we’re looking in the Monster PNG file, which has 8 monster sprites, including the goblin’s)
<characterIndex:0> (The Goblin Sprite happens to be the first sprite on the sheet)
<faceName:MonsterFace> (Now we’re telling the game to look in the “MonsterFace” png in the faces folder)
<faceIndex:0> (and the goblin face art is in the first slot, so he would be “0” because RPG maker counts 0 as a number)
<srpgLevel:3> (this goblin will have a subtext telling the player that he is level 5, even though there isn’t any level associated with him. We simply reflect this weak number in his low stats.)

9. Then we want to make a more powerful version for added challenge. We simply copy the Goblin’s information in the enemy database into #003 creating an exact replica, using the same art, and same stats.
After improving his attack from 5 to 15, we then change his tags in the Note section;
<characterName:Monster>
<characterIndex:0>
<faceName:MonsterFace>
<faceIndex:0>
<srpgLevel:7>

This stronger goblin is using all the same artwork, but now has a higher level, so at a glance players know he is stronger than his Level 3 brother. This allows us to create lots of enemies but saving on the workload of creating custom assets over and over again.

10. Then, when we want to create the more unique enemies, we can add the “Class” tag to make them stand out as “different”. So we copy #003 into #004 of the enemy database, but this time add in a class tag.
<characterName:Monster>
<characterIndex:0>
<faceName:MonsterFace>
<faceIndex:0>
<srpgClass:Officer> (Now this goblin is an officer!)
<srpgLevel:7>

11. We can also tie this goblin to victory conditions, such as defeating him to bring out the boss, and we know which event ID to link it to as we have this new Goblin all set up in the enemy database. Of course, it would be good measure to give these more unique characters different artwork and sprites, but that’s really just polish.

Keeping with the Enemy Notes, now we get into the actual abilities of the enemy;
1. Like with the Actors, we add a movement tag to say how many tiles an enemy can move:
<srpgMove:X>
2. We then set up how far the enemy can attack with their basic move:
<weaponRange:X>
We can also add a “Minimum range” if the enemy is using a bow or ranged weapon as a primary:
<weaponMinRange:X>
3. Instead of a normal attack, we can give the enemies a skill to use, just like the players:
<srpgWeaponSkill:X>
4. Or, we can even give the enemy access to a weapon from the database!
<srpgWeapon:X>
Remember that this will overwrite the enemy’s weapon range tag, so best not to include both to avoid confusion.
5. We also want to set up if we allow them to counterattack:
<srpgReactionSkill:X>
Remember that this is the skill they will use for a counterattack, so setting this to 0 will make the enemy unable.

So, in summary, all enemies require the following;
<characterName:X>
<characterIndex:X>
<faceName:X>
<faceIndex:X>
<srpgMove:X>
<weaponRange:X> OR <srpgWeapon:X>
<srpgReactionSkill:X>

All the other Enemy tags are to help distinguish and add to the game, but are not necessary for function.

Like all the others, we can also add to the States database to allow temporary effects (usually combined with Skills) to be passed top units – as these can be set to “turn off” after X amount of turns.

1. To give or take away a unit’s movement points:
<srpgMovePlus:2> OR <srpgMovePlus:-2>

2. We can also temporarily take away the ability to counter attack!
<srpgReactionSkill:0>
Or, by changing the 0 to 1 (or any other skillID) we can give a unit a new counterattack (for a little while).

3. Like the other tags, we can change weapon ranges: <srpgWRangePlus:X>

With the right additional plugins enabled (included in the SRPG pack), we can also add special abilities to units.

1. If a character can fly over impassable terrain (like water or rocks/stumps etc.), such as a “Bat”-type enemy, we add the tag:
<srpgThroughTag:X>
This allows them to pass over any terrain tag including and under whatever X is equal to. We can set up terrain tags in the battle’s maps level editor, but setting to this to 1 is a good idea as most region tags are 0 by default. Oh, but don’t set this to 0 or it won’t work!
This can also be added to armour, weapons, and even states!

Pro tip, don’t forget to actually set up the terrain tags via Database>Tilesets>(The Tileset you’re using on the battlemap)>Terrain Tag (Right side menu) and then assign number 1 to all tags you want to be able to fly over.
Put higher numbers for things only certain characters (like ghosts) can use fly to “Pass through” and 7 for unpassable (so the player can’t fly or teleport out of the map)!












Don’t forget to make sure that in the SRPG core Plugin menu, “srpgRangeTerrainTag7” is turned on!

2. Alternatively, to allow a unit to move through all opponent units, like they can allies, but NOT fly over impassable tiles :
<passOpponents>
This is good for enemy types like ghosts to break through player “battle lines”! We can even add this as a state so that spells can “slip past enemies”.

<passObjects> is only for passing events you’ve added to the battle map with the tag <type:object>
That would be something like, an enemy summons a rock to block the player, player activates a skill called “Jump” which gives the caster the temporary state tagged with the above. <type:Object> is the rock, jump will have <passObjects>, allowing the player to pass them.


3. When added to a state and inflicted, players can have their weapon disabled for a short time (or even the entire battle if you’re mean), and also be unable to switch:
<srpgWeaponBreak>
This can affect enemies too, but not recommended.

4. Added onto states, weapons, and armour, we can give additional boosts to any “variable Ranges” tags: <srpgRangePlus:X>

5. Auras are special states that allow units to have an area around them that, while active, any friendlies (or foes, depending on setup) will be affected with simply by being close to the user. First we need to set up the “Aura’s name”: so in states we are going to add in “Speed Increase Aura” into a blank slot in the database.
We then set up who it targets: <SRPGAuraTarget:X> (Which can be “friend”, “foe, or “all”)
Then the range around the caster: <SRPGAuraRange:4>
And then we add in: <SRPGAuraState:X>

6. We then create another State below our “Speed Increase Aura”, which will be the effect. Name this “Speed Down (Aura)”, create the effect within the Traits of the state (Parameter Agility * 125%), and then add in the tag:
<SRPGAura>
With this note, the speed increase will be removed once a unit is out of the Aura.

7. Go back into the “Speed increase Aura” state, and now change the “X” in <SRPGAuraState:X> to the ID of the “Speed Down (Aura)” to link the aura with its effect.

We can also create a script call that allows events to happen wherein new units are summoned to the battle field!

1. First, we create a new map in the game, this will store all our summon-able units.
2. In the map we create 3 new events; in the notes of the first event, “For Actor”, in the second “For Enemy”, and the third, “For Object”.
Like our events on the battle map, these are simply placeholders that the game will call on.
In the “SRPG_Summon” Plugin, make sure to link the summoned Map Id in the parameters.

3. Then we want to set up the conditions in either Player Turn Start, Enemy Turn Start, or Process After Unit Action events on the battle map – such as after X amount of turns.

4. After setting up the Conditional Branch, we then call on a script;
this.summon(type, summonId, battlerId, level, turn, x, y);
type: can be ‘actor’, ‘enemy’, or ‘object’ – telling the SRPG Engine whose team this event is going to be on.
summonId: the id of the event that you are going to copy from the Summon Map, which are our placeholder sprites from step 2.
battlerId: the id of actor/enemy from their respective databases.
level: the level of summoned actor, putting “undefined” is initial level of actor.
turn: the life span of this summon. After this number of turns the event will disappear. “undefined” is infinite.
x: x position on the battle map that the summon will appear (default will be in the next available space to the player)
y: y position on the battle map that the summon will appear (default will be in the next available space to the player)
If it is an enemy, we can add in a movement mode: “normal”, “stand”, “random” etc.

If you want to use the default value of a parameter, or a parameter is not needed for your summon and you are not sure what to put, simply use undefined (do not add '') as a place holder.

5. So, if we were to summon in an ally, lets call him “Harold” and he is #002 in the actor database;
this.summon(‘actor’, 1, 2, undefined, 8, 5, 10);

This will go into the Summon Map, “summon” sprite 1 (the actor), replace the sprite with Harold’s sprite and information, put Harold’s level to his initial, Harold is going to remain on the battle map for 8 turns, and he spawns in position x=5:y=10 on the battlemap.
6. And yes, we can use this to summon multiple units. As a note, don’t summon any actors that are currently on the field – it causes errors. If you want a “doppelganger effect”, make sure to create separate “copy/pasted” pages in the actor database!

7. To link summoning Harold to a skill, create a blank skill in the database and name it accordingly.
We want to add the tags;
<cellTarget>
<srpgRange:3>
This will allow the player to select the tile to summon Harold on, and how far away he can be summoned.
8. However, Harold needs his script to function, and this way isn’t tied to our battle map! So, we need to now create a common event, and name it “Summon Harold”.
9. In the common event, add the Script call as before:
this.summon('actor', 1, 2, undefined, 8, undefined, undefined);

Remember to leave the X and Y coordinates undefined so the player can select them!
Also, we can add in; this.activeBattler().level
This will give Harold his “current” level in the game, as this way of summoning can happen more than once per battle, and we don’t want to confuse the player if Harold levels up in a fight, disappears then is back to a lower level when summoned again!

10. Make sure to link the common event to the “Summon Harold” skill in the “Effects” section.
11. We can also use this summoning “spell” to summon objects to the battlefield to impede enemies!

1. We can also use this summoning spell as a base for Player teleportation! First set up a new skill called teleport and add in the tags as before;
<cellTarget>
<srpgRange:4>

2. Now we make another common event called “teleport” and put in the following Script;
this.activeBattler().teleport();
Simply, this will make the caster teleport to the selected “cell” (tile).

3. For added flair with either the summon or the teleport spell, add SFX and have the screen flash before the script call!

We can also transform units visually to show off temporary power-ups. We will need sprite artwork different to the actor we want to transform.

1. First, we need to set up a state called “Transformed”. Make sure to add in buffs and/or new skills for your super powered character to use.
2. Then we link it to a skill called “Transform”, and give the skill to the character who can transform.
3. Make a switch and name it “Harold transformed”.

4. We also need to make a common event to check if the character is using the transformed skill. Set up a conditional branch, checking if Actor “Harold” is affected by state “Transformed”, and if he is, turn on the “Harold Transformed” switch.
In the common event you can add any custom art to be shown, dialogue, visual effects (such as changing the actor image to a new sprite), music cues, etc. for flare.
Note that just changing the Actor Image settings will only affect the face and side battler art, not the sprite in combat, which we will fix next.

5. Now go into the Battle Map, and open up one of the Actor sprites.
6. Copy and then Paste Event Page, to get an identical to the first (make sure all the tags in the Notes section match).
7. Under Conditions, tick Switch and link it to Harold Transformed.

8. We then need to add the custom sprite in the image box, to make it appear on the battle map.
This only works with a set character (Actor 1/2/3 in the notes) but can be used for Actor 0 tag. Otherwise every single Actor 0 appearing on the map will become Harold in his transformation instead of whatever character was placed there.

9. After the battle, remember to turn off the Harold transformed switch and change the Actor Image settings back to Harold’s “normal” sprites and face art/side battler.

It took me a lot of work recording all these notes and turning them into something I hope you can use. I’ll try to update this as I go with any other useful information, but this covers everything you need to get the system working.

Good luck!

@Morxun asks;
“Hi! Do you use the built-in plugin function to gain experience, or did you disable it? I was happy when I discovered this function - it can get guaranteed experience in battle, unlike the method of gaining experience from the engine. But when I figured it out, I decided to disable it - the experience gained depends on the experience scale, and not on the level of enemies, and it turns out that you can level up to level 100 on first-level enemies. Now I'm thinking about how to add experience through an event in battle. So far, the idea is to assign variables to actor events, and at the end of the battle add experience to them. This is complicated by the fact that I created 2-3 times more events with id: 0 than will participate in the battle (to be able to arrange them).”

Good question. My answer is a little long so I decided to add this section.

For anyone else reading; the only reason to not use the built in plugin (by turning everything to 0 in srpgBattleExpRate under SRPG_core , for anyone curious) is if you plan to add a set amount of Exp to the party at the end of the fight via “Change EXP” in the event editor – the downside being that you will have to do this for ALL battles.

Otherwise what the SRPG system does is give the EXP per “attack”, based on if the player doesn’t defeat the enemy with the attack, they will be awarded X percent of the total EXP awarded for defeating the enemy – X defined by the srpgBattleExpRate.

So, if I set the srpgBattleExpRate to 0.4, and it takes the player X turns to kill an enemy, they will be awarded 0.4 (40%) of the total EXP an enemy would give if defeated in one shot, for each attack the player lands.

This is so that multiple player characters can attack a single foe and share EXP rather than only the killing blow getting the experience.



I think that in Morxun’s example, being able to level up to 100 on the first enemies mean that you’re giving wayyyy too much exp set in the Enemy Database, or maybe too many enemies per map.

As an example, in my game I have srpgBattleExpRate set to 0.4 – and the first enemies players face only give 1 EXP each. This way, I could put 100 of these enemies and still the player never go near Lv 10 without serious grinding, which is what we want as the player shouldn’t hang around one place too often.

Even later in the game my enemies have low EXP to account for the srpgBattleExpRate (I keep EXP under 100 for “normal enemies”, 100-150 for stronger variants (sergeants, captains,etc), and so on, with bosses/set objectives (find X Herbs etc) giving the most EXP but won’t be encountered often/only once (can’t be farmed).

In a nutshell, keep the EXP awards low.

So, say that it takes 4 turns to kill the 1 EXP enemy (player at level 1), well then each enemy actually gives 4 EXP rather than 1 – as the SRPG engine awards exp per attack.

BUT, once the player gets strong enough to two shot/one shot the enemy, they’ll actually be earning LESS EXP – reflecting that they’re too strong for this enemy and it’s time to move on.

This is why Morxun ‘s players are levelling up so fast; the EXP being awarded for defeating the enemy is too high, the player’s class “EXP needed to level up” is too low, or there are too many enemies awarding decent experience based on the Player’s level (or a mix of all).

My advice would be to turn the plugin EXP system back on, and set a low EXP for your enemies, then play test until you feel that said enemy reflects what the player should be facing at whatever the player's current level is. Remember, we can also make the same enemy but stronger and define them with the tags in the enemy database to make a distinction!

But honestly @Morxun, I think you’re making it a little too complicated with the variables. I get what you’re thinking, a variable that say an actor who attacked 50 times will get more exp than one who attacked 4 times, or supporting (healers) gets more EXP than attacking, etc.

This is a really cool idea on paper, but it’s adding a tonne of workload for little payoff (in my opinion), as players generally won’t notice or care beyond the initial “Oh cool system”, or worse, be confused as to why certain characters are levelling up faster than others.

Not to mention it’s another thing for the game to track, and RPG Maker can crash for all sorts of reasons without adding fuel to the fire. Basically, the game already does a great EXP system if you tweak it slightly, I’d highly recommend using the EXP system that’s already there over setting up your variables.

--------------------

@BattleBees asks,
“Hello I've been working hard at implementing this plugin in MZ, it seems to all still work. When I first set it up my counter attacks worked, but after working on other parts of my game and returning to the battles I cannot get them to activate on the enemy turn, only player turn. I just can't figure it out!”

So the counter attack skill, known in the system as “srpgBattleReaction”, has a few factors affecting whether the enemy can do it. I’m going to assume BattleBees has this already set up, but here’s some details for the rest of you!
Firstly, the Enemy itself needs to have the right tag. If you’ve followed the guide, your Reaction Skill should be set to the default (001-Attack) and look like <srpgReactionSkill:1> in the notes section of your enemy. If this is set to 0, then the enemy will not counter attack. In the actual plugin of “SRPG_core”, we want to make sure that “srpgDefaultReactionSkill” is set to 1 – just to make things easier.


In BattleBees’ example, it sounds like the counterattacks aren’t working for the Bad Guys for one of two reasons;
1) They are being hit with an attack that they cannot counter.

Some skills have the note attached to them that stop the Reaction Skill. Anything with this tag:
<srpgUncounterable> - which is best used for long ranged attacks, where “in Game” it wouldn’t make sense that a melee fighter could counter attack a gunman at range, with his sword.

Most likely if this is the case, the Player character has this on either their Weapon or Skill, and is blocking the enemy counter.

Also, as a note, make sure that none of the combatants have this tag: <srpgCounter:false>
While it does work with the Reaction Skill, it can cause problems with the priority list, best to set any instances of this back to <srpgReactionSkill:0>

2) It is being overwritten by another effect.

In terms of priority the engine looks for: State > Equipment > Skill > Enemy > Class > Actor > Plugin Default.

This means that any tags in “State”, as in any effects attached to a state when applied to a character, takes priority over anything attached to an “Enemy”.
For example, if the Enemy has a counter attack reaction set up in his notes, BUT he is also using a weapon that DOESN’T have the reaction skill tag attached, then he will not be able to counter attack, as it is over written.


Of course, with RPG maker, it could also be dumb luck, as in the enemies haven’t “rolled” the chance to counter attack. Now, I can’t see anything in the notes that says this is true, but as I’ve been play testing my own game, I have noticed that my Player Character doesn’t always counter attack – though admittedly I’ve not been looking too hard.
This leads me to believe that there is some sort of “chance to counter attack” going on here, but again, I can’t prove it and haven’t found any option that reflects this.

As a final note, don’t forget that “useAgiAttackPlus” gives players and enemies the chance to attack twice if turned on, all tied to the Agility stat. This has nothing to do with the counter attack ability, but might give the impression that the Enemy counter attack is being ignored (Player attacks, enemy doesn’t react, player attacks again).