public override IEnumerator Trigger(AbilityCastData abilityCastData)
{
//Outputs the desired string to the console.
Debug.Log(debugText);
yield return(null);
}
public override IEnumerator Trigger(AbilityCastData abilityCastData)
{
//Remove the desired amount of mana from the player's mana pool.
playerStatsDataHolder.Mana -= manaToSpend;
yield return(null);
}
public override IEnumerator Trigger(AbilityCastData abilityCastData)
{
//Put the item on cooldown.
abilityCooldownDataHolder.PutOnCooldown(cooldown);
yield return(null);
}
public override IEnumerator Trigger(AbilityCastData abilityCastData)
{
//Loop for the number of shots we wish to fire at each target.
for (int i = 0; i < shotsPerTarget; i++)
{
//Loop through each target that we have collected.
foreach (ITargetable target in abilityCastData.AbilityActionHandler.CurrentTargets)
{
//Make sure the target still exists.
if (target == null)
{
continue;
}
//Spawn in the projectile at the player's right hand.
GameObject projectileInstance = GameObject.Instantiate(projectileToShoot, abilityCastData.RightHandTransform.position, Quaternion.identity);
//Initialise the homing script with the target's transform component.
projectileInstance.GetComponent <HomeInOnTransform>().Initialise(target.TargetTransform);
}
//Only wait for the delay if it isn't our last shot.
if (i != shotsPerTarget - 1)
{
yield return(new WaitForSeconds(delayBetweenShots));
}
}
yield return(null);
}
public static void WriteAbilityCastData(this NetworkWriter writer, AbilityCastData castData)
{
AbilityCastIdentifier identifier = new AbilityCastIdentifier(
castData.Caster,
castData.CastTime,
castData.AbilityCast.AbilityID,
castData.MultiCastID);
//Identifier
writer.WriteAbilityCastIdentifier(identifier);
//Resources Impacts
writer.WriteInt32(castData.BaseResourcesImpacts.Length);
for (int i = 0; i < castData.BaseResourcesImpacts.Length; i++)
{
writer.WriteAbilityResourceImpactData(castData.BaseResourcesImpacts[i]);
}
//Vec3
writer.WriteVector3(castData.BaseKnockback);
writer.WriteVector3(castData.BaseRecoil);
writer.WriteVector3(castData.CastDirection);
writer.WriteVector3(castData.Origin);
if (_storedAbilityCastData.ContainsKey(identifier))
{
_storedAbilityCastData[identifier] = castData;
}
else
{
_storedAbilityCastData.Add(identifier, castData);
}
}
public override IEnumerator Trigger(AbilityCastData abilityCastData)
{
//Remove the desired quantity of the desired item from the player's inventory.
playerInventory.ItemHolder.RemoveItem(itemToRemove, quantityToRemove);
yield return(null);
}
public override IEnumerator Trigger(AbilityCastData abilityCastData)
{
//Loop through each target that we have collected.
foreach (ITargetable target in abilityCastData.AbilityActionHandler.CurrentTargets)
{
//Make sure that the target still exists.
if (target == null)
{
continue;
}
//Get the damageable component from the target.
IDamageable damageable = target.transform.GetComponent <IDamageable>();
//Make sure that the target is damageable.
if (damageable == null)
{
continue;
}
//Heal the target damageable by the desired heal amount.
damageable.Heal(healAmount);
}
yield return(null);
}
protected override void PerformAbility(AbilityCastData castData)
{
base.PerformAbility(castData);
if (References.NetworkIdentity.hasAuthority == true)
{
_nextAbilitiesCast.Add(castData);
PinouNetworkManager.MainBehaviour.SetDirty(master.gameObject, SyncableVariable.EntityAbilityCast);
}
}
public override IEnumerator Trigger(AbilityCastData abilityCastData)
{
//Smoothly transition to the desired animation clip
abilityCastData.Animator.CrossFade(AnimationHash, crossfadeDuration);
//Wait for the animation clip to trigger an animation event callback
if (waitForCallback)
{
yield return(abilityCastData.AbilityActionHandler.WaitForAnimationCallback());
}
}
public override IEnumerator Trigger(AbilityCastData abilityCastData)
{
//Check if something is already being channeled and if not, start channeling.
if (!abilityChannelDataHolder.StartChanneling(channelable))
{
//Something was already being channeled so we interrupt.
abilityCastData.AbilityActionHandler.Interrupt();
}
//If the spell needs to wait until the channel has finished to continue then do so.
if (waitForChannel)
{
yield return(new WaitUntil(() => abilityChannelDataHolder.FinishedChanneling));
}
}
private void SyncDestroyAbilityHitbox(SyncableVariable var, NetworkReader reader)
{
int hitboxCount = reader.ReadInt32();
for (int i = 0; i < hitboxCount; i++)
{
AbilityCastData castData = reader.ReadAbilityCastData();
AbilityHitbox.DestroyFromCastData(castData);
if (References.NetworkIdentity.isServer && References.NetworkIdentity.hasAuthority == false)
{
_nextHitboxDestroyed.Add(castData);
PinouNetworkManager.MainBehaviour.SetDirty(master.gameObject, SyncableVariable.EntityAbilityHitboxDestroyed);
}
}
}
private static void ReadAbilityCastDataBody(NetworkReader reader, AbilityCastData castDataToFill)
{
//Resources Impacts
int baseResourcesImpactLength = reader.ReadInt32();
AbilityResourceImpactData[] impactsData = new AbilityResourceImpactData[baseResourcesImpactLength];
for (int i = 0; i < impactsData.Length; i++)
{
impactsData[i] = reader.ReadAbilityResourceImpactData();
}
castDataToFill.FillBase(
impactsData,
//Vec3
reader.ReadVector3(),
reader.ReadVector3());
castDataToFill.FillCastDirection(reader.ReadVector3());
castDataToFill.FillOrigin(reader.ReadVector3());
}
public static AbilityCastResult ReadAbilityCastResult(this NetworkReader reader)
{
//CastData
AbilityCastData castData;
AbilityCastIdentifier identifier = ReadAbilityCastIdentifier(reader);
if (_storedAbilityCastData.ContainsKey(identifier))
{
castData = _storedAbilityCastData[identifier];
}
else
{
castData = new AbilityCastData(
identifier.Caster,
(AbilityData)PinouApp.Resources.Data.Databases.GetItem(DatabaseType.Ability, identifier.AbilityID),
identifier.CastTime,
identifier.MultiCastID);
_storedAbilityCastData.Add(identifier, castData);
}
ReadAbilityCastDataBody(reader, castData);
AbilityCastResult result = new AbilityCastResult(castData);
//Main
_ = reader.ReadInt32();//Discards ResultType
result.FillVictim(reader.ReadGameObject().GetComponent <Entity>());
result.FillImpact(reader.ReadVector3());
result.FillKnockbackApplied(reader.ReadVector3());
//Resources Changes
int resourceChangesLength = reader.ReadInt32();
AbilityResourceImpactData[] resourceChanges = new AbilityResourceImpactData[resourceChangesLength];
for (int i = 0; i < resourceChangesLength; i++)
{
resourceChanges[i] = reader.ReadAbilityResourceImpactData();
}
result.SetResourceChanges(resourceChanges);
return(result);
}
private void SyncCastAbility(SyncableVariable var, NetworkReader reader)
{
int hitboxCount = reader.ReadInt32();
for (int i = 0; i < hitboxCount; i++)
{
AbilityCastData castData = reader.ReadAbilityCastData();
if (castData.AbilityCast.Hitbox.UnlimitedLifeSpan == true || castData.AbilityCast.Hitbox.LifeSpan > 0)
{
AbilityHitbox hitBox = AbilityPerformer.HandleSpawnAbilityHitbox(castData);
hitBox.ActivateVisualMode();
}
OnPerformAbility.Invoke(master, castData);
if (References.NetworkIdentity.isServer && References.NetworkIdentity.hasAuthority == false)
{
_nextAbilitiesCast.Add(castData);
PinouNetworkManager.MainBehaviour.SetDirty(master.gameObject, SyncableVariable.EntityAbilityCast);
}
}
}
public override IEnumerator Trigger(AbilityCastData abilityCastData)
{
//Spawn in the projectile at the player's right hand.
GameObject projectileInstance = GameObject.Instantiate(projectileToLaunch, abilityCastData.RightHandTransform.position, Quaternion.identity);
//Get the forward direction relative to where the main camera is aiming.
Transform mainCameraTransform = Camera.main.transform;
//Initialise the target position in case we don't hit anything with the raycast.
Vector3 targetPos = mainCameraTransform.position + mainCameraTransform.forward * 1000f;
//Overwrite the target pos if we hit something with the raycast.
if (Physics.Raycast(mainCameraTransform.position, mainCameraTransform.forward, out RaycastHit hit, 1000f, layerMask))
{
targetPos = hit.point;
}
//Calculate the target direction to launch the projectile.
Vector3 targetDirection = (targetPos - projectileInstance.transform.position).normalized * launchSpeed;
//Handle the different launch scenarios.
switch (launchType)
{
case LaunchType.None:
Debug.LogError("You've forgotten to set the projectile's launch type.");
break;
case LaunchType.Transform:
MoveTransformOverTime transformMovement = projectileInstance.GetComponent <MoveTransformOverTime>();
transformMovement.Initialise(targetDirection);
break;
case LaunchType.Rigidbody:
Rigidbody rb = projectileInstance.GetComponent <Rigidbody>();
rb.AddForce(targetDirection, ForceMode.VelocityChange);
break;
}
yield return(null);
}
public static AbilityCastData ReadAbilityCastData(this NetworkReader reader)
{
AbilityCastIdentifier identifier = ReadAbilityCastIdentifier(reader);
if (_storedAbilityCastData.ContainsKey(identifier))
{
ReadAbilityCastDataBody(reader, _storedAbilityCastData[identifier]);
return(_storedAbilityCastData[identifier]);
}
else
{
AbilityCastData castData = new AbilityCastData(
identifier.Caster,
(AbilityData)PinouApp.Resources.Data.Databases.GetItem(DatabaseType.Ability, identifier.AbilityID),
identifier.CastTime,
identifier.MultiCastID);
ReadAbilityCastDataBody(reader, castData);
_storedAbilityCastData.Add(identifier, castData);
return(castData);
}
}
public abstract void StartFX(AbilityCastData castData);
public override void Interrupt(AbilityCastData abilityCastData) => onChannelableInterrupted.Raise(channelable);
public override IEnumerator Trigger(AbilityCastData abilityCastData)
{
//Wait for the desired time (in seconds).
yield return(new WaitForSeconds(waitTime));
}
