f8-foundation-bootstrap-workflow

F8 Foundation Bootstrap Workflow

Use this skill when

• The project is new to F8Framework.
• The user asks how to start, what to click first, or where modules live.
• A downstream feature task is blocked by missing bootstrap context.
• The user needs to understand GameLauncher or module initialization order.

Path resolution

1. Prefer project source at Assets/F8Framework.
2. If F8Framework is installed as a package, use Packages/F8Framework.
3. Keep all follow-up routing consistent with the same root (Assets or Packages).

Sources of truth

• Assets/F8Framework/README.md or Packages/F8Framework/README.md
• Assets/F8Framework/Launcher/GameLauncher.cs or Packages/F8Framework/Launcher/GameLauncher.cs
• Assets/F8Framework/Launcher/FF8.cs or Packages/F8Framework/Launcher/FF8.cs
• Assets/F8Framework/Tests or Packages/F8Framework/Tests

Key classes and interfaces

GameLauncher.cs — full reference

using System.Collections;
using F8Framework.Core;
using F8Framework.F8ExcelDataClass;
using UnityEngine;

namespace F8Framework.Launcher
{
    public class GameLauncher : MonoBehaviour
    {
        // 使用协程 IEnumerator Start()，支持异步加载
        IEnumerator Start()
        {
            // 1. 初始化模块中心（必须首先调用）
            ModuleCenter.Initialize(this);

            // 2. 初始化热更新版本管理（可选模块，建议最先创建）
            FF8.HotUpdate = ModuleCenter.CreateModule<HotUpdateManager>();

            // 3. 按顺序创建核心模块（顺序影响依赖关系）
            FF8.Message = ModuleCenter.CreateModule<MessageManager>();
            FF8.Input = ModuleCenter.CreateModule<InputManager>(new DefaultInputHelper());
            FF8.Storage = ModuleCenter.CreateModule<StorageManager>();
            FF8.Timer = ModuleCenter.CreateModule<TimerManager>();
            FF8.Procedure = ModuleCenter.CreateModule<ProcedureManager>();
            FF8.Network = ModuleCenter.CreateModule<NetworkManager>();
            FF8.FSM = ModuleCenter.CreateModule<FSMManager>();
            FF8.GameObjectPool = ModuleCenter.CreateModule<GameObjectPool>();
            FF8.Asset = ModuleCenter.CreateModule<AssetManager>();

            // 4. 加载 AssetBundleManifest（必须在 AssetManager 模块创建之后）
            yield return AssetBundleManager.Instance.LoadAssetBundleManifest();

            FF8.Config = ModuleCenter.CreateModule<F8DataManager>();
            FF8.Audio = ModuleCenter.CreateModule<AudioManager>();
            FF8.Tween = ModuleCenter.CreateModule<Tween>();
            FF8.UI = ModuleCenter.CreateModule<UIManager>();

            // 5. 加载 LocalizedStrings 配置表（必须在 Localization 模块创建之前）
            yield return F8DataManager.Instance.LoadLocalizedStringsIEnumerator();

            FF8.Local = ModuleCenter.CreateModule<Localization>(
                F8DataManager.Instance.GetLocalizedStrings());
            FF8.SDK = ModuleCenter.CreateModule<SDKManager>();
            FF8.Download = ModuleCenter.CreateModule<DownloadManager>();
            FF8.LogWriter = ModuleCenter.CreateModule<F8LogWriter>();

            yield return new WaitForEndOfFrame();

            // 6. 所有模块就绪，开始游戏逻辑
            StartGame();
            yield break;
        }

        // 开始游戏（在此添加游戏入口逻辑）
        public void StartGame()
        {
            // 例如：FF8.Procedure.RunProcedureNode<InitProcedure>();
        }

        void Update()
        {
            // 驱动所有模块的 Update，切勿在其他地方重复调用
            ModuleCenter.Update();
        }

        void LateUpdate()
        {
            // 驱动所有模块的 LateUpdate，切勿在其他地方重复调用
            ModuleCenter.LateUpdate();
        }

        void FixedUpdate()
        {
            // 驱动所有模块的 FixedUpdate，切勿在其他地方重复调用
            ModuleCenter.FixedUpdate();
        }
    }
}

FF8.cs — lazy initialization pattern

FF8 是一个静态类，每个模块属性都有懒加载机制：

public static class FF8
{
    // 每个属性同时支持 get（懒创建）和 set（手动赋值）
    public static MessageManager Message
    {
        get
        {
            if (_message == null)
                _message = ModuleCenter.CreateModule<MessageManager>();
            return _message;
        }
        set
        {
            if (_message == null)
                _message = value;
        }
    }
    // ... 其他模块同此模式
}

重要特性：

• 如果 GameLauncher 中已通过 set 赋值，后续 get 直接返回已创建的实例
• 如果未通过 GameLauncher 初始化，首次 get 会自动创建模块（懒加载）
• GameObjectPool 的 set 和 get 都以 GameObjectPool 自身作为唯一对象池入口
• Localization 的 get 会自动调用 F8DataManager.Instance.GetLocalizedStrings() 获取翻译数据
• InputManager 的 get 会自动传入 new DefaultInputHelper() 作为参数

Module dependency chain (creation order matters)

ModuleCenter.Initialize(this)  ← 必须最先
    ↓
HotUpdateManager               ← 可选，建议最先
    ↓
MessageManager                  ← 全局消息（被 Input, Timer, SDK 依赖）
InputManager(DefaultInputHelper)← 依赖 Message
StorageManager
TimerManager                    ← 依赖 Message
ProcedureManager
NetworkManager
FSMManager
GameObjectPool
AssetManager
    ↓
yield return LoadAssetBundleManifest()  ← 异步！必须在 AssetManager 之后
    ↓
F8DataManager(Config)           ← 依赖 Asset
AudioManager                    ← 依赖 Asset, GameObjectPool, Tween, Timer
Tween
UIManager                       ← 依赖 Asset
    ↓
yield return LoadLocalizedStringsIEnumerator()  ← 异步！必须在 Localization 之前
    ↓
Localization(GetLocalizedStrings()) ← 依赖 Config, Asset
SDKManager                      ← 依赖 Message
DownloadManager
F8LogWriter

Directory structure map

First-run checklist

1. Import framework: git clone 或 Package Manager 导入
2. Press F8: 自动生成资源索引、AB名和配置数据类
3. 挂接 GameLauncher: 确保场景中有 GameObject 挂载 GameLauncher 组件
4. 检查初始化顺序: 在 GameLauncher.Start() 中按依赖链创建模块
5. 编写 StartGame(): 在所有模块就绪后启动游戏逻辑
6. 跳转目标层技能: 按任务类型路由到 features / editor / tools / build

Operation steps

1. Read README from Assets/F8Framework/README.md to extract startup intent, supported platforms, and first-run notes.
2. Confirm launcher entry in Launcher/GameLauncher.cs and module-name customization in Launcher/FF8.cs.
3. Map directories for the user with strict boundaries as shown above.
4. Provide a minimal start path in order:
   • Import or sync framework (git clone or Package Manager)
   • Press F8 to generate asset index and config classes
   • Verify GameLauncher is attached to a scene GameObject
   • Check module initialization order in GameLauncher.Start()
   • Move to target layer skill
5. Route task by target intent:
   • features: runtime module implementation and behavior
   • editor: editor window/menu/inspector tooling
   • tools: Runtime/Utility helper internals
   • build: packaging and artifact verification

Common error handling

Output checklist

• Explain startup sequence in concrete steps.
• Name the exact folders the user should inspect next.
• State which follow-up layer skill should be used for the actual task.