public static EntityAction <TComponent> Create(World world)
{
var instance = PoolClass <EntityAction <TComponent> > .Spawn();
world.RegisterEntityAction(instance);
return(instance);
}
public override void Recycle()
{
this.anchorPosition = default;
this.rotation = default;
this.scale = default;
PoolClass <RectState> .Recycle(this);
}
public void Copy(Node from, ref Node to)
{
if (to == null)
{
to = PoolClass <GridNode> .Spawn();
}
to.CopyFrom(from);
}
public static void Release(ref FiltersStorage storage)
{
if (storage == null)
{
return;
}
PoolClass <FiltersStorage> .Recycle(ref storage);
}
public static TState CreateState <TState>() where TState : class, IStateBase, new()
{
var state = PoolClass <TState> .Spawn();
state.entityId = default;
state.tick = default;
return(state);
}
public static void ReleaseState <TState>(ref State state) where TState : State, new()
{
state.entityId = default;
state.tick = default;
state.randomState = default;
PoolClass <TState> .Recycle((TState)state);
state = null;
}
public override void RemoveNode(ref Node node, bool bruteForceConnections = false)
{
base.RemoveNode(ref node, bruteForceConnections);
var g = (GridNode)node;
PoolClass <GridNode> .Recycle(ref g);
node = null;
}
public void Dispose()
{
this.internalCall = default;
this.animationComplete = default;
this.hierarchyComplete = default;
this.baseComplete = default;
this.instance = null;
this.parameters = default;
PoolClass <ShowHideClosureParametersClass> .Recycle(this);
}
public virtual T AddNode <T>() where T : Node, new()
{
var node = PoolClass <T> .Spawn();
node.graph = this;
node.index = this.nodes.Count;
this.nodes.Add(node);
return(node);
}
public static void CreateWorld <TState>(ref World <TState> worldRef, float tickTime, int forcedWorldId = 0) where TState : class, IState <TState>, new()
{
if (worldRef != null)
{
WorldUtilities.ReleaseWorld(ref worldRef);
}
worldRef = PoolClass <World <TState> > .Spawn();
worldRef.SetId(forcedWorldId);
((IWorldBase)worldRef).SetTickTime(tickTime);
Worlds <TState> .Register(worldRef);
}
/// <summary>
/// Initializes the contents of the stack from an existing collection.
/// </summary>
/// <param name="collection">A collection from which to copy elements.</param>
private void InitializeFromCollection(IEnumerable <T> collection)
{
// We just copy the contents of the collection to our stack.
Node lastNode = null;
foreach (T element in collection)
{
Node newNode = (this.usePool == true ? PoolClass <Node> .Spawn() : new Node());
newNode.m_value = element;
newNode.m_next = lastNode;
lastNode = newNode;
}
m_head = lastNode;
}
public static string UnpackDirect(Packer packer)
{
var length = Int32Serializer.UnpackDirect(packer);
var sb = PoolClass <System.Text.StringBuilder> .Spawn();
sb.Clear();
sb.Capacity = length;
for (int i = 0; i < length; ++i)
{
sb.Append(CharSerializer.UnpackDirect(packer));
}
var res = sb.ToString();
PoolClass <System.Text.StringBuilder> .Recycle(ref sb);
return(res);
}
/// <summary>
/// Local helper function to Pop an item from the stack, slow path
/// </summary>
/// <param name="result">The popped item</param>
/// <returns>True if succeeded, false otherwise</returns>
private bool TryPopCore(out T result)
{
Node poppedNode;
if (TryPopCore(1, out poppedNode) == 1)
{
result = poppedNode.m_value;
if (this.usePool == true)
{
PoolClass <Node> .Recycle(ref poppedNode);
}
return(true);
}
result = default(T);
return(false);
}
public static void ReleaseWorld <TState>(ref World world) where TState : State, new()
{
if (world == null || world.isActive == false)
{
world = null;
return;
}
Worlds.DeInitializeBegin();
var w = world;
world.RecycleResetState <TState>();
PoolClass <World> .Recycle(ref w);
world.RecycleStates <TState>();
Worlds.UnRegister(world);
Worlds.DeInitializeEnd();
}
/// <summary>
/// Inserts an object at the top of the <see cref="ConcurrentStack{T}"/>.
/// </summary>
/// <param name="item">The object to push onto the <see cref="ConcurrentStack{T}"/>. The value can be
/// a null reference (Nothing in Visual Basic) for reference types.
/// </param>
public void Push(T item)
{
// Pushes a node onto the front of the stack thread-safely. Internally, this simply
// swaps the current head pointer using a (thread safe) CAS operation to accomplish
// lock freedom. If the CAS fails, we add some back off to statistically decrease
// contention at the head, and then go back around and retry.
Node newNode = (this.usePool == true ? PoolClass <Node> .Spawn() : new Node());
newNode.m_value = item;
newNode.m_next = m_head;
if (Interlocked.CompareExchange(ref m_head, newNode, newNode.m_next) == newNode.m_next)
{
return;
}
// If we failed, go to the slow path and loop around until we succeed.
PushCore(newNode, newNode);
}
/// <summary>
/// Removes all objects from the <see cref="ConcurrentStack{T}"/>.
/// </summary>
public void Clear()
{
// Clear the list by setting the head to null. We don't need to use an atomic
// operation for this: anybody who is mutating the head by pushing or popping
// will need to use an atomic operation to guarantee they serialize and don't
// overwrite our setting of the head to null.
var current = this.m_head;
this.m_head = null;
if (this.usePool == true)
{
while (current != null)
{
PoolClass <Node> .Recycle(ref current);
current = current.m_next;
}
}
}
/// <summary>
/// Notifies that resource was deactivated.
/// </summary>
/// <remarks>
/// This function should call direct only owner/manager of this resource.
/// </remarks>
/// <param name="source">The source of deactivation.</param>
public virtual void NotifyDeactivated(object source)
{
using (var ob = PoolClass <HashSet <MyResource> > .Acquire())
{
HashSet <MyResource> collectedResources = ob;
collectedResources.Clear();
CollectResources(collectedResources, false);
foreach (var collectedResource in collectedResources)
{
collectedResource.NotifyDeactivated(this);
}
}
// removed, it's "Storkovina"
//this.IsActivated = false;
OnDeactivated(source);
}
public static void CreateWorld <TState>(ref World worldRef, float tickTime, int forcedWorldId = 0, uint seed = 1u) where TState : State, new()
{
if (seed <= 0u)
{
seed = 1u;
}
if (worldRef != null)
{
WorldUtilities.ReleaseWorld <TState>(ref worldRef);
}
worldRef = PoolClass <World> .Spawn();
worldRef.SetId(forcedWorldId);
var worldInt = worldRef;
worldInt.SetSeed(seed);
worldInt.SetTickTime(tickTime);
Worlds.Register(worldRef);
}
void Update()
{
if (Input.GetKeyDown(KeyCode.Q))
{
Debug.Log(SingletonDebug.GetPtr().text());
} // Q Down
if (Input.GetKeyDown(KeyCode.W))
{
Debug.Log(MonoBehaviourSingletonDebug.GetPtr().text());
} // Q Down
if (Input.GetKeyDown(KeyCode.E))
{
new DataFromCSV("/Excels/buildings.csv");
} // Q Down
if (Input.GetKeyDown(KeyCode.A))
{
PoolClass pool = new PoolClass();
pool.InitPoolType <DebugInput>(1);
var temp2 = pool.GetObject <pepe>();
var temp3 = pool.GetObject <pepe>();
pool.FreeObject <pepe>(temp2);
temp3 = pool.GetObject <pepe>();
} // Q Down
if (Input.GetKeyDown(KeyCode.S))
{
PoolGameObject pool = new PoolGameObject();
pool.InitPoolGameObject(gameObject, "DebugInput", 1);
var temp2 = pool.GetGameObject("DebugInput");
var temp3 = pool.GetGameObject("DebugInput");
pool.FreeGameObject("DebugInput", temp2);
} // Q Down
}
/// <summary>
/// Attempts to pop and return the object at the top of the <see cref="ConcurrentStack{T}"/>.
/// </summary>
/// <param name="result">
/// When this method returns, if the operation was successful, <paramref name="result"/> contains the
/// object removed. If no object was available to be removed, the value is unspecified.
/// </param>
/// <returns>true if an element was removed and returned from the top of the <see
/// cref="ConcurrentStack{T}"/>
/// succesfully; otherwise, false.</returns>
public bool TryPop(out T result)
{
Node head = m_head;
//stack is empty
if (head == null)
{
result = default(T);
return(false);
}
if (Interlocked.CompareExchange(ref m_head, head.m_next, head) == head)
{
result = head.m_value;
if (this.usePool == true)
{
PoolClass <Node> .Recycle(ref head);
}
return(true);
}
// Fall through to the slow path.
return(TryPopCore(out result));
}
public override void OnRecycle()
{
this.size = default;
this.nodeSize = default;
this.initialPenalty = default;
this.diagonalCostFactor = default;
this.connectionsType = default;
this.agentHeight = default;
this.checkMask = default;
this.collisionMask = default;
this.collisionCheckRadius = default;
if (this.nodes != null)
{
Debug.Log("Recycle: " + this.nodes.Count);
for (int i = 0; i < this.nodes.Count; ++i)
{
var node = (GridNode)this.nodes[i];
PoolClass <GridNode> .Recycle(ref node);
}
this.nodes.Clear();
}
}
public static void ReleaseState <TState>(ref TState state) where TState : class, IStateBase, new()
{
state.entityId = default;
state.tick = default;
PoolClass <TState> .Recycle(ref state);
}
public static void Release(ref FiltersStorage storage)
{
PoolClass <FiltersStorage> .Recycle(ref storage);
}
public static void Release(ref Storage storage)
{
PoolClass <Storage> .Recycle(ref storage);
}
public static void ReleaseWorld <TState>(ref World <TState> world) where TState : class, IState <TState>, new()
{
Worlds <TState> .UnRegister(world);
PoolClass <World <TState> > .Recycle(ref world);
}
public IViewsProvider <TEntity> Create()
{
return(PoolClass <UnityGameObjectProvider <TEntity> > .Spawn());
}
public static void Release <T>(ref Storage <T> storage) where T : struct, IEntity
{
PoolClass <Storage <T> > .Recycle(ref storage);
}
public static void Release(ref Components components)
{
PoolClass <Components> .Recycle(ref components);
}
public static void Release <TEntity, TState>(ref Components <TEntity, TState> components) where TState : class, IState <TState>, new() where TEntity : struct, IEntity
{
PoolClass <Components <TEntity, TState> > .Recycle(ref components);
}
public void Destroy(IViewsProvider <TEntity> instance)
{
PoolClass <UnityGameObjectProvider <TEntity> > .Recycle((UnityGameObjectProvider <TEntity>) instance);
}
