FusionFrameworks

Sprite sprite = AssetsManager.Instance.Load<Sprite>("Sprites/hearts");

AssetsManager.Instance.LoadAsync("Sprites/hearts", delegate (Sprite sprite)
{
    //在回调中对加载的资源进行处理
});

AssetsUtility.Release("Sprites/hearts");

AssetsUtility.ReleaseImmediate("Sprites/hearts");

GameObject go = AssetsUtility.CreateGameObject("Prefabs/Cube");

AssetsUtility.CreateGameObjectAsync("Prefabs/Cube", finishCallback: delegate (GameObject go)
{
    //在回调中可以处理加载的对象
});

AssetsUtility.Release(go);

AssetsUtility.ReleaseImmediate(go);

AssetsUtility.SetSpriteOfImage(gameObject, "Sprites/hearts");

AssetsUtility.SetAudioSourceClip(audioSource, "Audios/1");

AudioPlayer audioPlayer = new AudioPlayer();

audioPlayer.FadeInSetter(1.0f);
audioPlayer.FadeOutSetter(1.0f);

audioPlayer.LoopSetter(true);

audioPlayer.VolumeSetter(0.5f);

audioPlayer.Play("Audios/1");

audioPlayer.Stop();

audioPlayer.Pause();

audioPlayer.Release();

audioPlayer.TagSetter("BGM");

AudioManager.Instance.SetTagVolume("BGM", 0.5f);

ScenesManager.Instance.Load("Scenes/First");

ScenesManager.Instance.LoadAsync("Scenes/First");

ScenesManager.LoadAsyncTask loadAsyncTask = new ScenesManager.LoadAsyncTask("Scenes/First");

loadAsyncTask.AddAdditive("Scenes/Second");

loadAsyncTask.updateCallback = delegate (float progress)
{
    //在此处理进度变更逻辑
};

loadAsyncTask.finishCallback = delegate ()
{
    //在此处理加载完成逻辑
};

loadAsyncTask.AddAdditive("Scenes/Second");

loadAsyncTask.AddSceneDataHandler(new SceneUIHandler());

ScenesManager.LoadAsyncOperation loadAsyncOperation = loadAsyncTask.Schedule();

using Fusion.Frameworks.UI;

namespace Prefabs.UI
{
    public class Page1 : UIObject
    {
        public Page1()
        {
        }

        public Page1(UIData data) : base(data)
        {
        }

        public override void Init()
        {
            base.Init();
        }

        public override void Update()
        {
            base.Update();
        }

        public override void OnFinished()
        {
            base.OnFinished();
        }

        public override void OnDestroy()
        {
            base.OnDestroy();
        }
    }
}

UIManager.Instance.Launch("Prefabs/UI/Page1");

UIManager.Instance.LaunchAsync("Prefabs/UI/Page1");

public class PageData : UIData
{
    // 可以添加自定义的变量，例如下面的text变量。
    public string text;
}

PageData pageData = new PageData();
pageData.text = "Passed Value";
UIManager.Instance.LaunchAsync("Prefabs/UI/Page1", pageData);

PageData pageData;
public Page1(UIData data) : base(data)
{
    pageData = (PageData)data;
}

TextMeshProUGUI text;
Image image;
Button jumpToBtn;
Button closeBtn;
public override void Init()
{
    base.Init();
    text = Utility.Find<TextMeshProUGUI>(gameObject, "Text");
    image = Utility.Find<Image>(gameObject, "Image");
    jumpToBtn = Utility.Find<Button>(gameObject, "Jump");
    closeBtn = Utility.Find<Button>(gameObject, "Close");
    UIUtility.RegisterButtonAction(closeBtn, Finish);
    UIUtility.RegisterButtonAction(jumpToBtn, JumpTo);
}

public override void Update()
{
    base.Update();
    UIUtility.SetText(text, pageData.text);
    UIUtility.SetImage(image, "Sprites/hearts");
}

public Page2(UIData data) : base(data)
{
    type = UIType.Pop;
}

UIData data = new UIData();
data.LaunchMode = UILaunchMode.SingleTop;

Example example = ExampleStorage.Get(1);

int intValue = example.intValue;
string stringValue = example.stringValue;
double doubleValue = example.doubleValue;
List<int> list = example.array;
(int id, string name) classValue = example.classValue;

ExampleStorage.Clear();

using UnityEngine;
using Fusion.Hotfix.Mono;

namespace Hotfix.Mono
{
    public class HotfixMono : DLLMonoBase
    {
        public HotfixMono(DLLMonoBehaviour mono, string monoData) : base(mono, monoData)
        {
        }

        public override void Awake()
        {
            base.Awake();
            Debug.Log("Awake");
        }

        public override void Start()
        {
            base.Start();
            Debug.Log("Start");
        }

        public void Update()
        {
            Debug.Log("Update");
        }
    }
}

using Fusion.Hotfix.Mono.Editor;
using UnityEngine;

[CreateAssetMenu(menuName = "DLLMonoData/HotfixMonoData", fileName = "HotfixMonoData")]
public class HotfixMonoData_MonoDataEditor : ScriptableMonoData
{
    public string test = "HotfixMonoData_String";
}

using UnityEngine;
using Fusion.Hotfix.Mono;
using LitJson.DynamicDLL;

namespace Hotfix.Mono
{
    public class HotfixMono : DLLMonoBase
    {
        HotfixMonoData hotfixMonoData;
        public HotfixMono(DLLMonoBehaviour mono, string monoData) : base(mono, monoData)
        {
            hotfixMonoData = JsonMapper.ToObject<HotfixMonoData>(monoData);
        }

        public override void Awake()
        {
            base.Awake();
            Debug.Log(hotfixMonoData.test);
            Debug.Log("Awake");
        }

        public override void Start()
        {
            base.Start();
            Debug.Log("Start");
        }

        public void Update()
        {
            Debug.Log("Update");
        }
    }
}

using UnityEngine;
using Fusion.Hotfix.Mono;

namespace Hotfix.Mono
{
    public class HotfixMono2 : DLLMonoBase
    {
        public HotfixMono2(DLLMonoBehaviour mono, string monoData) : base(mono, monoData)
        {
        }

        public override void OnDisable()
        {
            base.OnDisable();
            Debug.Log("OnDisable2");
        }

        public override void OnEnable()
        {
            base.OnEnable();
            Debug.Log("OnEnable2");
        }

        public override void Awake()
        {
            base.Awake();
            Debug.Log("Awake2");
        }

        public override void Start()
        {
            base.Start();
            Debug.Log("Start2");
        }

        public void Update()
        {
            Debug.Log("Update2");
        }
    }
}

using UnityEngine;
using Fusion.Hotfix.Mono;
using LitJson.DynamicDLL;
using Fusion.Hotfix;

namespace Hotfix.Mono
{
    public class HotfixMono : DLLMonoBase
    {
        HotfixMonoData hotfixMonoData;
        public HotfixMono(DLLMonoBehaviour mono, string monoData) : base(mono, monoData)
        {
            hotfixMonoData = JsonMapper.ToObject<HotfixMonoData>(monoData);
        }

        HotfixMono2 hotfixMono2;
        public override void Awake()
        {
            base.Awake();
            Debug.Log(hotfixMonoData.test);
            Debug.Log("Awake");
        }

        public override void Start()
        {
            base.Start();
            Debug.Log("Start");
            hotfixMono2 = (HotfixMono2)gameObject.GetMono("Hotfix.Mono.HotfixMono2");
            hotfixMono2.enabled = false;
        }

        public void Update()
        {
            Debug.Log("Update");
        }
    }
}

using UnityEngine;
using Fusion.Net.TCP;
using Fusion.Net;
using System.Text;
public class TCPServerTest : MonoBehaviour
{
    TCPServer server;

    // Start is called before the first frame update
    void Start()
    {
        server = new TCPServer(20000);
        server.OnOpen += OnOpen;
        server.OnClosed += OnClose;
        server.OnConnected += OnConnect;
        server.OnError += OnError;
        server.OnMessage += OnMessage;
    }

    //回调
    public void OnOpen(SocketBase server)
    {
        Debug.Log($"服务器{server.IP}已启动");
    }

    public void OnClose(SocketBase server, int code)
    {
        Debug.Log($"套接字{server.IP}已关闭，Cose:{code}");
    }

    public void OnConnect(SocketBase client)
    {
        Debug.Log($"客户端{client.IP}已连接");
    }

    public void OnError(SocketBase server, ExceptionData e)
    {
        Debug.LogError($"Error: {e.ErrorCode}");
    }

    public void OnMessage(SocketBase client, byte[] data)
    {
        Debug.Log($"消息[IP:{client.IP}]: {Encoding.UTF8.GetString(data)}");
    }

    // 测试方法
    public void Open()
    {
        server.Open();
    }

    public void Send()
    {
        server.SendBroadcast(Encoding.UTF8.GetBytes($"我是服务器：{NetUtility.GetIP()}"));
    }

    public void Close()
    {
        server.Close();
    }
}

using UnityEngine;
using Fusion.Net.TCP;
using Fusion.Net;
using System.Text;
public class TCPClientTest : MonoBehaviour
{
    TCPClient client;

    // Start is called before the first frame update
    void Start()
    {
        client = new TCPClient("127.0.0.1", 20000);
        client.OnOpen += OnOpen;
        client.OnClosed += OnClose;
        client.OnError += OnError;
        client.OnMessage += OnMessage;
    }

    //回调
    public void OnOpen(SocketBase client)
    {
    }

    public void OnClose(SocketBase client, int code)
    {
        Debug.Log($"套接字{client.IP}已关闭，Cose:{code}");
    }

    public void OnError(SocketBase client, ExceptionData e)
    {
        Debug.LogError($"Error: {e.ErrorCode}");
    }

    public void OnMessage(SocketBase server, byte[] data)
    {
        Debug.Log($"消息[IP:{server.IP}]: {Encoding.UTF8.GetString(data)}");
    }

    // 测试方法
    public void Open()
    {
        client.Open();
    }

    public void Send()
    {
        client.Send(Encoding.UTF8.GetBytes($"我是客户端：{NetUtility.GetIP()}"));
    }

    public void Close()
    {
        client.Close();
    }
}

using UnityEngine;
using Fusion.Net.UDP;
using Fusion.Net;
using System.Text;
public class UDPClientTest : MonoBehaviour
{
    public int port;
    public int targetPort;
    UDPClient client;

    // Start is called before the first frame update
    void Start()
    {
        client = new UDPClient(port);
        client.OnOpen += OnOpen;
        client.OnClosed += OnClose;
        client.OnError += OnError;
        client.OnMessage += OnMessage;
    }

    //回调
    public void OnOpen(SocketBase client)
    {
    }

    public void OnClose(SocketBase client, int code)
    {
        Debug.Log($"套接字{client.IP}已关闭，Cose:{code}");
    }

    public void OnError(SocketBase client, ExceptionData e)
    {
        Debug.LogError($"Error: {e.ErrorCode}");
    }

    public void OnMessage(SocketBase target, byte[] data)
    {
        Debug.Log($"消息[IP:{target.IP}]: {Encoding.UTF8.GetString(data)}");
    }

    // 测试方法
    public void Open()
    {
        client.Open();
    }

    public void Send()
    {
        client.Send("127.0.0.1", targetPort, Encoding.UTF8.GetBytes($"我是User：{NetUtility.GetIP()}:{port}"));
    }

    public void Close()
    {
        client.Close();
    }
}

client = new UDPClient(port, UDPType.ReliableOrder);

syntax = "proto3";
package Protos.Lobby;
message RoomProfileMessage {
    string name = 1;
    int32 currentNum = 2;
    int32 maxNum = 3;
    string ownerName = 4;
    string ownerAddress = 5;
}

RoomProfileMessage roomProfileMessage = RoomProfileMessage.Pool.Get();

<?xml version="1.0" encoding="UTF-8" ?>

<package>
    <class name = "TestClass1" tag = "root">
        <field name = "typeBool" type = "bool"/>
        <field name = "typeInt" type = "int"/>
        <field name = "typeLong" type = "long"/>
        <field name = "typeFloat" type = "float"/>
        <field name = "typeDouble" type = "double"/>
        <field name = "typeString" type = "string"/>
        <field name = "typeList" type = "List[int]"/>
        <!-- Map的key只能是基本类型 -->
        <field name = "typeMap" type = "Map[int,string]"/>  
        <field name = "typeObject" type = "SimpleVector3"/>
        <field name = "typeListObject" type = "List[SimpleVector3]"/>
        <field name = "typeMapObject" type = "Map[int,SimpleVector3]"/>
    </class>

    <class name = "SimpleVector3">
        <field name = "x" type = "float"/>
        <field name = "y" type = "float"/>
        <field name = "z" type = "float"/>
    </class>

    <class name = "TestClass2" tag = "root">
        <field name = "typeInt" type = "int"/>
    </class>
</package>

TestClass1 originData = new TestClass1();

// 从对象池中获取ProxyMessage
ProxyMessage proxyMessage = ProxyMessage.Pool.Get();

// 第一次需要先初始化数据
ProxyManager.FillObject(ref proxyMessage, ProxyIndex.TestClass1, originData);

// 设置基本类型
ProxyManager.FillFieldBool(ref proxyMessage, ProxyIndex.TestClass1_TypeBool, true);
ProxyManager.FillFieldDouble(ref proxyMessage, ProxyIndex.TestClass1_TypeDouble, 5.0);
ProxyManager.FillFieldFloat(ref proxyMessage, ProxyIndex.TestClass1_TypeFloat, 4.0f);
ProxyManager.FillFieldInt(ref proxyMessage, ProxyIndex.TestClass1_TypeInt, 3);
ProxyManager.FillFieldLong(ref proxyMessage, ProxyIndex.TestClass1_TypeLong, 6);
ProxyManager.FillFieldString(ref proxyMessage, ProxyIndex.TestClass1_TypeString, "ProxyString");

// 设置对象
SimpleVector3 simpleVector3 = SimpleVector3.Pool.Get();
simpleVector3.X = 1; simpleVector3.Y = 2; simpleVector3.Z = 3;
ProxyManager.FillFieldObject(ref proxyMessage, ProxyIndex.TestClass1_TypeObject, simpleVector3);

// 向list中添加数据
ProxyManager.FillGeneric(ref proxyMessage, ProxyIndex.TestClass1_TypeList, GenericAction.Add, null, ProxyManager.GetIntValue(10));
ProxyManager.FillGeneric(ref proxyMessage, ProxyIndex.TestClass1_TypeList, GenericAction.Add, null, ProxyManager.GetIntValue(7));

ValueMessage[] keys = new ValueMessage[]
{
    ProxyManager.GetIntValue(5)
};
ValueMessage[] keys2 = new ValueMessage[]
{
    ProxyManager.GetIntValue(7)
};
// 向Map中添加数据
ProxyManager.FillGeneric(ref proxyMessage, ProxyIndex.TestClass1_TypeMap, GenericAction.Add, keys, ProxyManager.GetStringValue("TestMap1"));
ProxyManager.FillGeneric(ref proxyMessage, ProxyIndex.TestClass1_TypeMap, GenericAction.Add, keys2, ProxyManager.GetStringValue("TestMap2"));

// 转换成byte数组 可以进行网络传输
byte[] data = proxyMessage.ToByteArray();

// 假设从网络中拿到数据 data
ProxyMessage recvedMessage = ProxyMessage.Parser.ParseFrom(data);
//注册数据修改回调
ProxyManager.Instance.RegisterCallback(ProxyIndex.TestClass1_TypeList, this, delegate (ProxyCallbackData proxyCallbackData)
{
    Debug.LogWarning($"TypeList被修改: Value: {proxyCallbackData.Data.IntValue}");
});
// 将Message传入ProxyManager，自动设置接收到的数据
ProxyManager.Instance.Update(proxyMessage);

//打印数据
TestClass1 testClass1 = ProxyManager.Instance.Get<TestClass1>(ProxyIndex.TestClass1);
Debug.LogError("Base");
Debug.Log(testClass1.TypeBool);
Debug.Log(testClass1.TypeDouble);
Debug.Log(testClass1.TypeFloat);
Debug.Log(testClass1.TypeInt);
Debug.Log(testClass1.TypeLong);
Debug.Log(testClass1.TypeString);

Debug.LogError("SimpleVector");
Debug.Log(testClass1.TypeObject.X);
Debug.Log(testClass1.TypeObject.Y);
Debug.Log(testClass1.TypeObject.Z);

Debug.LogError("List");
for (int i = 0; i < testClass1.TypeList.Count; i++)
{
    Debug.Log(testClass1.TypeList[i]);
}

Debug.LogError("Map");
for (int i = 0; i < testClass1.TypeMap.Count; i++)
{
    Debug.Log($"Key: {testClass1.TypeMap.GetKey(i)} Value: {testClass1.TypeMap.Get(i)}");
}

//注册数据修改回调
ProxyManager.Instance.RegisterCallback(ProxyIndex.TestClass1_TypeList, this, delegate (ProxyCallbackData proxyCallbackData)
{
    //处理数据
});

//删除数据修改回调
ProxyManager.Instance.RemoveCallback(ProxyIndex.TestClass1_TypeList, this);

using Fusion.Async.Timers;

Timer timer = new Timer();

timer.TypeSetter(Timer.InvokeType.Time);

timer.FrequencySetter(1.0f);

timer.CountSetter(1);

timer.FirstImmediatelySetter(false);

timer.RoundSetter(2);

timer.PersistentSetter(false);

timer.Invoke(delegate ()
{
    // 自定义方法
});

timer.Pause();

timer.Stop();

using Fusion.Frameworks.Notification;

public static class NotificationKey
{
    public readonly static int Test_1 = 1;
}

public struct NotificationTestData : INotificationData
{
    public int value;
}

NotificationManager.Register(this, NotificationKey.Test_1, Func);

void Func(INotificationData notificationData)
{
    NotificationTestData notificationTestData = (NotificationTestData)notificationData;
    Debug.Log($"Notification: {notificationTestData.value}");
}

NotificationTestData notificationTestData = new NotificationTestData { value = 4 };
NotificationManager.Send(NotificationKey.Test_1, notificationTestData);

NotificationManager.Remove(this);

NotificationManager.Remove(this, NotificationKey.Test_1);

GameObject box = Utility.Find(gameObject, "Cube");
BoxCollider boxCollider = Utility.Find<BoxCollider>(gameObject, "Cube");