private void SwitchAbnormalState(eAbnormalState abnormalState, AbnormalStateEffectPrefabData _specialEffectData)
{
AbnormalStateCategoryData categoryData = abnormalStateCategoryDataDictionary[GetAbnormalStateCategory(abnormalState)];
EnableAbnormalState(categoryData.CurrentAbnormalState, false, false, true);
EnableAbnormalState(abnormalState, true, false, false);
categoryData.CurrentAbnormalState = abnormalState;
//处理特效
}
public void SetAbnormalState(UnitCtrl source, eAbnormalState abnormalState, float effectTime, ActionParameter action, Skill skill, float value, float value2, bool reduceEnergy, float reduceEnergyRate)
{
if (action != null)
{
//获取特效
}
if ((this.staticBattleManager.GameState == eGameBattleState.FIGHTING) && ((!this.IsAbnormalState(eAbnormalState.NO_DAMAGE_MOTION) && !this.IsAbnormalState(eAbnormalState.NO_ABNORMAL)) || ABNORMAL_CONST_DATA[abnormalState].IsBuff))
{
switch (abnormalState)
{
case eAbnormalState.BURN:
case eAbnormalState.CURSE:
case eAbnormalState.SLOW:
case eAbnormalState.INHIBIT_HEAL:
case eAbnormalState.FAINT:
this.OnSlipDamage();
break;
}
int effecttime_int = (int)(staticBattleManager.FrameRate * effectTime);
if (abnormalState == eAbnormalState.GUANG_BOTH && IsAbnormalState(eAbnormalState.DRAIN_BOTH) ||
abnormalState == eAbnormalState.GUARD_ATK && IsAbnormalState(eAbnormalState.DRAIN_ATK) ||
abnormalState == eAbnormalState.GUARG_MGC && IsAbnormalState(eAbnormalState.DRAIN_MGC))
{
//设置特效
return;
}
AbnormalStateCategoryData categoryData = abnormalStateCategoryDataDictionary[GetAbnormalStateCategory(abnormalState)];
if (isDead)
{
return;
}
if (IsAbnormalState(GetAbnormalStateCategory(abnormalState)))
{
SwitchAbnormalState(abnormalState, null);
}
categoryData.Time = effectTime;
categoryData.Duration = effectTime;
categoryData.MainValue = value;
categoryData.SubValue = value2;
categoryData.EnergyReduceRate = reduceEnergyRate;
categoryData.ActionId = action == null ? 0 : action.ActionId;
categoryData.IsEnergyReduceMode = reduceEnergy;
categoryData.Skill = skill;
categoryData.Source = source;
if (!IsAbnormalState(GetAbnormalStateCategory(abnormalState)))
{
categoryData.CurrentAbnormalState = abnormalState;
StartCoroutine(UpdateAbnormalState(abnormalState, null));
}
return;
}
if (IsAbnormalState(eAbnormalState.NO_ABNORMAL))
{
SetMissAtk(source, eMissLogType.DODGE_BY_NO_DAMAGE_MOTION, eDamageEffectType.NORMAL, null, 1);
}
}
public void SetRecovery(int _value, eInhibitHealType _inhibitHealType, UnitCtrl _source, bool _isEffect = true, bool _isRevival = false, bool _isUnionBurstLifeSteal = false, bool _isRegenerate = false, bool _useNumberEffect = true, BasePartsData _target = null)
{
if (_target == null)
{
_target = GetFirstParts(true, 0);
}
if ((isDead || Hp <= 0) && !_isRevival)
{
Debug.LogError("治疗无效，目标已经死了！");
}
else
{
if (_inhibitHealType != eInhibitHealType.NO_EFFECT && IsAbnormalState(eAbnormalState.INHIBIT_HEAL))
{
if (GetAbnormalStateMainValue(eAbnormalStateCategory.INHIBIT_HEAL) != 0)
{
DamageData damageData_0 = new DamageData();
damageData_0.Target = GetFirstParts(this != null, 0);
damageData_0.Damage = Mathf.FloorToInt(GetAbnormalStateMainValue(eAbnormalStateCategory.INHIBIT_HEAL) * _value);
damageData_0.DamageType = eDamageType.NONE;
AbnormalStateCategoryData abdata = abnormalStateCategoryDataDictionary[eAbnormalStateCategory.INHIBIT_HEAL];
damageData_0.Source = abdata.Source;
damageData_0.DamageNumMagic = _inhibitHealType == eInhibitHealType.MAGIC;
damageData_0.ActionType = eActionType.INHIBIT_HEAL;
SetDamage(damageData_0, false, abdata.ActionId, null, true, abdata.Skill, true, null, false, 1, 1, null);
}
}
else
{
Hp += _value;
//AppendbattleLog;
if (Hp > BaseValues.Hp)
{
Hp = BaseValues.Hp;
}
unitUI.SetHP(Hp / BaseValues.Hp);
string msg = UnitName + "恢复<color=#00FF00>" + _value + "</color>生命";
BattleUIManager.Instance.LogMessage(msg, eLogMessageType.HP_RECOVERY, IsOther);
if (_isUnionBurstLifeSteal)
{
unionburstLifeStealNum += _value;
}
else
{
if (_useNumberEffect)
{
//特效数字
}
if (_isEffect)
{
//治疗特效
}
}
}
}
}
private IEnumerator UpdateAbnormalState(eAbnormalState _abnormalState, AbnormalStateEffectPrefabData _specialEffectData)
{
eAbnormalStateCategory category = GetAbnormalStateCategory(_abnormalState);
AbnormalStateCategoryData categoryData = abnormalStateCategoryDataDictionary[category];
categoryData.Time = categoryData.Duration;
//特效处理
EnableAbnormalState(_abnormalState, true, categoryData.IsEnergyReduceMode, false);
while (true)
{
if (IsAbnormalState(category))
{
_abnormalState = categoryData.CurrentAbnormalState;
if (categoryData.IsEnergyReduceMode)
{
float energy_min = categoryData.EnergyReduceRate * DeltaTimeForPause_BUFF;
SetEnergy(Energy - energy_min, eSetEnergyType.BY_MODE_CHANGE, null);
if (Energy <= 0)
{
EnableAbnormalState(_abnormalState, false);
yield break;
}
}
else
{
categoryData.Time -= DeltaTimeForPause_BUFF;
if (categoryData.Time <= 0)
{
EnableAbnormalState(_abnormalState, false);
yield break;
}
}
if (!IsDead)
{
yield return(null);
continue;
}
EnableAbnormalState(_abnormalState, false);
break;
}
break;
}
}
private IEnumerator UpdateSlipDamage(eAbnormalStateCategory _category, int _slipDamageId)
{
AbnormalStateCategoryData categoryData = abnormalStateCategoryDataDictionary[_category];
float time_5 = 0;
int damage_5 = (int)categoryData.MainValue;
int incrementDamage_5 = (int)(categoryData.MainValue * categoryData.SubValue / 100.0f);//一般都为0 yield return null;
yield return(null);
while (true)
{
if (IsAbnormalState(_category))
{
if (slipDamageIdDictionary[_category] == _slipDamageId)
{
time_5 += DeltaTimeForPause_BUFF;
if (time_5 > 0.995f)
{
DamageData damageData = new DamageData();
damageData.Target = GetFirstParts(false, 0);
damageData.Damage = damage_5;
damageData.DamageType = eDamageType.NONE;
damageData.Source = categoryData.Source;
damageData.IsSlipDamage = true;
damageData.ActionType = eActionType.SLIP_DAMAGE;
SetDamage(damageData, false, categoryData.ActionId, null, true, categoryData.Skill, true, null, false, 1, 1, null);
damage_5 += incrementDamage_5;
time_5 = 0;
}
yield return(null);
continue;
}
}
break;
}
}
private void EnableAbnormalState(eAbnormalState abnormalState, bool enable, bool reduceEnergy = false, bool _switch = false)
{
eAbnormalStateCategory category = GetAbnormalStateCategory(abnormalState);
AbnormalStateCategoryData categoryData = abnormalStateCategoryDataDictionary[category];
if (!enable)
{
//销毁特效
categoryData.MainValue = 0;
categoryData.Time = 0;
categoryData.Duration = 0;
}
categoryData.enable = enable;
m_abnormalState[abnormalState] = enable;
switch (abnormalState)
{
case eAbnormalState.HASTE:
if (enable)
{
if (actionState == eActionState.IDLE)
{
spineController.SetTimeScale(timeScale * 2.0f);
break;
}
}
else if (!IsUnableActionState() && !isPause)
{
spineController.Resume();
}
break;
case eAbnormalState.POISON:
case eAbnormalState.BURN:
case eAbnormalState.CURSE:
case eAbnormalState.NO_EFFECT_SLIP_DAMAGE:
case eAbnormalState.VENOM:
case eAbnormalState.HEX:
case eAbnormalState.COMPENSATION:
if (enable)
{
slipDamageIdDictionary[category]++;
StartCoroutine(UpdateSlipDamage(category, slipDamageIdDictionary[category]));
}
break;
case eAbnormalState.SLOW:
if (enable)
{
//改变颜色
if (actionState == eActionState.IDLE)
{
spineController.SetTimeScale(timeScale * 0.5f);
}
}
else
{
//改变颜色
if (!IsUnableActionState())
{
spineController.Resume();
}
}
break;
case eAbnormalState.PARALYSIS:
case eAbnormalState.FREEZE:
case eAbnormalState.CHAINED:
case eAbnormalState.SLEEP:
case eAbnormalState.STUN:
case eAbnormalState.DETAIN:
case eAbnormalState.FAINT:
if (enable)
{
if (actionState != eActionState.DAMAGE)
{
SetState(eActionState.DAMAGE, 0);
break;
}
}
else if (!IsUnableActionState() && !_switch)
{
SetMotionResume();
}
break;
case eAbnormalState.CONVERT:
case eAbnormalState.CONFUSION:
SetLeftDirection(IsNearestEnemyLeft());
if (actionState == eActionState.ATK || actionState == eActionState.IDLE || actionState == eActionState.SKILL1 || actionState == eActionState.SKILL)
{
cancalByCovert = true;
idleStartAfterWaitFrame = m_fCastTimer <= DeltaTimeForPause;
}
if (Hp >= 1 && !IsUnableActionState() && actionState != eActionState.DAMAGE)
{
SetState(eActionState.IDLE, 0);
}
break;
case eAbnormalState.CONTINUOUS_ATTACK_NEARBY:
Debug.LogError("咕咕咕！");
break;
case eAbnormalState.DECOY:
Debug.LogError("咕咕咕！");
break;
case eAbnormalState.STONE:
if (enable)
{
if (actionState != eActionState.DAMAGE)
{
SetState(eActionState.DAMAGE, 0);
}
//设置石化颜色
}
else
{
if (!IsUnableActionState() && !_switch)
{
SetMotionResume();
}
//设置石化颜色
}
break;
case eAbnormalState.REGENERATION:
if (enable)
{
currentHpRegeneId++;
StartCoroutine(UpdateHpRegeneration(currentHpRegeneId));
}
break;
case eAbnormalState.TP_REGENERATION:
if (enable)
{
currentTpRegeneId++;
StartCoroutine(UpdateTpRegeneration(currentHpRegeneId));
}
break;
default:
break;
}
OnChangeState?.Invoke(this, ABNORMAL_CONST_DATA[abnormalState].IconType, enable);
if (!enable && !_switch)
{
//Elements_Battle_BattleManager__RestartAbnormalStateField(v43, this, abnormalState, 0LL)
}
}
private void ExecBarrier(DamageData _damageData, ref float _fDamage, ref int _overRecoverValue)
{
if (IsAbnormalState(eAbnormalState.GUARD_ATK))
{
if (_damageData.DamageType == eDamageType.ATK)
{
AbnormalStateCategoryData abdata = abnormalStateCategoryDataDictionary[eAbnormalStateCategory.DAMAGE_RESISTANCE_ATK];
float v13 = _fDamage - abdata.MainValue;
if (v13 <= 0)//如果伤害小于护盾量
{
abdata.MainValue -= Mathf.FloorToInt(_fDamage);
_fDamage = 0;
}
else//伤害大于护盾量
{
EnableAbnormalState(eAbnormalState.GUARD_ATK, false, false, false);
_fDamage = v13;
}
}
}
if (IsAbnormalState(eAbnormalState.GUARG_MGC))
{
if (_damageData.DamageType == eDamageType.MGC)
{
AbnormalStateCategoryData abdata = abnormalStateCategoryDataDictionary[eAbnormalStateCategory.DAMAGE_RESISTANCE_MGK];
float v13 = _fDamage - abdata.MainValue;
if (v13 <= 0)//如果伤害小于护盾量
{
abdata.MainValue -= Mathf.FloorToInt(_fDamage);
_fDamage = 0;
}
else//伤害大于护盾量
{
EnableAbnormalState(eAbnormalState.GUARG_MGC, false, false, false);
_fDamage = v13;
}
}
}
if (IsAbnormalState(eAbnormalState.DRAIN_ATK))
{
if (_damageData.DamageType == eDamageType.ATK)
{
AbnormalStateCategoryData abdata = abnormalStateCategoryDataDictionary[eAbnormalStateCategory.DAMAGE_RESISTANCE_ATK];
float v13 = _fDamage - abdata.MainValue;
if (v13 <= 0)//如果伤害小于护盾量
{
long rec = SetRecoveryAndGetOverRecovery(Mathf.FloorToInt(_fDamage), this, _damageData.Target, _damageData.DamageType == eDamageType.MGC);
_overRecoverValue += (int)rec;
abdata.MainValue -= Mathf.FloorToInt(_fDamage);
_fDamage = 0;
}
else//伤害大于护盾量
{
long rec = SetRecoveryAndGetOverRecovery(Mathf.FloorToInt(abdata.MainValue), this, _damageData.Target, _damageData.DamageType == eDamageType.MGC);
_overRecoverValue += (int)rec;
EnableAbnormalState(eAbnormalState.DRAIN_ATK, false);
_fDamage = v13;
}
}
}
if (IsAbnormalState(eAbnormalState.DRAIN_MGC))
{
if (_damageData.DamageType == eDamageType.MGC)
{
AbnormalStateCategoryData abdata = abnormalStateCategoryDataDictionary[eAbnormalStateCategory.DAMAGE_RESISTANCE_MGK];
float v13 = _fDamage - abdata.MainValue;
if (v13 <= 0)//如果伤害小于护盾量
{
long rec = SetRecoveryAndGetOverRecovery(Mathf.FloorToInt(_fDamage), this, _damageData.Target, _damageData.DamageType == eDamageType.MGC);
_overRecoverValue += (int)rec;
abdata.MainValue -= Mathf.FloorToInt(_fDamage);
_fDamage = 0;
}
else//伤害大于护盾量
{
long rec = SetRecoveryAndGetOverRecovery(Mathf.FloorToInt(abdata.MainValue), this, _damageData.Target, _damageData.DamageType == eDamageType.MGC);
_overRecoverValue += (int)rec;
EnableAbnormalState(eAbnormalState.DRAIN_MGC, false);
_fDamage = v13;
}
}
}
if (IsAbnormalState(eAbnormalState.GUANG_BOTH))
{
if (_damageData.ActionType != eActionType.DESTROY)
{
AbnormalStateCategoryData abdata = abnormalStateCategoryDataDictionary[eAbnormalStateCategory.DAMAGE_RESISTANCE_BOTH];
float v13 = _fDamage - abdata.MainValue;
if (v13 <= 0)
{
abdata.MainValue -= Mathf.FloorToInt(_fDamage);
_fDamage = 0;
}
else
{
EnableAbnormalState(eAbnormalState.GUANG_BOTH, false);
_fDamage = v13;
}
}
}
if (IsAbnormalState(eAbnormalState.DRAIN_BOTH))
{
if (_damageData.ActionType != eActionType.DESTROY)
{
AbnormalStateCategoryData abdata = abnormalStateCategoryDataDictionary[eAbnormalStateCategory.DAMAGE_RESISTANCE_BOTH];
float v13 = _fDamage - abdata.MainValue;
if (v13 <= 0)//如果伤害小于护盾量
{
long rec = SetRecoveryAndGetOverRecovery(Mathf.FloorToInt(_fDamage), this, _damageData.Target, _damageData.DamageType == eDamageType.MGC);
_overRecoverValue += (int)rec;
abdata.MainValue -= Mathf.FloorToInt(_fDamage);
_fDamage = 0;
}
else//伤害大于护盾量
{
long rec = SetRecoveryAndGetOverRecovery(Mathf.FloorToInt(abdata.MainValue), this, _damageData.Target, _damageData.DamageType == eDamageType.MGC);
_overRecoverValue += (int)rec;
EnableAbnormalState(eAbnormalState.DRAIN_BOTH, false);
_fDamage = v13;
}
}
}
}
