```html Graphic View Score System - Comprehensive Documentation

Graphic View Score System

Visual, Dynamic, and Modular Scoring for Online Games

Unity Integration

GraphView API

Real-Time Evaluation

Instant Feedback

Modular Design

Extensible Architecture

A node-based scoring system that allows developers to visualize, customize, and optimize game scoring in real time. Traditional hardcoded scoring is inflexible and hard to maintain. With Graphic View Score System, create complex scoring logic through an intuitive visual interface without constant code changes.

Node-Based Editor
Real-Time Evaluation
Unity GraphView Integration
Explore the System Back to Works
Graphic View Score System Visualization
Unity Node System Scoring
Old vs New Scoring System

Why We Created the Graphic View Score System

Our online games need a flexible scoring system that can handle complex logic, multiple player actions, and dynamic events. Traditional hardcoded scoring is inflexible and hard to maintain.

With Graphic View Score System, we built a node-based editor that allows developers to visualize, customize, and optimize game scoring in real time. This system has been successfully implemented in multiple online games, including HoGo Hot Mini Games Hub.

Key Innovation

The system bridges the gap between game designers and programmers by providing a visual interface for scoring logic that requires minimal coding knowledge while maintaining technical precision.

Core Scripts

The foundation of the Graphic View Score System

Example Implementation

A simple node structure for calculating scores in a mini-game:

// Score Node Implementation
public class RewardNodeView : BaseNodeView
{
        public int rewardAmount = 10;
        public string rewardType = "Coins";

        private IntegerField rewardField;
        private TextField typeField;

        public override void Initialize(string titleText, Vector2 position, string type = "Reward")
        {
            base.Initialize("Reward", position, type);

            AddInputPort("In", typeof(bool), Port.Capacity.Multi, false, isStaticPort: true);

            RefreshExpandedState();
            RefreshPorts();
        }

}
Unity C# GraphView API Event-Driven
▶
⚡
?
⚙️

Node Types

The building blocks of the scoring system

E

EntryNode

Starting point for score flow. Initializes score evaluation process.

Properties: StartValue, AutoTrigger

Events: OnEvaluationStart

FLOW STARTER
EV

EventNode

Represents player/game events (Collect Coin, Kill Enemy). Outputs score changes.

Properties: EventName, Points, Multiplier

Events: OnEventTriggered

TRIGGER POINT
C

ConditionNode

Branching logic (if score > X then …). Allows complex conditions and decision trees.

Properties: ConditionType, Threshold, Comparison

Events: OnConditionMet, OnConditionFailed

DECISION MAKER
A

ActionNode

Executes scoring actions (AddPoints, MultiplyPoints, ApplyBonus).

Properties: ActionType, Value, Duration

Events: OnActionCompleted

EXECUTION UNIT
O

OutputNode

Final node to collect and display score result. Connects to UI systems.

Properties: OutputFormat, DisplayStyle

Events: OnScoreFinalized

RESULT TERMINAL
C

CustomNode

Extendable base for specialized scoring logic. Developers can create custom implementations.

Properties: CustomData, ScriptReference

Events: OnCustomEvent

EXTENSION POINT

System Features

Comprehensive functionality for modern game development

Real-time Evaluation

Nodes update scores instantly as the game runs. Developers can see calculations happening in real-time.

Drag-and-Drop Interface

Intuitive drag-and-drop for node creation and connection. No coding required for basic setup.

Copy/Paste/Duplicate

Full clipboard support with keyboard shortcuts (Ctrl+C/V) for efficient workflow.

Undo/Redo Support

Complete history management with unlimited undo/redo operations for safe experimentation.

Validation System

Automatic detection of broken edges, invalid connections, and null references with visual feedback.

Searchable Node Palette

Quick search to add new nodes by typing their names. Contextual suggestions based on current graph state.

Save/Load Graphs

Persist graphs as assets for reuse across projects. Supports multiple save formats and versioning.

Custom Styles (USS)

Theming support with Unity Style Sheets. Different visual styles for different node categories.

Edge Highlighting

Visual feedback when hovering over or selecting edges. Shows data flow direction and status.

Integration & Usage

How to implement the system in your projects

In-Game Use

1

Attach ScoreEvaluationManager

Add to a GameObject in your scene

2

Load Saved Graph Asset

Assign your .asset file to the manager

3

Connect Game Events

Link enemy kills, item collection, etc. to EventNodes

4

Start Evaluation

Call Evaluate() method when needed

With UI Systems

1

Bind OnScoreUpdated Event

Subscribe to receive score changes

2

Update UI Elements

Send values to Text, Slider, or Progress Bar components

3

Show Visual Feedback

Animate UI when scores change significantly

4

Handle Final Scores

Process results from OutputNode for end-game screens

Multiplayer Extension

To extend the system for multiplayer games:

  • Extend ScoreEvaluationManager to sync scoring across network using Photon, Mirror, or Netcode
  • Add timestamp validation to prevent cheating
  • Implement server-side verification for critical scoring events
  • Support partial graph synchronization for performance
  • Add latency compensation for real-time multiplayer experiences

Key Benefits

Why this approach transforms game development

Visual Logic Building

Create complex scoring rules without writing code. Perfect for designers and non-programmers.

Fast Iteration

Rapidly test and modify scoring rules. Change mechanics in minutes instead of hours.

Debug-Friendly

See exactly which node failed or caused issues. Visual debugging saves hours of troubleshooting.

Extensible Architecture

Add custom node types and behaviors. The system grows with your project requirements.

Reusable Graphs

Save and share scoring systems across multiple games. Create templates for common patterns.

Energy Flow Visualization

Watch data flow through the system with animated energy particles showing the exact path of score calculation.

How It Works

The visual flow of data through the scoring system

Score Flow Visualization

Step-by-Step Process:

  1. Entry Node activates the scoring system
  2. Event Node triggers when a player action occurs
  3. Condition Node evaluates if conditions are met
  4. If conditions are true, Action Node calculates score
  5. If conditions are false, system follows alternative path
  6. Output Node sends final score to UI

Energy Flow Concept

The system visualizes data flow as energy moving through the graph. When a node is activated, energy pulses along connected edges to subsequent nodes, creating a clear visual representation of the execution path.

This visualization helps developers understand exactly how scoring is calculated and where issues might be occurring in complex scoring logic.

Pro Tip: Watch the energy flow when debugging to see exactly which path your scoring logic is taking through the graph.

Real-Time Evaluation

As you modify nodes or connections, the system instantly recalculates the score and visualizes the changes. This immediate feedback loop enables rapid iteration and testing of scoring rules. 

// Example of real-time evaluation
public void UpdateScore() {
    var result = entryNode.Evaluate();
    Debug.Log($"Current Score: {result}");
    uiManager.UpdateScoreDisplay(result);
}

The evaluation process follows the graph connections, passing data from node to node until reaching the output, with each node potentially modifying the score value.

Practical Examples

Real-world implementations of the scoring system

1

Coin Collection System

A simple scoring system where players collect coins to earn points. Each coin adds 10 points to the score.

Node Structure:

  • • EntryNode → Starts scoring process
  • • EventNode (CoinCollected) → Triggered when coin is collected
  • • ActionNode (AddPoints) → Adds 10 points to score
  • • OutputNode → Sends final score to UI

Implementation: This basic system can be set up in under 5 minutes using drag-and-drop, making it perfect for rapid prototyping.

2

Combo Scoring System

A more complex system that rewards players for consecutive actions with increasing multipliers.

Node Structure:

  • • EntryNode → Starts combo system
  • • EventNode (ActionCompleted) → Triggered on each action
  • • ConditionNode (TimeSinceLastAction < 2s) → Checks for combo window
  • • ActionNode (IncrementCombo) → Increases combo counter
  • • ActionNode (CalculateMultiplier) → Applies combo multiplier
  • • OutputNode → Sends final score with multiplier

Implementation: This system demonstrates the power of conditional logic in the node system, creating engaging gameplay mechanics with visual programming.

3

Multi-Stage Puzzle Scoring

A sophisticated scoring system for a puzzle game with multiple stages, time bonuses, and perfect run rewards.

Scoring Logic:

  • • Base score for completing each puzzle stage
  • • Time bonus for completing under target time
  • • Perfect run bonus for no mistakes
  • • Multiplier for consecutive perfect runs
  • • Stage completion bonuses

Challenge: This complex scoring system would require significant code without the node system, but with our visual approach, it's intuitive and easy to modify.

Node Implementation:

Entry StageComplete TimeCheck AddBaseScore AddTimeBonus PerfectRunCheck AddPerfectBonus StreakCheck ApplyStreak Output

The visual layout clearly shows the branching logic and data flow through the complex scoring system.

Over 15 connected nodes in this example implementation

Bring Smarter Scoring to Your Games

See the Graphic View Score System in action or contact us to implement it in your game

View Demo Contact Us
Unity 6000.1+ Node Graph Visual Scripting Game Development