API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Jan 22nd, 2020
100
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C# 161.52 KB | None | 0 0
raw download clone embed print report
  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;
  5. using System.Reflection;
  6. namespace scare2D {
  7.     public sealed class EntityWorld : IEntityWorld {
  8.         public EntityManager Entities { get; set; }
  9.         public ComponentManager Components => Entities.Components;
  10.         public Microsoft.Xna.Framework.Graphics.SpriteBatch _Microsoft_dot_Xna_dot_Framework_dot_Graphics_dot_SpriteBatch_null;
  11.         public scare2D.FastSpriteBatch _scare2D_dot_FastSpriteBatch_null;
  12.         public Microsoft.Xna.Framework.Content.ContentManager _Microsoft_dot_Xna_dot_Framework_dot_Content_dot_ContentManager_null;
  13.         public Microsoft.Xna.Framework.Graphics.GraphicsDevice _Microsoft_dot_Xna_dot_Framework_dot_Graphics_dot_GraphicsDevice_null;
  14.         public scare2D.IPrimitiveBatch _scare2D_dot_IPrimitiveBatch_null;
  15.         public scare2D.Camera2D _scare2D_dot_Camera2D_null;
  16.         public System.Single _System_dot_Single_deltaTime;
  17.         public System.Single _System_dot_Single_fixedTime;
  18.         public System.Single _System_dot_Single_alpha;
  19.         public System.Single _System_dot_Single_totalTime;
  20.         public System.String _System_dot_String_player1Name;
  21.         public System.String _System_dot_String_player2Name;
  22.         public Microsoft.Xna.Framework.Color _Microsoft_dot_Xna_dot_Framework_dot_Color_null;
  23.         public Microsoft.Xna.Framework.Graphics.Texture2D _Microsoft_dot_Xna_dot_Framework_dot_Graphics_dot_Texture2D_redTexture;
  24.         public Microsoft.Xna.Framework.Graphics.SpriteFont _Microsoft_dot_Xna_dot_Framework_dot_Graphics_dot_SpriteFont_null;
  25.         public scare2D.float4 _scare2D_dot_float4_rect;
  26.         public scare2D.float2 _scare2D_dot_float2_gravity;
  27.         public bool _scare2D_dot_AutoLerpTransformBeginFixedUpdateSystem_enabled = true;
  28.         public scare2D.AutoLerpTransformBeginFixedUpdateSystem _scare2D_dot_AutoLerpTransformBeginFixedUpdateSystem_null;
  29.         public bool _scare2D_dot_AutoLerpTransformBeginDrawSystem_enabled = true;
  30.         public scare2D.AutoLerpTransformBeginDrawSystem _scare2D_dot_AutoLerpTransformBeginDrawSystem_null;
  31.         public bool _scare2D_dot_AutoSetDefaultTransformSystem_enabled = true;
  32.         public scare2D.AutoSetDefaultTransformSystem _scare2D_dot_AutoSetDefaultTransformSystem_null;
  33.         public bool _scare2D_dot_PhysicsCleanupSystem_enabled = true;
  34.         public scare2D.PhysicsCleanupSystem _scare2D_dot_PhysicsCleanupSystem_null;
  35.         public bool _scare2D_dot_BroadPhaseRendererSystem_enabled = true;
  36.         public scare2D.BroadPhaseRendererSystem _scare2D_dot_BroadPhaseRendererSystem_null;
  37.         public bool _scare2D_dot_BroadPhaseSystem_enabled = true;
  38.         public scare2D.BroadPhaseSystem _scare2D_dot_BroadPhaseSystem_null;
  39.         public bool _scare2D_dot_NarrowPhaseSystem_enabled = true;
  40.         public scare2D.NarrowPhaseSystem _scare2D_dot_NarrowPhaseSystem_null;
  41.         public bool _scare2D_dot_CollisionResponseSystem_enabled = true;
  42.         public scare2D.CollisionResponseSystem _scare2D_dot_CollisionResponseSystem_null;
  43.         public bool _scare2D_dot_RigidBody2DSystem_enabled = true;
  44.         public scare2D.RigidBody2DSystem _scare2D_dot_RigidBody2DSystem_null;
  45.         public bool _scare2D_dot_ParticleEmitterRenderer_enabled = true;
  46.         public scare2D.ParticleEmitterRenderer _scare2D_dot_ParticleEmitterRenderer_null;
  47.         public bool _scare2D_dot_SpawnerSystem_enabled = true;
  48.         public scare2D.SpawnerSystem _scare2D_dot_SpawnerSystem_null;
  49.         public bool _scare2D_dot_LifeTimeSystem_enabled = true;
  50.         public scare2D.LifeTimeSystem _scare2D_dot_LifeTimeSystem_null;
  51.         public bool _scare2D_dot_PingPongSystem_enabled = true;
  52.         public scare2D.PingPongSystem _scare2D_dot_PingPongSystem_null;
  53.         public bool _scare2D_dot_SpriteRendererSystem_enabled = true;
  54.         public scare2D.SpriteRendererSystem _scare2D_dot_SpriteRendererSystem_null;
  55.         public bool _scare2D_dot_NameRendererSystem_enabled = true;
  56.         public scare2D.NameRendererSystem _scare2D_dot_NameRendererSystem_null;
  57.         public bool _scare2D_dot_BoxColliderRendererSystem_enabled = true;
  58.         public scare2D.BoxColliderRendererSystem _scare2D_dot_BoxColliderRendererSystem_null;
  59.         public bool _scare2D_dot_TextureRotatorSystem_enabled = true;
  60.         public scare2D.TextureRotatorSystem _scare2D_dot_TextureRotatorSystem_null;
  61.         public bool _scare2D_dot_AutoLerpTransformEndFixedUpdateSystem_enabled = true;
  62.         public scare2D.AutoLerpTransformEndFixedUpdateSystem _scare2D_dot_AutoLerpTransformEndFixedUpdateSystem_null;
  63.         public bool _scare2D_dot_RigidBody2DColliderRendererSystem_enabled = true;
  64.         public scare2D.RigidBody2DColliderRendererSystem _scare2D_dot_RigidBody2DColliderRendererSystem_null;
  65.         public bool _scare2D_dot_RigidBody2DVelocityRendererSystem_enabled = true;
  66.         public scare2D.RigidBody2DVelocityRendererSystem _scare2D_dot_RigidBody2DVelocityRendererSystem_null;
  67.         public bool _scare2D_dot_Manifold2DRendererSystem_enabled = true;
  68.         public scare2D.Manifold2DRendererSystem _scare2D_dot_Manifold2DRendererSystem_null;
  69.         public EntityWorld() : this(new EntityManager()) { }
  70.         internal EntityWorld(EntityManager entities) {
  71.             Entities = entities;
  72.             _scare2D_dot_AutoLerpTransformBeginFixedUpdateSystem_null = new scare2D.AutoLerpTransformBeginFixedUpdateSystem();
  73.             typeof(scare2D.AutoLerpTransformBeginFixedUpdateSystem).GetField("addAutoLerpGroup", BindingFlags.Instance | BindingFlags.NonPublic).SetValue(_scare2D_dot_AutoLerpTransformBeginFixedUpdateSystem_null, new _scare2D_dot_AutoLerpTransformBeginFixedUpdateSystem_dot_AddAutoLerpGroup_Collection(this));
  74.             typeof(scare2D.AutoLerpTransformBeginFixedUpdateSystem).GetField("autoLerpGroup", BindingFlags.Instance | BindingFlags.NonPublic).SetValue(_scare2D_dot_AutoLerpTransformBeginFixedUpdateSystem_null, new _scare2D_dot_AutoLerpTransformBeginFixedUpdateSystem_dot_AutoLerpGroup_Collection(this));
  75.             _scare2D_dot_AutoLerpTransformBeginDrawSystem_null = new scare2D.AutoLerpTransformBeginDrawSystem();
  76.             typeof(scare2D.AutoLerpTransformBeginDrawSystem).GetField("items", BindingFlags.Instance | BindingFlags.NonPublic).SetValue(_scare2D_dot_AutoLerpTransformBeginDrawSystem_null, new _scare2D_dot_AutoLerpTransformBeginDrawSystem_dot_AutoLerpGroup_Collection(this));
  77.             _scare2D_dot_AutoSetDefaultTransformSystem_null = new scare2D.AutoSetDefaultTransformSystem();
  78.             typeof(scare2D.AutoSetDefaultTransformSystem).GetField("items", BindingFlags.Instance | BindingFlags.NonPublic).SetValue(_scare2D_dot_AutoSetDefaultTransformSystem_null, new _scare2D_dot_AutoSetDefaultTransformSystem_dot_ItemGroup_Collection(this));
  79.             _scare2D_dot_PhysicsCleanupSystem_null = new scare2D.PhysicsCleanupSystem();
  80.             typeof(scare2D.PhysicsCleanupSystem).GetField("items", BindingFlags.Instance | BindingFlags.NonPublic).SetValue(_scare2D_dot_PhysicsCleanupSystem_null, new _scare2D_dot_PhysicsCleanupSystem_dot_ItemGroup_Collection(this));
  81.             typeof(scare2D.PhysicsCleanupSystem).GetField("items2", BindingFlags.Instance | BindingFlags.NonPublic).SetValue(_scare2D_dot_PhysicsCleanupSystem_null, new _scare2D_dot_PhysicsCleanupSystem_dot_ItemGroup2_Collection(this));
  82.             _scare2D_dot_BroadPhaseRendererSystem_null = new scare2D.BroadPhaseRendererSystem();
  83.             typeof(scare2D.BroadPhaseRendererSystem).GetField("items", BindingFlags.Instance | BindingFlags.NonPublic).SetValue(_scare2D_dot_BroadPhaseRendererSystem_null, new _scare2D_dot_BroadPhaseRendererSystem_dot_ItemGroup_Collection(this));
  84.             _scare2D_dot_BroadPhaseSystem_null = new scare2D.BroadPhaseSystem();
  85.             typeof(scare2D.BroadPhaseSystem).GetField("items", BindingFlags.Instance | BindingFlags.NonPublic).SetValue(_scare2D_dot_BroadPhaseSystem_null, new _scare2D_dot_PhysicsObject_Collection(this));
  86.             _scare2D_dot_NarrowPhaseSystem_null = new scare2D.NarrowPhaseSystem();
  87.             typeof(scare2D.NarrowPhaseSystem).GetField("items", BindingFlags.Instance | BindingFlags.NonPublic).SetValue(_scare2D_dot_NarrowPhaseSystem_null, new _scare2D_dot_NarrowPhaseSystem_dot_ItemGroup_Collection(this));
  88.             _scare2D_dot_CollisionResponseSystem_null = new scare2D.CollisionResponseSystem();
  89.             typeof(scare2D.CollisionResponseSystem).GetField("items", BindingFlags.Instance | BindingFlags.NonPublic).SetValue(_scare2D_dot_CollisionResponseSystem_null, new _scare2D_dot_CollisionResponseSystem_dot_ItemGroup_Collection(this));
  90.             _scare2D_dot_RigidBody2DSystem_null = new scare2D.RigidBody2DSystem();
  91.             typeof(scare2D.RigidBody2DSystem).GetField("items", BindingFlags.Instance | BindingFlags.NonPublic).SetValue(_scare2D_dot_RigidBody2DSystem_null, new _scare2D_dot_PhysicsObject_Collection(this));
  92.             _scare2D_dot_ParticleEmitterRenderer_null = new scare2D.ParticleEmitterRenderer();
  93.             typeof(scare2D.ParticleEmitterRenderer).GetField("items", BindingFlags.Instance | BindingFlags.NonPublic).SetValue(_scare2D_dot_ParticleEmitterRenderer_null, new _scare2D_dot_ParticleEmitterRenderer_dot_ItemGroup_Collection(this));
  94.             _scare2D_dot_SpawnerSystem_null = new scare2D.SpawnerSystem();
  95.             typeof(scare2D.SpawnerSystem).GetField("items", BindingFlags.Instance | BindingFlags.NonPublic).SetValue(_scare2D_dot_SpawnerSystem_null, new _scare2D_dot_SpawnerSystem_dot_Group_Collection(this));
  96.             _scare2D_dot_LifeTimeSystem_null = new scare2D.LifeTimeSystem();
  97.             typeof(scare2D.LifeTimeSystem).GetField("items", BindingFlags.Instance | BindingFlags.NonPublic).SetValue(_scare2D_dot_LifeTimeSystem_null, new _scare2D_dot_LifeTimeSystem_dot_Group_Collection(this));
  98.             _scare2D_dot_PingPongSystem_null = new scare2D.PingPongSystem();
  99.             typeof(scare2D.PingPongSystem).GetField("items", BindingFlags.Instance | BindingFlags.NonPublic).SetValue(_scare2D_dot_PingPongSystem_null, new _scare2D_dot_PingPongSystem_dot_PingPong_Collection(this));
  100.             _scare2D_dot_SpriteRendererSystem_null = new scare2D.SpriteRendererSystem();
  101.             typeof(scare2D.SpriteRendererSystem).GetField("sprites", BindingFlags.Instance | BindingFlags.NonPublic).SetValue(_scare2D_dot_SpriteRendererSystem_null, new _scare2D_dot_SpriteRendererSystem_dot_ItemGroup_Collection(this));
  102.             typeof(scare2D.SpriteRendererSystem).GetField("items", BindingFlags.Instance | BindingFlags.NonPublic).SetValue(_scare2D_dot_SpriteRendererSystem_null, new _scare2D_dot_SpriteRendererSystem_dot_ItemGroup2_Collection(this));
  103.             _scare2D_dot_NameRendererSystem_null = new scare2D.NameRendererSystem();
  104.             typeof(scare2D.NameRendererSystem).GetField("items", BindingFlags.Instance | BindingFlags.NonPublic).SetValue(_scare2D_dot_NameRendererSystem_null, new _scare2D_dot_NameRendererSystem_dot_ItemGroup_Collection(this));
  105.             typeof(scare2D.NameRendererSystem).GetField("items2", BindingFlags.Instance | BindingFlags.NonPublic).SetValue(_scare2D_dot_NameRendererSystem_null, new _scare2D_dot_NameRendererSystem_dot_ItemGroup2_Collection(this));
  106.             typeof(scare2D.NameRendererSystem).GetField("items3", BindingFlags.Instance | BindingFlags.NonPublic).SetValue(_scare2D_dot_NameRendererSystem_null, new _scare2D_dot_NameRendererSystem_dot_ItemGroup3_Collection(this));
  107.             _scare2D_dot_BoxColliderRendererSystem_null = new scare2D.BoxColliderRendererSystem();
  108.             typeof(scare2D.BoxColliderRendererSystem).GetField("items", BindingFlags.Instance | BindingFlags.NonPublic).SetValue(_scare2D_dot_BoxColliderRendererSystem_null, new _scare2D_dot_BoxColliderRendererSystem_dot_ItemGroup_Collection(this));
  109.             _scare2D_dot_TextureRotatorSystem_null = new scare2D.TextureRotatorSystem();
  110.             typeof(scare2D.TextureRotatorSystem).GetField("items", BindingFlags.Instance | BindingFlags.NonPublic).SetValue(_scare2D_dot_TextureRotatorSystem_null, new _scare2D_dot_TextureRotatorSystem_dot_ItemGroup_Collection(this));
  111.             _scare2D_dot_AutoLerpTransformEndFixedUpdateSystem_null = new scare2D.AutoLerpTransformEndFixedUpdateSystem();
  112.             typeof(scare2D.AutoLerpTransformEndFixedUpdateSystem).GetField("autoLerpGroup", BindingFlags.Instance | BindingFlags.NonPublic).SetValue(_scare2D_dot_AutoLerpTransformEndFixedUpdateSystem_null, new _scare2D_dot_AutoLerpTransformEndFixedUpdateSystem_dot_AutoLerpGroup_Collection(this));
  113.             _scare2D_dot_RigidBody2DColliderRendererSystem_null = new scare2D.RigidBody2DColliderRendererSystem();
  114.             typeof(scare2D.RigidBody2DColliderRendererSystem).GetField("items", BindingFlags.Instance | BindingFlags.NonPublic).SetValue(_scare2D_dot_RigidBody2DColliderRendererSystem_null, new _scare2D_dot_PhysicsObject_Collection(this));
  115.             _scare2D_dot_RigidBody2DVelocityRendererSystem_null = new scare2D.RigidBody2DVelocityRendererSystem();
  116.             typeof(scare2D.RigidBody2DVelocityRendererSystem).GetField("items", BindingFlags.Instance | BindingFlags.NonPublic).SetValue(_scare2D_dot_RigidBody2DVelocityRendererSystem_null, new _scare2D_dot_RigidBody2DVelocityRendererSystem_dot_ItemGroup_Collection(this));
  117.             _scare2D_dot_Manifold2DRendererSystem_null = new scare2D.Manifold2DRendererSystem();
  118.             typeof(scare2D.Manifold2DRendererSystem).GetField("items", BindingFlags.Instance | BindingFlags.NonPublic).SetValue(_scare2D_dot_Manifold2DRendererSystem_null, new _scare2D_dot_ReadOnlyGenericGroup_scare2D_dot_Manifold2D__Collection(this));
  119.         }
  120.         static EntityWorld() {
  121.             SharedDataType.PERFORMANCE_HACK.Add(typeof(scare2D.EntityHandle), ((Func<Func<object, IEnumerable<SharedDataValue>>>)(() => {
  122.                 return o => {
  123.                     return new SharedDataValue[] {};
  124.                 };
  125.             }))());
  126.             SharedDataType.PERFORMANCE_HACK.Add(typeof(scare2D.Transform2D), ((Func<Func<object, IEnumerable<SharedDataValue>>>)(() => {
  127.                 return o => {
  128.                     return new SharedDataValue[] {};
  129.                 };
  130.             }))());
  131.             SharedDataType.PERFORMANCE_HACK.Add(typeof(scare2D.AutoLerpTransformComponent), ((Func<Func<object, IEnumerable<SharedDataValue>>>)(() => {
  132.                 return o => {
  133.                     return new SharedDataValue[] {};
  134.                 };
  135.             }))());
  136.             SharedDataType.PERFORMANCE_HACK.Add(typeof(scare2D.BroadPhasePair), ((Func<Func<object, IEnumerable<SharedDataValue>>>)(() => {
  137.                 return o => {
  138.                     return new SharedDataValue[] {};
  139.                 };
  140.             }))());
  141.             SharedDataType.PERFORMANCE_HACK.Add(typeof(scare2D.Manifold2D), ((Func<Func<object, IEnumerable<SharedDataValue>>>)(() => {
  142.                 return o => {
  143.                     return new SharedDataValue[] {};
  144.                 };
  145.             }))());
  146.             SharedDataType.PERFORMANCE_HACK.Add(typeof(scare2D.RigidBody2D), ((Func<Func<object, IEnumerable<SharedDataValue>>>)(() => {
  147.                 var CollisionMask = typeof(scare2D.RigidBody2D).GetField("CollisionMask");
  148.                 return o => {
  149.                     return new SharedDataValue[] {new SharedDataValue(CollisionMask, ((scare2D.RigidBody2D)o).CollisionMask)};
  150.                 };
  151.             }))());
  152.             SharedDataType.PERFORMANCE_HACK.Add(typeof(scare2D.Transform), ((Func<Func<object, IEnumerable<SharedDataValue>>>)(() => {
  153.                 return o => {
  154.                     return new SharedDataValue[] {};
  155.                 };
  156.             }))());
  157.             SharedDataType.PERFORMANCE_HACK.Add(typeof(scare2D.ParticleEmitter), ((Func<Func<object, IEnumerable<SharedDataValue>>>)(() => {
  158.                 var textureName = typeof(scare2D.ParticleEmitter).GetField("textureName");
  159.                 return o => {
  160.                     return new SharedDataValue[] {new SharedDataValue(textureName, ((scare2D.ParticleEmitter)o).textureName)};
  161.                 };
  162.             }))());
  163.             SharedDataType.PERFORMANCE_HACK.Add(typeof(scare2D.Spawner), ((Func<Func<object, IEnumerable<SharedDataValue>>>)(() => {
  164.                 return o => {
  165.                     return new SharedDataValue[] {};
  166.                 };
  167.             }))());
  168.             SharedDataType.PERFORMANCE_HACK.Add(typeof(scare2D.LifeTime), ((Func<Func<object, IEnumerable<SharedDataValue>>>)(() => {
  169.                 return o => {
  170.                     return new SharedDataValue[] {};
  171.                 };
  172.             }))());
  173.             SharedDataType.PERFORMANCE_HACK.Add(typeof(scare2D.BoxCollider), ((Func<Func<object, IEnumerable<SharedDataValue>>>)(() => {
  174.                 var canCollide = typeof(scare2D.BoxCollider).GetField("canCollide");
  175.                 return o => {
  176.                     return new SharedDataValue[] {new SharedDataValue(canCollide, ((scare2D.BoxCollider)o).canCollide)};
  177.                 };
  178.             }))());
  179.             SharedDataType.PERFORMANCE_HACK.Add(typeof(scare2D.PingPongComponent), ((Func<Func<object, IEnumerable<SharedDataValue>>>)(() => {
  180.                 return o => {
  181.                     return new SharedDataValue[] {};
  182.                 };
  183.             }))());
  184.             SharedDataType.PERFORMANCE_HACK.Add(typeof(scare2D.SpriteRenderer), ((Func<Func<object, IEnumerable<SharedDataValue>>>)(() => {
  185.                 var textureName = typeof(scare2D.SpriteRenderer).GetField("textureName");
  186.                 return o => {
  187.                     return new SharedDataValue[] {new SharedDataValue(textureName, ((scare2D.SpriteRenderer)o).textureName)};
  188.                 };
  189.             }))());
  190.             SharedDataType.PERFORMANCE_HACK.Add(typeof(scare2D.EntityName), ((Func<Func<object, IEnumerable<SharedDataValue>>>)(() => {
  191.                 return o => {
  192.                     return new SharedDataValue[] {};
  193.                 };
  194.             }))());
  195.             SharedDataType.PERFORMANCE_HACK.Add(typeof(scare2D.TextureRotator), ((Func<Func<object, IEnumerable<SharedDataValue>>>)(() => {
  196.                 return o => {
  197.                     return new SharedDataValue[] {};
  198.                 };
  199.             }))());
  200.         }
  201.         public void SetSystemState<T>(T value) {
  202.             if(value is Microsoft.Xna.Framework.Graphics.SpriteBatch @_Microsoft_dot_Xna_dot_Framework_dot_Graphics_dot_SpriteBatch_local) {
  203.                 _Microsoft_dot_Xna_dot_Framework_dot_Graphics_dot_SpriteBatch_null = @_Microsoft_dot_Xna_dot_Framework_dot_Graphics_dot_SpriteBatch_local;
  204.             }
  205.             else if(value is scare2D.FastSpriteBatch @_scare2D_dot_FastSpriteBatch_local) {
  206.                 _scare2D_dot_FastSpriteBatch_null = @_scare2D_dot_FastSpriteBatch_local;
  207.             }
  208.             else if(value is Microsoft.Xna.Framework.Content.ContentManager @_Microsoft_dot_Xna_dot_Framework_dot_Content_dot_ContentManager_local) {
  209.                 _Microsoft_dot_Xna_dot_Framework_dot_Content_dot_ContentManager_null = @_Microsoft_dot_Xna_dot_Framework_dot_Content_dot_ContentManager_local;
  210.             }
  211.             else if(value is Microsoft.Xna.Framework.Graphics.GraphicsDevice @_Microsoft_dot_Xna_dot_Framework_dot_Graphics_dot_GraphicsDevice_local) {
  212.                 _Microsoft_dot_Xna_dot_Framework_dot_Graphics_dot_GraphicsDevice_null = @_Microsoft_dot_Xna_dot_Framework_dot_Graphics_dot_GraphicsDevice_local;
  213.             }
  214.             else if(value is scare2D.IPrimitiveBatch @_scare2D_dot_IPrimitiveBatch_local) {
  215.                 _scare2D_dot_IPrimitiveBatch_null = @_scare2D_dot_IPrimitiveBatch_local;
  216.             }
  217.             else if(value is scare2D.Camera2D @_scare2D_dot_Camera2D_local) {
  218.                 _scare2D_dot_Camera2D_null = @_scare2D_dot_Camera2D_local;
  219.             }
  220.             else if(value is Microsoft.Xna.Framework.Color @_Microsoft_dot_Xna_dot_Framework_dot_Color_local) {
  221.                 _Microsoft_dot_Xna_dot_Framework_dot_Color_null = @_Microsoft_dot_Xna_dot_Framework_dot_Color_local;
  222.             }
  223.             else if(value is Microsoft.Xna.Framework.Graphics.SpriteFont @_Microsoft_dot_Xna_dot_Framework_dot_Graphics_dot_SpriteFont_local) {
  224.                 _Microsoft_dot_Xna_dot_Framework_dot_Graphics_dot_SpriteFont_null = @_Microsoft_dot_Xna_dot_Framework_dot_Graphics_dot_SpriteFont_local;
  225.             }
  226.         }
  227.         public void SetSystemState<T>(string name, T value) {
  228.             if(value is System.Single @_System_dot_Single_local) {
  229.                 if(name == "deltaTime") {
  230.                     _System_dot_Single_deltaTime = @_System_dot_Single_local;
  231.                 }
  232.                 else if(name == "fixedTime") {
  233.                     _System_dot_Single_fixedTime = @_System_dot_Single_local;
  234.                 }
  235.                 else if(name == "alpha") {
  236.                     _System_dot_Single_alpha = @_System_dot_Single_local;
  237.                 }
  238.                 else if(name == "totalTime") {
  239.                     _System_dot_Single_totalTime = @_System_dot_Single_local;
  240.                 }
  241.             }
  242.             else if(value is System.String @_System_dot_String_local) {
  243.                 if(name == "player1Name") {
  244.                     _System_dot_String_player1Name = @_System_dot_String_local;
  245.                 }
  246.                 else if(name == "player2Name") {
  247.                     _System_dot_String_player2Name = @_System_dot_String_local;
  248.                 }
  249.             }
  250.             else if(value is Microsoft.Xna.Framework.Graphics.Texture2D @_Microsoft_dot_Xna_dot_Framework_dot_Graphics_dot_Texture2D_local) {
  251.                 if(name == "redTexture") {
  252.                     _Microsoft_dot_Xna_dot_Framework_dot_Graphics_dot_Texture2D_redTexture = @_Microsoft_dot_Xna_dot_Framework_dot_Graphics_dot_Texture2D_local;
  253.                 }
  254.             }
  255.             else if(value is scare2D.float4 @_scare2D_dot_float4_local) {
  256.                 if(name == "rect") {
  257.                     _scare2D_dot_float4_rect = @_scare2D_dot_float4_local;
  258.                 }
  259.             }
  260.             else if(value is scare2D.float2 @_scare2D_dot_float2_local) {
  261.                 if(name == "gravity") {
  262.                     _scare2D_dot_float2_gravity = @_scare2D_dot_float2_local;
  263.                 }
  264.             }
  265.         }
  266.         public void SetSystemEnabled<T>(bool enabled) {
  267.             if(typeof(T) == typeof(scare2D.AutoLerpTransformBeginFixedUpdateSystem)) {
  268.                 _scare2D_dot_AutoLerpTransformBeginFixedUpdateSystem_enabled = enabled;
  269.                 return;
  270.             }
  271.             if(typeof(T) == typeof(scare2D.AutoLerpTransformBeginDrawSystem)) {
  272.                 _scare2D_dot_AutoLerpTransformBeginDrawSystem_enabled = enabled;
  273.                 return;
  274.             }
  275.             if(typeof(T) == typeof(scare2D.AutoSetDefaultTransformSystem)) {
  276.                 _scare2D_dot_AutoSetDefaultTransformSystem_enabled = enabled;
  277.                 return;
  278.             }
  279.             if(typeof(T) == typeof(scare2D.PhysicsCleanupSystem)) {
  280.                 _scare2D_dot_PhysicsCleanupSystem_enabled = enabled;
  281.                 return;
  282.             }
  283.             if(typeof(T) == typeof(scare2D.BroadPhaseRendererSystem)) {
  284.                 _scare2D_dot_BroadPhaseRendererSystem_enabled = enabled;
  285.                 return;
  286.             }
  287.             if(typeof(T) == typeof(scare2D.BroadPhaseSystem)) {
  288.                 _scare2D_dot_BroadPhaseSystem_enabled = enabled;
  289.                 return;
  290.             }
  291.             if(typeof(T) == typeof(scare2D.NarrowPhaseSystem)) {
  292.                 _scare2D_dot_NarrowPhaseSystem_enabled = enabled;
  293.                 return;
  294.             }
  295.             if(typeof(T) == typeof(scare2D.CollisionResponseSystem)) {
  296.                 _scare2D_dot_CollisionResponseSystem_enabled = enabled;
  297.                 return;
  298.             }
  299.             if(typeof(T) == typeof(scare2D.RigidBody2DSystem)) {
  300.                 _scare2D_dot_RigidBody2DSystem_enabled = enabled;
  301.                 return;
  302.             }
  303.             if(typeof(T) == typeof(scare2D.ParticleEmitterRenderer)) {
  304.                 _scare2D_dot_ParticleEmitterRenderer_enabled = enabled;
  305.                 return;
  306.             }
  307.             if(typeof(T) == typeof(scare2D.SpawnerSystem)) {
  308.                 _scare2D_dot_SpawnerSystem_enabled = enabled;
  309.                 return;
  310.             }
  311.             if(typeof(T) == typeof(scare2D.LifeTimeSystem)) {
  312.                 _scare2D_dot_LifeTimeSystem_enabled = enabled;
  313.                 return;
  314.             }
  315.             if(typeof(T) == typeof(scare2D.PingPongSystem)) {
  316.                 _scare2D_dot_PingPongSystem_enabled = enabled;
  317.                 return;
  318.             }
  319.             if(typeof(T) == typeof(scare2D.SpriteRendererSystem)) {
  320.                 _scare2D_dot_SpriteRendererSystem_enabled = enabled;
  321.                 return;
  322.             }
  323.             if(typeof(T) == typeof(scare2D.NameRendererSystem)) {
  324.                 _scare2D_dot_NameRendererSystem_enabled = enabled;
  325.                 return;
  326.             }
  327.             if(typeof(T) == typeof(scare2D.BoxColliderRendererSystem)) {
  328.                 _scare2D_dot_BoxColliderRendererSystem_enabled = enabled;
  329.                 return;
  330.             }
  331.             if(typeof(T) == typeof(scare2D.TextureRotatorSystem)) {
  332.                 _scare2D_dot_TextureRotatorSystem_enabled = enabled;
  333.                 return;
  334.             }
  335.             if(typeof(T) == typeof(scare2D.AutoLerpTransformEndFixedUpdateSystem)) {
  336.                 _scare2D_dot_AutoLerpTransformEndFixedUpdateSystem_enabled = enabled;
  337.                 return;
  338.             }
  339.             if(typeof(T) == typeof(scare2D.RigidBody2DColliderRendererSystem)) {
  340.                 _scare2D_dot_RigidBody2DColliderRendererSystem_enabled = enabled;
  341.                 return;
  342.             }
  343.             if(typeof(T) == typeof(scare2D.RigidBody2DVelocityRendererSystem)) {
  344.                 _scare2D_dot_RigidBody2DVelocityRendererSystem_enabled = enabled;
  345.                 return;
  346.             }
  347.             if(typeof(T) == typeof(scare2D.Manifold2DRendererSystem)) {
  348.                 _scare2D_dot_Manifold2DRendererSystem_enabled = enabled;
  349.                 return;
  350.             }
  351.         }
  352.         public bool GetSystemEnabled<T>() {
  353.             if(typeof(T) == typeof(scare2D.AutoLerpTransformBeginFixedUpdateSystem)) {
  354.                 return _scare2D_dot_AutoLerpTransformBeginFixedUpdateSystem_enabled;
  355.             }
  356.             if(typeof(T) == typeof(scare2D.AutoLerpTransformBeginDrawSystem)) {
  357.                 return _scare2D_dot_AutoLerpTransformBeginDrawSystem_enabled;
  358.             }
  359.             if(typeof(T) == typeof(scare2D.AutoSetDefaultTransformSystem)) {
  360.                 return _scare2D_dot_AutoSetDefaultTransformSystem_enabled;
  361.             }
  362.             if(typeof(T) == typeof(scare2D.PhysicsCleanupSystem)) {
  363.                 return _scare2D_dot_PhysicsCleanupSystem_enabled;
  364.             }
  365.             if(typeof(T) == typeof(scare2D.BroadPhaseRendererSystem)) {
  366.                 return _scare2D_dot_BroadPhaseRendererSystem_enabled;
  367.             }
  368.             if(typeof(T) == typeof(scare2D.BroadPhaseSystem)) {
  369.                 return _scare2D_dot_BroadPhaseSystem_enabled;
  370.             }
  371.             if(typeof(T) == typeof(scare2D.NarrowPhaseSystem)) {
  372.                 return _scare2D_dot_NarrowPhaseSystem_enabled;
  373.             }
  374.             if(typeof(T) == typeof(scare2D.CollisionResponseSystem)) {
  375.                 return _scare2D_dot_CollisionResponseSystem_enabled;
  376.             }
  377.             if(typeof(T) == typeof(scare2D.RigidBody2DSystem)) {
  378.                 return _scare2D_dot_RigidBody2DSystem_enabled;
  379.             }
  380.             if(typeof(T) == typeof(scare2D.ParticleEmitterRenderer)) {
  381.                 return _scare2D_dot_ParticleEmitterRenderer_enabled;
  382.             }
  383.             if(typeof(T) == typeof(scare2D.SpawnerSystem)) {
  384.                 return _scare2D_dot_SpawnerSystem_enabled;
  385.             }
  386.             if(typeof(T) == typeof(scare2D.LifeTimeSystem)) {
  387.                 return _scare2D_dot_LifeTimeSystem_enabled;
  388.             }
  389.             if(typeof(T) == typeof(scare2D.PingPongSystem)) {
  390.                 return _scare2D_dot_PingPongSystem_enabled;
  391.             }
  392.             if(typeof(T) == typeof(scare2D.SpriteRendererSystem)) {
  393.                 return _scare2D_dot_SpriteRendererSystem_enabled;
  394.             }
  395.             if(typeof(T) == typeof(scare2D.NameRendererSystem)) {
  396.                 return _scare2D_dot_NameRendererSystem_enabled;
  397.             }
  398.             if(typeof(T) == typeof(scare2D.BoxColliderRendererSystem)) {
  399.                 return _scare2D_dot_BoxColliderRendererSystem_enabled;
  400.             }
  401.             if(typeof(T) == typeof(scare2D.TextureRotatorSystem)) {
  402.                 return _scare2D_dot_TextureRotatorSystem_enabled;
  403.             }
  404.             if(typeof(T) == typeof(scare2D.AutoLerpTransformEndFixedUpdateSystem)) {
  405.                 return _scare2D_dot_AutoLerpTransformEndFixedUpdateSystem_enabled;
  406.             }
  407.             if(typeof(T) == typeof(scare2D.RigidBody2DColliderRendererSystem)) {
  408.                 return _scare2D_dot_RigidBody2DColliderRendererSystem_enabled;
  409.             }
  410.             if(typeof(T) == typeof(scare2D.RigidBody2DVelocityRendererSystem)) {
  411.                 return _scare2D_dot_RigidBody2DVelocityRendererSystem_enabled;
  412.             }
  413.             if(typeof(T) == typeof(scare2D.Manifold2DRendererSystem)) {
  414.                 return _scare2D_dot_Manifold2DRendererSystem_enabled;
  415.             }
  416.             throw new ArgumentException();
  417.         }
  418.         public void ReadComponentGroup<T>(EntityHandle handle, T componentGroup)
  419.             where T : IComponentGroup
  420.         {
  421.             if(componentGroup is scare2D.AutoLerpTransformBeginFixedUpdateSystem.AddAutoLerpGroup _scare2D_dot_AutoLerpTransformBeginFixedUpdateSystem_dot_AddAutoLerpGroup_local) {
  422.                 _scare2D_dot_AutoLerpTransformBeginFixedUpdateSystem_dot_AddAutoLerpGroup_local.Handle = handle;
  423.                 _scare2D_dot_AutoLerpTransformBeginFixedUpdateSystem_dot_AddAutoLerpGroup_local.Transform = handle.GetComponentUnsafe<scare2D.Transform2D>();
  424.                 return;
  425.             }
  426.             else if(componentGroup is scare2D.AutoLerpTransformBeginFixedUpdateSystem.AutoLerpGroup _scare2D_dot_AutoLerpTransformBeginFixedUpdateSystem_dot_AutoLerpGroup_local) {
  427.                 _scare2D_dot_AutoLerpTransformBeginFixedUpdateSystem_dot_AutoLerpGroup_local.Transform = handle.GetComponentUnsafe<scare2D.Transform2D>();
  428.                 _scare2D_dot_AutoLerpTransformBeginFixedUpdateSystem_dot_AutoLerpGroup_local.AutoLerp = handle.GetComponentUnsafe<scare2D.AutoLerpTransformComponent>();
  429.                 return;
  430.             }
  431.             else if(componentGroup is scare2D.AutoLerpTransformBeginDrawSystem.AutoLerpGroup _scare2D_dot_AutoLerpTransformBeginDrawSystem_dot_AutoLerpGroup_local) {
  432.                 _scare2D_dot_AutoLerpTransformBeginDrawSystem_dot_AutoLerpGroup_local.Transform = handle.GetComponentUnsafe<scare2D.Transform2D>();
  433.                 _scare2D_dot_AutoLerpTransformBeginDrawSystem_dot_AutoLerpGroup_local.AutoLerp = handle.GetComponentUnsafe<scare2D.AutoLerpTransformComponent>();
  434.                 return;
  435.             }
  436.             else if(componentGroup is scare2D.AutoSetDefaultTransformSystem.ItemGroup _scare2D_dot_AutoSetDefaultTransformSystem_dot_ItemGroup_local) {
  437.                 _scare2D_dot_AutoSetDefaultTransformSystem_dot_ItemGroup_local.Transform = handle.GetComponentUnsafe<scare2D.Transform2D>();
  438.                 return;
  439.             }
  440.             else if(componentGroup is scare2D.PhysicsCleanupSystem.ItemGroup _scare2D_dot_PhysicsCleanupSystem_dot_ItemGroup_local) {
  441.                 _scare2D_dot_PhysicsCleanupSystem_dot_ItemGroup_local.Handle = handle;
  442.                 _scare2D_dot_PhysicsCleanupSystem_dot_ItemGroup_local._ = handle.GetComponentUnsafe<scare2D.BroadPhasePair>();
  443.                 return;
  444.             }
  445.             else if(componentGroup is scare2D.PhysicsCleanupSystem.ItemGroup2 _scare2D_dot_PhysicsCleanupSystem_dot_ItemGroup2_local) {
  446.                 _scare2D_dot_PhysicsCleanupSystem_dot_ItemGroup2_local.Handle = handle;
  447.                 _scare2D_dot_PhysicsCleanupSystem_dot_ItemGroup2_local._ = handle.GetComponentUnsafe<scare2D.Manifold2D>();
  448.                 return;
  449.             }
  450.             else if(componentGroup is scare2D.BroadPhaseRendererSystem.ItemGroup _scare2D_dot_BroadPhaseRendererSystem_dot_ItemGroup_local) {
  451.                 _scare2D_dot_BroadPhaseRendererSystem_dot_ItemGroup_local.Pair = handle.GetComponentUnsafe<scare2D.BroadPhasePair>();
  452.                 return;
  453.             }
  454.             else if(componentGroup is scare2D.PhysicsObject _scare2D_dot_PhysicsObject_local) {
  455.                 _scare2D_dot_PhysicsObject_local.Handle = handle;
  456.                 _scare2D_dot_PhysicsObject_local.Transform = handle.GetComponentUnsafe<scare2D.Transform2D>();
  457.                 _scare2D_dot_PhysicsObject_local.RigidBody = handle.GetComponentUnsafe<scare2D.RigidBody2D>();
  458.                 return;
  459.             }
  460.             else if(componentGroup is scare2D.NarrowPhaseSystem.ItemGroup _scare2D_dot_NarrowPhaseSystem_dot_ItemGroup_local) {
  461.                 _scare2D_dot_NarrowPhaseSystem_dot_ItemGroup_local.Pair = handle.GetComponentUnsafe<scare2D.BroadPhasePair>();
  462.                 return;
  463.             }
  464.             else if(componentGroup is scare2D.CollisionResponseSystem.ItemGroup _scare2D_dot_CollisionResponseSystem_dot_ItemGroup_local) {
  465.                 _scare2D_dot_CollisionResponseSystem_dot_ItemGroup_local.Collision = handle.GetComponentUnsafe<scare2D.Manifold2D>();
  466.                 return;
  467.             }
  468.             else if(componentGroup is scare2D.ParticleEmitterRenderer.ItemGroup _scare2D_dot_ParticleEmitterRenderer_dot_ItemGroup_local) {
  469.                 _scare2D_dot_ParticleEmitterRenderer_dot_ItemGroup_local.handle = handle;
  470.                 _scare2D_dot_ParticleEmitterRenderer_dot_ItemGroup_local.transform = handle.GetComponentUnsafe<scare2D.Transform>();
  471.                 _scare2D_dot_ParticleEmitterRenderer_dot_ItemGroup_local.emitter = handle.GetComponentUnsafe<scare2D.ParticleEmitter>();
  472.                 return;
  473.             }
  474.             else if(componentGroup is scare2D.SpawnerSystem.Group _scare2D_dot_SpawnerSystem_dot_Group_local) {
  475.                 _scare2D_dot_SpawnerSystem_dot_Group_local.transform = handle.GetComponentUnsafe<scare2D.Transform>();
  476.                 _scare2D_dot_SpawnerSystem_dot_Group_local.spawner = handle.GetComponentUnsafe<scare2D.Spawner>();
  477.                 return;
  478.             }
  479.             else if(componentGroup is scare2D.LifeTimeSystem.Group _scare2D_dot_LifeTimeSystem_dot_Group_local) {
  480.                 _scare2D_dot_LifeTimeSystem_dot_Group_local.handle = handle;
  481.                 _scare2D_dot_LifeTimeSystem_dot_Group_local.lifeTime = handle.GetComponentUnsafe<scare2D.LifeTime>();
  482.                 return;
  483.             }
  484.             else if(componentGroup is scare2D.PingPongSystem.PingPong _scare2D_dot_PingPongSystem_dot_PingPong_local) {
  485.                 _scare2D_dot_PingPongSystem_dot_PingPong_local.transform = handle.GetComponentUnsafe<scare2D.Transform>();
  486.                 _scare2D_dot_PingPongSystem_dot_PingPong_local.collider = handle.GetComponentUnsafe<scare2D.BoxCollider>();
  487.                 _scare2D_dot_PingPongSystem_dot_PingPong_local.ball = handle.GetComponentUnsafe<scare2D.PingPongComponent>();
  488.                 return;
  489.             }
  490.             else if(componentGroup is scare2D.SpriteRendererSystem.ItemGroup _scare2D_dot_SpriteRendererSystem_dot_ItemGroup_local) {
  491.                 _scare2D_dot_SpriteRendererSystem_dot_ItemGroup_local.transform = handle.GetComponentUnsafe<scare2D.Transform>();
  492.                 _scare2D_dot_SpriteRendererSystem_dot_ItemGroup_local.collider = handle.GetComponentUnsafe<scare2D.BoxCollider>();
  493.                 _scare2D_dot_SpriteRendererSystem_dot_ItemGroup_local.renderer = handle.GetComponentUnsafe<scare2D.SpriteRenderer>();
  494.                 return;
  495.             }
  496.             else if(componentGroup is scare2D.SpriteRendererSystem.ItemGroup2 _scare2D_dot_SpriteRendererSystem_dot_ItemGroup2_local) {
  497.                 _scare2D_dot_SpriteRendererSystem_dot_ItemGroup2_local.Transform = handle.GetComponentUnsafe<scare2D.Transform2D>();
  498.                 _scare2D_dot_SpriteRendererSystem_dot_ItemGroup2_local.SpriteRenderer = handle.GetComponentUnsafe<scare2D.SpriteRenderer>();
  499.                 return;
  500.             }
  501.             else if(componentGroup is scare2D.NameRendererSystem.ItemGroup _scare2D_dot_NameRendererSystem_dot_ItemGroup_local) {
  502.                 _scare2D_dot_NameRendererSystem_dot_ItemGroup_local.handle = handle;
  503.                 _scare2D_dot_NameRendererSystem_dot_ItemGroup_local.entityName = handle.GetComponentUnsafe<scare2D.EntityName>();
  504.                 _scare2D_dot_NameRendererSystem_dot_ItemGroup_local.transform = handle.GetComponentUnsafe<scare2D.Transform>();
  505.                 return;
  506.             }
  507.             else if(componentGroup is scare2D.NameRendererSystem.ItemGroup2 _scare2D_dot_NameRendererSystem_dot_ItemGroup2_local) {
  508.                 _scare2D_dot_NameRendererSystem_dot_ItemGroup2_local.handle = handle;
  509.                 _scare2D_dot_NameRendererSystem_dot_ItemGroup2_local.entityName = handle.GetComponentUnsafe<scare2D.EntityName>();
  510.                 _scare2D_dot_NameRendererSystem_dot_ItemGroup2_local.transform = handle.GetComponentUnsafe<scare2D.Transform>();
  511.                 _scare2D_dot_NameRendererSystem_dot_ItemGroup2_local.collider = handle.GetComponentUnsafe<scare2D.BoxCollider>();
  512.                 return;
  513.             }
  514.             else if(componentGroup is scare2D.NameRendererSystem.ItemGroup3 _scare2D_dot_NameRendererSystem_dot_ItemGroup3_local) {
  515.                 _scare2D_dot_NameRendererSystem_dot_ItemGroup3_local.handle = handle;
  516.                 _scare2D_dot_NameRendererSystem_dot_ItemGroup3_local.transform = handle.GetComponentUnsafe<scare2D.Transform>();
  517.                 return;
  518.             }
  519.             else if(componentGroup is scare2D.BoxColliderRendererSystem.ItemGroup _scare2D_dot_BoxColliderRendererSystem_dot_ItemGroup_local) {
  520.                 _scare2D_dot_BoxColliderRendererSystem_dot_ItemGroup_local.transform = handle.GetComponentUnsafe<scare2D.Transform>();
  521.                 _scare2D_dot_BoxColliderRendererSystem_dot_ItemGroup_local.collider = handle.GetComponentUnsafe<scare2D.BoxCollider>();
  522.                 return;
  523.             }
  524.             else if(componentGroup is scare2D.TextureRotatorSystem.ItemGroup _scare2D_dot_TextureRotatorSystem_dot_ItemGroup_local) {
  525.                 _scare2D_dot_TextureRotatorSystem_dot_ItemGroup_local.SpriteRenderer = handle.GetComponentUnsafe<scare2D.SpriteRenderer>();
  526.                 _scare2D_dot_TextureRotatorSystem_dot_ItemGroup_local.TextureRotator = handle.GetComponentUnsafe<scare2D.TextureRotator>();
  527.                 return;
  528.             }
  529.             else if(componentGroup is scare2D.AutoLerpTransformEndFixedUpdateSystem.AutoLerpGroup _scare2D_dot_AutoLerpTransformEndFixedUpdateSystem_dot_AutoLerpGroup_local) {
  530.                 _scare2D_dot_AutoLerpTransformEndFixedUpdateSystem_dot_AutoLerpGroup_local.Transform = handle.GetComponentUnsafe<scare2D.Transform2D>();
  531.                 _scare2D_dot_AutoLerpTransformEndFixedUpdateSystem_dot_AutoLerpGroup_local.AutoLerp = handle.GetComponentUnsafe<scare2D.AutoLerpTransformComponent>();
  532.                 return;
  533.             }
  534.             else if(componentGroup is scare2D.RigidBody2DVelocityRendererSystem.ItemGroup _scare2D_dot_RigidBody2DVelocityRendererSystem_dot_ItemGroup_local) {
  535.                 _scare2D_dot_RigidBody2DVelocityRendererSystem_dot_ItemGroup_local.Transform = handle.GetComponentUnsafe<scare2D.Transform2D>();
  536.                 _scare2D_dot_RigidBody2DVelocityRendererSystem_dot_ItemGroup_local.RigidBody = handle.GetComponentUnsafe<scare2D.RigidBody2D>();
  537.                 return;
  538.             }
  539.             else if(componentGroup is scare2D.ReadOnlyGenericGroup<scare2D.Manifold2D> _scare2D_dot_ReadOnlyGenericGroup_scare2D_dot_Manifold2D__local) {
  540.                 _scare2D_dot_ReadOnlyGenericGroup_scare2D_dot_Manifold2D__local.Component = handle.GetComponentUnsafe<scare2D.Manifold2D>();
  541.                 return;
  542.             }
  543.             throw new NotSupportedException();
  544.         }
  545.         public void WriteComponentGroup<T>(EntityHandle handle, T componentGroup)
  546.             where T : IComponentGroup
  547.         {
  548.             if(componentGroup is scare2D.AutoLerpTransformBeginFixedUpdateSystem.AddAutoLerpGroup _scare2D_dot_AutoLerpTransformBeginFixedUpdateSystem_dot_AddAutoLerpGroup_local) {
  549.                 handle.GetComponentUnsafe<scare2D.Transform2D>() = _scare2D_dot_AutoLerpTransformBeginFixedUpdateSystem_dot_AddAutoLerpGroup_local.Transform;
  550.                 return;
  551.             }
  552.             else if(componentGroup is scare2D.AutoLerpTransformBeginFixedUpdateSystem.AutoLerpGroup _scare2D_dot_AutoLerpTransformBeginFixedUpdateSystem_dot_AutoLerpGroup_local) {
  553.                 handle.GetComponentUnsafe<scare2D.Transform2D>() = _scare2D_dot_AutoLerpTransformBeginFixedUpdateSystem_dot_AutoLerpGroup_local.Transform;
  554.                 handle.GetComponentUnsafe<scare2D.AutoLerpTransformComponent>() = _scare2D_dot_AutoLerpTransformBeginFixedUpdateSystem_dot_AutoLerpGroup_local.AutoLerp;
  555.                 return;
  556.             }
  557.             else if(componentGroup is scare2D.AutoLerpTransformBeginDrawSystem.AutoLerpGroup _scare2D_dot_AutoLerpTransformBeginDrawSystem_dot_AutoLerpGroup_local) {
  558.                 handle.GetComponentUnsafe<scare2D.Transform2D>() = _scare2D_dot_AutoLerpTransformBeginDrawSystem_dot_AutoLerpGroup_local.Transform;
  559.                 handle.GetComponentUnsafe<scare2D.AutoLerpTransformComponent>() = _scare2D_dot_AutoLerpTransformBeginDrawSystem_dot_AutoLerpGroup_local.AutoLerp;
  560.                 return;
  561.             }
  562.             else if(componentGroup is scare2D.AutoSetDefaultTransformSystem.ItemGroup _scare2D_dot_AutoSetDefaultTransformSystem_dot_ItemGroup_local) {
  563.                 handle.GetComponentUnsafe<scare2D.Transform2D>() = _scare2D_dot_AutoSetDefaultTransformSystem_dot_ItemGroup_local.Transform;
  564.                 return;
  565.             }
  566.             else if(componentGroup is scare2D.PhysicsCleanupSystem.ItemGroup _scare2D_dot_PhysicsCleanupSystem_dot_ItemGroup_local) {
  567.                 handle.GetComponentUnsafe<scare2D.BroadPhasePair>() = _scare2D_dot_PhysicsCleanupSystem_dot_ItemGroup_local._;
  568.                 return;
  569.             }
  570.             else if(componentGroup is scare2D.PhysicsCleanupSystem.ItemGroup2 _scare2D_dot_PhysicsCleanupSystem_dot_ItemGroup2_local) {
  571.                 handle.GetComponentUnsafe<scare2D.Manifold2D>() = _scare2D_dot_PhysicsCleanupSystem_dot_ItemGroup2_local._;
  572.                 return;
  573.             }
  574.             else if(componentGroup is scare2D.BroadPhaseRendererSystem.ItemGroup _scare2D_dot_BroadPhaseRendererSystem_dot_ItemGroup_local) {
  575.                 handle.GetComponentUnsafe<scare2D.BroadPhasePair>() = _scare2D_dot_BroadPhaseRendererSystem_dot_ItemGroup_local.Pair;
  576.                 return;
  577.             }
  578.             else if(componentGroup is scare2D.PhysicsObject _scare2D_dot_PhysicsObject_local) {
  579.                 handle.GetComponentUnsafe<scare2D.Transform2D>() = _scare2D_dot_PhysicsObject_local.Transform;
  580.                 handle.GetComponentUnsafe<scare2D.RigidBody2D>() = _scare2D_dot_PhysicsObject_local.RigidBody;
  581.                 return;
  582.             }
  583.             else if(componentGroup is scare2D.NarrowPhaseSystem.ItemGroup _scare2D_dot_NarrowPhaseSystem_dot_ItemGroup_local) {
  584.                 handle.GetComponentUnsafe<scare2D.BroadPhasePair>() = _scare2D_dot_NarrowPhaseSystem_dot_ItemGroup_local.Pair;
  585.                 return;
  586.             }
  587.             else if(componentGroup is scare2D.CollisionResponseSystem.ItemGroup _scare2D_dot_CollisionResponseSystem_dot_ItemGroup_local) {
  588.                 handle.GetComponentUnsafe<scare2D.Manifold2D>() = _scare2D_dot_CollisionResponseSystem_dot_ItemGroup_local.Collision;
  589.                 return;
  590.             }
  591.             else if(componentGroup is scare2D.ParticleEmitterRenderer.ItemGroup _scare2D_dot_ParticleEmitterRenderer_dot_ItemGroup_local) {
  592.                 handle.GetComponentUnsafe<scare2D.Transform>() = _scare2D_dot_ParticleEmitterRenderer_dot_ItemGroup_local.transform;
  593.                 handle.GetComponentUnsafe<scare2D.ParticleEmitter>() = _scare2D_dot_ParticleEmitterRenderer_dot_ItemGroup_local.emitter;
  594.                 return;
  595.             }
  596.             else if(componentGroup is scare2D.SpawnerSystem.Group _scare2D_dot_SpawnerSystem_dot_Group_local) {
  597.                 handle.GetComponentUnsafe<scare2D.Transform>() = _scare2D_dot_SpawnerSystem_dot_Group_local.transform;
  598.                 handle.GetComponentUnsafe<scare2D.Spawner>() = _scare2D_dot_SpawnerSystem_dot_Group_local.spawner;
  599.                 return;
  600.             }
  601.             else if(componentGroup is scare2D.LifeTimeSystem.Group _scare2D_dot_LifeTimeSystem_dot_Group_local) {
  602.                 handle.GetComponentUnsafe<scare2D.LifeTime>() = _scare2D_dot_LifeTimeSystem_dot_Group_local.lifeTime;
  603.                 return;
  604.             }
  605.             else if(componentGroup is scare2D.PingPongSystem.PingPong _scare2D_dot_PingPongSystem_dot_PingPong_local) {
  606.                 handle.GetComponentUnsafe<scare2D.Transform>() = _scare2D_dot_PingPongSystem_dot_PingPong_local.transform;
  607.                 handle.GetComponentUnsafe<scare2D.BoxCollider>() = _scare2D_dot_PingPongSystem_dot_PingPong_local.collider;
  608.                 handle.GetComponentUnsafe<scare2D.PingPongComponent>() = _scare2D_dot_PingPongSystem_dot_PingPong_local.ball;
  609.                 return;
  610.             }
  611.             else if(componentGroup is scare2D.SpriteRendererSystem.ItemGroup _scare2D_dot_SpriteRendererSystem_dot_ItemGroup_local) {
  612.                 handle.GetComponentUnsafe<scare2D.Transform>() = _scare2D_dot_SpriteRendererSystem_dot_ItemGroup_local.transform;
  613.                 handle.GetComponentUnsafe<scare2D.BoxCollider>() = _scare2D_dot_SpriteRendererSystem_dot_ItemGroup_local.collider;
  614.                 handle.GetComponentUnsafe<scare2D.SpriteRenderer>() = _scare2D_dot_SpriteRendererSystem_dot_ItemGroup_local.renderer;
  615.                 return;
  616.             }
  617.             else if(componentGroup is scare2D.SpriteRendererSystem.ItemGroup2 _scare2D_dot_SpriteRendererSystem_dot_ItemGroup2_local) {
  618.                 handle.GetComponentUnsafe<scare2D.Transform2D>() = _scare2D_dot_SpriteRendererSystem_dot_ItemGroup2_local.Transform;
  619.                 handle.GetComponentUnsafe<scare2D.SpriteRenderer>() = _scare2D_dot_SpriteRendererSystem_dot_ItemGroup2_local.SpriteRenderer;
  620.                 return;
  621.             }
  622.             else if(componentGroup is scare2D.NameRendererSystem.ItemGroup _scare2D_dot_NameRendererSystem_dot_ItemGroup_local) {
  623.                 handle.GetComponentUnsafe<scare2D.EntityName>() = _scare2D_dot_NameRendererSystem_dot_ItemGroup_local.entityName;
  624.                 handle.GetComponentUnsafe<scare2D.Transform>() = _scare2D_dot_NameRendererSystem_dot_ItemGroup_local.transform;
  625.                 return;
  626.             }
  627.             else if(componentGroup is scare2D.NameRendererSystem.ItemGroup2 _scare2D_dot_NameRendererSystem_dot_ItemGroup2_local) {
  628.                 handle.GetComponentUnsafe<scare2D.EntityName>() = _scare2D_dot_NameRendererSystem_dot_ItemGroup2_local.entityName;
  629.                 handle.GetComponentUnsafe<scare2D.Transform>() = _scare2D_dot_NameRendererSystem_dot_ItemGroup2_local.transform;
  630.                 handle.GetComponentUnsafe<scare2D.BoxCollider>() = _scare2D_dot_NameRendererSystem_dot_ItemGroup2_local.collider;
  631.                 return;
  632.             }
  633.             else if(componentGroup is scare2D.NameRendererSystem.ItemGroup3 _scare2D_dot_NameRendererSystem_dot_ItemGroup3_local) {
  634.                 handle.GetComponentUnsafe<scare2D.Transform>() = _scare2D_dot_NameRendererSystem_dot_ItemGroup3_local.transform;
  635.                 return;
  636.             }
  637.             else if(componentGroup is scare2D.BoxColliderRendererSystem.ItemGroup _scare2D_dot_BoxColliderRendererSystem_dot_ItemGroup_local) {
  638.                 handle.GetComponentUnsafe<scare2D.Transform>() = _scare2D_dot_BoxColliderRendererSystem_dot_ItemGroup_local.transform;
  639.                 handle.GetComponentUnsafe<scare2D.BoxCollider>() = _scare2D_dot_BoxColliderRendererSystem_dot_ItemGroup_local.collider;
  640.                 return;
  641.             }
  642.             else if(componentGroup is scare2D.TextureRotatorSystem.ItemGroup _scare2D_dot_TextureRotatorSystem_dot_ItemGroup_local) {
  643.                 handle.GetComponentUnsafe<scare2D.SpriteRenderer>() = _scare2D_dot_TextureRotatorSystem_dot_ItemGroup_local.SpriteRenderer;
  644.                 handle.GetComponentUnsafe<scare2D.TextureRotator>() = _scare2D_dot_TextureRotatorSystem_dot_ItemGroup_local.TextureRotator;
  645.                 return;
  646.             }
  647.             else if(componentGroup is scare2D.AutoLerpTransformEndFixedUpdateSystem.AutoLerpGroup _scare2D_dot_AutoLerpTransformEndFixedUpdateSystem_dot_AutoLerpGroup_local) {
  648.                 handle.GetComponentUnsafe<scare2D.Transform2D>() = _scare2D_dot_AutoLerpTransformEndFixedUpdateSystem_dot_AutoLerpGroup_local.Transform;
  649.                 handle.GetComponentUnsafe<scare2D.AutoLerpTransformComponent>() = _scare2D_dot_AutoLerpTransformEndFixedUpdateSystem_dot_AutoLerpGroup_local.AutoLerp;
  650.                 return;
  651.             }
  652.             else if(componentGroup is scare2D.RigidBody2DVelocityRendererSystem.ItemGroup _scare2D_dot_RigidBody2DVelocityRendererSystem_dot_ItemGroup_local) {
  653.                 handle.GetComponentUnsafe<scare2D.Transform2D>() = _scare2D_dot_RigidBody2DVelocityRendererSystem_dot_ItemGroup_local.Transform;
  654.                 handle.GetComponentUnsafe<scare2D.RigidBody2D>() = _scare2D_dot_RigidBody2DVelocityRendererSystem_dot_ItemGroup_local.RigidBody;
  655.                 return;
  656.             }
  657.             else if(componentGroup is scare2D.ReadOnlyGenericGroup<scare2D.Manifold2D> _scare2D_dot_ReadOnlyGenericGroup_scare2D_dot_Manifold2D__local) {
  658.                 handle.GetComponentUnsafe<scare2D.Manifold2D>() = _scare2D_dot_ReadOnlyGenericGroup_scare2D_dot_Manifold2D__local.Component;
  659.                 return;
  660.             }
  661.             throw new NotSupportedException();
  662.         }
  663.         public void FixedUpdate() {
  664.             if(_scare2D_dot_AutoLerpTransformBeginFixedUpdateSystem_enabled) {
  665.                 _scare2D_dot_AutoLerpTransformBeginFixedUpdateSystem_null.FixedUpdate();
  666.             }
  667.             if(_scare2D_dot_AutoSetDefaultTransformSystem_enabled) {
  668.                 _scare2D_dot_AutoSetDefaultTransformSystem_null.FixedUpdate();
  669.             }
  670.             if(_scare2D_dot_PhysicsCleanupSystem_enabled) {
  671.                 _scare2D_dot_PhysicsCleanupSystem_null.FixedUpdate();
  672.             }
  673.             if(_scare2D_dot_BroadPhaseSystem_enabled) {
  674.                 _scare2D_dot_BroadPhaseSystem_null.FixedUpdate();
  675.             }
  676.             if(_scare2D_dot_NarrowPhaseSystem_enabled) {
  677.                 _scare2D_dot_NarrowPhaseSystem_null.FixedUpdate();
  678.             }
  679.             if(_scare2D_dot_CollisionResponseSystem_enabled) {
  680.                 _scare2D_dot_CollisionResponseSystem_null.FixedUpdate();
  681.             }
  682.             if(_scare2D_dot_RigidBody2DSystem_enabled) {
  683.                 _scare2D_dot_RigidBody2DSystem_null.FixedUpdate(_System_dot_Single_fixedTime, _scare2D_dot_float2_gravity);
  684.             }
  685.             if(_scare2D_dot_AutoLerpTransformEndFixedUpdateSystem_enabled) {
  686.                 _scare2D_dot_AutoLerpTransformEndFixedUpdateSystem_null.FixedUpdate();
  687.             }
  688.         }
  689.         public void Update() {
  690.             if(_scare2D_dot_AutoSetDefaultTransformSystem_enabled) {
  691.                 _scare2D_dot_AutoSetDefaultTransformSystem_null.Update();
  692.             }
  693.             if(_scare2D_dot_ParticleEmitterRenderer_enabled) {
  694.                 _scare2D_dot_ParticleEmitterRenderer_null.Update(_System_dot_Single_deltaTime, _Microsoft_dot_Xna_dot_Framework_dot_Graphics_dot_GraphicsDevice_null);
  695.             }
  696.             if(_scare2D_dot_SpawnerSystem_enabled) {
  697.                 _scare2D_dot_SpawnerSystem_null.Update(_System_dot_Single_deltaTime);
  698.             }
  699.             if(_scare2D_dot_LifeTimeSystem_enabled) {
  700.                 _scare2D_dot_LifeTimeSystem_null.Update(_System_dot_Single_deltaTime);
  701.             }
  702.             if(_scare2D_dot_PingPongSystem_enabled) {
  703.                 _scare2D_dot_PingPongSystem_null.Update(_scare2D_dot_float4_rect, _System_dot_Single_deltaTime);
  704.             }
  705.             if(_scare2D_dot_TextureRotatorSystem_enabled) {
  706.                 _scare2D_dot_TextureRotatorSystem_null.Update(_System_dot_Single_deltaTime);
  707.             }
  708.         }
  709.         public void Draw() {
  710.             if(_scare2D_dot_AutoLerpTransformBeginDrawSystem_enabled) {
  711.                 _scare2D_dot_AutoLerpTransformBeginDrawSystem_null.Draw(_System_dot_Single_alpha);
  712.             }
  713.             if(_scare2D_dot_BroadPhaseRendererSystem_enabled) {
  714.                 _scare2D_dot_BroadPhaseRendererSystem_null.Draw(_scare2D_dot_IPrimitiveBatch_null, _scare2D_dot_Camera2D_null);
  715.             }
  716.             if(_scare2D_dot_ParticleEmitterRenderer_enabled) {
  717.                 _scare2D_dot_ParticleEmitterRenderer_null.Draw(_Microsoft_dot_Xna_dot_Framework_dot_Graphics_dot_GraphicsDevice_null, _scare2D_dot_Camera2D_null);
  718.             }
  719.             if(_scare2D_dot_SpriteRendererSystem_enabled) {
  720.                 _scare2D_dot_SpriteRendererSystem_null.Draw(_Microsoft_dot_Xna_dot_Framework_dot_Graphics_dot_SpriteBatch_null, _scare2D_dot_Camera2D_null);
  721.             }
  722.             if(_scare2D_dot_NameRendererSystem_enabled) {
  723.                 _scare2D_dot_NameRendererSystem_null.Draw(_Microsoft_dot_Xna_dot_Framework_dot_Graphics_dot_SpriteBatch_null, _Microsoft_dot_Xna_dot_Framework_dot_Graphics_dot_SpriteFont_null, _scare2D_dot_Camera2D_null);
  724.             }
  725.             if(_scare2D_dot_BoxColliderRendererSystem_enabled) {
  726.                 _scare2D_dot_BoxColliderRendererSystem_null.Draw(_scare2D_dot_IPrimitiveBatch_null, _scare2D_dot_Camera2D_null);
  727.             }
  728.             if(_scare2D_dot_RigidBody2DColliderRendererSystem_enabled) {
  729.                 _scare2D_dot_RigidBody2DColliderRendererSystem_null.Draw(_scare2D_dot_IPrimitiveBatch_null, _scare2D_dot_Camera2D_null);
  730.             }
  731.             if(_scare2D_dot_RigidBody2DVelocityRendererSystem_enabled) {
  732.                 _scare2D_dot_RigidBody2DVelocityRendererSystem_null.Draw(_scare2D_dot_IPrimitiveBatch_null, _scare2D_dot_Camera2D_null, _System_dot_Single_fixedTime);
  733.             }
  734.             if(_scare2D_dot_Manifold2DRendererSystem_enabled) {
  735.                 _scare2D_dot_Manifold2DRendererSystem_null.Draw(_scare2D_dot_IPrimitiveBatch_null, _scare2D_dot_Camera2D_null);
  736.             }
  737.         }
  738.     }
  739.     public sealed class _scare2D_dot_AutoLerpTransformBeginFixedUpdateSystem_dot_AddAutoLerpGroup_Collection : IComponentCollection<scare2D.AutoLerpTransformBeginFixedUpdateSystem.AddAutoLerpGroup> {
  740.         public sealed class _scare2D_dot_AutoLerpTransformBeginFixedUpdateSystem_dot_AddAutoLerpGroup_Enumerator : IRefEnumerator<scare2D.AutoLerpTransformBeginFixedUpdateSystem.AddAutoLerpGroup> {
  741.             private _scare2D_dot_AutoLerpTransformBeginFixedUpdateSystem_dot_AddAutoLerpGroup_Collection collection;
  742.             private scare2D.AutoLerpTransformBeginFixedUpdateSystem.AddAutoLerpGroup currentValue = new scare2D.AutoLerpTransformBeginFixedUpdateSystem.AddAutoLerpGroup();
  743.             private IEnumerator<bool> moveNextEnumerator;
  744.             public _scare2D_dot_AutoLerpTransformBeginFixedUpdateSystem_dot_AddAutoLerpGroup_Enumerator(_scare2D_dot_AutoLerpTransformBeginFixedUpdateSystem_dot_AddAutoLerpGroup_Collection collection) {
  745.                 this.collection = collection;
  746.             }
  747.             public ref scare2D.AutoLerpTransformBeginFixedUpdateSystem.AddAutoLerpGroup Current => ref currentValue;
  748.             public bool MoveNext() {
  749.                 if(moveNextEnumerator == null) {
  750.                     moveNextEnumerator = MoveNextInternal();
  751.                 }
  752.                 return moveNextEnumerator.MoveNext();
  753.             }
  754.             public IEnumerator<bool> MoveNextInternal() {
  755.                 foreach(var setType in collection.EntityWorld.Entities.Components) {
  756.                     bool keepSetType = setType.TypeSet.IsSupersetOf(collection.Includes) && setType.TypeSet.GetIntersection(collection.Excludes).IsEmpty;
  757.                     if(keepSetType == false) continue;
  758.                     foreach(var set in setType) {
  759.                         var refList__scare2D_dot_EntityHandle_null = set.GetRefList<scare2D.EntityHandle>();
  760.                         var refList__scare2D_dot_Transform2D_null = set.GetRefList<scare2D.Transform2D>();
  761.                         for(var i = 0; i < set.Handles.Count; ++i) {
  762.                             currentValue.Handle = refList__scare2D_dot_EntityHandle_null[i];
  763.                             currentValue.Transform = refList__scare2D_dot_Transform2D_null[i];
  764.                             yield return true;
  765.                         }
  766.                     }
  767.                 }
  768.             }
  769.         }
  770.         public sealed class _scare2D_dot_AutoLerpTransformBeginFixedUpdateSystem_dot_AddAutoLerpGroup_Enumerator_ReadOnlyFilter : IRefEnumerator<scare2D.AutoLerpTransformBeginFixedUpdateSystem.AddAutoLerpGroup> {
  771.             private Func<SharedDataType, bool> filter;
  772.             private _scare2D_dot_AutoLerpTransformBeginFixedUpdateSystem_dot_AddAutoLerpGroup_Collection collection;
  773.             private scare2D.AutoLerpTransformBeginFixedUpdateSystem.AddAutoLerpGroup currentValue = new scare2D.AutoLerpTransformBeginFixedUpdateSystem.AddAutoLerpGroup();
  774.             private IEnumerator<bool> moveNextEnumerator;
  775.             public _scare2D_dot_AutoLerpTransformBeginFixedUpdateSystem_dot_AddAutoLerpGroup_Enumerator_ReadOnlyFilter(_scare2D_dot_AutoLerpTransformBeginFixedUpdateSystem_dot_AddAutoLerpGroup_Collection collection, Func<SharedDataType, bool> filter) {
  776.                 this.collection = collection;
  777.                 this.filter = filter;
  778.             }
  779.             public ref scare2D.AutoLerpTransformBeginFixedUpdateSystem.AddAutoLerpGroup Current => ref currentValue;
  780.             public bool MoveNext() {
  781.                 if(moveNextEnumerator == null) {
  782.                     moveNextEnumerator = MoveNextInternal();
  783.                 }
  784.                 return moveNextEnumerator.MoveNext();
  785.             }
  786.             public IEnumerator<bool> MoveNextInternal() {
  787.                 foreach(var setType in collection.EntityWorld.Entities.Components) {
  788.                     bool keepSetType = setType.TypeSet.IsSupersetOf(collection.Includes) && setType.TypeSet.GetIntersection(collection.Excludes).IsEmpty;
  789.                     if(keepSetType == false) continue;
  790.                     foreach(var set in setType) {
  791.                         if(filter(set.SharedDataType) == false) continue;
  792.                         var refList__scare2D_dot_EntityHandle_null = set.GetRefList<scare2D.EntityHandle>();
  793.                         var refList__scare2D_dot_Transform2D_null = set.GetRefList<scare2D.Transform2D>();
  794.                         for(var i = 0; i < set.Handles.Count; ++i) {
  795.                             currentValue.Handle = refList__scare2D_dot_EntityHandle_null[i];
  796.                             currentValue.Transform = refList__scare2D_dot_Transform2D_null[i];
  797.                             yield return true;
  798.                         }
  799.                     }
  800.                 }
  801.             }
  802.         }
  803.         public scare2D.AutoLerpTransformBeginFixedUpdateSystem System => EntityWorld._scare2D_dot_AutoLerpTransformBeginFixedUpdateSystem_null;
  804.         public EntityWorld EntityWorld { get; }
  805.         public TypeSet Includes { get; }
  806.         public TypeSet Excludes { get; }
  807.         public IEntityWorld World => EntityWorld;
  808.         public _scare2D_dot_AutoLerpTransformBeginFixedUpdateSystem_dot_AddAutoLerpGroup_Collection(EntityWorld world) {
  809.             EntityWorld = world;
  810.             Includes = new TypeSet(typeof(scare2D.Transform2D));
  811.             Excludes = new TypeSet(typeof(scare2D.AutoLerpTransformComponent));
  812.            
  813.         }
  814.         public IRefEnumerator<scare2D.AutoLerpTransformBeginFixedUpdateSystem.AddAutoLerpGroup> GetEnumerator() => new _scare2D_dot_AutoLerpTransformBeginFixedUpdateSystem_dot_AddAutoLerpGroup_Enumerator(this);
  815.         public IRefEnumerable<scare2D.AutoLerpTransformBeginFixedUpdateSystem.AddAutoLerpGroup> WithFilter(Func<SharedDataType, bool> filter) => new RefEnumeratorWrapper<scare2D.AutoLerpTransformBeginFixedUpdateSystem.AddAutoLerpGroup>(new _scare2D_dot_AutoLerpTransformBeginFixedUpdateSystem_dot_AddAutoLerpGroup_Enumerator_ReadOnlyFilter(this, filter));
  816.     }
  817.     public sealed class _scare2D_dot_AutoLerpTransformBeginFixedUpdateSystem_dot_AutoLerpGroup_Collection : IComponentCollection<scare2D.AutoLerpTransformBeginFixedUpdateSystem.AutoLerpGroup> {
  818.         public sealed class _scare2D_dot_AutoLerpTransformBeginFixedUpdateSystem_dot_AutoLerpGroup_Enumerator : IRefEnumerator<scare2D.AutoLerpTransformBeginFixedUpdateSystem.AutoLerpGroup> {
  819.             private _scare2D_dot_AutoLerpTransformBeginFixedUpdateSystem_dot_AutoLerpGroup_Collection collection;
  820.             private scare2D.AutoLerpTransformBeginFixedUpdateSystem.AutoLerpGroup currentValue = new scare2D.AutoLerpTransformBeginFixedUpdateSystem.AutoLerpGroup();
  821.             private IEnumerator<bool> moveNextEnumerator;
  822.             public _scare2D_dot_AutoLerpTransformBeginFixedUpdateSystem_dot_AutoLerpGroup_Enumerator(_scare2D_dot_AutoLerpTransformBeginFixedUpdateSystem_dot_AutoLerpGroup_Collection collection) {
  823.                 this.collection = collection;
  824.             }
  825.             public ref scare2D.AutoLerpTransformBeginFixedUpdateSystem.AutoLerpGroup Current => ref currentValue;
  826.             public bool MoveNext() {
  827.                 if(moveNextEnumerator == null) {
  828.                     moveNextEnumerator = MoveNextInternal();
  829.                 }
  830.                 return moveNextEnumerator.MoveNext();
  831.             }
  832.             public IEnumerator<bool> MoveNextInternal() {
  833.                 foreach(var setType in collection.EntityWorld.Entities.Components) {
  834.                     bool keepSetType = setType.TypeSet.IsSupersetOf(collection.Includes);
  835.                     if(keepSetType == false) continue;
  836.                     foreach(var set in setType) {
  837.                         var refList__scare2D_dot_Transform2D_null = set.GetRefList<scare2D.Transform2D>();
  838.                         var refList__scare2D_dot_AutoLerpTransformComponent_null = set.GetRefList<scare2D.AutoLerpTransformComponent>();
  839.                         for(var i = 0; i < set.Handles.Count; ++i) {
  840.                             currentValue.Transform = refList__scare2D_dot_Transform2D_null[i];
  841.                             currentValue.AutoLerp = refList__scare2D_dot_AutoLerpTransformComponent_null[i];
  842.                             yield return true;
  843.                             refList__scare2D_dot_Transform2D_null[i] = currentValue.Transform;
  844.                             refList__scare2D_dot_AutoLerpTransformComponent_null[i] = currentValue.AutoLerp;
  845.                         }
  846.                     }
  847.                 }
  848.             }
  849.         }
  850.         public sealed class _scare2D_dot_AutoLerpTransformBeginFixedUpdateSystem_dot_AutoLerpGroup_Enumerator_ReadOnlyFilter : IRefEnumerator<scare2D.AutoLerpTransformBeginFixedUpdateSystem.AutoLerpGroup> {
  851.             private Func<SharedDataType, bool> filter;
  852.             private _scare2D_dot_AutoLerpTransformBeginFixedUpdateSystem_dot_AutoLerpGroup_Collection collection;
  853.             private scare2D.AutoLerpTransformBeginFixedUpdateSystem.AutoLerpGroup currentValue = new scare2D.AutoLerpTransformBeginFixedUpdateSystem.AutoLerpGroup();
  854.             private IEnumerator<bool> moveNextEnumerator;
  855.             public _scare2D_dot_AutoLerpTransformBeginFixedUpdateSystem_dot_AutoLerpGroup_Enumerator_ReadOnlyFilter(_scare2D_dot_AutoLerpTransformBeginFixedUpdateSystem_dot_AutoLerpGroup_Collection collection, Func<SharedDataType, bool> filter) {
  856.                 this.collection = collection;
  857.                 this.filter = filter;
  858.             }
  859.             public ref scare2D.AutoLerpTransformBeginFixedUpdateSystem.AutoLerpGroup Current => ref currentValue;
  860.             public bool MoveNext() {
  861.                 if(moveNextEnumerator == null) {
  862.                     moveNextEnumerator = MoveNextInternal();
  863.                 }
  864.                 return moveNextEnumerator.MoveNext();
  865.             }
  866.             public IEnumerator<bool> MoveNextInternal() {
  867.                 foreach(var setType in collection.EntityWorld.Entities.Components) {
  868.                     bool keepSetType = setType.TypeSet.IsSupersetOf(collection.Includes);
  869.                     if(keepSetType == false) continue;
  870.                     foreach(var set in setType) {
  871.                         if(filter(set.SharedDataType) == false) continue;
  872.                         var refList__scare2D_dot_Transform2D_null = set.GetRefList<scare2D.Transform2D>();
  873.                         var refList__scare2D_dot_AutoLerpTransformComponent_null = set.GetRefList<scare2D.AutoLerpTransformComponent>();
  874.                         for(var i = 0; i < set.Handles.Count; ++i) {
  875.                             currentValue.Transform = refList__scare2D_dot_Transform2D_null[i];
  876.                             currentValue.AutoLerp = refList__scare2D_dot_AutoLerpTransformComponent_null[i];
  877.                             yield return true;
  878.                         }
  879.                     }
  880.                 }
  881.             }
  882.         }
  883.         public scare2D.AutoLerpTransformBeginFixedUpdateSystem System => EntityWorld._scare2D_dot_AutoLerpTransformBeginFixedUpdateSystem_null;
  884.         public EntityWorld EntityWorld { get; }
  885.         public TypeSet Includes { get; }
  886.         public TypeSet Excludes { get; }
  887.         public IEntityWorld World => EntityWorld;
  888.         public _scare2D_dot_AutoLerpTransformBeginFixedUpdateSystem_dot_AutoLerpGroup_Collection(EntityWorld world) {
  889.             EntityWorld = world;
  890.             Includes = new TypeSet(typeof(scare2D.Transform2D), typeof(scare2D.AutoLerpTransformComponent));
  891.             Excludes = new TypeSet();
  892.            
  893.         }
  894.         public IRefEnumerator<scare2D.AutoLerpTransformBeginFixedUpdateSystem.AutoLerpGroup> GetEnumerator() => new _scare2D_dot_AutoLerpTransformBeginFixedUpdateSystem_dot_AutoLerpGroup_Enumerator(this);
  895.         public IRefEnumerable<scare2D.AutoLerpTransformBeginFixedUpdateSystem.AutoLerpGroup> WithFilter(Func<SharedDataType, bool> filter) => new RefEnumeratorWrapper<scare2D.AutoLerpTransformBeginFixedUpdateSystem.AutoLerpGroup>(new _scare2D_dot_AutoLerpTransformBeginFixedUpdateSystem_dot_AutoLerpGroup_Enumerator_ReadOnlyFilter(this, filter));
  896.     }
  897.     public sealed class _scare2D_dot_AutoLerpTransformBeginDrawSystem_dot_AutoLerpGroup_Collection : IComponentCollection<scare2D.AutoLerpTransformBeginDrawSystem.AutoLerpGroup> {
  898.         public sealed class _scare2D_dot_AutoLerpTransformBeginDrawSystem_dot_AutoLerpGroup_Enumerator : IRefEnumerator<scare2D.AutoLerpTransformBeginDrawSystem.AutoLerpGroup> {
  899.             private _scare2D_dot_AutoLerpTransformBeginDrawSystem_dot_AutoLerpGroup_Collection collection;
  900.             private scare2D.AutoLerpTransformBeginDrawSystem.AutoLerpGroup currentValue = new scare2D.AutoLerpTransformBeginDrawSystem.AutoLerpGroup();
  901.             private IEnumerator<bool> moveNextEnumerator;
  902.             public _scare2D_dot_AutoLerpTransformBeginDrawSystem_dot_AutoLerpGroup_Enumerator(_scare2D_dot_AutoLerpTransformBeginDrawSystem_dot_AutoLerpGroup_Collection collection) {
  903.                 this.collection = collection;
  904.             }
  905.             public ref scare2D.AutoLerpTransformBeginDrawSystem.AutoLerpGroup Current => ref currentValue;
  906.             public bool MoveNext() {
  907.                 if(moveNextEnumerator == null) {
  908.                     moveNextEnumerator = MoveNextInternal();
  909.                 }
  910.                 return moveNextEnumerator.MoveNext();
  911.             }
  912.             public IEnumerator<bool> MoveNextInternal() {
  913.                 foreach(var setType in collection.EntityWorld.Entities.Components) {
  914.                     bool keepSetType = setType.TypeSet.IsSupersetOf(collection.Includes);
  915.                     if(keepSetType == false) continue;
  916.                     foreach(var set in setType) {
  917.                         var refList__scare2D_dot_Transform2D_null = set.GetRefList<scare2D.Transform2D>();
  918.                         var refList__scare2D_dot_AutoLerpTransformComponent_null = set.GetRefList<scare2D.AutoLerpTransformComponent>();
  919.                         for(var i = 0; i < set.Handles.Count; ++i) {
  920.                             currentValue.Transform = refList__scare2D_dot_Transform2D_null[i];
  921.                             currentValue.AutoLerp = refList__scare2D_dot_AutoLerpTransformComponent_null[i];
  922.                             yield return true;
  923.                             refList__scare2D_dot_Transform2D_null[i] = currentValue.Transform;
  924.                             refList__scare2D_dot_AutoLerpTransformComponent_null[i] = currentValue.AutoLerp;
  925.                         }
  926.                     }
  927.                 }
  928.             }
  929.         }
  930.         public sealed class _scare2D_dot_AutoLerpTransformBeginDrawSystem_dot_AutoLerpGroup_Enumerator_ReadOnlyFilter : IRefEnumerator<scare2D.AutoLerpTransformBeginDrawSystem.AutoLerpGroup> {
  931.             private Func<SharedDataType, bool> filter;
  932.             private _scare2D_dot_AutoLerpTransformBeginDrawSystem_dot_AutoLerpGroup_Collection collection;
  933.             private scare2D.AutoLerpTransformBeginDrawSystem.AutoLerpGroup currentValue = new scare2D.AutoLerpTransformBeginDrawSystem.AutoLerpGroup();
  934.             private IEnumerator<bool> moveNextEnumerator;
  935.             public _scare2D_dot_AutoLerpTransformBeginDrawSystem_dot_AutoLerpGroup_Enumerator_ReadOnlyFilter(_scare2D_dot_AutoLerpTransformBeginDrawSystem_dot_AutoLerpGroup_Collection collection, Func<SharedDataType, bool> filter) {
  936.                 this.collection = collection;
  937.                 this.filter = filter;
  938.             }
  939.             public ref scare2D.AutoLerpTransformBeginDrawSystem.AutoLerpGroup Current => ref currentValue;
  940.             public bool MoveNext() {
  941.                 if(moveNextEnumerator == null) {
  942.                     moveNextEnumerator = MoveNextInternal();
  943.                 }
  944.                 return moveNextEnumerator.MoveNext();
  945.             }
  946.             public IEnumerator<bool> MoveNextInternal() {
  947.                 foreach(var setType in collection.EntityWorld.Entities.Components) {
  948.                     bool keepSetType = setType.TypeSet.IsSupersetOf(collection.Includes);
  949.                     if(keepSetType == false) continue;
  950.                     foreach(var set in setType) {
  951.                         if(filter(set.SharedDataType) == false) continue;
  952.                         var refList__scare2D_dot_Transform2D_null = set.GetRefList<scare2D.Transform2D>();
  953.                         var refList__scare2D_dot_AutoLerpTransformComponent_null = set.GetRefList<scare2D.AutoLerpTransformComponent>();
  954.                         for(var i = 0; i < set.Handles.Count; ++i) {
  955.                             currentValue.Transform = refList__scare2D_dot_Transform2D_null[i];
  956.                             currentValue.AutoLerp = refList__scare2D_dot_AutoLerpTransformComponent_null[i];
  957.                             yield return true;
  958.                         }
  959.                     }
  960.                 }
  961.             }
  962.         }
  963.         public scare2D.AutoLerpTransformBeginDrawSystem System => EntityWorld._scare2D_dot_AutoLerpTransformBeginDrawSystem_null;
  964.         public EntityWorld EntityWorld { get; }
  965.         public TypeSet Includes { get; }
  966.         public TypeSet Excludes { get; }
  967.         public IEntityWorld World => EntityWorld;
  968.         public _scare2D_dot_AutoLerpTransformBeginDrawSystem_dot_AutoLerpGroup_Collection(EntityWorld world) {
  969.             EntityWorld = world;
  970.             Includes = new TypeSet(typeof(scare2D.Transform2D), typeof(scare2D.AutoLerpTransformComponent));
  971.             Excludes = new TypeSet();
  972.            
  973.         }
  974.         public IRefEnumerator<scare2D.AutoLerpTransformBeginDrawSystem.AutoLerpGroup> GetEnumerator() => new _scare2D_dot_AutoLerpTransformBeginDrawSystem_dot_AutoLerpGroup_Enumerator(this);
  975.         public IRefEnumerable<scare2D.AutoLerpTransformBeginDrawSystem.AutoLerpGroup> WithFilter(Func<SharedDataType, bool> filter) => new RefEnumeratorWrapper<scare2D.AutoLerpTransformBeginDrawSystem.AutoLerpGroup>(new _scare2D_dot_AutoLerpTransformBeginDrawSystem_dot_AutoLerpGroup_Enumerator_ReadOnlyFilter(this, filter));
  976.     }
  977.     public sealed class _scare2D_dot_AutoSetDefaultTransformSystem_dot_ItemGroup_Collection : IComponentCollection<scare2D.AutoSetDefaultTransformSystem.ItemGroup> {
  978.         public sealed class _scare2D_dot_AutoSetDefaultTransformSystem_dot_ItemGroup_Enumerator : IRefEnumerator<scare2D.AutoSetDefaultTransformSystem.ItemGroup> {
  979.             private _scare2D_dot_AutoSetDefaultTransformSystem_dot_ItemGroup_Collection collection;
  980.             private scare2D.AutoSetDefaultTransformSystem.ItemGroup currentValue = new scare2D.AutoSetDefaultTransformSystem.ItemGroup();
  981.             private IEnumerator<bool> moveNextEnumerator;
  982.             public _scare2D_dot_AutoSetDefaultTransformSystem_dot_ItemGroup_Enumerator(_scare2D_dot_AutoSetDefaultTransformSystem_dot_ItemGroup_Collection collection) {
  983.                 this.collection = collection;
  984.             }
  985.             public ref scare2D.AutoSetDefaultTransformSystem.ItemGroup Current => ref currentValue;
  986.             public bool MoveNext() {
  987.                 if(moveNextEnumerator == null) {
  988.                     moveNextEnumerator = MoveNextInternal();
  989.                 }
  990.                 return moveNextEnumerator.MoveNext();
  991.             }
  992.             public IEnumerator<bool> MoveNextInternal() {
  993.                 foreach(var setType in collection.EntityWorld.Entities.Components) {
  994.                     bool keepSetType = setType.TypeSet.IsSupersetOf(collection.Includes);
  995.                     if(keepSetType == false) continue;
  996.                     foreach(var set in setType) {
  997.                         var refList__scare2D_dot_Transform2D_null = set.GetRefList<scare2D.Transform2D>();
  998.                         for(var i = 0; i < set.Handles.Count; ++i) {
  999.                             currentValue.Transform = refList__scare2D_dot_Transform2D_null[i];
  1000.                             yield return true;
  1001.                             refList__scare2D_dot_Transform2D_null[i] = currentValue.Transform;
  1002.                         }
  1003.                     }
  1004.                 }
  1005.             }
  1006.         }
  1007.         public sealed class _scare2D_dot_AutoSetDefaultTransformSystem_dot_ItemGroup_Enumerator_ReadOnlyFilter : IRefEnumerator<scare2D.AutoSetDefaultTransformSystem.ItemGroup> {
  1008.             private Func<SharedDataType, bool> filter;
  1009.             private _scare2D_dot_AutoSetDefaultTransformSystem_dot_ItemGroup_Collection collection;
  1010.             private scare2D.AutoSetDefaultTransformSystem.ItemGroup currentValue = new scare2D.AutoSetDefaultTransformSystem.ItemGroup();
  1011.             private IEnumerator<bool> moveNextEnumerator;
  1012.             public _scare2D_dot_AutoSetDefaultTransformSystem_dot_ItemGroup_Enumerator_ReadOnlyFilter(_scare2D_dot_AutoSetDefaultTransformSystem_dot_ItemGroup_Collection collection, Func<SharedDataType, bool> filter) {
  1013.                 this.collection = collection;
  1014.                 this.filter = filter;
  1015.             }
  1016.             public ref scare2D.AutoSetDefaultTransformSystem.ItemGroup Current => ref currentValue;
  1017.             public bool MoveNext() {
  1018.                 if(moveNextEnumerator == null) {
  1019.                     moveNextEnumerator = MoveNextInternal();
  1020.                 }
  1021.                 return moveNextEnumerator.MoveNext();
  1022.             }
  1023.             public IEnumerator<bool> MoveNextInternal() {
  1024.                 foreach(var setType in collection.EntityWorld.Entities.Components) {
  1025.                     bool keepSetType = setType.TypeSet.IsSupersetOf(collection.Includes);
  1026.                     if(keepSetType == false) continue;
  1027.                     foreach(var set in setType) {
  1028.                         if(filter(set.SharedDataType) == false) continue;
  1029.                         var refList__scare2D_dot_Transform2D_null = set.GetRefList<scare2D.Transform2D>();
  1030.                         for(var i = 0; i < set.Handles.Count; ++i) {
  1031.                             currentValue.Transform = refList__scare2D_dot_Transform2D_null[i];
  1032.                             yield return true;
  1033.                         }
  1034.                     }
  1035.                 }
  1036.             }
  1037.         }
  1038.         public scare2D.AutoSetDefaultTransformSystem System => EntityWorld._scare2D_dot_AutoSetDefaultTransformSystem_null;
  1039.         public EntityWorld EntityWorld { get; }
  1040.         public TypeSet Includes { get; }
  1041.         public TypeSet Excludes { get; }
  1042.         public IEntityWorld World => EntityWorld;
  1043.         public _scare2D_dot_AutoSetDefaultTransformSystem_dot_ItemGroup_Collection(EntityWorld world) {
  1044.             EntityWorld = world;
  1045.             Includes = new TypeSet(typeof(scare2D.Transform2D));
  1046.             Excludes = new TypeSet();
  1047.            
  1048.         }
  1049.         public IRefEnumerator<scare2D.AutoSetDefaultTransformSystem.ItemGroup> GetEnumerator() => new _scare2D_dot_AutoSetDefaultTransformSystem_dot_ItemGroup_Enumerator(this);
  1050.         public IRefEnumerable<scare2D.AutoSetDefaultTransformSystem.ItemGroup> WithFilter(Func<SharedDataType, bool> filter) => new RefEnumeratorWrapper<scare2D.AutoSetDefaultTransformSystem.ItemGroup>(new _scare2D_dot_AutoSetDefaultTransformSystem_dot_ItemGroup_Enumerator_ReadOnlyFilter(this, filter));
  1051.     }
  1052.     public sealed class _scare2D_dot_PhysicsCleanupSystem_dot_ItemGroup_Collection : IComponentCollection<scare2D.PhysicsCleanupSystem.ItemGroup> {
  1053.         public sealed class _scare2D_dot_PhysicsCleanupSystem_dot_ItemGroup_Enumerator : IRefEnumerator<scare2D.PhysicsCleanupSystem.ItemGroup> {
  1054.             private _scare2D_dot_PhysicsCleanupSystem_dot_ItemGroup_Collection collection;
  1055.             private scare2D.PhysicsCleanupSystem.ItemGroup currentValue = new scare2D.PhysicsCleanupSystem.ItemGroup();
  1056.             private IEnumerator<bool> moveNextEnumerator;
  1057.             public _scare2D_dot_PhysicsCleanupSystem_dot_ItemGroup_Enumerator(_scare2D_dot_PhysicsCleanupSystem_dot_ItemGroup_Collection collection) {
  1058.                 this.collection = collection;
  1059.             }
  1060.             public ref scare2D.PhysicsCleanupSystem.ItemGroup Current => ref currentValue;
  1061.             public bool MoveNext() {
  1062.                 if(moveNextEnumerator == null) {
  1063.                     moveNextEnumerator = MoveNextInternal();
  1064.                 }
  1065.                 return moveNextEnumerator.MoveNext();
  1066.             }
  1067.             public IEnumerator<bool> MoveNextInternal() {
  1068.                 foreach(var setType in collection.EntityWorld.Entities.Components) {
  1069.                     bool keepSetType = setType.TypeSet.IsSupersetOf(collection.Includes);
  1070.                     if(keepSetType == false) continue;
  1071.                     foreach(var set in setType) {
  1072.                         var refList__scare2D_dot_EntityHandle_null = set.GetRefList<scare2D.EntityHandle>();
  1073.                         var refList__scare2D_dot_BroadPhasePair_null = set.GetRefList<scare2D.BroadPhasePair>();
  1074.                         for(var i = 0; i < set.Handles.Count; ++i) {
  1075.                             currentValue.Handle = refList__scare2D_dot_EntityHandle_null[i];
  1076.                             currentValue._ = refList__scare2D_dot_BroadPhasePair_null[i];
  1077.                             yield return true;
  1078.                         }
  1079.                     }
  1080.                 }
  1081.             }
  1082.         }
  1083.         public sealed class _scare2D_dot_PhysicsCleanupSystem_dot_ItemGroup_Enumerator_ReadOnlyFilter : IRefEnumerator<scare2D.PhysicsCleanupSystem.ItemGroup> {
  1084.             private Func<SharedDataType, bool> filter;
  1085.             private _scare2D_dot_PhysicsCleanupSystem_dot_ItemGroup_Collection collection;
  1086.             private scare2D.PhysicsCleanupSystem.ItemGroup currentValue = new scare2D.PhysicsCleanupSystem.ItemGroup();
  1087.             private IEnumerator<bool> moveNextEnumerator;
  1088.             public _scare2D_dot_PhysicsCleanupSystem_dot_ItemGroup_Enumerator_ReadOnlyFilter(_scare2D_dot_PhysicsCleanupSystem_dot_ItemGroup_Collection collection, Func<SharedDataType, bool> filter) {
  1089.                 this.collection = collection;
  1090.                 this.filter = filter;
  1091.             }
  1092.             public ref scare2D.PhysicsCleanupSystem.ItemGroup Current => ref currentValue;
  1093.             public bool MoveNext() {
  1094.                 if(moveNextEnumerator == null) {
  1095.                     moveNextEnumerator = MoveNextInternal();
  1096.                 }
  1097.                 return moveNextEnumerator.MoveNext();
  1098.             }
  1099.             public IEnumerator<bool> MoveNextInternal() {
  1100.                 foreach(var setType in collection.EntityWorld.Entities.Components) {
  1101.                     bool keepSetType = setType.TypeSet.IsSupersetOf(collection.Includes);
  1102.                     if(keepSetType == false) continue;
  1103.                     foreach(var set in setType) {
  1104.                         if(filter(set.SharedDataType) == false) continue;
  1105.                         var refList__scare2D_dot_EntityHandle_null = set.GetRefList<scare2D.EntityHandle>();
  1106.                         var refList__scare2D_dot_BroadPhasePair_null = set.GetRefList<scare2D.BroadPhasePair>();
  1107.                         for(var i = 0; i < set.Handles.Count; ++i) {
  1108.                             currentValue.Handle = refList__scare2D_dot_EntityHandle_null[i];
  1109.                             currentValue._ = refList__scare2D_dot_BroadPhasePair_null[i];
  1110.                             yield return true;
  1111.                         }
  1112.                     }
  1113.                 }
  1114.             }
  1115.         }
  1116.         public scare2D.PhysicsCleanupSystem System => EntityWorld._scare2D_dot_PhysicsCleanupSystem_null;
  1117.         public EntityWorld EntityWorld { get; }
  1118.         public TypeSet Includes { get; }
  1119.         public TypeSet Excludes { get; }
  1120.         public IEntityWorld World => EntityWorld;
  1121.         public _scare2D_dot_PhysicsCleanupSystem_dot_ItemGroup_Collection(EntityWorld world) {
  1122.             EntityWorld = world;
  1123.             Includes = new TypeSet(typeof(scare2D.BroadPhasePair));
  1124.             Excludes = new TypeSet();
  1125.            
  1126.         }
  1127.         public IRefEnumerator<scare2D.PhysicsCleanupSystem.ItemGroup> GetEnumerator() => new _scare2D_dot_PhysicsCleanupSystem_dot_ItemGroup_Enumerator(this);
  1128.         public IRefEnumerable<scare2D.PhysicsCleanupSystem.ItemGroup> WithFilter(Func<SharedDataType, bool> filter) => new RefEnumeratorWrapper<scare2D.PhysicsCleanupSystem.ItemGroup>(new _scare2D_dot_PhysicsCleanupSystem_dot_ItemGroup_Enumerator_ReadOnlyFilter(this, filter));
  1129.     }
  1130.     public sealed class _scare2D_dot_PhysicsCleanupSystem_dot_ItemGroup2_Collection : IComponentCollection<scare2D.PhysicsCleanupSystem.ItemGroup2> {
  1131.         public sealed class _scare2D_dot_PhysicsCleanupSystem_dot_ItemGroup2_Enumerator : IRefEnumerator<scare2D.PhysicsCleanupSystem.ItemGroup2> {
  1132.             private _scare2D_dot_PhysicsCleanupSystem_dot_ItemGroup2_Collection collection;
  1133.             private scare2D.PhysicsCleanupSystem.ItemGroup2 currentValue = new scare2D.PhysicsCleanupSystem.ItemGroup2();
  1134.             private IEnumerator<bool> moveNextEnumerator;
  1135.             public _scare2D_dot_PhysicsCleanupSystem_dot_ItemGroup2_Enumerator(_scare2D_dot_PhysicsCleanupSystem_dot_ItemGroup2_Collection collection) {
  1136.                 this.collection = collection;
  1137.             }
  1138.             public ref scare2D.PhysicsCleanupSystem.ItemGroup2 Current => ref currentValue;
  1139.             public bool MoveNext() {
  1140.                 if(moveNextEnumerator == null) {
  1141.                     moveNextEnumerator = MoveNextInternal();
  1142.                 }
  1143.                 return moveNextEnumerator.MoveNext();
  1144.             }
  1145.             public IEnumerator<bool> MoveNextInternal() {
  1146.                 foreach(var setType in collection.EntityWorld.Entities.Components) {
  1147.                     bool keepSetType = setType.TypeSet.IsSupersetOf(collection.Includes);
  1148.                     if(keepSetType == false) continue;
  1149.                     foreach(var set in setType) {
  1150.                         var refList__scare2D_dot_EntityHandle_null = set.GetRefList<scare2D.EntityHandle>();
  1151.                         var refList__scare2D_dot_Manifold2D_null = set.GetRefList<scare2D.Manifold2D>();
  1152.                         for(var i = 0; i < set.Handles.Count; ++i) {
  1153.                             currentValue.Handle = refList__scare2D_dot_EntityHandle_null[i];
  1154.                             currentValue._ = refList__scare2D_dot_Manifold2D_null[i];
  1155.                             yield return true;
  1156.                         }
  1157.                     }
  1158.                 }
  1159.             }
  1160.         }
  1161.         public sealed class _scare2D_dot_PhysicsCleanupSystem_dot_ItemGroup2_Enumerator_ReadOnlyFilter : IRefEnumerator<scare2D.PhysicsCleanupSystem.ItemGroup2> {
  1162.             private Func<SharedDataType, bool> filter;
  1163.             private _scare2D_dot_PhysicsCleanupSystem_dot_ItemGroup2_Collection collection;
  1164.             private scare2D.PhysicsCleanupSystem.ItemGroup2 currentValue = new scare2D.PhysicsCleanupSystem.ItemGroup2();
  1165.             private IEnumerator<bool> moveNextEnumerator;
  1166.             public _scare2D_dot_PhysicsCleanupSystem_dot_ItemGroup2_Enumerator_ReadOnlyFilter(_scare2D_dot_PhysicsCleanupSystem_dot_ItemGroup2_Collection collection, Func<SharedDataType, bool> filter) {
  1167.                 this.collection = collection;
  1168.                 this.filter = filter;
  1169.             }
  1170.             public ref scare2D.PhysicsCleanupSystem.ItemGroup2 Current => ref currentValue;
  1171.             public bool MoveNext() {
  1172.                 if(moveNextEnumerator == null) {
  1173.                     moveNextEnumerator = MoveNextInternal();
  1174.                 }
  1175.                 return moveNextEnumerator.MoveNext();
  1176.             }
  1177.             public IEnumerator<bool> MoveNextInternal() {
  1178.                 foreach(var setType in collection.EntityWorld.Entities.Components) {
  1179.                     bool keepSetType = setType.TypeSet.IsSupersetOf(collection.Includes);
  1180.                     if(keepSetType == false) continue;
  1181.                     foreach(var set in setType) {
  1182.                         if(filter(set.SharedDataType) == false) continue;
  1183.                         var refList__scare2D_dot_EntityHandle_null = set.GetRefList<scare2D.EntityHandle>();
  1184.                         var refList__scare2D_dot_Manifold2D_null = set.GetRefList<scare2D.Manifold2D>();
  1185.                         for(var i = 0; i < set.Handles.Count; ++i) {
  1186.                             currentValue.Handle = refList__scare2D_dot_EntityHandle_null[i];
  1187.                             currentValue._ = refList__scare2D_dot_Manifold2D_null[i];
  1188.                             yield return true;
  1189.                         }
  1190.                     }
  1191.                 }
  1192.             }
  1193.         }
  1194.         public scare2D.PhysicsCleanupSystem System => EntityWorld._scare2D_dot_PhysicsCleanupSystem_null;
  1195.         public EntityWorld EntityWorld { get; }
  1196.         public TypeSet Includes { get; }
  1197.         public TypeSet Excludes { get; }
  1198.         public IEntityWorld World => EntityWorld;
  1199.         public _scare2D_dot_PhysicsCleanupSystem_dot_ItemGroup2_Collection(EntityWorld world) {
  1200.             EntityWorld = world;
  1201.             Includes = new TypeSet(typeof(scare2D.Manifold2D));
  1202.             Excludes = new TypeSet();
  1203.            
  1204.         }
  1205.         public IRefEnumerator<scare2D.PhysicsCleanupSystem.ItemGroup2> GetEnumerator() => new _scare2D_dot_PhysicsCleanupSystem_dot_ItemGroup2_Enumerator(this);
  1206.         public IRefEnumerable<scare2D.PhysicsCleanupSystem.ItemGroup2> WithFilter(Func<SharedDataType, bool> filter) => new RefEnumeratorWrapper<scare2D.PhysicsCleanupSystem.ItemGroup2>(new _scare2D_dot_PhysicsCleanupSystem_dot_ItemGroup2_Enumerator_ReadOnlyFilter(this, filter));
  1207.     }
  1208.     public sealed class _scare2D_dot_BroadPhaseRendererSystem_dot_ItemGroup_Collection : IComponentCollection<scare2D.BroadPhaseRendererSystem.ItemGroup> {
  1209.         public sealed class _scare2D_dot_BroadPhaseRendererSystem_dot_ItemGroup_Enumerator : IRefEnumerator<scare2D.BroadPhaseRendererSystem.ItemGroup> {
  1210.             private _scare2D_dot_BroadPhaseRendererSystem_dot_ItemGroup_Collection collection;
  1211.             private scare2D.BroadPhaseRendererSystem.ItemGroup currentValue = new scare2D.BroadPhaseRendererSystem.ItemGroup();
  1212.             private IEnumerator<bool> moveNextEnumerator;
  1213.             public _scare2D_dot_BroadPhaseRendererSystem_dot_ItemGroup_Enumerator(_scare2D_dot_BroadPhaseRendererSystem_dot_ItemGroup_Collection collection) {
  1214.                 this.collection = collection;
  1215.             }
  1216.             public ref scare2D.BroadPhaseRendererSystem.ItemGroup Current => ref currentValue;
  1217.             public bool MoveNext() {
  1218.                 if(moveNextEnumerator == null) {
  1219.                     moveNextEnumerator = MoveNextInternal();
  1220.                 }
  1221.                 return moveNextEnumerator.MoveNext();
  1222.             }
  1223.             public IEnumerator<bool> MoveNextInternal() {
  1224.                 foreach(var setType in collection.EntityWorld.Entities.Components) {
  1225.                     bool keepSetType = setType.TypeSet.IsSupersetOf(collection.Includes);
  1226.                     if(keepSetType == false) continue;
  1227.                     foreach(var set in setType) {
  1228.                         var refList__scare2D_dot_BroadPhasePair_null = set.GetRefList<scare2D.BroadPhasePair>();
  1229.                         for(var i = 0; i < set.Handles.Count; ++i) {
  1230.                             currentValue.Pair = refList__scare2D_dot_BroadPhasePair_null[i];
  1231.                             yield return true;
  1232.                         }
  1233.                     }
  1234.                 }
  1235.             }
  1236.         }
  1237.         public sealed class _scare2D_dot_BroadPhaseRendererSystem_dot_ItemGroup_Enumerator_ReadOnlyFilter : IRefEnumerator<scare2D.BroadPhaseRendererSystem.ItemGroup> {
  1238.             private Func<SharedDataType, bool> filter;
  1239.             private _scare2D_dot_BroadPhaseRendererSystem_dot_ItemGroup_Collection collection;
  1240.             private scare2D.BroadPhaseRendererSystem.ItemGroup currentValue = new scare2D.BroadPhaseRendererSystem.ItemGroup();
  1241.             private IEnumerator<bool> moveNextEnumerator;
  1242.             public _scare2D_dot_BroadPhaseRendererSystem_dot_ItemGroup_Enumerator_ReadOnlyFilter(_scare2D_dot_BroadPhaseRendererSystem_dot_ItemGroup_Collection collection, Func<SharedDataType, bool> filter) {
  1243.                 this.collection = collection;
  1244.                 this.filter = filter;
  1245.             }
  1246.             public ref scare2D.BroadPhaseRendererSystem.ItemGroup Current => ref currentValue;
  1247.             public bool MoveNext() {
  1248.                 if(moveNextEnumerator == null) {
  1249.                     moveNextEnumerator = MoveNextInternal();
  1250.                 }
  1251.                 return moveNextEnumerator.MoveNext();
  1252.             }
  1253.             public IEnumerator<bool> MoveNextInternal() {
  1254.                 foreach(var setType in collection.EntityWorld.Entities.Components) {
  1255.                     bool keepSetType = setType.TypeSet.IsSupersetOf(collection.Includes);
  1256.                     if(keepSetType == false) continue;
  1257.                     foreach(var set in setType) {
  1258.                         if(filter(set.SharedDataType) == false) continue;
  1259.                         var refList__scare2D_dot_BroadPhasePair_null = set.GetRefList<scare2D.BroadPhasePair>();
  1260.                         for(var i = 0; i < set.Handles.Count; ++i) {
  1261.                             currentValue.Pair = refList__scare2D_dot_BroadPhasePair_null[i];
  1262.                             yield return true;
  1263.                         }
  1264.                     }
  1265.                 }
  1266.             }
  1267.         }
  1268.         public scare2D.BroadPhaseRendererSystem System => EntityWorld._scare2D_dot_BroadPhaseRendererSystem_null;
  1269.         public EntityWorld EntityWorld { get; }
  1270.         public TypeSet Includes { get; }
  1271.         public TypeSet Excludes { get; }
  1272.         public IEntityWorld World => EntityWorld;
  1273.         public _scare2D_dot_BroadPhaseRendererSystem_dot_ItemGroup_Collection(EntityWorld world) {
  1274.             EntityWorld = world;
  1275.             Includes = new TypeSet(typeof(scare2D.BroadPhasePair));
  1276.             Excludes = new TypeSet();
  1277.            
  1278.         }
  1279.         public IRefEnumerator<scare2D.BroadPhaseRendererSystem.ItemGroup> GetEnumerator() => new _scare2D_dot_BroadPhaseRendererSystem_dot_ItemGroup_Enumerator(this);
  1280.         public IRefEnumerable<scare2D.BroadPhaseRendererSystem.ItemGroup> WithFilter(Func<SharedDataType, bool> filter) => new RefEnumeratorWrapper<scare2D.BroadPhaseRendererSystem.ItemGroup>(new _scare2D_dot_BroadPhaseRendererSystem_dot_ItemGroup_Enumerator_ReadOnlyFilter(this, filter));
  1281.     }
  1282.     public sealed class _scare2D_dot_PhysicsObject_Collection : IComponentCollection<scare2D.PhysicsObject> {
  1283.         public sealed class _scare2D_dot_PhysicsObject_Enumerator : IRefEnumerator<scare2D.PhysicsObject> {
  1284.             private _scare2D_dot_PhysicsObject_Collection collection;
  1285.             private scare2D.PhysicsObject currentValue = new scare2D.PhysicsObject();
  1286.             private IEnumerator<bool> moveNextEnumerator;
  1287.             public _scare2D_dot_PhysicsObject_Enumerator(_scare2D_dot_PhysicsObject_Collection collection) {
  1288.                 this.collection = collection;
  1289.             }
  1290.             public ref scare2D.PhysicsObject Current => ref currentValue;
  1291.             public bool MoveNext() {
  1292.                 if(moveNextEnumerator == null) {
  1293.                     moveNextEnumerator = MoveNextInternal();
  1294.                 }
  1295.                 return moveNextEnumerator.MoveNext();
  1296.             }
  1297.             public IEnumerator<bool> MoveNextInternal() {
  1298.                 var handlesThatChangedSharedType = new RefList<EntityHandle>();
  1299.                 foreach(var setType in collection.EntityWorld.Entities.Components) {
  1300.                     bool keepSetType = setType.TypeSet.IsSupersetOf(collection.Includes);
  1301.                     if(keepSetType == false) continue;
  1302.                     foreach(var handle in handlesThatChangedSharedType) {
  1303.                         collection.World.Entities.Components.CheckSharedDataTypeFor(handle);
  1304.                     }
  1305.                     handlesThatChangedSharedType.Clear();
  1306.                     foreach(var set in setType) {
  1307.                         var refList__scare2D_dot_EntityHandle_null = set.GetRefList<scare2D.EntityHandle>();
  1308.                         var refList__scare2D_dot_Transform2D_null = set.GetRefList<scare2D.Transform2D>();
  1309.                         var refList__scare2D_dot_RigidBody2D_null = set.GetRefList<scare2D.RigidBody2D>();
  1310.                         System.UInt32 _scare2D_dot_RigidBody2D_CollisionMask = default;
  1311.                         if(set.Handles.Count > 0) {
  1312.                             _scare2D_dot_RigidBody2D_CollisionMask = refList__scare2D_dot_RigidBody2D_null[0].CollisionMask;
  1313.                         }
  1314.                         for(var i = 0; i < set.Handles.Count; ++i) {
  1315.                             currentValue.Handle = refList__scare2D_dot_EntityHandle_null[i];
  1316.                             currentValue.Transform = refList__scare2D_dot_Transform2D_null[i];
  1317.                             currentValue.RigidBody = refList__scare2D_dot_RigidBody2D_null[i];
  1318.                             yield return true;
  1319.                             refList__scare2D_dot_Transform2D_null[i] = currentValue.Transform;
  1320.                             refList__scare2D_dot_RigidBody2D_null[i] = currentValue.RigidBody;
  1321.                             if(object.Equals(_scare2D_dot_RigidBody2D_CollisionMask, currentValue.RigidBody.CollisionMask) == false) {
  1322.                                 handlesThatChangedSharedType.Add(set.Handles[i]);
  1323.                             }
  1324.                         }
  1325.                     }
  1326.                 }
  1327.                 foreach(var handle in handlesThatChangedSharedType) {
  1328.                     collection.World.Entities.Components.CheckSharedDataTypeFor(handle);
  1329.                 }
  1330.             }
  1331.         }
  1332.         public sealed class _scare2D_dot_PhysicsObject_Enumerator_ReadOnlyFilter : IRefEnumerator<scare2D.PhysicsObject> {
  1333.             private Func<SharedDataType, bool> filter;
  1334.             private _scare2D_dot_PhysicsObject_Collection collection;
  1335.             private scare2D.PhysicsObject currentValue = new scare2D.PhysicsObject();
  1336.             private IEnumerator<bool> moveNextEnumerator;
  1337.             public _scare2D_dot_PhysicsObject_Enumerator_ReadOnlyFilter(_scare2D_dot_PhysicsObject_Collection collection, Func<SharedDataType, bool> filter) {
  1338.                 this.collection = collection;
  1339.                 this.filter = filter;
  1340.             }
  1341.             public ref scare2D.PhysicsObject Current => ref currentValue;
  1342.             public bool MoveNext() {
  1343.                 if(moveNextEnumerator == null) {
  1344.                     moveNextEnumerator = MoveNextInternal();
  1345.                 }
  1346.                 return moveNextEnumerator.MoveNext();
  1347.             }
  1348.             public IEnumerator<bool> MoveNextInternal() {
  1349.                 foreach(var setType in collection.EntityWorld.Entities.Components) {
  1350.                     bool keepSetType = setType.TypeSet.IsSupersetOf(collection.Includes);
  1351.                     if(keepSetType == false) continue;
  1352.                     foreach(var set in setType) {
  1353.                         if(filter(set.SharedDataType) == false) continue;
  1354.                         var refList__scare2D_dot_EntityHandle_null = set.GetRefList<scare2D.EntityHandle>();
  1355.                         var refList__scare2D_dot_Transform2D_null = set.GetRefList<scare2D.Transform2D>();
  1356.                         var refList__scare2D_dot_RigidBody2D_null = set.GetRefList<scare2D.RigidBody2D>();
  1357.                         if(set.Handles.Count > 0) {
  1358.                         }
  1359.                         for(var i = 0; i < set.Handles.Count; ++i) {
  1360.                             currentValue.Handle = refList__scare2D_dot_EntityHandle_null[i];
  1361.                             currentValue.Transform = refList__scare2D_dot_Transform2D_null[i];
  1362.                             currentValue.RigidBody = refList__scare2D_dot_RigidBody2D_null[i];
  1363.                             yield return true;
  1364.                         }
  1365.                     }
  1366.                 }
  1367.             }
  1368.         }
  1369.         public scare2D.BroadPhaseSystem System => EntityWorld._scare2D_dot_BroadPhaseSystem_null;
  1370.         public EntityWorld EntityWorld { get; }
  1371.         public TypeSet Includes { get; }
  1372.         public TypeSet Excludes { get; }
  1373.         public IEntityWorld World => EntityWorld;
  1374.         public _scare2D_dot_PhysicsObject_Collection(EntityWorld world) {
  1375.             EntityWorld = world;
  1376.             Includes = new TypeSet(typeof(scare2D.Transform2D), typeof(scare2D.RigidBody2D));
  1377.             Excludes = new TypeSet();
  1378.            
  1379.         }
  1380.         public IRefEnumerator<scare2D.PhysicsObject> GetEnumerator() => new _scare2D_dot_PhysicsObject_Enumerator(this);
  1381.         public IRefEnumerable<scare2D.PhysicsObject> WithFilter(Func<SharedDataType, bool> filter) => new RefEnumeratorWrapper<scare2D.PhysicsObject>(new _scare2D_dot_PhysicsObject_Enumerator_ReadOnlyFilter(this, filter));
  1382.     }
  1383.     public sealed class _scare2D_dot_NarrowPhaseSystem_dot_ItemGroup_Collection : IComponentCollection<scare2D.NarrowPhaseSystem.ItemGroup> {
  1384.         public sealed class _scare2D_dot_NarrowPhaseSystem_dot_ItemGroup_Enumerator : IRefEnumerator<scare2D.NarrowPhaseSystem.ItemGroup> {
  1385.             private _scare2D_dot_NarrowPhaseSystem_dot_ItemGroup_Collection collection;
  1386.             private scare2D.NarrowPhaseSystem.ItemGroup currentValue = new scare2D.NarrowPhaseSystem.ItemGroup();
  1387.             private IEnumerator<bool> moveNextEnumerator;
  1388.             public _scare2D_dot_NarrowPhaseSystem_dot_ItemGroup_Enumerator(_scare2D_dot_NarrowPhaseSystem_dot_ItemGroup_Collection collection) {
  1389.                 this.collection = collection;
  1390.             }
  1391.             public ref scare2D.NarrowPhaseSystem.ItemGroup Current => ref currentValue;
  1392.             public bool MoveNext() {
  1393.                 if(moveNextEnumerator == null) {
  1394.                     moveNextEnumerator = MoveNextInternal();
  1395.                 }
  1396.                 return moveNextEnumerator.MoveNext();
  1397.             }
  1398.             public IEnumerator<bool> MoveNextInternal() {
  1399.                 foreach(var setType in collection.EntityWorld.Entities.Components) {
  1400.                     bool keepSetType = setType.TypeSet.IsSupersetOf(collection.Includes);
  1401.                     if(keepSetType == false) continue;
  1402.                     foreach(var set in setType) {
  1403.                         var refList__scare2D_dot_BroadPhasePair_null = set.GetRefList<scare2D.BroadPhasePair>();
  1404.                         for(var i = 0; i < set.Handles.Count; ++i) {
  1405.                             currentValue.Pair = refList__scare2D_dot_BroadPhasePair_null[i];
  1406.                             yield return true;
  1407.                         }
  1408.                     }
  1409.                 }
  1410.             }
  1411.         }
  1412.         public sealed class _scare2D_dot_NarrowPhaseSystem_dot_ItemGroup_Enumerator_ReadOnlyFilter : IRefEnumerator<scare2D.NarrowPhaseSystem.ItemGroup> {
  1413.             private Func<SharedDataType, bool> filter;
  1414.             private _scare2D_dot_NarrowPhaseSystem_dot_ItemGroup_Collection collection;
  1415.             private scare2D.NarrowPhaseSystem.ItemGroup currentValue = new scare2D.NarrowPhaseSystem.ItemGroup();
  1416.             private IEnumerator<bool> moveNextEnumerator;
  1417.             public _scare2D_dot_NarrowPhaseSystem_dot_ItemGroup_Enumerator_ReadOnlyFilter(_scare2D_dot_NarrowPhaseSystem_dot_ItemGroup_Collection collection, Func<SharedDataType, bool> filter) {
  1418.                 this.collection = collection;
  1419.                 this.filter = filter;
  1420.             }
  1421.             public ref scare2D.NarrowPhaseSystem.ItemGroup Current => ref currentValue;
  1422.             public bool MoveNext() {
  1423.                 if(moveNextEnumerator == null) {
  1424.                     moveNextEnumerator = MoveNextInternal();
  1425.                 }
  1426.                 return moveNextEnumerator.MoveNext();
  1427.             }
  1428.             public IEnumerator<bool> MoveNextInternal() {
  1429.                 foreach(var setType in collection.EntityWorld.Entities.Components) {
  1430.                     bool keepSetType = setType.TypeSet.IsSupersetOf(collection.Includes);
  1431.                     if(keepSetType == false) continue;
  1432.                     foreach(var set in setType) {
  1433.                         if(filter(set.SharedDataType) == false) continue;
  1434.                         var refList__scare2D_dot_BroadPhasePair_null = set.GetRefList<scare2D.BroadPhasePair>();
  1435.                         for(var i = 0; i < set.Handles.Count; ++i) {
  1436.                             currentValue.Pair = refList__scare2D_dot_BroadPhasePair_null[i];
  1437.                             yield return true;
  1438.                         }
  1439.                     }
  1440.                 }
  1441.             }
  1442.         }
  1443.         public scare2D.NarrowPhaseSystem System => EntityWorld._scare2D_dot_NarrowPhaseSystem_null;
  1444.         public EntityWorld EntityWorld { get; }
  1445.         public TypeSet Includes { get; }
  1446.         public TypeSet Excludes { get; }
  1447.         public IEntityWorld World => EntityWorld;
  1448.         public _scare2D_dot_NarrowPhaseSystem_dot_ItemGroup_Collection(EntityWorld world) {
  1449.             EntityWorld = world;
  1450.             Includes = new TypeSet(typeof(scare2D.BroadPhasePair));
  1451.             Excludes = new TypeSet();
  1452.            
  1453.         }
  1454.         public IRefEnumerator<scare2D.NarrowPhaseSystem.ItemGroup> GetEnumerator() => new _scare2D_dot_NarrowPhaseSystem_dot_ItemGroup_Enumerator(this);
  1455.         public IRefEnumerable<scare2D.NarrowPhaseSystem.ItemGroup> WithFilter(Func<SharedDataType, bool> filter) => new RefEnumeratorWrapper<scare2D.NarrowPhaseSystem.ItemGroup>(new _scare2D_dot_NarrowPhaseSystem_dot_ItemGroup_Enumerator_ReadOnlyFilter(this, filter));
  1456.     }
  1457.     public sealed class _scare2D_dot_CollisionResponseSystem_dot_ItemGroup_Collection : IComponentCollection<scare2D.CollisionResponseSystem.ItemGroup> {
  1458.         public sealed class _scare2D_dot_CollisionResponseSystem_dot_ItemGroup_Enumerator : IRefEnumerator<scare2D.CollisionResponseSystem.ItemGroup> {
  1459.             private _scare2D_dot_CollisionResponseSystem_dot_ItemGroup_Collection collection;
  1460.             private scare2D.CollisionResponseSystem.ItemGroup currentValue = new scare2D.CollisionResponseSystem.ItemGroup();
  1461.             private IEnumerator<bool> moveNextEnumerator;
  1462.             public _scare2D_dot_CollisionResponseSystem_dot_ItemGroup_Enumerator(_scare2D_dot_CollisionResponseSystem_dot_ItemGroup_Collection collection) {
  1463.                 this.collection = collection;
  1464.             }
  1465.             public ref scare2D.CollisionResponseSystem.ItemGroup Current => ref currentValue;
  1466.             public bool MoveNext() {
  1467.                 if(moveNextEnumerator == null) {
  1468.                     moveNextEnumerator = MoveNextInternal();
  1469.                 }
  1470.                 return moveNextEnumerator.MoveNext();
  1471.             }
  1472.             public IEnumerator<bool> MoveNextInternal() {
  1473.                 foreach(var setType in collection.EntityWorld.Entities.Components) {
  1474.                     bool keepSetType = setType.TypeSet.IsSupersetOf(collection.Includes);
  1475.                     if(keepSetType == false) continue;
  1476.                     foreach(var set in setType) {
  1477.                         var refList__scare2D_dot_Manifold2D_null = set.GetRefList<scare2D.Manifold2D>();
  1478.                         for(var i = 0; i < set.Handles.Count; ++i) {
  1479.                             currentValue.Collision = refList__scare2D_dot_Manifold2D_null[i];
  1480.                             yield return true;
  1481.                         }
  1482.                     }
  1483.                 }
  1484.             }
  1485.         }
  1486.         public sealed class _scare2D_dot_CollisionResponseSystem_dot_ItemGroup_Enumerator_ReadOnlyFilter : IRefEnumerator<scare2D.CollisionResponseSystem.ItemGroup> {
  1487.             private Func<SharedDataType, bool> filter;
  1488.             private _scare2D_dot_CollisionResponseSystem_dot_ItemGroup_Collection collection;
  1489.             private scare2D.CollisionResponseSystem.ItemGroup currentValue = new scare2D.CollisionResponseSystem.ItemGroup();
  1490.             private IEnumerator<bool> moveNextEnumerator;
  1491.             public _scare2D_dot_CollisionResponseSystem_dot_ItemGroup_Enumerator_ReadOnlyFilter(_scare2D_dot_CollisionResponseSystem_dot_ItemGroup_Collection collection, Func<SharedDataType, bool> filter) {
  1492.                 this.collection = collection;
  1493.                 this.filter = filter;
  1494.             }
  1495.             public ref scare2D.CollisionResponseSystem.ItemGroup Current => ref currentValue;
  1496.             public bool MoveNext() {
  1497.                 if(moveNextEnumerator == null) {
  1498.                     moveNextEnumerator = MoveNextInternal();
  1499.                 }
  1500.                 return moveNextEnumerator.MoveNext();
  1501.             }
  1502.             public IEnumerator<bool> MoveNextInternal() {
  1503.                 foreach(var setType in collection.EntityWorld.Entities.Components) {
  1504.                     bool keepSetType = setType.TypeSet.IsSupersetOf(collection.Includes);
  1505.                     if(keepSetType == false) continue;
  1506.                     foreach(var set in setType) {
  1507.                         if(filter(set.SharedDataType) == false) continue;
  1508.                         var refList__scare2D_dot_Manifold2D_null = set.GetRefList<scare2D.Manifold2D>();
  1509.                         for(var i = 0; i < set.Handles.Count; ++i) {
  1510.                             currentValue.Collision = refList__scare2D_dot_Manifold2D_null[i];
  1511.                             yield return true;
  1512.                         }
  1513.                     }
  1514.                 }
  1515.             }
  1516.         }
  1517.         public scare2D.CollisionResponseSystem System => EntityWorld._scare2D_dot_CollisionResponseSystem_null;
  1518.         public EntityWorld EntityWorld { get; }
  1519.         public TypeSet Includes { get; }
  1520.         public TypeSet Excludes { get; }
  1521.         public IEntityWorld World => EntityWorld;
  1522.         public _scare2D_dot_CollisionResponseSystem_dot_ItemGroup_Collection(EntityWorld world) {
  1523.             EntityWorld = world;
  1524.             Includes = new TypeSet(typeof(scare2D.Manifold2D));
  1525.             Excludes = new TypeSet();
  1526.            
  1527.         }
  1528.         public IRefEnumerator<scare2D.CollisionResponseSystem.ItemGroup> GetEnumerator() => new _scare2D_dot_CollisionResponseSystem_dot_ItemGroup_Enumerator(this);
  1529.         public IRefEnumerable<scare2D.CollisionResponseSystem.ItemGroup> WithFilter(Func<SharedDataType, bool> filter) => new RefEnumeratorWrapper<scare2D.CollisionResponseSystem.ItemGroup>(new _scare2D_dot_CollisionResponseSystem_dot_ItemGroup_Enumerator_ReadOnlyFilter(this, filter));
  1530.     }
  1531.     public sealed class _scare2D_dot_ParticleEmitterRenderer_dot_ItemGroup_Collection : IComponentCollection<scare2D.ParticleEmitterRenderer.ItemGroup> {
  1532.         public sealed class _scare2D_dot_ParticleEmitterRenderer_dot_ItemGroup_Enumerator : IRefEnumerator<scare2D.ParticleEmitterRenderer.ItemGroup> {
  1533.             private _scare2D_dot_ParticleEmitterRenderer_dot_ItemGroup_Collection collection;
  1534.             private scare2D.ParticleEmitterRenderer.ItemGroup currentValue = new scare2D.ParticleEmitterRenderer.ItemGroup();
  1535.             private IEnumerator<bool> moveNextEnumerator;
  1536.             public _scare2D_dot_ParticleEmitterRenderer_dot_ItemGroup_Enumerator(_scare2D_dot_ParticleEmitterRenderer_dot_ItemGroup_Collection collection) {
  1537.                 this.collection = collection;
  1538.             }
  1539.             public ref scare2D.ParticleEmitterRenderer.ItemGroup Current => ref currentValue;
  1540.             public bool MoveNext() {
  1541.                 if(moveNextEnumerator == null) {
  1542.                     moveNextEnumerator = MoveNextInternal();
  1543.                 }
  1544.                 return moveNextEnumerator.MoveNext();
  1545.             }
  1546.             public IEnumerator<bool> MoveNextInternal() {
  1547.                 var handlesThatChangedSharedType = new RefList<EntityHandle>();
  1548.                 foreach(var setType in collection.EntityWorld.Entities.Components) {
  1549.                     bool keepSetType = setType.TypeSet.IsSupersetOf(collection.Includes);
  1550.                     if(keepSetType == false) continue;
  1551.                     foreach(var handle in handlesThatChangedSharedType) {
  1552.                         collection.World.Entities.Components.CheckSharedDataTypeFor(handle);
  1553.                     }
  1554.                     handlesThatChangedSharedType.Clear();
  1555.                     foreach(var set in setType) {
  1556.                         var refList__scare2D_dot_EntityHandle_null = set.GetRefList<scare2D.EntityHandle>();
  1557.                         var refList__scare2D_dot_Transform_null = set.GetRefList<scare2D.Transform>();
  1558.                         var refList__scare2D_dot_ParticleEmitter_null = set.GetRefList<scare2D.ParticleEmitter>();
  1559.                         System.String _scare2D_dot_ParticleEmitter_textureName = default;
  1560.                         if(set.Handles.Count > 0) {
  1561.                             _scare2D_dot_ParticleEmitter_textureName = refList__scare2D_dot_ParticleEmitter_null[0].textureName;
  1562.                             currentValue.handle = refList__scare2D_dot_EntityHandle_null[0];
  1563.                             currentValue.transform = refList__scare2D_dot_Transform_null[0];
  1564.                             currentValue.emitter = refList__scare2D_dot_ParticleEmitter_null[0];
  1565.                             collection.System.SetSharedState(currentValue, collection.EntityWorld._Microsoft_dot_Xna_dot_Framework_dot_Content_dot_ContentManager_null, collection.EntityWorld._Microsoft_dot_Xna_dot_Framework_dot_Graphics_dot_GraphicsDevice_null);
  1566.                         }
  1567.                         for(var i = 0; i < set.Handles.Count; ++i) {
  1568.                             currentValue.handle = refList__scare2D_dot_EntityHandle_null[i];
  1569.                             currentValue.transform = refList__scare2D_dot_Transform_null[i];
  1570.                             currentValue.emitter = refList__scare2D_dot_ParticleEmitter_null[i];
  1571.                             yield return true;
  1572.                             refList__scare2D_dot_Transform_null[i] = currentValue.transform;
  1573.                             refList__scare2D_dot_ParticleEmitter_null[i] = currentValue.emitter;
  1574.                             if(_scare2D_dot_ParticleEmitter_textureName != currentValue.emitter.textureName) {
  1575.                                 handlesThatChangedSharedType.Add(set.Handles[i]);
  1576.                             }
  1577.                         }
  1578.                     }
  1579.                 }
  1580.                 foreach(var handle in handlesThatChangedSharedType) {
  1581.                     collection.World.Entities.Components.CheckSharedDataTypeFor(handle);
  1582.                 }
  1583.             }
  1584.         }
  1585.         public sealed class _scare2D_dot_ParticleEmitterRenderer_dot_ItemGroup_Enumerator_ReadOnlyFilter : IRefEnumerator<scare2D.ParticleEmitterRenderer.ItemGroup> {
  1586.             private Func<SharedDataType, bool> filter;
  1587.             private _scare2D_dot_ParticleEmitterRenderer_dot_ItemGroup_Collection collection;
  1588.             private scare2D.ParticleEmitterRenderer.ItemGroup currentValue = new scare2D.ParticleEmitterRenderer.ItemGroup();
  1589.             private IEnumerator<bool> moveNextEnumerator;
  1590.             public _scare2D_dot_ParticleEmitterRenderer_dot_ItemGroup_Enumerator_ReadOnlyFilter(_scare2D_dot_ParticleEmitterRenderer_dot_ItemGroup_Collection collection, Func<SharedDataType, bool> filter) {
  1591.                 this.collection = collection;
  1592.                 this.filter = filter;
  1593.             }
  1594.             public ref scare2D.ParticleEmitterRenderer.ItemGroup Current => ref currentValue;
  1595.             public bool MoveNext() {
  1596.                 if(moveNextEnumerator == null) {
  1597.                     moveNextEnumerator = MoveNextInternal();
  1598.                 }
  1599.                 return moveNextEnumerator.MoveNext();
  1600.             }
  1601.             public IEnumerator<bool> MoveNextInternal() {
  1602.                 foreach(var setType in collection.EntityWorld.Entities.Components) {
  1603.                     bool keepSetType = setType.TypeSet.IsSupersetOf(collection.Includes);
  1604.                     if(keepSetType == false) continue;
  1605.                     foreach(var set in setType) {
  1606.                         if(filter(set.SharedDataType) == false) continue;
  1607.                         var refList__scare2D_dot_EntityHandle_null = set.GetRefList<scare2D.EntityHandle>();
  1608.                         var refList__scare2D_dot_Transform_null = set.GetRefList<scare2D.Transform>();
  1609.                         var refList__scare2D_dot_ParticleEmitter_null = set.GetRefList<scare2D.ParticleEmitter>();
  1610.                         if(set.Handles.Count > 0) {
  1611.                             currentValue.handle = refList__scare2D_dot_EntityHandle_null[0];
  1612.                             currentValue.transform = refList__scare2D_dot_Transform_null[0];
  1613.                             currentValue.emitter = refList__scare2D_dot_ParticleEmitter_null[0];
  1614.                             collection.System.SetSharedState(currentValue, collection.EntityWorld._Microsoft_dot_Xna_dot_Framework_dot_Content_dot_ContentManager_null, collection.EntityWorld._Microsoft_dot_Xna_dot_Framework_dot_Graphics_dot_GraphicsDevice_null);
  1615.                         }
  1616.                         for(var i = 0; i < set.Handles.Count; ++i) {
  1617.                             currentValue.handle = refList__scare2D_dot_EntityHandle_null[i];
  1618.                             currentValue.transform = refList__scare2D_dot_Transform_null[i];
  1619.                             currentValue.emitter = refList__scare2D_dot_ParticleEmitter_null[i];
  1620.                             yield return true;
  1621.                         }
  1622.                     }
  1623.                 }
  1624.             }
  1625.         }
  1626.         public scare2D.ParticleEmitterRenderer System => EntityWorld._scare2D_dot_ParticleEmitterRenderer_null;
  1627.         public EntityWorld EntityWorld { get; }
  1628.         public TypeSet Includes { get; }
  1629.         public TypeSet Excludes { get; }
  1630.         public IEntityWorld World => EntityWorld;
  1631.         public _scare2D_dot_ParticleEmitterRenderer_dot_ItemGroup_Collection(EntityWorld world) {
  1632.             EntityWorld = world;
  1633.             Includes = new TypeSet(typeof(scare2D.Transform), typeof(scare2D.ParticleEmitter));
  1634.             Excludes = new TypeSet();
  1635.            
  1636.         }
  1637.         public IRefEnumerator<scare2D.ParticleEmitterRenderer.ItemGroup> GetEnumerator() => new _scare2D_dot_ParticleEmitterRenderer_dot_ItemGroup_Enumerator(this);
  1638.         public IRefEnumerable<scare2D.ParticleEmitterRenderer.ItemGroup> WithFilter(Func<SharedDataType, bool> filter) => new RefEnumeratorWrapper<scare2D.ParticleEmitterRenderer.ItemGroup>(new _scare2D_dot_ParticleEmitterRenderer_dot_ItemGroup_Enumerator_ReadOnlyFilter(this, filter));
  1639.     }
  1640.     public sealed class _scare2D_dot_SpawnerSystem_dot_Group_Collection : IComponentCollection<scare2D.SpawnerSystem.Group> {
  1641.         public sealed class _scare2D_dot_SpawnerSystem_dot_Group_Enumerator : IRefEnumerator<scare2D.SpawnerSystem.Group> {
  1642.             private _scare2D_dot_SpawnerSystem_dot_Group_Collection collection;
  1643.             private scare2D.SpawnerSystem.Group currentValue = new scare2D.SpawnerSystem.Group();
  1644.             private IEnumerator<bool> moveNextEnumerator;
  1645.             public _scare2D_dot_SpawnerSystem_dot_Group_Enumerator(_scare2D_dot_SpawnerSystem_dot_Group_Collection collection) {
  1646.                 this.collection = collection;
  1647.             }
  1648.             public ref scare2D.SpawnerSystem.Group Current => ref currentValue;
  1649.             public bool MoveNext() {
  1650.                 if(moveNextEnumerator == null) {
  1651.                     moveNextEnumerator = MoveNextInternal();
  1652.                 }
  1653.                 return moveNextEnumerator.MoveNext();
  1654.             }
  1655.             public IEnumerator<bool> MoveNextInternal() {
  1656.                 foreach(var setType in collection.EntityWorld.Entities.Components) {
  1657.                     bool keepSetType = setType.TypeSet.IsSupersetOf(collection.Includes);
  1658.                     if(keepSetType == false) continue;
  1659.                     foreach(var set in setType) {
  1660.                         var refList__scare2D_dot_Transform_null = set.GetRefList<scare2D.Transform>();
  1661.                         var refList__scare2D_dot_Spawner_null = set.GetRefList<scare2D.Spawner>();
  1662.                         for(var i = 0; i < set.Handles.Count; ++i) {
  1663.                             currentValue.transform = refList__scare2D_dot_Transform_null[i];
  1664.                             currentValue.spawner = refList__scare2D_dot_Spawner_null[i];
  1665.                             yield return true;
  1666.                             refList__scare2D_dot_Transform_null[i] = currentValue.transform;
  1667.                             refList__scare2D_dot_Spawner_null[i] = currentValue.spawner;
  1668.                         }
  1669.                     }
  1670.                 }
  1671.             }
  1672.         }
  1673.         public sealed class _scare2D_dot_SpawnerSystem_dot_Group_Enumerator_ReadOnlyFilter : IRefEnumerator<scare2D.SpawnerSystem.Group> {
  1674.             private Func<SharedDataType, bool> filter;
  1675.             private _scare2D_dot_SpawnerSystem_dot_Group_Collection collection;
  1676.             private scare2D.SpawnerSystem.Group currentValue = new scare2D.SpawnerSystem.Group();
  1677.             private IEnumerator<bool> moveNextEnumerator;
  1678.             public _scare2D_dot_SpawnerSystem_dot_Group_Enumerator_ReadOnlyFilter(_scare2D_dot_SpawnerSystem_dot_Group_Collection collection, Func<SharedDataType, bool> filter) {
  1679.                 this.collection = collection;
  1680.                 this.filter = filter;
  1681.             }
  1682.             public ref scare2D.SpawnerSystem.Group Current => ref currentValue;
  1683.             public bool MoveNext() {
  1684.                 if(moveNextEnumerator == null) {
  1685.                     moveNextEnumerator = MoveNextInternal();
  1686.                 }
  1687.                 return moveNextEnumerator.MoveNext();
  1688.             }
  1689.             public IEnumerator<bool> MoveNextInternal() {
  1690.                 foreach(var setType in collection.EntityWorld.Entities.Components) {
  1691.                     bool keepSetType = setType.TypeSet.IsSupersetOf(collection.Includes);
  1692.                     if(keepSetType == false) continue;
  1693.                     foreach(var set in setType) {
  1694.                         if(filter(set.SharedDataType) == false) continue;
  1695.                         var refList__scare2D_dot_Transform_null = set.GetRefList<scare2D.Transform>();
  1696.                         var refList__scare2D_dot_Spawner_null = set.GetRefList<scare2D.Spawner>();
  1697.                         for(var i = 0; i < set.Handles.Count; ++i) {
  1698.                             currentValue.transform = refList__scare2D_dot_Transform_null[i];
  1699.                             currentValue.spawner = refList__scare2D_dot_Spawner_null[i];
  1700.                             yield return true;
  1701.                         }
  1702.                     }
  1703.                 }
  1704.             }
  1705.         }
  1706.         public scare2D.SpawnerSystem System => EntityWorld._scare2D_dot_SpawnerSystem_null;
  1707.         public EntityWorld EntityWorld { get; }
  1708.         public TypeSet Includes { get; }
  1709.         public TypeSet Excludes { get; }
  1710.         public IEntityWorld World => EntityWorld;
  1711.         public _scare2D_dot_SpawnerSystem_dot_Group_Collection(EntityWorld world) {
  1712.             EntityWorld = world;
  1713.             Includes = new TypeSet(typeof(scare2D.Transform), typeof(scare2D.Spawner));
  1714.             Excludes = new TypeSet();
  1715.            
  1716.         }
  1717.         public IRefEnumerator<scare2D.SpawnerSystem.Group> GetEnumerator() => new _scare2D_dot_SpawnerSystem_dot_Group_Enumerator(this);
  1718.         public IRefEnumerable<scare2D.SpawnerSystem.Group> WithFilter(Func<SharedDataType, bool> filter) => new RefEnumeratorWrapper<scare2D.SpawnerSystem.Group>(new _scare2D_dot_SpawnerSystem_dot_Group_Enumerator_ReadOnlyFilter(this, filter));
  1719.     }
  1720.     public sealed class _scare2D_dot_LifeTimeSystem_dot_Group_Collection : IComponentCollection<scare2D.LifeTimeSystem.Group> {
  1721.         public sealed class _scare2D_dot_LifeTimeSystem_dot_Group_Enumerator : IRefEnumerator<scare2D.LifeTimeSystem.Group> {
  1722.             private _scare2D_dot_LifeTimeSystem_dot_Group_Collection collection;
  1723.             private scare2D.LifeTimeSystem.Group currentValue = new scare2D.LifeTimeSystem.Group();
  1724.             private IEnumerator<bool> moveNextEnumerator;
  1725.             public _scare2D_dot_LifeTimeSystem_dot_Group_Enumerator(_scare2D_dot_LifeTimeSystem_dot_Group_Collection collection) {
  1726.                 this.collection = collection;
  1727.             }
  1728.             public ref scare2D.LifeTimeSystem.Group Current => ref currentValue;
  1729.             public bool MoveNext() {
  1730.                 if(moveNextEnumerator == null) {
  1731.                     moveNextEnumerator = MoveNextInternal();
  1732.                 }
  1733.                 return moveNextEnumerator.MoveNext();
  1734.             }
  1735.             public IEnumerator<bool> MoveNextInternal() {
  1736.                 foreach(var setType in collection.EntityWorld.Entities.Components) {
  1737.                     bool keepSetType = setType.TypeSet.IsSupersetOf(collection.Includes);
  1738.                     if(keepSetType == false) continue;
  1739.                     foreach(var set in setType) {
  1740.                         var refList__scare2D_dot_EntityHandle_null = set.GetRefList<scare2D.EntityHandle>();
  1741.                         var refList__scare2D_dot_LifeTime_null = set.GetRefList<scare2D.LifeTime>();
  1742.                         for(var i = 0; i < set.Handles.Count; ++i) {
  1743.                             currentValue.handle = refList__scare2D_dot_EntityHandle_null[i];
  1744.                             currentValue.lifeTime = refList__scare2D_dot_LifeTime_null[i];
  1745.                             yield return true;
  1746.                             refList__scare2D_dot_LifeTime_null[i] = currentValue.lifeTime;
  1747.                         }
  1748.                     }
  1749.                 }
  1750.             }
  1751.         }
  1752.         public sealed class _scare2D_dot_LifeTimeSystem_dot_Group_Enumerator_ReadOnlyFilter : IRefEnumerator<scare2D.LifeTimeSystem.Group> {
  1753.             private Func<SharedDataType, bool> filter;
  1754.             private _scare2D_dot_LifeTimeSystem_dot_Group_Collection collection;
  1755.             private scare2D.LifeTimeSystem.Group currentValue = new scare2D.LifeTimeSystem.Group();
  1756.             private IEnumerator<bool> moveNextEnumerator;
  1757.             public _scare2D_dot_LifeTimeSystem_dot_Group_Enumerator_ReadOnlyFilter(_scare2D_dot_LifeTimeSystem_dot_Group_Collection collection, Func<SharedDataType, bool> filter) {
  1758.                 this.collection = collection;
  1759.                 this.filter = filter;
  1760.             }
  1761.             public ref scare2D.LifeTimeSystem.Group Current => ref currentValue;
  1762.             public bool MoveNext() {
  1763.                 if(moveNextEnumerator == null) {
  1764.                     moveNextEnumerator = MoveNextInternal();
  1765.                 }
  1766.                 return moveNextEnumerator.MoveNext();
  1767.             }
  1768.             public IEnumerator<bool> MoveNextInternal() {
  1769.                 foreach(var setType in collection.EntityWorld.Entities.Components) {
  1770.                     bool keepSetType = setType.TypeSet.IsSupersetOf(collection.Includes);
  1771.                     if(keepSetType == false) continue;
  1772.                     foreach(var set in setType) {
  1773.                         if(filter(set.SharedDataType) == false) continue;
  1774.                         var refList__scare2D_dot_EntityHandle_null = set.GetRefList<scare2D.EntityHandle>();
  1775.                         var refList__scare2D_dot_LifeTime_null = set.GetRefList<scare2D.LifeTime>();
  1776.                         for(var i = 0; i < set.Handles.Count; ++i) {
  1777.                             currentValue.handle = refList__scare2D_dot_EntityHandle_null[i];
  1778.                             currentValue.lifeTime = refList__scare2D_dot_LifeTime_null[i];
  1779.                             yield return true;
  1780.                         }
  1781.                     }
  1782.                 }
  1783.             }
  1784.         }
  1785.         public scare2D.LifeTimeSystem System => EntityWorld._scare2D_dot_LifeTimeSystem_null;
  1786.         public EntityWorld EntityWorld { get; }
  1787.         public TypeSet Includes { get; }
  1788.         public TypeSet Excludes { get; }
  1789.         public IEntityWorld World => EntityWorld;
  1790.         public _scare2D_dot_LifeTimeSystem_dot_Group_Collection(EntityWorld world) {
  1791.             EntityWorld = world;
  1792.             Includes = new TypeSet(typeof(scare2D.LifeTime));
  1793.             Excludes = new TypeSet();
  1794.            
  1795.         }
  1796.         public IRefEnumerator<scare2D.LifeTimeSystem.Group> GetEnumerator() => new _scare2D_dot_LifeTimeSystem_dot_Group_Enumerator(this);
  1797.         public IRefEnumerable<scare2D.LifeTimeSystem.Group> WithFilter(Func<SharedDataType, bool> filter) => new RefEnumeratorWrapper<scare2D.LifeTimeSystem.Group>(new _scare2D_dot_LifeTimeSystem_dot_Group_Enumerator_ReadOnlyFilter(this, filter));
  1798.     }
  1799.     public sealed class _scare2D_dot_PingPongSystem_dot_PingPong_Collection : IComponentCollection<scare2D.PingPongSystem.PingPong> {
  1800.         public sealed class _scare2D_dot_PingPongSystem_dot_PingPong_Enumerator : IRefEnumerator<scare2D.PingPongSystem.PingPong> {
  1801.             private _scare2D_dot_PingPongSystem_dot_PingPong_Collection collection;
  1802.             private scare2D.PingPongSystem.PingPong currentValue = new scare2D.PingPongSystem.PingPong();
  1803.             private IEnumerator<bool> moveNextEnumerator;
  1804.             public _scare2D_dot_PingPongSystem_dot_PingPong_Enumerator(_scare2D_dot_PingPongSystem_dot_PingPong_Collection collection) {
  1805.                 this.collection = collection;
  1806.             }
  1807.             public ref scare2D.PingPongSystem.PingPong Current => ref currentValue;
  1808.             public bool MoveNext() {
  1809.                 if(moveNextEnumerator == null) {
  1810.                     moveNextEnumerator = MoveNextInternal();
  1811.                 }
  1812.                 return moveNextEnumerator.MoveNext();
  1813.             }
  1814.             public IEnumerator<bool> MoveNextInternal() {
  1815.                 var handlesThatChangedSharedType = new RefList<EntityHandle>();
  1816.                 foreach(var setType in collection.EntityWorld.Entities.Components) {
  1817.                     bool keepSetType = setType.TypeSet.IsSupersetOf(collection.Includes);
  1818.                     if(keepSetType == false) continue;
  1819.                     foreach(var handle in handlesThatChangedSharedType) {
  1820.                         collection.World.Entities.Components.CheckSharedDataTypeFor(handle);
  1821.                     }
  1822.                     handlesThatChangedSharedType.Clear();
  1823.                     foreach(var set in setType) {
  1824.                         var refList__scare2D_dot_Transform_null = set.GetRefList<scare2D.Transform>();
  1825.                         var refList__scare2D_dot_BoxCollider_null = set.GetRefList<scare2D.BoxCollider>();
  1826.                         var refList__scare2D_dot_PingPongComponent_null = set.GetRefList<scare2D.PingPongComponent>();
  1827.                         System.Boolean _scare2D_dot_BoxCollider_canCollide = default;
  1828.                         if(set.Handles.Count > 0) {
  1829.                             _scare2D_dot_BoxCollider_canCollide = refList__scare2D_dot_BoxCollider_null[0].canCollide;
  1830.                         }
  1831.                         for(var i = 0; i < set.Handles.Count; ++i) {
  1832.                             currentValue.transform = refList__scare2D_dot_Transform_null[i];
  1833.                             currentValue.collider = refList__scare2D_dot_BoxCollider_null[i];
  1834.                             currentValue.ball = refList__scare2D_dot_PingPongComponent_null[i];
  1835.                             yield return true;
  1836.                             refList__scare2D_dot_Transform_null[i] = currentValue.transform;
  1837.                             refList__scare2D_dot_BoxCollider_null[i] = currentValue.collider;
  1838.                             refList__scare2D_dot_PingPongComponent_null[i] = currentValue.ball;
  1839.                             if(object.Equals(_scare2D_dot_BoxCollider_canCollide, currentValue.collider.canCollide) == false) {
  1840.                                 handlesThatChangedSharedType.Add(set.Handles[i]);
  1841.                             }
  1842.                         }
  1843.                     }
  1844.                 }
  1845.                 foreach(var handle in handlesThatChangedSharedType) {
  1846.                     collection.World.Entities.Components.CheckSharedDataTypeFor(handle);
  1847.                 }
  1848.             }
  1849.         }
  1850.         public sealed class _scare2D_dot_PingPongSystem_dot_PingPong_Enumerator_ReadOnlyFilter : IRefEnumerator<scare2D.PingPongSystem.PingPong> {
  1851.             private Func<SharedDataType, bool> filter;
  1852.             private _scare2D_dot_PingPongSystem_dot_PingPong_Collection collection;
  1853.             private scare2D.PingPongSystem.PingPong currentValue = new scare2D.PingPongSystem.PingPong();
  1854.             private IEnumerator<bool> moveNextEnumerator;
  1855.             public _scare2D_dot_PingPongSystem_dot_PingPong_Enumerator_ReadOnlyFilter(_scare2D_dot_PingPongSystem_dot_PingPong_Collection collection, Func<SharedDataType, bool> filter) {
  1856.                 this.collection = collection;
  1857.                 this.filter = filter;
  1858.             }
  1859.             public ref scare2D.PingPongSystem.PingPong Current => ref currentValue;
  1860.             public bool MoveNext() {
  1861.                 if(moveNextEnumerator == null) {
  1862.                     moveNextEnumerator = MoveNextInternal();
  1863.                 }
  1864.                 return moveNextEnumerator.MoveNext();
  1865.             }
  1866.             public IEnumerator<bool> MoveNextInternal() {
  1867.                 foreach(var setType in collection.EntityWorld.Entities.Components) {
  1868.                     bool keepSetType = setType.TypeSet.IsSupersetOf(collection.Includes);
  1869.                     if(keepSetType == false) continue;
  1870.                     foreach(var set in setType) {
  1871.                         if(filter(set.SharedDataType) == false) continue;
  1872.                         var refList__scare2D_dot_Transform_null = set.GetRefList<scare2D.Transform>();
  1873.                         var refList__scare2D_dot_BoxCollider_null = set.GetRefList<scare2D.BoxCollider>();
  1874.                         var refList__scare2D_dot_PingPongComponent_null = set.GetRefList<scare2D.PingPongComponent>();
  1875.                         if(set.Handles.Count > 0) {
  1876.                         }
  1877.                         for(var i = 0; i < set.Handles.Count; ++i) {
  1878.                             currentValue.transform = refList__scare2D_dot_Transform_null[i];
  1879.                             currentValue.collider = refList__scare2D_dot_BoxCollider_null[i];
  1880.                             currentValue.ball = refList__scare2D_dot_PingPongComponent_null[i];
  1881.                             yield return true;
  1882.                         }
  1883.                     }
  1884.                 }
  1885.             }
  1886.         }
  1887.         public scare2D.PingPongSystem System => EntityWorld._scare2D_dot_PingPongSystem_null;
  1888.         public EntityWorld EntityWorld { get; }
  1889.         public TypeSet Includes { get; }
  1890.         public TypeSet Excludes { get; }
  1891.         public IEntityWorld World => EntityWorld;
  1892.         public _scare2D_dot_PingPongSystem_dot_PingPong_Collection(EntityWorld world) {
  1893.             EntityWorld = world;
  1894.             Includes = new TypeSet(typeof(scare2D.Transform), typeof(scare2D.BoxCollider), typeof(scare2D.PingPongComponent));
  1895.             Excludes = new TypeSet();
  1896.            
  1897.         }
  1898.         public IRefEnumerator<scare2D.PingPongSystem.PingPong> GetEnumerator() => new _scare2D_dot_PingPongSystem_dot_PingPong_Enumerator(this);
  1899.         public IRefEnumerable<scare2D.PingPongSystem.PingPong> WithFilter(Func<SharedDataType, bool> filter) => new RefEnumeratorWrapper<scare2D.PingPongSystem.PingPong>(new _scare2D_dot_PingPongSystem_dot_PingPong_Enumerator_ReadOnlyFilter(this, filter));
  1900.     }
  1901.     public sealed class _scare2D_dot_SpriteRendererSystem_dot_ItemGroup_Collection : IComponentCollection<scare2D.SpriteRendererSystem.ItemGroup> {
  1902.         public sealed class _scare2D_dot_SpriteRendererSystem_dot_ItemGroup_Enumerator : IRefEnumerator<scare2D.SpriteRendererSystem.ItemGroup> {
  1903.             private _scare2D_dot_SpriteRendererSystem_dot_ItemGroup_Collection collection;
  1904.             private scare2D.SpriteRendererSystem.ItemGroup currentValue = new scare2D.SpriteRendererSystem.ItemGroup();
  1905.             private IEnumerator<bool> moveNextEnumerator;
  1906.             public _scare2D_dot_SpriteRendererSystem_dot_ItemGroup_Enumerator(_scare2D_dot_SpriteRendererSystem_dot_ItemGroup_Collection collection) {
  1907.                 this.collection = collection;
  1908.             }
  1909.             public ref scare2D.SpriteRendererSystem.ItemGroup Current => ref currentValue;
  1910.             public bool MoveNext() {
  1911.                 if(moveNextEnumerator == null) {
  1912.                     moveNextEnumerator = MoveNextInternal();
  1913.                 }
  1914.                 return moveNextEnumerator.MoveNext();
  1915.             }
  1916.             public IEnumerator<bool> MoveNextInternal() {
  1917.                 foreach(var setType in collection.EntityWorld.Entities.Components) {
  1918.                     bool keepSetType = setType.TypeSet.IsSupersetOf(collection.Includes);
  1919.                     if(keepSetType == false) continue;
  1920.                     foreach(var set in setType) {
  1921.                         var refList__scare2D_dot_Transform_null = set.GetRefList<scare2D.Transform>();
  1922.                         var refList__scare2D_dot_BoxCollider_null = set.GetRefList<scare2D.BoxCollider>();
  1923.                         var refList__scare2D_dot_SpriteRenderer_null = set.GetRefList<scare2D.SpriteRenderer>();
  1924.                         if(set.Handles.Count > 0) {
  1925.                             currentValue.transform = refList__scare2D_dot_Transform_null[0];
  1926.                             currentValue.collider = refList__scare2D_dot_BoxCollider_null[0];
  1927.                             currentValue.renderer = refList__scare2D_dot_SpriteRenderer_null[0];
  1928.                             collection.System.SetSharedState(currentValue, collection.EntityWorld._Microsoft_dot_Xna_dot_Framework_dot_Content_dot_ContentManager_null);
  1929.                         }
  1930.                         for(var i = 0; i < set.Handles.Count; ++i) {
  1931.                             currentValue.transform = refList__scare2D_dot_Transform_null[i];
  1932.                             currentValue.collider = refList__scare2D_dot_BoxCollider_null[i];
  1933.                             currentValue.renderer = refList__scare2D_dot_SpriteRenderer_null[i];
  1934.                             yield return true;
  1935.                         }
  1936.                     }
  1937.                 }
  1938.             }
  1939.         }
  1940.         public sealed class _scare2D_dot_SpriteRendererSystem_dot_ItemGroup_Enumerator_ReadOnlyFilter : IRefEnumerator<scare2D.SpriteRendererSystem.ItemGroup> {
  1941.             private Func<SharedDataType, bool> filter;
  1942.             private _scare2D_dot_SpriteRendererSystem_dot_ItemGroup_Collection collection;
  1943.             private scare2D.SpriteRendererSystem.ItemGroup currentValue = new scare2D.SpriteRendererSystem.ItemGroup();
  1944.             private IEnumerator<bool> moveNextEnumerator;
  1945.             public _scare2D_dot_SpriteRendererSystem_dot_ItemGroup_Enumerator_ReadOnlyFilter(_scare2D_dot_SpriteRendererSystem_dot_ItemGroup_Collection collection, Func<SharedDataType, bool> filter) {
  1946.                 this.collection = collection;
  1947.                 this.filter = filter;
  1948.             }
  1949.             public ref scare2D.SpriteRendererSystem.ItemGroup Current => ref currentValue;
  1950.             public bool MoveNext() {
  1951.                 if(moveNextEnumerator == null) {
  1952.                     moveNextEnumerator = MoveNextInternal();
  1953.                 }
  1954.                 return moveNextEnumerator.MoveNext();
  1955.             }
  1956.             public IEnumerator<bool> MoveNextInternal() {
  1957.                 foreach(var setType in collection.EntityWorld.Entities.Components) {
  1958.                     bool keepSetType = setType.TypeSet.IsSupersetOf(collection.Includes);
  1959.                     if(keepSetType == false) continue;
  1960.                     foreach(var set in setType) {
  1961.                         if(filter(set.SharedDataType) == false) continue;
  1962.                         var refList__scare2D_dot_Transform_null = set.GetRefList<scare2D.Transform>();
  1963.                         var refList__scare2D_dot_BoxCollider_null = set.GetRefList<scare2D.BoxCollider>();
  1964.                         var refList__scare2D_dot_SpriteRenderer_null = set.GetRefList<scare2D.SpriteRenderer>();
  1965.                         if(set.Handles.Count > 0) {
  1966.                             currentValue.transform = refList__scare2D_dot_Transform_null[0];
  1967.                             currentValue.collider = refList__scare2D_dot_BoxCollider_null[0];
  1968.                             currentValue.renderer = refList__scare2D_dot_SpriteRenderer_null[0];
  1969.                             collection.System.SetSharedState(currentValue, collection.EntityWorld._Microsoft_dot_Xna_dot_Framework_dot_Content_dot_ContentManager_null);
  1970.                         }
  1971.                         for(var i = 0; i < set.Handles.Count; ++i) {
  1972.                             currentValue.transform = refList__scare2D_dot_Transform_null[i];
  1973.                             currentValue.collider = refList__scare2D_dot_BoxCollider_null[i];
  1974.                             currentValue.renderer = refList__scare2D_dot_SpriteRenderer_null[i];
  1975.                             yield return true;
  1976.                         }
  1977.                     }
  1978.                 }
  1979.             }
  1980.         }
  1981.         public scare2D.SpriteRendererSystem System => EntityWorld._scare2D_dot_SpriteRendererSystem_null;
  1982.         public EntityWorld EntityWorld { get; }
  1983.         public TypeSet Includes { get; }
  1984.         public TypeSet Excludes { get; }
  1985.         public IEntityWorld World => EntityWorld;
  1986.         public _scare2D_dot_SpriteRendererSystem_dot_ItemGroup_Collection(EntityWorld world) {
  1987.             EntityWorld = world;
  1988.             Includes = new TypeSet(typeof(scare2D.Transform), typeof(scare2D.BoxCollider), typeof(scare2D.SpriteRenderer));
  1989.             Excludes = new TypeSet();
  1990.            
  1991.         }
  1992.         public IRefEnumerator<scare2D.SpriteRendererSystem.ItemGroup> GetEnumerator() => new _scare2D_dot_SpriteRendererSystem_dot_ItemGroup_Enumerator(this);
  1993.         public IRefEnumerable<scare2D.SpriteRendererSystem.ItemGroup> WithFilter(Func<SharedDataType, bool> filter) => new RefEnumeratorWrapper<scare2D.SpriteRendererSystem.ItemGroup>(new _scare2D_dot_SpriteRendererSystem_dot_ItemGroup_Enumerator_ReadOnlyFilter(this, filter));
  1994.     }
  1995.     public sealed class _scare2D_dot_SpriteRendererSystem_dot_ItemGroup2_Collection : IComponentCollection<scare2D.SpriteRendererSystem.ItemGroup2> {
  1996.         public sealed class _scare2D_dot_SpriteRendererSystem_dot_ItemGroup2_Enumerator : IRefEnumerator<scare2D.SpriteRendererSystem.ItemGroup2> {
  1997.             private _scare2D_dot_SpriteRendererSystem_dot_ItemGroup2_Collection collection;
  1998.             private scare2D.SpriteRendererSystem.ItemGroup2 currentValue = new scare2D.SpriteRendererSystem.ItemGroup2();
  1999.             private IEnumerator<bool> moveNextEnumerator;
  2000.             public _scare2D_dot_SpriteRendererSystem_dot_ItemGroup2_Enumerator(_scare2D_dot_SpriteRendererSystem_dot_ItemGroup2_Collection collection) {
  2001.                 this.collection = collection;
  2002.             }
  2003.             public ref scare2D.SpriteRendererSystem.ItemGroup2 Current => ref currentValue;
  2004.             public bool MoveNext() {
  2005.                 if(moveNextEnumerator == null) {
  2006.                     moveNextEnumerator = MoveNextInternal();
  2007.                 }
  2008.                 return moveNextEnumerator.MoveNext();
  2009.             }
  2010.             public IEnumerator<bool> MoveNextInternal() {
  2011.                 foreach(var setType in collection.EntityWorld.Entities.Components) {
  2012.                     bool keepSetType = setType.TypeSet.IsSupersetOf(collection.Includes);
  2013.                     if(keepSetType == false) continue;
  2014.                     foreach(var set in setType) {
  2015.                         var refList__scare2D_dot_Transform2D_null = set.GetRefList<scare2D.Transform2D>();
  2016.                         var refList__scare2D_dot_SpriteRenderer_null = set.GetRefList<scare2D.SpriteRenderer>();
  2017.                         if(set.Handles.Count > 0) {
  2018.                             currentValue.Transform = refList__scare2D_dot_Transform2D_null[0];
  2019.                             currentValue.SpriteRenderer = refList__scare2D_dot_SpriteRenderer_null[0];
  2020.                             collection.System.SetSharedState(currentValue, collection.EntityWorld._Microsoft_dot_Xna_dot_Framework_dot_Content_dot_ContentManager_null);
  2021.                         }
  2022.                         for(var i = 0; i < set.Handles.Count; ++i) {
  2023.                             currentValue.Transform = refList__scare2D_dot_Transform2D_null[i];
  2024.                             currentValue.SpriteRenderer = refList__scare2D_dot_SpriteRenderer_null[i];
  2025.                             yield return true;
  2026.                         }
  2027.                     }
  2028.                 }
  2029.             }
  2030.         }
  2031.         public sealed class _scare2D_dot_SpriteRendererSystem_dot_ItemGroup2_Enumerator_ReadOnlyFilter : IRefEnumerator<scare2D.SpriteRendererSystem.ItemGroup2> {
  2032.             private Func<SharedDataType, bool> filter;
  2033.             private _scare2D_dot_SpriteRendererSystem_dot_ItemGroup2_Collection collection;
  2034.             private scare2D.SpriteRendererSystem.ItemGroup2 currentValue = new scare2D.SpriteRendererSystem.ItemGroup2();
  2035.             private IEnumerator<bool> moveNextEnumerator;
  2036.             public _scare2D_dot_SpriteRendererSystem_dot_ItemGroup2_Enumerator_ReadOnlyFilter(_scare2D_dot_SpriteRendererSystem_dot_ItemGroup2_Collection collection, Func<SharedDataType, bool> filter) {
  2037.                 this.collection = collection;
  2038.                 this.filter = filter;
  2039.             }
  2040.             public ref scare2D.SpriteRendererSystem.ItemGroup2 Current => ref currentValue;
  2041.             public bool MoveNext() {
  2042.                 if(moveNextEnumerator == null) {
  2043.                     moveNextEnumerator = MoveNextInternal();
  2044.                 }
  2045.                 return moveNextEnumerator.MoveNext();
  2046.             }
  2047.             public IEnumerator<bool> MoveNextInternal() {
  2048.                 foreach(var setType in collection.EntityWorld.Entities.Components) {
  2049.                     bool keepSetType = setType.TypeSet.IsSupersetOf(collection.Includes);
  2050.                     if(keepSetType == false) continue;
  2051.                     foreach(var set in setType) {
  2052.                         if(filter(set.SharedDataType) == false) continue;
  2053.                         var refList__scare2D_dot_Transform2D_null = set.GetRefList<scare2D.Transform2D>();
  2054.                         var refList__scare2D_dot_SpriteRenderer_null = set.GetRefList<scare2D.SpriteRenderer>();
  2055.                         if(set.Handles.Count > 0) {
  2056.                             currentValue.Transform = refList__scare2D_dot_Transform2D_null[0];
  2057.                             currentValue.SpriteRenderer = refList__scare2D_dot_SpriteRenderer_null[0];
  2058.                             collection.System.SetSharedState(currentValue, collection.EntityWorld._Microsoft_dot_Xna_dot_Framework_dot_Content_dot_ContentManager_null);
  2059.                         }
  2060.                         for(var i = 0; i < set.Handles.Count; ++i) {
  2061.                             currentValue.Transform = refList__scare2D_dot_Transform2D_null[i];
  2062.                             currentValue.SpriteRenderer = refList__scare2D_dot_SpriteRenderer_null[i];
  2063.                             yield return true;
  2064.                         }
  2065.                     }
  2066.                 }
  2067.             }
  2068.         }
  2069.         public scare2D.SpriteRendererSystem System => EntityWorld._scare2D_dot_SpriteRendererSystem_null;
  2070.         public EntityWorld EntityWorld { get; }
  2071.         public TypeSet Includes { get; }
  2072.         public TypeSet Excludes { get; }
  2073.         public IEntityWorld World => EntityWorld;
  2074.         public _scare2D_dot_SpriteRendererSystem_dot_ItemGroup2_Collection(EntityWorld world) {
  2075.             EntityWorld = world;
  2076.             Includes = new TypeSet(typeof(scare2D.Transform2D), typeof(scare2D.SpriteRenderer));
  2077.             Excludes = new TypeSet();
  2078.            
  2079.         }
  2080.         public IRefEnumerator<scare2D.SpriteRendererSystem.ItemGroup2> GetEnumerator() => new _scare2D_dot_SpriteRendererSystem_dot_ItemGroup2_Enumerator(this);
  2081.         public IRefEnumerable<scare2D.SpriteRendererSystem.ItemGroup2> WithFilter(Func<SharedDataType, bool> filter) => new RefEnumeratorWrapper<scare2D.SpriteRendererSystem.ItemGroup2>(new _scare2D_dot_SpriteRendererSystem_dot_ItemGroup2_Enumerator_ReadOnlyFilter(this, filter));
  2082.     }
  2083.     public sealed class _scare2D_dot_NameRendererSystem_dot_ItemGroup_Collection : IComponentCollection<scare2D.NameRendererSystem.ItemGroup> {
  2084.         public sealed class _scare2D_dot_NameRendererSystem_dot_ItemGroup_Enumerator : IRefEnumerator<scare2D.NameRendererSystem.ItemGroup> {
  2085.             private _scare2D_dot_NameRendererSystem_dot_ItemGroup_Collection collection;
  2086.             private scare2D.NameRendererSystem.ItemGroup currentValue = new scare2D.NameRendererSystem.ItemGroup();
  2087.             private IEnumerator<bool> moveNextEnumerator;
  2088.             public _scare2D_dot_NameRendererSystem_dot_ItemGroup_Enumerator(_scare2D_dot_NameRendererSystem_dot_ItemGroup_Collection collection) {
  2089.                 this.collection = collection;
  2090.             }
  2091.             public ref scare2D.NameRendererSystem.ItemGroup Current => ref currentValue;
  2092.             public bool MoveNext() {
  2093.                 if(moveNextEnumerator == null) {
  2094.                     moveNextEnumerator = MoveNextInternal();
  2095.                 }
  2096.                 return moveNextEnumerator.MoveNext();
  2097.             }
  2098.             public IEnumerator<bool> MoveNextInternal() {
  2099.                 foreach(var setType in collection.EntityWorld.Entities.Components) {
  2100.                     bool keepSetType = setType.TypeSet.IsSupersetOf(collection.Includes) && setType.TypeSet.GetIntersection(collection.Excludes).IsEmpty;
  2101.                     if(keepSetType == false) continue;
  2102.                     foreach(var set in setType) {
  2103.                         var refList__scare2D_dot_EntityHandle_null = set.GetRefList<scare2D.EntityHandle>();
  2104.                         var refList__scare2D_dot_EntityName_null = set.GetRefList<scare2D.EntityName>();
  2105.                         var refList__scare2D_dot_Transform_null = set.GetRefList<scare2D.Transform>();
  2106.                         for(var i = 0; i < set.Handles.Count; ++i) {
  2107.                             currentValue.handle = refList__scare2D_dot_EntityHandle_null[i];
  2108.                             currentValue.entityName = refList__scare2D_dot_EntityName_null[i];
  2109.                             currentValue.transform = refList__scare2D_dot_Transform_null[i];
  2110.                             yield return true;
  2111.                         }
  2112.                     }
  2113.                 }
  2114.             }
  2115.         }
  2116.         public sealed class _scare2D_dot_NameRendererSystem_dot_ItemGroup_Enumerator_ReadOnlyFilter : IRefEnumerator<scare2D.NameRendererSystem.ItemGroup> {
  2117.             private Func<SharedDataType, bool> filter;
  2118.             private _scare2D_dot_NameRendererSystem_dot_ItemGroup_Collection collection;
  2119.             private scare2D.NameRendererSystem.ItemGroup currentValue = new scare2D.NameRendererSystem.ItemGroup();
  2120.             private IEnumerator<bool> moveNextEnumerator;
  2121.             public _scare2D_dot_NameRendererSystem_dot_ItemGroup_Enumerator_ReadOnlyFilter(_scare2D_dot_NameRendererSystem_dot_ItemGroup_Collection collection, Func<SharedDataType, bool> filter) {
  2122.                 this.collection = collection;
  2123.                 this.filter = filter;
  2124.             }
  2125.             public ref scare2D.NameRendererSystem.ItemGroup Current => ref currentValue;
  2126.             public bool MoveNext() {
  2127.                 if(moveNextEnumerator == null) {
  2128.                     moveNextEnumerator = MoveNextInternal();
  2129.                 }
  2130.                 return moveNextEnumerator.MoveNext();
  2131.             }
  2132.             public IEnumerator<bool> MoveNextInternal() {
  2133.                 foreach(var setType in collection.EntityWorld.Entities.Components) {
  2134.                     bool keepSetType = setType.TypeSet.IsSupersetOf(collection.Includes) && setType.TypeSet.GetIntersection(collection.Excludes).IsEmpty;
  2135.                     if(keepSetType == false) continue;
  2136.                     foreach(var set in setType) {
  2137.                         if(filter(set.SharedDataType) == false) continue;
  2138.                         var refList__scare2D_dot_EntityHandle_null = set.GetRefList<scare2D.EntityHandle>();
  2139.                         var refList__scare2D_dot_EntityName_null = set.GetRefList<scare2D.EntityName>();
  2140.                         var refList__scare2D_dot_Transform_null = set.GetRefList<scare2D.Transform>();
  2141.                         for(var i = 0; i < set.Handles.Count; ++i) {
  2142.                             currentValue.handle = refList__scare2D_dot_EntityHandle_null[i];
  2143.                             currentValue.entityName = refList__scare2D_dot_EntityName_null[i];
  2144.                             currentValue.transform = refList__scare2D_dot_Transform_null[i];
  2145.                             yield return true;
  2146.                         }
  2147.                     }
  2148.                 }
  2149.             }
  2150.         }
  2151.         public scare2D.NameRendererSystem System => EntityWorld._scare2D_dot_NameRendererSystem_null;
  2152.         public EntityWorld EntityWorld { get; }
  2153.         public TypeSet Includes { get; }
  2154.         public TypeSet Excludes { get; }
  2155.         public IEntityWorld World => EntityWorld;
  2156.         public _scare2D_dot_NameRendererSystem_dot_ItemGroup_Collection(EntityWorld world) {
  2157.             EntityWorld = world;
  2158.             Includes = new TypeSet(typeof(scare2D.EntityName), typeof(scare2D.Transform));
  2159.             Excludes = new TypeSet(typeof(scare2D.BoxCollider));
  2160.            
  2161.         }
  2162.         public IRefEnumerator<scare2D.NameRendererSystem.ItemGroup> GetEnumerator() => new _scare2D_dot_NameRendererSystem_dot_ItemGroup_Enumerator(this);
  2163.         public IRefEnumerable<scare2D.NameRendererSystem.ItemGroup> WithFilter(Func<SharedDataType, bool> filter) => new RefEnumeratorWrapper<scare2D.NameRendererSystem.ItemGroup>(new _scare2D_dot_NameRendererSystem_dot_ItemGroup_Enumerator_ReadOnlyFilter(this, filter));
  2164.     }
  2165.     public sealed class _scare2D_dot_NameRendererSystem_dot_ItemGroup2_Collection : IComponentCollection<scare2D.NameRendererSystem.ItemGroup2> {
  2166.         public sealed class _scare2D_dot_NameRendererSystem_dot_ItemGroup2_Enumerator : IRefEnumerator<scare2D.NameRendererSystem.ItemGroup2> {
  2167.             private _scare2D_dot_NameRendererSystem_dot_ItemGroup2_Collection collection;
  2168.             private scare2D.NameRendererSystem.ItemGroup2 currentValue = new scare2D.NameRendererSystem.ItemGroup2();
  2169.             private IEnumerator<bool> moveNextEnumerator;
  2170.             public _scare2D_dot_NameRendererSystem_dot_ItemGroup2_Enumerator(_scare2D_dot_NameRendererSystem_dot_ItemGroup2_Collection collection) {
  2171.                 this.collection = collection;
  2172.             }
  2173.             public ref scare2D.NameRendererSystem.ItemGroup2 Current => ref currentValue;
  2174.             public bool MoveNext() {
  2175.                 if(moveNextEnumerator == null) {
  2176.                     moveNextEnumerator = MoveNextInternal();
  2177.                 }
  2178.                 return moveNextEnumerator.MoveNext();
  2179.             }
  2180.             public IEnumerator<bool> MoveNextInternal() {
  2181.                 foreach(var setType in collection.EntityWorld.Entities.Components) {
  2182.                     bool keepSetType = setType.TypeSet.IsSupersetOf(collection.Includes);
  2183.                     if(keepSetType == false) continue;
  2184.                     foreach(var set in setType) {
  2185.                         var refList__scare2D_dot_EntityHandle_null = set.GetRefList<scare2D.EntityHandle>();
  2186.                         var refList__scare2D_dot_EntityName_null = set.GetRefList<scare2D.EntityName>();
  2187.                         var refList__scare2D_dot_Transform_null = set.GetRefList<scare2D.Transform>();
  2188.                         var refList__scare2D_dot_BoxCollider_null = set.GetRefList<scare2D.BoxCollider>();
  2189.                         if(set.Handles.Count > 0) {
  2190.                         }
  2191.                         for(var i = 0; i < set.Handles.Count; ++i) {
  2192.                             currentValue.handle = refList__scare2D_dot_EntityHandle_null[i];
  2193.                             currentValue.entityName = refList__scare2D_dot_EntityName_null[i];
  2194.                             currentValue.transform = refList__scare2D_dot_Transform_null[i];
  2195.                             currentValue.collider = refList__scare2D_dot_BoxCollider_null[i];
  2196.                             yield return true;
  2197.                         }
  2198.                     }
  2199.                 }
  2200.             }
  2201.         }
  2202.         public sealed class _scare2D_dot_NameRendererSystem_dot_ItemGroup2_Enumerator_ReadOnlyFilter : IRefEnumerator<scare2D.NameRendererSystem.ItemGroup2> {
  2203.             private Func<SharedDataType, bool> filter;
  2204.             private _scare2D_dot_NameRendererSystem_dot_ItemGroup2_Collection collection;
  2205.             private scare2D.NameRendererSystem.ItemGroup2 currentValue = new scare2D.NameRendererSystem.ItemGroup2();
  2206.             private IEnumerator<bool> moveNextEnumerator;
  2207.             public _scare2D_dot_NameRendererSystem_dot_ItemGroup2_Enumerator_ReadOnlyFilter(_scare2D_dot_NameRendererSystem_dot_ItemGroup2_Collection collection, Func<SharedDataType, bool> filter) {
  2208.                 this.collection = collection;
  2209.                 this.filter = filter;
  2210.             }
  2211.             public ref scare2D.NameRendererSystem.ItemGroup2 Current => ref currentValue;
  2212.             public bool MoveNext() {
  2213.                 if(moveNextEnumerator == null) {
  2214.                     moveNextEnumerator = MoveNextInternal();
  2215.                 }
  2216.                 return moveNextEnumerator.MoveNext();
  2217.             }
  2218.             public IEnumerator<bool> MoveNextInternal() {
  2219.                 foreach(var setType in collection.EntityWorld.Entities.Components) {
  2220.                     bool keepSetType = setType.TypeSet.IsSupersetOf(collection.Includes);
  2221.                     if(keepSetType == false) continue;
  2222.                     foreach(var set in setType) {
  2223.                         if(filter(set.SharedDataType) == false) continue;
  2224.                         var refList__scare2D_dot_EntityHandle_null = set.GetRefList<scare2D.EntityHandle>();
  2225.                         var refList__scare2D_dot_EntityName_null = set.GetRefList<scare2D.EntityName>();
  2226.                         var refList__scare2D_dot_Transform_null = set.GetRefList<scare2D.Transform>();
  2227.                         var refList__scare2D_dot_BoxCollider_null = set.GetRefList<scare2D.BoxCollider>();
  2228.                         if(set.Handles.Count > 0) {
  2229.                         }
  2230.                         for(var i = 0; i < set.Handles.Count; ++i) {
  2231.                             currentValue.handle = refList__scare2D_dot_EntityHandle_null[i];
  2232.                             currentValue.entityName = refList__scare2D_dot_EntityName_null[i];
  2233.                             currentValue.transform = refList__scare2D_dot_Transform_null[i];
  2234.                             currentValue.collider = refList__scare2D_dot_BoxCollider_null[i];
  2235.                             yield return true;
  2236.                         }
  2237.                     }
  2238.                 }
  2239.             }
  2240.         }
  2241.         public scare2D.NameRendererSystem System => EntityWorld._scare2D_dot_NameRendererSystem_null;
  2242.         public EntityWorld EntityWorld { get; }
  2243.         public TypeSet Includes { get; }
  2244.         public TypeSet Excludes { get; }
  2245.         public IEntityWorld World => EntityWorld;
  2246.         public _scare2D_dot_NameRendererSystem_dot_ItemGroup2_Collection(EntityWorld world) {
  2247.             EntityWorld = world;
  2248.             Includes = new TypeSet(typeof(scare2D.EntityName), typeof(scare2D.Transform), typeof(scare2D.BoxCollider));
  2249.             Excludes = new TypeSet();
  2250.            
  2251.         }
  2252.         public IRefEnumerator<scare2D.NameRendererSystem.ItemGroup2> GetEnumerator() => new _scare2D_dot_NameRendererSystem_dot_ItemGroup2_Enumerator(this);
  2253.         public IRefEnumerable<scare2D.NameRendererSystem.ItemGroup2> WithFilter(Func<SharedDataType, bool> filter) => new RefEnumeratorWrapper<scare2D.NameRendererSystem.ItemGroup2>(new _scare2D_dot_NameRendererSystem_dot_ItemGroup2_Enumerator_ReadOnlyFilter(this, filter));
  2254.     }
  2255.     public sealed class _scare2D_dot_NameRendererSystem_dot_ItemGroup3_Collection : IComponentCollection<scare2D.NameRendererSystem.ItemGroup3> {
  2256.         public sealed class _scare2D_dot_NameRendererSystem_dot_ItemGroup3_Enumerator : IRefEnumerator<scare2D.NameRendererSystem.ItemGroup3> {
  2257.             private _scare2D_dot_NameRendererSystem_dot_ItemGroup3_Collection collection;
  2258.             private scare2D.NameRendererSystem.ItemGroup3 currentValue = new scare2D.NameRendererSystem.ItemGroup3();
  2259.             private IEnumerator<bool> moveNextEnumerator;
  2260.             public _scare2D_dot_NameRendererSystem_dot_ItemGroup3_Enumerator(_scare2D_dot_NameRendererSystem_dot_ItemGroup3_Collection collection) {
  2261.                 this.collection = collection;
  2262.             }
  2263.             public ref scare2D.NameRendererSystem.ItemGroup3 Current => ref currentValue;
  2264.             public bool MoveNext() {
  2265.                 if(moveNextEnumerator == null) {
  2266.                     moveNextEnumerator = MoveNextInternal();
  2267.                 }
  2268.                 return moveNextEnumerator.MoveNext();
  2269.             }
  2270.             public IEnumerator<bool> MoveNextInternal() {
  2271.                 foreach(var setType in collection.EntityWorld.Entities.Components) {
  2272.                     bool keepSetType = setType.TypeSet.IsSupersetOf(collection.Includes) && setType.TypeSet.GetIntersection(collection.Excludes).IsEmpty;
  2273.                     if(keepSetType == false) continue;
  2274.                     foreach(var set in setType) {
  2275.                         var refList__scare2D_dot_EntityHandle_null = set.GetRefList<scare2D.EntityHandle>();
  2276.                         var refList__scare2D_dot_Transform_null = set.GetRefList<scare2D.Transform>();
  2277.                         for(var i = 0; i < set.Handles.Count; ++i) {
  2278.                             currentValue.handle = refList__scare2D_dot_EntityHandle_null[i];
  2279.                             currentValue.transform = refList__scare2D_dot_Transform_null[i];
  2280.                             yield return true;
  2281.                         }
  2282.                     }
  2283.                 }
  2284.             }
  2285.         }
  2286.         public sealed class _scare2D_dot_NameRendererSystem_dot_ItemGroup3_Enumerator_ReadOnlyFilter : IRefEnumerator<scare2D.NameRendererSystem.ItemGroup3> {
  2287.             private Func<SharedDataType, bool> filter;
  2288.             private _scare2D_dot_NameRendererSystem_dot_ItemGroup3_Collection collection;
  2289.             private scare2D.NameRendererSystem.ItemGroup3 currentValue = new scare2D.NameRendererSystem.ItemGroup3();
  2290.             private IEnumerator<bool> moveNextEnumerator;
  2291.             public _scare2D_dot_NameRendererSystem_dot_ItemGroup3_Enumerator_ReadOnlyFilter(_scare2D_dot_NameRendererSystem_dot_ItemGroup3_Collection collection, Func<SharedDataType, bool> filter) {
  2292.                 this.collection = collection;
  2293.                 this.filter = filter;
  2294.             }
  2295.             public ref scare2D.NameRendererSystem.ItemGroup3 Current => ref currentValue;
  2296.             public bool MoveNext() {
  2297.                 if(moveNextEnumerator == null) {
  2298.                     moveNextEnumerator = MoveNextInternal();
  2299.                 }
  2300.                 return moveNextEnumerator.MoveNext();
  2301.             }
  2302.             public IEnumerator<bool> MoveNextInternal() {
  2303.                 foreach(var setType in collection.EntityWorld.Entities.Components) {
  2304.                     bool keepSetType = setType.TypeSet.IsSupersetOf(collection.Includes) && setType.TypeSet.GetIntersection(collection.Excludes).IsEmpty;
  2305.                     if(keepSetType == false) continue;
  2306.                     foreach(var set in setType) {
  2307.                         if(filter(set.SharedDataType) == false) continue;
  2308.                         var refList__scare2D_dot_EntityHandle_null = set.GetRefList<scare2D.EntityHandle>();
  2309.                         var refList__scare2D_dot_Transform_null = set.GetRefList<scare2D.Transform>();
  2310.                         for(var i = 0; i < set.Handles.Count; ++i) {
  2311.                             currentValue.handle = refList__scare2D_dot_EntityHandle_null[i];
  2312.                             currentValue.transform = refList__scare2D_dot_Transform_null[i];
  2313.                             yield return true;
  2314.                         }
  2315.                     }
  2316.                 }
  2317.             }
  2318.         }
  2319.         public scare2D.NameRendererSystem System => EntityWorld._scare2D_dot_NameRendererSystem_null;
  2320.         public EntityWorld EntityWorld { get; }
  2321.         public TypeSet Includes { get; }
  2322.         public TypeSet Excludes { get; }
  2323.         public IEntityWorld World => EntityWorld;
  2324.         public _scare2D_dot_NameRendererSystem_dot_ItemGroup3_Collection(EntityWorld world) {
  2325.             EntityWorld = world;
  2326.             Includes = new TypeSet(typeof(scare2D.Transform));
  2327.             Excludes = new TypeSet(typeof(scare2D.EntityName));
  2328.            
  2329.         }
  2330.         public IRefEnumerator<scare2D.NameRendererSystem.ItemGroup3> GetEnumerator() => new _scare2D_dot_NameRendererSystem_dot_ItemGroup3_Enumerator(this);
  2331.         public IRefEnumerable<scare2D.NameRendererSystem.ItemGroup3> WithFilter(Func<SharedDataType, bool> filter) => new RefEnumeratorWrapper<scare2D.NameRendererSystem.ItemGroup3>(new _scare2D_dot_NameRendererSystem_dot_ItemGroup3_Enumerator_ReadOnlyFilter(this, filter));
  2332.     }
  2333.     public sealed class _scare2D_dot_BoxColliderRendererSystem_dot_ItemGroup_Collection : IComponentCollection<scare2D.BoxColliderRendererSystem.ItemGroup> {
  2334.         public sealed class _scare2D_dot_BoxColliderRendererSystem_dot_ItemGroup_Enumerator : IRefEnumerator<scare2D.BoxColliderRendererSystem.ItemGroup> {
  2335.             private _scare2D_dot_BoxColliderRendererSystem_dot_ItemGroup_Collection collection;
  2336.             private scare2D.BoxColliderRendererSystem.ItemGroup currentValue = new scare2D.BoxColliderRendererSystem.ItemGroup();
  2337.             private IEnumerator<bool> moveNextEnumerator;
  2338.             public _scare2D_dot_BoxColliderRendererSystem_dot_ItemGroup_Enumerator(_scare2D_dot_BoxColliderRendererSystem_dot_ItemGroup_Collection collection) {
  2339.                 this.collection = collection;
  2340.             }
  2341.             public ref scare2D.BoxColliderRendererSystem.ItemGroup Current => ref currentValue;
  2342.             public bool MoveNext() {
  2343.                 if(moveNextEnumerator == null) {
  2344.                     moveNextEnumerator = MoveNextInternal();
  2345.                 }
  2346.                 return moveNextEnumerator.MoveNext();
  2347.             }
  2348.             public IEnumerator<bool> MoveNextInternal() {
  2349.                 var handlesThatChangedSharedType = new RefList<EntityHandle>();
  2350.                 foreach(var setType in collection.EntityWorld.Entities.Components) {
  2351.                     bool keepSetType = setType.TypeSet.IsSupersetOf(collection.Includes);
  2352.                     if(keepSetType == false) continue;
  2353.                     foreach(var handle in handlesThatChangedSharedType) {
  2354.                         collection.World.Entities.Components.CheckSharedDataTypeFor(handle);
  2355.                     }
  2356.                     handlesThatChangedSharedType.Clear();
  2357.                     foreach(var set in setType) {
  2358.                         var refList__scare2D_dot_Transform_null = set.GetRefList<scare2D.Transform>();
  2359.                         var refList__scare2D_dot_BoxCollider_null = set.GetRefList<scare2D.BoxCollider>();
  2360.                         System.Boolean _scare2D_dot_BoxCollider_canCollide = default;
  2361.                         if(set.Handles.Count > 0) {
  2362.                             _scare2D_dot_BoxCollider_canCollide = refList__scare2D_dot_BoxCollider_null[0].canCollide;
  2363.                         }
  2364.                         for(var i = 0; i < set.Handles.Count; ++i) {
  2365.                             currentValue.transform = refList__scare2D_dot_Transform_null[i];
  2366.                             currentValue.collider = refList__scare2D_dot_BoxCollider_null[i];
  2367.                             yield return true;
  2368.                             refList__scare2D_dot_Transform_null[i] = currentValue.transform;
  2369.                             refList__scare2D_dot_BoxCollider_null[i] = currentValue.collider;
  2370.                             if(object.Equals(_scare2D_dot_BoxCollider_canCollide, currentValue.collider.canCollide) == false) {
  2371.                                 handlesThatChangedSharedType.Add(set.Handles[i]);
  2372.                             }
  2373.                         }
  2374.                     }
  2375.                 }
  2376.                 foreach(var handle in handlesThatChangedSharedType) {
  2377.                     collection.World.Entities.Components.CheckSharedDataTypeFor(handle);
  2378.                 }
  2379.             }
  2380.         }
  2381.         public sealed class _scare2D_dot_BoxColliderRendererSystem_dot_ItemGroup_Enumerator_ReadOnlyFilter : IRefEnumerator<scare2D.BoxColliderRendererSystem.ItemGroup> {
  2382.             private Func<SharedDataType, bool> filter;
  2383.             private _scare2D_dot_BoxColliderRendererSystem_dot_ItemGroup_Collection collection;
  2384.             private scare2D.BoxColliderRendererSystem.ItemGroup currentValue = new scare2D.BoxColliderRendererSystem.ItemGroup();
  2385.             private IEnumerator<bool> moveNextEnumerator;
  2386.             public _scare2D_dot_BoxColliderRendererSystem_dot_ItemGroup_Enumerator_ReadOnlyFilter(_scare2D_dot_BoxColliderRendererSystem_dot_ItemGroup_Collection collection, Func<SharedDataType, bool> filter) {
  2387.                 this.collection = collection;
  2388.                 this.filter = filter;
  2389.             }
  2390.             public ref scare2D.BoxColliderRendererSystem.ItemGroup Current => ref currentValue;
  2391.             public bool MoveNext() {
  2392.                 if(moveNextEnumerator == null) {
  2393.                     moveNextEnumerator = MoveNextInternal();
  2394.                 }
  2395.                 return moveNextEnumerator.MoveNext();
  2396.             }
  2397.             public IEnumerator<bool> MoveNextInternal() {
  2398.                 foreach(var setType in collection.EntityWorld.Entities.Components) {
  2399.                     bool keepSetType = setType.TypeSet.IsSupersetOf(collection.Includes);
  2400.                     if(keepSetType == false) continue;
  2401.                     foreach(var set in setType) {
  2402.                         if(filter(set.SharedDataType) == false) continue;
  2403.                         var refList__scare2D_dot_Transform_null = set.GetRefList<scare2D.Transform>();
  2404.                         var refList__scare2D_dot_BoxCollider_null = set.GetRefList<scare2D.BoxCollider>();
  2405.                         if(set.Handles.Count > 0) {
  2406.                         }
  2407.                         for(var i = 0; i < set.Handles.Count; ++i) {
  2408.                             currentValue.transform = refList__scare2D_dot_Transform_null[i];
  2409.                             currentValue.collider = refList__scare2D_dot_BoxCollider_null[i];
  2410.                             yield return true;
  2411.                         }
  2412.                     }
  2413.                 }
  2414.             }
  2415.         }
  2416.         public scare2D.BoxColliderRendererSystem System => EntityWorld._scare2D_dot_BoxColliderRendererSystem_null;
  2417.         public EntityWorld EntityWorld { get; }
  2418.         public TypeSet Includes { get; }
  2419.         public TypeSet Excludes { get; }
  2420.         public IEntityWorld World => EntityWorld;
  2421.         public _scare2D_dot_BoxColliderRendererSystem_dot_ItemGroup_Collection(EntityWorld world) {
  2422.             EntityWorld = world;
  2423.             Includes = new TypeSet(typeof(scare2D.Transform), typeof(scare2D.BoxCollider));
  2424.             Excludes = new TypeSet();
  2425.            
  2426.         }
  2427.         public IRefEnumerator<scare2D.BoxColliderRendererSystem.ItemGroup> GetEnumerator() => new _scare2D_dot_BoxColliderRendererSystem_dot_ItemGroup_Enumerator(this);
  2428.         public IRefEnumerable<scare2D.BoxColliderRendererSystem.ItemGroup> WithFilter(Func<SharedDataType, bool> filter) => new RefEnumeratorWrapper<scare2D.BoxColliderRendererSystem.ItemGroup>(new _scare2D_dot_BoxColliderRendererSystem_dot_ItemGroup_Enumerator_ReadOnlyFilter(this, filter));
  2429.     }
  2430.     public sealed class _scare2D_dot_TextureRotatorSystem_dot_ItemGroup_Collection : IComponentCollection<scare2D.TextureRotatorSystem.ItemGroup> {
  2431.         public sealed class _scare2D_dot_TextureRotatorSystem_dot_ItemGroup_Enumerator : IRefEnumerator<scare2D.TextureRotatorSystem.ItemGroup> {
  2432.             private _scare2D_dot_TextureRotatorSystem_dot_ItemGroup_Collection collection;
  2433.             private scare2D.TextureRotatorSystem.ItemGroup currentValue = new scare2D.TextureRotatorSystem.ItemGroup();
  2434.             private IEnumerator<bool> moveNextEnumerator;
  2435.             public _scare2D_dot_TextureRotatorSystem_dot_ItemGroup_Enumerator(_scare2D_dot_TextureRotatorSystem_dot_ItemGroup_Collection collection) {
  2436.                 this.collection = collection;
  2437.             }
  2438.             public ref scare2D.TextureRotatorSystem.ItemGroup Current => ref currentValue;
  2439.             public bool MoveNext() {
  2440.                 if(moveNextEnumerator == null) {
  2441.                     moveNextEnumerator = MoveNextInternal();
  2442.                 }
  2443.                 return moveNextEnumerator.MoveNext();
  2444.             }
  2445.             public IEnumerator<bool> MoveNextInternal() {
  2446.                 var handlesThatChangedSharedType = new RefList<EntityHandle>();
  2447.                 foreach(var setType in collection.EntityWorld.Entities.Components) {
  2448.                     bool keepSetType = setType.TypeSet.IsSupersetOf(collection.Includes);
  2449.                     if(keepSetType == false) continue;
  2450.                     foreach(var handle in handlesThatChangedSharedType) {
  2451.                         collection.World.Entities.Components.CheckSharedDataTypeFor(handle);
  2452.                     }
  2453.                     handlesThatChangedSharedType.Clear();
  2454.                     foreach(var set in setType) {
  2455.                         var refList__scare2D_dot_SpriteRenderer_null = set.GetRefList<scare2D.SpriteRenderer>();
  2456.                         var refList__scare2D_dot_TextureRotator_null = set.GetRefList<scare2D.TextureRotator>();
  2457.                         System.String _scare2D_dot_SpriteRenderer_textureName = default;
  2458.                         if(set.Handles.Count > 0) {
  2459.                             _scare2D_dot_SpriteRenderer_textureName = refList__scare2D_dot_SpriteRenderer_null[0].textureName;
  2460.                         }
  2461.                         for(var i = 0; i < set.Handles.Count; ++i) {
  2462.                             currentValue.SpriteRenderer = refList__scare2D_dot_SpriteRenderer_null[i];
  2463.                             currentValue.TextureRotator = refList__scare2D_dot_TextureRotator_null[i];
  2464.                             yield return true;
  2465.                             refList__scare2D_dot_SpriteRenderer_null[i] = currentValue.SpriteRenderer;
  2466.                             refList__scare2D_dot_TextureRotator_null[i] = currentValue.TextureRotator;
  2467.                             if(_scare2D_dot_SpriteRenderer_textureName != currentValue.SpriteRenderer.textureName) {
  2468.                                 handlesThatChangedSharedType.Add(set.Handles[i]);
  2469.                             }
  2470.                         }
  2471.                     }
  2472.                 }
  2473.                 foreach(var handle in handlesThatChangedSharedType) {
  2474.                     collection.World.Entities.Components.CheckSharedDataTypeFor(handle);
  2475.                 }
  2476.             }
  2477.         }
  2478.         public sealed class _scare2D_dot_TextureRotatorSystem_dot_ItemGroup_Enumerator_ReadOnlyFilter : IRefEnumerator<scare2D.TextureRotatorSystem.ItemGroup> {
  2479.             private Func<SharedDataType, bool> filter;
  2480.             private _scare2D_dot_TextureRotatorSystem_dot_ItemGroup_Collection collection;
  2481.             private scare2D.TextureRotatorSystem.ItemGroup currentValue = new scare2D.TextureRotatorSystem.ItemGroup();
  2482.             private IEnumerator<bool> moveNextEnumerator;
  2483.             public _scare2D_dot_TextureRotatorSystem_dot_ItemGroup_Enumerator_ReadOnlyFilter(_scare2D_dot_TextureRotatorSystem_dot_ItemGroup_Collection collection, Func<SharedDataType, bool> filter) {
  2484.                 this.collection = collection;
  2485.                 this.filter = filter;
  2486.             }
  2487.             public ref scare2D.TextureRotatorSystem.ItemGroup Current => ref currentValue;
  2488.             public bool MoveNext() {
  2489.                 if(moveNextEnumerator == null) {
  2490.                     moveNextEnumerator = MoveNextInternal();
  2491.                 }
  2492.                 return moveNextEnumerator.MoveNext();
  2493.             }
  2494.             public IEnumerator<bool> MoveNextInternal() {
  2495.                 foreach(var setType in collection.EntityWorld.Entities.Components) {
  2496.                     bool keepSetType = setType.TypeSet.IsSupersetOf(collection.Includes);
  2497.                     if(keepSetType == false) continue;
  2498.                     foreach(var set in setType) {
  2499.                         if(filter(set.SharedDataType) == false) continue;
  2500.                         var refList__scare2D_dot_SpriteRenderer_null = set.GetRefList<scare2D.SpriteRenderer>();
  2501.                         var refList__scare2D_dot_TextureRotator_null = set.GetRefList<scare2D.TextureRotator>();
  2502.                         if(set.Handles.Count > 0) {
  2503.                         }
  2504.                         for(var i = 0; i < set.Handles.Count; ++i) {
  2505.                             currentValue.SpriteRenderer = refList__scare2D_dot_SpriteRenderer_null[i];
  2506.                             currentValue.TextureRotator = refList__scare2D_dot_TextureRotator_null[i];
  2507.                             yield return true;
  2508.                         }
  2509.                     }
  2510.                 }
  2511.             }
  2512.         }
  2513.         public scare2D.TextureRotatorSystem System => EntityWorld._scare2D_dot_TextureRotatorSystem_null;
  2514.         public EntityWorld EntityWorld { get; }
  2515.         public TypeSet Includes { get; }
  2516.         public TypeSet Excludes { get; }
  2517.         public IEntityWorld World => EntityWorld;
  2518.         public _scare2D_dot_TextureRotatorSystem_dot_ItemGroup_Collection(EntityWorld world) {
  2519.             EntityWorld = world;
  2520.             Includes = new TypeSet(typeof(scare2D.SpriteRenderer), typeof(scare2D.TextureRotator));
  2521.             Excludes = new TypeSet();
  2522.            
  2523.         }
  2524.         public IRefEnumerator<scare2D.TextureRotatorSystem.ItemGroup> GetEnumerator() => new _scare2D_dot_TextureRotatorSystem_dot_ItemGroup_Enumerator(this);
  2525.         public IRefEnumerable<scare2D.TextureRotatorSystem.ItemGroup> WithFilter(Func<SharedDataType, bool> filter) => new RefEnumeratorWrapper<scare2D.TextureRotatorSystem.ItemGroup>(new _scare2D_dot_TextureRotatorSystem_dot_ItemGroup_Enumerator_ReadOnlyFilter(this, filter));
  2526.     }
  2527.     public sealed class _scare2D_dot_AutoLerpTransformEndFixedUpdateSystem_dot_AutoLerpGroup_Collection : IComponentCollection<scare2D.AutoLerpTransformEndFixedUpdateSystem.AutoLerpGroup> {
  2528.         public sealed class _scare2D_dot_AutoLerpTransformEndFixedUpdateSystem_dot_AutoLerpGroup_Enumerator : IRefEnumerator<scare2D.AutoLerpTransformEndFixedUpdateSystem.AutoLerpGroup> {
  2529.             private _scare2D_dot_AutoLerpTransformEndFixedUpdateSystem_dot_AutoLerpGroup_Collection collection;
  2530.             private scare2D.AutoLerpTransformEndFixedUpdateSystem.AutoLerpGroup currentValue = new scare2D.AutoLerpTransformEndFixedUpdateSystem.AutoLerpGroup();
  2531.             private IEnumerator<bool> moveNextEnumerator;
  2532.             public _scare2D_dot_AutoLerpTransformEndFixedUpdateSystem_dot_AutoLerpGroup_Enumerator(_scare2D_dot_AutoLerpTransformEndFixedUpdateSystem_dot_AutoLerpGroup_Collection collection) {
  2533.                 this.collection = collection;
  2534.             }
  2535.             public ref scare2D.AutoLerpTransformEndFixedUpdateSystem.AutoLerpGroup Current => ref currentValue;
  2536.             public bool MoveNext() {
  2537.                 if(moveNextEnumerator == null) {
  2538.                     moveNextEnumerator = MoveNextInternal();
  2539.                 }
  2540.                 return moveNextEnumerator.MoveNext();
  2541.             }
  2542.             public IEnumerator<bool> MoveNextInternal() {
  2543.                 foreach(var setType in collection.EntityWorld.Entities.Components) {
  2544.                     bool keepSetType = setType.TypeSet.IsSupersetOf(collection.Includes);
  2545.                     if(keepSetType == false) continue;
  2546.                     foreach(var set in setType) {
  2547.                         var refList__scare2D_dot_Transform2D_null = set.GetRefList<scare2D.Transform2D>();
  2548.                         var refList__scare2D_dot_AutoLerpTransformComponent_null = set.GetRefList<scare2D.AutoLerpTransformComponent>();
  2549.                         for(var i = 0; i < set.Handles.Count; ++i) {
  2550.                             currentValue.Transform = refList__scare2D_dot_Transform2D_null[i];
  2551.                             currentValue.AutoLerp = refList__scare2D_dot_AutoLerpTransformComponent_null[i];
  2552.                             yield return true;
  2553.                             refList__scare2D_dot_Transform2D_null[i] = currentValue.Transform;
  2554.                             refList__scare2D_dot_AutoLerpTransformComponent_null[i] = currentValue.AutoLerp;
  2555.                         }
  2556.                     }
  2557.                 }
  2558.             }
  2559.         }
  2560.         public sealed class _scare2D_dot_AutoLerpTransformEndFixedUpdateSystem_dot_AutoLerpGroup_Enumerator_ReadOnlyFilter : IRefEnumerator<scare2D.AutoLerpTransformEndFixedUpdateSystem.AutoLerpGroup> {
  2561.             private Func<SharedDataType, bool> filter;
  2562.             private _scare2D_dot_AutoLerpTransformEndFixedUpdateSystem_dot_AutoLerpGroup_Collection collection;
  2563.             private scare2D.AutoLerpTransformEndFixedUpdateSystem.AutoLerpGroup currentValue = new scare2D.AutoLerpTransformEndFixedUpdateSystem.AutoLerpGroup();
  2564.             private IEnumerator<bool> moveNextEnumerator;
  2565.             public _scare2D_dot_AutoLerpTransformEndFixedUpdateSystem_dot_AutoLerpGroup_Enumerator_ReadOnlyFilter(_scare2D_dot_AutoLerpTransformEndFixedUpdateSystem_dot_AutoLerpGroup_Collection collection, Func<SharedDataType, bool> filter) {
  2566.                 this.collection = collection;
  2567.                 this.filter = filter;
  2568.             }
  2569.             public ref scare2D.AutoLerpTransformEndFixedUpdateSystem.AutoLerpGroup Current => ref currentValue;
  2570.             public bool MoveNext() {
  2571.                 if(moveNextEnumerator == null) {
  2572.                     moveNextEnumerator = MoveNextInternal();
  2573.                 }
  2574.                 return moveNextEnumerator.MoveNext();
  2575.             }
  2576.             public IEnumerator<bool> MoveNextInternal() {
  2577.                 foreach(var setType in collection.EntityWorld.Entities.Components) {
  2578.                     bool keepSetType = setType.TypeSet.IsSupersetOf(collection.Includes);
  2579.                     if(keepSetType == false) continue;
  2580.                     foreach(var set in setType) {
  2581.                         if(filter(set.SharedDataType) == false) continue;
  2582.                         var refList__scare2D_dot_Transform2D_null = set.GetRefList<scare2D.Transform2D>();
  2583.                         var refList__scare2D_dot_AutoLerpTransformComponent_null = set.GetRefList<scare2D.AutoLerpTransformComponent>();
  2584.                         for(var i = 0; i < set.Handles.Count; ++i) {
  2585.                             currentValue.Transform = refList__scare2D_dot_Transform2D_null[i];
  2586.                             currentValue.AutoLerp = refList__scare2D_dot_AutoLerpTransformComponent_null[i];
  2587.                             yield return true;
  2588.                         }
  2589.                     }
  2590.                 }
  2591.             }
  2592.         }
  2593.         public scare2D.AutoLerpTransformEndFixedUpdateSystem System => EntityWorld._scare2D_dot_AutoLerpTransformEndFixedUpdateSystem_null;
  2594.         public EntityWorld EntityWorld { get; }
  2595.         public TypeSet Includes { get; }
  2596.         public TypeSet Excludes { get; }
  2597.         public IEntityWorld World => EntityWorld;
  2598.         public _scare2D_dot_AutoLerpTransformEndFixedUpdateSystem_dot_AutoLerpGroup_Collection(EntityWorld world) {
  2599.             EntityWorld = world;
  2600.             Includes = new TypeSet(typeof(scare2D.Transform2D), typeof(scare2D.AutoLerpTransformComponent));
  2601.             Excludes = new TypeSet();
  2602.            
  2603.         }
  2604.         public IRefEnumerator<scare2D.AutoLerpTransformEndFixedUpdateSystem.AutoLerpGroup> GetEnumerator() => new _scare2D_dot_AutoLerpTransformEndFixedUpdateSystem_dot_AutoLerpGroup_Enumerator(this);
  2605.         public IRefEnumerable<scare2D.AutoLerpTransformEndFixedUpdateSystem.AutoLerpGroup> WithFilter(Func<SharedDataType, bool> filter) => new RefEnumeratorWrapper<scare2D.AutoLerpTransformEndFixedUpdateSystem.AutoLerpGroup>(new _scare2D_dot_AutoLerpTransformEndFixedUpdateSystem_dot_AutoLerpGroup_Enumerator_ReadOnlyFilter(this, filter));
  2606.     }
  2607.     public sealed class _scare2D_dot_RigidBody2DVelocityRendererSystem_dot_ItemGroup_Collection : IComponentCollection<scare2D.RigidBody2DVelocityRendererSystem.ItemGroup> {
  2608.         public sealed class _scare2D_dot_RigidBody2DVelocityRendererSystem_dot_ItemGroup_Enumerator : IRefEnumerator<scare2D.RigidBody2DVelocityRendererSystem.ItemGroup> {
  2609.             private _scare2D_dot_RigidBody2DVelocityRendererSystem_dot_ItemGroup_Collection collection;
  2610.             private scare2D.RigidBody2DVelocityRendererSystem.ItemGroup currentValue = new scare2D.RigidBody2DVelocityRendererSystem.ItemGroup();
  2611.             private IEnumerator<bool> moveNextEnumerator;
  2612.             public _scare2D_dot_RigidBody2DVelocityRendererSystem_dot_ItemGroup_Enumerator(_scare2D_dot_RigidBody2DVelocityRendererSystem_dot_ItemGroup_Collection collection) {
  2613.                 this.collection = collection;
  2614.             }
  2615.             public ref scare2D.RigidBody2DVelocityRendererSystem.ItemGroup Current => ref currentValue;
  2616.             public bool MoveNext() {
  2617.                 if(moveNextEnumerator == null) {
  2618.                     moveNextEnumerator = MoveNextInternal();
  2619.                 }
  2620.                 return moveNextEnumerator.MoveNext();
  2621.             }
  2622.             public IEnumerator<bool> MoveNextInternal() {
  2623.                 foreach(var setType in collection.EntityWorld.Entities.Components) {
  2624.                     bool keepSetType = setType.TypeSet.IsSupersetOf(collection.Includes);
  2625.                     if(keepSetType == false) continue;
  2626.                     foreach(var set in setType) {
  2627.                         var refList__scare2D_dot_Transform2D_null = set.GetRefList<scare2D.Transform2D>();
  2628.                         var refList__scare2D_dot_RigidBody2D_null = set.GetRefList<scare2D.RigidBody2D>();
  2629.                         if(set.Handles.Count > 0) {
  2630.                         }
  2631.                         for(var i = 0; i < set.Handles.Count; ++i) {
  2632.                             currentValue.Transform = refList__scare2D_dot_Transform2D_null[i];
  2633.                             currentValue.RigidBody = refList__scare2D_dot_RigidBody2D_null[i];
  2634.                             yield return true;
  2635.                         }
  2636.                     }
  2637.                 }
  2638.             }
  2639.         }
  2640.         public sealed class _scare2D_dot_RigidBody2DVelocityRendererSystem_dot_ItemGroup_Enumerator_ReadOnlyFilter : IRefEnumerator<scare2D.RigidBody2DVelocityRendererSystem.ItemGroup> {
  2641.             private Func<SharedDataType, bool> filter;
  2642.             private _scare2D_dot_RigidBody2DVelocityRendererSystem_dot_ItemGroup_Collection collection;
  2643.             private scare2D.RigidBody2DVelocityRendererSystem.ItemGroup currentValue = new scare2D.RigidBody2DVelocityRendererSystem.ItemGroup();
  2644.             private IEnumerator<bool> moveNextEnumerator;
  2645.             public _scare2D_dot_RigidBody2DVelocityRendererSystem_dot_ItemGroup_Enumerator_ReadOnlyFilter(_scare2D_dot_RigidBody2DVelocityRendererSystem_dot_ItemGroup_Collection collection, Func<SharedDataType, bool> filter) {
  2646.                 this.collection = collection;
  2647.                 this.filter = filter;
  2648.             }
  2649.             public ref scare2D.RigidBody2DVelocityRendererSystem.ItemGroup Current => ref currentValue;
  2650.             public bool MoveNext() {
  2651.                 if(moveNextEnumerator == null) {
  2652.                     moveNextEnumerator = MoveNextInternal();
  2653.                 }
  2654.                 return moveNextEnumerator.MoveNext();
  2655.             }
  2656.             public IEnumerator<bool> MoveNextInternal() {
  2657.                 foreach(var setType in collection.EntityWorld.Entities.Components) {
  2658.                     bool keepSetType = setType.TypeSet.IsSupersetOf(collection.Includes);
  2659.                     if(keepSetType == false) continue;
  2660.                     foreach(var set in setType) {
  2661.                         if(filter(set.SharedDataType) == false) continue;
  2662.                         var refList__scare2D_dot_Transform2D_null = set.GetRefList<scare2D.Transform2D>();
  2663.                         var refList__scare2D_dot_RigidBody2D_null = set.GetRefList<scare2D.RigidBody2D>();
  2664.                         if(set.Handles.Count > 0) {
  2665.                         }
  2666.                         for(var i = 0; i < set.Handles.Count; ++i) {
  2667.                             currentValue.Transform = refList__scare2D_dot_Transform2D_null[i];
  2668.                             currentValue.RigidBody = refList__scare2D_dot_RigidBody2D_null[i];
  2669.                             yield return true;
  2670.                         }
  2671.                     }
  2672.                 }
  2673.             }
  2674.         }
  2675.         public scare2D.RigidBody2DVelocityRendererSystem System => EntityWorld._scare2D_dot_RigidBody2DVelocityRendererSystem_null;
  2676.         public EntityWorld EntityWorld { get; }
  2677.         public TypeSet Includes { get; }
  2678.         public TypeSet Excludes { get; }
  2679.         public IEntityWorld World => EntityWorld;
  2680.         public _scare2D_dot_RigidBody2DVelocityRendererSystem_dot_ItemGroup_Collection(EntityWorld world) {
  2681.             EntityWorld = world;
  2682.             Includes = new TypeSet(typeof(scare2D.Transform2D), typeof(scare2D.RigidBody2D));
  2683.             Excludes = new TypeSet();
  2684.            
  2685.         }
  2686.         public IRefEnumerator<scare2D.RigidBody2DVelocityRendererSystem.ItemGroup> GetEnumerator() => new _scare2D_dot_RigidBody2DVelocityRendererSystem_dot_ItemGroup_Enumerator(this);
  2687.         public IRefEnumerable<scare2D.RigidBody2DVelocityRendererSystem.ItemGroup> WithFilter(Func<SharedDataType, bool> filter) => new RefEnumeratorWrapper<scare2D.RigidBody2DVelocityRendererSystem.ItemGroup>(new _scare2D_dot_RigidBody2DVelocityRendererSystem_dot_ItemGroup_Enumerator_ReadOnlyFilter(this, filter));
  2688.     }
  2689.     public sealed class _scare2D_dot_ReadOnlyGenericGroup_scare2D_dot_Manifold2D__Collection : IComponentCollection<scare2D.ReadOnlyGenericGroup<scare2D.Manifold2D>> {
  2690.         public sealed class _scare2D_dot_ReadOnlyGenericGroup_scare2D_dot_Manifold2D__Enumerator : IRefEnumerator<scare2D.ReadOnlyGenericGroup<scare2D.Manifold2D>> {
  2691.             private _scare2D_dot_ReadOnlyGenericGroup_scare2D_dot_Manifold2D__Collection collection;
  2692.             private scare2D.ReadOnlyGenericGroup<scare2D.Manifold2D> currentValue = new scare2D.ReadOnlyGenericGroup<scare2D.Manifold2D>();
  2693.             private IEnumerator<bool> moveNextEnumerator;
  2694.             public _scare2D_dot_ReadOnlyGenericGroup_scare2D_dot_Manifold2D__Enumerator(_scare2D_dot_ReadOnlyGenericGroup_scare2D_dot_Manifold2D__Collection collection) {
  2695.                 this.collection = collection;
  2696.             }
  2697.             public ref scare2D.ReadOnlyGenericGroup<scare2D.Manifold2D> Current => ref currentValue;
  2698.             public bool MoveNext() {
  2699.                 if(moveNextEnumerator == null) {
  2700.                     moveNextEnumerator = MoveNextInternal();
  2701.                 }
  2702.                 return moveNextEnumerator.MoveNext();
  2703.             }
  2704.             public IEnumerator<bool> MoveNextInternal() {
  2705.                 foreach(var setType in collection.EntityWorld.Entities.Components) {
  2706.                     bool keepSetType = setType.TypeSet.IsSupersetOf(collection.Includes);
  2707.                     if(keepSetType == false) continue;
  2708.                     foreach(var set in setType) {
  2709.                         var refList__scare2D_dot_Manifold2D_null = set.GetRefList<scare2D.Manifold2D>();
  2710.                         for(var i = 0; i < set.Handles.Count; ++i) {
  2711.                             currentValue.Component = refList__scare2D_dot_Manifold2D_null[i];
  2712.                             yield return true;
  2713.                         }
  2714.                     }
  2715.                 }
  2716.             }
  2717.         }
  2718.         public sealed class _scare2D_dot_ReadOnlyGenericGroup_scare2D_dot_Manifold2D__Enumerator_ReadOnlyFilter : IRefEnumerator<scare2D.ReadOnlyGenericGroup<scare2D.Manifold2D>> {
  2719.             private Func<SharedDataType, bool> filter;
  2720.             private _scare2D_dot_ReadOnlyGenericGroup_scare2D_dot_Manifold2D__Collection collection;
  2721.             private scare2D.ReadOnlyGenericGroup<scare2D.Manifold2D> currentValue = new scare2D.ReadOnlyGenericGroup<scare2D.Manifold2D>();
  2722.             private IEnumerator<bool> moveNextEnumerator;
  2723.             public _scare2D_dot_ReadOnlyGenericGroup_scare2D_dot_Manifold2D__Enumerator_ReadOnlyFilter(_scare2D_dot_ReadOnlyGenericGroup_scare2D_dot_Manifold2D__Collection collection, Func<SharedDataType, bool> filter) {
  2724.                 this.collection = collection;
  2725.                 this.filter = filter;
  2726.             }
  2727.             public ref scare2D.ReadOnlyGenericGroup<scare2D.Manifold2D> Current => ref currentValue;
  2728.             public bool MoveNext() {
  2729.                 if(moveNextEnumerator == null) {
  2730.                     moveNextEnumerator = MoveNextInternal();
  2731.                 }
  2732.                 return moveNextEnumerator.MoveNext();
  2733.             }
  2734.             public IEnumerator<bool> MoveNextInternal() {
  2735.                 foreach(var setType in collection.EntityWorld.Entities.Components) {
  2736.                     bool keepSetType = setType.TypeSet.IsSupersetOf(collection.Includes);
  2737.                     if(keepSetType == false) continue;
  2738.                     foreach(var set in setType) {
  2739.                         if(filter(set.SharedDataType) == false) continue;
  2740.                         var refList__scare2D_dot_Manifold2D_null = set.GetRefList<scare2D.Manifold2D>();
  2741.                         for(var i = 0; i < set.Handles.Count; ++i) {
  2742.                             currentValue.Component = refList__scare2D_dot_Manifold2D_null[i];
  2743.                             yield return true;
  2744.                         }
  2745.                     }
  2746.                 }
  2747.             }
  2748.         }
  2749.         public scare2D.Manifold2DRendererSystem System => EntityWorld._scare2D_dot_Manifold2DRendererSystem_null;
  2750.         public EntityWorld EntityWorld { get; }
  2751.         public TypeSet Includes { get; }
  2752.         public TypeSet Excludes { get; }
  2753.         public IEntityWorld World => EntityWorld;
  2754.         public _scare2D_dot_ReadOnlyGenericGroup_scare2D_dot_Manifold2D__Collection(EntityWorld world) {
  2755.             EntityWorld = world;
  2756.             Includes = new TypeSet(typeof(scare2D.Manifold2D));
  2757.             Excludes = new TypeSet();
  2758.            
  2759.         }
  2760.         public IRefEnumerator<scare2D.ReadOnlyGenericGroup<scare2D.Manifold2D>> GetEnumerator() => new _scare2D_dot_ReadOnlyGenericGroup_scare2D_dot_Manifold2D__Enumerator(this);
  2761.         public IRefEnumerable<scare2D.ReadOnlyGenericGroup<scare2D.Manifold2D>> WithFilter(Func<SharedDataType, bool> filter) => new RefEnumeratorWrapper<scare2D.ReadOnlyGenericGroup<scare2D.Manifold2D>>(new _scare2D_dot_ReadOnlyGenericGroup_scare2D_dot_Manifold2D__Enumerator_ReadOnlyFilter(this, filter));
  2762.     }
  2763.    
  2764.     public sealed class EntityWorldFormatter : BaseSerializationFormatter<EntityWorld> {
  2765.             public override void Serialize(Type objectType, object obj, ISerializeContext context)
  2766.             {
  2767.                 var world = (EntityWorld)obj;
  2768.                 context.Serialize(world.Entities);
  2769.             }
  2770.    
  2771.             public override IEnumerator<object> Deserialize(Type objectType, IDeserializeContext context)
  2772.             {
  2773.                 var world = new EntityWorld();
  2774.                 yield return world;
  2775.                 var entities = context.Deserialize<EntityManager>();
  2776.                 world.Entities = entities;
  2777.             }
  2778.     }
  2779. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!