MyFramework(一)
一、介绍
这是一个纯的前端框架,适用于unity的C#开发,如今只是一个雏形,是根据ET框架中的思想经过他人(我是伸手党)的整理而形成的初版。
二、整体构思
项目分为两个文件夹:Framework和Module
1、Framework文件夹
(1)Kernel:框架的核心
思想:跟unity的思想一样:一切皆对象。
首先自己定义了一个Object类,这是所有类型的基类。
/// <summary>
/// Entity / Component base class
/// </summary>
public class Object : IDisposable
{
/// <summary>
/// 唯一Id(当前环境)
/// </summary>
public long InstanceId { get; private set; }
//用作资源的回收和管理
private bool isFormPool;
public bool IsFormPool
{
get
{
return this.isFormPool;
}
set
{
this.isFormPool = value;
if (!isFormPool) return;
if (InstanceId == 0) InstanceId = IdGenerater.GenerateInstanceId();
}
}
public Object Parent { get; set; }
//只有继承Object的类才能被获取-------------对返回的类进行限定
public T GetParent<T>() where T : Object
{
return Parent as T;
}
public Object()
{
//给每个继承Object的类生成唯一id
this.InstanceId = IdGenerater.GenerateInstanceId();
}
public virtual void Dispose()
{
this.InstanceId = 0;
if (this.isFormPool)
{
Game.ObjectPool.Recycle(this);
}
}
public bool IsDisposed
{
get
{
return this.InstanceId == 0;
}
}
}
Entity.cs--------实体类,相当于Unity中的GameObject,一个实体上可以挂载许多个Component。
/// <summary>
/// 所有实体基类
/// </summary>
public class Entity : Object
{
public long Id { get; set; }
private Dictionary<Type, Component> components = new Dictionary<Type, Component>();
public Entity()
{
Id = InstanceId;
}
// 约束构造函数
public virtual K AddComponent<K>() where K : Component, new()
{
Type type = typeof(K);
if (this.components.ContainsKey(type))
{
throw new Exception($"Component already exist, id: {this.Id}, component: {typeof(K).Name}");
}
K component = ObjectFactory.CreateWithParent<K>(this, this.IsFormPool);
this.components.Add(type, component);
return component;
}
//获取挂载到Entity上的组件
public virtual K GetComponent<K>() where K : Component
{
Type type = typeof(K);
if (this.components.TryGetValue(type, out Component com))
{
return com as K;
}
Log.Error($"类型不存在:{type}");
return null;
}
//移除组件
public virtual void RemoveComponent<T>() where T : Component
{
if (IsDisposed) return;
Type type = typeof(T);
Component component;
if (!this.components.TryGetValue(type, out component))
{
return;
}
components.Remove(type);
component.Dispose();
}
}
Component.cs-------------所有组件的基类
/// <summary>
/// 所有逻辑组件基类
/// </summary>
public class Component : Object
{
public override void Dispose()
{
if (IsDisposed) return;
Game.System.RemoveSystem(this);
base.Dispose();
}
}
ObjectPool.cs------------对象池,用于管理所有的object对象
public class ObjectPool : Object
{
private readonly Dictionary<Type, Queue<Object>> objects = new Dictionary<Type, Queue<Object>>();
public Object Fetch(Type type)
{
Object obj;
if (!this.objects.TryGetValue(type, out Queue<Object> queue))
{
obj = (Object)Activator.CreateInstance(type);
}
else
{
if (queue.Count == 0)
obj = (Object)Activator.CreateInstance(type);
else
{
obj = queue.Dequeue();
Log.DebugPurple($"Fetch:{obj.GetType()}");
}
}
obj.IsFormPool = true;
return obj;
}
public void Recycle(Object obj)
{
obj.Parent = this;
Type type = obj.GetType();
Queue<Object> queue;
if (!this.objects.TryGetValue(type, out queue))
{
queue = new Queue<Object>();
this.objects.Add(type, queue);
}
queue.Enqueue(obj);
Log.DebugPurple($"Recycle:{obj.GetType()}");
}
}
System.cs------整个系统的核心,管理所有对象的生命周期,自己实现的一套生命周期,而不是直接使用Monobehaior中生命周期。
/// <summary>
/// 所有对象生命周期管理
/// </summary>
public sealed class System
{
private readonly MultiMap<Type, Type> types = new MultiMap<Type, Type>();
private readonly Dictionary<long, Object> objects = new Dictionary<long, Object>();
private readonly Dictionary<long, IUpdate> updates = new Dictionary<long, IUpdate>();
private readonly Dictionary<long, ILateUpdate> lateUpdates = new Dictionary<long, ILateUpdate>();
private Queue<long> startEnter = new Queue<long>();
private Queue<long> updateEnter = new Queue<long>();
private Queue<long> updateExit = new Queue<long>();
private Queue<long> lateUpdateEnter = new Queue<long>();
private Queue<long> lateUpdateExit = new Queue<long>();
public void AddSystem(Object obj)
{
long InstanceId = obj.InstanceId;
this.objects.Add(InstanceId, obj);
if (obj is IStart)
{
startEnter.Enqueue(InstanceId);
}
if (obj is IUpdate)
{
updateEnter.Enqueue(InstanceId);
}
if (obj is ILateUpdate)
{
lateUpdateEnter.Enqueue(InstanceId);
}
}
public void RemoveSystem(Object obj)
{
long instanceId = obj.InstanceId;
if (objects.ContainsKey(instanceId)) objects.Remove(instanceId);
if (updates.ContainsKey(instanceId)) updateExit.Enqueue(obj.InstanceId);
if (lateUpdates.ContainsKey(instanceId)) lateUpdateExit.Enqueue(instanceId);
}
public void AddTypes(Assembly assembly)
{
types.Clear();
foreach (Type type in assembly.GetTypes())
{
object[] objects = type.GetCustomAttributes(typeof(BaseAttribute), false);
if (objects.Length == 0) continue;
BaseAttribute baseAttribute = (BaseAttribute)objects[0];
this.types.Add(baseAttribute.AttributeType, type);
}
}
}
整个核心架构就这些了,这个思想跟ECS很像(也可以说是仿照ECS写的),可以完全不继承MonoBehaivor,动态实例化Entity,然后在对应的Entity上挂载相应的组件来实现管理的,而且不同的Entity挂载相同的组件就可以获得该组件的所有功能,用起来非常方便。