generated from nhcarrigan/template
3700 lines
103 KiB
JavaScript
3700 lines
103 KiB
JavaScript
//=============================================================================
|
|
// rmmz_sprites.js v1.4.4
|
|
//=============================================================================
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Sprite_Clickable
|
|
//
|
|
// The sprite class with click handling functions.
|
|
|
|
function Sprite_Clickable() {
|
|
this.initialize(...arguments);
|
|
}
|
|
|
|
Sprite_Clickable.prototype = Object.create(Sprite.prototype);
|
|
Sprite_Clickable.prototype.constructor = Sprite_Clickable;
|
|
|
|
Sprite_Clickable.prototype.initialize = function() {
|
|
Sprite.prototype.initialize.call(this);
|
|
this._pressed = false;
|
|
this._hovered = false;
|
|
};
|
|
|
|
Sprite_Clickable.prototype.update = function() {
|
|
Sprite.prototype.update.call(this);
|
|
this.processTouch();
|
|
};
|
|
|
|
Sprite_Clickable.prototype.processTouch = function() {
|
|
if (this.isClickEnabled()) {
|
|
if (this.isBeingTouched()) {
|
|
if (!this._hovered && TouchInput.isHovered()) {
|
|
this._hovered = true;
|
|
this.onMouseEnter();
|
|
}
|
|
if (TouchInput.isTriggered()) {
|
|
this._pressed = true;
|
|
this.onPress();
|
|
}
|
|
} else {
|
|
if (this._hovered) {
|
|
this.onMouseExit();
|
|
}
|
|
this._pressed = false;
|
|
this._hovered = false;
|
|
}
|
|
if (this._pressed && TouchInput.isReleased()) {
|
|
this._pressed = false;
|
|
this.onClick();
|
|
}
|
|
} else {
|
|
this._pressed = false;
|
|
this._hovered = false;
|
|
}
|
|
};
|
|
|
|
Sprite_Clickable.prototype.isPressed = function() {
|
|
return this._pressed;
|
|
};
|
|
|
|
Sprite_Clickable.prototype.isClickEnabled = function() {
|
|
return this.worldVisible;
|
|
};
|
|
|
|
Sprite_Clickable.prototype.isBeingTouched = function() {
|
|
const touchPos = new Point(TouchInput.x, TouchInput.y);
|
|
const localPos = this.worldTransform.applyInverse(touchPos);
|
|
return this.hitTest(localPos.x, localPos.y);
|
|
};
|
|
|
|
Sprite_Clickable.prototype.hitTest = function(x, y) {
|
|
const rect = new Rectangle(
|
|
-this.anchor.x * this.width,
|
|
-this.anchor.y * this.height,
|
|
this.width,
|
|
this.height
|
|
);
|
|
return rect.contains(x, y);
|
|
};
|
|
|
|
Sprite_Clickable.prototype.onMouseEnter = function() {
|
|
//
|
|
};
|
|
|
|
Sprite_Clickable.prototype.onMouseExit = function() {
|
|
//
|
|
};
|
|
|
|
Sprite_Clickable.prototype.onPress = function() {
|
|
//
|
|
};
|
|
|
|
Sprite_Clickable.prototype.onClick = function() {
|
|
//
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Sprite_Button
|
|
//
|
|
// The sprite for displaying a button.
|
|
|
|
function Sprite_Button() {
|
|
this.initialize(...arguments);
|
|
}
|
|
|
|
Sprite_Button.prototype = Object.create(Sprite_Clickable.prototype);
|
|
Sprite_Button.prototype.constructor = Sprite_Button;
|
|
|
|
Sprite_Button.prototype.initialize = function(buttonType) {
|
|
Sprite_Clickable.prototype.initialize.call(this);
|
|
this._buttonType = buttonType;
|
|
this._clickHandler = null;
|
|
this._coldFrame = null;
|
|
this._hotFrame = null;
|
|
this.setupFrames();
|
|
};
|
|
|
|
Sprite_Button.prototype.setupFrames = function() {
|
|
const data = this.buttonData();
|
|
const x = data.x * this.blockWidth();
|
|
const width = data.w * this.blockWidth();
|
|
const height = this.blockHeight();
|
|
this.loadButtonImage();
|
|
this.setColdFrame(x, 0, width, height);
|
|
this.setHotFrame(x, height, width, height);
|
|
this.updateFrame();
|
|
this.updateOpacity();
|
|
};
|
|
|
|
Sprite_Button.prototype.blockWidth = function() {
|
|
return 48;
|
|
};
|
|
|
|
Sprite_Button.prototype.blockHeight = function() {
|
|
return 48;
|
|
};
|
|
|
|
Sprite_Button.prototype.loadButtonImage = function() {
|
|
this.bitmap = ImageManager.loadSystem("ButtonSet");
|
|
};
|
|
|
|
Sprite_Button.prototype.buttonData = function() {
|
|
const buttonTable = {
|
|
cancel: { x: 0, w: 2 },
|
|
pageup: { x: 2, w: 1 },
|
|
pagedown: { x: 3, w: 1 },
|
|
down: { x: 4, w: 1 },
|
|
up: { x: 5, w: 1 },
|
|
down2: { x: 6, w: 1 },
|
|
up2: { x: 7, w: 1 },
|
|
ok: { x: 8, w: 2 },
|
|
menu: { x: 10, w: 1 }
|
|
};
|
|
return buttonTable[this._buttonType];
|
|
};
|
|
|
|
Sprite_Button.prototype.update = function() {
|
|
Sprite_Clickable.prototype.update.call(this);
|
|
this.checkBitmap();
|
|
this.updateFrame();
|
|
this.updateOpacity();
|
|
this.processTouch();
|
|
};
|
|
|
|
Sprite_Button.prototype.checkBitmap = function() {
|
|
if (this.bitmap.isReady() && this.bitmap.width < this.blockWidth() * 11) {
|
|
// Probably MV image is used
|
|
throw new Error("ButtonSet image is too small");
|
|
}
|
|
};
|
|
|
|
Sprite_Button.prototype.updateFrame = function() {
|
|
const frame = this.isPressed() ? this._hotFrame : this._coldFrame;
|
|
if (frame) {
|
|
this.setFrame(frame.x, frame.y, frame.width, frame.height);
|
|
}
|
|
};
|
|
|
|
Sprite_Button.prototype.updateOpacity = function() {
|
|
this.opacity = this._pressed ? 255 : 192;
|
|
};
|
|
|
|
Sprite_Button.prototype.setColdFrame = function(x, y, width, height) {
|
|
this._coldFrame = new Rectangle(x, y, width, height);
|
|
};
|
|
|
|
Sprite_Button.prototype.setHotFrame = function(x, y, width, height) {
|
|
this._hotFrame = new Rectangle(x, y, width, height);
|
|
};
|
|
|
|
Sprite_Button.prototype.setClickHandler = function(method) {
|
|
this._clickHandler = method;
|
|
};
|
|
|
|
Sprite_Button.prototype.onClick = function() {
|
|
if (this._clickHandler) {
|
|
this._clickHandler();
|
|
} else {
|
|
Input.virtualClick(this._buttonType);
|
|
}
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Sprite_Character
|
|
//
|
|
// The sprite for displaying a character.
|
|
|
|
function Sprite_Character() {
|
|
this.initialize(...arguments);
|
|
}
|
|
|
|
Sprite_Character.prototype = Object.create(Sprite.prototype);
|
|
Sprite_Character.prototype.constructor = Sprite_Character;
|
|
|
|
Sprite_Character.prototype.initialize = function(character) {
|
|
Sprite.prototype.initialize.call(this);
|
|
this.initMembers();
|
|
this.setCharacter(character);
|
|
};
|
|
|
|
Sprite_Character.prototype.initMembers = function() {
|
|
this.anchor.x = 0.5;
|
|
this.anchor.y = 1;
|
|
this._character = null;
|
|
this._balloonDuration = 0;
|
|
this._tilesetId = 0;
|
|
this._upperBody = null;
|
|
this._lowerBody = null;
|
|
};
|
|
|
|
Sprite_Character.prototype.setCharacter = function(character) {
|
|
this._character = character;
|
|
};
|
|
|
|
Sprite_Character.prototype.checkCharacter = function(character) {
|
|
return this._character === character;
|
|
};
|
|
|
|
Sprite_Character.prototype.update = function() {
|
|
Sprite.prototype.update.call(this);
|
|
this.updateBitmap();
|
|
this.updateFrame();
|
|
this.updatePosition();
|
|
this.updateOther();
|
|
this.updateVisibility();
|
|
};
|
|
|
|
Sprite_Character.prototype.updateVisibility = function() {
|
|
Sprite.prototype.updateVisibility.call(this);
|
|
if (this.isEmptyCharacter() || this._character.isTransparent()) {
|
|
this.visible = false;
|
|
}
|
|
};
|
|
|
|
Sprite_Character.prototype.isTile = function() {
|
|
return this._character.isTile();
|
|
};
|
|
|
|
Sprite_Character.prototype.isObjectCharacter = function() {
|
|
return this._character.isObjectCharacter();
|
|
};
|
|
|
|
Sprite_Character.prototype.isEmptyCharacter = function() {
|
|
return this._tileId === 0 && !this._characterName;
|
|
};
|
|
|
|
Sprite_Character.prototype.tilesetBitmap = function(tileId) {
|
|
const tileset = $gameMap.tileset();
|
|
const setNumber = 5 + Math.floor(tileId / 256);
|
|
return ImageManager.loadTileset(tileset.tilesetNames[setNumber]);
|
|
};
|
|
|
|
Sprite_Character.prototype.updateBitmap = function() {
|
|
if (this.isImageChanged()) {
|
|
this._tilesetId = $gameMap.tilesetId();
|
|
this._tileId = this._character.tileId();
|
|
this._characterName = this._character.characterName();
|
|
this._characterIndex = this._character.characterIndex();
|
|
if (this._tileId > 0) {
|
|
this.setTileBitmap();
|
|
} else {
|
|
this.setCharacterBitmap();
|
|
}
|
|
}
|
|
};
|
|
|
|
Sprite_Character.prototype.isImageChanged = function() {
|
|
return (
|
|
this._tilesetId !== $gameMap.tilesetId() ||
|
|
this._tileId !== this._character.tileId() ||
|
|
this._characterName !== this._character.characterName() ||
|
|
this._characterIndex !== this._character.characterIndex()
|
|
);
|
|
};
|
|
|
|
Sprite_Character.prototype.setTileBitmap = function() {
|
|
this.bitmap = this.tilesetBitmap(this._tileId);
|
|
};
|
|
|
|
Sprite_Character.prototype.setCharacterBitmap = function() {
|
|
this.bitmap = ImageManager.loadCharacter(this._characterName);
|
|
this._isBigCharacter = ImageManager.isBigCharacter(this._characterName);
|
|
};
|
|
|
|
Sprite_Character.prototype.updateFrame = function() {
|
|
if (this.bitmap.isReady()) {
|
|
if (this._tileId > 0) {
|
|
this.updateTileFrame();
|
|
} else {
|
|
this.updateCharacterFrame();
|
|
}
|
|
}
|
|
};
|
|
|
|
Sprite_Character.prototype.updateTileFrame = function() {
|
|
const tileId = this._tileId;
|
|
const pw = this.patternWidth();
|
|
const ph = this.patternHeight();
|
|
const sx = ((Math.floor(tileId / 128) % 2) * 8 + (tileId % 8)) * pw;
|
|
const sy = (Math.floor((tileId % 256) / 8) % 16) * ph;
|
|
this.setFrame(sx, sy, pw, ph);
|
|
};
|
|
|
|
Sprite_Character.prototype.updateCharacterFrame = function() {
|
|
const pw = this.patternWidth();
|
|
const ph = this.patternHeight();
|
|
const sx = (this.characterBlockX() + this.characterPatternX()) * pw;
|
|
const sy = (this.characterBlockY() + this.characterPatternY()) * ph;
|
|
this.updateHalfBodySprites();
|
|
if (this._bushDepth > 0) {
|
|
const d = this._bushDepth;
|
|
this._upperBody.setFrame(sx, sy, pw, ph - d);
|
|
this._lowerBody.setFrame(sx, sy + ph - d, pw, d);
|
|
this.setFrame(sx, sy, 0, ph);
|
|
} else {
|
|
this.setFrame(sx, sy, pw, ph);
|
|
}
|
|
};
|
|
|
|
Sprite_Character.prototype.characterBlockX = function() {
|
|
if (this._isBigCharacter) {
|
|
return 0;
|
|
} else {
|
|
const index = this._character.characterIndex();
|
|
return (index % 4) * 3;
|
|
}
|
|
};
|
|
|
|
Sprite_Character.prototype.characterBlockY = function() {
|
|
if (this._isBigCharacter) {
|
|
return 0;
|
|
} else {
|
|
const index = this._character.characterIndex();
|
|
return Math.floor(index / 4) * 4;
|
|
}
|
|
};
|
|
|
|
Sprite_Character.prototype.characterPatternX = function() {
|
|
return this._character.pattern();
|
|
};
|
|
|
|
Sprite_Character.prototype.characterPatternY = function() {
|
|
return (this._character.direction() - 2) / 2;
|
|
};
|
|
|
|
Sprite_Character.prototype.patternWidth = function() {
|
|
if (this._tileId > 0) {
|
|
return $gameMap.tileWidth();
|
|
} else if (this._isBigCharacter) {
|
|
return this.bitmap.width / 3;
|
|
} else {
|
|
return this.bitmap.width / 12;
|
|
}
|
|
};
|
|
|
|
Sprite_Character.prototype.patternHeight = function() {
|
|
if (this._tileId > 0) {
|
|
return $gameMap.tileHeight();
|
|
} else if (this._isBigCharacter) {
|
|
return this.bitmap.height / 4;
|
|
} else {
|
|
return this.bitmap.height / 8;
|
|
}
|
|
};
|
|
|
|
Sprite_Character.prototype.updateHalfBodySprites = function() {
|
|
if (this._bushDepth > 0) {
|
|
this.createHalfBodySprites();
|
|
this._upperBody.bitmap = this.bitmap;
|
|
this._upperBody.visible = true;
|
|
this._upperBody.y = -this._bushDepth;
|
|
this._lowerBody.bitmap = this.bitmap;
|
|
this._lowerBody.visible = true;
|
|
this._upperBody.setBlendColor(this.getBlendColor());
|
|
this._lowerBody.setBlendColor(this.getBlendColor());
|
|
this._upperBody.setColorTone(this.getColorTone());
|
|
this._lowerBody.setColorTone(this.getColorTone());
|
|
this._upperBody.blendMode = this.blendMode;
|
|
this._lowerBody.blendMode = this.blendMode;
|
|
} else if (this._upperBody) {
|
|
this._upperBody.visible = false;
|
|
this._lowerBody.visible = false;
|
|
}
|
|
};
|
|
|
|
Sprite_Character.prototype.createHalfBodySprites = function() {
|
|
if (!this._upperBody) {
|
|
this._upperBody = new Sprite();
|
|
this._upperBody.anchor.x = 0.5;
|
|
this._upperBody.anchor.y = 1;
|
|
this.addChild(this._upperBody);
|
|
}
|
|
if (!this._lowerBody) {
|
|
this._lowerBody = new Sprite();
|
|
this._lowerBody.anchor.x = 0.5;
|
|
this._lowerBody.anchor.y = 1;
|
|
this._lowerBody.opacity = 128;
|
|
this.addChild(this._lowerBody);
|
|
}
|
|
};
|
|
|
|
Sprite_Character.prototype.updatePosition = function() {
|
|
this.x = this._character.screenX();
|
|
this.y = this._character.screenY();
|
|
this.z = this._character.screenZ();
|
|
};
|
|
|
|
Sprite_Character.prototype.updateOther = function() {
|
|
this.opacity = this._character.opacity();
|
|
this.blendMode = this._character.blendMode();
|
|
this._bushDepth = this._character.bushDepth();
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Sprite_Battler
|
|
//
|
|
// The superclass of Sprite_Actor and Sprite_Enemy.
|
|
|
|
function Sprite_Battler() {
|
|
this.initialize(...arguments);
|
|
}
|
|
|
|
Sprite_Battler.prototype = Object.create(Sprite_Clickable.prototype);
|
|
Sprite_Battler.prototype.constructor = Sprite_Battler;
|
|
|
|
Sprite_Battler.prototype.initialize = function(battler) {
|
|
Sprite_Clickable.prototype.initialize.call(this);
|
|
this.initMembers();
|
|
this.setBattler(battler);
|
|
};
|
|
|
|
Sprite_Battler.prototype.initMembers = function() {
|
|
this.anchor.x = 0.5;
|
|
this.anchor.y = 1;
|
|
this._battler = null;
|
|
this._damages = [];
|
|
this._homeX = 0;
|
|
this._homeY = 0;
|
|
this._offsetX = 0;
|
|
this._offsetY = 0;
|
|
this._targetOffsetX = NaN;
|
|
this._targetOffsetY = NaN;
|
|
this._movementDuration = 0;
|
|
this._selectionEffectCount = 0;
|
|
};
|
|
|
|
Sprite_Battler.prototype.setBattler = function(battler) {
|
|
this._battler = battler;
|
|
};
|
|
|
|
Sprite_Battler.prototype.checkBattler = function(battler) {
|
|
return this._battler === battler;
|
|
};
|
|
|
|
Sprite_Battler.prototype.mainSprite = function() {
|
|
return this;
|
|
};
|
|
|
|
Sprite_Battler.prototype.setHome = function(x, y) {
|
|
this._homeX = x;
|
|
this._homeY = y;
|
|
this.updatePosition();
|
|
};
|
|
|
|
Sprite_Battler.prototype.update = function() {
|
|
Sprite_Clickable.prototype.update.call(this);
|
|
if (this._battler) {
|
|
this.updateMain();
|
|
this.updateDamagePopup();
|
|
this.updateSelectionEffect();
|
|
this.updateVisibility();
|
|
} else {
|
|
this.bitmap = null;
|
|
}
|
|
};
|
|
|
|
Sprite_Battler.prototype.updateVisibility = function() {
|
|
Sprite_Clickable.prototype.updateVisibility.call(this);
|
|
if (!this._battler || !this._battler.isSpriteVisible()) {
|
|
this.visible = false;
|
|
}
|
|
};
|
|
|
|
Sprite_Battler.prototype.updateMain = function() {
|
|
if (this._battler.isSpriteVisible()) {
|
|
this.updateBitmap();
|
|
this.updateFrame();
|
|
}
|
|
this.updateMove();
|
|
this.updatePosition();
|
|
};
|
|
|
|
Sprite_Battler.prototype.updateBitmap = function() {
|
|
//
|
|
};
|
|
|
|
Sprite_Battler.prototype.updateFrame = function() {
|
|
//
|
|
};
|
|
|
|
Sprite_Battler.prototype.updateMove = function() {
|
|
if (this._movementDuration > 0) {
|
|
const d = this._movementDuration;
|
|
this._offsetX = (this._offsetX * (d - 1) + this._targetOffsetX) / d;
|
|
this._offsetY = (this._offsetY * (d - 1) + this._targetOffsetY) / d;
|
|
this._movementDuration--;
|
|
if (this._movementDuration === 0) {
|
|
this.onMoveEnd();
|
|
}
|
|
}
|
|
};
|
|
|
|
Sprite_Battler.prototype.updatePosition = function() {
|
|
this.x = this._homeX + this._offsetX;
|
|
this.y = this._homeY + this._offsetY;
|
|
};
|
|
|
|
Sprite_Battler.prototype.updateDamagePopup = function() {
|
|
this.setupDamagePopup();
|
|
if (this._damages.length > 0) {
|
|
for (const damage of this._damages) {
|
|
damage.update();
|
|
}
|
|
if (!this._damages[0].isPlaying()) {
|
|
this.destroyDamageSprite(this._damages[0]);
|
|
}
|
|
}
|
|
};
|
|
|
|
Sprite_Battler.prototype.updateSelectionEffect = function() {
|
|
const target = this.mainSprite();
|
|
if (this._battler.isSelected()) {
|
|
this._selectionEffectCount++;
|
|
if (this._selectionEffectCount % 30 < 15) {
|
|
target.setBlendColor([255, 255, 255, 64]);
|
|
} else {
|
|
target.setBlendColor([0, 0, 0, 0]);
|
|
}
|
|
} else if (this._selectionEffectCount > 0) {
|
|
this._selectionEffectCount = 0;
|
|
target.setBlendColor([0, 0, 0, 0]);
|
|
}
|
|
};
|
|
|
|
Sprite_Battler.prototype.setupDamagePopup = function() {
|
|
if (this._battler.isDamagePopupRequested()) {
|
|
if (this._battler.isSpriteVisible()) {
|
|
this.createDamageSprite();
|
|
}
|
|
this._battler.clearDamagePopup();
|
|
this._battler.clearResult();
|
|
}
|
|
};
|
|
|
|
Sprite_Battler.prototype.createDamageSprite = function() {
|
|
const last = this._damages[this._damages.length - 1];
|
|
const sprite = new Sprite_Damage();
|
|
if (last) {
|
|
sprite.x = last.x + 8;
|
|
sprite.y = last.y - 16;
|
|
} else {
|
|
sprite.x = this.x + this.damageOffsetX();
|
|
sprite.y = this.y + this.damageOffsetY();
|
|
}
|
|
sprite.setup(this._battler);
|
|
this._damages.push(sprite);
|
|
this.parent.addChild(sprite);
|
|
};
|
|
|
|
Sprite_Battler.prototype.destroyDamageSprite = function(sprite) {
|
|
this.parent.removeChild(sprite);
|
|
this._damages.remove(sprite);
|
|
sprite.destroy();
|
|
};
|
|
|
|
Sprite_Battler.prototype.damageOffsetX = function() {
|
|
return 0;
|
|
};
|
|
|
|
Sprite_Battler.prototype.damageOffsetY = function() {
|
|
return 0;
|
|
};
|
|
|
|
Sprite_Battler.prototype.startMove = function(x, y, duration) {
|
|
if (this._targetOffsetX !== x || this._targetOffsetY !== y) {
|
|
this._targetOffsetX = x;
|
|
this._targetOffsetY = y;
|
|
this._movementDuration = duration;
|
|
if (duration === 0) {
|
|
this._offsetX = x;
|
|
this._offsetY = y;
|
|
}
|
|
}
|
|
};
|
|
|
|
Sprite_Battler.prototype.onMoveEnd = function() {
|
|
//
|
|
};
|
|
|
|
Sprite_Battler.prototype.isEffecting = function() {
|
|
return false;
|
|
};
|
|
|
|
Sprite_Battler.prototype.isMoving = function() {
|
|
return this._movementDuration > 0;
|
|
};
|
|
|
|
Sprite_Battler.prototype.inHomePosition = function() {
|
|
return this._offsetX === 0 && this._offsetY === 0;
|
|
};
|
|
|
|
Sprite_Battler.prototype.onMouseEnter = function() {
|
|
$gameTemp.setTouchState(this._battler, "select");
|
|
};
|
|
|
|
Sprite_Battler.prototype.onPress = function() {
|
|
$gameTemp.setTouchState(this._battler, "select");
|
|
};
|
|
|
|
Sprite_Battler.prototype.onClick = function() {
|
|
$gameTemp.setTouchState(this._battler, "click");
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Sprite_Actor
|
|
//
|
|
// The sprite for displaying an actor.
|
|
|
|
function Sprite_Actor() {
|
|
this.initialize(...arguments);
|
|
}
|
|
|
|
Sprite_Actor.prototype = Object.create(Sprite_Battler.prototype);
|
|
Sprite_Actor.prototype.constructor = Sprite_Actor;
|
|
|
|
Sprite_Actor.MOTIONS = {
|
|
walk: { index: 0, loop: true },
|
|
wait: { index: 1, loop: true },
|
|
chant: { index: 2, loop: true },
|
|
guard: { index: 3, loop: true },
|
|
damage: { index: 4, loop: false },
|
|
evade: { index: 5, loop: false },
|
|
thrust: { index: 6, loop: false },
|
|
swing: { index: 7, loop: false },
|
|
missile: { index: 8, loop: false },
|
|
skill: { index: 9, loop: false },
|
|
spell: { index: 10, loop: false },
|
|
item: { index: 11, loop: false },
|
|
escape: { index: 12, loop: true },
|
|
victory: { index: 13, loop: true },
|
|
dying: { index: 14, loop: true },
|
|
abnormal: { index: 15, loop: true },
|
|
sleep: { index: 16, loop: true },
|
|
dead: { index: 17, loop: true }
|
|
};
|
|
|
|
Sprite_Actor.prototype.initialize = function(battler) {
|
|
Sprite_Battler.prototype.initialize.call(this, battler);
|
|
this.moveToStartPosition();
|
|
};
|
|
|
|
Sprite_Actor.prototype.initMembers = function() {
|
|
Sprite_Battler.prototype.initMembers.call(this);
|
|
this._battlerName = "";
|
|
this._motion = null;
|
|
this._motionCount = 0;
|
|
this._pattern = 0;
|
|
this.createShadowSprite();
|
|
this.createWeaponSprite();
|
|
this.createMainSprite();
|
|
this.createStateSprite();
|
|
};
|
|
|
|
Sprite_Actor.prototype.mainSprite = function() {
|
|
return this._mainSprite;
|
|
};
|
|
|
|
Sprite_Actor.prototype.createMainSprite = function() {
|
|
this._mainSprite = new Sprite();
|
|
this._mainSprite.anchor.x = 0.5;
|
|
this._mainSprite.anchor.y = 1;
|
|
this.addChild(this._mainSprite);
|
|
};
|
|
|
|
Sprite_Actor.prototype.createShadowSprite = function() {
|
|
this._shadowSprite = new Sprite();
|
|
this._shadowSprite.bitmap = ImageManager.loadSystem("Shadow2");
|
|
this._shadowSprite.anchor.x = 0.5;
|
|
this._shadowSprite.anchor.y = 0.5;
|
|
this._shadowSprite.y = -2;
|
|
this.addChild(this._shadowSprite);
|
|
};
|
|
|
|
Sprite_Actor.prototype.createWeaponSprite = function() {
|
|
this._weaponSprite = new Sprite_Weapon();
|
|
this.addChild(this._weaponSprite);
|
|
};
|
|
|
|
Sprite_Actor.prototype.createStateSprite = function() {
|
|
this._stateSprite = new Sprite_StateOverlay();
|
|
this.addChild(this._stateSprite);
|
|
};
|
|
|
|
Sprite_Actor.prototype.setBattler = function(battler) {
|
|
Sprite_Battler.prototype.setBattler.call(this, battler);
|
|
if (battler !== this._actor) {
|
|
this._actor = battler;
|
|
if (battler) {
|
|
this.setActorHome(battler.index());
|
|
} else {
|
|
this._mainSprite.bitmap = null;
|
|
this._battlerName = "";
|
|
}
|
|
this.startEntryMotion();
|
|
this._stateSprite.setup(battler);
|
|
}
|
|
};
|
|
|
|
Sprite_Actor.prototype.moveToStartPosition = function() {
|
|
this.startMove(300, 0, 0);
|
|
};
|
|
|
|
Sprite_Actor.prototype.setActorHome = function(index) {
|
|
this.setHome(600 + index * 32, 280 + index * 48);
|
|
};
|
|
|
|
Sprite_Actor.prototype.update = function() {
|
|
Sprite_Battler.prototype.update.call(this);
|
|
this.updateShadow();
|
|
if (this._actor) {
|
|
this.updateMotion();
|
|
}
|
|
};
|
|
|
|
Sprite_Actor.prototype.updateShadow = function() {
|
|
this._shadowSprite.visible = !!this._actor;
|
|
};
|
|
|
|
Sprite_Actor.prototype.updateMain = function() {
|
|
Sprite_Battler.prototype.updateMain.call(this);
|
|
if (this._actor.isSpriteVisible() && !this.isMoving()) {
|
|
this.updateTargetPosition();
|
|
}
|
|
};
|
|
|
|
Sprite_Actor.prototype.setupMotion = function() {
|
|
if (this._actor.isMotionRequested()) {
|
|
this.startMotion(this._actor.motionType());
|
|
this._actor.clearMotion();
|
|
}
|
|
};
|
|
|
|
Sprite_Actor.prototype.setupWeaponAnimation = function() {
|
|
if (this._actor.isWeaponAnimationRequested()) {
|
|
this._weaponSprite.setup(this._actor.weaponImageId());
|
|
this._actor.clearWeaponAnimation();
|
|
}
|
|
};
|
|
|
|
Sprite_Actor.prototype.startMotion = function(motionType) {
|
|
const newMotion = Sprite_Actor.MOTIONS[motionType];
|
|
if (this._motion !== newMotion) {
|
|
this._motion = newMotion;
|
|
this._motionCount = 0;
|
|
this._pattern = 0;
|
|
}
|
|
};
|
|
|
|
Sprite_Actor.prototype.updateTargetPosition = function() {
|
|
if (this._actor.canMove() && BattleManager.isEscaped()) {
|
|
this.retreat();
|
|
} else if (this.shouldStepForward()) {
|
|
this.stepForward();
|
|
} else if (!this.inHomePosition()) {
|
|
this.stepBack();
|
|
}
|
|
};
|
|
|
|
Sprite_Actor.prototype.shouldStepForward = function() {
|
|
return this._actor.isInputting() || this._actor.isActing();
|
|
};
|
|
|
|
Sprite_Actor.prototype.updateBitmap = function() {
|
|
Sprite_Battler.prototype.updateBitmap.call(this);
|
|
const name = this._actor.battlerName();
|
|
if (this._battlerName !== name) {
|
|
this._battlerName = name;
|
|
this._mainSprite.bitmap = ImageManager.loadSvActor(name);
|
|
}
|
|
};
|
|
|
|
Sprite_Actor.prototype.updateFrame = function() {
|
|
Sprite_Battler.prototype.updateFrame.call(this);
|
|
const bitmap = this._mainSprite.bitmap;
|
|
if (bitmap) {
|
|
const motionIndex = this._motion ? this._motion.index : 0;
|
|
const pattern = this._pattern < 3 ? this._pattern : 1;
|
|
const cw = bitmap.width / 9;
|
|
const ch = bitmap.height / 6;
|
|
const cx = Math.floor(motionIndex / 6) * 3 + pattern;
|
|
const cy = motionIndex % 6;
|
|
this._mainSprite.setFrame(cx * cw, cy * ch, cw, ch);
|
|
this.setFrame(0, 0, cw, ch);
|
|
}
|
|
};
|
|
|
|
Sprite_Actor.prototype.updateMove = function() {
|
|
const bitmap = this._mainSprite.bitmap;
|
|
if (!bitmap || bitmap.isReady()) {
|
|
Sprite_Battler.prototype.updateMove.call(this);
|
|
}
|
|
};
|
|
|
|
Sprite_Actor.prototype.updateMotion = function() {
|
|
this.setupMotion();
|
|
this.setupWeaponAnimation();
|
|
if (this._actor.isMotionRefreshRequested()) {
|
|
this.refreshMotion();
|
|
this._actor.clearMotion();
|
|
}
|
|
this.updateMotionCount();
|
|
};
|
|
|
|
Sprite_Actor.prototype.updateMotionCount = function() {
|
|
if (this._motion && ++this._motionCount >= this.motionSpeed()) {
|
|
if (this._motion.loop) {
|
|
this._pattern = (this._pattern + 1) % 4;
|
|
} else if (this._pattern < 2) {
|
|
this._pattern++;
|
|
} else {
|
|
this.refreshMotion();
|
|
}
|
|
this._motionCount = 0;
|
|
}
|
|
};
|
|
|
|
Sprite_Actor.prototype.motionSpeed = function() {
|
|
return 12;
|
|
};
|
|
|
|
Sprite_Actor.prototype.refreshMotion = function() {
|
|
const actor = this._actor;
|
|
if (actor) {
|
|
const stateMotion = actor.stateMotionIndex();
|
|
if (actor.isInputting() || actor.isActing()) {
|
|
this.startMotion("walk");
|
|
} else if (stateMotion === 3) {
|
|
this.startMotion("dead");
|
|
} else if (stateMotion === 2) {
|
|
this.startMotion("sleep");
|
|
} else if (actor.isChanting()) {
|
|
this.startMotion("chant");
|
|
} else if (actor.isGuard() || actor.isGuardWaiting()) {
|
|
this.startMotion("guard");
|
|
} else if (stateMotion === 1) {
|
|
this.startMotion("abnormal");
|
|
} else if (actor.isDying()) {
|
|
this.startMotion("dying");
|
|
} else if (actor.isUndecided()) {
|
|
this.startMotion("walk");
|
|
} else {
|
|
this.startMotion("wait");
|
|
}
|
|
}
|
|
};
|
|
|
|
Sprite_Actor.prototype.startEntryMotion = function() {
|
|
if (this._actor && this._actor.canMove()) {
|
|
this.startMotion("walk");
|
|
this.startMove(0, 0, 30);
|
|
} else if (!this.isMoving()) {
|
|
this.refreshMotion();
|
|
this.startMove(0, 0, 0);
|
|
}
|
|
};
|
|
|
|
Sprite_Actor.prototype.stepForward = function() {
|
|
this.startMove(-48, 0, 12);
|
|
};
|
|
|
|
Sprite_Actor.prototype.stepBack = function() {
|
|
this.startMove(0, 0, 12);
|
|
};
|
|
|
|
Sprite_Actor.prototype.retreat = function() {
|
|
this.startMove(300, 0, 30);
|
|
};
|
|
|
|
Sprite_Actor.prototype.onMoveEnd = function() {
|
|
Sprite_Battler.prototype.onMoveEnd.call(this);
|
|
if (!BattleManager.isBattleEnd()) {
|
|
this.refreshMotion();
|
|
}
|
|
};
|
|
|
|
Sprite_Actor.prototype.damageOffsetX = function() {
|
|
return Sprite_Battler.prototype.damageOffsetX.call(this) - 32;
|
|
};
|
|
|
|
Sprite_Actor.prototype.damageOffsetY = function() {
|
|
return Sprite_Battler.prototype.damageOffsetY.call(this);
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Sprite_Enemy
|
|
//
|
|
// The sprite for displaying an enemy.
|
|
|
|
function Sprite_Enemy() {
|
|
this.initialize(...arguments);
|
|
}
|
|
|
|
Sprite_Enemy.prototype = Object.create(Sprite_Battler.prototype);
|
|
Sprite_Enemy.prototype.constructor = Sprite_Enemy;
|
|
|
|
Sprite_Enemy.prototype.initialize = function(battler) {
|
|
Sprite_Battler.prototype.initialize.call(this, battler);
|
|
};
|
|
|
|
Sprite_Enemy.prototype.initMembers = function() {
|
|
Sprite_Battler.prototype.initMembers.call(this);
|
|
this._enemy = null;
|
|
this._appeared = false;
|
|
this._battlerName = "";
|
|
this._battlerHue = 0;
|
|
this._effectType = null;
|
|
this._effectDuration = 0;
|
|
this._shake = 0;
|
|
this.createStateIconSprite();
|
|
};
|
|
|
|
Sprite_Enemy.prototype.createStateIconSprite = function() {
|
|
this._stateIconSprite = new Sprite_StateIcon();
|
|
this.addChild(this._stateIconSprite);
|
|
};
|
|
|
|
Sprite_Enemy.prototype.setBattler = function(battler) {
|
|
Sprite_Battler.prototype.setBattler.call(this, battler);
|
|
this._enemy = battler;
|
|
this.setHome(battler.screenX(), battler.screenY());
|
|
this._stateIconSprite.setup(battler);
|
|
};
|
|
|
|
Sprite_Enemy.prototype.update = function() {
|
|
Sprite_Battler.prototype.update.call(this);
|
|
if (this._enemy) {
|
|
this.updateEffect();
|
|
this.updateStateSprite();
|
|
}
|
|
};
|
|
|
|
Sprite_Enemy.prototype.updateBitmap = function() {
|
|
Sprite_Battler.prototype.updateBitmap.call(this);
|
|
const name = this._enemy.battlerName();
|
|
const hue = this._enemy.battlerHue();
|
|
if (this._battlerName !== name || this._battlerHue !== hue) {
|
|
this._battlerName = name;
|
|
this._battlerHue = hue;
|
|
this.loadBitmap(name);
|
|
this.setHue(hue);
|
|
this.initVisibility();
|
|
}
|
|
};
|
|
|
|
Sprite_Enemy.prototype.loadBitmap = function(name) {
|
|
if ($gameSystem.isSideView()) {
|
|
this.bitmap = ImageManager.loadSvEnemy(name);
|
|
} else {
|
|
this.bitmap = ImageManager.loadEnemy(name);
|
|
}
|
|
};
|
|
|
|
Sprite_Enemy.prototype.setHue = function(hue) {
|
|
Sprite_Battler.prototype.setHue.call(this, hue);
|
|
for (const child of this.children) {
|
|
if (child.setHue) {
|
|
child.setHue(-hue);
|
|
}
|
|
}
|
|
};
|
|
|
|
Sprite_Enemy.prototype.updateFrame = function() {
|
|
Sprite_Battler.prototype.updateFrame.call(this);
|
|
if (this._effectType === "bossCollapse") {
|
|
this.setFrame(0, 0, this.bitmap.width, this._effectDuration);
|
|
} else {
|
|
this.setFrame(0, 0, this.bitmap.width, this.bitmap.height);
|
|
}
|
|
};
|
|
|
|
Sprite_Enemy.prototype.updatePosition = function() {
|
|
Sprite_Battler.prototype.updatePosition.call(this);
|
|
this.x += this._shake;
|
|
};
|
|
|
|
Sprite_Enemy.prototype.updateStateSprite = function() {
|
|
this._stateIconSprite.y = -Math.round((this.bitmap.height + 40) * 0.9);
|
|
if (this._stateIconSprite.y < 20 - this.y) {
|
|
this._stateIconSprite.y = 20 - this.y;
|
|
}
|
|
};
|
|
|
|
Sprite_Enemy.prototype.initVisibility = function() {
|
|
this._appeared = this._enemy.isAlive();
|
|
if (!this._appeared) {
|
|
this.opacity = 0;
|
|
}
|
|
};
|
|
|
|
Sprite_Enemy.prototype.setupEffect = function() {
|
|
if (this._appeared && this._enemy.isEffectRequested()) {
|
|
this.startEffect(this._enemy.effectType());
|
|
this._enemy.clearEffect();
|
|
}
|
|
if (!this._appeared && this._enemy.isAlive()) {
|
|
this.startEffect("appear");
|
|
} else if (this._appeared && this._enemy.isHidden()) {
|
|
this.startEffect("disappear");
|
|
}
|
|
};
|
|
|
|
Sprite_Enemy.prototype.startEffect = function(effectType) {
|
|
this._effectType = effectType;
|
|
switch (this._effectType) {
|
|
case "appear":
|
|
this.startAppear();
|
|
break;
|
|
case "disappear":
|
|
this.startDisappear();
|
|
break;
|
|
case "whiten":
|
|
this.startWhiten();
|
|
break;
|
|
case "blink":
|
|
this.startBlink();
|
|
break;
|
|
case "collapse":
|
|
this.startCollapse();
|
|
break;
|
|
case "bossCollapse":
|
|
this.startBossCollapse();
|
|
break;
|
|
case "instantCollapse":
|
|
this.startInstantCollapse();
|
|
break;
|
|
}
|
|
this.revertToNormal();
|
|
};
|
|
|
|
Sprite_Enemy.prototype.startAppear = function() {
|
|
this._effectDuration = 16;
|
|
this._appeared = true;
|
|
};
|
|
|
|
Sprite_Enemy.prototype.startDisappear = function() {
|
|
this._effectDuration = 32;
|
|
this._appeared = false;
|
|
};
|
|
|
|
Sprite_Enemy.prototype.startWhiten = function() {
|
|
this._effectDuration = 16;
|
|
};
|
|
|
|
Sprite_Enemy.prototype.startBlink = function() {
|
|
this._effectDuration = 20;
|
|
};
|
|
|
|
Sprite_Enemy.prototype.startCollapse = function() {
|
|
this._effectDuration = 32;
|
|
this._appeared = false;
|
|
};
|
|
|
|
Sprite_Enemy.prototype.startBossCollapse = function() {
|
|
this._effectDuration = this.bitmap.height;
|
|
this._appeared = false;
|
|
};
|
|
|
|
Sprite_Enemy.prototype.startInstantCollapse = function() {
|
|
this._effectDuration = 16;
|
|
this._appeared = false;
|
|
};
|
|
|
|
Sprite_Enemy.prototype.updateEffect = function() {
|
|
this.setupEffect();
|
|
if (this._effectDuration > 0) {
|
|
this._effectDuration--;
|
|
switch (this._effectType) {
|
|
case "whiten":
|
|
this.updateWhiten();
|
|
break;
|
|
case "blink":
|
|
this.updateBlink();
|
|
break;
|
|
case "appear":
|
|
this.updateAppear();
|
|
break;
|
|
case "disappear":
|
|
this.updateDisappear();
|
|
break;
|
|
case "collapse":
|
|
this.updateCollapse();
|
|
break;
|
|
case "bossCollapse":
|
|
this.updateBossCollapse();
|
|
break;
|
|
case "instantCollapse":
|
|
this.updateInstantCollapse();
|
|
break;
|
|
}
|
|
if (this._effectDuration === 0) {
|
|
this._effectType = null;
|
|
}
|
|
}
|
|
};
|
|
|
|
Sprite_Enemy.prototype.isEffecting = function() {
|
|
return this._effectType !== null;
|
|
};
|
|
|
|
Sprite_Enemy.prototype.revertToNormal = function() {
|
|
this._shake = 0;
|
|
this.blendMode = 0;
|
|
this.opacity = 255;
|
|
this.setBlendColor([0, 0, 0, 0]);
|
|
};
|
|
|
|
Sprite_Enemy.prototype.updateWhiten = function() {
|
|
const alpha = 128 - (16 - this._effectDuration) * 8;
|
|
this.setBlendColor([255, 255, 255, alpha]);
|
|
};
|
|
|
|
Sprite_Enemy.prototype.updateBlink = function() {
|
|
this.opacity = this._effectDuration % 10 < 5 ? 255 : 0;
|
|
};
|
|
|
|
Sprite_Enemy.prototype.updateAppear = function() {
|
|
this.opacity = (16 - this._effectDuration) * 16;
|
|
};
|
|
|
|
Sprite_Enemy.prototype.updateDisappear = function() {
|
|
this.opacity = 256 - (32 - this._effectDuration) * 10;
|
|
};
|
|
|
|
Sprite_Enemy.prototype.updateCollapse = function() {
|
|
this.blendMode = 1;
|
|
this.setBlendColor([255, 128, 128, 128]);
|
|
this.opacity *= this._effectDuration / (this._effectDuration + 1);
|
|
};
|
|
|
|
Sprite_Enemy.prototype.updateBossCollapse = function() {
|
|
this._shake = (this._effectDuration % 2) * 4 - 2;
|
|
this.blendMode = 1;
|
|
this.opacity *= this._effectDuration / (this._effectDuration + 1);
|
|
this.setBlendColor([255, 255, 255, 255 - this.opacity]);
|
|
if (this._effectDuration % 20 === 19) {
|
|
SoundManager.playBossCollapse2();
|
|
}
|
|
};
|
|
|
|
Sprite_Enemy.prototype.updateInstantCollapse = function() {
|
|
this.opacity = 0;
|
|
};
|
|
|
|
Sprite_Enemy.prototype.damageOffsetX = function() {
|
|
return Sprite_Battler.prototype.damageOffsetX.call(this);
|
|
};
|
|
|
|
Sprite_Enemy.prototype.damageOffsetY = function() {
|
|
return Sprite_Battler.prototype.damageOffsetY.call(this) - 8;
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Sprite_Animation
|
|
//
|
|
// The sprite for displaying an animation.
|
|
|
|
function Sprite_Animation() {
|
|
this.initialize(...arguments);
|
|
}
|
|
|
|
Sprite_Animation.prototype = Object.create(Sprite.prototype);
|
|
Sprite_Animation.prototype.constructor = Sprite_Animation;
|
|
|
|
Sprite_Animation.prototype.initialize = function() {
|
|
Sprite.prototype.initialize.call(this);
|
|
this.initMembers();
|
|
};
|
|
|
|
Sprite_Animation.prototype.initMembers = function() {
|
|
this._targets = [];
|
|
this._animation = null;
|
|
this._mirror = false;
|
|
this._delay = 0;
|
|
this._previous = null;
|
|
this._effect = null;
|
|
this._handle = null;
|
|
this._playing = false;
|
|
this._started = false;
|
|
this._frameIndex = 0;
|
|
this._maxTimingFrames = 0;
|
|
this._flashColor = [0, 0, 0, 0];
|
|
this._flashDuration = 0;
|
|
this._viewportSize = 4096;
|
|
this.z = 8;
|
|
};
|
|
|
|
Sprite_Animation.prototype.destroy = function(options) {
|
|
Sprite.prototype.destroy.call(this, options);
|
|
if (this._handle) {
|
|
this._handle.stop();
|
|
}
|
|
this._effect = null;
|
|
this._handle = null;
|
|
this._playing = false;
|
|
this._started = false;
|
|
};
|
|
|
|
// prettier-ignore
|
|
Sprite_Animation.prototype.setup = function(
|
|
targets, animation, mirror, delay, previous
|
|
) {
|
|
this._targets = targets;
|
|
this._animation = animation;
|
|
this._mirror = mirror;
|
|
this._delay = delay;
|
|
this._previous = previous;
|
|
this._effect = EffectManager.load(animation.effectName);
|
|
this._playing = true;
|
|
const timings = animation.soundTimings.concat(animation.flashTimings);
|
|
for (const timing of timings) {
|
|
if (timing.frame > this._maxTimingFrames) {
|
|
this._maxTimingFrames = timing.frame;
|
|
}
|
|
}
|
|
};
|
|
|
|
Sprite_Animation.prototype.update = function() {
|
|
Sprite.prototype.update.call(this);
|
|
if (this._delay > 0) {
|
|
this._delay--;
|
|
} else if (this._playing) {
|
|
if (!this._started && this.canStart()) {
|
|
if (this._effect) {
|
|
if (this._effect.isLoaded) {
|
|
this._handle = Graphics.effekseer.play(this._effect);
|
|
this._started = true;
|
|
} else {
|
|
EffectManager.checkErrors();
|
|
}
|
|
} else {
|
|
this._started = true;
|
|
}
|
|
}
|
|
if (this._started) {
|
|
this.updateEffectGeometry();
|
|
this.updateMain();
|
|
this.updateFlash();
|
|
}
|
|
}
|
|
};
|
|
|
|
Sprite_Animation.prototype.canStart = function() {
|
|
if (this._previous && this.shouldWaitForPrevious()) {
|
|
return !this._previous.isPlaying();
|
|
} else {
|
|
return true;
|
|
}
|
|
};
|
|
|
|
Sprite_Animation.prototype.shouldWaitForPrevious = function() {
|
|
// [Note] Older versions of Effekseer were very heavy on some mobile
|
|
// devices. We don't need this anymore.
|
|
return false;
|
|
};
|
|
|
|
Sprite_Animation.prototype.updateEffectGeometry = function() {
|
|
const scale = this._animation.scale / 100;
|
|
const r = Math.PI / 180;
|
|
const rx = this._animation.rotation.x * r;
|
|
const ry = this._animation.rotation.y * r;
|
|
const rz = this._animation.rotation.z * r;
|
|
if (this._handle) {
|
|
this._handle.setLocation(0, 0, 0);
|
|
this._handle.setRotation(rx, ry, rz);
|
|
this._handle.setScale(scale, scale, scale);
|
|
this._handle.setSpeed(this._animation.speed / 100);
|
|
}
|
|
};
|
|
|
|
Sprite_Animation.prototype.updateMain = function() {
|
|
this.processSoundTimings();
|
|
this.processFlashTimings();
|
|
this._frameIndex++;
|
|
this.checkEnd();
|
|
};
|
|
|
|
Sprite_Animation.prototype.processSoundTimings = function() {
|
|
for (const timing of this._animation.soundTimings) {
|
|
if (timing.frame === this._frameIndex) {
|
|
AudioManager.playSe(timing.se);
|
|
}
|
|
}
|
|
};
|
|
|
|
Sprite_Animation.prototype.processFlashTimings = function() {
|
|
for (const timing of this._animation.flashTimings) {
|
|
if (timing.frame === this._frameIndex) {
|
|
this._flashColor = timing.color.clone();
|
|
this._flashDuration = timing.duration;
|
|
}
|
|
}
|
|
};
|
|
|
|
Sprite_Animation.prototype.checkEnd = function() {
|
|
if (
|
|
this._frameIndex > this._maxTimingFrames &&
|
|
this._flashDuration === 0 &&
|
|
!(this._handle && this._handle.exists)
|
|
) {
|
|
this._playing = false;
|
|
}
|
|
};
|
|
|
|
Sprite_Animation.prototype.updateFlash = function() {
|
|
if (this._flashDuration > 0) {
|
|
const d = this._flashDuration--;
|
|
this._flashColor[3] *= (d - 1) / d;
|
|
for (const target of this._targets) {
|
|
target.setBlendColor(this._flashColor);
|
|
}
|
|
}
|
|
};
|
|
|
|
Sprite_Animation.prototype.isPlaying = function() {
|
|
return this._playing;
|
|
};
|
|
|
|
Sprite_Animation.prototype.setRotation = function(x, y, z) {
|
|
if (this._handle) {
|
|
this._handle.setRotation(x, y, z);
|
|
}
|
|
};
|
|
|
|
Sprite_Animation.prototype._render = function(renderer) {
|
|
if (this._targets.length > 0 && this._handle && this._handle.exists) {
|
|
this.onBeforeRender(renderer);
|
|
this.setProjectionMatrix(renderer);
|
|
this.setCameraMatrix(renderer);
|
|
this.setViewport(renderer);
|
|
Graphics.effekseer.beginDraw();
|
|
Graphics.effekseer.drawHandle(this._handle);
|
|
Graphics.effekseer.endDraw();
|
|
this.resetViewport(renderer);
|
|
this.onAfterRender(renderer);
|
|
}
|
|
};
|
|
|
|
Sprite_Animation.prototype.setProjectionMatrix = function(renderer) {
|
|
const x = this._mirror ? -1 : 1;
|
|
const y = -1;
|
|
const p = -(this._viewportSize / renderer.view.height);
|
|
// prettier-ignore
|
|
Graphics.effekseer.setProjectionMatrix([
|
|
x, 0, 0, 0,
|
|
0, y, 0, 0,
|
|
0, 0, 1, p,
|
|
0, 0, 0, 1,
|
|
]);
|
|
};
|
|
|
|
Sprite_Animation.prototype.setCameraMatrix = function(/*renderer*/) {
|
|
// prettier-ignore
|
|
Graphics.effekseer.setCameraMatrix([
|
|
1, 0, 0, 0,
|
|
0, 1, 0, 0,
|
|
0, 0, 1, 0,
|
|
0, 0, -10, 1
|
|
]);
|
|
};
|
|
|
|
Sprite_Animation.prototype.setViewport = function(renderer) {
|
|
const vw = this._viewportSize;
|
|
const vh = this._viewportSize;
|
|
const vx = this._animation.offsetX - vw / 2;
|
|
const vy = this._animation.offsetY - vh / 2;
|
|
const pos = this.targetPosition(renderer);
|
|
renderer.gl.viewport(vx + pos.x, vy + pos.y, vw, vh);
|
|
};
|
|
|
|
Sprite_Animation.prototype.targetPosition = function(renderer) {
|
|
const pos = new Point();
|
|
if (this._animation.displayType === 2) {
|
|
pos.x = renderer.view.width / 2;
|
|
pos.y = renderer.view.height / 2;
|
|
} else {
|
|
for (const target of this._targets) {
|
|
const tpos = this.targetSpritePosition(target);
|
|
pos.x += tpos.x;
|
|
pos.y += tpos.y;
|
|
}
|
|
pos.x /= this._targets.length;
|
|
pos.y /= this._targets.length;
|
|
}
|
|
return pos;
|
|
};
|
|
|
|
Sprite_Animation.prototype.targetSpritePosition = function(sprite) {
|
|
const point = new Point(0, -sprite.height / 2);
|
|
if (this._animation.alignBottom) {
|
|
point.y = 0;
|
|
}
|
|
sprite.updateTransform();
|
|
return sprite.worldTransform.apply(point);
|
|
};
|
|
|
|
Sprite_Animation.prototype.resetViewport = function(renderer) {
|
|
renderer.gl.viewport(0, 0, renderer.view.width, renderer.view.height);
|
|
};
|
|
|
|
Sprite_Animation.prototype.onBeforeRender = function(renderer) {
|
|
renderer.batch.flush();
|
|
renderer.geometry.reset();
|
|
};
|
|
|
|
Sprite_Animation.prototype.onAfterRender = function(renderer) {
|
|
renderer.texture.reset();
|
|
renderer.geometry.reset();
|
|
renderer.state.reset();
|
|
renderer.shader.reset();
|
|
renderer.framebuffer.reset();
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Sprite_AnimationMV
|
|
//
|
|
// The sprite for displaying an old format animation.
|
|
|
|
function Sprite_AnimationMV() {
|
|
this.initialize(...arguments);
|
|
}
|
|
|
|
Sprite_AnimationMV.prototype = Object.create(Sprite.prototype);
|
|
Sprite_AnimationMV.prototype.constructor = Sprite_AnimationMV;
|
|
|
|
Sprite_AnimationMV.prototype.initialize = function() {
|
|
Sprite.prototype.initialize.call(this);
|
|
this.initMembers();
|
|
};
|
|
|
|
Sprite_AnimationMV.prototype.initMembers = function() {
|
|
this._targets = [];
|
|
this._animation = null;
|
|
this._mirror = false;
|
|
this._delay = 0;
|
|
this._rate = 4;
|
|
this._duration = 0;
|
|
this._flashColor = [0, 0, 0, 0];
|
|
this._flashDuration = 0;
|
|
this._screenFlashDuration = 0;
|
|
this._hidingDuration = 0;
|
|
this._hue1 = 0;
|
|
this._hue2 = 0;
|
|
this._bitmap1 = null;
|
|
this._bitmap2 = null;
|
|
this._cellSprites = [];
|
|
this._screenFlashSprite = null;
|
|
this.z = 8;
|
|
};
|
|
|
|
// prettier-ignore
|
|
Sprite_AnimationMV.prototype.setup = function(
|
|
targets, animation, mirror, delay
|
|
) {
|
|
this._targets = targets;
|
|
this._animation = animation;
|
|
this._mirror = mirror;
|
|
this._delay = delay;
|
|
if (this._animation) {
|
|
this.setupRate();
|
|
this.setupDuration();
|
|
this.loadBitmaps();
|
|
this.createCellSprites();
|
|
this.createScreenFlashSprite();
|
|
}
|
|
};
|
|
|
|
Sprite_AnimationMV.prototype.setupRate = function() {
|
|
this._rate = 4;
|
|
};
|
|
|
|
Sprite_AnimationMV.prototype.setupDuration = function() {
|
|
this._duration = this._animation.frames.length * this._rate + 1;
|
|
};
|
|
|
|
Sprite_AnimationMV.prototype.update = function() {
|
|
Sprite.prototype.update.call(this);
|
|
this.updateMain();
|
|
this.updateFlash();
|
|
this.updateScreenFlash();
|
|
this.updateHiding();
|
|
};
|
|
|
|
Sprite_AnimationMV.prototype.updateFlash = function() {
|
|
if (this._flashDuration > 0) {
|
|
const d = this._flashDuration--;
|
|
this._flashColor[3] *= (d - 1) / d;
|
|
for (const target of this._targets) {
|
|
target.setBlendColor(this._flashColor);
|
|
}
|
|
}
|
|
};
|
|
|
|
Sprite_AnimationMV.prototype.updateScreenFlash = function() {
|
|
if (this._screenFlashDuration > 0) {
|
|
const d = this._screenFlashDuration--;
|
|
if (this._screenFlashSprite) {
|
|
this._screenFlashSprite.x = -this.absoluteX();
|
|
this._screenFlashSprite.y = -this.absoluteY();
|
|
this._screenFlashSprite.opacity *= (d - 1) / d;
|
|
this._screenFlashSprite.visible = this._screenFlashDuration > 0;
|
|
}
|
|
}
|
|
};
|
|
|
|
Sprite_AnimationMV.prototype.absoluteX = function() {
|
|
let x = 0;
|
|
let object = this;
|
|
while (object) {
|
|
x += object.x;
|
|
object = object.parent;
|
|
}
|
|
return x;
|
|
};
|
|
|
|
Sprite_AnimationMV.prototype.absoluteY = function() {
|
|
let y = 0;
|
|
let object = this;
|
|
while (object) {
|
|
y += object.y;
|
|
object = object.parent;
|
|
}
|
|
return y;
|
|
};
|
|
|
|
Sprite_AnimationMV.prototype.updateHiding = function() {
|
|
if (this._hidingDuration > 0) {
|
|
this._hidingDuration--;
|
|
if (this._hidingDuration === 0) {
|
|
for (const target of this._targets) {
|
|
target.show();
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
Sprite_AnimationMV.prototype.isPlaying = function() {
|
|
return this._duration > 0;
|
|
};
|
|
|
|
Sprite_AnimationMV.prototype.loadBitmaps = function() {
|
|
const name1 = this._animation.animation1Name;
|
|
const name2 = this._animation.animation2Name;
|
|
this._hue1 = this._animation.animation1Hue;
|
|
this._hue2 = this._animation.animation2Hue;
|
|
this._bitmap1 = ImageManager.loadAnimation(name1);
|
|
this._bitmap2 = ImageManager.loadAnimation(name2);
|
|
};
|
|
|
|
Sprite_AnimationMV.prototype.isReady = function() {
|
|
return (
|
|
this._bitmap1 &&
|
|
this._bitmap1.isReady() &&
|
|
this._bitmap2 &&
|
|
this._bitmap2.isReady()
|
|
);
|
|
};
|
|
|
|
Sprite_AnimationMV.prototype.createCellSprites = function() {
|
|
this._cellSprites = [];
|
|
for (let i = 0; i < 16; i++) {
|
|
const sprite = new Sprite();
|
|
sprite.anchor.x = 0.5;
|
|
sprite.anchor.y = 0.5;
|
|
this._cellSprites.push(sprite);
|
|
this.addChild(sprite);
|
|
}
|
|
};
|
|
|
|
Sprite_AnimationMV.prototype.createScreenFlashSprite = function() {
|
|
this._screenFlashSprite = new ScreenSprite();
|
|
this.addChild(this._screenFlashSprite);
|
|
};
|
|
|
|
Sprite_AnimationMV.prototype.updateMain = function() {
|
|
if (this.isPlaying() && this.isReady()) {
|
|
if (this._delay > 0) {
|
|
this._delay--;
|
|
} else {
|
|
this._duration--;
|
|
this.updatePosition();
|
|
if (this._duration % this._rate === 0) {
|
|
this.updateFrame();
|
|
}
|
|
if (this._duration <= 0) {
|
|
this.onEnd();
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
Sprite_AnimationMV.prototype.updatePosition = function() {
|
|
if (this._animation.position === 3) {
|
|
this.x = this.parent.width / 2;
|
|
this.y = this.parent.height / 2;
|
|
} else if (this._targets.length > 0) {
|
|
const target = this._targets[0];
|
|
const parent = target.parent;
|
|
const grandparent = parent ? parent.parent : null;
|
|
this.x = target.x;
|
|
this.y = target.y;
|
|
if (this.parent === grandparent) {
|
|
this.x += parent.x;
|
|
this.y += parent.y;
|
|
}
|
|
if (this._animation.position === 0) {
|
|
this.y -= target.height;
|
|
} else if (this._animation.position === 1) {
|
|
this.y -= target.height / 2;
|
|
}
|
|
}
|
|
};
|
|
|
|
Sprite_AnimationMV.prototype.updateFrame = function() {
|
|
if (this._duration > 0) {
|
|
const frameIndex = this.currentFrameIndex();
|
|
this.updateAllCellSprites(this._animation.frames[frameIndex]);
|
|
for (const timing of this._animation.timings) {
|
|
if (timing.frame === frameIndex) {
|
|
this.processTimingData(timing);
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
Sprite_AnimationMV.prototype.currentFrameIndex = function() {
|
|
return (
|
|
this._animation.frames.length -
|
|
Math.floor((this._duration + this._rate - 1) / this._rate)
|
|
);
|
|
};
|
|
|
|
Sprite_AnimationMV.prototype.updateAllCellSprites = function(frame) {
|
|
if (this._targets.length > 0) {
|
|
for (let i = 0; i < this._cellSprites.length; i++) {
|
|
const sprite = this._cellSprites[i];
|
|
if (i < frame.length) {
|
|
this.updateCellSprite(sprite, frame[i]);
|
|
} else {
|
|
sprite.visible = false;
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
Sprite_AnimationMV.prototype.updateCellSprite = function(sprite, cell) {
|
|
const pattern = cell[0];
|
|
if (pattern >= 0) {
|
|
const sx = (pattern % 5) * 192;
|
|
const sy = Math.floor((pattern % 100) / 5) * 192;
|
|
const mirror = this._mirror;
|
|
sprite.bitmap = pattern < 100 ? this._bitmap1 : this._bitmap2;
|
|
sprite.setHue(pattern < 100 ? this._hue1 : this._hue2);
|
|
sprite.setFrame(sx, sy, 192, 192);
|
|
sprite.x = cell[1];
|
|
sprite.y = cell[2];
|
|
sprite.rotation = (cell[4] * Math.PI) / 180;
|
|
sprite.scale.x = cell[3] / 100;
|
|
|
|
if (cell[5]) {
|
|
sprite.scale.x *= -1;
|
|
}
|
|
if (mirror) {
|
|
sprite.x *= -1;
|
|
sprite.rotation *= -1;
|
|
sprite.scale.x *= -1;
|
|
}
|
|
|
|
sprite.scale.y = cell[3] / 100;
|
|
sprite.opacity = cell[6];
|
|
sprite.blendMode = cell[7];
|
|
sprite.visible = true;
|
|
} else {
|
|
sprite.visible = false;
|
|
}
|
|
};
|
|
|
|
Sprite_AnimationMV.prototype.processTimingData = function(timing) {
|
|
const duration = timing.flashDuration * this._rate;
|
|
switch (timing.flashScope) {
|
|
case 1:
|
|
this.startFlash(timing.flashColor, duration);
|
|
break;
|
|
case 2:
|
|
this.startScreenFlash(timing.flashColor, duration);
|
|
break;
|
|
case 3:
|
|
this.startHiding(duration);
|
|
break;
|
|
}
|
|
if (timing.se) {
|
|
AudioManager.playSe(timing.se);
|
|
}
|
|
};
|
|
|
|
Sprite_AnimationMV.prototype.startFlash = function(color, duration) {
|
|
this._flashColor = color.clone();
|
|
this._flashDuration = duration;
|
|
};
|
|
|
|
Sprite_AnimationMV.prototype.startScreenFlash = function(color, duration) {
|
|
this._screenFlashDuration = duration;
|
|
if (this._screenFlashSprite) {
|
|
this._screenFlashSprite.setColor(color[0], color[1], color[2]);
|
|
this._screenFlashSprite.opacity = color[3];
|
|
}
|
|
};
|
|
|
|
Sprite_AnimationMV.prototype.startHiding = function(duration) {
|
|
this._hidingDuration = duration;
|
|
for (const target of this._targets) {
|
|
target.hide();
|
|
}
|
|
};
|
|
|
|
Sprite_AnimationMV.prototype.onEnd = function() {
|
|
this._flashDuration = 0;
|
|
this._screenFlashDuration = 0;
|
|
this._hidingDuration = 0;
|
|
for (const target of this._targets) {
|
|
target.setBlendColor([0, 0, 0, 0]);
|
|
target.show();
|
|
}
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Sprite_Battleback
|
|
//
|
|
// The sprite for displaying a background image in battle.
|
|
|
|
function Sprite_Battleback() {
|
|
this.initialize(...arguments);
|
|
}
|
|
|
|
Sprite_Battleback.prototype = Object.create(TilingSprite.prototype);
|
|
Sprite_Battleback.prototype.constructor = Sprite_Battleback;
|
|
|
|
Sprite_Battleback.prototype.initialize = function(type) {
|
|
TilingSprite.prototype.initialize.call(this);
|
|
if (type === 0) {
|
|
this.bitmap = this.battleback1Bitmap();
|
|
} else {
|
|
this.bitmap = this.battleback2Bitmap();
|
|
}
|
|
};
|
|
|
|
Sprite_Battleback.prototype.adjustPosition = function() {
|
|
this.width = Math.floor((1000 * Graphics.width) / 816);
|
|
this.height = Math.floor((740 * Graphics.height) / 624);
|
|
this.x = (Graphics.width - this.width) / 2;
|
|
if ($gameSystem.isSideView()) {
|
|
this.y = Graphics.height - this.height;
|
|
} else {
|
|
this.y = 0;
|
|
}
|
|
const ratioX = this.width / this.bitmap.width;
|
|
const ratioY = this.height / this.bitmap.height;
|
|
const scale = Math.max(ratioX, ratioY, 1.0);
|
|
this.scale.x = scale;
|
|
this.scale.y = scale;
|
|
};
|
|
|
|
Sprite_Battleback.prototype.battleback1Bitmap = function() {
|
|
return ImageManager.loadBattleback1(this.battleback1Name());
|
|
};
|
|
|
|
Sprite_Battleback.prototype.battleback2Bitmap = function() {
|
|
return ImageManager.loadBattleback2(this.battleback2Name());
|
|
};
|
|
|
|
Sprite_Battleback.prototype.battleback1Name = function() {
|
|
if (BattleManager.isBattleTest()) {
|
|
return $dataSystem.battleback1Name;
|
|
} else if ($gameMap.battleback1Name() !== null) {
|
|
return $gameMap.battleback1Name();
|
|
} else if ($gameMap.isOverworld()) {
|
|
return this.overworldBattleback1Name();
|
|
} else {
|
|
return "";
|
|
}
|
|
};
|
|
|
|
Sprite_Battleback.prototype.battleback2Name = function() {
|
|
if (BattleManager.isBattleTest()) {
|
|
return $dataSystem.battleback2Name;
|
|
} else if ($gameMap.battleback2Name() !== null) {
|
|
return $gameMap.battleback2Name();
|
|
} else if ($gameMap.isOverworld()) {
|
|
return this.overworldBattleback2Name();
|
|
} else {
|
|
return "";
|
|
}
|
|
};
|
|
|
|
Sprite_Battleback.prototype.overworldBattleback1Name = function() {
|
|
if ($gamePlayer.isInVehicle()) {
|
|
return this.shipBattleback1Name();
|
|
} else {
|
|
return this.normalBattleback1Name();
|
|
}
|
|
};
|
|
|
|
Sprite_Battleback.prototype.overworldBattleback2Name = function() {
|
|
if ($gamePlayer.isInVehicle()) {
|
|
return this.shipBattleback2Name();
|
|
} else {
|
|
return this.normalBattleback2Name();
|
|
}
|
|
};
|
|
|
|
Sprite_Battleback.prototype.normalBattleback1Name = function() {
|
|
return (
|
|
this.terrainBattleback1Name(this.autotileType(1)) ||
|
|
this.terrainBattleback1Name(this.autotileType(0)) ||
|
|
this.defaultBattleback1Name()
|
|
);
|
|
};
|
|
|
|
Sprite_Battleback.prototype.normalBattleback2Name = function() {
|
|
return (
|
|
this.terrainBattleback2Name(this.autotileType(1)) ||
|
|
this.terrainBattleback2Name(this.autotileType(0)) ||
|
|
this.defaultBattleback2Name()
|
|
);
|
|
};
|
|
|
|
Sprite_Battleback.prototype.terrainBattleback1Name = function(type) {
|
|
switch (type) {
|
|
case 24:
|
|
case 25:
|
|
return "Wasteland";
|
|
case 26:
|
|
case 27:
|
|
return "DirtField";
|
|
case 32:
|
|
case 33:
|
|
return "Desert";
|
|
case 34:
|
|
return "Lava1";
|
|
case 35:
|
|
return "Lava2";
|
|
case 40:
|
|
case 41:
|
|
return "Snowfield";
|
|
case 42:
|
|
return "Clouds";
|
|
case 4:
|
|
case 5:
|
|
return "PoisonSwamp";
|
|
default:
|
|
return null;
|
|
}
|
|
};
|
|
|
|
Sprite_Battleback.prototype.terrainBattleback2Name = function(type) {
|
|
switch (type) {
|
|
case 20:
|
|
case 21:
|
|
return "Forest";
|
|
case 22:
|
|
case 30:
|
|
case 38:
|
|
return "Cliff";
|
|
case 24:
|
|
case 25:
|
|
case 26:
|
|
case 27:
|
|
return "Wasteland";
|
|
case 32:
|
|
case 33:
|
|
return "Desert";
|
|
case 34:
|
|
case 35:
|
|
return "Lava";
|
|
case 40:
|
|
case 41:
|
|
return "Snowfield";
|
|
case 42:
|
|
return "Clouds";
|
|
case 4:
|
|
case 5:
|
|
return "PoisonSwamp";
|
|
}
|
|
};
|
|
|
|
Sprite_Battleback.prototype.defaultBattleback1Name = function() {
|
|
return "Grassland";
|
|
};
|
|
|
|
Sprite_Battleback.prototype.defaultBattleback2Name = function() {
|
|
return "Grassland";
|
|
};
|
|
|
|
Sprite_Battleback.prototype.shipBattleback1Name = function() {
|
|
return "Ship";
|
|
};
|
|
|
|
Sprite_Battleback.prototype.shipBattleback2Name = function() {
|
|
return "Ship";
|
|
};
|
|
|
|
Sprite_Battleback.prototype.autotileType = function(z) {
|
|
return $gameMap.autotileType($gamePlayer.x, $gamePlayer.y, z);
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Sprite_Damage
|
|
//
|
|
// The sprite for displaying a popup damage.
|
|
|
|
function Sprite_Damage() {
|
|
this.initialize(...arguments);
|
|
}
|
|
|
|
Sprite_Damage.prototype = Object.create(Sprite.prototype);
|
|
Sprite_Damage.prototype.constructor = Sprite_Damage;
|
|
|
|
Sprite_Damage.prototype.initialize = function() {
|
|
Sprite.prototype.initialize.call(this);
|
|
this._duration = 90;
|
|
this._flashColor = [0, 0, 0, 0];
|
|
this._flashDuration = 0;
|
|
this._colorType = 0;
|
|
};
|
|
|
|
Sprite_Damage.prototype.destroy = function(options) {
|
|
for (const child of this.children) {
|
|
if (child.bitmap) {
|
|
child.bitmap.destroy();
|
|
}
|
|
}
|
|
Sprite.prototype.destroy.call(this, options);
|
|
};
|
|
|
|
Sprite_Damage.prototype.setup = function(target) {
|
|
const result = target.result();
|
|
if (result.missed || result.evaded) {
|
|
this._colorType = 0;
|
|
this.createMiss();
|
|
} else if (result.hpAffected) {
|
|
this._colorType = result.hpDamage >= 0 ? 0 : 1;
|
|
this.createDigits(result.hpDamage);
|
|
} else if (target.isAlive() && result.mpDamage !== 0) {
|
|
this._colorType = result.mpDamage >= 0 ? 2 : 3;
|
|
this.createDigits(result.mpDamage);
|
|
}
|
|
if (result.critical) {
|
|
this.setupCriticalEffect();
|
|
}
|
|
};
|
|
|
|
Sprite_Damage.prototype.setupCriticalEffect = function() {
|
|
this._flashColor = [255, 0, 0, 160];
|
|
this._flashDuration = 60;
|
|
};
|
|
|
|
Sprite_Damage.prototype.fontFace = function() {
|
|
return $gameSystem.numberFontFace();
|
|
};
|
|
|
|
Sprite_Damage.prototype.fontSize = function() {
|
|
return $gameSystem.mainFontSize() + 4;
|
|
};
|
|
|
|
Sprite_Damage.prototype.damageColor = function() {
|
|
return ColorManager.damageColor(this._colorType);
|
|
};
|
|
|
|
Sprite_Damage.prototype.outlineColor = function() {
|
|
return "rgba(0, 0, 0, 0.7)";
|
|
};
|
|
|
|
Sprite_Damage.prototype.outlineWidth = function() {
|
|
return 4;
|
|
};
|
|
|
|
Sprite_Damage.prototype.createMiss = function() {
|
|
const h = this.fontSize();
|
|
const w = Math.floor(h * 3.0);
|
|
const sprite = this.createChildSprite(w, h);
|
|
sprite.bitmap.drawText("Miss", 0, 0, w, h, "center");
|
|
sprite.dy = 0;
|
|
};
|
|
|
|
Sprite_Damage.prototype.createDigits = function(value) {
|
|
const string = Math.abs(value).toString();
|
|
const h = this.fontSize();
|
|
const w = Math.floor(h * 0.75);
|
|
for (let i = 0; i < string.length; i++) {
|
|
const sprite = this.createChildSprite(w, h);
|
|
sprite.bitmap.drawText(string[i], 0, 0, w, h, "center");
|
|
sprite.x = (i - (string.length - 1) / 2) * w;
|
|
sprite.dy = -i;
|
|
}
|
|
};
|
|
|
|
Sprite_Damage.prototype.createChildSprite = function(width, height) {
|
|
const sprite = new Sprite();
|
|
sprite.bitmap = this.createBitmap(width, height);
|
|
sprite.anchor.x = 0.5;
|
|
sprite.anchor.y = 1;
|
|
sprite.y = -40;
|
|
sprite.ry = sprite.y;
|
|
this.addChild(sprite);
|
|
return sprite;
|
|
};
|
|
|
|
Sprite_Damage.prototype.createBitmap = function(width, height) {
|
|
const bitmap = new Bitmap(width, height);
|
|
bitmap.fontFace = this.fontFace();
|
|
bitmap.fontSize = this.fontSize();
|
|
bitmap.textColor = this.damageColor();
|
|
bitmap.outlineColor = this.outlineColor();
|
|
bitmap.outlineWidth = this.outlineWidth();
|
|
return bitmap;
|
|
};
|
|
|
|
Sprite_Damage.prototype.update = function() {
|
|
Sprite.prototype.update.call(this);
|
|
if (this._duration > 0) {
|
|
this._duration--;
|
|
for (const child of this.children) {
|
|
this.updateChild(child);
|
|
}
|
|
}
|
|
this.updateFlash();
|
|
this.updateOpacity();
|
|
};
|
|
|
|
Sprite_Damage.prototype.updateChild = function(sprite) {
|
|
sprite.dy += 0.5;
|
|
sprite.ry += sprite.dy;
|
|
if (sprite.ry >= 0) {
|
|
sprite.ry = 0;
|
|
sprite.dy *= -0.6;
|
|
}
|
|
sprite.y = Math.round(sprite.ry);
|
|
sprite.setBlendColor(this._flashColor);
|
|
};
|
|
|
|
Sprite_Damage.prototype.updateFlash = function() {
|
|
if (this._flashDuration > 0) {
|
|
const d = this._flashDuration--;
|
|
this._flashColor[3] *= (d - 1) / d;
|
|
}
|
|
};
|
|
|
|
Sprite_Damage.prototype.updateOpacity = function() {
|
|
if (this._duration < 10) {
|
|
this.opacity = (255 * this._duration) / 10;
|
|
}
|
|
};
|
|
|
|
Sprite_Damage.prototype.isPlaying = function() {
|
|
return this._duration > 0;
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Sprite_Gauge
|
|
//
|
|
// The sprite for displaying a status gauge.
|
|
|
|
function Sprite_Gauge() {
|
|
this.initialize(...arguments);
|
|
}
|
|
|
|
Sprite_Gauge.prototype = Object.create(Sprite.prototype);
|
|
Sprite_Gauge.prototype.constructor = Sprite_Gauge;
|
|
|
|
Sprite_Gauge.prototype.initialize = function() {
|
|
Sprite.prototype.initialize.call(this);
|
|
this.initMembers();
|
|
this.createBitmap();
|
|
};
|
|
|
|
Sprite_Gauge.prototype.initMembers = function() {
|
|
this._battler = null;
|
|
this._statusType = "";
|
|
this._value = NaN;
|
|
this._maxValue = NaN;
|
|
this._targetValue = NaN;
|
|
this._targetMaxValue = NaN;
|
|
this._duration = 0;
|
|
this._flashingCount = 0;
|
|
};
|
|
|
|
Sprite_Gauge.prototype.destroy = function(options) {
|
|
this.bitmap.destroy();
|
|
Sprite.prototype.destroy.call(this, options);
|
|
};
|
|
|
|
Sprite_Gauge.prototype.createBitmap = function() {
|
|
const width = this.bitmapWidth();
|
|
const height = this.bitmapHeight();
|
|
this.bitmap = new Bitmap(width, height);
|
|
};
|
|
|
|
Sprite_Gauge.prototype.bitmapWidth = function() {
|
|
return 128;
|
|
};
|
|
|
|
Sprite_Gauge.prototype.bitmapHeight = function() {
|
|
return 32;
|
|
};
|
|
|
|
Sprite_Gauge.prototype.textHeight = function() {
|
|
return 24;
|
|
};
|
|
|
|
Sprite_Gauge.prototype.gaugeHeight = function() {
|
|
return 12;
|
|
};
|
|
|
|
Sprite_Gauge.prototype.gaugeX = function() {
|
|
if (this._statusType === "time") {
|
|
return 0;
|
|
} else {
|
|
return this.measureLabelWidth() + 6;
|
|
}
|
|
};
|
|
|
|
Sprite_Gauge.prototype.labelY = function() {
|
|
return 3;
|
|
};
|
|
|
|
Sprite_Gauge.prototype.labelFontFace = function() {
|
|
return $gameSystem.mainFontFace();
|
|
};
|
|
|
|
Sprite_Gauge.prototype.labelFontSize = function() {
|
|
return $gameSystem.mainFontSize() - 2;
|
|
};
|
|
|
|
Sprite_Gauge.prototype.valueFontFace = function() {
|
|
return $gameSystem.numberFontFace();
|
|
};
|
|
|
|
Sprite_Gauge.prototype.valueFontSize = function() {
|
|
return $gameSystem.mainFontSize() - 6;
|
|
};
|
|
|
|
Sprite_Gauge.prototype.setup = function(battler, statusType) {
|
|
this._battler = battler;
|
|
this._statusType = statusType;
|
|
this._value = this.currentValue();
|
|
this._maxValue = this.currentMaxValue();
|
|
this.updateBitmap();
|
|
};
|
|
|
|
Sprite_Gauge.prototype.update = function() {
|
|
Sprite.prototype.update.call(this);
|
|
this.updateBitmap();
|
|
};
|
|
|
|
Sprite_Gauge.prototype.updateBitmap = function() {
|
|
const value = this.currentValue();
|
|
const maxValue = this.currentMaxValue();
|
|
if (value !== this._targetValue || maxValue !== this._targetMaxValue) {
|
|
this.updateTargetValue(value, maxValue);
|
|
}
|
|
this.updateGaugeAnimation();
|
|
this.updateFlashing();
|
|
};
|
|
|
|
Sprite_Gauge.prototype.updateTargetValue = function(value, maxValue) {
|
|
this._targetValue = value;
|
|
this._targetMaxValue = maxValue;
|
|
if (isNaN(this._value)) {
|
|
this._value = value;
|
|
this._maxValue = maxValue;
|
|
this.redraw();
|
|
} else {
|
|
this._duration = this.smoothness();
|
|
}
|
|
};
|
|
|
|
Sprite_Gauge.prototype.smoothness = function() {
|
|
return this._statusType === "time" ? 5 : 20;
|
|
};
|
|
|
|
Sprite_Gauge.prototype.updateGaugeAnimation = function() {
|
|
if (this._duration > 0) {
|
|
const d = this._duration;
|
|
this._value = (this._value * (d - 1) + this._targetValue) / d;
|
|
this._maxValue = (this._maxValue * (d - 1) + this._targetMaxValue) / d;
|
|
this._duration--;
|
|
this.redraw();
|
|
}
|
|
};
|
|
|
|
Sprite_Gauge.prototype.updateFlashing = function() {
|
|
if (this._statusType === "time") {
|
|
this._flashingCount++;
|
|
if (this._battler.isInputting()) {
|
|
if (this._flashingCount % 30 < 15) {
|
|
this.setBlendColor(this.flashingColor1());
|
|
} else {
|
|
this.setBlendColor(this.flashingColor2());
|
|
}
|
|
} else {
|
|
this.setBlendColor([0, 0, 0, 0]);
|
|
}
|
|
}
|
|
};
|
|
|
|
Sprite_Gauge.prototype.flashingColor1 = function() {
|
|
return [255, 255, 255, 64];
|
|
};
|
|
|
|
Sprite_Gauge.prototype.flashingColor2 = function() {
|
|
return [0, 0, 255, 48];
|
|
};
|
|
|
|
Sprite_Gauge.prototype.isValid = function() {
|
|
if (this._battler) {
|
|
if (this._statusType === "tp" && !this._battler.isPreserveTp()) {
|
|
return $gameParty.inBattle();
|
|
} else {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
};
|
|
|
|
Sprite_Gauge.prototype.currentValue = function() {
|
|
if (this._battler) {
|
|
switch (this._statusType) {
|
|
case "hp":
|
|
return this._battler.hp;
|
|
case "mp":
|
|
return this._battler.mp;
|
|
case "tp":
|
|
return this._battler.tp;
|
|
case "time":
|
|
return this._battler.tpbChargeTime();
|
|
}
|
|
}
|
|
return NaN;
|
|
};
|
|
|
|
Sprite_Gauge.prototype.currentMaxValue = function() {
|
|
if (this._battler) {
|
|
switch (this._statusType) {
|
|
case "hp":
|
|
return this._battler.mhp;
|
|
case "mp":
|
|
return this._battler.mmp;
|
|
case "tp":
|
|
return this._battler.maxTp();
|
|
case "time":
|
|
return 1;
|
|
}
|
|
}
|
|
return NaN;
|
|
};
|
|
|
|
Sprite_Gauge.prototype.label = function() {
|
|
switch (this._statusType) {
|
|
case "hp":
|
|
return TextManager.hpA;
|
|
case "mp":
|
|
return TextManager.mpA;
|
|
case "tp":
|
|
return TextManager.tpA;
|
|
default:
|
|
return "";
|
|
}
|
|
};
|
|
|
|
Sprite_Gauge.prototype.gaugeBackColor = function() {
|
|
return ColorManager.gaugeBackColor();
|
|
};
|
|
|
|
Sprite_Gauge.prototype.gaugeColor1 = function() {
|
|
switch (this._statusType) {
|
|
case "hp":
|
|
return ColorManager.hpGaugeColor1();
|
|
case "mp":
|
|
return ColorManager.mpGaugeColor1();
|
|
case "tp":
|
|
return ColorManager.tpGaugeColor1();
|
|
case "time":
|
|
return ColorManager.ctGaugeColor1();
|
|
default:
|
|
return ColorManager.normalColor();
|
|
}
|
|
};
|
|
|
|
Sprite_Gauge.prototype.gaugeColor2 = function() {
|
|
switch (this._statusType) {
|
|
case "hp":
|
|
return ColorManager.hpGaugeColor2();
|
|
case "mp":
|
|
return ColorManager.mpGaugeColor2();
|
|
case "tp":
|
|
return ColorManager.tpGaugeColor2();
|
|
case "time":
|
|
return ColorManager.ctGaugeColor2();
|
|
default:
|
|
return ColorManager.normalColor();
|
|
}
|
|
};
|
|
|
|
Sprite_Gauge.prototype.labelColor = function() {
|
|
return ColorManager.systemColor();
|
|
};
|
|
|
|
Sprite_Gauge.prototype.labelOutlineColor = function() {
|
|
return ColorManager.outlineColor();
|
|
};
|
|
|
|
Sprite_Gauge.prototype.labelOutlineWidth = function() {
|
|
return 3;
|
|
};
|
|
|
|
Sprite_Gauge.prototype.valueColor = function() {
|
|
switch (this._statusType) {
|
|
case "hp":
|
|
return ColorManager.hpColor(this._battler);
|
|
case "mp":
|
|
return ColorManager.mpColor(this._battler);
|
|
case "tp":
|
|
return ColorManager.tpColor(this._battler);
|
|
default:
|
|
return ColorManager.normalColor();
|
|
}
|
|
};
|
|
|
|
Sprite_Gauge.prototype.valueOutlineColor = function() {
|
|
return "rgba(0, 0, 0, 1)";
|
|
};
|
|
|
|
Sprite_Gauge.prototype.valueOutlineWidth = function() {
|
|
return 2;
|
|
};
|
|
|
|
Sprite_Gauge.prototype.redraw = function() {
|
|
this.bitmap.clear();
|
|
const currentValue = this.currentValue();
|
|
if (!isNaN(currentValue)) {
|
|
this.drawGauge();
|
|
if (this._statusType !== "time") {
|
|
this.drawLabel();
|
|
if (this.isValid()) {
|
|
this.drawValue();
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
Sprite_Gauge.prototype.drawGauge = function() {
|
|
const gaugeX = this.gaugeX();
|
|
const gaugeY = this.textHeight() - this.gaugeHeight();
|
|
const gaugewidth = this.bitmapWidth() - gaugeX;
|
|
const gaugeHeight = this.gaugeHeight();
|
|
this.drawGaugeRect(gaugeX, gaugeY, gaugewidth, gaugeHeight);
|
|
};
|
|
|
|
Sprite_Gauge.prototype.drawGaugeRect = function(x, y, width, height) {
|
|
const rate = this.gaugeRate();
|
|
const fillW = Math.floor((width - 2) * rate);
|
|
const fillH = height - 2;
|
|
const color0 = this.gaugeBackColor();
|
|
const color1 = this.gaugeColor1();
|
|
const color2 = this.gaugeColor2();
|
|
this.bitmap.fillRect(x, y, width, height, color0);
|
|
this.bitmap.gradientFillRect(x + 1, y + 1, fillW, fillH, color1, color2);
|
|
};
|
|
|
|
Sprite_Gauge.prototype.gaugeRate = function() {
|
|
if (this.isValid()) {
|
|
const value = this._value;
|
|
const maxValue = this._maxValue;
|
|
return maxValue > 0 ? value / maxValue : 0;
|
|
} else {
|
|
return 0;
|
|
}
|
|
};
|
|
|
|
Sprite_Gauge.prototype.drawLabel = function() {
|
|
const label = this.label();
|
|
const x = this.labelOutlineWidth() / 2;
|
|
const y = this.labelY();
|
|
const width = this.bitmapWidth();
|
|
const height = this.textHeight();
|
|
this.setupLabelFont();
|
|
this.bitmap.paintOpacity = this.labelOpacity();
|
|
this.bitmap.drawText(label, x, y, width, height, "left");
|
|
this.bitmap.paintOpacity = 255;
|
|
};
|
|
|
|
Sprite_Gauge.prototype.setupLabelFont = function() {
|
|
this.bitmap.fontFace = this.labelFontFace();
|
|
this.bitmap.fontSize = this.labelFontSize();
|
|
this.bitmap.textColor = this.labelColor();
|
|
this.bitmap.outlineColor = this.labelOutlineColor();
|
|
this.bitmap.outlineWidth = this.labelOutlineWidth();
|
|
};
|
|
|
|
Sprite_Gauge.prototype.measureLabelWidth = function() {
|
|
this.setupLabelFont();
|
|
const labels = [TextManager.hpA, TextManager.mpA, TextManager.tpA];
|
|
const widths = labels.map(str => this.bitmap.measureTextWidth(str));
|
|
return Math.ceil(Math.max(...widths));
|
|
};
|
|
|
|
Sprite_Gauge.prototype.labelOpacity = function() {
|
|
return this.isValid() ? 255 : 160;
|
|
};
|
|
|
|
Sprite_Gauge.prototype.drawValue = function() {
|
|
const currentValue = this.currentValue();
|
|
const width = this.bitmapWidth();
|
|
const height = this.textHeight();
|
|
this.setupValueFont();
|
|
this.bitmap.drawText(currentValue, 0, 0, width, height, "right");
|
|
};
|
|
|
|
Sprite_Gauge.prototype.setupValueFont = function() {
|
|
this.bitmap.fontFace = this.valueFontFace();
|
|
this.bitmap.fontSize = this.valueFontSize();
|
|
this.bitmap.textColor = this.valueColor();
|
|
this.bitmap.outlineColor = this.valueOutlineColor();
|
|
this.bitmap.outlineWidth = this.valueOutlineWidth();
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Sprite_Name
|
|
//
|
|
// The sprite for displaying a status gauge.
|
|
|
|
function Sprite_Name() {
|
|
this.initialize(...arguments);
|
|
}
|
|
|
|
Sprite_Name.prototype = Object.create(Sprite.prototype);
|
|
Sprite_Name.prototype.constructor = Sprite_Name;
|
|
|
|
Sprite_Name.prototype.initialize = function() {
|
|
Sprite.prototype.initialize.call(this);
|
|
this.initMembers();
|
|
this.createBitmap();
|
|
};
|
|
|
|
Sprite_Name.prototype.initMembers = function() {
|
|
this._battler = null;
|
|
this._name = "";
|
|
this._textColor = "";
|
|
};
|
|
|
|
Sprite_Name.prototype.destroy = function(options) {
|
|
this.bitmap.destroy();
|
|
Sprite.prototype.destroy.call(this, options);
|
|
};
|
|
|
|
Sprite_Name.prototype.createBitmap = function() {
|
|
const width = this.bitmapWidth();
|
|
const height = this.bitmapHeight();
|
|
this.bitmap = new Bitmap(width, height);
|
|
};
|
|
|
|
Sprite_Name.prototype.bitmapWidth = function() {
|
|
return 128;
|
|
};
|
|
|
|
Sprite_Name.prototype.bitmapHeight = function() {
|
|
return 24;
|
|
};
|
|
|
|
Sprite_Name.prototype.fontFace = function() {
|
|
return $gameSystem.mainFontFace();
|
|
};
|
|
|
|
Sprite_Name.prototype.fontSize = function() {
|
|
return $gameSystem.mainFontSize();
|
|
};
|
|
|
|
Sprite_Name.prototype.setup = function(battler) {
|
|
this._battler = battler;
|
|
this.updateBitmap();
|
|
};
|
|
|
|
Sprite_Name.prototype.update = function() {
|
|
Sprite.prototype.update.call(this);
|
|
this.updateBitmap();
|
|
};
|
|
|
|
Sprite_Name.prototype.updateBitmap = function() {
|
|
const name = this.name();
|
|
const color = this.textColor();
|
|
if (name !== this._name || color !== this._textColor) {
|
|
this._name = name;
|
|
this._textColor = color;
|
|
this.redraw();
|
|
}
|
|
};
|
|
|
|
Sprite_Name.prototype.name = function() {
|
|
return this._battler ? this._battler.name() : "";
|
|
};
|
|
|
|
Sprite_Name.prototype.textColor = function() {
|
|
return ColorManager.hpColor(this._battler);
|
|
};
|
|
|
|
Sprite_Name.prototype.outlineColor = function() {
|
|
return ColorManager.outlineColor();
|
|
};
|
|
|
|
Sprite_Name.prototype.outlineWidth = function() {
|
|
return 3;
|
|
};
|
|
|
|
Sprite_Name.prototype.redraw = function() {
|
|
const name = this.name();
|
|
const width = this.bitmapWidth();
|
|
const height = this.bitmapHeight();
|
|
this.setupFont();
|
|
this.bitmap.clear();
|
|
this.bitmap.drawText(name, 0, 0, width, height, "left");
|
|
};
|
|
|
|
Sprite_Name.prototype.setupFont = function() {
|
|
this.bitmap.fontFace = this.fontFace();
|
|
this.bitmap.fontSize = this.fontSize();
|
|
this.bitmap.textColor = this.textColor();
|
|
this.bitmap.outlineColor = this.outlineColor();
|
|
this.bitmap.outlineWidth = this.outlineWidth();
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Sprite_StateIcon
|
|
//
|
|
// The sprite for displaying state icons.
|
|
|
|
function Sprite_StateIcon() {
|
|
this.initialize(...arguments);
|
|
}
|
|
|
|
Sprite_StateIcon.prototype = Object.create(Sprite.prototype);
|
|
Sprite_StateIcon.prototype.constructor = Sprite_StateIcon;
|
|
|
|
Sprite_StateIcon.prototype.initialize = function() {
|
|
Sprite.prototype.initialize.call(this);
|
|
this.initMembers();
|
|
this.loadBitmap();
|
|
};
|
|
|
|
Sprite_StateIcon.prototype.initMembers = function() {
|
|
this._battler = null;
|
|
this._iconIndex = 0;
|
|
this._animationCount = 0;
|
|
this._animationIndex = 0;
|
|
this.anchor.x = 0.5;
|
|
this.anchor.y = 0.5;
|
|
};
|
|
|
|
Sprite_StateIcon.prototype.loadBitmap = function() {
|
|
this.bitmap = ImageManager.loadSystem("IconSet");
|
|
this.setFrame(0, 0, 0, 0);
|
|
};
|
|
|
|
Sprite_StateIcon.prototype.setup = function(battler) {
|
|
if (this._battler !== battler) {
|
|
this._battler = battler;
|
|
this._animationCount = this.animationWait();
|
|
}
|
|
};
|
|
|
|
Sprite_StateIcon.prototype.update = function() {
|
|
Sprite.prototype.update.call(this);
|
|
this._animationCount++;
|
|
if (this._animationCount >= this.animationWait()) {
|
|
this.updateIcon();
|
|
this.updateFrame();
|
|
this._animationCount = 0;
|
|
}
|
|
};
|
|
|
|
Sprite_StateIcon.prototype.animationWait = function() {
|
|
return 40;
|
|
};
|
|
|
|
Sprite_StateIcon.prototype.updateIcon = function() {
|
|
const icons = [];
|
|
if (this.shouldDisplay()) {
|
|
icons.push(...this._battler.allIcons());
|
|
}
|
|
if (icons.length > 0) {
|
|
this._animationIndex++;
|
|
if (this._animationIndex >= icons.length) {
|
|
this._animationIndex = 0;
|
|
}
|
|
this._iconIndex = icons[this._animationIndex];
|
|
} else {
|
|
this._animationIndex = 0;
|
|
this._iconIndex = 0;
|
|
}
|
|
};
|
|
|
|
Sprite_StateIcon.prototype.shouldDisplay = function() {
|
|
const battler = this._battler;
|
|
return battler && (battler.isActor() || battler.isAlive());
|
|
};
|
|
|
|
Sprite_StateIcon.prototype.updateFrame = function() {
|
|
const pw = ImageManager.iconWidth;
|
|
const ph = ImageManager.iconHeight;
|
|
const sx = (this._iconIndex % 16) * pw;
|
|
const sy = Math.floor(this._iconIndex / 16) * ph;
|
|
this.setFrame(sx, sy, pw, ph);
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Sprite_StateOverlay
|
|
//
|
|
// The sprite for displaying an overlay image for a state.
|
|
|
|
function Sprite_StateOverlay() {
|
|
this.initialize(...arguments);
|
|
}
|
|
|
|
Sprite_StateOverlay.prototype = Object.create(Sprite.prototype);
|
|
Sprite_StateOverlay.prototype.constructor = Sprite_StateOverlay;
|
|
|
|
Sprite_StateOverlay.prototype.initialize = function() {
|
|
Sprite.prototype.initialize.call(this);
|
|
this.initMembers();
|
|
this.loadBitmap();
|
|
};
|
|
|
|
Sprite_StateOverlay.prototype.initMembers = function() {
|
|
this._battler = null;
|
|
this._overlayIndex = 0;
|
|
this._animationCount = 0;
|
|
this._pattern = 0;
|
|
this.anchor.x = 0.5;
|
|
this.anchor.y = 1;
|
|
};
|
|
|
|
Sprite_StateOverlay.prototype.loadBitmap = function() {
|
|
this.bitmap = ImageManager.loadSystem("States");
|
|
this.setFrame(0, 0, 0, 0);
|
|
};
|
|
|
|
Sprite_StateOverlay.prototype.setup = function(battler) {
|
|
this._battler = battler;
|
|
};
|
|
|
|
Sprite_StateOverlay.prototype.update = function() {
|
|
Sprite.prototype.update.call(this);
|
|
this._animationCount++;
|
|
if (this._animationCount >= this.animationWait()) {
|
|
this.updatePattern();
|
|
this.updateFrame();
|
|
this._animationCount = 0;
|
|
}
|
|
};
|
|
|
|
Sprite_StateOverlay.prototype.animationWait = function() {
|
|
return 8;
|
|
};
|
|
|
|
Sprite_StateOverlay.prototype.updatePattern = function() {
|
|
this._pattern++;
|
|
this._pattern %= 8;
|
|
if (this._battler) {
|
|
this._overlayIndex = this._battler.stateOverlayIndex();
|
|
} else {
|
|
this._overlayIndex = 0;
|
|
}
|
|
};
|
|
|
|
Sprite_StateOverlay.prototype.updateFrame = function() {
|
|
if (this._overlayIndex > 0) {
|
|
const w = 96;
|
|
const h = 96;
|
|
const sx = this._pattern * w;
|
|
const sy = (this._overlayIndex - 1) * h;
|
|
this.setFrame(sx, sy, w, h);
|
|
} else {
|
|
this.setFrame(0, 0, 0, 0);
|
|
}
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Sprite_Weapon
|
|
//
|
|
// The sprite for displaying a weapon image for attacking.
|
|
|
|
function Sprite_Weapon() {
|
|
this.initialize(...arguments);
|
|
}
|
|
|
|
Sprite_Weapon.prototype = Object.create(Sprite.prototype);
|
|
Sprite_Weapon.prototype.constructor = Sprite_Weapon;
|
|
|
|
Sprite_Weapon.prototype.initialize = function() {
|
|
Sprite.prototype.initialize.call(this);
|
|
this.initMembers();
|
|
};
|
|
|
|
Sprite_Weapon.prototype.initMembers = function() {
|
|
this._weaponImageId = 0;
|
|
this._animationCount = 0;
|
|
this._pattern = 0;
|
|
this.anchor.x = 0.5;
|
|
this.anchor.y = 1;
|
|
this.x = -16;
|
|
};
|
|
|
|
Sprite_Weapon.prototype.setup = function(weaponImageId) {
|
|
this._weaponImageId = weaponImageId;
|
|
this._animationCount = 0;
|
|
this._pattern = 0;
|
|
this.loadBitmap();
|
|
this.updateFrame();
|
|
};
|
|
|
|
Sprite_Weapon.prototype.update = function() {
|
|
Sprite.prototype.update.call(this);
|
|
this._animationCount++;
|
|
if (this._animationCount >= this.animationWait()) {
|
|
this.updatePattern();
|
|
this.updateFrame();
|
|
this._animationCount = 0;
|
|
}
|
|
};
|
|
|
|
Sprite_Weapon.prototype.animationWait = function() {
|
|
return 12;
|
|
};
|
|
|
|
Sprite_Weapon.prototype.updatePattern = function() {
|
|
this._pattern++;
|
|
if (this._pattern >= 3) {
|
|
this._weaponImageId = 0;
|
|
}
|
|
};
|
|
|
|
Sprite_Weapon.prototype.loadBitmap = function() {
|
|
const pageId = Math.floor((this._weaponImageId - 1) / 12) + 1;
|
|
if (pageId >= 1) {
|
|
this.bitmap = ImageManager.loadSystem("Weapons" + pageId);
|
|
} else {
|
|
this.bitmap = ImageManager.loadSystem("");
|
|
}
|
|
};
|
|
|
|
Sprite_Weapon.prototype.updateFrame = function() {
|
|
if (this._weaponImageId > 0) {
|
|
const index = (this._weaponImageId - 1) % 12;
|
|
const w = 96;
|
|
const h = 64;
|
|
const sx = (Math.floor(index / 6) * 3 + this._pattern) * w;
|
|
const sy = Math.floor(index % 6) * h;
|
|
this.setFrame(sx, sy, w, h);
|
|
} else {
|
|
this.setFrame(0, 0, 0, 0);
|
|
}
|
|
};
|
|
|
|
Sprite_Weapon.prototype.isPlaying = function() {
|
|
return this._weaponImageId > 0;
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Sprite_Balloon
|
|
//
|
|
// The sprite for displaying a balloon icon.
|
|
|
|
function Sprite_Balloon() {
|
|
this.initialize(...arguments);
|
|
}
|
|
|
|
Sprite_Balloon.prototype = Object.create(Sprite.prototype);
|
|
Sprite_Balloon.prototype.constructor = Sprite_Balloon;
|
|
|
|
Sprite_Balloon.prototype.initialize = function() {
|
|
Sprite.prototype.initialize.call(this);
|
|
this.initMembers();
|
|
this.loadBitmap();
|
|
};
|
|
|
|
Sprite_Balloon.prototype.initMembers = function() {
|
|
this._target = null;
|
|
this._balloonId = 0;
|
|
this._duration = 0;
|
|
this.anchor.x = 0.5;
|
|
this.anchor.y = 1;
|
|
this.z = 7;
|
|
};
|
|
|
|
Sprite_Balloon.prototype.loadBitmap = function() {
|
|
this.bitmap = ImageManager.loadSystem("Balloon");
|
|
this.setFrame(0, 0, 0, 0);
|
|
};
|
|
|
|
Sprite_Balloon.prototype.setup = function(targetSprite, balloonId) {
|
|
this._target = targetSprite;
|
|
this._balloonId = balloonId;
|
|
this._duration = 8 * this.speed() + this.waitTime();
|
|
};
|
|
|
|
Sprite_Balloon.prototype.update = function() {
|
|
Sprite.prototype.update.call(this);
|
|
if (this._duration > 0) {
|
|
this._duration--;
|
|
if (this._duration > 0) {
|
|
this.updatePosition();
|
|
this.updateFrame();
|
|
}
|
|
}
|
|
};
|
|
|
|
Sprite_Balloon.prototype.updatePosition = function() {
|
|
this.x = this._target.x;
|
|
this.y = this._target.y - this._target.height;
|
|
};
|
|
|
|
Sprite_Balloon.prototype.updateFrame = function() {
|
|
const w = 48;
|
|
const h = 48;
|
|
const sx = this.frameIndex() * w;
|
|
const sy = (this._balloonId - 1) * h;
|
|
this.setFrame(sx, sy, w, h);
|
|
};
|
|
|
|
Sprite_Balloon.prototype.speed = function() {
|
|
return 8;
|
|
};
|
|
|
|
Sprite_Balloon.prototype.waitTime = function() {
|
|
return 12;
|
|
};
|
|
|
|
Sprite_Balloon.prototype.frameIndex = function() {
|
|
const index = (this._duration - this.waitTime()) / this.speed();
|
|
return 7 - Math.max(Math.floor(index), 0);
|
|
};
|
|
|
|
Sprite_Balloon.prototype.isPlaying = function() {
|
|
return this._duration > 0;
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Sprite_Picture
|
|
//
|
|
// The sprite for displaying a picture.
|
|
|
|
function Sprite_Picture() {
|
|
this.initialize(...arguments);
|
|
}
|
|
|
|
Sprite_Picture.prototype = Object.create(Sprite_Clickable.prototype);
|
|
Sprite_Picture.prototype.constructor = Sprite_Picture;
|
|
|
|
Sprite_Picture.prototype.initialize = function(pictureId) {
|
|
Sprite_Clickable.prototype.initialize.call(this);
|
|
this._pictureId = pictureId;
|
|
this._pictureName = "";
|
|
this.update();
|
|
};
|
|
|
|
Sprite_Picture.prototype.picture = function() {
|
|
return $gameScreen.picture(this._pictureId);
|
|
};
|
|
|
|
Sprite_Picture.prototype.update = function() {
|
|
Sprite_Clickable.prototype.update.call(this);
|
|
this.updateBitmap();
|
|
if (this.visible) {
|
|
this.updateOrigin();
|
|
this.updatePosition();
|
|
this.updateScale();
|
|
this.updateTone();
|
|
this.updateOther();
|
|
}
|
|
};
|
|
|
|
Sprite_Picture.prototype.updateBitmap = function() {
|
|
const picture = this.picture();
|
|
if (picture) {
|
|
const pictureName = picture.name();
|
|
if (this._pictureName !== pictureName) {
|
|
this._pictureName = pictureName;
|
|
this.loadBitmap();
|
|
}
|
|
this.visible = true;
|
|
} else {
|
|
this._pictureName = "";
|
|
this.bitmap = null;
|
|
this.visible = false;
|
|
}
|
|
};
|
|
|
|
Sprite_Picture.prototype.updateOrigin = function() {
|
|
const picture = this.picture();
|
|
if (picture.origin() === 0) {
|
|
this.anchor.x = 0;
|
|
this.anchor.y = 0;
|
|
} else {
|
|
this.anchor.x = 0.5;
|
|
this.anchor.y = 0.5;
|
|
}
|
|
};
|
|
|
|
Sprite_Picture.prototype.updatePosition = function() {
|
|
const picture = this.picture();
|
|
this.x = Math.round(picture.x());
|
|
this.y = Math.round(picture.y());
|
|
};
|
|
|
|
Sprite_Picture.prototype.updateScale = function() {
|
|
const picture = this.picture();
|
|
this.scale.x = picture.scaleX() / 100;
|
|
this.scale.y = picture.scaleY() / 100;
|
|
};
|
|
|
|
Sprite_Picture.prototype.updateTone = function() {
|
|
const picture = this.picture();
|
|
if (picture.tone()) {
|
|
this.setColorTone(picture.tone());
|
|
} else {
|
|
this.setColorTone([0, 0, 0, 0]);
|
|
}
|
|
};
|
|
|
|
Sprite_Picture.prototype.updateOther = function() {
|
|
const picture = this.picture();
|
|
this.opacity = picture.opacity();
|
|
this.blendMode = picture.blendMode();
|
|
this.rotation = (picture.angle() * Math.PI) / 180;
|
|
};
|
|
|
|
Sprite_Picture.prototype.loadBitmap = function() {
|
|
this.bitmap = ImageManager.loadPicture(this._pictureName);
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Sprite_Timer
|
|
//
|
|
// The sprite for displaying the timer.
|
|
|
|
function Sprite_Timer() {
|
|
this.initialize(...arguments);
|
|
}
|
|
|
|
Sprite_Timer.prototype = Object.create(Sprite.prototype);
|
|
Sprite_Timer.prototype.constructor = Sprite_Timer;
|
|
|
|
Sprite_Timer.prototype.initialize = function() {
|
|
Sprite.prototype.initialize.call(this);
|
|
this._seconds = 0;
|
|
this.createBitmap();
|
|
this.update();
|
|
};
|
|
|
|
Sprite_Timer.prototype.destroy = function(options) {
|
|
this.bitmap.destroy();
|
|
Sprite.prototype.destroy.call(this, options);
|
|
};
|
|
|
|
Sprite_Timer.prototype.createBitmap = function() {
|
|
this.bitmap = new Bitmap(96, 48);
|
|
this.bitmap.fontFace = this.fontFace();
|
|
this.bitmap.fontSize = this.fontSize();
|
|
this.bitmap.outlineColor = ColorManager.outlineColor();
|
|
};
|
|
|
|
Sprite_Timer.prototype.fontFace = function() {
|
|
return $gameSystem.numberFontFace();
|
|
};
|
|
|
|
Sprite_Timer.prototype.fontSize = function() {
|
|
return $gameSystem.mainFontSize() + 8;
|
|
};
|
|
|
|
Sprite_Timer.prototype.update = function() {
|
|
Sprite.prototype.update.call(this);
|
|
this.updateBitmap();
|
|
this.updatePosition();
|
|
this.updateVisibility();
|
|
};
|
|
|
|
Sprite_Timer.prototype.updateBitmap = function() {
|
|
if (this._seconds !== $gameTimer.seconds()) {
|
|
this._seconds = $gameTimer.seconds();
|
|
this.redraw();
|
|
}
|
|
};
|
|
|
|
Sprite_Timer.prototype.redraw = function() {
|
|
const text = this.timerText();
|
|
const width = this.bitmap.width;
|
|
const height = this.bitmap.height;
|
|
this.bitmap.clear();
|
|
this.bitmap.drawText(text, 0, 0, width, height, "center");
|
|
};
|
|
|
|
Sprite_Timer.prototype.timerText = function() {
|
|
const min = Math.floor(this._seconds / 60) % 60;
|
|
const sec = this._seconds % 60;
|
|
return min.padZero(2) + ":" + sec.padZero(2);
|
|
};
|
|
|
|
Sprite_Timer.prototype.updatePosition = function() {
|
|
this.x = (Graphics.width - this.bitmap.width) / 2;
|
|
this.y = 0;
|
|
};
|
|
|
|
Sprite_Timer.prototype.updateVisibility = function() {
|
|
this.visible = $gameTimer.isWorking();
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Sprite_Destination
|
|
//
|
|
// The sprite for displaying the destination place of the touch input.
|
|
|
|
function Sprite_Destination() {
|
|
this.initialize(...arguments);
|
|
}
|
|
|
|
Sprite_Destination.prototype = Object.create(Sprite.prototype);
|
|
Sprite_Destination.prototype.constructor = Sprite_Destination;
|
|
|
|
Sprite_Destination.prototype.initialize = function() {
|
|
Sprite.prototype.initialize.call(this);
|
|
this.createBitmap();
|
|
this._frameCount = 0;
|
|
};
|
|
|
|
Sprite_Destination.prototype.destroy = function(options) {
|
|
if (this.bitmap) {
|
|
this.bitmap.destroy();
|
|
}
|
|
Sprite.prototype.destroy.call(this, options);
|
|
};
|
|
|
|
Sprite_Destination.prototype.update = function() {
|
|
Sprite.prototype.update.call(this);
|
|
if ($gameTemp.isDestinationValid()) {
|
|
this.updatePosition();
|
|
this.updateAnimation();
|
|
this.visible = true;
|
|
} else {
|
|
this._frameCount = 0;
|
|
this.visible = false;
|
|
}
|
|
};
|
|
|
|
Sprite_Destination.prototype.createBitmap = function() {
|
|
const tileWidth = $gameMap.tileWidth();
|
|
const tileHeight = $gameMap.tileHeight();
|
|
this.bitmap = new Bitmap(tileWidth, tileHeight);
|
|
this.bitmap.fillAll("white");
|
|
this.anchor.x = 0.5;
|
|
this.anchor.y = 0.5;
|
|
this.blendMode = 1;
|
|
};
|
|
|
|
Sprite_Destination.prototype.updatePosition = function() {
|
|
const tileWidth = $gameMap.tileWidth();
|
|
const tileHeight = $gameMap.tileHeight();
|
|
const x = $gameTemp.destinationX();
|
|
const y = $gameTemp.destinationY();
|
|
this.x = ($gameMap.adjustX(x) + 0.5) * tileWidth;
|
|
this.y = ($gameMap.adjustY(y) + 0.5) * tileHeight;
|
|
};
|
|
|
|
Sprite_Destination.prototype.updateAnimation = function() {
|
|
this._frameCount++;
|
|
this._frameCount %= 20;
|
|
this.opacity = (20 - this._frameCount) * 6;
|
|
this.scale.x = 1 + this._frameCount / 20;
|
|
this.scale.y = this.scale.x;
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Spriteset_Base
|
|
//
|
|
// The superclass of Spriteset_Map and Spriteset_Battle.
|
|
|
|
function Spriteset_Base() {
|
|
this.initialize(...arguments);
|
|
}
|
|
|
|
Spriteset_Base.prototype = Object.create(Sprite.prototype);
|
|
Spriteset_Base.prototype.constructor = Spriteset_Base;
|
|
|
|
Spriteset_Base.prototype.initialize = function() {
|
|
Sprite.prototype.initialize.call(this);
|
|
this.setFrame(0, 0, Graphics.width, Graphics.height);
|
|
this.loadSystemImages();
|
|
this.createLowerLayer();
|
|
this.createUpperLayer();
|
|
this._animationSprites = [];
|
|
};
|
|
|
|
Spriteset_Base.prototype.destroy = function(options) {
|
|
this.removeAllAnimations();
|
|
Sprite.prototype.destroy.call(this, options);
|
|
};
|
|
|
|
Spriteset_Base.prototype.loadSystemImages = function() {
|
|
//
|
|
};
|
|
|
|
Spriteset_Base.prototype.createLowerLayer = function() {
|
|
this.createBaseSprite();
|
|
this.createBaseFilters();
|
|
};
|
|
|
|
Spriteset_Base.prototype.createUpperLayer = function() {
|
|
this.createPictures();
|
|
this.createTimer();
|
|
this.createOverallFilters();
|
|
};
|
|
|
|
Spriteset_Base.prototype.update = function() {
|
|
Sprite.prototype.update.call(this);
|
|
this.updateBaseFilters();
|
|
this.updateOverallFilters();
|
|
this.updatePosition();
|
|
this.updateAnimations();
|
|
};
|
|
|
|
Spriteset_Base.prototype.createBaseSprite = function() {
|
|
this._baseSprite = new Sprite();
|
|
this._blackScreen = new ScreenSprite();
|
|
this._blackScreen.opacity = 255;
|
|
this.addChild(this._baseSprite);
|
|
this._baseSprite.addChild(this._blackScreen);
|
|
};
|
|
|
|
Spriteset_Base.prototype.createBaseFilters = function() {
|
|
this._baseSprite.filters = [];
|
|
this._baseColorFilter = new ColorFilter();
|
|
this._baseSprite.filters.push(this._baseColorFilter);
|
|
};
|
|
|
|
Spriteset_Base.prototype.createPictures = function() {
|
|
const rect = this.pictureContainerRect();
|
|
this._pictureContainer = new Sprite();
|
|
this._pictureContainer.setFrame(rect.x, rect.y, rect.width, rect.height);
|
|
for (let i = 1; i <= $gameScreen.maxPictures(); i++) {
|
|
this._pictureContainer.addChild(new Sprite_Picture(i));
|
|
}
|
|
this.addChild(this._pictureContainer);
|
|
};
|
|
|
|
Spriteset_Base.prototype.pictureContainerRect = function() {
|
|
return new Rectangle(0, 0, Graphics.width, Graphics.height);
|
|
};
|
|
|
|
Spriteset_Base.prototype.createTimer = function() {
|
|
this._timerSprite = new Sprite_Timer();
|
|
this.addChild(this._timerSprite);
|
|
};
|
|
|
|
Spriteset_Base.prototype.createOverallFilters = function() {
|
|
this.filters = [];
|
|
this._overallColorFilter = new ColorFilter();
|
|
this.filters.push(this._overallColorFilter);
|
|
};
|
|
|
|
Spriteset_Base.prototype.updateBaseFilters = function() {
|
|
const filter = this._baseColorFilter;
|
|
filter.setColorTone($gameScreen.tone());
|
|
};
|
|
|
|
Spriteset_Base.prototype.updateOverallFilters = function() {
|
|
const filter = this._overallColorFilter;
|
|
filter.setBlendColor($gameScreen.flashColor());
|
|
filter.setBrightness($gameScreen.brightness());
|
|
};
|
|
|
|
Spriteset_Base.prototype.updatePosition = function() {
|
|
const screen = $gameScreen;
|
|
const scale = screen.zoomScale();
|
|
this.scale.x = scale;
|
|
this.scale.y = scale;
|
|
this.x = Math.round(-screen.zoomX() * (scale - 1));
|
|
this.y = Math.round(-screen.zoomY() * (scale - 1));
|
|
this.x += Math.round(screen.shake());
|
|
};
|
|
|
|
Spriteset_Base.prototype.findTargetSprite = function(/*target*/) {
|
|
return null;
|
|
};
|
|
|
|
Spriteset_Base.prototype.updateAnimations = function() {
|
|
for (const sprite of this._animationSprites) {
|
|
if (!sprite.isPlaying()) {
|
|
this.removeAnimation(sprite);
|
|
}
|
|
}
|
|
this.processAnimationRequests();
|
|
};
|
|
|
|
Spriteset_Base.prototype.processAnimationRequests = function() {
|
|
for (;;) {
|
|
const request = $gameTemp.retrieveAnimation();
|
|
if (request) {
|
|
this.createAnimation(request);
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
};
|
|
|
|
Spriteset_Base.prototype.createAnimation = function(request) {
|
|
const animation = $dataAnimations[request.animationId];
|
|
const targets = request.targets;
|
|
const mirror = request.mirror;
|
|
let delay = this.animationBaseDelay();
|
|
const nextDelay = this.animationNextDelay();
|
|
if (this.isAnimationForEach(animation)) {
|
|
for (const target of targets) {
|
|
this.createAnimationSprite([target], animation, mirror, delay);
|
|
delay += nextDelay;
|
|
}
|
|
} else {
|
|
this.createAnimationSprite(targets, animation, mirror, delay);
|
|
}
|
|
};
|
|
|
|
// prettier-ignore
|
|
Spriteset_Base.prototype.createAnimationSprite = function(
|
|
targets, animation, mirror, delay
|
|
) {
|
|
const mv = this.isMVAnimation(animation);
|
|
const sprite = new (mv ? Sprite_AnimationMV : Sprite_Animation)();
|
|
const targetSprites = this.makeTargetSprites(targets);
|
|
const baseDelay = this.animationBaseDelay();
|
|
const previous = delay > baseDelay ? this.lastAnimationSprite() : null;
|
|
if (this.animationShouldMirror(targets[0])) {
|
|
mirror = !mirror;
|
|
}
|
|
sprite.targetObjects = targets;
|
|
sprite.setup(targetSprites, animation, mirror, delay, previous);
|
|
this._effectsContainer.addChild(sprite);
|
|
this._animationSprites.push(sprite);
|
|
};
|
|
|
|
Spriteset_Base.prototype.isMVAnimation = function(animation) {
|
|
return !!animation.frames;
|
|
};
|
|
|
|
Spriteset_Base.prototype.makeTargetSprites = function(targets) {
|
|
const targetSprites = [];
|
|
for (const target of targets) {
|
|
const targetSprite = this.findTargetSprite(target);
|
|
if (targetSprite) {
|
|
targetSprites.push(targetSprite);
|
|
}
|
|
}
|
|
return targetSprites;
|
|
};
|
|
|
|
Spriteset_Base.prototype.lastAnimationSprite = function() {
|
|
return this._animationSprites[this._animationSprites.length - 1];
|
|
};
|
|
|
|
Spriteset_Base.prototype.isAnimationForEach = function(animation) {
|
|
const mv = this.isMVAnimation(animation);
|
|
return mv ? animation.position !== 3 : animation.displayType === 0;
|
|
};
|
|
|
|
Spriteset_Base.prototype.animationBaseDelay = function() {
|
|
return 8;
|
|
};
|
|
|
|
Spriteset_Base.prototype.animationNextDelay = function() {
|
|
return 12;
|
|
};
|
|
|
|
Spriteset_Base.prototype.animationShouldMirror = function(target) {
|
|
return target && target.isActor && target.isActor();
|
|
};
|
|
|
|
Spriteset_Base.prototype.removeAnimation = function(sprite) {
|
|
this._animationSprites.remove(sprite);
|
|
this._effectsContainer.removeChild(sprite);
|
|
for (const target of sprite.targetObjects) {
|
|
if (target.endAnimation) {
|
|
target.endAnimation();
|
|
}
|
|
}
|
|
sprite.destroy();
|
|
};
|
|
|
|
Spriteset_Base.prototype.removeAllAnimations = function() {
|
|
for (const sprite of this._animationSprites.clone()) {
|
|
this.removeAnimation(sprite);
|
|
}
|
|
};
|
|
|
|
Spriteset_Base.prototype.isAnimationPlaying = function() {
|
|
return this._animationSprites.length > 0;
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Spriteset_Map
|
|
//
|
|
// The set of sprites on the map screen.
|
|
|
|
function Spriteset_Map() {
|
|
this.initialize(...arguments);
|
|
}
|
|
|
|
Spriteset_Map.prototype = Object.create(Spriteset_Base.prototype);
|
|
Spriteset_Map.prototype.constructor = Spriteset_Map;
|
|
|
|
Spriteset_Map.prototype.initialize = function() {
|
|
Spriteset_Base.prototype.initialize.call(this);
|
|
this._balloonSprites = [];
|
|
};
|
|
|
|
Spriteset_Map.prototype.destroy = function(options) {
|
|
this.removeAllBalloons();
|
|
Spriteset_Base.prototype.destroy.call(this, options);
|
|
};
|
|
|
|
Spriteset_Map.prototype.loadSystemImages = function() {
|
|
Spriteset_Base.prototype.loadSystemImages.call(this);
|
|
ImageManager.loadSystem("Balloon");
|
|
ImageManager.loadSystem("Shadow1");
|
|
};
|
|
|
|
Spriteset_Map.prototype.createLowerLayer = function() {
|
|
Spriteset_Base.prototype.createLowerLayer.call(this);
|
|
this.createParallax();
|
|
this.createTilemap();
|
|
this.createCharacters();
|
|
this.createShadow();
|
|
this.createDestination();
|
|
this.createWeather();
|
|
};
|
|
|
|
Spriteset_Map.prototype.update = function() {
|
|
Spriteset_Base.prototype.update.call(this);
|
|
this.updateTileset();
|
|
this.updateParallax();
|
|
this.updateTilemap();
|
|
this.updateShadow();
|
|
this.updateWeather();
|
|
this.updateAnimations();
|
|
this.updateBalloons();
|
|
};
|
|
|
|
Spriteset_Map.prototype.hideCharacters = function() {
|
|
for (const sprite of this._characterSprites) {
|
|
if (!sprite.isTile() && !sprite.isObjectCharacter()) {
|
|
sprite.hide();
|
|
}
|
|
}
|
|
};
|
|
|
|
Spriteset_Map.prototype.createParallax = function() {
|
|
this._parallax = new TilingSprite();
|
|
this._parallax.move(0, 0, Graphics.width, Graphics.height);
|
|
this._baseSprite.addChild(this._parallax);
|
|
};
|
|
|
|
Spriteset_Map.prototype.createTilemap = function() {
|
|
const tilemap = new Tilemap();
|
|
tilemap.tileWidth = $gameMap.tileWidth();
|
|
tilemap.tileHeight = $gameMap.tileHeight();
|
|
tilemap.setData($gameMap.width(), $gameMap.height(), $gameMap.data());
|
|
tilemap.horizontalWrap = $gameMap.isLoopHorizontal();
|
|
tilemap.verticalWrap = $gameMap.isLoopVertical();
|
|
this._baseSprite.addChild(tilemap);
|
|
this._effectsContainer = tilemap;
|
|
this._tilemap = tilemap;
|
|
this.loadTileset();
|
|
};
|
|
|
|
Spriteset_Map.prototype.loadTileset = function() {
|
|
this._tileset = $gameMap.tileset();
|
|
if (this._tileset) {
|
|
const bitmaps = [];
|
|
const tilesetNames = this._tileset.tilesetNames;
|
|
for (const name of tilesetNames) {
|
|
bitmaps.push(ImageManager.loadTileset(name));
|
|
}
|
|
this._tilemap.setBitmaps(bitmaps);
|
|
this._tilemap.flags = $gameMap.tilesetFlags();
|
|
}
|
|
};
|
|
|
|
Spriteset_Map.prototype.createCharacters = function() {
|
|
this._characterSprites = [];
|
|
for (const event of $gameMap.events()) {
|
|
this._characterSprites.push(new Sprite_Character(event));
|
|
}
|
|
for (const vehicle of $gameMap.vehicles()) {
|
|
this._characterSprites.push(new Sprite_Character(vehicle));
|
|
}
|
|
for (const follower of $gamePlayer.followers().reverseData()) {
|
|
this._characterSprites.push(new Sprite_Character(follower));
|
|
}
|
|
this._characterSprites.push(new Sprite_Character($gamePlayer));
|
|
for (const sprite of this._characterSprites) {
|
|
this._tilemap.addChild(sprite);
|
|
}
|
|
};
|
|
|
|
Spriteset_Map.prototype.createShadow = function() {
|
|
this._shadowSprite = new Sprite();
|
|
this._shadowSprite.bitmap = ImageManager.loadSystem("Shadow1");
|
|
this._shadowSprite.anchor.x = 0.5;
|
|
this._shadowSprite.anchor.y = 1;
|
|
this._shadowSprite.z = 6;
|
|
this._tilemap.addChild(this._shadowSprite);
|
|
};
|
|
|
|
Spriteset_Map.prototype.createDestination = function() {
|
|
this._destinationSprite = new Sprite_Destination();
|
|
this._destinationSprite.z = 9;
|
|
this._tilemap.addChild(this._destinationSprite);
|
|
};
|
|
|
|
Spriteset_Map.prototype.createWeather = function() {
|
|
this._weather = new Weather();
|
|
this.addChild(this._weather);
|
|
};
|
|
|
|
Spriteset_Map.prototype.updateTileset = function() {
|
|
if (this._tileset !== $gameMap.tileset()) {
|
|
this.loadTileset();
|
|
}
|
|
};
|
|
|
|
Spriteset_Map.prototype.updateParallax = function() {
|
|
if (this._parallaxName !== $gameMap.parallaxName()) {
|
|
this._parallaxName = $gameMap.parallaxName();
|
|
this._parallax.bitmap = ImageManager.loadParallax(this._parallaxName);
|
|
}
|
|
if (this._parallax.bitmap) {
|
|
const bitmap = this._parallax.bitmap;
|
|
this._parallax.origin.x = $gameMap.parallaxOx() % bitmap.width;
|
|
this._parallax.origin.y = $gameMap.parallaxOy() % bitmap.height;
|
|
}
|
|
};
|
|
|
|
Spriteset_Map.prototype.updateTilemap = function() {
|
|
this._tilemap.origin.x = $gameMap.displayX() * $gameMap.tileWidth();
|
|
this._tilemap.origin.y = $gameMap.displayY() * $gameMap.tileHeight();
|
|
};
|
|
|
|
Spriteset_Map.prototype.updateShadow = function() {
|
|
const airship = $gameMap.airship();
|
|
this._shadowSprite.x = airship.shadowX();
|
|
this._shadowSprite.y = airship.shadowY();
|
|
this._shadowSprite.opacity = airship.shadowOpacity();
|
|
};
|
|
|
|
Spriteset_Map.prototype.updateWeather = function() {
|
|
this._weather.type = $gameScreen.weatherType();
|
|
this._weather.power = $gameScreen.weatherPower();
|
|
this._weather.origin.x = $gameMap.displayX() * $gameMap.tileWidth();
|
|
this._weather.origin.y = $gameMap.displayY() * $gameMap.tileHeight();
|
|
};
|
|
|
|
Spriteset_Map.prototype.updateBalloons = function() {
|
|
for (const sprite of this._balloonSprites) {
|
|
if (!sprite.isPlaying()) {
|
|
this.removeBalloon(sprite);
|
|
}
|
|
}
|
|
this.processBalloonRequests();
|
|
};
|
|
|
|
Spriteset_Map.prototype.processBalloonRequests = function() {
|
|
for (;;) {
|
|
const request = $gameTemp.retrieveBalloon();
|
|
if (request) {
|
|
this.createBalloon(request);
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
};
|
|
|
|
Spriteset_Map.prototype.createBalloon = function(request) {
|
|
const targetSprite = this.findTargetSprite(request.target);
|
|
if (targetSprite) {
|
|
const sprite = new Sprite_Balloon();
|
|
sprite.targetObject = request.target;
|
|
sprite.setup(targetSprite, request.balloonId);
|
|
this._effectsContainer.addChild(sprite);
|
|
this._balloonSprites.push(sprite);
|
|
}
|
|
};
|
|
|
|
Spriteset_Map.prototype.removeBalloon = function(sprite) {
|
|
this._balloonSprites.remove(sprite);
|
|
this._effectsContainer.removeChild(sprite);
|
|
if (sprite.targetObject.endBalloon) {
|
|
sprite.targetObject.endBalloon();
|
|
}
|
|
sprite.destroy();
|
|
};
|
|
|
|
Spriteset_Map.prototype.removeAllBalloons = function() {
|
|
for (const sprite of this._balloonSprites.clone()) {
|
|
this.removeBalloon(sprite);
|
|
}
|
|
};
|
|
|
|
Spriteset_Map.prototype.findTargetSprite = function(target) {
|
|
return this._characterSprites.find(sprite => sprite.checkCharacter(target));
|
|
};
|
|
|
|
Spriteset_Map.prototype.animationBaseDelay = function() {
|
|
return 0;
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Spriteset_Battle
|
|
//
|
|
// The set of sprites on the battle screen.
|
|
|
|
function Spriteset_Battle() {
|
|
this.initialize(...arguments);
|
|
}
|
|
|
|
Spriteset_Battle.prototype = Object.create(Spriteset_Base.prototype);
|
|
Spriteset_Battle.prototype.constructor = Spriteset_Battle;
|
|
|
|
Spriteset_Battle.prototype.initialize = function() {
|
|
Spriteset_Base.prototype.initialize.call(this);
|
|
this._battlebackLocated = false;
|
|
};
|
|
|
|
Spriteset_Battle.prototype.loadSystemImages = function() {
|
|
Spriteset_Base.prototype.loadSystemImages.call(this);
|
|
ImageManager.loadSystem("Shadow2");
|
|
ImageManager.loadSystem("Weapons1");
|
|
ImageManager.loadSystem("Weapons2");
|
|
ImageManager.loadSystem("Weapons3");
|
|
};
|
|
|
|
Spriteset_Battle.prototype.createLowerLayer = function() {
|
|
Spriteset_Base.prototype.createLowerLayer.call(this);
|
|
this.createBackground();
|
|
this.createBattleback();
|
|
this.createBattleField();
|
|
this.createEnemies();
|
|
this.createActors();
|
|
};
|
|
|
|
Spriteset_Battle.prototype.createBackground = function() {
|
|
this._backgroundFilter = new PIXI.filters.BlurFilter();
|
|
this._backgroundSprite = new Sprite();
|
|
this._backgroundSprite.bitmap = SceneManager.backgroundBitmap();
|
|
this._backgroundSprite.filters = [this._backgroundFilter];
|
|
this._baseSprite.addChild(this._backgroundSprite);
|
|
};
|
|
|
|
Spriteset_Battle.prototype.createBattleback = function() {
|
|
this._back1Sprite = new Sprite_Battleback(0);
|
|
this._back2Sprite = new Sprite_Battleback(1);
|
|
this._baseSprite.addChild(this._back1Sprite);
|
|
this._baseSprite.addChild(this._back2Sprite);
|
|
};
|
|
|
|
Spriteset_Battle.prototype.createBattleField = function() {
|
|
const width = Graphics.boxWidth;
|
|
const height = Graphics.boxHeight;
|
|
const x = (Graphics.width - width) / 2;
|
|
const y = (Graphics.height - height) / 2;
|
|
this._battleField = new Sprite();
|
|
this._battleField.setFrame(0, 0, width, height);
|
|
this._battleField.x = x;
|
|
this._battleField.y = y - this.battleFieldOffsetY();
|
|
this._baseSprite.addChild(this._battleField);
|
|
this._effectsContainer = this._battleField;
|
|
};
|
|
|
|
Spriteset_Battle.prototype.battleFieldOffsetY = function() {
|
|
return 24;
|
|
};
|
|
|
|
Spriteset_Battle.prototype.update = function() {
|
|
Spriteset_Base.prototype.update.call(this);
|
|
this.updateActors();
|
|
this.updateBattleback();
|
|
this.updateAnimations();
|
|
};
|
|
|
|
Spriteset_Battle.prototype.updateBattleback = function() {
|
|
if (!this._battlebackLocated) {
|
|
this._back1Sprite.adjustPosition();
|
|
this._back2Sprite.adjustPosition();
|
|
this._battlebackLocated = true;
|
|
}
|
|
};
|
|
|
|
Spriteset_Battle.prototype.createEnemies = function() {
|
|
const enemies = $gameTroop.members();
|
|
const sprites = [];
|
|
for (const enemy of enemies) {
|
|
sprites.push(new Sprite_Enemy(enemy));
|
|
}
|
|
sprites.sort(this.compareEnemySprite.bind(this));
|
|
for (const sprite of sprites) {
|
|
this._battleField.addChild(sprite);
|
|
}
|
|
this._enemySprites = sprites;
|
|
};
|
|
|
|
Spriteset_Battle.prototype.compareEnemySprite = function(a, b) {
|
|
if (a.y !== b.y) {
|
|
return a.y - b.y;
|
|
} else {
|
|
return b.spriteId - a.spriteId;
|
|
}
|
|
};
|
|
|
|
Spriteset_Battle.prototype.createActors = function() {
|
|
this._actorSprites = [];
|
|
if ($gameSystem.isSideView()) {
|
|
for (let i = 0; i < $gameParty.maxBattleMembers(); i++) {
|
|
const sprite = new Sprite_Actor();
|
|
this._actorSprites.push(sprite);
|
|
this._battleField.addChild(sprite);
|
|
}
|
|
}
|
|
};
|
|
|
|
Spriteset_Battle.prototype.updateActors = function() {
|
|
const members = $gameParty.battleMembers();
|
|
for (let i = 0; i < this._actorSprites.length; i++) {
|
|
this._actorSprites[i].setBattler(members[i]);
|
|
}
|
|
};
|
|
|
|
Spriteset_Battle.prototype.findTargetSprite = function(target) {
|
|
return this.battlerSprites().find(sprite => sprite.checkBattler(target));
|
|
};
|
|
|
|
Spriteset_Battle.prototype.battlerSprites = function() {
|
|
return this._enemySprites.concat(this._actorSprites);
|
|
};
|
|
|
|
Spriteset_Battle.prototype.isEffecting = function() {
|
|
return this.battlerSprites().some(sprite => sprite.isEffecting());
|
|
};
|
|
|
|
Spriteset_Battle.prototype.isAnyoneMoving = function() {
|
|
return this.battlerSprites().some(sprite => sprite.isMoving());
|
|
};
|
|
|
|
Spriteset_Battle.prototype.isBusy = function() {
|
|
return this.isAnimationPlaying() || this.isAnyoneMoving();
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|