Top-down alien shooter · hy4

We need implement index.html with Phaser. Need inspect directory, perhaps Phaser version. Need use browser tools briefly. Need think through robust game with procedural graphics. Need likely Phaser 3. We need write self-contained one file, script local phaser.min.js. Need no external requests. Need controls displayed. Need playable top-down shooter, WASD, aim mouse, left click fire. Arena, player, first wave aliens advance. Shots damage, contact damage. HUD health score wave. Points kills. Clear wave then harder wave increasing count or speed. Game over stop gameplay and restart restoring. Procedural graphics via Graphics/generated textures.

Need verify browser initial output and console, movement/aim/firing opening encounter, hits visible feedback, reload initial values. Need likely simulate via browser clicks/drags/keys and inspect perhaps expose state globally for testing. Browser tool can click/key/type/etc and inspect DOM/console/screenshots/motion. Need know Phaser mechanics. Let's inspect files.

Need determine version string.

Could be Phaser CE 2? Need inspect header.

Maybe Phaser 3 bundled webpack. Need find version assignment.

Phaser 3.80.1. Good.

Need design carefully.

Canvas perhaps 960x640, responsive scaling via Phaser.Scale.FIT/CENTER_BOTH. CSS dark background, game container. In-page overlay controls via DOM? Requirements display controls on screen. Could use Phaser text plus DOM overlay. Need avoid pointer conflicts. Phaser input pointer works on canvas. If DOM overlay pointer-events none. Could use Phaser HUD text all. Need restart button maybe DOM? Requirement game-over state with Restart. Can use Phaser interactive text/button. Better all in Phaser, easier browser interaction maybe click. Could also expose global API for testing. Need ensure game responds to browser tool key/click. Phaser keyboard capture perhaps. Need maybe browser tool click coordinates map canvas. Need understand browser harness viewport 1200x800; game might be 960x640 scaled and centered. We can choose fixed 1000x700 maybe centered. Use Scale.FIT and CENTER_BOTH, canvas likely scale 1.14 to viewport? Browser tool coordinate viewport; easier choose 1200x800 game dimensions and scale FIT to viewport, giving exact 1:1 if same. But sandbox perhaps viewport 1200x800 and body size maybe. We can set game width 1200 height 800 and Scale.FIT; canvas should 1200x800, perhaps scrollbar? CSS body hidden. That makes mapping straightforward. But arena should be playable and HUD. Perhaps use 1000x650 with centered offset; browser tools map coord perhaps need screenshots. Could set full 1200x800 to match. A big arena is okay. Need first wave aliens advance toward player. If spawn at border maybe too far to reach in test. We can spawn at moderate radius 220-320 from center and have speed ~55-75 px/s, encounter in a few seconds. Need first wave maybe 5 aliens. Need shots at pointer.

Could implement physics arcade with sprites from generated textures. Generated textures via Phaser Graphics. Need procedural designs:
- Starfield/grid using Graphics directly drawn to texture? no external assets. Could generate background texture perhaps using Graphics fill and random dots / grid. Use `this.make.graphics({x:0,y:0,add:false})`, draw, `generateTexture('bg', width,height)`, then `this.add.image(0,0,'bg').setOrigin(0)`.
- Player texture: maybe a triangular ship pointing right (so rotation 0 means right) with cyan/white details. Draw on 48x48 graphics with polygon and thrusters, generateTexture.
- Alien texture: green bug-ish circle/oval with eyes/antennae maybe generated texture; rotate? We can use sprite.
- Bullet texture: glowing yellow capsule/circle generated via graphics.
- Particle/hit feedback: use small graphics circles or built-in particle manager with generated texture. In Phaser 3.80 use `this.add.particles(x,y,'spark',{...})` maybe. Simpler manually create tweened circles/rectangles on hit and damage flash. Need visible feedback. Could tint alien white/red briefly, add explosion ring, floating damage? On projectile hit, destroy bullet, decrement alien HP, flash alien via `setTintFill(0xffffff)`, tween scale, create a burst of small colored circles using graphics objects and tweens. Alien death explosion and score popup. Player contact: damage with cooldown per alien, flash player, screen shake/camera red overlay. Health HUD update. Should be easy to verify.

Need game structure perhaps one Scene "GameScene", with restart via scene.restart. HUD. Need game-over state stops gameplay: set `gameOver=true`, physics.pause maybe; set velocities zero, disable spawning and firing; show overlay with Restart. Need restart restore health, score, wave 1. We can call `this.scene.restart()` and reinitialize fields. Potential issue old pointer state from click could auto-fire after restart. Set fire input state manually maybe handle `pointerdown` with cooldown and check gameOver. If use `input.activePointer.isDown` in update and fire rate, restart button click could be captured and immediately fire; harmless. Need restart button works.

Need wave progression after aliens cleared. Could spawn next wave after short delay and show "WAVE X" banner; increase count and speed. Need first wave active at startup. Need perhaps wave delay 1.3 secs. Need if all aliens dead. Need transition robustly. Use `waveActive`, `waveTransition`, `pendingWave`. In update, check `enemies.countActive(true)===0 && !waveTransition && !gameOver`, call clearWave. Need this right after start? First wave spawned in create. Good.

Aliens advance to player: in update iterate group children and set velocity based on angle to player, perhaps rotation toward player. Need variable speeds; each alien has hp. On contact, overlap with player. But arcade overlap continuous; implement per-alien hit cooldown via `alien.nextTouch` or global player invulnerability. Simpler global `lastContactTime`; overlap callback on each frame if `time > nextPlayerHit`. Damage 12 or 15, flash player, push alien back, camera shake, HUD. Need avoid aliens swarming and killing too fast; contact damage every 600ms. Player health 100. Need collision handling: bullets and aliens overlap; aliens and player overlap. Add collider between aliens and player maybe collision, but they'd push. Use overlap plus manual repulsion perhaps. Requirement contact damages. Fine. Could also add `physics.add.collider(alienGroup, alienGroup)` maybe avoid stacking; not essential. Could add world bounds player and enemies? Player `setCollideWorldBounds(true)` with world bounds inset perhaps arena. Need arena boundaries: draw border and use an inner rectangle. Use `physics.world.setBounds(32, 80, W-64, H-112)` perhaps HUD top. But game background full. Player should be clamped. Aliens spawn within bounds; setCollideWorldBounds? If they collide and seek player, could get stuck outside? Spawn inside. Use bounds. Bullets should be destroyed on world bounds? Arcade sprites with `setCollideWorldBounds(true)` and `onWorldBounds=true` or simpler check x/y outside arena in update. Need avoid enemy spawned on top player. Spawn from edges but inside: choose one of four sides near boundary. Need world bounds x 32 to W-32, y maybe 84 to H-32. Player start center (600,440 maybe). Spawn at edge with margin 60. Need first encounter perhaps visible almost immediately; at speed 70 px/s they reach in 3-4 sec. Could spawn a few nearer around 180-280 px from player. Use random angle and distance 260-330, clamp to arena. Need perhaps visually "advance toward player" can check positions with global debug state. Expose `window.__gameState()` or `window.alienShooterDebug` for tests. The browser tool's `inspect` maybe DOM only? Let's see docs? We can use browser inspect perhaps it outputs console and DOM summary. Could write JS variables and use `browser` action? No arbitrary JS execution besides maybe `inspect` could have console? We can use page through screenshot/motion. Could potentially use `browser` type into input? Need learn tool behavior by starting. Could maybe use custom debug outputs in DOM (hidden or visually labelled) and use inspect to read. The browser tool likely uses Playwright and `inspect` returns DOM text/console. Could have a `#debug` element with state (not necessarily hidden) updated periodically; then inspect DOM. Or detect from screenshots. Expose global state via `window.__shooter` and `inspect` may not evaluate JS. But can perhaps use browser tool `key` to manipulate; `inspect` gives screenshot? Let's later test. Could use visible HUD and motion frames to verify.

Need perhaps use Canvas with a DOM overlay containing title, controls, HUD. But dynamic values easier via text elements. Yet requirement game over restart. Could use HTML overlay with restart button and state; if harness inspects DOM, easier. However need ensure Phaser pointer input works with overlay. Use pointer-events none on HUD; gameover overlay pointer-events auto. But Phaser game canvas may still receive pointerdown through transparent HUD? If HUD parent pointer-events none, yes. Need perhaps avoid external network. Fine.

Would mixing DOM and Phaser be okay? All graphics procedurally generated in game; HUD text via DOM is not "graphics"? Requirement likely means no image assets, text fine. But perhaps simpler all Phaser text to avoid layout weirdness. Yet use HTML CSS to display title/controls and HUD with actual DOM gives easy inspect and screenshot. We can arrange around canvas and a fixed in-game panel. Need game canvas fill viewport, overlay positioned. We can use a `<div id="ui">` with HUD top bar and controls bottom. Need gameover overlay DOM with Restart button. But restart via native button click more reliable. Need manage pointer events and restart. Could use CSS pointer-events none for HUD, pointer-events auto for gameover overlay. Need ensure starting play: overlay hidden. Need controls on screen always: bottom-left small panel "WASD Move • MOUSE Aim • LEFT CLICK Fire". Need title/score/health/wave top. Add health bar maybe DOM. Could create updateHud() from scene and set text/bar width. Need initial health 100 score 0 wave 1. Need game over overlay with "GAME OVER", final score, wave reached, RESTART button. Button onclick calls scene.restart perhaps through global reference. Need mark game over; physics paused. Need restart resets HUD and state. Need ensure click on Restart doesn't also trigger Phaser firing. Overlay sits full-screen and pointer events auto; canvas beneath may still receive pointer? Native DOM event bubbles to overlay not canvas, so Phaser canvas won't get pointerdown if overlay catches it. Phaser's global input listeners might still see event at document level though Phaser often listens on canvas by default, so no. Need maybe set game.input.enabled false during game over? Could keep true; pressing restart may fire if canvas does get pointer event. Harmless. But gameOver check prevents firing.

Need make game canvas 1200x800. Use `Phaser.AUTO`, parent `'game'`, backgroundColor dark. Scale mode `Phaser.Scale.RESIZE`? If set width 1200 height 800 and CSS width 100vw/height 100vh, canvas could scale via CSS but input pointer mapping may need account. Phaser Scale.FIT with autoCenter: `scale: { mode: Phaser.Scale.FIT, autoCenter: Phaser.Scale.CENTER_BOTH, width: 1200, height: 800 }`; game canvas element will be scaled via CSS to fit window while internal dimensions are 1200x800; pointer coordinates map correctly. In 1200x800 viewport, exact. Browser tool could use fixed coordinates. However if body has margins, set 0. Need maybe zoom. Browser viewport always 1200x800. Good.

Could use canvas at full window and overlay. Need maybe title etc. Let's design.

Arena:
- World bounds `ARENA = {left:32, top:96, right:1168, bottom:768}` maybe. HUD top bar 84 high. Controls bottom 50 high; arena bottom can be 744. Need keep game objects above controls overlay: bounds bottom 742 perhaps. Use `physics.world.setBounds(ARENA.left, ARENA.top, ARENA.right-ARENA.left, ARENA.bottom-ARENA.top)`. Draw a subtle grid and border. Need player clamped to arena. Use static background with generated texture.

- `createProceduralTextures`:
  - Background texture: graphics fill `#070d18`; draw grid lines every 40 with low alpha; draw random star dots using deterministic seeded RNG maybe Math.random; draw border perhaps on separate graphics. Generate texture `'arena-bg'` at W,H. Use `this.add.image(0,0,'arena-bg').setOrigin(0).setDepth(-10)`. Need `graphics.generateTexture` after drawing. For alpha lines, `lineStyle(1, 0x...)`. Random stars maybe no need (procedural).
  - Border as `this.add.rectangle`? Generated graphics with line rectangle; all procedural. Could use graphics object directly. Fine.
  - player texture: Graphics 56x48 with triangular arrow pointing right: body polygon points `(6,24), (46,6), (40,24), (46,42)` maybe. Need fill cyan, stroke white. Cockpit circle. Side wings perhaps fill darker. Draw thrusters. Generate 56x48. Need texture origin center. `this.add.sprite` with arcade physics. Need body size maybe circle via `setCircle(16,12,8)`? With rotated texture maybe body stays circle. Easier `setSize(30,30).setOffset(13,9)`. Need world bounds.
  - alien texture: 44x44 green insect: perhaps central oval with spikes/legs and eyes. Draw polygon legs; fill ellipse; outline. generate. Need setCircle(17,5,5) or setSize(34,34). Could use `this.physics.add.sprite` and `setCircle(18,4,4)`. Need ensure no external assets.
  - bullet texture: 16x8? glow circle with line? Generate 20x12 with yellow outer ellipse fill alpha, bright core. `setCircle(4,6,2)` maybe.
  - particle texture: 8x8 circle.

Potential issue `generateTexture` with Graphics and alpha needs `generateTexture(key,w,h)`; then destroy graphics. Fine.

- Phaser groups:
  `this.bullets = this.physics.add.group({ classType: Phaser.Physics.Arcade.Sprite, runChildUpdate: false });`
  `this.aliens = this.physics.add.group({ classType: Phaser.Physics.Arcade.Sprite, runChildUpdate: false });`
  Could set `allowGravity:false`; no gravity by default.
  Need add overlap:
```
this.physics.add.overlap(this.bullets, this.aliens, this.hitAlien, null, this);
this.physics.add.overlap(this.player, this.aliens, this.touchAlien, null, this);
```
  Bullet could hit multiple aliens in same frame if overlap callback multiple times; destroy bullet and check `if (!bullet.active || !alien.active) return;` then disable/destroy. Use `bullet.destroy()` and alien hp. Need avoid alien destroyed leading callback with old sprite. Check active.
  Need collision world bounds for bullets? We can check in update:
```
for (const b of this.bullets.getChildren()) if active and outside arena expanded -> b.destroy()
```
  But bullets could be culled immediately if fired from player near boundary? no.
  Could set `disableBody(true,true)` perhaps group reuse. Simpler `destroy`.
  Need bullet speed 620, lifespan 1300ms maybe store `bornAt`. In update destroy if time-bornAt > 1500 or outside. Need avoid relying solely on world bounds. Good.

- Input:
  - `this.keys = this.input.keyboard.addKeys('W,A,S,D')`; also arrow maybe optional but required WASD. Could include `this.input.keyboard.addKeys({up: 'W', left:'A', down:'S', right:'D'})`. Need avoid keyboard input issue with global hotkeys? Fine. Also `SHIFT` maybe not needed.
  - pointer: `this.input.on('pointermove', pointer => { this.aimAngle = Phaser.Math.Angle.Between(player.x, player.y, pointer.worldX, pointer.worldY); })`. But with a fixed camera, pointer.x/y same world. Need update in update from activePointer each frame so aim tracks player movement even if mouse stationary. Use `const pointer = this.input.activePointer; const worldPoint = pointer.positionToCamera(this.cameras.main);` maybe `pointer.worldX` updated by input plugin? In Phaser 3, `activePointer.worldX/worldY` updated during input processing with camera. Better use `pointer.positionToCamera(this.cameras.main)` returning Vector2. Or `this.input.activePointer.worldX`. Since camera no scroll, pointer.x equals world. Use `Phaser.Math.Angle.Between(this.player.x, this.player.y, pointer.x, pointer.y)` and `player.setRotation(angle)`. Need account canvas scaling; pointer.x/y are game coordinates. Good.
  - fire: use pointerdown and `isDown` continuous with fire rate. In update:
```
if (!gameOver && pointer.isDown && pointer.leftButtonDown() && time >= nextFire) fireBullet(pointer);
```
But pointer may be down over DOM HUD? HUD pointer-events none, so canvas gets it. Need prevent browser context menu? left only.
  - Maybe pointerdown event triggers immediate fire: in update first frame after pointer down. Use `isDown`. Fire rate 180ms. To be responsive, set `nextFire=0`. Need make sure pointer's `leftButtonDown()` works; in Phaser 3 pointer event supplies button state. Could use `pointer.isDown && pointer.button === 0`? `leftButtonDown()` should exist. Use `(pointer.isDown && pointer.leftButtonDown())`. Need maybe pointer.isDown is true for touch too. Good.
  - Need initial aim maybe toward default pointer (0,0), could make player point toward right initially by setting pointer at center+100? Can't set pointer; set `aimAngle=0` until pointer moves. In update, if pointer has moved? ActivePointer starts x=0,y=0, so player would point upper-left initially. Could set `this.hasPointer=false`; on pointermove set true; in update if no pointer movement, angle 0. Need browser click likely pointer has position. But requirement aim toward mouse pointer; initial can be east until pointer moves. Could also use DOM mousemove listener to set last pointer. Phaser pointer events on canvas only. We can set `this.input.on('pointermove', ...)`, and perhaps global `window.addEventListener('mousemove', ...)` to capture pointer over HUD (pointer-events none anyway). But no need.
  - Need `this.input.mouse.disableContextMenu()` maybe.

- Player movement:
```
let vx=0,vy=0;
if (A.isDown) vx--; ...
normalize; player.body.setVelocity(vx*280, vy*280);
```
Need perhaps `setCollideWorldBounds(true)` and `body.setBoundsRectangle`? physics world bounds applies. Player's `setCollideWorldBounds(true)`. Need if scene paused? setting velocity while gameOver? update should return early perhaps. If gameOver, zero velocity.
  - Add thruster visual? Could generate particles when moving; not required but nice. Could create a tiny flame sprite or use `this.add.particles` with generated `'spark'`. But avoid complexity. Could draw player thruster as part of texture. Maybe create a `this.thruster = this.add.image(...)` updated to player x/y/rotation? Could be nice but unnecessary. Need focus functionality.

- Aliens:
  - `spawnWave(wave)`:
```
const count = 4 + wave*2; // wave1=6
const speed = 55 + wave*10; maybe first 62, harder each wave.
const hp = 1 + Math.floor((wave-1)/2) maybe first 2 hp? Need shots damage aliens. To verify a projectile hit produces visible feedback, better first-wave aliens die in 1 shot so visible explosion is obvious. Use hp = 1 + Math.floor((wave-1)/3), first 1, later 2. Need maybe score 100*wave. Could first wave 6 enemies with 1 HP.
```
Need initial first wave perhaps 5. Harder wave by count or speed. Use count = 4 + 2*wave (6 first, 8 second) and speed = 58 + 12*(wave-1). Fine.
  - spawn positions: use polar around player with distance 260-360, angle random, then clamp to ARENA margins. But random may place some near HUD/controls; clamp. Need avoid too close if clamp. Could choose side:
```
const side=Phaser.Math.Between(0,3);
x/y = ...
```
Maybe spawn from arena edges to make "advance toward player" obvious; but distance 400-550 px means 7-9 sec at 60px/s. Verification needs opening encounter; can choose distance 230-320 from player. Use angle around player and clamp. Ensure min distance from player > 180. If clamped causes close, adjust. Could spawn distributed around:
```
for i:
 angle = (i/count)*TAU + random(-0.25,0.25) + wave*0.3;
 dist = Phaser.Math.Between(240,330);
 x=clamp(player.x+cos*dist, ARENA.left+35, ARENA.right-35)
 y=clamp(...);
 if distance < 170 then maybe invert direction or increase.
```
Would spawn around player. Good. Need make first wave visible and nearby. Could use fixed angles for deterministic testing. Use `Phaser.Math.RND` maybe but random fine. Better deterministic positions via angle offset so no overlap. Use `angle = (i/count)*2π + 0.25`, distance = 270 + (i%3)*30. Clamping after could cause positions near edge. Need account player center at (600,430), arena top 96 bottom 752. Dist max 330, y min 100, okay; clamp top+30=126 maybe. x min 270 max930, okay. So no clamp needed mostly. Could just use fixed. The player can move, spawn based on current player position. At wave transitions perhaps player could be near edge; clamp then distance could shrink. We can ensure by clamping and then if <180, position from player along opposite? Maybe choose from edge side. Simpler spawn from points at arena edges x=left+45/right-45/y... plus random along side; distance >= 250 typically from center. If player near edge, one side may be close. Add check: if distance<200, choose opposite side. Fine.
  - Use a helper `pickSpawnPoint(i,count)`: choose 4 sides round robin; margin 55; random t 0.15-0.85; if distance from player<220, choose far side based on player's positions. Use `Phaser.Math.Between` random. Need perhaps all aliens spawn at edge; visible and advancing. At speed 65, from horizontal edge ~500px = 7.7 sec; vertical ~300px = 4.6 sec. Opening encounter can be observed with enemy movement. Could set speed first 80 to reach in ~4-6 sec. Better. Need maybe game not too hard. Set speed = 65 + 10*(wave-1), first 70? Let's choose 72 + 9*(wave-1), count = 5+wave (first 6). Contact damage 12 every 650ms. Player can shoot. Good.
  - Could spawn first wave at radius 250 from center to ensure encounter in 3 secs. Maybe use fixed ring for all waves, and increase speed/count. Need an arena and aliens advance. Doesn't require edge spawn. Let's do ring around current player with radius 260-340 but clamp. This gives rapid encounter. We can also add a "spawn flash" at position and brief tween scale from 0.2 to 1.0; visually indicates wave start.

- Alien movement:
```
const children = this.aliens.getChildren().slice();
for alien of children:
 if (!alien.active) continue;
 const angle = Phaser.Math.Angle.Between(alien.x,alien.y,player.x,player.y);
 this.physics.velocityFromRotation(angle, alien.speed, alien.body.velocity);
 alien.setRotation(angle + Math.PI/2?) If texture oriented up? Need draw alien texture symmetrical maybe no rotation needed. Could rotate slowly for bug-like wobble with `alien.rotation += dt*?`; but if setting to angle, could point. Draw alien with face facing right perhaps; then angle. Need texture design. Could make alien face right: eyes near right. Then rotation angle toward player. Fine.
 alien.body.setVelocity(cos*speed, sin*speed).
```
Need perhaps alien body `setCollideWorldBounds(true)` and `setBounce(1)`? If ring within bounds, okay. If player near edge, aliens might go outside but overlap still. Clamp spawns. Could set world bounds and bounce to keep in arena. Use `alien.setCollideWorldBounds(true).setBounce(1)`; but update sets velocity toward player each frame, could fight against bounds. Fine.
  - Wobble via `alien.setScale(1 + Math.sin(time*0.008+alien.phase)*0.05)` maybe slight. Need not conflict with flash tween scale. Could skip.
  - Separate group collider to avoid overlap maybe `this.physics.add.collider(this.aliens, this.aliens)`; this can complicate but okay. Need set in create once. Could cause speed issues; avoid.

- Bullet fire:
```
fireBullet(pointer, time) {
 if (gameOver) return;
 const targetX = pointer.worldX ?? pointer.x;
 const targetY = pointer.worldY ?? pointer.y;
 const angle = Angle.Between(player.x,player.y,targetX,targetY);
 const muzzleX=player.x+cos(angle)*28;
 const muzzleY=...
 const bullet=this.bullets.create(muzzleX,muzzleY,'bullet');
 bullet.setDepth(5).setRotation(angle).setCircle(4,6,2)?;
 bullet.body.setAllowGravity(false);
 bullet.born=time;
 bullet.damage=1;
 this.physics.velocityFromRotation(angle, 680, bullet.body.velocity);
 // muzzle flash: small circle tween and maybe camera shake slight
}
```
Need `create` from physics group sets body. generated bullet texture 20x12. `setCircle(4,6,2)` on arcade Sprite? yes via body maybe `bullet.body.setCircle(4,6,2)`, but setCircle offsets relative texture and may need `body.setAllowGravity(false)`. Simpler leave rectangular body 20x12. Fine.
  - Need bullet rotation angle; texture is horizontal pointing right.
  - Add `bullet.setBlendMode(Phaser.BlendModes.ADD)` maybe glow, nice.
  - Muzzle flash via `this.spawnSpark(muzzleX,muzzleY,0xffe66d,4,60)` maybe custom particle circles.
  - Set `nextFire=time+140` (7 shots/sec). Need perhaps mouse pointer down from browser click triggers a very brief down/up too short to register in update? Browser tool click likely sends pointerdown then pointerup quickly; Phaser's update may miss `isDown` if both happen between frames. Better handle `pointerdown` event directly to fire one shot. Also update continuous fire while `isDown`. Need define:
```
this.input.on('pointerdown', pointer => {
 if (pointer.leftButtonDown() && !gameOver) {
  this.aimAt(pointer);
  this.fireBullet(pointer, this.time.now);
 }
});
```
Then update uses `pointer.isDown && pointer.leftButtonDown()` for held fire but a click will produce immediate shot. Need avoid double firing with pointerdown + update same frame; set `nextFire = time+fireRate` in fireBullet. Good. Need `pointer.leftButtonDown()` in pointerdown event might return true. Could simply `if (pointer.button === 0 || pointer.leftButtonDown())`. In Phaser, pointer.button is 0 for left on pointerdown; for pointermove might be -1. Use `pointer.leftButtonDown && pointer.leftButtonDown()`. Need not use touch.
  - Could listen to `this.input.on('pointerupoutside')` not needed.

- Hit feedback:
```
hitAlien(bullet, alien) {
 if gameOver || !bullet.active || !alien.active return;
 bullet.destroy();
 this.createHitBurst(bullet.x, bullet.y, 0xffe66d, 8);
 alien.hp -= 1;
 alien.setTintFill(0xffffff);
 this.time.delayedCall(70,()=> {if(alien.active) alien.clearTint();});
 this.tweens.add({targets:alien,scaleX:1.3,scaleY:1.3,duration:70,yoyo:true});
 if hp<=0 killAlien...
}
```
Need `setTintFill` supported on Sprite. yes. Could set `alien.setTint(0xff5555)` instead. Use both? `setTintFill` makes solid white. Then `clearTint`.
  - `createHitBurst` create 8 particles as `this.add.circle(x,y,r,color,1)` (Phaser Shape GameObject - procedural graphics, allowed). Tween x/y/outward, alpha 0, scale 0, destroy. Need avoid slowdown but fine. Use `this.tweens.add`. Could create ring `this.add.circle(x,y,6,color).setStrokeStyle(2,color).setFillStyle()` and scale tween. Need no external assets.
  - `killAlien`:
```
alien.destroy();
this.score += 100 + (wave-1)*25;
this.kills++;
updateHud();
createExplosion(alien.x, alien.y);
showFloatingText(`+${points}`, ...);
```
Need collision overlap may call again; destroy sets active false. Good.
  - Need wave clear detection maybe immediately after kill: in update when group count 0. To avoid checking during spawn with scale tween, active true. Fine.
  - Need hidden DOM HUD update. `window.uiElements` perhaps define globally before Phaser. Need scene references. Create plain JS constants outside:
```
const ui = {health:..., ...}
window.setHud = function... maybe.
```
Could use `document.getElementById`. Need Ensure script order: phaser script then own script; DOM elements exist if own script at end body. Good.

- Contact:
```
touchAlien(player, alien) {
 if gameOver || !alien.active || time<this.nextPlayerDamage return;
 damagePlayer(12);
 this.nextPlayerDamage = time+650;
 knockback alien by velocity or position:
 const angle=Angle.Between(player.x,player.y,alien.x,alien.y);
 alien.x += cos*25...
 player.setTintFill(0xff4d6d); tween alpha? clear after 100.
 camera shake(120,0.006);
 flash red overlay using DOM? Could use `this.add.rectangle(...).setScrollFactor(0)` with alpha tween.
}
```
Need global `this.time.now` maybe scene time. In Phaser callback can use `this.time.now`. Fine.
  - `damagePlayer` set health=max(0,health-amount), update HUD; if zero `endGame()`.
  - Need avoid game over while iterating group etc. physics.pause() can be called inside overlap callback perhaps okay. Better set gameOver and use `this.physics.pause()` maybe safe. Could defer with `this.time.delayedCall(0,()=>this.physics.pause())`. But likely safe. Need stop gameplay. Set all velocities to zero, no further bullets. Could call `this.physics.pause()`. Need ensure restart works after physics paused; scene.restart should resume world? Does physics world resume on scene restart? Phaser Arcade Physics World is recreated on scene restart; likely yes. But to be safe call `this.physics.resume()` in `startRestart` before scene.restart or in create. We can call `this.physics.world.resume()` in create. Phaser docs have `this.physics.pause()` / `resume()`. On restart, new world likely running. But call `this.physics.resume()` at start of create. Need check method exists: ArcadePhysics has `pause()` and `resume()`. Yes.
  - Need stop timers/tweens? `this.scene.restart()` destroys scene; all. DOM overlay hidden. Need perhaps `game.canvas` remains. Fine.
  - Game over overlay:
```
const overlay=document.getElementById('game-over');
overlay.classList.add('show');
...
```
Need restart button:
```
document.getElementById('restart').addEventListener('click', () => {
 overlay.classList.remove('show');
 window.restartGame();
});
```
Global `window.restartGame = function(){ if (window.__scene) window.__scene.scene.restart(); }`. But if physics paused, calling `scene.restart()` from DOM outside should work. Need maybe `game.scene.getScene('GameScene').scene.restart()`. Could set global reference in create: `window.__alienShooter = this;`. In restart handler:
```
if (window.shooterScene) {
 window.shooterScene.physics.resume();
 window.shooterScene.scene.restart();
}
```
Could also call `game.scene.start('GameScene')`. scene.restart probably safe. Need no duplicate event listeners. Set once outside.
  - Need perhaps prevent keyboard keys from being captured and browser scrolling. `this.input.keyboard.addKeys` captures W/A/S/D by default? Phaser addKey captures. Use `preventDefault` maybe. Could add `this.input.keyboard.addCapture(['W','A','S','D','SPACE'])`.
  - Need handle pointer over gameover overlay: overlay set pointer-events auto; clicking Restart button triggers DOM event. Need Phaser maybe also listens on window and receives pointerdown; gameOver prevents firing. Good.

- Wave transition:
```
clearWave() {
 this.waveTransition=true;
 this.waveBanner text in Phaser? or DOM.
 this.wave++;
 show `WAVE ${wave} INCOMING` via center text (Phaser text) tween.
 this.time.delayedCall(1300, () => { if(!gameOver){ updateHud(); spawnWave(wave); waveTransition=false; }});
}
```
Need HUD wave display update when next wave starts? Could increment at clear and show next wave. Requirement after wave cleared start harder wave by increasing count/speed. Could increment immediately and spawn after delay; HUD wave 2 while no enemies. Fine. Or keep wave 1 until spawn. Need avoid update repeatedly invoking clearWave: set waveTransition. Need gameOver cancel delayed call? On scene restart timers destroyed. If gameOver during transition, callback checks `!gameOver`.
  - Need perhaps show wave banner DOM. Could use Phaser text. Use fixed center with alpha tween and scale. Need on restart clear. Phaser scene restart clears. Good.
  - Need first wave banner "WAVE 1" at start maybe. Requirement first wave active. Could show short banner but not block. Do it.
  - Need `wave` score etc fields initialized in create. `this.wave=1`, `this.health=100`, `this.score=0`, `this.kills=0`, `this.gameOver=false`, `this.waveTransition=false`, etc.
  - Need update HUD from create, and overlay hidden. Need `this.updateHud()`.
  - Need spawn first wave immediately. Spawn with `spawnWave(1)`. Need maybe a short spawn scale tween but active from start. Good.
  - Need HUD health bar width updated based on health. Need color change if low. Use CSS custom property or direct style.width and background. Implement:
```
healthValue.textContent = `${health}%`;
healthFill.style.width = `${health}%`;
healthFill.style.background = health>60? ...;
scoreValue.textContent = score.toString().padStart(5,'0');
waveValue.textContent=`${wave}`;
```
Need initial values visible. Good.
  - Need debug state DOM maybe add `#debug-state` at bottom of controls perhaps hidden from visual? To verify via inspect, could include a small `data-state` attribute on `#game-shell` updated every 100ms with JSON or simple string. Browser inspect might show attributes. Could also render a small status line e.g. "ALIENS 6 • BULLETS 0 • X 600 Y 430" in controls panel. This is actually useful and visible but might clutter. Could include `#telemetry` tiny text. Requirement display controls; additional telemetry acceptable. It would let us easily inspect movement/enemy positions. But perhaps it's unpolished to expose debug. Could set hidden debug element with text. Browser inspect might include hidden text? We can use `data-debug` on body and include state string. Could update `document.body.dataset.gameState = ...` and inspect DOM body attributes. Need know browser tool inspect output. Could also use console logs on events, but inspect may capture console. Could write a visible `#diagnostics` small line in bottom controls: `ALIENS: 6 | POS: 600,430 | SHOTS:0`. The task says display controls; telemetry not prohibited. Could style subtle. Better perhaps not show internals; use Phaser debug state in `window.__state` and use browser `inspect` maybe it might only return DOM/console. Could see.

Need perhaps expose a debug API to facilitate deterministic verification:
```
window.__shooterDebug = {
 getState: () => ({
 health,score,wave, px,py, angle, bulletCount, bullets:..., aliens:..., gameOver
 }),
 fireAt(x,y) maybe,
 spawnTestAlien...
}
```
No arbitrary browser tool to invoke JS though maybe we can use URL hash or key sequence. Could leverage keyboard input to trigger hidden debug commands? Not needed. But maybe browser inspect can evaluate? Let's learn tool behavior after first implementation. Could call browser `inspect` with no args and see output. We'll need an index.html first. Could also use `browser` screenshot and motion frames. Need perhaps use browser `click` at coords and `key` for WASD. Need know key action semantics; maybe `key` has `text` to type key names? tool schema says action key, text string. Could call `{"action":"key","text":"D"}` maybe. Need likely supported. We'll test.

Potential need to add explicit test hooks that browser can interact with via typing into an input field, but no arbitrary JS. Could use query parameter handling to perform scripted actions? For verification, we can add hidden debug controls activated by URL hash, but no network. Could reload with `?test=...` maybe browser reload action doesn't allow URL. Could perhaps click DOM debug button to fire etc. But requirement actual WASD/mouse behavior, should test via browser tool. Need not expose internals.

Let's think through browser tool actions. It likely uses Playwright. `browser` action can `click`, `drag`, `key`, `type`, `scroll`, `screenshot`, `motion`, `inspect`, `reload`. For key, `text` perhaps key string like "w". We can call `key` with text "w" or "KeyD"? Need discover. Could use `drag` from player to target? That's mouse down/move/up, may fire while dragging; good for aiming/firing. Need movement via key. Could perhaps use `browser.click` at pointer location to fire; aiming from activePointer coordinate should fire toward that coordinate. Need capture before/after positions via screenshot or DOM telemetry. Could use motion frames over time. Need maybe use key down hold? The `key` action might press/release instantly, too short for Phaser update to pick up. Could use `type` to send keys? `key` likely `page.keyboard.press` or down maybe. Need inspect. Could use `drag` physically move player? No, player isn't draggable. Could add an on-screen virtual joystick? Not required. Need test movement maybe via `browser.key` with text `"d"`; if press/release quick, Phaser might not see key down at update frame. Could use repeated key presses around screenshot but likely each action awaits time enough? Tool may have `key` with strings like `"W"` and simulates keydown. Need perhaps implement key handling with keydown events that directly move player by a small amount in addition to continuous update. But requirement move with WASD; can implement keydown to set velocity for a short duration or directly update position. Better robustly handle key presses from harness: add DOM keydown listener to set a `pulseMove` vector that lasts e.g. 140ms even if keyup quickly. But continuous WASD from real user still works. Could in Phaser `keydown` event set velocity and a timer. Or define custom `window.addEventListener('keydown',...)` to set `keyBoost`. Yet a keydown/keyup pair in one frame can otherwise be missed. Could have `this.input.keyboard.on('keydown-W', ...)` set `this.keyPulses.W = this.time.now+120`, and update checks `keys.W.isDown || time < pulses.W`. That makes quick key registered. Need perhaps handle repeat. Could do all keys with generic event:
```
this.input.keyboard.on('keydown', ev => {
 const k=ev.key.toLowerCase();
 if ('wasd'.includes(k)) this.keyPulse[k]=this.time.now+120;
});
```
Then update uses `isDown || pulse`. This helps testing. Need avoid duplicate keydown events from Phaser and browser? Fine.
  - Could also use direct `keydown-W` etc. Need Phaser keyboard plugin event names maybe `'keydown-W'`. Generic `keydown` works with `event` object. Use `event.code` maybe `KeyW`. Simpler use `event.key.toLowerCase()`. Need browser key tool maybe sends `"d"`. Good.
  - Need perhaps keep pulse 120ms so one key press moves ~30px; enough to see in screenshot. Could set 180ms. Real key hold uses isDown. Need when key released after hold, pulse ends maybe 120ms and small extra movement; acceptable.
  - Need set player velocity based on pulses.
  - Need perhaps also support arrow keys for convenience though controls specify WASD. Could include but not needed.
  - Need pointer aiming from click: pointerdown event uses pointer coordinates. Good.

Potential issue browser tool click at (x,y) may call page.mouse.click, which moves pointer then down/up very quickly; Phaser pointerdown event should fire but pointer coordinates might be from prior move event? Usually Playwright mouse.click triggers move then down; Phaser pointer position updates on down event. Good. Need aim use pointer x/y from event. Fine.

Need perhaps make player firing when clicking on canvas anywhere, including if click on HUD overlay with pointer-events none. Good. Gameover overlay has pointer events. Need avoid clicking restart firing after restart: gameover handler likely immediate; gameOver false after scene.restart; pointerup could perhaps register but no pointerdown in new scene. Fine.

Need perhaps use `Phaser.AUTO` with WebGL; browser sandbox likely supports. `Phaser.Graphics.generateTexture` works in Canvas and WebGL. Need no external fonts; use system fonts via CSS and Phaser text. Fine.

Need maybe use DOM HUD with CSS `font-family: monospace`, bright neon colors. Need all inline. Need no external resources. Need use local script tag exact filename: `<script src="phaser.min.js"></script>`. The runner inlines it; okay. Need perhaps avoid `type="module"` due local file restrictions. Plain script. Need add own script inline after. Need `index.html` present. Need no separate files. Good.

Let's draft full implementation.

HTML structure:
```
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset...>
<title>Xenon Breach</title>
<style>
:root...
* {box-sizing:border-box}
html,body {width:100%;height:100%;margin:0;overflow:hidden;background:#030711;color:#dff;}
body{font-family:...; user-select:none;}
#game-shell{position:relative;width:100vw;height:100vh;overflow:hidden;}
#game{position:absolute;inset:0;}
#game canvas{display:block;}
.hud {position:absolute;top:0;left:0;right:0;height:84px; display:flex;... pointer-events:none; background:linear-gradient(...); border-bottom...}
.brand...
.stats...
.stat...
#health-track...
#controls {position:absolute;left:20px;bottom:18px;... pointer-events:none}
kbd...
#telemetry maybe...
#wave-banner? Could use Phaser.
#game-over {position:absolute;inset:0;display:none;align-items:center;justify-content:center;background:rgba(...);backdrop-filter:blur(...);z-index:20;pointer-events:auto;}
#game-over.show{display:flex;}
.panel...
button...
</style>
</head>
<body>
<div id="game-shell">
 <div id="game"></div>
 <div class="hud">... </div>
 <div id="controls">... </div>
 <div id="game-over"...>...</div>
</div>
<script src="phaser.min.js"></script>
<script>
(function(){...
})();
</script>
</body>
</html>
```
Need fix `backdrop-filter` maybe supported, no issue. Need body not scroll. Need pointer events. Need gameover overlay hidden via `visibility:hidden` or display none; display none okay. Need button visually clear.
Need controls visible on screen maybe bottom panel:
```
<div class="controls-title">CONTROLS</div>
<div><kbd>W</kbd><kbd>A</kbd>... MOVE <span>...</span></div>
...
```
Need perhaps aim "MOUSE — AIM", "LEFT CLICK — FIRE". Include. Could add a small "WASD / MOUSE / LEFT CLICK" line. Good.
Need telemetry perhaps:
```
<div id="readout">Ready • Wave 1</div>
```
maybe useful but not necessary. Could style small.

HUD:
```
<div class="brand"><span class="logo">✦</span><div><h1>XENON BREACH</h1><p>SECTOR 7 // ALIEN CONTACT</p></div></div>
<div class="stat"><small>HULL</small><div id health...>100%</div><div track>fill</div></div>
...
```
Need scores etc ID. Need score, wave. Need kills? Not required; could show. Perhaps include `KILLS` to show points. But minimum health, score, wave. Add kills maybe. Use compact.

Gameover:
```
<div id=game-over ...>
 <div class=gameover-card>
  <p class=eyebrow>SIGNAL LOST</p>
  <h2>GAME OVER</h2>
  <p>...</p>
  <div>FINAL SCORE <b id=final-score>0</b> ...</div>
  <button id=restart>↻ RESTART MISSION</button>
 </div>
</div>
```
Need restart restores.

JS:
```
(() => {
'use strict';
const W=1200,H=800;
const ARENA = {...};
const ui = {...};
window.__shooter = { scene: null, snapshot: () => ... };
document.getElementById('restart').addEventListener('click', e => { e.stopPropagation(); ... });
class GameScene extends Phaser.Scene { constructor(){super('GameScene')}
create(){ window.__shooter.scene=this; this.physics.resume(); ... }
...
}
const config={type:Phaser.AUTO,parent:'game',width:W,height:H,backgroundColor:'#050a14',scale:{...},physics:{default:'arcade',arcade:{debug:false,gravity:{y:0}}},scene:[GameScene],render:{pixelArt:false,antialias:true},input:{mouse:{preventDefaultWheel:true}}};
const game = new Phaser.Game(config);
window.__shooter.game = game;
})();
```
Need maybe `input.activePointer`Capture? not necessary. Need call `this.input.mouse.disableContextMenu()` if exists. Need prevent browser context menu on right click; fine.
Need avoid `physics.resume()` before world created? In create, plugin exists. Fine.
Need maybe `this.physics.world.setBounds` and `this.physics.world.setBoundsCollision(true,true,true,true)`.

Texture generation:
```
makeTextures() {
 const g=this.make.graphics({x:0,y:0,add:false});
 g.fillStyle(0x060b17,1); g.fillRect(0,0,W,H);
 g.lineStyle(1,0x16314a,0.35);
 for (let x=ARENA.left; x<=ARENA.right; x+=40){...}
 // grid dashed maybe
 for random stars, deterministic LCG
 let seed=1337; const rand=()=>...
 for i 0..180: g.fillStyle(... alpha); g.fillCircle(rand()*W,rand()*H,rand()*1.5+0.3)
 // maybe nebula blobs via fillCircle with alpha
 g.lineStyle(2,0x1de5ff,0.45); g.strokeRect(ARENA.left,...)
 g.lineStyle(1,0x1de5ff,0.18); g.strokeRect(ARENA.left+6,...)
 // corner accents
 g.generateTexture('arena-bg',W,H); g.destroy();
 this.add.image(0,0,'arena-bg').setOrigin(0).setDepth(-20);

 // player
 const p=this.make.graphics({x:0,y:0,add:false});
 p.fillStyle(0x0b526e,1); p.fillTriangle maybe; need graphics fillPoints.
 p.fillStyle(0x19d9ff,1);
 p.beginPath(); p.moveTo(4,24); p.lineTo(48,5); p.lineTo(40,24); p.lineTo(48,43); p.closePath(); p.fillPath();
 p.lineStyle(2,0xd7fbff,1); ... strokePath
 p.fillStyle(0x08293b,1); p.fillTriangle(14,17,35,24,14,31);
 p.fillStyle(0xffffff,1); p.fillCircle(34,24,5);
 p.fillStyle(0xffb000,...); p.fillRect(4,20,6,8)
 p.generateTexture('player',56,48); p.destroy();
```
Need verify Graphics API: `fillTriangle(x1,y1,x2,y2,x3,y3)` exists. `fillPoints(points, closeShape, closePath)` maybe. Simpler use `fillTriangle` combos and `fillRect`, `fillCircle`, `lineBetween`.
Player triangle pointing right:
- main body: `fillTriangle(4,6,52,24,4,42)` gives arrow right point at (52,24); maybe wings.
- dark inner wing.
- cockpit circle at (32,24).
- outline via `lineStyle(2, color,1); strokeTriangle(4,6,52,24,4,42)` maybe Phaser Graphics has `strokeTriangle`. I think yes: `strokeTriangle(x1,y1,x2,y2,x3,y3)`. Could use `beginPath/moveTo/lineTo` and `strokePath` more reliable. Need Phaser Graphics methods: `beginPath`, `moveTo`, `lineTo`, `closePath`, `fillPath`, `strokePath`. yes.
- engine glow at rear left maybe `fillRect(0,20,6,8)`.

Alien texture:
```
a.lineStyle(3,0x5cff8f,1);
for legs: a.lineBetween(...);
a.fillStyle(0x1b8e4b); a.fillEllipse(22,22,26,32); // Graphics.fillEllipse exists? likely. Could use fillCircle(22,22,16) and scale? Graphics.fillEllipse(x,y,width,height) yes.
a.fillStyle(0x61ff7d); a.fillCircle(22,22,13);
a.fillStyle(0x06190d); a.fillCircle(27,17,3); ...
a.fillStyle(0xffffff); eyes maybe red.
a.lineStyle...
a.generateTexture('alien',44,44)
```
Need draw alien facing right, eyes at x 28 and 28 perhaps. Maybe body centered and slight directional "horn" at right. Good.
- bullet texture:
```
b.fillStyle(0xffcf33,0.25); b.fillCircle(10,6,6);
b.fillStyle(0xfff3a0); b.fillRoundedRect? Graphics.fillRoundedRect exists. Use fillRect(3,3,14,6); fillTriangle(17,1,20,6,17,11)
```
Need create 22x12.
- spark texture not needed if using circles.
- reticle texture perhaps custom Graphics crosshair follower? Nice to show aim toward mouse. Could generate `'reticle'` via Graphics and add image at pointer.x/y updated. This would make aiming visible and help verification. Use generated graphics texture, no external. Add crosshair to scene and track pointer each frame. Need setDepth 20. Could use `this.reticle = this.add.image(W/2+100,H/2,'reticle').setDepth(30)`; update position from activePointer; perhaps show only within arena. Need generate with line circles etc. This makes aim target obvious. Need pointer coordinates map. Could also draw aim line from player to reticle with Graphics object each frame. A thin dashed laser sight could show shooting direction. Use `this.aimLine = this.add.graphics().setDepth(1)`, update clear/lineStyle/lineBetween player to pointer. This would directly verify shots travel toward pointer. Need avoid clutter. Nice.

- Crosshair texture via Graphics:
```
r.lineStyle(2,0x7df9ff,0.9); r.strokeCircle(10,10,7); r.lineBetween...; generateTexture('reticle',20,20)
```
Need maybe hide native cursor over canvas? CSS `#game canvas { cursor: crosshair; }` but if custom reticle also show, could use `cursor:none;` to avoid double. Better set `cursor: crosshair` and no custom reticle? Native crosshair may be visible only in screenshot? Playwright screenshots usually don't include cursor. Custom reticle useful. Set `cursor:none`; show custom reticle. But if pointer starts at 0,0, custom reticle at top-left; could set initial at player.x+160, player.y. Need update only after pointer movement. Could use `this.pointerInitialized` and set reticle to default position; on first `pointermove`, set true. Then aim line from player to reticle default east until pointer moves. Good.
  - Need `pointermove` events from canvas to set pointerInitialized. Also `pointerdown` should set true. Could still use pointer coordinates from event. Good.
  - Need when mouse leaves canvas, reticle maybe stays; fine.
  - Need reticle visible over gameover? Phaser canvas behind DOM overlay; overlay dims it. Fine.
  - Need at game start pointer at (0,0) from activePointer; avoid by using `this.aimPoint={x:player.x+180,y:player.y}`. On pointermove/down set to pointer.x/y. On update if pointerInitialized and activePointer? Use stored aimPoint. Need if player moves and pointer stationary, aim updates angle from player to fixed aimPoint. Good. Need reticle position follow aimPoint. Need pointermove events only when pointer moves; fine. Need handle pointer coordinates relative to canvas scaling; Phaser pointer x/y in game coordinates.
  - Could use `this.input.on('pointermove', p => this.setAim(p));` and `pointerdown` set. Need no `pointerInitialized` if aimPoint default. Good.
  - Need update reticle maybe when pointer at gameover? doesn't matter.
  - Aim line `clear(); lineStyle(1,0x3fdfff,0.22); lineBetween(player.x,player.y,aimPoint.x,aimPoint.y)`. Need maybe dashes? simple line. Draw a small aim line from muzzle to target, not too distracting. Need set depth below sprites but above background.
  - Need `this.aimLine` graphics object perhaps generated separately.

- HUD update can also update DOM readout `#status` with aliens remaining etc for debug. Could have a small status in controls panel:
```
<span id="field-status">CONTACTS 06</span>
```
This is actually useful. Update every 200ms with active aliens, bullets, player x/y maybe not visible? Could use `data-*` attributes for debugging rather than showing coordinates. Let's include a small "CONTACTS: N" indicator and maybe `#telemetry` hidden visually? Need avoid hidden content from inspect. We can set body dataset state with JSON every 100ms:
```
document.body.dataset.shooterState = JSON.stringify(this.snapshot());
```
Then browser inspect might show. Could also set document.title with state? Inspect might show title. Maybe easiest read from screenshot HUD and use motion frames. But to verify positions precisely, we can use a visible tiny diagnostic line e.g. "CONTACTS 06 · POS 600,430 · SHOTS 0". It doesn't harm. Use status pill bottom right maybe. Need design: controls bottom-left, telemetry bottom-right. Keep subtle. This is not an external asset. Good.
```
<div id="telemetry">CONTACTS 06 · HULL OK</div>
```
Update with `PX 600 PY 430 · ALIENS 6 · SHOTS 0` every 100ms. This gives us DOM text to inspect after actions. Need perhaps browser `inspect` returns entire DOM text. Great. Also body dataset with state, possibly unnecessary. But can include `window.__shooter.snapshot()`. Let's do both maybe robust. Need avoid too much overhead; update telemetry every 100ms from update. Fine.

Snapshot:
```
snapshot() {
 return {
  health:this.health, score:this.score, wave:this.wave,
  player:{x:Math.round(this.player.x),y...,rotation:+...toFixed(3)},
  aliens:this.aliens.getChildren().filter(a=>a.active).map(...),
  bullets:this.bullets.getChildren().filter(...).map(...),
  aim:{x:Math.round(this.aimPoint.x),...},
  gameOver:this.gameOver,
  waveTransition:this.waveTransition
 };
}
window.__shooter.snapshot=()=>window.__shooter.scene?.snapshot()||null;
```
Need perhaps browser inspect can't call JS, but body dataset can include string:
```
document.body.dataset.state = `${...}`;
```
Need enough to see positions. Could put JSON string in a hidden `<pre id="state-json">` with `display:none`; DOM inspect may not show hidden text. Could put in attribute. We can set `document.getElementById('game-shell').setAttribute('data-state', JSON.stringify(...))`; inspect likely reports attributes? unknown. Visible telemetry is safest.

Need perhaps use browser screenshot and motion to check. We can read initial screenshot.

Need ensure game can be run from file:// path. Phaser local script loads. No network. Good. `new Phaser.Game` may try to access WebGL, okay. No assets load, so no issues. Need maybe `Phaser.AUTO` with WebGL in headless Chromium may fail; falls back to Canvas. Good.

Let's be precise with Phaser API.

Phaser 3.80:
- `this.make.graphics({ x: 0, y: 0, add: false })` works; could use `this.add.graphics()` then destroy. For generateTexture on graphics not added, `this.make.graphics({x:0,y:0,add:false})` works.
- `generateTexture(key, width, height)` works.
- `this.add.image(0,0,'bg').setOrigin(0)`.
- `this.physics.add.sprite(x,y,'player')`.
- `this.physics.add.group()` returns Arcade.Group. `group.create(x,y,'bullet')` returns Arcade.Sprite with body.
- `sprite.setCollideWorldBounds(true)` works.
- `sprite.setBounce(1)` works.
- `sprite.setCircle(radius, offsetX, offsetY)` on Arcade Sprite? There is `Sprite.setCircle(radius, offsetX, offsetY)` via Arcade Physics components maybe method exists. To avoid risk, use `sprite.body.setCircle(...)`. But body setCircle may need offset; use `sprite.body.setSize(30,30).setOffset(13,9)`? Arcade Body has `setSize(width,height,center)` and `setOffset(x,y)`. For sprite, `setSize` method perhaps proxies. Simpler no custom body: player texture 56x48 rectangular body okay; alien 44x44 rectangular body okay; bullet 22x12. Contact/hit detection slightly generous but fine. Could set `player.body.setSize(34,34,true)` — I think Body.setSize(width,height,center=true). Need check. To reduce risk, omit custom body. Arcade physics automatically uses texture size. Fine.
- `this.physics.velocityFromRotation(angle, speed, sprite.body.velocity)` works. Alternatively `sprite.body.setVelocity(Math.cos(angle)*speed, Math.sin(angle)*speed)`. Use direct to avoid API uncertainties.
- `sprite.setVelocity(vx,vy)` works on Arcade Sprite directly. Use that.
- `this.physics.add.overlap(this.bullets, this.aliens, this.onBulletHit, undefined, this)` works.
- `this.physics.add.overlap(this.player, this.aliens, this.onPlayerTouch, undefined, this)`.
- `this.physics.add.collider(this.aliens, this.aliens)` optional; skip.
- `setTintFill` on Sprite works. `clearTint` works.
- `this.cameras.main.shake(duration, intensity)` works.
- `this.cameras.main.flash(duration, r,g,b)` perhaps red flash; but can use DOM overlay. Could use `this.cameras.main.shake`.
- `this.add.circle(x,y,r,color,alpha)` gives Arc GameObject. Need methods `.setStrokeStyle`, `.setDepth`, `.setBlendMode` etc. Shape GameObjects support. Use `this.add.circle(x,y, radius, fillColor, fillAlpha)` perhaps `setFillStyle()`. Good.
- Tweens: `this.tweens.add({ targets: obj, x: ..., y: ..., alpha:0, scale:0, duration:..., ease:'Quad.easeOut', onComplete:()=>obj.destroy()})`. Works for shapes. Need avoid using `scale` if shape has no scale? It does. Good.
- For floating text: `this.add.text(x,y,text,{fontFamily:'...',fontSize:'18px',color:'#...'}).setOrigin(0.5).setDepth(15)` then tween y:y-40,alpha:0. Need no external font.
- Wave banner: `this.add.text(W/2,H/2,...).setOrigin(0.5).setDepth(20).setAlpha(0).setScale(.8); tween alpha 1 etc then yoyo? Simpler:
```
const banner=...
this.tweens.add({targets:banner,alpha:1,scale:1,duration:250,yoyo:true,hold:650,onComplete:()=>banner.destroy()});
```
Need Phaser tween `hold` property, yes maybe. Could avoid hold with delayedCall:
```
banner.setAlpha(0);
this.tweens.add({targets:banner,alpha:1,scale:1,duration:250,onComplete:()=>{
 this.tweens.add({targets:banner,alpha:0,duration:450,delay:600,onComplete:()=>banner.destroy()});
}});
```
Works. Need if scene restarts before tweens complete, objects destroyed. fine.
- `this.time.delayedCall(ms, callback, [], this)` works. If gameOver, check.

Potential issue `this.physics.pause()` inside `endGame` stops physics, but tweens/timers still run. Need "stop gameplay" includes no movement/firing/alien advance. With physics paused, bodies won't move. Update still runs but early return:
```
update(time,delta) {
 if (this.gameOver) { this.player.setVelocity(0,0); return; }
 ...
}
```
Need clear aim line? Could leave. Need maybe hide reticle on gameover? Not important. Gameover overlay covers. Need set `this.input.keyboard.enabled=false`? Could, but restart with new scene would need re-enable. Better not; update early return. Need perhaps `this.input.activePointer.isDown` from restart click could fire after restart; okay. Need wave delayed calls check gameOver. Good.
- Need contact overlap callback only if physics running; paused after game over. fine.

Need ensure wave clear detection doesn't trigger immediately when all aliens killed before transition; update sets `waveTransition=true`. Good.
- Need `clearWave()` increments wave, updates HUD, banner, awards maybe bonus? Not required. Could award wave clear bonus? Points for kills required; extra bonus okay. Keep no bonus maybe.
- Need spawn wave harder via count or speed. count = 5 + wave, speed=72+10*(wave-1). wave 1: 6 aliens, 72. wave 2: 7, 82. Need HP maybe `1 + Math.floor((wave - 1) / 3)` so wave 4 harder HP 2. Need perhaps alien scale/tint for higher waves. Could tint from palette by wave, e.g. `alien.setTint(0x...)`; but hit flash uses clearTint, losing tint. Could skip. Use `alien.wave=wave`. Need speed increase. Need count increase. Good.
- Need score per kill = `100 + (wave-1)*25`. Score HUD. Need floating `+100`. Could use score pad. Fine.
- Need player health 100, contact damage 14 per 650ms. Need maybe aliens persist after contact and keep damaging; okay. Player can shoot them. Need knockback alien 35 px to avoid overlap every frame. Need global cooldown, so contact damage at most ~22/sec. Player can survive ~4.5 sec if swarmed. Fine.
- Need player invulnerability flash only once per contact. Use `this.player.setTintFill(0xff5470); this.time.delayedCall(100, ...);`. Need if gameOver, `clearTint` still okay. Could set tween alpha yoyo: `this.tweens.add({targets:this.player,alpha:0.35,duration:80,yoyo:true,repeat:2})`. But alpha might remain if game over; set alpha=1 in endGame. Need simpler tint.

- Need maybe bullet hit feedback via hit flash and particles and score. Need visible feedback. Good.
- Need shots travel toward pointer: use aimPoint from pointer event. Need crosshair + aim line. Need bullet velocity angle from player to aimPoint. Need test by aiming at an alien and hitting it. Need spawn positions maybe deterministic ring; crosshair at click coordinate. We can perhaps add hidden debug button to align target? But we can choose an alien position from screenshot/telemetry and click there. Good.

Need maybe ensure first wave positions are deterministic and known. We can set spawn ring angles fixed:
```
const angle = (i / count) * Math.PI * 2 - Math.PI/2 + (this.wave*0.23);
const distance = 260 + (i % 3)*35;
let x = player.x+cos(angle)*distance;
let y = player.y+sin(angle)*distance;
x = clamp(x, ARENA.left+35, ARENA.right-35);
y = clamp(y, ARENA.top+35, ARENA.bottom-35);
```
At player start (600,430), arena top 96 bottom 744, x bounds 32-1168. First i=0 angle=-π/2+0.23 ≈ -1.34, x=600+61=661,y=430-254=176. i=1 angle=-0.29, x=600+280=880,y=430-84=346. i=2 angle=0.76, x=600+238=838,y=430+203=633. i=3 angle=1.80, x=600-72=528,y=430+284=714. i=4 angle=2.85, x=600-286=314,y=430+85=515. i=5 angle=3.90, x=600-214=386,y=430-203=227. All within. Great. Need first alien at (661,176) etc. Spawning scale tween from 0.25 to 1 over 300ms. Need active immediately. Need show maybe spawn ring.
  - Could add slight random jitter ±15 to avoid exact symmetry, but for testing deterministic better no random. Could use wave angle offset. Need no randomness needed. Need perhaps first alien directly right of player to make firing test easy. One of positions near (880,346) is slightly up-right. Could set angle 0 for i=0 so alien at (860,430) directly east. Then player initial rotation east; first shot at default aimPoint east would hit it. But requirement aiming toward pointer; test could click at (860,430). Let's set base angle 0, evenly around: i0 east (x=860,y=430), i1 southeast (~730,650), i2 southwest (~430,650), i3 west (~330,430), i4 northwest (~430,210), i5 northeast (~760,210). This is aesthetically distributed and gives an alien directly right. Use `angle = (i/count)*TAU + (wave-1)*0.18`. Distance 270 + (i%2)*30 maybe. First:
i0 x=870,y=430
i1 angle 60°, dist 300 x=750,y=690
i2 120°, dist270 x=465,y=664
i3 180°,dist300 x=300,y=430
i4 240°,dist270 x=465,y=196
i5 300°,dist300 x=750,y=170
all inside. Great. Could target first at (870,430). Need perhaps screenshot at 1200x800 canvas; HUD top 84, controls bottom ~70; aliens y=690 may be behind controls but still partially visible. Controls bottom-left only; telemetry bottom-right maybe. Fine. Set arena bottom 744. Controls panel bottom 16 height ~65 covers y 720-784, outside arena mostly. Good.

Need maybe spawn ring indicator: `this.add.circle(x,y,28,0x52ff8f,0.08)` with stroke and tween scale/alpha. That's procedural. Need perhaps alien scale tween. Good.

Need first wave aliens can be seen. Need maybe add labels above aliens with hp? no.

Need initial player at (600,420) maybe centered in arena vertical from 96 to 744 => center 420. Use 420. Then ring positions as above. Good. Let's set `PLAYER_START = {x:600,y:420}`. HUD top 84 and controls bottom 18; arena top 96 bottom 744. Player at 420. Good.

Need maybe motion frames to verify aliens advance: screenshot at t=0 and t=2s; positions should shift toward player. With 72 px/s, 144 px in 2 sec; visible. Need first wave ring 270 px away, so contact ~3.75s. Browser `motion` might sample frames over e.g. 1 sec. Good. Need perhaps after 3 sec they contact and damage player; that's okay. Need reload initial health etc.

Need game over perhaps testing can be accelerated by allowing aliens to swarm. But brief pass through representative checks in task, maybe no need game over verification? Required behavior includes game over/restart. We should test if time. Could add a hidden test shortcut? We can use key `G` to force damage? Not required but could implement debug key to trigger game over for verification; however that would be an extra accessible behavior maybe not harmful but weird. Could use repeated contact by not shooting and waiting ~5-10 secs. Browser `motion` maybe can wait. Need perhaps browser tool can't wait arbitrary seconds except `motion` frames. Could use clicks and keys. We can test game over by letting aliens contact for ~8 sec and screenshot. But tool call timeout maybe. We can call `browser` motion maybe returns frames over 1s. Need perhaps multiple screenshots, each call takes time. Could avoid gameover test due remaining time but required functionality should be implemented robustly. Need maybe expose a global restart handler and inspect. We can test via console? no. Could add a `data-test` button? Not needed.

Could add a visible "RESTART" button in game-over overlay and a hidden keyboard R shortcut to restart; requirement only restart button. Need maybe `R` key restarts even during game over. Good. Need perhaps pressing R during normal play shouldn't restart. Add in input keyboard:
```
this.input.keyboard.on('keydown-R', () => { if (this.gameOver) this.restartGame();});
```
Need restart via button and R. Not necessary but helpful. Need ensure global restart handler doesn't use scene methods after destroyed. Fine.

Need maybe use transparent HUD and controls; Phaser canvas cursor none. Need custom reticle default east. Need pointer events on HUD none. Need gameover overlay pointer events auto. Need button pointer events auto. Need `#game-over` hidden so no interception.

Need maybe use `pointer-events:none` on `.hud` and `#controls`, but #telemetry too. Good.
Need maybe `#game-over` should be `display:none`, when shown `display:flex`. Need overlay's backdrop intercept. Need button with cursor pointer. Need `user-select:none`.
Need ensure no external font URLs. Use `font-family: "Courier New", ui-monospace, monospace`. Good.
Need maybe CSS `letter-spacing` etc. Fine.

Need perhaps use Phaser text with `fontFamily:'Courier New'` no external. Fine.

Need perhaps set `document.getElementById('game-over').classList.remove('show')` in create. Need final score etc. Need update HUD. Need set body data state. Fine.

Need maybe `window.__shooter` exist before restart listener. Define early:
```
const shooter = { scene:null, game:null, snapshot:()=>..., restart:()=>...};
window.__shooter=shooter;
```
But `restart` needs scene. Use function. Need game variable declared `let game;` and assign. Call restart handler after game created perhaps:
```
function restartMission() {
 document...remove('show');
 const scene = shooter.scene;
 if (scene && scene.scene) { scene.physics.resume(); scene.scene.restart(); }
}
```
Need if scene has been destroyed? game-over scene still alive. Fine.
Need perhaps call `game.input.reset()`? not needed.
Need set `shooter.restart=restartMission`.
Need attach button listener. Good.

Potential issue when `scene.restart()` is called, Phaser's Scene Manager might not process because physics world paused? Calling `scene.physics.resume()` first. Good.
Need maybe remove focus from restart button so WASD key events go to window. Phaser keyboard listens to window by default, so fine. Could call `e.currentTarget.blur()`.
Need perhaps browser `key` events while focus on button after restart would still trigger button if space/enter, not WASD. Fine.

Need debug telemetry:
```
updateHud() {
...
ui.wave.textContent = String(this.wave).padStart(2,'0');
}
updateTelemetry(time) { if(time - lastTelemetry < 120) return; 
 const activeAliens = this.aliens.countActive(true);
 const activeBullets=...
 ui.telemetry.textContent = `PX ${Math.round(player.x)} PY ${Math.round(player.y)} · CONTACTS ${...} · ROUNDS ${...} · AIM ${Math.round(Phaser.Math.RadToDeg(this.aimAngle))}°`;
 const snap = this.snapshot();
 document.getElementById('game-shell').dataset.state = JSON.stringify(snap);
}
```
Need body data maybe not too long. Could set attribute with compact state. Use JSON ~ few hundred chars. Fine. Need maybe `countActive(true)` works on Arcade Group. yes. Need active bullets group count. Fine.
Need perhaps update telemetry even when gameOver; call before early return? We can call at top of update after gameOver check? Actually need show gameover state too. Could call `this.updateTelemetry(time)` in both branches; but snapshot uses player etc. Let's structure:
```
update(time,delta){
 if (time > this.nextTelemetry) { this.updateTelemetry(); this.nextTelemetry=time+100; }
 if (this.gameOver){ this.player.setVelocity(0,0); return; }
 ...
}
```
So telemetry still updates. Good.
Need on initial create call `updateTelemetry(0)` maybe. Need set `nextTelemetry=0`. Good.
Need perhaps player rotation updates after movement:
```
this.aimAngle = Angle.Between(player.x,player.y,aimPoint.x,aimPoint.y);
player.setRotation(this.aimAngle);
```
Need if aimPoint exactly player's position, angle 0 fallback. Use if distance < 1 then keep previous. Fine.
Need crosshair follow aimPoint.
Need draw aim line:
```
this.aimLine.clear();
this.aimLine.lineStyle(1,0x58eaff,0.2);
this.aimLine.lineBetween(player.x,player.y,aimPoint.x,aimPoint.y);
```
Need maybe clip to arena? no.
Need reticle depth 25, maybe setBlendMode(ADD). fine.

Need input pointermove set aim:
```
setAimFromPointer(pointer) {
 if (!pointer) return;
 const x=Phaser.Math.Clamp(pointer.x,ARENA.left+10,ARENA.right-10);
 const y=...
 this.aimPoint.set(x,y);
}
```
Should aim toward mouse pointer; clamping to arena could deviate if pointer in HUD, but HUD overlays top; perhaps better not clamp, use raw pointer.x/y. Need reticle could be behind HUD but okay. Use raw.
Need maybe pointer coordinates from event when canvas is CSS scaled; Phaser normalizes. Good.
Need pointerdown immediate fire:
```
this.input.on('pointerdown', pointer => {
 if (gameOver) return;
 this.setAimFromPointer(pointer);
 if (pointer.button === 0 || pointer.leftButtonDown()) this.fireBullet(this.time.now);
});
```
Need `pointer.button` maybe 0 on left. Need `pointer.leftButtonDown()` may require method; use safe:
```
const isLeft = pointer.button === 0 || (typeof pointer.leftButtonDown==='function' && pointer.leftButtonDown());
```
Need also allow touch (button maybe 0). Good.
Need in update continuous fire:
```
const isDown = pointer.isDown && (pointer.button === 0 || pointer.leftButtonDown());
if (isDown && time>=nextFire) fireBullet(time);
```
Need after pointerup, pointer.button may remain 0 but isDown false. Fine.
Need perhaps pointer.leftButtonDown() on activePointer when pointer is down but button value 0. okay.
Need set `this.input.mouse.disableContextMenu()` if method exists:
```
if (this.input.mouse && this.input.mouse.disableContextMenu) this.input.mouse.disableContextMenu();
```
Need keyboard:
```
this.keys = this.input.keyboard.addKeys({w:Phaser.Input.Keyboard.KeyCodes.W,...});
this.keyPulse={w:0,...};
this.input.keyboard.on('keydown', e=> {
 const key=(e.key||'').toLowerCase();
 if (key in this.keyPulse) this.keyPulse[key]=this.time.now+160;
 if (key==='r' && this.gameOver) restartMission();
});
```
Need addCapture:
```
this.input.keyboard.addCapture([Phaser.Input.Keyboard.KeyCodes.W,...]);
```
Maybe `addCapture` accepts array of keycodes or strings. Use `[ 'W','A','S','D','R' ]`? Phaser docs say `addCapture(keycode)` string or array. Could use numbers. Need avoid API issue; simply omit, body overflow hidden so no scroll. Phaser addKeys captures by default maybe. `addKeys` has `enableCapture=true` default. Good. Could call `this.input.keyboard.addCapture('W,A,S,D,R')`? Might be okay but unnecessary.
Need arrow maybe not needed.
Need movement pulse values:
```
let dx=0,dy=0;
if (keys.a.isDown || time<keyPulse.a) dx--;
...
if(dx||dy){ const len=Math.hypot(dx,dy); player.setVelocity(dx/len*280,dy/len*280); } else player.setVelocity(0,0);
```
Need use `Math.hypot` supported. Fine.
Need maybe pulse from initial event before `this.time.now` set? events registered in create after time plugin; fine.
Need maybe key tool sends uppercase `"D"`; `toLowerCase` handles.
Need perhaps key event from Phaser has `key` property like `"d"`; yes.
Need perhaps key tool sends `"ArrowRight"`; not needed. Could support arrow keys too:
```
const keyMap = {arrowup:'w',...}
```
But controls say WASD. Could include arrow support as bonus.
Need maybe key event from Playwright `key` action with text `"d"` gets key `"d"`. Fine.

Need perhaps `pointer.button` on pointermove could be -1; pointerdown call still sets aim. Good.
Need pointerup over restart overlay doesn't matter.

Need bullets update:
```
for (const bullet of this.bullets.getChildren().slice()) {
 if (!bullet.active) continue;
 if (time - bullet.bornAt > 1500 || bullet.x<ARENA.left-20 ... ) { bullet.destroy(); }
}
```
Need if bullet destroyed by hit callback, group children array changes; copy via `slice()`. Good.
Need aliens update similarly:
```
for (const alien of this.aliens.getChildren().slice()) {...}
```
Need group count active check after update maybe:
```
if (!waveTransition && this.aliens.countActive(true)===0) clearWave();
```
Need ensure first wave spawn scale tween sets active true. yes.
Need if all aliens killed by bullet in overlap callback during physics step before update, count 0. clearWave triggers. Good.
Need perhaps physics overlap callback can run after update? Phaser runs scene update then physics world step? In Phaser 3, preupdate updates physics, then scene update, then postupdate. Actually Arcade physics world update may occur before scene.update? Need not worry; eventually count check next frame. Good.
Need waveTransition timer may call spawnWave after game has restarted; old timer destroyed on scene shutdown. Good.

Need contact callback check time:
```
const now = this.time.now;
if (now < this.nextPlayerHit) return;
this.nextPlayerHit = now + 650;
...
```
Need `this.time.now` maybe not updated on callback? Yes.
Need on gameOver, maybe `this.physics.pause()` called from overlap callback; could cause issues iterating. To be safe:
```
if (health<=0) this.time.delayedCall(0,()=>this.endGame());
```
But need stop immediately. Setting gameOver=true immediately in damagePlayer, update returns. Physics still moves bodies for one frame maybe. Could call `this.physics.pause()` inside a delayed call. Let's implement `damagePlayer` sets health and if zero calls `endGame()`, and endGame calls `this.physics.pause()`. It should be fine. Phaser physics pause likely just toggles `isPaused`. Need no iteration issue. Need set all velocities to zero explicitly:
```
this.player.setVelocity(0,0);
for alien of active: alien.setVelocity(0,0);
for bullet of active: bullet.setVelocity(0,0);
```
Then `this.physics.pause()`. Good.
Need overlay perhaps show final values. Need update HUD. Need reticle hidden? set visible false. Need aimLine clear. Need wave banner maybe. Fine.
Need `gameOver` overlay `show`. Need perhaps pointer cursor reset? not needed.
Need restart create `physics.resume()` and hide overlay, set reticle etc. Good.

Need game-over state with Restart. Button text "RESTART". Need perhaps `R - RESTART` as hint. Good.
Need restart restores health, score, first wave. create resets and hides overlay. Need `this.score=0;` etc. Need first wave spawns. Good.

Need maybe clear all old DOM final values on create? not necessary.
Need maybe reset `nextPlayerHit` etc. Good.
Need `this.nextFire=0; this.nextPlayerHit=0; this.nextTelemetry=0; this.fireCooldown=150;`.
Need waveTransition false.
Need `this.wave=1`.
Need spawnWave(1). Need wave banner maybe "WAVE 1 // CONTACT". Fine.

Need potential bug: `window.__shooter.scene = this` in create; restart creates new scene instance? Actually same instance reused; fine. Need snapshot method use current fields. Good.
Need `restartMission` referencing `shooter.scene` and `shooter.scene.physics.resume()`; if old scene paused but still alive. Good.
Need perhaps `shooter.scene.scene.restart()` from DOM event while Phaser game loop busy; okay. Need maybe call `game.scene.resume('GameScene')`? scene isn't paused, only physics. fine.

Need perhaps use `this.events.once('shutdown', () => { ... })` to remove keyboard listeners? Scene restart reuses plugin and listeners might accumulate if added via `this.input.keyboard.on` each create. Wait! If we register `this.input.keyboard.on('keydown',...)` in create and don't remove it, on scene.restart, the keyboard plugin might be shut down and listeners cleared? Phaser Scene's input plugin is per scene and gets shutdown; likely listeners are removed. But to be safe use `this.events.once(Phaser.Scenes.Events.SHUTDOWN, () => { this.input.keyboard.off('keydown', handler); ... })`. Could implement. Need pointer listeners also. Scene input plugin should clear events on shutdown, but safe. Need avoid complexity. Could use methods bound and store, then cleanup:
```
this._onKeyDown = ...
this.input.keyboard.on('keydown', this._onKeyDown);
this.events.once('shutdown', () => {
 this.input.keyboard.off('keydown', this._onKeyDown);
 document... maybe.
});
```
Pointer listeners added via `this.input.on` also cleared on shutdown likely. Fine. Could call `this.input.removeAllListeners()` on shutdown? Might be too broad. Probably unnecessary. Phaser Scene input plugin likely calls `removeAllListeners()` on shutdown? Let's check. It's okay.

Need perhaps DOM restart listener attached once outside, not per scene. Good.

Need maybe wave banner and other Phaser text generated from system font. Fine.

Need perhaps use `Phaser.Math.RadToDeg` exists. yes. But to avoid issue, use `(angle*180/Math.PI)`. Fine.

Need need exact local script tag `<script src="phaser.min.js"></script>`, no `defer`. Good.

Need perhaps generate background texture with random stars using a deterministic PRNG; avoid `Math.random` to get consistent. Implement:
```
let seed=918273; const rnd=()=>{seed=(seed*1664525+1013904223)>>>0;return seed/4294967296;};
for (let i=0;i<170;i++){
 const x=rnd()*W, y=rnd()*H, r=0.5+rnd()*1.4;
 g.fillStyle(rnd()>0.7?0x60eaff:0x8ea7c8, 0.25+rnd()*0.45);
 g.fillCircle(x,y,r);
}
```
Need drawing grid lines: `g.lineStyle(1,0x183b58,0.35); for... g.lineBetween`. Fine.
Need draw arena border perhaps `g.lineStyle(2,0x22d3ee,0.5); g.strokeRect(...)`. `strokeRect` exists. Draw corner brackets with `lineBetween`. Fine.
Need draw central circle perhaps. Fine.

Need perhaps background texture actually includes border beneath HUD; HUD overlays top. Good.

Need perhaps draw player shadow? Could add a small `this.playerGlow = this.add.circle(..., 30,0x00d9ff,0.08)` followed update to player position. But not necessary. Could add to enhance visual. Need no external. Let's do perhaps a glow behind player:
```
this.playerGlow = this.add.circle(player.x,player.y,30,0x19d9ff,0.08).setDepth(1).setBlendMode(ADD);
```
update position. Need player depth 5. Alien depth 4, bullets 6, effects 10. Good.
Need maybe thruster particles while moving; could add simple small circle at rear based on angle with alpha tween every 100ms. But more complexity. Could create using `createBurst` with 1-2 particles. Need not.

Need maybe health bar CSS transition. Use `transition:width .15s linear, background...`. Good.

Need maybe wave transition banner uses Phaser text and CSS overlay not interfering. Fine.

Need maybe score popup on kill. Fine.

Need perhaps first wave aliens have health 1 so a shot gives clear hit feedback + death. Need hit flash on each hit and explosion. Good.
Need perhaps alien damage hit feedback visible even if bullet doesn't kill? First wave kills in one hit, so explosion visible. At later waves hp>1, flash. Fine.

Need perhaps player shots damage aliens: `alien.hp -= bullet.damage || 1`. Good.
Need contact damages player: health decrement. Good.
Need score points for kills: score increment. Good.
Need wave clear/harder: count and speed. Good.
Need gameover/restart. Good.
Need display controls. Good.
Need no external assets. Good.
Need procedural graphics via generated textures and shape objects. Good.

Need perhaps test that `index.html` uses no external resources/CDN. Could grep for http, url( maybe no. Need no audio. Fine.

Let's write file. Need careful syntax. We'll use write with full content. Need maybe 600 lines? Keep manageable ~500 lines. Let's draft meticulously.

Potential Phaser details:
- `this.add.circle(x, y, radius, fillColor, fillAlpha)` is available in Phaser 3.80. Generated via Shape. Good.
- `setStrokeStyle(lineWidth, color, alpha)` on Shape works.
- `setBlendMode(Phaser.BlendModes.ADD)` on Shape/Sprite works.
- `Phaser.Math.Clamp` exists.
- `this.make.graphics({ x: 0, y: 0, add: false })` can pass `add:false`? In Phaser 3, GameObjectCreator.graphics(config, addToScene) where config includes `{ x:0,y:0, add:false }` perhaps yes. Common pattern: `this.make.graphics({x:0,y:0,add:false})`. Good. Could use `this.add.graphics()` then `generateTexture` and `destroy()`; simpler and definitely works. But added graphics briefly visible before destroy within same frame not rendered. Use `this.add.graphics()`:
```
const g=this.add.graphics();
...
g.generateTexture(...);
g.destroy();
```
This creates on display list but no render until frame end, so fine. Use that to avoid config uncertainties. Need `generateTexture` works on graphics. Yes. For background, add image after destroy. Good.
- `g.strokeRect(x,y,w,h)` works.
- `g.strokeCircle(x,y,r)` works.
- `g.lineBetween(x1,y1,x2,y2)` works.
- `g.fillEllipse(x,y,width,height)` I think works. Could avoid by `fillCircle` and `fillRect`. Need alien body shape could be circle. Use `fillCircle(22,22,16)` plus `fillCircle(22,22,12)` etc. No `fillEllipse` needed.
- `g.fillRoundedRect` maybe works, but avoid; use `fillRect` and circles.
- `g.strokeTriangle` perhaps works, but use path. Need `beginPath` etc. Let's use path for player outline:
```
p.lineStyle(2,0xd7fbff,1);
p.beginPath();
p.moveTo(4,6);
p.lineTo(52,24);
p.lineTo(4,42);
p.lineTo(11,24);
p.closePath();
p.fillPath();
p.strokePath();
```
Need note fillStyle should be set before `fillPath`. yes.
- Need draw wings maybe triangle shape after. Fine.
- Alien legs using lineStyle then lineBetween. Need draw before body so behind. Good.
- Bullet with `fillCircle(5,6,5)` etc. Fine.
- Reticle using `strokeCircle`, `lineBetween`. Fine.

Need perhaps generated texture keys persist across scene restarts. Calling generateTexture with same key when key already exists may throw warning or overwrite? Phaser TextureManager `addCanvas` perhaps key exists, generates but might fail or warn. On scene restart, textures persist globally in game; calling `generateTexture('arena-bg',...)` again with same key might error "Texture key already in use" or overwrite? Need handle. Important. In Phaser, `TextureManager.generate` may remove existing? Let's check. Graphics.generateTexture calls `this.scene.sys.textures.generate(key, ...)`; if key exists, `TextureManager.generate` likely returns null or warns `Texture key already exists`. We need avoid duplicate textures on restart. Could check `if (!this.textures.exists('arena-bg')) { ... }` around generation. Then on restart skip. Need still add background image every create. Good. Use:
```
makeTextures() {
 if (!this.textures.exists('arena-bg')) { ... generate... }
 ...
 this.add.image(...);
}
```
Could wrap each key separately, or one `if (!exists('player'))` around all since all generated together first time; on restart all exist. Need if some missing not issue. Use one outer:
```
if (!this.textures.exists('arena-bg')) { generate all }
```
After first create all keys exist. On restart skip. Need add background image using `'arena-bg'`. Good. Need if key conflict unlikely. Fine.
- Need `this.textures.exists` method. yes.
- Need generated textures persisted after scene restart, yes.

Need maybe reset camera effects on restart: `this.cameras.main.resetFX()` perhaps. Not needed.
Need maybe tint from previous player cleared on restart; new sprite. fine.
Need DOM overlay hidden. fine.
Need perhaps physics world pause carries across restart? Call `this.physics.resume()` early. Good.
Need perhaps old `window.__shooter.scene` reference stays, but create sets new same instance. fine.

Need maybe on gameover `ui.gameOver.classList.add('show')`, on create remove. Good.
Need maybe `body.dataset.state` reset. fine.

Need exact string for Phaser config:
```
const config = {
 type: Phaser.AUTO,
 parent: 'game',
 width: GAME_W,
 height: GAME_H,
 backgroundColor: '#050a14',
 scale: { mode: Phaser.Scale.FIT, autoCenter: Phaser.Scale.CENTER_BOTH, width: GAME_W, height: GAME_H },
 physics: { default: 'arcade', arcade: { gravity: {y:0}, debug:false } },
 input: { mouse: { preventDefaultDown: true, preventDefaultUp: true, preventDefaultMove: true } },
 scene: [GameScene]
};
```
Input config may not need; `preventDefaultDown` perhaps okay. Could avoid extra potential issues. Just `physics` and `scale`.
Need `render: { antialias:true, roundPixels:false }`. Fine.
Need perhaps Canvas fallback. `Phaser.AUTO` works.
Need maybe `fps: { target:60 }` not needed.

Need maybe `parent:'game'` game canvas inserted into `#game`, which has width/height 100%. Phaser scale FIT uses parent size? In Phaser, scale FIT computes canvas CSS based on game size and parent bounds. Since parent is 100vw/100vh, good. autoCenter centers canvas. Need `#game` position absolute inset 0. Need perhaps `canvas { width:100%; height:100% }`? Phaser sets style. Do not override because FIT needs proper scaling. Could set `display:block`. Good.
Need maybe if viewport 1200x800 exactly, canvas 1200x800. Great.

Need maybe UI overlay aligns with canvas if aspect ratio differs; here likely exact. For general responsive, HUD fixed to viewport not canvas, but acceptable. Need game coordinates map to canvas. Browser tool coordinate mapping still via Phaser pointer plugin. Fine.

Need perhaps canvas `cursor:none` hides pointer over canvas. But when overlay shown, button cursor pointer. Good.

Need maybe use `aria` attributes. Not necessary.

Need perhaps no network calls from Phaser itself, e.g. default loader baseURL? No assets loaded, so no requests. Fine.

Need maybe add title of controls etc. Good.

Let's write.

Need run browser inspect initial output and console. Need call browser reload maybe first. Let's do reload and inspect perhaps parallel? `reload` then inspect sequential likely. Use browser reload first.

Initial output good. Phaser console only startup warnings, no errors. Need inspect maybe data-state not shown but DOM text shows telemetry. Need test movement, aiming, firing. Need use browser tool actions. First perhaps inspect after a short pass with key D and click at an alien. Need understand `key` action. Could call `browser` action "key" with text "d" then inspect. Need likely triggers keydown/up. Do that.

Movement works (PX 600->609; aliens moved closer over ~1 sec). Need test WASD other directions maybe a couple. Need aiming: click at specific point e.g. (600,200) should reticle move and player rotate toward up; fire bullet. Need check bullet velocity direction. We can use browser click and inspect immediately; perhaps shot may already hit? Need likely click at (600,200) and telemetry may show AIM -90°, rounds perhaps 1 if immediate inspect. Need perhaps browser "click" returns screenshot after event; by then update maybe a frame. Let's try. Need use coordinates 600,200 (toward upper middle, there may be aliens near x=700,y=250). Could target an alien directly to produce hit. Current alien positions after ~1 sec: screenshot shows right alien around (774,417), upper-right (702,240), upper-left (514,265), left (395,417), lower-left (514,570), lower-right (697,590). Could aim at upper-right alien (702,240) from player (609,420), angle ~-63°. Click at 702,240. Bullet from muzzle toward alien, likely hit in ~0.3 sec. Need inspect quickly perhaps screenshot after event includes bullet/hit feedback. Browser click likely screenshot after ~?Maybe enough to see muzzle flash/bullet. Need maybe use `motion` after click? Hard because pointerdown event only during tool call, bullet persists ~1.6 sec; motion can capture frames. Could use `browser.click` then `browser.motion` perhaps. Let's first click at (702,240) and inspect.

Oops game over very quickly between tool calls! Why? The browser actions seemingly take a lot of wall time despite "Frame 1,+0ms" maybe tool screenshot captures after many seconds; aliens advanced and damaged player 8 times, game over. Need use browser movement/click within single tool? The `drag` action can combine pointer down/move/up and perhaps pass time, but game over occurred before click due long idle. Need understand timing. Actually between first reload and key D screenshot, aliens moved from radius ~270 to ~190 (80 px, ~1.1 sec). Between key D and click screenshot, maybe another ~5 seconds due tool latency, aliens reached and killed. So need maybe reduce alien speed and contact damage / increase player health to allow longer testing and playability. Game over in ~6 seconds if idle is too fast; gameplay should be playable. Need adjust enemies to slower speed and/or lower contact DPS, perhaps spawn further away. Need still "aliens advance toward player" visible. Could set speed first wave 45 px/s, contact damage 10 per 900ms, giving ~6 sec to contact + ~9 sec to death. Tool calls have ~5-6 sec gap, so still maybe game over before click. Could also give health 100 and damage 8 per 1000ms => 12.5 sec. Need maybe spawn at radius 300 and speed 45 => 6.7 sec to contact; total ~19 sec. Better. But requirement "first wave of aliens that advance toward the player" can be slower. Need likely better playability. Could also make aliens not all converge exactly; but okay. Need maybe avoid game over while idle verification. Could add an "invulnerability until first shot" or "grace period" (first 8 seconds) to allow testing. But requirement contact damages player; could have initial 2s grace only. Need not circumvent. Better adjust difficulty.

Need also test restart after game over. We can click Restart at (600,487), then check initial values. That will verify restart. Need perhaps implement changes and reload first. But before modifying, we can test restart now, maybe exact. Click Restart.

Restart works. Need make game less punishing and maybe use faster tool sequence. Need perhaps use `browser` action `drag` to perform click and maybe motion in same call? `drag` from one point to another likely pointerdown at x,y then pointermove to toX,toY and pointerup; could fire at start and perhaps hold for a while. Could use `drag` from (600,420) to (870,420). That simulates left button down and move; at starting pointer coordinate (600,420) aim is same as player, bullet fire with angle fallback, not good. Could drag from target coordinate to nearby target e.g. from (870,420) to (870,430), pointerdown at target, move 10 px; fires along target. Need click at target easier. But tool calls take enough time from reload that aliens may already be near player. Could reload and then immediately click perhaps sequential tool calls with little wall time? We can call reload and click in parallel? Tools can be parallel but browser actions on same state not independent; no. Could call `browser` with action `drag` after reload; likely perhaps 5s gap. Need use `motion` maybe can capture immediate frames during single action, but no input. We need adjust difficulty to allow at least ~20 sec idle. Then can test reliably.

Let's estimate tool wall time: first reload to key D about maybe 2 sec (aliens moved 80 px at 72/s =1.1s, plus screenshot processing). Key D to click maybe maybe 6+ sec because health dropped from 100 to 0 with 14 per 0.65 sec = 8 hits ~5.2 sec, plus initial contact ~3 sec =8.2 sec. So total between actions maybe 8-9 sec? Could be due model reasoning time too—the tool call itself has human/AI latency. Need game survive at least ~20-30 sec idle. Could implement a contact damage cooldown 1200ms and damage 8, needing 13 hits*1.2=15.6 sec, plus spawn distance 270 / speed 45 =6 sec => 22 sec. That should allow several tool calls. But a playable shooter with enemies reaching in 6 sec and death in 22 sec is reasonable if player can shoot. Need perhaps wave harder by speed increments 9. Need not make too easy. Could also make aliens bounce away after contact by 70px, so they need time to re-approach; global cooldown still. Push back 28 currently insufficient. Increase push to 70 px and use global 900ms; aliens at 45px/s take 1.5 sec to return, so contact damage every 1.5 sec. Then death ~12 hits * 1.5 =18s plus 6s =24s. Good. Need perhaps player can escape. Fine.
- speed first wave 48 (instead of 72), increment 9.
- distance maybe 300 + (i%2)*25 (instead of 270/300), giving ~6.25 sec.
- contact damage 10 (10 hits), cooldown 850, pushback 65.
- health 100. death after first contact ~6.2s + ~10*max(0.85,1.3)=19.2s. Good.
- Need aliens advance visibly: 48 px/s gives 48 px between tool calls maybe enough. Could use 55 px/s and distance 320 =5.8s; death ~19s. Fine.
- Harder wave: speed=50+wave... need wave1 50. Let's choose `speed = 48 + (wave-1)*10`, count 5+wave. Wave2 58. Fine. Maybe too slow for gameplay but okay. Could use 58 first + spawn 330 =5.7s; still. Speed 58 gives more obvious advance. Contact damage 8 per 900ms and pushback 75 => 13 hits, re-approach ~1.3s => 16.9+5.7=22.6s. Good. Let's choose speed=52 first, distance 300, damage=8, cooldown=900, push=75. Death ~5.8+13*1.44=24.5s. Great. Harder speed increment 10, count increment 1. Need maybe wave 3 score etc. Fine.

Need perhaps make first wave hit test easier by adding an alien directly east at distance 300: (900,420). Initial screenshot would show; click at (900,420) from player (600,420) and bullet hits in ~0.4s. Tool screenshot after click may be delayed ~? Could show score 00100 and contacts 05. Need aim test: telemetry AIM 0° stays same, so need click upward to check aim. We can choose click at alien upper-right (maybe x=750,y=160) and check AIM negative angle; bullet hit maybe. Need use a single `click` at target after reload; tool call delay from reload to click maybe ~? If we reload then click quickly in next message, AI reasoning can be short. Need perhaps combine two browser calls in one assistant message? Tools can be parallel but sequential state. Could use multi_tool_use.parallel with reload and click—not safe. Could maybe use `browser` action `drag` starting at target after a `reload` call; sequential. Need make first click after reload within ~10s; game survives. Aim pointer set from click, shot fired. Need check telemetry after click. Need perhaps tool screenshot after click occurs ~0ms but DOM telemetry might be from before click? In previous click, gameover overlay DOM but telemetry still old (AIM 0°, PX609) because game over update paused and telemetry from old state. Need HUD update path: `updateTelemetry` called in update before gameOver branch, but after gameover `physics.pause()` doesn't pause scene update; still should update telemetry. Why telemetry showed PX609, AIM0, ROUNDS0 from old? Wait `endGame` called `updateTelemetry(time,true)`, snapshot gameOver true. But DOM telemetry updates with aimAngle (0) and player x609, contacts 6, rounds0. That was from gameover state at contact. So click at (702,240) did not set aim/fire because gameOver already true by time click received. Fine.

Need after clicking at target while alive, telemetry likely update after next frame and show aim degrees. Need maybe click action screenshot after event returns quickly enough. We can call `inspect` immediately after click to read telemetry. Need maybe browser screenshot may show bullet or hit. Use `motion` perhaps. Need think about tool call overhead. Could potentially use direct `browser` action `drag` with `text`? Maybe `drag` includes wait durations? No. `motion` captures frames over some time and returns images; could show bullet traveling. Need call `motion` right after click; perhaps captures 1 sec. Good. Need perhaps use `inspect` after click to read DOM. We'll sequence.

Before modifying, need maybe also consider bug: player rotation and aim line: player's texture arrow points right, rotation angle works. Need bullet generation from aimPoint. Need reticle and aim line. Good.
Need perhaps issue: `alien.setScale(wobble)` in update overwrites spawn scale tween from 0.25 to1 every frame; spawn tween may be fighting update. Initial screenshot after restart showed aliens full size with spawn rings, so tween likely competed; perhaps update set scale to ~1 immediately, so spawn tween not visible. Not critical. But hit tween scaleX/scaleY also overwritten by update each frame, so hit flash scale bounce doesn't show, but tint and particles still visible. Need visible hit feedback via burst and tint. Fine. Could avoid overriding scale by using `alien.setScale(wobble)` only after spawn tween; but not needed. Could set `alien.baseScale` and use tween on `scaleX` only? Actually update sets both every frame. Could modify to preserve hit scale by not updating scale after spawn/hit tweens; use display rotation or alpha wobble instead. We can remove wobble entirely to let spawn and hit scale tweens show. Simpler: remove `const wobble... alien.setScale(wobble);` from update. Aliens still rotate and move. This improves visible hit feedback. Need perhaps spawn scale tween works. Let's do that.
Need perhaps hit tween scaleX/scaleY yoyo back to 1, okay.
Need perhaps `killAlien` calls `alien.destroy()` before `hitBurst`, fine.
Need perhaps `onBulletHit` calls `alien.setTintFill` and tween, then if hp<=0 killAlien immediately destroys alien; so the hit flash tween target destroyed (Phaser tween handles destroyed? could warn). Time delayedCall checks active. Tween on destroyed object may still update but no error maybe. Better if death, skip flash tween? Could restructure:
```
if (alien.hp <=0) { this.killAlien(alien); return; }
alien.setTintFill... tween...
```
Need hit burst first. This avoids tween on destroyed sprite. Let's adjust.
Need maybe killAlien explosion visible. Good.

Need perhaps contact damage pushback due player body overlap; push alien from player by 75. Good.

Need perhaps gameover after idle still possible but slower. Need perhaps add a visible "DANGER" when low health not necessary.

Need maybe wave progression after all aliens killed: spawn scale tweens from 0.25 but active. Need update no longer sets scale, so fine. Need count check after kill. Good.
Need perhaps wave 2 spawn based on player's current position; okay.
Need perhaps bullet fire disabled during wave transition; `fireBullet` checks `waveTransition`. Requirement firing left mouse; disabling for 1.25 sec between waves is okay. But if click during transition no shot; not a problem. Could allow firing even during transition; no aliens anyway. Need maybe if pointer held for next wave, fires. Fine.
Need perhaps `this.waveTransition` remains true if gameOver during delay and restart? scene restart resets false, old timer gone. fine.

Need perhaps `physics.pause()` on gameover and restart via `physics.resume()` works already. Good.

Need maybe initial wave count 6, HUD. Good.
Need perhaps DOM `telemetry` shows `AIM` from `this.aimAngle` updated in update. Need after click to a point, update angle. Good.

Need perhaps test score/kill via initial shot at east alien. We can use click at (900,420) immediately after reload, but if game starts with east alien at (900,420) and all aliens start moving toward player at 52 px/s, by click time maybe it moved 50-100 px, so aiming at original (900,420) still on same line east; bullet travels east and will hit alien wherever along line, as long as no other events. Good. Need click at (900,420) maybe right alien is at x~850 after 1s, bullet still hits. Great. Need perhaps score 00100, contacts 05. This tests shots travel toward pointer (east) but aim 0° is default; not enough to prove pointer-specific aiming. Could click at upper-right alien maybe (750,160), but by click time it advances toward player along line; from player to original spawn still same radial line; bullet will hit it too. Good. Need target coordinate predetermined from initial geometry. With distance 300 and count 6:
i=1 angle 60°, dist 325: x=600+162.5=762.5, y=420+281.5=701.5 (lower-right). i=5 angle 300°,dist325: x=762.5,y=138.5 (upper-right). i=0 east x=900,y=420. i=2 angle120,dist300: x=450,y=680. i=3 west x=300,y=420. i=4 angle240,dist325: x=437.5,y=138.5. Need upper-right target (762,139) but y=139 is near top arena (96) and HUD overlay bottom 84; okay. Click at (762,140) points ~-56° from center. Alien advances along radial line toward player, so shot will hit if fired at exact original point. Its body size 44; bullet direction from muzzle at (600+cos*31,420+sin*31) to (762,140) is radial, so should hit. Need perhaps if alien moved from (762,139) to (720,205) by click time, still on line. Great. So one click can test aiming and hit at non-default angle. Need telemetry after click should show AIM ~-56° and score maybe 00100. Need maybe bullet collision with alien after ~0.4 sec; if tool screenshot immediate, perhaps score not yet updated. Could call `inspect` or screenshot after a short delay; tool call itself gives some delay. Need perhaps use `motion` to capture frames. We can use two steps: click, then inspect. Need perhaps game survives. Good.
Need maybe click at (762,140) crosses HUD? HUD height 84, so no. Good.
Need maybe reticle at target; aim line visible. Need check shot direction via telemetry `AIM -56°`. Need perhaps bullet velocity vector from data-state not shown, but can call browser inspect maybe DOM only; data-state attr not shown. Could perhaps set telemetry to include bullet direction or first bullet vx/vy. But not necessary if screenshot shows bullet along line and hit. Yet requirement verify shots travel toward pointer. Need maybe more direct. We can modify telemetry to include last shot angle and bullet direction. E.g. add `LAST SHOT -56°` and perhaps `VX 385 VY -572`. This would be visible debug line. Could include in telemetry to verify. Need perhaps after click, bullet likely destroyed on hit, so vx not available. Could store `this.lastShot = {angle, vx,vy}` in fireBullet and display. Then telemetry can show `SHOT -56°`. This is useful. But perhaps clutter. Could set `data-shot` attribute on shell with JSON; inspect maybe not show. Could add to telemetry compact string `· SHOT -56°`. Need also aim. It's fine. Could include `SHOT` in status line. Need initial "SHOT --". Need maybe `this.lastShotAngle`. In create set `this.lastShotAngle = null`. In fireBullet set. In updateTelemetry append. This verifies pointer aim direction. Need perhaps browser inspect DOM shows telemetry. Let's add. Need maybe snap includes lastShot. Good.
Need perhaps "ROUND(S)" count can show bullet. Fine.
Need maybe need test firing held down? Could use `drag` perhaps not necessary; click fires one shot. Requirement fire with left mouse button, click suffice. Need maybe aim toward mouse pointer: pointermove maybe test by `drag` from one point to another, but click sets aim too. Need perhaps move mouse without click via `browser` action `drag` with no button? drag uses left down; still sets aim. Could use `browser` action `motion` no. Maybe `drag` from (762,140) to (600,200) would set reticle and bullet start; but click at target enough. Need perhaps test pointermove specifically by action `drag` from one coordinate to another and see AIM changes. Could call `browser.drag` with start at upper-right target and end at lower-left; that holds left button and fires multiple bullets; could kill multiple aliens. But click is simpler. Need maybe use `browser` action `scroll` to move pointer? no. Could use `drag` to set aim to destination. We'll test perhaps after initial click if time.

Need maybe test aliens advance toward player: compare screenshots at reload and after key D; already saw positions shrink. Could telemetry include nearest alien distance? Could add. Not necessary. But maybe after difficulty change, still visible 50px between tool calls. Good.

Need perhaps test projectile hit visible feedback: initial click at upper-right alien should produce score and contact count; screenshot may show explosion if captured quickly. Need perhaps call `motion` immediately after click to capture frames; but motion tool maybe captures frames with no user input over some time. Need learn motion behavior. Could call after click and see output frames. Good.

Need perhaps test wave progression: kill all aliens with repeated clicks; too time-consuming, but could use held fire? Need maybe use a debug shortcut to clear wave? Not required but we should verify wave logic perhaps via code or browser. Could add hidden test hook function `window.__shooter.testClearWave` that kills all aliens; but cannot invoke via browser tool unless console execution available. Could perhaps add a keyboard shortcut `N` to clear wave (debug) but that's extraneous and could be considered cheating. Need not. Task says brief pass through representative checks; wave progression can remain unverified if not accessible. But maybe need ensure code works logically. Could test by shooting all 6 aliens with a drag across directions? Hard. Could use sustained click and drag around player, maybe kill all. But tool actions might be too slow. Could perhaps make a "wave clear" via clicking a hidden debug button? Not needed. Need maybe test game over/restart already had due idle; saw it and restart. Good. Need after changes, gameover may be harder to reach. Could still test via no shooting and enough tool calls, or use keyboard R after gameover. But we already verified restart before changes; changes only difficulty and tween, restart logic unchanged. Need perhaps re-test restart after gameover not necessary, but final report can mention earlier check. Need maybe verify on final file with reloaded initial state. Good.

Need maybe test wave progression by temporarily using browser console? No arbitrary JS tool. Could use `browser` action key with text? Maybe key can send arbitrary JavaScript? no. Could maybe use `type` into a hidden input that we add as a debug field to invoke commands. But not needed, and adding debug command could be questionable. Could perhaps use a URL query parameter to auto-kill aliens for test, but browser reload doesn't allow setting URL. Could encode debug command in keyboard shortcut; e.g. pressing `0` kills all aliens. If we add hidden test shortcut, we can verify wave progression. But user didn't request, and could be seen as extra hidden behavior but harmless. Maybe add `F2` "skip wave" only for development? Could leave it in final app, no one knows. But perhaps violates "playable" not. Better not.

Could make wave progression easier to verify by reducing first wave count to 3, speed slower, and using sustained fire via `drag` to mow them down. But requirement first wave of aliens plural; 6 is good. Could perhaps set count first wave 4 (3+wave) and speed 52. Wave 2 5, speed 62. Then killing all via repeated clicks is easier. But visual arena with 6 aliens is nice. Maybe use 5 first wave (4+wave), wave2 6. Need hit test still. Could do 5 = one at east etc. But not necessary.

Need perhaps use a "fire at pointer" with holding left mouse and moving reticle around using drag, which will send multiple bullets. Might kill all aliens if aimed at each. Could call `drag` from east alien to upper-right etc, but drag only linear path and bullets fire along moving aim; could sweep a radial arc? Starting at one point and ending another, pointer moves linearly across screen, firing every 145ms along directions from player to pointer. Might hit many aliens. But tool call maybe takes ~1 sec; with 145ms cooldown ~7 shots. Could kill all 6 if path sweeps around? Not likely. Could do multiple drags. But wave progression can be left unverified.

Need maybe test score increment by shot; enough.

Let's edit difficulty, remove wobble, add last shot telemetry, hit flash skip on kill. Need be precise. Use edit with multiple entries. Need perhaps maintain smaller oldText. Let's make changes:
1. `this.aimAngle = 0;` add `this.lastShotAngle = null;`
2. spawnWave distance/speed.
3. contact damage/cooldown/push.
4. telemetry display SHOT.
5. snapshot includes lastShotAngle.
6. fireBullet set lastShotAngle.
7. onBulletHit restructure.
8. remove wobble.

Let's do one edit call with multiple disjoint entries.

Need maybe update initial HTML telemetry to include SHOT -- for consistency before JS loads, but JS updates create. Could edit. Not critical. Need maybe lastShotAngle persists across restart? Create resets null. Good. Need maybe `telemetry` initial line "SHOT --"; can edit. Let's do perhaps later with final polish.

Need reload and verify initial state with new difficulty and no errors. Then test click quickly. Need maybe use `browser.reload`, then `browser.click` at upper-right target (762,139). Need aim angle from player (600,420) to (762,139): dx162 dy-281 => atan2=-60.0° roughly (since 162/281=.576, atan=29.9 -> -60.1). Actually spawn angle for i=5 is 300° (-60°), so shot -60°. Good. Need target x=762.5,y=138.5. Click at (763,139). Need top HUD ends 84; okay. Need the alien spawn ring maybe at y139. Great. Need after click, shot travels -60°, should hit. Need maybe alien has moved toward center along radial line by time click. Since start distance 325 at -60°; after 2s at speed52 => x=710.5,y=234.4; still line. Bullet at 690 px/s from muzzle (615.5,393.2) to target; will hit alien in ~(325-31-44)/(690+52) ~0.34s. Tool screenshot after click may be at +0ms per output but likely wait until event settles; perhaps score could update. Need call `inspect` immediately after click to read DOM. But inspect itself may take time; let's do click then inspect. Need perhaps use `motion` right after click to capture frames; but inspect first may show result. Let's reload.

Initial state correct. Need click target quickly. Note screenshot shows upper-right alien at x763,y143, great. Let's click at (763,140).

Great! Aiming works: player rotated -60, reticle at (763,140), aim line, bullet visible traveling toward pointer at -60°, shot telemetry -60°, aliens advanced from initial positions toward center: upper-right alien moved from (763,143) to (729,201) maybe; yes. Need hit feedback. Bullet currently at (644,342) maybe, alien at (729,201), will hit soon. Need call `motion` or inspect to see score/hit. Let's call `motion` perhaps captures animation frames.

Motion frames show score 00100 from first hit, contacts 05, health drops due contact. Need hit burst visible perhaps first frame? Score update happened before motion started likely; first frame score 00100 already. But click screenshot showed bullet in flight, so shots travel toward pointer. Need maybe hit visible feedback from motion frames: green bursts around aliens maybe contact bursts, but we need projectile hit visible feedback. We saw first bullet hit before motion (score 00100) but no direct explosion frame perhaps because tool call gap. Need maybe perform another click at an alien very close to player now (there are 5 aliens clustered), then motion capture explosion. Need game health currently 68%; can survive. Need perhaps click at an alien near player maybe (650,420) or (620,490). Need use screenshot from final motion frame: aliens at around (590,420) and (655,420)? Player at (600,420), actually positions scaled? Screenshot is 1200x800, player around (600,420). Two aliens near (585,420) and (655,420). Health 76% in frame4; DOM says 68% at end. Need click at close alien to get immediate hit and capture feedback with motion. Could click at (655,420) and then call motion; might hit within 0.05 sec and show explosion. Need perhaps pointer aim from player to that point ~0°, shot east, good. But player may be overlapped by alien; bullet muzzle at x631, and alien at x655, hit in 0.02 sec. Need score increase to 200 and contacts 4. Need call click. Need perhaps game still alive. Let's do quick.

Game over before second click due tool latency. Need perhaps contact damage still too fast because all aliens clustered and pushback 75 but global cooldown 900; health went from 68% to 0 between motion and click, maybe 8*? Need at least 9 hits ~8 sec, plausible tool call + reasoning time ~8 sec. Need game survive longer. Could lower damage to 4 or increase cooldown, but then gameplay too forgiving. Yet for verification and playability, perhaps okay: health 100, damage 10 every 1200ms =10 hits ~12 sec; similar. We had 8 every 900ms =9 hits ~8.1 sec. Need ~20 sec. Damage 5 every 1000ms => 20 hits ~20 sec; plus contact time ~6 sec. Good. Could set 5 damage, cooldown 1000ms; health 100. Need "contact with aliens damages player" yes 5% increments visible. Need perhaps wave can still kill an idle player in ~26 sec. Good. Need maybe score/wave progression test can have enough time. Could also set contact damage 6 and cooldown 1100ms =>17 hits*1.1=18.7 sec +6=24.7 sec. Good. Let's choose 6 damage / 1100 cooldown. Pushback 90. Need per hit health values not multiples? 100-6=94 etc. Fine. Need HUD health bar. Good.
Need maybe first contact pushback can shove aliens out of arena and collide world bounds; okay. If multiple aliens overlap, global cooldown means only one damage at a time. Good.
Need perhaps players can ignore swarm for 25 sec; it's okay, still a threat. Need quicker difficulty perhaps not relevant.
Need maybe add "grace period" 4 seconds after spawn before contact damage, but that could be a reasonable invulnerability after wave start; not required. Could set `nextPlayerHit=this.time.now+3000` at create (player spawn protection). But task says contact damages; with grace, still eventually. It would help testing. But perhaps unnecessary with 25s survival. Need maybe after wave transition new wave spawn, contact damage could be immediate; fine.

Need maybe hit feedback capture via a single browser action that includes click and motion? `browser` action `drag` from target to target maybe click+hold and motion frames? No. Could perhaps use `browser` `motion` after a click but gameover overlay may appear if too long; reducing damage helps. Need maybe use `browser` action `drag` from target to another point; this action itself might capture multiple frames? It returns screenshot only, not motion frames perhaps. Could call `motion` right after, with enough health. Need maybe bullet hit occurs before motion starts, so explosion could be gone by first frame; but we can use click at a farther alien so bullet takes ~0.3 sec and motion captures it. Need perhaps call `motion` immediately after click, tool latency ~some seconds now; bullet would have hit long before. Could use a drag action starting at pointer location far away and ending nearby over 1 sec, maybe motion frames not captured. Could perhaps invoke `browser` action `motion` with a pending click? no.

Need maybe explicitly make hit feedback linger longer (e.g., explosion particles 450ms, score popup 900ms) so it's visible even if tool call latency ~1-2 seconds? Could make score popup 1200ms and particles 700ms. Need perhaps visible feedback can be score increase and contacts decrease; that's already visible in HUD. The requirement says "a projectile hit produces visible feedback", score increment and contact count are visible, plus burst. We can report score/contact changes as feedback, even if explosion frame not captured. But we should try to capture burst by making it last longer or use a persistent kill marker. Could add a small "HIT!" text on hit that lasts 1s. Maybe too much. But could make kill popup "+100" last 1100ms and burst 500ms. Good. Need perhaps tool call latency from click to inspect ~? First click screenshot showed bullet still in flight at +0ms from event; apparently no wall-time advancement during tool call, so next action could capture hit. The gameover happened between actions due model reasoning latency, not tool call itself. We can sequence click then motion with very little reasoning time by sending tool calls back-to-back in same assistant turn? We can call browser click, then browser motion without an intervening user message; but each tool call is separate assistant message with tool result; we can immediately call next tool after result. The reasoning between can be minimal. In prior sequence, click at (763,140) then motion: we did think a bit but not too long; motion frames started after hit and health 92%, score 100, so hit occurred before motion. To capture explosion, need perhaps click and then call motion with no thinking; but tool return itself likely enough time that hit occurred. Could use a longer-lived explosion. Let's extend kill/hit burst durations and popup. Need maybe set `hitBurst` ring duration 420, dots 500-700. Score popup 1200. Kill ring green maybe 500. Need not be too distracting. Need perhaps create a `HIT` text on nonlethal hit but first wave kills. Score popup +100 is clear. Need perhaps visible feedback includes score HUD. Good.

Need maybe wave progression verification could be easier with a debug button or reduce contacts. Could perhaps alter game to start with 3 aliens so one could kill all via 3 clicks, but requirement first wave plural, okay. But we already have 6. Need maybe we can test wave progression by using a drag action that fires continuously in a circle? Could use `drag` from one far point to another across many seconds; maybe not. Could perhaps use multiple `browser.click` actions at radial spawn positions quickly, back-to-back, with no reasoning; if aliens move toward center but remain along radial lines, each click at original radial target will fire a bullet along that line and hit the corresponding alien. There are 6 radial directions at angles 0°,60°,120°,180°,240°,300°. We can click at target coordinates one by one sequentially, with minimal reasoning. If game survives ~25 sec idle, can do 6 clicks in ~6 tool calls; each tool call maybe 1 sec? We can call them in rapid succession. Need maybe use `multi_tool_use.parallel`? Browser actions cannot be parallel because same page and dependent, but sequential tool calls in one assistant turn are not possible? We can send multiple tool calls in one assistant message via multi_tool_use.parallel, but they might run concurrently. Could use one `browser` action `drag` that sweeps pointer across multiple targets and holds fire; perhaps easier. Need maybe kill all 6 with a `drag` from target0 to target1 etc? drag only start/end, linear path. Could maybe call six `browser.click` calls wrapped in multi_tool_use.parallel; they'd execute concurrently, likely race and pointer events interleaved unpredictably. Not good. Could use `browser` action `drag` with start at (900,420) and end at (300,420) while holding left button; pointer moves horizontally across top? Actually pointer moves from east to west through player. Bullets fire continuously at aim points along horizontal line; could hit east and west aliens. Then another drag from upper-right to lower-left, hitting two diagonal aliens; another from upper-left to lower-right, hitting remaining two. Three drags could clear wave. Need perhaps each drag duration ~0.5 sec, fire cooldown 145ms, maybe 3-4 shots per drag. Good. But tool call may have long latency between drags; game survives longer now. Could try. Need maybe wave progression HUD becomes 02. Need perhaps score 600. This would verify wave. But time budget 15 min; we have maybe ~8 min? Need track. We should prioritize. Could implement slower difficulty and test wave progression via dragging if feasible. Need also verify restart after final changes maybe click restart once. We already did restart before difficulty changes; restart logic unchanged. Could final reload initial state after changes. Good.

Need perhaps consider game-over behavior due contact damage still may be too fast in actual gameplay? With 25 sec idle, fine. Need perhaps wave progression if player kills all 6 in first 10 sec, no issue. Need perhaps harder wave count/speed could be tested. Need maybe set `waveTransition` with delayed spawn. Good.

Need maybe update initial telemetry HTML. Need make hit effects last longer. Need adjust damage/cooldown/push. Need perhaps make score popup duration 1100. Need perhaps add persistent green kill ring. Let's edit.

Also maybe hitBurst count uses `Math.random()`, okay. Need perhaps no external network. Fine.

Need maybe add a global function to clear wave for test but hidden? Could use `window.__shooter.clearWave = () => ...` perhaps not needed. But maybe browser tool could call via console? `inspect` doesn't execute JS. Could use DOM click on a hidden debug button; no. Let's not.

Need perhaps avoid Phaser warnings from tweens on destroyed objects. We fixed lethal hit. Spawn tween still active and update no longer sets scale. Good.
Need perhaps wave clear `clearWave` increments wave while last alien kill popup still visible. Fine.
Need maybe `spawnWave` ring and alien scale tween; if alien killed before tween complete, tween target destroyed might persist and warn. Need not. Could store tween and kill on destroy; not necessary.
Need maybe `this.aliens.countActive(true)` returns 0 after all killed. Good.
Need maybe physics paused on gameover; restart resumes. Good.

Need maybe contact push of 90 can put alien outside arena and world bounds collides; okay.
Need maybe player shot during waveTransition disabled; if wave cleared, there is 1.25s no shooting. Fine.

Let's edit.

Need maybe test reload initial state, then perhaps use drag sequence to clear wave. Need time. Let's reload.

Initial screenshot looks good. Need perhaps test movement with key W/A/S/D after final changes. We earlier saw D movement. Could maybe test W quickly then click. Need perhaps wave clearing via drags. Let's think.

We can use browser `drag` with start at (900,420), end at (300,420) perhaps. But pointerdown at (900,420) fires east, hits east alien. Pointermove along horizontal line toward west; as pointer passes player center, aim undefined fallback last angle. It fires shots in various directions mostly horizontal; might hit east and west aliens. Need perhaps `drag` duration maybe 1 sec; could capture frames. But to clear all six, use three drags along lines through center:
- Horizontal from (900,420) to (300,420): catches east/west.
- Diagonal descending from (762,139) to (438,701): catches upper-right/lower-left.
- Diagonal ascending from (438,139) to (762,701): catches upper-left/lower-right.
Need maybe fire cooldown 145ms, drag likely spans maybe 0.5 sec -> 3-4 shots. Fine. But pointer moves through center, and aim line may point toward pointer; at some point near player, bullets fire in odd directions. Still okay. Need perhaps click/dwell at endpoints; drag ends at opposite endpoint and pointerup, so one shot at start and continuous shots during movement. Need maybe each drag kills 2. Could try. Need perhaps health declines after aliens reach player, but with slower damage now enough.

Could instead use six separate clicks at original radial positions. Each click fires one shot along radial line, guaranteed hit if alien still on line. More deterministic. Need six tool calls; can do quickly. But game starts with aliens moving toward center; original target positions still on same radial line. Need click at each spawn coordinate:
(900,420), (763,139), (438,139), (300,420), (438,701), (763,701).
Need note some y=701 near controls bottom-left but controls panel covers x20-420,y700-780; target (438,701) just right of controls, okay. Telemetry bottom-right x716-1170,y750; target (763,701) above telemetry. Good.
Need click on HUD? no.
Need maybe some clicks on controls overlay with pointer-events none, so canvas gets. Good.
Need perhaps after first click, bullet kills alien and score100

; after all six, wave 2. Need tool calls and no reasoning between; could perhaps use multi_tool_use.parallel with six click actions? They are not independent due same game state; but maybe tool calls will be executed concurrently, pointer events from different coordinates could race. Could order them via `multi_tool_use.parallel` wrapper? It says only if can operate in parallel; these cannot. Could use sequential `browser` calls in a single assistant message? The tool interface only one tool call per assistant message? We can issue one call to multi_tool_use.parallel with multiple browser calls, but not sequential. Could perhaps use one browser `type` action with text containing multiple mouse actions? no.

Could use `drag` as a single call to fire multiple shots. Let's try one drag and see contacts/score. Need perhaps start at (900,420) and end at (300,420), maybe enough time to fire many bullets. Need use browser drag with x,y,toX,toY. Let's do.

Interesting: health 70% after one drag? That means 5 hits in maybe tool latency; game survived. Score 100 from one kill, contacts 5, rounds 3-4. Screenshot shows `+100` popup faint near player and green burst maybe. This is visible projectile hit feedback! Great. The drag held fire and shot west, but aliens clustered; one kill. Need perhaps health 70 means 30 damage /6=5 hits over ~5.5s, consistent. Game can survive another ~12 hits =13s. Need maybe enough to kill remaining 5 via clicks, but tool calls may take ~5s each; likely gameover before. Could perhaps restart and use a more efficient approach to clear wave quickly by sequential clicks in one multi-tool parallel? Maybe not. Need perhaps wave progression can be tested with a debug hook or more robust time. Could further slow damage drastically for verification: e.g., 2 damage per 1200ms => 50 hits ~60s, giving plenty of time. But gameplay becomes too forgiving; still contact damages. Could perhaps set health 100 and damage 3 per 900ms ->34 hits ~31s, enough for 6 clicks maybe. Need maybe tool calls ~5s each, 6*5=30s; borderline. Could set damage 2 per 1100ms =>55s, plenty. Is that too easy? Player can still die if idle, but slowly. Could be acceptable. Need maybe "playable top-down alien shooter" with challenge from waves; wave speed/count increases. Could keep contact damage 6 but add a per-wave invulnerability? Hmm.

Maybe we can test wave progression via a hidden debug command implemented as a key sequence that kills all aliens, e.g. pressing `X` during play. We can then use browser `key` with text "x" and see wave 2. But adding a hidden debug key isn't ideal, though could be framed as a "scan pulse" ability? User didn't ask. Could implement an actual gameplay feature: press SPACE to trigger an EMP that damages all aliens, but controls don't mention it; not required. Could use key `N` to skip wave, not good. We don't need to verify wave progression via browser if code logic is straightforward. Task says brief pass through representative checks, focus readily accessible behavior; unspecified implementation details are our choice. We can report wave progression unverified. But requirement must still work. Need perhaps confidence code works. Let's

review wave logic:
- `spawnWave(1)` creates 6 active aliens.
- update checks `!waveTransition && countActive(true)===0` -> clearWave.
- `clearWave` increments wave, sets true, updates HUD, banner, delayedCall 1250 to spawnWave(wave), set false.
- But `update` loop still runs while waveTransition true and doesn't call clearWave. Good.
- `spawnWave` count=5+wave (wave2=7), speed=52+(wave-1)*10=62. Harder. Good.
- If gameOver during transition, old callback checks gameOver. On restart scene timers destroyed. Good.
- Need potential issue bullets disabled during waveTransition (fireBullet checks), but after spawn waveTransition=false. Good.
- If all aliens cleared, score increments; wave HUD changes. Good.
Thus we can leave unverified.

Need perhaps test movement after final changes just once. Earlier D movement verified before difficulty changes; movement code unchanged. Need maybe test key W and see PY decrease. Could call key "w" now; game health 70; might survive. Let's do quickly.

Again gameover quickly due tool latency. Health 70 to 0 means 12 hits *1.1=13.2 sec between drag and key call. Tool call reasoning/time ~13s. Need maybe make damage much lower for robust verification, but at some point game should still be playable. Could set contact damage 4 and cooldown 1500ms =>25 hits*1.5=37.5s. Then from full health idle ~6s+37.5=43.5s. That's enough. From 70% after drag, 18 hits*1.5=27s. Could still die between tool calls if 13s gap, but not as quickly. Need maybe 2 damage and 1500ms =>50 hits*1.5=75s. That might be too forgiving but okay. Or add player regeneration? no.

Could make contact damage only when alien first collides, then knockback and per-alien cooldown rather than global; but with 5 aliens, damage every 1.1s anyway. Need perhaps global cooldown 2s and damage 10 =>10 hits*2=20s. From 70% 7 hits*2=14s, borderline. Set damage 5/cooldown 1800ms =>20 hits*1.8=36s. Good. Maybe use 5 and 1800. This is reasonable enough; player can still die after 36 sec idle. Need maybe a real player will be swarmed and can lose in ~36 sec; waves get harder. Fine. But for testing, we can reduce further with a "shield" that recharges? no.

Could perhaps add a visible starting shield/invulnerability period of 10s after each wave, but then contact damage still. Not needed.

Need perhaps test wave progression by using a developer hook via `window.__shooter` and browser console maybe tool `inspect` cannot execute. Could perhaps use `browser` action `key` with text `"R"` to restart etc. Could add hidden key `"0"` to clear wave and verify. Need maybe use key action and see wave 02. This would be efficient. Is it acceptable to leave a debug shortcut in final app? Could be hidden but not documented; might be considered a flaw? Usually not, but we can remove it after verification. Ah! We can temporarily add a debug shortcut/hook, verify wave progression, then remove it before final. That's a good approach. Need use tools to

edit file, reload, press key to clear all aliens, check wave 2 spawn and speed/count, then remove hook and reload final. Need perhaps maybe also test gameover/restart via hidden shortcut. But we already tested restart. Need perhaps wave progression verification with hidden debug shortcut. Need time budget maybe 15 min, we've used maybe ~10 min? Need check. We can do quickly. Add keyboard key `0` when not gameover: destroy all aliens and maybe call `clearWave` naturally via update. Could use code:
```
if (key === '0' && !this.gameOver) {
 for (const alien of this.aliens.getChildren().slice()) if(alien.active) alien.destroy();
}
```
Then update sees count 0, wave 2 after 1.25 sec. Need reload, press "0", inspect after maybe. Need maybe tool call to key returns DOM at +0ms; wave HUD might already be 02 (clearWave immediate increment), but contacts 0. Need another inspect/motion to see wave 2 spawn with 7 contacts. Need perhaps call `browser.motion` after key; could capture 2.7 sec and show wave2 spawn. Health remains 100 because no contact. Great. Then remove debug shortcut. Need also perhaps verify speed/count via telemetry? Contacts 07 and wave 02. Need perhaps `snapshot` includes alien positions/hp but not speed. Could add data-state with wave speed; not necessary. Need count 7 demonstrates harder count. Could check `data-state` maybe no. Could add telemetry `SPD` to show speed, but optional. Need maybe wave number and contacts suffice.

Need perhaps need restart final file after removing debug, reload and check initial state. Yes. Need maybe recheck initial health/score/wave after final edit. Great.

Need also maybe test movement with final file after removing debug; already verified D movement earlier and W after gameover did not move. But movement code unchanged. Could perhaps reload final file and press `d` quickly, inspect; one call. Need perhaps no long reasoning. Fine.
Need perhaps test aiming/firing again after final file? We already verified with final-ish file (before damage adjustment only). Changes after that don't affect movement/aim/fire except durations and telemetry. Need maybe final reload and one click at target to ensure no syntax errors and aim works. Could do. Need perhaps no need to re-verify shot hit; already score 100 and +100 popup with current build before final damage adjustment. But after final edit changes only number, fine.
Need perhaps use hidden debug hook to verify wave. Let's do. Need also adjust damage to 5/1800 for playability and avoid gameover during tool latency, though wave verification with debug won't take long. Need maybe final game over still reachable. Need perhaps use 5/1500 ->20 hits*1.5=30s; enough. From initial to gameover ~36s. Good. Let's set 5/1500. Need health bar initial unchanged. Need perhaps contact feedback still. Good.
Need maybe add debug shortcut temporarily. Could include in same edit call. Then reload. Let's do both.

Need reload and press 0 quickly, then motion perhaps. Let's reload.

Need press 0.

Wave 02 banner shown, contacts 00 during transition. Need verify spawn 7 contacts after 1.25s. Call inspect or motion. Use inspect perhaps tool call after enough time. Could call `motion` for 2.7s and see. Need maybe health still 100. Let's do motion quickly.

Motion frames confirm wave2 7 aliens, faster (from ring to center in 2.5s? Wait speed 62 px/s should move 155px in 2.5s, from 300 to 145; frames show at +1.6s they are already near center ~70px, which implies ~150px/s. Why? Hmm perhaps motion frames timestamps are not wall time relative to page perhaps frames sampled at game time accelerated? Or physics speeds maybe more due to scale? Let's examine: first frame at +0ms wave2 aliens at radius ~190? Actually perhaps wave2 spawned before motion call (1.25 sec after key); by frame1 they had already moved ~? distance from center 190. Last frame at +2.48s they are at center. So speed maybe 100 px/s. But code speed 62. Could be motion tool's frame interval not wall time; perhaps game runs faster under screenshots? Doesn't matter. Wave2 count 7 and HUD 02. Need note health 95 due contact; contact damage works. Great.

Need now remove debug `0` shortcut. Need final reload and perhaps initial state check. Need maybe ensure no console errors after removing. Need perhaps final movement/aim/firing check could use one click after reload. Need perhaps use visible feedback from earlier. Need perhaps perhaps game over/restart final with debug removed? We tested restart before final changes; logic unchanged. Could maybe test gameover via waiting ~? with lower damage 5/1500 =20 hits*1.5=30s; too long. Could use hidden debug to set health=0 temporarily, but that's another hook. We can perhaps add a temp `9` key to set health=0 to test gameover/restart final, then remove. But we already verified gameover and restart earlier with higher damage. Need perhaps final file's gameover logic unchanged except damage amount. Good. Need maybe report that we checked gameover/restart earlier. Fine.

Need remove debug key. Use edit exact block.

Need final reload and initial check, perhaps click quickly to verify aim/fire on final file. Need maybe use quick sequence: reload, click at (763,140) then inspect. Need maybe no debug. Need perhaps check initial state first via reload output. Then click. Need perhaps final health/score/wave check after reload. Let's reload.

Initial screenshot looks great. Need perhaps final click to verify aim/fire on final file. Need maybe call click at (763,140) and inspect; with lower damage, game won't be over. Let's do.

Great final click screenshot clearly shows bullet traveling along aim line toward pointer at -60°, reticle at pointer, player rotated, aliens advanced toward player (from radius 300 to ~260). Need perhaps check hit visually with another motion maybe not necessary; earlier final-ish build showed score 100 and +100 popup. Need maybe final file no syntax errors. Need perhaps remove debug from telemetry? It has SHOT angle, okay. Need perhaps check no external URLs. Need perhaps check file ends present, script tag exact. Use bash grep. Need maybe check HTML for hidden "http" Phaser console banner only from Phaser library, not our code. Need maybe no external asset requests. We can grep our file for `http`, `src=`, `url(`. Need perhaps `src="phaser.min.js"` only. Need maybe ensure no CSS url. Let's do.

Need maybe final browser inspect after click to confirm score/hit maybe score increments on final build. Could call `motion` to capture hit. Need perhaps enough time but game survives now. Let's do motion quickly; might show score 100 and burst. Need final file no debug. Call motion.

The attached motion frames show score 00100, contacts 05, health dropping due contact, player flash bursts. Need perhaps note first frame hit burst around player? Score already 100. Good. Need perhaps check initial state after reload already. Need maybe test movement on final build? We earlier did D movement before final changes; movement code unchanged. But maybe final file with `keyPulses` etc works. Could do one final `reload` then `key d` quickly, inspect. Need perhaps initial state check also. Need ensure no gameover due long latency; with damage 5/1500, game survives ~36s, so key after reload should show movement and health maybe 100/95. Let's do reload then key "d". Need two tool calls. Need perhaps final reload confirms initial state again. Let's do.

Need finalize soon. Need maybe do movement quick after reload? User says save now, fix only essential, finish. We have index.html saved. Need perhaps maybe no need more checks. But perhaps final browser check initial state done. Need maybe one key D to check movement final build, quick. We have 5 min but should finish. Need maybe no essential issues. Need perhaps remove telemetry debug shot angle? Not essential. Need maybe ensure final file is saved (it is via edits). Need perhaps check no hidden debug key (did). Need maybe final response concise, report checks and unverified behaviors. Need mention wave progression verified via temporary debug shortcut (removed), game over/restart verified earlier, initial state reloaded. Need perhaps movement final build unverified? We did D movement earlier before final difficulty changes; movement code unchanged. Could quickly call `key d` now to confirm. Need maybe user asks finalize as soon as possible. One quick call.

Need final response. Need mention file saved. Need brief report what checked and remaining unverified. Need be honest: we checked reload initial health/score/wave/controls, D movement PX600->609, aiming/firing click at non-default pointer angle -60, shot bullet visible along line, aliens advance (screenshot/motion), projectile hit score 00100 contacts 06->05 and +100/burst visible earlier, wave progression via temporary debug clear (wave 02 with 7 contacts, faster code; debug hook removed), game-over and Restart observed in earlier build and restart restored 100/00000/01. Need note contact damage observed health decrease. Need note Phaser WebGL performance warnings but no JS errors. Remaining unverified: maybe sustained held-fire? We did drag and saw 3 rounds, so held fire verified. Need perhaps "full later waves/game-over on final build not re-run after difficulty tuning" but gameover/restart logic unchanged. Need say "I did not re-run a full natural game-over sequence on final tuned difficulty; earlier build confirmed overlay/restart, and final code path unchanged." Need perhaps "all six aliens killed naturally" not verified; wave transition verified by temporary debug. Need mention hidden debug hook removed. Need perhaps say "The final file contains no external URLs or network requests, only local phaser.min.js." Good.

Need keep concise. Need not include code. Need ensure no mention "temporary debug" too much maybe okay. Need final answer in plain text.