///--------------------------------------------
void Preallocate <T>(uint groupID, uint size) where T : IEntityDescriptor, new()
{
var entityViewsToBuild = EntityDescriptorTemplate <T> .descriptor.entitiesToBuild;
var numberOfEntityViews = entityViewsToBuild.Length;
//reserve space in the database
if (_groupEntityViewsDB.TryGetValue(groupID, out var group) == false)
{
group = _groupEntityViewsDB[groupID] = new FasterDictionary <RefWrapper <Type>, ITypeSafeDictionary>();
}
for (var index = 0; index < numberOfEntityViews; index++)
{
var entityViewBuilder = entityViewsToBuild[index];
var entityViewType = entityViewBuilder.GetEntityType();
var refWrapper = new RefWrapper <Type>(entityViewType);
if (group.TryGetValue(refWrapper, out var dbList) == false)
{
group[refWrapper] = entityViewBuilder.Preallocate(ref dbList, size);
}
else
{
dbList.SetCapacity(size);
}
if (_groupsPerEntity.TryGetValue(refWrapper, out var groupedGroup) == false)
{
groupedGroup = _groupsPerEntity[refWrapper] =
new FasterDictionary <uint, ITypeSafeDictionary>();
}
groupedGroup[groupID] = dbList;
}
}
void CopyEntityToDictionary(EGID entityGID, EGID toEntityGID,
FasterDictionary <RefWrapper <Type>, ITypeSafeDictionary> fromGroup,
FasterDictionary <RefWrapper <Type>, ITypeSafeDictionary> toGroup, Type entityViewType)
{
var wrapper = new RefWrapper <Type>(entityViewType);
if (fromGroup.TryGetValue(wrapper, out var fromTypeSafeDictionary) == false)
{
throw new ECSException("no entities in from group eid: ".FastConcat(entityGID.entityID)
.FastConcat(" group: ").FastConcat(entityGID.groupID));
}
#if DEBUG && !PROFILER
if (fromTypeSafeDictionary.Has(entityGID.entityID) == false)
{
throw new EntityNotFoundException(entityGID, entityViewType);
}
#endif
if (toGroup.TryGetValue(wrapper, out var toEntitiesDictionary) == false)
{
toEntitiesDictionary = fromTypeSafeDictionary.Create();
toGroup.Add(wrapper, toEntitiesDictionary);
}
//todo: this must be unit tested properly
if (_groupsPerEntity.TryGetValue(wrapper, out var groupedGroup) == false)
{
groupedGroup = _groupsPerEntity[wrapper] =
new FasterDictionary <uint, ITypeSafeDictionary>();
}
groupedGroup[toEntityGID.groupID] = toEntitiesDictionary;
fromTypeSafeDictionary.AddEntityToDictionary(entityGID, toEntityGID, toEntitiesDictionary);
}
public override bool Shoot(Player player, ref Vector2 position, ref float speedX, ref float speedY, ref int type, ref int damage, ref float knockBack)
{
if (drive is null)
{
return(false);
}
float c = maxCharge;
RefWrapper <float> projCharge = getCharge;
//Main.NewText($"{getCharge}/{c}");
if (powerCellItem.type == ItemID.LihzahrdPowerCell)
{
RefWrapper <float> charge = powerCellItem.GetGlobalItem <PowerCellGlobalItem>().charge;
if (charge.value < PowerCellGlobalItem.LihzahrdMaxCharge)
{
return(false);
}
projCharge = maxCharge;
charge.value = 0;
}
base.Shoot(player, ref position, ref speedX, ref speedY, ref type, ref damage, ref knockBack);
ActionContext context = ((BasicGlyphProjectile)Main.projectile[lastProj].modProjectile).context;
context.charge = projCharge;
context.Caster = player;
context.color = LensGlobalItem.getColor(lensItem);
//((BasicGlyphProjectile)Main.projectile[lastProj].modProjectile).context.charge = projCharge;
//((BasicGlyphProjectile)Main.projectile[lastProj].modProjectile).context.Caster = player;
//((BasicGlyphProjectile)Main.projectile[lastProj].modProjectile).context.color = LensGlobalItem.getColor(lensItem);
return(false);
}
///--------------------------------------------
void Preallocate <T>(ExclusiveGroupStruct groupID, uint size) where T : IEntityDescriptor, new()
{
using (var profiler = new PlatformProfiler("Preallocate"))
{
var entityComponentsToBuild = EntityDescriptorTemplate <T> .descriptor.componentsToBuild;
var numberOfEntityComponents = entityComponentsToBuild.Length;
FasterDictionary <RefWrapper <Type>, ITypeSafeDictionary> group = GetOrCreateGroup(groupID, profiler);
for (var index = 0; index < numberOfEntityComponents; index++)
{
var entityComponentBuilder = entityComponentsToBuild[index];
var entityComponentType = entityComponentBuilder.GetEntityComponentType();
var refWrapper = new RefWrapper <Type>(entityComponentType);
if (group.TryGetValue(refWrapper, out var dbList) == false)
{
group[refWrapper] = entityComponentBuilder.Preallocate(ref dbList, size);
}
else
{
dbList.SetCapacity(size);
}
if (_groupsPerEntity.TryGetValue(refWrapper, out var groupedGroup) == false)
{
groupedGroup = _groupsPerEntity[refWrapper] = new FasterDictionary <uint, ITypeSafeDictionary>();
}
groupedGroup[groupID] = dbList;
}
}
}
public void shouldUseReferenceEqualityForEquals()
{
string s1 = "Hello";
string s2 = new string(s1.AsSpan());
RefWrapper <string> w1 = s1, w2 = s2;
Assert.True(w1.Equals(w1));
Assert.True(w1.Equals((object)w1));
Assert.True(w1.Equals(s1));
Assert.True(w1.Equals((object)s1));
Assert.True(w2.Equals(w2));
Assert.True(w2.Equals((object)w2));
Assert.True(w2.Equals(s2));
Assert.True(w2.Equals((object)s2));
Assert.False(w1.Equals(w2));
Assert.False(w1.Equals((object)w2));
Assert.False(w1.Equals(s2));
Assert.False(w1.Equals((object)s2));
Assert.False(w2.Equals(w1));
Assert.False(w2.Equals((object)w1));
Assert.False(w2.Equals(s1));
Assert.False(w2.Equals((object)s1));
Assert.False(w1.Equals(new object()));
Assert.True(default(RefWrapper <string>).Equals(null));
Assert.True(default(RefWrapper <string>).Equals((object)null));
Assert.True(default(RefWrapper <string>).Equals((object)default(RefWrapper <string>)));
Assert.False(default(RefWrapper <string>).Equals(w1));
Assert.False(default(RefWrapper <string>).Equals(w2));
Assert.False(w1.Equals(default(RefWrapper <string>)));
Assert.False(w1.Equals(default(RefWrapper <string>)));
Assert.False(w1.Equals((object)default(RefWrapper <string>)));
Assert.False(w1.Equals((object)default(RefWrapper <string>)));
}
public void shouldWrapWithConversionOperator()
{
var obj = new object();
RefWrapper <object> wrapper = obj;
Assert.Same(wrapper.value, obj);
}
public void shouldProvideUniqueInstancePerThreadWithDifferentSeed()
{
var queue1 = new ConcurrentQueue <Random>();
var queue2 = new ConcurrentQueue <Random>();
var threads = new Thread[10];
void worker()
{
queue1.Enqueue(ThreadStaticRandom.instance);
queue2.Enqueue(ThreadStaticRandom.instance);
}
for (int i = 0; i < threads.Length; i++)
{
threads[i] = new Thread(worker);
threads[i].Start();
}
for (int i = 0; i < threads.Length; i++)
{
threads[i].Join();
}
Assert.Equal(queue1.Count, threads.Length);
Assert.Equal(queue2.Count, threads.Length);
var instances = new RefWrapper <Random> [threads.Length];
var instances2 = new RefWrapper <Random> [threads.Length];
for (int i = 0; i < instances.Length; i++)
{
Random inst;
queue1.TryDequeue(out inst);
instances[i] = inst;
queue2.TryDequeue(out inst);
instances2[i] = inst;
}
Assert.Equal(instances.Length, instances.Distinct().Count());
Assert.Equal(instances2.Length, instances2.Distinct().Count());
Assert.True(instances.ToHashSet().SetEquals(instances2.ToHashSet()));
var bigints = new BigInteger[instances.Length];
for (int i = 0; i < instances.Length; i++)
{
bigints[i] = randomBigInt(instances[i].value, 64);
}
Assert.Equal(bigints.Length, bigints.Distinct().Count());
BigInteger randomBigInt(Random r, int byteLength)
{
byte[] b = new byte[byteLength];
r.NextBytes(b);
return(new BigInteger(b, isUnsigned: true));
}
}
public IActionResult Data()
{
RefWrapper <IList <President> > widgets = new RefWrapper <IList <President> >
{
Value = new List <President>()
};
return(View(GetModel(new WidgetGetter(widgets))));
}
public void shouldUseReferenceEqualityForHashCode()
{
string s1 = "Hello";
string s2 = new string(s1.AsSpan());
RefWrapper <string> w1 = s1, w2 = s2;
Assert.Equal(w1.GetHashCode(), RuntimeHelpers.GetHashCode(s1));
Assert.Equal(w2.GetHashCode(), RuntimeHelpers.GetHashCode(s2));
}
public static int Main()
{
RefWrapper a = new RefWrapper();
arr = new RefWrapper[1];
arr[0] = a;
RefWrapper e = GetElement(); // force struct retyping to ref.
arr[0] = e; // a struct typed copy.
return(100);
}
public void shouldUseReferenceEqualityForOperator()
{
string s1 = "Hello";
string s2 = new string(s1.AsSpan());
RefWrapper <string> w1 = s1, w2 = s2;
RefWrapper <string> w3 = w1, w4 = w2;
Assert.True(w1 == w3);
Assert.True(w2 == w4);
Assert.True(w1 != w2);
Assert.True(w1 != w4);
Assert.False(w1 != w3);
Assert.False(w2 != w4);
Assert.False(w1 == w2);
Assert.False(w1 == w4);
}
public static ExclusiveGroupStruct AddTag <T>(this ExclusiveGroupStruct group) where T : GroupTag <T>
{
if (_addTransitions.TryGetValue(group, out var transitions))
{
var type = new RefWrapper <Type>(typeof(T));
if (transitions.TryGetValue(type, out var result))
{
return(result);
}
}
throw new ECSException("No add transition found for type "
.FastConcat(typeof(T).ToString())
.FastConcat(" in group ").FastConcat(group)
);
}
public static void SetTagRemoval <T>(this ExclusiveGroupStruct group, ExclusiveGroupStruct target, bool setReverse = true) where T : GroupTag <T>
{
if (_removeTransitions.TryGetValue(group, out var transitions) == false)
{
transitions = new FasterDictionary <RefWrapper <Type>, ExclusiveGroupStruct>();
_removeTransitions[group] = transitions;
}
var type = new RefWrapper <Type>(typeof(T));
transitions[type] = target;
if (setReverse)
{
SetTagAddition <T>(target, group, false);
}
}
public void EndPlanExecution()
{
if (GetActorGroup() != null)
{
ending = true;
foreach (var t in new List <Task>(tasks))
{
t.EndExecution();
RemoveTaskFromPlan(t);
}
//tasks.Clear();
Debug.Log("ended plan");
GetActorGroup().UnregisterOwnedPlan(this);
_group = null;
}
}
public void AddEngine(IEngine engine)
{
var type = engine.GetType();
var refWrapper = new RefWrapper <Type>(type);
DBC.ECS.Check.Require(engine != null, "Engine to add is invalid or null");
DBC.ECS.Check.Require(
_enginesTypeSet.Contains(refWrapper) == false ||
type.ContainsCustomAttribute(typeof(AllowMultipleAttribute)) == true
, "The same engine has been added more than once, if intentional, use [AllowMultiple] class attribute "
.FastConcat(engine.ToString()));
try
{
if (engine is IReactOnAddAndRemove viewEngine)
{
CheckEntityComponentsEngine(viewEngine, _reactiveEnginesAddRemove);
}
if (engine is IReactOnSwap viewEngineSwap)
{
CheckEntityComponentsEngine(viewEngineSwap, _reactiveEnginesSwap);
}
_enginesTypeSet.Add(refWrapper);
_enginesSet.Add(engine);
if (engine is IDisposable)
{
_disposableEngines.Add(engine as IDisposable);
}
if (engine is IQueryingEntitiesEngine queryableEntityComponentEngine)
{
queryableEntityComponentEngine.entitiesDB = _entitiesDB;
queryableEntityComponentEngine.Ready();
}
}
catch (Exception e)
{
throw new ECSException("Code crashed while adding engine ".FastConcat(engine.GetType().ToString(), " ")
, e);
}
}
void CopyEntityToDictionary(EGID entityGID, EGID toEntityGID,
FasterDictionary <RefWrapper <Type>, ITypeSafeDictionary> fromGroup,
FasterDictionary <RefWrapper <Type>, ITypeSafeDictionary> toGroup,
Type entityViewType)
{
var wrapper = new RefWrapper <Type>(entityViewType);
ITypeSafeDictionary fromTypeSafeDictionary = GetTypeSafeDictionary(entityGID.groupID, fromGroup, wrapper);
#if DEBUG && !PROFILER
if (fromTypeSafeDictionary.Has(entityGID.entityID) == false)
{
throw new EntityNotFoundException(entityGID, entityViewType);
}
#endif
ITypeSafeDictionary toEntitiesDictionary =
GetOrCreateTypeSafeDictionary(toEntityGID.groupID, toGroup, wrapper, fromTypeSafeDictionary);
fromTypeSafeDictionary.AddEntityToDictionary(entityGID, toEntityGID, toEntitiesDictionary);
}
public static void SetTagSwap <TRemove, TAdd>(this ExclusiveGroupStruct group, ExclusiveGroupStruct target, bool setReverse = true)
where TRemove : GroupTag <TRemove> where TAdd : GroupTag <TAdd>
{
if (_swapTransitions.TryGetValue(group, out var transitions) == false)
{
transitions = new FasterDictionary <RefWrapper <Type>, ExclusiveGroupStruct>();
_swapTransitions[group] = transitions;
}
var type = new RefWrapper <Type>(typeof(TAdd));
transitions[type] = target;
// To avoid needing to check if the group already has the tag when swaping (prevent ecs exceptions).
// The current groups adds the removed tag pointing to itself.
type = new RefWrapper <Type>(typeof(TRemove));
transitions[type] = group;
if (setReverse)
{
SetTagSwap <TAdd, TRemove>(target, group, false);
}
}
/// <summary>
/// Constructor with parameters for construction with <see cref="VariableSource"/>
/// </summary>
/// <param name="value"></param>
private Variable(RefWrapper <Complex> value, RefWrapper <string> label)
{
_Value = value;
_Label = label;
}
/// <summary>
/// Constructor with parameters for static constants and implicit conversions
/// </summary>
private Variable(Complex value)
{
_Value = new RefWrapper <Complex>(value);
}
public override void AI()
{
ActionItem item;
bool fail;
if (context.Caster is null)
{
context.Caster = Main.player[projectile.owner];
}
int cycleCount = 0;
object ret;
if ((glyphType & GlyphProjectileType.Tracer) != 0)
{
Dust.NewDustPerfect(projectile.Center, 267, new Vector2(projectile.velocity.X * 0.2f, projectile.velocity.Y * 0.2f), 100, context.color, 0.75f).noGravity = true;
}
RefWrapper <float> charge = context.charge;
if (context.costMult == -1 && context.Caster is Player player)
{
charge.value = player.statMana / 20;
}
while (context.Delay < 1 && (glyphType & GlyphProjectileType.Paused) == 0)
{
try {
fail = context.Cursor >= actions.Count || (++cycleCount > 255);
if (fail)
{
if ((glyphType & GlyphProjectileType.Repeat) != 0)
{
context.Cursor = 0;
if ((glyphType & GlyphProjectileType.OnHit) != 0)
{
glyphType |= GlyphProjectileType.Paused;
}
}
else
{
projectile.Kill();
}
return;
}
item = actions[context.Cursor++];
item.context = context;
float cost = item.cost;
if (context.costMult > 0)
{
cost *= context.costMult;
}
if (cost <= (charge?.value ?? 100))
{
if (!(charge is null))
{
ConsumeCharge(cost);
}
float delay = item.delay;
if (!(item is SleepControl)) //if anyone has a reason why this should be a property instead of being uniqe to SleepControl, please tell me
{
switch (context.delayMult)
{
case -1:
delay = 15;
break;
default:
delay *= context.delayMult;
break;
}
}
context.Delay += delay;
ret = item.Execute(glyphType);
context.lastReturn = ret ?? context.lastReturn;
}
else
{
context.Cursor = actions.Count;
mod.Logger.Info($"Didn't have {cost} charge for {item.GetType()} at {context.Cursor}");
}
} catch (InvalidTimeZoneException) {
projectile.Kill();
return;
}
}
while (context.parameters.Count > 16)
{
context.parameters.RemoveAt(16);
}
if ((glyphType & GlyphProjectileType.Paused) == 0)
{
context.Delay--;
}
}
public TaskPlan2(IActorGroup group)
{
_group = new RefWrapper <IActorGroup>(group);
}
ref FilterGroup CreateOrGetFilterForGroup(int filterID, ExclusiveGroupStruct groupID, RefWrapper <Type> refWrapper)
{
var fasterDictionary =
_filters.GetOrCreate(refWrapper, () => new FasterDictionary <ExclusiveGroupStruct, GroupFilters>());
GroupFilters filters =
fasterDictionary.GetOrCreate(
groupID, () => new GroupFilters(new SharedSveltoDictionaryNative <int, FilterGroup>(0), groupID));
return(ref filters.CreateOrGetFilter(filterID, groupID));
}
