// Use this for initialization
void Start()
{
ins = this;
container = transform;
objects = new GenericPool <ObjectItem>();
components = new GenericPool <ObjectItem>();
}
protected override void Init()
{
_instance = this;
_tower1Pool = new GenericPool <BaseTower>(GetTowerPrefab(TowerType.Tower1), 5);
_tower2Pool = new GenericPool <BaseTower>(GetTowerPrefab(TowerType.Tower2), 5);
_tower3Pool = new GenericPool <BaseTower>(GetTowerPrefab(TowerType.Tower3), 5);
}
/// <summary>
/// Creates a new <see cref="WritableMessageFragment"/> which represents a string.
/// Fragments are created using an ObjectPool so they can be reused. Use <see cref="ReleaseFragment(MessageFragment)"/> to
/// return the fragment or allow the Message to handle returning the fragment if it is part of <see cref="Fragments"/>.
/// </summary>
/// <param name="original">The source string.</param>
/// <returns>A new fragment.</returns>
public WritableMessageFragment CreateTextFragment(string original)
{
var frag = GenericPool <WritableMessageFragment> .Get();
frag.Initialize(this, original);
return(frag);
}
private IEnumerator Routine(GenericPool pool)
{
var remainder = count; // Remaining number of Flake to place
var state = true;
while (state)
{
var batch = Random.Range(spawnRange.x, spawnRange.y);
remainder -= batch;
if (remainder <= 0) // If going into zero or negative, break out of the loop after last execution
{
remainder = 0;
batch -= remainder; // Correct the negative value
state = false;
}
for (var i = 0; i < batch; i++)
{
var flake = pool.CastSingle <Flake>(); // A GenericPool allows to directly cast an Object request
flake.transform.position = new Vector2(Random.Range(rect.xMin, rect.xMax), rect.yMax);
}
yield return(new WaitForSeconds(Random.Range(delayRange.x, delayRange.y))); // Random wait for next placed batch
}
routine = null;
}
public override void Initiate()
{
shellPool = new ShellPool();
shellPool.InitiatePool();
PreSpawnShells(maxSheelCount);
}
public static GenericPool CreateNewPoolWithPrefab(PoolableObject _poolableObjectPrefab, Transform _parent, string _poolName = "Pool", string _poolObjName = "PoolObj", int _maxPoolSize = NoSizeLimit)
{
GenericPool pool = CreateNewPool(_parent, _poolName, _maxPoolSize);
pool.SetPoolableObject(_poolableObjectPrefab, _poolObjName);
return(pool);
}
/// <summary>
/// Creates a <see cref="ReadOnlyMessageFragment"/> which represents string that should be preserved and not modified by any other pseudo methods.
/// Fragments are created using an ObjectPool so they can be reused. Use <see cref="ReleaseFragment(MessageFragment)"/> to
/// return the fragment or allow the Message to handle returning the fragment if it is part of <see cref="Fragments"/>.
/// </summary>
/// <param name="original">The source string.</param>
/// <returns>A new fragment.</returns>
public ReadOnlyMessageFragment CreateReadonlyTextFragment(string original)
{
var frag = GenericPool <ReadOnlyMessageFragment> .Get();
frag.Initialize(this, original);
return(frag);
}
private void Start()
{
audioSource = GetComponent <AudioSource>();
anim = GetComponentInChildren <Animator>();
pool = ProjectilePool.instance.pool;
playerPhy = GetComponent <PlayerController>();
}
public static GenericPool CreateNewPool <T>(Transform _parent, string _poolName = "Pool", string _poolObjName = "PoolObj", int _maxPoolSize = NoSizeLimit) where T : PoolableObject
{
GenericPool pool = CreateNewPool(_parent, _poolName, _maxPoolSize);
T poolObj = GameObjectUtil.CreateInstance <T>(pool.transform, _poolObjName);
pool.SetPoolableObject(poolObj, _poolObjName);
return(pool);
}
public static GenericPool CreateNewPool(Transform _parent, string _poolName = "Pool", int _maxPoolSize = NoSizeLimit)
{
GenericPool pool = GameObjectUtil.CreateInstance <GenericPool>(_parent, _poolName);
pool.maxPoolSize = _maxPoolSize;
pool.InitializePool();
return(pool);
}
/// <summary>
/// Creates a new message to represent a piece of text.
/// </summary>
/// <param name="text">The source text.</param>
/// <returns>A new Message instance.</returns>
internal static Message CreateMessage(string text)
{
var message = GenericPool <Message> .Get();
message.Fragments.Add(message.CreateTextFragment(text));
message.Original = text;
return(message);
}
protected virtual void InitializeCollectionsIfNecessary()
{
Teams = Teams ?? new Dictionary <string, LobbyTeamUi>();
TeamsPool = TeamsPool ?? new GenericPool <LobbyTeamUi>(TeamPrefab);
Users = Users ?? new Dictionary <string, LobbyUserUi>();
UsersPool = UsersPool ?? new GenericPool <LobbyUserUi>(UserPrefab);
}
private SocketAsyncEventArgs CreateNewSocketAsyncEventArgs(GenericPool <SocketAsyncEventArgs> pool)
{
SocketAsyncEventArgs acceptEventArg = new SocketAsyncEventArgs();
acceptEventArg.Completed += new EventHandler <SocketAsyncEventArgs>(AcceptEventArg_Completed);
return(acceptEventArg);
}
protected override void Destroy()
{
loadTables.Clear();
loadTablesOperation.Clear();
m_PreloadTablesOperations.Clear();
m_TableReferences.Clear();
GenericPool <PreLoadTablesOperation <TTable, TEntry> > .Release(this);
}
internal void WriteAsyncLogEvents(ArraySegment <AsyncLogEventInfo> logEventInfos, AsyncContinuation continuation)
{
if (logEventInfos.Count == 0)
{
continuation(null);
}
else
{
AsyncLogEventInfo[] wrappedLogEventInfos = null;
try
{
Counter counter;
GenericPool <ContinueWhenAll> continuePool = null;
int remaining = logEventInfos.Count;
if (this.LoggingConfiguration.PoolingEnabled())
{
counter = this.LoggingConfiguration.PoolFactory.Get <Counter>();
continuePool = this.LoggingConfiguration.PoolFactory.Get <GenericPool <ContinueWhenAll>, ContinueWhenAll>();
wrappedLogEventInfos = this.LoggingConfiguration.PoolFactory.Get <AsyncLogEventInfoArrayPool, AsyncLogEventInfo[]>().Get(logEventInfos.Count);
}
else
{
wrappedLogEventInfos = new AsyncLogEventInfo[logEventInfos.Count];
counter = new Counter();
}
counter.Reset(remaining);
for (int i = 0; i < logEventInfos.Count; ++i)
{
AsyncContinuation originalContinuation = logEventInfos.Array[i].Continuation;
ContinueWhenAll cont;
if (continuePool != null)
{
cont = continuePool.Get();
cont.Reset(counter, originalContinuation, continuation);
wrappedLogEventInfos[i] = logEventInfos.Array[i].LogEvent.WithContinuation(cont.Delegate);
}
else
{
cont = new ContinueWhenAll();
}
cont.Reset(counter, originalContinuation, continuation);
wrappedLogEventInfos[i] = logEventInfos.Array[i].LogEvent.WithContinuation(cont.Delegate);
}
this.WriteAsyncLogEvents(new ArraySegment <AsyncLogEventInfo>(wrappedLogEventInfos, 0, logEventInfos.Count));
}
finally
{
this.LoggingConfiguration.PutBack(wrappedLogEventInfos);
}
}
}
/// <inheritdoc cref="Message.CreateReadonlyTextFragment(string, int, int)"/>
public ReadOnlyMessageFragment CreateReadonlyTextFragment(int start, int end)
{
var frag = GenericPool <ReadOnlyMessageFragment> .Get();
var startIndex = m_StartIndex == -1 ? start : m_StartIndex + start;
frag.Initialize(@Message, m_OriginalString, startIndex, end);
return(frag);
}
public void Dispose()
{
if (disposed)
{
throw new ObjectDisposedException(ToString());
}
GenericPool <Flow> .Free(this);
}
public void Recycle(GameObject go)
{
GenericPool <T> pool = Find(go.name);
if (pool != null)
{
pool.Recycle(go);
}
}
protected virtual void Awake()
{
redApplePool = GenericPool.Create(gameObject, spawns.Length * 2, redApple);
goldenApplePool = GenericPool.Create(gameObject, spawns.Length, goldenApple);
EventManager <GameStartEvent> .AddListener(this);
EventManager <GameEndEvent> .AddListener(this);
}
public Executable GetExecutable(HiraComponentContainer target, IBlackboardComponent blackboard)
{
if (target is IContainsComponent <NavMeshAgent> navigableTarget && navigableTarget.Component != null)
{
return(GenericPool <StaticMoveToExecutable> .Retrieve().Init(navigableTarget.Component, blackboard, targetPosition, followTarget, speed, tolerance));
}
return(AutoFailExecutable.INSTANCE);
}
public Executable GetExecutable(HiraComponentContainer target, IBlackboardComponent blackboard)
{
if (target is IContainsComponent <AgentAnimator> animatedTarget)
{
return(GenericPool <KickExecutable> .Retrieve().Init(animatedTarget.Component));
}
return(AutoFailExecutable.INSTANCE);
}
private void Initialize()
{
bulletType = BulletType.Default;
bulletPool = GenericPool.CreateNewPool(this.transform, "BulletPool");
SetBulletPrefab(BulletType.Default);
bulletSpawnTimer = Timer.InstantiateTimer(this.transform, "BulletTimer");
bulletSpawnTimer.SetOnCompleteCallback(ShootBullet);
bulletSpawnTimer.RunTimer(bulletSpawnPeriod, true);
}
public EnemySpawner(GenericPool <EnemyBase> _enemyPool, List <Transform> _spawnPos, Transform _enemyHolder, MonoBehaviour _mono, EnemyBase[] _enemies)
{
enemyPool = _enemyPool;
spawnPos = _spawnPos;
enemies = _enemies;
mono = _mono;
enemyHolder = _enemyHolder;
PrespawnEnemies();
}
public TcpCommunicationService(IApplicationContext applicationContext, ILoggerService loggerService, IBufferManagerFactory bufferManagerFactory, IPacketsHandler packetsHandler, INodesResolutionService nodesResolutionService)
: base(applicationContext, loggerService, bufferManagerFactory, packetsHandler, nodesResolutionService)
{
_acceptEventArgsPool = new GenericPool <SocketAsyncEventArgs>(10);
for (Int32 i = 0; i < 10; i++)
{
_acceptEventArgsPool.Push(CreateNewSocketAsyncEventArgs(_acceptEventArgsPool));
}
}
public static Flow New(GraphReference reference)
{
Ensure.That(nameof(reference)).IsNotNull(reference);
var flow = GenericPool <Flow> .New(() => new Flow());;
flow.stack = reference.ToStackPooled();
return(flow);
}
internal void Release()
{
foreach (var f in Fragments)
{
ReleaseFragment(f);
}
Fragments.Clear();
GenericPool <Message> .Release(this);
}
protected override void Init()
{
_terrainPool = new GenericPool<TerrainFragment>(_terrainPrefab, (uint)_startTerrainCount);
bool genObjects = false;
for(int i=1; i<=_startTerrainCount; i++)
{
GenerateTerrain(genObjects);
genObjects = true;
}
}
public static GenericPool <T> GetPool <T>() where T : class, new()
{
var type = typeof(T);
if (!_pools.TryGetValue(type, out var pool))
{
pool = new GenericPool <T>(InitialSize);
_pools.Add(type, pool);
}
return((GenericPool <T>)pool);
}
public void Clear()
{
Assert.IsNotNull(m_Requests);
foreach (var pair in m_Requests)
{
pair.Value.Clear();
GenericPool <Set> .Release(pair.Value);
}
m_Requests.Clear();
}
/// <summary>
/// Returns a Fragment back to its ObjectPool so it can be used again.
/// </summary>
/// <param name="fragment"></param>
public void ReleaseFragment(MessageFragment fragment)
{
if (fragment is WritableMessageFragment wmf)
{
GenericPool <WritableMessageFragment> .Release(wmf);
}
else if (fragment is ReadOnlyMessageFragment romf)
{
GenericPool <ReadOnlyMessageFragment> .Release(romf);
}
}
public CullingItemFactory()
{
var shadowPool = new GenericPool <ShadowCullingHandler>();
shadowPool.SetMeta(new ShadowCullingHandler(shadowPool.Reuse));
_shadowPool = shadowPool;
var probePool = new GenericPool <ProbeCullingHandler>();
probePool.SetMeta(new ProbeCullingHandler(probePool.Reuse));
_probePool = probePool;
}
public void AddSceneObject(BaseSceneObject sceneObject, GenericPool<BaseSceneObject> pool)
{
_sceneObjects.Add(new InstanceSceneObjects(sceneObject, pool));
}
public void InitPool()
{
SceneObjectPool = new GenericPool<BaseSceneObject>(SceneObjectPrefab, 5);
}
public InstanceSceneObjects(BaseSceneObject sceneObject, GenericPool<BaseSceneObject> pool)
{
SceneObject = sceneObject;
Pool = pool;
}
void Awake()
{
_fireDelayTimer = new GameTimer(_fireDelay);
_drawingTime = _gunAnimation["Gun Draw"].length;
_drawingTimer = new GameTimer(_drawingTime);
_bulletPool = GenericPool<Bullet>.CreatePool(_bulletPrefab, 30);
_gunAnimation.Play("Gun Draw");
_gunAnimation.Sample();
_gunAnimation.Stop();
}
