public void OnSkillEnter(int skillID)
{
if (skillID > 0 &&
_owner.ACGetCurrentAttack() != null &&
_owner.ACGetCurrentAttack()._energyCost != 0)
{
LevelManager.Singleton.TotalCounter[skillID + (int)LevelManager.VarNeedCount.SKILL_1_ENG_COST] = _energyCost;
}
if (_owner.AIUse.CurrentSkill.CoolDownTimeMax > _skillTime[skillID] + 0.1f &&
LevelManager.Singleton.TotalCounter[skillID + (int)LevelManager.VarNeedCount.SKILL_1_UES_TIMES] > 0)
{
Debug.LogError("This may be a JB client");
if (_skillTime[skillID] < _skillMinTime[skillID])
{
_skillMinTime[skillID] = _skillTime[skillID];
LevelManager.Singleton.TotalCounter[skillID + (int)LevelManager.VarNeedCount.SKILL_1_CD_MIN_TIME] = (int)(_skillMinTime[skillID] * 100);
}
}
LevelManager.Singleton.TotalCounter[skillID + (int)LevelManager.VarNeedCount.SKILL_1_UES_TIMES]++;
}
public Eot[] GetEots(DefenseInfo di)
{
if (_owner.ACGetCurrentAttack() != null)
{
foreach (Eot eot in _owner.ACGetCurrentAttack()._eots)
{
switch (eot.eotType)
{
case Eot.EOT_TYPE.EOT_PHYSICAL:
eot.OwnerDamage = _attackInfo._attackPoints[0] - di._defensePoints[0];
break;
case Eot.EOT_TYPE.EOT_FIRE:
eot.OwnerDamage = _attackInfo._attackPoints[1] - di._defensePoints[1];
break;
case Eot.EOT_TYPE.EOT_ICE:
eot.OwnerDamage = _attackInfo._attackPoints[1] - di._defensePoints[1];
break;
case Eot.EOT_TYPE.EOT_THUNDER:
eot.OwnerDamage = _attackInfo._attackPoints[1] - di._defensePoints[1];
break;
case Eot.EOT_TYPE.EOT_POISON:
eot.OwnerDamage = _attackInfo._attackPoints[1] - di._defensePoints[1];
break;
default:
eot.OwnerDamage = _attackInfo._attackPoints[0] - di._defensePoints[0];
break;
}
}
return(_owner.ACGetCurrentAttack()._eots);
}
return(null);
}
//must not be override by any other child class
public void Fire(ActionController target, Transform firePoint, int angleOffset, int angleOffsetY, float lifeTime, RangerAgent.FirePort rfp)
{
_isDead = false;
_attackInfo._isFromSkill = rfp.IsFromSkill;
_lifeTime = lifeTime;
_deadTime = -1;
_target = target;
_isFrom2P = _owner.IsClientPlayer;
ThisObject.layer = (int)_faction + 1;
_firePoint = firePoint;
_step = 0;
_attackInfo._attackPoints = _owner.TotalAttackPoints;
_attackInfo._criticalChance = _owner.Data.TotalCritRate;
_attackInfo._criticalDamage = _owner.Data.TotalCritDamage;
_attackInfo._skillTriggerChance = _owner.Data.TotalSkillTriggerRate;
_attackInfo._skillAttackDamage = _owner.Data.TotalSkillAttackDamage;
_attackInfo._pushStrength = _pushStrength;
_attackInfo._pushTime = _pushTime;
_attackInfo._pushAngle = _pushAngle;
_attackInfo._pushByPoint = _pushByPoint;
RangerAgent.FireRangeInfo fri = rfp._rangeInfo;
if (angleOffsetY != 0)
{
_enableSpeedY = true;
_fireAngleY = angleOffsetY;
}
if (fri != null)
{
_attackInfo._effectTime = fri._effectTime;
}
//_damageScale = rfp.DamageScale;
if (!_owner.IsPlayer && _owner.ACGetCurrentAttack() != null)
{
_attackInfo._damageScale = _damageScale * _owner.ACGetCurrentAttack().DamageScale;
}
else
{
_attackInfo._damageScale = _damageScale * rfp.DamageScale;
}
if (_firePorts != null && _firePorts.Length != 0)
{
foreach (RangerAgent.FirePort pt in _firePorts)
{
pt.IsFromSkill = rfp.IsFromSkill;
pt.DamageScale = _attackInfo._damageScale;
}
}
ThisTransform.localPosition = firePoint.position;
if (rfp._shootByFirePointDirection)
{
ThisTransform.forward = firePoint.forward;
}
else if (target != null)
{
if (target.ThisTransform.localPosition != ThisTransform.localPosition)
{
Vector3 d3 = target.ThisTransform.localPosition - ThisTransform.localPosition;
d3.y = 0;
ThisTransform.forward = d3;
}
else
{
ThisTransform.forward = _owner.ThisTransform.forward;
}
}
else
{
ThisTransform.forward = _owner.ThisTransform.forward;
}
if (angleOffset != 65535)
{
ThisTransform.Rotate(new Vector3(0, angleOffset, 0));
}
if (rfp.IsOverride && _hitInfo != null && _hitInfo.Length > 0)
{
foreach (Eot eot in _hitInfo[_step]._eots)
{
eot.lastTime = rfp.DotDamageTime;
}
}
//add record to remeber ther port name
// for if some one want to kill bullet
_firePortName = rfp._portName;
ActiveLogic(rfp);
}
public override bool HandleHitByTarget(ActionController ac, bool isBullet)
{
bool ret = false;
Vector3 dir = ac.ThisTransform.localPosition - _owner.ACOwner.ThisTransform.localPosition;
dir.y = 0;
if ((ac.ACGetCurrentAttack() != null && ac.ACGetCurrentAttack()._ignoredParry))
{
_owner.ClearActionSwitchFlag(FC_ACTION_SWITCH_FLAG.IN_RIGIDBODY2);
}
else if (_owner.IsOnParry == FC_PARRY_EFFECT.PARRY ||
_owner.IsOnParry == FC_PARRY_EFFECT.PARRY_BULLET_FAIL ||
_owner.IsOnParry == FC_PARRY_EFFECT.SUCCESS)
{
ret = true;
}
else if (_currentState == AttackBase.ATTACK_STATE.STEP_1 &&
_canParry && _parrySuccessCost <= _owner.ACOwner.Energy &&
_isFirstAttack &&
(_canParryBullet ||
(!_canParryBullet && !isBullet)))
{
_owner.IsOnParry = FC_PARRY_EFFECT.SUCCESS;
dir.Normalize();
if (dir != Vector3.zero)
{
_owner.ACOwner.ACRotateToDirection(ref dir, false);
_owner.ParryTarget = ac;
_owner.SetActionSwitchFlag(FC_ACTION_SWITCH_FLAG.CANT_ROTATE);
}
ret = true;
}
else if (_currentState == AttackBase.ATTACK_STATE.STEP_2 && _parryCost <= _owner.ACOwner.Energy)
{
if ((isBullet && !_canParryBullet))
{
_owner.IsOnParry = FC_PARRY_EFFECT.PARRY_BULLET_FAIL;
}
else
{
_owner.IsOnParry = FC_PARRY_EFFECT.PARRY;
}
dir.Normalize();
if (dir != Vector3.zero)
{
_owner.ACOwner.ACRotateToDirection(ref dir, false);
_owner.ParryTarget = ac;
_owner.SetActionSwitchFlag(FC_ACTION_SWITCH_FLAG.CANT_ROTATE);
}
_attackCanSwitch = true;
ret = false;
}
else
{
_owner.ClearActionSwitchFlag(FC_ACTION_SWITCH_FLAG.IN_RIGIDBODY2);
_owner.IsOnParry = FC_PARRY_EFFECT.FAIL;
Transform trans = Utils.FindTransformByNodeName(_owner.ACOwner.ThisTransform, "node_right_weapon");
if (trans == null)
{
Debug.LogError("PARRY_EFFECT_POS is null");
}
Vector3 pos = trans.position;
GlobalEffectManager.Instance.PlayEffect(FC_GLOBAL_EFFECT.PARRY_FAIL, pos);
}
if (ret)
{
_attackCanSwitch = true;
}
return(ret);
}
public static void HandleHit(ActionController owner, AttackUnit attackUnit, FC_DAMAGE_TYPE damageType, ActionController target)
{
if (owner.IsAlived)
{
if (owner.ACGetCurrentAttack() != null)
{
owner.ACIsHitTarget(target, attackUnit.GetSharpness(), owner.ACGetCurrentAttack()._hitGainEnergy, attackUnit.GetAttackInfo()._isFromSkill);
}
else
{
owner.ACIsHitTarget(target, 0, false, attackUnit.GetAttackInfo()._isFromSkill);
}
}
if (attackUnit.GetAttackInfo()._damageType != FC_DAMAGE_TYPE.NONE)
{
damageType = attackUnit.GetAttackInfo()._damageType;
}
if (damageType != FC_DAMAGE_TYPE.NONE &&
!(target.SuperArmorSelf.ActiveArmor() == FCConst.SUPER_ARMOR_LVL2 &&
target.SuperArmorSelf.DamageAbsorb(FCConst.SUPER_ARMOR_LVL2) > 0.99f))
{
//play blood effect
Vector3 bloodPos = target.ACGetTransformByName(EnumEquipSlot.belt).position;
//play blood on ground with random rotation
int rotY = Random.Range(0, 360);
Quaternion rot = Quaternion.Euler(0, rotY, 0);
Vector3 bloodGroundPos = target.ACGetTransformByName(EnumEquipSlot.foot_point).position;
bloodGroundPos.y -= target.SelfMoveAgent.GetFlyHeight();
GlobalEffectManager.Instance.PlayEffect(FC_GLOBAL_EFFECT.BLOOD_GROUND, bloodGroundPos, rot);
//play effect by damage type
switch (damageType)
{
case FC_DAMAGE_TYPE.PHYSICAL:
{
if (target.HasBloodEffect)
{
//play physical attack effect
GlobalEffectManager.Instance.PlayEffect(FC_GLOBAL_EFFECT.ATTACK_PHYSICAL
, bloodPos);
GlobalEffectManager.Instance.PlayEffect(FC_GLOBAL_EFFECT.BLOOD
, bloodPos);
}
}
break;
case FC_DAMAGE_TYPE.FIRE:
{
CharacterEffectManager.Instance.PlayEffect(FC_CHARACTER_EFFECT.FIRE_ATTACK
, target._avatarController, -1);
}
break;
case FC_DAMAGE_TYPE.POISON:
{
CharacterEffectManager.Instance.PlayEffect(FC_CHARACTER_EFFECT.DAMAGE_POISON
, target._avatarController, -1);
}
break;
case FC_DAMAGE_TYPE.ICE:
{
CharacterEffectManager.Instance.PlayEffect(FC_CHARACTER_EFFECT.DAMAGE_ICE
, target._avatarController, -1);
}
break;
case FC_DAMAGE_TYPE.THUNDER:
{
CharacterEffectManager.Instance.PlayEffect(FC_CHARACTER_EFFECT.DAMAGE_THUNDER
, target._avatarController, -1);
}
break;
default:
{
Assertion.Check(false, "now we do not support this type damage");
}
break;
}
}
}
public static int Result(AttackInfo ai, DefenseInfo di, out bool isCriticalHit, ActionController attacker, ActionController target)
{
float ret = 0;
isCriticalHit = false;
float physicalDamageReduction = 0;
if (GameManager.Instance.IsPVPMode)
{
ret = Mathf.Max(ai._attackPoints[0] - di._defensePoints[0], ((float)ai._attackPoints[0]) * 0.3f); //pvp damage reduction
if (attacker.SelfCountAgent != null)
{
attacker.SelfCountAgent.OnTryToHit((int)ai._attackPoints[0]);
}
}
else
{
ret = Mathf.Max(ai._attackPoints[0] - di._defensePoints[0], ((float)ai._attackPoints[0]) * 0.1f); //pve damage reduction
}
//ret = ret * (1 - di._defensePercents[0]);
//if (ret < 1)
//{
// ret = 1;
//}
for (int i = 1; i < ai._attackPoints.Length; i++)
{
float ret1 = ((float)(ai._attackPoints[i] - di._defensePoints[i])) * (1 - di._defensePercents[i]);
if (ret1 < 0.5)
{
ret1 = 0;
}
ret += ret1;
}
/*if(attacker.IsPlayer)
* {
* float r1 = Mathf.Pow((ai._criticalChance*10/(75* Mathf.Exp((attacker.Data._level-1)*(0.065f-attacker.Data._level*0.0002f)))),1.7f);
* chance = (int)(Mathf.Sqrt(r1)*0.7f +0.5f);
* //chance = (int)(Mathf.Log(ai._criticalChance*0.25f)*1.25f);
* //Debug.Log(chance);
* }*/
int chance = Mathf.RoundToInt(ai._criticalChance * 100);
chance = Mathf.Clamp(chance, 1, 50);
if (chance >= Random.Range(1, 100))
{
ret = (1 + ai._criticalDamage - di._criticalDamageResist) * ret;
isCriticalHit = true;
}
float addScale = 0;
if (attacker.ACGetCurrentAttack() != null &&
attacker.AIUse.AddDamageScale > 0)
{
addScale = attacker.AIUse.AddDamageScale;
}
ret = ret * (ai._damageScale + addScale);
if (ai._skillAttackDamage > 0)
{
chance = Mathf.RoundToInt(ai._skillTriggerChance * 100);
chance = Mathf.Clamp(chance, 1, 50);
if (chance >= Random.Range(1, 100))
{
ret = (1 + ai._skillAttackDamage) * ret;
}
}
if (CheatManager.showAttackInfo)
{
if (isCriticalHit)
{
attacklog = attacklog + "This is a critical \n";
}
attacklog = attacklog + "Final damage = " + ret + "\n";
}
if (ret < 1 && ret >= 0)
{
ret = 1;
}
if (attacker.IsPlayerSelf && isCriticalHit)
{
if (isCriticalHit)
{
if (attacker.ACGetCurrentAttack() != null)
{
attacker.ACHitTargetIsCrit(target);
}
if (attacker.SkillGodDown)
{
int deltaHp = Mathf.RoundToInt(ret * attacker.Data.PassiveSkillGodDownCriticalToHp);
attacker.ACIncreaseHP(deltaHp);
}
}
}
if (CheatManager.showAttackInfo)
{
attacklog = "------------------------------------------------------\n";
attacklog = attacklog + "Attacker is " + attacker.Data.id + "\n";
attacklog = attacklog + "Target is " + target.Data.id + "\t Level " + target.Data.Level + "\tArmor = " + target.Data.TotalDefense + "\n";
attacklog = attacklog + target.Data.id + " hitpoint before hurt = " + target.HitPoint + "\n";
attacklog = attacklog + "Normal Attack point = " + ai._attackPoints[0] + "\n";
attacklog = attacklog + "Normal Defense point = " + di._defensePoints[0] + "\n";
attacklog = attacklog + "Damage reduction percent = " + physicalDamageReduction + "\n";
attacklog = attacklog + "Damage = " + ret + "\n";
}
return((int)ret);
}
static void FireBullet(string bulletName, int angle, int angleY, Transform tf, FirePort fp, float lifeTime, ActionController owner)
{
FCBullet eb = owner.GetBulletFromPool(bulletName);
ActionController ac = null;
if (owner.IsPlayer)
{
if (eb._seekLevel == FCBullet.SEEK_LEVEL.NORMAL)
{
ac = ActionControllerManager.Instance.GetEnemyTargetBySight
(owner.ThisTransform, eb._maxTargetingDistance, 0, owner.Faction, FCConst.SEEK_ANGLE_NORMAL, true);
}
else if (eb._seekLevel == FCBullet.SEEK_LEVEL.PRO)
{
ac = ActionControllerManager.Instance.GetEnemyTargetBySight
(owner.ThisTransform, eb._maxTargetingDistance, 0, owner.Faction, FCConst.SEEK_ANGLE_NORMAL, FCConst.SEEK_ANGLE_PRO, true);
}
}
else
{
if (eb._seekLevel == FCBullet.SEEK_LEVEL.NORMAL)
{
//ac = ActionControllerManager.Instance.GetEnemyTargetBySight
// (owner.ThisTransform,eb._maxTargetingDistance ,0,owner.Faction,FC_CONST.SEEK_ANGLE_NORMAL,true);
}
else if (eb._seekLevel == FCBullet.SEEK_LEVEL.PRO)
{
if (owner.TargetAC != null)
{
ac = owner.TargetAC;
}
}
}
if (eb != null)
{
/*_fastCommand._cmd = FCCommand.CMD.DIRECTION_FACE_TARGET;
* _fastCommand._param1 = ac;
* CommandManager.Instance.SendFast(ref _fastCommand,_owner);*/
eb.Init(owner);
if (eb.IsRangerBullet)
{
eb.FireRanger(null, tf, fp);
//(eb as BulletRanger).Fire(5f,3f,FC_HIT_TYPE.DIZZY,tf,false);
}
else
{
eb.Fire(ac, tf, angle, angleY, lifeTime, fp);
if (eb._controlByAttack &&
ac != null &&
owner.ACGetCurrentAttack() != null &&
owner.ACGetCurrentAttack()._needAttackCorrect)
{
Vector3 v3 = ac.ThisTransform.localPosition - owner.ThisTransform.localPosition;
v3.y = 0;
v3.Normalize();
if (v3 != Vector3.zero)
{
owner.ACRotateTo(v3, -1, true, true);
}
}
}
if (eb._controlByAttack)
{
owner.ACAddBulletToAttack(eb);
}
}
}