Haunt.py

Haunt.py is Moneyball for Valorant: an autonomous scouting engine that processes raw match telemetry to predict map vetoes, track utility usage, and expose opponent strategies in seconds.

Comment

Haunt.py - Tactical Warfare Intelligence

Inspiration

I am a die-hard Valorant esports fanatic. My journey into the scene properly started back in 2021, watching Tarik's watch parties. The energy, the community, and the high-stakes tactical depth of the game completely hooked me. As I watched more, I realized that while pro teams have armies of analysts, the average semi-pro or Premier IGL (In-Game Leader) is often overwhelmed with scattered data. They track stats on spreadsheets or basic trackers. I wanted to create something for the scene, even if it is a simple tool that bridges the gap between raw data and actionable strategy. I looked at the interfaces in the game lore (like Cypher's spy network or Brimstone's bracer) and thought to have a sleek minimalistic but in touch with the lore design for the product.

What it does

Haunt.py is a tactical intelligence engine designed for Valorant IGLs.

  • Target Scanning: You input a team name (e.g., "Sentinels"), and it instantly retrieves their recent competitive history.
  • Veto Analysis: Instead of just showing win rates, it applies a deterministic algorithm to suggest the optimal Map Bans and Picks. It identifies "Permabans" (maps opponents are too strong on) and "Punish Picks" (maps where they are statistically weak).
  • Tactical Insights: It breaks down performance into granular metrics—Pistol Round Win Rates, Economy (Thrifty) conversion rates, and Map Pool depth—visualizing them in a "Mission Briefing" style dashboard.

How I built it

I built Haunt.py as a high-performance web application:

  • Frontend: React powered the UI, with Tailwind CSS for the styling. I used Framer Motion extensively to create the "living" interface—animations, slide-ins, and tactical transitions that mimic in-game HUDs.
  • Backend: A Python Flask server handles the data processing.
  • The Engine: I originally experimented with AI, but realized that for competitive integrity, exactness is better than hallucination. I built a Statistical Inference Engine in Python. It aggregates match data, calculates weighted win rates, and uses heuristic logic to determine the "Threat Level" of a team on specific maps.
  • Data Visualization: I used custom CSS and logic to build the "Veto Timeline" and "Win Probability" visualizations to make complex data readable at a glance.

Challenges we ran into

  • The Pivot from AI: I started by using Large Language Models to summarize data. However, I found that they often hallucinated stats or gave generic advice ("Shoot heads"). I had to make the hard decision to rip out the LLM and build our own statistical algorithms instead. This was a massive rewrite late in the process, but it resulted in a faster, more reliable tool.
  • Data Scarcity: Getting reliable, granular data (like "Economy Rating") for non-Tier 1 teams is difficult. I had to build robust fallback mechanisms and error handling to ensure the dashboard never breaks, even when data is sparse.
  • Aesthetic Discipline: Creating the "Tactical" look (blurs, glow effects, neon accents) without destroying legibility was a constant battle. I spent hours tweaking CSS box-shadows and z-indices to get the "glassmorphism" just right.

Accomplishments that I amproud of

  • The User Experience: The app feels like a piece of software from the Valorant universe. The sounds, the inputs, and the "System Online" feedback loops create genuine immersion.
  • The Reliability: By moving away from black-box AI to transparent statistical logic, I created a tool that IGLs can actually trust.
  • The Autocomplete System: It sounds simple, but implementing a keyboard-navigable, side-floating, z-indexed autocomplete menu that works seamlessly with the complex UI animations was a surprisingly tough technical win.

What I learned

  • Context is King: Raw data (50% Win Rate) is useless. Comparative data (50% Win Rate vs 80% League Average) is useful.
  • Latency Matters: Fast, heuristic code beats slow, "smart" AI models every time for this use case.
  • Design is a Feature: The "cool factor" isn't just vanity; it keeps users engaged and makes the data feel more authoritative.

What's next for Haunt.py

  • Live Game Integration: Hooking into the live client API to provide overlay suggestions during the Agent Select screen.
  • VOD Review Engine: Adding a feature to upload match recordings for automated round-tagging.
  • Scrim Partner Finder: Using our team database to match teams with similar "Skill Ratings" for practice.
  • LLM Integration: Using an embedding models and storing all this data in an RAG and being able to provide based on situation to LLM to provide more insights for specific scenarios.

Built With

Share this project:

Updates