Visual
Home Page
Fire Simulation
Roadblock Page
AI Analyzation
logic flow
logic flow2
Citation Page
Usage of antigravity

Inspiration

Wildfires are not static disasters. Fire fronts expand unevenly, roads can become unusable in minutes, and evacuation decisions have to adapt to changing risk rather than follow a fixed map. Traditional evacuation diagrams are useful for planning, but they are limited when the threat itself is moving.

Wildfire Tactics was built as an interactive wildfire evacuation simulation that connects three systems in one environment: fire propagation, route planning, and human coordination. Instead of treating evacuation as a single shortest-path problem, the project models how residents, guides, blocked roads, and safe points continuously influence one another as the fire evolves.

Our goal is to give emergency planning scenarios a more tactical and dynamic form: users can place hazards and agents directly on the map, observe how routes change over time, and inspect how guide decisions affect nearby residents under pressure.

What It Does

Wildfire Tactics is an interactive browser-based simulation for exploring wildfire evacuation behavior on a mapped road network.

It currently supports:

Dynamic fire spread simulation with intensity growth, burnout, wind-influenced spread probability, and roadblock-aware propagation.
Resident evacuation behavior constrained to the road graph rather than free movement across the map.
Guide agent coordination, where AI-assisted guides periodically choose a target safe point and influence nearby residents.
Interactive tactical controls, including manual placement of fire sources, residents, guides, and roadblocks.
Pause and resume inspection, allowing users to freeze the simulation and observe outcomes.
Outcome tracking, where residents eventually become either safe or dead depending on fire exposure and route availability.
Guide decision tracking, including a draggable live log panel that shows which safe point a guide selected and why.

The project is designed as a proof-of-concept command interface for wildfire evacuation reasoning, not as a literal real-world forecasting system.

How We Built It

Frontend and Visualization

The application is built with React, TypeScript, and Vite. We use Mapbox GL JS as the geospatial base map and Deck.gl to render the simulation layers on top of it, including roads, fire cells, agents, and safety zones.

This setup lets us separate concerns cleanly:

React manages simulation state, tool selection, overlays, and UI interactions.
Mapbox provides the real map context.
Deck.gl handles high-frequency, map-aligned rendering for moving agents and expanding fire.

We use the IDE provided by Google Antigravity and the api provided by Backboard.io

Simulation Architecture

The simulation advances in discrete ticks. On each tick:

Fire cells update their age, intensity, spread, and burnout state.
Residents and guides advance along the road graph.
At a fixed interval, guide agents request new AI decisions.
The UI refreshes to reflect updated fire intensity, agent positions, and outcomes.

This structure makes the system easy to inspect and tune, because fire behavior, movement, and AI decision cadence are all explicit and separable.

Core Simulation Logic

Fire Spread Model

The fire system is not just a visual animation. Each fire cell has:

a geographic position
an intensity level
a size
an age

Fire evolves in three stages:

Growth: low-intensity cells can intensify over time.
Spread: sufficiently mature and intense cells attempt to ignite neighbors.
Burnout: older cells gradually decay and eventually disappear.

Spread is probabilistic and directional. For each active fire cell, the simulator samples a candidate spread direction and computes a spread chance that depends on both intensity and wind alignment.

Let:

( I ) be the current fire intensity
( P_{\text{base}} ) be the base spread coefficient
( \theta ) be the angle between the wind direction and the chosen spread direction
( v ) be the normalized wind speed

Then the spread tendency is modeled approximately as:

[ P_{\text{spread}} \propto P_{\text{base}} \cdot (I - 1) ]

and wind modifies it using directional alignment:

[ P_{\text{final}} = \max \left(0.15 P_{\text{spread}},\; P_{\text{spread}} \cdot (1 + 2v\cos\theta)\right) ]

This means fire spreads more aggressively when the sampled direction aligns with the wind, and is suppressed when spreading against it.

We also added two important spatial constraints:

Minimum spacing between fire cells, so the fire front does not collapse into an unrealistic dense cluster.
Roadblock crossing penalty, so fire is less likely to jump across blocked segments, making road intervention relevant to both routing and spread.

Resident Logic

Residents are not simple markers. Each resident has:

a reaction delay
a movement speed
a current road node
a target safe point
an optional followed guide
panic state
path history

Their behavior is driven by several interacting rules:

Residents stay idle until they detect a threat or a nearby guide.
Once activated, they route through the road network toward a safe point.
If fire is nearby, they panic and temporarily move faster.
When panicking, they may abandon guide-following and act independently.
If they enter the lethal core of a fire cell, they die.
If they enter the arrival radius of a safe point, they are marked safe.

A key design choice is that residents are road-constrained. They do not move in straight lines across the map. Their movement is governed by a shared routing field computed over the evacuation graph.

Guide Logic

Guide agents are designed as tactical coordinators rather than just faster residents.

Each guide:

operates on the same road network
receives AI decisions at a fixed tick interval
selects a target safe point
influences nearby residents within a guide radius
can be clicked, removed, or tracked through a live decision log

The guide AI is backed by a structured LLM workflow. For each active guide, the system builds a situation report containing:

current fire activity and estimated fire direction
blocked road segments
safe-point accessibility checks
resident status summaries
the guide’s own position

The AI is then asked to choose the best safe point, and that choice is validated before use. If the AI is unavailable, the system falls back gracefully to a default safe-point selection.

This makes guide behavior both interactive and inspectable: the guide is not a black box, because users can open a live log panel and review the guide’s latest decisions and reasoning.

Shared Routing and Fire Avoidance

One of the most important technical pieces in the project is the evacuation routing layer.

Instead of running a full A* search independently for every resident on every tick, we compute shared flow fields from safe points over the road graph. This means many residents can reuse the same routing structure, which is much more efficient for evacuation scenarios with many agents moving toward common exits.

Routing is also fire-aware:

edges near dangerous fire become more costly
areas inside severe fire become effectively impassable
user-placed roadblocks remove paths from consideration

This creates the behavior we wanted most: agents do not simply seek the shortest route, but dynamically reroute away from danger as the simulation changes.

Challenges We Ran Into

1. Keeping the evacuation graph coherent

A road-network simulation is only as good as its graph. During development, disconnected edges and duplicate identifiers caused broken routing behavior and made some agents appear irrational when the actual issue was bad network data. We had to tighten the structure of the graph and make blocked-edge behavior more consistent.

2. Aligning visuals with simulation logic

A major challenge was making sure the fire users saw on the map matched the fire the simulation was actually reasoning about. We had to unify distance scaling and remove visual/logical mismatches so that influence radii, fire danger, and death checks made sense together.

3. Balancing realism with responsiveness

If the fire spreads too slowly, the demo feels static. If it spreads too aggressively, evacuation becomes meaningless. The same applies to resident speed and AI decision cadence. We spent significant time tuning fire growth, spread, burnout, resident movement, panic behavior, and guide update intervals so the simulation feels active without becoming chaotic.

4. Coordinating multiple interacting systems

The hardest part was not any single algorithm in isolation. It was making the interactions believable:

fire changes routing
routing changes resident movement
guide decisions change resident targets
panic can override guide-following
roadblocks affect both fire spread and evacuation feasibility

That coupling is where most of the project complexity lives.

Accomplishments That We're Proud Of

A unified simulation loop that ties fire spread, evacuation routing, and guide coordination together in one interactive system.
Threat-aware evacuation routing, where agents respond to changing fire conditions instead of following static shortest paths.
Guide-agent observability, including clickable guides, removable guides, and a draggable decision-tracking panel.
Interactive scenario building, where users can create a simulation from scratch by placing fires, residents, guides, and roadblocks directly on the map.
A polished tactical UI, combining geospatial rendering with a command-center style visual language.

What We Learned

Pathfinding becomes much harder when the map itself is changing. Static shortest-path logic is not enough once hazards evolve over time.
Visual honesty matters. In simulations, even small inconsistencies between what users see and what the engine computes can destroy trust quickly.
Shared routing structures are powerful. Flow-field style routing is a strong fit when many agents are moving toward a small number of exits.
Human behavior needs layered rules. Reaction delay, panic, guide influence, and death thresholds together produce much more convincing outcomes than a single movement rule.
AI is most useful when it is constrained. Letting the guide AI choose among validated safe points worked better than giving it unrestricted control.

What's Next for Wildfire Tactics

We see several clear next steps for the project:

Path visualization for agents, so users can inspect the current planned routes directly on the map.
Stronger crowd realism, including congestion, capacity limits, and group behavior among residents.
Richer environmental inputs, such as dynamic wind changes, terrain effects, and humidity-sensitive spread.
Automated map ingestion, replacing manually defined road networks with imported real-world GIS or OpenStreetMap data.
Scenario analytics, including richer dashboards for evacuation efficiency, casualties, route bottlenecks, and guide effectiveness.
More advanced guide behavior, where guides do more than pick safe points and can actively reposition to maximize influence.

Why This Project Matters

At its core, Wildfire Tactics is about turning evacuation planning into something dynamic, inspectable, and interactive. The project demonstrates how wildfire spread, road constraints, human response, and tactical intervention can be modeled together rather than treated as separate systems.

That combination is what makes the project interesting: not just that the fire spreads, and not just that agents move, but that each system continuously changes the behavior of the others.