GLOSSARY
Metaplay terminology
Definitions for key concepts in Metaplay and live service game development.
A/B Testing
A method for comparing two or more variants of game features, configs, or experiences to determine which performs better. Metaplay supports A/B testing through experiments and player segments.
Action
An atomic operation that modifies player state. Actions run on both client (for prediction) and server (for validation). They must be deterministic to ensure consistent results.
Actor Model
The concurrency model used by Metaplay's game server. Each entity (player, guild) runs as an independent actor, enabling horizontal scaling without shared state.
Analytics Events
Game-defined events that are logged for analysis. Analytics events can be streamed to external storage like BigQuery or S3 for processing and visualization.
Auto-Renewing Subscriptions
Subscription purchases that automatically renew on a recurring basis. Metaplay provides server-side validation and management of subscription states, including renewal tracking and expiration handling.
BigQuery
Google's data warehouse service that can be used to store and analyze analytics events from Metaplay games. Supports streaming data export for real-time analytics.
BotClient
A headless client system for load testing and automated testing. BotClient allows you to simulate many concurrent players to test server performance and game logic.
Broadcasts
In-game messages sent to players through the LiveOps Dashboard. Broadcasts can be targeted to specific player segments and scheduled for delivery.
Client Patches
Client-only hotfixes that can be deployed without a full app store update. The server controls which client patch versions are accepted, allowing for staged rollouts.
Client-Side Prediction
The technique of running game logic locally on the client for instant feedback, while the server validates and can override the results. Enables responsive gameplay in a server-authoritative model.
Commit ID Check
A mechanism to prevent clients built from different source code versions from connecting to the server. Ensures client-server compatibility and prevents version mismatches.
Database Scan Jobs
Operations that scan all entities of a type in the database to perform bulk operations. Used for migrations, analytics, and maintenance tasks.
Deterministic Collections
Collections that maintain a consistent iteration order across all platforms and instances. Required for deterministic game logic. Examples include MetaDictionary and OrderedSet.
Deterministic Execution
The requirement that game logic produces identical results on both client and server. Achieved through fixed-point math, deterministic collections, and seeded random number generation.
Dynamic Scaling
The ability to automatically adjust the number of server nodes based on backend load. Metaplay supports dynamic scaling for workload entities to handle traffic spikes.
Entity
A persistent game object managed by the server. Players and Guilds are built-in entity types. Custom entities can be created for game-specific needs like matches or chat rooms.
EntityAsk
A request-response pattern for entity-to-entity communication. Provides synchronous communication with timeout handling and error propagation. The response bypasses the normal message queue.
Entity Export/Import
The ability to export entities (players, guilds) from the database and import them into another environment. Used for testing, debugging, and player support.
EntityKind
The type classification for entities. Built-in kinds include Player and Guild. Each EntityKind defines its own state model, actions, and server-side behavior.
Entity Shard Group
Groups that determine the initialization order of entities. BaseServices initializes first, followed by ServiceProxies, then Workloads. Most entities use the Workloads group.
Ephemeral Entity
An entity that exists only while running. Its state is not persisted, and the entity is removed from the system when it stops. Used for temporary service entities.
Environment Configs
Client-side configuration that varies by environment (dev, staging, production). Includes server endpoints and other environment-specific values. Configured separately from game configs.
Experiments
Controlled studies of how changes to game configs affect players. Experiments assign players to variants and track results for statistical analysis. Used for A/B testing.
Fixed-Point Math
Numerical calculations using fixed-point arithmetic instead of floating-point. Ensures deterministic results across platforms. Metaplay provides F32 and F64 fixed-point types.
GameConfig
Type-safe static game data (items, levels, balancing) that can be updated over-the-air without a client update. Supports validation, versioning, and multiple source formats.
GameConfig Archive
A file containing a collection of GameConfig Libraries as binary serialized data. Archives group related configs as a single atomic unit for distribution and deployment.
GameConfigLibrary
The collection of all GameConfig data for a game. Contains multiple config sheets (items, rewards, etc.) and handles loading, validation, and hot-swapping.
GDPR Compliance
Features for complying with the General Data Protection Regulation. Includes player data export for data portability requests and player account deletion capabilities.
Guild
A built-in entity type for player groups or alliances. Metaplay provides a framework for implementing guilds with features like invites, member management, and guild-specific state.
GuildModel
The server-authoritative data structure containing all guild state. Similar to PlayerModel but for guild entities. Modified through guild-specific actions.
In-App Purchases (IAP)
Purchases made within the game, validated server-side. Metaplay supports purchases from Apple App Store, Google Play, Steam, and custom stores. Includes purchase validation and receipt handling.
In-Game Events
Time-limited events that can be configured and scheduled through the LiveOps Dashboard. Events support player segment targeting and calendar-based activation.
In-Game Mail
A messaging system for sending messages and rewards to players. Can be configured through the LiveOps Dashboard and supports player segment targeting.
In-Game Offers
Promotional offers that can be configured and scheduled through the LiveOps Dashboard. Offers can be targeted to specific player segments and include dynamic pricing.
Leagues
A season-based leaderboard system that matches players against opponents of similar rank. Supports progression, competition, and rewards based on performance.
LiveOps Dashboard
The web-based administration interface for managing your live game. Used for player support, config editing, A/B testing, event scheduling, and analytics.
LiveOps Events
Config-driven events that can be scheduled and configured via the LiveOps Dashboard. Events support player segment targeting, calendar-based schedules, and dynamic content.
LiveOps Timeline
A timeline view in the LiveOps Dashboard for monitoring and interacting with time-related items like events, offers, and maintenance windows.
Load Balancing
The distribution of entity workload across server nodes. Metaplay provides tools for balancing load between nodes and configuring cluster topology for optimal performance.
Localization
The process of translating game content into multiple languages. Metaplay's localization system supports config-driven translations that can be updated over-the-air.
Logic Version
A mechanism for evolving game logic while maintaining backward compatibility. Logic versions allow different code paths based on when a player's state was created.
Matchmaking
The process of pairing players for multiplayer sessions. Metaplay provides both synchronous and asynchronous matchmaking systems with customizable algorithms.
MetaplayClient
The Unity client-side component that manages connection to the game server, state synchronization, and action execution.
MetaRewards
Built-in reward classes for common game currencies and items. Provides type-safe reward handling and simplifies reward distribution logic.
MetaTime
Metaplay's deterministic time class. Replaces System.DateTime to ensure consistent time representation across client and server. Essential for deterministic execution.
Model Inspector
A Unity editor window that displays the current model's properties while in Play Mode. Useful for debugging and inspecting player state during development.
Multiplayer Entities
Custom entities designed for multiplayer game features. Enable real-time synchronization between multiple players in shared game sessions.
Node Set Placement
Configuration that determines which cluster nodes an entity type should run on. Options include Service (singleton entities), Logic (scalable entities), and All (all nodes).
Over-the-Air Updates
The ability to push game changes (configs, events, offers) to live players without an app store update. Changes take effect when players next connect to the server.
Persisted Entity
An entity whose state is stored in the database when not running. The entity can be woken up on demand and will restore its state. Players and Guilds are persisted entities.
Player Banning
The ability to ban players from accessing the game. Metaplay provides infrastructure for implementing player bans with customizable ban logic and appeal processes.
Player Deletion
The process of permanently deleting a player's account and data. Required for GDPR compliance. Metaplay handles most of the deletion logic with customization hooks.
Player IP Geolocation
Server-side detection of player geographic location based on IP address. Useful for region-based features, compliance, and analytics.
Player Segments
Dynamic player groups based on attributes or behavior. Used for targeting content, offers, and experiments to specific audiences.
PlayerModel
The core data structure representing all server-authoritative player state. Automatically serialized, persisted, and migrated. Modified through Actions.
Push Notifications
Notifications sent to players' devices outside of the game. Can be configured through the LiveOps Dashboard and targeted to specific player segments.
RandomPCG
Metaplay's deterministic random number generator. Provides high-quality RNG with a tiny memory footprint and ensures identical random sequences on client and server.
Runtime Options
Configuration data that varies by environment and deployment. Set through multiple sources including environment variables, config files, and cloud platform secrets.
Sandbox Purchases
Test purchases made in sandbox environments (e.g., Apple's sandbox test environment). Metaplay can be configured to accept sandbox purchases for testing purposes.
Schema Migration
The process of evolving data structures over time. Metaplay automatically handles adding new fields and supports custom migration code for complex changes.
Session
An active connection between a game client and the server. Sessions handle message routing, reconnection, and maintain client-server state consistency.
Subscriptions
Recurring purchases that provide ongoing access to content or features. Metaplay supports auto-renewing subscriptions with server-side validation and state management.
Testing
Metaplay provides multiple testing frameworks including .NET unit tests, Playwright tests for the LiveOps Dashboard, system tests, and BotClient for load testing.
Tick
A unit of logical time in Metaplay. Ticks provide deterministic time progression independent of wall-clock time, ensuring consistent simulation results.
Time Skip
A testing feature that allows setting the server's time to the future. Useful for testing scheduled events, timers, and time-based game logic without waiting.
UDP Passthrough
The ability to implement a UDP server embedded within a Metaplay backend. Useful for real-time multiplayer games requiring low-latency UDP communication.
Learn more in the docs
Each concept is covered in depth in our documentation with examples and best practices.
Explore documentation
Social Logins
Authentication methods that use external platforms like Apple Game Center, Google Sign-In, Facebook Login, or Steam. Metaplay provides integration for multiple social login providers.