> Arcade Engine: Space Invaders

When developing this arcade engine, an unexpected structural anomaly emerged: if a player destroyed any enemy ship while the fleet was moving across the screen, the entire formation would later become physically distorted, miss the boundary thresholds, and slide completely off the canvas. The fleet would only bounce back once the absolute last remaining ship in the fleet array hit the margin. The core problem stems from mutating a list in-place while iterating over it sequentially. When .remove() is called, Python immediately shifts all subsequent elements one slot to the left to fill the empty allocation space. However, the active for loop cursor keeps moving forward sequentially to the next index. This causes the loop to completely skip the ship right next to the deleted one for that single frame. That skipped ship missed its position update, causing it to permanently lag behind by MOVE_DISTANCE (5 pixels). Because this entire sequence is nested inside the infinite heartbeat of the 'while self.game_is_on:' loop in main.py, the error compounded exponentially on every tick. The Solution: De-coupling State with the Snapshot Pattern To stop the infinite while loop from amplifying these shifting indices, the code introduces a variant of the Snapshot Design Pattern, isolating the boundary evaluation check into short-lived, immutable memory captures: newlst_right = [i for i in self.alien_ships if i.xcor() > 350] newlst_left = [i for i in self.alien_ships if i.xcor() < -350] By generating newlst_right and newlst_left via list comprehensions, the code captures an instance snapshot of the ships' physical locations on the canvas, completely independent of their index positions in the master self.alien_ships collection. Even if a prior frame skip caused a ship to lag behind or drift out of formation, its spatial coordinates are caught by the snapshot list, forcing bounce_x() to execute reliably and keeping the entire fleet safely inside the screen boundaries. An advanced operational nuance inside the dynamic boundary handler is the explicit invocation of 'newlst_right.clear()' immediately following the vector inversion call. By explicitly executing '.clear()' on the temporary array inside the initial valid loop step, the engine performs a high-speed execution short-circuit. It purges remaining reference pointers instantly, halting the iteration process before redundant balance flips occur, ensuring that fleet trajectory changes exactly once per tick loop.