public void Execute(int index)
{
Vector3 avoidance = Vector3.zero;
MobComponentData currentFrienData;
NativeMultiHashMapIterator <int> frienderator = new NativeMultiHashMapIterator <int>();
bool success = friends.TryGetFirstValue(index, out currentFrienData, out frienderator);
while (success)
{
float dist = Vector3.Distance(allMobs[index].Position, currentFrienData.Position);
if (dist > 0 && dist < radius)
{
Vector3 diff = Vector3.Normalize(allMobs[index].Position - currentFrienData.Position);
diff = diff / dist;
avoidance += diff;
}
success = friends.TryGetNextValue(out currentFrienData, ref frienderator);
}
output[index] = new PersonalSpaceJobOutput()
{
PersonalSpace = avoidance * scaler
};
}
public void Execute(int index)
{
Vector3 perceivedVelocity = Vector3.zero;
int friendCount = 0;
MobComponentData currentFrienData;
NativeMultiHashMapIterator <int> frienderator = new NativeMultiHashMapIterator <int>();
bool success = friends.TryGetFirstValue(index, out currentFrienData, out frienderator);
while (success)
{
friendCount++;
float dist = Vector3.Distance(allMobs[index].Position, currentFrienData.Position);
if (dist < radius)
{
perceivedVelocity += currentFrienData.Velocity;
}
success = friends.TryGetNextValue(out currentFrienData, ref frienderator);
}
perceivedVelocity = (friendCount > 1) ? perceivedVelocity / (friendCount) : perceivedVelocity;
output[index] = new EqualizeSpeedJobOutput()
{
EqualizeSpeed = ((perceivedVelocity - allMobs[index].Velocity) / 8f) * scaler
};
}
public UnsafeMultiHashMapEnumerator(UnsafeMultiHashMap <TKey, TValue> map, TKey key)
{
this.map = map;
this.key = key;
iterator = default;
value = default;
isFirst = true;
}
public static void TryGetFirstValueAndThrowOnFail <TKey, TValue>(
this NativeMultiHashMap <TKey, TValue> nativeMultiHashMap, TKey key, out TValue item,
out NativeMultiHashMapIterator <TKey> it)
where TKey : struct, IEquatable <TKey>
where TValue : struct
{
#if ENABLE_UNITY_COLLECTIONS_CHECKS
var state = nativeMultiHashMap.TryGetFirstValue(key, out item, out it);
HashMapHelpers.ThrowOnFailedKey(state, key);
#else
nativeMultiHashMap.TryGetFirstValue(key, out item, out it);
#endif
}
private static int GetEntityCountInQuadrant(int quadrantKey)
{
QuadrantData quadrantData;
NativeMultiHashMapIterator <int> iterator = new NativeMultiHashMapIterator <int>();
int count = 0;
// We have at least 1 value for our key
// This is how you iterate over
if (quadrantMap.TryGetFirstValue(quadrantKey, out quadrantData, out iterator))
{
do
{
count++;
} while (quadrantMap.TryGetNextValue(out quadrantData, ref iterator)); // Keep iterationg as long as there are values for this key
}
return(count);
}
public void Execute()
{
int i_nextBestUniqueKeyIndex = i_eltiesCount - 1;
bool canCheckForElite = i_nextBestUniqueKeyIndex >= 0 ? true : false;
int i_eliteIndex = 0;
bool isNextUniqueKey = true;
EntityIndex parentEntityScore = default;
NativeMultiHashMapIterator <int> it = default;
while (canCheckForElite)
{
if (!isNextUniqueKey && nmhm_entitiesScore.TryGetNextValue(out parentEntityScore, ref it))
{
// Debug.Log ( "try get nexxt value: " + parent.entity + "; " + parent.i_index ) ;
}
else
{
// Debug.LogWarning ( "try get but NO MORE." ) ;
isNextUniqueKey = true;
}
if (isNextUniqueKey && nmhm_entitiesScore.TryGetFirstValue(na_currentSortedKeysWithDuplicates [i_nextBestUniqueKeyIndex], out parentEntityScore, out it))
{
// Debug.LogWarning ( "try get first value: " + parent.entity + "; " + parent.i_index ) ;
i_nextBestUniqueKeyIndex--;
isNextUniqueKey = false;
}
na_elities [i_eliteIndex] = parentEntityScore;
i_eliteIndex++;
if (i_eliteIndex >= i_eltiesCount)
{
// Stop lookup.
canCheckForElite = false;
}
} // while
}
public void Execute(Entity entity, int index, [ReadOnly] ref Translation translation, [ReadOnly] ref QuadrantEntity quadrantEntity)
{
float3 unitPosition = translation.Value;
Entity closestTargetEntity = Entity.Null;
float3 closestTargetPosition = float3.zero;
int key = QuadrantSystem.GetKeyFromPosition(unitPosition);
NativeMultiHashMapIterator <int> iterator = new NativeMultiHashMapIterator <int>();
QuadrantData quadrantData;
if (quadrantMap.TryGetFirstValue(key, out quadrantData, out iterator))
{
do
{
if (quadrantEntity.type != quadrantData.quadrantEntity.type)
{
if (closestTargetEntity == Entity.Null)
{
// No target
closestTargetEntity = quadrantData.entity;
closestTargetPosition = math.distance(unitPosition, quadrantData.position);
}
else
{
if (math.distance(unitPosition, quadrantData.position) < math.distance(unitPosition, closestTargetPosition))
{
// This target is closer
closestTargetEntity = entity;
closestTargetPosition = math.distancesq(unitPosition, quadrantData.position);
}
}
}
} while (quadrantMap.TryGetNextValue(out quadrantData, ref iterator));
}
closestTargets[index] = closestTargetEntity;
}
public void Execute(int index)
{
Vector3 center = Vector3.zero;
int friendCount = 0;
MobComponentData currentFrienData;
NativeMultiHashMapIterator <int> frienderator = new NativeMultiHashMapIterator <int>();
bool success = friends.TryGetFirstValue(index, out currentFrienData, out frienderator);
while (success)
{
friendCount++;
center += currentFrienData.Position;
success = friends.TryGetNextValue(out currentFrienData, ref frienderator);
}
center = (friendCount > 1) ? center / (friendCount) : center;
output[index] = new CenterMassJobOutput()
{
GroupCenterMass = ((center - allMobs[index].Position) / 100f) *
scaler
};
}
/// <summary>
/// Replace value at iterator.
/// </summary>
/// <param name="item">Value.</param>
/// <param name="it">Iterator</param>
/// <returns>Returns true if value was sucessfuly replaced.</returns>
public bool SetValue(TValue item, NativeMultiHashMapIterator <TKey> it)
{
return(UnsafeHashMapBase <TKey, TValue> .SetValue(m_Buffer, ref it, ref item));
}
/// <summary>
/// Retrieve iterator to the next value for the key.
/// </summary>
/// <param name="item">Output value.</param>
/// <param name="it">Iterator.</param>
/// <returns>Returns true if next value for the key is found.</returns>
public bool TryGetNextValue(out TValue item, ref NativeMultiHashMapIterator <TKey> it)
{
return(UnsafeHashMapBase <TKey, TValue> .TryGetNextValueAtomic(m_Buffer, out item, ref it));
}
/// <summary>
/// Retrieve iterator for the first value for the key.
/// </summary>
/// <param name="key">The key.</param>
/// <param name="item">Output value.</param>
/// <param name="it">Iterator.</param>
/// <returns>Returns true if the container contains the key.</returns>
public bool TryGetFirstValue(TKey key, out TValue item, out NativeMultiHashMapIterator <TKey> it)
{
return(UnsafeHashMapBase <TKey, TValue> .TryGetFirstValueAtomic(m_Buffer, key, out item, out it));
}
/// <summary>
/// Removes all elements with the specified iterator the container.
/// </summary>
/// <param name="it">Iterator pointing at value to remove.</param>
public void Remove(NativeMultiHashMapIterator <TKey> it)
{
UnsafeHashMapBase <TKey, TValue> .Remove(m_Buffer, it);
}
public void Execute( )
{
NativeHashMap <int, bool> nhm_checkedEliteEntities = new NativeHashMap <int, bool> (na_elities.Length, Allocator.Temp);
int i_parentUniqueKeyIndex = 0;
bool isNextParentUniqueKey = true;
NativeMultiHashMapIterator <int> it = default;
for (int i_eliteIndex = 0; i_eliteIndex < na_elities.Length; i_eliteIndex++)
{
EntityIndex currentEntityIndex = na_elities [i_eliteIndex];
Entity currentEliteEntity = currentEntityIndex.entity;
// Check if this entity has not been tested already.
if (nhm_checkedEliteEntities.TryAdd(currentEliteEntity.Index, true))
{
int i_currentEntityIndex = currentEntityIndex.i_index;
int i_currentPopulationBrainScore = a_brainScore [currentEliteEntity].i;
// Debug.Log ( "* Inject Elite: " + i_eliteIndex + " / " + na_currentEliteIndexProbability.Length + "; " + currentEliteEntity + "; with current score: " + i_currentPopulationBrainScore ) ;
// Debug.Log ( "* Inject Elite: " + i_probablity + " / " + i_perentageOfElites + "; " + eliteEntity + "; with current score: " + i_currentPopulationBrainScore ) ;
EntityIndex parentIndex = default;
// Look up through parents' scores, starting from lowest score ascending.
if (!isNextParentUniqueKey && nmhm_parentEntitiesScore.TryGetNextValue(out parentIndex, ref it))
{
// Debug.Log ( "try get next value: " + parentIndex.entity + "; " + parentIndex.i_index ) ;
}
else
{
// Debug.LogWarning ( "try get but NO MORE." ) ;
isNextParentUniqueKey = true;
}
if (isNextParentUniqueKey && nmhm_parentEntitiesScore.TryGetFirstValue(na_parentKeysWithDuplicates [i_parentUniqueKeyIndex], out parentIndex, out it))
{
// Debug.LogWarning ( "try get first value: " + parentIndex.entity + "; " + parentIndex.i_index ) ;
i_parentUniqueKeyIndex++;
isNextParentUniqueKey = false;
}
// Parent is valid.
if (!isNextParentUniqueKey && parentIndex.entity.Version > 0)
{
int i_parentPopulationBrainScore = a_brainScore [parentIndex.entity].i;
// Debug.Log ( "score: " + i_currentPopulationBrainScore + " >> " + i_parentPopulationBrainScore ) ;
if (i_currentPopulationBrainScore > i_parentPopulationBrainScore)
{
// isBetterScore = true ;
na_parentPopulationEntities [parentIndex.i_index] = currentEliteEntity;
// Debug.LogWarning ( "Parent index: " + parentIndex.i_index + " / " + na_parentPopulationEntities.Length + "; inject : " + currentEliteEntity + "; for: " + parentIndex.entity + "; score: " + i_currentPopulationBrainScore + " >> " + i_parentPopulationBrainScore ) ;
// Debug.LogWarning ( "Parent index: " + parent.i_index + " / " + na_parentPopulationEntities.Length + "; inject : " + eliteEntity + "; for: " + parent.entity + "; score: " + i_currentPopulationBrainScore + " >> " + i_parentPopulationBrainScore + "; index prob: " + i_indexProbability ) ;
// Swap entities.
na_currentPopulationEntities [i_currentEntityIndex] = parentIndex.entity;
// na_elities [i_eliteIndex] = parent.entity ;
// na_currentPopulationEntities [i_indexProbability] = parent.entity ;
}
}
if (isNextParentUniqueKey || i_parentUniqueKeyIndex >= na_parentKeysWithDuplicates.Length)
{
// Debug.LogError ( "No more parent entities." ) ;
break; // No more parent entities.
}
}
} // for
nhm_checkedEliteEntities.Dispose();
// na_currentPopulationEntitiesCopy.Dispose () ;
}
protected virtual int SetUpInventoryItems(InventoryGroupWrapper inventoryGroup, int itemCount, Entity owner)
{
var foodList = new NativeList <ItemHashValue>(Allocator.Temp);
var potionList = new NativeList <ItemHashValue>(Allocator.Temp);
var treasureList = new NativeList <ItemHashValue>(Allocator.Temp);
var weaponList = new NativeList <ItemHashValue>(Allocator.Temp);
var magicWeaponList = new NativeList <ItemHashValue>(Allocator.Temp);
var helmetList = new NativeList <ItemHashValue>(Allocator.Temp);
var chestList = new NativeList <ItemHashValue>(Allocator.Temp);
var bootsList = new NativeList <ItemHashValue>(Allocator.Temp);
var itemCounter = 0;
this.Entities.With(this._itemsGroup).ForEach((Entity itemEntity, ref ItemComponent itemComponent, ref PickedUpComponent pickedUpComponent) =>
{
if (pickedUpComponent.Owner != owner)
{
return;
}
itemCounter++;
var item = ItemsManagerComponent.Instance.ItemsStoreComponent.Items[itemComponent.StoreIndex];
switch (item.ItemType)
{
case ItemType.Food:
foodList.Add(
new ItemHashValue
{
Entity = itemEntity,
ItemComponent = itemComponent
});
break;
case ItemType.Potion:
potionList.Add(
new ItemHashValue
{
Entity = itemEntity,
ItemComponent = itemComponent
});
break;
case ItemType.Treasure:
treasureList.Add(
new ItemHashValue
{
Entity = itemEntity,
ItemComponent = itemComponent
});
break;
case ItemType.Gear:
switch (item.GearType)
{
case GearType.Helmet:
helmetList.Add(
new ItemHashValue
{
Entity = itemEntity,
ItemComponent = itemComponent
});
break;
case GearType.Chest:
chestList.Add(
new ItemHashValue
{
Entity = itemEntity,
ItemComponent = itemComponent
});
break;
case GearType.Weapon:
weaponList.Add(
new ItemHashValue
{
Entity = itemEntity,
ItemComponent = itemComponent
});
break;
case GearType.Boots:
bootsList.Add(
new ItemHashValue
{
Entity = itemEntity,
ItemComponent = itemComponent
});
break;
case GearType.Magic:
magicWeaponList.Add(
new ItemHashValue
{
Entity = itemEntity,
ItemComponent = itemComponent
});
break;
}
break;
}
});
if (itemCounter != this.LastItemsCount || this.LastOwnerEntity != owner)
{
this.LastItemsCount = itemCounter;
this.LastOwnerEntity = owner;
for (var i = inventoryGroup.Grid.transform.childCount - 1; i >= 0; i--)
{
GameObject.Destroy(inventoryGroup.Grid.transform.GetChild(i).gameObject);
}
var itemsHashMap = new NativeMultiHashMap <int, ItemHashValue>(foodList.Length + potionList.Length + treasureList.Length, Allocator.Temp);
for (var i = 0; i < foodList.Length; i++)
{
itemsHashMap.Add(this.GetItemHash(foodList[i]), foodList[i]);
}
for (var i = 0; i < potionList.Length; i++)
{
itemsHashMap.Add(this.GetItemHash(potionList[i]), potionList[i]);
}
for (var i = 0; i < treasureList.Length; i++)
{
itemsHashMap.Add(this.GetItemHash(treasureList[i]), treasureList[i]);
}
if (itemsHashMap.Length > 0)
{
var iterator = new NativeMultiHashMapIterator <int>();
var(keys, keysLength) = itemsHashMap.GetUniqueKeyArray(Allocator.Temp);
for (var keyI = 0; keyI < keysLength; keyI++)
{
if (!itemsHashMap.TryGetFirstValue(keys[keyI], out var hashValue, out iterator))
{
continue;
}
var button = this.AddInventoryButton(hashValue, inventoryGroup);
var itemsCount = 1;
while (itemsHashMap.TryGetNextValue(out hashValue, ref iterator))
{
itemsCount++;
}
if (itemsCount > 1)
{
button.Amount.text = itemsCount.ToString();
}
else
{
button.Amount.text = string.Empty;
}
}
keys.Dispose();
}
itemsHashMap.Dispose();
for (var i = 0; i < weaponList.Length; i++)
{
this.AddInventoryButton(weaponList[i], inventoryGroup);
}
for (var i = 0; i < magicWeaponList.Length; i++)
{
this.AddInventoryButton(magicWeaponList[i], inventoryGroup);
}
for (var i = 0; i < helmetList.Length; i++)
{
this.AddInventoryButton(helmetList[i], inventoryGroup);
}
for (var i = 0; i < chestList.Length; i++)
{
this.AddInventoryButton(chestList[i], inventoryGroup);
}
for (var i = 0; i < bootsList.Length; i++)
{
this.AddInventoryButton(bootsList[i], inventoryGroup);
}
}
foodList.Dispose();
potionList.Dispose();
treasureList.Dispose();
weaponList.Dispose();
magicWeaponList.Dispose();
helmetList.Dispose();
chestList.Dispose();
bootsList.Dispose();
return(itemCounter);
}
public static bool SelectIterator <K, T>(this NativeMultiHashMap <K, T> HashMap, Predicate <T> Operate, K Key, out NativeMultiHashMapIterator <K> Iterator) where T : struct where K : struct, IEquatable <K>
{
for (bool Success = HashMap.TryGetFirstValue(Key, out var Value, out var It); Success;)
