protected override void HandleMonsters(Character p_sorcerer, SpellEventArgs p_result, List <Object> p_targets, Single p_magicFactor)
{
m_previouslySelectedMonster = LegacyLogic.Instance.WorldManager.Party.SelectedMonster;
base.HandleMonsters(p_sorcerer, p_result, p_targets, p_magicFactor);
LegacyLogic.Instance.WorldManager.Party.SelectMonsterWithoutEvent(m_previouslySelectedMonster);
m_previouslySelectedMonster = null;
}
protected override Boolean IsApplySpellEventForMe(Object p_sender, EventArgs p_args, out String out_buffNameKey, out String out_spellNameKey)
{
out_buffNameKey = null;
out_spellNameKey = null;
if (p_args is SpellEventArgs)
{
SpellEventArgs spellEventArgs = (SpellEventArgs)p_args;
foreach (MonsterBuffTarget monsterBuffTarget in spellEventArgs.SpellTargetsOfType <MonsterBuffTarget>())
{
if (monsterBuffTarget.Target == MyController && monsterBuffTarget.Buff != EMonsterBuffType.NONE && ((Monster)monsterBuffTarget.Target).BuffHandler.HasBuff(monsterBuffTarget.Buff))
{
out_buffNameKey = monsterBuffTarget.Buff.ToString();
out_spellNameKey = GetSpellNameKey(spellEventArgs.Spell);
return(true);
}
}
return(false);
}
ItemSuffixApplyBuffEventArgs itemSuffixApplyBuffEventArgs = (ItemSuffixApplyBuffEventArgs)p_args;
if (itemSuffixApplyBuffEventArgs.TargetMonster == MyController && itemSuffixApplyBuffEventArgs.Buff != EMonsterBuffType.NONE)
{
out_buffNameKey = itemSuffixApplyBuffEventArgs.Buff.ToString();
out_spellNameKey = itemSuffixApplyBuffEventArgs.SuffixKey;
return(true);
}
return(false);
}
public override void DoEffect(Monster p_monster, Character p_target, SpellEventArgs p_spellArgs)
{
GridSlot slot = LegacyLogic.Instance.MapLoader.Grid.GetSlot(p_monster.Position);
IList <MovingEntity> entities = slot.Entities;
for (Int32 i = 0; i < entities.Count; i++)
{
if (entities[i] is Monster)
{
Monster monster = (Monster)entities[i];
List <MonsterBuff> buffList = monster.BuffHandler.BuffList;
if (buffList != null && buffList.Count != 0)
{
List <MonsterBuff> list = new List <MonsterBuff>();
for (Int32 j = 0; j < buffList.Count; j++)
{
if (buffList[j].IsDebuff && (buffList[j].StaticID != 3 || monster != p_monster))
{
list.Add(buffList[j]);
}
}
if (list.Count > 0)
{
Int32 index = Random.Range(0, list.Count);
monster.BuffHandler.RemoveBuff(list[index]);
}
}
}
}
}
public override void DoEffect(Monster p_monster, Character p_target, SpellEventArgs p_spellArgs)
{
m_grid = LegacyLogic.Instance.MapLoader.Grid;
Party party = LegacyLogic.Instance.WorldManager.Party;
GridSlot gridSlot = CheckSlot(party.Position);
if (gridSlot == null)
{
gridSlot = FindTargetSlot(p_monster.Position);
}
if (gridSlot != null)
{
if (gridSlot.Position != party.Position)
{
MoveParty(gridSlot);
}
SpawnCagePiece(gridSlot.Position + EDirection.WEST, true);
SpawnCagePiece(gridSlot.Position + EDirection.NORTH, false);
SpawnCagePiece(gridSlot.Position + EDirection.EAST, false);
SpawnCagePiece(gridSlot.Position + EDirection.SOUTH, false);
}
else
{
LegacyLogger.Log("FOUND no slot :(");
}
}
protected override void HandleMonsterBuffs(Character p_sorcerer, SpellEventArgs p_result, Monster p_target, Single p_magicFactor)
{
if (!p_target.AbilityHandler.HasAbility(EMonsterAbilityType.LARGE))
{
base.HandleMonsterBuffs(p_sorcerer, p_result, p_target, p_magicFactor);
}
}
protected override void HandleMonsters(Character p_sorcerer, SpellEventArgs p_result, List <Object> p_targets, Single p_magicFactor)
{
if (m_didHit)
{
for (Int32 i = 0; i < p_targets.Count; i++)
{
Monster monster = p_targets[i] as Monster;
if (monster.CurrentHealth > 0 && m_staticData.MonsterBuffs != null)
{
for (Int32 j = 0; j < m_staticData.MonsterBuffs.Length; j++)
{
if (m_staticData.MonsterBuffs[j] != EMonsterBuffType.NONE)
{
AddMonsterBuff(monster, m_staticData.MonsterBuffs[j], p_magicFactor);
Boolean p_Successful = monster.BuffHandler.HasBuff(m_staticData.MonsterBuffs[j]);
Boolean p_IsImmune = false;
if (!monster.AbilityHandler.CanAddBuff(m_staticData.MonsterBuffs[j]))
{
p_IsImmune = true;
}
p_result.SpellTargets.Add(new MonsterBuffTarget(monster, m_staticData.MonsterBuffs[j], p_Successful, p_IsImmune));
}
}
}
}
}
}
public override void DoEffect(Monster p_monster, Character p_target, SpellEventArgs p_spellArgs)
{
if (Random.Value < m_staticData.GetAdditionalValue(m_level))
{
base.DoEffect(p_monster, p_target, p_spellArgs);
}
}
protected virtual void HandleConditions(SpellEventArgs p_result, List <Object> p_targets, Single p_magicFactor)
{
if (m_staticData.RemovedConditions != null && m_staticData.RemovedConditions.Length != 0)
{
for (Int32 i = 0; i < m_staticData.RemovedConditions.Length; i++)
{
ECondition econdition = m_staticData.RemovedConditions[i];
if (econdition != ECondition.NONE)
{
for (Int32 j = 0; j < p_targets.Count; j++)
{
Character character = p_targets[j] as Character;
if (character != null)
{
if (character.ConditionHandler.HasCondition(econdition))
{
p_result.SpellTargets.Add(new RemovedConditionTarget(p_targets[j], econdition));
RemoveCondition(p_targets[j], econdition);
m_didPushEntry = true;
}
}
}
}
}
}
}
protected void Drag(Monster p_monster, SpellEventArgs p_result)
{
if (p_monster.CurrentHealth <= 0)
{
return;
}
if (p_monster.AbilityHandler.HasAbility(EMonsterAbilityType.LARGE) || p_monster.AbilityHandler.HasAbility(EMonsterAbilityType.BOSS) || p_monster.AbilityHandler.HasAbility(EMonsterAbilityType.STATIC_OBJECT))
{
return;
}
Party party = LegacyLogic.Instance.WorldManager.Party;
Grid grid = LegacyLogic.Instance.MapLoader.Grid;
EDirection direction = EDirectionFunctions.GetDirection(p_monster.Position, party.Position);
Int32 num = (Int32)Position.Distance(p_monster.Position, party.Position) - 1;
for (Int32 i = 0; i < num; i++)
{
if (!grid.CanMoveEntity(p_monster, direction))
{
break;
}
Position p_pos = p_monster.Position + direction;
GridSlot slot = grid.GetSlot(p_monster.Position);
if (grid.GetSlot(p_pos).AddEntity(p_monster))
{
slot.RemoveEntity(p_monster);
}
}
if (Position.Distance(p_monster.Position, party.Position) > 1f)
{
LegacyLogic.Instance.WorldManager.Party.SelectedMonster = null;
}
}
protected override void HandlePartyMemberHealing(Single p_magicFactor, Single p_critChance, Int32 p_critHealValue, SpellEventArgs p_result, List <Object> p_targets)
{
SpellEventArgs eventArgs = GetEventArgs();
if (m_staticData.Damage != null && m_staticData.Damage.Length > 0 && m_staticData.Damage[0].Type == EDamageType.HEAL)
{
Int32 value = Damage.Create(m_staticData.Damage[0] * p_magicFactor, 0f).Value;
for (Int32 i = 0; i < LegacyLogic.Instance.WorldManager.Party.Members.Length; i++)
{
Character character = LegacyLogic.Instance.WorldManager.Party.Members[i];
if (character.HealthPoints < character.MaximumHealthPoints)
{
Boolean flag = Random.Range(0f, 1f) < p_critChance;
Int32 num = value;
if (flag)
{
num = p_critHealValue;
}
eventArgs.SpellTargets.Add(new HealedTarget(character, num, flag));
character.ChangeHP(num);
DamageEventArgs p_eventArgs = new DamageEventArgs(new AttackResult
{
Result = EResultType.HEAL,
DamageResults =
{
new DamageResult(EDamageType.HEAL, num, 0, 1f)
}
});
LegacyLogic.Instance.EventManager.InvokeEvent(character, EEventType.CHARACTER_HEALS, p_eventArgs);
}
}
}
eventArgs.Result = ESpellResult.OK;
LegacyLogic.Instance.ActionLog.PushEntry(new SpellEffectEntryEventArgs(null, eventArgs));
}
public static void InvokeSpellFinished(SpellEventArgs args)
{
if (SpellFinished != null)
{
SpellFinished(args);
}
}
protected override void HandleMonsters(Character p_attacker, SpellEventArgs p_result, List <Object> p_targets, Single p_magicFactor)
{
foreach (Monster monster in LegacyLogic.Instance.WorldManager.GetObjectsByTypeIterator <Monster>())
{
monster.BuffHandler.RemoveBuffByID(19);
}
base.HandleMonsters(p_attacker, p_result, p_targets, p_magicFactor);
}
public override void DoEffect(Monster p_monster, Character p_target, SpellEventArgs p_spellArgs)
{
if (p_monster != null && !p_monster.BuffHandler.HasBuff(EMonsterBuffType.FLICKERING_LIGHT))
{
p_monster.AddBuff(BuffFactory.CreateMonsterBuff(EMonsterBuffType.FLICKERING_LIGHT, p_monster.MagicPower, m_level));
m_cooldown = 3;
}
}
protected override void HandleMonsters(Character p_attacker, SpellEventArgs p_result, List <Object> p_targets, Single p_magicFactor)
{
if (p_targets.Count > 0)
{
((Monster)p_targets[0]).BuffHandler.RemoveAllBuffs();
p_result.SpellTargets.Add(new SpellTarget((Monster)p_targets[0]));
}
}
private static void OnSpellEvent(SpellEventArgs args)
{
try
{
int eoc = 0;
Spell spell = args.Spell;
Spell[] recentSpells;
if (spellCache.ContainsKey(args.Player) == false)
{
recentSpells = new Spell[3];
recentSpells[0] = spell;
recentSpells[1] = spell;
recentSpells[2] = spell;
spellCache.Add(args.Player, recentSpells);
if (spell is MagerySpell)
{
eoc = (1 * ((int)((MagerySpell)spell).Circle + 1));
}
args.Player.EssenceOfCharacter += eoc;
}
else
{
recentSpells = spellCache[args.Player];
bool recentSpell =
(recentSpells[0].ToString() == spell.ToString() ||
recentSpells[1].ToString() == spell.ToString() ||
recentSpells[2].ToString() == spell.ToString());
if (!recentSpell)
{
if (recentSpells[1] != null)
{
recentSpells[2] = recentSpells[1];
}
if (recentSpells[0] != null)
{
recentSpells[1] = recentSpells[0];
}
recentSpells[0] = spell;
if (spell is MagerySpell)
{
eoc = (1 * ((int)((MagerySpell)spell).Circle + 1));
}
args.Player.EssenceOfCharacter += eoc;
}
}
}
catch { }
}
private void HandlePartyBuffs(SpellEventArgs p_result, Single p_magicFactor)
{
if (m_staticData.PartyBuff != EPartyBuffs.NONE)
{
p_result.AddedPartyBuffs = m_staticData.PartyBuff;
p_result.SpellTargets.Add(new PartyBuffTarget(LegacyLogic.Instance.WorldManager.Party, m_staticData.PartyBuff));
AddPartyBuff(p_magicFactor);
}
}
public override void DoEffect(Monster p_monster, Character p_target, SpellEventArgs p_spellArgs)
{
Grid grid = LegacyLogic.Instance.MapLoader.Grid;
Position position = LegacyLogic.Instance.WorldManager.Party.Position;
Int32 num = 0;
EDirection direction = EDirectionFunctions.GetDirection(position, p_monster.Position);
Position position2 = p_monster.Position + direction;
GridSlot slot = grid.GetSlot(position2);
while (slot != null && slot.IsPassable(p_monster, false) && num < 4)
{
num++;
position2 += direction;
slot = grid.GetSlot(position2);
}
Int32 num2 = 0;
EDirection direction2 = EDirectionFunctions.GetDirection(p_monster.Position, position);
position2 = position + direction2;
slot = grid.GetSlot(position2);
while (slot != null && slot.IsPassable(p_monster, false) && num2 < 3)
{
num2++;
position2 += direction2;
slot = grid.GetSlot(position2);
}
if (num2 > 0)
{
num2++;
}
Position position3 = p_monster.Position;
if (num2 > num)
{
for (Int32 i = 0; i < num2; i++)
{
position3 += direction2;
}
}
else
{
for (Int32 i = 0; i < num; i++)
{
position3 += direction;
}
}
Position position4 = p_monster.Position;
grid.GetSlot(p_monster.Position).RemoveEntity(p_monster);
grid.GetSlot(position3).AddEntity(p_monster);
p_monster.Position = position3;
p_monster.Direction = EDirectionFunctions.GetDirection(p_monster.Position, position);
BaseObjectEventArgs p_eventArgs = new BaseObjectEventArgs(p_monster, p_monster.Position);
LegacyLogic.Instance.EventManager.InvokeEvent(p_monster, EEventType.SET_ENTITY_POSITION, p_eventArgs);
}
public override void DoEffect(Monster p_monster, Character p_target, SpellEventArgs p_spellArgs)
{
if (Random.Value < m_staticData.GetAdditionalValue(m_level))
{
for (Int32 i = 0; i < m_staticData.InflictedConditions.Length; i++)
{
p_target.ConditionHandler.AddCondition(m_staticData.InflictedConditions[i]);
}
}
}
public override void DoEffect(Monster p_monster, Character p_target, SpellEventArgs p_spellArgs)
{
Party party = LegacyLogic.Instance.WorldManager.Party;
if (party.Buffs.Buffs.Count > 0)
{
List <PartyBuff> buffs = party.Buffs.Buffs;
Int32 index = Random.Range(0, buffs.Count - 1);
party.Buffs.RemoveBuff(buffs[index].Type);
}
}
protected override void HandleMonsters(Character p_sorcerer, SpellEventArgs p_result, List <Object> p_targets, Single p_magicFactor)
{
foreach (Object obj in p_targets)
{
Monster monster = (Monster)obj;
if (monster != null)
{
ExecuteRangedAttackOnTarget(monster, p_sorcerer);
}
}
}
public override void DoEffect(Monster p_monster, Character p_target, SpellEventArgs p_spellArgs)
{
if (p_target.FightHandler.CurrentGeneralBlockAttempts > 0)
{
p_target.FightHandler.CurrentGeneralBlockAttempts--;
}
else if (p_target.FightHandler.CurrentMeleeBlockAttempts > 0)
{
p_target.FightHandler.CurrentMeleeBlockAttempts--;
}
}
public virtual Boolean CastSpell(Character p_sorcerer, Boolean p_fromScroll, Int32 p_scrollTier, List <Object> p_targets)
{
SpellEventArgs eventArgs = GetEventArgs();
eventArgs.DamageType = ESkillIDToEDamageType(m_staticData.SkillID);
m_didPushEntry = false;
m_fromScroll = p_fromScroll;
Single magicFactor = GetMagicFactor(p_sorcerer, p_fromScroll, p_scrollTier);
if (m_staticData.SkillID == ESkillID.SKILL_WARFARE)
{
p_sorcerer.BarkHandler.TriggerBark(EBarks.ABILITY, p_sorcerer);
}
if (m_staticData.Damage != null && (m_staticData.Damage.Length == 0 || m_staticData.Damage[0].Maximum == 0 || m_staticData.Damage[0].Type == EDamageType.HEAL))
{
eventArgs.Result = ESpellResult.OK;
if (m_staticData.RemovedConditions.Length == 0 || m_staticData.RemovedConditions[0] == ECondition.NONE)
{
p_sorcerer.FightHandler.FeedActionLog(new CastSpellEntryEventArgs(p_sorcerer, eventArgs));
m_didPushEntry = true;
}
}
HandleConditions(eventArgs, p_targets, magicFactor);
HandlePartyBuffs(eventArgs, magicFactor);
HandleMonsters(p_sorcerer, eventArgs, p_targets, magicFactor);
if (m_staticData.Damage != null && m_staticData.Damage.Length > 0 && m_staticData.Damage[0].Type == EDamageType.HEAL)
{
Int32 value = Damage.Create(m_staticData.Damage[0] * magicFactor, 0f).Value;
Int32 p_critHealValue = (Int32)(value * p_sorcerer.FightValues.MagicalCriticalDamageMod);
Single criticalMagicHitChance = p_sorcerer.FightValues.CriticalMagicHitChance;
HandlePartyMemberHealing(magicFactor, criticalMagicHitChance, p_critHealValue, eventArgs, p_targets);
}
else if (SpellType == ECharacterSpell.SPELL_LIGHT_LAY_ON_HANDS)
{
HandlePartyMemberHealing(magicFactor, 0f, 0, eventArgs, p_targets);
}
HandlePartyCharacters(p_sorcerer, eventArgs, p_targets, magicFactor);
if (!p_fromScroll && SpellType != ECharacterSpell.SPELL_PRIME_IDENTIFY)
{
UseResources(p_sorcerer);
}
eventArgs.Result = ESpellResult.OK;
if (m_staticData.SkillID != ESkillID.SKILL_WARFARE)
{
p_sorcerer.BarkHandler.TriggerBark(EBarks.SPELL, p_sorcerer);
}
p_sorcerer.CastSpellEvent(this, eventArgs);
if (!m_didPushEntry)
{
p_sorcerer.FightHandler.FeedActionLog(new CastSpellEntryEventArgs(p_sorcerer, eventArgs));
}
p_sorcerer.FightHandler.FlushActionLog();
return(true);
}
protected override void HandlePartyCharacters(Character p_sorcerer, SpellEventArgs p_result, List<Object> p_targets, Single p_magicFactor)
{
base.HandlePartyCharacters(p_sorcerer, p_result, p_targets, p_magicFactor);
foreach (Object obj in p_targets)
{
if (obj is Character)
{
p_result.SpellTargets.Add(new SpellTarget(obj));
}
}
}
protected override void HandlePartyCharacters(Character p_caster, SpellEventArgs p_result, List <Object> p_targets, Single p_magicFactor)
{
for (Int32 i = 0; i < p_targets.Count; i++)
{
Character character = p_targets[i] as Character;
if (character != null)
{
character.FightHandler.InterceptingCharacter = p_caster;
}
}
}
protected virtual void HandleMonsters(Character p_sorcerer, SpellEventArgs p_result, List <Object> p_targets, Single p_magicFactor)
{
for (Int32 i = 0; i < p_targets.Count; i++)
{
Monster monster = p_targets[i] as Monster;
if (monster != null)
{
if (monster.IsAttackable)
{
if (m_staticData.SkillID == ESkillID.SKILL_WARFARE)
{
if (m_staticData.TargetType == ETargetType.SINGLE_MONSTER || m_staticData.TargetType == ETargetType.ALL_ADJACENT_MONSTERS)
{
List <AttackResult> list = MeleeAttackMonster(p_sorcerer, monster);
if (list == null)
{
goto IL_144;
}
if (list.Count == 0)
{
monster.HitAnimationDone.Trigger();
}
Boolean flag = false;
foreach (AttackResult attackResult in list)
{
if (attackResult.Result != EResultType.EVADE && attackResult.Result != EResultType.BLOCK)
{
flag = true;
break;
}
}
if (!flag)
{
goto IL_144;
}
}
}
else
{
AttackResult attackResult2 = DoAttackMonster(p_sorcerer, monster, p_magicFactor);
p_result.SpellTargets.Add(new AttackedTarget(monster, attackResult2));
if (attackResult2.Result == EResultType.EVADE || attackResult2.Result == EResultType.IMMUNE)
{
goto IL_144;
}
monster.ApplyDamages(attackResult2, p_sorcerer);
}
}
HandleMonsterBuffs(p_sorcerer, p_result, monster, p_magicFactor);
}
IL_144 :;
}
}
private void OnMonsterCastSpell(Object p_sender, EventArgs p_args)
{
SpellEventArgs spellEventArgs = (SpellEventArgs)p_args;
foreach (AttackedTarget attackedTarget in spellEventArgs.SpellTargetsOfType <AttackedTarget>())
{
if (attackedTarget.Target == m_character && attackedTarget.Result != null)
{
ShowDamageTextAndAnimationAndPlaySound(attackedTarget.Result, false, false, spellEventArgs.DamageType != EDamageType.PHYSICAL);
}
}
}
private void OnMonsterCastSpell(Object p_sender, EventArgs p_args)
{
SpellEventArgs spellEventArgs = (SpellEventArgs)p_args;
foreach (AttackedTarget attackedTarget in spellEventArgs.SpellTargetsOfType <AttackedTarget>())
{
if (spellEventArgs.Spell.NameKey != "MONSTER_SPELL_LIQUID_MEMBRANE")
{
ShowHitEffect((Monster)p_sender);
}
}
}
public override void DoEffect(Monster p_monster, Character p_target, SpellEventArgs p_spellArgs)
{
Grid grid = LegacyLogic.Instance.MapLoader.Grid;
Position position = p_monster.Position;
GridSlot slot = grid.GetSlot(position);
Int32 num;
if (LegacyLogic.Instance.WorldManager.Party.InCombat)
{
num = Random.Range(0, 4);
}
else
{
List <GridSlot> list = new List <GridSlot>();
for (Int32 i = 0; i < 4; i++)
{
GridSlot slot2 = grid.GetSlot(position + (EDirection)i);
if (slot2 != null && p_monster.CanPassTerrain(slot2.TerrainType))
{
list.Add(slot2);
}
}
list.Sort((GridSlot a, GridSlot b) => Position.Distance(a.Position, LegacyLogic.Instance.WorldManager.Party.Position).CompareTo(Position.Distance(b.Position, LegacyLogic.Instance.WorldManager.Party.Position)));
num = (Int32)EDirectionFunctions.GetDirection(position, list[0].Position);
}
EDirection p_dir = (EDirection)num;
if (grid.AddMovingEntity(position + p_dir, p_monster))
{
slot.RemoveEntity(p_monster);
}
else
{
Int32 num2 = num - 1;
while (num != num2)
{
if (num2 < 0)
{
num2 = 3;
}
if (grid.AddMovingEntity(position + (EDirection)num2, p_monster))
{
slot.RemoveEntity(p_monster);
break;
}
num2--;
}
}
if (position != p_monster.Position && LegacyLogic.Instance.WorldManager.Party.SelectedMonster == p_monster)
{
LegacyLogic.Instance.WorldManager.Party.SelectedMonster = null;
}
}
/// <summary>
/// Grants EoC for casting spells
/// </summary>
private static void OnSpellEvent(SpellEventArgs args)
{
int eoc = 0;
Spell spell = args.Spell;
if (spell is MagerySpell)
{
eoc = (1 * ((int)((MagerySpell)spell).Circle + 1));
}
args.Player.EssenceOfCharacter += eoc;
}
protected override void HandleMonsterBuffs(Character p_sorcerer, SpellEventArgs p_result, Monster p_target, Single p_magicFactor)
{
if (!p_target.AbilityHandler.HasAbility(EMonsterAbilityType.LARGE))
{
base.HandleMonsterBuffs(p_sorcerer, p_result, p_target, p_magicFactor);
}
else
{
MonsterAbilityBase ability = p_target.AbilityHandler.GetAbility(EMonsterAbilityType.LARGE);
AbilityTriggeredEventArgs p_args = new AbilityTriggeredEventArgs(p_target, ability);
p_target.AbilityHandler.AddEntry(ability.ExecutionPhase, p_args);
}
}
public static void InvokeSpellFinished( SpellEventArgs args )
{
if( SpellFinished != null )
SpellFinished(args);
}
