### Sample Projects

Source: https://llm-docs.platform.metaplay.dev/docs/index

Starter projects and examples demonstrating Metaplay features.

```APIDOC
## Sample Projects

### Starter Projects

- **samples/helloworld/index.md**: Hello World Sample - A minimal starter project that scaffolds a new Metaplay-powered game.
- **samples/idler/index.md**: Idler Sample - A testing ground for Metaplay features in a simple idle live-service game.
- **samples/trash-dash/index.md**: Trash Dash Sample Project - A complete sample of how to integrate Metaplay into an existing Unity game.

### Advanced Samples

- **samples/orca/index.md**: Orca Sample
- **samples/orca/orca-arch.md**: Orca - Architecture Overview - Technical overview of Orca, how it is built, and how it integrates with Metaplay's systems.

### Wordle Tutorial Samples

- **samples/wordle-tutorial/index.md**: Wordle Tutorial - Practical exercises introducing Metaplay's main concepts and building a Wordle clone.
```

--------------------------------

### Tutorials

Source: https://llm-docs.platform.metaplay.dev/docs/index

Guides on integrating game configs, implementing LiveOps features, customizing the dashboard, and wrapping up your game development.

```APIDOC
## Tutorials

### Game Configs

- **tutorial-02-game-configs.md**: Integrate game configs to remotely configure and balance your game.
- **tutorial-04-customize-dashboard.md**: Customize The Dashboard - Add your own visualizations for the player's state to the dashboard.
- **tutorial-05-wrapping-up.md**: Review & Next Steps - Summary of what we've learned and next steps for building your game with Metaplay.

### LiveOps Features

- **tutorial-03-liveops-features.md**: Use game configs to implement A/B testing, segmentation, and LiveOps events into your game.

### Wordle Clone Tutorials

- **tutorial-cheat-proof-gameplay.md**: Tutorial: Cheat-Proof Gameplay - Implement server actions and configs to make the Wordle clone cheat-proof.
- **tutorial-learn-to-write-game-logic-with-a-wordle-clone.md**: Tutorial: Game Logic - Program games using Metaplay’s actions and models paradigm by implementing a clone of Wordle.
- **tutorial-wordle-game-configs.md**: Tutorial: Game Configs - Fetch data from Google Sheets for a more realistic workflow using Game Configs in the Wordle clone.
```

--------------------------------

### LiveOps Dashboard: Development Guide

Source: https://llm-docs.platform.metaplay.dev/docs/index

Guides you on how to set up a custom LiveOps Dashboard and run an instance of it locally, enabling tailored management tools.

```markdown
liveops-dashboard/developing-the-liveops-dashboard.md: Developing the LiveOps Dashboard - This article will guide you on how to set up a custom LiveOps Dashboard and run an instance of it locally.
```

--------------------------------

### Implement In-Game Mail with Metaplay SDK

Source: https://llm-docs.platform.metaplay.dev/docs/index

This guide introduces a basic implementation of custom in-game mails in your game using Metaplay SDK's example code. It outlines the necessary steps and considerations for setting up and managing in-game mail functionality.

```csharp
using Metaplay.Core;

public class InGameMailManager : MetaSystem<InGameMailManager>
{
    // Example method to send an in-game mail
    public void SendMail(string recipientId, string subject, string body)
    {
        // Implementation details for sending mail
        // This would typically involve interacting with Metaplay's backend services
        Log.Info("Sending mail to {0}: {1}", recipientId, subject);
    }
}
```

--------------------------------

### Minimal SDK Integration Tutorial

Source: https://llm-docs.platform.metaplay.dev/docs/index

A tutorial on adding the Metaplay SDK into an existing game and starting to sync player state. This focuses on the most basic integration steps.

```csharp
// Add Metaplay SDK package to your Unity project.
// Initialize the SDK in your game's startup sequence.
// Configure your PlayerModel and GameConfigs.
// Connect to the server.

```

--------------------------------

### Integrate Metaplay SDK In-Game Offers

Source: https://llm-docs.platform.metaplay.dev/docs/index

This document contains a step-by-step guide for integrating the Metaplay SDK's in-game offers in your game, as well as advanced use cases. It covers the setup and utilization of the in-game offers system.

```csharp
using Metaplay.Core;
using Metaplay.Offers;

public class OfferManager : MetaSystem<OfferManager>
{
    // Example method to fetch available offers
    public async Task<OfferCollection> GetAvailableOffersAsync()
    {
        // Implementation to retrieve offers from Metaplay backend
        return await MetaplayOffers.Instance.GetOffersAsync();
    }
}
```

--------------------------------

### Create and Use Actions in Metaplay

Source: https://llm-docs.platform.metaplay.dev/docs/index

Guides for setting up your first Actions in Metaplay. Actions represent commands or events that can be triggered within the game.

```csharp
using Metaplay.Core;

[MetaAction("DoSomething")]
public class DoSomethingAction : MetaAction<DoSomethingAction>
{
    public string Message { get; private set; }

    public DoSomethingAction(string message) { Message = message; }

    protected override void Execute() { /* Action logic here */ }
}
```

--------------------------------

### Implement Steam Authentication with Metaplay

Source: https://llm-docs.platform.metaplay.dev/docs/index

How to integrate Steam as a device login source. This guide provides the necessary steps and code examples for implementing Steam authentication in your game using Metaplay.

```csharp
using Metaplay.Core;
using Metaplay.SocialLogins;

public class SteamLogin : SocialLoginProvider
{
    public override async Task<LoginResult> LoginAsync(LoginOptions options)
    {
        // Implementation for Steam authentication
        // This would involve Steam SDK integration
        return await base.LoginAsync(options);
    }
}
```

--------------------------------

### Connect to Metaplay Game Server Locally

Source: https://llm-docs.platform.metaplay.dev/docs/index

Guides you through running a Metaplay server locally and connecting to it from a Unity client. This is essential for development and testing.

```csharp
using Metaplay.Unity;

public class ConnectionManager : MonoBehaviour
{
    async void ConnectToServer()
    {
        await MetaplaySDK.Connect("127.0.0.1", 7000);
    }
}
```

--------------------------------

### Set Up Game Configs in Metaplay

Source: https://llm-docs.platform.metaplay.dev/docs/index

Guides for setting up your first Game Configs in Metaplay. Game Configs are essential for defining game-specific data and settings.

```csharp
using Metaplay.Core;

[MetaConfig("MyGameConfig")]
public class MyGameConfig : MetaConfig<MyGameConfig>
{
    public int MaxPlayers { get; private set; } = 100;
}
```

--------------------------------

### Miscellaneous: CLI Command Reference

Source: https://llm-docs.platform.metaplay.dev/docs/index

A complete reference for all Metaplay CLI commands, including their syntax and usage examples.

```markdown
miscellaneous/cli-command-reference.md: CLI Command Reference - Complete reference for all Metaplay CLI commands and their usage.
```

--------------------------------

### LiveOps Dashboard: HTTP API Guide

Source: https://llm-docs.platform.metaplay.dev/docs/index

Walks through implementing new end-to-end features into the LiveOps Dashboard using its HTTP API.

```markdown
liveops-dashboard/how-to-guides/working-with-the-liveops-dashboard-http-api.md: Working with the LiveOps Dashboard HTTP API - This guide walks you through implementing a new end-to-end feature into the LiveOps Dashboard.
```

--------------------------------

### Integrate Metaplay Async Matchmaker

Source: https://llm-docs.platform.metaplay.dev/docs/index

This guide provides a hands-on introduction to a basic implementation of an asynchronous matchmaker into your game. It covers the essential steps for integrating the matchmaking service.

```csharp
using Metaplay.Core;
using Metaplay.Matchmaking;

public class MatchmakingIntegration : MetaSystem<MatchmakingIntegration>
{
    // Example method to start matchmaking
    public async Task StartMatchmakingAsync(Player player, MatchmakingConfig config)
    {
        await MetaplayMatchmaking.Instance.StartMatchAsync(player, config);
    }
}
```

--------------------------------

### Integrate ImmutableX Wallet Social Login

Source: https://llm-docs.platform.metaplay.dev/docs/index

How to integrate ImmutableX Wallet as a social login source. This guide provides the steps for integrating ImmutableX Wallet authentication.

```csharp
using Metaplay.Core;
using Metaplay.SocialLogins;

public class ImmutableXWalletLogin : SocialLoginProvider
{
    public override async Task<LoginResult> LoginAsync(LoginOptions options)
    {
        // Implementation for ImmutableX Wallet authentication
        return await base.LoginAsync(options);
    }
}
```

--------------------------------

### Save Player Data to Server with PlayerModel

Source: https://llm-docs.platform.metaplay.dev/docs/index

Guides for setting up your first PlayerModel in Metaplay. PlayerModel is used to save and manage player data on the server.

```csharp
using Metaplay.Core;

[MetaSerializable]
public class PlayerData
{
    public int Score { get; set; } = 0;
}

public class MyPlayerModel : PlayerModel<PlayerData>
{
    public void AddScore(int amount)
    {
        Model.Score += amount;
        MarkDirty();
    }
}
```

--------------------------------

### LiveOps Dashboard: Viewing Event Streams

Source: https://llm-docs.platform.metaplay.dev/docs/index

Guides you through navigating streams of events in the LiveOps Dashboard, used to understand how changes occur over time.

```markdown
liveops-dashboard/how-to-guides/viewing-event-streams.md: Viewing Event Streams - This article will guide you through how to navigate streams of events in the LiveOps Dashboard. Event streams can be used to understand how something has changed over time.
```

--------------------------------

### Integrate Google Sign-In Social Login

Source: https://llm-docs.platform.metaplay.dev/docs/index

How to integrate Google Sign-In as a social login source. This guide provides the steps for integrating Google Sign-In authentication.

```csharp
using Metaplay.Core;
using Metaplay.SocialLogins;

public class GoogleSignInLogin : SocialLoginProvider
{
    public override async Task<LoginResult> LoginAsync(LoginOptions options)
    {
        // Implementation for Google Sign-In authentication
        return await base.LoginAsync(options);
    }
}
```

--------------------------------

### Integrate Sign in with Apple Social Login

Source: https://llm-docs.platform.metaplay.dev/docs/index

How to integrate Sign in with Apple as a social login source. This guide provides the steps for integrating Sign in with Apple authentication.

```csharp
using Metaplay.Core;
using Metaplay.SocialLogins;

public class SignInWithAppleLogin : SocialLoginProvider
{
    public override async Task<LoginResult> LoginAsync(LoginOptions options)
    {
        // Implementation for Sign in with Apple authentication
        return await base.LoginAsync(options);
    }
}
```

--------------------------------

### Integrate Metaplay SDK into Unity Project

Source: https://llm-docs.platform.metaplay.dev/docs/index

Guides for integrating the Metaplay SDK package into your Unity game project. This process typically involves adding the SDK package and configuring project settings.

```csharp
using Metaplay.Unity;

public class GameInitializer : MonoBehaviour
{
    void Start()
    {
        MetaplaySDK.Initialize();
    }
}
```

--------------------------------

### Integrate Facebook Login Social Login

Source: https://llm-docs.platform.metaplay.dev/docs/index

How to integrate Facebook Login as a social login source. This guide provides the steps for integrating Facebook Login authentication.

```csharp
using Metaplay.Core;
using Metaplay.SocialLogins;

public class FacebookLogin : SocialLoginProvider
{
    public override async Task<LoginResult> LoginAsync(LoginOptions options)
    {
        // Implementation for Facebook Login authentication
        return await base.LoginAsync(options);
    }
}
```

--------------------------------

### LiveOps Dashboard: Add Admin Action

Source: https://llm-docs.platform.metaplay.dev/docs/index

A practical guide on how to add a new admin action to the player details page of the LiveOps Dashboard, extending its functionality.

```markdown
liveops-dashboard/how-to-guides/dashboard-actions.md: Tutorial: Add an Admin Action - This page gives a practical overview of how to add a new admin action to the player details page of the LiveOps Dashboard.
```

--------------------------------

### Implement Player Segments in Metaplay

Source: https://llm-docs.platform.metaplay.dev/docs/index

This is a hands-on guide on how to implement player segmentation in your game. Segments define groups of players and can be used by other game features to target subsets of your entire player base.

```csharp
using Metaplay.Core;

public class SegmentManager : MetaSystem<SegmentManager>
{
    // Example method to check if a player belongs to a segment
    public bool IsPlayerInSegment(Player player, string segmentName)
    {
        // Implementation to check player's segment membership
        return player.Segments.Contains(segmentName);
    }
}
```

--------------------------------

### Integrate Apple Game Center Social Login

Source: https://llm-docs.platform.metaplay.dev/docs/index

How to integrate Apple Game Center as a social login source. This guide provides the steps for integrating Apple Game Center authentication.

```csharp
using Metaplay.Core;
using Metaplay.SocialLogins;

public class AppleGameCenterLogin : SocialLoginProvider
{
    public override async Task<LoginResult> LoginAsync(LoginOptions options)
    {
        // Implementation for Apple Game Center authentication
        return await base.LoginAsync(options);
    }
}
```

--------------------------------

### Integrate Google Play Games Social Login

Source: https://llm-docs.platform.metaplay.dev/docs/index

How to integrate Google Play Games as a social login source. This guide provides the steps for integrating Google Play Games authentication.

```csharp
using Metaplay.Core;
using Metaplay.SocialLogins;

public class GooglePlayGamesLogin : SocialLoginProvider
{
    public override async Task<LoginResult> LoginAsync(LoginOptions options)
    {
        // Implementation for Google Play Games authentication
        return await base.LoginAsync(options);
    }
}
```

--------------------------------

### Implement Player IP Geolocation with Metaplay

Source: https://llm-docs.platform.metaplay.dev/docs/index

This document describes how to enable and access IP-based player geolocation information. It covers the setup and retrieval of player location data based on their IP address.

```csharp
using Metaplay.Core;

public class GeolocationManager : MetaSystem<GeolocationManager>
{
    // Example method to get player's country code
    public string GetPlayerCountryCode(Player player)
    {
        // Implementation to access geolocation data for the player
        return player.DeviceInfo.CountryCode;
    }
}
```

--------------------------------

### Sample: Hello World - Minimal Starter Project

Source: https://llm-docs.platform.metaplay.dev/docs/index

A minimal starter project that scaffolds a new Metaplay-powered game, providing a basic foundation for new projects.

```markdown
samples/helloworld/index.md: Hello World Sample - A minimal starter project that scaffolds a new Metaplay-powered game.
```

--------------------------------

### Tutorial: Review & Next Steps - Building Your Game

Source: https://llm-docs.platform.metaplay.dev/docs/index

A summary of learned concepts and guidance on the next steps for building your game with Metaplay.

```markdown
tutorial-05-wrapping-up.md: Tutorial: Review & Next Steps - Summary of what we've learned and next steps for building your game with Metaplay.
```

--------------------------------

### Tutorial: Game Configs - Integrate Game Configs

Source: https://llm-docs.platform.metaplay.dev/docs/index

Learn how to integrate game configurations to remotely configure and balance your game. This tutorial focuses on fetching data from external sources like Google Sheets for a more realistic workflow.

```markdown
tutorial-02-game-configs.md: Tutorial: Game Configs - Integrate game configs to remotely configure and balance your game.
tutorial-wordle-game-configs.md: Tutorial: Game Configs - This tutorial builds on the previous guide on implementing a Wordle clone. This time, we're focusing on the project's Game Configs to fetch data from Google Sheets for a more realistic workflow.
```

--------------------------------

### Tutorial: Wordle Clone - Metaplay Concepts and Game Logic

Source: https://llm-docs.platform.metaplay.dev/docs/index

Practical exercises introducing Metaplay's main concepts and teaching how to build a Wordle clone. Focuses on programming games using Metaplay’s actions and models paradigm.

```markdown
samples/wordle-tutorial/index.md: Wordle Tutorial - This section has some practical exercises that introduce Metaplay's main concepts and teach you how to build a Wordle clone.
samples/wordle-tutorial/tutorial-learn-to-write-game-logic-with-a-wordle-clone.md: Tutorial: Game Logic - This article gives a practical overview of how to program games using Metaplay’s actions and models paradigm by implementing a clone of Wordle using the Metaplay SDK.
```

--------------------------------

### Tutorial: LiveOps Features - Implement A/B Testing and Segmentation

Source: https://llm-docs.platform.metaplay.dev/docs/index

Utilize game configurations to implement A/B testing, segmentation, and LiveOps events into your game. This enables dynamic adjustments and feature rollouts.

```markdown
tutorial-03-liveops-features.md: Tutorial: LiveOps Features - Use game configs to implement A/B testing, segmentation, and LiveOps events into your game.
```

--------------------------------

### Sample: Trash Dash - Integrate Metaplay into Unity

Source: https://llm-docs.platform.metaplay.dev/docs/index

A complete sample project demonstrating how to integrate Metaplay into an existing Unity game.

```markdown
samples/trash-dash/index.md: Trash Dash Sample Project - A complete sample of how to integrate Metaplay into an existing Unity game.
```

--------------------------------

### Tutorial: Cheat-Proof Gameplay - Server Actions and Configs

Source: https://llm-docs.platform.metaplay.dev/docs/index

Implement server actions and configurations to make the Wordle clone cheat-proof. This tutorial builds upon the previously created Wordle clone.

```markdown
samples/wordle-tutorial/tutorial-cheat-proof-gameplay.md: Tutorial: Cheat-Proof Gameplay - In this tutorial, we'll take the Wordle clone we built previously and implement server actions and configs to make it cheat-proof.
```

--------------------------------

### Tutorial: Customize Dashboard - Add Custom Visualizations

Source: https://llm-docs.platform.metaplay.dev/docs/index

This section explains how to add your own visualizations for the player's state to the dashboard, enhancing data monitoring and analysis capabilities.

```markdown
tutorial-04-customize-dashboard.md: Tutorial: Customize The Dashboard - This section explains how to add your own visualizations for the player's state to the dashboard.
```

--------------------------------

### Sample: Orca - Architecture Overview

Source: https://llm-docs.platform.metaplay.dev/docs/index

Technical overview of the Orca sample project, detailing its architecture and integration with Metaplay's systems.

```markdown
samples/orca/orca-arch.md: Orca - Architecture Overview - Technical overview of Orca, how it is built, and how it integrates with Metaplay's systems.
```

--------------------------------

### Working with Runtime Options in Metaplay

Source: https://llm-docs.platform.metaplay.dev/docs/index

Explains how runtime options configure the game server with game and environment-specific data. Options can be set through multiple sources.

```csharp
using Metaplay.Core;

public class GameRuntimeOptions : MetaRuntimeOptions
{
    public string ApiKey { get; private set; }
}

public class ServerConfig
{
    public void LoadOptions()
    {
        var options = GameRuntimeOptions.Instance;
        string apiKey = options.ApiKey;
    }
}
```

--------------------------------

### Miscellaneous: AI Assistants Tips

Source: https://llm-docs.platform.metaplay.dev/docs/index

Practical tips for effectively using AI assistants in conjunction with Metaplay development.

```markdown
miscellaneous/ai-assistants.md: AI Assistants - Practical tips for using AI assistants with Metaplay.
```

--------------------------------

### LiveOps Dashboard: Configuration Overview

Source: https://llm-docs.platform.metaplay.dev/docs/index

Provides an overview of how to configure the LiveOps Dashboard to manage and monitor your game.

```markdown
liveops-dashboard/configuring-the-liveops-dashboard.md: Configuring the LiveOps Dashboard - This page provides an overview of how to configure the LiveOps Dashboard.
```

--------------------------------

### LiveOps Dashboard: Introduction

Source: https://llm-docs.platform.metaplay.dev/docs/index

An introduction to the Metaplay SDK's pre-configured LiveOps Dashboard, used for viewing and managing your game.

```markdown
liveops-dashboard/introduction-to-the-liveops-dashboard.md: Introduction to the LiveOps Dashboard - Metaplay SDK ships with a pre-configured website, the LiveOps Dashboard, for viewing and managing your game.
```

--------------------------------

### LiveOps Dashboard: Working with Subscriptions

Source: https://llm-docs.platform.metaplay.dev/docs/index

Details the recommended method for fetching data from the game server using subscriptions, providing in-depth usage information.

```markdown
liveops-dashboard/how-to-guides/working-with-subscriptions.md: Working with Subscriptions - Subscriptions are the recommended way to fetch data from the game server. This document dives into the detail of how to work with subscriptions.
```

--------------------------------

### Sample: Idler - Testing Metaplay Features

Source: https://llm-docs.platform.metaplay.dev/docs/index

A testing ground for Metaplay features within a simple idle live-service game, demonstrating core functionalities.

```markdown
samples/idler/index.md: Idler Sample - A testing ground for Metaplay features in a simple idle live-service game.
```

--------------------------------

### Working with the Database in Metaplay

Source: https://llm-docs.platform.metaplay.dev/docs/index

Explains Metaplay's data persistence model and how to extend it for game-specific data. This covers saving and retrieving data from the database.

```csharp
using Metaplay.Core;

public class MyDataManager
{
    public void SavePlayerData(PlayerModel player)
    {
        // PlayerModel is automatically persisted
        player.MarkDirty();
    }

    public PlayerModel LoadPlayer(string playerId)
    {
        return PlayerModel.Get(playerId);
    }
}
```

--------------------------------

### Miscellaneous: Creating Support Tickets

Source: https://llm-docs.platform.metaplay.dev/docs/index

Information on how to create support tickets and expected response times based on your support plan.

```markdown
miscellaneous/creating-support-tickets.md: Creating Support Tickets - This page describes how to create support tickets and the approximate response time you can expect depending on your support plan.
```

--------------------------------

### Use Fixed-Point Math in Metaplay

Source: https://llm-docs.platform.metaplay.dev/docs/index

Describes how to use fixed-point math in your game logic. Fixed-point math is useful for precise calculations without floating-point inaccuracies.

```csharp
using Metaplay.Core.Math;

public class GameLogic
{
    public Fixed64 CalculateDamage(Fixed64 attack, Fixed64 defense)
    {
        return attack - defense;
    }
}
```

--------------------------------

### Miscellaneous

Source: https://llm-docs.platform.metaplay.dev/docs/index

Additional resources including AI assistants, CLI commands, support tickets, and license information.

```APIDOC
## Miscellaneous

- **miscellaneous/ai-assistants.md**: AI Assistants - Practical tips for using AI assistants with Metaplay.
- **miscellaneous/cli-command-reference.md**: CLI Command Reference - Complete reference for all Metaplay CLI commands and their usage.
- **miscellaneous/creating-support-tickets.md**: Creating Support Tickets - How to create support tickets and expected response times.
- **miscellaneous/licenses/game-server-licenses.md**: Game Server OSS Licenses - Lists the OSS licenses of third-party packages used in the Game Server.
```

--------------------------------

### LiveOps Dashboard: Fetching Data from Game Server

Source: https://llm-docs.platform.metaplay.dev/docs/index

Outlines different methods for fetching data from the game server into the LiveOps Dashboard, enabling real-time data visualization.

```markdown
liveops-dashboard/how-to-guides/fetching-data-from-the-game-server.md: Fetching Data from the Game Server - This document outlines the different methods of fetching data from the game server into the LiveOps Dashboard.
```

--------------------------------

### Entity Schema Versions and Migrations in Metaplay

Source: https://llm-docs.platform.metaplay.dev/docs/index

Explains schema versions for persisted entities and how to implement schema version migrations. This is crucial for evolving your data models over time.

```csharp
using Metaplay.Core;

[MetaSerializable, MetaEntitySchema("MyEntity", 1)]
public class MyEntityV1
{
    public int OldValue { get; set; }
}

[MetaEntitySchema("MyEntity", 2)]
public class MyEntityV2
{
    public int NewValue { get; set; }

    public static MyEntityV2 MigrateFrom(MyEntityV1 oldData)
    {
        return new MyEntityV2 { NewValue = oldData.OldValue * 2 };
    }
}
```

--------------------------------

### LiveOps Dashboard: Using the Timeline View

Source: https://llm-docs.platform.metaplay.dev/docs/index

Explains how to use the timeline view within the LiveOps Dashboard for monitoring and interacting with time-related items like LiveOps events.

```markdown
liveops-dashboard/liveops-timeline.md: Using the LiveOps Timeline - The LiveOps Dashboard uses a timeline view for monitoring and interacting with various time-related items, such as LiveOps events.
```

--------------------------------

### Licenses: Game Server OSS Licenses

Source: https://llm-docs.platform.metaplay.dev/docs/index

Lists the open-source software (OSS) licenses of third-party packages utilized within the Metaplay Game Server.

```markdown
licenses/game-server-licenses.md: Game Server OSS Licenses - This page lists the OSS licenses of the third-party packages used in the Game Server.
```

--------------------------------

### Custom Server Entities in Metaplay

Source: https://llm-docs.platform.metaplay.dev/docs/index

Demonstrates how to add a custom server-only entity to the backend. These entities are not present on the client and are used for backend logic.

```csharp
using Metaplay.Core;

public class CustomServerEntity : GameEntity
{
    // Server-only logic here
    protected override void OnTick() { /* ... */ }
}
```

--------------------------------

### Implement Metaplay Localization System

Source: https://llm-docs.platform.metaplay.dev/docs/index

The page describes how Metaplay's localization system works and how you can integrate it into your game. It covers the core concepts and implementation details for supporting multiple languages.

```csharp
using Metaplay.Core;

public class LocalizationManager : MetaSystem<LocalizationManager>
{
    // Example method to get a localized string
    public string GetLocalizedString(string key)
    {
        // Implementation to retrieve localized string based on current culture
        return MetaplayLocalization.Instance.GetString(key);
    }
}
```

--------------------------------

### LiveOps Dashboard: Customizing Frontend

Source: https://llm-docs.platform.metaplay.dev/docs/index

Documents how to customize the LiveOps Dashboard frontend to better suit your game's specific needs and branding.

```markdown
liveops-dashboard/how-to-guides/customizing-the-liveops-dashboard-frontend.md: Customizing the LiveOps Dashboard Frontend - This page documents customizing the LiveOps Dashboard to your game's needs.
```

--------------------------------

### Implement MetaRewards in Metaplay

Source: https://llm-docs.platform.metaplay.dev/docs/index

Explains why and how to use the built-in MetaRewards classes in your game. MetaRewards are used for in-game rewards and monetization.

```csharp
using Metaplay.Core.Rewards;

public class RewardManager : MetaRewardsManager
{
    public void GrantDailyLoginBonus(IPlayerSession session)
    {
        GrantReward(session, "DailyLoginBonus");
    }
}
```

--------------------------------

### UDP Passthrough Server in Metaplay

Source: https://llm-docs.platform.metaplay.dev/docs/index

Describes implementing a UDP server that can be embedded within a Metaplay backend. This allows for efficient, low-latency communication.

```csharp
using Metaplay.Core.Net;

public class UdpServer : UdpServerBase
{
    protected override void OnDatagramReceived(UdpSocket socket, byte[] data, IPEndPoint endpoint)
    {
        // Process received UDP data
    }
}
```

--------------------------------

### LiveOps Dashboard

Source: https://llm-docs.platform.metaplay.dev/docs/index

Information on configuring, developing, and using the LiveOps Dashboard for managing your game.

```APIDOC
## LiveOps Dashboard

### Getting Started

- **liveops-dashboard/introduction-to-the-liveops-dashboard.md**: Introduction to the LiveOps Dashboard - Overview of the pre-configured website for viewing and managing your game.
- **liveops-dashboard/configuring-the-liveops-dashboard.md**: Configuring the LiveOps Dashboard - Overview of how to configure the LiveOps Dashboard.
- **liveops-dashboard/developing-the-liveops-dashboard.md**: Developing the LiveOps Dashboard - Guide on setting up a custom LiveOps Dashboard and running it locally.

### Features and Usage

- **liveops-dashboard/liveops-timeline.md**: Using the LiveOps Timeline - Monitoring and interacting with time-related items like LiveOps events using the timeline view.

### How-To Guides

- **liveops-dashboard/how-to-guides/customizing-the-liveops-dashboard-frontend.md**: Customizing the LiveOps Dashboard Frontend - Documenting customization of the LiveOps Dashboard to your game's needs.
- **liveops-dashboard/how-to-guides/dashboard-actions.md**: Tutorial: Add an Admin Action - Adding a new admin action to the player details page of the LiveOps Dashboard.
- **liveops-dashboard/how-to-guides/fetching-data-from-the-game-server.md**: Fetching Data from the Game Server - Methods for fetching data from the game server into the LiveOps Dashboard.
- **liveops-dashboard/how-to-guides/viewing-event-streams.md**: Viewing Event Streams - Navigating streams of events in the LiveOps Dashboard to understand changes over time.
- **liveops-dashboard/how-to-guides/working-with-generated-dashboard-forms-and-views.md**: Working with Generated Dashboard UI - Experimental feature for generating dashboard UI from C# type information.
- **liveops-dashboard/how-to-guides/working-with-subscriptions.md**: Working with Subscriptions - Recommended way to fetch data from the game server.
- **liveops-dashboard/how-to-guides/working-with-the-liveops-dashboard-http-api.md**: Working with the LiveOps Dashboard HTTP API - Implementing new end-to-end features into the LiveOps Dashboard.
```

--------------------------------

### LiveOps Dashboard: Generated UI and Forms

Source: https://llm-docs.platform.metaplay.dev/docs/index

Explains the experimental Metaplay feature for generating dashboard UI from C# type information, potentially replacing custom UI components.

```markdown
liveops-dashboard/how-to-guides/working-with-generated-dashboard-forms-and-views.md: Working with Generated Dashboard UI - Generated UIs are an experimental Metaplay feature that allows the generation of dashboard UI from C# type information. It can replace the need for a lot of game-specific custom UI components.
```

--------------------------------

### Entity-to-Entity Communication in Metaplay

Source: https://llm-docs.platform.metaplay.dev/docs/index

Deep dive into entity-to-entity communication within the Metaplay SDK. This allows different game entities to interact with each other.

```csharp
using Metaplay.Core;

public class SenderEntity : GameEntity
{
    public void SendMessageToReceiver(EntityId receiverId, string message)
    {
        PostMessage(receiverId, new MyMessage(message));
    }
}

public class ReceiverEntity : GameEntity
{
    protected override void OnMessage(MetaMessage message)
    {
        if (message is MyMessage myMessage)
        {
            // Handle message
        }
    }
}
```

--------------------------------

### Manage Broadcasts with Metaplay LiveOps Dashboard

Source: https://llm-docs.platform.metaplay.dev/docs/index

This document describes how to use the Broadcasts feature of the LiveOps Dashboard to send in-game messages to your players. It details the process of creating, scheduling, and sending broadcast messages.

--------------------------------

### Database Scan Jobs in Metaplay

Source: https://llm-docs.platform.metaplay.dev/docs/index

Utilizes the database scanning system to perform operations on server entities based on custom parameters. This is useful for batch processing or cleanup tasks.

```csharp
using Metaplay.Core.Database;

public class MyDatabaseScanJob : DatabaseScanJob<PlayerModel>
{
    protected override void Process(PlayerModel player)
    {
        if (player.Model.Score < 0)
        {
            player.Model.Score = 0;
            player.MarkDirty();
        }
    }
}
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.