void OnFire()
{
List <UnitScript> targetUnits = new List <UnitScript>();
for (int i = 0; i < skill.unitGroupScript.unitsInGroupRange.Count; i++)
{
if (i == numTargets)
{
break;
}
UnitScript unit = skill.unitGroupScript.unitsInGroupRangeScripts[i];
if (unit != null)
{
if (unit.flagScript.Faction == targetFaction &&
!unit.flagScript.currentSkillFlags.ContainsKey(SkillResult.flag_recentlyHealed) &&
unit.healthScript.CurrentHealth < unit.healthScript.BaseHealth)
{
targetUnits.Add(unit);
}
}
}
if (targetUnits.Count < numTargets)
{
for (int i = 0; i < skill.unitGroupScript.unitsInGroupScripts.Count; i++)
{
if (i == numTargets)
{
break;
}
UnitScript unit = skill.unitGroupScript.unitsInGroupScripts[i];
if (unit != null)
{
if (unit.flagScript.Faction == targetFaction &&
!unit.flagScript.currentSkillFlags.ContainsKey(SkillResult.flag_recentlyHealed) &&
unit.healthScript.CurrentHealth < unit.healthScript.BaseHealth)
{
targetUnits.Add(unit);
}
}
}
}
sortByLowestHealth(ref targetUnits);
SkillResult skillResult = new SkillResult();
skillResult.skillType = SkillResult.SkillType.Heal;
skillResult.skillPower = healpower;
skillResult.skillFlag = SkillResult.flag_recentlyHealed;
skillResult.skillFlagTimer = Time.time + flagCooldown;
if (targetUnits.Count > 0 && numTargets > 0)
{
for (int i = 0; i < numTargets; i++)
{
SkillCalculator.passSkillResult(this.gameObject, targetUnits[i].gameObject, skillResult);
Instantiate(healEffect, targetUnits[i].transform.position, Quaternion.identity);
}
}
}
private void CastSkil()
{
SkillResult result = this.skill.canCast(BattleManager.Instance.CurrentTarget);
switch (result)
{
case SkillResult.InvalidTarget:
MessageBox.Show("技能：[" + this.skill.Define.Name + "]目标无效");
break;
case SkillResult.OutOfMp:
MessageBox.Show("技能：[" + this.skill.Define.Name + " ]MP 不足");
break;
case SkillResult.CoolDown:
MessageBox.Show("技能：[" + this.skill.Define.Name + " ]长、正在冷却");
break;
case SkillResult.OutOfRange:
MessageBox.Show("技能：[" + this.skill.Define.Name + " ]施法范围");
break;
}
BattleManager.Instance.CastSkill(this.skill);
}
public void passSkillResultToGroup(SkillResult skillResult, GameObject attacker)
{
if (skillResult.skillType == SkillResult.SkillType.Buff)
{
if (!currentSkillFlags.ContainsKey(skillResult.skillFlag))
{
currentSkillFlags.Add(skillResult.skillFlag, skillResult.skillFlagTimer);
}
for (int i = 0; i < unitsInGroup.Count; i++)
{
SkillCalculator.passSkillResult(attacker, unitsInGroup[i], skillResult);
}
return;
}
else if (skillResult.skillType == SkillResult.SkillType.RemoveBuff)
{
if (currentSkillFlags.ContainsKey(skillResult.skillFlag))
{
currentSkillFlags.Remove(skillResult.skillFlag);
}
for (int i = 0; i < unitsInGroup.Count; i++)
{
SkillCalculator.passSkillResult(attacker, unitsInGroup[i], skillResult);
}
return;
}
for (int i = 0; i < unitsInGroup.Count; i++)
{
SkillCalculator.passSkillResult(attacker, unitsInGroup[i], skillResult);
}
return;
}
public static void passSkillResult(GameObject attacker, GameObject target, SkillResult skillResult)
{
if (target != null)
{
target.SendMessage("OnSkillResult", skillResult, SendMessageOptions.DontRequireReceiver);
}
}
public void OnFire()
{
Collider[] hitColliders = Physics.OverlapSphere(transform.parent.position, attackRadius);
int i = 0;
while (i < hitColliders.Length)
{
Debug.Log("HIT");
if (hitColliders[i].gameObject.tag.Contains(vars.attackable_tag) &&
hitColliders[i].gameObject.GetComponent <FlagScript>().Faction == targetFaction &&
!hitColliders[i].gameObject.GetComponent <FlagScript>().currentSkillFlags.ContainsKey(SkillResult.flag_movementspeedDecreased) &&
hitColliders[i].gameObject.GetComponent <HealthScript>().hasHealth)
{
SkillResult skillResult = new SkillResult();
sporeEffect.emitOnce();
skillResult.skillType = SkillResult.SkillType.Debuff;
skillResult.skillAttribute = SkillResult.SkillAttribute.MovementSpeed;
skillResult.skillFlag = SkillResult.flag_movementspeedDecreased;
skillResult.skillFlagTimer = 1.0f;
skillResult.skillPower = attackPower;
SkillCalculator.passSkillResult(transform.gameObject, hitColliders[i].gameObject, skillResult);
}
i++;
}
}
public IEnumerable <Tera.Game.Skill> SkillsIdBySource(UserEntity source, Entity target, bool timed)
{
IEnumerable <Tera.Game.Skill> result;
if (!SourceTargetSkill.ContainsKey(source))
{
return(new List <Tera.Game.Skill>());
}
if (timed || target == null)
{
result = from skills in SourceTargetSkill[source].Values
from skill in skills
select SkillResult.GetSkill(source, skill.Pet, skill.SkillId, skill.HotDot, PacketProcessor.Instance.EntityTracker,
BasicTeraData.Instance.SkillDatabase, BasicTeraData.Instance.HotDotDatabase, BasicTeraData.Instance.PetSkillDatabase);
return(result.Distinct());
}
if (!SourceTargetSkill[source].ContainsKey(target))
{
return(new List <Tera.Game.Skill>());
}
result = from skills in SourceTargetSkill[source][target]
select SkillResult.GetSkill(source, skills.Pet, skills.SkillId, skills.HotDot, PacketProcessor.Instance.EntityTracker,
BasicTeraData.Instance.SkillDatabase, BasicTeraData.Instance.HotDotDatabase, BasicTeraData.Instance.PetSkillDatabase);
return(result.Distinct());
}
public void OnFire()
{
Collider[] hitColliders = Physics.OverlapSphere(transform.parent.position, radius);
int i = 0;
while (i < hitColliders.Length)
{
if (hitColliders[i].gameObject.tag.Contains(vars.attackable_tag) &&
hitColliders[i].gameObject.GetComponent <FlagScript>().Faction == targetFaction &&
!hitColliders[i].gameObject.GetComponent <FlagScript>().currentSkillFlags.ContainsKey(SkillResult.flag_movementspeedIncreased) &&
hitColliders[i].gameObject.GetComponent <HealthScript>().hasHealth)
{
if (hitColliders[i].gameObject.tag.Contains(vars.collector_ant_tag) ||
hitColliders[i].gameObject.tag.Contains(vars.scout_ant_tag))
{
SkillResult skillResult = new SkillResult();
skillResult.skillType = SkillResult.SkillType.Buff;
skillResult.skillAttribute = SkillResult.SkillAttribute.MovementSpeed;
skillResult.skillFlag = SkillResult.flag_movementspeedIncreased;
skillResult.skillFlagTimer = duration;
skillResult.skillPower = boost;
SkillCalculator.passSkillResult(transform.gameObject, hitColliders[i].gameObject, skillResult);
}
}
i++;
}
}
public void OnFire()
{
Collider[] hitColliders = Physics.OverlapSphere(transform.parent.position, radius);
int i = 0;
while (i < hitColliders.Length) {
if(hitColliders[i].gameObject.tag.Contains(vars.attackable_tag) &&
hitColliders[i].gameObject.GetComponent<FlagScript>().Faction == targetFaction &&
!hitColliders[i].gameObject.GetComponent<FlagScript>().currentSkillFlags.ContainsKey(SkillResult.flag_movementspeedIncreased) &&
hitColliders[i].gameObject.GetComponent<HealthScript>().hasHealth) {
if(hitColliders[i].gameObject.tag.Contains(vars.collector_ant_tag) ||
hitColliders[i].gameObject.tag.Contains(vars.scout_ant_tag)) {
SkillResult skillResult = new SkillResult();
skillResult.skillType = SkillResult.SkillType.Buff;
skillResult.skillAttribute = SkillResult.SkillAttribute.MovementSpeed;
skillResult.skillFlag = SkillResult.flag_movementspeedIncreased;
skillResult.skillFlagTimer = duration;
skillResult.skillPower = boost;
SkillCalculator.passSkillResult(transform.gameObject, hitColliders[i].gameObject, skillResult);
}
}
i++;
}
}
internal SkillResult Cast(BattleContext context)
{
SkillResult result = this.CanCast(context);
if (result == SkillResult.Ok)
{
this.castingTime = 0;
this.skillTime = 0;
this.cd = this.Define.CD;
this.Context = context;
this.Hit = 0;
this.Bullets.Clear();
this.AddBuff(TriggerType.SkillCast, this.Context.Target);
if (this.Instant)
{
this.DoHit();
}
else
{
if (this.Define.CastTime > 0)
{
this.Status = SkillStatus.Casting;
}
else
{
this.Status = SkillStatus.Running;
}
}
}
Log.InfoFormat("Skill[{0}].Cast Result:[{1}] Status:{2}", this.Define.Name, result, this.Status);
return(result);
}
public void OnFire()
{
Collider[] hitColliders = Physics.OverlapSphere(transform.parent.position, attackRadius);
int i = 0;
while (i < hitColliders.Length)
{
if (hitColliders[i].gameObject.tag.Contains(vars.attackable_tag) &&
hitColliders[i].gameObject.GetComponent <FlagScript>().Faction == targetFaction &&
hitColliders[i].gameObject.GetComponent <HealthScript>().hasHealth)
{
laser.target = hitColliders[i].gameObject;
laser.emitOnce();
Debug.Log("FOUND TARGET");
SkillResult skillResult = new SkillResult();
skillResult.skillType = SkillResult.SkillType.Damage;
skillResult.skillPower = attackPower;
SkillCalculator.passSkillResult(transform.gameObject, hitColliders[i].gameObject, skillResult);
break;
}
i++;
}
}
public void attackCurrentTarget()
{
if (unitScript.unitTargetScript.attackTarget == null)
{
return;
}
SkillResult skillResult = new SkillResult();
GameObject weaponTarget = unitScript.unitTargetScript.attackTarget.gameObject;
if (weaponTarget == previousTarget)
{
numHitsOnCurrentTarget++;
}
else
{
numHitsOnCurrentTarget = 0;
previousTarget = weaponTarget;
}
skillResult.skillType = SkillResult.SkillType.Damage;
skillResult.skillPower = unitScript.attributeScript.CurrentAttackDamage;
if (unitScript.unitTargetScript.attackTarget != null)
{
SkillCalculator.passSkillResult(transform.gameObject, unitScript.unitTargetScript.attackTarget.gameObject, skillResult);
}
}
public IEnumerable <Tera.Game.Skill> SkillsIdBySource(UserEntity source, Entity target, bool timed)
{
IEnumerable <Tera.Game.Skill> result;
if (timed || target == null)
{
result = from skills in SourceTargetSkill[source.Id].Values
from skill in skills
select
SkillResult.GetSkill(source.Id, skill.Pet, skill.SkillId, skill.HotDot,
NetworkController.Instance.EntityTracker, BasicTeraData.Instance.SkillDatabase,
BasicTeraData.Instance.HotDotDatabase, BasicTeraData.Instance.PetSkillDatabase);
return(result.Distinct());
}
result = from skills in SourceTargetSkill[source.Id][target.Id]
select
SkillResult.GetSkill(source.Id, skills.Pet, skills.SkillId, skills.HotDot,
NetworkController.Instance.EntityTracker, BasicTeraData.Instance.SkillDatabase,
BasicTeraData.Instance.HotDotDatabase, BasicTeraData.Instance.PetSkillDatabase);
return(result.Distinct());
}
internal S_EACH_SKILL_RESULT(Tera.Game.Messages.EachSkillResultServerMessage message)
{
NetworkController.Instance.EntityTracker.Update(message);
var skillResult = new SkillResult(message, NetworkController.Instance.EntityTracker, NetworkController.Instance.PlayerTracker,
BasicTeraData.Instance.SkillDatabase, BasicTeraData.Instance.PetSkillDatabase, NetworkController.Instance.AbnormalityTracker);
DamageTracker.Instance.Update(skillResult);
NotifyProcessor.Instance.UpdateMeterBoss(message);
}
internal S_EACH_SKILL_RESULT(Tera.Game.Messages.EachSkillResultServerMessage message)
{
NetworkController.Instance.EntityTracker.Update(message);
var skillResult = new SkillResult(message, NetworkController.Instance.EntityTracker, NetworkController.Instance.PlayerTracker,
BasicTeraData.Instance.SkillDatabase, BasicTeraData.Instance.PetSkillDatabase, NetworkController.Instance.AbnormalityTracker);
DamageTracker.Instance.Update(skillResult);
NotifyProcessor.Instance.UpdateMeterBoss(message);
}
public SkillResult ApplySkill(Skill skill, Character target)
{
if (Stats.ActionPoints < skill.ActionPoints)
{
return(new SkillResult
{
IsSuccess = false,
Comment = "Not enough action points."
});
}
if (Stats.Mana < skill.ManaConsumption)
{
return(new SkillResult
{
IsSuccess = false,
Comment = "Not enough mana."
});
}
var result = new SkillResult
{
IsSuccess = true,
};
switch (skill.SkillType)
{
case SkillType.Melee:
result.Damage = skill.BasePower * (Stats.Strength / 2);
target.Stats.Health -= skill.BasePower * (Stats.Strength / 2);
break;
case SkillType.Heal:
result.Damage = -(skill.BasePower * (Stats.Intelligence / 2));
target.Stats.Health += -(skill.BasePower * (Stats.Intelligence / 2));
break;
case SkillType.Projectile:
result.Damage = skill.BasePower * (Stats.Intelligence);
target.Stats.Health -= skill.BasePower * (Stats.Intelligence);
break;
case SkillType.AreaOfEffect:
result.Damage = skill.BasePower * (Stats.Intelligence / 3);
target.Stats.Health -= skill.BasePower * (Stats.Intelligence / 3);
break;
default:
throw new ArgumentOutOfRangeException();
}
Stats.Mana -= skill.ManaConsumption;
Stats.ActionPoints -= skill.ActionPoints;
return(result);
}
internal S_EACH_SKILL_RESULT(EachSkillResultServerMessage message)
{
PacketProcessor.Instance.EntityTracker.Update(message);
var skillResult = new SkillResult(message, PacketProcessor.Instance.EntityTracker, PacketProcessor.Instance.PlayerTracker,
BasicTeraData.Instance.SkillDatabase, BasicTeraData.Instance.PetSkillDatabase, PacketProcessor.Instance.AbnormalityTracker);
DamageTracker.Instance.Update(skillResult);
RichPresence.Instance.EachSkillResult(skillResult);
NotifyProcessor.Instance.UpdateMeterBoss(message);
}
//public bool visited;
//public float distance;
//public int ancestor;
//public bool tagged;
public void OnSkillResult(SkillResult skillResult)
{
if (skillResult.skillType == SkillResult.SkillType.Buff)
{
if (skillResult.skillAttribute == SkillResult.SkillAttribute.WPVision)
{
GetComponent <FogOfWarCircleRevealer>().increaseRange(skillResult.skillPower);
}
}
}
public override SkillResult GenerateResultToTarget(CharacterData inSource, CharacterData inTarget)
{
SkillResult result = PoolManager.poolSkillResults.GetNext();
result.Init(this, inSource, inTarget);
result.statChanges.Set(Stat.hp, -CalcHpChange(inSource, inTarget));
return(result);
}
private static string GenDamage(SkillResult skillResult)
{
if (skillResult.IsMiss)
{
return("Miss");
}
string critical = skillResult.IsCritical ? "Critical! " : "";
return($"{critical}cause <color=\"red\">{skillResult.Damage}</color> damage.");
}
void OnUnFire()
{
SkillResult skillResult = new SkillResult();
skillResult.skillAttribute = skillAttribute;
skillResult.skillType = SkillResult.SkillType.Buff;
skillResult.skillPower = -skillPower;
skillResult.skillFlag = skillResult.skillType.ToString() + "" + skillAttribute.ToString();
SkillCalculator.passSkillResult(this.gameObject, skill.skillTarget, skillResult);
}
void OnUnFire()
{
SkillResult skillResult = new SkillResult();
skillResult.skillAttribute = skillAttribute;
skillResult.skillType = SkillResult.SkillType.Buff;
skillResult.skillPower = -skillPower;
skillResult.skillFlag = skillResult.skillType.ToString()+""+skillAttribute.ToString();
SkillCalculator.passSkillResult(this.gameObject, skill.skillTarget, skillResult);
}
private PlayerInfo GetOrCreate(SkillResult skillResult)
{
NpcEntity npctarget = skillResult.Target as NpcEntity;
//ignore pvp if onlybosses is ticked
if (OnlyBosses && npctarget == null && IsValidAttack(skillResult))
{
return(null);
}
if (npctarget != null)
{
if (OnlyBosses)//not count bosses
{
if (!npctarget.Info.Boss)
{
return(null);
}
}
if (IgnoreOneshots)
{
if ((npctarget.Info.HP > 0)
//ignore damage that is more than 10x times than mob's hp
&& (npctarget.Info.HP <= skillResult.Damage / 10
//ignore damage over 100m on a boss
|| (npctarget.Info.Boss && skillResult.Damage > 99999999)))
{
return(null);
}
}
}
var player = skillResult.SourcePlayer;
PlayerInfo playerStats = StatsByUser.FirstOrDefault(pi => pi.Player.Equals(player));
if (playerStats == null && (IsFromHealer(skillResult) || //either healer
(!IsFromHealer(skillResult) && IsValidAttack(skillResult)))) //or damage from non-healer
{
playerStats = new PlayerInfo(player, this);
StatsByUser.Add(playerStats);
}
//update primary target if it's a mob
if (npctarget != null)
{
if (!_targetHitCount.ContainsKey(npctarget))
{
_targetHitCount.Add(npctarget, 0);
}
_targetHitCount[npctarget]++;
PrimaryTarget = _targetHitCount.Aggregate((l, r) => l.Value > r.Value ? l : r).Key;
}
return(playerStats);
}
void OnSkillResult(SkillResult skillresult)
{
if (skillresult.skillType == SkillResult.SkillType.Damage)
{
float removedFromShield = 0;
if (CurrentShield > 0)
{
removedFromShield = Mathf.Abs(CurrentShield - skillresult.skillPower);
if (shieldObject != null)
{
shieldObject.SetActive(true);
currentShieldCooldown = 3.0f;
}
}
CurrentHealth = Mathf.Clamp(CurrentHealth - (skillresult.skillPower - removedFromShield), -1.0f, BaseHealth);
if (unitScript != null)
{
unitScript.setIsInFight(true);
}
}
else if (skillresult.skillType == SkillResult.SkillType.Heal)
{
CurrentHealth = Mathf.Clamp(CurrentHealth + skillresult.skillPower, -1.0f, BaseHealth);
}
else if (skillresult.skillType == SkillResult.SkillType.Buff)
{
if (skillresult.skillAttribute == SkillResult.SkillAttribute.Shield)
{
BaseShield += skillresult.skillPower;
CurrentShield = BaseShield;
}
if (skillresult.skillAttribute == SkillResult.SkillAttribute.Health)
{
BaseHealth += skillresult.skillPower;
CurrentHealth = BaseHealth;
}
}
if (skillresult.skillFlag != "")
{
if (!unitScript.flagScript.currentSkillFlags.ContainsKey(skillresult.skillFlag))
{
unitScript.flagScript.currentSkillFlags.Add(skillresult.skillFlag, skillresult.skillFlagTimer);
}
}
checkDeath();
}
public override SkillResult GenerateResultToTarget(CharacterData inSource, CharacterData inTarget)
{
SkillResult result = PoolManager.poolSkillResults.GetNext();
result.Init(this, inSource, inTarget);
//strike deals attack damage directly
result.statChanges.Set(Stat.hp, -CalcHpChange(inSource, inTarget));
result.ApplyStatusEffectsBasedOnStats(inSource.stats);
return(result);
}
public SkillResult Copy()
{
SkillResult copy = new SkillResult();
copy.Skill = Skill;
copy.ArtInfo = ArtInfo;
copy.Current = Current;
copy.HasHit = HasHit;
copy.HasZeroHealth = HasZeroHealth;
copy.AppliedEffects = new List <Effect>(AppliedEffects);
copy.SkillEntries = new List <SkillResultEntry>(SkillEntries);
return(copy);
}
public void OnSkillHit(SkillResult skillResult)
{
if (skillResult.IsMiss)
{
Debug.Log("Miss");
return;
}
if (skillResult.IsCritical)
{
Debug.Log("Critical");
}
AddHp(-skillResult.Damage);
}
void OnSkillResult(SkillResult skillResult)
{
if (skillResult.skillType == SkillResult.SkillType.Buff)
{
switch (skillResult.skillAttribute)
{
case SkillResult.SkillAttribute.AttackRange: {
CurrentAttackRange += skillResult.skillPower;
break;
}
case SkillResult.SkillAttribute.AttackDamage: {
CurrentAttackDamage += skillResult.skillPower;
break;
}
case SkillResult.SkillAttribute.AttackSpeed: {
CurrentAttackSpeed += skillResult.skillPower;
break;
}
case SkillResult.SkillAttribute.HealthRegeneration: {
CurrentHealthRegeneration += skillResult.skillPower;
break;
}
case SkillResult.SkillAttribute.ShieldRegenration: {
CurrentShieldRegeneration += skillResult.skillPower;
break;
}
case SkillResult.SkillAttribute.VisionRange: {
CurrentVisionRange += skillResult.skillPower;
break;
}
case SkillResult.SkillAttribute.MovementSpeed: {
CurrentMovementSpeed += skillResult.skillPower;
unitScript.navMeshAgent.speed = CurrentMovementSpeed;
if (skillResult.skillFlag != "")
{
if (!unitScript.flagScript.currentSkillFlags.ContainsKey(skillResult.skillFlag))
{
unitScript.flagScript.currentSkillFlags.Add(skillResult.skillFlag, skillResult.skillFlagTimer);
}
}
break;
}
}
}
}
private static string AggregatedSkillName(this SkillResult skillResult, AggregationType type)
{
switch (type)
{
case AggregationType.Id:
return(skillResult.SkillNameDetailed);
case AggregationType.Name:
return(skillResult.SkillShortName);
default:
return(string.Empty);
}
}
//public GameObject res_c_model_complete;
//public GameObject res_c_model_bitten;
public void OnSkillResult(SkillResult skillResult)
{
if(skillResult.skillType == SkillResult.SkillType.Buff) {
if(skillResult.skillAttribute == SkillResult.SkillAttribute.RessourceAbbauzeit) {
res.harvesting_time -= skillResult.skillPower;
}
if(skillResult.skillAttribute == SkillResult.SkillAttribute.RessourceMenge) {
res.max_harvest += skillResult.skillPower;
res.current_harvest_amount += skillResult.skillPower;
}
if(skillResult.skillAttribute == SkillResult.SkillAttribute.RessourceMenge) {
res.ant_bite_decrease += skillResult.skillPower;
}
}
}
public IEnumerable <KeyValuePair <Entity, Tera.Game.Skill> > SkillsIdByTarget(Entity target)
{
if (!TargetSourceSkill.ContainsKey(target))
{
return(new List <KeyValuePair <Entity, Tera.Game.Skill> >());
}
var result = from skills in TargetSourceSkill[target].Values
from skill in skills
select new KeyValuePair <Entity, Tera.Game.Skill>(skill.Source,
SkillResult.GetSkill(skill.Source, skill.Pet, skill.SkillId, skill.HotDot, PacketProcessor.Instance.EntityTracker,
BasicTeraData.Instance.SkillDatabase, BasicTeraData.Instance.HotDotDatabase, BasicTeraData.Instance.PetSkillDatabase));
return(result.Where(x => x.Value != null).Distinct());
}
public static void ProcessSkill(ReqCastSkill msg)
{
Entity caster = EntityManager.Instance.Find(msg.caster);
if (caster == null)
{
Log.Error("找不到技能释放者! id = " + msg.caster);
return;
}
CSVSkill skillInfo = CSVManager.GetSkillCfg(msg.skillID);
if (skillInfo == null)
{
Log.Error("找不到技能配置 skillid = " + msg.skillID);
return;
}
List <Entity> targets = GetTargets(msg, skillInfo);
if (targets == null)
{
return;
}
List <SkillResult> result = null;
for (int i = 0; i < targets.Count; i++)
{
SkillResult sr = new SkillResult();
sr.target = msg.target;
if (skillInfo.type == 1) //普攻
{
sr.damage = caster.Property.PhysicDamage - targets[i].Property.PhysicDefence;
}
else if (skillInfo.type == 2) //物理技能攻击
{
}
else if (skillInfo.type == 3) //法术技能攻击
{
}
result.Add(sr);
}
OnCastSkill rsp = new OnCastSkill();
rsp.result = result;
caster.OnEvent(eEntityEvent.OnSkillResult, rsp);
}
public void attackCurrentTarget()
{
SkillResult skillResult = new SkillResult();
GameObject weaponTarget = unitScript.unitTargetScript.attackTarget.gameObject;
if(weaponTarget == previousTarget) {
numHitsOnCurrentTarget++;
} else {
numHitsOnCurrentTarget = 0;
previousTarget = weaponTarget;
}
skillResult.skillType = SkillResult.SkillType.Damage;
skillResult.skillPower = unitScript.attributeScript.CurrentAttackDamage;
if(unitScript.unitTargetScript.attackTarget != null) {
SkillCalculator.passSkillResult(transform.gameObject, unitScript.unitTargetScript.attackTarget.gameObject, skillResult);
}
}
virtual public void OnTakeSkillResult(SkillResult result)
{
if (result.skillType == SkillResult.SkillType.Heal)
{
unitCurrentHealth = Mathf.Clamp(unitCurrentHealth + result.skillPower, 0, unitBaseHealth);
}
if (result.skillType == SkillResult.SkillType.Damage)
{
unitCurrentHealth = Mathf.Clamp(unitCurrentHealth - result.skillPower, 0, unitBaseHealth);
}
if (!currentSkillFlags.ContainsKey(result.skillFlag))
{
currentSkillFlags.Add(result.skillFlag, result.skillFlagTimer);
}
checkForDeath();
}
public void update(float elapsed)
{
while (this.combatRequests.Count > 0)
{
CombatRequest request = getFirst();
if (request.Skill != null)
{
SkillResult skillResult = request.Skill.perform(request.Source.Range);
if (skillResult != null)
{
foreach (var target in request.Targets)
{
if (target != null)
{
if (request.Source != null)
{
// can we see the target?
target.damage(skillResult.Damage);
// did we kill the target?
if (target.AmIDead)
{
removeRequests(target);
// if we had a death effect it needs to go to the front of the list of actions and apply against all targets in the area
Skill deathEffect = target.die();
if (deathEffect != null)
{
List <Character> charactersInRange = target.CharactersInRange.Invoke(target);
this.combatRequests.Insert(0, new CombatRequest()
{
Skill = deathEffect,
Source = target,
Targets = charactersInRange
});
}
}
}
}
}
}
}
}
}
//public GameObject res_c_model_complete;
//public GameObject res_c_model_bitten;
public void OnSkillResult(SkillResult skillResult)
{
if (skillResult.skillType == SkillResult.SkillType.Buff)
{
if (skillResult.skillAttribute == SkillResult.SkillAttribute.RessourceAbbauzeit)
{
res.harvesting_time -= skillResult.skillPower;
}
if (skillResult.skillAttribute == SkillResult.SkillAttribute.RessourceMenge)
{
res.max_harvest += skillResult.skillPower;
res.current_harvest_amount += skillResult.skillPower;
}
if (skillResult.skillAttribute == SkillResult.SkillAttribute.RessourceMenge)
{
res.ant_bite_decrease += skillResult.skillPower;
}
}
}
void OnSkillResult(SkillResult skillresult)
{
if(skillresult.skillType == SkillResult.SkillType.Damage) {
float removedFromShield = 0;
if(CurrentShield > 0) {
removedFromShield = Mathf.Abs(CurrentShield - skillresult.skillPower);
if(shieldObject != null) {
shieldObject.SetActive(true);
currentShieldCooldown = 3.0f;
}
}
CurrentHealth = Mathf.Clamp(CurrentHealth - (skillresult.skillPower - removedFromShield), -1.0f, BaseHealth);
if(unitScript != null) {
unitScript.setIsInFight(true);
}
}
else if(skillresult.skillType == SkillResult.SkillType.Heal) {
CurrentHealth = Mathf.Clamp(CurrentHealth + skillresult.skillPower, -1.0f, BaseHealth);
}
else if(skillresult.skillType == SkillResult.SkillType.Buff) {
if(skillresult.skillAttribute == SkillResult.SkillAttribute.Shield) {
BaseShield += skillresult.skillPower;
CurrentShield = BaseShield;
}
if(skillresult.skillAttribute == SkillResult.SkillAttribute.Health) {
BaseHealth += skillresult.skillPower;
CurrentHealth = BaseHealth;
}
}
if(skillresult.skillFlag != "") {
if(!unitScript.flagScript.currentSkillFlags.ContainsKey(skillresult.skillFlag)) {
unitScript.flagScript.currentSkillFlags.Add(skillresult.skillFlag, skillresult.skillFlagTimer);
}
}
checkDeath();
}
void OnSkillResult(SkillResult skillResult)
{
if(skillResult.skillType == SkillResult.SkillType.Buff) {
switch(skillResult.skillAttribute) {
case SkillResult.SkillAttribute.AttackRange: {
CurrentAttackRange += skillResult.skillPower;
break;
}
case SkillResult.SkillAttribute.AttackDamage: {
CurrentAttackDamage += skillResult.skillPower;
break;
}
case SkillResult.SkillAttribute.AttackSpeed: {
CurrentAttackSpeed += skillResult.skillPower;
break;
}
case SkillResult.SkillAttribute.HealthRegeneration: {
CurrentHealthRegeneration += skillResult.skillPower;
break;
}
case SkillResult.SkillAttribute.ShieldRegenration: {
CurrentShieldRegeneration += skillResult.skillPower;
break;
}
case SkillResult.SkillAttribute.VisionRange: {
CurrentVisionRange += skillResult.skillPower;
break;
}
case SkillResult.SkillAttribute.MovementSpeed: {
CurrentMovementSpeed += skillResult.skillPower;
unitScript.navMeshAgent.speed = CurrentMovementSpeed;
if(skillResult.skillFlag != "") {
if(!unitScript.flagScript.currentSkillFlags.ContainsKey(skillResult.skillFlag)) {
unitScript.flagScript.currentSkillFlags.Add(skillResult.skillFlag, skillResult.skillFlagTimer);
}
}
break;
}
}
}
}
public void Update(SkillResult skillResult)
{
if (skillResult.Source == null || skillResult.Target == null) return;
var entitySource = UserEntity.ForEntity(NetworkController.Instance.EntityTracker.GetOrPlaceholder(skillResult.Source.Id));
var entityTarget = GetActorEntity(skillResult.Target.Id);
if (skillResult.SourcePlayer == null && skillResult.TargetPlayer == null) return;
if (BasicTeraData.Instance.WindowData.PartyOnly &&
(skillResult.SourcePlayer == null ||
!NetworkController.Instance.PlayerTracker.MyParty(skillResult.SourcePlayer)) &&
(skillResult.TargetPlayer == null ||
!NetworkController.Instance.PlayerTracker.MyParty(skillResult.TargetPlayer))) return;
if (BasicTeraData.Instance.WindowData.OnlyBoss && !(((entityTarget as NpcEntity)?.Info.Boss ?? false) ||
(skillResult.SourcePlayer != null && skillResult.TargetPlayer != null) ||
((entitySource["root_source"] as NpcEntity)?.Info.Boss ?? false))) return;
if (entitySource["root_source"] is PlaceHolderEntity|| entityTarget == null)
{
return;
}
InsertSkill(entityTarget, entitySource["root_source"], entitySource["source"], skillResult);
}
public void OnFire()
{
Collider[] hitColliders = Physics.OverlapSphere(transform.parent.position, attackRadius);
int i = 0;
while (i < hitColliders.Length) {
if(hitColliders[i].gameObject.tag.Contains(vars.attackable_tag) &&
hitColliders[i].gameObject.GetComponent<FlagScript>().Faction == targetFaction &&
hitColliders[i].gameObject.GetComponent<HealthScript>().hasHealth) {
laser.target = hitColliders[i].gameObject;
laser.emitOnce();
Debug.Log ("FOUND TARGET");
SkillResult skillResult = new SkillResult();
skillResult.skillType = SkillResult.SkillType.Damage;
skillResult.skillPower = attackPower;
SkillCalculator.passSkillResult(transform.gameObject, hitColliders[i].gameObject, skillResult);
break;
}
i++;
}
}
public void OnFire()
{
Collider[] hitColliders = Physics.OverlapSphere(transform.parent.position, attackRadius);
int i = 0;
while (i < hitColliders.Length) {
Debug.Log ("HIT");
if(hitColliders[i].gameObject.tag.Contains(vars.attackable_tag) &&
hitColliders[i].gameObject.GetComponent<FlagScript>().Faction == targetFaction &&
!hitColliders[i].gameObject.GetComponent<FlagScript>().currentSkillFlags.ContainsKey(SkillResult.flag_movementspeedDecreased) &&
hitColliders[i].gameObject.GetComponent<HealthScript>().hasHealth) {
SkillResult skillResult = new SkillResult();
sporeEffect.emitOnce();
skillResult.skillType = SkillResult.SkillType.Debuff;
skillResult.skillAttribute = SkillResult.SkillAttribute.MovementSpeed;
skillResult.skillFlag = SkillResult.flag_movementspeedDecreased;
skillResult.skillFlagTimer = 1.0f;
skillResult.skillPower = attackPower;
SkillCalculator.passSkillResult(transform.gameObject, hitColliders[i].gameObject, skillResult);
}
i++;
}
}
private SkillStats StatsChange(SkillResult message)
{
var result = new SkillStats();
if (message.Amount == 0)
return result;
result.Damage = message.Damage;
result.Heal = message.Heal;
if (IsFromHealer(message) || (!IsFromHealer(message) && !message.IsHeal))
{
result.Hits++;
if (message.IsCritical)
result.Crits++;
}
return result;
}
//public bool visited;
//public float distance;
//public int ancestor;
//public bool tagged;
public void OnSkillResult(SkillResult skillResult)
{
if(skillResult.skillType == SkillResult.SkillType.Buff) {
if(skillResult.skillAttribute == SkillResult.SkillAttribute.WPVision) {
GetComponent<FogOfWarCircleRevealer>().increaseRange(skillResult.skillPower);
}
}
}
private void HandleMessageReceived(Message obj)
{
var message = _messageFactory.Create(obj);
if (DamageTracker.IsArchived)
{
var npcOccupier = message as SNpcOccupierInfo;
if (npcOccupier != null)
{
Entity ent = _entityTracker.GetOrPlaceholder(npcOccupier.NPC);
if (ent is NpcEntity)
{
var npce = ent as NpcEntity;
if (npce.Info.Boss && npcOccupier.Target != EntityId.Empty)
{
CasualMessenger.Instance.ResetPlayerStats(true); //Stop viewing saved encounter on boss aggro
}
}
return;
}
}
_entityTracker?.Update(message);
var skillResultMessage = message as EachSkillResultServerMessage;
if (skillResultMessage != null)
{
if (skillResultMessage.IsValid(DamageTracker))
{
var skillResult = new SkillResult(skillResultMessage, _entityTracker, _playerTracker, _teraData.SkillDatabase, null, _abnormalityTracker);
CheckUpdate(skillResult);
}
return;
}
_playerTracker?.UpdateParty(message);
_abnormalityTracker?.Update(message);
var despawnNpc = message as SDespawnNpc;
if (despawnNpc != null)
{
Entity ent = _entityTracker.GetOrPlaceholder(despawnNpc.Npc);
if (ent is NpcEntity)
{
var npce = ent as NpcEntity;
if (npce.Info.Boss && despawnNpc.Dead && !DamageTracker.IsArchived)
{ //no need to do something if we didn't count any skill against this boss
if (DamageTracker.StatsByUser.SelectMany(x => x.SkillLog).Any(x => x.Target == npce))
{
DamageTracker.PrimaryTarget = npce; //Name encounter with the last dead boss
DamageTracker.IsPrimaryTargetDead = despawnNpc.Dead;
//determine type
ExportType exportType = ExportType.None;
if (SettingsHelper.Instance.Settings.ExcelExport)
exportType = exportType | ExportType.Excel;
if (SettingsHelper.Instance.Settings.SiteExport)
exportType = exportType | ExportType.Upload;
if (exportType != ExportType.None)
DataExporter.ToTeraDpsApi(exportType, DamageTracker, _teraData);
if (AutosaveEncounters)
ResetDamageTracker(new ResetPlayerStatsMessage { ShouldSaveCurrent = true });
}
}
}
return;
}
var sLogin = message as LoginServerMessage;
if (sLogin != null)
{
if (_needInit)
{
Server = BasicTeraData.Servers.GetServer(sLogin.ServerId, Server);
_messageFactory.Version = Server.Region;
Logger.Info($"Logged in to server {Server.Name}.");
_teraData = BasicTeraData.DataForRegion(Server.Region);
_entityTracker = new EntityTracker(_teraData.NpcDatabase);
_playerTracker = new PlayerTracker(_entityTracker, BasicTeraData.Servers);
_abnormalityTracker = new AbnormalityTracker(_entityTracker, _playerTracker, _teraData.HotDotDatabase, _abnormalityStorage, CheckUpdate);
_entityTracker.Update(message);
_needInit = false;
}
_abnormalityStorage.EndAll(message.Time.Ticks);
_abnormalityTracker = new AbnormalityTracker(_entityTracker, _playerTracker, _teraData.HotDotDatabase, _abnormalityStorage, CheckUpdate);
return;
}
var cVersion = message as C_CHECK_VERSION;
if (cVersion != null)
{
var opCodeNamer =
new OpCodeNamer(Path.Combine(BasicTeraData.ResourceDirectory,
$"opcodes/{cVersion.Versions[0]}.txt"));
_messageFactory = new MessageFactory(opCodeNamer, Server.Region);
return;
}
}
private void CheckUpdate(SkillResult skillResult)
{
if (PartyOnly &&//check if party only
!(_playerTracker.MyParty(skillResult.SourcePlayer) || _playerTracker.MyParty(skillResult.TargetPlayer)))
return;
if (IsInactiveTimerReached() && skillResult.IsValid())
{
CasualMessenger.Instance.ResetPlayerStats(AutosaveEncounters || DamageTracker.IsArchived);
}
if (!DamageTracker.IsArchived && skillResult.IsValid(DamageTracker?.FirstAttack)) //don't process while viewing a past encounter
{
DamageTracker.Update(skillResult);
if (!skillResult.IsHeal && skillResult.Amount > 0)
_inactivityTimer.Restart();
PlayerCount = DamageTracker.StatsByUser.Count;
}
}
public void passSkillResultToGroup(SkillResult skillResult, GameObject attacker)
{
if(skillResult.skillType == SkillResult.SkillType.Buff) {
if(!currentSkillFlags.ContainsKey(skillResult.skillFlag)) {
currentSkillFlags.Add(skillResult.skillFlag, skillResult.skillFlagTimer);
}
for(int i = 0; i < unitsInGroup.Count; i++) {
SkillCalculator.passSkillResult(attacker, unitsInGroup[i], skillResult);
}
return;
}
else if(skillResult.skillType == SkillResult.SkillType.RemoveBuff) {
if(currentSkillFlags.ContainsKey(skillResult.skillFlag)) {
currentSkillFlags.Remove(skillResult.skillFlag);
}
for(int i = 0; i < unitsInGroup.Count; i++) {
SkillCalculator.passSkillResult(attacker, unitsInGroup[i], skillResult);
}
return;
}
for(int i = 0; i < unitsInGroup.Count; i++) {
SkillCalculator.passSkillResult(attacker, unitsInGroup[i], skillResult);
}
return;
}
public bool IsFromHealer(SkillResult skillResult)
{
return skillResult.SourcePlayer.IsHealer;
}
public bool IsValidAttack(SkillResult skillResult)
{
return skillResult.SourcePlayer != null && skillResult.Damage > 0 &&
skillResult.Source.Id != skillResult.Target.Id;
}
private void InsertSkill(Entity entityTarget, Entity entitySource, Entity petSource, SkillResult message)
{
if (!IsValidSkill(message))
{
return;
}
var skillType = Database.Database.Type.Mana;
if (message.IsHp)
{
skillType = message.IsHeal ? Database.Database.Type.Heal : Database.Database.Type.Damage;
}
var entity = entityTarget as NpcEntity;
if (entity != null)
{
/*
* Remove data from resetted boss when hitting a new boss
* (we don't remove the data directly when the boss reset, to let the time for a review of the encounter.)
*/
if (skillType == Database.Database.Type.Damage && entity.Info.Boss)
{
foreach (var delete in _toDelete)
{
DeleteEntity(delete);
}
_toDelete = new List<Entity>();
}
UpdateCurrentBoss(entity);
}
Database.Database.Instance.Insert(message.Amount, skillType, entityTarget, entitySource, message.SkillId,
message.Abnormality, message.IsCritical, message.Time.Ticks, petSource, message.HitDirection);
}
private static bool IsValidSkill(SkillResult message)
{
if (message.Amount == 0)
// to count buff skills/consumable usage - need additional hitstat for it (damage/heal/mana/uses)
{
return false;
}
return (UserEntity.ForEntity(message.Source)["root_source"] != UserEntity.ForEntity(message.Target)["root_source"]) || (message.Damage == 0);
}
public static bool IsSameSkillAs(this SkillResult skillResult, SkillResult other, AggregationType type)
{
return skillResult.AggregatedSkillName(type) == other.AggregatedSkillName(type) &&
skillResult.IsHeal == other.IsHeal;
}
public static void passSkillResult(GameObject attacker, GameObject target, SkillResult skillResult)
{
if(target != null) {
target.SendMessage("OnSkillResult", skillResult, SendMessageOptions.DontRequireReceiver);
}
}
public virtual void OnTakeSkillResult(SkillResult result)
{
if(result.skillType == SkillResult.SkillType.Heal) {
unitCurrentHealth = Mathf.Clamp(unitCurrentHealth + result.skillPower, 0, unitBaseHealth);
}
if(result.skillType == SkillResult.SkillType.Damage) {
unitCurrentHealth = Mathf.Clamp(unitCurrentHealth - result.skillPower, 0, unitBaseHealth);
}
if(!currentSkillFlags.ContainsKey(result.skillFlag)) {
currentSkillFlags.Add(result.skillFlag, result.skillFlagTimer);
}
checkForDeath();
}
private PlayerInfo GetOrCreate(SkillResult skillResult)
{
NpcEntity npctarget = skillResult.Target as NpcEntity;
//ignore pvp if onlybosses is ticked
if (OnlyBosses && npctarget == null && IsValidAttack(skillResult)) return null;
if (npctarget != null)
{
if (OnlyBosses)//not count bosses
if (!npctarget.Info.Boss)
return null;
if (IgnoreOneshots)
if ((npctarget.Info.HP>0)
//ignore damage that is more than 10x times than mob's hp
&& ( npctarget.Info.HP <= skillResult.Damage/10
//ignore damage over 100m on a boss
|| (npctarget.Info.Boss && skillResult.Damage > 99999999)))
return null;
}
var player = skillResult.SourcePlayer;
PlayerInfo playerStats = StatsByUser.FirstOrDefault(pi => pi.Player.Equals(player));
if (playerStats == null && (IsFromHealer(skillResult) ||//either healer
(!IsFromHealer(skillResult) && IsValidAttack(skillResult))))//or damage from non-healer
{
playerStats = new PlayerInfo(player, this);
StatsByUser.Add(playerStats);
}
//update primary target if it's a mob
if (npctarget != null)
{
if (!_targetHitCount.ContainsKey(npctarget))
_targetHitCount.Add(npctarget, 0);
_targetHitCount[npctarget]++;
PrimaryTarget = _targetHitCount.Aggregate((l, r) => l.Value > r.Value ? l : r).Key;
}
return playerStats;
}
public void Update(SkillResult skillResult)
{
if (IsArchived) return;//prevent archived trackers from accidentally recording stats
if (skillResult.SourcePlayer != null)
{
var playerStats = GetOrCreate(skillResult);
if (playerStats == null) return; //if this is null, that means we should ignore it
var statsChange = StatsChange(skillResult);
if (statsChange == null) Logger.Warn($"Generated null SkillStats from {skillResult}");
playerStats.LogSkillUsage(skillResult);
TotalDealt.Add(statsChange);
playerStats.Dealt.Add(statsChange);
}
if (IsValidAttack(skillResult))
{
if (FirstAttack == null)
FirstAttack = skillResult.Time;
LastAttack = skillResult.Time;
}
foreach (var playerStat in StatsByUser)
{ //force update of calculated dps metrics
playerStat.Dealt.UpdateStats();
}
}
public void LogSkillUsage(SkillResult result)
{
SkillLog.Add(result);
}
