Unity3d+Gameframework:entity实体代码分析，基于StarForce

Posted 2023-04-02 四夕立羽

游戏场景中，动态创建的一切物体定义为实体。此模块提供管理实体和实体组的功能，如显示隐藏实体、挂接实体（如挂接武器、坐骑，或者抓起另一个实体）等。实体使用结束后可以不立刻销毁，从而等待下一次重新使用。

EntityGroup

内部包含对象池

实体加载成功订阅

GameEntry.Event.Subscribe(ShowEntitySuccessEventArgs.EventId, OnShowEntitySuccess);
protected virtual void OnShowEntitySuccess(object sender, GameEventArgs e)
        
            ShowEntitySuccessEventArgs ne = (ShowEntitySuccessEventArgs)e;
            if (ne.EntityLogicType == typeof(MyAircraft))
            
                m_MyAircraft = (MyAircraft)ne.Entity.Logic;
            
        

EntityManager

GameFramework.Entity.EntityManager.Update
实体组轮询，变为单一实体OnUpdate

创建实体

StarForce.GameBase.Initialize
与加载UI类似
GameFramework.Entity.EntityManager.ShowEntity

GameFramework.Entity.EntityManager.ShowEntity 

 EntityInstanceObject entityInstanceObject = entityGroup.SpawnEntityInstanceObject(entityAssetName);
            if (entityInstanceObject == null)
            
                int serialId = ++m_Serial;
                m_EntitiesBeingLoaded.Add(entityId, serialId);
                m_ResourceManager.LoadAsset(entityAssetName, priority, m_LoadAssetCallbacks, ShowEntityInfo.Create(serialId, entityId, entityGroup, userData));
                return;
            

            InternalShowEntity(entityId, entityAssetName, entityGroup, entityInstanceObject.Target, false, 0f, userData);

如果实体组中对象池能实例出来，即立即返回
否则调用资源加载
实体资源表中确定ID与asset的关系

  IDataTable<DREntity> dtEntity = GameEntry.DataTable.GetDataTable<DREntity>();
            DREntity drEntity = dtEntity.GetDataRow(data.TypeId);

正在加载中实体释放

public void HideEntity(int entityId, object userData)
        
            if (IsLoadingEntity(entityId))
            
                GameFrameworkLog.Info("实体0正在加载等待释放", entityId);
                m_EntitiesToReleaseOnLoad.Add(m_EntitiesBeingLoaded[entityId]);
                m_EntitiesBeingLoaded.Remove(entityId);
                return;
            

Entity

实体接口，包含被挂载，或者挂载别的方法
根据资源加载出的GameObject–》挂载Entity脚本（继承了于MonoBehaviour）

 /// <summary>
        /// 创建实体。
        /// </summary>
        /// <param name="entityInstance">实体实例。</param>
        /// <param name="entityGroup">实体所属的实体组。</param>
        /// <param name="userData">用户自定义数据。</param>
        /// <returns>实体。</returns>
        public override IEntity CreateEntity(object entityInstance, IEntityGroup entityGroup, object userData)
        
            GameObject gameObject = entityInstance as GameObject;
                     Transform transform = gameObject.transform;
            transform.SetParent(((MonoBehaviour)entityGroup.Helper).transform);

            return gameObject.GetOrAddComponent<Entity>();
        

实体统一设置到实体组子物体下，那么武器跟随人动如何实现

   namespace UnityGameFramework.Runtime
   
     public sealed class Entity : MonoBehaviour, IEntity
    
        private int m_Id;
        private string m_EntityAssetName;
        private IEntityGroup m_EntityGroup;
        private EntityLogic m_EntityLogic;

ObjecBase

对象基类
UI面板，资源（asset，resource），实体都是继承对象基类

EntityInstanceObject

实体实例对象，不会继承自MonoBehavior，在实体资源加载成功后调用创建
GameFramework.Entity.EntityManager.LoadAssetSuccessCallback

//实例化出来
            EntityInstanceObject entityInstanceObject = EntityInstanceObject.Create(entityAssetName, entityAsset, m_EntityHelper.InstantiateEntity(entityAsset), m_EntityHelper);
            showEntityInfo.EntityGroup.RegisterEntityInstanceObject(entityInstanceObject, true);

            InternalShowEntity(showEntityInfo.EntityId, entityAssetName, showEntityInfo.EntityGroup, entityInstanceObject.Target, true, duration, showEntityInfo.UserData);
            ReferencePool.Release(showEntityInfo);

把预制体加载完成，然后实例化后GameObject设置为实体的Target

EntityLogic

public abstract class EntityLogic : MonoBehaviour
实体逻辑基类
实体挂载好Entity，后Entity初始化时挂载逻辑处理脚本
public abstract class Entity : EntityLogic，此实体与gf实体不是同样东西（不在同个命名空间中）
创建时，通过逻辑类型就传递下去

public static void ShowMyAircraft(this EntityComponent entityComponent, MyAircraftData data)
        
            entityComponent.ShowEntity(typeof(MyAircraft), "Aircraft", Constant.AssetPriority.MyAircraftAsset, data);
        

SurvivalGame

继承GameBase
游戏模式
Update中随机产生陨石实体
GameEntry.Entity.ShowAsteroid

TargetableObject

所有的实体逻辑继承
OnTriggerEnter，碰撞检测

放入到回收池，什么时候彻底去除引用

Weapon

增加武器实体，为什么能挂载人身上
武器挂载
在创建完成后，挂载在主角身上
StarForce.Weapon.OnShow

protected override void OnShow(object userData)
        
            base.OnShow(userData);

            m_WeaponData = userData as WeaponData;
             GameEntry.Entity.AttachEntity(Entity, m_WeaponData.OwnerId, AttachPoint);
        

AttachEntity

附加子实体GameFramework.Entity.EntityManager.AttachEntity

             IEntity childEntity = childEntityInfo.Entity;
            IEntity parentEntity = parentEntityInfo.Entity;
            DetachEntity(childEntity.Id, userData);
            childEntityInfo.ParentEntity = parentEntity;
            parentEntityInfo.AddChildEntity(childEntity);
            parentEntity.OnAttached(childEntity, userData);
            childEntity.OnAttachTo(parentEntity, userData);

在childEntity.OnAttachTo(parentEntity, userData);设置unity 父子物体关系

 protected internal virtual void OnAttachTo(EntityLogic parentEntity, Transform parentTransform, object userData)
        
            CachedTransform.SetParent(parentTransform);
        

InternalHideEntity隐藏实体

//先隐藏子实体
            while (entityInfo.ChildEntityCount > 0)
            
                IEntity childEntity = entityInfo.GetChildEntity();
                HideEntity(childEntity.Id, userData);
            
            //把自己从父实体上移除
            IEntity entity = entityInfo.Entity;
            DetachEntity(entity.Id, userData);
            entityInfo.Status = EntityStatus.WillHide;
            entity.OnHide(m_IsShutdown, userData);
            entityInfo.Status = EntityStatus.Hidden;
            
            //实体组移除
            EntityGroup entityGroup = (EntityGroup)entity.EntityGroup;
            entityGroup.RemoveEntity(entity);
            
            //放入到回收队列
            m_RecycleQueue.Enqueue(entityInfo);

GameFramework.Entity.EntityManager.Update 中轮询处理实体进入实体组的对象池

//处理回收队列的实体
            while (m_RecycleQueue.Count > 0)
            
                EntityInfo entityInfo = m_RecycleQueue.Dequeue();
                IEntity entity = entityInfo.Entity;
                EntityGroup entityGroup = (EntityGroup)entity.EntityGroup;
                entityInfo.Status = EntityStatus.WillRecycle;
                entity.OnRecycle();
                entityInfo.Status = EntityStatus.Recycled;
                entityGroup.UnspawnEntity(entity); //实体组回收，相当于对象池
                ReferencePool.Release(entityInfo);
            

2022-04-20 Unity入门7——物理系统之碰撞检测

文章目录

• • • • 一、刚体 Rigid Body
      • 二、碰撞器 Collider
      • 三、物理材质
      • 四、碰撞检测函数
      • 五、刚体加力

一、刚体 Rigid Body

​ 刚体利用体积（碰撞器 Collider）进行碰撞计算，模拟真实的碰撞效果，产生力的作用

​ 碰撞产生的必要条件：

• 两个物体都有碰撞器 Collider
• 至少一个物体有刚体

1. Mass：质量

   默认为千克，质量越大惯性越大

2. Drag：空气阻力

   根据力移动对象时影响空气阻力大小

   0 表示没有空气阻力

3. Augular Drag：旋转阻力

   根据扭矩旋转对象时影响对象的空气阻力大小

   0 表示没有阻力

4. Use Gravity：是否受重力影响

5. Is Kinematic：是否设置为运动学

   如果启用，对象将不会被物理引擎驱动，只能通过 Transform 对其进行操作

   对于移动平台，或者如果要动画附加了 HingeJoint 的刚体，此属性将非常有用

6. Interpolate：插值运算

   • None：不应用插值运算

   • Interpolate：根据前一帧的变换来平滑变换

   • Extrapolate：插值运算

     根据下一帧的估计变换来平滑变换，若物理帧时间过长，此效果将不好

7. Collison Detection：碰撞检测模式

   • Discrete：离散检测

     对场景中的所有其他碰撞体使用离散碰撞检测，其他碰撞体在测试碰撞时会使用离散检测。

     用于正常碰撞（默认值）

   • Continuous：连续检测

     对动态碰撞体（具有刚体）使用离散碰撞检测

     对静态碰撞体（没有刚体）使用连续碰撞检测

     设置为连续动态的刚体，将在测试与该刚体的碰撞时使用连续碰撞检测（物理性能消耗较大，物体运动缓慢时请设置为 Discrete）

     其他刚体将使用离散碰撞检测

   • Continuous Dynamic：连续动态检测

     对设置为连续和连续动态碰撞的对象使用连续碰撞检测

     对静态碰撞体（没有刚体）使用连续碰撞检测

     对其他碰撞体使用离散碰撞检测

     用于快速移动的对象

   • Continuous Speculative：连续推测检测

     对刚体和碰撞体使用推测性连续碰撞检测

     通常比连续碰撞检测的成本更低

   	无刚体碰撞盒	Discrete	Continuous	Continuous Dynamic	Continuous Speculative
   无刚体碰撞盒	不检测碰撞	Discrete	Continuous	Continuous	Continuous Speculative
   Discrete	Discrete	Discrete	Discrete	Discrete	Continuous Speculative
   Continuous	Continuous	Discrete	Discrete	Continuous	Continuous Speculative
   Continuous Dynamic	Continuous	Discrete	Continuous	Continuous	Continuous Speculative
   Continuous Speculative	Continuous Speculative	Continuous Speculative	Continuous Speculative	Continuous Speculative	Continuous Speculative

   性能消耗关系：Continuous Dynamic > Continuous Speculative > Continuous > Discrete

8. Constrains：对刚体运动的约束

   • Freeze Position：限制刚体在世界坐标轴下 X、Y、Z 轴的移动
   • Freeze Rotation：限制刚体在世界坐标轴下 X、Y、Z 轴的旋转

9. Info：用于显示参数的面板，不修改里面的值

二、碰撞器 Collider

​ 碰撞器表示物体的体积（形状）

​ 碰撞器种类一共有 6 种：

• 盒状碰撞器 Box Collider
• 球状碰撞器 Sphere Collider
• 胶囊碰撞器 Capsule Collider
• 网格碰撞器 Mesh Collider
• 轮胎碰撞器 Wheel Collider
• 地形碰撞器 Terrain Collider

​ 常用的为前 3 种

（一）共同参数

1. Edit Collider：编辑碰撞器的大小

2. Is Trigger：是否为触发器

   如果启用，则该碰撞体用于触发事件，并被物理引擎所忽略

   主要用于进行没有物理效果的碰撞检测

3. Material：物理材质

   可以确定碰撞体和其他对象碰撞时的交互（表现）方式

4. Center：碰撞体的中心偏移位置

（二）常用碰撞器

1. Box Collider
   • Size：碰撞体在 X、Y、Z 方向上的大小
2. Sphere Collider
   • Radius：球形碰撞体的半径大小
3. Capsule Collider
   • Radius：胶囊体的半径
   • Height：胶囊体的高度
   • Direction：胶囊体在对象局部空间中的轴向

（三）异形物体使用多种碰撞器组合

​ 刚体对象的子对象碰撞信息参与碰撞检测

​ 即父物体添加 Rigid Body，子物体设置 Collider。

（四）不常用碰撞器

1. Mesh Collider

   • Convex：是否为凸面的

     勾选后，该 Mesh Collider 将会与其他 Mesh Collider 发生碰撞，最多支持 255 个三角面片

     如果该对象添加了刚体 Rigid Body，则该选项必须勾选，否则会报错

   • Cooking Options：物理引擎对网格的处理方式

     不常用

   • Mesh：引用需要用于碰撞的网格

2. Wheel Collider

   赛车游戏中使用，其他时候不常用

   注意：添加 Wheel Collider 后一定要添加 Rigid Body（或在父物体添加），否则将失效

3. Terrain Collider

   地形系统中使用

   性能较为低下，很少使用

三、物理材质

​ 在 Project 中创建物理材质 Physics Material

1. Dynamic Friction：滑动摩擦力

   0 表示绝对光滑，1 表示迅速静止

2. Static Frction：静摩擦力

   0 表示绝对光滑，1 表示无法移动

3. Bounciness：表面弹性

   0 表示不会反弹，1 表示反弹没有能量损失，甚至可能会增加少量能量

4. Friction Combine：摩擦力组合方式

   • Average：取平均值
   • Minimum：取最小值
   • Maximum：取最大值
   • Multiply：相乘

5. Bounce Combine：弹性组合方式

   • Average：取平均值
   • Minimum：取最小值
   • Maximum：取最大值
   • Multiply：相乘

四、碰撞检测函数

​ 碰撞和触发响应函数属于特殊的生命周期函数，也是通过反射调用

​ 碰撞和触发器函数都可以写成虚函数，在子类去重写逻辑

（一）物理碰撞检测响应函数

// 碰撞触发接触时会 自动执行这个函数
private void OnCollisionEnter(Collision collision)

    // Collision类型的 参数 包含了 碰到自己的对象的相关信息

    // 关键参数
    // 1.碰撞到的对象碰撞器的信息
    collision.collider

    // 2.碰撞对象的依附对象（GameObject）
    collision.gameObject

    // 3.碰撞对象的依附对象的位置信息
    collision.transform

    // 4.触碰点数相关
    collision.contactCount
    // 接触点 具体的坐标
    ContactPoint[] pos = collision.contacts;

    // 只要得到了 碰撞到的对象的 任意一个信息 就可以得到它的所有信息

    print(this.name + "被" + collision.gameObject.name + "撞到了");


// 碰撞结束分离时  会自动执行的函数
private void OnCollisionExit(Collision collision)

    print(this.name + "被" + collision.gameObject.name + "结束碰撞了");


// 两个物体相互接触摩擦时 会不停的调用该函数
private void OnCollisionStay(Collision collision)

    print(this.name + "一直在和" + collision.gameObject.name + "接触");

（二）触发器检测响应函数

// 触发开始的函数 当第一次接触时 会自动调用
protected virtual void OnTriggerEnter(Collider other)

    print(this.name + "被" + other.gameObject.name + "触发了");


// 触发结束的函数 当水乳相融的状态结束时 会调用一次
private void OnTriggerExit(Collider other)

    print(this.name + "被" + other.gameObject.name + "结束水乳相融的状态了");


// 当两个对象 水乳相融的时候 会不停调用
private void OnTriggerStay(Collider other)

    print(this.name + "和" + other.gameObject.name + "正在水乳相融");

1. 只要挂载的对象能和别的物体产生碰撞或者触发，那么对应的这 6 个函数就能够被响应

2. 6 个函数不是说都得写，一般根据需求来进行选择书写，一般用 Enter 函数较多

3. 如果是一个异形物体，刚体在父对象上，如果你想通过子对象上挂脚本检测碰撞是不行的，必须挂载到这个刚体父对象上才行

五、刚体加力

（一）刚体自带添加力的方法

1. 获取刚体组件

rigidBody = this.GetComponent<Rigidbody>();

2. 添加力

// 相对世界坐标
// 世界坐标系 Z轴正方向加了一个力
// 加力过后 对象是否停止移动 是由阻力决定的
// 如果阻力为0 那给了一个力过后 始终 是不会停止运动
rigidBody.AddForce(Vector3.forward * 10);

// 如果想要在 世界坐标系方法中 让对象 相对于自己的面朝向动
rigidBody.AddForce(this.transform.forward * 10);

// 相对本地坐标
rigidBody.AddRelativeForce(Vector3.forward * 10);

//如果你希望即使有阻力 也希望对象一直动 那你就把下面代码放在Update函数中 一直“推”就行了
rigidBody.AddForce(Vector3.forward * 10);

3. 添加扭矩力

// 相对世界坐标
// 绕y轴旋转
rigidBody.AddTorque(Vector3.up * 10);

// 相对本地坐标
rigidBody.AddRelativeTorque(Vector3.up * 10);

4. 直接改变速度

// 这个速度方向 是相对于 世界坐标系的 
// 如果要直接通过改变速度 来让其移动 一定要注意这一点
rigidBody.velocity = Vector3.forward * 5;

5. 模拟爆炸效果

// 模拟爆炸的力 一定是 所有希望产生爆炸效果影响的对象 
// 都需要得到他们的刚体 来执行这个方法 才能都有效果
// 参数一 爆炸力
// 参数二 爆炸位置
// 参数三 爆炸半径范围
rigidBody.AddExplosionForce(100, Vector3.zero, 10);

（二）力的模式

// 第二个参数 力的模式 主要的作用 就是 计算方式不同而已 
// 由于4中计算方式的不同 最终的移动速度就会不同
rigidBody.AddForce(Vector3.forward * 10, ForceMode.Acceleration);

​ 速度计算公式：v = F * t / m（动量定理）

1. Acceleration

   给物体增加一个持续的加速度，忽略其质量

   F = (0, 0, 10)、t = 0.02 s、m = 默认为 1
   v = 10 * 0.02 / 1 = 0.2 m/s
   每物理帧移动 0.2 m/s * 0.02 = 0.004 m

2. Force

   给物体添加一个持续的力，与物体的质量有关
   F = (0, 0, 10)、t = 0.02 s、m = 2 kg
   v = 10 * 0.02 / 2 = 0.1 m/s
   每物理帧移动 0.1 m/s * 0.02 = 0.002 m

3. Impulse

   给物体添加一个瞬间的力，与物体的质量有关，忽略时间，t 默认为1
   F = (0, 0, 10)、t = 1 s、m = 2 kg
   v = 10 * 1 / 2 = 5 m/s
   每物理帧移动 5 m/s * 0.02 = 0.1 m

4. VelocityChange

   给物体添加一个瞬时速度，忽略质量，忽略时间
   F = (0, 0, 10)、t = 1 s、m = 默认为 1
   v = 10 * 1 / 1 = 10 m/s
   每物理帧移动 10 m/s * 0.02 = 0.2 m

（三）力场

​ 为物体添加 Constant Force，若物体之前没有 Rigid Body，则会为其自动添加

​ 进行参数设置

（四）刚体休眠

​ Unity 为了节约性能，为刚体添加了休眠机制：

Rigidbody sleeping happens completely automatically. Whenever a rigidbody is slower than the sleepAngularVelocity and sleepVelocity it will start falling asleep. After a few frames of resting it will then be set to sleep. When the body is sleeping, no collision detection or simulation will be performed anymore. This saves a lot of CPU cycles.

刚体休眠完全自动发生。只要刚体的速度低于 sleepAngularVelocity 和 sleepVelocity，该刚体就会开始休眠。其空闲一些帧后，就会被设置成休眠状态。处于休眠状态中的物体，不会再对其进行碰撞检测和模拟。这会节约大量的 CPU 开销。

​ 例如，在为 Cube 添加 Rigid Body 后其下落静止在平面上

​ 将平面旋转一定角度后，发现 Cube 悬空，说明此时 Cube 的刚体休眠了

​ 将平面向下以一定速度拖动，则 Cube 下落，刚体被激活

​ 使用代码控制：

// 获取刚体是否处于休眠状态 如果是 
if (rigidBody.IsSleeping())

    // 就唤醒它
    rigidBody.WakeUp();