Glyph Warden

Create a self-contained browser game in a pixel-art fantasy setting where the player is a wizard who casts spells by drawing glyphs directly on the screen.

The game must be designed around gesture-based spellcasting as its central mechanic. The player should draw shapes, runes, lines, loops, sigils, and other recognizable glyphs with touch or mouse input, and the game should interpret those gestures into magical actions in real time.

Core design goals:
- Make the game fun, tactile, and highly responsive
- Make drawing glyphs feel satisfying
- Reward mastery of more difficult glyphs without making simple glyphs useless
- Keep the experience readable and engaging on a mobile screen
- Support both portrait mobile play and desktop browser play

Spell design:
Create a small but expressive spell vocabulary with multiple complexity tiers.

Simple glyphs:
- easy to draw
- easy to recognize
- fast to cast
- low mana cost
- modest, narrow, or utility-focused effects

Medium glyphs:
- require more intention and shape accuracy
- stronger or more flexible
- moderate mana cost
- useful in more demanding situations

Complex glyphs:
- harder to draw and recognize
- slower or riskier to cast
- high mana cost
- dramatic, powerful, or multi-purpose effects

The game should include several different categories of spells, such as:
- direct attack
- area damage
- shielding or warding
- movement or repositioning
- repair or restoration
- interaction with magical objects or environmental systems
- puzzle or utility magic
- resource conversion, harvesting, or transformation

Each spell should have:
- a distinct glyph shape
- a distinct gameplay role
- a clear cost and power profile
- a strong audiovisual identity

Gesture recognition:
Implement robust gesture recognition suitable for finger input on touchscreens.
The system should:
- tolerate imperfect human drawing
- avoid constant misclassification
- keep different glyph families clearly separated
- provide immediate feedback when a glyph is recognized
- provide graceful feedback when input is invalid or ambiguous

Visual style:
- pixel-art presentation throughout
- strong wizard-fantasy identity
- original in-game art rendered directly in code or canvas
- readable sprites, silhouettes, and effects on small screens
- polished magical atmosphere with arcane symbols, spell trails, particles, glows, and fantasy environments

Procedural VFX and SFX:
All special effects and sound effects must be generated procedurally in code.
Do not rely on external effect assets.
Use code-driven techniques to create satisfying magic feedback, such as:
- rune traces
- pixel particles
- sparks
- shock rings
- pulses
- lightning arcs
- embers
- smoke puffs
- magical flares
- impact bursts
- screen shake
- synthesized magical tones, hits, hums, bursts, and charge sounds

Game structure:
Build a complete, playable game loop with goals, pressure, and progression.
Possible elements include:
- enemy encounters
- magical hazards
- objects to protect, repair, or activate
- resource management
- score chasing
- escalating challenge
- short wave-like encounters or room-based progression
- unlockable or learnable spells
- combo or mastery systems

UI and UX:
- include a clear title screen
- include a start button
- include pause and restart
- include a clean HUD
- keep the main screen uncluttered
- place help or tutorial content in a help modal, codex, or overlay rather than scattering instructions everywhere
- make the controls self-explanatory after brief onboarding

Technical requirements:
- deliver the complete game as a single self-contained HTML file
- embed CSS and JavaScript in that file
- require no external assets to run
- avoid external libraries unless absolutely necessary
- run locally in a browser
- prioritize mobile touch input first
- also support desktop mouse play
- use canvas or similarly portable browser-native rendering

Tone:
The final game should feel magical, playful, skill-based, and polished.
The joy of the experience should come from drawing glyphs, seeing them resolve into spells, and using them cleverly across varied situations.

Deliverable:
Produce the complete playable game, not a design document.
Include all code needed to run it in one file.