private bool checkSkillEffect()
{
DataType myName = DataType.DATA_SKILL_EFFECT;
IDictionaryEnumerator itr = DataManager.SkillEffectTable.GetEnumerator();
while (itr.MoveNext())
{
SkillEffectTableItem item = itr.Value as SkillEffectTableItem;
for (uint i = 0; i < SkillEffectTableItem.SkillEffectCount; ++i)
{
SkillEffectItem subItem = item.items[i];
SkillEffectType type = subItem.effectType;
uint resId = subItem.effectID;
switch (type)
{
case SkillEffectType.Buff:
if (!checkLink(myName, item.resID, DataType.DATA_SKILL_BUFF, resId))
{
return(false);
}
break;
case SkillEffectType.Displacement:
if (!checkLink(myName, item.resID, DataType.DATA_SKILL_DISPLACEMENT, resId))
{
return(false);
}
break;
case SkillEffectType.Impact:
if (!checkLink(myName, item.resID, DataType.DATA_SKILL_IMPACT, resId))
{
return(false);
}
break;
case SkillEffectType.Spasticity:
if (!checkLink(myName, item.resID, DataType.DATA_SKILL_SPASTICITY, resId))
{
return(false);
}
break;
case SkillEffectType.Invalid:
break;
default:
checkParam(false, myName, item.resID, "效果类型");
return(false);
}
}
}
// foreach (int key in DataManager.SkillEffectTable.Keys)
// {
//
// }
return(true);
}
/// <summary>
/// 判断某一skilleffect是否是有害的.
/// </summary>
/// <param name="type">skilleffect的类型</param>
/// <param name="resID">skilleffect的资源ID</param>
/// <returns></returns>
public static bool IsHarmfulEffect(SkillEffectType type, uint resID)
{
switch (type)
{
case SkillEffectType.Buff:
SkillBuffTableItem resBuff = DataManager.BuffTable[resID] as SkillBuffTableItem;
return(resBuff == null || resBuff.harmful);
case SkillEffectType.Impact:
SkillImpactTableItem resImpact = DataManager.ImpactTable[resID] as SkillImpactTableItem;
return(resImpact == null || resImpact.harmful);
case SkillEffectType.Displacement:
SkillDisplacementTableItem resDisplacement = DataManager.DisplacementTable[resID] as SkillDisplacementTableItem;
return(resDisplacement == null || resDisplacement.harmful);
case SkillEffectType.Spasticity:
return(true);
default:
ErrorHandler.Parse(ErrorCode.LogicError, "invalid skill effect type: " + type);
break;
}
return(true);
}
public virtual void CreateSkillEffect(EffectCreateContext ctx)
{
SkillEffectType effectType = ctx.EffectType;
switch (effectType)
{
case SkillEffectType.Damage:
{
m_effect = new EffectSDamage();
}
break;
default:
{
Debug.LogError("Skill::CreateSkillEffect Effect Type Not Implement!!!");
}
break;
}
if (m_effect.Create(ctx) == false)
{
Debug.LogError("Skill::Create " + effectType + " Failed !!!");
}
m_effect.Start();
}
public static string GetEffectDesc(SkillEffectType skillEffectType)
{
CTextManager instance = Singleton <CTextManager> .instance;
string text = "{0}{1}";
object obj = "Skill_Common_Effect_Type_";
uint num = (uint)skillEffectType;
return(instance.GetText(string.Format(text, obj, num.ToString())));
}
public static void AddEffect(List <Effect> Effects, SkillEffectType EffectType)
{
if (EffectType != SkillEffectType.None)
{
if (EffectType == SkillEffectType.AddStatus)
{
Effects.Add(new AddStatusEffect()
{
Enabled = true
});
}
if (EffectType == SkillEffectType.RemoveStatus)
{
Effects.Add(new RemoveStatusEffect()
{
Enabled = true
});
}
if (EffectType == SkillEffectType.NumericModify)
{
Effects.Add(new AttributeNumericModifyEffect()
{
Enabled = true
});
}
if (EffectType == SkillEffectType.CauseDamage)
{
Effects.Add(new DamageEffect()
{
Enabled = true
});
}
if (EffectType == SkillEffectType.CureHero)
{
Effects.Add(new CureEffect()
{
Enabled = true
});
}
if (EffectType == SkillEffectType.AddShield)
{
Effects.Add(new AddShieldEffect()
{
Enabled = true
});
}
if (EffectType == SkillEffectType.StackTag)
{
Effects.Add(new StackTagEffect()
{
Enabled = true
});
}
EffectType = SkillEffectType.None;
}
}
public static string GetEffectDesc(SkillEffectType skillEffectType)
{
CTextManager arg_1D_0 = Singleton <CTextManager> .get_instance();
string arg_18_0 = "{0}{1}";
object arg_18_1 = "Skill_Common_Effect_Type_";
uint num = skillEffectType;
return(arg_1D_0.GetText(string.Format(arg_18_0, arg_18_1, num.ToString())));
}
public void RemovePower()
{
if (recepient == null)
{
return;
}
effectType = SkillEffectType.debuff;
ImplementPower();
}
public override void Read(XmlNode item)
{
skillAreaType = (SkillAreaType)GetInt(item, "skillAreaType");
skillEffectType = (SkillEffectType)GetInt(item, "skillEffectType");
skillAdditionType = (SkillAdditionType)GetInt(item, "skillAdditionType");
id = GetInt(item, "id");
skillName = GetString(item, "skillName");
range = GetInt(item, "range");
des = GetString(item, "des");
}
public Skill()
{
Id = 1;
NameLang = 10000;
DescriptionLang = 10001;
Image = Resources.Load("Skill/LinerSword", typeof(Sprite)) as Sprite;
HotKeyIndex = 0;
RangeType = SkillRangeType.Line;
Range = 3;
EffectType = SkillEffectType.PhysicalDamage;
CD = 2;
Power = 10000;
}
public int NameToValue(SkillEffectType status)
{
switch (status)
{
case SkillEffectType.MaxHp:
return(MaxHp);
case SkillEffectType.PAtk:
return(PAtk);
case SkillEffectType.PDef:
return(PDef);
case SkillEffectType.PCri:
return(PCri);
case SkillEffectType.MAtk:
return(MAtk);
case SkillEffectType.MDef:
return(MDef);
case SkillEffectType.MCri:
return(MCri);
case SkillEffectType.Hit:
return(Hit);
case SkillEffectType.Avoid:
return(Avoid);
case SkillEffectType.Accuracy:
return(Accuracy);
case SkillEffectType.HealUp:
return(HealUp);
case SkillEffectType.TPUp:
return(TPUp);
case SkillEffectType.HPAuto:
return(HPAuto);
case SkillEffectType.TPAuto:
return(TPAuto);
default:
return(0);
}
}
/// <summary>
/// 给当前单位添加技能效果.
/// </summary>
/// <param name="attackerAttr">为this添加技能效果的单位的属性</param>
/// <param name="type">效果类型</param>
/// <param name="resID">效果ID</param>
/// <returns></returns>
public ErrorCode AddSkillEffect(AttackerAttr attackerAttr, SkillEffectType type, uint resID)
{
// 是否死亡.
if (IsDead())
{
return(ErrorCode.TargetIsDead);
}
// 由单位的本身类型, 决定的是否免疫给类型的技能效果.
if (SkillEffectImmunity(type))
{
return(ErrorCode.AddEffectFailedSkillEffectImmunity);
}
if (SkillUtilities.IsHarmfulEffect(type, resID) && IsInviolable())
{
return(ErrorCode.AddEffectFailedSkillEffectImmunity);
}
ErrorCode err = ErrorCode.ConfigError;
switch (type)
{
case SkillEffectType.Spasticity:
#region Pending
err = SkillDetails.StartSpasticity(mActionCenter, attackerAttr, resID, ref mSpasticityCd);
#endregion Pending
break;
case SkillEffectType.Displacement:
err = SkillDetails.StartDisplace(mActionCenter, attackerAttr, resID);
break;
case SkillEffectType.Buff:
case SkillEffectType.Impact:
err = SkillDetails.StartSkillEffect(attackerAttr, mSkillEffectManager, type, resID);
break;
default:
break;
}
if (err == ErrorCode.Succeeded && type == SkillEffectType.Buff)
{
onSkillBuffAdded((uint)resID);
}
return(err);
}
public static void Damage(Character character, int damage, SkillEffectType skillEffect, SkillLevelConf skillLevel)
{
Debug.LogError("Damage " + damage + "name " + character.name);
switch (skillEffect)
{
case SkillEffectType.blood:
if (character.blood - damage <= 0)
{
character.Dead();
}
else if (character.blood - damage > character.totalBlood)
{
character.blood = character.totalBlood;
}
else
{
character.blood -= damage;
}
break;
case SkillEffectType.gas:
if (character.gas - damage < 0)
{
character.gas = 0;
}
else if (character.gas - damage > character.totalGas)
{
character.gas = character.totalGas;
}
else
{
character.gas -= damage;
}
break;
}
if (skillLevel.buffList != null)
{
List <Buff> buffs = GetBuff(skillLevel.buffList);
if (buffs != null)
{
character.buffList.AddRange(buffs);
}
}
if (character.IsNPC)
{
character.GetComponent <AIBase>().IsAttack = true;
}
}
/// <summary>
/// 添加技能效果.
/// </summary>
/// <param name="attackerAttr">添加者的属性</param>
/// <param name="effectManager">被添加者的技能效果控制器</param>
/// <param name="type">效果类型</param>
/// <param name="resID">效果ID</param>
/// <returns></returns>
public static ErrorCode StartSkillEffect(AttackerAttr attackerAttr,
SkillEffectManager effectManager,
SkillEffectType type,
uint resID
)
{
if (effectManager == null)
{
return(ErrorCode.LogicError);
}
SkillEffect effect = null;
SkillEffectInitParam param = null;
switch (type)
{
case SkillEffectType.Buff:
effect = effectManager.FindSkillEffectByPredicate(new SkillUtilities.FindBuffByResource(resID));
// 存在相同的buff, 进行叠加.
if (effect != null)
{
return((effect as SkillBuff).AddStack());
}
// 不存在相同的buff, 创建buff.
param = new SkillBuffInitParam(effectManager.Owner, attackerAttr, resID);
// 移除所有与新buff互斥的效果.
uint mutex = ((SkillBuffInitParam)param).buffResource.mutex;
if (mutex != uint.MaxValue)
{
effectManager.ForEverySkillEffect(new SkillUtilities.KillMutuallyExclusiveSkillBuff(mutex));
}
break;
case SkillEffectType.Impact:
// 创建impact.
param = new SkillImpactInitParam(effectManager.Owner, attackerAttr, resID);
break;
default:
ErrorHandler.Parse(ErrorCode.ConfigError, "invalid skilleffect type " + (uint)type);
break;
}
return(effectManager.CreateSkillEffect(param));
}
public virtual bool Create(EffectCreateContext ctx)
{
m_owner = GameMgr.Instance.m_entityMgr.Get(ctx.TargetUID);
if (m_owner == null)
{
return(false);
}
m_effectType = ctx.EffectType;
m_srcID = ctx.SrcUID;
m_targetID = ctx.TargetUID;
m_showID = ctx.ShowID;
m_hitShowID = ctx.HitShowID;
return(true);
}
static public void UseSkillEffect(uint objId, SkillEffectType type, uint resID)
{
BaseScene scn = SceneManager.Instance.GetCurScene();
if (scn == null)
{
return;
}
ObjectBase obj = scn.FindObject(objId);
if (obj == null)
{
return;
}
BattleUnit npc = (BattleUnit)obj;
npc.AddSkillEffect(new AttackerAttr(npc), type, resID);
}
/// <summary>
/// 添加出生技能效果, 不会检查是否可以添加该效果.
/// </summary>
/// <param name="summonerAttr">召唤者的属性, 如果没有召唤者, 那么通过this构造该结构</param>
protected ErrorCode AddBornSkillEffect(AttackerAttr summonerAttr, SkillEffectType type, uint resID)
{
ErrorCode err = ErrorCode.ConfigError;
switch (type)
{
case SkillEffectType.Displacement:
err = SkillDetails.StartDisplace(mActionCenter, summonerAttr, resID);
break;
case SkillEffectType.Buff:
case SkillEffectType.Impact:
err = SkillDetails.StartSkillEffect(summonerAttr, mSkillEffectManager, type, resID);
break;
default:
break;
}
return(err);
}
public Skill(int id)
{
this.SkillID = id;
if (id == 1) {
this.Name = "愤怒一击";
this.Type = SkillType.Active;
this.TargetNumber = 1;
this.TargetState = SkillTargetState.EnemyAlive;
this.TargetStrategy = SkillTargetStrategy.Random;
this.EffectType = SkillEffectType.HPReduce;
this.EffectValue = 5;
this.EffectProbability = 0.8;
this.SpellType = SkillSpellType.AfterCooldown;
this.FirstSpellTurn = 1;
this.CurrentHPRequire = 1;
this.UnitCountRequire = 1;
this.Cooldown = 3;
}
}
public static string GetEffectSlotBg(SkillEffectType skillEffectType)
{
return(string.Format("{0}{1}", "UGUI/Sprite/Common/", CSkillData.slotBgStrs[(int)((uint)((UIntPtr)((ulong)((long)(skillEffectType - SkillEffectType.Physical)))))]));
}
public static string GetEffectDesc(SkillEffectType skillEffectType)
{
uint num = (uint)skillEffectType;
return(Singleton <CTextManager> .instance.GetText(string.Format("{0}{1}", "Skill_Common_Effect_Type_", num.ToString())));
}
protected override bool SkillEffectImmunity(SkillEffectType type)
{
// 免疫位移, buff和硬直.
return(type == SkillEffectType.Displacement || type == SkillEffectType.Buff || type == SkillEffectType.Spasticity);
}
/// <summary>
/// 返回true, 表示免疫某些类型的技能效果.
/// </summary>
protected virtual bool SkillEffectImmunity(SkillEffectType type)
{
return(false);
}
public static string GetEffectSlotBg(SkillEffectType skillEffectType)
{
return(string.Format("{0}{1}", "UGUI/Sprite/Common/", CSkillData.slotBgStrs[(int)(skillEffectType - 1)]));
}
public static ParticleEffect showEfectBySkillEffectTypeWithCharacterSize(int effId, Monster target, SkillEffectType type, int attackerUniqueId = -1000)
{
switch (type)
{
case SkillEffectType.isUp:
if (string.IsNullOrEmpty(GameManager.info.skillEffectSetupData[effId].effUp))
{
return(null);
}
return(GameManager.info.effectData[GameManager.info.skillEffectSetupData[effId].effUp].getParticleEffectByCharacterSize(attackerUniqueId, target));
break;
case SkillEffectType.isDown:
if (string.IsNullOrEmpty(GameManager.info.skillEffectSetupData[effId].effDown))
{
return(null);
}
return(GameManager.info.effectData[GameManager.info.skillEffectSetupData[effId].effDown].getParticleEffectByCharacterSize(attackerUniqueId, target));
break;
case SkillEffectType.upLoop:
if (string.IsNullOrEmpty(GameManager.info.skillEffectSetupData[effId].effUpLoop))
{
return(null);
}
return(GameManager.info.effectData[GameManager.info.skillEffectSetupData[effId].effUpLoop].getParticleEffectByCharacterSize(attackerUniqueId, target, target.tf, target.tf));
break;
case SkillEffectType.downLoop:
if (string.IsNullOrEmpty(GameManager.info.skillEffectSetupData[effId].effDownLoop))
{
return(null);
}
return(GameManager.info.effectData[GameManager.info.skillEffectSetupData[effId].effDownLoop].getParticleEffectByCharacterSize(attackerUniqueId, target, target.tf, target.tf));
break;
}
return(null);
}
