# Proximity DMG, more DMG closer to target?

#### Icenick

##### Veteran
no you don't have to.
But you will need to edit the shell in the script to fit your game.
In the present script, shells are define as 50px, 100px and 150px distances. if your aoe radius is 100px, those shells definition will not make sens.
find the following lines in the script and edit them accordingly :
JavaScript:
``````var innerShell = 50; // setting what our shells will looks like.
var midShell = 100;
var outerShell = 150;``````

Yes I was playing with it to find that sweet spot, an interesting observation was the damage varied small amounts one bat took 46 the other 48, is it due to how close it is? Like the one closer took a bit more damage because it was a tiny bit closer?

#### Lay

##### Veteran
No, this probably come from variance.

the script works as follow :

if the target is distant from the aoe center by less than 50 pixels, he will take 100% of damages
if the target is distant from the aoe center between 50 and 100 pixels, he will take 75% of damages.
if the target is distance from the aoe center between 100 and 150 pixels, he will take 50% of damages.
else, if he is distant by more thant 150 px, he will take 25% of damages.

but you can change it to make the damages decreasing proportionally to the distance without notion of shells. I've just scripted it that way because I thought you wanted so.

below the line
Code:
``// Below scalling the damages according to shells.``

replace all the code by
JavaScript:
``````// Below scalling the damages according to shells.
value = Math.floor( value * ( 1 - ( dist / aoe_radius ) ));
value = Math.max(value,0);

</Pre-Damage Eval>``````

However, for some reason I don't understand, a skill with a notetag <AOE Radius: 250> will catch enemies at a higher distance than 250px. thus, it is possible that the farest enemies will received 0 damages with this.

Last edited:

#### Lay

##### Veteran
After a deeper investigation of the YEP_X_AreaOfEffect script, I've noticed that the way I've proposed to compute distances in the script don't correspond to the distances computed by yanfly.

The way I've computed distances assume that enemies are identically spaced than what the player can see at the screen. However, the player do not see the battlefiled from the top. Thus, yanfly compute distances according to a notion of perspective between the different object in the battlefiled.
In other words : the distance we saw along the x axis are not the same than what we saw on the y axis. Small distances on the y axis as saw on screen may correspond to potentially high distances on the battlefield.

I've edit the script in consequence. Distances are now computed according to how yanfly computes distances with perspective.

I've also learn how to retrieve the aoe radius and height ratio from the game action. Thus, it is not mandatory to edit the script to fit those values to the notetags you used.

However, I still don't know how we can retrieve the scope as an array when processing codes in a pre-damage eval notetag. If a scripter see this post, maybe he will find the answer.

the variable farestDamageRatio at the top of the <Pre Damage Eval> might be customize in order to define how much damages enemies that are located the farest from the aoe center will take.

JavaScript:
``````<AOE Radius: 250>

<Custom Execution>
// Custom Execution is executed only once regardless of the scope size
user._targetX = -1; // set a variable to -1.
user._targetY = -1; // set a variable to -1.
</Custom Execution>

<Pre-Damage Eval>

// setting customizable variable. Feel free to modify
var farestDamageRatio = 1;
// if this variable = 1, damage at the border will be 0.
// if this variable = 2, damage at the border will be twice the damage at the center.
// if this variable = 0.5, damage at the border will be half the damage at the center.

// setting few variables. !! Don't touch !!
var height = this.item().aoeCircleHeightRate;
var x = user._targetX; // the variable with ID 1 is used for x
var y = user._targetY; // the variable with ID 2 is used for y
var targetX = target.aoeX(); // this is the x coord of the current target
var targetY = target.aoeY(); // this is the y coord of the current target

// Main target position storage :
if (x === -1 && y === -1){ // x and y = -1 only for the first target.
user._targetX = targetX; // store the x coord of the first target
user._targetY = targetY; // store the y coord of the first target
}

var mainX = user._targetX;
var mainY = user._targetY;

// Below computing the distance between main target and current target
// according to yanfly perspective geometry definition.
if (mainX > targetX) {
targetX = Math.min(mainX, target.aoeX() + target.aoeWidth() / 2);
} else if (mainX < targetX) {
targetX = Math.max(mainX, target.aoeX() - target.aoeWidth() / 2);
}
if (mainY > targetY) {
targetY = Math.min(mainY, target.aoeY());
} else if (mainY < targetY) {
targetY = Math.max(mainY, target.aoeY() - target.aoeHeight());
}
var x =  (targetX - mainX) * Math.cos(0) + (targetY - mainY) * Math.sin(0);
var y = -(targetX - mainX) * Math.sin(0) + (targetY - mainY) * Math.cos(0);
var c = (Math.pow(x, 2) / Math.pow(a, 2));
c += (Math.pow(y, 2) / Math.pow(b, 2));

// Below scalling the damages according to c.
// c = 0 for main target and c=1 for targets at the border of the aoe circle

c = Math.min(c,1);
c = c * farestDamageRatio;
value = Math.floor( value * ( 1 - c ) );
value = Math.max(value,0);

</Pre-Damage Eval>``````

Last edited:

#### Icenick

##### Veteran
After a deeper investigation of the YEP_X_AreaOfEffect script, I've noticed that the way I've proposed to compute distances in the script don't correspond to the distances computed by yanfly.

The way I've computed distances assume that enemies are identically spaced than what the player can see at the screen. However, the player do not see the battlefiled from the top. Thus, yanfly compute distances according to a notion of perspective between the different object in the battlefiled.
In other words : the distance we saw along the x axis are not the same than what we saw on the y axis. Small distances on the y axis as saw on screen may correspond to potentially high distances on the battlefield.

I've edit the script in consequence. Distances are now computed according to how yanfly computes distances with perspective.

I've also learn how to retrieve the aoe radius and height ratio from the game action. Thus, it is not mandatory to edit the script to fit those values to the notetags you used.

However, I still don't know how we can retrieve the scope as an array when processing codes in a pre-damage eval notetag. If a scripter see this post, maybe he will find the answer.

the variable farestDamageRatio at the top of the <Pre Damage Eval> might be customize in order to define how much damages enemies that are located the farest from the aoe center will take.

JavaScript:
``````<AOE Radius: 250>

<Custom Execution>
// Custom Execution is executed only once regardless of the scope size
user._targetX = -1; // set a variable to -1.
user._targetY = -1; // set a variable to -1.
</Custom Execution>

<Pre-Damage Eval>

// setting customizable variable. Feel free to modify
var farestDamageRatio = 1;
// if this variable = 1, damage at the border will be 0.
// if this variable = 2, damage at the border will be twice the damage at the center.
// if this variable = 0.5, damage at the border will be half the damage at the center.

// setting few variables. !! Don't touch !!
var height = this.item().aoeCircleHeightRate;
var x = user._targetX; // the variable with ID 1 is used for x
var y = user._targetY; // the variable with ID 2 is used for y
var targetX = target.aoeX(); // this is the x coord of the current target
var targetY = target.aoeY(); // this is the y coord of the current target

// Main target position storage :
if (x === -1 && y === -1){ // x and y = -1 only for the first target.
user._targetX = targetX; // store the x coord of the first target
user._targetY = targetY; // store the y coord of the first target
}

var mainX = user._targetX;
var mainY = user._targetY;

// Below computing the distance between main target and current target
// according to yanfly perspective geometry definition.
if (mainX > targetX) {
targetX = Math.min(mainX, target.aoeX() + target.aoeWidth() / 2);
} else if (mainX < targetX) {
targetX = Math.max(mainX, target.aoeX() - target.aoeWidth() / 2);
}
if (mainY > targetY) {
targetY = Math.min(mainY, target.aoeY());
} else if (mainY < targetY) {
targetY = Math.max(mainY, target.aoeY() - target.aoeHeight());
}
var x =  (targetX - mainX) * Math.cos(0) + (targetY - mainY) * Math.sin(0);
var y = -(targetX - mainX) * Math.sin(0) + (targetY - mainY) * Math.cos(0);
var c = (Math.pow(x, 2) / Math.pow(a, 2));
c += (Math.pow(y, 2) / Math.pow(b, 2));

// Below scalling the damages according to c.
// c = 0 for main target and c=1 for targets at the border of the aoe circle

c = Math.min(c,1);
c = c * farestDamageRatio;
value = Math.floor( value * ( 1 - c ) );
value = Math.max(value,0);

</Pre-Damage Eval>``````

Your way was much better, with this new script I target the middle bat and it only hits the bat even when the AoE radius shows all enemies in area.
Also when I target plant it hits plant and middle bat for same damage, again the middle bat doesnt hit plant but plant hits middle bat.

I tested again and the second time (nothing change in code) the plant is being hit this time for way less damage than when the middle bat is targeted.
I realize I am using MOG_BattlerMotion with my bats having float, that if I cast it while they are floating they are out of reach.
Edit: I removed MOG and using Yanfly Animated sideview enemies which works now.

Damage is set to 200 / 0% variance
Edit: The difference is in BOLD:
See images below
img 1 is targeting middle bat, only can target middle bat 100% of the time, my plugin error.
img 2 is the damage 187 for target and plant is 55, Target takes 190 dmg
img 3 is targeting plant, all 3 enemies in range now.
img 4 shows 180 for target and bat takes 172. Plant takes 180 dmg, middle bat 175, top bat 112.
The damage is very odd since the distance is the same.
Im not sure why focusing the plant takes 180 and not 190, also the middle battle almost takes as much damage as the focus target, yet if you focus that middle bat, plant is not hit.

I want to have skills in my game that move targets position so that I can make skills like this that deal damage based on how you position them. Your last script worked well, in theory I can add more shells and have damage based off distance more varied.

#### Attachments

• 1.jpg
66.3 KB · Views: 4
• 2.jpg
67.8 KB · Views: 4
• 3.jpg
68.1 KB · Views: 3
• 4.jpg
65.5 KB · Views: 3
Last edited:

#### Lay

##### Veteran
If I reformulate, you don't understand why on one hand when Bat_B is the main target, the serpent Windroot take 55 damages and, on the other hand, when SerpentWindroot is the target, Bat_B take 172 damages. And for sure, the distance between Bat_B and SerpentWindroot is the same regardless of the target.

This phenomenon comes from the fact that Bat sprite and Plant sprite have different dimension.
Let's compute manually together the distance between those two sprites according to Yanfly

This is the sprite dimention of plant and bat :
name Height Width
Bat 198 px 128 px
Plant 138 px 152 px

let's assume that plant and bat are located at the following coordinates
Plant x = 0
Plant y = 0

Bat x = 100
Bat y = 100

### Targetting Bat ####

JavaScript:
``````if (mainX > targetX) {

targetX = Math.min(mainX, target.aoeX() + target.aoeWidth() / 2);

} else if (mainX < targetX) {

targetX = Math.max(mainX, target.aoeX() - target.aoeWidth() / 2);

}``````

the main refer to Bat (our target)
target refer to Plant (that is in the aoe)

JavaScript:
``if (mainX > targetX) {``
mainX is Bat x = 100
targetX is Plant x = 0
condition is met

JavaScript:
``targetX = Math.min(mainX, target.aoeX() + target.aoeWidth() / 2);``
mainX is Bat x = 100
target.aoeX() is Plant x = 0
target.aoeWidth is Plant sprite width = 152

we take the minimal value between 100 and 0 + 152/2 = 76.
From now, we consider that targetX = 76 (Plant x = 76)

Hope you understand that from this point the script consider that, on the x axis, the distance between bat and plant is 24 px right ? (Bat x - Plant x = 100 - 76 = 24 px)

### Targetting Plant ###

JavaScript:
``````if (mainX > targetX) {

targetX = Math.min(mainX, target.aoeX() + target.aoeWidth() / 2);

} else if (mainX < targetX) {

targetX = Math.max(mainX, target.aoeX() - target.aoeWidth() / 2);

}``````

the main refer to Plant (our target)
target refer to Bat (that is in the aoe)

JavaScript:
``if (mainX > targetX) {``
mainX is Pant x = 0
targetX is Bat x = 100
condition is not met

JavaScript:
``````} else if (mainX < targetX) {

targetX = Math.max(mainX, target.aoeX() - target.aoeWidth() / 2);

}``````

mainX is Pant x = 0
targetX is Bat x = 100
condition is met

JavaScript:
``targetX = Math.max(mainX, target.aoeX() - target.aoeWidth() / 2);``

mainX in Plant X = 0
target.aoeX() is Bat x = 100
target.aoeWidth is Bat sprite width = 128

we take the maximal value between 0 and 100 - 128/2 = 36.
From now, we consider that targetX = 36 (Bat x = 36)

Hope you understand that from this point the script consider that, on the x axis, the distance between bat and plant is now 36 px right ? (Bat x - Plant x = 36 - 0 = 36 px)

So, when we target the bat, the script estimate that the distance between the two battlers is 24 pixels on the x axis.
But, when we target the plant, the script now estimate that the distance between the two battlers is 36 pixels on the x axis.

Thus, it is normal that damages are not symmetrical according to which battler you are targeting.

#### Icenick

##### Veteran
If I reformulate, you don't understand why on one hand when Bat_B is the main target, the serpent Windroot take 55 damages and, on the other hand, when SerpentWindroot is the target, Bat_B take 172 damages. And for sure, the distance between Bat_B and SerpentWindroot is the same regardless of the target.

This phenomenon comes from the fact that Bat sprite and Plant sprite have different dimension.
Let's compute manually together the distance between those two sprites according to Yanfly

This is the sprite dimention of plant and bat :
name Height Width
Bat 198 px 128 px
Plant 138 px 152 px

let's assume that plant and bat are located at the following coordinates
Plant x = 0
Plant y = 0

Bat x = 100
Bat y = 100

### Targetting Bat ####

JavaScript:
``````if (mainX > targetX) {

targetX = Math.min(mainX, target.aoeX() + target.aoeWidth() / 2);

} else if (mainX < targetX) {

targetX = Math.max(mainX, target.aoeX() - target.aoeWidth() / 2);

}``````

the main refer to Bat (our target)
target refer to Plant (that is in the aoe)

JavaScript:
``if (mainX > targetX) {``
mainX is Bat x = 100
targetX is Plant x = 0
condition is met

JavaScript:
``targetX = Math.min(mainX, target.aoeX() + target.aoeWidth() / 2);``
mainX is Bat x = 100
target.aoeX() is Plant x = 0
target.aoeWidth is Plant sprite width = 152

we take the minimal value between 100 and 0 + 152/2 = 76.
From now, we consider that targetX = 76 (Plant x = 76)

Hope you understand that from this point the script consider that, on the x axis, the distance between bat and plant is 24 px right ? (Bat x - Plant x = 100 - 76 = 24 px)

### Targetting Plant ###

JavaScript:
``````if (mainX > targetX) {

targetX = Math.min(mainX, target.aoeX() + target.aoeWidth() / 2);

} else if (mainX < targetX) {

targetX = Math.max(mainX, target.aoeX() - target.aoeWidth() / 2);

}``````

the main refer to Plant (our target)
target refer to Bat (that is in the aoe)

JavaScript:
``if (mainX > targetX) {``
mainX is Pant x = 0
targetX is Bat x = 100
condition is not met

JavaScript:
``````} else if (mainX < targetX) {

targetX = Math.max(mainX, target.aoeX() - target.aoeWidth() / 2);

}``````

mainX is Pant x = 0
targetX is Bat x = 100
condition is met

JavaScript:
``targetX = Math.max(mainX, target.aoeX() - target.aoeWidth() / 2);``

mainX in Plant X = 0
target.aoeX() is Bat x = 100
target.aoeWidth is Bat sprite width = 128

we take the maximal value between 0 and 100 - 128/2 = 36.
From now, we consider that targetX = 36 (Bat x = 36)

Hope you understand that from this point the script consider that, on the x axis, the distance between bat and plant is now 36 px right ? (Bat x - Plant x = 36 - 0 = 36 px)

So, when we target the bat, the script estimate that the distance between the two battlers is 24 pixels on the x axis.
But, when we target the plant, the script now estimate that the distance between the two battlers is 36 pixels on the x axis.

Thus, it is normal that damages are not symmetrical according to which battler you are targeting.

Right thanks for breaking it down! I sort of get it, I understand the concept of it, which is why I prefer your original solution.

#### Icenick

##### Veteran
If I reformulate, you don't understand why on one hand when Bat_B is the main target, the serpent Windroot take 55 damages and, on the other hand, when SerpentWindroot is the target, Bat_B take 172 damages. And for sure, the distance between Bat_B and SerpentWindroot is the same regardless of the target.

This phenomenon comes from the fact that Bat sprite and Plant sprite have different dimension.
Let's compute manually together the distance between those two sprites according to Yanfly

This is the sprite dimention of plant and bat :
name Height Width
Bat 198 px 128 px
Plant 138 px 152 px

let's assume that plant and bat are located at the following coordinates
Plant x = 0
Plant y = 0

Bat x = 100
Bat y = 100

### Targetting Bat ####

JavaScript:
``````if (mainX > targetX) {

targetX = Math.min(mainX, target.aoeX() + target.aoeWidth() / 2);

} else if (mainX < targetX) {

targetX = Math.max(mainX, target.aoeX() - target.aoeWidth() / 2);

}``````

the main refer to Bat (our target)
target refer to Plant (that is in the aoe)

JavaScript:
``if (mainX > targetX) {``
mainX is Bat x = 100
targetX is Plant x = 0
condition is met

JavaScript:
``targetX = Math.min(mainX, target.aoeX() + target.aoeWidth() / 2);``
mainX is Bat x = 100
target.aoeX() is Plant x = 0
target.aoeWidth is Plant sprite width = 152

we take the minimal value between 100 and 0 + 152/2 = 76.
From now, we consider that targetX = 76 (Plant x = 76)

Hope you understand that from this point the script consider that, on the x axis, the distance between bat and plant is 24 px right ? (Bat x - Plant x = 100 - 76 = 24 px)

### Targetting Plant ###

JavaScript:
``````if (mainX > targetX) {

targetX = Math.min(mainX, target.aoeX() + target.aoeWidth() / 2);

} else if (mainX < targetX) {

targetX = Math.max(mainX, target.aoeX() - target.aoeWidth() / 2);

}``````

the main refer to Plant (our target)
target refer to Bat (that is in the aoe)

JavaScript:
``if (mainX > targetX) {``
mainX is Pant x = 0
targetX is Bat x = 100
condition is not met

JavaScript:
``````} else if (mainX < targetX) {

targetX = Math.max(mainX, target.aoeX() - target.aoeWidth() / 2);

}``````

mainX is Pant x = 0
targetX is Bat x = 100
condition is met

JavaScript:
``targetX = Math.max(mainX, target.aoeX() - target.aoeWidth() / 2);``

mainX in Plant X = 0
target.aoeX() is Bat x = 100
target.aoeWidth is Bat sprite width = 128

we take the maximal value between 0 and 100 - 128/2 = 36.
From now, we consider that targetX = 36 (Bat x = 36)

Hope you understand that from this point the script consider that, on the x axis, the distance between bat and plant is now 36 px right ? (Bat x - Plant x = 36 - 0 = 36 px)

So, when we target the bat, the script estimate that the distance between the two battlers is 24 pixels on the x axis.
But, when we target the plant, the script now estimate that the distance between the two battlers is 36 pixels on the x axis.

Thus, it is normal that damages are not symmetrical according to which battler you are targeting.

Hey Lay, so turns out I dont understand the concept as much as Id hoped lol. Im trying to modify this for another skill im using.

Basically its a melee attack that I want to apply a state in a radius around (and including) the target.
Its progressive so if they already have the state it will get the next level up.

I want the initial hit to do DMG to the target and apply State 20 on it, then anyone within 100 distance also gets State 20 but no DMG, however if State 20 is applied then it is removed and State 21 is applied instead (This part I have already working).

I dont see how it possible to do it without DMG so I can settle for 20% of the DMG dealt as Splash DMG.

Code:
``````<Custom Execution>
// Custom Execution is executed only once regardless of the scope size
user._targetX = -1; // set a variable to -1.
user._targetY = -1; // set a variable to -1.
</Custom Execution>

<Pre-Damage Eval>

// setting customizable variable. Feel free to modify
var farestDamageRatio = 0.2;
// if this variable = 1, damage at the border will be 0.
// if this variable = 2, damage at the border will be twice the damage at the center.
// if this variable = 0.5, damage at the border will be half the damage at the center.

// setting few variables. !! Don't touch !!
var height = this.item().aoeCircleHeightRate;
var x = user._targetX; // the variable with ID 1 is used for x
var y = user._targetY; // the variable with ID 2 is used for y
var targetX = target.aoeX(); // this is the x coord of the current target
var targetY = target.aoeY(); // this is the y coord of the current target

// Main target position storage :
if (x === -1 && y === -1){ // x and y = -1 only for the first target.
user._targetX = targetX; // store the x coord of the first target
user._targetY = targetY; // store the y coord of the first target
}

var mainX = user._targetX;
var mainY = user._targetY;

// Below computing the distance between main target and current target
// according to yanfly perspective geometry definition.
if (mainX > targetX) {
targetX = Math.min(mainX, target.aoeX() + target.aoeWidth() / 2);
} else if (mainX < targetX) {
targetX = Math.max(mainX, target.aoeX() - target.aoeWidth() / 2);
}
if (mainY > targetY) {
targetY = Math.min(mainY, target.aoeY());
} else if (mainY < targetY) {
targetY = Math.max(mainY, target.aoeY() - target.aoeHeight());
}
var x =  (targetX - mainX) * Math.cos(0) + (targetY - mainY) * Math.sin(0);
var y = -(targetX - mainX) * Math.sin(0) + (targetY - mainY) * Math.cos(0);
var c = (Math.pow(x, 2) / Math.pow(a, 2));
c += (Math.pow(y, 2) / Math.pow(b, 2));

// Below scalling the damages according to c.
// c = 0 for main target and c=1 for targets at the border of the aoe circle

c = Math.min(c,1);
c = c * farestDamageRatio;
value = Math.floor( value * ( 1 - c ) );
value = Math.max(value,0);

</Pre-Damage Eval>``````

I tried using this formula and set farestDamageRatio = .2 and it does roughly the same around of damage to both Bats. The states work just fine because I have it set up. Its the DMG im not understanding.

#### Lay

##### Veteran
Its progressive so if they already have the state it will get the next level up.
Didn't understand this sentence

I want the initial hit to do DMG to the target and apply State 20 on it, then anyone within 100 distance also gets State 20 but no DMG, however if State 20 is applied then it is removed and State 21 is applied instead (This part I have already working).
If I reformulate :
• apply damages only on the target
• don't apply damages on the other targets.
• apply the state20 on everyone with a distance below 100.
So you don't need to compute distances right ? You just need to make the distinction between the main target and the aoe targets right ?

set the AOE to 100 with the dedicated notetag.

JavaScript:
``````<Custom Execution>
// Custom Execution is executed only once regardless of the scope size
user._targetX = -1; // set a variable to -1.
user._targetY = -1; // set a variable to -1.
</Custom Execution>

<Pre-Damage Eval>
var x = user._targetX; // the variable with ID 1 is used for x
var y = user._targetY; // the variable with ID 2 is used for y
var targetX = target.aoeX(); // this is the x coord of the current target
var targetY = target.aoeY(); // this is the y coord of the current target

// Main target position storage :
if (x === -1 && y === -1){ // x and y = -1 only for the first target.
user._targetX = targetX; // store the x coord of the first target
user._targetY = targetY; // store the y coord of the first target
} else {
value = 0;
}
</Pre-Damage Eval>``````

Edit the script to take into account the states to apply or remove or replace.

#### Icenick

##### Veteran
Didn't understand this sentence

If I reformulate :
• apply damages only on the target
• don't apply damages on the other targets.
• apply the state20 on everyone with a distance below 100.
So you don't need to compute distances right ? You just need to make the distinction between the main target and the aoe targets right ?

set the AOE to 100 with the dedicated notetag.

JavaScript:
``````<Custom Execution>
// Custom Execution is executed only once regardless of the scope size
user._targetX = -1; // set a variable to -1.
user._targetY = -1; // set a variable to -1.
</Custom Execution>

<Pre-Damage Eval>
var x = user._targetX; // the variable with ID 1 is used for x
var y = user._targetY; // the variable with ID 2 is used for y
var targetX = target.aoeX(); // this is the x coord of the current target
var targetY = target.aoeY(); // this is the y coord of the current target

// Main target position storage :
if (x === -1 && y === -1){ // x and y = -1 only for the first target.
user._targetX = targetX; // store the x coord of the first target
user._targetY = targetY; // store the y coord of the first target
} else {
value = 0;
}
</Pre-Damage Eval>``````

Edit the script to take into account the states to apply or remove or replace.

Awesome yes that works for my purposes!
If I understand I can do this to set the dmg to 20%. I tested it with 50% and worked great.
Code:
``````var dmg = Math.ceil(0.2 * value)
if (x === -1 && y === -1){ // x and y = -1 only for the first target.
user._targetX = targetX; // store the x coord of the first target
user._targetY = targetY; // store the y coord of the first target
} else {
value = dmg;
}``````

Just out of curiosity when I had value = 0, it would show 0 damage is there any way to hide the 0 damage?

#### Lay

##### Veteran
If I understand I can do this to set the dmg to 20%. I tested it with 50% and worked great.
absolutely

Just out of curiosity when I had value = 0, it would show 0 damage is there any way to hide the 0 damage?
With the best of my knowledge, I think it is not possible with SkillCore only. Maybe you can try to play with the action sequences. An other alternative is to split the skill into two skills, one that deals no damage and that apply the state and an other that deals damage on a single target and make the skill that deal no damage to force an action with the damage skill on the desire target...

Well in fact I don't know xD

### Latest Profile Posts

How would you judge a game you played? Art/Graphics? Story? Gameplay?
Learn MV sales goal = 2%
NSFW game sales goal = 2500% (no jokes)
After gathering, sorting out & reconsidering hundreds of enemy battlers over the last two das, finally my favorite part begins: Inventing names and lore for them all
I'm running a sale for Learn RPG Maker MV on Itch.io, can I compete with NSFW games earning goals?