### Localization Module Setup and Usage in C#

Source: https://context7.com/ellanjiang/unitygameframework/llms.txt

Demonstrates how to set up and use the Localization Module in Unity Game Framework. It covers subscribing to localization events, setting the current language, loading dictionary files, retrieving localized strings with and without parameters, checking for key existence, and modifying localized strings at runtime.

```csharp
using UnityGameFramework.Runtime;
using GameFramework.Localization;
using GameFramework.Event;

LocalizationComponent localization = GameEntry.GetComponent<LocalizationComponent>();
EventComponent eventComponent = GameEntry.GetComponent<EventComponent>();

// Subscribe to localization events
eventComponent.Subscribe(LoadDictionarySuccessEventArgs.EventId, OnLoadDictionarySuccess);
eventComponent.Subscribe(LoadDictionaryFailureEventArgs.EventId, OnLoadDictionaryFailure);

// Set current language
localization.Language = Language.English;
localization.Language = Language.ChineseSimplified;
localization.Language = Language.ChineseTraditional;
localization.Language = Language.Korean;
localization.Language = Language.Japanese;

// Get system language
Language systemLang = localization.SystemLanguage;

// Load dictionary file
localization.ReadData("Assets/Localization/English.txt");
localization.ReadData("Assets/Localization/English.txt", priority: 100, userData: null);

// Get localized string
string welcomeText = localization.GetString("UI.Welcome");
// Returns: "Welcome to the game!"

// Get localized string with parameters (up to 16 parameters supported)
string levelText = localization.GetString("UI.Level", 5);
// Dictionary entry: "UI.Level" = "Level: {0}"
// Returns: "Level: 5"

string scoreText = localization.GetString("UI.Score", 1000, 50);
// Dictionary entry: "UI.Score" = "Score: {0} / Combo: {1}"
// Returns: "Score: 1000 / Combo: 50"

string playerInfo = localization.GetString("UI.PlayerInfo", "Alice", 25, 15000);
// Dictionary entry: "UI.PlayerInfo" = "Player: {0}, Level: {1}, XP: {2}"
// Returns: "Player: Alice, Level: 25, XP: 15000"

// Check if key exists
bool hasKey = localization.HasRawString("UI.Welcome");

// Add or update localized string at runtime
localization.AddRawString("NewKey", "New Value");

// Remove localized strings
localization.RemoveRawString("OldKey");
localization.RemoveAllRawStrings();

// Dictionary file format (tab-separated):
// Key\tValue
// UI.Welcome\tWelcome to the game!
// UI.Level\tLevel: {0}
// UI.Score\tScore: {0} / Combo: {1}
// UI.PlayerInfo\tPlayer: {0}, Level: {1}, XP: {2}

// Event handlers
void OnLoadDictionarySuccess(object sender, GameEventArgs e)
{
    LoadDictionarySuccessEventArgs args = (LoadDictionarySuccessEventArgs)e;
    Log.Info("Dictionary loaded: {0}, Duration: {1}s", args.DictionaryAssetName, args.Duration);
}

void OnLoadDictionaryFailure(object sender, GameEventArgs e)
{
    LoadDictionaryFailureEventArgs args = (LoadDictionaryFailureEventArgs)e;
    Log.Error("Dictionary failed: {0}, Error: {1}", args.DictionaryAssetName, args.ErrorMessage);
}
```

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

### C# Event Handling with Unity Game Framework

Source: https://context7.com/ellanjiang/unitygameframework/llms.txt

Demonstrates how to define custom event arguments, subscribe to and unsubscribe from framework and custom events, check for subscriptions, get handler counts, and fire events using Unity Game Framework's EventComponent. It also shows how to use ReferencePool for efficient event argument management.

```csharp
using UnityGameFramework.Runtime;
using GameFramework.Event;
using System;

// Define custom game event
public class PlayerLevelUpEventArgs : GameEventArgs
{
    public static readonly int EventId = typeof(PlayerLevelUpEventArgs).GetHashCode();

    public int PlayerId { get; set; }
    public int NewLevel { get; set; }

    public override int Id { get { return EventId; } }

    public override void Clear()
    {
        PlayerId = 0;
        NewLevel = 0;
    }
}

public class GameManager : MonoBehaviour
{
    private EventComponent m_EventComponent;

    void Start()
    {
        m_EventComponent = GameEntry.GetComponent<EventComponent>();

        // Subscribe to built-in framework events
        m_EventComponent.Subscribe(ShowEntitySuccessEventArgs.EventId, OnShowEntitySuccess);
        m_EventComponent.Subscribe(LoadConfigSuccessEventArgs.EventId, OnLoadConfigSuccess);

        // Subscribe to custom game events
        m_EventComponent.Subscribe(PlayerLevelUpEventArgs.EventId, OnPlayerLevelUp);

        // Check if handler is subscribed
        bool isSubscribed = m_EventComponent.Check(
            PlayerLevelUpEventArgs.EventId, OnPlayerLevelUp);

        // Get handler count for event
        int handlerCount = m_EventComponent.Count(PlayerLevelUpEventArgs.EventId);
    }

    void OnDestroy()
    {
        // Unsubscribe from events
        m_EventComponent.Unsubscribe(ShowEntitySuccessEventArgs.EventId, OnShowEntitySuccess);
        m_EventComponent.Unsubscribe(LoadConfigSuccessEventArgs.EventId, OnLoadConfigSuccess);
        m_EventComponent.Unsubscribe(PlayerLevelUpEventArgs.EventId, OnPlayerLevelUp);
    }

    void LevelUpPlayer(int playerId, int newLevel)
    {
        // Fire event (thread-safe, dispatched next frame)
        PlayerLevelUpEventArgs e = ReferencePool.Acquire<PlayerLevelUpEventArgs>();
        e.PlayerId = playerId;
        e.NewLevel = newLevel;
        m_EventComponent.Fire(this, e);
        ReferencePool.Release(e);

        // Or fire immediately (not thread-safe, immediate dispatch)
        // m_EventComponent.FireNow(this, e);
    }

    void OnPlayerLevelUp(object sender, GameEventArgs e)
    {
        PlayerLevelUpEventArgs args = (PlayerLevelUpEventArgs)e;
        Log.Info("Player {0} leveled up to {1}!", args.PlayerId, args.NewLevel);
    }

    void OnShowEntitySuccess(object sender, GameEventArgs e)
    {
        ShowEntitySuccessEventArgs args = (ShowEntitySuccessEventArgs)e;
        Log.Info("Entity {0} shown successfully", args.Entity.Id);
    }

    void OnLoadConfigSuccess(object sender, GameEventArgs e)
    {
        LoadConfigSuccessEventArgs args = (LoadConfigSuccessEventArgs)e;
        Log.Info("Config {0} loaded", args.ConfigAssetName);
    }
}
```

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

### Unity C# Download Files Asynchronously

Source: https://context7.com/ellanjiang/unitygameframework/llms.txt

This snippet demonstrates how to use the DownloadComponent in UnityGameFramework to download files asynchronously. It covers subscribing to download events (start, update, success, failure), configuring download settings like timeout and flush size, checking download status (total, free, working agents, speed), adding new downloads with specified paths and URIs, pausing and resuming all downloads, removing individual or all downloads, and implementing basic event handlers for logging download progress and status. It requires UnityGameFramework runtime components.

```csharp
using UnityGameFramework.Runtime;
using GameFramework.Event;
using GameFramework.Download;

DownloadComponent download = GameEntry.GetComponent<DownloadComponent>();
EventComponent eventComponent = GameEntry.GetComponent<EventComponent>();

// Subscribe to download events
eventComponent.Subscribe(DownloadStartEventArgs.EventId, OnDownloadStart);
eventComponent.Subscribe(DownloadUpdateEventArgs.EventId, OnDownloadUpdate);
eventComponent.Subscribe(DownloadSuccessEventArgs.EventId, OnDownloadSuccess);
eventComponent.Subscribe(DownloadFailureEventArgs.EventId, OnDownloadFailure);

// Configure download settings
download.Timeout = 30f;  // Timeout in seconds
download.FlushSize = 1048576;  // 1MB flush size for resume support

// Check download status
int totalAgents = download.TotalAgentCount;  // Total downloaders
int freeAgents = download.FreeAgentCount;    // Available downloaders
int workingAgents = download.WorkingAgentCount;  // Active downloads
float downloadSpeed = download.CurrentSpeed;  // Bytes per second

// Add download agent helpers (configure in Inspector or at runtime)
// Default count is 3 concurrent downloaders

// Start file download
int serialId = download.AddDownload(
    downloadPath: "Assets/UpdatedAssets/Level2.bundle",
    downloadUri: "https://cdn.example.com/assets/Level2.bundle",
    userData: null
);

// Start download with custom save path
serialId = download.AddDownload(
    downloadPath: "/CustomPath/level2.bundle",
    downloadUri: "https://cdn.example.com/assets/Level2.bundle",
    priority: 100,
    userData: null
);

// Pause and resume all downloads
download.Paused = true;   // Pause
download.Paused = false;  // Resume

// Remove download
download.RemoveDownload(serialId);

// Remove all downloads
download.RemoveAllDownloads();

// Event handlers
void OnDownloadStart(object sender, GameEventArgs e)
{
    DownloadStartEventArgs args = (DownloadStartEventArgs)e;
    Log.Info("Download started: {0}", args.DownloadPath);
}

void OnDownloadUpdate(object sender, GameEventArgs e)
{
    DownloadUpdateEventArgs args = (DownloadUpdateEventArgs)e;
    float progress = (float)args.CurrentLength / args.TotalLength;
    Log.Info("Downloading: {0}, Progress: {1:P}, Speed: {2} KB/s",
        args.DownloadPath, progress, args.CurrentSpeed / 1024f);
}

void OnDownloadSuccess(object sender, GameEventArgs e)
{
    DownloadSuccessEventArgs args = (DownloadSuccessEventArgs)e;
    Log.Info("Download complete: {0}, Size: {1} bytes",
        args.DownloadPath, args.CurrentLength);
}

void OnDownloadFailure(object sender, GameEventArgs e)
{
    DownloadFailureEventArgs args = (DownloadFailureEventArgs)e;
    Log.Error("Download failed: {0}, Error: {1}",
        args.DownloadUri, args.ErrorMessage);
}

```

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

### C# UI Form Logic and Usage in UnityGameFramework

Source: https://context7.com/ellanjiang/unitygameframework/llms.txt

Demonstrates the implementation of a custom UI form (MainMenuUI) inheriting from UIFormLogic and provides examples of how to use the UIComponent for managing UI forms and groups within UnityGameFramework. This includes opening, closing, refocusing forms, and handling UI events.

```csharp
using UnityGameFramework.Runtime;
using GameFramework.Event;
using UnityEngine;
using UnityEngine.UI;

// Define custom UI form logic
public class MainMenuUI : UIFormLogic
{
    private Button m_StartButton;
    private Button m_SettingsButton;
    private Button m_QuitButton;

    protected internal override void OnInit(object userData)
    {
        base.OnInit(userData);
        // Initialize UI (called once when created)
        m_StartButton = CachedTransform.Find("StartButton").GetComponent<Button>();
        m_SettingsButton = CachedTransform.Find("SettingsButton").GetComponent<Button>();
        m_QuitButton = CachedTransform.Find("QuitButton").GetComponent<Button>();

        m_StartButton.onClick.AddListener(OnStartButtonClick);
        m_SettingsButton.onClick.AddListener(OnSettingsButtonClick);
        m_QuitButton.onClick.AddListener(OnQuitButtonClick);
    }

    protected internal override void OnOpen(object userData)
    {
        base.OnOpen(userData);
        // UI form is opened
        Log.Info("Main menu opened");
    }

    protected internal override void OnClose(bool isShutdown, object userData)
    {
        base.OnClose(isShutdown, userData);
        // UI form is closed
        Log.Info("Main menu closed");
    }

    protected internal override void OnPause()
    {
        base.OnPause();
        // UI form is paused (covered by another UI)
    }

    protected internal override void OnResume()
    {
        base.OnResume();
        // UI form is resumed (no longer covered)
    }

    protected internal override void OnCover()
    {
        base.OnCover();
        // UI form is covered by another UI
    }

    protected internal override void OnReveal()
    {
        base.OnReveal();
        // UI form is revealed (covering UI closed)
    }

    protected internal override void OnRefocus(object userData)
    {
        base.OnRefocus(userData);
        // UI form is refocused (brought to front)
    }

    protected internal override void OnUpdate(float elapseSeconds, float realElapseSeconds)
    {
        base.OnUpdate(elapseSeconds, realElapseSeconds);
        // Update logic each frame
    }

    protected internal override void OnDepthChanged(int uiGroupDepth, int depthInUIGroup)
    {
        base.OnDepthChanged(uiGroupDepth, depthInUIGroup);
        // UI depth changed
    }

    private void OnStartButtonClick() { /* Start game */ }
    private void OnSettingsButtonClick() { /* Open settings */ }
    private void OnQuitButtonClick() { /* Quit game */ }
}

// Usage
UIComponent ui = GameEntry.GetComponent<UIComponent>();
EventComponent eventComponent = GameEntry.GetComponent<EventComponent>();

// Subscribe to UI events
eventComponent.Subscribe(OpenUIFormSuccessEventArgs.EventId, OnOpenUIFormSuccess);
eventComponent.Subscribe(OpenUIFormFailureEventArgs.EventId, OnOpenUIFormFailure);
eventComponent.Subscribe(CloseUIFormCompleteEventArgs.EventId, OnCloseUIFormComplete);

// Create UI group with depth ordering
ui.AddUIGroup("DefaultGroup", depth: 0);
ui.AddUIGroup("DialogGroup", depth: 100);
ui.AddUIGroup("TipGroup", depth: 200);

// Check if UI group exists
bool hasGroup = ui.HasUIGroup("DefaultGroup");

// Get UI group
IUIGroup group = ui.GetUIGroup("DefaultGroup");

// Open UI form
int serialId = ui.OpenUIForm(
    uiFormAssetName: "Assets/UI/MainMenuUI.prefab",
    uiGroupName: "DefaultGroup",
    pauseCoveredUIForm: true,
    userData: null
);

// Open with priority
serialId = ui.OpenUIForm(
    uiFormAssetName: "Assets/UI/DialogUI.prefab",
    uiGroupName: "DialogGroup",
    priority: 100,
    pauseCoveredUIForm: true,
    userData: null
);

// Get UI form by serial ID
UIForm uiForm = ui.GetUIForm(serialId);
if (uiForm != null)
{
    MainMenuUI logic = uiForm.Logic as MainMenuUI;
    // Access UI logic
}

// Get all loaded UI forms
UIForm[] allForms = ui.GetAllLoadedUIForms();

// Check if UI form is loading or loaded
bool isLoading = ui.IsLoadingUIForm(serialId);
bool isLoaded = ui.HasUIForm(serialId);

// Refocus UI form (bring to front)
ui.RefocusUIForm(uiForm);

// Close UI form
ui.CloseUIForm(serialId);
ui.CloseUIForm(serialId, userData: null);
ui.CloseUIForm(uiForm);

// Close all loaded UI forms in a group
ui.CloseAllLoadedUIForms("DefaultGroup");

// Event handlers
void OnOpenUIFormSuccess(object sender, GameEventArgs e)
{
    OpenUIFormSuccessEventArgs args = (OpenUIFormSuccessEventArgs)e;
    Log.Info("UI opened: {0}, Duration: {1}s", args.UIForm.UIFormAssetName, args.Duration);
}

void OnOpenUIFormFailure(object sender, GameEventArgs e)
{
    OpenUIFormFailureEventArgs args = (OpenUIFormFailureEventArgs)e;
    Log.Error("UI failed: {0}, Error: {1}", args.UIFormAssetName, args.ErrorMessage);
}

void OnCloseUIFormComplete(object sender, GameEventArgs e)
{
    CloseUIFormCompleteEventArgs args = (CloseUIFormCompleteEventArgs)e;
}
```

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

### Unity C# WebRequest Module Usage

Source: https://context7.com/ellanjiang/unitygameframework/llms.txt

Demonstrates how to use the WebRequestComponent in Unity Game Framework to send GET and POST requests. It covers subscribing to events, configuring timeouts, checking agent status, sending requests with different data types (form and JSON), and managing requests. Dependencies include UnityGameFramework.Runtime and GameFramework.WebRequest.

```csharp
using UnityGameFramework.Runtime;
using GameFramework.WebRequest;
using GameFramework.Event;
using System.Collections.Generic;
using System.Text;

WebRequestComponent webRequest = GameEntry.GetComponent<WebRequestComponent>();
EventComponent eventComponent = GameEntry.GetComponent<EventComponent>();

// Subscribe to web request events
eventComponent.Subscribe(WebRequestStartEventArgs.EventId, OnWebRequestStart);
eventComponent.Subscribe(WebRequestSuccessEventArgs.EventId, OnWebRequestSuccess);
eventComponent.Subscribe(WebRequestFailureEventArgs.EventId, OnWebRequestFailure);

// Configure timeout
webRequest.Timeout = 30f;  // 30 seconds timeout

// Check agent status
int totalAgents = webRequest.TotalAgentCount;  // Total web request agents
int freeAgents = webRequest.FreeAgentCount;    // Available agents
int workingAgents = webRequest.WorkingAgentCount;  // Active requests

// Send GET request
int serialId = webRequest.AddWebRequest(
    webRequestUri: "https://api.example.com/players/123",
    userData: null
);

// Send GET request with priority
serialId = webRequest.AddWebRequest(
    webRequestUri: "https://api.example.com/config",
    priority: 100,
    userData: null
);

// Send POST request with form data
WWWForm form = new WWWForm();
form.AddField("username", "player123");
form.AddField("password", "password");

serialId = webRequest.AddWebRequest(
    webRequestUri: "https://api.example.com/login",
    postData: form.data,
    userData: null
);

// Send POST request with JSON data
string jsonData = "{\"username\":\"player123\",\"password\":\"password\"}";
byte[] postData = Encoding.UTF8.GetBytes(jsonData);

serialId = webRequest.AddWebRequest(
    webRequestUri: "https://api.example.com/login",
    postData: postData,
    priority: 100,
    userData: null
);

// Remove web request
bool removed = webRequest.RemoveWebRequest(serialId);

// Remove all web requests
webRequest.RemoveAllWebRequests();

// Event handlers
void OnWebRequestStart(object sender, GameEventArgs e)
{
    WebRequestStartEventArgs args = (WebRequestStartEventArgs)e;
    Log.Info("Web request started: {0}, Serial ID: {1}",
        args.WebRequestUri, args.SerialId);
}

void OnWebRequestSuccess(object sender, GameEventArgs e)
{
    WebRequestSuccessEventArgs args = (WebRequestSuccessEventArgs)e;
    string responseText = Encoding.UTF8.GetString(args.GetWebResponseBytes());
    Log.Info("Web request success: {0}, Response: {1}",
        args.WebRequestUri, responseText);

    // Process response
    // Parse JSON, XML, etc.
}

void OnWebRequestFailure(object sender, GameEventArgs e)
{
    WebRequestFailureEventArgs args = (WebRequestFailureEventArgs)e;
    Log.Error("Web request failed: {0}, Error: {1}",
        args.WebRequestUri, args.ErrorMessage);
}

```

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

### Scene Module: Load, Unload, and Manage Scenes in Unity

Source: https://context7.com/ellanjiang/unitygameframework/llms.txt

Demonstrates how to use the SceneComponent for asynchronous scene loading and unloading. It covers subscribing to scene events like load success, failure, update, and unload success. It also shows how to check scene status, retrieve loaded/loading scene names, and get the scene name from an asset path.

```csharp
using UnityGameFramework.Runtime;
using GameFramework.Event;

SceneComponent scene = GameEntry.GetComponent<SceneComponent>();
EventComponent eventComponent = GameEntry.GetComponent<EventComponent>();

// Subscribe to scene events
eventComponent.Subscribe(LoadSceneSuccessEventArgs.EventId, OnLoadSceneSuccess);
eventComponent.Subscribe(LoadSceneFailureEventArgs.EventId, OnLoadSceneFailure);
eventComponent.Subscribe(LoadSceneUpdateEventArgs.EventId, OnLoadSceneUpdate);
eventComponent.Subscribe(UnloadSceneSuccessEventArgs.EventId, OnUnloadSceneSuccess);

// Get current main camera
Camera mainCamera = scene.MainCamera;

// Load scene asynchronously
scene.LoadScene("Assets/Scenes/Level1.unity");
scene.LoadScene("Assets/Scenes/Level1.unity", priority: 100, userData: null);

// Check scene status
bool isLoaded = scene.SceneIsLoaded("Assets/Scenes/Level1.unity");
bool isLoading = scene.SceneIsLoading("Assets/Scenes/Level1.unity");

// Get loaded scene names
string[] loadedScenes = scene.GetLoadedSceneAssetNames();
foreach (string sceneName in loadedScenes)
{
    Log.Info("Loaded scene: {0}", sceneName);
}

// Get loading scene names
string[] loadingScenes = scene.GetLoadingSceneAssetNames();

// Unload scene
scene.UnloadScene("Assets/Scenes/Level1.unity");
scene.UnloadScene("Assets/Scenes/Level1.unity", userData: null);

// Get scene name from asset path
string sceneName = SceneComponent.GetSceneName("Assets/Scenes/Level1.unity");
// Returns: "Level1"

// Refresh main camera reference (call after loading new scene)
scene.RefreshMainCamera();

// Event handlers
void OnLoadSceneSuccess(object sender, GameEventArgs e)
{
    LoadSceneSuccessEventArgs args = (LoadSceneSuccessEventArgs)e;
    Log.Info("Scene loaded: {0}, Duration: {1}s", args.SceneAssetName, args.Duration);
}

void OnLoadSceneFailure(object sender, GameEventArgs e)
{
    LoadSceneFailureEventArgs args = (LoadSceneFailureEventArgs)e;
    Log.Error("Scene load failed: {0}, Error: {1}", args.SceneAssetName, args.ErrorMessage);
}

void OnLoadSceneUpdate(object sender, GameEventArgs e)
{
    LoadSceneUpdateEventArgs args = (LoadSceneUpdateEventArgs)e;
    Log.Info("Scene loading progress: {0}%%", args.Progress * 100f);
}

void OnUnloadSceneSuccess(object sender, GameEventArgs e)
{
    UnloadSceneSuccessEventArgs args = (UnloadSceneSuccessEventArgs)e;
    Log.Info("Scene unloaded: {0}", args.SceneAssetName);
}

```

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

### Config Module: Loading and Accessing Configuration Data in Unity

Source: https://context7.com/ellanjiang/unitygameframework/llms.txt

Shows how to use the ConfigComponent to load, access, and manage game configuration data from asset files. It covers subscribing to load events, retrieving values with defaults, and adding/removing configurations at runtime.

```csharp
using UnityGameFramework.Runtime;
using GameFramework.Event;

ConfigComponent config = GameEntry.GetComponent<ConfigComponent>();
EventComponent eventComponent = GameEntry.GetComponent<EventComponent>();

// Subscribe to config load events
eventComponent.Subscribe(LoadConfigSuccessEventArgs.EventId, OnLoadConfigSuccess);
eventComponent.Subscribe(LoadConfigFailureEventArgs.EventId, OnLoadConfigFailure);

// Load configuration file asynchronously
config.ReadData("Assets/Configs/GameConfig.txt");
config.ReadData("Assets/Configs/GameConfig.txt", priority: 100);

// Check if config exists
bool hasConfig = config.HasConfig("PlayerSpeed");

// Retrieve configuration values with defaults
float playerSpeed = config.GetFloat("PlayerSpeed", 5.0f);
int maxPlayers = config.GetInt("MaxPlayers", 4);
bool soundEnabled = config.GetBool("SoundEnabled", true);
string serverUrl = config.GetString("ServerUrl", "https://default.server.com");

// Add or modify configs at runtime
config.AddConfig("NewSetting", "NewValue");

// Remove configs
config.RemoveConfig("OldSetting");
config.RemoveAllConfigs();

// Event handlers
void OnLoadConfigSuccess(object sender, GameEventArgs e)
{
    LoadConfigSuccessEventArgs args = (LoadConfigSuccessEventArgs)e;
    Log.Info("Config loaded: {0}, Duration: {1}s", args.ConfigAssetName, args.Duration);
}

void OnLoadConfigFailure(object sender, GameEventArgs e)
{
    LoadConfigFailureEventArgs args = (LoadConfigFailureEventArgs)e;
    Log.Error("Config load failed: {0}, Error: {1}", args.ConfigAssetName, args.ErrorMessage);
}
```

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

### Accessing Unity Game Framework Components via GameEntry

Source: https://context7.com/ellanjiang/unitygameframework/llms.txt

Demonstrates how to access various framework components (Entity, UI, Event, Config) using the central GameEntry static class. It also shows how to shut down the framework with different options.

```csharp
using UnityGameFramework.Runtime;

// Access any framework component
EntityComponent entityComponent = GameEntry.GetComponent<EntityComponent>();
UIComponent uiComponent = GameEntry.GetComponent<UIComponent>();
EventComponent eventComponent = GameEntry.GetComponent<EventComponent>();
ConfigComponent configComponent = GameEntry.GetComponent<ConfigComponent>();

// Shutdown the framework
GameEntry.Shutdown(ShutdownType.Quit);     // Quit application
GameEntry.Shutdown(ShutdownType.Restart);  // Restart framework
GameEntry.Shutdown(ShutdownType.None);     // Cleanup only
```

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

### Manage Audio Playback with Unity Game Framework Sound Module (C#)

Source: https://context7.com/ellanjiang/unitygameframework/llms.txt

Demonstrates how to use the SoundComponent for managing audio playback. It covers playing 2D and 3D sounds, binding sounds to entities, controlling sound groups, and handling playback events. Requires UnityGameFramework and GameFramework.Event.

```csharp
using UnityGameFramework.Runtime;
using GameFramework.Event;
using UnityEngine;

SoundComponent sound = GameEntry.GetComponent<SoundComponent>();
EventComponent eventComponent = GameEntry.GetComponent<EventComponent>();

// Subscribe to sound events
eventComponent.Subscribe(PlaySoundSuccessEventArgs.EventId, OnPlaySoundSuccess);
eventComponent.Subscribe(PlaySoundFailureEventArgs.EventId, OnPlaySoundFailure);

// Sound groups should be configured in Inspector or created at runtime
// Each group can have independent volume control and audio mixer settings

// Play 2D sound (UI sounds, music)
int soundId = sound.PlaySound(
    soundAssetName: "Assets/Audio/BGM_Menu.mp3",
    soundGroupName: "Music",
    priority: 0,
    playSoundParams: PlaySoundParams.Create()
);

// Play 3D spatial sound at world position
PlaySoundParams spatialParams = PlaySoundParams.Create();
spatialParams.SpatialBlend = 1.0f;  // Full 3D
spatialParams.Volume = 0.8f;
spatialParams.Loop = false;
spatialParams.VolumeInSoundGroup = 1.0f;
spatialParams.Position = new Vector3(10, 0, 5);

soundId = sound.PlaySound(
    soundAssetName: "Assets/Audio/SFX_Explosion.wav",
    soundGroupName: "SFX",
    priority: 100,
    playSoundParams: spatialParams,
    userData: null
);

// Play sound bound to entity (follows entity position)
Entity playerEntity = GameEntry.GetComponent<EntityComponent>().GetEntity(1001);
PlaySoundParams entityParams = PlaySoundParams.Create();
entityParams.SpatialBlend = 1.0f;
entityParams.Volume = 1.0f;
entityParams.Loop = true;

soundId = sound.PlaySound(
    soundAssetName: "Assets/Audio/SFX_Footsteps.wav",
    soundGroupName: "SFX",
    bindingEntity: playerEntity,
    playSoundParams: entityParams
);

// Control sound groups
sound.SetSoundGroupMute("Music", true);  // Mute music group
sound.SetSoundGroupMute("Music", false);  // Unmute
sound.SetSoundGroupVolume("Music", 0.5f);  // Set group volume (0.0 - 1.0)

// Check if sound is playing
bool isPlaying = sound.IsSoundPlaying(soundId);

// Stop specific sound
sound.StopSound(soundId);
sound.StopSound(soundId, fadeOutSeconds: 1.0f);

// Stop all sounds in a group
sound.StopAllLoadedSounds("SFX");
sound.StopAllLoadedSounds("Music", fadeOutSeconds: 2.0f);

// Stop all sounds
sound.StopAllLoadingSounds();

// Pause and resume
sound.PauseSound(soundId);
sound.PauseSound(soundId, fadeOutSeconds: 0.5f);
sound.ResumeSound(soundId);
sound.ResumeSound(soundId, fadeInSeconds: 0.5f);

// Event handlers
void OnPlaySoundSuccess(object sender, GameEventArgs e)
{
    PlaySoundSuccessEventArgs args = (PlaySoundSuccessEventArgs)e;
    Log.Info("Sound playing: {0}, Serial ID: {1}, Duration: {2}s",
        args.SoundAssetName, args.SoundSerialId, args.Duration);
}

void OnPlaySoundFailure(object sender, GameEventArgs e)
{
    PlaySoundFailureEventArgs args = (PlaySoundFailureEventArgs)e;
    Log.Error("Sound failed: {0}, Error: {1}",
        args.SoundAssetName, args.ErrorMessage);
}

```

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

### Managing Core Settings with BaseComponent in Unity Game Framework

Source: https://context7.com/ellanjiang/unitygameframework/llms.txt

Illustrates how to use the BaseComponent for fundamental framework settings, including controlling frame rate, game speed, pausing/resuming the game, and checking the resource mode. BaseComponent must be attached to a GameObject in the scene.

```csharp
using UnityGameFramework.Runtime;

// BaseComponent should be attached to a GameObject in the scene
// Access via GameEntry
BaseComponent baseComponent = GameEntry.GetComponent<BaseComponent>();

// Control frame rate
baseComponent.FrameRate = 60;

// Control game speed (time scale)
baseComponent.GameSpeed = 1.0f;  // Normal speed
baseComponent.GameSpeed = 0.5f;  // Half speed
baseComponent.GameSpeed = 2.0f;  // Double speed

// Pause and resume game
baseComponent.PauseGame();
bool isPaused = baseComponent.IsGamePaused;
baseComponent.ResumeGame();

// Check resource mode
bool isEditorMode = baseComponent.EditorResourceMode;
```

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

### C# Finite State Machine Implementation for Player

Source: https://context7.com/ellanjiang/unitygameframework/llms.txt

This C# code defines states (Idle, Move, Attack) for a Player entity within a Finite State Machine. It demonstrates state transitions, lifecycle methods (OnEnter, OnUpdate, OnLeave), and data management within states. Dependencies include UnityGameFramework.Runtime and GameFramework.Fsm.

```csharp
using UnityGameFramework.Runtime;
using GameFramework.Fsm;
using GameFramework;

// Define state classes
public class IdleState : FsmState<Player>
{
    protected override void OnEnter(IFsm<Player> fsm)
    {
        base.OnEnter(fsm);
        Log.Info("Player entered Idle state");
        fsm.Owner.SetAnimation("Idle");
    }

    protected override void OnUpdate(IFsm<Player> fsm, float elapseSeconds, float realElapseSeconds)
    {
        base.OnUpdate(fsm, elapseSeconds, realElapseSeconds);

        if (fsm.Owner.IsMoving)
        {
            ChangeState<MoveState>(fsm);
        }
    }

    protected override void OnLeave(IFsm<Player> fsm, bool isShutdown)
    {
        base.OnLeave(fsm, isShutdown);
        Log.Info("Player left Idle state");
    }
}

public class MoveState : FsmState<Player>
{
    protected override void OnEnter(IFsm<Player> fsm)
    {
        base.OnEnter(fsm);
        fsm.Owner.SetAnimation("Move");
        fsm.SetData<VarSingle>("MoveSpeed", 5.0f);
    }

    protected override void OnUpdate(IFsm<Player> fsm, float elapseSeconds, float realElapseSeconds)
    {
        base.OnUpdate(fsm, elapseSeconds, realElapseSeconds);

        VarSingle moveSpeed = fsm.GetData<VarSingle>("MoveSpeed");
        fsm.Owner.Move(moveSpeed.Value * elapseSeconds);

        if (!fsm.Owner.IsMoving)
        {
            ChangeState<IdleState>(fsm);
        }
        else if (fsm.Owner.IsAttacking)
        {
            ChangeState<AttackState>(fsm);
        }
    }
}

public class AttackState : FsmState<Player>
{
    protected override void OnEnter(IFsm<Player> fsm)
    {
        base.OnEnter(fsm);
        fsm.Owner.SetAnimation("Attack");
    }

    protected override void OnUpdate(IFsm<Player> fsm, float elapseSeconds, float realElapseSeconds)
    {
        base.OnUpdate(fsm, elapseSeconds, realElapseSeconds);

        if (fsm.Owner.AttackFinished)
        {
            ChangeState<IdleState>(fsm);
        }
    }
}

public class Player
{
    public bool IsMoving { get; set; }
    public bool IsAttacking { get; set; }
    public bool AttackFinished { get; set; }

    public void SetAnimation(string animName) { /* ... */ }
    public void Move(float distance) { /* ... */ }
}

// Usage
FsmComponent fsmComponent = GameEntry.GetComponent<FsmComponent>();
Player player = new Player();

// Create FSM with multiple states
IFsm<Player> playerFsm = fsmComponent.CreateFsm(
    name: "PlayerFSM",
    owner: player,
    states: new FsmState<Player>[]
    {
        new IdleState(),
        new MoveState(),
        new AttackState()
    }
);

// Start FSM with initial state
playerFsm.Start<IdleState>();

// Get current state
Type currentState = playerFsm.CurrentState.GetType();
string currentStateName = playerFsm.CurrentStateName;
float timeInState = playerFsm.CurrentStateTime;

// Check if FSM exists
bool hasFsm = fsmComponent.HasFsm<Player>("PlayerFSM");

// Get FSM by name
IFsm<Player> fsm = fsmComponent.GetFsm<Player>("PlayerFSM");

// Destroy FSM
fsmComponent.DestroyFsm<Player>("PlayerFSM");
fsmComponent.DestroyFsm(playerFsm);

```

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

### C# TCP Socket Networking with Custom Packets in Unity Game Framework

Source: https://context7.com/ellanjiang/unitygameframework/llms.txt

Demonstrates how to establish TCP socket connections using Unity Game Framework's Network component. It includes defining custom packet structures, implementing network channel helpers for serialization/deserialization, subscribing to network events, creating and configuring network channels, sending packets, and handling network events. Dependencies include UnityGameFramework.Runtime, GameFramework.Network, and GameFramework.Event.

```csharp
using UnityGameFramework.Runtime;
using GameFramework.Network;
using GameFramework.Event;
using System;

// Define custom packet class
public class LoginPacket : Packet
{
    public override int Id { get { return 1001; } }

    public string Username { get; set; }
    public string Password { get; set; }

    public override void Clear()
    {
        Username = null;
        Password = null;
    }
}

// Define network channel helper
public class GameNetworkChannelHelper : INetworkChannelHelper
{
    public void Initialize(INetworkChannel networkChannel)
    {
        // Initialize network channel
    }

    public void PrepareForConnecting()
    {
        // Called before connecting
    }

    public void Shutdown()
    {
        // Cleanup
    }

    public IPacketHeader DeserializePacketHeader(byte[] source, object userData)
    {
        // Deserialize packet header
        return null;
    }

    public Packet DeserializePacket(IPacketHeader packetHeader, byte[] source, object userData)
    {
        // Deserialize packet body
        return null;
    }

    public bool SerializePacket(Packet packet, byte[] destination, out int length, out object userData)
    {
        // Serialize packet
        length = 0;
        userData = null;
        return true;
    }
}

// Usage
NetworkComponent network = GameEntry.GetComponent<NetworkComponent>();
EventComponent eventComponent = GameEntry.GetComponent<EventComponent>();

// Subscribe to network events
eventComponent.Subscribe(NetworkConnectedEventArgs.EventId, OnNetworkConnected);
eventComponent.Subscribe(NetworkClosedEventArgs.EventId, OnNetworkClosed);
eventComponent.Subscribe(NetworkErrorEventArgs.EventId, OnNetworkError);
eventComponent.Subscribe(NetworkCustomErrorEventArgs.EventId, OnNetworkCustomError);

// Create network channel
INetworkChannel channel = network.CreateNetworkChannel(
    name: "GameServer",
    serviceType: ServiceType.Tcp,
    networkChannelHelper: new GameNetworkChannelHelper()
);

// Configure channel
channel.HeartBeatInterval = 30f;  // Heartbeat every 30 seconds
channel.MissHeartBeatCount = 3;   // Disconnect after 3 missed heartbeats

// Connect to server (IPv4)
channel.Connect("127.0.0.1", 8080);

// Connect to server (IPv6)
channel.Connect("::1", 8080);

// Connect with user data
channel.Connect("game.example.com", 8080, userData: null);

// Check connection status
bool isConnected = channel.Connected;

// Send packet
LoginPacket loginPacket = new LoginPacket
{
    Username = "player123",
    Password = "password"
};
channel.Send(loginPacket);

// Register packet handler
channel.RegisterHandler(new CustomPacketHandler());

// Close connection
channel.Close();

// Destroy channel
network.DestroyNetworkChannel("GameServer");

// Event handlers
void OnNetworkConnected(object sender, GameEventArgs e)
{
    NetworkConnectedEventArgs args = (NetworkConnectedEventArgs)e;
    Log.Info("Connected to: {0}", args.NetworkChannel.Name);
}

void OnNetworkClosed(object sender, GameEventArgs e)
{
    NetworkClosedEventArgs args = (NetworkClosedEventArgs)e;
    Log.Info("Connection closed: {0}", args.NetworkChannel.Name);
}

void OnNetworkError(object sender, GameEventArgs e)
{
    NetworkErrorEventArgs args = (NetworkErrorEventArgs)e;
    Log.Error("Network error on {0}: {1}", args.NetworkChannel.Name, args.ErrorMessage);
}

void OnNetworkCustomError(object sender, GameEventArgs e)
{
    NetworkCustomErrorEventArgs args = (NetworkCustomErrorEventArgs)e;
    Log.Error("Custom network error: {0}", args.CustomErrorData);
}

```

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

### C# Object Pooling with Unity Game Framework

Source: https://context7.com/ellanjiang/unitygameframework/llms.txt

Demonstrates how to implement and utilize object pools in Unity using the UnityGameFramework.Runtime and GameFramework.ObjectPool libraries. It includes defining custom pooled objects, creating different types of pools (single-spawn and multi-spawn), managing object lifecycle (spawning, unspawning, releasing), and retrieving pool information. This approach helps optimize performance by reusing objects instead of constantly instantiating and destroying them.

```csharp
using UnityGameFramework.Runtime;
using GameFramework.ObjectPool;
using GameFramework;
using UnityEngine;

// Define pooled object class
public class BulletObject : ObjectBase
{
    private GameObject m_GameObject;

    public BulletObject(GameObject gameObject)
    {
        m_GameObject = gameObject;
    }

    public override string Name { get { return m_GameObject.name; } }
    public override object Target { get { return m_GameObject; } }

    public GameObject GameObject { get { return m_GameObject; } }

    protected internal override void Release(bool isShutdown)
    {
        // Cleanup when object is released from pool
        Object.Destroy(m_GameObject);
    }
}

// Usage Example:
// Assuming ObjectPoolComponent is available via GameEntry
// ObjectPoolComponent pool = GameEntry.GetComponent<ObjectPoolComponent>();

// --- Pool Creation ---
// Create single-spawn object pool (object can only be spawned once at a time)
/*
IObjectPool<BulletObject> bulletPool = pool.CreateSingleSpawnObjectPool<BulletObject>(
    name: "BulletPool",
    autoReleaseInterval: 60f,  // Auto-release interval (seconds)
    capacity: 100,              // Pool capacity
    expireTime: 60f,            // Object expire time (seconds)
    priority: 0                 // Pool priority
);
*/

// Create multi-spawn object pool (object can be spawned multiple times)
/*
IObjectPool<BulletObject> multiSpawnPool = pool.CreateMultiSpawnObjectPool<BulletObject>(
    name: "MultiSpawnBulletPool",
    autoReleaseInterval: 60f,
    capacity: 100,
    expireTime: 60f,
    priority: 0
);
*/

// --- Object Management ---
// Spawn object from pool (example: manual instantiation before pooling)
/*
GameObject bulletPrefab = Resources.Load<GameObject>("Bullet");
GameObject bulletGO = Object.Instantiate(bulletPrefab);
BulletObject bullet = new BulletObject(bulletGO);
bulletPool.Register(bullet, spawned: true);
*/

// Unspawn object (return to pool)
/*
bulletPool.Unspawn(bullet);
*/

// Spawn existing pooled object by name (requires prior registration or pool setup)
/*
bulletPool.Spawn("Bullet_001");
*/

// --- Pool Information ---
// Get pool count
/*
int count = bulletPool.Count;
int canReleaseCount = bulletPool.CanReleaseCount;
int allowAcquireCount = bulletPool.AllowAcquireCount;
int allowSpawnCount = bulletPool.AllowSpawnCount;
*/

// --- Pool Release ---
// Release unused objects
/*
bulletPool.Release();  // Release one object
bulletPool.Release(10);  // Release up to 10 objects
bulletPool.ReleaseAllUnused();  // Release all unused objects in this pool
*/

// --- Pool Existence and Retrieval ---
// Check if pool exists
/*
bool hasPool = pool.HasObjectPool<BulletObject>("BulletPool");
*/

// Get pool by name
/*
IObjectPool<BulletObject> existingPool = pool.GetObjectPool<BulletObject>("BulletPool");
*/

// --- Pool Destruction ---
// Destroy pool
/*
pool.DestroyObjectPool<BulletObject>("BulletPool");
*/

// Release all unused objects in all pools managed by the component
/*
pool.ReleaseAllUnused();
*/

```

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

### C# Entity Logic and Usage in UnityGameFramework

Source: https://context7.com/ellanjiang/unitygameframework/llms.txt

Defines custom entity logic by extending EntityLogic and demonstrates usage patterns within UnityGameFramework. This includes initialization, showing, hiding, updating, attaching/detaching entities, and handling related events. It requires UnityGameFramework.Runtime and GameFramework.Event namespaces.

```csharp
using UnityGameFramework.Runtime;
using GameFramework.Event;
using UnityEngine;

// Define custom entity logic
public class PlayerEntity : EntityLogic
{
    private float m_Speed = 5.0f;

    protected internal override void OnInit(object userData)
    {
        base.OnInit(userData);
        // Initialize entity (called once when created)
    }

    protected internal override void OnShow(object userData)
    {
        base.OnShow(userData);
        // Entity is shown/spawned
        PlayerData data = (PlayerData)userData;
        m_Speed = data.Speed;
        CachedTransform.position = data.Position;
    }

    protected internal override void OnHide(bool isShutdown, object userData)
    {
        base.OnHide(isShutdown, userData);
        // Entity is hidden/despawned
    }

    protected internal override void OnUpdate(float elapseSeconds, float realElapseSeconds)
    {
        base.OnUpdate(elapseSeconds, realElapseSeconds);
        // Update logic each frame
        CachedTransform.position += Vector3.forward * m_Speed * elapseSeconds;
    }

    protected internal override void OnAttachTo(EntityLogic parentEntity, Transform parentTransform, object userData)
    {
        base.OnAttachTo(parentEntity, parentTransform, userData);
        // This entity attached to parent (e.g., weapon attached to player)
    }

    protected internal override void OnDetachFrom(EntityLogic parentEntity, object userData)
    {
        base.OnDetachFrom(parentEntity, userData);
        // This entity detached from parent
    }
}

public class PlayerData
{
    public Vector3 Position { get; set; }
    public float Speed { get; set; }
}

// Usage
EntityComponent entity = GameEntry.GetComponent<EntityComponent>();
EventComponent eventComponent = GameEntry.GetComponent<EventComponent>();

// Subscribe to entity events
eventComponent.Subscribe(ShowEntitySuccessEventArgs.EventId, OnShowEntitySuccess);
eventComponent.Subscribe(ShowEntityFailureEventArgs.EventId, OnShowEntityFailure);
eventComponent.Subscribe(HideEntityCompleteEventArgs.EventId, OnHideEntityComplete);

// Create entity group with pooling settings
entity.AddEntityGroup("PlayerGroup", instanceAutoReleaseInterval: 60f,
    instanceCapacity: 10, instanceExpireTime: 60f, instancePriority: 0);

// Show entity (spawn with pooling)
PlayerData playerData = new PlayerData
{
    Position = Vector3.zero,
    Speed = 5.0f
};
entity.ShowEntity<PlayerEntity>(
    entityId: 1001,
    entityAssetName: "Assets/Entities/Player.prefab",
    entityGroupName: "PlayerGroup",
    userData: playerData
);

// Get entity by ID
Entity player = entity.GetEntity(1001);
if (player != null)
{
    PlayerEntity logic = player.Logic as PlayerEntity;
    // Access entity logic
}

// Attach entities (e.g., weapon to player)
entity.AttachEntity(
    childEntityId: 2001,  // Weapon entity ID
    parentEntityId: 1001,  // Player entity ID
    parentTransformPath: "RightHand",  // Attachment point
    userData: null
);

// Detach entities
entity.DetachEntity(childEntityId: 2001, userData: null);

// Hide entity (return to pool)
entity.HideEntity(1001);
entity.HideEntity(1001, userData: null);

// Event handlers
void OnShowEntitySuccess(object sender, GameEventArgs e)
{
    ShowEntitySuccessEventArgs args = (ShowEntitySuccessEventArgs)e;
    Log.Info("Entity shown: ID={0}, Duration={1}s", args.Entity.Id, args.Duration);
}

void OnShowEntityFailure(object sender, GameEventArgs e)
{
    ShowEntityFailureEventArgs args = (ShowEntityFailureEventArgs)e;
    Log.Error("Entity failed: ID={0}, Asset={1}, Error={2}",
        args.EntityId, args.EntityAssetName, args.ErrorMessage);
}

void OnHideEntityComplete(object sender, GameEventArgs e)
{
    HideEntityCompleteEventArgs args = (HideEntityCompleteEventArgs)e;
    Log.Info("Entity hidden: ID={0}", args.EntityId);
}

```