Beware of Shady Plugin Seller/Thief


A plugin seller by the name of Isabella Ava (aka master2015hp) was questioned to clarify why a certain plugin had the overly similar appearance of the Yanfly Engine Plugins library’s Aftermath Level Up.

Here are the comparisons:


What it looks like, to quote some other users, is that parts of the Aftermath Level Up plugin is cut and pasted on top of Olivia’s Victory UI. It’s one thing if the code was made entirely by themselves, but there is a distinct way the numbers appear in the Yanfly Aftermath Level Up plugin that also resurfaces on the suspect’s. No permission has been asked from the individual nor granted to the individual to resell the code either.

When the suspect was probed as to why this is, here is the response:


To which, Irina mentions that Olivia’s Victory UI cannot exist in the same project as Yanfly’s Victory Aftermath without conflicts. As Aftermath Level Up is an extension plugin of Yanfly’s Victory Aftermath, there’s no way for the suspected plugin to be able to call from it, which means the code has be have been taken from Aftermath Level Up.

When Yanfly asked the individual if the code can be compared, the individual responded as such:


Had the individual actually crafted the code themselves, there’d be nothing to be afraid of here, and they’d have cleared themselves of suspicion. Instead, leaving such a nasty message in hopes of a desperate sale puts them in the limelight all the more.

Now with code comparisons:


Window_VictoryLevelUp.prototype.refresh = function() {
    var bitmap = ImageManager.loadFace(this._actor.faceName());
    if (bitmap.width <= 0) return setTimeout(this.refresh.bind(this), 5);

Here is theirs:

Window_ActorLevelUp.prototype.refresh = function() {
	this.drawBackgroundRewardStrip(actorStat_x - 20, actorStat_y - this.lineHeight(), actorStat_w - 100, 100);
	this.contents.fontSize = cFontSize;
	this.drawText(str1, actorStat_x - 20 + ckeIndent * 5, actorStat_y - this.lineHeight(), actorStat_w - 100, this.lineHeight(), 'left');

Looks innocent enough, right?

But ever heard that phrase, “to hide a body, you best chop it up into smaller pieces first?”

Turns out they did just that.

Window_ActorLevelUp.prototype.createSubWindows = function() {

They split up the methods across three (unnecessarily) created windows to split up the functions.

Now, let’s take a look at how YEP Aftermath Level Up handles drawing each of the parameters:

Window_VictoryLevelUp.prototype.drawStatChanges = function() {
    this.contents.fontSize = Yanfly.Param.ALUFontSize;
    for (var i = 0; i < 9; ++i) {
      var rect = this.itemRect(i);
      this.drawParamName(i, rect);
      this.drawCurrentParam(i, rect);
      this.drawNewParam(i, rect);
      this.drawParamDifference(i, rect);

Keep this in mind that this is not the standard way of looping through all the parameters. This is just the one way I did it, this one particular time for this one particular plugin. There are only 8 parameters out there, which means only numbers 0 through 7 have to be looped.

So then, why is it done here?

Window_ActorStats.prototype.createSubWindows = function() {
	var statData = "";
	for(i = 0; i < 9; i++) {
		switch(i) {
			case 0: statData = "Level"; break;
			case 1: statData = "Max HP"; break;
			case 2: statData = "Max MP"; break;
			case 3: statData = "ATK"; break;
			case 4: statData = "DEF"; break;
			case 5: statData = "MAT"; break;
			case 6: statData = "MDF"; break;
			case 7: statData = "AGI"; break;
			case 8: statData = "LUK"; break;
			default: statData = "Test";
		this._subWindows = new Window_SubStats(statData);
		subStat_y += this.lineHeight();

Where in which, the standard thing to do would be to draw the level first, then loop 0 through 7 for the parameters? Why follow it the way I did it? If it’s because “there’s only so many ways to do x”, this is the usual excuse given by anyone who plagiarizes from another. The truth is, there’s many ways to handle this code, yet, they choose to do it like mine with the same strange loop I’ve made. Wonder why?

Now, let’s go take a look back at the code comparisons. Now, what they did this time was the complete opposite of what I did. Where I wrote things out in an object oriented manner, they decided to consolidate it into one thing. Why? Perhaps to look different? Who knows. But let’s see:

Window_SubStats.prototype.drawData = function(statData){
	this.drawText(this.title, ckeIndent, 0, this.width, this.height, 'left');
	this.drawText(String(this.valueOld), 150, 0, this.width, this.height, 'left');
	if (this.valueOld != this.value) {
		this.drawText('→', 200, 0, this.width, this.height, 'left');
		this.drawText(String(this.value), 250, 0, this.width, this.height, 'left');
		var str = '(+' + String(this.value - this.valueOld) + ')';
		this.drawText(str, 300, 0, this.width, this.height, 'left');

These come from the YEP Aftermath Level Up functions, but in a stripped down manner, free of any Plugin Parameter fluff in the code and hard values for the coordinates. Let’s see what happens when I do the same, too.

Window_VictoryLevelUp.prototype.drawItem = function(paramId, x, y) {
	var arrow = '\u2192';
	var index = paramId - 1;
	var newValue = this._actor._postVictoryParams[index];
	var diffvalue = newValue - this._actor._preVictoryParams[index];
	this.drawText(TextManager.param(index), 0, y, this._paramNameWidth);
	this.drawText(this._actor._preVictoryParams[index], 150, y, this._paramValueWidth, 'right');
	if (diffvalue !== 0) {
		this.drawText(arrow, 200, y, dw, 'center');
		this.drawText(this._actor._postVictoryParams[index], 250, y, this._paramValueWidth, 'right');
		var text = '(' + (diffValue >= 0 ? '+' : '-') + diffvalue + ')';
		this.drawText(text, 300, y, this._bonusValueWidth, 'left');

Looks similar?


The code I’ve added there is essentially the last line of all the functions within the previous loop I’ve made with inserted variables where they have to be and arbitrary numbers from 0 to 300 in increments of 50. Suddenly, it seems pretty close, huh?

The only real differences is that there’s errors in Ava’s code (since widths and heights are calculated like such) and they automatically position everything to left text alignment. But other than that, the same.

It’s easy to say that this would be the general way of handling it, but then, you’d have to consider the point I made before: the strange for loop of going from 0 to 9 instead of the norm. In short, the more questions you ask about the oddities, the more awkward it gets when trying to figure out where the reasoning behind it comes from (aka from YEP Aftermath Level Up).

There’s more examples found in the code like with the skill window, but I’ll spare you all the details since that’s some other levels and layers that I’d have to dig through and all that’d accomplish is beating a dead horse.

Other suspicious plugins of theirs also include the “addon for YEP Grid Free Doodad”, which as far as Team Yanfly can tell, only does as far as changing up some shortcut keys to perform other actions by Yanfly’s code. This plugin of theirs is also being sold.

Another one being sold is their Persistent Switches, which (though unconfirmed) may have been an alteration of Endless Illusion Software’s Persistent Switches.

There may be other plugins out there under the same nature.

We STRONGLY encourage you users to stay away from this “plugin developer” as their actions and products are extremely suspicious.


umm hi ! I draw monsters !

Leave a Reply

Your email address will not be published. Required fields are marked *

This site uses Akismet to reduce spam. Learn how your comment data is processed.