TactiXpert

TactiXpert, built on Amazon Bedrock, helps form winning Valorant teams by analyzing player data and team dynamics, offering quick insights to optimize performance and strategy.

Comment

Inspiration

As a passionate Valorant player from its inception and an avid follower of Valorant esports, joining this hackathon felt like the perfect opportunity. I’ve always been fascinated by the strategy and coordination in professional teams, and I wanted to create something that could help users build strong teams and better understand the game's dynamics. The excitement of combining my love for Valorant with the power of AI made this project a no-brainer for me.

TactiXpert: Your AI-Driven Valorant Team Builder

TactiXpert helps users create insightful Valorant teams by leveraging Amazon Bedrock's capabilities. It provides detailed analyses of each player's role and why they were selected, along with a comprehensive team strength summary. This includes insights into synergy, composition, and tactics. Beyond team building, TactiXpert answers both team-specific and general Valorant queries, acting as a complete gaming assistant.

Building Blocks: Crafting TactiXpert from the Ground Up

The development of TactiXpert involved processing over 1.5 TB of game data and constructing a robust data pipeline to support dynamic team creation and analysis. This process included parsing raw game files, aggregating player statistics, and structuring a comprehensive database to house a central entity: the Player Profile.

After aggregating each player's game data, a Player Profile entity was created, containing detailed statistics and metadata. Here is a breakdown of the data within player_profile:

Player Profile Entity

  • player_id: A unique identifier for the player.
  • player_type: The competitive level or category in which the player participates (e.g., VCT-Challengers).
  • 2022_stats, 2023_stats, 2024_stats: Yearly statistics for the player, including metrics like agents played, roles, maps, kills, deaths, assists, etc. (stat entity).
  • acs: The player’s average combat score (ACS), a key performance metric.
  • all_time_score: The cumulative performance score over the player’s career.
  • all_time_stats: Career-wide stats, covering all games and including metrics such as win rates, kills, deaths, and rounds played. (stat entity).
  • igl_score: A custom score reflecting the player’s effectiveness as an in-game leader (IGL).
  • is_igl: Boolean indicating if the player serves as an in-game leader.
  • kd: The player’s kill-to-death ratio, reflecting kills relative to deaths.
  • last_15_stats, last_30_stats, last_60_stats: Recent performance metrics for the last 15, 30, and 60 games, capturing recent trends and effectiveness. (stat entity).
  • main_roles: A list of the player’s primary roles, like Sentinel or Controller.
  • player_handle: The player’s in-game username or alias.
  • player_info: Metadata on the player, including aliases, full name, photo URL, current team, and status.
  • player_region: The geographic region associated with the player, like EMEA.
  • team_acronym: The acronym of the player's current team.
  • team_name: The name of the player’s current team.
  • top_5_agents: The player’s most frequently used agents or characters in-game.
  • total_games: The total number of games the player has participated in.
  • total_kills: The cumulative number of kills across all games.
  • total_wins: The total number of games won by the player.
  • win_percentage: The player’s win rate, expressed as a percentage of total games won.
  • kills_per_round: The average number of kills per round, indicating the player’s offensive effectiveness.
  • assists_per_round: The average number of assists per round, reflecting the player’s support capabilities.
  • first_kills_per_round: The average number of first kills per round, highlighting the player’s role in initiating engagements.
  • first_deaths_per_round: The average number of first deaths per round, showing the player’s risk in early engagements.
  • headshot_percentage: The percentage of kills made with headshots, a metric of accuracy and precision.
  • clutch_success_percentage: The percentage of rounds in which the player successfully clutches (wins in a 1vX situation), indicating clutch ability.

Stat Entity Details

Each stat entity (e.g., last_15_stats, 2023_stats) includes specific performance metrics:

  • acs: The average combat score for recent games.
  • agents_played: Map of agents used in the last 15 games, with counts for each.
  • agents_wins: Map of wins achieved per agent.
  • agent_win_percentage: Win percentage per agent, based on games played.
  • kd: Kill-to-death ratio over recent games.
  • league_type_player: The types and counts of leagues played within the recent games.
  • maps_played: Map showing counts of each map played.
  • maps_wins: Map showing the number of wins on each map.
  • map_win_percentage: Win percentage for each map played.
  • player_positions: Counts of rounds in specific player positions.
  • player_score: Overall performance score for recent games, often derived from ACS, KD, and win rate.
  • regions_played: Map indicating regions played, with counts for each.
  • role_played: Count of each role (e.g., Controller, Sentinel) assumed in recent games.
  • role_wins: Wins for each role played.
  • role_win_percentage: Win percentage for each role.
  • total_assists: Total assists in recent games.
  • total_combat_score: Total combat score across all rounds in recent games.
  • total_deaths: Total deaths across recent games.
  • total_games: Total games played in the recent time frame.
  • total_kills: Total kills in recent games.
  • total_rounds_played: Total rounds in recent games.
  • total_wins: Wins in recent games.
  • win_percentage: Win rate in recent games.

This nested structure allows for an in-depth view of both the player’s recent performance and overall career metrics.

Intelligent Agent Framework

TactiXpert utilizes Amazon Bedrock to power intelligent agents for in-depth analysis of player roles and team dynamics, deploying a multi-agent framework that assigns tasks to specialized agents for enhanced accuracy and efficiency. This framework comprises:

  1. Team Planner: Establishes an initial team strategy, which adapts dynamically with each selected player to ensure alignment with the evolving team composition.
  2. Player Selector: Selects players based on the current team plan and specified selection criteria.
  3. Query Responder: Delivers detailed responses to user queries regarding individual players or the entire team, leveraging insights from the Player Profile.

The team-building process is iterative, with the Team Planner assessing the team’s needs, strengths, and requirements at each step. Based on this evolving assessment, it creates specific player selection criteria for the Player Selector, who then chooses players from a database pool to meet these needs. This process continues until five players are selected. Once the team is complete, the Team Planner reviews the team’s composition to produce a strength summary and address any further queries from the team generation command.

The Query Responder handles user queries about specific team selections. Given the query and current team data, it identifies relevant player details to construct a comprehensive response. Additionally, the Query Responder works seamlessly with the Player Selector to manage queries requiring player replacements, ensuring a cohesive team analysis experience.

The front-end, built in React, interacts with these agents to facilitate an interactive team selection process. The agents work in tandem, adjusting team plans dynamically to meet evolving criteria, resulting in a comprehensive, context-sensitive selection process. Once the team is finalized, user queries about players are answered by analyzing the relevant Player Profile data, providing insights on team strategy, individual strengths, and performance dynamics.

Overcoming Obstacles

Handling such a massive amount of data was challenging. Building the data pre-processing pipeline, associating each game event with player information, and structuring it for efficient querying was a significant hurdle. Another challenge was setting up Amazon Bedrock agents due to limited inference capacity. On the front-end side, learning React from scratch while building a functional and user-friendly interface was tough but rewarding.

What We Achieved

I'm particularly proud of building the largest data processing pipeline I've ever worked on, handling 1.5 TB of game data effectively. Creating a multi-agent framework that divides tasks between agents and improves performance was another achievement. Despite being new to React, I was able to build a functional UI that integrates seamlessly with the backend. TactiXpert’s ability to provide detailed team insights and answer general Valorant queries makes it a well-rounded assistant.

Lessons in Data and AI

This project taught me a lot about working with large datasets, particularly in the context of esports analytics. I gained insights into how game events are recorded and processed, which broadened my understanding of the backend of professional esports. I also became proficient with AWS services, particularly Amazon Bedrock, for building intelligent agents. Additionally, learning React for the front-end development was a valuable experience.

The Future of TactiXpert

I envision taking TactiXpert beyond Valorant. The next step is to extend it to other competitive games like League of Legends. I also plan to incorporate additional data such as lineups, map tactics, and strategies to help players improve their gameplay. My goal is to make TactiXpert a comprehensive gaming assistant that guides players through their ranked journey, offering insights and advice for multiple games.

Built With

Share this project:

Updates