public class V : QFramework.Architecture<V>
{
    protected override void Init(){ }
}

public class Launcher : MonoController, ICanSendEvent
{
    void Start()
    {
        // 初始化框架
        Vomit.Init(V.Interface);
    }
}

public abstract class ProcedureState<T> : ICanGetModel, ICanGetUtility, ICanGetSystem, ICanRegisterEvent, ICanSendEvent, ICanSendCommand, IState

    // 声明Procedure的状态枚举
    public enum GameProcedureState { Launch, Home, Town, Battle,}   // 启动流程, 主页流程, 城镇流程, 战斗流程
    
    // 声明一个启动流程类,并且作为入口流程.
    [Procedure(ProcedureID = GameProcedureState.Launch, IsEntry = true)]
    public class ProcedureLaunch : ProcedureState<GameProcedureState>
    {
        public override bool Condition() => false;  // 不可逆
        
        public override void Enter()
        {
            // Do something...
            ChangeState(JGT.JGTProcedure.Home);     // 进入主界面流程
        }

        public override void Exit()
        {
            LogKit.I("启动流程结束!");
        }
    }
    
    // 声明一个主页流程类
    [Procedure(ProcedureID = GameProcedureState.Home)]
    public class ProcedureHome : ProcedureState<GameProcedureState>
    {
        public override bool Condition()
        {
            return CurrentProcedure == ProcedureState.Launch;   // 启动流程 => 主页流程
        }
        
        public override void Enter()
        {
            View.Open<ViewHome>();                  // 打开主页UI
            // Do something...   
            ChangeState(JGT.JGTProcedure.Town);     // 切换状态
        }

        public override void Exit()
        {
            View.Close<ViewHome>();                 // 关闭主页UI
            LogKit.I("主页流程结束!");
        }
    }
    
    // 声明一个城镇流程类
    [Procedure(ProcedureID = GameProcedureState.Town)]
    public class ProcedureTown : ProcedureState<GameProcedureState>
    {
        public override bool Condition()
        {
            // 启动流程 => 城镇流程 ; 战斗流程 => 城镇流程
            return CurrentProcedure == ProcedureState.Home || CurrentProcedure == ProcedureState.Battle;   
        }
        
        public async override  void Enter()
        {   
            // 监听战斗开始事件, 切换状态, 事件自动取消监听
            this.RegisterProcedureEvent<BattleStart> (e => ChangeState(ProcedureState.Battle));
            
            if(PrevProcedure == ProcedureState.Home) {/* 进入游戏逻辑 */}
            
            if(PrevProcedure == ProcedureState.Battle) {/* 战斗归来逻辑 */}
        }
        
        public override void OnUpdate() { }     // 提供 Update 方法
        public override void OnFixUpdate() { }  // 提供 FixUpdate 方法

        public override void Exit() { }
    }
   

 public class ArenaSystem : AbstractSystem
 {
     
     public async void Continue()
     {
        // ...
        await DrawRewardCard(3);        // 抽取三张奖励卡

        // (int winArgumentIndex, EArena.ConfirmCard result1, EArena.ConfirmCard result2)
        var result = await Event.WaitEvent<EArena.ConfirmCard, EArena.SkipReward>();        // 等待玩家选择奖励或是跳过奖励,支持同时监听多个事件, 相当于 WhenAny()
        
        if(result.winArgumentIndex == 0)
        {
            // 确认奖励
        }
        
        if(result.winArgumentIndex == 1)
        {
            // 跳过奖励
        }
        await ClearAllCards();
        await ChangeArenaState(ArenaState.Rewarded);
        await UniTask.WaitForSeconds(1);
     }
 }

    // 声明一个异步事件
    [AsyncEvent]
    public struct TestEvent { public string Str; }
    
    // ICanSendEvent
    public class Test : MonoController, ICanSendEvent
    {
        async UniTask Delay(string str)
        {
            await UniTask.WaitForSeconds(2);    // 延迟 2s.
            LogKit.I($"{str} With Async Call");
        }
        
        async void Start()
        {
            // 注册异步任务
            this.RegisterAliveEvent<TestEvent>(e =>
            {
                e.AddTask(Delay(e.Str));
            });
            
            // 也可以注册同步任务
            this.RegisterAliveEvent<TestEvent>(e =>
            {
                LogKit.I(e.Str);
            });
            
            // 异步任务完成回调事件, 通常多个controller层会监听同一个异步事件,但不一定都提供异步方法.
            this.RegisterAliveEvent<TestAsyncEvent>(e =>
            {
                e.Done(() =>
                {
                    LogKit.I("I know this event done!");
                });
            });
            
            // 广播异步事件并等待
            await this.SendAsyncEvent(new TestEvent() {Str = "Hi"});
            
            // 所有事件回调执行完毕后调用
            LogKit.I("Finish!");
            
            // > Hi
            // > Hi With AsyncCall
            // > I know this event done!
            // > Finish
       }
}

// 当作普通的 MonoBehaviour 去开发
public class VCSwordIcon : ViewComponent
{
    public void Start()
    {
        this.RegisterViewEvent<>    // 监听事件, 组件销毁时自动取消监听.
    }
}

// UI 面板
public class ViewSwordDetail : ViewLogic
{
    public override UniTask OnOpened(ViewParameterBase param)
    {
        // 自动加载 ViewComponent 并实例化
        var icon = View.InstantiateVC<VCSwordIcon>(transform);
    }
 
    // 运行时自动绑定 UnityEditor 中的 BtnLogin,无需额外步骤
    private void __OnClick_BtnLogin()
    {
        LogKit.I("Click BtnLogin");
    }
}

public class Launch
{
    void Start()
    {
        // 同步打开一个 View
        View.OpenView<ViewSwordDetail>();
        // 异步打开一个 View, 可以在 View 的 OnOpen 中实现动画效果.
        await View.OpenViewAsync<ViewSwordDetail>();
        // 在打开时通过 QFramework 的事件系统 View 链式传递参数.
        await View.OpenViewAsync<ViewSwordDetail>().WithEvent(new ViewTestEvent {Params = "NewTest!"})
    }
}

public static void Init(Func<string, AudioClip> onSearchAudioClip = null, float bgmFactors = 0.8f, float bgmVolume = 1f, float seFactors = 1f, float seVolume = 1f)
   

    // 注册一类资源的索引拼接规则, 这里是不同骰子点数的Sprite
    Addr.RegisterRule<Sprite>(Constant.AssetType.Sprite.Dice, s => $"Sprites/Dices/Dice{s}@png.png");
    
    // 同步加载点数3的骰子
    Sprite dice3Sprite = Addr.Load<Sprite>(Constant.AssetType.Sprite.Dice, 3);
    
    // 异步加载点数6的骰子
    Sprite dice6Sprite = Addr.LoadAsync<Sprite>(Constant.AssetType.Sprite.Dice, 6).Forget();
    
    // 异步加载点数5的骰子
    Addr.LoadAsync<Sprite>(Constant.AssetType.Sprite.Dice, 5, sprite => {
        image.sprite = sprite;
    });
    
    // 可以同时异步加载所有图标而无需担心重复Load
    for(var itemID in Backpack.List)
    {
        Addr.LoadAsync<GameObejct>(Constant.AssetType.GameObejct.ItemToken, itemID, token => {
            token.Init(itemID);
        });
    }
    
    // 或是借助UniTask
    for(var itemID in Backpack.List)
    {
        var id = itemID;
        UniTask.Create(async () => {await Addr.LoadAsync<GameObejct>(Constant.AssetType.GameObejct.ItemToken, itemID).Init(id)});
    }
    

    
    public class ClientDB 
    {
        public static Tables T => ClientDB<Tables>.T;
        
        public static void Init()
        {
            // Tables 为鲁班生成代码
            ClientDB<Tables>.Init(new Tables(Loader, true));
        }
        
        private static JSONNode Loader(string fileName)
        {
            // 加载数据文件
            var asset = Addr.Load<TextAsset>(Constant.AssetType.Text.LubanData, fileName);
            string json = asset.text;
            Addressables.Release(asset);
            return JSON.Parse(json);
        }
    }
    
    // 更多时候,我们不是所有数据都通过excel配置.
    // 类似技能数据这种复杂数据,我配置excel会配到头晕,于是更喜欢自己的数据配置器
    public class SkillData : IEditable  // 实现 IEditable 接口
    {
        public int GetID();

        public string GetName();
    }
    
    // 扩展 Tables 
    public partial class Tables
    {
        // CustomTable<T> 提供和Luban生成代码风格一致的数据表
        public CustomTable<SkillData> TbSkill;
        
        public Tables(System.Func<string, JSONNode> loader, bool useSelfData) : this(loader)
        {
            // 加载自己实现的配置文件
            TbSkill = new CustomTable<SkillData>(Addr.Load<TextAsset>(Constant.AssetType.Text.JGTData, nameof(SkillData)).text);
        }
    }
    
    // 正常使用它
    ExecuteSkill(ClientDB.T.TbSkill[1001].Logic);