public static ReturnTypes spell_attack(int sn, int level, CharacterInstance ch, object vo)
{
var skill = RepositoryManager.Instance.SKILLS.Get(sn);
var vch = (CharacterInstance)vo;
var saved = skill.CheckSave(level, ch, vch);
if (CheckFunctions.CheckIfTrueCasting(
saved && Macros.SPELL_SAVE(skill) == (int)SpellSaveEffectTypes.Negate, skill, ch,
CastingFunctionType.Failed, vch))
{
return(ReturnTypes.SpellFailed);
}
var damage = GetBaseDamage(level, ch, skill);
if (saved)
{
var spellSaveType =
EnumerationExtensions.GetEnum <SpellSaveEffectTypes>(Macros.SPELL_SAVE(skill));
switch (spellSaveType)
{
case SpellSaveEffectTypes.ThreeQuartersDamage:
damage = GetThreeQuartersDamage(damage);
break;
case SpellSaveEffectTypes.HalfDamage:
damage = GetHalfDamage(damage);
break;
case SpellSaveEffectTypes.QuarterDamage:
damage = GetQuarterDamage(damage);
break;
case SpellSaveEffectTypes.EighthDamage:
damage = GetEighthDamage(damage);
break;
case SpellSaveEffectTypes.Absorb:
AbsorbDamage(ch, skill, vch, damage);
return(ReturnTypes.None);
case SpellSaveEffectTypes.Reflect:
return(spell_attack(sn, level, vch, ch));
}
}
var retcode = ch.CauseDamageTo(vch, damage, sn);
if (retcode == ReturnTypes.None &&
!ch.CharDied() && !vch.CharDied()
&&
(!vch.IsAffectedBy(sn) || skill.Flags.IsSet(SkillFlags.Accumulative) ||
skill.Flags.IsSet(SkillFlags.ReCastable)))
{
retcode = AffectCharacter.spell_affectchar(sn, level, ch, vch);
}
return(retcode);
}
public static ReturnTypes spell_cure_blindness(int sn, int level, CharacterInstance ch, object vo)
{
var victim = (CharacterInstance)vo;
var skill = RepositoryManager.Instance.GetEntity <SkillData>(sn);
ch.SetColor(ATTypes.AT_MAGIC);
if (CheckFunctions.CheckIfTrueCasting(victim.IsImmune(ResistanceTypes.Magic), skill, ch,
CastingFunctionType.Immune, victim))
{
return(ReturnTypes.SpellFailed);
}
if (CheckFunctions.CheckIfTrue(ch, ch.IsAffected(AffectedByTypes.Blind),
ch != victim
? "You work your cure, but it has no apparent effect."
: "You don't seem to be blind."))
{
return(ReturnTypes.SpellFailed);
}
victim.StripAffects((int)AffectedByTypes.Blind);
victim.SetColor(ATTypes.AT_MAGIC);
victim.SendTo("Your vision returns!");
if (ch != victim)
{
ch.SendTo("You work your cure, restoring vision.");
}
return(ReturnTypes.None);
}
public static ReturnTypes spell_change_sex(int sn, int level, CharacterInstance ch, object vo)
{
var victim = (CharacterInstance)vo;
var skill = RepositoryManager.Instance.GetEntity <SkillData>(sn);
if (CheckFunctions.CheckIfTrueCasting(victim.IsImmune(ResistanceTypes.Magic), skill, ch,
CastingFunctionType.Immune, victim))
{
return(ReturnTypes.SpellFailed);
}
if (CheckFunctions.CheckIfTrueCasting(victim.IsAffectedBy(sn), skill, ch, CastingFunctionType.Failed, victim))
{
return(ReturnTypes.SpellFailed);
}
var af = new AffectData
{
SkillNumber = sn,
Duration = GetDuration(level),
Location = ApplyTypes.Gender
};
do
{
af.Modifier = SmaugRandom.Between(0, 2) - (int)victim.Gender;
} while (af.Modifier == 0);
victim.AddAffect(af);
ch.SuccessfulCast(skill, victim);
return(ReturnTypes.None);
}
public static ReturnTypes spell_curse(int sn, int level, CharacterInstance ch, object vo)
{
var victim = (CharacterInstance)vo;
var skill = RepositoryManager.Instance.GetEntity <SkillData>(sn);
if (CheckFunctions.CheckIfTrueCasting(victim.Immunity.IsSet(ResistanceTypes.Magic), skill, ch,
CastingFunctionType.Immune, victim))
{
return(ReturnTypes.SpellFailed);
}
if (CheckFunctions.CheckIfTrueCasting(victim.IsAffected(AffectedByTypes.Curse) ||
victim.SavingThrows.CheckSaveVsSpellStaff(level, victim), skill, ch,
CastingFunctionType.Failed, victim))
{
return(ReturnTypes.SpellFailed);
}
AddAffectToTarget(ch, sn, level, ApplyTypes.HitRoll);
AddAffectToTarget(victim, sn, level, ApplyTypes.SaveVsSpell);
victim.SetColor(ATTypes.AT_MAGIC);
victim.SendTo("You feel unclean.");
if (ch != victim)
{
comm.act(ATTypes.AT_MAGIC, "You utter a curse upon $N.", ch, null, victim, ToTypes.Character);
comm.act(ATTypes.AT_MAGIC, "$n utters a curse upon $N.", ch, null, victim, ToTypes.NotVictim);
}
return(ReturnTypes.None);
}
public static ReturnTypes spell_area_attack(int sn, int level, CharacterInstance ch, object vo)
{
var skill = RepositoryManager.Instance.SKILLS.Get(sn);
if (CheckFunctions.CheckIfTrueCasting(ch.CurrentRoom.Flags.IsSet(RoomFlags.Safe), skill, ch))
{
return(ReturnTypes.SpellFailed);
}
if (string.IsNullOrEmpty(skill.HitCharacterMessage))
{
comm.act(ATTypes.AT_MAGIC, skill.HitCharacterMessage, ch, null, null, ToTypes.Character);
}
if (string.IsNullOrEmpty(skill.HitRoomMessage))
{
comm.act(ATTypes.AT_MAGIC, skill.HitRoomMessage, ch, null, null, ToTypes.Room);
}
foreach (var vch in ch.CurrentRoom.Persons
.Where(x => x.IsNpc() || !x.Act.IsSet((int)PlayerFlags.WizardInvisibility) ||
((PlayerInstance)x).PlayerData.WizardInvisible < LevelConstants.ImmortalLevel)
.Where(x => x != ch)
.Where(x => !fight.is_safe(ch, x, false))
.Where(x => ch.IsNpc() || x.IsNpc() || ch.IsInArena() || (ch.IsPKill() && x.IsPKill())))
{
var saved = skill.CheckSave(level, ch, vch);
if (saved &&
CheckFunctions.CheckIfTrueCasting(Macros.SPELL_SAVE(skill) == (int)SpellSaveEffectTypes.Negate,
skill, ch, CastingFunctionType.Failed, vch))
{
continue;
}
var damage = GetBaseDamage(level, ch, skill);
if (saved)
{
damage = GetDamageIfSaved(sn, level, ch, skill, vch, damage);
}
var retcode = ch.CauseDamageTo(vch, damage, sn);
if (retcode == ReturnTypes.None &&
!ch.CharDied() && !vch.CharDied()
&&
(!vch.IsAffectedBy(sn) || skill.Flags.IsSet(SkillFlags.Accumulative) ||
skill.Flags.IsSet(SkillFlags.ReCastable)))
{
retcode = AffectCharacter.spell_affectchar(sn, level, ch, vch);
}
if (retcode == ReturnTypes.CharacterDied || ch.CharDied())
{
break;
}
}
return(ReturnTypes.None);
}
public static ReturnTypes spell_obj_inv(int sn, int level, CharacterInstance ch, object vo)
{
var obj = (ObjectInstance)vo;
var skill = RepositoryManager.Instance.SKILLS.Get(sn);
var cell = WeatherManager.Instance.GetWeather(ch.CurrentRoom.Area);
if (CheckFunctions.CheckIfNullObjectCasting(obj, skill, ch))
{
return(ReturnTypes.None);
}
switch (Macros.SPELL_ACTION(skill))
{
case (int)SpellActTypes.Create:
if (skill.Flags.IsSet(SkillFlags.Water))
{
return(CreateWaterSpellAction(skill, level, ch, obj, cell));
}
if (Macros.SPELL_DAMAGE(skill) == (int)SpellDamageTypes.Fire)
{
return(BurnObjectSpellAction(skill, ch, obj));
}
if (Macros.SPELL_DAMAGE(skill) == (int)SpellDamageTypes.Poison ||
Macros.SPELL_CLASS(skill) == (int)SpellClassTypes.Death)
{
return(PoisonOrDeathSpellAction(skill, ch, obj));
}
if (Macros.SPELL_CLASS(skill) == (int)SpellClassTypes.Life
&&
(obj.ItemType == ItemTypes.Food || obj.ItemType == ItemTypes.Cook ||
obj.ItemType == ItemTypes.DrinkContainer))
{
return(PurifySpellAction(skill, ch, obj));
}
return(CheckFunctions.CheckIfTrueCasting(Macros.SPELL_CLASS(skill) != (int)SpellClassTypes.None,
skill, ch, CastingFunctionType.Failed, null, obj)
? ReturnTypes.None
: CloneObjectSpellAction(skill, level, ch, obj));
case (int)SpellActTypes.Obscure:
return(ObscureSpellAction(skill, level, ch, obj));
case (int)SpellActTypes.Destroy:
case (int)SpellActTypes.Resist:
case (int)SpellActTypes.Suscept:
case (int)SpellActTypes.Divinate:
return(OtherSpellAction(skill, ch, obj));
}
return(ReturnTypes.None);
}
private static ReturnTypes ObscureSpellAction(SkillData skill, int level, CharacterInstance ch, ObjectInstance obj)
{
var percent = !string.IsNullOrEmpty(skill.Dice) ? magic.ParseDiceExpression(ch, skill.Dice) : 20;
if (CheckFunctions.CheckIfTrueCasting(
obj.ExtraFlags.IsSet((int)ItemExtraFlags.Invisible) || ch.Chance(percent), skill, ch))
{
return(ReturnTypes.SpellFailed);
}
ch.SuccessfulCast(skill, null, obj);
obj.ExtraFlags.SetBit((int)ItemExtraFlags.Invisible);
return(ReturnTypes.None);
}
private static ReturnTypes CloneObjectSpellAction(SkillData skill, int level, CharacterInstance ch, ObjectInstance obj)
{
switch (Macros.SPELL_POWER(skill))
{
case (int)SpellPowerTypes.Minor:
if (CheckFunctions.CheckIfTrueCasting(
(ch.Level - obj.Level < 20) || (obj.Cost > ch.Level * ch.GetCurrentIntelligence() / 5),
skill, ch, CastingFunctionType.Failed, null, obj))
{
return(ReturnTypes.None);
}
break;
case (int)SpellPowerTypes.Greater:
if (CheckFunctions.CheckIfTrueCasting((ch.Level - obj.Level < 5) ||
(obj.Cost > ch.Level * 10 * ch.GetCurrentIntelligence() * ch.GetCurrentWisdom()),
skill, ch, CastingFunctionType.Failed, null, obj))
{
return(ReturnTypes.None);
}
break;
case (int)SpellPowerTypes.Major:
if (CheckFunctions.CheckIfTrueCasting((ch.Level - obj.Level < 0) ||
(obj.Cost > ch.Level * 50 * ch.GetCurrentIntelligence() * ch.GetCurrentWisdom()),
skill, ch, CastingFunctionType.Failed, null, obj))
{
return(ReturnTypes.None);
}
ObjectInstance clonedObj = null; // TODO Clone ObjectInstance
clonedObj.Timer = !string.IsNullOrEmpty(skill.Dice) ? magic.ParseDiceExpression(ch, skill.Dice) : 0;
clonedObj.AddTo(ch);
ch.SuccessfulCast(skill, null, obj);
break;
default:
if (CheckFunctions.CheckIfTrueCasting((ch.Level - obj.Level < 10) ||
(obj.Cost > ch.Level * ch.GetCurrentIntelligence() * ch.GetCurrentWisdom()),
skill, ch, CastingFunctionType.Failed, null, obj))
{
return(ReturnTypes.None);
}
break;
}
return(ReturnTypes.None);
}
public static ReturnTypes spell_astral_walk(int sn, int level, CharacterInstance ch, object vo)
{
var skill = RepositoryManager.Instance.GetEntity <SkillData>(sn);
var victim = ch.GetCharacterInWorld(Cast.TargetName);
if (CheckFunctions.CheckIfTrueCasting(victim == null ||
!ch.CanAstral(victim) ||
!victim.CurrentRoom.Area.IsInHardRange(ch), skill, ch,
CastingFunctionType.Failed, victim))
{
return(ReturnTypes.SpellFailed);
}
if (!string.IsNullOrEmpty(skill.HitCharacterMessage))
{
comm.act(ATTypes.AT_MAGIC, skill.HitCharacterMessage, ch, null, victim, ToTypes.Character);
}
if (!string.IsNullOrEmpty(skill.HitVictimMessage))
{
comm.act(ATTypes.AT_MAGIC, skill.HitVictimMessage, ch, null, victim, ToTypes.Victim);
}
if (!string.IsNullOrEmpty(skill.HitRoomMessage))
{
comm.act(ATTypes.AT_MAGIC, skill.HitRoomMessage, ch, null, victim, ToTypes.NotVictim);
}
else
{
comm.act(ATTypes.AT_MAGIC, "$n disappears in a flash of light!", ch, null, victim, ToTypes.Room);
}
ch.CurrentRoom.RemoveFrom(ch);
victim.CurrentRoom.AddTo(ch);
if (!string.IsNullOrEmpty(skill.HitDestinationMessage))
{
comm.act(ATTypes.AT_MAGIC, skill.HitDestinationMessage, ch, null, victim, ToTypes.NotVictim);
}
else
{
comm.act(ATTypes.AT_MAGIC, "$n appears in a flash of light!", ch, null, victim, ToTypes.Room);
}
Look.do_look(ch, "auto");
return(ReturnTypes.None);
}
public static ReturnTypes spell_earthquake(int sn, int level, CharacterInstance ch, object vo)
{
var skill = RepositoryManager.Instance.GetEntity <SkillData>(sn);
if (CheckFunctions.CheckIfTrueCasting(ch.CurrentRoom.Flags.IsSet(RoomFlags.Safe), skill, ch))
{
return(ReturnTypes.SpellFailed);
}
comm.act(ATTypes.AT_MAGIC, "The earth trembles beneath your feet!", ch, null, null, ToTypes.Character);
comm.act(ATTypes.AT_MAGIC, "$n makes the earth tremble and shiver", ch, null, null, ToTypes.Room);
var charDied = false;
// TODO Don't display to everyone in the world, thats dumb
return(charDied ? ReturnTypes.CharacterDied : ReturnTypes.None);
}
private static ReturnTypes CastSingleTargetSpell(SkillData skill, int level, CharacterInstance ch, CharacterInstance victim)
{
if (CheckFunctions.CheckIfNullObjectCasting(victim, skill, ch))
{
return(ReturnTypes.SpellFailed);
}
if (CheckFunctions.CheckIfTrueCasting(
(skill.Type != SkillTypes.Herb && victim.Immunity.IsSet(ResistanceTypes.Magic))
||
victim.IsImmune(
EnumerationExtensions.GetEnum <ResistanceTypes>(Macros.SPELL_DAMAGE(skill))),
skill, ch, CastingFunctionType.Immune, victim))
{
return(ReturnTypes.SpellFailed);
}
if (CheckFunctions.CheckIfTrueCasting(
victim.IsAffectedBy((int)skill.ID) && !skill.Flags.IsSet(SkillFlags.Accumulative) &&
!skill.Flags.IsSet(SkillFlags.ReCastable), skill, ch, CastingFunctionType.Failed, victim))
{
return(ReturnTypes.SpellFailed);
}
var saf = skill.Affects.FirstOrDefault();
if (CheckFunctions.CheckIfTrueCasting(saf != null && saf.Location == (int)ApplyTypes.StripSN &&
!victim.IsAffectedBy(magic.ParseDiceExpression(ch, saf.Modifier)),
skill, ch, CastingFunctionType.Failed, victim))
{
return(ReturnTypes.SpellFailed);
}
return(CheckFunctions.CheckIfTrueCasting(skill.CheckSave(level, ch, victim), skill, ch,
CastingFunctionType.Failed, victim)
? ReturnTypes.SpellFailed
: ReturnTypes.None);
}
public static ReturnTypes spell_dispel_evil(int sn, int level, CharacterInstance ch, object vo)
{
var victim = (CharacterInstance)vo;
var skill = RepositoryManager.Instance.GetEntity <SkillData>(sn);
if (!ch.IsNpc() && ch.IsEvil())
{
victim = ch;
}
if (victim.IsGood())
{
comm.act(ATTypes.AT_MAGIC, "Thoric protects $N.", ch, null, victim, ToTypes.Room);
return(ReturnTypes.SpellFailed);
}
if (victim.IsNeutral())
{
comm.act(ATTypes.AT_MAGIC, "$N does not seem to be affected.", ch, null, victim, ToTypes.Character);
return(ReturnTypes.SpellFailed);
}
if (CheckFunctions.CheckIfTrueCasting(victim.IsImmune(ResistanceTypes.Magic), skill, ch,
CastingFunctionType.Immune, victim))
{
return(ReturnTypes.SpellFailed);
}
var damage = SmaugRandom.Roll(level, 4);
if (victim.SavingThrows.CheckSaveVsSpellStaff(level, victim))
{
damage /= 2;
}
return(ch.CauseDamageTo(victim, damage, sn));
}
public static ReturnTypes spell_dispel_magic(int sn, int level, CharacterInstance ch, object vo)
{
var victim = (CharacterInstance)vo;
var skill = RepositoryManager.Instance.GetEntity <SkillData>(sn);
ch.SetColor(ATTypes.AT_MAGIC);
if (CheckFunctions.CheckIfTrueCasting(victim.Immunity.IsSet(ResistanceTypes.Magic), skill, ch, CastingFunctionType.Immune, victim))
{
return(ReturnTypes.SpellFailed);
}
if (CheckFunctions.CheckIfTrueCasting(victim.IsNpc() && victim.IsAffected(AffectedByTypes.Possess), skill,
ch, CastingFunctionType.Immune, victim))
{
return(ReturnTypes.SpellFailed);
}
if (ch == victim)
{
return(DispelSelf(ch, victim));
}
var isMage = ch.IsNpc() || ch.CurrentClass == ClassTypes.Mage;
if (!isMage && !ch.IsAffected(AffectedByTypes.DetectMagic))
{
ch.SendTo("You don't sense a magical aura to dispel.");
return(ReturnTypes.Error);
}
int chance = ch.GetCurrentIntelligence() - victim.GetCurrentIntelligence();
if (isMage)
{
chance += 5;
}
else
{
chance -= 15;
}
bool twice = false, three = false;
if (SmaugRandom.D100() > 75 - chance)
{
twice = true;
if (SmaugRandom.D100() > 75 - chance)
{
three = true;
}
}
bool continueOuterLoop = true;
int affectedBy;
bool found = false;
int cnt = 0, times = 0;
while (continueOuterLoop)
{
AffectData paf = null;
// grab affected_by from mobs first
if (victim.IsNpc() && victim.AffectedBy.IsEmpty())
{
for (; ;)
{
affectedBy = SmaugRandom.Between(0, EnumerationFunctions.MaximumEnumValue <AffectedByTypes>() - 1);
if (victim.IsAffectedBy(affectedBy))
{
found = true;
break;
}
if (cnt++ > 30)
{
found = false;
break;
}
}
// is it a spell?
if (found)
{
foreach (var af in victim.Affects)
{
paf = af;
if (paf.Type.IsSet(affectedBy))
{
break;
}
}
// its a spell, remove it
if (paf != null)
{
if (level < victim.Level || victim.SavingThrows.CheckSaveVsSpellStaff(level, victim))
{
if (magic.dispel_casting(paf, ch, victim, 0, false) != 0)
{
ch.FailedCast(skill, victim);
}
return(ReturnTypes.SpellFailed);
}
if (skill.Flags.IsSet(SkillFlags.NoDispel))
{
if (magic.dispel_casting(paf, ch, victim, 0, false) != 0 && times == 0)
{
ch.FailedCast(skill, victim);
}
return(ReturnTypes.SpellFailed);
}
if (magic.dispel_casting(paf, ch, victim, 0, true) != 0 && times == 0)
{
ch.SuccessfulCast(skill, victim);
}
victim.RemoveAffect(paf);
if ((twice && times < 1) || (three && times < 2))
{
times++;
continue;
}
return(ReturnTypes.None);
}
// not a spell, just remove the bit (for mobs only)
else
{
if (level < victim.Level || victim.SavingThrows.CheckSaveVsSpellStaff(level, victim))
{
if (magic.dispel_casting(null, ch, victim, affectedBy, false) != 0)
{
ch.FailedCast(skill, victim);
}
return(ReturnTypes.SpellFailed);
}
if (magic.dispel_casting(null, ch, victim, affectedBy, true) != 0 && times == 0)
{
ch.SuccessfulCast(skill, victim);
}
victim.AffectedBy.RemoveBit(affectedBy);
if ((twice && times < 1) || (three && times < 2))
{
times++;
continue;
}
return(ReturnTypes.None);
}
}
}
// mob has no affectedBys or we didn't catch them
if (!victim.Affects.Any())
{
ch.FailedCast(skill, victim);
return(ReturnTypes.SpellFailed);
}
// randomize the affects
cnt = victim.Affects.Count;
paf = victim.Affects.First();
int affectNum;
int i = 0;
for (affectNum = SmaugRandom.Between(0, cnt - 1); affectNum > 0; affectNum--)
{
paf = victim.Affects.ToList()[i];
}
if (level < victim.Level || victim.SavingThrows.CheckSaveVsSpellStaff(level, victim))
{
if (magic.dispel_casting(paf, ch, victim, 0, false) != 0)
{
ch.FailedCast(skill, victim);
}
return(ReturnTypes.SpellFailed);
}
// make sure we have an affect and it isn't a dispel
if (paf == null || paf.Type.IsSet(SkillFlags.NoDispel))
{
if (magic.dispel_casting(paf, ch, victim, 0, false) != 0)
{
ch.FailedCast(skill, victim);
}
return(ReturnTypes.SpellFailed);
}
if (magic.dispel_casting(null, ch, victim, 0, true) != 0 && times == 0)
{
ch.SuccessfulCast(skill, victim);
}
victim.RemoveAffect(paf);
if ((twice && times < 1) || (three && times < 2))
{
times++;
continue;
}
}
if (!victim.IsNpc())
{
victim.update_aris();
}
return(ReturnTypes.None);
}
public static ReturnTypes ObjectCastSpell(this CharacterInstance ch, int sn, int level,
CharacterInstance victim = null, ObjectInstance obj = null)
{
var skill = RepositoryManager.Instance.GetEntity <SkillData>(sn);
if (skill?.SpellFunction == null)
{
return(ReturnTypes.Error);
}
if (ch.CurrentRoom.Flags.IsSet(RoomFlags.NoMagic) ||
(ch.CurrentRoom.Flags.IsSet(RoomFlags.Safe) &&
skill.Target == TargetTypes.OffensiveCharacter))
{
ch.SetColor(ATTypes.AT_MAGIC);
ch.SendTo("Nothing seems to happen...");
return(ReturnTypes.None);
}
// Reduces the number of level 5 players using level 40 scrolls in battle
var levelDiff = ch.Level - level;
if ((skill.Target == TargetTypes.OffensiveCharacter || SmaugRandom.Bits(7) == 1) &&
skill.Type != SkillTypes.Herb &&
ch.Chance(95 + levelDiff))
{
switch (SmaugRandom.Bits(2))
{
case 0:
case 2:
ch.FailedCast(skill, victim);
break;
case 1:
case 3:
comm.act(ATTypes.AT_MAGIC, "The $t spell backfires!", ch, skill.Name, victim, ToTypes.Character);
if (victim != null)
{
comm.act(ATTypes.AT_MAGIC, "$n's $t spell backfires!", ch, skill.Name, victim,
ToTypes.Victim);
}
comm.act(ATTypes.AT_MAGIC, "$n's $t spell backfires!", ch, skill.Name, victim, ToTypes.Room);
return(ch.CauseDamageTo(ch, SmaugRandom.Between(1, level), Program.TYPE_UNDEFINED));
}
return(ReturnTypes.None);
}
object vo;
switch (skill.Target)
{
default:
LogManager.Instance.Bug("Bad target for sn {0}", sn);
return(ReturnTypes.Error);
case TargetTypes.Ignore:
vo = null;
if (victim != null)
{
Cast.TargetName = victim.Name;
}
else if (obj != null)
{
Cast.TargetName = obj.Name;
}
break;
case TargetTypes.OffensiveCharacter:
if (victim != ch)
{
if (victim == null)
{
victim = ch.GetMyTarget();
}
if (CheckFunctions.CheckIfTrue(ch, victim == null || (!victim.IsNpc() && !victim.IsInArena()),
"You can't do that."))
{
return(ReturnTypes.None);
}
}
if (ch != victim && fight.is_safe(ch, victim, true))
{
return(ReturnTypes.None);
}
vo = victim;
break;
case TargetTypes.DefensiveCharacter:
if (victim == null)
{
victim = ch;
}
vo = victim;
if (CheckFunctions.CheckIfTrueCasting(
skill.Type != SkillTypes.Herb && victim.Immunity.IsSet(ResistanceTypes.Magic),
skill, ch, CastingFunctionType.Immune, victim))
{
return(ReturnTypes.None);
}
break;
case TargetTypes.Self:
vo = ch;
if (CheckFunctions.CheckIfTrueCasting(
skill.Type != SkillTypes.Herb && ch.Immunity.IsSet(ResistanceTypes.Magic),
skill, ch, CastingFunctionType.Immune, victim))
{
return(ReturnTypes.None);
}
break;
case TargetTypes.InventoryObject:
if (CheckFunctions.CheckIfNullObject(ch, obj, "You can't do that!"))
{
return(ReturnTypes.None);
}
vo = obj;
break;
}
var start = DateTime.Now;
var retcode = skill.SpellFunction.Value.Invoke(sn, level, ch, vo);
skill.UseHistory.Use(ch, DateTime.Now.Subtract(start));
if (retcode == ReturnTypes.SpellFailed)
{
retcode = ReturnTypes.None;
}
if (retcode == ReturnTypes.CharacterDied || retcode == ReturnTypes.Error)
{
return(retcode);
}
if (ch.CharDied())
{
return(ReturnTypes.CharacterDied);
}
if (skill.Target == TargetTypes.OffensiveCharacter &&
victim != ch &&
!victim.CharDied())
{
foreach (
var vch in
ch.CurrentRoom.Persons.Where(
vch => victim == vch && vch.CurrentFighting == null && vch.Master != ch))
{
retcode = fight.multi_hit(vch, ch, Program.TYPE_UNDEFINED);
break;
}
}
return(retcode);
}
public static ReturnTypes spell_solar_flight(int sn, int level, CharacterInstance ch, object vo)
{
var skill = RepositoryManager.Instance.GetEntity <SkillData>(sn);
var cell = WeatherManager.Instance.GetWeather(ch.CurrentRoom.Area);
var victim = ch.GetCharacterInWorld(Cast.TargetName);
var lvl = GetModdedLevel(level);
if (CheckFunctions.CheckIfTrueCasting(victim == null || victim == ch, skill, ch, CastingFunctionType.Failed,
victim))
{
return(ReturnTypes.SpellFailed);
}
if (CheckFunctions.CheckIfTrueCasting(GameManager.Instance.GameTime.Hour > 18 ||
GameManager.Instance.GameTime.Hour < 8, skill, ch, CastingFunctionType.Failed, victim))
{
return(ReturnTypes.SpellFailed);
}
if (CheckFunctions.CheckIfNullObjectCasting(victim.CurrentRoom, skill, ch, CastingFunctionType.Failed,
victim))
{
return(ReturnTypes.SpellFailed);
}
if (CheckFunctions.CheckIfTrueCasting(!ch.IsOutside() && !victim.IsOutside(), skill, ch,
CastingFunctionType.Failed, victim))
{
return(ReturnTypes.SpellFailed);
}
if (CheckFunctions.CheckIfTrueCasting(cell.CloudCover >= 20, skill, ch, CastingFunctionType.Failed, victim))
{
return(ReturnTypes.SpellFailed);
}
if (CheckFunctions.CheckIfTrueCasting(AreInvalidRoomFlagsSet(victim.CurrentRoom), skill, ch,
CastingFunctionType.Failed, victim))
{
return(ReturnTypes.SpellFailed);
}
if (CheckFunctions.CheckIfTrueCasting(ch.CurrentRoom.Flags.IsSet(RoomFlags.NoRecall), skill, ch,
CastingFunctionType.Failed, victim))
{
return(ReturnTypes.SpellFailed);
}
if (CheckFunctions.CheckIfTrueCasting(victim.Level >= lvl, skill, ch, CastingFunctionType.Failed, victim))
{
return(ReturnTypes.SpellFailed);
}
if (CheckFunctions.CheckIfTrueCasting(victim.CanPKill() && !ch.IsNpc() && !ch.IsPKill(), skill, ch,
CastingFunctionType.Failed, victim))
{
return(ReturnTypes.SpellFailed);
}
if (CheckFunctions.CheckIfTrueCasting(victim.IsNpc() &&
victim.SavingThrows.CheckSaveVsSpellStaff(level, victim), skill, ch, CastingFunctionType.Failed,
victim))
{
return(ReturnTypes.SpellFailed);
}
if (CheckFunctions.CheckIfTrueCasting(!victim.CurrentRoom.Area.IsInHardRange(ch), skill, ch,
CastingFunctionType.Failed, victim))
{
return(ReturnTypes.SpellFailed);
}
if (CheckFunctions.CheckIfTrueCasting(
victim.CurrentRoom.Area.Flags.IsSet(AreaFlags.NoPlayerVsPlayer) && ch.IsPKill(), skill, ch,
CastingFunctionType.Failed, victim))
{
return(ReturnTypes.SpellFailed);
}
comm.act(ATTypes.AT_MAGIC, "$n disappears in a blinding flash of light!", ch, null, null, ToTypes.Room);
ch.CurrentRoom.RemoveFrom(ch);
victim.CurrentRoom.AddTo(ch);
comm.act(ATTypes.AT_MAGIC, "$n appears in a blinding flash of light!", ch, null, null, ToTypes.Room);
Look.do_look(ch, "auto");
return(ReturnTypes.None);
}
public static ReturnTypes spell_charm_person(int sn, int level, CharacterInstance ch, object vo)
{
var victim = (CharacterInstance)vo;
var skill = RepositoryManager.Instance.GetEntity <SkillData>(sn);
if (CheckFunctions.CheckIfEquivalent(ch, ch, victim, "You like yourself even better!"))
{
return(ReturnTypes.SpellFailed);
}
if (CheckFunctions.CheckIfTrueCasting(victim.IsImmune(ResistanceTypes.Magic) ||
victim.IsImmune(ResistanceTypes.Charm), skill, ch, CastingFunctionType.Immune, victim))
{
return(ReturnTypes.SpellFailed);
}
if (!victim.IsNpc() && !ch.IsNpc())
{
ch.SendTo("I don't think so...");
victim.SendTo("You feel charmed...");
return(ReturnTypes.SpellFailed);
}
var schance = victim.ModifySavingThrowWithResistance(level, ResistanceTypes.Charm);
if (victim.IsAffected(AffectedByTypes.Charm) ||
schance == 1000 ||
ch.IsAffected(AffectedByTypes.Charm) ||
level < victim.Level ||
victim.IsCircleFollowing(ch) ||
!ch.CanCharm() ||
victim.SavingThrows.CheckSaveVsSpellStaff(schance, victim))
{
ch.FailedCast(skill, victim);
return(ReturnTypes.SpellFailed);
}
if (victim.Master != null)
{
victim.StopFollower();
}
victim.AddFollower(ch);
var af = new AffectData
{
SkillNumber = sn,
Duration = GetDuration(level)
};
victim.AddAffect(af);
ch.SuccessfulCast(skill, victim);
if (!ch.IsNpc())
{
((PlayerInstance)ch).PlayerData.NumberOfCharmies++;
}
if (!victim.IsNpc())
{
return(ReturnTypes.None);
}
var mob = (MobileInstance)victim;
mob.StartHating(ch);
mob.StartHunting(ch);
return(ReturnTypes.None);
}
