generated from nhcarrigan/template
6631 lines
190 KiB
JavaScript
6631 lines
190 KiB
JavaScript
//=============================================================================
|
||
// rmmz_windows.js v1.4.4
|
||
//=============================================================================
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Window_Base
|
||
//
|
||
// The superclass of all windows within the game.
|
||
|
||
function Window_Base() {
|
||
this.initialize(...arguments);
|
||
}
|
||
|
||
Window_Base.prototype = Object.create(Window.prototype);
|
||
Window_Base.prototype.constructor = Window_Base;
|
||
|
||
Window_Base.prototype.initialize = function(rect) {
|
||
Window.prototype.initialize.call(this);
|
||
this.loadWindowskin();
|
||
this.checkRectObject(rect);
|
||
this.move(rect.x, rect.y, rect.width, rect.height);
|
||
this.updatePadding();
|
||
this.updateBackOpacity();
|
||
this.updateTone();
|
||
this.createContents();
|
||
this._opening = false;
|
||
this._closing = false;
|
||
this._dimmerSprite = null;
|
||
};
|
||
|
||
Window_Base.prototype.destroy = function(options) {
|
||
this.destroyContents();
|
||
if (this._dimmerSprite) {
|
||
this._dimmerSprite.bitmap.destroy();
|
||
}
|
||
Window.prototype.destroy.call(this, options);
|
||
};
|
||
|
||
Window_Base.prototype.checkRectObject = function(rect) {
|
||
if (typeof rect !== "object" || !("x" in rect)) {
|
||
// Probably MV plugin is used
|
||
throw new Error("Argument must be a Rectangle");
|
||
}
|
||
};
|
||
|
||
Window_Base.prototype.lineHeight = function() {
|
||
return 36;
|
||
};
|
||
|
||
Window_Base.prototype.itemWidth = function() {
|
||
return this.innerWidth;
|
||
};
|
||
|
||
Window_Base.prototype.itemHeight = function() {
|
||
return this.lineHeight();
|
||
};
|
||
|
||
Window_Base.prototype.itemPadding = function() {
|
||
return 8;
|
||
};
|
||
|
||
Window_Base.prototype.baseTextRect = function() {
|
||
const rect = new Rectangle(0, 0, this.innerWidth, this.innerHeight);
|
||
rect.pad(-this.itemPadding(), 0);
|
||
return rect;
|
||
};
|
||
|
||
Window_Base.prototype.loadWindowskin = function() {
|
||
this.windowskin = ImageManager.loadSystem("Window");
|
||
};
|
||
|
||
Window_Base.prototype.updatePadding = function() {
|
||
this.padding = $gameSystem.windowPadding();
|
||
};
|
||
|
||
Window_Base.prototype.updateBackOpacity = function() {
|
||
this.backOpacity = $gameSystem.windowOpacity();
|
||
};
|
||
|
||
Window_Base.prototype.fittingHeight = function(numLines) {
|
||
return numLines * this.itemHeight() + $gameSystem.windowPadding() * 2;
|
||
};
|
||
|
||
Window_Base.prototype.updateTone = function() {
|
||
const tone = $gameSystem.windowTone();
|
||
this.setTone(tone[0], tone[1], tone[2]);
|
||
};
|
||
|
||
Window_Base.prototype.createContents = function() {
|
||
const width = this.contentsWidth();
|
||
const height = this.contentsHeight();
|
||
this.destroyContents();
|
||
this.contents = new Bitmap(width, height);
|
||
this.contentsBack = new Bitmap(width, height);
|
||
this.resetFontSettings();
|
||
};
|
||
|
||
Window_Base.prototype.destroyContents = function() {
|
||
if (this.contents) {
|
||
this.contents.destroy();
|
||
}
|
||
if (this.contentsBack) {
|
||
this.contentsBack.destroy();
|
||
}
|
||
};
|
||
|
||
Window_Base.prototype.contentsWidth = function() {
|
||
return this.innerWidth;
|
||
};
|
||
|
||
Window_Base.prototype.contentsHeight = function() {
|
||
return this.innerHeight;
|
||
};
|
||
|
||
Window_Base.prototype.resetFontSettings = function() {
|
||
this.contents.fontFace = $gameSystem.mainFontFace();
|
||
this.contents.fontSize = $gameSystem.mainFontSize();
|
||
this.resetTextColor();
|
||
};
|
||
|
||
Window_Base.prototype.resetTextColor = function() {
|
||
this.changeTextColor(ColorManager.normalColor());
|
||
this.changeOutlineColor(ColorManager.outlineColor());
|
||
};
|
||
|
||
Window_Base.prototype.update = function() {
|
||
Window.prototype.update.call(this);
|
||
this.updateTone();
|
||
this.updateOpen();
|
||
this.updateClose();
|
||
this.updateBackgroundDimmer();
|
||
};
|
||
|
||
Window_Base.prototype.updateOpen = function() {
|
||
if (this._opening) {
|
||
this.openness += 32;
|
||
if (this.isOpen()) {
|
||
this._opening = false;
|
||
}
|
||
}
|
||
};
|
||
|
||
Window_Base.prototype.updateClose = function() {
|
||
if (this._closing) {
|
||
this.openness -= 32;
|
||
if (this.isClosed()) {
|
||
this._closing = false;
|
||
}
|
||
}
|
||
};
|
||
|
||
Window_Base.prototype.open = function() {
|
||
if (!this.isOpen()) {
|
||
this._opening = true;
|
||
}
|
||
this._closing = false;
|
||
};
|
||
|
||
Window_Base.prototype.close = function() {
|
||
if (!this.isClosed()) {
|
||
this._closing = true;
|
||
}
|
||
this._opening = false;
|
||
};
|
||
|
||
Window_Base.prototype.isOpening = function() {
|
||
return this._opening;
|
||
};
|
||
|
||
Window_Base.prototype.isClosing = function() {
|
||
return this._closing;
|
||
};
|
||
|
||
Window_Base.prototype.show = function() {
|
||
this.visible = true;
|
||
};
|
||
|
||
Window_Base.prototype.hide = function() {
|
||
this.visible = false;
|
||
};
|
||
|
||
Window_Base.prototype.activate = function() {
|
||
this.active = true;
|
||
};
|
||
|
||
Window_Base.prototype.deactivate = function() {
|
||
this.active = false;
|
||
};
|
||
|
||
Window_Base.prototype.systemColor = function() {
|
||
return ColorManager.systemColor();
|
||
};
|
||
|
||
Window_Base.prototype.translucentOpacity = function() {
|
||
return 160;
|
||
};
|
||
|
||
Window_Base.prototype.changeTextColor = function(color) {
|
||
this.contents.textColor = color;
|
||
};
|
||
|
||
Window_Base.prototype.changeOutlineColor = function(color) {
|
||
this.contents.outlineColor = color;
|
||
};
|
||
|
||
Window_Base.prototype.changePaintOpacity = function(enabled) {
|
||
this.contents.paintOpacity = enabled ? 255 : this.translucentOpacity();
|
||
};
|
||
|
||
Window_Base.prototype.drawRect = function(x, y, width, height) {
|
||
const outlineColor = this.contents.outlineColor;
|
||
const mainColor = this.contents.textColor;
|
||
this.contents.fillRect(x, y, width, height, outlineColor);
|
||
this.contents.fillRect(x + 1, y + 1, width - 2, height - 2, mainColor);
|
||
};
|
||
|
||
Window_Base.prototype.drawText = function(text, x, y, maxWidth, align) {
|
||
this.contents.drawText(text, x, y, maxWidth, this.lineHeight(), align);
|
||
};
|
||
|
||
Window_Base.prototype.textWidth = function(text) {
|
||
return this.contents.measureTextWidth(text);
|
||
};
|
||
|
||
Window_Base.prototype.drawTextEx = function(text, x, y, width) {
|
||
this.resetFontSettings();
|
||
const textState = this.createTextState(text, x, y, width);
|
||
this.processAllText(textState);
|
||
return textState.outputWidth;
|
||
};
|
||
|
||
Window_Base.prototype.textSizeEx = function(text) {
|
||
this.resetFontSettings();
|
||
const textState = this.createTextState(text, 0, 0, 0);
|
||
textState.drawing = false;
|
||
this.processAllText(textState);
|
||
return { width: textState.outputWidth, height: textState.outputHeight };
|
||
};
|
||
|
||
Window_Base.prototype.createTextState = function(text, x, y, width) {
|
||
const rtl = Utils.containsArabic(text);
|
||
const textState = {};
|
||
textState.text = this.convertEscapeCharacters(text);
|
||
textState.index = 0;
|
||
textState.x = rtl ? x + width : x;
|
||
textState.y = y;
|
||
textState.width = width;
|
||
textState.height = this.calcTextHeight(textState);
|
||
textState.startX = textState.x;
|
||
textState.startY = textState.y;
|
||
textState.rtl = rtl;
|
||
textState.buffer = this.createTextBuffer(rtl);
|
||
textState.drawing = true;
|
||
textState.outputWidth = 0;
|
||
textState.outputHeight = 0;
|
||
return textState;
|
||
};
|
||
|
||
Window_Base.prototype.processAllText = function(textState) {
|
||
while (textState.index < textState.text.length) {
|
||
this.processCharacter(textState);
|
||
}
|
||
this.flushTextState(textState);
|
||
};
|
||
|
||
Window_Base.prototype.flushTextState = function(textState) {
|
||
const text = textState.buffer;
|
||
const rtl = textState.rtl;
|
||
const width = this.textWidth(text);
|
||
const height = textState.height;
|
||
const x = rtl ? textState.x - width : textState.x;
|
||
const y = textState.y;
|
||
if (textState.drawing) {
|
||
this.contents.drawText(text, x, y, width, height);
|
||
}
|
||
textState.x += rtl ? -width : width;
|
||
textState.buffer = this.createTextBuffer(rtl);
|
||
const outputWidth = Math.abs(textState.x - textState.startX);
|
||
if (textState.outputWidth < outputWidth) {
|
||
textState.outputWidth = outputWidth;
|
||
}
|
||
textState.outputHeight = y - textState.startY + height;
|
||
};
|
||
|
||
Window_Base.prototype.createTextBuffer = function(rtl) {
|
||
// U+202B: RIGHT-TO-LEFT EMBEDDING
|
||
return rtl ? "\u202B" : "";
|
||
};
|
||
|
||
Window_Base.prototype.convertEscapeCharacters = function(text) {
|
||
/* eslint no-control-regex: 0 */
|
||
text = text.replace(/\\/g, "\x1b");
|
||
text = text.replace(/\x1b\x1b/g, "\\");
|
||
text = text.replace(/\x1bV\[(\d+)\]/gi, (_, p1) =>
|
||
$gameVariables.value(parseInt(p1))
|
||
);
|
||
text = text.replace(/\x1bV\[(\d+)\]/gi, (_, p1) =>
|
||
$gameVariables.value(parseInt(p1))
|
||
);
|
||
text = text.replace(/\x1bN\[(\d+)\]/gi, (_, p1) =>
|
||
this.actorName(parseInt(p1))
|
||
);
|
||
text = text.replace(/\x1bP\[(\d+)\]/gi, (_, p1) =>
|
||
this.partyMemberName(parseInt(p1))
|
||
);
|
||
text = text.replace(/\x1bG/gi, TextManager.currencyUnit);
|
||
return text;
|
||
};
|
||
|
||
Window_Base.prototype.actorName = function(n) {
|
||
const actor = n >= 1 ? $gameActors.actor(n) : null;
|
||
return actor ? actor.name() : "";
|
||
};
|
||
|
||
Window_Base.prototype.partyMemberName = function(n) {
|
||
const actor = n >= 1 ? $gameParty.members()[n - 1] : null;
|
||
return actor ? actor.name() : "";
|
||
};
|
||
|
||
Window_Base.prototype.processCharacter = function(textState) {
|
||
const c = textState.text[textState.index++];
|
||
if (c.charCodeAt(0) < 0x20) {
|
||
this.flushTextState(textState);
|
||
this.processControlCharacter(textState, c);
|
||
} else {
|
||
textState.buffer += c;
|
||
}
|
||
};
|
||
|
||
Window_Base.prototype.processControlCharacter = function(textState, c) {
|
||
if (c === "\n") {
|
||
this.processNewLine(textState);
|
||
}
|
||
if (c === "\x1b") {
|
||
const code = this.obtainEscapeCode(textState);
|
||
this.processEscapeCharacter(code, textState);
|
||
}
|
||
};
|
||
|
||
Window_Base.prototype.processNewLine = function(textState) {
|
||
textState.x = textState.startX;
|
||
textState.y += textState.height;
|
||
textState.height = this.calcTextHeight(textState);
|
||
};
|
||
|
||
Window_Base.prototype.obtainEscapeCode = function(textState) {
|
||
const regExp = /^[$.|^!><{}\\]|^[A-Z]+/i;
|
||
const arr = regExp.exec(textState.text.slice(textState.index));
|
||
if (arr) {
|
||
textState.index += arr[0].length;
|
||
return arr[0].toUpperCase();
|
||
} else {
|
||
return "";
|
||
}
|
||
};
|
||
|
||
Window_Base.prototype.obtainEscapeParam = function(textState) {
|
||
const regExp = /^\[\d+\]/;
|
||
const arr = regExp.exec(textState.text.slice(textState.index));
|
||
if (arr) {
|
||
textState.index += arr[0].length;
|
||
return parseInt(arr[0].slice(1));
|
||
} else {
|
||
return "";
|
||
}
|
||
};
|
||
|
||
Window_Base.prototype.processEscapeCharacter = function(code, textState) {
|
||
switch (code) {
|
||
case "C":
|
||
this.processColorChange(this.obtainEscapeParam(textState));
|
||
break;
|
||
case "I":
|
||
this.processDrawIcon(this.obtainEscapeParam(textState), textState);
|
||
break;
|
||
case "PX":
|
||
textState.x = this.obtainEscapeParam(textState);
|
||
break;
|
||
case "PY":
|
||
textState.y = this.obtainEscapeParam(textState);
|
||
break;
|
||
case "FS":
|
||
this.contents.fontSize = this.obtainEscapeParam(textState);
|
||
break;
|
||
case "{":
|
||
this.makeFontBigger();
|
||
break;
|
||
case "}":
|
||
this.makeFontSmaller();
|
||
break;
|
||
}
|
||
};
|
||
|
||
Window_Base.prototype.processColorChange = function(colorIndex) {
|
||
this.changeTextColor(ColorManager.textColor(colorIndex));
|
||
};
|
||
|
||
Window_Base.prototype.processDrawIcon = function(iconIndex, textState) {
|
||
if (textState.drawing) {
|
||
this.drawIcon(iconIndex, textState.x + 2, textState.y + 2);
|
||
}
|
||
textState.x += ImageManager.iconWidth + 4;
|
||
};
|
||
|
||
Window_Base.prototype.makeFontBigger = function() {
|
||
if (this.contents.fontSize <= 96) {
|
||
this.contents.fontSize += 12;
|
||
}
|
||
};
|
||
|
||
Window_Base.prototype.makeFontSmaller = function() {
|
||
if (this.contents.fontSize >= 24) {
|
||
this.contents.fontSize -= 12;
|
||
}
|
||
};
|
||
|
||
Window_Base.prototype.calcTextHeight = function(textState) {
|
||
const lineSpacing = this.lineHeight() - $gameSystem.mainFontSize();
|
||
const lastFontSize = this.contents.fontSize;
|
||
const lines = textState.text.slice(textState.index).split("\n");
|
||
const textHeight = this.maxFontSizeInLine(lines[0]) + lineSpacing;
|
||
this.contents.fontSize = lastFontSize;
|
||
return textHeight;
|
||
};
|
||
|
||
Window_Base.prototype.maxFontSizeInLine = function(line) {
|
||
let maxFontSize = this.contents.fontSize;
|
||
const regExp = /\x1b({|}|FS)(\[(\d+)])?/gi;
|
||
for (;;) {
|
||
const array = regExp.exec(line);
|
||
if (!array) {
|
||
break;
|
||
}
|
||
const code = String(array[1]).toUpperCase();
|
||
if (code === "{") {
|
||
this.makeFontBigger();
|
||
} else if (code === "}") {
|
||
this.makeFontSmaller();
|
||
} else if (code === "FS") {
|
||
this.contents.fontSize = parseInt(array[3]);
|
||
}
|
||
if (this.contents.fontSize > maxFontSize) {
|
||
maxFontSize = this.contents.fontSize;
|
||
}
|
||
}
|
||
return maxFontSize;
|
||
};
|
||
|
||
Window_Base.prototype.drawIcon = function(iconIndex, x, y) {
|
||
const bitmap = ImageManager.loadSystem("IconSet");
|
||
const pw = ImageManager.iconWidth;
|
||
const ph = ImageManager.iconHeight;
|
||
const sx = (iconIndex % 16) * pw;
|
||
const sy = Math.floor(iconIndex / 16) * ph;
|
||
this.contents.blt(bitmap, sx, sy, pw, ph, x, y);
|
||
};
|
||
|
||
// prettier-ignore
|
||
Window_Base.prototype.drawFace = function(
|
||
faceName, faceIndex, x, y, width, height
|
||
) {
|
||
width = width || ImageManager.faceWidth;
|
||
height = height || ImageManager.faceHeight;
|
||
const bitmap = ImageManager.loadFace(faceName);
|
||
const pw = ImageManager.faceWidth;
|
||
const ph = ImageManager.faceHeight;
|
||
const sw = Math.min(width, pw);
|
||
const sh = Math.min(height, ph);
|
||
const dx = Math.floor(x + Math.max(width - pw, 0) / 2);
|
||
const dy = Math.floor(y + Math.max(height - ph, 0) / 2);
|
||
const sx = Math.floor((faceIndex % 4) * pw + (pw - sw) / 2);
|
||
const sy = Math.floor(Math.floor(faceIndex / 4) * ph + (ph - sh) / 2);
|
||
this.contents.blt(bitmap, sx, sy, sw, sh, dx, dy);
|
||
};
|
||
|
||
// prettier-ignore
|
||
Window_Base.prototype.drawCharacter = function(
|
||
characterName, characterIndex, x, y
|
||
) {
|
||
const bitmap = ImageManager.loadCharacter(characterName);
|
||
const big = ImageManager.isBigCharacter(characterName);
|
||
const pw = bitmap.width / (big ? 3 : 12);
|
||
const ph = bitmap.height / (big ? 4 : 8);
|
||
const n = big ? 0: characterIndex;
|
||
const sx = ((n % 4) * 3 + 1) * pw;
|
||
const sy = Math.floor(n / 4) * 4 * ph;
|
||
this.contents.blt(bitmap, sx, sy, pw, ph, x - pw / 2, y - ph);
|
||
};
|
||
|
||
Window_Base.prototype.drawItemName = function(item, x, y, width) {
|
||
if (item) {
|
||
const iconY = y + (this.lineHeight() - ImageManager.iconHeight) / 2;
|
||
const textMargin = ImageManager.iconWidth + 4;
|
||
const itemWidth = Math.max(0, width - textMargin);
|
||
this.resetTextColor();
|
||
this.drawIcon(item.iconIndex, x, iconY);
|
||
this.drawText(item.name, x + textMargin, y, itemWidth);
|
||
}
|
||
};
|
||
|
||
Window_Base.prototype.drawCurrencyValue = function(value, unit, x, y, width) {
|
||
const unitWidth = Math.min(80, this.textWidth(unit));
|
||
this.resetTextColor();
|
||
this.drawText(value, x, y, width - unitWidth - 6, "right");
|
||
this.changeTextColor(ColorManager.systemColor());
|
||
this.drawText(unit, x + width - unitWidth, y, unitWidth, "right");
|
||
};
|
||
|
||
Window_Base.prototype.setBackgroundType = function(type) {
|
||
if (type === 0) {
|
||
this.opacity = 255;
|
||
} else {
|
||
this.opacity = 0;
|
||
}
|
||
if (type === 1) {
|
||
this.showBackgroundDimmer();
|
||
} else {
|
||
this.hideBackgroundDimmer();
|
||
}
|
||
};
|
||
|
||
Window_Base.prototype.showBackgroundDimmer = function() {
|
||
if (!this._dimmerSprite) {
|
||
this.createDimmerSprite();
|
||
}
|
||
const bitmap = this._dimmerSprite.bitmap;
|
||
if (bitmap.width !== this.width || bitmap.height !== this.height) {
|
||
this.refreshDimmerBitmap();
|
||
}
|
||
this._dimmerSprite.visible = true;
|
||
this.updateBackgroundDimmer();
|
||
};
|
||
|
||
Window_Base.prototype.createDimmerSprite = function() {
|
||
this._dimmerSprite = new Sprite();
|
||
this._dimmerSprite.bitmap = new Bitmap(0, 0);
|
||
this._dimmerSprite.x = -4;
|
||
this.addChildToBack(this._dimmerSprite);
|
||
};
|
||
|
||
Window_Base.prototype.hideBackgroundDimmer = function() {
|
||
if (this._dimmerSprite) {
|
||
this._dimmerSprite.visible = false;
|
||
}
|
||
};
|
||
|
||
Window_Base.prototype.updateBackgroundDimmer = function() {
|
||
if (this._dimmerSprite) {
|
||
this._dimmerSprite.opacity = this.openness;
|
||
}
|
||
};
|
||
|
||
Window_Base.prototype.refreshDimmerBitmap = function() {
|
||
if (this._dimmerSprite) {
|
||
const bitmap = this._dimmerSprite.bitmap;
|
||
const w = this.width > 0 ? this.width + 8 : 0;
|
||
const h = this.height;
|
||
const m = this.padding;
|
||
const c1 = ColorManager.dimColor1();
|
||
const c2 = ColorManager.dimColor2();
|
||
bitmap.resize(w, h);
|
||
bitmap.gradientFillRect(0, 0, w, m, c2, c1, true);
|
||
bitmap.fillRect(0, m, w, h - m * 2, c1);
|
||
bitmap.gradientFillRect(0, h - m, w, m, c1, c2, true);
|
||
this._dimmerSprite.setFrame(0, 0, w, h);
|
||
}
|
||
};
|
||
|
||
Window_Base.prototype.playCursorSound = function() {
|
||
SoundManager.playCursor();
|
||
};
|
||
|
||
Window_Base.prototype.playOkSound = function() {
|
||
SoundManager.playOk();
|
||
};
|
||
|
||
Window_Base.prototype.playBuzzerSound = function() {
|
||
SoundManager.playBuzzer();
|
||
};
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Window_Scrollable
|
||
//
|
||
// The window class with scroll functions.
|
||
|
||
function Window_Scrollable() {
|
||
this.initialize(...arguments);
|
||
}
|
||
|
||
Window_Scrollable.prototype = Object.create(Window_Base.prototype);
|
||
Window_Scrollable.prototype.constructor = Window_Scrollable;
|
||
|
||
Window_Scrollable.prototype.initialize = function(rect) {
|
||
Window_Base.prototype.initialize.call(this, rect);
|
||
this._scrollX = 0;
|
||
this._scrollY = 0;
|
||
this._scrollBaseX = 0;
|
||
this._scrollBaseY = 0;
|
||
this.clearScrollStatus();
|
||
};
|
||
|
||
Window_Scrollable.prototype.clearScrollStatus = function() {
|
||
this._scrollTargetX = 0;
|
||
this._scrollTargetY = 0;
|
||
this._scrollDuration = 0;
|
||
this._scrollAccelX = 0;
|
||
this._scrollAccelY = 0;
|
||
this._scrollTouching = false;
|
||
this._scrollLastTouchX = 0;
|
||
this._scrollLastTouchY = 0;
|
||
this._scrollLastCursorVisible = false;
|
||
};
|
||
|
||
Window_Scrollable.prototype.scrollX = function() {
|
||
return this._scrollX;
|
||
};
|
||
|
||
Window_Scrollable.prototype.scrollY = function() {
|
||
return this._scrollY;
|
||
};
|
||
|
||
Window_Scrollable.prototype.scrollBaseX = function() {
|
||
return this._scrollBaseX;
|
||
};
|
||
|
||
Window_Scrollable.prototype.scrollBaseY = function() {
|
||
return this._scrollBaseY;
|
||
};
|
||
|
||
Window_Scrollable.prototype.scrollTo = function(x, y) {
|
||
const scrollX = x.clamp(0, this.maxScrollX());
|
||
const scrollY = y.clamp(0, this.maxScrollY());
|
||
if (this._scrollX !== scrollX || this._scrollY !== scrollY) {
|
||
this._scrollX = scrollX;
|
||
this._scrollY = scrollY;
|
||
this.updateOrigin();
|
||
}
|
||
};
|
||
|
||
Window_Scrollable.prototype.scrollBy = function(x, y) {
|
||
this.scrollTo(this._scrollX + x, this._scrollY + y);
|
||
};
|
||
|
||
Window_Scrollable.prototype.smoothScrollTo = function(x, y) {
|
||
this._scrollTargetX = x.clamp(0, this.maxScrollX());
|
||
this._scrollTargetY = y.clamp(0, this.maxScrollY());
|
||
this._scrollDuration = Input.keyRepeatInterval;
|
||
};
|
||
|
||
Window_Scrollable.prototype.smoothScrollBy = function(x, y) {
|
||
if (this._scrollDuration === 0) {
|
||
this._scrollTargetX = this.scrollX();
|
||
this._scrollTargetY = this.scrollY();
|
||
}
|
||
this.smoothScrollTo(this._scrollTargetX + x, this._scrollTargetY + y);
|
||
};
|
||
|
||
Window_Scrollable.prototype.setScrollAccel = function(x, y) {
|
||
this._scrollAccelX = x;
|
||
this._scrollAccelY = y;
|
||
};
|
||
|
||
Window_Scrollable.prototype.overallWidth = function() {
|
||
return this.innerWidth;
|
||
};
|
||
|
||
Window_Scrollable.prototype.overallHeight = function() {
|
||
return this.innerHeight;
|
||
};
|
||
|
||
Window_Scrollable.prototype.maxScrollX = function() {
|
||
return Math.max(0, this.overallWidth() - this.innerWidth);
|
||
};
|
||
|
||
Window_Scrollable.prototype.maxScrollY = function() {
|
||
return Math.max(0, this.overallHeight() - this.innerHeight);
|
||
};
|
||
|
||
Window_Scrollable.prototype.scrollBlockWidth = function() {
|
||
return this.itemWidth();
|
||
};
|
||
|
||
Window_Scrollable.prototype.scrollBlockHeight = function() {
|
||
return this.itemHeight();
|
||
};
|
||
|
||
Window_Scrollable.prototype.smoothScrollDown = function(n) {
|
||
this.smoothScrollBy(0, this.itemHeight() * n);
|
||
};
|
||
|
||
Window_Scrollable.prototype.smoothScrollUp = function(n) {
|
||
this.smoothScrollBy(0, -this.itemHeight() * n);
|
||
};
|
||
|
||
Window_Scrollable.prototype.update = function() {
|
||
Window_Base.prototype.update.call(this);
|
||
this.processWheelScroll();
|
||
this.processTouchScroll();
|
||
this.updateSmoothScroll();
|
||
this.updateScrollAccel();
|
||
this.updateArrows();
|
||
this.updateOrigin();
|
||
};
|
||
|
||
Window_Scrollable.prototype.processWheelScroll = function() {
|
||
if (this.isWheelScrollEnabled() && this.isTouchedInsideFrame()) {
|
||
const threshold = 20;
|
||
if (TouchInput.wheelY >= threshold) {
|
||
this.smoothScrollDown(1);
|
||
}
|
||
if (TouchInput.wheelY <= -threshold) {
|
||
this.smoothScrollUp(1);
|
||
}
|
||
}
|
||
};
|
||
|
||
Window_Scrollable.prototype.processTouchScroll = function() {
|
||
if (this.isTouchScrollEnabled()) {
|
||
if (TouchInput.isTriggered() && this.isTouchedInsideFrame()) {
|
||
this.onTouchScrollStart();
|
||
}
|
||
if (this._scrollTouching) {
|
||
if (TouchInput.isReleased()) {
|
||
this.onTouchScrollEnd();
|
||
} else if (TouchInput.isMoved()) {
|
||
this.onTouchScroll();
|
||
}
|
||
}
|
||
}
|
||
};
|
||
|
||
Window_Scrollable.prototype.isWheelScrollEnabled = function() {
|
||
return this.isScrollEnabled();
|
||
};
|
||
|
||
Window_Scrollable.prototype.isTouchScrollEnabled = function() {
|
||
return this.isScrollEnabled();
|
||
};
|
||
|
||
Window_Scrollable.prototype.isScrollEnabled = function() {
|
||
return true;
|
||
};
|
||
|
||
Window_Scrollable.prototype.isTouchedInsideFrame = function() {
|
||
const touchPos = new Point(TouchInput.x, TouchInput.y);
|
||
const localPos = this.worldTransform.applyInverse(touchPos);
|
||
return this.innerRect.contains(localPos.x, localPos.y);
|
||
};
|
||
|
||
Window_Scrollable.prototype.onTouchScrollStart = function() {
|
||
this._scrollTouching = true;
|
||
this._scrollLastTouchX = TouchInput.x;
|
||
this._scrollLastTouchY = TouchInput.y;
|
||
this._scrollLastCursorVisible = this.cursorVisible;
|
||
this.setScrollAccel(0, 0);
|
||
};
|
||
|
||
Window_Scrollable.prototype.onTouchScroll = function() {
|
||
const accelX = this._scrollLastTouchX - TouchInput.x;
|
||
const accelY = this._scrollLastTouchY - TouchInput.y;
|
||
this.setScrollAccel(accelX, accelY);
|
||
this._scrollLastTouchX = TouchInput.x;
|
||
this._scrollLastTouchY = TouchInput.y;
|
||
this.cursorVisible = false;
|
||
};
|
||
|
||
Window_Scrollable.prototype.onTouchScrollEnd = function() {
|
||
this._scrollTouching = false;
|
||
this.cursorVisible = this._scrollLastCursorVisible;
|
||
};
|
||
|
||
Window_Scrollable.prototype.updateSmoothScroll = function() {
|
||
if (this._scrollDuration > 0) {
|
||
const d = this._scrollDuration;
|
||
const deltaX = (this._scrollTargetX - this._scrollX) / d;
|
||
const deltaY = (this._scrollTargetY - this._scrollY) / d;
|
||
this.scrollBy(deltaX, deltaY);
|
||
this._scrollDuration--;
|
||
}
|
||
};
|
||
|
||
Window_Scrollable.prototype.updateScrollAccel = function() {
|
||
if (this._scrollAccelX !== 0 || this._scrollAccelY !== 0) {
|
||
this.scrollBy(this._scrollAccelX, this._scrollAccelY);
|
||
this._scrollAccelX *= 0.92;
|
||
this._scrollAccelY *= 0.92;
|
||
if (Math.abs(this._scrollAccelX) < 1) {
|
||
this._scrollAccelX = 0;
|
||
}
|
||
if (Math.abs(this._scrollAccelY) < 1) {
|
||
this._scrollAccelY = 0;
|
||
}
|
||
}
|
||
};
|
||
|
||
Window_Scrollable.prototype.updateArrows = function() {
|
||
this.downArrowVisible = this._scrollY < this.maxScrollY();
|
||
this.upArrowVisible = this._scrollY > 0;
|
||
};
|
||
|
||
Window_Scrollable.prototype.updateOrigin = function() {
|
||
const blockWidth = this.scrollBlockWidth() || 1;
|
||
const blockHeight = this.scrollBlockHeight() || 1;
|
||
const baseX = this._scrollX - (this._scrollX % blockWidth);
|
||
const baseY = this._scrollY - (this._scrollY % blockHeight);
|
||
if (baseX !== this._scrollBaseX || baseY !== this._scrollBaseY) {
|
||
this.updateScrollBase(baseX, baseY);
|
||
this.paint();
|
||
}
|
||
this.origin.x = this._scrollX % blockWidth;
|
||
this.origin.y = this._scrollY % blockHeight;
|
||
};
|
||
|
||
Window_Scrollable.prototype.updateScrollBase = function(baseX, baseY) {
|
||
const deltaX = baseX - this._scrollBaseX;
|
||
const deltaY = baseY - this._scrollBaseY;
|
||
this._scrollBaseX = baseX;
|
||
this._scrollBaseY = baseY;
|
||
this.moveCursorBy(-deltaX, -deltaY);
|
||
this.moveInnerChildrenBy(-deltaX, -deltaY);
|
||
};
|
||
|
||
Window_Scrollable.prototype.paint = function() {
|
||
// to be overridden
|
||
};
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Window_Selectable
|
||
//
|
||
// The window class with cursor movement functions.
|
||
|
||
function Window_Selectable() {
|
||
this.initialize(...arguments);
|
||
}
|
||
|
||
Window_Selectable.prototype = Object.create(Window_Scrollable.prototype);
|
||
Window_Selectable.prototype.constructor = Window_Selectable;
|
||
|
||
Window_Selectable.prototype.initialize = function(rect) {
|
||
Window_Scrollable.prototype.initialize.call(this, rect);
|
||
this._index = -1;
|
||
this._cursorFixed = false;
|
||
this._cursorAll = false;
|
||
this._helpWindow = null;
|
||
this._handlers = {};
|
||
this._doubleTouch = false;
|
||
this._canRepeat = true;
|
||
this.deactivate();
|
||
};
|
||
|
||
Window_Selectable.prototype.index = function() {
|
||
return this._index;
|
||
};
|
||
|
||
Window_Selectable.prototype.cursorFixed = function() {
|
||
return this._cursorFixed;
|
||
};
|
||
|
||
Window_Selectable.prototype.setCursorFixed = function(cursorFixed) {
|
||
this._cursorFixed = cursorFixed;
|
||
};
|
||
|
||
Window_Selectable.prototype.cursorAll = function() {
|
||
return this._cursorAll;
|
||
};
|
||
|
||
Window_Selectable.prototype.setCursorAll = function(cursorAll) {
|
||
this._cursorAll = cursorAll;
|
||
};
|
||
|
||
Window_Selectable.prototype.maxCols = function() {
|
||
return 1;
|
||
};
|
||
|
||
Window_Selectable.prototype.maxItems = function() {
|
||
return 0;
|
||
};
|
||
|
||
Window_Selectable.prototype.colSpacing = function() {
|
||
return 8;
|
||
};
|
||
|
||
Window_Selectable.prototype.rowSpacing = function() {
|
||
return 4;
|
||
};
|
||
|
||
Window_Selectable.prototype.itemWidth = function() {
|
||
return Math.floor(this.innerWidth / this.maxCols());
|
||
};
|
||
|
||
Window_Selectable.prototype.itemHeight = function() {
|
||
return Window_Scrollable.prototype.itemHeight.call(this) + 8;
|
||
};
|
||
|
||
Window_Selectable.prototype.contentsHeight = function() {
|
||
return this.innerHeight + this.itemHeight();
|
||
};
|
||
|
||
Window_Selectable.prototype.maxRows = function() {
|
||
return Math.max(Math.ceil(this.maxItems() / this.maxCols()), 1);
|
||
};
|
||
|
||
Window_Selectable.prototype.overallHeight = function() {
|
||
return this.maxRows() * this.itemHeight();
|
||
};
|
||
|
||
Window_Selectable.prototype.activate = function() {
|
||
Window_Scrollable.prototype.activate.call(this);
|
||
this.reselect();
|
||
};
|
||
|
||
Window_Selectable.prototype.deactivate = function() {
|
||
Window_Scrollable.prototype.deactivate.call(this);
|
||
this.reselect();
|
||
};
|
||
|
||
Window_Selectable.prototype.select = function(index) {
|
||
this._index = index;
|
||
this.refreshCursor();
|
||
this.callUpdateHelp();
|
||
};
|
||
|
||
Window_Selectable.prototype.forceSelect = function(index) {
|
||
this.select(index);
|
||
this.ensureCursorVisible(false);
|
||
};
|
||
|
||
Window_Selectable.prototype.smoothSelect = function(index) {
|
||
this.select(index);
|
||
this.ensureCursorVisible(true);
|
||
};
|
||
|
||
Window_Selectable.prototype.deselect = function() {
|
||
this.select(-1);
|
||
};
|
||
|
||
Window_Selectable.prototype.reselect = function() {
|
||
this.select(this._index);
|
||
this.ensureCursorVisible(true);
|
||
this.cursorVisible = true;
|
||
};
|
||
|
||
Window_Selectable.prototype.row = function() {
|
||
return Math.floor(this.index() / this.maxCols());
|
||
};
|
||
|
||
Window_Selectable.prototype.topRow = function() {
|
||
return Math.floor(this.scrollY() / this.itemHeight());
|
||
};
|
||
|
||
Window_Selectable.prototype.maxTopRow = function() {
|
||
return Math.max(0, this.maxRows() - this.maxPageRows());
|
||
};
|
||
|
||
Window_Selectable.prototype.setTopRow = function(row) {
|
||
this.scrollTo(this.scrollX(), row * this.itemHeight());
|
||
};
|
||
|
||
Window_Selectable.prototype.maxPageRows = function() {
|
||
return Math.floor(this.innerHeight / this.itemHeight());
|
||
};
|
||
|
||
Window_Selectable.prototype.maxPageItems = function() {
|
||
return this.maxPageRows() * this.maxCols();
|
||
};
|
||
|
||
Window_Selectable.prototype.maxVisibleItems = function() {
|
||
const visibleRows = Math.ceil(this.contentsHeight() / this.itemHeight());
|
||
return visibleRows * this.maxCols();
|
||
};
|
||
|
||
Window_Selectable.prototype.isHorizontal = function() {
|
||
return this.maxPageRows() === 1;
|
||
};
|
||
|
||
Window_Selectable.prototype.topIndex = function() {
|
||
return this.topRow() * this.maxCols();
|
||
};
|
||
|
||
Window_Selectable.prototype.itemRect = function(index) {
|
||
const maxCols = this.maxCols();
|
||
const itemWidth = this.itemWidth();
|
||
const itemHeight = this.itemHeight();
|
||
const colSpacing = this.colSpacing();
|
||
const rowSpacing = this.rowSpacing();
|
||
const col = index % maxCols;
|
||
const row = Math.floor(index / maxCols);
|
||
const x = col * itemWidth + colSpacing / 2 - this.scrollBaseX();
|
||
const y = row * itemHeight + rowSpacing / 2 - this.scrollBaseY();
|
||
const width = itemWidth - colSpacing;
|
||
const height = itemHeight - rowSpacing;
|
||
return new Rectangle(x, y, width, height);
|
||
};
|
||
|
||
Window_Selectable.prototype.itemRectWithPadding = function(index) {
|
||
const rect = this.itemRect(index);
|
||
const padding = this.itemPadding();
|
||
rect.x += padding;
|
||
rect.width -= padding * 2;
|
||
return rect;
|
||
};
|
||
|
||
Window_Selectable.prototype.itemLineRect = function(index) {
|
||
const rect = this.itemRectWithPadding(index);
|
||
const padding = (rect.height - this.lineHeight()) / 2;
|
||
rect.y += padding;
|
||
rect.height -= padding * 2;
|
||
return rect;
|
||
};
|
||
|
||
Window_Selectable.prototype.setHelpWindow = function(helpWindow) {
|
||
this._helpWindow = helpWindow;
|
||
this.callUpdateHelp();
|
||
};
|
||
|
||
Window_Selectable.prototype.showHelpWindow = function() {
|
||
if (this._helpWindow) {
|
||
this._helpWindow.show();
|
||
}
|
||
};
|
||
|
||
Window_Selectable.prototype.hideHelpWindow = function() {
|
||
if (this._helpWindow) {
|
||
this._helpWindow.hide();
|
||
}
|
||
};
|
||
|
||
Window_Selectable.prototype.setHandler = function(symbol, method) {
|
||
this._handlers[symbol] = method;
|
||
};
|
||
|
||
Window_Selectable.prototype.isHandled = function(symbol) {
|
||
return !!this._handlers[symbol];
|
||
};
|
||
|
||
Window_Selectable.prototype.callHandler = function(symbol) {
|
||
if (this.isHandled(symbol)) {
|
||
this._handlers[symbol]();
|
||
}
|
||
};
|
||
|
||
Window_Selectable.prototype.isOpenAndActive = function() {
|
||
return this.isOpen() && this.visible && this.active;
|
||
};
|
||
|
||
Window_Selectable.prototype.isCursorMovable = function() {
|
||
return (
|
||
this.isOpenAndActive() &&
|
||
!this._cursorFixed &&
|
||
!this._cursorAll &&
|
||
this.maxItems() > 0
|
||
);
|
||
};
|
||
|
||
Window_Selectable.prototype.cursorDown = function(wrap) {
|
||
const index = this.index();
|
||
const maxItems = this.maxItems();
|
||
const maxCols = this.maxCols();
|
||
if (index < maxItems - maxCols || (wrap && maxCols === 1)) {
|
||
this.smoothSelect((index + maxCols) % maxItems);
|
||
}
|
||
};
|
||
|
||
Window_Selectable.prototype.cursorUp = function(wrap) {
|
||
const index = Math.max(0, this.index());
|
||
const maxItems = this.maxItems();
|
||
const maxCols = this.maxCols();
|
||
if (index >= maxCols || (wrap && maxCols === 1)) {
|
||
this.smoothSelect((index - maxCols + maxItems) % maxItems);
|
||
}
|
||
};
|
||
|
||
Window_Selectable.prototype.cursorRight = function(wrap) {
|
||
const index = this.index();
|
||
const maxItems = this.maxItems();
|
||
const maxCols = this.maxCols();
|
||
const horizontal = this.isHorizontal();
|
||
if (maxCols >= 2 && (index < maxItems - 1 || (wrap && horizontal))) {
|
||
this.smoothSelect((index + 1) % maxItems);
|
||
}
|
||
};
|
||
|
||
Window_Selectable.prototype.cursorLeft = function(wrap) {
|
||
const index = Math.max(0, this.index());
|
||
const maxItems = this.maxItems();
|
||
const maxCols = this.maxCols();
|
||
const horizontal = this.isHorizontal();
|
||
if (maxCols >= 2 && (index > 0 || (wrap && horizontal))) {
|
||
this.smoothSelect((index - 1 + maxItems) % maxItems);
|
||
}
|
||
};
|
||
|
||
Window_Selectable.prototype.cursorPagedown = function() {
|
||
const index = this.index();
|
||
const maxItems = this.maxItems();
|
||
if (this.topRow() + this.maxPageRows() < this.maxRows()) {
|
||
this.smoothScrollDown(this.maxPageRows());
|
||
this.select(Math.min(index + this.maxPageItems(), maxItems - 1));
|
||
}
|
||
};
|
||
|
||
Window_Selectable.prototype.cursorPageup = function() {
|
||
const index = this.index();
|
||
if (this.topRow() > 0) {
|
||
this.smoothScrollUp(this.maxPageRows());
|
||
this.select(Math.max(index - this.maxPageItems(), 0));
|
||
}
|
||
};
|
||
|
||
Window_Selectable.prototype.isScrollEnabled = function() {
|
||
return this.active || this.index() < 0;
|
||
};
|
||
|
||
Window_Selectable.prototype.update = function() {
|
||
this.processCursorMove();
|
||
this.processHandling();
|
||
this.processTouch();
|
||
Window_Scrollable.prototype.update.call(this);
|
||
};
|
||
|
||
Window_Selectable.prototype.processCursorMove = function() {
|
||
if (this.isCursorMovable()) {
|
||
const lastIndex = this.index();
|
||
if (Input.isRepeated("down")) {
|
||
this.cursorDown(Input.isTriggered("down"));
|
||
}
|
||
if (Input.isRepeated("up")) {
|
||
this.cursorUp(Input.isTriggered("up"));
|
||
}
|
||
if (Input.isRepeated("right")) {
|
||
this.cursorRight(Input.isTriggered("right"));
|
||
}
|
||
if (Input.isRepeated("left")) {
|
||
this.cursorLeft(Input.isTriggered("left"));
|
||
}
|
||
if (!this.isHandled("pagedown") && Input.isTriggered("pagedown")) {
|
||
this.cursorPagedown();
|
||
}
|
||
if (!this.isHandled("pageup") && Input.isTriggered("pageup")) {
|
||
this.cursorPageup();
|
||
}
|
||
if (this.index() !== lastIndex) {
|
||
this.playCursorSound();
|
||
}
|
||
}
|
||
};
|
||
|
||
Window_Selectable.prototype.processHandling = function() {
|
||
if (this.isOpenAndActive()) {
|
||
if (this.isOkEnabled() && this.isOkTriggered()) {
|
||
return this.processOk();
|
||
}
|
||
if (this.isCancelEnabled() && this.isCancelTriggered()) {
|
||
return this.processCancel();
|
||
}
|
||
if (this.isHandled("pagedown") && Input.isTriggered("pagedown")) {
|
||
return this.processPagedown();
|
||
}
|
||
if (this.isHandled("pageup") && Input.isTriggered("pageup")) {
|
||
return this.processPageup();
|
||
}
|
||
}
|
||
};
|
||
|
||
Window_Selectable.prototype.processTouch = function() {
|
||
if (this.isOpenAndActive()) {
|
||
if (this.isHoverEnabled() && TouchInput.isHovered()) {
|
||
this.onTouchSelect(false);
|
||
} else if (TouchInput.isTriggered()) {
|
||
this.onTouchSelect(true);
|
||
}
|
||
if (TouchInput.isClicked()) {
|
||
this.onTouchOk();
|
||
} else if (TouchInput.isCancelled()) {
|
||
this.onTouchCancel();
|
||
}
|
||
}
|
||
};
|
||
|
||
Window_Selectable.prototype.isHoverEnabled = function() {
|
||
return true;
|
||
};
|
||
|
||
Window_Selectable.prototype.onTouchSelect = function(trigger) {
|
||
this._doubleTouch = false;
|
||
if (this.isCursorMovable()) {
|
||
const lastIndex = this.index();
|
||
const hitIndex = this.hitIndex();
|
||
if (hitIndex >= 0) {
|
||
if (hitIndex === this.index()) {
|
||
this._doubleTouch = true;
|
||
}
|
||
this.select(hitIndex);
|
||
}
|
||
if (trigger && this.index() !== lastIndex) {
|
||
this.playCursorSound();
|
||
}
|
||
}
|
||
};
|
||
|
||
Window_Selectable.prototype.onTouchOk = function() {
|
||
if (this.isTouchOkEnabled()) {
|
||
const hitIndex = this.hitIndex();
|
||
if (this._cursorFixed) {
|
||
if (hitIndex === this.index()) {
|
||
this.processOk();
|
||
}
|
||
} else if (hitIndex >= 0) {
|
||
this.processOk();
|
||
}
|
||
}
|
||
};
|
||
|
||
Window_Selectable.prototype.onTouchCancel = function() {
|
||
if (this.isCancelEnabled()) {
|
||
this.processCancel();
|
||
}
|
||
};
|
||
|
||
Window_Selectable.prototype.hitIndex = function() {
|
||
const touchPos = new Point(TouchInput.x, TouchInput.y);
|
||
const localPos = this.worldTransform.applyInverse(touchPos);
|
||
return this.hitTest(localPos.x, localPos.y);
|
||
};
|
||
|
||
Window_Selectable.prototype.hitTest = function(x, y) {
|
||
if (this.innerRect.contains(x, y)) {
|
||
const cx = this.origin.x + x - this.padding;
|
||
const cy = this.origin.y + y - this.padding;
|
||
const topIndex = this.topIndex();
|
||
for (let i = 0; i < this.maxVisibleItems(); i++) {
|
||
const index = topIndex + i;
|
||
if (index < this.maxItems()) {
|
||
const rect = this.itemRect(index);
|
||
if (rect.contains(cx, cy)) {
|
||
return index;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
return -1;
|
||
};
|
||
|
||
Window_Selectable.prototype.isTouchOkEnabled = function() {
|
||
return (
|
||
this.isOkEnabled() &&
|
||
(this._cursorFixed || this._cursorAll || this._doubleTouch)
|
||
);
|
||
};
|
||
|
||
Window_Selectable.prototype.isOkEnabled = function() {
|
||
return this.isHandled("ok");
|
||
};
|
||
|
||
Window_Selectable.prototype.isCancelEnabled = function() {
|
||
return this.isHandled("cancel");
|
||
};
|
||
|
||
Window_Selectable.prototype.isOkTriggered = function() {
|
||
return this._canRepeat ? Input.isRepeated("ok") : Input.isTriggered("ok");
|
||
};
|
||
|
||
Window_Selectable.prototype.isCancelTriggered = function() {
|
||
return Input.isRepeated("cancel");
|
||
};
|
||
|
||
Window_Selectable.prototype.processOk = function() {
|
||
if (this.isCurrentItemEnabled()) {
|
||
this.playOkSound();
|
||
this.updateInputData();
|
||
this.deactivate();
|
||
this.callOkHandler();
|
||
} else {
|
||
this.playBuzzerSound();
|
||
}
|
||
};
|
||
|
||
Window_Selectable.prototype.callOkHandler = function() {
|
||
this.callHandler("ok");
|
||
};
|
||
|
||
Window_Selectable.prototype.processCancel = function() {
|
||
SoundManager.playCancel();
|
||
this.updateInputData();
|
||
this.deactivate();
|
||
this.callCancelHandler();
|
||
};
|
||
|
||
Window_Selectable.prototype.callCancelHandler = function() {
|
||
this.callHandler("cancel");
|
||
};
|
||
|
||
Window_Selectable.prototype.processPageup = function() {
|
||
this.updateInputData();
|
||
this.deactivate();
|
||
this.callHandler("pageup");
|
||
};
|
||
|
||
Window_Selectable.prototype.processPagedown = function() {
|
||
this.updateInputData();
|
||
this.deactivate();
|
||
this.callHandler("pagedown");
|
||
};
|
||
|
||
Window_Selectable.prototype.updateInputData = function() {
|
||
Input.update();
|
||
TouchInput.update();
|
||
this.clearScrollStatus();
|
||
};
|
||
|
||
Window_Selectable.prototype.ensureCursorVisible = function(smooth) {
|
||
if (this._cursorAll) {
|
||
this.scrollTo(0, 0);
|
||
} else if (this.innerHeight > 0 && this.row() >= 0) {
|
||
const scrollY = this.scrollY();
|
||
const itemTop = this.row() * this.itemHeight();
|
||
const itemBottom = itemTop + this.itemHeight();
|
||
const scrollMin = itemBottom - this.innerHeight;
|
||
if (scrollY > itemTop) {
|
||
if (smooth) {
|
||
this.smoothScrollTo(0, itemTop);
|
||
} else {
|
||
this.scrollTo(0, itemTop);
|
||
}
|
||
} else if (scrollY < scrollMin) {
|
||
if (smooth) {
|
||
this.smoothScrollTo(0, scrollMin);
|
||
} else {
|
||
this.scrollTo(0, scrollMin);
|
||
}
|
||
}
|
||
}
|
||
};
|
||
|
||
Window_Selectable.prototype.callUpdateHelp = function() {
|
||
if (this.active && this._helpWindow) {
|
||
this.updateHelp();
|
||
}
|
||
};
|
||
|
||
Window_Selectable.prototype.updateHelp = function() {
|
||
this._helpWindow.clear();
|
||
};
|
||
|
||
Window_Selectable.prototype.setHelpWindowItem = function(item) {
|
||
if (this._helpWindow) {
|
||
this._helpWindow.setItem(item);
|
||
}
|
||
};
|
||
|
||
Window_Selectable.prototype.isCurrentItemEnabled = function() {
|
||
return true;
|
||
};
|
||
|
||
Window_Selectable.prototype.drawAllItems = function() {
|
||
const topIndex = this.topIndex();
|
||
for (let i = 0; i < this.maxVisibleItems(); i++) {
|
||
const index = topIndex + i;
|
||
if (index < this.maxItems()) {
|
||
this.drawItemBackground(index);
|
||
this.drawItem(index);
|
||
}
|
||
}
|
||
};
|
||
|
||
Window_Selectable.prototype.drawItem = function(/*index*/) {
|
||
//
|
||
};
|
||
|
||
Window_Selectable.prototype.clearItem = function(index) {
|
||
const rect = this.itemRect(index);
|
||
this.contents.clearRect(rect.x, rect.y, rect.width, rect.height);
|
||
this.contentsBack.clearRect(rect.x, rect.y, rect.width, rect.height);
|
||
};
|
||
|
||
Window_Selectable.prototype.drawItemBackground = function(index) {
|
||
const rect = this.itemRect(index);
|
||
this.drawBackgroundRect(rect);
|
||
};
|
||
|
||
Window_Selectable.prototype.drawBackgroundRect = function(rect) {
|
||
const c1 = ColorManager.itemBackColor1();
|
||
const c2 = ColorManager.itemBackColor2();
|
||
const x = rect.x;
|
||
const y = rect.y;
|
||
const w = rect.width;
|
||
const h = rect.height;
|
||
this.contentsBack.gradientFillRect(x, y, w, h, c1, c2, true);
|
||
this.contentsBack.strokeRect(x, y, w, h, c1);
|
||
};
|
||
|
||
Window_Selectable.prototype.redrawItem = function(index) {
|
||
if (index >= 0) {
|
||
this.clearItem(index);
|
||
this.drawItemBackground(index);
|
||
this.drawItem(index);
|
||
}
|
||
};
|
||
|
||
Window_Selectable.prototype.redrawCurrentItem = function() {
|
||
this.redrawItem(this.index());
|
||
};
|
||
|
||
Window_Selectable.prototype.refresh = function() {
|
||
this.paint();
|
||
};
|
||
|
||
Window_Selectable.prototype.paint = function() {
|
||
if (this.contents) {
|
||
this.contents.clear();
|
||
this.contentsBack.clear();
|
||
this.drawAllItems();
|
||
}
|
||
};
|
||
|
||
Window_Selectable.prototype.refreshCursor = function() {
|
||
if (this._cursorAll) {
|
||
this.refreshCursorForAll();
|
||
} else if (this.index() >= 0) {
|
||
const rect = this.itemRect(this.index());
|
||
this.setCursorRect(rect.x, rect.y, rect.width, rect.height);
|
||
} else {
|
||
this.setCursorRect(0, 0, 0, 0);
|
||
}
|
||
};
|
||
|
||
Window_Selectable.prototype.refreshCursorForAll = function() {
|
||
const maxItems = this.maxItems();
|
||
if (maxItems > 0) {
|
||
const rect = this.itemRect(0);
|
||
rect.enlarge(this.itemRect(maxItems - 1));
|
||
this.setCursorRect(rect.x, rect.y, rect.width, rect.height);
|
||
} else {
|
||
this.setCursorRect(0, 0, 0, 0);
|
||
}
|
||
};
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Window_Command
|
||
//
|
||
// The superclass of windows for selecting a command.
|
||
|
||
function Window_Command() {
|
||
this.initialize(...arguments);
|
||
}
|
||
|
||
Window_Command.prototype = Object.create(Window_Selectable.prototype);
|
||
Window_Command.prototype.constructor = Window_Command;
|
||
|
||
Window_Command.prototype.initialize = function(rect) {
|
||
Window_Selectable.prototype.initialize.call(this, rect);
|
||
this.refresh();
|
||
this.select(0);
|
||
this.activate();
|
||
};
|
||
|
||
Window_Command.prototype.maxItems = function() {
|
||
return this._list.length;
|
||
};
|
||
|
||
Window_Command.prototype.clearCommandList = function() {
|
||
this._list = [];
|
||
};
|
||
|
||
Window_Command.prototype.makeCommandList = function() {
|
||
//
|
||
};
|
||
|
||
// prettier-ignore
|
||
Window_Command.prototype.addCommand = function(
|
||
name, symbol, enabled = true, ext = null
|
||
) {
|
||
this._list.push({ name: name, symbol: symbol, enabled: enabled, ext: ext });
|
||
};
|
||
|
||
Window_Command.prototype.commandName = function(index) {
|
||
return this._list[index].name;
|
||
};
|
||
|
||
Window_Command.prototype.commandSymbol = function(index) {
|
||
return this._list[index].symbol;
|
||
};
|
||
|
||
Window_Command.prototype.isCommandEnabled = function(index) {
|
||
return this._list[index].enabled;
|
||
};
|
||
|
||
Window_Command.prototype.currentData = function() {
|
||
return this.index() >= 0 ? this._list[this.index()] : null;
|
||
};
|
||
|
||
Window_Command.prototype.isCurrentItemEnabled = function() {
|
||
return this.currentData() ? this.currentData().enabled : false;
|
||
};
|
||
|
||
Window_Command.prototype.currentSymbol = function() {
|
||
return this.currentData() ? this.currentData().symbol : null;
|
||
};
|
||
|
||
Window_Command.prototype.currentExt = function() {
|
||
return this.currentData() ? this.currentData().ext : null;
|
||
};
|
||
|
||
Window_Command.prototype.findSymbol = function(symbol) {
|
||
return this._list.findIndex(item => item.symbol === symbol);
|
||
};
|
||
|
||
Window_Command.prototype.selectSymbol = function(symbol) {
|
||
const index = this.findSymbol(symbol);
|
||
if (index >= 0) {
|
||
this.forceSelect(index);
|
||
} else {
|
||
this.forceSelect(0);
|
||
}
|
||
};
|
||
|
||
Window_Command.prototype.findExt = function(ext) {
|
||
return this._list.findIndex(item => item.ext === ext);
|
||
};
|
||
|
||
Window_Command.prototype.selectExt = function(ext) {
|
||
const index = this.findExt(ext);
|
||
if (index >= 0) {
|
||
this.forceSelect(index);
|
||
} else {
|
||
this.forceSelect(0);
|
||
}
|
||
};
|
||
|
||
Window_Command.prototype.drawItem = function(index) {
|
||
const rect = this.itemLineRect(index);
|
||
const align = this.itemTextAlign();
|
||
this.resetTextColor();
|
||
this.changePaintOpacity(this.isCommandEnabled(index));
|
||
this.drawText(this.commandName(index), rect.x, rect.y, rect.width, align);
|
||
};
|
||
|
||
Window_Command.prototype.itemTextAlign = function() {
|
||
return "center";
|
||
};
|
||
|
||
Window_Command.prototype.isOkEnabled = function() {
|
||
return true;
|
||
};
|
||
|
||
Window_Command.prototype.callOkHandler = function() {
|
||
const symbol = this.currentSymbol();
|
||
if (this.isHandled(symbol)) {
|
||
this.callHandler(symbol);
|
||
} else if (this.isHandled("ok")) {
|
||
Window_Selectable.prototype.callOkHandler.call(this);
|
||
} else {
|
||
this.activate();
|
||
}
|
||
};
|
||
|
||
Window_Command.prototype.refresh = function() {
|
||
this.clearCommandList();
|
||
this.makeCommandList();
|
||
Window_Selectable.prototype.refresh.call(this);
|
||
};
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Window_HorzCommand
|
||
//
|
||
// The command window for the horizontal selection format.
|
||
|
||
function Window_HorzCommand() {
|
||
this.initialize(...arguments);
|
||
}
|
||
|
||
Window_HorzCommand.prototype = Object.create(Window_Command.prototype);
|
||
Window_HorzCommand.prototype.constructor = Window_HorzCommand;
|
||
|
||
Window_HorzCommand.prototype.initialize = function(rect) {
|
||
Window_Command.prototype.initialize.call(this, rect);
|
||
};
|
||
|
||
Window_HorzCommand.prototype.maxCols = function() {
|
||
return 4;
|
||
};
|
||
|
||
Window_HorzCommand.prototype.itemTextAlign = function() {
|
||
return "center";
|
||
};
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Window_Help
|
||
//
|
||
// The window for displaying the description of the selected item.
|
||
|
||
function Window_Help() {
|
||
this.initialize(...arguments);
|
||
}
|
||
|
||
Window_Help.prototype = Object.create(Window_Base.prototype);
|
||
Window_Help.prototype.constructor = Window_Help;
|
||
|
||
Window_Help.prototype.initialize = function(rect) {
|
||
Window_Base.prototype.initialize.call(this, rect);
|
||
this._text = "";
|
||
};
|
||
|
||
Window_Help.prototype.setText = function(text) {
|
||
if (this._text !== text) {
|
||
this._text = text;
|
||
this.refresh();
|
||
}
|
||
};
|
||
|
||
Window_Help.prototype.clear = function() {
|
||
this.setText("");
|
||
};
|
||
|
||
Window_Help.prototype.setItem = function(item) {
|
||
this.setText(item ? item.description : "");
|
||
};
|
||
|
||
Window_Help.prototype.refresh = function() {
|
||
const rect = this.baseTextRect();
|
||
this.contents.clear();
|
||
this.drawTextEx(this._text, rect.x, rect.y, rect.width);
|
||
};
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Window_Gold
|
||
//
|
||
// The window for displaying the party's gold.
|
||
|
||
function Window_Gold() {
|
||
this.initialize(...arguments);
|
||
}
|
||
|
||
Window_Gold.prototype = Object.create(Window_Selectable.prototype);
|
||
Window_Gold.prototype.constructor = Window_Gold;
|
||
|
||
Window_Gold.prototype.initialize = function(rect) {
|
||
Window_Selectable.prototype.initialize.call(this, rect);
|
||
this.refresh();
|
||
};
|
||
|
||
Window_Gold.prototype.colSpacing = function() {
|
||
return 0;
|
||
};
|
||
|
||
Window_Gold.prototype.refresh = function() {
|
||
const rect = this.itemLineRect(0);
|
||
const x = rect.x;
|
||
const y = rect.y;
|
||
const width = rect.width;
|
||
this.contents.clear();
|
||
this.drawCurrencyValue(this.value(), this.currencyUnit(), x, y, width);
|
||
};
|
||
|
||
Window_Gold.prototype.value = function() {
|
||
return $gameParty.gold();
|
||
};
|
||
|
||
Window_Gold.prototype.currencyUnit = function() {
|
||
return TextManager.currencyUnit;
|
||
};
|
||
|
||
Window_Gold.prototype.open = function() {
|
||
this.refresh();
|
||
Window_Selectable.prototype.open.call(this);
|
||
};
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Window_StatusBase
|
||
//
|
||
// The superclass of windows for displaying actor status.
|
||
|
||
function Window_StatusBase() {
|
||
this.initialize(...arguments);
|
||
}
|
||
|
||
Window_StatusBase.prototype = Object.create(Window_Selectable.prototype);
|
||
Window_StatusBase.prototype.constructor = Window_StatusBase;
|
||
|
||
Window_StatusBase.prototype.initialize = function(rect) {
|
||
Window_Selectable.prototype.initialize.call(this, rect);
|
||
this._additionalSprites = {};
|
||
this.loadFaceImages();
|
||
};
|
||
|
||
Window_StatusBase.prototype.loadFaceImages = function() {
|
||
for (const actor of $gameParty.members()) {
|
||
ImageManager.loadFace(actor.faceName());
|
||
}
|
||
};
|
||
|
||
Window_StatusBase.prototype.refresh = function() {
|
||
this.hideAdditionalSprites();
|
||
Window_Selectable.prototype.refresh.call(this);
|
||
};
|
||
|
||
Window_StatusBase.prototype.hideAdditionalSprites = function() {
|
||
for (const sprite of Object.values(this._additionalSprites)) {
|
||
sprite.hide();
|
||
}
|
||
};
|
||
|
||
Window_StatusBase.prototype.placeActorName = function(actor, x, y) {
|
||
const key = "actor%1-name".format(actor.actorId());
|
||
const sprite = this.createInnerSprite(key, Sprite_Name);
|
||
sprite.setup(actor);
|
||
sprite.move(x, y);
|
||
sprite.show();
|
||
};
|
||
|
||
Window_StatusBase.prototype.placeStateIcon = function(actor, x, y) {
|
||
const key = "actor%1-stateIcon".format(actor.actorId());
|
||
const sprite = this.createInnerSprite(key, Sprite_StateIcon);
|
||
sprite.setup(actor);
|
||
sprite.move(x, y);
|
||
sprite.show();
|
||
};
|
||
|
||
Window_StatusBase.prototype.placeGauge = function(actor, type, x, y) {
|
||
const key = "actor%1-gauge-%2".format(actor.actorId(), type);
|
||
const sprite = this.createInnerSprite(key, Sprite_Gauge);
|
||
sprite.setup(actor, type);
|
||
sprite.move(x, y);
|
||
sprite.show();
|
||
};
|
||
|
||
Window_StatusBase.prototype.createInnerSprite = function(key, spriteClass) {
|
||
const dict = this._additionalSprites;
|
||
if (dict[key]) {
|
||
return dict[key];
|
||
} else {
|
||
const sprite = new spriteClass();
|
||
dict[key] = sprite;
|
||
this.addInnerChild(sprite);
|
||
return sprite;
|
||
}
|
||
};
|
||
|
||
Window_StatusBase.prototype.placeTimeGauge = function(actor, x, y) {
|
||
if (BattleManager.isTpb()) {
|
||
this.placeGauge(actor, "time", x, y);
|
||
}
|
||
};
|
||
|
||
Window_StatusBase.prototype.placeBasicGauges = function(actor, x, y) {
|
||
this.placeGauge(actor, "hp", x, y);
|
||
this.placeGauge(actor, "mp", x, y + this.gaugeLineHeight());
|
||
if ($dataSystem.optDisplayTp) {
|
||
this.placeGauge(actor, "tp", x, y + this.gaugeLineHeight() * 2);
|
||
}
|
||
};
|
||
|
||
Window_StatusBase.prototype.gaugeLineHeight = function() {
|
||
return 24;
|
||
};
|
||
|
||
Window_StatusBase.prototype.drawActorCharacter = function(actor, x, y) {
|
||
this.drawCharacter(actor.characterName(), actor.characterIndex(), x, y);
|
||
};
|
||
|
||
// prettier-ignore
|
||
Window_StatusBase.prototype.drawActorFace = function(
|
||
actor, x, y, width, height
|
||
) {
|
||
this.drawFace(actor.faceName(), actor.faceIndex(), x, y, width, height);
|
||
};
|
||
|
||
Window_StatusBase.prototype.drawActorName = function(actor, x, y, width) {
|
||
width = width || 168;
|
||
this.changeTextColor(ColorManager.hpColor(actor));
|
||
this.drawText(actor.name(), x, y, width);
|
||
};
|
||
|
||
Window_StatusBase.prototype.drawActorClass = function(actor, x, y, width) {
|
||
width = width || 168;
|
||
this.resetTextColor();
|
||
this.drawText(actor.currentClass().name, x, y, width);
|
||
};
|
||
|
||
Window_StatusBase.prototype.drawActorNickname = function(actor, x, y, width) {
|
||
width = width || 270;
|
||
this.resetTextColor();
|
||
this.drawText(actor.nickname(), x, y, width);
|
||
};
|
||
|
||
Window_StatusBase.prototype.drawActorLevel = function(actor, x, y) {
|
||
this.changeTextColor(ColorManager.systemColor());
|
||
this.drawText(TextManager.levelA, x, y, 48);
|
||
this.resetTextColor();
|
||
this.drawText(actor.level, x + 84, y, 36, "right");
|
||
};
|
||
|
||
Window_StatusBase.prototype.drawActorIcons = function(actor, x, y, width) {
|
||
width = width || 144;
|
||
const iconWidth = ImageManager.iconWidth;
|
||
const icons = actor.allIcons().slice(0, Math.floor(width / iconWidth));
|
||
let iconX = x;
|
||
for (const icon of icons) {
|
||
this.drawIcon(icon, iconX, y + 2);
|
||
iconX += iconWidth;
|
||
}
|
||
};
|
||
|
||
Window_StatusBase.prototype.drawActorSimpleStatus = function(actor, x, y) {
|
||
const lineHeight = this.lineHeight();
|
||
const x2 = x + 180;
|
||
this.drawActorName(actor, x, y);
|
||
this.drawActorLevel(actor, x, y + lineHeight * 1);
|
||
this.drawActorIcons(actor, x, y + lineHeight * 2);
|
||
this.drawActorClass(actor, x2, y);
|
||
this.placeBasicGauges(actor, x2, y + lineHeight);
|
||
};
|
||
|
||
Window_StatusBase.prototype.actorSlotName = function(actor, index) {
|
||
const slots = actor.equipSlots();
|
||
return $dataSystem.equipTypes[slots[index]];
|
||
};
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Window_MenuCommand
|
||
//
|
||
// The window for selecting a command on the menu screen.
|
||
|
||
function Window_MenuCommand() {
|
||
this.initialize(...arguments);
|
||
}
|
||
|
||
Window_MenuCommand.prototype = Object.create(Window_Command.prototype);
|
||
Window_MenuCommand.prototype.constructor = Window_MenuCommand;
|
||
|
||
Window_MenuCommand.prototype.initialize = function(rect) {
|
||
Window_Command.prototype.initialize.call(this, rect);
|
||
this.selectLast();
|
||
this._canRepeat = false;
|
||
};
|
||
|
||
Window_MenuCommand._lastCommandSymbol = null;
|
||
|
||
Window_MenuCommand.initCommandPosition = function() {
|
||
this._lastCommandSymbol = null;
|
||
};
|
||
|
||
Window_MenuCommand.prototype.makeCommandList = function() {
|
||
this.addMainCommands();
|
||
this.addFormationCommand();
|
||
this.addOriginalCommands();
|
||
this.addOptionsCommand();
|
||
this.addSaveCommand();
|
||
this.addGameEndCommand();
|
||
};
|
||
|
||
Window_MenuCommand.prototype.addMainCommands = function() {
|
||
const enabled = this.areMainCommandsEnabled();
|
||
if (this.needsCommand("item")) {
|
||
this.addCommand(TextManager.item, "item", enabled);
|
||
}
|
||
if (this.needsCommand("skill")) {
|
||
this.addCommand(TextManager.skill, "skill", enabled);
|
||
}
|
||
if (this.needsCommand("equip")) {
|
||
this.addCommand(TextManager.equip, "equip", enabled);
|
||
}
|
||
if (this.needsCommand("status")) {
|
||
this.addCommand(TextManager.status, "status", enabled);
|
||
}
|
||
};
|
||
|
||
Window_MenuCommand.prototype.addFormationCommand = function() {
|
||
if (this.needsCommand("formation")) {
|
||
const enabled = this.isFormationEnabled();
|
||
this.addCommand(TextManager.formation, "formation", enabled);
|
||
}
|
||
};
|
||
|
||
Window_MenuCommand.prototype.addOriginalCommands = function() {
|
||
//
|
||
};
|
||
|
||
Window_MenuCommand.prototype.addOptionsCommand = function() {
|
||
if (this.needsCommand("options")) {
|
||
const enabled = this.isOptionsEnabled();
|
||
this.addCommand(TextManager.options, "options", enabled);
|
||
}
|
||
};
|
||
|
||
Window_MenuCommand.prototype.addSaveCommand = function() {
|
||
if (this.needsCommand("save")) {
|
||
const enabled = this.isSaveEnabled();
|
||
this.addCommand(TextManager.save, "save", enabled);
|
||
}
|
||
};
|
||
|
||
Window_MenuCommand.prototype.addGameEndCommand = function() {
|
||
const enabled = this.isGameEndEnabled();
|
||
this.addCommand(TextManager.gameEnd, "gameEnd", enabled);
|
||
};
|
||
|
||
Window_MenuCommand.prototype.needsCommand = function(name) {
|
||
const table = ["item", "skill", "equip", "status", "formation", "save"];
|
||
const index = table.indexOf(name);
|
||
if (index >= 0) {
|
||
return $dataSystem.menuCommands[index];
|
||
}
|
||
return true;
|
||
};
|
||
|
||
Window_MenuCommand.prototype.areMainCommandsEnabled = function() {
|
||
return $gameParty.exists();
|
||
};
|
||
|
||
Window_MenuCommand.prototype.isFormationEnabled = function() {
|
||
return $gameParty.size() >= 2 && $gameSystem.isFormationEnabled();
|
||
};
|
||
|
||
Window_MenuCommand.prototype.isOptionsEnabled = function() {
|
||
return true;
|
||
};
|
||
|
||
Window_MenuCommand.prototype.isSaveEnabled = function() {
|
||
return !DataManager.isEventTest() && $gameSystem.isSaveEnabled();
|
||
};
|
||
|
||
Window_MenuCommand.prototype.isGameEndEnabled = function() {
|
||
return true;
|
||
};
|
||
|
||
Window_MenuCommand.prototype.processOk = function() {
|
||
Window_MenuCommand._lastCommandSymbol = this.currentSymbol();
|
||
Window_Command.prototype.processOk.call(this);
|
||
};
|
||
|
||
Window_MenuCommand.prototype.selectLast = function() {
|
||
this.selectSymbol(Window_MenuCommand._lastCommandSymbol);
|
||
};
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Window_MenuStatus
|
||
//
|
||
// The window for displaying party member status on the menu screen.
|
||
|
||
function Window_MenuStatus() {
|
||
this.initialize(...arguments);
|
||
}
|
||
|
||
Window_MenuStatus.prototype = Object.create(Window_StatusBase.prototype);
|
||
Window_MenuStatus.prototype.constructor = Window_MenuStatus;
|
||
|
||
Window_MenuStatus.prototype.initialize = function(rect) {
|
||
Window_StatusBase.prototype.initialize.call(this, rect);
|
||
this._formationMode = false;
|
||
this._pendingIndex = -1;
|
||
this.refresh();
|
||
};
|
||
|
||
Window_MenuStatus.prototype.maxItems = function() {
|
||
return $gameParty.size();
|
||
};
|
||
|
||
Window_MenuStatus.prototype.numVisibleRows = function() {
|
||
return 4;
|
||
};
|
||
|
||
Window_MenuStatus.prototype.itemHeight = function() {
|
||
return Math.floor(this.innerHeight / this.numVisibleRows());
|
||
};
|
||
|
||
Window_MenuStatus.prototype.actor = function(index) {
|
||
return $gameParty.members()[index];
|
||
};
|
||
|
||
Window_MenuStatus.prototype.drawItem = function(index) {
|
||
this.drawPendingItemBackground(index);
|
||
this.drawItemImage(index);
|
||
this.drawItemStatus(index);
|
||
};
|
||
|
||
Window_MenuStatus.prototype.drawPendingItemBackground = function(index) {
|
||
if (index === this._pendingIndex) {
|
||
const rect = this.itemRect(index);
|
||
const color = ColorManager.pendingColor();
|
||
this.changePaintOpacity(false);
|
||
this.contents.fillRect(rect.x, rect.y, rect.width, rect.height, color);
|
||
this.changePaintOpacity(true);
|
||
}
|
||
};
|
||
|
||
Window_MenuStatus.prototype.drawItemImage = function(index) {
|
||
const actor = this.actor(index);
|
||
const rect = this.itemRect(index);
|
||
const width = ImageManager.faceWidth;
|
||
const height = rect.height - 2;
|
||
this.changePaintOpacity(actor.isBattleMember());
|
||
this.drawActorFace(actor, rect.x + 1, rect.y + 1, width, height);
|
||
this.changePaintOpacity(true);
|
||
};
|
||
|
||
Window_MenuStatus.prototype.drawItemStatus = function(index) {
|
||
const actor = this.actor(index);
|
||
const rect = this.itemRect(index);
|
||
const x = rect.x + 180;
|
||
const y = rect.y + Math.floor(rect.height / 2 - this.lineHeight() * 1.5);
|
||
this.drawActorSimpleStatus(actor, x, y);
|
||
};
|
||
|
||
Window_MenuStatus.prototype.processOk = function() {
|
||
Window_StatusBase.prototype.processOk.call(this);
|
||
const actor = this.actor(this.index());
|
||
$gameParty.setMenuActor(actor);
|
||
};
|
||
|
||
Window_MenuStatus.prototype.isCurrentItemEnabled = function() {
|
||
if (this._formationMode) {
|
||
const actor = this.actor(this.index());
|
||
return actor && actor.isFormationChangeOk();
|
||
} else {
|
||
return true;
|
||
}
|
||
};
|
||
|
||
Window_MenuStatus.prototype.selectLast = function() {
|
||
this.smoothSelect($gameParty.menuActor().index() || 0);
|
||
};
|
||
|
||
Window_MenuStatus.prototype.formationMode = function() {
|
||
return this._formationMode;
|
||
};
|
||
|
||
Window_MenuStatus.prototype.setFormationMode = function(formationMode) {
|
||
this._formationMode = formationMode;
|
||
};
|
||
|
||
Window_MenuStatus.prototype.pendingIndex = function() {
|
||
return this._pendingIndex;
|
||
};
|
||
|
||
Window_MenuStatus.prototype.setPendingIndex = function(index) {
|
||
const lastPendingIndex = this._pendingIndex;
|
||
this._pendingIndex = index;
|
||
this.redrawItem(this._pendingIndex);
|
||
this.redrawItem(lastPendingIndex);
|
||
};
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Window_MenuActor
|
||
//
|
||
// The window for selecting a target actor on the item and skill screens.
|
||
|
||
function Window_MenuActor() {
|
||
this.initialize(...arguments);
|
||
}
|
||
|
||
Window_MenuActor.prototype = Object.create(Window_MenuStatus.prototype);
|
||
Window_MenuActor.prototype.constructor = Window_MenuActor;
|
||
|
||
Window_MenuActor.prototype.initialize = function(rect) {
|
||
Window_MenuStatus.prototype.initialize.call(this, rect);
|
||
this.hide();
|
||
};
|
||
|
||
Window_MenuActor.prototype.processOk = function() {
|
||
if (!this.cursorAll()) {
|
||
$gameParty.setTargetActor($gameParty.members()[this.index()]);
|
||
}
|
||
this.callOkHandler();
|
||
};
|
||
|
||
Window_MenuActor.prototype.selectLast = function() {
|
||
this.forceSelect($gameParty.targetActor().index() || 0);
|
||
};
|
||
|
||
Window_MenuActor.prototype.selectForItem = function(item) {
|
||
const actor = $gameParty.menuActor();
|
||
const action = new Game_Action(actor);
|
||
action.setItemObject(item);
|
||
this.setCursorFixed(false);
|
||
this.setCursorAll(false);
|
||
if (action.isForUser()) {
|
||
if (DataManager.isSkill(item)) {
|
||
this.setCursorFixed(true);
|
||
this.forceSelect(actor.index());
|
||
} else {
|
||
this.selectLast();
|
||
}
|
||
} else if (action.isForAll()) {
|
||
this.setCursorAll(true);
|
||
this.forceSelect(0);
|
||
} else {
|
||
this.selectLast();
|
||
}
|
||
};
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Window_ItemCategory
|
||
//
|
||
// The window for selecting a category of items on the item and shop screens.
|
||
|
||
function Window_ItemCategory() {
|
||
this.initialize(...arguments);
|
||
}
|
||
|
||
Window_ItemCategory.prototype = Object.create(Window_HorzCommand.prototype);
|
||
Window_ItemCategory.prototype.constructor = Window_ItemCategory;
|
||
|
||
Window_ItemCategory.prototype.initialize = function(rect) {
|
||
Window_HorzCommand.prototype.initialize.call(this, rect);
|
||
};
|
||
|
||
Window_ItemCategory.prototype.maxCols = function() {
|
||
return 4;
|
||
};
|
||
|
||
Window_ItemCategory.prototype.update = function() {
|
||
Window_HorzCommand.prototype.update.call(this);
|
||
if (this._itemWindow) {
|
||
this._itemWindow.setCategory(this.currentSymbol());
|
||
}
|
||
};
|
||
|
||
Window_ItemCategory.prototype.makeCommandList = function() {
|
||
if (this.needsCommand("item")) {
|
||
this.addCommand(TextManager.item, "item");
|
||
}
|
||
if (this.needsCommand("weapon")) {
|
||
this.addCommand(TextManager.weapon, "weapon");
|
||
}
|
||
if (this.needsCommand("armor")) {
|
||
this.addCommand(TextManager.armor, "armor");
|
||
}
|
||
if (this.needsCommand("keyItem")) {
|
||
this.addCommand(TextManager.keyItem, "keyItem");
|
||
}
|
||
};
|
||
|
||
Window_ItemCategory.prototype.needsCommand = function(name) {
|
||
const table = ["item", "weapon", "armor", "keyItem"];
|
||
const index = table.indexOf(name);
|
||
if (index >= 0) {
|
||
return $dataSystem.itemCategories[index];
|
||
}
|
||
return true;
|
||
};
|
||
|
||
Window_ItemCategory.prototype.setItemWindow = function(itemWindow) {
|
||
this._itemWindow = itemWindow;
|
||
};
|
||
|
||
Window_ItemCategory.prototype.needsSelection = function() {
|
||
return this.maxItems() >= 2;
|
||
};
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Window_ItemList
|
||
//
|
||
// The window for selecting an item on the item screen.
|
||
|
||
function Window_ItemList() {
|
||
this.initialize(...arguments);
|
||
}
|
||
|
||
Window_ItemList.prototype = Object.create(Window_Selectable.prototype);
|
||
Window_ItemList.prototype.constructor = Window_ItemList;
|
||
|
||
Window_ItemList.prototype.initialize = function(rect) {
|
||
Window_Selectable.prototype.initialize.call(this, rect);
|
||
this._category = "none";
|
||
this._data = [];
|
||
};
|
||
|
||
Window_ItemList.prototype.setCategory = function(category) {
|
||
if (this._category !== category) {
|
||
this._category = category;
|
||
this.refresh();
|
||
this.scrollTo(0, 0);
|
||
}
|
||
};
|
||
|
||
Window_ItemList.prototype.maxCols = function() {
|
||
return 2;
|
||
};
|
||
|
||
Window_ItemList.prototype.colSpacing = function() {
|
||
return 16;
|
||
};
|
||
|
||
Window_ItemList.prototype.maxItems = function() {
|
||
return this._data ? this._data.length : 1;
|
||
};
|
||
|
||
Window_ItemList.prototype.item = function() {
|
||
return this.itemAt(this.index());
|
||
};
|
||
|
||
Window_ItemList.prototype.itemAt = function(index) {
|
||
return this._data && index >= 0 ? this._data[index] : null;
|
||
};
|
||
|
||
Window_ItemList.prototype.isCurrentItemEnabled = function() {
|
||
return this.isEnabled(this.item());
|
||
};
|
||
|
||
Window_ItemList.prototype.includes = function(item) {
|
||
switch (this._category) {
|
||
case "item":
|
||
return DataManager.isItem(item) && item.itypeId === 1;
|
||
case "weapon":
|
||
return DataManager.isWeapon(item);
|
||
case "armor":
|
||
return DataManager.isArmor(item);
|
||
case "keyItem":
|
||
return DataManager.isItem(item) && item.itypeId === 2;
|
||
default:
|
||
return false;
|
||
}
|
||
};
|
||
|
||
Window_ItemList.prototype.needsNumber = function() {
|
||
if (this._category === "keyItem") {
|
||
return $dataSystem.optKeyItemsNumber;
|
||
} else {
|
||
return true;
|
||
}
|
||
};
|
||
|
||
Window_ItemList.prototype.isEnabled = function(item) {
|
||
return $gameParty.canUse(item);
|
||
};
|
||
|
||
Window_ItemList.prototype.makeItemList = function() {
|
||
this._data = $gameParty.allItems().filter(item => this.includes(item));
|
||
if (this.includes(null)) {
|
||
this._data.push(null);
|
||
}
|
||
};
|
||
|
||
Window_ItemList.prototype.selectLast = function() {
|
||
const index = this._data.indexOf($gameParty.lastItem());
|
||
this.forceSelect(index >= 0 ? index : 0);
|
||
};
|
||
|
||
Window_ItemList.prototype.drawItem = function(index) {
|
||
const item = this.itemAt(index);
|
||
if (item) {
|
||
const numberWidth = this.numberWidth();
|
||
const rect = this.itemLineRect(index);
|
||
this.changePaintOpacity(this.isEnabled(item));
|
||
this.drawItemName(item, rect.x, rect.y, rect.width - numberWidth);
|
||
this.drawItemNumber(item, rect.x, rect.y, rect.width);
|
||
this.changePaintOpacity(1);
|
||
}
|
||
};
|
||
|
||
Window_ItemList.prototype.numberWidth = function() {
|
||
return this.textWidth("000");
|
||
};
|
||
|
||
Window_ItemList.prototype.drawItemNumber = function(item, x, y, width) {
|
||
if (this.needsNumber()) {
|
||
this.drawText(":", x, y, width - this.textWidth("00"), "right");
|
||
this.drawText($gameParty.numItems(item), x, y, width, "right");
|
||
}
|
||
};
|
||
|
||
Window_ItemList.prototype.updateHelp = function() {
|
||
this.setHelpWindowItem(this.item());
|
||
};
|
||
|
||
Window_ItemList.prototype.refresh = function() {
|
||
this.makeItemList();
|
||
Window_Selectable.prototype.refresh.call(this);
|
||
};
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Window_SkillType
|
||
//
|
||
// The window for selecting a skill type on the skill screen.
|
||
|
||
function Window_SkillType() {
|
||
this.initialize(...arguments);
|
||
}
|
||
|
||
Window_SkillType.prototype = Object.create(Window_Command.prototype);
|
||
Window_SkillType.prototype.constructor = Window_SkillType;
|
||
|
||
Window_SkillType.prototype.initialize = function(rect) {
|
||
Window_Command.prototype.initialize.call(this, rect);
|
||
this._actor = null;
|
||
};
|
||
|
||
Window_SkillType.prototype.setActor = function(actor) {
|
||
if (this._actor !== actor) {
|
||
this._actor = actor;
|
||
this.refresh();
|
||
this.selectLast();
|
||
}
|
||
};
|
||
|
||
Window_SkillType.prototype.makeCommandList = function() {
|
||
if (this._actor) {
|
||
const skillTypes = this._actor.skillTypes();
|
||
for (const stypeId of skillTypes) {
|
||
const name = $dataSystem.skillTypes[stypeId];
|
||
this.addCommand(name, "skill", true, stypeId);
|
||
}
|
||
}
|
||
};
|
||
|
||
Window_SkillType.prototype.update = function() {
|
||
Window_Command.prototype.update.call(this);
|
||
if (this._skillWindow) {
|
||
this._skillWindow.setStypeId(this.currentExt());
|
||
}
|
||
};
|
||
|
||
Window_SkillType.prototype.setSkillWindow = function(skillWindow) {
|
||
this._skillWindow = skillWindow;
|
||
};
|
||
|
||
Window_SkillType.prototype.selectLast = function() {
|
||
const skill = this._actor.lastMenuSkill();
|
||
if (skill) {
|
||
this.selectExt(skill.stypeId);
|
||
} else {
|
||
this.forceSelect(0);
|
||
}
|
||
};
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Window_SkillStatus
|
||
//
|
||
// The window for displaying the skill user's status on the skill screen.
|
||
|
||
function Window_SkillStatus() {
|
||
this.initialize(...arguments);
|
||
}
|
||
|
||
Window_SkillStatus.prototype = Object.create(Window_StatusBase.prototype);
|
||
Window_SkillStatus.prototype.constructor = Window_SkillStatus;
|
||
|
||
Window_SkillStatus.prototype.initialize = function(rect) {
|
||
Window_StatusBase.prototype.initialize.call(this, rect);
|
||
this._actor = null;
|
||
};
|
||
|
||
Window_SkillStatus.prototype.setActor = function(actor) {
|
||
if (this._actor !== actor) {
|
||
this._actor = actor;
|
||
this.refresh();
|
||
}
|
||
};
|
||
|
||
Window_SkillStatus.prototype.refresh = function() {
|
||
Window_StatusBase.prototype.refresh.call(this);
|
||
if (this._actor) {
|
||
const x = this.colSpacing() / 2;
|
||
const h = this.innerHeight;
|
||
const y = h / 2 - this.lineHeight() * 1.5;
|
||
this.drawActorFace(this._actor, x + 1, 0, 144, h);
|
||
this.drawActorSimpleStatus(this._actor, x + 180, y);
|
||
}
|
||
};
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Window_SkillList
|
||
//
|
||
// The window for selecting a skill on the skill screen.
|
||
|
||
function Window_SkillList() {
|
||
this.initialize(...arguments);
|
||
}
|
||
|
||
Window_SkillList.prototype = Object.create(Window_Selectable.prototype);
|
||
Window_SkillList.prototype.constructor = Window_SkillList;
|
||
|
||
Window_SkillList.prototype.initialize = function(rect) {
|
||
Window_Selectable.prototype.initialize.call(this, rect);
|
||
this._actor = null;
|
||
this._stypeId = 0;
|
||
this._data = [];
|
||
};
|
||
|
||
Window_SkillList.prototype.setActor = function(actor) {
|
||
if (this._actor !== actor) {
|
||
this._actor = actor;
|
||
this.refresh();
|
||
this.scrollTo(0, 0);
|
||
}
|
||
};
|
||
|
||
Window_SkillList.prototype.setStypeId = function(stypeId) {
|
||
if (this._stypeId !== stypeId) {
|
||
this._stypeId = stypeId;
|
||
this.refresh();
|
||
this.scrollTo(0, 0);
|
||
}
|
||
};
|
||
|
||
Window_SkillList.prototype.maxCols = function() {
|
||
return 2;
|
||
};
|
||
|
||
Window_SkillList.prototype.colSpacing = function() {
|
||
return 16;
|
||
};
|
||
|
||
Window_SkillList.prototype.maxItems = function() {
|
||
return this._data ? this._data.length : 1;
|
||
};
|
||
|
||
Window_SkillList.prototype.item = function() {
|
||
return this.itemAt(this.index());
|
||
};
|
||
|
||
Window_SkillList.prototype.itemAt = function(index) {
|
||
return this._data && index >= 0 ? this._data[index] : null;
|
||
};
|
||
|
||
Window_SkillList.prototype.isCurrentItemEnabled = function() {
|
||
return this.isEnabled(this._data[this.index()]);
|
||
};
|
||
|
||
Window_SkillList.prototype.includes = function(item) {
|
||
return item && item.stypeId === this._stypeId;
|
||
};
|
||
|
||
Window_SkillList.prototype.isEnabled = function(item) {
|
||
return this._actor && this._actor.canUse(item);
|
||
};
|
||
|
||
Window_SkillList.prototype.makeItemList = function() {
|
||
if (this._actor) {
|
||
this._data = this._actor.skills().filter(item => this.includes(item));
|
||
} else {
|
||
this._data = [];
|
||
}
|
||
};
|
||
|
||
Window_SkillList.prototype.selectLast = function() {
|
||
const index = this._data.indexOf(this._actor.lastSkill());
|
||
this.forceSelect(index >= 0 ? index : 0);
|
||
};
|
||
|
||
Window_SkillList.prototype.drawItem = function(index) {
|
||
const skill = this.itemAt(index);
|
||
if (skill) {
|
||
const costWidth = this.costWidth();
|
||
const rect = this.itemLineRect(index);
|
||
this.changePaintOpacity(this.isEnabled(skill));
|
||
this.drawItemName(skill, rect.x, rect.y, rect.width - costWidth);
|
||
this.drawSkillCost(skill, rect.x, rect.y, rect.width);
|
||
this.changePaintOpacity(1);
|
||
}
|
||
};
|
||
|
||
Window_SkillList.prototype.costWidth = function() {
|
||
return this.textWidth("000");
|
||
};
|
||
|
||
Window_SkillList.prototype.drawSkillCost = function(skill, x, y, width) {
|
||
if (this._actor.skillTpCost(skill) > 0) {
|
||
this.changeTextColor(ColorManager.tpCostColor());
|
||
this.drawText(this._actor.skillTpCost(skill), x, y, width, "right");
|
||
} else if (this._actor.skillMpCost(skill) > 0) {
|
||
this.changeTextColor(ColorManager.mpCostColor());
|
||
this.drawText(this._actor.skillMpCost(skill), x, y, width, "right");
|
||
}
|
||
};
|
||
|
||
Window_SkillList.prototype.updateHelp = function() {
|
||
this.setHelpWindowItem(this.item());
|
||
};
|
||
|
||
Window_SkillList.prototype.refresh = function() {
|
||
this.makeItemList();
|
||
Window_Selectable.prototype.refresh.call(this);
|
||
};
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Window_EquipStatus
|
||
//
|
||
// The window for displaying parameter changes on the equipment screen.
|
||
|
||
function Window_EquipStatus() {
|
||
this.initialize(...arguments);
|
||
}
|
||
|
||
Window_EquipStatus.prototype = Object.create(Window_StatusBase.prototype);
|
||
Window_EquipStatus.prototype.constructor = Window_EquipStatus;
|
||
|
||
Window_EquipStatus.prototype.initialize = function(rect) {
|
||
Window_StatusBase.prototype.initialize.call(this, rect);
|
||
this._actor = null;
|
||
this._tempActor = null;
|
||
this.refresh();
|
||
};
|
||
|
||
Window_EquipStatus.prototype.setActor = function(actor) {
|
||
if (this._actor !== actor) {
|
||
this._actor = actor;
|
||
this.refresh();
|
||
}
|
||
};
|
||
|
||
Window_EquipStatus.prototype.colSpacing = function() {
|
||
return 0;
|
||
};
|
||
|
||
Window_EquipStatus.prototype.refresh = function() {
|
||
this.contents.clear();
|
||
if (this._actor) {
|
||
const nameRect = this.itemLineRect(0);
|
||
this.drawActorName(this._actor, nameRect.x, 0, nameRect.width);
|
||
this.drawActorFace(this._actor, nameRect.x, nameRect.height);
|
||
this.drawAllParams();
|
||
}
|
||
};
|
||
|
||
Window_EquipStatus.prototype.setTempActor = function(tempActor) {
|
||
if (this._tempActor !== tempActor) {
|
||
this._tempActor = tempActor;
|
||
this.refresh();
|
||
}
|
||
};
|
||
|
||
Window_EquipStatus.prototype.drawAllParams = function() {
|
||
for (let i = 0; i < 6; i++) {
|
||
const x = this.itemPadding();
|
||
const y = this.paramY(i);
|
||
this.drawItem(x, y, 2 + i);
|
||
}
|
||
};
|
||
|
||
Window_EquipStatus.prototype.drawItem = function(x, y, paramId) {
|
||
const paramX = this.paramX();
|
||
const paramWidth = this.paramWidth();
|
||
const rightArrowWidth = this.rightArrowWidth();
|
||
this.drawParamName(x, y, paramId);
|
||
if (this._actor) {
|
||
this.drawCurrentParam(paramX, y, paramId);
|
||
}
|
||
this.drawRightArrow(paramX + paramWidth, y);
|
||
if (this._tempActor) {
|
||
this.drawNewParam(paramX + paramWidth + rightArrowWidth, y, paramId);
|
||
}
|
||
};
|
||
|
||
Window_EquipStatus.prototype.drawParamName = function(x, y, paramId) {
|
||
const width = this.paramX() - this.itemPadding() * 2;
|
||
this.changeTextColor(ColorManager.systemColor());
|
||
this.drawText(TextManager.param(paramId), x, y, width);
|
||
};
|
||
|
||
Window_EquipStatus.prototype.drawCurrentParam = function(x, y, paramId) {
|
||
const paramWidth = this.paramWidth();
|
||
this.resetTextColor();
|
||
this.drawText(this._actor.param(paramId), x, y, paramWidth, "right");
|
||
};
|
||
|
||
Window_EquipStatus.prototype.drawRightArrow = function(x, y) {
|
||
const rightArrowWidth = this.rightArrowWidth();
|
||
this.changeTextColor(ColorManager.systemColor());
|
||
this.drawText("\u2192", x, y, rightArrowWidth, "center");
|
||
};
|
||
|
||
Window_EquipStatus.prototype.drawNewParam = function(x, y, paramId) {
|
||
const paramWidth = this.paramWidth();
|
||
const newValue = this._tempActor.param(paramId);
|
||
const diffvalue = newValue - this._actor.param(paramId);
|
||
this.changeTextColor(ColorManager.paramchangeTextColor(diffvalue));
|
||
this.drawText(newValue, x, y, paramWidth, "right");
|
||
};
|
||
|
||
Window_EquipStatus.prototype.rightArrowWidth = function() {
|
||
return 32;
|
||
};
|
||
|
||
Window_EquipStatus.prototype.paramWidth = function() {
|
||
return 48;
|
||
};
|
||
|
||
Window_EquipStatus.prototype.paramX = function() {
|
||
const itemPadding = this.itemPadding();
|
||
const rightArrowWidth = this.rightArrowWidth();
|
||
const paramWidth = this.paramWidth();
|
||
return this.innerWidth - itemPadding - paramWidth * 2 - rightArrowWidth;
|
||
};
|
||
|
||
Window_EquipStatus.prototype.paramY = function(index) {
|
||
const faceHeight = ImageManager.faceHeight;
|
||
return faceHeight + Math.floor(this.lineHeight() * (index + 1.5));
|
||
};
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Window_EquipCommand
|
||
//
|
||
// The window for selecting a command on the equipment screen.
|
||
|
||
function Window_EquipCommand() {
|
||
this.initialize(...arguments);
|
||
}
|
||
|
||
Window_EquipCommand.prototype = Object.create(Window_HorzCommand.prototype);
|
||
Window_EquipCommand.prototype.constructor = Window_EquipCommand;
|
||
|
||
Window_EquipCommand.prototype.initialize = function(rect) {
|
||
Window_HorzCommand.prototype.initialize.call(this, rect);
|
||
};
|
||
|
||
Window_EquipCommand.prototype.maxCols = function() {
|
||
return 3;
|
||
};
|
||
|
||
Window_EquipCommand.prototype.makeCommandList = function() {
|
||
this.addCommand(TextManager.equip2, "equip");
|
||
this.addCommand(TextManager.optimize, "optimize");
|
||
this.addCommand(TextManager.clear, "clear");
|
||
};
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Window_EquipSlot
|
||
//
|
||
// The window for selecting an equipment slot on the equipment screen.
|
||
|
||
function Window_EquipSlot() {
|
||
this.initialize(...arguments);
|
||
}
|
||
|
||
Window_EquipSlot.prototype = Object.create(Window_StatusBase.prototype);
|
||
Window_EquipSlot.prototype.constructor = Window_EquipSlot;
|
||
|
||
Window_EquipSlot.prototype.initialize = function(rect) {
|
||
Window_StatusBase.prototype.initialize.call(this, rect);
|
||
this._actor = null;
|
||
this.refresh();
|
||
};
|
||
|
||
Window_EquipSlot.prototype.setActor = function(actor) {
|
||
if (this._actor !== actor) {
|
||
this._actor = actor;
|
||
this.refresh();
|
||
}
|
||
};
|
||
|
||
Window_EquipSlot.prototype.update = function() {
|
||
Window_StatusBase.prototype.update.call(this);
|
||
if (this._itemWindow) {
|
||
this._itemWindow.setSlotId(this.index());
|
||
}
|
||
};
|
||
|
||
Window_EquipSlot.prototype.maxItems = function() {
|
||
return this._actor ? this._actor.equipSlots().length : 0;
|
||
};
|
||
|
||
Window_EquipSlot.prototype.item = function() {
|
||
return this.itemAt(this.index());
|
||
};
|
||
|
||
Window_EquipSlot.prototype.itemAt = function(index) {
|
||
return this._actor ? this._actor.equips()[index] : null;
|
||
};
|
||
|
||
Window_EquipSlot.prototype.drawItem = function(index) {
|
||
if (this._actor) {
|
||
const slotName = this.actorSlotName(this._actor, index);
|
||
const item = this.itemAt(index);
|
||
const slotNameWidth = this.slotNameWidth();
|
||
const rect = this.itemLineRect(index);
|
||
const itemWidth = rect.width - slotNameWidth;
|
||
this.changeTextColor(ColorManager.systemColor());
|
||
this.changePaintOpacity(this.isEnabled(index));
|
||
this.drawText(slotName, rect.x, rect.y, slotNameWidth, rect.height);
|
||
this.drawItemName(item, rect.x + slotNameWidth, rect.y, itemWidth);
|
||
this.changePaintOpacity(true);
|
||
}
|
||
};
|
||
|
||
Window_EquipSlot.prototype.slotNameWidth = function() {
|
||
return 138;
|
||
};
|
||
|
||
Window_EquipSlot.prototype.isEnabled = function(index) {
|
||
return this._actor ? this._actor.isEquipChangeOk(index) : false;
|
||
};
|
||
|
||
Window_EquipSlot.prototype.isCurrentItemEnabled = function() {
|
||
return this.isEnabled(this.index());
|
||
};
|
||
|
||
Window_EquipSlot.prototype.setStatusWindow = function(statusWindow) {
|
||
this._statusWindow = statusWindow;
|
||
this.callUpdateHelp();
|
||
};
|
||
|
||
Window_EquipSlot.prototype.setItemWindow = function(itemWindow) {
|
||
this._itemWindow = itemWindow;
|
||
};
|
||
|
||
Window_EquipSlot.prototype.updateHelp = function() {
|
||
Window_StatusBase.prototype.updateHelp.call(this);
|
||
this.setHelpWindowItem(this.item());
|
||
if (this._statusWindow) {
|
||
this._statusWindow.setTempActor(null);
|
||
}
|
||
};
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Window_EquipItem
|
||
//
|
||
// The window for selecting an equipment item on the equipment screen.
|
||
|
||
function Window_EquipItem() {
|
||
this.initialize(...arguments);
|
||
}
|
||
|
||
Window_EquipItem.prototype = Object.create(Window_ItemList.prototype);
|
||
Window_EquipItem.prototype.constructor = Window_EquipItem;
|
||
|
||
Window_EquipItem.prototype.initialize = function(rect) {
|
||
Window_ItemList.prototype.initialize.call(this, rect);
|
||
this._actor = null;
|
||
this._slotId = 0;
|
||
};
|
||
|
||
Window_EquipItem.prototype.maxCols = function() {
|
||
return 1;
|
||
};
|
||
|
||
Window_EquipItem.prototype.colSpacing = function() {
|
||
return 8;
|
||
};
|
||
|
||
Window_EquipItem.prototype.setActor = function(actor) {
|
||
if (this._actor !== actor) {
|
||
this._actor = actor;
|
||
this.refresh();
|
||
this.scrollTo(0, 0);
|
||
}
|
||
};
|
||
|
||
Window_EquipItem.prototype.setSlotId = function(slotId) {
|
||
if (this._slotId !== slotId) {
|
||
this._slotId = slotId;
|
||
this.refresh();
|
||
this.scrollTo(0, 0);
|
||
}
|
||
};
|
||
|
||
Window_EquipItem.prototype.includes = function(item) {
|
||
if (item === null) {
|
||
return true;
|
||
}
|
||
return (
|
||
this._actor &&
|
||
this._actor.canEquip(item) &&
|
||
item.etypeId === this.etypeId()
|
||
);
|
||
};
|
||
|
||
Window_EquipItem.prototype.etypeId = function() {
|
||
if (this._actor && this._slotId >= 0) {
|
||
return this._actor.equipSlots()[this._slotId];
|
||
} else {
|
||
return 0;
|
||
}
|
||
};
|
||
|
||
Window_EquipItem.prototype.isEnabled = function(/*item*/) {
|
||
return true;
|
||
};
|
||
|
||
Window_EquipItem.prototype.selectLast = function() {
|
||
//
|
||
};
|
||
|
||
Window_EquipItem.prototype.setStatusWindow = function(statusWindow) {
|
||
this._statusWindow = statusWindow;
|
||
this.callUpdateHelp();
|
||
};
|
||
|
||
Window_EquipItem.prototype.updateHelp = function() {
|
||
Window_ItemList.prototype.updateHelp.call(this);
|
||
if (this._actor && this._statusWindow && this._slotId >= 0) {
|
||
const actor = JsonEx.makeDeepCopy(this._actor);
|
||
actor.forceChangeEquip(this._slotId, this.item());
|
||
this._statusWindow.setTempActor(actor);
|
||
}
|
||
};
|
||
|
||
Window_EquipItem.prototype.playOkSound = function() {
|
||
//
|
||
};
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Window_Status
|
||
//
|
||
// The window for displaying full status on the status screen.
|
||
|
||
function Window_Status() {
|
||
this.initialize(...arguments);
|
||
}
|
||
|
||
Window_Status.prototype = Object.create(Window_StatusBase.prototype);
|
||
Window_Status.prototype.constructor = Window_Status;
|
||
|
||
Window_Status.prototype.initialize = function(rect) {
|
||
Window_StatusBase.prototype.initialize.call(this, rect);
|
||
this._actor = null;
|
||
this.refresh();
|
||
this.activate();
|
||
};
|
||
|
||
Window_Status.prototype.setActor = function(actor) {
|
||
if (this._actor !== actor) {
|
||
this._actor = actor;
|
||
this.refresh();
|
||
}
|
||
};
|
||
|
||
Window_Status.prototype.refresh = function() {
|
||
Window_StatusBase.prototype.refresh.call(this);
|
||
if (this._actor) {
|
||
this.drawBlock1();
|
||
this.drawBlock2();
|
||
}
|
||
};
|
||
|
||
Window_Status.prototype.drawBlock1 = function() {
|
||
const y = this.block1Y();
|
||
this.drawActorName(this._actor, 6, y, 168);
|
||
this.drawActorClass(this._actor, 192, y, 168);
|
||
this.drawActorNickname(this._actor, 432, y, 270);
|
||
};
|
||
|
||
Window_Status.prototype.block1Y = function() {
|
||
return 0;
|
||
};
|
||
|
||
Window_Status.prototype.drawBlock2 = function() {
|
||
const y = this.block2Y();
|
||
this.drawActorFace(this._actor, 12, y);
|
||
this.drawBasicInfo(204, y);
|
||
this.drawExpInfo(456, y);
|
||
};
|
||
|
||
Window_Status.prototype.block2Y = function() {
|
||
const lineHeight = this.lineHeight();
|
||
const min = lineHeight;
|
||
const max = this.innerHeight - lineHeight * 4;
|
||
return Math.floor((lineHeight * 1.4).clamp(min, max));
|
||
};
|
||
|
||
Window_Status.prototype.drawBasicInfo = function(x, y) {
|
||
const lineHeight = this.lineHeight();
|
||
this.drawActorLevel(this._actor, x, y + lineHeight * 0);
|
||
this.drawActorIcons(this._actor, x, y + lineHeight * 1);
|
||
this.placeBasicGauges(this._actor, x, y + lineHeight * 2);
|
||
};
|
||
|
||
Window_Status.prototype.drawExpInfo = function(x, y) {
|
||
const lineHeight = this.lineHeight();
|
||
const expTotal = TextManager.expTotal.format(TextManager.exp);
|
||
const expNext = TextManager.expNext.format(TextManager.level);
|
||
this.changeTextColor(ColorManager.systemColor());
|
||
this.drawText(expTotal, x, y + lineHeight * 0, 270);
|
||
this.drawText(expNext, x, y + lineHeight * 2, 270);
|
||
this.resetTextColor();
|
||
this.drawText(this.expTotalValue(), x, y + lineHeight * 1, 270, "right");
|
||
this.drawText(this.expNextValue(), x, y + lineHeight * 3, 270, "right");
|
||
};
|
||
|
||
Window_Status.prototype.expTotalValue = function() {
|
||
if (this._actor.isMaxLevel()) {
|
||
return "-------";
|
||
} else {
|
||
return this._actor.currentExp();
|
||
}
|
||
};
|
||
|
||
Window_Status.prototype.expNextValue = function() {
|
||
if (this._actor.isMaxLevel()) {
|
||
return "-------";
|
||
} else {
|
||
return this._actor.nextRequiredExp();
|
||
}
|
||
};
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Window_StatusParams
|
||
//
|
||
// The window for displaying parameters on the status screen.
|
||
|
||
function Window_StatusParams() {
|
||
this.initialize(...arguments);
|
||
}
|
||
|
||
Window_StatusParams.prototype = Object.create(Window_StatusBase.prototype);
|
||
Window_StatusParams.prototype.constructor = Window_StatusParams;
|
||
|
||
Window_StatusParams.prototype.initialize = function(rect) {
|
||
Window_StatusBase.prototype.initialize.call(this, rect);
|
||
this._actor = null;
|
||
};
|
||
|
||
Window_StatusParams.prototype.setActor = function(actor) {
|
||
if (this._actor !== actor) {
|
||
this._actor = actor;
|
||
this.refresh();
|
||
}
|
||
};
|
||
|
||
Window_StatusParams.prototype.maxItems = function() {
|
||
return 6;
|
||
};
|
||
|
||
Window_StatusParams.prototype.itemHeight = function() {
|
||
return this.lineHeight();
|
||
};
|
||
|
||
Window_StatusParams.prototype.drawItem = function(index) {
|
||
const rect = this.itemLineRect(index);
|
||
const paramId = index + 2;
|
||
const name = TextManager.param(paramId);
|
||
const value = this._actor.param(paramId);
|
||
this.changeTextColor(ColorManager.systemColor());
|
||
this.drawText(name, rect.x, rect.y, 160);
|
||
this.resetTextColor();
|
||
this.drawText(value, rect.x + 160, rect.y, 60, "right");
|
||
};
|
||
|
||
Window_StatusParams.prototype.drawItemBackground = function(/*index*/) {
|
||
//
|
||
};
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Window_StatusEquip
|
||
//
|
||
// The window for displaying equipment items on the status screen.
|
||
|
||
function Window_StatusEquip() {
|
||
this.initialize(...arguments);
|
||
}
|
||
|
||
Window_StatusEquip.prototype = Object.create(Window_StatusBase.prototype);
|
||
Window_StatusEquip.prototype.constructor = Window_StatusEquip;
|
||
|
||
Window_StatusEquip.prototype.initialize = function(rect) {
|
||
Window_StatusBase.prototype.initialize.call(this, rect);
|
||
this._actor = null;
|
||
};
|
||
|
||
Window_StatusEquip.prototype.setActor = function(actor) {
|
||
if (this._actor !== actor) {
|
||
this._actor = actor;
|
||
this.refresh();
|
||
}
|
||
};
|
||
|
||
Window_StatusEquip.prototype.maxItems = function() {
|
||
return this._actor ? this._actor.equipSlots().length : 0;
|
||
};
|
||
|
||
Window_StatusEquip.prototype.itemHeight = function() {
|
||
return this.lineHeight();
|
||
};
|
||
|
||
Window_StatusEquip.prototype.drawItem = function(index) {
|
||
const rect = this.itemLineRect(index);
|
||
const equips = this._actor.equips();
|
||
const item = equips[index];
|
||
const slotName = this.actorSlotName(this._actor, index);
|
||
const sw = 138;
|
||
this.changeTextColor(ColorManager.systemColor());
|
||
this.drawText(slotName, rect.x, rect.y, sw, rect.height);
|
||
this.drawItemName(item, rect.x + sw, rect.y, rect.width - sw);
|
||
};
|
||
|
||
Window_StatusEquip.prototype.drawItemBackground = function(/*index*/) {
|
||
//
|
||
};
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Window_Options
|
||
//
|
||
// The window for changing various settings on the options screen.
|
||
|
||
function Window_Options() {
|
||
this.initialize(...arguments);
|
||
}
|
||
|
||
Window_Options.prototype = Object.create(Window_Command.prototype);
|
||
Window_Options.prototype.constructor = Window_Options;
|
||
|
||
Window_Options.prototype.initialize = function(rect) {
|
||
Window_Command.prototype.initialize.call(this, rect);
|
||
};
|
||
|
||
Window_Options.prototype.makeCommandList = function() {
|
||
this.addGeneralOptions();
|
||
this.addVolumeOptions();
|
||
};
|
||
|
||
Window_Options.prototype.addGeneralOptions = function() {
|
||
this.addCommand(TextManager.alwaysDash, "alwaysDash");
|
||
this.addCommand(TextManager.commandRemember, "commandRemember");
|
||
this.addCommand(TextManager.touchUI, "touchUI");
|
||
};
|
||
|
||
Window_Options.prototype.addVolumeOptions = function() {
|
||
this.addCommand(TextManager.bgmVolume, "bgmVolume");
|
||
this.addCommand(TextManager.bgsVolume, "bgsVolume");
|
||
this.addCommand(TextManager.meVolume, "meVolume");
|
||
this.addCommand(TextManager.seVolume, "seVolume");
|
||
};
|
||
|
||
Window_Options.prototype.drawItem = function(index) {
|
||
const title = this.commandName(index);
|
||
const status = this.statusText(index);
|
||
const rect = this.itemLineRect(index);
|
||
const statusWidth = this.statusWidth();
|
||
const titleWidth = rect.width - statusWidth;
|
||
this.resetTextColor();
|
||
this.changePaintOpacity(this.isCommandEnabled(index));
|
||
this.drawText(title, rect.x, rect.y, titleWidth, "left");
|
||
this.drawText(status, rect.x + titleWidth, rect.y, statusWidth, "right");
|
||
};
|
||
|
||
Window_Options.prototype.statusWidth = function() {
|
||
return 120;
|
||
};
|
||
|
||
Window_Options.prototype.statusText = function(index) {
|
||
const symbol = this.commandSymbol(index);
|
||
const value = this.getConfigValue(symbol);
|
||
if (this.isVolumeSymbol(symbol)) {
|
||
return this.volumeStatusText(value);
|
||
} else {
|
||
return this.booleanStatusText(value);
|
||
}
|
||
};
|
||
|
||
Window_Options.prototype.isVolumeSymbol = function(symbol) {
|
||
return symbol.includes("Volume");
|
||
};
|
||
|
||
Window_Options.prototype.booleanStatusText = function(value) {
|
||
return value ? "ON" : "OFF";
|
||
};
|
||
|
||
Window_Options.prototype.volumeStatusText = function(value) {
|
||
return value + "%";
|
||
};
|
||
|
||
Window_Options.prototype.processOk = function() {
|
||
const index = this.index();
|
||
const symbol = this.commandSymbol(index);
|
||
if (this.isVolumeSymbol(symbol)) {
|
||
this.changeVolume(symbol, true, true);
|
||
} else {
|
||
this.changeValue(symbol, !this.getConfigValue(symbol));
|
||
}
|
||
};
|
||
|
||
Window_Options.prototype.cursorRight = function() {
|
||
const index = this.index();
|
||
const symbol = this.commandSymbol(index);
|
||
if (this.isVolumeSymbol(symbol)) {
|
||
this.changeVolume(symbol, true, false);
|
||
} else {
|
||
this.changeValue(symbol, true);
|
||
}
|
||
};
|
||
|
||
Window_Options.prototype.cursorLeft = function() {
|
||
const index = this.index();
|
||
const symbol = this.commandSymbol(index);
|
||
if (this.isVolumeSymbol(symbol)) {
|
||
this.changeVolume(symbol, false, false);
|
||
} else {
|
||
this.changeValue(symbol, false);
|
||
}
|
||
};
|
||
|
||
Window_Options.prototype.changeVolume = function(symbol, forward, wrap) {
|
||
const lastValue = this.getConfigValue(symbol);
|
||
const offset = this.volumeOffset();
|
||
const value = lastValue + (forward ? offset : -offset);
|
||
if (value > 100 && wrap) {
|
||
this.changeValue(symbol, 0);
|
||
} else {
|
||
this.changeValue(symbol, value.clamp(0, 100));
|
||
}
|
||
};
|
||
|
||
Window_Options.prototype.volumeOffset = function() {
|
||
return 20;
|
||
};
|
||
|
||
Window_Options.prototype.changeValue = function(symbol, value) {
|
||
const lastValue = this.getConfigValue(symbol);
|
||
if (lastValue !== value) {
|
||
this.setConfigValue(symbol, value);
|
||
this.redrawItem(this.findSymbol(symbol));
|
||
this.playCursorSound();
|
||
}
|
||
};
|
||
|
||
Window_Options.prototype.getConfigValue = function(symbol) {
|
||
return ConfigManager[symbol];
|
||
};
|
||
|
||
Window_Options.prototype.setConfigValue = function(symbol, volume) {
|
||
ConfigManager[symbol] = volume;
|
||
};
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Window_SavefileList
|
||
//
|
||
// The window for selecting a save file on the save and load screens.
|
||
|
||
function Window_SavefileList() {
|
||
this.initialize(...arguments);
|
||
}
|
||
|
||
Window_SavefileList.prototype = Object.create(Window_Selectable.prototype);
|
||
Window_SavefileList.prototype.constructor = Window_SavefileList;
|
||
|
||
Window_SavefileList.prototype.initialize = function(rect) {
|
||
Window_Selectable.prototype.initialize.call(this, rect);
|
||
this.activate();
|
||
this._mode = null;
|
||
this._autosave = false;
|
||
};
|
||
|
||
Window_SavefileList.prototype.setMode = function(mode, autosave) {
|
||
this._mode = mode;
|
||
this._autosave = autosave;
|
||
this.refresh();
|
||
};
|
||
|
||
Window_SavefileList.prototype.maxItems = function() {
|
||
return DataManager.maxSavefiles() - (this._autosave ? 0 : 1);
|
||
};
|
||
|
||
Window_SavefileList.prototype.numVisibleRows = function() {
|
||
return 5;
|
||
};
|
||
|
||
Window_SavefileList.prototype.itemHeight = function() {
|
||
return Math.floor(this.innerHeight / this.numVisibleRows());
|
||
};
|
||
|
||
Window_SavefileList.prototype.drawItem = function(index) {
|
||
const savefileId = this.indexToSavefileId(index);
|
||
const info = DataManager.savefileInfo(savefileId);
|
||
const rect = this.itemRectWithPadding(index);
|
||
this.resetTextColor();
|
||
this.changePaintOpacity(this.isEnabled(savefileId));
|
||
this.drawTitle(savefileId, rect.x, rect.y + 4);
|
||
if (info) {
|
||
this.drawContents(info, rect);
|
||
}
|
||
};
|
||
|
||
Window_SavefileList.prototype.indexToSavefileId = function(index) {
|
||
return index + (this._autosave ? 0 : 1);
|
||
};
|
||
|
||
Window_SavefileList.prototype.savefileIdToIndex = function(savefileId) {
|
||
return savefileId - (this._autosave ? 0 : 1);
|
||
};
|
||
|
||
Window_SavefileList.prototype.isEnabled = function(savefileId) {
|
||
if (this._mode === "save") {
|
||
return savefileId > 0;
|
||
} else {
|
||
return !!DataManager.savefileInfo(savefileId);
|
||
}
|
||
};
|
||
|
||
Window_SavefileList.prototype.savefileId = function() {
|
||
return this.indexToSavefileId(this.index());
|
||
};
|
||
|
||
Window_SavefileList.prototype.selectSavefile = function(savefileId) {
|
||
const index = Math.max(0, this.savefileIdToIndex(savefileId));
|
||
this.select(index);
|
||
this.setTopRow(index - 2);
|
||
};
|
||
|
||
Window_SavefileList.prototype.drawTitle = function(savefileId, x, y) {
|
||
if (savefileId === 0) {
|
||
this.drawText(TextManager.autosave, x, y, 180);
|
||
} else {
|
||
this.drawText(TextManager.file + " " + savefileId, x, y, 180);
|
||
}
|
||
};
|
||
|
||
Window_SavefileList.prototype.drawContents = function(info, rect) {
|
||
const bottom = rect.y + rect.height;
|
||
if (rect.width >= 420) {
|
||
this.drawPartyCharacters(info, rect.x + 220, bottom - 8);
|
||
}
|
||
const lineHeight = this.lineHeight();
|
||
const y2 = bottom - lineHeight - 4;
|
||
if (y2 >= lineHeight) {
|
||
this.drawPlaytime(info, rect.x, y2, rect.width);
|
||
}
|
||
};
|
||
|
||
Window_SavefileList.prototype.drawPartyCharacters = function(info, x, y) {
|
||
if (info.characters) {
|
||
let characterX = x;
|
||
for (const data of info.characters) {
|
||
this.drawCharacter(data[0], data[1], characterX, y);
|
||
characterX += 48;
|
||
}
|
||
}
|
||
};
|
||
|
||
Window_SavefileList.prototype.drawPlaytime = function(info, x, y, width) {
|
||
if (info.playtime) {
|
||
this.drawText(info.playtime, x, y, width, "right");
|
||
}
|
||
};
|
||
|
||
Window_SavefileList.prototype.playOkSound = function() {
|
||
//
|
||
};
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Window_ShopCommand
|
||
//
|
||
// The window for selecting buy/sell on the shop screen.
|
||
|
||
function Window_ShopCommand() {
|
||
this.initialize(...arguments);
|
||
}
|
||
|
||
Window_ShopCommand.prototype = Object.create(Window_HorzCommand.prototype);
|
||
Window_ShopCommand.prototype.constructor = Window_ShopCommand;
|
||
|
||
Window_ShopCommand.prototype.initialize = function(rect) {
|
||
Window_HorzCommand.prototype.initialize.call(this, rect);
|
||
};
|
||
|
||
Window_ShopCommand.prototype.setPurchaseOnly = function(purchaseOnly) {
|
||
this._purchaseOnly = purchaseOnly;
|
||
this.refresh();
|
||
};
|
||
|
||
Window_ShopCommand.prototype.maxCols = function() {
|
||
return 3;
|
||
};
|
||
|
||
Window_ShopCommand.prototype.makeCommandList = function() {
|
||
this.addCommand(TextManager.buy, "buy");
|
||
this.addCommand(TextManager.sell, "sell", !this._purchaseOnly);
|
||
this.addCommand(TextManager.cancel, "cancel");
|
||
};
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Window_ShopBuy
|
||
//
|
||
// The window for selecting an item to buy on the shop screen.
|
||
|
||
function Window_ShopBuy() {
|
||
this.initialize(...arguments);
|
||
}
|
||
|
||
Window_ShopBuy.prototype = Object.create(Window_Selectable.prototype);
|
||
Window_ShopBuy.prototype.constructor = Window_ShopBuy;
|
||
|
||
Window_ShopBuy.prototype.initialize = function(rect) {
|
||
Window_Selectable.prototype.initialize.call(this, rect);
|
||
this._money = 0;
|
||
};
|
||
|
||
Window_ShopBuy.prototype.setupGoods = function(shopGoods) {
|
||
this._shopGoods = shopGoods;
|
||
this.refresh();
|
||
this.select(0);
|
||
};
|
||
|
||
Window_ShopBuy.prototype.maxItems = function() {
|
||
return this._data ? this._data.length : 1;
|
||
};
|
||
|
||
Window_ShopBuy.prototype.item = function() {
|
||
return this.itemAt(this.index());
|
||
};
|
||
|
||
Window_ShopBuy.prototype.itemAt = function(index) {
|
||
return this._data && index >= 0 ? this._data[index] : null;
|
||
};
|
||
|
||
Window_ShopBuy.prototype.setMoney = function(money) {
|
||
this._money = money;
|
||
this.refresh();
|
||
};
|
||
|
||
Window_ShopBuy.prototype.isCurrentItemEnabled = function() {
|
||
return this.isEnabled(this._data[this.index()]);
|
||
};
|
||
|
||
Window_ShopBuy.prototype.price = function(item) {
|
||
return this._price[this._data.indexOf(item)] || 0;
|
||
};
|
||
|
||
Window_ShopBuy.prototype.isEnabled = function(item) {
|
||
return (
|
||
item && this.price(item) <= this._money && !$gameParty.hasMaxItems(item)
|
||
);
|
||
};
|
||
|
||
Window_ShopBuy.prototype.refresh = function() {
|
||
this.makeItemList();
|
||
Window_Selectable.prototype.refresh.call(this);
|
||
};
|
||
|
||
Window_ShopBuy.prototype.makeItemList = function() {
|
||
this._data = [];
|
||
this._price = [];
|
||
for (const goods of this._shopGoods) {
|
||
const item = this.goodsToItem(goods);
|
||
if (item) {
|
||
this._data.push(item);
|
||
this._price.push(goods[2] === 0 ? item.price : goods[3]);
|
||
}
|
||
}
|
||
};
|
||
|
||
Window_ShopBuy.prototype.goodsToItem = function(goods) {
|
||
switch (goods[0]) {
|
||
case 0:
|
||
return $dataItems[goods[1]];
|
||
case 1:
|
||
return $dataWeapons[goods[1]];
|
||
case 2:
|
||
return $dataArmors[goods[1]];
|
||
default:
|
||
return null;
|
||
}
|
||
};
|
||
|
||
Window_ShopBuy.prototype.drawItem = function(index) {
|
||
const item = this.itemAt(index);
|
||
const price = this.price(item);
|
||
const rect = this.itemLineRect(index);
|
||
const priceWidth = this.priceWidth();
|
||
const priceX = rect.x + rect.width - priceWidth;
|
||
const nameWidth = rect.width - priceWidth;
|
||
this.changePaintOpacity(this.isEnabled(item));
|
||
this.drawItemName(item, rect.x, rect.y, nameWidth);
|
||
this.drawText(price, priceX, rect.y, priceWidth, "right");
|
||
this.changePaintOpacity(true);
|
||
};
|
||
|
||
Window_ShopBuy.prototype.priceWidth = function() {
|
||
return 96;
|
||
};
|
||
|
||
Window_ShopBuy.prototype.setStatusWindow = function(statusWindow) {
|
||
this._statusWindow = statusWindow;
|
||
this.callUpdateHelp();
|
||
};
|
||
|
||
Window_ShopBuy.prototype.updateHelp = function() {
|
||
this.setHelpWindowItem(this.item());
|
||
if (this._statusWindow) {
|
||
this._statusWindow.setItem(this.item());
|
||
}
|
||
};
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Window_ShopSell
|
||
//
|
||
// The window for selecting an item to sell on the shop screen.
|
||
|
||
function Window_ShopSell() {
|
||
this.initialize(...arguments);
|
||
}
|
||
|
||
Window_ShopSell.prototype = Object.create(Window_ItemList.prototype);
|
||
Window_ShopSell.prototype.constructor = Window_ShopSell;
|
||
|
||
Window_ShopSell.prototype.initialize = function(rect) {
|
||
Window_ItemList.prototype.initialize.call(this, rect);
|
||
};
|
||
|
||
Window_ShopSell.prototype.isEnabled = function(item) {
|
||
return item && item.price > 0;
|
||
};
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Window_ShopNumber
|
||
//
|
||
// The window for inputting quantity of items to buy or sell on the shop
|
||
// screen.
|
||
|
||
function Window_ShopNumber() {
|
||
this.initialize(...arguments);
|
||
}
|
||
|
||
Window_ShopNumber.prototype = Object.create(Window_Selectable.prototype);
|
||
Window_ShopNumber.prototype.constructor = Window_ShopNumber;
|
||
|
||
Window_ShopNumber.prototype.initialize = function(rect) {
|
||
Window_Selectable.prototype.initialize.call(this, rect);
|
||
this._item = null;
|
||
this._max = 1;
|
||
this._price = 0;
|
||
this._number = 1;
|
||
this._currencyUnit = TextManager.currencyUnit;
|
||
this.createButtons();
|
||
this.select(0);
|
||
this._canRepeat = false;
|
||
};
|
||
|
||
Window_ShopNumber.prototype.isScrollEnabled = function() {
|
||
return false;
|
||
};
|
||
|
||
Window_ShopNumber.prototype.number = function() {
|
||
return this._number;
|
||
};
|
||
|
||
Window_ShopNumber.prototype.setup = function(item, max, price) {
|
||
this._item = item;
|
||
this._max = Math.floor(max);
|
||
this._price = price;
|
||
this._number = 1;
|
||
this.placeButtons();
|
||
this.refresh();
|
||
};
|
||
|
||
Window_ShopNumber.prototype.setCurrencyUnit = function(currencyUnit) {
|
||
this._currencyUnit = currencyUnit;
|
||
this.refresh();
|
||
};
|
||
|
||
Window_ShopNumber.prototype.createButtons = function() {
|
||
this._buttons = [];
|
||
if (ConfigManager.touchUI) {
|
||
for (const type of ["down2", "down", "up", "up2", "ok"]) {
|
||
const button = new Sprite_Button(type);
|
||
this._buttons.push(button);
|
||
this.addInnerChild(button);
|
||
}
|
||
this._buttons[0].setClickHandler(this.onButtonDown2.bind(this));
|
||
this._buttons[1].setClickHandler(this.onButtonDown.bind(this));
|
||
this._buttons[2].setClickHandler(this.onButtonUp.bind(this));
|
||
this._buttons[3].setClickHandler(this.onButtonUp2.bind(this));
|
||
this._buttons[4].setClickHandler(this.onButtonOk.bind(this));
|
||
}
|
||
};
|
||
|
||
Window_ShopNumber.prototype.placeButtons = function() {
|
||
const sp = this.buttonSpacing();
|
||
const totalWidth = this.totalButtonWidth();
|
||
let x = (this.innerWidth - totalWidth) / 2;
|
||
for (const button of this._buttons) {
|
||
button.x = x;
|
||
button.y = this.buttonY();
|
||
x += button.width + sp;
|
||
}
|
||
};
|
||
|
||
Window_ShopNumber.prototype.totalButtonWidth = function() {
|
||
const sp = this.buttonSpacing();
|
||
return this._buttons.reduce((r, button) => r + button.width + sp, -sp);
|
||
};
|
||
|
||
Window_ShopNumber.prototype.buttonSpacing = function() {
|
||
return 8;
|
||
};
|
||
|
||
Window_ShopNumber.prototype.refresh = function() {
|
||
Window_Selectable.prototype.refresh.call(this);
|
||
this.drawItemBackground(0);
|
||
this.drawCurrentItemName();
|
||
this.drawMultiplicationSign();
|
||
this.drawNumber();
|
||
this.drawHorzLine();
|
||
this.drawTotalPrice();
|
||
};
|
||
|
||
Window_ShopNumber.prototype.drawCurrentItemName = function() {
|
||
const padding = this.itemPadding();
|
||
const x = padding * 2;
|
||
const y = this.itemNameY();
|
||
const width = this.multiplicationSignX() - padding * 3;
|
||
this.drawItemName(this._item, x, y, width);
|
||
};
|
||
|
||
Window_ShopNumber.prototype.drawMultiplicationSign = function() {
|
||
const sign = this.multiplicationSign();
|
||
const width = this.textWidth(sign);
|
||
const x = this.multiplicationSignX();
|
||
const y = this.itemNameY();
|
||
this.resetTextColor();
|
||
this.drawText(sign, x, y, width);
|
||
};
|
||
|
||
Window_ShopNumber.prototype.multiplicationSign = function() {
|
||
return "\u00d7";
|
||
};
|
||
|
||
Window_ShopNumber.prototype.multiplicationSignX = function() {
|
||
const sign = this.multiplicationSign();
|
||
const width = this.textWidth(sign);
|
||
return this.cursorX() - width * 2;
|
||
};
|
||
|
||
Window_ShopNumber.prototype.drawNumber = function() {
|
||
const x = this.cursorX();
|
||
const y = this.itemNameY();
|
||
const width = this.cursorWidth() - this.itemPadding();
|
||
this.resetTextColor();
|
||
this.drawText(this._number, x, y, width, "right");
|
||
};
|
||
|
||
Window_ShopNumber.prototype.drawHorzLine = function() {
|
||
const padding = this.itemPadding();
|
||
const lineHeight = this.lineHeight();
|
||
const itemY = this.itemNameY();
|
||
const totalY = this.totalPriceY();
|
||
const x = padding;
|
||
const y = Math.floor((itemY + totalY + lineHeight) / 2);
|
||
const width = this.innerWidth - padding * 2;
|
||
this.drawRect(x, y, width, 5);
|
||
};
|
||
|
||
Window_ShopNumber.prototype.drawTotalPrice = function() {
|
||
const padding = this.itemPadding();
|
||
const total = this._price * this._number;
|
||
const width = this.innerWidth - padding * 2;
|
||
const y = this.totalPriceY();
|
||
this.drawCurrencyValue(total, this._currencyUnit, 0, y, width);
|
||
};
|
||
|
||
Window_ShopNumber.prototype.itemNameY = function() {
|
||
return Math.floor(this.innerHeight / 2 - this.lineHeight() * 1.5);
|
||
};
|
||
|
||
Window_ShopNumber.prototype.totalPriceY = function() {
|
||
return Math.floor(this.itemNameY() + this.lineHeight() * 2);
|
||
};
|
||
|
||
Window_ShopNumber.prototype.buttonY = function() {
|
||
return Math.floor(this.totalPriceY() + this.lineHeight() * 2);
|
||
};
|
||
|
||
Window_ShopNumber.prototype.cursorWidth = function() {
|
||
const padding = this.itemPadding();
|
||
const digitWidth = this.textWidth("0");
|
||
return this.maxDigits() * digitWidth + padding * 2;
|
||
};
|
||
|
||
Window_ShopNumber.prototype.cursorX = function() {
|
||
const padding = this.itemPadding();
|
||
return this.innerWidth - this.cursorWidth() - padding * 2;
|
||
};
|
||
|
||
Window_ShopNumber.prototype.maxDigits = function() {
|
||
return 2;
|
||
};
|
||
|
||
Window_ShopNumber.prototype.update = function() {
|
||
Window_Selectable.prototype.update.call(this);
|
||
this.processNumberChange();
|
||
};
|
||
|
||
Window_ShopNumber.prototype.playOkSound = function() {
|
||
//
|
||
};
|
||
|
||
Window_ShopNumber.prototype.processNumberChange = function() {
|
||
if (this.isOpenAndActive()) {
|
||
if (Input.isRepeated("right")) {
|
||
this.changeNumber(1);
|
||
}
|
||
if (Input.isRepeated("left")) {
|
||
this.changeNumber(-1);
|
||
}
|
||
if (Input.isRepeated("up")) {
|
||
this.changeNumber(10);
|
||
}
|
||
if (Input.isRepeated("down")) {
|
||
this.changeNumber(-10);
|
||
}
|
||
}
|
||
};
|
||
|
||
Window_ShopNumber.prototype.changeNumber = function(amount) {
|
||
const lastNumber = this._number;
|
||
this._number = (this._number + amount).clamp(1, this._max);
|
||
if (this._number !== lastNumber) {
|
||
this.playCursorSound();
|
||
this.refresh();
|
||
}
|
||
};
|
||
|
||
Window_ShopNumber.prototype.itemRect = function() {
|
||
const rect = new Rectangle();
|
||
rect.x = this.cursorX();
|
||
rect.y = this.itemNameY();
|
||
rect.width = this.cursorWidth();
|
||
rect.height = this.lineHeight();
|
||
return rect;
|
||
};
|
||
|
||
Window_ShopNumber.prototype.isTouchOkEnabled = function() {
|
||
return false;
|
||
};
|
||
|
||
Window_ShopNumber.prototype.onButtonUp = function() {
|
||
this.changeNumber(1);
|
||
};
|
||
|
||
Window_ShopNumber.prototype.onButtonUp2 = function() {
|
||
this.changeNumber(10);
|
||
};
|
||
|
||
Window_ShopNumber.prototype.onButtonDown = function() {
|
||
this.changeNumber(-1);
|
||
};
|
||
|
||
Window_ShopNumber.prototype.onButtonDown2 = function() {
|
||
this.changeNumber(-10);
|
||
};
|
||
|
||
Window_ShopNumber.prototype.onButtonOk = function() {
|
||
this.processOk();
|
||
};
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Window_ShopStatus
|
||
//
|
||
// The window for displaying number of items in possession and the actor's
|
||
// equipment on the shop screen.
|
||
|
||
function Window_ShopStatus() {
|
||
this.initialize(...arguments);
|
||
}
|
||
|
||
Window_ShopStatus.prototype = Object.create(Window_StatusBase.prototype);
|
||
Window_ShopStatus.prototype.constructor = Window_ShopStatus;
|
||
|
||
Window_ShopStatus.prototype.initialize = function(rect) {
|
||
Window_StatusBase.prototype.initialize.call(this, rect);
|
||
this._item = null;
|
||
this._pageIndex = 0;
|
||
this.refresh();
|
||
};
|
||
|
||
Window_ShopStatus.prototype.refresh = function() {
|
||
this.contents.clear();
|
||
if (this._item) {
|
||
const x = this.itemPadding();
|
||
this.drawPossession(x, 0);
|
||
if (this.isEquipItem()) {
|
||
const y = Math.floor(this.lineHeight() * 1.5);
|
||
this.drawEquipInfo(x, y);
|
||
}
|
||
}
|
||
};
|
||
|
||
Window_ShopStatus.prototype.setItem = function(item) {
|
||
this._item = item;
|
||
this.refresh();
|
||
};
|
||
|
||
Window_ShopStatus.prototype.isEquipItem = function() {
|
||
return DataManager.isWeapon(this._item) || DataManager.isArmor(this._item);
|
||
};
|
||
|
||
Window_ShopStatus.prototype.drawPossession = function(x, y) {
|
||
const width = this.innerWidth - this.itemPadding() - x;
|
||
const possessionWidth = this.textWidth("0000");
|
||
this.changeTextColor(ColorManager.systemColor());
|
||
this.drawText(TextManager.possession, x, y, width - possessionWidth);
|
||
this.resetTextColor();
|
||
this.drawText($gameParty.numItems(this._item), x, y, width, "right");
|
||
};
|
||
|
||
Window_ShopStatus.prototype.drawEquipInfo = function(x, y) {
|
||
const members = this.statusMembers();
|
||
for (let i = 0; i < members.length; i++) {
|
||
const actorY = y + Math.floor(this.lineHeight() * i * 2.2);
|
||
this.drawActorEquipInfo(x, actorY, members[i]);
|
||
}
|
||
};
|
||
|
||
Window_ShopStatus.prototype.statusMembers = function() {
|
||
const start = this._pageIndex * this.pageSize();
|
||
const end = start + this.pageSize();
|
||
return $gameParty.members().slice(start, end);
|
||
};
|
||
|
||
Window_ShopStatus.prototype.pageSize = function() {
|
||
return 4;
|
||
};
|
||
|
||
Window_ShopStatus.prototype.maxPages = function() {
|
||
return Math.floor(
|
||
($gameParty.size() + this.pageSize() - 1) / this.pageSize()
|
||
);
|
||
};
|
||
|
||
Window_ShopStatus.prototype.drawActorEquipInfo = function(x, y, actor) {
|
||
const item1 = this.currentEquippedItem(actor, this._item.etypeId);
|
||
const width = this.innerWidth - x - this.itemPadding();
|
||
const enabled = actor.canEquip(this._item);
|
||
this.changePaintOpacity(enabled);
|
||
this.resetTextColor();
|
||
this.drawText(actor.name(), x, y, width);
|
||
if (enabled) {
|
||
this.drawActorParamChange(x, y, actor, item1);
|
||
}
|
||
this.drawItemName(item1, x, y + this.lineHeight(), width);
|
||
this.changePaintOpacity(true);
|
||
};
|
||
|
||
// prettier-ignore
|
||
Window_ShopStatus.prototype.drawActorParamChange = function(
|
||
x, y, actor, item1
|
||
) {
|
||
const width = this.innerWidth - this.itemPadding() - x;
|
||
const paramId = this.paramId();
|
||
const change =
|
||
this._item.params[paramId] - (item1 ? item1.params[paramId] : 0);
|
||
this.changeTextColor(ColorManager.paramchangeTextColor(change));
|
||
this.drawText((change > 0 ? "+" : "") + change, x, y, width, "right");
|
||
};
|
||
|
||
Window_ShopStatus.prototype.paramId = function() {
|
||
return DataManager.isWeapon(this._item) ? 2 : 3;
|
||
};
|
||
|
||
Window_ShopStatus.prototype.currentEquippedItem = function(actor, etypeId) {
|
||
const list = [];
|
||
const equips = actor.equips();
|
||
const slots = actor.equipSlots();
|
||
for (let i = 0; i < slots.length; i++) {
|
||
if (slots[i] === etypeId) {
|
||
list.push(equips[i]);
|
||
}
|
||
}
|
||
const paramId = this.paramId();
|
||
let worstParam = Number.MAX_VALUE;
|
||
let worstItem = null;
|
||
for (const item of list) {
|
||
if (item && item.params[paramId] < worstParam) {
|
||
worstParam = item.params[paramId];
|
||
worstItem = item;
|
||
}
|
||
}
|
||
return worstItem;
|
||
};
|
||
|
||
Window_ShopStatus.prototype.update = function() {
|
||
Window_StatusBase.prototype.update.call(this);
|
||
this.updatePage();
|
||
};
|
||
|
||
Window_ShopStatus.prototype.updatePage = function() {
|
||
if (this.isPageChangeEnabled() && this.isPageChangeRequested()) {
|
||
this.changePage();
|
||
}
|
||
};
|
||
|
||
Window_ShopStatus.prototype.isPageChangeEnabled = function() {
|
||
return this.visible && this.maxPages() >= 2;
|
||
};
|
||
|
||
Window_ShopStatus.prototype.isPageChangeRequested = function() {
|
||
if (Input.isTriggered("shift")) {
|
||
return true;
|
||
}
|
||
if (TouchInput.isTriggered() && this.isTouchedInsideFrame()) {
|
||
return true;
|
||
}
|
||
return false;
|
||
};
|
||
|
||
Window_ShopStatus.prototype.changePage = function() {
|
||
this._pageIndex = (this._pageIndex + 1) % this.maxPages();
|
||
this.refresh();
|
||
this.playCursorSound();
|
||
};
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Window_NameEdit
|
||
//
|
||
// The window for editing an actor's name on the name input screen.
|
||
|
||
function Window_NameEdit() {
|
||
this.initialize(...arguments);
|
||
}
|
||
|
||
Window_NameEdit.prototype = Object.create(Window_StatusBase.prototype);
|
||
Window_NameEdit.prototype.constructor = Window_NameEdit;
|
||
|
||
Window_NameEdit.prototype.initialize = function(rect) {
|
||
Window_StatusBase.prototype.initialize.call(this, rect);
|
||
this._actor = null;
|
||
this._maxLength = 0;
|
||
this._name = "";
|
||
this._index = 0;
|
||
this._defaultName = 0;
|
||
this.deactivate();
|
||
};
|
||
|
||
Window_NameEdit.prototype.setup = function(actor, maxLength) {
|
||
this._actor = actor;
|
||
this._maxLength = maxLength;
|
||
this._name = actor.name().slice(0, this._maxLength);
|
||
this._index = this._name.length;
|
||
this._defaultName = this._name;
|
||
ImageManager.loadFace(actor.faceName());
|
||
};
|
||
|
||
Window_NameEdit.prototype.name = function() {
|
||
return this._name;
|
||
};
|
||
|
||
Window_NameEdit.prototype.restoreDefault = function() {
|
||
this._name = this._defaultName;
|
||
this._index = this._name.length;
|
||
this.refresh();
|
||
return this._name.length > 0;
|
||
};
|
||
|
||
Window_NameEdit.prototype.add = function(ch) {
|
||
if (this._index < this._maxLength) {
|
||
this._name += ch;
|
||
this._index++;
|
||
this.refresh();
|
||
return true;
|
||
} else {
|
||
return false;
|
||
}
|
||
};
|
||
|
||
Window_NameEdit.prototype.back = function() {
|
||
if (this._index > 0) {
|
||
this._index--;
|
||
this._name = this._name.slice(0, this._index);
|
||
this.refresh();
|
||
return true;
|
||
} else {
|
||
return false;
|
||
}
|
||
};
|
||
|
||
Window_NameEdit.prototype.faceWidth = function() {
|
||
return 144;
|
||
};
|
||
|
||
Window_NameEdit.prototype.charWidth = function() {
|
||
const text = $gameSystem.isJapanese() ? "\uff21" : "A";
|
||
return this.textWidth(text);
|
||
};
|
||
|
||
Window_NameEdit.prototype.left = function() {
|
||
const nameCenter = (this.innerWidth + this.faceWidth()) / 2;
|
||
const nameWidth = (this._maxLength + 1) * this.charWidth();
|
||
return Math.min(nameCenter - nameWidth / 2, this.innerWidth - nameWidth);
|
||
};
|
||
|
||
Window_NameEdit.prototype.itemRect = function(index) {
|
||
const x = this.left() + index * this.charWidth();
|
||
const y = 54;
|
||
const width = this.charWidth();
|
||
const height = this.lineHeight();
|
||
return new Rectangle(x, y, width, height);
|
||
};
|
||
|
||
Window_NameEdit.prototype.underlineRect = function(index) {
|
||
const rect = this.itemRect(index);
|
||
rect.x++;
|
||
rect.y += rect.height - 4;
|
||
rect.width -= 2;
|
||
rect.height = 2;
|
||
return rect;
|
||
};
|
||
|
||
Window_NameEdit.prototype.underlineColor = function() {
|
||
return ColorManager.normalColor();
|
||
};
|
||
|
||
Window_NameEdit.prototype.drawUnderline = function(index) {
|
||
const rect = this.underlineRect(index);
|
||
const color = this.underlineColor();
|
||
this.contents.paintOpacity = 48;
|
||
this.contents.fillRect(rect.x, rect.y, rect.width, rect.height, color);
|
||
this.contents.paintOpacity = 255;
|
||
};
|
||
|
||
Window_NameEdit.prototype.drawChar = function(index) {
|
||
const rect = this.itemRect(index);
|
||
this.resetTextColor();
|
||
this.drawText(this._name[index] || "", rect.x, rect.y);
|
||
};
|
||
|
||
Window_NameEdit.prototype.refresh = function() {
|
||
this.contents.clear();
|
||
this.drawActorFace(this._actor, 0, 0);
|
||
for (let i = 0; i < this._maxLength; i++) {
|
||
this.drawUnderline(i);
|
||
}
|
||
for (let j = 0; j < this._name.length; j++) {
|
||
this.drawChar(j);
|
||
}
|
||
const rect = this.itemRect(this._index);
|
||
this.setCursorRect(rect.x, rect.y, rect.width, rect.height);
|
||
};
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Window_NameInput
|
||
//
|
||
// The window for selecting text characters on the name input screen.
|
||
|
||
function Window_NameInput() {
|
||
this.initialize(...arguments);
|
||
}
|
||
|
||
Window_NameInput.prototype = Object.create(Window_Selectable.prototype);
|
||
Window_NameInput.prototype.constructor = Window_NameInput;
|
||
|
||
// prettier-ignore
|
||
Window_NameInput.LATIN1 =
|
||
[ "A","B","C","D","E", "a","b","c","d","e",
|
||
"F","G","H","I","J", "f","g","h","i","j",
|
||
"K","L","M","N","O", "k","l","m","n","o",
|
||
"P","Q","R","S","T", "p","q","r","s","t",
|
||
"U","V","W","X","Y", "u","v","w","x","y",
|
||
"Z","[","]","^","_", "z","{","}","|","~",
|
||
"0","1","2","3","4", "!","#","$","%","&",
|
||
"5","6","7","8","9", "(",")","*","+","-",
|
||
"/","=","@","<",">", ":",";"," ","Page","OK" ];
|
||
// prettier-ignore
|
||
Window_NameInput.LATIN2 =
|
||
[ "Á","É","Í","Ó","Ú", "á","é","í","ó","ú",
|
||
"À","È","Ì","Ò","Ù", "à","è","ì","ò","ù",
|
||
"Â","Ê","Î","Ô","Û", "â","ê","î","ô","û",
|
||
"Ä","Ë","Ï","Ö","Ü", "ä","ë","ï","ö","ü",
|
||
"Ā","Ē","Ī","Ō","Ū", "ā","ē","ī","ō","ū",
|
||
"Ã","Å","Æ","Ç","Ð", "ã","å","æ","ç","ð",
|
||
"Ñ","Õ","Ø","Š","Ŵ", "ñ","õ","ø","š","ŵ",
|
||
"Ý","Ŷ","Ÿ","Ž","Þ", "ý","ÿ","ŷ","ž","þ",
|
||
"IJ","Œ","ij","œ","ß", "«","»"," ","Page","OK" ];
|
||
// prettier-ignore
|
||
Window_NameInput.RUSSIA =
|
||
[ "А","Б","В","Г","Д", "а","б","в","г","д",
|
||
"Е","Ё","Ж","З","И", "е","ё","ж","з","и",
|
||
"Й","К","Л","М","Н", "й","к","л","м","н",
|
||
"О","П","Р","С","Т", "о","п","р","с","т",
|
||
"У","Ф","Х","Ц","Ч", "у","ф","х","ц","ч",
|
||
"Ш","Щ","Ъ","Ы","Ь", "ш","щ","ъ","ы","ь",
|
||
"Э","Ю","Я","^","_", "э","ю","я","%","&",
|
||
"0","1","2","3","4", "(",")","*","+","-",
|
||
"5","6","7","8","9", ":",";"," ","","OK" ];
|
||
// prettier-ignore
|
||
Window_NameInput.JAPAN1 =
|
||
[ "あ","い","う","え","お", "が","ぎ","ぐ","げ","ご",
|
||
"か","き","く","け","こ", "ざ","じ","ず","ぜ","ぞ",
|
||
"さ","し","す","せ","そ", "だ","ぢ","づ","で","ど",
|
||
"た","ち","つ","て","と", "ば","び","ぶ","べ","ぼ",
|
||
"な","に","ぬ","ね","の", "ぱ","ぴ","ぷ","ぺ","ぽ",
|
||
"は","ひ","ふ","へ","ほ", "ぁ","ぃ","ぅ","ぇ","ぉ",
|
||
"ま","み","む","め","も", "っ","ゃ","ゅ","ょ","ゎ",
|
||
"や","ゆ","よ","わ","ん", "ー","～","・","＝","☆",
|
||
"ら","り","る","れ","ろ", "ゔ","を"," ","カナ","決定" ];
|
||
// prettier-ignore
|
||
Window_NameInput.JAPAN2 =
|
||
[ "ア","イ","ウ","エ","オ", "ガ","ギ","グ","ゲ","ゴ",
|
||
"カ","キ","ク","ケ","コ", "ザ","ジ","ズ","ゼ","ゾ",
|
||
"サ","シ","ス","セ","ソ", "ダ","ヂ","ヅ","デ","ド",
|
||
"タ","チ","ツ","テ","ト", "バ","ビ","ブ","ベ","ボ",
|
||
"ナ","ニ","ヌ","ネ","ノ", "パ","ピ","プ","ペ","ポ",
|
||
"ハ","ヒ","フ","ヘ","ホ", "ァ","ィ","ゥ","ェ","ォ",
|
||
"マ","ミ","ム","メ","モ", "ッ","ャ","ュ","ョ","ヮ",
|
||
"ヤ","ユ","ヨ","ワ","ン", "ー","～","・","＝","☆",
|
||
"ラ","リ","ル","レ","ロ", "ヴ","ヲ"," ","英数","決定" ];
|
||
// prettier-ignore
|
||
Window_NameInput.JAPAN3 =
|
||
[ "Ａ","Ｂ","Ｃ","Ｄ","Ｅ", "ａ","ｂ","ｃ","ｄ","ｅ",
|
||
"Ｆ","Ｇ","Ｈ","Ｉ","Ｊ", "ｆ","ｇ","ｈ","ｉ","ｊ",
|
||
"Ｋ","Ｌ","Ｍ","Ｎ","Ｏ", "ｋ","ｌ","ｍ","ｎ","ｏ",
|
||
"Ｐ","Ｑ","Ｒ","Ｓ","Ｔ", "ｐ","ｑ","ｒ","ｓ","ｔ",
|
||
"Ｕ","Ｖ","Ｗ","Ｘ","Ｙ", "ｕ","ｖ","ｗ","ｘ","ｙ",
|
||
"Ｚ","［","］","＾","＿", "ｚ","｛","｝","｜","～",
|
||
"０","１","２","３","４", "！","＃","＄","％","＆",
|
||
"５","６","７","８","９", "（","）","＊","＋","－",
|
||
"／","＝","＠","＜","＞", "：","；"," ","かな","決定" ];
|
||
|
||
Window_NameInput.prototype.initialize = function(rect) {
|
||
Window_Selectable.prototype.initialize.call(this, rect);
|
||
this._editWindow = null;
|
||
this._page = 0;
|
||
this._index = 0;
|
||
};
|
||
|
||
Window_NameInput.prototype.setEditWindow = function(editWindow) {
|
||
this._editWindow = editWindow;
|
||
this.refresh();
|
||
this.updateCursor();
|
||
this.activate();
|
||
};
|
||
|
||
Window_NameInput.prototype.table = function() {
|
||
if ($gameSystem.isJapanese()) {
|
||
return [
|
||
Window_NameInput.JAPAN1,
|
||
Window_NameInput.JAPAN2,
|
||
Window_NameInput.JAPAN3
|
||
];
|
||
} else if ($gameSystem.isRussian()) {
|
||
return [Window_NameInput.RUSSIA];
|
||
} else {
|
||
return [Window_NameInput.LATIN1, Window_NameInput.LATIN2];
|
||
}
|
||
};
|
||
|
||
Window_NameInput.prototype.maxCols = function() {
|
||
return 10;
|
||
};
|
||
|
||
Window_NameInput.prototype.maxItems = function() {
|
||
return 90;
|
||
};
|
||
|
||
Window_NameInput.prototype.itemWidth = function() {
|
||
return Math.floor((this.innerWidth - this.groupSpacing()) / 10);
|
||
};
|
||
|
||
Window_NameInput.prototype.groupSpacing = function() {
|
||
return 24;
|
||
};
|
||
|
||
Window_NameInput.prototype.character = function() {
|
||
return this._index < 88 ? this.table()[this._page][this._index] : "";
|
||
};
|
||
|
||
Window_NameInput.prototype.isPageChange = function() {
|
||
return this._index === 88;
|
||
};
|
||
|
||
Window_NameInput.prototype.isOk = function() {
|
||
return this._index === 89;
|
||
};
|
||
|
||
Window_NameInput.prototype.itemRect = function(index) {
|
||
const itemWidth = this.itemWidth();
|
||
const itemHeight = this.itemHeight();
|
||
const colSpacing = this.colSpacing();
|
||
const rowSpacing = this.rowSpacing();
|
||
const groupSpacing = this.groupSpacing();
|
||
const col = index % 10;
|
||
const group = Math.floor(col / 5);
|
||
const x = col * itemWidth + group * groupSpacing + colSpacing / 2;
|
||
const y = Math.floor(index / 10) * itemHeight + rowSpacing / 2;
|
||
const width = itemWidth - colSpacing;
|
||
const height = itemHeight - rowSpacing;
|
||
return new Rectangle(x, y, width, height);
|
||
};
|
||
|
||
Window_NameInput.prototype.drawItem = function(index) {
|
||
const table = this.table();
|
||
const character = table[this._page][index];
|
||
const rect = this.itemLineRect(index);
|
||
this.drawText(character, rect.x, rect.y, rect.width, "center");
|
||
};
|
||
|
||
Window_NameInput.prototype.updateCursor = function() {
|
||
const rect = this.itemRect(this._index);
|
||
this.setCursorRect(rect.x, rect.y, rect.width, rect.height);
|
||
};
|
||
|
||
Window_NameInput.prototype.isCursorMovable = function() {
|
||
return this.active;
|
||
};
|
||
|
||
Window_NameInput.prototype.cursorDown = function(wrap) {
|
||
if (this._index < 80 || wrap) {
|
||
this._index = (this._index + 10) % 90;
|
||
}
|
||
};
|
||
|
||
Window_NameInput.prototype.cursorUp = function(wrap) {
|
||
if (this._index >= 10 || wrap) {
|
||
this._index = (this._index + 80) % 90;
|
||
}
|
||
};
|
||
|
||
Window_NameInput.prototype.cursorRight = function(wrap) {
|
||
if (this._index % 10 < 9) {
|
||
this._index++;
|
||
} else if (wrap) {
|
||
this._index -= 9;
|
||
}
|
||
};
|
||
|
||
Window_NameInput.prototype.cursorLeft = function(wrap) {
|
||
if (this._index % 10 > 0) {
|
||
this._index--;
|
||
} else if (wrap) {
|
||
this._index += 9;
|
||
}
|
||
};
|
||
|
||
Window_NameInput.prototype.cursorPagedown = function() {
|
||
this._page = (this._page + 1) % this.table().length;
|
||
this.refresh();
|
||
};
|
||
|
||
Window_NameInput.prototype.cursorPageup = function() {
|
||
this._page = (this._page + this.table().length - 1) % this.table().length;
|
||
this.refresh();
|
||
};
|
||
|
||
Window_NameInput.prototype.processCursorMove = function() {
|
||
const lastPage = this._page;
|
||
Window_Selectable.prototype.processCursorMove.call(this);
|
||
this.updateCursor();
|
||
if (this._page !== lastPage) {
|
||
this.playCursorSound();
|
||
}
|
||
};
|
||
|
||
Window_NameInput.prototype.processHandling = function() {
|
||
if (this.isOpen() && this.active) {
|
||
if (Input.isTriggered("shift")) {
|
||
this.processJump();
|
||
}
|
||
if (Input.isRepeated("cancel")) {
|
||
this.processBack();
|
||
}
|
||
if (Input.isRepeated("ok")) {
|
||
this.processOk();
|
||
}
|
||
}
|
||
};
|
||
|
||
Window_NameInput.prototype.isCancelEnabled = function() {
|
||
return true;
|
||
};
|
||
|
||
Window_NameInput.prototype.processCancel = function() {
|
||
this.processBack();
|
||
};
|
||
|
||
Window_NameInput.prototype.processJump = function() {
|
||
if (this._index !== 89) {
|
||
this._index = 89;
|
||
this.playCursorSound();
|
||
}
|
||
};
|
||
|
||
Window_NameInput.prototype.processBack = function() {
|
||
if (this._editWindow.back()) {
|
||
SoundManager.playCancel();
|
||
}
|
||
};
|
||
|
||
Window_NameInput.prototype.processOk = function() {
|
||
if (this.character()) {
|
||
this.onNameAdd();
|
||
} else if (this.isPageChange()) {
|
||
this.playOkSound();
|
||
this.cursorPagedown();
|
||
} else if (this.isOk()) {
|
||
this.onNameOk();
|
||
}
|
||
};
|
||
|
||
Window_NameInput.prototype.onNameAdd = function() {
|
||
if (this._editWindow.add(this.character())) {
|
||
this.playOkSound();
|
||
} else {
|
||
this.playBuzzerSound();
|
||
}
|
||
};
|
||
|
||
Window_NameInput.prototype.onNameOk = function() {
|
||
if (this._editWindow.name() === "") {
|
||
if (this._editWindow.restoreDefault()) {
|
||
this.playOkSound();
|
||
} else {
|
||
this.playBuzzerSound();
|
||
}
|
||
} else {
|
||
this.playOkSound();
|
||
this.callOkHandler();
|
||
}
|
||
};
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Window_NameBox
|
||
//
|
||
// The window for displaying a speaker name above the message window.
|
||
|
||
function Window_NameBox() {
|
||
this.initialize(...arguments);
|
||
}
|
||
|
||
Window_NameBox.prototype = Object.create(Window_Base.prototype);
|
||
Window_NameBox.prototype.constructor = Window_NameBox;
|
||
|
||
Window_NameBox.prototype.initialize = function() {
|
||
Window_Base.prototype.initialize.call(this, new Rectangle());
|
||
this.openness = 0;
|
||
this._name = "";
|
||
};
|
||
|
||
Window_NameBox.prototype.setMessageWindow = function(messageWindow) {
|
||
this._messageWindow = messageWindow;
|
||
};
|
||
|
||
Window_NameBox.prototype.setName = function(name) {
|
||
if (this._name !== name) {
|
||
this._name = name;
|
||
this.refresh();
|
||
}
|
||
};
|
||
|
||
Window_NameBox.prototype.clear = function() {
|
||
this.setName("");
|
||
};
|
||
|
||
Window_NameBox.prototype.start = function() {
|
||
this.updatePlacement();
|
||
this.updateBackground();
|
||
this.createContents();
|
||
this.refresh();
|
||
};
|
||
|
||
Window_NameBox.prototype.updatePlacement = function() {
|
||
this.width = this.windowWidth();
|
||
this.height = this.windowHeight();
|
||
const messageWindow = this._messageWindow;
|
||
if ($gameMessage.isRTL()) {
|
||
this.x = messageWindow.x + messageWindow.width - this.width;
|
||
} else {
|
||
this.x = messageWindow.x;
|
||
}
|
||
if (messageWindow.y > 0) {
|
||
this.y = messageWindow.y - this.height;
|
||
} else {
|
||
this.y = messageWindow.y + messageWindow.height;
|
||
}
|
||
};
|
||
|
||
Window_NameBox.prototype.updateBackground = function() {
|
||
this.setBackgroundType($gameMessage.background());
|
||
};
|
||
|
||
Window_NameBox.prototype.windowWidth = function() {
|
||
if (this._name) {
|
||
const textWidth = this.textSizeEx(this._name).width;
|
||
const padding = this.padding + this.itemPadding();
|
||
const width = Math.ceil(textWidth) + padding * 2;
|
||
return Math.min(width, Graphics.boxWidth);
|
||
} else {
|
||
return 0;
|
||
}
|
||
};
|
||
|
||
Window_NameBox.prototype.windowHeight = function() {
|
||
return this.fittingHeight(1);
|
||
};
|
||
|
||
Window_NameBox.prototype.refresh = function() {
|
||
const rect = this.baseTextRect();
|
||
this.contents.clear();
|
||
this.drawTextEx(this._name, rect.x, rect.y, rect.width);
|
||
};
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Window_ChoiceList
|
||
//
|
||
// The window used for the event command [Show Choices].
|
||
|
||
function Window_ChoiceList() {
|
||
this.initialize(...arguments);
|
||
}
|
||
|
||
Window_ChoiceList.prototype = Object.create(Window_Command.prototype);
|
||
Window_ChoiceList.prototype.constructor = Window_ChoiceList;
|
||
|
||
Window_ChoiceList.prototype.initialize = function() {
|
||
Window_Command.prototype.initialize.call(this, new Rectangle());
|
||
this.createCancelButton();
|
||
this.openness = 0;
|
||
this.deactivate();
|
||
this._background = 0;
|
||
this._canRepeat = false;
|
||
};
|
||
|
||
Window_ChoiceList.prototype.setMessageWindow = function(messageWindow) {
|
||
this._messageWindow = messageWindow;
|
||
};
|
||
|
||
Window_ChoiceList.prototype.createCancelButton = function() {
|
||
if (ConfigManager.touchUI) {
|
||
this._cancelButton = new Sprite_Button("cancel");
|
||
this._cancelButton.visible = false;
|
||
this.addChild(this._cancelButton);
|
||
}
|
||
};
|
||
|
||
Window_ChoiceList.prototype.start = function() {
|
||
this.updatePlacement();
|
||
this.updateBackground();
|
||
this.placeCancelButton();
|
||
this.createContents();
|
||
this.refresh();
|
||
this.scrollTo(0, 0);
|
||
this.selectDefault();
|
||
this.open();
|
||
this.activate();
|
||
};
|
||
|
||
Window_ChoiceList.prototype.update = function() {
|
||
Window_Selectable.prototype.update.call(this);
|
||
this.updateCancelButton();
|
||
};
|
||
|
||
Window_ChoiceList.prototype.updateCancelButton = function() {
|
||
if (this._cancelButton) {
|
||
this._cancelButton.visible = this.needsCancelButton() && this.isOpen();
|
||
}
|
||
};
|
||
|
||
Window_ChoiceList.prototype.selectDefault = function() {
|
||
this.select($gameMessage.choiceDefaultType());
|
||
};
|
||
|
||
Window_ChoiceList.prototype.updatePlacement = function() {
|
||
this.x = this.windowX();
|
||
this.y = this.windowY();
|
||
this.width = this.windowWidth();
|
||
this.height = this.windowHeight();
|
||
};
|
||
|
||
Window_ChoiceList.prototype.updateBackground = function() {
|
||
this._background = $gameMessage.choiceBackground();
|
||
this.setBackgroundType(this._background);
|
||
};
|
||
|
||
Window_ChoiceList.prototype.placeCancelButton = function() {
|
||
if (this._cancelButton) {
|
||
const spacing = 8;
|
||
const button = this._cancelButton;
|
||
const right = this.x + this.width;
|
||
if (right < Graphics.boxWidth - button.width + spacing) {
|
||
button.x = this.width + spacing;
|
||
} else {
|
||
button.x = -button.width - spacing;
|
||
}
|
||
button.y = this.height / 2 - button.height / 2;
|
||
}
|
||
};
|
||
|
||
Window_ChoiceList.prototype.windowX = function() {
|
||
const positionType = $gameMessage.choicePositionType();
|
||
if (positionType === 1) {
|
||
return (Graphics.boxWidth - this.windowWidth()) / 2;
|
||
} else if (positionType === 2) {
|
||
return Graphics.boxWidth - this.windowWidth();
|
||
} else {
|
||
return 0;
|
||
}
|
||
};
|
||
|
||
Window_ChoiceList.prototype.windowY = function() {
|
||
const messageY = this._messageWindow.y;
|
||
if (messageY >= Graphics.boxHeight / 2) {
|
||
return messageY - this.windowHeight();
|
||
} else {
|
||
return messageY + this._messageWindow.height;
|
||
}
|
||
};
|
||
|
||
Window_ChoiceList.prototype.windowWidth = function() {
|
||
const width = this.maxChoiceWidth() + this.colSpacing() + this.padding * 2;
|
||
return Math.min(width, Graphics.boxWidth);
|
||
};
|
||
|
||
Window_ChoiceList.prototype.windowHeight = function() {
|
||
return this.fittingHeight(this.numVisibleRows());
|
||
};
|
||
|
||
Window_ChoiceList.prototype.numVisibleRows = function() {
|
||
const choices = $gameMessage.choices();
|
||
return Math.min(choices.length, this.maxLines());
|
||
};
|
||
|
||
Window_ChoiceList.prototype.maxLines = function() {
|
||
const messageWindow = this._messageWindow;
|
||
const messageY = messageWindow ? messageWindow.y : 0;
|
||
const messageHeight = messageWindow ? messageWindow.height : 0;
|
||
const centerY = Graphics.boxHeight / 2;
|
||
if (messageY < centerY && messageY + messageHeight > centerY) {
|
||
return 4;
|
||
} else {
|
||
return 8;
|
||
}
|
||
};
|
||
|
||
Window_ChoiceList.prototype.maxChoiceWidth = function() {
|
||
let maxWidth = 96;
|
||
const choices = $gameMessage.choices();
|
||
for (const choice of choices) {
|
||
const textWidth = this.textSizeEx(choice).width;
|
||
const choiceWidth = Math.ceil(textWidth) + this.itemPadding() * 2;
|
||
if (maxWidth < choiceWidth) {
|
||
maxWidth = choiceWidth;
|
||
}
|
||
}
|
||
return maxWidth;
|
||
};
|
||
|
||
Window_ChoiceList.prototype.makeCommandList = function() {
|
||
const choices = $gameMessage.choices();
|
||
for (const choice of choices) {
|
||
this.addCommand(choice, "choice");
|
||
}
|
||
};
|
||
|
||
Window_ChoiceList.prototype.drawItem = function(index) {
|
||
const rect = this.itemLineRect(index);
|
||
this.drawTextEx(this.commandName(index), rect.x, rect.y, rect.width);
|
||
};
|
||
|
||
Window_ChoiceList.prototype.isCancelEnabled = function() {
|
||
return $gameMessage.choiceCancelType() !== -1;
|
||
};
|
||
|
||
Window_ChoiceList.prototype.needsCancelButton = function() {
|
||
return $gameMessage.choiceCancelType() === -2;
|
||
};
|
||
|
||
Window_ChoiceList.prototype.callOkHandler = function() {
|
||
$gameMessage.onChoice(this.index());
|
||
this._messageWindow.terminateMessage();
|
||
this.close();
|
||
};
|
||
|
||
Window_ChoiceList.prototype.callCancelHandler = function() {
|
||
$gameMessage.onChoice($gameMessage.choiceCancelType());
|
||
this._messageWindow.terminateMessage();
|
||
this.close();
|
||
};
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Window_NumberInput
|
||
//
|
||
// The window used for the event command [Input Number].
|
||
|
||
function Window_NumberInput() {
|
||
this.initialize(...arguments);
|
||
}
|
||
|
||
Window_NumberInput.prototype = Object.create(Window_Selectable.prototype);
|
||
Window_NumberInput.prototype.constructor = Window_NumberInput;
|
||
|
||
Window_NumberInput.prototype.initialize = function() {
|
||
Window_Selectable.prototype.initialize.call(this, new Rectangle());
|
||
this._number = 0;
|
||
this._maxDigits = 1;
|
||
this.openness = 0;
|
||
this.createButtons();
|
||
this.deactivate();
|
||
this._canRepeat = false;
|
||
};
|
||
|
||
Window_NumberInput.prototype.setMessageWindow = function(messageWindow) {
|
||
this._messageWindow = messageWindow;
|
||
};
|
||
|
||
Window_NumberInput.prototype.start = function() {
|
||
this._maxDigits = $gameMessage.numInputMaxDigits();
|
||
this._number = $gameVariables.value($gameMessage.numInputVariableId());
|
||
this._number = this._number.clamp(0, Math.pow(10, this._maxDigits) - 1);
|
||
this.updatePlacement();
|
||
this.placeButtons();
|
||
this.createContents();
|
||
this.refresh();
|
||
this.open();
|
||
this.activate();
|
||
this.select(0);
|
||
};
|
||
|
||
Window_NumberInput.prototype.updatePlacement = function() {
|
||
const messageY = this._messageWindow.y;
|
||
const spacing = 8;
|
||
this.width = this.windowWidth();
|
||
this.height = this.windowHeight();
|
||
this.x = (Graphics.boxWidth - this.width) / 2;
|
||
if (messageY >= Graphics.boxHeight / 2) {
|
||
this.y = messageY - this.height - spacing;
|
||
} else {
|
||
this.y = messageY + this._messageWindow.height + spacing;
|
||
}
|
||
};
|
||
|
||
Window_NumberInput.prototype.windowWidth = function() {
|
||
const totalItemWidth = this.maxCols() * this.itemWidth();
|
||
const totalButtonWidth = this.totalButtonWidth();
|
||
return Math.max(totalItemWidth, totalButtonWidth) + this.padding * 2;
|
||
};
|
||
|
||
Window_NumberInput.prototype.windowHeight = function() {
|
||
if (ConfigManager.touchUI) {
|
||
return this.fittingHeight(1) + this.buttonSpacing() + 48;
|
||
} else {
|
||
return this.fittingHeight(1);
|
||
}
|
||
};
|
||
|
||
Window_NumberInput.prototype.maxCols = function() {
|
||
return this._maxDigits;
|
||
};
|
||
|
||
Window_NumberInput.prototype.maxItems = function() {
|
||
return this._maxDigits;
|
||
};
|
||
|
||
Window_NumberInput.prototype.itemWidth = function() {
|
||
return 48;
|
||
};
|
||
|
||
Window_NumberInput.prototype.itemRect = function(index) {
|
||
const rect = Window_Selectable.prototype.itemRect.call(this, index);
|
||
const innerMargin = this.innerWidth - this.maxCols() * this.itemWidth();
|
||
rect.x += innerMargin / 2;
|
||
return rect;
|
||
};
|
||
|
||
Window_NumberInput.prototype.isScrollEnabled = function() {
|
||
return false;
|
||
};
|
||
|
||
Window_NumberInput.prototype.isHoverEnabled = function() {
|
||
return false;
|
||
};
|
||
|
||
Window_NumberInput.prototype.createButtons = function() {
|
||
this._buttons = [];
|
||
if (ConfigManager.touchUI) {
|
||
for (const type of ["down", "up", "ok"]) {
|
||
const button = new Sprite_Button(type);
|
||
this._buttons.push(button);
|
||
this.addInnerChild(button);
|
||
}
|
||
this._buttons[0].setClickHandler(this.onButtonDown.bind(this));
|
||
this._buttons[1].setClickHandler(this.onButtonUp.bind(this));
|
||
this._buttons[2].setClickHandler(this.onButtonOk.bind(this));
|
||
}
|
||
};
|
||
|
||
Window_NumberInput.prototype.placeButtons = function() {
|
||
const sp = this.buttonSpacing();
|
||
const totalWidth = this.totalButtonWidth();
|
||
let x = (this.innerWidth - totalWidth) / 2;
|
||
for (const button of this._buttons) {
|
||
button.x = x;
|
||
button.y = this.buttonY();
|
||
x += button.width + sp;
|
||
}
|
||
};
|
||
|
||
Window_NumberInput.prototype.totalButtonWidth = function() {
|
||
const sp = this.buttonSpacing();
|
||
return this._buttons.reduce((r, button) => r + button.width + sp, -sp);
|
||
};
|
||
|
||
Window_NumberInput.prototype.buttonSpacing = function() {
|
||
return 8;
|
||
};
|
||
|
||
Window_NumberInput.prototype.buttonY = function() {
|
||
return this.itemHeight() + this.buttonSpacing();
|
||
};
|
||
|
||
Window_NumberInput.prototype.update = function() {
|
||
Window_Selectable.prototype.update.call(this);
|
||
this.processDigitChange();
|
||
};
|
||
|
||
Window_NumberInput.prototype.processDigitChange = function() {
|
||
if (this.isOpenAndActive()) {
|
||
if (Input.isRepeated("up")) {
|
||
this.changeDigit(true);
|
||
} else if (Input.isRepeated("down")) {
|
||
this.changeDigit(false);
|
||
}
|
||
}
|
||
};
|
||
|
||
Window_NumberInput.prototype.changeDigit = function(up) {
|
||
const index = this.index();
|
||
const place = Math.pow(10, this._maxDigits - 1 - index);
|
||
let n = Math.floor(this._number / place) % 10;
|
||
this._number -= n * place;
|
||
if (up) {
|
||
n = (n + 1) % 10;
|
||
} else {
|
||
n = (n + 9) % 10;
|
||
}
|
||
this._number += n * place;
|
||
this.refresh();
|
||
this.playCursorSound();
|
||
};
|
||
|
||
Window_NumberInput.prototype.isTouchOkEnabled = function() {
|
||
return false;
|
||
};
|
||
|
||
Window_NumberInput.prototype.isOkEnabled = function() {
|
||
return true;
|
||
};
|
||
|
||
Window_NumberInput.prototype.isCancelEnabled = function() {
|
||
return false;
|
||
};
|
||
|
||
Window_NumberInput.prototype.processOk = function() {
|
||
this.playOkSound();
|
||
$gameVariables.setValue($gameMessage.numInputVariableId(), this._number);
|
||
this._messageWindow.terminateMessage();
|
||
this.updateInputData();
|
||
this.deactivate();
|
||
this.close();
|
||
};
|
||
|
||
Window_NumberInput.prototype.drawItem = function(index) {
|
||
const rect = this.itemLineRect(index);
|
||
const align = "center";
|
||
const s = this._number.padZero(this._maxDigits);
|
||
const c = s.slice(index, index + 1);
|
||
this.resetTextColor();
|
||
this.drawText(c, rect.x, rect.y, rect.width, align);
|
||
};
|
||
|
||
Window_NumberInput.prototype.onButtonUp = function() {
|
||
this.changeDigit(true);
|
||
};
|
||
|
||
Window_NumberInput.prototype.onButtonDown = function() {
|
||
this.changeDigit(false);
|
||
};
|
||
|
||
Window_NumberInput.prototype.onButtonOk = function() {
|
||
this.processOk();
|
||
};
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Window_EventItem
|
||
//
|
||
// The window used for the event command [Select Item].
|
||
|
||
function Window_EventItem() {
|
||
this.initialize(...arguments);
|
||
}
|
||
|
||
Window_EventItem.prototype = Object.create(Window_ItemList.prototype);
|
||
Window_EventItem.prototype.constructor = Window_EventItem;
|
||
|
||
Window_EventItem.prototype.initialize = function(rect) {
|
||
Window_ItemList.prototype.initialize.call(this, rect);
|
||
this.createCancelButton();
|
||
this.openness = 0;
|
||
this.deactivate();
|
||
this.setHandler("ok", this.onOk.bind(this));
|
||
this.setHandler("cancel", this.onCancel.bind(this));
|
||
};
|
||
|
||
Window_EventItem.prototype.setMessageWindow = function(messageWindow) {
|
||
this._messageWindow = messageWindow;
|
||
};
|
||
|
||
Window_EventItem.prototype.createCancelButton = function() {
|
||
if (ConfigManager.touchUI) {
|
||
this._cancelButton = new Sprite_Button("cancel");
|
||
this._cancelButton.visible = false;
|
||
this.addChild(this._cancelButton);
|
||
}
|
||
};
|
||
|
||
Window_EventItem.prototype.start = function() {
|
||
this.refresh();
|
||
this.updatePlacement();
|
||
this.placeCancelButton();
|
||
this.forceSelect(0);
|
||
this.open();
|
||
this.activate();
|
||
};
|
||
|
||
Window_EventItem.prototype.update = function() {
|
||
Window_Selectable.prototype.update.call(this);
|
||
this.updateCancelButton();
|
||
};
|
||
|
||
Window_EventItem.prototype.updateCancelButton = function() {
|
||
if (this._cancelButton) {
|
||
this._cancelButton.visible = this.isOpen();
|
||
}
|
||
};
|
||
|
||
Window_EventItem.prototype.updatePlacement = function() {
|
||
if (this._messageWindow.y >= Graphics.boxHeight / 2) {
|
||
this.y = 0;
|
||
} else {
|
||
this.y = Graphics.boxHeight - this.height;
|
||
}
|
||
};
|
||
|
||
Window_EventItem.prototype.placeCancelButton = function() {
|
||
if (this._cancelButton) {
|
||
const spacing = 8;
|
||
const button = this._cancelButton;
|
||
if (this.y === 0) {
|
||
button.y = this.height + spacing;
|
||
} else if (this._messageWindow.y >= Graphics.boxHeight / 4) {
|
||
const distance = this.y - this._messageWindow.y;
|
||
button.y = -button.height - spacing - distance;
|
||
} else {
|
||
button.y = -button.height - spacing;
|
||
}
|
||
button.x = this.width - button.width - spacing;
|
||
}
|
||
};
|
||
|
||
Window_EventItem.prototype.includes = function(item) {
|
||
const itypeId = $gameMessage.itemChoiceItypeId();
|
||
return DataManager.isItem(item) && item.itypeId === itypeId;
|
||
};
|
||
|
||
Window_EventItem.prototype.needsNumber = function() {
|
||
const itypeId = $gameMessage.itemChoiceItypeId();
|
||
if (itypeId === 2) {
|
||
// Key Item
|
||
return $dataSystem.optKeyItemsNumber;
|
||
} else if (itypeId >= 3) {
|
||
// Hidden Item
|
||
return false;
|
||
} else {
|
||
// Normal Item
|
||
return true;
|
||
}
|
||
};
|
||
|
||
Window_EventItem.prototype.isEnabled = function(/*item*/) {
|
||
return true;
|
||
};
|
||
|
||
Window_EventItem.prototype.onOk = function() {
|
||
const item = this.item();
|
||
const itemId = item ? item.id : 0;
|
||
$gameVariables.setValue($gameMessage.itemChoiceVariableId(), itemId);
|
||
this._messageWindow.terminateMessage();
|
||
this.close();
|
||
};
|
||
|
||
Window_EventItem.prototype.onCancel = function() {
|
||
$gameVariables.setValue($gameMessage.itemChoiceVariableId(), 0);
|
||
this._messageWindow.terminateMessage();
|
||
this.close();
|
||
};
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Window_Message
|
||
//
|
||
// The window for displaying text messages.
|
||
|
||
function Window_Message() {
|
||
this.initialize(...arguments);
|
||
}
|
||
|
||
Window_Message.prototype = Object.create(Window_Base.prototype);
|
||
Window_Message.prototype.constructor = Window_Message;
|
||
|
||
Window_Message.prototype.initialize = function(rect) {
|
||
Window_Base.prototype.initialize.call(this, rect);
|
||
this.openness = 0;
|
||
this.initMembers();
|
||
};
|
||
|
||
Window_Message.prototype.initMembers = function() {
|
||
this._background = 0;
|
||
this._positionType = 2;
|
||
this._waitCount = 0;
|
||
this._faceBitmap = null;
|
||
this._textState = null;
|
||
this._goldWindow = null;
|
||
this._nameBoxWindow = null;
|
||
this._choiceListWindow = null;
|
||
this._numberInputWindow = null;
|
||
this._eventItemWindow = null;
|
||
this.clearFlags();
|
||
};
|
||
|
||
Window_Message.prototype.setGoldWindow = function(goldWindow) {
|
||
this._goldWindow = goldWindow;
|
||
};
|
||
|
||
Window_Message.prototype.setNameBoxWindow = function(nameBoxWindow) {
|
||
this._nameBoxWindow = nameBoxWindow;
|
||
};
|
||
|
||
Window_Message.prototype.setChoiceListWindow = function(choiceListWindow) {
|
||
this._choiceListWindow = choiceListWindow;
|
||
};
|
||
|
||
Window_Message.prototype.setNumberInputWindow = function(numberInputWindow) {
|
||
this._numberInputWindow = numberInputWindow;
|
||
};
|
||
|
||
Window_Message.prototype.setEventItemWindow = function(eventItemWindow) {
|
||
this._eventItemWindow = eventItemWindow;
|
||
};
|
||
|
||
Window_Message.prototype.clearFlags = function() {
|
||
this._showFast = false;
|
||
this._lineShowFast = false;
|
||
this._pauseSkip = false;
|
||
};
|
||
|
||
Window_Message.prototype.update = function() {
|
||
this.checkToNotClose();
|
||
Window_Base.prototype.update.call(this);
|
||
this.synchronizeNameBox();
|
||
while (!this.isOpening() && !this.isClosing()) {
|
||
if (this.updateWait()) {
|
||
return;
|
||
} else if (this.updateLoading()) {
|
||
return;
|
||
} else if (this.updateInput()) {
|
||
return;
|
||
} else if (this.updateMessage()) {
|
||
return;
|
||
} else if (this.canStart()) {
|
||
this.startMessage();
|
||
} else {
|
||
this.startInput();
|
||
return;
|
||
}
|
||
}
|
||
};
|
||
|
||
Window_Message.prototype.checkToNotClose = function() {
|
||
if (this.isOpen() && this.isClosing() && this.doesContinue()) {
|
||
this.open();
|
||
}
|
||
};
|
||
|
||
Window_Message.prototype.synchronizeNameBox = function() {
|
||
this._nameBoxWindow.openness = this.openness;
|
||
};
|
||
|
||
Window_Message.prototype.canStart = function() {
|
||
return $gameMessage.hasText() && !$gameMessage.scrollMode();
|
||
};
|
||
|
||
Window_Message.prototype.startMessage = function() {
|
||
const text = $gameMessage.allText();
|
||
const textState = this.createTextState(text, 0, 0, 0);
|
||
textState.x = this.newLineX(textState);
|
||
textState.startX = textState.x;
|
||
this._textState = textState;
|
||
this.newPage(this._textState);
|
||
this.updatePlacement();
|
||
this.updateBackground();
|
||
this.open();
|
||
this._nameBoxWindow.start();
|
||
};
|
||
|
||
Window_Message.prototype.newLineX = function(textState) {
|
||
const faceExists = $gameMessage.faceName() !== "";
|
||
const faceWidth = ImageManager.faceWidth;
|
||
const spacing = 20;
|
||
const margin = faceExists ? faceWidth + spacing : 4;
|
||
return textState.rtl ? this.innerWidth - margin : margin;
|
||
};
|
||
|
||
Window_Message.prototype.updatePlacement = function() {
|
||
const goldWindow = this._goldWindow;
|
||
this._positionType = $gameMessage.positionType();
|
||
this.y = (this._positionType * (Graphics.boxHeight - this.height)) / 2;
|
||
if (goldWindow) {
|
||
goldWindow.y = this.y > 0 ? 0 : Graphics.boxHeight - goldWindow.height;
|
||
}
|
||
};
|
||
|
||
Window_Message.prototype.updateBackground = function() {
|
||
this._background = $gameMessage.background();
|
||
this.setBackgroundType(this._background);
|
||
};
|
||
|
||
Window_Message.prototype.terminateMessage = function() {
|
||
this.close();
|
||
this._goldWindow.close();
|
||
$gameMessage.clear();
|
||
};
|
||
|
||
Window_Message.prototype.updateWait = function() {
|
||
if (this._waitCount > 0) {
|
||
this._waitCount--;
|
||
return true;
|
||
} else {
|
||
return false;
|
||
}
|
||
};
|
||
|
||
Window_Message.prototype.updateLoading = function() {
|
||
if (this._faceBitmap) {
|
||
if (this._faceBitmap.isReady()) {
|
||
this.drawMessageFace();
|
||
this._faceBitmap = null;
|
||
return false;
|
||
} else {
|
||
return true;
|
||
}
|
||
} else {
|
||
return false;
|
||
}
|
||
};
|
||
|
||
Window_Message.prototype.updateInput = function() {
|
||
if (this.isAnySubWindowActive()) {
|
||
return true;
|
||
}
|
||
if (this.pause) {
|
||
if (this.isTriggered()) {
|
||
Input.update();
|
||
this.pause = false;
|
||
if (!this._textState) {
|
||
this.terminateMessage();
|
||
}
|
||
}
|
||
return true;
|
||
}
|
||
return false;
|
||
};
|
||
|
||
Window_Message.prototype.isAnySubWindowActive = function() {
|
||
return (
|
||
this._choiceListWindow.active ||
|
||
this._numberInputWindow.active ||
|
||
this._eventItemWindow.active
|
||
);
|
||
};
|
||
|
||
Window_Message.prototype.updateMessage = function() {
|
||
const textState = this._textState;
|
||
if (textState) {
|
||
while (!this.isEndOfText(textState)) {
|
||
if (this.needsNewPage(textState)) {
|
||
this.newPage(textState);
|
||
}
|
||
this.updateShowFast();
|
||
this.processCharacter(textState);
|
||
if (this.shouldBreakHere(textState)) {
|
||
break;
|
||
}
|
||
}
|
||
this.flushTextState(textState);
|
||
if (this.isEndOfText(textState) && !this.isWaiting()) {
|
||
this.onEndOfText();
|
||
}
|
||
return true;
|
||
} else {
|
||
return false;
|
||
}
|
||
};
|
||
|
||
Window_Message.prototype.shouldBreakHere = function(textState) {
|
||
if (this.canBreakHere(textState)) {
|
||
if (!this._showFast && !this._lineShowFast) {
|
||
return true;
|
||
}
|
||
if (this.isWaiting()) {
|
||
return true;
|
||
}
|
||
}
|
||
return false;
|
||
};
|
||
|
||
Window_Message.prototype.canBreakHere = function(textState) {
|
||
if (!this.isEndOfText(textState)) {
|
||
const c = textState.text[textState.index];
|
||
if (c.charCodeAt(0) >= 0xdc00 && c.charCodeAt(0) <= 0xdfff) {
|
||
// surrogate pair
|
||
return false;
|
||
}
|
||
if (textState.rtl && c.charCodeAt(0) > 0x20) {
|
||
return false;
|
||
}
|
||
}
|
||
return true;
|
||
};
|
||
|
||
Window_Message.prototype.onEndOfText = function() {
|
||
if (!this.startInput()) {
|
||
if (!this._pauseSkip) {
|
||
this.startPause();
|
||
} else {
|
||
this.terminateMessage();
|
||
}
|
||
}
|
||
this._textState = null;
|
||
};
|
||
|
||
Window_Message.prototype.startInput = function() {
|
||
if ($gameMessage.isChoice()) {
|
||
this._choiceListWindow.start();
|
||
return true;
|
||
} else if ($gameMessage.isNumberInput()) {
|
||
this._numberInputWindow.start();
|
||
return true;
|
||
} else if ($gameMessage.isItemChoice()) {
|
||
this._eventItemWindow.start();
|
||
return true;
|
||
} else {
|
||
return false;
|
||
}
|
||
};
|
||
|
||
Window_Message.prototype.isTriggered = function() {
|
||
return (
|
||
Input.isRepeated("ok") ||
|
||
Input.isRepeated("cancel") ||
|
||
TouchInput.isRepeated()
|
||
);
|
||
};
|
||
|
||
Window_Message.prototype.doesContinue = function() {
|
||
return (
|
||
$gameMessage.hasText() &&
|
||
!$gameMessage.scrollMode() &&
|
||
!this.areSettingsChanged()
|
||
);
|
||
};
|
||
|
||
Window_Message.prototype.areSettingsChanged = function() {
|
||
return (
|
||
this._background !== $gameMessage.background() ||
|
||
this._positionType !== $gameMessage.positionType()
|
||
);
|
||
};
|
||
|
||
Window_Message.prototype.updateShowFast = function() {
|
||
if (this.isTriggered()) {
|
||
this._showFast = true;
|
||
}
|
||
};
|
||
|
||
Window_Message.prototype.newPage = function(textState) {
|
||
this.contents.clear();
|
||
this.resetFontSettings();
|
||
this.clearFlags();
|
||
this.updateSpeakerName();
|
||
this.loadMessageFace();
|
||
textState.x = textState.startX;
|
||
textState.y = 0;
|
||
textState.height = this.calcTextHeight(textState);
|
||
};
|
||
|
||
Window_Message.prototype.updateSpeakerName = function() {
|
||
this._nameBoxWindow.setName($gameMessage.speakerName());
|
||
};
|
||
|
||
Window_Message.prototype.loadMessageFace = function() {
|
||
this._faceBitmap = ImageManager.loadFace($gameMessage.faceName());
|
||
};
|
||
|
||
Window_Message.prototype.drawMessageFace = function() {
|
||
const faceName = $gameMessage.faceName();
|
||
const faceIndex = $gameMessage.faceIndex();
|
||
const rtl = $gameMessage.isRTL();
|
||
const width = ImageManager.faceWidth;
|
||
const height = this.innerHeight;
|
||
const x = rtl ? this.innerWidth - width - 4 : 4;
|
||
this.drawFace(faceName, faceIndex, x, 0, width, height);
|
||
};
|
||
|
||
Window_Message.prototype.processControlCharacter = function(textState, c) {
|
||
Window_Base.prototype.processControlCharacter.call(this, textState, c);
|
||
if (c === "\f") {
|
||
this.processNewPage(textState);
|
||
}
|
||
};
|
||
|
||
Window_Message.prototype.processNewLine = function(textState) {
|
||
this._lineShowFast = false;
|
||
Window_Base.prototype.processNewLine.call(this, textState);
|
||
if (this.needsNewPage(textState)) {
|
||
this.startPause();
|
||
}
|
||
};
|
||
|
||
Window_Message.prototype.processNewPage = function(textState) {
|
||
if (textState.text[textState.index] === "\n") {
|
||
textState.index++;
|
||
}
|
||
textState.y = this.contents.height;
|
||
this.startPause();
|
||
};
|
||
|
||
Window_Message.prototype.isEndOfText = function(textState) {
|
||
return textState.index >= textState.text.length;
|
||
};
|
||
|
||
Window_Message.prototype.needsNewPage = function(textState) {
|
||
return (
|
||
!this.isEndOfText(textState) &&
|
||
textState.y + textState.height > this.contents.height
|
||
);
|
||
};
|
||
|
||
Window_Message.prototype.processEscapeCharacter = function(code, textState) {
|
||
switch (code) {
|
||
case "$":
|
||
this._goldWindow.open();
|
||
break;
|
||
case ".":
|
||
this.startWait(15);
|
||
break;
|
||
case "|":
|
||
this.startWait(60);
|
||
break;
|
||
case "!":
|
||
this.startPause();
|
||
break;
|
||
case ">":
|
||
this._lineShowFast = true;
|
||
break;
|
||
case "<":
|
||
this._lineShowFast = false;
|
||
break;
|
||
case "^":
|
||
this._pauseSkip = true;
|
||
break;
|
||
default:
|
||
Window_Base.prototype.processEscapeCharacter.call(
|
||
this,
|
||
code,
|
||
textState
|
||
);
|
||
break;
|
||
}
|
||
};
|
||
|
||
Window_Message.prototype.startWait = function(count) {
|
||
this._waitCount = count;
|
||
};
|
||
|
||
Window_Message.prototype.startPause = function() {
|
||
this.startWait(10);
|
||
this.pause = true;
|
||
};
|
||
|
||
Window_Message.prototype.isWaiting = function() {
|
||
return this.pause || this._waitCount > 0;
|
||
};
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Window_ScrollText
|
||
//
|
||
// The window for displaying scrolling text. No frame is displayed, but it
|
||
// is handled as a window for convenience.
|
||
|
||
function Window_ScrollText() {
|
||
this.initialize(...arguments);
|
||
}
|
||
|
||
Window_ScrollText.prototype = Object.create(Window_Base.prototype);
|
||
Window_ScrollText.prototype.constructor = Window_ScrollText;
|
||
|
||
Window_ScrollText.prototype.initialize = function(rect) {
|
||
Window_Base.prototype.initialize.call(this, new Rectangle());
|
||
this.opacity = 0;
|
||
this.hide();
|
||
this._reservedRect = rect;
|
||
this._text = "";
|
||
this._allTextHeight = 0;
|
||
};
|
||
|
||
Window_ScrollText.prototype.update = function() {
|
||
Window_Base.prototype.update.call(this);
|
||
if ($gameMessage.scrollMode()) {
|
||
if (this._text) {
|
||
this.updateMessage();
|
||
}
|
||
if (!this._text && $gameMessage.hasText()) {
|
||
this.startMessage();
|
||
}
|
||
}
|
||
};
|
||
|
||
Window_ScrollText.prototype.startMessage = function() {
|
||
this._text = $gameMessage.allText();
|
||
if (this._text) {
|
||
this.updatePlacement();
|
||
this.refresh();
|
||
this.show();
|
||
} else {
|
||
$gameMessage.clear();
|
||
}
|
||
};
|
||
|
||
Window_ScrollText.prototype.refresh = function() {
|
||
this._allTextHeight = this.textSizeEx(this._text).height;
|
||
this.createContents();
|
||
this.origin.y = -this.height;
|
||
const rect = this.baseTextRect();
|
||
this.drawTextEx(this._text, rect.x, rect.y, rect.width);
|
||
};
|
||
|
||
Window_ScrollText.prototype.updatePlacement = function() {
|
||
const rect = this._reservedRect;
|
||
this.move(rect.x, rect.y, rect.width, rect.height);
|
||
};
|
||
|
||
Window_ScrollText.prototype.contentsHeight = function() {
|
||
return Math.max(this._allTextHeight, 1);
|
||
};
|
||
|
||
Window_ScrollText.prototype.updateMessage = function() {
|
||
this.origin.y += this.scrollSpeed();
|
||
if (this.origin.y >= this.contents.height) {
|
||
this.terminateMessage();
|
||
}
|
||
};
|
||
|
||
Window_ScrollText.prototype.scrollSpeed = function() {
|
||
let speed = $gameMessage.scrollSpeed() / 2;
|
||
if (this.isFastForward()) {
|
||
speed *= this.fastForwardRate();
|
||
}
|
||
return speed;
|
||
};
|
||
|
||
Window_ScrollText.prototype.isFastForward = function() {
|
||
if ($gameMessage.scrollNoFast()) {
|
||
return false;
|
||
} else {
|
||
return (
|
||
Input.isPressed("ok") ||
|
||
Input.isPressed("shift") ||
|
||
TouchInput.isPressed()
|
||
);
|
||
}
|
||
};
|
||
|
||
Window_ScrollText.prototype.fastForwardRate = function() {
|
||
return 3;
|
||
};
|
||
|
||
Window_ScrollText.prototype.terminateMessage = function() {
|
||
this._text = null;
|
||
$gameMessage.clear();
|
||
this.hide();
|
||
};
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Window_MapName
|
||
//
|
||
// The window for displaying the map name on the map screen.
|
||
|
||
function Window_MapName() {
|
||
this.initialize(...arguments);
|
||
}
|
||
|
||
Window_MapName.prototype = Object.create(Window_Base.prototype);
|
||
Window_MapName.prototype.constructor = Window_MapName;
|
||
|
||
Window_MapName.prototype.initialize = function(rect) {
|
||
Window_Base.prototype.initialize.call(this, rect);
|
||
this.opacity = 0;
|
||
this.contentsOpacity = 0;
|
||
this._showCount = 0;
|
||
this.refresh();
|
||
};
|
||
|
||
Window_MapName.prototype.update = function() {
|
||
Window_Base.prototype.update.call(this);
|
||
if (this._showCount > 0 && $gameMap.isNameDisplayEnabled()) {
|
||
this.updateFadeIn();
|
||
this._showCount--;
|
||
} else {
|
||
this.updateFadeOut();
|
||
}
|
||
};
|
||
|
||
Window_MapName.prototype.updateFadeIn = function() {
|
||
this.contentsOpacity += 16;
|
||
};
|
||
|
||
Window_MapName.prototype.updateFadeOut = function() {
|
||
this.contentsOpacity -= 16;
|
||
};
|
||
|
||
Window_MapName.prototype.open = function() {
|
||
this.refresh();
|
||
this._showCount = 150;
|
||
};
|
||
|
||
Window_MapName.prototype.close = function() {
|
||
this._showCount = 0;
|
||
};
|
||
|
||
Window_MapName.prototype.refresh = function() {
|
||
this.contents.clear();
|
||
if ($gameMap.displayName()) {
|
||
const width = this.innerWidth;
|
||
this.drawBackground(0, 0, width, this.lineHeight());
|
||
this.drawText($gameMap.displayName(), 0, 0, width, "center");
|
||
}
|
||
};
|
||
|
||
Window_MapName.prototype.drawBackground = function(x, y, width, height) {
|
||
const color1 = ColorManager.dimColor1();
|
||
const color2 = ColorManager.dimColor2();
|
||
const half = width / 2;
|
||
this.contents.gradientFillRect(x, y, half, height, color2, color1);
|
||
this.contents.gradientFillRect(x + half, y, half, height, color1, color2);
|
||
};
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Window_BattleLog
|
||
//
|
||
// The window for displaying battle progress. No frame is displayed, but it is
|
||
// handled as a window for convenience.
|
||
|
||
function Window_BattleLog() {
|
||
this.initialize(...arguments);
|
||
}
|
||
|
||
Window_BattleLog.prototype = Object.create(Window_Base.prototype);
|
||
Window_BattleLog.prototype.constructor = Window_BattleLog;
|
||
|
||
Window_BattleLog.prototype.initialize = function(rect) {
|
||
Window_Base.prototype.initialize.call(this, rect);
|
||
this.opacity = 0;
|
||
this._lines = [];
|
||
this._methods = [];
|
||
this._waitCount = 0;
|
||
this._waitMode = "";
|
||
this._baseLineStack = [];
|
||
this._spriteset = null;
|
||
this.refresh();
|
||
};
|
||
|
||
Window_BattleLog.prototype.setSpriteset = function(spriteset) {
|
||
this._spriteset = spriteset;
|
||
};
|
||
|
||
Window_BattleLog.prototype.maxLines = function() {
|
||
return 10;
|
||
};
|
||
|
||
Window_BattleLog.prototype.numLines = function() {
|
||
return this._lines.length;
|
||
};
|
||
|
||
Window_BattleLog.prototype.messageSpeed = function() {
|
||
return 16;
|
||
};
|
||
|
||
Window_BattleLog.prototype.isBusy = function() {
|
||
return this._waitCount > 0 || this._waitMode || this._methods.length > 0;
|
||
};
|
||
|
||
Window_BattleLog.prototype.update = function() {
|
||
if (!this.updateWait()) {
|
||
this.callNextMethod();
|
||
}
|
||
};
|
||
|
||
Window_BattleLog.prototype.updateWait = function() {
|
||
return this.updateWaitCount() || this.updateWaitMode();
|
||
};
|
||
|
||
Window_BattleLog.prototype.updateWaitCount = function() {
|
||
if (this._waitCount > 0) {
|
||
this._waitCount -= this.isFastForward() ? 3 : 1;
|
||
if (this._waitCount < 0) {
|
||
this._waitCount = 0;
|
||
}
|
||
return true;
|
||
}
|
||
return false;
|
||
};
|
||
|
||
Window_BattleLog.prototype.updateWaitMode = function() {
|
||
let waiting = false;
|
||
switch (this._waitMode) {
|
||
case "effect":
|
||
waiting = this._spriteset.isEffecting();
|
||
break;
|
||
case "movement":
|
||
waiting = this._spriteset.isAnyoneMoving();
|
||
break;
|
||
}
|
||
if (!waiting) {
|
||
this._waitMode = "";
|
||
}
|
||
return waiting;
|
||
};
|
||
|
||
Window_BattleLog.prototype.setWaitMode = function(waitMode) {
|
||
this._waitMode = waitMode;
|
||
};
|
||
|
||
Window_BattleLog.prototype.callNextMethod = function() {
|
||
if (this._methods.length > 0) {
|
||
const method = this._methods.shift();
|
||
if (method.name && this[method.name]) {
|
||
this[method.name].apply(this, method.params);
|
||
} else {
|
||
throw new Error("Method not found: " + method.name);
|
||
}
|
||
}
|
||
};
|
||
|
||
Window_BattleLog.prototype.isFastForward = function() {
|
||
return (
|
||
Input.isLongPressed("ok") ||
|
||
Input.isPressed("shift") ||
|
||
TouchInput.isLongPressed()
|
||
);
|
||
};
|
||
|
||
Window_BattleLog.prototype.push = function(methodName) {
|
||
const methodArgs = Array.prototype.slice.call(arguments, 1);
|
||
this._methods.push({ name: methodName, params: methodArgs });
|
||
};
|
||
|
||
Window_BattleLog.prototype.clear = function() {
|
||
this._lines = [];
|
||
this._baseLineStack = [];
|
||
this.refresh();
|
||
};
|
||
|
||
Window_BattleLog.prototype.wait = function() {
|
||
this._waitCount = this.messageSpeed();
|
||
};
|
||
|
||
Window_BattleLog.prototype.waitForEffect = function() {
|
||
this.setWaitMode("effect");
|
||
};
|
||
|
||
Window_BattleLog.prototype.waitForMovement = function() {
|
||
this.setWaitMode("movement");
|
||
};
|
||
|
||
Window_BattleLog.prototype.addText = function(text) {
|
||
this._lines.push(text);
|
||
this.refresh();
|
||
this.wait();
|
||
};
|
||
|
||
Window_BattleLog.prototype.pushBaseLine = function() {
|
||
this._baseLineStack.push(this._lines.length);
|
||
};
|
||
|
||
Window_BattleLog.prototype.popBaseLine = function() {
|
||
const baseLine = this._baseLineStack.pop();
|
||
while (this._lines.length > baseLine) {
|
||
this._lines.pop();
|
||
}
|
||
};
|
||
|
||
Window_BattleLog.prototype.waitForNewLine = function() {
|
||
let baseLine = 0;
|
||
if (this._baseLineStack.length > 0) {
|
||
baseLine = this._baseLineStack[this._baseLineStack.length - 1];
|
||
}
|
||
if (this._lines.length > baseLine) {
|
||
this.wait();
|
||
}
|
||
};
|
||
|
||
Window_BattleLog.prototype.popupDamage = function(target) {
|
||
if (target.shouldPopupDamage()) {
|
||
target.startDamagePopup();
|
||
}
|
||
};
|
||
|
||
Window_BattleLog.prototype.performActionStart = function(subject, action) {
|
||
subject.performActionStart(action);
|
||
};
|
||
|
||
Window_BattleLog.prototype.performAction = function(subject, action) {
|
||
subject.performAction(action);
|
||
};
|
||
|
||
Window_BattleLog.prototype.performActionEnd = function(subject) {
|
||
subject.performActionEnd();
|
||
};
|
||
|
||
Window_BattleLog.prototype.performDamage = function(target) {
|
||
target.performDamage();
|
||
};
|
||
|
||
Window_BattleLog.prototype.performMiss = function(target) {
|
||
target.performMiss();
|
||
};
|
||
|
||
Window_BattleLog.prototype.performRecovery = function(target) {
|
||
target.performRecovery();
|
||
};
|
||
|
||
Window_BattleLog.prototype.performEvasion = function(target) {
|
||
target.performEvasion();
|
||
};
|
||
|
||
Window_BattleLog.prototype.performMagicEvasion = function(target) {
|
||
target.performMagicEvasion();
|
||
};
|
||
|
||
Window_BattleLog.prototype.performCounter = function(target) {
|
||
target.performCounter();
|
||
};
|
||
|
||
Window_BattleLog.prototype.performReflection = function(target) {
|
||
target.performReflection();
|
||
};
|
||
|
||
Window_BattleLog.prototype.performSubstitute = function(substitute, target) {
|
||
substitute.performSubstitute(target);
|
||
};
|
||
|
||
Window_BattleLog.prototype.performCollapse = function(target) {
|
||
target.performCollapse();
|
||
};
|
||
|
||
// prettier-ignore
|
||
Window_BattleLog.prototype.showAnimation = function(
|
||
subject, targets, animationId
|
||
) {
|
||
if (animationId < 0) {
|
||
this.showAttackAnimation(subject, targets);
|
||
} else {
|
||
this.showNormalAnimation(targets, animationId);
|
||
}
|
||
};
|
||
|
||
Window_BattleLog.prototype.showAttackAnimation = function(subject, targets) {
|
||
if (subject.isActor()) {
|
||
this.showActorAttackAnimation(subject, targets);
|
||
} else {
|
||
this.showEnemyAttackAnimation(subject, targets);
|
||
}
|
||
};
|
||
|
||
// prettier-ignore
|
||
Window_BattleLog.prototype.showActorAttackAnimation = function(
|
||
subject, targets
|
||
) {
|
||
this.showNormalAnimation(targets, subject.attackAnimationId1(), false);
|
||
this.showNormalAnimation(targets, subject.attackAnimationId2(), true);
|
||
};
|
||
|
||
// prettier-ignore
|
||
Window_BattleLog.prototype.showEnemyAttackAnimation = function(
|
||
/* subject, targets */
|
||
) {
|
||
SoundManager.playEnemyAttack();
|
||
};
|
||
|
||
// prettier-ignore
|
||
Window_BattleLog.prototype.showNormalAnimation = function(
|
||
targets, animationId, mirror
|
||
) {
|
||
const animation = $dataAnimations[animationId];
|
||
if (animation) {
|
||
$gameTemp.requestAnimation(targets, animationId, mirror);
|
||
}
|
||
};
|
||
|
||
Window_BattleLog.prototype.refresh = function() {
|
||
this.drawBackground();
|
||
this.contents.clear();
|
||
for (let i = 0; i < this._lines.length; i++) {
|
||
this.drawLineText(i);
|
||
}
|
||
};
|
||
|
||
Window_BattleLog.prototype.drawBackground = function() {
|
||
const rect = this.backRect();
|
||
const color = this.backColor();
|
||
this.contentsBack.clear();
|
||
this.contentsBack.paintOpacity = this.backPaintOpacity();
|
||
this.contentsBack.fillRect(rect.x, rect.y, rect.width, rect.height, color);
|
||
this.contentsBack.paintOpacity = 255;
|
||
};
|
||
|
||
Window_BattleLog.prototype.backRect = function() {
|
||
const height = this.numLines() * this.itemHeight();
|
||
return new Rectangle(0, 0, this.innerWidth, height);
|
||
};
|
||
|
||
Window_BattleLog.prototype.lineRect = function(index) {
|
||
const itemHeight = this.itemHeight();
|
||
const padding = this.itemPadding();
|
||
const x = padding;
|
||
const y = index * itemHeight;
|
||
const width = this.innerWidth - padding * 2;
|
||
const height = itemHeight;
|
||
return new Rectangle(x, y, width, height);
|
||
};
|
||
|
||
Window_BattleLog.prototype.backColor = function() {
|
||
return "#000000";
|
||
};
|
||
|
||
Window_BattleLog.prototype.backPaintOpacity = function() {
|
||
return 64;
|
||
};
|
||
|
||
Window_BattleLog.prototype.drawLineText = function(index) {
|
||
const rect = this.lineRect(index);
|
||
this.contents.clearRect(rect.x, rect.y, rect.width, rect.height);
|
||
this.drawTextEx(this._lines[index], rect.x, rect.y, rect.width);
|
||
};
|
||
|
||
Window_BattleLog.prototype.startTurn = function() {
|
||
this.push("wait");
|
||
};
|
||
|
||
Window_BattleLog.prototype.startAction = function(subject, action, targets) {
|
||
const item = action.item();
|
||
this.push("performActionStart", subject, action);
|
||
this.push("waitForMovement");
|
||
this.push("performAction", subject, action);
|
||
this.push("showAnimation", subject, targets.clone(), item.animationId);
|
||
this.displayAction(subject, item);
|
||
};
|
||
|
||
Window_BattleLog.prototype.endAction = function(subject) {
|
||
this.push("waitForNewLine");
|
||
this.push("clear");
|
||
this.push("performActionEnd", subject);
|
||
};
|
||
|
||
Window_BattleLog.prototype.displayCurrentState = function(subject) {
|
||
const stateText = subject.mostImportantStateText();
|
||
if (stateText) {
|
||
this.push("addText", stateText.format(subject.name()));
|
||
this.push("wait");
|
||
this.push("clear");
|
||
}
|
||
};
|
||
|
||
Window_BattleLog.prototype.displayRegeneration = function(subject) {
|
||
this.push("popupDamage", subject);
|
||
};
|
||
|
||
Window_BattleLog.prototype.displayAction = function(subject, item) {
|
||
const numMethods = this._methods.length;
|
||
if (DataManager.isSkill(item)) {
|
||
this.displayItemMessage(item.message1, subject, item);
|
||
this.displayItemMessage(item.message2, subject, item);
|
||
} else {
|
||
this.displayItemMessage(TextManager.useItem, subject, item);
|
||
}
|
||
if (this._methods.length === numMethods) {
|
||
this.push("wait");
|
||
}
|
||
};
|
||
|
||
Window_BattleLog.prototype.displayItemMessage = function(fmt, subject, item) {
|
||
if (fmt) {
|
||
this.push("addText", fmt.format(subject.name(), item.name));
|
||
}
|
||
};
|
||
|
||
Window_BattleLog.prototype.displayCounter = function(target) {
|
||
this.push("performCounter", target);
|
||
this.push("addText", TextManager.counterAttack.format(target.name()));
|
||
};
|
||
|
||
Window_BattleLog.prototype.displayReflection = function(target) {
|
||
this.push("performReflection", target);
|
||
this.push("addText", TextManager.magicReflection.format(target.name()));
|
||
};
|
||
|
||
Window_BattleLog.prototype.displaySubstitute = function(substitute, target) {
|
||
const substName = substitute.name();
|
||
const text = TextManager.substitute.format(substName, target.name());
|
||
this.push("performSubstitute", substitute, target);
|
||
this.push("addText", text);
|
||
};
|
||
|
||
Window_BattleLog.prototype.displayActionResults = function(subject, target) {
|
||
if (target.result().used) {
|
||
this.push("pushBaseLine");
|
||
this.displayCritical(target);
|
||
this.push("popupDamage", target);
|
||
this.push("popupDamage", subject);
|
||
this.displayDamage(target);
|
||
this.displayAffectedStatus(target);
|
||
this.displayFailure(target);
|
||
this.push("waitForNewLine");
|
||
this.push("popBaseLine");
|
||
}
|
||
};
|
||
|
||
Window_BattleLog.prototype.displayFailure = function(target) {
|
||
if (target.result().isHit() && !target.result().success) {
|
||
this.push("addText", TextManager.actionFailure.format(target.name()));
|
||
}
|
||
};
|
||
|
||
Window_BattleLog.prototype.displayCritical = function(target) {
|
||
if (target.result().critical) {
|
||
if (target.isActor()) {
|
||
this.push("addText", TextManager.criticalToActor);
|
||
} else {
|
||
this.push("addText", TextManager.criticalToEnemy);
|
||
}
|
||
}
|
||
};
|
||
|
||
Window_BattleLog.prototype.displayDamage = function(target) {
|
||
if (target.result().missed) {
|
||
this.displayMiss(target);
|
||
} else if (target.result().evaded) {
|
||
this.displayEvasion(target);
|
||
} else {
|
||
this.displayHpDamage(target);
|
||
this.displayMpDamage(target);
|
||
this.displayTpDamage(target);
|
||
}
|
||
};
|
||
|
||
Window_BattleLog.prototype.displayMiss = function(target) {
|
||
let fmt;
|
||
if (target.result().physical) {
|
||
const isActor = target.isActor();
|
||
fmt = isActor ? TextManager.actorNoHit : TextManager.enemyNoHit;
|
||
this.push("performMiss", target);
|
||
} else {
|
||
fmt = TextManager.actionFailure;
|
||
}
|
||
this.push("addText", fmt.format(target.name()));
|
||
};
|
||
|
||
Window_BattleLog.prototype.displayEvasion = function(target) {
|
||
let fmt;
|
||
if (target.result().physical) {
|
||
fmt = TextManager.evasion;
|
||
this.push("performEvasion", target);
|
||
} else {
|
||
fmt = TextManager.magicEvasion;
|
||
this.push("performMagicEvasion", target);
|
||
}
|
||
this.push("addText", fmt.format(target.name()));
|
||
};
|
||
|
||
Window_BattleLog.prototype.displayHpDamage = function(target) {
|
||
if (target.result().hpAffected) {
|
||
if (target.result().hpDamage > 0 && !target.result().drain) {
|
||
this.push("performDamage", target);
|
||
}
|
||
if (target.result().hpDamage < 0) {
|
||
this.push("performRecovery", target);
|
||
}
|
||
this.push("addText", this.makeHpDamageText(target));
|
||
}
|
||
};
|
||
|
||
Window_BattleLog.prototype.displayMpDamage = function(target) {
|
||
if (target.isAlive() && target.result().mpDamage !== 0) {
|
||
if (target.result().mpDamage < 0) {
|
||
this.push("performRecovery", target);
|
||
}
|
||
this.push("addText", this.makeMpDamageText(target));
|
||
}
|
||
};
|
||
|
||
Window_BattleLog.prototype.displayTpDamage = function(target) {
|
||
if (target.isAlive() && target.result().tpDamage !== 0) {
|
||
if (target.result().tpDamage < 0) {
|
||
this.push("performRecovery", target);
|
||
}
|
||
this.push("addText", this.makeTpDamageText(target));
|
||
}
|
||
};
|
||
|
||
Window_BattleLog.prototype.displayAffectedStatus = function(target) {
|
||
if (target.result().isStatusAffected()) {
|
||
this.push("pushBaseLine");
|
||
this.displayChangedStates(target);
|
||
this.displayChangedBuffs(target);
|
||
this.push("waitForNewLine");
|
||
this.push("popBaseLine");
|
||
}
|
||
};
|
||
|
||
Window_BattleLog.prototype.displayAutoAffectedStatus = function(target) {
|
||
if (target.result().isStatusAffected()) {
|
||
this.displayAffectedStatus(target, null);
|
||
this.push("clear");
|
||
}
|
||
};
|
||
|
||
Window_BattleLog.prototype.displayChangedStates = function(target) {
|
||
this.displayAddedStates(target);
|
||
this.displayRemovedStates(target);
|
||
};
|
||
|
||
Window_BattleLog.prototype.displayAddedStates = function(target) {
|
||
const result = target.result();
|
||
const states = result.addedStateObjects();
|
||
for (const state of states) {
|
||
const stateText = target.isActor() ? state.message1 : state.message2;
|
||
if (state.id === target.deathStateId()) {
|
||
this.push("performCollapse", target);
|
||
}
|
||
if (stateText) {
|
||
this.push("popBaseLine");
|
||
this.push("pushBaseLine");
|
||
this.push("addText", stateText.format(target.name()));
|
||
this.push("waitForEffect");
|
||
}
|
||
}
|
||
};
|
||
|
||
Window_BattleLog.prototype.displayRemovedStates = function(target) {
|
||
const result = target.result();
|
||
const states = result.removedStateObjects();
|
||
for (const state of states) {
|
||
if (state.message4) {
|
||
this.push("popBaseLine");
|
||
this.push("pushBaseLine");
|
||
this.push("addText", state.message4.format(target.name()));
|
||
}
|
||
}
|
||
};
|
||
|
||
Window_BattleLog.prototype.displayChangedBuffs = function(target) {
|
||
const result = target.result();
|
||
this.displayBuffs(target, result.addedBuffs, TextManager.buffAdd);
|
||
this.displayBuffs(target, result.addedDebuffs, TextManager.debuffAdd);
|
||
this.displayBuffs(target, result.removedBuffs, TextManager.buffRemove);
|
||
};
|
||
|
||
Window_BattleLog.prototype.displayBuffs = function(target, buffs, fmt) {
|
||
for (const paramId of buffs) {
|
||
const text = fmt.format(target.name(), TextManager.param(paramId));
|
||
this.push("popBaseLine");
|
||
this.push("pushBaseLine");
|
||
this.push("addText", text);
|
||
}
|
||
};
|
||
|
||
Window_BattleLog.prototype.makeHpDamageText = function(target) {
|
||
const result = target.result();
|
||
const damage = result.hpDamage;
|
||
const isActor = target.isActor();
|
||
let fmt;
|
||
if (damage > 0 && result.drain) {
|
||
fmt = isActor ? TextManager.actorDrain : TextManager.enemyDrain;
|
||
return fmt.format(target.name(), TextManager.hp, damage);
|
||
} else if (damage > 0) {
|
||
fmt = isActor ? TextManager.actorDamage : TextManager.enemyDamage;
|
||
return fmt.format(target.name(), damage);
|
||
} else if (damage < 0) {
|
||
fmt = isActor ? TextManager.actorRecovery : TextManager.enemyRecovery;
|
||
return fmt.format(target.name(), TextManager.hp, -damage);
|
||
} else {
|
||
fmt = isActor ? TextManager.actorNoDamage : TextManager.enemyNoDamage;
|
||
return fmt.format(target.name());
|
||
}
|
||
};
|
||
|
||
Window_BattleLog.prototype.makeMpDamageText = function(target) {
|
||
const result = target.result();
|
||
const damage = result.mpDamage;
|
||
const isActor = target.isActor();
|
||
let fmt;
|
||
if (damage > 0 && result.drain) {
|
||
fmt = isActor ? TextManager.actorDrain : TextManager.enemyDrain;
|
||
return fmt.format(target.name(), TextManager.mp, damage);
|
||
} else if (damage > 0) {
|
||
fmt = isActor ? TextManager.actorLoss : TextManager.enemyLoss;
|
||
return fmt.format(target.name(), TextManager.mp, damage);
|
||
} else if (damage < 0) {
|
||
fmt = isActor ? TextManager.actorRecovery : TextManager.enemyRecovery;
|
||
return fmt.format(target.name(), TextManager.mp, -damage);
|
||
} else {
|
||
return "";
|
||
}
|
||
};
|
||
|
||
Window_BattleLog.prototype.makeTpDamageText = function(target) {
|
||
const result = target.result();
|
||
const damage = result.tpDamage;
|
||
const isActor = target.isActor();
|
||
let fmt;
|
||
if (damage > 0) {
|
||
fmt = isActor ? TextManager.actorLoss : TextManager.enemyLoss;
|
||
return fmt.format(target.name(), TextManager.tp, damage);
|
||
} else if (damage < 0) {
|
||
fmt = isActor ? TextManager.actorGain : TextManager.enemyGain;
|
||
return fmt.format(target.name(), TextManager.tp, -damage);
|
||
} else {
|
||
return "";
|
||
}
|
||
};
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Window_PartyCommand
|
||
//
|
||
// The window for selecting whether to fight or escape on the battle screen.
|
||
|
||
function Window_PartyCommand() {
|
||
this.initialize(...arguments);
|
||
}
|
||
|
||
Window_PartyCommand.prototype = Object.create(Window_Command.prototype);
|
||
Window_PartyCommand.prototype.constructor = Window_PartyCommand;
|
||
|
||
Window_PartyCommand.prototype.initialize = function(rect) {
|
||
Window_Command.prototype.initialize.call(this, rect);
|
||
this.openness = 0;
|
||
this.deactivate();
|
||
};
|
||
|
||
Window_PartyCommand.prototype.makeCommandList = function() {
|
||
this.addCommand(TextManager.fight, "fight");
|
||
this.addCommand(TextManager.escape, "escape", BattleManager.canEscape());
|
||
};
|
||
|
||
Window_PartyCommand.prototype.setup = function() {
|
||
this.refresh();
|
||
this.forceSelect(0);
|
||
this.activate();
|
||
this.open();
|
||
};
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Window_ActorCommand
|
||
//
|
||
// The window for selecting an actor's action on the battle screen.
|
||
|
||
function Window_ActorCommand() {
|
||
this.initialize(...arguments);
|
||
}
|
||
|
||
Window_ActorCommand.prototype = Object.create(Window_Command.prototype);
|
||
Window_ActorCommand.prototype.constructor = Window_ActorCommand;
|
||
|
||
Window_ActorCommand.prototype.initialize = function(rect) {
|
||
Window_Command.prototype.initialize.call(this, rect);
|
||
this.openness = 0;
|
||
this.deactivate();
|
||
this._actor = null;
|
||
};
|
||
|
||
Window_ActorCommand.prototype.makeCommandList = function() {
|
||
if (this._actor) {
|
||
this.addAttackCommand();
|
||
this.addSkillCommands();
|
||
this.addGuardCommand();
|
||
this.addItemCommand();
|
||
}
|
||
};
|
||
|
||
Window_ActorCommand.prototype.addAttackCommand = function() {
|
||
this.addCommand(TextManager.attack, "attack", this._actor.canAttack());
|
||
};
|
||
|
||
Window_ActorCommand.prototype.addSkillCommands = function() {
|
||
const skillTypes = this._actor.skillTypes();
|
||
for (const stypeId of skillTypes) {
|
||
const name = $dataSystem.skillTypes[stypeId];
|
||
this.addCommand(name, "skill", true, stypeId);
|
||
}
|
||
};
|
||
|
||
Window_ActorCommand.prototype.addGuardCommand = function() {
|
||
this.addCommand(TextManager.guard, "guard", this._actor.canGuard());
|
||
};
|
||
|
||
Window_ActorCommand.prototype.addItemCommand = function() {
|
||
this.addCommand(TextManager.item, "item");
|
||
};
|
||
|
||
Window_ActorCommand.prototype.setup = function(actor) {
|
||
this._actor = actor;
|
||
this.refresh();
|
||
this.selectLast();
|
||
this.activate();
|
||
this.open();
|
||
};
|
||
|
||
Window_ActorCommand.prototype.actor = function() {
|
||
return this._actor;
|
||
};
|
||
|
||
Window_ActorCommand.prototype.processOk = function() {
|
||
if (this._actor) {
|
||
if (ConfigManager.commandRemember) {
|
||
this._actor.setLastCommandSymbol(this.currentSymbol());
|
||
} else {
|
||
this._actor.setLastCommandSymbol("");
|
||
}
|
||
}
|
||
Window_Command.prototype.processOk.call(this);
|
||
};
|
||
|
||
Window_ActorCommand.prototype.selectLast = function() {
|
||
this.forceSelect(0);
|
||
if (this._actor && ConfigManager.commandRemember) {
|
||
const symbol = this._actor.lastCommandSymbol();
|
||
this.selectSymbol(symbol);
|
||
if (symbol === "skill") {
|
||
const skill = this._actor.lastBattleSkill();
|
||
if (skill) {
|
||
this.selectExt(skill.stypeId);
|
||
}
|
||
}
|
||
}
|
||
};
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Window_BattleStatus
|
||
//
|
||
// The window for displaying the status of party members on the battle screen.
|
||
|
||
function Window_BattleStatus() {
|
||
this.initialize(...arguments);
|
||
}
|
||
|
||
Window_BattleStatus.prototype = Object.create(Window_StatusBase.prototype);
|
||
Window_BattleStatus.prototype.constructor = Window_BattleStatus;
|
||
|
||
Window_BattleStatus.prototype.initialize = function(rect) {
|
||
Window_StatusBase.prototype.initialize.call(this, rect);
|
||
this.frameVisible = false;
|
||
this.openness = 0;
|
||
this._bitmapsReady = 0;
|
||
this.preparePartyRefresh();
|
||
};
|
||
|
||
Window_BattleStatus.prototype.extraHeight = function() {
|
||
return 10;
|
||
};
|
||
|
||
Window_BattleStatus.prototype.maxCols = function() {
|
||
return 4;
|
||
};
|
||
|
||
Window_BattleStatus.prototype.itemHeight = function() {
|
||
return this.innerHeight;
|
||
};
|
||
|
||
Window_BattleStatus.prototype.maxItems = function() {
|
||
return $gameParty.battleMembers().length;
|
||
};
|
||
|
||
Window_BattleStatus.prototype.rowSpacing = function() {
|
||
return 0;
|
||
};
|
||
|
||
Window_BattleStatus.prototype.updatePadding = function() {
|
||
this.padding = 8;
|
||
};
|
||
|
||
Window_BattleStatus.prototype.actor = function(index) {
|
||
return $gameParty.battleMembers()[index];
|
||
};
|
||
|
||
Window_BattleStatus.prototype.selectActor = function(actor) {
|
||
const members = $gameParty.battleMembers();
|
||
this.select(members.indexOf(actor));
|
||
};
|
||
|
||
Window_BattleStatus.prototype.update = function() {
|
||
Window_StatusBase.prototype.update.call(this);
|
||
if ($gameTemp.isBattleRefreshRequested()) {
|
||
this.preparePartyRefresh();
|
||
}
|
||
};
|
||
|
||
Window_BattleStatus.prototype.preparePartyRefresh = function() {
|
||
$gameTemp.clearBattleRefreshRequest();
|
||
this._bitmapsReady = 0;
|
||
for (const actor of $gameParty.members()) {
|
||
const bitmap = ImageManager.loadFace(actor.faceName());
|
||
bitmap.addLoadListener(this.performPartyRefresh.bind(this));
|
||
}
|
||
};
|
||
|
||
Window_BattleStatus.prototype.performPartyRefresh = function() {
|
||
this._bitmapsReady++;
|
||
if (this._bitmapsReady >= $gameParty.members().length) {
|
||
this.refresh();
|
||
}
|
||
};
|
||
|
||
Window_BattleStatus.prototype.drawItem = function(index) {
|
||
this.drawItemImage(index);
|
||
this.drawItemStatus(index);
|
||
};
|
||
|
||
Window_BattleStatus.prototype.drawItemImage = function(index) {
|
||
const actor = this.actor(index);
|
||
const rect = this.faceRect(index);
|
||
this.drawActorFace(actor, rect.x, rect.y, rect.width, rect.height);
|
||
};
|
||
|
||
Window_BattleStatus.prototype.drawItemStatus = function(index) {
|
||
const actor = this.actor(index);
|
||
const rect = this.itemRectWithPadding(index);
|
||
const nameX = this.nameX(rect);
|
||
const nameY = this.nameY(rect);
|
||
const stateIconX = this.stateIconX(rect);
|
||
const stateIconY = this.stateIconY(rect);
|
||
const basicGaugesX = this.basicGaugesX(rect);
|
||
const basicGaugesY = this.basicGaugesY(rect);
|
||
this.placeTimeGauge(actor, nameX, nameY);
|
||
this.placeActorName(actor, nameX, nameY);
|
||
this.placeStateIcon(actor, stateIconX, stateIconY);
|
||
this.placeBasicGauges(actor, basicGaugesX, basicGaugesY);
|
||
};
|
||
|
||
Window_BattleStatus.prototype.faceRect = function(index) {
|
||
const rect = this.itemRect(index);
|
||
rect.pad(-1);
|
||
rect.height = this.nameY(rect) + this.gaugeLineHeight() / 2 - rect.y;
|
||
return rect;
|
||
};
|
||
|
||
Window_BattleStatus.prototype.nameX = function(rect) {
|
||
return rect.x;
|
||
};
|
||
|
||
Window_BattleStatus.prototype.nameY = function(rect) {
|
||
return this.basicGaugesY(rect) - this.gaugeLineHeight();
|
||
};
|
||
|
||
Window_BattleStatus.prototype.stateIconX = function(rect) {
|
||
return rect.x + rect.width - ImageManager.iconWidth / 2 + 4;
|
||
};
|
||
|
||
Window_BattleStatus.prototype.stateIconY = function(rect) {
|
||
return rect.y + ImageManager.iconHeight / 2 + 4;
|
||
};
|
||
|
||
Window_BattleStatus.prototype.basicGaugesX = function(rect) {
|
||
return rect.x;
|
||
};
|
||
|
||
Window_BattleStatus.prototype.basicGaugesY = function(rect) {
|
||
const bottom = rect.y + rect.height - this.extraHeight();
|
||
const numGauges = $dataSystem.optDisplayTp ? 3 : 2;
|
||
return bottom - this.gaugeLineHeight() * numGauges;
|
||
};
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Window_BattleActor
|
||
//
|
||
// The window for selecting a target actor on the battle screen.
|
||
|
||
function Window_BattleActor() {
|
||
this.initialize(...arguments);
|
||
}
|
||
|
||
Window_BattleActor.prototype = Object.create(Window_BattleStatus.prototype);
|
||
Window_BattleActor.prototype.constructor = Window_BattleActor;
|
||
|
||
Window_BattleActor.prototype.initialize = function(rect) {
|
||
Window_BattleStatus.prototype.initialize.call(this, rect);
|
||
this.openness = 255;
|
||
this.hide();
|
||
};
|
||
|
||
Window_BattleActor.prototype.show = function() {
|
||
this.forceSelect(0);
|
||
$gameTemp.clearTouchState();
|
||
Window_BattleStatus.prototype.show.call(this);
|
||
};
|
||
|
||
Window_BattleActor.prototype.hide = function() {
|
||
Window_BattleStatus.prototype.hide.call(this);
|
||
$gameParty.select(null);
|
||
};
|
||
|
||
Window_BattleActor.prototype.select = function(index) {
|
||
Window_BattleStatus.prototype.select.call(this, index);
|
||
$gameParty.select(this.actor(index));
|
||
};
|
||
|
||
Window_BattleActor.prototype.processTouch = function() {
|
||
Window_BattleStatus.prototype.processTouch.call(this);
|
||
if (this.isOpenAndActive()) {
|
||
const target = $gameTemp.touchTarget();
|
||
if (target) {
|
||
const members = $gameParty.battleMembers();
|
||
if (members.includes(target)) {
|
||
this.select(members.indexOf(target));
|
||
if ($gameTemp.touchState() === "click") {
|
||
this.processOk();
|
||
}
|
||
}
|
||
$gameTemp.clearTouchState();
|
||
}
|
||
}
|
||
};
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Window_BattleEnemy
|
||
//
|
||
// The window for selecting a target enemy on the battle screen.
|
||
|
||
function Window_BattleEnemy() {
|
||
this.initialize(...arguments);
|
||
}
|
||
|
||
Window_BattleEnemy.prototype = Object.create(Window_Selectable.prototype);
|
||
Window_BattleEnemy.prototype.constructor = Window_BattleEnemy;
|
||
|
||
Window_BattleEnemy.prototype.initialize = function(rect) {
|
||
this._enemies = [];
|
||
Window_Selectable.prototype.initialize.call(this, rect);
|
||
this.refresh();
|
||
this.hide();
|
||
};
|
||
|
||
Window_BattleEnemy.prototype.maxCols = function() {
|
||
return 2;
|
||
};
|
||
|
||
Window_BattleEnemy.prototype.maxItems = function() {
|
||
return this._enemies.length;
|
||
};
|
||
|
||
Window_BattleEnemy.prototype.enemy = function() {
|
||
return this._enemies[this.index()];
|
||
};
|
||
|
||
Window_BattleEnemy.prototype.enemyIndex = function() {
|
||
const enemy = this.enemy();
|
||
return enemy ? enemy.index() : -1;
|
||
};
|
||
|
||
Window_BattleEnemy.prototype.drawItem = function(index) {
|
||
this.resetTextColor();
|
||
const name = this._enemies[index].name();
|
||
const rect = this.itemLineRect(index);
|
||
this.drawText(name, rect.x, rect.y, rect.width);
|
||
};
|
||
|
||
Window_BattleEnemy.prototype.show = function() {
|
||
this.refresh();
|
||
this.forceSelect(0);
|
||
$gameTemp.clearTouchState();
|
||
Window_Selectable.prototype.show.call(this);
|
||
};
|
||
|
||
Window_BattleEnemy.prototype.hide = function() {
|
||
Window_Selectable.prototype.hide.call(this);
|
||
$gameTroop.select(null);
|
||
};
|
||
|
||
Window_BattleEnemy.prototype.refresh = function() {
|
||
this._enemies = $gameTroop.aliveMembers();
|
||
Window_Selectable.prototype.refresh.call(this);
|
||
};
|
||
|
||
Window_BattleEnemy.prototype.select = function(index) {
|
||
Window_Selectable.prototype.select.call(this, index);
|
||
$gameTroop.select(this.enemy());
|
||
};
|
||
|
||
Window_BattleEnemy.prototype.processTouch = function() {
|
||
Window_Selectable.prototype.processTouch.call(this);
|
||
if (this.isOpenAndActive()) {
|
||
const target = $gameTemp.touchTarget();
|
||
if (target) {
|
||
if (this._enemies.includes(target)) {
|
||
this.select(this._enemies.indexOf(target));
|
||
if ($gameTemp.touchState() === "click") {
|
||
this.processOk();
|
||
}
|
||
}
|
||
$gameTemp.clearTouchState();
|
||
}
|
||
}
|
||
};
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Window_BattleSkill
|
||
//
|
||
// The window for selecting a skill to use on the battle screen.
|
||
|
||
function Window_BattleSkill() {
|
||
this.initialize(...arguments);
|
||
}
|
||
|
||
Window_BattleSkill.prototype = Object.create(Window_SkillList.prototype);
|
||
Window_BattleSkill.prototype.constructor = Window_BattleSkill;
|
||
|
||
Window_BattleSkill.prototype.initialize = function(rect) {
|
||
Window_SkillList.prototype.initialize.call(this, rect);
|
||
this.hide();
|
||
};
|
||
|
||
Window_BattleSkill.prototype.show = function() {
|
||
this.selectLast();
|
||
this.showHelpWindow();
|
||
Window_SkillList.prototype.show.call(this);
|
||
};
|
||
|
||
Window_BattleSkill.prototype.hide = function() {
|
||
this.hideHelpWindow();
|
||
Window_SkillList.prototype.hide.call(this);
|
||
};
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Window_BattleItem
|
||
//
|
||
// The window for selecting an item to use on the battle screen.
|
||
|
||
function Window_BattleItem() {
|
||
this.initialize(...arguments);
|
||
}
|
||
|
||
Window_BattleItem.prototype = Object.create(Window_ItemList.prototype);
|
||
Window_BattleItem.prototype.constructor = Window_BattleItem;
|
||
|
||
Window_BattleItem.prototype.initialize = function(rect) {
|
||
Window_ItemList.prototype.initialize.call(this, rect);
|
||
this.hide();
|
||
};
|
||
|
||
Window_BattleItem.prototype.includes = function(item) {
|
||
return $gameParty.canUse(item);
|
||
};
|
||
|
||
Window_BattleItem.prototype.show = function() {
|
||
this.selectLast();
|
||
this.showHelpWindow();
|
||
Window_ItemList.prototype.show.call(this);
|
||
};
|
||
|
||
Window_BattleItem.prototype.hide = function() {
|
||
this.hideHelpWindow();
|
||
Window_ItemList.prototype.hide.call(this);
|
||
};
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Window_TitleCommand
|
||
//
|
||
// The window for selecting New Game/Continue on the title screen.
|
||
|
||
function Window_TitleCommand() {
|
||
this.initialize(...arguments);
|
||
}
|
||
|
||
Window_TitleCommand.prototype = Object.create(Window_Command.prototype);
|
||
Window_TitleCommand.prototype.constructor = Window_TitleCommand;
|
||
|
||
Window_TitleCommand.prototype.initialize = function(rect) {
|
||
Window_Command.prototype.initialize.call(this, rect);
|
||
this.openness = 0;
|
||
this.selectLast();
|
||
};
|
||
|
||
Window_TitleCommand._lastCommandSymbol = null;
|
||
|
||
Window_TitleCommand.initCommandPosition = function() {
|
||
this._lastCommandSymbol = null;
|
||
};
|
||
|
||
Window_TitleCommand.prototype.makeCommandList = function() {
|
||
const continueEnabled = this.isContinueEnabled();
|
||
this.addCommand(TextManager.newGame, "newGame");
|
||
this.addCommand(TextManager.continue_, "continue", continueEnabled);
|
||
this.addCommand(TextManager.options, "options");
|
||
};
|
||
|
||
Window_TitleCommand.prototype.isContinueEnabled = function() {
|
||
return DataManager.isAnySavefileExists();
|
||
};
|
||
|
||
Window_TitleCommand.prototype.processOk = function() {
|
||
Window_TitleCommand._lastCommandSymbol = this.currentSymbol();
|
||
Window_Command.prototype.processOk.call(this);
|
||
};
|
||
|
||
Window_TitleCommand.prototype.selectLast = function() {
|
||
if (Window_TitleCommand._lastCommandSymbol) {
|
||
this.selectSymbol(Window_TitleCommand._lastCommandSymbol);
|
||
} else if (this.isContinueEnabled()) {
|
||
this.selectSymbol("continue");
|
||
}
|
||
};
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Window_GameEnd
|
||
//
|
||
// The window for selecting "Go to Title" on the game end screen.
|
||
|
||
function Window_GameEnd() {
|
||
this.initialize(...arguments);
|
||
}
|
||
|
||
Window_GameEnd.prototype = Object.create(Window_Command.prototype);
|
||
Window_GameEnd.prototype.constructor = Window_GameEnd;
|
||
|
||
Window_GameEnd.prototype.initialize = function(rect) {
|
||
Window_Command.prototype.initialize.call(this, rect);
|
||
this.openness = 0;
|
||
this.open();
|
||
};
|
||
|
||
Window_GameEnd.prototype.makeCommandList = function() {
|
||
this.addCommand(TextManager.toTitle, "toTitle");
|
||
this.addCommand(TextManager.cancel, "cancel");
|
||
};
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Window_DebugRange
|
||
//
|
||
// The window for selecting a block of switches/variables on the debug screen.
|
||
|
||
function Window_DebugRange() {
|
||
this.initialize(...arguments);
|
||
}
|
||
|
||
Window_DebugRange.prototype = Object.create(Window_Selectable.prototype);
|
||
Window_DebugRange.prototype.constructor = Window_DebugRange;
|
||
|
||
Window_DebugRange.lastTopRow = 0;
|
||
Window_DebugRange.lastIndex = 0;
|
||
|
||
Window_DebugRange.prototype.initialize = function(rect) {
|
||
this._maxSwitches = Math.ceil(($dataSystem.switches.length - 1) / 10);
|
||
this._maxVariables = Math.ceil(($dataSystem.variables.length - 1) / 10);
|
||
Window_Selectable.prototype.initialize.call(this, rect);
|
||
this.refresh();
|
||
this.setTopRow(Window_DebugRange.lastTopRow);
|
||
this.select(Window_DebugRange.lastIndex);
|
||
this.activate();
|
||
};
|
||
|
||
Window_DebugRange.prototype.maxItems = function() {
|
||
return this._maxSwitches + this._maxVariables;
|
||
};
|
||
|
||
Window_DebugRange.prototype.update = function() {
|
||
Window_Selectable.prototype.update.call(this);
|
||
if (this._editWindow) {
|
||
const index = this.index();
|
||
this._editWindow.setMode(this.mode(index));
|
||
this._editWindow.setTopId(this.topId(index));
|
||
}
|
||
};
|
||
|
||
Window_DebugRange.prototype.mode = function(index) {
|
||
return this.isSwitchMode(index) ? "switch" : "variable";
|
||
};
|
||
|
||
Window_DebugRange.prototype.topId = function(index) {
|
||
if (this.isSwitchMode(index)) {
|
||
return index * 10 + 1;
|
||
} else {
|
||
return (index - this._maxSwitches) * 10 + 1;
|
||
}
|
||
};
|
||
|
||
Window_DebugRange.prototype.isSwitchMode = function(index) {
|
||
return index < this._maxSwitches;
|
||
};
|
||
|
||
Window_DebugRange.prototype.drawItem = function(index) {
|
||
const rect = this.itemLineRect(index);
|
||
const c = this.isSwitchMode(index) ? "S" : "V";
|
||
const start = this.topId(index);
|
||
const end = start + 9;
|
||
const text = c + " [" + start.padZero(4) + "-" + end.padZero(4) + "]";
|
||
this.drawText(text, rect.x, rect.y, rect.width);
|
||
};
|
||
|
||
Window_DebugRange.prototype.isCancelTriggered = function() {
|
||
return (
|
||
Window_Selectable.prototype.isCancelTriggered() ||
|
||
Input.isTriggered("debug")
|
||
);
|
||
};
|
||
|
||
Window_DebugRange.prototype.processCancel = function() {
|
||
Window_Selectable.prototype.processCancel.call(this);
|
||
Window_DebugRange.lastTopRow = this.topRow();
|
||
Window_DebugRange.lastIndex = this.index();
|
||
};
|
||
|
||
Window_DebugRange.prototype.setEditWindow = function(editWindow) {
|
||
this._editWindow = editWindow;
|
||
};
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Window_DebugEdit
|
||
//
|
||
// The window for displaying switches and variables on the debug screen.
|
||
|
||
function Window_DebugEdit() {
|
||
this.initialize(...arguments);
|
||
}
|
||
|
||
Window_DebugEdit.prototype = Object.create(Window_Selectable.prototype);
|
||
Window_DebugEdit.prototype.constructor = Window_DebugEdit;
|
||
|
||
Window_DebugEdit.prototype.initialize = function(rect) {
|
||
Window_Selectable.prototype.initialize.call(this, rect);
|
||
this._mode = "switch";
|
||
this._topId = 1;
|
||
this.refresh();
|
||
};
|
||
|
||
Window_DebugEdit.prototype.maxItems = function() {
|
||
return 10;
|
||
};
|
||
|
||
Window_DebugEdit.prototype.drawItem = function(index) {
|
||
const dataId = this._topId + index;
|
||
const idText = dataId.padZero(4) + ":";
|
||
const idWidth = this.textWidth(idText);
|
||
const statusWidth = this.textWidth("-00000000");
|
||
const name = this.itemName(dataId);
|
||
const status = this.itemStatus(dataId);
|
||
const rect = this.itemLineRect(index);
|
||
this.resetTextColor();
|
||
this.drawText(idText, rect.x, rect.y, rect.width);
|
||
rect.x += idWidth;
|
||
rect.width -= idWidth + statusWidth;
|
||
this.drawText(name, rect.x, rect.y, rect.width);
|
||
this.drawText(status, rect.x + rect.width, rect.y, statusWidth, "right");
|
||
};
|
||
|
||
Window_DebugEdit.prototype.itemName = function(dataId) {
|
||
if (this._mode === "switch") {
|
||
return $dataSystem.switches[dataId];
|
||
} else {
|
||
return $dataSystem.variables[dataId];
|
||
}
|
||
};
|
||
|
||
Window_DebugEdit.prototype.itemStatus = function(dataId) {
|
||
if (this._mode === "switch") {
|
||
return $gameSwitches.value(dataId) ? "[ON]" : "[OFF]";
|
||
} else {
|
||
return String($gameVariables.value(dataId));
|
||
}
|
||
};
|
||
|
||
Window_DebugEdit.prototype.setMode = function(mode) {
|
||
if (this._mode !== mode) {
|
||
this._mode = mode;
|
||
this.refresh();
|
||
}
|
||
};
|
||
|
||
Window_DebugEdit.prototype.setTopId = function(id) {
|
||
if (this._topId !== id) {
|
||
this._topId = id;
|
||
this.refresh();
|
||
}
|
||
};
|
||
|
||
Window_DebugEdit.prototype.currentId = function() {
|
||
return this._topId + this.index();
|
||
};
|
||
|
||
Window_DebugEdit.prototype.update = function() {
|
||
Window_Selectable.prototype.update.call(this);
|
||
if (this.active) {
|
||
if (this._mode === "switch") {
|
||
this.updateSwitch();
|
||
} else {
|
||
this.updateVariable();
|
||
}
|
||
}
|
||
};
|
||
|
||
Window_DebugEdit.prototype.updateSwitch = function() {
|
||
if (Input.isRepeated("ok")) {
|
||
const switchId = this.currentId();
|
||
this.playCursorSound();
|
||
$gameSwitches.setValue(switchId, !$gameSwitches.value(switchId));
|
||
this.redrawCurrentItem();
|
||
}
|
||
};
|
||
|
||
Window_DebugEdit.prototype.updateVariable = function() {
|
||
const variableId = this.currentId();
|
||
const value = $gameVariables.value(variableId);
|
||
if (typeof value === "number") {
|
||
const newValue = value + this.deltaForVariable();
|
||
if (value !== newValue) {
|
||
$gameVariables.setValue(variableId, newValue);
|
||
this.playCursorSound();
|
||
this.redrawCurrentItem();
|
||
}
|
||
}
|
||
};
|
||
|
||
Window_DebugEdit.prototype.deltaForVariable = function() {
|
||
if (Input.isRepeated("right")) {
|
||
return 1;
|
||
} else if (Input.isRepeated("left")) {
|
||
return -1;
|
||
} else if (Input.isRepeated("pagedown")) {
|
||
return 10;
|
||
} else if (Input.isRepeated("pageup")) {
|
||
return -10;
|
||
}
|
||
return 0;
|
||
};
|
||
|
||
//-----------------------------------------------------------------------------
|