public static ItemTransactionResult ExecuteItemTransaction(ISimGameWorldReadWriteAccessor accessor, ItemTransation transaction)
{
int sourceCap, destinationCap;
DynamicBuffer <InventoryItemReference>?sourceBuffer, destinationBuffer;
GetCap(accessor, transaction.Source, out sourceCap);
GetBuffer(accessor, transaction.Source, out sourceBuffer);
GetCap(accessor, transaction.Destination, out destinationCap);
GetBuffer(accessor, transaction.Destination, out destinationBuffer);
ItemTransationData transationData = new ItemTransationData()
{
Item = transaction.Item,
SourceBuffer = sourceBuffer,
DestinationBuffer = destinationBuffer,
Stacks = transaction.Stacks,
SourceCapacity = sourceCap,
DestinationCapacity = destinationCap,
Source = transaction.Source,
Destination = transaction.Destination,
};
return(ExecuteItemTransaction_Internal(accessor, ref transationData));
}
public static void ExecuteItemTransaction(ISimGameWorldReadWriteAccessor accessor, ItemTransationBatch transaction)
{
int destinationCap, sourceCap;
DynamicBuffer <InventoryItemReference>?sourceBuffer, destinationBuffer;
GetCap(accessor, transaction.Source, out sourceCap);
GetBuffer(accessor, transaction.Source, out sourceBuffer);
GetCap(accessor, transaction.Destination, out destinationCap);
GetBuffer(accessor, transaction.Destination, out destinationBuffer);
ItemTransationData transationData = new ItemTransationData()
{
SourceBuffer = sourceBuffer,
DestinationBuffer = destinationBuffer,
SourceCapacity = sourceCap,
DestinationCapacity = destinationCap,
Source = transaction.Source,
Destination = transaction.Destination,
};
for (int i = 0; i < transaction.ItemsAndStacks.Length; i++)
{
transationData.Item = transaction.ItemsAndStacks[i].item;
transationData.Stacks = transaction.ItemsAndStacks[i].stacks;
var report = ExecuteItemTransaction_Internal(accessor, ref transationData);
if (transaction.OutResults.IsCreated && transaction.OutResults.Length > i)
{
transaction.OutResults[i] = report;
}
}
}
public static bool RequestUseItem(ISimGameWorldReadWriteAccessor accessor, Entity actor, Entity item, GameAction.UseParameters parameters = null)
{
if (!CommonReads.CanUseItem(accessor, actor, item, out ItemUnavailablityReason unavailabilityReason))
{
Log.Warning($"Instigator {accessor.GetNameSafe(actor)} cannot use item {accessor.GetNameSafe(item)} because of {unavailabilityReason}");
return(false);
}
accessor.TryGetComponent(item, out ItemAction itemAction);
CommonWrites.RequestExecuteGameAction(accessor, item, itemAction, parameters);
// reduce consumable amount
if (accessor.GetComponent <StackableFlag>(item))
{
CommonWrites.DecrementItem(accessor, item, actor);
}
// reduce instigator AP
if (accessor.TryGetComponent(item, out ItemSettingAPCost itemActionPointCost) && itemActionPointCost.Value != 0)
{
CommonWrites.ModifyStatFix <ActionPoints>(accessor, actor, -itemActionPointCost.Value);
}
// Cooldown
if (accessor.TryGetComponent(item, out ItemTimeCooldownData itemTimeCooldownData))
{
accessor.SetOrAddComponent(item, new ItemCooldownTimeCounter()
{
Value = itemTimeCooldownData.Value
});
}
return(true);
}
public static NativeList <OverlapPointHit> OverlapPoint(ISimGameWorldReadWriteAccessor accessor, fix2 position, Entity ignoreEntity = default)
{
NativeList <OverlapPointHit> outHits = new NativeList <OverlapPointHit>(Allocator.Temp);
OverlapPoint(accessor, position, outHits, ignoreEntity);
return(outHits);
}
public static NativeList <RaycastHit> CastRay(ISimGameWorldReadWriteAccessor accessor, fix2 start, fix2 end, Entity ignoreEntity = default)
{
NativeList <RaycastHit> outHits = new NativeList <RaycastHit>(Allocator.Temp);
CastRay(outHits, accessor, start, end, ignoreEntity);
return(outHits);
}
public static NativeList <Entity> OverlapAabb(ISimGameWorldReadWriteAccessor accessor, fix2 min, fix2 max, Entity ignoreEntity = default)
{
NativeList <Entity> outHits = new NativeList <Entity>(Allocator.Temp);
OverlapAabb(accessor, min, max, outHits, ignoreEntity);
return(outHits);
}
public static NativeList <DistanceHit> OverlapCircle(ISimGameWorldReadWriteAccessor accessor, fix2 position, fix radius, Entity ignoreEntity = default)
{
NativeList <DistanceHit> outHits = new NativeList <DistanceHit>(Allocator.Temp);
OverlapCircle(accessor, position, radius, outHits, ignoreEntity);
return(outHits);
}
public static void RequestDamage(ISimGameWorldReadWriteAccessor accessor, Entity target, fix amount, uint effectGroupID = uint.MaxValue)
{
var request = new HealthChangeRequestData()
{
Amount = -amount, Target = target, EffectGroupID = effectGroupID
};
accessor.GetExistingSystem <ApplyDamageSystem>().RequestHealthChange(request);
}
public static void RequestPull(ISimGameWorldReadWriteAccessor accessor, Entity entity, fix2 Destination, fix Speed)
{
accessor.SetOrAddComponent(entity, new PullData()
{
Destination = Destination,
Speed = Speed,
StartTime = accessor.Time.ElapsedTime
});
}
public static void ModifyStatFix <T>(ISimGameWorldReadWriteAccessor accessor, Entity entity, fix value)
where T : struct, IComponentData, IStatFix
{
fix currentValue = accessor.GetComponent <T>(entity).Value;
fix newValue = currentValue + value;
SetStatFix(accessor, entity, new T {
Value = newValue
});
}
public static void ModifyStatInt <T>(ISimGameWorldReadWriteAccessor accessor, Entity entity, int value)
where T : struct, IComponentData, IStatInt
{
int currentValue = accessor.GetComponent <T>(entity).Value;
int newValue = currentValue + value;
SetStatInt(accessor, entity, new T {
Value = newValue
});
}
public static void AddStatInt <T>(ISimGameWorldReadWriteAccessor accessor, Entity entity, int value)
where T : struct, IComponentData, IStatInt
{
if (!accessor.HasComponent <T>(entity))
{
accessor.AddComponent(entity, new T {
Value = value
});
}
}
public static void RequestTeleport(ISimGameWorldReadWriteAccessor accessor, Entity entity, fix2 destination)
{
var requests = accessor.GetExistingSystem <TeleportSystem>().GetRequestBuffer();
requests.Add(new TeleportRequestSingletonBufferElement()
{
Entity = entity,
Destination = destination
});
}
public static void RequestImpulse(ISimGameWorldReadWriteAccessor accessor, Entity target, fix2 strength, bool ignoreMass = false)
{
DirectImpulseRequestData request = new DirectImpulseRequestData()
{
Target = target,
Strength = strength,
IgnoreMass = ignoreMass,
};
accessor.GetExistingSystem <ApplyImpulseSystem>().RequestImpulseDirect(request);
}
public static ItemTransactionResult IncrementItem(ISimGameWorldReadWriteAccessor accessor, Entity item, Entity destination, int stacks = 1)
{
ItemTransation transaction = new ItemTransation()
{
Source = null,
Destination = destination,
Stacks = stacks,
Item = item,
};
return(ExecuteItemTransaction(accessor, transaction));
}
public static void RequestExplosion(ISimGameWorldReadWriteAccessor accessor, Entity instigator, fix2 position, fix radius, int damage, bool destroyTiles)
{
SystemRequestExplosion request = new SystemRequestExplosion()
{
Damage = damage,
Radius = radius,
Instigator = instigator,
Position = position,
DestroyTiles = destroyTiles
};
accessor.GetSingletonBuffer <SystemRequestExplosion>().Add(request);
}
public static void RequestDamage(ISimGameWorldReadWriteAccessor accessor, NativeArray <Entity> targets, fix amount, uint effectGroupID = uint.MaxValue)
{
var sys = accessor.GetExistingSystem <ApplyDamageSystem>();
for (int i = 0; i < targets.Length; i++)
{
var request = new HealthChangeRequestData()
{
Amount = -amount, Target = targets[i], EffectGroupID = effectGroupID
};
sys.RequestHealthChange(request);
}
}
public static void RequestRadialImpulse(ISimGameWorldReadWriteAccessor accessor, Entity target, fix strengthMin, fix strengthMax, fix radius, fix2 position, bool ignoreMass = false)
{
RadialImpulseRequestData request = new RadialImpulseRequestData()
{
Target = target,
Radius = radius,
Position = position,
IgnoreMass = ignoreMass,
StrengthMax = strengthMax,
StrengthMin = strengthMin,
};
accessor.GetExistingSystem <ApplyImpulseSystem>().RequestImpulseRadial(request);
}
public static bool OverlapPoint(ISimGameWorldReadWriteAccessor accessor, fix2 position, NativeList <OverlapPointHit> outHits, Entity ignoreEntity = default)
{
var physicsSystem = accessor.GetExistingSystem <PhysicsWorldSystem>();
OverlapPointInput pointDistanceInput = OverlapPointInput.Default;
pointDistanceInput.Position = (float2)position;
if (ignoreEntity != Entity.Null)
{
pointDistanceInput.Ignore = new IgnoreHit(physicsSystem.GetPhysicsBodyIndex(ignoreEntity));
}
return(physicsSystem.PhysicsWorld.OverlapPoint(pointDistanceInput, ref outHits));
}
public static void SetStatInt <T>(ISimGameWorldReadWriteAccessor accessor, Entity entity, T compData)
where T : struct, IComponentData, IStatInt
{
if (accessor.TryGetComponent(entity, out MinimumInt <T> minimum))
{
compData.Value = max(minimum.Value, compData.Value);
}
if (accessor.TryGetComponent(entity, out MaximumInt <T> maximum))
{
compData.Value = min(maximum.Value, compData.Value);
}
accessor.SetComponent(entity, compData);
}
public static bool CastRay(NativeList <RaycastHit> result, ISimGameWorldReadWriteAccessor accessor, fix2 start, fix2 end, Entity ignoreEntity = default)
{
var physicsSystem = accessor.GetExistingSystem <PhysicsWorldSystem>();
RaycastInput rayCastInput = RaycastInput.Default;
rayCastInput.Start = (float2)start;
rayCastInput.End = (float2)end;
if (ignoreEntity != Entity.Null)
{
rayCastInput.Ignore = new IgnoreHit(physicsSystem.GetPhysicsBodyIndex(ignoreEntity));
}
return(physicsSystem.PhysicsWorld.CastRay(rayCastInput, ref result));
}
public static Entity FindFirstEntityWithComponentAtPosition <T>(ISimGameWorldReadWriteAccessor accessor, fix2 position, Entity ignoreEntity = default) where T : struct
{
Entity closestEntity = Entity.Null;
fix closestDistanceSq = 9999;
var hits = OverlapPoint(accessor, position, ignoreEntity);
for (int i = 0; i < hits.Length; i++)
{
fix dist = fixMath.distancesq((fix2)hits[i].Position, position);
if (dist < closestDistanceSq && accessor.HasComponent <T>(hits[i].Entity))
{
closestDistanceSq = dist;
closestEntity = hits[i].Entity;
}
}
return(closestEntity);
}
public static bool OverlapAabb(ISimGameWorldReadWriteAccessor accessor, fix2 min, fix2 max, NativeList <Entity> outEntities, Entity ignoreEntity = default)
{
var physicsSystem = accessor.GetExistingSystem <PhysicsWorldSystem>();
OverlapAabbInput input = OverlapAabbInput.Default;
input.Aabb = new Aabb((float2)min, (float2)max);
if (ignoreEntity != Entity.Null)
{
input.Ignore = new IgnoreHit(physicsSystem.GetPhysicsBodyIndex(ignoreEntity));
}
NativeList <int> outBodyIndexes = new NativeList <int>(Allocator.Temp);
bool hit = physicsSystem.PhysicsWorld.OverlapAabb(input, outBodyIndexes);
for (int i = 0; i < outBodyIndexes.Length; i++)
{
outEntities.Add(physicsSystem.PhysicsWorld.AllBodies[outBodyIndexes[i]].Entity);
}
return(hit);
}
public static void RequestHeal(ISimGameWorldReadWriteAccessor accessor, Entity target, fix amount, uint effectGroupID = uint.MaxValue)
{
// for now a heal request is a negative damage request
RequestDamage(accessor, target, -amount, effectGroupID);
}
protected override void OnCreate()
{
base.OnCreate();
Accessor = (ISimGameWorldReadWriteAccessor)base.Accessor;
}
public static ItemTransactionResult MoveItemAll(ISimGameWorldReadWriteAccessor accessor, Entity item, Entity source, Entity destination)
{
return(MoveItem(accessor, item, source, destination, int.MaxValue));
}
/// <param name="accessor"></param>
/// <param name="item">The item to transfer</param>
/// <param name="source">The source inventory</param>
/// <param name="destination">The destination inventory</param>
/// <param name="stacks">How many stacks to move. Use -1 to specify 'all' stacks</param>
/// <param name="destinationCapacity">The capacity of the destination inventory</param>
private static ItemTransactionResult ExecuteItemTransaction_Internal(ISimGameWorldReadWriteAccessor accessor, ref ItemTransationData data)
{
if (data.Stacks == 0)
{
return(new ItemTransactionResult(stackTransfered: 0));
}
if (data.Stacks < 0) // invert source and destination ?
{
var temp1 = data.SourceBuffer;
var temp2 = data.SourceCapacity;
data.SourceBuffer = data.DestinationBuffer;
data.SourceCapacity = data.DestinationCapacity;
data.DestinationBuffer = temp1;
data.DestinationCapacity = temp2;
data.Stacks = -data.Stacks;
}
if (!accessor.Exists(data.Item))
{
return(new ItemTransactionResult(ItemTransactionResultType.Failed_BadTransationRequest));
}
if (data.SourceBuffer != null && !data.SourceBuffer.Value.IsCreated)
{
return(new ItemTransactionResult(ItemTransactionResultType.Failed_SourceInvalid));
}
if (data.DestinationBuffer != null && !data.DestinationBuffer.Value.IsCreated)
{
return(new ItemTransactionResult(ItemTransactionResultType.Failed_DestinationInvalid));
}
if (!accessor.HasComponent <SimAssetId>(data.Item))
{
return(new ItemTransactionResult(ItemTransactionResultType.Failed_ItemHasNoSimAssetId));
}
var itemAssetId = accessor.GetComponent <SimAssetId>(data.Item);
var sourceIndex = -1;
var destinationIndex = -1;
var itemStackable = accessor.GetComponent <StackableFlag>(data.Item);
var sourceBuffer = data.SourceBuffer.GetValueOrDefault();
var destinationBuffer = data.DestinationBuffer.GetValueOrDefault();
if (sourceBuffer.IsCreated) // Find item in source
{
for (int i = 0; i < sourceBuffer.Length; i++)
{
if (accessor.TryGetComponent(sourceBuffer[i].ItemEntity, out SimAssetId assetId) && assetId == itemAssetId)
{
sourceIndex = i;
break;
}
}
}
if (destinationBuffer.IsCreated) // Find item in destination
{
for (int i = 0; i < destinationBuffer.Length; i++)
{
if (accessor.TryGetComponent(destinationBuffer[i].ItemEntity, out SimAssetId assetId) && assetId == itemAssetId)
{
destinationIndex = i;
break;
}
}
}
if (sourceBuffer.IsCreated && sourceIndex == -1)
{
return(new ItemTransactionResult(ItemTransactionResultType.Failed_ItemNotFoundInSource));
}
if (destinationBuffer.IsCreated && destinationIndex == -1 && destinationBuffer.Length >= data.DestinationCapacity)
{
return(new ItemTransactionResult(ItemTransactionResultType.Failed_DestinationFull));
}
// cap stacks
if (sourceIndex >= 0)
{
data.Stacks = min(data.Stacks, sourceBuffer[sourceIndex].Stacks);
if (data.Stacks == 0)
{
return(new ItemTransactionResult(ItemTransactionResultType.Failed_SourceStack0));
}
}
if (!itemStackable)
{
data.Stacks = 1;
}
// check unique item is not about to be added twice
if (!itemStackable && destinationIndex != -1 && destinationBuffer[destinationIndex].Stacks > 0)
{
return(new ItemTransactionResult(ItemTransactionResultType.Failed_UniqueItemAlreadyInDestination));
}
////////////////////////////////////////////////////////////////////////////////////////
// Perform Transaction
////////////////////////////////////////////////////////////////////////////////////////
// Remove from source
if (sourceIndex != -1)
{
// decrease stacks
var sourceEntry = sourceBuffer[sourceIndex];
sourceEntry.Stacks -= data.Stacks;
sourceBuffer[sourceIndex] = sourceEntry;
if (sourceEntry.Stacks <= 0) // remove from source if 0 left
{
// remove from source
sourceBuffer.RemoveAt(sourceIndex);
// Destroy item
accessor.DestroyEntity(sourceEntry.ItemEntity);
UpdateBuffersAfterStructuraleChange(ref data);
}
}
if (destinationBuffer.IsCreated)
{
// not found ? add new reference
if (destinationIndex == -1)
{
// Instantiate item copy
var itemCopy = accessor.Instantiate(data.Item);
UpdateBuffersAfterStructuraleChange(ref data);
accessor.SetComponent(itemCopy, new FirstInstigator()
{
Value = data.Destination.Value
});
destinationBuffer.Add(new InventoryItemReference()
{
ItemEntity = itemCopy, Stacks = 0
});
destinationIndex = destinationBuffer.Length - 1;
}
// increase stacks
var destinationEntry = destinationBuffer[destinationIndex];
destinationEntry.Stacks += data.Stacks;
destinationBuffer[destinationIndex] = destinationEntry;
}
return(new ItemTransactionResult(data.Stacks));
void UpdateBuffersAfterStructuraleChange(ref ItemTransationData data)
{
GetBuffer(accessor, data.Source, out data.SourceBuffer);
GetBuffer(accessor, data.Destination, out data.DestinationBuffer);
sourceBuffer = data.SourceBuffer.GetValueOrDefault();
destinationBuffer = data.DestinationBuffer.GetValueOrDefault();
}
}
private static void GetBuffer(ISimGameWorldReadWriteAccessor accessor, Entity?sourceOrDestination, out DynamicBuffer <InventoryItemReference>?buffer)
{
buffer = accessor.HasComponent <InventoryItemReference>(sourceOrDestination.GetValueOrDefault())
? (DynamicBuffer <InventoryItemReference>?)accessor.GetBuffer <InventoryItemReference>(sourceOrDestination.Value) : null;
}
private static void GetCap(ISimGameWorldReadWriteAccessor accessor, Entity?sourceOrDestination, out int cap)
{
cap = accessor.HasComponent <InventoryCapacity>(sourceOrDestination.GetValueOrDefault())
? accessor.GetComponent <InventoryCapacity>(sourceOrDestination.Value) : default;
}
public static void RequestExecuteGameAction(ISimGameWorldReadWriteAccessor accessor, Entity actionInstigator, Entity actionEntity, GameAction.UseParameters parameters = null)
{
RequestExecuteGameAction(accessor, actionInstigator, actionEntity, targets: default, parameters);
