void ModifySkillEffectProperty(
HeaderProto.ESkillEffectPro PropertyType,
HeaderProto.EOpreationFlag opType,
HeaderProto.EOpreationFlag dataType,
int data,
HeaderProto.EEffectSkillBuffOptType optType,
int SkillEffect_UID,
bool bBegin
)
{
string PropertyName = sdActorInterface.SkillEffectName[(int)PropertyType];
if (PropertyName.Length == 0)
{
return;
}
SkillEffect baseSkillEffect = sdConfDataMgr.Instance().m_BaseSkillEffect[SkillEffect_UID] as SkillEffect;
Hashtable skillEffectArray = GetActor().GetSkillEffect();
SkillEffect skillEffect = skillEffectArray[SkillEffect_UID] as SkillEffect;
int Orgin = (int)sdConfDataMgr.GetMemberValue(baseSkillEffect, PropertyName);
int Current = (int)sdConfDataMgr.GetMemberValue(skillEffect, PropertyName);
int iValue = ConvertValue(dataType, data, Orgin);
Current = GetModifyValue(bBegin, opType, Orgin, Current, iValue);
sdConfDataMgr.SetMemberValue(skillEffect, PropertyName, Current);
}
public GameObject CreateEffect(string effectName, Vector3 position)
{
if (string.IsNullOrEmpty(effectName))
{
return(null);
}
GameObject toCreate = GetEffectFromPool(effectName);
if (toCreate == null)
{
toCreate = CreateNewEffectToScene(effectName);
toCreate.transform.localPosition = Vector3.zero;
toCreate.transform.localRotation = Quaternion.identity;
SkillEffect se = toCreate.AddComponent <SkillEffect>();
se.CreateEffect(position);
AddCount(se);
}
else
{
toCreate.transform.localPosition = Vector3.zero;
toCreate.transform.localRotation = Quaternion.identity;
SkillEffect se = toCreate.GetComponent <SkillEffect>();
se.EnableEffect(position);
AddCount(se);
}
return(toCreate);
}
private IEnumerator SkillEffectCorutine(SkillEffect skill)
{
skill.ActivateSkillAction.Perform();
yield return(new WaitForSeconds(skill.SkillEffectDuration));
skill.DeactivateSkillAction.Perform();
}
protected void ApplyEffect(Character source, GameObject target, SkillEffect ef, bool allowStackingSameEffect = false)
{
foreach (EquippableItem u in Owner.Inventory.ActiveUpgrades)
{
u.ModifySkillEffects(this, new SkillEffect[] { ef });
}
ef.Source = source;
ef.SourceSkill = GetSkillId();
ef.SourceSkillObject = this;
if (!allowStackingSameEffect && !(ef is EffectDamage))
{
Character targetCh = target.GetChar();
if (targetCh != null && targetCh.HasEffectAlready(ef))
{
SkillEffect oldEf = targetCh.GetCopyEffect(ef);
if (oldEf != null)
{
targetCh.RemoveEffect(oldEf);
}
else
{
return;
}
}
}
ef.ApplyEffect(source, target);
}
public void UpdateSkillEffects(uint elapsed)
{
// 构造临时容器, 更新之中的元素.
// 因为在Update和Stop一个SkillEffect时, 可能产生新的SkillEffect加入到mContainer中,
// 因此只遍历当前容器内的元素.
int count = mContainer.Count;
for (int i = 0; i < count; ++i)
{
SkillEffect effect = mContainer[i];
if (!effect.IsAwake)
{
continue;
}
UpdateRetCode retCode = effect.Update(elapsed);
if (retCode != UpdateRetCode.Continue)
{
// effect从运行状态开始, 经过Update之后, 不在工作, 原因只可能是
// 时间结束或者在Update中, 被终止(不可能被回收).
effect.Stop(retCode == UpdateRetCode.Finished
? SkillEffectStopReason.Expired : SkillEffectStopReason.Diffused
);
}
}
mContainer.RemoveAll(x => (!x.IsAwake));
}
public void InitCastSkill(uint skill_id, ISkillPart skillPart, uint attackActionID)
{
if (skillPart.GetSkillPartType() == SkillPartType.SKILL_PLAYERPART)
{
playerSkill = skillPart as PlayerSkillPart;
SkillEffectProp skillEffectProp;
if (playerSkill.SkillEffectDic.TryGetValue((int)skill_id, out skillEffectProp) == false)
{
skillEffectProp = playerSkill.RegisterSkill(skill_id);
if (skillEffectProp == null)
{
Log.LogGroup("ZDY", "没有注册技能配置 {0}", skill_id.ToString());
}
return;
}
playerSkill.NextSkillID = 0;
playerSkill.CurSkillID = skill_id;
playerSkill.AttackAnimState = null;
playerSkill.SetFighting(true);
SkillEffect skillEffect = CreateSkillEffect(skillEffectProp);
Cast(skillEffect, skill_id);
}
}
public void AddRunSkillEffect(SkillEffect eff)
{
if (!m_runSkillEffect.Contains(eff))
{
m_runSkillEffect.Add(eff);
}
}
/// <summary>
/// 서버로부터 전송받은 스킬의 효과를 대상에게 적용하도록 하는 함수
/// </summary>
/// <param name="tCampNum">타겟의 캠프 번호</param>
/// <param name="tIndex">타겟이 되는 로봇의 번호</param>
/// <param name="statusType">효과가 적용되는 스테이터스 타입</param>
/// <param name="ccType">효과에 담긴 CC 타입</param>
/// <param name="amount">변화할 스테이터스의 양</param>
/// <param name="duration">변화할 시간. 0이면 무제한</param>
public void ApplySkillEffect(int tCampNum, int tIndex, int statusType, int ccType, int amount, float duration, float chp)
{
Robot target;
if (tCampNum == 1)
{
target = robotManager.FirstCampRobot(tIndex);
}
else
{
target = robotManager.SecondCampRobot(tIndex);
}
SkillEffect effect = new SkillEffect((StatusType)statusType, (CCType)ccType, amount, duration);
if (target == null)
{
Debug.Log("해당하는 타겟을 찾을 수 없습니다. 스킬 효과 적용을 무시합니다." + System.Environment.NewLine
+ "타겟 정보 : " + tCampNum + "P의 " + tIndex + "번째 로봇" + System.Environment.NewLine
+ "스킬 정보 : " + (StatusType)statusType + "스탯, " + (CCType)ccType + "CC 기, " + amount + "만큼 " + duration + "초 동안 변화");
return;
}
target.Synchronize(chp);
target.Apply(effect);
// 상대 로봇에게 가한 damage를 게임매니저에 저장.
if ((StatusType)statusType == StatusType.CHP && tCampNum != MyCampNum)
{
if (amount < 0)
{
IncDamageCount(-amount);
}
}
}
/// <summary>
/// 根据参数, 创建技能效果, 并使之开始运行.
/// </summary>
/// <returns></returns>
public ErrorCode CreateSkillEffect(SkillEffectInitParam param)
{
SkillEffect effect = SkillDetails.AllocSkillEffect(param);
if (effect == null)
{
return(ErrorCode.InvalidParam);
}
if (!effect.Initialize(param))
{
return(ErrorCode.LogicError);
}
ErrorCode err = effect.Start(param);
if (err == ErrorCode.Succeeded)
{
if (effect.NeedUpdate)
{
mContainer.Add(effect as SkillBuff);
}
else
{
effect.Stop(SkillEffectStopReason.Expired);
}
}
return(err);
}
public override void NotifyEffectRemoved(SkillEffect eff)
{
if (eff is EffectSkillReuse)
{
DeleteParticleEffect(particleSystem);
}
}
private void ApplyEnmityToCharacters(BattleCharacter actor, SkillEffect effect, List<BattleCharacter> targets)
{
foreach (var target in targets)
{
this.ApplyEnmityToCharacter(actor, effect, target);
}
}
public void showPlayerSkillActivate()
{
SkillEffect se = bcManager.getBattleSkillEffect();
if (se == null)
{
// 沒使用技能
Debug.Log("普通攻擊動畫!");
}
else
{
if (se.isSkillActivated)
{
// 技能發動成功
battleSkillText.text = usingBattleSkill.skillName_ch;
playSkillActivatedAnimation();
Debug.Log("技能動畫! 技能成功");
}
else
{
// 技能沒發動成功
Debug.Log("普通攻擊動畫! 技能失敗");
}
}
}
private void PatchSkillEffect(SkillEffect b)
{
switch (b.TypeValue)
{
case SkillEffect.EffectType.UpAttack:
Status.AttackBase += b.Value;
break;
case SkillEffect.EffectType.UpCrit:
Status.CritOffset += b.Value;
break;
case SkillEffect.EffectType.UpDodge:
Status.Dodge += b.Value;
break;
case SkillEffect.EffectType.UpAim:
Status.Aim += b.Value;
break;
case SkillEffect.EffectType.AddAttackTimes:
Status.AdditionalAttackTimes += b.Value;
break;
case SkillEffect.EffectType.UpLife:
Status.life_max += b.Value;
break;
}
}
IEnumerator PlayerAttackRoutine()
{
SkillEffect se = bcManager.getBattleSkillEffect();
uiManager.showPlayerAttack();
bcManager.destroyAllDice(); // 清掉骰子模型
uiManager.showPlayerSkillActivate();
if (se == null)
{
yield return(new WaitForSeconds(0.8f));
}
else
{
yield return(new WaitForSeconds(1));
}
if (bcManager.turnDamage > 0)
{
uiManager.showPlayerAttackAnim();
yield return(new WaitForSeconds(0.5f));
audioManager.playPlayerAttack();
if (se != null && se.isSkillActivated && se.isDamage)
{
Instantiate(bcManager.getBattleSkill().skillprefab, monster.transform.position, Quaternion.identity);
}
else
{
Instantiate(normalAttackPrefab, monster.transform.position, Quaternion.identity);
}
uiManager.showMonsterHurt();
yield return(new WaitForSeconds(1));
}
if (se != null && se.isHeal && se.heal > 0)
{
Instantiate(HealPrefab, currentCharacter.transform.position, Quaternion.identity);
uiManager.showPlayerRecoverHp();
yield return(new WaitForSeconds(1));
}
// demo用
if (monster.Hp <= 0)
{
// 提醒一下，換scene前一定要將角色parent移回dataManager，不然就算有Don't Destroy，也因為父親被砍，而消失。
// 只有戰敗死亡的時候，才不用管，反正都要重頭來過
currentCharacter.transform.SetParent(dataManager.transform, false);
currentCharacter.transform.localPosition = new Vector3(0f, 10f, 0f);
screenEffectManager.fadeOutToLoot();
}
uiManager.updateMonsterUI();
uiManager.updateCharacterUI();
uiManager.showNextButton();
currentUnitIndex = (currentUnitIndex + 1) % battleUnits.Length;
}
public void CreateSkillEffect()
{
uint count = m_skillEffectData.Number;
if (count <= 0)
{
return;
}
bool hasInit = count == m_lstSkillList.Count;
float startShowTime = 0;
Vector2 startPos = (Vector2)m_owner.Transform.position + m_startPosOffset;
for (int i = 0; i < count; i++)
{
if (!hasInit)
{
SkillEffect skillEffect = new SkillEffect(m_skillEffectData);
m_lstSkillList.Add(skillEffect);
skillEffect.Initialize(startShowTime, startPos, m_owner.Direction, m_loadObj, m_rootTrans, m_owner);
}
else
{
m_lstSkillList[i].Initialize(startShowTime, startPos, m_owner.Direction, m_loadObj, m_rootTrans, m_owner);
}
startShowTime += m_skillEffectData.CreatDeltaTime;
startPos += m_createPosOffset;
}
}
public double CalculateDamage(BattleCharacter attacker, BattleCharacter defender, SkillEffect effect, bool shouldCritical)
{
var damage = 0d;
if (effect.HasStatModifier(Const.Stats.Attack))
{
var modifiedAtk = attacker.GetStatWithModifiers(Const.Stats.Attack, effect.StatsModifiers);
damage += modifiedAtk.Value - defender.GetStat(Const.Stats.Defense);
}
if (effect.HasStatModifier(Const.Stats.Wisdom))
{
var modifiedWis = attacker.GetStatWithModifiers(Const.Stats.Wisdom, effect.StatsModifiers);
damage += modifiedWis.Value - defender.GetStat(Const.Stats.Mind);
}
if (effect.HasStatModifier(Const.Stats.Mind))
{
damage += attacker.GetStatWithModifiers(Const.Stats.Mind, effect.StatsModifiers).Value;
}
if (shouldCritical)
{
damage *= Const.CriticalDamageMultiplier;
}
// damage value needs to be positive or zero at this point so a low atk doesn't heal a high def without going thru affinities
damage = Math.Max(0d, damage);
damage = ApplyAffinityBonuses(damage, defender, effect.Affinities);
return Math.Floor(damage);
}
public TrashBin(TimeSpan birthTime, Texture texture, Vector startingPosition, string name, int price, string description, string iconTextureKey,
NecessityEffect necessityEffect, SkillEffect skillEffect)
: base(birthTime, name, texture, startingPosition, price, description, iconTextureKey)
{
NecessityEffect = necessityEffect;
SkillEffect = skillEffect;
}
public override SkillEffect calSkillEffect(int[] checkValue)
{
bool isTrigger = true;
finalCheckValue = 0;
SkillEffect skilleffect = new SkillEffect(this.isDamage,
this.isHeal,
this.isDodge,
this.isShield,
this.isDisable,
this.isSelfDisable,
this.isMPDamage,
this.isHealMP);
for (int i = 0; i < checkValue.Length; i++)
{
finalCheckValue += checkValue[i];
if (checkValue[i] < 2)
{
isTrigger = false;
}
}
if (isTrigger)
{
finalCheckValue += 4;
skilleffect.setSkillActivated(true);
Debug.Log("迴旋斬發動成功! - " + finalCheckValue);
}
skilleffect.setDamage(finalCheckValue);
return(skilleffect);
}
public Skill(string name, Cost cost, SkillEffect effect, double skillStrength)
{
Name = name;
Cost = cost;
Effect = effect;
SkillStrength = skillStrength;
}
protected override void takeAction(SkillEffect effect)
{
if (effect.NeedRemoveOnOwnerEvent(mOwnerEvent))
{
effect.Stop(StopReason);
}
}
public override SkillEffect calSkillEffect(int[] checkValue)
{
SkillEffect skilleffect = new SkillEffect(this.isDamage,
this.isHeal,
this.isDodge,
this.isShield,
this.isDisable,
this.isSelfDisable,
this.isMPDamage,
this.isHealMP);
finalCheckValue = 0;
for (int i = 0; i < checkValue.Length; i++)
{
if (checkValue[i] % 2 == 1)
{
finalCheckValue += checkValue[i];
}
}
// 吸收對方的MP 回復自己的
Debug.Log("魔力吸收! - " + finalCheckValue);
skilleffect.setSkillActivated(true);
skilleffect.setHealMP(finalCheckValue);
skilleffect.setMPDamage(finalCheckValue);
return(skilleffect);
}
//-----------------------------------------------------------------------//
//
// 戦闘判定用
//
//-----------------------------------------------------------------------//
protected override bool BattleCanHit3Way()
{
SkillData ActiveSkill = JobManager.instance.GetSkillFromID(ActiveSkillID);
List <SkillData> UsableSkill = JobManager.instance.GetUsableSkill(this);
if (ActiveSkill != null)
{
foreach (SkillEffect b in ActiveSkill.SkillEffect)
{
if (b.TypeValue == SkillEffect.EffectType.Hit3Way)
{
return(true);
}
}
}
foreach (SkillData s in UsableSkill)
{
if (s.IsActiveSkill)
{
continue;
}
for (int i = 0; i < s.SkillEffect.Count; i++)
{
SkillEffect b = s.SkillEffect[i];
if (b.TypeValue == SkillEffect.EffectType.Hit3Way)
{
return(true);
}
}
}
return(false);
}
public override SkillEffect calSkillEffect(int[] checkValue)
{
SkillEffect skilleffect = new SkillEffect(this.isDamage,
this.isHeal,
this.isDodge,
this.isShield,
this.isDisable,
this.isSelfDisable,
this.isMPDamage,
this.isHealMP);
bool isAllSmallerThanThree = true;
for (int i = 0; i < checkValue.Length; i++)
{
if (checkValue[i] >= 3)
{
isAllSmallerThanThree = false;
}
}
if (isAllSmallerThanThree)
{
finalCheckValue = 1;
skilleffect.setSkillActivated(true);
Debug.Log("下一擊不會中!");
}
skilleffect.setDodge(finalCheckValue);
return(skilleffect);
}
public override SkillEffect calSkillEffect(int[] checkValue)
{
finalCheckValue = 0;
SkillEffect skilleffect = new SkillEffect(this.isDamage,
this.isHeal,
this.isDodge,
this.isShield,
this.isDisable,
this.isSelfDisable,
this.isMPDamage,
this.isHealMP);
for (int i = 0; i < checkValue.Length; i++)
{
finalCheckValue += checkValue[i];
}
if (finalCheckValue > 8)
{
finalCheckValue *= 2;
skilleffect.setDamage(finalCheckValue);
skilleffect.setHeal(2);
skilleffect.setSkillActivated(true);
Debug.Log("重擊發動成攻! - " + finalCheckValue);
}
else
{
skilleffect.setDamage(finalCheckValue);
}
return(skilleffect);
}
public void EffectsTick(Character target, List <SkillEffects> skillEffects)
{
foreach (var e in skillEffects)
{
SkillEffect effect = default;
switch (e.skillEffectType)
{
case SkillEffectType.ChangeHealth:
effect = e.changeHealth;
break;
case SkillEffectType.ChangeHealthOverTime:
effect = e.changeHealthOverTime;
break;
case SkillEffectType.Frozen:
effect = e.frozen;
break;
default:
break;
}
effect.user = this.user;
effect.Tick(target);
Debug.Log($"EffectsTick: {effect}");
}
}
public void SetSkillsValues(SkillEffect skillEffect)
{
labelCommunicationValue.Text = String.Format("{0} {1}", (int)skillEffect.CommunicationEffectiveness, skillEffect.CommunicationEffectivenessToString());
labelLeadershipValue.Text = String.Format("{0} {1}", (int)skillEffect.LeadershipEffectiveness, skillEffect.LeadershipEffectivenessToString());
labelCreativityValue.Text = String.Format("{0} {1}", (int)skillEffect.CreativityEffectiveness, skillEffect.CreativityEffectivenessToString());
labelIntelligenceValue.Text = String.Format("{0} {1}", (int)skillEffect.IntelligenceEffectiveness, skillEffect.IntelligenceEffectivenessToString());
}
// enum types
public static SkillEffect[] Add(SkillEffect n, SkillEffect[] list)
{
ArrayList tmp = new ArrayList();
foreach(SkillEffect str in list) tmp.Add(str);
tmp.Add(n);
return tmp.ToArray(typeof(SkillEffect)) as SkillEffect[];
}
public override SkillEffect calSkillEffect(int[] checkValue)
{
SkillEffect skilleffect = new SkillEffect(this.isDamage,
this.isHeal,
this.isDodge,
this.isShield,
this.isDisable,
this.isSelfDisable,
this.isMPDamage,
this.isHealMP);
finalCheckValue = 0;
for (int i = 0; i < checkValue.Length; i++)
{
finalCheckValue += checkValue[i];
}
if (finalCheckValue > 10)
{
Debug.Log("風之守護!");
skilleffect.setSkillActivated(true);
finalCheckValue = 1;
}
skilleffect.setDodge(finalCheckValue);
return(skilleffect);
}
public async Task <ActionResult> UpdateSkillEffect(int skillID, sbyte level, sbyte sequence, SkillEffect skillEffect)
{
if (!SkillEffect.Validate(skillEffect))
{
return(BadRequest(skillEffect));
}
var result = await _context.UpdateSkillEffect(skillID, level, sequence, skillEffect);
if (result.Conflict)
{
return(Conflict($"{skillEffect.SkillID}/{skillEffect.Level}/{skillEffect.Sequence}"));
}
if (result.SkillID < 1 ||
result.Level < 1 ||
result.Sequence < 1)
{
return(NotFound($"{skillEffect.SkillID}/{skillEffect.Level}/{skillEffect.Sequence}"));
}
if (skillID != result.SkillID ||
level != result.Level ||
sequence != result.Sequence)
{
return(Redirect($"skilleffect/{skillEffect.SkillID}/{skillEffect.Level}/{skillEffect.Sequence}"));
}
return(NoContent());
}
protected override void takeAction(SkillEffect effect)
{
if (IsHarmfulEffect(effect.Type, effect.ResID) == mHarmful)
{
effect.Stop(StopReason);
}
}
protected override void takeAction(SkillEffect effect)
{
if (effect.Type == SkillEffectType.Buff && effect.ResID == ResID)
{
effect.Stop(StopReason);
}
}
public static PacketWriter GiveCrossSurgeBuff(Buff buff, MapleCharacter chr, SkillEffect effect)
{
BuffedCharacterStats stats = chr.Stats;
int damageIncPercent = effect.Info[CharacterSkillStat.x];
int absorbPercent = effect.Info[CharacterSkillStat.y];
PacketWriter pw = new PacketWriter();
pw.WriteHeader(SendHeader.GiveBuff);
WriteBuffMask(pw, buff.Effect.BuffInfo.Keys);
double hpPercent = (chr.Hp / (double)stats.MaxHp) * 100;
short dmgInc = (short)(hpPercent * (damageIncPercent / 100.0));
pw.WriteShort(dmgInc);
pw.WriteInt(buff.SkillId);
pw.WriteUInt(buff.Duration);
pw.WriteInt(0);
pw.WriteByte(0);
int absorb = (int)((stats.MaxHp - chr.Hp) * (absorbPercent / 100.0));
absorb = Math.Min(absorb, 4000);
pw.WriteInt(absorb);
pw.WriteInt(0);
pw.WriteInt(540); //?
pw.WriteInt(1);
pw.WriteByte(0);
return(pw);
}
public Skill(int id)
{
if (CfgManager.GetInstance().Skills.ContainsKey(id) == false)
{
Debug.LogErrorFormat("skill cfg not found: {0}", id);
return;
}
CfgSkill cfg = CfgManager.GetInstance().Skills[id];
this.id = cfg.id;
name = cfg.name;
desc = cfg.desc;
animation = cfg.animation;
sound = cfg.sound;
hiteffect = cfg.hiteffect;
hitpoints = cfg.hitpoints;
targettype = cfg.targettype;
aoe = cfg.aoe;
spcost = cfg.spcost;
colddown = cfg.colddown;
// skill effects
int count = cfg.skilleffects.Length;
if (count > 0)
{
skilleffects = new SkillEffect[count];
for (int i = 0; i < count; i++)
{
skilleffects[i] = SkillEffect.CreateSkillEffect(cfg.skilleffects[i], this);
}
}
}
public bool ShouldHit(BattleCharacter attacker, BattleCharacter defender, SkillEffect effect)
{
var modifiedStat = attacker.GetStatWithModifiers(Const.Stats.Accuracy, effect.StatsModifiers);
var hitChance = modifiedStat.Value;
var evaChance = modifiedStat.IsAbsolute ? 0d :defender.GetStat(Const.Stats.Evasion);
return this.IsRandomCheckSuccess(hitChance - evaChance);
}
public void ApplyEnmityForSkillEffect(BattleCharacter actor, SkillEffect effect, List<BattleCharacter> affectedCharacters, List<BattleCharacter> allCharacters)
{
switch (effect.EnmityType)
{
case Const.EnmityTargetType.Target:
this.ApplyEnmityToCharacters(actor, effect, affectedCharacters);
break;
case Const.EnmityTargetType.All:
var targets = allCharacters.FindAll(x => x.Team != actor.Team);
this.ApplyEnmityToCharacters(actor, effect, targets);
break;
}
}
public static SkillEffect CrossSlashEffect()
{
var skillEffect = new SkillEffect();
skillEffect.EffectTarget = Targeting.CrossOpponentTarget();
var affinities = new SkillEffectAffinities();
affinities.SetAffinity(Const.Affinities.Physical, 1d);
skillEffect.Affinities = affinities;
skillEffect.BaseEnmity = 15;
skillEffect.EnmityType = Const.EnmityTargetType.Target;
skillEffect.EffectType = Const.SkillEffectType.Attack;
skillEffect.AddStatModifier(Const.Stats.Attack, 2d, Const.ModifierType.Multiply);
return skillEffect;
}
public static SkillEffect MeleeAttackEffect()
{
var skillEffect = new SkillEffect();
skillEffect.EffectTarget = Targeting.SingleOpponentTarget();
var affinities = new SkillEffectAffinities();
affinities.SetAffinity(Const.Affinities.Physical, 1d);
skillEffect.Affinities = affinities;
skillEffect.BaseEnmity = 10;
skillEffect.EnmityType = Const.EnmityTargetType.Target;
skillEffect.EffectType = Const.SkillEffectType.Attack;
skillEffect.AddStatModifier(Const.Stats.Attack, 1d, Const.ModifierType.Multiply);
skillEffect.AddStatusEffect(StatusEffect.Blind());
return skillEffect;
}
public bool ShouldCritical(BattleCharacter attacker, BattleCharacter defender, SkillEffect effect)
{
var critChance = attacker.GetStatWithModifiers(Const.Stats.Critical, effect.StatsModifiers);
return this.IsRandomCheckSuccess(critChance.Value);
}
public static SkillEffect[] Remove(int index, SkillEffect[] list)
{
ArrayList tmp = new ArrayList();
foreach(SkillEffect str in list) tmp.Add(str);
tmp.RemoveAt(index);
return tmp.ToArray(typeof(SkillEffect)) as SkillEffect[];
}
public EquippedSkillEffect(SkillEffect sE, float multiplier)
{
skillEffect = sE;
skillMultiplier = multiplier;
}
private void ApplyEnmityToCharacter(BattleCharacter actor, SkillEffect effect, BattleCharacter target)
{
// TODO: better enmity calculation logic
var enmityDelta = effect.BaseEnmity;
target.Enmity.ChangeEnmityLevel(actor, enmityDelta);
}
public static int createEffect(ILuaState luaState)
{
SkillEffect effect = new SkillEffect();
InterpreterManager.getInstance().registerEffect(effect);
InterpreterManager.getInstance().pushEffect(luaState, effect);
return 1;
}
public void InitializeAttributesStats(ArmorAttribute[] attributes, SkillEffect[] effects)
{
//characterTransform = Player.Instance.avatarObject.transform;
skillEffects = effects;
armorAttributes = attributes;
}
public static SkillEffect SquashEffect()
{
var skillEffect = new SkillEffect();
skillEffect.EffectTarget = Targeting.SquashTarget();
var affinities = new SkillEffectAffinities();
affinities.SetAffinity(Const.Affinities.Physical, 1d);
skillEffect.Affinities = affinities;
skillEffect.BaseEnmity = 30;
skillEffect.EnmityType = Const.EnmityTargetType.Target;
skillEffect.EffectType = Const.SkillEffectType.Attack;
skillEffect.AddStatModifier(Const.Stats.Attack, 0.5d, Const.ModifierType.Multiply);
skillEffect.AddStatusEffect(StatusEffect.Poison());
return skillEffect;
}
public static SkillEffect WaitEffect()
{
var skillEffect = new SkillEffect();
skillEffect.EffectTarget = Targeting.SingleTarget();
skillEffect.BaseEnmity = 0;
skillEffect.EnmityType = Const.EnmityTargetType.Target;
skillEffect.EffectType = Const.SkillEffectType.None;
skillEffect.AddStatModifier(Const.Stats.Accuracy, 1d, Const.ModifierType.Absolute);
return skillEffect;
}
public static SkillEffect MinorHealEffect()
{
var skillEffect = new SkillEffect();
skillEffect.EffectTarget = Targeting.SingleTarget();
var affinities = new SkillEffectAffinities();
affinities.SetAffinity(Const.Affinities.Healing, 1d);
skillEffect.Affinities = affinities;
skillEffect.BaseEnmity = 40;
skillEffect.EnmityType = Const.EnmityTargetType.All;
skillEffect.EffectType = Const.SkillEffectType.Heal;
skillEffect.AddStatModifier(Const.Stats.Accuracy, 1d, Const.ModifierType.Absolute);
skillEffect.AddStatModifier(Const.Stats.Mind, 3d, Const.ModifierType.Multiply);
skillEffect.AddStatusEffect(StatusEffect.PoisonResistanceUp());
return skillEffect;
}
public static SkillEffect ChainLightningSecondary()
{
var skillEffect = new SkillEffect();
skillEffect.EffectTarget = Targeting.ChainLightningSecondary();
var affinities = new SkillEffectAffinities();
affinities.SetAffinity(Const.Affinities.Lightning, 1d);
skillEffect.Affinities = affinities;
skillEffect.BaseEnmity = 20;
skillEffect.EnmityType = Const.EnmityTargetType.Target;
skillEffect.EffectType = Const.SkillEffectType.Attack;
skillEffect.AddStatModifier(Const.Stats.Accuracy, 1d, Const.ModifierType.Absolute);
skillEffect.AddStatModifier(Const.Stats.Wisdom, 1d, Const.ModifierType.Multiply);
return skillEffect;
}
public SkillCfg GetSkillCfg(int skillId)
{
if(null == skill001)
{
skill001 = new SkillCfg();
skill001.SkillId = 1;
skill001.AffNum = 1;
skill001.AffRange = 0;
skill001.AffDirection = (byte)ESkillDir.Fore;
SkillEffect eff = new SkillEffect();
eff.AnimType = EAnimType.Attack_Arrow_Fire;
eff.EffectBegin = true;
eff.EffectType = (byte)ESkillEffectType.TrackTarget;
eff.EffectFile = AssetPath.GetAssetStorePathWithSlash() + "Particle/Arrow001.unity3d";
eff.EffectTime = 0f;
eff.EffectSpeed = 50f;
eff.EffectHardPoint = (byte)EHardPoint.Back;
eff.EffectFireSrc = (byte)ESkillFireSrc.WeaponLeft;
eff.EffectFireSrcHardPoint = (byte)EHardPoint.Effect;
skill001.EffectList = new List<SkillEffect>();
skill001.EffectList.Add(eff);
skill001.AnimTime = 1f;
skill001.AnimList = new List<EAnimType>();
skill001.AnimList.Add(EAnimType.Attack_Arrow_Begin);
skill001.AnimList.Add(EAnimType.Attack_Arrow_Hold);
skill001.AnimList.Add(EAnimType.Attack_Arrow_Fire);
}
return skill001;
}
private Const.Team GetPreferredSkillTargetTeam(SkillEffect skillEffect, Const.Team actorTeam)
{
switch (skillEffect.EffectType)
{
case Const.SkillEffectType.Attack:
case Const.SkillEffectType.Debuff:
return this.GetOpponentTeam(actorTeam);
case Const.SkillEffectType.Buff:
case Const.SkillEffectType.Heal:
return actorTeam;
case Const.SkillEffectType.None:
return actorTeam;
default:
return this.GetOpponentTeam(actorTeam);
}
}
public BattleSkill(string _skillName, SkillEffect[] _skillEffects, SkillElement _skillElement)
{
skillName = _skillName;
}
public void registerEffect(SkillEffect effect)
{
this._luaState.PushLightUserData(effect);
effect.setRef(this._luaState.L_Ref(LuaDef.LUA_REGISTRYINDEX));
}
