Let's make a Tetris-style game. Standard implementation: canvas, a 10x20 playfield, 7 tetrominoes (4-block shapes), SRS-like rotation via simple collision detection, line clearing, scoring (100/450/800/2000 × level), level up every 10 lines, speed-up. Preview of the next piece. Game over and restart (any key? Enter/R key). Dark style.

Let's write clean code. Rotation collision check: attempt rotation, and if it collides, try simple kicks (offsets of 0, -1, +1, -2, +2 columns). Requirements only say respect walls and blocks, so basic kicks are enough.

Hard drop: repeatedly soft-drop until collision, lock immediately.

Game over: if a new piece collides at the spawn position.

Display score, number of lines cleared, level, and the next-piece canvas.

Rendering: main canvas probably 300x600 (cell 30px). Preview canvas 120x120.

Implement the classic 4 shapes with color per shape.

Use the standard 4 shapes with color per piece: I cyan, O yellow, T purple, S green, Z red, J blue, L orange.

Spawn position: column offset, row at top (row 0 or negative). Use an array of matrices for the shapes. Generate the rotation states via rotation calculation, or precompute them. Simpler: represent a piece as a 4x4 matrix of coordinates? Use a block list per shape with rotation offsets? Simple approach: define shapes as matrices and rotate the matrices.

For example, define shapes as a list of 4x4 matrices? Standard approach:

Shapes as matrices:
I: 4x4? Use a width-4x height-... Use standard bounding boxes:
- I: [[0,0,0,0],[1,1,1,1],[0,0,0,0],[0,0,0,0]] 4x4
- O: [[1,1],[1,1]]
- T, S, Z, J, L: 3x3.

Rotating a matrix: transpose + reverse the rows. Rotation within a bounding box of the same size works fine.

Spawn: piece x = Math.floor((10 - cols)/2). Row starts at -? just row 0 or row -1? For simplicity spawn at row 0. Game over check on spawn.

Gravity interval: speed = based on level: interval = Math.max(1000 * Math.pow(0.8, level-1)... use a table: [800,700,600,...] or formula 1000/(1 + (level-1)*0.5)? Simple: interval = Math.max(80, 800 - (level-1)*70) or classic 0.8^(level-1)*1000 ms.

Score: points = [0,100,450,800,2000]*level; lines += count; level = floor(lines/10)+1.

Input: keydown handling, prevent default for arrow keys/space.

Rendering: grid background, blocks with borders, ghost probably not required—skip ghost or add it. Simple: skip ghost.

Let's write the file.