Unity SKFramework Documentation

CoderZ1010

已于 2023-07-14 11:32:40 修改

阅读量5.4k

点赞数 12

分类专栏： Unity SKFramework 文章标签： Unity SKFramework 框架

于 2023-02-02 14:22:43 首次发布

本文链接：https://blog.csdn.net/qq_42139931/article/details/128849528

版权

Unity SKFramework 专栏收录该内容

26 篇文章

订阅专栏

本文详细介绍了游戏开发中音频管理的各个方面，包括背景音乐播放、音效控制、音频库以及AudioListener的设置。此外，还讨论了事件处理系统，如Action事件类型、事件链（Sequence和Concurrent）以及时间轴事件链。接着，文章阐述了有限状态机（FSM）的实现，包括状态的创建、切换和构建。对象池的概念也被提及，用于管理和复用对象。最后，简要介绍了网络请求的发送方法及其数据结构。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Audio 音频

背景音乐

播放

void Play(AudioClip bgm)

参数：

bgm：背景音乐AudioClip资产

停止

void Stop()

是否循环

bool IsLoop { get; set; }

音量

float Volume { get; set; }

是否暂停

bool IsPaused { get; set; }

是否静音

bool IsMuted { get; set; }

是否正在播放

bool IsPlaying { get; }

播放进度

float Progress { get; }

暂停

void Pause()

取消暂停

void Unpause()

背景音乐有两种暂停方式：

将IsPaused属性设为false；
调用Pause方法。

区别：IsPaused设为false时立即暂停背景音乐播放，调用Pause方法是音量通过插值方式逐渐降为0，最终暂停背景音乐播放，有一个渐进的过程。

调用示例：

using UnityEngine;
using SK.Framework;

public class Example : MonoBehaviour
{
    [SerializeField] private AudioClip clip;

    private void Start()
    {
        Main.Audio.BGM.Play(clip);
        Main.Audio.BGM.Stop();
        Main.Audio.BGM.IsLoop = true;
        Main.Audio.BGM.Volume = 0.5f;
        Main.Audio.BGM.IsPaused = false;
        Main.Audio.BGM.IsMuted = false;
        bool isPlaying = Main.Audio.BGM.IsPlaying;
        float progress = Main.Audio.BGM.Progress;
        Main.Audio.BGM.Pause();
        Main.Audio.BGM.Unpause();
    }
}

音效

播放

AudioHandler Play(AudioClip clip, AudioMixerGroup output, float pitch, bool autoRecycle);
AudioHandler Play(AudioClip clip, Vector3 position, AudioMixerGroup output, float pitch, bool autoRecycle);
AudioHandler Play(AudioClip clip, Transform followTarget, AudioMixerGroup output, float pitch, bool autoRecycle);
AudioHandler Play(AudioClip clip, Vector3 position, float minDistance, float maxDistance, AudioMixerGroup output, float pitch, bool autoRecycle);
AudioHandler Play(AudioClip clip, Transform followTarget, float minDistance, float maxDistance, AudioMixerGroup output, float pitch, bool autoRecycle);

参数：

clip：音效AudioClip资产

output：混音组

position：音效播放的位置（3D音效）

followTarget：音效播放跟随的目标（3D音效）

pitch：音高

minDistance：最小距离（3D音效设置）

maxDistance：最大距离（3D音效设置）

autoRecycle：表示是否自动回收AudioHandler音频处理器（默认由对象池自动回收音频处理器）

返回值：

AudioHandler音频处理器

停止

void Stop()

是否暂停

bool IsPaused { get; set; }

是否静音

bool IsMuted { get; set; }

调用示例：

using UnityEngine;
using SK.Framework;

public class Example : MonoBehaviour
{
    [SerializeField] private AudioClip clip;

    private void Start()
    {
        Main.Audio.SFX.Play(clip, transform.position);
        Main.Audio.SFX.Stop();
        Main.Audio.SFX.IsPaused = false;
        Main.Audio.SFX.IsMuted = false;
    }
}

音频库

编辑音频库

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-W406mjYw-1689305523650)(C:\Users\admin\AppData\Roaming\Typora\typora-user-images\image-20230131173241705.png “编辑音频库”)]

在音频库中获取音频

AudioClip FromDatabase(string databaseName, string clipName)

参数：

databaseName：音频库名称

clipName：音频名称

返回值：

AudioClip音频

调用示例：

using UnityEngine;
using SK.Framework;

public class Example : MonoBehaviour
{
    private void Start()
    {
        AudioClip clip = Main.Audio.FromDatabase("Click", "click01");
    }
}

Audio Listener

设置Listener

void SetListener(Transform listenerTrans)

参数：

listenerTrans：Audio Listener跟随的物体，仅影响3D音效。

注：Audio Listener组件设置在框架Prefab中，注意移除Main Camera中的Audio Listener。

调用示例：

using UnityEngine;
using SK.Framework;

public class Example : MonoBehaviour
{
    private void Start()
    {
        Main.Audio.SetListener(transform);
    }
}

Actions 事件

Action 事件类型

Simple Action：普通事件，可以理解为一个简单的Action回调函数。
Delay Action：延迟事件，指定一个时长，在经过该时长后执行指定的回调函数。
Timer Action：定时事件，可以理解为定时器，分为正计时和倒计时，通过参数isReverse指定，事件为float参数类型事件，通过已经计时的时长（正计时）或剩余的时长（倒计时）调用执行。
Until Action：条件事件，直到条件成立，执行指定的回调函数。
While Action：条件事件，与Until条件事件不同的是，While条件事件中设置的回调函数在条件成立时一直被调用，当条件不再成立时，事件结束。
Tween Action：动画事件，依赖DoTween插件，Tween事件表示播放一个DoTween动画，动画播放完后，事件结束。
Animate Action：动画事件，通过Animator播放动画，需要指定Animator组件和Animator Controller中动画状态State的名称，动画播放完后，事件结束。
Timeline Action：时间轴事件，指定事件开始的时间节点，和事件执行的时长，需要配合Timeline ActionChain时间轴事件链使用。

除上述事件类型外，可以通过继承AbstractAction抽象事件类，重写OnInvoke和OnReset函数来自定义事件。

Action Chain 事件链

添加事件

IActionChain Append(IAction action)

参数：

action：要添加的事件

返回值：

IActionChain事件链

开启

IActionChain Begin()

终止

void Stop()

暂停

void Pause()

恢复

void Resume()

是否暂停

bool IsPaused { get; }

设置终止条件

IActionChain StopWhen(Func<bool> predicate)

参数：

predicate：终止事件链的条件，该条件成立时事件链会终止。

返回值：

IActionChain事件链

设置回调函数

IActionChain OnStop(UnityAction action)

参数：

action：事件链终止时执行的回调函数

返回值：

IActionChain事件链

设置事件链循环次数

IActionChain SetLoops(int loops)

参数：

loops：事件链循环执行的次数，默认为1，若要一直执行可以将其设为-1，

返回值：

IActionChain事件链

事件链的执行依赖于携程，通过this获取事件链表示以当前的MonoBehaviour开启携程，也可以通过模块管理器开启协程，如下所示：

using UnityEngine;
using SK.Framework;
using SK.Framework.Actions;

public class Example : MonoBehaviour
{
    private void Start()
    {
        //通过当前MonoBehaviour执行事件链
        IActionChain chain1 = Main.Actions.Sequence(this);
        //通过模块管理器执行事件链
        IActionChain chain2 = Main.Actions.Sequence();
    }
}

Sequence 序列事件链

序列事件链中的事件是依次执行的，即只有上一个事件执行结束后，才会开始执行下一个事件。示例如下，事件链中包含三个事件，Event指的是Simple普通事件，该事件链首先打印日志Begin，第一个事件结束，第二个事件开始执行，为延迟事件，在经历3秒的延迟后，第二个事件结束，第三个事件开始执行，打印日志"3f"。

using UnityEngine;
using SK.Framework;
using SK.Framework.Actions;

public class Example : MonoBehaviour
{
    private void Start()
    {
        Main.Actions.Sequence()
            .Event(() => Debug.Log("Begin"))
            .Delay(3f)
            .Event(() => Debug.Log("3f"))
            .Begin();
    }
}

其他一些事件的调用示例如下：

using UnityEngine;
using DG.Tweening;
using SK.Framework;
using SK.Framework.Actions;

public class Example : MonoBehaviour
{
    private void Start()
    {
        Main.Actions.Sequence()
            //普通事件
            .Event(() => Debug.Log("Begin"))
            //延迟2秒
            .Delay(2f)
            //普通事件
            .Event(() => Debug.Log("2f"))
            //直到按下键盘A键
            .Until(() => Input.GetKeyDown(KeyCode.A))
            //普通事件
            .Event(() => Debug.Log("A Pressed."))
            //DoTween动画事件
            .Tween(() => transform.DOMove(new Vector3(0f, 0f, 1f), 2f))
            //定时事件
            .Timer(3f, false, s => Debug.Log(s))
            //开始执行事件链
            .Begin()
            //设置回调函数
            .OnStop(() => Debug.Log("Completed"));
    }
}

Concurrent 并发事件链

并发事件链中的事件是并发执行的，在事件链启动时同时开启执行，在所有的事件都执行完成后，事件链终止。示例如下：

using UnityEngine;
using SK.Framework;
using SK.Framework.Actions;

public class Example : MonoBehaviour
{
    private void Start()
    {
        Main.Actions.Concurrent()
            .Event(() => Debug.Log("Begin"))
            .Delay(1f, () => Debug.Log("1f"))
            .Delay(2f, () => Debug.Log("2f"))
            .Delay(3f, () => Debug.Log("2f"))
            .Until(() => Input.GetKeyDown(KeyCode.A))
            .Begin()
            .OnStop(() => Debug.Log("Completed"));
    }
}

Timeline 时间轴事件链

当前执行的时间节点

float CurrentTime { get; set; }

执行的速度

float Speed { get; set; }

调用示例：

using UnityEngine;
using SK.Framework;
using SK.Framework.Actions;

public class Example : MonoBehaviour
{
    [SerializeField] private GameObject cube;
    [SerializeField] private GameObject sphere;

    private TimelineActionChain timeline;

    private void Start()
    {
        timeline = Main.Actions.Timeline()
            //通过Append添加时间轴事件
            //第一个参数表示该事件开始的时间节点
            //第二个参数表示该事件的时长
            .Append(0f, 5f, s => cube.transform.position = Vector3.Lerp(Vector3.zero, new Vector3(0, 0, 5f), s))
            .Append(2f, 4f, s => sphere.transform.position = Vector3.Lerp(Vector3.zero, Vector3.up * 2f, s))
            .Begin() as TimelineActionChain;

        //2倍速
        timeline.Speed = 2f;
    }

    private void OnGUI()
    {
        GUILayout.BeginHorizontal();
        GUILayout.Label("时间轴");
        //通过Slider调整CurrentTime 实现从指定的时间节点执行
        timeline.CurrentTime = GUILayout.HorizontalSlider(timeline.CurrentTime, 0f, 6f, GUILayout.Width(300f), GUILayout.Height(50f));
        GUILayout.EndHorizontal();
    }
}

事件链嵌套

事件链支持相互嵌套，示例如下：

using UnityEngine;
using SK.Framework;
using SK.Framework.Actions;

public class Example : MonoBehaviour
{
    private void Start()
    {
        Main.Actions.Sequence()
            .Event(() => Debug.Log("Begin"))
            //嵌套一个并发事件链
            .Append(new ConcurrentActionChain()
                .Delay(1f, () => Debug.Log("1f"))
                .Delay(2f, () => Debug.Log("2f"))
                .Delay(3f, () => Debug.Log("3f"))
                as IAction)
            //并发事件链执行完成后 继续执行序列事件链
            .Until(() => Input.GetKeyDown(KeyCode.A))
            .Event(() => Debug.Log("A Pressed."))
            .Timer(3f, false, s => Debug.Log(s))
            .Begin()
            .OnStop(() => Debug.Log("Completed."));
    }
}

FSM 有限状态机

创建状态机

T Create<T>(string stateMachineName) where T : StateMachine, new()

参数：

stateMachineName：状态机命名

返回值：

StateMachine状态机

销毁状态机

bool Destroy(string stateMachineName)

参数：

stateMachineName：要销毁的目标状态机的名称

返回值：

true：成功销毁

false：目标状态机不存在，销毁失败

获取状态机

T GetMachine<T>(string stateMachineName) where T : StateMachine

参数：

stateMachineName：获取的目标状态机的名称

返回值：

StateMachine状态机

State 状态

名称

string Name { get; set; }

是否可切换至自身（默认为false）

bool CanSwitch2Self { get; set; }

所属状态机

StateMachine Machine { get; }

设置切换条件

void SwitchWhen(Func<bool> predicate, string targetStateName)

参数：

predicate：切换条件，条件成立时切换至目标状态

targetStateName：目标状态名称

初始化事件

virtual void OnInitialization()

进入事件

virtual void OnEnter()

停留事件

virtual void OnStay()

退出事件

virtual void OnExit()

终止事件

virtual void OnTermination()

State Machine 状态机

名称

string Name { get; }

当前状态

State CurrentState { get; }

添加状态

int Add(State state)

参数：

state：添加的状态

返回值：

0：添加成功

-1：状态已存在，无需重复添加

-2：存在同名状态，添加失败

移除状态

bool Remove(string stateName)

参数：

stateName：要移除的状态的名称

返回值：

true：移除成功

false：状态不存在，移除失败

切换状态

int Switch(string stateName)

参数：

stateName：要切换的目标状态的名称

返回值：

0：切换成功

-1：状态不存在，切换失败

-2：当前状态已经是目标状态，并且改状态不可切换至自身，切换失败

切换至下一状态

bool Switch2Next()

返回值：

true：切换成功

false：状态机中不存在任何状态，切换失败

切换至上一状态

bool Switch2Last()

返回值：

true：切换成功

false：状态机中不存在任何状态，切换失败

切换至空状态（退出当前状态）

void Switch2Null()

获取状态

T GetState<T>(string stateName) where T : State

参数：

stateName：状态名称

返回值：

State状态

设置状态切换条件

StateMachine SwitchWhen(Func<bool> predicate, string targetStateName)

参数：

predicate：切换条件，当条件成立时从当前状态切换至目标状态

targetStateName：目标状态名称

返回值：

StateMachine状态机

设置状态切换条件

StateMachine SwitchWhen(Func<bool> predicate, string sourceStateName, string targetStateName)

参数：

predicate：切换条件，当条件成立且当前状态是源状态时切换至目标状态

sourceStateName：源状态名称

targetStateName：目标状态名称

返回值：

StateMachine状态机

构建状态

StateBuilder<T> Build<T>(string stateName = null) where T : State, new()

参数：

stateName：状态命名

返回值：

StateBuilder状态构建器

State Builder 状态构建器

设置状态初始化事件

StateBuilder<T> OnInitialization(Action<T> onInitialization)

设置状态进入事件

StateBuilder<T> OnEnter(Action<T> onEnter)

设置状态停留事件

StateBuilder<T> OnStay(Action<T> onStay)

设置状态退出事件

StateBuilder<T> OnExit(Action<T> onExit)

设置状态终止事件

StateBuilder<T> OnTermination(Action<T> onTermination)

设置状态切换条件

StateBuilder<T> SwitchWhen(Func<bool> predicate, string targetStateName)

构建完成

StateMachine Complete()

调用示例一：

using UnityEngine;
using SK.Framework;
using SK.Framework.FSM;

public class Example : MonoBehaviour
{
    public class ExampleState : State
    {
        public override void OnInitialization()
        {
            Debug.Log(string.Format("{0}状态初始化", Name));
        }
        public override void OnEnter()
        {
            Debug.Log(string.Format("{0}状态进入", Name));
        }
        public override void OnStay()
        {
            Debug.Log(string.Format("{0}状态停留", Name));
        }
        public override void OnExit()
        {
            Debug.Log(string.Format("{0}状态退出", Name));
        }
        public override void OnTermination()
        {
            Debug.Log(string.Format("{0}状态终止", Name));
        }
    }

    private void Start()
    {
        var machine = Main.FSM.Create<StateMachine>("示例状态机");
        machine.Add(new ExampleState() { Name = "State1" });
        machine.Add<State>("State2");
        machine.Add<State>("State3");
        machine.Switch("State2");
        machine.Switch2Next();
        machine.Switch2Last();
        machine.Switch2Null();
        machine.SwitchWhen(() => Input.GetKeyDown(KeyCode.Alpha1), "State1");
        machine.SwitchWhen(() => Input.GetKeyDown(KeyCode.Alpha2), "State2");
        machine.SwitchWhen(() => Input.GetKeyDown(KeyCode.Alpha3), "State3");
    }
}

调用示例二：

using UnityEngine;
using SK.Framework;
using SK.Framework.FSM;

public class Example : MonoBehaviour
{
    public class TestState : State
    {
        public string stringValue;
    }

    private void Start()
    {
        //创建状态机
        var machine = Main.FSM.Create<StateMachine>("示例状态机")
            //构建状态一
            .Build<TestState>("状态一")
                //设置状态一初始化事件
                .OnInitialization(state => state.stringValue = "A")
                //设置状态一进入事件
                .OnEnter(state => Debug.Log("进入状态一"))
                //设置状态一停留事件
                .OnStay(state => Debug.Log("状态一"))
                //设置状态一推出事件
                .OnExit(state => Debug.Log("退出状态一"))
                //设置状态一销毁事件
                .OnTermination(state => state.stringValue = null)
            //状态一构建完成
            .Complete()
            //构建状态二
            .Build<State>("状态二")
                //设置状态二进入事件
                .OnEnter(state => Debug.Log("进入状态二"))
                //设置状态二停留事件
                .OnStay(state => Debug.Log("状态二"))
                //设置状态二退出事件
                .OnExit((state => Debug.Log("退出状态二")))
            //状态二构建完成
            .Complete()
            //构建状态三
            .Build<State>("状态三")
                //设置状态三进入事件
                .OnEnter(state => Debug.Log("进入状态三"))
                //设置状态三停留事件
                .OnStay(state => Debug.Log("状态三"))
                //设置状态三退出事件
                .OnExit((state => Debug.Log("退出状态三")))
            //状态三构建完成
            .Complete()
            //添加状态切换条件 当按下快捷键1时 切换至状态一
            .SwitchWhen(() => Input.GetKeyDown(KeyCode.Alpha1), "状态一")
            //添加状态切换条件 当按下快捷键2时 切换至状态二
            .SwitchWhen(() => Input.GetKeyDown(KeyCode.Alpha2), "状态二")
            //添加状态切换条件 当按下快捷键3时 切换至状态三
            .SwitchWhen(() => Input.GetKeyDown(KeyCode.Alpha3), "状态三")
            //为状态一至状态二添加切换条件：若当前状态为状态一时 按下快捷键4 切换至状态二
            .SwitchWhen(() => Input.GetKeyDown(KeyCode.Alpha4), "状态一", "状态二");

        //切换到指定状态
        machine.Switch("状态一");
        //切换到下一状态
        machine.Switch2Next();
        //切换到上一状态
        machine.Switch2Last();
    }
}

ObjectPool 对象池

当前缓存的数量

int CurrentCacheCount { get; }

最大可缓存的数量

int MaxCacheCount { get; set; }

分配对象

T Allocate()

回收对象

bool Recycle(T t)

释放对象池

void Release()

设置创建方法（Mono类型对象池）

void CreateBy(Func<T> createMethod)

IPoolable 接口

为需要实现对象池管理的对象类继承IPoolable接口

是否已经回收

bool IsRecycled { get; set; }

回收事件

void OnRecycled()

调用示例一：

using UnityEngine;
using SK.Framework;
using SK.Framework.ObjectPool;

public class Example : MonoBehaviour
{
    public class Person : IPoolable
    {
        public string Name { get; set; }
        public int Age { get; set; }
        public float Weight { get; set; }

        public bool IsRecycled { get; set; }
        public void OnRecycled()
        {
            Name = null;
            Age = 0;
            Weight = 0f;
        }
    }

    private void Start()
    {
        //分配对象
        Person person = Main.ObjectPool.Allocate<Person>();
        person.Name = "CoderZ";
        person.Age = 30;
        person.Weight = 66f;
        //设置对象池的最大缓存数量
        Main.ObjectPool.SetMaxCacheCount<Person>(100);
        //对象池中当前缓存的数量
        int count = Main.ObjectPool.GetCurrentCacheCount<Person>();
        //回收对象
        Main.ObjectPool.Recycle(person);
        //释放对象池
        Main.ObjectPool.Release<Person>();
    }
}

调用示例二：

using UnityEngine;
using SK.Framework;
using SK.Framework.ObjectPool;

public class Bullet : MonoBehaviour, IPoolable
{
    public bool IsRecycled { get; set; }

    public void OnRecycled()
    {
        gameObject.SetActive(false);
        transform.localPosition = Vector3.zero;
        transform.localRotation = Quaternion.identity;
    }
}

public class Example : MonoBehaviour
{
    //子弹预制体
    [SerializeField] private GameObject bulletPrefab;

    private void Start()
    {
        //设置创建方法
        Main.ObjectPool.CreateBy(() =>
        {
            var instance = Instantiate(bulletPrefab);
            instance.transform.SetParent(transform);
            instance.transform.localPosition = Vector3.zero;
            instance.transform.localRotation = Quaternion.identity;
            instance.SetActive(true);
            Bullet bullet = instance.GetComponent<Bullet>();
            return bullet;
        });
        //分配对象
        Bullet bullet = Main.ObjectPool.Allocate<Bullet>();
        //设置对象池的最大缓存数量
        Main.ObjectPool.SetMaxCacheCount<Bullet>(100);
        //对象池中当前缓存的数量
        int count = Main.ObjectPool.GetCurrentCacheCount<Bullet>();
        //回收对象
        Main.ObjectPool.Recycle(bullet);
        //释放对象池
        Main.ObjectPool.Release<Bullet>();
    }
}

Event 事件

发布

void Publish(int eventId)
void Publish<T>(int eventId, T arg)
void Publish<T1, T2>(int eventId, T1 arg1, T2 arg2)
void Publish<T1, T2, T3>(int eventId, T1 arg1, T2 arg2, T3 arg3)
void Publish<T1, T2, T3, T4>(int eventId, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
void Publish<T1, T2, T3, T4, T5>(int eventId, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5)
void Publish<T1, T2, T3, T4, T5, T6>(int eventId, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6)
void Publish<T1, T2, T3, T4, T5, T6, T7>(int eventId, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7)
void Publish<T1, T2, T3, T4, T5, T6, T7, T8>(int eventId, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8)
void Publish<T1, T2, T3, T4, T5, T6, T7, T8, T9>(int eventId, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9)
void Publish<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(int eventId, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10)

参数：

eventId：事件ID

arg1 … arg10：事件参数

void Subscribe(int eventId, Action callback)
void Subscribe<T>(int eventId, Action<T> callback)
void Subscribe<T1, T2>(int eventId, Action<T1, T2> callback)
void Subscribe<T1, T2, T3>(int eventId, Action<T1, T2, T3> callback)
void Subscribe<T1, T2, T3, T4>(int eventId, Action<T1, T2, T3, T4> callback)
void Subscribe<T1, T2, T3, T4, T5>(int eventId, Action<T1, T2, T3, T4, T5> callback)
void Subscribe<T1, T2, T3, T4, T5, T6>(int eventId, Action<T1, T2, T3, T4, T5, T6> callback)
void Subscribe<T1, T2, T3, T4, T5, T6, T7>(int eventId, Action<T1, T2, T3, T4, T5, T6, T7> callback)
void Subscribe<T1, T2, T3, T4, T5, T6, T7, T8>(int eventId, Action<T1, T2, T3, T4, T5, T6, T7, T8> callback)
void Subscribe<T1, T2, T3, T4, T5, T6, T7, T8, T9>(int eventId, Action<T1, T2, T3, T4, T5, T6, T7, T8, T9> callback)
void Subscribe<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(int eventId, Action<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback)

参数：

eventId：事件ID

callback：回调函数

取消订阅

bool Unsubscribe(int eventId, Action callback)
bool Unsubscribe<T>(int eventId, Action<T> callback)
bool Unsubscribe<T1, T2>(int eventId, Action<T1, T2> callback)
bool Unsubscribe<T1, T2, T3>(int eventId, Action<T1, T2, T3> callback)
bool Unsubscribe<T1, T2, T3, T4>(int eventId, Action<T1, T2, T3, T4> callback)
bool Unsubscribe<T1, T2, T3, T4, T5>(int eventId, Action<T1, T2, T3, T4, T5> callback)
bool Unsubscribe<T1, T2, T3, T4, T5, T6>(int eventId, Action<T1, T2, T3, T4, T5, T6> callback)
bool Unsubscribe<T1, T2, T3, T4, T5, T6, T7>(int eventId, Action<T1, T2, T3, T4, T5, T6, T7> callback)
bool Unsubscribe<T1, T2, T3, T4, T5, T6, T7, T8>(int eventId, Action<T1, T2, T3, T4, T5, T6, T7, T8> callback)
bool Unsubscribe<T1, T2, T3, T4, T5, T6, T7, T8, T9>(int eventId, Action<T1, T2, T3, T4, T5, T6, T7, T8, T9> callback)
bool Unsubscribe<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(int eventId, Action<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> callback)

参数：

eventId：事件ID

callback：回调函数

调用示例：

using UnityEngine;
using SK.Framework;

public class Example : MonoBehaviour
{
    public class AttackEvent
    {
        public static readonly int EventID = typeof(AttackEvent).GetHashCode();

        public int power;

        public AttackEvent(int power)
        {
            this.power = power;
        }
    }

    private void Start()
    {
        //订阅
        Main.Events.Subscribe<GameObject, AttackEvent>(AttackEvent.EventID, OnAttackEvent);
        //发布
        Main.Events.Publish(AttackEvent.EventID, gameObject, new AttackEvent(50));
        //取消订阅
        Main.Events.Unsubscribe<GameObject, AttackEvent>(AttackEvent.EventID, OnAttackEvent);
    }

    private void OnAttackEvent(GameObject attacker, AttackEvent ae)
    {
        Debug.Log(string.Format("Attacker:{0}, Attack Power:{1}", attacker.name, ae.power));
    }
}

Resource 资源

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-aOJZ6iHT-1689305523652)(C:\Users\admin\AppData\Roaming\Typora\typora-user-images\image-20230202131130583.png)]

Mode：资源加载模式

Editor：编辑器模式
SIMULATIVE：模拟模式（StreamingAssets）
REALITY：真实环境

AssetBundleUrl；AssetBundle资源包所在路径

AssetBundleManifestName：manifest文件名称

加载资产

void LoadAssetAsync<T>(string assetPath, Action<float> onLoading, Action<bool, T> onCompleted)
void LoadAssetAsync<T>(MonoBehaviour executer, string assetPath, Action<float> onLoading, Action<bool, T> onCompleted)

参数：

executer：开启加载协程的Monobehaviour

assetPath：资产路径

onLoading：加载中回调

onCompleted：加载完成回调

返回值：

Coroutine加载协程

卸载资产

void UnloadAsset(AssetInfo assetInfo, bool unloadAllLoadedObjects)

参数：

assetInfo：资产信息

unloadAllLoadedObjects：是否卸载其所有实例，默认为false

卸载所有资产

UnloadAllAsset(bool unloadAllLoadedObjects)

加载场景

void LoadSceneAsync(string sceneAssetPath, Action<float> onLoading, Action onCompleted)
void LoadSceneAsync(MonoBehaviour executer, string sceneAssetPath, Action<float> onLoading, Action onCompleted)

参数：

executer：开启加载协程的Monobehaviour

sceneAssetPath：场景资源路径

onLoading：加载中回调

onCompleted：加载完成回调

返回值：

Coroutine加载协程

卸载场景

bool UnloadScene(SceneInfo sceneInfo)

参数：

sceneInfo：场景信息

返回值：

true：卸载成功

false：未加载该场景，卸载失败

调用示例：

using UnityEngine;
using SK.Framework;
using SK.Framework.Resource;

public class Example : MonoBehaviour
{
    private void Start()
    {
        //异步加载资产
        Main.Resource.LoadAssetAsync<AudioClip>("Assets/click01.mp3", onCompleted: (success, clip) =>
        {
            if (success)
            {
                AudioSource source = gameObject.AddComponent<AudioSource>();
                source.clip = clip;
                source.Play();
            }
        });
        //异步加载场景
        Main.Resource.LoadSceneAsync("Assets/Scenes/Example.unity");
    }
}

UI 模块

加载视图

T LoadView<T>(string viewName, string resourcesPath, ViewLevel viewLevel = ViewLevel.COMMON, object data = null) where T : MonoBehaviour, IUIView;

参数：

viewName：视图命名

resourcePath：视图Prefab在Resources文件夹中的路径

viewLevel：视图层级

data：视图数据

返回值：

UIView视图

注：该接口通过Resources.Load方式加载视图资源

异步加载视图：

void LoadViewAsync<T>(string viewName, string assetPath, ViewLevel viewLevel = ViewLevel.COMMON, object data = null, Action<bool, T> onCompleted = null) where T : MonoBehaviour, IUIView;

参数：

viewName：视图命名

assetPath：视图资产路径

viewLevel：视图层级

data：视图数据

onCompleted：加载完成回调

注：该接口通过AssetsBundle方式加载视图资源

打开视图

T OpenView<T>(string viewName, string resourcesPath, ViewLevel viewLevel = ViewLevel.COMMON, bool instant = false, object data = null) where T : MonoBehaviour, IUIView;

参数：

viewName：视图名称

resourcePath：视图Prefab在Resources文件夹中的路径

viewLevel：视图层级

instant：是否立刻显示（不播放视图动画过程），默认为false

data：视图数据

返回值：

UIView视图

注：该接口通过Resources.Load方式加载视图资源，如果视图已经加载，直接打开。

异步打开视图：

void OpenViewAsync<T>(string viewName, string assetPath, ViewLevel viewLevel = ViewLevel.COMMON, bool instant = false, object data = null, Action<bool, T> onCompleted = null) where T : MonoBehaviour, IUIView;

参数：

viewName：视图名称

assetPath：视图资产路径

viewLevel：视图层级

instant：是否立刻显示（不播放视图动画过程），默认为false

data：视图数据

onCompleted：加载完成回调

注：该接口通过AssetsBundle方式加载视图资源，如果视图已经加载，直接打开。

关闭视图

bool CloseView(string viewName, bool instant = false);IUIView HideView(string viewName, bool instant)

参数：

viewName：视图名称

instant：是否立刻关闭（不播放视图动画过程），默认为false

返回值：

true：关闭成功

false：不存在该视图，操作失败

卸载视图

bool UnloadView(string viewName);

参数：

viewName：视图名称

返回值：

true：卸载成功

false：不存在该视图，卸载失败

获取视图

T GetView<T>(string viewName) where T : IUIView;

参数：

viewName：视图名称

返回值：

UIView视图

调用示例：

using UnityEngine;
using SK.Framework;
using SK.Framework.UI;

public class Example : MonoBehaviour
{
    private void Start()
    {
        Main.UI.LoadView<ExampleView>();

        Main.UI.OpenView<ExampleView>();

        Main.UI.Close<ExampleView>();

        Main.UI.UnloadView<ExampleView>();
    }
}

WebRequest 网络请求

发起网络请求

void Send(string url, WebRequestData data, Action<DownloadHandler> onSuccess, Action<string> onFailure = null, MonoBehaviour sender = null)

参数：

url：网络请求地址

data：网络请求数据

onSuccess：请求成功回调函数

onFailure：请求失败回调函数

sender：网络请求的发起依赖于协程，sender表示开启协程的Monobehaviour，传null表示通过模块管理器开启协程

WebRequest Data

请求方式（GET/POST）

WebRequestType RequestType { get; }

表单

WWWForm WWWForm { get; }

请求头

Dictionary<string, string> Headers { get; }

请求数据

byte[] PostData { get; }

调用示例：

using UnityEngine;
using SK.Framework;
using SK.Framework.Networking;

public class Example : MonoBehaviour
{
    public class WebInterface
    {
        public static string BaiDu
        {
            get
            {
                return "https://www.baidu.com/";
            }
        }
    }
    private void Start()
    {
        Main.WebRequest.Send(WebInterface.BaiDu, WebRequestData.Allocate(WebRequestType.GET),
            onSuccess: handler => Debug.Log(handler.text),
            onFailure: error => Debug.Log(string.Format("发起网络请求失败：{0}", error)));
    }
}