Merge branch 'battleDialogue' into main

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);

src/field/pokemon.ts

@@ -1645,28 +1645,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:

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<Moves> = [];
 export const SHINY_OVERRIDE: boolean = false;
 export const VARIANT_OVERRIDE: Variant = 0;
+// eg: Moves.TACKLE
+export const MOVESET_OVERRIDE: Array<Moves> = []
 
 /**
  * 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<Moves> = [];
+export const OPP_MOVESET_OVERRIDE: Array<Moves> = []
 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 STARTER_SPECIES_OVERRIDE: Species | integer = 0
-export const OPP_SPECIES_OVERRIDE: Species | integer = 0;
+export const OPP_SPECIES_OVERRIDE: Species | integer = 0
 
 /**
  * MODIFIER / ITEM OVERRIDES

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