2023-04-20 20:46:05 +01:00
|
|
|
import { default as Pokemon } from '../pokemon';
|
|
|
|
import { getLevelTotalExp, getLevelRelExp } from '../data/exp';
|
|
|
|
import * as Utils from '../utils';
|
2023-04-02 01:06:44 +01:00
|
|
|
import { addTextObject, TextStyle } from './text';
|
2023-04-20 20:46:05 +01:00
|
|
|
import { getGenderSymbol, getGenderColor } from '../data/gender';
|
|
|
|
import { StatusEffect } from '../data/status-effect';
|
2023-10-03 17:50:31 +01:00
|
|
|
import BattleScene from '../battle-scene';
|
2023-03-28 19:54:52 +01:00
|
|
|
|
|
|
|
export default class BattleInfo extends Phaser.GameObjects.Container {
|
|
|
|
private player: boolean;
|
2023-05-18 16:11:06 +01:00
|
|
|
private mini: boolean;
|
|
|
|
private offset: boolean;
|
2023-04-10 18:54:06 +01:00
|
|
|
private lastName: string;
|
2023-04-12 00:08:03 +01:00
|
|
|
private lastStatus: StatusEffect;
|
2023-03-28 19:54:52 +01:00
|
|
|
private lastHp: integer;
|
|
|
|
private lastMaxHp: integer;
|
|
|
|
private lastHpFrame: string;
|
|
|
|
private lastExp: integer;
|
|
|
|
private lastLevelExp: integer;
|
|
|
|
private lastLevel: integer;
|
2023-10-03 17:50:31 +01:00
|
|
|
private lastLevelCapped: boolean;
|
2023-03-28 19:54:52 +01:00
|
|
|
|
2023-05-18 16:11:06 +01:00
|
|
|
private box: Phaser.GameObjects.Sprite;
|
2023-03-28 19:54:52 +01:00
|
|
|
private nameText: Phaser.GameObjects.Text;
|
2023-04-02 01:06:44 +01:00
|
|
|
private genderText: Phaser.GameObjects.Text;
|
2023-05-18 16:11:06 +01:00
|
|
|
private ownedIcon: Phaser.GameObjects.Sprite;
|
2023-11-04 23:46:48 +00:00
|
|
|
private splicedIcon: Phaser.GameObjects.Sprite;
|
2023-04-12 00:08:03 +01:00
|
|
|
private statusIndicator: Phaser.GameObjects.Sprite;
|
2023-03-28 19:54:52 +01:00
|
|
|
private levelContainer: Phaser.GameObjects.Container;
|
|
|
|
private hpBar: Phaser.GameObjects.Image;
|
|
|
|
private levelNumbersContainer: Phaser.GameObjects.Container;
|
|
|
|
private hpNumbersContainer: Phaser.GameObjects.Container;
|
|
|
|
private expBar: Phaser.GameObjects.Image;
|
|
|
|
|
|
|
|
constructor(scene: Phaser.Scene, x: number, y: number, player: boolean) {
|
|
|
|
super(scene, x, y);
|
|
|
|
this.player = player;
|
2023-05-18 16:11:06 +01:00
|
|
|
this.mini = !player;
|
|
|
|
this.offset = false;
|
2023-04-12 00:08:03 +01:00
|
|
|
this.lastName = null;
|
|
|
|
this.lastStatus = StatusEffect.NONE;
|
2023-03-28 19:54:52 +01:00
|
|
|
this.lastHp = -1;
|
|
|
|
this.lastMaxHp = -1;
|
|
|
|
this.lastHpFrame = null;
|
|
|
|
this.lastExp = -1;
|
|
|
|
this.lastLevelExp = -1;
|
|
|
|
this.lastLevel = -1;
|
|
|
|
|
|
|
|
// Initially invisible and shown via Pokemon.showInfo
|
|
|
|
this.setVisible(false);
|
|
|
|
|
2023-05-18 16:11:06 +01:00
|
|
|
this.box = this.scene.add.sprite(0, 0, this.getTextureName());
|
|
|
|
this.box.setOrigin(1, 0.5);
|
|
|
|
this.add(this.box);
|
2023-03-28 19:54:52 +01:00
|
|
|
|
2023-04-02 01:06:44 +01:00
|
|
|
this.nameText = addTextObject(this.scene, player ? -115 : -124, player ? -15.2 : -11.2, '', TextStyle.BATTLE_INFO);
|
|
|
|
this.nameText.setOrigin(0, 0);
|
|
|
|
this.add(this.nameText);
|
2023-03-28 19:54:52 +01:00
|
|
|
|
2023-04-02 01:06:44 +01:00
|
|
|
this.genderText = addTextObject(this.scene, 0, 0, '', TextStyle.BATTLE_INFO);
|
|
|
|
this.genderText.setOrigin(0, 0);
|
|
|
|
this.genderText.setPositionRelative(this.nameText, 0, 2);
|
|
|
|
this.add(this.genderText);
|
2023-03-28 19:54:52 +01:00
|
|
|
|
2023-04-18 06:32:26 +01:00
|
|
|
if (!this.player) {
|
2023-05-18 16:11:06 +01:00
|
|
|
this.ownedIcon = this.scene.add.sprite(0, 0, 'icon_owned');
|
2023-04-18 06:32:26 +01:00
|
|
|
this.ownedIcon.setVisible(false);
|
|
|
|
this.ownedIcon.setOrigin(0, 0);
|
|
|
|
this.ownedIcon.setPositionRelative(this.nameText, 0, 11.5);
|
|
|
|
this.add(this.ownedIcon);
|
|
|
|
}
|
|
|
|
|
2023-11-04 23:46:48 +00:00
|
|
|
this.splicedIcon = this.scene.add.sprite(0, 0, 'icon_spliced');
|
|
|
|
this.splicedIcon.setVisible(false);
|
|
|
|
this.splicedIcon.setOrigin(0, 0);
|
|
|
|
this.splicedIcon.setPositionRelative(this.nameText, 0, 2);
|
|
|
|
this.splicedIcon.setInteractive(new Phaser.Geom.Rectangle(0, 0, 5, 7), Phaser.Geom.Rectangle.Contains);
|
|
|
|
this.add(this.splicedIcon);
|
|
|
|
|
2023-04-12 00:08:03 +01:00
|
|
|
this.statusIndicator = this.scene.add.sprite(0, 0, 'statuses');
|
|
|
|
this.statusIndicator.setVisible(false);
|
|
|
|
this.statusIndicator.setOrigin(0, 0);
|
|
|
|
this.statusIndicator.setPositionRelative(this.nameText, 0, 11.5);
|
|
|
|
this.add(this.statusIndicator);
|
|
|
|
|
2023-04-02 01:06:44 +01:00
|
|
|
this.levelContainer = this.scene.add.container(player ? -41 : -50, player ? -10 : -5);
|
|
|
|
this.add(this.levelContainer);
|
2023-03-28 19:54:52 +01:00
|
|
|
|
|
|
|
const levelOverlay = this.scene.add.image(0, 0, 'overlay_lv');
|
2023-04-02 01:06:44 +01:00
|
|
|
this.levelContainer.add(levelOverlay);
|
2023-03-28 19:54:52 +01:00
|
|
|
|
2023-04-02 01:06:44 +01:00
|
|
|
this.hpBar = this.scene.add.image(player ? -61 : -71, player ? -1 : 4.5, 'overlay_hp');
|
|
|
|
this.hpBar.setOrigin(0);
|
|
|
|
this.add(this.hpBar);
|
2023-03-28 19:54:52 +01:00
|
|
|
|
2023-04-02 01:06:44 +01:00
|
|
|
this.levelNumbersContainer = this.scene.add.container(9.5, 0);
|
|
|
|
this.levelContainer.add(this.levelNumbersContainer);
|
2023-03-28 19:54:52 +01:00
|
|
|
|
|
|
|
if (this.player) {
|
2023-04-02 01:06:44 +01:00
|
|
|
this.hpNumbersContainer = this.scene.add.container(-15, 10);
|
|
|
|
this.add(this.hpNumbersContainer);
|
2023-03-28 19:54:52 +01:00
|
|
|
|
|
|
|
const expBar = this.scene.add.image(-98, 18, 'overlay_exp');
|
|
|
|
expBar.setOrigin(0);
|
|
|
|
expBar.setScale(0, 1);
|
|
|
|
this.add(expBar);
|
|
|
|
|
|
|
|
this.expBar = expBar;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-03-29 17:23:52 +01:00
|
|
|
initInfo(pokemon: Pokemon) {
|
|
|
|
this.nameText.setText(pokemon.name);
|
2023-04-10 18:54:06 +01:00
|
|
|
this.lastName = pokemon.name;
|
2023-04-02 01:06:44 +01:00
|
|
|
|
|
|
|
const nameSizeTest = addTextObject(this.scene, 0, 0, pokemon.name, TextStyle.BATTLE_INFO);
|
|
|
|
const nameTextWidth = nameSizeTest.displayWidth;
|
|
|
|
nameSizeTest.destroy();
|
|
|
|
|
|
|
|
this.genderText.setText(getGenderSymbol(pokemon.gender));
|
|
|
|
this.genderText.setColor(getGenderColor(pokemon.gender));
|
|
|
|
this.genderText.setPositionRelative(this.nameText, nameTextWidth, 0);
|
2023-03-28 19:54:52 +01:00
|
|
|
|
2023-11-04 23:46:48 +00:00
|
|
|
this.splicedIcon.setPositionRelative(this.nameText, nameTextWidth + this.genderText.displayWidth + 1, 1);
|
|
|
|
this.splicedIcon.setVisible(!!pokemon.fusionSpecies);
|
|
|
|
if (this.splicedIcon.visible) {
|
|
|
|
this.splicedIcon.on('pointerover', () => (this.scene as BattleScene).ui.showTooltip(null, `Spliced with ${pokemon.fusionSpecies.name}`));
|
|
|
|
this.splicedIcon.on('pointerout', () => (this.scene as BattleScene).ui.hideTooltip());
|
|
|
|
}
|
|
|
|
|
2023-04-18 06:32:26 +01:00
|
|
|
if (!this.player) {
|
2023-11-13 04:47:04 +00:00
|
|
|
const dexEntry = pokemon.scene.gameData.dexData[pokemon.species.speciesId];
|
|
|
|
this.ownedIcon.setVisible(!!dexEntry.caughtAttr);
|
2023-11-13 13:20:31 +00:00
|
|
|
const dexAttr = pokemon.getDexAttr();
|
|
|
|
if ((dexEntry.caughtAttr & dexAttr) < dexAttr)
|
2023-04-18 06:32:26 +01:00
|
|
|
this.ownedIcon.setTint(0x808080);
|
|
|
|
}
|
|
|
|
|
2023-03-29 17:23:52 +01:00
|
|
|
this.hpBar.setScale(pokemon.getHpRatio(), 1);
|
2023-05-18 16:11:06 +01:00
|
|
|
this.lastHpFrame = this.hpBar.scaleX > 0.5 ? 'high' : this.hpBar.scaleX > 0.25 ? 'medium' : 'low';
|
|
|
|
this.hpBar.setFrame(this.lastHpFrame);
|
2023-03-28 19:54:52 +01:00
|
|
|
if (this.player)
|
2023-03-29 17:23:52 +01:00
|
|
|
this.setHpNumbers(pokemon.hp, pokemon.getMaxHp());
|
|
|
|
this.lastHp = pokemon.hp;
|
|
|
|
this.lastMaxHp = pokemon.getMaxHp();
|
2023-03-28 19:54:52 +01:00
|
|
|
|
2023-03-29 17:23:52 +01:00
|
|
|
this.setLevel(pokemon.level);
|
|
|
|
this.lastLevel = pokemon.level;
|
2023-03-28 19:54:52 +01:00
|
|
|
|
|
|
|
if (this.player) {
|
2023-03-29 17:23:52 +01:00
|
|
|
this.expBar.setScale(pokemon.levelExp / getLevelTotalExp(pokemon.level, pokemon.species.growthRate), 1);
|
|
|
|
this.lastExp = pokemon.exp;
|
|
|
|
this.lastLevelExp = pokemon.levelExp;
|
2023-03-28 19:54:52 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-05-18 16:11:06 +01:00
|
|
|
getTextureName(): string {
|
|
|
|
return `pbinfo_${this.player ? 'player' : 'enemy'}${this.mini ? '_mini' : ''}`;
|
|
|
|
}
|
|
|
|
|
|
|
|
setMini(mini: boolean): void {
|
|
|
|
if (this.mini === mini)
|
|
|
|
return;
|
|
|
|
|
|
|
|
this.mini = mini;
|
|
|
|
|
|
|
|
this.box.setTexture(this.getTextureName());
|
|
|
|
|
|
|
|
if (this.player) {
|
|
|
|
this.y -= 12 * (mini ? 1 : -1);
|
|
|
|
}
|
|
|
|
|
|
|
|
const offsetElements = [ this.nameText, this.genderText, this.statusIndicator, this.levelContainer ];
|
|
|
|
offsetElements.forEach(el => el.y += 1.5 * (mini ? -1 : 1));
|
|
|
|
|
|
|
|
const toggledElements = [ this.hpNumbersContainer, this.expBar ];
|
|
|
|
toggledElements.forEach(el => el.setVisible(!mini));
|
|
|
|
}
|
|
|
|
|
|
|
|
setOffset(offset: boolean): void {
|
|
|
|
if (this.offset === offset)
|
|
|
|
return;
|
|
|
|
|
|
|
|
this.offset = offset;
|
|
|
|
|
|
|
|
this.x += 10 * (offset === this.player ? 1 : -1);
|
|
|
|
this.y += 27 * (offset ? 1 : -1);
|
|
|
|
}
|
|
|
|
|
2023-04-10 12:59:00 +01:00
|
|
|
updateInfo(pokemon: Pokemon, instant?: boolean): Promise<void> {
|
2023-04-10 00:15:21 +01:00
|
|
|
return new Promise(resolve => {
|
|
|
|
if (!this.scene) {
|
|
|
|
resolve();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2023-12-01 22:23:26 +00:00
|
|
|
if (this.lastName !== pokemon.name) {
|
2023-04-10 18:54:06 +01:00
|
|
|
this.nameText.setText(pokemon.name);
|
|
|
|
this.lastName = pokemon.name;
|
|
|
|
|
|
|
|
const nameSizeTest = addTextObject(this.scene, 0, 0, pokemon.name, TextStyle.BATTLE_INFO);
|
|
|
|
const nameTextWidth = nameSizeTest.displayWidth;
|
|
|
|
nameSizeTest.destroy();
|
|
|
|
|
|
|
|
this.genderText.setPositionRelative(this.nameText, nameTextWidth, 0);
|
|
|
|
}
|
|
|
|
|
2023-04-12 00:08:03 +01:00
|
|
|
if (this.lastStatus !== (pokemon.status?.effect || StatusEffect.NONE)) {
|
|
|
|
this.lastStatus = pokemon.status?.effect || StatusEffect.NONE;
|
|
|
|
|
|
|
|
if (this.lastStatus !== StatusEffect.NONE)
|
|
|
|
this.statusIndicator.setFrame(StatusEffect[this.lastStatus].toLowerCase());
|
|
|
|
this.statusIndicator.setVisible(!!this.lastStatus);
|
2023-04-18 06:32:26 +01:00
|
|
|
|
|
|
|
if (!this.player && this.ownedIcon.visible)
|
|
|
|
this.ownedIcon.setAlpha(this.statusIndicator.visible ? 0 : 1);
|
2023-04-12 00:08:03 +01:00
|
|
|
}
|
|
|
|
|
2023-04-26 05:16:00 +01:00
|
|
|
const updateHpFrame = () => {
|
|
|
|
const hpFrame = this.hpBar.scaleX > 0.5 ? 'high' : this.hpBar.scaleX > 0.25 ? 'medium' : 'low';
|
|
|
|
if (hpFrame !== this.lastHpFrame) {
|
|
|
|
this.hpBar.setFrame(hpFrame);
|
|
|
|
this.lastHpFrame = hpFrame;
|
|
|
|
};
|
|
|
|
};
|
|
|
|
|
2023-04-10 00:15:21 +01:00
|
|
|
const updatePokemonHp = () => {
|
2023-04-10 12:59:00 +01:00
|
|
|
const duration = !instant ? Utils.clampInt(Math.abs((this.lastHp) - pokemon.hp) * 5, 250, 5000) : 0;
|
2023-04-10 00:15:21 +01:00
|
|
|
this.scene.tweens.add({
|
|
|
|
targets: this.hpBar,
|
|
|
|
ease: 'Sine.easeOut',
|
|
|
|
scaleX: pokemon.getHpRatio(),
|
|
|
|
duration: duration,
|
|
|
|
onUpdate: () => {
|
|
|
|
if (this.player && this.lastHp !== pokemon.hp) {
|
|
|
|
const tweenHp = Math.ceil(this.hpBar.scaleX * pokemon.getMaxHp());
|
|
|
|
this.setHpNumbers(tweenHp, pokemon.getMaxHp())
|
|
|
|
this.lastHp = tweenHp;
|
|
|
|
}
|
|
|
|
|
2023-04-26 05:16:00 +01:00
|
|
|
updateHpFrame();
|
2023-04-10 00:15:21 +01:00
|
|
|
},
|
|
|
|
onComplete: () => {
|
2023-04-26 05:16:00 +01:00
|
|
|
updateHpFrame();
|
2023-04-10 00:15:21 +01:00
|
|
|
resolve();
|
|
|
|
}
|
|
|
|
});
|
|
|
|
if (!this.player)
|
|
|
|
this.lastHp = pokemon.hp;
|
|
|
|
this.lastMaxHp = pokemon.getMaxHp();
|
|
|
|
};
|
|
|
|
|
2023-10-03 17:50:31 +01:00
|
|
|
if (this.player) {
|
|
|
|
const isLevelCapped = pokemon.level >= (this.scene as BattleScene).getMaxExpLevel();
|
|
|
|
|
|
|
|
if ((this.lastExp !== pokemon.exp || this.lastLevel !== pokemon.level)) {
|
|
|
|
const originalResolve = resolve;
|
|
|
|
resolve = () => this.updatePokemonExp(pokemon).then(() => originalResolve());
|
|
|
|
} else if (isLevelCapped !== this.lastLevelCapped)
|
|
|
|
this.setLevel(pokemon.level);
|
|
|
|
|
|
|
|
this.lastLevelCapped = isLevelCapped;
|
2023-04-10 00:15:21 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
if (this.lastHp !== pokemon.hp || this.lastMaxHp !== pokemon.getMaxHp()) {
|
|
|
|
updatePokemonHp();
|
|
|
|
return;
|
|
|
|
} else if (!this.player && this.lastLevel !== pokemon.level) {
|
|
|
|
this.setLevel(pokemon.level);
|
|
|
|
this.lastLevel = pokemon.level;
|
|
|
|
}
|
|
|
|
|
|
|
|
resolve();
|
|
|
|
});
|
|
|
|
}
|
2023-03-28 19:54:52 +01:00
|
|
|
|
2023-04-10 12:59:00 +01:00
|
|
|
updatePokemonExp(battler: Pokemon, instant?: boolean): Promise<void> {
|
2023-04-10 00:15:21 +01:00
|
|
|
return new Promise(resolve => {
|
|
|
|
const levelUp = this.lastLevel < battler.level;
|
|
|
|
const relLevelExp = getLevelRelExp(this.lastLevel + 1, battler.species.growthRate);
|
|
|
|
const levelExp = levelUp ? relLevelExp : battler.levelExp;
|
2023-04-19 19:07:38 +01:00
|
|
|
let ratio = relLevelExp ? levelExp / relLevelExp : 0;
|
2023-10-28 23:38:22 +01:00
|
|
|
if (this.lastLevel >= (this.scene as BattleScene).getMaxExpLevel(true)) {
|
2023-04-19 19:07:38 +01:00
|
|
|
if (levelUp)
|
|
|
|
ratio = 1;
|
2023-10-03 17:50:31 +01:00
|
|
|
else
|
|
|
|
ratio = 0;
|
2023-04-19 19:07:38 +01:00
|
|
|
instant = true;
|
|
|
|
}
|
2023-11-04 04:32:12 +00:00
|
|
|
const durationMultiplier = Phaser.Tweens.Builders.GetEaseFunction('Sine.easeIn')(1 - (Math.max(this.lastLevel - 100, 0) / 150));
|
|
|
|
let duration = this.visible && !instant ? (((levelExp - this.lastLevelExp) / relLevelExp) * 1650) * durationMultiplier : 0;
|
2023-04-10 00:15:21 +01:00
|
|
|
if (duration)
|
2023-10-21 13:58:39 +01:00
|
|
|
(this.scene as BattleScene).playSound('exp');
|
2023-03-28 19:54:52 +01:00
|
|
|
this.scene.tweens.add({
|
2023-04-10 00:15:21 +01:00
|
|
|
targets: this.expBar,
|
|
|
|
ease: 'Sine.easeIn',
|
|
|
|
scaleX: ratio,
|
2023-03-28 19:54:52 +01:00
|
|
|
duration: duration,
|
|
|
|
onComplete: () => {
|
2023-04-20 06:04:36 +01:00
|
|
|
if (!this.scene) {
|
|
|
|
resolve();
|
|
|
|
return;
|
|
|
|
}
|
2023-04-10 00:15:21 +01:00
|
|
|
if (duration)
|
|
|
|
this.scene.sound.stopByKey('exp');
|
|
|
|
if (ratio === 1) {
|
|
|
|
this.lastLevelExp = 0;
|
|
|
|
this.lastLevel++;
|
2023-10-21 13:58:39 +01:00
|
|
|
(this.scene as BattleScene).playSound('level_up');
|
2023-04-10 00:15:21 +01:00
|
|
|
this.setLevel(this.lastLevel);
|
|
|
|
this.scene.time.delayedCall(500, () => {
|
|
|
|
this.expBar.setScale(0, 1);
|
2023-04-10 12:59:00 +01:00
|
|
|
this.updateInfo(battler, instant).then(() => resolve());
|
2023-04-10 00:15:21 +01:00
|
|
|
});
|
|
|
|
return;
|
|
|
|
} else {
|
|
|
|
this.lastExp = battler.exp;
|
|
|
|
this.lastLevelExp = battler.levelExp;
|
2023-03-28 19:54:52 +01:00
|
|
|
}
|
2023-04-10 00:15:21 +01:00
|
|
|
resolve();
|
2023-03-28 19:54:52 +01:00
|
|
|
}
|
|
|
|
});
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
setLevel(level: integer) {
|
2023-10-03 17:50:31 +01:00
|
|
|
const isCapped = level >= (this.scene as BattleScene).getMaxExpLevel();
|
2023-04-10 18:54:06 +01:00
|
|
|
this.levelNumbersContainer.removeAll(true);
|
2023-03-28 19:54:52 +01:00
|
|
|
const levelStr = level.toString();
|
|
|
|
for (let i = 0; i < levelStr.length; i++)
|
2023-10-27 02:51:24 +01:00
|
|
|
this.levelNumbersContainer.add(this.scene.add.image(i * 8, 0, `numbers${isCapped && this.player ? '_red' : ''}`, levelStr[i]));
|
2023-03-28 19:54:52 +01:00
|
|
|
this.levelContainer.setX((this.player ? -41 : -50) - 8 * Math.max(levelStr.length - 3, 0));
|
|
|
|
}
|
|
|
|
|
|
|
|
setHpNumbers(hp: integer, maxHp: integer) {
|
2023-04-20 06:04:36 +01:00
|
|
|
if (!this.player || !this.scene)
|
2023-03-28 19:54:52 +01:00
|
|
|
return;
|
2023-04-10 18:54:06 +01:00
|
|
|
this.hpNumbersContainer.removeAll(true);
|
2023-03-28 19:54:52 +01:00
|
|
|
const hpStr = hp.toString();
|
|
|
|
const maxHpStr = maxHp.toString();
|
|
|
|
let offset = 0;
|
|
|
|
for (let i = maxHpStr.length - 1; i >= 0; i--)
|
|
|
|
this.hpNumbersContainer.add(this.scene.add.image(offset++ * -8, 0, 'numbers', maxHpStr[i]));
|
|
|
|
this.hpNumbersContainer.add(this.scene.add.image(offset++ * -8, 0, 'numbers', '/'));
|
|
|
|
for (let i = hpStr.length - 1; i >= 0; i--)
|
|
|
|
this.hpNumbersContainer.add(this.scene.add.image(offset++ * -8, 0, 'numbers', hpStr[i]));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
export class PlayerBattleInfo extends BattleInfo {
|
|
|
|
constructor(scene: Phaser.Scene) {
|
|
|
|
super(scene, Math.floor(scene.game.canvas.width / 6) - 10, -72, true);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
export class EnemyBattleInfo extends BattleInfo {
|
|
|
|
constructor(scene: Phaser.Scene) {
|
|
|
|
super(scene, 140, -141, false);
|
|
|
|
}
|
2023-05-18 16:11:06 +01:00
|
|
|
|
|
|
|
setMini(mini: boolean): void { } // Always mini
|
2023-03-28 19:54:52 +01:00
|
|
|
}
|