CENTURY.

Build a polished, self-contained browser strategy game called CENTURY: 2026–2126. Create the entire game as one index.html file with embedded CSS and JavaScript. It must run locally without a server, external libraries, external assets, APIs, accounts, subscriptions, or internet access. CORE PREMISE The player becomes humanity’s steward in 2026 and must guide civilization through the next 100 years. The game consists of 20 turns. Each turn advances time by five years and presents a major global event, crisis, discovery, or opportunity. The player must choose one of three consequential responses. The objective is to preserve both human civilization and human agency until 2126. CORE METRICS Track six interconnected global metrics from 0 to 100:

- Human Survival
- Global Stability
- Habitability
- Human Agency
- Prosperity
- Knowledge

Human Survival, Global Stability, Habitability, and Human Agency are critical metrics. If any critical metric reaches zero, the run ends immediately with a distinct failure scenario.
Prosperity and Knowledge affect available choices, future events, recovery options, and the final score, but reaching zero should create severe disadvantages rather than automatically ending the game.
DECISION SYSTEM
Every turn must include:

- The current year
- A clearly written global event
- Enough context to understand the stakes
- Three meaningfully different responses
- Qualitative risk indicators rather than exact numerical outcomes
- Immediate consequences
- Possible delayed consequences that emerge one to three turns later
- A short explanation of what happened after the decision

Choices must involve genuine tradeoffs. Avoid obviously correct answers, joke answers, and choices that differ only cosmetically.
Examples of decision categories may include:

- Artificial intelligence and automation
- Energy and resource scarcity
- Climate and natural disasters
- Public health and biotechnology
- Cyberattacks and infrastructure
- Economic instability
- Governance and civil liberties
- Scientific discovery
- Space development
- International cooperation and conflict
- Demographic and cultural change

Do not use real contemporary politicians, political parties, or partisan slogans. Keep geopolitical events fictionalized and globally framed so the game remains evergreen.
EVENT SYSTEM
Create at least 45 distinct events distributed across four eras:

- 2026–2050
- 2051–2075
- 2076–2100
- 2101–2126

Include both crises and opportunities. Some earlier decisions should unlock, prevent, intensify, or alter later events.
Include at least 10 delayed-consequence chains. Make those consequences clearly connect to earlier choices when they appear.
Use a seeded deterministic random-number system. Display the world seed so another player can replay the same century and compare decisions.
The same seed and same choices must always produce the same events and outcomes.
BALANCE AND FAIRNESS
The game should be challenging but winnable on the first completed build.
Requirements:

- Never create an unavoidable failure state
- Never destroy a healthy critical metric with one untelegraphed event
- Provide warnings when a dangerous imbalance is developing
- Do not allow one strategy or metric to dominate every run
- Reward balanced long-term stewardship
- Allow short-term sacrifices to create meaningful future advantages
- Make careless play likely to fail before 2126
- Ensure at least one legitimate path can reach 2126
- Support multiple viable winning strategies
- Make each complete attempt last approximately four to six minutes

Do not secretly change difficulty during a run.
RESULTS AND REPLAYABILITY
Create multiple distinct endings based on the final world state, including:

- Cooperative flourishing
- Technological abundance
- Fragile survival
- Ecological collapse
- Civilizational breakdown
- Authoritarian lock-in
- Human extinction

At the end of every run, show:

- The year reached
- Total years survived
- A memorable ending title
- Final values for all six metrics
- A score from 0 to 1,000
- The world seed
- Three pivotal choices
- A concise summary of the civilization the player created

Include functional buttons for:

- Replay the same seed
- Begin with a new seed
- Copy the result as plain text
- View the complete decision timeline
- Return to the title screen

Store the ten highest local scores in localStorage. Include the seed, ending, year reached, score, and date.
Also provide an “Export Result” button that downloads a small JSON file containing the seed, final score, ending, metrics, and decision history. This should make future leaderboard integration possible without requiring a backend now.
VISUAL DESIGN
The game must look excellent in a 1920×1080 YouTube recording while remaining responsive on mobile devices.
Use:

- A cinematic dark interface
- Deep navy and black backgrounds
- Cyan, amber, green, and restrained red status colors
- A stylized animated Earth, globe, or world-system visualization created entirely with CSS, SVG, or Canvas
- A prominent timeline from 2026 to 2126
- Large, readable metric displays
- Smooth number and progress-bar animations
- Clear warning effects when civilization approaches failure
- Satisfying but restrained particles, pulses, and transitions
- Strong visual differences between prosperous, unstable, damaged, and flourishing world states

The main gameplay screen should fit within a standard 16:9 desktop window without requiring constant scrolling.
Do not use placeholder artwork, broken icons, tiny text, excessive screen shake, or unfinished interface elements.
AUDIO AND ACCESSIBILITY
Generate restrained interface sounds with the Web Audio API for:

- Selecting a decision
- Advancing five years
- Metric warnings
- Major discoveries
- Victory
- Defeat

Audio must begin only after user interaction. Include a clearly visible mute control and keep sounds tasteful rather than childish or oppressive.
Also include:

- Keyboard navigation
- Visible focus states
- Sufficient color contrast
- Reduced-motion support
- Tooltips or labels for unfamiliar controls
- A skip-animation option

OPENING EXPERIENCE
The title screen should immediately communicate:
CENTURY
2026–2126
Can humanity survive the next 100 years?
Include a short explanation:
“One century. Twenty decisions. Every solution creates another problem.”
Provide one prominent button labeled “BEGIN THE CENTURY.”
Do not bury the player in instructions. Introduce the six metrics through a brief, polished onboarding sequence before the first decision.
EDITORIAL RESPONSIBILITY
Clearly label CENTURY as a speculative strategy game and thought experiment, not a scientific forecast or policy recommendation.
Do not claim to predict real events. Avoid deterministic statements about real countries, cultures, demographic groups, or political systems.
The game may explore difficult moral and strategic tradeoffs, but it should not endorse cruelty, discrimination, political violence, or the removal of human rights as objectively correct.
TECHNICAL REQUIREMENTS

- One index.html file only
- Embedded CSS and JavaScript
- No external dependencies
- No network requests
- No placeholder buttons
- No unfinished features
- No console errors
- Every control must function
- All gameplay data must remain on the local device
- Responsive desktop and mobile layouts
- Deterministic seeded randomness
- Functional local high scores
- Functional result copying
- Functional JSON export
- Functional restart and replay controls
- Complete victory and failure logic

Before finishing:

1. Inspect the complete file for syntax and logic errors.
2. Verify that all 20 turns can be completed.
3. Verify that victory and failure are both possible.
4. Verify that delayed consequences trigger correctly.
5. Verify that replaying the same seed reproduces the same century.
6. Verify that every button and control works.
7. Verify that the interface remains readable at 1920×1080 and on a mobile-sized viewport.
8. Correct any problems you find before declaring the project complete.

Do not ask me questions. Make sensible creative and technical decisions, create the complete working application in the current folder, test it, and finish the project using only this prompt.