using System.Runtime.CompilerServices; namespace Tertius.Simulation; ///

/// A test of one entity of the snapshot, for . Use a static lambda, so that the compiler /// caches the delegate and nothing allocates. Read the entity through . ///

public delegate bool EntityPredicate(Snapshot snapshot, Entity entity); ///

/// A stored query over the entities of the snapshot: a component mask, a collision mask, places and predicates. It holds /// no source, so a field can keep it, and runs it. The default value matches every live /// entity. Each word returns a new query and leaves this one as it was. ///

/// /// /// Inline, with no allocation: the component mask (, ), the collision mask /// (, , ), one , one Near and one /// . A second In, Near or Where goes into an immutable heap part. Building the /// heap part during an entity's run throws, because it would allocate on every run: build such a query once, in a /// static readonly field of the component. The world runs each component type's class constructor before the type's /// first run, so such a field is built outside the tick. /// /// /// The filters narrow with each call, except , which widens the one any-of set of the collision mask. /// A query whose With and Without share a type would match nothing, so building it throws. A Near /// finds the entities in the frame of its center whose position is within the radius. /// /// public readonly record struct EntityQuery { ///

The component types that a matching entity must all have and must not have.

public ComponentMask Components { get; private init; } ///

The filter over the collision groups of a matching entity's body. An entity without a body is in no group.

public CollisionMask Collision { get; private init; } ///

The frame of the inline , or null.

internal FrameHandle InFrame { get; private init; } ///

The inline Near, or the empty filter ( is false) when the slot is free.

internal QueryFilter NearFilter { get; private init; } ///

The predicate of the inline , or null.

internal EntityPredicate? WherePredicate { get; private init; } ///

The filters that do not fit inline, or null.

internal QueryExtras? Extras { get; private init; } ///

Keeps the entities that have a component. Throws if the query refuses /// .

public EntityQuery With() where T : IComponent { int id = ComponentType.Id; return Components.Without.Contains(id) ? throw new InvalidOperationException( $"The query already refuses {typeof(T).Name}, so With<{typeof(T).Name}> would make it match nothing." ) : this with { Components = Components.AndWith(id), }; } ///

Keeps the entities that have no component. Throws if the query needs /// .

public EntityQuery Without() where T : IComponent { int id = ComponentType.Id; return Components.With.Contains(id) ? throw new InvalidOperationException( $"The query already needs {typeof(T).Name}, so Without<{typeof(T).Name}> would make it match nothing." ) : this with { Components = Components.AndWithout(id), }; } ///

Keeps the entities whose body is in .

public EntityQuery InAll(CollisionGroup group) => this with { Collision = Collision.InAll(group) }; ///

Keeps the entities that have no body in .

public EntityQuery InNone(CollisionGroup group) => this with { Collision = Collision.InNone(group) }; ///

/// Adds to the one any-of set: the query keeps the entities whose body is in at least one /// group of the set. Each call widens the set. ///

public EntityQuery InAny(CollisionGroup group) => this with { Collision = Collision.InAny(group) }; ///

Keeps the entities in . Throws for the null frame.

public EntityQuery In(FrameHandle frame) { var filter = QueryFilter.In(frame); return InFrame.IsNull ? this with { InFrame = frame } : WithExtra(filter); } ///

/// Keeps the entities in the frame of the entity that runs the query whose position is within /// meters of it; that entity matches too when it passes the other filters. A run from /// , which has no such entity, throws. ///

public EntityQuery Near(double radius) => WithNear(QueryFilter.Near(radius)); ///

/// Keeps the entities in the frame of whose position is within /// meters of its position in the snapshot. When is not live, the query matches nothing. ///

public EntityQuery Near(Entity other, double radius) => WithNear(QueryFilter.Near(other, radius)); ///

/// Keeps the entities in whose position is within meters of /// . When the frame is gone, the query matches nothing. ///

public EntityQuery Near(FrameHandle frame, Double3 point, double radius) => WithNear(QueryFilter.Near(frame, point, radius)); ///

Keeps the entities that pass . Use a static lambda, so that it allocates nothing.

public EntityQuery Where(EntityPredicate predicate) { var filter = QueryFilter.Where(predicate); return WherePredicate is null ? this with { WherePredicate = predicate } : WithExtra(filter); } ///

This query with a Near filter: inline while the inline Near is free, else in the heap part.

internal EntityQuery WithNear(in QueryFilter filter) => !NearFilter.HasValue ? this with { NearFilter = filter } : WithExtra(filter); private EntityQuery WithExtra(in QueryFilter filter) => this with { Extras = QueryExtras.Append(Extras, filter) }; ///

/// True if a live passes every filter of the query and every filter of /// , in the front snapshot. The one filter code of every form of the query: the cheap mask /// tests come first. ///

[MethodImpl(MethodImplOptions.AggressiveInlining)] internal bool Matches(in Snapshot snapshot, Entity entity, ReadOnlySpan more) { EntityTable entities = snapshot.World.Entities; if (!Components.Matches(entities.FrontComponents(entity))) return false; if (Collision != CollisionMask.Empty && !Collision.Matches(entities.FrontCollision(entity).Groups)) return false; ref readonly TransformRow row = ref entities.FrontRow(entity); if (!InFrame.IsNull && row.Frame != InFrame) return false; if (!NearFilter.Passes(snapshot, entity, row)) return false; if (WherePredicate != null && !WherePredicate(snapshot, entity)) return false; if (Extras != null) foreach (ref readonly QueryFilter filter in Extras.Filters) if (!filter.Passes(snapshot, entity, row)) return false; foreach (ref readonly QueryFilter filter in more) if (!filter.Passes(snapshot, entity, row)) return false; return true; } } ///

/// The static starts of an chain, such as EntityQuery.With<Crew>(). C# cannot give a /// struct a static and an instance member with one signature, so the starts are static extension members. Each one /// starts from the default query, which matches every live entity. ///

public static class EntityQueryStarts { extension(EntityQuery) { /// public static EntityQuery With() where T : IComponent => default(EntityQuery).With(); /// public static EntityQuery Without() where T : IComponent => default(EntityQuery).Without(); /// public static EntityQuery InAll(CollisionGroup group) => default(EntityQuery).InAll(group); /// public static EntityQuery InNone(CollisionGroup group) => default(EntityQuery).InNone(group); /// public static EntityQuery InAny(CollisionGroup group) => default(EntityQuery).InAny(group); /// public static EntityQuery In(FrameHandle frame) => default(EntityQuery).In(frame); /// public static EntityQuery Near(double radius) => default(EntityQuery).Near(radius); /// public static EntityQuery Near(Entity other, double radius) => default(EntityQuery).Near(other, radius); /// public static EntityQuery Near(FrameHandle frame, Double3 point, double radius) => default(EntityQuery).Near(frame, point, radius); /// public static EntityQuery Where(EntityPredicate predicate) => default(EntityQuery).Where(predicate); } } ///

/// The immutable heap part of an : its filters past the inline In, Near and /// Where, in the order of the calls. Two heap parts are equal when they hold equal filters. ///

internal sealed class QueryExtras : IEquatable { private readonly QueryFilter[] filters; private QueryExtras(QueryFilter[] filters) { this.filters = filters; } public ReadOnlySpan Filters => filters; ///

/// A new heap part with the filters of and then . Throws /// during an entity's run. ///

public static QueryExtras Append(QueryExtras? extras, in QueryFilter filter) => GameplayThread.InEntityRun ? throw new InvalidOperationException( "This entity query needs a heap part for its second In, Near or Where, and an entity's run cannot build one: it would allocate on every run. " + "Build the query once, as a static readonly field of the component, or use the chain from Self.Snapshot.Entities, which keeps such filters on the stack." ) : new([.. extras?.filters ?? [], filter]); public bool Equals(QueryExtras? other) => other is not null && filters.AsSpan().SequenceEqual(other.filters); public override bool Equals(object? obj) => Equals(obj as QueryExtras); public override int GetHashCode() => filters.Length; }