protected override void OnUpdate()
{
// TODO (mogensh) put this check into its own system. Can we enable/disable systems depending on configvars ?
if (CharacterModule.PredictionCheck.IntValue > 0)
{
var timeQuery = EntityManager.CreateEntityQuery(ComponentType.ReadOnly <GlobalGameTime>());
var time = timeQuery.GetSingleton <GlobalGameTime>().gameTime;
var query = EntityManager.CreateEntityQuery(typeof(Character.PredictedData), typeof(PredictedGhostComponent));
var predictedDataArray = query.ToComponentDataArray <Character.PredictedData>(Allocator.TempJob);
var entityArray = query.ToEntityArray(Allocator.TempJob);
for (int i = 0; i < predictedDataArray.Length; i++)
{
if (!GhostPredictionSystemGroup.ShouldPredict(World.GetExistingSystem <GhostPredictionSystemGroup>().PredictingTick, EntityManager.GetComponentData <PredictedGhostComponent>(entityArray[i])))
{
continue;
}
var predictedData = predictedDataArray[i];
if (predictedData.tick > 0 && time.tick != predictedData.tick + 1)
{
GameDebug.Log("Update tick invalid. Game tick:" + time.tick + " but current state is at tick:" + predictedData.tick);
}
predictedData.tick = time.tick;
EntityManager.SetComponentData(entityArray[i], predictedData);
}
entityArray.Dispose();
predictedDataArray.Dispose();
timeQuery.Dispose();
query.Dispose();
}
base.OnUpdate();
}
/// <summary>
/// Gets a BufferFromEntity<T> object that can access a <seealso cref="DynamicBuffer{T}"/>.
/// </summary>
/// <remarks>Assign the returned object to a field of your Job struct so that you can access the
/// contents of the buffer in a Job.</remarks>
/// <param name="isReadOnly">Whether the buffer data is only read or is also written. Access data in
/// a read-only fashion whenever possible.</param>
/// <typeparam name="T">The type of <see cref="IBufferElementData"/> stored in the buffer.</typeparam>
/// <returns>An array-like object that provides access to buffers, indexed by <see cref="Entity"/>.</returns>
/// <seealso cref="ComponentDataFromEntity{T}"/>
public BufferFromEntity <T> GetBufferFromEntity <T>(bool isReadOnly = false) where T : struct, IBufferElementData
{
AddReaderWriter(isReadOnly ? ComponentType.ReadOnly <T>() : ComponentType.ReadWrite <T>());
return(EntityManager.GetBufferFromEntity <T>(isReadOnly));
}
public FixedArrayFromEntity <T> GetFixedArrayFromEntity <T>(bool isReadOnly = false) where T : struct
{
AddReaderWriter(isReadOnly ? ComponentType.ReadOnly <T>() : ComponentType.Create <T>());
return(EntityManager.GetFixedArrayFromEntity <T>(TypeManager.GetTypeIndex <T>(), isReadOnly));
}
/// <summary>
/// Gets the run-time type information required to access an array of component data in a chunk.
/// </summary>
/// <param name="isReadOnly">Whether the component data is only read, not written. Access components as
/// read-only whenever possible.</param>
/// <typeparam name="T">A struct that implements <see cref="IComponentData"/>.</typeparam>
/// <returns>An object representing the type information required to safely access component data stored in a
/// chunk.</returns>
/// <remarks>Pass an <see cref="ArchetypeChunkComponentType"/> instance to a job that has access to chunk data,
/// such as an <see cref="IJobChunk"/> job, to access that type of component inside the job.</remarks>
public ArchetypeChunkComponentType <T> GetArchetypeChunkComponentType <T>(bool isReadOnly = false) where T : struct, IComponentData
{
AddReaderWriter(isReadOnly ? ComponentType.ReadOnly <T>() : ComponentType.ReadWrite <T>());
return(EntityManager.GetArchetypeChunkComponentType <T>(isReadOnly));
}
public ComponentDataFromEntity <T> GetComponentDataFromEntity <T>(bool isReadOnly = false)
where T : struct, IComponentData
{
AddReaderWriter(isReadOnly ? ComponentType.ReadOnly <T>() : ComponentType.Create <T>());
return(EntityManager.GetComponentDataFromEntity <T>(isReadOnly));
}
public ArchetypeChunkEntityType GetArchetypeChunkEntityType()
{
AddReaderWriter(ComponentType.ReadOnly <Entity>());
return(EntityManager.GetArchetypeChunkEntityType());
}
public ArchetypeChunkSharedComponentType <T> GetArchetypeChunkSharedComponentType <T>()
where T : struct, ISharedComponentData
{
AddReaderWriter(ComponentType.ReadOnly <T>());
return(EntityManager.GetArchetypeChunkSharedComponentType <T>());
}
ArchetypeQuery *CreateQuery(ref UnsafeScratchAllocator unsafeScratchAllocator, EntityQueryDesc[] queryDesc)
{
var outQuery = (ArchetypeQuery *)unsafeScratchAllocator.Allocate(sizeof(ArchetypeQuery) * queryDesc.Length, UnsafeUtility.AlignOf <ArchetypeQuery>());
for (int q = 0; q != queryDesc.Length; q++)
{
// Validate the queryDesc has components declared in a consistent way
queryDesc[q].Validate();
var typesNone = queryDesc[q].None;
var typesAll = queryDesc[q].All;
var typesAny = queryDesc[q].Any;
// None forced to read only
{
for (int i = 0; i < typesNone.Length; i++)
{
if (typesNone[i].AccessModeType != ComponentType.AccessMode.ReadOnly)
{
typesNone[i] = ComponentType.ReadOnly(typesNone[i].TypeIndex);
}
}
}
var isFilterWriteGroup = (queryDesc[q].Options & EntityQueryOptions.FilterWriteGroup) != 0;
if (isFilterWriteGroup)
{
// Each ReadOnly<type> in any or all
// if has WriteGroup types,
// - Recursively add to any (if not explictly mentioned)
var explicitList = CreateExplicitTypeList(typesNone, typesAll, typesAny);
for (int i = 0; i < typesAny.Length; i++)
{
IncludeDependentWriteGroups(typesAny[i], explicitList);
}
for (int i = 0; i < typesAll.Length; i++)
{
IncludeDependentWriteGroups(typesAll[i], explicitList);
}
// Each ReadWrite<type> in any or all
// if has WriteGroup types,
// Add to none (if not exist in any or all or none)
var noneList = new NativeList <ComponentType>(typesNone.Length, Allocator.Temp);
for (int i = 0; i < typesNone.Length; i++)
{
noneList.Add(typesNone[i]);
}
for (int i = 0; i < typesAny.Length; i++)
{
ExcludeWriteGroups(typesAny[i], noneList, explicitList);
}
for (int i = 0; i < typesAll.Length; i++)
{
ExcludeWriteGroups(typesAll[i], noneList, explicitList);
}
typesNone = new ComponentType[noneList.Length];
for (int i = 0; i < noneList.Length; i++)
{
typesNone[i] = noneList[i];
}
noneList.Dispose();
explicitList.Dispose();
}
ConstructTypeArray(ref unsafeScratchAllocator, typesNone, out outQuery[q].None, out outQuery[q].NoneAccessMode, out outQuery[q].NoneCount);
ConstructTypeArray(ref unsafeScratchAllocator, typesAll, out outQuery[q].All, out outQuery[q].AllAccessMode, out outQuery[q].AllCount);
ConstructTypeArray(ref unsafeScratchAllocator, typesAny, out outQuery[q].Any, out outQuery[q].AnyAccessMode, out outQuery[q].AnyCount);
outQuery[q].Options = queryDesc[q].Options;
}
return(outQuery);
}
