public void ApplyGameplayEffect(int index, EntityCommandBuffer.Concurrent Ecb, AttributesComponent attributesComponent, float WorldTime) { var attributeModData = AttributeModData(); // var gameplayEffectData = new GameplayEffectDurationComponent() // { // WorldStartTime = WorldTime, // Duration = 5, // Effect = EGameplayEffect.HealRegen // }; var attributeModEntity = Ecb.CreateEntity(index); Ecb.AddComponent(index, attributeModEntity, new HealthAttributeModifier()); // Ecb.AddComponent(index, attributeModEntity, new TemporaryAttributeModification()); Ecb.AddComponent(index, attributeModEntity, new PermanentAttributeModification()); // Ecb.AddComponent(index, attributeModEntity, gameplayEffectData); Ecb.AddComponent(index, attributeModEntity, attributeModData); }
public void Execute(Entity entity, int index, ref Translation translation) { float angle = RandomCache.GetAngle(); float newX = SpawnerSystem.SpawnerPos.x + Mathf.Sin(angle) * RandomCache.GetCenterDistance(); float newZ = SpawnerSystem.SpawnerPos.z + Mathf.Cos(angle) * RandomCache.GetCenterDistance(); translation.Value = new float3(newX, SpawnerSystem.SpawnerPos.y, newZ); CommandBuffer.RemoveComponent <ResetCube>(index, entity); uint BlockType = RandomCache.GetCubeType(); if (BlockType == 1) { CommandBuffer.AddComponent(index, entity, new MoveUp(RandomCache.GetLifeSpan())); } else { CommandBuffer.AddComponent(index, entity, new MoveRandom(RandomCache.GetLifeSpan(), SpawnerSystem.GetRandComponentfloat3())); } }
public void Execute(Entity ent, int idx, [ReadOnly] ref Translation trans, [ReadOnly] ref BoundMarkerConvert convert) { if (!BoundUtil.IsOutOfBounds(bounds, trans.Value.x, trans.Value.y)) { commandBuffer.RemoveComponent(idx, ent, typeof(BoundMarkerConvert)); // add new marker switch (convert.newMarker) { case InteractionType.KeepIn: commandBuffer.AddComponent(idx, ent, new BoundMarkerIn()); break; case InteractionType.DeleteOutside: commandBuffer.AddComponent(idx, ent, new BoundMarkerDelete()); break; } } }
public void Execute(Entity entity, int index, [ReadOnly] ref AttackInput attackInput) { if (attackInput.Attack == true) { float busyUntil = currentTime + attackInput.AttackLength; ECB.AddComponent <Busy>(index, entity, new Busy { Until = busyUntil }); } }
public void Execute(Entity entity, int index, ref Translation translation) { var closestEntity = closestTargets[index]; if (closestEntity != Entity.Null) { commandBuffer.AddComponent(index, entity, new HasTarget { target = closestEntity }); } }
public void Execute(Entity soldierEntity, int index, ref Translation c0) { Entity closestEnemyEntity = closestEntityArray[index]; if (closestEnemyEntity != Entity.Null) { entityCommandBuffer.AddComponent(index, soldierEntity, new HasEnemyComponent { enemyEntity = closestEnemyEntity }); } }
private static void ApplyRandomColor(ref EntityCommandBuffer.Concurrent commandBuffer, ref Random randomGenerator, int entityInQueryIndex, Entity spawnedEntity) { Color color = Color.HSVToRGB(randomGenerator.NextFloat(), 0.6f, 0.6f); float4 colorValue = new float4(color.r, color.g, color.b, color.a); MaterialColor materialColor = new MaterialColor { Value = colorValue }; commandBuffer.AddComponent(entityInQueryIndex, spawnedEntity, materialColor); }
public void Execute(Entity entity, int index, ref Attack Attack, ref Target Target) { if (Clicked) { Damage damage = new Damage() { Value = Attack.Value }; cmd.AddComponent(index, Target.Entity, damage); } }
public void Execute (Entity entity, int i, [ReadOnly] ref PlayerInput input, [ReadOnly] ref AABB aabb) { if (input.LeftClick) { //If selected component exists on our unit, unselect before we recalc selected if (Selected.Exists(entity)) { commandBuffer.RemoveComponent <PlayerUnitSelect>(i, entity); commandBuffer.AddComponent(i, entity, new Deselecting()); } //Add select component to unit if (RTSPhysics.Intersect(aabb, ray)) { commandBuffer.AddComponent(i, entity, new PlayerUnitSelect()); commandBuffer.AddComponent(i, entity, new Selecting()); } } }
public void Execute(Entity actor, int index, [ReadOnly] ref ValidateUsageRequest c0) { EndEcb.RemoveComponent <ValidateUsageRequest>(index, actor); if (c0.ResultType != ResultType.Fail) { return; } BeginEcb.AddComponent <OnActionInvalid>(index, actor); EndEcb.RemoveComponent <OnActionInvalid>(index, actor); }
public void Execute(Entity entity, int index, DynamicBuffer <KillersOnActorDeath> actorDeathByKillers, [ChangedFilter, ReadOnly] DynamicBuffer <ActorAttribute3Modifys <T> > attribute3Modifys, ref ActorAttribute3Base <T> attribute3Base, ref ActorAttribute3 <T> attribute3) { //max attribute3.max = attribute3Base.max; for (var i = 0; i < attribute3Modifys.Length; ++i) { if (attribute3Modifys[i].attribute3ModifyType == Attribute3SubModifyType.MaxOffset) { attribute3.max += attribute3Modifys[i].value; } } //regain attribute3.regain = attribute3Base.regain; for (var i = 0; i < attribute3Modifys.Length; ++i) { if (attribute3Modifys[i].attribute3ModifyType == Attribute3SubModifyType.RegainOffset) { attribute3.regain += attribute3Modifys[i].value; } } if (attribute3.regain < 0f) { attribute3.regain = 0f; } //value for (var i = 0; i < attribute3Modifys.Length; ++i) { var attribute3Modify = attribute3Modifys[i]; if (attribute3Modify.attribute3ModifyType == Attribute3SubModifyType.ValueOffset) { attribute3.value += attribute3Modify.value; // if (attribute3Modify.value < 0f) { actorDeathByKillers.Add(new KillersOnActorDeath { playerEntity = attribute3Modify.player, type = attribute3Modify.type }); } } } if (attribute3.value > attribute3.max) { attribute3.value = attribute3.max; } //dead if (attribute3.value <= 0f) { endCommandBuffer.AddComponent(index, entity, OnDestroyMessage); } }
public void Execute(Entity e, int index, ref Translation translation, ref RigidBodyComponent rigidBody, [ReadOnly] ref ConveyorComponent conveyor) { rigidBody.Velocity = conveyor.Direction * conveyor.Speed; translation.Value += rigidBody.Velocity * DeltaTime; if (translation.Value.x * conveyor.Direction.x > conveyor.MaxX) { CommandBuffer.RemoveComponent <ConveyorComponent>(index, e); CommandBuffer.AddComponent(index, e, new ResetTag()); } }
public void Execute(Entity entity, int index, [ReadOnly] ref LevelLoadRequest request, [ReadOnly] ref ReceiveRpcCommandRequestComponent requestSource) { commandBuffer.DestroyEntity(index, entity); // Check for disconnects if (!rpcFromEntity.Exists(requestSource.SourceConnection)) { return; } // set the level size - fake loading of level levelFromEntity[levelSingleton] = new LevelComponent { width = request.width, height = request.height, playerForce = request.playerForce, bulletVelocity = request.bulletVelocity }; commandBuffer.AddComponent(index, requestSource.SourceConnection, new PlayerStateComponentData()); commandBuffer.AddComponent(index, requestSource.SourceConnection, default(NetworkStreamInGame)); rpcQueue.Schedule(rpcFromEntity[requestSource.SourceConnection], new RpcLevelLoaded()); }
public void Execute(int index) { if (AddArray[index]) { CommandBuffer.AddComponent(m_ThreadIndex, EntityArray[index], new FacingTarget()); } else if (RemoveArray[index]) { CommandBuffer.RemoveComponent <FacingTarget>(m_ThreadIndex, EntityArray[index]); } }
public void Execute(Entity weaponEntity, int index, ref WeaponControlInFireState fireState) { fireState.duration -= fixedDeltaTime; if (fireState.duration <= 0) { commandBuffer.RemoveComponent(index, weaponEntity, WeaponControlInFireState); commandBuffer.AddComponent(index, weaponEntity, OnWeaponControlFireOffMessage); endCommandBuffer.RemoveComponent(index, weaponEntity, OnWeaponControlFireOffMessage); } }
public void Execute(Entity entity, int index, [ReadOnly] ref LbPlayer player, ref Translation translation, [ReadOnly] ref LbMovementSpeed speed, [ReadOnly] ref LbArrowPosition position) { translation.Value += speed.Value * DeltaTime * (position.Value - translation.Value); if (math.distancesq(translation.Value, position.Value) < 0.05f) { translation.Value = position.Value; CommandBuffer.AddComponent(index, entity, new LbArrow()); } }
public void Execute(Entity _ /*playerEntity*/, int index, ref PlayerActorArray playerActorArray) { if (playerActorArray.mainActorEntity != Entity.Null) { endCommandBuffer.AddComponent(index, playerActorArray.mainActorEntity, OnDestroyMessage); playerActorArray.mainActorEntity = Entity.Null; } //commandBuffer.RemoveComponent(index, playerEntity, PlayerActorArray); }
public void Execute(Entity entity, int index, ref FindTarget findTarget) { if (findTarget.FoundEntity != Entity.Null) { Debug.Log("Add target"); CommandBuffer.AddComponent(index, entity, new Target() { TargetEntity = findTarget.FoundEntity }); CommandBuffer.RemoveComponent(index, entity, typeof(FindTarget)); } }
public void Execute(Entity entity, int index, ref Translation translation) { QuadrantData quadrantData; if (entityTargetHashMap.TryGetValue(entity, out quadrantData)) { entityCommandBuffer.RemoveComponent(index, entity, typeof(HasTarget)); entityCommandBuffer.AddComponent(index, entity, new HasTarget { targetEntity = quadrantData.entity, targetPosition = quadrantData.position }); } }
// The [ReadOnly] attribute tells the job scheduler that this job will not write to rotSpeedSpawnAndRemove public void Execute(Entity entity, int index, ref Translation translation, ref MoveRandom moving) { // Rotate something about its up vector at the speed given by RotationSpeed_SpawnAndRemove. translation.Value = new float3(translation.Value.x + moving.Direction.x * DeltaTime, translation.Value.y + DeltaTime * moving.Direction.y, translation.Value.z);// + moving.Direction.z * DeltaTime); moving.LifeSpan -= DeltaTime; if (translation.Value.y > 7.0f || moving.LifeSpan <= 0f || translation.Value.x > 20f) { CommandBuffer.RemoveComponent <MoveRandom>(index, entity); CommandBuffer.AddComponent <ResetCube>(index, entity); } }
public void Execute(Entity entity, int index, [Unity.Collections.ReadOnly] ref ResolveAbilityTradeData c0) { EntityCommandBuffer.RemoveComponent <ResolveAbilityTradeData>(index, entity); var e = EntityCommandBuffer.CreateEntity(index); EntityCommandBuffer.AddComponent(index, e, new LootCoinsData { Amount = 10, }); EntityCommandBuffer.CreateEntity(index, PostResolveCardArchetype); }
public void Execute(ArchetypeChunk chunk, int chunkIndex, int firstEntityIndex) { var instanceCount = chunk.Count; var entities = chunk.GetNativeArray(entityType); for (var i = 0; i < instanceCount; i++) { commandBuffer.AddComponent(chunkIndex, entities[i], new LocalToWorld { Value = float4x4.identity }); } }
protected override JobHandle OnUpdate(JobHandle inputDeps) { EntityCommandBuffer.Concurrent commandBuffer = m_EntityCommandBuffer.CreateCommandBuffer().ToConcurrent(); JobHandle savePos = Entities.ForEach((Entity entity, int entityInQueryIndex, in Translation translation, in C_HoldComponentData holdData) => { commandBuffer.AddComponent <C_SetPositionComponentData>(entityInQueryIndex, holdData.Item); commandBuffer.SetComponent(entityInQueryIndex, holdData.Item, new C_SetPositionComponentData { Position = translation.Value, }); }).Schedule(inputDeps);
public void Execute(Entity entity, int index, [ReadOnly] ref ServerStateCommand c0) { EndCommandBuffer.DestroyEntity(index, entity); var buffer = ServerStates[entity].Reinterpret <byte>().AsNativeArray().ToArray(); var worldState = MessagePackSerializer.Deserialize <WorldState>(buffer); foreach (var pState in worldState.playerState) { var e = CommandBuffer.CreateEntity(index); CommandBuffer.AddComponent(index, e, pState); } }
protected override JobHandle OnUpdate(JobHandle inputDeps) { EntityCommandBuffer.Concurrent commandBuffer = m_EntityCommandBuffer.CreateCommandBuffer().ToConcurrent(); JobHandle jobHandle = Entities .WithAll <TC_PickHoldAction>() .WithNone <C_CanPick>() .ForEach((Entity entity, int entityInQueryIndex, in Translation translation, in C_HoldComponentData holdComponent, in DirectionData directionData) => { int2 i2Direction = directionData.directionLook; float fXDropPosition = translation.Value.x + (float)i2Direction.x / 2; commandBuffer.AddComponent <MC_RemoveInHold>(entityInQueryIndex, holdComponent.Item); commandBuffer.SetComponent(entityInQueryIndex, holdComponent.Item, new MC_RemoveInHold { Position = new float3(fXDropPosition, translation.Value.y, 0) }); commandBuffer.RemoveComponent <TC_PickHoldAction>(entityInQueryIndex, entity); commandBuffer.RemoveComponent <C_HoldComponentData>(entityInQueryIndex, entity); commandBuffer.AddComponent <C_CanPick>(entityInQueryIndex, entity); }).Schedule(inputDeps);
public void Execute(Entity entity, int index, ref Translation translation) { float3 entityPosition = translation.Value; if (entityPosition.x >= lowerLeftPosition.x && entityPosition.y >= lowerLeftPosition.y && entityPosition.x <= upperRightPosition.x && entityPosition.y <= upperRightPosition.y) { entityCommandBuffer.AddComponent(index, entity, new SelectedTag()); } }
protected override void OnStateEnter(EntityCommandBuffer.Concurrent ecbConcurrent) { Entities .WithNone <TestPlayStateSystemState>() .ForEach((Entity entity, int entityInQueryIndex, in TestPlayState state) => { ecbConcurrent.AddComponent <TestPlayStateSystemState>(entityInQueryIndex, entity); }) .Schedule(); }
public void Execute(Entity e, int index, [ReadOnly] ref Position antPos, ref FacingAngle facingAngle) { Vector2 distance = antPos.Value - ColonyPos[0].Value; if (distance.sqrMagnitude < 4f * 4f) { //ant.holdingResource = !ant.holdingResource; ecb.RemoveComponent <TagAntHasFood>(index, e); ecb.AddComponent <TagAntHasDirtyMesh>(index, e); facingAngle.Value += Mathf.PI; } }
public void Execute(Entity npc, int index, [ReadOnly] ref Translation translation) { var target = TargetArray[index]; if (target != Entity.Null) { EntityCommandBuffer.AddComponent(index, npc, new HasTarget { Target = target }); } }
public void Execute(Entity entity, int jobIndex, ref AttackTargetComponent attackTarget, ref AttackStatusComponent attackStatus) { if (time - attackStatus.LastAttack >= attackRate) { attackStatus.LastAttack = time; Entity e = commandBuffer.CreateEntity(jobIndex); commandBuffer.AddComponent(jobIndex, e, new DamageComponent { Source = entity, Target = attackTarget.Target, Amount = damage }); } }