Got it, let's tackle this. First, I need to create a single index.html file that uses Phaser (already present as phaser.min.js) to make a top-down alien shooter. Let's start by outlining the requirements:

1.  Procedurally generated graphics only, no external assets. So I'll use Phaser's Graphics API to draw everything: player, aliens, bullets.
2.  Controls: WASD to move, mouse to aim, click to shoot.
3.  Waves of advancing aliens, increasing difficulty.
4.  Health, score tracking.
5.  No external audio or images, all code in one file.

First, the basic HTML structure: include the phaser.min.js script, then a canvas element, or let Phaser create it. The HTML will have a style tag for any basic styling, then the Phaser game code.

Wait, Phaser 3 is what's in phaser.min.js probably, so I'll use Phaser 3 syntax. Let's set up the game config: width 800, height 600, physics set to arcade, which is good for simple collision.

First, create the scene. The main scene will handle:
- Spawning the player: a small triangle or square, drawn with graphics. Player can move with WASD, collide with world bounds.
- Mouse tracking: get the mouse position, rotate the player to face the mouse.
- Shooting: when left click is pressed, spawn a bullet that travels in the direction the player is facing. Bullets get destroyed when they leave the screen or hit an alien.
- Alien spawning: spawn waves of aliens from the edges of the screen, they move towards the player. Each wave is bigger and faster than the last.
- Collision detection: between bullets and aliens (destroy both, increase score), between player and aliens (player takes damage, alien destroyed, if health reaches 0 game over).
- UI: display health and score on the screen, use Phaser's text objects.
- Procedural graphics: for every object, use Graphics to generate textures, or draw them directly. Wait, better to generate textures once using generateTexture, so we can reuse them. Like create a player texture, alien texture, bullet texture.

Let's outline the steps in code:

1.  HTML boilerplate, include phaser.min.js.
2.  In the Phaser config, set up the game, use the Arcade physics.
3.  In the preload function, we can create all the textures using graphics. So create a player graphic: a small triangle, fill it with green. Alien: a red circle or a small red shape, bullet: a white small square.
4.  In create function:
    - Set up cursor keys (WASD) and mouse input.
    - Create the player sprite, set physics properties (collide world bounds, speed).
    - Create groups for bullets and aliens, so we can manage collisions.
    - Set up collision between bullets and aliens: when they collide, destroy both, add to score.
    - Set up collision between player and aliens: player takes damage, alien destroyed.
    - Start the first wave, set a timer to spawn waves every few seconds, increasing difficulty.
    - Add text objects for health and score, update them as needed.
5.  In update function:
    - Handle player movement: set velocity based on WASD input.
    - Rotate the player to face the mouse position.
    - Check if mouse is down, shoot bullets (with a cooldown so you can't spam too fast).
    - Update all aliens to move towards the player.
    - Update the health and score text to reflect current values.
6.  Wave spawning function: each wave increases the number of aliens, their speed, so difficulty goes up. Spawn aliens off-screen so they come from all edges.
7.  Game over state: when health reaches 0, stop the game, show game over text.

Wait, let's make sure all graphics are generated. For example, in preload, create the player texture:

this.textures.generateTexture('player', 32, 32);
const canvas = this.textures.get('player').getSourceImage();
const ctx = canvas.getContext('2d');
ctx.fillStyle = '#00ff00';
ctx.beginPath();
ctx.moveTo(16, 0);
ctx.lineTo(32, 32);
ctx.lineTo(0, 32);
ctx.closePath();
ctx.fill();

That draws a green triangle pointing up, which is the player. Then alien texture: red circle, 24x24. Bullet: 8x8 white square. That's all procedurally generated, no external images.

For shooting, add a fire rate variable, so you can only shoot every 200ms, prevent spamming. For aliens, each alien's speed increases with each wave, so they get faster and more numerous.

Health system: player starts with 100 health, each alien collision takes 20 health, so 5 hits to die. Score increases by 10 per alien killed.

Let's put all this together into index.html. The file will be self-contained, all CSS in a style tag to center the game canvas, JS in a script tag, include phaser.min.js.

Wait, the style tag can set the body to have margin 0, display flex to center the canvas, background black, so it looks clean. Then the Phaser game creates the canvas, which is 800x600.

Let me write the full code now, make sure all parts are included. Let's check for any issues: in Phaser, to get the mouse position, use this.input.activePointer, to check if it's down, use this.input.activePointer.isDown. To rotate the player to face the mouse, use Phaser.Math.Angle.Between to get the angle between player and mouse, then set the player's rotation to that angle.

Aliens moving towards the player: for each alien in the aliens group, use Phaser.Math.Angle.Between to get the angle from alien to player, then set velocityX and velocityY using Math.cos(angle) * speed, Math.sin(angle) * speed. That makes them move straight towards the player.

Wave spawning: every 10 seconds, spawn a new wave, with waveNumber * 3 aliens, speed starting at 50, increasing by 10 each wave, so they get faster. Spawn them at random edges: top, bottom, left, right, so they come from all sides.

Yes, that should work. Now write the full index.html file.

Okay, the index.html file is created. Let me just check that everything is there: it uses the local phaser.min.js, all graphics are procedurally generated with canvas APIs in the preload function, controls are WASD for movement, mouse to aim and click to shoot, has health and score tracking, waves of aliens that get faster and more numerous over time, collision detection, game over state. All requirements are met. No external assets, all code in one self-contained file. Looks good.