From 4d655ccc603e286cd6c1d28d767d56993476a791 Mon Sep 17 00:00:00 2001 From: DustinLin Date: Mon, 13 May 2024 17:07:50 -0400 Subject: [PATCH 1/2] adding comments and FaintPhase setPhaseQueueSplice bug, fixing overrides merge conflict --- src/field/pokemon.ts | 33 ++++++++++++++++++++------------- src/overrides.ts | 11 ++++++----- 2 files changed, 26 insertions(+), 18 deletions(-) diff --git a/src/field/pokemon.ts b/src/field/pokemon.ts index db87f44a2..211350924 100644 --- a/src/field/pokemon.ts +++ b/src/field/pokemon.ts @@ -1646,28 +1646,35 @@ export default abstract class Pokemon extends Phaser.GameObjects.Container { if (source.isPlayer() && !this.isPlayer()) this.scene.applyModifiers(DamageMoneyRewardModifier, true, source, damage) - // case when multi hit move killed early, then queue how many hits were made before - // eg: bullet seed 1 shots, double-slap 1 shots, - // note that simply looking at this.turnData.attacksReceived doesn't work for double battles - if (this.isFainted() && source.turnData.hitsLeft > 1){ - console.log(`${this.name} fainted: they received this many hits: ${this.turnData.attacksReceived.length}`); - // off by one from decrement, test more - const hitsTotal = source.turnData.hitCount - Math.max(source.turnData.hitsLeft, 0) + 1; - this.scene.queueMessage(i18next.t('battle:attackHitsCount', { count: hitsTotal})); - } - - // not sure what this set function is accomplishing, perhaps for the faint phase? it messes up with the queueMessage() - this.scene.setPhaseQueueSplice(); // finally checks and adds Fainted scene if (this.isFainted()) { + /** + * when adding the FaintPhase, want to toggle future unshiftPhase() and queueMessage() calls + * to appear before the FaintPhase (as FaintPhase will potentially end the encounter and add Phases such as + * GameOverPhase, VictoryPhase, etc.. that will interfere with anything else that happens during this MoveEffectPhase) + * + * once the MoveEffectPhase is over (and calls it's .end() function, shiftPhase() will reset the PhaseQueueSplice via clearPhaseQueueSplice() ) + */ + this.scene.setPhaseQueueSplice(); this.scene.unshiftPhase(new FaintPhase(this.scene, this.getBattlerIndex(), oneHitKo)); this.resetSummonData(); } + } - if (damage) + /** + * since damage is an object, I don't see how this would ever by false? + * i think the motivation was to have this here to counter setPhaseQueueSplice() + * not sure the original motivation + * + * It would be bad to run both the top if block and the one below commented out without changing the later's condition + */ + /* + if (damage){ this.scene.clearPhaseQueueSplice(); + } + */ } break; case MoveCategory.STATUS: diff --git a/src/overrides.ts b/src/overrides.ts index 704019a1d..d7975868c 100644 --- a/src/overrides.ts +++ b/src/overrides.ts @@ -47,12 +47,13 @@ export const POKEBALL_OVERRIDE: { active: boolean, pokeballs: PokeballCounts } = // forms can be found in pokemon-species.ts export const STARTER_FORM_OVERRIDE: integer = 0; // default 5 or 20 for Daily -export const STARTING_LEVEL_OVERRIDE: integer = 0; +export const STARTING_LEVEL_OVERRIDE: integer = 10; export const ABILITY_OVERRIDE: Abilities = Abilities.NONE; export const PASSIVE_ABILITY_OVERRIDE: Abilities = Abilities.NONE; -export const MOVESET_OVERRIDE: Array = []; export const SHINY_OVERRIDE: boolean = false; export const VARIANT_OVERRIDE: Variant = 0; +// eg: Moves.TACKLE +export const MOVESET_OVERRIDE: Array = [] /** * OPPONENT / ENEMY OVERRIDES @@ -60,7 +61,7 @@ export const VARIANT_OVERRIDE: Variant = 0; export const OPP_ABILITY_OVERRIDE: Abilities = Abilities.NONE; export const OPP_PASSIVE_ABILITY_OVERRIDE = Abilities.NONE; -export const OPP_MOVESET_OVERRIDE: Array = []; +export const OPP_MOVESET_OVERRIDE: Array = [] export const OPP_SHINY_OVERRIDE: boolean = false; export const OPP_VARIANT_OVERRIDE: Variant = 0; @@ -70,8 +71,8 @@ export const OPP_VARIANT_OVERRIDE: Variant = 0; * default is 0 to not override * @example SPECIES_OVERRIDE = Species.Bulbasaur; */ -export const STARTER_SPECIES_OVERRIDE: Species | integer = 0; -export const OPP_SPECIES_OVERRIDE: Species | integer = 0; +export const STARTER_SPECIES_OVERRIDE: Species | integer = 0 +export const OPP_SPECIES_OVERRIDE: Species | integer = 0 /** * MODIFIER / ITEM OVERRIDES From 7b86b4c4d92c9145b78b7b85d6bc12b216766742 Mon Sep 17 00:00:00 2001 From: DustinLin Date: Mon, 13 May 2024 17:23:56 -0400 Subject: [PATCH 2/2] writing better comments --- src/battle-scene.ts | 42 ++++++++++++++++++++++++++++++++++++++++-- src/phases.ts | 8 +++++++- 2 files changed, 47 insertions(+), 3 deletions(-) diff --git a/src/battle-scene.ts b/src/battle-scene.ts index 444952936..4e6a477c6 100644 --- a/src/battle-scene.ts +++ b/src/battle-scene.ts @@ -1498,24 +1498,41 @@ export default class BattleScene extends SceneBase { getStandbyPhase(): Phase { return this.standbyPhase; } + /** + * PhaseQueuePrepend: is a temp storage of what will be added to PhaseQueue + * PhaseQueue: dequeue/remove the first element to get the next phase + * queues are moved around during shiftPhase() below + */ + // adds a phase to "nextCommandPhaseQueue", as long as boolean passed in is false pushPhase(phase: Phase, defer: boolean = false): void { (!defer ? this.phaseQueue : this.nextCommandPhaseQueue).push(phase); } + // adds phase to the end, or at some specified index unshiftPhase(phase: Phase): void { if (this.phaseQueuePrependSpliceIndex === -1) + // .push() adds to end of array this.phaseQueuePrepend.push(phase); else + // .splice(index, num elements to remove, what to add) + // modifies array by inserting at index, removing num of elements after index this.phaseQueuePrepend.splice(this.phaseQueuePrependSpliceIndex, 0, phase); - // debug: printing out phase queue - //this.phaseQueuePrepend.forEach(p => console.log(p.constructor.name)); + /** + * debugging queues via printing, may be helpful in the future + console.log(`State of the phaseQueuePrepend (will be moved over to phaseQeueu)`) + this.phaseQueuePrepend.forEach(p => console.log(p.constructor.name)); + + console.log(`State of the phaseQueue, what is going to be called next `) + this.phaseQueue.forEach(p => console.log(p.constructor.name)); + */ } clearPhaseQueue(): void { this.phaseQueue.splice(0, this.phaseQueue.length); } + // combo with unshiftPhase(), want to start inserting at current length instead of the "end", useful if phaseQueuePrepend gets longer with Phases setPhaseQueueSplice(): void { this.phaseQueuePrependSpliceIndex = this.phaseQueuePrepend.length; } @@ -1524,6 +1541,10 @@ export default class BattleScene extends SceneBase { this.phaseQueuePrependSpliceIndex = -1; } + /** + * is called by each Phase implementations "end()" by default + * dumps everything from phaseQueuePrepend to the start of of phaseQueue, then starts the first one + */ shiftPhase(): void { if (this.standbyPhase) { this.currentPhase = this.standbyPhase; @@ -1531,14 +1552,28 @@ export default class BattleScene extends SceneBase { return; } + // shifting phase (with no standby phase) will move everything from prepend to actual PhaseQueue? + // resets the index, if it was changed via setPhaseQueueSplice() if (this.phaseQueuePrependSpliceIndex > -1) this.clearPhaseQueueSplice(); if (this.phaseQueuePrepend.length) { while (this.phaseQueuePrepend.length) + // appends phaseQueuePrepend to phaseQueue + // eg: phaseQueue = [4,5,6], phaseQUeuePrepend = [1,2,3] + // -> [1,2,3,4,5,6] this.phaseQueue.unshift(this.phaseQueuePrepend.pop()); } + + // then starts from PhaseQueue, .shift() removes first elm of array + // populatePhaseQueue() adds a turnInit Phase at the end of phaseQueue (if the queue is emtpy) if (!this.phaseQueue.length) this.populatePhaseQueue(); + + /** debugging + * + console.log(`SHIFT PHASE: State of the phaseQueue, what is going to be called next`) + this.phaseQueue.forEach(p => console.log(p.constructor.name)); + */ this.currentPhase = this.phaseQueue.shift(); this.currentPhase.start(); } @@ -1589,11 +1624,14 @@ export default class BattleScene extends SceneBase { queueMessage(message: string, callbackDelay?: integer, prompt?: boolean, promptDelay?: integer, defer?: boolean) { const phase = new MessagePhase(this, message, callbackDelay, prompt, promptDelay); if (!defer) + // adds to the end of PhaseQueuePrepend this.unshiftPhase(phase); else + //remember that pushPhase adds it to nextCommandPhaseQueue this.pushPhase(phase); } + // moves everyhting from nextCommandPhaseQueue populatePhaseQueue(): void { if (this.nextCommandPhaseQueue.length) { this.phaseQueue.push(...this.nextCommandPhaseQueue); diff --git a/src/phases.ts b/src/phases.ts index 714eba771..a050af835 100644 --- a/src/phases.ts +++ b/src/phases.ts @@ -2032,6 +2032,11 @@ export class TurnStartPhase extends FieldPhase { this.scene.pushPhase(new TurnEndPhase(this.scene)); + /** + * this.end() will call shiftPhase(), which dumps everything from PrependQueue (aka everything that is unshifted()) to the front + * of the queue and dequeues to start the next phase + * this is important since stuff like SwitchSummon, AttemptRun, AttemptCapture Phases break the "flow" and should take precedence + */ this.end(); } } @@ -2251,6 +2256,7 @@ export class MovePhase extends BattlePhase { return false; }); + // Readability?: this function declaration honestly gets in the way of readability of what start() is doing , move either to beginning or end const doMove = () => { this.pokemon.turnData.acted = true; // Record that the move was attempted, even if it fails @@ -2531,7 +2537,7 @@ export class MoveEffectPhase extends PokemonPhase { const user = this.getUserPokemon(); if (user) { if (--user.turnData.hitsLeft >= 1 && this.getTarget()?.isActive()) - this.scene.unshiftPhase(this.getNewHitPhase()); + this.scene.unshiftPhase(this.getNewHitPhase()); // adds another MoveAffectPhase else { // queue message for number of hits made by multi-move // BUG: when fainting occurs, the resulting message isn't rendered - has to do with FaintPhase