// Update is called once per frame. It is the main workhorse function for frame updates.
void Update()
{
if(Input.GetButtonDown("Fire3"))
{
//Rigidbody bulletInstance = Instantiate(m_BulletPrefab, m_BulletSpawnPoint.position, m_BulletSpawnPoint.rotation) as Rigidbody;
//bulletInstance.velocity = m_BulletVelocity * m_BulletSpawnPoint.up; //(up = y-axis)
// Get a bullet and initialize it before activating it.
//m_Bullet = GameManager.instance.m_BulletPool.Pop();
m_Bullet = m_BulletPool.Pop();
Rigidbody rigidbody = m_Bullet.GetComponent<Rigidbody>();
m_Bullet.transform.position = m_BulletSpawnPoint.position;
m_Bullet.transform.rotation = m_BulletSpawnPoint.rotation;
rigidbody.velocity = m_BulletVelocity * m_BulletSpawnPoint.up; //(up: y-axis)
m_Bullet.gameObject.SetActive(true);
//Invoke("Repool", m_BulletLife);
//StartCoroutine(Repool(m_Bullet, m_BulletLife));
// Change the clip to the firing clip and play it.
//m_ShootingAudio.clip = m_ShootClip;
m_ShootingAudio.Play();
//SoundManager.instance.PlaySingle(m_ShootClip);
}
}
public void ReturnLight(Poolable instance)
{
if (!instance.exists) {
throw new Exception("Returning the non-existent object to pool!");
}
instance.exists = false;
lightPool.Add(instance);
}
// Play the system, then recycle it when over.
void OnEnable()
{
m_explosionPS.Play();
m_explosionAudio.Play();
// Get Poolable component here. GObject won't have it on Awake!
m_Poolable = GetComponent<Poolable>();
Invoke("PoolItem", m_explosionPS.startLifetime);
}
private void GoToSleep()
{
if (poolable == null) {
poolable = GetComponent<Poolable>();
}
if (poolable != null) {
poolable.PoolBack();
} else {
Destroy(gameObject);
}
}
public void Return(Poolable instance)
{
if (instance.gameObject == sample) {
Debug.LogError("Sample returning to pool!");
}
if (!instance.exists) {
throw new Exception("Returning the non-existent object to pool!");
}
instance.exists = false;
Disappear(instance);
pool.Add(instance);
}
public static void Enqueue(Poolable sender)
{
if (sender == null || sender.isPooled || !pools.ContainsKey(sender.key))
return;
PoolData data = pools[sender.key];
if (data.pool.Count >= data.maxCount)
{
GameObject.Destroy(sender.gameObject);
return;
}
data.pool.Enqueue(sender);
sender.isPooled = true;
sender.transform.SetParent(Instance.transform);
sender.gameObject.SetActive(false);
}
// Pool and deactivate an item for reuse, or destroy it if pool is full.
public void Push(Poolable obj)
{
if(obj == null || obj.isPooled)
return;
// Pool is full! Destroy the object.
if(m_Pool.Count >= m_MaxCount)
{
GameObject.Destroy(obj.gameObject);
return;
}
// Pool the object for reuse.
m_Pool.Add(obj);
obj.isPooled = true;
//obj.transform.SetParent(Instance.transform);
obj.gameObject.SetActive(false);
}
private IEnumerable <IPoolable> InstantiateRay(InteractiveData interactiveData)
{
var ray = Instantiate(rayPrefab, transform.position, transform.rotation);
ray.name = "Lazer Ray";
var rayComponent = ray.GetComponent <LazerRay>();
rayComponent.SetData(interactiveData);
ray.GetComponent <ILinkWithShower>().EffectShower = EffectShower;
var poolable = new Poolable(ray);
poolable.OnFloated.Subscribe
(
() =>
{
ray.transform.position = transform.position;
ray.transform.rotation = transform.rotation;
float y = movingObject.Speed.y;
movingObject.Speed = movingObject.Speed.Change(y: 0);
movingObject.UpdateSpeedAndDelta();
rayComponent.StartCoroutine(CoroutineT.Single
(
() =>
{
ray.SetActive(false);
movingObject.Speed = movingObject.Speed.Change(y: y);
movingObject.UpdateSpeedAndDelta();
},
rayLivingTime
));
}
);
yield return(poolable);
}
/// <summary>
/// Update this instance.
/// </summary>
void FixedUpdate()
{
if (target == null)
{
return;
}
counter += Time.fixedDeltaTime;
if (counter >= lifeTime)
{
counter = 0;
Poolable.TryPool(gameObject);
}
// Add acceleration
speed += Time.fixedDeltaTime * speedUpOverTime;
if (target != null)
{
aimPoint = GetPenetrationPoint(target.position);
}
// Calculate distance from firepoint to aim
Vector2 originDistance = aimPoint - originPoint;
// Calculate remaining distance
Vector2 distanceToAim = aimPoint - (Vector2)myVirtualPosition;
// Move towards aim
myVirtualPosition = Vector2.Lerp(originPoint, aimPoint, counter * speed / originDistance.magnitude);
// Add ballistic offset to trajectory
transform.position = AddBallisticOffset(originDistance.magnitude, distanceToAim.magnitude);
// Rotate bullet towards trajectory
LookAtDirection2D((Vector2)transform.position - myPreviousPosition);
myPreviousPosition = transform.position;
sprite.enabled = true;
// Close enough to hit
if (distanceToAim.magnitude <= hitDistance)
{
// Destroy bullet
//Destroy(gameObject);
Poolable.TryPool(gameObject);
}
}
public void PoolElement(GameObject toPool)
{
Poolable poolable = toPool.GetComponent <Poolable>();
if (poolable != null)
{
if (m_AllPools.ContainsKey(poolable.keyPrefab))
{
m_AllPools[poolable.keyPrefab].SetAvailable(toPool);
}
else
{
Debug.LogWarning("Try To Pool No Prefab Key available => Destroy !");
Destroy(toPool);
}
}
else
{
Debug.LogWarning("Try To Pool but no Poolable !");
Destroy(toPool);
}
}
/// <summary>
/// Spawn our effect
/// </summary>
protected virtual void OnFired()
{
if (effectPrefab != null)
{
m_SpawnedEffect = Poolable.TryGetPoolable(effectPrefab);
m_SpawnedEffect.transform.parent = null;
m_SpawnedEffect.transform.position = followTransform.position;
m_SpawnedEffect.transform.rotation = followTransform.rotation;
// Make sure to disable timer if it's on initially, so it doesn't destroy this object
m_DestroyTimer = m_SpawnedEffect.GetComponent <SelfDestroyTimer>();
if (m_DestroyTimer != null)
{
m_DestroyTimer.enabled = false;
}
m_Resetter = m_SpawnedEffect.GetComponent <PoolableEffect>();
if (m_Resetter != null)
{
m_Resetter.TurnOnAllSystems();
}
}
}
private Transform GetPlane()
{
Transform planeClone = null;
if (currentPlane.GetComponent <AircraftThatWorksWithWeapon>())
{
//Debug.Log("1");
planeClone = Poolable.Get <AircraftThatWorksWithWeapon>(() => Poolable.CreateObj <AircraftThatWorksWithWeapon>(currentPlane.gameObject), aircraftSpawnPoint.position, transform.rotation, null).transform;
}
else if (currentPlane.GetComponent <StrikeFighterThatWorksWithWeapon>())
{
//Debug.Log("2");
planeClone = Poolable.Get <StrikeFighterThatWorksWithWeapon>(() => Poolable.CreateObj <StrikeFighterThatWorksWithWeapon>(currentPlane.gameObject), aircraftSpawnPoint.position, transform.rotation, null).transform;
}
else if (currentPlane.GetComponent <StrategicBomberThatWorksWithWeapon>())
{
//Debug.Log("3");
planeClone = Poolable.Get <StrategicBomberThatWorksWithWeapon>(() => Poolable.CreateObj <StrategicBomberThatWorksWithWeapon>(currentPlane.gameObject), aircraftSpawnPoint.position, transform.rotation, null).transform;
}
return(planeClone);
}
private void Start()
{
for (int a = 0; a < 60; a++)
{
Poolable poolable = ObjectPool.Instance.Aquire <Poolable>(gameObject: this._prefab);
Debug.Log($"Pool InstanceId: {poolable.Pool.InstanceId}");
Debug.Log($"GameObject InstanceId: {poolable.GameObject.GetInstanceID()}");
ObjectPool.Instance.Release(poolable: poolable);
}
for (int a = 0; a < 30; a++)
{
Poolable poolable = ObjectPool.Instance.Aquire <Poolable>(gameObject: this._prefab);
Debug.Log($"Pool InstanceId: {poolable.Pool.InstanceId}");
Debug.Log($"GameObject InstanceId: {poolable.GameObject.GetInstanceID()}");
poolable.GameObject.transform.position = new Vector3(x: 235.3f, y: 0.0f, z: 32.3f);
}
}
private IEnumerable <IPoolable <Vector2> > InstansiateHittingEffect()
{
var hittingEffect = Instantiate(hittingEffectPrefab);
hittingEffect.name = "HittingEffect";
var particle = hittingEffect.GetComponent <ParticleSystem>();
var poolable = new Poolable <Vector2>(hittingEffect);
poolable.OnFloated.Subscribe
(
position =>
{
hittingEffect.transform.position = position;
float angle = Mathf.Rad2Deg * Mathf.Atan2(distanceToPlayer.y, distanceToPlayer.x);
hittingEffect.transform.eulerAngles = hittingEffect.transform.eulerAngles.Change(x: -angle);
particle.Play();
}
);
yield return(poolable);
}
private void Start()
{
targPos = transform.position;
if (!gm && FindObjectOfType <GameMaster>())
{
gm = FindObjectOfType <GameMaster>();
}
if (!anim)
{
anim = GetComponent <Animator>();
}
if (!rb)
{
rb = GetComponent <Rigidbody2D>();
}
if (!firePos)
{
firePos = transform.Find("FirePoint").transform;
}
arrowPool = arrowPref.GetComponent <Poolable>();
}
public Poolable GetObject(System.Action <Poolable> initialize = null, Transform parent = null, bool instantiateInWorldSpace = true)
{
Poolable poolable = null;
if (freeObjects.Count <= 0)
{
poolable = Spawn(parent, instantiateInWorldSpace);
}
else
{
while (freeObjects.Count > 0 && poolable == null)
{
poolable = freeObjects.Dequeue();
}
if (freeObjects.Count <= 0 && poolable == null)
{
return(GetObject(initialize));
}
}
#if UNITY_EDITOR
Debug.Assert(!freeObjects.Contains(poolable));
#endif
usedObjects.Add(poolable);
foreach (IResettable resettable in poolable.gameObject.GetComponentsInChildren(typeof(IResettable)))
{
resettable.OnReset();
}
initialize?.Invoke(poolable);
poolable.transform.parent = parent;
poolable.gameObject.SetActive(true);
return(poolable);
}
public override FireState Fire()
{
if (target)
{
if (!target.gameObject.activeInHierarchy)
{
target = null;
return(FireState.Failed);
}
if (Time.time > fireTimer)
{
Transform missileClone = Poolable.Get <GuidedSSMissile>(() => Poolable.CreateObj <GuidedSSMissile>(projectilePrefab.gameObject), new Vector3(spawnLocation.position.x + Random.Range(-0.2f, 0.2f), spawnLocation.position.y, spawnLocation.position.z), Quaternion.identity).transform;
int layerValue = whatAreOurProjectiles.layermask_to_layer();
missileClone.gameObject.layer = layerValue;
TrailRenderer projTrail = missileClone.GetComponent <TrailRenderer>();
projTrail.material = layerValue == 8 ? t1Mat : t2Mat;
projTrail.Clear();
GuidedSSMissile missile = missileClone.GetComponent <GuidedSSMissile>();
missile.target = target;
missile.whatIsTarget = whatIsTarget;
missile.BoostStage();
fireTimer = delayBetweenFire + Time.time;
fireSound.Play();
//soundMngr.PlayEnviroSound(spawnLocation.gameObject, "missile1", 10f);
return(FireState.Fired);
}
else
{
return(FireState.OnDelay);
}
}
else
{
return(FireState.Failed);
}
}
public override FireState Fire()
{
bool isTargVisual = CheckIfLookingAtTarget(lookCheckRange);
if (isTargVisual)
{
if (Time.time > fireTimer)
{
Transform missileClone = Poolable.Get <GuidedAAMissile>(() => Poolable.CreateObj <GuidedAAMissile>(projectilePrefab.gameObject), spawnLocation.position, owner.rotation).transform;
int layerValue = whatAreOurProjectiles.layermask_to_layer();
missileClone.gameObject.layer = layerValue;
GuidedAAMissile missile = missileClone.GetComponent <GuidedAAMissile>();
missile.whatIsTarget = whatIsTarget;
missile.target = target;
TrailRenderer projTrail = missileClone.GetComponent <TrailRenderer>();
projTrail.material = layerValue == 8 ? t1Mat : t2Mat;
projTrail.enabled = true;
fireTimer = delayBetweenFire + Time.time + Random.Range(-delayBetweenFire / 5f, delayBetweenFire / 3.4f);
fireSound.Play();
return(FireState.Fired);
}
else
{
if (!target.gameObject.activeInHierarchy)
{
target = null;
return(FireState.Failed);
}
return(FireState.OnDelay);
}
}
else
{
return(FireState.Failed);
}
}
// Called when hit by a bullet trigger collider.
void OnTriggerEnter(Collider other)
{
// other = Bullet. Inactivate it until it repools itself.
other.gameObject.SetActive(false);
if (gameObject.CompareTag("AsteroidBig"))
{
// Split the big asteroid into 2 smaller ones.
for (int i = 0; i < 2; i++)
{
//GameObject a1 = Instantiate(m_SmallAsteroidPrefab);
Poolable small = GameManager.instance.m_AsteroidSmallPool.Pop();
AsteroidBehaviour behaviour = small.GetComponent <AsteroidBehaviour>();
small.transform.position = gameObject.transform.position;
small.gameObject.SetActive(true);
behaviour.SetRandomForces();
}
// Recycle this (big) asteroid.
GameManager.instance.m_AsteroidBigPool.Push(m_Poolable);
}
else // "AsteroidSmall"
{
// Recycle this (small) asteroid.
GameManager.instance.m_AsteroidSmallPool.Push(m_Poolable);
}
// Play the explosion sound clip via SM (because object will be destroyed).
// Could also use AudioSource.PlayClipAtPoint()
//SoundManager.instance.PlaySingle(m_ExplosionClip);
// Activate an explosion.
SpawnExplosion();
//Poolable explosion = GameManager.instance.m_ExplosionPool.Pop();
//explosion.transform.position = transform.position;
//explosion.transform.Rotate(new Vector3(0f, 0f, 360f * Random.value));
//explosion.gameObject.SetActive(true);
}
public void TestDefragment61()
{
Scene scene = new Scene();
Settings settings = new Settings();
Pooler <Poolable> pooler = new Pooler <Poolable>(settings, scene, 5);
Poolable p1 = pooler.Enable();
Poolable p2 = pooler.Enable();
Poolable p3 = pooler.Enable();
Poolable p4 = pooler.Enable();
Poolable p5 = pooler.Enable();
p1.Disable();
p3.Disable();
Assert.AreEqual(p1, pooler[0], "in method Defragment, line 72");
Assert.AreEqual(p2, pooler[1], "in method Defragment, line 73");
Assert.AreEqual(p3, pooler[2], "in method Defragment, line 74");
Assert.AreEqual(p4, pooler[3], "in method Defragment, line 75");
Assert.AreEqual(p5, pooler[4], "in method Defragment, line 76");
try
{
Assert.AreEqual(p5, pooler[5], "in method Defragment, line 77");
Assert.Fail("Did not throw IndexOutOfRangeException in method Defragment on line 76");
}
catch (IndexOutOfRangeException)
{
}
Assert.AreEqual(4, pooler.Index, "in method Defragment, line 78");
Assert.AreEqual(true, pooler[pooler.Index].Active, "in method Defragment, line 79");
pooler.Defragment();
Assert.AreEqual(3, pooler.Index, "in method Defragment, line 81");
Assert.AreEqual(false, pooler[pooler.Index].Active, "in method Defragment, line 82");
Assert.AreEqual(p5, pooler[0], "in method Defragment, line 83");
Assert.AreEqual(p2, pooler[1], "in method Defragment, line 84");
Assert.AreEqual(p4, pooler[2], "in method Defragment, line 85");
Assert.AreEqual(p3, pooler[3], "in method Defragment, line 86");
Assert.AreEqual(p1, pooler[4], "in method Defragment, line 87");
}
void InstantiateBox(string _alimentName, AlimentState _alimentState, int posFree, int finalPos, int viewID)
{
//Debug.Log("Receive RPC InstantiateBox :" + _alimentName + " AlimentState:" + _alimentState + " viewID:" + viewID);
KeyValuePair <string, AlimentState> key = new KeyValuePair <string, AlimentState>(_alimentName, _alimentState);
Poolable foodToInstantiate = PoolManager.Instance.Get(key, viewID);
BoxDatasController box = foodToInstantiate.GetComponent <BoxDatasController>();
foodToInstantiate.transform.position = PosInstantiation[posFree].position;
foodToInstantiate.transform.rotation = PosInstantiation[posFree].rotation;
box.Init();
box.SetActive(false);
box.Grabable.onGrab += OnGrabBox;
boxInPos.Add(box, posFree);
PosFree.Remove(posFree);
boxInPos[box] = finalPos;
PosFree.Remove(finalPos);
StartCoroutine(TranslateBoxToPosition(box, posFree));
}
void OnTriggerEnter2D(Collider2D col)
{
Rigidbody2D rb = col.attachedRigidbody;
GameObject obj;
if (rb)
{
obj = rb.gameObject;
}
else
{
obj = col.gameObject;
}
Poolable poolable = obj.GetComponent <Poolable> ();
if (poolable)
{
poolable.TryPool();
}
else
{
Destroy(obj);
}
}
/// <summary>
/// Gets a copy of the original gameobject. If none are available, one is added to the pool and returned.
/// When you are done with the pooled object, its IsAvailable() function should return true to be available to the pool again.
/// A maximum pool size can been set through the inspector (defaults to infinite).
/// If the pool has reached that limit and no copies are avaible, the object returned is null.
/// </summary>
public Poolable GetObject()
{
// Grab the first available object
for (int i = 0; i < _Pool.Count; ++i)
{
if (_Pool[i].IsAvailable())
{
return(_Pool[i]);
}
}
// If there are no available objects, make one.
if (_Pool.Count != _MaxSize)
{
GameObject obj = Instantiate(_Original, transform);
Poolable script = obj.GetComponent <Poolable>();
_Pool.Add(script);
script.OnCreation(_SharedResource);
return(script);
}
// The max pool size has been reached and no objects are available. Return null.
return(null);
}
/// <summary>
/// Moves the rocket toward its target.
/// </summary>
private void Update()
{
if ((behaviorFlags & RocketFlags.NoHoming) == 0)
{
if (isHoming)
{
if (target != null && target.CompareTag("Enemy") && targetEnemyScript != null && targetEnemyId != targetEnemyScript.EnemyId)
{
// clear target because it died and has respawned
target = null;
targetPoolableScript = null;
targetEnemyScript = null;
isTargetDead = true;
isHoming = false;
if ((behaviorFlags & RocketFlags.AutoTarget) != 0)
{
AquireTarget();
}
}
else if (targetPoolableScript != null && !targetPoolableScript.IsActive ||
targetEnemyScript != null && targetEnemyScript.Health <= 0 ||
target == null || !target.activeSelf)
{
// clear target because it is dead or deactivated
target = null;
targetPoolableScript = null;
targetEnemyScript = null;
isTargetDead = true;
isHoming = false;
if ((behaviorFlags & RocketFlags.AutoTarget) != 0)
{
AquireTarget();
}
}
if (targetPoolableScript != null && targetPoolableScript.IsActive ||
targetEnemyScript != null && targetEnemyScript.Health > 0 ||
!isTargetDead)
{
// update the target position if it is alive and not null
if (target != null)
{
targetPosition = target.transform.position;
}
}
}
if (target == null && (behaviorFlags & RocketFlags.AutoTarget) != 0)
{
AquireTarget();
}
if (isTargetDead || !isHoming)
{
if (Vector3.Distance(transform.position, targetPosition) < 0.4f)
{
Explode();
}
}
}
smoothFrac += Time.deltaTime / randomTime;
smoothMovement = Vector3.Lerp(initialMovement, randomMovement, smoothFrac);
transform.Translate(0.0f, 0.0f, speed * Time.deltaTime, Space.Self);
transform.Translate(smoothMovement);
Vector3 relativePosition = targetPosition - transform.position;
Quaternion rotation = Quaternion.LookRotation(relativePosition);
transform.rotation =
Quaternion.Slerp(transform.rotation, rotation, homingSensitivity);
}
void SpawnAsteroidExplosion(bool spawnBig, Vector3 position)
{
Poolable explosion = spawnBig ? m_BigExplosionPool.GetRecyclable() : m_SmallExplosionPool.GetRecyclable();
SetPositionRotation(explosion.transform, position);
}
private void AddToPool(Poolable target)
{
objectPool.Enqueue(target);
target.gameObject.SetActive(false);
}
void Enqueue(StatusIndicatorEntry entry)
{
Poolable p = entry.GetComponent <Poolable>();
GameObjectPoolController.Enqueue(p);
}
public void Lock(Poolable instance, object key)
{
EnsureLockExists(instance);
lockedInstances[instance].Lock(key);
}
void Appear(Poolable instance)
{
instance.gameObject.SetActive(true);
}
//Pool the object
private void enqueue(Poolable p)
{
this.initPoolable(p);
p.transform.SetParent(poolableParent);
this.poolables.Enqueue(p);
}
void Enqueue(AbilityMenuEntry entry)
{
Poolable p = entry.GetComponent <Poolable>();
GameObjectPoolController.Enqueue(p);
}
public Pool(Poolable init)
{
pool = new List<Poolable>();
initial = init;
}
void Disappear(Poolable instance)
{
instance.gameObject.SetActive(false);
instance.transform.SetParent(transform, worldPositionStays: false);
}
// instantiate food object in hand of player
public void GetFood(bool _Remove = false)
{
KeyValuePair <string, AlimentState> keyFood;
Poolable foodToGet = null;
if (_Remove == false) // "se servir" button
{
// Take the key of prefab stock in slected button
keyFood = ui.GetPoolableFromSelectedButton();
// change state of the prefab stock in selected button if it's a box
if (keyFood.Value == AlimentState.Box || keyFood.Value == AlimentState.Stack)
{
KeyValuePair <string, AlimentState> newKeyFood = new KeyValuePair <string, AlimentState>(keyFood.Key, AlimentState.InContent);
foodToGet = PoolManager.Instance.Get(newKeyFood, true);
}
else // remove object if state different of box or stack (limited food)
{
limitedFoodsStocked[keyFood] -= 1;
if (limitedFoodsStocked[keyFood] == 0)
{
if (ui.RemoveButton(out keyFood))
{
limitedFoodsStocked.Remove(keyFood);
foodToGet = PoolManager.Instance.Get(keyFood, true);
}
}
else
{
foodToGet = PoolManager.Instance.Get(keyFood, true);
}
}
}
else // remove object "Tout prendre" button
{
if (ui.RemoveButton(out keyFood))
{
foodsStocked.Remove(keyFood);
foodToGet = PoolManager.Instance.Get(keyFood, true);
if (keyFood.Value == AlimentState.Box)
{
foodToGet.GetComponent <BoxDatasController>().Init();
}
}
}
GrabableObject toGrab = foodToGet.GetComponent <GrabableObject>();
toGrab.Init();
toGrab.AllowGrab(true);
if (!player.pInteract.GrabObject(toGrab, false))
{
// player can't grab object.
Debug.Log("grab");
}
else
{
photonView.RPC("GetObjectInColdRoom", RpcTarget.Others, keyFood.Key, keyFood.Value, foodToGet.photonView.ViewID, player.photonView.OwnerActorNr, _Remove);
StopInteraction();
GameManager.Instance.Audio.PlaySound("GrabCardboard", AudioManager.Canal.SoundEffect);
}
}
public void Free(Type type, Poolable instance)
{
Unlock(type, instance, this);
}
public override void Execute(GameObject obj)
{
Poolable.Destroy(obj);
}
void OnEnable()
{
// Get Poolable component here. GObject won't have it on Awake! (change?)
m_Poolable = GetComponent<Poolable>();
//SetRandomForces();
}
public virtual U DequeueScriptByKey <U> (T key) where U : MonoBehaviour
{
Poolable item = DequeueByKey(key);
return(item.GetComponent <U>());
}
internal Releaser(Poolable pooledObject)
{
_pooledObject = pooledObject;
}
//Make sure the object is deactivated
private void initPoolable(Poolable p)
{
p.gameObject.SetActive(false);
}
private void InternalFree(Type type, Poolable instance)
{
EnsurePoolExists(type);
instances[type].Enqueue(instance);
}
