View Categories

Score Manager

23 min read

Score Manager #

  • Overview
  • Prerequisites
    • Player Manager Required
    • Related Systems
  • Core Concepts
    • What Is the Score Manager?
    • How It Works
    • Scoring Types
  • AC_ScoreManager
    • Component Location
    • Core Functionality
    • Configuration Variables
  • AC_ScoreCommunicator
    • Component Location
    • Score Popup System
  • Score Structure
    • Struct_PlayerScore
    • Struct_SingleScore
    • Team Scores Array
  • Player Scores
    • Player Score Data
    • Score Tags
    • Final Game Score
  • Game Score Multipliers
    • What Are Multipliers?
    • Multiplier Sources
    • Score Calculation
  • Scoring Types
    • Win-Based Scoring
    • Aggregate Scoring
    • Configuring Scoring Type
  • Team Scores
    • Team Score Array
    • Team Score Updates
    • Winning Score
  • Score Tracking
    • Binding to Player Manager
    • Kill Tracking
    • Death Tracking
    • Assist Tracking
  • Score Updates
    • Adding Score to Player
    • Adding Score to Team
    • Automatic Updates
  • Score Calculation
    • Single Score Calculation
    • Final Game Score Calculation
    • Team Score Calculation
  • Score Reset
    • Between Games
    • Between Rounds
  • Winning Score System
    • What Is Winning Score?
    • Aggregate Scoring Winner
  • Event Dispatchers
    • OnPlayerScoreChanged
    • OnTeamScoreChanged
    • OnWinningScoreChanged
  • Utility Functions
    • Player Score Functions
    • Team Score Access
  • Integration with Other Systems
    • Player Manager Integration
    • Team Manager Integration
    • Game Mode System Integration
    • Scoreboard Integration
  • How To Guides
    • Setting Up Score Manager
    • Adding Custom Score Tags
    • Implementing Score UI
    • Querying Score Data
  • OVERVIEW

This documentation explains the Score Manager System, which provides centralized score tracking for players and teams, including kill/death/assist tracking, team scoring, win-based and aggregate scoring types, and score popups.

What Is the Score Manager?:

The Score Manager tracks all score-related data in multiplayer sessions. It maintains player scores (kills, deaths, assists, objectives), calculates final game scores based on multipliers, tracks team scores, and integrates with other systems to provide complete scoring functionality.

Key Features:

  • ✅ Player Score Tracking: Track individual stats (kills, deaths, assists, objectives)
  • ✅ Score Tags: Gameplay tag-based scoring (Score.Kills, Score.Deaths, etc.)
  • ✅ Game Score Multipliers: Point values for actions (kill = 100 points, death = -10 points)
  • ✅ Final Game Score: Calculated score based on stats × multipliers
  • ✅ Team Scores: Track team points
  • ✅ Scoring Types: Win-based (manual team scoring) or aggregate (sum of player scores)
  • ✅ Winning Score: Track which team/player is winning
  • ✅ Score Popups: Visual feedback for score changes (+100, -10, etc.)
  • ✅ Automatic Tracking: Binds to Player Manager for kill/death events
  • ✅ Integration: Works with Player Manager, Team Manager, Game Mode System

Use Cases:

  • Track player kills/deaths/assists
  • Calculate player scores based on actions
  • Track team scores for team-based games
  • Determine winning team/player
  • Display scoreboard with stats
  • Show score popups for player feedback

Prerequisites #

Player Manager Required #

CRITICAL: Score Manager requires Player Manager.

Setup Order:

  1. Set up Player Manager (see Player Manager documentation)
  2. Set up Score Manager (this documentation)

Why Player Manager Required:

  • Score Manager binds to Player Manager's kill/death events
  • Score Manager needs player tracking
  • Score Manager creates score entries when players join

Without Player Manager:

  • Cannot detect player kills/deaths
  • Cannot track player scores
  • Cannot initialize player score data

Component Order (GameState):

  1. AC_SessionManager
  2. AC_TeamManager (if using team scores)
  3. AC_ScoreManager ← Binds to Player Manager events
  4. AC_PlayerManager ← MUST be bottom (see Player Manager docs)

Related Systems #

Systems That Integrate with Score Manager:

Player Manager (required, separate documentation):

Provides:

  • Player kill/death events
  • Player join/leave events
  • Connected players list

Score Manager uses:

  • Bind to OnPlayerDied to track deaths
  • Bind to OnPlayerKilledPlayer to track kills
  • Bind to OnPlayerJoined to create score entries

Team Manager (optional, separate documentation):

Provides:

  • Team structure
  • Team assignments
  • Team member lists

Score Manager uses:

  • Team index for team scores
  • Team members for aggregate scoring
  • Team data for scoreboard

Game Mode System (optional, separate documentation):

Provides:

  • Game settings (score multipliers)
  • Win condition checking

Score Manager provides:

  • Score data for win conditions
  • Team/player scores for winner determination

Game Mode binds to:

  • OnTeamScoreChanged (check win condition)
  • OnWinningScoreChanged (check if winner changed)

Session Manager (optional, separate documentation):

Provides:

  • Game settings (score multipliers)
  • Scoring type configuration

Score Manager uses:

  • Load multipliers from game settings
  • Load scoring type from game settings

Core concepts #

What Is the Score Manager? #

The Score Manager is a centralized system for tracking and calculating scores for players and teams in multiplayer games.

Why Score Manager?:

Without Score Manager:

  • Manual score tracking per system
  • Duplicate score logic
  • No standardized scoring
  • Hard to query scores

With Score Manager:

  • One source of truth for scores
  • Automatic kill/death tracking
  • Standardized score calculation
  • Easy score queries
  • Event-based score updates

How It Works #

Score Lifecycle:

  1. Player Joins:
 - Player Manager fires OnPlayerJoined
 - Score Manager creates Struct_PlayerScore entry
 - Initialize score tags (kills, deaths, assists all = 0)
 - Final Game Score = 0
  1. Player Gets Kill:
 - Player Manager fires OnPlayerKilledPlayer
 - Score Manager receives event
 - Increment Score.Kills tag (5 → 6)
 - Recalculate Final Game Score (6 × 100 = 600 for kills + other scores)
 - If aggregate scoring: Update team score
 - Fire OnPlayerScoreChanged event
 - Show score popup (+100)
  1. Player Dies:
 - Player Manager fires OnPlayerDied
 - Score Manager receives event
 - Increment Score.Deaths tag (3 → 4)
 - Recalculate Final Game Score (includes death penalty)
 - If aggregate scoring: Update team score
 - Fire OnPlayerScoreChanged event
 - Show score popup (-10)
  1. Game Mode Adds Score:
 - Game Mode calls AddScoreToPlayer("Player1", Score.Objectives, 1)
 - Increment Score.Objectives tag (2 → 3)
 - Recalculate Final Game Score
 - Fire events
 - Show popup
  1. Team Scoring:
 - Win-Based: Game Mode calls AddScoreToTeam(0, 500) manually
 - Aggregate: Score Manager sums all player Final Game Scores on team
 - Fire OnTeamScoreChanged event
 - Game Mode checks win condition
  1. Game End:
 - Winner determined (highest team/player score)
 - Scores displayed on scoreboard
 - New game loads → Scores reset automatically
Example – Team Deathmatch:

Configuration:

  • Scoring Type: Aggregate
  • Kill Score Multiplier: 100
  • Death Score Multiplier: -10
  • Assist Score Multiplier: 50

Player 1 Stats:

  • Kills: 15
  • Deaths: 8
  • Assists: 5

Final Game Score Calculation:

= (15 kills × 100) + (8 deaths × -10) + (5 assists × 50)

= 1500 – 80 + 250

= 1670 points

Team A Total (Aggregate):

  • Player 1: 1670
  • Player 2: 1420
  • Player 3: 980

= Team Score: 4070

Team B Total:

  • Player 4: 1550
  • Player 5: 1200
  • Player 6: 890

= Team Score: 3640

Team A wins (higher score).

4 ac_scoremanager #

Component Name: AC_ScoreManager

Location: GameState

Component Location #

Where to Add:

Component: AC_ScoreManager

Location: GameState blueprint

Why GameState:

  • Server-authoritative
  • Accessible to all players
  • Persists across level transitions
  • Manages global score state

Component Order:

  1. AC_SessionManager
  2. AC_TeamManager (if used)
  3. AC_ScoreManager ← Binds to Player Manager events
  4. AC_PlayerManager ← MUST be bottom (see Player Manager docs)

Score Manager must be ABOVE Player Manager to bind to events.

Core Functionality #

What AC_ScoreManager Provides:

Player Score Tracking:

  • Track kills, deaths, assists, objectives per player
  • Calculate Final Game Score based on multipliers
  • Store player score data (Struct_PlayerScore array)

Team Score Tracking:

  • Track team scores (integer array)
  • Win-based or aggregate scoring
  • Winning score tracking

Score Calculation:

  • Game score multipliers (tag → points)
  • Final Game Score calculation
  • Team score calculation (aggregate)

Automatic Tracking:

  • Bind to Player Manager kill/death events
  • Auto-increment score tags
  • Auto-recalculate scores

Manual Scoring:

  • AddScoreToPlayer (custom score tags)
  • AddScoreToTeam (win-based scoring)

Events:

  • OnPlayerScoreChanged
  • OnTeamScoreChanged
  • OnWinningScoreChanged

Utility Functions:

  • GetAllPlayerScores
  • FindPlayerScoreIndex
  • FindScoreInScoreArray
  • Direct team score access

Configuration Variables #

Score Manager Settings:

Scoring Type (Enum or Setting):

  • Win-Based: Manual team scoring
  • Aggregate: Sum of player scores
  • Can be set manually or via game settings

Game Score Multipliers (Map: Gameplay Tag → Integer):

  • Score.Kills → 100 points
  • Score.Deaths → -10 points
  • Score.Assists → 50 points
  • Score.Objectives → 200 points
  • etc.

Default Multipliers:

  • Predefined multipliers if game settings not used
  • Fallback values

Sources:

  • Game settings (DA_GameMode_Defaults) – primary
  • Manual configuration – fallback

5 AC_SCORECOMMUNICATOR

Component Name: AC_ScoreCommunicator

Location: PlayerController

Component Location #

Where to Add:

Component: AC_ScoreCommunicator

Location: PlayerController blueprint

Why PlayerController:

  • Per-player component
  • Displays score popups for individual player
  • Client-side UI

Score Popup System #

What Are Score Popups:

Purpose:

  • Visual feedback when your score changes
  • Shows points gained or lost
  • Appears on your screen only

Display:

  • Shows change in Final Game Score
  • Examples: “+100”, “-10”, “+200”
  • No explanation of source (just the number)
  • Plus/minus icon with value

When Shown:

  • When YOUR Final Game Score changes
  • Kill: +100
  • Death: -10
  • Objective: +200
  • Any score change triggers popup
Example:

You get a kill:

  1. Score Manager increments Score.Kills
  2. Recalculates Final Game Score (+100 from kill multiplier)
  3. Score Communicator detects change
  4. Shows popup: “+100”

You die:

  1. Score Manager increments Score.Deaths
  2. Recalculates Final Game Score (-10 from death multiplier)
  3. Score Communicator detects change
  4. Shows popup: “-10”

Score structure #

Struct_PlayerScore #

Player Score Data Structure:

Struct Name: Struct_PlayerScore

Fields:

  • Player Name (String)
  • Scores (Array of Struct_SingleScore)
  • Game Score (Integer)
Example:

{

 PlayerName: "Player1"
 Scores: [
 {Tag: Score.Kills, Value: 15},
 {Tag: Score.Deaths, Value: 8},
 {Tag: Score.Assists, Value: 5}
 ]
 GameScore: 1670

}

Stored In: AC_ScoreManager->PlayerScores (array)

Struct_SingleScore #

Individual Score Data Structure:

Struct Name: Struct_SingleScore

Fields:

  • Tag (Gameplay Tag)
  • Value (Integer)

Purpose:

  • Track individual stat counts
  • Link score type to value
Examples:

{Tag: Score.Kills, Value: 10}

{Tag: Score.Deaths, Value: 5}

{Tag: Score.Assists, Value: 3}

{Tag: Score.Objectives, Value: 2}

Value Meaning:

  • Raw count (number of kills, deaths, etc.)
  • NOT points (points calculated via multipliers)
Example:

Score.Kills = 10 means 10 kills

With Kill Score Multiplier: 100 points per kill

Contributes: 10 × 100 = 1000 points to Final Game Score

Team Scores Array #

Team Score Data Structure:

Data Type: Array of Integers

Structure:

TeamScores[0] = Team A score

TeamScores[1] = Team B score

TeamScores[2] = Team C score

etc.

Index Matching:

  • Team index matches Team Manager team index
  • Team A (Team Manager index 0) = TeamScores[0]
Example:

TeamScores = [5000, 3200]

  • Team A: 5000 points
  • Team B: 3200 points

Access:

  • Direct access: ScoreManager->TeamScores[0]
  • No getter function needed

Team Removal:

  • If Team Manager deletes team
  • Score Manager removes that index from TeamScores array

Player scores #

Player Score Data #

How Player Scores Are Stored:

Location: AC_ScoreManager->PlayerScores (array)

Structure: Array of Struct_PlayerScore

Each Entry:

  • Player Name (from PlayerState->GetPlayerName())
  • Scores array (individual stats)
  • Game Score (calculated total)

When Created:

  • Player joins (Player Manager OnPlayerJoined event)
  • Score Manager creates entry
  • Initialize all score tags to 0
  • Game Score = 0

When Removed:

  • Player leaves: Score kept until game end
  • Game end: All scores reset
  • Short game duration, so scores persist

Score Tags #

Standard Score Tags:

Common Tags (examples):

Score.Kills:

  • Number of kills
  • Incremented when player kills another player

Score.Deaths:

  • Number of deaths
  • Incremented when player dies

Score.Assists:

  • Number of assists
  • Placeholder (not implemented by default)

Score.Objectives:

  • Objective captures/completions
  • Game mode specific

Custom Tags:

  • Add your own tags for custom scoring
  • Example: Score.Headshots, Score.Revives, Score.DamageDealt

Final Game Score #

What Is Final Game Score:

Purpose:

  • Single calculated score value
  • Combines all stats with multipliers
  • Used for scoreboard ranking
  • Used for aggregate team scoring

Calculation:

For each score tag in player's Scores array:

  1. Get tag value (e.g., 10 kills)
  2. Get multiplier for that tag (e.g., 100 points per kill)
  3. Multiply: 10 × 100 = 1000
  4. Sum all results

Final Game Score = Sum of all (stat value × multiplier)

Example:

Player Stats:

  • Score.Kills: 15
  • Score.Deaths: 8
  • Score.Assists: 5

Multipliers:

  • Score.Kills: 100
  • Score.Deaths: -10
  • Score.Assists: 50

Calculation:

= (15 × 100) + (8 × -10) + (5 × 50)

= 1500 – 80 + 250

= 1670 Final Game Score

Stored In: Struct_PlayerScore->GameScore

Game score multipliers #

What Are Multipliers? #

Purpose:

Multipliers convert stat counts to point values.

Without Multipliers:

  • 10 kills = 10 (just a count)
  • No point values
  • No weighted scoring

With Multipliers:

  • 10 kills × 100 = 1000 points
  • 5 deaths × -10 = -50 points
  • Different actions worth different amounts

Multiplier Sources #

Where Multipliers Come From:

Primary Source – Game Settings:

From: DA_GameMode_Defaults (Game Mode System)

Process:

  1. Game Mode System loads game settings
  2. Game settings include score multipliers
  3. Score Manager reads multipliers from game settings
  4. Uses for all score calculations
Example (DA_GameMode_Defaults_TeamDeathmatch):
  • Kill Score: 100
  • Death Score: -10
  • Assist Score: 50

Score Manager loads these automatically.

Fallback Source – Predefined Multipliers:

If game settings not used:

  • Score Manager has predefined default multipliers
  • Configured in Score Manager component
  • Used when no game settings available
Example:

Predefined in Score Manager:

  • Score.Kills → 100
  • Score.Deaths → -10
  • Score.Assists → 50

Used when not using Game Mode System.

Manual Override:

You can also set multipliers manually:

  • Via Score Manager configuration
  • Via code

Useful for custom game modes without game settings.

Score Calculation #

How Scores Are Calculated:

When score tag updated:

  1. Player gets kill
  2. Score Manager increments Score.Kills (10 → 11)
  3. Recalculate Final Game Score:
 For each score tag:
 - Get tag value (Score.Kills = 11)
 - Get multiplier (Score.Kills → 100)
 - Multiply: 11 × 100 = 1100

 For all tags:
 - Score.Kills: 11 × 100 = 1100
 - Score.Deaths: 5 × -10 = -50
 - Score.Assists: 3 × 50 = 150

 Sum: 1100 - 50 + 150 = 1200 Final Game Score
  1. Update Struct_PlayerScore->GameScore = 1200
  2. If aggregate scoring: Update team score
  3. Fire OnPlayerScoreChanged event
  4. Show popup (+100 for the kill)

Automatic recalculation on every score change.

Scoring types #

Win-Based Scoring #

How Win-Based Scoring Works:

Purpose: Objective-based games

Behavior:

  • Player scores tracked and shown on scoreboard
  • Player scores do NOT add to team score
  • Game mode manually adds points to teams for objectives

Team Score Source: Manual (game mode adds points)

Example – Domination:

Player Stats (shown on scoreboard):

  • Player 1: 15 kills, 8 deaths → Final Game Score: 1420
  • Player 2: 10 kills, 5 deaths → Final Game Score: 950

Team Score (win-based):

  • NOT sum of player scores
  • Game mode adds points for capturing control points
  • Team A controls point: +10 points per second
  • Team A captures new point: +100 points
  • Team A reaches 200 points → Wins

Player Final Game Scores used for individual ranking only.

Team score from objectives only.

Game Mode Manually Adds Points:

In Domination Game Mode:

When control point captured:

ScoreManager->AddScoreToTeam(TeamIndex, 100)

Every second controlling point:

ScoreManager->AddScoreToTeam(TeamIndex, 10)

Result: Team score increases independently of player kills.

Aggregate Scoring #

How Aggregate Scoring Works:

Purpose: Kill-based games

Behavior:

  • Player scores tracked
  • Team score = sum of all player Final Game Scores on team
  • Automatic team score updates when player scores change

Team Score Source: Automatic (sum of players)

Example – Team Deathmatch:

Team A Players:

  • Player 1: Final Game Score: 1670
  • Player 2: Final Game Score: 1420
  • Player 3: Final Game Score: 980

Team A Score: 1670 + 1420 + 980 = 4070

Team B Players:

  • Player 4: Final Game Score: 1550
  • Player 5: Final Game Score: 1200
  • Player 6: Final Game Score: 890

Team B Score: 1550 + 1200 + 890 = 3640

Team A wins (higher total).

Updates:

  • Player 1 gets kill (+100 to Final Game Score)
  • Player 1: 1670 → 1770
  • Team A: 4070 → 4170 (automatic)

Automatic Team Score Calculation:

Score Manager handles automatically:

When player score changes (aggregate scoring enabled):

  1. Player Final Game Score updated
  2. Score Manager recalculates team score:
 - Get all players on this team
 - Sum their Final Game Scores
 - Update TeamScores[TeamIndex]
  1. Fire OnTeamScoreChanged event
  2. Game Mode checks win condition

No manual team scoring needed.

Configuring Scoring Type #

How to Set Scoring Type:

Option 1 – Game Settings (recommended):

In Session Manager / Game Mode System:

Game Setting: Scoring Type

  • Win-Based
  • Aggregate

Score Manager reads this setting automatically.

Example (DA_GameMode_Defaults_TeamDeathmatch):
  • Scoring Type: Aggregate
Example (DA_GameMode_Defaults_Domination):
  • Scoring Type: Win-Based

Option 2 – Manual Configuration:

In Score Manager component:

Set: Scoring Type

  • Win-Based
  • Aggregate

Used when not using Game Mode System.

Option 3 – Session Manager Setting:

Via Session Manager game settings:

Struct_GameSetting:

  • Settings Tag: Gameplay.ScoringType
  • Value: Win-Based or Aggregate

Score Manager reads from session settings.

Team scores #

Team Score Array #

How Team Scores Are Stored:

Data Structure: Array of Integers

Access: ScoreManager->TeamScores[TeamIndex]

Example:

TeamScores[0] = 5000 (Team A)

TeamScores[1] = 3200 (Team B)

TeamScores[2] = 4100 (Team C)

Index Matching:

  • Matches Team Manager team indices
  • Team A (index 0) → TeamScores[0]
  • Team B (index 1) → TeamScores[1]

Direct Access:

  • No getter function needed
  • Access array directly: ScoreManager->TeamScores[0]

Team Score Updates #

Win-Based Scoring Updates:

Manual Updates:

Function: AddScoreToTeam(TeamIndex, Amount)

Example:

// Domination: Team captures control point

ScoreManager->AddScoreToTeam(0, 100)

// Team A (index 0) gains 100 points

// Search and Destroy: Team detonates bomb

ScoreManager->AddScoreToTeam(1, 500)

// Team B (index 1) gains 500 points

Result:

  • TeamScores[TeamIndex] += Amount
  • Fire OnTeamScoreChanged event
  • Game Mode checks win condition

Aggregate Scoring Updates:

Automatic Updates:

When player score changes:

  1. Player Final Game Score updated
  2. Score Manager detects change
  3. If aggregate scoring:
 - Get player's team index
 - Recalculate team score (sum all players on team)
 - Update TeamScores[TeamIndex]
 - Fire OnTeamScoreChanged event

No manual calls needed.

Example:

Player 1 (Team A) gets kill:

  1. Player 1 Final Game Score: 1670 → 1770
  2. Recalculate Team A score:
 - Sum all Team A player scores
 - Team A: 4070 → 4170
  1. Fire OnTeamScoreChanged

Winning Score #

What Is Winning Score:

Purpose:

  • Track which team/player is currently winning
  • Used for aggregate scoring
  • Fires events when winner changes

How It Works:

  1. Player scores change
  2. Team scores recalculated (aggregate)
  3. Score Manager determines highest team score
  4. If different from previous winner:
 - Update winning score
 - Fire OnWinningScoreChanged event
  1. Game Mode responds to event (check win condition)
Example:

Team A: 4070

Team B: 3640

Winning Score: Team A (4070)

Player on Team B gets kill:

Team A: 4070

Team B: 3740

Winning Score: Still Team A

Player on Team B gets more kills:

Team A: 4070

Team B: 4200

Winning Score: Team B (4200) ← Changed!

OnWinningScoreChanged fired

Score tracking #

Binding to Player Manager #

How Score Manager Binds to Player Manager:

Score Manager BeginPlay:

  1. Get Player Manager reference:
 PlayerManager = GetOwner()->FindComponentByClass(AC_PlayerManager)
  1. Bind to events:
 PlayerManager->OnPlayerJoined.AddDynamic(this, &ThisClass::HandlePlayerJoin)
 PlayerManager->OnPlayerDied.AddDynamic(this, &ThisClass::HandlePlayerDeath)
 PlayerManager->OnPlayerKilledPlayer.AddDynamic(this, &ThisClass::HandlePlayerKill)
  1. Ready to track scores

This is why Player Manager must be bottom component:

  • Score Manager binds on BeginPlay
  • Player Manager initializes last
  • Score Manager ready to receive events

Kill Tracking #

How Kills Are Tracked:

Player Manager fires OnPlayerKilledPlayer:

Score Manager Receives Event:

  1. Get killer player name
  2. Get victim player name
  3. Find killer's score entry
  4. AddScoreToPlayer(KillerName, Score.Kills, 1)
  5. Increment Score.Kills value (10 → 11)
  6. Recalculate killer's Final Game Score
  7. If aggregate scoring: Update killer's team score
  8. Fire OnPlayerScoreChanged(KillerName, NewScore)
  9. Show popup to killer (+100)

Automatic, no game mode interaction needed.

Example:

Player “John” kills Player “Jane”:

  1. Player Manager: OnPlayerKilledPlayer(“John”, “Jane”)
  2. Score Manager: Add 1 to John's Score.Kills
  3. John's kills: 10 → 11
  4. Recalculate: 11 × 100 = 1100 (+ other scores)
  5. John's Final Game Score: 1670 → 1770
  6. John sees popup: “+100”

Death Tracking #

How Deaths Are Tracked:

Player Manager fires OnPlayerDied:

Score Manager Receives Event:

  1. Get dead player name
  2. Find player's score entry
  3. AddScoreToPlayer(PlayerName, Score.Deaths, 1)
  4. Increment Score.Deaths value (5 → 6)
  5. Recalculate player's Final Game Score
  6. If aggregate scoring: Update player's team score
  7. Fire OnPlayerScoreChanged(PlayerName, NewScore)
  8. Show popup to player (-10)

Automatic, no game mode interaction needed.

Example:

Player “John” dies:

  1. Player Manager: OnPlayerDied(“John”)
  2. Score Manager: Add 1 to John's Score.Deaths
  3. John's deaths: 5 → 6
  4. Recalculate: 6 × -10 = -60 (+ other scores)
  5. John's Final Game Score: 1770 → 1760
  6. John sees popup: “-10”

Assist Tracking #

Assist System Status:

Current State: Placeholder (not implemented)

What Exists:

  • Score.Assists tag
  • Assist Score multiplier
  • Score structure supports assists

What's NOT Implemented:

  • Automatic assist detection
  • Damage tracking for assists
  • Assist attribution logic

Purpose:

  • Provided for users to implement themselves
  • Framework exists, logic needs custom implementation

If You Want Assists:

  1. Track damage dealt by all players to target
  2. When player dies, check who damaged them
  3. Award assists to players who damaged but didn't kill
  4. Call AddScoreToPlayer(PlayerName, Score.Assists, 1)
  5. Score Manager handles rest (calculation, events, popups)

Score updates #

Adding Score to Player #

How to Add Score to Player:

Function: AddScoreToPlayer(PlayerName, ScoreTag, Amount)

Parameters:

  • PlayerName (String): Target player
  • ScoreTag (Gameplay Tag): Which score to update
  • Amount (Integer): Always 1 (increment by 1)

Behavior:

  1. Find player's score entry
  2. Find ScoreTag in player's Scores array
  3. Increment value by 1 (always +1, not Amount)
  4. Recalculate Final Game Score based on multipliers
  5. If aggregate scoring: Update team score
  6. Fire OnPlayerScoreChanged event
  7. Show popup (multiplier value, e.g., +100)
Example:

AddScoreToPlayer(“Player1”, Score.Objectives, 1)

Result:

  • Player1's Score.Objectives: 2 → 3 (incremented by 1)
  • Recalculate Final Game Score: +200 (objective multiplier)
  • Final Game Score: 1770 → 1970
  • Popup shows: “+200”
Note: Amount parameter always treated as 1.

Function always adds 1 to score tag value.

Adding Score to Team #

How to Add Score to Team:

Function: AddScoreToTeam(TeamIndex, Amount)

Parameters:

  • TeamIndex (Integer): Target team
  • Amount (Integer): Points to add

Behavior:

  1. Find team score: TeamScores[TeamIndex]
  2. Add amount: TeamScores[TeamIndex] += Amount
  3. Fire OnTeamScoreChanged event
  4. Game Mode checks win condition

Used For: Win-based scoring only

Example:

// Domination: Team A captures control point

AddScoreToTeam(0, 100)

Result:

  • Team A score: 5000 → 5100
  • OnTeamScoreChanged fired
  • Game Mode checks if 200 points reached (win condition)

// Search and Destroy: Team B detonates bomb

AddScoreToTeam(1, 500)

Result:

  • Team B score: 3200 → 3700
  • Event fired
  • Game Mode checks win

Automatic Updates #

What Updates Automatically:

Score Manager handles automatically:

Kill Tracking:

  • Player Manager: OnPlayerKilledPlayer
  • Score Manager: Add 1 to Score.Kills
  • Recalculate Final Game Score
  • Update team score (if aggregate)
  • Fire events
  • Show popup

Death Tracking:

  • Player Manager: OnPlayerDied
  • Score Manager: Add 1 to Score.Deaths
  • Recalculate Final Game Score
  • Update team score (if aggregate)
  • Fire events
  • Show popup

Aggregate Team Scoring:

  • Player Final Game Score changes
  • Score Manager recalculates team score
  • Sum all player scores on team
  • Update TeamScores array
  • Fire OnTeamScoreChanged

Winning Score (Aggregate):

  • Team scores change
  • Score Manager finds highest score
  • If different from previous: Fire OnWinningScoreChanged

Game Mode does NOT need to:

  • Track kills/deaths
  • Calculate scores
  • Update team scores (aggregate)
  • Check for winner changes (just bind to events)

Score calculation #

Single Score Calculation #

How Individual Scores Work:

Score Tag Value:

  • Raw count (number of times action performed)
  • Example: Score.Kills = 15 means 15 kills

Multiplier:

  • Points per action
  • Example: Score.Kills → 100 means 100 points per kill

Contribution to Final Game Score:

  • Value × Multiplier
  • Example: 15 × 100 = 1500 points

Each score tag contributes independently.

Final Game Score Calculation #

How Final Game Score Is Calculated:

Algorithm:

  1. Initialize: FinalScore = 0
  2. For each Struct_SingleScore in player's Scores array:
 - Get score tag (e.g., Score.Kills)
 - Get score value (e.g., 15)
 - Get multiplier for tag (e.g., 100)
 - Calculate: value × multiplier (15 × 100 = 1500)
 - Add to FinalScore: FinalScore += 1500
  1. Repeat for all score tags
  2. Store result in Struct_PlayerScore->GameScore
Example:

Player Scores Array:

  • {Tag: Score.Kills, Value: 15}
  • {Tag: Score.Deaths, Value: 8}
  • {Tag: Score.Assists, Value: 5}

Multipliers:

  • Score.Kills → 100
  • Score.Deaths → -10
  • Score.Assists → 50

Calculation:

FinalScore = 0

+ (15 × 100) = 0 + 1500 = 1500

+ (8 × -10) = 1500 – 80 = 1420

+ (5 × 50) = 1420 + 250 = 1670

Final Game Score: 1670

Team Score Calculation #

Win-Based Scoring:

Team score is independent of player scores.

Calculation: Manual only

  • Game mode calls AddScoreToTeam
  • No automatic calculation
Example:

Team A starts: 0

Capture point: AddScoreToTeam(0, 100) → 100

Control for 10 sec: AddScoreToTeam(0, 100) → 200

Capture another: AddScoreToTeam(0, 100) → 300

Team score based on objectives only.

Aggregate Scoring:

Team score is sum of player Final Game Scores.

Calculation: Automatic

  1. Get all players on team (from Team Manager)
  2. For each player:
 - Get their Final Game Score
 - Add to team total
  1. Store in TeamScores[TeamIndex]
Example:

Team A:

  • Player 1: Final Game Score: 1670
  • Player 2: Final Game Score: 1420
  • Player 3: Final Game Score: 980

Team A Score = 1670 + 1420 + 980 = 4070

Updates automatically when any player score changes.

Score reset #

Between Games #

How Scores Reset Between Games:

When: New map loads (next game in playlist)

What Resets:

  • All player scores (kills, deaths, assists, objectives)
  • All player Final Game Scores
  • All team scores
  • Winning score

How It Works:

  • Automatic (no manual reset needed)
  • New map loads → Score Manager reinitializes
  • All score arrays cleared
  • Players rejoin → New score entries created
  • Scores start at 0
Example:

Game 1 End:

  • Player 1: 15 kills, 8 deaths, Final Score: 1670
  • Team A: 4070

Game 2 Start (new map):

  • Player 1: 0 kills, 0 deaths, Final Score: 0
  • Team A: 0

Fresh start for new game.

Between Rounds #

How Scores Work in Round-Based Games:

Scores Do NOT Reset Between Rounds:

Reason: Round-based games use win-based scoring

  • Player scores shown on scoreboard
  • Player scores NOT used for round winner
  • Round winner based on round-specific objectives
  • Player stats accumulated across all rounds
Example – Search and Destroy:

Round 1:

  • Player 1: 3 kills, 1 death

Round 2:

  • Player 1: 5 kills total, 2 deaths total
  • Scores accumulated, not reset

Round 3:

  • Player 1: 8 kills total, 3 deaths total
  • Continue accumulating

Game End:

  • Player 1 final stats: 15 kills, 8 deaths
  • Final Game Score: 1420
  • Shown on scoreboard

Scores persist across rounds.

Only reset when game ends (new map loads).

Winning score system #

What Is Winning Score? #

Purpose:

Track which team/player is currently winning.

Used in aggregate scoring mode.

Fires events when winner changes.

Aggregate Scoring Winner #

How Winning Score Works:

In Aggregate Scoring:

  1. Player scores change
  2. Team scores recalculated (sum of player scores)
  3. Score Manager finds highest team score
  4. If highest score changed or winner changed:
 - Update winning score
 - Fire OnWinningScoreChanged event
  1. Game Mode binds to event
  2. Game Mode checks win condition
Example:

Initial:

Team A: 4070 (winning)

Team B: 3640

Player on Team B gets kills:

Team A: 4070

Team B: 4200 (now winning)

OnWinningScoreChanged fired (Team B now winning)

Game Mode Response:

  • Receive OnWinningScoreChanged
  • Check if win condition met (e.g., 5000 points)
  • If not: Continue game
  • If yes: End game, Team B wins

Event dispatchers #

OnPlayerScoreChanged #

When Event Fires:

Event: OnPlayerScoreChanged

Fires When:

  • Player's Final Game Score changes
  • Any score tag updated (kills, deaths, objectives, etc.)

Data Provided:

  • Player name (String)
  • New Final Game Score (Integer)

Use Cases:

  • Update scoreboard
  • Check win conditions (Free for All)
  • Display player ranking
  • Custom logic on score change
Example Binding:

ScoreManager->OnPlayerScoreChanged.AddDynamic(this, &ThisClass::HandleScoreChange)

void HandleScoreChange(FString PlayerName, int NewScore)

{

 // Update scoreboard for this player
 UpdateScoreboardPlayer(PlayerName, NewScore);

}

OnTeamScoreChanged #

When Event Fires:

Event: OnTeamScoreChanged

Fires When:

  • Team score changes
  • Win-based: AddScoreToTeam called
  • Aggregate: Player score changes → team score recalculated

Data Provided:

  • Team index (Integer)
  • New team score (Integer)

Use Cases:

  • Update scoreboard
  • Check win conditions (team-based games)
  • Display team ranking
  • Game Mode win checking
Example Binding:

ScoreManager->OnTeamScoreChanged.AddDynamic(this, &ThisClass::HandleTeamScoreChange)

void HandleTeamScoreChange(int TeamIndex, int NewScore)

{

 // Check if team reached win condition
 if (NewScore >= WinRequirement)
 {
 EndGame(TeamIndex); // Team wins
 }

}

OnWinningScoreChanged #

When Event Fires:

Event: OnWinningScoreChanged

Fires When:

  • Winning team/player changes (aggregate scoring)
  • Highest score changes

Data Provided:

  • Team/player with highest score
  • New winning score value

Use Cases:

  • Game Mode win checking
  • Display “Team A is winning” message
  • Update UI with leader
Example Binding:

ScoreManager->OnWinningScoreChanged.AddDynamic(this, &ThisClass::HandleWinningChange)

void HandleWinningChange(int WinningTeam, int WinningScore)

{

 // Check if winning score met win condition
 if (WinningScore >= WinRequirement)
 {
 EndGame(WinningTeam);
 }

 // Or just display leader
 ShowLeaderMessage(WinningTeam);

}

Utility functions #

Player Score Functions #

GetAllPlayerScores:

Function: GetAllPlayerScores()

Returns: Array of Struct_PlayerScore

Description:

  • Returns all player score entries
  • Includes player name, scores array, Final Game Score
Example:

AllScores = ScoreManager->GetAllPlayerScores()

// Returns: [{Player1, […], 1670}, {Player2, […], 1420}, …]

Use Cases:

  • Display full scoreboard
  • Iterate over all player scores
  • Find top players

FindPlayerScoreIndex:

Function: FindPlayerScoreIndex(PlayerName)

Parameters: Player name (String)

Returns: Index in PlayerScores array (Integer)

Description:

  • Finds index of player in PlayerScores array
  • Returns -1 if not found
Example:

Index = ScoreManager->FindPlayerScoreIndex(“Player1”)

// Returns: 0 (if Player1 is first in array)

Use Cases:

  • Look up player score entry
  • Validate player exists in scores

FindScoreInScoreArray:

Function: FindScoreInScoreArray(PlayerName, ScoreTag)

Parameters:

  • Player name (String)
  • Score tag (Gameplay Tag)

Returns: Score value (Integer)

Description:

  • Finds specific score tag value for player
  • Returns 0 if not found
Example:

Kills = ScoreManager->FindScoreInScoreArray(“Player1”, Score.Kills)

// Returns: 15 (Player1 has 15 kills)

Deaths = ScoreManager->FindScoreInScoreArray(“Player1”, Score.Deaths)

// Returns: 8 (Player1 has 8 deaths)

Use Cases:

  • Get specific stat for player
  • Display individual stats
  • Query kills/deaths/assists

Team Score Access #

Direct Array Access:

Team scores accessed directly (no getter function):

Access: ScoreManager->TeamScores[TeamIndex]

Example:

// Get Team A score

TeamAScore = ScoreManager->TeamScores[0]

// Get Team B score

TeamBScore = ScoreManager->TeamScores[1]

// Set Team C score (manual)

ScoreManager->TeamScores[2] = 5000

Use Cases:

  • Quick team score lookup
  • Compare team scores
  • Manual score setting

Integration with other systems #

Player Manager Integration #

How They Work Together:

Player Manager Provides:

  • OnPlayerJoined event
  • OnPlayerDied event
  • OnPlayerKilledPlayer event
  • Connected players list

Score Manager Uses:

  1. Bind to OnPlayerJoined:
 - Create Struct_PlayerScore entry for new player
 - Initialize all score tags to 0
  1. Bind to OnPlayerDied:
 - Increment player's Score.Deaths
 - Recalculate Final Game Score
 - Update team score (if aggregate)
  1. Bind to OnPlayerKilledPlayer:
 - Increment killer's Score.Kills
 - Recalculate killer's Final Game Score
 - Update team score (if aggregate)

Critical Dependency:

  • Score Manager REQUIRES Player Manager
  • Cannot function without it
  • Player Manager must be below Score Manager in component list

Team Manager Integration #

How They Work Together:

Team Manager Provides:

  • Team structure
  • Team indices
  • Team member lists

Score Manager Uses:

  1. Team indices for team scores array:
 - TeamScores[0] = Team A score
 - TeamScores[1] = Team B score
  1. Team member lists for aggregate scoring:
 - Get all players on team
 - Sum their Final Game Scores
 - Update team score
  1. Team removal:
 - If Team Manager deletes team
 - Score Manager removes team score from array

Direction:

  • Score Manager depends on Team Manager for team data
  • Team Manager does NOT depend on Score Manager

Game Mode System Integration #

How They Work Together:

Game Mode System Provides:

  • Game settings (score multipliers, scoring type)
  • Win condition checking

Score Manager Provides:

  • Score data (player scores, team scores)
  • Score events (OnTeamScoreChanged, OnWinningScoreChanged)

Integration:

  1. Score Manager loads multipliers from game settings
  2. Score Manager loads scoring type from game settings
  3. Game Mode binds to score events:
 - OnTeamScoreChanged: Check if team reached win score
 - OnWinningScoreChanged: Check if winner met condition
  1. Game Mode queries scores:
 - Get team scores for win determination
 - Get player scores for individual ranking

Win-Based Scoring:

  • Game Mode calls AddScoreToTeam for objectives
  • Score Manager fires events
  • Game Mode checks win condition

Aggregate Scoring:

  • Score Manager calculates team scores automatically
  • Score Manager fires events
  • Game Mode checks win condition

Scoreboard Integration #

How Scoreboard Uses Score Manager:

Scoreboard (from Player Manager) displays:

  • Player name
  • Score (Final Game Score)
  • Kills (Score.Kills value)
  • Deaths (Score.Deaths value)
  • Assists (Score.Assists value)
  • Ping (from PlayerState)

Data Source: Score Manager

Scoreboard queries Score Manager for all score data.

Score Manager provides all stats for display.

How to guides #

Setting Up Score Manager #

Step 1 – Add Components: #

On GameState:

  1. Open GameState blueprint
  2. Add components in order:
 - AC_SessionManager (if used)
 - AC_TeamManager (if used)
 - AC_ScoreManager ← Above Player Manager
 - AC_PlayerManager ← MUST be bottom
  1. Verify component order
  2. Save

On PlayerController:

  1. Open PlayerController blueprint
  2. Add component: AC_ScoreCommunicator
  3. Save

Step 2 – Configure Score Manager: #

In GameState, select AC_ScoreManager component:

If using Game Mode System:

  • Scoring type loaded from game settings automatically
  • Multipliers loaded from DA_GameMode_Defaults automatically

If NOT using Game Mode System:

  • Set Scoring Type manually: Aggregate or Win-Based
  • Configure Game Score Multipliers:
 - Score.Kills → 100
 - Score.Deaths → -10
 - Score.Assists → 50
 - etc.

Save GameState.

Step 3 – Test: #

  1. Host session
  2. Join with two players
  3. Player 1 kills Player 2:
 - Verify Player 1 Score.Kills increments
 - Verify Player 1 Final Game Score increases
 - Verify popup shows "+100"
 - Verify Player 2 Score.Deaths increments
 - Verify Player 2 popup shows "-10"
  1. Open scoreboard (P key):
 - Verify kills/deaths shown correctly
 - Verify scores displayed
  1. Check team scores (if aggregate):
 - Verify team scores = sum of player scores

Adding Custom Score Tags #

Step 1 – Create Gameplay Tags: #

In Project Settings or Gameplay Tags:

Add tags:

  • Score.Headshots
  • Score.Revives
  • Score.DamageDealt
  • Score.ObjectivesCaptured

Save.

Step 2 – Add Multipliers: #

In DA_GameMode_Defaults or Score Manager:

Add multipliers:

  • Score.Headshots → 200 (bonus for headshots)
  • Score.Revives → 150 (points for reviving teammate)
  • Score.DamageDealt → 1 (1 point per damage)
  • Score.ObjectivesCaptured → 300

Save.

Step 3 – Add Scores in Game: #

In your game logic:

When player gets headshot kill:

ScoreManager->AddScoreToPlayer(PlayerName, Score.Headshots, 1)

Result:

  • Score.Headshots: 0 → 1
  • Final Game Score: +200 (headshot multiplier)
  • Popup: “+200”

When player revives teammate:

ScoreManager->AddScoreToPlayer(PlayerName, Score.Revives, 1)

Result:

  • Score.Revives: 0 → 1
  • Final Game Score: +150
  • Popup: “+150”

Score Manager handles calculation and events automatically.

Implementing Score UI #

Step 1 – Create Score Widget: #

  1. Create widget: WBP_ScoreDisplay
  2. Layout:
 ┌─────────────────────────┐
 │ Your Score: 1670 │
 │ Kills: 15 Deaths: 8 │
 │ Team Score: 4070 │
 └─────────────────────────┘

Step 2 – Bind to Score Events: #

In WBP_ScoreDisplay:

On Widget Constructed:

  1. Get Score Manager reference
  2. Bind to OnPlayerScoreChanged:
 ScoreManager->OnPlayerScoreChanged.AddDynamic(this, &ThisClass::UpdateScore)
  1. Bind to OnTeamScoreChanged (if team game):
 ScoreManager->OnTeamScoreChanged.AddDynamic(this, &ThisClass::UpdateTeamScore)

Initial Display:

  1. Get your player name (from PlayerState)
  2. Find your score:
 MyScore = ScoreManager->FindScoreInScoreArray(MyName, Score.Kills)
  1. Display stats

Step 3 – Implement Update Functions: #

void UpdateScore(FString PlayerName, int NewScore)

{

 // Only update if it's your score
 if (PlayerName == MyPlayerName)
 {
 // Update Final Game Score display
 ScoreText->SetText(NewScore);

 // Update kill/death display
 Kills = ScoreManager->FindScoreInScoreArray(MyName, Score.Kills)
 Deaths = ScoreManager->FindScoreInScoreArray(MyName, Score.Deaths)
 KillsText->SetText(Kills);
 DeathsText->SetText(Deaths);
 }

}

void UpdateTeamScore(int TeamIndex, int NewScore)

{

 // Only update if it's your team
 if (TeamIndex == MyTeamIndex)
 {
 TeamScoreText->SetText(NewScore);
 }

}

Result: Real-time score display updates.

Querying Score Data #

Example – Get Top 3 Players:

Function: GetTopPlayers(Count)

Implementation:

TArray GetTopPlayers(int Count)

{

 // Get all player scores
 AllScores = ScoreManager->GetAllPlayerScores();

 // Sort by Final Game Score (descending)
 AllScores.Sort([](const FStruct_PlayerScore& A, const FStruct_PlayerScore& B)
 {
 return A.GameScore > B.GameScore;
 });

 // Return top Count players
 TArray TopPlayers;
 for (int i = 0; i < Count && i < AllScores.Num(); i++)
 {
 TopPlayers.Add(AllScores[i]);
 }

 return TopPlayers;

}

Usage:

TopThree = GetTopPlayers(3)

// Returns top 3 players by Final Game Score

Display:

1st: Player1 (1670 points)

2nd: Player2 (1550 points)

3rd: Player3 (1420 points)

Example - Get Player K/D Ratio:

Function: GetKDRatio(PlayerName)

Implementation:

float GetKDRatio(FString PlayerName)

{

 // Get kills
 Kills = ScoreManager->FindScoreInScoreArray(PlayerName, Score.Kills);

 // Get deaths
 Deaths = ScoreManager->FindScoreInScoreArray(PlayerName, Score.Deaths);

 // Calculate ratio
 if (Deaths == 0)
 return Kills; // Avoid divide by zero

 return (float)Kills / (float)Deaths;

}

Usage:

KD = GetKDRatio("Player1")

// Returns: 1.875 (15 kills / 8 deaths)

Display: "K/D: 1.88"

  • --

END OF DOCUMENTATION

Summary:

The Score Manager System provides centralized score tracking and calculation:

Core Components:

  • AC_ScoreManager (GameState, above PlayerManager): Score tracking, calculation, events
  • AC_ScoreCommunicator (PlayerController): Score popups (+100, -10, etc.)

Key Features:

  • Player Scores: Struct_PlayerScore (Player Name, Scores array of Struct_SingleScore, Game Score integer)
  • Score Tags: Struct_SingleScore (Gameplay Tag, Value integer) - Score.Kills = 10 means 10 kills
  • Game Score Multipliers: Map of Gameplay Tag → Integer (Score.Kills → 100 points per kill)
  • Final Game Score: Calculated by summing (score tag value × multiplier) for all tags
  • Team Scores: Integer array, index matches Team Manager team index
  • Scoring Types: Win-based (game mode adds points manually) or Aggregate (sum of player Final Game Scores)
  • Automatic Tracking: Binds to Player Manager OnPlayerDied/OnPlayerKilledPlayer, increments score tags
  • Score Calculation: Automatic recalculation of Final Game Score when any tag changes
  • Winning Score: Tracks which team/player is winning (aggregate scoring)
  • Score Reset: Automatic between games (new map load), NOT between rounds
  • Events: OnPlayerScoreChanged, OnTeamScoreChanged, OnWinningScoreChanged

Score Flow: Player gets kill → Score.Kills +1 → Final Game Score recalculated (kills × 100) → Team score updated (if aggregate) → Events fired → Popup shown (+100)

Integration: Binds to Player Manager for kill/death tracking; uses Team Manager for team indices; provides score data for Game Mode System win checking; provides stats for scoreboard display.

Complete score tracking for any multiplayer game!

What are your Feelings