protected override void OnUpdate()
{
var geneticTrainerID = new List <GeneticTrainerIDComponentData>(10);
EntityManager.GetAllUniqueSharedComponentData(geneticTrainerID);
var transforms = geneticTrainerGroup.GetComponentArray <Transform>();
for (int i = 0, length = transforms.Length; i < length; ++i)
{
var geneticTrainer = transforms[i].GetComponent <GeneticTrainerComponent>();
deadNetworkGroup.SetFilter(geneticTrainerID[i]); //may need to change if more than one
if (deadNetworkGroup.GetEntityArray().Length != 0)
{
if (deadNetworkGroup.GetEntityArray().Length == geneticTrainer.pool.Length)
{
for (int j = 0, entityCount = deadNetworkGroup.GetEntityArray().Length; deadNetworkGroup.GetEntityArray().Length != 0;)
{
var entity = deadNetworkGroup.GetEntityArray()[j];
geneticTrainer.scores[deadNetworkGroup.GetComponentDataArray <PointComponentData>()[j].PointValue] = entity;
EntityManager.AddComponentData(entity, new ResetComponentData());
EntityManager.RemoveComponent(entity, ComponentType.Create <DeadComponentData>());
}
}
}
}
}
protected override JobHandle OnUpdate(JobHandle inputDeps)
{
Debug.Log("Remove Octree Instance.");
int i_groupLength = group.CalculateLength();
var removeInstanceJob = new RemoveInstanceJob
{
a_octreeEntities = group.GetEntityArray(),
// Contains a list of instances to add, with its properties.
removeInstanceBufferElement = GetBufferFromEntity <RemoveInstanceBufferElement> (),
a_rootNodeData = GetComponentDataFromEntity <RootNodeData> (),
nodeSparesBufferElement = GetBufferFromEntity <NodeSparesBufferElement> (),
nodeBufferElement = GetBufferFromEntity <NodeBufferElement> (),
nodeInstancesIndexBufferElement = GetBufferFromEntity <NodeInstancesIndexBufferElement> (),
nodeChildrenBufferElement = GetBufferFromEntity <NodeChildrenBufferElement> (),
instanceBufferElement = GetBufferFromEntity <InstanceBufferElement> (),
instancesSpareIndexBufferElement = GetBufferFromEntity <InstancesSpareIndexBufferElement> ()
}.Schedule(i_groupLength, 8, inputDeps);
var completeRemoveInstanceJob = new CompleteRemoveInstanceJob
{
ecb = barrier.CreateCommandBuffer().ToConcurrent(),
a_octreeEntities = group.GetEntityArray()
}.Schedule(i_groupLength, 8, removeInstanceJob);
return(completeRemoveInstanceJob);
}
protected override JobHandle OnUpdate(JobHandle inputDeps)
{
return(new GridSystemJob
{
Array = _componentGroup.GetEntityArray()
}.Schedule(_componentGroup.GetEntityArray().Length, 64, inputDeps));
}
protected override JobHandle OnUpdate(JobHandle inputDeps)
{
_componentGroup = GetComponentGroup(typeof(CircleCollider), typeof(Position), typeof(Tag));
var array = _componentGroup.GetEntityArray();
for (int i = 0; i < array.Length; i++)
{
try
{
EntityManager.GetBuffer <CollisionList>(array[i]);
}
catch (Exception e)
{
EntityManager.AddBuffer <CollisionList>(_componentGroup.GetEntityArray()[i]);
}
}
return(new CircleColliderJob()
{
PositionArray = _componentGroup.GetComponentDataArray <Position>(),
CircleColliderArray = _componentGroup.GetComponentDataArray <CircleCollider>(),
TagArray = _componentGroup.GetComponentDataArray <Tag>(),
Buffer = GetBufferFromEntity <CollisionList>()
}
.Schedule(this, inputDeps));
}
protected override void OnUpdate()
{
var defaultComponent = EntityManager.GetSharedComponentData <RenderMesh>(group.GetEntityArray()[0]);
int length = group.GetEntityArray().Length;
var entities = group.GetEntityArray().ToArray();
for (int i = 0; i < length; ++i)
{
var newComponent = new RenderMesh();
newComponent.layer = defaultComponent.layer;
newComponent.mesh = defaultComponent.mesh;
newComponent.material = new Material(defaultComponent.material);
newComponent.subMesh = defaultComponent.subMesh;
var entity = entities[i];
newComponent.material.color = Random.ColorHSV();
if (newComponent.material.color.r < 0.2f &&
newComponent.material.color.g < 0.2f &&
newComponent.material.color.b < 0.2f)
{
newComponent.material.color += Random.ColorHSV();
}
EntityManager.SetSharedComponentData(entity, newComponent);
EntityManager.RemoveComponent <RandomizeColorData>(entity);
}
}
protected override JobHandle OnUpdate(JobHandle inputDeps)
{
var geneticTrainerID = new List <GeneticTrainerIDComponentData>(10);
EntityManager.GetAllUniqueSharedComponentData(geneticTrainerID);
var transforms = geneticTrainerGroup.GetComponentArray <Transform>();
for (int i = 0, length = transforms.Length; i < length; ++i)
{
var geneticTrainer = transforms[i].GetComponent <GeneticTrainerComponent>();
neuralNetworkToResetGroup.SetFilter(geneticTrainerID[i]); //may need to change if more than one
if (neuralNetworkToResetGroup.GetEntityArray().Length != 0)
{
if (neuralNetworkToResetGroup.GetEntityArray().Length == geneticTrainer.pool.Length)
{
var neuralNetwork = EntityManager.GetSharedComponentData <NeuralNetworkComponentData>(neuralNetworkToResetGroup.GetEntityArray()[0]);
ComputeBestNetwork(geneticTrainer, neuralNetwork);
var randomNumbers = new NativeArray <float>(neuralNetwork.Connections.Length, Allocator.TempJob, NativeArrayOptions.UninitializedMemory);
var randomRanges = new NativeArray <float>(neuralNetwork.Connections.Length, Allocator.TempJob, NativeArrayOptions.UninitializedMemory);
var rangeByGain = (geneticTrainer.Value.maxPoint / geneticTrainer.bestOverall[0].Item1) * neuralNetwork.WeightRange;
System.Random random = new System.Random();
for (int j = 0, numberCount = neuralNetwork.Connections.Length; j < numberCount; ++j)
{
var weightA = geneticTrainer.bestOverall[0].Item2[j % neuralNetwork.ConnectionCountPerNetwork];
var weightB = geneticTrainer.bestOverall[1].Item2[j % neuralNetwork.ConnectionCountPerNetwork];
randomNumbers[j] = (float)random.NextDouble();
randomRanges[j] = UnityEngine.Random.Range(math.min(weightA - rangeByGain, weightB - rangeByGain),
math.max(weightA + rangeByGain, weightB + rangeByGain));
}
var percentA = geneticTrainer.bestOverall[0].Item1 / (geneticTrainer.bestOverall[0].Item1 + geneticTrainer.bestOverall[1].Item1);
var percentB = 1.0f - percentA;
var job = new FusionBestNeuralNetwork {
Connections = neuralNetwork.Connections,
Mutation = geneticTrainer.Value.Mutation,
PercentA = percentA,
PercentB = percentB,
RandomNumbers = randomNumbers,
RandomRanges = randomRanges,
ScoreConnectionA = geneticTrainer.bestOverall[0],
ScoreConnectionB = geneticTrainer.bestOverall[1]
};
Utils.Utils.ScheduleBatchedJobAndComplete(job.ScheduleBatch(neuralNetwork.Connections.Length, neuralNetwork.ConnectionCountPerNetwork, inputDeps));
geneticTrainer.scores.Clear();
EntityManager.AddComponentData(geneticTrainer.GetComponent <GameObjectEntity>().Entity, new ResetPoolFromPresetComponentData());
var data = geneticTrainer.Value;
data.Generation += 1;
geneticTrainer.Value = data;
geneticTrainer.generationCount.text = (data.Generation).ToString();
}
}
}
return(inputDeps);
}
private JobHandle ScheduleMembershipDebugJob(JobHandle inputDeps)
{
var handle = inputDeps;
var length = _membershipDebugGroup.CalculateLength();
if (length > 0)
{
handle = new MembershipDebugJob
{
EntityArray = _membershipDebugGroup.GetEntityArray(),
PhysicsObject = _membershipDebugGroup.GetSharedComponentDataArray <PhysicsObject>()[0]
}.Schedule(length, 64, inputDeps);
}
return(handle);
}
protected override void OnUpdate()
{
// Remove all predicted projectiles that should have been acknowledged by now
var predictedProjectileArray = PredictedProjectileGroup.GetComponentDataArray <PredictedProjectile>();
var predictedProjectileEntityArray = PredictedProjectileGroup.GetEntityArray();
for (var i = 0; i < predictedProjectileArray.Length; i++)
{
var predictedEntity = predictedProjectileArray[i];
if (predictedEntity.startTick >= m_world.lastServerTick)
{
continue;
}
var entity = predictedProjectileEntityArray[i];
PostUpdateCommands.AddComponent(entity, new DespawningEntity());
// var gameObject = EntityManager.GetComponentObject<Transform>(predictedProjectileEntityArray[i]).gameObject;
// m_world.RequestDespawn(gameObject, PostUpdateCommands);
if (ProjectileModuleClient.logInfo.IntValue > 0)
{
GameDebug.Log(string.Format("<color=red>Predicted projectile {0} destroyed as it was not verified. startTick:{1}]</color>", entity, predictedEntity.startTick));
}
}
}
protected override void OnUpdate()
{
Profiler.BeginSample("HandleCharacterSpawnRequests");
var requestArray = SpawnGroup.GetComponentDataArray <CharacterSpawnRequest>();
if (requestArray.Length == 0)
{
return;
}
var requestEntityArray = SpawnGroup.GetEntityArray();
// Copy requests as spawning will invalidate Group
var spawnRequests = new CharacterSpawnRequest[requestArray.Length];
for (var i = 0; i < requestArray.Length; i++)
{
spawnRequests[i] = requestArray[i];
PostUpdateCommands.DestroyEntity(requestEntityArray[i]);
}
for (var i = 0; i < spawnRequests.Length; i++)
{
var request = spawnRequests[i];
var playerState = EntityManager.GetComponentObject <PlayerState>(request.playerEntity);
var character = SpawnCharacter(m_world, playerState, request.position, request.rotation, request.characterType, m_ResourceManager);
playerState.controlledEntity = character.gameObject.GetComponent <GameObjectEntity>().Entity;
}
Profiler.EndSample();
}
protected override JobHandle OnUpdate(JobHandle inputDeps)
{
var transforms = m_InitialTransformGroup.GetTransformAccessArray();
var entities = m_InitialTransformGroup.GetEntityArray();
var transformStashes = new NativeArray <TransformStash>(transforms.length, Allocator.TempJob);
var stashTransformsJob = new StashTransforms
{
transformStashes = transformStashes
};
var stashTransformsJobHandle = stashTransformsJob.Schedule(transforms, inputDeps);
var copyTransformsJob = new CopyTransforms
{
positions = m_Positions,
rotations = m_Rotations,
localPositions = m_LocalPositions,
localRotations = m_LocalRotations,
transformStashes = transformStashes,
entities = entities
};
var copyTransformsJobHandle = copyTransformsJob.Schedule(transformStashes.Length, 64, stashTransformsJobHandle);
var removeComponentsJob = new RemoveCopyInitialTransformFromGameObjectComponent
{
entities = entities,
entityCommandBuffer = m_EndFrameBarrier.CreateCommandBuffer()
};
var removeComponentsJobHandle = removeComponentsJob.Schedule(copyTransformsJobHandle);
return(removeComponentsJobHandle);
}
protected override void OnUpdate()
{
var p_entity = player.GetEntityArray();
var p_movementInput = player.GetComponentDataArray <MovementInput> ();
var p_walkSpeed = player.GetComponentDataArray <WalkSpeed> ();
var p_rigidBody2d = player.GetComponentArray <Rigidbody2D> ();
var dt = Time.deltaTime;
for (int i = 0; i < player.CalculateLength(); i++)
{
if (p_movementInput[i].Value.Equals(Vector2.zero))
{
continue;
}
p_rigidBody2d[i].velocity = new Vector2(
p_movementInput[i].Value.x * p_walkSpeed[i].Value,
p_rigidBody2d[i].velocity.y
);
// Debug.Log(p_rigidBody2d[i].velocity);
// Old Movement System:
// p_transform[i].position = Vector3.Lerp(
// p_transform[i].position,
// p_transform[i].position + new Vector3(p_movementInput[i].Value.x, p_movementInput[i].Value.y, 0),
// p_walkSpeed[i].Value * dt
// );
}
}
protected override void OnUpdate()
{
// Add entities that needs change to buffer (as we cant destroy/create while iterating)
var gameEntityTypeArray = Group.GetComponentDataArray <PresentationOwnerData>();
var entityArray = Group.GetEntityArray();
m_entityBuffer.Clear();
m_typeDataBuffer.Clear();
for (int i = 0; i < gameEntityTypeArray.Length; i++)
{
var typeData = gameEntityTypeArray[i];
if (typeData.variation == typeData.currentVariation)
{
continue;
}
m_entityBuffer.Add(entityArray[i]);
m_typeDataBuffer.Add(typeData);
}
for (int i = 0; i < m_entityBuffer.Count; i++)
{
var entity = m_entityBuffer[i];
var typeData = m_typeDataBuffer[i];
var replicatedData = EntityManager.GetComponentData <ReplicatedEntityData>(entity);
WeakAssetReference presentationGuid;
var found = m_presentationRegistry.GetPresentation(replicatedData.assetGuid, out presentationGuid);
if (!found)
{
continue;
}
// var registryEntry = m_assetRegistry.GetEntry(replicatedData.assetGuid);
//
// if (registryEntry == null)
// continue;
//
// if (registryEntry.factory == null)
// continue;
//var presentation = registryEntry.factory.CreateVariation(EntityManager, m_resourceManager, m_world, entity, 0);
var presentation = m_resourceManager.CreateEntity(presentationGuid);
GameDebug.Assert(presentation != Entity.Null, "failed to create presentation");
typeData.currentVariation = typeData.variation;
typeData.currentVariationEntity = presentation;
EntityManager.SetComponentData(entity, typeData);
var presentationEntity = EntityManager.GetComponentObject <PresentationEntity>(presentation);
presentationEntity.ownerEntity = entity;
}
}
protected override void OnUpdate()
{
var positions = _teleportComponentGroup.GetComponentDataArray <VrTeleportPosition>();
if (positions.Length == 0)
{
return;
}
var vrPlayerPos = _vrPlayerGroup.GetComponentDataArray <Position>();
var vrPlayerPosition = vrPlayerPos[0];
var vrCameraPos = _vrCameraGroup.GetComponentDataArray <Position>();
var diff = vrCameraPos[0].Value - vrPlayerPosition.Value;
diff.y = 0f;
var newPosition = positions[0].position - diff;
newPosition.y = vrPlayerPosition.Value.y;
// Update pos
vrPlayerPos[0] = new Position()
{
Value = newPosition
};
// Delete entity
PostUpdateCommands.DestroyEntity(_teleportComponentGroup.GetEntityArray()[0]);
}
protected override JobHandle OnUpdate(JobHandle inputDeps)
{
if (!initialized)
{
Initialize();
initialized = true;
}
sphereRequestsGroup = GetComponentGroup(typeof(SphereRequest));
if (sphereRequestsGroup.CalculateLength() == 0)
{
return(inputDeps);
}
ComponentDataArray <SphereRequest> sphereRequests = sphereRequestsGroup.GetComponentDataArray <SphereRequest>();
JobHandle sgj = new SphereGenerateSystem.SphereGenerateJob {
requests = sphereRequests,
commandBuffer = generateBarrier.CreateCommandBuffer().ToConcurrent(),
}.Schedule(sphereRequests.Length, 64, inputDeps);
EntityArray sphereRequestEntities = sphereRequestsGroup.GetEntityArray();
JobHandle srcj = new SphereRequestCleanupJob {
entities = sphereRequestEntities,
commandBuffer = cleanupBarrier.CreateCommandBuffer().ToConcurrent(),
}.Schedule(sphereRequestEntities.Length, 64, sgj);
return(srcj);
}
protected override void OnUpdate()
{
var b_entity = boost.GetEntityArray();
var b_timer = boost.GetComponentDataArray <Boosting>();
var b_cooldown = boost.GetComponentDataArray <BoostCooldown>();
for (int i = 0; i < boost.CalculateLength(); i++)
{
if (b_timer[i].Value > 0)
{
continue;
}
PostUpdateCommands.RemoveComponent <Boosting>(b_entity[i]);
PostUpdateCommands.AddComponent <BoostEnd>(
b_entity[i],
new BoostEnd {
Value = b_cooldown[i].Value
}
);
/* ----------------- DEVELOPER SETTINGS - REMOVE ME -------------------- */
if (Bootstrap.DeveloperSettings.DebugBoostState)
{
Debug.Log($"<color=green>{this.GetType()}</color> BoostEnd");
}
/* ----------------- DEVELOPER SETTINGS - REMOVE ME -------------------- */
}
}
protected override void OnUpdate()
{
var requestArray = Group.GetComponentDataArray <NameboardSpawnRequest>();
var entityArray = Group.GetEntityArray();
var spawnRequests = new NameboardSpawnRequest[requestArray.Length];
for (var i = 0; i < requestArray.Length; i++)
{
spawnRequests[i] = requestArray[i];
PostUpdateCommands.DestroyEntity(entityArray[i]);
}
for (var i = 0; i < spawnRequests.Length; i++)
{
var request = spawnRequests[i];
GameObjectEntity nameboardGOE = m_world.Spawn <GameObjectEntity>(ResMgr.GetInstance().GetPrefab("Nameboard"));
nameboardGOE.transform.SetParent(nameboardCanvas);
var nameboardBehav = nameboardGOE.GetComponent <Nameboard>();
var uid = EntityManager.GetComponentData <UID>(request.Owner);
string name = SceneMgr.Instance.GetNameByUID(uid.Value);
nameboardBehav.Name = name;
var isMainRole = RoleMgr.GetInstance().IsMainRoleEntity(request.Owner);
nameboardBehav.CurColorStyle = isMainRole ? Nameboard.ColorStyle.Green : Nameboard.ColorStyle.Red;
if (EntityManager.HasComponent <NameboardData>(request.Owner))
{
var nameboardData = EntityManager.GetComponentData <NameboardData>(request.Owner);
nameboardData.UIEntity = nameboardGOE.Entity;
nameboardData.UIResState = NameboardData.ResState.Loaded;
EntityManager.SetComponentData(request.Owner, nameboardData);
}
}
}
private void NetworkManager_OnDisconnect()
{
ComponentGroup group = GetComponentGroup(ComponentType.Create <NetworkSyncState>(), ComponentType.Create <NetworkSync>());
ComponentDataArray <NetworkSyncState> networkSyncStateComponents = group.GetComponentDataArray <NetworkSyncState>();
ComponentDataArray <NetworkSync> networkSyncComponents = group.GetComponentDataArray <NetworkSync>();
EntityArray entities = group.GetEntityArray();
for (int i = 0; i < entities.Length; i++)
{
Entity entity = entities[i];
PostUpdateCommands.RemoveComponent <NetworkSyncState>(entity);
if (networkSyncStateComponents[i].actorId != networkManager.LocalPlayerID && networkSyncComponents[i].authority != Authority.Scene)
{
PostUpdateCommands.DestroyEntity(entity);
if (EntityManager.HasComponent <Transform>(entity))
{
gameObjectsToDestroy.Add(EntityManager.GetComponentObject <Transform>(entity).gameObject);
}
}
else if (EntityManager.HasComponent <NetworktAuthority>(entity))
{
PostUpdateCommands.RemoveComponent <NetworktAuthority>(entity);
}
for (int j = 0; j < RemoveComponentOnDestroyEntityMethods.Count; j++)
{
RemoveComponentOnDestroyEntityMethods[j].Invoke(this, entity);
}
}
}
protected override void OnUpdate()
{
// Debug.Log("on OnUpdate role looks system");
var requestArray = SpawnGroup.GetComponentDataArray <RoleLooksSpawnRequest>();
if (requestArray.Length == 0)
{
return;
}
var requestEntityArray = SpawnGroup.GetEntityArray();
// Copy requests as spawning will invalidate Group
var spawnRequests = new RoleLooksSpawnRequest[requestArray.Length];
for (var i = 0; i < requestArray.Length; i++)
{
spawnRequests[i] = requestArray[i];
PostUpdateCommands.DestroyEntity(requestEntityArray[i]);
}
for (var i = 0; i < spawnRequests.Length; i++)
{
var request = spawnRequests[i];
// var playerState = EntityManager.GetComponentObject<RoleState>(request.ownerEntity);
var looksInfo = EntityManager.GetComponentData <LooksInfo>(request.ownerEntity);
int career = request.career;
int body = request.body;
int hair = request.hair;
Debug.Log("body : " + body + " hair:" + hair);
int bodyID = 1000 + career * 100 + body;
int hairID = 1000 + career * 100 + hair;
// string careerPath = UnityMMO.GameConst.GetRoleCareerResPath(career);
string roleResPath = "Assets/AssetBundleRes/role";
string bodyPath = roleResPath + "/body/body_" + bodyID + "/model_body_" + bodyID + ".prefab";
string hairPath = roleResPath + "/hair/hair_" + hairID + "/model_hair_" + hairID + ".prefab";
Debug.Log("SpawnRoleLooks bodyPath : " + bodyPath);
XLuaFramework.ResourceManager.GetInstance().LoadAsset <GameObject>(bodyPath, delegate(UnityEngine.Object[] objs) {
if (objs != null && objs.Length > 0)
{
GameObject bodyObj = objs[0] as GameObject;
GameObjectEntity bodyOE = m_world.Spawn <GameObjectEntity>(bodyObj);
var parentTrans = EntityManager.GetComponentObject <Transform>(request.ownerEntity);
parentTrans.localPosition = request.position;
bodyOE.transform.SetParent(parentTrans);
bodyOE.transform.localPosition = Vector3.zero;
bodyOE.transform.localRotation = Quaternion.identity;
LoadHair(hairPath, bodyOE.transform.Find("head"));
Debug.Log("load ok role model");
looksInfo.CurState = LooksInfo.State.Loaded;
looksInfo.LooksEntity = bodyOE.Entity;
EntityManager.SetComponentData <LooksInfo>(request.ownerEntity, looksInfo);
}
else
{
Debug.LogError("cannot fine file " + bodyPath);
}
});
}
}
protected override void OnUpdate()
{
var entities = cubeGroup.GetEntityArray();
var cubeVelocityData = cubeGroup.GetComponentDataArray <CubeTargetVelocity.Component>();
for (var i = 0; i < cubeVelocityData.Length; i++)
{
var rigidbody = EntityManager.GetComponentObject <Rigidbody>(entities[i]);
var cubeComponent = cubeVelocityData[i];
if (cubeComponent.TargetVelocity.X > 0 && rigidbody.position.x - origin.x > 10)
{
cubeComponent.TargetVelocity = new Vector3f {
X = -2.0f
};
cubeVelocityData[i] = cubeComponent;
}
else if (cubeComponent.TargetVelocity.X < 0 && rigidbody.position.x - origin.x < -10)
{
cubeComponent.TargetVelocity = new Vector3f {
X = 2.0f
};
cubeVelocityData[i] = cubeComponent;
}
rigidbody.MovePosition(rigidbody.position + cubeComponent.TargetVelocity.ToUnityVector() * Time.fixedDeltaTime);
}
}
protected override JobHandle OnUpdate(JobHandle inputDeps)
{
var neuralNetworks = new List <NeuralNetworkComponentData>(20);
EntityManager.GetAllUniqueSharedComponentData(neuralNetworks);
for (int i = 0, length = neuralNetworks.Count; i < length; ++i)
{
var neuralNetwork = neuralNetworks[i];
NeuralNetworkGroup.SetFilter(neuralNetwork);
if (NeuralNetworkGroup.GetEntityArray().Length != 0)
{
var job = new UpdateNeuralNetwork {
ResultCountPerNetwork = neuralNetwork.ResultCountPerNetwork,
Inputs = neuralNetwork.Inputs,
Connections = neuralNetwork.Connections,
Results = neuralNetwork.Results,
Poise = neuralNetwork.Poise,
hiddenLayerFunction = neuralNetwork.HiddenLayerThresholdFunction,
outputLayerFunction = neuralNetwork.OutputThresholdFunction,
PerceptronPerLayer = neuralNetwork.PerceptronPerLayerCount,
ConnectionPerNetwork = neuralNetwork.ConnectionCountPerNetwork,
NeuralNetworkIDs = NeuralNetworkGroup.GetComponentDataArray <NeuralNetworkIDComponentData>()
};
Utils.Utils.ScheduleBatchedJobAndComplete(job.Schedule(NeuralNetworkGroup.GetComponentDataArray <NeuralNetworkIDComponentData>().Length, 64, inputDeps));
}
}
return(inputDeps);
}
protected override void OnUpdate()
{
m_mapDataEntities = m_mapDataGroup.GetEntityArray();
m_DataGroupIndex = m_mapDataGroup.GetComponentDataArray <MapIndexComponent>();
m_DataGroupData = m_mapDataGroup.GetComponentDataArray <MapDataComponent>();
for (int i = 0; i < 128 * 128; i++)
{
m_rawFloatData[m_DataGroupIndex[i].Value.x, m_DataGroupIndex[i].Value.y] = m_DataGroupData[i].Value;
m_entityIndexData[m_DataGroupIndex[i].Value.x, m_DataGroupIndex[i].Value.y] = i;
}
for (int w = 0; w < 128; w++)
{
for (int h = 0; h < 128; h++)
{
//------ INNER LOOP ------
for (int wx = -1; wx <= 1; wx++)
{
for (int hx = -1; hx <= 1; hx++)
{
}
}
//------ INNER LOOP ------
}
}
m_mapDataGroup.Dispose();
Unity.Entities.World.Active.GetExistingManager <MetaDataSystem>().Enabled = false;
}
protected override JobHandle OnUpdate(JobHandle inputDeps)
{
var transforms = m_TransformGroup.GetTransformAccessArray();
var entities = m_TransformGroup.GetEntityArray();
var transformStashes = new NativeArray <TransformStash>(transforms.Length, Allocator.TempJob);
var stashTransformsJob = new StashTransforms
{
transformStashes = transformStashes
};
var stashTransformsJobHandle = stashTransformsJob.Schedule(transforms, inputDeps);
var copyTransformsJob = new CopyTransforms
{
positions = m_Positions,
rotations = m_Rotations,
localPositions = m_LocalPositions,
localRotations = m_LocalRotations,
transformStashes = transformStashes,
entities = entities
};
return(copyTransformsJob.Schedule(transformStashes.Length, 64, stashTransformsJobHandle));
}
private void AddedComponents <T>() where T : struct, IComponentData
{
ComponentType componentType = ComponentType.Create <T>();
ComponentGroup group = GetComponentGroup(ComponentType.Create <NetworkSyncState>(), componentType, ComponentType.Subtractive <NetworkComponentState <T> >(), ComponentType.Create <NetworktAuthority>());
ComponentDataArray <T> components = group.GetComponentDataArray <T>();
ComponentDataArray <NetworkSyncState> networkSyncStateComponents = group.GetComponentDataArray <NetworkSyncState>();
EntityArray entities = group.GetEntityArray();
NetworkMemberInfo[] networkMemberInfos = reflectionUtility.GetNetworkMemberInfo(componentType);
for (int i = 0; i < entities.Length; i++)
{
NetworkSyncState networkSyncState = networkSyncStateComponents[i];
ComponentDataContainer componentData = new ComponentDataContainer {
ComponentTypeId = reflectionUtility.GetComponentTypeID(componentType)
};
T component = components[i];
for (int j = 0; j < networkMemberInfos.Length; j++)
{
componentData.MemberData.Add(new MemberDataContainer {
MemberId = j,
Data = (networkMemberInfos[j] as NetworkMemberInfo <T>).GetValue(component),
});
}
ownNetworkSendMessageUtility.AddComponent(entities[i], networkSyncState.actorId, networkSyncState.networkId, componentData);
AllNetworkSendMessageUtility.AddComponent(entities[i], networkSyncState.actorId, networkSyncState.networkId, componentData);
int numberOfMembers = reflectionUtility.GetNumberOfMembers(componentType.GetManagedType());
networkFactory.CreateNetworkComponentData <T>(entities[i], numberOfMembers);
PostUpdateCommands.AddComponent(entities[i], new NetworkComponentState <T>());
}
}
protected override JobHandle OnUpdate(JobHandle inputDeps)
{
// Debug.LogWarning ( "Col" ) ;
Bounds checkBounds = new Bounds()
{
center = new float3(10, 2, 10),
size = new float3(1, 1, 1) * 5 // Total size of boundry
};
EntityArray a_entities = group.GetEntityArray();
Entity rootNodeEntity = a_entities [0];
ComponentDataArray <RootNodeData> a_rootNodeData = group.GetComponentDataArray <RootNodeData> ( );
RootNodeData rootNodeData = a_rootNodeData [0];
BufferFromEntity <NodeBufferElement> nodeBufferElement = GetBufferFromEntity <NodeBufferElement> ();
DynamicBuffer <NodeBufferElement> a_nodesBuffer = nodeBufferElement [rootNodeEntity];
Bounds maxBouds = _GetOctreeMaxBounds(rootNodeData, a_nodesBuffer);
return(base.OnUpdate(inputDeps));
}
protected override void OnUpdate()
{
var time = m_world.worldTime;
var entityArray = ProjectileGroup.GetEntityArray();
var projectileDataArray = ProjectileGroup.GetComponentDataArray <ProjectileData>();
for (var i = 0; i < projectileDataArray.Length; i++)
{
var projectileData = projectileDataArray[i];
if (projectileData.impactTick > 0)
{
if (m_world.worldTime.DurationSinceTick(projectileData.impactTick) > 1.0f)
{
PostUpdateCommands.AddComponent(entityArray[i], new DespawningEntity());
}
continue;
}
var age = time.DurationSinceTick(projectileData.startTick);
var toOld = age > projectileData.maxAge;
if (toOld)
{
PostUpdateCommands.AddComponent(entityArray[i], new DespawningEntity());
}
}
}
protected override void OnUpdate()
{
var entityArray = Group.GetEntityArray();
var requestArray = Group.GetComponentDataArray <ProjectileRequest>();
// Copy requests as spawning will invalidate Group
var requests = new ProjectileRequest[requestArray.Length];
for (var i = 0; i < requestArray.Length; i++)
{
requests[i] = requestArray[i];
PostUpdateCommands.DestroyEntity(entityArray[i]);
}
// Handle requests
foreach (var request in requests)
{
var projectileEntity = m_settings.projectileFactory.Create(EntityManager, -1);
var projectileData = EntityManager.GetComponentData <ProjectileData>(projectileEntity);
projectileData.SetupFromRequest(request);
var projectileRegistry = m_resourceSystem.GetResourceRegistry <ProjectileRegistry>();
projectileData.Initialize(projectileRegistry);
PostUpdateCommands.SetComponent(projectileEntity, projectileData);
PostUpdateCommands.AddComponent(projectileEntity, new UpdateProjectileFlag());
}
}
private void NetworkManager_OnMasterClientChanged(int oldMasterClientId, int newMasterClientId)
{
if (networkManager.LocalPlayerID == oldMasterClientId)
{
ComponentGroup group = GetComponentGroup(ComponentType.Create <NetworkSyncState>(), ComponentType.Create <NetworkSync>(), ComponentType.Create <NetworktAuthority>());
EntityArray entities = group.GetEntityArray();
ComponentDataArray <NetworkSync> networkSync = group.GetComponentDataArray <NetworkSync>();
for (int i = 0; i < entities.Length; i++)
{
if (networkSync[i].authority != Authority.Client)
{
PostUpdateCommands.RemoveComponent <NetworktAuthority>(entities[i]);
}
}
}
if (networkManager.LocalPlayerID == newMasterClientId)
{
ComponentGroup group = GetComponentGroup(ComponentType.Create <NetworkSyncState>(), ComponentType.Create <NetworkSync>(), ComponentType.Subtractive <NetworktAuthority>());
ComponentDataArray <NetworkSync> networkSync = group.GetComponentDataArray <NetworkSync>();
EntityArray entities = group.GetEntityArray();
for (int i = 0; i < entities.Length; i++)
{
if (networkSync[i].authority != Authority.Client)
{
PostUpdateCommands.AddComponent(entities[i], new NetworktAuthority());
}
}
}
}
protected override JobHandle OnUpdate(JobHandle inputDeps)
{
EntityCommandBuffer ecb = barrier.CreateCommandBuffer();
EntityArray a_entities = group.GetEntityArray();
for (int i = 0; i < a_entities.Length; ++i)
{
Entity entity = a_entities [i];
// Renderer
Common.previousMeshInstanceRenderer = entityManager.GetSharedComponentData <MeshInstanceRenderer> (entity);
// Assign new renderrer
Unity.Rendering.MeshInstanceRenderer renderer = Bootstrap.highlightRenderer;
ecb.SetSharedComponent <MeshInstanceRenderer> (entity, renderer); // replace renderer with material and mesh
ecb.RemoveComponent <SetHighlightTag> (entity);
}
/*
* JobHandle job = new Job
* {
* ecb = barrier.CreateCommandBuffer (),
* entityManager = entityManager,
* a_entities = group.GetEntityArray (),
*
* }.Schedule (inputDeps) ;
*
* return job ;
*/
return(inputDeps);
}
protected override void OnUpdate()
{
// Need a list because slot 0 is for the default value of SharedComponentData.
// It's only there because of API limitations. We only care about the SharedComponentData in slot 1.
var uniqueSpawners = new List <HelloSpawner>(2);
// Get all the spawners in the scene.
// In this case, there's only 1, but you could potentially have several spawners with, for example, different prefabs.
EntityManager.GetAllUniqueSharedComponentData(uniqueSpawners);
HelloSpawner spawner = uniqueSpawners[1];
// Filter the component group so we're only looking at entities with shared component data we set in the editor.
// In this case, it's only 1 entity, and it corresponds to the CubeSpawner game object in the scene.
m_Spawners.SetFilter(spawner);
// Create an entity from the prefab set on the spawner component.
// This can't be called from a job, which is why we're doing this in a ComponentSystem on the main thread.
Entity spawnedCubeEntity = EntityManager.Instantiate(spawner.prefab);
// Set the position of the newly spawned cube to the origin.
var position = new Position
{
Value = float3.zero
};
EntityManager.SetComponentData(spawnedCubeEntity, position);
// Destroy the spawner so this system only runs once.
var spawnerEntity = m_Spawners.GetEntityArray()[0];
EntityManager.DestroyEntity(spawnerEntity);
}
protected override void OnUpdate()
{
float dt = Time.deltaTime;
var requestArray = RequestGroup.GetComponentDataArray <SkillSpawnRequest>();
if (requestArray.Length == 0)
{
return;
}
var requestEntityArray = RequestGroup.GetEntityArray();
// Copy requests as spawning will invalidate Group
var requests = new SkillSpawnRequest[requestArray.Length];
for (var i = 0; i < requestArray.Length; i++)
{
requests[i] = requestArray[i];
PostUpdateCommands.DestroyEntity(requestEntityArray[i]);
}
for (var i = 0; i < requests.Length; i++)
{
}
}
