public override void UpdateSkillActivation(ItemSkill SourceItemSkill, float CurrentActivationTime, bool StillActivating, bool ActivationIntervallReached)
{
if (CurrentActivationTime < ActivationTime)
{
return;
}
// Spawn and Initialize Projectile:
SkillProjectile SpawnedProjectile = Instantiate(ProjectilePrefab, SourceItemSkill.transform.position, SourceItemSkill.GetCurrentOwner().transform.rotation);
SpawnedProjectile.InitializeProjectile(SourceItemSkill.GetCurrentOwner(), SourceItemSkill, this);
if (ThrowSound)
{
var audioSource = SourceItemSkill.GetComponent <AudioSource>();
audioSource.clip = ThrowSound;
audioSource.volume = 1;
audioSource.loop = false;
audioSource.Play();
}
// Stop Skill Activation:
if (Cooldown > 0)
{
SourceItemSkill.SetCurrentCooldown(Cooldown);
}
RemoveActivationMovementRateModifier(SourceItemSkill, SourceItemSkill.GetCurrentOwner());
SourceItemSkill.StoppedActivatingSkillWithHitObjects(this);
SourceItemSkill.FinishedSkillActivation();
}
public void ApplyEffectsOnTick(Character Owner, ItemSkill SourceItemSkill, Character Target, int FixedLevel)
{
for (int i = 0; i < OnTick.Length; i++)
{
OnTick[i].ApplyEffect(Owner, SourceItemSkill, Target, FixedLevel);
}
}
public virtual bool StartSkillActivation(ItemSkill SourceItemSkill, Character Owner)
{
if (!Owner.CheckHindrance(HindranceLevel))
{
return(false);
}
//CheckIfSkillCouldBeActivated(SourceItemSkill, Owner);
// Skill succesfully activated if this point is reached:
// Pay Activation Cost:
Owner.ChangeEnergyCurrent(-1 * Cost);
// Add Hindrance Level:
Owner.ChangeHindranceLevel(HindranceLevel);
// Add Movement Modifier:
Owner.ChangeMovementRateModifier(ActivationMovementModifier);
// Start Cooldown: (Note: The current Cooldown is saved in the SourceWeapon)
/* if (Cooldown > 0)
* {
* SourceItemSkill.SetCurrentCooldown(Cooldown);
* }*/
return(true);
}
private void OnRefreshSkillItems()
{
foreach (var current in mSkillBtns)
{
ESkillPos pos = current.Key;
ActSkill skill = CharacterManager.Main.Skill.GetSkill(pos);
ItemSkill tab = current.Value;
if (skill == null)
{
tab.maskSprite.gameObject.SetActive(true);
tab.lockSprite.gameObject.SetActive(true);
}
else
{
tab.lockSprite.gameObject.SetActive(false);
if (skill.IsCD())
{
tab.maskSprite.gameObject.SetActive(true);
tab.maskSprite.fillAmount = skill.GetLeftTime() / skill.CD;
}
else
{
tab.maskSprite.gameObject.SetActive(false);
}
}
}
}
public override void ApplyEffect(Character Owner, ItemSkill SourceItemSkill, Character Target)
{
for (int i = 0; i < SkillEffectsToOwner.Length; i++)
{
SkillEffectsToOwner[i].ApplyEffect(Owner, SourceItemSkill, Owner);
}
}
public override void ApplyEffect(Character Owner, ItemSkill SourceItemSkill, Character Target)
{
Vector3 ForceDirection = Vector3.zero;
if (PushDirection == Direction.OWNER_DIRECTION)
{
ForceDirection = Owner.transform.rotation * Vector3.forward;
}
else if (PushDirection == Direction.FROM_OWNER_TO_TARGET)
{
ForceDirection = (Target.transform.position - Owner.transform.position).normalized;
}
else if (PushDirection == Direction.RANDOM)
{
int RandomDegrees = Random.Range(0, 360);
ForceDirection = Quaternion.Euler(0, RandomDegrees, 0) * Vector3.forward;
}
float FinalMagnitude = ForceMagnitude;
for (int i = 0; i < ForceValueModifiers.Length; i++)
{
FinalMagnitude = ForceValueModifiers[i].ModifyValue(FinalMagnitude, Owner, SourceItemSkill, Target);
}
Target.GetComponent <Rigidbody>().AddForce(ForceDirection * FinalMagnitude, ForceMode.Impulse);
}
public virtual void ApplyEffects(Character Owner, ItemSkill SourceItemSkill, Character Target, int FixedLevel)
{
for (int i = 0; i < Effects.Length; i++)
{
Effects[i].ApplyEffect(Owner, SourceItemSkill, Target, FixedLevel);
}
}
public void InitializeProjectile(Character _Owner, ItemSkill _SourceItemSkill, SkillType _SourceSkill)
{
// Link Skill User and Skill:
Owner = _Owner;
SourceSkill = _SourceSkill;
SourceItemSkill = _SourceItemSkill;
// Calculate which Team(s) the Projectile can hit:
int counter = 0;
if (SourceSkill.GetAllowTargetFriendly())
{
counter += (int)(Owner.GetAlignment());
}
if (SourceSkill.GetAllowTargetEnemy())
{
counter += ((int)(Owner.GetAlignment()) % 2) + 1;
}
ProjectileAlignment = (Character.TeamAlignment)(counter);
// Calculate the direction in which the projectile flies:
FlyDirection = Vector3.forward;//Owner.transform.forward;
}
public void EndCondition(Character Owner, ItemSkill SourceItemSkill, Character Target, int FixedLevel)
{
for (int i = 0; i < OnEnd.Length; i++)
{
OnEnd[i].ApplyEffect(Owner, SourceItemSkill, Target, FixedLevel);
}
}
public void EndSkillCurrentlyUsingItemHitBox()
{
SkillCurrentlyUsingItemHitBox = null;
ItemSkillCurrentlyUsingItemHitBox = null;
AlreadyHitCharacters = new List <Character>();
MaxHittableCharacters = -1;
MaxHittableCharactersCounter = -2;
}
public bool CheckIfSkillIsUsingHitBox(ItemSkill SkillToCheck)
{
if (ItemSkillCurrentlyUsingItemHitBox && ItemSkillCurrentlyUsingItemHitBox == SkillToCheck)
{
return(true);
}
return(false);
}
public override void ApplyEffect(Character Owner, ItemSkill SourceItemSkill, Character Target, int FixedLevel)
{
float FinalResistanceValue = ResistanceValueBase;
FinalResistanceValue += ResistanceValuePerLevel * FixedLevel;
Target.ChangeResistance(ResistanceType, FinalResistanceValue);
}
public override void ApplyEffect(Character Owner, ItemSkill SourceItemSkill, Character Target)
{
float FinalResistanceValue = DefenseValueBase;
FinalResistanceValue += DefenseValuePerLevel * SourceItemSkill.GetSkillLevel();
Target.ChangeDefense(DefenseType, FinalResistanceValue);
}
public override void ApplyEffect(Character Owner, ItemSkill SourceItemSkill, Character Target, int FixedLevel)
{
float FinalMoveValue = MoveValueBase;
FinalMoveValue += MoveValuePerLevel * FixedLevel;
Target.ChangeMovementRateModifier(FinalMoveValue);
}
public override void ApplyEffect(Character Owner, ItemSkill SourceItemSkill, Character Target)
{
if (Owner.GetEquippedElement())
{
return;
}
Owner.SpawnAndEquipElement(ElementToEquip);
}
/// <summary>
/// 发送技能升级的请求
/// </summary>
/// <param name="skillId">技能id</param>
/// <param name="item">发送请求的ui</param>
public void SendUpgradeSkill(int skillId, ItemSkill item)
{
Dictionary <byte, object> data = new Dictionary <byte, object>();
data.Add((byte)ParameterCode.SkillId, skillId);
SendRequest(data);
m_ItemSkill = item;
}
public override void UpdateSkillActivation(ItemSkill SourceItemSkill, float CurrentActivationTime, bool StillActivating, bool ActivationIntervallReached)
{
if (CurrentActivationTime < ActivationTime)
{
return;
}
if (!SourceItemSkill.GetEffectOnlyOnceBool(0))
{
SourceItemSkill.SetEffectOnlyOnceBool(0, true);
for (int i = 0; i < EffectsStart.Length; i++)
{
EffectsStart[i].ApplyEffect(SourceItemSkill.GetCurrentOwner(), SourceItemSkill, SourceItemSkill.GetCurrentOwner());
}
SourceItemSkill.GetCurrentOwner().StartAnimation(IdleAnimation, 1, SourceItemSkill.GetParentItemEquipmentSlot());
}
if (ActivationIntervallReached)
{
ApplyEffects(SourceItemSkill.GetCurrentOwner(), SourceItemSkill, SourceItemSkill.GetCurrentOwner());
var audioSource = SourceItemSkill.GetComponent <AudioSource>();
if (ChanellingSound)
{
audioSource.clip = ChanellingSound;
audioSource.loop = true;
audioSource.Play();
}
}
if (!StillActivating || (ActivationTimeMax > 0 && CurrentActivationTime >= ActivationTimeMax))
{
for (int i = 0; i < EffectsEnd.Length; i++)
{
EffectsEnd[i].ApplyEffect(SourceItemSkill.GetCurrentOwner(), SourceItemSkill, SourceItemSkill.GetCurrentOwner());
}
SourceItemSkill.GetCurrentOwner().StartAnimation(ReleaseAnimation, 1, SourceItemSkill.GetParentItemEquipmentSlot());
// Stop Skill Activation:
if (Cooldown > 0)
{
SourceItemSkill.SetCurrentCooldown(Cooldown);
if (ChanellingSound)
{
SourceItemSkill.GetComponent <AudioSource>().Stop();
}
}
RemoveActivationMovementRateModifier(SourceItemSkill, SourceItemSkill.GetCurrentOwner());
SourceItemSkill.StoppedActivatingSkillWithHitObjects(this);
SourceItemSkill.FinishedSkillActivation();
}
}
public override void InitializeHitObject(Character _Owner, ItemSkill _SourceItemSkill, SkillType _SourceSkill, bool UseLevelAtActivationMoment)
{
base.InitializeHitObject(_Owner, _SourceItemSkill, _SourceSkill, UseLevelAtActivationMoment);
// Spawn Particle System:
if (ParticlesPrefab)
{
ParticlesInstance = Instantiate(ParticlesPrefab, ParticlesSpawnParent.transform);
}
}
public override bool StartSkillActivation(ItemSkill SourceItemSkill, Character Owner)
{
var result = base.StartSkillActivation(SourceItemSkill, Owner);
if (result && ChargeUp)
{
var weaponAudioSource = SourceItemSkill.GetComponent <AudioSource>();
weaponAudioSource.clip = ChargeUp;
weaponAudioSource.Play();
}
return(result);
}
public void CreateHitObject(Character Owner, ItemSkill SourceItemSkill, Character Target)
{
Vector3 SpawnPos = Vector3.zero;
Quaternion SpawnRot = Quaternion.identity;
// Spawn and Initialize Projectile:
if (Target == Owner)
{
SpawnRot = Owner.transform.rotation;
if (UseRotationOffset)
{
SpawnRot = Quaternion.Euler(RotationOffset) * SpawnRot;
}
}
else
{
SpawnRot = Quaternion.LookRotation(Target.transform.position - Owner.transform.position);
}
if (SpawnAtTargetPosition)
{
SpawnPos = Target.transform.position;
}
else
{
SpawnPos = SourceItemSkill.transform.position;
}
SkillHitObjectForEffect SpawnedHitObject = Instantiate(HitObjectPrefab, SpawnPos, SpawnRot);
if (SpawnSound)
{
var audioSource = SpawnedHitObject.gameObject.GetComponent <AudioSource>();
if (!audioSource)
{
audioSource = SpawnedHitObject.gameObject.AddComponent <AudioSource>();
}
audioSource.clip = SpawnSound;
if (LoopSound)
{
audioSource.loop = LoopSound;
SpawnedHitObject.FadeSound = true;
SpawnedHitObject.StartCoroutine(FadeAudioIn(audioSource, .5f));
}
else
{
audioSource.Play();
}
}
SpawnedHitObject.InitializeHitObject(SourceItemSkill.GetCurrentOwner(), SourceItemSkill, SkillEffects, AllowTarget, Threat, UseSkillLevelAtActivationMoment);
}
public override void ApplyEffect(Character Owner, ItemSkill SourceItemSkill, Character Target)
{
int FinalDamageValue = DamageValueBase;
FinalDamageValue += DamageValuePerLevel * SourceItemSkill.GetSkillLevel();
int LifeStealValue = Target.InflictDamage(DefenseType, DamageType, FinalDamageValue, 0, 0);
LifeStealValue = Mathf.RoundToInt(LifeStealValue * LifeStealPercentage);
Owner.ChangeHealthCurrent(LifeStealValue);
}
public void ApplyNewCondition(Condition NewCondition, Character SourceCharacter, ItemSkill SourceItemSkill, float Duration)
{
// If the maximum Instances of this Condition is reached, one is removed and the new one applied:
if (CheckIfConditionExists(NewCondition) >= NewCondition.GetInstanceMaximum())
{
RemoveCondition(NewCondition);
}
ActiveCondition NewActiveCondition = new ActiveCondition(this, SourceCharacter, SourceItemSkill, NewCondition, Duration);
ActiveConditions.Add(NewActiveCondition);
}
public override void ApplyEffect(Character Owner, ItemSkill SourceItemSkill, Character Target, int FixedLevel)
{
float LevelValue = LevelValueBase;
LevelValue += LevelValuePerLevel * FixedLevel;
for (int i = 0; i < LevelValueModifiers.Length; i++)
{
LevelValue = LevelValueModifiers[i].ModifyValue(LevelValue, Owner, SourceItemSkill, Target);
}
Target.ChangeSkillLevelModifier(Mathf.RoundToInt(LevelValue));
}
private int CalculateIgnoreResistance(Character Owner, ItemSkill SourceItemSkill, Character Target, int Level)
{
int FinalIgnoreResistanceValue = IgnoreResistanceValueBase;
FinalIgnoreResistanceValue += IgnoreResistanceValuePerLevel * Level;
for (int i = 0; i < IgnoreValueModifiers.Length; i++)
{
FinalIgnoreResistanceValue = Mathf.RoundToInt(IgnoreValueModifiers[i].ModifyValue(FinalIgnoreResistanceValue, Owner, SourceItemSkill, Target));
}
return(FinalIgnoreResistanceValue);
}
public override void ApplyEffect(Character Owner, ItemSkill SourceItemSkill, Character Target, int FixedLevel)
{
if (!Owner.GetEquippedElement())
{
return;
}
SkillEffect[] BonusEffects = Owner.GetEquippedElement().GetBonusEffectOfType(BonusEffectType).GetAdditionalEffects(OnApply);
for (int i = 0; i < BonusEffects.Length; i++)
{
BonusEffects[i].ApplyEffect(Owner, SourceItemSkill, Target, FixedLevel);
}
}
public void StartSkillCurrentlyUsingItemHitBox(ItemSkill SourceItemSkill, SkillType SourceSkill, bool HitEachCharacterOnce, int MaxNumberOfCharactersHittable)
{
if (MaxNumberOfCharactersHittable > 0)
{
MaxHittableCharacters = MaxNumberOfCharactersHittable;
MaxHittableCharactersCounter = 0;
}
else
{
MaxHittableCharacters = -1;
MaxHittableCharactersCounter = -2;
}
StartSkillCurrentlyUsingItemHitBox(SourceItemSkill, SourceSkill, HitEachCharacterOnce);
}
public override void UpdateSkillActivation(ItemSkill SourceItemSkill, float CurrentActivationTime, bool StillActivating, bool ActivationIntervallReached)
{
if (CurrentActivationTime >= HitTimeStart && CurrentActivationTime <= HitTimeStop)
{
if (!SourceItemSkill.CheckIfSkillIsUsingHitBox(SourceItemSkill))
{
SourceItemSkill.StartSkillCurrentlyUsingItemHitBox(HitEachCharacterOnlyOnce, MaxHittableCharacters);
}
}
else if (SourceItemSkill.CheckIfSkillIsUsingHitBox(SourceItemSkill))
{
SourceItemSkill.EndSkillCurrentlyUsingItemHitBox();
}
if (CheckForAnimationTrigger)
{
if (SourceItemSkill.GetCurrentOwner().GetHand(0).TriggerActivateEffect(0))
{
for (int i = 0; i < EffectsOnSelfOnAnimationTrigger.Length; i++)
{
EffectsOnSelfOnAnimationTrigger[i].ApplyEffect(SourceItemSkill.GetCurrentOwner(), SourceItemSkill, SourceItemSkill.GetCurrentOwner());
}
}
if (SourceItemSkill.GetCurrentOwner().GetHand(0).TriggerActivateEffect(1))
{
for (int i = 0; i < EffectsOnSelfOnAnimationTrigger2.Length; i++)
{
EffectsOnSelfOnAnimationTrigger2[i].ApplyEffect(SourceItemSkill.GetCurrentOwner(), SourceItemSkill, SourceItemSkill.GetCurrentOwner());
}
}
}
if (CurrentActivationTime >= ActivationTime)
{
// Stop Skill Activation:
if (Cooldown > 0)
{
SourceItemSkill.SetCurrentCooldown(Cooldown);
}
RemoveActivationMovementRateModifier(SourceItemSkill, SourceItemSkill.GetCurrentOwner());
SourceItemSkill.EndSkillCurrentlyUsingItemHitBox();
SourceItemSkill.StoppedActivatingSkillWithHitObjects(this);
SourceItemSkill.FinishedSkillActivation();
}
}
public void StartSkillCurrentlyUsingItemHitBox(ItemSkill SourceItemSkill, SkillType SourceSkill, bool HitEachCharacterOnce)
{
if (SkillCurrentlyUsingItemHitBox)
{
Debug.Log("WARNING: " + SourceSkill + " overwrites existing " + SkillCurrentlyUsingItemHitBox + " Skill for use of Item Hit Box!");
}
CanHitCharactersOnlyOnce = HitEachCharacterOnce;
SkillCurrentlyUsingItemHitBox = SourceSkill;
ItemSkillCurrentlyUsingItemHitBox = SourceItemSkill;
AlreadyHitCharacters = new List <Character>();
// Calculate which Team(s) the Item can hit:
int counter = 0;
if (SourceSkill.GetAllowTargetFriendly())
{
counter += (int)(CurrentOwner.GetAlignment());
}
if (SourceSkill.GetAllowTargetEnemy())
{
counter += ((int)(CurrentOwner.GetAlignment()) % 2) + 1;
}
CurrentItemHitBoxAlignment = (Character.TeamAlignment)(counter);
// Try to hit all Characters already in the hit box:
List <Character> CleanUpMissingCharacters = new List <Character>();
for (int i = 0; i < CurrentlyCollidingCharacters.Count; i++)
{
if (CurrentlyCollidingCharacters[i] == null)
{
CleanUpMissingCharacters.Add(CurrentlyCollidingCharacters[i]);
}
else if (CheckIfEnterCharacterLegit(CurrentlyCollidingCharacters[i]))
{
ApplyCurrentSkillEffectsToCharacter(CurrentlyCollidingCharacters[i]);
}
}
for (int i = 0; i < CleanUpMissingCharacters.Count; i++)
{
CurrentlyCollidingCharacters.Remove(CleanUpMissingCharacters[i]);
}
}
public override void ApplyEffect(Character Owner, ItemSkill SourceItemSkill, Character Target)
{
if (Target.CheckIfConditionExists(RequiredCondition) > 0)
{
for (int i = 0; i < SkillEffectsIfHasCondition.Length; i++)
{
SkillEffectsIfHasCondition[i].ApplyEffect(Owner, SourceItemSkill, Target);
}
}
else
{
for (int i = 0; i < SkillEffectsIfNoCondition.Length; i++)
{
SkillEffectsIfNoCondition[i].ApplyEffect(Owner, SourceItemSkill, Target);
}
}
}
private void OnRefreshSkillIcons()
{
foreach (var current in mSkillBtns)
{
ESkillPos pos = current.Key;
ActSkill skill = CharacterManager.Main.Skill.GetSkill(pos);
ItemSkill tab = current.Value;
if (skill != null)
{
DSkill db = ReadCfgSkill.GetDataById(skill.ID);
if (db != null)
{
GTItemHelper.ShowTexture(tab.icon, db.Icon);
}
}
}
}
