I apologize for missing the last two updates. Unfortunately, real life commitments have kept me from updating, and will continue to do so for the foreseeable future.
As such, I will be closing up shop, as it were for the next several weeks. I will be back in December, hopefully when I have more free time for RPG Maker things, and maybe with some brand new states to share.
Until then. Farewell for now.
~Ramza
Hello everyone. I haven’t had much of a chance to check yet, but I suspect there are still very few of you reading this. I apologize once again for my absence, I’m not quite ready to return yet, but I made a new plugin and figured I should show it off!
This plugin actually builds upon my very first state, the block chance. What it does, is it solidifies Block Chance (blk) as an xparam in the engine, allowing states and armors to add to it, and actors to display it as a parameter in the status screen, with some coaxing of course.
With this plugin, the parameter blk can be used in the same way that att, or mat, or cev, or acc can be used. In damage formulas, or evals, or enemy ai evals or whatever you want. In order to make use of it, you’ll need some other plugins that can work with custom parameters. Yanfly’s buffs/states core is what we use all the time here, and it works perfectly for this as well.
The plugin gives us the following note tag, which can be placed on an armor or on a state:
<BLOCK CHANCE: X>
X is equal to the percent chance you want the block to happen. Eg: <Block Chance: 15> will give a 15% chance to block.
We also have two other note tags that can only be placed on an armor:
<BLOCK ANIMATION: X>
<SLAM ANIMATION: X>
These tags take the id in X and show the respective animation when a shield block or a shield slam occurs. You’ll need an action sequence plugin to make use of the slam animation, but the block animation is built into our new and improved Shield Block State:
<Custom React Effect>
if (value > 0 && this.isHpEffect() && this.isPhysical()) {
var rnd = (Math.floor(Math.random() * 99 + 1))
var shd = target.blk
if (rnd < shd){
value -= value;
target.startAnimation(target.equips()[1].blockAnimation, true, 0);
}
}
</Custom React Effect>
The plugin can be downloaded here. Happy building.
Good morning everyone, apologies for posting this one a day late, work got in the way.
This week is a double feature. I’m starting to run out of awesome states from my own project to share, so this week I’m going to share a modification of a state that my good pal* yanfly came up with for a tips and tricks video a long time ago (at least I think that’s where I got it from).
*(Disclaimer: yanfly isn’t my good pal)
Prayer of Mending is an active buff spell that causes a small amount of healing when the affected target is hit. After healing, the state ‘jumps’ to another ally. The buff will bounce a number of times before running out. Naturally, given the name, and effect, this is lifted almost entirely from World of Warcraft, where this used to be a staple spell of the Discipline Priest. I’m not even sure if this spell is even still in the game now, mind you.
As a bonus this week, though, I am going to share a second spell, one that consumes the number of ‘jumps’ the state has left on it to cause an active healing effect on the target. This allows the players healer character to give up random, mostly passive healing effects on her allies to cast a giant emergency heal instead.
So let’s get to it.
Here is our state. Note that the turn duration can be anything you want it to be, it will reset when it hops to another actor.
Here is the copy paste code for this effect:
<Custom Apply Effect>
this._mendingCharges = 6;
this._mendingHeal = origin.mat * 4;
this._origin = origin
this.setStateCounter(236, 'x' + 6);
</Custom Apply Effect>
<Custom Remove Effect>
this._mendingCharges = undefined;
this._mendingHeal = undefined;
this._origin = undefined;
</Custom Remove Effect>
<Custom React Effect>
if (this.isHpEffect() && this.isDamage() && target.hp > 0) {
var heal = Math.floor(target._mendingHeal * (((Math.random()*40)+80)/100)) * target.elementRate(11) || 1;
target.startAnimation(193);
target.gainHp(heal);
target.startDamagePopup();
target.clearResult();
var charges = target._mendingCharges - 1;
var caster = target._origin
target.removeState(236);
if (charges > 0) {
var members = [];
for (var i = 0; i < target.friendsUnit().aliveMembers().length; ++i) {
var potential = target.friendsUnit().aliveMembers()[i];
if (!potential) continue;
if (potential === target) continue;
if (potential.isStateAffected(236)) continue;
if (potential.hp <= 0) continue;
members.push(potential);
}
var member = members[Math.floor(Math.random() * members.length)];
if (member) {
member.addState(236);
member._mendingCharges = charges;
member._mendingHeal = heal;
member._origin = caster
member.setStateCounter(236, 'x' + charges);
}
}
}
</Custom React Effect>
Make note that where this state is determining damage, it is using the target’s elementrate for element Id 11. In my project, this element is a healing element. For your own project, you can remove this section, if needed.
The flow for this ability goes as follows:
There is a tiny mechanic built into this ability, in that the heal from each charge has been randomized for each charge before it. This is difficult to convey properly, so I will try to explain in point form.
Alright, so now that we’ve got that finished, let’s cover Swiftmend. This is an active spell that removes all remaining charges of Prayer of Mending from the target and heals them for equivalent of the remaining charges. This skill makes use of yanfly’s target core and selection control plugins to make sure you can only ever use this spell on a target affected with Prayer of Mending.
This skill is an instant cast, which has a cooldown of three turns (which both require those plugins from yanfly if you want to make use of that), preventing the caster from using this emergency heal multiple times in a row. The the damage formula for this spell is where we get the entire effect from. b._mendingCharges is where the charges from the state are stored. You can also modify the formula to make the ffect stronger or weaker than the individual charges would be. In this case, this will do healing as if each remaining charge had been used, but you can also make it slightly stronger or weaker by changing the first part of the formula. By removing the state afterward, the charges, and healing are also cleared, so the effect is gone. Also worth noting, the extra variance effect from the actual state doesn’t apply to this skill, as it only goes through random variance once.
That’s all for today’s update.
~Ramza
Welcome to this weeks state shop update. I’d like to start by apologizing for missing the update last week. I was at a wedding on the weekend, and then some health stuff happened that wasn’t pleasant the result was some missed work, and unfortunately, a missed update. Apologies.
Alright, with that out of the way, let’s talk about today’s state, Touch of Death. Inspired by a similar skill of the same name in Final Fantasy XIV, touch of death is a damage over time effect that gets stronger the longer it is on the target. My example lasts 12 turns, and the damage it deals doubles each turn it is active. This effect is possible thanks to state counters, a feature of yanfly’s Buffs and States Core plugin (which we always use already).
First, here’s a screen grab of our state. Note the turn duration, and remove at battle end.
Now, to keep with our other damage over time states, this state will also take into account the element of it when it deals damage. In my example, I have created a variable to reduce the damage from the state as if it were a physical attack. This is the default formula that Yanfly’s Armor Scaling plugin uses. You can also change this to just about anytghing to make it work in your project, but remember that damage reduction from the armor scaling plugin doesn’t take effect on damage dealt by states in this way. It is also important to note, that because by the last turn of this state, it will be doing 12x more damage than it did on the first turn, the base damage of the state should be very low. In this example, the state deals damage equal to the actor’s attack parameter.
Here is the paste code:
<Custom Turn End Effect> this.addStateCounter(29, 1); if (this.getStateCounter(29) > 12) { this.setStateCounter(29, 12) } var ele = 1 var reduction = (100 / (100 + (this.def / 2))) var formula = Math.round((origin.atk * this.getStateCounter(29)) * reduction); var total = (Math.floor(formula * ((Math.random()*40)+80)/100) * this.elementRate(ele)) this.gainHp(-total); this.startDamagePopup(); if (this.isDead()) { this.performCollapse(); } </Custom Turn End Effect> <Custom Leave Effect> var ele = 1 var reduction = (100 / (100 + (this.def / 2))) var formula = Math.round((origin.atk * 12) * reduction); var total = (Math.floor(formula * ((Math.random()*40)+80)/100) * this.elementRate(ele)) this.gainHp(-total); this.startDamagePopup(); if (this.isDead()) { this.performCollapse(); } </Custom Leave Effect>
Note that the state Id we’re working with is 29, and this will need to updated in your own project. Also note the Math.random function is being used to add variance to the damage of the skill, in this case, 20%. When the state first does damage, it is at one stack, so it will deal 1x damage. Every turn end after, it gains one more stack, dealing more damage each turn, until it falls off on the 12th turn, dealing 12x damage. The state is designed to never exceed twelve stacks, but you can adjust that to your liking. See below for a possible strategy tip regarding this state, and others like it.
This effect is mostly only useful for the start of a fight, as if the enemy dies early after receiving it, it will not have done much damage. However, as scripted, if someone re-applies the state, the turn counter will remain where it was when the state is re-applied, allowing someone to refresh the highly stacked state with a fresh 12 turn duration. This results in a Damage over time type strategy, where applying this state, and keeping it on the target becomes a very high source of damage.
If you don’t want this to happen in your project, you can add the line <Reapply Ignore Turns>, which will causes a skill that re-applies this state to have no effect on it. This would prevent the damage stacking of the above tip.
That’s all for this update folks.
~Ramza
This week I’m going with another added effect state. Lightning shield is an active buff state that causes the affected battler to discharge lightning to all enemies when hit by a physical attack.
This state paste code will make use of our new plugin that I just released earlier today, which will make the copy + paste code for it much simpler to use and read. The plugin handles the calculations of the waiting and does the damage popups automatically based on the animation Id used.
So lets just jump into it.
Our first state is the shield state. This is the state that is applied to the target when the lightning shield spell is cast on them. It has a turn duration, and some info in the note box.
Here is the copy-paste code for this state:
<Custom React Effect>
if (this.isHpEffect() && this.isPhysical() && !target.isStateAffected(27)){
user.addState(27)
target.startAnimation(77, false, 0)
for (i = 0; i < $gameTroop.members().length; i++){
if (!$gameTroop.members()[i].isDead()){
$gameTroop.members()[i].shddmg = origin.mat * 2
target.addState(27)
performStateAnimationDmg2(76, $gameTroop.members()[i], (Math.floor(($gameTroop.members()[i].shddmg) * ((Math.random()*40)+80)/100)), 4);
$gameTroop.members()[i].shddmg = undefined
}
}
}
</Custom React Effect>
<Custom Deselect Effect>
target.removeState(27)
</Custom Deselect Effect>
StateId 27 is used as a fail safe to make sure that a lightning shield doesn’t trigger multiple times on the same action. Without it being applied and checked for, an attack that hit’s three times would trigger the shield three times as well.
As I said when I first created this blog a little over two months ago, occasionally I will release plugins here as well as state codes.
With this weeks state, I have made the paste code simpler by including a function that performs the state animations, and calculates the amount of time waited before the damage popup automatically. It contains a couple of different versions of the same thing, which react differently when multiple animations are played, or when there are multiple targets of a state animation.
The idea of this plugin is simply to make the paste codes easier to read. It adds the following functions to the game engine, and can either be loaded as it’s own plugin, or have the code below pasted into a .js file of your own to add the functions to the game.
performStateAnimationDmg(animationId, target, damage, ele)
performStateAnimationDmg2(animationId, target, damage, ele)
performStateAnimationDmg3(animationId, target, damage, ele)
All of this information is also in the help description of the javascript file. Please note that with the release of this plugin I will no longer be manually showing the settimeout functions used to delay the damage popup in any new added effect states, they will all make use of this plugin from today forward.
This plugin can be found here. Make sure that the filename does not change.
For this week’s state, I’m providing a much more basic ability than usual. Overload, when active, causes skills that belong to a certain skilltype to deal 1.8 times normal damage. It also causes those same skills to deal 15% of the dealt damage back to the caster. As a passive ability, it can cause a mage-type character to turn into a true glass cannon, and as a toggleable ability, gives the player an extra strategic choice, in deciding if dealing that massive damage is worth healing the actor later (or possible).
Our paste code is quite simple. For this example, I have created the state as a passive, in that anyone who will make use of it will do so passively. In my project this is to allow players to ‘equip’ passive skills to the actors, to further customize them.
<Custom Confirm Effect>
if (this.isMagical() && this._item.isSkill() && $dataSkills[this._item._itemId].stypeId == 12 && value !== 0) {
value = Math.ceil(value * 1.8)
user.gainHp(-Math.floor(Math.abs(value * 0.15)))
}
</Custom Confirm Effect>
Our If condition is checking for the following:
These checks can be further modified to your liking, of course. When all checks are passed, damage is multiplied by 1.8, and 15% of that is dealt to the caster.
That’s all for now.
This week I am showcasing a special type of states, the added effect. These states are special in that they cause an effect to happen after another action has taken place. The state this week is enflame, a single target buff spell that causes extra fire damage on a foe after being attacked.
This state is surprisingly technical, and I’ve already found a non-yanfly plugin that broke compatibility with it (an outdated plugin that I’m still using in my project), so it’s possible it might not entirely work for you. Let me know if there are any issues on your end.
This particular skill can be cast by one actor to affect another actor. When the affected actor makes a physical attack, the conditions for this state become true, and some extra fire elemental damage is dealt to the target. This has a separate animation, and a separate damage popup.
I will include a more in depth explanation of the spaghetti code I’ve used and what each part of it does, to facilitate more easily using it for your own states.
The skill:
For this effect, I have a single target buff spell that can be used on the caster’s allies. It doesn’t really have anything special in it, aside from giving the state to the ally.
Next we need to make our state.
This state expires after a number of turns, like a lot of my states. Otherwise, the state itself does basically nothing. All of the effect is held in the note tags below:
<Custom Apply Effect> target.enflameDmg = (origin.mat * 4) // The above line sets the damage of the added effect // origin is the caster of the spell, in this way the spell can have its // damage be based on the casting stats of the actor who applied it if (target._name == origin._name){ target._stateTurns[209] = target._stateTurns[209] + 1 // For this skill, I have made it so that if the caster uses it on himself // its duration increases by one turn. // In the CTB battle system, the actor's turn ends as soon as his action is // over, causing the effect to last one less action than if he'd put it on // someone else } </Custom Apply Effect> <Custom Conclude Effect> if (target.result().isHit() && this.isHpEffect() && this.isPhysical() && target.hp > 0) { user.enfOn = true user.enfTarget = target // This if statement is checking to see if the requirements for enflame have // been met. Because we can't interrupt the action just yet, this local variable // is set on the user to denote that the effect will be triggered. // This also doubles in preventing the effect from happening multiple times on // multi-hit skills }else if (user.enfOn != true){ user.enfOn = false user.enfTarget = null // This else statement is preventing the added effect from not being applied, // if multiple actions had been taken, but the last one didn't meet the requirements // eg. if a three hit attack had the third hit miss. } </Custom Conclude Effect> <Custom Action End Effect> if (user.enfOn == true && !user.enfTarget.isDead()) { // If the effect was triggered, and the intended target isn't dead var extraFramesToWaitFor = 15; var animFrames = ($dataAnimations[178].frames.length * 4) + 1 + extraFramesToWaitFor; var waitSeconds = (animFrames/60) * 1000; // These variables set up our wait time, which allows the animation to play before // the damage popup shows up. target.startAnimation(178, false, 0); //Show the battle animation Id 178 setTimeout(function () { // everything below this line happens on a delay equal to waitSeconds above var total = Math.floor(user.enflameDmg * user.enftarget.elementRate(2)) // the above line adjusts the damage for elemental resistances user.enftarget.gainHp(-total); // deal damage user.enftarget.startDamagePopup(); // show the damage being dealt user.enftarget.performDamage(); // makes the affected battler do its damage pose if (user.enftarget.isDead()) { user.enftarget.performCollapse(); // kill the battler if it is now dead } BattleManager.checkBattleEnd(); // end the fight if this was the last unit alive setTimeout(function () { // this second timeout waits 3 seconds after the damage popup and moves the // affected battler back into position after having been hit target.performActionEnd() }, 180); }, waitSeconds); BattleManager._logWindow._waitCount += (animFrames + 30); // the above line makes the entire battle system wait for the specified time // in this case, we add 30 frames to it, to ensure an enemy doesn't take an action // while the damage popup is still on screen user.enfOn = false // after the effect is complete, turn the local variable off, so it won't // trigger again on the same action. } </Custom Action End Effect>
Also, here is an action sequence for the skill, as mine is fancy and I don’t mind sharing it 🙂
<setup action> camera clamp on display action immortal: targets, true perform start zoom: 300% camera focus: user wait for zoom motion chant: user cast animation wait for animation </setup action> <target action> motion spell: user camera focus: target zoom: 250% wait for camera motion attack: target action animation: target wait for animation action effect: target </target action> <finish action> perform finish clear battle log immortal: targets, false reset camera reset zoom wait for camera camera clamp on </finish action>
That’s all for this update.
~Ramza
Edit: October 16, 2016 I have changed the paste code to correct an incorrect target issue, that would cause enflame to always deal damage to the battler who was using it, rather than the target of their attacks. If you were having this issue, please re-copy the code now. Thanks.
My apologies for posting this late, I lost track of what day it was, and had to work, so I didn’t have time to post this until now.
This week’s state is a little favorite of mine, Second Chance, which allows a fallen actor to be resurrected at 50% HP, but only once per battle. This effect will trigger even if the actor who is affected by it is the only actor left alive in the battle, no instant game overs here.
We also need to modify your death state to accommodate the second chance ability. You will need a way to apply the passive state to the affected actor as well. You could alternatively not use a passive state, and instead make this effect an active buff with a turn duration.
First, let’s change our death state. We will need to add the following notetags to the death state to make it check for the presence of the second chance state:
<Custom Apply Effect> if (target.isStateAffected(186)) { BattleManager.queueForceAction(target, 210, 0); } </Custom Apply Effect>
The actor is checked for state 186 when he dies, if found, an action is forced to use skill 210 on that same actor. Skill 210 will be our second chance effect.
Note that this skill needs to have its scope set to affect a dead ally, otherwise it will have no effect on the actor. The effects of this skill remove the death trait, and restore a flat 50% HP to the affected actor, as well as add our second state. Here is the action sequence code for this skill:
<setup action> camera clamp on display action zoom: 300% camera focus: user wait for zoom </setup action> <target action> camera focus: user zoom: 250% wait for camera action animation: user animation wait: 20 motion dying: user wait for animation action effect: target motion standby: user wait: 20 motion spell: user wait: 25 </target action> <finish action> perform finish clear battle log reset camera reset zoom wait for camera camera clamp on </finish action>
Next we will cover the two states we need. The first is the enabler state, which causes the affected actor to resurrect after being afflicted with the death state. There is nothing too special on this state, only the following note tags:
<Category: Bypass Death Removal>
<Custom Passive Condition>
if (user.isStateAffected(187)) {
condition = false;
} else {
condition = true;
}
</Custom Passive Condition>
The above code prevents this passive state from becoming active if state 187 is detected. State 187 is the cooldown state, applied when the resurrection happens to the battler. This prevents the effect from happening more than once during a battle. The bypass death removal tag makes it so that this state is not removed upon death, without this tag, or some other way to make states remain on a battle even through death, the state has no effect.
The second state is the cooldown state, which is applied after an actor is resurrected. This state needs to be removed at battle end, but you could also modify it to last a number of turns as well, if you’d like your auto-resurrection to happen more than once. Without this cooldown state, the effect will happen every time the actor dies, making him functionally immortal. The only note tag for this state is below:
<Category: Bypass Death Removal>
This prevents the state from being removed if the actor dies, which prevents the auto-resurrection from happening every time the actor dies as well.
As said above, this works best as a passive ability, but can be easily modified to be a temporary buff spell as well. That’s all for this update, thanks.
~Ramza
This week’s state is a lot more simple. Overcharge is a special ability of the wizard class in my project, which allows them to cast a magic spell that deals twice as much damage as normal, while costing double the normal MP cost. This effect is instant cast, and only lasts for the following turn, and also makes use of a skill cooldown to prevent abuse.
Naturally, for the instant cast and cooldown, you will need the YEP Instant Cast and YEP Skill Cooldown plugins.
For this effect, we need a state, and a skill. The skill is used to apply the state to the caster.
To complete the skill, we also need the following note tags in the note box.
<Instant Cast> <Cooldown: 2>
Next we need the state
The state itself doesn’t really do anything, aside from expire after 1 turn. To get the desired effect, we need to add a few things to affected skills.
First, in order to double the MP cost of an overcharged skill, we need to add the following note tag to ANY skill that will be affected by Overcharged:
<Custom MP Cost>
cost = cost * (1+ user.isStateAffected(43))
</Custom MP Cost>
Note that StateId 43 is our overcharged state. What this does is double the cost of the spell, but only if Overcharged is active.
Next, the easiest way to double the damage of the affected skill is to change its damage formula. We need to add the following bit to the end of the damage formula for our spell.
* (1 + a.isStateAffected(43));
This will double the damage of the skill, only if the user is affected by the overcharged state.
If your damage formula looked like this before:
a.atk * 4 - b.def * 2
It should look like this after:
(a.atk * 4 - b.def * 2) * (1 + a.isStateAffected(43));
Because the state expires after one turn, generally the actor will only be able to use it once before it expires. This will not be the case when using instant cast skills, so keep that in mind when you’re balancing your battles around this mechanic.
That’s all for this update, folks.
~Ramza
ramzasworkshop 