public void Register(int id, Transform caster, Transform target, int index = 0, bool immediately = false)
{
ProjectileData projectileData = ProjectileData.GetProjectileData(id);
if (projectileData == null || caster == null)
{
return;
}
Transform emitter = null;
if (!string.IsNullOrEmpty(projectileData._bone) && "0" != projectileData._bone)
{
PeEntity entity = caster.GetComponent <PeEntity>();
if (null != entity)
{
emitter = entity.GetChild(projectileData._bone);
}
else
{
emitter = PETools.PEUtil.GetChild(caster, projectileData._bone);
}
}
ProjectileRequest req = new ProjectileRequest(id, caster, emitter, Vector3.zero, Quaternion.identity, target, Vector3.zero, index);
if (immediately)
{
req.Create(transform);
}
else
{
m_ReqList.Add(req);
}
}
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());
}
}
public void CreateProjectiles(ProjectileRequest request)
{
if (request.SendToServer)
{
if (request.FiringObj is Structure)
{
_messageService.SendStructureFireRequest(request.FiringObj.Id, request.FiringRotation, request.GetProjectileIDs(), request.FiringWeaponSlot, request.PctCharge);
}
else if (request.FiringObj is Ship)
{
_messageService.SendShipFireRequest(request.FiringObj.Id, request.FiringWeaponSlot, request.GetProjectileIDs(), request.FiringRotation, request.PctCharge, request.ProjectileType);
}
}
if (!Validation.IsMissileType(request.ProjectileType))
{
foreach (var pd in request.ProjectileData)
{
CreateProjectile(request.ProjectileType, pd.ProjectilePosition, pd.VelocityOffset, pd.ProjectileRotation, pd.ProjectileID, request.FiringObj, pd.PctCharge, request.FiringWeaponSlot);
}
}
else
{
foreach (var pd in request.ProjectileData)
{
CreateMissile(request.ProjectileType, pd.ProjectilePosition, pd.VelocityOffset, pd.ProjectileRotation, pd.ProjectileID, request.FiringObj, true, request.FiringWeaponSlot);
}
}
}
protected override void OnUpdate()
{
// Copy requests as spawning will invalidate Group
var requests = new ProjectileRequest[Group.requests.Length];
for (var i = 0; i < Group.requests.Length; i++)
{
requests[i] = Group.requests[i];
PostUpdateCommands.DestroyEntity(Group.entities[i]);
}
// Handle requests
foreach (var request in requests)
{
var projectileEntity = m_settings.projectileFactory.Create(EntityManager);
var projectileData = EntityManager.GetComponentData <ProjectileData>(projectileEntity);
projectileData.Initialize(request);
projectileData.LoadSettings(m_resourceSystem);
PostUpdateCommands.SetComponent(projectileEntity, projectileData);
PostUpdateCommands.AddComponent(projectileEntity, new ServerEntity());
}
}
/// <summary>
/// Fires the weapon. Used for weapons which are fired by this client. Sends fire request to server. Generates a list of projectileIDs to be sent to the server.
/// </summary>
/// <param name="projectileIDs"></param>
/// <param name="rotation"></param>
/// <param name="charge"></param>
public virtual bool Fire_LocalOrigin(float rotation, byte charge, bool changeEnergy)
{
if (!Fire(changeEnergy))
{
return(false);
}
var projectileIDs = new List <int>(Stats.NumProjectiles);
for (int i = 0; i < Stats.NumProjectiles; i++)
{
projectileIDs.Add(Utilities.NextUnique());//Ensures that all IDs are unique
}
List <Vector2> projectilePositions = GeneratePositions(rotation);
List <float> projectileRotations = GenerateRotations(rotation);
List <Vector2> projectileVelocities = GenerateVelocityOffsets(rotation);
ProjectileRequest pr = new ProjectileRequest(HoldingObj, rotation, Slot, charge, true, Stats.ProjectileType);
for (int i = 0; i < projectileIDs.Count; i++)
{
ProjectileData d = new ProjectileData(projectilePositions[i], projectileVelocities[i], projectileRotations[i], projectileIDs[i]);
pr.AddProjectile(d);
}
_projectileManager.CreateProjectiles(pr);
return(true);
}
public void SetupFromRequest(ProjectileRequest request)
{
rayQueryId = -1;
projectileOwner = request.owner;
projectileTypeRegistryId = request.projectileTypeRegistryId;
startTick = request.startTick;
startPos = request.startPosition;
endPos = request.endPosition;
teamId = request.teamId;
collisionCheckTickDelay = request.collisionTestTickDelay;
}
public void Register(int id, Transform caster, Transform emitter, Transform target, int index = 0, bool immediately = false)
{
ProjectileRequest req = new ProjectileRequest(id, caster, emitter, Vector3.zero, Quaternion.identity, target, Vector3.zero, index);
if (immediately)
{
req.Create(transform);
}
else
{
m_ReqList.Add(req);
}
}
public void Register(int id, Transform caster, Vector3 pos, Quaternion rot, Vector3 targetPosition, int index = 0, bool immediately = false)
{
ProjectileRequest req = new ProjectileRequest(id, caster, null, pos, rot, null, targetPosition, index);
if (immediately)
{
req.Create(transform);
}
else
{
m_ReqList.Add(req);
}
}
public static void Create(EntityCommandBuffer commandBuffer, int tick, int tickDelay, WeakAssetReference projectileAsset, Entity owner, int teamId, float3 startPosition, float3 endPosition)
{
var request = new ProjectileRequest
{
projectileAssetGuid = projectileAsset,
startTick = tick,
startPosition = startPosition,
endPosition = endPosition,
owner = owner,
collisionTestTickDelay = tickDelay,
teamId = teamId,
};
commandBuffer.AddComponent(commandBuffer.CreateEntity(), request);
}
void EnterFiringPhase(Entity abilityEntity, ref AbilityControl abilityCtrl
, ref Ability_Chaingun.PredictedState predictedState, ref Ability_Chaingun.Settings settings, int tick)
{
// GameDebug.Log("Chaingun.EnterFiringPhase");
var charAbility = EntityManager.GetComponentData <CharBehaviour>(abilityEntity);
var charPredictedState = EntityManager.GetComponentData <CharPredictedStateData>(charAbility.character);
var character = EntityManager.GetComponentObject <Character>(charAbility.character);
abilityCtrl.behaviorState = AbilityControl.State.Active;
predictedState.SetPhase(Ability_Chaingun.Action.Fire, tick);
predictedState.ammoInClip -= 1;
charPredictedState.SetAction(CharPredictedStateData.Action.PrimaryFire, tick);
// Only fire shot once for each tick (so it does not fire again when re-predicting)
var localState = EntityManager.GetComponentData <Ability_Chaingun.LocalState>(abilityEntity);
if (tick > localState.lastFireTick)
{
localState.lastFireTick = tick;
var command = EntityManager.GetComponentObject <UserCommandComponent>(charAbility.character).command;
var eyePos = charPredictedState.position + Vector3.up * character.eyeHeight;
var endPos = eyePos + command.lookDir * settings.projectileRange;
Debug.Log($"character is {character} and item is {character.presentations[1].GetComponent<RobotWeaponA>()}");
var muzzle = character.presentations[1].GetComponent <RobotWeaponA>().muzzle;
eyePos = muzzle.transform.position;
endPos = eyePos + muzzle.transform.forward * settings.projectileRange;
Debug.Log($"shot from Chaingun, char is {character.name}. Eye Pos is {eyePos} and direction is {endPos}");
//GameDebug.Log("Request Projectile. Tick:" + tick);
ProjectileRequest.Create(PostUpdateCommands, tick, tick - command.renderTick,
settings.projectileRegistryId, charAbility.character, character.teamId, eyePos, endPos);
//
var interpolatedState = EntityManager.GetComponentData <Ability_Chaingun.InterpolatedState>(abilityEntity);
interpolatedState.fireTick = tick;
EntityManager.SetComponentData(abilityEntity, interpolatedState);
EntityManager.SetComponentData(abilityEntity, localState);
}
EntityManager.SetComponentData(abilityEntity, abilityCtrl);
EntityManager.SetComponentData(abilityEntity, predictedState);
EntityManager.SetComponentData(charAbility.character, charPredictedState);
}
public static void Create(EntityCommandBuffer commandBuffer, int tick, int tickDelay, int projectileRegistryId, Entity owner, int teamId, float3 startPosition, float3 endPosition)
{
var request = new ProjectileRequest
{
projectileTypeRegistryId = projectileRegistryId,
startTick = tick,
startPosition = startPosition,
endPosition = endPosition,
owner = owner,
collisionTestTickDelay = tickDelay,
teamId = teamId,
};
commandBuffer.CreateEntity();
commandBuffer.AddComponent(request);
}
void LateUpdate()
{
if (m_ReqList.Count > 0)
{
m_Reqs.Clear();
m_Reqs.AddRange(m_ReqList);
for (int i = m_Reqs.Count - 1; i >= 0; i--)
{
ProjectileRequest req = m_ReqList[i];
req.Create(transform);
m_ReqList.Remove(req);
}
}
}
void EnterFiringPhase(Entity abilityEntity, ref AbilityControl abilityCtrl
, ref Ability_Chaingun.PredictedState predictedState, ref Ability_Chaingun.Settings settings, int tick)
{
// GameDebug.Log("Chaingun.EnterFiringPhase");
var charAbility = EntityManager.GetComponentData <CharBehaviour>(abilityEntity);
var charPredictedState = EntityManager.GetComponentData <CharacterPredictedData>(charAbility.character);
var character = EntityManager.GetComponentObject <Character>(charAbility.character);
abilityCtrl.behaviorState = AbilityControl.State.Active;
predictedState.SetPhase(Ability_Chaingun.State.Fire, tick);
predictedState.ammoInClip -= 1;
charPredictedState.SetAction(CharacterPredictedData.Action.PrimaryFire, tick);
// Only fire shot once for each tick (so it does not fire again when re-predicting)
var localState = EntityManager.GetComponentData <Ability_Chaingun.LocalState>(abilityEntity);
if (tick > localState.lastFireTick)
{
localState.lastFireTick = tick;
var command = EntityManager.GetComponentData <UserCommandComponentData>(charAbility.character).command;
var eyePos = charPredictedState.position + Vector3.up * character.eyeHeight;
var endPos = eyePos + command.lookDir * settings.projectileRange;
//GameDebug.Log("Request Projectile. Tick:" + tick);
ProjectileRequest.Create(PostUpdateCommands, tick, tick - command.renderTick,
settings.projectileAssetGuid, charAbility.character, character.teamId, eyePos, endPos);
//
var interpolatedState = EntityManager.GetComponentData <Ability_Chaingun.InterpolatedState>(abilityEntity);
interpolatedState.fireTick = tick;
EntityManager.SetComponentData(abilityEntity, interpolatedState);
EntityManager.SetComponentData(abilityEntity, localState);
}
EntityManager.SetComponentData(abilityEntity, abilityCtrl);
EntityManager.SetComponentData(abilityEntity, predictedState);
EntityManager.SetComponentData(charAbility.character, charPredictedState);
}
protected override void OnUpdate()
{
var entityArray = Group.ToEntityArray(Allocator.Persistent);
var requestArray = Group.ToComponentDataArray <ProjectileRequest>(Allocator.Persistent);
// 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
var projectileRegistry = m_resourceSystem.GetResourceRegistry <ProjectileRegistry>();
foreach (var request in requests)
{
var registryIndex = projectileRegistry.FindIndex(request.projectileAssetGuid);
if (registryIndex == -1)
{
GameDebug.LogError("Cant find asset guid in registry");
continue;
}
var projectileEntity = m_settings.projectileFactory.Create(EntityManager, m_resourceSystem, null, 0);
var projectileData = EntityManager.GetComponentData <ProjectileData>(projectileEntity);
projectileData.SetupFromRequest(request, registryIndex);
projectileData.Initialize(projectileRegistry);
PostUpdateCommands.SetComponent(projectileEntity, projectileData);
PostUpdateCommands.AddComponent(projectileEntity, new UpdateProjectileFlag());
}
entityArray.Dispose();
requestArray.Dispose();
}
/// <summary>
/// Fires the weapon. Used for weapons which are fired by other clients, with data received from the server.
/// </summary>
/// <param name="projectileIDs"></param>
/// <param name="rotation"></param>
/// <param name="charge"></param>
/// <returns></returns>
public virtual bool Fire_ServerOrigin(List <int> projectileIDs, float rotation, byte charge, bool changeEnergy)
{
if (!Fire(changeEnergy))
{
return(false);
}
List <Vector2> projectilePositions = GeneratePositions(rotation);
List <float> projectileRotations = GenerateRotations(rotation);
List <Vector2> projectileVelocities = GenerateVelocityOffsets(rotation);
ProjectileRequest pr = new ProjectileRequest(HoldingObj, rotation, Slot, charge, false, Stats.ProjectileType);
for (int i = 0; i < projectileIDs.Count; i++)
{
ProjectileData d = new ProjectileData(projectilePositions[i], projectileVelocities[i], projectileRotations[i], projectileIDs[i]);
pr.AddProjectile(d);
}
_projectileManager.CreateProjectiles(pr);
return(true);
}
protected override void Update(Entity entity, AbilityControl abilityCtrl, Ability_ProjectileLauncher.PredictedState predictedState, Ability_ProjectileLauncher.Settings settings)
{
Profiler.BeginSample("ProjectileLauncher_Update");
var time = m_world.worldTime;
switch (predictedState.phase)
{
case Ability_ProjectileLauncher.Phase.Idle:
if (abilityCtrl.activeAllowed == 1)
{
var charAbility = EntityManager.GetComponentData <CharacterAbility>(entity);
var character = EntityManager.GetComponentObject <Character>(charAbility.character);
var charPredictedState = EntityManager.GetComponentObject <CharacterPredictedState>(charAbility.character);
predictedState.SetPhase(Ability_ProjectileLauncher.Phase.Active, time.tick);
charPredictedState.State.SetAction(settings.fireAction, time.tick);
// Only spawn once for each tick (so it does not fire again when re-predicting)
var localState = EntityManager.GetComponentData <Ability_ProjectileLauncher.LocalState>(entity);
if (time.tick > localState.lastFireTick)
{
localState.lastFireTick = time.tick;
EntityManager.SetComponentData(entity, localState);
var eyePos = charPredictedState.State.position + Vector3.up * character.eyeHeight;
var interpolatedState = EntityManager.GetComponentData <Ability_ProjectileLauncher.InterpolatedState>(entity);
var command = EntityManager.GetComponentObject <UserCommandComponent>(charAbility.character)
.command;
var endPos = eyePos + command.lookDir * settings.projectileRange;
ProjectileRequest.Create(PostUpdateCommands, time.tick, time.tick - command.renderTick,
settings.projectileRegistryId, charAbility.character, charPredictedState.teamId, eyePos, endPos);
interpolatedState.fireTick = time.tick;
EntityManager.SetComponentData(entity, interpolatedState);
}
}
break;
case Ability_ProjectileLauncher.Phase.Active:
{
var phaseDuration = time.DurationSinceTick(predictedState.phaseStartTick);
if (phaseDuration > settings.activationDuration)
{
var charAbility = EntityManager.GetComponentData <CharacterAbility>(entity);
var character = EntityManager.GetComponentObject <CharacterPredictedState>(charAbility.character);
predictedState.SetPhase(Ability_ProjectileLauncher.Phase.Cooldown, time.tick);
character.State.SetAction(CharacterPredictedState.StateData.Action.None, time.tick);
}
break;
}
case Ability_ProjectileLauncher.Phase.Cooldown:
{
var phaseDuration = time.DurationSinceTick(predictedState.phaseStartTick);
if (phaseDuration > settings.cooldownDuration)
{
predictedState.SetPhase(Ability_ProjectileLauncher.Phase.Idle, time.tick);
}
break;
}
}
EntityManager.SetComponentData(entity, predictedState);
Profiler.EndSample();
}
protected override void Update(Entity entity, AbilityControl abilityCtrl, Ability_ProjectileLauncher.PredictedState predictedState, Ability_ProjectileLauncher.Settings state)
{
var time = m_world.worldTime;
switch (abilityCtrl.behaviorState)
{
case AbilityControl.State.Idle:
if (abilityCtrl.active == 1)
{
var charAbility = EntityManager.GetComponentData <CharBehaviour>(entity);
var character = EntityManager.GetComponentObject <Character>(charAbility.character);
var charPredictedState = EntityManager.GetComponentData <CharPredictedStateData>(charAbility.character);
abilityCtrl.behaviorState = AbilityControl.State.Active;
predictedState.activeTick = time.tick;
// GameDebug.Log("Ability_ProjectileLauncher SetAction:" + state.fireAction + " tick:" + time.tick);
charPredictedState.SetAction(state.fireAction, time.tick);
// Only spawn once for each tick (so it does not fire again when re-predicting)
var localState = EntityManager.GetComponentData <Ability_ProjectileLauncher.LocalState>(entity);
if (time.tick > localState.lastFireTick)
{
localState.lastFireTick = time.tick;
EntityManager.SetComponentData(entity, localState);
var eyePos = charPredictedState.position + Vector3.up * character.eyeHeight;
var interpolatedState = EntityManager.GetComponentData <Ability_ProjectileLauncher.InterpolatedState>(entity);
var command = EntityManager.GetComponentObject <UserCommandComponent>(charAbility.character)
.command;
var endPos = eyePos + command.lookDir * state.projectileRange;
ProjectileRequest.Create(PostUpdateCommands, time.tick, time.tick - command.renderTick,
state.projectileRegistryId, charAbility.character, character.teamId, eyePos, endPos);
interpolatedState.fireTick = time.tick;
EntityManager.SetComponentData(entity, interpolatedState);
}
EntityManager.SetComponentData(entity, abilityCtrl);
EntityManager.SetComponentData(entity, predictedState);
EntityManager.SetComponentData(charAbility.character, charPredictedState);
}
break;
case AbilityControl.State.Active:
{
var phaseDuration = time.DurationSinceTick(predictedState.activeTick);
if (phaseDuration > state.activationDuration)
{
var charAbility = EntityManager.GetComponentData <CharBehaviour>(entity);
var charPredictedState = EntityManager.GetComponentData <CharPredictedStateData>(charAbility.character);
abilityCtrl.behaviorState = AbilityControl.State.Cooldown;
// GameDebug.Log("Ability_ProjectileLauncher SetAction:" + CharPredictedStateData.Action.None + " tick:" + time.tick);
charPredictedState.SetAction(CharPredictedStateData.Action.None, time.tick);
EntityManager.SetComponentData(entity, abilityCtrl);
EntityManager.SetComponentData(charAbility.character, charPredictedState);
}
break;
}
case AbilityControl.State.Cooldown:
{
var phaseDuration = time.DurationSinceTick(predictedState.activeTick);
if (phaseDuration > state.cooldownDuration)
{
abilityCtrl.behaviorState = AbilityControl.State.Idle;
EntityManager.SetComponentData(entity, abilityCtrl);
}
break;
}
}
}
