phaser4-rex-plugins
Version:
1,628 lines (1,338 loc) • 640 kB
JavaScript
(function (global, factory) {
typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
typeof define === 'function' && define.amd ? define(factory) :
(global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.rextextbox = factory());
})(this, (function () { 'use strict';
var EventEmitterMethods$1 = {
setEventEmitter(eventEmitter, EventEmitterClass) {
if (EventEmitterClass === undefined) {
EventEmitterClass = Phaser.Events.EventEmitter; // Use built-in EventEmitter class by default
}
this._privateEE = (eventEmitter === true) || (eventEmitter === undefined);
this._eventEmitter = (this._privateEE) ? (new EventEmitterClass()) : eventEmitter;
return this;
},
destroyEventEmitter() {
if (this._eventEmitter && this._privateEE) {
this._eventEmitter.shutdown();
}
return this;
},
getEventEmitter() {
return this._eventEmitter;
},
on() {
if (this._eventEmitter) {
this._eventEmitter.on.apply(this._eventEmitter, arguments);
}
return this;
},
once() {
if (this._eventEmitter) {
this._eventEmitter.once.apply(this._eventEmitter, arguments);
}
return this;
},
off() {
if (this._eventEmitter) {
this._eventEmitter.off.apply(this._eventEmitter, arguments);
}
return this;
},
emit(event) {
if (this._eventEmitter && event) {
this._eventEmitter.emit.apply(this._eventEmitter, arguments);
}
return this;
},
addListener() {
if (this._eventEmitter) {
this._eventEmitter.addListener.apply(this._eventEmitter, arguments);
}
return this;
},
removeListener() {
if (this._eventEmitter) {
this._eventEmitter.removeListener.apply(this._eventEmitter, arguments);
}
return this;
},
removeAllListeners() {
if (this._eventEmitter) {
this._eventEmitter.removeAllListeners.apply(this._eventEmitter, arguments);
}
return this;
},
listenerCount() {
if (this._eventEmitter) {
return this._eventEmitter.listenerCount.apply(this._eventEmitter, arguments);
}
return 0;
},
listeners() {
if (this._eventEmitter) {
return this._eventEmitter.listeners.apply(this._eventEmitter, arguments);
}
return [];
},
eventNames() {
if (this._eventEmitter) {
return this._eventEmitter.eventNames.apply(this._eventEmitter, arguments);
}
return [];
},
};
const SceneClass = Phaser.Scene;
var IsSceneObject = function (object) {
return (object instanceof SceneClass);
};
var GetSceneObject = function (object) {
if ((object == null) || (typeof (object) !== 'object')) {
return null;
} else if (IsSceneObject(object)) { // object = scene
return object;
} else if (object.scene && IsSceneObject(object.scene)) { // object = game object
return object.scene;
} else if (object.parent && object.parent.scene && IsSceneObject(object.parent.scene)) { // parent = bob object
return object.parent.scene;
} else {
return null;
}
};
const GameClass = Phaser.Game;
var IsGame = function (object) {
return (object instanceof GameClass);
};
var GetGame = function (object) {
if ((object == null) || (typeof (object) !== 'object')) {
return null;
} else if (IsGame(object)) {
return object;
} else if (IsGame(object.game)) {
return object.game;
} else if (IsSceneObject(object)) { // object = scene object
return object.sys.game;
} else if (IsSceneObject(object.scene)) { // object = game object
return object.scene.sys.game;
}
};
const GetValue$X = Phaser.Utils.Objects.GetValue;
class ComponentBase {
constructor(parent, config) {
this.setParent(parent); // gameObject, scene, or game
this.isShutdown = false;
// Event emitter, default is private event emitter
this.setEventEmitter(GetValue$X(config, 'eventEmitter', true));
// Register callback of parent destroy event, also see `shutdown` method
if (this.parent) {
if (this.parent === this.scene) { // parent is a scene
this.scene.sys.events.once('shutdown', this.onEnvDestroy, this);
} else if (this.parent === this.game) { // parent is game
this.game.events.once('shutdown', this.onEnvDestroy, this);
} else if (this.parent.once) { // parent is game object or something else
this.parent.once('destroy', this.onParentDestroy, this);
}
// bob object does not have event emitter
}
}
shutdown(fromScene) {
// Already shutdown
if (this.isShutdown) {
return;
}
// parent might not be shutdown yet
if (this.parent) {
if (this.parent === this.scene) { // parent is a scene
this.scene.sys.events.off('shutdown', this.onEnvDestroy, this);
} else if (this.parent === this.game) { // parent is game
this.game.events.off('shutdown', this.onEnvDestroy, this);
} else if (this.parent.once) { // parent is game object or something else
this.parent.off('destroy', this.onParentDestroy, this);
}
// bob object does not have event emitter
}
this.destroyEventEmitter();
this.parent = undefined;
this.scene = undefined;
this.game = undefined;
this.isShutdown = true;
}
destroy(fromScene) {
this.shutdown(fromScene);
}
onEnvDestroy() {
this.destroy(true);
}
onParentDestroy(parent, fromScene) {
this.destroy(fromScene);
}
setParent(parent) {
this.parent = parent; // gameObject, scene, or game
this.scene = GetSceneObject(parent);
this.game = GetGame(parent);
return this;
}
}
Object.assign(
ComponentBase.prototype,
EventEmitterMethods$1
);
const TextClass = Phaser.GameObjects.Text;
var IsTextGameObject = function (gameObject) {
return (gameObject instanceof TextClass);
};
const BitmapTextClass = Phaser.GameObjects.BitmapText;
var IsBitmapTextGameObject = function (gameObject) {
return (gameObject instanceof BitmapTextClass);
};
const TextType = 0;
const TagTextType = 1;
const BitmapTextType = 2;
var GetTextObjectType = function (textObject) {
var textObjectType;
if (IsBitmapTextGameObject(textObject)) {
textObjectType = BitmapTextType;
} else if (IsTextGameObject(textObject)) {
textObjectType = TextType;
} else {
textObjectType = TagTextType;
}
return textObjectType;
};
var TextToLines = function (textObject, text, lines) {
var textObjectType = GetTextObjectType(textObject);
switch (textObjectType) {
case TextType:
lines = textObject.getWrappedText(text); // Array of string
break;
case TagTextType:
lines = textObject.getPenManager(text, lines); // Pens-manager
break;
case BitmapTextType:
if (textObject.maxWidth > 0) {
lines = textObject.setText(text).getTextBounds().wrappedText.split('\n');
} else {
lines = text.split('\n');
}
break;
}
return lines;
};
var TextHeightToLinesCount = function (textObject) {
var textObjectType = GetTextObjectType(textObject);
var height, lineSpacing, lineHeight;
switch (textObjectType) {
case TextType:
case TagTextType:
height = textObject.height - textObject.padding.top - textObject.padding.bottom;
lineSpacing = textObject.lineSpacing;
lineHeight = textObject.style.metrics.fontSize + textObject.style.strokeThickness;
break;
case BitmapTextType:
height = textObject.height;
lineSpacing = 0;
var scale = (textObject.fontSize / textObject.fontData.size);
lineHeight = textObject.fontData.lineHeight * scale;
break;
}
// height = (lines * (lineHeight + lineSpacing)) - lineSpacing
return (height - lineSpacing) / (lineHeight + lineSpacing);
};
var GetLines = function (startLineIndex, endLineIdx) {
if (startLineIndex === undefined) {
startLineIndex = this.startLineIndex;
}
if (endLineIdx === undefined) {
var pageLinesCount = this.pageLinesCount;
if (pageLinesCount > 0) {
endLineIdx = startLineIndex + pageLinesCount;
} else {
endLineIdx = this.totalLinesCount;
}
}
if (endLineIdx > this.totalLinesCount) {
endLineIdx = this.totalLinesCount;
}
var text;
switch (this.textObjectType) {
case TextType:
case BitmapTextType:
text = this.lines.slice(startLineIndex, endLineIdx).join('\n');
break;
case TagTextType:
var startIdx = this.lines.getLineStartIndex(startLineIndex);
var endIdx = this.lines.getLineEndIndex(endLineIdx - 1);
text = this.lines.getSliceTagText(startIdx, endIdx, true);
// Check line count
var newLineCharCount = (text.match(/\n/g) || []).length;
if (newLineCharCount > (endLineIdx - startLineIndex - 1)) {
// Remove last '\n'
text = text.substring(0, text.length - 1);
}
break;
}
return text;
};
var GetString = function (value) {
if (value == null) {
value = '';
} else if (Array.isArray(value)) {
value = value.join('\n');
} else if (typeof (value) === 'number') {
value = value.toString();
}
return value;
};
var SetContentMethods = {
clearText() {
this.sections.length = 0;
this.pageStartIndexes.length = 0;
this.lines.length = 0;
return this;
},
appendPage(text) {
var pageStartIndex = this.totalLinesCount;
this.sections.push(GetString(text));
var text = this.sections.join('\n');
this.lines = TextToLines(this.parent, text, this.lines);
var newLinesCount = this.totalLinesCount - pageStartIndex;
var pageLinesCount = this.pageLinesCount;
var pageCount;
if (pageLinesCount > 0) {
pageCount = Math.ceil(newLinesCount / this.pageLinesCount);
} else { // Height of Text object might be 0
pageCount = 1;
}
for (var i = 0; i < pageCount; i++) {
this.pageStartIndexes.push(
pageStartIndex + (i * this.pageLinesCount)
);
}
return this;
},
setText(text, resetIndex) {
if (resetIndex === undefined) {
resetIndex = true;
}
if (resetIndex) {
this.resetIndex();
}
this.clearText();
var sections = GetString(text).split(this.pageBreak);
// if (sections[sections.length - 1] === '') { // Last section is an empty string
// sections.length -= 1;
// }
for (var i = 0, cnt = sections.length; i < cnt; i++) {
this.appendPage(sections[i]);
}
return this;
},
appendText(text) {
var content = this.content + GetString(text);
this.setText(content, false);
return this;
},
};
const Clamp$1 = Phaser.Math.Clamp;
var GetPageMethods = {
resetIndex() {
this.pageIndex = -1;
this.startLineIndex = -1;
this.endLineIndex = undefined;
return this;
},
setPageIndex(idx) {
idx = Clamp$1(idx, 0, this.lastPageIndex);
this.pageIndex = idx;
this.startLineIndex = this.pageStartIndexes[idx];
this.endLineIndex = this.pageStartIndexes[idx + 1];
return this;
},
getPage(idx) {
if (idx === undefined) {
idx = this.pageIndex;
}
return this.setPageIndex(idx).getLines(this.startLineIndex, this.endLineIndex);
},
getNextPage() {
return this.getPage(this.pageIndex + 1);
},
getPreviousPage() {
return this.getPage(this.pageIndex - 1);
},
getFirstPage() {
return this.getPage(0);
},
getLastPage() {
return this.getPage(this.lastPageIndex);
},
setStartLineIndex(idx) {
var lastStartLineIndex = Math.max(this.totalLinesCount - this.pageLinesCount, 0);
idx = Clamp$1(idx, 0, lastStartLineIndex);
this.startLineIndex = idx;
this.endLineIndex = idx + this.pageLinesCount;
return this;
},
getPageByLineIndex(idx) {
return this.setStartLineIndex(idx).getLines(this.startLineIndex, this.endLineIndex);
},
getPageOfNextLine() {
return this.getPageByLineIndex(this.startLineIndex + 1);
},
getPageOfPreviousLine() {
return this.getPageByLineIndex(this.startLineIndex - 1);
},
getPageOfFirstLine() {
return this.getPageByLineIndex(0);
},
getPageOfLastLine() {
return this.getPageByLineIndex(this.totalLinesCount);
},
};
var SetNoWrapText = function (textObject, text) {
var textObjectType = GetTextObjectType(textObject);
switch (textObjectType) {
case TextType:
// Store wrap properties
var style = textObject.style;
var wordWrapWidth = style.wordWrapWidth;
var wordWrapCallback = style.wordWrapCallback;
// Disable wrap
style.wordWrapWidth = 0;
style.wordWrapCallback = undefined;
// Set text
textObject.setText(text);
// Restore wrap
style.wordWrapWidth = wordWrapWidth;
style.wordWrapCallback = wordWrapCallback;
break;
case TagTextType:
// Store wrap properties
var style = textObject.style;
var wrapMode = style.wrapMode;
// Disable wrap
style.wrapMode = 0;
// Set text
textObject.setText(text);
// Restore wrap
style.wrapMode = wrapMode;
break;
case BitmapTextType:
// Store wrap properties
var maxWidth = textObject._maxWidth;
// Disable wrap
textObject._maxWidth = 0;
// Set text
textObject.setText(text);
// Restore wrap
textObject._maxWidth = maxWidth;
break;
}
};
var ShowMethods = {
showPage(idx) {
this.displayText(
this.getPage(idx)
);
return this;
},
showNextPage() {
this.displayText(
this.getNextPage()
);
return this;
},
showPreviousPage() {
this.displayText(
this.getPreviousPage()
);
return this;
},
showFirstPage() {
this.displayText(
this.getFirstPage()
);
return this;
},
showLastPage() {
this.displayText(
this.getLastPage()
);
return this;
},
show() {
this.displayText(
this.getLines()
);
return this;
},
showPageByLineIndex(lineIndex) {
this.displayText(
this.getPageByLineIndex(lineIndex)
);
return this;
},
showNextLine() {
this.displayText(
this.getPageOfNextLine()
);
return this;
},
showPreviousLine() {
this.displayText(
this.getPageOfPreviousLine()
);
return this;
},
showFirstLine() {
this.displayText(
this.getPageOfFirstLine()
);
return this;
},
showLastLine() {
this.displayText(
this.getPageOfLastLine()
);
return this;
},
displayText(text) {
SetNoWrapText(this.parent, text);
}
};
var Methods$3 = {
getLines: GetLines,
};
Object.assign(
Methods$3,
SetContentMethods,
GetPageMethods,
ShowMethods
);
const GetValue$W = Phaser.Utils.Objects.GetValue;
Phaser.Math.Clamp;
class TextPage extends ComponentBase {
constructor(gameObject, config) {
super(gameObject, { eventEmitter: false });
// No event emitter
// this.parent = gameObject;
this.textObjectType = GetTextObjectType(this.parent);
this.pageStartIndexes = [];
// Text object : array of string
// Tag text object : pens-manager
// Bitmap text object : array of string
this.lines = TextToLines(this.parent, '');
this.sections = [];
this.resetFromJSON(config);
}
resetFromJSON(o) {
this.setMaxLines(GetValue$W(o, 'maxLines', undefined));
this.setPageBreak(GetValue$W(o, 'pageBreak', '\f\n'));
this.setText(GetValue$W(o, 'text', ''));
this.startLineIndex = GetValue$W(o, 'start', -1);
this.endLineIndex = GetValue$W(o, 'end', undefined);
var pageIndex = GetValue$W(o, 'page');
if (pageIndex === undefined) {
this.resetIndex();
} else {
this.setPageIndex(pageIndex);
}
return this;
}
toJSON() {
return {
maxLines: this.maxLines,
text: this.content,
start: this.startLineIndex,
end: this.endLineIndex,
page: this.pageIndex,
pageBreak: this.pageBreak
};
}
shutdown(fromScene) {
// Already shutdown
if (this.isShutdown) {
return;
}
switch (this.textObjectType) {
case TextType:
this.lines.length = 0;
break;
case TagTextType:
this.lines.destroy();
break;
case BitmapTextType:
this.lines.length = 0;
break;
}
this.pageStartIndexes.length = 0;
this.sections.length = 0;
this.lines = undefined;
this.pageStartIndexes = undefined;
this.sections = undefined;
super.shutdown(fromScene);
}
setMaxLines(maxLines) {
this.maxLines = maxLines;
return this;
}
setPageBreak(pageBreak) {
this.pageBreak = pageBreak;
return this;
}
get pageCount() {
return this.pageStartIndexes.length;
}
get lastPageIndex() {
return this.pageCount - 1;
}
get isFirstPage() {
return (this.pageIndex <= 0);
}
get isLastPage() {
return (this.pageIndex >= (this.pageCount - 1));
}
get totalLinesCount() {
return (this.lines) ? this.lines.length : 0;
}
get pageLinesCount() {
// Since the line height of each line is the same,
// each page will have the same number of lines
if (this.maxLines !== undefined) {
return this.maxLines;
} else {
var count;
switch (this.textObjectType) {
case TextType:
case TagTextType:
var maxLines = this.parent.style.maxLines;
if (maxLines > 0) {
count = maxLines;
} else {
count = Math.floor(TextHeightToLinesCount(this.parent));
}
break;
case BitmapTextType:
count = this.totalLinesCount;
break;
}
return count;
}
}
get isFirstLine() {
return (this.startLineIndex <= 0);
}
get isLastLine() {
return this.endLineIndex === this.totalLinesCount;
}
get content() {
return this.sections.join(this.pageBreak);
}
}
Object.assign(
TextPage.prototype,
Methods$3,
);
var SetTextMethods = {
setText(text) {
if (this.setTextCallback) {
if (this.setTextCallbackScope) {
text = this.setTextCallback.call(this.setTextCallbackScope, text, this.isLastChar, this.insertIndex);
} else {
text = this.setTextCallback(text, this.isLastChar, this.insertIndex);
}
}
if (this.textWrapEnable) {
SetNoWrapText(this.parent, text);
} else {
this.parent.setText(text);
}
},
appendText(text) {
var newText = this.text.concat(GetString(text));
if (this.isTyping) {
this.setTypingContent(newText);
} else {
this.start(newText, undefined, this.textLength);
}
return this;
}
};
var StartTyping = function (text, speed, startIndex, timerStartAt) {
if (text !== undefined) {
this.setTypingContent(text);
}
if (speed !== undefined) {
this.speed = speed;
}
if (startIndex === undefined) {
startIndex = 0;
}
this.typingIndex = startIndex + 1;
if (this.speed === 0) {
this.stop(true);
} else {
this.setText('');
this.startTimer(timerStartAt);
}
return this;
};
var GetPlainText = function (textObject, text) {
if (textObject.getPlainText) {
text = textObject.getPlainText(text);
}
return text;
};
var StartTypingFromLine = function (text, lineIndex, speed, offsetIndex, timerStartAt) {
var startIdx;
if (lineIndex > 0) {
if (offsetIndex === undefined) {
offsetIndex = 0;
}
var plainText = GetPlainText(this.parent, text);
startIdx = GetNewLineIndex(plainText, lineIndex) + offsetIndex;
}
return this.start(text, speed, startIdx, timerStartAt);
};
var GetNewLineIndex = function (s, n) {
var index = undefined;
for (var i = 0; i < n; i++) {
index = s.indexOf('\n', index + 1);
if (index === -1) {
break;
}
}
return index;
};
var GetSubString = function (textObject, text, startIdx, endIdx) {
var result;
if (textObject.getSubString) {
result = textObject.getSubString(text, startIdx, endIdx);
} else {
result = text.slice(startIdx, endIdx);
}
return result;
};
var GetTypingString = function (text, typeIdx, textLength, typeMode) {
var textObject = this.parent;
var result;
if (typeMode === 0) { //left-to-right
var startIdx = 0;
var endIdx = typeIdx;
this.insertIndex = endIdx;
result = GetSubString(textObject, text, startIdx, endIdx);
} else if (typeMode === 1) { //right-to-left
var endIdx = textLength;
var startIdx = endIdx - typeIdx;
this.insertIndex = 0;
result = GetSubString(textObject, text, startIdx, endIdx);
} else if (typeMode === 2) { //middle-to-sides
var midIdx = textLength / 2;
var startIdx = Math.floor(midIdx - (typeIdx / 2));
var endIdx = startIdx + typeIdx;
this.insertIndex = (typeIdx % 2) ? typeIdx : 0;
result = GetSubString(textObject, text, startIdx, endIdx);
} else if (typeMode === 3) { //sides-to-middle
var lowerLen = Math.floor(typeIdx / 2);
var lowerResult;
if (lowerLen > 0) {
var endIdx = textLength;
var startIdx = endIdx - lowerLen;
lowerResult = GetSubString(textObject, text, startIdx, endIdx);
} else {
lowerResult = "";
}
var upperLen = typeIdx - lowerLen;
var upperResult;
if (upperLen > 0) {
var startIdx = 0;
var endIdx = startIdx + upperLen;
this.insertIndex = endIdx;
upperResult = GetSubString(textObject, text, startIdx, endIdx);
} else {
upperResult = "";
this.insertIndex = 0;
}
result = upperResult + lowerResult;
}
this.insertChar = result.charAt(this.insertIndex - 1);
return result;
};
var StopTyping = function (showAllText) {
var timer = this.getTimer();
if (timer) {
this.freeTimer();
}
if (showAllText) {
// Fire 'type' event for remainder characters until lastChar
while (!this.isLastChar) {
GetTypingString.call(this, this.text, this.typingIndex, this.textLength, this.typeMode);
this.emit('typechar', this.insertChar);
this.typingIndex++;
}
// Display all characters on text game object
this.setText(this.text);
this.emit('type');
this.emit('complete', this, this.parent);
}
return this;
};
var PauseTyping = function () {
var timer = this.getTimer();
if (timer) {
timer.paused = true;
}
return this;
};
var ResumeTyping = function () {
var timer = this.getTimer();
if (timer) {
timer.paused = false;
}
return this;
};
var methods$9 = {
start: StartTyping,
startFromLine: StartTypingFromLine,
stop: StopTyping,
pause: PauseTyping,
resumeTyping: ResumeTyping,
};
Object.assign(
methods$9,
SetTextMethods
);
var GetWrapText = function (textObject, text) {
var textObjectType = GetTextObjectType(textObject);
switch (textObjectType) {
case TextType:
textObject.style.syncFont(textObject.canvas, textObject.context);
text = textObject.runWordWrap(text);
break;
case TagTextType:
text = textObject.getText(text, undefined, undefined, true);
break;
case BitmapTextType:
text = textObject.setText(text).getTextBounds().wrappedText;
break;
}
return text;
};
const GetFastValue$1 = Phaser.Utils.Objects.GetFastValue;
const GetValue$V = Phaser.Utils.Objects.GetValue;
class TextTyping extends ComponentBase {
constructor(gameObject, config) {
super(gameObject, config);
// this.parent = gameObject;
this.timer = null;
this.resetFromJSON(config);
}
resetFromJSON(o) {
this.setTextWrapEnable(GetValue$V(o, 'wrap', false));
this.setTypeMode(GetValue$V(o, 'typeMode', 0));
this.setTypingSpeed(GetValue$V(o, 'speed', 333));
this.setTextCallback = GetFastValue$1(o, 'setTextCallback', null);
this.setTextCallbackScope = GetFastValue$1(o, 'setTextCallbackScope', null);
this.setTypingContent(GetFastValue$1(o, 'text', ''));
this.typingIndex = GetFastValue$1(o, 'typingIndex', 0);
this.insertIndex = null;
this.insertChar = null;
var elapsed = GetFastValue$1(o, 'elapsed', null);
if (elapsed !== null) {
this.start(undefined, undefined, this.typingIndex, elapsed);
}
return this;
}
shutdown(fromScene) {
// Already shutdown
if (this.isShutdown) {
return;
}
this.freeTimer();
super.shutdown(fromScene);
}
setTypeMode(m) {
if (typeof (m) === 'string') {
m = TYPEMODE[m];
}
this.typeMode = m;
return this;
}
setTypeSpeed(speed) {
this.speed = speed;
return this;
}
setTypingSpeed(speed) {
this.speed = speed;
return this;
}
setTextWrapEnable(enable) {
if (enable === undefined) {
enable = true;
}
this.textWrapEnable = enable;
return this;
}
set text(value) {
var text = GetString(value);
if (this.textWrapEnable) {
text = GetWrapText(this.parent, text);
}
this._text = text;
}
get text() {
return this._text;
}
get isTyping() {
return (this.getTimer() !== null);
}
get isLastChar() {
return (this.typingIndex === this.textLength);
}
setTypingContent(text) {
this.text = text;
this.textLength = GetPlainText(this.parent, this.text).length;
return this;
}
onTyping() {
var newText = GetTypingString.call(this, this.text, this.typingIndex, this.textLength, this.typeMode);
this.setText(newText);
this.emit('typechar', this.insertChar);
this.emit('type');
if (this.isLastChar) {
this.freeTimer();
// Fire 'complete' next tick, to render last character on screen
this.scene.sys.events.once('preupdate', function () {
this.emit('complete', this, this.parent);
}, this);
} else {
this.timer.delay = this.speed; // delay of next typing
this.typingIndex++;
}
}
startTimer(timerStartAt) {
if (this.timer) {
this.freeTimer();
}
var startAt;
if (timerStartAt === undefined) {
startAt = 0;
} else {
this.speed;
startAt = timerStartAt;
}
this.timer = this.scene.time.addEvent({
delay: 0.0001,
startAt: startAt,
loop: true,
callback: this.onTyping,
callbackScope: this
});
// Note: Throw error message if delay is 0 with repeat/loop
return this;
}
getTimer() {
return this.timer;
}
freeTimer() {
if (this.timer) {
this.timer.remove();
this.timer = null;
}
return this;
}
setText(text) {
if (this.setTextCallback) {
if (this.setTextCallbackScope) {
text = this.setTextCallback.call(this.setTextCallbackScope, text, this.isLastChar, this.insertIndex);
} else {
text = this.setTextCallback(text, this.isLastChar, this.insertIndex);
}
}
if (this.textWrapEnable) {
SetNoWrapText(this.parent, text);
} else {
this.parent.setText(text);
}
}
}
const TYPEMODE = {
'left-to-right': 0,
'right-to-left': 1,
'middle-to-sides': 2,
'sides-to-middle': 3
};
Object.assign(
TextTyping.prototype,
methods$9
);
const GetValue$U = Phaser.Utils.Objects.GetValue;
var TextBoxBase = function (GOClass, type) {
if (type === undefined) {
type = 'rexTextBox';
}
class TextBox extends GOClass {
constructor(scene, config) {
super(scene, config);
this.type = type;
this.isRunning = false;
this._isPageEnd = false;
// childrenMap must have 'text' element
var text = this.childrenMap.text;
// Expand text size
var expandTextWidth = GetValue$U(config, 'expandTextWidth', false);
var expandTextHeight = GetValue$U(config, 'expandTextHeight', false);
if (expandTextWidth || expandTextHeight) {
var textObjectType = GetTextObjectType(text);
switch (textObjectType) {
case TextType:
case TagTextType:
// Don't overwrite resize method if text has it already
text.resize = function (width, height) {
var fixedWidth = (expandTextWidth) ? width : 0;
var fixedHeight = (expandTextHeight) ? height : 0;
text.setFixedSize(fixedWidth, fixedHeight);
if (fixedWidth > 0) {
text.setWordWrapWidth(fixedWidth);
}
};
if (textObjectType === TagTextType) {
var style = text.style;
if (style.wrapMode === 0) { // Turn no-wrap to word-wrap
style.wrapMode = 1;
}
}
break;
}
if (expandTextWidth) {
text._minWidth = 0;
}
if (expandTextHeight) {
text._minHeight = 0;
}
}
// Build typing and page behaviors
this.setTypingMode(GetValue$U(config, 'typingMode', 'page'));
this.page = new TextPage(text, GetValue$U(config, 'page', undefined));
this.typing = new TextTyping(text, GetValue$U(config, 'typing', config.type));
this.typing
.on('complete', this.onTypingComplete, this)
.on('type', this.onType, this)
.on('typechar', this.onTypeChar, this);
// Run layout again when size of text game object has changed
this.textWidthSave = text.width;
this.textHeightSave = text.height;
}
setTypingMode(mode) {
if (typeof (mode) === 'string') {
mode = TypingMode[mode];
}
this.typingMode = mode;
return this;
}
start(text, speed) {
if (speed !== undefined) {
this.setTypingSpeed(speed);
}
// Start typing task
this.isRunning = true;
this.page.setText(text);
this.emit('start');
if (this.typingMode === 0) {
// Typing page by page
this.typeNextPage();
} else {
// Typing line by line
this.typeNextLine();
}
return this;
}
more(text, speed) {
if (speed !== undefined) {
this.setTypingSpeed(speed);
}
if (this.isRunning) {
this.page.appendText(text);
this.typing.appendText(text);
} else {
this.isRunning = true;
this.page.appendText(text);
this.emit('start');
if (this.typingMode === 0) {
this._isPageEnd = false;
var txt = this.page.getPage();
var startIndex = this.typing.textLength;
this.typing.start(txt, undefined, startIndex);
}
return this;
}
}
typeNextPage() {
// Do nothing if typing task does not start
if (!this.isRunning) {
return this;
}
if (!this.isLastPage) {
this._isPageEnd = false;
var txt = this.page.getNextPage();
this.typing.start(txt);
} else {
this.emit('complete');
}
return this;
}
typeNextLine() {
// Do nothing if typing task does not start
if (!this.isRunning) {
return this;
}
if (!this.isLastLine) {
var txt = this.page.getPageOfNextLine();
var startLineIndex;
if (this.isFirstLine) {
// Typing from 1st line
startLineIndex = 0;
} else {
// Typing last line
startLineIndex = this.page.pageLinesCount - 1;
}
this.typing.startFromLine(txt, startLineIndex);
} else {
// Stop typing tasl if typing complete at last line
this.isRunning = false;
this.emit('pageend');
this.emit('complete');
}
}
pause() {
// Do nothing if typing task does not start
if (!this.isRunning) {
return this;
}
if (this.isTyping) {
this.typing.pause();
this.emit('pause');
}
return this;
}
resume() {
// Do nothing if typing task does not start
if (!this.isRunning) {
return this;
}
if (!this.isTyping) {
this.emit('resume');
this.typing.resume();
}
return this;
}
stop(showAllText) {
// Do nothing if typing task does not start
if (!this.isRunning) {
return this;
}
this.typing.stop(showAllText);
return this;
}
showLastPage() {
// Do nothing if typing task does not start
if (!this.isRunning) {
return this;
}
this.typing.stop();
if (this.typingMode === 0) {
this.page.showLastPage();
} else {
this.page.showLastLine();
}
this.emit('type');
this.onTypingComplete();
return this;
}
setTypeSpeed(speed) {
this.typing.setTypingSpeed(speed);
return this;
}
setTypingSpeed(speed) {
this.typing.setTypingSpeed(speed);
return this;
}
get isTyping() {
return this.typing.isTyping;
}
get isPageEnd() {
return this._isPageEnd;
}
get isLastPage() {
return this.page.isLastPage;
}
get isFirstPage() {
return this.page.isFirstPage;
}
get pageCount() {
return this.page.pageCount;
}
get pageIndex() {
return this.page.pageIndex;
}
get isLastLine() {
return this.page.isLastLine;
}
get isFirstLine() {
return this.page.isFirstLine;
}
get lineCound() {
return this.page.totalLinesCount;
}
get startLineIndex() {
return this.page.startLineIndex;
}
get endLineIndex() {
return this.page.endLineIndex;
}
get typingSpeed() {
return this.typing.speed;
}
onType() {
var text = this.childrenMap.text;
if ((this.textWidthSave !== text.width) || (this.textHeightSave !== text.height)) {
this.textWidthSave = text.width;
this.textHeightSave = text.height;
this.getTopmostSizer().layout();
}
this.emit('type');
}
onTypeChar(char) {
this.emit('typechar', char);
}
onTypingComplete() {
if (this.typingMode === 0) {
this._isPageEnd = true;
var isLastPage = this.isLastPage;
// Stop typing tasl if typing complete at last page
this.isRunning = !isLastPage;
this.emit('pageend');
/*
Might enter this method immediately, if invoking typeNextPage() in this 'pageend' event.
*/
if (isLastPage) {
this.emit('complete');
}
} else {
// Typing next line continually
this.typeNextLine();
}
}
}
return TextBox;
};
const TypingMode = {
page: 0,
line: 1
};
const MainVersionNumber = 4;
const SubVersionNumber = 0;
var IsChecked = false;
var CheckP3Version = function (minVersion) {
if (IsChecked) {
return;
}
if (minVersion === undefined) {
minVersion = SubVersionNumber;
}
var version = Phaser.VERSION.split('.');
var mainVersion = parseInt(version[0]);
if (mainVersion === MainVersionNumber) {
var subVersion = parseInt(version[1]);
if (subVersion < minVersion) {
console.error(`Minimum supported version : ${mainVersion}.${subVersion}`);
}
} else {
console.error(`Can't supported version : ${mainVersion}`);
}
IsChecked = true;
};
CheckP3Version();
const Zone$1 = Phaser.GameObjects.Zone;
const AddItem = Phaser.Utils.Array.Add;
const RemoveItem$6 = Phaser.Utils.Array.Remove;
let Base$2 = class Base extends Zone$1 {
constructor(scene, x, y, width, height) {
if (x === undefined) {
x = 0;
}
if (y === undefined) {
y = 0;
}
if (width === undefined) {
width = 1;
}
if (height === undefined) {
height = 1;
}
super(scene, x, y, width, height);
this.children = [];
}
destroy(fromScene) {
// This Game Object has already been destroyed
if (!this.scene || this.ignoreDestroy) {
return;
}
if (fromScene) {
// Stop scene
var child;
for (var i = this.children.length - 1; i >= 0; i--) {
child = this.children[i];
if (!child.parentContainer && // Not in container
!child.displayList // Not in scene, neither in layer
) {
// Destroy child which is not in scene, container, or layer manually
child.destroy(fromScene);
}
}
}
// Destroy/remove children
this.clear(!fromScene);
super.destroy(fromScene);
}
contains(gameObject) {
return (this.children.indexOf(gameObject) !== -1);
}
add(gameObjects) {
var parent = this;
AddItem(this.children, gameObjects, 0,
// Callback of item added
function (gameObject) {
gameObject.once('destroy', parent.onChildDestroy, parent);
}, this);
return this;
}
remove(gameObjects, destroyChild) {
var parent = this;
RemoveItem$6(this.children, gameObjects,
// Callback of item removed
function (gameObject) {
gameObject.off('destroy', parent.onChildDestroy, parent);
if (destroyChild) {
gameObject.destroy();
}
}
);
return this;
}
onChildDestroy(child, fromScene) {
// Only remove reference
this.remove(child, false);
}
clear(destroyChild) {
var parent = this;
var gameObject;
for (var i = 0, cnt = this.children.length; i < cnt; i++) {
gameObject = this.children[i];
gameObject.off('destroy', parent.onChildDestroy, parent);
if (destroyChild) {
gameObject.destroy();
}
}
this.children.length = 0;
re