814 lines
26 KiB
JavaScript
814 lines
26 KiB
JavaScript
//-----------------------------------------------------------------------------
|
|
// Galv's Message Styles MZ
|
|
//-----------------------------------------------------------------------------
|
|
// For: RPGMAKER MV
|
|
// GALV_MessageStylesMZ.js
|
|
//-----------------------------------------------------------------------------
|
|
// 2020-11-07 - Version 2.1 - added plugin order fix
|
|
// 2020-10-18 - Version 2.0 - hopefully fixed bugs with other text commands
|
|
// 2020-10-11 - Version 1.9 - fixed another text command issue
|
|
// 2020-10-04 - Version 1.8 - fixed issue when using other text commands after
|
|
// the pop command
|
|
// 2020-10-02 - Version 1.7 - fixed position issue when using larger screen
|
|
// width/height than the UI.
|
|
// 2020-09-28 - Version 1.6 - added compatibility with Galv's Cam Control zoom
|
|
// 2020-09-26 - Version 1.5 - fixed some code scope issues
|
|
// 2020-09-22 - Version 1.4 - added compatibility codes
|
|
// 2020-09-19 - Version 1.3 - added ability to add y offset per message
|
|
// more code updates/improvements
|
|
// 2020-09-18 - Version 1.2 - added ability to change message windowskin,
|
|
// arrow graphics, code updates and improvements,
|
|
// fixed target x,y bug and changed syntax method
|
|
// fixed 'middle' align arrow to be invisible
|
|
// 2020-09-17 - Version 1.1 - fixed a bug with the \. and \| wait codes
|
|
// 2020-09-16 - Version 1.0 - release
|
|
//-----------------------------------------------------------------------------
|
|
// Terms can be found at:
|
|
// galvs-scripts.com
|
|
//-----------------------------------------------------------------------------
|
|
|
|
var Imported = Imported || {};
|
|
Imported.Galv_MessageStyles = true;
|
|
|
|
var Galv = Galv || {}; // Galv's main object
|
|
Galv.Mstyle = Galv.Mstyle || {}; // Galv's stuff
|
|
Galv.Mstyle.pluginName = "GALV_MessageStylesMZ";
|
|
|
|
//-----------------------------------------------------------------------------
|
|
/*:
|
|
* @plugindesc (v.2.1) 'Show Text' windows float above characters and change visuals during game.
|
|
* @url http://galvs-scripts.com
|
|
* @target MZ
|
|
* @author Galv
|
|
* @orderAfter GALV_MessageTimerMZ
|
|
*
|
|
* @param iIndicator
|
|
* @text Input Indicator Position
|
|
* @desc pos,x,y - pos is a direction number (numpad). 1,2,3,4,6,7,8,9.
|
|
* @default 2,0,-12
|
|
*
|
|
* @param mPadding
|
|
* @text Message Padding
|
|
* @desc Adds padding around the text in the message box... top,right,bottom,left.
|
|
* @default 0,0,0,0
|
|
*
|
|
* @param invertPos
|
|
* @text Invert Floating Message
|
|
* @type boolean
|
|
* @default false
|
|
* @desc When showing a floating message, displaying window position 'Bottom' will instead be top and vice verca.
|
|
*
|
|
* @param aGraphic
|
|
* @text Arrow Graphic
|
|
* @desc Image from /img/system/ that is used to point at the target of a floating message box. Leave blank for none.
|
|
* @default WindowArrow
|
|
*
|
|
* @param yOffset
|
|
* @text Default Y Offset
|
|
* @desc How many pixels above the event/actor the message box will appear.
|
|
* @default 60
|
|
*
|
|
*
|
|
* @command mWindowStyle
|
|
* @text Message Window Style
|
|
* @desc Set the styles for the default message window (not using \pop).
|
|
*
|
|
* @arg windowskin
|
|
* @text Windowskin
|
|
* @default Window
|
|
* @desc The windowskin graphic from /img/system (without extension)
|
|
*
|
|
*
|
|
* @command pWindowStyle
|
|
* @text Pop Window Style
|
|
* @desc Set the styles for the popup message window (when \pop is used).
|
|
*
|
|
* @arg windowskin
|
|
* @text Windowskin
|
|
* @default Window
|
|
* @desc The windowskin graphic from /img/system (without extension).
|
|
*
|
|
* @arg arrowGraphic
|
|
* @text Arrow Graphic
|
|
* @default WindowArrow
|
|
* @dec Change the arrow graphic for the popup window.
|
|
*
|
|
*
|
|
* @command defaultWindowStyle
|
|
* @text Reset Window Styles
|
|
* @desc Changes styles for both windows to default.
|
|
*
|
|
* @help
|
|
* Galv's Message Styles
|
|
* ----------------------------------------------------------------------------
|
|
* The main purpose of this plugin is to allow your "Show Text" message boxes
|
|
* to have a different style to other windows in the game. The plugin settings
|
|
* have a variety of visual settings you can tweak, and in addition using a
|
|
* text code in Show Text messages will allow you to turn that message into a
|
|
* floating message.
|
|
*
|
|
* NOTE: The use of /{ and \} text commands are not currently supported inside
|
|
* pop message windows.
|
|
*
|
|
* ----------------------------------------------------------------------------
|
|
* CODE to use inside a SHOW TEXT message event command
|
|
* ----------------------------------------------------------------------------
|
|
* The following code must be put in the first line of a Show Message event
|
|
* command to work.
|
|
*
|
|
* \pop[t]
|
|
*
|
|
* t = event Id - to target an event on the map
|
|
* 0 to target the event the Show Text command is used in
|
|
* -1,-2,-3,-4... negative numbers to target followers in those postions
|
|
* a1,a2,a3, etc... to target a specific actor IF they are a follower. If
|
|
* not a follower, the message will not display
|
|
* x|y to target a SCREEN pixel position.
|
|
*
|
|
* EXAMPLES
|
|
* \pop[23] // targets event 23
|
|
* \pop[-3] // targets the 3rd follower in your follower lineup
|
|
* \pop[a8] // targets actor 8, only if the actor is a follower on the map
|
|
* \pop[500|200] // targets center of message to screen position at
|
|
* // 500px X and 200px Y
|
|
*
|
|
* OPTIONALLY:
|
|
* Advanced data can be added via the \pop[] text within a message.
|
|
*
|
|
* \pop[t,y,windowskin,windowarrow]
|
|
*
|
|
* t = same as above
|
|
* y = another modifier for y offset in pixels - for taller sprites.
|
|
* set to 0 to not modify the default y offset
|
|
* windowskin = filename for a different window to use (blank for no change)
|
|
* windowarrow = filename for a different arrow to use (blank for no change)
|
|
*
|
|
* ----------------------------------------------------------------------------
|
|
* PLUGIN COMMANDS
|
|
* ----------------------------------------------------------------------------
|
|
* There are plugin commands available to change windowskins. When they are
|
|
* used, all messages will use the new settings until they used again to
|
|
* change them back to defaults. These are a work in progress, more features
|
|
* may be added to them.
|
|
*
|
|
*/
|
|
//-----------------------------------------------------------------------------
|
|
// CODE STUFFS
|
|
//-----------------------------------------------------------------------------
|
|
|
|
// PLUGIN COMMANDS
|
|
//-----------------------------------------------------------------------------
|
|
|
|
PluginManager.registerCommand(
|
|
Galv.Mstyle.pluginName,
|
|
"mWindowStyle",
|
|
(args) => {
|
|
args.index = 0;
|
|
$gameSystem.updateMStyles(args);
|
|
}
|
|
);
|
|
|
|
PluginManager.registerCommand(
|
|
Galv.Mstyle.pluginName,
|
|
"pWindowStyle",
|
|
(args) => {
|
|
args.index = 1;
|
|
$gameSystem.updateMStyles(args);
|
|
}
|
|
);
|
|
|
|
PluginManager.registerCommand(
|
|
Galv.Mstyle.pluginName,
|
|
"defaultWindowStyle",
|
|
(args) => {
|
|
$gameSystem.buildMStyles();
|
|
}
|
|
);
|
|
|
|
Galv.Mstyle.invertPos =
|
|
PluginManager.parameters(Galv.Mstyle.pluginName)["invertPos"] == "true";
|
|
Galv.Mstyle.arrow = PluginManager.parameters(Galv.Mstyle.pluginName)[
|
|
"aGraphic"
|
|
];
|
|
Galv.Mstyle.yOffset = Number(
|
|
PluginManager.parameters(Galv.Mstyle.pluginName)["yOffset"]
|
|
);
|
|
|
|
// If screen is bigger than ui
|
|
Galv.Mstyle.screenXOffset = 0;
|
|
Galv.Mstyle.screenYOffset = 0;
|
|
|
|
Galv.Mstyle.indPos = PluginManager.parameters(Galv.Mstyle.pluginName)[
|
|
"iIndicator"
|
|
].split(",");
|
|
for (let i = 0; i < Galv.Mstyle.indPos.length; i++) {
|
|
Galv.Mstyle.indPos[i] = Number(Galv.Mstyle.indPos[i]);
|
|
}
|
|
|
|
Galv.Mstyle.padding = PluginManager.parameters(Galv.Mstyle.pluginName)[
|
|
"mPadding"
|
|
].split(",");
|
|
for (let i = 0; i < Galv.Mstyle.padding.length; i++) {
|
|
Galv.Mstyle.padding[i] = Number(Galv.Mstyle.padding[i]);
|
|
}
|
|
|
|
Galv.Mstyle.target = null;
|
|
Galv.Mstyle.thisEvent = null;
|
|
Galv.Mstyle.refreshOnClose = false;
|
|
Galv.Mstyle.tempPopData = {};
|
|
|
|
Galv.Mstyle.checkTarget = function (text) {
|
|
let target = {};
|
|
let tmp = text.replace(/\\/g, "\x1b");
|
|
tmp = tmp.replace(/\x1b\x1b/g, "\\");
|
|
tmp = tmp.replace(/\x1bV\[(\d+)\]/gi, (_, p1) =>
|
|
$gameVariables.value(parseInt(p1))
|
|
);
|
|
|
|
let popData = tmp.match(/\x1bpop\[[^\]]*\]/gi);
|
|
|
|
if (popData) {
|
|
const data = popData[0].match(/\[(.*)\]/)[1].split(",");
|
|
const d = data[0].split("|");
|
|
if (!d[1]) {
|
|
// target is an id only
|
|
target.id = d[0];
|
|
} else {
|
|
// target is an x,y
|
|
target.x = d[0];
|
|
target.y = d[1];
|
|
}
|
|
|
|
target.extra = []; // additional potential data here
|
|
for (let i = 1; i < data.length; i++) {
|
|
target.extra.push(data[i]);
|
|
}
|
|
}
|
|
return target;
|
|
};
|
|
|
|
Galv.Mstyle.setTarget = function (target) {
|
|
// build temp pop data object
|
|
this.buildTempPopData(target);
|
|
|
|
if (target.y) {
|
|
// Target has a Y value, so it's an X,Y object
|
|
this.xyTarget = {
|
|
_x: Number(target.x),
|
|
_y: Number(target.y),
|
|
screenX: function () {
|
|
return this._x;
|
|
},
|
|
screenY: function () {
|
|
return this._y;
|
|
},
|
|
};
|
|
return this.xyTarget;
|
|
} else if (!target.id.contains("a")) {
|
|
// Target is an ID (event or negatives for follower) and NOT and x,y location
|
|
target.id = Number(target.id);
|
|
// event ID or player
|
|
if (target.id >= -1) {
|
|
switch (target.id) {
|
|
case 0:
|
|
return $gameMap.event(this.thisEvent);
|
|
break;
|
|
case -1:
|
|
return $gamePlayer;
|
|
break;
|
|
default:
|
|
return $gameMap.event(target.id);
|
|
break;
|
|
}
|
|
} else {
|
|
// Target is a follower
|
|
const f = Math.abs(target.id);
|
|
if (f > $gameParty.battleMembers().length) {
|
|
// if no follower exists - don't do it!
|
|
return false;
|
|
} else {
|
|
return $gamePlayer._followers.follower(f - 2);
|
|
}
|
|
}
|
|
} else if (target.id.contains("a")) {
|
|
// Target an actor - check if the actor is in the followers
|
|
const actor = $gameActors.actor(Number(target.id.replace("a", "")));
|
|
actorIndex = actor.index();
|
|
if (actorIndex < 0 || actorIndex > $gameParty.battleMembers().length) {
|
|
return false;
|
|
} else {
|
|
const ind = actorIndex - 1;
|
|
return ind < 0 ? $gamePlayer : $gamePlayer._followers.follower(ind);
|
|
}
|
|
}
|
|
};
|
|
|
|
Galv.Mstyle.buildTempPopData = function (target) {
|
|
this.tempPopData = {}; // reset temp data
|
|
this.tempPopData.array = target.extra || []; // array of extra data
|
|
this.processTempPopData();
|
|
};
|
|
|
|
Galv.Mstyle.processTempPopData = function () {
|
|
let data = this.tempPopData.array;
|
|
this.tempPopData.yo = Number(data[0]) || 0;
|
|
this.tempPopData.windowskin = data[1] || "";
|
|
this.tempPopData.windowarrow = data[2] || "";
|
|
// Add more data here if needed
|
|
};
|
|
|
|
Galv.Mstyle.refreshMessageWindows = function () {
|
|
if (SceneManager._scene._messageWindow)
|
|
SceneManager._scene._messageWindow.refreshGraphics();
|
|
if (SceneManager._scene._nameWindow)
|
|
SceneManager._scene._nameBoxWindow.refreshGraphics();
|
|
};
|
|
|
|
Galv.Mstyle.zoomOffset = function (v1, v2) {
|
|
return v1 - v2 - (v1 - v2) * $gameScreen.zoomScale();
|
|
};
|
|
|
|
// GAME SYSTEM
|
|
//-----------------------------------------------------------------------------
|
|
|
|
Galv.Mstyle.Game_System_initialize = Game_System.prototype.initialize;
|
|
Game_System.prototype.initialize = function () {
|
|
Galv.Mstyle.Game_System_initialize.call(this);
|
|
this.buildMStyles();
|
|
};
|
|
|
|
Game_System.prototype.buildMStyles = function () {
|
|
const windowskin = "Window";
|
|
const arrow = Galv.Mstyle.arrow;
|
|
this._mStyles = [
|
|
// default message window settings [0]
|
|
{ windowskin: windowskin },
|
|
// pop message settings [1]
|
|
{ windowskin: windowskin, arrowGraphic: arrow },
|
|
];
|
|
};
|
|
|
|
Game_System.prototype.updateMStyles = function (args) {
|
|
// update the message style settings
|
|
this._mStyles[args.index] = args;
|
|
};
|
|
|
|
// INTERPRETER
|
|
//-----------------------------------------------------------------------------
|
|
|
|
Galv.Mstyle.Game_Interpreter_command101 = Game_Interpreter.prototype.command101;
|
|
Game_Interpreter.prototype.command101 = function (params) {
|
|
const ispop = this._list[this._index + 1].parameters[0].match(/\\pop/i);
|
|
if (ispop) {
|
|
// Is a pop message
|
|
Galv.Mstyle.thisEvent = this._eventId;
|
|
Galv.Mstyle.target = Galv.Mstyle.setTarget(
|
|
Galv.Mstyle.checkTarget(this._list[this._index + 1].parameters[0])
|
|
);
|
|
|
|
if (Galv.Mstyle.target == false) {
|
|
while (this.nextEventCode() === 401) {
|
|
// Text data
|
|
this._index++;
|
|
}
|
|
return false;
|
|
}
|
|
} else {
|
|
// Not a pop message
|
|
Galv.Mstyle.thisEvent = null;
|
|
Galv.Mstyle.target = null;
|
|
}
|
|
return Galv.Mstyle.Game_Interpreter_command101.call(this, params);
|
|
};
|
|
|
|
// WINDOW MESSAGE
|
|
//-----------------------------------------------------------------------------
|
|
|
|
Galv.Mstyle.Window_Message_initialize = Window_Message.prototype.initialize;
|
|
Window_Message.prototype.initialize = function (rect) {
|
|
Galv.Mstyle.Window_Message_initialize.call(this, rect);
|
|
Galv.Mstyle.screenXOffset = (Graphics.width - Graphics.boxWidth) / 2;
|
|
Galv.Mstyle.screenYOffset = (Graphics.height - Graphics.boxHeight) / 2;
|
|
this.createWindowTail();
|
|
};
|
|
|
|
Window_Message.prototype.refreshGraphics = function () {
|
|
this.loadWindowskin();
|
|
this.contents.clear();
|
|
this.updateTone();
|
|
this.changeWindowDimensions();
|
|
this.createContents();
|
|
this.openness = 0;
|
|
this.createWindowTail();
|
|
};
|
|
|
|
Window_Message.prototype.loadWindowskin = function () {
|
|
Window_Base.prototype.loadPopMessageWindowskin.call(this);
|
|
};
|
|
|
|
Galv.Mstyle.Window_Message_updateClose = Window_Message.prototype.updateClose;
|
|
Window_Message.prototype.updateClose = function () {
|
|
if (Galv.Mstyle.refreshOnClose && this.isClosed()) {
|
|
Galv.Mstyle.refreshOnClose = false;
|
|
Galv.Mstyle.refreshMessageWindows();
|
|
}
|
|
Galv.Mstyle.Window_Message_updateClose.call(this);
|
|
};
|
|
|
|
Window_Message.prototype.createWindowTail = function () {
|
|
const arrowName = Galv.Mstyle.tempPopData.windowarrow
|
|
? Galv.Mstyle.tempPopData.windowarrow
|
|
: $gameSystem._mStyles[1].arrowGraphic;
|
|
if (this._tailSprite) {
|
|
if (this._tailSprite.name != arrowName) {
|
|
this.removeChild(this._tailSprite); // if arrow graphic has changed, remove the sprite to rebuild it.
|
|
} else {
|
|
return; // no need to rebuild the sprite below.
|
|
}
|
|
}
|
|
this._tailSprite = new Sprite();
|
|
this._tailSprite.bitmap = ImageManager.loadSystem(arrowName);
|
|
this._tailSprite.opacity = 0;
|
|
this._tailSprite.anchor.x = 0.5;
|
|
this._tailSprite.name = arrowName;
|
|
this.addChild(this._tailSprite);
|
|
};
|
|
|
|
Galv.Mstyle.Window_Message_startMessage = Window_Message.prototype.startMessage;
|
|
Window_Message.prototype.startMessage = function () {
|
|
Galv.Mstyle.Window_Message_startMessage.call(this);
|
|
this.startPopMessageStuff();
|
|
};
|
|
|
|
Window_Message.prototype.startPopMessageStuff = function () {
|
|
this.loadWindowskin(); // load windowskin in case it was changed with plugin command
|
|
this._nameBoxWindow.loadWindowskin();
|
|
this.createWindowTail();
|
|
this.changeWindowDimensions();
|
|
this.refreshDimmerBitmap();
|
|
this.setPopSettings();
|
|
this.createWindowTail();
|
|
};
|
|
|
|
Galv.Mstyle.Window_Message_updatePlacement =
|
|
Window_Message.prototype.updatePlacement;
|
|
Window_Message.prototype.updatePlacement = function () {
|
|
if (Galv.Mstyle.target) {
|
|
this.pTarget = Galv.Mstyle.target;
|
|
this.updateFloatPlacement();
|
|
} else {
|
|
this.pTarget = null;
|
|
this.changeWindowDimensions();
|
|
Galv.Mstyle.Window_Message_updatePlacement.call(this);
|
|
}
|
|
};
|
|
|
|
Galv.Mstyle.Window_Message_terminateMessage =
|
|
Window_Message.prototype.terminateMessage;
|
|
Window_Message.prototype.terminateMessage = function () {
|
|
Galv.Mstyle.Window_Message_terminateMessage.call(this);
|
|
this.pTarget = null;
|
|
Galv.Mstyle.target = null;
|
|
Galv.Mstyle.thisEvent = null;
|
|
};
|
|
|
|
Galv.Mstyle.Window_Message_update = Window_Message.prototype.update;
|
|
Window_Message.prototype.update = function () {
|
|
Galv.Mstyle.Window_Message_update.call(this);
|
|
this.updateFloatPlacement();
|
|
};
|
|
|
|
Window_Message.prototype.setPopSettings = function () {
|
|
// Invert bottom and top if setting is true
|
|
if (Galv.Mstyle.invertPos) {
|
|
if ($gameMessage._positionType == 2) {
|
|
$gameMessage._positionType = 0;
|
|
} else if ($gameMessage._positionType == 0) {
|
|
$gameMessage._positionType = 2;
|
|
}
|
|
}
|
|
|
|
// Initial yOffset value
|
|
switch ($gameMessage._positionType) {
|
|
case 1: // MIDDLE
|
|
this.yOffset = -(this.height / 2);
|
|
break;
|
|
case 2: // BOTTOM
|
|
this.yOffset = 15;
|
|
break;
|
|
}
|
|
};
|
|
|
|
Window_Message.prototype.updateFloatPlacement = function () {
|
|
if (this.pTarget == null) return (this._tailSprite.opacity = 0); // If not a floating message, hide tailsprite and stop function
|
|
if (this.openness < 255) this._tailSprite.opacity = 0; // hide tail sprite when not fully open
|
|
|
|
// init pos X,Y
|
|
let zx = this.pTarget.screenX() - Galv.Mstyle.screenXOffset;
|
|
let zy = this.pTarget.screenY() - Galv.Mstyle.screenYOffset;
|
|
|
|
// compensate for zoomed screen
|
|
const zoomX = Galv.Mstyle.zoomOffset(Graphics.boxWidth / 2, zx);
|
|
const zoomY = Galv.Mstyle.zoomOffset(Graphics.boxHeight / 2, zy);
|
|
|
|
let posX = zx - this.width / 2 + zoomX;
|
|
let posY = zy + this.yOffset + Galv.Mstyle.tempPopData.yo + zoomY;
|
|
|
|
// set posX
|
|
if (posX + this.width > Graphics.boxWidth) {
|
|
posX = Graphics.boxWidth - this.width;
|
|
} else if (posX < 0) {
|
|
posX = 0;
|
|
}
|
|
this.x = posX;
|
|
this._nameBoxWindow.x = this.x;
|
|
|
|
// set posY
|
|
const nameBoxOffset = this._nameBoxWindow._name
|
|
? this._nameBoxWindow.height
|
|
: 0;
|
|
|
|
if (posY + this.height > Graphics.height) {
|
|
// If window would go off bottom of screen
|
|
const maxY = Graphics.height - this.height;
|
|
posY = Math.min(
|
|
maxY,
|
|
this.pTarget.screenY() - Galv.Mstyle.yOffset - this.height
|
|
);
|
|
this.tailPos = 0;
|
|
} else if (posY - nameBoxOffset < 0) {
|
|
// If window would go off top of screen
|
|
posY = Math.max(this.pTarget.screenY() + 15, 0); // position box under when it hits top of screen
|
|
this.tailPos = 2;
|
|
} else {
|
|
this.tailPos = $gameMessage._positionType;
|
|
}
|
|
|
|
if ($gameMessage._positionType == 1) this.tailPos = 1; // if set to middle, no tail.
|
|
|
|
this.y = posY;
|
|
this._nameBoxWindow.y = posY - nameBoxOffset;
|
|
|
|
// Update other stuff
|
|
this.updateOtherMsgWindows();
|
|
this.updateTailSprite();
|
|
};
|
|
|
|
Window_Message.prototype.updateOtherMsgWindows = function () {
|
|
this.updateFloatGoldWindow();
|
|
this.updateFloatChoiceWindow();
|
|
};
|
|
|
|
Window_Message.prototype.updateFloatGoldWindow = function () {
|
|
if (!this._goldWindow) return;
|
|
this._goldWindow.y =
|
|
this._nameBoxWindow.y < this._goldWindow.height
|
|
? Graphics.boxHeight - this._goldWindow.height
|
|
: 0;
|
|
};
|
|
|
|
Window_Message.prototype.updateFloatChoiceWindow = function () {
|
|
const positionType = $gameMessage.choicePositionType();
|
|
const setY = this.y + this.height;
|
|
if (setY + this._choiceListWindow.height > Graphics.height) {
|
|
// If choice window goes off bottom of screen.
|
|
this._choiceListWindow.y = this.y - this._choiceListWindow.height;
|
|
} else {
|
|
this._choiceListWindow.y = setY;
|
|
}
|
|
switch (positionType) {
|
|
case 0: // left
|
|
this._choiceListWindow.x = this.x;
|
|
break;
|
|
case 1: // middle
|
|
this._choiceListWindow.x =
|
|
this.x + this.width / 2 - this._choiceListWindow.width / 2;
|
|
break;
|
|
case 2: // right
|
|
this._choiceListWindow.x =
|
|
this.x + this.width - this._choiceListWindow.width;
|
|
break;
|
|
}
|
|
};
|
|
|
|
Window_Message.prototype.updateTailSprite = function () {
|
|
if (this.openness > 200) {
|
|
if (this.tailPos == 1) {
|
|
// MID
|
|
this._tailSprite.opacity = 0;
|
|
} else if (this.tailPos == 2) {
|
|
// BOT
|
|
this._tailSprite.y = 2;
|
|
this._tailSprite.scale.y = -1;
|
|
this._tailSprite.opacity += 50;
|
|
} else if (this.tailPos == 0) {
|
|
// TOP
|
|
this._tailSprite.scale.y = 1;
|
|
this._tailSprite.y = this.height - 2;
|
|
this._tailSprite.opacity += 50;
|
|
}
|
|
}
|
|
|
|
// compensate for zoomed screen
|
|
const screenX = this.pTarget.screenX() - Galv.Mstyle.screenXOffset;
|
|
const zoomX = Galv.Mstyle.zoomOffset(Graphics.boxWidth / 2, screenX);
|
|
this._tailSprite.x = screenX - this.x + zoomX;
|
|
};
|
|
|
|
Galv.Mstyle.Window_Message_newLineX = Window_Message.prototype.newLineX;
|
|
Window_Message.prototype.newLineX = function (textState) {
|
|
const padding = !$gameMessage.faceName() ? Galv.Mstyle.padding[3] : 0;
|
|
return Galv.Mstyle.Window_Message_newLineX.call(this, textState) + padding;
|
|
};
|
|
|
|
Galv.Mstyle.Window_Message_newPage = Window_Message.prototype.newPage;
|
|
Window_Message.prototype.newPage = function (textState) {
|
|
Galv.Mstyle.Window_Message_newPage.call(this, textState);
|
|
textState.y += Galv.Mstyle.padding[0];
|
|
};
|
|
|
|
Window_Message.prototype.galvExtraWidths = function () {
|
|
return 0; // For compatibility
|
|
};
|
|
|
|
Window_Message.prototype.galvExtraHeights = function () {
|
|
return 0; // For compatibility
|
|
};
|
|
|
|
Window_Message.prototype.changeWindowDimensions = function () {
|
|
if (this.pTarget != null) {
|
|
Galv.Mstyle.testActive = true;
|
|
let w = 0;
|
|
let h = 0;
|
|
const faceoffset = $gameMessage.faceName()
|
|
? ImageManager.faceWidth + 25
|
|
: 0;
|
|
const xO = $gameMessage.faceName() ? faceoffset : 8;
|
|
|
|
// Calc text width
|
|
for (let i = 0; i < $gameMessage._texts.length; i++) {
|
|
let lineWidth = this.testWidthEx($gameMessage._texts[i]);
|
|
if (w < lineWidth) w = lineWidth;
|
|
}
|
|
w =
|
|
w +
|
|
$gameSystem.windowPadding() * 2 +
|
|
xO +
|
|
Galv.Mstyle.padding[3] +
|
|
Galv.Mstyle.padding[1]; // padding!
|
|
w += this.galvExtraWidths();
|
|
this.width = Math.min(Graphics.boxWidth, w); // can't be wider than the screen!
|
|
|
|
// Calc minimum lines
|
|
let minFaceHeight = 0;
|
|
if ($gameMessage._faceName)
|
|
minFaceHeight = ImageManager.faceHeight + $gameSystem.windowPadding() * 2;
|
|
|
|
// Calc text height
|
|
let textState = { index: 0 };
|
|
let extraFontHeight = 0;
|
|
const lines = $gameMessage._texts;
|
|
|
|
// Dodgy way to modify text line height if the \{ \} text codes are used.
|
|
for (let i = 0; i < lines.length; i++) {
|
|
let up = (lines[i].match(/\\{/g) || []).length;
|
|
let down = (lines[i].match(/\\}/g) || []).length;
|
|
|
|
// Height
|
|
extraFontHeight += extraFontHeight + (up - down);
|
|
}
|
|
extraFontHeight *= 24;
|
|
|
|
// Escape characters from text
|
|
textState.text = this.convertEscapeCharacters($gameMessage.allText());
|
|
|
|
// Build actual height from everything
|
|
const allLineHeight = this.calcTextHeight(textState, true);
|
|
const height =
|
|
allLineHeight + $gameSystem.windowPadding() * 2 + extraFontHeight;
|
|
const minHeight = this.fittingHeight($gameMessage._texts.length);
|
|
this.height = Math.max(height, minHeight, minFaceHeight);
|
|
this.height += Galv.Mstyle.padding[0] + Galv.Mstyle.padding[2];
|
|
this.height += this.galvExtraHeights();
|
|
this.yOffset = -Galv.Mstyle.yOffset - this.height;
|
|
|
|
Galv.Mstyle.testActive = false;
|
|
this.otherMStyleCommands(); // stop certain things happening when drawing the text that was used for determining size.
|
|
} else {
|
|
// if this.pTarget is null
|
|
// normal message window
|
|
this.yOffset = 0;
|
|
this.width = this.windowWidth();
|
|
this.height =
|
|
this.fittingHeight(4) + Galv.Mstyle.padding[0] + Galv.Mstyle.padding[2];
|
|
this.x = (Graphics.boxWidth - this.width) / 2;
|
|
}
|
|
};
|
|
|
|
Galv.Mstyle.Window_Message_processEscapeCharacter =
|
|
Window_Message.prototype.processEscapeCharacter;
|
|
Window_Message.prototype.processEscapeCharacter = function (code, textState) {
|
|
// if only testing the text for sizes, don't process the characters that pause, etc.
|
|
if (Galv.Mstyle.testActive)
|
|
return Window_Base.prototype.processEscapeCharacter.call(
|
|
this,
|
|
code,
|
|
textState
|
|
);
|
|
Galv.Mstyle.Window_Message_processEscapeCharacter.call(this, code, textState);
|
|
};
|
|
|
|
Window_Message.prototype.otherMStyleCommands = function () {};
|
|
|
|
Window_Message.prototype.windowWidth = function () {
|
|
return Graphics.boxWidth;
|
|
};
|
|
|
|
Window_Message.prototype.testWidthEx = function (text) {
|
|
return this.textSizeEx(text).width;
|
|
};
|
|
|
|
Galv.Mstyle.Window_Message__refreshPauseSign =
|
|
Window_Message.prototype._refreshPauseSign;
|
|
Window_Message.prototype._refreshPauseSign = function () {
|
|
Galv.Mstyle.Window_Message__refreshPauseSign.call(this);
|
|
// indicator graphic to let user know they need to press a button
|
|
let x = 0;
|
|
let y = 0;
|
|
const oX = Galv.Mstyle.indPos[1];
|
|
const oY = Galv.Mstyle.indPos[2];
|
|
|
|
this._pauseSignSprite.anchor.y = 0.5;
|
|
this._pauseSignSprite.anchor.x = 0.5;
|
|
|
|
const pos = Galv.Mstyle.indPos[0];
|
|
|
|
switch (pos) {
|
|
case 1:
|
|
x = oX;
|
|
y = this._height + oY;
|
|
break;
|
|
case 2:
|
|
x = this._width / 2 + oX;
|
|
y = this._height + oY;
|
|
break;
|
|
case 3:
|
|
x = this.width + oX;
|
|
y = this._height + oY;
|
|
break;
|
|
case 4:
|
|
x = oX;
|
|
y = this.height / 2 + oY;
|
|
break;
|
|
case 6:
|
|
x = this.width + oX;
|
|
y = this.height / 2 + oY;
|
|
break;
|
|
case 7:
|
|
x = oX;
|
|
y = oY;
|
|
break;
|
|
case 8:
|
|
x = this._width / 2 + oX;
|
|
y = oY;
|
|
break;
|
|
case 9:
|
|
x = this.width + oX;
|
|
y = oY;
|
|
break;
|
|
}
|
|
this._pauseSignSprite.move(x, y);
|
|
};
|
|
|
|
Galv.Mstyle.Window_Message_convertEscapeCharacters =
|
|
Window_Message.prototype.convertEscapeCharacters;
|
|
Window_Message.prototype.convertEscapeCharacters = function (text) {
|
|
text = Galv.Mstyle.Window_Message_convertEscapeCharacters.call(this, text);
|
|
text = text.replace(/\x1bpop\[[^\]]*\]/gi, ""); // Remove it if different characters are present!
|
|
return text;
|
|
};
|
|
|
|
// WINDOW NAMEBOX
|
|
//-----------------------------------------------------------------------------
|
|
|
|
Window_NameBox.prototype.loadWindowskin = function () {
|
|
Window_Base.prototype.loadPopMessageWindowskin.call(this);
|
|
};
|
|
|
|
// WINDOW BASE
|
|
//-----------------------------------------------------------------------------
|
|
|
|
Window_Base.prototype.loadPopMessageWindowskin = function () {
|
|
if (Galv.Mstyle.target) {
|
|
// use the pop settings
|
|
const skin = Galv.Mstyle.tempPopData.windowskin
|
|
? Galv.Mstyle.tempPopData.windowskin
|
|
: $gameSystem._mStyles[1].windowskin;
|
|
return (this.windowskin = ImageManager.loadSystem(skin));
|
|
} else {
|
|
// use the default settings
|
|
return (this.windowskin = ImageManager.loadSystem(
|
|
$gameSystem._mStyles[0].windowskin
|
|
));
|
|
}
|
|
};
|