/**
* Суперкласс для всех сцен в игре
* The superclass of all scenes within the game
*
* @class Scene_Base
* @augments Stage
*/
function Scene_Base() {
this.initialize.apply(this, arguments);
}
Scene_Base.prototype = Object.create(Stage.prototype);
Scene_Base.prototype.constructor = Scene_Base;
/**
* Инициализирует объект класса
*
* initialize
*/
Scene_Base.prototype.initialize = function() {
};
/**
* Создает объекты в сцене
*
* create
*/
Scene_Base.prototype.create = function() {
};
/**
* Возвращает true, если сцена активна
*
* isActive
* @returns {Boolean} Сцена активна
*/
Scene_Base.prototype.isActive = function() {
};
/**
* Возвращает true, если сцена готова
*
* isReady
* @returns {Boolean} Сцена готова
*/
Scene_Base.prototype.isReady = function() {
};
/**
* Запускает сцену
*
* start
*/
Scene_Base.prototype.start = function() {
};
/**
* Обновляет сцену
*
* update
*/
Scene_Base.prototype.update = function() {
};
/**
* Останавливает сцену
*
* stop
*/
Scene_Base.prototype.stop = function() {
};
/**
* Возвращает true, если сцена занята
*
* isBusy
* @returns {Boolean} Сцена занята
*/
Scene_Base.prototype.isBusy = function() {
};
/**
* Уничтожает все объекты в сцене
*
* terminate
*/
Scene_Base.prototype.terminate = function() {
};
/**
* Создает слой для окон
*
* createWindowLayer
*/
Scene_Base.prototype.createWindowLayer = function() {
};
/**
* Добавляет окно в обработку сцены
*
* addWindow
* @param {*} window - Окно
*/
Scene_Base.prototype.addWindow = function(window) {
};
Scene_Base.prototype.startFadeIn = function(duration, white) {
this.createFadeSprite(white);
this._fadeSign = 1;
this._fadeDuration = duration || 30;
this._fadeSprite.opacity = 255;
};
Scene_Base.prototype.startFadeOut = function(duration, white) {
this.createFadeSprite(white);
this._fadeSign = -1;
this._fadeDuration = duration || 30;
this._fadeSprite.opacity = 0;
};
Scene_Base.prototype.createFadeSprite = function(white) {
if (!this._fadeSprite) {
this._fadeSprite = new ScreenSprite();
this.addChild(this._fadeSprite);
}
if (white) {
this._fadeSprite.setWhite();
} else {
this._fadeSprite.setBlack();
}
};
Scene_Base.prototype.updateFade = function() {
if (this._fadeDuration > 0) {
var d = this._fadeDuration;
if (this._fadeSign > 0) {
this._fadeSprite.opacity -= this._fadeSprite.opacity / d;
} else {
this._fadeSprite.opacity += (255 - this._fadeSprite.opacity) / d;
}
this._fadeDuration--;
}
};
Scene_Base.prototype.updateChildren = function() {
this.children.forEach(function(child) {
if (child.update) {
child.update();
}
});
};
/**
* Закрывает сцену
*
* popScene
*/
Scene_Base.prototype.popScene = function() {
};
Scene_Base.prototype.checkGameover = function() {
if ($gameParty.isAllDead()) {
SceneManager.goto(Scene_Gameover);
}
};
Scene_Base.prototype.fadeOutAll = function() {
var time = this.slowFadeSpeed() / 60;
AudioManager.fadeOutBgm(time);
AudioManager.fadeOutBgs(time);
AudioManager.fadeOutMe(time);
this.startFadeOut(this.slowFadeSpeed());
};
Scene_Base.prototype.fadeSpeed = function() {
return 24;
};
Scene_Base.prototype.slowFadeSpeed = function() {
return this.fadeSpeed() * 2;
};
/**
* Класс сцены, которая инициализирует игру
* The scene class for initializing the entire game
*
* @class Scene_Boot
* @augments Scene_Base
*/
function Scene_Boot() {
this.initialize.apply(this, arguments);
}
Scene_Boot.prototype = Object.create(Scene_Base.prototype);
Scene_Boot.prototype.constructor = Scene_Boot;
/**
* Инициализирует объект класса
*
* @override
* initialize
*/
Scene_Boot.prototype.initialize;
/**
* Создает объекты в сцене
*
* @override
* create
*/
Scene_Boot.prototype.create;
/**
* Загружает обложку окна
*
* loadSystemWindowImage
*/
Scene_Boot.prototype.loadSystemWindowImage;
/**
* Загружает системные изображения
*
* @static
* loadSystemImages
*/
Scene_Boot.loadSystemImages;
/**
* Возвращает true, если сцена готова
*
* @override
* isReady
* @returns {Boolean} Сцена готова
*/
Scene_Boot.prototype.isReady;
/**
* Возвращает true, если шрифт загружен
*
* isGameFontLoaded
* @returns {Boolean} Шрифт загружен
*/
Scene_Boot.prototype.isGameFontLoaded;
/**
* Запускает сцену
*
* @override
* start
*/
Scene_Boot.prototype.start;
/**
* Обновляет заголовок игры
*
* updateDocumentTitle
*/
Scene_Boot.prototype.updateDocumentTitle;
/**
* Проверяет начальную позицию игрока
*
* checkPlayerLocation
*/
Scene_Boot.prototype.checkPlayerLocation;
/**
* Класс сцены титульного экрана
* The scene class of the title screen
*
* @class Scene_Title
* @augments Scene_Base
*/
function Scene_Title() {
this.initialize.apply(this, arguments);
}
Scene_Title.prototype = Object.create(Scene_Base.prototype);
Scene_Title.prototype.constructor = Scene_Title;
/**
* Инициализирует объект класса
*
* @override
* initialize
*/
Scene_Title.prototype.initialize;
/**
* Создает объекты в сцене
*
* @override
* create
*/
Scene_Title.prototype.create;
/**
* Запускает сцену
*
* @override
* start
*/
Scene_Title.prototype.start;
/**
* Обновляет сцену
*
* @override
* update
*/
Scene_Title.prototype.update;
/**
* Возвращает true, если сцена занята
*
* @override
* isBusy
* @returns {Boolean} Сцена занята
*/
Scene_Title.prototype.isBusy;
/**
* Уничтожает все объекты в сцене
*
* @override
* terminate
*/
Scene_Title.prototype.terminate;
/**
* Создает задний фон
*
* createBackground
*/
Scene_Title.prototype.createBackground;
/**
* Создает передний фон
*
* createForeground
*/
Scene_Title.prototype.createForeground;
/**
* Рисует название игры
*
* drawGameTitle
*/
Scene_Title.prototype.drawGameTitle;
/**
* Центрирует спрайт
*
* centerSprite
* @param sprite - Спрайт
*/
Scene_Title.prototype.centerSprite;
/**
* Создает окно с командами
*
* createCommandWindow
*/
Scene_Title.prototype.createCommandWindow;
/**
* Обрабатывает выбор команды Новая игра
*
* commandNewGame
*/
Scene_Title.prototype.commandNewGame;
/**
* Обрабатывает выбор команды Продолжить
*
* commandContinue
*/
Scene_Title.prototype.commandContinue;
/**
* Обрабатывает выбор команды Опции
*
* commandOptions
*/
Scene_Title.prototype.commandOptions;
/**
* Запускает музыку титульного экрана
*
* playTitleMusic
*/
Scene_Title.prototype.playTitleMusic;
/**
* Класс сцены экрана карты
* The scene class of the map screen
*
* @class Scene_Map
* @augments Scene_Base
*/
function Scene_Map() {
this.initialize.apply(this, arguments);
}
Scene_Map.prototype = Object.create(Scene_Base.prototype);
Scene_Map.prototype.constructor = Scene_Map;
/**
* Инициализирует объект класса
*
* @override
* initialize
*/
Scene_Map.prototype.initialize;
/**
* Создает объекты в сцене
*
* @override
* create
*/
Scene_Map.prototype.create;
/**
* Возвращает true, если сцена готова
*
* @override
* isReady
* @returns {Boolean} Сцена готова
*/
Scene_Map.prototype.isReady;
/**
* Обрабатывает загрузку карты
*
* onMapLoaded
*/
Scene_Map.prototype.onMapLoaded;
/**
* Запускает сцену
*
* @override
* start
*/
Scene_Map.prototype.start;
/**
* Обновляет сцену
*
* @override
* update
*/
Scene_Map.prototype.update;
Scene_Map.prototype.updateMainMultiply = function() {
this.updateMain();
if (this.isFastForward()) {
this.updateMain();
}
};
Scene_Map.prototype.updateMain = function() {
var active = this.isActive();
$gameMap.update(active);
$gamePlayer.update(active);
$gameTimer.update(active);
$gameScreen.update();
};
Scene_Map.prototype.isFastForward = function() {
return ($gameMap.isEventRunning() && !SceneManager.isSceneChanging() &&
(Input.isLongPressed('ok') || TouchInput.isLongPressed()));
};
/**
* Останавливает сцену
*
* @override
* stop
*/
Scene_Map.prototype.stop;
/**
* Возвращает true, если сцена занята
*
* @override
* isBusy
* @returns {Boolean} Сцена занята
*/
Scene_Map.prototype.isBusy;
/**
* Уничтожает все объекты в сцене
*
* @override
* terminate
*/
Scene_Map.prototype.terminate;
Scene_Map.prototype.needsFadeIn = function() {
return (SceneManager.isPreviousScene(Scene_Battle) ||
SceneManager.isPreviousScene(Scene_Load));
};
Scene_Map.prototype.needsSlowFadeOut = function() {
return (SceneManager.isNextScene(Scene_Title) ||
SceneManager.isNextScene(Scene_Gameover));
};
Scene_Map.prototype.updateWaitCount = function() {
if (this._waitCount > 0) {
this._waitCount--;
return true;
}
return false;
};
Scene_Map.prototype.updateDestination = function() {
if (this.isMapTouchOk()) {
this.processMapTouch();
} else {
$gameTemp.clearDestination();
this._touchCount = 0;
}
};
Scene_Map.prototype.isMapTouchOk = function() {
return this.isActive() && $gamePlayer.canMove();
};
Scene_Map.prototype.processMapTouch = function() {
if (TouchInput.isTriggered() || this._touchCount > 0) {
if (TouchInput.isPressed()) {
if (this._touchCount === 0 || this._touchCount >= 15) {
var x = $gameMap.canvasToMapX(TouchInput.x);
var y = $gameMap.canvasToMapY(TouchInput.y);
$gameTemp.setDestination(x, y);
}
this._touchCount++;
} else {
this._touchCount = 0;
}
}
};
Scene_Map.prototype.isSceneChangeOk = function() {
return this.isActive() && !$gameMessage.isBusy();
};
Scene_Map.prototype.updateScene = function() {
this.checkGameover();
if (!SceneManager.isSceneChanging()) {
this.updateTransferPlayer();
}
if (!SceneManager.isSceneChanging()) {
this.updateEncounter();
}
if (!SceneManager.isSceneChanging()) {
this.updateCallMenu();
}
if (!SceneManager.isSceneChanging()) {
this.updateCallDebug();
}
};
/**
* Создает все отображаемые объекты
*
* createDisplayObjects
*/
Scene_Map.prototype.createDisplayObjects;
Scene_Map.prototype.createSpriteset = function() {
this._spriteset = new Spriteset_Map();
this.addChild(this._spriteset);
};
/**
* Создает все окна
*
* createAllWindows
*/
Scene_Map.prototype.createAllWindows;
/**
* Создает окно с названием карты
*
* createMapNameWindow
*/
Scene_Map.prototype.createMapNameWindow;
/**
* Создает окно сообщений
*
* createMessageWindow
*/
Scene_Map.prototype.createMessageWindow;
Scene_Map.prototype.createScrollTextWindow = function() {
this._scrollTextWindow = new Window_ScrollText();
this.addWindow(this._scrollTextWindow);
};
Scene_Map.prototype.updateTransferPlayer = function() {
if ($gamePlayer.isTransferring()) {
SceneManager.goto(Scene_Map);
}
};
Scene_Map.prototype.updateEncounter = function() {
if ($gamePlayer.executeEncounter()) {
SceneManager.push(Scene_Battle);
}
};
Scene_Map.prototype.updateCallMenu = function() {
if (this.isMenuEnabled()) {
if (this.isMenuCalled()) {
this.menuCalling = true;
}
if (this.menuCalling && !$gamePlayer.isMoving()) {
this.callMenu();
}
} else {
this.menuCalling = false;
}
};
/**
* Возвращает true, если меню доступно
*
* isMenuEnabled
* @returns {Boolean} Меню доступно
*/
Scene_Map.prototype.isMenuEnabled;
/**
* Возвращает true, если меню было вызвано
*
* isMenuCalled
* @returns {Boolean} Меню было вызвано
*/
Scene_Map.prototype.isMenuCalled;
/**
* Вызывает меню
*
* callMenu
*/
Scene_Map.prototype.callMenu;
/**
* Вызывает дебаг
*
* updateCallDebug
*/
Scene_Map.prototype.updateCallDebug;
/**
* Возвращает true, если дебаг был вызван
*
* isDebugCalled
* @returns {Boolean} Дебаг был вызван
*/
Scene_Map.prototype.isDebugCalled;
Scene_Map.prototype.fadeInForTransfer = function() {
var fadeType = $gamePlayer.fadeType();
switch (fadeType) {
case 0: case 1:
this.startFadeIn(this.fadeSpeed(), fadeType === 1);
break;
}
};
Scene_Map.prototype.fadeOutForTransfer = function() {
var fadeType = $gamePlayer.fadeType();
switch (fadeType) {
case 0: case 1:
this.startFadeOut(this.fadeSpeed(), fadeType === 1);
break;
}
};
Scene_Map.prototype.launchBattle = function() {
BattleManager.saveBgmAndBgs();
this.stopAudioOnBattleStart();
SoundManager.playBattleStart();
this.startEncounterEffect();
this._mapNameWindow.hide();
};
Scene_Map.prototype.stopAudioOnBattleStart = function() {
if (!AudioManager.isCurrentBgm($gameSystem.battleBgm())) {
AudioManager.stopBgm();
}
AudioManager.stopBgs();
AudioManager.stopMe();
AudioManager.stopSe();
};
Scene_Map.prototype.startEncounterEffect = function() {
this._spriteset.hideCharacters();
this._encounterEffectDuration = this.encounterEffectSpeed();
};
Scene_Map.prototype.updateEncounterEffect = function() {
if (this._encounterEffectDuration > 0) {
this._encounterEffectDuration--;
var speed = this.encounterEffectSpeed();
var n = speed - this._encounterEffectDuration;
var p = n / speed;
var q = ((p - 1) * 20 * p + 5) * p + 1;
var zoomX = $gamePlayer.screenX();
var zoomY = $gamePlayer.screenY() - 24;
if (n === 2) {
$gameScreen.setZoom(zoomX, zoomY, 1);
this.snapForBattleBackground();
this.startFlashForEncounter(speed / 2);
}
$gameScreen.setZoom(zoomX, zoomY, q);
if (n === Math.floor(speed / 6)) {
this.startFlashForEncounter(speed / 2);
}
if (n === Math.floor(speed / 2)) {
BattleManager.playBattleBgm();
this.startFadeOut(this.fadeSpeed());
}
}
};
Scene_Map.prototype.snapForBattleBackground = function() {
this._windowLayer.visible = false;
SceneManager.snapForBackground();
this._windowLayer.visible = true;
};
Scene_Map.prototype.startFlashForEncounter = function(duration) {
var color = [255, 255, 255, 255];
$gameScreen.startFlash(color, duration);
};
Scene_Map.prototype.encounterEffectSpeed = function() {
return 60;
};
/**
* Суперкласс для всех сцен типа меню
* The superclass of all the menu-type scenes
*
* @class Scene_MenuBase
* @augments Scene_Base
*/
function Scene_MenuBase() {
this.initialize.apply(this, arguments);
}
Scene_MenuBase.prototype = Object.create(Scene_Base.prototype);
Scene_MenuBase.prototype.constructor = Scene_MenuBase;
/**
* Инициализирует объект класса
*
* @override
* initialize
*/
Scene_MenuBase.prototype.initialize;
/**
* Создает объекты в сцене
*
* @override
* create
*/
Scene_MenuBase.prototype.create;
/**
* Возвращает персонажа, выбранного в меню
*
* actor
* @returns {Game_Actor} Персонаж, выбранный в меню
*/
Scene_MenuBase.prototype.actor;
/**
* Устанавливает персонажа меню
*
* updateActor
*/
Scene_MenuBase.prototype.updateActor;
/**
* Создает задний фон
*
* createBackground
*/
Scene_MenuBase.prototype.createBackground;
/**
* Устанавливает прозрачность фона
*
* setBackgroundOpacity
* @param {Number} opacity - Прозрачность фона
*/
Scene_MenuBase.prototype.setBackgroundOpacity;
/**
* Создает окно помощи
*
* createHelpWindow
*/
Scene_MenuBase.prototype.createHelpWindow;
/**
* Выбирает следующего персонажа в меню
*
* nextActor
*/
Scene_MenuBase.prototype.nextActor;
/**
* Выбирает предыдущего персонажа в меню
*
* previousActor
*/
Scene_MenuBase.prototype.previousActor;
/**
* Обрабатывает изменение персонажа в меню
*
* onActorChange
*/
Scene_MenuBase.prototype.onActorChange;
/**
* Класс сцены экрана меню
* The scene class of the menu screen
*
* @class Scene_Menu
* @augments Scene_MenuBase
*/
function Scene_Menu() {
this.initialize.apply(this, arguments);
}
Scene_Menu.prototype = Object.create(Scene_MenuBase.prototype);
Scene_Menu.prototype.constructor = Scene_Menu;
/**
* Инициализирует объект класса
*
* @override
* initialize
*/
Scene_Menu.prototype.initialize;
/**
* Создает объекты в сцене
*
* @override
* create
*/
Scene_Menu.prototype.create;
/**
* Запускает сцену
*
* @override
* start
*/
Scene_Menu.prototype.start;
/**
* Создает окно с командами
*
* createCommandWindow
*/
Scene_Menu.prototype.createCommandWindow;
/**
* Создает окно золота
*
* createGoldWindow
*/
Scene_Menu.prototype.createGoldWindow;
/**
* Создает окно статуса
*
* createStatusWindow
*/
Scene_Menu.prototype.createStatusWindow;
/**
* Обрабатывает выбор команды Вещи
*
* commandItem
*/
Scene_Menu.prototype.commandItem;
/**
* Обрабатывает выбор команды Состояние
*
* commandPersonal
*/
Scene_Menu.prototype.commandPersonal;
/**
* Обрабатывает выбор команды Построение
*
* commandFormation
*/
Scene_Menu.prototype.commandFormation;
/**
* Обрабатывает выбор команды Опции
*
* commandOptions
*/
Scene_Menu.prototype.commandOptions;
/**
* Обрабатывает выбор команды Сохранить
*
* commandSave
*/
Scene_Menu.prototype.commandSave;
/**
* Обрабатывает выбор команды Конец игры
*
* commandGameEnd
*/
Scene_Menu.prototype.commandGameEnd;
Scene_Menu.prototype.onPersonalOk = function() {
switch (this._commandWindow.currentSymbol()) {
case 'skill':
SceneManager.push(Scene_Skill);
break;
case 'equip':
SceneManager.push(Scene_Equip);
break;
case 'status':
SceneManager.push(Scene_Status);
break;
}
};
Scene_Menu.prototype.onPersonalCancel = function() {
this._statusWindow.deselect();
this._commandWindow.activate();
};
Scene_Menu.prototype.onFormationOk = function() {
var index = this._statusWindow.index();
var actor = $gameParty.members()[index];
var pendingIndex = this._statusWindow.pendingIndex();
if (pendingIndex >= 0) {
$gameParty.swapOrder(index, pendingIndex);
this._statusWindow.setPendingIndex(-1);
this._statusWindow.redrawItem(index);
} else {
this._statusWindow.setPendingIndex(index);
}
this._statusWindow.activate();
};
Scene_Menu.prototype.onFormationCancel = function() {
if (this._statusWindow.pendingIndex() >= 0) {
this._statusWindow.setPendingIndex(-1);
this._statusWindow.activate();
} else {
this._statusWindow.deselect();
this._commandWindow.activate();
}
};
/**
* Суперкласс для Scene_Item и Scene_Skill
* The superclass of Scene_Item and Scene_Skill
*
* @class Scene_ItemBase
* @augments Scene_MenuBase
*/
function Scene_ItemBase() {
this.initialize.apply(this, arguments);
}
Scene_ItemBase.prototype = Object.create(Scene_MenuBase.prototype);
Scene_ItemBase.prototype.constructor = Scene_ItemBase;
/**
* Инициализирует объект класса
*
* @override
* initialize
*/
Scene_ItemBase.prototype.initialize;
/**
* Создает объекты в сцене
*
* @override
* create
*/
Scene_ItemBase.prototype.create;
Scene_ItemBase.prototype.createActorWindow = function() {
this._actorWindow = new Window_MenuActor();
this._actorWindow.setHandler('ok', this.onActorOk.bind(this));
this._actorWindow.setHandler('cancel', this.onActorCancel.bind(this));
this.addWindow(this._actorWindow);
};
Scene_ItemBase.prototype.item = function() {
return this._itemWindow.item();
};
Scene_ItemBase.prototype.user = function() {
return null;
};
Scene_ItemBase.prototype.isCursorLeft = function() {
return this._itemWindow.index() % 2 === 0;
};
Scene_ItemBase.prototype.showSubWindow = function(window) {
window.x = this.isCursorLeft() ? Graphics.boxWidth - window.width : 0;
window.show();
window.activate();
};
Scene_ItemBase.prototype.hideSubWindow = function(window) {
window.hide();
window.deactivate();
this.activateItemWindow();
};
Scene_ItemBase.prototype.onActorOk = function() {
if (this.canUse()) {
this.useItem();
} else {
SoundManager.playBuzzer();
}
};
Scene_ItemBase.prototype.onActorCancel = function() {
this.hideSubWindow(this._actorWindow);
};
Scene_ItemBase.prototype.determineItem = function() {
var action = new Game_Action(this.user());
var item = this.item();
action.setItemObject(item);
if (action.isForFriend()) {
this.showSubWindow(this._actorWindow);
this._actorWindow.selectForItem(this.item());
} else {
this.useItem();
this.activateItemWindow();
}
};
Scene_ItemBase.prototype.useItem = function() {
this.playSeForItem();
this.user().useItem(this.item());
this.applyItem();
this.checkCommonEvent();
this.checkGameover();
this._actorWindow.refresh();
};
Scene_ItemBase.prototype.activateItemWindow = function() {
this._itemWindow.refresh();
this._itemWindow.activate();
};
Scene_ItemBase.prototype.itemTargetActors = function() {
var action = new Game_Action(this.user());
action.setItemObject(this.item());
if (!action.isForFriend()) {
return [];
} else if (action.isForAll()) {
return $gameParty.members();
} else {
return [$gameParty.members()[this._actorWindow.index()]];
}
};
Scene_ItemBase.prototype.canUse = function() {
return this.user().canUse(this.item()) && this.isItemEffectsValid();
};
Scene_ItemBase.prototype.isItemEffectsValid = function() {
var action = new Game_Action(this.user());
action.setItemObject(this.item());
return this.itemTargetActors().some(function(target) {
return action.testApply(target);
}, this);
};
Scene_ItemBase.prototype.applyItem = function() {
var action = new Game_Action(this.user());
action.setItemObject(this.item());
this.itemTargetActors().forEach(function(target) {
for (var i = 0; i < action.numRepeats(); i++) {
action.apply(target);
}
}, this);
action.applyGlobal();
};
Scene_ItemBase.prototype.checkCommonEvent = function() {
if ($gameTemp.isCommonEventReserved()) {
SceneManager.goto(Scene_Map);
}
};
/**
* Класс сцены экрана вещей
* The scene class of the item screen
*
* @class Scene_Item
* @augments Scene_ItemBase
*/
function Scene_Item() {
this.initialize.apply(this, arguments);
}
Scene_Item.prototype = Object.create(Scene_ItemBase.prototype);
Scene_Item.prototype.constructor = Scene_Item;
/**
* Инициализирует объект класса
*
* @override
* initialize
*/
Scene_Item.prototype.initialize;
/**
* Создает объекты в сцене
*
* @override
* create
*/
Scene_Item.prototype.create;
Scene_Item.prototype.createCategoryWindow = function() {
this._categoryWindow = new Window_ItemCategory();
this._categoryWindow.setHelpWindow(this._helpWindow);
this._categoryWindow.y = this._helpWindow.height;
this._categoryWindow.setHandler('ok', this.onCategoryOk.bind(this));
this._categoryWindow.setHandler('cancel', this.popScene.bind(this));
this.addWindow(this._categoryWindow);
};
Scene_Item.prototype.createItemWindow = function() {
var wy = this._categoryWindow.y + this._categoryWindow.height;
var wh = Graphics.boxHeight - wy;
this._itemWindow = new Window_ItemList(0, wy, Graphics.boxWidth, wh);
this._itemWindow.setHelpWindow(this._helpWindow);
this._itemWindow.setHandler('ok', this.onItemOk.bind(this));
this._itemWindow.setHandler('cancel', this.onItemCancel.bind(this));
this.addWindow(this._itemWindow);
this._categoryWindow.setItemWindow(this._itemWindow);
};
Scene_Item.prototype.user = function() {
var members = $gameParty.movableMembers();
var bestActor = members[0];
var bestPha = 0;
for (var i = 0; i < members.length; i++) {
if (members[i].pha > bestPha) {
bestPha = members[i].pha;
bestActor = members[i];
}
}
return bestActor;
};
Scene_Item.prototype.onCategoryOk = function() {
this._itemWindow.activate();
this._itemWindow.selectLast();
};
Scene_Item.prototype.onItemOk = function() {
$gameParty.setLastItem(this.item());
this.determineItem();
};
Scene_Item.prototype.onItemCancel = function() {
this._itemWindow.deselect();
this._categoryWindow.activate();
};
Scene_Item.prototype.playSeForItem = function() {
SoundManager.playUseItem();
};
Scene_Item.prototype.useItem = function() {
Scene_ItemBase.prototype.useItem.call(this);
this._itemWindow.redrawCurrentItem();
};
/**
* Класс сцены экрана навыков
* The scene class of the skill screen
*
* @class Scene_Skill
* @augments Scene_ItemBase
*/
function Scene_Skill() {
this.initialize.apply(this, arguments);
}
Scene_Skill.prototype = Object.create(Scene_ItemBase.prototype);
Scene_Skill.prototype.constructor = Scene_Skill;
/**
* Инициализирует объект класса
*
* @override
* initialize
*/
Scene_Skill.prototype.initialize;
/**
* Создает объекты в сцене
*
* @override
* create
*/
Scene_Skill.prototype.create;
Scene_Skill.prototype.createSkillTypeWindow = function() {
var wy = this._helpWindow.height;
this._skillTypeWindow = new Window_SkillType(0, wy);
this._skillTypeWindow.setHelpWindow(this._helpWindow);
this._skillTypeWindow.setHandler('skill', this.commandSkill.bind(this));
this._skillTypeWindow.setHandler('cancel', this.popScene.bind(this));
this._skillTypeWindow.setHandler('pagedown', this.nextActor.bind(this));
this._skillTypeWindow.setHandler('pageup', this.previousActor.bind(this));
this.addWindow(this._skillTypeWindow);
};
Scene_Skill.prototype.createStatusWindow = function() {
var wx = this._skillTypeWindow.width;
var wy = this._helpWindow.height;
var ww = Graphics.boxWidth - wx;
var wh = this._skillTypeWindow.height;
this._statusWindow = new Window_SkillStatus(wx, wy, ww, wh);
this.addWindow(this._statusWindow);
};
Scene_Skill.prototype.createItemWindow = function() {
var wx = 0;
var wy = this._statusWindow.y + this._statusWindow.height;
var ww = Graphics.boxWidth;
var wh = Graphics.boxHeight - wy;
this._itemWindow = new Window_SkillList(wx, wy, ww, wh);
this._itemWindow.setHelpWindow(this._helpWindow);
this._itemWindow.setHandler('ok', this.onItemOk.bind(this));
this._itemWindow.setHandler('cancel', this.onItemCancel.bind(this));
this._skillTypeWindow.setSkillWindow(this._itemWindow);
this.addWindow(this._itemWindow);
};
Scene_Skill.prototype.refreshActor = function() {
var actor = this.actor();
this._skillTypeWindow.setActor(actor);
this._statusWindow.setActor(actor);
this._itemWindow.setActor(actor);
};
Scene_Skill.prototype.user = function() {
return this.actor();
};
Scene_Skill.prototype.commandSkill = function() {
this._itemWindow.activate();
this._itemWindow.selectLast();
};
Scene_Skill.prototype.onItemOk = function() {
this.actor().setLastMenuSkill(this.item());
this.determineItem();
};
Scene_Skill.prototype.onItemCancel = function() {
this._itemWindow.deselect();
this._skillTypeWindow.activate();
};
Scene_Skill.prototype.playSeForItem = function() {
SoundManager.playUseSkill();
};
Scene_Skill.prototype.useItem = function() {
Scene_ItemBase.prototype.useItem.call(this);
this._statusWindow.refresh();
this._itemWindow.refresh();
};
Scene_Skill.prototype.onActorChange = function() {
this.refreshActor();
this._skillTypeWindow.activate();
};
/**
* Класс сцены экрана экипировки
* The scene class of the equipment screen
*
* @class Scene_Equip
* @augments Scene_MenuBase
*/
function Scene_Equip() {
this.initialize.apply(this, arguments);
}
Scene_Equip.prototype = Object.create(Scene_MenuBase.prototype);
Scene_Equip.prototype.constructor = Scene_Equip;
/**
* Инициализирует объект класса
*
* @override
* initialize
*/
Scene_Equip.prototype.initialize;
/**
* Создает объекты в сцене
*
* @override
* create
*/
Scene_Equip.prototype.create;
Scene_Equip.prototype.createStatusWindow = function() {
this._statusWindow = new Window_EquipStatus(0, this._helpWindow.height);
this.addWindow(this._statusWindow);
};
Scene_Equip.prototype.createCommandWindow = function() {
var wx = this._statusWindow.width;
var wy = this._helpWindow.height;
var ww = Graphics.boxWidth - this._statusWindow.width;
this._commandWindow = new Window_EquipCommand(wx, wy, ww);
this._commandWindow.setHelpWindow(this._helpWindow);
this._commandWindow.setHandler('equip', this.commandEquip.bind(this));
this._commandWindow.setHandler('optimize', this.commandOptimize.bind(this));
this._commandWindow.setHandler('clear', this.commandClear.bind(this));
this._commandWindow.setHandler('cancel', this.popScene.bind(this));
this._commandWindow.setHandler('pagedown', this.nextActor.bind(this));
this._commandWindow.setHandler('pageup', this.previousActor.bind(this));
this.addWindow(this._commandWindow);
};
Scene_Equip.prototype.createSlotWindow = function() {
var wx = this._statusWindow.width;
var wy = this._commandWindow.y + this._commandWindow.height;
var ww = Graphics.boxWidth - this._statusWindow.width;
var wh = this._statusWindow.height - this._commandWindow.height;
this._slotWindow = new Window_EquipSlot(wx, wy, ww, wh);
this._slotWindow.setHelpWindow(this._helpWindow);
this._slotWindow.setStatusWindow(this._statusWindow);
this._slotWindow.setHandler('ok', this.onSlotOk.bind(this));
this._slotWindow.setHandler('cancel', this.onSlotCancel.bind(this));
this.addWindow(this._slotWindow);
};
Scene_Equip.prototype.createItemWindow = function() {
var wx = 0;
var wy = this._statusWindow.y + this._statusWindow.height;
var ww = Graphics.boxWidth;
var wh = Graphics.boxHeight - wy;
this._itemWindow = new Window_EquipItem(wx, wy, ww, wh);
this._itemWindow.setHelpWindow(this._helpWindow);
this._itemWindow.setStatusWindow(this._statusWindow);
this._itemWindow.setHandler('ok', this.onItemOk.bind(this));
this._itemWindow.setHandler('cancel', this.onItemCancel.bind(this));
this._slotWindow.setItemWindow(this._itemWindow);
this.addWindow(this._itemWindow);
};
Scene_Equip.prototype.refreshActor = function() {
var actor = this.actor();
this._statusWindow.setActor(actor);
this._slotWindow.setActor(actor);
this._itemWindow.setActor(actor);
};
Scene_Equip.prototype.commandEquip = function() {
this._slotWindow.activate();
this._slotWindow.select(0);
};
Scene_Equip.prototype.commandOptimize = function() {
SoundManager.playEquip();
this.actor().optimizeEquipments();
this._statusWindow.refresh();
this._slotWindow.refresh();
this._commandWindow.activate();
};
Scene_Equip.prototype.commandClear = function() {
SoundManager.playEquip();
this.actor().clearEquipments();
this._statusWindow.refresh();
this._slotWindow.refresh();
this._commandWindow.activate();
};
Scene_Equip.prototype.onSlotOk = function() {
this._itemWindow.activate();
this._itemWindow.select(0);
};
Scene_Equip.prototype.onSlotCancel = function() {
this._slotWindow.deselect();
this._commandWindow.activate();
};
Scene_Equip.prototype.onItemOk = function() {
SoundManager.playEquip();
this.actor().changeEquip(this._slotWindow.index(), this._itemWindow.item());
this._slotWindow.activate();
this._slotWindow.refresh();
this._itemWindow.deselect();
this._itemWindow.refresh();
this._statusWindow.refresh();
};
Scene_Equip.prototype.onItemCancel = function() {
this._slotWindow.activate();
this._itemWindow.deselect();
};
Scene_Equip.prototype.onActorChange = function() {
this.refreshActor();
this._commandWindow.activate();
};
/**
* Класс сцены экрана статуса
* The scene class of the status screen
*
* @class Scene_Status
* @augments Scene_MenuBase
*/
function Scene_Status() {
this.initialize.apply(this, arguments);
}
Scene_Status.prototype = Object.create(Scene_MenuBase.prototype);
Scene_Status.prototype.constructor = Scene_Status;
/**
* Инициализирует объект класса
*
* @override
* initialize
*/
Scene_Status.prototype.initialize;
/**
* Создает объекты в сцене
*
* @override
* create
*/
Scene_Status.prototype.create;
Scene_Status.prototype.refreshActor = function() {
var actor = this.actor();
this._statusWindow.setActor(actor);
};
Scene_Status.prototype.onActorChange = function() {
this.refreshActor();
this._statusWindow.activate();
};
/**
* Класс сцены экрана опций
* The scene class of the options screen
*
* @class Scene_Options
* @augments Scene_MenuBase
*/
function Scene_Options() {
this.initialize.apply(this, arguments);
}
Scene_Options.prototype = Object.create(Scene_MenuBase.prototype);
Scene_Options.prototype.constructor = Scene_Options;
/**
* Инициализирует объект класса
*
* @override
* initialize
*/
Scene_Options.prototype.initialize;
/**
* Создает объекты в сцене
*
* @override
* create
*/
Scene_Options.prototype.create;
/**
* Уничтожает все объекты в сцене
*
* @override
* terminate
*/
Scene_Options.prototype.terminate;
/**
* Создает окно опций
*
* createOptionsWindow
*/
Scene_Options.prototype.createOptionsWindow;
/**
* Суперкласс для Scene_Save и Scene_Load
* The superclass of Scene_Save and Scene_Load
*
* @class Scene_File
* @augments Scene_MenuBase
*/
function Scene_File() {
this.initialize.apply(this, arguments);
}
Scene_File.prototype = Object.create(Scene_MenuBase.prototype);
Scene_File.prototype.constructor = Scene_File;
/**
* Инициализирует объект класса
*
* @override
* initialize
*/
Scene_File.prototype.initialize;
/**
* Создает объекты в сцене
*
* @override
* create
*/
Scene_File.prototype.create;
/**
* Запускает сцену
*
* @override
* start
*/
Scene_File.prototype.start;
Scene_File.prototype.savefileId = function() {
return this._listWindow.index() + 1;
};
Scene_File.prototype.createHelpWindow = function() {
this._helpWindow = new Window_Help(1);
this._helpWindow.setText(this.helpWindowText());
this.addWindow(this._helpWindow);
};
Scene_File.prototype.createListWindow = function() {
var x = 0;
var y = this._helpWindow.height;
var width = Graphics.boxWidth;
var height = Graphics.boxHeight - y;
this._listWindow = new Window_SavefileList(x, y, width, height);
this._listWindow.setHandler('ok', this.onSavefileOk.bind(this));
this._listWindow.setHandler('cancel', this.popScene.bind(this));
this._listWindow.select(this.firstSavefileIndex());
this._listWindow.setTopRow(this.firstSavefileIndex() - 2);
this._listWindow.setMode(this.mode());
this._listWindow.refresh();
this.addWindow(this._listWindow);
};
Scene_File.prototype.mode = function() {
return null;
};
Scene_File.prototype.activateListWindow = function() {
this._listWindow.activate();
};
Scene_File.prototype.helpWindowText = function() {
return '';
};
Scene_File.prototype.firstSavefileIndex = function() {
return 0;
};
Scene_File.prototype.onSavefileOk = function() {
};
/**
* Класс сцены экрана сохранения
* The scene class of the save screen
*
* @class Scene_Save
* @augments Scene_File
*/
function Scene_Save() {
this.initialize.apply(this, arguments);
}
Scene_Save.prototype = Object.create(Scene_File.prototype);
Scene_Save.prototype.constructor = Scene_Save;
/**
* Инициализирует объект класса
*
* @override
* initialize
*/
Scene_Save.prototype.initialize;
Scene_Save.prototype.mode = function() {
return 'save';
};
Scene_Save.prototype.helpWindowText = function() {
return TextManager.saveMessage;
};
Scene_Save.prototype.firstSavefileIndex = function() {
return DataManager.lastAccessedSavefileId() - 1;
};
Scene_Save.prototype.onSavefileOk = function() {
Scene_File.prototype.onSavefileOk.call(this);
$gameSystem.onBeforeSave();
if (DataManager.saveGame(this.savefileId())) {
this.onSaveSuccess();
} else {
this.onSaveFailure();
}
};
Scene_Save.prototype.onSaveSuccess = function() {
SoundManager.playSave();
StorageManager.cleanBackup(this.savefileId());
this.popScene();
};
Scene_Save.prototype.onSaveFailure = function() {
SoundManager.playBuzzer();
this.activateListWindow();
};
/**
* Класс сцены экрана загрузки
* The scene class of the load screen
*
* @class Scene_Load
* @augments Scene_File
*/
function Scene_Load() {
this.initialize.apply(this, arguments);
}
Scene_Load.prototype = Object.create(Scene_File.prototype);
Scene_Load.prototype.constructor = Scene_Load;
/**
* Инициализирует объект класса
*
* @override
* initialize
*/
Scene_Load.prototype.initialize;
/**
* Уничтожает все объекты в сцене
*
* @override
* terminate
*/
Scene_Load.prototype.terminate;
Scene_Load.prototype.mode = function() {
return 'load';
};
Scene_Load.prototype.helpWindowText = function() {
return TextManager.loadMessage;
};
Scene_Load.prototype.firstSavefileIndex = function() {
return DataManager.latestSavefileId() - 1;
};
Scene_Load.prototype.onSavefileOk = function() {
Scene_File.prototype.onSavefileOk.call(this);
if (DataManager.loadGame(this.savefileId())) {
this.onLoadSuccess();
} else {
this.onLoadFailure();
}
};
Scene_Load.prototype.onLoadSuccess = function() {
SoundManager.playLoad();
this.fadeOutAll();
this.reloadMapIfUpdated();
SceneManager.goto(Scene_Map);
this._loadSuccess = true;
};
Scene_Load.prototype.onLoadFailure = function() {
SoundManager.playBuzzer();
this.activateListWindow();
};
Scene_Load.prototype.reloadMapIfUpdated = function() {
if ($gameSystem.versionId() !== $dataSystem.versionId) {
$gamePlayer.reserveTransfer($gameMap.mapId(), $gamePlayer.x, $gamePlayer.y);
$gamePlayer.requestMapReload();
}
};
/**
* Класс сцены экрана выхода из игры
* The scene class of the game end screen
*
* @class Scene_GameEnd
* @augments Scene_MenuBase
*/
function Scene_GameEnd() {
this.initialize.apply(this, arguments);
}
Scene_GameEnd.prototype = Object.create(Scene_MenuBase.prototype);
Scene_GameEnd.prototype.constructor = Scene_GameEnd;
/**
* Инициализирует объект класса
*
* @override
* initialize
*/
Scene_GameEnd.prototype.initialize;
/**
* Создает объекты в сцене
*
* @override
* create
*/
Scene_GameEnd.prototype.create;
/**
* Останавливает сцену
*
* @override
* stop
*/
Scene_GameEnd.prototype.stop;
Scene_GameEnd.prototype.createBackground = function() {
Scene_MenuBase.prototype.createBackground.call(this);
this.setBackgroundOpacity(128);
};
Scene_GameEnd.prototype.createCommandWindow = function() {
this._commandWindow = new Window_GameEnd();
this._commandWindow.setHandler('toTitle', this.commandToTitle.bind(this));
this._commandWindow.setHandler('cancel', this.popScene.bind(this));
this.addWindow(this._commandWindow);
};
Scene_GameEnd.prototype.commandToTitle = function() {
this.fadeOutAll();
SceneManager.goto(Scene_Title);
};
/**
* Класс сцены экрана магазина
* The scene class of the shop screen
*
* @class Scene_Shop
* @augments Scene_MenuBase
*/
function Scene_Shop() {
this.initialize.apply(this, arguments);
}
Scene_Shop.prototype = Object.create(Scene_MenuBase.prototype);
Scene_Shop.prototype.constructor = Scene_Shop;
/**
* Инициализирует объект класса
*
* @override
* initialize
*/
Scene_Shop.prototype.initialize;
Scene_Shop.prototype.prepare = function(goods, purchaseOnly) {
this._goods = goods;
this._purchaseOnly = purchaseOnly;
this._item = null;
};
/**
* Создает объекты в сцене
*
* @override
* create
*/
Scene_Shop.prototype.create;
Scene_Shop.prototype.createGoldWindow = function() {
this._goldWindow = new Window_Gold(0, this._helpWindow.height);
this._goldWindow.x = Graphics.boxWidth - this._goldWindow.width;
this.addWindow(this._goldWindow);
};
Scene_Shop.prototype.createCommandWindow = function() {
this._commandWindow = new Window_ShopCommand(this._goldWindow.x, this._purchaseOnly);
this._commandWindow.y = this._helpWindow.height;
this._commandWindow.setHandler('buy', this.commandBuy.bind(this));
this._commandWindow.setHandler('sell', this.commandSell.bind(this));
this._commandWindow.setHandler('cancel', this.popScene.bind(this));
this.addWindow(this._commandWindow);
};
Scene_Shop.prototype.createDummyWindow = function() {
var wy = this._commandWindow.y + this._commandWindow.height;
var wh = Graphics.boxHeight - wy;
this._dummyWindow = new Window_Base(0, wy, Graphics.boxWidth, wh);
this.addWindow(this._dummyWindow);
};
Scene_Shop.prototype.createNumberWindow = function() {
var wy = this._dummyWindow.y;
var wh = this._dummyWindow.height;
this._numberWindow = new Window_ShopNumber(0, wy, wh);
this._numberWindow.hide();
this._numberWindow.setHandler('ok', this.onNumberOk.bind(this));
this._numberWindow.setHandler('cancel', this.onNumberCancel.bind(this));
this.addWindow(this._numberWindow);
};
Scene_Shop.prototype.createStatusWindow = function() {
var wx = this._numberWindow.width;
var wy = this._dummyWindow.y;
var ww = Graphics.boxWidth - wx;
var wh = this._dummyWindow.height;
this._statusWindow = new Window_ShopStatus(wx, wy, ww, wh);
this._statusWindow.hide();
this.addWindow(this._statusWindow);
};
Scene_Shop.prototype.createBuyWindow = function() {
var wy = this._dummyWindow.y;
var wh = this._dummyWindow.height;
this._buyWindow = new Window_ShopBuy(0, wy, wh, this._goods);
this._buyWindow.setHelpWindow(this._helpWindow);
this._buyWindow.setStatusWindow(this._statusWindow);
this._buyWindow.hide();
this._buyWindow.setHandler('ok', this.onBuyOk.bind(this));
this._buyWindow.setHandler('cancel', this.onBuyCancel.bind(this));
this.addWindow(this._buyWindow);
};
Scene_Shop.prototype.createCategoryWindow = function() {
this._categoryWindow = new Window_ItemCategory();
this._categoryWindow.setHelpWindow(this._helpWindow);
this._categoryWindow.y = this._dummyWindow.y;
this._categoryWindow.hide();
this._categoryWindow.deactivate();
this._categoryWindow.setHandler('ok', this.onCategoryOk.bind(this));
this._categoryWindow.setHandler('cancel', this.onCategoryCancel.bind(this));
this.addWindow(this._categoryWindow);
};
Scene_Shop.prototype.createSellWindow = function() {
var wy = this._categoryWindow.y + this._categoryWindow.height;
var wh = Graphics.boxHeight - wy;
this._sellWindow = new Window_ShopSell(0, wy, Graphics.boxWidth, wh);
this._sellWindow.setHelpWindow(this._helpWindow);
this._sellWindow.hide();
this._sellWindow.setHandler('ok', this.onSellOk.bind(this));
this._sellWindow.setHandler('cancel', this.onSellCancel.bind(this));
this._categoryWindow.setItemWindow(this._sellWindow);
this.addWindow(this._sellWindow);
};
Scene_Shop.prototype.activateBuyWindow = function() {
this._buyWindow.setMoney(this.money());
this._buyWindow.show();
this._buyWindow.activate();
this._statusWindow.show();
};
Scene_Shop.prototype.activateSellWindow = function() {
this._categoryWindow.show();
this._sellWindow.refresh();
this._sellWindow.show();
this._sellWindow.activate();
this._statusWindow.hide();
};
Scene_Shop.prototype.commandBuy = function() {
this._dummyWindow.hide();
this.activateBuyWindow();
};
Scene_Shop.prototype.commandSell = function() {
this._dummyWindow.hide();
this._categoryWindow.show();
this._categoryWindow.activate();
this._sellWindow.show();
this._sellWindow.deselect();
this._sellWindow.refresh();
};
Scene_Shop.prototype.onBuyOk = function() {
this._item = this._buyWindow.item();
this._buyWindow.hide();
this._numberWindow.setup(this._item, this.maxBuy(), this.buyingPrice());
this._numberWindow.setCurrencyUnit(this.currencyUnit());
this._numberWindow.show();
this._numberWindow.activate();
};
Scene_Shop.prototype.onBuyCancel = function() {
this._commandWindow.activate();
this._dummyWindow.show();
this._buyWindow.hide();
this._statusWindow.hide();
this._statusWindow.setItem(null);
this._helpWindow.clear();
};
Scene_Shop.prototype.onCategoryOk = function() {
this.activateSellWindow();
this._sellWindow.select(0);
};
Scene_Shop.prototype.onCategoryCancel = function() {
this._commandWindow.activate();
this._dummyWindow.show();
this._categoryWindow.hide();
this._sellWindow.hide();
};
Scene_Shop.prototype.onSellOk = function() {
this._item = this._sellWindow.item();
this._categoryWindow.hide();
this._sellWindow.hide();
this._numberWindow.setup(this._item, this.maxSell(), this.sellingPrice());
this._numberWindow.setCurrencyUnit(this.currencyUnit());
this._numberWindow.show();
this._numberWindow.activate();
this._statusWindow.setItem(this._item);
this._statusWindow.show();
};
Scene_Shop.prototype.onSellCancel = function() {
this._sellWindow.deselect();
this._categoryWindow.activate();
this._statusWindow.setItem(null);
this._helpWindow.clear();
};
Scene_Shop.prototype.onNumberOk = function() {
SoundManager.playShop();
switch (this._commandWindow.currentSymbol()) {
case 'buy':
this.doBuy(this._numberWindow.number());
break;
case 'sell':
this.doSell(this._numberWindow.number());
break;
}
this.endNumberInput();
this._goldWindow.refresh();
this._statusWindow.refresh();
};
Scene_Shop.prototype.onNumberCancel = function() {
SoundManager.playCancel();
this.endNumberInput();
};
Scene_Shop.prototype.doBuy = function(number) {
$gameParty.loseGold(number * this.buyingPrice());
$gameParty.gainItem(this._item, number);
};
Scene_Shop.prototype.doSell = function(number) {
$gameParty.gainGold(number * this.sellingPrice());
$gameParty.loseItem(this._item, number);
};
Scene_Shop.prototype.endNumberInput = function() {
this._numberWindow.hide();
switch (this._commandWindow.currentSymbol()) {
case 'buy':
this.activateBuyWindow();
break;
case 'sell':
this.activateSellWindow();
break;
}
};
Scene_Shop.prototype.maxBuy = function() {
var max = $gameParty.maxItems(this._item) - $gameParty.numItems(this._item);
var price = this.buyingPrice();
if (price > 0) {
return Math.min(max, Math.floor(this.money() / price));
} else {
return max;
}
};
Scene_Shop.prototype.maxSell = function() {
return $gameParty.numItems(this._item);
};
Scene_Shop.prototype.money = function() {
return this._goldWindow.value();
};
Scene_Shop.prototype.currencyUnit = function() {
return this._goldWindow.currencyUnit();
};
Scene_Shop.prototype.buyingPrice = function() {
return this._buyWindow.price(this._item);
};
Scene_Shop.prototype.sellingPrice = function() {
return Math.floor(this._item.price / 2);
};
/**
* Класс сцены экрана ввода имени
* The scene class of the name input screen
*
* @class Scene_Name
* @augments Scene_MenuBase
*/
function Scene_Name() {
this.initialize.apply(this, arguments);
}
Scene_Name.prototype = Object.create(Scene_MenuBase.prototype);
Scene_Name.prototype.constructor = Scene_Name;
/**
* Инициализирует объект класса
*
* @override
* initialize
*/
Scene_Name.prototype.initialize;
Scene_Name.prototype.prepare = function(actorId, maxLength) {
this._actorId = actorId;
this._maxLength = maxLength;
};
/**
* Создает объекты в сцене
*
* @override
* create
*/
Scene_Name.prototype.create;
/**
* Запускает сцену
*
* @override
* start
*/
Scene_Name.prototype.start;
Scene_Name.prototype.createEditWindow = function() {
this._editWindow = new Window_NameEdit(this._actor, this._maxLength);
this.addWindow(this._editWindow);
};
Scene_Name.prototype.createInputWindow = function() {
this._inputWindow = new Window_NameInput(this._editWindow);
this._inputWindow.setHandler('ok', this.onInputOk.bind(this));
this.addWindow(this._inputWindow);
};
Scene_Name.prototype.onInputOk = function() {
this._actor.setName(this._editWindow.name());
this.popScene();
};
/**
* Класс сцены экрана дебага
* The scene class of the debug screen
*
* @class Scene_Debug
* @augments Scene_MenuBase
*/
function Scene_Debug() {
this.initialize.apply(this, arguments);
}
Scene_Debug.prototype = Object.create(Scene_MenuBase.prototype);
Scene_Debug.prototype.constructor = Scene_Debug;
/**
* Инициализирует объект класса
*
* @override
* initialize
*/
Scene_Debug.prototype.initialize;
/**
* Создает объекты в сцене
*
* @override
* create
*/
Scene_Debug.prototype.create;
Scene_Debug.prototype.createRangeWindow = function() {
this._rangeWindow = new Window_DebugRange(0, 0);
this._rangeWindow.setHandler('ok', this.onRangeOk.bind(this));
this._rangeWindow.setHandler('cancel', this.popScene.bind(this));
this.addWindow(this._rangeWindow);
};
Scene_Debug.prototype.createEditWindow = function() {
var wx = this._rangeWindow.width;
var ww = Graphics.boxWidth - wx;
this._editWindow = new Window_DebugEdit(wx, 0, ww);
this._editWindow.setHandler('cancel', this.onEditCancel.bind(this));
this._rangeWindow.setEditWindow(this._editWindow);
this.addWindow(this._editWindow);
};
Scene_Debug.prototype.createDebugHelpWindow = function() {
var wx = this._editWindow.x;
var wy = this._editWindow.height;
var ww = this._editWindow.width;
var wh = Graphics.boxHeight - wy;
this._debugHelpWindow = new Window_Base(wx, wy, ww, wh);
this.addWindow(this._debugHelpWindow);
};
Scene_Debug.prototype.onRangeOk = function() {
this._editWindow.activate();
this._editWindow.select(0);
this.refreshHelpWindow();
};
Scene_Debug.prototype.onEditCancel = function() {
this._rangeWindow.activate();
this._editWindow.deselect();
this.refreshHelpWindow();
};
Scene_Debug.prototype.refreshHelpWindow = function() {
this._debugHelpWindow.contents.clear();
if (this._editWindow.active) {
this._debugHelpWindow.drawTextEx(this.helpText(), 4, 0);
}
};
Scene_Debug.prototype.helpText = function() {
if (this._rangeWindow.mode() === 'switch') {
return 'Enter : ON / OFF';
} else {
return ('Left : -1\n' +
'Right : +1\n' +
'Pageup : -10\n' +
'Pagedown : +10');
}
};
/**
* Класс сцены экрана битвы
* The scene class of the battle screen
*
* @class Scene_Battle
* @augments Scene_Base
*/
function Scene_Battle() {
this.initialize.apply(this, arguments);
}
Scene_Battle.prototype = Object.create(Scene_Base.prototype);
Scene_Battle.prototype.constructor = Scene_Battle;
/**
* Инициализирует объект класса
*
* @override
* initialize
*/
Scene_Battle.prototype.initialize;
/**
* Создает объекты в сцене
*
* @override
* create
*/
Scene_Battle.prototype.create;
/**
* Запускает сцену
*
* @override
* start
*/
Scene_Battle.prototype.start;
/**
* Обновляет сцену
*
* @override
* update
*/
Scene_Battle.prototype.update;
Scene_Battle.prototype.updateBattleProcess = function() {
if (!this.isAnyInputWindowActive() || BattleManager.isAborting() ||
BattleManager.isBattleEnd()) {
BattleManager.update();
this.changeInputWindow();
}
};
Scene_Battle.prototype.isAnyInputWindowActive = function() {
return (this._partyCommandWindow.active ||
this._actorCommandWindow.active ||
this._skillWindow.active ||
this._itemWindow.active ||
this._actorWindow.active ||
this._enemyWindow.active);
};
Scene_Battle.prototype.changeInputWindow = function() {
if (BattleManager.isInputting()) {
if (BattleManager.actor()) {
this.startActorCommandSelection();
} else {
this.startPartyCommandSelection();
}
} else {
this.endCommandSelection();
}
};
/**
* Останавливает сцену
*
* @override
* stop
*/
Scene_Battle.prototype.stop;
/**
* Уничтожает все объекты в сцене
*
* @override
* terminate
*/
Scene_Battle.prototype.terminate;
Scene_Battle.prototype.needsSlowFadeOut = function() {
return (SceneManager.isNextScene(Scene_Title) ||
SceneManager.isNextScene(Scene_Gameover));
};
Scene_Battle.prototype.updateStatusWindow = function() {
if ($gameMessage.isBusy()) {
this._statusWindow.close();
this._partyCommandWindow.close();
this._actorCommandWindow.close();
} else if (this.isActive() && !this._messageWindow.isClosing()) {
this._statusWindow.open();
}
};
Scene_Battle.prototype.updateWindowPositions = function() {
var statusX = 0;
if (BattleManager.isInputting()) {
statusX = this._partyCommandWindow.width;
} else {
statusX = this._partyCommandWindow.width / 2;
}
if (this._statusWindow.x < statusX) {
this._statusWindow.x += 16;
if (this._statusWindow.x > statusX) {
this._statusWindow.x = statusX;
}
}
if (this._statusWindow.x > statusX) {
this._statusWindow.x -= 16;
if (this._statusWindow.x < statusX) {
this._statusWindow.x = statusX;
}
}
};
Scene_Battle.prototype.createDisplayObjects = function() {
this.createSpriteset();
this.createWindowLayer();
this.createAllWindows();
BattleManager.setLogWindow(this._logWindow);
BattleManager.setStatusWindow(this._statusWindow);
BattleManager.setSpriteset(this._spriteset);
this._logWindow.setSpriteset(this._spriteset);
};
Scene_Battle.prototype.createSpriteset = function() {
this._spriteset = new Spriteset_Battle();
this.addChild(this._spriteset);
};
/**
* Создает все окна
*
* createAllWindows
*/
Scene_Battle.prototype.createAllWindows;
Scene_Battle.prototype.createLogWindow = function() {
this._logWindow = new Window_BattleLog();
this.addWindow(this._logWindow);
};
Scene_Battle.prototype.createStatusWindow = function() {
this._statusWindow = new Window_BattleStatus();
this.addWindow(this._statusWindow);
};
Scene_Battle.prototype.createPartyCommandWindow = function() {
this._partyCommandWindow = new Window_PartyCommand();
this._partyCommandWindow.setHandler('fight', this.commandFight.bind(this));
this._partyCommandWindow.setHandler('escape', this.commandEscape.bind(this));
this._partyCommandWindow.deselect();
this.addWindow(this._partyCommandWindow);
};
Scene_Battle.prototype.createActorCommandWindow = function() {
this._actorCommandWindow = new Window_ActorCommand();
this._actorCommandWindow.setHandler('attack', this.commandAttack.bind(this));
this._actorCommandWindow.setHandler('skill', this.commandSkill.bind(this));
this._actorCommandWindow.setHandler('guard', this.commandGuard.bind(this));
this._actorCommandWindow.setHandler('item', this.commandItem.bind(this));
this._actorCommandWindow.setHandler('cancel', this.selectPreviousCommand.bind(this));
this.addWindow(this._actorCommandWindow);
};
/**
* Создает окно помощи
*
* createHelpWindow
*/
Scene_Battle.prototype.createHelpWindow;
Scene_Battle.prototype.createSkillWindow = function() {
var wy = this._helpWindow.y + this._helpWindow.height;
var wh = this._statusWindow.y - wy;
this._skillWindow = new Window_BattleSkill(0, wy, Graphics.boxWidth, wh);
this._skillWindow.setHelpWindow(this._helpWindow);
this._skillWindow.setHandler('ok', this.onSkillOk.bind(this));
this._skillWindow.setHandler('cancel', this.onSkillCancel.bind(this));
this.addWindow(this._skillWindow);
};
Scene_Battle.prototype.createItemWindow = function() {
var wy = this._helpWindow.y + this._helpWindow.height;
var wh = this._statusWindow.y - wy;
this._itemWindow = new Window_BattleItem(0, wy, Graphics.boxWidth, wh);
this._itemWindow.setHelpWindow(this._helpWindow);
this._itemWindow.setHandler('ok', this.onItemOk.bind(this));
this._itemWindow.setHandler('cancel', this.onItemCancel.bind(this));
this.addWindow(this._itemWindow);
};
Scene_Battle.prototype.createActorWindow = function() {
this._actorWindow = new Window_BattleActor(0, this._statusWindow.y);
this._actorWindow.setHandler('ok', this.onActorOk.bind(this));
this._actorWindow.setHandler('cancel', this.onActorCancel.bind(this));
this.addWindow(this._actorWindow);
};
Scene_Battle.prototype.createEnemyWindow = function() {
this._enemyWindow = new Window_BattleEnemy(0, this._statusWindow.y);
this._enemyWindow.x = Graphics.boxWidth - this._enemyWindow.width;
this._enemyWindow.setHandler('ok', this.onEnemyOk.bind(this));
this._enemyWindow.setHandler('cancel', this.onEnemyCancel.bind(this));
this.addWindow(this._enemyWindow);
};
/**
* Создает окно сообщений
*
* createMessageWindow
*/
Scene_Battle.prototype.createMessageWindow;
Scene_Battle.prototype.createScrollTextWindow = function() {
this._scrollTextWindow = new Window_ScrollText();
this.addWindow(this._scrollTextWindow);
};
Scene_Battle.prototype.refreshStatus = function() {
this._statusWindow.refresh();
};
Scene_Battle.prototype.startPartyCommandSelection = function() {
this.refreshStatus();
this._statusWindow.deselect();
this._statusWindow.open();
this._actorCommandWindow.close();
this._partyCommandWindow.setup();
};
Scene_Battle.prototype.commandFight = function() {
this.selectNextCommand();
};
Scene_Battle.prototype.commandEscape = function() {
BattleManager.processEscape();
this.changeInputWindow();
};
Scene_Battle.prototype.startActorCommandSelection = function() {
this._statusWindow.select(BattleManager.actor().index());
this._partyCommandWindow.close();
this._actorCommandWindow.setup(BattleManager.actor());
};
Scene_Battle.prototype.commandAttack = function() {
BattleManager.inputtingAction().setAttack();
this.selectEnemySelection();
};
Scene_Battle.prototype.commandSkill = function() {
this._skillWindow.setActor(BattleManager.actor());
this._skillWindow.setStypeId(this._actorCommandWindow.currentExt());
this._skillWindow.refresh();
this._skillWindow.show();
this._skillWindow.activate();
};
Scene_Battle.prototype.commandGuard = function() {
BattleManager.inputtingAction().setGuard();
this.selectNextCommand();
};
Scene_Battle.prototype.commandItem = function() {
this._itemWindow.refresh();
this._itemWindow.show();
this._itemWindow.activate();
};
Scene_Battle.prototype.selectNextCommand = function() {
BattleManager.selectNextCommand();
this.changeInputWindow();
};
Scene_Battle.prototype.selectPreviousCommand = function() {
BattleManager.selectPreviousCommand();
this.changeInputWindow();
};
Scene_Battle.prototype.selectActorSelection = function() {
this._actorWindow.refresh();
this._actorWindow.show();
this._actorWindow.activate();
};
Scene_Battle.prototype.onActorOk = function() {
var action = BattleManager.inputtingAction();
action.setTarget(this._actorWindow.index());
this._actorWindow.hide();
this._skillWindow.hide();
this._itemWindow.hide();
this.selectNextCommand();
};
Scene_Battle.prototype.onActorCancel = function() {
this._actorWindow.hide();
switch (this._actorCommandWindow.currentSymbol()) {
case 'skill':
this._skillWindow.show();
this._skillWindow.activate();
break;
case 'item':
this._itemWindow.show();
this._itemWindow.activate();
break;
}
};
Scene_Battle.prototype.selectEnemySelection = function() {
this._enemyWindow.refresh();
this._enemyWindow.show();
this._enemyWindow.select(0);
this._enemyWindow.activate();
};
Scene_Battle.prototype.onEnemyOk = function() {
var action = BattleManager.inputtingAction();
action.setTarget(this._enemyWindow.enemyIndex());
this._enemyWindow.hide();
this._skillWindow.hide();
this._itemWindow.hide();
this.selectNextCommand();
};
Scene_Battle.prototype.onEnemyCancel = function() {
this._enemyWindow.hide();
switch (this._actorCommandWindow.currentSymbol()) {
case 'attack':
this._actorCommandWindow.activate();
break;
case 'skill':
this._skillWindow.show();
this._skillWindow.activate();
break;
case 'item':
this._itemWindow.show();
this._itemWindow.activate();
break;
}
};
Scene_Battle.prototype.onSkillOk = function() {
var skill = this._skillWindow.item();
var action = BattleManager.inputtingAction();
action.setSkill(skill.id);
BattleManager.actor().setLastBattleSkill(skill);
this.onSelectAction();
};
Scene_Battle.prototype.onSkillCancel = function() {
this._skillWindow.hide();
this._actorCommandWindow.activate();
};
Scene_Battle.prototype.onItemOk = function() {
var item = this._itemWindow.item();
var action = BattleManager.inputtingAction();
action.setItem(item.id);
$gameParty.setLastItem(item);
this.onSelectAction();
};
Scene_Battle.prototype.onItemCancel = function() {
this._itemWindow.hide();
this._actorCommandWindow.activate();
};
Scene_Battle.prototype.onSelectAction = function() {
var action = BattleManager.inputtingAction();
this._skillWindow.hide();
this._itemWindow.hide();
if (!action.needsSelection()) {
this.selectNextCommand();
} else if (action.isForOpponent()) {
this.selectEnemySelection();
} else {
this.selectActorSelection();
}
};
Scene_Battle.prototype.endCommandSelection = function() {
this._partyCommandWindow.close();
this._actorCommandWindow.close();
this._statusWindow.deselect();
};
/**
* Класс сцены экрана конца игры
* The scene class of the game over screen
*
* @class Scene_Gameover
* @augments Scene_Base
*/
function Scene_Gameover() {
this.initialize.apply(this, arguments);
}
Scene_Gameover.prototype = Object.create(Scene_Base.prototype);
Scene_Gameover.prototype.constructor = Scene_Gameover;
/**
* Инициализирует объект класса
*
* @override
* initialize
*/
Scene_Gameover.prototype.initialize;
/**
* Создает объекты в сцене
*
* @override
* create
*/
Scene_Gameover.prototype.create;
/**
* Запускает сцену
*
* @override
* start
*/
Scene_Gameover.prototype.start;
/**
* Обновляет сцену
*
* @override
* update
*/
Scene_Gameover.prototype.update;
/**
* Останавливает сцену
*
* @override
* stop
*/
Scene_Gameover.prototype.stop;
/**
* Уничтожает все объекты в сцене
*
* @override
* terminate
*/
Scene_Gameover.prototype.terminate;
/**
* Запускает музыку геймовера
*
* playGameoverMusic
*/
Scene_Gameover.prototype.playGameoverMusic;
/**
* Создает задний фон
*
* createBackground
*/
Scene_Gameover.prototype.createBackground;
/**
* Возвращает true, если была нажата клавиша 'ok', или игрок коснулся экрана
*
* isTriggered
* @returns {Boolean} Была нажата клавиша 'ok', или игрок коснулся экрана
*/
Scene_Gameover.prototype.isTriggered;
/**
* Открывает титульный экран
*
* gotoTitle
*/
Scene_Gameover.prototype.gotoTitle;