//=============================================================================

// rmmz_scenes.js v1.8.0
//=============================================================================

//-----------------------------------------------------------------------------
// Scene_Base
//
// The superclass of all scenes within the game.

function Scene_Base() {
[Link](...arguments);
}

Scene_Base.prototype = [Link]([Link]);
Scene_Base.[Link] = Scene_Base;

Scene_Base.[Link] = function() {
[Link](this);
this._started = false;
this._active = false;
this._fadeSign = 0;
this._fadeDuration = 0;
this._fadeWhite = 0;
this._fadeOpacity = 0;
[Link]();
};

Scene_Base.[Link] = function() {
//
};

Scene_Base.[Link] = function() {
return this._active;
};

Scene_Base.[Link] = function() {
return (
[Link]() &&
[Link]() &&
[Link]()
);
};

Scene_Base.[Link] = function() {
this._started = true;
this._active = true;
};

Scene_Base.[Link] = function() {
[Link]();
[Link]();
[Link]();
[Link]();
};

Scene_Base.[Link] = function() {
this._active = false;
};
Scene_Base.[Link] = function() {
return this._started;
};

Scene_Base.[Link] = function() {
return [Link]();
};

Scene_Base.[Link] = function() {
return this._fadeDuration > 0;
};

Scene_Base.[Link] = function() {
//
};

Scene_Base.[Link] = function() {
this._windowLayer = new WindowLayer();
this._windowLayer.x = ([Link] - [Link]) / 2;
this._windowLayer.y = ([Link] - [Link]) / 2;
[Link](this._windowLayer);
};

Scene_Base.[Link] = function(window) {
this._windowLayer.addChild(window);
};

Scene_Base.[Link] = function(duration, white) {

this._fadeSign = 1;
this._fadeDuration = duration || 30;
this._fadeWhite = white;
this._fadeOpacity = 255;
[Link]();
};

Scene_Base.[Link] = function(duration, white) {

this._fadeSign = -1;
this._fadeDuration = duration || 30;
this._fadeWhite = white;
this._fadeOpacity = 0;
[Link]();
};

Scene_Base.[Link] = function() {
this._colorFilter = new ColorFilter();
[Link] = [this._colorFilter];
};

Scene_Base.[Link] = function() {
const c = this._fadeWhite ? 255 : 0;
const blendColor = [c, c, c, this._fadeOpacity];
this._colorFilter.setBlendColor(blendColor);
};

Scene_Base.[Link] = function() {
if (this._fadeDuration > 0) {
const d = this._fadeDuration;
if (this._fadeSign > 0) {
this._fadeOpacity -= this._fadeOpacity / d;
 } else {
this._fadeOpacity += (255 - this._fadeOpacity) / d;
}
this._fadeDuration--;
}
};

Scene_Base.[Link] = function() {
for (const child of [Link]) {
if ([Link]) {
[Link]();
}
}
};

Scene_Base.[Link] = function() {
[Link]();
};

Scene_Base.[Link] = function() {
if ($[Link]()) {
[Link](Scene_Gameover);
}
};

Scene_Base.[Link] = function() {
const time = [Link]() / 60;
[Link](time);
[Link](time);
[Link](time);
[Link]([Link]());
};

Scene_Base.[Link] = function() {
return 24;
};

Scene_Base.[Link] = function() {
return [Link]() * 2;
};

Scene_Base.[Link] = function(sprite) {
const ratioX = [Link] / [Link];
const ratioY = [Link] / [Link];
const scale = [Link](ratioX, ratioY, 1.0);
[Link].x = scale;
[Link].y = scale;
};

Scene_Base.[Link] = function(sprite) {
sprite.x = [Link] / 2;
sprite.y = [Link] / 2;
[Link].x = 0.5;
[Link].y = 0.5;
};

Scene_Base.[Link] = function() {
return true;
};
Scene_Base.[Link] = function() {
return false;
};

Scene_Base.[Link] = function() {
return true;
};

Scene_Base.[Link] = function() {
return 240;
};

Scene_Base.[Link] = function() {
if ([Link]()) {
return [Link] - [Link]();
} else {
return 0;
}
};

Scene_Base.[Link] = function() {
return [Link]() + [Link]();
};

Scene_Base.[Link] = function() {
return 52;
};

Scene_Base.[Link] = function() {
const offsetY = [Link](([Link]() - 48) / 2);
return [Link]() + offsetY;
};

Scene_Base.[Link] = function(numLines, selectable) {

if (selectable) {
return Window_Selectable.[Link](numLines);
} else {
return Window_Base.[Link](numLines);
}
};

Scene_Base.[Link] = function() {
if ([Link]()) {
[Link]();
}
};

Scene_Base.[Link] = function() {
return (
![Link]() &&
![Link]() &&
$[Link]() &&
$[Link]()
);
};

Scene_Base.[Link] = function() {
$[Link]();
 [Link](0)
.then(() => [Link]())
.catch(() => [Link]());
};

Scene_Base.[Link] = function() {
//
};

Scene_Base.[Link] = function() {
//
};

//-----------------------------------------------------------------------------
// Scene_Boot
//
// The scene class for initializing the entire game.

function Scene_Boot() {
[Link](...arguments);
}

Scene_Boot.prototype = [Link](Scene_Base.prototype);
Scene_Boot.[Link] = Scene_Boot;

Scene_Boot.[Link] = function() {
Scene_Base.[Link](this);
this._databaseLoaded = false;
};

Scene_Boot.[Link] = function() {
Scene_Base.[Link](this);
[Link]();
[Link]();
};

Scene_Boot.[Link] = function() {
if (!this._databaseLoaded) {
if (
[Link]() &&
[Link]()
) {
this._databaseLoaded = true;
[Link]();
}
return false;
}
return Scene_Base.[Link](this) && [Link]();
};

Scene_Boot.[Link] = function() {
[Link]();
[Link]();
[Link]();
[Link]();
};

Scene_Boot.[Link] = function() {
const hasImages = $[Link];
 const hasAudio = $[Link];
const key = $[Link];
[Link](hasImages, hasAudio, key);
};

Scene_Boot.[Link] = function() {
[Link]();
[Link]("IconSet");
};

Scene_Boot.[Link] = function() {
[Link]();
[Link]();
};

Scene_Boot.[Link] = function() {
const advanced = $[Link];
[Link]("rmmz-mainfont", [Link]);
[Link]("rmmz-numberfont", [Link]);
};

Scene_Boot.[Link] = function() {
return [Link]() && [Link]();
};

Scene_Boot.[Link] = function() {
Scene_Base.[Link](this);
[Link]();
if ([Link]()) {
[Link]();
[Link](Scene_Battle);
} else if ([Link]()) {
[Link]();
[Link](Scene_Map);
} else if ([Link]()) {
[Link]();
[Link]();
[Link](Scene_Map);
} else {
[Link]();
}
[Link]();
[Link]();
};

Scene_Boot.[Link] = function() {
[Link]();
[Link]();
Window_TitleCommand.initCommandPosition();
[Link](Scene_Splash);
};

Scene_Boot.[Link] = function() {
const screenWidth = $[Link];
const screenHeight = $[Link];
[Link](screenWidth, screenHeight);
[Link] = [Link]();
[Link]();
[Link]();
};

Scene_Boot.[Link] = function() {
const uiAreaWidth = $[Link];
const uiAreaHeight = $[Link];
const boxMargin = 4;
[Link] = uiAreaWidth - boxMargin * 2;
[Link] = uiAreaHeight - boxMargin * 2;
};

Scene_Boot.[Link] = function() {
if ([Link]()) {
const scale = [Link]();
const xDelta = [Link] * scale - [Link];
const yDelta = [Link] * scale - [Link];
[Link](-xDelta / 2, -yDelta / 2);
[Link](xDelta, yDelta);
}
};

Scene_Boot.[Link] = function() {
if ("screenScale" in $[Link]) {
return $[Link];
} else {
return 1;
}
};

Scene_Boot.[Link] = function() {
[Link] = $[Link];
};

Scene_Boot.[Link] = function() {
if ($[Link] === 0) {
throw new Error("Player's starting position is not set");
}
};

//-----------------------------------------------------------------------------
// Scene_Splash
//
// The scene class of the splash screen.

function Scene_Splash() {
[Link](...arguments);
}

Scene_Splash.prototype = [Link](Scene_Base.prototype);
Scene_Splash.[Link] = Scene_Splash;

Scene_Splash.[Link] = function() {
Scene_Base.[Link](this);
[Link]();
};

Scene_Splash.[Link] = function() {
Scene_Base.[Link](this);
if ([Link]()) {
[Link]();
 }
};

Scene_Splash.[Link] = function() {
Scene_Base.[Link](this);
if ([Link]()) {
[Link]();
[Link]([Link](), false);
}
};

Scene_Splash.[Link] = function() {
Scene_Base.[Link](this);
if ([Link]()) {
if (![Link]()) {
[Link]();
}
[Link]();
}
};

Scene_Splash.[Link] = function() {
Scene_Base.[Link](this);
if ([Link]()) {
[Link]([Link]());
}
};

Scene_Splash.[Link] = function() {
this._backSprite = new Sprite();
this._backSprite.bitmap = [Link]("Splash");
[Link](this._backSprite);
};

Scene_Splash.[Link] = function() {
[Link](this._backSprite);
[Link](this._backSprite);
};

Scene_Splash.[Link] = function() {
return $[Link];
};

Scene_Splash.[Link] = function() {
if ([Link]()) {
this._waitCount = 120;
} else {
this._waitCount = 0;
}
};

Scene_Splash.[Link] = function() {
if (this._waitCount > 0) {
this._waitCount--;
return true;
}
return false;
};
Scene_Splash.[Link] = function() {
if ([Link]("ok") || [Link]()) {
this._waitCount = 0;
}
};

Scene_Splash.[Link] = function() {
[Link](Scene_Title);
};

//-----------------------------------------------------------------------------
// Scene_Title
//
// The scene class of the title screen.

function Scene_Title() {
[Link](...arguments);
}

Scene_Title.prototype = [Link](Scene_Base.prototype);
Scene_Title.[Link] = Scene_Title;

Scene_Title.[Link] = function() {
Scene_Base.[Link](this);
};

Scene_Title.[Link] = function() {
Scene_Base.[Link](this);
[Link]();
[Link]();
[Link]();
[Link]();
};

Scene_Title.[Link] = function() {
Scene_Base.[Link](this);
[Link]();
[Link]();
[Link]();
[Link]([Link](), false);
};

Scene_Title.[Link] = function() {
if (![Link]()) {
this._commandWindow.open();
}
Scene_Base.[Link](this);
};

Scene_Title.[Link] = function() {
return (
this._commandWindow.isClosing() ||
Scene_Base.[Link](this)
);
};

Scene_Title.[Link] = function() {
Scene_Base.[Link](this);
[Link]();
 if (this._gameTitleSprite) {
this._gameTitleSprite.[Link]();
}
};

Scene_Title.[Link] = function() {
this._backSprite1 = new Sprite(
ImageManager.loadTitle1($dataSystem.title1Name)
);
this._backSprite2 = new Sprite(
ImageManager.loadTitle2($dataSystem.title2Name)
);
[Link](this._backSprite1);
[Link](this._backSprite2);
};

Scene_Title.[Link] = function() {
this._gameTitleSprite = new Sprite(
new Bitmap([Link], [Link])
);
[Link](this._gameTitleSprite);
if ($[Link]) {
[Link]();
}
};

Scene_Title.[Link] = function() {
const x = 20;
const y = [Link] / 4;
const maxWidth = [Link] - x * 2;
const text = $[Link];
const bitmap = this._gameTitleSprite.bitmap;
[Link] = $[Link]();
[Link] = "black";
[Link] = 8;
[Link] = 72;
[Link](text, x, y, maxWidth, 48, "center");
};

Scene_Title.[Link] = function() {
[Link](this._backSprite1);
[Link](this._backSprite2);
[Link](this._backSprite1);
[Link](this._backSprite2);
};

Scene_Title.[Link] = function() {
const background = $[Link];
const rect = [Link]();
this._commandWindow = new Window_TitleCommand(rect);
this._commandWindow.setBackgroundType(background);
this._commandWindow.setHandler("newGame", [Link](this));
this._commandWindow.setHandler("continue", [Link](this));
this._commandWindow.setHandler("options", [Link](this));
[Link](this._commandWindow);
};

Scene_Title.[Link] = function() {
const offsetX = $[Link];
 const offsetY = $[Link];
const ww = [Link]();
const wh = [Link](3, true);
const wx = ([Link] - ww) / 2 + offsetX;
const wy = [Link] - wh - 96 + offsetY;
return new Rectangle(wx, wy, ww, wh);
};

Scene_Title.[Link] = function() {
[Link]();
this._commandWindow.close();
[Link]();
[Link](Scene_Map);
};

Scene_Title.[Link] = function() {
this._commandWindow.close();
[Link](Scene_Load);
};

Scene_Title.[Link] = function() {
this._commandWindow.close();
[Link](Scene_Options);
};

Scene_Title.[Link] = function() {
[Link]($[Link]);
[Link]();
[Link]();
};

//-----------------------------------------------------------------------------
// Scene_Message
//
// The superclass of Scene_Map and Scene_Battle.

function Scene_Message() {
[Link](...arguments);
}

Scene_Message.prototype = [Link](Scene_Base.prototype);
Scene_Message.[Link] = Scene_Message;

Scene_Message.[Link] = function() {
Scene_Base.[Link](this);
};

Scene_Message.[Link] = function() {
return this._messageWindow.isClosing();
};

Scene_Message.[Link] = function() {
[Link]();
[Link]();
[Link]();
[Link]();
[Link]();
[Link]();
[Link]();
 [Link]();
};

Scene_Message.[Link] = function() {
const rect = [Link]();
this._messageWindow = new Window_Message(rect);
[Link](this._messageWindow);
};

Scene_Message.[Link] = function() {
const ww = [Link];
const wh = [Link](4, false) + 8;
const wx = ([Link] - ww) / 2;
const wy = 0;
return new Rectangle(wx, wy, ww, wh);
};

Scene_Message.[Link] = function() {
const rect = [Link]();
this._scrollTextWindow = new Window_ScrollText(rect);
[Link](this._scrollTextWindow);
};

Scene_Message.[Link] = function() {
const wx = 0;
const wy = 0;
const ww = [Link];
const wh = [Link];
return new Rectangle(wx, wy, ww, wh);
};

Scene_Message.[Link] = function() {
const rect = [Link]();
this._goldWindow = new Window_Gold(rect);
this._goldWindow.openness = 0;
[Link](this._goldWindow);
};

Scene_Message.[Link] = function() {
const ww = [Link]();
const wh = [Link](1, true);
const wx = [Link] - ww;
const wy = 0;
return new Rectangle(wx, wy, ww, wh);
};

Scene_Message.[Link] = function() {
this._nameBoxWindow = new Window_NameBox();
[Link](this._nameBoxWindow);
};

Scene_Message.[Link] = function() {
this._choiceListWindow = new Window_ChoiceList();
[Link](this._choiceListWindow);
};

Scene_Message.[Link] = function() {
this._numberInputWindow = new Window_NumberInput();
[Link](this._numberInputWindow);
};

Scene_Message.[Link] = function() {
const rect = [Link]();
this._eventItemWindow = new Window_EventItem(rect);
[Link](this._eventItemWindow);
};

Scene_Message.[Link] = function() {
const wx = 0;
const wy = 0;
const ww = [Link];
const wh = [Link](4, true);
return new Rectangle(wx, wy, ww, wh);
};

Scene_Message.[Link] = function() {
const messageWindow = this._messageWindow;
[Link](this._goldWindow);
[Link](this._nameBoxWindow);
[Link](this._choiceListWindow);
[Link](this._numberInputWindow);
[Link](this._eventItemWindow);
this._nameBoxWindow.setMessageWindow(messageWindow);
this._choiceListWindow.setMessageWindow(messageWindow);
this._numberInputWindow.setMessageWindow(messageWindow);
this._eventItemWindow.setMessageWindow(messageWindow);
};

Scene_Message.[Link] = function() {
this._messageWindow.cancelWait();
};

//-----------------------------------------------------------------------------
// Scene_Map
//
// The scene class of the map screen.

function Scene_Map() {
[Link](...arguments);
}

Scene_Map.prototype = [Link](Scene_Message.prototype);
Scene_Map.[Link] = Scene_Map;

Scene_Map.[Link] = function() {
Scene_Message.[Link](this);
this._waitCount = 0;
this._encounterEffectDuration = 0;
this._mapLoaded = false;
this._touchCount = 0;
this._menuEnabled = false;
};

Scene_Map.[Link] = function() {
Scene_Message.[Link](this);
this._transfer = $[Link]();
this._lastMapWasNull = !$dataMap;
if (this._transfer) {
 [Link]($[Link]());
[Link]();
} else {
[Link]($[Link]());
}
};

Scene_Map.[Link] = function() {
if (!this._mapLoaded && [Link]()) {
[Link]();
this._mapLoaded = true;
}
return this._mapLoaded && Scene_Message.[Link](this);
};

Scene_Map.[Link] = function() {
if (this._transfer) {
$[Link]();
}
[Link]();
};

Scene_Map.[Link] = function() {
[Link]();
[Link]();
};

Scene_Map.[Link] = function() {
Scene_Message.[Link](this);
[Link]();
if (this._transfer) {
[Link]();
[Link]();
} else if ([Link]()) {
[Link]([Link](), false);
}
[Link] = false;
};

Scene_Map.[Link] = function() {
this._mapNameWindow.open();
$[Link]();
if ([Link]()) {
[Link]();
}
};

Scene_Map.[Link] = function() {
return !this._lastMapWasNull;
};

Scene_Map.[Link] = function() {
Scene_Message.[Link](this);
[Link]();
[Link]();
[Link]();
[Link]();
if ([Link]()) {
[Link]();
 } else if ([Link](Scene_Battle)) {
[Link]();
}
[Link]();
};

Scene_Map.[Link] = function() {
if ([Link]()) {
[Link]();
[Link]();
}
[Link]();
};

Scene_Map.[Link] = function() {
$[Link]([Link]());
$[Link]([Link]());
$[Link]([Link]());
$[Link]();
};

Scene_Map.[Link] = function() {
return [Link]() && ![Link]();
};

Scene_Map.[Link] = function() {
return (
$[Link]() &&
![Link]() &&
([Link]("ok") || [Link]())
);
};

Scene_Map.[Link] = function() {
Scene_Message.[Link](this);
$[Link]();
this._mapNameWindow.close();
if ([Link]()) {
[Link]([Link](), false);
} else if ([Link](Scene_Map)) {
[Link]();
} else if ([Link](Scene_Battle)) {
[Link]();
}
};

Scene_Map.[Link] = function() {
return (
[Link]() ||
this._waitCount > 0 ||
this._encounterEffectDuration > 0 ||
Scene_Message.[Link](this)
);
};

Scene_Map.[Link] = function() {
Scene_Message.[Link](this);
if () {
this._spriteset.update();
 this._mapNameWindow.hide();
[Link]();
[Link]();
}
$[Link]();
};

Scene_Map.[Link] = function() {
return (
[Link](Scene_Battle) ||
[Link](Scene_Load)
);
};

Scene_Map.[Link] = function() {
return (
[Link](Scene_Title) ||
[Link](Scene_Gameover)
);
};

Scene_Map.[Link] = function() {
if (this._waitCount > 0) {
this._waitCount--;
return true;
}
return false;
};

Scene_Map.[Link] = function() {
if ([Link]()) {
[Link]();
} else {
$[Link]();
this._touchCount = 0;
}
};

Scene_Map.[Link] = function() {
if (this._menuButton) {
const menuEnabled = [Link]();
if (menuEnabled === this._menuEnabled) {
this._menuButton.visible = this._menuEnabled;
} else {
this._menuEnabled = menuEnabled;
}
}
};

Scene_Map.[Link] = function() {
if (this._menuButton) {
this._menuButton.visible = false;
this._menuEnabled = false;
}
};

Scene_Map.[Link] = function() {
if ($[Link]()) {
this._mapNameWindow.close();
 }
};

Scene_Map.[Link] = function() {
return $[Link]() && !$[Link]();
};

Scene_Map.[Link] = function() {
return [Link]() && $[Link]();
};

Scene_Map.[Link] = function() {
if ([Link]() || this._touchCount > 0) {
if ([Link]() && ![Link]()) {
if (this._touchCount === 0 || this._touchCount >= 15) {
[Link]();
}
this._touchCount++;
} else {
this._touchCount = 0;
}
}
};

Scene_Map.[Link] = function() {
return this._menuButton && this._menuButton.isPressed();
};

Scene_Map.[Link] = function() {
const x = $[Link](TouchInput.x);
const y = $[Link](TouchInput.y);
$[Link](x, y);
};

Scene_Map.[Link] = function() {
return [Link]() && !$[Link]();
};

Scene_Map.[Link] = function() {
[Link]();
if (![Link]()) {
[Link]();
}
if (![Link]()) {
[Link]();
}
if (![Link]()) {
[Link]();
}
if (![Link]()) {
[Link]();
}
};

Scene_Map.[Link] = function() {
[Link]();
[Link]();
[Link]();
[Link]();
};

Scene_Map.[Link] = function() {
this._spriteset = new Spriteset_Map();
[Link](this._spriteset);
this._spriteset.update();
};

Scene_Map.[Link] = function() {
[Link]();
Scene_Message.[Link](this);
};

Scene_Map.[Link] = function() {
const rect = [Link]();
this._mapNameWindow = new Window_MapName(rect);
[Link](this._mapNameWindow);
};

Scene_Map.[Link] = function() {
const wx = 0;
const wy = 0;
const ww = 360;
const wh = [Link](1, false);
return new Rectangle(wx, wy, ww, wh);
};

Scene_Map.[Link] = function() {
if ([Link]) {
[Link]();
}
};

Scene_Map.[Link] = function() {
this._menuButton = new Sprite_Button("menu");
this._menuButton.x = [Link] - this._menuButton.width - 4;
this._menuButton.y = [Link]();
this._menuButton.visible = false;
[Link](this._menuButton);
};

Scene_Map.[Link] = function() {
if ($[Link]()) {
[Link](Scene_Map);
}
};

Scene_Map.[Link] = function() {
if ($[Link]()) {
[Link](Scene_Battle);
}
};

Scene_Map.[Link] = function() {
if ([Link]()) {
if ([Link]()) {
[Link] = true;
}
if ([Link] && !$[Link]()) {
 [Link]();
}
} else {
[Link] = false;
}
};

Scene_Map.[Link] = function() {
return [Link]("menu") || [Link]();
};

Scene_Map.[Link] = function() {
[Link]();
[Link](Scene_Menu);
Window_MenuCommand.initCommandPosition();
$[Link]();
this._mapNameWindow.hide();
this._waitCount = 2;
};

Scene_Map.[Link] = function() {
if ([Link]()) {
[Link](Scene_Debug);
}
};

Scene_Map.[Link] = function() {
return [Link]("debug") && $[Link]();
};

Scene_Map.[Link] = function() {
const fadeType = $[Link]();
switch (fadeType) {
case 0:
case 1:
[Link]([Link](), fadeType === 1);
break;
}
};

Scene_Map.[Link] = function() {
const fadeType = $[Link]();
switch (fadeType) {
case 0:
case 1:
[Link]([Link](), fadeType === 1);
break;
}
};

Scene_Map.[Link] = function() {
[Link]();
[Link]();
[Link]();
[Link]();
this._mapNameWindow.hide();
};

Scene_Map.[Link] = function() {
 if ()) {
[Link]();
}
[Link]();
[Link]();
[Link]();
};

Scene_Map.[Link] = function() {
this._spriteset.hideCharacters();
this._encounterEffectDuration = [Link]();
};

Scene_Map.[Link] = function() {
if (this._encounterEffectDuration > 0) {
this._encounterEffectDuration--;
const speed = [Link]();
const n = speed - this._encounterEffectDuration;
const p = n / speed;
const q = ((p - 1) * 20 * p + 5) * p + 1;
const zoomX = $[Link]();
const zoomY = $[Link]() - 24;
if (n === 2) {
$[Link](zoomX, zoomY, 1);
[Link]();
[Link](speed / 2);
}
$[Link](zoomX, zoomY, q);
if (n === [Link](speed / 6)) {
[Link](speed / 2);
}
if (n === [Link](speed / 2)) {
[Link]();
[Link]([Link]());
}
}
};

Scene_Map.[Link] = function() {
this._windowLayer.visible = false;
[Link]();
this._windowLayer.visible = true;
};

Scene_Map.[Link] = function(duration) {
const color = [255, 255, 255, 255];
$[Link](color, duration);
};

Scene_Map.[Link] = function() {
return 60;
};

//-----------------------------------------------------------------------------
// Scene_MenuBase
//
// The superclass of all the menu-type scenes.

function Scene_MenuBase() {
 [Link](...arguments);
}

Scene_MenuBase.prototype = [Link](Scene_Base.prototype);
Scene_MenuBase.[Link] = Scene_MenuBase;

Scene_MenuBase.[Link] = function() {
Scene_Base.[Link](this);
};

Scene_MenuBase.[Link] = function() {
Scene_Base.[Link](this);
[Link]();
[Link]();
[Link]();
[Link]();
};

Scene_MenuBase.[Link] = function() {
Scene_Base.[Link](this);
[Link]();
};

Scene_MenuBase.[Link] = function() {
if ([Link]()) {
return [Link]();
} else if ([Link]()) {
return 0;
} else {
return [Link]();
}
};

Scene_MenuBase.[Link] = function() {
return [Link]() + [Link]();
};

Scene_MenuBase.[Link] = function() {
return [Link](2, false);
};

Scene_MenuBase.[Link] = function() {
if (![Link]()) {
return [Link]();
} else if ([Link]()) {
return 0;
} else {
return [Link]();
}
};

Scene_MenuBase.[Link] = function() {
return [Link]() + [Link]();
};

Scene_MenuBase.[Link] = function() {
return [Link] - [Link]() - [Link]();
};
Scene_MenuBase.[Link] = function() {
return this._actor;
};

Scene_MenuBase.[Link] = function() {
this._actor = $[Link]();
};

Scene_MenuBase.[Link] = function() {
this._backgroundFilter = new [Link]();
this._backgroundSprite = new Sprite();
this._backgroundSprite.bitmap = [Link]();
this._backgroundSprite.filters = [this._backgroundFilter];
[Link](this._backgroundSprite);
[Link](192);
};

Scene_MenuBase.[Link] = function(opacity) {
this._backgroundSprite.opacity = opacity;
};

Scene_MenuBase.[Link] = function() {
const rect = [Link]();
this._helpWindow = new Window_Help(rect);
[Link](this._helpWindow);
};

Scene_MenuBase.[Link] = function() {
const wx = 0;
const wy = [Link]();
const ww = [Link];
const wh = [Link]();
return new Rectangle(wx, wy, ww, wh);
};

Scene_MenuBase.[Link] = function() {
if ([Link]) {
if ([Link]()) {
[Link]();
}
if ([Link]()) {
[Link]();
}
}
};

Scene_MenuBase.[Link] = function() {
return true;
};

Scene_MenuBase.[Link] = function() {
this._cancelButton = new Sprite_Button("cancel");
this._cancelButton.x = [Link] - this._cancelButton.width - 4;
this._cancelButton.y = [Link]();
[Link](this._cancelButton);
};

Scene_MenuBase.[Link] = function() {
return false;
};

Scene_MenuBase.[Link] = function() {
this._pageupButton = new Sprite_Button("pageup");
this._pageupButton.x = 4;
this._pageupButton.y = [Link]();
const pageupRight = this._pageupButton.x + this._pageupButton.width;
this._pagedownButton = new Sprite_Button("pagedown");
this._pagedownButton.x = pageupRight + 4;
this._pagedownButton.y = [Link]();
[Link](this._pageupButton);
[Link](this._pagedownButton);
this._pageupButton.setClickHandler([Link](this));
this._pagedownButton.setClickHandler([Link](this));
};

Scene_MenuBase.[Link] = function() {
if (this._pageupButton && this._pagedownButton) {
const enabled = [Link]();
this._pageupButton.visible = enabled;
this._pagedownButton.visible = enabled;
}
};

Scene_MenuBase.[Link] = function() {
return true;
};

Scene_MenuBase.[Link] = function() {
$[Link]();
[Link]();
[Link]();
};

Scene_MenuBase.[Link] = function() {
$[Link]();
[Link]();
[Link]();
};

Scene_MenuBase.[Link] = function() {
[Link]();
};

//-----------------------------------------------------------------------------
// Scene_Menu
//
// The scene class of the menu screen.

function Scene_Menu() {
[Link](...arguments);
}

Scene_Menu.prototype = [Link](Scene_MenuBase.prototype);
Scene_Menu.[Link] = Scene_Menu;

Scene_Menu.[Link] = function() {
Scene_MenuBase.[Link](this);
};
Scene_Menu.[Link] = function() {
return 0;
};

Scene_Menu.[Link] = function() {
Scene_MenuBase.[Link](this);
[Link]();
[Link]();
[Link]();
};

Scene_Menu.[Link] = function() {
Scene_MenuBase.[Link](this);
this._statusWindow.refresh();
};

Scene_Menu.[Link] = function() {
const rect = [Link]();
const commandWindow = new Window_MenuCommand(rect);
[Link]("item", [Link](this));
[Link]("skill", [Link](this));
[Link]("equip", [Link](this));
[Link]("status", [Link](this));
[Link]("formation", [Link](this));
[Link]("options", [Link](this));
[Link]("save", [Link](this));
[Link]("gameEnd", [Link](this));
[Link]("cancel", [Link](this));
[Link](commandWindow);
this._commandWindow = commandWindow;
};

Scene_Menu.[Link] = function() {
const ww = [Link]();
const wh = [Link]() - [Link]().height;
const wx = [Link]() ? [Link] - ww : 0;
const wy = [Link]();
return new Rectangle(wx, wy, ww, wh);
};

Scene_Menu.[Link] = function() {
const rect = [Link]();
this._goldWindow = new Window_Gold(rect);
[Link](this._goldWindow);
};

Scene_Menu.[Link] = function() {
const ww = [Link]();
const wh = [Link](1, true);
const wx = [Link]() ? [Link] - ww : 0;
const wy = [Link]() - wh;
return new Rectangle(wx, wy, ww, wh);
};

Scene_Menu.[Link] = function() {
const rect = [Link]();
this._statusWindow = new Window_MenuStatus(rect);
[Link](this._statusWindow);
};

Scene_Menu.[Link] = function() {
const ww = [Link] - [Link]();
const wh = [Link]();
const wx = [Link]() ? 0 : [Link] - ww;
const wy = [Link]();
return new Rectangle(wx, wy, ww, wh);
};

Scene_Menu.[Link] = function() {
[Link](Scene_Item);
};

Scene_Menu.[Link] = function() {
this._statusWindow.setFormationMode(false);
this._statusWindow.selectLast();
this._statusWindow.activate();
this._statusWindow.setHandler("ok", [Link](this));
this._statusWindow.setHandler("cancel", [Link](this));
};

Scene_Menu.[Link] = function() {
this._statusWindow.setFormationMode(true);
this._statusWindow.selectLast();
this._statusWindow.activate();
this._statusWindow.setHandler("ok", [Link](this));
this._statusWindow.setHandler("cancel", [Link](this));
};

Scene_Menu.[Link] = function() {
[Link](Scene_Options);
};

Scene_Menu.[Link] = function() {
[Link](Scene_Save);
};

Scene_Menu.[Link] = function() {
[Link](Scene_GameEnd);
};

Scene_Menu.[Link] = function() {
switch (this._commandWindow.currentSymbol()) {
case "skill":
[Link](Scene_Skill);
break;
case "equip":
[Link](Scene_Equip);
break;
case "status":
[Link](Scene_Status);
break;
}
};

Scene_Menu.[Link] = function() {
this._statusWindow.deselect();
this._commandWindow.activate();
};

Scene_Menu.[Link] = function() {
const index = this._statusWindow.index();
const pendingIndex = this._statusWindow.pendingIndex();
if (pendingIndex >= 0) {
$[Link](index, pendingIndex);
this._statusWindow.setPendingIndex(-1);
this._statusWindow.redrawItem(index);
} else {
this._statusWindow.setPendingIndex(index);
}
this._statusWindow.activate();
};

Scene_Menu.[Link] = function() {
if (this._statusWindow.pendingIndex() >= 0) {
this._statusWindow.setPendingIndex(-1);
this._statusWindow.activate();
} else {
this._statusWindow.deselect();
this._commandWindow.activate();
}
};

//-----------------------------------------------------------------------------
// Scene_ItemBase
//
// The superclass of Scene_Item and Scene_Skill.

function Scene_ItemBase() {
[Link](...arguments);
}

Scene_ItemBase.prototype = [Link](Scene_MenuBase.prototype);
Scene_ItemBase.[Link] = Scene_ItemBase;

Scene_ItemBase.[Link] = function() {
Scene_MenuBase.[Link](this);
};

Scene_ItemBase.[Link] = function() {
Scene_MenuBase.[Link](this);
};

Scene_ItemBase.[Link] = function() {
const rect = [Link]();
this._actorWindow = new Window_MenuActor(rect);
this._actorWindow.setHandler("ok", [Link](this));
this._actorWindow.setHandler("cancel", [Link](this));
[Link](this._actorWindow);
};

Scene_ItemBase.[Link] = function() {
const wx = 0;
const wy = [Link]([Link](), [Link]());
const ww = [Link] - [Link]();
const wh = [Link]() + [Link]();
return new Rectangle(wx, wy, ww, wh);
};

Scene_ItemBase.[Link] = function() {
return this._itemWindow.item();
};

Scene_ItemBase.[Link] = function() {
return null;
};

Scene_ItemBase.[Link] = function() {
return this._itemWindow.index() % 2 === 0;
};

Scene_ItemBase.[Link] = function() {
if ([Link]()) {
this._actorWindow.x = [Link] - this._actorWindow.width;
} else {
this._actorWindow.x = 0;
}
this._actorWindow.show();
this._actorWindow.activate();
};

Scene_ItemBase.[Link] = function() {
this._actorWindow.hide();
this._actorWindow.deactivate();
};

Scene_ItemBase.[Link] = function() {
return this._actorWindow && this._actorWindow.active;
};

Scene_ItemBase.[Link] = function() {
if ([Link]()) {
[Link]();
} else {
[Link]();
}
};

Scene_ItemBase.[Link] = function() {
[Link]();
[Link]();
};

Scene_ItemBase.[Link] = function() {
const action = new Game_Action([Link]());
const item = [Link]();
[Link](item);
if ([Link]()) {
[Link]();
this._actorWindow.selectForItem([Link]());
} else {
[Link]();
[Link]();
}
};
Scene_ItemBase.[Link] = function() {
[Link]();
[Link]().useItem([Link]());
[Link]();
[Link]();
[Link]();
this._actorWindow.refresh();
};

Scene_ItemBase.[Link] = function() {
this._itemWindow.refresh();
this._itemWindow.activate();
};

Scene_ItemBase.[Link] = function() {
const action = new Game_Action([Link]());
[Link]([Link]());
if (![Link]()) {
return [];
} else if ([Link]()) {
return $[Link]();
} else {
return [$[Link]()[this._actorWindow.index()]];
}
};

Scene_ItemBase.[Link] = function() {
const user = [Link]();
return user && [Link]([Link]()) && [Link]();
};

Scene_ItemBase.[Link] = function() {
const action = new Game_Action([Link]());
[Link]([Link]());
return [Link]().some(target => [Link](target));
};

Scene_ItemBase.[Link] = function() {
const action = new Game_Action([Link]());
[Link]([Link]());
for (const target of [Link]()) {
for (let i = 0; i < [Link](); i++) {
[Link](target);
}
}
[Link]();
};

Scene_ItemBase.[Link] = function() {
if ($[Link]()) {
[Link](Scene_Map);
}
};

//-----------------------------------------------------------------------------
// Scene_Item
//
// The scene class of the item screen.
function Scene_Item() {
[Link](...arguments);
}

Scene_Item.prototype = [Link](Scene_ItemBase.prototype);
Scene_Item.[Link] = Scene_Item;

Scene_Item.[Link] = function() {
Scene_ItemBase.[Link](this);
};

Scene_Item.[Link] = function() {
Scene_ItemBase.[Link](this);
[Link]();
[Link]();
[Link]();
[Link]();
};

Scene_Item.[Link] = function() {
const rect = [Link]();
this._categoryWindow = new Window_ItemCategory(rect);
this._categoryWindow.setHelpWindow(this._helpWindow);
this._categoryWindow.setHandler("ok", [Link](this));
this._categoryWindow.setHandler("cancel", [Link](this));
[Link](this._categoryWindow);
};

Scene_Item.[Link] = function() {
const wx = 0;
const wy = [Link]();
const ww = [Link];
const wh = [Link](1, true);
return new Rectangle(wx, wy, ww, wh);
};

Scene_Item.[Link] = function() {
const rect = [Link]();
this._itemWindow = new Window_ItemList(rect);
this._itemWindow.setHelpWindow(this._helpWindow);
this._itemWindow.setHandler("ok", [Link](this));
this._itemWindow.setHandler("cancel", [Link](this));
[Link](this._itemWindow);
this._categoryWindow.setItemWindow(this._itemWindow);
if (!this._categoryWindow.needsSelection()) {
this._itemWindow.y -= this._categoryWindow.height;
this._itemWindow.height += this._categoryWindow.height;
this._itemWindow.createContents();
this._categoryWindow.update();
this._categoryWindow.hide();
this._categoryWindow.deactivate();
[Link]();
}
};

Scene_Item.[Link] = function() {
const wx = 0;
const wy = this._categoryWindow.y + this._categoryWindow.height;
const ww = [Link];
 const wh = [Link]() - wy;
return new Rectangle(wx, wy, ww, wh);
};

Scene_Item.[Link] = function() {
const members = $[Link]();
const bestPha = [Link](...[Link](member => [Link]));
return [Link](member => [Link] === bestPha);
};

Scene_Item.[Link] = function() {
this._itemWindow.activate();
this._itemWindow.selectLast();
};

Scene_Item.[Link] = function() {
$[Link]([Link]());
[Link]();
};

Scene_Item.[Link] = function() {
if (this._categoryWindow.needsSelection()) {
this._itemWindow.deselect();
this._categoryWindow.activate();
} else {
[Link]();
}
};

Scene_Item.[Link] = function() {
[Link]();
};

Scene_Item.[Link] = function() {
Scene_ItemBase.[Link](this);
this._itemWindow.redrawCurrentItem();
};

//-----------------------------------------------------------------------------
// Scene_Skill
//
// The scene class of the skill screen.

function Scene_Skill() {
[Link](...arguments);
}

Scene_Skill.prototype = [Link](Scene_ItemBase.prototype);
Scene_Skill.[Link] = Scene_Skill;

Scene_Skill.[Link] = function() {
Scene_ItemBase.[Link](this);
};

Scene_Skill.[Link] = function() {
Scene_ItemBase.[Link](this);
[Link]();
[Link]();
[Link]();
 [Link]();
[Link]();
};

Scene_Skill.[Link] = function() {
Scene_ItemBase.[Link](this);
[Link]();
};

Scene_Skill.[Link] = function() {
const rect = [Link]();
this._skillTypeWindow = new Window_SkillType(rect);
this._skillTypeWindow.setHelpWindow(this._helpWindow);
this._skillTypeWindow.setHandler("skill", [Link](this));
this._skillTypeWindow.setHandler("cancel", [Link](this));
this._skillTypeWindow.setHandler("pagedown", [Link](this));
this._skillTypeWindow.setHandler("pageup", [Link](this));
[Link](this._skillTypeWindow);
};

Scene_Skill.[Link] = function() {
const ww = [Link]();
const wh = [Link](3, true);
const wx = [Link]() ? [Link] - ww : 0;
const wy = [Link]();
return new Rectangle(wx, wy, ww, wh);
};

Scene_Skill.[Link] = function() {
const rect = [Link]();
this._statusWindow = new Window_SkillStatus(rect);
[Link](this._statusWindow);
};

Scene_Skill.[Link] = function() {
const ww = [Link] - [Link]();
const wh = this._skillTypeWindow.height;
const wx = [Link]() ? 0 : [Link] - ww;
const wy = [Link]();
return new Rectangle(wx, wy, ww, wh);
};

Scene_Skill.[Link] = function() {
const rect = [Link]();
this._itemWindow = new Window_SkillList(rect);
this._itemWindow.setHelpWindow(this._helpWindow);
this._itemWindow.setHandler("ok", [Link](this));
this._itemWindow.setHandler("cancel", [Link](this));
this._skillTypeWindow.setSkillWindow(this._itemWindow);
[Link](this._itemWindow);
};

Scene_Skill.[Link] = function() {
const wx = 0;
const wy = this._statusWindow.y + this._statusWindow.height;
const ww = [Link];
const wh = [Link]() - this._statusWindow.height;
return new Rectangle(wx, wy, ww, wh);
};
Scene_Skill.[Link] = function() {
return true;
};

Scene_Skill.[Link] = function() {
return ![Link]();
};

Scene_Skill.[Link] = function() {
const actor = [Link]();
this._skillTypeWindow.setActor(actor);
this._statusWindow.setActor(actor);
this._itemWindow.setActor(actor);
};

Scene_Skill.[Link] = function() {
return [Link]();
};

Scene_Skill.[Link] = function() {
this._itemWindow.activate();
this._itemWindow.selectLast();
};

Scene_Skill.[Link] = function() {
[Link]().setLastMenuSkill([Link]());
[Link]();
};

Scene_Skill.[Link] = function() {
this._itemWindow.deselect();
this._skillTypeWindow.activate();
};

Scene_Skill.[Link] = function() {
[Link]();
};

Scene_Skill.[Link] = function() {
Scene_ItemBase.[Link](this);
this._statusWindow.refresh();
this._itemWindow.refresh();
};

Scene_Skill.[Link] = function() {
Scene_MenuBase.[Link](this);
[Link]();
this._itemWindow.deselect();
this._skillTypeWindow.activate();
};

//-----------------------------------------------------------------------------
// Scene_Equip
//
// The scene class of the equipment screen.

function Scene_Equip() {
[Link](...arguments);
}

Scene_Equip.prototype = [Link](Scene_MenuBase.prototype);
Scene_Equip.[Link] = Scene_Equip;

Scene_Equip.[Link] = function() {
Scene_MenuBase.[Link](this);
};

Scene_Equip.[Link] = function() {
Scene_MenuBase.[Link](this);
[Link]();
[Link]();
[Link]();
[Link]();
[Link]();
[Link]();
};

Scene_Equip.[Link] = function() {
const rect = [Link]();
this._statusWindow = new Window_EquipStatus(rect);
[Link](this._statusWindow);
};

Scene_Equip.[Link] = function() {
const wx = 0;
const wy = [Link]();
const ww = [Link]();
const wh = [Link]();
return new Rectangle(wx, wy, ww, wh);
};

Scene_Equip.[Link] = function() {
const rect = [Link]();
this._commandWindow = new Window_EquipCommand(rect);
this._commandWindow.setHelpWindow(this._helpWindow);
this._commandWindow.setHandler("equip", [Link](this));
this._commandWindow.setHandler("optimize", [Link](this));
this._commandWindow.setHandler("clear", [Link](this));
this._commandWindow.setHandler("cancel", [Link](this));
this._commandWindow.setHandler("pagedown", [Link](this));
this._commandWindow.setHandler("pageup", [Link](this));
[Link](this._commandWindow);
};

Scene_Equip.[Link] = function() {
const wx = [Link]();
const wy = [Link]();
const ww = [Link] - [Link]();
const wh = [Link](1, true);
return new Rectangle(wx, wy, ww, wh);
};

Scene_Equip.[Link] = function() {
const rect = [Link]();
this._slotWindow = new Window_EquipSlot(rect);
this._slotWindow.setHelpWindow(this._helpWindow);
this._slotWindow.setStatusWindow(this._statusWindow);
 this._slotWindow.setHandler("ok", [Link](this));
this._slotWindow.setHandler("cancel", [Link](this));
[Link](this._slotWindow);
};

Scene_Equip.[Link] = function() {
const commandWindowRect = [Link]();
const wx = [Link]();
const wy = commandWindowRect.y + [Link];
const ww = [Link] - [Link]();
const wh = [Link]() - [Link];
return new Rectangle(wx, wy, ww, wh);
};

Scene_Equip.[Link] = function() {
const rect = [Link]();
this._itemWindow = new Window_EquipItem(rect);
this._itemWindow.setHelpWindow(this._helpWindow);
this._itemWindow.setStatusWindow(this._statusWindow);
this._itemWindow.setHandler("ok", [Link](this));
this._itemWindow.setHandler("cancel", [Link](this));
this._itemWindow.hide();
this._slotWindow.setItemWindow(this._itemWindow);
[Link](this._itemWindow);
};

Scene_Equip.[Link] = function() {
return [Link]();
};

Scene_Equip.[Link] = function() {
return 312;
};

Scene_Equip.[Link] = function() {
return true;
};

Scene_Equip.[Link] = function() {
return !(this._itemWindow && this._itemWindow.active);
};

Scene_Equip.[Link] = function() {
const actor = [Link]();
this._statusWindow.setActor(actor);
this._slotWindow.setActor(actor);
this._itemWindow.setActor(actor);
};

Scene_Equip.[Link] = function() {
this._slotWindow.activate();
this._slotWindow.select(0);
};

Scene_Equip.[Link] = function() {
[Link]();
[Link]().optimizeEquipments();
this._statusWindow.refresh();
this._slotWindow.refresh();
 this._commandWindow.activate();
};

Scene_Equip.[Link] = function() {
[Link]();
[Link]().clearEquipments();
this._statusWindow.refresh();
this._slotWindow.refresh();
this._commandWindow.activate();
};

Scene_Equip.[Link] = function() {
this._slotWindow.hide();
this._itemWindow.show();
this._itemWindow.activate();
this._itemWindow.select(0);
};

Scene_Equip.[Link] = function() {
this._slotWindow.deselect();
this._commandWindow.activate();
};

Scene_Equip.[Link] = function() {
[Link]();
[Link]();
[Link]();
this._slotWindow.refresh();
this._itemWindow.refresh();
this._statusWindow.refresh();
};

Scene_Equip.[Link] = function() {
const actor = [Link]();
const slotId = this._slotWindow.index();
const item = this._itemWindow.item();
[Link](slotId, item);
};

Scene_Equip.[Link] = function() {
[Link]();
};

Scene_Equip.[Link] = function() {
Scene_MenuBase.[Link](this);
[Link]();
[Link]();
this._slotWindow.deselect();
this._slotWindow.deactivate();
this._commandWindow.activate();
};

Scene_Equip.[Link] = function() {
this._slotWindow.show();
this._slotWindow.activate();
this._itemWindow.hide();
this._itemWindow.deselect();
};
//-----------------------------------------------------------------------------
// Scene_Status
//
// The scene class of the status screen.

function Scene_Status() {
[Link](...arguments);
}

Scene_Status.prototype = [Link](Scene_MenuBase.prototype);
Scene_Status.[Link] = Scene_Status;

Scene_Status.[Link] = function() {
Scene_MenuBase.[Link](this);
};

Scene_Status.[Link] = function() {
Scene_MenuBase.[Link](this);
[Link]();
[Link]();
[Link]();
[Link]();
};

Scene_Status.[Link] = function() {
return 0;
};

Scene_Status.[Link] = function() {
const rect = [Link]();
this._profileWindow = new Window_Help(rect);
[Link](this._profileWindow);
};

Scene_Status.[Link] = function() {
const ww = [Link];
const wh = [Link]();
const wx = 0;
const wy = [Link]() - wh;
return new Rectangle(wx, wy, ww, wh);
};

Scene_Status.[Link] = function() {
const rect = [Link]();
this._statusWindow = new Window_Status(rect);
this._statusWindow.setHandler("cancel", [Link](this));
this._statusWindow.setHandler("pagedown", [Link](this));
this._statusWindow.setHandler("pageup", [Link](this));
[Link](this._statusWindow);
};

Scene_Status.[Link] = function() {
const wx = 0;
const wy = [Link]();
const ww = [Link];
const wh = [Link]().y - wy;
return new Rectangle(wx, wy, ww, wh);
};
Scene_Status.[Link] = function() {
const rect = [Link]();
this._statusParamsWindow = new Window_StatusParams(rect);
[Link](this._statusParamsWindow);
};

Scene_Status.[Link] = function() {
const ww = [Link]();
const wh = [Link]();
const wx = 0;
const wy = [Link]() - [Link]() - wh;
return new Rectangle(wx, wy, ww, wh);
};

Scene_Status.[Link] = function() {
const rect = [Link]();
this._statusEquipWindow = new Window_StatusEquip(rect);
[Link](this._statusEquipWindow);
};

Scene_Status.[Link] = function() {
const ww = [Link] - [Link]();
const wh = [Link]();
const wx = [Link]();
const wy = [Link]() - [Link]() - wh;
return new Rectangle(wx, wy, ww, wh);
};

Scene_Status.[Link] = function() {
return 300;
};

Scene_Status.[Link] = function() {
return [Link](6, false);
};

Scene_Status.[Link] = function() {
return [Link](2, false);
};

Scene_Status.[Link] = function() {
Scene_MenuBase.[Link](this);
[Link]();
};

Scene_Status.[Link] = function() {
return true;
};

Scene_Status.[Link] = function() {
const actor = [Link]();
this._profileWindow.setText([Link]());
this._statusWindow.setActor(actor);
this._statusParamsWindow.setActor(actor);
this._statusEquipWindow.setActor(actor);
};

Scene_Status.[Link] = function() {
Scene_MenuBase.[Link](this);
 [Link]();
this._statusWindow.activate();
};

//-----------------------------------------------------------------------------
// Scene_Options
//
// The scene class of the options screen.

function Scene_Options() {
[Link](...arguments);
}

Scene_Options.prototype = [Link](Scene_MenuBase.prototype);
Scene_Options.[Link] = Scene_Options;

Scene_Options.[Link] = function() {
Scene_MenuBase.[Link](this);
};

Scene_Options.[Link] = function() {
Scene_MenuBase.[Link](this);
[Link]();
};

Scene_Options.[Link] = function() {
Scene_MenuBase.[Link](this);
[Link]();
};

Scene_Options.[Link] = function() {
const rect = [Link]();
this._optionsWindow = new Window_Options(rect);
this._optionsWindow.setHandler("cancel", [Link](this));
[Link](this._optionsWindow);
};

Scene_Options.[Link] = function() {
const n = [Link]([Link](), [Link]());
const ww = 400;
const wh = [Link](n, true);
const wx = ([Link] - ww) / 2;
const wy = ([Link] - wh) / 2;
return new Rectangle(wx, wy, ww, wh);
};

Scene_Options.[Link] = function() {
// Increase this value when adding option items.
return 7;
};

Scene_Options.[Link] = function() {
return 12;
};

//-----------------------------------------------------------------------------
// Scene_File
//
// The superclass of Scene_Save and Scene_Load.
function Scene_File() {
[Link](...arguments);
}

Scene_File.prototype = [Link](Scene_MenuBase.prototype);
Scene_File.[Link] = Scene_File;

Scene_File.[Link] = function() {
Scene_MenuBase.[Link](this);
};

Scene_File.[Link] = function() {
Scene_MenuBase.[Link](this);
[Link]();
[Link]();
[Link]();
this._helpWindow.setText([Link]());
};

Scene_File.[Link] = function() {
return 0;
};

Scene_File.[Link] = function() {
Scene_MenuBase.[Link](this);
this._listWindow.refresh();
};

Scene_File.[Link] = function() {
return this._listWindow.savefileId();
};

Scene_File.[Link] = function(savefileId) {
return this._listWindow.isEnabled(savefileId);
};

Scene_File.[Link] = function() {
const rect = [Link]();
this._helpWindow = new Window_Help(rect);
[Link](this._helpWindow);
};

Scene_File.[Link] = function() {
const wx = 0;
const wy = [Link]();
const ww = [Link];
const wh = [Link](1, false);
return new Rectangle(wx, wy, ww, wh);
};

Scene_File.[Link] = function() {
const rect = [Link]();
this._listWindow = new Window_SavefileList(rect);
this._listWindow.setHandler("ok", [Link](this));
this._listWindow.setHandler("cancel", [Link](this));
this._listWindow.setMode([Link](), [Link]());
this._listWindow.selectSavefile([Link]());
this._listWindow.refresh();
 [Link](this._listWindow);
};

Scene_File.[Link] = function() {
const wx = 0;
const wy = [Link]() + this._helpWindow.height;
const ww = [Link];
const wh = [Link]() - this._helpWindow.height;
return new Rectangle(wx, wy, ww, wh);
};

Scene_File.[Link] = function() {
return null;
};

Scene_File.[Link] = function() {
return $[Link]();
};

Scene_File.[Link] = function() {
this._listWindow.activate();
};

Scene_File.[Link] = function() {
return "";
};

Scene_File.[Link] = function() {
return 0;
};

Scene_File.[Link] = function() {
//
};

//-----------------------------------------------------------------------------
// Scene_Save
//
// The scene class of the save screen.

function Scene_Save() {
[Link](...arguments);
}

Scene_Save.prototype = [Link](Scene_File.prototype);
Scene_Save.[Link] = Scene_Save;

Scene_Save.[Link] = function() {
Scene_File.[Link](this);
};

Scene_Save.[Link] = function() {
return "save";
};

Scene_Save.[Link] = function() {
return [Link];
};
Scene_Save.[Link] = function() {
return $[Link]();
};

Scene_Save.[Link] = function() {
Scene_File.[Link](this);
const savefileId = [Link]();
if ([Link](savefileId)) {
[Link](savefileId);
} else {
[Link]();
}
};

Scene_Save.[Link] = function(savefileId) {
$[Link](savefileId);
$[Link]();
[Link](savefileId)
.then(() => [Link]())
.catch(() => [Link]());
};

Scene_Save.[Link] = function() {
[Link]();
[Link]();
};

Scene_Save.[Link] = function() {
[Link]();
[Link]();
};

//-----------------------------------------------------------------------------
// Scene_Load
//
// The scene class of the load screen.

function Scene_Load() {
[Link](...arguments);
}

Scene_Load.prototype = [Link](Scene_File.prototype);
Scene_Load.[Link] = Scene_Load;

Scene_Load.[Link] = function() {
Scene_File.[Link](this);
this._loadSuccess = false;
};

Scene_Load.[Link] = function() {
Scene_File.[Link](this);
if (this._loadSuccess) {
$[Link]();
}
};

Scene_Load.[Link] = function() {
return "load";
};
Scene_Load.[Link] = function() {
return [Link];
};

Scene_Load.[Link] = function() {
return [Link]();
};

Scene_Load.[Link] = function() {
Scene_File.[Link](this);
const savefileId = [Link]();
if ([Link](savefileId)) {
[Link](savefileId);
} else {
[Link]();
}
};

Scene_Load.[Link] = function(savefileId) {
[Link](savefileId)
.then(() => [Link]())
.catch(() => [Link]());
};

Scene_Load.[Link] = function() {
[Link]();
[Link]();
[Link]();
[Link](Scene_Map);
this._loadSuccess = true;
};

Scene_Load.[Link] = function() {
[Link]();
[Link]();
};

Scene_Load.[Link] = function() {
if ($[Link]() !== $[Link]) {
const mapId = $[Link]();
const x = $gamePlayer.x;
const y = $gamePlayer.y;
const d = $[Link]();
$[Link](mapId, x, y, d, 0);
$[Link]();
}
};

//-----------------------------------------------------------------------------
// Scene_GameEnd
//
// The scene class of the game end screen.

function Scene_GameEnd() {
[Link](...arguments);
}

Scene_GameEnd.prototype = [Link](Scene_MenuBase.prototype);
Scene_GameEnd.[Link] = Scene_GameEnd;

Scene_GameEnd.[Link] = function() {
Scene_MenuBase.[Link](this);
};

Scene_GameEnd.[Link] = function() {
Scene_MenuBase.[Link](this);
[Link]();
};

Scene_GameEnd.[Link] = function() {
Scene_MenuBase.[Link](this);
this._commandWindow.close();
};

Scene_GameEnd.[Link] = function() {
Scene_MenuBase.[Link](this);
[Link](128);
};

Scene_GameEnd.[Link] = function() {
const rect = [Link]();
this._commandWindow = new Window_GameEnd(rect);
this._commandWindow.setHandler("toTitle", [Link](this));
this._commandWindow.setHandler("cancel", [Link](this));
[Link](this._commandWindow);
};

Scene_GameEnd.[Link] = function() {
const ww = [Link]();
const wh = [Link](2, true);
const wx = ([Link] - ww) / 2;
const wy = ([Link] - wh) / 2;
return new Rectangle(wx, wy, ww, wh);
};

Scene_GameEnd.[Link] = function() {
[Link]();
[Link](Scene_Title);
Window_TitleCommand.initCommandPosition();
};

//-----------------------------------------------------------------------------
// Scene_Shop
//
// The scene class of the shop screen.

function Scene_Shop() {
[Link](...arguments);
}

Scene_Shop.prototype = [Link](Scene_MenuBase.prototype);
Scene_Shop.[Link] = Scene_Shop;

Scene_Shop.[Link] = function() {
Scene_MenuBase.[Link](this);
};
Scene_Shop.[Link] = function(goods, purchaseOnly) {
this._goods = goods;
this._purchaseOnly = purchaseOnly;
this._item = null;
};

Scene_Shop.[Link] = function() {
Scene_MenuBase.[Link](this);
[Link]();
[Link]();
[Link]();
[Link]();
[Link]();
[Link]();
[Link]();
[Link]();
[Link]();
};

Scene_Shop.[Link] = function() {
const rect = [Link]();
this._goldWindow = new Window_Gold(rect);
[Link](this._goldWindow);
};

Scene_Shop.[Link] = function() {
const ww = [Link]();
const wh = [Link](1, true);
const wx = [Link] - ww;
const wy = [Link]();
return new Rectangle(wx, wy, ww, wh);
};

Scene_Shop.[Link] = function() {
const rect = [Link]();
this._commandWindow = new Window_ShopCommand(rect);
this._commandWindow.setPurchaseOnly(this._purchaseOnly);
this._commandWindow.y = [Link]();
this._commandWindow.setHandler("buy", [Link](this));
this._commandWindow.setHandler("sell", [Link](this));
this._commandWindow.setHandler("cancel", [Link](this));
[Link](this._commandWindow);
};

Scene_Shop.[Link] = function() {
const wx = 0;
const wy = [Link]();
const ww = this._goldWindow.x;
const wh = [Link](1, true);
return new Rectangle(wx, wy, ww, wh);
};

Scene_Shop.[Link] = function() {
const rect = [Link]();
this._dummyWindow = new Window_Base(rect);
[Link](this._dummyWindow);
};

Scene_Shop.[Link] = function() {
 const wx = 0;
const wy = this._commandWindow.y + this._commandWindow.height;
const ww = [Link];
const wh = [Link]() - this._commandWindow.height;
return new Rectangle(wx, wy, ww, wh);
};

Scene_Shop.[Link] = function() {
const rect = [Link]();
this._numberWindow = new Window_ShopNumber(rect);
this._numberWindow.hide();
this._numberWindow.setHandler("ok", [Link](this));
this._numberWindow.setHandler("cancel", [Link](this));
[Link](this._numberWindow);
};

Scene_Shop.[Link] = function() {
const wx = 0;
const wy = this._dummyWindow.y;
const ww = [Link] - [Link]();
const wh = this._dummyWindow.height;
return new Rectangle(wx, wy, ww, wh);
};

Scene_Shop.[Link] = function() {
const rect = [Link]();
this._statusWindow = new Window_ShopStatus(rect);
this._statusWindow.hide();
[Link](this._statusWindow);
};

Scene_Shop.[Link] = function() {
const ww = [Link]();
const wh = this._dummyWindow.height;
const wx = [Link] - ww;
const wy = this._dummyWindow.y;
return new Rectangle(wx, wy, ww, wh);
};

Scene_Shop.[Link] = function() {
const rect = [Link]();
this._buyWindow = new Window_ShopBuy(rect);
this._buyWindow.setupGoods(this._goods);
this._buyWindow.setHelpWindow(this._helpWindow);
this._buyWindow.setStatusWindow(this._statusWindow);
this._buyWindow.hide();
this._buyWindow.setHandler("ok", [Link](this));
this._buyWindow.setHandler("cancel", [Link](this));
[Link](this._buyWindow);
};

Scene_Shop.[Link] = function() {
const wx = 0;
const wy = this._dummyWindow.y;
const ww = [Link] - [Link]();
const wh = this._dummyWindow.height;
return new Rectangle(wx, wy, ww, wh);
};
Scene_Shop.[Link] = function() {
const rect = [Link]();
this._categoryWindow = new Window_ItemCategory(rect);
this._categoryWindow.setHelpWindow(this._helpWindow);
this._categoryWindow.hide();
this._categoryWindow.deactivate();
this._categoryWindow.setHandler("ok", [Link](this));
this._categoryWindow.setHandler("cancel", [Link](this));
[Link](this._categoryWindow);
};

Scene_Shop.[Link] = function() {
const wx = 0;
const wy = this._dummyWindow.y;
const ww = [Link];
const wh = [Link](1, true);
return new Rectangle(wx, wy, ww, wh);
};

Scene_Shop.[Link] = function() {
const rect = [Link]();
this._sellWindow = new Window_ShopSell(rect);
this._sellWindow.setHelpWindow(this._helpWindow);
this._sellWindow.hide();
this._sellWindow.setHandler("ok", [Link](this));
this._sellWindow.setHandler("cancel", [Link](this));
this._categoryWindow.setItemWindow(this._sellWindow);
[Link](this._sellWindow);
if (!this._categoryWindow.needsSelection()) {
this._sellWindow.y -= this._categoryWindow.height;
this._sellWindow.height += this._categoryWindow.height;
}
};

Scene_Shop.[Link] = function() {
const wx = 0;
const wy = this._categoryWindow.y + this._categoryWindow.height;
const ww = [Link];
const wh =
[Link]() -
this._commandWindow.height -
this._categoryWindow.height;
return new Rectangle(wx, wy, ww, wh);
};

Scene_Shop.[Link] = function() {
return 352;
};

Scene_Shop.[Link] = function() {
this._buyWindow.setMoney([Link]());
this._buyWindow.show();
this._buyWindow.activate();
this._statusWindow.show();
};

Scene_Shop.[Link] = function() {
if (this._categoryWindow.needsSelection()) {
this._categoryWindow.show();
 }
this._sellWindow.refresh();
this._sellWindow.show();
this._sellWindow.activate();
this._statusWindow.hide();
};

Scene_Shop.[Link] = function() {
this._dummyWindow.hide();
[Link]();
};

Scene_Shop.[Link] = function() {
this._dummyWindow.hide();
this._sellWindow.show();
this._sellWindow.deselect();
this._sellWindow.refresh();
if (this._categoryWindow.needsSelection()) {
this._categoryWindow.show();
this._categoryWindow.activate();
} else {
[Link]();
}
};

Scene_Shop.[Link] = function() {
this._item = this._buyWindow.item();
this._buyWindow.hide();
this._numberWindow.setup(this._item, [Link](), [Link]());
this._numberWindow.setCurrencyUnit([Link]());
this._numberWindow.show();
this._numberWindow.activate();
};

Scene_Shop.[Link] = function() {
this._commandWindow.activate();
this._dummyWindow.show();
this._buyWindow.hide();
this._statusWindow.hide();
this._statusWindow.setItem(null);
this._helpWindow.clear();
};

Scene_Shop.[Link] = function() {
[Link]();
this._sellWindow.select(0);
};

Scene_Shop.[Link] = function() {
this._commandWindow.activate();
this._dummyWindow.show();
this._categoryWindow.hide();
this._sellWindow.hide();
};

Scene_Shop.[Link] = function() {
this._item = this._sellWindow.item();
this._categoryWindow.hide();
this._sellWindow.hide();
 this._numberWindow.setup(this._item, [Link](), [Link]());
this._numberWindow.setCurrencyUnit([Link]());
this._numberWindow.show();
this._numberWindow.activate();
this._statusWindow.setItem(this._item);
this._statusWindow.show();
};

Scene_Shop.[Link] = function() {
this._sellWindow.deselect();
this._statusWindow.setItem(null);
this._helpWindow.clear();
if (this._categoryWindow.needsSelection()) {
this._categoryWindow.activate();
} else {
[Link]();
}
};

Scene_Shop.[Link] = function() {
[Link]();
switch (this._commandWindow.currentSymbol()) {
case "buy":
[Link](this._numberWindow.number());
break;
case "sell":
[Link](this._numberWindow.number());
break;
}
[Link]();
this._goldWindow.refresh();
this._statusWindow.refresh();
};

Scene_Shop.[Link] = function() {
[Link]();
[Link]();
};

Scene_Shop.[Link] = function(number) {
$[Link](number * [Link]());
$[Link](this._item, number);
};

Scene_Shop.[Link] = function(number) {
$[Link](number * [Link]());
$[Link](this._item, number);
};

Scene_Shop.[Link] = function() {
this._numberWindow.hide();
switch (this._commandWindow.currentSymbol()) {
case "buy":
[Link]();
break;
case "sell":
[Link]();
break;
}
};

Scene_Shop.[Link] = function() {
const num = $[Link](this._item);
const max = $[Link](this._item) - num;
const price = [Link]();
if (price > 0) {
return [Link](max, [Link]([Link]() / price));
} else {
return max;
}
};

Scene_Shop.[Link] = function() {
return $[Link](this._item);
};

Scene_Shop.[Link] = function() {
return this._goldWindow.value();
};

Scene_Shop.[Link] = function() {
return this._goldWindow.currencyUnit();
};

Scene_Shop.[Link] = function() {
return this._buyWindow.price(this._item);
};

Scene_Shop.[Link] = function() {
return [Link](this._item.price / 2);
};

//-----------------------------------------------------------------------------
// Scene_Name
//
// The scene class of the name input screen.

function Scene_Name() {
[Link](...arguments);
}

Scene_Name.prototype = [Link](Scene_MenuBase.prototype);
Scene_Name.[Link] = Scene_Name;

Scene_Name.[Link] = function() {
Scene_MenuBase.[Link](this);
};

Scene_Name.[Link] = function(actorId, maxLength) {

this._actorId = actorId;
this._maxLength = maxLength;
};

Scene_Name.[Link] = function() {
Scene_MenuBase.[Link](this);
this._actor = $[Link](this._actorId);
[Link]();
[Link]();
};

Scene_Name.[Link] = function() {
Scene_MenuBase.[Link](this);
this._editWindow.refresh();
};

Scene_Name.[Link] = function() {
const rect = [Link]();
this._editWindow = new Window_NameEdit(rect);
this._editWindow.setup(this._actor, this._maxLength);
[Link](this._editWindow);
};

Scene_Name.[Link] = function() {
const inputWindowHeight = [Link](9, true);
const padding = $[Link]();
const ww = 600;
const wh = [Link] + padding * 2;
const wx = ([Link] - ww) / 2;
const wy = ([Link] - (wh + inputWindowHeight + 8)) / 2;
return new Rectangle(wx, wy, ww, wh);
};

Scene_Name.[Link] = function() {
const rect = [Link]();
this._inputWindow = new Window_NameInput(rect);
this._inputWindow.setEditWindow(this._editWindow);
this._inputWindow.setHandler("ok", [Link](this));
[Link](this._inputWindow);
};

Scene_Name.[Link] = function() {
const wx = this._editWindow.x;
const wy = this._editWindow.y + this._editWindow.height + 8;
const ww = this._editWindow.width;
const wh = [Link](9, true);
return new Rectangle(wx, wy, ww, wh);
};

Scene_Name.[Link] = function() {
this._actor.setName(this._editWindow.name());
[Link]();
};

//-----------------------------------------------------------------------------
// Scene_Debug
//
// The scene class of the debug screen.

function Scene_Debug() {
[Link](...arguments);
}

Scene_Debug.prototype = [Link](Scene_MenuBase.prototype);
Scene_Debug.[Link] = Scene_Debug;

Scene_Debug.[Link] = function() {
Scene_MenuBase.[Link](this);
};

Scene_Debug.[Link] = function() {
Scene_MenuBase.[Link](this);
[Link]();
[Link]();
[Link]();
};

Scene_Debug.[Link] = function() {
return false;
};

Scene_Debug.[Link] = function() {
const rect = [Link]();
this._rangeWindow = new Window_DebugRange(rect);
this._rangeWindow.setHandler("ok", [Link](this));
this._rangeWindow.setHandler("cancel", [Link](this));
[Link](this._rangeWindow);
};

Scene_Debug.[Link] = function() {
const wx = 0;
const wy = 0;
const ww = 246;
const wh = [Link];
return new Rectangle(wx, wy, ww, wh);
};

Scene_Debug.[Link] = function() {
const rect = [Link]();
this._editWindow = new Window_DebugEdit(rect);
this._editWindow.setHandler("cancel", [Link](this));
this._rangeWindow.setEditWindow(this._editWindow);
[Link](this._editWindow);
};

Scene_Debug.[Link] = function() {
const wx = this._rangeWindow.width;
const wy = 0;
const ww = [Link] - wx;
const wh = [Link](10, true);
return new Rectangle(wx, wy, ww, wh);
};

Scene_Debug.[Link] = function() {
const rect = [Link]();
this._debugHelpWindow = new Window_Base(rect);
[Link](this._debugHelpWindow);
};

Scene_Debug.[Link] = function() {
const wx = this._editWindow.x;
const wy = this._editWindow.height;
const ww = this._editWindow.width;
const wh = [Link] - wy;
return new Rectangle(wx, wy, ww, wh);
};
Scene_Debug.[Link] = function() {
this._editWindow.activate();
this._editWindow.select(0);
[Link]();
};

Scene_Debug.[Link] = function() {
this._rangeWindow.activate();
this._editWindow.deselect();
[Link]();
};

Scene_Debug.[Link] = function() {
const helpWindow = this._debugHelpWindow;
[Link]();
if (this._editWindow.active) {
const rect = [Link]();
[Link]([Link](), rect.x, rect.y, [Link]);
}
};

Scene_Debug.[Link] = function() {
if (this._rangeWindow.mode() === "switch") {
return "Enter : ON / OFF";
} else {
return (
"Left : -1 Pageup : -10\n" +
"Right : +1 Pagedown : +10"
);
}
};

//-----------------------------------------------------------------------------
// Scene_Battle
//
// The scene class of the battle screen.

function Scene_Battle() {
[Link](...arguments);
}

Scene_Battle.prototype = [Link](Scene_Message.prototype);
Scene_Battle.[Link] = Scene_Battle;

Scene_Battle.[Link] = function() {
Scene_Message.[Link](this);
};

Scene_Battle.[Link] = function() {
Scene_Message.[Link](this);
[Link]();
};

Scene_Battle.[Link] = function() {
Scene_Message.[Link](this);
[Link]();
[Link]();
this._statusWindow.refresh();
[Link]([Link](), false);
};

Scene_Battle.[Link] = function() {
const active = [Link]();
$[Link](active);
$[Link]();
[Link]();
if (active && ![Link]()) {
[Link]();
}
Scene_Message.[Link](this);
};

Scene_Battle.[Link] = function() {
[Link]();
[Link]();
[Link]();
[Link]();
};

Scene_Battle.[Link] = function() {
[Link]([Link]());
};

Scene_Battle.[Link] = function() {
if ([Link]()) {
return !this._skillWindow.active && !this._itemWindow.active;
} else {
return ![Link]();
}
};

Scene_Battle.[Link] = function() {
return (
this._partyCommandWindow.active ||
this._actorCommandWindow.active ||
this._skillWindow.active ||
this._itemWindow.active ||
this._actorWindow.active ||
this._enemyWindow.active
);
};

Scene_Battle.[Link] = function() {
[Link]();
if ([Link]()) {
if ([Link]()) {
[Link]();
} else {
[Link]();
}
} else {
[Link]();
}
};

Scene_Battle.[Link] = function() {
Scene_Message.[Link](this);
if ([Link]()) {
 [Link]([Link](), false);
} else {
[Link]([Link](), false);
}
this._statusWindow.close();
this._partyCommandWindow.close();
this._actorCommandWindow.close();
};

Scene_Battle.[Link] = function() {
Scene_Message.[Link](this);
$[Link]();
$[Link]();
[Link]();
if ([Link]()) {
[Link]();
}
};

Scene_Battle.[Link] = function() {
return [Link](Scene_Map);
};

Scene_Battle.[Link] = function() {
return (
[Link](Scene_Title) ||
[Link](Scene_Gameover)
);
};

Scene_Battle.[Link] = function() {
this._logWindow.visible = !this._helpWindow.visible;
};

Scene_Battle.[Link] = function() {
if ($[Link]()) {
this._statusWindow.close();
} else if ([Link]()) {
this._statusWindow.open();
}
[Link]();
};

Scene_Battle.[Link] = function() {
return (
[Link]() &&
![Link]() &&
![Link]()
);
};

Scene_Battle.[Link] = function() {
const statusWindow = this._statusWindow;
const targetX = [Link]();
if (statusWindow.x < targetX) {
statusWindow.x = [Link](statusWindow.x + 16, targetX);
}
if (statusWindow.x > targetX) {
statusWindow.x = [Link](statusWindow.x - 16, targetX);
 }
};

Scene_Battle.[Link] = function() {
if ([Link]()) {
return [Link]().x;
} else {
return this._partyCommandWindow.width / 2;
}
};

Scene_Battle.[Link] = function() {
if ($[Link]()) {
[Link]();
[Link]();
} else if ([Link]()) {
[Link]();
}
};

Scene_Battle.[Link] = function() {
const windowActive = [Link]();
const inputting = [Link]();
if (windowActive && inputting) {
return this._actorCommandWindow.actor() !== [Link]();
}
return windowActive !== inputting;
};

Scene_Battle.[Link] = function() {
if (this._cancelButton) {
this._cancelButton.visible =
[Link]() && !this._partyCommandWindow.active;
}
};

Scene_Battle.[Link] = function() {
[Link]();
[Link]();
[Link]();
[Link]();
[Link](this._logWindow);
[Link](this._spriteset);
this._logWindow.setSpriteset(this._spriteset);
};

Scene_Battle.[Link] = function() {
this._spriteset = new Spriteset_Battle();
[Link](this._spriteset);
};

Scene_Battle.[Link] = function() {
[Link]();
[Link]();
[Link]();
[Link]();
[Link]();
[Link]();
[Link]();
 [Link]();
[Link]();
Scene_Message.[Link](this);
};

Scene_Battle.[Link] = function() {
const rect = [Link]();
this._logWindow = new Window_BattleLog(rect);
[Link](this._logWindow);
};

Scene_Battle.[Link] = function() {
const wx = 0;
const wy = 0;
const ww = [Link];
const wh = [Link](10, false);
return new Rectangle(wx, wy, ww, wh);
};

Scene_Battle.[Link] = function() {
const rect = [Link]();
const statusWindow = new Window_BattleStatus(rect);
[Link](statusWindow);
this._statusWindow = statusWindow;
};

Scene_Battle.[Link] = function() {
const extra = 10;
const ww = [Link] - 192;
const wh = [Link]() + extra;
const wx = [Link]() ? 0 : [Link] - ww;
const wy = [Link] - wh + extra - 4;
return new Rectangle(wx, wy, ww, wh);
};

Scene_Battle.[Link] = function() {
const rect = [Link]();
const commandWindow = new Window_PartyCommand(rect);
[Link]("fight", [Link](this));
[Link]("escape", [Link](this));
[Link]();
[Link](commandWindow);
this._partyCommandWindow = commandWindow;
};

Scene_Battle.[Link] = function() {
const ww = 192;
const wh = [Link]();
const wx = [Link]() ? [Link] - ww : 0;
const wy = [Link] - wh;
return new Rectangle(wx, wy, ww, wh);
};

Scene_Battle.[Link] = function() {
const rect = [Link]();
const commandWindow = new Window_ActorCommand(rect);
commandWindow.y = [Link] - [Link];
[Link]("attack", [Link](this));
[Link]("skill", [Link](this));
 [Link]("guard", [Link](this));
[Link]("item", [Link](this));
[Link]("cancel", [Link](this));
[Link](commandWindow);
this._actorCommandWindow = commandWindow;
};

Scene_Battle.[Link] = function() {
const ww = 192;
const wh = [Link]();
const wx = [Link]() ? [Link] - ww : 0;
const wy = [Link] - wh;
return new Rectangle(wx, wy, ww, wh);
};

Scene_Battle.[Link] = function() {
const rect = [Link]();
this._helpWindow = new Window_Help(rect);
this._helpWindow.hide();
[Link](this._helpWindow);
};

Scene_Battle.[Link] = function() {
const wx = 0;
const wy = [Link]();
const ww = [Link];
const wh = [Link]();
return new Rectangle(wx, wy, ww, wh);
};

Scene_Battle.[Link] = function() {
const rect = [Link]();
this._skillWindow = new Window_BattleSkill(rect);
this._skillWindow.setHelpWindow(this._helpWindow);
this._skillWindow.setHandler("ok", [Link](this));
this._skillWindow.setHandler("cancel", [Link](this));
[Link](this._skillWindow);
};

Scene_Battle.[Link] = function() {
const ww = [Link];
const wh = [Link]();
const wx = 0;
const wy = [Link] - wh;
return new Rectangle(wx, wy, ww, wh);
};

Scene_Battle.[Link] = function() {
const rect = [Link]();
this._itemWindow = new Window_BattleItem(rect);
this._itemWindow.setHelpWindow(this._helpWindow);
this._itemWindow.setHandler("ok", [Link](this));
this._itemWindow.setHandler("cancel", [Link](this));
[Link](this._itemWindow);
};

Scene_Battle.[Link] = function() {
return [Link]();
};
Scene_Battle.[Link] = function() {
const rect = [Link]();
this._actorWindow = new Window_BattleActor(rect);
this._actorWindow.setHandler("ok", [Link](this));
this._actorWindow.setHandler("cancel", [Link](this));
[Link](this._actorWindow);
};

Scene_Battle.[Link] = function() {
return [Link]();
};

Scene_Battle.[Link] = function() {
const rect = [Link]();
this._enemyWindow = new Window_BattleEnemy(rect);
this._enemyWindow.setHandler("ok", [Link](this));
this._enemyWindow.setHandler("cancel", [Link](this));
[Link](this._enemyWindow);
};

Scene_Battle.[Link] = function() {
const wx = this._statusWindow.x;
const ww = this._statusWindow.width;
const wh = [Link]();
const wy = [Link] - wh;
return new Rectangle(wx, wy, ww, wh);
};

Scene_Battle.[Link] = function() {
return 0;
};

Scene_Battle.[Link] = function() {
return [Link]() + [Link]();
};

Scene_Battle.[Link] = function() {
return [Link](2, false);
};

Scene_Battle.[Link] = function() {
return [Link]();
};

Scene_Battle.[Link] = function() {
return [Link](4, true);
};

Scene_Battle.[Link] = function() {
if ([Link]) {
[Link]();
}
};

Scene_Battle.[Link] = function() {
this._cancelButton = new Sprite_Button("cancel");
this._cancelButton.x = [Link] - this._cancelButton.width - 4;
this._cancelButton.y = [Link]();
 [Link](this._cancelButton);
};

Scene_Battle.[Link] = function() {
this._partyCommandWindow.deactivate();
this._actorCommandWindow.deactivate();
this._partyCommandWindow.close();
this._actorCommandWindow.close();
};

Scene_Battle.[Link] = function() {
this._actorWindow.deactivate();
this._enemyWindow.deactivate();
this._skillWindow.deactivate();
this._itemWindow.deactivate();
this._actorWindow.hide();
this._enemyWindow.hide();
this._skillWindow.hide();
this._itemWindow.hide();
};

Scene_Battle.[Link] = function() {
this._statusWindow.deselect();
this._statusWindow.show();
this._statusWindow.open();
this._actorCommandWindow.setup(null);
this._actorCommandWindow.close();
this._partyCommandWindow.setup();
};

Scene_Battle.[Link] = function() {
[Link]();
};

Scene_Battle.[Link] = function() {
[Link]();
[Link]();
};

Scene_Battle.[Link] = function() {
this._statusWindow.show();
this._statusWindow.selectActor([Link]());
this._partyCommandWindow.close();
this._actorCommandWindow.show();
this._actorCommandWindow.setup([Link]());
};

Scene_Battle.[Link] = function() {
const action = [Link]();
[Link]();
[Link]();
};

Scene_Battle.[Link] = function() {
this._skillWindow.setActor([Link]());
this._skillWindow.setStypeId(this._actorCommandWindow.currentExt());
this._skillWindow.refresh();
this._skillWindow.show();
this._skillWindow.activate();
 this._statusWindow.hide();
this._actorCommandWindow.hide();
};

Scene_Battle.[Link] = function() {
const action = [Link]();
[Link]();
[Link]();
};

Scene_Battle.[Link] = function() {
this._itemWindow.refresh();
this._itemWindow.show();
this._itemWindow.activate();
this._statusWindow.hide();
this._actorCommandWindow.hide();
};

Scene_Battle.[Link] = function() {
[Link]();
};

Scene_Battle.[Link] = function() {
[Link]();
[Link]();
};

Scene_Battle.[Link] = function() {
[Link]();
[Link]();
};

Scene_Battle.[Link] = function() {
this._actorWindow.refresh();
this._actorWindow.show();
this._actorWindow.activate();
};

Scene_Battle.[Link] = function() {
const action = [Link]();
[Link](this._actorWindow.index());
[Link]();
[Link]();
};

Scene_Battle.[Link] = function() {
this._actorWindow.hide();
switch (this._actorCommandWindow.currentSymbol()) {
case "skill":
this._skillWindow.show();
this._skillWindow.activate();
break;
case "item":
this._itemWindow.show();
this._itemWindow.activate();
break;
}
};
Scene_Battle.[Link] = function() {
this._enemyWindow.refresh();
this._enemyWindow.show();
this._enemyWindow.select(0);
this._enemyWindow.activate();
this._statusWindow.hide();
};

Scene_Battle.[Link] = function() {
const action = [Link]();
[Link](this._enemyWindow.enemyIndex());
[Link]();
[Link]();
};

Scene_Battle.[Link] = function() {
this._enemyWindow.hide();
switch (this._actorCommandWindow.currentSymbol()) {
case "attack":
this._statusWindow.show();
this._actorCommandWindow.activate();
break;
case "skill":
this._skillWindow.show();
this._skillWindow.activate();
break;
case "item":
this._itemWindow.show();
this._itemWindow.activate();
break;
}
};

Scene_Battle.[Link] = function() {
const skill = this._skillWindow.item();
const action = [Link]();
[Link]([Link]);
[Link]().setLastBattleSkill(skill);
[Link]();
};

Scene_Battle.[Link] = function() {
this._skillWindow.hide();
this._statusWindow.show();
this._actorCommandWindow.show();
this._actorCommandWindow.activate();
};

Scene_Battle.[Link] = function() {
const item = this._itemWindow.item();
const action = [Link]();
[Link]([Link]);
$[Link](item);
[Link]();
};

Scene_Battle.[Link] = function() {
this._itemWindow.hide();
this._statusWindow.show();
 this._actorCommandWindow.show();
this._actorCommandWindow.activate();
};

Scene_Battle.[Link] = function() {
const action = [Link]();
if (![Link]()) {
[Link]();
} else if ([Link]()) {
[Link]();
} else {
[Link]();
}
};

Scene_Battle.[Link] = function() {
[Link]();
[Link]();
this._statusWindow.deselect();
this._statusWindow.show();
};

//-----------------------------------------------------------------------------
// Scene_Gameover
//
// The scene class of the game over screen.

function Scene_Gameover() {
[Link](...arguments);
}

Scene_Gameover.prototype = [Link](Scene_Base.prototype);
Scene_Gameover.[Link] = Scene_Gameover;

Scene_Gameover.[Link] = function() {
Scene_Base.[Link](this);
};

Scene_Gameover.[Link] = function() {
Scene_Base.[Link](this);
[Link]();
[Link]();
};

Scene_Gameover.[Link] = function() {
Scene_Base.[Link](this);
[Link]();
[Link]([Link](), false);
};

Scene_Gameover.[Link] = function() {
if ([Link]() && ![Link]() && [Link]()) {
[Link]();
}
Scene_Base.[Link](this);
};

Scene_Gameover.[Link] = function() {
Scene_Base.[Link](this);
 [Link]();
};

Scene_Gameover.[Link] = function() {
Scene_Base.[Link](this);
[Link]();
};

Scene_Gameover.[Link] = function() {
[Link]();
[Link]();
[Link]($[Link]);
};

Scene_Gameover.[Link] = function() {
this._backSprite = new Sprite();
this._backSprite.bitmap = [Link]("GameOver");
[Link](this._backSprite);
};

Scene_Gameover.[Link] = function() {
[Link](this._backSprite);
[Link](this._backSprite);
};

Scene_Gameover.[Link] = function() {
return [Link]("ok") || [Link]();
};

Scene_Gameover.[Link] = function() {
[Link](Scene_Title);
};

//-----------------------------------------------------------------------------