971 lines
23 KiB
JavaScript
971 lines
23 KiB
JavaScript
/*:
|
|
* @plugindesc Add Option to Message log
|
|
* @author siguren
|
|
*
|
|
* @target MZ
|
|
* @base ManoUZ_MessageLog
|
|
*
|
|
* @command OpenScene
|
|
* @text Open Option Screen
|
|
*
|
|
* @param optionText
|
|
* @desc Sets display name on Option Screen.
|
|
* @default Message log Setting
|
|
*
|
|
* @param textON
|
|
* @default ON
|
|
*
|
|
* @param textOFF
|
|
* @default OFF
|
|
*
|
|
* @param logLimitBasicText
|
|
* @text Basic number of logs saved:Item Name
|
|
* @default Basic number of logs saved
|
|
*
|
|
* @param logLimitBasicHelp
|
|
* @text Basic number of logs saved:Description
|
|
* @default Affects the size of saved data.
|
|
* @parent logLimitBasicText
|
|
*
|
|
* @param logLimitBasicItemList
|
|
* @text Number of logs saved:List
|
|
* @type struct<EnumItem>[]
|
|
* @default ["{\"text\":\"Few\",\"value\":\"20\"}","{\"text\":\"Standard\",\"value\":\"40\"}","{\"text\":\"Many\",\"value\":\"60\"}","{\"text\":\"Extreme\",\"value\":\"100\"}"]
|
|
* @parent logLimitBasicText
|
|
*
|
|
* @param logLimitExtendsText
|
|
* @text Number of logs saved/added:Item Name
|
|
* @default Number of logs saved(Add)
|
|
*
|
|
* @param logLimitExtendsHelp
|
|
* @type multiline_string
|
|
* @text Number of logs saved/added:Description
|
|
* @default Affects memory consumption.
|
|
* @parent logLimitExtendsText
|
|
*
|
|
* @param logLimitExtendsItemList
|
|
* @text Number of logs saved/added:List
|
|
* @desc This item is for changing settings.
|
|
* @type struct<EnumItem>[]
|
|
* @default ["{\"text\":\"Few\",\"value\":\"20\"}","{\"text\":\"Standard\",\"value\":\"50\"}","{\"text\":\"Many\",\"value\":\"80\"}"]
|
|
* @parent logLimitExtendsText
|
|
*
|
|
* @param autoWaitTimeText
|
|
* @text Auto Read:Item Name
|
|
* @default Auto Read Wait Time
|
|
*
|
|
* @param autoWaitTimeHelp
|
|
* @type multiline_string
|
|
* @text Auto Read Wait Time:Description
|
|
* @default Waiting time after sentence is displayed.
|
|
* @parent autoWaitTimeText
|
|
*
|
|
* @param autoWaitTimeItemList
|
|
* @text Auto Read Wait Time:Item List
|
|
* @type struct<EnumItem>[]
|
|
* @default ["{\"text\":\"Short\",\"value\":\"180\"}","{\"text\":\"Standard\",\"value\":\"360\"}","{\"text\":\"Long\",\"value\":\"480\"}","{\"text\":\"Very Long\",\"value\":\"600\"}"]
|
|
* @parent autoWaitTimeText
|
|
*
|
|
* @param gaugeColorText
|
|
* @text Gauge Color:Item Name
|
|
* @type string
|
|
* @default Gauge Color
|
|
*
|
|
* @param gaugeColorHelp
|
|
* @type multiline_string
|
|
* @text Gauge Color:Description
|
|
* @default The color of the gauge
|
|
* that appears during the Auto Read Wait Time.
|
|
* @parent gaugeColorText
|
|
*
|
|
* @param gaugeColorItemListOld
|
|
* @text Gauge Color List
|
|
* @type number[]
|
|
* @desc Numeric Value
|
|
* Manually convert a hexadecimal number to a decimal number.
|
|
* @default ["13181999","12674371","8104783","3050327","45797","20362","16628736"]
|
|
* @parent gaugeColorText
|
|
*
|
|
* @param keepAutoMode
|
|
* @text Keep Auto Read Mode:Item Name
|
|
* @default Keep Auto Read Mode
|
|
*
|
|
* @param keepAutoModeHelp
|
|
* @type multiline_string
|
|
* @text Keep Auto Read Mode:Description
|
|
* @default After the conversation has ended, keeps Auto Read Mode on.
|
|
* @parent keepAutoMode
|
|
*
|
|
* @param machinakaMode
|
|
* @text NPC convo Mode Line:Item Name
|
|
* @default NPC convo Mode Line
|
|
*
|
|
* @param machinakaModeHelp
|
|
* @text NPC convo Mode Line:Description
|
|
* @type multiline_string
|
|
* @default number for simultaneous displays in NPC convo Mode.
|
|
* @parent machinakaMode
|
|
*
|
|
*
|
|
*
|
|
* @help
|
|
* Attach optional features to ManoUZ_MessageLog.
|
|
*
|
|
* The main unit has Plugin Commands for changing values directly.
|
|
*
|
|
*/
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
/*:ja
|
|
* @plugindesc メッセージログにオプションを追加
|
|
* @author しぐれん
|
|
*
|
|
* @target MZ
|
|
* @base ManoUZ_MessageLog
|
|
*
|
|
* @command OpenScene
|
|
* @text オプション画面を開く/OpenScene
|
|
*
|
|
* @param optionText
|
|
* @text オプション画面での表示名
|
|
* @default メッセージログ設定
|
|
*
|
|
* @param textON
|
|
* @default ON
|
|
*
|
|
* @param textOFF
|
|
* @default OFF
|
|
*
|
|
*
|
|
* @param logLimitBasicText
|
|
* @text ログ保存数(基本)：項目名
|
|
* @default ログ保存数(基本)
|
|
*
|
|
* @param logLimitBasicHelp
|
|
* @text ログの保存数(基本)：解説
|
|
* @default セーブデータの大きさに影響します。
|
|
* @parent logLimitBasicText
|
|
*
|
|
* @param logLimitBasicItemList
|
|
* @text ログ保存数：候補リスト
|
|
* @type struct<EnumItem>[]
|
|
* @default ["{\"text\":\"少ない\",\"value\":\"20\"}","{\"text\":\"標準\",\"value\":\"40\"}","{\"text\":\"多い\",\"value\":\"60\"}","{\"text\":\"とても多い\",\"value\":\"100\"}"]
|
|
* @parent logLimitBasicText
|
|
*
|
|
* @param logLimitExtendsText
|
|
* @text ログ保存数・追加分：項目名
|
|
* @default ログ保持数(追加)
|
|
*
|
|
* @param logLimitExtendsHelp
|
|
* @text ログ保存数・追加分：説明文
|
|
* @default メモリの消費量に影響します。
|
|
* @parent logLimitExtendsText
|
|
*
|
|
* @param logLimitExtendsItemList
|
|
* @text 追加のログ保存数：項目リスト
|
|
* @desc 設定変更用の項目です。
|
|
* @type struct<EnumItem>[]
|
|
* @default ["{\"text\":\"少ない\",\"value\":\"20\"}","{\"text\":\"標準\",\"value\":\"50\"}","{\"text\":\"多い\",\"value\":\"80\"}"]
|
|
* @parent logLimitExtendsText
|
|
*
|
|
* @param autoWaitTimeText
|
|
* @text オート待ち時間：項目名
|
|
* @default オート待ち時間
|
|
*
|
|
* @param autoWaitTimeHelp
|
|
* @text オート待ち時間：説明文
|
|
* @default 文章表示完了後の待機時間です。
|
|
* @parent autoWaitTimeText
|
|
*
|
|
* @param autoWaitTimeItemList
|
|
* @text オート待ち時間:項目リスト
|
|
* @type struct<EnumItem>[]
|
|
* @default ["{\"text\":\"短い\",\"value\":\"180\"}","{\"text\":\"標準\",\"value\":\"360\"}","{\"text\":\"長い\",\"value\":\"480\"}","{\"text\":\"とても長い\",\"value\":\"600\"}"]
|
|
* @parent autoWaitTimeText
|
|
*
|
|
* @param gaugeColorText
|
|
* @text ゲージ色：項目名
|
|
* @type string
|
|
* @default ゲージ色
|
|
*
|
|
* @param gaugeColorHelp
|
|
* @text ゲージ色：説明文
|
|
* @type string
|
|
* @default オート待ち時間の間に表示するゲージの色。
|
|
* @parent gaugeColorText
|
|
*
|
|
*
|
|
* @param gaugeColorItemListOld
|
|
* @text ゲージ色一覧
|
|
* @type number[]
|
|
* @desc 数値指定です。
|
|
* 各自で16進数を10進数に変換して設定します。
|
|
* @default ["13181999","12674371","8104783","3050327","45797","20362","16628736"]
|
|
* @parent gaugeColorText
|
|
*
|
|
*
|
|
* @param keepAutoMode
|
|
* @text オートモード保持：項目名
|
|
* @default オートモードを保持
|
|
*
|
|
* @param keepAutoModeHelp
|
|
* @text オートモード保持：説明文
|
|
* @default 会話終了後もオートモードを維持します。
|
|
* @parent keepAutoMode
|
|
*
|
|
* @param machinakaMode
|
|
* @text 街中モード行数：項目名
|
|
* @default 街中モード行数
|
|
*
|
|
* @param machinakaModeHelp
|
|
* @text 街中モード行数：説明文
|
|
* @type string
|
|
* @default 表示する数を増やすと、その分ログを表示する場所が減ります。
|
|
* @parent machinakaMode
|
|
*
|
|
*
|
|
*
|
|
* @help
|
|
* ManoUZ_MessageLogにオプション機能を取り付けます。
|
|
*
|
|
* 数値を直接変更するプラグインコマンドは本体側にあります。
|
|
*
|
|
*/
|
|
/*~struct~EnumItem:
|
|
* @param text
|
|
* @type string
|
|
*
|
|
* @param value
|
|
* @type number
|
|
* @default 0
|
|
*/
|
|
|
|
(function () {
|
|
"use strict";
|
|
|
|
/**
|
|
* @typedef {Object} OptionParametor
|
|
* @property {number} logLimitBasic
|
|
* @property {number} logLimitExtends
|
|
* @property {number} autoWaitTime
|
|
* @property {boolean} keepingAutoMode
|
|
* @property {number} gaugeColor
|
|
* @property {number} machinakaLines
|
|
*/
|
|
|
|
/**
|
|
* @type {String}
|
|
*/
|
|
const PLUGIN_NAME = "ManoUZ_MessageLogOption";
|
|
function getParam() {
|
|
return PluginManager.parameters(PLUGIN_NAME);
|
|
}
|
|
|
|
/**
|
|
* @returns {OptionParametor}
|
|
*/
|
|
function getOption() {
|
|
return ManoUZ_MessageLog.cloneOptionValue();
|
|
}
|
|
/**
|
|
* @param {OptionParametor} option
|
|
*/
|
|
function setOption(option) {
|
|
ManoUZ_MessageLog.setOptionValue(option);
|
|
}
|
|
|
|
class Option_ItemBase {
|
|
/**
|
|
*
|
|
* @param {string} key
|
|
* @param {string} name
|
|
* @param {string} help
|
|
*/
|
|
constructor(key, name, help) {
|
|
this._key = key;
|
|
this._help = help;
|
|
this._name = name;
|
|
}
|
|
helpText() {
|
|
return this._help;
|
|
}
|
|
key() {
|
|
return this._key;
|
|
}
|
|
|
|
name() {
|
|
return this._name;
|
|
}
|
|
/**
|
|
* @param {number} index
|
|
* @returns
|
|
*/
|
|
text(index) {
|
|
return "";
|
|
}
|
|
/**
|
|
*
|
|
* @param {number} index
|
|
* @returns
|
|
*/
|
|
textColor(index) {
|
|
return ColorManager.normalColor();
|
|
}
|
|
/**
|
|
* @param {number} value
|
|
* @returns
|
|
*/
|
|
indexOf(value) {
|
|
const maxItems = this.maxItems();
|
|
for (let i = 0; i < maxItems; ++i) {
|
|
const vv = this.value(i);
|
|
if (vv === value) {
|
|
return i;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
maxItems() {
|
|
return 1;
|
|
}
|
|
/**
|
|
* @returns {number}
|
|
* @param {number} _index
|
|
*/
|
|
value(_index) {
|
|
return 0;
|
|
}
|
|
}
|
|
/**
|
|
* @typedef {object} ValueTextPair
|
|
* @property {number} value
|
|
* @property {string} text
|
|
*/
|
|
|
|
class OptionItemEnum extends Option_ItemBase {
|
|
/**
|
|
* @param {string} key
|
|
* @param {string} name
|
|
* @param {string} help
|
|
* @param {ValueTextPair[]} list
|
|
*/
|
|
constructor(key, name, help, list) {
|
|
super(key, name, help);
|
|
//this._defaultValue=defaultValue;
|
|
|
|
this._list = list;
|
|
}
|
|
/**
|
|
* @param {string} key
|
|
* @param {string} name
|
|
* @param {string} helpText
|
|
* @param {string} listText
|
|
*/
|
|
static create(key, name, helpText, listText) {
|
|
/**
|
|
* @type {string[]}
|
|
*/
|
|
const listObj = JSON.parse(listText || "[]");
|
|
|
|
return new OptionItemEnum(
|
|
key,
|
|
name,
|
|
helpText,
|
|
listObj.map((text) => {
|
|
const obj = JSON.parse(text);
|
|
return {
|
|
text: obj.text,
|
|
value: Number(obj.value),
|
|
};
|
|
})
|
|
);
|
|
}
|
|
|
|
maxItems() {
|
|
return this._list.length;
|
|
}
|
|
/**
|
|
* @param {number} index
|
|
* @returns
|
|
*/
|
|
text(index) {
|
|
const item = this._list[index];
|
|
if (item) {
|
|
return item.text;
|
|
}
|
|
return "";
|
|
}
|
|
/**
|
|
*
|
|
* @param {number} index
|
|
*/
|
|
value(index) {
|
|
const item = this._list[index];
|
|
if (item) {
|
|
return item.value;
|
|
}
|
|
return 0;
|
|
}
|
|
}
|
|
/**
|
|
* @param {string} key
|
|
* @param {string} name
|
|
* @param {string} helpText
|
|
* @param {string} listText
|
|
*/
|
|
function createEnumOption(key, name, helpText, listText) {
|
|
return OptionItemEnum.create(key, String(name), String(helpText), listText);
|
|
}
|
|
|
|
class OptionItem_Boolean extends Option_ItemBase {
|
|
/**
|
|
* @param {number} index
|
|
* @returns
|
|
*/
|
|
value(index) {
|
|
return index;
|
|
}
|
|
/**
|
|
* @param {number} index
|
|
* @returns
|
|
*/
|
|
text(index) {
|
|
return index === 0 ? "OFF" : "ON";
|
|
}
|
|
maxItems() {
|
|
return 2;
|
|
}
|
|
}
|
|
|
|
class OptionItem_Number extends Option_ItemBase {
|
|
/**
|
|
* @param {string} key
|
|
* @param {string} name
|
|
* @param {string} help
|
|
*
|
|
* @param {number} min
|
|
* @param {number} max
|
|
*/
|
|
constructor(key, name, help, min, max) {
|
|
super(key, name, help);
|
|
this._min = min;
|
|
this._max = max;
|
|
this._name = name;
|
|
}
|
|
/**
|
|
* @param {number} index
|
|
* @returns
|
|
*/
|
|
text(index) {
|
|
return this.value(index).toString();
|
|
}
|
|
maxItems() {
|
|
return this._max - this._min;
|
|
}
|
|
/**
|
|
*
|
|
* @param {number} index
|
|
* @returns
|
|
*/
|
|
value(index) {
|
|
return index + this._min;
|
|
}
|
|
}
|
|
|
|
class OptionItemColorSelect extends Option_ItemBase {
|
|
/**
|
|
* @param {string} name
|
|
* @param {string} help
|
|
* @param {number[]} colorList
|
|
*/
|
|
constructor(name, help, colorList) {
|
|
super("color", name, help);
|
|
|
|
this._colorList = colorList;
|
|
}
|
|
|
|
text() {
|
|
return "????";
|
|
}
|
|
/**
|
|
* @param {number} index
|
|
* @returns
|
|
*/
|
|
textColor(index) {
|
|
const color = this.value(index);
|
|
const _0x = color.toString(16);
|
|
const zzz = _0x.padStart(6, "0");
|
|
|
|
return `#${zzz}`;
|
|
}
|
|
maxItems() {
|
|
return this._colorList.length;
|
|
}
|
|
/**
|
|
*
|
|
* @param {number} index
|
|
* @returns
|
|
*/
|
|
value(index) {
|
|
return this._colorList[index];
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @template {Option_ItemBase} OptionItemType
|
|
*/
|
|
class OptionItemCase {
|
|
/**
|
|
*
|
|
* @param {OptionItemType} obj
|
|
* @param {(opt:OptionParametor)=>number} optionReadFunc
|
|
*
|
|
*/
|
|
constructor(obj, optionReadFunc) {
|
|
this._index = 0;
|
|
this._item = obj;
|
|
this._readFunc = optionReadFunc;
|
|
}
|
|
/**
|
|
* @param {OptionParametor} option
|
|
*/
|
|
readIndex(option) {
|
|
const value = this._readFunc(option);
|
|
this._index = this._item.indexOf(value);
|
|
}
|
|
helpText() {
|
|
return this._item.helpText();
|
|
}
|
|
name() {
|
|
return this._item.name();
|
|
}
|
|
text() {
|
|
return this._item.text(this._index);
|
|
}
|
|
textColor() {
|
|
return this._item.textColor(this._index);
|
|
}
|
|
changePrev() {
|
|
if (this._index > 0) {
|
|
this._index -= 1;
|
|
return true;
|
|
}
|
|
this._index = this._item.maxItems() - 1;
|
|
return true;
|
|
}
|
|
changeNext() {
|
|
if (this._index + 1 < this._item.maxItems()) {
|
|
this._index += 1;
|
|
return true;
|
|
}
|
|
this._index = 0;
|
|
return true;
|
|
}
|
|
/**
|
|
* @returns {OptionItemType | Option_ItemBase}
|
|
*/
|
|
item() {
|
|
return this._item;
|
|
}
|
|
maxItems() {
|
|
return this._item.maxItems();
|
|
}
|
|
value() {
|
|
return this._item.value(this._index);
|
|
}
|
|
/**
|
|
* @param {number} value
|
|
*/
|
|
selectValue(value) {
|
|
const index = this._item.indexOf(value);
|
|
this._index = index;
|
|
}
|
|
}
|
|
|
|
class OptionClass {
|
|
/**
|
|
*
|
|
* @param {Option_ItemBase[]} list
|
|
*/
|
|
constructor(list) {
|
|
/**
|
|
* @type {Map<string,OptionItemCase< Option_ItemBase > >}
|
|
*/
|
|
this._map = new Map();
|
|
this.addItem(setting.logLimitBasic, (opt) => opt.logLimitBasic);
|
|
this.addItem(setting.logLimitExtends, (opt) => opt.logLimitExtends);
|
|
this.addItem(setting.autoSpeed, (opt) => opt.autoWaitTime);
|
|
this.addItem(setting.keepAutoMode, (opt) =>
|
|
opt.keepingAutoMode ? 1 : 0
|
|
);
|
|
this.addItem(setting.colorList, (opt) => opt.gaugeColor);
|
|
this.addItem(setting.machinaka, (opt) => opt.machinakaLines);
|
|
}
|
|
/**
|
|
*
|
|
* @param {string} key
|
|
*/
|
|
getValue(key) {
|
|
const item = this._map.get(key);
|
|
if (item) {
|
|
return item.value();
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* @returns {OptionParametor}
|
|
*
|
|
*/
|
|
createOption() {
|
|
const autokeep = this.getValue(setting.keepAutoMode.key()) !== 0;
|
|
return {
|
|
autoWaitTime: this.getValue(setting.autoSpeed.key()),
|
|
logLimitBasic: this.getValue(setting.logLimitBasic.key()),
|
|
logLimitExtends: this.getValue(setting.logLimitExtends.key()),
|
|
keepingAutoMode: autokeep,
|
|
gaugeColor: this.getValue(setting.colorList.key()),
|
|
machinakaLines: this.getValue(setting.machinaka.key()),
|
|
};
|
|
}
|
|
|
|
/**
|
|
* @private
|
|
* @param {Option_ItemBase} item
|
|
* @param {(option:OptionParametor)=>number} func
|
|
*/
|
|
addItem(item, func) {
|
|
const key = item.key();
|
|
this._map.set(key, new OptionItemCase(item, func));
|
|
}
|
|
/**
|
|
*
|
|
* @param {OptionParametor} option
|
|
*/
|
|
setOption(option) {
|
|
for (const iterator of this._map.values()) {
|
|
iterator.readIndex(option);
|
|
}
|
|
}
|
|
/**
|
|
* @returns
|
|
*/
|
|
createKeyList() {
|
|
return Array.from(this._map.keys());
|
|
}
|
|
/**
|
|
* @param {string} key
|
|
* @returns {OptionItemCase<Option_ItemBase>}
|
|
*/
|
|
getItem(key) {
|
|
return this._map.get(key);
|
|
}
|
|
}
|
|
|
|
const setting = (function () {
|
|
const param = getParam();
|
|
const logLimitBasic = createEnumOption(
|
|
"logbasic",
|
|
param.logLimitBasicText,
|
|
param.logLimitBasicHelp || "",
|
|
param.logLimitBasicItemList || "[]"
|
|
);
|
|
|
|
const logLimitExtends = createEnumOption(
|
|
"logextends",
|
|
param.logLimitExtendsText,
|
|
param.logLimitExtendsHelp || "",
|
|
param.logLimitExtendsItemList || "[]"
|
|
);
|
|
|
|
const autoSpeed = createEnumOption(
|
|
"autospeed",
|
|
param.autoWaitTimeText,
|
|
param.autoWaitTimeHelp,
|
|
param.autoWaitTimeItemList || "[]"
|
|
);
|
|
|
|
/**
|
|
* @type {String[]}
|
|
*/
|
|
const colorArray = JSON.parse(param.gaugeColorItemListOld);
|
|
const colorList = new OptionItemColorSelect(
|
|
String(param.gaugeColorText),
|
|
String(param.gaugeColorHelp),
|
|
colorArray.map((c) => Number(c))
|
|
);
|
|
const keepAutoMode = new OptionItem_Boolean(
|
|
"autokeep",
|
|
String(param.keepAutoMode),
|
|
String(param.keepAutoModeHelp)
|
|
);
|
|
|
|
const machinaka = new OptionItem_Number(
|
|
"machinaka",
|
|
String(param.machinkaMode || param.machinakaMode),
|
|
String(param.machinakaModeHelp || param.machinkaModeHelp),
|
|
1,
|
|
9
|
|
);
|
|
|
|
const optionText = String(param.optionText);
|
|
|
|
const result = {
|
|
optionText,
|
|
logLimitBasic,
|
|
logLimitExtends,
|
|
colorList,
|
|
autoSpeed,
|
|
keepAutoMode,
|
|
machinaka,
|
|
};
|
|
return result;
|
|
})();
|
|
|
|
class Window_LogOption extends Window_Selectable {
|
|
/**
|
|
* @param {Rectangle} rect
|
|
*/
|
|
constructor(rect) {
|
|
super(rect);
|
|
this._optionClass = new OptionClass(setting.itemList);
|
|
this._list = this._optionClass.createKeyList();
|
|
}
|
|
/**
|
|
*
|
|
* @param {OptionParametor} value
|
|
*/
|
|
setOption(value) {
|
|
this._optionClass.setOption(value);
|
|
this.refresh();
|
|
}
|
|
/**
|
|
* @returns {OptionParametor}
|
|
*/
|
|
createOption() {
|
|
return this._optionClass.createOption();
|
|
}
|
|
maxItems() {
|
|
if (this._list) {
|
|
return this._list.length;
|
|
}
|
|
return 0;
|
|
}
|
|
changeNextValue() {
|
|
const index = this.index();
|
|
const key = this._list[index];
|
|
const item = this._optionClass.getItem(key);
|
|
if (item) {
|
|
if (item.changeNext()) {
|
|
this.playCursorSound();
|
|
this.redrawItem(index);
|
|
}
|
|
}
|
|
}
|
|
changePrevValue() {
|
|
const index = this.index();
|
|
const key = this._list[index];
|
|
const item = this._optionClass.getItem(key);
|
|
if (item) {
|
|
if (item.changePrev()) {
|
|
this.playCursorSound();
|
|
this.redrawItem(index);
|
|
}
|
|
}
|
|
}
|
|
cursorLeft() {
|
|
this.changePrevValue();
|
|
}
|
|
playOkSound() {}
|
|
cursorRight() {
|
|
this.changeNextValue();
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @param {OptionItemCase<Option_ItemBase>} item
|
|
* @param {Rectangle} rect
|
|
*/
|
|
drawItemText(item, rect) {
|
|
const color = item.textColor();
|
|
this.changeTextColor(color);
|
|
this.drawText(item.text(), rect.x, rect.y, rect.width, "right");
|
|
}
|
|
/**
|
|
* @param {number} index
|
|
*/
|
|
itemAt(index) {
|
|
const key = this._list[index];
|
|
if (!key) {
|
|
return null;
|
|
}
|
|
return this._optionClass.getItem(key);
|
|
}
|
|
/**
|
|
* @param {number} index
|
|
*/
|
|
drawItem(index) {
|
|
const item = this.itemAt(index);
|
|
if (item) {
|
|
const rect = this.itemRectWithPadding(index);
|
|
const nameWidth = Math.min(rect.width, 200);
|
|
const name = item.name() || "";
|
|
this.drawTextEx(name, rect.x, rect.y, nameWidth);
|
|
if (item.item() !== setting.colorList) {
|
|
this.drawItemText(item, rect);
|
|
} else {
|
|
const colorRect = new Rectangle(
|
|
rect.x + 240,
|
|
rect.y + 2,
|
|
rect.width - 240,
|
|
rect.height - 4
|
|
);
|
|
const color = item.textColor();
|
|
this.drawColorBar(colorRect, color);
|
|
}
|
|
}
|
|
}
|
|
/**
|
|
* @param {Rectangle} rect
|
|
* @param {string} color
|
|
*/
|
|
drawColorBar(rect, color) {
|
|
this.contents.fillRect(rect.x, rect.y, rect.width, rect.height, color);
|
|
}
|
|
updateHelp() {
|
|
const item = this.itemAt(this.index());
|
|
if (item) {
|
|
this._helpWindow.setText(item.helpText());
|
|
}
|
|
}
|
|
}
|
|
/**
|
|
*
|
|
* @param {string} symbol
|
|
* @param {Sprite_Button} other
|
|
* @param {number} buttonY
|
|
* @param {number} spacing
|
|
*/
|
|
function createButton(symbol, other, buttonY, spacing) {
|
|
const button = new Sprite_Button(symbol);
|
|
button.x = other.x - button.width - spacing;
|
|
button.y = buttonY;
|
|
return button;
|
|
}
|
|
|
|
class Scene_MessageLogOption extends Scene_MenuBase {
|
|
constructor() {
|
|
super();
|
|
this._helpWindow = null;
|
|
this._opitonWindow = null;
|
|
}
|
|
create() {
|
|
super.create();
|
|
this.createAllWindows();
|
|
}
|
|
createAllWindows() {
|
|
this.createHelpWindow();
|
|
this.createLogOpitonWindow();
|
|
}
|
|
logWindowRect() {
|
|
const x = 0;
|
|
const y = this.mainAreaTop();
|
|
const w = Graphics.boxWidth;
|
|
const h = this.mainAreaHeight();
|
|
return new Rectangle(x, y, w, h);
|
|
}
|
|
createButtons() {
|
|
super.createButtons();
|
|
if (ConfigManager.touchUI) {
|
|
this.createCursorButton();
|
|
}
|
|
}
|
|
|
|
createCursorButton() {
|
|
if (!this._cancelButton) {
|
|
return;
|
|
}
|
|
const spacing = 4;
|
|
const buttonY = this.buttonY();
|
|
|
|
const right = createButton(
|
|
"pagedown",
|
|
this._cancelButton,
|
|
buttonY,
|
|
spacing
|
|
);
|
|
const left = createButton("pageup", right, buttonY, spacing);
|
|
|
|
this.addWindow(right);
|
|
this.addWindow(left);
|
|
}
|
|
createLogOpitonWindow() {
|
|
const low = new Window_LogOption(this.logWindowRect());
|
|
low.setOption(getOption());
|
|
low.setHandler("ok", this.onOptionOk.bind(this));
|
|
low.setHandler("cancel", this.saveOption.bind(this));
|
|
low.setHandler("pageup", this.onOptionPageup.bind(this));
|
|
low.setHandler("pagedown", this.onOptionPagedown.bind(this));
|
|
|
|
this._opitonWindow = low;
|
|
this.addWindow(low);
|
|
low.select(0);
|
|
low.setHelpWindow(this._helpWindow);
|
|
low.activate();
|
|
}
|
|
onOptionOk() {
|
|
this._opitonWindow.changeNextValue();
|
|
this._opitonWindow.activate();
|
|
}
|
|
onOptionPageup() {
|
|
this._opitonWindow.changePrevValue();
|
|
this._opitonWindow.activate();
|
|
}
|
|
onOptionPagedown() {
|
|
this._opitonWindow.changeNextValue();
|
|
this._opitonWindow.activate();
|
|
}
|
|
|
|
saveOption() {
|
|
const value = this._opitonWindow.createOption();
|
|
setOption(value);
|
|
this.popScene();
|
|
}
|
|
}
|
|
|
|
const MESSAGELOG_OPTION = "MSGLOG_OPTION";
|
|
|
|
const Window_Options_makeCommandList =
|
|
Window_Options.prototype.makeCommandList;
|
|
|
|
Window_Options.prototype.makeCommandList = function () {
|
|
Window_Options_makeCommandList.call(this);
|
|
this.addCommand(setting.optionText, MESSAGELOG_OPTION);
|
|
};
|
|
const Window_Options_drawItem = Window_Options.prototype.drawItem;
|
|
Window_Options.prototype.drawItem = function (index) {
|
|
const symbol = this.commandSymbol(index);
|
|
if (symbol === MESSAGELOG_OPTION) {
|
|
const rect = this.itemRectWithPadding(index);
|
|
this.drawTextEx(setting.optionText, rect.x, rect.y, rect.width);
|
|
} else {
|
|
Window_Options_drawItem.call(this, index);
|
|
}
|
|
};
|
|
const Window_Options_processOk = Window_Options.prototype.processOk;
|
|
Window_Options.prototype.processOk = function () {
|
|
Window_Options_processOk.call(this);
|
|
if (SceneManager.isSceneChanging()) {
|
|
return;
|
|
}
|
|
const symbol = this.currentSymbol();
|
|
if (symbol === MESSAGELOG_OPTION) {
|
|
SceneManager.push(Scene_MessageLogOption);
|
|
return;
|
|
}
|
|
};
|
|
|
|
PluginManager.registerCommand(PLUGIN_NAME, "OpenScene", () => {
|
|
SceneManager.push(Scene_MessageLogOption);
|
|
});
|
|
})();
|