【Unity基础】Unity的事件系统 ------ Player的等级变化引起一系列的变化

最新推荐文章于 2022-11-15 23:56:24 发布
最新推荐文章于 2022-11-15 23:56:24 发布
阅读量285 收藏
点赞数
文章标签： unity
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42404497/article/details/117231763
版权

工具类：能避免重复挂载事件 用来代替默认的事件

using System;

namespace Utils
{
    /// <summary>
    /// 能避免重复挂事件的默认委托
    /// </summary>
    public struct SafeAction
    {
        Action act;

        public static implicit operator Action(SafeAction a)
        {
            return a.act;
        }

        public static implicit operator SafeAction(Action a)
        {
            SafeAction res = new SafeAction();
            res.act = a;
            return res;
        }
        public static SafeAction operator +(SafeAction a, Action b)
        {
            a.act -= b;
            SafeAction res = new SafeAction();
            res.act = a.act + b;

            return res;
        }

        public static SafeAction operator -(SafeAction a, Action b)
        {
            SafeAction res = new SafeAction();
            res.act = a.act - b;
            return res;
        }

        public void SafeInvoke()
        {
            act.SafeInvoke();
        }

        public bool IsNull
        {
            get
            {
                return act == null;
            }
        }

        public void Dispose()
        {
            act = null;
        }
    }

    /// <summary>
    /// 能避免重复挂事件的默认委托
    /// </summary>
    public struct SafeAction<T>
    {
        Action<T> act;

        public static implicit operator Action<T>(SafeAction<T> a)
        {
            return a.act;
        }

        public static implicit operator SafeAction<T>(Action<T> a)
        {
            SafeAction<T> res = new SafeAction<T>();
            res.act = a;
            return res;
        }
        public static SafeAction<T> operator +(SafeAction<T> a, Action<T> b)
        {
            a.act -= b;
            SafeAction<T> res = new SafeAction<T>();
            res.act = a.act + b;

            return res;
        }

        public static SafeAction<T> operator -(SafeAction<T> a, Action<T> b)
        {
            SafeAction<T> res = new SafeAction<T>();
            res.act = a.act - b;
            return res;
        }

        public void SafeInvoke(T param)
        {
            act.SafeInvoke(param);
        }

        public bool IsNull
        {
            get
            {
                return act == null;
            }
        }

        public void Dispose()
        {
            act = null;
        }
    }

    /// <summary>
    /// 能避免重复挂事件的默认委托
    /// </summary>
    public struct SafeAction<T, T2>
    {
        Action<T, T2> act;

        public static implicit operator Action<T, T2>(SafeAction<T, T2> a)
        {
            return a.act;
        }

        public static implicit operator SafeAction<T, T2>(Action<T, T2> a)
        {
            SafeAction<T, T2> res = new SafeAction<T, T2>();
            res.act = a;
            return res;
        }

        public static SafeAction<T, T2> operator +(SafeAction<T, T2> a, Action<T, T2> b)
        {
            a.act -= b;
            SafeAction<T, T2> res = new SafeAction<T, T2>();
            res.act = a.act + b;

            return res;
        }

        public static SafeAction<T, T2> operator -(SafeAction<T, T2> a, Action<T, T2> b)
        {
            SafeAction<T, T2> res = new SafeAction<T, T2>();
            res.act = a.act - b;
            return res;
        }

        public void SafeInvoke(T param, T2 param2)
        {
            act.SafeInvoke(param, param2);
        }

        public bool IsNull
        {
            get
            {
                return act == null;
            }
        }

        public void Dispose()
        {
            act = null;
        }
    }

    /// <summary>
    /// 能避免重复挂事件的默认委托
    /// </summary>
    public struct SafeAction<T, T2, T3>
    {
        Action<T, T2, T3> act;

        public static implicit operator Action<T, T2, T3>(SafeAction<T, T2, T3> a)
        {
            return a.act;
        }

        public static implicit operator SafeAction<T, T2, T3>(Action<T, T2, T3> a)
        {
            SafeAction<T, T2, T3> res = new SafeAction<T, T2, T3>();
            res.act = a;
            return res;
        }
        public static SafeAction<T, T2, T3> operator +(SafeAction<T, T2, T3> a, Action<T, T2, T3> b)
        {
            a.act -= b;
            SafeAction<T, T2, T3> res = new SafeAction<T, T2, T3>();
            res.act = a.act + b;

            return res;
        }

        public static SafeAction<T, T2, T3> operator -(SafeAction<T, T2, T3> a, Action<T, T2, T3> b)
        {
            SafeAction<T, T2, T3> res = new SafeAction<T, T2, T3>();
            res.act = a.act - b;
            return res;
        }

        public void SafeInvoke(T param, T2 param2, T3 param3)
        {
            act.SafeInvoke(param, param2, param3);
        }

        public bool IsNull
        {
            get
            {
                return act == null;
            }
        }

        public void Dispose()
        {
            act = null;
        }
    }

    /// <summary>
    /// 能避免重复挂事件的默认委托
    /// </summary>
    public struct SafeAction<T, T2, T3, T4>
    {
        Action<T, T2, T3, T4> act;

        public static implicit operator Action<T, T2, T3, T4>(SafeAction<T, T2, T3, T4> a)
        {
            return a.act;
        }
        
        public static implicit operator SafeAction<T, T2, T3, T4>(Action<T, T2, T3, T4> a)
        {
            SafeAction<T, T2, T3, T4> res = new SafeAction<T, T2, T3, T4>();
            res.act = a;
            return res;
        }
        
        public static SafeAction<T, T2, T3, T4> operator +(SafeAction<T, T2, T3, T4> a, Action<T, T2, T3, T4> b)
        {
            a.act -= b;
            SafeAction<T, T2, T3, T4> res = new SafeAction<T, T2, T3, T4>();
            res.act = a.act + b;
            return res;
        }

        public static SafeAction<T, T2, T3, T4> operator -(SafeAction<T, T2, T3, T4> a, Action<T, T2, T3, T4> b)
        {
            SafeAction<T, T2, T3, T4> res = new SafeAction<T, T2, T3, T4>();
            res.act = a.act - b;
            return res;
        }

        public void SafeInvoke(T param, T2 param2, T3 param3, T4 param4)
        {
            act.SafeInvoke(param, param2, param3,param4);
        }

        public bool IsNull
        {
            get
            {
                return act == null;
            }
        }

        public void Dispose()
        {
            act = null;
        }
    }

    /// <summary>
    /// 能避免重复挂事件的默认委托
    /// </summary>
    public struct SafeAction<T, T2, T3, T4, T5>
    {
        Action<T, T2, T3, T4, T5> act;

        public static implicit operator Action<T, T2, T3, T4, T5>(SafeAction<T, T2, T3, T4, T5> a)
        {
            return a.act;
        }
        
        public static implicit operator SafeAction<T, T2, T3, T4, T5>(Action<T, T2, T3, T4, T5> a)
        {
            SafeAction<T, T2, T3, T4, T5> res = new SafeAction<T, T2, T3, T4, T5>();
            res.act = a;
            return res;
        }
        public static SafeAction<T, T2, T3, T4, T5> operator +(SafeAction<T, T2, T3, T4, T5> a, Action<T, T2, T3, T4, T5> b)
        {
            a.act -= b;
            SafeAction<T, T2, T3, T4, T5> res = new SafeAction<T, T2, T3, T4, T5>();
            res.act = a.act + b;
            return res;
        }

        public static SafeAction<T, T2, T3, T4, T5> operator -(SafeAction<T, T2, T3, T4, T5> a, Action<T, T2, T3, T4, T5> b)
        {
            SafeAction<T, T2, T3, T4, T5> res = new SafeAction<T, T2, T3, T4, T5>();
            res.act = a.act - b;
            return res;
        }

        public void SafeInvoke(T param, T2 param2, T3 param3, T4 param4, T5 param5)
        {
            act.SafeInvoke(param, param2, param3, param4, param5);
        }

        public bool IsNull
        {
            get
            {
                return act == null;
            }
        }

        public void Dispose()
        {
            act = null;
        }
    }

    /// <summary>
    /// 能避免重复挂事件的默认委托
    /// </summary>
    public struct SafeFunc<T>
    {
        Func<T> act;

        public static implicit operator Func<T>(SafeFunc<T> a)
        {
            return a.act;
        }
        
        public static implicit operator SafeFunc<T>(Func<T> a)
        {
            SafeFunc<T> res = new SafeFunc<T>();
            res.act = a;
            return res;
        }
        public static SafeFunc<T> operator +(SafeFunc<T> a, Func<T> b)
        {
            a.act -= b;
            SafeFunc<T> res = new SafeFunc<T>();
            res.act = a.act + b;

            return res;
        }

        public static SafeFunc<T> operator -(SafeFunc<T> a, Func<T> b)
        {
            SafeFunc<T> res = new SafeFunc<T>();
            res.act = a.act - b;
            return res;
        }

        public T SafeInvoke()
        {
            return act.SafeInvoke();
        }

        public bool IsNull
        {
            get
            {
                return act == null;
            }
        }

        public void Dispose()
        {
            act = null;
        }
    }

    /// <summary>
    /// 能避免重复挂事件的默认委托
    /// </summary>
    public struct SafeFunc<T, T2>
    {
        Func<T, T2> act;

        public static implicit operator Func<T, T2>(SafeFunc<T, T2> a)
        {
            return a.act;
        }
        public static implicit operator SafeFunc<T, T2>(Func<T, T2> a)
        {
            SafeFunc<T, T2> res = new SafeFunc<T, T2>();
            res.act = a;
            return res;
        }
        public static SafeFunc<T, T2> operator +(SafeFunc<T, T2> a, Func<T, T2> b)
        {
            a.act -= b;
            SafeFunc<T, T2> res = new SafeFunc<T, T2>();
            res.act = a.act + b;

            return res;
        }

        public static SafeFunc<T, T2> operator -(SafeFunc<T, T2> a, Func<T, T2> b)
        {
            SafeFunc<T, T2> res = new SafeFunc<T, T2>();
            res.act = a.act - b;
            return res;
        }

        public T2 SafeInvoke(T param)
        {
            return act.SafeInvoke(param);
        }

        public bool IsNull
        {
            get
            {
                return act == null;
            }
        }

        public void Dispose()
        {
            act = null;
        }
    }

    /// <summary>
    /// 能避免重复挂事件的默认委托
    /// </summary>
    public struct SafeFunc<T, T2, T3>
    {
        Func<T, T2, T3> act;

        public static implicit operator Func<T, T2, T3>(SafeFunc<T, T2, T3> a)
        {
            return a.act;
        }
        
        public static implicit operator SafeFunc<T, T2, T3>(Func<T, T2, T3> a)
        {
            SafeFunc<T, T2, T3> res = new SafeFunc<T, T2, T3>();
            res.act = a;
            return res;
        }
        public static SafeFunc<T, T2, T3> operator +(SafeFunc<T, T2, T3> a, Func<T, T2, T3> b)
        {
            a.act -= b;
            SafeFunc<T, T2, T3> res = new SafeFunc<T, T2, T3>();
            res.act = a.act + b;

            return res;
        }

        public static SafeFunc<T, T2, T3> operator -(SafeFunc<T, T2, T3> a, Func<T, T2, T3> b)
        {
            SafeFunc<T, T2, T3> res = new SafeFunc<T, T2, T3>();
            res.act = a.act - b;
            return res;
        }

        public T3 SafeInvoke(T param, T2 param2)
        {
            return act.SafeInvoke(param, param2);
        }

        public bool IsNull
        {
            get
            {
                return act == null;
            }
        }

        public void Dispose()
        {
            act = null;
        }
    }

    /// <summary>
    /// 能避免重复挂事件的默认委托
    /// </summary>
    public struct SafeFunc<T, T2, T3, T4>
    {
        Func<T, T2, T3, T4> act;

        public static implicit operator Func<T, T2, T3, T4>(SafeFunc<T, T2, T3, T4> a)
        {
            return a.act;
        }
        
        public static implicit operator SafeFunc<T, T2, T3, T4>(Func<T, T2, T3, T4> a)
        {
            SafeFunc<T, T2, T3, T4> res = new SafeFunc<T, T2, T3, T4>();
            res.act = a;
            return res;
        }
        public static SafeFunc<T, T2, T3, T4> operator +(SafeFunc<T, T2, T3, T4> a, Func<T, T2, T3, T4> b)
        {
            a.act -= b;
            SafeFunc<T, T2, T3, T4> res = new SafeFunc<T, T2, T3, T4>();
            res.act = a.act + b;

            return res;
        }

        public static SafeFunc<T, T2, T3, T4> operator -(SafeFunc<T, T2, T3, T4> a, Func<T, T2, T3, T4> b)
        {
            SafeFunc<T, T2, T3, T4> res = new SafeFunc<T, T2, T3, T4>();
            res.act = a.act - b;
            return res;
        }

        public T4 SafeInvoke(T param, T2 param2, T3 param3)
        {
            return act.SafeInvoke(param, param2, param3);
        }

        public bool IsNull
        {
            get
            {
                return act == null;
            }
        }

        public void Dispose()
        {
            act = null;
        }
    }

    /// <summary>
    /// 能避免重复挂事件的默认委托
    /// </summary>
    public struct SafeFunc<T, T2, T3, T4, T5>
    {
        Func<T, T2, T3, T4, T5> act;

        public static implicit operator Func<T, T2, T3, T4, T5>(SafeFunc<T, T2, T3, T4, T5> a)
        {
            return a.act;
        }
        
        public static implicit operator SafeFunc<T, T2, T3, T4, T5>(Func<T, T2, T3, T4, T5> a)
        {
            SafeFunc<T, T2, T3, T4, T5> res = new SafeFunc<T, T2, T3, T4, T5>();
            res.act = a;
            return res;
        }
        public static SafeFunc<T, T2, T3, T4, T5> operator +(SafeFunc<T, T2, T3, T4, T5> a, Func<T, T2, T3, T4, T5> b)
        {
            a.act -= b;
            SafeFunc<T, T2, T3, T4, T5> res = new SafeFunc<T, T2, T3, T4, T5>();
            res.act = a.act + b;

            return res;
        }

        public static SafeFunc<T, T2, T3, T4, T5> operator -(SafeFunc<T, T2, T3, T4, T5> a, Func<T, T2, T3, T4, T5> b)
        {
            SafeFunc<T, T2, T3, T4, T5> res = new SafeFunc<T, T2, T3, T4, T5>();
            res.act = a.act - b;
            return res;
        }

        public T5 SafeInvoke(T param, T2 param2, T3 param3, T4 param4)
        {
            return act.SafeInvoke(param, param2, param3, param4);
        }

        public bool IsNull
        {
            get
            {
                return act == null;
            }
        }

        public void Dispose()
        {
            act = null;
        }
    }
}

想要实现的效果：

玩家等级变化—> 界面UI变化 / 怪物生成数量变化 /
事件的总类：
与事件相关联的方法的参数类型必须一致， 这里传入的皆为玩家的等级
因为所有事件的触发条件都是玩家等级的变化。

namespace EventCenter
{
    public static class Player
    {
        public static SafeAction<int> LevelChange;
    }

    public static class UI
    {
        public static SafeAction<PlayerInfo> UpdatePlayerInfo; 
    }
}

玩家信息类 : 用来存储玩家数据
PlayerInfo做成一个单例 ， level写一个属性， 每次调用set方法时就会调用事件里面的方法。事件里面的方法就是UI和怪物生成数量变化的方法。

using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class PlayerInfo
{
    public int level;
    public int Level
    {
        get
        {
            return level;
        }
        set
        {
            level = value;
            //调用委托里面的方法
            EventCenter.Player.LevelChange.SafeInvoke(level);
        }
    }
    public int hp;
    private static PlayerInfo playerInfo;
    public static PlayerInfo Ins()
    {
        if (playerInfo == null)
        {
            playerInfo = new PlayerInfo();
        }
        return playerInfo;
    }
    public PlayerInfo()
    {
        level = 1;
        UpdateStatus(level);
    }

    public void UpdateStatus(int level)
    {
        Debug.Log("UpdateStatus");
        this.level = level;
        hp  = 10 + level * 2;
        EventCenter.UI.UpdatePlayerInfo.SafeInvoke(this);
    }
}

PlayerController类：
主要就是写等级变化的触发条件：

	using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class PlayerController : MonoBehaviour
{
    void Start()
    {
        EventCenter.Player.LevelChange += PlayerInfo.Ins().UpdateStatus;
    }


    void Update()
    {
        if (Input.GetKeyDown(KeyCode.Space))
        {
            PlayerInfo.Ins().Level++;   
            print("level= " + PlayerInfo.Ins().level);
        }
    }
    private void OnDestroy()
    {
        EventCenter.Player.LevelChange -= PlayerInfo.Ins().UpdateStatus;
    }
}

SceneManager类： 根据玩家等级的变化生成怪物数量。

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class SceneManager :MonoBehaviour
{
    GameObject prefabMonster;


    private void Start()
    {
        prefabMonster = Resources.Load<GameObject>("Monster");
        EventCenter.Player.LevelChange += CreateMonster;
    }

    void CreateMonster(int lv)
    {
        for (int i = 0; i < lv; i++)
        {
            Instantiate(prefabMonster);
        }
    }
    private void Update()
    {
        
    }
    private void OnDestroy()
    {
        EventCenter.Player.LevelChange -= CreateMonster;
    }
}

GameUI类: 界面UI等级数字的变化

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;

public class GameUI : MonoBehaviour
{
    Text level;
    public void UpdateLevel(int lv)
    {
        level.text = lv.ToString();
    }
    void Start()
    {
        level = transform.Find("Level").GetComponent<Text>();
        EventCenter.Player.LevelChange += UpdateLevel;
    }

  
    void Update()
    {
       
    }
    private void OnDestroy()
    {
        EventCenter.Player.LevelChange -= UpdateLevel;
    }
}
894.000000
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Unity:动态加载游戏等级.
u013509878的博客
05-05 1166
我们知道在游戏中,游戏等级不是在搭建UI时写死的,而是动态加载的.比如,消灭星星,等级的信息是根据玩家的数据而改变的,不同的等级可能得到的星星数量不同.动态加载时在搭好的UI界面通过Resources,load动态加载进去,资源工程文件:https://pan.baidu.com/s/1RIF_fdFOye6sFu82_7aUpw项目目标.步骤:1.首先还是搭建UI界面,层次等级如下:Select...
Unity 升级系统 经验值管理器 AES 加密 经验配置表存档
u013160594的博客
03-06 3585
Unity 升级系统 经验值管理器 AES 加密 经验配置表存档
Unity 监听第一次进入播放状态的事件
无幻
02-25 6843
原因由于 Unity 场景没有挂载脚本，当要在编辑器下也可以直接运行游戏时，需要给场景动态挂载脚本，那么就需要知道 Unity 第一次进入播放状态的事件。编辑器提供了EditorApplication.playmodeStateChanged委托事件，会在播放状态改变的时候进行回调，但是这个事件不止会回调一次，播放、暂停、结束等都会调用这个事件，而且第一次调用时，也不是真正进入播放状态的时机。详细的
Unity3D levels表
Nice_66的博客
06-13 412
Unity3D自学笔记——UGUI背包系统（五）沿用Attribute设计实现物品等级
alistair_chow的博客
11-08 3478
沿用Attribute设计实现物品等级效果图1级物品 前面已对Attribute设计做了介绍 Unity3D自学笔记——角色属性设计分析 Unity3D自学笔记——架构应用（十）角色属性 大致示意图增加ItemStatus为了沿用设计，首先需要将AttributeNode封装出来 通过从UserItemEntity封装ItemStatuspublic class ItemStatu
Unity自带的存储信息PlayerPrefs
piyixia的博客
06-13 559
Playerprefs静态方法 SetFloat()，SetInt()，SetString()写入数据 GetFloat()，GetInt()，GetString()读取数据 DeleteKey()，DeleteAll()删除数据 HasKey(“SS”)检查数据，是否有该键 Save() 这些函数的用法基本一致使用Set进行保存，使用获取进行读取。 ...
Unity3D如何导出为webGL--教程.zip
01-09
Unity3D是一款强大的跨平台游戏开发引擎，广泛用于制作2D和3D游戏、互动体验以及虚拟现实应用。WebGL是一种基于OpenGL标准的JavaScript API，它允许在任何兼容的现代浏览器中实现硬件加速的3D图形渲染，无需任何插件...
Ubuntu-Linux的桌面环境和初始设置.docx
12-15
它包括一系列类似 HTML 的标记，并以树型结构来对这些标记进行排列。用户可以通过了解 XML 的基础概念来更好地使用 Libxml2 库。 8. 小结 本文详细介绍了 Ubuntu Linux 的桌面环境和初始设置，包括登录界面、桌面...
Unity-support-Arabic-language-gameobject：Gameobject上免费支持统一教程的阿拉伯语
02-06
9. **教程和社区资源**：Unity有一系列官方教程和社区资源，如Unity Learn、论坛等，可以学习更多关于阿拉伯语支持的知识和最佳实践。 10. **持续更新**：随着Unity版本的更新，其对阿拉伯语的支持可能会有所改进，...
不知道怎么开发VR游戏？Unity5.3官方VR教程重磅登场-系列11
08-03
一、VR 基础知识 虚拟现实（VR）是一种计算机模拟的三维环境，可以提供更加逼真的体验。VR 技术可以应用于游戏、教育、医疗、建筑等领域。Unity 5.3 提供了对 VR 的支持，可以-help 开发者快速创建 VR 游戏。 ...
Unity-Jump.rar
09-06
6. **脚本编程**：Unity3D支持C#脚本，开发者会编写一系列的C#脚本来控制游戏逻辑。例如，一个名为“PlayerController”的脚本可能会包含角色的移动、跳跃和分数计算等功能。 7. **碰撞检测**：Unity3D的Collider...
Unity 数据存储与读取_PlayerPrefs
风定川华的博客
01-25 365
using System.Collections; using System.Collections.Generic; using UnityEngine; using UnityEngine.UI; public class PlayerInfo : MonoBehaviour { /// /// 等级 /// public Text LevelText;
Unity实战篇：移植游戏到安卓平台的注意事项及其实例（四）（玩家等级，对象池概念的引入以及优化）
设计师养成记
10-03 597
1.对象池基础概念的了解（必看） https://blog.csdn.net/qq_15020543/article/details/82933479 2.引入玩家等级概念，根据玩家等级来升级子弹，针对项目来进行嵌入对象池 对于玩家，我们需要多添加几个子弹发射位置。玩家等级和枚举类型皆由GameController控制 using UnityEngine;...
《Unity初试面试评级标准初稿》请拍砖。。。
yizhenlei的专栏
08-13 1736
拟把面试人员技术能力分为四个等级，按A（主程级别）、B（高级）、C（中级）、D（初级）四个等级划分；并将每个级别分为三个档次，按照前缀 + 、- 来区分，例如：A等级中有三个级别，分别为：A+ 、A 和 A- ，B等级中有B+ 、B、B- 。 各级别暂拟定标准如下： A等级：定义为主程级别，需具备能力如下： 》三年以上Unity项目经验， 》精通C#语言。 》良好的英文阅读能力，可读懂A
Unity 各个系统
qq_35433081的博客
07-23 2615
一：Animator: 动画事件：写在text中，读写 动画名字+路径+动画时长+动画触发事件 动画:勾选此选项后，动画会跳抖动，动画一致播放，播放不完整。自己一直传递自己，一般此选项不勾选。 动画平滑过渡的原理： 插值两个帧之间有变化的骨骼的旋转和位移。 Mirr: 动画镜像 左右走 2DBlendTree : 多个动画之间的融合。相同身体部位，不同身体的融合。 A...
全面理解 Unity UI 系统
热门推荐
01-04 1万+
随着 Unity 4.6 发布，新 UI 系统终于与大家见面了。这篇文章将不会介绍如何使用按钮、滚动条之类的UI控件，这些内容可以参考 Unity Manual；这篇文章的重点是，如何理解 UI 系统的设计，以便更好的在实际中使用它。   RectTransform         Unity UI 系统使用 RectTransform 实现基本的布局和层次控制。RectTr
unity3d职业规划与技能职级体系
Have a nice day.
12-07 3240
职业规划 UI程序员（3年起步，UI都很重复，重复到90%时间跟个机器人一样） 中级u3d：游戏核心模块程序员（技能，任务，新手引导） （3-5年） 高级u3d：引擎专家程序员，模块组长（UI业务组，战斗组）（网络连接，AI寻路模块，动画状态机管理，声音管理，AssetBundle管理，大世界加载优化） 主程，(客户端技术总监（技术管理岗）或者是转行做TA，或者是到大公司里面做引擎组的成员，或者是全栈工程师，（客户端+服务器) 技能职级体系 ...
U3D客户端框架之基于类对象池的可回收变量代码实现
qq_33531923的博客
11-15 351
因为原先已经写过一篇文章了，里面已经写明白了类对象池是什么？具体特征是什么？优缺点都有什么？大家如果有兴趣可以点下面的文章去细看一下。如果懂原理直接看代码即可。
【Unity经验】委托与事件
BuladeMian的博客，菜得抠脚，菜得真实
01-05 2465
SIKI的028-控制人物的状态和其他信息的更新同步 里面就使用了委托与事件，其他的参考资料在文章下面 PlayerInfo是事件，PlayerBar是委托 PlayerBar委托PlayerInfo办事情，由于PlayerBar要办理的业务很多很杂，因此PlayerInfo需要知道PB要办理什么样的业务， 才能解决对应的问题 委托的标识符就是delegate 事件
unityplayer.dll
最新发布
08-30
而unityplayer.dll文件是Unity引擎的核心组件之一，它包含了一系列供游戏引擎使用的功能、类和方法。 unityplayer.dll文件的存在是为了帮助Unity引擎在Windows操作系统上正常运行。它包含了Unity引擎所需的众多功能...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值