RMMZ Objects

//=============================================================================
// rmmz_objects.js v1.8.0
//=============================================================================
//-----------------------------------------------------------------------------
// Game_Temp
//
// The game object class for temporary data that is not included in save data.
function Game_Temp() {
this.initialize(...arguments);
}
Game_Temp.prototype.initialize = function() {
this._isPlaytest = Utils.isOptionValid("test");
this._destinationX = null;
this._destinationY = null;
this._touchTarget = null;
this._touchState = "";
this._needsBattleRefresh = false;
this._commonEventQueue = [];
this._animationQueue = [];
this._balloonQueue = [];
this._lastActionData = [0, 0, 0, 0, 0, 0];
};
Game_Temp.prototype.isPlaytest = function() {
return this._isPlaytest;
};
Game_Temp.prototype.setDestination = function(x, y) {
this._destinationX = x;
this._destinationY = y;
};
Game_Temp.prototype.clearDestination = function() {
this._destinationX = null;
this._destinationY = null;
};
Game_Temp.prototype.isDestinationValid = function() {
return this._destinationX !== null;
};
Game_Temp.prototype.destinationX = function() {
return this._destinationX;
};
Game_Temp.prototype.destinationY = function() {
return this._destinationY;
};
Game_Temp.prototype.setTouchState = function(target, state) {

this._touchTarget = target;
this._touchState = state;
};
Game_Temp.prototype.clearTouchState = function() {
this._touchTarget = null;
this._touchState = "";
};
Game_Temp.prototype.touchTarget = function() {
return this._touchTarget;
};
Game_Temp.prototype.touchState = function() {
return this._touchState;
};
Game_Temp.prototype.requestBattleRefresh = function() {
if ($gameParty.inBattle()) {
this._needsBattleRefresh = true;
}
};
Game_Temp.prototype.clearBattleRefreshRequest = function() {
this._needsBattleRefresh = false;
};
Game_Temp.prototype.isBattleRefreshRequested = function() {
return this._needsBattleRefresh;
};
Game_Temp.prototype.reserveCommonEvent = function(commonEventId) {
this._commonEventQueue.push(commonEventId);
};
Game_Temp.prototype.retrieveCommonEvent = function() {
return $dataCommonEvents[this._commonEventQueue.shift()];
};
Game_Temp.prototype.clearCommonEventReservation = function() {
this._commonEventQueue.length = 0;
};
Game_Temp.prototype.isCommonEventReserved = function() {
return this._commonEventQueue.length > 0;
};
// prettier-ignore
Game_Temp.prototype.requestAnimation = function(
targets, animationId, mirror = false
) {
if ($dataAnimations[animationId]) {
const request = {
targets: targets,
animationId: animationId,
mirror: mirror
};
this._animationQueue.push(request);
for (const target of targets) {
if (target.startAnimation) {
target.startAnimation();
}
}
}
};
Game_Temp.prototype.retrieveAnimation = function() {
return this._animationQueue.shift();
};
Game_Temp.prototype.requestBalloon = function(target, balloonId) {

const request = { target: target, balloonId: balloonId };
this._balloonQueue.push(request);
if (target.startBalloon) {
target.startBalloon();
}
};
Game_Temp.prototype.retrieveBalloon = function() {
return this._balloonQueue.shift();
};
Game_Temp.prototype.lastActionData = function(type) {
return this._lastActionData[type] || 0;
};
Game_Temp.prototype.setLastActionData = function(type, value) {

this._lastActionData[type] = value;
};
Game_Temp.prototype.setLastUsedSkillId = function(skillID) {
this.setLastActionData(0, skillID);
};
Game_Temp.prototype.setLastUsedItemId = function(itemID) {
this.setLastActionData(1, itemID);
};
Game_Temp.prototype.setLastSubjectActorId = function(actorID) {
this.setLastActionData(2, actorID);
};
Game_Temp.prototype.setLastSubjectEnemyIndex = function(enemyIndex) {
this.setLastActionData(3, enemyIndex);
};
Game_Temp.prototype.setLastTargetActorId = function(actorID) {
this.setLastActionData(4, actorID);
};
Game_Temp.prototype.setLastTargetEnemyIndex = function(enemyIndex) {
this.setLastActionData(5, enemyIndex);
};
//-----------------------------------------------------------------------------
// Game_System
//
// The game object class for the system data.
function Game_System() {
}
Game_System.prototype.initialize = function() {
this._saveEnabled = true;
this._menuEnabled = true;
this._encounterEnabled = true;
this._formationEnabled = true;
this._battleCount = 0;
this._winCount = 0;
this._escapeCount = 0;
this._saveCount = 0;
this._versionId = 0;
this._savefileId = 0;
this._framesOnSave = 0;
this._bgmOnSave = null;
this._bgsOnSave = null;
this._windowTone = null;
this._battleBgm = null;
this._victoryMe = null;
this._defeatMe = null;
this._savedBgm = null;
this._walkingBgm = null;
};
Game_System.prototype.isJapanese = function() {
return $dataSystem.locale.match(/^ja/);
};
Game_System.prototype.isChinese = function() {
return $dataSystem.locale.match(/^zh/);
};
Game_System.prototype.isKorean = function() {
return $dataSystem.locale.match(/^ko/);
};
Game_System.prototype.isCJK = function() {
return $dataSystem.locale.match(/^(ja|zh|ko)/);
};
Game_System.prototype.isRussian = function() {
return $dataSystem.locale.match(/^ru/);
};
Game_System.prototype.isSideView = function() {
return $dataSystem.optSideView;
};
Game_System.prototype.isAutosaveEnabled = function() {
return $dataSystem.optAutosave;
};
Game_System.prototype.isSaveEnabled = function() {
return this._saveEnabled;
};
Game_System.prototype.disableSave = function() {
this._saveEnabled = false;
};
Game_System.prototype.enableSave = function() {
this._saveEnabled = true;
};
Game_System.prototype.isMenuEnabled = function() {
return this._menuEnabled;
};
Game_System.prototype.disableMenu = function() {
this._menuEnabled = false;
};
Game_System.prototype.enableMenu = function() {
this._menuEnabled = true;
};
Game_System.prototype.isEncounterEnabled = function() {
return this._encounterEnabled;
};
Game_System.prototype.disableEncounter = function() {
this._encounterEnabled = false;
};
Game_System.prototype.enableEncounter = function() {
this._encounterEnabled = true;
};
Game_System.prototype.isFormationEnabled = function() {
return this._formationEnabled;
};
Game_System.prototype.disableFormation = function() {
this._formationEnabled = false;
};
Game_System.prototype.enableFormation = function() {
this._formationEnabled = true;
};
Game_System.prototype.battleCount = function() {
return this._battleCount;
};
Game_System.prototype.winCount = function() {
return this._winCount;
};
Game_System.prototype.escapeCount = function() {
return this._escapeCount;
};
Game_System.prototype.saveCount = function() {
return this._saveCount;
};
Game_System.prototype.versionId = function() {
return this._versionId;
};
Game_System.prototype.savefileId = function() {
return this._savefileId || 0;
};
Game_System.prototype.setSavefileId = function(savefileId) {
this._savefileId = savefileId;
};
Game_System.prototype.windowTone = function() {
return this._windowTone || $dataSystem.windowTone;
};
Game_System.prototype.setWindowTone = function(value) {
this._windowTone = value;
};
Game_System.prototype.battleBgm = function() {
return this._battleBgm || $dataSystem.battleBgm;
};
Game_System.prototype.setBattleBgm = function(value) {
this._battleBgm = value;
};
Game_System.prototype.victoryMe = function() {
return this._victoryMe || $dataSystem.victoryMe;
};
Game_System.prototype.setVictoryMe = function(value) {
this._victoryMe = value;
};
Game_System.prototype.defeatMe = function() {
return this._defeatMe || $dataSystem.defeatMe;
};
Game_System.prototype.setDefeatMe = function(value) {
this._defeatMe = value;
};
Game_System.prototype.onBattleStart = function() {
this._battleCount++;
};
Game_System.prototype.onBattleWin = function() {
this._winCount++;
};
Game_System.prototype.onBattleEscape = function() {
this._escapeCount++;
};
Game_System.prototype.onBeforeSave = function() {
this._saveCount++;
this._versionId = $dataSystem.versionId;
this._framesOnSave = Graphics.frameCount;
this._bgmOnSave = AudioManager.saveBgm();
this._bgsOnSave = AudioManager.saveBgs();
};
Game_System.prototype.onAfterLoad = function() {
Graphics.frameCount = this._framesOnSave;
AudioManager.playBgm(this._bgmOnSave);
AudioManager.playBgs(this._bgsOnSave);
};
Game_System.prototype.playtime = function() {
return Math.floor(Graphics.frameCount / 60);
};
Game_System.prototype.playtimeText = function() {
const hour = Math.floor(this.playtime() / 60 / 60);
const min = Math.floor(this.playtime() / 60) % 60;
const sec = this.playtime() % 60;
return hour.padZero(2) + ":" + min.padZero(2) + ":" + sec.padZero(2);
};
Game_System.prototype.saveBgm = function() {
this._savedBgm = AudioManager.saveBgm();
};
Game_System.prototype.replayBgm = function() {
if (this._savedBgm) {
AudioManager.replayBgm(this._savedBgm);
}
};
Game_System.prototype.saveWalkingBgm = function() {
this._walkingBgm = AudioManager.saveBgm();
};
Game_System.prototype.replayWalkingBgm = function() {
if (this._walkingBgm) {
AudioManager.playBgm(this._walkingBgm);
}
};
Game_System.prototype.saveWalkingBgm2 = function() {
this._walkingBgm = $dataMap.bgm;
};
Game_System.prototype.mainFontFace = function() {
return "rmmz-mainfont, " + $dataSystem.advanced.fallbackFonts;
};
Game_System.prototype.numberFontFace = function() {
return "rmmz-numberfont, " + this.mainFontFace();
};
Game_System.prototype.mainFontSize = function() {
return $dataSystem.advanced.fontSize;
};
Game_System.prototype.windowPadding = function() {
return 12;
};
Game_System.prototype.windowOpacity = function() {
return $dataSystem.advanced.windowOpacity;
};
//-----------------------------------------------------------------------------
// Game_Timer
//
// The game object class for the timer.
function Game_Timer() {
}
Game_Timer.prototype.initialize = function() {
this._frames = 0;
this._working = false;
};
Game_Timer.prototype.update = function(sceneActive) {
if (sceneActive && this._working && this._frames > 0) {
this._frames--;
if (this._frames === 0) {
this.onExpire();
}
}
};
Game_Timer.prototype.start = function(count) {
this._frames = count;
this._working = true;
};
Game_Timer.prototype.stop = function() {
this._working = false;
};
Game_Timer.prototype.isWorking = function() {
return this._working;
};
Game_Timer.prototype.seconds = function() {
return Math.floor(this._frames / 60);
};
Game_Timer.prototype.frames = function() {
return this._frames;
};
Game_Timer.prototype.onExpire = function() {
BattleManager.abort();
};
//-----------------------------------------------------------------------------
// Game_Message
//
// The game object class for the state of the message window that displays text
// or selections, etc.
function Game_Message() {
}
Game_Message.prototype.initialize = function() {
this.clear();
};
Game_Message.prototype.clear = function() {
this._texts = [];
this._choices = [];
this._speakerName = "";
this._faceName = "";
this._faceIndex = 0;
this._background = 0;
this._positionType = 2;
this._choiceDefaultType = 0;
this._choiceCancelType = 0;
this._choiceBackground = 0;
this._choicePositionType = 2;
this._numInputVariableId = 0;
this._numInputMaxDigits = 0;
this._itemChoiceVariableId = 0;
this._itemChoiceItypeId = 0;
this._scrollMode = false;
this._scrollSpeed = 2;
this._scrollNoFast = false;
this._choiceCallback = null;
};
Game_Message.prototype.choices = function() {
return this._choices;
};
Game_Message.prototype.speakerName = function() {
return this._speakerName;
};
Game_Message.prototype.faceName = function() {
return this._faceName;
};
Game_Message.prototype.faceIndex = function() {
return this._faceIndex;
};
Game_Message.prototype.background = function() {
return this._background;
};
Game_Message.prototype.positionType = function() {
return this._positionType;
};
Game_Message.prototype.choiceDefaultType = function() {
return this._choiceDefaultType;
};
Game_Message.prototype.choiceCancelType = function() {
return this._choiceCancelType;
};
Game_Message.prototype.choiceBackground = function() {
return this._choiceBackground;
};
Game_Message.prototype.choicePositionType = function() {
return this._choicePositionType;
};
Game_Message.prototype.numInputVariableId = function() {
return this._numInputVariableId;
};
Game_Message.prototype.numInputMaxDigits = function() {
return this._numInputMaxDigits;
};
Game_Message.prototype.itemChoiceVariableId = function() {
return this._itemChoiceVariableId;
};
Game_Message.prototype.itemChoiceItypeId = function() {
return this._itemChoiceItypeId;
};
Game_Message.prototype.scrollMode = function() {
return this._scrollMode;
};
Game_Message.prototype.scrollSpeed = function() {
return this._scrollSpeed;
};
Game_Message.prototype.scrollNoFast = function() {
return this._scrollNoFast;
};
Game_Message.prototype.add = function(text) {
this._texts.push(text);
};
Game_Message.prototype.setSpeakerName = function(speakerName) {
this._speakerName = speakerName ? speakerName : "";
};
Game_Message.prototype.setFaceImage = function(faceName, faceIndex) {

this._faceName = faceName;
this._faceIndex = faceIndex;
};
Game_Message.prototype.setBackground = function(background) {
this._background = background;
};
Game_Message.prototype.setPositionType = function(positionType) {
this._positionType = positionType;
};
Game_Message.prototype.setChoices = function(choices, defaultType, cancelType) {

this._choices = choices;
this._choiceDefaultType = defaultType;
this._choiceCancelType = cancelType;
};
Game_Message.prototype.setChoiceBackground = function(background) {
this._choiceBackground = background;
};
Game_Message.prototype.setChoicePositionType = function(positionType) {
this._choicePositionType = positionType;
};
Game_Message.prototype.setNumberInput = function(variableId, maxDigits) {

this._numInputVariableId = variableId;
this._numInputMaxDigits = maxDigits;
};
Game_Message.prototype.setItemChoice = function(variableId, itemType) {

this._itemChoiceVariableId = variableId;
this._itemChoiceItypeId = itemType;
};
Game_Message.prototype.setScroll = function(speed, noFast) {

this._scrollMode = true;
this._scrollSpeed = speed;
this._scrollNoFast = noFast;
};
Game_Message.prototype.setChoiceCallback = function(callback) {
this._choiceCallback = callback;
};
Game_Message.prototype.onChoice = function(n) {
if (this._choiceCallback) {
this._choiceCallback(n);
this._choiceCallback = null;
}
};
Game_Message.prototype.hasText = function() {
return this._texts.length > 0;
};
Game_Message.prototype.isChoice = function() {
return this._choices.length > 0;
};
Game_Message.prototype.isNumberInput = function() {
return this._numInputVariableId > 0;
};
Game_Message.prototype.isItemChoice = function() {
return this._itemChoiceVariableId > 0;
};
Game_Message.prototype.isBusy = function() {
return (
this.hasText() ||
this.isChoice() ||
this.isNumberInput() ||
this.isItemChoice()
);
};
Game_Message.prototype.newPage = function() {
if (this._texts.length > 0) {
this._texts[this._texts.length - 1] += "\f";
}
};
Game_Message.prototype.allText = function() {
return this._texts.join("\n");
};
Game_Message.prototype.isRTL = function() {
return Utils.containsArabic(this.allText());
};
//-----------------------------------------------------------------------------
// Game_Switches
//
// The game object class for switches.
function Game_Switches() {
}
Game_Switches.prototype.initialize = function() {
this.clear();
};
Game_Switches.prototype.clear = function() {
this._data = [];
};
Game_Switches.prototype.value = function(switchId) {
return !!this._data[switchId];
};
Game_Switches.prototype.setValue = function(switchId, value) {

if (switchId > 0 && switchId < $dataSystem.switches.length) {
this._data[switchId] = value;
this.onChange();
}
};
Game_Switches.prototype.onChange = function() {
$gameMap.requestRefresh();
};
//-----------------------------------------------------------------------------
// Game_Variables
//
// The game object class for variables.
function Game_Variables() {
}
Game_Variables.prototype.initialize = function() {
this.clear();
};
Game_Variables.prototype.clear = function() {
this._data = [];
};
Game_Variables.prototype.value = function(variableId) {
return this._data[variableId] || 0;
};
Game_Variables.prototype.setValue = function(variableId, value) {

if (variableId > 0 && variableId < $dataSystem.variables.length) {
if (typeof value === "number") {
value = Math.floor(value);
}
this._data[variableId] = value;
this.onChange();
}
};
Game_Variables.prototype.onChange = function() {
};
//-----------------------------------------------------------------------------
// Game_SelfSwitches
//
// The game object class for self switches.
function Game_SelfSwitches() {
}
Game_SelfSwitches.prototype.initialize = function() {
this.clear();
};
Game_SelfSwitches.prototype.clear = function() {
this._data = {};
};
Game_SelfSwitches.prototype.value = function(key) {
return !!this._data[key];
};
Game_SelfSwitches.prototype.setValue = function(key, value) {

if (value) {
this._data[key] = true;
} else {
delete this._data[key];
}
this.onChange();
};
Game_SelfSwitches.prototype.onChange = function() {
};
//-----------------------------------------------------------------------------
// Game_Screen
//
// The game object class for screen effect data, such as changes in color tone
// and flashes.
function Game_Screen() {
}
Game_Screen.prototype.initialize = function() {
this.clear();
};
Game_Screen.prototype.clear = function() {
this.clearFade();
this.clearTone();
this.clearFlash();
this.clearShake();
this.clearZoom();
this.clearWeather();
this.clearPictures();
};
Game_Screen.prototype.onBattleStart = function() {
this.clearFade();
this.clearFlash();
this.clearShake();
this.clearZoom();
this.eraseBattlePictures();
};
Game_Screen.prototype.brightness = function() {
return this._brightness;
};
Game_Screen.prototype.tone = function() {
return this._tone;
};
Game_Screen.prototype.flashColor = function() {
return this._flashColor;
};
Game_Screen.prototype.shake = function() {
return this._shake;
};
Game_Screen.prototype.zoomX = function() {
return this._zoomX;
};
Game_Screen.prototype.zoomY = function() {
return this._zoomY;
};
Game_Screen.prototype.zoomScale = function() {
return this._zoomScale;
};
Game_Screen.prototype.weatherType = function() {
return this._weatherType;
};
Game_Screen.prototype.weatherPower = function() {
return this._weatherPower;
};
Game_Screen.prototype.picture = function(pictureId) {
const realPictureId = this.realPictureId(pictureId);
return this._pictures[realPictureId];
};
Game_Screen.prototype.realPictureId = function(pictureId) {
return pictureId + this.maxPictures();
} else {
return pictureId;
}
};
Game_Screen.prototype.clearFade = function() {
this._brightness = 255;
this._fadeOutDuration = 0;
this._fadeInDuration = 0;
};
Game_Screen.prototype.clearTone = function() {
this._tone = [0, 0, 0, 0];
this._toneTarget = [0, 0, 0, 0];
this._toneDuration = 0;
};
Game_Screen.prototype.clearFlash = function() {
this._flashColor = [0, 0, 0, 0];
this._flashDuration = 0;
};
Game_Screen.prototype.clearShake = function() {
this._shakePower = 0;
this._shakeSpeed = 0;
this._shakeDuration = 0;
this._shakeDirection = 1;
this._shake = 0;
};
Game_Screen.prototype.clearZoom = function() {
this._zoomX = 0;
this._zoomY = 0;
this._zoomScale = 1;
this._zoomScaleTarget = 1;
this._zoomDuration = 0;
};
Game_Screen.prototype.clearWeather = function() {
this._weatherType = "none";
this._weatherPower = 0;
this._weatherPowerTarget = 0;
this._weatherDuration = 0;
};
Game_Screen.prototype.clearPictures = function() {
this._pictures = [];
};
Game_Screen.prototype.eraseBattlePictures = function() {
this._pictures = this._pictures.slice(0, this.maxPictures() + 1);
};
Game_Screen.prototype.maxPictures = function() {
return 100;
};
Game_Screen.prototype.startFadeOut = function(duration) {
this._fadeOutDuration = duration;
this._fadeInDuration = 0;
};
Game_Screen.prototype.startFadeIn = function(duration) {
this._fadeInDuration = duration;
this._fadeOutDuration = 0;
};
Game_Screen.prototype.startTint = function(tone, duration) {

this._toneTarget = tone.clone();
this._toneDuration = duration;
if (this._toneDuration === 0) {
this._tone = this._toneTarget.clone();
}
};
Game_Screen.prototype.startFlash = function(color, duration) {

this._flashColor = color.clone();
this._flashDuration = duration;
};
Game_Screen.prototype.startShake = function(power, speed, duration) {

this._shakePower = power;
this._shakeSpeed = speed;
this._shakeDuration = duration;
};
Game_Screen.prototype.startZoom = function(x, y, scale, duration) {

this._zoomX = x;
this._zoomY = y;
this._zoomScaleTarget = scale;
this._zoomDuration = duration;
};
Game_Screen.prototype.setZoom = function(x, y, scale) {

this._zoomX = x;
this._zoomY = y;
this._zoomScale = scale;
};
Game_Screen.prototype.changeWeather = function(type, power, duration) {
if (type !== "none" || duration === 0) {
this._weatherType = type;
}
this._weatherPowerTarget = type === "none" ? 0 : power;
this._weatherDuration = duration;
if (duration === 0) {
this._weatherPower = this._weatherPowerTarget;
}
};
Game_Screen.prototype.update = function() {
this.updateFadeOut();
this.updateFadeIn();
this.updateTone();
this.updateFlash();
this.updateShake();
this.updateZoom();
this.updateWeather();
this.updatePictures();
};
Game_Screen.prototype.updateFadeOut = function() {
if (this._fadeOutDuration > 0) {
const d = this._fadeOutDuration;
this._brightness = (this._brightness * (d - 1)) / d;
this._fadeOutDuration--;
}
};
Game_Screen.prototype.updateFadeIn = function() {
if (this._fadeInDuration > 0) {
const d = this._fadeInDuration;
this._brightness = (this._brightness * (d - 1) + 255) / d;
this._fadeInDuration--;
}
};
Game_Screen.prototype.updateTone = function() {
if (this._toneDuration > 0) {
const d = this._toneDuration;
for (let i = 0; i < 4; i++) {
this._tone[i] = (this._tone[i] * (d - 1) + this._toneTarget[i]) / d;
}
this._toneDuration--;
}
};
Game_Screen.prototype.updateFlash = function() {
if (this._flashDuration > 0) {
const d = this._flashDuration;
this._flashColor[3] *= (d - 1) / d;
this._flashDuration--;
}
};
Game_Screen.prototype.updateShake = function() {
if (this._shakeDuration > 0 || this._shake !== 0) {
const delta =
(this._shakePower * this._shakeSpeed * this._shakeDirection) / 10;
if (
this._shakeDuration <= 1 &&
this._shake * (this._shake + delta) < 0
) {
this._shake = 0;
} else {
this._shake += delta;
}
if (this._shake > this._shakePower * 2) {
this._shakeDirection = -1;
}
if (this._shake < -this._shakePower * 2) {
this._shakeDirection = 1;
}
this._shakeDuration--;
}
};
Game_Screen.prototype.updateZoom = function() {
if (this._zoomDuration > 0) {
const d = this._zoomDuration;
const t = this._zoomScaleTarget;
this._zoomScale = (this._zoomScale * (d - 1) + t) / d;
this._zoomDuration--;
}
};
Game_Screen.prototype.updateWeather = function() {
if (this._weatherDuration > 0) {
const d = this._weatherDuration;
const t = this._weatherPowerTarget;
this._weatherPower = (this._weatherPower * (d - 1) + t) / d;
this._weatherDuration--;
if (this._weatherDuration === 0 && this._weatherPowerTarget === 0) {
this._weatherType = "none";
}
}
};
Game_Screen.prototype.updatePictures = function() {
for (const picture of this._pictures) {
if (picture) {
picture.update();
}
}
};
Game_Screen.prototype.startFlashForDamage = function() {
this.startFlash([255, 0, 0, 128], 8);
};
// prettier-ignore
Game_Screen.prototype.showPicture = function(
pictureId, name, origin, x, y, scaleX, scaleY, opacity, blendMode
) {
const picture = new Game_Picture();
picture.show(name, origin, x, y, scaleX, scaleY, opacity, blendMode);
this._pictures[realPictureId] = picture;
};
// prettier-ignore
Game_Screen.prototype.movePicture = function(
pictureId, origin, x, y, scaleX, scaleY, opacity, blendMode, duration,
easingType
) {
const picture = this.picture(pictureId);
if (picture) {
// prettier-ignore
picture.move(origin, x, y, scaleX, scaleY, opacity, blendMode,
duration, easingType);
}
};
Game_Screen.prototype.rotatePicture = function(pictureId, speed) {

if (picture) {
picture.rotate(speed);
}
};
Game_Screen.prototype.tintPicture = function(pictureId, tone, duration) {

if (picture) {
picture.tint(tone, duration);
}
};
Game_Screen.prototype.erasePicture = function(pictureId) {
this._pictures[realPictureId] = null;
};
//-----------------------------------------------------------------------------
// Game_Picture
//
// The game object class for a picture.
function Game_Picture() {
}
Game_Picture.prototype.initialize = function() {
this.initBasic();
this.initTarget();
this.initTone();
this.initRotation();
};
Game_Picture.prototype.name = function() {
return this._name;
};
Game_Picture.prototype.origin = function() {
return this._origin;
};
Game_Picture.prototype.x = function() {
return this._x;
};
Game_Picture.prototype.y = function() {
return this._y;
};
Game_Picture.prototype.scaleX = function() {
return this._scaleX;
};
Game_Picture.prototype.scaleY = function() {
return this._scaleY;
};
Game_Picture.prototype.opacity = function() {
return this._opacity;
};
Game_Picture.prototype.blendMode = function() {
return this._blendMode;
};
Game_Picture.prototype.tone = function() {
return this._tone;
};
Game_Picture.prototype.angle = function() {
return this._angle;
};
Game_Picture.prototype.initBasic = function() {
this._name = "";
this._origin = 0;
this._x = 0;
this._y = 0;
this._scaleX = 100;
this._scaleY = 100;
this._opacity = 255;
this._blendMode = 0;
};
Game_Picture.prototype.initTarget = function() {
this._targetX = this._x;
this._targetY = this._y;
this._targetScaleX = this._scaleX;
this._targetScaleY = this._scaleY;
this._targetOpacity = this._opacity;
this._duration = 0;
this._wholeDuration = 0;
this._easingType = 0;
this._easingExponent = 0;
};
Game_Picture.prototype.initTone = function() {
this._tone = null;
this._toneTarget = null;
this._toneDuration = 0;
};
Game_Picture.prototype.initRotation = function() {
this._angle = 0;
this._rotationSpeed = 0;
};
// prettier-ignore
Game_Picture.prototype.show = function(
name, origin, x, y, scaleX, scaleY, opacity, blendMode
) {
this._name = name;
this._origin = origin;
this._x = x;
this._y = y;
this._scaleX = scaleX;
this._scaleY = scaleY;
this._opacity = opacity;
this._blendMode = blendMode;
this.initTarget();
this.initTone();
this.initRotation();
};
// prettier-ignore
Game_Picture.prototype.move = function(
origin, x, y, scaleX, scaleY, opacity, blendMode, duration, easingType
) {
this._origin = origin;
this._targetX = x;
this._targetY = y;
this._targetScaleX = scaleX;
this._targetScaleY = scaleY;
this._targetOpacity = opacity;
this._duration = duration;
this._wholeDuration = duration;
this._easingType = easingType;
this._easingExponent = 2;
};
Game_Picture.prototype.rotate = function(speed) {
this._rotationSpeed = speed;
};
Game_Picture.prototype.tint = function(tone, duration) {

if (!this._tone) {
this._tone = [0, 0, 0, 0];
}
this._toneTarget = tone.clone();
this._toneDuration = duration;
if (this._toneDuration === 0) {
this._tone = this._toneTarget.clone();
}
};
Game_Picture.prototype.update = function() {
this.updateMove();
this.updateTone();
this.updateRotation();
};
Game_Picture.prototype.updateMove = function() {
if (this._duration > 0) {
this._x = this.applyEasing(this._x, this._targetX);
this._y = this.applyEasing(this._y, this._targetY);
this._scaleX = this.applyEasing(this._scaleX, this._targetScaleX);
this._scaleY = this.applyEasing(this._scaleY, this._targetScaleY);
this._opacity = this.applyEasing(this._opacity, this._targetOpacity);
this._duration--;
}
};
Game_Picture.prototype.updateTone = function() {
if (this._toneDuration > 0) {
const d = this._toneDuration;
for (let i = 0; i < 4; i++) {
this._tone[i] = (this._tone[i] * (d - 1) + this._toneTarget[i]) / d;
}
this._toneDuration--;
}
};
Game_Picture.prototype.updateRotation = function() {
if (this._rotationSpeed !== 0) {
this._angle += this._rotationSpeed / 2;
}
};
Game_Picture.prototype.applyEasing = function(current, target) {

const d = this._duration;
const wd = this._wholeDuration;
const lt = this.calcEasing((wd - d) / wd);
const t = this.calcEasing((wd - d + 1) / wd);
const start = (current - target * lt) / (1 - lt);
return start + (target - start) * t;
};
Game_Picture.prototype.calcEasing = function(t) {
const exponent = this._easingExponent;
switch (this._easingType) {
case 1: // Slow start
return this.easeIn(t, exponent);
case 2: // Slow end
return this.easeOut(t, exponent);
case 3: // Slow start and end
return this.easeInOut(t, exponent);
default:
return t;
}
};
Game_Picture.prototype.easeIn = function(t, exponent) {

return Math.pow(t, exponent);
};
Game_Picture.prototype.easeOut = function(t, exponent) {

return 1 - Math.pow(1 - t, exponent);
};
Game_Picture.prototype.easeInOut = function(t, exponent) {

if (t < 0.5) {
return this.easeIn(t * 2, exponent) / 2;
} else {
return this.easeOut(t * 2 - 1, exponent) / 2 + 0.5;
}
};
//-----------------------------------------------------------------------------
// Game_Item
//
// The game object class for handling skills, items, weapons, and armor. It is
// required because save data should not include the database object itself.
function Game_Item() {
}
Game_Item.prototype.initialize = function(item) {
this._dataClass = "";
this._itemId = 0;
if (item) {
this.setObject(item);
}
};
Game_Item.prototype.isSkill = function() {
return this._dataClass === "skill";
};
Game_Item.prototype.isItem = function() {
return this._dataClass === "item";
};
Game_Item.prototype.isUsableItem = function() {
return this.isSkill() || this.isItem();
};
Game_Item.prototype.isWeapon = function() {
return this._dataClass === "weapon";
};
Game_Item.prototype.isArmor = function() {
return this._dataClass === "armor";
};
Game_Item.prototype.isEquipItem = function() {
return this.isWeapon() || this.isArmor();
};
Game_Item.prototype.isNull = function() {
return this._dataClass === "";
};
Game_Item.prototype.itemId = function() {
return this._itemId;
};
Game_Item.prototype.object = function() {
if (this.isSkill()) {
return $dataSkills[this._itemId];
} else if (this.isItem()) {
return $dataItems[this._itemId];
} else if (this.isWeapon()) {
return $dataWeapons[this._itemId];
} else if (this.isArmor()) {
return $dataArmors[this._itemId];
} else {
return null;
}
};
Game_Item.prototype.setObject = function(item) {
if (DataManager.isSkill(item)) {
this._dataClass = "skill";
} else if (DataManager.isItem(item)) {
this._dataClass = "item";
} else if (DataManager.isWeapon(item)) {
this._dataClass = "weapon";
} else if (DataManager.isArmor(item)) {
this._dataClass = "armor";
} else {
this._dataClass = "";
}
this._itemId = item ? item.id : 0;
};
Game_Item.prototype.setEquip = function(isWeapon, itemId) {

this._dataClass = isWeapon ? "weapon" : "armor";
this._itemId = itemId;
};
//-----------------------------------------------------------------------------
// Game_Action
//
// The game object class for a battle action.
function Game_Action() {
}
Game_Action.EFFECT_RECOVER_HP = 11;
Game_Action.EFFECT_RECOVER_MP = 12;
Game_Action.EFFECT_GAIN_TP = 13;
Game_Action.EFFECT_ADD_STATE = 21;
Game_Action.EFFECT_REMOVE_STATE = 22;
Game_Action.EFFECT_ADD_BUFF = 31;
Game_Action.EFFECT_ADD_DEBUFF = 32;
Game_Action.EFFECT_REMOVE_BUFF = 33;
Game_Action.EFFECT_REMOVE_DEBUFF = 34;
Game_Action.EFFECT_SPECIAL = 41;
Game_Action.EFFECT_GROW = 42;
Game_Action.EFFECT_LEARN_SKILL = 43;
Game_Action.EFFECT_COMMON_EVENT = 44;
Game_Action.SPECIAL_EFFECT_ESCAPE = 0;
Game_Action.HITTYPE_CERTAIN = 0;
Game_Action.HITTYPE_PHYSICAL = 1;
Game_Action.HITTYPE_MAGICAL = 2;
Game_Action.prototype.initialize = function(subject, forcing) {

this._subjectActorId = 0;
this._subjectEnemyIndex = -1;
this._forcing = forcing || false;
this.setSubject(subject);
this.clear();
};
Game_Action.prototype.clear = function() {
this._item = new Game_Item();
this._targetIndex = -1;
};
Game_Action.prototype.setSubject = function(subject) {
if (subject.isActor()) {
this._subjectActorId = subject.actorId();
this._subjectEnemyIndex = -1;
} else {
this._subjectEnemyIndex = subject.index();
this._subjectActorId = 0;
}
};
Game_Action.prototype.subject = function() {
if (this._subjectActorId > 0) {
return $gameActors.actor(this._subjectActorId);
} else {
return $gameTroop.members()[this._subjectEnemyIndex];
}
};
Game_Action.prototype.friendsUnit = function() {
return this.subject().friendsUnit();
};
Game_Action.prototype.opponentsUnit = function() {
return this.subject().opponentsUnit();
};
Game_Action.prototype.setEnemyAction = function(action) {
if (action) {
this.setSkill(action.skillId);
} else {
this.clear();
}
};
Game_Action.prototype.setAttack = function() {
this.setSkill(this.subject().attackSkillId());
};
Game_Action.prototype.setGuard = function() {
this.setSkill(this.subject().guardSkillId());
};
Game_Action.prototype.setSkill = function(skillId) {
this._item.setObject($dataSkills[skillId]);
};
Game_Action.prototype.setItem = function(itemId) {
this._item.setObject($dataItems[itemId]);
};
Game_Action.prototype.setItemObject = function(object) {
this._item.setObject(object);
};
Game_Action.prototype.setTarget = function(targetIndex) {
this._targetIndex = targetIndex;
};
Game_Action.prototype.item = function() {
return this._item.object();
};
Game_Action.prototype.isSkill = function() {
return this._item.isSkill();
};
Game_Action.prototype.isItem = function() {
return this._item.isItem();
};
Game_Action.prototype.numRepeats = function() {
let repeats = this.item().repeats;
if (this.isAttack()) {
repeats += this.subject().attackTimesAdd();
}
return Math.floor(repeats);
};
Game_Action.prototype.checkItemScope = function(list) {
return list.includes(this.item().scope);
};
Game_Action.prototype.isForOpponent = function() {
return this.checkItemScope([1, 2, 3, 4, 5, 6, 14]);
};
Game_Action.prototype.isForFriend = function() {
return this.checkItemScope([7, 8, 9, 10, 11, 12, 13, 14]);
};
Game_Action.prototype.isForEveryone = function() {
return this.checkItemScope([14]);
};
Game_Action.prototype.isForAliveFriend = function() {
return this.checkItemScope([7, 8, 11, 14]);
};
Game_Action.prototype.isForDeadFriend = function() {
return this.checkItemScope([9, 10]);
};
Game_Action.prototype.isForUser = function() {
return this.checkItemScope([11]);
};
Game_Action.prototype.isForOne = function() {
return this.checkItemScope([1, 3, 7, 9, 11, 12]);
};
Game_Action.prototype.isForRandom = function() {
};
Game_Action.prototype.isForAll = function() {
return this.checkItemScope([2, 8, 10, 13, 14]);
};
Game_Action.prototype.needsSelection = function() {
};
Game_Action.prototype.numTargets = function() {
return this.isForRandom() ? this.item().scope - 2 : 0;
};
Game_Action.prototype.checkDamageType = function(list) {
return list.includes(this.item().damage.type);
};
Game_Action.prototype.isHpEffect = function() {
return this.checkDamageType([1, 3, 5]);
};
Game_Action.prototype.isMpEffect = function() {
return this.checkDamageType([2, 4, 6]);
};
Game_Action.prototype.isDamage = function() {
return this.checkDamageType([1, 2]);
};
Game_Action.prototype.isRecover = function() {
};
Game_Action.prototype.isDrain = function() {
};
Game_Action.prototype.isHpRecover = function() {
return this.checkDamageType([3]);
};
Game_Action.prototype.isMpRecover = function() {
return this.checkDamageType([4]);
};
Game_Action.prototype.isCertainHit = function() {
return this.item().hitType === Game_Action.HITTYPE_CERTAIN;
};
Game_Action.prototype.isPhysical = function() {
return this.item().hitType === Game_Action.HITTYPE_PHYSICAL;
};
Game_Action.prototype.isMagical = function() {
return this.item().hitType === Game_Action.HITTYPE_MAGICAL;
};
Game_Action.prototype.isAttack = function() {
return this.item() === $dataSkills[this.subject().attackSkillId()];
};
Game_Action.prototype.isGuard = function() {
return this.item() === $dataSkills[this.subject().guardSkillId()];
};
Game_Action.prototype.isMagicSkill = function() {
if (this.isSkill()) {
return $dataSystem.magicSkills.includes(this.item().stypeId);
} else {
return false;
}
};
Game_Action.prototype.decideRandomTarget = function() {
let target;
if (this.isForDeadFriend()) {
target = this.friendsUnit().randomDeadTarget();
} else if (this.isForFriend()) {
target = this.friendsUnit().randomTarget();
} else {
target = this.opponentsUnit().randomTarget();
}
if (target) {
this._targetIndex = target.index();
} else {
this.clear();
}
};
Game_Action.prototype.setConfusion = function() {
this.setAttack();
};
Game_Action.prototype.prepare = function() {
if (this.subject().isConfused() && !this._forcing) {
this.setConfusion();
}
};
Game_Action.prototype.isValid = function() {
return (this._forcing && this.item()) || this.subject().canUse(this.item());
};
Game_Action.prototype.speed = function() {
const agi = this.subject().agi;
let speed = agi + Math.randomInt(Math.floor(5 + agi / 4));
if (this.item()) {
speed += this.item().speed;
}
if (this.isAttack()) {
speed += this.subject().attackSpeed();
}
return speed;
};
Game_Action.prototype.makeTargets = function() {
const targets = [];
if (!this._forcing && this.subject().isConfused()) {
targets.push(this.confusionTarget());
} else if (this.isForEveryone()) {
targets.push(...this.targetsForEveryone());
} else if (this.isForOpponent()) {
targets.push(...this.targetsForOpponents());
} else if (this.isForFriend()) {
targets.push(...this.targetsForFriends());
}
return this.repeatTargets(targets);
};
Game_Action.prototype.repeatTargets = function(targets) {
const repeatedTargets = [];
const repeats = this.numRepeats();
for (const target of targets) {
if (target) {
for (let i = 0; i < repeats; i++) {
repeatedTargets.push(target);
}
}
}
return repeatedTargets;
};
Game_Action.prototype.confusionTarget = function() {
switch (this.subject().confusionLevel()) {
case 1:
return this.opponentsUnit().randomTarget();
case 2:
if (Math.randomInt(2) === 0) {
return this.opponentsUnit().randomTarget();
}
return this.friendsUnit().randomTarget();
default:
return this.friendsUnit().randomTarget();
}
};
Game_Action.prototype.targetsForEveryone = function() {
const opponentMembers = this.opponentsUnit().aliveMembers();
const friendMembers = this.friendsUnit().aliveMembers();
return opponentMembers.concat(friendMembers);
};
Game_Action.prototype.targetsForOpponents = function() {
const unit = this.opponentsUnit();
if (this.isForRandom()) {
return this.randomTargets(unit);
} else {
return this.targetsForAlive(unit);
}
};
Game_Action.prototype.targetsForFriends = function() {
const unit = this.friendsUnit();
if (this.isForUser()) {
return [this.subject()];
} else if (this.isForDeadFriend()) {
return this.targetsForDead(unit);
} else if (this.isForAliveFriend()) {
return this.targetsForAlive(unit);
} else {
return this.targetsForDeadAndAlive(unit);
}
};
Game_Action.prototype.randomTargets = function(unit) {
const targets = [];
for (let i = 0; i < this.numTargets(); i++) {
targets.push(unit.randomTarget());
}
return targets;
};
Game_Action.prototype.targetsForDead = function(unit) {
if (this.isForOne()) {
return [unit.smoothDeadTarget(this._targetIndex)];
} else {
return unit.deadMembers();
}
};
Game_Action.prototype.targetsForAlive = function(unit) {
if (this._targetIndex < 0) {
return [unit.randomTarget()];
} else {
return [unit.smoothTarget(this._targetIndex)];
}
} else {
return unit.aliveMembers();
}
};
Game_Action.prototype.targetsForDeadAndAlive = function(unit) {
return [unit.members()[this._targetIndex]];
} else {
return unit.members();
}
};
Game_Action.prototype.evaluate = function() {
let value = 0;
for (const target of this.itemTargetCandidates()) {
const targetValue = this.evaluateWithTarget(target);
if (this.isForAll()) {
value += targetValue;
} else if (targetValue > value) {
value = targetValue;
this._targetIndex = target.index();
}
}
value *= this.numRepeats();
if (value > 0) {
value += Math.random();
}
return value;
};
Game_Action.prototype.itemTargetCandidates = function() {
if (!this.isValid()) {
return [];
} else if (this.isForOpponent()) {
return this.opponentsUnit().aliveMembers();
} else if (this.isForUser()) {
return [this.subject()];
return this.friendsUnit().deadMembers();
} else {
return this.friendsUnit().aliveMembers();
}
};
Game_Action.prototype.evaluateWithTarget = function(target) {
if (this.isHpEffect()) {
const value = this.makeDamageValue(target, false);
if (this.isForOpponent()) {
return value / Math.max(target.hp, 1);
} else {
const recovery = Math.min(-value, target.mhp - target.hp);
return recovery / target.mhp;
}
}
};
Game_Action.prototype.testApply = function(target) {
return (
this.testLifeAndDeath(target) &&
($gameParty.inBattle() ||
(this.isHpRecover() && target.hp < target.mhp) ||
(this.isMpRecover() && target.mp < target.mmp) ||
this.hasItemAnyValidEffects(target))
);
};
Game_Action.prototype.testLifeAndDeath = function(target) {
if (this.isForOpponent() || this.isForAliveFriend()) {
return target.isAlive();
return target.isDead();
} else {
return true;
}
};
Game_Action.prototype.hasItemAnyValidEffects = function(target) {
return this.item().effects.some(effect =>
this.testItemEffect(target, effect)
);
};
Game_Action.prototype.testItemEffect = function(target, effect) {

switch (effect.code) {
case Game_Action.EFFECT_RECOVER_HP:
return (
target.hp < target.mhp || effect.value1 < 0 || effect.value2 < 0
);
case Game_Action.EFFECT_RECOVER_MP:
return (
target.mp < target.mmp || effect.value1 < 0 || effect.value2 < 0
);
case Game_Action.EFFECT_ADD_STATE:
return !target.isStateAffected(effect.dataId);
case Game_Action.EFFECT_REMOVE_STATE:
return target.isStateAffected(effect.dataId);
case Game_Action.EFFECT_ADD_BUFF:
return !target.isMaxBuffAffected(effect.dataId);
case Game_Action.EFFECT_ADD_DEBUFF:
return !target.isMaxDebuffAffected(effect.dataId);
case Game_Action.EFFECT_REMOVE_BUFF:
return target.isBuffAffected(effect.dataId);
case Game_Action.EFFECT_REMOVE_DEBUFF:
return target.isDebuffAffected(effect.dataId);
case Game_Action.EFFECT_LEARN_SKILL:
return target.isActor() && !target.isLearnedSkill(effect.dataId);
default:
return true;
}
};
Game_Action.prototype.itemCnt = function(target) {
if (this.isPhysical() && target.canMove()) {
return target.cnt;
} else {
return 0;
}
};
Game_Action.prototype.itemMrf = function(target) {
if (this.isMagical()) {
return target.mrf;
} else {
return 0;
}
};
Game_Action.prototype.itemHit = function(/*target*/) {
const successRate = this.item().successRate;
if (this.isPhysical()) {
return successRate * 0.01 * this.subject().hit;
} else {
return successRate * 0.01;
}
};
Game_Action.prototype.itemEva = function(target) {
return target.eva;
} else if (this.isMagical()) {
return target.mev;
} else {
return 0;
}
};
Game_Action.prototype.itemCri = function(target) {
return this.item().damage.critical
? this.subject().cri * (1 - target.cev)
: 0;
};
Game_Action.prototype.apply = function(target) {
const result = target.result();
this.subject().clearResult();
result.clear();
result.used = this.testApply(target);
result.missed = result.used && Math.random() >= this.itemHit(target);
result.evaded = !result.missed && Math.random() < this.itemEva(target);
result.physical = this.isPhysical();
result.drain = this.isDrain();
if (result.isHit()) {
if (this.item().damage.type > 0) {
result.critical = Math.random() < this.itemCri(target);
const value = this.makeDamageValue(target, result.critical);
this.executeDamage(target, value);
}
for (const effect of this.item().effects) {
this.applyItemEffect(target, effect);
}
this.applyItemUserEffect(target);
}
this.updateLastTarget(target);
};
Game_Action.prototype.makeDamageValue = function(target, critical) {

const item = this.item();
const baseValue = this.evalDamageFormula(target);
let value = baseValue * this.calcElementRate(target);
value *= target.pdr;
}
if (this.isMagical()) {
value *= target.mdr;
}
if (baseValue < 0) {
value *= target.rec;
}
if (critical) {
value = this.applyCritical(value);
}
value = this.applyVariance(value, item.damage.variance);
value = this.applyGuard(value, target);
value = Math.round(value);
return value;
};
Game_Action.prototype.evalDamageFormula = function(target) {
try {
const a = this.subject(); // eslint-disable-line no-unused-vars
const b = target; // eslint-disable-line no-unused-vars
const v = $gameVariables._data; // eslint-disable-line no-unused-vars
const sign = [3, 4].includes(item.damage.type) ? -1 : 1;
const value = Math.max(eval(item.damage.formula), 0) * sign;
return isNaN(value) ? 0 : value;
} catch (e) {
return 0;
}
};
Game_Action.prototype.calcElementRate = function(target) {
if (this.item().damage.elementId < 0) {
return this.elementsMaxRate(target, this.subject().attackElements());
} else {
return target.elementRate(this.item().damage.elementId);
}
};
Game_Action.prototype.elementsMaxRate = function(target, elements) {

if (elements.length > 0) {
const rates = elements.map(elementId => target.elementRate(elementId));
return Math.max(...rates);
} else {
return 1;
}
};
Game_Action.prototype.applyCritical = function(damage) {
return damage * 3;
};
Game_Action.prototype.applyVariance = function(damage, variance) {

const amp = Math.floor(Math.max((Math.abs(damage) * variance) / 100, 0));
const v = Math.randomInt(amp + 1) + Math.randomInt(amp + 1) - amp;
return damage >= 0 ? damage + v : damage - v;
};
Game_Action.prototype.applyGuard = function(damage, target) {

return damage / (damage > 0 && target.isGuard() ? 2 * target.grd : 1);
};
Game_Action.prototype.executeDamage = function(target, value) {

const result = target.result();
if (value === 0) {
result.critical = false;
}
if (this.isHpEffect()) {
this.executeHpDamage(target, value);
}
if (this.isMpEffect()) {
this.executeMpDamage(target, value);
}
};
Game_Action.prototype.executeHpDamage = function(target, value) {

if (this.isDrain()) {
value = Math.min(target.hp, value);
}
this.makeSuccess(target);
target.gainHp(-value);
if (value > 0) {
target.onDamage(value);
}
this.gainDrainedHp(value);
};
Game_Action.prototype.executeMpDamage = function(target, value) {

if (!this.isMpRecover()) {
value = Math.min(target.mp, value);
}
if (value !== 0) {
}
target.gainMp(-value);
this.gainDrainedMp(value);
};
Game_Action.prototype.gainDrainedHp = function(value) {
let gainTarget = this.subject();
if (this._reflectionTarget) {
gainTarget = this._reflectionTarget;
}
gainTarget.gainHp(value);
}
};
Game_Action.prototype.gainDrainedMp = function(value) {
let gainTarget = this.subject();
if (this._reflectionTarget) {
gainTarget = this._reflectionTarget;
}
gainTarget.gainMp(value);
}
};
Game_Action.prototype.applyItemEffect = function(target, effect) {

switch (effect.code) {
case Game_Action.EFFECT_RECOVER_HP:
this.itemEffectRecoverHp(target, effect);
break;
case Game_Action.EFFECT_RECOVER_MP:
this.itemEffectRecoverMp(target, effect);
break;
case Game_Action.EFFECT_GAIN_TP:
this.itemEffectGainTp(target, effect);
break;
case Game_Action.EFFECT_ADD_STATE:
this.itemEffectAddState(target, effect);
break;
case Game_Action.EFFECT_REMOVE_STATE:
this.itemEffectRemoveState(target, effect);
break;
case Game_Action.EFFECT_ADD_BUFF:
this.itemEffectAddBuff(target, effect);
break;
case Game_Action.EFFECT_ADD_DEBUFF:
this.itemEffectAddDebuff(target, effect);
break;
case Game_Action.EFFECT_REMOVE_BUFF:
this.itemEffectRemoveBuff(target, effect);
break;
case Game_Action.EFFECT_REMOVE_DEBUFF:
this.itemEffectRemoveDebuff(target, effect);
break;
case Game_Action.EFFECT_SPECIAL:
this.itemEffectSpecial(target, effect);
break;
case Game_Action.EFFECT_GROW:
this.itemEffectGrow(target, effect);
break;
case Game_Action.EFFECT_LEARN_SKILL:
this.itemEffectLearnSkill(target, effect);
break;
case Game_Action.EFFECT_COMMON_EVENT:
this.itemEffectCommonEvent(target, effect);
break;
}
};
Game_Action.prototype.itemEffectRecoverHp = function(target, effect) {

let value = (target.mhp * effect.value1 + effect.value2) * target.rec;
if (this.isItem()) {
value *= this.subject().pha;
}
if (value !== 0) {
target.gainHp(value);
}
};
Game_Action.prototype.itemEffectRecoverMp = function(target, effect) {

let value = (target.mmp * effect.value1 + effect.value2) * target.rec;
if (this.isItem()) {
value *= this.subject().pha;
}
if (value !== 0) {
target.gainMp(value);
}
};
Game_Action.prototype.itemEffectGainTp = function(target, effect) {

let value = Math.floor(effect.value1);
if (value !== 0) {
target.gainTp(value);
}
};
Game_Action.prototype.itemEffectAddState = function(target, effect) {

if (effect.dataId === 0) {
this.itemEffectAddAttackState(target, effect);
} else {
this.itemEffectAddNormalState(target, effect);
}
};
Game_Action.prototype.itemEffectAddAttackState = function(target, effect) {

for (const stateId of this.subject().attackStates()) {
let chance = effect.value1;
chance *= target.stateRate(stateId);
chance *= this.subject().attackStatesRate(stateId);
chance *= this.lukEffectRate(target);
if (Math.random() < chance) {
target.addState(stateId);
}
}
};
Game_Action.prototype.itemEffectAddNormalState = function(target, effect) {

if (!this.isCertainHit()) {
chance *= target.stateRate(effect.dataId);
chance *= this.lukEffectRate(target);
}
target.addState(effect.dataId);
}
};
Game_Action.prototype.itemEffectRemoveState = function(target, effect) {

target.removeState(effect.dataId);
}
};
Game_Action.prototype.itemEffectAddBuff = function(target, effect) {

target.addBuff(effect.dataId, effect.value1);
};
Game_Action.prototype.itemEffectAddDebuff = function(target, effect) {

let chance = target.debuffRate(effect.dataId) * this.lukEffectRate(target);
target.addDebuff(effect.dataId, effect.value1);
}
};
Game_Action.prototype.itemEffectRemoveBuff = function(target, effect) {

if (target.isBuffAffected(effect.dataId)) {
target.removeBuff(effect.dataId);
}
};
Game_Action.prototype.itemEffectRemoveDebuff = function(target, effect) {

if (target.isDebuffAffected(effect.dataId)) {
target.removeBuff(effect.dataId);
}
};
Game_Action.prototype.itemEffectSpecial = function(target, effect) {

if (effect.dataId === Game_Action.SPECIAL_EFFECT_ESCAPE) {
target.escape();
}
};
Game_Action.prototype.itemEffectGrow = function(target, effect) {

target.addParam(effect.dataId, Math.floor(effect.value1));
};
Game_Action.prototype.itemEffectLearnSkill = function(target, effect) {

if (target.isActor()) {
target.learnSkill(effect.dataId);
}
};
Game_Action.prototype.itemEffectCommonEvent = function(/*target, effect*/) {

//
};
Game_Action.prototype.makeSuccess = function(target) {
target.result().success = true;
};
Game_Action.prototype.applyItemUserEffect = function(/*target*/) {
const value = Math.floor(this.item().tpGain * this.subject().tcr);
this.subject().gainSilentTp(value);
};
Game_Action.prototype.lukEffectRate = function(target) {
return Math.max(1.0 + (this.subject().luk - target.luk) * 0.001, 0.0);
};
Game_Action.prototype.applyGlobal = function() {
for (const effect of this.item().effects) {
if (effect.code === Game_Action.EFFECT_COMMON_EVENT) {
$gameTemp.reserveCommonEvent(effect.dataId);
}
}
this.updateLastUsed();
this.updateLastSubject();
};
Game_Action.prototype.updateLastUsed = function() {
$gameTemp.setLastUsedSkillId(item.id);
$gameTemp.setLastUsedItemId(item.id);
}
};
Game_Action.prototype.updateLastSubject = function() {
const subject = this.subject();
if (subject.isActor()) {
$gameTemp.setLastSubjectActorId(subject.actorId());
} else {
$gameTemp.setLastSubjectEnemyIndex(subject.index() + 1);
}
};
Game_Action.prototype.updateLastTarget = function(target) {
if (target.isActor()) {
$gameTemp.setLastTargetActorId(target.actorId());
} else {
$gameTemp.setLastTargetEnemyIndex(target.index() + 1);
}
};
//-----------------------------------------------------------------------------
// Game_ActionResult
//
// The game object class for a result of a battle action. For convinience, all
// member variables in this class are public.
function Game_ActionResult() {
}
Game_ActionResult.prototype.initialize = function() {
this.clear();
};
Game_ActionResult.prototype.clear = function() {
this.used = false;
this.missed = false;
this.evaded = false;
this.physical = false;
this.drain = false;
this.critical = false;
this.success = false;
this.hpAffected = false;
this.hpDamage = 0;
this.mpDamage = 0;
this.tpDamage = 0;
this.addedStates = [];
this.removedStates = [];
this.addedBuffs = [];
this.addedDebuffs = [];
this.removedBuffs = [];
};
Game_ActionResult.prototype.addedStateObjects = function() {
return this.addedStates.map(id => $dataStates[id]);
};
Game_ActionResult.prototype.removedStateObjects = function() {
return this.removedStates.map(id => $dataStates[id]);
};
Game_ActionResult.prototype.isStatusAffected = function() {
return (
this.addedStates.length > 0 ||
this.removedStates.length > 0 ||
this.addedBuffs.length > 0 ||
this.addedDebuffs.length > 0 ||
this.removedBuffs.length > 0
);
};
Game_ActionResult.prototype.isHit = function() {
return this.used && !this.missed && !this.evaded;
};
Game_ActionResult.prototype.isStateAdded = function(stateId) {
return this.addedStates.includes(stateId);
};
Game_ActionResult.prototype.pushAddedState = function(stateId) {
if (!this.isStateAdded(stateId)) {
this.addedStates.push(stateId);
}
};
Game_ActionResult.prototype.isStateRemoved = function(stateId) {
return this.removedStates.includes(stateId);
};
Game_ActionResult.prototype.pushRemovedState = function(stateId) {
if (!this.isStateRemoved(stateId)) {
this.removedStates.push(stateId);
}
};
Game_ActionResult.prototype.isBuffAdded = function(paramId) {
return this.addedBuffs.includes(paramId);
};
Game_ActionResult.prototype.pushAddedBuff = function(paramId) {
if (!this.isBuffAdded(paramId)) {
this.addedBuffs.push(paramId);
}
};
Game_ActionResult.prototype.isDebuffAdded = function(paramId) {
return this.addedDebuffs.includes(paramId);
};
Game_ActionResult.prototype.pushAddedDebuff = function(paramId) {
if (!this.isDebuffAdded(paramId)) {
this.addedDebuffs.push(paramId);
}
};
Game_ActionResult.prototype.isBuffRemoved = function(paramId) {
return this.removedBuffs.includes(paramId);
};
Game_ActionResult.prototype.pushRemovedBuff = function(paramId) {
if (!this.isBuffRemoved(paramId)) {
this.removedBuffs.push(paramId);
}
};
//-----------------------------------------------------------------------------
// Game_BattlerBase
//
// The superclass of Game_Battler. It mainly contains parameters calculation.
function Game_BattlerBase() {
}
Game_BattlerBase.TRAIT_ELEMENT_RATE = 11;
Game_BattlerBase.TRAIT_DEBUFF_RATE = 12;
Game_BattlerBase.TRAIT_STATE_RATE = 13;
Game_BattlerBase.TRAIT_STATE_RESIST = 14;
Game_BattlerBase.TRAIT_PARAM = 21;
Game_BattlerBase.TRAIT_XPARAM = 22;
Game_BattlerBase.TRAIT_SPARAM = 23;
Game_BattlerBase.TRAIT_ATTACK_ELEMENT = 31;
Game_BattlerBase.TRAIT_ATTACK_STATE = 32;
Game_BattlerBase.TRAIT_ATTACK_SPEED = 33;
Game_BattlerBase.TRAIT_ATTACK_TIMES = 34;
Game_BattlerBase.TRAIT_ATTACK_SKILL = 35;
Game_BattlerBase.TRAIT_STYPE_ADD = 41;
Game_BattlerBase.TRAIT_STYPE_SEAL = 42;
Game_BattlerBase.TRAIT_SKILL_ADD = 43;
Game_BattlerBase.TRAIT_SKILL_SEAL = 44;
Game_BattlerBase.TRAIT_EQUIP_WTYPE = 51;
Game_BattlerBase.TRAIT_EQUIP_ATYPE = 52;
Game_BattlerBase.TRAIT_EQUIP_LOCK = 53;
Game_BattlerBase.TRAIT_EQUIP_SEAL = 54;
Game_BattlerBase.TRAIT_SLOT_TYPE = 55;
Game_BattlerBase.TRAIT_ACTION_PLUS = 61;
Game_BattlerBase.TRAIT_SPECIAL_FLAG = 62;
Game_BattlerBase.TRAIT_COLLAPSE_TYPE = 63;
Game_BattlerBase.TRAIT_PARTY_ABILITY = 64;
Game_BattlerBase.FLAG_ID_AUTO_BATTLE = 0;
Game_BattlerBase.FLAG_ID_GUARD = 1;
Game_BattlerBase.FLAG_ID_SUBSTITUTE = 2;
Game_BattlerBase.FLAG_ID_PRESERVE_TP = 3;
Game_BattlerBase.ICON_BUFF_START = 32;
Game_BattlerBase.ICON_DEBUFF_START = 48;
Object.defineProperties(Game_BattlerBase.prototype, {
// Hit Points
hp: {
get: function() {
return this._hp;
},
configurable: true
},
// Magic Points
mp: {
get: function() {
return this._mp;
},
configurable: true
},
// Tactical Points
tp: {
get: function() {
return this._tp;
},
configurable: true
},
// Maximum Hit Points
mhp: {
get: function() {
return this.param(0);
},
configurable: true
},
// Maximum Magic Points
mmp: {
get: function() {
},
configurable: true
},
// ATtacK power
atk: {
get: function() {
},
configurable: true
},
// DEFense power
def: {
get: function() {
},
configurable: true
},
// Magic ATtack power
mat: {
get: function() {
},
configurable: true
},
// Magic DeFense power
mdf: {
get: function() {
},
configurable: true
},
// AGIlity
agi: {
get: function() {
},
configurable: true
},
// LUcK
luk: {
get: function() {
},
configurable: true
},
// HIT rate
hit: {
get: function() {
return this.xparam(0);
},
configurable: true
},
// EVAsion rate
eva: {
get: function() {
},
configurable: true
},
// CRItical rate
cri: {
get: function() {
},
configurable: true
},
// Critical EVasion rate
cev: {
get: function() {
},
configurable: true
},
// Magic EVasion rate
mev: {
get: function() {
},
configurable: true
},
// Magic ReFlection rate
mrf: {
get: function() {
},
configurable: true
},
// CouNTer attack rate
cnt: {
get: function() {
},
configurable: true
},
// Hp ReGeneration rate
hrg: {
get: function() {
},
configurable: true
},
// Mp ReGeneration rate
mrg: {
get: function() {
},
configurable: true
},
// Tp ReGeneration rate
trg: {
get: function() {
},
configurable: true
},
// TarGet Rate
tgr: {
get: function() {
return this.sparam(0);
},
configurable: true
},
// GuaRD effect rate
grd: {
get: function() {
},
configurable: true
},
// RECovery effect rate
rec: {
get: function() {
},
configurable: true
},
// PHArmacology
pha: {
get: function() {
},
configurable: true
},
// Mp Cost Rate
mcr: {
get: function() {
},
configurable: true
},
// Tp Charge Rate
tcr: {
get: function() {
},
configurable: true
},
// Physical Damage Rate
pdr: {
get: function() {
},
configurable: true
},
// Magic Damage Rate
mdr: {
get: function() {
},
configurable: true
},
// Floor Damage Rate
fdr: {
get: function() {
},
configurable: true
},
// EXperience Rate
exr: {
get: function() {
},
configurable: true
}
});
Game_BattlerBase.prototype.initialize = function() {
this.initMembers();
};
Game_BattlerBase.prototype.initMembers = function() {
this._hp = 1;
this._mp = 0;
this._tp = 0;
this._hidden = false;
this.clearParamPlus();
this.clearStates();
this.clearBuffs();
};
Game_BattlerBase.prototype.clearParamPlus = function() {
this._paramPlus = [0, 0, 0, 0, 0, 0, 0, 0];
};
Game_BattlerBase.prototype.clearStates = function() {
this._states = [];
this._stateTurns = {};
};
Game_BattlerBase.prototype.eraseState = function(stateId) {
this._states.remove(stateId);
delete this._stateTurns[stateId];
};
Game_BattlerBase.prototype.isStateAffected = function(stateId) {
return this._states.includes(stateId);
};
Game_BattlerBase.prototype.isDeathStateAffected = function() {
return this.isStateAffected(this.deathStateId());
};
Game_BattlerBase.prototype.deathStateId = function() {
return 1;
};
Game_BattlerBase.prototype.resetStateCounts = function(stateId) {
const state = $dataStates[stateId];
const variance = 1 + Math.max(state.maxTurns - state.minTurns, 0);
this._stateTurns[stateId] = state.minTurns + Math.randomInt(variance);
};
Game_BattlerBase.prototype.isStateExpired = function(stateId) {
return this._stateTurns[stateId] === 0;
};
Game_BattlerBase.prototype.updateStateTurns = function() {
for (const stateId of this._states) {
if (this._stateTurns[stateId] > 0) {
this._stateTurns[stateId]--;
}
}
};
Game_BattlerBase.prototype.clearBuffs = function() {
this._buffs = [0, 0, 0, 0, 0, 0, 0, 0];
this._buffTurns = [0, 0, 0, 0, 0, 0, 0, 0];
};
Game_BattlerBase.prototype.eraseBuff = function(paramId) {
this._buffs[paramId] = 0;
this._buffTurns[paramId] = 0;
};
Game_BattlerBase.prototype.buffLength = function() {
return this._buffs.length;
};
Game_BattlerBase.prototype.buff = function(paramId) {
return this._buffs[paramId];
};
Game_BattlerBase.prototype.isBuffAffected = function(paramId) {
return this._buffs[paramId] > 0;
};
Game_BattlerBase.prototype.isDebuffAffected = function(paramId) {
return this._buffs[paramId] < 0;
};
Game_BattlerBase.prototype.isBuffOrDebuffAffected = function(paramId) {
return this._buffs[paramId] !== 0;
};
Game_BattlerBase.prototype.isMaxBuffAffected = function(paramId) {
return this._buffs[paramId] === 2;
};
Game_BattlerBase.prototype.isMaxDebuffAffected = function(paramId) {
return this._buffs[paramId] === -2;
};
Game_BattlerBase.prototype.increaseBuff = function(paramId) {
if (!this.isMaxBuffAffected(paramId)) {
this._buffs[paramId]++;
}
};
Game_BattlerBase.prototype.decreaseBuff = function(paramId) {
if (!this.isMaxDebuffAffected(paramId)) {
this._buffs[paramId]--;
}
};
Game_BattlerBase.prototype.overwriteBuffTurns = function(paramId, turns) {

if (this._buffTurns[paramId] < turns) {
this._buffTurns[paramId] = turns;
}
};
Game_BattlerBase.prototype.isBuffExpired = function(paramId) {
return this._buffTurns[paramId] === 0;
};
Game_BattlerBase.prototype.updateBuffTurns = function() {
for (let i = 0; i < this._buffTurns.length; i++) {
if (this._buffTurns[i] > 0) {
this._buffTurns[i]--;
}
}
};
Game_BattlerBase.prototype.die = function() {
this._hp = 0;
this.clearStates();
this.clearBuffs();
};
Game_BattlerBase.prototype.revive = function() {
if (this._hp === 0) {
this._hp = 1;
}
};
Game_BattlerBase.prototype.states = function() {
return this._states.map(id => $dataStates[id]);
};
Game_BattlerBase.prototype.stateIcons = function() {
return this.states()
.map(state => state.iconIndex)
.filter(iconIndex => iconIndex > 0);
};
Game_BattlerBase.prototype.buffIcons = function() {
const icons = [];
for (let i = 0; i < this._buffs.length; i++) {
if (this._buffs[i] !== 0) {
icons.push(this.buffIconIndex(this._buffs[i], i));
}
}
return icons;
};
Game_BattlerBase.prototype.buffIconIndex = function(buffLevel, paramId) {

if (buffLevel > 0) {
return Game_BattlerBase.ICON_BUFF_START + (buffLevel - 1) * 8 + paramId;
} else if (buffLevel < 0) {
return (
Game_BattlerBase.ICON_DEBUFF_START + (-buffLevel - 1) * 8 + paramId
);
} else {
return 0;
}
};
Game_BattlerBase.prototype.allIcons = function() {
return this.stateIcons().concat(this.buffIcons());
};
Game_BattlerBase.prototype.traitObjects = function() {
// Returns an array of the all objects having traits. States only here.
return this.states();
};
Game_BattlerBase.prototype.allTraits = function() {
return this.traitObjects().reduce((r, obj) => r.concat(obj.traits), []);
};
Game_BattlerBase.prototype.traits = function(code) {
return this.allTraits().filter(trait => trait.code === code);
};
Game_BattlerBase.prototype.traitsWithId = function(code, id) {

return this.allTraits().filter(
trait => trait.code === code && trait.dataId === id
);
};
Game_BattlerBase.prototype.traitsPi = function(code, id) {

return this.traitsWithId(code, id).reduce((r, trait) => r * trait.value, 1);
};
Game_BattlerBase.prototype.traitsSum = function(code, id) {

return this.traitsWithId(code, id).reduce((r, trait) => r + trait.value, 0);
};
Game_BattlerBase.prototype.traitsSumAll = function(code) {
return this.traits(code).reduce((r, trait) => r + trait.value, 0);
};
Game_BattlerBase.prototype.traitsSet = function(code) {
return this.traits(code).reduce((r, trait) => r.concat(trait.dataId), []);
};
Game_BattlerBase.prototype.paramBase = function(/*paramId*/) {
return 0;
};
Game_BattlerBase.prototype.paramPlus = function(paramId) {
return this._paramPlus[paramId];
};
Game_BattlerBase.prototype.paramBasePlus = function(paramId) {
return Math.max(0, this.paramBase(paramId) + this.paramPlus(paramId));
};
Game_BattlerBase.prototype.paramMin = function(paramId) {
if (paramId === 0) {
return 1; // MHP
} else {
return 0;
}
};
Game_BattlerBase.prototype.paramMax = function(/*paramId*/) {
return Infinity;
};
Game_BattlerBase.prototype.paramRate = function(paramId) {
return this.traitsPi(Game_BattlerBase.TRAIT_PARAM, paramId);
};
Game_BattlerBase.prototype.paramBuffRate = function(paramId) {
return this._buffs[paramId] * 0.25 + 1.0;
};
Game_BattlerBase.prototype.param = function(paramId) {
const value =
this.paramBasePlus(paramId) *
this.paramRate(paramId) *
this.paramBuffRate(paramId);
const maxValue = this.paramMax(paramId);
const minValue = this.paramMin(paramId);
return Math.round(value.clamp(minValue, maxValue));
};
Game_BattlerBase.prototype.xparam = function(xparamId) {
return this.traitsSum(Game_BattlerBase.TRAIT_XPARAM, xparamId);
};
Game_BattlerBase.prototype.sparam = function(sparamId) {
return this.traitsPi(Game_BattlerBase.TRAIT_SPARAM, sparamId);
};
Game_BattlerBase.prototype.elementRate = function(elementId) {
return this.traitsPi(Game_BattlerBase.TRAIT_ELEMENT_RATE, elementId);
};
Game_BattlerBase.prototype.debuffRate = function(paramId) {
return this.traitsPi(Game_BattlerBase.TRAIT_DEBUFF_RATE, paramId);
};
Game_BattlerBase.prototype.stateRate = function(stateId) {
return this.traitsPi(Game_BattlerBase.TRAIT_STATE_RATE, stateId);
};
Game_BattlerBase.prototype.stateResistSet = function() {
return this.traitsSet(Game_BattlerBase.TRAIT_STATE_RESIST);
};
Game_BattlerBase.prototype.isStateResist = function(stateId) {
return this.stateResistSet().includes(stateId);
};
Game_BattlerBase.prototype.attackElements = function() {
return this.traitsSet(Game_BattlerBase.TRAIT_ATTACK_ELEMENT);
};
Game_BattlerBase.prototype.attackStates = function() {
return this.traitsSet(Game_BattlerBase.TRAIT_ATTACK_STATE);
};
Game_BattlerBase.prototype.attackStatesRate = function(stateId) {
return this.traitsSum(Game_BattlerBase.TRAIT_ATTACK_STATE, stateId);
};
Game_BattlerBase.prototype.attackSpeed = function() {
return this.traitsSumAll(Game_BattlerBase.TRAIT_ATTACK_SPEED);
};
Game_BattlerBase.prototype.attackTimesAdd = function() {
return Math.max(this.traitsSumAll(Game_BattlerBase.TRAIT_ATTACK_TIMES), 0);
};
Game_BattlerBase.prototype.attackSkillId = function() {
const set = this.traitsSet(Game_BattlerBase.TRAIT_ATTACK_SKILL);
return set.length > 0 ? Math.max(...set) : 1;
};
Game_BattlerBase.prototype.addedSkillTypes = function() {
return this.traitsSet(Game_BattlerBase.TRAIT_STYPE_ADD);
};
Game_BattlerBase.prototype.isSkillTypeSealed = function(stypeId) {
return this.traitsSet(Game_BattlerBase.TRAIT_STYPE_SEAL).includes(stypeId);
};
Game_BattlerBase.prototype.addedSkills = function() {
return this.traitsSet(Game_BattlerBase.TRAIT_SKILL_ADD);
};
Game_BattlerBase.prototype.isSkillSealed = function(skillId) {
return this.traitsSet(Game_BattlerBase.TRAIT_SKILL_SEAL).includes(skillId);
};
Game_BattlerBase.prototype.isEquipWtypeOk = function(wtypeId) {
return this.traitsSet(Game_BattlerBase.TRAIT_EQUIP_WTYPE).includes(wtypeId);
};
Game_BattlerBase.prototype.isEquipAtypeOk = function(atypeId) {
return this.traitsSet(Game_BattlerBase.TRAIT_EQUIP_ATYPE).includes(atypeId);
};
Game_BattlerBase.prototype.isEquipTypeLocked = function(etypeId) {
return this.traitsSet(Game_BattlerBase.TRAIT_EQUIP_LOCK).includes(etypeId);
};
Game_BattlerBase.prototype.isEquipTypeSealed = function(etypeId) {
return this.traitsSet(Game_BattlerBase.TRAIT_EQUIP_SEAL).includes(etypeId);
};
Game_BattlerBase.prototype.slotType = function() {
const set = this.traitsSet(Game_BattlerBase.TRAIT_SLOT_TYPE);
};
Game_BattlerBase.prototype.isDualWield = function() {
return this.slotType() === 1;
};
Game_BattlerBase.prototype.actionPlusSet = function() {
return this.traits(Game_BattlerBase.TRAIT_ACTION_PLUS).map(
trait => trait.value
);
};
Game_BattlerBase.prototype.specialFlag = function(flagId) {
return this.traits(Game_BattlerBase.TRAIT_SPECIAL_FLAG).some(
trait => trait.dataId === flagId
);
};
Game_BattlerBase.prototype.collapseType = function() {
const set = this.traitsSet(Game_BattlerBase.TRAIT_COLLAPSE_TYPE);
};
Game_BattlerBase.prototype.partyAbility = function(abilityId) {
return this.traits(Game_BattlerBase.TRAIT_PARTY_ABILITY).some(
trait => trait.dataId === abilityId
);
};
Game_BattlerBase.prototype.isAutoBattle = function() {
return this.specialFlag(Game_BattlerBase.FLAG_ID_AUTO_BATTLE);
};
Game_BattlerBase.prototype.isGuard = function() {
return this.specialFlag(Game_BattlerBase.FLAG_ID_GUARD) && this.canMove();
};
Game_BattlerBase.prototype.isSubstitute = function() {
return (
this.specialFlag(Game_BattlerBase.FLAG_ID_SUBSTITUTE) && this.canMove()
);
};
Game_BattlerBase.prototype.isPreserveTp = function() {
return this.specialFlag(Game_BattlerBase.FLAG_ID_PRESERVE_TP);
};
Game_BattlerBase.prototype.addParam = function(paramId, value) {

this._paramPlus[paramId] += value;
this.refresh();
};
Game_BattlerBase.prototype.setHp = function(hp) {
this._hp = hp;
this.refresh();
};
Game_BattlerBase.prototype.setMp = function(mp) {
this._mp = mp;
this.refresh();
};
Game_BattlerBase.prototype.setTp = function(tp) {
this._tp = tp;
this.refresh();
};
Game_BattlerBase.prototype.maxTp = function() {
return 100;
};
Game_BattlerBase.prototype.refresh = function() {
for (const stateId of this.stateResistSet()) {
this.eraseState(stateId);
}
this._hp = this._hp.clamp(0, this.mhp);
this._mp = this._mp.clamp(0, this.mmp);
this._tp = this._tp.clamp(0, this.maxTp());
};
Game_BattlerBase.prototype.recoverAll = function() {
this.clearStates();
this._hp = this.mhp;
this._mp = this.mmp;
};
Game_BattlerBase.prototype.hpRate = function() {
return this.hp / this.mhp;
};
Game_BattlerBase.prototype.mpRate = function() {
return this.mmp > 0 ? this.mp / this.mmp : 0;
};
Game_BattlerBase.prototype.tpRate = function() {
return this.tp / this.maxTp();
};
Game_BattlerBase.prototype.hide = function() {
this._hidden = true;
};
Game_BattlerBase.prototype.appear = function() {
this._hidden = false;
};
Game_BattlerBase.prototype.isHidden = function() {
return this._hidden;
};
Game_BattlerBase.prototype.isAppeared = function() {
return !this.isHidden();
};
Game_BattlerBase.prototype.isDead = function() {
return this.isAppeared() && this.isDeathStateAffected();
};
Game_BattlerBase.prototype.isAlive = function() {
return this.isAppeared() && !this.isDeathStateAffected();
};
Game_BattlerBase.prototype.isDying = function() {
return this.isAlive() && this._hp < this.mhp / 4;
};
Game_BattlerBase.prototype.isRestricted = function() {
return this.isAppeared() && this.restriction() > 0;
};
Game_BattlerBase.prototype.canInput = function() {
// prettier-ignore
return this.isAppeared() && this.isActor() &&
!this.isRestricted() && !this.isAutoBattle();
};
Game_BattlerBase.prototype.canMove = function() {
return this.isAppeared() && this.restriction() < 4;
};
Game_BattlerBase.prototype.isConfused = function() {
return (
this.isAppeared() && this.restriction() >= 1 && this.restriction() <= 3
);
};
Game_BattlerBase.prototype.confusionLevel = function() {
return this.isConfused() ? this.restriction() : 0;
};
Game_BattlerBase.prototype.isActor = function() {
return false;
};
Game_BattlerBase.prototype.isEnemy = function() {
return false;
};
Game_BattlerBase.prototype.sortStates = function() {
this._states.sort((a, b) => {
const p1 = $dataStates[a].priority;
const p2 = $dataStates[b].priority;
if (p1 !== p2) {
return p2 - p1;
}
return a - b;
});
};
Game_BattlerBase.prototype.restriction = function() {
const restrictions = this.states().map(state => state.restriction);
return Math.max(0, ...restrictions);
};
Game_BattlerBase.prototype.addNewState = function(stateId) {
if (stateId === this.deathStateId()) {
this.die();
}
const restricted = this.isRestricted();
this._states.push(stateId);
this.sortStates();
if (!restricted && this.isRestricted()) {
this.onRestrict();
}
};
Game_BattlerBase.prototype.onRestrict = function() {
//
};
Game_BattlerBase.prototype.mostImportantStateText = function() {
for (const state of this.states()) {
if (state.message3) {
return state.message3;
}
}
return "";
};
Game_BattlerBase.prototype.stateMotionIndex = function() {
const states = this.states();
if (states.length > 0) {
return states[0].motion;
} else {
return 0;
}
};
Game_BattlerBase.prototype.stateOverlayIndex = function() {
const states = this.states();
if (states.length > 0) {
return states[0].overlay;
} else {
return 0;
}
};
Game_BattlerBase.prototype.isSkillWtypeOk = function(/*skill*/) {
return true;
};
Game_BattlerBase.prototype.skillMpCost = function(skill) {
return Math.floor(skill.mpCost * this.mcr);
};
Game_BattlerBase.prototype.skillTpCost = function(skill) {
return skill.tpCost;
};
Game_BattlerBase.prototype.canPaySkillCost = function(skill) {
return (
this._tp >= this.skillTpCost(skill) &&
this._mp >= this.skillMpCost(skill)
);
};
Game_BattlerBase.prototype.paySkillCost = function(skill) {
this._mp -= this.skillMpCost(skill);
this._tp -= this.skillTpCost(skill);
};
Game_BattlerBase.prototype.isOccasionOk = function(item) {
return item.occasion === 0 || item.occasion === 1;
} else {
return item.occasion === 0 || item.occasion === 2;
}
};
Game_BattlerBase.prototype.meetsUsableItemConditions = function(item) {
return this.canMove() && this.isOccasionOk(item);
};
Game_BattlerBase.prototype.meetsSkillConditions = function(skill) {
return (
this.meetsUsableItemConditions(skill) &&
this.isSkillWtypeOk(skill) &&
this.canPaySkillCost(skill) &&
!this.isSkillSealed(skill.id) &&
!this.isSkillTypeSealed(skill.stypeId)
);
};
Game_BattlerBase.prototype.meetsItemConditions = function(item) {
return this.meetsUsableItemConditions(item) && $gameParty.hasItem(item);
};
Game_BattlerBase.prototype.canUse = function(item) {
if (!item) {
return false;
} else if (DataManager.isSkill(item)) {
return this.meetsSkillConditions(item);
return this.meetsItemConditions(item);
} else {
return false;
}
};
Game_BattlerBase.prototype.canEquip = function(item) {
if (!item) {
return false;
return this.canEquipWeapon(item);
return this.canEquipArmor(item);
} else {
return false;
}
};
Game_BattlerBase.prototype.canEquipWeapon = function(item) {
return (
this.isEquipWtypeOk(item.wtypeId) &&
!this.isEquipTypeSealed(item.etypeId)
);
};
Game_BattlerBase.prototype.canEquipArmor = function(item) {
return (
this.isEquipAtypeOk(item.atypeId) &&
!this.isEquipTypeSealed(item.etypeId)
);
};
Game_BattlerBase.prototype.guardSkillId = function() {
return 2;
};
Game_BattlerBase.prototype.canAttack = function() {
return this.canUse($dataSkills[this.attackSkillId()]);
};
Game_BattlerBase.prototype.canGuard = function() {
return this.canUse($dataSkills[this.guardSkillId()]);
};
//-----------------------------------------------------------------------------
// Game_Battler
//
// The superclass of Game_Actor and Game_Enemy. It contains methods for sprites
// and actions.
function Game_Battler() {
}
Game_Battler.prototype = Object.create(Game_BattlerBase.prototype);
Game_Battler.prototype.constructor = Game_Battler;
Game_Battler.prototype.initialize = function() {
Game_BattlerBase.prototype.initialize.call(this);
};
Game_Battler.prototype.initMembers = function() {
Game_BattlerBase.prototype.initMembers.call(this);
this._actions = [];
this._speed = 0;
this._result = new Game_ActionResult();
this._actionState = "";
this._lastTargetIndex = 0;
this._damagePopup = false;
this._effectType = null;
this._motionType = null;
this._weaponImageId = 0;
this._motionRefresh = false;
this._selected = false;
this._tpbState = "";
this._tpbChargeTime = 0;
this._tpbCastTime = 0;
this._tpbIdleTime = 0;
this._tpbTurnCount = 0;
this._tpbTurnEnd = false;
};
Game_Battler.prototype.clearDamagePopup = function() {
this._damagePopup = false;
};
Game_Battler.prototype.clearWeaponAnimation = function() {
this._weaponImageId = 0;
};
Game_Battler.prototype.clearEffect = function() {
this._effectType = null;
};
Game_Battler.prototype.clearMotion = function() {
this._motionType = null;
};
Game_Battler.prototype.requestEffect = function(effectType) {
this._effectType = effectType;
};
Game_Battler.prototype.requestMotion = function(motionType) {
this._motionType = motionType;
};
Game_Battler.prototype.requestMotionRefresh = function() {
this._motionRefresh = true;
};
Game_Battler.prototype.cancelMotionRefresh = function() {
};
Game_Battler.prototype.select = function() {
this._selected = true;
};
Game_Battler.prototype.deselect = function() {
this._selected = false;
};
Game_Battler.prototype.isDamagePopupRequested = function() {
return this._damagePopup;
};
Game_Battler.prototype.isEffectRequested = function() {
return !!this._effectType;
};
Game_Battler.prototype.isMotionRequested = function() {
return !!this._motionType;
};
Game_Battler.prototype.isWeaponAnimationRequested = function() {
return this._weaponImageId > 0;
};
Game_Battler.prototype.isMotionRefreshRequested = function() {
return this._motionRefresh;
};
Game_Battler.prototype.isSelected = function() {
return this._selected;
};
Game_Battler.prototype.effectType = function() {
return this._effectType;
};
Game_Battler.prototype.motionType = function() {
return this._motionType;
};
Game_Battler.prototype.weaponImageId = function() {
return this._weaponImageId;
};
Game_Battler.prototype.startDamagePopup = function() {
this._damagePopup = true;
};
Game_Battler.prototype.shouldPopupDamage = function() {
const result = this._result;
return (
result.missed ||
result.evaded ||
result.hpAffected ||
result.mpDamage !== 0
);
};
Game_Battler.prototype.startWeaponAnimation = function(weaponImageId) {
this._weaponImageId = weaponImageId;
};
Game_Battler.prototype.action = function(index) {
return this._actions[index];
};
Game_Battler.prototype.setAction = function(index, action) {

this._actions[index] = action;
};
Game_Battler.prototype.numActions = function() {
return this._actions.length;
};
Game_Battler.prototype.clearActions = function() {
this._actions = [];
};
Game_Battler.prototype.result = function() {
return this._result;
};
Game_Battler.prototype.clearResult = function() {
this._result.clear();
};
Game_Battler.prototype.clearTpbChargeTime = function() {
this._tpbState = "charging";
};
Game_Battler.prototype.applyTpbPenalty = function() {
this._tpbChargeTime -= 1;
};
Game_Battler.prototype.initTpbChargeTime = function(advantageous) {
const speed = this.tpbRelativeSpeed();
this._tpbChargeTime = advantageous ? 1 : speed * Math.random() * 0.5;
if (this.isRestricted()) {
}
};
Game_Battler.prototype.tpbChargeTime = function() {
return this._tpbChargeTime;
};
Game_Battler.prototype.startTpbCasting = function() {
this._tpbState = "casting";
this._tpbCastTime = 0;
};
Game_Battler.prototype.startTpbAction = function() {
this._tpbState = "acting";
};
Game_Battler.prototype.isTpbCharged = function() {
return this._tpbState === "charged";
};
Game_Battler.prototype.isTpbReady = function() {
return this._tpbState === "ready";
};
Game_Battler.prototype.isTpbTimeout = function() {
return this._tpbIdleTime >= 1;
};
Game_Battler.prototype.updateTpb = function() {
if (this.canMove()) {
this.updateTpbChargeTime();
this.updateTpbCastTime();
this.updateTpbAutoBattle();
}
if (this.isAlive()) {
this.updateTpbIdleTime();
}
};
Game_Battler.prototype.updateTpbChargeTime = function() {
if (this._tpbState === "charging") {
this._tpbChargeTime += this.tpbAcceleration();
if (this._tpbChargeTime >= 1) {
this.onTpbCharged();
}
}
};
Game_Battler.prototype.updateTpbCastTime = function() {
if (this._tpbState === "casting") {
this._tpbCastTime += this.tpbAcceleration();
if (this._tpbCastTime >= this.tpbRequiredCastTime()) {
this._tpbCastTime = this.tpbRequiredCastTime();
this._tpbState = "ready";
}
}
};
Game_Battler.prototype.updateTpbAutoBattle = function() {
if (this.isTpbCharged() && !this.isTpbTurnEnd() && this.isAutoBattle()) {
this.makeTpbActions();
}
};
Game_Battler.prototype.updateTpbIdleTime = function() {
if (!this.canMove() || this.isTpbCharged()) {
this._tpbIdleTime += this.tpbAcceleration();
}
};
Game_Battler.prototype.tpbAcceleration = function() {
const speed = this.tpbRelativeSpeed();
const referenceTime = $gameParty.tpbReferenceTime();
return speed / referenceTime;
};
Game_Battler.prototype.tpbRelativeSpeed = function() {
return this.tpbSpeed() / $gameParty.tpbBaseSpeed();
};
Game_Battler.prototype.tpbSpeed = function() {
return Math.sqrt(this.agi) + 1;
};
Game_Battler.prototype.tpbBaseSpeed = function() {
const baseAgility = this.paramBasePlus(6);
return Math.sqrt(baseAgility) + 1;
};
Game_Battler.prototype.tpbRequiredCastTime = function() {
const actions = this._actions.filter(action => action.isValid());
const items = actions.map(action => action.item());
const delay = items.reduce((r, item) => r + Math.max(0, -item.speed), 0);
return Math.sqrt(delay) / this.tpbSpeed();
};
Game_Battler.prototype.onTpbCharged = function() {
if (!this.shouldDelayTpbCharge()) {
this.finishTpbCharge();
}
};
Game_Battler.prototype.shouldDelayTpbCharge = function() {
return !BattleManager.isActiveTpb() && $gameParty.canInput();
};
Game_Battler.prototype.finishTpbCharge = function() {
this._tpbState = "charged";
this._tpbTurnEnd = true;
};
Game_Battler.prototype.isTpbTurnEnd = function() {
return this._tpbTurnEnd;
};
Game_Battler.prototype.initTpbTurn = function() {
this._tpbTurnCount = 0;
};
Game_Battler.prototype.startTpbTurn = function() {
this._tpbTurnCount++;
if (this.numActions() === 0) {
this.makeTpbActions();
}
};
Game_Battler.prototype.makeTpbActions = function() {
this.makeActions();
if (this.canInput()) {
this.setActionState("undecided");
} else {
this.startTpbCasting();
this.setActionState("waiting");
}
};
Game_Battler.prototype.onTpbTimeout = function() {
this.onAllActionsEnd();
this._tpbTurnEnd = true;
};
Game_Battler.prototype.turnCount = function() {
if (BattleManager.isTpb()) {
return this._tpbTurnCount;
} else {
return $gameTroop.turnCount() + 1;
}
};
Game_Battler.prototype.canInput = function() {
if (BattleManager.isTpb() && !this.isTpbCharged()) {
return false;
}
return Game_BattlerBase.prototype.canInput.call(this);
};
Game_Battler.prototype.refresh = function() {
Game_BattlerBase.prototype.refresh.call(this);
if (this.hp === 0) {
this.addState(this.deathStateId());
} else {
this.removeState(this.deathStateId());
}
};
Game_Battler.prototype.addState = function(stateId) {
if (this.isStateAddable(stateId)) {
if (!this.isStateAffected(stateId)) {
this.addNewState(stateId);
this.refresh();
}
this.resetStateCounts(stateId);
this._result.pushAddedState(stateId);
}
};
Game_Battler.prototype.isStateAddable = function(stateId) {
return (
this.isAlive() &&
$dataStates[stateId] &&
!this.isStateResist(stateId) &&
!this.isStateRestrict(stateId)
);
};
Game_Battler.prototype.isStateRestrict = function(stateId) {
return $dataStates[stateId].removeByRestriction && this.isRestricted();
};
Game_Battler.prototype.onRestrict = function() {
Game_BattlerBase.prototype.onRestrict.call(this);
this.clearTpbChargeTime();
this.clearActions();
if (state.removeByRestriction) {
this.removeState(state.id);
}
}
};
Game_Battler.prototype.removeState = function(stateId) {
if (this.isStateAffected(stateId)) {
if (stateId === this.deathStateId()) {
this.revive();
}
this.eraseState(stateId);
this.refresh();
this._result.pushRemovedState(stateId);
}
};
Game_Battler.prototype.escape = function() {
this.hide();
}
this.clearStates();
SoundManager.playEscape();
};
Game_Battler.prototype.addBuff = function(paramId, turns) {

this.increaseBuff(paramId);
if (this.isBuffAffected(paramId)) {
this.overwriteBuffTurns(paramId, turns);
}
this._result.pushAddedBuff(paramId);
this.refresh();
}
};
Game_Battler.prototype.addDebuff = function(paramId, turns) {

this.decreaseBuff(paramId);
if (this.isDebuffAffected(paramId)) {
this.overwriteBuffTurns(paramId, turns);
}
this._result.pushAddedDebuff(paramId);
this.refresh();
}
};
Game_Battler.prototype.removeBuff = function(paramId) {
if (this.isAlive() && this.isBuffOrDebuffAffected(paramId)) {
this.eraseBuff(paramId);
this._result.pushRemovedBuff(paramId);
this.refresh();
}
};
Game_Battler.prototype.removeBattleStates = function() {
if (state.removeAtBattleEnd) {
}
}
};
Game_Battler.prototype.removeAllBuffs = function() {
for (let i = 0; i < this.buffLength(); i++) {
this.removeBuff(i);
}
};
Game_Battler.prototype.removeStatesAuto = function(timing) {
if (
this.isStateExpired(state.id) &&
state.autoRemovalTiming === timing
) {
}
}
};
Game_Battler.prototype.removeBuffsAuto = function() {
for (let i = 0; i < this.buffLength(); i++) {
if (this.isBuffExpired(i)) {
this.removeBuff(i);
}
}
};
Game_Battler.prototype.removeStatesByDamage = function() {
if (
state.removeByDamage &&
Math.randomInt(100) < state.chanceByDamage
) {
}
}
};
Game_Battler.prototype.makeActionTimes = function() {
const actionPlusSet = this.actionPlusSet();
return actionPlusSet.reduce((r, p) => (Math.random() < p ? r + 1 : r), 1);
};
Game_Battler.prototype.makeActions = function() {
const actionTimes = this.makeActionTimes();
this._actions = [];
for (let i = 0; i < actionTimes; i++) {
this._actions.push(new Game_Action(this));
}
}
};
Game_Battler.prototype.speed = function() {
return this._speed;
};
Game_Battler.prototype.makeSpeed = function() {
this._speed = Math.min(...this._actions.map(action => action.speed())) || 0;
};
Game_Battler.prototype.currentAction = function() {
return this._actions[0];
};
Game_Battler.prototype.removeCurrentAction = function() {
this._actions.shift();
};
Game_Battler.prototype.setLastTarget = function(target) {
this._lastTargetIndex = target ? target.index() : 0;
};
Game_Battler.prototype.forceAction = function(skillId, targetIndex) {

const action = new Game_Action(this, true);
action.setSkill(skillId);
if (targetIndex === -2) {
action.setTarget(this._lastTargetIndex);
} else if (targetIndex === -1) {
action.decideRandomTarget();
} else {
action.setTarget(targetIndex);
}
if (action.item()) {
this._actions.push(action);
}
};
Game_Battler.prototype.useItem = function(item) {
this.paySkillCost(item);
this.consumeItem(item);
}
};
Game_Battler.prototype.consumeItem = function(item) {
$gameParty.consumeItem(item);
};
Game_Battler.prototype.gainHp = function(value) {
this._result.hpDamage = -value;
this._result.hpAffected = true;
this.setHp(this.hp + value);
};
Game_Battler.prototype.gainMp = function(value) {
this._result.mpDamage = -value;
this.setMp(this.mp + value);
};
Game_Battler.prototype.gainTp = function(value) {
this._result.tpDamage = -value;
this.setTp(this.tp + value);
};
Game_Battler.prototype.gainSilentTp = function(value) {
this.setTp(this.tp + value);
};
Game_Battler.prototype.initTp = function() {
this.setTp(Math.randomInt(25));
};
Game_Battler.prototype.clearTp = function() {
this.setTp(0);
};
Game_Battler.prototype.chargeTpByDamage = function(damageRate) {
const value = Math.floor(50 * damageRate * this.tcr);
this.gainSilentTp(value);
};
Game_Battler.prototype.regenerateHp = function() {
const minRecover = -this.maxSlipDamage();
const value = Math.max(Math.floor(this.mhp * this.hrg), minRecover);
if (value !== 0) {
this.gainHp(value);
}
};
Game_Battler.prototype.maxSlipDamage = function() {
return $dataSystem.optSlipDeath ? this.hp : Math.max(this.hp - 1, 0);
};
Game_Battler.prototype.regenerateMp = function() {
const value = Math.floor(this.mmp * this.mrg);
if (value !== 0) {
this.gainMp(value);
}
};
Game_Battler.prototype.regenerateTp = function() {
const value = Math.floor(100 * this.trg);
this.gainSilentTp(value);
};
Game_Battler.prototype.regenerateAll = function() {
this.regenerateHp();
this.regenerateMp();
this.regenerateTp();
}
};
Game_Battler.prototype.onBattleStart = function(advantageous) {
this.clearMotion();
this.initTpbChargeTime(advantageous);
this.initTpbTurn();
if (!this.isPreserveTp()) {
this.initTp();
}
};
Game_Battler.prototype.onAllActionsEnd = function() {
this.clearResult();
this.removeStatesAuto(1);
this.removeBuffsAuto();
};
Game_Battler.prototype.onTurnEnd = function() {
this.clearResult();
this.regenerateAll();
this.updateStateTurns();
this.updateBuffTurns();
this.removeStatesAuto(2);
};
Game_Battler.prototype.onBattleEnd = function() {
this.clearResult();
this.removeBattleStates();
this.removeAllBuffs();
if (!this.isPreserveTp()) {
this.clearTp();
}
this.appear();
};
Game_Battler.prototype.onDamage = function(value) {
this.removeStatesByDamage();
this.chargeTpByDamage(value / this.mhp);
};
Game_Battler.prototype.setActionState = function(actionState) {
this._actionState = actionState;
this.requestMotionRefresh();
};
Game_Battler.prototype.isUndecided = function() {
return this._actionState === "undecided";
};
Game_Battler.prototype.isInputting = function() {
return this._actionState === "inputting";
};
Game_Battler.prototype.isWaiting = function() {
return this._actionState === "waiting";
};
Game_Battler.prototype.isActing = function() {
return this._actionState === "acting";
};
Game_Battler.prototype.isChanting = function() {
if (this.isWaiting()) {
return this._actions.some(action => action.isMagicSkill());
}
return false;
};
Game_Battler.prototype.isGuardWaiting = function() {
if (this.isWaiting()) {
return this._actions.some(action => action.isGuard());
}
return false;
};
Game_Battler.prototype.performActionStart = function(action) {
if (!action.isGuard()) {
this.setActionState("acting");
}
};
Game_Battler.prototype.performAction = function(/*action*/) {
//
};
Game_Battler.prototype.performActionEnd = function() {
//
};
Game_Battler.prototype.performDamage = function() {
//
};
Game_Battler.prototype.performMiss = function() {
SoundManager.playMiss();
};
Game_Battler.prototype.performRecovery = function() {
SoundManager.playRecovery();
};
Game_Battler.prototype.performEvasion = function() {
SoundManager.playEvasion();
};
Game_Battler.prototype.performMagicEvasion = function() {
SoundManager.playMagicEvasion();
};
Game_Battler.prototype.performCounter = function() {
SoundManager.playEvasion();
};
Game_Battler.prototype.performReflection = function() {
SoundManager.playReflection();
};
Game_Battler.prototype.performSubstitute = function(/*target*/) {
//
};
Game_Battler.prototype.performCollapse = function() {
//
};
//-----------------------------------------------------------------------------
// Game_Actor
//
// The game object class for an actor.
function Game_Actor() {
}
Game_Actor.prototype = Object.create(Game_Battler.prototype);
Game_Actor.prototype.constructor = Game_Actor;
Object.defineProperty(Game_Actor.prototype, "level", {
get: function() {
return this._level;
},
configurable: true
});
Game_Actor.prototype.initialize = function(actorId) {
Game_Battler.prototype.initialize.call(this);
this.setup(actorId);
};
Game_Actor.prototype.initMembers = function() {
Game_Battler.prototype.initMembers.call(this);
this._actorId = 0;
this._name = "";
this._nickname = "";
this._classId = 0;
this._level = 0;
this._characterName = "";
this._characterIndex = 0;
this._faceName = "";
this._faceIndex = 0;
this._battlerName = "";
this._exp = {};
this._skills = [];
this._equips = [];
this._actionInputIndex = 0;
this._lastMenuSkill = new Game_Item();
this._lastBattleSkill = new Game_Item();
this._lastCommandSymbol = "";
};
Game_Actor.prototype.setup = function(actorId) {
const actor = $dataActors[actorId];
this._actorId = actorId;
this._name = actor.name;
this._nickname = actor.nickname;
this._profile = actor.profile;
this._classId = actor.classId;
this._level = actor.initialLevel;
this.initImages();
this.initExp();
this.initSkills();
this.initEquips(actor.equips);
this.clearParamPlus();
this.recoverAll();
};
Game_Actor.prototype.actorId = function() {
return this._actorId;
};
Game_Actor.prototype.actor = function() {
return $dataActors[this._actorId];
};
Game_Actor.prototype.name = function() {
return this._name;
};
Game_Actor.prototype.setName = function(name) {
this._name = name;
};
Game_Actor.prototype.nickname = function() {
return this._nickname;
};
Game_Actor.prototype.setNickname = function(nickname) {
this._nickname = nickname;
};
Game_Actor.prototype.profile = function() {
return this._profile;
};
Game_Actor.prototype.setProfile = function(profile) {
this._profile = profile;
};
Game_Actor.prototype.characterName = function() {
return this._characterName;
};
Game_Actor.prototype.characterIndex = function() {
return this._characterIndex;
};
Game_Actor.prototype.faceName = function() {
return this._faceName;
};
Game_Actor.prototype.faceIndex = function() {
return this._faceIndex;
};
Game_Actor.prototype.battlerName = function() {
return this._battlerName;
};
Game_Actor.prototype.clearStates = function() {
Game_Battler.prototype.clearStates.call(this);
this._stateSteps = {};
};
Game_Actor.prototype.eraseState = function(stateId) {
Game_Battler.prototype.eraseState.call(this, stateId);
delete this._stateSteps[stateId];
};
Game_Actor.prototype.resetStateCounts = function(stateId) {
Game_Battler.prototype.resetStateCounts.call(this, stateId);
this._stateSteps[stateId] = $dataStates[stateId].stepsToRemove;
};
Game_Actor.prototype.initImages = function() {
const actor = this.actor();
this._characterName = actor.characterName;
this._characterIndex = actor.characterIndex;
this._faceName = actor.faceName;
this._faceIndex = actor.faceIndex;
this._battlerName = actor.battlerName;
};
Game_Actor.prototype.expForLevel = function(level) {
const c = this.currentClass();
const basis = c.expParams[0];
const extra = c.expParams[1];
const acc_a = c.expParams[2];
const acc_b = c.expParams[3];
return Math.round(
(basis * Math.pow(level - 1, 0.9 + acc_a / 250) * level * (level + 1)) /
(6 + Math.pow(level, 2) / 50 / acc_b) +
(level - 1) * extra
);
};
Game_Actor.prototype.initExp = function() {
this._exp[this._classId] = this.currentLevelExp();
};
Game_Actor.prototype.currentExp = function() {
return this._exp[this._classId];
};
Game_Actor.prototype.currentLevelExp = function() {
return this.expForLevel(this._level);
};
Game_Actor.prototype.nextLevelExp = function() {
return this.expForLevel(this._level + 1);
};
Game_Actor.prototype.nextRequiredExp = function() {
return this.nextLevelExp() - this.currentExp();
};
Game_Actor.prototype.maxLevel = function() {
return this.actor().maxLevel;
};
Game_Actor.prototype.isMaxLevel = function() {
return this._level >= this.maxLevel();
};
Game_Actor.prototype.initSkills = function() {
this._skills = [];
for (const learning of this.currentClass().learnings) {
if (learning.level <= this._level) {
this.learnSkill(learning.skillId);
}
}
};
Game_Actor.prototype.initEquips = function(equips) {
const slots = this.equipSlots();
const maxSlots = slots.length;
this._equips = [];
for (let i = 0; i < maxSlots; i++) {
this._equips[i] = new Game_Item();
}
for (let j = 0; j < equips.length; j++) {
if (j < maxSlots) {
this._equips[j].setEquip(slots[j] === 1, equips[j]);
}
}
this.releaseUnequippableItems(true);
this.refresh();
};
Game_Actor.prototype.equipSlots = function() {
const slots = [];
for (let i = 1; i < $dataSystem.equipTypes.length; i++) {
slots.push(i);
}
if (slots.length >= 2 && this.isDualWield()) {
slots[1] = 1;
}
return slots;
};
Game_Actor.prototype.equips = function() {
return this._equips.map(item => item.object());
};
Game_Actor.prototype.weapons = function() {
return this.equips().filter(item => item && DataManager.isWeapon(item));
};
Game_Actor.prototype.armors = function() {
return this.equips().filter(item => item && DataManager.isArmor(item));
};
Game_Actor.prototype.hasWeapon = function(weapon) {
return this.weapons().includes(weapon);
};
Game_Actor.prototype.hasArmor = function(armor) {
return this.armors().includes(armor);
};
Game_Actor.prototype.isEquipChangeOk = function(slotId) {
return (
!this.isEquipTypeLocked(this.equipSlots()[slotId]) &&
!this.isEquipTypeSealed(this.equipSlots()[slotId])
);
};
Game_Actor.prototype.changeEquip = function(slotId, item) {

if (
this.tradeItemWithParty(item, this.equips()[slotId]) &&
(!item || this.equipSlots()[slotId] === item.etypeId)
) {
this._equips[slotId].setObject(item);
this.refresh();
}
};
Game_Actor.prototype.forceChangeEquip = function(slotId, item) {

this._equips[slotId].setObject(item);
this.releaseUnequippableItems(true);
this.refresh();
};
Game_Actor.prototype.tradeItemWithParty = function(newItem, oldItem) {

if (newItem && !$gameParty.hasItem(newItem)) {
return false;
} else {
$gameParty.gainItem(oldItem, 1);
$gameParty.loseItem(newItem, 1);
return true;
}
};
Game_Actor.prototype.changeEquipById = function(etypeId, itemId) {

const slotId = etypeId - 1;
if (this.equipSlots()[slotId] === 1) {
this.changeEquip(slotId, $dataWeapons[itemId]);
} else {
this.changeEquip(slotId, $dataArmors[itemId]);
}
};
Game_Actor.prototype.isEquipped = function(item) {
return this.equips().includes(item);
};
Game_Actor.prototype.discardEquip = function(item) {
const slotId = this.equips().indexOf(item);
if (slotId >= 0) {
this._equips[slotId].setObject(null);
}
};
Game_Actor.prototype.releaseUnequippableItems = function(forcing) {
for (;;) {
const slots = this.equipSlots();
const equips = this.equips();
let changed = false;
for (let i = 0; i < equips.length; i++) {
const item = equips[i];
if (item && (!this.canEquip(item) || item.etypeId !== slots[i])) {
if (!forcing) {
this.tradeItemWithParty(null, item);
}
this._equips[i].setObject(null);
changed = true;
}
}
if (!changed) {
break;
}
}
};
Game_Actor.prototype.clearEquipments = function() {
const maxSlots = this.equipSlots().length;
if (this.isEquipChangeOk(i)) {
this.changeEquip(i, null);
}
}
};
Game_Actor.prototype.optimizeEquipments = function() {
const maxSlots = this.equipSlots().length;
this.clearEquipments();
if (this.isEquipChangeOk(i)) {
this.changeEquip(i, this.bestEquipItem(i));
}
}
};
Game_Actor.prototype.bestEquipItem = function(slotId) {
const etypeId = this.equipSlots()[slotId];
const items = $gameParty
.equipItems()
.filter(item => item.etypeId === etypeId && this.canEquip(item));
let bestItem = null;
let bestPerformance = -1000;
for (let i = 0; i < items.length; i++) {
const performance = this.calcEquipItemPerformance(items[i]);
if (performance > bestPerformance) {
bestPerformance = performance;
bestItem = items[i];
}
}
return bestItem;
};
Game_Actor.prototype.calcEquipItemPerformance = function(item) {
return item.params.reduce((a, b) => a + b);
};
Game_Actor.prototype.isSkillWtypeOk = function(skill) {
const wtypeId1 = skill.requiredWtypeId1;
const wtypeId2 = skill.requiredWtypeId2;
if (
(wtypeId1 === 0 && wtypeId2 === 0) ||
(wtypeId1 > 0 && this.isWtypeEquipped(wtypeId1)) ||
(wtypeId2 > 0 && this.isWtypeEquipped(wtypeId2))
) {
return true;
} else {
return false;
}
};
Game_Actor.prototype.isWtypeEquipped = function(wtypeId) {
return this.weapons().some(weapon => weapon.wtypeId === wtypeId);
};
Game_Actor.prototype.refresh = function() {
this.releaseUnequippableItems(false);
Game_Battler.prototype.refresh.call(this);
};
Game_Actor.prototype.hide = function() {
Game_Battler.prototype.hide.call(this);
$gameTemp.requestBattleRefresh();
};
Game_Actor.prototype.isActor = function() {
return true;
};
Game_Actor.prototype.friendsUnit = function() {
return $gameParty;
};
Game_Actor.prototype.opponentsUnit = function() {
return $gameTroop;
};
Game_Actor.prototype.index = function() {
return $gameParty.members().indexOf(this);
};
Game_Actor.prototype.isBattleMember = function() {
return $gameParty.battleMembers().includes(this);
};
Game_Actor.prototype.isFormationChangeOk = function() {
return true;
};
Game_Actor.prototype.currentClass = function() {
return $dataClasses[this._classId];
};
Game_Actor.prototype.isClass = function(gameClass) {
return gameClass && this._classId === gameClass.id;
};
Game_Actor.prototype.skillTypes = function() {
const skillTypes = this.addedSkillTypes().sort((a, b) => a - b);
return skillTypes.filter((x, i, self) => self.indexOf(x) === i);
};
Game_Actor.prototype.skills = function() {
const list = [];
for (const id of this._skills.concat(this.addedSkills())) {
if (!list.includes($dataSkills[id])) {
list.push($dataSkills[id]);
}
}
return list;
};
Game_Actor.prototype.usableSkills = function() {
return this.skills().filter(skill => this.canUse(skill));
};
Game_Actor.prototype.traitObjects = function() {
const objects = Game_Battler.prototype.traitObjects.call(this);
objects.push(this.actor(), this.currentClass());
for (const item of this.equips()) {
if (item) {
objects.push(item);
}
}
return objects;
};
Game_Actor.prototype.attackElements = function() {
const set = Game_Battler.prototype.attackElements.call(this);
if (this.hasNoWeapons() && !set.includes(this.bareHandsElementId())) {
set.push(this.bareHandsElementId());
}
return set;
};
Game_Actor.prototype.hasNoWeapons = function() {
return this.weapons().length === 0;
};
Game_Actor.prototype.bareHandsElementId = function() {
return 1;
};
Game_Actor.prototype.paramBase = function(paramId) {
return this.currentClass().params[paramId][this._level];
};
Game_Actor.prototype.paramPlus = function(paramId) {
let value = Game_Battler.prototype.paramPlus.call(this, paramId);
for (const item of this.equips()) {
if (item) {
value += item.params[paramId];
}
}
return value;
};
Game_Actor.prototype.attackAnimationId1 = function() {
if (this.hasNoWeapons()) {
return this.bareHandsAnimationId();
} else {
const weapons = this.weapons();
return weapons[0] ? weapons[0].animationId : 0;
}
};
Game_Actor.prototype.attackAnimationId2 = function() {
return weapons[1] ? weapons[1].animationId : 0;
};
Game_Actor.prototype.bareHandsAnimationId = function() {
return 1;
};
Game_Actor.prototype.changeExp = function(exp, show) {

this._exp[this._classId] = Math.max(exp, 0);
const lastLevel = this._level;
const lastSkills = this.skills();
while (!this.isMaxLevel() && this.currentExp() >= this.nextLevelExp()) {
this.levelUp();
}
while (this.currentExp() < this.currentLevelExp()) {
this.levelDown();
}
if (show && this._level > lastLevel) {
this.displayLevelUp(this.findNewSkills(lastSkills));
}
this.refresh();
};
Game_Actor.prototype.levelUp = function() {
this._level++;
for (const learning of this.currentClass().learnings) {
if (learning.level === this._level) {
this.learnSkill(learning.skillId);
}
}
};
Game_Actor.prototype.levelDown = function() {
this._level--;
};
Game_Actor.prototype.findNewSkills = function(lastSkills) {
const newSkills = this.skills();
for (const lastSkill of lastSkills) {
newSkills.remove(lastSkill);
}
return newSkills;
};
Game_Actor.prototype.displayLevelUp = function(newSkills) {
const text = TextManager.levelUp.format(
this._name,
TextManager.level,
this._level
);
$gameMessage.newPage();
$gameMessage.add(text);
for (const skill of newSkills) {
$gameMessage.add(TextManager.obtainSkill.format(skill.name));
}
};
Game_Actor.prototype.gainExp = function(exp) {
const newExp = this.currentExp() + Math.round(exp * this.finalExpRate());
this.changeExp(newExp, this.shouldDisplayLevelUp());
};
Game_Actor.prototype.finalExpRate = function() {
return this.exr * (this.isBattleMember() ? 1 : this.benchMembersExpRate());
};
Game_Actor.prototype.benchMembersExpRate = function() {
return $dataSystem.optExtraExp ? 1 : 0;
};
Game_Actor.prototype.shouldDisplayLevelUp = function() {
return true;
};
Game_Actor.prototype.changeLevel = function(level, show) {

level = level.clamp(1, this.maxLevel());
this.changeExp(this.expForLevel(level), show);
};
Game_Actor.prototype.learnSkill = function(skillId) {
if (!this.isLearnedSkill(skillId)) {
this._skills.push(skillId);
this._skills.sort((a, b) => a - b);
}
};
Game_Actor.prototype.forgetSkill = function(skillId) {
this._skills.remove(skillId);
};
Game_Actor.prototype.isLearnedSkill = function(skillId) {
return this._skills.includes(skillId);
};
Game_Actor.prototype.hasSkill = function(skillId) {
return this.skills().includes($dataSkills[skillId]);
};
Game_Actor.prototype.changeClass = function(classId, keepExp) {

if (keepExp) {
this._exp[classId] = this.currentExp();
}
this._classId = classId;
this._level = 0;
this.changeExp(this._exp[this._classId] || 0, false);
this.refresh();
};
Game_Actor.prototype.setCharacterImage = function(
characterName,
characterIndex
) {
this._characterName = characterName;
this._characterIndex = characterIndex;
};
Game_Actor.prototype.setFaceImage = function(faceName, faceIndex) {

this._faceName = faceName;
this._faceIndex = faceIndex;
};
Game_Actor.prototype.setBattlerImage = function(battlerName) {
this._battlerName = battlerName;
};
Game_Actor.prototype.isSpriteVisible = function() {
return $gameSystem.isSideView();
};
Game_Actor.prototype.performActionStart = function(action) {
Game_Battler.prototype.performActionStart.call(this, action);
};
Game_Actor.prototype.performAction = function(action) {
Game_Battler.prototype.performAction.call(this, action);
if (action.isAttack()) {
this.performAttack();
} else if (action.isGuard()) {
this.requestMotion("guard");
} else if (action.isMagicSkill()) {
this.requestMotion("spell");
} else if (action.isSkill()) {
this.requestMotion("skill");
} else if (action.isItem()) {
this.requestMotion("item");
}
};
Game_Actor.prototype.performActionEnd = function() {
Game_Battler.prototype.performActionEnd.call(this);
};
Game_Actor.prototype.performAttack = function() {
const wtypeId = weapons[0] ? weapons[0].wtypeId : 0;
const attackMotion = $dataSystem.attackMotions[wtypeId];
if (attackMotion) {
if (attackMotion.type === 0) {
this.requestMotion("thrust");
} else if (attackMotion.type === 1) {
this.requestMotion("swing");
} else if (attackMotion.type === 2) {
this.requestMotion("missile");
}
this.startWeaponAnimation(attackMotion.weaponImageId);
}
};
Game_Actor.prototype.performDamage = function() {
Game_Battler.prototype.performDamage.call(this);
if (this.isSpriteVisible()) {
this.requestMotion("damage");
} else {
$gameScreen.startShake(5, 5, 10);
}
SoundManager.playActorDamage();
};
Game_Actor.prototype.performEvasion = function() {
Game_Battler.prototype.performEvasion.call(this);
this.requestMotion("evade");
};
Game_Actor.prototype.performMagicEvasion = function() {
Game_Battler.prototype.performMagicEvasion.call(this);
this.requestMotion("evade");
};
Game_Actor.prototype.performCounter = function() {
Game_Battler.prototype.performCounter.call(this);
this.performAttack();
};
Game_Actor.prototype.performCollapse = function() {
Game_Battler.prototype.performCollapse.call(this);
SoundManager.playActorCollapse();
}
};
Game_Actor.prototype.performVictory = function() {
this.setActionState("done");
this.requestMotion("victory");
}
};
Game_Actor.prototype.performEscape = function() {
this.requestMotion("escape");
}
};
Game_Actor.prototype.makeActionList = function() {
const list = [];
const attackAction = new Game_Action(this);
attackAction.setAttack();
list.push(attackAction);
for (const skill of this.usableSkills()) {
const skillAction = new Game_Action(this);
skillAction.setSkill(skill.id);
list.push(skillAction);
}
return list;
};
Game_Actor.prototype.makeAutoBattleActions = function() {
for (let i = 0; i < this.numActions(); i++) {
const list = this.makeActionList();
let maxValue = -Number.MAX_VALUE;
for (const action of list) {
const value = action.evaluate();
if (value > maxValue) {
maxValue = value;
this.setAction(i, action);
}
}
}
};
Game_Actor.prototype.makeConfusionActions = function() {
this.action(i).setConfusion();
}
};
Game_Actor.prototype.makeActions = function() {
Game_Battler.prototype.makeActions.call(this);
if (this.numActions() > 0) {
} else {
}
if (this.isAutoBattle()) {
this.makeAutoBattleActions();
} else if (this.isConfused()) {
this.makeConfusionActions();
}
};
Game_Actor.prototype.onPlayerWalk = function() {
this.clearResult();
this.checkFloorEffect();
if ($gamePlayer.isNormal()) {
this.turnEndOnMap();
this.updateStateSteps(state);
}
this.showAddedStates();
this.showRemovedStates();
}
};
Game_Actor.prototype.updateStateSteps = function(state) {
if (state.removeByWalking) {
if (this._stateSteps[state.id] > 0) {
if (--this._stateSteps[state.id] === 0) {
}
}
}
};
Game_Actor.prototype.showAddedStates = function() {
for (const state of this.result().addedStateObjects()) {
$gameMessage.add(state.message1.format(this._name));
}
}
};
Game_Actor.prototype.showRemovedStates = function() {
for (const state of this.result().removedStateObjects()) {
$gameMessage.add(state.message4.format(this._name));
}
}
};
Game_Actor.prototype.stepsForTurn = function() {
return 20;
};
Game_Actor.prototype.turnEndOnMap = function() {
if ($gameParty.steps() % this.stepsForTurn() === 0) {
this.onTurnEnd();
if (this.result().hpDamage > 0) {
this.performMapDamage();
}
}
};
Game_Actor.prototype.checkFloorEffect = function() {
if ($gamePlayer.isOnDamageFloor()) {
this.executeFloorDamage();
}
};
Game_Actor.prototype.executeFloorDamage = function() {
const floorDamage = Math.floor(this.basicFloorDamage() * this.fdr);
const realDamage = Math.min(floorDamage, this.maxFloorDamage());
this.gainHp(-realDamage);
if (realDamage > 0) {
this.performMapDamage();
}
};
Game_Actor.prototype.basicFloorDamage = function() {
return 10;
};
Game_Actor.prototype.maxFloorDamage = function() {
return $dataSystem.optFloorDeath ? this.hp : Math.max(this.hp - 1, 0);
};
Game_Actor.prototype.performMapDamage = function() {
if (!$gameParty.inBattle()) {
$gameScreen.startFlashForDamage();
}
};
Game_Actor.prototype.clearActions = function() {
Game_Battler.prototype.clearActions.call(this);
this._actionInputIndex = 0;
};
Game_Actor.prototype.inputtingAction = function() {
return this.action(this._actionInputIndex);
};
Game_Actor.prototype.selectNextCommand = function() {
if (this._actionInputIndex < this.numActions() - 1) {
this._actionInputIndex++;
return true;
} else {
return false;
}
};
Game_Actor.prototype.selectPreviousCommand = function() {
if (this._actionInputIndex > 0) {
this._actionInputIndex--;
return true;
} else {
return false;
}
};
Game_Actor.prototype.lastSkill = function() {
return this.lastBattleSkill();
} else {
return this.lastMenuSkill();
}
};
Game_Actor.prototype.lastMenuSkill = function() {
return this._lastMenuSkill.object();
};
Game_Actor.prototype.setLastMenuSkill = function(skill) {
this._lastMenuSkill.setObject(skill);
};
Game_Actor.prototype.lastBattleSkill = function() {
return this._lastBattleSkill.object();
};
Game_Actor.prototype.setLastBattleSkill = function(skill) {
this._lastBattleSkill.setObject(skill);
};
Game_Actor.prototype.lastCommandSymbol = function() {
return this._lastCommandSymbol;
};
Game_Actor.prototype.setLastCommandSymbol = function(symbol) {
this._lastCommandSymbol = symbol;
};
Game_Actor.prototype.testEscape = function(item) {
return item.effects.some(
effect => effect && effect.code === Game_Action.EFFECT_SPECIAL
);
};
Game_Actor.prototype.meetsUsableItemConditions = function(item) {
if (!BattleManager.canEscape() && this.testEscape(item)) {
return false;
}
}
return Game_BattlerBase.prototype.meetsUsableItemConditions.call(
this,
item
);
};
Game_Actor.prototype.onEscapeFailure = function() {
if (BattleManager.isTpb()) {
this.applyTpbPenalty();
}
this.requestMotionRefresh();
};
//-----------------------------------------------------------------------------
// Game_Enemy
//
// The game object class for an enemy.
function Game_Enemy() {
}
Game_Enemy.prototype = Object.create(Game_Battler.prototype);
Game_Enemy.prototype.constructor = Game_Enemy;
Game_Enemy.prototype.initialize = function(enemyId, x, y) {
Game_Battler.prototype.initialize.call(this);
this.setup(enemyId, x, y);
};
Game_Enemy.prototype.initMembers = function() {
Game_Battler.prototype.initMembers.call(this);
this._enemyId = 0;
this._letter = "";
this._plural = false;
this._screenX = 0;
this._screenY = 0;
};
Game_Enemy.prototype.setup = function(enemyId, x, y) {
this._enemyId = enemyId;
this._screenX = x;
this._screenY = y;
this.recoverAll();
};
Game_Enemy.prototype.isEnemy = function() {
return true;
};
Game_Enemy.prototype.friendsUnit = function() {
return $gameTroop;
};
Game_Enemy.prototype.opponentsUnit = function() {
return $gameParty;
};
Game_Enemy.prototype.index = function() {
return $gameTroop.members().indexOf(this);
};
Game_Enemy.prototype.isBattleMember = function() {
return this.index() >= 0;
};
Game_Enemy.prototype.enemyId = function() {
return this._enemyId;
};
Game_Enemy.prototype.enemy = function() {
return $dataEnemies[this._enemyId];
};
Game_Enemy.prototype.traitObjects = function() {
return Game_Battler.prototype.traitObjects.call(this).concat(this.enemy());
};
Game_Enemy.prototype.paramBase = function(paramId) {
return this.enemy().params[paramId];
};
Game_Enemy.prototype.exp = function() {
return this.enemy().exp;
};
Game_Enemy.prototype.gold = function() {
return this.enemy().gold;
};
Game_Enemy.prototype.makeDropItems = function() {
const rate = this.dropItemRate();
return this.enemy().dropItems.reduce((r, di) => {
if (di.kind > 0 && Math.random() * di.denominator < rate) {
return r.concat(this.itemObject(di.kind, di.dataId));
} else {
return r;
}
}, []);
};
Game_Enemy.prototype.dropItemRate = function() {
return $gameParty.hasDropItemDouble() ? 2 : 1;
};
Game_Enemy.prototype.itemObject = function(kind, dataId) {

if (kind === 1) {
return $dataItems[dataId];
} else if (kind === 2) {
return $dataWeapons[dataId];
} else if (kind === 3) {
return $dataArmors[dataId];
} else {
return null;
}
};
Game_Enemy.prototype.isSpriteVisible = function() {
return true;
};
Game_Enemy.prototype.screenX = function() {
return this._screenX;
};
Game_Enemy.prototype.screenY = function() {
return this._screenY;
};
Game_Enemy.prototype.battlerName = function() {
return this.enemy().battlerName;
};
Game_Enemy.prototype.battlerHue = function() {
return this.enemy().battlerHue;
};
Game_Enemy.prototype.originalName = function() {
return this.enemy().name;
};
Game_Enemy.prototype.name = function() {
return this.originalName() + (this._plural ? this._letter : "");
};
Game_Enemy.prototype.isLetterEmpty = function() {
return this._letter === "";
};
Game_Enemy.prototype.setLetter = function(letter) {
this._letter = letter;
};
Game_Enemy.prototype.setPlural = function(plural) {
this._plural = plural;
};
Game_Enemy.prototype.performActionStart = function(action) {
Game_Battler.prototype.performActionStart.call(this, action);
this.requestEffect("whiten");
};
Game_Enemy.prototype.performAction = function(action) {
Game_Battler.prototype.performAction.call(this, action);
};
Game_Enemy.prototype.performActionEnd = function() {
Game_Battler.prototype.performActionEnd.call(this);
};
Game_Enemy.prototype.performDamage = function() {
Game_Battler.prototype.performDamage.call(this);
SoundManager.playEnemyDamage();
this.requestEffect("blink");
};
Game_Enemy.prototype.performCollapse = function() {
Game_Battler.prototype.performCollapse.call(this);
switch (this.collapseType()) {
case 0:
this.requestEffect("collapse");
SoundManager.playEnemyCollapse();
break;
case 1:
this.requestEffect("bossCollapse");
SoundManager.playBossCollapse1();
break;
case 2:
this.requestEffect("instantCollapse");
break;
}
};
Game_Enemy.prototype.transform = function(enemyId) {
const name = this.originalName();
this._enemyId = enemyId;
if (this.originalName() !== name) {
this._letter = "";
this._plural = false;
}
this.refresh();
this.makeActions();
}
};
Game_Enemy.prototype.meetsCondition = function(action) {
const param1 = action.conditionParam1;
const param2 = action.conditionParam2;
switch (action.conditionType) {
case 1:
return this.meetsTurnCondition(param1, param2);
case 2:
return this.meetsHpCondition(param1, param2);
case 3:
return this.meetsMpCondition(param1, param2);
case 4:
return this.meetsStateCondition(param1);
case 5:
return this.meetsPartyLevelCondition(param1);
case 6:
return this.meetsSwitchCondition(param1);
default:
return true;
}
};
Game_Enemy.prototype.meetsTurnCondition = function(param1, param2) {

const n = this.turnCount();
if (param2 === 0) {
return n === param1;
} else {
return n > 0 && n >= param1 && n % param2 === param1 % param2;
}
};
Game_Enemy.prototype.meetsHpCondition = function(param1, param2) {

return this.hpRate() >= param1 && this.hpRate() <= param2;
};
Game_Enemy.prototype.meetsMpCondition = function(param1, param2) {

return this.mpRate() >= param1 && this.mpRate() <= param2;
};
Game_Enemy.prototype.meetsStateCondition = function(param) {
return this.isStateAffected(param);
};
Game_Enemy.prototype.meetsPartyLevelCondition = function(param) {
return $gameParty.highestLevel() >= param;
};
Game_Enemy.prototype.meetsSwitchCondition = function(param) {
return $gameSwitches.value(param);
};
Game_Enemy.prototype.isActionValid = function(action) {
return (
this.meetsCondition(action) && this.canUse($dataSkills[action.skillId])
);
};
Game_Enemy.prototype.selectAction = function(actionList, ratingZero) {

const sum = actionList.reduce((r, a) => r + a.rating - ratingZero, 0);
if (sum > 0) {
let value = Math.randomInt(sum);
for (const action of actionList) {
value -= action.rating - ratingZero;
if (value < 0) {
return action;
}
}
} else {
return null;
}
};
Game_Enemy.prototype.selectAllActions = function(actionList) {
const ratingMax = Math.max(...actionList.map(a => a.rating));
const ratingZero = ratingMax - 3;
actionList = actionList.filter(a => a.rating > ratingZero);
this.action(i).setEnemyAction(
this.selectAction(actionList, ratingZero)
);
}
};
Game_Enemy.prototype.makeActions = function() {
Game_Battler.prototype.makeActions.call(this);
const actionList = this.enemy().actions.filter(a =>
this.isActionValid(a)
);
if (actionList.length > 0) {
this.selectAllActions(actionList);
}
}
};
//-----------------------------------------------------------------------------
// Game_Actors
//
// The wrapper class for an actor array.
function Game_Actors() {
}
Game_Actors.prototype.initialize = function() {
this._data = [];
};
Game_Actors.prototype.actor = function(actorId) {
if ($dataActors[actorId]) {
if (!this._data[actorId]) {
this._data[actorId] = new Game_Actor(actorId);
}
return this._data[actorId];
}
return null;
};
//-----------------------------------------------------------------------------
// Game_Unit
//
// The superclass of Game_Party and Game_Troop.
function Game_Unit() {
}
Game_Unit.prototype.initialize = function() {
this._inBattle = false;
};
Game_Unit.prototype.inBattle = function() {
return this._inBattle;
};
Game_Unit.prototype.members = function() {
return [];
};
Game_Unit.prototype.aliveMembers = function() {
return this.members().filter(member => member.isAlive());
};
Game_Unit.prototype.deadMembers = function() {
return this.members().filter(member => member.isDead());
};
Game_Unit.prototype.movableMembers = function() {
return this.members().filter(member => member.canMove());
};
Game_Unit.prototype.clearActions = function() {
for (const member of this.members()) {
member.clearActions();
}
};
Game_Unit.prototype.agility = function() {
const members = this.members();
const sum = members.reduce((r, member) => r + member.agi, 0);
return Math.max(1, sum / Math.max(1, members.length));
};
Game_Unit.prototype.tgrSum = function() {
return this.aliveMembers().reduce((r, member) => r + member.tgr, 0);
};
Game_Unit.prototype.randomTarget = function() {
let tgrRand = Math.random() * this.tgrSum();
let target = null;
for (const member of this.aliveMembers()) {
tgrRand -= member.tgr;
if (tgrRand <= 0 && !target) {
target = member;
}
}
return target;
};
Game_Unit.prototype.randomDeadTarget = function() {
const members = this.deadMembers();
return members.length ? members[Math.randomInt(members.length)] : null;
};
Game_Unit.prototype.smoothTarget = function(index) {
const member = this.members()[Math.max(0, index)];
return member && member.isAlive() ? member : this.aliveMembers()[0];
};
Game_Unit.prototype.smoothDeadTarget = function(index) {
const member = this.members()[Math.max(0, index)];
return member && member.isDead() ? member : this.deadMembers()[0];
};
Game_Unit.prototype.clearResults = function() {
member.clearResult();
}
};
Game_Unit.prototype.onBattleStart = function(advantageous) {
member.onBattleStart(advantageous);
}
this._inBattle = true;
};
Game_Unit.prototype.onBattleEnd = function() {
this._inBattle = false;
member.onBattleEnd();
}
};
Game_Unit.prototype.makeActions = function() {
member.makeActions();
}
};
Game_Unit.prototype.select = function(activeMember) {
if (member === activeMember) {
member.select();
} else {
member.deselect();
}
}
};
Game_Unit.prototype.isAllDead = function() {
return this.aliveMembers().length === 0;
};
Game_Unit.prototype.substituteBattler = function() {
if (member.isSubstitute()) {
return member;
}
}
return null;
};
Game_Unit.prototype.tpbBaseSpeed = function() {
return Math.max(...members.map(member => member.tpbBaseSpeed()));
};
Game_Unit.prototype.tpbReferenceTime = function() {
return BattleManager.isActiveTpb() ? 240 : 60;
};
Game_Unit.prototype.updateTpb = function() {
member.updateTpb();
}
};
//-----------------------------------------------------------------------------
// Game_Party
//
// The game object class for the party. Information such as gold and items is
// included.
function Game_Party() {
}
Game_Party.prototype = Object.create(Game_Unit.prototype);
Game_Party.prototype.constructor = Game_Party;
Game_Party.ABILITY_ENCOUNTER_HALF = 0;
Game_Party.ABILITY_ENCOUNTER_NONE = 1;
Game_Party.ABILITY_CANCEL_SURPRISE = 2;
Game_Party.ABILITY_RAISE_PREEMPTIVE = 3;
Game_Party.ABILITY_GOLD_DOUBLE = 4;
Game_Party.ABILITY_DROP_ITEM_DOUBLE = 5;
Game_Party.prototype.initialize = function() {
Game_Unit.prototype.initialize.call(this);
this._gold = 0;
this._steps = 0;
this._lastItem = new Game_Item();
this._menuActorId = 0;
this._targetActorId = 0;
this._actors = [];
this.initAllItems();
};
Game_Party.prototype.initAllItems = function() {
this._items = {};
this._weapons = {};
this._armors = {};
};
Game_Party.prototype.exists = function() {
return this._actors.length > 0;
};
Game_Party.prototype.size = function() {
return this.members().length;
};
Game_Party.prototype.isEmpty = function() {
return this.size() === 0;
};
Game_Party.prototype.members = function() {
return this.inBattle() ? this.battleMembers() : this.allMembers();
};
Game_Party.prototype.allMembers = function() {
return this._actors.map(id => $gameActors.actor(id));
};
Game_Party.prototype.battleMembers = function() {
return this.allBattleMembers().filter(actor => actor.isAppeared());
};
Game_Party.prototype.hiddenBattleMembers = function() {
return this.allBattleMembers().filter(actor => actor.isHidden());
};
Game_Party.prototype.allBattleMembers = function() {
return this.allMembers().slice(0, this.maxBattleMembers());
};
Game_Party.prototype.maxBattleMembers = function() {
return 4;
};
Game_Party.prototype.leader = function() {
return this.battleMembers()[0];
};
Game_Party.prototype.removeInvalidMembers = function() {
for (const actorId of this._actors) {
if (!$dataActors[actorId]) {
this._actors.remove(actorId);
}
}
};
Game_Party.prototype.reviveBattleMembers = function() {
for (const actor of this.battleMembers()) {
if (actor.isDead()) {
actor.setHp(1);
}
}
};
Game_Party.prototype.items = function() {
return Object.keys(this._items).map(id => $dataItems[id]);
};
Game_Party.prototype.weapons = function() {
return Object.keys(this._weapons).map(id => $dataWeapons[id]);
};
Game_Party.prototype.armors = function() {
return Object.keys(this._armors).map(id => $dataArmors[id]);
};
Game_Party.prototype.equipItems = function() {
return this.weapons().concat(this.armors());
};
Game_Party.prototype.allItems = function() {
return this.items().concat(this.equipItems());
};
Game_Party.prototype.itemContainer = function(item) {
if (!item) {
return null;
return this._items;
return this._weapons;
return this._armors;
} else {
return null;
}
};
Game_Party.prototype.setupStartingMembers = function() {
this._actors = [];
for (const actorId of $dataSystem.partyMembers) {
if ($gameActors.actor(actorId)) {
this._actors.push(actorId);
}
}
};
Game_Party.prototype.name = function() {
const numBattleMembers = this.battleMembers().length;
if (numBattleMembers === 0) {
return "";
} else if (numBattleMembers === 1) {
return this.leader().name();
} else {
return TextManager.partyName.format(this.leader().name());
}
};
Game_Party.prototype.setupBattleTest = function() {
this.setupBattleTestMembers();
this.setupBattleTestItems();
};
Game_Party.prototype.setupBattleTestMembers = function() {
for (const battler of $dataSystem.testBattlers) {
const actor = $gameActors.actor(battler.actorId);
if (actor) {
actor.changeLevel(battler.level, false);
actor.initEquips(battler.equips);
actor.recoverAll();
this.addActor(battler.actorId);
}
}
};
Game_Party.prototype.setupBattleTestItems = function() {
for (const item of $dataItems) {
if (item && item.name.length > 0) {
this.gainItem(item, this.maxItems(item));
}
}
};
Game_Party.prototype.highestLevel = function() {
return Math.max(...this.members().map(actor => actor.level));
};
Game_Party.prototype.addActor = function(actorId) {
if (!this._actors.includes(actorId)) {
this._actors.push(actorId);
$gamePlayer.refresh();
if (this.inBattle()) {
const actor = $gameActors.actor(actorId);
if (this.battleMembers().includes(actor)) {
actor.onBattleStart();
}
}
}
};
Game_Party.prototype.removeActor = function(actorId) {
if (this._actors.includes(actorId)) {
const actor = $gameActors.actor(actorId);
const wasBattleMember = this.battleMembers().includes(actor);
this._actors.remove(actorId);
if (this.inBattle() && wasBattleMember) {
actor.onBattleEnd();
}
}
};
Game_Party.prototype.gold = function() {
return this._gold;
};
Game_Party.prototype.gainGold = function(amount) {
this._gold = (this._gold + amount).clamp(0, this.maxGold());
};
Game_Party.prototype.loseGold = function(amount) {
this.gainGold(-amount);
};
Game_Party.prototype.maxGold = function() {
return 99999999;
};
Game_Party.prototype.steps = function() {
return this._steps;
};
Game_Party.prototype.increaseSteps = function() {
this._steps++;
};
Game_Party.prototype.numItems = function(item) {
const container = this.itemContainer(item);
return container ? container[item.id] || 0 : 0;
};
Game_Party.prototype.maxItems = function(/*item*/) {
return 99;
};
Game_Party.prototype.hasMaxItems = function(item) {
return this.numItems(item) >= this.maxItems(item);
};
Game_Party.prototype.hasItem = function(item, includeEquip) {

if (this.numItems(item) > 0) {
return true;
} else if (includeEquip && this.isAnyMemberEquipped(item)) {
return true;
} else {
return false;
}
};
Game_Party.prototype.isAnyMemberEquipped = function(item) {
return this.members().some(actor => actor.equips().includes(item));
};
Game_Party.prototype.gainItem = function(item, amount, includeEquip) {

const container = this.itemContainer(item);
if (container) {
const lastNumber = this.numItems(item);
const newNumber = lastNumber + amount;
container[item.id] = newNumber.clamp(0, this.maxItems(item));
if (container[item.id] === 0) {
delete container[item.id];
}
if (includeEquip && newNumber < 0) {
this.discardMembersEquip(item, -newNumber);
}
}
};
Game_Party.prototype.discardMembersEquip = function(item, amount) {

let n = amount;
for (const actor of this.members()) {
while (n > 0 && actor.isEquipped(item)) {
actor.discardEquip(item);
n--;
}
}
};
Game_Party.prototype.loseItem = function(item, amount, includeEquip) {

this.gainItem(item, -amount, includeEquip);
};
Game_Party.prototype.consumeItem = function(item) {
if (DataManager.isItem(item) && item.consumable) {
this.loseItem(item, 1);
}
};
Game_Party.prototype.canUse = function(item) {
return this.members().some(actor => actor.canUse(item));
};
Game_Party.prototype.canInput = function() {
return this.members().some(actor => actor.canInput());
};
Game_Party.prototype.isAllDead = function() {
if (Game_Unit.prototype.isAllDead.call(this)) {
return this.inBattle() || !this.isEmpty();
} else {
return false;
}
};
Game_Party.prototype.isEscaped = function() {
return this.isAllDead() && this.hiddenBattleMembers().length > 0;
};
Game_Party.prototype.onPlayerWalk = function() {
actor.onPlayerWalk();
}
};
Game_Party.prototype.menuActor = function() {
let actor = $gameActors.actor(this._menuActorId);
if (!this.members().includes(actor)) {
actor = this.members()[0];
}
return actor;
};
Game_Party.prototype.setMenuActor = function(actor) {
this._menuActorId = actor.actorId();
};
Game_Party.prototype.makeMenuActorNext = function() {
let index = this.members().indexOf(this.menuActor());
if (index >= 0) {
index = (index + 1) % this.members().length;
this.setMenuActor(this.members()[index]);
} else {
this.setMenuActor(this.members()[0]);
}
};
Game_Party.prototype.makeMenuActorPrevious = function() {
let index = this.members().indexOf(this.menuActor());
if (index >= 0) {
index = (index + this.members().length - 1) % this.members().length;
this.setMenuActor(this.members()[index]);
} else {
this.setMenuActor(this.members()[0]);
}
};
Game_Party.prototype.targetActor = function() {
let actor = $gameActors.actor(this._targetActorId);
if (!this.members().includes(actor)) {
actor = this.members()[0];
}
return actor;
};
Game_Party.prototype.setTargetActor = function(actor) {
this._targetActorId = actor.actorId();
};
Game_Party.prototype.lastItem = function() {
return this._lastItem.object();
};
Game_Party.prototype.setLastItem = function(item) {
this._lastItem.setObject(item);
};
Game_Party.prototype.swapOrder = function(index1, index2) {

const temp = this._actors[index1];
this._actors[index1] = this._actors[index2];
this._actors[index2] = temp;
};
Game_Party.prototype.charactersForSavefile = function() {
return this.battleMembers().map(actor => [
actor.characterName(),
actor.characterIndex()
]);
};
Game_Party.prototype.facesForSavefile = function() {
return this.battleMembers().map(actor => [
actor.faceName(),
actor.faceIndex()
]);
};
Game_Party.prototype.partyAbility = function(abilityId) {
return this.battleMembers().some(actor => actor.partyAbility(abilityId));
};
Game_Party.prototype.hasEncounterHalf = function() {
return this.partyAbility(Game_Party.ABILITY_ENCOUNTER_HALF);
};
Game_Party.prototype.hasEncounterNone = function() {
return this.partyAbility(Game_Party.ABILITY_ENCOUNTER_NONE);
};
Game_Party.prototype.hasCancelSurprise = function() {
return this.partyAbility(Game_Party.ABILITY_CANCEL_SURPRISE);
};
Game_Party.prototype.hasRaisePreemptive = function() {
return this.partyAbility(Game_Party.ABILITY_RAISE_PREEMPTIVE);
};
Game_Party.prototype.hasGoldDouble = function() {
return this.partyAbility(Game_Party.ABILITY_GOLD_DOUBLE);
};
Game_Party.prototype.hasDropItemDouble = function() {
return this.partyAbility(Game_Party.ABILITY_DROP_ITEM_DOUBLE);
};
Game_Party.prototype.ratePreemptive = function(troopAgi) {
let rate = this.agility() >= troopAgi ? 0.05 : 0.03;
if (this.hasRaisePreemptive()) {
rate *= 4;
}
return rate;
};
Game_Party.prototype.rateSurprise = function(troopAgi) {
let rate = this.agility() >= troopAgi ? 0.03 : 0.05;
if (this.hasCancelSurprise()) {
rate = 0;
}
return rate;
};
Game_Party.prototype.performVictory = function() {
actor.performVictory();
}
};
Game_Party.prototype.performEscape = function() {
actor.performEscape();
}
};
Game_Party.prototype.removeBattleStates = function() {
actor.removeBattleStates();
}
};
Game_Party.prototype.requestMotionRefresh = function() {
actor.requestMotionRefresh();
}
};
Game_Party.prototype.onEscapeFailure = function() {
actor.onEscapeFailure();
}
};
//-----------------------------------------------------------------------------
// Game_Troop
//
// The game object class for a troop and the battle-related data.
function Game_Troop() {
}
Game_Troop.prototype = Object.create(Game_Unit.prototype);
Game_Troop.prototype.constructor = Game_Troop;
// prettier-ignore
Game_Troop.LETTER_TABLE_HALF = [
" A"," B"," C"," D"," E"," F"," G"," H"," I"," J"," K"," L"," M",
" N"," O"," P"," Q"," R"," S"," T"," U"," V"," W"," X"," Y"," Z"
];
// prettier-ignore
Game_Troop.LETTER_TABLE_FULL = [
"Ａ","Ｂ","Ｃ","Ｄ","Ｅ","Ｆ","Ｇ","Ｈ","Ｉ","Ｊ","Ｋ","Ｌ","Ｍ",
"Ｎ","Ｏ","Ｐ","Ｑ","Ｒ","Ｓ","Ｔ","Ｕ","Ｖ","Ｗ","Ｘ","Ｙ","Ｚ"
];
Game_Troop.prototype.initialize = function() {
Game_Unit.prototype.initialize.call(this);
this._interpreter = new Game_Interpreter();
this.clear();
};
Game_Troop.prototype.isEventRunning = function() {
return this._interpreter.isRunning();
};
Game_Troop.prototype.updateInterpreter = function() {
this._interpreter.update();
};
Game_Troop.prototype.turnCount = function() {
return this._turnCount;
};
Game_Troop.prototype.members = function() {
return this._enemies;
};
Game_Troop.prototype.clear = function() {
this._interpreter.clear();
this._troopId = 0;
this._eventFlags = {};
this._enemies = [];
this._turnCount = 0;
this._namesCount = {};
};
Game_Troop.prototype.troop = function() {
return $dataTroops[this._troopId];
};
Game_Troop.prototype.setup = function(troopId) {
this.clear();
this._troopId = troopId;
this._enemies = [];
for (const member of this.troop().members) {
if ($dataEnemies[member.enemyId]) {
const enemyId = member.enemyId;
const x = member.x;
const y = member.y;
const enemy = new Game_Enemy(enemyId, x, y);
if (member.hidden) {
enemy.hide();
}
this._enemies.push(enemy);
}
}
this.makeUniqueNames();
};
Game_Troop.prototype.makeUniqueNames = function() {
const table = this.letterTable();
for (const enemy of this.members()) {
if (enemy.isAlive() && enemy.isLetterEmpty()) {
const name = enemy.originalName();
const n = this._namesCount[name] || 0;
enemy.setLetter(table[n % table.length]);
this._namesCount[name] = n + 1;
}
}
this.updatePluralFlags();
};
Game_Troop.prototype.updatePluralFlags = function() {
if (this._namesCount[name] >= 2) {
enemy.setPlural(true);
}
}
};
Game_Troop.prototype.letterTable = function() {
return $gameSystem.isCJK()
? Game_Troop.LETTER_TABLE_FULL
: Game_Troop.LETTER_TABLE_HALF;
};
Game_Troop.prototype.enemyNames = function() {
const names = [];
if (enemy.isAlive() && !names.includes(name)) {
names.push(name);
}
}
return names;
};
Game_Troop.prototype.meetsConditions = function(page) {
const c = page.conditions;
if (
!c.turnEnding &&
!c.turnValid &&
!c.enemyValid &&
!c.actorValid &&
!c.switchValid
) {
return false; // Conditions not set
}
if (c.turnEnding) {
if (!BattleManager.isTurnEnd()) {
return false;
}
}
if (c.turnValid) {
const n = this._turnCount;
const a = c.turnA;
const b = c.turnB;
if (b === 0 && n !== a) {
return false;
}
if (b > 0 && (n < 1 || n < a || n % b !== a % b)) {
return false;
}
}
if (c.enemyValid) {
const enemy = $gameTroop.members()[c.enemyIndex];
if (!enemy || enemy.hpRate() * 100 > c.enemyHp) {
return false;
}
}
if (c.actorValid) {
const actor = $gameActors.actor(c.actorId);
if (!actor || actor.hpRate() * 100 > c.actorHp) {
return false;
}
}
if (c.switchValid) {
if (!$gameSwitches.value(c.switchId)) {
return false;
}
}
return true;
};
Game_Troop.prototype.setupBattleEvent = function() {
if (!this._interpreter.isRunning()) {
if (this._interpreter.setupReservedCommonEvent()) {
return;
}
const pages = this.troop().pages;
for (let i = 0; i < pages.length; i++) {
const page = pages[i];
if (this.meetsConditions(page) && !this._eventFlags[i]) {
this._interpreter.setup(page.list);
if (page.span <= 1) {
this._eventFlags[i] = true;
}
break;
}
}
}
};
Game_Troop.prototype.increaseTurn = function() {
const pages = this.troop().pages;
for (let i = 0; i < pages.length; i++) {
if (page.span === 1) {
this._eventFlags[i] = false;
}
}
this._turnCount++;
};
Game_Troop.prototype.expTotal = function() {
return this.deadMembers().reduce((r, enemy) => r + enemy.exp(), 0);
};
Game_Troop.prototype.goldTotal = function() {
return members.reduce((r, enemy) => r + enemy.gold(), 0) * this.goldRate();
};
Game_Troop.prototype.goldRate = function() {
return $gameParty.hasGoldDouble() ? 2 : 1;
};
Game_Troop.prototype.makeDropItems = function() {
return members.reduce((r, enemy) => r.concat(enemy.makeDropItems()), []);
};
Game_Troop.prototype.isTpbTurnEnd = function() {
const turnMax = Math.max(...members.map(member => member.turnCount()));
return turnMax > this._turnCount;
};
//-----------------------------------------------------------------------------
// Game_Map
//
// The game object class for a map. It contains scrolling and passage
// determination functions.
function Game_Map() {
}
Game_Map.prototype.initialize = function() {
this._mapId = 0;
this._tilesetId = 0;
this._events = [];
this._commonEvents = [];
this._vehicles = [];
this._displayX = 0;
this._displayY = 0;
this._nameDisplay = true;
this._scrollDirection = 2;
this._scrollRest = 0;
this._parallaxName = "";
this._parallaxZero = false;
this._parallaxLoopX = false;
this._parallaxLoopY = false;
this._parallaxSx = 0;
this._parallaxSy = 0;
this._parallaxX = 0;
this._parallaxY = 0;
this._battleback1Name = null;
this.createVehicles();
};
Game_Map.prototype.setup = function(mapId) {
if (!$dataMap) {
throw new Error("The map data is not available");
}
this._mapId = mapId;
this._tilesetId = $dataMap.tilesetId;
this._displayX = 0;
this._displayY = 0;
this.refereshVehicles();
this.setupEvents();
this.setupScroll();
this.setupParallax();
this.setupBattleback();
this._needsRefresh = false;
};
Game_Map.prototype.isEventRunning = function() {
return this._interpreter.isRunning() || this.isAnyEventStarting();
};
Game_Map.prototype.tileWidth = function() {
if ("tileSize" in $dataSystem) {
return $dataSystem.tileSize;
} else {
return 48;
}
};
Game_Map.prototype.tileHeight = function() {
return this.tileWidth();
};
Game_Map.prototype.bushDepth = function() {
return this.tileHeight() / 4;
};
Game_Map.prototype.mapId = function() {
return this._mapId;
};
Game_Map.prototype.tilesetId = function() {
return this._tilesetId;
};
Game_Map.prototype.displayX = function() {
return this._displayX;
};
Game_Map.prototype.displayY = function() {
return this._displayY;
};
Game_Map.prototype.parallaxName = function() {
return this._parallaxName;
};
Game_Map.prototype.battleback1Name = function() {
return this._battleback1Name;
};
Game_Map.prototype.battleback2Name = function() {
return this._battleback2Name;
};
Game_Map.prototype.requestRefresh = function() {
this._needsRefresh = true;
};
Game_Map.prototype.isNameDisplayEnabled = function() {
return this._nameDisplay;
};
Game_Map.prototype.disableNameDisplay = function() {
this._nameDisplay = false;
};
Game_Map.prototype.enableNameDisplay = function() {
this._nameDisplay = true;
};
Game_Map.prototype.createVehicles = function() {
this._vehicles = [];
this._vehicles[0] = new Game_Vehicle("boat");
this._vehicles[1] = new Game_Vehicle("ship");
this._vehicles[2] = new Game_Vehicle("airship");
};
Game_Map.prototype.refereshVehicles = function() {
for (const vehicle of this._vehicles) {
vehicle.refresh();
}
};
Game_Map.prototype.vehicles = function() {
return this._vehicles;
};
Game_Map.prototype.vehicle = function(type) {
if (type === 0 || type === "boat") {
return this.boat();
} else if (type === 1 || type === "ship") {
return this.ship();
} else if (type === 2 || type === "airship") {
return this.airship();
} else {
return null;
}
};
Game_Map.prototype.boat = function() {
return this._vehicles[0];
};
Game_Map.prototype.ship = function() {
};
Game_Map.prototype.airship = function() {
};
Game_Map.prototype.setupEvents = function() {
this._events = [];
this._commonEvents = [];
for (const event of $dataMap.events.filter(event => !!event)) {
this._events[event.id] = new Game_Event(this._mapId, event.id);
}
for (const commonEvent of this.parallelCommonEvents()) {
this._commonEvents.push(new Game_CommonEvent(commonEvent.id));
}
this.refreshTileEvents();
};
Game_Map.prototype.events = function() {
return this._events.filter(event => !!event);
};
Game_Map.prototype.event = function(eventId) {
return this._events[eventId];
};
Game_Map.prototype.eraseEvent = function(eventId) {
this._events[eventId].erase();
};
Game_Map.prototype.autorunCommonEvents = function() {
return $dataCommonEvents.filter(
commonEvent => commonEvent && commonEvent.trigger === 1
);
};
Game_Map.prototype.parallelCommonEvents = function() {
return $dataCommonEvents.filter(
commonEvent => commonEvent && commonEvent.trigger === 2
);
};
Game_Map.prototype.setupScroll = function() {
this._scrollDirection = 2;
};
Game_Map.prototype.setupParallax = function() {
this._parallaxName = $dataMap.parallaxName || "";
this._parallaxZero = ImageManager.isZeroParallax(this._parallaxName);
this._parallaxLoopX = $dataMap.parallaxLoopX;
this._parallaxLoopY = $dataMap.parallaxLoopY;
this._parallaxSx = $dataMap.parallaxSx;
this._parallaxSy = $dataMap.parallaxSy;
};
Game_Map.prototype.setupBattleback = function() {
if ($dataMap.specifyBattleback) {
this._battleback1Name = $dataMap.battleback1Name;
this._battleback2Name = $dataMap.battleback2Name;
} else {
}
};
Game_Map.prototype.setDisplayPos = function(x, y) {
if (this.isLoopHorizontal()) {
this._displayX = x.mod(this.width());
this._parallaxX = x;
} else {
const endX = this.width() - this.screenTileX();
this._displayX = endX < 0 ? endX / 2 : x.clamp(0, endX);
this._parallaxX = this._displayX;
}
if (this.isLoopVertical()) {
this._displayY = y.mod(this.height());
this._parallaxY = y;
} else {
const endY = this.height() - this.screenTileY();
this._displayY = endY < 0 ? endY / 2 : y.clamp(0, endY);
this._parallaxY = this._displayY;
}
};
Game_Map.prototype.parallaxOx = function() {
if (this._parallaxZero) {
return this._parallaxX * this.tileWidth();
} else if (this._parallaxLoopX) {
return (this._parallaxX * this.tileWidth()) / 2;
} else {
return 0;
}
};
Game_Map.prototype.parallaxOy = function() {
if (this._parallaxZero) {
return this._parallaxY * this.tileHeight();
} else if (this._parallaxLoopY) {
return (this._parallaxY * this.tileHeight()) / 2;
} else {
return 0;
}
};
Game_Map.prototype.tileset = function() {
return $dataTilesets[this._tilesetId];
};
Game_Map.prototype.tilesetFlags = function() {
const tileset = this.tileset();
if (tileset) {
return tileset.flags;
} else {
return [];
}
};
Game_Map.prototype.displayName = function() {
return $dataMap.displayName;
};
Game_Map.prototype.width = function() {
return $dataMap.width;
};
Game_Map.prototype.height = function() {
return $dataMap.height;
};
Game_Map.prototype.data = function() {
return $dataMap.data;
};
Game_Map.prototype.isLoopHorizontal = function() {
return $dataMap.scrollType === 2 || $dataMap.scrollType === 3;
};
Game_Map.prototype.isLoopVertical = function() {
return $dataMap.scrollType === 1 || $dataMap.scrollType === 3;
};
Game_Map.prototype.isDashDisabled = function() {
return $dataMap.disableDashing;
};
Game_Map.prototype.encounterList = function() {
return $dataMap.encounterList;
};
Game_Map.prototype.encounterStep = function() {
return $dataMap.encounterStep;
};
Game_Map.prototype.isOverworld = function() {
return this.tileset() && this.tileset().mode === 0;
};
Game_Map.prototype.screenTileX = function() {
return Math.round((Graphics.width / this.tileWidth()) * 16) / 16;
};
Game_Map.prototype.screenTileY = function() {
return Math.round((Graphics.height / this.tileHeight()) * 16) / 16;
};
Game_Map.prototype.adjustX = function(x) {
if (
this.isLoopHorizontal() &&
x < this._displayX - (this.width() - this.screenTileX()) / 2
) {
return x - this._displayX + $dataMap.width;
} else {
return x - this._displayX;
}
};
Game_Map.prototype.adjustY = function(y) {
if (
this.isLoopVertical() &&
y < this._displayY - (this.height() - this.screenTileY()) / 2
) {
return y - this._displayY + $dataMap.height;
} else {
return y - this._displayY;
}
};
Game_Map.prototype.roundX = function(x) {
return this.isLoopHorizontal() ? x.mod(this.width()) : x;
};
Game_Map.prototype.roundY = function(y) {
return this.isLoopVertical() ? y.mod(this.height()) : y;
};
Game_Map.prototype.xWithDirection = function(x, d) {
return x + (d === 6 ? 1 : d === 4 ? -1 : 0);
};
Game_Map.prototype.yWithDirection = function(y, d) {
return y + (d === 2 ? 1 : d === 8 ? -1 : 0);
};
Game_Map.prototype.roundXWithDirection = function(x, d) {
return this.roundX(x + (d === 6 ? 1 : d === 4 ? -1 : 0));
};
Game_Map.prototype.roundYWithDirection = function(y, d) {
return this.roundY(y + (d === 2 ? 1 : d === 8 ? -1 : 0));
};
Game_Map.prototype.deltaX = function(x1, x2) {

let result = x1 - x2;
if (this.isLoopHorizontal() && Math.abs(result) > this.width() / 2) {
if (result < 0) {
result += this.width();
} else {
result -= this.width();
}
}
return result;
};
Game_Map.prototype.deltaY = function(y1, y2) {

let result = y1 - y2;
if (this.isLoopVertical() && Math.abs(result) > this.height() / 2) {
if (result < 0) {
result += this.height();
} else {
result -= this.height();
}
}
return result;
};
Game_Map.prototype.distance = function(x1, y1, x2, y2) {

return Math.abs(this.deltaX(x1, x2)) + Math.abs(this.deltaY(y1, y2));
};
Game_Map.prototype.canvasToMapX = function(x) {
const tileWidth = this.tileWidth();
const originX = this._displayX * tileWidth;
const mapX = Math.floor((originX + x) / tileWidth);
return this.roundX(mapX);
};
Game_Map.prototype.canvasToMapY = function(y) {
const tileHeight = this.tileHeight();
const originY = this._displayY * tileHeight;
const mapY = Math.floor((originY + y) / tileHeight);
return this.roundY(mapY);
};
Game_Map.prototype.autoplay = function() {
if ($dataMap.autoplayBgm) {
if ($gamePlayer.isInVehicle()) {
$gameSystem.saveWalkingBgm2();
} else {
AudioManager.playBgm($dataMap.bgm);
}
}
if ($dataMap.autoplayBgs) {
AudioManager.playBgs($dataMap.bgs);
}
};
Game_Map.prototype.refreshIfNeeded = function() {
if (this._needsRefresh) {
this.refresh();
}
};
Game_Map.prototype.refresh = function() {
for (const event of this.events()) {
event.refresh();
}
for (const commonEvent of this._commonEvents) {
commonEvent.refresh();
}
this.refreshTileEvents();
this._needsRefresh = false;
};
Game_Map.prototype.refreshTileEvents = function() {
this._tileEvents = this.events().filter(event => event.isTile());
};
Game_Map.prototype.eventsXy = function(x, y) {
return this.events().filter(event => event.pos(x, y));
};
Game_Map.prototype.eventsXyNt = function(x, y) {
return this.events().filter(event => event.posNt(x, y));
};
Game_Map.prototype.tileEventsXy = function(x, y) {
return this._tileEvents.filter(event => event.posNt(x, y));
};
Game_Map.prototype.eventIdXy = function(x, y) {
const list = this.eventsXy(x, y);
return list.length === 0 ? 0 : list[0].eventId();
};
Game_Map.prototype.scrollDown = function(distance) {
this._displayY += distance;
this._displayY %= $dataMap.height;
if (this._parallaxLoopY) {
this._parallaxY += distance;
}
} else if (this.height() >= this.screenTileY()) {
const lastY = this._displayY;
this._displayY = Math.min(
this._displayY + distance,
this.height() - this.screenTileY()
);
this._parallaxY += this._displayY - lastY;
}
};
Game_Map.prototype.scrollLeft = function(distance) {
this._displayX += $dataMap.width - distance;
this._displayX %= $dataMap.width;
if (this._parallaxLoopX) {
this._parallaxX -= distance;
}
} else if (this.width() >= this.screenTileX()) {
const lastX = this._displayX;
this._displayX = Math.max(this._displayX - distance, 0);
this._parallaxX += this._displayX - lastX;
}
};
Game_Map.prototype.scrollRight = function(distance) {
this._displayX += distance;
this._displayX %= $dataMap.width;
this._parallaxX += distance;
}
} else if (this.width() >= this.screenTileX()) {
this._displayX = Math.min(
this._displayX + distance,
this.width() - this.screenTileX()
);
this._parallaxX += this._displayX - lastX;
}
};
Game_Map.prototype.scrollUp = function(distance) {
this._displayY += $dataMap.height - distance;
this._displayY %= $dataMap.height;
this._parallaxY -= distance;
}
} else if (this.height() >= this.screenTileY()) {
this._displayY = Math.max(this._displayY - distance, 0);
this._parallaxY += this._displayY - lastY;
}
};
Game_Map.prototype.isValid = function(x, y) {
return x >= 0 && x < this.width() && y >= 0 && y < this.height();
};
Game_Map.prototype.checkPassage = function(x, y, bit) {

const flags = this.tilesetFlags();
const tiles = this.allTiles(x, y);
for (const tile of tiles) {
const flag = flags[tile];
if ((flag & 0x10) !== 0) {
// [*] No effect on passage
continue;
}
if ((flag & bit) === 0) {
// [o] Passable
return true;
}
if ((flag & bit) === bit) {
// [x] Impassable
return false;
}
}
return false;
};
Game_Map.prototype.tileId = function(x, y, z) {
const width = $dataMap.width;
const height = $dataMap.height;
return $dataMap.data[(z * height + y) * width + x] || 0;
};
Game_Map.prototype.layeredTiles = function(x, y) {
const tiles = [];
for (let i = 0; i < 4; i++) {
tiles.push(this.tileId(x, y, 3 - i));
}
return tiles;
};
Game_Map.prototype.allTiles = function(x, y) {
const tiles = this.tileEventsXy(x, y).map(event => event.tileId());
return tiles.concat(this.layeredTiles(x, y));
};
Game_Map.prototype.autotileType = function(x, y, z) {
const tileId = this.tileId(x, y, z);
return tileId >= 2048 ? Math.floor((tileId - 2048) / 48) : -1;
};
Game_Map.prototype.isPassable = function(x, y, d) {
return this.checkPassage(x, y, (1 << (d / 2 - 1)) & 0x0f);
};
Game_Map.prototype.isBoatPassable = function(x, y) {
return this.checkPassage(x, y, 0x0200);
};
Game_Map.prototype.isShipPassable = function(x, y) {
return this.checkPassage(x, y, 0x0400);
};
Game_Map.prototype.isAirshipLandOk = function(x, y) {
return this.checkPassage(x, y, 0x0800) && this.checkPassage(x, y, 0x0f);
};
Game_Map.prototype.checkLayeredTilesFlags = function(x, y, bit) {

return this.layeredTiles(x, y).some(tileId => (flags[tileId] & bit) !== 0);
};
Game_Map.prototype.isLadder = function(x, y) {
return this.isValid(x, y) && this.checkLayeredTilesFlags(x, y, 0x20);
};
Game_Map.prototype.isBush = function(x, y) {
};
Game_Map.prototype.isCounter = function(x, y) {
};
Game_Map.prototype.isDamageFloor = function(x, y) {
};
Game_Map.prototype.terrainTag = function(x, y) {
if (this.isValid(x, y)) {
const tiles = this.layeredTiles(x, y);
for (const tile of tiles) {
const tag = flags[tile] >> 12;
if (tag > 0) {
return tag;
}
}
}
return 0;
};
Game_Map.prototype.regionId = function(x, y) {
return this.isValid(x, y) ? this.tileId(x, y, 5) : 0;
};
Game_Map.prototype.startScroll = function(direction, distance, speed) {

this._scrollDirection = direction;
this._scrollRest = distance;
this._scrollSpeed = speed;
};
Game_Map.prototype.isScrolling = function() {
return this._scrollRest > 0;
};
Game_Map.prototype.update = function(sceneActive) {
this.refreshIfNeeded();
if (sceneActive) {
this.updateInterpreter();
}
this.updateScroll();
this.updateEvents();
this.updateVehicles();
this.updateParallax();
};
Game_Map.prototype.updateScroll = function() {
if (this.isScrolling()) {
this.doScroll(this._scrollDirection, this.scrollDistance());
if (this._displayX === lastX && this._displayY === lastY) {
} else {
this._scrollRest -= this.scrollDistance();
}
}
};
Game_Map.prototype.scrollDistance = function() {
return Math.pow(2, this._scrollSpeed) / 256;
};
Game_Map.prototype.doScroll = function(direction, distance) {

switch (direction) {
case 2:
this.scrollDown(distance);
break;
case 4:
this.scrollLeft(distance);
break;
case 6:
this.scrollRight(distance);
break;
case 8:
this.scrollUp(distance);
break;
}
};
Game_Map.prototype.updateEvents = function() {
event.update();
}
for (const commonEvent of this._commonEvents) {
commonEvent.update();
}
};
Game_Map.prototype.updateVehicles = function() {
for (const vehicle of this._vehicles) {
vehicle.update();
}
};
Game_Map.prototype.updateParallax = function() {
this._parallaxX += this._parallaxSx / this.tileWidth() / 2;
}
this._parallaxY += this._parallaxSy / this.tileHeight() / 2;
}
};
Game_Map.prototype.changeTileset = function(tilesetId) {
this._tilesetId = tilesetId;
this.refresh();
};
Game_Map.prototype.changeBattleback = function(
battleback1Name,
battleback2Name
) {
this._battleback1Name = battleback1Name;
this._battleback2Name = battleback2Name;
};
Game_Map.prototype.changeParallax = function(name, loopX, loopY, sx, sy) {

this._parallaxName = name;
this._parallaxZero = ImageManager.isZeroParallax(this._parallaxName);
if (this._parallaxLoopX && !loopX) {
}
if (this._parallaxLoopY && !loopY) {
}
this._parallaxLoopX = loopX;
this._parallaxLoopY = loopY;
this._parallaxSx = sx;
this._parallaxSy = sy;
};
Game_Map.prototype.updateInterpreter = function() {
for (;;) {
if (this._interpreter.isRunning()) {
return;
}
if (this._interpreter.eventId() > 0) {
this.unlockEvent(this._interpreter.eventId());
this._interpreter.clear();
}
if (!this.setupStartingEvent()) {
return;
}
}
};
Game_Map.prototype.unlockEvent = function(eventId) {
if (this._events[eventId]) {
this._events[eventId].unlock();
}
};
Game_Map.prototype.setupStartingEvent = function() {
this.refreshIfNeeded();
if (this._interpreter.setupReservedCommonEvent()) {
return true;
}
if (this.setupTestEvent()) {
return true;
}
if (this.setupStartingMapEvent()) {
return true;
}
if (this.setupAutorunCommonEvent()) {
return true;
}
return false;
};
Game_Map.prototype.setupTestEvent = function() {
if (window.$testEvent) {
this._interpreter.setup($testEvent, 0);
$testEvent = null;
return true;
}
return false;
};
Game_Map.prototype.setupStartingMapEvent = function() {
if (event.isStarting()) {
event.clearStartingFlag();
this._interpreter.setup(event.list(), event.eventId());
return true;
}
}
return false;
};
Game_Map.prototype.setupAutorunCommonEvent = function() {
for (const commonEvent of this.autorunCommonEvents()) {
if ($gameSwitches.value(commonEvent.switchId)) {
this._interpreter.setup(commonEvent.list);
return true;
}
}
return false;
};
Game_Map.prototype.isAnyEventStarting = function() {
return this.events().some(event => event.isStarting());
};
//-----------------------------------------------------------------------------
// Game_CommonEvent
//
// The game object class for a common event. It contains functionality for
// running parallel process events.
function Game_CommonEvent() {
}
Game_CommonEvent.prototype.initialize = function(commonEventId) {
this._commonEventId = commonEventId;
this.refresh();
};
Game_CommonEvent.prototype.event = function() {
return $dataCommonEvents[this._commonEventId];
};
Game_CommonEvent.prototype.list = function() {
return this.event().list;
};
Game_CommonEvent.prototype.refresh = function() {
if (this.isActive()) {
if (!this._interpreter) {
}
} else {
this._interpreter = null;
}
};
Game_CommonEvent.prototype.isActive = function() {
const event = this.event();
return event.trigger === 2 && $gameSwitches.value(event.switchId);
};
Game_CommonEvent.prototype.update = function() {
if (this._interpreter) {
this._interpreter.setup(this.list());
}
}
};
//-----------------------------------------------------------------------------
// Game_CharacterBase
//
// The superclass of Game_Character. It handles basic information, such as
// coordinates and images, shared by all characters.
function Game_CharacterBase() {
}
Object.defineProperties(Game_CharacterBase.prototype, {
x: {
get: function() {
return this._x;
},
configurable: true
},
y: {
get: function() {
return this._y;
},
configurable: true
}
});
Game_CharacterBase.prototype.initialize = function() {
this.initMembers();
};
Game_CharacterBase.prototype.initMembers = function() {
this._x = 0;
this._y = 0;
this._realX = 0;
this._realY = 0;
this._moveSpeed = 4;
this._moveFrequency = 6;
this._opacity = 255;
this._blendMode = 0;
this._direction = 2;
this._pattern = 1;
this._priorityType = 1;
this._tileId = 0;
this._isObjectCharacter = false;
this._walkAnime = true;
this._stepAnime = false;
this._directionFix = false;
this._through = false;
this._transparent = false;
this._bushDepth = 0;
this._animationId = 0;
this._balloonId = 0;
this._animationPlaying = false;
this._balloonPlaying = false;
this._animationCount = 0;
this._stopCount = 0;
this._jumpCount = 0;
this._jumpPeak = 0;
this._movementSuccess = true;
};
Game_CharacterBase.prototype.pos = function(x, y) {
return this._x === x && this._y === y;
};
Game_CharacterBase.prototype.posNt = function(x, y) {
// No through
return this.pos(x, y) && !this.isThrough();
};
Game_CharacterBase.prototype.moveSpeed = function() {
return this._moveSpeed;
};
Game_CharacterBase.prototype.setMoveSpeed = function(moveSpeed) {
this._moveSpeed = moveSpeed;
};
Game_CharacterBase.prototype.moveFrequency = function() {
return this._moveFrequency;
};
Game_CharacterBase.prototype.setMoveFrequency = function(moveFrequency) {
this._moveFrequency = moveFrequency;
};
Game_CharacterBase.prototype.opacity = function() {
return this._opacity;
};
Game_CharacterBase.prototype.setOpacity = function(opacity) {
this._opacity = opacity;
};
Game_CharacterBase.prototype.blendMode = function() {
return this._blendMode;
};
Game_CharacterBase.prototype.setBlendMode = function(blendMode) {
};
Game_CharacterBase.prototype.isNormalPriority = function() {
return this._priorityType === 1;
};
Game_CharacterBase.prototype.setPriorityType = function(priorityType) {
this._priorityType = priorityType;
};
Game_CharacterBase.prototype.isMoving = function() {
return this._realX !== this._x || this._realY !== this._y;
};
Game_CharacterBase.prototype.isJumping = function() {
return this._jumpCount > 0;
};
Game_CharacterBase.prototype.jumpHeight = function() {
return (
(this._jumpPeak * this._jumpPeak -
Math.pow(Math.abs(this._jumpCount - this._jumpPeak), 2)) /
2
);
};
Game_CharacterBase.prototype.isStopping = function() {
return !this.isMoving() && !this.isJumping();
};
Game_CharacterBase.prototype.checkStop = function(threshold) {
return this._stopCount > threshold;
};
Game_CharacterBase.prototype.resetStopCount = function() {
this._stopCount = 0;
};
Game_CharacterBase.prototype.realMoveSpeed = function() {
return this._moveSpeed + (this.isDashing() ? 1 : 0);
};
Game_CharacterBase.prototype.distancePerFrame = function() {
return Math.pow(2, this.realMoveSpeed()) / 256;
};
Game_CharacterBase.prototype.isDashing = function() {
return false;
};
Game_CharacterBase.prototype.isDebugThrough = function() {
return false;
};
Game_CharacterBase.prototype.straighten = function() {
if (this.hasWalkAnime() || this.hasStepAnime()) {
this._pattern = 1;
}
};
Game_CharacterBase.prototype.reverseDir = function(d) {
return 10 - d;
};
Game_CharacterBase.prototype.canPass = function(x, y, d) {
const x2 = $gameMap.roundXWithDirection(x, d);
const y2 = $gameMap.roundYWithDirection(y, d);
if (!$gameMap.isValid(x2, y2)) {
return false;
}
if (this.isThrough() || this.isDebugThrough()) {
return true;
}
if (!this.isMapPassable(x, y, d)) {
return false;
}
if (this.isCollidedWithCharacters(x2, y2)) {
return false;
}
return true;
};
Game_CharacterBase.prototype.canPassDiagonally = function(x, y, horz, vert) {

const x2 = $gameMap.roundXWithDirection(x, horz);
const y2 = $gameMap.roundYWithDirection(y, vert);
if (this.canPass(x, y, vert) && this.canPass(x, y2, horz)) {
return true;
}
if (this.canPass(x, y, horz) && this.canPass(x2, y, vert)) {
return true;
}
return false;
};
Game_CharacterBase.prototype.isMapPassable = function(x, y, d) {
const d2 = this.reverseDir(d);
return $gameMap.isPassable(x, y, d) && $gameMap.isPassable(x2, y2, d2);
};
Game_CharacterBase.prototype.isCollidedWithCharacters = function(x, y) {
return this.isCollidedWithEvents(x, y) || this.isCollidedWithVehicles(x, y);
};
Game_CharacterBase.prototype.isCollidedWithEvents = function(x, y) {
const events = $gameMap.eventsXyNt(x, y);
return events.some(event => event.isNormalPriority());
};
Game_CharacterBase.prototype.isCollidedWithVehicles = function(x, y) {
return $gameMap.boat().posNt(x, y) || $gameMap.ship().posNt(x, y);
};
Game_CharacterBase.prototype.setPosition = function(x, y) {
this._x = Math.round(x);
this._y = Math.round(y);
this._realX = x;
this._realY = y;
};
Game_CharacterBase.prototype.copyPosition = function(character) {
this._x = character._x;
this._y = character._y;
this._realX = character._realX;
this._realY = character._realY;
this._direction = character._direction;
};
Game_CharacterBase.prototype.locate = function(x, y) {
this.setPosition(x, y);
this.straighten();
this.refreshBushDepth();
};
Game_CharacterBase.prototype.direction = function() {
return this._direction;
};
Game_CharacterBase.prototype.setDirection = function(d) {
if (!this.isDirectionFixed() && d) {
this._direction = d;
}
this.resetStopCount();
};
Game_CharacterBase.prototype.isTile = function() {
return this._tileId > 0 && this._priorityType === 0;
};
Game_CharacterBase.prototype.isObjectCharacter = function() {
return this._isObjectCharacter;
};
Game_CharacterBase.prototype.shiftY = function() {
return this.isObjectCharacter() ? 0 : 6;
};
Game_CharacterBase.prototype.scrolledX = function() {
return $gameMap.adjustX(this._realX);
};
Game_CharacterBase.prototype.scrolledY = function() {
return $gameMap.adjustY(this._realY);
};
Game_CharacterBase.prototype.screenX = function() {
const tw = $gameMap.tileWidth();
return Math.floor(this.scrolledX() * tw + tw / 2);
};
Game_CharacterBase.prototype.screenY = function() {
const th = $gameMap.tileHeight();
return Math.floor(
this.scrolledY() * th + th - this.shiftY() - this.jumpHeight()
);
};
Game_CharacterBase.prototype.screenZ = function() {
return this._priorityType * 2 + 1;
};
Game_CharacterBase.prototype.isNearTheScreen = function() {
const gw = Graphics.width;
const gh = Graphics.height;
const tw = $gameMap.tileWidth();
const th = $gameMap.tileHeight();
const px = this.scrolledX() * tw + tw / 2 - gw / 2;
const py = this.scrolledY() * th + th / 2 - gh / 2;
return px >= -gw && px <= gw && py >= -gh && py <= gh;
};
Game_CharacterBase.prototype.update = function() {
if (this.isStopping()) {
this.updateStop();
}
if (this.isJumping()) {
this.updateJump();
} else if (this.isMoving()) {
this.updateMove();
}
this.updateAnimation();
};
Game_CharacterBase.prototype.updateStop = function() {
this._stopCount++;
};
Game_CharacterBase.prototype.updateJump = function() {
this._jumpCount--;
this._realX =
(this._realX * this._jumpCount + this._x) / (this._jumpCount + 1.0);
this._realY =
(this._realY * this._jumpCount + this._y) / (this._jumpCount + 1.0);
if (this._jumpCount === 0) {
this._realX = this._x = $gameMap.roundX(this._x);
this._realY = this._y = $gameMap.roundY(this._y);
}
};
Game_CharacterBase.prototype.updateMove = function() {
if (this._x < this._realX) {
this._realX = Math.max(this._realX - this.distancePerFrame(), this._x);
}
if (this._x > this._realX) {
this._realX = Math.min(this._realX + this.distancePerFrame(), this._x);
}
if (this._y < this._realY) {
this._realY = Math.max(this._realY - this.distancePerFrame(), this._y);
}
if (this._y > this._realY) {
this._realY = Math.min(this._realY + this.distancePerFrame(), this._y);
}
if (!this.isMoving()) {
}
};
Game_CharacterBase.prototype.updateAnimation = function() {
this.updateAnimationCount();
if (this._animationCount >= this.animationWait()) {
this.updatePattern();
}
};
Game_CharacterBase.prototype.animationWait = function() {
return (9 - this.realMoveSpeed()) * 3;
};
Game_CharacterBase.prototype.updateAnimationCount = function() {
if (this.isMoving() && this.hasWalkAnime()) {
this._animationCount += 1.5;
} else if (this.hasStepAnime() || !this.isOriginalPattern()) {
this._animationCount++;
}
};
Game_CharacterBase.prototype.updatePattern = function() {
if (!this.hasStepAnime() && this._stopCount > 0) {
this.resetPattern();
} else {
this._pattern = (this._pattern + 1) % this.maxPattern();
}
};
Game_CharacterBase.prototype.maxPattern = function() {
return 4;
};
Game_CharacterBase.prototype.pattern = function() {
return this._pattern < 3 ? this._pattern : 1;
};
Game_CharacterBase.prototype.setPattern = function(pattern) {
this._pattern = pattern;
};
Game_CharacterBase.prototype.isOriginalPattern = function() {
return this.pattern() === 1;
};
Game_CharacterBase.prototype.resetPattern = function() {
this.setPattern(1);
};
Game_CharacterBase.prototype.refreshBushDepth = function() {
if (
this.isNormalPriority() &&
!this.isObjectCharacter() &&
this.isOnBush() &&
!this.isJumping()
) {
this._bushDepth = $gameMap.bushDepth();
}
} else {
this._bushDepth = 0;
}
};
Game_CharacterBase.prototype.isOnLadder = function() {
return $gameMap.isLadder(this._x, this._y);
};
Game_CharacterBase.prototype.isOnBush = function() {
return $gameMap.isBush(this._x, this._y);
};
Game_CharacterBase.prototype.terrainTag = function() {
return $gameMap.terrainTag(this._x, this._y);
};
Game_CharacterBase.prototype.regionId = function() {
return $gameMap.regionId(this._x, this._y);
};
Game_CharacterBase.prototype.increaseSteps = function() {
if (this.isOnLadder()) {
this.setDirection(8);
}
};
Game_CharacterBase.prototype.tileId = function() {
return this._tileId;
};
Game_CharacterBase.prototype.characterName = function() {
return this._characterName;
};
Game_CharacterBase.prototype.characterIndex = function() {
return this._characterIndex;
};
Game_CharacterBase.prototype.setImage = function(
characterName,
characterIndex
) {
this._tileId = 0;
this._characterName = characterName;
this._characterIndex = characterIndex;
this._isObjectCharacter = ImageManager.isObjectCharacter(characterName);
};
Game_CharacterBase.prototype.setTileImage = function(tileId) {
this._tileId = tileId;
this._isObjectCharacter = true;
};
Game_CharacterBase.prototype.checkEventTriggerTouchFront = function(d) {
const x2 = $gameMap.roundXWithDirection(this._x, d);
const y2 = $gameMap.roundYWithDirection(this._y, d);
this.checkEventTriggerTouch(x2, y2);
};
Game_CharacterBase.prototype.checkEventTriggerTouch = function(/*x, y*/) {

return false;
};
Game_CharacterBase.prototype.isMovementSucceeded = function(/*x, y*/) {

return this._movementSuccess;
};
Game_CharacterBase.prototype.setMovementSuccess = function(success) {
this._movementSuccess = success;
};
Game_CharacterBase.prototype.moveStraight = function(d) {
this.setMovementSuccess(this.canPass(this._x, this._y, d));
if (this.isMovementSucceeded()) {
this.setDirection(d);
this._x = $gameMap.roundXWithDirection(this._x, d);
this._y = $gameMap.roundYWithDirection(this._y, d);
this._realX = $gameMap.xWithDirection(this._x, this.reverseDir(d));
this._realY = $gameMap.yWithDirection(this._y, this.reverseDir(d));
this.increaseSteps();
} else {
this.setDirection(d);
this.checkEventTriggerTouchFront(d);
}
};
Game_CharacterBase.prototype.moveDiagonally = function(horz, vert) {

this.setMovementSuccess(
this.canPassDiagonally(this._x, this._y, horz, vert)
);
if (this.isMovementSucceeded()) {
this._x = $gameMap.roundXWithDirection(this._x, horz);
this._y = $gameMap.roundYWithDirection(this._y, vert);
this._realX = $gameMap.xWithDirection(this._x, this.reverseDir(horz));
this._realY = $gameMap.yWithDirection(this._y, this.reverseDir(vert));
this.increaseSteps();
}
if (this._direction === this.reverseDir(horz)) {
this.setDirection(horz);
}
if (this._direction === this.reverseDir(vert)) {
this.setDirection(vert);
}
};
Game_CharacterBase.prototype.jump = function(xPlus, yPlus) {

if (Math.abs(xPlus) > Math.abs(yPlus)) {
if (xPlus !== 0) {
this.setDirection(xPlus < 0 ? 4 : 6);
}
} else {
if (yPlus !== 0) {
this.setDirection(yPlus < 0 ? 8 : 2);
}
}
this._x += xPlus;
this._y += yPlus;
const distance = Math.round(Math.sqrt(xPlus * xPlus + yPlus * yPlus));
this._jumpPeak = 10 + distance - this._moveSpeed;
this._jumpCount = this._jumpPeak * 2;
this.straighten();
};
Game_CharacterBase.prototype.hasWalkAnime = function() {
return this._walkAnime;
};
Game_CharacterBase.prototype.setWalkAnime = function(walkAnime) {
this._walkAnime = walkAnime;
};
Game_CharacterBase.prototype.hasStepAnime = function() {
return this._stepAnime;
};
Game_CharacterBase.prototype.setStepAnime = function(stepAnime) {
this._stepAnime = stepAnime;
};
Game_CharacterBase.prototype.isDirectionFixed = function() {
return this._directionFix;
};
Game_CharacterBase.prototype.setDirectionFix = function(directionFix) {
this._directionFix = directionFix;
};
Game_CharacterBase.prototype.isThrough = function() {
return this._through;
};
Game_CharacterBase.prototype.setThrough = function(through) {
this._through = through;
};
Game_CharacterBase.prototype.isTransparent = function() {
return this._transparent;
};
Game_CharacterBase.prototype.bushDepth = function() {
return this._bushDepth;
};
Game_CharacterBase.prototype.setTransparent = function(transparent) {
this._transparent = transparent;
};
Game_CharacterBase.prototype.startAnimation = function() {
this._animationPlaying = true;
};
Game_CharacterBase.prototype.startBalloon = function() {
this._balloonPlaying = true;
};
Game_CharacterBase.prototype.isAnimationPlaying = function() {
return this._animationPlaying;
};
Game_CharacterBase.prototype.isBalloonPlaying = function() {
return this._balloonPlaying;
};
Game_CharacterBase.prototype.endAnimation = function() {
this._animationPlaying = false;
};
Game_CharacterBase.prototype.endBalloon = function() {
this._balloonPlaying = false;
};
//-----------------------------------------------------------------------------
// Game_Character
//
// The superclass of Game_Player, Game_Follower, GameVehicle, and Game_Event.
function Game_Character() {
}
Game_Character.prototype = Object.create(Game_CharacterBase.prototype);
Game_Character.prototype.constructor = Game_Character;
Game_Character.ROUTE_END = 0;
Game_Character.ROUTE_MOVE_DOWN = 1;
Game_Character.ROUTE_MOVE_LEFT = 2;
Game_Character.ROUTE_MOVE_RIGHT = 3;
Game_Character.ROUTE_MOVE_UP = 4;
Game_Character.ROUTE_MOVE_LOWER_L = 5;
Game_Character.ROUTE_MOVE_LOWER_R = 6;
Game_Character.ROUTE_MOVE_UPPER_L = 7;
Game_Character.ROUTE_MOVE_UPPER_R = 8;
Game_Character.ROUTE_MOVE_RANDOM = 9;
Game_Character.ROUTE_MOVE_TOWARD = 10;
Game_Character.ROUTE_MOVE_AWAY = 11;
Game_Character.ROUTE_MOVE_FORWARD = 12;
Game_Character.ROUTE_MOVE_BACKWARD = 13;
Game_Character.ROUTE_JUMP = 14;
Game_Character.ROUTE_WAIT = 15;
Game_Character.ROUTE_TURN_DOWN = 16;
Game_Character.ROUTE_TURN_LEFT = 17;
Game_Character.ROUTE_TURN_RIGHT = 18;
Game_Character.ROUTE_TURN_UP = 19;
Game_Character.ROUTE_TURN_90D_R = 20;
Game_Character.ROUTE_TURN_90D_L = 21;
Game_Character.ROUTE_TURN_180D = 22;
Game_Character.ROUTE_TURN_90D_R_L = 23;
Game_Character.ROUTE_TURN_RANDOM = 24;
Game_Character.ROUTE_TURN_TOWARD = 25;
Game_Character.ROUTE_TURN_AWAY = 26;
Game_Character.ROUTE_SWITCH_ON = 27;
Game_Character.ROUTE_SWITCH_OFF = 28;
Game_Character.ROUTE_CHANGE_SPEED = 29;
Game_Character.ROUTE_CHANGE_FREQ = 30;
Game_Character.ROUTE_WALK_ANIME_ON = 31;
Game_Character.ROUTE_WALK_ANIME_OFF = 32;
Game_Character.ROUTE_STEP_ANIME_ON = 33;
Game_Character.ROUTE_STEP_ANIME_OFF = 34;
Game_Character.ROUTE_DIR_FIX_ON = 35;
Game_Character.ROUTE_DIR_FIX_OFF = 36;
Game_Character.ROUTE_THROUGH_ON = 37;
Game_Character.ROUTE_THROUGH_OFF = 38;
Game_Character.ROUTE_TRANSPARENT_ON = 39;
Game_Character.ROUTE_TRANSPARENT_OFF = 40;
Game_Character.ROUTE_CHANGE_IMAGE = 41;
Game_Character.ROUTE_CHANGE_OPACITY = 42;
Game_Character.ROUTE_CHANGE_BLEND_MODE = 43;
Game_Character.ROUTE_PLAY_SE = 44;
Game_Character.ROUTE_SCRIPT = 45;
Game_Character.prototype.initialize = function() {
Game_CharacterBase.prototype.initialize.call(this);
};
Game_Character.prototype.initMembers = function() {
Game_CharacterBase.prototype.initMembers.call(this);
this._moveRouteForcing = false;
this._moveRoute = null;
this._moveRouteIndex = 0;
this._originalMoveRoute = null;
this._originalMoveRouteIndex = 0;
this._waitCount = 0;
};
Game_Character.prototype.memorizeMoveRoute = function() {
this._originalMoveRoute = this._moveRoute;
this._originalMoveRouteIndex = this._moveRouteIndex;
};
Game_Character.prototype.restoreMoveRoute = function() {
this._moveRoute = this._originalMoveRoute;
this._moveRouteIndex = this._originalMoveRouteIndex;
this._originalMoveRoute = null;
};
Game_Character.prototype.isMoveRouteForcing = function() {
return this._moveRouteForcing;
};
Game_Character.prototype.setMoveRoute = function(moveRoute) {
if (this._moveRouteForcing) {
this._originalMoveRoute = moveRoute;
this._originalMoveRouteIndex = 0;
} else {
this._moveRoute = moveRoute;
}
};
Game_Character.prototype.forceMoveRoute = function(moveRoute) {
if (!this._originalMoveRoute) {
this.memorizeMoveRoute();
}
this._moveRoute = moveRoute;
this._moveRouteForcing = true;
};
Game_Character.prototype.updateStop = function() {
Game_CharacterBase.prototype.updateStop.call(this);
if (this._moveRouteForcing) {
this.updateRoutineMove();
}
};
Game_Character.prototype.updateRoutineMove = function() {
if (this._waitCount > 0) {
this._waitCount--;
} else {
this.setMovementSuccess(true);
const command = this._moveRoute.list[this._moveRouteIndex];
if (command) {
this.processMoveCommand(command);
this.advanceMoveRouteIndex();
}
}
};
Game_Character.prototype.processMoveCommand = function(command) {
const gc = Game_Character;
const params = command.parameters;
switch (command.code) {
case gc.ROUTE_END:
this.processRouteEnd();
break;
case gc.ROUTE_MOVE_DOWN:
this.moveStraight(2);
break;
case gc.ROUTE_MOVE_LEFT:
break;
case gc.ROUTE_MOVE_RIGHT:
break;
case gc.ROUTE_MOVE_UP:
break;
case gc.ROUTE_MOVE_LOWER_L:
this.moveDiagonally(4, 2);
break;
case gc.ROUTE_MOVE_LOWER_R:
break;
case gc.ROUTE_MOVE_UPPER_L:
break;
case gc.ROUTE_MOVE_UPPER_R:
break;
case gc.ROUTE_MOVE_RANDOM:
this.moveRandom();
break;
case gc.ROUTE_MOVE_TOWARD:
this.moveTowardPlayer();
break;
case gc.ROUTE_MOVE_AWAY:
this.moveAwayFromPlayer();
break;
case gc.ROUTE_MOVE_FORWARD:
this.moveForward();
break;
case gc.ROUTE_MOVE_BACKWARD:
this.moveBackward();
break;
case gc.ROUTE_JUMP:
this.jump(params[0], params[1]);
break;
case gc.ROUTE_WAIT:
this._waitCount = params[0] - 1;
break;
case gc.ROUTE_TURN_DOWN:
break;
case gc.ROUTE_TURN_LEFT:
break;
case gc.ROUTE_TURN_RIGHT:
break;
case gc.ROUTE_TURN_UP:
break;
case gc.ROUTE_TURN_90D_R:
this.turnRight90();
break;
case gc.ROUTE_TURN_90D_L:
this.turnLeft90();
break;
case gc.ROUTE_TURN_180D:
this.turn180();
break;
case gc.ROUTE_TURN_90D_R_L:
this.turnRightOrLeft90();
break;
case gc.ROUTE_TURN_RANDOM:
this.turnRandom();
break;
case gc.ROUTE_TURN_TOWARD:
this.turnTowardPlayer();
break;
case gc.ROUTE_TURN_AWAY:
this.turnAwayFromPlayer();
break;
case gc.ROUTE_SWITCH_ON:
$gameSwitches.setValue(params[0], true);
break;
case gc.ROUTE_SWITCH_OFF:
$gameSwitches.setValue(params[0], false);
break;
case gc.ROUTE_CHANGE_SPEED:
this.setMoveSpeed(params[0]);
break;
case gc.ROUTE_CHANGE_FREQ:
this.setMoveFrequency(params[0]);
break;
case gc.ROUTE_WALK_ANIME_ON:
this.setWalkAnime(true);
break;
case gc.ROUTE_WALK_ANIME_OFF:
this.setWalkAnime(false);
break;
case gc.ROUTE_STEP_ANIME_ON:
this.setStepAnime(true);
break;
case gc.ROUTE_STEP_ANIME_OFF:
this.setStepAnime(false);
break;
case gc.ROUTE_DIR_FIX_ON:
this.setDirectionFix(true);
break;
case gc.ROUTE_DIR_FIX_OFF:
this.setDirectionFix(false);
break;
case gc.ROUTE_THROUGH_ON:
this.setThrough(true);
break;
case gc.ROUTE_THROUGH_OFF:
this.setThrough(false);
break;
case gc.ROUTE_TRANSPARENT_ON:
this.setTransparent(true);
break;
case gc.ROUTE_TRANSPARENT_OFF:
this.setTransparent(false);
break;
case gc.ROUTE_CHANGE_IMAGE:
this.setImage(params[0], params[1]);
break;
case gc.ROUTE_CHANGE_OPACITY:
this.setOpacity(params[0]);
break;
case gc.ROUTE_CHANGE_BLEND_MODE:
this.setBlendMode(params[0]);
break;
case gc.ROUTE_PLAY_SE:
AudioManager.playSe(params[0]);
break;
case gc.ROUTE_SCRIPT:
eval(params[0]);
break;
}
};
Game_Character.prototype.deltaXFrom = function(x) {
return $gameMap.deltaX(this.x, x);
};
Game_Character.prototype.deltaYFrom = function(y) {
return $gameMap.deltaY(this.y, y);
};
Game_Character.prototype.moveRandom = function() {
const d = 2 + Math.randomInt(4) * 2;
if (this.canPass(this.x, this.y, d)) {
this.moveStraight(d);
}
};
Game_Character.prototype.moveTowardCharacter = function(character) {
const sx = this.deltaXFrom(character.x);
const sy = this.deltaYFrom(character.y);
if (Math.abs(sx) > Math.abs(sy)) {
this.moveStraight(sx > 0 ? 4 : 6);
if (!this.isMovementSucceeded() && sy !== 0) {
this.moveStraight(sy > 0 ? 8 : 2);
}
} else if (sy !== 0) {
if (!this.isMovementSucceeded() && sx !== 0) {
}
}
};
Game_Character.prototype.moveAwayFromCharacter = function(character) {
if (!this.isMovementSucceeded() && sy !== 0) {
}
} else if (sy !== 0) {
if (!this.isMovementSucceeded() && sx !== 0) {
}
}
};
Game_Character.prototype.turnTowardCharacter = function(character) {
this.setDirection(sx > 0 ? 4 : 6);
} else if (sy !== 0) {
this.setDirection(sy > 0 ? 8 : 2);
}
};
Game_Character.prototype.turnAwayFromCharacter = function(character) {
this.setDirection(sx > 0 ? 6 : 4);
} else if (sy !== 0) {
this.setDirection(sy > 0 ? 2 : 8);
}
};
Game_Character.prototype.turnTowardPlayer = function() {
this.turnTowardCharacter($gamePlayer);
};
Game_Character.prototype.turnAwayFromPlayer = function() {
this.turnAwayFromCharacter($gamePlayer);
};
Game_Character.prototype.moveTowardPlayer = function() {
this.moveTowardCharacter($gamePlayer);
};
Game_Character.prototype.moveAwayFromPlayer = function() {
this.moveAwayFromCharacter($gamePlayer);
};
Game_Character.prototype.moveForward = function() {
this.moveStraight(this.direction());
};
Game_Character.prototype.moveBackward = function() {
const lastDirectionFix = this.isDirectionFixed();
this.setDirectionFix(true);
this.moveStraight(this.reverseDir(this.direction()));
this.setDirectionFix(lastDirectionFix);
};
Game_Character.prototype.processRouteEnd = function() {
if (this._moveRoute.repeat) {
this._moveRouteIndex = -1;
} else if (this._moveRouteForcing) {
this._moveRouteForcing = false;
this.restoreMoveRoute();
this.setMovementSuccess(false);
}
};
Game_Character.prototype.advanceMoveRouteIndex = function() {
const moveRoute = this._moveRoute;
if (moveRoute && (this.isMovementSucceeded() || moveRoute.skippable)) {
let numCommands = moveRoute.list.length - 1;
this._moveRouteIndex++;
if (moveRoute.repeat && this._moveRouteIndex >= numCommands) {
}
}
};
Game_Character.prototype.turnRight90 = function() {
switch (this.direction()) {
case 2:
break;
case 4:
break;
case 6:
break;
case 8:
break;
}
};
Game_Character.prototype.turnLeft90 = function() {
switch (this.direction()) {
case 2:
break;
case 4:
break;
case 6:
break;
case 8:
break;
}
};
Game_Character.prototype.turn180 = function() {
this.setDirection(this.reverseDir(this.direction()));
};
Game_Character.prototype.turnRightOrLeft90 = function() {
switch (Math.randomInt(2)) {
case 0:
this.turnRight90();
break;
case 1:
this.turnLeft90();
break;
}
};
Game_Character.prototype.turnRandom = function() {
this.setDirection(2 + Math.randomInt(4) * 2);
};
Game_Character.prototype.swap = function(character) {
const newX = character.x;
const newY = character.y;
character.locate(this.x, this.y);
this.locate(newX, newY);
};
Game_Character.prototype.findDirectionTo = function(goalX, goalY) {

const searchLimit = this.searchLimit();
const mapWidth = $gameMap.width();
const nodeList = [];
const openList = [];
const closedList = [];
const start = {};
let best = start;
if (this.x === goalX && this.y === goalY) {

return 0;
}
start.parent = null;
start.x = this.x;
start.y = this.y;
start.g = 0;
start.f = $gameMap.distance(start.x, start.y, goalX, goalY);
nodeList.push(start);
openList.push(start.y * mapWidth + start.x);
while (nodeList.length > 0) {

let bestIndex = 0;
for (let i = 0; i < nodeList.length; i++) {
if (nodeList[i].f < nodeList[bestIndex].f) {
bestIndex = i;
}
}
const current = nodeList[bestIndex];

const x1 = current.x;
const y1 = current.y;
const pos1 = y1 * mapWidth + x1;
const g1 = current.g;
nodeList.splice(bestIndex, 1);
openList.splice(openList.indexOf(pos1), 1);
closedList.push(pos1);
if (current.x === goalX && current.y === goalY) {

best = current;
break;
}
if (g1 >= searchLimit) {

continue;
}
for (let j = 0; j < 4; j++) {

const direction = 2 + j * 2;
const x2 = $gameMap.roundXWithDirection(x1, direction);
const y2 = $gameMap.roundYWithDirection(y1, direction);
const pos2 = y2 * mapWidth + x2;
if (closedList.includes(pos2)) {
continue;
}
if (!this.canPass(x1, y1, direction)) {
continue;
}
const g2 = g1 + 1;
const index2 = openList.indexOf(pos2);
if (index2 < 0 || g2 < nodeList[index2].g) {

let neighbor = {};
if (index2 >= 0) {
neighbor = nodeList[index2];
} else {
nodeList.push(neighbor);
openList.push(pos2);
}
neighbor.parent = current;
neighbor.x = x2;
neighbor.y = y2;
neighbor.g = g2;
neighbor.f = g2 + $gameMap.distance(x2, y2, goalX, goalY);
if (!best || neighbor.f - neighbor.g < best.f - best.g) {
best = neighbor;
}
}
}
}
let node = best;

while (node.parent && node.parent !== start) {
node = node.parent;
}
const deltaX1 = $gameMap.deltaX(node.x, start.x);

const deltaY1 = $gameMap.deltaY(node.y, start.y);
if (deltaY1 > 0) {
return 2;
} else if (deltaX1 < 0) {
return 4;
} else if (deltaX1 > 0) {
return 6;
} else if (deltaY1 < 0) {
return 8;
}
const deltaX2 = this.deltaXFrom(goalX);

const deltaY2 = this.deltaYFrom(goalY);
if (Math.abs(deltaX2) > Math.abs(deltaY2)) {
return deltaX2 > 0 ? 4 : 6;
} else if (deltaY2 !== 0) {
return deltaY2 > 0 ? 8 : 2;
}
return 0;
};
Game_Character.prototype.searchLimit = function() {
return 12;
};
//-----------------------------------------------------------------------------
// Game_Player
//
// The game object class for the player. It contains event starting
// determinants and map scrolling functions.
function Game_Player() {
}
Game_Player.prototype = Object.create(Game_Character.prototype);
Game_Player.prototype.constructor = Game_Player;
Game_Player.prototype.initialize = function() {
Game_Character.prototype.initialize.call(this);
this.setTransparent($dataSystem.optTransparent);
};
Game_Player.prototype.initMembers = function() {
Game_Character.prototype.initMembers.call(this);
this._vehicleType = "walk";
this._vehicleGettingOn = false;
this._vehicleGettingOff = false;
this._dashing = false;
this._needsMapReload = false;
this._transferring = false;
this._newMapId = 0;
this._newX = 0;
this._newY = 0;
this._newDirection = 0;
this._fadeType = 0;
this._followers = new Game_Followers();
this._encounterCount = 0;
};
Game_Player.prototype.clearTransferInfo = function() {
this._transferring = false;
this._newMapId = 0;
this._newX = 0;
this._newY = 0;
this._newDirection = 0;
};
Game_Player.prototype.followers = function() {
return this._followers;
};
Game_Player.prototype.refresh = function() {
const actor = $gameParty.leader();
const characterName = actor ? actor.characterName() : "";
const characterIndex = actor ? actor.characterIndex() : 0;
this.setImage(characterName, characterIndex);
this._followers.refresh();
};
Game_Player.prototype.isStopping = function() {
if (this._vehicleGettingOn || this._vehicleGettingOff) {
return false;
}
return Game_Character.prototype.isStopping.call(this);
};
Game_Player.prototype.reserveTransfer = function(mapId, x, y, d, fadeType) {

this._transferring = true;
this._newMapId = mapId;
this._newX = x;
this._newY = y;
this._newDirection = d;
this._fadeType = fadeType;
};
Game_Player.prototype.setupForNewGame = function() {
const mapId = $dataSystem.startMapId;
const x = $dataSystem.startX;
const y = $dataSystem.startY;
this.reserveTransfer(mapId, x, y, 2, 0);
};
Game_Player.prototype.requestMapReload = function() {
this._needsMapReload = true;
};
Game_Player.prototype.isTransferring = function() {
return this._transferring;
};
Game_Player.prototype.newMapId = function() {
return this._newMapId;
};
Game_Player.prototype.fadeType = function() {
return this._fadeType;
};
Game_Player.prototype.performTransfer = function() {
if (this.isTransferring()) {
this.setDirection(this._newDirection);
if (this._newMapId !== $gameMap.mapId() || this._needsMapReload) {
$gameMap.setup(this._newMapId);
this._needsMapReload = false;
}
this.locate(this._newX, this._newY);
this.refresh();
this.clearTransferInfo();
}
};
Game_Player.prototype.isMapPassable = function(x, y, d) {
const vehicle = this.vehicle();
if (vehicle) {
return vehicle.isMapPassable(x, y, d);
} else {
return Game_Character.prototype.isMapPassable.call(this, x, y, d);
}
};
Game_Player.prototype.vehicle = function() {
return $gameMap.vehicle(this._vehicleType);
};
Game_Player.prototype.isInBoat = function() {
return this._vehicleType === "boat";
};
Game_Player.prototype.isInShip = function() {
return this._vehicleType === "ship";
};
Game_Player.prototype.isInAirship = function() {
return this._vehicleType === "airship";
};
Game_Player.prototype.isInVehicle = function() {
return this.isInBoat() || this.isInShip() || this.isInAirship();
};
Game_Player.prototype.isNormal = function() {
return this._vehicleType === "walk" && !this.isMoveRouteForcing();
};
Game_Player.prototype.isDashing = function() {
return this._dashing;
};
Game_Player.prototype.isDebugThrough = function() {
return Input.isPressed("control") && $gameTemp.isPlaytest();
};
Game_Player.prototype.isCollided = function(x, y) {
if (this.isThrough()) {
return false;
} else {
return this.pos(x, y) || this._followers.isSomeoneCollided(x, y);
}
};
Game_Player.prototype.centerX = function() {
return ($gameMap.screenTileX() - 1) / 2;
};
Game_Player.prototype.centerY = function() {
return ($gameMap.screenTileY() - 1) / 2;
};
Game_Player.prototype.center = function(x, y) {
return $gameMap.setDisplayPos(x - this.centerX(), y - this.centerY());
};
Game_Player.prototype.locate = function(x, y) {
Game_Character.prototype.locate.call(this, x, y);
this.center(x, y);
this.makeEncounterCount();
if (this.isInVehicle()) {
this.vehicle().refresh();
}
this._followers.synchronize(x, y, this.direction());
};
Game_Player.prototype.increaseSteps = function() {
Game_Character.prototype.increaseSteps.call(this);
if (this.isNormal()) {
$gameParty.increaseSteps();
}
};
Game_Player.prototype.makeEncounterCount = function() {
const n = $gameMap.encounterStep();
this._encounterCount = Math.randomInt(n) + Math.randomInt(n) + 1;
};
Game_Player.prototype.makeEncounterTroopId = function() {
const encounterList = [];
let weightSum = 0;
for (const encounter of $gameMap.encounterList()) {
if (this.meetsEncounterConditions(encounter)) {
encounterList.push(encounter);
weightSum += encounter.weight;
}
}
if (weightSum > 0) {
let value = Math.randomInt(weightSum);
for (const encounter of encounterList) {
value -= encounter.weight;
if (value < 0) {
return encounter.troopId;
}
}
}
return 0;
};
Game_Player.prototype.meetsEncounterConditions = function(encounter) {
return (
encounter.regionSet.length === 0 ||
encounter.regionSet.includes(this.regionId())
);
};
Game_Player.prototype.executeEncounter = function() {
if (!$gameMap.isEventRunning() && this._encounterCount <= 0) {
const troopId = this.makeEncounterTroopId();
if ($dataTroops[troopId]) {
BattleManager.setup(troopId, true, false);
BattleManager.onEncounter();
return true;
} else {
return false;
}
} else {
return false;
}
};
Game_Player.prototype.startMapEvent = function(x, y, triggers, normal) {

if (!$gameMap.isEventRunning()) {
for (const event of $gameMap.eventsXy(x, y)) {
if (
event.isTriggerIn(triggers) &&
event.isNormalPriority() === normal
) {
event.start();
}
}
}
};
Game_Player.prototype.moveByInput = function() {
if (!this.isMoving() && this.canMove()) {
let direction = this.getInputDirection();
if (direction > 0) {
$gameTemp.clearDestination();
} else if ($gameTemp.isDestinationValid()) {
const x = $gameTemp.destinationX();
const y = $gameTemp.destinationY();
direction = this.findDirectionTo(x, y);
}
if (direction > 0) {
this.executeMove(direction);
}
}
};
Game_Player.prototype.canMove = function() {
if ($gameMap.isEventRunning() || $gameMessage.isBusy()) {
return false;
}
if (this.isMoveRouteForcing() || this.areFollowersGathering()) {
return false;
}
if (this._vehicleGettingOn || this._vehicleGettingOff) {
return false;
}
if (this.isInVehicle() && !this.vehicle().canMove()) {
return false;
}
return true;
};
Game_Player.prototype.getInputDirection = function() {
return Input.dir4;
};
Game_Player.prototype.executeMove = function(direction) {
this.moveStraight(direction);
};
Game_Player.prototype.update = function(sceneActive) {
const lastScrolledX = this.scrolledX();
const lastScrolledY = this.scrolledY();
const wasMoving = this.isMoving();
this.updateDashing();
if (sceneActive) {
this.moveByInput();
}
Game_Character.prototype.update.call(this);
this.updateScroll(lastScrolledX, lastScrolledY);
this.updateVehicle();
this.updateNonmoving(wasMoving, sceneActive);
}
this._followers.update();
};
Game_Player.prototype.updateDashing = function() {
if (this.isMoving()) {
return;
}
if (this.canMove() && !this.isInVehicle() && !$gameMap.isDashDisabled()) {
this._dashing =
this.isDashButtonPressed() || $gameTemp.isDestinationValid();
} else {
this._dashing = false;
}
};
Game_Player.prototype.isDashButtonPressed = function() {
const shift = Input.isPressed("shift");
if (ConfigManager.alwaysDash) {
return !shift;
} else {
return shift;
}
};
Game_Player.prototype.updateScroll = function(lastScrolledX, lastScrolledY) {

const x1 = lastScrolledX;
const y1 = lastScrolledY;
const x2 = this.scrolledX();
const y2 = this.scrolledY();
if (y2 > y1 && y2 > this.centerY()) {
$gameMap.scrollDown(y2 - y1);
}
if (x2 < x1 && x2 < this.centerX()) {
$gameMap.scrollLeft(x1 - x2);
}
if (x2 > x1 && x2 > this.centerX()) {
$gameMap.scrollRight(x2 - x1);
}
if (y2 < y1 && y2 < this.centerY()) {
$gameMap.scrollUp(y1 - y2);
}
};
Game_Player.prototype.updateVehicle = function() {
if (this.isInVehicle() && !this.areFollowersGathering()) {
if (this._vehicleGettingOn) {
this.updateVehicleGetOn();
} else if (this._vehicleGettingOff) {
this.updateVehicleGetOff();
} else {
this.vehicle().syncWithPlayer();
}
}
};
Game_Player.prototype.updateVehicleGetOn = function() {
if (!this.areFollowersGathering() && !this.isMoving()) {
this.setDirection(this.vehicle().direction());
this.setMoveSpeed(this.vehicle().moveSpeed());
this._vehicleGettingOn = false;
this.setTransparent(true);
if (this.isInAirship()) {
}
this.vehicle().getOn();
}
};
Game_Player.prototype.updateVehicleGetOff = function() {
if (!this.areFollowersGathering() && this.vehicle().isLowest()) {
this._vehicleGettingOff = false;
this._vehicleType = "walk";
}
};
Game_Player.prototype.updateNonmoving = function(wasMoving, sceneActive) {

if (wasMoving) {
$gameParty.onPlayerWalk();
this.checkEventTriggerHere([1, 2]);
if ($gameMap.setupStartingEvent()) {
return;
}
}
if (sceneActive && this.triggerAction()) {
return;
}
if (wasMoving) {
this.updateEncounterCount();
} else {
$gameTemp.clearDestination();
}
}
};
Game_Player.prototype.triggerAction = function() {
if (this.triggerButtonAction()) {
return true;
}
if (this.triggerTouchAction()) {
return true;
}
}
return false;
};
Game_Player.prototype.triggerButtonAction = function() {
if (Input.isTriggered("ok")) {
if (this.getOnOffVehicle()) {
return true;
}
this.checkEventTriggerHere([0]);
return true;
}
this.checkEventTriggerThere([0, 1, 2]);
return true;
}
}
return false;
};
Game_Player.prototype.triggerTouchAction = function() {
if ($gameTemp.isDestinationValid()) {
const direction = this.direction();
const x1 = this.x;
const y1 = this.y;
const destX = $gameTemp.destinationX();
const destY = $gameTemp.destinationY();
if (destX === x1 && destY === y1) {
return this.triggerTouchActionD1(x1, y1);
} else if (destX === x2 && destY === y2) {
} else if (destX === x3 && destY === y3) {
}
}
return false;
};
Game_Player.prototype.triggerTouchActionD1 = function(x1, y1) {

if ($gameMap.airship().pos(x1, y1)) {
if (TouchInput.isTriggered() && this.getOnOffVehicle()) {
return true;
}
}
this.checkEventTriggerHere([0]);
return $gameMap.setupStartingEvent();
};

if ($gameMap.boat().pos(x2, y2) || $gameMap.ship().pos(x2, y2)) {
if (TouchInput.isTriggered() && this.getOnVehicle()) {
return true;
}
}
if (this.isInBoat() || this.isInShip()) {
if (TouchInput.isTriggered() && this.getOffVehicle()) {
return true;
}
}
};

if ($gameMap.isCounter(x2, y2)) {
}
};
Game_Player.prototype.updateEncounterCount = function() {
if (this.canEncounter()) {
this._encounterCount -= this.encounterProgressValue();
}
};
Game_Player.prototype.canEncounter = function() {
return (
!$gameParty.hasEncounterNone() &&
$gameSystem.isEncounterEnabled() &&
!this.isInAirship() &&
!this.isMoveRouteForcing() &&
!this.isDebugThrough()
);
};
Game_Player.prototype.encounterProgressValue = function() {
let value = $gameMap.isBush(this.x, this.y) ? 2 : 1;
if ($gameParty.hasEncounterHalf()) {
value *= 0.5;
}
if (this.isInShip()) {
value *= 0.5;
}
return value;
};
Game_Player.prototype.checkEventTriggerHere = function(triggers) {
if (this.canStartLocalEvents()) {
this.startMapEvent(this.x, this.y, triggers, false);
}
};
Game_Player.prototype.checkEventTriggerThere = function(triggers) {
const x1 = this.x;
const y1 = this.y;
this.startMapEvent(x2, y2, triggers, true);
if (!$gameMap.isAnyEventStarting() && $gameMap.isCounter(x2, y2)) {
this.startMapEvent(x3, y3, triggers, true);
}
}
};
Game_Player.prototype.checkEventTriggerTouch = function(x, y) {
this.startMapEvent(x, y, [1, 2], true);
}
};
Game_Player.prototype.canStartLocalEvents = function() {
return !this.isInAirship();
};
Game_Player.prototype.getOnOffVehicle = function() {
return this.getOffVehicle();
} else {
return this.getOnVehicle();
}
};
Game_Player.prototype.getOnVehicle = function() {
const x1 = this.x;
const y1 = this.y;
if ($gameMap.airship().pos(x1, y1)) {
this._vehicleType = "airship";
} else if ($gameMap.ship().pos(x2, y2)) {
this._vehicleType = "ship";
} else if ($gameMap.boat().pos(x2, y2)) {
this._vehicleType = "boat";
}
this._vehicleGettingOn = true;
if (!this.isInAirship()) {
this.forceMoveForward();
}
this.gatherFollowers();
}
return this._vehicleGettingOn;
};
Game_Player.prototype.getOffVehicle = function() {
if (this.vehicle().isLandOk(this.x, this.y, this.direction())) {
if (this.isInAirship()) {
}
this._followers.synchronize(this.x, this.y, this.direction());
this.vehicle().getOff();
if (!this.isInAirship()) {
this.forceMoveForward();
}
this._vehicleGettingOff = true;
this.setMoveSpeed(4);
this.gatherFollowers();
}
return this._vehicleGettingOff;
};
Game_Player.prototype.forceMoveForward = function() {
this.moveForward();
};
Game_Player.prototype.isOnDamageFloor = function() {
return $gameMap.isDamageFloor(this.x, this.y) && !this.isInAirship();
};
Game_Player.prototype.moveStraight = function(d) {
if (this.canPass(this.x, this.y, d)) {
this._followers.updateMove();
}
Game_Character.prototype.moveStraight.call(this, d);
};
Game_Player.prototype.moveDiagonally = function(horz, vert) {

if (this.canPassDiagonally(this.x, this.y, horz, vert)) {
this._followers.updateMove();
}
Game_Character.prototype.moveDiagonally.call(this, horz, vert);
};
Game_Player.prototype.jump = function(xPlus, yPlus) {

Game_Character.prototype.jump.call(this, xPlus, yPlus);
this._followers.jumpAll();
};
Game_Player.prototype.showFollowers = function() {
this._followers.show();
};
Game_Player.prototype.hideFollowers = function() {
this._followers.hide();
};
Game_Player.prototype.gatherFollowers = function() {
this._followers.gather();
};
Game_Player.prototype.areFollowersGathering = function() {
return this._followers.areGathering();
};
Game_Player.prototype.areFollowersGathered = function() {
return this._followers.areGathered();
};
//-----------------------------------------------------------------------------
// Game_Follower
//
// The game object class for a follower. A follower is an allied character,
// other than the front character, displayed in the party.
function Game_Follower() {
}
Game_Follower.prototype = Object.create(Game_Character.prototype);
Game_Follower.prototype.constructor = Game_Follower;
Game_Follower.prototype.initialize = function(memberIndex) {
this._memberIndex = memberIndex;
this.setTransparent($dataSystem.optTransparent);
};
Game_Follower.prototype.refresh = function() {
const characterName = this.isVisible() ? this.actor().characterName() : "";
const characterIndex = this.isVisible() ? this.actor().characterIndex() : 0;
this.setImage(characterName, characterIndex);
};
Game_Follower.prototype.actor = function() {
return $gameParty.battleMembers()[this._memberIndex];
};
Game_Follower.prototype.isVisible = function() {
return this.actor() && $gamePlayer.followers().isVisible();
};
Game_Follower.prototype.isGathered = function() {
return !this.isMoving() && this.pos($gamePlayer.x, $gamePlayer.y);
};
Game_Follower.prototype.update = function() {
this.setMoveSpeed($gamePlayer.realMoveSpeed());
this.setOpacity($gamePlayer.opacity());
this.setBlendMode($gamePlayer.blendMode());
this.setWalkAnime($gamePlayer.hasWalkAnime());
this.setStepAnime($gamePlayer.hasStepAnime());
this.setDirectionFix($gamePlayer.isDirectionFixed());
this.setTransparent($gamePlayer.isTransparent());
};
Game_Follower.prototype.chaseCharacter = function(character) {
if (sx !== 0 && sy !== 0) {
this.moveDiagonally(sx > 0 ? 4 : 6, sy > 0 ? 8 : 2);
} else if (sx !== 0) {
} else if (sy !== 0) {
}
this.setMoveSpeed($gamePlayer.realMoveSpeed());
};
//-----------------------------------------------------------------------------
// Game_Followers
//
// The wrapper class for a follower array.
function Game_Followers() {
}
Game_Followers.prototype.initialize = function() {
this._visible = $dataSystem.optFollowers;
this._gathering = false;
this._data = [];
this.setup();
};
Game_Followers.prototype.setup = function() {
this._data = [];
for (let i = 1; i < $gameParty.maxBattleMembers(); i++) {
this._data.push(new Game_Follower(i));
}
};
Game_Followers.prototype.isVisible = function() {
return this._visible;
};
Game_Followers.prototype.show = function() {
this._visible = true;
};
Game_Followers.prototype.hide = function() {
this._visible = false;
};
Game_Followers.prototype.data = function() {
return this._data.clone();
};
Game_Followers.prototype.reverseData = function() {
return this._data.clone().reverse();
};
Game_Followers.prototype.follower = function(index) {
return this._data[index];
};
Game_Followers.prototype.refresh = function() {
for (const follower of this._data) {
follower.refresh();
}
};
Game_Followers.prototype.update = function() {
if (this.areGathering()) {
if (!this.areMoving()) {
this.updateMove();
}
if (this.areGathered()) {
this._gathering = false;
}
}
follower.update();
}
};
Game_Followers.prototype.updateMove = function() {
for (let i = this._data.length - 1; i >= 0; i--) {
const precedingCharacter = i > 0 ? this._data[i - 1] : $gamePlayer;
this._data[i].chaseCharacter(precedingCharacter);
}
};
Game_Followers.prototype.jumpAll = function() {
if ($gamePlayer.isJumping()) {
const sx = $gamePlayer.deltaXFrom(follower.x);
const sy = $gamePlayer.deltaYFrom(follower.y);
follower.jump(sx, sy);
}
}
};
Game_Followers.prototype.synchronize = function(x, y, d) {
follower.locate(x, y);
follower.setDirection(d);
}
};
Game_Followers.prototype.gather = function() {
this._gathering = true;
};
Game_Followers.prototype.areGathering = function() {
return this._gathering;
};
Game_Followers.prototype.visibleFollowers = function() {
return this._data.filter(follower => follower.isVisible());
};
Game_Followers.prototype.areMoving = function() {
return this.visibleFollowers().some(follower => follower.isMoving());
};
Game_Followers.prototype.areGathered = function() {
return this.visibleFollowers().every(follower => follower.isGathered());
};
Game_Followers.prototype.isSomeoneCollided = function(x, y) {
return this.visibleFollowers().some(follower => follower.pos(x, y));
};
//-----------------------------------------------------------------------------
// Game_Vehicle
//
// The game object class for a vehicle.
function Game_Vehicle() {
}
Game_Vehicle.prototype = Object.create(Game_Character.prototype);
Game_Vehicle.prototype.constructor = Game_Vehicle;
Game_Vehicle.prototype.initialize = function(type) {
this._type = type;
this.resetDirection();
this.initMoveSpeed();
this.loadSystemSettings();
};
Game_Vehicle.prototype.initMembers = function() {
this._type = "";
this._mapId = 0;
this._altitude = 0;
this._driving = false;
this._bgm = null;
};
Game_Vehicle.prototype.isBoat = function() {
return this._type === "boat";
};
Game_Vehicle.prototype.isShip = function() {
return this._type === "ship";
};
Game_Vehicle.prototype.isAirship = function() {
return this._type === "airship";
};
Game_Vehicle.prototype.resetDirection = function() {
};
Game_Vehicle.prototype.initMoveSpeed = function() {
if (this.isBoat()) {
} else if (this.isShip()) {
} else if (this.isAirship()) {
}
};
Game_Vehicle.prototype.vehicle = function() {
return $dataSystem.boat;
return $dataSystem.ship;
return $dataSystem.airship;
} else {
return null;
}
};
Game_Vehicle.prototype.loadSystemSettings = function() {
const vehicle = this.vehicle();
this._mapId = vehicle.startMapId;
this.setPosition(vehicle.startX, vehicle.startY);
this.setImage(vehicle.characterName, vehicle.characterIndex);
};
Game_Vehicle.prototype.refresh = function() {
if (this._driving) {
this._mapId = $gameMap.mapId();
this.syncWithPlayer();
} else if (this._mapId === $gameMap.mapId()) {
this.locate(this.x, this.y);
}
if (this.isAirship()) {
this.setPriorityType(this._driving ? 2 : 0);
} else {
this.setPriorityType(1);
}
this.setWalkAnime(this._driving);
this.setStepAnime(this._driving);
this.setTransparent(this._mapId !== $gameMap.mapId());
};
Game_Vehicle.prototype.setLocation = function(mapId, x, y) {
this.setPosition(x, y);
this.refresh();
};
Game_Vehicle.prototype.pos = function(x, y) {
if (this._mapId === $gameMap.mapId()) {
return Game_Character.prototype.pos.call(this, x, y);
} else {
return false;
}
};
Game_Vehicle.prototype.isMapPassable = function(x, y, d) {
return $gameMap.isBoatPassable(x2, y2);
return $gameMap.isShipPassable(x2, y2);
return true;
} else {
return false;
}
};
Game_Vehicle.prototype.getOn = function() {
this._driving = true;
this.setWalkAnime(true);
this.setStepAnime(true);
$gameSystem.saveWalkingBgm();
this.playBgm();
};
Game_Vehicle.prototype.getOff = function() {
this._driving = false;
this.setWalkAnime(false);
this.setStepAnime(false);
this.resetDirection();
$gameSystem.replayWalkingBgm();
};
Game_Vehicle.prototype.setBgm = function(bgm) {
this._bgm = bgm;
};
Game_Vehicle.prototype.playBgm = function() {
AudioManager.playBgm(this._bgm || this.vehicle().bgm);
};
Game_Vehicle.prototype.syncWithPlayer = function() {
this.copyPosition($gamePlayer);
};
Game_Vehicle.prototype.screenY = function() {
return Game_Character.prototype.screenY.call(this) - this._altitude;
};
Game_Vehicle.prototype.shadowX = function() {
return this.screenX();
};
Game_Vehicle.prototype.shadowY = function() {
return this.screenY() + this._altitude;
};
Game_Vehicle.prototype.shadowOpacity = function() {
return (255 * this._altitude) / this.maxAltitude();
};
Game_Vehicle.prototype.canMove = function() {
return this.isHighest();
} else {
return true;
}
};
Game_Vehicle.prototype.update = function() {
this.updateAirship();
}
};
Game_Vehicle.prototype.updateAirship = function() {
this.updateAirshipAltitude();
this.setStepAnime(this.isHighest());
this.setPriorityType(this.isLowest() ? 0 : 2);
};
Game_Vehicle.prototype.updateAirshipAltitude = function() {
if (this._driving && !this.isHighest()) {
this._altitude++;
}
if (!this._driving && !this.isLowest()) {
this._altitude--;
}
};
Game_Vehicle.prototype.maxAltitude = function() {
return 48;
};
Game_Vehicle.prototype.isLowest = function() {
return this._altitude <= 0;
};
Game_Vehicle.prototype.isHighest = function() {
return this._altitude >= this.maxAltitude();
};
Game_Vehicle.prototype.isTakeoffOk = function() {
return $gamePlayer.areFollowersGathered();
};
Game_Vehicle.prototype.isLandOk = function(x, y, d) {
if (!$gameMap.isAirshipLandOk(x, y)) {
return false;
}
if ($gameMap.eventsXy(x, y).length > 0) {
return false;
}
} else {
if (!$gameMap.isValid(x2, y2)) {
return false;
}
if (!$gameMap.isPassable(x2, y2, this.reverseDir(d))) {
return false;
}
if (this.isCollidedWithCharacters(x2, y2)) {
return false;
}
}
return true;
};
//-----------------------------------------------------------------------------
// Game_Event
//
// The game object class for an event. It contains functionality for event page
// switching and running parallel process events.
function Game_Event() {
}
Game_Event.prototype = Object.create(Game_Character.prototype);
Game_Event.prototype.constructor = Game_Event;
Game_Event.prototype.initialize = function(mapId, eventId) {

this._eventId = eventId;
this.locate(this.event().x, this.event().y);
this.refresh();
};
Game_Event.prototype.initMembers = function() {
this._moveType = 0;
this._trigger = 0;
this._starting = false;
this._erased = false;
this._pageIndex = -2;
this._originalPattern = 1;
this._originalDirection = 2;
this._prelockDirection = 0;
this._locked = false;
};
Game_Event.prototype.eventId = function() {
return this._eventId;
};
Game_Event.prototype.event = function() {
return $dataMap.events[this._eventId];
};
Game_Event.prototype.page = function() {
return this.event().pages[this._pageIndex];
};
Game_Event.prototype.list = function() {
return this.page().list;
};
Game_Event.prototype.isCollidedWithCharacters = function(x, y) {
return (
Game_Character.prototype.isCollidedWithCharacters.call(this, x, y) ||
this.isCollidedWithPlayerCharacters(x, y)
);
};
Game_Event.prototype.isCollidedWithEvents = function(x, y) {
const events = $gameMap.eventsXyNt(x, y);
return events.length > 0;
};
Game_Event.prototype.isCollidedWithPlayerCharacters = function(x, y) {
return this.isNormalPriority() && $gamePlayer.isCollided(x, y);
};
Game_Event.prototype.lock = function() {
if (!this._locked) {
this._prelockDirection = this.direction();
this.turnTowardPlayer();
this._locked = true;
}
};
Game_Event.prototype.unlock = function() {
if (this._locked) {
this._locked = false;
this.setDirection(this._prelockDirection);
}
};
Game_Event.prototype.updateStop = function() {
if (this._locked) {
}
Game_Character.prototype.updateStop.call(this);
if (!this.isMoveRouteForcing()) {
this.updateSelfMovement();
}
};
Game_Event.prototype.updateSelfMovement = function() {
if (
!this._locked &&
this.isNearTheScreen() &&
this.checkStop(this.stopCountThreshold())
) {
switch (this._moveType) {
case 1:
this.moveTypeRandom();
break;
case 2:
this.moveTypeTowardPlayer();
break;
case 3:
this.moveTypeCustom();
break;
}
}
};
Game_Event.prototype.stopCountThreshold = function() {
return 30 * (5 - this.moveFrequency());
};
Game_Event.prototype.moveTypeRandom = function() {
case 0:
case 1:
this.moveRandom();
break;
case 2:
case 3:
case 4:
this.moveForward();
break;
case 5:
break;
}
};
Game_Event.prototype.moveTypeTowardPlayer = function() {
if (this.isNearThePlayer()) {
case 0:
case 1:
case 2:
case 3:
this.moveTowardPlayer();
break;
case 4:
this.moveRandom();
break;
case 5:
this.moveForward();
break;
}
} else {
this.moveRandom();
}
};
Game_Event.prototype.isNearThePlayer = function() {
const sx = Math.abs(this.deltaXFrom($gamePlayer.x));
const sy = Math.abs(this.deltaYFrom($gamePlayer.y));
return sx + sy < 20;
};
Game_Event.prototype.moveTypeCustom = function() {
this.updateRoutineMove();
};
Game_Event.prototype.isStarting = function() {
return this._starting;
};
Game_Event.prototype.clearStartingFlag = function() {
this._starting = false;
};
Game_Event.prototype.isTriggerIn = function(triggers) {
return triggers.includes(this._trigger);
};
Game_Event.prototype.start = function() {
const list = this.list();
if (list && list.length > 1) {
this._starting = true;
if (this.isTriggerIn([0, 1, 2])) {
this.lock();
}
}
};
Game_Event.prototype.erase = function() {
this._erased = true;
this.refresh();
};
Game_Event.prototype.refresh = function() {
const newPageIndex = this._erased ? -1 : this.findProperPageIndex();
if (this._pageIndex !== newPageIndex) {
this._pageIndex = newPageIndex;
this.setupPage();
}
};
Game_Event.prototype.findProperPageIndex = function() {
const pages = this.event().pages;
for (let i = pages.length - 1; i >= 0; i--) {
if (this.meetsConditions(page)) {
return i;
}
}
return -1;
};
Game_Event.prototype.meetsConditions = function(page) {
const c = page.conditions;
if (c.switch1Valid) {
if (!$gameSwitches.value(c.switch1Id)) {
return false;
}
}
if (c.switch2Valid) {
if (!$gameSwitches.value(c.switch2Id)) {
return false;
}
}
if (c.variableValid) {
if ($gameVariables.value(c.variableId) < c.variableValue) {
return false;
}
}
if (c.selfSwitchValid) {
const key = [this._mapId, this._eventId, c.selfSwitchCh];
if ($gameSelfSwitches.value(key) !== true) {
return false;
}
}
if (c.itemValid) {
const item = $dataItems[c.itemId];
if (!$gameParty.hasItem(item)) {
return false;
}
}
if (c.actorValid) {
const actor = $gameActors.actor(c.actorId);
if (!$gameParty.members().includes(actor)) {
return false;
}
}
return true;
};
Game_Event.prototype.setupPage = function() {
if (this._pageIndex >= 0) {
this.setupPageSettings();
} else {
this.clearPageSettings();
}
this.clearStartingFlag();
this.checkEventTriggerAuto();
};
Game_Event.prototype.clearPageSettings = function() {
this.setImage("", 0);
this._moveType = 0;
this._trigger = null;
};
Game_Event.prototype.setupPageSettings = function() {
const page = this.page();
const image = page.image;
if (image.tileId > 0) {
this.setTileImage(image.tileId);
} else {
this.setImage(image.characterName, image.characterIndex);
}
if (this._originalDirection !== image.direction) {
this._originalDirection = image.direction;
this.setDirectionFix(false);
this.setDirection(image.direction);
}
if (this._originalPattern !== image.pattern) {
this._originalPattern = image.pattern;
this.setPattern(image.pattern);
}
this.setMoveSpeed(page.moveSpeed);
this.setMoveFrequency(page.moveFrequency);
this.setPriorityType(page.priorityType);
this.setWalkAnime(page.walkAnime);
this.setStepAnime(page.stepAnime);
this.setDirectionFix(page.directionFix);
this.setThrough(page.through);
this.setMoveRoute(page.moveRoute);
this._moveType = page.moveType;
this._trigger = page.trigger;
if (this._trigger === 4) {
} else {
}
};
Game_Event.prototype.isOriginalPattern = function() {
return this.pattern() === this._originalPattern;
};
Game_Event.prototype.resetPattern = function() {
this.setPattern(this._originalPattern);
};
Game_Event.prototype.checkEventTriggerTouch = function(x, y) {
if (this._trigger === 2 && $gamePlayer.pos(x, y)) {
if (!this.isJumping() && this.isNormalPriority()) {
this.start();
}
}
}
};
Game_Event.prototype.checkEventTriggerAuto = function() {
if (this._trigger === 3) {
this.start();
}
};
Game_Event.prototype.update = function() {
this.checkEventTriggerAuto();
this.updateParallel();
};
Game_Event.prototype.updateParallel = function() {
if (this._interpreter) {
this._interpreter.setup(this.list(), this._eventId);
}
}
};
Game_Event.prototype.locate = function(x, y) {
Game_Character.prototype.locate.call(this, x, y);
};
Game_Event.prototype.forceMoveRoute = function(moveRoute) {
Game_Character.prototype.forceMoveRoute.call(this, moveRoute);
};
//-----------------------------------------------------------------------------
// Game_Interpreter
//
// The interpreter for running event commands.
function Game_Interpreter() {
}
Game_Interpreter.prototype.initialize = function(depth) {
this._depth = depth || 0;
this.checkOverflow();
this.clear();
this._branch = {};
this._indent = 0;
this._frameCount = 0;
this._freezeChecker = 0;
};
Game_Interpreter.prototype.checkOverflow = function() {
if (this._depth >= 100) {
throw new Error("Common event calls exceeded the limit");
}
};
Game_Interpreter.prototype.clear = function() {
this._mapId = 0;
this._eventId = 0;
this._list = null;
this._index = 0;
this._waitMode = "";
this._comments = "";
this._characterId = 0;
this._childInterpreter = null;
};
Game_Interpreter.prototype.setup = function(list, eventId) {

this.clear();
this._mapId = $gameMap.mapId();
this._eventId = eventId || 0;
this._list = list;
this.loadImages();
};
Game_Interpreter.prototype.loadImages = function() {
// [Note] The certain versions of MV had a more complicated preload scheme.
// However it is usually sufficient to preload face and picture images.
const list = this._list.slice(0, 200);
for (const command of list) {
switch (command.code) {
case 101: // Show Text
ImageManager.loadFace(command.parameters[0]);
break;
case 231: // Show Picture
ImageManager.loadPicture(command.parameters[1]);
break;
}
}
};
Game_Interpreter.prototype.eventId = function() {
return this._eventId;
};
Game_Interpreter.prototype.isOnCurrentMap = function() {
return this._mapId === $gameMap.mapId();
};
Game_Interpreter.prototype.setupReservedCommonEvent = function() {
if ($gameTemp.isCommonEventReserved()) {
const commonEvent = $gameTemp.retrieveCommonEvent();
if (commonEvent) {
this.setup(commonEvent.list);
return true;
}
}
return false;
};
Game_Interpreter.prototype.isRunning = function() {
return !!this._list;
};
Game_Interpreter.prototype.update = function() {
while (this.isRunning()) {
if (this.updateChild() || this.updateWait()) {
break;
}
if (SceneManager.isSceneChanging()) {
break;
}
if (!this.executeCommand()) {
break;
}
if (this.checkFreeze()) {
break;
}
}
};
Game_Interpreter.prototype.updateChild = function() {
if (this._childInterpreter) {
this._childInterpreter.update();
if (this._childInterpreter.isRunning()) {
return true;
} else {
this._childInterpreter = null;
}
}
return false;
};
Game_Interpreter.prototype.updateWait = function() {
return this.updateWaitCount() || this.updateWaitMode();
};
Game_Interpreter.prototype.updateWaitCount = function() {
if (this._waitCount > 0) {
this._waitCount--;
return true;
}
return false;
};
Game_Interpreter.prototype.updateWaitMode = function() {
let character = null;
let waiting = false;
switch (this._waitMode) {
case "message":
waiting = $gameMessage.isBusy();
break;
case "transfer":
waiting = $gamePlayer.isTransferring();
break;
case "scroll":
waiting = $gameMap.isScrolling();
break;
case "route":
character = this.character(this._characterId);
waiting = character && character.isMoveRouteForcing();
break;
case "animation":
waiting = character && character.isAnimationPlaying();
break;
case "balloon":
waiting = character && character.isBalloonPlaying();
break;
case "gather":
waiting = $gamePlayer.areFollowersGathering();
break;
case "action":
waiting = BattleManager.isActionForced();
break;
case "video":
waiting = Video.isPlaying();
break;
case "image":
waiting = !ImageManager.isReady();
break;
}
if (!waiting) {
this._waitMode = "";
}
return waiting;
};
Game_Interpreter.prototype.setWaitMode = function(waitMode) {
this._waitMode = waitMode;
};
Game_Interpreter.prototype.wait = function(duration) {
this._waitCount = duration;
};
Game_Interpreter.prototype.fadeSpeed = function() {
return 24;
};
Game_Interpreter.prototype.executeCommand = function() {
const command = this.currentCommand();
if (command) {
this._indent = command.indent;
const methodName = "command" + command.code;
if (typeof this[methodName] === "function") {
if (!this[methodName](command.parameters)) {
return false;
}
}
this._index++;
} else {
this.terminate();
}
return true;
};
Game_Interpreter.prototype.checkFreeze = function() {
if (this._frameCount !== Graphics.frameCount) {
this._frameCount = Graphics.frameCount;
this._freezeChecker = 0;
}
if (this._freezeChecker++ >= 100000) {
return true;
} else {
return false;
}
};
Game_Interpreter.prototype.terminate = function() {
this._list = null;
this._comments = "";
};
Game_Interpreter.prototype.skipBranch = function() {
while (this._list[this._index + 1].indent > this._indent) {
this._index++;
}
};
Game_Interpreter.prototype.currentCommand = function() {
return this._list[this._index];
};
Game_Interpreter.prototype.nextEventCode = function() {
const command = this._list[this._index + 1];
if (command) {
return command.code;
} else {
return 0;
}
};
Game_Interpreter.prototype.iterateActorId = function(param, callback) {

if (param === 0) {
$gameParty.members().forEach(callback);
} else {
const actor = $gameActors.actor(param);
if (actor) {
callback(actor);
}
}
};
Game_Interpreter.prototype.iterateActorEx = function(param1, param2, callback) {

if (param1 === 0) {
this.iterateActorId(param2, callback);
} else {
this.iterateActorId($gameVariables.value(param2), callback);
}
};
Game_Interpreter.prototype.iterateActorIndex = function(param, callback) {

if (param < 0) {
$gameParty.members().forEach(callback);
} else {
const actor = $gameParty.members()[param];
if (actor) {
callback(actor);
}
}
};
Game_Interpreter.prototype.iterateEnemyIndex = function(param, callback) {

if (param < 0) {
$gameTroop.members().forEach(callback);
} else {
const enemy = $gameTroop.members()[param];
if (enemy) {
callback(enemy);
}
}
};
Game_Interpreter.prototype.iterateBattler = function(param1, param2, callback) {

if (param1 === 0) {
this.iterateEnemyIndex(param2, callback);
} else {
this.iterateActorId(param2, callback);
}
}
};
Game_Interpreter.prototype.character = function(param) {
return null;
} else if (param < 0) {
return $gamePlayer;
} else if (this.isOnCurrentMap()) {
return $gameMap.event(param > 0 ? param : this._eventId);
} else {
return null;
}
};
// prettier-ignore
Game_Interpreter.prototype.operateValue = function(
operation, operandType, operand
) {
const value = operandType === 0 ? operand : $gameVariables.value(operand);
return operation === 0 ? value : -value;
};
Game_Interpreter.prototype.changeHp = function(target, value, allowDeath) {

if (target.isAlive()) {
if (!allowDeath && target.hp <= -value) {
value = 1 - target.hp;
}
target.gainHp(value);
if (target.isDead()) {
target.performCollapse();
}
}
};
// Show Text
Game_Interpreter.prototype.command101 = function(params) {
if ($gameMessage.isBusy()) {
return false;
}
$gameMessage.setFaceImage(params[0], params[1]);
$gameMessage.setBackground(params[2]);
$gameMessage.setPositionType(params[3]);
$gameMessage.setSpeakerName(params[4]);
while (this.nextEventCode() === 401) {
// Text data
this._index++;
$gameMessage.add(this.currentCommand().parameters[0]);
}
switch (this.nextEventCode()) {
case 102: // Show Choices
this._index++;
this.setupChoices(this.currentCommand().parameters);
break;
case 103: // Input Number
this._index++;
this.setupNumInput(this.currentCommand().parameters);
break;
case 104: // Select Item
this._index++;
this.setupItemChoice(this.currentCommand().parameters);
break;
}
this.setWaitMode("message");
return true;
};
// Show Choices
return false;
}
this.setupChoices(params);
return true;
};
Game_Interpreter.prototype.setupChoices = function(params) {
const choices = params[0].clone();
const cancelType = params[1] < choices.length ? params[1] : -2;
const defaultType = params.length > 2 ? params[2] : 0;
const positionType = params.length > 3 ? params[3] : 2;
const background = params.length > 4 ? params[4] : 0;
$gameMessage.setChoices(choices, defaultType, cancelType);
$gameMessage.setChoiceBackground(background);
$gameMessage.setChoicePositionType(positionType);
$gameMessage.setChoiceCallback(n => {
this._branch[this._indent] = n;
});
};
// When [**]
if (this._branch[this._indent] !== params[0]) {
this.skipBranch();
}
return true;
};
// When Cancel
Game_Interpreter.prototype.command403 = function() {
if (this._branch[this._indent] >= 0) {
this.skipBranch();
}
return true;
};
// Input Number
return false;
}
this.setupNumInput(params);
return true;
};
Game_Interpreter.prototype.setupNumInput = function(params) {
$gameMessage.setNumberInput(params[0], params[1]);
};
// Select Item
return false;
}
this.setupItemChoice(params);
return true;
};
Game_Interpreter.prototype.setupItemChoice = function(params) {
$gameMessage.setItemChoice(params[0], params[1] || 2);
};
// Show Scrolling Text

return false;
}
$gameMessage.setScroll(params[0], params[1]);
this._index++;
$gameMessage.add(this.currentCommand().parameters[0]);
}
return true;
};
// Comment
this._comments = [params[0]];
this._index++;
this._comments.push(this.currentCommand().parameters[0]);
}
return true;
};
// Skip
this.skipBranch();
return true;
};
// Conditional Branch
let result = false;
let value1, value2;
let actor, enemy, character;
switch (params[0]) {
case 0: // Switch
result = $gameSwitches.value(params[1]) === (params[2] === 0);
break;
case 1: // Variable
value1 = $gameVariables.value(params[1]);
if (params[2] === 0) {
value2 = params[3];
} else {
value2 = $gameVariables.value(params[3]);
}
case 0: // Equal to
result = value1 === value2;
break;
case 1: // Greater than or Equal to
result = value1 >= value2;
break;
case 2: // Less than or Equal to
result = value1 <= value2;
break;
case 3: // Greater than
result = value1 > value2;
break;
case 4: // Less than
result = value1 < value2;
break;
case 5: // Not Equal to
result = value1 !== value2;
break;
}
break;
case 2: // Self Switch
if (this._eventId > 0) {
const key = [this._mapId, this._eventId, params[1]];
result = $gameSelfSwitches.value(key) === (params[2] === 0);
}
break;
case 3: // Timer
if ($gameTimer.isWorking()) {
const sec = $gameTimer.frames() / 60;
if (params[2] === 0) {
result = sec >= params[1];
} else {
result = sec <= params[1];
}
}
break;
case 4: // Actor
actor = $gameActors.actor(params[1]);
if (actor) {
const n = params[3];
case 0: // In the Party
result = $gameParty.members().includes(actor);
break;
case 1: // Name
result = actor.name() === n;
break;
case 2: // Class
result = actor.isClass($dataClasses[n]);
break;
case 3: // Skill
result = actor.hasSkill(n);
break;
case 4: // Weapon
result = actor.hasWeapon($dataWeapons[n]);
break;
case 5: // Armor
result = actor.hasArmor($dataArmors[n]);
break;
case 6: // State
result = actor.isStateAffected(n);
break;
}
}
break;
case 5: // Enemy
enemy = $gameTroop.members()[params[1]];
if (enemy) {
case 0: // Appeared
result = enemy.isAlive();
break;
case 1: // State
result = enemy.isStateAffected(params[3]);
break;
}
}
break;
case 6: // Character
character = this.character(params[1]);
if (character) {
result = character.direction() === params[2];
}
break;
case 7: // Gold
case 0: // Greater than or equal to
result = $gameParty.gold() >= params[1];
break;
case 1: // Less than or equal to
result = $gameParty.gold() <= params[1];
break;
case 2: // Less than
result = $gameParty.gold() < params[1];
break;
}
break;
case 8: // Item
result = $gameParty.hasItem($dataItems[params[1]]);
break;
case 9: // Weapon
result = $gameParty.hasItem($dataWeapons[params[1]], params[2]);
break;
case 10: // Armor
result = $gameParty.hasItem($dataArmors[params[1]], params[2]);
break;
case 11: // Button
switch (params[2] || 0) {
case 0:
result = Input.isPressed(params[1]);
break;
case 1:
result = Input.isTriggered(params[1]);
break;
case 2:
result = Input.isRepeated(params[1]);
break;
}
break;
case 12: // Script
result = !!eval(params[1]);
break;
case 13: // Vehicle
result = $gamePlayer.vehicle() === $gameMap.vehicle(params[1]);
break;
}
this._branch[this._indent] = result;
if (this._branch[this._indent] === false) {
this.skipBranch();
}
return true;
};
// Else
if (this._branch[this._indent] !== false) {
this.skipBranch();
}
return true;
};
// Loop
return true;
};
// Repeat Above
do {
this._index--;
} while (this.currentCommand().indent !== this._indent);
return true;
};
// Break Loop
let depth = 0;
while (this._index < this._list.length - 1) {
this._index++;
const command = this.currentCommand();
if (command.code === 112) {
depth++;
}
if (command.code === 413) {
if (depth > 0) {
depth--;
} else {
break;
}
}
}
return true;
};
// Exit Event Processing

this._index = this._list.length;
return true;
};
// Common Event
const commonEvent = $dataCommonEvents[params[0]];
if (commonEvent) {
const eventId = this.isOnCurrentMap() ? this._eventId : 0;
this.setupChild(commonEvent.list, eventId);
}
return true;
};
Game_Interpreter.prototype.setupChild = function(list, eventId) {

this._childInterpreter = new Game_Interpreter(this._depth + 1);
this._childInterpreter.setup(list, eventId);
};
// Label
return true;
};
// Jump to Label
const labelName = params[0];
for (let i = 0; i < this._list.length; i++) {
const command = this._list[i];
if (command.code === 118 && command.parameters[0] === labelName) {
this.jumpTo(i);
break;
}
}
return true;
};
Game_Interpreter.prototype.jumpTo = function(index) {
const lastIndex = this._index;
const startIndex = Math.min(index, lastIndex);
const endIndex = Math.max(index, lastIndex);
let indent = this._indent;
for (let i = startIndex; i <= endIndex; i++) {
const newIndent = this._list[i].indent;
if (newIndent !== indent) {
this._branch[indent] = null;
indent = newIndent;
}
}
this._index = index;
};
// Control Switches
for (let i = params[0]; i <= params[1]; i++) {
$gameSwitches.setValue(i, params[2] === 0);
}
return true;
};
// Control Variables
const startId = params[0];
const endId = params[1];
const operationType = params[2];
const operand = params[3];
let value = 0;
let randomMax = 1;
switch (operand) {
case 0: // Constant
value = params[4];
break;
case 1: // Variable
value = $gameVariables.value(params[4]);
break;
case 2: // Random
value = params[4];
randomMax = params[5] - params[4] + 1;
randomMax = Math.max(randomMax, 1);
break;
case 3: // Game Data
value = this.gameDataOperand(params[4], params[5], params[6]);
break;
case 4: // Script
value = eval(params[4]);
break;
}
for (let i = startId; i <= endId; i++) {
if (typeof value === "number") {
const realValue = value + Math.randomInt(randomMax);
this.operateVariable(i, operationType, realValue);
} else {
this.operateVariable(i, operationType, value);
}
}
return true;
};
Game_Interpreter.prototype.gameDataOperand = function(type, param1, param2) {
let actor, enemy, character;
switch (type) {
case 0: // Item
return $gameParty.numItems($dataItems[param1]);
case 1: // Weapon
return $gameParty.numItems($dataWeapons[param1]);
case 2: // Armor
return $gameParty.numItems($dataArmors[param1]);
case 3: // Actor
actor = $gameActors.actor(param1);
if (actor) {
switch (param2) {
case 0: // Level
return actor.level;
case 1: // EXP
return actor.currentExp();
case 2: // HP
return actor.hp;
case 3: // MP
return actor.mp;
case 12: // TP
return actor.tp;
default:
// Parameter
if (param2 >= 4 && param2 <= 11) {
return actor.param(param2 - 4);
}
}
}
break;
case 4: // Enemy
enemy = $gameTroop.members()[param1];
if (enemy) {
switch (param2) {
case 0: // HP
return enemy.hp;
case 1: // MP
return enemy.mp;
case 10: // TP
return enemy.tp;
default:
// Parameter
if (param2 >= 2 && param2 <= 9) {
return enemy.param(param2 - 2);
}
}
}
break;
case 5: // Character
character = this.character(param1);
if (character) {
switch (param2) {
case 0: // Map X
return character.x;
case 1: // Map Y
return character.y;
case 2: // Direction
return character.direction();
case 3: // Screen X
return character.screenX();
case 4: // Screen Y
return character.screenY();
}
}
break;
case 6: // Party
actor = $gameParty.members()[param1];
return actor ? actor.actorId() : 0;
case 8: // Last
return $gameTemp.lastActionData(param1);
case 7: // Other
switch (param1) {
case 0: // Map ID
return $gameMap.mapId();
case 1: // Party Members
return $gameParty.size();
case 2: // Gold
return $gameParty.gold();
case 3: // Steps
return $gameParty.steps();
case 4: // Play Time
return $gameSystem.playtime();
case 5: // Timer
return $gameTimer.seconds();
case 6: // Save Count
return $gameSystem.saveCount();
case 7: // Battle Count
return $gameSystem.battleCount();
case 8: // Win Count
return $gameSystem.winCount();
case 9: // Escape Count
return $gameSystem.escapeCount();
}
break;
}
return 0;
};
Game_Interpreter.prototype.operateVariable = function(
variableId,
operationType,
value
) {
try {
const oldValue = $gameVariables.value(variableId);
switch (operationType) {
case 0: // Set
$gameVariables.setValue(variableId, value);
break;
case 1: // Add
$gameVariables.setValue(variableId, oldValue + value);
break;
case 2: // Sub
$gameVariables.setValue(variableId, oldValue - value);
break;
case 3: // Mul
$gameVariables.setValue(variableId, oldValue * value);
break;
case 4: // Div
$gameVariables.setValue(variableId, oldValue / value);
break;
case 5: // Mod
$gameVariables.setValue(variableId, oldValue % value);
break;
}
} catch (e) {
$gameVariables.setValue(variableId, 0);
}
};
// Control Self Switch

if (this._eventId > 0) {
const key = [this._mapId, this._eventId, params[0]];
$gameSelfSwitches.setValue(key, params[1] === 0);
}
return true;
};
// Control Timer
if (params[0] === 0) {
// Start
$gameTimer.start(params[1] * 60);
} else {
// Stop
$gameTimer.stop();
}
return true;
};
// Change Gold
const value = this.operateValue(params[0], params[1], params[2]);
$gameParty.gainGold(value);
return true;
};
// Change Items
$gameParty.gainItem($dataItems[params[0]], value);
return true;
};
// Change Weapons
$gameParty.gainItem($dataWeapons[params[0]], value, params[4]);
return true;
};
// Change Armors
$gameParty.gainItem($dataArmors[params[0]], value, params[4]);
return true;
};
// Change Party Member

const actor = $gameActors.actor(params[0]);
if (actor) {
if (params[1] === 0) {
// Add
if (params[2]) {
// Initialize
$gameActors.actor(params[0]).setup(params[0]);
}
$gameParty.addActor(params[0]);
} else {
// Remove
$gameParty.removeActor(params[0]);
}
}
return true;
};
// Change Battle BGM

$gameSystem.setBattleBgm(params[0]);
return true;
};
// Change Victory ME
$gameSystem.setVictoryMe(params[0]);
return true;
};
// Change Save Access

if (params[0] === 0) {
$gameSystem.disableSave();
} else {
$gameSystem.enableSave();
}
return true;
};
// Change Menu Access

if (params[0] === 0) {
$gameSystem.disableMenu();
} else {
$gameSystem.enableMenu();
}
return true;
};
// Change Encounter
if (params[0] === 0) {
$gameSystem.disableEncounter();
} else {
$gameSystem.enableEncounter();
}
$gamePlayer.makeEncounterCount();
return true;
};
// Change Formation Access

if (params[0] === 0) {
$gameSystem.disableFormation();
} else {
$gameSystem.enableFormation();
}
return true;
};
// Change Window Color

$gameSystem.setWindowTone(params[0]);
return true;
};
// Change Defeat ME
$gameSystem.setDefeatMe(params[0]);
return true;
};
// Change Vehicle BGM

const vehicle = $gameMap.vehicle(params[0]);
if (vehicle) {
vehicle.setBgm(params[1]);
}
return true;
};
// Transfer Player
if ($gameParty.inBattle() || $gameMessage.isBusy()) {
return false;
}
let mapId, x, y;
if (params[0] === 0) {
// Direct designation
mapId = params[1];
x = params[2];
y = params[3];
} else {
// Designation with variables
mapId = $gameVariables.value(params[1]);
x = $gameVariables.value(params[2]);
y = $gameVariables.value(params[3]);
}
$gamePlayer.reserveTransfer(mapId, x, y, params[4], params[5]);
this.setWaitMode("transfer");
return true;
};
// Set Vehicle Location
let mapId, x, y;
if (params[1] === 0) {
mapId = params[2];
x = params[3];
y = params[4];
} else {
mapId = $gameVariables.value(params[2]);
}
if (vehicle) {
vehicle.setLocation(mapId, x, y);
}
return true;
};
// Set Event Location

const character = this.character(params[0]);
if (character) {
if (params[1] === 0) {
character.locate(params[2], params[3]);
} else if (params[1] === 1) {
const x = $gameVariables.value(params[2]);
const y = $gameVariables.value(params[3]);
character.locate(x, y);
} else {
// Exchange with another event
const character2 = this.character(params[2]);
if (character2) {
character.swap(character2);
}
}
if (params[4] > 0) {
character.setDirection(params[4]);
}
}
return true;
};
// Scroll Map
if ($gameMap.isScrolling()) {
this.setWaitMode("scroll");
return false;
}
$gameMap.startScroll(params[0], params[1], params[2]);
if (params[3]) {
this.setWaitMode("scroll");
}
}
return true;
};
// Set Movement Route

$gameMap.refreshIfNeeded();
this._characterId = params[0];
const character = this.character(this._characterId);
if (character) {
character.forceMoveRoute(params[1]);
if (params[1].wait) {
this.setWaitMode("route");
}
}
return true;
};
// Get on/off Vehicle

$gamePlayer.getOnOffVehicle();
return true;
};
// Change Transparency
$gamePlayer.setTransparent(params[0] === 0);
return true;
};
// Show Animation
if (character) {
$gameTemp.requestAnimation([character], params[1]);
if (params[2]) {
this.setWaitMode("animation");
}
}
return true;
};
// Show Balloon Icon

if (character) {
$gameTemp.requestBalloon(character, params[1]);
if (params[2]) {
this.setWaitMode("balloon");
}
}
return true;
};
// Erase Event
if (this.isOnCurrentMap() && this._eventId > 0) {
$gameMap.eraseEvent(this._eventId);
}
return true;
};
// Change Player Followers

if (params[0] === 0) {
$gamePlayer.showFollowers();
} else {
$gamePlayer.hideFollowers();
}
return true;
};
// Gather Followers
$gamePlayer.gatherFollowers();
this.setWaitMode("gather");
}
return true;
};
// Fadeout Screen
return false;
}
$gameScreen.startFadeOut(this.fadeSpeed());
this.wait(this.fadeSpeed());
return true;
};
// Fadein Screen
return false;
}
$gameScreen.startFadeIn(this.fadeSpeed());
this.wait(this.fadeSpeed());
return true;
};
// Tint Screen
$gameScreen.startTint(params[0], params[1]);
if (params[2]) {
this.wait(params[1]);
}
return true;
};
// Flash Screen
$gameScreen.startFlash(params[0], params[1]);
if (params[2]) {
}
return true;
};
// Shake Screen
$gameScreen.startShake(params[0], params[1], params[2]);
if (params[3]) {
}
return true;
};
// Wait
return true;
};
// Show Picture
const point = this.picturePoint(params);
// prettier-ignore
$gameScreen.showPicture(
params[0], params[1], params[2], point.x, point.y,
params[6], params[7], params[8], params[9]
);
return true;
};
// Move Picture
const point = this.picturePoint(params);
// prettier-ignore
$gameScreen.movePicture(
params[0], params[2], point.x, point.y, params[6], params[7],
params[8], params[9], params[10], params[12] || 0
);
if (params[11]) {
}
return true;
};
Game_Interpreter.prototype.picturePoint = function(params) {
const point = new Point();
if (params[3] === 0) {
point.x = params[4];
point.y = params[5];
} else {
point.x = $gameVariables.value(params[4]);
point.y = $gameVariables.value(params[5]);
}
return point;
};
// Rotate Picture
$gameScreen.rotatePicture(params[0], params[1]);
return true;
};
// Tint Picture
$gameScreen.tintPicture(params[0], params[1], params[2]);
if (params[3]) {
}
return true;
};
// Erase Picture
$gameScreen.erasePicture(params[0]);
return true;
};
// Set Weather Effect

$gameScreen.changeWeather(params[0], params[1], params[2]);
if (params[3]) {
}
}
return true;
};
// Play BGM
AudioManager.playBgm(params[0]);
return true;
};
// Fadeout BGM
AudioManager.fadeOutBgm(params[0]);
return true;
};
// Save BGM
$gameSystem.saveBgm();
return true;
};
// Resume BGM
$gameSystem.replayBgm();
return true;
};
// Play BGS
AudioManager.playBgs(params[0]);
return true;
};
// Fadeout BGS
AudioManager.fadeOutBgs(params[0]);
return true;
};
// Play ME
AudioManager.playMe(params[0]);
return true;
};
// Play SE
AudioManager.playSe(params[0]);
return true;
};
// Stop SE
AudioManager.stopSe();
return true;
};
// Play Movie
return false;
}
const name = params[0];
if (name.length > 0) {
const ext = this.videoFileExt();
Video.play("movies/" + name + ext);
this.setWaitMode("video");
}
return true;
};
Game_Interpreter.prototype.videoFileExt = function() {
if (Utils.canPlayWebm()) {
return ".webm";
} else {
return ".mp4";
}
};
// Change Map Name Display

if (params[0] === 0) {
$gameMap.enableNameDisplay();
} else {
$gameMap.disableNameDisplay();
}
return true;
};
// Change Tileset
const tileset = $dataTilesets[params[0]];
const allReady = tileset.tilesetNames
.map(tilesetName => ImageManager.loadTileset(tilesetName))
.every(bitmap => bitmap.isReady());
if (allReady) {
$gameMap.changeTileset(params[0]);
return true;
} else {
return false;
}
};
// Change Battle Background

$gameMap.changeBattleback(params[0], params[1]);
return true;
};
// Change Parallax
// prettier-ignore
$gameMap.changeParallax(
params[0], params[1], params[2], params[3], params[4]
);
return true;
};
// Get Location Info

let x, y, value;
if (params[2] === 0) {
x = params[3];
y = params[4];
} else {
// Designation by a character
const character = this.character(params[3]);
x = character.x;
y = character.y;
}
case 0: // Terrain Tag
value = $gameMap.terrainTag(x, y);
break;
case 1: // Event ID
value = $gameMap.eventIdXy(x, y);
break;
case 2: // Tile ID (Layer 1)
value = $gameMap.tileId(x, y, params[1] - 2);
break;
default:
// Region ID
value = $gameMap.regionId(x, y);
break;
}
$gameVariables.setValue(params[0], value);
return true;
};
// Battle Processing
let troopId;
if (params[0] === 0) {
troopId = params[1];
// Designation with a variable
troopId = $gameVariables.value(params[1]);
} else {
// Same as Random Encounters
troopId = $gamePlayer.makeEncounterTroopId();
}
if ($dataTroops[troopId]) {
BattleManager.setup(troopId, params[2], params[3]);
BattleManager.setEventCallback(n => {
this._branch[this._indent] = n;
});
$gamePlayer.makeEncounterCount();
SceneManager.push(Scene_Battle);
}
}
return true;
};
// If Win
if (this._branch[this._indent] !== 0) {
this.skipBranch();
}
return true;
};
// If Escape
this.skipBranch();
}
return true;
};
// If Lose
this.skipBranch();
}
return true;
};
// Shop Processing
const goods = [params];
this._index++;
goods.push(this.currentCommand().parameters);
}
SceneManager.push(Scene_Shop);
SceneManager.prepareNextScene(goods, params[4]);
}
return true;
};
// Name Input Processing

if ($dataActors[params[0]]) {
SceneManager.push(Scene_Name);
SceneManager.prepareNextScene(params[0], params[1]);
}
}
return true;
};
// Change HP
this.iterateActorEx(params[0], params[1], actor => {
this.changeHp(actor, value, params[5]);
});
return true;
};
// Change MP
actor.gainMp(value);
});
return true;
};
// Change TP
actor.gainTp(value);
});
return true;
};
// Change State
const alreadyDead = actor.isDead();
if (params[2] === 0) {
actor.addState(params[3]);
} else {
actor.removeState(params[3]);
}
if (actor.isDead() && !alreadyDead) {
actor.performCollapse();
}
actor.clearResult();
});
return true;
};
// Recover All
actor.recoverAll();
});
return true;
};
// Change EXP
actor.changeExp(actor.currentExp() + value, params[5]);
});
return true;
};
// Change Level
actor.changeLevel(actor.level + value, params[5]);
});
return true;
};
// Change Parameter
actor.addParam(params[2], value);
});
return true;
};
// Change Skill
if (params[2] === 0) {
actor.learnSkill(params[3]);
} else {
actor.forgetSkill(params[3]);
}
});
return true;
};
// Change Equipment
if (actor) {
actor.changeEquipById(params[1], params[2]);
}
return true;
};
// Change Name
if (actor) {
actor.setName(params[1]);
}
return true;
};
// Change Class
if (actor && $dataClasses[params[1]]) {
actor.changeClass(params[1], params[2]);
}
return true;
};
// Change Actor Images

if (actor) {
actor.setCharacterImage(params[1], params[2]);
actor.setFaceImage(params[3], params[4]);
actor.setBattlerImage(params[5]);
}
return true;
};
// Change Vehicle Image

if (vehicle) {
vehicle.setImage(params[1], params[2]);
}
return true;
};
// Change Nickname
if (actor) {
actor.setNickname(params[1]);
}
return true;
};
// Change Profile
if (actor) {
actor.setProfile(params[1]);
}
return true;
};
// Change Enemy HP
this.iterateEnemyIndex(params[0], enemy => {
this.changeHp(enemy, value, params[4]);
});
return true;
};
// Change Enemy MP
enemy.gainMp(value);
});
return true;
};
// Change Enemy TP
enemy.gainTp(value);
});
return true;
};
// Change Enemy State

const alreadyDead = enemy.isDead();
if (params[1] === 0) {
enemy.addState(params[2]);
} else {
enemy.removeState(params[2]);
}
if (enemy.isDead() && !alreadyDead) {
enemy.performCollapse();
}
enemy.clearResult();
});
return true;
};
// Enemy Recover All

enemy.recoverAll();
});
return true;
};
// Enemy Appear
enemy.appear();
$gameTroop.makeUniqueNames();
});
return true;
};
// Enemy Transform
enemy.transform(params[1]);
$gameTroop.makeUniqueNames();
});
return true;
};
// Show Battle Animation

let param = params[0];
if (params[2]) {
param = -1;
}
const targets = [];
this.iterateEnemyIndex(param, enemy => {
if (enemy.isAlive()) {
targets.push(enemy);
}
});
$gameTemp.requestAnimation(targets, params[1]);
return true;
};
// Force Action
this.iterateBattler(params[0], params[1], battler => {
if (!battler.isDeathStateAffected()) {
battler.forceAction(params[2], params[3]);
BattleManager.forceAction(battler);
this.setWaitMode("action");
}
});
return true;
};
// Abort Battle
BattleManager.abort();
return true;
};
// Open Menu Screen

SceneManager.push(Scene_Menu);
Window_MenuCommand.initCommandPosition();
}
return true;
};
// Open Save Screen

SceneManager.push(Scene_Save);
}
return true;
};
// Game Over
SceneManager.goto(Scene_Gameover);
return true;
};
// Return to Title Screen

SceneManager.goto(Scene_Title);
return true;
};
// Script
let script = this.currentCommand().parameters[0] + "\n";
this._index++;
script += this.currentCommand().parameters[0] + "\n";
}
eval(script);
return true;
};
// Plugin Command MV (deprecated)

const args = params[0].split(" ");
const command = args.shift();
this.pluginCommand(command, args);
return true;
};
Game_Interpreter.prototype.pluginCommand = function() {
// deprecated
};
// Plugin Command
const pluginName = Utils.extractFileName(params[0]);
PluginManager.callCommand(this, pluginName, params[1], params[3]);
return true;
};
//-----------------------------------------------------------------------------

RMMZ Objects

Uploaded by

Copyright:

Available Formats

You might also like

RMMZ Objects

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

RMMZ Objects

Uploaded by

Copyright:

Available Formats

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

Game_Temp.prototype.setTouchState = function(target, state) {

Game_Temp.prototype.requestBalloon = function(target, balloonId) {

Game_Temp.prototype.setLastActionData = function(type, value) {

Game_Message.prototype.setFaceImage = function(faceName, faceIndex) {

Game_Message.prototype.setChoices = function(choices, defaultType, cancelType) {

Game_Message.prototype.setNumberInput = function(variableId, maxDigits) {

Game_Message.prototype.setItemChoice = function(variableId, itemType) {

Game_Message.prototype.setScroll = function(speed, noFast) {

Game_Switches.prototype.setValue = function(switchId, value) {

Game_Variables.prototype.setValue = function(variableId, value) {

Game_SelfSwitches.prototype.setValue = function(key, value) {

Game_Screen.prototype.startTint = function(tone, duration) {

Game_Screen.prototype.startFlash = function(color, duration) {

Game_Screen.prototype.startShake = function(power, speed, duration) {

Game_Screen.prototype.startZoom = function(x, y, scale, duration) {

Game_Screen.prototype.setZoom = function(x, y, scale) {

Game_Screen.prototype.rotatePicture = function(pictureId, speed) {

Game_Screen.prototype.tintPicture = function(pictureId, tone, duration) {

Game_Picture.prototype.tint = function(tone, duration) {

Game_Picture.prototype.applyEasing = function(current, target) {

Game_Picture.prototype.easeIn = function(t, exponent) {

Game_Picture.prototype.easeOut = function(t, exponent) {

Game_Picture.prototype.easeInOut = function(t, exponent) {

Game_Item.prototype.setEquip = function(isWeapon, itemId) {

Game_Action.prototype.initialize = function(subject, forcing) {

Game_Action.prototype.testItemEffect = function(target, effect) {

Game_Action.prototype.makeDamageValue = function(target, critical) {

Game_Action.prototype.elementsMaxRate = function(target, elements) {

Game_Action.prototype.applyVariance = function(damage, variance) {

Game_Action.prototype.applyGuard = function(damage, target) {

Game_Action.prototype.executeDamage = function(target, value) {

Game_Action.prototype.executeHpDamage = function(target, value) {

Game_Action.prototype.executeMpDamage = function(target, value) {

Game_Action.prototype.applyItemEffect = function(target, effect) {

Game_Action.prototype.itemEffectRecoverHp = function(target, effect) {

Game_Action.prototype.itemEffectRecoverMp = function(target, effect) {

Game_Action.prototype.itemEffectGainTp = function(target, effect) {

Game_Action.prototype.itemEffectAddState = function(target, effect) {

Game_Action.prototype.itemEffectAddAttackState = function(target, effect) {

Game_Action.prototype.itemEffectAddNormalState = function(target, effect) {

Game_Action.prototype.itemEffectRemoveState = function(target, effect) {

Game_Action.prototype.itemEffectAddBuff = function(target, effect) {

Game_Action.prototype.itemEffectAddDebuff = function(target, effect) {

Game_Action.prototype.itemEffectRemoveBuff = function(target, effect) {

Game_Action.prototype.itemEffectRemoveDebuff = function(target, effect) {

Game_Action.prototype.itemEffectSpecial = function(target, effect) {

Game_Action.prototype.itemEffectGrow = function(target, effect) {

Game_Action.prototype.itemEffectLearnSkill = function(target, effect) {

Game_Action.prototype.itemEffectCommonEvent = function(/*target, effect*/) {

Game_BattlerBase.prototype.overwriteBuffTurns = function(paramId, turns) {

Game_BattlerBase.prototype.buffIconIndex = function(buffLevel, paramId) {

Game_BattlerBase.prototype.traitsWithId = function(code, id) {

Game_BattlerBase.prototype.traitsPi = function(code, id) {

Game_BattlerBase.prototype.traitsSum = function(code, id) {

Game_BattlerBase.prototype.addParam = function(paramId, value) {

Game_Battler.prototype.setAction = function(index, action) {

Game_Battler.prototype.addBuff = function(paramId, turns) {

Game_Action.prototype.itemEffectCommonEvent = function(/target, effect/) {

Game_CharacterBase.prototype.checkEventTriggerTouch = function(/x, y/) {

Game_CharacterBase.prototype.isMovementSucceeded = function(/x, y/) {