EntityManager.EntityGroup.cs 13 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394
  1. //------------------------------------------------------------
  2. // Game Framework
  3. // Copyright © 2013-2021 loyalsoft. All rights reserved.
  4. // Homepage: http://www.game7000.com/
  5. // Feedback: http://www.game7000.com/
  6. //------------------------------------------------------------
  7. using GameFramework.ObjectPool;
  8. using System.Collections.Generic;
  9. namespace GameFramework.Entity
  10. {
  11. internal sealed partial class EntityManager : GameFrameworkModule, IEntityManager
  12. {
  13. /// <summary>
  14. /// 实体组。
  15. /// </summary>
  16. private sealed class EntityGroup : IEntityGroup
  17. {
  18. private readonly string m_Name;
  19. private readonly IEntityGroupHelper m_EntityGroupHelper;
  20. private readonly IObjectPool<EntityInstanceObject> m_InstancePool;
  21. private readonly GameFrameworkLinkedList<IEntity> m_Entities;
  22. private LinkedListNode<IEntity> m_CachedNode;
  23. /// <summary>
  24. /// 初始化实体组的新实例。
  25. /// </summary>
  26. /// <param name="name">实体组名称。</param>
  27. /// <param name="instanceAutoReleaseInterval">实体实例对象池自动释放可释放对象的间隔秒数。</param>
  28. /// <param name="instanceCapacity">实体实例对象池容量。</param>
  29. /// <param name="instanceExpireTime">实体实例对象池对象过期秒数。</param>
  30. /// <param name="instancePriority">实体实例对象池的优先级。</param>
  31. /// <param name="entityGroupHelper">实体组辅助器。</param>
  32. /// <param name="objectPoolManager">对象池管理器。</param>
  33. public EntityGroup(string name, float instanceAutoReleaseInterval, int instanceCapacity, float instanceExpireTime, int instancePriority, IEntityGroupHelper entityGroupHelper, IObjectPoolManager objectPoolManager)
  34. {
  35. if (string.IsNullOrEmpty(name))
  36. {
  37. throw new GameFrameworkException("Entity group name is invalid.");
  38. }
  39. if (entityGroupHelper == null)
  40. {
  41. throw new GameFrameworkException("Entity group helper is invalid.");
  42. }
  43. m_Name = name;
  44. m_EntityGroupHelper = entityGroupHelper;
  45. m_InstancePool = objectPoolManager.CreateSingleSpawnObjectPool<EntityInstanceObject>(Utility.Text.Format("Entity Instance Pool ({0})", name), instanceCapacity, instanceExpireTime, instancePriority);
  46. m_InstancePool.AutoReleaseInterval = instanceAutoReleaseInterval;
  47. m_Entities = new GameFrameworkLinkedList<IEntity>();
  48. m_CachedNode = null;
  49. }
  50. /// <summary>
  51. /// 获取实体组名称。
  52. /// </summary>
  53. public string Name
  54. {
  55. get
  56. {
  57. return m_Name;
  58. }
  59. }
  60. /// <summary>
  61. /// 获取实体组中实体数量。
  62. /// </summary>
  63. public int EntityCount
  64. {
  65. get
  66. {
  67. return m_Entities.Count;
  68. }
  69. }
  70. /// <summary>
  71. /// 获取或设置实体组实例对象池自动释放可释放对象的间隔秒数。
  72. /// </summary>
  73. public float InstanceAutoReleaseInterval
  74. {
  75. get
  76. {
  77. return m_InstancePool.AutoReleaseInterval;
  78. }
  79. set
  80. {
  81. m_InstancePool.AutoReleaseInterval = value;
  82. }
  83. }
  84. /// <summary>
  85. /// 获取或设置实体组实例对象池的容量。
  86. /// </summary>
  87. public int InstanceCapacity
  88. {
  89. get
  90. {
  91. return m_InstancePool.Capacity;
  92. }
  93. set
  94. {
  95. m_InstancePool.Capacity = value;
  96. }
  97. }
  98. /// <summary>
  99. /// 获取或设置实体组实例对象池对象过期秒数。
  100. /// </summary>
  101. public float InstanceExpireTime
  102. {
  103. get
  104. {
  105. return m_InstancePool.ExpireTime;
  106. }
  107. set
  108. {
  109. m_InstancePool.ExpireTime = value;
  110. }
  111. }
  112. /// <summary>
  113. /// 获取或设置实体组实例对象池的优先级。
  114. /// </summary>
  115. public int InstancePriority
  116. {
  117. get
  118. {
  119. return m_InstancePool.Priority;
  120. }
  121. set
  122. {
  123. m_InstancePool.Priority = value;
  124. }
  125. }
  126. /// <summary>
  127. /// 获取实体组辅助器。
  128. /// </summary>
  129. public IEntityGroupHelper Helper
  130. {
  131. get
  132. {
  133. return m_EntityGroupHelper;
  134. }
  135. }
  136. /// <summary>
  137. /// 实体组轮询。
  138. /// </summary>
  139. /// <param name="elapseSeconds">逻辑流逝时间,以秒为单位。</param>
  140. /// <param name="realElapseSeconds">真实流逝时间,以秒为单位。</param>
  141. public void Update(float elapseSeconds, float realElapseSeconds)
  142. {
  143. LinkedListNode<IEntity> current = m_Entities.First;
  144. while (current != null)
  145. {
  146. m_CachedNode = current.Next;
  147. current.Value.OnUpdate(elapseSeconds, realElapseSeconds);
  148. current = m_CachedNode;
  149. m_CachedNode = null;
  150. }
  151. }
  152. /// <summary>
  153. /// 实体组中是否存在实体。
  154. /// </summary>
  155. /// <param name="entityId">实体序列编号。</param>
  156. /// <returns>实体组中是否存在实体。</returns>
  157. public bool HasEntity(int entityId)
  158. {
  159. foreach (IEntity entity in m_Entities)
  160. {
  161. if (entity.Id == entityId)
  162. {
  163. return true;
  164. }
  165. }
  166. return false;
  167. }
  168. /// <summary>
  169. /// 实体组中是否存在实体。
  170. /// </summary>
  171. /// <param name="entityAssetName">实体资源名称。</param>
  172. /// <returns>实体组中是否存在实体。</returns>
  173. public bool HasEntity(string entityAssetName)
  174. {
  175. if (string.IsNullOrEmpty(entityAssetName))
  176. {
  177. throw new GameFrameworkException("Entity asset name is invalid.");
  178. }
  179. foreach (IEntity entity in m_Entities)
  180. {
  181. if (entity.EntityAssetName == entityAssetName)
  182. {
  183. return true;
  184. }
  185. }
  186. return false;
  187. }
  188. /// <summary>
  189. /// 从实体组中获取实体。
  190. /// </summary>
  191. /// <param name="entityId">实体序列编号。</param>
  192. /// <returns>要获取的实体。</returns>
  193. public IEntity GetEntity(int entityId)
  194. {
  195. foreach (IEntity entity in m_Entities)
  196. {
  197. if (entity.Id == entityId)
  198. {
  199. return entity;
  200. }
  201. }
  202. return null;
  203. }
  204. /// <summary>
  205. /// 从实体组中获取实体。
  206. /// </summary>
  207. /// <param name="entityAssetName">实体资源名称。</param>
  208. /// <returns>要获取的实体。</returns>
  209. public IEntity GetEntity(string entityAssetName)
  210. {
  211. if (string.IsNullOrEmpty(entityAssetName))
  212. {
  213. throw new GameFrameworkException("Entity asset name is invalid.");
  214. }
  215. foreach (IEntity entity in m_Entities)
  216. {
  217. if (entity.EntityAssetName == entityAssetName)
  218. {
  219. return entity;
  220. }
  221. }
  222. return null;
  223. }
  224. /// <summary>
  225. /// 从实体组中获取实体。
  226. /// </summary>
  227. /// <param name="entityAssetName">实体资源名称。</param>
  228. /// <returns>要获取的实体。</returns>
  229. public IEntity[] GetEntities(string entityAssetName)
  230. {
  231. if (string.IsNullOrEmpty(entityAssetName))
  232. {
  233. throw new GameFrameworkException("Entity asset name is invalid.");
  234. }
  235. List<IEntity> results = new List<IEntity>();
  236. foreach (IEntity entity in m_Entities)
  237. {
  238. if (entity.EntityAssetName == entityAssetName)
  239. {
  240. results.Add(entity);
  241. }
  242. }
  243. return results.ToArray();
  244. }
  245. /// <summary>
  246. /// 从实体组中获取实体。
  247. /// </summary>
  248. /// <param name="entityAssetName">实体资源名称。</param>
  249. /// <param name="results">要获取的实体。</param>
  250. public void GetEntities(string entityAssetName, List<IEntity> results)
  251. {
  252. if (string.IsNullOrEmpty(entityAssetName))
  253. {
  254. throw new GameFrameworkException("Entity asset name is invalid.");
  255. }
  256. if (results == null)
  257. {
  258. throw new GameFrameworkException("Results is invalid.");
  259. }
  260. results.Clear();
  261. foreach (IEntity entity in m_Entities)
  262. {
  263. if (entity.EntityAssetName == entityAssetName)
  264. {
  265. results.Add(entity);
  266. }
  267. }
  268. }
  269. /// <summary>
  270. /// 从实体组中获取所有实体。
  271. /// </summary>
  272. /// <returns>实体组中的所有实体。</returns>
  273. public IEntity[] GetAllEntities()
  274. {
  275. List<IEntity> results = new List<IEntity>();
  276. foreach (IEntity entity in m_Entities)
  277. {
  278. results.Add(entity);
  279. }
  280. return results.ToArray();
  281. }
  282. /// <summary>
  283. /// 从实体组中获取所有实体。
  284. /// </summary>
  285. /// <param name="results">实体组中的所有实体。</param>
  286. public void GetAllEntities(List<IEntity> results)
  287. {
  288. if (results == null)
  289. {
  290. throw new GameFrameworkException("Results is invalid.");
  291. }
  292. results.Clear();
  293. foreach (IEntity entity in m_Entities)
  294. {
  295. results.Add(entity);
  296. }
  297. }
  298. /// <summary>
  299. /// 往实体组增加实体。
  300. /// </summary>
  301. /// <param name="entity">要增加的实体。</param>
  302. public void AddEntity(IEntity entity)
  303. {
  304. m_Entities.AddLast(entity);
  305. }
  306. /// <summary>
  307. /// 从实体组移除实体。
  308. /// </summary>
  309. /// <param name="entity">要移除的实体。</param>
  310. public void RemoveEntity(IEntity entity)
  311. {
  312. if (m_CachedNode != null && m_CachedNode.Value == entity)
  313. {
  314. m_CachedNode = m_CachedNode.Next;
  315. }
  316. if (!m_Entities.Remove(entity))
  317. {
  318. throw new GameFrameworkException(Utility.Text.Format("Entity group '{0}' not exists specified entity '[{1}]{2}'.", m_Name, entity.Id, entity.EntityAssetName));
  319. }
  320. }
  321. public void RegisterEntityInstanceObject(EntityInstanceObject obj, bool spawned)
  322. {
  323. m_InstancePool.Register(obj, spawned);
  324. }
  325. public EntityInstanceObject SpawnEntityInstanceObject(string name)
  326. {
  327. return m_InstancePool.Spawn(name);
  328. }
  329. public void UnspawnEntity(IEntity entity)
  330. {
  331. m_InstancePool.Unspawn(entity.Handle);
  332. }
  333. public void SetEntityInstanceLocked(object entityInstance, bool locked)
  334. {
  335. if (entityInstance == null)
  336. {
  337. throw new GameFrameworkException("Entity instance is invalid.");
  338. }
  339. m_InstancePool.SetLocked(entityInstance, locked);
  340. }
  341. public void SetEntityInstancePriority(object entityInstance, int priority)
  342. {
  343. if (entityInstance == null)
  344. {
  345. throw new GameFrameworkException("Entity instance is invalid.");
  346. }
  347. m_InstancePool.SetPriority(entityInstance, priority);
  348. }
  349. }
  350. }
  351. }