Project1

标题: 测试，此代码太长无法直接交给AI，发这里让AI过来读取试试 [打印本页]
作者: 雷影    时间: 2023-4-9 18:27
标题: 测试，此代码太长无法直接交给AI，发这里让AI过来读取试试
  1. //=============================================================================
  2. // rpg_windows.js v1.6.2
  3. //=============================================================================

  5. //-----------------------------------------------------------------------------
  6. // Window_Base
  7. //
  8. // The superclass of all windows within the game.

  10. function Window_Base() {
  11.     this.initialize.apply(this, arguments);
  12. }

  14. Window_Base.prototype = Object.create(Window.prototype);
  15. Window_Base.prototype.constructor = Window_Base;

  17. Window_Base.prototype.initialize = function(x, y, width, height) {
  18.     Window.prototype.initialize.call(this);
  19.     this.loadWindowskin();
  20.     this.move(x, y, width, height);
  21.     this.updatePadding();
  22.     this.updateBackOpacity();
  23.     this.updateTone();
  24.     this.createContents();
  25.     this._opening = false;
  26.     this._closing = false;
  27.     this._dimmerSprite = null;
  28. };

  30. Window_Base._iconWidth  = 32;
  31. Window_Base._iconHeight = 32;
  32. Window_Base._faceWidth  = 144;
  33. Window_Base._faceHeight = 144;

  35. Window_Base.prototype.lineHeight = function() {
  36.     return 36;
  37. };

  39. Window_Base.prototype.standardFontFace = function() {
  40.     if ($gameSystem.isChinese()) {
  41.         return 'SimHei, Heiti TC, sans-serif';
  42.     } else if ($gameSystem.isKorean()) {
  43.         return 'Dotum, AppleGothic, sans-serif';
  44.     } else {
  45.         return 'GameFont';
  46.     }
  47. };

  49. Window_Base.prototype.standardFontSize = function() {
  50.     return 28;
  51. };

  53. Window_Base.prototype.standardPadding = function() {
  54.     return 18;
  55. };

  57. Window_Base.prototype.textPadding = function() {
  58.     return 6;
  59. };

  61. Window_Base.prototype.standardBackOpacity = function() {
  62.     return 192;
  63. };

  65. Window_Base.prototype.loadWindowskin = function() {
  66.     this.windowskin = ImageManager.loadSystem('Window');
  67. };

  69. Window_Base.prototype.updatePadding = function() {
  70.     this.padding = this.standardPadding();
  71. };

  73. Window_Base.prototype.updateBackOpacity = function() {
  74.     this.backOpacity = this.standardBackOpacity();
  75. };

  77. Window_Base.prototype.contentsWidth = function() {
  78.     return this.width - this.standardPadding() * 2;
  79. };

  81. Window_Base.prototype.contentsHeight = function() {
  82.     return this.height - this.standardPadding() * 2;
  83. };

  85. Window_Base.prototype.fittingHeight = function(numLines) {
  86.     return numLines * this.lineHeight() + this.standardPadding() * 2;
  87. };

  89. Window_Base.prototype.updateTone = function() {
  90.     var tone = $gameSystem.windowTone();
  91.     this.setTone(tone[0], tone[1], tone[2]);
  92. };

  94. Window_Base.prototype.createContents = function() {
  95.     this.contents = new Bitmap(this.contentsWidth(), this.contentsHeight());
  96.     this.resetFontSettings();
  97. };

  99. Window_Base.prototype.resetFontSettings = function() {
  100.     this.contents.fontFace = this.standardFontFace();
  101.     this.contents.fontSize = this.standardFontSize();
  102.     this.resetTextColor();
  103. };

  105. Window_Base.prototype.resetTextColor = function() {
  106.     this.changeTextColor(this.normalColor());
  107. };

  109. Window_Base.prototype.update = function() {
  110.     Window.prototype.update.call(this);
  111.     this.updateTone();
  112.     this.updateOpen();
  113.     this.updateClose();
  114.     this.updateBackgroundDimmer();
  115. };

  117. Window_Base.prototype.updateOpen = function() {
  118.     if (this._opening) {
  119.         this.openness += 32;
  120.         if (this.isOpen()) {
  121.             this._opening = false;
  122.         }
  123.     }
  124. };

  126. Window_Base.prototype.updateClose = function() {
  127.     if (this._closing) {
  128.         this.openness -= 32;
  129.         if (this.isClosed()) {
  130.             this._closing = false;
  131.         }
  132.     }
  133. };

  135. Window_Base.prototype.open = function() {
  136.     if (!this.isOpen()) {
  137.         this._opening = true;
  138.     }
  139.     this._closing = false;
  140. };

  142. Window_Base.prototype.close = function() {
  143.     if (!this.isClosed()) {
  144.         this._closing = true;
  145.     }
  146.     this._opening = false;
  147. };

  149. Window_Base.prototype.isOpening = function() {
  150.     return this._opening;
  151. };

  153. Window_Base.prototype.isClosing = function() {
  154.     return this._closing;
  155. };

  157. Window_Base.prototype.show = function() {
  158.     this.visible = true;
  159. };

  161. Window_Base.prototype.hide = function() {
  162.     this.visible = false;
  163. };

  165. Window_Base.prototype.activate = function() {
  166.     this.active = true;
  167. };

  169. Window_Base.prototype.deactivate = function() {
  170.     this.active = false;
  171. };

  173. Window_Base.prototype.textColor = function(n) {
  174.     var px = 96 + (n % 8) * 12 + 6;
  175.     var py = 144 + Math.floor(n / 8) * 12 + 6;
  176.     return this.windowskin.getPixel(px, py);
  177. };

  179. Window_Base.prototype.normalColor = function() {
  180.     return this.textColor(0);
  181. };

  183. Window_Base.prototype.systemColor = function() {
  184.     return this.textColor(16);
  185. };

  187. Window_Base.prototype.crisisColor = function() {
  188.     return this.textColor(17);
  189. };

  191. Window_Base.prototype.deathColor = function() {
  192.     return this.textColor(18);
  193. };

  195. Window_Base.prototype.gaugeBackColor = function() {
  196.     return this.textColor(19);
  197. };

  199. Window_Base.prototype.hpGaugeColor1 = function() {
  200.     return this.textColor(20);
  201. };

  203. Window_Base.prototype.hpGaugeColor2 = function() {
  204.     return this.textColor(21);
  205. };

  207. Window_Base.prototype.mpGaugeColor1 = function() {
  208.     return this.textColor(22);
  209. };

  211. Window_Base.prototype.mpGaugeColor2 = function() {
  212.     return this.textColor(23);
  213. };

  215. Window_Base.prototype.mpCostColor = function() {
  216.     return this.textColor(23);
  217. };

  219. Window_Base.prototype.powerUpColor = function() {
  220.     return this.textColor(24);
  221. };

  223. Window_Base.prototype.powerDownColor = function() {
  224.     return this.textColor(25);
  225. };

  227. Window_Base.prototype.tpGaugeColor1 = function() {
  228.     return this.textColor(28);
  229. };

  231. Window_Base.prototype.tpGaugeColor2 = function() {
  232.     return this.textColor(29);
  233. };

  235. Window_Base.prototype.tpCostColor = function() {
  236.     return this.textColor(29);
  237. };

  239. Window_Base.prototype.pendingColor = function() {
  240.     return this.windowskin.getPixel(120, 120);
  241. };

  243. Window_Base.prototype.translucentOpacity = function() {
  244.     return 160;
  245. };

  247. Window_Base.prototype.changeTextColor = function(color) {
  248.     this.contents.textColor = color;
  249. };

  251. Window_Base.prototype.changePaintOpacity = function(enabled) {
  252.     this.contents.paintOpacity = enabled ? 255 : this.translucentOpacity();
  253. };

  255. Window_Base.prototype.drawText = function(text, x, y, maxWidth, align) {
  256.     this.contents.drawText(text, x, y, maxWidth, this.lineHeight(), align);
  257. };

  259. Window_Base.prototype.textWidth = function(text) {
  260.     return this.contents.measureTextWidth(text);
  261. };

  263. Window_Base.prototype.drawTextEx = function(text, x, y) {
  264.     if (text) {
  265.         var textState = { index: 0, x: x, y: y, left: x };
  266.         textState.text = this.convertEscapeCharacters(text);
  267.         textState.height = this.calcTextHeight(textState, false);
  268.         this.resetFontSettings();
  269.         while (textState.index < textState.text.length) {
  270.             this.processCharacter(textState);
  271.         }
  272.         return textState.x - x;
  273.     } else {
  274.         return 0;
  275.     }
  276. };

  278. Window_Base.prototype.convertEscapeCharacters = function(text) {
  279.     text = text.replace(/\\/g, '\x1b');
  280.     text = text.replace(/\x1b\x1b/g, '\\');
  281.     text = text.replace(/\x1bV\[(\d+)\]/gi, function() {
  282.         return $gameVariables.value(parseInt(arguments[1]));
  283.     }.bind(this));
  284.     text = text.replace(/\x1bV\[(\d+)\]/gi, function() {
  285.         return $gameVariables.value(parseInt(arguments[1]));
  286.     }.bind(this));
  287.     text = text.replace(/\x1bN\[(\d+)\]/gi, function() {
  288.         return this.actorName(parseInt(arguments[1]));
  289.     }.bind(this));
  290.     text = text.replace(/\x1bP\[(\d+)\]/gi, function() {
  291.         return this.partyMemberName(parseInt(arguments[1]));
  292.     }.bind(this));
  293.     text = text.replace(/\x1bG/gi, TextManager.currencyUnit);
  294.     return text;
  295. };

  297. Window_Base.prototype.actorName = function(n) {
  298.     var actor = n >= 1 ? $gameActors.actor(n) : null;
  299.     return actor ? actor.name() : '';
  300. };

  302. Window_Base.prototype.partyMemberName = function(n) {
  303.     var actor = n >= 1 ? $gameParty.members()[n - 1] : null;
  304.     return actor ? actor.name() : '';
  305. };

  307. Window_Base.prototype.processCharacter = function(textState) {
  308.     switch (textState.text[textState.index]) {
  309.     case '\n':
  310.         this.processNewLine(textState);
  311.         break;
  312.     case '\f':
  313.         this.processNewPage(textState);
  314.         break;
  315.     case '\x1b':
  316.         this.processEscapeCharacter(this.obtainEscapeCode(textState), textState);
  317.         break;
  318.     default:
  319.         this.processNormalCharacter(textState);
  320.         break;
  321.     }
  322. };

  324. Window_Base.prototype.processNormalCharacter = function(textState) {
  325.     var c = textState.text[textState.index++];
  326.     var w = this.textWidth(c);
  327.     this.contents.drawText(c, textState.x, textState.y, w * 2, textState.height);
  328.     textState.x += w;
  329. };

  331. Window_Base.prototype.processNewLine = function(textState) {
  332.     textState.x = textState.left;
  333.     textState.y += textState.height;
  334.     textState.height = this.calcTextHeight(textState, false);
  335.     textState.index++;
  336. };

  338. Window_Base.prototype.processNewPage = function(textState) {
  339.     textState.index++;
  340. };

  342. Window_Base.prototype.obtainEscapeCode = function(textState) {
  343.     textState.index++;
  344.     var regExp = /^[\$\.\|\^!><\{\}\\]|^[A-Z]+/i;
  345.     var arr = regExp.exec(textState.text.slice(textState.index));
  346.     if (arr) {
  347.         textState.index += arr[0].length;
  348.         return arr[0].toUpperCase();
  349.     } else {
  350.         return '';
  351.     }
  352. };

  354. Window_Base.prototype.obtainEscapeParam = function(textState) {
  355.     var arr = /^\[\d+\]/.exec(textState.text.slice(textState.index));
  356.     if (arr) {
  357.         textState.index += arr[0].length;
  358.         return parseInt(arr[0].slice(1));
  359.     } else {
  360.         return '';
  361.     }
  362. };

  364. Window_Base.prototype.processEscapeCharacter = function(code, textState) {
  365.     switch (code) {
  366.     case 'C':
  367.         this.changeTextColor(this.textColor(this.obtainEscapeParam(textState)));
  368.         break;
  369.     case 'I':
  370.         this.processDrawIcon(this.obtainEscapeParam(textState), textState);
  371.         break;
  372.     case '{':
  373.         this.makeFontBigger();
  374.         break;
  375.     case '}':
  376.         this.makeFontSmaller();
  377.         break;
  378.     }
  379. };

  381. Window_Base.prototype.processDrawIcon = function(iconIndex, textState) {
  382.     this.drawIcon(iconIndex, textState.x + 2, textState.y + 2);
  383.     textState.x += Window_Base._iconWidth + 4;
  384. };

  386. Window_Base.prototype.makeFontBigger = function() {
  387.     if (this.contents.fontSize <= 96) {
  388.         this.contents.fontSize += 12;
  389.     }
  390. };

  392. Window_Base.prototype.makeFontSmaller = function() {
  393.     if (this.contents.fontSize >= 24) {
  394.         this.contents.fontSize -= 12;
  395.     }
  396. };

  398. Window_Base.prototype.calcTextHeight = function(textState, all) {
  399.     var lastFontSize = this.contents.fontSize;
  400.     var textHeight = 0;
  401.     var lines = textState.text.slice(textState.index).split('\n');
  402.     var maxLines = all ? lines.length : 1;

  404.     for (var i = 0; i < maxLines; i++) {
  405.         var maxFontSize = this.contents.fontSize;
  406.         var regExp = /\x1b[\{\}]/g;
  407.         for (;;) {
  408.             var array = regExp.exec(lines[i]);
  409.             if (array) {
  410.                 if (array[0] === '\x1b{') {
  411.                     this.makeFontBigger();
  412.                 }
  413.                 if (array[0] === '\x1b}') {
  414.                     this.makeFontSmaller();
  415.                 }
  416.                 if (maxFontSize < this.contents.fontSize) {
  417.                     maxFontSize = this.contents.fontSize;
  418.                 }
  419.             } else {
  420.                 break;
  421.             }
  422.         }
  423.         textHeight += maxFontSize + 8;
  424.     }

  426.     this.contents.fontSize = lastFontSize;
  427.     return textHeight;
  428. };

  430. Window_Base.prototype.drawIcon = function(iconIndex, x, y) {
  431.     var bitmap = ImageManager.loadSystem('IconSet');
  432.     var pw = Window_Base._iconWidth;
  433.     var ph = Window_Base._iconHeight;
  434.     var sx = iconIndex % 16 * pw;
  435.     var sy = Math.floor(iconIndex / 16) * ph;
  436.     this.contents.blt(bitmap, sx, sy, pw, ph, x, y);
  437. };

  439. Window_Base.prototype.drawFace = function(faceName, faceIndex, x, y, width, height) {
  440.     width = width || Window_Base._faceWidth;
  441.     height = height || Window_Base._faceHeight;
  442.     var bitmap = ImageManager.loadFace(faceName);
  443.     var pw = Window_Base._faceWidth;
  444.     var ph = Window_Base._faceHeight;
  445.     var sw = Math.min(width, pw);
  446.     var sh = Math.min(height, ph);
  447.     var dx = Math.floor(x + Math.max(width - pw, 0) / 2);
  448.     var dy = Math.floor(y + Math.max(height - ph, 0) / 2);
  449.     var sx = faceIndex % 4 * pw + (pw - sw) / 2;
  450.     var sy = Math.floor(faceIndex / 4) * ph + (ph - sh) / 2;
  451.     this.contents.blt(bitmap, sx, sy, sw, sh, dx, dy);
  452. };

  454. Window_Base.prototype.drawCharacter = function(characterName, characterIndex, x, y) {
  455.     var bitmap = ImageManager.loadCharacter(characterName);
  456.     var big = ImageManager.isBigCharacter(characterName);
  457.     var pw = bitmap.width / (big ? 3 : 12);
  458.     var ph = bitmap.height / (big ? 4 : 8);
  459.     var n = characterIndex;
  460.     var sx = (n % 4 * 3 + 1) * pw;
  461.     var sy = (Math.floor(n / 4) * 4) * ph;
  462.     this.contents.blt(bitmap, sx, sy, pw, ph, x - pw / 2, y - ph);
  463. };

  465. Window_Base.prototype.drawGauge = function(x, y, width, rate, color1, color2) {
  466.     var fillW = Math.floor(width * rate);
  467.     var gaugeY = y + this.lineHeight() - 8;
  468.     this.contents.fillRect(x, gaugeY, width, 6, this.gaugeBackColor());
  469.     this.contents.gradientFillRect(x, gaugeY, fillW, 6, color1, color2);
  470. };

  472. Window_Base.prototype.hpColor = function(actor) {
  473.     if (actor.isDead()) {
  474.         return this.deathColor();
  475.     } else if (actor.isDying()) {
  476.         return this.crisisColor();
  477.     } else {
  478.         return this.normalColor();
  479.     }
  480. };

  482. Window_Base.prototype.mpColor = function(actor) {
  483.     return this.normalColor();
  484. };

  486. Window_Base.prototype.tpColor = function(actor) {
  487.     return this.normalColor();
  488. };

  490. Window_Base.prototype.drawActorCharacter = function(actor, x, y) {
  491.     this.drawCharacter(actor.characterName(), actor.characterIndex(), x, y);
  492. };

  494. Window_Base.prototype.drawActorFace = function(actor, x, y, width, height) {
  495.     this.drawFace(actor.faceName(), actor.faceIndex(), x, y, width, height);
  496. };

  498. Window_Base.prototype.drawActorName = function(actor, x, y, width) {
  499.     width = width || 168;
  500.     this.changeTextColor(this.hpColor(actor));
  501.     this.drawText(actor.name(), x, y, width);
  502. };

  504. Window_Base.prototype.drawActorClass = function(actor, x, y, width) {
  505.     width = width || 168;
  506.     this.resetTextColor();
  507.     this.drawText(actor.currentClass().name, x, y, width);
  508. };

  510. Window_Base.prototype.drawActorNickname = function(actor, x, y, width) {
  511.     width = width || 270;
  512.     this.resetTextColor();
  513.     this.drawText(actor.nickname(), x, y, width);
  514. };

  516. Window_Base.prototype.drawActorLevel = function(actor, x, y) {
  517.     this.changeTextColor(this.systemColor());
  518.     this.drawText(TextManager.levelA, x, y, 48);
  519.     this.resetTextColor();
  520.     this.drawText(actor.level, x + 84, y, 36, 'right');
  521. };

  523. Window_Base.prototype.drawActorIcons = function(actor, x, y, width) {
  524.     width = width || 144;
  525.     var icons = actor.allIcons().slice(0, Math.floor(width / Window_Base._iconWidth));
  526.     for (var i = 0; i < icons.length; i++) {
  527.         this.drawIcon(icons[i], x + Window_Base._iconWidth * i, y + 2);
  528.     }
  529. };

  531. Window_Base.prototype.drawCurrentAndMax = function(current, max, x, y,
  532.                                                    width, color1, color2) {
  533.     var labelWidth = this.textWidth('HP');
  534.     var valueWidth = this.textWidth('0000');
  535.     var slashWidth = this.textWidth('/');
  536.     var x1 = x + width - valueWidth;
  537.     var x2 = x1 - slashWidth;
  538.     var x3 = x2 - valueWidth;
  539.     if (x3 >= x + labelWidth) {
  540.         this.changeTextColor(color1);
  541.         this.drawText(current, x3, y, valueWidth, 'right');
  542.         this.changeTextColor(color2);
  543.         this.drawText('/', x2, y, slashWidth, 'right');
  544.         this.drawText(max, x1, y, valueWidth, 'right');
  545.     } else {
  546.         this.changeTextColor(color1);
  547.         this.drawText(current, x1, y, valueWidth, 'right');
  548.     }
  549. };

  551. Window_Base.prototype.drawActorHp = function(actor, x, y, width) {
  552.     width = width || 186;
  553.    
  554.     var color1 = this.hpGaugeColor1();
  555.     var color2 = this.hpGaugeColor2();
  556.     this.drawGauge(x, y, width, actor.hpRate(), color1, color2);
  557.     this.changeTextColor(this.systemColor());
  558.     this.drawText(TextManager.hpA, x, y, 44);
  559.     this.drawCurrentAndMax(actor.hp, actor.mhp, x, y, width,
  560.                            this.hpColor(actor), this.normalColor());
  561. };

  563. Window_Base.prototype.drawActorMp = function(actor, x, y, width) {
  564.     width = width || 186;
  565.     var color1 = this.mpGaugeColor1();
  566.     var color2 = this.mpGaugeColor2();
  567.     this.drawGauge(x, y, width, actor.mpRate(), color1, color2);
  568.     this.changeTextColor(this.systemColor());
  569.     this.drawText(TextManager.mpA, x, y, 44);
  570.     this.drawCurrentAndMax(actor.mp, actor.mmp, x, y, width,
  571.                            this.mpColor(actor), this.normalColor());
  572. };

  574. Window_Base.prototype.drawActorTp = function(actor, x, y, width) {
  575.     width = width || 96;
  576.     var color1 = this.tpGaugeColor1();
  577.     var color2 = this.tpGaugeColor2();
  578.     this.drawGauge(x, y, width, actor.tpRate(), color1, color2);
  579.     this.changeTextColor(this.systemColor());
  580.     this.drawText(TextManager.tpA, x, y, 44);
  581.     this.changeTextColor(this.tpColor(actor));
  582.     this.drawText(actor.tp, x + width - 64, y, 64, 'right');
  583. };

  585. Window_Base.prototype.drawActorSimpleStatus = function(actor, x, y, width) {
  586.     var lineHeight = this.lineHeight();
  587.     var x2 = x + 180;
  588.     var width2 = Math.min(200, width - 180 - this.textPadding());
  589.     this.drawActorName(actor, x, y);
  590.     this.drawActorLevel(actor, x, y + lineHeight * 1);
  591.     this.drawActorIcons(actor, x, y + lineHeight * 2);
  592.     this.drawActorClass(actor, x2, y);
  593.     this.drawActorHp(actor, x2, y + lineHeight * 1, width2);
  594.     this.drawActorMp(actor, x2, y + lineHeight * 2, width2);
  595. };

  597. Window_Base.prototype.drawItemName = function(item, x, y, width) {
  598.     width = width || 312;
  599.     if (item) {
  600.         var iconBoxWidth = Window_Base._iconWidth + 4;
  601.         this.resetTextColor();
  602.         this.drawIcon(item.iconIndex, x + 2, y + 2);
  603.         this.drawText(item.name, x + iconBoxWidth, y, width - iconBoxWidth);
  604.     }
  605. };

  607. Window_Base.prototype.drawCurrencyValue = function(value, unit, x, y, width) {
  608.     var unitWidth = Math.min(80, this.textWidth(unit));
  609.     this.resetTextColor();
  610.     this.drawText(value, x, y, width - unitWidth - 6, 'right');
  611.     this.changeTextColor(this.systemColor());
  612.     this.drawText(unit, x + width - unitWidth, y, unitWidth, 'right');
  613. };

  615. Window_Base.prototype.paramchangeTextColor = function(change) {
  616.     if (change > 0) {
  617.         return this.powerUpColor();
  618.     } else if (change < 0) {
  619.         return this.powerDownColor();
  620.     } else {
  621.         return this.normalColor();
  622.     }
  623. };

  625. Window_Base.prototype.setBackgroundType = function(type) {
  626.     if (type === 0) {
  627.         this.opacity = 255;
  628.     } else {
  629.         this.opacity = 0;
  630.     }
  631.     if (type === 1) {
  632.         this.showBackgroundDimmer();
  633.     } else {
  634.         this.hideBackgroundDimmer();
  635.     }
  636. };

  638. Window_Base.prototype.showBackgroundDimmer = function() {
  639.     if (!this._dimmerSprite) {
  640.         this._dimmerSprite = new Sprite();
  641.         this._dimmerSprite.bitmap = new Bitmap(0, 0);
  642.         this.addChildToBack(this._dimmerSprite);
  643.     }
  644.     var bitmap = this._dimmerSprite.bitmap;
  645.     if (bitmap.width !== this.width || bitmap.height !== this.height) {
  646.         this.refreshDimmerBitmap();
  647.     }
  648.     this._dimmerSprite.visible = true;
  649.     this.updateBackgroundDimmer();
  650. };

  652. Window_Base.prototype.hideBackgroundDimmer = function() {
  653.     if (this._dimmerSprite) {
  654.         this._dimmerSprite.visible = false;
  655.     }
  656. };

  658. Window_Base.prototype.updateBackgroundDimmer = function() {
  659.     if (this._dimmerSprite) {
  660.         this._dimmerSprite.opacity = this.openness;
  661.     }
  662. };

  664. Window_Base.prototype.refreshDimmerBitmap = function() {
  665.     if (this._dimmerSprite) {
  666.         var bitmap = this._dimmerSprite.bitmap;
  667.         var w = this.width;
  668.         var h = this.height;
  669.         var m = this.padding;
  670.         var c1 = this.dimColor1();
  671.         var c2 = this.dimColor2();
  672.         bitmap.resize(w, h);
  673.         bitmap.gradientFillRect(0, 0, w, m, c2, c1, true);
  674.         bitmap.fillRect(0, m, w, h - m * 2, c1);
  675.         bitmap.gradientFillRect(0, h - m, w, m, c1, c2, true);
  676.         this._dimmerSprite.setFrame(0, 0, w, h);
  677.     }
  678. };

  680. Window_Base.prototype.dimColor1 = function() {
  681.     return 'rgba(0, 0, 0, 0.6)';
  682. };

  684. Window_Base.prototype.dimColor2 = function() {
  685.     return 'rgba(0, 0, 0, 0)';
  686. };

  688. Window_Base.prototype.canvasToLocalX = function(x) {
  689.     var node = this;
  690.     while (node) {
  691.         x -= node.x;
  692.         node = node.parent;
  693.     }
  694.     return x;
  695. };

  697. Window_Base.prototype.canvasToLocalY = function(y) {
  698.     var node = this;
  699.     while (node) {
  700.         y -= node.y;
  701.         node = node.parent;
  702.     }
  703.     return y;
  704. };

  706. Window_Base.prototype.reserveFaceImages = function() {
  707.     $gameParty.members().forEach(function(actor) {
  708.         ImageManager.reserveFace(actor.faceName());
  709.     }, this);
  710. };

  712. //-----------------------------------------------------------------------------
  713. // Window_Selectable
  714. //
  715. // The window class with cursor movement and scroll functions.

  717. function Window_Selectable() {
  718.     this.initialize.apply(this, arguments);
  719. }

  721. Window_Selectable.prototype = Object.create(Window_Base.prototype);
  722. Window_Selectable.prototype.constructor = Window_Selectable;

  724. Window_Selectable.prototype.initialize = function(x, y, width, height) {
  725.     Window_Base.prototype.initialize.call(this, x, y, width, height);
  726.     this._index = -1;
  727.     this._cursorFixed = false;
  728.     this._cursorAll = false;
  729.     this._stayCount = 0;
  730.     this._helpWindow = null;
  731.     this._handlers = {};
  732.     this._touching = false;
  733.     this._scrollX = 0;
  734.     this._scrollY = 0;
  735.     this.deactivate();
  736. };

  738. Window_Selectable.prototype.index = function() {
  739.     return this._index;
  740. };

  742. Window_Selectable.prototype.cursorFixed = function() {
  743.     return this._cursorFixed;
  744. };

  746. Window_Selectable.prototype.setCursorFixed = function(cursorFixed) {
  747.     this._cursorFixed = cursorFixed;
  748. };

  750. Window_Selectable.prototype.cursorAll = function() {
  751.     return this._cursorAll;
  752. };

  754. Window_Selectable.prototype.setCursorAll = function(cursorAll) {
  755.     this._cursorAll = cursorAll;
  756. };

  758. Window_Selectable.prototype.maxCols = function() {
  759.     return 1;
  760. };

  762. Window_Selectable.prototype.maxItems = function() {
  763.     return 0;
  764. };

  766. Window_Selectable.prototype.spacing = function() {
  767.     return 12;
  768. };

  770. Window_Selectable.prototype.itemWidth = function() {
  771.     return Math.floor((this.width - this.padding * 2 +
  772.                        this.spacing()) / this.maxCols() - this.spacing());
  773. };

  775. Window_Selectable.prototype.itemHeight = function() {
  776.     return this.lineHeight();
  777. };

  779. Window_Selectable.prototype.maxRows = function() {
  780.     return Math.max(Math.ceil(this.maxItems() / this.maxCols()), 1);
  781. };

  783. Window_Selectable.prototype.activate = function() {
  784.     Window_Base.prototype.activate.call(this);
  785.     this.reselect();
  786. };

  788. Window_Selectable.prototype.deactivate = function() {
  789.     Window_Base.prototype.deactivate.call(this);
  790.     this.reselect();
  791. };

  793. Window_Selectable.prototype.select = function(index) {
  794.     this._index = index;
  795.     this._stayCount = 0;
  796.     this.ensureCursorVisible();
  797.     this.updateCursor();
  798.     this.callUpdateHelp();
  799. };

  801. Window_Selectable.prototype.deselect = function() {
  802.     this.select(-1);
  803. };

  805. Window_Selectable.prototype.reselect = function() {
  806.     this.select(this._index);
  807. };

  809. Window_Selectable.prototype.row = function() {
  810.     return Math.floor(this.index() / this.maxCols());
  811. };

  813. Window_Selectable.prototype.topRow = function() {
  814.     return Math.floor(this._scrollY / this.itemHeight());
  815. };

  817. Window_Selectable.prototype.maxTopRow = function() {
  818.     return Math.max(0, this.maxRows() - this.maxPageRows());
  819. };

  821. Window_Selectable.prototype.setTopRow = function(row) {
  822.     var scrollY = row.clamp(0, this.maxTopRow()) * this.itemHeight();
  823.     if (this._scrollY !== scrollY) {
  824.         this._scrollY = scrollY;
  825.         this.refresh();
  826.         this.updateCursor();
  827.     }
  828. };

  830. Window_Selectable.prototype.resetScroll = function() {
  831.     this.setTopRow(0);
  832. };

  834. Window_Selectable.prototype.maxPageRows = function() {
  835.     var pageHeight = this.height - this.padding * 2;
  836.     return Math.floor(pageHeight / this.itemHeight());
  837. };

  839. Window_Selectable.prototype.maxPageItems = function() {
  840.     return this.maxPageRows() * this.maxCols();
  841. };

  843. Window_Selectable.prototype.isHorizontal = function() {
  844.     return this.maxPageRows() === 1;
  845. };

  847. Window_Selectable.prototype.bottomRow = function() {
  848.     return Math.max(0, this.topRow() + this.maxPageRows() - 1);
  849. };

  851. Window_Selectable.prototype.setBottomRow = function(row) {
  852.     this.setTopRow(row - (this.maxPageRows() - 1));
  853. };

  855. Window_Selectable.prototype.topIndex = function() {
  856.     return this.topRow() * this.maxCols();
  857. };

  859. Window_Selectable.prototype.itemRect = function(index) {
  860.     var rect = new Rectangle();
  861.     var maxCols = this.maxCols();
  862.     rect.width = this.itemWidth();
  863.     rect.height = this.itemHeight();
  864.     rect.x = index % maxCols * (rect.width + this.spacing()) - this._scrollX;
  865.     rect.y = Math.floor(index / maxCols) * rect.height - this._scrollY;
  866.     return rect;
  867. };

  869. Window_Selectable.prototype.itemRectForText = function(index) {
  870.     var rect = this.itemRect(index);
  871.     rect.x += this.textPadding();
  872.     rect.width -= this.textPadding() * 2;
  873.     return rect;
  874. };

  876. Window_Selectable.prototype.setHelpWindow = function(helpWindow) {
  877.     this._helpWindow = helpWindow;
  878.     this.callUpdateHelp();
  879. };

  881. Window_Selectable.prototype.showHelpWindow = function() {
  882.     if (this._helpWindow) {
  883.         this._helpWindow.show();
  884.     }
  885. };

  887. Window_Selectable.prototype.hideHelpWindow = function() {
  888.     if (this._helpWindow) {
  889.         this._helpWindow.hide();
  890.     }
  891. };

  893. Window_Selectable.prototype.setHandler = function(symbol, method) {
  894.     this._handlers[symbol] = method;
  895. };

  897. Window_Selectable.prototype.isHandled = function(symbol) {
  898.     return !!this._handlers[symbol];
  899. };

  901. Window_Selectable.prototype.callHandler = function(symbol) {
  902.     if (this.isHandled(symbol)) {
  903.         this._handlers[symbol]();
  904.     }
  905. };

  907. Window_Selectable.prototype.isOpenAndActive = function() {
  908.     return this.isOpen() && this.active;
  909. };

  911. Window_Selectable.prototype.isCursorMovable = function() {
  912.     return (this.isOpenAndActive() && !this._cursorFixed &&
  913.             !this._cursorAll && this.maxItems() > 0);
  914. };

  916. Window_Selectable.prototype.cursorDown = function(wrap) {
  917.     var index = this.index();
  918.     var maxItems = this.maxItems();
  919.     var maxCols = this.maxCols();
  920.     if (index < maxItems - maxCols || (wrap && maxCols === 1)) {
  921.         this.select((index + maxCols) % maxItems);
  922.     }
  923. };

  925. Window_Selectable.prototype.cursorUp = function(wrap) {
  926.     var index = this.index();
  927.     var maxItems = this.maxItems();
  928.     var maxCols = this.maxCols();
  929.     if (index >= maxCols || (wrap && maxCols === 1)) {
  930.         this.select((index - maxCols + maxItems) % maxItems);
  931.     }
  932. };

  934. Window_Selectable.prototype.cursorRight = function(wrap) {
  935.     var index = this.index();
  936.     var maxItems = this.maxItems();
  937.     var maxCols = this.maxCols();
  938.     if (maxCols >= 2 && (index < maxItems - 1 || (wrap && this.isHorizontal()))) {
  939.         this.select((index + 1) % maxItems);
  940.     }
  941. };

  943. Window_Selectable.prototype.cursorLeft = function(wrap) {
  944.     var index = this.index();
  945.     var maxItems = this.maxItems();
  946.     var maxCols = this.maxCols();
  947.     if (maxCols >= 2 && (index > 0 || (wrap && this.isHorizontal()))) {
  948.         this.select((index - 1 + maxItems) % maxItems);
  949.     }
  950. };

  952. Window_Selectable.prototype.cursorPagedown = function() {
  953.     var index = this.index();
  954.     var maxItems = this.maxItems();
  955.     if (this.topRow() + this.maxPageRows() < this.maxRows()) {
  956.         this.setTopRow(this.topRow() + this.maxPageRows());
  957.         this.select(Math.min(index + this.maxPageItems(), maxItems - 1));
  958.     }
  959. };

  961. Window_Selectable.prototype.cursorPageup = function() {
  962.     var index = this.index();
  963.     if (this.topRow() > 0) {
  964.         this.setTopRow(this.topRow() - this.maxPageRows());
  965.         this.select(Math.max(index - this.maxPageItems(), 0));
  966.     }
  967. };

  969. Window_Selectable.prototype.scrollDown = function() {
  970.     if (this.topRow() + 1 < this.maxRows()) {
  971.         this.setTopRow(this.topRow() + 1);
  972.     }
  973. };

  975. Window_Selectable.prototype.scrollUp = function() {
  976.     if (this.topRow() > 0) {
  977.         this.setTopRow(this.topRow() - 1);
  978.     }
  979. };

  981. Window_Selectable.prototype.update = function() {
  982.     Window_Base.prototype.update.call(this);
  983.     this.updateArrows();
  984.     this.processCursorMove();
  985.     this.processHandling();
  986.     this.processWheel();
  987.     this.processTouch();
  988.     this._stayCount++;
  989. };

  991. Window_Selectable.prototype.updateArrows = function() {
  992.     var topRow = this.topRow();
  993.     var maxTopRow = this.maxTopRow();
  994.     this.downArrowVisible = maxTopRow > 0 && topRow < maxTopRow;
  995.     this.upArrowVisible = topRow > 0;
  996. };

  998. Window_Selectable.prototype.processCursorMove = function() {
  999.     if (this.isCursorMovable()) {
  1000.         var lastIndex = this.index();
  1001.         if (Input.isRepeated('down')) {
  1002.             this.cursorDown(Input.isTriggered('down'));
  1003.         }
  1004.         if (Input.isRepeated('up')) {
  1005.             this.cursorUp(Input.isTriggered('up'));
  1006.         }
  1007.         if (Input.isRepeated('right')) {
  1008.             this.cursorRight(Input.isTriggered('right'));
  1009.         }
  1010.         if (Input.isRepeated('left')) {
  1011.             this.cursorLeft(Input.isTriggered('left'));
  1012.         }
  1013.         if (!this.isHandled('pagedown') && Input.isTriggered('pagedown')) {
  1014.             this.cursorPagedown();
  1015.         }
  1016.         if (!this.isHandled('pageup') && Input.isTriggered('pageup')) {
  1017.             this.cursorPageup();
  1018.         }
  1019.         if (this.index() !== lastIndex) {
  1020.             SoundManager.playCursor();
  1021.         }
  1022.     }
  1023. };

  1025. Window_Selectable.prototype.processHandling = function() {
  1026.     if (this.isOpenAndActive()) {
  1027.         if (this.isOkEnabled() && this.isOkTriggered()) {
  1028.             this.processOk();
  1029.         } else if (this.isCancelEnabled() && this.isCancelTriggered()) {
  1030.             this.processCancel();
  1031.         } else if (this.isHandled('pagedown') && Input.isTriggered('pagedown')) {
  1032.             this.processPagedown();
  1033.         } else if (this.isHandled('pageup') && Input.isTriggered('pageup')) {
  1034.             this.processPageup();
  1035.         }
  1036.     }
  1037. };

  1039. Window_Selectable.prototype.processWheel = function() {
  1040.     if (this.isOpenAndActive()) {
  1041.         var threshold = 20;
  1042.         if (TouchInput.wheelY >= threshold) {
  1043.             this.scrollDown();
  1044.         }
  1045.         if (TouchInput.wheelY <= -threshold) {
  1046.             this.scrollUp();
  1047.         }
  1048.     }
  1049. };

  1051. Window_Selectable.prototype.processTouch = function() {
  1052.     if (this.isOpenAndActive()) {
  1053.         if (TouchInput.isTriggered() && this.isTouchedInsideFrame()) {
  1054.             this._touching = true;
  1055.             this.onTouch(true);
  1056.         } else if (TouchInput.isCancelled()) {
  1057.             if (this.isCancelEnabled()) {
  1058.                 this.processCancel();
  1059.             }
  1060.         }
  1061.         if (this._touching) {
  1062.             if (TouchInput.isPressed()) {
  1063.                 this.onTouch(false);
  1064.             } else {
  1065.                 this._touching = false;
  1066.             }
  1067.         }
  1068.     } else {
  1069.         this._touching = false;
  1070.     }
  1071. };

  1073. Window_Selectable.prototype.isTouchedInsideFrame = function() {
  1074.     var x = this.canvasToLocalX(TouchInput.x);
  1075.     var y = this.canvasToLocalY(TouchInput.y);
  1076.     return x >= 0 && y >= 0 && x < this.width && y < this.height;
  1077. };

  1079. Window_Selectable.prototype.onTouch = function(triggered) {
  1080.     var lastIndex = this.index();
  1081.     var x = this.canvasToLocalX(TouchInput.x);
  1082.     var y = this.canvasToLocalY(TouchInput.y);
  1083.     var hitIndex = this.hitTest(x, y);
  1084.     if (hitIndex >= 0) {
  1085.         if (hitIndex === this.index()) {
  1086.             if (triggered && this.isTouchOkEnabled()) {
  1087.                 this.processOk();
  1088.             }
  1089.         } else if (this.isCursorMovable()) {
  1090.             this.select(hitIndex);
  1091.         }
  1092.     } else if (this._stayCount >= 10) {
  1093.         if (y < this.padding) {
  1094.             this.cursorUp();
  1095.         } else if (y >= this.height - this.padding) {
  1096.             this.cursorDown();
  1097.         }
  1098.     }
  1099.     if (this.index() !== lastIndex) {
  1100.         SoundManager.playCursor();
  1101.     }
  1102. };

  1104. Window_Selectable.prototype.hitTest = function(x, y) {
  1105.     if (this.isContentsArea(x, y)) {
  1106.         var cx = x - this.padding;
  1107.         var cy = y - this.padding;
  1108.         var topIndex = this.topIndex();
  1109.         for (var i = 0; i < this.maxPageItems(); i++) {
  1110.             var index = topIndex + i;
  1111.             if (index < this.maxItems()) {
  1112.                 var rect = this.itemRect(index);
  1113.                 var right = rect.x + rect.width;
  1114.                 var bottom = rect.y + rect.height;
  1115.                 if (cx >= rect.x && cy >= rect.y && cx < right && cy < bottom) {
  1116.                     return index;
  1117.                 }
  1118.             }
  1119.         }
  1120.     }
  1121.     return -1;
  1122. };

  1124. Window_Selectable.prototype.isContentsArea = function(x, y) {
  1125.     var left = this.padding;
  1126.     var top = this.padding;
  1127.     var right = this.width - this.padding;
  1128.     var bottom = this.height - this.padding;
  1129.     return (x >= left && y >= top && x < right && y < bottom);
  1130. };

  1132. Window_Selectable.prototype.isTouchOkEnabled = function() {
  1133.     return this.isOkEnabled();
  1134. };

  1136. Window_Selectable.prototype.isOkEnabled = function() {
  1137.     return this.isHandled('ok');
  1138. };

  1140. Window_Selectable.prototype.isCancelEnabled = function() {
  1141.     return this.isHandled('cancel');
  1142. };

  1144. Window_Selectable.prototype.isOkTriggered = function() {
  1145.     return Input.isRepeated('ok');
  1146. };

  1148. Window_Selectable.prototype.isCancelTriggered = function() {
  1149.     return Input.isRepeated('cancel');
  1150. };

  1152. Window_Selectable.prototype.processOk = function() {
  1153.     if (this.isCurrentItemEnabled()) {
  1154.         this.playOkSound();
  1155.         this.updateInputData();
  1156.         this.deactivate();
  1157.         this.callOkHandler();
  1158.     } else {
  1159.         this.playBuzzerSound();
  1160.     }
  1161. };

  1163. Window_Selectable.prototype.playOkSound = function() {
  1164.     SoundManager.playOk();
  1165. };

  1167. Window_Selectable.prototype.playBuzzerSound = function() {
  1168.     SoundManager.playBuzzer();
  1169. };

  1171. Window_Selectable.prototype.callOkHandler = function() {
  1172.     this.callHandler('ok');
  1173. };

  1175. Window_Selectable.prototype.processCancel = function() {
  1176.     SoundManager.playCancel();
  1177.     this.updateInputData();
  1178.     this.deactivate();
  1179.     this.callCancelHandler();
  1180. };

  1182. Window_Selectable.prototype.callCancelHandler = function() {
  1183.     this.callHandler('cancel');
  1184. };

  1186. Window_Selectable.prototype.processPageup = function() {
  1187.     SoundManager.playCursor();
  1188.     this.updateInputData();
  1189.     this.deactivate();
  1190.     this.callHandler('pageup');
  1191. };

  1193. Window_Selectable.prototype.processPagedown = function() {
  1194.     SoundManager.playCursor();
  1195.     this.updateInputData();
  1196.     this.deactivate();
  1197.     this.callHandler('pagedown');
  1198. };

  1200. Window_Selectable.prototype.updateInputData = function() {
  1201.     Input.update();
  1202.     TouchInput.update();
  1203. };

  1205. Window_Selectable.prototype.updateCursor = function() {
  1206.     if (this._cursorAll) {
  1207.         var allRowsHeight = this.maxRows() * this.itemHeight();
  1208.         this.setCursorRect(0, 0, this.contents.width, allRowsHeight);
  1209.         this.setTopRow(0);
  1210.     } else if (this.isCursorVisible()) {
  1211.         var rect = this.itemRect(this.index());
  1212.         this.setCursorRect(rect.x, rect.y, rect.width, rect.height);
  1213.     } else {
  1214.         this.setCursorRect(0, 0, 0, 0);
  1215.     }
  1216. };

  1218. Window_Selectable.prototype.isCursorVisible = function() {
  1219.     var row = this.row();
  1220.     return row >= this.topRow() && row <= this.bottomRow();
  1221. };

  1223. Window_Selectable.prototype.ensureCursorVisible = function() {
  1224.     var row = this.row();
  1225.     if (row < this.topRow()) {
  1226.         this.setTopRow(row);
  1227.     } else if (row > this.bottomRow()) {
  1228.         this.setBottomRow(row);
  1229.     }
  1230. };

  1232. Window_Selectable.prototype.callUpdateHelp = function() {
  1233.     if (this.active && this._helpWindow) {
  1234.         this.updateHelp();
  1235.     }
  1236. };

  1238. Window_Selectable.prototype.updateHelp = function() {
  1239.     this._helpWindow.clear();
  1240. };

  1242. Window_Selectable.prototype.setHelpWindowItem = function(item) {
  1243.     if (this._helpWindow) {
  1244.         this._helpWindow.setItem(item);
  1245.     }
  1246. };

  1248. Window_Selectable.prototype.isCurrentItemEnabled = function() {
  1249.     return true;
  1250. };

  1252. Window_Selectable.prototype.drawAllItems = function() {
  1253.     var topIndex = this.topIndex();
  1254.     for (var i = 0; i < this.maxPageItems(); i++) {
  1255.         var index = topIndex + i;
  1256.         if (index < this.maxItems()) {
  1257.             this.drawItem(index);
  1258.         }
  1259.     }
  1260. };

  1262. Window_Selectable.prototype.drawItem = function(index) {
  1263. };

  1265. Window_Selectable.prototype.clearItem = function(index) {
  1266.     var rect = this.itemRect(index);
  1267.     this.contents.clearRect(rect.x, rect.y, rect.width, rect.height);
  1268. };

  1270. Window_Selectable.prototype.redrawItem = function(index) {
  1271.     if (index >= 0) {
  1272.         this.clearItem(index);
  1273.         this.drawItem(index);
  1274.     }
  1275. };

  1277. Window_Selectable.prototype.redrawCurrentItem = function() {
  1278.     this.redrawItem(this.index());
  1279. };

  1281. Window_Selectable.prototype.refresh = function() {
  1282.     if (this.contents) {
  1283.         this.contents.clear();
  1284.         this.drawAllItems();
  1285.     }
  1286. };

  1288. //-----------------------------------------------------------------------------
  1289. // Window_Command
  1290. //
  1291. // The superclass of windows for selecting a command.

  1293. function Window_Command() {
  1294.     this.initialize.apply(this, arguments);
  1295. }

  1297. Window_Command.prototype = Object.create(Window_Selectable.prototype);
  1298. Window_Command.prototype.constructor = Window_Command;

  1300. Window_Command.prototype.initialize = function(x, y) {
  1301.     this.clearCommandList();
  1302.     this.makeCommandList();
  1303.     var width = this.windowWidth();
  1304.     var height = this.windowHeight();
  1305.     Window_Selectable.prototype.initialize.call(this, x, y, width, height);
  1306.     this.refresh();
  1307.     this.select(0);
  1308.     this.activate();
  1309. };

  1311. Window_Command.prototype.windowWidth = function() {
  1312.     return 240;
  1313. };

  1315. Window_Command.prototype.windowHeight = function() {
  1316.     return this.fittingHeight(this.numVisibleRows());
  1317. };

  1319. Window_Command.prototype.numVisibleRows = function() {
  1320.     return Math.ceil(this.maxItems() / this.maxCols());
  1321. };

  1323. Window_Command.prototype.maxItems = function() {
  1324.     return this._list.length;
  1325. };

  1327. Window_Command.prototype.clearCommandList = function() {
  1328.     this._list = [];
  1329. };

  1331. Window_Command.prototype.makeCommandList = function() {
  1332. };

  1334. Window_Command.prototype.addCommand = function(name, symbol, enabled, ext) {
  1335.     if (enabled === undefined) {
  1336.         enabled = true;
  1337.     }
  1338.     if (ext === undefined) {
  1339.         ext = null;
  1340.     }
  1341.     this._list.push({ name: name, symbol: symbol, enabled: enabled, ext: ext});
  1342. };

  1344. Window_Command.prototype.commandName = function(index) {
  1345.     return this._list[index].name;
  1346. };

  1348. Window_Command.prototype.commandSymbol = function(index) {
  1349.     return this._list[index].symbol;
  1350. };

  1352. Window_Command.prototype.isCommandEnabled = function(index) {
  1353.     return this._list[index].enabled;
  1354. };

  1356. Window_Command.prototype.currentData = function() {
  1357.     return this.index() >= 0 ? this._list[this.index()] : null;
  1358. };

  1360. Window_Command.prototype.isCurrentItemEnabled = function() {
  1361.     return this.currentData() ? this.currentData().enabled : false;
  1362. };

  1364. Window_Command.prototype.currentSymbol = function() {
  1365.     return this.currentData() ? this.currentData().symbol : null;
  1366. };

  1368. Window_Command.prototype.currentExt = function() {
  1369.     return this.currentData() ? this.currentData().ext : null;
  1370. };

  1372. Window_Command.prototype.findSymbol = function(symbol) {
  1373.     for (var i = 0; i < this._list.length; i++) {
  1374.         if (this._list[i].symbol === symbol) {
  1375.             return i;
  1376.         }
  1377.     }
  1378.     return -1;
  1379. };

  1381. Window_Command.prototype.selectSymbol = function(symbol) {
  1382.     var index = this.findSymbol(symbol);
  1383.     if (index >= 0) {
  1384.         this.select(index);
  1385.     } else {
  1386.         this.select(0);
  1387.     }
  1388. };

  1390. Window_Command.prototype.findExt = function(ext) {
  1391.     for (var i = 0; i < this._list.length; i++) {
  1392.         if (this._list[i].ext === ext) {
  1393.             return i;
  1394.         }
  1395.     }
  1396.     return -1;
  1397. };

  1399. Window_Command.prototype.selectExt = function(ext) {
  1400.     var index = this.findExt(ext);
  1401.     if (index >= 0) {
  1402.         this.select(index);
  1403.     } else {
  1404.         this.select(0);
  1405.     }
  1406. };

  1408. Window_Command.prototype.drawItem = function(index) {
  1409.     var rect = this.itemRectForText(index);
  1410.     var align = this.itemTextAlign();
  1411.     this.resetTextColor();
  1412.     this.changePaintOpacity(this.isCommandEnabled(index));
  1413.     this.drawText(this.commandName(index), rect.x, rect.y, rect.width, align);
  1414. };

  1416. Window_Command.prototype.itemTextAlign = function() {
  1417.     return 'left';
  1418. };

  1420. Window_Command.prototype.isOkEnabled = function() {
  1421.     return true;
  1422. };

  1424. Window_Command.prototype.callOkHandler = function() {
  1425.     var symbol = this.currentSymbol();
  1426.     if (this.isHandled(symbol)) {
  1427.         this.callHandler(symbol);
  1428.     } else if (this.isHandled('ok')) {
  1429.         Window_Selectable.prototype.callOkHandler.call(this);
  1430.     } else {
  1431.         this.activate();
  1432.     }
  1433. };

  1435. Window_Command.prototype.refresh = function() {
  1436.     this.clearCommandList();
  1437.     this.makeCommandList();
  1438.     this.createContents();
  1439.     Window_Selectable.prototype.refresh.call(this);
  1440. };

  1442. //-----------------------------------------------------------------------------
  1443. // Window_HorzCommand
  1444. //
  1445. // The command window for the horizontal selection format.

  1447. function Window_HorzCommand() {
  1448.     this.initialize.apply(this, arguments);
  1449. }

  1451. Window_HorzCommand.prototype = Object.create(Window_Command.prototype);
  1452. Window_HorzCommand.prototype.constructor = Window_HorzCommand;

  1454. Window_HorzCommand.prototype.initialize = function(x, y) {
  1455.     Window_Command.prototype.initialize.call(this, x, y);
  1456. };

  1458. Window_HorzCommand.prototype.numVisibleRows = function() {
  1459.     return 1;
  1460. };

  1462. Window_HorzCommand.prototype.maxCols = function() {
  1463.     return 4;
  1464. };

  1466. Window_HorzCommand.prototype.itemTextAlign = function() {
  1467.     return 'center';
  1468. };

  1470. //-----------------------------------------------------------------------------
  1471. // Window_Help
  1472. //
  1473. // The window for displaying the description of the selected item.

  1475. function Window_Help() {
  1476.     this.initialize.apply(this, arguments);
  1477. }

  1479. Window_Help.prototype = Object.create(Window_Base.prototype);
  1480. Window_Help.prototype.constructor = Window_Help;

  1482. Window_Help.prototype.initialize = function(numLines) {
  1483.     var width = Graphics.boxWidth;
  1484.     var height = this.fittingHeight(numLines || 2);
  1485.     Window_Base.prototype.initialize.call(this, 0, 0, width, height);
  1486.     this._text = '';
  1487. };

  1489. Window_Help.prototype.setText = function(text) {
  1490.     if (this._text !== text) {
  1491.         this._text = text;
  1492.         this.refresh();
  1493.     }
  1494. };

  1496. Window_Help.prototype.clear = function() {
  1497.     this.setText('');
  1498. };

  1500. Window_Help.prototype.setItem = function(item) {
  1501.     this.setText(item ? item.description : '');
  1502. };

  1504. Window_Help.prototype.refresh = function() {
  1505.     this.contents.clear();
  1506.     this.drawTextEx(this._text, this.textPadding(), 0);
  1507. };

  1509. //-----------------------------------------------------------------------------
  1510. // Window_Gold
  1511. //
  1512. // The window for displaying the party's gold.

  1514. function Window_Gold() {
  1515.     this.initialize.apply(this, arguments);
  1516. }

  1518. Window_Gold.prototype = Object.create(Window_Base.prototype);
  1519. Window_Gold.prototype.constructor = Window_Gold;

  1521. Window_Gold.prototype.initialize = function(x, y) {
  1522.     var width = this.windowWidth();
  1523.     var height = this.windowHeight();
  1524.     Window_Base.prototype.initialize.call(this, x, y, width, height);
  1525.     this.refresh();
  1526. };

  1528. Window_Gold.prototype.windowWidth = function() {
  1529.     return 240;
  1530. };

  1532. Window_Gold.prototype.windowHeight = function() {
  1533.     return this.fittingHeight(1);
  1534. };

  1536. Window_Gold.prototype.refresh = function() {
  1537.     var x = this.textPadding();
  1538.     var width = this.contents.width - this.textPadding() * 2;
  1539.     this.contents.clear();
  1540.     this.drawCurrencyValue(this.value(), this.currencyUnit(), x, 0, width);
  1541. };

  1543. Window_Gold.prototype.value = function() {
  1544.     return $gameParty.gold();
  1545. };

  1547. Window_Gold.prototype.currencyUnit = function() {
  1548.     return TextManager.currencyUnit;
  1549. };

  1551. Window_Gold.prototype.open = function() {
  1552.     this.refresh();
  1553.     Window_Base.prototype.open.call(this);
  1554. };

  1556. //-----------------------------------------------------------------------------
  1557. // Window_MenuCommand
  1558. //
  1559. // The window for selecting a command on the menu screen.

  1561. function Window_MenuCommand() {
  1562.     this.initialize.apply(this, arguments);
  1563. }

  1565. Window_MenuCommand.prototype = Object.create(Window_Command.prototype);
  1566. Window_MenuCommand.prototype.constructor = Window_MenuCommand;

  1568. Window_MenuCommand.prototype.initialize = function(x, y) {
  1569.     Window_Command.prototype.initialize.call(this, x, y);
  1570.     this.selectLast();
  1571. };

  1573. Window_MenuCommand._lastCommandSymbol = null;

  1575. Window_MenuCommand.initCommandPosition = function() {
  1576.     this._lastCommandSymbol = null;
  1577. };

  1579. Window_MenuCommand.prototype.windowWidth = function() {
  1580.     return 240;
  1581. };

  1583. Window_MenuCommand.prototype.numVisibleRows = function() {
  1584.     return this.maxItems();
  1585. };

  1587. Window_MenuCommand.prototype.makeCommandList = function() {
  1588.     this.addMainCommands();
  1589.     this.addFormationCommand();
  1590.     this.addOriginalCommands();
  1591.     this.addOptionsCommand();
  1592.     this.addSaveCommand();
  1593.     this.addGameEndCommand();
  1594. };

  1596. Window_MenuCommand.prototype.addMainCommands = function() {
  1597.     var enabled = this.areMainCommandsEnabled();
  1598.     if (this.needsCommand('item')) {
  1599.         this.addCommand(TextManager.item, 'item', enabled);
  1600.     }
  1601.     if (this.needsCommand('skill')) {
  1602.         this.addCommand(TextManager.skill, 'skill', enabled);
  1603.     }
  1604.     if (this.needsCommand('equip')) {
  1605.         this.addCommand(TextManager.equip, 'equip', enabled);
  1606.     }
  1607.     if (this.needsCommand('status')) {
  1608.         this.addCommand(TextManager.status, 'status', enabled);
  1609.     }
  1610. };

  1612. Window_MenuCommand.prototype.addFormationCommand = function() {
  1613.     if (this.needsCommand('formation')) {
  1614.         var enabled = this.isFormationEnabled();
  1615.         this.addCommand(TextManager.formation, 'formation', enabled);
  1616.     }
  1617. };

  1619. Window_MenuCommand.prototype.addOriginalCommands = function() {
  1620. };

  1622. Window_MenuCommand.prototype.addOptionsCommand = function() {
  1623.     if (this.needsCommand('options')) {
  1624.         var enabled = this.isOptionsEnabled();
  1625.         this.addCommand(TextManager.options, 'options', enabled);
  1626.     }
  1627. };

  1629. Window_MenuCommand.prototype.addSaveCommand = function() {
  1630.     if (this.needsCommand('save')) {
  1631.         var enabled = this.isSaveEnabled();
  1632.         this.addCommand(TextManager.save, 'save', enabled);
  1633.     }
  1634. };

  1636. Window_MenuCommand.prototype.addGameEndCommand = function() {
  1637.     var enabled = this.isGameEndEnabled();
  1638.     this.addCommand(TextManager.gameEnd, 'gameEnd', enabled);
  1639. };

  1641. Window_MenuCommand.prototype.needsCommand = function(name) {
  1642.     var flags = $dataSystem.menuCommands;
  1643.     if (flags) {
  1644.         switch (name) {
  1645.         case 'item':
  1646.             return flags[0];
  1647.         case 'skill':
  1648.             return flags[1];
  1649.         case 'equip':
  1650.             return flags[2];
  1651.         case 'status':
  1652.             return flags[3];
  1653.         case 'formation':
  1654.             return flags[4];
  1655.         case 'save':
  1656.             return flags[5];
  1657.         }
  1658.     }
  1659.     return true;
  1660. };

  1662. Window_MenuCommand.prototype.areMainCommandsEnabled = function() {
  1663.     return $gameParty.exists();
  1664. };

  1666. Window_MenuCommand.prototype.isFormationEnabled = function() {
  1667.     return $gameParty.size() >= 2 && $gameSystem.isFormationEnabled();
  1668. };

  1670. Window_MenuCommand.prototype.isOptionsEnabled = function() {
  1671.     return true;
  1672. };

  1674. Window_MenuCommand.prototype.isSaveEnabled = function() {
  1675.     return !DataManager.isEventTest() && $gameSystem.isSaveEnabled();
  1676. };

  1678. Window_MenuCommand.prototype.isGameEndEnabled = function() {
  1679.     return true;
  1680. };

  1682. Window_MenuCommand.prototype.processOk = function() {
  1683.     Window_MenuCommand._lastCommandSymbol = this.currentSymbol();
  1684.     Window_Command.prototype.processOk.call(this);
  1685. };

  1687. Window_MenuCommand.prototype.selectLast = function() {
  1688.     this.selectSymbol(Window_MenuCommand._lastCommandSymbol);
  1689. };

  1691. //-----------------------------------------------------------------------------
  1692. // Window_MenuStatus
  1693. //
  1694. // The window for displaying party member status on the menu screen.

  1696. function Window_MenuStatus() {
  1697.     this.initialize.apply(this, arguments);
  1698. }

  1700. Window_MenuStatus.prototype = Object.create(Window_Selectable.prototype);
  1701. Window_MenuStatus.prototype.constructor = Window_MenuStatus;

  1703. Window_MenuStatus.prototype.initialize = function(x, y) {
  1704.     var width = this.windowWidth();
  1705.     var height = this.windowHeight();
  1706.     Window_Selectable.prototype.initialize.call(this, x, y, width, height);
  1707.     this._formationMode = false;
  1708.     this._pendingIndex = -1;
  1709.     this.refresh();
  1710. };

  1712. Window_MenuStatus.prototype.windowWidth = function() {
  1713.     return Graphics.boxWidth - 240;
  1714. };

  1716. Window_MenuStatus.prototype.windowHeight = function() {
  1717.     return Graphics.boxHeight;
  1718. };

  1720. Window_MenuStatus.prototype.maxItems = function() {
  1721.     return $gameParty.size();
  1722. };

  1724. Window_MenuStatus.prototype.itemHeight = function() {
  1725.     var clientHeight = this.height - this.padding * 2;
  1726.     return Math.floor(clientHeight / this.numVisibleRows());
  1727. };

  1729. Window_MenuStatus.prototype.numVisibleRows = function() {
  1730.     return 4;
  1731. };

  1733. Window_MenuStatus.prototype.loadImages = function() {
  1734.     $gameParty.members().forEach(function(actor) {
  1735.         ImageManager.reserveFace(actor.faceName());
  1736.     }, this);
  1737. };

  1739. Window_MenuStatus.prototype.drawItem = function(index) {
  1740.     this.drawItemBackground(index);
  1741.     this.drawItemImage(index);
  1742.     this.drawItemStatus(index);
  1743. };

  1745. Window_MenuStatus.prototype.drawItemBackground = function(index) {
  1746.     if (index === this._pendingIndex) {
  1747.         var rect = this.itemRect(index);
  1748.         var color = this.pendingColor();
  1749.         this.changePaintOpacity(false);
  1750.         this.contents.fillRect(rect.x, rect.y, rect.width, rect.height, color);
  1751.         this.changePaintOpacity(true);
  1752.     }
  1753. };

  1755. Window_MenuStatus.prototype.drawItemImage = function(index) {
  1756.     var actor = $gameParty.members()[index];
  1757.     var rect = this.itemRect(index);
  1758.     this.changePaintOpacity(actor.isBattleMember());
  1759.     this.drawActorFace(actor, rect.x + 1, rect.y + 1, Window_Base._faceWidth, Window_Base._faceHeight);
  1760.     this.changePaintOpacity(true);
  1761. };

  1763. Window_MenuStatus.prototype.drawItemStatus = function(index) {
  1764.     var actor = $gameParty.members()[index];
  1765.     var rect = this.itemRect(index);
  1766.     var x = rect.x + 162;
  1767.     var y = rect.y + rect.height / 2 - this.lineHeight() * 1.5;
  1768.     var width = rect.width - x - this.textPadding();
  1769.     this.drawActorSimpleStatus(actor, x, y, width);
  1770. };

  1772. Window_MenuStatus.prototype.processOk = function() {
  1773.     Window_Selectable.prototype.processOk.call(this);
  1774.     $gameParty.setMenuActor($gameParty.members()[this.index()]);
  1775. };

  1777. Window_MenuStatus.prototype.isCurrentItemEnabled = function() {
  1778.     if (this._formationMode) {
  1779.         var actor = $gameParty.members()[this.index()];
  1780.         return actor && actor.isFormationChangeOk();
  1781.     } else {
  1782.         return true;
  1783.     }
  1784. };

  1786. Window_MenuStatus.prototype.selectLast = function() {
  1787.     this.select($gameParty.menuActor().index() || 0);
  1788. };

  1790. Window_MenuStatus.prototype.formationMode = function() {
  1791.     return this._formationMode;
  1792. };

  1794. Window_MenuStatus.prototype.setFormationMode = function(formationMode) {
  1795.     this._formationMode = formationMode;
  1796. };

  1798. Window_MenuStatus.prototype.pendingIndex = function() {
  1799.     return this._pendingIndex;
  1800. };

  1802. Window_MenuStatus.prototype.setPendingIndex = function(index) {
  1803.     var lastPendingIndex = this._pendingIndex;
  1804.     this._pendingIndex = index;
  1805.     this.redrawItem(this._pendingIndex);
  1806.     this.redrawItem(lastPendingIndex);
  1807. };

  1809. //-----------------------------------------------------------------------------
  1810. // Window_MenuActor
  1811. //
  1812. // The window for selecting a target actor on the item and skill screens.

  1814. function Window_MenuActor() {
  1815.     this.initialize.apply(this, arguments);
  1816. }

  1818. Window_MenuActor.prototype = Object.create(Window_MenuStatus.prototype);
  1819. Window_MenuActor.prototype.constructor = Window_MenuActor;

  1821. Window_MenuActor.prototype.initialize = function() {
  1822.     Window_MenuStatus.prototype.initialize.call(this, 0, 0);
  1823.     this.hide();
  1824. };

  1826. Window_MenuActor.prototype.processOk = function() {
  1827.     if (!this.cursorAll()) {
  1828.         $gameParty.setTargetActor($gameParty.members()[this.index()]);
  1829.     }
  1830.     this.callOkHandler();
  1831. };

  1833. Window_MenuActor.prototype.selectLast = function() {
  1834.     this.select($gameParty.targetActor().index() || 0);
  1835. };

  1837. Window_MenuActor.prototype.selectForItem = function(item) {
  1838.     var actor = $gameParty.menuActor();
  1839.     var action = new Game_Action(actor);
  1840.     action.setItemObject(item);
  1841.     this.setCursorFixed(false);
  1842.     this.setCursorAll(false);
  1843.     if (action.isForUser()) {
  1844.         if (DataManager.isSkill(item)) {
  1845.             this.setCursorFixed(true);
  1846.             this.select(actor.index());
  1847.         } else {
  1848.             this.selectLast();
  1849.         }
  1850.     } else if (action.isForAll()) {
  1851.         this.setCursorAll(true);
  1852.         this.select(0);
  1853.     } else {
  1854.         this.selectLast();
  1855.     }
  1856. };

  1858. //-----------------------------------------------------------------------------
  1859. // Window_ItemCategory
  1860. //
  1861. // The window for selecting a category of items on the item and shop screens.

  1863. function Window_ItemCategory() {
  1864.     this.initialize.apply(this, arguments);
  1865. }

  1867. Window_ItemCategory.prototype = Object.create(Window_HorzCommand.prototype);
  1868. Window_ItemCategory.prototype.constructor = Window_ItemCategory;

  1870. Window_ItemCategory.prototype.initialize = function() {
  1871.     Window_HorzCommand.prototype.initialize.call(this, 0, 0);
  1872. };

  1874. Window_ItemCategory.prototype.windowWidth = function() {
  1875.     return Graphics.boxWidth;
  1876. };

  1878. Window_ItemCategory.prototype.maxCols = function() {
  1879.     return 4;
  1880. };

  1882. Window_ItemCategory.prototype.update = function() {
  1883.     Window_HorzCommand.prototype.update.call(this);
  1884.     if (this._itemWindow) {
  1885.         this._itemWindow.setCategory(this.currentSymbol());
  1886.     }
  1887. };

  1889. Window_ItemCategory.prototype.makeCommandList = function() {
  1890.     this.addCommand(TextManager.item,    'item');
  1891.     this.addCommand(TextManager.weapon,  'weapon');
  1892.     this.addCommand(TextManager.armor,   'armor');
  1893.     this.addCommand(TextManager.keyItem, 'keyItem');
  1894. };

  1896. Window_ItemCategory.prototype.setItemWindow = function(itemWindow) {
  1897.     this._itemWindow = itemWindow;
  1898. };

  1900. //-----------------------------------------------------------------------------
  1901. // Window_ItemList
  1902. //
  1903. // The window for selecting an item on the item screen.

  1905. function Window_ItemList() {
  1906.     this.initialize.apply(this, arguments);
  1907. }

  1909. Window_ItemList.prototype = Object.create(Window_Selectable.prototype);
  1910. Window_ItemList.prototype.constructor = Window_ItemList;

  1912. Window_ItemList.prototype.initialize = function(x, y, width, height) {
  1913.     Window_Selectable.prototype.initialize.call(this, x, y, width, height);
  1914.     this._category = 'none';
  1915.     this._data = [];
  1916. };

  1918. Window_ItemList.prototype.setCategory = function(category) {
  1919.     if (this._category !== category) {
  1920.         this._category = category;
  1921.         this.refresh();
  1922.         this.resetScroll();
  1923.     }
  1924. };

  1926. Window_ItemList.prototype.maxCols = function() {
  1927.     return 2;
  1928. };

  1930. Window_ItemList.prototype.spacing = function() {
  1931.     return 48;
  1932. };

  1934. Window_ItemList.prototype.maxItems = function() {
  1935.     return this._data ? this._data.length : 1;
  1936. };

  1938. Window_ItemList.prototype.item = function() {
  1939.     var index = this.index();
  1940.     return this._data && index >= 0 ? this._data[index] : null;
  1941. };

  1943. Window_ItemList.prototype.isCurrentItemEnabled = function() {
  1944.     return this.isEnabled(this.item());
  1945. };

  1947. Window_ItemList.prototype.includes = function(item) {
  1948.     switch (this._category) {
  1949.     case 'item':
  1950.         return DataManager.isItem(item) && item.itypeId === 1;
  1951.     case 'weapon':
  1952.         return DataManager.isWeapon(item);
  1953.     case 'armor':
  1954.         return DataManager.isArmor(item);
  1955.     case 'keyItem':
  1956.         return DataManager.isItem(item) && item.itypeId === 2;
  1957.     default:
  1958.         return false;
  1959.     }
  1960. };

  1962. Window_ItemList.prototype.needsNumber = function() {
  1963.     return true;
  1964. };

  1966. Window_ItemList.prototype.isEnabled = function(item) {
  1967.     return $gameParty.canUse(item);
  1968. };

  1970. Window_ItemList.prototype.makeItemList = function() {
  1971.     this._data = $gameParty.allItems().filter(function(item) {
  1972.         return this.includes(item);
  1973.     }, this);
  1974.     if (this.includes(null)) {
  1975.         this._data.push(null);
  1976.     }
  1977. };

  1979. Window_ItemList.prototype.selectLast = function() {
  1980.     var index = this._data.indexOf($gameParty.lastItem());
  1981.     this.select(index >= 0 ? index : 0);
  1982. };

  1984. Window_ItemList.prototype.drawItem = function(index) {
  1985.     var item = this._data[index];
  1986.     if (item) {
  1987.         var numberWidth = this.numberWidth();
  1988.         var rect = this.itemRect(index);
  1989.         rect.width -= this.textPadding();
  1990.         this.changePaintOpacity(this.isEnabled(item));
  1991.         this.drawItemName(item, rect.x, rect.y, rect.width - numberWidth);
  1992.         this.drawItemNumber(item, rect.x, rect.y, rect.width);
  1993.         this.changePaintOpacity(1);
  1994.     }
  1995. };

  1997. Window_ItemList.prototype.numberWidth = function() {
  1998.     return this.textWidth('000');
  1999. };

  2001. Window_ItemList.prototype.drawItemNumber = function(item, x, y, width) {
  2002.     if (this.needsNumber()) {
  2003.         this.drawText(':', x, y, width - this.textWidth('00'), 'right');
  2004.         this.drawText($gameParty.numItems(item), x, y, width, 'right');
  2005.     }
  2006. };

  2008. Window_ItemList.prototype.updateHelp = function() {
  2009.     this.setHelpWindowItem(this.item());
  2010. };

  2012. Window_ItemList.prototype.refresh = function() {
  2013.     this.makeItemList();
  2014.     this.createContents();
  2015.     this.drawAllItems();
  2016. };

  2018. //-----------------------------------------------------------------------------
  2019. // Window_SkillType
  2020. //
  2021. // The window for selecting a skill type on the skill screen.

  2023. function Window_SkillType() {
  2024.     this.initialize.apply(this, arguments);
  2025. }

  2027. Window_SkillType.prototype = Object.create(Window_Command.prototype);
  2028. Window_SkillType.prototype.constructor = Window_SkillType;

  2030. Window_SkillType.prototype.initialize = function(x, y) {
  2031.     Window_Command.prototype.initialize.call(this, x, y);
  2032.     this._actor = null;
  2033. };

  2035. Window_SkillType.prototype.windowWidth = function() {
  2036.     return 240;
  2037. };

  2039. Window_SkillType.prototype.setActor = function(actor) {
  2040.     if (this._actor !== actor) {
  2041.         this._actor = actor;
  2042.         this.refresh();
  2043.         this.selectLast();
  2044.     }
  2045. };

  2047. Window_SkillType.prototype.numVisibleRows = function() {
  2048.     return 4;
  2049. };

  2051. Window_SkillType.prototype.makeCommandList = function() {
  2052.     if (this._actor) {
  2053.         var skillTypes = this._actor.addedSkillTypes();
  2054.         skillTypes.sort(function(a, b) {
  2055.             return a - b;
  2056.         });
  2057.         skillTypes.forEach(function(stypeId) {
  2058.             var name = $dataSystem.skillTypes[stypeId];
  2059.             this.addCommand(name, 'skill', true, stypeId);
  2060.         }, this);
  2061.     }
  2062. };

  2064. Window_SkillType.prototype.update = function() {
  2065.     Window_Command.prototype.update.call(this);
  2066.     if (this._skillWindow) {
  2067.         this._skillWindow.setStypeId(this.currentExt());
  2068.     }
  2069. };

  2071. Window_SkillType.prototype.setSkillWindow = function(skillWindow) {
  2072.     this._skillWindow = skillWindow;
  2073. };

  2075. Window_SkillType.prototype.selectLast = function() {
  2076.     var skill = this._actor.lastMenuSkill();
  2077.     if (skill) {
  2078.         this.selectExt(skill.stypeId);
  2079.     } else {
  2080.         this.select(0);
  2081.     }
  2082. };

  2084. //-----------------------------------------------------------------------------
  2085. // Window_SkillStatus
  2086. //
  2087. // The window for displaying the skill user's status on the skill screen.

  2089. function Window_SkillStatus() {
  2090.     this.initialize.apply(this, arguments);
  2091. }

  2093. Window_SkillStatus.prototype = Object.create(Window_Base.prototype);
  2094. Window_SkillStatus.prototype.constructor = Window_SkillStatus;

  2096. Window_SkillStatus.prototype.initialize = function(x, y, width, height) {
  2097.     Window_Base.prototype.initialize.call(this, x, y, width, height);
  2098.     this._actor = null;
  2099. };

  2101. Window_SkillStatus.prototype.setActor = function(actor) {
  2102.     if (this._actor !== actor) {
  2103.         this._actor = actor;
  2104.         this.refresh();
  2105.     }
  2106. };

  2108. Window_SkillStatus.prototype.refresh = function() {
  2109.     this.contents.clear();
  2110.     if (this._actor) {
  2111.         var w = this.width - this.padding * 2;
  2112.         var h = this.height - this.padding * 2;
  2113.         var y = h / 2 - this.lineHeight() * 1.5;
  2114.         var width = w - 162 - this.textPadding();
  2115.         this.drawActorFace(this._actor, 0, 0, 144, h);
  2116.         this.drawActorSimpleStatus(this._actor, 162, y, width);
  2117.     }
  2118. };

  2120. //-----------------------------------------------------------------------------
  2121. // Window_SkillList
  2122. //
  2123. // The window for selecting a skill on the skill screen.

  2125. function Window_SkillList() {
  2126.     this.initialize.apply(this, arguments);
  2127. }

  2129. Window_SkillList.prototype = Object.create(Window_Selectable.prototype);
  2130. Window_SkillList.prototype.constructor = Window_SkillList;

  2132. Window_SkillList.prototype.initialize = function(x, y, width, height) {
  2133.     Window_Selectable.prototype.initialize.call(this, x, y, width, height);
  2134.     this._actor = null;
  2135.     this._stypeId = 0;
  2136.     this._data = [];
  2137. };

  2139. Window_SkillList.prototype.setActor = function(actor) {
  2140.     if (this._actor !== actor) {
  2141.         this._actor = actor;
  2142.         this.refresh();
  2143.         this.resetScroll();
  2144.     }
  2145. };

  2147. Window_SkillList.prototype.setStypeId = function(stypeId) {
  2148.     if (this._stypeId !== stypeId) {
  2149.         this._stypeId = stypeId;
  2150.         this.refresh();
  2151.         this.resetScroll();
  2152.     }
  2153. };

  2155. Window_SkillList.prototype.maxCols = function() {
  2156.     return 2;
  2157. };

  2159. Window_SkillList.prototype.spacing = function() {
  2160.     return 48;
  2161. };

  2163. Window_SkillList.prototype.maxItems = function() {
  2164.     return this._data ? this._data.length : 1;
  2165. };

  2167. Window_SkillList.prototype.item = function() {
  2168.     return this._data && this.index() >= 0 ? this._data[this.index()] : null;
  2169. };

  2171. Window_SkillList.prototype.isCurrentItemEnabled = function() {
  2172.     return this.isEnabled(this._data[this.index()]);
  2173. };

  2175. Window_SkillList.prototype.includes = function(item) {
  2176.     return item && item.stypeId === this._stypeId;
  2177. };

  2179. Window_SkillList.prototype.isEnabled = function(item) {
  2180.     return this._actor && this._actor.canUse(item);
  2181. };

  2183. Window_SkillList.prototype.makeItemList = function() {
  2184.     if (this._actor) {
  2185.         this._data = this._actor.skills().filter(function(item) {
  2186.             return this.includes(item);
  2187.         }, this);
  2188.     } else {
  2189.         this._data = [];
  2190.     }
  2191. };

  2193. Window_SkillList.prototype.selectLast = function() {
  2194.     var skill;
  2195.     if ($gameParty.inBattle()) {
  2196.         skill = this._actor.lastBattleSkill();
  2197.     } else {
  2198.         skill = this._actor.lastMenuSkill();
  2199.     }
  2200.     var index = this._data.indexOf(skill);
  2201.     this.select(index >= 0 ? index : 0);
  2202. };

  2204. Window_SkillList.prototype.drawItem = function(index) {
  2205.     var skill = this._data[index];
  2206.     if (skill) {
  2207.         var costWidth = this.costWidth();
  2208.         var rect = this.itemRect(index);
  2209.         rect.width -= this.textPadding();
  2210.         this.changePaintOpacity(this.isEnabled(skill));
  2211.         this.drawItemName(skill, rect.x, rect.y, rect.width - costWidth);
  2212.         this.drawSkillCost(skill, rect.x, rect.y, rect.width);
  2213.         this.changePaintOpacity(1);
  2214.     }
  2215. };

  2217. Window_SkillList.prototype.costWidth = function() {
  2218.     return this.textWidth('000');
  2219. };

  2221. Window_SkillList.prototype.drawSkillCost = function(skill, x, y, width) {
  2222.     if (this._actor.skillTpCost(skill) > 0) {
  2223.         this.changeTextColor(this.tpCostColor());
  2224.         this.drawText(this._actor.skillTpCost(skill), x, y, width, 'right');
  2225.     } else if (this._actor.skillMpCost(skill) > 0) {
  2226.         this.changeTextColor(this.mpCostColor());
  2227.         this.drawText(this._actor.skillMpCost(skill), x, y, width, 'right');
  2228.     }
  2229. };

  2231. Window_SkillList.prototype.updateHelp = function() {
  2232.     this.setHelpWindowItem(this.item());
  2233. };

  2235. Window_SkillList.prototype.refresh = function() {
  2236.     this.makeItemList();
  2237.     this.createContents();
  2238.     this.drawAllItems();
  2239. };

  2241. //-----------------------------------------------------------------------------
  2242. // Window_EquipStatus
  2243. //
  2244. // The window for displaying parameter changes on the equipment screen.

  2246. function Window_EquipStatus() {
  2247.     this.initialize.apply(this, arguments);
  2248. }

  2250. Window_EquipStatus.prototype = Object.create(Window_Base.prototype);
  2251. Window_EquipStatus.prototype.constructor = Window_EquipStatus;

  2253. Window_EquipStatus.prototype.initialize = function(x, y) {
  2254.     var width = this.windowWidth();
  2255.     var height = this.windowHeight();
  2256.     Window_Base.prototype.initialize.call(this, x, y, width, height);
  2257.     this._actor = null;
  2258.     this._tempActor = null;
  2259.     this.refresh();
  2260. };

  2262. Window_EquipStatus.prototype.windowWidth = function() {
  2263.     return 312;
  2264. };

  2266. Window_EquipStatus.prototype.windowHeight = function() {
  2267.     return this.fittingHeight(this.numVisibleRows());
  2268. };

  2270. Window_EquipStatus.prototype.numVisibleRows = function() {
  2271.     return 7;
  2272. };

  2274. Window_EquipStatus.prototype.setActor = function(actor) {
  2275.     if (this._actor !== actor) {
  2276.         this._actor = actor;
  2277.         this.refresh();
  2278.     }
  2279. };

  2281. Window_EquipStatus.prototype.refresh = function() {
  2282.     this.contents.clear();
  2283.     if (this._actor) {
  2284.         this.drawActorName(this._actor, this.textPadding(), 0);
  2285.         for (var i = 0; i < 6; i++) {
  2286.             this.drawItem(0, this.lineHeight() * (1 + i), 2 + i);
  2287.         }
  2288.     }
  2289. };

  2291. Window_EquipStatus.prototype.setTempActor = function(tempActor) {
  2292.     if (this._tempActor !== tempActor) {
  2293.         this._tempActor = tempActor;
  2294.         this.refresh();
  2295.     }
  2296. };

  2298. Window_EquipStatus.prototype.drawItem = function(x, y, paramId) {
  2299.     this.drawParamName(x + this.textPadding(), y, paramId);
  2300.     if (this._actor) {
  2301.         this.drawCurrentParam(x + 140, y, paramId);
  2302.     }
  2303.     this.drawRightArrow(x + 188, y);
  2304.     if (this._tempActor) {
  2305.         this.drawNewParam(x + 222, y, paramId);
  2306.     }
  2307. };

  2309. Window_EquipStatus.prototype.drawParamName = function(x, y, paramId) {
  2310.     this.changeTextColor(this.systemColor());
  2311.     this.drawText(TextManager.param(paramId), x, y, 120);
  2312. };

  2314. Window_EquipStatus.prototype.drawCurrentParam = function(x, y, paramId) {
  2315.     this.resetTextColor();
  2316.     this.drawText(this._actor.param(paramId), x, y, 48, 'right');
  2317. };

  2319. Window_EquipStatus.prototype.drawRightArrow = function(x, y) {
  2320.     this.changeTextColor(this.systemColor());
  2321.     this.drawText('\u2192', x, y, 32, 'center');
  2322. };

  2324. Window_EquipStatus.prototype.drawNewParam = function(x, y, paramId) {
  2325.     var newValue = this._tempActor.param(paramId);
  2326.     var diffvalue = newValue - this._actor.param(paramId);
  2327.     this.changeTextColor(this.paramchangeTextColor(diffvalue));
  2328.     this.drawText(newValue, x, y, 48, 'right');
  2329. };

  2331. //-----------------------------------------------------------------------------
  2332. // Window_EquipCommand
  2333. //
  2334. // The window for selecting a command on the equipment screen.

  2336. function Window_EquipCommand() {
  2337.     this.initialize.apply(this, arguments);
  2338. }

  2340. Window_EquipCommand.prototype = Object.create(Window_HorzCommand.prototype);
  2341. Window_EquipCommand.prototype.constructor = Window_EquipCommand;

  2343. Window_EquipCommand.prototype.initialize = function(x, y, width) {
  2344.     this._windowWidth = width;
  2345.     Window_HorzCommand.prototype.initialize.call(this, x, y);
  2346. };

  2348. Window_EquipCommand.prototype.windowWidth = function() {
  2349.     return this._windowWidth;
  2350. };

  2352. Window_EquipCommand.prototype.maxCols = function() {
  2353.     return 3;
  2354. };

  2356. Window_EquipCommand.prototype.makeCommandList = function() {
  2357.     this.addCommand(TextManager.equip2,   'equip');
  2358.     this.addCommand(TextManager.optimize, 'optimize');
  2359.     this.addCommand(TextManager.clear,    'clear');
  2360. };

  2362. //-----------------------------------------------------------------------------
  2363. // Window_EquipSlot
  2364. //
  2365. // The window for selecting an equipment slot on the equipment screen.

  2367. function Window_EquipSlot() {
  2368.     this.initialize.apply(this, arguments);
  2369. }

  2371. Window_EquipSlot.prototype = Object.create(Window_Selectable.prototype);
  2372. Window_EquipSlot.prototype.constructor = Window_EquipSlot;

  2374. Window_EquipSlot.prototype.initialize = function(x, y, width, height) {
  2375.     Window_Selectable.prototype.initialize.call(this, x, y, width, height);
  2376.     this._actor = null;
  2377.     this.refresh();
  2378. };

  2380. Window_EquipSlot.prototype.setActor = function(actor) {
  2381.     if (this._actor !== actor) {
  2382.         this._actor = actor;
  2383.         this.refresh();
  2384.     }
  2385. };

  2387. Window_EquipSlot.prototype.update = function() {
  2388.     Window_Selectable.prototype.update.call(this);
  2389.     if (this._itemWindow) {
  2390.         this._itemWindow.setSlotId(this.index());
  2391.     }
  2392. };

  2394. Window_EquipSlot.prototype.maxItems = function() {
  2395.     return this._actor ? this._actor.equipSlots().length : 0;
  2396. };

  2398. Window_EquipSlot.prototype.item = function() {
  2399.     return this._actor ? this._actor.equips()[this.index()] : null;
  2400. };

  2402. Window_EquipSlot.prototype.drawItem = function(index) {
  2403.     if (this._actor) {
  2404.         var rect = this.itemRectForText(index);
  2405.         this.changeTextColor(this.systemColor());
  2406.         this.changePaintOpacity(this.isEnabled(index));
  2407.         this.drawText(this.slotName(index), rect.x, rect.y, 138, this.lineHeight());
  2408.         this.drawItemName(this._actor.equips()[index], rect.x + 138, rect.y);
  2409.         this.changePaintOpacity(true);
  2410.     }
  2411. };

  2413. Window_EquipSlot.prototype.slotName = function(index) {
  2414.     var slots = this._actor.equipSlots();
  2415.     return this._actor ? $dataSystem.equipTypes[slots[index]] : '';
  2416. };

  2418. Window_EquipSlot.prototype.isEnabled = function(index) {
  2419.     return this._actor ? this._actor.isEquipChangeOk(index) : false;
  2420. };

  2422. Window_EquipSlot.prototype.isCurrentItemEnabled = function() {
  2423.     return this.isEnabled(this.index());
  2424. };

  2426. Window_EquipSlot.prototype.setStatusWindow = function(statusWindow) {
  2427.     this._statusWindow = statusWindow;
  2428.     this.callUpdateHelp();
  2429. };

  2431. Window_EquipSlot.prototype.setItemWindow = function(itemWindow) {
  2432.     this._itemWindow = itemWindow;
  2433. };

  2435. Window_EquipSlot.prototype.updateHelp = function() {
  2436.     Window_Selectable.prototype.updateHelp.call(this);
  2437.     this.setHelpWindowItem(this.item());
  2438.     if (this._statusWindow) {
  2439.         this._statusWindow.setTempActor(null);
  2440.     }
  2441. };

  2443. //-----------------------------------------------------------------------------
  2444. // Window_EquipItem
  2445. //
  2446. // The window for selecting an equipment item on the equipment screen.

  2448. function Window_EquipItem() {
  2449.     this.initialize.apply(this, arguments);
  2450. }

  2452. Window_EquipItem.prototype = Object.create(Window_ItemList.prototype);
  2453. Window_EquipItem.prototype.constructor = Window_EquipItem;

  2455. Window_EquipItem.prototype.initialize = function(x, y, width, height) {
  2456.     Window_ItemList.prototype.initialize.call(this, x, y, width, height);
  2457.     this._actor = null;
  2458.     this._slotId = 0;
  2459. };

  2461. Window_EquipItem.prototype.setActor = function(actor) {
  2462.     if (this._actor !== actor) {
  2463.         this._actor = actor;
  2464.         this.refresh();
  2465.         this.resetScroll();
  2466.     }
  2467. };

  2469. Window_EquipItem.prototype.setSlotId = function(slotId) {
  2470.     if (this._slotId !== slotId) {
  2471.         this._slotId = slotId;
  2472.         this.refresh();
  2473.         this.resetScroll();
  2474.     }
  2475. };

  2477. Window_EquipItem.prototype.includes = function(item) {
  2478.     if (item === null) {
  2479.         return true;
  2480.     }
  2481.     if (this._slotId < 0 || item.etypeId !== this._actor.equipSlots()[this._slotId]) {
  2482.         return false;
  2483.     }
  2484.     return this._actor.canEquip(item);
  2485. };

  2487. Window_EquipItem.prototype.isEnabled = function(item) {
  2488.     return true;
  2489. };

  2491. Window_EquipItem.prototype.selectLast = function() {
  2492. };

  2494. Window_EquipItem.prototype.setStatusWindow = function(statusWindow) {
  2495.     this._statusWindow = statusWindow;
  2496.     this.callUpdateHelp();
  2497. };

  2499. Window_EquipItem.prototype.updateHelp = function() {
  2500.     Window_ItemList.prototype.updateHelp.call(this);
  2501.     if (this._actor && this._statusWindow) {
  2502.         var actor = JsonEx.makeDeepCopy(this._actor);
  2503.         actor.forceChangeEquip(this._slotId, this.item());
  2504.         this._statusWindow.setTempActor(actor);
  2505.     }
  2506. };

  2508. Window_EquipItem.prototype.playOkSound = function() {
  2509. };

  2511. //-----------------------------------------------------------------------------
  2512. // Window_Status
  2513. //
  2514. // The window for displaying full status on the status screen.

  2516. function Window_Status() {
  2517.     this.initialize.apply(this, arguments);
  2518. }

  2520. Window_Status.prototype = Object.create(Window_Selectable.prototype);
  2521. Window_Status.prototype.constructor = Window_Status;

  2523. Window_Status.prototype.initialize = function() {
  2524.     var width = Graphics.boxWidth;
  2525.     var height = Graphics.boxHeight;
  2526.     Window_Selectable.prototype.initialize.call(this, 0, 0, width, height);
  2527.     this._actor = null;
  2528.     this.refresh();
  2529.     this.activate();
  2530. };

  2532. Window_Status.prototype.setActor = function(actor) {
  2533.     if (this._actor !== actor) {
  2534.         this._actor = actor;
  2535.         this.refresh();
  2536.     }
  2537. };

  2539. Window_Status.prototype.refresh = function() {
  2540.     this.contents.clear();
  2541.     if (this._actor) {
  2542.         var lineHeight = this.lineHeight();
  2543.         this.drawBlock1(lineHeight * 0);
  2544.         this.drawHorzLine(lineHeight * 1);
  2545.         this.drawBlock2(lineHeight * 2);
  2546.         this.drawHorzLine(lineHeight * 6);
  2547.         this.drawBlock3(lineHeight * 7);
  2548.         this.drawHorzLine(lineHeight * 13);
  2549.         this.drawBlock4(lineHeight * 14);
  2550.     }
  2551. };

  2553. Window_Status.prototype.drawBlock1 = function(y) {
  2554.     this.drawActorName(this._actor, 6, y);
  2555.     this.drawActorClass(this._actor, 192, y);
  2556.     this.drawActorNickname(this._actor, 432, y);
  2557. };

  2559. Window_Status.prototype.drawBlock2 = function(y) {
  2560.     this.drawActorFace(this._actor, 12, y);
  2561.     this.drawBasicInfo(204, y);
  2562.     this.drawExpInfo(456, y);
  2563. };

  2565. Window_Status.prototype.drawBlock3 = function(y) {
  2566.     this.drawParameters(48, y);
  2567.     this.drawEquipments(432, y);
  2568. };

  2570. Window_Status.prototype.drawBlock4 = function(y) {
  2571.     this.drawProfile(6, y);
  2572. };

  2574. Window_Status.prototype.drawHorzLine = function(y) {
  2575.     var lineY = y + this.lineHeight() / 2 - 1;
  2576.     this.contents.paintOpacity = 48;
  2577.     this.contents.fillRect(0, lineY, this.contentsWidth(), 2, this.lineColor());
  2578.     this.contents.paintOpacity = 255;
  2579. };

  2581. Window_Status.prototype.lineColor = function() {
  2582.     return this.normalColor();
  2583. };

  2585. Window_Status.prototype.drawBasicInfo = function(x, y) {
  2586.     var lineHeight = this.lineHeight();
  2587.     this.drawActorLevel(this._actor, x, y + lineHeight * 0);
  2588.     this.drawActorIcons(this._actor, x, y + lineHeight * 1);
  2589.     this.drawActorHp(this._actor, x, y + lineHeight * 2);
  2590.     this.drawActorMp(this._actor, x, y + lineHeight * 3);
  2591. };

  2593. Window_Status.prototype.drawParameters = function(x, y) {
  2594.     var lineHeight = this.lineHeight();
  2595.     for (var i = 0; i < 6; i++) {
  2596.         var paramId = i + 2;
  2597.         var y2 = y + lineHeight * i;
  2598.         this.changeTextColor(this.systemColor());
  2599.         this.drawText(TextManager.param(paramId), x, y2, 160);
  2600.         this.resetTextColor();
  2601.         this.drawText(this._actor.param(paramId), x + 160, y2, 60, 'right');
  2602.     }
  2603. };

  2605. Window_Status.prototype.drawExpInfo = function(x, y) {
  2606.     var lineHeight = this.lineHeight();
  2607.     var expTotal = TextManager.expTotal.format(TextManager.exp);
  2608.     var expNext = TextManager.expNext.format(TextManager.level);
  2609.     var value1 = this._actor.currentExp();
  2610.     var value2 = this._actor.nextRequiredExp();
  2611.     if (this._actor.isMaxLevel()) {
  2612.         value1 = '-------';
  2613.         value2 = '-------';
  2614.     }
  2615.     this.changeTextColor(this.systemColor());
  2616.     this.drawText(expTotal, x, y + lineHeight * 0, 270);
  2617.     this.drawText(expNext, x, y + lineHeight * 2, 270);
  2618.     this.resetTextColor();
  2619.     this.drawText(value1, x, y + lineHeight * 1, 270, 'right');
  2620.     this.drawText(value2, x, y + lineHeight * 3, 270, 'right');
  2621. };

  2623. Window_Status.prototype.drawEquipments = function(x, y) {
  2624.     var equips = this._actor.equips();
  2625.     var count = Math.min(equips.length, this.maxEquipmentLines());
  2626.     for (var i = 0; i < count; i++) {
  2627.         this.drawItemName(equips[i], x, y + this.lineHeight() * i);
  2628.     }
  2629. };

  2631. Window_Status.prototype.drawProfile = function(x, y) {
  2632.     this.drawTextEx(this._actor.profile(), x, y);
  2633. };

  2635. Window_Status.prototype.maxEquipmentLines = function() {
  2636.     return 6;
  2637. };

  2639. //-----------------------------------------------------------------------------
  2640. // Window_Options
  2641. //
  2642. // The window for changing various settings on the options screen.

  2644. function Window_Options() {
  2645.     this.initialize.apply(this, arguments);
  2646. }

  2648. Window_Options.prototype = Object.create(Window_Command.prototype);
  2649. Window_Options.prototype.constructor = Window_Options;

  2651. Window_Options.prototype.initialize = function() {
  2652.     Window_Command.prototype.initialize.call(this, 0, 0);
  2653.     this.updatePlacement();
  2654. };

  2656. Window_Options.prototype.windowWidth = function() {
  2657.     return 400;
  2658. };

  2660. Window_Options.prototype.windowHeight = function() {
  2661.     return this.fittingHeight(Math.min(this.numVisibleRows(), 12));
  2662. };

  2664. Window_Options.prototype.updatePlacement = function() {
  2665.     this.x = (Graphics.boxWidth - this.width) / 2;
  2666.     this.y = (Graphics.boxHeight - this.height) / 2;
  2667. };

  2669. Window_Options.prototype.makeCommandList = function() {
  2670.     this.addGeneralOptions();
  2671.     this.addVolumeOptions();
  2672. };

  2674. Window_Options.prototype.addGeneralOptions = function() {
  2675.     this.addCommand(TextManager.alwaysDash, 'alwaysDash');
  2676.     this.addCommand(TextManager.commandRemember, 'commandRemember');
  2677. };

  2679. Window_Options.prototype.addVolumeOptions = function() {
  2680.     this.addCommand(TextManager.bgmVolume, 'bgmVolume');
  2681.     this.addCommand(TextManager.bgsVolume, 'bgsVolume');
  2682.     this.addCommand(TextManager.meVolume, 'meVolume');
  2683.     this.addCommand(TextManager.seVolume, 'seVolume');
  2684. };

  2686. Window_Options.prototype.drawItem = function(index) {
  2687.     var rect = this.itemRectForText(index);
  2688.     var statusWidth = this.statusWidth();
  2689.     var titleWidth = rect.width - statusWidth;
  2690.     this.resetTextColor();
  2691.     this.changePaintOpacity(this.isCommandEnabled(index));
  2692.     this.drawText(this.commandName(index), rect.x, rect.y, titleWidth, 'left');
  2693.     this.drawText(this.statusText(index), titleWidth, rect.y, statusWidth, 'right');
  2694. };

  2696. Window_Options.prototype.statusWidth = function() {
  2697.     return 120;
  2698. };

  2700. Window_Options.prototype.statusText = function(index) {
  2701.     var symbol = this.commandSymbol(index);
  2702.     var value = this.getConfigValue(symbol);
  2703.     if (this.isVolumeSymbol(symbol)) {
  2704.         return this.volumeStatusText(value);
  2705.     } else {
  2706.         return this.booleanStatusText(value);
  2707.     }
  2708. };

  2710. Window_Options.prototype.isVolumeSymbol = function(symbol) {
  2711.     return symbol.contains('Volume');
  2712. };

  2714. Window_Options.prototype.booleanStatusText = function(value) {
  2715.     return value ? 'ON' : 'OFF';
  2716. };

  2718. Window_Options.prototype.volumeStatusText = function(value) {
  2719.     return value + '%';
  2720. };

  2722. Window_Options.prototype.processOk = function() {
  2723.     var index = this.index();
  2724.     var symbol = this.commandSymbol(index);
  2725.     var value = this.getConfigValue(symbol);
  2726.     if (this.isVolumeSymbol(symbol)) {
  2727.         value += this.volumeOffset();
  2728.         if (value > 100) {
  2729.             value = 0;
  2730.         }
  2731.         value = value.clamp(0, 100);
  2732.         this.changeValue(symbol, value);
  2733.     } else {
  2734.         this.changeValue(symbol, !value);
  2735.     }
  2736. };

  2738. Window_Options.prototype.cursorRight = function(wrap) {
  2739.     var index = this.index();
  2740.     var symbol = this.commandSymbol(index);
  2741.     var value = this.getConfigValue(symbol);
  2742.     if (this.isVolumeSymbol(symbol)) {
  2743.         value += this.volumeOffset();
  2744.         value = value.clamp(0, 100);
  2745.         this.changeValue(symbol, value);
  2746.     } else {
  2747.         this.changeValue(symbol, true);
  2748.     }
  2749. };

  2751. Window_Options.prototype.cursorLeft = function(wrap) {
  2752.     var index = this.index();
  2753.     var symbol = this.commandSymbol(index);
  2754.     var value = this.getConfigValue(symbol);
  2755.     if (this.isVolumeSymbol(symbol)) {
  2756.         value -= this.volumeOffset();
  2757.         value = value.clamp(0, 100);
  2758.         this.changeValue(symbol, value);
  2759.     } else {
  2760.         this.changeValue(symbol, false);
  2761.     }
  2762. };

  2764. Window_Options.prototype.volumeOffset = function() {
  2765.     return 20;
  2766. };

  2768. Window_Options.prototype.changeValue = function(symbol, value) {
  2769.     var lastValue = this.getConfigValue(symbol);
  2770.     if (lastValue !== value) {
  2771.         this.setConfigValue(symbol, value);
  2772.         this.redrawItem(this.findSymbol(symbol));
  2773.         SoundManager.playCursor();
  2774.     }
  2775. };

  2777. Window_Options.prototype.getConfigValue = function(symbol) {
  2778.     return ConfigManager[symbol];
  2779. };

  2781. Window_Options.prototype.setConfigValue = function(symbol, volume) {
  2782.     ConfigManager[symbol] = volume;
  2783. };

  2785. //-----------------------------------------------------------------------------
  2786. // Window_SavefileList
  2787. //
  2788. // The window for selecting a save file on the save and load screens.

  2790. function Window_SavefileList() {
  2791.     this.initialize.apply(this, arguments);
  2792. }

  2794. Window_SavefileList.prototype = Object.create(Window_Selectable.prototype);
  2795. Window_SavefileList.prototype.constructor = Window_SavefileList;

  2797. Window_SavefileList.prototype.initialize = function(x, y, width, height) {
  2798.     Window_Selectable.prototype.initialize.call(this, x, y, width, height);
  2799.     this.activate();
  2800.     this._mode = null;
  2801. };

  2803. Window_SavefileList.prototype.setMode = function(mode) {
  2804.     this._mode = mode;
  2805. };

  2807. Window_SavefileList.prototype.maxItems = function() {
  2808.     return DataManager.maxSavefiles();
  2809. };

  2811. Window_SavefileList.prototype.maxVisibleItems = function() {
  2812.     return 5;
  2813. };

  2815. Window_SavefileList.prototype.itemHeight = function() {
  2816.     var innerHeight = this.height - this.padding * 2;
  2817.     return Math.floor(innerHeight / this.maxVisibleItems());
  2818. };

  2820. Window_SavefileList.prototype.drawItem = function(index) {
  2821.     var id = index + 1;
  2822.     var valid = DataManager.isThisGameFile(id);
  2823.     var info = DataManager.loadSavefileInfo(id);
  2824.     var rect = this.itemRectForText(index);
  2825.     this.resetTextColor();
  2826.     if (this._mode === 'load') {
  2827.         this.changePaintOpacity(valid);
  2828.     }
  2829.     this.drawFileId(id, rect.x, rect.y);
  2830.     if (info) {
  2831.         this.changePaintOpacity(valid);
  2832.         this.drawContents(info, rect, valid);
  2833.         this.changePaintOpacity(true);
  2834.     }
  2835. };

  2837. Window_SavefileList.prototype.drawFileId = function(id, x, y) {
  2838.     this.drawText(TextManager.file + ' ' + id, x, y, 180);
  2839. };

  2841. Window_SavefileList.prototype.drawContents = function(info, rect, valid) {
  2842.     var bottom = rect.y + rect.height;
  2843.     if (rect.width >= 420) {
  2844.         this.drawGameTitle(info, rect.x + 192, rect.y, rect.width - 192);
  2845.         if (valid) {
  2846.             this.drawPartyCharacters(info, rect.x + 220, bottom - 4);
  2847.         }
  2848.     }
  2849.     var lineHeight = this.lineHeight();
  2850.     var y2 = bottom - lineHeight;
  2851.     if (y2 >= lineHeight) {
  2852.         this.drawPlaytime(info, rect.x, y2, rect.width);
  2853.     }
  2854. };

  2856. Window_SavefileList.prototype.drawGameTitle = function(info, x, y, width) {
  2857.     if (info.title) {
  2858.         this.drawText(info.title, x, y, width);
  2859.     }
  2860. };

  2862. Window_SavefileList.prototype.drawPartyCharacters = function(info, x, y) {
  2863.     if (info.characters) {
  2864.         for (var i = 0; i < info.characters.length; i++) {
  2865.             var data = info.characters[i];
  2866.             this.drawCharacter(data[0], data[1], x + i * 48, y);
  2867.         }
  2868.     }
  2869. };

  2871. Window_SavefileList.prototype.drawPlaytime = function(info, x, y, width) {
  2872.     if (info.playtime) {
  2873.         this.drawText(info.playtime, x, y, width, 'right');
  2874.     }
  2875. };

  2877. Window_SavefileList.prototype.playOkSound = function() {
  2878. };

  2880. //-----------------------------------------------------------------------------
  2881. // Window_ShopCommand
  2882. //
  2883. // The window for selecting buy/sell on the shop screen.

  2885. function Window_ShopCommand() {
  2886.     this.initialize.apply(this, arguments);
  2887. }

  2889. Window_ShopCommand.prototype = Object.create(Window_HorzCommand.prototype);
  2890. Window_ShopCommand.prototype.constructor = Window_ShopCommand;

  2892. Window_ShopCommand.prototype.initialize = function(width, purchaseOnly) {
  2893.     this._windowWidth = width;
  2894.     this._purchaseOnly = purchaseOnly;
  2895.     Window_HorzCommand.prototype.initialize.call(this, 0, 0);
  2896. };

  2898. Window_ShopCommand.prototype.windowWidth = function() {
  2899.     return this._windowWidth;
  2900. };

  2902. Window_ShopCommand.prototype.maxCols = function() {
  2903.     return 3;
  2904. };

  2906. Window_ShopCommand.prototype.makeCommandList = function() {
  2907.     this.addCommand(TextManager.buy,    'buy');
  2908.     this.addCommand(TextManager.sell,   'sell',   !this._purchaseOnly);
  2909.     this.addCommand(TextManager.cancel, 'cancel');
  2910. };

  2912. //-----------------------------------------------------------------------------
  2913. // Window_ShopBuy
  2914. //
  2915. // The window for selecting an item to buy on the shop screen.

  2917. function Window_ShopBuy() {
  2918.     this.initialize.apply(this, arguments);
  2919. }

  2921. Window_ShopBuy.prototype = Object.create(Window_Selectable.prototype);
  2922. Window_ShopBuy.prototype.constructor = Window_ShopBuy;

  2924. Window_ShopBuy.prototype.initialize = function(x, y, height, shopGoods) {
  2925.     var width = this.windowWidth();
  2926.     Window_Selectable.prototype.initialize.call(this, x, y, width, height);
  2927.     this._shopGoods = shopGoods;
  2928.     this._money = 0;
  2929.     this.refresh();
  2930.     this.select(0);
  2931. };

  2933. Window_ShopBuy.prototype.windowWidth = function() {
  2934.     return 456;
  2935. };

  2937. Window_ShopBuy.prototype.maxItems = function() {
  2938.     return this._data ? this._data.length : 1;
  2939. };

  2941. Window_ShopBuy.prototype.item = function() {
  2942.     return this._data[this.index()];
  2943. };

  2945. Window_ShopBuy.prototype.setMoney = function(money) {
  2946.     this._money = money;
  2947.     this.refresh();
  2948. };

  2950. Window_ShopBuy.prototype.isCurrentItemEnabled = function() {
  2951.     return this.isEnabled(this._data[this.index()]);
  2952. };

  2954. Window_ShopBuy.prototype.price = function(item) {
  2955.     return this._price[this._data.indexOf(item)] || 0;
  2956. };

  2958. Window_ShopBuy.prototype.isEnabled = function(item) {
  2959.     return (item && this.price(item) <= this._money &&
  2960.             !$gameParty.hasMaxItems(item));
  2961. };

  2963. Window_ShopBuy.prototype.refresh = function() {
  2964.     this.makeItemList();
  2965.     this.createContents();
  2966.     this.drawAllItems();
  2967. };

  2969. Window_ShopBuy.prototype.makeItemList = function() {
  2970.     this._data = [];
  2971.     this._price = [];
  2972.     this._shopGoods.forEach(function(goods) {
  2973.         var item = null;
  2974.         switch (goods[0]) {
  2975.         case 0:
  2976.             item = $dataItems[goods[1]];
  2977.             break;
  2978.         case 1:
  2979.             item = $dataWeapons[goods[1]];
  2980.             break;
  2981.         case 2:
  2982.             item = $dataArmors[goods[1]];
  2983.             break;
  2984.         }
  2985.         if (item) {
  2986.             this._data.push(item);
  2987.             this._price.push(goods[2] === 0 ? item.price : goods[3]);
  2988.         }
  2989.     }, this);
  2990. };

  2992. Window_ShopBuy.prototype.drawItem = function(index) {
  2993.     var item = this._data[index];
  2994.     var rect = this.itemRect(index);
  2995.     var priceWidth = 96;
  2996.     rect.width -= this.textPadding();
  2997.     this.changePaintOpacity(this.isEnabled(item));
  2998.     this.drawItemName(item, rect.x, rect.y, rect.width - priceWidth);
  2999.     this.drawText(this.price(item), rect.x + rect.width - priceWidth,
  3000.                   rect.y, priceWidth, 'right');
  3001.     this.changePaintOpacity(true);
  3002. };

  3004. Window_ShopBuy.prototype.setStatusWindow = function(statusWindow) {
  3005.     this._statusWindow = statusWindow;
  3006.     this.callUpdateHelp();
  3007. };

  3009. Window_ShopBuy.prototype.updateHelp = function() {
  3010.     this.setHelpWindowItem(this.item());
  3011.     if (this._statusWindow) {
  3012.         this._statusWindow.setItem(this.item());
  3013.     }
  3014. };

  3016. //-----------------------------------------------------------------------------
  3017. // Window_ShopSell
  3018. //
  3019. // The window for selecting an item to sell on the shop screen.

  3021. function Window_ShopSell() {
  3022.     this.initialize.apply(this, arguments);
  3023. }

  3025. Window_ShopSell.prototype = Object.create(Window_ItemList.prototype);
  3026. Window_ShopSell.prototype.constructor = Window_ShopSell;

  3028. Window_ShopSell.prototype.initialize = function(x, y, width, height) {
  3029.     Window_ItemList.prototype.initialize.call(this, x, y, width, height);
  3030. };

  3032. Window_ShopSell.prototype.isEnabled = function(item) {
  3033.     return item && item.price > 0;
  3034. };

  3036. //-----------------------------------------------------------------------------
  3037. // Window_ShopNumber
  3038. //
  3039. // The window for inputting quantity of items to buy or sell on the shop
  3040. // screen.

  3042. function Window_ShopNumber() {
  3043.     this.initialize.apply(this, arguments);
  3044. }

  3046. Window_ShopNumber.prototype = Object.create(Window_Selectable.prototype);
  3047. Window_ShopNumber.prototype.constructor = Window_ShopNumber;

  3049. Window_ShopNumber.prototype.initialize = function(x, y, height) {
  3050.     var width = this.windowWidth();
  3051.     Window_Selectable.prototype.initialize.call(this, x, y, width, height);
  3052.     this._item = null;
  3053.     this._max = 1;
  3054.     this._price = 0;
  3055.     this._number = 1;
  3056.     this._currencyUnit = TextManager.currencyUnit;
  3057.     this.createButtons();
  3058. };

  3060. Window_ShopNumber.prototype.windowWidth = function() {
  3061.     return 456;
  3062. };

  3064. Window_ShopNumber.prototype.number = function() {
  3065.     return this._number;
  3066. };

  3068. Window_ShopNumber.prototype.setup = function(item, max, price) {
  3069.     this._item = item;
  3070.     this._max = Math.floor(max);
  3071.     this._price = price;
  3072.     this._number = 1;
  3073.     this.placeButtons();
  3074.     this.updateButtonsVisiblity();
  3075.     this.refresh();
  3076. };

  3078. Window_ShopNumber.prototype.setCurrencyUnit = function(currencyUnit) {
  3079.     this._currencyUnit = currencyUnit;
  3080.     this.refresh();
  3081. };

  3083. Window_ShopNumber.prototype.createButtons = function() {
  3084.     var bitmap = ImageManager.loadSystem('ButtonSet');
  3085.     var buttonWidth = 48;
  3086.     var buttonHeight = 48;
  3087.     this._buttons = [];
  3088.     for (var i = 0; i < 5; i++) {
  3089.         var button = new Sprite_Button();
  3090.         var x = buttonWidth * i;
  3091.         var w = buttonWidth * (i === 4 ? 2 : 1);
  3092.         button.bitmap = bitmap;
  3093.         button.setColdFrame(x, 0, w, buttonHeight);
  3094.         button.setHotFrame(x, buttonHeight, w, buttonHeight);
  3095.         button.visible = false;
  3096.         this._buttons.push(button);
  3097.         this.addChild(button);
  3098.     }
  3099.     this._buttons[0].setClickHandler(this.onButtonDown2.bind(this));
  3100.     this._buttons[1].setClickHandler(this.onButtonDown.bind(this));
  3101.     this._buttons[2].setClickHandler(this.onButtonUp.bind(this));
  3102.     this._buttons[3].setClickHandler(this.onButtonUp2.bind(this));
  3103.     this._buttons[4].setClickHandler(this.onButtonOk.bind(this));
  3104. };

  3106. Window_ShopNumber.prototype.placeButtons = function() {
  3107.     var numButtons = this._buttons.length;
  3108.     var spacing = 16;
  3109.     var totalWidth = -spacing;
  3110.     for (var i = 0; i < numButtons; i++) {
  3111.         totalWidth += this._buttons[i].width + spacing;
  3112.     }
  3113.     var x = (this.width - totalWidth) / 2;
  3114.     for (var j = 0; j < numButtons; j++) {
  3115.         var button = this._buttons[j];
  3116.         button.x = x;
  3117.         button.y = this.buttonY();
  3118.         x += button.width + spacing;
  3119.     }
  3120. };

  3122. Window_ShopNumber.prototype.updateButtonsVisiblity = function() {
  3123.     if (TouchInput.date > Input.date) {
  3124.         this.showButtons();
  3125.     } else {
  3126.         this.hideButtons();
  3127.     }
  3128. };

  3130. Window_ShopNumber.prototype.showButtons = function() {
  3131.     for (var i = 0; i < this._buttons.length; i++) {
  3132.         this._buttons[i].visible = true;
  3133.     }
  3134. };

  3136. Window_ShopNumber.prototype.hideButtons = function() {
  3137.     for (var i = 0; i < this._buttons.length; i++) {
  3138.         this._buttons[i].visible = false;
  3139.     }
  3140. };

  3142. Window_ShopNumber.prototype.refresh = function() {
  3143.     this.contents.clear();
  3144.     this.drawItemName(this._item, 0, this.itemY());
  3145.     this.drawMultiplicationSign();
  3146.     this.drawNumber();
  3147.     this.drawTotalPrice();
  3148. };

  3150. Window_ShopNumber.prototype.drawMultiplicationSign = function() {
  3151.     var sign = '\u00d7';
  3152.     var width = this.textWidth(sign);
  3153.     var x = this.cursorX() - width * 2;
  3154.     var y = this.itemY();
  3155.     this.resetTextColor();
  3156.     this.drawText(sign, x, y, width);
  3157. };

  3159. Window_ShopNumber.prototype.drawNumber = function() {
  3160.     var x = this.cursorX();
  3161.     var y = this.itemY();
  3162.     var width = this.cursorWidth() - this.textPadding();
  3163.     this.resetTextColor();
  3164.     this.drawText(this._number, x, y, width, 'right');
  3165. };

  3167. Window_ShopNumber.prototype.drawTotalPrice = function() {
  3168.     var total = this._price * this._number;
  3169.     var width = this.contentsWidth() - this.textPadding();
  3170.     this.drawCurrencyValue(total, this._currencyUnit, 0, this.priceY(), width);
  3171. };

  3173. Window_ShopNumber.prototype.itemY = function() {
  3174.     return Math.round(this.contentsHeight() / 2 - this.lineHeight() * 1.5);
  3175. };

  3177. Window_ShopNumber.prototype.priceY = function() {
  3178.     return Math.round(this.contentsHeight() / 2 + this.lineHeight() / 2);
  3179. };

  3181. Window_ShopNumber.prototype.buttonY = function() {
  3182.     return Math.round(this.priceY() + this.lineHeight() * 2.5);
  3183. };

  3185. Window_ShopNumber.prototype.cursorWidth = function() {
  3186.     var digitWidth = this.textWidth('0');
  3187.     return this.maxDigits() * digitWidth + this.textPadding() * 2;
  3188. };

  3190. Window_ShopNumber.prototype.cursorX = function() {
  3191.     return this.contentsWidth() - this.cursorWidth() - this.textPadding();
  3192. };

  3194. Window_ShopNumber.prototype.maxDigits = function() {
  3195.     return 2;
  3196. };

  3198. Window_ShopNumber.prototype.update = function() {
  3199.     Window_Selectable.prototype.update.call(this);
  3200.     this.processNumberChange();
  3201. };

  3203. Window_ShopNumber.prototype.isOkTriggered = function() {
  3204.     return Input.isTriggered('ok');
  3205. };

  3207. Window_ShopNumber.prototype.playOkSound = function() {
  3208. };

  3210. Window_ShopNumber.prototype.processNumberChange = function() {
  3211.     if (this.isOpenAndActive()) {
  3212.         if (Input.isRepeated('right')) {
  3213.             this.changeNumber(1);
  3214.         }
  3215.         if (Input.isRepeated('left')) {
  3216.             this.changeNumber(-1);
  3217.         }
  3218.         if (Input.isRepeated('up')) {
  3219.             this.changeNumber(10);
  3220.         }
  3221.         if (Input.isRepeated('down')) {
  3222.             this.changeNumber(-10);
  3223.         }
  3224.     }
  3225. };

  3227. Window_ShopNumber.prototype.changeNumber = function(amount) {
  3228.     var lastNumber = this._number;
  3229.     this._number = (this._number + amount).clamp(1, this._max);
  3230.     if (this._number !== lastNumber) {
  3231.         SoundManager.playCursor();
  3232.         this.refresh();
  3233.     }
  3234. };

  3236. Window_ShopNumber.prototype.updateCursor = function() {
  3237.     this.setCursorRect(this.cursorX(), this.itemY(),
  3238.                        this.cursorWidth(), this.lineHeight());
  3239. };

  3241. Window_ShopNumber.prototype.onButtonUp = function() {
  3242.     this.changeNumber(1);
  3243. };

  3245. Window_ShopNumber.prototype.onButtonUp2 = function() {
  3246.     this.changeNumber(10);
  3247. };

  3249. Window_ShopNumber.prototype.onButtonDown = function() {
  3250.     this.changeNumber(-1);
  3251. };

  3253. Window_ShopNumber.prototype.onButtonDown2 = function() {
  3254.     this.changeNumber(-10);
  3255. };

  3257. Window_ShopNumber.prototype.onButtonOk = function() {
  3258.     this.processOk();
  3259. };

  3261. //-----------------------------------------------------------------------------
  3262. // Window_ShopStatus
  3263. //
  3264. // The window for displaying number of items in possession and the actor's
  3265. // equipment on the shop screen.

  3267. function Window_ShopStatus() {
  3268.     this.initialize.apply(this, arguments);
  3269. }

  3271. Window_ShopStatus.prototype = Object.create(Window_Base.prototype);
  3272. Window_ShopStatus.prototype.constructor = Window_ShopStatus;

  3274. Window_ShopStatus.prototype.initialize = function(x, y, width, height) {
  3275.     Window_Base.prototype.initialize.call(this, x, y, width, height);
  3276.     this._item = null;
  3277.     this._pageIndex = 0;
  3278.     this.refresh();
  3279. };

  3281. Window_ShopStatus.prototype.refresh = function() {
  3282.     this.contents.clear();
  3283.     if (this._item) {
  3284.         var x = this.textPadding();
  3285.         this.drawPossession(x, 0);
  3286.         if (this.isEquipItem()) {
  3287.             this.drawEquipInfo(x, this.lineHeight() * 2);
  3288.         }
  3289.     }
  3290. };

  3292. Window_ShopStatus.prototype.setItem = function(item) {
  3293.     this._item = item;
  3294.     this.refresh();
  3295. };

  3297. Window_ShopStatus.prototype.isEquipItem = function() {
  3298.     return DataManager.isWeapon(this._item) || DataManager.isArmor(this._item);
  3299. };

  3301. Window_ShopStatus.prototype.drawPossession = function(x, y) {
  3302.     var width = this.contents.width - this.textPadding() - x;
  3303.     var possessionWidth = this.textWidth('0000');
  3304.     this.changeTextColor(this.systemColor());
  3305.     this.drawText(TextManager.possession, x, y, width - possessionWidth);
  3306.     this.resetTextColor();
  3307.     this.drawText($gameParty.numItems(this._item), x, y, width, 'right');
  3308. };

  3310. Window_ShopStatus.prototype.drawEquipInfo = function(x, y) {
  3311.     var members = this.statusMembers();
  3312.     for (var i = 0; i < members.length; i++) {
  3313.         this.drawActorEquipInfo(x, y + this.lineHeight() * (i * 2.4), members[i]);
  3314.     }
  3315. };

  3317. Window_ShopStatus.prototype.statusMembers = function() {
  3318.     var start = this._pageIndex * this.pageSize();
  3319.     var end = start + this.pageSize();
  3320.     return $gameParty.members().slice(start, end);
  3321. };

  3323. Window_ShopStatus.prototype.pageSize = function() {
  3324.     return 4;
  3325. };

  3327. Window_ShopStatus.prototype.maxPages = function() {
  3328.     return Math.floor(($gameParty.size() + this.pageSize() - 1) / this.pageSize());
  3329. };

  3331. Window_ShopStatus.prototype.drawActorEquipInfo = function(x, y, actor) {
  3332.     var enabled = actor.canEquip(this._item);
  3333.     this.changePaintOpacity(enabled);
  3334.     this.resetTextColor();
  3335.     this.drawText(actor.name(), x, y, 168);
  3336.     var item1 = this.currentEquippedItem(actor, this._item.etypeId);
  3337.     if (enabled) {
  3338.         this.drawActorParamChange(x, y, actor, item1);
  3339.     }
  3340.     this.drawItemName(item1, x, y + this.lineHeight());
  3341.     this.changePaintOpacity(true);
  3342. };

  3344. Window_ShopStatus.prototype.drawActorParamChange = function(x, y, actor, item1) {
  3345.     var width = this.contents.width - this.textPadding() - x;
  3346.     var paramId = this.paramId();
  3347.     var change = this._item.params[paramId] - (item1 ? item1.params[paramId] : 0);
  3348.     this.changeTextColor(this.paramchangeTextColor(change));
  3349.     this.drawText((change > 0 ? '+' : '') + change, x, y, width, 'right');
  3350. };

  3352. Window_ShopStatus.prototype.paramId = function() {
  3353.     return DataManager.isWeapon(this._item) ? 2 : 3;
  3354. };

  3356. Window_ShopStatus.prototype.currentEquippedItem = function(actor, etypeId) {
  3357.     var list = [];
  3358.     var equips = actor.equips();
  3359.     var slots = actor.equipSlots();
  3360.     for (var i = 0; i < slots.length; i++) {
  3361.         if (slots[i] === etypeId) {
  3362.             list.push(equips[i]);
  3363.         }
  3364.     }
  3365.     var paramId = this.paramId();
  3366.     var worstParam = Number.MAX_VALUE;
  3367.     var worstItem = null;
  3368.     for (var j = 0; j < list.length; j++) {
  3369.         if (list[j] && list[j].params[paramId] < worstParam) {
  3370.             worstParam = list[j].params[paramId];
  3371.             worstItem = list[j];
  3372.         }
  3373.     }
  3374.     return worstItem;
  3375. };

  3377. Window_ShopStatus.prototype.update = function() {
  3378.     Window_Base.prototype.update.call(this);
  3379.     this.updatePage();
  3380. };

  3382. Window_ShopStatus.prototype.updatePage = function() {
  3383.     if (this.isPageChangeEnabled() && this.isPageChangeRequested()) {
  3384.         this.changePage();
  3385.     }
  3386. };

  3388. Window_ShopStatus.prototype.isPageChangeEnabled = function() {
  3389.     return this.visible && this.maxPages() >= 2;
  3390. };

  3392. Window_ShopStatus.prototype.isPageChangeRequested = function() {
  3393.     if (Input.isTriggered('shift')) {
  3394.         return true;
  3395.     }
  3396.     if (TouchInput.isTriggered() && this.isTouchedInsideFrame()) {
  3397.         return true;
  3398.     }
  3399.     return false;
  3400. };

  3402. Window_ShopStatus.prototype.isTouchedInsideFrame = function() {
  3403.     var x = this.canvasToLocalX(TouchInput.x);
  3404.     var y = this.canvasToLocalY(TouchInput.y);
  3405.     return x >= 0 && y >= 0 && x < this.width && y < this.height;
  3406. };

  3408. Window_ShopStatus.prototype.changePage = function() {
  3409.     this._pageIndex = (this._pageIndex + 1) % this.maxPages();
  3410.     this.refresh();
  3411.     SoundManager.playCursor();
  3412. };

  3414. //-----------------------------------------------------------------------------
  3415. // Window_NameEdit
  3416. //
  3417. // The window for editing an actor's name on the name input screen.

  3419. function Window_NameEdit() {
  3420.     this.initialize.apply(this, arguments);
  3421. }

  3423. Window_NameEdit.prototype = Object.create(Window_Base.prototype);
  3424. Window_NameEdit.prototype.constructor = Window_NameEdit;

  3426. Window_NameEdit.prototype.initialize = function(actor, maxLength) {
  3427.     var width = this.windowWidth();
  3428.     var height = this.windowHeight();
  3429.     var x = (Graphics.boxWidth - width) / 2;
  3430.     var y = (Graphics.boxHeight - (height + this.fittingHeight(9) + 8)) / 2;
  3431.     Window_Base.prototype.initialize.call(this, x, y, width, height);
  3432.     this._actor = actor;
  3433.     this._name = actor.name().slice(0, this._maxLength);
  3434.     this._index = this._name.length;
  3435.     this._maxLength = maxLength;
  3436.     this._defaultName = this._name;
  3437.     this.deactivate();
  3438.     this.refresh();
  3439.     ImageManager.reserveFace(actor.faceName());
  3440. };

  3442. Window_NameEdit.prototype.windowWidth = function() {
  3443.     return 480;
  3444. };

  3446. Window_NameEdit.prototype.windowHeight = function() {
  3447.     return this.fittingHeight(4);
  3448. };

  3450. Window_NameEdit.prototype.name = function() {
  3451.     return this._name;
  3452. };

  3454. Window_NameEdit.prototype.restoreDefault = function() {
  3455.     this._name = this._defaultName;
  3456.     this._index = this._name.length;
  3457.     this.refresh();
  3458.     return this._name.length > 0;
  3459. };

  3461. Window_NameEdit.prototype.add = function(ch) {
  3462.     if (this._index < this._maxLength) {
  3463.         this._name += ch;
  3464.         this._index++;
  3465.         this.refresh();
  3466.         return true;
  3467.     } else {
  3468.         return false;
  3469.     }
  3470. };

  3472. Window_NameEdit.prototype.back = function() {
  3473.     if (this._index > 0) {
  3474.         this._index--;
  3475.         this._name = this._name.slice(0, this._index);
  3476.         this.refresh();
  3477.         return true;
  3478.     } else {
  3479.         return false;
  3480.     }
  3481. };

  3483. Window_NameEdit.prototype.faceWidth = function() {
  3484.     return 144;
  3485. };

  3487. Window_NameEdit.prototype.charWidth = function() {
  3488.     var text = $gameSystem.isJapanese() ? '\uff21' : 'A';
  3489.     return this.textWidth(text);
  3490. };

  3492. Window_NameEdit.prototype.left = function() {
  3493.     var nameCenter = (this.contentsWidth() + this.faceWidth()) / 2;
  3494.     var nameWidth = (this._maxLength + 1) * this.charWidth();
  3495.     return Math.min(nameCenter - nameWidth / 2, this.contentsWidth() - nameWidth);
  3496. };

  3498. Window_NameEdit.prototype.itemRect = function(index) {
  3499.     return {
  3500.         x: this.left() + index * this.charWidth(),
  3501.         y: 54,
  3502.         width: this.charWidth(),
  3503.         height: this.lineHeight()
  3504.     };
  3505. };

  3507. Window_NameEdit.prototype.underlineRect = function(index) {
  3508.     var rect = this.itemRect(index);
  3509.     rect.x++;
  3510.     rect.y += rect.height - 4;
  3511.     rect.width -= 2;
  3512.     rect.height = 2;
  3513.     return rect;
  3514. };

  3516. Window_NameEdit.prototype.underlineColor = function() {
  3517.     return this.normalColor();
  3518. };

  3520. Window_NameEdit.prototype.drawUnderline = function(index) {
  3521.     var rect = this.underlineRect(index);
  3522.     var color = this.underlineColor();
  3523.     this.contents.paintOpacity = 48;
  3524.     this.contents.fillRect(rect.x, rect.y, rect.width, rect.height, color);
  3525.     this.contents.paintOpacity = 255;
  3526. };

  3528. Window_NameEdit.prototype.drawChar = function(index) {
  3529.     var rect = this.itemRect(index);
  3530.     this.resetTextColor();
  3531.     this.drawText(this._name[index] || '', rect.x, rect.y);
  3532. };

  3534. Window_NameEdit.prototype.refresh = function() {
  3535.     this.contents.clear();
  3536.     this.drawActorFace(this._actor, 0, 0);
  3537.     for (var i = 0; i < this._maxLength; i++) {
  3538.         this.drawUnderline(i);
  3539.     }
  3540.     for (var j = 0; j < this._name.length; j++) {
  3541.         this.drawChar(j);
  3542.     }
  3543.     var rect = this.itemRect(this._index);
  3544.     this.setCursorRect(rect.x, rect.y, rect.width, rect.height);
  3545. };

  3547. //-----------------------------------------------------------------------------
  3548. // Window_NameInput
  3549. //
  3550. // The window for selecting text characters on the name input screen.

  3552. function Window_NameInput() {
  3553.     this.initialize.apply(this, arguments);
  3554. }

  3556. Window_NameInput.prototype = Object.create(Window_Selectable.prototype);
  3557. Window_NameInput.prototype.constructor = Window_NameInput;
  3558. Window_NameInput.LATIN1 =
  3559.         [ 'A','B','C','D','E',  'a','b','c','d','e',
  3560.           'F','G','H','I','J',  'f','g','h','i','j',
  3561.           'K','L','M','N','O',  'k','l','m','n','o',
  3562.           'P','Q','R','S','T',  'p','q','r','s','t',
  3563.           'U','V','W','X','Y',  'u','v','w','x','y',
  3564.           'Z','[',']','^','_',  'z','{','}','|','~',
  3565.           '0','1','2','3','4',  '!','#',','%','&',
  3566.           '5','6','7','8','9',  '(',')','*','+','-',
  3567.           '/','=','@','<','>',  ':',';',' ','Page','OK' ];
  3568. Window_NameInput.LATIN2 =
  3569.         [ 'Á','É','Í','Ó','Ú',  'á','é','í','ó','ú',
  3570.           'À','È','Ì','Ò','Ù',  'à','è','ì','ò','ù',
  3571.           'Â','Ê','Î','Ô','Û',  'â','ê','î','ô','û',
  3572.           'Ä','Ë','Ï','Ö','Ü',  'ä','ë','ï','ö','ü',
  3573.           'Ā','Ē','Ī','Ō','Ū',  'ā','ē','ī','ō','ū',
  3574.           'Ã','Å','Æ','Ç','Ð',  'ã','å','æ','ç','ð',
  3575.           'Ñ','Õ','Ø','Š','Ŵ',  'ñ','õ','ø','š','ŵ',
  3576.           'Ý','Ŷ','Ÿ','Ž','Þ',  'ý','ÿ','ŷ','ž','þ',
  3577.           'IJ','Œ','ij','œ','ß',  '«','»',' ','Page','OK' ];
  3578. Window_NameInput.RUSSIA =
  3579.         [ 'А','Б','В','Г','Д',  'а','б','в','г','д',
  3580.           'Е','Ё','Ж','З','И',  'е','ё','ж','з','и',
  3581.           'Й','К','Л','М','Н',  'й','к','л','м','н',
  3582.           'О','П','Р','С','Т',  'о','п','р','с','т',
  3583.           'У','Ф','Х','Ц','Ч',  'у','ф','х','ц','ч',
  3584.           'Ш','Щ','Ъ','Ы','Ь',  'ш','щ','ъ','ы','ь',
  3585.           'Э','Ю','Я','^','_',  'э','ю','я','%','&',
  3586.           '0','1','2','3','4',  '(',')','*','+','-',
  3587.           '5','6','7','8','9',  ':',';',' ','','OK' ];
  3588. Window_NameInput.JAPAN1 =
  3589.         [ 'あ','い','う','え','お',  'が','ぎ','ぐ','げ','ご',
  3590.           'か','き','く','け','こ',  'ざ','じ','ず','ぜ','ぞ',
  3591.           'さ','し','す','せ','そ',  'だ','ぢ','づ','で','ど',
  3592.           'た','ち','つ','て','と',  'ば','び','ぶ','べ','ぼ',
  3593.           'な','に','ぬ','ね','の',  'ぱ','ぴ','ぷ','ぺ','ぽ',
  3594.           'は','ひ','ふ','へ','ほ',  'ぁ','ぃ','ぅ','ぇ','ぉ',
  3595.           'ま','み','む','め','も',  'っ','ゃ','ゅ','ょ','ゎ',
  3596.           'や','ゆ','よ','わ','ん',  'ー','～','・','＝','☆',
  3597.           'ら','り','る','れ','ろ',  'ゔ','を','　','カナ','決定' ];
  3598. Window_NameInput.JAPAN2 =
  3599.         [ 'ア','イ','ウ','エ','オ',  'ガ','ギ','グ','ゲ','ゴ',
  3600.           'カ','キ','ク','ケ','コ',  'ザ','ジ','ズ','ゼ','ゾ',
  3601.           'サ','シ','ス','セ','ソ',  'ダ','ヂ','ヅ','デ','ド',
  3602.           'タ','チ','ツ','テ','ト',  'バ','ビ','ブ','ベ','ボ',
  3603.           'ナ','ニ','ヌ','ネ','ノ',  'パ','ピ','プ','ペ','ポ',
  3604.           'ハ','ヒ','フ','ヘ','ホ',  'ァ','ィ','ゥ','ェ','ォ',
  3605.           'マ','ミ','ム','メ','モ',  'ッ','ャ','ュ','ョ','ヮ',
  3606.           'ヤ','ユ','ヨ','ワ','ン',  'ー','～','・','＝','☆',
  3607.           'ラ','リ','ル','レ','ロ',  'ヴ','ヲ','　','英数','決定' ];
  3608. Window_NameInput.JAPAN3 =
  3609.         [ 'Ａ','Ｂ','Ｃ','Ｄ','Ｅ',  'ａ','ｂ','ｃ','ｄ','ｅ',
  3610.           'Ｆ','Ｇ','Ｈ','Ｉ','Ｊ',  'ｆ','ｇ','ｈ','ｉ','ｊ',
  3611.           'Ｋ','Ｌ','Ｍ','Ｎ','Ｏ',  'ｋ','ｌ','ｍ','ｎ','ｏ',
  3612.           'Ｐ','Ｑ','Ｒ','Ｓ','Ｔ',  'ｐ','ｑ','ｒ','ｓ','ｔ',
  3613.           'Ｕ','Ｖ','Ｗ','Ｘ','Ｙ',  'ｕ','ｖ','ｗ','ｘ','ｙ',
  3614.           'Ｚ','［','］','＾','＿',  'ｚ','｛','｝','｜','～',
  3615.           '０','１','２','３','４',  '！','＃','＄','％','＆',
  3616.           '５','６','７','８','９',  '（','）','＊','＋','－',
  3617.           '／','＝','＠','＜','＞',  '：','；','　','かな','決定' ];

  3619. Window_NameInput.prototype.initialize = function(editWindow) {
  3620.     var x = editWindow.x;
  3621.     var y = editWindow.y + editWindow.height + 8;
  3622.     var width = editWindow.width;
  3623.     var height = this.windowHeight();
  3624.     Window_Selectable.prototype.initialize.call(this, x, y, width, height);
  3625.     this._editWindow = editWindow;
  3626.     this._page = 0;
  3627.     this._index = 0;
  3628.     this.refresh();
  3629.     this.updateCursor();
  3630.     this.activate();
  3631. };

  3633. Window_NameInput.prototype.windowHeight = function() {
  3634.     return this.fittingHeight(9);
  3635. };

  3637. Window_NameInput.prototype.table = function() {
  3638.     if ($gameSystem.isJapanese()) {
  3639.         return [Window_NameInput.JAPAN1,
  3640.                 Window_NameInput.JAPAN2,
  3641.                 Window_NameInput.JAPAN3];
  3642.     } else if ($gameSystem.isRussian()) {
  3643.         return [Window_NameInput.RUSSIA];
  3644.     } else {
  3645.         return [Window_NameInput.LATIN1,
  3646.                 Window_NameInput.LATIN2];
  3647.     }
  3648. };

  3650. Window_NameInput.prototype.maxCols = function() {
  3651.     return 10;
  3652. };

  3654. Window_NameInput.prototype.maxItems = function() {
  3655.     return 90;
  3656. };

  3658. Window_NameInput.prototype.character = function() {
  3659.     return this._index < 88 ? this.table()[this._page][this._index] : '';
  3660. };

  3662. Window_NameInput.prototype.isPageChange = function() {
  3663.     return this._index === 88;
  3664. };

  3666. Window_NameInput.prototype.isOk = function() {
  3667.     return this._index === 89;
  3668. };

  3670. Window_NameInput.prototype.itemRect = function(index) {
  3671.     return {
  3672.         x: index % 10 * 42 + Math.floor(index % 10 / 5) * 24,
  3673.         y: Math.floor(index / 10) * this.lineHeight(),
  3674.         width: 42,
  3675.         height: this.lineHeight()
  3676.     };
  3677. };

  3679. Window_NameInput.prototype.refresh = function() {
  3680.     var table = this.table();
  3681.     this.contents.clear();
  3682.     this.resetTextColor();
  3683.     for (var i = 0; i < 90; i++) {
  3684.         var rect = this.itemRect(i);
  3685.         rect.x += 3;
  3686.         rect.width -= 6;
  3687.         this.drawText(table[this._page][i], rect.x, rect.y, rect.width, 'center');
  3688.     }
  3689. };

  3691. Window_NameInput.prototype.updateCursor = function() {
  3692.     var rect = this.itemRect(this._index);
  3693.     this.setCursorRect(rect.x, rect.y, rect.width, rect.height);
  3694. };

  3696. Window_NameInput.prototype.isCursorMovable = function() {
  3697.     return this.active;
  3698. };

  3700. Window_NameInput.prototype.cursorDown = function(wrap) {
  3701.     if (this._index < 80 || wrap) {
  3702.         this._index = (this._index + 10) % 90;
  3703.     }
  3704. };

  3706. Window_NameInput.prototype.cursorUp = function(wrap) {
  3707.     if (this._index >= 10 || wrap) {
  3708.         this._index = (this._index + 80) % 90;
  3709.     }
  3710. };

  3712. Window_NameInput.prototype.cursorRight = function(wrap) {
  3713.     if (this._index % 10 < 9) {
  3714.         this._index++;
  3715.     } else if (wrap) {
  3716.         this._index -= 9;
  3717.     }
  3718. };

  3720. Window_NameInput.prototype.cursorLeft = function(wrap) {
  3721.     if (this._index % 10 > 0) {
  3722.         this._index--;
  3723.     } else if (wrap) {
  3724.         this._index += 9;
  3725.     }
  3726. };

  3728. Window_NameInput.prototype.cursorPagedown = function() {
  3729.     this._page = (this._page + 1) % this.table().length;
  3730.     this.refresh();
  3731. };

  3733. Window_NameInput.prototype.cursorPageup = function() {
  3734.     this._page = (this._page + this.table().length - 1) % this.table().length;
  3735.     this.refresh();
  3736. };

  3738. Window_NameInput.prototype.processCursorMove = function() {
  3739.     var lastPage = this._page;
  3740.     Window_Selectable.prototype.processCursorMove.call(this);
  3741.     this.updateCursor();
  3742.     if (this._page !== lastPage) {
  3743.         SoundManager.playCursor();
  3744.     }
  3745. };

  3747. Window_NameInput.prototype.processHandling = function() {
  3748.     if (this.isOpen() && this.active) {
  3749.         if (Input.isTriggered('shift')) {
  3750.             this.processJump();
  3751.         }
  3752.         if (Input.isRepeated('cancel')) {
  3753.             this.processBack();
  3754.         }
  3755.         if (Input.isRepeated('ok')) {
  3756.             this.processOk();
  3757.         }
  3758.     }
  3759. };

  3761. Window_NameInput.prototype.isCancelEnabled = function() {
  3762.     return true;
  3763. };

  3765. Window_NameInput.prototype.processCancel = function() {
  3766.     this.processBack();
  3767. };

  3769. Window_NameInput.prototype.processJump = function() {
  3770.     if (this._index !== 89) {
  3771.         this._index = 89;
  3772.         SoundManager.playCursor();
  3773.     }
  3774. };

  3776. Window_NameInput.prototype.processBack = function() {
  3777.     if (this._editWindow.back()) {
  3778.         SoundManager.playCancel();
  3779.     }
  3780. };

  3782. Window_NameInput.prototype.processOk = function() {
  3783.     if (this.character()) {
  3784.         this.onNameAdd();
  3785.     } else if (this.isPageChange()) {
  3786.         SoundManager.playOk();
  3787.         this.cursorPagedown();
  3788.     } else if (this.isOk()) {
  3789.         this.onNameOk();
  3790.     }
  3791. };

  3793. Window_NameInput.prototype.onNameAdd = function() {
  3794.     if (this._editWindow.add(this.character())) {
  3795.         SoundManager.playOk();
  3796.     } else {
  3797.         SoundManager.playBuzzer();
  3798.     }
  3799. };

  3801. Window_NameInput.prototype.onNameOk = function() {
  3802.     if (this._editWindow.name() === '') {
  3803.         if (this._editWindow.restoreDefault()) {
  3804.             SoundManager.playOk();
  3805.         } else {
  3806.             SoundManager.playBuzzer();
  3807.         }
  3808.     } else {
  3809.         SoundManager.playOk();
  3810.         this.callOkHandler();
  3811.     }
  3812. };

  3814. //-----------------------------------------------------------------------------
  3815. // Window_ChoiceList
  3816. //
  3817. // The window used for the event command [Show Choices].

  3819. function Window_ChoiceList() {
  3820.     this.initialize.apply(this, arguments);
  3821. }

  3823. Window_ChoiceList.prototype = Object.create(Window_Command.prototype);
  3824. Window_ChoiceList.prototype.constructor = Window_ChoiceList;

  3826. Window_ChoiceList.prototype.initialize = function(messageWindow) {
  3827.     this._messageWindow = messageWindow;
  3828.     Window_Command.prototype.initialize.call(this, 0, 0);
  3829.     this.openness = 0;
  3830.     this.deactivate();
  3831.     this._background = 0;
  3832. };

  3834. Window_ChoiceList.prototype.start = function() {
  3835.     this.updatePlacement();
  3836.     this.updateBackground();
  3837.     this.refresh();
  3838.     this.selectDefault();
  3839.     this.open();
  3840.     this.activate();
  3841. };

  3843. Window_ChoiceList.prototype.selectDefault = function() {
  3844.     this.select($gameMessage.choiceDefaultType());
  3845. };

  3847. Window_ChoiceList.prototype.updatePlacement = function() {
  3848.     var positionType = $gameMessage.choicePositionType();
  3849.     var messageY = this._messageWindow.y;
  3850.     this.width = this.windowWidth();
  3851.     this.height = this.windowHeight();
  3852.     switch (positionType) {
  3853.     case 0:
  3854.         this.x = 0;
  3855.         break;
  3856.     case 1:
  3857.         this.x = (Graphics.boxWidth - this.width) / 2;
  3858.         break;
  3859.     case 2:
  3860.         this.x = Graphics.boxWidth - this.width;
  3861.         break;
  3862.     }
  3863.     if (messageY >= Graphics.boxHeight / 2) {
  3864.         this.y = messageY - this.height;
  3865.     } else {
  3866.         this.y = messageY + this._messageWindow.height;
  3867.     }
  3868. };

  3870. Window_ChoiceList.prototype.updateBackground = function() {
  3871.     this._background = $gameMessage.choiceBackground();
  3872.     this.setBackgroundType(this._background);
  3873. };

  3875. Window_ChoiceList.prototype.windowWidth = function() {
  3876.     var width = this.maxChoiceWidth() + this.padding * 2;
  3877.     return Math.min(width, Graphics.boxWidth);
  3878. };

  3880. Window_ChoiceList.prototype.numVisibleRows = function() {
  3881.     var messageY = this._messageWindow.y;
  3882.     var messageHeight = this._messageWindow.height;
  3883.     var centerY = Graphics.boxHeight / 2;
  3884.     var choices = $gameMessage.choices();
  3885.     var numLines = choices.length;
  3886.     var maxLines = 8;
  3887.     if (messageY < centerY && messageY + messageHeight > centerY) {
  3888.         maxLines = 4;
  3889.     }
  3890.     if (numLines > maxLines) {
  3891.         numLines = maxLines;
  3892.     }
  3893.     return numLines;
  3894. };

  3896. Window_ChoiceList.prototype.maxChoiceWidth = function() {
  3897.     var maxWidth = 96;
  3898.     var choices = $gameMessage.choices();
  3899.     for (var i = 0; i < choices.length; i++) {
  3900.         var choiceWidth = this.textWidthEx(choices[i]) + this.textPadding() * 2;
  3901.         if (maxWidth < choiceWidth) {
  3902.             maxWidth = choiceWidth;
  3903.         }
  3904.     }
  3905.     return maxWidth;
  3906. };

  3908. Window_ChoiceList.prototype.textWidthEx = function(text) {
  3909.     return this.drawTextEx(text, 0, this.contents.height);
  3910. };

  3912. Window_ChoiceList.prototype.contentsHeight = function() {
  3913.     return this.maxItems() * this.itemHeight();
  3914. };

  3916. Window_ChoiceList.prototype.makeCommandList = function() {
  3917.     var choices = $gameMessage.choices();
  3918.     for (var i = 0; i < choices.length; i++) {
  3919.         this.addCommand(choices[i], 'choice');
  3920.     }
  3921. };

  3923. Window_ChoiceList.prototype.drawItem = function(index) {
  3924.     var rect = this.itemRectForText(index);
  3925.     this.drawTextEx(this.commandName(index), rect.x, rect.y);
  3926. };

  3928. Window_ChoiceList.prototype.isCancelEnabled = function() {
  3929.     return $gameMessage.choiceCancelType() !== -1;
  3930. };

  3932. Window_ChoiceList.prototype.isOkTriggered = function() {
  3933.     return Input.isTriggered('ok');
  3934. };

  3936. Window_ChoiceList.prototype.callOkHandler = function() {
  3937.     $gameMessage.onChoice(this.index());
  3938.     this._messageWindow.terminateMessage();
  3939.     this.close();
  3940. };

  3942. Window_ChoiceList.prototype.callCancelHandler = function() {
  3943.     $gameMessage.onChoice($gameMessage.choiceCancelType());
  3944.     this._messageWindow.terminateMessage();
  3945.     this.close();
  3946. };

  3948. //-----------------------------------------------------------------------------
  3949. // Window_NumberInput
  3950. //
  3951. // The window used for the event command [Input Number].

  3953. function Window_NumberInput() {
  3954.     this.initialize.apply(this, arguments);
  3955. }

  3957. Window_NumberInput.prototype = Object.create(Window_Selectable.prototype);
  3958. Window_NumberInput.prototype.constructor = Window_NumberInput;

  3960. Window_NumberInput.prototype.initialize = function(messageWindow) {
  3961.     this._messageWindow = messageWindow;
  3962.     Window_Selectable.prototype.initialize.call(this, 0, 0, 0, 0);
  3963.     this._number = 0;
  3964.     this._maxDigits = 1;
  3965.     this.openness = 0;
  3966.     this.createButtons();
  3967.     this.deactivate();
  3968. };

  3970. Window_NumberInput.prototype.start = function() {
  3971.     this._maxDigits = $gameMessage.numInputMaxDigits();
  3972.     this._number = $gameVariables.value($gameMessage.numInputVariableId());
  3973.     this._number = this._number.clamp(0, Math.pow(10, this._maxDigits) - 1);
  3974.     this.updatePlacement();
  3975.     this.placeButtons();
  3976.     this.updateButtonsVisiblity();
  3977.     this.createContents();
  3978.     this.refresh();
  3979.     this.open();
  3980.     this.activate();
  3981.     this.select(0);
  3982. };

  3984. Window_NumberInput.prototype.updatePlacement = function() {
  3985.     var messageY = this._messageWindow.y;
  3986.     var spacing = 8;
  3987.     this.width = this.windowWidth();
  3988.     this.height = this.windowHeight();
  3989.     this.x = (Graphics.boxWidth - this.width) / 2;
  3990.     if (messageY >= Graphics.boxHeight / 2) {
  3991.         this.y = messageY - this.height - spacing;
  3992.     } else {
  3993.         this.y = messageY + this._messageWindow.height + spacing;
  3994.     }
  3995. };

  3997. Window_NumberInput.prototype.windowWidth = function() {
  3998.     return this.maxCols() * this.itemWidth() + this.padding * 2;
  3999. };

  4001. Window_NumberInput.prototype.windowHeight = function() {
  4002.     return this.fittingHeight(1);
  4003. };

  4005. Window_NumberInput.prototype.maxCols = function() {
  4006.     return this._maxDigits;
  4007. };

  4009. Window_NumberInput.prototype.maxItems = function() {
  4010.     return this._maxDigits;
  4011. };

  4013. Window_NumberInput.prototype.spacing = function() {
  4014.     return 0;
  4015. };

  4017. Window_NumberInput.prototype.itemWidth = function() {
  4018.     return 32;
  4019. };

  4021. Window_NumberInput.prototype.createButtons = function() {
  4022.     var bitmap = ImageManager.loadSystem('ButtonSet');
  4023.     var buttonWidth = 48;
  4024.     var buttonHeight = 48;
  4025.     this._buttons = [];
  4026.     for (var i = 0; i < 3; i++) {
  4027.         var button = new Sprite_Button();
  4028.         var x = buttonWidth * [1, 2, 4][i];
  4029.         var w = buttonWidth * (i === 2 ? 2 : 1);
  4030.         button.bitmap = bitmap;
  4031.         button.setColdFrame(x, 0, w, buttonHeight);
  4032.         button.setHotFrame(x, buttonHeight, w, buttonHeight);
  4033.         button.visible = false;
  4034.         this._buttons.push(button);
  4035.         this.addChild(button);
  4036.     }
  4037.     this._buttons[0].setClickHandler(this.onButtonDown.bind(this));
  4038.     this._buttons[1].setClickHandler(this.onButtonUp.bind(this));
  4039.     this._buttons[2].setClickHandler(this.onButtonOk.bind(this));
  4040. };

  4042. Window_NumberInput.prototype.placeButtons = function() {
  4043.     var numButtons = this._buttons.length;
  4044.     var spacing = 16;
  4045.     var totalWidth = -spacing;
  4046.     for (var i = 0; i < numButtons; i++) {
  4047.         totalWidth += this._buttons[i].width + spacing;
  4048.     }
  4049.     var x = (this.width - totalWidth) / 2;
  4050.     for (var j = 0; j < numButtons; j++) {
  4051.         var button = this._buttons[j];
  4052.         button.x = x;
  4053.         button.y = this.buttonY();
  4054.         x += button.width + spacing;
  4055.     }
  4056. };

  4058. Window_NumberInput.prototype.updateButtonsVisiblity = function() {
  4059.     if (TouchInput.date > Input.date) {
  4060.         this.showButtons();
  4061.     } else {
  4062.         this.hideButtons();
  4063.     }
  4064. };

  4066. Window_NumberInput.prototype.showButtons = function() {
  4067.     for (var i = 0; i < this._buttons.length; i++) {
  4068.         this._buttons[i].visible = true;
  4069.     }
  4070. };

  4072. Window_NumberInput.prototype.hideButtons = function() {
  4073.     for (var i = 0; i < this._buttons.length; i++) {
  4074.         this._buttons[i].visible = false;
  4075.     }
  4076. };

  4078. Window_NumberInput.prototype.buttonY = function() {
  4079.     var spacing = 8;
  4080.     if (this._messageWindow.y >= Graphics.boxHeight / 2) {
  4081.         return 0 - this._buttons[0].height - spacing;
  4082.     } else {
  4083.         return this.height + spacing;
  4084.     }
  4085. };

  4087. Window_NumberInput.prototype.update = function() {
  4088.     Window_Selectable.prototype.update.call(this);
  4089.     this.processDigitChange();
  4090. };

  4092. Window_NumberInput.prototype.processDigitChange = function() {
  4093.     if (this.isOpenAndActive()) {
  4094.         if (Input.isRepeated('up')) {
  4095.             this.changeDigit(true);
  4096.         } else if (Input.isRepeated('down')) {
  4097.             this.changeDigit(false);
  4098.         }
  4099.     }
  4100. };

  4102. Window_NumberInput.prototype.changeDigit = function(up) {
  4103.     var index = this.index();
  4104.     var place = Math.pow(10, this._maxDigits - 1 - index);
  4105.     var n = Math.floor(this._number / place) % 10;
  4106.     this._number -= n * place;
  4107.     if (up) {
  4108.         n = (n + 1) % 10;
  4109.     } else {
  4110.         n = (n + 9) % 10;
  4111.     }
  4112.     this._number += n * place;
  4113.     this.refresh();
  4114.     SoundManager.playCursor();
  4115. };

  4117. Window_NumberInput.prototype.isTouchOkEnabled = function() {
  4118.     return false;
  4119. };

  4121. Window_NumberInput.prototype.isOkEnabled = function() {
  4122.     return true;
  4123. };

  4125. Window_NumberInput.prototype.isCancelEnabled = function() {
  4126.     return false;
  4127. };

  4129. Window_NumberInput.prototype.isOkTriggered = function() {
  4130.     return Input.isTriggered('ok');
  4131. };

  4133. Window_NumberInput.prototype.processOk = function() {
  4134.     SoundManager.playOk();
  4135.     $gameVariables.setValue($gameMessage.numInputVariableId(), this._number);
  4136.     this._messageWindow.terminateMessage();
  4137.     this.updateInputData();
  4138.     this.deactivate();
  4139.     this.close();
  4140. };

  4142. Window_NumberInput.prototype.drawItem = function(index) {
  4143.     var rect = this.itemRect(index);
  4144.     var align = 'center';
  4145.     var s = this._number.padZero(this._maxDigits);
  4146.     var c = s.slice(index, index + 1);
  4147.     this.resetTextColor();
  4148.     this.drawText(c, rect.x, rect.y, rect.width, align);
  4149. };

  4151. Window_NumberInput.prototype.onButtonUp = function() {
  4152.     this.changeDigit(true);
  4153. };

  4155. Window_NumberInput.prototype.onButtonDown = function() {
  4156.     this.changeDigit(false);
  4157. };

  4159. Window_NumberInput.prototype.onButtonOk = function() {
  4160.     this.processOk();
  4161.     this.hideButtons();
  4162. };

  4164. //-----------------------------------------------------------------------------
  4165. // Window_EventItem
  4166. //
  4167. // The window used for the event command [Select Item].

  4169. function Window_EventItem() {
  4170.     this.initialize.apply(this, arguments);
  4171. }

  4173. Window_EventItem.prototype = Object.create(Window_ItemList.prototype);
  4174. Window_EventItem.prototype.constructor = Window_EventItem;

  4176. Window_EventItem.prototype.initialize = function(messageWindow) {
  4177.     this._messageWindow = messageWindow;
  4178.     var width = Graphics.boxWidth;
  4179.     var height = this.windowHeight();
  4180.     Window_ItemList.prototype.initialize.call(this, 0, 0, width, height);
  4181.     this.openness = 0;
  4182.     this.deactivate();
  4183.     this.setHandler('ok',     this.onOk.bind(this));
  4184.     this.setHandler('cancel', this.onCancel.bind(this));
  4185. };

  4187. Window_EventItem.prototype.windowHeight = function() {
  4188.     return this.fittingHeight(this.numVisibleRows());
  4189. };

  4191. Window_EventItem.prototype.numVisibleRows = function() {
  4192.     return 4;
  4193. };

  4195. Window_EventItem.prototype.start = function() {
  4196.     this.refresh();
  4197.     this.updatePlacement();
  4198.     this.select(0);
  4199.     this.open();
  4200.     this.activate();
  4201. };

  4203. Window_EventItem.prototype.updatePlacement = function() {
  4204.     if (this._messageWindow.y >= Graphics.boxHeight / 2) {
  4205.         this.y = 0;
  4206.     } else {
  4207.         this.y = Graphics.boxHeight - this.height;
  4208.     }
  4209. };

  4211. Window_EventItem.prototype.includes = function(item) {
  4212.     var itypeId = $gameMessage.itemChoiceItypeId();
  4213.     return DataManager.isItem(item) && item.itypeId === itypeId;
  4214. };

  4216. Window_EventItem.prototype.isEnabled = function(item) {
  4217.     return true;
  4218. };

  4220. Window_EventItem.prototype.onOk = function() {
  4221.     var item = this.item();
  4222.     var itemId = item ? item.id : 0;
  4223.     $gameVariables.setValue($gameMessage.itemChoiceVariableId(), itemId);
  4224.     this._messageWindow.terminateMessage();
  4225.     this.close();
  4226. };

  4228. Window_EventItem.prototype.onCancel = function() {
  4229.     $gameVariables.setValue($gameMessage.itemChoiceVariableId(), 0);
  4230.     this._messageWindow.terminateMessage();
  4231.     this.close();
  4232. };

  4234. //-----------------------------------------------------------------------------
  4235. // Window_Message
  4236. //
  4237. // The window for displaying text messages.

  4239. function Window_Message() {
  4240.     this.initialize.apply(this, arguments);
  4241. }

  4243. Window_Message.prototype = Object.create(Window_Base.prototype);
  4244. Window_Message.prototype.constructor = Window_Message;

  4246. Window_Message.prototype.initialize = function() {
  4247.     var width = this.windowWidth();
  4248.     var height = this.windowHeight();
  4249.     var x = (Graphics.boxWidth - width) / 2;
  4250.     Window_Base.prototype.initialize.call(this, x, 0, width, height);
  4251.     this.openness = 0;
  4252.     this.initMembers();
  4253.     this.createSubWindows();
  4254.     this.updatePlacement();
  4255. };

  4257. Window_Message.prototype.initMembers = function() {
  4258.     this._imageReservationId = Utils.generateRuntimeId();
  4259.     this._background = 0;
  4260.     this._positionType = 2;
  4261.     this._waitCount = 0;
  4262.     this._faceBitmap = null;
  4263.     this._textState = null;
  4264.     this.clearFlags();
  4265. };

  4267. Window_Message.prototype.subWindows = function() {
  4268.     return [this._goldWindow, this._choiceWindow,
  4269.             this._numberWindow, this._itemWindow];
  4270. };

  4272. Window_Message.prototype.createSubWindows = function() {
  4273.     this._goldWindow = new Window_Gold(0, 0);
  4274.     this._goldWindow.x = Graphics.boxWidth - this._goldWindow.width;
  4275.     this._goldWindow.openness = 0;
  4276.     this._choiceWindow = new Window_ChoiceList(this);
  4277.     this._numberWindow = new Window_NumberInput(this);
  4278.     this._itemWindow = new Window_EventItem(this);
  4279. };

  4281. Window_Message.prototype.windowWidth = function() {
  4282.     return Graphics.boxWidth;
  4283. };

  4285. Window_Message.prototype.windowHeight = function() {
  4286.     return this.fittingHeight(this.numVisibleRows());
  4287. };

  4289. Window_Message.prototype.clearFlags = function() {
  4290.     this._showFast = false;
  4291.     this._lineShowFast = false;
  4292.     this._pauseSkip = false;
  4293. };

  4295. Window_Message.prototype.numVisibleRows = function() {
  4296.     return 4;
  4297. };

  4299. Window_Message.prototype.update = function() {
  4300.     this.checkToNotClose();
  4301.     Window_Base.prototype.update.call(this);
  4302.     while (!this.isOpening() && !this.isClosing()) {
  4303.         if (this.updateWait()) {
  4304.             return;
  4305.         } else if (this.updateLoading()) {
  4306.             return;
  4307.         } else if (this.updateInput()) {
  4308.             return;
  4309.         } else if (this.updateMessage()) {
  4310.             return;
  4311.         } else if (this.canStart()) {
  4312.             this.startMessage();
  4313.         } else {
  4314.             this.startInput();
  4315.             return;
  4316.         }
  4317.     }
  4318. };

  4320. Window_Message.prototype.checkToNotClose = function() {
  4321.     if (this.isClosing() && this.isOpen()) {
  4322.         if (this.doesContinue()) {
  4323.             this.open();
  4324.         }
  4325.     }
  4326. };

  4328. Window_Message.prototype.canStart = function() {
  4329.     return $gameMessage.hasText() && !$gameMessage.scrollMode();
  4330. };

  4332. Window_Message.prototype.startMessage = function() {
  4333.     this._textState = {};
  4334.     this._textState.index = 0;
  4335.     this._textState.text = this.convertEscapeCharacters($gameMessage.allText());
  4336.     this.newPage(this._textState);
  4337.     this.updatePlacement();
  4338.     this.updateBackground();
  4339.     this.open();
  4340. };

  4342. Window_Message.prototype.updatePlacement = function() {
  4343.     this._positionType = $gameMessage.positionType();
  4344.     this.y = this._positionType * (Graphics.boxHeight - this.height) / 2;
  4345.     this._goldWindow.y = this.y > 0 ? 0 : Graphics.boxHeight - this._goldWindow.height;
  4346. };

  4348. Window_Message.prototype.updateBackground = function() {
  4349.     this._background = $gameMessage.background();
  4350.     this.setBackgroundType(this._background);
  4351. };

  4353. Window_Message.prototype.terminateMessage = function() {
  4354.     this.close();
  4355.     this._goldWindow.close();
  4356.     $gameMessage.clear();
  4357. };

  4359. Window_Message.prototype.updateWait = function() {
  4360.     if (this._waitCount > 0) {
  4361.         this._waitCount--;
  4362.         return true;
  4363.     } else {
  4364.         return false;
  4365.     }
  4366. };

  4368. Window_Message.prototype.updateLoading = function() {
  4369.     if (this._faceBitmap) {
  4370.         if (this._faceBitmap.isReady()) {
  4371.             this.drawMessageFace();
  4372.             this._faceBitmap = null;
  4373.             return false;
  4374.         } else {
  4375.             return true;
  4376.         }
  4377.     } else {
  4378.         return false;
  4379.     }
  4380. };

  4382. Window_Message.prototype.updateInput = function() {
  4383.     if (this.isAnySubWindowActive()) {
  4384.         return true;
  4385.     }
  4386.     if (this.pause) {
  4387.         if (this.isTriggered()) {
  4388.             Input.update();
  4389.             this.pause = false;
  4390.             if (!this._textState) {
  4391.                 this.terminateMessage();
  4392.             }
  4393.         }
  4394.         return true;
  4395.     }
  4396.     return false;
  4397. };

  4399. Window_Message.prototype.isAnySubWindowActive = function() {
  4400.     return (this._choiceWindow.active ||
  4401.             this._numberWindow.active ||
  4402.             this._itemWindow.active);
  4403. };

  4405. Window_Message.prototype.updateMessage = function() {
  4406.     if (this._textState) {
  4407.         while (!this.isEndOfText(this._textState)) {
  4408.             if (this.needsNewPage(this._textState)) {
  4409.                 this.newPage(this._textState);
  4410.             }
  4411.             this.updateShowFast();
  4412.             this.processCharacter(this._textState);
  4413.             if (!this._showFast && !this._lineShowFast) {
  4414.                 break;
  4415.             }
  4416.             if (this.pause || this._waitCount > 0) {
  4417.                 break;
  4418.             }
  4419.         }
  4420.         if (this.isEndOfText(this._textState)) {
  4421.             this.onEndOfText();
  4422.         }
  4423.         return true;
  4424.     } else {
  4425.         return false;
  4426.     }
  4427. };

  4429. Window_Message.prototype.onEndOfText = function() {
  4430.     if (!this.startInput()) {
  4431.         if (!this._pauseSkip) {
  4432.             this.startPause();
  4433.         } else {
  4434.             this.terminateMessage();
  4435.         }
  4436.     }
  4437.     this._textState = null;
  4438. };

  4440. Window_Message.prototype.startInput = function() {
  4441.     if ($gameMessage.isChoice()) {
  4442.         this._choiceWindow.start();
  4443.         return true;
  4444.     } else if ($gameMessage.isNumberInput()) {
  4445.         this._numberWindow.start();
  4446.         return true;
  4447.     } else if ($gameMessage.isItemChoice()) {
  4448.         this._itemWindow.start();
  4449.         return true;
  4450.     } else {
  4451.         return false;
  4452.     }
  4453. };

  4455. Window_Message.prototype.isTriggered = function() {
  4456.     return (Input.isRepeated('ok') || Input.isRepeated('cancel') ||
  4457.             TouchInput.isRepeated());
  4458. };

  4460. Window_Message.prototype.doesContinue = function() {
  4461.     return ($gameMessage.hasText() && !$gameMessage.scrollMode() &&
  4462.             !this.areSettingsChanged());
  4463. };

  4465. Window_Message.prototype.areSettingsChanged = function() {
  4466.     return (this._background !== $gameMessage.background() ||
  4467.             this._positionType !== $gameMessage.positionType());
  4468. };

  4470. Window_Message.prototype.updateShowFast = function() {
  4471.     if (this.isTriggered()) {
  4472.         this._showFast = true;
  4473.     }
  4474. };

  4476. Window_Message.prototype.newPage = function(textState) {
  4477.     this.contents.clear();
  4478.     this.resetFontSettings();
  4479.     this.clearFlags();
  4480.     this.loadMessageFace();
  4481.     textState.x = this.newLineX();
  4482.     textState.y = 0;
  4483.     textState.left = this.newLineX();
  4484.     textState.height = this.calcTextHeight(textState, false);
  4485. };

  4487. Window_Message.prototype.loadMessageFace = function() {
  4488.     this._faceBitmap = ImageManager.reserveFace($gameMessage.faceName(), 0, this._imageReservationId);
  4489. };

  4491. Window_Message.prototype.drawMessageFace = function() {
  4492.     this.drawFace($gameMessage.faceName(), $gameMessage.faceIndex(), 0, 0);
  4493.     ImageManager.releaseReservation(this._imageReservationId);
  4494. };

  4496. Window_Message.prototype.newLineX = function() {
  4497.     return $gameMessage.faceName() === '' ? 0 : 168;
  4498. };

  4500. Window_Message.prototype.processNewLine = function(textState) {
  4501.     this._lineShowFast = false;
  4502.     Window_Base.prototype.processNewLine.call(this, textState);
  4503.     if (this.needsNewPage(textState)) {
  4504.         this.startPause();
  4505.     }
  4506. };

  4508. Window_Message.prototype.processNewPage = function(textState) {
  4509.     Window_Base.prototype.processNewPage.call(this, textState);
  4510.     if (textState.text[textState.index] === '\n') {
  4511.         textState.index++;
  4512.     }
  4513.     textState.y = this.contents.height;
  4514.     this.startPause();
  4515. };

  4517. Window_Message.prototype.isEndOfText = function(textState) {
  4518.     return textState.index >= textState.text.length;
  4519. };

  4521. Window_Message.prototype.needsNewPage = function(textState) {
  4522.     return (!this.isEndOfText(textState) &&
  4523.             textState.y + textState.height > this.contents.height);
  4524. };

  4526. Window_Message.prototype.processEscapeCharacter = function(code, textState) {
  4527.     switch (code) {
  4528.     case ':
  4529.         this._goldWindow.open();
  4530.         break;
  4531.     case '.':
  4532.         this.startWait(15);
  4533.         break;
  4534.     case '|':
  4535.         this.startWait(60);
  4536.         break;
  4537.     case '!':
  4538.         this.startPause();
  4539.         break;
  4540.     case '>':
  4541.         this._lineShowFast = true;
  4542.         break;
  4543.     case '<':
  4544.         this._lineShowFast = false;
  4545.         break;
  4546.     case '^':
  4547.         this._pauseSkip = true;
  4548.         break;
  4549.     default:
  4550.         Window_Base.prototype.processEscapeCharacter.call(this, code, textState);
  4551.         break;
  4552.     }
  4553. };

  4555. Window_Message.prototype.startWait = function(count) {
  4556.     this._waitCount = count;
  4557. };

  4559. Window_Message.prototype.startPause = function() {
  4560.     this.startWait(10);
  4561.     this.pause = true;
  4562. };

  4564. //-----------------------------------------------------------------------------
  4565. // Window_ScrollText
  4566. //
  4567. // The window for displaying scrolling text. No frame is displayed, but it
  4568. // is handled as a window for convenience.

  4570. function Window_ScrollText() {
  4571.     this.initialize.apply(this, arguments);
  4572. }

  4574. Window_ScrollText.prototype = Object.create(Window_Base.prototype);
  4575. Window_ScrollText.prototype.constructor = Window_ScrollText;

  4577. Window_ScrollText.prototype.initialize = function() {
  4578.     var width = Graphics.boxWidth;
  4579.     var height = Graphics.boxHeight;
  4580.     Window_Base.prototype.initialize.call(this, 0, 0, width, height);
  4581.     this.opacity = 0;
  4582.     this.hide();
  4583.     this._text = '';
  4584.     this._allTextHeight = 0;
  4585. };

  4587. Window_ScrollText.prototype.update = function() {
  4588.     Window_Base.prototype.update.call(this);
  4589.     if ($gameMessage.scrollMode()) {
  4590.         if (this._text) {
  4591.             this.updateMessage();
  4592.         }
  4593.         if (!this._text && $gameMessage.hasText()) {
  4594.             this.startMessage();
  4595.         }
  4596.     }
  4597. };

  4599. Window_ScrollText.prototype.startMessage = function() {
  4600.     this._text = $gameMessage.allText();
  4601.     this.refresh();
  4602.     this.show();
  4603. };

  4605. Window_ScrollText.prototype.refresh = function() {
  4606.     var textState = { index: 0 };
  4607.     textState.text = this.convertEscapeCharacters(this._text);
  4608.     this.resetFontSettings();
  4609.     this._allTextHeight = this.calcTextHeight(textState, true);
  4610.     this.createContents();
  4611.     this.origin.y = -this.height;
  4612.     this.drawTextEx(this._text, this.textPadding(), 1);
  4613. };

  4615. Window_ScrollText.prototype.contentsHeight = function() {
  4616.     return Math.max(this._allTextHeight, 1);
  4617. };

  4619. Window_ScrollText.prototype.updateMessage = function() {
  4620.     this.origin.y += this.scrollSpeed();
  4621.     if (this.origin.y >= this.contents.height) {
  4622.         this.terminateMessage();
  4623.     }
  4624. };

  4626. Window_ScrollText.prototype.scrollSpeed = function() {
  4627.     var speed = $gameMessage.scrollSpeed() / 2;
  4628.     if (this.isFastForward()) {
  4629.         speed *= this.fastForwardRate();
  4630.     }
  4631.     return speed;
  4632. };

  4634. Window_ScrollText.prototype.isFastForward = function() {
  4635.     if ($gameMessage.scrollNoFast()) {
  4636.         return false;
  4637.     } else {
  4638.         return (Input.isPressed('ok') || Input.isPressed('shift') ||
  4639.                 TouchInput.isPressed());
  4640.     }
  4641. };

  4643. Window_ScrollText.prototype.fastForwardRate = function() {
  4644.     return 3;
  4645. };

  4647. Window_ScrollText.prototype.terminateMessage = function() {
  4648.     this._text = null;
  4649.     $gameMessage.clear();
  4650.     this.hide();
  4651. };

  4653. //-----------------------------------------------------------------------------
  4654. // Window_MapName
  4655. //
  4656. // The window for displaying the map name on the map screen.

  4658. function Window_MapName() {
  4659.     this.initialize.apply(this, arguments);
  4660. }

  4662. Window_MapName.prototype = Object.create(Window_Base.prototype);
  4663. Window_MapName.prototype.constructor = Window_MapName;

  4665. Window_MapName.prototype.initialize = function() {
  4666.     var wight = this.windowWidth();
  4667.     var height = this.windowHeight();
  4668.     Window_Base.prototype.initialize.call(this, 0, 0, wight, height);
  4669.     this.opacity = 0;
  4670.     this.contentsOpacity = 0;
  4671.     this._showCount = 0;
  4672.     this.refresh();
  4673. };

  4675. Window_MapName.prototype.windowWidth = function() {
  4676.     return 360;
  4677. };

  4679. Window_MapName.prototype.windowHeight = function() {
  4680.     return this.fittingHeight(1);
  4681. };

  4683. Window_MapName.prototype.update = function() {
  4684.     Window_Base.prototype.update.call(this);
  4685.     if (this._showCount > 0 && $gameMap.isNameDisplayEnabled()) {
  4686.         this.updateFadeIn();
  4687.         this._showCount--;
  4688.     } else {
  4689.         this.updateFadeOut();
  4690.     }
  4691. };

  4693. Window_MapName.prototype.updateFadeIn = function() {
  4694.     this.contentsOpacity += 16;
  4695. };

  4697. Window_MapName.prototype.updateFadeOut = function() {
  4698.     this.contentsOpacity -= 16;
  4699. };

  4701. Window_MapName.prototype.open = function() {
  4702.     this.refresh();
  4703.     this._showCount = 150;
  4704. };

  4706. Window_MapName.prototype.close = function() {
  4707.     this._showCount = 0;
  4708. };

  4710. Window_MapName.prototype.refresh = function() {
  4711.     this.contents.clear();
  4712.     if ($gameMap.displayName()) {
  4713.         var width = this.contentsWidth();
  4714.         this.drawBackground(0, 0, width, this.lineHeight());
  4715.         this.drawText($gameMap.displayName(), 0, 0, width, 'center');
  4716.     }
  4717. };

  4719. Window_MapName.prototype.drawBackground = function(x, y, width, height) {
  4720.     var color1 = this.dimColor1();
  4721.     var color2 = this.dimColor2();
  4722.     this.contents.gradientFillRect(x, y, width / 2, height, color2, color1);
  4723.     this.contents.gradientFillRect(x + width / 2, y, width / 2, height, color1, color2);
  4724. };

  4726. //-----------------------------------------------------------------------------
  4727. // Window_BattleLog
  4728. //
  4729. // The window for displaying battle progress. No frame is displayed, but it is
  4730. // handled as a window for convenience.

  4732. function Window_BattleLog() {
  4733.     this.initialize.apply(this, arguments);
  4734. }

  4736. Window_BattleLog.prototype = Object.create(Window_Selectable.prototype);
  4737. Window_BattleLog.prototype.constructor = Window_BattleLog;

  4739. Window_BattleLog.prototype.initialize = function() {
  4740.     var width = this.windowWidth();
  4741.     var height = this.windowHeight();
  4742.     Window_Selectable.prototype.initialize.call(this, 0, 0, width, height);
  4743.     this.opacity = 0;
  4744.     this._lines = [];
  4745.     this._methods = [];
  4746.     this._waitCount = 0;
  4747.     this._waitMode = '';
  4748.     this._baseLineStack = [];
  4749.     this._spriteset = null;
  4750.     this.createBackBitmap();
  4751.     this.createBackSprite();
  4752.     this.refresh();
  4753. };

  4755. Window_BattleLog.prototype.setSpriteset = function(spriteset) {
  4756.     this._spriteset = spriteset;
  4757. };

  4759. Window_BattleLog.prototype.windowWidth = function() {
  4760.     return Graphics.boxWidth;
  4761. };

  4763. Window_BattleLog.prototype.windowHeight = function() {
  4764.     return this.fittingHeight(this.maxLines());
  4765. };

  4767. Window_BattleLog.prototype.maxLines = function() {
  4768.     return 10;
  4769. };

  4771. Window_BattleLog.prototype.createBackBitmap = function() {
  4772.     this._backBitmap = new Bitmap(this.width, this.height);
  4773. };

  4775. Window_BattleLog.prototype.createBackSprite = function() {
  4776.     this._backSprite = new Sprite();
  4777.     this._backSprite.bitmap = this._backBitmap;
  4778.     this._backSprite.y = this.y;
  4779.     this.addChildToBack(this._backSprite);
  4780. };

  4782. Window_BattleLog.prototype.numLines = function() {
  4783.     return this._lines.length;
  4784. };

  4786. Window_BattleLog.prototype.messageSpeed = function() {
  4787.     return 16;
  4788. };

  4790. Window_BattleLog.prototype.isBusy = function() {
  4791.     return this._waitCount > 0 || this._waitMode || this._methods.length > 0;
  4792. };

  4794. Window_BattleLog.prototype.update = function() {
  4795.     if (!this.updateWait()) {
  4796.         this.callNextMethod();
  4797.     }
  4798. };

  4800. Window_BattleLog.prototype.updateWait = function() {
  4801.     return this.updateWaitCount() || this.updateWaitMode();
  4802. };

  4804. Window_BattleLog.prototype.updateWaitCount = function() {
  4805.     if (this._waitCount > 0) {
  4806.         this._waitCount -= this.isFastForward() ? 3 : 1;
  4807.         if (this._waitCount < 0) {
  4808.             this._waitCount = 0;
  4809.         }
  4810.         return true;
  4811.     }
  4812.     return false;
  4813. };

  4815. Window_BattleLog.prototype.updateWaitMode = function() {
  4816.     var waiting = false;
  4817.     switch (this._waitMode) {
  4818.     case 'effect':
  4819.         waiting = this._spriteset.isEffecting();
  4820.         break;
  4821.     case 'movement':
  4822.         waiting = this._spriteset.isAnyoneMoving();
  4823.         break;
  4824.     }
  4825.     if (!waiting) {
  4826.         this._waitMode = '';
  4827.     }
  4828.     return waiting;
  4829. };

  4831. Window_BattleLog.prototype.setWaitMode = function(waitMode) {
  4832.     this._waitMode = waitMode;
  4833. };

  4835. Window_BattleLog.prototype.callNextMethod = function() {
  4836.     if (this._methods.length > 0) {
  4837.         var method = this._methods.shift();
  4838.         if (method.name && this[method.name]) {
  4839.             this[method.name].apply(this, method.params);
  4840.         } else {
  4841.             throw new Error('Method not found: ' + method.name);
  4842.         }
  4843.     }
  4844. };

  4846. Window_BattleLog.prototype.isFastForward = function() {
  4847.     return (Input.isLongPressed('ok') || Input.isPressed('shift') ||
  4848.             TouchInput.isLongPressed());
  4849. };

  4851. Window_BattleLog.prototype.push = function(methodName) {
  4852.     var methodArgs = Array.prototype.slice.call(arguments, 1);
  4853.     this._methods.push({ name: methodName, params: methodArgs });
  4854. };

  4856. Window_BattleLog.prototype.clear = function() {
  4857.     this._lines = [];
  4858.     this._baseLineStack = [];
  4859.     this.refresh();
  4860. };

  4862. Window_BattleLog.prototype.wait = function() {
  4863.     this._waitCount = this.messageSpeed();
  4864. };

  4866. Window_BattleLog.prototype.waitForEffect = function() {
  4867.     this.setWaitMode('effect');
  4868. };

  4870. Window_BattleLog.prototype.waitForMovement = function() {
  4871.     this.setWaitMode('movement');
  4872. };

  4874. Window_BattleLog.prototype.addText = function(text) {
  4875.     this._lines.push(text);
  4876.     this.refresh();
  4877.     this.wait();
  4878. };

  4880. Window_BattleLog.prototype.pushBaseLine = function() {
  4881.     this._baseLineStack.push(this._lines.length);
  4882. };

  4884. Window_BattleLog.prototype.popBaseLine = function() {
  4885.     var baseLine = this._baseLineStack.pop();
  4886.     while (this._lines.length > baseLine) {
  4887.         this._lines.pop();
  4888.     }
  4889. };

  4891. Window_BattleLog.prototype.waitForNewLine = function() {
  4892.     var baseLine = 0;
  4893.     if (this._baseLineStack.length > 0) {
  4894.         baseLine = this._baseLineStack[this._baseLineStack.length - 1];
  4895.     }
  4896.     if (this._lines.length > baseLine) {
  4897.         this.wait();
  4898.     }
  4899. };

  4901. Window_BattleLog.prototype.popupDamage = function(target) {
  4902.     target.startDamagePopup();
  4903. };

  4905. Window_BattleLog.prototype.performActionStart = function(subject, action) {
  4906.     subject.performActionStart(action);
  4907. };

  4909. Window_BattleLog.prototype.performAction = function(subject, action) {
  4910.     subject.performAction(action);
  4911. };

  4913. Window_BattleLog.prototype.performActionEnd = function(subject) {
  4914.     subject.performActionEnd();
  4915. };

  4917. Window_BattleLog.prototype.performDamage = function(target) {
  4918.     target.performDamage();
  4919. };

  4921. Window_BattleLog.prototype.performMiss = function(target) {
  4922.     target.performMiss();
  4923. };

  4925. Window_BattleLog.prototype.performRecovery = function(target) {
  4926.     target.performRecovery();
  4927. };

  4929. Window_BattleLog.prototype.performEvasion = function(target) {
  4930.     target.performEvasion();
  4931. };

  4933. Window_BattleLog.prototype.performMagicEvasion = function(target) {
  4934.     target.performMagicEvasion();
  4935. };

  4937. Window_BattleLog.prototype.performCounter = function(target) {
  4938.     target.performCounter();
  4939. };

  4941. Window_BattleLog.prototype.performReflection = function(target) {
  4942.     target.performReflection();
  4943. };

  4945. Window_BattleLog.prototype.performSubstitute = function(substitute, target) {
  4946.     substitute.performSubstitute(target);
  4947. };

  4949. Window_BattleLog.prototype.performCollapse = function(target) {
  4950.     target.performCollapse();
  4951. };

  4953. Window_BattleLog.prototype.showAnimation = function(subject, targets, animationId) {
  4954.     if (animationId < 0) {
  4955.         this.showAttackAnimation(subject, targets);
  4956.     } else {
  4957.         this.showNormalAnimation(targets, animationId);
  4958.     }
  4959. };

  4961. Window_BattleLog.prototype.showAttackAnimation = function(subject, targets) {
  4962.     if (subject.isActor()) {
  4963.         this.showActorAttackAnimation(subject, targets);
  4964.     } else {
  4965.         this.showEnemyAttackAnimation(subject, targets);
  4966.     }
  4967. };

  4969. Window_BattleLog.prototype.showActorAttackAnimation = function(subject, targets) {
  4970.     this.showNormalAnimation(targets, subject.attackAnimationId1(), false);
  4971.     this.showNormalAnimation(targets, subject.attackAnimationId2(), true);
  4972. };

  4974. Window_BattleLog.prototype.showEnemyAttackAnimation = function(subject, targets) {
  4975.     SoundManager.playEnemyAttack();
  4976. };

  4978. Window_BattleLog.prototype.showNormalAnimation = function(targets, animationId, mirror) {
  4979.     var animation = $dataAnimations[animationId];
  4980.     if (animation) {
  4981.         var delay = this.animationBaseDelay();
  4982.         var nextDelay = this.animationNextDelay();
  4983.         targets.forEach(function(target) {
  4984.             target.startAnimation(animationId, mirror, delay);
  4985.             delay += nextDelay;
  4986.         });
  4987.     }
  4988. };

  4990. Window_BattleLog.prototype.animationBaseDelay = function() {
  4991.     return 8;
  4992. };

  4994. Window_BattleLog.prototype.animationNextDelay = function() {
  4995.     return 12;
  4996. };

  4998. Window_BattleLog.prototype.refresh = function() {
  4999.     this.drawBackground();
  5000.     this.contents.clear();
  5001.     for (var i = 0; i < this._lines.length; i++) {
  5002.         this.drawLineText(i);
  5003.     }
  5004. };

  5006. Window_BattleLog.prototype.drawBackground = function() {
  5007.     var rect = this.backRect();
  5008.     var color = this.backColor();
  5009.     this._backBitmap.clear();
  5010.     this._backBitmap.paintOpacity = this.backPaintOpacity();
  5011.     this._backBitmap.fillRect(rect.x, rect.y, rect.width, rect.height, color);
  5012.     this._backBitmap.paintOpacity = 255;
  5013. };

  5015. Window_BattleLog.prototype.backRect = function() {
  5016.     return {
  5017.         x: 0,
  5018.         y: this.padding,
  5019.         width: this.width,
  5020.         height: this.numLines() * this.lineHeight()
  5021.     };
  5022. };

  5024. Window_BattleLog.prototype.backColor = function() {
  5025.     return '#000000';
  5026. };

  5028. Window_BattleLog.prototype.backPaintOpacity = function() {
  5029.     return 64;
  5030. };

  5032. Window_BattleLog.prototype.drawLineText = function(index) {
  5033.     var rect = this.itemRectForText(index);
  5034.     this.contents.clearRect(rect.x, rect.y, rect.width, rect.height);
  5035.     this.drawTextEx(this._lines[index], rect.x, rect.y, rect.width);
  5036. };

  5038. Window_BattleLog.prototype.startTurn = function() {
  5039.     this.push('wait');
  5040. };

  5042. Window_BattleLog.prototype.startAction = function(subject, action, targets) {
  5043.     var item = action.item();
  5044.     this.push('performActionStart', subject, action);
  5045.     this.push('waitForMovement');
  5046.     this.push('performAction', subject, action);
  5047.     this.push('showAnimation', subject, targets.clone(), item.animationId);
  5048.     this.displayAction(subject, item);
  5049. };

  5051. Window_BattleLog.prototype.endAction = function(subject) {
  5052.     this.push('waitForNewLine');
  5053.     this.push('clear');
  5054.     this.push('performActionEnd', subject);
  5055. };

  5057. Window_BattleLog.prototype.displayCurrentState = function(subject) {
  5058.     var stateText = subject.mostImportantStateText();
  5059.     if (stateText) {
  5060.         this.push('addText', subject.name() + stateText);
  5061.         this.push('wait');
  5062.         this.push('clear');
  5063.     }
  5064. };

  5066. Window_BattleLog.prototype.displayRegeneration = function(subject) {
  5067.     this.push('popupDamage', subject);
  5068. };

  5070. Window_BattleLog.prototype.displayAction = function(subject, item) {
  5071.     var numMethods = this._methods.length;
  5072.     if (DataManager.isSkill(item)) {
  5073.         if (item.message1) {
  5074.             this.push('addText', subject.name() + item.message1.format(item.name));
  5075.         }
  5076.         if (item.message2) {
  5077.             this.push('addText', item.message2.format(item.name));
  5078.         }
  5079.     } else {
  5080.         this.push('addText', TextManager.useItem.format(subject.name(), item.name));
  5081.     }
  5082.     if (this._methods.length === numMethods) {
  5083.         this.push('wait');
  5084.     }
  5085. };

  5087. Window_BattleLog.prototype.displayCounter = function(target) {
  5088.     this.push('performCounter', target);
  5089.     this.push('addText', TextManager.counterAttack.format(target.name()));
  5090. };

  5092. Window_BattleLog.prototype.displayReflection = function(target) {
  5093.     this.push('performReflection', target);
  5094.     this.push('addText', TextManager.magicReflection.format(target.name()));
  5095. };

  5097. Window_BattleLog.prototype.displaySubstitute = function(substitute, target) {
  5098.     var substName = substitute.name();
  5099.     this.push('performSubstitute', substitute, target);
  5100.     this.push('addText', TextManager.substitute.format(substName, target.name()));
  5101. };

  5103. Window_BattleLog.prototype.displayActionResults = function(subject, target) {
  5104.     if (target.result().used) {
  5105.         this.push('pushBaseLine');
  5106.         this.displayCritical(target);
  5107.         this.push('popupDamage', target);
  5108.         this.push('popupDamage', subject);
  5109.         this.displayDamage(target);
  5110.         this.displayAffectedStatus(target);
  5111.         this.displayFailure(target);
  5112.         this.push('waitForNewLine');
  5113.         this.push('popBaseLine');
  5114.     }
  5115. };

  5117. Window_BattleLog.prototype.displayFailure = function(target) {
  5118.     if (target.result().isHit() && !target.result().success) {
  5119.         this.push('addText', TextManager.actionFailure.format(target.name()));
  5120.     }
  5121. };

  5123. Window_BattleLog.prototype.displayCritical = function(target) {
  5124.     if (target.result().critical) {
  5125.         if (target.isActor()) {
  5126.             this.push('addText', TextManager.criticalToActor);
  5127.         } else {
  5128.             this.push('addText', TextManager.criticalToEnemy);
  5129.         }
  5130.     }
  5131. };

  5133. Window_BattleLog.prototype.displayDamage = function(target) {
  5134.     if (target.result().missed) {
  5135.         this.displayMiss(target);
  5136.     } else if (target.result().evaded) {
  5137.         this.displayEvasion(target);
  5138.     } else {
  5139.         this.displayHpDamage(target);
  5140.         this.displayMpDamage(target);
  5141.         this.displayTpDamage(target);
  5142.     }
  5143. };

  5145. Window_BattleLog.prototype.displayMiss = function(target) {
  5146.     var fmt;
  5147.     if (target.result().physical) {
  5148.         fmt = target.isActor() ? TextManager.actorNoHit : TextManager.enemyNoHit;
  5149.         this.push('performMiss', target);
  5150.     } else {
  5151.         fmt = TextManager.actionFailure;
  5152.     }
  5153.     this.push('addText', fmt.format(target.name()));
  5154. };

  5156. Window_BattleLog.prototype.displayEvasion = function(target) {
  5157.     var fmt;
  5158.     if (target.result().physical) {
  5159.         fmt = TextManager.evasion;
  5160.         this.push('performEvasion', target);
  5161.     } else {
  5162.         fmt = TextManager.magicEvasion;
  5163.         this.push('performMagicEvasion', target);
  5164.     }
  5165.     this.push('addText', fmt.format(target.name()));
  5166. };

  5168. Window_BattleLog.prototype.displayHpDamage = function(target) {
  5169.     if (target.result().hpAffected) {
  5170.         if (target.result().hpDamage > 0 && !target.result().drain) {
  5171.             this.push('performDamage', target);
  5172.         }
  5173.         if (target.result().hpDamage < 0) {
  5174.             this.push('performRecovery', target);
  5175.         }
  5176.         this.push('addText', this.makeHpDamageText(target));
  5177.     }
  5178. };

  5180. Window_BattleLog.prototype.displayMpDamage = function(target) {
  5181.     if (target.isAlive() && target.result().mpDamage !== 0) {
  5182.         if (target.result().mpDamage < 0) {
  5183.             this.push('performRecovery', target);
  5184.         }
  5185.         this.push('addText', this.makeMpDamageText(target));
  5186.     }
  5187. };

  5189. Window_BattleLog.prototype.displayTpDamage = function(target) {
  5190.     if (target.isAlive() && target.result().tpDamage !== 0) {
  5191.         if (target.result().tpDamage < 0) {
  5192.             this.push('performRecovery', target);
  5193.         }
  5194.         this.push('addText', this.makeTpDamageText(target));
  5195.     }
  5196. };

  5198. Window_BattleLog.prototype.displayAffectedStatus = function(target) {
  5199.     if (target.result().isStatusAffected()) {
  5200.         this.push('pushBaseLine');
  5201.         this.displayChangedStates(target);
  5202.         this.displayChangedBuffs(target);
  5203.         this.push('waitForNewLine');
  5204.         this.push('popBaseLine');
  5205.     }
  5206. };

  5208. Window_BattleLog.prototype.displayAutoAffectedStatus = function(target) {
  5209.     if (target.result().isStatusAffected()) {
  5210.         this.displayAffectedStatus(target, null);
  5211.         this.push('clear');
  5212.     }
  5213. };

  5215. Window_BattleLog.prototype.displayChangedStates = function(target) {
  5216.     this.displayAddedStates(target);
  5217.     this.displayRemovedStates(target);
  5218. };

  5220. Window_BattleLog.prototype.displayAddedStates = function(target) {
  5221.     target.result().addedStateObjects().forEach(function(state) {
  5222.         var stateMsg = target.isActor() ? state.message1 : state.message2;
  5223.         if (state.id === target.deathStateId()) {
  5224.             this.push('performCollapse', target);
  5225.         }
  5226.         if (stateMsg) {
  5227.             this.push('popBaseLine');
  5228.             this.push('pushBaseLine');
  5229.             this.push('addText', target.name() + stateMsg);
  5230.             this.push('waitForEffect');
  5231.         }
  5232.     }, this);
  5233. };

  5235. Window_BattleLog.prototype.displayRemovedStates = function(target) {
  5236.     target.result().removedStateObjects().forEach(function(state) {
  5237.         if (state.message4) {
  5238.             this.push('popBaseLine');
  5239.             this.push('pushBaseLine');
  5240.             this.push('addText', target.name() + state.message4);
  5241.         }
  5242.     }, this);
  5243. };

  5245. Window_BattleLog.prototype.displayChangedBuffs = function(target) {
  5246.     var result = target.result();
  5247.     this.displayBuffs(target, result.addedBuffs, TextManager.buffAdd);
  5248.     this.displayBuffs(target, result.addedDebuffs, TextManager.debuffAdd);
  5249.     this.displayBuffs(target, result.removedBuffs, TextManager.buffRemove);
  5250. };

  5252. Window_BattleLog.prototype.displayBuffs = function(target, buffs, fmt) {
  5253.     buffs.forEach(function(paramId) {
  5254.         this.push('popBaseLine');
  5255.         this.push('pushBaseLine');
  5256.         this.push('addText', fmt.format(target.name(), TextManager.param(paramId)));
  5257.     }, this);
  5258. };

  5260. Window_BattleLog.prototype.makeHpDamageText = function(target) {
  5261.     var result = target.result();
  5262.     var damage = result.hpDamage;
  5263.     var isActor = target.isActor();
  5264.     var fmt;
  5265.     if (damage > 0 && result.drain) {
  5266.         fmt = isActor ? TextManager.actorDrain : TextManager.enemyDrain;
  5267.         return fmt.format(target.name(), TextManager.hp, damage);
  5268.     } else if (damage > 0) {
  5269.         fmt = isActor ? TextManager.actorDamage : TextManager.enemyDamage;
  5270.         return fmt.format(target.name(), damage);
  5271.     } else if (damage < 0) {
  5272.         fmt = isActor ? TextManager.actorRecovery : TextManager.enemyRecovery;
  5273.         return fmt.format(target.name(), TextManager.hp, -damage);
  5274.     } else {
  5275.         fmt = isActor ? TextManager.actorNoDamage : TextManager.enemyNoDamage;
  5276.         return fmt.format(target.name());
  5277.     }
  5278. };

  5280. Window_BattleLog.prototype.makeMpDamageText = function(target) {
  5281.     var result = target.result();
  5282.     var damage = result.mpDamage;
  5283.     var isActor = target.isActor();
  5284.     var fmt;
  5285.     if (damage > 0 && result.drain) {
  5286.         fmt = isActor ? TextManager.actorDrain : TextManager.enemyDrain;
  5287.         return fmt.format(target.name(), TextManager.mp, damage);
  5288.     } else if (damage > 0) {
  5289.         fmt = isActor ? TextManager.actorLoss : TextManager.enemyLoss;
  5290.         return fmt.format(target.name(), TextManager.mp, damage);
  5291.     } else if (damage < 0) {
  5292.         fmt = isActor ? TextManager.actorRecovery : TextManager.enemyRecovery;
  5293.         return fmt.format(target.name(), TextManager.mp, -damage);
  5294.     } else {
  5295.         return '';
  5296.     }
  5297. };

  5299. Window_BattleLog.prototype.makeTpDamageText = function(target) {
  5300.     var result = target.result();
  5301.     var damage = result.tpDamage;
  5302.     var isActor = target.isActor();
  5303.     var fmt;
  5304.     if (damage > 0) {
  5305.         fmt = isActor ? TextManager.actorLoss : TextManager.enemyLoss;
  5306.         return fmt.format(target.name(), TextManager.tp, damage);
  5307.     } else if (damage < 0) {
  5308.         fmt = isActor ? TextManager.actorGain : TextManager.enemyGain;
  5309.         return fmt.format(target.name(), TextManager.tp, -damage);
  5310.     } else {
  5311.         return '';
  5312.     }
  5313. };

  5315. //-----------------------------------------------------------------------------
  5316. // Window_PartyCommand
  5317. //
  5318. // The window for selecting whether to fight or escape on the battle screen.

  5320. function Window_PartyCommand() {
  5321.     this.initialize.apply(this, arguments);
  5322. }

  5324. Window_PartyCommand.prototype = Object.create(Window_Command.prototype);
  5325. Window_PartyCommand.prototype.constructor = Window_PartyCommand;

  5327. Window_PartyCommand.prototype.initialize = function() {
  5328.     var y = Graphics.boxHeight - this.windowHeight();
  5329.     Window_Command.prototype.initialize.call(this, 0, y);
  5330.     this.openness = 0;
  5331.     this.deactivate();
  5332. };

  5334. Window_PartyCommand.prototype.windowWidth = function() {
  5335.     return 192;
  5336. };

  5338. Window_PartyCommand.prototype.numVisibleRows = function() {
  5339.     return 4;
  5340. };

  5342. Window_PartyCommand.prototype.makeCommandList = function() {
  5343.     this.addCommand(TextManager.fight,  'fight');
  5344.     this.addCommand(TextManager.escape, 'escape', BattleManager.canEscape());
  5345. };

  5347. Window_PartyCommand.prototype.setup = function() {
  5348.     this.clearCommandList();
  5349.     this.makeCommandList();
  5350.     this.refresh();
  5351.     this.select(0);
  5352.     this.activate();
  5353.     this.open();
  5354. };

  5356. //-----------------------------------------------------------------------------
  5357. // Window_ActorCommand
  5358. //
  5359. // The window for selecting an actor's action on the battle screen.

  5361. function Window_ActorCommand() {
  5362.     this.initialize.apply(this, arguments);
  5363. }

  5365. Window_ActorCommand.prototype = Object.create(Window_Command.prototype);
  5366. Window_ActorCommand.prototype.constructor = Window_ActorCommand;

  5368. Window_ActorCommand.prototype.initialize = function() {
  5369.     var y = Graphics.boxHeight - this.windowHeight();
  5370.     Window_Command.prototype.initialize.call(this, 0, y);
  5371.     this.openness = 0;
  5372.     this.deactivate();
  5373.     this._actor = null;
  5374. };

  5376. Window_ActorCommand.prototype.windowWidth = function() {
  5377.     return 192;
  5378. };

  5380. Window_ActorCommand.prototype.numVisibleRows = function() {
  5381.     return 4;
  5382. };

  5384. Window_ActorCommand.prototype.makeCommandList = function() {
  5385.     if (this._actor) {
  5386.         this.addAttackCommand();
  5387.         this.addSkillCommands();
  5388.         this.addGuardCommand();
  5389.         this.addItemCommand();
  5390.     }
  5391. };

  5393. Window_ActorCommand.prototype.addAttackCommand = function() {
  5394.     this.addCommand(TextManager.attack, 'attack', this._actor.canAttack());
  5395. };

  5397. Window_ActorCommand.prototype.addSkillCommands = function() {
  5398.     var skillTypes = this._actor.addedSkillTypes();
  5399.     skillTypes.sort(function(a, b) {
  5400.         return a - b;
  5401.     });
  5402.     skillTypes.forEach(function(stypeId) {
  5403.         var name = $dataSystem.skillTypes[stypeId];
  5404.         this.addCommand(name, 'skill', true, stypeId);
  5405.     }, this);
  5406. };

  5408. Window_ActorCommand.prototype.addGuardCommand = function() {
  5409.     this.addCommand(TextManager.guard, 'guard', this._actor.canGuard());
  5410. };

  5412. Window_ActorCommand.prototype.addItemCommand = function() {
  5413.     this.addCommand(TextManager.item, 'item');
  5414. };

  5416. Window_ActorCommand.prototype.setup = function(actor) {
  5417.     this._actor = actor;
  5418.     this.clearCommandList();
  5419.     this.makeCommandList();
  5420.     this.refresh();
  5421.     this.selectLast();
  5422.     this.activate();
  5423.     this.open();
  5424. };

  5426. Window_ActorCommand.prototype.processOk = function() {
  5427.     if (this._actor) {
  5428.         if (ConfigManager.commandRemember) {
  5429.             this._actor.setLastCommandSymbol(this.currentSymbol());
  5430.         } else {
  5431.             this._actor.setLastCommandSymbol('');
  5432.         }
  5433.     }
  5434.     Window_Command.prototype.processOk.call(this);
  5435. };

  5437. Window_ActorCommand.prototype.selectLast = function() {
  5438.     this.select(0);
  5439.     if (this._actor && ConfigManager.commandRemember) {
  5440.         var symbol = this._actor.lastCommandSymbol();
  5441.         this.selectSymbol(symbol);
  5442.         if (symbol === 'skill') {
  5443.             var skill = this._actor.lastBattleSkill();
  5444.             if (skill) {
  5445.                 this.selectExt(skill.stypeId);
  5446.             }
  5447.         }
  5448.     }
  5449. };

  5451. //-----------------------------------------------------------------------------
  5452. // Window_BattleStatus
  5453. //
  5454. // The window for displaying the status of party members on the battle screen.

  5456. function Window_BattleStatus() {
  5457.     this.initialize.apply(this, arguments);
  5458. }

  5460. Window_BattleStatus.prototype = Object.create(Window_Selectable.prototype);
  5461. Window_BattleStatus.prototype.constructor = Window_BattleStatus;

  5463. Window_BattleStatus.prototype.initialize = function() {
  5464.     var width = this.windowWidth();
  5465.     var height = this.windowHeight();
  5466.     var x = Graphics.boxWidth - width;
  5467.     var y = Graphics.boxHeight - height;
  5468.     Window_Selectable.prototype.initialize.call(this, x, y, width, height);
  5469.     this.refresh();
  5470.     this.openness = 0;
  5471. };

  5473. Window_BattleStatus.prototype.windowWidth = function() {
  5474.     return Graphics.boxWidth - 192;
  5475. };

  5477. Window_BattleStatus.prototype.windowHeight = function() {
  5478.     return this.fittingHeight(this.numVisibleRows());
  5479. };

  5481. Window_BattleStatus.prototype.numVisibleRows = function() {
  5482.     return 4;
  5483. };

  5485. Window_BattleStatus.prototype.maxItems = function() {
  5486.     return $gameParty.battleMembers().length;
  5487. };

  5489. Window_BattleStatus.prototype.refresh = function() {
  5490.     this.contents.clear();
  5491.     this.drawAllItems();
  5492. };

  5494. Window_BattleStatus.prototype.drawItem = function(index) {
  5495.     var actor = $gameParty.battleMembers()[index];
  5496.     this.drawBasicArea(this.basicAreaRect(index), actor);
  5497.     this.drawGaugeArea(this.gaugeAreaRect(index), actor);
  5498. };

  5500. Window_BattleStatus.prototype.basicAreaRect = function(index) {
  5501.     var rect = this.itemRectForText(index);
  5502.     rect.width -= this.gaugeAreaWidth() + 15;
  5503.     return rect;
  5504. };

  5506. Window_BattleStatus.prototype.gaugeAreaRect = function(index) {
  5507.     var rect = this.itemRectForText(index);
  5508.     rect.x += rect.width - this.gaugeAreaWidth();
  5509.     rect.width = this.gaugeAreaWidth();
  5510.     return rect;
  5511. };

  5513. Window_BattleStatus.prototype.gaugeAreaWidth = function() {
  5514.     return 330;
  5515. };

  5517. Window_BattleStatus.prototype.drawBasicArea = function(rect, actor) {
  5518.     this.drawActorName(actor, rect.x + 0, rect.y, 150);
  5519.     this.drawActorIcons(actor, rect.x + 156, rect.y, rect.width - 156);
  5520. };

  5522. Window_BattleStatus.prototype.drawGaugeArea = function(rect, actor) {
  5523.     if ($dataSystem.optDisplayTp) {
  5524.         this.drawGaugeAreaWithTp(rect, actor);
  5525.     } else {
  5526.         this.drawGaugeAreaWithoutTp(rect, actor);
  5527.     }
  5528. };

  5530. Window_BattleStatus.prototype.drawGaugeAreaWithTp = function(rect, actor) {
  5531.     this.drawActorHp(actor, rect.x + 0, rect.y, 108);
  5532.     this.drawActorMp(actor, rect.x + 123, rect.y, 96);
  5533.     this.drawActorTp(actor, rect.x + 234, rect.y, 96);
  5534. };

  5536. Window_BattleStatus.prototype.drawGaugeAreaWithoutTp = function(rect, actor) {
  5537.     this.drawActorHp(actor, rect.x + 0, rect.y, 201);
  5538.     this.drawActorMp(actor, rect.x + 216,  rect.y, 114);
  5539. };

  5541. //-----------------------------------------------------------------------------
  5542. // Window_BattleActor
  5543. //
  5544. // The window for selecting a target actor on the battle screen.

  5546. function Window_BattleActor() {
  5547.     this.initialize.apply(this, arguments);
  5548. }

  5550. Window_BattleActor.prototype = Object.create(Window_BattleStatus.prototype);
  5551. Window_BattleActor.prototype.constructor = Window_BattleActor;

  5553. Window_BattleActor.prototype.initialize = function(x, y) {
  5554.     Window_BattleStatus.prototype.initialize.call(this);
  5555.     this.x = x;
  5556.     this.y = y;
  5557.     this.openness = 255;
  5558.     this.hide();
  5559. };

  5561. Window_BattleActor.prototype.show = function() {
  5562.     this.select(0);
  5563.     Window_BattleStatus.prototype.show.call(this);
  5564. };

  5566. Window_BattleActor.prototype.hide = function() {
  5567.     Window_BattleStatus.prototype.hide.call(this);
  5568.     $gameParty.select(null);
  5569. };

  5571. Window_BattleActor.prototype.select = function(index) {
  5572.     Window_BattleStatus.prototype.select.call(this, index);
  5573.     $gameParty.select(this.actor());
  5574. };

  5576. Window_BattleActor.prototype.actor = function() {
  5577.     return $gameParty.members()[this.index()];
  5578. };

  5580. //-----------------------------------------------------------------------------
  5581. // Window_BattleEnemy
  5582. //
  5583. // The window for selecting a target enemy on the battle screen.

  5585. function Window_BattleEnemy() {
  5586.     this.initialize.apply(this, arguments);
  5587. }

  5589. Window_BattleEnemy.prototype = Object.create(Window_Selectable.prototype);
  5590. Window_BattleEnemy.prototype.constructor = Window_BattleEnemy;

  5592. Window_BattleEnemy.prototype.initialize = function(x, y) {
  5593.     this._enemies = [];
  5594.     var width = this.windowWidth();
  5595.     var height = this.windowHeight();
  5596.     Window_Selectable.prototype.initialize.call(this, x, y, width, height);
  5597.     this.refresh();
  5598.     this.hide();
  5599. };

  5601. Window_BattleEnemy.prototype.windowWidth = function() {
  5602.     return Graphics.boxWidth - 192;
  5603. };

  5605. Window_BattleEnemy.prototype.windowHeight = function() {
  5606.     return this.fittingHeight(this.numVisibleRows());
  5607. };

  5609. Window_BattleEnemy.prototype.numVisibleRows = function() {
  5610.     return 4;
  5611. };

  5613. Window_BattleEnemy.prototype.maxCols = function() {
  5614.     return 2;
  5615. };

  5617. Window_BattleEnemy.prototype.maxItems = function() {
  5618.     return this._enemies.length;
  5619. };

  5621. Window_BattleEnemy.prototype.enemy = function() {
  5622.     return this._enemies[this.index()];
  5623. };

  5625. Window_BattleEnemy.prototype.enemyIndex = function() {
  5626.     var enemy = this.enemy();
  5627.     return enemy ? enemy.index() : -1;
  5628. };

  5630. Window_BattleEnemy.prototype.drawItem = function(index) {
  5631.     this.resetTextColor();
  5632.     var name = this._enemies[index].name();
  5633.     var rect = this.itemRectForText(index);
  5634.     this.drawText(name, rect.x, rect.y, rect.width);
  5635. };

  5637. Window_BattleEnemy.prototype.show = function() {
  5638.     this.refresh();
  5639.     this.select(0);
  5640.     Window_Selectable.prototype.show.call(this);
  5641. };

  5643. Window_BattleEnemy.prototype.hide = function() {
  5644.     Window_Selectable.prototype.hide.call(this);
  5645.     $gameTroop.select(null);
  5646. };

  5648. Window_BattleEnemy.prototype.refresh = function() {
  5649.     this._enemies = $gameTroop.aliveMembers();
  5650.     Window_Selectable.prototype.refresh.call(this);
  5651. };

  5653. Window_BattleEnemy.prototype.select = function(index) {
  5654.     Window_Selectable.prototype.select.call(this, index);
  5655.     $gameTroop.select(this.enemy());
  5656. };

  5658. //-----------------------------------------------------------------------------
  5659. // Window_BattleSkill
  5660. //
  5661. // The window for selecting a skill to use on the battle screen.

  5663. function Window_BattleSkill() {
  5664.     this.initialize.apply(this, arguments);
  5665. }

  5667. Window_BattleSkill.prototype = Object.create(Window_SkillList.prototype);
  5668. Window_BattleSkill.prototype.constructor = Window_BattleSkill;

  5670. Window_BattleSkill.prototype.initialize = function(x, y, width, height) {
  5671.     Window_SkillList.prototype.initialize.call(this, x, y, width, height);
  5672.     this.hide();
  5673. };

  5675. Window_BattleSkill.prototype.show = function() {
  5676.     this.selectLast();
  5677.     this.showHelpWindow();
  5678.     Window_SkillList.prototype.show.call(this);
  5679. };

  5681. Window_BattleSkill.prototype.hide = function() {
  5682.     this.hideHelpWindow();
  5683.     Window_SkillList.prototype.hide.call(this);
  5684. };

  5686. //-----------------------------------------------------------------------------
  5687. // Window_BattleItem
  5688. //
  5689. // The window for selecting an item to use on the battle screen.

  5691. function Window_BattleItem() {
  5692.     this.initialize.apply(this, arguments);
  5693. }

  5695. Window_BattleItem.prototype = Object.create(Window_ItemList.prototype);
  5696. Window_BattleItem.prototype.constructor = Window_BattleItem;

  5698. Window_BattleItem.prototype.initialize = function(x, y, width, height) {
  5699.     Window_ItemList.prototype.initialize.call(this, x, y, width, height);
  5700.     this.hide();
  5701. };

  5703. Window_BattleItem.prototype.includes = function(item) {
  5704.     return $gameParty.canUse(item);
  5705. };

  5707. Window_BattleItem.prototype.show = function() {
  5708.     this.selectLast();
  5709.     this.showHelpWindow();
  5710.     Window_ItemList.prototype.show.call(this);
  5711. };

  5713. Window_BattleItem.prototype.hide = function() {
  5714.     this.hideHelpWindow();
  5715.     Window_ItemList.prototype.hide.call(this);
  5716. };

  5718. //-----------------------------------------------------------------------------
  5719. // Window_TitleCommand
  5720. //
  5721. // The window for selecting New Game/Continue on the title screen.

  5723. function Window_TitleCommand() {
  5724.     this.initialize.apply(this, arguments);
  5725. }

  5727. Window_TitleCommand.prototype = Object.create(Window_Command.prototype);
  5728. Window_TitleCommand.prototype.constructor = Window_TitleCommand;

  5730. Window_TitleCommand.prototype.initialize = function() {
  5731.     Window_Command.prototype.initialize.call(this, 0, 0);
  5732.     this.updatePlacement();
  5733.     this.openness = 0;
  5734.     this.selectLast();
  5735. };

  5737. Window_TitleCommand._lastCommandSymbol = null;

  5739. Window_TitleCommand.initCommandPosition = function() {
  5740.     this._lastCommandSymbol = null;
  5741. };

  5743. Window_TitleCommand.prototype.windowWidth = function() {
  5744.     return 240;
  5745. };

  5747. Window_TitleCommand.prototype.updatePlacement = function() {
  5748.     this.x = (Graphics.boxWidth - this.width) / 2;
  5749.     this.y = Graphics.boxHeight - this.height - 96;
  5750. };

  5752. Window_TitleCommand.prototype.makeCommandList = function() {
  5753.     this.addCommand(TextManager.newGame,   'newGame');
  5754.     this.addCommand(TextManager.continue_, 'continue', this.isContinueEnabled());
  5755.     this.addCommand(TextManager.options,   'options');
  5756. };

  5758. Window_TitleCommand.prototype.isContinueEnabled = function() {
  5759.     return DataManager.isAnySavefileExists();
  5760. };

  5762. Window_TitleCommand.prototype.processOk = function() {
  5763.     Window_TitleCommand._lastCommandSymbol = this.currentSymbol();
  5764.     Window_Command.prototype.processOk.call(this);
  5765. };

  5767. Window_TitleCommand.prototype.selectLast = function() {
  5768.     if (Window_TitleCommand._lastCommandSymbol) {
  5769.         this.selectSymbol(Window_TitleCommand._lastCommandSymbol);
  5770.     } else if (this.isContinueEnabled()) {
  5771.         this.selectSymbol('continue');
  5772.     }
  5773. };

  5775. //-----------------------------------------------------------------------------
  5776. // Window_GameEnd
  5777. //
  5778. // The window for selecting "Go to Title" on the game end screen.

  5780. function Window_GameEnd() {
  5781.     this.initialize.apply(this, arguments);
  5782. }

  5784. Window_GameEnd.prototype = Object.create(Window_Command.prototype);
  5785. Window_GameEnd.prototype.constructor = Window_GameEnd;

  5787. Window_GameEnd.prototype.initialize = function() {
  5788.     Window_Command.prototype.initialize.call(this, 0, 0);
  5789.     this.updatePlacement();
  5790.     this.openness = 0;
  5791.     this.open();
  5792. };

  5794. Window_GameEnd.prototype.windowWidth = function() {
  5795.     return 240;
  5796. };

  5798. Window_GameEnd.prototype.updatePlacement = function() {
  5799.     this.x = (Graphics.boxWidth - this.width) / 2;
  5800.     this.y = (Graphics.boxHeight - this.height) / 2;
  5801. };

  5803. Window_GameEnd.prototype.makeCommandList = function() {
  5804.     this.addCommand(TextManager.toTitle, 'toTitle');
  5805.     this.addCommand(TextManager.cancel,  'cancel');
  5806. };

  5808. //-----------------------------------------------------------------------------
  5809. // Window_DebugRange
  5810. //
  5811. // The window for selecting a block of switches/variables on the debug screen.

  5813. function Window_DebugRange() {
  5814.     this.initialize.apply(this, arguments);
  5815. }

  5817. Window_DebugRange.prototype = Object.create(Window_Selectable.prototype);
  5818. Window_DebugRange.prototype.constructor = Window_DebugRange;

  5820. Window_DebugRange.lastTopRow = 0;
  5821. Window_DebugRange.lastIndex  = 0;

  5823. Window_DebugRange.prototype.initialize = function(x, y) {
  5824.     this._maxSwitches = Math.ceil(($dataSystem.switches.length - 1) / 10);
  5825.     this._maxVariables = Math.ceil(($dataSystem.variables.length - 1) / 10);
  5826.     var width = this.windowWidth();
  5827.     var height = this.windowHeight();
  5828.     Window_Selectable.prototype.initialize.call(this, x, y, width, height);
  5829.     this.refresh();
  5830.     this.setTopRow(Window_DebugRange.lastTopRow);
  5831.     this.select(Window_DebugRange.lastIndex);
  5832.     this.activate();
  5833. };

  5835. Window_DebugRange.prototype.windowWidth = function() {
  5836.     return 246;
  5837. };

  5839. Window_DebugRange.prototype.windowHeight = function() {
  5840.     return Graphics.boxHeight;
  5841. };

  5843. Window_DebugRange.prototype.maxItems = function() {
  5844.     return this._maxSwitches + this._maxVariables;
  5845. };

  5847. Window_DebugRange.prototype.update = function() {
  5848.     Window_Selectable.prototype.update.call(this);
  5849.     if (this._editWindow) {
  5850.         this._editWindow.setMode(this.mode());
  5851.         this._editWindow.setTopId(this.topId());
  5852.     }
  5853. };

  5855. Window_DebugRange.prototype.mode = function() {
  5856.     return this.index() < this._maxSwitches ? 'switch' : 'variable';
  5857. };

  5859. Window_DebugRange.prototype.topId = function() {
  5860.     var index = this.index();
  5861.     if (index < this._maxSwitches) {
  5862.         return index * 10 + 1;
  5863.     } else {
  5864.         return (index - this._maxSwitches) * 10 + 1;
  5865.     }
  5866. };

  5868. Window_DebugRange.prototype.refresh = function() {
  5869.     this.createContents();
  5870.     this.drawAllItems();
  5871. };

  5873. Window_DebugRange.prototype.drawItem = function(index) {
  5874.     var rect = this.itemRectForText(index);
  5875.     var start;
  5876.     var text;
  5877.     if (index < this._maxSwitches) {
  5878.         start = index * 10 + 1;
  5879.         text = 'S';
  5880.     } else {
  5881.         start = (index - this._maxSwitches) * 10 + 1;
  5882.         text = 'V';
  5883.     }
  5884.     var end = start + 9;
  5885.     text += ' [' + start.padZero(4) + '-' + end.padZero(4) + ']';
  5886.     this.drawText(text, rect.x, rect.y, rect.width);
  5887. };

  5889. Window_DebugRange.prototype.isCancelTriggered = function() {
  5890.     return (Window_Selectable.prototype.isCancelTriggered() ||
  5891.             Input.isTriggered('debug'));
  5892. };

  5894. Window_DebugRange.prototype.processCancel = function() {
  5895.     Window_Selectable.prototype.processCancel.call(this);
  5896.     Window_DebugRange.lastTopRow = this.topRow();
  5897.     Window_DebugRange.lastIndex = this.index();
  5898. };

  5900. Window_DebugRange.prototype.setEditWindow = function(editWindow) {
  5901.     this._editWindow = editWindow;
  5902. };

  5904. //-----------------------------------------------------------------------------
  5905. // Window_DebugEdit
  5906. //
  5907. // The window for displaying switches and variables on the debug screen.

  5909. function Window_DebugEdit() {
  5910.     this.initialize.apply(this, arguments);
  5911. }

  5913. Window_DebugEdit.prototype = Object.create(Window_Selectable.prototype);
  5914. Window_DebugEdit.prototype.constructor = Window_DebugEdit;

  5916. Window_DebugEdit.prototype.initialize = function(x, y, width) {
  5917.     var height = this.fittingHeight(10);
  5918.     Window_Selectable.prototype.initialize.call(this, x, y, width, height);
  5919.     this._mode = 'switch';
  5920.     this._topId = 1;
  5921.     this.refresh();
  5922. };

  5924. Window_DebugEdit.prototype.maxItems = function() {
  5925.     return 10;
  5926. };

  5928. Window_DebugEdit.prototype.refresh = function() {
  5929.     this.contents.clear();
  5930.     this.drawAllItems();
  5931. };

  5933. Window_DebugEdit.prototype.drawItem = function(index) {
  5934.     var dataId = this._topId + index;
  5935.     var idText = dataId.padZero(4) + ':';
  5936.     var idWidth = this.textWidth(idText);
  5937.     var statusWidth = this.textWidth('-00000000');
  5938.     var name = this.itemName(dataId);
  5939.     var status = this.itemStatus(dataId);
  5940.     var rect = this.itemRectForText(index);
  5941.     this.resetTextColor();
  5942.     this.drawText(idText, rect.x, rect.y, rect.width);
  5943.     rect.x += idWidth;
  5944.     rect.width -= idWidth + statusWidth;
  5945.     this.drawText(name, rect.x, rect.y, rect.width);
  5946.     this.drawText(status, rect.x + rect.width, rect.y, statusWidth, 'right');
  5947. };

  5949. Window_DebugEdit.prototype.itemName = function(dataId) {
  5950.     if (this._mode === 'switch') {
  5951.         return $dataSystem.switches[dataId];
  5952.     } else {
  5953.         return $dataSystem.variables[dataId];
  5954.     }
  5955. };

  5957. Window_DebugEdit.prototype.itemStatus = function(dataId) {
  5958.     if (this._mode === 'switch') {
  5959.         return $gameSwitches.value(dataId) ? '[ON]' : '[OFF]';
  5960.     } else {
  5961.         return String($gameVariables.value(dataId));
  5962.     }
  5963. };

  5965. Window_DebugEdit.prototype.setMode = function(mode) {
  5966.     if (this._mode !== mode) {
  5967.         this._mode = mode;
  5968.         this.refresh();
  5969.     }
  5970. };

  5972. Window_DebugEdit.prototype.setTopId = function(id) {
  5973.     if (this._topId !== id) {
  5974.         this._topId = id;
  5975.         this.refresh();
  5976.     }
  5977. };

  5979. Window_DebugEdit.prototype.currentId = function() {
  5980.     return this._topId + this.index();
  5981. };

  5983. Window_DebugEdit.prototype.update = function() {
  5984.     Window_Selectable.prototype.update.call(this);
  5985.     if (this.active) {
  5986.         if (this._mode === 'switch') {
  5987.             this.updateSwitch();
  5988.         } else {
  5989.             this.updateVariable();
  5990.         }
  5991.     }
  5992. };

  5994. Window_DebugEdit.prototype.updateSwitch = function() {
  5995.     if (Input.isRepeated('ok')) {
  5996.         var switchId = this.currentId();
  5997.         SoundManager.playCursor();
  5998.         $gameSwitches.setValue(switchId, !$gameSwitches.value(switchId));
  5999.         this.redrawCurrentItem();
  6000.     }
  6001. };

  6003. Window_DebugEdit.prototype.updateVariable = function() {
  6004.     var variableId = this.currentId();
  6005.     var value = $gameVariables.value(variableId);
  6006.     if (typeof value === 'number') {
  6007.         if (Input.isRepeated('right')) {
  6008.             value++;
  6009.         }
  6010.         if (Input.isRepeated('left')) {
  6011.             value--;
  6012.         }
  6013.         if (Input.isRepeated('pagedown')) {
  6014.             value += 10;
  6015.         }
  6016.         if (Input.isRepeated('pageup')) {
  6017.             value -= 10;
  6018.         }
  6019.         if ($gameVariables.value(variableId) !== value) {
  6020.             $gameVariables.setValue(variableId, value);
  6021.             SoundManager.playCursor();
  6022.             this.redrawCurrentItem();
  6023.         }
  6024.     }
  6025. };
复制代码
作者: 雷影    时间: 2023-4-9 18:48
成功？失败？有点微妙！AI可以完整识别出是什么的代码！可要求改写以后，写出来的代码无效？也没报错，就是运行后没变化！
作者: 哇哇哇啊叭叭    时间: 2023-4-10 10:47
妈呀...眼瞎啦（捂眼A捂眼）(つ﹏⊂)~！！代码好~~~~~~~~~~~~~~~~~长

  这种需要“二分法”来排错呢。
  1. 把程序一分为2
  2. 分别测试1和2哪个有错
  3. 重复上述步骤







欢迎光临 Project1 (https://rpg.blue/) Powered by Discuz! X3.1