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-shadowsand 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.