dazed-translations/ultimate-angel-zerachiel
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
ultimate-angel-zerachiel/www/js/plugins/XPStyleBattleMV.js
Dazed 962c3a0c97 Reformat files
2024-01-17 11:38:37 -06:00

9431 lines
303 KiB
JavaScript
Raw Blame History

/*:
* @plugindesc XPStyleBattle for MV Build200211
* @author Momomaru Remix / Peachround
*
* @help Please refer to: http://peachround.com/mv/xpb4mv/
*
* @requiredAssets img/system/selection_cursor
* @requiredAssets img/system/bd_standard/hud_bg
* @requiredAssets img/system/bd_standard/std_bg
* @requiredAssets img/system/bd_standard/std_gauge_bg
* @requiredAssets img/system/bd_standard/std_hp
* @requiredAssets img/system/bd_standard/std_gauge
* @requiredAssets img/system/bd_standard/std_large_numbers
* @requiredAssets img/system/bd_standard/std_gauge_bg
* @requiredAssets img/system/bd_standard/std_mp
* @requiredAssets img/system/bd_standard/std_gauge
* @requiredAssets img/system/bd_standard/std_large_numbers
* @requiredAssets img/system/bd_standard/std_tp_gauge_bg
* @requiredAssets img/system/bd_standard/std_tp
* @requiredAssets img/system/bd_standard/std_tp_gauge
* @requiredAssets img/system/bd_standard/std_small_numbers
*
*
*
* @param (string)hud.themeFileName
* @type string
* @desc HUD theme file path that placed in "data" folder. [Default: empty string]
*
* ----------------------------------------------------------------------------
*
* @param (string)battlerGraphic.rootPath
* @type string
* @desc Battler graphics image path. [Default: img/battlergraphics/]
*
* @param (boolean)battlerGraphic.enableAnimation
* @type boolean
* @desc Enable animation for actor. [Front view only] [Default: true]
*
* @param (boolean)battlerGraphic.enablePopup
* @type boolean
* @desc Enable popup for actor. [Front view only] [Default: true]
*
* @param (integer)battlerGraphic.damageDuration
* @type number
* @min 1
* @max 4096
* @desc Duration to display Damage BattlerGraphic. [Default: 24]
*
* ----------------------------------------------------------------------------
*
* @param (integer)animation.playRate
* @type number
* @min 1
* @max 8
* @desc Animation play speed. 1: 4/1 2: 2/1 3: 4/3 4: 1/1 [Default: 4]
*
* @param (integer)animation.forParty.adjustPosition.x
* @type number
* @min -4096
* @max 4096
* @desc The adjustment x coordinate for party animation. [Default: 0]
*
* @param (integer)animation.forParty.adjustPosition.y
* @type number
* @min -4096
* @max 4096
* @desc The adjustment y coordinate for party animation. [Default: 0]
*
* ----------------------------------------------------------------------------
*
* @param (string)targetCursor.fileName
* @type file
* @dir img/system
* @desc The file name of the cursor image. [Default: selection_cursor]
* @default selection_cursor
* @require 1
*
* @param (integer)targetCursor.width
* @type number
* @min 0
* @max 4096
* @desc Width per pattern. 0: Auto [Default: 0]
*
* @param (integer)targetCursor.animationSpeed
* @type number
* @min 1
* @max 128
* @desc The smaller the value, the faster. [Default: 4]
*
* @param (integer)targetCursor.moveSpeed
* @type number
* @min 1
* @max 128
* @desc The smaller the value, the faster. [Default: 5]
*
* @param (integer)targetCursor.adjustPositionOnActor.x
* @type number
* @min -4096
* @max 4096
* @desc The adjustment x coordinate. [Default: 0]
*
* @param (integer)targetCursor.adjustPositionOnActor.y
* @type number
* @min -4096
* @max 4096
* @desc The adjustment y coordinate. [Default: -32]
*
* @param (integer)targetCursor.adjustPositionOnEnemy.x
* @type number
* @min -4096
* @max 4096
* @desc The adjustment x coordinate. [Default: 0]
*
* @param (integer)targetCursor.adjustPositionOnEnemy.y
* @type number
* @min -4096
* @max 4096
* @desc The adjustment y coordinate. [Default: 0]
*
* @param (integer)targetCursor.minY
* @type number
* @min 0
* @max 4096
* @desc The minimum value of y coordinate. [Default: 96]
*
* @param (boolean)targetCursor.checkSelection
* @type boolean
* @desc Check target selection in all scope. [Default: true]
*
* ----------------------------------------------------------------------------
*
* @param (integer)targetInformation.gaugeWidth
* @type number
* @min 1
* @max 4096
* @desc Each gauge width. [Default: 108]
*
* @param (string)targetInformation.scopeNotation.forParty
* @type string
* @desc Scope notation of for party. [Default: 味方全体]
*
* @param (string)targetInformation.scopeNotation.forTroop
* @type string
* @desc Scope notation of for troop. [Default: 敵全体]
*
* @param (string)targetInformation.scopeNotation.forTroopRandom
* @type string
* @desc Scope notation of for random enemies. %1 is random number. [Default: 敵%1体 ランダム]
*
* @param (boolean)targetInformation.actor.states
* @type boolean
* @desc Display actor's state icon. [Default: true]
*
* @param (boolean)targetInformation.actor.hp
* @type boolean
* @desc Display actor's hp. [Default: true]
*
* @param (boolean)targetInformation.actor.mp
* @type boolean
* @desc Display actor's mp. [Default: true]
*
* @param (boolean)targetInformation.actor.tp
* @type boolean
* @desc Display actor's tp. [Default: true]
*
* @param (boolean)targetInformation.enemy.states
* @type boolean
* @desc Display enemy's state icon. [Default: true]
*
* @param (boolean)targetInformation.enemy.hp
* @type boolean
* @desc Display enemy's hp. [Default: false]
*
* @param (boolean)targetInformation.enemy.mp
* @type boolean
* @desc Display enemy's mp. [Default: false]
*
* @param (boolean)targetInformation.enemy.tp
* @type boolean
* @desc Display enemy's tp. [Default: false]
*
* ----------------------------------------------------------------------------
*
* @param (boolean)battleMessage.enemyEmergeMessage
* @type boolean
* @desc Display enemy emergence message at the battle start. [Default: false]
*
* @param (boolean)battleMessage.simpleBattleLog.useSimpleBattleLog
* @type boolean
* @desc Enable simple battle log. [Default: true]
*
* @param (boolean)battleMessage.simpleBattleLog.displayAttack
* @type boolean
* @desc Display normal attack in the log. [Default: true]
*
* @param (boolean)battleMessage.simpleBattleLog.displayGuard
* @type boolean
* @desc Display guard in the log. [Default: true]
*
* @param (boolean)battleMessage.simpleBattleLog.drawIcon
* @type boolean
* @desc Draw an icon with the action name. [Default: true]
*
* @param (integer)battleMessage.simpleBattleLog.align
* @type number
* @min 0
* @max 2
* @desc Text horizontal alignment. 0: Left 1: Center 2: Right [Default: 1]
*
* @param (string)battleMessage.simpleBattleLog.descriptionDelimiter
* @type string
* @desc Delimiter between action name and action description. [Default: ' : ']
*
* @param (integer)battleMessage.simpleBattleLog.descriptionFontSize
* @type number
* @min 0
* @max 128
* @desc Font size of action description. 0: The same font size as the action name [Default: 0]
*
* ----------------------------------------------------------------------------
*
* @param (boolean)windowLayout.itemSkill.fitting
* @type boolean
* @desc Fit height according to the number of items. [Default: true]
*
* @param (boolean)windowLayout.itemSkill.maxHeight
* @type boolean
* @desc Maximum height of item/skill window. [Default: 320]
*
* @param (integer)windowLayout.actorCommand.absolutePosition.x
* @type number
* @min -4096
* @max 4096
* @desc The absolute x coordinate. undefiled: apply relative position from actor [Default: undefined]
*
* @param (integer)windowLayout.actorCommand.absolutePosition.y
* @type number
* @min -4096
* @max 4096
* @desc The absolute y coordinate. undefiled: apply relative position from actor [Default: undefined]
*
* @param (integer)windowLayout.actorCommand.adjustPosition.x
* @type number
* @min -4096
* @max 4096
* @desc The adjustment x coordinate. [Default: 0]
*
* @param (integer)windowLayout.actorCommand.adjustPosition.y
* @type number
* @min -4096
* @max 4096
* @desc The adjustment y coordinate. [Default: -56]
*
* @param (integer)windowLayout.actorCommand.width
* @type number
* @min 1
* @max 4096
* @desc The width. [Default: 192]
*
* @param (boolean)windowLayout.actorCommand.heightFitting
* @type boolean
* @desc Fit height according to the number of items. [Default: true]
*
* @param (integer)windowLayout.actorCommand.visibleRows
* @type number
* @min 1
* @max 64
* @desc Number of rows to display. [Only heightFitting = false] [Default: 4]
*
* @param (boolean)windowLayout.actorCommand.isHorizontal
* @type boolean
* @desc Enable horizontal command. [Default: false]
*
* @param (integer)windowLayout.actorCommand.maxCols
* @type number
* @min 1
* @max 64
* @desc The max number of column. [Only isHorizontal = false] [Default: 1]
*
* @param (string)windowLayout.actorCommand.itemAlign
* @type string
* @desc Alignment of items. parameter = left or center or right [Default: left]
*
* @param (integer)windowLayout.partyCommand.position.x
* @type number
* @min -4096
* @max 4096
* @desc The x coordinate. [Default: undefined]
*
* @param (integer)windowLayout.partyCommand.position.y
* @type number
* @min -4096
* @max 4096
* @desc The y coordinate. [Default: undefined]
*
* @param (integer)windowLayout.partyCommand.width
* @type number
* @min 1
* @max 4096
* @desc The width. undefined: game screen width [Default: undefined]
*
* @param (boolean)windowLayout.partyCommand.heightFitting
* @type boolean
* @desc Fit height according to the number of items. [Default: false]
*
* @param (integer)windowLayout.partyCommand.visibleRows
* @type number
* @min 1
* @max 64
* @desc Number of rows to display. [Only heightFitting = false] [Default: 1]
*
* @param (boolean)windowLayout.partyCommand.isHorizontal
* @type boolean
* @desc Enable horizontal command. [Default: true]
*
* @param (integer)windowLayout.partyCommand.maxCols
* @type number
* @min 1
* @max 64
* @desc The max number of column. [Only isHorizontal = false] [Default: 2]
*
* @param (string)windowLayout.partyCommand.itemAlign
* @type string
* @desc Alignment of items. parameter = left or center or right [Default: center]
*
* ----------------------------------------------------------------------------
*
* @param (integer)battleSpeed.basicSpeed
* @type number
* @min 4
* @max 128
* @desc The smaller the value, the faster. [Default: 12]
*
* @param (boolean)battleSpeed.animationFastForward
* @type boolean
* @desc Enable fast forward of animation. [Default: true]
*
* @param (boolean)battleSpeed.animationDelayFastForward
* @type boolean
* @desc Enable fast forward of animation delay. [Default: true]
*
* @param (integer)battleSpeed.actorStepDuration
* @type number
* @min 1
* @max 128
* @desc The time that the actor takes a small move. [Side view only] [Default: 6]
*
* @param (integer)battleSpeed.animationSkipDuration
* @type number
* @min 0
* @max 4096
* @desc If animation's remaining duration falls below this value, skip the animation. [Default: 8]
*
* @param (boolean)battleSpeed.skipBlinkEffect
* @desc Enable skip of blink effect. [Default: true]
*
* ----------------------------------------------------------------------------
*
* @param (boolean)minorFixes.enableSelectionEffect
* @type boolean
* @desc Enable selection effect for battler. [Default: true]
*
*/
"use strict";
(function () {
if (!Array.prototype.find) {
Array.prototype.find = function (callback, thisArg) {
if (this === null) {
throw new TypeError("Array.prototype.find called on null or undefined");
}
if (typeof callback !== "function") {
throw new TypeError("Callback must be a function");
}
var list = Object(this);
var length = list.length >>> 0;
var value;
for (var i = 0; i < length; i++) {
value = list[i];
if (callback.call(thisArg, value, i, list)) {
return value;
}
}
return undefined;
};
}
})();
(function () {
var TO_RADIANS = Math.PI / 180;
var TO_DEGREES = 180 / Math.PI;
if (!Math.radians) {
Math.radians = function (degrees) {
return degrees * TO_RADIANS;
};
}
if (!Math.degrees) {
Math.degrees = function (radians) {
return radians * TO_DEGREES;
};
}
})();
var BD;
(function (BD) {
var Core;
(function (Core) {
var Consts;
(function (Consts) {
var Enums;
(function (Enums) {
var Mode;
(function (Mode) {
Mode[(Mode["Game"] = 0)] = "Game";
Mode[(Mode["Preview"] = 1)] = "Preview";
Mode[(Mode["Studio"] = 2)] = "Studio";
})((Mode = Enums.Mode || (Enums.Mode = {})));
var TouchInputStatus;
(function (TouchInputStatus) {
TouchInputStatus[(TouchInputStatus["NoInput"] = 0)] = "NoInput";
TouchInputStatus[(TouchInputStatus["Pressed"] = 1)] = "Pressed";
TouchInputStatus[(TouchInputStatus["Triggered"] = 2)] = "Triggered";
})(
(TouchInputStatus =
Enums.TouchInputStatus || (Enums.TouchInputStatus = {}))
);
var Orientation;
(function (Orientation) {
Orientation[(Orientation["Horizontal"] = 0)] = "Horizontal";
Orientation[(Orientation["Vertical"] = 1)] = "Vertical";
})((Orientation = Enums.Orientation || (Enums.Orientation = {})));
var VerticalAlignment;
(function (VerticalAlignment) {
VerticalAlignment[(VerticalAlignment["Top"] = 0)] = "Top";
VerticalAlignment[(VerticalAlignment["Middle"] = 1)] = "Middle";
VerticalAlignment[(VerticalAlignment["Bottom"] = 2)] = "Bottom";
})(
(VerticalAlignment =
Enums.VerticalAlignment || (Enums.VerticalAlignment = {}))
);
var HorizontalAlignment;
(function (HorizontalAlignment) {
HorizontalAlignment[(HorizontalAlignment["Left"] = 0)] = "Left";
HorizontalAlignment[(HorizontalAlignment["Center"] = 1)] = "Center";
HorizontalAlignment[(HorizontalAlignment["Right"] = 2)] = "Right";
})(
(HorizontalAlignment =
Enums.HorizontalAlignment || (Enums.HorizontalAlignment = {}))
);
var Directions;
(function (Directions) {
Directions[(Directions["NoDirection"] = 0)] = "NoDirection";
Directions[(Directions["LeftDown"] = 1)] = "LeftDown";
Directions[(Directions["Down"] = 2)] = "Down";
Directions[(Directions["RightDown"] = 3)] = "RightDown";
Directions[(Directions["Left"] = 4)] = "Left";
Directions[(Directions["Center"] = 5)] = "Center";
Directions[(Directions["Right"] = 6)] = "Right";
Directions[(Directions["LeftUp"] = 7)] = "LeftUp";
Directions[(Directions["Up"] = 8)] = "Up";
Directions[(Directions["RightUp"] = 9)] = "RightUp";
})((Directions = Enums.Directions || (Enums.Directions = {})));
var DamagePopupTypes;
(function (DamagePopupTypes) {
DamagePopupTypes[(DamagePopupTypes["Normal"] = 0)] = "Normal";
DamagePopupTypes[(DamagePopupTypes["Miss"] = 1)] = "Miss";
DamagePopupTypes[(DamagePopupTypes["Evasion"] = 2)] = "Evasion";
DamagePopupTypes[(DamagePopupTypes["Counter"] = 3)] = "Counter";
DamagePopupTypes[(DamagePopupTypes["Reflection"] = 4)] = "Reflection";
DamagePopupTypes[(DamagePopupTypes["Substitute"] = 5)] = "Substitute";
DamagePopupTypes[(DamagePopupTypes["HpDamage"] = 16)] = "HpDamage";
DamagePopupTypes[(DamagePopupTypes["HpCriticalDamage"] = 17)] =
"HpCriticalDamage";
DamagePopupTypes[(DamagePopupTypes["HpRecover"] = 18)] = "HpRecover";
DamagePopupTypes[(DamagePopupTypes["MpDamage"] = 32)] = "MpDamage";
DamagePopupTypes[(DamagePopupTypes["MpCriticalDamage"] = 33)] =
"MpCriticalDamage";
DamagePopupTypes[(DamagePopupTypes["MpRecover"] = 34)] = "MpRecover";
DamagePopupTypes[(DamagePopupTypes["TpDamage"] = 48)] = "TpDamage";
DamagePopupTypes[(DamagePopupTypes["TpCriticalDamage"] = 49)] =
"TpCriticalDamage";
DamagePopupTypes[(DamagePopupTypes["TpRecover"] = 50)] = "TpRecover";
DamagePopupTypes[(DamagePopupTypes["AddState"] = 64)] = "AddState";
DamagePopupTypes[(DamagePopupTypes["AddPositiveState"] = 65)] =
"AddPositiveState";
DamagePopupTypes[(DamagePopupTypes["AddNegativeState"] = 66)] =
"AddNegativeState";
DamagePopupTypes[(DamagePopupTypes["RemoveState"] = 80)] =
"RemoveState";
DamagePopupTypes[(DamagePopupTypes["RemovePositiveState"] = 81)] =
"RemovePositiveState";
DamagePopupTypes[(DamagePopupTypes["RemoveNegativeState"] = 82)] =
"RemoveNegativeState";
DamagePopupTypes[(DamagePopupTypes["AddBuff"] = 96)] = "AddBuff";
DamagePopupTypes[(DamagePopupTypes["AddDebuff"] = 97)] = "AddDebuff";
DamagePopupTypes[(DamagePopupTypes["RemoveBuff"] = 112)] =
"RemoveBuff";
DamagePopupTypes[(DamagePopupTypes["RemoveDebuff"] = 113)] =
"RemoveDebuff";
DamagePopupTypes[(DamagePopupTypes["Effective"] = 256)] = "Effective";
DamagePopupTypes[(DamagePopupTypes["NotEffective"] = 257)] =
"NotEffective";
})(
(DamagePopupTypes =
Enums.DamagePopupTypes || (Enums.DamagePopupTypes = {}))
);
var ConditionalBattlerGraphicKind;
(function (ConditionalBattlerGraphicKind) {
ConditionalBattlerGraphicKind[
(ConditionalBattlerGraphicKind["state"] = 128)
] = "state";
ConditionalBattlerGraphicKind[
(ConditionalBattlerGraphicKind["crisis"] = 256)
] = "crisis";
ConditionalBattlerGraphicKind[
(ConditionalBattlerGraphicKind["command"] = 512)
] = "command";
ConditionalBattlerGraphicKind[
(ConditionalBattlerGraphicKind["ready"] = 513)
] = "ready";
ConditionalBattlerGraphicKind[
(ConditionalBattlerGraphicKind["guard"] = 514)
] = "guard";
ConditionalBattlerGraphicKind[
(ConditionalBattlerGraphicKind["chanting"] = 515)
] = "chanting";
ConditionalBattlerGraphicKind[
(ConditionalBattlerGraphicKind["skill"] = 1024)
] = "skill";
ConditionalBattlerGraphicKind[
(ConditionalBattlerGraphicKind["item"] = 1025)
] = "item";
ConditionalBattlerGraphicKind[
(ConditionalBattlerGraphicKind["damage"] = 2048)
] = "damage";
ConditionalBattlerGraphicKind[
(ConditionalBattlerGraphicKind["victory"] = 2049)
] = "victory";
ConditionalBattlerGraphicKind[
(ConditionalBattlerGraphicKind["dead"] = 4096)
] = "dead";
})(
(ConditionalBattlerGraphicKind =
Enums.ConditionalBattlerGraphicKind ||
(Enums.ConditionalBattlerGraphicKind = {}))
);
var Languages;
(function (Languages) {
Languages[(Languages["English"] = 0)] = "English";
Languages[(Languages["Japanese"] = 1)] = "Japanese";
})((Languages = Enums.Languages || (Enums.Languages = {})));
})((Enums = Consts.Enums || (Consts.Enums = {})));
})((Consts = Core.Consts || (Core.Consts = {})));
})((Core = BD.Core || (BD.Core = {})));
})(BD || (BD = {}));
(function () {
var xpbBattleSpeed = "xpbBattleSpeed";
var _bdc_ConfigManager_applyData = ConfigManager.applyData;
ConfigManager.applyData = function (config) {
_bdc_ConfigManager_applyData.apply(this, arguments);
var cm = this;
cm.xpbBattleSpeed = cm.readXpbBattleSpeed(config, xpbBattleSpeed);
};
var _bdc_ConfigManager_makeData = ConfigManager.makeData;
ConfigManager.makeData = function () {
var config = _bdc_ConfigManager_makeData.apply(this, arguments);
config.xpbBattleSpeed = this.xpbBattleSpeed;
return config;
};
ConfigManager.readXpbBattleSpeed = function (config, name) {
var value = config[name];
if (value !== undefined) {
return Number(value).clamp(1, 3);
} else {
return 2;
}
};
ConfigManager.writeXpbBattleSpeed = function (speed) {
this.xpbBattleSpeed = speed.clamp(1, 3);
};
})();
(function () {
Game_System.prototype.xpbBasicSpeed = function () {
return this._xpbBasicSpeed;
};
Game_System.prototype.setXpbBasicSpeed = function (speed) {
this._xpbBasicSpeed = speed.clamp(4, 128);
};
Game_System.prototype.resetXpbBasicSpeed = function () {
return (this._xpbBasicSpeed = undefined);
};
})();
(function () {
var _bdc_Window_Options_changeValue = Window_Options.prototype.changeValue;
Window_Options.prototype.changeValue = function (symbol, value) {
_bdc_Window_Options_changeValue.apply(this, arguments);
if (this.isCustomSymbol && this.isCustomSymbol(symbol) && !isNaN(value)) {
var script = this._customParams[symbol].script;
if ("BD.CMD.xpbBattleSpeed" === script) {
ConfigManager.writeXpbBattleSpeed(value);
}
}
};
})();
var BD;
(function (BD) {
var Core;
(function (Core) {
var PluginParameterLoader;
(function (PluginParameterLoader) {
function overwriteWithPluginParameters(pluginName, dst) {
var params = PluginManager.parameters(pluginName);
var paramsKeys = Object.keys(params);
_enumerateSettingKeys("", dst).forEach(function (x) {
return _overwrite(dst, params, paramsKeys, x);
});
}
PluginParameterLoader.overwriteWithPluginParameters =
overwriteWithPluginParameters;
function _enumerateSettingKeys(base, object) {
if (Object.prototype.toString.call(object) !== "[object Object]") {
return [base];
}
var settingKeys = [];
var keys = Object.keys(object);
keys
.filter(function (x) {
return x !== "hudData";
})
.forEach(function (x) {
var k = _enumerateSettingKeys(x, object[x]);
k.map(function (y) {
return base + (base.length > 0 ? "." : "") + y;
}).forEach(function (y) {
return settingKeys.push(y);
});
});
return settingKeys;
}
function _overwrite(dst, params, paramsKeys, key) {
var regexp = /^\((.+)\)(.*)$/;
var paramKey = paramsKeys.find(function (x) {
var match = regexp.exec(x);
return match[2] === key;
});
if (!paramKey) {
return;
}
var match = regexp.exec(paramKey);
var value = _parseValue(match[1], params[paramKey]);
if (value === undefined) {
return;
}
var setting = dst;
var path = key.split(".");
path.slice(0, path.length - 1).forEach(function (x) {
return (setting = setting[x]);
});
setting[key.split(".").pop()] = value;
}
function _parseValue(type, value) {
if (value === "undefined" || value === "") {
return undefined;
}
switch (type.toLowerCase()) {
case "integer":
var int = parseInt(value, 10);
if (isNaN(int)) {
return undefined;
}
return int;
case "float":
var float = parseFloat(value);
if (isNaN(float)) {
return undefined;
}
return float;
case "string":
return value;
case "boolean":
if (value.toLowerCase() === "true") {
return true;
} else if (value.toLowerCase() === "false") {
return false;
}
return undefined;
default:
return undefined;
}
}
})(
(PluginParameterLoader =
Core.PluginParameterLoader || (Core.PluginParameterLoader = {}))
);
})((Core = BD.Core || (BD.Core = {})));
})(BD || (BD = {}));
var $BDHUD;
var BD;
(function (BD) {
var Core;
(function (Core) {
var Settings;
(function (Settings) {
var _defaultColors = [
{ bodyColor: "rgba(255,255,255,1.0)", outlineColor: "rgba(0,0,0,1.0)" },
{
bodyColor: "rgba(160,250,108,1.0)",
outlineColor: "rgba(0,72,32,1.0)",
},
{ bodyColor: "rgba(192,96,232,1.0)", outlineColor: "rgba(0,0,0,1.0)" },
{
bodyColor: "rgba(172,232,250,1.0)",
outlineColor: "rgba(40,64,168,1.0)",
},
{
bodyColor: "rgba(224,224,72,1.0)",
outlineColor: "rgba(0,80,80,1.0)",
},
{
bodyColor: "rgba(224,224,72,1.0)",
outlineColor: "rgba(0,80,80,1.0)",
},
{
bodyColor: "rgba(255,255,255,1.0)",
outlineColor: "rgba(48,92,224,1.0)",
},
{
bodyColor: "rgba(220,214,208,1.0)",
outlineColor: "rgba(64,64,64,1.0)",
},
{
bodyColor: "rgba(248,242,96,1.0)",
outlineColor: "rgba(200,28,32,1.0)",
},
{
bodyColor: "rgba(224,224,224,1.0)",
outlineColor: "rgba(64,64,64,0.5)",
},
{
bodyColor: "rgba(255,255,255,1.0)",
outlineColor: "rgba(144,108,16,1.0)",
},
{
bodyColor: "rgba(255,255,255,1.0)",
outlineColor: "rgba(48,116,132,1.0)",
},
{
bodyColor: "rgba(255,255,255,1.0)",
outlineColor: "rgba(136,64,120,1.0)",
},
];
var _defaultColorAlloc = {
17: 8,
18: 1,
32: 2,
33: 2,
34: 3,
48: 4,
49: 4,
50: 5,
66: 7,
97: 7,
256: 6,
257: 7,
80: 9,
81: 9,
82: 9,
112: 9,
113: 9,
3: 10,
4: 11,
5: 12,
};
var _defaultPopupSettings = {
fileName: "",
numberSize: 32,
numberHeight: 28,
numberSpacing: 0.75,
textSize: 24,
textFont: "Arial Black, Avenir-Black, sans-serif-black, GameFont",
textHeight: 28,
colors: _defaultColors,
pattern: _defaultColors.length,
colorAlloc: _defaultColorAlloc,
texts: {
counter: "COUNTER",
reflection: "REFLECTION",
substitute: "SUBSTITUTE",
miss: "MISS",
evasion: "MISS",
critical: "CRITICAL",
weakness: "WEAKNESS",
resist: "RESIST",
plus: "+",
minus: "-",
},
types: {
addState: "Rise",
removeState: "Rise",
addBuff: "Rise",
addDebuff: "Rise",
removeBuff: "Rise",
tpCharge: "Overlay",
regenerate: "SimpleBounce",
miss: "SimpleBounce",
hpDamage: "SimpleBounce",
mpDamage: "SimpleBounce",
tpDamage: "SimpleBounce",
counter: "Overlay",
reflection: "Overlay",
substitute: "Overlay",
},
};
var _defaultBattlerGraphic = {
rootPath: "img/battlergraphics/",
enableAnimation: true,
enablePopup: true,
damageDuration: 24,
};
var _defaultAnimation = {
playRate: 4,
forParty: {
adjustPosition: {
x: 0,
y: 0,
},
},
};
var _defaultTargetCursor = {
fileName: "selection_cursor",
width: 0,
animationSpeed: 4,
moveSpeed: 5,
adjustPositionOnActor: {
x: 0,
y: -32,
},
adjustPositionOnEnemy: {
x: 0,
y: 0,
},
minY: 96,
checkSelection: true,
};
var _defaultTargetInformation = {
gaugeWidth: 108,
scopeNotation: {
forParty: "味方全体",
forTroop: "敵全体",
forTroopRandom: "敵%1体 ランダム",
},
actor: {
states: true,
hp: true,
mp: true,
tp: true,
},
enemy: {
states: true,
hp: false,
mp: false,
tp: false,
},
};
var _defaultBattleMessage = {
enemyEmergeMessage: false,
simpleBattleLog: {
useSimpleBattleLog: true,
type: "Window",
displayAttack: false,
displayGuard: true,
drawIcon: true,
align: BD.Core.Consts.Enums.HorizontalAlignment.Center,
descriptionDelimiter: " : ",
descriptionFontSize: 0,
},
};
var _defaultWindowLayout = {
itemSkill: {
fitting: true,
maxHeight: 320,
},
actorCommand: {
absolutePosition: {
x: undefined,
y: undefined,
},
adjustPosition: {
x: 0,
y: -56,
},
width: 192,
heightFitting: true,
visibleRows: 4,
isHorizontal: false,
maxCols: 1,
itemAlign: "left",
},
partyCommand: {
position: {
x: 0,
y: 0,
},
width: undefined,
heightFitting: false,
visibleRows: 1,
isHorizontal: true,
maxCols: 2,
itemAlign: "center",
},
};
var _defaultBattleSpeed = {
basicSpeed: 12,
animationFastForward: true,
animationDelayFastForward: true,
actorStepDuration: 6,
animationSkipDuration: 8,
skipBlinkEffect: false,
};
var _defaultMinorFixes = {
enableSelectionEffect: true,
};
var _defaultSettings = {
hudData: null,
battlerGraphic: _defaultBattlerGraphic,
popup: _defaultPopupSettings,
animation: _defaultAnimation,
targetCursor: _defaultTargetCursor,
targetInformation: _defaultTargetInformation,
battleMessage: _defaultBattleMessage,
windowLayout: _defaultWindowLayout,
battleSpeed: _defaultBattleSpeed,
minorFixes: _defaultMinorFixes,
};
var _settings;
var _hudData;
var _battlerGraphic;
var _popup;
var _animation;
var _targetCursor;
var _targetInformation;
var _battleMessage;
var _windowLayout;
var _battleSpeed;
var _minorFixes;
var _themeHud;
function loadSettingsJson() {
_settings = _defaultSettings;
_hudData = _settings.hudData;
_battlerGraphic = _settings.battlerGraphic;
_popup = _settings.popup;
_animation = _settings.animation;
_targetCursor = _settings.targetCursor;
_targetInformation = _settings.targetInformation;
_battleMessage = _settings.battleMessage;
_windowLayout = _settings.windowLayout;
_battleSpeed = _settings.battleSpeed;
_minorFixes = _settings.minorFixes;
Core.PluginParameterLoader.overwriteWithPluginParameters(
"XPStyleBattleMV",
_settings
);
}
Settings.loadSettingsJson = loadSettingsJson;
function setHud(data) {
_themeHud = data;
}
Settings.setHud = setHud;
function hud() {
if (_themeHud) {
return _themeHud;
}
if (!_hudData) {
_hudData = Core.StandardTheme.create();
}
return _hudData;
}
Settings.hud = hud;
function battlerGraphic() {
return _battlerGraphic;
}
Settings.battlerGraphic = battlerGraphic;
function animation() {
return _animation;
}
Settings.animation = animation;
function targetCursor() {
return _targetCursor;
}
Settings.targetCursor = targetCursor;
function targetInformation() {
return _targetInformation;
}
Settings.targetInformation = targetInformation;
function windowLayout() {
return _windowLayout;
}
Settings.windowLayout = windowLayout;
function battleMessage() {
return _battleMessage;
}
Settings.battleMessage = battleMessage;
function battleSpeed() {
return _battleSpeed;
}
Settings.battleSpeed = battleSpeed;
function popup() {
return _popup;
}
Settings.popup = popup;
function minorFixes() {
return _minorFixes;
}
Settings.minorFixes = minorFixes;
function basicSpeed() {
var base = $gameSystem.xpbBasicSpeed() || _battleSpeed.basicSpeed;
if ($gameSystem.xpbBasicSpeed()) {
return $gameSystem.xpbBasicSpeed();
} else if (ConfigManager.xpbBattleSpeed) {
var rate = 1.0;
switch (ConfigManager.xpbBattleSpeed) {
case 1:
rate = 0.33;
break;
case 3:
rate = 2.0;
break;
}
return Math.round(base * rate);
}
return base;
}
Settings.basicSpeed = basicSpeed;
function enableSideVidwBattler() {
return $gameSystem.isSideView();
}
Settings.enableSideVidwBattler = enableSideVidwBattler;
function isDisplayTp() {
return $dataSystem.optDisplayTp;
}
Settings.isDisplayTp = isDisplayTp;
function isSimpleBattleLog() {
return battleMessage().simpleBattleLog.useSimpleBattleLog;
}
Settings.isSimpleBattleLog = isSimpleBattleLog;
})((Settings = Core.Settings || (Core.Settings = {})));
})((Core = BD.Core || (BD.Core = {})));
})(BD || (BD = {}));
BD.Core.Settings.loadSettingsJson();
var BD;
(function (BD) {
var Core;
(function (Core) {
var StandardTheme;
(function (StandardTheme) {
var params = {
root: {
x: 0,
y: 0,
},
hudBg: {
x: 0,
y: 544,
visible: true,
fileName: "bd_standard/hud_bg",
},
general: {
x: 8,
y: 558,
width: 800,
height: 180,
horizontalAlignment: 1,
verticalAlignment: 0,
actorStatusWidth: 200,
actorStatusHeight: 166,
horizontalSpacing: 0,
verticalSpacing: 0,
orientation: 0,
maxRows: 16,
maxLines: 1,
isBricks: false,
},
bg: {
x: -4,
y: -4,
visible: true,
fileName: "bd_standard/std_bg",
},
battler: {
x: 78,
y: 150,
visible: true,
zoom: 100,
overlayOffsetX: 0,
overlayOffsetY: -8,
isOverlayOnBottom: false,
maskImage: "",
maskImageX: 0,
maskImageY: 0,
},
statusBg: {
x: 0,
y: 0,
visible: true,
fileName: "",
},
hp: {
x: 80,
y: 68,
visible: true,
bg: {
x: 0,
y: 29,
visible: true,
fileName: "bd_standard/std_gauge_bg",
},
symbol: {
x: 2,
y: 14,
visible: true,
fileName: "bd_standard/std_hp",
},
gauge: {
x: 3,
y: 31,
visible: true,
fileName: "bd_standard/std_gauge",
skewAngleX: 0,
skewAngleY: 0,
animationSpeed: 8,
},
number: {
x: 30,
y: 0,
visible: true,
fileName: "bd_standard/std_large_numbers",
digits: 4,
horizontalSpacing: -5,
zeroSuppress: true,
horizontalAlignment: 2,
animationSpeed: 8,
},
},
mp: {
x: 80,
y: 108,
visible: true,
bg: {
x: 0,
y: 29,
visible: true,
fileName: "bd_standard/std_gauge_bg",
},
symbol: {
x: 2,
y: 14,
visible: true,
fileName: "bd_standard/std_mp",
},
gauge: {
x: 3,
y: 31,
visible: true,
fileName: "bd_standard/std_gauge",
skewAngleX: 0,
skewAngleY: 0,
animationSpeed: 8,
},
number: {
x: 30,
y: 0,
visible: true,
fileName: "bd_standard/std_large_numbers",
digits: 4,
horizontalSpacing: -5,
zeroSuppress: true,
horizontalAlignment: 2,
animationSpeed: 8,
},
},
tp: {
x: 126,
y: -1,
visible: true,
bg: {
x: 0,
y: 0,
visible: true,
fileName: "bd_standard/std_tp_gauge_bg",
},
symbol: {
x: 8,
y: 20,
visible: true,
fileName: "bd_standard/std_tp",
},
gauge: {
x: 0,
y: 0,
visible: true,
fileName: "bd_standard/std_tp_gauge",
startAngle: -88,
endAngle: 272,
radius: 28,
lineWidth: 8,
animationSpeed: 8,
},
number: {
x: 12,
y: 27,
visible: true,
fileName: "bd_standard/std_small_numbers",
digits: 3,
horizontalSpacing: -5,
zeroSuppress: true,
horizontalAlignment: 1,
animationSpeed: 8,
},
},
state: {
x: 11,
y: 116,
visible: true,
bg: {
x: 0,
y: 0,
visible: true,
fileName: "",
},
symbol: {
x: 0,
y: 0,
visible: true,
fileName: "",
},
icon: {
x: 0,
y: 0,
visible: true,
stateIconSize: 32,
spacing: 0,
maxStates: 2,
animationSpeed: 50,
},
},
name: {
x: 12,
y: 9,
visible: false,
maxWidth: 122,
color: "rgba(255,255,255,1.0)",
outlineColor: "rgba(0,0,0,0.5)",
outlineWidth: 5,
fontSize: 22,
fontFace: "GameFont",
fontItalic: false,
horizontalAlignment: 0,
},
};
function root() {
var args = [];
for (var _i = 0; _i < arguments.length; _i++) {
args[_i] = arguments[_i];
}
return {
properties: {
type: "Root",
name: "Ether",
x: params.root.x,
y: params.root.y,
visible: true,
},
children: [].slice.call(args),
};
}
function actorAreaBackground() {
return {
properties: {
type: "Image",
name: "actorAreaBackground",
x: params.hudBg.x,
y: params.hudBg.y,
visible: params.hudBg.visible,
fileName: "'" + params.hudBg.fileName + "'",
},
};
}
function partyStatusContainer() {
var args = [];
for (var _i = 0; _i < arguments.length; _i++) {
args[_i] = arguments[_i];
}
return {
properties: {
type: "PartyStatusContainer",
name: "PartyBgContainer",
x: params.general.x,
y: params.general.y,
visible: true,
width: params.general.width,
height: params.general.height,
horizontalAlignment: params.general.horizontalAlignment,
verticalAlignment: params.general.verticalAlignment,
actorStatusWidth: params.general.actorStatusWidth,
actorStatusHeight: params.general.actorStatusHeight,
horizontalSpacing: params.general.horizontalSpacing,
verticalSpacing: params.general.verticalSpacing,
orientation: params.general.orientation,
maxRows: params.general.maxRows,
maxLines: params.general.maxLines,
isBricks: params.general.isBricks,
},
children: [].slice.call(args),
};
}
function background() {
return {
properties: {
type: "Image",
name: "Background",
x: params.bg.x,
y: params.bg.y,
visible: params.bg.visible,
fileName: "'" + params.bg.fileName + "'",
},
};
}
function statusBackground() {
return {
properties: {
type: "Image",
name: "StatusBackground",
x: params.statusBg.x,
y: params.statusBg.y,
visible: params.statusBg.visible,
fileName: "'" + params.statusBg.fileName + "'",
},
};
}
function battler() {
return {
properties: {
type: "Battler",
name: "Battler",
x: params.battler.x,
y: params.battler.y,
visible: params.battler.visible,
zoom: params.battler.zoom,
overlayOffsetX: params.battler.overlayOffsetX,
overlayOffsetY: params.battler.overlayOffsetY,
isOverlayOnBottom: params.battler.isOverlayOnBottom,
maskImage: "'" + params.battler.maskImage + "'",
maskImageX: params.battler.maskImageX,
maskImageY: params.battler.maskImageY,
},
};
}
function hpContainer() {
var args = [];
for (var _i = 0; _i < arguments.length; _i++) {
args[_i] = arguments[_i];
}
return {
properties: {
type: "Container",
name: "HPContainer",
x: params.hp.x,
y: params.hp.y,
visible: params.hp.visible,
},
children: [].slice.call(args),
};
}
function mpContainer() {
var args = [];
for (var _i = 0; _i < arguments.length; _i++) {
args[_i] = arguments[_i];
}
return {
properties: {
type: "Container",
name: "MPContainer",
x: params.mp.x,
y: params.mp.y,
visible: params.mp.visible,
},
children: [].slice.call(args),
};
}
function tpContainer() {
var args = [];
for (var _i = 0; _i < arguments.length; _i++) {
args[_i] = arguments[_i];
}
return {
properties: {
type: "Container",
name: "TPContainer",
x: params.tp.x,
y: params.tp.y,
visible: params.tp.visible
? "BD.Core.Settings.isDisplayTp()"
: false,
},
children: [].slice.call(args),
};
}
function stateContainer() {
var args = [];
for (var _i = 0; _i < arguments.length; _i++) {
args[_i] = arguments[_i];
}
return {
properties: {
type: "Container",
name: "StateContainer",
x: params.state.x,
y: params.state.y,
visible: params.state.visible,
},
children: [].slice.call(args),
};
}
function hpBackground() {
return {
properties: {
type: "Image",
name: "HPBackground",
x: params.hp.bg.x,
y: params.hp.bg.y,
visible: params.hp.bg.visible,
fileName: "'" + params.hp.bg.fileName + "'",
},
};
}
function hpSymbol() {
return {
properties: {
type: "Image",
name: "HPSymbol",
x: params.hp.symbol.x,
y: params.hp.symbol.y,
visible: params.hp.symbol.visible,
fileName: "'" + params.hp.symbol.fileName + "'",
},
};
}
function hpGauge() {
return {
properties: {
type: "HorizontalGauge",
name: "HPGauge",
x: params.hp.gauge.x,
y: params.hp.gauge.y,
visible: params.hp.gauge.visible,
fileName: "'" + params.hp.gauge.fileName + "'",
skewAngleX: params.hp.gauge.skewAngleX,
skewAngleY: params.hp.gauge.skewAngleY,
value: "this.b.hp",
maxValue: "this.b.hudMhp()",
pattern: 0,
maxPattern: 2,
animationSpeed: params.hp.gauge.animationSpeed,
},
};
}
function hpNumber() {
return {
properties: {
type: "Number",
name: "HPNumber",
x: params.hp.number.x,
y: params.hp.number.y,
visible: params.hp.number.visible,
fileName: "'" + params.hp.number.fileName + "'",
value: "this.b.hp",
pattern: "this.b.hudHpNumberPattern()",
maxPattern: 3,
digits: params.hp.number.digits,
horizontalSpacing: params.hp.number.horizontalSpacing,
zeroSuppress: params.hp.number.zeroSuppress,
horizontalAlignment: params.hp.number.horizontalAlignment,
animationSpeed: params.hp.number.animationSpeed,
},
};
}
function mpBackground() {
return {
properties: {
type: "Image",
name: "MPBackground",
x: params.mp.bg.x,
y: params.mp.bg.y,
visible: params.mp.bg.visible,
fileName: "'" + params.mp.bg.fileName + "'",
},
};
}
function mpSymbol() {
return {
properties: {
type: "Image",
name: "MPSymbol",
x: params.mp.symbol.x,
y: params.mp.symbol.y,
visible: params.mp.symbol.visible,
fileName: "'" + params.mp.symbol.fileName + "'",
},
};
}
function mpGauge() {
return {
properties: {
type: "HorizontalGauge",
name: "MPGauge",
x: params.mp.gauge.x,
y: params.mp.gauge.y,
visible: params.mp.gauge.visible,
fileName: "'" + params.mp.gauge.fileName + "'",
skewAngleX: params.mp.gauge.skewAngleX,
skewAngleY: params.mp.gauge.skewAngleY,
value: "this.b.mp",
maxValue: "this.b.hudMmp()",
pattern: 1,
maxPattern: 2,
animationSpeed: params.mp.gauge.animationSpeed,
},
};
}
function mpNumber() {
return {
properties: {
type: "Number",
name: "MPNumber",
x: params.mp.number.x,
y: params.mp.number.y,
visible: params.mp.number.visible,
fileName: "'" + params.mp.number.fileName + "'",
value: "this.b.mp",
pattern: 0,
maxPattern: 3,
digits: params.mp.number.digits,
horizontalSpacing: params.mp.number.horizontalSpacing,
zeroSuppress: params.mp.number.zeroSuppress,
horizontalAlignment: params.mp.number.horizontalAlignment,
animationSpeed: params.mp.number.animationSpeed,
},
};
}
function tpBackground() {
return {
properties: {
type: "Image",
name: "TPBackground",
x: params.tp.bg.x,
y: params.tp.bg.y,
visible: params.tp.bg.visible,
fileName: "'" + params.tp.bg.fileName + "'",
},
};
}
function tpSymbol() {
return {
properties: {
type: "Image",
name: "TPSymbol",
x: params.tp.symbol.x,
y: params.tp.symbol.y,
visible: params.tp.symbol.visible,
fileName: "'" + params.tp.symbol.fileName + "'",
},
};
}
function tpGauge() {
return {
properties: {
type: "CircleGauge",
name: "TPGauge",
x: params.tp.gauge.x,
y: params.tp.gauge.y,
visible: params.tp.gauge.visible,
fileName: "'" + params.tp.gauge.fileName + "'",
value: "this.b.tp",
maxValue: "this.b.maxTp()",
startAngle: params.tp.gauge.startAngle,
endAngle: params.tp.gauge.endAngle,
radius: params.tp.gauge.radius,
lineWidth: params.tp.gauge.lineWidth,
animationSpeed: params.tp.gauge.animationSpeed,
},
};
}
function tpNumber() {
return {
properties: {
type: "Number",
name: "TPNumber",
x: params.tp.number.x,
y: params.tp.number.y,
visible: params.tp.number.visible,
fileName: "'" + params.tp.number.fileName + "'",
value: "this.b.tp",
pattern: 0,
maxPattern: 3,
digits: params.tp.number.digits,
horizontalSpacing: params.tp.number.horizontalSpacing,
zeroSuppress: params.tp.number.zeroSuppress,
horizontalAlignment: params.tp.number.horizontalAlignment,
animationSpeed: params.tp.number.animationSpeed,
},
};
}
function stateBackground() {
return {
properties: {
type: "Image",
name: "StateBackground",
x: params.state.bg.x,
y: params.state.bg.y,
visible: params.state.bg.visible,
fileName: "'" + params.state.bg.fileName + "'",
},
};
}
function stateIcon() {
return {
properties: {
type: "StateIcon",
name: "StateIcon",
x: params.state.icon.x,
y: params.state.icon.y,
visible: params.state.icon.visible,
stateIconSize: params.state.icon.stateIconSize,
spacing: params.state.icon.spacing,
maxStates: params.state.icon.maxStates,
animationSpeed: params.state.icon.animationSpeed,
relatedObjects: "'StateBackground,StateSymbol'",
},
};
}
function stateSymbol() {
return {
properties: {
type: "Image",
name: "StateSymbol",
x: params.state.symbol.x,
y: params.state.symbol.y,
visible: params.state.symbol.visible,
fileName: "'" + params.state.symbol.fileName + "'",
},
};
}
function actorName() {
return {
properties: {
type: "Text",
name: "ActorName",
x: params.name.x,
y: params.name.y,
visible: params.name.visible,
text: "this.b.name()",
maxWidth: params.name.maxWidth,
color: "'" + params.name.color + "'",
outlineColor: "'" + params.name.outlineColor + "'",
outlineWidth: params.name.outlineWidth,
fontSize: params.name.fontSize,
fontFace: "'" + params.name.fontFace + "'",
fontItalic: params.name.fontItalic,
horizontalAlignment: params.name.horizontalAlignment,
},
};
}
function overwrite() {
BD.Core.PluginParameterLoader.overwriteWithPluginParameters(
"XPB-StandardTheme",
params
);
}
StandardTheme.overwrite = overwrite;
function create() {
return root(
actorAreaBackground(),
partyStatusContainer(background()),
partyStatusContainer(battler()),
partyStatusContainer(
statusBackground(),
hpContainer(hpBackground(), hpGauge(), hpSymbol(), hpNumber()),
mpContainer(mpBackground(), mpGauge(), mpSymbol(), mpNumber()),
tpContainer(tpBackground(), tpGauge(), tpSymbol(), tpNumber()),
stateContainer(stateBackground(), stateIcon(), stateSymbol()),
actorName()
)
);
}
StandardTheme.create = create;
})((StandardTheme = Core.StandardTheme || (Core.StandardTheme = {})));
})((Core = BD.Core || (BD.Core = {})));
})(BD || (BD = {}));
var BD;
(function (BD) {
var Core;
(function (Core) {
var Manager;
(function (Manager) {
var modes = BD.Core.Consts.Enums.Mode;
var _mode = BD.Core.Consts.Enums.Mode.Game;
function getMode() {
return _mode;
}
Manager.getMode = getMode;
function setMode(value) {
_mode = value;
}
Manager.setMode = setMode;
function isGameMode() {
return getMode() === modes.Game;
}
Manager.isGameMode = isGameMode;
function isPreviewMode() {
return getMode() === modes.Preview;
}
Manager.isPreviewMode = isPreviewMode;
function isStudioMode() {
return getMode() === modes.Studio;
}
Manager.isStudioMode = isStudioMode;
function setup() {
switch (getMode()) {
case modes.Game:
break;
case modes.Preview:
setupPreview();
break;
case modes.Studio:
break;
}
}
Manager.setup = setup;
function setupPreview() {
Graphics._defaultStretchMode = function () {
return true;
};
}
Manager.setupPreview = setupPreview;
function isStopHUD() {
return BattleManager.isBattleEndFadeOut();
}
Manager.isStopHUD = isStopHUD;
})((Manager = Core.Manager || (Core.Manager = {})));
})((Core = BD.Core || (BD.Core = {})));
})(BD || (BD = {}));
try {
if ($bdStudio !== undefined) {
BD.Core.Manager.setMode(BD.Core.Consts.Enums.Mode.Studio);
}
} catch (e) {
if (Utils.isOptionValid("bdpreview")) {
BD.Core.Manager.setMode(BD.Core.Consts.Enums.Mode.Preview);
} else {
BD.Core.Manager.setMode(BD.Core.Consts.Enums.Mode.Game);
}
}
BD.Core.Manager.setup();
var BD;
(function (BD) {
var Core;
(function (Core) {
var Utils;
(function (Utils) {
var BattlerGraphicManager;
(function (BattlerGraphicManager) {
var Settings = Core.Settings.battlerGraphic;
var Kind = BD.Core.Consts.Enums.ConditionalBattlerGraphicKind;
var _checkConditionFuncs;
function battlerGraphic(battler) {
if (battler instanceof Game_Actor) {
return _actorBattlerGraphic(battler);
} else if (battler instanceof Game_Enemy) {
return _enemyBattlerGraphic(battler);
}
return {
bitmap: ImageManager.loadEmptyBitmap(),
faceIndex: -1,
height: 48,
};
}
BattlerGraphicManager.battlerGraphic = battlerGraphic;
function areEqualBattlerGraphic(a, b) {
if (!a && !b) {
return true;
}
if (!a || !b) {
return false;
}
if (a.fileName !== b.fileName) {
return false;
}
if (a.faceIndex !== b.faceIndex) {
return false;
}
return true;
}
BattlerGraphicManager.areEqualBattlerGraphic = areEqualBattlerGraphic;
function createConditionalBattlerGraphic(
fileNameWithFaceIndex,
kind,
idOrTag,
priority
) {
var bg = createBattlerGraphic(fileNameWithFaceIndex);
var conditionKind = defaultPriority(kind);
if (conditionKind === null) {
return;
}
var prio = priority || conditionKind;
return {
condition: {
kind: conditionKind,
idOrTag: idOrTag,
priority: prio,
},
battlerGraphic: bg,
};
}
BattlerGraphicManager.createConditionalBattlerGraphic =
createConditionalBattlerGraphic;
function createBattlerGraphic(fileNameWithFaceIndex) {
if (!fileNameWithFaceIndex) {
return {
fileName: null,
faceIndex: -1,
};
}
var re = /([^\[\]]*)(?:\[(\d+)\]$)?/g;
var match = re.exec(fileNameWithFaceIndex);
var name = match[1] || fileNameWithFaceIndex;
var m2 = match[2] || "";
var i = parseInt(m2);
var faceIndex = isNaN(i) ? -1 : i;
return {
fileName: name,
faceIndex: faceIndex,
};
}
BattlerGraphicManager.createBattlerGraphic = createBattlerGraphic;
function defaultPriority(kind) {
var conditionKind = Kind[kind.toLowerCase()];
if (conditionKind === undefined) {
return null;
}
return conditionKind;
}
BattlerGraphicManager.defaultPriority = defaultPriority;
function determineCandidate(actor) {
var candidates = [];
actor.conditionalBattlerGraphics().forEach(function (x) {
var func = _getCheckConditionFuncs()[x.condition.kind];
if (func && func(actor, x)) {
candidates.push(x);
}
});
if (candidates.length === 0) {
return null;
} else {
return candidates.reduce(function (a, b) {
return a.condition.priority > b.condition.priority ? a : b;
});
}
}
BattlerGraphicManager.determineCandidate = determineCandidate;
function damageDuration() {
return Settings().damageDuration;
}
BattlerGraphicManager.damageDuration = damageDuration;
function _actorBattlerGraphic(actor) {
var battlerGraphic = actor.battlerGraphics();
if (battlerGraphic.fileName !== null) {
var fileName = _generateFileName(actor, battlerGraphic.fileName);
if (battlerGraphic.faceIndex > -1) {
return {
bitmap: ImageManager.loadFace(fileName, 0),
faceIndex: battlerGraphic.faceIndex,
height: 144,
};
} else {
var bitmap = ImageManager.loadBitmap(
Settings().rootPath,
fileName,
0,
false
);
return {
bitmap: bitmap,
faceIndex: -1,
height: bitmap.height,
};
}
} else {
return {
bitmap: ImageManager.loadFace(actor.faceName(), 0),
faceIndex: actor.faceIndex(),
height: 144,
};
}
}
function _generateFileName(actor, fileName) {
if (!fileName.contains("*")) {
return fileName;
}
var base = actor.baseBattlerGraphics();
if (base && base.fileName !== null) {
return fileName.replace("*", base.fileName);
} else {
return fileName.replace("*", actor.faceName());
}
}
function _enemyBattlerGraphic(battler) {
var bitmap;
if ($gameSystem.isSideView()) {
bitmap = ImageManager.loadSvEnemy(
battler.battlerName(),
battler.battlerHue()
);
} else {
bitmap = ImageManager.loadEnemy(
battler.battlerName(),
battler.battlerHue()
);
}
return {
bitmap: bitmap,
faceIndex: null,
height: bitmap.height,
};
}
function _getCheckConditionFuncs() {
if (!_checkConditionFuncs) {
_checkConditionFuncs = {};
_checkConditionFuncs[Kind.state] = _checkStateCondition;
_checkConditionFuncs[Kind.crisis] = _checkCrisisCondition;
_checkConditionFuncs[Kind.command] = _checkCommandCondition;
_checkConditionFuncs[Kind.ready] = _checkReadyCondition;
_checkConditionFuncs[Kind.guard] = _checkGuardCondition;
_checkConditionFuncs[Kind.chanting] = _checkChantingCondition;
_checkConditionFuncs[Kind.skill] = _checkSkillCondition;
_checkConditionFuncs[Kind.item] = _checkItemCondition;
_checkConditionFuncs[Kind.damage] = _checkDamageCondition;
_checkConditionFuncs[Kind.victory] = _checkVictoryCondition;
_checkConditionFuncs[Kind.dead] = _checkDeadCondition;
}
return _checkConditionFuncs;
}
function _checkStateCondition(a, c) {
var idOrTag = c.condition.idOrTag;
if (typeof idOrTag === "string") {
var f = a.states().find(function (y) {
return y.meta[idOrTag];
});
if (f) {
return true;
}
} else if (
a._states.contains(idOrTag) ||
(a._states.length > 0 && idOrTag === 0)
) {
return true;
}
return false;
}
function _checkCrisisCondition(a, c) {
return a.isDying();
}
function _checkCommandCondition(a, c) {
return a.isInputting();
}
function _checkReadyCondition(a, c) {
var action = a.inputtingAction();
if (action && typeof c.condition.idOrTag === "string") {
return a.isWaiting() && action.item().meta[c.condition.idOrTag];
}
return a.isWaiting();
}
function _checkGuardCondition(a, c) {
return a.isGuardWaiting() || a.isGuard() || a._motionType === "guard";
}
function _checkChantingCondition(a, c) {
return a.isChanting();
}
function _checkActionConditionCore(a, c, kindCheck) {
var action = BattleManager._action;
if (
a._motionType !== "victory" &&
BattleManager._subject === a &&
action &&
kindCheck(action)
) {
var idOrTag = c.condition.idOrTag;
if (typeof idOrTag === "string") {
if (action.item().meta[idOrTag]) {
return true;
}
} else if (action.item().id === idOrTag || idOrTag <= 0) {
return true;
}
}
return false;
}
function _checkSkillCondition(a, c) {
return _checkActionConditionCore(a, c, function (x) {
return x.isSkill();
});
}
function _checkItemCondition(a, c) {
return _checkActionConditionCore(a, c, function (x) {
return x.isItem();
});
}
function _checkDamageCondition(a, c) {
return a._motionType === "damage";
}
function _checkVictoryCondition(a, c) {
return a._motionType === "victory";
}
function _checkDeadCondition(a, c) {
if (
Core.Settings.enableSideVidwBattler() &&
a._motionType !== "damage" &&
a.isDead()
) {
return true;
} else if (a.isDead()) {
a.clearMotion();
return true;
}
return false;
}
})(
(BattlerGraphicManager =
Utils.BattlerGraphicManager || (Utils.BattlerGraphicManager = {}))
);
})((Utils = Core.Utils || (Core.Utils = {})));
})((Core = BD.Core || (BD.Core = {})));
})(BD || (BD = {}));
var BD;
(function (BD) {
var Core;
(function (Core) {
var Utils;
(function (Utils) {
var Interpolator;
(function (Interpolator) {
function smooth(target, current, speed, minSpeed) {
if (target === current) {
return target;
}
var d = (target - current) / (speed * 1.0);
if (0 < d && d < minSpeed) {
d = minSpeed;
var newValue = current + d;
if (target < newValue) {
return target;
} else {
return newValue;
}
}
if (0 > d && d > -minSpeed) {
d = -minSpeed;
var newValue = current + d;
if (target > newValue) {
return target;
} else {
return newValue;
}
}
return current + d;
}
Interpolator.smooth = smooth;
})((Interpolator = Utils.Interpolator || (Utils.Interpolator = {})));
})((Utils = Core.Utils || (Core.Utils = {})));
})((Core = BD.Core || (BD.Core = {})));
})(BD || (BD = {}));
(function () {
ImageManager.loadThemeImage = function (filename, smooth) {
if (smooth === void 0) {
smooth = false;
}
if (!filename) {
return this.loadEmptyBitmap();
}
var f = filename.split("/");
var name = f.pop();
var path = "";
if (f.length > 0) {
path =
f.reduce(function (a, b) {
return encodeURIComponent(a) + "/" + encodeURIComponent(b);
}) + "/";
}
return this.loadBitmap("img/system/" + path, name, 0, smooth);
};
})();
var BD;
(function (BD) {
var Core;
(function (Core) {
var RPGExtension;
(function (RPGExtension) {
function getActionDescription(action) {
return _getString(action, "Tip", "");
}
RPGExtension.getActionDescription = getActionDescription;
function getAttackAnimationId(battler) {
return _getInt(battler, "AttackAnimation", 1);
}
RPGExtension.getAttackAnimationId = getAttackAnimationId;
function getBattlerGraphic(battler) {
return _getString(battler, "Graphic", null);
}
RPGExtension.getBattlerGraphic = getBattlerGraphic;
function getConditionalBattlerGraphicsRaw(battler) {
var strings = _getMultiMetadata(battler, "GraphicWhen");
return strings.map(function (x) {
var args = x.split(",").map(function (y) {
return y.trim();
});
var idOrTagArg = args[2] || "0";
var int = parseInt(idOrTagArg);
return {
fileName: args[0] || "",
kind: args[1] || "",
idOrTag: isNaN(int) ? idOrTagArg : int,
priority: parseInt(args[3]) || undefined,
};
});
}
RPGExtension.getConditionalBattlerGraphicsRaw =
getConditionalBattlerGraphicsRaw;
function getPreAnimationId(item) {
return _getInt(item, "PreAnimation", 0);
}
RPGExtension.getPreAnimationId = getPreAnimationId;
function getStateAnimationId(state) {
return _getInt(state, "Animation", 0);
}
RPGExtension.getStateAnimationId = getStateAnimationId;
function getDisplayNameForPopup(state) {
return _getString(state, "DisplayNameForPopup", state.name);
}
RPGExtension.getDisplayNameForPopup = getDisplayNameForPopup;
function getPositive(state) {
return state.meta["Positive"] === true;
}
RPGExtension.getPositive = getPositive;
function getNegative(state) {
return state.meta["Negative"] === true;
}
RPGExtension.getNegative = getNegative;
function getHideAddPopup(state) {
return state.meta["HideAddPopup"] === true || getHidePopup(state);
}
RPGExtension.getHideAddPopup = getHideAddPopup;
function getHideRemovePopup(state) {
return state.meta["HideRemovePopup"] === true || getHidePopup(state);
}
RPGExtension.getHideRemovePopup = getHideRemovePopup;
function getHidePopup(state) {
return state.meta["HidePopup"] === true;
}
RPGExtension.getHidePopup = getHidePopup;
function getAnimationRate(animation) {
_setAnimationMetadata(animation);
var defaultRate = Core.Settings.animation().playRate;
return _getInt(animation, "Rate", defaultRate);
}
RPGExtension.getAnimationRate = getAnimationRate;
function _getInt(data, key, defaultValue) {
if (data.meta[key] === undefined) {
data.meta[key] = defaultValue.toString();
}
var result = parseInt(data.meta[key]);
if (isNaN(result)) {
data.meta[key] = defaultValue.toString();
result = parseInt(data.meta[key]);
}
return result;
}
function _getString(data, key, defaultValue) {
if (data.meta[key] === undefined || data.meta[key] === true) {
data.meta[key] = defaultValue;
}
if (typeof data.meta[key] === "string") {
return data.meta[key].trim();
}
return data.meta[key];
}
function _getMultiMetadata(data, keyPattern) {
var strings = [];
var re = new RegExp("<(" + keyPattern + ")(:?)([^>]*)>", "g");
while (true) {
var match = re.exec(data.note);
if (match && match[2] === ":") {
strings.push(match[3]);
} else {
break;
}
}
return strings;
}
function _setAnimationMetadata(data) {
if (data.meta !== undefined) {
return;
}
data.note = "";
data.meta = {};
var re = /<(\d+)>/;
var match = re.exec(data.name);
if (!match) {
return;
}
data.meta["Rate"] = match[1];
}
})((RPGExtension = Core.RPGExtension || (Core.RPGExtension = {})));
})((Core = BD.Core || (BD.Core = {})));
})(BD || (BD = {}));
(function () {
Sprite.prototype.flatten = function () {
var sprites = [];
sprites.push(this);
this.children.forEach(function (element, index, array) {
sprites = sprites.concat(element.flatten ? element.flatten() : []);
});
return sprites;
};
Sprite.prototype.clone = function () {
var clone = new Sprite();
clone.bitmap = this.bitmap;
clone.opacity = this.opacity;
clone.visible = this.visible;
clone.x = this.x;
clone.y = this.y;
clone.scale.x = this.scale.x;
clone.scale.y = this.scale.y;
clone.rotation = this.rotation;
clone.blendMode = this.blendMode;
clone.filters = this.filters;
clone.anchor.x = this.anchor.x;
clone.anchor.y = this.anchor.y;
clone.pivot.x = this.pivot.x;
clone.pivot.y = this.pivot.y;
clone.texture.frame = this.texture.frame;
this.children.forEach(function (x) {
return clone.addChild(x.clone());
});
return clone;
};
Sprite.prototype.absolutePosition = function () {
var x = this.x;
var y = this.y;
var parent = this.parent;
while (parent) {
x += parent.x;
y += parent.y;
parent = parent.parent;
}
return new Point(x, y);
};
Sprite.prototype.findFamily = function (func, breakFunc) {
if (breakFunc === void 0) {
breakFunc = null;
}
var top = this;
while (top.parent && top.parent instanceof Sprite) {
top = top.parent;
if (breakFunc && breakFunc(top)) {
break;
}
}
return top.flatten().find(function (x) {
return func(x);
});
};
})();
(function () {
DataManager._removeTestPrefix = function (src) {
return src.lastIndexOf("Test_") === 0 ? src.replace("Test_", "") : src;
};
var _bdc_DataManager_loadDataFile = DataManager.loadDataFile;
DataManager.loadDataFile = function (name, src) {
var newSrc = src;
if (!BD.Core.Manager.isGameMode()) {
newSrc = DataManager._removeTestPrefix(src);
}
_bdc_DataManager_loadDataFile.call(this, name, newSrc);
};
})();
var BD;
(function (BD) {
var Core;
(function (Core) {
var Utils;
(function (Utils) {
var PluginCommand;
(function (PluginCommand) {
function execute(command, args) {
var lowCommand = command.toLowerCase();
var key = Object.keys(BD.Core.Utils.PluginCommand).find(function (x) {
return x === lowCommand;
});
if (!key) {
return;
}
var func = BD.Core.Utils.PluginCommand[key];
if (func) {
func.call(null, args);
}
}
PluginCommand.execute = execute;
function hud(args) {
if (args.length < 1) {
return;
}
if (args[0].toLowerCase() === "hide") {
$gameTemp.hideBDHUD();
} else if (args[0].toLowerCase() === "show") {
$gameTemp.showBDHUD();
}
}
PluginCommand.hud = hud;
})((PluginCommand = Utils.PluginCommand || (Utils.PluginCommand = {})));
})((Utils = Core.Utils || (Core.Utils = {})));
})((Core = BD.Core || (BD.Core = {})));
})(BD || (BD = {}));
(function () {
var _bdc_Game_Interpreter_pluginCommand =
Game_Interpreter.prototype.pluginCommand;
Game_Interpreter.prototype.pluginCommand = function (command, args) {
_bdc_Game_Interpreter_pluginCommand.call(this, command, args);
if (command === "BD" && args.length > 0) {
var a = args.clone();
BD.Core.Utils.PluginCommand.execute(a.shift(), a);
}
};
})();
var BD;
(function (BD) {
var CMD;
(function (CMD) {
var BattlerGraphicManager = BD.Core.Utils.BattlerGraphicManager;
function xpbBattleSpeed() {}
CMD.xpbBattleSpeed = xpbBattleSpeed;
function setBasicSpeed(speed) {
$gameSystem.setXpbBasicSpeed(speed);
}
CMD.setBasicSpeed = setBasicSpeed;
function resetBasicSpeed() {
$gameSystem.resetXpbBasicSpeed();
}
CMD.resetBasicSpeed = resetBasicSpeed;
function getBattleSpeed() {
return 0;
}
CMD.getBattleSpeed = getBattleSpeed;
function setBG(type, idOrIndex, fileNameWithFaceIndex) {
if (fileNameWithFaceIndex === void 0) {
fileNameWithFaceIndex = null;
}
setBattlerGraphic(type, idOrIndex, fileNameWithFaceIndex);
}
CMD.setBG = setBG;
function setBattlerGraphic(type, idOrIndex, fileNameWithFaceIndex) {
if (fileNameWithFaceIndex === void 0) {
fileNameWithFaceIndex = null;
}
var actor = _getActor(type, idOrIndex);
if (!actor) {
return;
}
var bg = BattlerGraphicManager.createBattlerGraphic(
fileNameWithFaceIndex
);
actor.setBattlerGraphics(bg.fileName, bg.faceIndex);
}
CMD.setBattlerGraphic = setBattlerGraphic;
function setCBG(
type,
idOrIndex,
fileNameWithFaceIndex,
kind,
idOrTag,
priority
) {
setConditionBattlerGraphic(
type,
idOrIndex,
fileNameWithFaceIndex,
kind,
idOrTag,
priority
);
}
CMD.setCBG = setCBG;
function setConditionBattlerGraphic(
type,
idOrIndex,
fileNameWithFaceIndex,
kind,
idOrTag,
priority
) {
var actor = _getActor(type, idOrIndex);
if (!actor) {
return;
}
var bg = BattlerGraphicManager.createBattlerGraphic(
fileNameWithFaceIndex
);
var conditionKind = BattlerGraphicManager.defaultPriority(kind);
if (conditionKind === null) {
return;
}
var prio = priority || conditionKind;
actor.setConditionalBattlerGraphics(
bg.fileName,
bg.faceIndex,
kind,
idOrTag,
prio
);
}
CMD.setConditionBattlerGraphic = setConditionBattlerGraphic;
function removeCBG(type, idOrIndex, kind, idOrTag) {
removeConditionBattlerGraphic(type, idOrIndex, kind, idOrTag);
}
CMD.removeCBG = removeCBG;
function removeConditionBattlerGraphic(type, idOrIndex, kind, idOrTag) {
var actor = _getActor(type, idOrIndex);
if (!actor) {
return;
}
actor.removeConditionalBattlerGraphics(kind, idOrTag);
}
CMD.removeConditionBattlerGraphic = removeConditionBattlerGraphic;
function resetBG(type, idOrIndex) {
if (idOrIndex === void 0) {
idOrIndex = null;
}
resetBattlerGraphic(type, idOrIndex);
}
CMD.resetBG = resetBG;
function resetBattlerGraphic(type, idOrIndex) {
if (idOrIndex === void 0) {
idOrIndex = null;
}
var actor = _getActor(type, idOrIndex);
if (!actor) {
var actors = $gameActors._data;
actors.forEach(function (x) {
return x.resetBattlerGraphic();
});
return;
}
actor.resetBattlerGraphic();
}
CMD.resetBattlerGraphic = resetBattlerGraphic;
function _getActor(type, idOrIndex) {
if (idOrIndex === null) {
return null;
}
var t = type.toLowerCase();
switch (t) {
case "id":
return $gameActors.actor(idOrIndex);
case "index":
return $gameParty.members()[idOrIndex];
}
return null;
}
})((CMD = BD.CMD || (BD.CMD = {})));
})(BD || (BD = {}));
var BD;
(function (BD) {
var Core;
(function (Core) {
var Utils;
(function (Utils) {
function sortTroopByX(enemies, reverse) {
if (reverse === void 0) {
reverse = false;
}
if (!reverse) {
return enemies.sort(function (a, b) {
return a.screenX() - b.screenX();
});
} else {
return enemies.sort(function (a, b) {
return b.screenX() - a.screenX();
});
}
}
Utils.sortTroopByX = sortTroopByX;
})((Utils = Core.Utils || (Core.Utils = {})));
})((Core = BD.Core || (BD.Core = {})));
})(BD || (BD = {}));
var BD;
(function (BD) {
var Core;
(function (Core) {
var Property;
(function (Property) {
var PropertyChanged = (function () {
function PropertyChanged() {
this._eventTable = {};
this._eventQueue = [];
}
PropertyChanged.prototype.addPropertyChanged = function (
type,
listener,
thisArg
) {
this._checkType(type);
var listeners = this._eventTable[type];
var index = listeners.indexOf(listener);
if (index === -1) {
listeners.push({
callback: listener,
this: thisArg,
});
}
};
PropertyChanged.prototype.raise = function (type) {
var listeners = this._eventTable[type];
Array.prototype.push.apply(this._eventQueue, listeners);
};
PropertyChanged.prototype.update = function () {
var _this = this;
var executedCallbacks = new Array();
var queue = this._eventQueue.concat();
this._eventQueue = new Array();
queue.forEach(function (listener) {
if (_this.containsCallback(executedCallbacks, listener.callback)) {
return;
}
listener.callback.call(listener.this);
executedCallbacks.push(listener.callback);
});
};
PropertyChanged.prototype.containsCallback = function (
callbacks,
callback
) {
var len = callbacks.length;
for (var i = 0; i <= len; i++) {
if (callbacks[i] === callback) {
return true;
}
}
return false;
};
PropertyChanged.prototype._checkType = function (type) {
if (this._eventTable[type] === undefined) {
this._eventTable[type] = [];
}
};
return PropertyChanged;
})();
Property.PropertyChanged = PropertyChanged;
})((Property = Core.Property || (Core.Property = {})));
})((Core = BD.Core || (BD.Core = {})));
})(BD || (BD = {}));
var BD;
(function (BD) {
var Core;
(function (Core) {
var Property;
(function (Property) {
var PropertyDefinition = (function () {
function PropertyDefinition(value) {
this.key = value["key"];
this.type = value["type"];
this.defaultValue = value["defaultValue"];
this.name = { eng: value["eng"] };
}
return PropertyDefinition;
})();
Property.PropertyDefinition = PropertyDefinition;
})((Property = Core.Property || (Core.Property = {})));
})((Core = BD.Core || (BD.Core = {})));
})(BD || (BD = {}));
var BD;
(function (BD) {
var Core;
(function (Core) {
var Property;
(function (Property) {
var PropertyUtility;
(function (PropertyUtility) {
var definitions;
(function (definitions) {
var pd = BD.Core.Property.PropertyDefinition;
definitions.type = new pd({
key: "type",
type: "objType",
defaultValue: "Type",
});
definitions.name = new pd({
key: "name",
type: "String",
defaultValue: "Name",
});
definitions.x = new pd({ key: "x", type: "Number", defaultValue: 0 });
definitions.y = new pd({ key: "y", type: "Number", defaultValue: 0 });
definitions.visible = new pd({
key: "visible",
type: "Boolean",
defaultValue: true,
});
definitions.width = new pd({
key: "width",
type: "Number",
defaultValue: 128,
});
definitions.height = new pd({
key: "height",
type: "Number",
defaultValue: 128,
});
definitions.maxWidth = new pd({
key: "maxWidth",
type: "Number",
defaultValue: 128,
});
definitions.fileName = new pd({
key: "fileName",
type: "String",
defaultValue: "''",
});
definitions.pattern = new pd({
key: "pattern",
type: "Number",
defaultValue: 0,
});
definitions.maxPattern = new pd({
key: "maxPattern",
type: "Number",
defaultValue: 1,
});
definitions.value = new pd({
key: "value",
type: "Number",
defaultValue: 0,
});
definitions.minValue = new pd({
key: "minValue",
type: "Number",
defaultValue: -999999,
});
definitions.maxValue = new pd({
key: "maxValue",
type: "Number",
defaultValue: 999999,
});
definitions.digits = new pd({
key: "digits",
type: "Number",
defaultValue: 4,
});
definitions.zeroSuppress = new pd({
key: "zeroSuppress",
type: "Boolean",
defaultValue: true,
});
definitions.spacing = new pd({
key: "spacing",
type: "Number",
defaultValue: 0,
});
definitions.horizontalSpacing = new pd({
key: "horizontalSpacing",
type: "Number",
defaultValue: 0,
});
definitions.verticalSpacing = new pd({
key: "verticalSpacing",
type: "Number",
defaultValue: 0,
});
definitions.animationSpeed = new pd({
key: "animationSpeed",
type: "Number",
defaultValue: 8,
});
definitions.horizontalAlignment = new pd({
key: "horizontalAlignment",
type: "Number",
defaultValue: 0,
});
definitions.verticalAlignment = new pd({
key: "verticalAlignment",
type: "Number",
defaultValue: 0,
});
definitions.orientation = new pd({
key: "orientation",
type: "Number",
defaultValue: 0,
});
definitions.actorStatusWidth = new pd({
key: "actorStatusWidth",
type: "Number",
defaultValue: 128,
});
definitions.actorStatusHeight = new pd({
key: "actorStatusHeight",
type: "Number",
defaultValue: 128,
});
definitions.maxRows = new pd({
key: "maxRows",
type: "Number",
defaultValue: 4,
});
definitions.maxLines = new pd({
key: "maxLines",
type: "Number",
defaultValue: 1,
});
definitions.startAngle = new pd({
key: "startAngle",
type: "Number",
defaultValue: 0,
});
definitions.endAngle = new pd({
key: "endAngle",
type: "Number",
defaultValue: 359,
});
definitions.radius = new pd({
key: "radius",
type: "Number",
defaultValue: 32,
});
definitions.lineWidth = new pd({
key: "lineWidth",
type: "Number",
defaultValue: 24,
});
definitions.zoom = new pd({
key: "zoom",
type: "Number",
defaultValue: 100,
});
definitions.zoomX = new pd({
key: "zoomX",
type: "Number",
defaultValue: 100,
});
definitions.zoomY = new pd({
key: "zoomY",
type: "Number",
defaultValue: 100,
});
definitions.overlayOffsetX = new pd({
key: "overlayOffsetX",
type: "Number",
defaultValue: 0,
});
definitions.overlayOffsetY = new pd({
key: "overlayOffsetY",
type: "Number",
defaultValue: 0,
});
definitions.isOverlayOnBottom = new pd({
key: "isOverlayOnBottom",
type: "Boolean",
defaultValue: false,
});
definitions.skewAngleX = new pd({
key: "skewAngleX",
type: "Number",
defaultValue: 0,
});
definitions.skewAngleY = new pd({
key: "skewAngleY",
type: "Number",
defaultValue: 0,
});
definitions.rotation = new pd({
key: "rotation",
type: "Number",
defaultValue: 0,
});
definitions.opacity = new pd({
key: "opacity",
type: "Number",
defaultValue: 255,
});
definitions.blendMode = new pd({
key: "blendMode",
type: "Number",
defaultValue: 0,
});
definitions.text = new pd({
key: "text",
type: "String",
defaultValue: "'Text'",
});
definitions.color = new pd({
key: "color",
type: "String",
defaultValue: "'Green'",
});
definitions.outlineColor = new pd({
key: "outlineColor",
type: "String",
defaultValue: "'Blue'",
});
definitions.outlineWidth = new pd({
key: "outlineWidth",
type: "Number",
defaultValue: 4,
});
definitions.fontSize = new pd({
key: "fontSize",
type: "Number",
defaultValue: 28,
});
definitions.fontFace = new pd({
key: "fontFace",
type: "String",
defaultValue: "'GameFont'",
});
definitions.fontItalic = new pd({
key: "fontItalic",
type: "Boolean",
defaultValue: false,
});
definitions.fillColor = new pd({
key: "fillColor",
type: "String",
defaultValue: "'Green'",
});
definitions.gradientColor = new pd({
key: "gradientColor",
type: "String",
defaultValue: "'Yellow'",
});
definitions.isGradient = new pd({
key: "isGradient",
type: "Boolean",
defaultValue: true,
});
definitions.isVertical = new pd({
key: "isVertical",
type: "Boolean",
defaultValue: false,
});
definitions.isBricks = new pd({
key: "isBricks",
type: "Boolean",
defaultValue: false,
});
definitions.maxStates = new pd({
key: "maxStates",
type: "Number",
defaultValue: 1,
});
definitions.stateIconSize = new pd({
key: "stateIconSize",
type: "Number",
defaultValue: 32,
});
definitions.maskImage = new pd({
key: "maskImage",
type: "String",
defaultValue: "''",
});
definitions.maskImageX = new pd({
key: "maskImageX",
type: "Number",
defaultValue: 0,
});
definitions.maskImageY = new pd({
key: "maskImageY",
type: "Number",
defaultValue: 0,
});
definitions.relatedObjects = new pd({
key: "relatedObjects",
type: "String",
defaultValue: "''",
});
})(
(definitions =
PropertyUtility.definitions || (PropertyUtility.definitions = {}))
);
function make(propData) {
if (BD.Core.Manager.isStudioMode()) {
var p = new BD.Studio.Property.Property(
propData.key,
propData.type,
propData.defaultValue
);
ko.track(p);
return p;
} else {
return null;
}
}
PropertyUtility.make = make;
function makeFunction(key, value, context) {
if (BD.Core.Manager.isStudioMode()) {
return this.safetyMakeFunction(key, value, context);
} else {
return new Function(value);
}
}
PropertyUtility.makeFunction = makeFunction;
function safetyMakeFunction(key, value, context) {
var type = this.definitions[key].type;
try {
var func = new Function(value);
var test = func.call(context);
if (!eval("_.is" + type + "(test)")) {
throw "Type Error";
}
return func;
} catch (e) {
return function () {
return PropertyUtility.definitions[key].defaultValue;
};
}
}
PropertyUtility.safetyMakeFunction = safetyMakeFunction;
})(
(PropertyUtility =
Property.PropertyUtility || (Property.PropertyUtility = {}))
);
})((Property = Core.Property || (Core.Property = {})));
})((Core = BD.Core || (BD.Core = {})));
})(BD || (BD = {}));
(function () {
var Settings = BD.Core.Settings.animation;
var adjustX = undefined;
var adjustY = undefined;
function getAdjustX() {
if (adjustX !== undefined) {
return adjustX;
}
adjustX = Settings().forParty.adjustPosition.x || 0;
return adjustX;
}
function getAdjustY() {
if (adjustY !== undefined) {
return adjustY;
}
adjustY = Settings().forParty.adjustPosition.y || 0;
return adjustY;
}
var _bdc_Sprite_Animation_updatePosition =
Sprite_Animation.prototype.updatePosition;
Sprite_Animation.prototype.updatePosition = function () {
if (this.parent instanceof BD.Core.HUD.BattleObjects.PartyStatusContainer) {
this._updatePositionForXPStyleBattler();
} else {
_bdc_Sprite_Animation_updatePosition.apply(this, arguments);
}
};
Sprite_Animation.prototype._updatePositionForXPStyleBattler = function () {
if (this._animation.position === 3) {
this._setContainerPoint();
this.x = -this.containerPoint.x + Graphics.boxWidth / 2 + getAdjustX();
this.y =
-this.containerPoint.y + (Graphics.boxHeight / 6) * 5 + getAdjustY();
} else {
this._setTargetPoint();
this._setContainerPoint();
this.x = -this.containerPoint.x + this.targetPoint.x + this._target.x;
this.y = -this.containerPoint.y + this.targetPoint.y + this._target.y;
var xps = this._target;
var offset = xps.getOverlayOffset();
this.x += offset.x;
}
if (this._animation.position === 0) {
this.y -= this._target.height;
} else if (this._animation.position === 1) {
this.y -= this._target.height / 2;
}
};
Sprite_Animation.prototype._setTargetPoint = function () {
if (!this.targetPoint) {
this.targetPoint = this._target.absolutePosition();
}
};
Sprite_Animation.prototype._setContainerPoint = function () {
if (!this.containerPoint) {
this.containerPoint = this.parent.absolutePosition();
}
};
})();
(function () {
Window_BattleLog.prototype.showEnemyAttackAnimation = function (
subject,
targets
) {
var id = BD.Core.RPGExtension.getAttackAnimationId(subject.enemy());
this.showNormalAnimation(targets, id, false);
};
})();
(function () {
var _bdc_Sprite_Animation_setupRate = Sprite_Animation.prototype.setupRate;
Sprite_Animation.prototype.setupRate = function () {
if (this._animation) {
this._rate = BD.Core.RPGExtension.getAnimationRate(this._animation);
} else {
_bdc_Sprite_Animation_setupRate.call(this);
}
};
})();
(function () {
var _bdc_Window_BattleLog_displayAction =
Window_BattleLog.prototype.displayAction;
Window_BattleLog.prototype.displayAction = function (subject, item) {
var _this = this;
var showAnimationMethods;
var preAnimationId = BD.Core.RPGExtension.getPreAnimationId(item);
if (preAnimationId > 0) {
showAnimationMethods = this._methods.filter(function (x) {
return x.name === "showAnimation";
});
this.push("showAnimation", subject, [subject].clone(), preAnimationId);
_bdc_Window_BattleLog_displayAction.call(this, subject, item);
this.push("waitForAnimation");
this._methods = this._methods.filter(function (x) {
return !showAnimationMethods.contains(x) && x.name !== "wait";
});
showAnimationMethods.forEach(function (x) {
return _this._methods.push(x);
});
this.push("wait");
return;
}
_bdc_Window_BattleLog_displayAction.call(this, subject, item);
};
Window_BattleLog.prototype.waitForAnimation = function () {
this.setWaitMode("animation");
};
var _bdc_Window_BattleLog_updateWaitMode =
Window_BattleLog.prototype.updateWaitMode;
Window_BattleLog.prototype.updateWaitMode = function () {
if (this._waitMode === "animation") {
var waiting = this._spriteset.isAnimationPlaying();
if (waiting) {
return true;
}
}
return _bdc_Window_BattleLog_updateWaitMode.call(this);
};
})();
var __extends =
(this && this.__extends) ||
(function () {
var extendStatics =
Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array &&
function (d, b) {
d.__proto__ = b;
}) ||
function (d, b) {
for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
};
return function (d, b) {
extendStatics(d, b);
function __() {
this.constructor = d;
}
d.prototype =
b === null
? Object.create(b)
: ((__.prototype = b.prototype), new __());
};
})();
var BD;
(function (BD) {
var Core;
(function (Core) {
var Animation;
(function (Animation) {
var StateAnimation;
(function (StateAnimation) {
var LoopAnimation = (function (_super) {
__extends(LoopAnimation, _super);
function LoopAnimation() {
return (_super !== null && _super.apply(this, arguments)) || this;
}
LoopAnimation.prototype.initMembers = function () {
_super.prototype.initMembers.call(this);
this._looping = true;
this._loopCount = -1;
};
LoopAnimation.prototype.update = function () {
_super.prototype.update.call(this);
if (this._duration <= 0) {
this.setupDuration();
if (this._loopCount-- === 0) {
this.terminate();
}
}
if (!this._looping) {
this._vanishing();
}
};
LoopAnimation.prototype.isPlaying = function () {
return this.opacity > 0;
};
LoopAnimation.prototype.terminate = function () {
this._looping = false;
};
LoopAnimation.prototype.animation = function () {
return this._animation;
};
LoopAnimation.prototype._vanishing = function () {
this.opacity -= 32;
};
return LoopAnimation;
})(Sprite_Animation);
StateAnimation.LoopAnimation = LoopAnimation;
})(
(StateAnimation =
Animation.StateAnimation || (Animation.StateAnimation = {}))
);
})((Animation = Core.Animation || (Core.Animation = {})));
})((Core = BD.Core || (BD.Core = {})));
})(BD || (BD = {}));
(function () {
var _bdc_Game_Battler_refresh = Game_Battler.prototype.refresh;
Game_Battler.prototype.refresh = function () {
_bdc_Game_Battler_refresh.call(this);
this.isStateAnimationUpdateRequested = true;
};
Game_Battler.prototype.currentStateAnimationId = function () {
var stateAnimationIds = this.states()
.sort(function (a, b) {
return b.priority - a.priority;
})
.map(function (x) {
return BD.Core.RPGExtension.getStateAnimationId(x);
})
.filter(function (x) {
return x > 0;
});
if (stateAnimationIds.length === 0) {
return 0;
} else {
return stateAnimationIds[0];
}
};
})();
(function () {
Sprite_Base.prototype.startLoopAnimation = function (
animation,
mirror,
delay
) {
var playing = this._animationSprites
.filter(function (x) {
return x instanceof BD.Core.Animation.StateAnimation.LoopAnimation;
})
.some(function (x) {
return x.animation() === animation;
});
if (playing) {
return;
}
var sprite = new BD.Core.Animation.StateAnimation.LoopAnimation();
sprite.setup(this._effectTarget, animation, mirror, delay);
this.parent.addChild(sprite);
this._animationSprites.push(sprite);
};
Sprite_Base.prototype.terminateLoopAnimation = function () {
this._animationSprites
.filter(function (x) {
return x instanceof BD.Core.Animation.StateAnimation.LoopAnimation;
})
.forEach(function (x) {
return x.terminate();
});
};
Sprite_Base.prototype.isAnimationPlaying = function () {
var animations = this._animationSprites.filter(function (x) {
return !(x instanceof BD.Core.Animation.StateAnimation.LoopAnimation);
});
return animations.length > 0;
};
Sprite_Base.prototype.isLoopAnimationPlaying = function () {
var animations = this._animationSprites.filter(function (x) {
return x instanceof BD.Core.Animation.StateAnimation.LoopAnimation;
});
return animations.length > 0;
};
})();
(function () {
var _bdc_Sprite_Battler_initMembers = Sprite_Battler.prototype.initMembers;
Sprite_Battler.prototype.initMembers = function () {
_bdc_Sprite_Battler_initMembers.call(this);
this._lastStateAnimationId = -1;
};
var _bdc_Sprite_Battler__updateAnimation =
Sprite_Battler.prototype.updateAnimation;
Sprite_Battler.prototype.updateAnimation = function () {
_bdc_Sprite_Battler__updateAnimation.call(this);
this.setupLoopAnimation();
};
Sprite_Battler.prototype.setupLoopAnimation = function () {
if (this._battler.isStateAnimationUpdateRequested) {
var id = this._battler.currentStateAnimationId();
var animation = $dataAnimations[id];
if (id !== this._lastStateAnimationId) {
this.terminateLoopAnimation();
}
if (id !== 0) {
this.startLoopAnimation(animation, false, 0);
}
this._lastStateAnimationId = id;
this._battler.isStateAnimationUpdateRequested = false;
}
};
})();
var BD;
(function (BD) {
var Core;
(function (Core) {
var BattleSpeed;
(function (BattleSpeed) {
var Utility;
(function (Utility) {
var Settings = BD.Core.Settings.battleSpeed;
function isFastForward() {
return Window_BattleLog.prototype.isFastForward.call(this);
}
Utility.isFastForward = isFastForward;
function isAnimationFastForward() {
return isFastForward() && Settings().animationFastForward;
}
Utility.isAnimationFastForward = isAnimationFastForward;
function isAnimationDelayFastForward() {
return isFastForward() && Settings().animationDelayFastForward;
}
Utility.isAnimationDelayFastForward = isAnimationDelayFastForward;
})((Utility = BattleSpeed.Utility || (BattleSpeed.Utility = {})));
})((BattleSpeed = Core.BattleSpeed || (Core.BattleSpeed = {})));
})((Core = BD.Core || (BD.Core = {})));
})(BD || (BD = {}));
(function () {
var Settings = BD.Core.Settings.battleSpeed;
var _bdc_Sprite_Actor_stepForward = Sprite_Actor.prototype.stepForward;
Sprite_Actor.prototype.stepForward = function () {
var duration = Settings().actorStepDuration;
if (duration > -1) {
this.startMove(-48, 0, duration);
} else {
_bdc_Sprite_Actor_stepForward.call(this);
}
};
var _bdc_Sprite_Actor_stepBack = Sprite_Actor.prototype.stepBack;
Sprite_Actor.prototype.stepBack = function () {
var duration = Settings().actorStepDuration;
if (duration > -1) {
this.startMove(0, 0, duration);
} else {
_bdc_Sprite_Actor_stepBack.call(this);
}
};
})();
(function () {
var _bdc_Sprite_Animation_updateMain = Sprite_Animation.prototype.updateMain;
Sprite_Animation.prototype.updateMain = function () {
if (
!(this instanceof BD.Core.Animation.StateAnimation.LoopAnimation) &&
this.isPlaying() &&
this.isReady()
) {
if (
BD.Core.BattleSpeed.Utility.isAnimationDelayFastForward() &&
this._delay > 0
) {
this._delay--;
} else if (BD.Core.BattleSpeed.Utility.isAnimationFastForward()) {
if (this._rate > 1 && this._duration % this._rate === this._rate - 1) {
this._duration--;
}
}
}
_bdc_Sprite_Animation_updateMain.call(this);
};
})();
(function () {
var Settings = BD.Core.Settings.battleSpeed;
var _bdc_Sprite_Base_isAnimationPlaying =
Sprite_Base.prototype.isAnimationPlaying;
Sprite_Base.prototype.isAnimationPlaying = function () {
var isPlaying = _bdc_Sprite_Base_isAnimationPlaying.call(this);
if (!isPlaying) {
return false;
}
var skipDuration = Settings().animationSkipDuration;
var endDuration = BD.Core.BattleSpeed.Utility.isFastForward()
? skipDuration * 2
: skipDuration;
return this._animationSprites
.filter(function (x) {
return !(x instanceof BD.Core.Animation.StateAnimation.LoopAnimation);
})
.some(function (x) {
return x.currentFrameIndex() < 2 || x._duration > endDuration;
});
};
})();
(function () {
Sprite_Battler.prototype.isBossCollapsing = function () {
return false;
};
})();
(function () {
var Settings = BD.Core.Settings.battleSpeed;
var _bdc_Sprite_Enemy_isEffecting = Sprite_Enemy.prototype.isEffecting;
Sprite_Enemy.prototype.isEffecting = function () {
if (
this._effectType === "collapse" ||
this._effectType === "bossCollapse"
) {
return false;
}
return _bdc_Sprite_Enemy_isEffecting.call(this);
};
Sprite_Enemy.prototype.isBossCollapsing = function () {
return this._effectType === "bossCollapse";
};
})();
(function () {
Spriteset_Battle.prototype.isBossCollapsing = function () {
return this.battlerSprites().some(function (sprite) {
return sprite.isBossCollapsing();
});
};
})();
(function () {
var Settings = BD.Core.Settings;
Window_BattleLog.prototype.messageSpeed = function () {
return Settings.basicSpeed();
};
var _bdc_Window_BattleLog_update = Window_BattleLog.prototype.update;
Window_BattleLog.prototype.update = function () {
_bdc_Window_BattleLog_update.call(this);
if (
this._waitCount === 0 &&
!this.updateWaitMode() &&
this._methods.length > 0
) {
this.update();
}
};
var _bdc_Window_BattleLog_setWaitMode =
Window_BattleLog.prototype.setWaitMode;
Window_BattleLog.prototype.setWaitMode = function (waitMode) {
if (this._waitCount === 0) {
this._waitCount += 1;
}
_bdc_Window_BattleLog_setWaitMode.call(this, waitMode);
};
})();
var BD;
(function (BD) {
var Core;
(function (Core) {
var DamagePopup;
(function (DamagePopup) {
var DamagePopupFactory;
(function (DamagePopupFactory) {
var Directions = BD.Core.Consts.Enums.Directions;
var PopupTypes = BD.Core.Consts.Enums.DamagePopupTypes;
function initialize() {
_getPopupImageAttributes();
Object.keys(DamagePopup.Types)
.map(function (x) {
return DamagePopup.Types[x].initializePopup;
})
.filter(function (x) {
return x && x instanceof Function;
})
.forEach(function (x) {
return x();
});
}
DamagePopupFactory.initialize = initialize;
function create(target) {
var popups = [];
var result = target.result();
if (result.performCounter) {
popups.push(_createCounterPopup(target));
return popups.filter(function (x) {
return x !== null;
});
}
if (result.performReflection) {
popups.push(_createReflectionPopup(target));
return popups.filter(function (x) {
return x !== null;
});
}
if (result.performSubstitute) {
popups.push(_createSubstitutePopup(target));
return popups.filter(function (x) {
return x !== null;
});
}
if (!result.regenerateTp && result.gainSilentTp) {
if (Core.Settings.isDisplayTp()) {
var chargeTp = _createTpChargePopup(target);
popups.push(chargeTp);
}
return popups.filter(function (x) {
return x !== null;
});
}
var miss = _createMissPopup(target);
popups.push(miss);
var hp = _createHpDamagePopup(target);
popups.push(hp);
var mp = _createMpDamagePopup(target);
popups.push(mp);
if (Core.Settings.isDisplayTp()) {
var tp = _createTpDamagePopup(target);
popups.push(tp);
}
var states = _createStatePopups(target);
Array.prototype.push.apply(popups, states);
var buffs = _createBuffPopups(target);
Array.prototype.push.apply(popups, buffs);
var regene = _createRegeneratePopups(target);
Array.prototype.push.apply(popups, regene);
return popups.filter(function (x) {
return x !== null;
});
}
DamagePopupFactory.create = create;
function adjustPopupPosition(popup, x, y) {
var lx = Math.min(0, x - popup.pieceWidth / 2);
popup.pivot.x += lx;
var rx = Math.min(0, Graphics.boxWidth - x - popup.pieceWidth / 2);
popup.pivot.x -= rx;
}
DamagePopupFactory.adjustPopupPosition = adjustPopupPosition;
function _createStatePopups(target) {
var popups = [];
var result = target.result();
if (!result.isStatusAffected()) {
return popups;
}
var name = _battlerIdName(target);
var deathStateId = target.deathStateId();
var addStates = result.addedNewStateObjects();
addStates
.filter(function (x) {
return (
x.id !== deathStateId &&
x.iconIndex !== 0 &&
!Core.RPGExtension.getHideAddPopup(x)
);
})
.forEach(function (state) {
var popup = _createPopup(
_types().addState,
_createAddState(state),
name
);
popups.push(popup);
});
var removeStates = result.removedStateObjects();
removeStates
.filter(function (x) {
return (
x.id !== deathStateId &&
x.iconIndex !== 0 &&
!Core.RPGExtension.getHideRemovePopup(x)
);
})
.forEach(function (state) {
var popup = _createPopup(
_types().removeState,
_createRemoveState(state),
name
);
popups.push(popup);
});
return popups;
}
function _createBuffPopups(target) {
var popups = [];
var result = target.result();
if (!result.isStatusAffected()) {
return popups;
}
var name = _battlerIdName(target);
result.addedBuffs.forEach(function (id) {
var popup = _createPopup(
_types().addBuff,
_createAddBuff(target, id, false),
name
);
popups.push(popup);
});
result.addedDebuffs.forEach(function (id) {
var popup = _createPopup(
_types().addDebuff,
_createAddBuff(target, id, true),
name
);
popups.push(popup);
});
result.removedBuffs.forEach(function (id) {
var popup = _createPopup(
_types().removeBuff,
_createRemoveBuff(target, id, false),
name
);
popups.push(popup);
});
return popups;
}
function _createAddState(state) {
var color = convertTypeToColorIndex(_addStateType(state));
var icon = new DamagePopup.Pieces.Icon(state.iconIndex, 255);
var name = Core.RPGExtension.getDisplayNameForPopup(state);
var text = new DamagePopup.Pieces.Text(
name,
color,
_getPopupImageAttributes()
);
return new DamagePopup.Pieces.Base()
.addPiece(text)
.addPiece(icon, Directions.Left);
}
function _createRemoveState(state) {
var color = convertTypeToColorIndex(_removeStateType(state));
var icon = new DamagePopup.Pieces.Icon(state.iconIndex, 128);
var name = Core.RPGExtension.getDisplayNameForPopup(state);
var text = new DamagePopup.Pieces.Text(
name,
color,
_getPopupImageAttributes()
);
return new DamagePopup.Pieces.Base()
.addPiece(text)
.addPiece(icon, Directions.Left);
}
function _createAddBuff(target, paramId, debuff) {
if (debuff === void 0) {
debuff = false;
}
var color = convertTypeToColorIndex(
debuff ? PopupTypes.AddDebuff : PopupTypes.AddBuff
);
var iconId = target.buffIconIndex(debuff ? -1 : 1, paramId);
var icon = new DamagePopup.Pieces.Icon(iconId, 255);
var text = new DamagePopup.Pieces.Text(
TextManager.param(paramId),
color,
_getPopupImageAttributes()
);
return new DamagePopup.Pieces.Base()
.addPiece(text)
.addPiece(icon, Directions.Left);
}
function _createRemoveBuff(target, paramId, debuff) {
if (debuff === void 0) {
debuff = false;
}
var color = convertTypeToColorIndex(
debuff ? PopupTypes.RemoveDebuff : PopupTypes.RemoveBuff
);
var iconId = target.buffIconIndex(debuff ? -1 : 1, paramId);
var icon = new DamagePopup.Pieces.Icon(iconId, 128);
var text = new DamagePopup.Pieces.Text(
TextManager.param(paramId),
color,
_getPopupImageAttributes()
);
return new DamagePopup.Pieces.Base()
.addPiece(text)
.addPiece(icon, Directions.Left);
}
function _createTpChargePopup(target) {
var result = target.result();
if (
target.isActor() &&
result.gainSilentTp &&
result.silentTpDamage !== 0
) {
return _createPopup(
_types().tpCharge,
_createTpDamage(target),
_battlerIdName(target)
);
}
return null;
}
function _createRegeneratePopups(target) {
var popups = [];
var result = target.result();
var name = _battlerIdName(target);
var popupType = _types().regenerate;
if (result.regenerateHp && result.hpDamage !== 0) {
var hp = _createPopup(popupType, _createHpDamage(target), name);
popups.push(hp);
}
if (result.regenerateMp && result.mpDamage !== 0) {
var mp = _createPopup(popupType, _createMpDamage(target), name);
popups.push(mp);
}
if (result.regenerateTp && result.silentTpDamage !== 0) {
var tp = _createPopup(popupType, _createTpDamage(target), name);
popups.push(tp);
}
return popups;
}
function _createMissPopup(target) {
var result = target.result();
var popupType = _types().miss;
if (result.missed) {
return _createPopup(
popupType,
_createMiss(target),
_battlerIdName(target)
);
} else if (result.evaded) {
return _createPopup(
popupType,
_createEvasion(target),
_battlerIdName(target)
);
}
return null;
}
function _createMiss(target) {
var color = convertTypeToColorIndex(PopupTypes.Miss);
var miss = new DamagePopup.Pieces.Text(
_texts().miss,
color,
_getPopupImageAttributes()
);
return new DamagePopup.Pieces.Base().addPiece(miss);
}
function _createEvasion(target) {
var color = convertTypeToColorIndex(PopupTypes.Evasion);
var evasion = new DamagePopup.Pieces.Text(
_texts().evasion,
color,
_getPopupImageAttributes()
);
return new DamagePopup.Pieces.Base().addPiece(evasion);
}
function _createHpDamagePopup(target) {
var result = target.result();
if (
!result.hpAffected ||
result.missed ||
result.evaded ||
result.regenerateHp
) {
return null;
}
return _createPopup(
_types().hpDamage,
_createHpDamage(target),
_battlerIdName(target)
);
}
function _createMpDamagePopup(target) {
var result = target.result();
if (
result.mpDamage === 0 ||
result.missed ||
result.evaded ||
result.regenerateMp
) {
return null;
}
return _createPopup(
_types().mpDamage,
_createMpDamage(target),
_battlerIdName(target)
);
}
function _createTpDamagePopup(target) {
var result = target.result();
if (
target.isEnemy() ||
result.tpDamage === 0 ||
result.missed ||
result.evaded ||
result.regenerateTp
) {
return null;
}
return _createPopup(
_types().tpDamage,
_createTpDamage(target),
_battlerIdName(target)
);
}
function _createHpDamage(target) {
var result = target.result();
var color;
if (result.hpDamage >= 0) {
if (result.isEffectiveDamage()) {
color = convertTypeToColorIndex(PopupTypes.Effective);
} else if (result.isNotEffectiveDamage()) {
color = convertTypeToColorIndex(PopupTypes.NotEffective);
} else {
color = convertTypeToColorIndex(
result.critical
? PopupTypes.HpCriticalDamage
: PopupTypes.HpDamage
);
}
} else {
color = convertTypeToColorIndex(PopupTypes.HpRecover);
}
var num = new DamagePopup.Pieces.Digits(
result.hpDamage,
color,
_getPopupImageAttributes()
);
var parts = new DamagePopup.Pieces.Base().addPiece(num);
if (result.hpDamage >= 0) {
parts.addPiece(_createEffective(target, color), Directions.Up);
parts.addPiece(_createCritical(target, color), Directions.Up);
}
return parts;
}
function _createMpDamage(target) {
var result = target.result();
var color;
var mpText;
if (result.mpDamage > 0) {
color = convertTypeToColorIndex(
result.critical
? PopupTypes.MpCriticalDamage
: PopupTypes.MpDamage
);
mpText = TextManager.mpA + _texts().minus;
} else {
color = convertTypeToColorIndex(PopupTypes.MpRecover);
mpText = TextManager.mpA + _texts().plus;
}
var text = new DamagePopup.Pieces.Text(
mpText,
color,
_getPopupImageAttributes()
);
var num = new DamagePopup.Pieces.Digits(
target.result().mpDamage,
color,
_getPopupImageAttributes()
);
return new DamagePopup.Pieces.Base()
.addPiece(num)
.addPiece(text, Directions.Left);
}
function _createTpDamage(target) {
var result = target.result();
var damage = result.gainSilentTp
? result.silentTpDamage
: result.tpDamage;
var color;
var tpText;
if (damage > 0) {
color = convertTypeToColorIndex(
result.critical
? PopupTypes.TpCriticalDamage
: PopupTypes.TpDamage
);
tpText = TextManager.tpA + _texts().minus;
} else {
color = convertTypeToColorIndex(PopupTypes.TpRecover);
tpText = TextManager.tpA + _texts().plus;
}
var text = new DamagePopup.Pieces.Text(
tpText,
color,
_getPopupImageAttributes()
);
var num = new DamagePopup.Pieces.Digits(
damage,
color,
_getPopupImageAttributes()
);
return new DamagePopup.Pieces.Base()
.addPiece(num)
.addPiece(text, Directions.Left);
}
function _createEffective(target, color) {
var result = target.result();
if (result.isEffectiveDamage()) {
return new DamagePopup.Pieces.Text(
_texts().weakness,
color,
_getPopupImageAttributes()
);
} else if (result.isNotEffectiveDamage()) {
return new DamagePopup.Pieces.Text(
_texts().resist,
color,
_getPopupImageAttributes()
);
} else {
return null;
}
}
function _createCritical(target, color) {
var result = target.result();
if (result.critical) {
return new DamagePopup.Pieces.Text(
_texts().critical,
color,
_getPopupImageAttributes()
);
} else {
return null;
}
}
function _createCounterPopup(target) {
if (target.result().performCounter) {
return _createPopup(
_types().counter,
_createCounter(),
_battlerIdName(target)
);
}
return null;
}
function _createCounter() {
var color = convertTypeToColorIndex(PopupTypes.Counter);
return new DamagePopup.Pieces.Text(
_texts().counter,
color,
_getPopupImageAttributes()
);
}
function _createReflectionPopup(target) {
if (target.result().performReflection) {
return _createPopup(
_types().reflection,
_createReflection(),
_battlerIdName(target)
);
}
return null;
}
function _createReflection() {
var color = convertTypeToColorIndex(PopupTypes.Reflection);
return new DamagePopup.Pieces.Text(
_texts().reflection,
color,
_getPopupImageAttributes()
);
}
function _createSubstitutePopup(target) {
if (target.result().performSubstitute) {
return _createPopup(
_types().substitute,
_createSubstitute(),
_battlerIdName(target)
);
}
return null;
}
function _createSubstitute() {
var color = convertTypeToColorIndex(PopupTypes.Substitute);
return new DamagePopup.Pieces.Text(
_texts().substitute,
color,
_getPopupImageAttributes()
);
}
function _battlerIdName(target) {
return (
target.index().toString() +
target.name().toString() +
target.battlerName().toString()
);
}
function _addStateType(state) {
if (Core.RPGExtension.getPositive(state)) {
return PopupTypes.AddPositiveState;
} else if (Core.RPGExtension.getNegative(state)) {
return PopupTypes.AddNegativeState;
} else {
return PopupTypes.AddState;
}
}
function _removeStateType(state) {
if (Core.RPGExtension.getPositive(state)) {
return PopupTypes.RemovePositiveState;
} else if (Core.RPGExtension.getNegative(state)) {
return PopupTypes.RemoveNegativeState;
} else {
return PopupTypes.RemoveState;
}
}
var attributes = null;
function _getPopupImageAttributes() {
if (attributes == null) {
attributes = _createPopupImageAttributes();
}
return attributes;
}
var numPaddingX = 8;
function _createPopupImageAttributes() {
var b = new Bitmap();
b.fontSize = Core.Settings.popup().numberSize;
var font = Core.Settings.popup().textFont;
b.fontFace = font;
var numbers = ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9"];
var numberWidths = numbers.map(function (x) {
return Math.round(b.measureTextWidth(x) + numPaddingX);
});
var bw = numberWidths.reduce(function (prev, current) {
return prev + current;
}, 0);
var height = Core.Settings.popup().numberHeight;
var colors = Core.Settings.popup().colors;
b.resize(bw, height * colors.length);
b.smooth = true;
colors.forEach(function (value, index) {
b.textColor = value.bodyColor;
b.outlineColor = value.outlineColor;
var drawX = 0;
numbers.forEach(function (n, i) {
b.drawText(
n,
drawX,
index * height,
numberWidths[i],
height,
"center"
);
drawX += numberWidths[i];
});
});
return {
numbers: b,
widths: numberWidths,
numberHeight: height,
numberSpacing: Core.Settings.popup().numberSpacing,
textSize: Core.Settings.popup().textSize,
textFont: font,
textHeight: Core.Settings.popup().textSize,
colors: colors,
};
}
function _createPopup(type, piece, name) {
var popupType = BD.Core.DamagePopup.Types[type];
if (popupType === undefined) {
return new DamagePopup.Types.SimpleBounce(piece, name);
}
return new popupType(piece, name);
}
function _types() {
return Core.Settings.popup().types;
}
function _texts() {
return Core.Settings.popup().texts;
}
function convertTypeToColorIndex(type) {
var t = type;
var index = Core.Settings.popup().colorAlloc[t];
return index ? index : 0;
}
DamagePopupFactory.convertTypeToColorIndex = convertTypeToColorIndex;
})(
(DamagePopupFactory =
DamagePopup.DamagePopupFactory ||
(DamagePopup.DamagePopupFactory = {}))
);
})((DamagePopup = Core.DamagePopup || (Core.DamagePopup = {})));
})((Core = BD.Core || (BD.Core = {})));
})(BD || (BD = {}));
(function () {
var _bdc_Game_Action_calcElementRate = Game_Action.prototype.calcElementRate;
Game_Action.prototype.calcElementRate = function (target) {
var rate = _bdc_Game_Action_calcElementRate.call(this, target);
target.result().damageRate = rate;
return rate;
};
})();
(function () {
var _bdc_Game_ActionResult_clear = Game_ActionResult.prototype.clear;
Game_ActionResult.prototype.clear = function () {
if (this.performCounter) {
this.performCounter = false;
return;
}
if (this.performReflection) {
this.performReflection = false;
return;
}
if (this.performSubstitute) {
this.performSubstitute = false;
return;
}
if (!this.regenerateTp && this.gainSilentTp) {
this.gainSilentTp = false;
this.silentTpDamage = 0;
return;
}
_bdc_Game_ActionResult_clear.call(this);
this.damageRate = 1.0;
this.regenerateHp = false;
this.regenerateMp = false;
this.regenerateTp = false;
this.gainSilentTp = false;
this.silentTpDamage = 0;
this.addedNewStates = [];
this.performCounter = false;
this.performReflection = false;
this.performSubstitute = false;
};
var _bdc_Game_ActionResult_isStatusAffected =
Game_ActionResult.prototype.isStatusAffected;
Game_ActionResult.prototype.isStatusAffected = function () {
if (this.addedNewStates.length > 0) {
return true;
}
return _bdc_Game_ActionResult_isStatusAffected.call(this);
};
Game_ActionResult.prototype.addedNewStateObjects = function () {
return this.addedNewStates.map(function (id) {
return $dataStates[id];
});
};
Game_ActionResult.prototype.isEffectiveDamage = function () {
return this.damageRate > 1.0;
};
Game_ActionResult.prototype.isNotEffectiveDamage = function () {
return this.damageRate < 1.0;
};
})();
(function () {
var _bdc_Game_Battler_gainSilentTp = Game_Battler.prototype.gainSilentTp;
Game_Battler.prototype.gainSilentTp = function (value) {
this.result().gainSilentTp = true;
this.result().silentTpDamage = -value;
_bdc_Game_Battler_gainSilentTp.call(this, value);
if (!this.result().regenerateTp) {
this.startDamagePopup();
}
};
var _bdc_Game_Battler_regenerateHp = Game_Battler.prototype.regenerateHp;
Game_Battler.prototype.regenerateHp = function () {
this.result().regenerateHp = true;
_bdc_Game_Battler_regenerateHp.call(this);
};
var _bdc_Game_Battler_regenerateMp = Game_Battler.prototype.regenerateMp;
Game_Battler.prototype.regenerateMp = function () {
this.result().regenerateMp = true;
_bdc_Game_Battler_regenerateMp.call(this);
};
var _bdc_Game_Battler_regenerateTp = Game_Battler.prototype.regenerateTp;
Game_Battler.prototype.regenerateTp = function () {
this.result().regenerateTp = true;
_bdc_Game_Battler_regenerateTp.call(this);
};
Game_Battler.prototype.addNewState = function (stateId) {
this.result().addedNewStates.push(stateId);
Game_BattlerBase.prototype.addNewState.call(this, stateId);
};
var _bdc_Game_Battler_performCounter = Game_Battler.prototype.performCounter;
Game_Battler.prototype.performCounter = function () {
this.result().performCounter = true;
this.startDamagePopup();
_bdc_Game_Battler_performCounter.call(this);
};
var _bdc_Game_Battler_performReflection =
Game_Battler.prototype.performReflection;
Game_Battler.prototype.performReflection = function () {
this.result().performReflection = true;
this.startDamagePopup();
_bdc_Game_Battler_performReflection.call(this);
};
var _bdc_Game_Battler_performSubstitute =
Game_Battler.prototype.performSubstitute;
Game_Battler.prototype.performSubstitute = function (target) {
this.result().performSubstitute = true;
this.startDamagePopup();
_bdc_Game_Battler_performSubstitute.call(this, target);
};
})();
(function () {
var Settings = BD.Core.Settings;
var _bdc_Sprite_Battler_initMembers = Sprite_Battler.prototype.initMembers;
Sprite_Battler.prototype.initMembers = function () {
_bdc_Sprite_Battler_initMembers.call(this);
this._popupLayer = null;
};
Sprite_Battler.prototype.getPopupLayer = function () {
if (!this._popupLayer) {
this._popupLayer = this.findFamily(function (sprite) {
return sprite instanceof BD.Core.DamagePopup.PopupLayer;
});
}
return this._popupLayer;
};
Sprite_Battler.prototype.setupDamagePopup = function () {
if (this._battler.isDamagePopupRequested()) {
var popupLayer = this.getPopupLayer();
var disablePopup =
this._battler.isActor() &&
!Settings.battlerGraphic().enablePopup &&
!Settings.enableSideVidwBattler();
if (popupLayer && this._battler.isSpriteVisible() && !disablePopup) {
var sprite = new Sprite_Damage();
var ap = this.absolutePosition();
sprite.x = ap.x + this.damageOffsetX();
sprite.y = ap.y + this.damageOffsetY();
sprite.setup(this._battler);
this._damages.push(sprite);
popupLayer.addChild(sprite);
}
this._battler.clearDamagePopup();
this._battler.clearResult();
}
};
Sprite_Battler.prototype.updateDamagePopup = function () {
this.setupDamagePopup();
if (this._damages.length > 0) {
for (var i = 0; i < this._damages.length; i++) {
this._damages[i].update();
}
var popupLayer = this.getPopupLayer();
if (popupLayer && !this._damages[0].isPlaying()) {
popupLayer.removeChild(this._damages[0]);
this._damages.shift();
}
}
};
})();
(function () {
var Popup = BD.Core.DamagePopup;
Sprite_Damage.prototype.initialize = function () {
Sprite.prototype.initialize.call(this);
this._duration = 90;
this.damages = [];
};
Sprite_Damage.prototype.setup = function (target) {
var _this = this;
var popups = Popup.DamagePopupFactory.create(target);
popups.forEach(function (popup) {
_this.damages.push(popup);
_this.addChild(popup);
Popup.DamagePopupFactory.adjustPopupPosition(popup, _this.x, _this.y);
});
};
Sprite_Damage.prototype.update = function () {
var damages = this.damages;
return damages.forEach(function (popup) {
popup.update();
});
};
Sprite_Damage.prototype.isPlaying = function () {
var damages = this.damages;
return damages.some(function (popup) {
return popup.isPlaying();
});
};
})();
(function () {
Sprite_Enemy.prototype.damageOffsetX = function () {
return 0;
};
Sprite_Enemy.prototype.damageOffsetY = function () {
return -Math.round(this.height * 0.25);
};
})();
(function () {
var _bdc_Window_BattleLog_displayBuffs =
Window_BattleLog.prototype.displayBuffs;
Window_BattleLog.prototype.displayBuffs = function (target, buffs, fmt) {
_bdc_Window_BattleLog_displayBuffs.call(this, target, buffs, fmt);
this.push("popupDamage", target);
};
})();
var __extends =
(this && this.__extends) ||
(function () {
var extendStatics =
Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array &&
function (d, b) {
d.__proto__ = b;
}) ||
function (d, b) {
for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
};
return function (d, b) {
extendStatics(d, b);
function __() {
this.constructor = d;
}
d.prototype =
b === null
? Object.create(b)
: ((__.prototype = b.prototype), new __());
};
})();
var BD;
(function (BD) {
var Core;
(function (Core) {
var DamagePopup;
(function (DamagePopup) {
var Pieces;
(function (Pieces) {
var Digits = (function (_super) {
__extends(Digits, _super);
function Digits(num, color, attributes) {
var _this = _super.call(this, null) || this;
_this.setup(num, color, attributes);
return _this;
}
Digits.prototype.setup = function (num, color, attributes) {
var _this = this;
this.pieceWidth = 0;
var nums = Math.abs(num).toString().split("");
nums
.map(function (x) {
return parseInt(x);
})
.forEach(function (n) {
var s = new Sprite(attributes.numbers);
s.setFrame(
_this._getFrameX(n, attributes.widths),
attributes.numberHeight * color,
attributes.widths[n],
attributes.numberHeight
);
s.x = _this.pieceWidth;
_this.pieceWidth += Math.round(
attributes.widths[n] * attributes.numberSpacing
);
_this.addChild(s);
});
this.pieceHeight = attributes.numberHeight;
this.children.forEach(function (x) {
x.x -= _this.pieceWidth / 2;
x.y -= _this.pieceHeight / 2;
});
};
Digits.prototype._getFrameX = function (num, widths) {
var x = 0;
for (var i = 0; i < num; i++) {
x += widths[i];
}
return x;
};
Digits.prototype.update = function () {};
return Digits;
})(Sprite);
Pieces.Digits = Digits;
})((Pieces = DamagePopup.Pieces || (DamagePopup.Pieces = {})));
})((DamagePopup = Core.DamagePopup || (Core.DamagePopup = {})));
})((Core = BD.Core || (BD.Core = {})));
})(BD || (BD = {}));
var __extends =
(this && this.__extends) ||
(function () {
var extendStatics =
Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array &&
function (d, b) {
d.__proto__ = b;
}) ||
function (d, b) {
for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
};
return function (d, b) {
extendStatics(d, b);
function __() {
this.constructor = d;
}
d.prototype =
b === null
? Object.create(b)
: ((__.prototype = b.prototype), new __());
};
})();
var BD;
(function (BD) {
var Core;
(function (Core) {
var DamagePopup;
(function (DamagePopup) {
var Pieces;
(function (Pieces) {
var Directions = BD.Core.Consts.Enums.Directions;
var Base = (function (_super) {
__extends(Base, _super);
function Base() {
var _this = _super.call(this, null) || this;
_this.anchor.x = 0.5;
_this.anchor.y = 0.5;
return _this;
}
Base.prototype.addPiece = function (piece, position) {
if (position === void 0) {
position = Directions.Center;
}
if (piece === null) {
return this;
}
if (this.children.length === 0) {
this._initialAdd(piece);
return this;
}
var pw = piece.pieceWidth;
var ph = piece.pieceHeight;
switch (position) {
case Directions.LeftDown:
throw "Not Implemented";
case Directions.Down:
this._putToDown(piece, pw, ph);
break;
case Directions.RightDown:
throw "Not Implemented";
case Directions.Left:
this._putToLeft(piece, pw, ph);
break;
case Directions.Center:
break;
case Directions.Right:
this._putToRight(piece, pw, ph);
break;
case Directions.LeftUp:
throw "Not Implemented";
case Directions.Up:
this._putToUp(piece, pw, ph);
break;
case Directions.RightUp:
throw "Not Implemented";
default:
break;
}
return this;
};
Base.prototype.shift = function (shiftX, shiftY) {
this.children.forEach(function (sprite) {
sprite.x += Math.round(shiftX);
sprite.y += Math.round(shiftY);
});
return this;
};
Base.prototype._initialAdd = function (piece) {
this.pieceWidth = piece.pieceWidth;
this.pieceHeight = piece.pieceHeight;
this.addChild(piece);
};
Base.prototype._putToLeft = function (piece, pw, ph) {
piece.x = Math.round(-this.pieceWidth / 2 - pw / 2);
this.pieceWidth += pw;
if (ph > this.pieceHeight) {
this.pieceHeight = ph;
}
this.addChild(piece);
this.shift(pw / 2, 0);
};
Base.prototype._putToRight = function (piece, pw, ph) {
piece.x = Math.round(this.pieceWidth / 2 + pw / 2);
this.pieceWidth += pw;
if (ph > this.pieceHeight) {
this.pieceHeight = ph;
}
this.addChild(piece);
this.shift(-pw / 2, 0);
};
Base.prototype._putToUp = function (piece, pw, ph) {
piece.y = Math.round(-this.pieceHeight / 2 - ph / 2);
this.pieceHeight += ph;
if (pw > this.pieceWidth) {
this.pieceWidth = pw;
}
this.addChild(piece);
this.shift(0, ph / 2);
};
Base.prototype._putToDown = function (piece, pw, ph) {
piece.y = Math.round(this.pieceHeight / 2 + ph / 2);
this.pieceHeight += ph;
if (pw > this.pieceWidth) {
this.pieceWidth = pw;
}
this.addChild(piece);
this.shift(0, -ph / 2);
};
return Base;
})(Sprite);
Pieces.Base = Base;
})((Pieces = DamagePopup.Pieces || (DamagePopup.Pieces = {})));
})((DamagePopup = Core.DamagePopup || (Core.DamagePopup = {})));
})((Core = BD.Core || (BD.Core = {})));
})(BD || (BD = {}));
var __extends =
(this && this.__extends) ||
(function () {
var extendStatics =
Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array &&
function (d, b) {
d.__proto__ = b;
}) ||
function (d, b) {
for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
};
return function (d, b) {
extendStatics(d, b);
function __() {
this.constructor = d;
}
d.prototype =
b === null
? Object.create(b)
: ((__.prototype = b.prototype), new __());
};
})();
var BD;
(function (BD) {
var Core;
(function (Core) {
var DamagePopup;
(function (DamagePopup) {
var Pieces;
(function (Pieces) {
var Icon = (function (_super) {
__extends(Icon, _super);
function Icon(iconIndex, opacity) {
var _this = _super.call(this) || this;
_this.setup(iconIndex, opacity);
return _this;
}
Icon.prototype.setup = function (iconIndex, opacity) {
this.bitmap = ImageManager.loadSystem("IconSet");
this._setIcon(iconIndex);
this.anchor.x = 0.5;
this.anchor.y = 0.5;
this.opacity = opacity;
this.pieceWidth = 32;
this.pieceHeight = 32;
};
Icon.prototype.update = function () {};
Icon.prototype._setIcon = function (iconIndex) {
var pw = 32;
var ph = 32;
var sx = (iconIndex % 16) * pw;
var sy = Math.floor(iconIndex / 16) * ph;
this.setFrame(sx, sy, pw, ph);
this.anchor.x = 0.5;
this.anchor.y = 0.5;
};
return Icon;
})(Sprite);
Pieces.Icon = Icon;
})((Pieces = DamagePopup.Pieces || (DamagePopup.Pieces = {})));
})((DamagePopup = Core.DamagePopup || (Core.DamagePopup = {})));
})((Core = BD.Core || (BD.Core = {})));
})(BD || (BD = {}));
var __extends =
(this && this.__extends) ||
(function () {
var extendStatics =
Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array &&
function (d, b) {
d.__proto__ = b;
}) ||
function (d, b) {
for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
};
return function (d, b) {
extendStatics(d, b);
function __() {
this.constructor = d;
}
d.prototype =
b === null
? Object.create(b)
: ((__.prototype = b.prototype), new __());
};
})();
var BD;
(function (BD) {
var Core;
(function (Core) {
var DamagePopup;
(function (DamagePopup) {
var Pieces;
(function (Pieces) {
var Text = (function (_super) {
__extends(Text, _super);
function Text(text, color, attributes) {
var _this = _super.call(this) || this;
_this.setup(text, color, attributes);
return _this;
}
Text.prototype.setup = function (text, color, attributes) {
var b = new Bitmap(4, 4);
b.outlineColor = attributes.colors[color].outlineColor;
b.textColor = attributes.colors[color].bodyColor;
b.fontSize = attributes.textSize;
b.fontFace = attributes.textFont;
var textWidth = b.measureTextWidth(text) + 4;
b.resize(textWidth, attributes.textHeight);
b.drawText(text, 0, 0, b.width, b.height, "center");
this.bitmap = b;
this.anchor.x = 0.5;
this.anchor.y = 0.5;
this.pieceWidth = b.width;
this.pieceHeight = b.height;
};
Text.prototype.update = function () {};
return Text;
})(Sprite);
Pieces.Text = Text;
})((Pieces = DamagePopup.Pieces || (DamagePopup.Pieces = {})));
})((DamagePopup = Core.DamagePopup || (Core.DamagePopup = {})));
})((Core = BD.Core || (BD.Core = {})));
})(BD || (BD = {}));
var __extends =
(this && this.__extends) ||
(function () {
var extendStatics =
Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array &&
function (d, b) {
d.__proto__ = b;
}) ||
function (d, b) {
for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
};
return function (d, b) {
extendStatics(d, b);
function __() {
this.constructor = d;
}
d.prototype =
b === null
? Object.create(b)
: ((__.prototype = b.prototype), new __());
};
})();
var BD;
(function (BD) {
var Core;
(function (Core) {
var DamagePopup;
(function (DamagePopup) {
var PopupLayer = (function (_super) {
__extends(PopupLayer, _super);
function PopupLayer() {
return (_super !== null && _super.apply(this, arguments)) || this;
}
return PopupLayer;
})(Sprite);
DamagePopup.PopupLayer = PopupLayer;
})((DamagePopup = Core.DamagePopup || (Core.DamagePopup = {})));
})((Core = BD.Core || (BD.Core = {})));
})(BD || (BD = {}));
var __extends =
(this && this.__extends) ||
(function () {
var extendStatics =
Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array &&
function (d, b) {
d.__proto__ = b;
}) ||
function (d, b) {
for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
};
return function (d, b) {
extendStatics(d, b);
function __() {
this.constructor = d;
}
d.prototype =
b === null
? Object.create(b)
: ((__.prototype = b.prototype), new __());
};
})();
var BD;
(function (BD) {
var Core;
(function (Core) {
var DamagePopup;
(function (DamagePopup) {
var Types;
(function (Types) {
var AbstractDamagePopup = (function (_super) {
__extends(AbstractDamagePopup, _super);
function AbstractDamagePopup(piece) {
var _this = _super.call(this, null) || this;
_this.anchor.x = 0.5;
_this.anchor.y = 0.5;
_this.addChild(piece);
return _this;
}
Object.defineProperty(AbstractDamagePopup.prototype, "pieceWidth", {
get: function () {
if (this.children[0] instanceof DamagePopup.Pieces.Base) {
return this.children[0].pieceWidth;
}
return 0;
},
enumerable: true,
configurable: true,
});
Object.defineProperty(AbstractDamagePopup.prototype, "pieceHeight", {
get: function () {
if (this.children[0] instanceof DamagePopup.Pieces.Base) {
return this.children[0].pieceHeight;
}
return 0;
},
enumerable: true,
configurable: true,
});
AbstractDamagePopup.prototype.update = function () {
_super.prototype.update.call(this);
};
AbstractDamagePopup.prototype.isPlaying = function () {
return false;
};
return AbstractDamagePopup;
})(Sprite);
Types.AbstractDamagePopup = AbstractDamagePopup;
})((Types = DamagePopup.Types || (DamagePopup.Types = {})));
})((DamagePopup = Core.DamagePopup || (Core.DamagePopup = {})));
})((Core = BD.Core || (BD.Core = {})));
})(BD || (BD = {}));
var __extends =
(this && this.__extends) ||
(function () {
var extendStatics =
Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array &&
function (d, b) {
d.__proto__ = b;
}) ||
function (d, b) {
for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
};
return function (d, b) {
extendStatics(d, b);
function __() {
this.constructor = d;
}
d.prototype =
b === null
? Object.create(b)
: ((__.prototype = b.prototype), new __());
};
})();
var BD;
(function (BD) {
var Core;
(function (Core) {
var DamagePopup;
(function (DamagePopup) {
var Types;
(function (Types) {
var Motionless = (function (_super) {
__extends(Motionless, _super);
function Motionless(parts) {
var _this = _super.call(this, parts) || this;
_this.setup();
return _this;
}
Motionless.prototype.setup = function () {
this.opacity = 32;
this._opacity = 32;
this._duration = 60;
};
Motionless.prototype.update = function () {
_super.prototype.update.call(this);
if (this._opacity < 256 && this._duration > 0) {
this._opacity = Math.min(255, this._opacity + 32);
}
this._duration--;
if (this._duration <= 0) {
this._opacity -= 32;
}
this.opacity = this._opacity;
};
Motionless.prototype.isPlaying = function () {
return this.opacity > 0;
};
return Motionless;
})(Types.AbstractDamagePopup);
Types.Motionless = Motionless;
})((Types = DamagePopup.Types || (DamagePopup.Types = {})));
})((DamagePopup = Core.DamagePopup || (Core.DamagePopup = {})));
})((Core = BD.Core || (BD.Core = {})));
})(BD || (BD = {}));
var __extends =
(this && this.__extends) ||
(function () {
var extendStatics =
Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array &&
function (d, b) {
d.__proto__ = b;
}) ||
function (d, b) {
for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
};
return function (d, b) {
extendStatics(d, b);
function __() {
this.constructor = d;
}
d.prototype =
b === null
? Object.create(b)
: ((__.prototype = b.prototype), new __());
};
})();
var BD;
(function (BD) {
var Core;
(function (Core) {
var DamagePopup;
(function (DamagePopup) {
var Types;
(function (Types) {
var Overlay = (function (_super) {
__extends(Overlay, _super);
function Overlay(parts, name) {
var _this = _super.call(this, parts) || this;
_this.setup(name);
return _this;
}
Overlay.initializePopup = function () {
Overlay.adjustYData = {};
};
Overlay.prototype.setup = function (name) {
var _this = this;
this._duration = 90;
this._name = name;
this._overlay = new Sprite();
this._overlay.opacity = 128;
this.children.forEach(function (x) {
return _this._overlay.addChild(x.clone());
});
this._overlay.flatten().forEach(function (x) {
return (x.blendMode = Graphics.BLEND_ADD);
});
this.addChild(this._overlay);
if (Overlay.adjustYData[this._name] === undefined) {
Overlay.adjustYData[this._name] = 0;
}
this.y = -Overlay.adjustYData[this._name];
Overlay.adjustYData[this._name] += this.pieceHeight;
};
Overlay.prototype.update = function () {
this._duration--;
this.y = -16;
this.opacity = 255 + (this._duration - 8) * 32;
this._overlay.scale.x += 0.1;
this._overlay.scale.y += 0.1;
this._overlay.opacity -= 6;
if (this._duration === 0) {
Overlay.adjustYData[this._name] -= this.pieceHeight;
}
};
Overlay.prototype.isPlaying = function () {
return this._duration > 0;
};
return Overlay;
})(Types.AbstractDamagePopup);
Types.Overlay = Overlay;
})((Types = DamagePopup.Types || (DamagePopup.Types = {})));
})((DamagePopup = Core.DamagePopup || (Core.DamagePopup = {})));
})((Core = BD.Core || (BD.Core = {})));
})(BD || (BD = {}));
var __extends =
(this && this.__extends) ||
(function () {
var extendStatics =
Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array &&
function (d, b) {
d.__proto__ = b;
}) ||
function (d, b) {
for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
};
return function (d, b) {
extendStatics(d, b);
function __() {
this.constructor = d;
}
d.prototype =
b === null
? Object.create(b)
: ((__.prototype = b.prototype), new __());
};
})();
var BD;
(function (BD) {
var Core;
(function (Core) {
var DamagePopup;
(function (DamagePopup) {
var Types;
(function (Types) {
var RandomBounce = (function (_super) {
__extends(RandomBounce, _super);
function RandomBounce(parts, name) {
var _this = _super.call(this, parts) || this;
_this.setup(name);
return _this;
}
RandomBounce.prototype.setup = function (name) {
this._duration = 90;
this._name = name;
this._realX = 0;
this._realY = -8;
this._gravity = 0.3;
this._horizon = 32;
this._xVelocityDispersion = [-1.25, 1.25];
this._yVelocityDispersion = [-4, -6];
var xvd = this._xVelocityDispersion;
this._xVelocity = xvd[0] + Math.random() * (xvd[1] - xvd[0]);
var yvd = this._yVelocityDispersion;
this._yVelocity = yvd[0] + Math.random() * (yvd[1] - yvd[0]);
this._restitution = 0.64;
this._maxBoundCount = Infinity;
};
RandomBounce.prototype.update = function () {
this._duration--;
this.x = Math.round(this._realX);
this.y = Math.round(this._realY);
if (this._maxBoundCount >= 0) {
this._realX += this._xVelocity;
this._realY += this._yVelocity;
this._yVelocity += this._gravity;
if (this._realY > this._horizon) {
this._realY = this._horizon;
this._yVelocity = -this._yVelocity * this._restitution;
this._maxBoundCount--;
if (this._yVelocity > -1) {
this._maxBoundCount = -1;
}
}
}
if (this._duration < 0) {
this.opacity -= 16;
}
};
RandomBounce.prototype.isPlaying = function () {
return this.opacity > 0;
};
return RandomBounce;
})(Types.AbstractDamagePopup);
Types.RandomBounce = RandomBounce;
})((Types = DamagePopup.Types || (DamagePopup.Types = {})));
})((DamagePopup = Core.DamagePopup || (Core.DamagePopup = {})));
})((Core = BD.Core || (BD.Core = {})));
})(BD || (BD = {}));
var __extends =
(this && this.__extends) ||
(function () {
var extendStatics =
Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array &&
function (d, b) {
d.__proto__ = b;
}) ||
function (d, b) {
for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
};
return function (d, b) {
extendStatics(d, b);
function __() {
this.constructor = d;
}
d.prototype =
b === null
? Object.create(b)
: ((__.prototype = b.prototype), new __());
};
})();
var BD;
(function (BD) {
var Core;
(function (Core) {
var DamagePopup;
(function (DamagePopup) {
var Types;
(function (Types) {
var Rise = (function (_super) {
__extends(Rise, _super);
function Rise(parts, name) {
var _this = _super.call(this, parts) || this;
_this.setup(name);
return _this;
}
Rise.initializePopup = function () {
Rise.RisingPopups = {};
};
Rise.prototype.setup = function (name) {
this._duration = 120;
this._name = name;
this._realX = 0;
this._realY = 0;
this._riseSpeed = 0.66;
this.visible = false;
};
Rise.prototype.update = function () {
if (!this.visible) {
if (this._isReady()) {
Rise.RisingPopups[this._name] = this;
this.visible = true;
}
return;
}
this._duration--;
this.x = Math.round(this._realX);
this.y = Math.round(this._realY);
this._realY -= this._riseSpeed;
if (this._duration < 0) {
if (Rise.RisingPopups[this._name] === this) {
Rise.RisingPopups[this._name] = null;
}
this.opacity -= 6;
}
};
Rise.prototype.isPlaying = function () {
return this.opacity > 0;
};
Rise.prototype._isReady = function () {
var currentPopup = Rise.RisingPopups[this._name];
if (currentPopup == null || currentPopup === this) {
return true;
}
if (
-this.pieceHeight / 2 >
currentPopup.y + currentPopup.pieceHeight / 2
) {
return true;
}
return false;
};
return Rise;
})(Types.AbstractDamagePopup);
Types.Rise = Rise;
})((Types = DamagePopup.Types || (DamagePopup.Types = {})));
})((DamagePopup = Core.DamagePopup || (Core.DamagePopup = {})));
})((Core = BD.Core || (BD.Core = {})));
})(BD || (BD = {}));
var __extends =
(this && this.__extends) ||
(function () {
var extendStatics =
Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array &&
function (d, b) {
d.__proto__ = b;
}) ||
function (d, b) {
for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
};
return function (d, b) {
extendStatics(d, b);
function __() {
this.constructor = d;
}
d.prototype =
b === null
? Object.create(b)
: ((__.prototype = b.prototype), new __());
};
})();
var BD;
(function (BD) {
var Core;
(function (Core) {
var DamagePopup;
(function (DamagePopup) {
var Types;
(function (Types) {
var SimpleBounce = (function (_super) {
__extends(SimpleBounce, _super);
function SimpleBounce(parts, name) {
var _this = _super.call(this, parts) || this;
_this.setup(name);
return _this;
}
SimpleBounce.initializePopup = function () {
SimpleBounce.adjustYData = {};
};
SimpleBounce.prototype.setup = function (name) {
this._duration = 90;
this._name = name;
this._realX = 0;
this._realY = 16;
this._yVelocity = -4.8;
this._gravity = 0.3;
this._horizon = 8;
if (SimpleBounce.adjustYData[this._name] === undefined) {
SimpleBounce.adjustYData[this._name] = 0;
}
this.pivot.y = -SimpleBounce.adjustYData[this._name];
SimpleBounce.adjustYData[this._name] += this.pieceHeight;
};
SimpleBounce.prototype.update = function () {
this._duration--;
this.x = Math.round(this._realX);
this.y = Math.round(this._realY);
this._realY += this._yVelocity;
if (this._realY > this._horizon) {
this._realY = this._horizon;
}
this._yVelocity += this._gravity;
if (this._duration === 48) {
SimpleBounce.adjustYData[this._name] -= this.pieceHeight;
}
if (this._duration < 0) {
this.opacity -= 16;
}
};
SimpleBounce.prototype.isPlaying = function () {
return this.opacity > 0;
};
return SimpleBounce;
})(Types.AbstractDamagePopup);
Types.SimpleBounce = SimpleBounce;
})((Types = DamagePopup.Types || (DamagePopup.Types = {})));
})((DamagePopup = Core.DamagePopup || (Core.DamagePopup = {})));
})((Core = BD.Core || (BD.Core = {})));
})(BD || (BD = {}));
var __extends =
(this && this.__extends) ||
(function () {
var extendStatics =
Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array &&
function (d, b) {
d.__proto__ = b;
}) ||
function (d, b) {
for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
};
return function (d, b) {
extendStatics(d, b);
function __() {
this.constructor = d;
}
d.prototype =
b === null
? Object.create(b)
: ((__.prototype = b.prototype), new __());
};
})();
var BD;
(function (BD) {
var Core;
(function (Core) {
var HUD;
(function (HUD) {
var BattleObjects;
(function (BattleObjects) {
BattleObjects.defs = BD.Core.Property.PropertyUtility.definitions;
BattleObjects.PropertyChanged = BD.Core.Property.PropertyChanged;
var Base = (function (_super) {
__extends(Base, _super);
function Base(obj) {
var _this = _super.call(this, null) || this;
_this._initObjectRaw = obj;
_this._internalVisibility = true;
return _this;
}
Object.defineProperty(Base.prototype, "propertyChanged", {
get: function () {
return this._propertyChanged;
},
set: function (value) {
this._propertyChanged = value;
},
enumerable: true,
configurable: true,
});
Base.prototype.setup = function (parent) {
parent.addChild(this);
var obj = this._initObjectRaw;
this._initUpdateCount();
this.propertyChanged = new BattleObjects.PropertyChanged();
this._setProperties(obj.properties);
this._setPropertyFunctions = {};
this._ready = true;
this._initObjectRaw = null;
this._createBattleObject(obj, this);
this._updateInternal();
this._updateCommonProperties();
this._setProperty(BattleObjects.defs.x);
this._setProperty(BattleObjects.defs.y);
this._setOneTimeProperty();
this._updatePropertyInternal();
this._initializeInternal(obj);
};
Base.prototype._setOneTimeProperty = function () {};
Base.prototype._initializeInternal = function (obj) {};
Base.prototype._onceUpdateProperties = function (obj) {};
Base.prototype.initializeDragging = function () {
this._touchStratPoint = new Point(0, 0);
this._hold = false;
this._touching = false;
this._dragging = false;
this._pressCount = 0;
};
Base.prototype.update = function () {
if (!this._ready) {
return;
}
this._updateInternal();
this._updateProperties();
this._updateCommonProperties();
_super.prototype.update.call(this);
};
Base.prototype._updateCommonProperties = function () {
if (this._internalVisibility) {
this._setProperty(BattleObjects.defs.visible);
}
};
Base.prototype._updateProperties = function () {
if (!Core.Manager.isStopHUD() && this._updateCount++ % 4 === 0) {
this._updateCommonProperties();
this._updatePropertyInternal();
this.propertyChanged.update();
}
};
Base.prototype._updateInternal = function () {};
Base.prototype._updatePropertyInternal = function () {};
Base.prototype._initUpdateCount = function () {
this._updateCount = this.spriteId % 4;
};
Base.prototype.containable = function () {
return false;
};
Base.prototype._createBattleObject = function (obj, parent) {
var _this = this;
if (!this.containable || !obj.children) {
return;
}
obj.children.forEach(function (x) {
var child = _this._createSpriteBattleObject(x);
child.setup(parent);
});
};
Base.prototype._createSpriteBattleObject = function (obj) {
try {
var o = eval(
"new BD.Core.HUD.BattleObjects." +
obj.properties["type"] +
"(obj)"
);
return o;
} catch (e) {
throw (
'failed _createSpriteBattleObject "' +
obj.properties["type"] +
'"'
);
}
};
Base.prototype.dragging = function () {
if (!this.draggable()) {
return;
}
if (
TouchInput.isTriggered() &&
this.isTouched() &&
this.isActive()
) {
this._touchStratPoint.x = TouchInput.x;
this._touchStratPoint.y = TouchInput.y;
this._touching = true;
} else if (TouchInput.isReleased() && this._touching) {
this.dragMove();
this.resetPressCount();
}
if (this._touching) {
this.dragMove();
}
return this._touching;
};
Base.prototype.dragMove = function () {
var newX = this.x + (TouchInput.x - this._touchStratPoint.x);
var newY = this.y + (TouchInput.y - this._touchStratPoint.y);
if (TouchInput.isReleased()) {
this.endDrag(newX, newY);
}
this.x = newX;
this.y = newY;
};
Base.prototype.endDrag = function (newX, newY) {
this._setPropertyFunctions[BattleObjects.defs.x.key] = null;
this._setPropertyFunctions[BattleObjects.defs.y.key] = null;
this._properties["x"] = newX;
this._properties["y"] = newY;
this.x = newX;
this.y = newY;
var name = this._properties["name"];
BD.Studio.Utilities.ObjectController.setProperties(
name,
this._properties
);
};
Base.prototype.draggable = function () {
return false;
};
Base.prototype.updatePressCount = function () {
this._pressCount++;
};
Base.prototype.resetPressCount = function () {
this._pressCount = 0;
this._touching = false;
};
Base.prototype.isActive = function () {
var node = this;
while (node) {
if (!node.visible) {
return false;
}
node = node.parent;
}
return true;
};
Base.prototype.isTouched = function () {
var x = this.canvasToLocalX(TouchInput.x);
var y = this.canvasToLocalY(TouchInput.y);
return x >= 0 && y >= 0 && x < this.width && y < this.height;
};
Base.prototype.canvasToLocalX = function (x) {
var node = this;
while (node) {
x -= node.x;
node = node.parent;
}
return x;
};
Base.prototype.canvasToLocalY = function (y) {
var node = this;
while (node) {
y -= node.y;
node = node.parent;
}
return y;
};
Base.prototype._setProperties = function (properties) {
this._properties = properties;
};
Base.prototype._getProperties = function () {
if (this._properties === null) {
return {};
}
return this._properties;
};
Base.prototype._getProperty = function (key) {
if (this._getProperties()[key] == null) {
return BattleObjects.defs[key].defaultValue;
}
return this._getProperties()[key];
};
Base.prototype._valueEvaluation = function (key) {
var func = this._setPropertyFunctions[key];
if (func) {
return func.call(this.getContext());
} else {
var value = "return " + this._getProperty(key);
this._setPropertyFunctions[key] =
BD.Core.Property.PropertyUtility.makeFunction(
key,
value,
this.getContext()
);
return this._valueEvaluation(key);
}
};
Base.prototype._setProperty = function (def) {
var key = def.key;
var value = this._valueEvaluation(key);
if (this[key] !== value) {
this.propertyChanged.raise(key);
this[key] = value;
}
};
Base.prototype.getContext = function () {
return this.parent.getContext();
};
Base.prototype.getObjectName = function () {
return this._properties["name"];
};
Base.prototype.setVisibility = function (visibility) {
if (visibility) {
this._internalVisibility = true;
this._setProperty(BattleObjects.defs.visible);
} else {
this._internalVisibility = false;
this.visible = false;
}
};
Base.prototype._scalePercentToDecimal = function (scale) {
return scale / 100;
};
Base.prototype._setScale = function (sprite) {
var s = sprite ? sprite : this;
if (this.zoom === undefined) {
var zx = this._scalePercentToDecimal(this.zoomX);
var zy = this._scalePercentToDecimal(this.zoomY);
s.scale.set(zx, zy);
} else {
var z = this._scalePercentToDecimal(this.zoom);
s.scale.set(z, z);
}
};
Base.prototype._degreeToSkew = function (deg) {
var d = deg || 0;
if (Math.abs(d) === 90 || Math.abs(d) === 270) {
d -= 1;
}
return Math.tan((d * Math.PI) / 180);
};
Base.prototype._enabledSkew = function () {
return this.skewAngleX !== 0 || this.skewAngleY !== 0;
};
Base.prototype._setSkewAngle = function (sprite) {
if (!this._enabledSkew()) {
return;
}
var s = sprite ? sprite : this;
this.worldTransform.c = this._degreeToSkew(this.skewAngleX);
this.worldTransform.b = this._degreeToSkew(this.skewAngleY);
this.worldTransform.tx = this.x;
this.worldTransform.ty = this.y;
this.worldTransform.decompose(this.transform);
};
return Base;
})(Sprite);
BattleObjects.Base = Base;
})((BattleObjects = HUD.BattleObjects || (HUD.BattleObjects = {})));
})((HUD = Core.HUD || (Core.HUD = {})));
})((Core = BD.Core || (BD.Core = {})));
})(BD || (BD = {}));
var __extends =
(this && this.__extends) ||
(function () {
var extendStatics =
Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array &&
function (d, b) {
d.__proto__ = b;
}) ||
function (d, b) {
for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
};
return function (d, b) {
extendStatics(d, b);
function __() {
this.constructor = d;
}
d.prototype =
b === null
? Object.create(b)
: ((__.prototype = b.prototype), new __());
};
})();
var BD;
(function (BD) {
var Core;
(function (Core) {
var HUD;
(function (HUD) {
var BattleObjects;
(function (BattleObjects) {
var Battler = (function (_super) {
__extends(Battler, _super);
function Battler() {
return (_super !== null && _super.apply(this, arguments)) || this;
}
Battler.prototype.isTouched = function () {
var x = this.canvasToLocalX(TouchInput.x);
var y = this.canvasToLocalY(TouchInput.y);
return x >= 0 && y >= 0 && x < 144 && y < 144;
};
Battler.prototype.draggable = function () {
return true;
};
Battler.prototype._initializeInternal = function (properties) {
this._createBattler();
};
Battler.prototype._setOneTimeProperty = function () {
this._setProperty(BattleObjects.defs.overlayOffsetX);
this._setProperty(BattleObjects.defs.overlayOffsetY);
this._setProperty(BattleObjects.defs.isOverlayOnBottom);
this._setProperty(BattleObjects.defs.zoom);
this._setProperty(BattleObjects.defs.maskImage);
this._setProperty(BattleObjects.defs.maskImageX);
this._setProperty(BattleObjects.defs.maskImageY);
};
Battler.prototype._updateInternal = function () {};
Battler.prototype._updatePropertyInternal = function () {};
Battler.prototype._createBattler = function () {
this.removeChildren();
var context = this.getContext();
if (!(context["b"] instanceof Game_Battler)) {
return;
}
var battler = context["b"];
battler.setXpb();
var s = new BattleObjects.Components.XPStyleBattler(battler);
s.setBattler(battler);
s.setOverlayOffset({
x: this.overlayOffsetX,
y: this.overlayOffsetY,
onBottom: this.isOverlayOnBottom,
});
this.addChild(s);
this._setScale(s);
s.mask = this._createMask();
};
Battler.prototype._createMask = function () {
var mask = undefined;
if (this.maskImage !== "") {
mask = new Sprite(ImageManager.loadThemeImage(this.maskImage));
mask.x = this.maskImageX;
mask.y = this.maskImageY;
this.parent.addChild(mask);
}
return mask;
};
return Battler;
})(BattleObjects.Base);
BattleObjects.Battler = Battler;
})((BattleObjects = HUD.BattleObjects || (HUD.BattleObjects = {})));
})((HUD = Core.HUD || (Core.HUD = {})));
})((Core = BD.Core || (BD.Core = {})));
})(BD || (BD = {}));
var __extends =
(this && this.__extends) ||
(function () {
var extendStatics =
Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array &&
function (d, b) {
d.__proto__ = b;
}) ||
function (d, b) {
for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
};
return function (d, b) {
extendStatics(d, b);
function __() {
this.constructor = d;
}
d.prototype =
b === null
? Object.create(b)
: ((__.prototype = b.prototype), new __());
};
})();
var BD;
(function (BD) {
var Core;
(function (Core) {
var HUD;
(function (HUD) {
var BattleObjects;
(function (BattleObjects) {
var CircleGauge = (function (_super) {
__extends(CircleGauge, _super);
function CircleGauge() {
return (_super !== null && _super.apply(this, arguments)) || this;
}
CircleGauge.prototype.draggable = function () {
return true;
};
CircleGauge.prototype._initializeInternal = function (properties) {
this._sourceBitmap = null;
this._canvasPattern = null;
this._displayRate = null;
this.propertyChanged.addPropertyChanged(
BattleObjects.defs.fileName.key,
this._createGauge,
this
);
this.propertyChanged.addPropertyChanged(
BattleObjects.defs.value.key,
this._updateRate,
this
);
this.propertyChanged.addPropertyChanged(
BattleObjects.defs.maxValue.key,
this._updateRate,
this
);
this._createGauge();
};
CircleGauge.prototype._setOneTimeProperty = function () {
this._setProperty(BattleObjects.defs.fileName);
this._setProperty(BattleObjects.defs.startAngle);
this._setProperty(BattleObjects.defs.endAngle);
this._setProperty(BattleObjects.defs.radius);
this._setProperty(BattleObjects.defs.lineWidth);
this._setProperty(BattleObjects.defs.animationSpeed);
};
CircleGauge.prototype._updateInternal = function () {
this._updateGauge();
};
CircleGauge.prototype._updatePropertyInternal = function () {
this._setProperty(BattleObjects.defs.value);
this._setProperty(BattleObjects.defs.maxValue);
};
CircleGauge.prototype._createGauge = function () {
this._lastDrawRate = null;
this._updateRate();
this._sourceBitmap = ImageManager.loadThemeImage(this.fileName);
this.bitmap = new Bitmap(
this._sourceBitmap.width,
this._sourceBitmap.height
);
this._createCanvasPattern();
this._ctx = this.bitmap.context;
if (!this._sourceBitmap.isReady()) {
this.propertyChanged.raise("fileName");
}
};
CircleGauge.prototype._createCanvasPattern = function () {
var ctx = this.bitmap.context;
this._canvasPattern = ctx.createPattern(
this._sourceBitmap.baseTexture.source,
"no-repeat"
);
};
CircleGauge.prototype._updateGauge = function () {
this._displayRate = Core.Utils.Interpolator.smooth(
this._currentRate,
this._displayRate,
this.animationSpeed,
0.001
);
this._drawGauge();
};
CircleGauge.prototype._updateRate = function () {
this._currentRate = this.value / this.maxValue;
if (this._displayRate === null) {
this._displayRate = this._currentRate;
}
};
CircleGauge.prototype._drawGauge = function () {
if (!this._ctx || this._lastDrawRate === this._displayRate) {
return;
}
this.bitmap.clear();
this._ctx.beginPath();
var x = this.width / 2;
var y = this.height / 2;
var startAngle = Math.radians(this.startAngle);
var endAngle = Math.radians(
this.startAngle -
(this.startAngle - this.endAngle) * this._displayRate
);
this._ctx.arc(x, y, this.radius, startAngle, endAngle, false);
this._ctx.lineWidth = this.lineWidth;
this._ctx.strokeStyle = this._canvasPattern;
this._ctx.stroke();
this._lastDrawRate = this._displayRate;
};
return CircleGauge;
})(BattleObjects.Base);
BattleObjects.CircleGauge = CircleGauge;
})((BattleObjects = HUD.BattleObjects || (HUD.BattleObjects = {})));
})((HUD = Core.HUD || (Core.HUD = {})));
})((Core = BD.Core || (BD.Core = {})));
})(BD || (BD = {}));
var __extends =
(this && this.__extends) ||
(function () {
var extendStatics =
Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array &&
function (d, b) {
d.__proto__ = b;
}) ||
function (d, b) {
for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
};
return function (d, b) {
extendStatics(d, b);
function __() {
this.constructor = d;
}
d.prototype =
b === null
? Object.create(b)
: ((__.prototype = b.prototype), new __());
};
})();
var BD;
(function (BD) {
var Core;
(function (Core) {
var HUD;
(function (HUD) {
var BattleObjects;
(function (BattleObjects) {
var Container = (function (_super) {
__extends(Container, _super);
function Container() {
return (_super !== null && _super.apply(this, arguments)) || this;
}
Container.prototype._initializeInternal = function (properties) {};
Container.prototype._setOneTimeProperty = function () {};
Container.prototype._updateInternal = function () {};
Container.prototype._updatePropertyInternal = function () {};
Container.prototype.containable = function () {
return true;
};
return Container;
})(BattleObjects.Base);
BattleObjects.Container = Container;
})((BattleObjects = HUD.BattleObjects || (HUD.BattleObjects = {})));
})((HUD = Core.HUD || (Core.HUD = {})));
})((Core = BD.Core || (BD.Core = {})));
})(BD || (BD = {}));
var __extends =
(this && this.__extends) ||
(function () {
var extendStatics =
Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array &&
function (d, b) {
d.__proto__ = b;
}) ||
function (d, b) {
for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
};
return function (d, b) {
extendStatics(d, b);
function __() {
this.constructor = d;
}
d.prototype =
b === null
? Object.create(b)
: ((__.prototype = b.prototype), new __());
};
})();
var BD;
(function (BD) {
var Core;
(function (Core) {
var HUD;
(function (HUD) {
var BattleObjects;
(function (BattleObjects) {
var HorizontalGauge = (function (_super) {
__extends(HorizontalGauge, _super);
function HorizontalGauge() {
return (_super !== null && _super.apply(this, arguments)) || this;
}
HorizontalGauge.prototype.draggable = function () {
return true;
};
HorizontalGauge.prototype.isTouched = function () {
var x = this.canvasToLocalX(TouchInput.x);
var y = this.canvasToLocalY(TouchInput.y);
var bitmap = ImageManager.loadThemeImage(this.fileName);
bitmap.smooth = true;
var nh = bitmap.height / this.maxPattern;
return x >= 0 && y >= 0 && x < bitmap.width && y < nh;
};
HorizontalGauge.prototype._initializeInternal = function (
properties
) {
this._displayRate = null;
this._gaugeWidth = 4;
this._gaugeHeight = 4;
this.propertyChanged.addPropertyChanged(
BattleObjects.defs.fileName.key,
this._setGauge,
this
);
this.propertyChanged.addPropertyChanged(
BattleObjects.defs.value.key,
this._updateRate,
this
);
this.propertyChanged.addPropertyChanged(
BattleObjects.defs.maxValue.key,
this._updateRate,
this
);
this._setSkewAngle();
this._setGauge();
};
HorizontalGauge.prototype._setOneTimeProperty = function () {
this._setProperty(BattleObjects.defs.maxPattern);
this._setProperty(BattleObjects.defs.animationSpeed);
this._setProperty(BattleObjects.defs.fileName);
this._setProperty(BattleObjects.defs.skewAngleX);
this._setProperty(BattleObjects.defs.skewAngleY);
};
HorizontalGauge.prototype._updateInternal = function () {
this._updateGauge();
};
HorizontalGauge.prototype._updatePropertyInternal = function () {
this._setProperty(BattleObjects.defs.value);
this._setProperty(BattleObjects.defs.maxValue);
this._setProperty(BattleObjects.defs.pattern);
};
HorizontalGauge.prototype._setGauge = function () {
this.bitmap = ImageManager.loadThemeImage(this.fileName);
this._updateRate();
if (!this.bitmap.isReady()) {
this.propertyChanged.raise("fileName");
return;
}
this._gaugeWidth = this.bitmap.width;
this._gaugeHeight = this.bitmap.height / this.maxPattern;
};
HorizontalGauge.prototype._updateRate = function () {
this._currentRate = this.value / this.maxValue;
if (this._displayRate === null) {
this._displayRate = this._currentRate;
}
};
HorizontalGauge.prototype._updateGauge = function () {
this._displayRate = Core.Utils.Interpolator.smooth(
this._currentRate,
this._displayRate,
this.animationSpeed,
0.001
);
this.setFrame(
0,
this._gaugeHeight * this.pattern,
this._gaugeWidth * this._displayRate,
this._gaugeHeight
);
};
return HorizontalGauge;
})(BattleObjects.Base);
BattleObjects.HorizontalGauge = HorizontalGauge;
})((BattleObjects = HUD.BattleObjects || (HUD.BattleObjects = {})));
})((HUD = Core.HUD || (Core.HUD = {})));
})((Core = BD.Core || (BD.Core = {})));
})(BD || (BD = {}));
var __extends =
(this && this.__extends) ||
(function () {
var extendStatics =
Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array &&
function (d, b) {
d.__proto__ = b;
}) ||
function (d, b) {
for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
};
return function (d, b) {
extendStatics(d, b);
function __() {
this.constructor = d;
}
d.prototype =
b === null
? Object.create(b)
: ((__.prototype = b.prototype), new __());
};
})();
var BD;
(function (BD) {
var Core;
(function (Core) {
var HUD;
(function (HUD) {
var BattleObjects;
(function (BattleObjects) {
var Image = (function (_super) {
__extends(Image, _super);
function Image() {
return (_super !== null && _super.apply(this, arguments)) || this;
}
Image.prototype.draggable = function () {
return true;
};
Image.prototype._initializeInternal = function (properties) {
this.propertyChanged.addPropertyChanged(
BattleObjects.defs.fileName.key,
this._setImage,
this
);
this._setImage();
};
Image.prototype._setOneTimeProperty = function () {
this._setProperty(BattleObjects.defs.fileName);
};
Image.prototype._updateInternal = function () {};
Image.prototype._updatePropertyInternal = function () {};
Image.prototype._setImage = function () {
this.bitmap = ImageManager.loadThemeImage(this.fileName);
if (!this.bitmap.isReady()) {
this.propertyChanged.raise("fileName");
}
if (this._internalVisibility) {
this.setVisibility(this.fileName.length > 0);
}
};
return Image;
})(BattleObjects.Base);
BattleObjects.Image = Image;
})((BattleObjects = HUD.BattleObjects || (HUD.BattleObjects = {})));
})((HUD = Core.HUD || (Core.HUD = {})));
})((Core = BD.Core || (BD.Core = {})));
})(BD || (BD = {}));
var __extends =
(this && this.__extends) ||
(function () {
var extendStatics =
Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array &&
function (d, b) {
d.__proto__ = b;
}) ||
function (d, b) {
for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
};
return function (d, b) {
extendStatics(d, b);
function __() {
this.constructor = d;
}
d.prototype =
b === null
? Object.create(b)
: ((__.prototype = b.prototype), new __());
};
})();
var BD;
(function (BD) {
var Core;
(function (Core) {
var HUD;
(function (HUD) {
var BattleObjects;
(function (BattleObjects) {
var Number = (function (_super) {
__extends(Number, _super);
function Number() {
return (_super !== null && _super.apply(this, arguments)) || this;
}
Number.prototype.draggable = function () {
return true;
};
Number.prototype.isTouched = function () {
var x = this.canvasToLocalX(TouchInput.x);
var y = this.canvasToLocalY(TouchInput.y);
return x >= 0 && y >= 0 && x < 128 && y < 128;
};
Number.prototype._initializeInternal = function (properties) {
this._displayValue = null;
this.propertyChanged.addPropertyChanged(
BattleObjects.defs.fileName.key,
this._createDigits,
this
);
this.propertyChanged.addPropertyChanged(
BattleObjects.defs.digits.key,
this._createDigits,
this
);
this._createDigits();
};
Number.prototype._setOneTimeProperty = function () {
this._setProperty(BattleObjects.defs.maxPattern);
this._setProperty(BattleObjects.defs.digits);
this._setProperty(BattleObjects.defs.zeroSuppress);
this._setProperty(BattleObjects.defs.horizontalSpacing);
this._setProperty(BattleObjects.defs.horizontalAlignment);
this._setProperty(BattleObjects.defs.verticalAlignment);
this._setProperty(BattleObjects.defs.animationSpeed);
this._setProperty(BattleObjects.defs.fileName);
};
Number.prototype._updateInternal = function () {
this._updateDisplayValue();
};
Number.prototype._updatePropertyInternal = function () {
this._setProperty(BattleObjects.defs.value);
this._setProperty(BattleObjects.defs.pattern);
};
Number.prototype._updateDisplayValue = function () {
if (this._displayValue === null) {
this._displayValue = this.value;
this._updateDigits();
} else if (this._displayValue !== this.value) {
this._displayValue = Core.Utils.Interpolator.smooth(
this.value,
this._displayValue,
this.animationSpeed,
0.1
);
this._updateDigits();
}
};
Number.prototype._createDigits = function () {
this.removeChildren();
var bitmap = ImageManager.loadThemeImage(this.fileName);
this._numberWidth = bitmap.width / 10;
this._numberHeight = bitmap.height / this.maxPattern;
for (var i = 0; i < this.digits; i++) {
var s = new Sprite(bitmap);
s.setFrame(0, 0, this._numberWidth, this._numberHeight);
this.addChild(s);
}
this._updateDigits();
if (!bitmap.isReady()) {
this.children.forEach(function (x) {
return (x.visible = false);
});
this.propertyChanged.raise("fileName");
}
};
Number.prototype._updateDigits = function () {
if (this._displayValue === null) {
this._displayValue = this.value;
}
var v = Math.abs(Math.round(this._displayValue));
var nums = v
.toString()
.split("")
.map(function (x) {
return parseInt(x);
})
.reverse();
var y = this._numberHeight * this.pattern;
for (var i = 0; i < this.digits; i++) {
var s = this.children[i];
s.x = this._getNumberPosition(
i + 1,
this.zeroSuppress
? Math.min(this.digits, nums.length)
: this.digits,
this._numberWidth
);
if (i < nums.length) {
s.visible = true;
s.setFrame(
this._numberWidth * nums[i],
y,
this._numberWidth,
this._numberHeight
);
} else if (this.zeroSuppress) {
s.visible = false;
} else {
s.visible = true;
s.setFrame(0, 0, this._numberWidth, this._numberHeight);
}
}
};
Number.prototype._getNumberPosition = function (
digit,
length,
numberWidth
) {
var baseX;
switch (this.horizontalAlignment) {
case Core.Consts.Enums.HorizontalAlignment.Left:
baseX =
numberWidth * length + this.horizontalSpacing * (length - 1);
break;
case Core.Consts.Enums.HorizontalAlignment.Center:
var aw =
numberWidth * length + this.horizontalSpacing * (length - 1);
var bw =
numberWidth * this.digits +
this.horizontalSpacing * (this.digits - 1);
baseX = bw - (bw - aw) / 2;
break;
case Core.Consts.Enums.HorizontalAlignment.Right:
baseX =
numberWidth * this.digits +
this.horizontalSpacing * (this.digits - 1);
break;
default:
baseX = 0;
break;
}
return (
baseX -
(numberWidth * digit + this.horizontalSpacing * (digit - 1))
);
};
return Number;
})(BattleObjects.Base);
BattleObjects.Number = Number;
})((BattleObjects = HUD.BattleObjects || (HUD.BattleObjects = {})));
})((HUD = Core.HUD || (Core.HUD = {})));
})((Core = BD.Core || (BD.Core = {})));
})(BD || (BD = {}));
var __extends =
(this && this.__extends) ||
(function () {
var extendStatics =
Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array &&
function (d, b) {
d.__proto__ = b;
}) ||
function (d, b) {
for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
};
return function (d, b) {
extendStatics(d, b);
function __() {
this.constructor = d;
}
d.prototype =
b === null
? Object.create(b)
: ((__.prototype = b.prototype), new __());
};
})();
var BD;
(function (BD) {
var Core;
(function (Core) {
var HUD;
(function (HUD) {
var BattleObjects;
(function (BattleObjects) {
var PartyStatusContainer = (function (_super) {
__extends(PartyStatusContainer, _super);
function PartyStatusContainer() {
return (_super !== null && _super.apply(this, arguments)) || this;
}
PartyStatusContainer.prototype._initializeInternal = function (
properties
) {
this._rawProperties = properties;
this._setPosition();
};
PartyStatusContainer.prototype._updateInternal = function () {
this._watchMemberChange();
};
PartyStatusContainer.prototype._setOneTimeProperty = function () {
this._setProperty(BattleObjects.defs.width);
this._setProperty(BattleObjects.defs.height);
this._setProperty(BattleObjects.defs.horizontalAlignment);
this._setProperty(BattleObjects.defs.verticalAlignment);
this._setProperty(BattleObjects.defs.actorStatusWidth);
this._setProperty(BattleObjects.defs.actorStatusHeight);
this._setProperty(BattleObjects.defs.horizontalSpacing);
this._setProperty(BattleObjects.defs.verticalSpacing);
this._setProperty(BattleObjects.defs.orientation);
this._setProperty(BattleObjects.defs.maxRows);
this._setProperty(BattleObjects.defs.maxLines);
this._setProperty(BattleObjects.defs.isBricks);
};
PartyStatusContainer.prototype.containable = function () {
return true;
};
PartyStatusContainer.prototype._createBattleObject = function (
object,
parent
) {
var _this = this;
this._lastBattleMembers = $gameParty.battleMembers();
this.children = [];
$gameParty.battleMembers().forEach(function (x) {
x.initHudParamCache();
var c = new BattleObjects.Components.BattlerContextContainer(
x,
_this
);
_super.prototype._createBattleObject.call(_this, object, c);
x.refresh();
});
};
PartyStatusContainer.prototype._setPosition = function () {
var _this = this;
var positions;
switch (this.orientation) {
case Core.Consts.Enums.Orientation.Horizontal:
positions = this._calcAllBattlersPosition(
this.maxRows,
this.actorStatusWidth,
this.horizontalSpacing,
this.horizontalAlignment,
this.actorStatusHeight,
this.verticalSpacing,
this.verticalAlignment,
this._calcActorX,
this._calcActorY,
function (a, b) {
return { x: a, y: b };
}
);
break;
case Core.Consts.Enums.Orientation.Vertical:
positions = this._calcAllBattlersPosition(
this.maxLines,
this.actorStatusHeight,
this.verticalSpacing,
this.verticalAlignment,
this.actorStatusWidth,
this.horizontalSpacing,
this.horizontalAlignment,
this._calcActorY,
this._calcActorX,
function (a, b) {
return { x: b, y: a };
}
);
break;
default:
positions = [];
break;
}
if (positions.length === 0) {
return;
}
this.children.forEach(function (s, i) {
s.position.set(positions[i].x, positions[i].y);
var abs = s.absolutePosition();
s.b._hitTestRectangle = {
x: abs.x,
y: abs.y,
width: _this.actorStatusWidth,
height: _this.actorStatusHeight,
};
});
};
PartyStatusContainer.prototype._calcAllBattlersPosition = function (
maxMainNum,
mainAxisSize,
mainAxisSpacing,
mainAxisAlignment,
subAxisSize,
subAxisSpacing,
subAxisAlignment,
mainAxisCalcFunc,
subAxisCalcFunc,
positionPushFunc
) {
var _this = this;
var membersLength = $gameParty.battleMembers().length;
var eachElementNumbers = [];
var maxElementNum = Math.ceil(membersLength / maxMainNum);
for (var i = 0; i < maxElementNum; i++) {
if (membersLength >= maxMainNum) {
eachElementNumbers.push(maxMainNum);
membersLength -= maxMainNum;
} else {
eachElementNumbers.push(membersLength);
}
}
if (this.isBricks && eachElementNumbers.length >= 2) {
var last = eachElementNumbers[eachElementNumbers.length - 1];
if (last < maxMainNum) {
eachElementNumbers[eachElementNumbers.length - 1] =
maxMainNum - 1;
}
}
var subNum = eachElementNumbers.length;
var totalSubSize =
subNum * subAxisSize + subAxisSpacing * (subNum - 1);
var positions = [];
eachElementNumbers.forEach(function (mainNum, i) {
var b = subAxisCalcFunc.call(
_this,
i,
totalSubSize,
subAxisAlignment
);
var totalMainSize =
mainNum * mainAxisSize + mainAxisSpacing * (mainNum - 1);
for (var i_1 = 0; i_1 < mainNum; i_1++) {
var a = mainAxisCalcFunc.call(
_this,
i_1,
totalMainSize,
mainAxisAlignment
);
positions.push(positionPushFunc(a, b));
}
});
return positions;
};
PartyStatusContainer.prototype._calcActorCoordinate = function (
alignment,
pos,
size,
actorSize,
spacing,
total
) {
var base = pos * actorSize + spacing * pos;
var p = 0;
switch (alignment) {
case 0:
p = base;
break;
case 1:
p = (size - total) / 2 + base;
break;
case 2:
p = size - total + base;
break;
}
return Math.floor(p);
};
PartyStatusContainer.prototype._calcActorX = function (
row,
totalWidth,
alignment
) {
return this._calcActorCoordinate(
alignment,
row,
this.width,
this.actorStatusWidth,
this.horizontalSpacing,
totalWidth
);
};
PartyStatusContainer.prototype._calcActorY = function (
line,
totalHeight,
alignment
) {
return this._calcActorCoordinate(
alignment,
line,
this.height,
this.actorStatusHeight,
this.verticalSpacing,
totalHeight
);
};
PartyStatusContainer.prototype._watchMemberChange = function () {
if (!$gameParty.battleMembers().equals(this._lastBattleMembers)) {
this._createBattleObject(this._rawProperties, null);
this._updateSpritesetBattleActorSprites();
this._setPosition();
}
};
PartyStatusContainer.prototype._updateSpritesetBattleActorSprites =
function () {
var parent = this.parent;
while (!(parent instanceof Spriteset_Battle)) {
parent = parent.parent;
}
parent.updateActorSprites();
};
return PartyStatusContainer;
})(BattleObjects.Base);
BattleObjects.PartyStatusContainer = PartyStatusContainer;
})((BattleObjects = HUD.BattleObjects || (HUD.BattleObjects = {})));
})((HUD = Core.HUD || (Core.HUD = {})));
})((Core = BD.Core || (BD.Core = {})));
})(BD || (BD = {}));
var __extends =
(this && this.__extends) ||
(function () {
var extendStatics =
Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array &&
function (d, b) {
d.__proto__ = b;
}) ||
function (d, b) {
for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
};
return function (d, b) {
extendStatics(d, b);
function __() {
this.constructor = d;
}
d.prototype =
b === null
? Object.create(b)
: ((__.prototype = b.prototype), new __());
};
})();
var BD;
(function (BD) {
var Core;
(function (Core) {
var HUD;
(function (HUD) {
var BattleObjects;
(function (BattleObjects) {
var Rectangle = (function (_super) {
__extends(Rectangle, _super);
function Rectangle() {
return (_super !== null && _super.apply(this, arguments)) || this;
}
Rectangle.prototype._initializeInternal = function (properties) {
this.propertyChanged.addPropertyChanged(
BattleObjects.defs.width.key,
this._drawRectangle,
this
);
this.propertyChanged.addPropertyChanged(
BattleObjects.defs.height.key,
this._drawRectangle,
this
);
this.propertyChanged.addPropertyChanged(
BattleObjects.defs.fillColor.key,
this._drawRectangle,
this
);
this.propertyChanged.addPropertyChanged(
BattleObjects.defs.gradientColor.key,
this._drawRectangle,
this
);
this.propertyChanged.addPropertyChanged(
BattleObjects.defs.isGradient.key,
this._drawRectangle,
this
);
this.propertyChanged.addPropertyChanged(
BattleObjects.defs.isVertical.key,
this._drawRectangle,
this
);
this._drawRectangle();
};
Rectangle.prototype._updateInternal = function () {};
Rectangle.prototype._updatePropertyInternal = function () {
this._setProperty(BattleObjects.defs.width);
this._setProperty(BattleObjects.defs.height);
this._setProperty(BattleObjects.defs.fillColor);
this._setProperty(BattleObjects.defs.gradientColor);
this._setProperty(BattleObjects.defs.isGradient);
this._setProperty(BattleObjects.defs.isVertical);
};
Rectangle.prototype.draggable = function () {
return true;
};
Rectangle.prototype._drawRectangle = function () {
this.bitmap = new Bitmap(this.width, this.height);
var color1 = this.fillColor;
var color2 = this.gradientColor;
if (!this.isGradient) {
color2 = color1;
}
this.bitmap.gradientFillRect(
0,
0,
this.width,
this.height,
color1,
color2,
this.isVertical
);
};
return Rectangle;
})(BattleObjects.Base);
BattleObjects.Rectangle = Rectangle;
})((BattleObjects = HUD.BattleObjects || (HUD.BattleObjects = {})));
})((HUD = Core.HUD || (Core.HUD = {})));
})((Core = BD.Core || (BD.Core = {})));
})(BD || (BD = {}));
var __extends =
(this && this.__extends) ||
(function () {
var extendStatics =
Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array &&
function (d, b) {
d.__proto__ = b;
}) ||
function (d, b) {
for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
};
return function (d, b) {
extendStatics(d, b);
function __() {
this.constructor = d;
}
d.prototype =
b === null
? Object.create(b)
: ((__.prototype = b.prototype), new __());
};
})();
var BD;
(function (BD) {
var Core;
(function (Core) {
var HUD;
(function (HUD) {
var BattleObjects;
(function (BattleObjects) {
var Root = (function (_super) {
__extends(Root, _super);
function Root() {
var _this =
(_super !== null && _super.apply(this, arguments)) || this;
_this.contextCache = {};
return _this;
}
Root.prototype.getContext = function () {
return this.contextCache;
};
return Root;
})(BattleObjects.Base);
BattleObjects.Root = Root;
})((BattleObjects = HUD.BattleObjects || (HUD.BattleObjects = {})));
})((HUD = Core.HUD || (Core.HUD = {})));
})((Core = BD.Core || (BD.Core = {})));
})(BD || (BD = {}));
var __extends =
(this && this.__extends) ||
(function () {
var extendStatics =
Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array &&
function (d, b) {
d.__proto__ = b;
}) ||
function (d, b) {
for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
};
return function (d, b) {
extendStatics(d, b);
function __() {
this.constructor = d;
}
d.prototype =
b === null
? Object.create(b)
: ((__.prototype = b.prototype), new __());
};
})();
var BD;
(function (BD) {
var Core;
(function (Core) {
var HUD;
(function (HUD) {
var BattleObjects;
(function (BattleObjects) {
var StateIcon = (function (_super) {
__extends(StateIcon, _super);
function StateIcon() {
return (_super !== null && _super.apply(this, arguments)) || this;
}
StateIcon.prototype.isTouched = function () {
var x = this.canvasToLocalX(TouchInput.x);
var y = this.canvasToLocalY(TouchInput.y);
var scale = this._getStateIconScale();
if (this.orientation == Core.Consts.Enums.Orientation.Horizontal) {
return (
x >= 0 && y >= 0 && x < scale * this.maxStates && y < scale
);
} else {
return (
x >= 0 && y >= 0 && x < scale && y < scale * this.maxStates
);
}
};
StateIcon.prototype.draggable = function () {
return true;
};
StateIcon.prototype._initializeInternal = function (properties) {
StateIcon.iconDisplayNumber = 0;
this._lastStates = [];
this._lastBuffs = [];
this._lastIcons = [];
this._page = 0;
this.propertyChanged.addPropertyChanged(
BattleObjects.defs.maxStates.key,
this._createIcons,
this
);
this.propertyChanged.addPropertyChanged(
BattleObjects.defs.stateIconSize.key,
this._applyStateIconSize,
this
);
this.propertyChanged.addPropertyChanged(
"_sync",
this._syncRelatedObjects,
this
);
this._createIcons();
this.propertyChanged.raise("_sync");
};
StateIcon.prototype._setOneTimeProperty = function () {
this._setProperty(BattleObjects.defs.maxStates);
this._setProperty(BattleObjects.defs.stateIconSize);
this._setProperty(BattleObjects.defs.spacing);
this._setProperty(BattleObjects.defs.animationSpeed);
this._setProperty(BattleObjects.defs.orientation);
this._setProperty(BattleObjects.defs.relatedObjects);
};
StateIcon.prototype._updateInternal = function () {
this._updateAnimation();
};
StateIcon.prototype._updatePropertyInternal = function () {
this._updateIcons();
};
StateIcon.prototype._initUpdateCount = function () {
this._updateCount = 0;
};
StateIcon.prototype._createIcons = function () {
this.removeChildren();
for (var i = 0; i < this.maxStates; i++) {
var s = new BattleObjects.Components.SimpleIcon();
this.addChild(s);
}
this._applyStateIconSize();
};
StateIcon.prototype._updateIcons = function () {
if (Core.Manager.isStopHUD()) {
return;
}
var battler = this._getBattler();
if (
!battler._states.equals(this._lastStates) ||
!battler._buffs.equals(this._lastBuffs)
) {
this._lastStates = battler._states.slice(0);
this._lastBuffs = battler._buffs.slice(0);
var newIcons = this._getBattlerAllIcons();
if (
this._lastIcons === undefined ||
newIcons.equals(this._lastIcons)
) {
return;
}
if (
newIcons.length > this.maxStates &&
this._lastIcons.length <= this.maxStates
) {
StateIcon.iconDisplayNumber++;
if (StateIcon.iconDisplayNumber === 1) {
StateIcon.updateTimingOffset =
Graphics.frameCount % this.animationSpeed;
}
} else if (
newIcons.length <= this.maxStates &&
this._lastIcons.length > this.maxStates
) {
StateIcon.iconDisplayNumber--;
}
this._lastIcons = newIcons;
this._page = 0;
this._updateDisplayIcons();
this._syncRelatedObjects();
}
};
StateIcon.prototype._getBattler = function () {
if (!this._battler) {
var context = this.getContext()["b"];
if (context instanceof Game_Battler) {
this._battler = context;
}
}
return this._battler;
};
StateIcon.prototype._updateTiming = function () {
return (
(StateIcon.updateTimingOffset + Graphics.frameCount) %
this.animationSpeed ===
0
);
};
StateIcon.prototype._getBattlerAllIcons = function () {
if (BD.Core.Manager.isStudioMode()) {
return [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11];
} else {
var context = this.getContext();
if (!(context["b"] instanceof Game_Battler)) {
return [1];
}
var battler = context["b"];
return battler.allIcons();
}
};
StateIcon.prototype._updateAnimation = function () {
if (this._updateTiming()) {
this._page =
(this._page + 1) %
Math.ceil(this._lastIcons.length / this.maxStates);
this._updateDisplayIcons();
}
};
StateIcon.prototype._updateDisplayIcons = function () {
var _this = this;
var icons = this._getDisplayIcons();
this._smoothIcons();
this.children.forEach(function (s, i) {
s.setIcon(icons[i]);
var space = _this.spacing * i;
_this.orientation == Core.Consts.Enums.Orientation.Horizontal
? s.position.set(i * 32 + space, 0)
: s.position.set(0, i * 32 + space);
s.visible = icons[i] > 0;
});
};
StateIcon.prototype._getDisplayIcons = function () {
var icons = [];
for (var i = 0; i < this.maxStates; i++) {
icons.push(this._getDisplayIcon(this._page * this.maxStates + i));
}
return icons;
};
StateIcon.prototype._getDisplayIcon = function (index) {
if (index < this._lastIcons.length) {
return this._lastIcons[index];
}
return 0;
};
StateIcon.prototype._smoothIcons = function () {
if (this.stateIconSize === 32) {
return;
}
var p = this.children[0];
if (p && p.bitmap.isReady) {
p.bitmap.smooth = true;
}
};
StateIcon.prototype._getStateIconScale = function () {
return this.stateIconSize / 32;
};
StateIcon.prototype._applyStateIconSize = function () {
var scale = this._getStateIconScale();
if (scale === 32) {
return;
}
this.scale.set(scale, scale);
};
StateIcon.prototype._syncRelatedObjects = function () {
var _this = this;
if (!this.relatedObjects || this.relatedObjects === "") {
return;
}
this.relatedObjects
.split(",")
.map(function (x) {
return x.trim();
})
.forEach(function (x) {
var s = _this.findFamily(
function (y) {
return (
y instanceof BattleObjects.Base && y.getObjectName() === x
);
},
function (t) {
return (
t.parent instanceof BattleObjects.PartyStatusContainer
);
}
);
if (s) {
s.setVisibility(_this._lastIcons.length > 0);
}
});
};
StateIcon.updateTimingOffset = 0;
StateIcon.iconDisplayNumber = 0;
return StateIcon;
})(BattleObjects.Base);
BattleObjects.StateIcon = StateIcon;
})((BattleObjects = HUD.BattleObjects || (HUD.BattleObjects = {})));
})((HUD = Core.HUD || (Core.HUD = {})));
})((Core = BD.Core || (BD.Core = {})));
})(BD || (BD = {}));
var __extends =
(this && this.__extends) ||
(function () {
var extendStatics =
Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array &&
function (d, b) {
d.__proto__ = b;
}) ||
function (d, b) {
for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
};
return function (d, b) {
extendStatics(d, b);
function __() {
this.constructor = d;
}
d.prototype =
b === null
? Object.create(b)
: ((__.prototype = b.prototype), new __());
};
})();
var BD;
(function (BD) {
var Core;
(function (Core) {
var HUD;
(function (HUD) {
var BattleObjects;
(function (BattleObjects) {
var Text = (function (_super) {
__extends(Text, _super);
function Text() {
return (_super !== null && _super.apply(this, arguments)) || this;
}
Text.prototype.draggable = function () {
return true;
};
Text.prototype._initializeInternal = function (properties) {
this.propertyChanged.addPropertyChanged(
BattleObjects.defs.text.key,
this._createTextBitmap,
this
);
this._createTextBitmap();
};
Text.prototype._setOneTimeProperty = function () {
this._setProperty(BattleObjects.defs.maxWidth);
this._setProperty(BattleObjects.defs.color);
this._setProperty(BattleObjects.defs.outlineColor);
this._setProperty(BattleObjects.defs.outlineWidth);
this._setProperty(BattleObjects.defs.fontSize);
this._setProperty(BattleObjects.defs.fontFace);
this._setProperty(BattleObjects.defs.fontItalic);
this._setProperty(BattleObjects.defs.horizontalAlignment);
};
Text.prototype._updatePropertyInternal = function () {
this._setProperty(BattleObjects.defs.text);
};
Text.prototype._updateInternal = function () {};
Text.prototype._createTextBitmap = function () {
this._applyFont(Text.measureBitmap);
var width = Math.min(
Text.measureBitmap.measureTextWidth(this.text),
this.maxWidth
);
this.bitmap = new Bitmap(
width + this.outlineWidth * 2,
this.fontSize + this.outlineWidth
);
this._applyFont(this.bitmap);
this.bitmap.drawText(
this.text,
this.outlineWidth,
0,
width,
this.bitmap.height
);
switch (this.horizontalAlignment) {
case Core.Consts.Enums.HorizontalAlignment.Left:
this.pivot.x = Math.round(this.outlineWidth);
break;
case Core.Consts.Enums.HorizontalAlignment.Center:
this.pivot.x = Math.round(
width / 2 - this.maxWidth / 2 + this.outlineWidth
);
break;
case Core.Consts.Enums.HorizontalAlignment.Right:
this.pivot.x = Math.round(
width - this.maxWidth + this.outlineWidth
);
break;
}
this.pivot.y = Math.round(this.outlineWidth / 2);
};
Text.prototype._applyFont = function (bitmap) {
bitmap.textColor = this.color;
bitmap.outlineColor = this.outlineColor;
bitmap.outlineWidth = this.outlineWidth;
bitmap.fontFace = this.fontFace;
bitmap.fontItalic = this.fontItalic;
bitmap.fontSize = this.fontSize;
};
Text.measureBitmap = new Bitmap(4, 4);
return Text;
})(BattleObjects.Base);
BattleObjects.Text = Text;
})((BattleObjects = HUD.BattleObjects || (HUD.BattleObjects = {})));
})((HUD = Core.HUD || (Core.HUD = {})));
})((Core = BD.Core || (BD.Core = {})));
})(BD || (BD = {}));
var __extends =
(this && this.__extends) ||
(function () {
var extendStatics =
Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array &&
function (d, b) {
d.__proto__ = b;
}) ||
function (d, b) {
for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
};
return function (d, b) {
extendStatics(d, b);
function __() {
this.constructor = d;
}
d.prototype =
b === null
? Object.create(b)
: ((__.prototype = b.prototype), new __());
};
})();
var BD;
(function (BD) {
var Core;
(function (Core) {
var HUD;
(function (HUD) {
var BattleObjects;
(function (BattleObjects) {
var Components;
(function (Components) {
var BattlerContextContainer = (function (_super) {
__extends(BattlerContextContainer, _super);
function BattlerContextContainer(context, parent) {
var _this = _super.call(this, null) || this;
_this._battlerContext = context;
_this._contextCache = { b: _this._battlerContext };
parent.addChild(_this);
return _this;
}
Object.defineProperty(BattlerContextContainer.prototype, "b", {
get: function () {
return this._battlerContext;
},
enumerable: true,
configurable: true,
});
Object.defineProperty(
BattlerContextContainer.prototype,
"container",
{
get: function () {
return this.parent;
},
enumerable: true,
configurable: true,
}
);
BattlerContextContainer.prototype.getContext = function () {
return this._contextCache;
};
return BattlerContextContainer;
})(Sprite);
Components.BattlerContextContainer = BattlerContextContainer;
})(
(Components =
BattleObjects.Components || (BattleObjects.Components = {}))
);
})((BattleObjects = HUD.BattleObjects || (HUD.BattleObjects = {})));
})((HUD = Core.HUD || (Core.HUD = {})));
})((Core = BD.Core || (BD.Core = {})));
})(BD || (BD = {}));
var __extends =
(this && this.__extends) ||
(function () {
var extendStatics =
Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array &&
function (d, b) {
d.__proto__ = b;
}) ||
function (d, b) {
for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
};
return function (d, b) {
extendStatics(d, b);
function __() {
this.constructor = d;
}
d.prototype =
b === null
? Object.create(b)
: ((__.prototype = b.prototype), new __());
};
})();
var BD;
(function (BD) {
var Core;
(function (Core) {
var HUD;
(function (HUD) {
var BattleObjects;
(function (BattleObjects) {
var Components;
(function (Components) {
var SimpleIcon = (function (_super) {
__extends(SimpleIcon, _super);
function SimpleIcon() {
var _this = _super.call(this) || this;
_this.setup();
return _this;
}
SimpleIcon.prototype.setup = function () {
this.bitmap = ImageManager.loadSystem("IconSet");
this.setIcon(0);
};
SimpleIcon.prototype.update = function () {};
SimpleIcon.prototype.setIcon = function (iconIndex) {
var pw = 32;
var ph = 32;
var sx = (iconIndex % 16) * pw;
var sy = Math.floor(iconIndex / 16) * ph;
this.setFrame(sx, sy, pw, ph);
};
return SimpleIcon;
})(Sprite);
Components.SimpleIcon = SimpleIcon;
})(
(Components =
BattleObjects.Components || (BattleObjects.Components = {}))
);
})((BattleObjects = HUD.BattleObjects || (HUD.BattleObjects = {})));
})((HUD = Core.HUD || (Core.HUD = {})));
})((Core = BD.Core || (BD.Core = {})));
})(BD || (BD = {}));
var __extends =
(this && this.__extends) ||
(function () {
var extendStatics =
Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array &&
function (d, b) {
d.__proto__ = b;
}) ||
function (d, b) {
for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
};
return function (d, b) {
extendStatics(d, b);
function __() {
this.constructor = d;
}
d.prototype =
b === null
? Object.create(b)
: ((__.prototype = b.prototype), new __());
};
})();
var BD;
(function (BD) {
var Core;
(function (Core) {
var HUD;
(function (HUD) {
var BattleObjects;
(function (BattleObjects) {
var Components;
(function (Components) {
var battlerGraphicManager = BD.Core.Utils.BattlerGraphicManager;
var Settings = Core.Settings;
var XPStyleBattler = (function (_super) {
__extends(XPStyleBattler, _super);
function XPStyleBattler(actor) {
var _this = _super.call(this, actor) || this;
_this.initVisibility();
return _this;
}
Object.defineProperty(XPStyleBattler.prototype, "_actor", {
get: function () {
return this._enemy;
},
enumerable: true,
configurable: true,
});
XPStyleBattler.prototype.initMembers = function () {
_super.prototype.initMembers.call(this);
this._battlerGraphic = null;
this._faceName = "";
this._faceIndex = 0;
this._faceFrameX = 0;
this._faceFrameY = 0;
this._overlayOffset = {
x: 0,
y: 0,
onBottom: false,
};
this._dummyTarget = new Sprite_Base();
};
XPStyleBattler.prototype.initVisibility = function () {
_super.prototype.initVisibility.call(this);
if (this._actor.isAlive()) {
this._appeared = true;
this.opacity = 255;
} else {
this._appeared = this._actor.existDeadBattlerGraphic();
this.opacity = this._appeared ? 255 : 0;
}
};
XPStyleBattler.prototype.setupEffect = function () {
if (Core.Manager.isStopHUD()) {
return;
}
_super.prototype.setupEffect.call(this);
};
XPStyleBattler.prototype.updateBitmap = function () {
var actor = this._battler;
if (actor.guardBattlerGraphicDuration() === 0) {
actor._guardBattlerGraphicDuration = -1;
if (Settings.enableSideVidwBattler()) {
actor.refreshBattlerGraphic();
} else {
actor.clearMotion();
actor.requestMotionRefresh();
}
}
var battlerGraphic = actor.battlerGraphics();
if (battlerGraphic.fileName !== null) {
this._faceName = null;
if (
!battlerGraphicManager.areEqualBattlerGraphic(
this._battlerGraphic,
battlerGraphic
)
) {
var b = battlerGraphicManager.battlerGraphic(actor).bitmap;
if (b.isReady()) {
this.bitmap = b;
this._battlerGraphic = battlerGraphic;
this._setFaceFramePosition(this._battlerGraphic.faceIndex);
} else if (!this.bitmap) {
this.bitmap = ImageManager.loadEmptyBitmap();
}
this._smoothBitmap();
}
} else {
this._battlerGraphic = null;
var name_1 = actor.faceName();
var index = actor.faceIndex();
if (this._faceName !== name_1 || this._faceIndex !== index) {
var b = battlerGraphicManager.battlerGraphic(
this._actor
).bitmap;
if (b.isReady()) {
this._faceName = name_1;
this._faceIndex = index;
this.bitmap = b;
} else if (!this.bitmap) {
this.bitmap = ImageManager.loadEmptyBitmap();
}
this._setFaceFramePosition(index);
this._smoothBitmap();
}
}
};
XPStyleBattler.prototype._smoothBitmap = function () {
if (this.parent["zoom"] !== 100) {
this.bitmap.smooth = true;
}
};
XPStyleBattler.prototype.updateFormation = function () {
if (Settings.enableSideVidwBattler()) {
return;
}
_super.prototype.updateFormation.call(this);
};
XPStyleBattler.prototype._setFaceFramePosition = function (
faceIndex
) {
this._faceFrameX =
(faceIndex % 4) * 144 + XPStyleBattler.FrameOffset;
this._faceFrameY =
Math.floor(faceIndex / 4) * 144 + XPStyleBattler.FrameOffset;
};
XPStyleBattler.prototype.setHome = function (x, y) {
this._homeX = -90;
this._homeY = 0;
this.updatePosition();
};
XPStyleBattler.prototype.updatePosition = function () {
_super.prototype.updatePosition.call(this);
this._setScreenPosition();
};
XPStyleBattler.prototype.updateFrame = function () {
Sprite_Battler.prototype.updateFrame.call(this);
if (
!this._battlerGraphic ||
(this._battlerGraphic && this._battlerGraphic.faceIndex > -1)
) {
var frameHeight = XPStyleBattler.FrameSize;
if (this._effectType === "bossCollapse") {
frameHeight = this._effectDuration;
}
this.setFrame(
this._faceFrameX,
this._faceFrameY,
XPStyleBattler.FrameSize,
frameHeight
);
} else {
var frameHeight = this.bitmap.height;
if (this._effectType === "bossCollapse") {
frameHeight = this._effectDuration;
}
this.setFrame(0, 0, this.bitmap.width, frameHeight);
}
};
XPStyleBattler.prototype.startBossCollapse = function () {
_super.prototype.startBossCollapse.call(this);
this._effectDuration = this.height;
};
XPStyleBattler.prototype.createStateIconSprite = function () {
var dummy = {
setup: function (_) {
return;
},
scale: new Point(1, 1),
};
this._stateIconSprite = dummy;
};
XPStyleBattler.prototype.updateStateSprite = function () {};
XPStyleBattler.prototype.setOverlayOffset = function (offset) {
this._overlayOffset = offset;
};
XPStyleBattler.prototype.getOverlayOffset = function () {
return this._overlayOffset;
};
XPStyleBattler.prototype.damageOffsetX = function () {
return this._overlayOffset.x;
};
XPStyleBattler.prototype.damageOffsetY = function () {
if (this._overlayOffset.onBottom) {
return this._overlayOffset.y;
} else {
return -Math.round(this.height * 0.9) + this._overlayOffset.y;
}
};
XPStyleBattler.prototype._setScreenPosition = function () {
var pos = this.absolutePosition();
this._battler.setScreenPosition(pos.x, pos.y);
this._battler._cursorX = pos.x + this._overlayOffset.x;
if (this._overlayOffset.onBottom) {
this._battler._cursorY = pos.y + this._overlayOffset.y;
}
};
XPStyleBattler.prototype.setupAnimation = function () {
var _this = this;
_super.prototype.setupAnimation.call(this);
if (
!Settings.enableSideVidwBattler() &&
!Settings.battlerGraphic().enableAnimation
) {
this._animationSprites.forEach(function (sprite) {
if (sprite.visible) {
sprite.visible = false;
sprite.overrideTarget(_this._dummyTarget);
}
});
}
};
XPStyleBattler.prototype.startAnimation = function (
animation,
mirror,
delay
) {
var sprite = new Sprite_Animation();
sprite.setup(this._effectTarget, animation, mirror, delay);
this.parent.parent.parent.addChild(sprite);
this._animationSprites.push(sprite);
};
XPStyleBattler.prototype.updateFutureSight = function () {};
XPStyleBattler.FrameOffset = 1;
XPStyleBattler.FrameSize = 142;
return XPStyleBattler;
})(Sprite_Enemy);
Components.XPStyleBattler = XPStyleBattler;
})(
(Components =
BattleObjects.Components || (BattleObjects.Components = {}))
);
})((BattleObjects = HUD.BattleObjects || (HUD.BattleObjects = {})));
})((HUD = Core.HUD || (Core.HUD = {})));
})((Core = BD.Core || (BD.Core = {})));
})(BD || (BD = {}));
var __extends =
(this && this.__extends) ||
(function () {
var extendStatics =
Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array &&
function (d, b) {
d.__proto__ = b;
}) ||
function (d, b) {
for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
};
return function (d, b) {
extendStatics(d, b);
function __() {
this.constructor = d;
}
d.prototype =
b === null
? Object.create(b)
: ((__.prototype = b.prototype), new __());
};
})();
var BD;
(function (BD) {
var Core;
(function (Core) {
var HUD;
(function (HUD_1) {
var Base = HUD_1.BattleObjects.Base;
var Root = HUD_1.BattleObjects.Root;
var isStudioMode = BD.Core.Manager.isStudioMode;
var HUD = (function (_super) {
__extends(HUD, _super);
function HUD() {
var _this = _super.call(this, null) || this;
Core.DamagePopup.DamagePopupFactory.initialize();
_this.setFrame(0, 0, Graphics.width, Graphics.height);
_this.createEditView();
_this.createBattleObjects();
_this.addChild(
new Core.Targeting.TargetCursorLayer(Core.Settings.targetCursor())
);
_this.addChild(new Core.DamagePopup.PopupLayer());
_this.update();
return _this;
}
HUD.prototype.createEditView = function () {
if (!BD.Core.Manager.isStudioMode()) {
return;
}
this._bg = new BD.Studio.Screen.BackGround();
this.addChild(this._bg);
};
HUD.prototype.createBattleObjects = function () {
$gameParty.battleMembers().forEach(function (x) {
x.removeXpb();
});
var json;
if (Core.Manager.isGameMode()) {
json = Core.Settings.hud();
} else {
json = sessionStorage["bdStudioPreview"];
}
if (typeof json === "string") {
json = JSON.parse(json);
} else if (typeof json === "undefined") {
return;
}
var root = new Root(json);
root.setup(this);
this._battleObject = root;
this.addChild(this._battleObject);
};
HUD.prototype.update = function () {
_super.prototype.update.call(this);
this._battleObject.visible = $gameTemp.isVisibleBDHUD();
if (isStudioMode()) {
this.updateTouchBattleObjects();
}
};
HUD.prototype.updateTouchBattleObjects = function () {
if (this._battleObject == null) {
return;
}
var firstFoundObject = _.find(
this._battleObject
.flatten()
.reverse()
.filter(function (x) {
return x instanceof Base;
}),
function (sprite) {
return sprite.dragging();
}
);
if (firstFoundObject != null) {
firstFoundObject.updatePressCount();
}
_.chain(this._battleObject.children)
.filter(function (sprite) {
return sprite !== firstFoundObject;
})
.forEach(function (sprite) {
sprite.resetPressCount();
});
};
return HUD;
})(Sprite);
HUD_1.HUD = HUD;
})((HUD = Core.HUD || (Core.HUD = {})));
})((Core = BD.Core || (BD.Core = {})));
})(BD || (BD = {}));
(function () {
var _bdc_BattleManager_initMembers = BattleManager.initMembers;
BattleManager.initMembers = function () {
_bdc_BattleManager_initMembers.call(this);
this._battleEndFadeOut = false;
};
var _bdc_BattleManager_startBattle = BattleManager.startBattle;
BattleManager.startBattle = function () {
this._battleEndFadeOut = false;
_bdc_BattleManager_startBattle.call(this);
};
var _bdc_BattleManager_updateBattleEnd = BattleManager.updateBattleEnd;
BattleManager.updateBattleEnd = function () {
_bdc_BattleManager_updateBattleEnd.call(this);
this._battleEndFadeOut = true;
};
BattleManager.isBattleEndFadeOut = function () {
return this._battleEndFadeOut;
};
})();
(function () {
var Settings = BD.Core.Settings;
var BattlerGraphicManager = BD.Core.Utils.BattlerGraphicManager;
var Kind = BD.Core.Consts.Enums.ConditionalBattlerGraphicKind;
Game_Actor.prototype.battlerGraphics = function () {
if (this._battlerGraphic === undefined) {
this._battlerGraphic = this.baseBattlerGraphics();
}
return this._battlerGraphic;
};
Game_Actor.prototype.baseBattlerGraphics = function () {
if (this._baseBattlerGraphic === undefined) {
var bgRaw = BD.Core.RPGExtension.getBattlerGraphic(this.actor());
this._baseBattlerGraphic =
BattlerGraphicManager.createBattlerGraphic(bgRaw);
}
return this._baseBattlerGraphic;
};
Game_Actor.prototype.conditionalBattlerGraphics = function () {
if (this._conditionalBattlerGraphics === undefined) {
var conditions = BD.Core.RPGExtension.getConditionalBattlerGraphicsRaw(
this.actor()
);
this._conditionalBattlerGraphics = conditions
.map(function (x) {
return BattlerGraphicManager.createConditionalBattlerGraphic(
x.fileName,
x.kind,
x.idOrTag,
x.priority
);
})
.filter(function (x) {
return x !== null;
});
}
return this._conditionalBattlerGraphics;
};
Game_Actor.prototype.setBattlerGraphics = function (faceName, faceIndex) {
if (faceIndex === void 0) {
faceIndex = -1;
}
this._baseBattlerGraphic = {
fileName: faceName,
faceIndex: faceIndex,
};
this.refreshBattlerGraphic();
};
Game_Actor.prototype.refreshBattlerGraphic = function () {
var c = BattlerGraphicManager.determineCandidate(this);
if (this._guardBattlerGraphicDuration >= 0) {
if (c && c.condition.kind === Kind.damage) {
this._guardBattlerGraphicDuration =
BattlerGraphicManager.damageDuration();
}
return;
}
if (c == null) {
this._battlerGraphic = this._baseBattlerGraphic;
} else {
this._battlerGraphic = c.battlerGraphic;
if (c.condition.kind === Kind.damage) {
this._guardBattlerGraphicDuration =
BattlerGraphicManager.damageDuration();
}
}
};
Game_Actor.prototype.existDeadBattlerGraphic = function () {
var d = this.conditionalBattlerGraphics().find(function (x) {
return x.condition.kind === Kind.dead;
});
return d !== undefined;
};
Game_Actor.prototype.guardBattlerGraphicDuration = function () {
if (!this._guardBattlerGraphicDuration) {
return -1;
}
if (this._guardBattlerGraphicDuration > 1) {
this._guardBattlerGraphicDuration--;
} else if (
this._guardBattlerGraphicDuration === 1 &&
(this._motionType !== "damage" || !Settings.enableSideVidwBattler())
) {
this._guardBattlerGraphicDuration = 0;
}
return this._guardBattlerGraphicDuration;
};
Game_Actor.prototype.setConditionalBattlerGraphics = function (
fileName,
faceIndex,
kind,
idOrTag,
priority
) {
this.conditionalBattlerGraphics();
var f = this._conditionalBattlerGraphics.find(function (x) {
if (
x.condition.kind === Kind[kind.toLowerCase()] &&
x.condition.idOrTag === idOrTag
) {
return true;
}
});
if (f) {
f.battlerGraphic.fileName = fileName;
f.battlerGraphic.faceIndex = faceIndex;
f.condition.priority = priority;
this.refreshBattlerGraphic();
return;
}
var cbg = {
condition: {
kind: Kind[kind.toLowerCase()],
idOrTag: idOrTag,
priority: priority,
},
battlerGraphic: {
fileName: fileName,
faceIndex: faceIndex.clamp(-1, 128),
},
};
this._conditionalBattlerGraphics.push(cbg);
this.refreshBattlerGraphic();
};
Game_Actor.prototype.removeConditionalBattlerGraphics = function (
kind,
idOrTag
) {
this.conditionalBattlerGraphics();
var f = this._conditionalBattlerGraphics.find(function (x) {
if (
x.condition.kind === Kind[kind.toLowerCase()] &&
x.condition.idOrTag === idOrTag
) {
return true;
}
});
if (f) {
this._conditionalBattlerGraphics =
this._conditionalBattlerGraphics.filter(function (x) {
return x !== f;
});
this.refreshBattlerGraphic();
return;
}
};
Game_Actor.prototype.resetBattlerGraphic = function () {
this._baseBattlerGraphic = undefined;
this._conditionalBattlerGraphics = undefined;
this._guardBattlerGraphicDuration = undefined;
this.refreshBattlerGraphic();
};
var _bdc_Game_Actor_onBattleStart = Game_Actor.prototype.onBattleStart;
Game_Actor.prototype.onBattleStart = function () {
_bdc_Game_Actor_onBattleStart.apply(this, arguments);
if (!BD.Core.Settings.enableSideVidwBattler()) {
this.refreshBattlerGraphic();
}
};
var _bdc_Game_Actor_clearMotion = Game_Actor.prototype.clearMotion;
Game_Actor.prototype.clearMotion = function () {
_bdc_Game_Actor_clearMotion.apply(this, arguments);
if (!this._guardBattlerGraphicDuration) {
this._guardBattlerGraphicDuration = -1;
}
};
var _bdc_Game_Actor_requestMotion = Game_Actor.prototype.requestMotion;
Game_Actor.prototype.requestMotion = function (motionType) {
_bdc_Game_Actor_requestMotion.apply(this, arguments);
this.refreshBattlerGraphic();
};
var _bdc_Game_Actor_requestMotionRefresh =
Game_Actor.prototype.requestMotionRefresh;
Game_Actor.prototype.requestMotionRefresh = function () {
_bdc_Game_Actor_requestMotionRefresh.apply(this, arguments);
this.refreshBattlerGraphic();
};
var _bdc_Game_Actor_performActionStart =
Game_Actor.prototype.performActionStart;
Game_Actor.prototype.performActionStart = function (action) {
_bdc_Game_Actor_performActionStart.apply(this, arguments);
if (!Settings.enableSideVidwBattler()) {
this.requestEffect("whiten");
}
};
Game_Actor.prototype.setScreenPosition = function (x, y) {
this._screenX = x;
this._screenY = y;
};
Game_Actor.prototype.screenX = function () {
return this._screenX === undefined ? 0 : this._screenX;
};
Game_Actor.prototype.screenY = function () {
return this._screenY === undefined ? 0 : this._screenY;
};
Game_Actor.prototype.performCollapse = function () {
Game_Battler.prototype.performCollapse.apply(this, arguments);
if (!$gameParty.inBattle()) {
return;
}
switch (this.collapseType()) {
case 0:
if (!this.existDeadBattlerGraphic()) {
this.requestEffect("collapse");
}
SoundManager.playActorCollapse();
break;
case 1:
this.requestEffect("bossCollapse");
SoundManager.playBossCollapse1();
break;
case 2:
if (!this.existDeadBattlerGraphic()) {
this.requestEffect("instantCollapse");
}
break;
}
};
Game_Actor.prototype.isSpriteVisible = function () {
return true;
};
Game_Actor.prototype.initHudParamCache = function () {
this._paramCache = new Array(2);
};
var _bdc_Game_Actor_onBattleEnd = Game_Actor.prototype.onBattleEnd;
Game_Actor.prototype.onBattleEnd = function () {
_bdc_Game_Actor_onBattleEnd.apply(this, arguments);
this._paramCache = undefined;
};
var _bdc_Game_Actor_refresh = Game_Actor.prototype.refresh;
Game_Actor.prototype.refresh = function () {
if ($gameParty.inBattle()) {
this.initHudParamCache();
}
_bdc_Game_Actor_refresh.apply(this, arguments);
};
Game_Actor.prototype.hasXpb = function () {
return this._hasXpbSprite || false;
};
Game_Actor.prototype.setXpb = function () {
this._hasXpbSprite = true;
};
Game_Actor.prototype.removeXpb = function () {
this._hasXpbSprite = false;
this._cursorX = undefined;
this._cursorY = undefined;
};
Game_Actor.prototype._hudParam = function (paramId) {
var cache = this._paramCache[paramId];
if (cache === undefined) {
this._paramCache[paramId] = Game_Actor.prototype.param.apply(
this,
arguments
);
return this._paramCache[paramId];
}
return cache;
};
Game_Actor.prototype.hudMhp = function () {
return this._hudParam(0);
};
Game_Actor.prototype.hudMmp = function () {
return this._hudParam(1);
};
Game_Actor.prototype.hudHpNumberPattern = function () {
if (this._hp === 0) {
return 2;
} else if (this._hp < this.hudMhp() / 4) {
return 1;
} else {
return 0;
}
};
Game_Actor.prototype.enemy = function () {
return this.actor();
};
Game_Actor.prototype.isBigEnemy = function () {
return false;
};
})();
(function () {
Game_Battler.prototype.screenX = function () {
return 0;
};
Game_Battler.prototype.screenY = function () {
return 0;
};
})();
(function () {
var _bdc_Game_Temp_initialize = Game_Temp.prototype.initialize;
Game_Temp.prototype.initialize = function () {
_bdc_Game_Temp_initialize.call(this);
this._isVisibleBDHUD = true;
};
Game_Temp.prototype.isVisibleBDHUD = function () {
return this._isVisibleBDHUD;
};
Game_Temp.prototype.hideBDHUD = function () {
this._isVisibleBDHUD = false;
};
Game_Temp.prototype.showBDHUD = function () {
this._isVisibleBDHUD = true;
};
})();
(function () {
var _bdc_Sprite_Actor_setActorHome = Sprite_Actor.prototype.setActorHome;
Sprite_Actor.prototype.setActorHome = function (index) {
_bdc_Sprite_Actor_setActorHome.call(this, index);
this._battler.setScreenPosition(this._homeX, this._homeY);
};
})();
(function () {
Sprite_Animation.prototype.overrideTarget = function (newTarget) {
this._target = newTarget;
};
})();
(function () {
var _bdc_Spriteset_Battle_createUpperLayer =
Spriteset_Battle.prototype.createUpperLayer;
Spriteset_Battle.prototype.createUpperLayer = function () {
_bdc_Spriteset_Battle_createUpperLayer.call(this);
this.createHUDSprite();
};
var _bdc_Spriteset_Battle_update = Spriteset_Battle.prototype.update;
Spriteset_Battle.prototype.update = function () {
_bdc_Spriteset_Battle_update.call(this);
this.updateHUDSprite();
};
var mogActorPictureCM = function () {
this._hudField = new Sprite();
this._hudField.z = 10;
var spriteSet = this.children[0];
var bdHud = spriteSet.children.pop();
spriteSet.addChild(this._hudField);
spriteSet.addChild(bdHud);
};
Spriteset_Battle.prototype.createHUDSprite = function () {
if (
Scene_Battle.prototype.createHudField !== undefined &&
Scene_Battle.prototype.createHudField !== mogActorPictureCM
) {
Scene_Battle.prototype.createHudField = mogActorPictureCM;
}
if (this._hudSprite !== undefined) {
this.removeChild(this._hudSprite);
}
this._hudSprite = new BD.Core.HUD.HUD();
this.addChild(this._hudSprite);
this.updateActorSprites();
};
Spriteset_Battle.prototype.updateActorSprites = function () {
if (BD.Core.Settings.enableSideVidwBattler()) {
return;
}
var s = this._hudSprite.flatten().filter(function (x) {
return x instanceof BD.Core.HUD.BattleObjects.Components.XPStyleBattler;
});
this._actorSprites = s;
};
Spriteset_Battle.prototype.updateHUDSprite = function () {
if (
BD.Core.Manager.isStudioMode() &&
BD.Studio.Utilities.RmvUtility.onrender
) {
BD.Studio.Utilities.RmvUtility.onrender = false;
this.createHUDSprite();
}
};
var _bdc_Spriteset_Battle_createActors =
Spriteset_Battle.prototype.createActors;
Spriteset_Battle.prototype.createActors = function () {
if (BD.Core.Settings.enableSideVidwBattler()) {
_bdc_Spriteset_Battle_createActors.call(this);
} else {
this._actorSprites = [];
}
};
})();
(function () {
BattleManager.displayStartMessages = function () {
if (BD.Core.Settings.battleMessage().enemyEmergeMessage) {
$gameTroop.enemyNames().forEach(function (name) {
$gameMessage.add(TextManager.emerge.format(name));
});
}
if (this._preemptive) {
$gameMessage.add(TextManager.preemptive.format($gameParty.name()));
} else if (this._surprise) {
$gameMessage.add(TextManager.surprise.format($gameParty.name()));
}
};
})();
var __extends =
(this && this.__extends) ||
(function () {
var extendStatics =
Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array &&
function (d, b) {
d.__proto__ = b;
}) ||
function (d, b) {
for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
};
return function (d, b) {
extendStatics(d, b);
function __() {
this.constructor = d;
}
d.prototype =
b === null
? Object.create(b)
: ((__.prototype = b.prototype), new __());
};
})();
var BD;
(function (BD) {
var Core;
(function (Core) {
var Message;
(function (Message) {
var SimpleBattleLog;
(function (SimpleBattleLog) {
var HorizontalAlignment = Core.Consts.Enums.HorizontalAlignment;
var ActionInformationWindow = (function (_super) {
__extends(ActionInformationWindow, _super);
function ActionInformationWindow() {
var _this = _super.call(this, 1) || this;
_this._item = null;
return _this;
}
ActionInformationWindow.prototype.clear = function () {
_super.prototype.clear.call(this);
this.setItem(null);
};
ActionInformationWindow.prototype.refresh = function () {
this.contents.clear();
this.resetTextColor();
this.resetFontSettings();
var drawIcon =
Core.Settings.battleMessage().simpleBattleLog.drawIcon;
var needIcon = drawIcon && this._item.iconIndex > 0;
var itemWidth = this._measureItemWidth(needIcon);
var desc = this._getDescription();
var descWidth = this._measureDescriptionWidth(desc);
var align = Core.Settings.battleMessage().simpleBattleLog.align;
this._drawActionInformation(
itemWidth,
descWidth,
needIcon,
desc,
align
);
};
ActionInformationWindow.prototype._setDescriptionFont = function () {
var fontSize =
Core.Settings.battleMessage().simpleBattleLog.descriptionFontSize;
if (fontSize > 0) {
this.contents.fontSize = fontSize;
}
};
ActionInformationWindow.prototype._getDescription = function () {
var desc = Core.RPGExtension.getActionDescription(this._item);
if (desc.length > 0) {
var delimiter =
Core.Settings.battleMessage().simpleBattleLog
.descriptionDelimiter;
return delimiter + desc;
}
return "";
};
ActionInformationWindow.prototype._measureItemWidth = function (
needIcon
) {
this.resetFontSettings();
var itemWidth = this.contents.measureTextWidth(this._item.name);
if (needIcon && this._item.iconIndex > 0) {
itemWidth += 32 + 4;
}
return itemWidth;
};
ActionInformationWindow.prototype._measureDescriptionWidth =
function (description) {
this._setDescriptionFont();
var descWidth = 0;
if (description.length > 0) {
descWidth = this.contents.measureTextWidth(description);
}
return descWidth;
};
ActionInformationWindow.prototype._drawActionInformation = function (
itemWidth,
descWidth,
needIcon,
description,
align
) {
this.resetFontSettings();
var itemX = this._calcDrawX(itemWidth + descWidth, align);
if (needIcon && this._item.iconIndex > 0) {
this.drawItemName(this._item, itemX, 0, itemWidth);
} else {
this.drawText(this._item.name, itemX, 0, itemWidth + 8, "left");
}
this._setDescriptionFont();
var descX = itemX + itemWidth;
this.drawText(description, descX, 0, descWidth, "left");
};
ActionInformationWindow.prototype._calcDrawX = function (
totalWidth,
align
) {
switch (align) {
case HorizontalAlignment.Center:
var x = this.contentsWidth() / 2 - totalWidth / 2;
if (this._item.iconIndex > 0) {
x -= 16;
}
return x;
case HorizontalAlignment.Right:
return this.contentsWidth() - totalWidth - 4;
default:
return 0;
}
};
ActionInformationWindow.prototype.setText = function (text) {};
ActionInformationWindow.prototype.setItem = function (item) {
if (this._item === item) {
return;
}
this._item = item;
this.refresh();
};
return ActionInformationWindow;
})(Window_Help);
SimpleBattleLog.ActionInformationWindow = ActionInformationWindow;
})(
(SimpleBattleLog =
Message.SimpleBattleLog || (Message.SimpleBattleLog = {}))
);
})((Message = Core.Message || (Core.Message = {})));
})((Core = BD.Core || (BD.Core = {})));
})(BD || (BD = {}));
(function () {
var _bdc_Scene_Battle_createAllWindows =
Scene_Battle.prototype.createAllWindows;
Scene_Battle.prototype.createAllWindows = function () {
_bdc_Scene_Battle_createAllWindows.call(this);
this.createActionInformationWindow();
};
Scene_Battle.prototype.createActionInformationWindow = function () {
this._actionInformationWindow =
new BD.Core.Message.SimpleBattleLog.ActionInformationWindow();
this._actionInformationWindow.visible = false;
this.addWindow(this._actionInformationWindow);
this._logWindow.actionInformationWindow = this._actionInformationWindow;
};
})();
(function () {
var Settings = BD.Core.Settings;
var _bdc_Window_BattleLog_startAction =
Window_BattleLog.prototype.startAction;
Window_BattleLog.prototype.startAction = function (subject, action, targets) {
this._showActionInformation(subject, action);
if (this._isSimpleBattleLog() && action.item().scope === 0) {
this.push("anyWait", _bdc_Window_BattleLog_messageSpeed.call(this) * 3);
}
_bdc_Window_BattleLog_startAction.call(this, subject, action, targets);
};
var _bdc_Window_BattleLog_endAction = Window_BattleLog.prototype.endAction;
Window_BattleLog.prototype.endAction = function (subject) {
if (Settings.isSimpleBattleLog()) {
this.push("waitForBossCollapse");
this._hideActionInformation();
_bdc_Window_BattleLog_endAction.call(this, subject);
} else {
this._hideActionInformation();
_bdc_Window_BattleLog_endAction.call(this, subject);
this.push("waitForBossCollapse");
}
};
Window_BattleLog.prototype._showActionInformation = function (
subject,
action
) {
if (!this._isSimpleBattleLog()) {
return;
}
if (action.isSkill()) {
var id = action.item().id;
var displayAttack =
Settings.battleMessage().simpleBattleLog.displayAttack;
if (!displayAttack && id === subject.attackSkillId()) {
return;
}
var displayGuard = Settings.battleMessage().simpleBattleLog.displayGuard;
if (!displayGuard && id === subject.guardSkillId()) {
return;
}
}
this.actionInformationWindow.setItem(action.item());
this.actionInformationWindow.show();
};
Window_BattleLog.prototype._hideActionInformation = function () {
if (!this._isSimpleBattleLog()) {
return;
}
this.actionInformationWindow.hide();
};
Window_BattleLog.prototype._isSimpleBattleLog = function () {
var useSimpleBattleLog =
Settings.battleMessage().simpleBattleLog.useSimpleBattleLog;
return useSimpleBattleLog && this.actionInformationWindow !== undefined;
};
var _bdc_Window_BattleLog_refresh = Window_BattleLog.prototype.refresh;
Window_BattleLog.prototype.refresh = function () {
if (this._isSimpleBattleLog()) {
return;
}
_bdc_Window_BattleLog_refresh.call(this);
};
var _bdc_Window_BattleLog_drawLineText =
Window_BattleLog.prototype.drawLineText;
Window_BattleLog.prototype.drawLineText = function (index) {
if (this._isSimpleBattleLog()) {
return;
}
_bdc_Window_BattleLog_drawLineText.call(this, index);
};
var _bdc_Window_BattleLog_messageSpeed =
Window_BattleLog.prototype.messageSpeed;
Window_BattleLog.prototype.messageSpeed = function () {
if (this._isSimpleBattleLog()) {
return 1;
}
return _bdc_Window_BattleLog_messageSpeed.call(this);
};
var _bdc_Window_BattleLog_displayActionResults =
Window_BattleLog.prototype.displayActionResults;
Window_BattleLog.prototype.displayActionResults = function (subject, target) {
_bdc_Window_BattleLog_displayActionResults.call(this, subject, target);
if (this._isSimpleBattleLog() && target.result().used) {
this.push("anyWait", _bdc_Window_BattleLog_messageSpeed.call(this));
}
};
var _bdc_Window_BattleLog_updateWait = Window_BattleLog.prototype.updateWait;
Window_BattleLog.prototype.updateWait = function () {
var waitMode = this._waitMode;
var waiting = _bdc_Window_BattleLog_updateWait.apply(this, arguments);
if (waitMode === "bossCollapse") {
waiting = this._spriteset.isBossCollapsing();
if (!waiting) {
this._waitMode = "";
} else {
this.waitForBossCollapse();
}
}
return waiting;
};
var _bdc_Window_BattleLog_startTurn = Window_BattleLog.prototype.startTurn;
Window_BattleLog.prototype.startTurn = function () {
_bdc_Window_BattleLog_startTurn.call(this);
if (!this._isSimpleBattleLog()) {
this._methods.pop();
this.push("anyWait", Math.round(this.messageSpeed()) / 2);
}
};
Window_BattleLog.prototype.anyWait = function (wait) {
if (wait === void 0) {
wait = 12;
}
this._waitCount = wait;
};
Window_BattleLog.prototype.waitForBossCollapse = function () {
this.setWaitMode("bossCollapse");
};
})();
(function () {
var Settings = BD.Core.Settings.minorFixes;
var _bdc_Sprite_Battler_updateSelectionEffect =
Sprite_Battler.prototype.updateSelectionEffect;
Sprite_Battler.prototype.updateSelectionEffect = function () {
if (Settings().enableSelectionEffect) {
_bdc_Sprite_Battler_updateSelectionEffect.apply(this, arguments);
}
};
})();
(function () {
var _bdc_BattleManager_startBattle = BattleManager.startBattle;
BattleManager.startBattle = function () {
this._initTargetedBattler();
_bdc_BattleManager_startBattle.call(this);
};
var _bdc_BattleManager_endBattle = BattleManager.endBattle;
BattleManager.endBattle = function (result) {
_bdc_BattleManager_endBattle.call(this, result);
this._initTargetedBattler();
};
BattleManager._initTargetedBattler = function () {
this.lastTargetedActor = null;
this.lastTargetedEnemy = null;
};
var _bdc_BattleManager_startInput = BattleManager.startInput;
BattleManager.startInput = function () {
_bdc_BattleManager_startInput.call(this);
this.doStartInputCallback();
};
BattleManager.doStartInputCallback = function () {
this._startInputCallback.forEach(function (x) {
return x[0].call(x[1]);
});
};
BattleManager.clearStartInputCallback = function () {
this._startInputCallback = [];
};
BattleManager.registerStartInputCallback = function (callback, context) {
this._startInputCallback.push([callback, context]);
};
})();
(function () {
var sideView = BD.Core.Settings.enableSideVidwBattler;
var _bdc_Game_Action_makeTargets = Game_Action.prototype.makeTargets;
Game_Action.prototype.makeTargets = function () {
var target = _bdc_Game_Action_makeTargets.call(this);
if (this.subject().isActor() && this.isForOpponent() && this.isForAll()) {
return BD.Core.Utils.sortTroopByX(target, sideView());
} else {
return target;
}
};
var _bdc_Game_Action_needsSelection = Game_Action.prototype.needsSelection;
Game_Action.prototype.needsSelection = function () {
if (BD.Core.Settings.targetCursor().checkSelection) {
return !this.checkItemScope([0]);
}
return _bdc_Game_Action_needsSelection.apply(this, arguments);
};
})();
(function () {
var battlerGraphicManager = BD.Core.Utils.BattlerGraphicManager;
Game_Actor.prototype.cursorX = function () {
if (this._cursorX !== undefined) {
return this._cursorX;
} else {
return this.screenX();
}
};
Game_Actor.prototype.cursorY = function () {
if (this._cursorY !== undefined) {
return this._cursorY;
} else {
var h = battlerGraphicManager.battlerGraphic(this).height;
return this.screenY() - h;
}
};
Game_Actor.prototype.hitTestRectangle = function () {
if (this._hitTestRectangle) {
return this._hitTestRectangle;
}
var x = this.screenX() - 144 / 2;
var y = this.screenY() - 144;
var width = 192;
var height = 144;
return new Rectangle(x, y, width, height);
};
})();
(function () {
Game_Battler.prototype.cursorX = function () {
return 0;
};
Game_Battler.prototype.cursorY = function () {
return 0;
};
Game_Battler.prototype.hitTestRectangle = function () {
return new Rectangle(0, 0, 0, 0);
};
Game_Battler.prototype.changeTouchInputStatus = function (status) {
this._touchInputStatus = status;
};
Game_Battler.prototype.touchInputStatus = function () {
return this._touchInputStatus || 0;
};
})();
(function () {
var battlerGraphicManager = BD.Core.Utils.BattlerGraphicManager;
Game_Enemy.prototype.cursorX = function () {
if (this._cursorX !== undefined) {
return this._cursorX;
} else {
return this.screenX();
}
};
Game_Enemy.prototype.cursorY = function () {
if (this._cursorY !== undefined) {
return this._cursorY;
} else {
var h = battlerGraphicManager.battlerGraphic(this).height;
return this.screenY() - h;
}
};
Game_Enemy.prototype.hitTestRectangle = function () {
if (this._hitTestRectangle) {
return this._hitTestRectangle;
}
var bitmap = battlerGraphicManager.battlerGraphic(this).bitmap;
var x = this.screenX() - bitmap.width / 2;
var y = this.screenY() - bitmap.height;
var width = bitmap.width;
var height = bitmap.height;
return new Rectangle(x, y, width, height);
};
})();
Game_Unit.prototype.selectAll = function () {
this.members().forEach(function (member) {
return member.select();
});
};
(function () {
var _bdc_Scene_Battle_initialize = Scene_Battle.prototype.initialize;
Scene_Battle.prototype.initialize = function () {
_bdc_Scene_Battle_initialize.call(this);
BattleManager.clearStartInputCallback();
};
var _bdc_Scene_Battle_createAllWindows =
Scene_Battle.prototype.createAllWindows;
Scene_Battle.prototype.createAllWindows = function () {
_bdc_Scene_Battle_createAllWindows.call(this);
this.createTargetInformationWindow();
};
Scene_Battle.prototype.createTargetInformationWindow = function () {
this._targetInformationWindow =
new BD.Core.Targeting.TargetInformationWindow();
this._targetInformationWindow.visible = false;
this.addWindow(this._targetInformationWindow);
this._actorWindow.setHelpWindow(this._targetInformationWindow);
this._enemyWindow.setHelpWindow(this._targetInformationWindow);
};
Scene_Battle.prototype.commandAttack = function () {
BattleManager.inputtingAction().setAttack();
this.onSelectAction();
};
Scene_Battle.prototype.commandGuard = function () {
BattleManager.inputtingAction().setGuard();
this.onSelectAction();
};
var _bdc_Scene_Battle_onActorCancel = Scene_Battle.prototype.onActorCancel;
Scene_Battle.prototype.onActorCancel = function () {
_bdc_Scene_Battle_onActorCancel.call(this);
if (this._actorCommandWindow.currentSymbol() === "guard") {
this._actorCommandWindow.activate();
}
};
var _bdc_Scene_Battle_onEnemyCancel = Scene_Battle.prototype.onEnemyCancel;
Scene_Battle.prototype.onEnemyCancel = function () {
_bdc_Scene_Battle_onEnemyCancel.call(this);
if (this._actorCommandWindow.currentSymbol() === "guard") {
this._actorCommandWindow.activate();
}
};
})();
(function () {
var SideView = BD.Core.Settings.enableSideVidwBattler;
var _bdc_Sprite_Actor_updateMove = Sprite_Actor.prototype.updateMove;
Sprite_Actor.prototype.updateMove = function () {
_bdc_Sprite_Actor_updateMove.apply(this, arguments);
this._setSideviewCursorPosition();
};
Sprite_Actor.prototype._setSideviewCursorPosition = function () {
var a = this._actor;
if (!a.hasXpb() && (this.isMoving() || a.isSelected() || a.isInputting())) {
a._cursorX = this.x;
a._cursorY = this.y - this._mainSprite.height;
}
};
var _bdc_Sprite_Actor_update = Sprite_Actor.prototype.update;
Sprite_Actor.prototype.update = function () {
_bdc_Sprite_Actor_update.apply(this, arguments);
this._updateTouch();
};
Sprite_Actor.prototype._updateTouch = function () {
var a = this._actor;
if (!a || !SideView() || !BattleManager.inputtingAction()) {
return;
}
if (TouchInput.isPressed() && this._targetingHitTest()) {
a.changeTouchInputStatus(BD.Core.Consts.Enums.TouchInputStatus.Pressed);
} else {
a.changeTouchInputStatus(BD.Core.Consts.Enums.TouchInputStatus.NoInput);
}
};
Sprite_Actor.prototype._targetingHitTest = function () {
var s = this;
var rect = new Rectangle(
s.x - s._mainSprite.width / 2,
s.y - s._mainSprite.height,
s._mainSprite.width,
s._mainSprite.height
);
var x = TouchInput.x - rect.x;
var y = TouchInput.y - rect.y;
return x >= 0 && y >= 0 && x < rect.width && y < rect.height;
};
})();
(function () {
var Sprite_StateIcon_loadBitmap = Sprite_StateIcon.prototype.loadBitmap;
Sprite_StateIcon.prototype.loadBitmap = function () {
Sprite_StateIcon_loadBitmap.apply(this, arguments);
this.visible = false;
};
var Sprite_StateIcon_update = Sprite_StateIcon.prototype.update;
Sprite_StateIcon.prototype.update = function () {
Sprite_StateIcon_update.apply(this, arguments);
this.visible = !this._battler.isSelected() && this._iconIndex > 0;
};
})();
(function () {
Window_BattleActor.prototype.forceTarget = function () {
this.setCursorAll(false);
this.setCursorFixed(false);
var action = BattleManager.inputtingAction();
if (!action) {
return;
}
if (action.isForAll()) {
this.setCursorAll(true);
this.setCursorFixed(true);
$gameParty.selectAll();
this.updateHelp();
} else if (action.isForUser()) {
this.select(BattleManager._actorIndex);
this.setCursorFixed(true);
this.updateHelp();
}
};
Window_BattleActor.prototype.restoreTarget = function () {
if (!ConfigManager.commandRemember) {
return;
}
var lastTarget = BattleManager.lastTargetedActor;
var index = $gameParty.members().indexOf(lastTarget);
this.select(Math.max(0, index));
};
Window_BattleActor.prototype.rememberTarget = function () {
if (!ConfigManager.commandRemember) {
return;
}
var action = BattleManager.inputtingAction();
if (!action || action.isForAll() || action.isForUser()) {
return;
}
BattleManager.lastTargetedActor = this.actor();
};
var _bdc_Window_BattleActor_show = Window_BattleActor.prototype.show;
Window_BattleActor.prototype.show = function () {
_bdc_Window_BattleActor_show.call(this);
this.showHelpWindow();
this.forceTarget();
};
var _bdc_Window_BattleActor_hide = Window_BattleActor.prototype.hide;
Window_BattleActor.prototype.hide = function () {
_bdc_Window_BattleActor_hide.call(this);
this.hideHelpWindow();
this.rememberTarget();
};
Window_BattleActor.prototype.activate = function () {
Window_Selectable.prototype.activate.call(this);
this.restoreTarget();
};
Window_BattleActor.prototype.updateHelp = function () {
this._helpWindow.setBattler($gameParty.battleMembers()[this.index()]);
};
var _bdc_Window_BattleActor_select = Window_BattleActor.prototype.select;
Window_BattleActor.prototype.select = function (index) {
if (this.cursorFixed()) {
return;
}
_bdc_Window_BattleActor_select.call(this, index);
};
})();
(function () {
var _bdc_Window_BattleEnemy_initialize =
Window_BattleEnemy.prototype.initialize;
Window_BattleEnemy.prototype.initialize = function (x, y) {
this._touchSelector = new BD.Core.Targeting.TargetTouchSelector(this);
_bdc_Window_BattleEnemy_initialize.call(this, x, y);
};
var _bdc_Window_BattleEnemy_update = Window_BattleEnemy.prototype.update;
Window_BattleEnemy.prototype.update = function () {
_bdc_Window_BattleEnemy_update.call(this);
this._touchSelector.update();
};
Window_BattleEnemy.prototype.isHorizontal = function () {
return true;
};
Window_BattleEnemy.prototype.maxCols = function () {
return this._enemies.length;
};
Window_BattleEnemy.prototype.maxItems = function () {
return this._enemies.length;
};
Window_BattleEnemy.prototype.refresh = function () {
this._enemies = BD.Core.Utils.sortTroopByX($gameTroop.aliveMembers());
this._touchSelector.setup(this._enemies);
Window_Selectable.prototype.refresh.call(this);
};
Window_BattleEnemy.prototype.forceTarget = function () {
this.setCursorAll(false);
this.setCursorFixed(false);
var action = BattleManager.inputtingAction();
if (!action) {
return;
}
if (action.isForAll() || action.isForRandom()) {
this.setCursorAll(true);
this.setCursorFixed(true);
$gameTroop.selectAll();
this.updateHelp();
}
};
Window_BattleEnemy.prototype.restoreTarget = function () {
if (!ConfigManager.commandRemember) {
return;
}
var lastTarget = BattleManager.lastTargetedEnemy;
var index = this._enemies.indexOf(lastTarget);
this.select(Math.max(0, index));
if (index === -1 && BD.Core.Settings.enableSideVidwBattler()) {
this.select(this._enemies.length - 1);
} else {
this.select(Math.max(0, index));
}
};
Window_BattleEnemy.prototype.rememberTarget = function () {
if (!ConfigManager.commandRemember) {
return;
}
var action = BattleManager.inputtingAction();
if (!action || action.isForAll() || action.isForRandom()) {
return;
}
BattleManager.lastTargetedEnemy = this.enemy();
};
Window_BattleEnemy.prototype.selectEndOfEnemy = function () {
if (ConfigManager.commandRemember) {
return;
}
this.select(this._enemies.length - 1);
};
var _bdc_Window_BattleEnemy_show = Window_BattleEnemy.prototype.show;
Window_BattleEnemy.prototype.show = function () {
_bdc_Window_BattleEnemy_show.call(this);
this.showHelpWindow();
this.forceTarget();
};
var _bdc_Window_BattleEnemy_hide = Window_BattleEnemy.prototype.hide;
Window_BattleEnemy.prototype.hide = function () {
_bdc_Window_BattleEnemy_hide.call(this);
this.hideHelpWindow();
this.rememberTarget();
};
Window_BattleEnemy.prototype.activate = function () {
Window_Selectable.prototype.activate.call(this);
this.restoreTarget();
};
Window_BattleEnemy.prototype.updateHelp = function () {
this._helpWindow.setBattler(this._enemies[this.index()]);
};
var _bdc_Window_BattleEnemy_select = Window_BattleEnemy.prototype.select;
Window_BattleEnemy.prototype.select = function (index) {
if (this.cursorFixed()) {
return;
}
_bdc_Window_BattleEnemy_select.call(this, index);
};
})();
(function () {
var _bdc_Window_BattleStatus_initialize =
Window_BattleStatus.prototype.initialize;
Window_BattleStatus.prototype.initialize = function () {
_updateMembers.call(this);
BattleManager.registerStartInputCallback(_updateMembers, this);
this._touchSelector = new BD.Core.Targeting.TargetTouchSelector(this);
_bdc_Window_BattleStatus_initialize.call(this);
};
var _bdc_Window_BattleStatus_update = Window_BattleStatus.prototype.update;
Window_BattleStatus.prototype.update = function () {
_bdc_Window_BattleStatus_update.call(this);
this._touchSelector.update();
};
var _bdcx_Window_BattleStatus_refresh = Window_BattleStatus.prototype.refresh;
Window_BattleStatus.prototype.refresh = function () {
_bdcx_Window_BattleStatus_refresh.call(this);
this._touchSelector.setup($gameParty.battleMembers());
};
Window_BattleStatus.prototype.isHorizontal = function () {
return true;
};
Window_BattleStatus.prototype.maxCols = function () {
return this._battleMembers.length;
};
Window_BattleStatus.prototype.maxRows = function () {
return 1;
};
function _updateMembers() {
this._battleMembers = $gameParty.battleMembers();
}
})();
var __extends =
(this && this.__extends) ||
(function () {
var extendStatics =
Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array &&
function (d, b) {
d.__proto__ = b;
}) ||
function (d, b) {
for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
};
return function (d, b) {
extendStatics(d, b);
function __() {
this.constructor = d;
}
d.prototype =
b === null
? Object.create(b)
: ((__.prototype = b.prototype), new __());
};
})();
var BD;
(function (BD) {
var Core;
(function (Core) {
var Targeting;
(function (Targeting) {
var TargetCursor = (function (_super) {
__extends(TargetCursor, _super);
function TargetCursor(settings) {
var _this = _super.call(this) || this;
_this.anchor.x = 0.5;
_this.anchor.y = 0.5;
_this._initMembers();
_this.hide();
_this.setup(settings);
_this._updateFrame();
return _this;
}
TargetCursor.prototype.setup = function (settings) {
var _this = this;
this._fileName = settings.fileName;
this._width = settings.width;
this._animationSpeed = settings.animationSpeed;
this._moveSpeed = settings.moveSpeed;
this._adjustPositionOnActor = settings.adjustPositionOnActor;
this._adjustPositionOnEnemy = settings.adjustPositionOnEnemy;
this._minY = settings.minY;
this._duration = this._animationSpeed;
this.bitmap = ImageManager.loadSystem(this._fileName, 0);
this.bitmap.addLoadListener(function () {
if (TargetCursor.detectedWidth !== -1) {
_this._width = TargetCursor.detectedWidth;
return;
}
if (_this._width === 0) {
var color = _this.bitmap.getPixel(0, 0);
var r = parseInt(color.substring(1, 3), 16);
var g = parseInt(color.substring(3, 5), 16);
var b = parseInt(color.substring(5, 7), 16);
if (r > 0 && g === 0 && b === 0) {
TargetCursor.detectedWidth = r;
_this._width = r;
var a = _this.bitmap._context.createImageData(1, 1);
a.data[3] = 0;
_this.bitmap._context.putImageData(a, 0, 0);
} else {
TargetCursor.detectedWidth = _this._width;
}
}
});
};
TargetCursor.prototype._initMembers = function () {
this._blink = false;
this._pattern = 0;
this._duration = this._animationSpeed;
this._rx = 0;
this._ry = 0;
this._tx = 0;
this._ty = 0;
this._progressRate = null;
};
TargetCursor.prototype.update = function () {
_super.prototype.update.call(this);
this._updatePosition();
this._updateAnimation();
};
TargetCursor.prototype._updateAnimation = function () {
this._duration--;
if (this._duration === 0) {
this._duration = this._animationSpeed;
this._pattern++;
if (this._width * this._pattern >= this.bitmap.width) {
this._pattern = 0;
}
this._updateFrame();
}
this.blendMode = Graphics.BLEND_NORMAL;
if (
this._blink &&
Math.floor(Math.ceil(Graphics.frameCount / 2)) % 2 === 0
) {
this.blendMode = Graphics.BLEND_SCREEN;
}
};
TargetCursor.prototype._updateFrame = function () {
var bitmap = ImageManager.loadSystem(this._fileName, 0);
if (this._width === 0) {
this._width = bitmap.height;
}
this.setFrame(
this._width * this._pattern,
0,
this._width,
bitmap.height
);
};
TargetCursor.prototype._updatePosition = function () {
if (this._progressRate === null) {
this._progressRate = 1;
} else {
this._progressRate = Core.Utils.Interpolator.smooth(
1,
this._progressRate,
this._moveSpeed,
0.005
);
}
if (this._target instanceof Game_Actor && !this._target.hasXpb()) {
this._setTargetPosition(
this._target.cursorX(),
this._target.cursorY()
);
}
this.x = Math.round(
this._rx - (this._rx - this._tx) * this._progressRate
);
this.y = Math.round(
this._ry - (this._ry - this._ty) * this._progressRate
);
};
TargetCursor.prototype._setPosition = function (x, y) {
this._rx = this.x;
this._ry = this.y;
this._setTargetPosition(x, y);
this._progressRate = 0;
};
TargetCursor.prototype._setTargetPosition = function (x, y) {
this._tx = x;
this._ty = Math.max(this._minY, y);
};
TargetCursor.prototype.syncAnimation = function (cursor) {
this._duration = cursor._duration;
this._pattern = cursor._pattern;
this._updateFrame();
};
TargetCursor.prototype.setTarget = function (target, startX, startY) {
var aPos = target.isActor()
? this._adjustPositionOnActor
: this._adjustPositionOnEnemy;
this._setPosition(
target.cursorX() + aPos.x,
target.cursorY() + aPos.y
);
this._blink = target.isSelected();
this._target = target;
this.show();
if (startX && startY) {
this._progressRate = 0;
this._rx = startX;
this._ry = startY;
this._updatePosition();
}
};
TargetCursor.prototype.show = function () {
if (!this.visible) {
this.completeProgress();
}
this.visible = true;
};
TargetCursor.prototype.hide = function () {
this.completeProgress();
this.visible = false;
};
TargetCursor.prototype.completeProgress = function () {
this._progressRate = 1;
this._updatePosition();
};
TargetCursor.detectedWidth = -1;
return TargetCursor;
})(Sprite);
Targeting.TargetCursor = TargetCursor;
})((Targeting = Core.Targeting || (Core.Targeting = {})));
})((Core = BD.Core || (BD.Core = {})));
})(BD || (BD = {}));
var __extends =
(this && this.__extends) ||
(function () {
var extendStatics =
Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array &&
function (d, b) {
d.__proto__ = b;
}) ||
function (d, b) {
for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
};
return function (d, b) {
extendStatics(d, b);
function __() {
this.constructor = d;
}
d.prototype =
b === null
? Object.create(b)
: ((__.prototype = b.prototype), new __());
};
})();
var BD;
(function (BD) {
var Core;
(function (Core) {
var Targeting;
(function (Targeting) {
var TargetCursorLayer = (function (_super) {
__extends(TargetCursorLayer, _super);
function TargetCursorLayer(settings) {
var _this = _super.call(this) || this;
_this._settings = settings;
_this._updateMembers();
BattleManager.registerStartInputCallback(_this._updateMembers, _this);
_this._mainCursor = new Targeting.TargetCursor(_this._settings);
_this.addChild(_this._mainCursor);
_this._subCursors = [];
_this._lastSelectedBattlers = [];
_this._commandActor = false;
return _this;
}
TargetCursorLayer.prototype.update = function () {
_super.prototype.update.call(this);
this._updateTarget();
};
TargetCursorLayer.prototype._updateTarget = function () {
if (Graphics.frameCount % 2 === 0) {
return;
}
var battlers = this._allBattlers.filter(function (x) {
return x.isSelected() && (x.isActor() || x.isAlive());
});
if (battlers.length === 0) {
this._updateCommandActor();
}
if (battlers.length === 1) {
this._updateSingleTarget(battlers[0], false);
} else if (battlers.length > 1) {
this._updateMultipleTarget(battlers);
}
};
TargetCursorLayer.prototype._updateCommandActor = function () {
var c = this._getCommandActor();
if (c) {
this._updateSingleTarget(c, true);
} else if (this._lastSelectedBattlers.length > 0) {
this._lastSelectedBattlers.length = 0;
this._hideMainCursor();
this._hideSubCursors();
}
};
TargetCursorLayer.prototype._updateSingleTarget = function (
selectedBattler,
command
) {
var s = [selectedBattler];
if (
this._lastSelectedBattlers.equals(s) &&
this._commandActor === command
) {
return;
}
this._lastSelectedBattlers = s;
this._commandActor = command;
this._hideSubCursors();
this._mainCursor.setTarget(selectedBattler);
if (command) {
this._mainCursor.completeProgress();
}
};
TargetCursorLayer.prototype._updateMultipleTarget = function (
selectedBattlers
) {
var _this = this;
if (this._lastSelectedBattlers.equals(selectedBattlers)) {
return;
}
this._lastSelectedBattlers = selectedBattlers;
this._commandActor = false;
this._hideSubCursors();
var sb = selectedBattlers.slice();
this._mainCursor.hide();
sb.forEach(function (x) {
return _this._addSubCursor(x);
});
};
TargetCursorLayer.prototype._addSubCursor = function (battler) {
var cursor = new Targeting.TargetCursor(this._settings);
cursor.syncAnimation(this._mainCursor);
cursor.setTarget(battler, this._mainCursor.x, this._mainCursor.y);
this._subCursors.push(cursor);
this.addChild(cursor);
};
TargetCursorLayer.prototype._hideMainCursor = function () {
this._mainCursor.hide();
};
TargetCursorLayer.prototype._hideSubCursors = function () {
var _this = this;
if (this._subCursors.length === 0) {
return;
}
this._subCursors.forEach(function (x) {
return _this.removeChild(x);
});
this._subCursors.length = 0;
};
TargetCursorLayer.prototype._updateMembers = function () {
this._partyBattleMembers = $gameParty.battleMembers();
this._troopMembers = $gameTroop.members();
this._allBattlers = this._partyBattleMembers.concat(
this._troopMembers
);
};
TargetCursorLayer.prototype._getCommandActor = function () {
if (BattleManager._actorIndex > -1) {
return this._partyBattleMembers[BattleManager._actorIndex];
}
return undefined;
};
return TargetCursorLayer;
})(Sprite);
Targeting.TargetCursorLayer = TargetCursorLayer;
})((Targeting = Core.Targeting || (Core.Targeting = {})));
})((Core = BD.Core || (BD.Core = {})));
})(BD || (BD = {}));
var __extends =
(this && this.__extends) ||
(function () {
var extendStatics =
Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array &&
function (d, b) {
d.__proto__ = b;
}) ||
function (d, b) {
for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
};
return function (d, b) {
extendStatics(d, b);
function __() {
this.constructor = d;
}
d.prototype =
b === null
? Object.create(b)
: ((__.prototype = b.prototype), new __());
};
})();
var BD;
(function (BD) {
var Core;
(function (Core) {
var Targeting;
(function (Targeting) {
var InfoSettings = Core.Settings.targetInformation;
var TargetInformationWindow = (function (_super) {
__extends(TargetInformationWindow, _super);
function TargetInformationWindow() {
var _this = _super.call(this, 1) || this;
_this._battler = null;
return _this;
}
TargetInformationWindow.prototype.setBattler = function (battler) {
this._battler = battler;
this.refresh();
};
TargetInformationWindow.prototype.clear = function () {
_super.prototype.clear.call(this);
this.setBattler(null);
};
TargetInformationWindow.prototype.refresh = function () {
this.contents.clear();
this.resetTextColor();
this.resetFontSettings();
var action = BattleManager.inputtingAction();
if (action.isForAll() && action.isForOpponent()) {
this._drawForTroop();
} else if (action.isForRandom() && action.isForOpponent()) {
this._drawForTroopRandom(action.numTargets());
} else if (action.isForAll() && action.isForFriend()) {
this._drawForParty();
} else if (this._battler) {
this._drawTargetInformation(this._battler);
}
};
TargetInformationWindow.prototype._drawForParty = function () {
this.drawText(
InfoSettings().scopeNotation.forParty,
0,
0,
this.contentsWidth(),
"center"
);
};
TargetInformationWindow.prototype._drawForTroop = function () {
this.drawText(
InfoSettings().scopeNotation.forTroop,
0,
0,
this.contentsWidth(),
"center"
);
};
TargetInformationWindow.prototype._drawForTroopRandom = function (
randomNumber
) {
var text =
InfoSettings().scopeNotation.forTroopRandom.format(randomNumber);
this.drawText(text, 0, 0, this.contentsWidth(), "center");
};
TargetInformationWindow.prototype._drawTargetInformation = function (
battler
) {
var settings = battler.isActor()
? InfoSettings().actor
: InfoSettings().enemy;
var gauges = this.gaugeNumber(settings);
var gaugeWidth = InfoSettings().gaugeWidth;
var gaugeMargin = TargetInformationWindow.GAUGE_MARGIN;
var gaugesBaseX =
this.contentsWidth() -
gaugeWidth * gauges -
gaugeMargin * Math.max(0, gauges - 1);
this.drawGauges(settings, battler, gaugesBaseX);
var nameAndStateWidth = gaugesBaseX;
if (gauges > 0) {
nameAndStateWidth -= gaugeMargin;
}
var stateMargin = TargetInformationWindow.STATE_LEFT_MARGIN;
if (settings.states) {
nameAndStateWidth -= stateMargin;
}
var nameWidth = Math.min(
this.contents.measureTextWidth(battler.name()),
nameAndStateWidth
);
var minNameWidth = Math.round(
nameWidth * TargetInformationWindow.MIN_NAME_RATIO
);
var maxStateWidth = Math.round(nameAndStateWidth - minNameWidth);
var stateWidth = 0;
if (settings.states) {
stateWidth = Math.min(
maxStateWidth,
battler.allIcons().length * Window_Base._iconWidth
);
}
var realStateWidth = Math.min(stateWidth, maxStateWidth);
var realNameWidth = Math.min(
nameWidth,
nameAndStateWidth - realStateWidth
);
var realNameAndStateWidth = realNameWidth + realStateWidth;
var nameX = Math.round(
(nameAndStateWidth - realNameAndStateWidth) / 2
);
if (battler.isActor() || settings.hp) {
this.drawActorName(battler, nameX, 0, realNameWidth);
} else {
this.drawText(battler.name(), nameX, 0, realNameWidth);
}
if (settings.states) {
var stateX = nameX + realNameWidth + stateMargin;
this.drawActorIcons(battler, stateX, 0, realStateWidth);
}
};
TargetInformationWindow.prototype.gaugeNumber = function (settings) {
var gauges = 0;
if (settings.hp) {
gauges++;
}
if (settings.mp) {
gauges++;
}
if (settings.tp && Core.Settings.isDisplayTp()) {
gauges++;
}
return gauges;
};
TargetInformationWindow.prototype.drawGauges = function (
settings,
battler,
baseX
) {
var width = InfoSettings().gaugeWidth;
var column = 0;
if (settings.hp) {
this.drawActorHp(battler, this.gaugeX(baseX, column), 0, width);
column++;
}
if (settings.mp) {
this.drawActorMp(battler, this.gaugeX(baseX, column), 0, width);
column++;
}
if (settings.tp && Core.Settings.isDisplayTp()) {
this.drawActorTp(battler, this.gaugeX(baseX, column), 0, width);
}
};
TargetInformationWindow.prototype.gaugeX = function (baseX, column) {
return (
baseX +
InfoSettings().gaugeWidth * column +
TargetInformationWindow.GAUGE_MARGIN * column
);
};
TargetInformationWindow.prototype.setText = function (text) {};
TargetInformationWindow.prototype.setItem = function (item) {};
TargetInformationWindow.prototype.drawActorIcons = function (
actor,
x,
y,
width
) {
var w = width || 144;
var icons = actor.allIcons();
var displayIcons = icons.slice(
0,
Math.floor(w / Window_Base._iconWidth)
);
if (icons > displayIcons) {
var space = (w - 32) / (icons.length - 1);
for (var i = 0; i < icons.length; i++) {
this.drawIcon(icons[i], Math.round(x + space * i), y + 2);
}
} else {
_super.prototype.drawActorIcons.call(this, actor, x, y, width);
}
};
TargetInformationWindow.STATE_LEFT_MARGIN = 4;
TargetInformationWindow.MIN_NAME_RATIO = 0.66;
TargetInformationWindow.GAUGE_MARGIN = 8;
return TargetInformationWindow;
})(Window_Help);
Targeting.TargetInformationWindow = TargetInformationWindow;
})((Targeting = Core.Targeting || (Core.Targeting = {})));
})((Core = BD.Core || (BD.Core = {})));
})(BD || (BD = {}));
var BD;
(function (BD) {
var Core;
(function (Core) {
var Targeting;
(function (Targeting) {
var TargetTouchSelector = (function () {
function TargetTouchSelector(selector) {
this._selector = selector;
this.setup([]);
}
TargetTouchSelector.prototype.setup = function (member) {
this._member = member;
this._sortedMember = member.slice().sort(function (a, b) {
var az = a.screenY() * 100 - a.index();
var bz = b.screenY() * 100 - b.index();
return bz - az;
});
this._stayCount = 0;
};
TargetTouchSelector.prototype.update = function () {
this._stayCount++;
if (
!this._selector.active ||
this._stayCount < TargetTouchSelector.Stay
) {
return;
}
if (this._decision()) {
return;
}
if (this._select()) {
this._stayCount = TargetTouchSelector.StayAfterSelect;
return;
}
};
TargetTouchSelector.prototype._select = function () {
var _this = this;
if (!this._selector.cursorFixed() && TouchInput.isPressed()) {
var target = this._sortedMember.find(function (x) {
return _this._hitTest(x);
});
if (target === undefined) {
return false;
}
var index = this._member.indexOf(target);
if (this._selector.index() === index) {
return false;
}
SoundManager.playCursor();
this._selector.select(index);
return true;
}
return false;
};
TargetTouchSelector.prototype._decision = function () {
var _this = this;
if (TouchInput.isTriggered()) {
if (this._selector.cursorFixed()) {
this._selector.processOk();
return true;
}
var target = this._sortedMember.find(function (x) {
return _this._hitTest(x);
});
if (target === undefined) {
return false;
}
var index = this._member.indexOf(target);
if (this._selector.index() !== index) {
return false;
}
if (!this._selector.cursorFixed()) {
this._selector.select(index);
}
this._selector.processOk();
return true;
}
return false;
};
TargetTouchSelector.prototype._hitTest = function (battler) {
if (
battler.touchInputStatus() !==
Core.Consts.Enums.TouchInputStatus.NoInput
) {
return true;
}
var rect = battler.hitTestRectangle();
var x = TouchInput.x - rect.x;
var y = TouchInput.y - rect.y;
return x >= 0 && y >= 0 && x < rect.width && y < rect.height;
};
TargetTouchSelector.Stay = 12;
TargetTouchSelector.StayAfterSelect = 10;
return TargetTouchSelector;
})();
Targeting.TargetTouchSelector = TargetTouchSelector;
})((Targeting = Core.Targeting || (Core.Targeting = {})));
})((Core = BD.Core || (BD.Core = {})));
})(BD || (BD = {}));
(function () {
var Settings = BD.Core.Settings.windowLayout;
var _bdc_Window_ActorCommand_update = Window_ActorCommand.prototype.update;
Window_ActorCommand.prototype.update = function () {
_bdc_Window_ActorCommand_update.apply(this, arguments);
var a = this._actor;
if (a instanceof Game_Actor && !a.hasXpb()) {
this._updatePosition();
}
};
Window_ActorCommand.prototype.windowWidth = function () {
return Settings().actorCommand.width;
};
Window_ActorCommand.prototype.numVisibleRows = function () {
if (!this._list) {
return 4;
}
var settings = Settings().actorCommand;
var row = settings.heightFitting ? this.maxRows() : settings.visibleRows;
return row;
};
Window_ActorCommand.prototype.maxCols = function () {
var settings = Settings().actorCommand;
var col = settings.isHorizontal ? this.maxItems() : settings.maxCols;
return col.clamp(1, 32);
};
Window_ActorCommand.prototype.refresh = function () {
this._updatePosition();
Window_Command.prototype.refresh.call(this);
};
Window_ActorCommand.prototype._updatePosition = function () {
if (!this._actor) {
return;
}
this.height = this.windowHeight();
var settings = Settings().actorCommand;
var adjustPos = settings.adjustPosition;
var absolutePos = settings.absolutePosition;
if (absolutePos.x !== undefined) {
this.x = absolutePos.x + adjustPos.x;
} else {
var x = (this._actor.cursorX() - this.width / 2 + adjustPos.x).clamp(
8,
Graphics.boxWidth - this.width - 8
);
this.x = x;
}
if (absolutePos.y !== undefined) {
this.y = Math.max(0, absolutePos.y + adjustPos.y);
} else {
this.y = Math.max(0, this._actor.cursorY() - this.height + adjustPos.y);
}
};
Window_ActorCommand.prototype.itemTextAlign = function () {
return Settings().actorCommand.itemAlign;
};
Window_ActorCommand.prototype.activate = function () {
Window_Base.prototype.activate.call(this);
this.reselect();
this.show();
this.open();
this.openness = 255;
};
Window_ActorCommand.prototype.deactivate = function () {
Window_Base.prototype.deactivate.call(this);
this.reselect();
this.hide();
};
})();
(function () {
var _bdc_Window_BattleEnemy_initialize =
Window_BattleEnemy.prototype.initialize;
Window_BattleEnemy.prototype.initialize = function (x, y) {
this.downArrowVisible = false;
this.upArrowVisible = false;
_bdc_Window_BattleEnemy_initialize.call(this, x, y);
};
Window_BattleEnemy.prototype.windowWidth = function () {
return 0;
};
Window_BattleEnemy.prototype.windowHeight = function () {
return 0;
};
Window_BattleEnemy.prototype.drawItem = function (index) {};
})();
(function () {
var _bdc_Window_BattleItem_activate = Window_BattleItem.prototype.activate;
Window_BattleItem.prototype.activate = function () {
_bdc_Window_BattleItem_activate.call(this);
BD.Core.WindowLayout.Utility.fittingWindowItemSkill(this);
};
var _bdc_Window_BattleItem_hide = Window_BattleItem.prototype.hide;
Window_BattleItem.prototype.hide = function () {
_bdc_Window_BattleItem_hide.call(this);
BD.Core.WindowLayout.Utility.fittingWindowItemSkill(this, true);
};
})();
(function () {
var _bdc_Window_BattleSkill_activate = Window_BattleSkill.prototype.activate;
Window_BattleSkill.prototype.activate = function () {
_bdc_Window_BattleSkill_activate.call(this);
BD.Core.WindowLayout.Utility.fittingWindowItemSkill(this);
};
var _bdc_Window_BattleSkill_hide = Window_BattleSkill.prototype.hide;
Window_BattleSkill.prototype.hide = function () {
_bdc_Window_BattleSkill_hide.call(this);
BD.Core.WindowLayout.Utility.fittingWindowItemSkill(this, true);
};
})();
(function () {
var _bdc_Window_BattleStatus_initialize =
Window_BattleStatus.prototype.initialize;
Window_BattleStatus.prototype.initialize = function () {
_bdc_Window_BattleStatus_initialize.call(this);
this.x = Graphics.boxWidth + 48;
};
Window_BattleStatus.prototype.windowWidth = function () {
return 0;
};
Window_BattleStatus.prototype.windowHeight = function () {
return 192;
};
Window_BattleStatus.prototype.drawItem = function (index) {};
})();
(function () {
var _bdc_Game_Message_clear = Game_Message.prototype.clear;
Game_Message.prototype.clear = function () {
_bdc_Game_Message_clear.call(this);
if ($gameParty && $gameParty.inBattle()) {
this._positionType = 0;
}
};
})();
(function () {
var _bdc_Scene_Battle_createMessageWindow =
Scene_Battle.prototype.createMessageWindow;
Scene_Battle.prototype.createMessageWindow = function () {
_bdc_Scene_Battle_createMessageWindow.call(this);
$gameMessage.setPositionType(0);
};
})();
(function () {
var Settings = BD.Core.Settings.windowLayout;
Window_PartyCommand.prototype.windowWidth = function () {
var w = Settings().partyCommand.width;
if (w === undefined) {
return Graphics.boxWidth;
}
return w;
};
Window_PartyCommand.prototype.numVisibleRows = function () {
if (!this._list) {
return 1;
}
var settings = Settings().partyCommand;
var row = settings.heightFitting ? this.maxRows() : settings.visibleRows;
return row;
};
Window_PartyCommand.prototype.maxCols = function () {
var settings = Settings().partyCommand;
var col = settings.isHorizontal ? this.maxItems() : settings.maxCols;
return col.clamp(1, 32);
};
Window_PartyCommand.prototype.itemTextAlign = function () {
return Settings().partyCommand.itemAlign;
};
var _bdc_Window_PartyCommand_setup = Window_PartyCommand.prototype.setup;
Window_PartyCommand.prototype.setup = function () {
_bdc_Window_PartyCommand_setup.call(this);
if (ConfigManager.commandRemember && this._lastIndex) {
this.select(this._lastIndex);
}
var pos = Settings().partyCommand.position;
this.x = pos.x;
this.y = pos.y;
};
Window_PartyCommand.prototype.open = function () {
Window_Selectable.prototype.open.apply(this, arguments);
this.openness = 255;
};
Window_PartyCommand.prototype.close = function () {
Window_Selectable.prototype.close.apply(this, arguments);
if (ConfigManager.commandRemember && this.index() > -1) {
this._lastIndex = this.index();
}
this.openness = 0;
};
Window_PartyCommand.prototype.activate = function () {
Window_Selectable.prototype.activate.apply(this, arguments);
if (typeof Imported !== "undefined" && Imported["SceneFormation"]) {
BattleManager.doStartInputCallback();
}
};
})();
(function () {
Scene_Battle.prototype.updateWindowPositions = function () {};
})();
var BD;
(function (BD) {
var Core;
(function (Core) {
var WindowLayout;
(function (WindowLayout) {
var Utility;
(function (Utility) {
var Settings = BD.Core.Settings;
function fittingWindowItemSkill(window, hide) {
if (hide === void 0) {
hide = false;
}
var setting = Settings.windowLayout().itemSkill;
var fitting = setting.fitting;
var height = setting.maxHeight;
if (hide || !fitting) {
window.height = height;
} else {
var h = height.clamp(0, window.fittingHeight(window.maxRows()));
window.height = h;
}
}
Utility.fittingWindowItemSkill = fittingWindowItemSkill;
})((Utility = WindowLayout.Utility || (WindowLayout.Utility = {})));
})((WindowLayout = Core.WindowLayout || (Core.WindowLayout = {})));
})((Core = BD.Core || (BD.Core = {})));
})(BD || (BD = {}));
Reference in a new issue View git blame Copy permalink