mirror of
https://github.com/UOX3DevTeam/UOX3
synced 2026-08-13 12:27:04 -04:00
7a3f4c5144
Updated calculations of magic and/or poison resistance to also include magic and/or poison resistance from races
5635 lines
192 KiB
C++
5635 lines
192 KiB
C++
#include "uox3.h"
|
|
#include "magic.h"
|
|
#include "power.h"
|
|
#include "weight.h"
|
|
#include "cGuild.h"
|
|
#include "townregion.h"
|
|
#include "cRaces.h"
|
|
#include "cServerDefinitions.h"
|
|
#include "cMagic.h"
|
|
#include "skills.h"
|
|
#include "ssection.h"
|
|
#include "CJSMapping.h"
|
|
#include "cScript.h"
|
|
#include "cEffects.h"
|
|
#include "CPacketSend.h"
|
|
#include "classes.h"
|
|
#include "regions.h"
|
|
#include "combat.h"
|
|
#include "Dictionary.h"
|
|
#include "movement.h"
|
|
#include "scriptc.h"
|
|
#include "StringUtility.hpp"
|
|
#include "ObjectFactory.h"
|
|
#include <algorithm>
|
|
#include "osunique.hpp"
|
|
CMagic *Magic = nullptr;
|
|
|
|
#define SPELL_MAX 68 // use define for now; can make autocount later
|
|
|
|
// Look up spell-names from dictionary-files
|
|
const MagicTable_st magic_table[] = {
|
|
{ 593, (MAGIC_DEFN)&splClumsy },
|
|
{ 594, (MAGIC_DEFN)&splCreateFood },
|
|
{ 595, (MAGIC_DEFN)&splFeeblemind },
|
|
{ 596, (MAGIC_DEFN)&splHeal },
|
|
{ 597, (MAGIC_DEFN)&splMagicArrow },
|
|
{ 598, (MAGIC_DEFN)&splNightSight },
|
|
{ 599, (MAGIC_DEFN)&splReactiveArmor },
|
|
{ 600, (MAGIC_DEFN)&splWeaken },
|
|
{ 601, (MAGIC_DEFN)&splAgility },
|
|
{ 602, (MAGIC_DEFN)&splCunning },
|
|
{ 603, (MAGIC_DEFN)&splCure },
|
|
{ 604, (MAGIC_DEFN)&splHarm },
|
|
{ 605, (MAGIC_DEFN)&splMagicTrap },
|
|
{ 606, (MAGIC_DEFN)&splMagicUntrap },
|
|
{ 607, (MAGIC_DEFN)&splProtection },
|
|
{ 608, (MAGIC_DEFN)&splStrength },
|
|
{ 609, (MAGIC_DEFN)&splBless },
|
|
{ 610, (MAGIC_DEFN)&splFireball },
|
|
{ 611, (MAGIC_DEFN)&splMagicLock },
|
|
{ 612, (MAGIC_DEFN)&splPoison },
|
|
{ 613, (MAGIC_DEFN)&splTelekinesis },
|
|
{ 614, (MAGIC_DEFN)&splTeleport },
|
|
{ 615, (MAGIC_DEFN)&splUnlock },
|
|
{ 616, (MAGIC_DEFN)&splWallOfStone },
|
|
{ 617, (MAGIC_DEFN)&splArchCure },
|
|
{ 618, (MAGIC_DEFN)&splArchProtection },
|
|
{ 619, (MAGIC_DEFN)&splCurse },
|
|
{ 620, (MAGIC_DEFN)&splFireField },
|
|
{ 621, (MAGIC_DEFN)&splGreaterHeal },
|
|
{ 622, (MAGIC_DEFN)&splLightning },
|
|
{ 623, (MAGIC_DEFN)&splManaDrain },
|
|
{ 624, (MAGIC_DEFN)&splRecall },
|
|
{ 625, (MAGIC_DEFN)&splBladeSpirits },
|
|
{ 626, (MAGIC_DEFN)&splDispelField },
|
|
{ 627, (MAGIC_DEFN)&splIncognito },
|
|
{ 628, (MAGIC_DEFN)&splMagicReflection },
|
|
{ 629, (MAGIC_DEFN)&splMindBlast },
|
|
{ 630, (MAGIC_DEFN)&splParalyze },
|
|
{ 631, (MAGIC_DEFN)&splPoisonField },
|
|
{ 632, (MAGIC_DEFN)&splSummonCreature },
|
|
{ 633, (MAGIC_DEFN)&splDispel },
|
|
{ 634, (MAGIC_DEFN)&splEnergyBolt },
|
|
{ 635, (MAGIC_DEFN)&splExplosion },
|
|
{ 636, (MAGIC_DEFN)&splInvisibility },
|
|
{ 637, (MAGIC_DEFN)&splMark },
|
|
{ 638, (MAGIC_DEFN)&splMassCurse },
|
|
{ 639, (MAGIC_DEFN)&splParalyzeField },
|
|
{ 640, (MAGIC_DEFN)&splReveal },
|
|
{ 641, (MAGIC_DEFN)&splChainLightning },
|
|
{ 642, (MAGIC_DEFN)&splEnergyField },
|
|
{ 643, (MAGIC_DEFN)&splFlameStrike },
|
|
{ 644, (MAGIC_DEFN)&splGateTravel },
|
|
{ 645, (MAGIC_DEFN)&splManaVampire },
|
|
{ 646, (MAGIC_DEFN)&splMassDispel },
|
|
{ 647, (MAGIC_DEFN)&splMeteorSwarm },
|
|
{ 648, (MAGIC_DEFN)&splPolymorph },
|
|
{ 649, (MAGIC_DEFN)&splEarthquake },
|
|
{ 650, (MAGIC_DEFN)&splEnergyVortex },
|
|
{ 651, (MAGIC_DEFN)&splResurrection },
|
|
{ 652, (MAGIC_DEFN)&splSummonAir },
|
|
{ 653, (MAGIC_DEFN)&splSummonDaemon },
|
|
{ 654, (MAGIC_DEFN)&splSummonEarth },
|
|
{ 655, (MAGIC_DEFN)&splSummonFire },
|
|
{ 656, (MAGIC_DEFN)&splSummonWater },
|
|
{ 657, (MAGIC_DEFN)&splRandom },
|
|
{ 658, (MAGIC_DEFN)&splNecro1 },
|
|
{ 659, (MAGIC_DEFN)&splNecro2 },
|
|
{ 660, (MAGIC_DEFN)&splNecro3 },
|
|
{ 661, (MAGIC_DEFN)&splNecro4 },
|
|
{ 662, (MAGIC_DEFN)&splNecro5 },
|
|
{ 0, nullptr }
|
|
};
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - SpawnGate()
|
|
//| Date - 17th September, 2001
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - It will construct 2 linked gates, one at srcX / srcY / srcZ and another at trgX / trgY / trgZ
|
|
//o------------------------------------------------------------------------------------------------o
|
|
void SpawnGate( CChar *caster, SI16 srcX, SI16 srcY, SI08 srcZ, UI08 srcWorld, SI16 trgX, SI16 trgY, SI08 trgZ, UI08 trgWorld, UI16 trgInstanceId )
|
|
{
|
|
CItem *g1 = Items->CreateItem( nullptr, caster, 0x0F6C, 1, 0, OT_ITEM );
|
|
if( ValidateObject( g1 ))
|
|
{
|
|
g1->SetDecayable( true );
|
|
g1->SetType( IT_GATE );
|
|
g1->SetLocation( srcX, srcY, srcZ, srcWorld, g1->GetInstanceId() );
|
|
g1->SetDecayTime( cwmWorldState->ServerData()->BuildSystemTimeValue( tSERVER_GATE ));
|
|
g1->SetDir( 1 );
|
|
|
|
CItem *g2 = Items->CreateItem( nullptr, caster, 0x0F6C, 1, 0, OT_ITEM );
|
|
if( ValidateObject( g2 ))
|
|
{
|
|
g2->SetDecayable( true );
|
|
g2->SetType( IT_GATE );
|
|
g2->SetLocation( trgX, trgY, trgZ, trgWorld, trgInstanceId );
|
|
g2->SetDecayTime( cwmWorldState->ServerData()->BuildSystemTimeValue( tSERVER_GATE ));
|
|
g2->SetDir( 1 );
|
|
|
|
g2->SetTempVar( CITV_MOREX, g1->GetSerial() );
|
|
g1->SetTempVar( CITV_MOREX, g2->GetSerial() );
|
|
}
|
|
else
|
|
{
|
|
g1->Delete();
|
|
}
|
|
}
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - FieldSpell()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Creates rows of items for field spells like firewalls, wall of stone, etc
|
|
//o------------------------------------------------------------------------------------------------o
|
|
bool FieldSpell( CChar *caster, UI16 id, SI16 x, SI16 y, SI08 z, UI08 fieldDir, SI08 spellNum )
|
|
{
|
|
SI16 fx[5], fy[5];
|
|
if( fieldDir )
|
|
{
|
|
fx[0] = fx[1] = fx[2] = fx[3] = fx[4] = x;
|
|
fy[0] = y - 1;
|
|
fy[1] = y + 1;
|
|
fy[2] = y - 2;
|
|
fy[3] = y + 2;
|
|
fy[4] = y;
|
|
}
|
|
else
|
|
{
|
|
fy[0] = fy[1] = fy[2] = fy[3] = fy[4] = y;
|
|
fx[0] = x - 1;
|
|
fx[1] = x + 1;
|
|
fx[2] = x - 2;
|
|
fx[3] = x + 2;
|
|
fx[4] = x;
|
|
}
|
|
CItem *i = nullptr;
|
|
UI08 worldNumber = caster->WorldNumber();
|
|
UI16 instanceId = caster->GetInstanceId();
|
|
for( UI08 j = 0; j < 5; ++j )
|
|
{
|
|
if( id != 0x0080 || ( id == 0x0080 && !Movement->CheckForCharacterAtXYZ( caster, fx[j], fy[j], z )))
|
|
{
|
|
// Don't allow field spells to be placed on top of blocking dynamic/static items
|
|
if( Map->DoesDynamicBlock( fx[j], fy[j], z, worldNumber, instanceId, false, false, false, true ))
|
|
continue;
|
|
|
|
if( Map->DoesStaticBlock( fx[j], fy[j], z, worldNumber, false ))
|
|
continue;
|
|
|
|
// Don't allow field spells cast outside a house to appear inside the house
|
|
CMultiObj *mMulti = FindMulti( fx[j], fy[j], z, worldNumber, instanceId );
|
|
if( ValidateObject( mMulti ) && mMulti != caster->GetMultiObj() )
|
|
continue;
|
|
|
|
i = Items->CreateItem( nullptr, caster, id, 1, 0, OT_ITEM );
|
|
if( i != nullptr )
|
|
{
|
|
i->SetDispellable( true );
|
|
i->SetDecayable( true );
|
|
|
|
// Duration of field item based on caster's Magery skill
|
|
i->SetDecayTime( BuildTimeValue( static_cast<R64>( caster->GetSkill( MAGERY )) / 15.0 ));
|
|
|
|
// If Poison Field, use average of caster's Magery and Poisoning skills
|
|
if( spellNum == 39 ) // Poison Field
|
|
{
|
|
i->SetTempVar( CITV_MOREX, static_cast<UI16>(( caster->GetSkill( MAGERY ) + caster->GetSkill( POISONING )) / 2 ));
|
|
}
|
|
else
|
|
{
|
|
i->SetTempVar( CITV_MOREX, caster->GetSkill( MAGERY )); // remember casters magery skill for damage
|
|
}
|
|
|
|
// Store caster's serial in field item
|
|
i->SetTempVar( CITV_MOREY, caster->GetSerial() );
|
|
i->SetLocation( fx[j], fy[j], Map->Height( fx[j], fy[j], z, worldNumber, instanceId ));
|
|
i->SetDir( 29 );
|
|
i->SetMovable( 2 );
|
|
|
|
// Don't save these temporary effect items!
|
|
i->ShouldSave( false );
|
|
|
|
CMagicStat temp = Magic->spells[spellNum].StaticEffect();
|
|
if( temp.Effect() != INVALIDID )
|
|
{
|
|
Effects->PlayStaticAnimation( i, temp.Effect(), temp.Speed(), temp.Loop() );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool splClumsy( [[maybe_unused]] CChar *caster, [[maybe_unused]] CChar *target, [[maybe_unused]] CChar *src, [[maybe_unused]] SI08 curSpell )
|
|
{
|
|
// This spell is now handled in JS/MAGIC/level1targ.js
|
|
return false;
|
|
}
|
|
bool splCreateFood( [[maybe_unused]] CSocket *sock, [[maybe_unused]] CChar *caster, [[maybe_unused]] SI08 curSpell )
|
|
{
|
|
// This spell is now handled in JS/MAGIC/createfood.js
|
|
return false;
|
|
}
|
|
bool splFeeblemind( [[maybe_unused]] CChar *caster, [[maybe_unused]] CChar *target, [[maybe_unused]] CChar *src, [[maybe_unused]] SI08 curSpell )
|
|
{
|
|
// This spell is now handled in JS/MAGIC/level1targ.js
|
|
return false;
|
|
}
|
|
bool splHeal( [[maybe_unused]] CChar *caster, [[maybe_unused]] CChar *target, [[maybe_unused]] CChar *src, [[maybe_unused]] SI08 curSpell )
|
|
{
|
|
// This spell is now handled in JS/MAGIC/level1targ.js
|
|
return false;
|
|
}
|
|
bool splMagicArrow( [[maybe_unused]] CChar *caster, [[maybe_unused]] CChar *target, [[maybe_unused]] CChar *src, [[maybe_unused]] SI08 curSpell )
|
|
{
|
|
// This spell is now handled in JS/MAGIC/level1targ.js
|
|
return false;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - splNightSight()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Applies effects of Night Sight spell
|
|
//o------------------------------------------------------------------------------------------------o
|
|
bool splNightSight( CChar *caster, CChar *target, CChar *src, [[maybe_unused]] SI08 curSpell )
|
|
{
|
|
Effects->TempEffect( src, target, 2, 0, 0, 0 );
|
|
if( target->IsMurderer() )
|
|
{
|
|
MakeCriminal( caster );
|
|
}
|
|
return true;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - splReactiveArmor()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Applies effects of Reactive Armor spell
|
|
//o------------------------------------------------------------------------------------------------o
|
|
bool splReactiveArmor( CChar *caster, CChar *target, CChar *src, [[maybe_unused]] SI08 curSpell )
|
|
{
|
|
Effects->TempEffect( src, target, 15, caster->GetSkill( MAGERY ) / 100, 0, 0 );
|
|
target->SetReactiveArmour( true );
|
|
return true;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - splWeaken()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Applies effects of Weaken spell
|
|
//o------------------------------------------------------------------------------------------------o
|
|
bool splWeaken( CChar *caster, CChar *target, CChar *src, [[maybe_unused]] SI08 curSpell )
|
|
{
|
|
Effects->TempEffect( src, target, 5, caster->GetSkill( MAGERY ) / 100, 0, 0 );
|
|
return true;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - splAgility()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Applies effects of Agility spell
|
|
//o------------------------------------------------------------------------------------------------o
|
|
bool splAgility( CChar *caster, CChar *target, CChar *src, [[maybe_unused]] SI08 curSpell )
|
|
{
|
|
Effects->TempEffect( src, target, 6, caster->GetSkill( MAGERY ) / 100, 0, 0 );
|
|
if( target->IsMurderer() )
|
|
{
|
|
MakeCriminal( caster );
|
|
}
|
|
return true;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - splCunning()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Applies effects of Cunning spell
|
|
//o------------------------------------------------------------------------------------------------o
|
|
bool splCunning( CChar *caster, CChar *target, CChar *src, [[maybe_unused]] SI08 curSpell )
|
|
{
|
|
Effects->TempEffect( src, target, 7, caster->GetSkill( MAGERY ) / 100, 0, 0 );
|
|
if( target->IsMurderer() )
|
|
{
|
|
MakeCriminal( caster );
|
|
}
|
|
return true;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - splCure()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Applies effects of Cure spell
|
|
//o------------------------------------------------------------------------------------------------o
|
|
bool splCure( CChar *caster, CChar *target, [[maybe_unused]] CChar *src, [[maybe_unused]] SI08 curSpell )
|
|
{
|
|
target->SetPoisoned( 0 );
|
|
target->SetPoisonedBy( INVALIDSERIAL );
|
|
target->SetTimer( tCHAR_POISONWEAROFF, cwmWorldState->GetUICurrentTime() );
|
|
if( target->IsMurderer() )
|
|
{
|
|
MakeCriminal( caster );
|
|
}
|
|
return true;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - splHarm()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Applies effects of Harm spell
|
|
//o------------------------------------------------------------------------------------------------o
|
|
bool splHarm( CChar *caster, CChar *target, CChar *src, SI08 curSpell )
|
|
{
|
|
SI16 spellDamage = 0;
|
|
bool spellResisted = Magic->CheckResist( caster, target, Magic->spells[curSpell].Circle() );
|
|
|
|
spellDamage = Magic->spells[curSpell].BaseDmg();
|
|
spellDamage = CalcSpellDamageMod( caster, target, spellDamage, spellResisted );
|
|
|
|
Effects->TempEffect( src, target, 29, spellDamage, 0, 0 );
|
|
return true;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - splMagicTrap()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Applies effects of Magic Trap spell
|
|
//o------------------------------------------------------------------------------------------------o
|
|
bool splMagicTrap( CSocket *sock, CChar *caster, CItem *target, [[maybe_unused]] SI08 curSpell )
|
|
{
|
|
if( target->IsContType() && target->GetId() != 0x0E75 )
|
|
{
|
|
target->SetTempVar( CITV_MOREZ, CalcSerial( 1, caster->GetSkill( MAGERY ) / 200, caster->GetSkill( MAGERY ) / 100, 0 ));
|
|
if( Magic->spells[13].Effect() != INVALIDID )
|
|
{
|
|
Effects->PlaySound( caster, Magic->spells[13].Effect() );
|
|
}
|
|
|
|
CMagicStat temp = Magic->spells[13].StaticEffect();
|
|
if( temp.Effect() != INVALIDID )
|
|
{
|
|
Effects->PlayStaticAnimation( target, temp.Effect(), temp.Speed(), temp.Loop() );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
sock->SysMessage( 663 ); // You cannot trap this!
|
|
}
|
|
return true;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - splMagicUntrap()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Applies effects of Magic Untrap spell
|
|
//o------------------------------------------------------------------------------------------------o
|
|
bool splMagicUntrap( CSocket *sock, CChar *caster, CItem *target, [[maybe_unused]] SI08 curSpell )
|
|
{
|
|
if( target->IsContType() )
|
|
{
|
|
if( target->GetTempVar( CITV_MOREZ, 1 ) == 1 )
|
|
{
|
|
if( RandomNum( 1, 100 ) <= 50 + ( caster->GetSkill( MAGERY ) / 10 ) - target->GetTempVar( CITV_MOREZ, 3 ))
|
|
{
|
|
target->SetTempVar( CITV_MOREZ, 1, 0 );
|
|
if( Magic->spells[14].Effect() != INVALIDID )
|
|
{
|
|
Effects->PlaySound( caster, Magic->spells[14].Effect() );
|
|
}
|
|
|
|
CMagicStat temp = Magic->spells[14].StaticEffect();
|
|
if( temp.Effect() != INVALIDID )
|
|
{
|
|
Effects->PlayStaticAnimation( target, temp.Effect(), temp.Speed(), temp.Loop() );
|
|
}
|
|
sock->SysMessage( 664 ); // You successful untrap this item!
|
|
}
|
|
else
|
|
{
|
|
sock->SysMessage( 665 ); // You miss to untrap this item!
|
|
}
|
|
}
|
|
else
|
|
{
|
|
sock->SysMessage( 667 ); // This items doesn't seem to be trapped!
|
|
}
|
|
}
|
|
else
|
|
{
|
|
sock->SysMessage( 668 ); // This items cannot be trapped!
|
|
}
|
|
return true;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - splProtection()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Applies effects of Protection spell
|
|
//o------------------------------------------------------------------------------------------------o
|
|
bool splProtection( CChar *caster, CChar *target, CChar *src, [[maybe_unused]] SI08 curSpell )
|
|
{
|
|
Effects->TempEffect( src, target, 21, caster->GetSkill( MAGERY ) / 10, 0, 0 );
|
|
if( target->IsMurderer() )
|
|
{
|
|
MakeCriminal( caster );
|
|
}
|
|
return true;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - splStrength()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Applies effects of Strength spell
|
|
//o------------------------------------------------------------------------------------------------o
|
|
bool splStrength( CChar *caster, CChar *target, CChar *src, [[maybe_unused]] SI08 curSpell )
|
|
{
|
|
Effects->TempEffect( src, target, 8, caster->GetSkill( MAGERY ) / 100, 0, 0 );
|
|
if( target->IsMurderer() )
|
|
{
|
|
MakeCriminal( caster );
|
|
}
|
|
return true;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - splBless()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Applies effects of Bless spell
|
|
//o------------------------------------------------------------------------------------------------o
|
|
bool splBless( CChar *caster, CChar *target, CChar *src, [[maybe_unused]] SI08 curSpell )
|
|
{
|
|
SI32 j = caster->GetSkill( MAGERY ) / 100;
|
|
Effects->TempEffect( src, target, 11, j, j, j);
|
|
if( target->IsMurderer() )
|
|
{
|
|
MakeCriminal( caster );
|
|
}
|
|
return true;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - splFireball()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Applies effects of Fireball spell
|
|
//o------------------------------------------------------------------------------------------------o
|
|
bool splFireball( CChar *caster, CChar *target, CChar *src, SI08 curSpell )
|
|
{
|
|
SI16 spellDamage = 0;
|
|
bool spellResisted = Magic->CheckResist( caster, target, Magic->spells[curSpell].Circle() );
|
|
|
|
spellDamage = Magic->spells[curSpell].BaseDmg();
|
|
spellDamage = CalcSpellDamageMod( caster, target, spellDamage, spellResisted );
|
|
|
|
Effects->TempEffect( src, target, 30, spellDamage, 0, 0 );
|
|
return true;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - splMagicLock()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Applies effects of Magic Lock spell
|
|
//o------------------------------------------------------------------------------------------------o
|
|
bool splMagicLock( CSocket *sock, CChar *caster, CItem *target, [[maybe_unused]] SI08 curSpell )
|
|
{
|
|
ItemTypes type = target->GetType();
|
|
if(( type == IT_CONTAINER || type == IT_DOOR || type == IT_SPAWNCONT ) && ( target->GetId( 1 ) != 0x0E || target->GetId( 2 ) != 0x75 ))
|
|
{
|
|
// Don't allow casting this on locks inside multis
|
|
if( ValidateObject( target->GetMultiObj() ))
|
|
{
|
|
sock->SysMessage( 669 ); // You cannot lock this!
|
|
return true;
|
|
}
|
|
|
|
switch( type )
|
|
{
|
|
case IT_CONTAINER: target->SetType( IT_LOCKEDCONTAINER ); break;
|
|
case IT_DOOR: target->SetType( IT_LOCKEDDOOR ); break;
|
|
case IT_SPAWNCONT: target->SetType( IT_LOCKEDSPAWNCONT ); break;
|
|
default:
|
|
Console.Error( "Fallout of switch statement without default. magic.cpp, magiclocktarget()" );
|
|
break;
|
|
}
|
|
|
|
// Mark lock as magically locked
|
|
target->SetTempVar( CITV_MOREY, 2, static_cast<UI08>( 0x01 ));
|
|
|
|
// Store min/max skill to unlock with magery based on player's magery skill
|
|
target->SetTempVar( CITV_MOREY, 3, static_cast<UI08>(( caster->GetSkill( MAGERY ) / 10 ) / 2 ));
|
|
target->SetTempVar( CITV_MOREY, 4, static_cast<UI08>( caster->GetSkill( MAGERY ) / 10 ));
|
|
|
|
target->RemoveFromSight();
|
|
target->Update();
|
|
|
|
if( Magic->spells[19].Effect() != INVALIDID )
|
|
{
|
|
Effects->PlaySound( caster, Magic->spells[19].Effect() );
|
|
}
|
|
|
|
CMagicStat temp = Magic->spells[19].StaticEffect();
|
|
if( temp.Effect() != INVALIDID )
|
|
{
|
|
auto iCont = target->GetCont();
|
|
if( ValidateObject( iCont ) && iCont->CanBeObjType( OT_CHAR ))
|
|
{
|
|
// If container is a character, play lock FX on character
|
|
Effects->PlayStaticAnimation( iCont, temp.Effect(), temp.Speed(), temp.Loop() );
|
|
}
|
|
else
|
|
{
|
|
// Otherwise play FX directly on object
|
|
Effects->PlayStaticAnimation( target, temp.Effect(), temp.Speed(), temp.Loop() );
|
|
}
|
|
}
|
|
|
|
// Make it an effect that expires in between 7 to 50 seconds, depending on caster's Magery skill
|
|
auto magicLockDuration = static_cast<UI16>( floor( caster->GetSkill( MAGERY ) / 100 ) + floor( caster->GetSkill( MAGERY ) / 25 ));
|
|
Effects->TempEffect( caster, target, 50, magicLockDuration, 0, 0 );
|
|
}
|
|
else
|
|
{
|
|
sock->SysMessage( 669 ); // You cannot lock this!
|
|
}
|
|
return true;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CalculateMagicPoisonStrength()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Calculate strength of magic poison based on caster and target
|
|
//o------------------------------------------------------------------------------------------------o
|
|
UI08 CalculateMagicPoisonStrength( CChar *caster, CChar *target, UI16 skillVal, bool checkDistance, UI08 spellCircle )
|
|
{
|
|
// Default to Lesser Poison if caster is further than 2 tiles away from target
|
|
UI08 poisonStrength = 1;
|
|
|
|
// Check if caster is within 2 tiles of target
|
|
if( !checkDistance || GetDist( caster, target ) <= 2 )
|
|
{
|
|
// Calculate poison strength based on average of caster's Magery and Poisoning skills
|
|
if( skillVal == 0 )
|
|
{
|
|
skillVal = static_cast<UI16>(( caster->GetSkill( MAGERY ) + caster->GetSkill( POISONING )) / 2 );
|
|
}
|
|
if( skillVal >= 1000 ) // GM in both skills
|
|
{
|
|
// 5% chance of Deadly Poison if spellCircle is lower than 5, or always Deadly if spellCircle is 5
|
|
if( spellCircle == 5 || RandomNum( 1, 100 ) <= 5 )
|
|
{
|
|
poisonStrength = 4; // Deadly Poison
|
|
}
|
|
else
|
|
{
|
|
poisonStrength = 3; // Greater Poison
|
|
}
|
|
}
|
|
else if( skillVal > 701 )
|
|
{
|
|
poisonStrength = 3; // Greater Poison
|
|
}
|
|
else if( skillVal > 301 )
|
|
{
|
|
poisonStrength = 2; // Regular Poison
|
|
}
|
|
}
|
|
|
|
// If target resists spell, reduce strength of poison
|
|
if( Magic->CheckResist( caster, target, 3 ))
|
|
{
|
|
if( poisonStrength > 1 )
|
|
{
|
|
poisonStrength--;
|
|
}
|
|
}
|
|
|
|
return poisonStrength;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - splPoison()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Applies effects of Poison spell
|
|
//o------------------------------------------------------------------------------------------------o
|
|
bool splPoison( CChar *caster, CChar *target, [[maybe_unused]] CChar *src, [[maybe_unused]] SI08 curSpell )
|
|
{
|
|
// Calculate poison strength of spell based on caster's skills, range to target and whether target resists
|
|
UI08 poisonStrength = CalculateMagicPoisonStrength( caster, target, 0, true, 3 );
|
|
|
|
// Apply poison on target
|
|
target->SetPoisoned( poisonStrength );
|
|
target->SetPoisonedBy( caster->GetSerial() );
|
|
|
|
// Set time until poison wears off completely
|
|
target->SetTimer( tCHAR_POISONWEAROFF, BuildTimeValue( static_cast<R64>( GetPoisonDuration( poisonStrength ))));
|
|
|
|
// Handle criminal flagging
|
|
if( ValidateObject( caster ) && target->IsInnocent() )
|
|
{
|
|
if( WillResultInCriminal( caster, target ) && ValidateObject( caster ) && !caster->IsGM() && !caster->IsCounselor() )
|
|
{
|
|
MakeCriminal( caster );
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - splTelekinesis()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Applies effects of Telekinesis spell
|
|
//o------------------------------------------------------------------------------------------------o
|
|
bool splTelekinesis( CSocket *sock, CChar *caster, CItem *target, [[maybe_unused]] SI08 curSpell )
|
|
{
|
|
if( target->IsContType() )
|
|
{
|
|
if( target->GetTempVar( CITV_MOREZ, 1 ) == 1 )
|
|
{
|
|
target->SetTempVar( CITV_MOREZ, 1, 0 );
|
|
|
|
if( Magic->spells[21].Effect() != INVALIDID )
|
|
{
|
|
Effects->PlaySound( caster, Magic->spells[21].Effect() );
|
|
}
|
|
|
|
CMagicStat temp = Magic->spells[21].StaticEffect();
|
|
if( temp.Effect() != INVALIDID )
|
|
{
|
|
Effects->PlayStaticAnimation( target, temp.Effect(), temp.Speed(), temp.Loop() );
|
|
}
|
|
|
|
Magic->MagicTrap( caster, target );
|
|
}
|
|
else
|
|
{
|
|
sock->SysMessage( 667 ); // This item doesn't seem to be trapped!
|
|
}
|
|
}
|
|
else
|
|
{
|
|
sock->SysMessage( 668 ); // This item cannot be trapped!
|
|
}
|
|
return true;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - splTeleport()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Applies effects of Teleport spell
|
|
//o------------------------------------------------------------------------------------------------o
|
|
bool splTeleport( CSocket *sock, CChar *caster, SI16 x, SI16 y, SI08 z, [[maybe_unused]] SI08 curSpell )
|
|
{
|
|
CMultiObj *m = FindMulti( x, y, z, caster->WorldNumber(), caster->GetInstanceId() );
|
|
if( ValidateObject( m ) && m->GetOwnerObj() != caster && !caster->IsNpc() )
|
|
{
|
|
sock->SysMessage( 670 ); // You can't teleport here!
|
|
return false;
|
|
}
|
|
if( !caster->IsNpc() )
|
|
{
|
|
CTile& tile = Map->SeekTile( sock->GetWord( 0x11 ));
|
|
if(( tile.Name() == "water" ) || tile.CheckFlag( TF_WET ))
|
|
{
|
|
sock->SysMessage( 671 ); //You can't teleport there!
|
|
return false;
|
|
}
|
|
if( tile.CheckFlag( TF_ROOF )) // slanted roof tile!!! naughty naughty
|
|
{
|
|
sock->SysMessage( 672 ); // You cannot teleport there!
|
|
return false;
|
|
}
|
|
}
|
|
if( Weight->IsOverloaded( caster ))
|
|
{
|
|
if( caster->GetMana() >= 20 )
|
|
{
|
|
caster->SetMana( static_cast<SI16>( caster->GetMana() - 20 ));
|
|
}
|
|
else
|
|
{
|
|
sock->SysMessage( 1386 ); // You are overloaded! You can't hold all this weight.
|
|
return false;
|
|
}
|
|
}
|
|
CMagicStat temp = Magic->spells[22].StaticEffect();
|
|
if( temp.Effect() != INVALIDID )
|
|
{
|
|
Effects->PlayStaticAnimation( caster->GetX(), caster->GetY(), caster->GetZ(), temp.Effect(), temp.Speed(), temp.Loop(), false );
|
|
caster->SetLocation( x, y, z );
|
|
Magic->DoStaticEffect( caster, 22 );
|
|
}
|
|
return true;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - splUnlock()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Applies effects of Unlock spell
|
|
//o------------------------------------------------------------------------------------------------o
|
|
bool splUnlock( CSocket *sock, CChar *caster, CItem *target, [[maybe_unused]] SI08 curSpell )
|
|
{
|
|
if( target->IsDivineLocked() )
|
|
{
|
|
sock->SysMessage( 673 ); // This item has been protected with divine magic. You cannot unlock this item.
|
|
return false;
|
|
}
|
|
if( target->GetType() == IT_LOCKEDCONTAINER )
|
|
{
|
|
bool canMagicUnlock = true;
|
|
if( target->GetTempVar( CITV_MOREY ) > 0 )
|
|
{
|
|
canMagicUnlock = static_cast<bool>( target->GetTempVar( CITV_MOREY, 2 ));
|
|
if( !canMagicUnlock )
|
|
{
|
|
sock->SysMessage( 9102 ); // That lock cannot be unlocked with magic!
|
|
return false;
|
|
}
|
|
}
|
|
|
|
auto minSkill = target->GetTempVar( CITV_MOREY, 3 ) * 10;
|
|
auto maxSkill = target->GetTempVar( CITV_MOREY, 4 ) * 10;
|
|
if( !Skills->CheckSkill( caster, MAGERY, minSkill, ( maxSkill > 0 ? maxSkill : caster->GetSkillCap( MAGERY ) )))
|
|
{
|
|
sock->SysMessage( 6092 ); // You are not skilled enough to do that.
|
|
return false;
|
|
}
|
|
|
|
target->SetType( IT_CONTAINER );
|
|
sock->SysMessage( 674 ); // You unlock the item.
|
|
target->RemoveFromSight();
|
|
target->Update();
|
|
|
|
if( Magic->spells[23].Effect() != INVALIDID )
|
|
{
|
|
Effects->PlaySound( caster, Magic->spells[23].Effect() );
|
|
}
|
|
|
|
CMagicStat temp = Magic->spells[23].StaticEffect();
|
|
if( temp.Effect() != INVALIDID )
|
|
{
|
|
auto iCont = target->GetCont();
|
|
if( ValidateObject( iCont ) && iCont->CanBeObjType( OT_CHAR ))
|
|
{
|
|
// If container is a character, play lock FX on character
|
|
Effects->PlayStaticAnimation( iCont, temp.Effect(), temp.Speed(), temp.Loop() );
|
|
}
|
|
else
|
|
{
|
|
Effects->PlayStaticAnimation( target, temp.Effect(), temp.Speed(), temp.Loop() );
|
|
}
|
|
}
|
|
}
|
|
else if( target->GetType() == IT_LOCKEDSPAWNCONT )
|
|
{
|
|
bool canMagicUnlock = true;
|
|
if( target->GetTempVar( CITV_MOREY ) > 0 )
|
|
{
|
|
canMagicUnlock = static_cast<bool>(target->GetTempVar( CITV_MOREY, 2 ));
|
|
if( !canMagicUnlock )
|
|
{
|
|
sock->SysMessage( 9102 ); // That lock cannot be unlocked with magic!
|
|
return false;
|
|
}
|
|
}
|
|
|
|
auto minSkill = target->GetTempVar( CITV_MOREY, 3 ) * 10;
|
|
auto maxSkill = target->GetTempVar( CITV_MOREY, 4 ) * 10;
|
|
if( !Skills->CheckSkill( caster, MAGERY, minSkill, ( maxSkill > 0 ? maxSkill : caster->GetSkillCap( MAGERY ) )))
|
|
{
|
|
sock->SysMessage( 6092 ); // You are not skilled enough to do that.
|
|
return false;
|
|
}
|
|
|
|
target->SetType( IT_SPAWNCONT );
|
|
sock->SysMessage( 675 ); // You unlock the item.
|
|
target->RemoveFromSight();
|
|
target->Update();
|
|
|
|
if( Magic->spells[23].Effect() != INVALIDID )
|
|
{
|
|
Effects->PlaySound( caster, Magic->spells[23].Effect() );
|
|
}
|
|
|
|
CMagicStat temp = Magic->spells[23].StaticEffect();
|
|
if( temp.Effect() != INVALIDID )
|
|
{
|
|
Effects->PlayStaticAnimation( target, temp.Effect(), temp.Speed(), temp.Loop() );
|
|
}
|
|
}
|
|
else if( target->GetType() == IT_CONTAINER || target->GetType() == IT_SPAWNCONT || target->GetType() == IT_LOCKEDSPAWNCONT || target->GetType() == IT_TRASHCONT )
|
|
{
|
|
sock->SysMessage( 676 ); // That is not locked.
|
|
}
|
|
else if( target->GetType() == IT_DOOR )
|
|
{
|
|
sock->SysMessage( 937 ); // That cannot be unlocked without a key!
|
|
}
|
|
else if( target->GetType() == IT_LOCKEDDOOR )
|
|
{
|
|
bool canMagicUnlock = true;
|
|
if( target->GetTempVar( CITV_MOREY ) > 0 )
|
|
{
|
|
canMagicUnlock = static_cast<bool>(target->GetTempVar( CITV_MOREY, 2 ));
|
|
if( !canMagicUnlock )
|
|
{
|
|
sock->SysMessage( 9102 ); // That lock cannot be unlocked with magic!
|
|
return false;
|
|
}
|
|
}
|
|
|
|
auto minSkill = target->GetTempVar( CITV_MOREY, 3 ) * 10;
|
|
auto maxSkill = target->GetTempVar( CITV_MOREY, 4 ) * 10;
|
|
if( !Skills->CheckSkill( caster, MAGERY, minSkill, ( maxSkill > 0 ? maxSkill : caster->GetSkillCap( MAGERY ) )))
|
|
{
|
|
sock->SysMessage( 6092 ); // You are not skilled enough to do that.
|
|
return false;
|
|
}
|
|
|
|
target->SetType( IT_DOOR );
|
|
sock->SysMessage( 675 ); // You unlock the item.
|
|
target->RemoveFromSight();
|
|
target->Update();
|
|
|
|
if( Magic->spells[23].Effect() != INVALIDID )
|
|
{
|
|
Effects->PlaySound( caster, Magic->spells[23].Effect() );
|
|
}
|
|
|
|
CMagicStat temp = Magic->spells[23].StaticEffect();
|
|
if( temp.Effect() != INVALIDID )
|
|
{
|
|
Effects->PlayStaticAnimation( target, temp.Effect(), temp.Speed(), temp.Loop() );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
sock->SysMessage( 678 ); // That does not have a lock.
|
|
}
|
|
return true;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - splWallOfStone()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Applies effects of Wall of Stone spell
|
|
//o------------------------------------------------------------------------------------------------o
|
|
bool splWallOfStone( [[maybe_unused]] CSocket *sock, CChar *caster, UI08 fieldDir, SI16 x, SI16 y, SI08 z, SI08 curSpell )
|
|
{
|
|
return FieldSpell( caster, 0x0080, x, y, z, fieldDir, curSpell );
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - ArchCureStub()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Applies effects of Arch Cure spell to an individual target
|
|
//o------------------------------------------------------------------------------------------------o
|
|
void ArchCureStub( [[maybe_unused]] CChar *caster, CChar *target, [[maybe_unused]] SI08 curSpell, [[maybe_unused]] SI08 targCount )
|
|
{
|
|
target->SetPoisoned( 0 );
|
|
target->SetPoisonedBy( INVALIDSERIAL );
|
|
target->SetTimer( tCHAR_POISONWEAROFF, cwmWorldState->GetUICurrentTime() );
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - splArchCure()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Casts Arch Cure as an area affect spell
|
|
//o------------------------------------------------------------------------------------------------o
|
|
bool splArchCure( CSocket *sock, CChar *caster, [[maybe_unused]] CChar *target, [[maybe_unused]] CChar *src, SI08 curSpell )
|
|
{
|
|
AreaAffectSpell( sock, caster, &ArchCureStub, curSpell );
|
|
return true;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - ArchProtectionStub()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Applies effects of Arch Protection spell to an individual target
|
|
//o------------------------------------------------------------------------------------------------o
|
|
void ArchProtectionStub( CChar *caster, CChar *target, [[maybe_unused]] SI08 curSpell, [[maybe_unused]] SI08 targCount )
|
|
{
|
|
Magic->PlaySound( target, 26 );
|
|
Magic->DoStaticEffect( target, 15 ); // protection
|
|
Effects->TempEffect( caster, target, 21, caster->GetSkill( MAGERY ) / 10, 0, 0 );
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - splArchProtection()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Casts Arch Protection as an area affect spell
|
|
//o------------------------------------------------------------------------------------------------o
|
|
bool splArchProtection( CSocket *sock, CChar *caster, [[maybe_unused]] CChar *target, [[maybe_unused]] CChar *src, SI08 curSpell )
|
|
{
|
|
AreaAffectSpell( sock, caster, &ArchProtectionStub, curSpell );
|
|
return true;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - splCurse()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Applies effects of Curse spell
|
|
//o------------------------------------------------------------------------------------------------o
|
|
bool splCurse( CChar *caster, CChar *target, [[maybe_unused]] CChar *src, [[maybe_unused]] SI08 curSpell )
|
|
{
|
|
SI32 j = caster->GetSkill( MAGERY ) / 100;
|
|
Effects->TempEffect( caster, target, 12, j, j, j);
|
|
return true;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - splFireField()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Casts Fire Field as a field spell
|
|
//o------------------------------------------------------------------------------------------------o
|
|
bool splFireField( [[maybe_unused]] CSocket *sock, CChar *caster, UI08 fieldDir, SI16 x, SI16 y, SI08 z, SI08 curSpell )
|
|
{
|
|
if( fieldDir == 0 )
|
|
{
|
|
return FieldSpell( caster, 0x398C, x, y, z, fieldDir, curSpell );
|
|
}
|
|
else
|
|
{
|
|
return FieldSpell( caster, 0x3996, x, y, z, fieldDir, curSpell );
|
|
}
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - splGreaterHeal()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Applies effects of Greater Heal spell
|
|
//o------------------------------------------------------------------------------------------------o
|
|
bool splGreaterHeal( CChar *caster, CChar *target, [[maybe_unused]] CChar *src, SI08 curSpell )
|
|
{
|
|
SI32 srcHealth = target->GetHP();
|
|
SI32 baseHealing = Magic->spells[curSpell].BaseDmg();
|
|
SI32 j = caster->GetSkill( MAGERY ) / 30 + HalfRandomNum( baseHealing );
|
|
|
|
target->Heal( j, caster );
|
|
Magic->SubtractHealth( caster, std::min( target->GetStrength(), static_cast<SI16>( srcHealth + j )), 29 );
|
|
if( target->IsMurderer() )
|
|
{
|
|
MakeCriminal( caster );
|
|
}
|
|
return true;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - splLightning()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Applies effects of Lightning spell
|
|
//o------------------------------------------------------------------------------------------------o
|
|
bool splLightning( CChar *caster, CChar *target, CChar *src, SI08 curSpell )
|
|
{
|
|
SI16 spellDamage = 0;
|
|
bool spellResisted = Magic->CheckResist( caster, target, Magic->spells[curSpell].Circle() );
|
|
|
|
spellDamage = Magic->spells[curSpell].BaseDmg();
|
|
spellDamage = CalcSpellDamageMod( caster, target, spellDamage, spellResisted );
|
|
|
|
Effects->TempEffect( src, target, 31, spellDamage, 0, 0 );
|
|
return true;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - splManaDrain()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Applies effects of Mana Drain spell
|
|
//o------------------------------------------------------------------------------------------------o
|
|
bool splManaDrain( CChar *caster, CChar *target, [[maybe_unused]] CChar *src, [[maybe_unused]] SI08 curSpell )
|
|
{
|
|
if( !Magic->CheckResist( caster, target, 4 ))
|
|
{
|
|
target->SetMana( target->GetMana() - caster->GetSkill( MAGERY )/35 );
|
|
if( target->GetMana() < 0 )
|
|
{
|
|
target->SetMana( 0 );
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - splRecall()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Applies effects of Recall spell
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto splRecall( CSocket *sock, CChar *caster, CItem *i, [[maybe_unused]] SI08 curSpell ) -> bool
|
|
{
|
|
// No recall if too heavy, GMs excempt
|
|
if( Weight->IsOverloaded( caster ) && !cwmWorldState->ServerData()->TravelSpellsWhileOverweight() && ( !caster->IsCounselor() && !caster->IsGM() ))
|
|
{
|
|
sock->SysMessage( 680 ); // You are too heavy to do that!
|
|
sock->SysMessage( 681 ); // You feel drained from the attempt.
|
|
return false;
|
|
}
|
|
else if( i->GetType() == 7 )
|
|
{
|
|
// Player recalled off a key
|
|
CMultiObj *shipMulti = CalcMultiFromSer( i->GetTempVar( CITV_MORE ));
|
|
if( ValidateObject( shipMulti ) && shipMulti->CanBeObjType( OT_BOAT ))
|
|
{
|
|
if(( shipMulti->WorldNumber() == caster->WorldNumber() || cwmWorldState->ServerData()->TravelSpellsBetweenWorlds() ) && shipMulti->GetInstanceId() == caster->GetInstanceId() )
|
|
{
|
|
if( shipMulti->WorldNumber() == 0 && caster->WorldNumber() != 0 && cwmWorldState->ServerData()->YoungPlayerSystem() && caster->GetAccount().wFlags.test( AB_FLAGS_YOUNG ) )
|
|
{
|
|
sock->SysMessage( 18733 ); // You decide against traveling to Felucca while you are still young.
|
|
return false;
|
|
}
|
|
|
|
// Teleport player's followers too
|
|
auto myFollowers = caster->GetFollowerList();
|
|
for( const auto &myFollower : myFollowers->collection() )
|
|
{
|
|
if( ValidateObject( myFollower ))
|
|
{
|
|
if( !myFollower->GetMounted() && myFollower->GetOwnerObj() == caster )
|
|
{
|
|
// Only teleport followers if they are set to actually following owner & are within range
|
|
if( myFollower->GetNpcWander() == WT_FOLLOW && ObjInOldRange( caster, myFollower, DIST_CMDRANGE ))
|
|
{
|
|
myFollower->SetLocation( shipMulti->GetX() + 1, shipMulti->GetY(), shipMulti->GetZ() + 3, shipMulti->WorldNumber(), shipMulti->GetInstanceId() );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Teleport player
|
|
caster->SetLocation( shipMulti->GetX() + 1, shipMulti->GetY(), shipMulti->GetZ() + 3, shipMulti->WorldNumber(), shipMulti->GetInstanceId() );
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
sock->SysMessage( 2063 ); // You are unable to recall to your ship - it might be in another world!
|
|
return false;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
sock->SysMessage( 2065 ); // You can only recall off of recall runes or valid ship keys!
|
|
return false;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Check if rune was marked in a multi - if so, try to take user directly there
|
|
TAGMAPOBJECT runeMore = i->GetTag( "multiSerial" );
|
|
if( runeMore.m_StringValue != "" )
|
|
{
|
|
SERIAL mSerial = oldstrutil::value<SERIAL>( runeMore.m_StringValue );
|
|
if( mSerial != 0 && mSerial != INVALIDSERIAL )
|
|
{
|
|
CMultiObj *shipMulti = CalcMultiFromSer( mSerial );
|
|
if( ValidateObject( shipMulti ) && shipMulti->CanBeObjType( OT_BOAT ))
|
|
{
|
|
if(( shipMulti->WorldNumber() == caster->WorldNumber() || cwmWorldState->ServerData()->TravelSpellsBetweenWorlds() ) && shipMulti->GetInstanceId() == caster->GetInstanceId() )
|
|
{
|
|
if( shipMulti->WorldNumber() == 0 && caster->WorldNumber() != 0 && cwmWorldState->ServerData()->YoungPlayerSystem() && caster->GetAccount().wFlags.test( AB_FLAGS_YOUNG ) )
|
|
{
|
|
sock->SysMessage( 18733 ); // You decide against traveling to Felucca while you are still young.
|
|
return false;
|
|
}
|
|
|
|
// Teleport player's followers too
|
|
auto myFollowers = caster->GetFollowerList();
|
|
for( const auto &myFollower : myFollowers->collection() )
|
|
{
|
|
if( ValidateObject( myFollower ))
|
|
{
|
|
if( !myFollower->GetMounted() && myFollower->GetOwnerObj() == caster )
|
|
{
|
|
if( myFollower->GetNpcWander() == WT_FOLLOW && ObjInOldRange( caster, myFollower, DIST_CMDRANGE ))
|
|
{
|
|
myFollower->SetLocation( shipMulti->GetX() + 1, shipMulti->GetY(), shipMulti->GetZ() + 3, shipMulti->WorldNumber(), shipMulti->GetInstanceId() );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
caster->SetLocation( shipMulti->GetX() + 1, shipMulti->GetY(), shipMulti->GetZ() + 3, shipMulti->WorldNumber(), shipMulti->GetInstanceId() );
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
sock->SysMessage( 2063 ); // You are unable to recall to your ship - it might be in another world!
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
sock->SysMessage( 2062 ); // Unable to locate ship - it might have been dry-docked... or sunk!
|
|
return false;
|
|
}
|
|
else if( i->GetTempVar( CITV_MOREX ) == 0 && i->GetTempVar( CITV_MOREY ) == 0 )
|
|
{
|
|
sock->SysMessage( 679 ); // That rune has not been marked yet!
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
UI08 worldNum = static_cast<UI08>( i->GetTempVar( CITV_MORE ));
|
|
if( !Map->MapExists( worldNum ))
|
|
{
|
|
worldNum = caster->WorldNumber();
|
|
}
|
|
|
|
SI16 targLocX = static_cast<SI16>( i->GetTempVar( CITV_MOREX ));
|
|
SI16 targLocY = static_cast<SI16>( i->GetTempVar( CITV_MOREY ));
|
|
SI08 targLocZ = static_cast<SI08>( i->GetTempVar( CITV_MOREZ ));
|
|
UI16 instanceId = static_cast<UI16>( i->GetTempVar( CITV_MORE0 ));
|
|
if( worldNum != caster->WorldNumber() )
|
|
{
|
|
if( cwmWorldState->ServerData()->TravelSpellsBetweenWorlds() )
|
|
{
|
|
if( worldNum == 0 && caster->WorldNumber() != 0 && cwmWorldState->ServerData()->YoungPlayerSystem() && caster->GetAccount().wFlags.test( AB_FLAGS_YOUNG ) )
|
|
{
|
|
sock->SysMessage( 18733 ); // You decide against traveling to Felucca while you are still young.
|
|
return false;
|
|
}
|
|
|
|
// Teleport player's followers too
|
|
auto myFollowers = caster->GetFollowerList();
|
|
for( const auto &myFollower : myFollowers->collection() )
|
|
{
|
|
if( ValidateObject( myFollower ))
|
|
{
|
|
if( !myFollower->GetMounted() && myFollower->GetOwnerObj() == caster )
|
|
{
|
|
if( myFollower->GetNpcWander() == WT_FOLLOW && ObjInOldRange( caster, myFollower, DIST_CMDRANGE ))
|
|
{
|
|
myFollower->SetLocation( targLocX, targLocY, targLocZ, worldNum, instanceId );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Teleport the player
|
|
caster->SetLocation( targLocX, targLocY, targLocZ, worldNum, instanceId );
|
|
SendMapChange( caster->WorldNumber(), sock, false );
|
|
}
|
|
else
|
|
{
|
|
sock->SysMessage( 2061 ); // Travelling between worlds using Recall or Gate spells is not possible.
|
|
return false;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Teleport player's followers too
|
|
auto myFollowers = caster->GetFollowerList();
|
|
for( const auto &myFollower : myFollowers->collection() )
|
|
{
|
|
if( ValidateObject( myFollower ))
|
|
{
|
|
if( !myFollower->GetMounted() && myFollower->GetOwnerObj() == caster )
|
|
{
|
|
if( myFollower->GetNpcWander() == WT_FOLLOW && ObjInOldRange( caster, myFollower, DIST_CMDRANGE ))
|
|
{
|
|
myFollower->SetLocation( targLocX, targLocY, targLocZ, worldNum, instanceId );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Teleport the player
|
|
caster->SetLocation( targLocX, targLocY, targLocZ, worldNum, instanceId );
|
|
}
|
|
sock->SysMessage( 682 ); // You have recalled from the rune.
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - splBladeSpirits()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Applies effects of Blade Spirits spell (summons a Blade Spirit)
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto splBladeSpirits( CSocket *sock, CChar *caster, SI16 x, SI16 y, SI08 z, [[maybe_unused]] SI08 curSpell ) -> bool
|
|
{
|
|
Magic->SummonMonster( sock, caster, 6, x, y, z );
|
|
return true;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - splDispelField()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Applies effects of Dispel Field spell
|
|
//o------------------------------------------------------------------------------------------------o
|
|
bool splDispelField( CSocket *sock, CChar *caster, [[maybe_unused]] SI08 curSpell )
|
|
{
|
|
CItem *i = CalcItemObjFromSer( sock->GetDWord( 7 ));
|
|
if( ValidateObject( i ))
|
|
{
|
|
if( LineOfSight( sock, caster, i->GetX(), i->GetY(), i->GetZ(), WALLS_CHIMNEYS + DOORS + FLOORS_FLAT_ROOFING, false ) || caster->IsGM() )
|
|
{
|
|
if( i->IsDecayable() && i->IsDispellable() )
|
|
{
|
|
std::vector<UI16> scriptTriggers = i->GetScriptTriggers();
|
|
for( auto scriptTrig : scriptTriggers )
|
|
{
|
|
cScript *toExecute = JSMapping->GetScript( scriptTrig );
|
|
if( toExecute != nullptr )
|
|
{
|
|
if( toExecute->OnDispel( i ) == 1 ) // if it exists and we don't want hard code, return
|
|
return false;
|
|
}
|
|
}
|
|
|
|
i->Delete();
|
|
}
|
|
Effects->PlaySound( caster, 0x0201 );
|
|
}
|
|
else
|
|
{
|
|
sock->SysMessage( 683 ); // There seems to be something in the way.
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
void SetRandomName( CBaseObject *s, const std::string& namelist );
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - splIncognito()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Applies effects of Incognito spell
|
|
//o------------------------------------------------------------------------------------------------o
|
|
bool splIncognito( CSocket *sock, CChar *caster, [[maybe_unused]] SI08 curSpell )
|
|
{
|
|
if( caster->IsIncognito() )
|
|
{
|
|
sock->SysMessage( 1636 ); // You cannot go incognito while already incognito
|
|
return false;
|
|
}
|
|
if( caster->IsPolymorphed() )
|
|
{
|
|
sock->SysMessage( 1674 ); // You can't do that while polymorphed.
|
|
return false;
|
|
}
|
|
if( caster->IsDisguised() )
|
|
{
|
|
sock->SysMessage( 9232 ); // You can't do that while disguised.
|
|
return false;
|
|
}
|
|
if( caster->GetId() == 0x00b8 || caster->GetId() == 0x00b7 ) // Savage Kin Paint transformation
|
|
{
|
|
sock->SysMessage( 1672 ); // You cannot use incognito while wearing body paint
|
|
return false;
|
|
}
|
|
// ------ SEX ------
|
|
caster->SetOrgId( caster->GetId() );
|
|
UI08 randomGender = RandomNum( 0, 3 );
|
|
switch( randomGender )
|
|
{
|
|
case 0: caster->SetId( 0x0190 ); break; // male, human
|
|
case 1: caster->SetId( 0x0191 ); break; // female, human
|
|
case 2: caster->SetId( 0x025D ); break; // male, elf
|
|
case 3: caster->SetId( 0x025E ); break; // female, elf
|
|
}
|
|
|
|
// ------ NAME -----
|
|
caster->SetOrgName( caster->GetName() );
|
|
switch( randomGender )
|
|
{
|
|
case 0: SetRandomName( caster, "1" ); break; // get a name from human male list
|
|
case 1: SetRandomName( caster, "2" ); break; // get a name from human female list
|
|
case 2: SetRandomName( caster, "3" ); break; // get a name from elf male list
|
|
case 3: SetRandomName( caster, "4" ); break; // get a name from elf female list
|
|
}
|
|
|
|
SI32 color = RandomNum( 0x044E, 0x047D );
|
|
CItem *j = caster->GetItemAtLayer( IL_HAIR );
|
|
if( ValidateObject( j ))
|
|
{
|
|
caster->SetHairColour( j->GetColour() );
|
|
caster->SetHairStyle( j->GetId() );
|
|
SI32 rNum = RandomNum( 0, 9 );
|
|
switch( rNum )
|
|
{
|
|
case 0:
|
|
case 1:
|
|
case 2:
|
|
j->SetId( 0x3B + rNum, 2 );
|
|
break;
|
|
case 3:
|
|
case 4:
|
|
case 5:
|
|
case 6:
|
|
case 7:
|
|
case 8:
|
|
case 9:
|
|
j->SetId( 0x44 + ( rNum - 3 ), 2 );
|
|
break;
|
|
}
|
|
j->SetColour( color );
|
|
}
|
|
|
|
// Handle facial hair
|
|
j = caster->GetItemAtLayer( IL_FACIALHAIR );
|
|
if( ValidateObject( j ))
|
|
{
|
|
if( randomGender == 0 || randomGender == 2 )
|
|
{
|
|
caster->SetBeardColour( j->GetColour() );
|
|
caster->SetBeardStyle( j->GetId() );
|
|
SI32 rNum2 = RandomNum( 0, 6 );
|
|
switch( rNum2 )
|
|
{
|
|
case 0:
|
|
case 1:
|
|
case 2:
|
|
case 3:
|
|
j->SetId( 0x3E + rNum2, 2 );
|
|
break;
|
|
case 4:
|
|
case 5:
|
|
case 6:
|
|
j->SetId( 0x4B + ( rNum2 - 4 ), 2 );
|
|
break;
|
|
}
|
|
j->SetColour( color );
|
|
}
|
|
else
|
|
{
|
|
// Hide the facial hair for female characters
|
|
j->SetVisible( VT_PERMHIDDEN );
|
|
}
|
|
}
|
|
|
|
//only refresh once
|
|
caster->SendWornItems( sock );
|
|
Effects->PlaySound( caster, 0x0203 );
|
|
Effects->TempEffect( caster, caster, 19, 0, 0, 0 );
|
|
caster->IsIncognito( true );
|
|
return true;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - splMagicReflection()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Applies effects of Magic Reflection spell
|
|
//o------------------------------------------------------------------------------------------------o
|
|
bool splMagicReflection( [[maybe_unused]] CSocket *sock, CChar *caster, [[maybe_unused]] SI08 curSpell )
|
|
{
|
|
caster->SetTempReflected( true );
|
|
return true;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - splMindBlast()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Applies effects of Mind Blast spell
|
|
//o------------------------------------------------------------------------------------------------o
|
|
bool splMindBlast( CChar *caster, CChar *target, CChar *src, SI08 curSpell )
|
|
{
|
|
SI16 spellDamage = 0;
|
|
SI16 baseDamage = 0;
|
|
|
|
SI16 targetStats = target->GetIntelligence() + target->GetStrength() + target->GetDexterity();
|
|
SI16 casterStats = caster->GetIntelligence() + caster->GetStrength() + caster->GetDexterity();
|
|
|
|
//If target's int makes out a larger percentage of the total stats than the caster's, backfire spell onto caster
|
|
if(( target->GetIntelligence() * 100 ) / targetStats > ( caster->GetIntelligence() * 100 ) / casterStats )
|
|
{
|
|
target = src;
|
|
}
|
|
|
|
bool spellResisted = Magic->CheckResist( caster, target, Magic->spells[curSpell].Circle() );
|
|
|
|
baseDamage = Magic->spells[curSpell].BaseDmg();
|
|
spellDamage = baseDamage;
|
|
spellDamage = CalcSpellDamageMod( caster, target, spellDamage, spellResisted );
|
|
|
|
//Damage should not exceed 60% of target maxHp
|
|
if( spellDamage > ( target->GetMaxHP() * 0.6 ))
|
|
{
|
|
spellDamage = static_cast<SI16>( std::round( target->GetMaxHP() * 0.6 ));
|
|
}
|
|
|
|
//Damage should not exceed basedamage from DFN + 20%
|
|
if( spellDamage > static_cast<SI16>( static_cast<R64>( baseDamage ) * 1.20 ))
|
|
{
|
|
spellDamage = static_cast<SI16>( static_cast<R64>( baseDamage ) * 1.20 );
|
|
}
|
|
|
|
Effects->TempEffect( src, target, 32, spellDamage, 0, 0 );
|
|
return true;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - splParalyze()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Applies effects of Paralyze spell
|
|
//o------------------------------------------------------------------------------------------------o
|
|
bool splParalyze( CChar *caster, CChar *target, [[maybe_unused]] CChar *src, [[maybe_unused]] SI08 curSpell )
|
|
{
|
|
if( !Magic->CheckResist( caster, target, 7 ))
|
|
{
|
|
Effects->TempEffect( caster, target, 1, 0, 0, 0 );
|
|
}
|
|
return true;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - splPoisonField()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Casts Poison Field as a field spell
|
|
//o------------------------------------------------------------------------------------------------o
|
|
bool splPoisonField( [[maybe_unused]] CSocket *sock, CChar *caster, UI08 fieldDir, SI16 x, SI16 y, SI08 z, SI08 curSpell )
|
|
{
|
|
if( fieldDir == 0 )
|
|
{
|
|
return FieldSpell( caster, 0x3915, x, y, z, fieldDir, curSpell );
|
|
}
|
|
else
|
|
{
|
|
return FieldSpell( caster, 0x3921, x, y, z, fieldDir, curSpell );
|
|
}
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - splSummonCreature()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Applies effects of Summon Creature spell (summons a creature)
|
|
//o------------------------------------------------------------------------------------------------o
|
|
bool splSummonCreature( CSocket *sock, CChar *caster, SI16 x, SI16 y, SI08 z, [[maybe_unused]] SI08 curSpell )
|
|
{
|
|
if( caster->GetSkill( MAGERY ) <= 380 )
|
|
{
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
Magic->SummonMonster( sock, caster, 0, x, y, z );
|
|
}
|
|
return true;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - splDispel()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Applies effects of Dispel spell
|
|
//o------------------------------------------------------------------------------------------------o
|
|
bool splDispel( CChar *caster, CChar *target, [[maybe_unused]] CChar *src, [[maybe_unused]] SI08 curSpell )
|
|
{
|
|
if( target->IsDispellable() && !target->IsGM() )
|
|
{
|
|
//Effects->PlayStaticAnimation( target, 0x372A, 0x09, 0x06 ); // why the specifics here?
|
|
if( target->IsNpc() )
|
|
{
|
|
std::vector<UI16> scriptTriggers = target->GetScriptTriggers();
|
|
for( auto scriptTrig : scriptTriggers )
|
|
{
|
|
cScript *toExecute = JSMapping->GetScript( scriptTrig );
|
|
if( toExecute != nullptr )
|
|
{
|
|
if( toExecute->OnDispel( target ) == 1 ) // if it exists and we don't want hard code, return
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// Base chance of dispelling on Dispel caster's Magery skill vs summoner's magicresistance
|
|
UI16 casterMagery = caster->GetSkill( MAGERY );
|
|
UI16 targetResist = 0;
|
|
targetResist = static_cast<UI16>( target->GetSkill( MAGICRESISTANCE ) + static_cast<UI16>( Races->Race( target->GetRace() )->MagicResistance() ));
|
|
|
|
// If creature was summoned, use highest of creature's resist and summoner's resist
|
|
if( target->GetOwner() != INVALIDSERIAL )
|
|
{
|
|
targetResist = std::max( targetResist, static_cast<UI16>( target->GetOwnerObj()->GetSkill( MAGICRESISTANCE ) + static_cast<UI16>( Races->Race( target->GetRace() )->MagicResistance() )));
|
|
}
|
|
|
|
UI16 dispelChance = std::max( static_cast<UI16>( 950 ), ( static_cast<UI16>( std::max( 0.0, static_cast<double>( std::ceil( static_cast<double>( 500 - ( targetResist - casterMagery )) / 1.5 ))))));
|
|
if( dispelChance > RandomNum( 1, 1000 ))
|
|
{
|
|
// Dispel succeeded!
|
|
if( Magic->spells[41].Effect() != INVALIDID )
|
|
{
|
|
Effects->PlaySound( target, Magic->spells[41].Effect() );
|
|
}
|
|
|
|
CMagicStat temp = Magic->spells[41].StaticEffect();
|
|
if( temp.Effect() != INVALIDID )
|
|
{
|
|
// Play static effect at target's location, since target gets destroyed
|
|
Effects->PlayStaticAnimation( target->GetX(), target->GetY(), target->GetZ(), temp.Effect(), temp.Speed(), temp.Loop(), false );
|
|
}
|
|
|
|
target->Delete();
|
|
}
|
|
else if( caster->GetSocket() != nullptr )
|
|
{
|
|
// Dispel resisted!
|
|
caster->GetSocket()->SysMessage( 2761 ); // The creature resisted the attempt to dispel it!
|
|
}
|
|
}
|
|
else
|
|
{
|
|
HandleDeath( target, nullptr );
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - splEnergyBolt()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Applies effects of Energy Bolt spell
|
|
//o------------------------------------------------------------------------------------------------o
|
|
bool splEnergyBolt( CChar *caster, CChar *target, CChar *src, SI08 curSpell )
|
|
{
|
|
SI16 spellDamage = 0;
|
|
bool spellResisted = Magic->CheckResist( caster, target, Magic->spells[curSpell].Circle() );
|
|
|
|
spellDamage = Magic->spells[curSpell].BaseDmg();
|
|
spellDamage = CalcSpellDamageMod( caster, target, spellDamage, spellResisted );
|
|
|
|
Effects->TempEffect( src, target, 33, spellDamage, 0, 0 );
|
|
return true;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - splExplosion()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Applies effects of Explosion spell. Delay configurable in UOX.INI
|
|
//o------------------------------------------------------------------------------------------------o
|
|
bool splExplosion( CChar *caster, CChar *target, CChar *src, SI08 curSpell )
|
|
{
|
|
SI16 spellDamage = 0;
|
|
bool spellResisted = Magic->CheckResist( caster, target, Magic->spells[curSpell].Circle() );
|
|
|
|
spellDamage = Magic->spells[curSpell].BaseDmg();
|
|
spellDamage = CalcSpellDamageMod( caster, target, spellDamage, spellResisted );
|
|
|
|
Effects->TempEffect( src, target, 27, spellDamage, 0, 0 );
|
|
return true;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - splInvisibility()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Applies effects of Invisibility spell
|
|
//o------------------------------------------------------------------------------------------------o
|
|
bool splInvisibility( CChar *caster, CChar *target, [[maybe_unused]] CChar *src, [[maybe_unused]] SI08 curSpell )
|
|
{
|
|
target->SetVisible( VT_INVISIBLE );
|
|
target->SetTimer( tCHAR_INVIS, cwmWorldState->ServerData()->BuildSystemTimeValue( tSERVER_INVISIBILITY ));
|
|
if( target->IsMurderer() )
|
|
{
|
|
MakeCriminal( caster );
|
|
}
|
|
|
|
//Stop autodefending against targets in combat once you turn invisible
|
|
if( !target->IsNpc() )
|
|
{
|
|
Combat->InvalidateAttacker( target );
|
|
}
|
|
return true;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - splMark()
|
|
//| Date - 09/22/2002
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Applies effects of Mark spell
|
|
//|
|
|
//| Changes - 09/22/2002 - Fixed marking of locked down runes..
|
|
//| (shouldn't be possible)
|
|
//o------------------------------------------------------------------------------------------------o
|
|
bool splMark( CSocket *sock, CChar *caster, CItem *i, [[maybe_unused]] SI08 curSpell )
|
|
{
|
|
if( i->IsLockedDown() )
|
|
{
|
|
sock->SysMessage( 774 ); // That is locked down and you cannot use it.
|
|
return false;
|
|
}
|
|
|
|
if( i->GetType() == IT_RUNEBOOK )
|
|
{
|
|
sock->SysMessage( 710 ); // That item is not a recall rune.
|
|
return false;
|
|
}
|
|
|
|
bool markedInMulti = false;
|
|
CMultiObj *multi = caster->GetMultiObj();
|
|
if( ValidateObject( multi ))
|
|
{
|
|
if( !multi->IsOnOwnerList( caster ))
|
|
{
|
|
sock->SysMessage( 9034 ); // Marking a rune in property you don't own is not possible.
|
|
return false;
|
|
}
|
|
else if( !cwmWorldState->ServerData()->MarkRunesInMultis() )
|
|
{
|
|
sock->SysMessage( 9035 ); // "Marking a rune inside one's property is not permitted.
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
// Let's allow marking the rune in the multi, and store multi's serial in a tag
|
|
auto mSerial = multi->GetSerial();
|
|
TAGMAPOBJECT tagObject;
|
|
tagObject.m_Destroy = false;
|
|
tagObject.m_StringValue = std::to_string( mSerial );
|
|
tagObject.m_IntValue = static_cast<SI32>( tagObject.m_StringValue.size() );
|
|
tagObject.m_ObjectType = TAGMAP_TYPE_STRING;
|
|
i->SetTag( "multiSerial", tagObject );
|
|
markedInMulti = true;
|
|
|
|
std::string tempRuneName = oldstrutil::format( Dictionary->GetEntry( 684 ), multi->GetNameRequest( caster, NRS_SYSTEM ).c_str() ); // A recall rune for %s.
|
|
if( tempRuneName.length() > 0 )
|
|
{
|
|
i->SetName( tempRuneName );
|
|
}
|
|
}
|
|
}
|
|
|
|
if( !markedInMulti )
|
|
{
|
|
i->SetTempVar( CITV_MOREX, caster->GetX() );
|
|
i->SetTempVar( CITV_MOREY, caster->GetY() );
|
|
i->SetTempVar( CITV_MOREZ, caster->GetZ() );
|
|
i->SetTempVar( CITV_MORE, caster->WorldNumber() );
|
|
i->SetTempVar( CITV_MORE0, caster->GetInstanceId() );
|
|
|
|
std::string tempitemname;
|
|
|
|
if( caster->GetRegion()->GetName()[0] != 0 )
|
|
{
|
|
tempitemname = oldstrutil::format( Dictionary->GetEntry( 684 ), caster->GetRegion()->GetName().c_str() ); // A recall rune for %s.
|
|
}
|
|
else
|
|
{
|
|
tempitemname = Dictionary->GetEntry( 685 ); // A recall rune for An Unknown Location.
|
|
}
|
|
i->SetName( tempitemname );
|
|
|
|
// Change ID of rune from a blank, unmarked rune (0x1f17) to a marked one (0x1f14)
|
|
i->SetId( 0x1f14 );
|
|
}
|
|
|
|
sock->SysMessage( 686 ); // Recall rune marked.
|
|
return true;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - MassCurseStub()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Applies effects of Mass Curse spell to an individual target
|
|
//o------------------------------------------------------------------------------------------------o
|
|
void MassCurseStub( CChar *caster, CChar *target, [[maybe_unused]] SI08 curSpell, [[maybe_unused]] SI08 targCount )
|
|
{
|
|
if( target->IsNpc() && target->GetNpcAiType() == AI_PLAYERVENDOR )
|
|
return; // Player Vendors can't be killed
|
|
|
|
if( target->IsGM() || target->IsInvulnerable() )
|
|
return; // GMs/Invuls can't be killed
|
|
|
|
if( target->IsNpc() && target == caster )
|
|
return; // Don't let NPC curse themselves
|
|
|
|
if( target->IsNpc() && caster->IsNpc() )
|
|
{
|
|
if( target->GetNPCFlag() == caster->GetNPCFlag() )
|
|
return; // Don't let NPCs curse other NPCs with same NPC Flag (innocent, evil, neutral)
|
|
|
|
switch( caster->GetNpcAiType() )
|
|
{
|
|
case 2: // AI_EVIL
|
|
case 11: // AI_EVIL_CASTER
|
|
{
|
|
if( target->GetNpcAiType() == AI_EVIL || target->GetNpcAiType() == AI_EVIL_CASTER )
|
|
return; // Don't curse NPCs with similar AI types
|
|
break;
|
|
}
|
|
case 5: // AI_FIGHTER
|
|
case 10: // AI_CASTER
|
|
{
|
|
if( target->GetNpcAiType() == AI_FIGHTER || target->GetNpcAiType() == AI_CASTER )
|
|
return; // Don't curse NPCs with similar AI types
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
SI32 j;
|
|
if( target->IsNpc() )
|
|
{
|
|
Combat->AttackTarget( caster, target );
|
|
}
|
|
Effects->PlayStaticAnimation( target, 0x374A, 0, 15 );
|
|
Effects->PlaySound( target, 0x01FC );
|
|
if( Magic->CheckResist( caster, target, 6 ))
|
|
{
|
|
j = caster->GetSkill( MAGERY ) / 200;
|
|
}
|
|
else
|
|
{
|
|
j = caster->GetSkill( MAGERY ) / 75;
|
|
}
|
|
Effects->TempEffect( caster, target, 12, j, j, j );
|
|
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - splMassCurse()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Casts Mass Curse as an area affect spell
|
|
//o------------------------------------------------------------------------------------------------o
|
|
bool splMassCurse( CSocket *sock, CChar *caster, [[maybe_unused]] CChar *target, [[maybe_unused]] CChar *src, SI08 curSpell )
|
|
{
|
|
AreaAffectSpell( sock, caster, &MassCurseStub, curSpell );
|
|
return true;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - splParalyzeField()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Casts Paralyze Field as a field spell
|
|
//o------------------------------------------------------------------------------------------------o
|
|
bool splParalyzeField( [[maybe_unused]] CSocket *sock, CChar *caster, UI08 fieldDir, SI16 x, SI16 y, SI08 z, SI08 curSpell )
|
|
{
|
|
if( fieldDir == 0 )
|
|
{
|
|
return FieldSpell( caster, 0x3967, x, y, z, fieldDir, curSpell );
|
|
}
|
|
else
|
|
{
|
|
return FieldSpell( caster, 0x3979, x, y, z, fieldDir, curSpell );
|
|
}
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - splReveal()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Applies effects of Reveal spell
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto splReveal( CSocket *sock, CChar *caster, SI16 x, SI16 y, SI08 z, [[maybe_unused]] SI08 curSpell ) -> bool
|
|
{
|
|
if( LineOfSight( sock, caster, x, y, z, WALLS_CHIMNEYS + DOORS + FLOORS_FLAT_ROOFING, false ) || caster->IsGM() )
|
|
{
|
|
UI16 j = caster->GetSkill( MAGERY );
|
|
SI32 revealRange = ((( j - 261 ) * ( 15 )) / 739 ) + 5;
|
|
//If the caster has a Magery of 26.1 (min to cast reveal w/ scroll), revealRange radius is
|
|
//5 tiles, if magery is maxed out at 100.0 (except for gms I suppose), revealRange is 20
|
|
|
|
for( auto &MapArea : MapRegion->PopulateList( caster ))
|
|
{
|
|
if( MapArea )
|
|
{
|
|
auto regChars = MapArea->GetCharList();
|
|
for( const auto &tempChar : regChars->collection() )
|
|
{
|
|
if( ValidateObject( tempChar ) && tempChar->GetInstanceId() == caster->GetInstanceId() )
|
|
{
|
|
if( tempChar->GetVisible() == VT_TEMPHIDDEN || tempChar->GetVisible() == VT_INVISIBLE )
|
|
{
|
|
Point3_st difference = ( tempChar->GetLocation() - Point3_st( x, y, z ));
|
|
if( difference.MagSquared() <= ( revealRange * revealRange )) // char to reveal is within radius or range
|
|
{
|
|
tempChar->ExposeToView();
|
|
CMagicStat temp = Magic->spells[48].StaticEffect();
|
|
if( temp.Effect() != INVALIDID )
|
|
{
|
|
Effects->PlayStaticAnimation( tempChar, temp.Effect(), temp.Speed(), temp.Loop() );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if( Magic->spells[48].Effect() != INVALIDID )
|
|
{
|
|
Effects->PlaySound( sock, Magic->spells[48].Effect(), true );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
sock->SysMessage( 687 ); // You would like to see if anything was there, but there is too much stuff in the way.
|
|
}
|
|
return true;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - ChainLightningStub()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Applies effects of Chain Lightning spell to an individual target
|
|
//o------------------------------------------------------------------------------------------------o
|
|
void ChainLightningStub( CChar *caster, CChar *target, SI08 curSpell, SI08 targCount )
|
|
{
|
|
if( target->IsNpc() && target->GetNpcAiType() == AI_PLAYERVENDOR )
|
|
return; // Player Vendors can't be killed
|
|
|
|
if( target->IsGM() || target->IsInvulnerable() )
|
|
return; // GMs/Invuls can't be killed
|
|
|
|
if( target->IsNpc() && target == caster )
|
|
return; // Don't let NPC hit themselves with damaging spell
|
|
|
|
if( target->IsNpc() && caster->IsNpc() )
|
|
{
|
|
if( target->GetNPCFlag() == caster->GetNPCFlag() )
|
|
return; // Don't let NPCs damage other NPCs with same NPC Flag (innocent, evil, neutral)
|
|
|
|
switch( caster->GetNpcAiType() )
|
|
{
|
|
case 2: // AI_EVIL
|
|
case 11: // AI_EVIL_CASTER
|
|
{
|
|
if( target->GetNpcAiType() == AI_EVIL || target->GetNpcAiType() == AI_EVIL_CASTER )
|
|
return; // Don't damage NPCs with similar AI types
|
|
break;
|
|
}
|
|
case 5: // AI_FIGHTER
|
|
case 10: // AI_CASTER
|
|
{
|
|
if( target->GetNpcAiType() == AI_FIGHTER || target->GetNpcAiType() == AI_CASTER )
|
|
return; // Don't damage NPCs with similar AI types
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
if( target->IsNpc() )
|
|
{
|
|
Combat->AttackTarget( target, caster );
|
|
}
|
|
/*Effects->PlaySound( caster, 0x0029 );*/
|
|
[[maybe_unused]] CChar *def = nullptr;
|
|
if( Magic->CheckMagicReflect( target ))
|
|
{
|
|
def = caster;
|
|
}
|
|
else
|
|
{
|
|
def = target;
|
|
}
|
|
|
|
SI16 spellDamage = 0;
|
|
bool spellResisted = Magic->CheckResist( caster, target, Magic->spells[curSpell].Circle() );
|
|
|
|
spellDamage = Magic->spells[curSpell].BaseDmg();
|
|
spellDamage = CalcSpellDamageMod( caster, target, spellDamage, spellResisted );
|
|
|
|
//If targetCOunt is > 1, do equal damage to two targets, split damage on more targets
|
|
if( targCount > 1 )
|
|
{
|
|
spellDamage = ( spellDamage * 2 ) / targCount;
|
|
}
|
|
|
|
Effects->TempEffect( caster, target, 34, spellDamage, 0, 0 );
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - splChainLightning()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Casts Chain Lightning as an area affect spell
|
|
//o------------------------------------------------------------------------------------------------o
|
|
bool splChainLightning( CSocket *sock, CChar *caster, [[maybe_unused]] CChar *target, [[maybe_unused]] CChar *src, SI08 curSpell )
|
|
{
|
|
AreaAffectSpell( sock, caster, &ChainLightningStub, curSpell );
|
|
return true;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - splEnergyField()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Casts Energy Field spell as a field spell
|
|
//o------------------------------------------------------------------------------------------------o
|
|
bool splEnergyField( [[maybe_unused]] CSocket *sock, CChar *caster, UI08 fieldDir, SI16 x, SI16 y, SI08 z, SI08 curSpell )
|
|
{
|
|
if( fieldDir == 0 )
|
|
{
|
|
return FieldSpell( caster, 0x3946, x, y, z, fieldDir, curSpell );
|
|
}
|
|
else
|
|
{
|
|
return FieldSpell( caster, 0x3956, x, y, z, fieldDir, curSpell );
|
|
}
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - splFlameStrike()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Applies effects of Flame Strike spell on target
|
|
//o------------------------------------------------------------------------------------------------o
|
|
bool splFlameStrike( CChar *caster, CChar *target, [[maybe_unused]] CChar *src, SI08 curSpell )
|
|
{
|
|
SI16 spellDamage = 0;
|
|
bool spellResisted = Magic->CheckResist( caster, target, Magic->spells[curSpell].Circle() );
|
|
|
|
spellDamage = Magic->spells[curSpell].BaseDmg();
|
|
spellDamage = CalcSpellDamageMod( caster, target, spellDamage, spellResisted );
|
|
|
|
Effects->TempEffect( caster, target, 35, spellDamage, 0, 0 );
|
|
return true;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - splGateTravel()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Applies effects of Gate Travel spell (opens gate from recall rune)
|
|
//o------------------------------------------------------------------------------------------------o
|
|
bool splGateTravel( CSocket *sock, CChar *caster, CItem *i, [[maybe_unused]] SI08 curSpell )
|
|
{
|
|
// No recall if too heavy, GM's excempt
|
|
if( Weight->IsOverloaded( caster ) && !cwmWorldState->ServerData()->TravelSpellsWhileOverweight() && ( !caster->IsCounselor() && !caster->IsGM() ))
|
|
{
|
|
sock->SysMessage( 680 ); // You are too heavy to do that!
|
|
sock->SysMessage( 681 ); // You feel drained from the attempt.
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
// Check if rune was marked in a multi - if so, try to take user directly there
|
|
TAGMAPOBJECT runeMore = i->GetTag( "multiSerial" );
|
|
if( runeMore.m_StringValue != "" )
|
|
{
|
|
SERIAL mSerial = oldstrutil::value<SERIAL>( runeMore.m_StringValue );
|
|
if( mSerial != 0 && mSerial != INVALIDSERIAL )
|
|
{
|
|
CMultiObj *shipMulti = CalcMultiFromSer( mSerial );
|
|
if( ValidateObject( shipMulti ) && shipMulti->CanBeObjType( OT_BOAT ))
|
|
{
|
|
if(( shipMulti->WorldNumber() == caster->WorldNumber() || cwmWorldState->ServerData()->TravelSpellsBetweenWorlds() ) && shipMulti->GetInstanceId() == caster->GetInstanceId() )
|
|
{
|
|
if( shipMulti->WorldNumber() == 0 && caster->WorldNumber() != 0 && cwmWorldState->ServerData()->YoungPlayerSystem() && caster->GetAccount().wFlags.test( AB_FLAGS_YOUNG ) )
|
|
{
|
|
sock->SysMessage( 18733 ); // You decide against traveling to Felucca while you are still young.
|
|
return false;
|
|
}
|
|
|
|
caster->SetLocation( shipMulti->GetX() + 1, shipMulti->GetY(), shipMulti->GetZ() + 3 );
|
|
SpawnGate( caster, caster->GetX() + 1, caster->GetY() + 1, caster->GetZ(), caster->WorldNumber(), shipMulti->GetX() + 1, shipMulti->GetY(), shipMulti->GetZ() + 3, shipMulti->WorldNumber(), shipMulti->GetInstanceId() );
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
sock->SysMessage( 2064 ); // You are unable to open a gate to your ship - it might be in another world!
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
sock->SysMessage( 2062 ); // Unable to locate ship - it might have been dry-docked... or sunk!
|
|
return false;
|
|
}
|
|
else if( i->GetTempVar( CITV_MOREX ) == 0 && i->GetTempVar( CITV_MOREY ) == 0 )
|
|
{
|
|
sock->SysMessage( 679 ); // That rune has not been marked yet!
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
UI08 worldNum = static_cast<UI08>( i->GetTempVar( CITV_MORE ));
|
|
if( !Map->MapExists( worldNum ))
|
|
{
|
|
worldNum = caster->WorldNumber();
|
|
}
|
|
if( caster->WorldNumber() != worldNum && !cwmWorldState->ServerData()->TravelSpellsBetweenWorlds() )
|
|
{
|
|
sock->SysMessage( 2061 ); // Travelling between worlds using Recall or Gate spells is not possible.
|
|
return false;
|
|
}
|
|
|
|
if( worldNum == 0 && caster->WorldNumber() != 0 && cwmWorldState->ServerData()->YoungPlayerSystem() && caster->GetAccount().wFlags.test( AB_FLAGS_YOUNG ) )
|
|
{
|
|
sock->SysMessage( 18733 ); // You decide against traveling to Felucca while you are still young.
|
|
return false;
|
|
}
|
|
|
|
SI16 targLocX = static_cast<SI16>( i->GetTempVar( CITV_MOREX ));
|
|
SI16 targLocY = static_cast<SI16>( i->GetTempVar( CITV_MOREY ));
|
|
SI08 targLocZ = static_cast<SI08>( i->GetTempVar( CITV_MOREZ ));
|
|
UI16 instanceId = static_cast<UI16>( i->GetTempVar( CITV_MORE0 ));
|
|
SpawnGate( caster, caster->GetX() + 1, caster->GetY() + 1, caster->GetZ(), caster->WorldNumber(), targLocX, targLocY, targLocZ, worldNum, instanceId );
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - splManaVampire()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Applies effects of Mana Vampire spell to target
|
|
//o------------------------------------------------------------------------------------------------o
|
|
bool splManaVampire( CChar *caster, CChar *target, [[maybe_unused]] CChar *src, [[maybe_unused]] SI08 curSpell )
|
|
{
|
|
if( !Magic->CheckResist( caster, target, 7 ))
|
|
{
|
|
if( target->GetMana() < 40 )
|
|
{
|
|
caster->SetMana( caster->GetMana() + target->GetMana() );
|
|
target->SetMana( 0 );
|
|
}
|
|
else
|
|
{
|
|
target->SetMana( target->GetMana() - 40 );
|
|
caster->SetMana( caster->GetMana() + 40 );
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - MassDispelStub()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Applies effects of Mass Dispel spell to an individual target
|
|
//o------------------------------------------------------------------------------------------------o
|
|
void MassDispelStub( CChar *caster, CChar *target, [[maybe_unused]] SI08 curSpell, [[maybe_unused]] SI08 targCount )
|
|
{
|
|
if( target->IsDispellable() )
|
|
{
|
|
//Effects->PlayStaticAnimation( target, 0x372A, 0x09, 0x06 ); // why the specifics here?
|
|
if( target->IsNpc() )
|
|
{
|
|
std::vector<UI16> scriptTriggers = target->GetScriptTriggers();
|
|
for( auto scriptTrig : scriptTriggers )
|
|
{
|
|
cScript *toExecute = JSMapping->GetScript( scriptTrig );
|
|
if( toExecute != nullptr )
|
|
{
|
|
if( toExecute->OnDispel( target ) == 1 ) // if it exists and we don't want hard code, return
|
|
return;
|
|
}
|
|
}
|
|
|
|
// Base chance of dispelling on Dispel caster's Magery skill vs summoner's magicresistance
|
|
UI16 casterMagery = caster->GetSkill( MAGERY );
|
|
UI16 targetResist = 0;
|
|
targetResist = static_cast<UI16>( target->GetSkill( MAGICRESISTANCE ) + static_cast<UI16>( Races->Race( target->GetRace() )->MagicResistance() ));
|
|
|
|
// If creature was summoned, use highest of creature's resist and summoner's resist
|
|
if( target->GetOwner() != INVALIDSERIAL )
|
|
{
|
|
targetResist = std::max( targetResist, static_cast<UI16>( target->GetOwnerObj()->GetSkill( MAGICRESISTANCE ) + static_cast<UI16>( Races->Race( target->GetRace() )->MagicResistance() )));
|
|
}
|
|
|
|
UI16 dispelChance = static_cast<UI16>( std::max( static_cast<UI16>( 950 ), static_cast<UI16>( std::ceil(( 500 - ( targetResist - casterMagery )) / 1.5 ))));
|
|
if( dispelChance > RandomNum( 1, 1000 ))
|
|
{
|
|
// Dispel succeeded!
|
|
if( Magic->spells[41].Effect() != INVALIDID )
|
|
{
|
|
Effects->PlaySound( target, Magic->spells[41].Effect() );
|
|
}
|
|
|
|
CMagicStat temp = Magic->spells[41].StaticEffect();
|
|
if( temp.Effect() != INVALIDID )
|
|
{
|
|
// Play static effect at target's location, since target gets destroyed
|
|
Effects->PlayStaticAnimation( target->GetX(), target->GetY(), target->GetZ(), temp.Effect(), temp.Speed(), temp.Loop(), false );
|
|
}
|
|
|
|
target->Delete();
|
|
}
|
|
else if( caster->GetSocket() != nullptr )
|
|
{
|
|
// Dispel resisted!
|
|
caster->GetSocket()->SysMessage( 2761 ); // The creature resisted the attempt to dispel it!
|
|
}
|
|
}
|
|
else
|
|
{
|
|
HandleDeath( target, nullptr );
|
|
}
|
|
}
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - splMassDispel()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Casts Mass Dispel spell as an area affect spell
|
|
//o------------------------------------------------------------------------------------------------o
|
|
bool splMassDispel( CSocket *sock, CChar *caster, [[maybe_unused]] CChar *target, [[maybe_unused]] CChar *src, SI08 curSpell )
|
|
{
|
|
AreaAffectSpell( sock, caster, &MassDispelStub, curSpell );
|
|
return true;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - MeteorSwarmStub()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Applies effects of Meteor Swarm spell to an individual target
|
|
//o------------------------------------------------------------------------------------------------o
|
|
void MeteorSwarmStub( CChar *caster, CChar *target, SI08 curSpell, SI08 targCount )
|
|
{
|
|
if( target->IsNpc() && target->GetNpcAiType() == AI_PLAYERVENDOR )
|
|
return; // Player Vendors can't be killed
|
|
|
|
if( target->IsInvulnerable() )
|
|
return; // GMs/Invuls can't be killed
|
|
|
|
if( target->IsNpc() && target == caster )
|
|
return; // Don't let NPC hit themselves with damaging spell
|
|
|
|
if( target->IsNpc() && caster->IsNpc() )
|
|
{
|
|
if( target->GetNPCFlag() == caster->GetNPCFlag() )
|
|
return; // Don't let NPCs damage other NPCs with same NPC Flag (innocent, evil, neutral)
|
|
|
|
switch( caster->GetNpcAiType() )
|
|
{
|
|
case 2: // AI_EVIL
|
|
case 11: // AI_EVIL_CASTER
|
|
{
|
|
if( target->GetNpcAiType() == AI_EVIL || target->GetNpcAiType() == AI_EVIL_CASTER )
|
|
return; // Don't damage NPCs with similar AI types
|
|
break;
|
|
}
|
|
case 5: // AI_FIGHTER
|
|
case 10: // AI_CASTER
|
|
{
|
|
if( target->GetNpcAiType() == AI_FIGHTER || target->GetNpcAiType() == AI_CASTER )
|
|
return; // Don't damage NPCs with similar AI types
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
if( target->IsNpc() )
|
|
{
|
|
Combat->AttackTarget( target, caster );
|
|
}
|
|
|
|
SI16 spellDamage = 0;
|
|
bool spellResisted = Magic->CheckResist( caster, target, Magic->spells[curSpell].Circle() );
|
|
|
|
spellDamage = Magic->spells[curSpell].BaseDmg();
|
|
spellDamage = CalcSpellDamageMod( caster, target, spellDamage, spellResisted );
|
|
|
|
//If targetCOunt is > 1, do equal damage to two targets, split damage on more targets
|
|
if( targCount > 1 )
|
|
{
|
|
spellDamage = ( spellDamage * 2 ) / targCount;
|
|
}
|
|
|
|
Effects->TempEffect( caster, target, 36, spellDamage, 0, 0 );
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - AreaAffectSpell()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Provides shared functionality for all area affect spells
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto AreaAffectSpell( CSocket *sock, CChar *caster, void (*trgFunc)( MAGIC_AREA_STUB_LIST ), SI08 curSpell ) -> bool
|
|
{
|
|
SI16 x1, x2, y1, y2;
|
|
SI08 z1, z2;
|
|
x1 = x2 = y1 = y2 = z1 = z2 = 0;
|
|
SI08 targCount = 0;
|
|
UI16 i;
|
|
std::vector<CChar *> targetList;
|
|
|
|
Magic->BoxSpell( sock, caster, x1, x2, y1, y2, z1, z2 );
|
|
|
|
for( auto &MapArea : MapRegion->PopulateList( caster ))
|
|
{
|
|
if( MapArea )
|
|
{
|
|
auto regChars = MapArea->GetCharList();
|
|
for( const auto &tempChar : regChars->collection() )
|
|
{
|
|
if( ValidateObject( tempChar ) && tempChar->GetInstanceId() == caster->GetInstanceId() )
|
|
{
|
|
if( tempChar->GetX() >= x1 && tempChar->GetX() <= x2 && tempChar->GetY() >= y1 && tempChar->GetY() <= y2 &&
|
|
tempChar->GetZ() >= z1 && tempChar->GetZ() <= z2 && ( IsOnline(( *tempChar )) || tempChar->IsNpc() ))
|
|
{
|
|
if( tempChar == caster || LineOfSight( sock, caster, tempChar->GetX(), tempChar->GetY(), tempChar->GetZ(), WALLS_CHIMNEYS + DOORS + FLOORS_FLAT_ROOFING, false ) || caster->IsGM() )
|
|
{
|
|
//Store target candidates in targetList
|
|
targetList.push_back( tempChar );
|
|
//trgFunc( caster, tempChar, curSpell, targCount );
|
|
}
|
|
else if( sock )
|
|
{
|
|
sock->SysMessage( 688 ); // You cannot see the target well.
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Iterate through list of valid targets, do damage
|
|
targCount = static_cast<SI08>( targetList.size() );
|
|
for( i = 0; i < targetList.size(); ++i )
|
|
{
|
|
trgFunc( caster, targetList[i], curSpell, targCount );
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - splMeteorSwarm()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Casts Meteor Swarm spell as an area affect spell
|
|
//o------------------------------------------------------------------------------------------------o
|
|
bool splMeteorSwarm( CSocket *sock, CChar *caster, [[maybe_unused]] CChar *target, [[maybe_unused]] CChar *src, SI08 curSpell )
|
|
{
|
|
AreaAffectSpell( sock, caster, &MeteorSwarmStub, curSpell );
|
|
return true;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - splPolymorph()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Applies effects of Polymorph spell
|
|
//o------------------------------------------------------------------------------------------------o
|
|
bool splPolymorph( CSocket *sock, CChar *caster, [[maybe_unused]] SI08 curSpell )
|
|
{
|
|
if( caster->IsPolymorphed() )
|
|
{
|
|
sock->SysMessage( 1637 ); // You cannot polymorph while already in another form
|
|
}
|
|
else if( caster->IsIncognito() )
|
|
{
|
|
sock->SysMessage( 1673 ); // You can't do that while incognito.
|
|
}
|
|
else if( caster->IsDisguised() )
|
|
{
|
|
sock->SysMessage( 9233 ); // You cannot polymorph while disguised.
|
|
}
|
|
else if( caster->GetId() == 0x00b8 || caster->GetId() == 0x00b7 ) // Savage Kin Paint transformation
|
|
{
|
|
sock->SysMessage( 1671 ); // You cannot polymorph while wearing body paint
|
|
}
|
|
else
|
|
{
|
|
Magic->PolymorphMenu( sock, POLYMORPHMENUOFFSET ); // Polymorph
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - EarthquakeStub()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Applies effects of Earthquake spell to an individual target
|
|
//o------------------------------------------------------------------------------------------------o
|
|
void EarthquakeStub( CChar *caster, CChar *target, SI08 curSpell, [[maybe_unused]] SI08 targCount )
|
|
{
|
|
// Check if target is in a safe zone, or invulnerable
|
|
if( target->GetRegion()->IsSafeZone() || target->IsInvulnerable() )
|
|
{
|
|
// Target is in a safe zone, or invulnerable ignore spell effect
|
|
return;
|
|
}
|
|
|
|
if( target == caster )
|
|
return; // Don't let caster hit themselves with damaging spell
|
|
|
|
if( target->IsNpc() && caster->IsNpc() )
|
|
{
|
|
if( target->GetNPCFlag() == caster->GetNPCFlag() )
|
|
return; // Don't let NPCs damage other NPCs with same NPC Flag (innocent, evil, neutral)
|
|
|
|
switch( caster->GetNpcAiType() )
|
|
{
|
|
case 2: // AI_EVIL
|
|
case 11: // AI_EVIL_CASTER
|
|
{
|
|
if( target->GetNpcAiType() == AI_EVIL || target->GetNpcAiType() == AI_EVIL_CASTER )
|
|
return; // Don't damage NPCs with similar AI types
|
|
break;
|
|
}
|
|
case 5: // AI_FIGHTER
|
|
case 10: // AI_CASTER
|
|
{
|
|
if( target->GetNpcAiType() == AI_FIGHTER || target->GetNpcAiType() == AI_CASTER )
|
|
return; // Don't damage NPCs with similar AI types
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Turn caster criminal if applicable
|
|
if( WillResultInCriminal( caster, target ) && !caster->IsGM() && !caster->IsCounselor() )
|
|
{
|
|
MakeCriminal( caster );
|
|
}
|
|
|
|
SI32 distx = abs( target->GetX() - caster->GetX() );
|
|
SI32 disty = abs( target->GetY() - caster->GetY() );
|
|
SI32 dmgmod = std::min( distx, disty );
|
|
dmgmod = -( dmgmod - 7 );
|
|
|
|
SI16 spellDamage = 0;
|
|
bool spellResisted = Magic->CheckResist( caster, target, Magic->spells[curSpell].Circle() );
|
|
|
|
spellDamage = Magic->spells[curSpell].BaseDmg();
|
|
spellDamage = CalcSpellDamageMod( caster, target, spellDamage, spellResisted );
|
|
|
|
//If targetCOunt is > 1, do equal damage to two targets, split damage on more targets
|
|
//if( targCount > 1 )
|
|
// spellDamage = ( spellDamage * 2 ) / targCount;
|
|
|
|
//Apply bonus damage based on target distance from center of earthquake
|
|
spellDamage += dmgmod;
|
|
|
|
if( target->Damage( spellDamage, LIGHTNING, caster, true ))
|
|
{
|
|
// If this killed the target, don't continue
|
|
if( target->IsDead() )
|
|
return;
|
|
}
|
|
|
|
target->SetStamina( target->GetStamina() - ( RandomNum( 0, 9 ) + 5 ));
|
|
|
|
if( target->GetStamina() == -1 )
|
|
{
|
|
target->SetStamina( 0 );
|
|
}
|
|
|
|
if(( !target->IsNpc() && IsOnline(( *target ))) || ( target->IsNpc() && cwmWorldState->creatures[target->GetId()].IsHuman() ))
|
|
{
|
|
if( !target->IsOnHorse() && !target->IsFlying() )
|
|
{
|
|
if( target->GetBodyType() == BT_GARGOYLE )
|
|
{
|
|
Effects->PlayNewCharacterAnimation( target, N_ACT_IMPACT ); // Impact anim (0x04) - can't seem to trigger death anim manually with new animation packet
|
|
}
|
|
else // BT_HUMAN and BT_ELF
|
|
{
|
|
if( RandomNum( 0, 1 ))
|
|
{
|
|
Effects->PlayCharacterAnimation( target, ACT_DIE_BACKWARD, 0, 6 ); // Death anim variation 1 - 0x15, forward
|
|
}
|
|
else
|
|
{
|
|
Effects->PlayCharacterAnimation( target, ACT_DIE_FORWARD, 0, 6 ); // Death anim variation 2 - 0x16, backward
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else // Monsters, animals
|
|
{
|
|
if( target->GetHP() > 0 )
|
|
{
|
|
Effects->PlayCharacterAnimation( target, 0x2, 0, 4 );
|
|
}
|
|
}
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - splEarthquake()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Casts Earthquake spell as an area affect spell
|
|
//o------------------------------------------------------------------------------------------------o
|
|
bool splEarthquake( CSocket *sock, CChar *caster, SI08 curSpell )
|
|
{
|
|
if( sock != nullptr )
|
|
{
|
|
sock->SetWord( 11, caster->GetX() );
|
|
sock->SetWord( 13, caster->GetY() );
|
|
sock->SetByte( 16, caster->GetZ() );
|
|
}
|
|
AreaAffectSpell( sock, caster, &EarthquakeStub, curSpell );
|
|
return true;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - splEnergyVortex()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Applies effects of Energy Vortex spell (summons an Energy Vortex)
|
|
//o------------------------------------------------------------------------------------------------o
|
|
bool splEnergyVortex( CSocket *sock, CChar *caster, SI16 x, SI16 y, SI08 z, [[maybe_unused]] SI08 curSpell )
|
|
{
|
|
if( caster->GetSkill( MAGERY ) <= 800 )
|
|
return false;
|
|
|
|
Magic->SummonMonster( sock, caster, 1, x, y, z );
|
|
return true;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - splResurrection()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Applies effects of Resurrection spell to a target
|
|
//o------------------------------------------------------------------------------------------------o
|
|
bool splResurrection( [[maybe_unused]] CChar *caster, CChar *target, [[maybe_unused]] CChar *src, [[maybe_unused]] SI08 curSpell )
|
|
{
|
|
if( target->IsDead() )
|
|
{
|
|
NpcResurrectTarget( target );
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - splSummonAir()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Applies effects of Summon Air Elemental spell (Summons Air Elemental)
|
|
//o------------------------------------------------------------------------------------------------o
|
|
bool splSummonAir( CSocket *sock, CChar *caster, [[maybe_unused]] SI08 curSpell )
|
|
{
|
|
if( caster->GetSkill( MAGERY ) <= 800 )
|
|
return false;
|
|
|
|
Magic->SummonMonster( sock, caster, 2, caster->GetX() + 1, caster->GetY() + 1, caster->GetZ() );
|
|
return true;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - splSummonDaemon()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Applies effects of Summon Daemon spell (Summons Daemon)
|
|
//o------------------------------------------------------------------------------------------------o
|
|
bool splSummonDaemon( CSocket *sock, CChar *caster, [[maybe_unused]] SI08 curSpell )
|
|
{
|
|
if( caster->GetSkill( MAGERY ) <= 800 )
|
|
return false;
|
|
|
|
Magic->SummonMonster( sock, caster, 7, caster->GetX() + 1, caster->GetY() + 1, caster->GetZ() );
|
|
return true;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - splSummonEarth()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Applies effects of Summon Earth Elemental spell (Summons Earth Elemental)
|
|
//o------------------------------------------------------------------------------------------------o
|
|
bool splSummonEarth( CSocket *sock, CChar *caster, [[maybe_unused]] SI08 curSpell )
|
|
{
|
|
if( caster->GetSkill( MAGERY ) <= 800 )
|
|
return false;
|
|
|
|
Magic->SummonMonster( sock, caster, 3, caster->GetX() + 1, caster->GetY() + 1, caster->GetZ() );
|
|
return true;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - splSummonFire()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Applies effects of Summon Fire Elemental spell (Summons Fire Elemental)
|
|
//o------------------------------------------------------------------------------------------------o
|
|
bool splSummonFire( CSocket *sock, CChar *caster, [[maybe_unused]] SI08 curSpell )
|
|
{
|
|
if( caster->GetSkill( MAGERY ) <= 800 )
|
|
return false;
|
|
|
|
Magic->SummonMonster( sock, caster, 4, caster->GetX() + 1, caster->GetY() + 1, caster->GetZ() );
|
|
return true;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - splSummonWater()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Applies effects of Summon Water Elemental spell (Summons Water Elemental)
|
|
//o------------------------------------------------------------------------------------------------o
|
|
bool splSummonWater( CSocket *sock, CChar *caster, [[maybe_unused]] SI08 curSpell )
|
|
{
|
|
if( caster->GetSkill( MAGERY ) <= 800 )
|
|
return false;
|
|
|
|
Magic->SummonMonster( sock, caster, 5, caster->GetX() + 1, caster->GetY() + 1, caster->GetZ() );
|
|
return true;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - splRandom()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Applies effects of Summon Monster spell (Summons random monster)
|
|
//o------------------------------------------------------------------------------------------------o
|
|
bool splRandom( CSocket *sock, CChar *caster, [[maybe_unused]] SI08 curSpell )
|
|
{
|
|
if( caster->GetSkill( MAGERY ) <= 800 )
|
|
return false;
|
|
|
|
Magic->SummonMonster( sock, caster, 8, caster->GetX() + 1, caster->GetY() + 1, caster->GetZ() );
|
|
return true;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - splNecro1()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - UNUSED
|
|
//o------------------------------------------------------------------------------------------------o
|
|
bool splNecro1( [[maybe_unused]] CChar *caster, [[maybe_unused]] CChar *target, [[maybe_unused]] CChar *src, [[maybe_unused]] SI08 curSpell )
|
|
{
|
|
return true;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - splNecro2()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Applies effect of Necromantic summon spell (summons monster)
|
|
//o------------------------------------------------------------------------------------------------o
|
|
bool splNecro2( CSocket *sock, CChar *caster, [[maybe_unused]] SI08 curSpell )
|
|
{
|
|
Magic->SummonMonster( sock, caster, 9, caster->GetX() +1, caster->GetY() +1, caster->GetZ() );
|
|
return true;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - splNecro3()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - UNUSED
|
|
//o------------------------------------------------------------------------------------------------o
|
|
bool splNecro3( [[maybe_unused]] CChar *caster, [[maybe_unused]] CChar *target, [[maybe_unused]] CChar *src, [[maybe_unused]] SI08 curSpell )
|
|
{
|
|
return true;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - splNecro4()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - UNUSED
|
|
//o------------------------------------------------------------------------------------------------o
|
|
bool splNecro4( [[maybe_unused]] CChar *caster, [[maybe_unused]] CChar *target, [[maybe_unused]] CChar *src, [[maybe_unused]] SI08 curSpell )
|
|
{
|
|
return true;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - splNecro5()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - UNUSED
|
|
//o------------------------------------------------------------------------------------------------o
|
|
bool splNecro5( [[maybe_unused]] CChar *caster, [[maybe_unused]] CChar *target, [[maybe_unused]] CChar *src, [[maybe_unused]] SI08 curSpell )
|
|
{
|
|
return true;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - DiamondSpell()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Casts field spell in the shape of a diamond
|
|
//o------------------------------------------------------------------------------------------------o
|
|
bool DiamondSpell( [[maybe_unused]] CSocket *sock, CChar *caster, UI16 id, SI16 x, SI16 y, SI08 z, UI08 length )
|
|
{
|
|
SI32 j;
|
|
SI16 fx[5], fy[5];
|
|
SI16 yOffset = length;
|
|
SI16 xOffset = length;
|
|
|
|
fx[0] = -xOffset; fy[0] = 0;
|
|
fx[1] = 0; fy[1] = yOffset;
|
|
fx[2] = 0; fy[2] = -yOffset;
|
|
fx[3] = xOffset; fy[3] = 0;
|
|
|
|
CItem *i = nullptr;
|
|
UI08 worldNumber = caster->WorldNumber();
|
|
UI16 instanceId = caster->GetInstanceId();
|
|
for( j = 0; j < 4; ++j ) // Draw the corners of our diamond
|
|
{
|
|
i = Items->CreateItem( nullptr, caster, id, 1, 0, OT_ITEM );
|
|
if( i != nullptr )
|
|
{
|
|
i->SetDispellable( true );
|
|
i->SetDecayable( true );
|
|
i->SetDecayTime( BuildTimeValue( static_cast<R64>( caster->GetSkill( MAGERY )) / 15.0 ));
|
|
i->SetTempVar( CITV_MOREX, caster->GetSkill( MAGERY )); // remember casters magery skill for damage
|
|
i->SetTempVar( CITV_MOREY, caster->GetSerial() );
|
|
i->SetLocation( x + fx[j], y + fy[j], Map->Height( x + fx[j], y + fy[j], z, worldNumber, instanceId ));
|
|
i->SetDir( 29 );
|
|
i->SetMovable( 2 );
|
|
}
|
|
}
|
|
for( j = -1; j < 2; j = j + 2 )
|
|
{
|
|
for( SI08 counter2 = -1; counter2 < 2; counter2 += 2 )
|
|
{
|
|
for( SI32 counter3 = 1; counter3 < yOffset; ++counter3 )
|
|
{
|
|
i = Items->CreateItem( nullptr, caster, id, 1, 0, OT_ITEM );
|
|
if( i != nullptr )
|
|
{
|
|
i->SetDispellable( true );
|
|
i->SetDecayable( true );
|
|
i->SetDecayTime( BuildTimeValue( static_cast<R64>( caster->GetSkill( MAGERY )) / 15.0 ));
|
|
i->SetTempVar( CITV_MOREX, caster->GetSkill( MAGERY )); // remember casters magery skill for damage
|
|
i->SetTempVar( CITV_MOREY, caster->GetSerial() );
|
|
const SI16 newX = x + counter2 * counter3;
|
|
const SI16 newY = y + j * ( yOffset - counter3 );
|
|
i->SetLocation( newX, newY, Map->Height( newX, newY, z, worldNumber, instanceId ));
|
|
i->SetDir( 29 );
|
|
i->SetMovable( 2 );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - SquareSpell()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Casts field spell in the shape of a square
|
|
//o------------------------------------------------------------------------------------------------o
|
|
bool SquareSpell( [[maybe_unused]] CSocket *sock, CChar *caster, UI16 id, SI16 x, SI16 y, SI08 z, UI08 length )
|
|
{
|
|
SI16 fx[5], fy[5];
|
|
SI16 yOffset = length;
|
|
SI16 xOffset = length;
|
|
|
|
fx[0] = -xOffset; fy[0] = xOffset;
|
|
fx[1] = -yOffset; fy[1] = yOffset;
|
|
fx[2] = -xOffset; fy[2] = xOffset;
|
|
fx[3] = -yOffset; fy[3] = yOffset;
|
|
|
|
CItem *i = nullptr;
|
|
UI08 worldNumber = caster->WorldNumber();
|
|
UI16 instanceId = caster->GetInstanceId();
|
|
for( UI08 j = 0; j < 4; ++j ) // Draw the corners of our diamond
|
|
{
|
|
for( SI32 counter = fx[j]; counter < fy[j]; ++counter )
|
|
{
|
|
i = Items->CreateItem( nullptr, caster, id, 1, 0, OT_ITEM );
|
|
if( i != nullptr )
|
|
{
|
|
i->SetDispellable( true );
|
|
i->SetDecayable( true );
|
|
i->SetDecayTime( BuildTimeValue( static_cast<R64>( caster->GetSkill( MAGERY )) / 15.0 ));
|
|
i->SetTempVar( CITV_MOREX, caster->GetSkill( MAGERY )); // remember casters magery skill for damage
|
|
i->SetTempVar( CITV_MOREY, caster->GetSerial() );
|
|
switch( j )
|
|
{
|
|
case 0:
|
|
case 2:
|
|
i->SetLocation( x + counter, y + (j - 1) * yOffset, Map->Height( x + counter, y + (j-1) * yOffset, z, worldNumber, instanceId ));
|
|
break;
|
|
case 1:
|
|
case 3:
|
|
i->SetLocation( x + (j-2 ) * xOffset, y + counter, Map->Height( x + (j-2 ) * xOffset, y + counter, z, worldNumber, instanceId ));
|
|
break;
|
|
}
|
|
i->SetDir( 29 );
|
|
i->SetMovable( 2 );
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - FloodSpell()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Casts field spell in the shape of a filled square
|
|
//o------------------------------------------------------------------------------------------------o
|
|
bool FloodSpell( [[maybe_unused]] CSocket *sock, CChar *caster, UI16 id, SI16 x, SI16 y, SI08 z, UI08 length )
|
|
{
|
|
SI16 yOffset = length;
|
|
SI16 xOffset = length;
|
|
|
|
SI16 maxX = x + xOffset;
|
|
SI16 maxY = y + yOffset;
|
|
SI16 minX = x - xOffset;
|
|
SI16 minY = y - yOffset;
|
|
|
|
UI08 worldNumber = caster->WorldNumber();
|
|
UI16 instanceId = caster->GetInstanceId();
|
|
for( SI32 counter1 = minX; counter1 <= maxX; ++counter1 )
|
|
{
|
|
for( SI32 counter2 = minY; counter2 <= maxY; ++counter2 )
|
|
{
|
|
CItem *i = Items->CreateItem( nullptr, caster, id, 1, 0, OT_ITEM );
|
|
if( i != nullptr )
|
|
{
|
|
i->SetDispellable( true );
|
|
i->SetDecayable( true );
|
|
i->SetDecayTime( BuildTimeValue( static_cast<R64>( caster->GetSkill( MAGERY )) / 15.0 ));
|
|
i->SetTempVar( CITV_MOREX, caster->GetSkill( MAGERY )); // remember casters magery skill for damage
|
|
i->SetTempVar( CITV_MOREY, caster->GetSerial() );
|
|
i->SetLocation( counter1, counter2, Map->Height( counter1, counter2, z, worldNumber, instanceId ));
|
|
i->SetDir( 29 );
|
|
i->SetMovable( 2 );
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
/////////////////////////////////////////////////////////////////
|
|
/// INDEX:
|
|
// - misc magic functions
|
|
// - NPCs casting spells related functions
|
|
// - ITEMs magic powers related functions
|
|
// - PCs casting spells related functions
|
|
/////////////////////////////////////////////////////////////////
|
|
/////////////////////////////////////////////////////////////////
|
|
/////////////////////////////////////////////////////////////////
|
|
/////// MISC MAGIC FUNCTIONS ////////////////////////////////////
|
|
/////////////////////////////////////////////////////////////////
|
|
/////////////////////////////////////////////////////////////////
|
|
|
|
// added constructor/destructor
|
|
CMagic::CMagic() : spellCount( 1 )
|
|
{
|
|
spells.resize( 0 );
|
|
}
|
|
|
|
CMagic::~CMagic()
|
|
{
|
|
// delete any allocations
|
|
spells.clear();
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CMagic::HasSpell()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Checks if given spellbook contains specific spell
|
|
//o------------------------------------------------------------------------------------------------o
|
|
bool CMagic::HasSpell( CItem *book, SI32 spellNum )
|
|
{
|
|
if( !ValidateObject( book ))
|
|
return false;
|
|
|
|
UI32 wordNum = spellNum / 32;
|
|
UI32 bitNum = ( spellNum % 32 );
|
|
UI32 flagToCheck = power( 2, bitNum );
|
|
UI32 sourceAmount = 0;
|
|
if( wordNum < 3 )
|
|
{
|
|
sourceAmount = book->GetSpell( static_cast<UI08>( wordNum ));
|
|
}
|
|
return (( sourceAmount & flagToCheck ) == flagToCheck);
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - AddSpell()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Adds specific spell to given spellbook
|
|
//o------------------------------------------------------------------------------------------------o
|
|
void CMagic::AddSpell( CItem *book, SI32 spellNum )
|
|
{
|
|
std::vector<UI16> scriptTriggers = book->GetScriptTriggers();
|
|
for( auto scriptTrig : scriptTriggers )
|
|
{
|
|
cScript *toExecute = JSMapping->GetScript( scriptTrig );
|
|
if( toExecute != nullptr )
|
|
{
|
|
// If script returns false/0, prevent addition of spell to spellbook
|
|
if( toExecute->OnSpellGain( book, spellNum ) == 0 )
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
if( !ValidateObject( book ))
|
|
return;
|
|
|
|
UI32 wordNum = spellNum / 32;
|
|
if( wordNum < 3 )
|
|
{
|
|
UI32 bitNum = ( spellNum % 32 );
|
|
UI32 flagToSet = power( 2, bitNum );
|
|
UI32 targAmount;
|
|
targAmount = ( book->GetSpell( static_cast<UI08>( wordNum )) | flagToSet );
|
|
book->SetSpell( static_cast<UI08>( wordNum ), targAmount );
|
|
}
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CMagic::RemoveSpell()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Removes specific spell from given spellbook
|
|
//o------------------------------------------------------------------------------------------------o
|
|
void CMagic::RemoveSpell( CItem *book, SI32 spellNum )
|
|
{
|
|
std::vector<UI16> scriptTriggers = book->GetScriptTriggers();
|
|
for( auto scriptTrig : scriptTriggers )
|
|
{
|
|
cScript *toExecute = JSMapping->GetScript( scriptTrig );
|
|
if( toExecute != nullptr )
|
|
{
|
|
// If script returns false/0, prevent removal of spell from spellbook
|
|
if( toExecute->OnSpellLoss( book, spellNum ) == 0 )
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
if( !ValidateObject( book ))
|
|
return;
|
|
|
|
UI32 wordNum = spellNum / 32;
|
|
if( wordNum < 3 )
|
|
{
|
|
UI32 bitNum = ( spellNum % 32 );
|
|
UI32 flagToSet = power( 2, bitNum );
|
|
UI32 flagMask = 0xFFFFFFFF;
|
|
UI32 targAmount;
|
|
flagMask ^= flagToSet;
|
|
targAmount = ( book->GetSpell( static_cast<UI08>( wordNum )) & flagMask );
|
|
book->SetSpell( static_cast<UI08>( wordNum ), targAmount );
|
|
}
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CMagic::SpellBook()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Opens the spellbook and displays all spells a character has in his book
|
|
//o------------------------------------------------------------------------------------------------o
|
|
void CMagic::SpellBook( CSocket *mSock )
|
|
{
|
|
UI08 spellsList[70];
|
|
|
|
SERIAL serial = ( mSock->GetDWord( 1 ) & 0x7FFFFFFF );
|
|
CChar *mChar = mSock->CurrcharObj();
|
|
CItem *spellBook = CalcItemObjFromSer( serial );
|
|
|
|
// Here's the kicker. We NEVER needed to search through our pack for our spellbook!!! Why, you might ask???
|
|
// Because we are able to calculate the serial of the spellbook, because it's targetted for us!!!!
|
|
// Hence, we can remove all searches from here, and just use it directly
|
|
// The only time we need to search is when they use the macro, and that's easily done (item == -1)
|
|
|
|
if( !ValidateObject( spellBook )) // used a macro!!!
|
|
{
|
|
spellBook = FindItemOfType( mChar, IT_SPELLBOOK );
|
|
}
|
|
if( !ValidateObject( spellBook )) // we STILL have no spellbook!!!
|
|
{
|
|
mSock->SysMessage( 692 ); // You have no spellbook upon you!
|
|
return;
|
|
}
|
|
CItem *x = mChar->GetPackItem();
|
|
if( spellBook->GetCont() != mChar && spellBook->GetCont() != x )
|
|
{
|
|
mSock->SysMessage( 403 ); // If you wish to open a spellbook, it must be equipped or in your main backpack.
|
|
return;
|
|
}
|
|
CPDrawContainer sbStart(( *spellBook ));
|
|
sbStart.Model( 0xFFFF );
|
|
if( mSock->ClientType() >= CV_HS2D && mSock->ClientVerShort() >= CVS_7090 )
|
|
{
|
|
sbStart.ContType( 0x7D );
|
|
}
|
|
mSock->Send( &sbStart );
|
|
|
|
// Support for new Client Spellbook
|
|
CPNewSpellBook ourBook(( *spellBook ));
|
|
if( ourBook.ClientCanReceive( mSock ))
|
|
{
|
|
mSock->Send( &ourBook );
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
memset( spellsList, 0, sizeof( UI08 ) * 70 );
|
|
for( UI08 j = 0; j < 65; ++j )
|
|
{
|
|
if( HasSpell( spellBook, j ))
|
|
{
|
|
spellsList[j] = 1;
|
|
}
|
|
}
|
|
UI08 i;
|
|
i = spellsList[0];
|
|
spellsList[0] = spellsList[1];
|
|
spellsList[1] = spellsList[2];
|
|
spellsList[2] = spellsList[3];
|
|
spellsList[3] = spellsList[4];
|
|
spellsList[4] = spellsList[5];
|
|
spellsList[5] = spellsList[6];
|
|
spellsList[6] = i;
|
|
|
|
if( spellsList[64] )
|
|
{
|
|
for( i = 0; i < 65; ++i )
|
|
{
|
|
spellsList[i] = 1;
|
|
}
|
|
spellsList[64] = 0;
|
|
}
|
|
spellsList[64] = spellsList[65];
|
|
spellsList[65] = 0;
|
|
|
|
UI08 scount = 0;
|
|
for( i = 0; i < 65; ++i )
|
|
{
|
|
if( spellsList[i] )
|
|
{
|
|
++scount;
|
|
}
|
|
}
|
|
if( scount > 0 )
|
|
{
|
|
CPItemsInContainer mItems;
|
|
if( mSock->ClientVerShort() >= CVS_6017 )
|
|
{
|
|
mItems.UOKRFlag( true );
|
|
}
|
|
mItems.NumberOfItems( scount );
|
|
UI16 runningCounter = 0;
|
|
const SERIAL CONTSER = spellBook->GetSerial();
|
|
for( i = 0; i < 65; ++i )
|
|
{
|
|
if( spellsList[i] )
|
|
{
|
|
mItems.Add( runningCounter++, 0x41000000 + i, CONTSER, i + 1 );
|
|
}
|
|
}
|
|
mSock->Send( &mItems );
|
|
}
|
|
}
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CMagic::GateCollision()
|
|
//| Changes - collision dir
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Used when a PLAYER passes through a gate. Takes the player
|
|
//| to the other side of the gate-link.
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CMagic::GateCollision( CSocket *mSock, CChar *mChar, CItem *itemCheck, ItemTypes type ) -> void
|
|
{
|
|
if( type == IT_GATE )
|
|
{
|
|
if( !mChar->IsNpc() )
|
|
{
|
|
auto otherGate = CalcItemObjFromSer( itemCheck->GetTempVar( CITV_MOREX ));
|
|
if( ValidateObject( otherGate ))
|
|
{
|
|
SI08 dirOffset = 0;
|
|
if( mChar->GetDir() < SOUTH )
|
|
{
|
|
dirOffset = 1;
|
|
}
|
|
else
|
|
{
|
|
dirOffset = -1;
|
|
}
|
|
if( otherGate->WorldNumber() != mChar->WorldNumber() )
|
|
{
|
|
mChar->SetLocation( otherGate->GetX() + dirOffset, otherGate->GetY(), otherGate->GetZ(), otherGate->WorldNumber(), otherGate->GetInstanceId() );
|
|
SendMapChange( mChar->WorldNumber(), mSock, false );
|
|
}
|
|
else
|
|
{
|
|
mChar->SetLocation( otherGate->GetX() + dirOffset, otherGate->GetY(), otherGate->GetZ(), otherGate->WorldNumber(), otherGate->GetInstanceId() );
|
|
}
|
|
|
|
// Teleport player's followers too
|
|
auto myFollowers = mChar->GetFollowerList();
|
|
for( const auto &myFollower : myFollowers->collection() )
|
|
{
|
|
if( ValidateObject( myFollower ))
|
|
{
|
|
if( !myFollower->GetMounted() && myFollower->GetOwnerObj() == mChar )
|
|
{
|
|
if( myFollower->GetNpcWander() == WT_FOLLOW && ObjInOldRange( mChar, myFollower, DIST_CMDRANGE ))
|
|
{
|
|
myFollower->SetLocation( mChar );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
Effects->PlaySound( mSock, 0x01FE, true );
|
|
Effects->PlayStaticAnimation( mChar, 0x372A, 0x09, 0x06 );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CMagic::SummonMonster()
|
|
//| Changes - May 4th, 2000 - made function general words PC's and NPC's
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Summon a monster (dispellable with DISPEL).
|
|
//o------------------------------------------------------------------------------------------------o
|
|
void CMagic::SummonMonster( CSocket *s, CChar *caster, UI16 id, SI16 x, SI16 y, SI08 z )
|
|
{
|
|
bool validSocket = ( s != nullptr );
|
|
if( validSocket )
|
|
{
|
|
caster = s->CurrcharObj();
|
|
}
|
|
else
|
|
{ // Since caster will determine who is casting the spell... get a socket for players to see animations and hear effects
|
|
if( caster->IsNpc() && !caster->GetTarg()->IsNpc() )
|
|
{
|
|
s = caster->GetTarg()->GetSocket();
|
|
}
|
|
}
|
|
|
|
UI08 maxControlSlots = cwmWorldState->ServerData()->MaxControlSlots();
|
|
UI08 maxFollowers = cwmWorldState->ServerData()->MaxFollowers();
|
|
UI08 controlSlotsUsed = caster->GetControlSlotsUsed();
|
|
UI08 followerCount = static_cast<UI08>( caster->GetFollowerList()->Num() );
|
|
|
|
CChar *newChar=nullptr;
|
|
|
|
switch( id )
|
|
{
|
|
case 0: // summon monster
|
|
{
|
|
newChar = Npcs->CreateRandomNPC( "10000" );
|
|
if( !ValidateObject( newChar ))
|
|
{
|
|
if( validSocket )
|
|
{
|
|
s->SysMessage( 694 ); // Contact your shard op to setup the summon list!
|
|
}
|
|
return;
|
|
}
|
|
|
|
if( maxControlSlots > 0 )
|
|
{
|
|
if( controlSlotsUsed + newChar->GetControlSlots() > maxControlSlots )
|
|
{
|
|
newChar->Delete();
|
|
if( validSocket )
|
|
{
|
|
s->SysMessage( 2390 ); // That would exceed your maximum pet control slots.
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
else if( maxFollowers > 0 && followerCount >= maxFollowers )
|
|
{
|
|
newChar->Delete();
|
|
if( validSocket )
|
|
{
|
|
s->SysMessage( 2346, maxFollowers ); // You can maximum have %i pets / followers active at the same time.
|
|
}
|
|
return;
|
|
}
|
|
|
|
if( Magic->spells[40].Effect() != INVALIDID )
|
|
{
|
|
Effects->PlaySound( newChar, Magic->spells[40].Effect() );
|
|
}
|
|
|
|
CMagicStat temp = Magic->spells[40].StaticEffect();
|
|
if( temp.Effect() != INVALIDID )
|
|
{
|
|
Magic->DoStaticEffect( newChar, 40 );
|
|
}
|
|
|
|
newChar->SetOwner( caster );
|
|
caster->SetControlSlotsUsed( std::clamp( controlSlotsUsed + newChar->GetControlSlots(), 0, 255 ));
|
|
newChar->SetTimer( tNPC_SUMMONTIME, BuildTimeValue( static_cast<R64>( caster->GetSkill( MAGERY )) / 5.0 ));
|
|
newChar->SetLocation( caster );
|
|
Effects->PlayCharacterAnimation( newChar, ACT_SPELL_AREA, 0, 7 ); // 0x11, used to be 0x0C
|
|
newChar->SetFTarg( caster );
|
|
newChar->SetNpcWander( WT_FOLLOW );
|
|
newChar->SetDispellable( true );
|
|
if( validSocket )
|
|
{
|
|
s->SysMessage( 695 ); // Your pet beings are following you.
|
|
}
|
|
return;
|
|
}
|
|
case 1: // Energy Vortex
|
|
Effects->PlaySound( s, 0x0216, true ); // EV
|
|
newChar = Npcs->CreateNPCxyz( "energyvortex-summon", 0, 0, 0, caster->WorldNumber(), caster->GetInstanceId() );
|
|
break;
|
|
case 2: // Air Elemental
|
|
Effects->PlaySound( s, 0x0217, true ); // AE
|
|
newChar = Npcs->CreateNPCxyz( "airele-summon", 0, 0, 0, caster->WorldNumber(), caster->GetInstanceId() );
|
|
break;
|
|
case 3: //Earth Elemental
|
|
Effects->PlaySound( s, 0x0217, true );
|
|
newChar = Npcs->CreateNPCxyz( "earthele-summon", 0, 0, 0, caster->WorldNumber(), caster->GetInstanceId() );
|
|
break;
|
|
case 4: //Fire Elemental
|
|
Effects->PlaySound( s, 0x0217, true );
|
|
newChar = Npcs->CreateNPCxyz( "firele-summon", 0, 0, 0, caster->WorldNumber(), caster->GetInstanceId() );
|
|
break;
|
|
case 5: //Water Elemental
|
|
Effects->PlaySound( s, 0x0217, true );
|
|
newChar = Npcs->CreateNPCxyz( "waterele-summon", 0, 0, 0, caster->WorldNumber(), caster->GetInstanceId() );
|
|
break;
|
|
case 6: //Blade Spirits
|
|
Effects->PlaySound( s, 0x0212, true ); // I don't know if this is the right effect...
|
|
newChar = Npcs->CreateNPCxyz( "bladespirit-summon", 0, 0, 0, caster->WorldNumber(), caster->GetInstanceId() );
|
|
break;
|
|
case 7: // Daemon
|
|
Effects->PlaySound( s, 0x0216, true );
|
|
newChar = Npcs->CreateNPCxyz( "daemon-summon", 0, 0, 0, caster->WorldNumber(), caster->GetInstanceId() );
|
|
break;
|
|
case 8: // Dupre The Hero
|
|
Effects->PlaySound( s, 0x0246, true );
|
|
newChar = Npcs->CreateNPCxyz( "dupre-summon", 0, 0, 0, caster->WorldNumber(), caster->GetInstanceId() );
|
|
break;
|
|
case 9: // Black Night
|
|
Effects->PlaySound( s, 0x0216, true );
|
|
newChar = Npcs->CreateNPCxyz( "blacknight-summon", 0, 0, 0, caster->WorldNumber(), caster->GetInstanceId() );
|
|
break;
|
|
default:
|
|
Effects->PlaySound( s, 0x0215, true );
|
|
}
|
|
|
|
if( !ValidateObject( newChar ))
|
|
return;
|
|
|
|
if( maxControlSlots > 0 )
|
|
{
|
|
if( controlSlotsUsed + newChar->GetControlSlots() > maxControlSlots )
|
|
{
|
|
newChar->Delete();
|
|
if( validSocket )
|
|
{
|
|
s->SysMessage( 2390 ); // That would exceed your maximum pet control slots.
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
else if( maxFollowers > 0 && followerCount >= maxFollowers )
|
|
{
|
|
newChar->Delete();
|
|
if( validSocket )
|
|
{
|
|
s->SysMessage( 2346, maxFollowers ); // You can maximum have %i pets / followers active at the same time.
|
|
}
|
|
return;
|
|
}
|
|
|
|
newChar->SetDispellable( true );
|
|
|
|
// pc's don't own BS/EV, NPCs do
|
|
if( caster->IsNpc() || ( id != 1 && id != 6 ))
|
|
{
|
|
newChar->SetOwner( caster );
|
|
if( !caster->IsNpc() )
|
|
{
|
|
// Update control slots used
|
|
caster->SetControlSlotsUsed( std::clamp(controlSlotsUsed + newChar->GetControlSlots(), 0, 255) );
|
|
}
|
|
}
|
|
|
|
if( x == 0 )
|
|
{
|
|
newChar->SetLocation( caster->GetX()-1, caster->GetY(), caster->GetZ() );
|
|
}
|
|
else
|
|
{
|
|
if( Map->ValidSpawnLocation( x, y, z, caster->WorldNumber(), caster->GetInstanceId() ))
|
|
{
|
|
newChar->SetLocation( x, y, z );
|
|
}
|
|
else
|
|
{
|
|
newChar->SetLocation( caster->GetX()-1, caster->GetY(), caster->GetZ() );
|
|
}
|
|
}
|
|
|
|
newChar->SetSpDelay( 10 );
|
|
newChar->SetTimer( tNPC_SUMMONTIME, BuildTimeValue( static_cast<R64>( caster->GetSkill( MAGERY )) / 5.0 ));
|
|
Effects->PlayCharacterAnimation( newChar, ACT_SPELL_AREA, 0, 7 ); // 0x11, used to be 0x0C
|
|
// (9/99) - added the chance to make the monster attack
|
|
// the person you targeted ( if you targeted a char, naturally :) )
|
|
CChar *i = nullptr;
|
|
if( !caster->IsNpc() && s != nullptr )
|
|
{
|
|
if( s->GetDWord( 7 ) != INVALIDSERIAL )
|
|
{
|
|
i = CalcCharObjFromSer( s->GetDWord( 7 ));
|
|
if( !ValidateObject( i ))
|
|
return;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
i = caster->GetTarg();
|
|
}
|
|
Combat->AttackTarget( newChar, i );
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CMagic::CheckBook()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Check if the spell is memorized into the spellbook.
|
|
//o------------------------------------------------------------------------------------------------o
|
|
|
|
bool CMagic::CheckBook( SI32 circle, SI32 spell, CItem *i )
|
|
{
|
|
SI32 spellnum = spell + ( circle - 1 ) * 8;
|
|
return HasSpell( i, spellnum );
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CMagic::CheckMana()
|
|
//| Changes - to use spells[] array.
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Check if character has enough mana to cast spell
|
|
//o------------------------------------------------------------------------------------------------o
|
|
bool CMagic::CheckMana( CChar *s, SI32 num )
|
|
{
|
|
if( !ValidateObject( s ))
|
|
return true;
|
|
|
|
if( s->NoNeedMana() )
|
|
return true;
|
|
|
|
if( s->GetMana() >= spells[num].Mana() )
|
|
{
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
CSocket *p = s->GetSocket();
|
|
if( p != nullptr )
|
|
{
|
|
p->SysMessage( 696 ); // You have insufficient mana to cast that spell.
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CMagic::CheckStamina()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Check if character has enough stamina to cast spell
|
|
//o------------------------------------------------------------------------------------------------o
|
|
bool CMagic::CheckStamina( CChar *s, SI32 num )
|
|
{
|
|
if( !ValidateObject( s ))
|
|
return true;
|
|
|
|
if( s->NoNeedMana() )
|
|
return true;
|
|
|
|
if( s->GetStamina() >= spells[num].Stamina() )
|
|
{
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
CSocket *p = s->GetSocket();
|
|
if( p != nullptr )
|
|
{
|
|
p->SysMessage( 697 ); // You have insufficient stamina to cast that spell.
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CMagic::CheckHealth()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Check if character has enough health to cast spell
|
|
//o------------------------------------------------------------------------------------------------o
|
|
bool CMagic::CheckHealth( CChar *s, SI32 num )
|
|
{
|
|
if( !ValidateObject( s ))
|
|
return true;
|
|
|
|
if( s->NoNeedMana() )
|
|
return true;
|
|
|
|
if( spells[num].Health() == 0 )
|
|
return true;
|
|
|
|
if( spells[num].Health() > 0 )
|
|
{
|
|
if( s->GetHP() >= spells[num].Health() )
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
return true;
|
|
}
|
|
CSocket *p = s->GetSocket();
|
|
if( p != nullptr )
|
|
{
|
|
p->SysMessage( 698 ); // You have insufficient health to cast that spell.
|
|
}
|
|
return false;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CMagic::SubtractMana()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Subtract the required mana from character's mana reserve
|
|
//o------------------------------------------------------------------------------------------------o
|
|
void CMagic::SubtractMana( CChar *s, SI32 mana)
|
|
{
|
|
if( s->NoNeedMana() )
|
|
return;
|
|
|
|
s->SetMana( s->GetMana() - mana );
|
|
if( s->GetMana() < 0 )
|
|
{
|
|
s->SetMana( 0 );
|
|
}
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CMagic::SubtractStamina()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Subtract the required stmina from character's stamina reserve
|
|
//o------------------------------------------------------------------------------------------------o
|
|
void CMagic::SubtractStamina( CChar *s, SI32 stamina )
|
|
{
|
|
if( s->NoNeedMana() )
|
|
return;
|
|
|
|
s->SetStamina( s->GetStamina() - stamina );
|
|
if( s->GetStamina() == -1 )
|
|
{
|
|
s->SetStamina( 0 );
|
|
}
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CMagic::SubtractHealth()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Subtract the required health from character's stamina reserve
|
|
//o------------------------------------------------------------------------------------------------o
|
|
void CMagic::SubtractHealth( CChar *s, SI32 health, SI32 spellNum )
|
|
{
|
|
if( s->NoNeedMana() || spells[spellNum].Health() == 0 )
|
|
return;
|
|
|
|
if( spells[spellNum].Health() < 0 )
|
|
{
|
|
if( abs( spells[spellNum].Health() * health ) > s->GetHP() )
|
|
{
|
|
s->SetHP( 0 );
|
|
}
|
|
else
|
|
{
|
|
s->IncHP( spells[spellNum].Health() * health );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
s->IncHP( -health );
|
|
}
|
|
if( s->GetHP() < 0 )
|
|
{
|
|
s->SetHP( 0 );
|
|
}
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CMagic::CheckMagicReflect()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Check if character is protected by MagicReflect.
|
|
//| If yes, remove the protection and do visual effect.
|
|
//| However, don't touch the protection if character is permanently protected
|
|
//o------------------------------------------------------------------------------------------------o
|
|
bool CMagic::CheckMagicReflect( CChar *i )
|
|
{
|
|
if( i->IsTempReflected() )
|
|
{
|
|
// Is character temporarily protected by a magic reflect spell?
|
|
i->SetTempReflected( false );
|
|
Effects->PlayStaticAnimation( i, 0x373A, 0, 15 );
|
|
return true;
|
|
}
|
|
else if( i->IsPermReflected() )
|
|
{
|
|
// Is character permanently protected by a magic reflect spell?
|
|
Effects->PlayStaticAnimation( i, 0x373A, 0, 15 );
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CMagic::CheckResist()
|
|
//| Changes - to add EV.INT. check
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Check character's magic resistance.
|
|
//o------------------------------------------------------------------------------------------------o
|
|
bool CMagic::CheckResist( CChar *attacker, CChar *defender, SI32 circle )
|
|
{
|
|
bool i = Skills->CheckSkill( defender, MAGICRESISTANCE, 80 * circle, 800 + ( 80 * circle ));
|
|
CSocket *s = nullptr;
|
|
if( ValidateObject( attacker ))
|
|
{
|
|
// Check what is higher between user's normal resistchance and a fallback value
|
|
// To ensure user always has a chance of resisting, however small (except at resist-skill 0 )
|
|
auto defenderMagicResist = defender->GetSkill( MAGICRESISTANCE );
|
|
auto raceMagicResist = Races->Race( defender->GetRace() )->MagicResistance();
|
|
SI16 defaultChance = ( defenderMagicResist + static_cast<UI16>( raceMagicResist * 10 )) / 5;
|
|
SI16 resistChance = ( defenderMagicResist + static_cast<UI16>( raceMagicResist * 10 )) - ((( attacker->GetSkill( MAGERY ) - 20 ) / 5 ) + ( circle * 5 ));
|
|
if( defaultChance > resistChance )
|
|
{
|
|
resistChance = defaultChance;
|
|
}
|
|
|
|
if( RandomNum( 1, 100 ) < resistChance / 10 )
|
|
{
|
|
s = defender->GetSocket();
|
|
if( s != nullptr )
|
|
{
|
|
s->SysMessage( 699 ); // You feel yourself resisting magical energy!
|
|
}
|
|
i = true;
|
|
}
|
|
else
|
|
{
|
|
i = false;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if( i )
|
|
{
|
|
s = defender->GetSocket();
|
|
if( s != nullptr )
|
|
{
|
|
s->SysMessage( 699 ); // You feel yourself resisting magical energy!
|
|
}
|
|
}
|
|
}
|
|
return i;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CMagic::CheckResist()
|
|
//| Changes - to add EV.INT. check
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Check character's magic resistance.
|
|
//o------------------------------------------------------------------------------------------------o
|
|
bool CMagic::CheckResist( SI16 resistDifficulty, CChar *defender, SI32 circle )
|
|
{
|
|
bool i = Skills->CheckSkill( defender, MAGICRESISTANCE, 80 * circle, 800 + ( 80 * circle ));
|
|
CSocket *s = nullptr;
|
|
|
|
// Calculate chance of resisting the magic effect based on defender's magic resistance vs the resistDifficulty
|
|
auto defenderMagicResist = defender->GetSkill( MAGICRESISTANCE );
|
|
auto raceMagicResist = Races->Race( defender->GetRace() )->MagicResistance();
|
|
SI16 defaultChance = ( defenderMagicResist + static_cast<UI16>( raceMagicResist * 10 )) / 5;
|
|
SI16 resistChance = ( defenderMagicResist + static_cast<UI16>( raceMagicResist * 10 )) - ((( resistDifficulty - 20 ) / 5 ) + ( circle * 5 ));
|
|
|
|
if( defaultChance > resistChance )
|
|
{
|
|
resistChance = defaultChance;
|
|
}
|
|
|
|
if( RandomNum( 1, 100 ) < resistChance / 10 )
|
|
{
|
|
s = defender->GetSocket();
|
|
if( s != nullptr )
|
|
{
|
|
s->SysMessage( 699 ); // You feel yourself resisting magical energy!
|
|
}
|
|
i = true;
|
|
}
|
|
else
|
|
{
|
|
i = false;
|
|
}
|
|
|
|
return i;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CalcSpellDamageMod()
|
|
//| Date - November 7th 2011
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Calculate Spell Damage after skill-modifiers
|
|
//o------------------------------------------------------------------------------------------------o
|
|
SI16 CalcSpellDamageMod( CChar *caster, CChar *target, SI16 spellDamage, bool spellResisted )
|
|
{
|
|
// Randomize in upper-half of damage range for some variety
|
|
spellDamage = HalfRandomNum( spellDamage );
|
|
|
|
// If spell was resisted, halve damage
|
|
if( spellResisted )
|
|
{
|
|
spellDamage = static_cast<SI16>( std::round( spellDamage / 2 ));
|
|
}
|
|
|
|
// Add damage bonus/penalty based on attacker's EVALINT vs defender's MAGICRESISTANCE
|
|
UI16 casterEval = caster->GetSkill( EVALUATINGINTEL ) / 10;
|
|
|
|
auto targetMagicResist = static_cast<UI16>( target->GetSkill( MAGICRESISTANCE ) / 10 );
|
|
auto raceMagicResist = static_cast<UI16>( Races->Race( target->GetRace() )->MagicResistance() );
|
|
if( targetMagicResist + raceMagicResist > casterEval )
|
|
{
|
|
spellDamage *= ( static_cast<SI16>((( casterEval - ( targetMagicResist + raceMagicResist )) / 200.0f )) + 1 );
|
|
}
|
|
else
|
|
{
|
|
spellDamage *= ( static_cast<SI16>((( casterEval - ( targetMagicResist + raceMagicResist )) / 500.0f )) + 1 );
|
|
}
|
|
|
|
// Randomize some more to get broader min/max damage values
|
|
SI32 i = RandomNum( 0, 4 );
|
|
if( i <= 2 )
|
|
{
|
|
spellDamage = std::round( RandomNum( static_cast<SI16>( HalfRandomNum( spellDamage ) / 2 ), spellDamage ));
|
|
}
|
|
else if( i == 3 )
|
|
{
|
|
spellDamage = std::round( HalfRandomNum( spellDamage ));
|
|
}
|
|
else //keep current spellDamage
|
|
{
|
|
spellDamage = std::round( spellDamage );
|
|
}
|
|
|
|
return spellDamage;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CMagic::MagicDamage()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Calculate and inflict magic damage.
|
|
//o------------------------------------------------------------------------------------------------o
|
|
void CMagic::MagicDamage( CChar *p, SI16 amount, CChar *attacker, WeatherType element )
|
|
{
|
|
if( !ValidateObject( p ))
|
|
return;
|
|
|
|
if( p->IsDead() || p->GetHP() <= 0 ) // extra condition check, to see if deathstuff hasn't been hit yet
|
|
return;
|
|
|
|
CSocket *mSock = p->GetSocket();
|
|
|
|
if( p->IsFrozen() && p->GetDexterity() > 0 && !p->IsCasting() )
|
|
{
|
|
p->SetFrozen( false );
|
|
p->Dirty( UT_UPDATE );
|
|
if( mSock != nullptr )
|
|
{
|
|
mSock->SysMessage( 700 ); // You are no longer frozen.
|
|
}
|
|
}
|
|
|
|
// Allow damage if target is not invulnerable or in a zone safe from aggressive magic
|
|
if( !p->IsInvulnerable() && !p->GetRegion()->IsSafeZone() && p->GetRegion()->CanCastAggressive() )
|
|
{
|
|
UI08 hitLoc = Combat->CalculateHitLoc();
|
|
SI16 damage = Combat->ApplyDamageBonuses( element, attacker, p, MAGERY, hitLoc, amount);
|
|
damage = Combat->ApplyDefenseModifiers( element, attacker, p, MAGERY, hitLoc, damage, true);
|
|
if( damage <= 0 )
|
|
{
|
|
damage = 1;
|
|
}
|
|
|
|
[[maybe_unused]] bool retVal = p->Damage( damage, element, attacker, true );
|
|
p->ReactOnDamage( element, attacker );
|
|
}
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CMagic::PoisonDamage()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Apply the poison to the character.
|
|
//o------------------------------------------------------------------------------------------------o
|
|
void CMagic::PoisonDamage( CChar *p, SI32 poison, CChar *caster )
|
|
{
|
|
if( p->IsFrozen() )
|
|
{
|
|
p->SetFrozen( false );
|
|
p->Dirty( UT_UPDATE );
|
|
CSocket *s = p->GetSocket();
|
|
if( s != nullptr )
|
|
{
|
|
s->SysMessage( 700 ); // You are no longer frozen.
|
|
}
|
|
}
|
|
|
|
// Allow poison damage if target is not invunlnerable or in a zone safe from aggressive magic
|
|
if( !p->IsInvulnerable() && !p->GetRegion()->IsSafeZone() && p->GetRegion()->CanCastAggressive() )
|
|
{
|
|
if( poison > 5 )
|
|
{
|
|
poison = 5;
|
|
}
|
|
else if( poison < 0 )
|
|
{
|
|
poison = 1;
|
|
}
|
|
|
|
// Apply poison on target
|
|
p->SetPoisoned( poison );
|
|
if( ValidateObject( caster ))
|
|
{
|
|
p->SetPoisonedBy( caster->GetSerial() );
|
|
}
|
|
|
|
// Set time until poison wears off completely
|
|
p->SetTimer( tCHAR_POISONWEAROFF, BuildTimeValue( static_cast<R64>( GetPoisonDuration( poison ))));
|
|
}
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CMagic::CheckFieldEffects()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Check if character stands on a magic-field and apply effects.
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CMagic::CheckFieldEffects( CChar& mChar ) -> void
|
|
{
|
|
auto toCheck = MapRegion->GetMapRegion( &mChar );
|
|
if( toCheck )
|
|
{
|
|
auto regItems = toCheck->GetItemList();
|
|
for( const auto &inItemList :regItems->collection() )
|
|
{
|
|
if( ValidateObject( inItemList ) && inItemList->GetInstanceId() == mChar.GetInstanceId() )
|
|
{
|
|
if( inItemList->GetX() == mChar.GetX() && inItemList->GetY() == mChar.GetY() )
|
|
{
|
|
HandleFieldEffects(( &mChar ), inItemList, inItemList->GetId() );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CMagic::HandleFieldEffects()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Handle the effects of characters entering field spells
|
|
//o------------------------------------------------------------------------------------------------o
|
|
bool CMagic::HandleFieldEffects( CChar *mChar, CItem *fieldItem, UI16 id )
|
|
{
|
|
CChar *caster;
|
|
if( id >= 0x398C && id <= 0x399F ) //fire field
|
|
{
|
|
caster = CalcCharObjFromSer( fieldItem->GetTempVar( CITV_MOREY )); // store caster in morey
|
|
if( ValidateObject( caster) )
|
|
{
|
|
if( mChar->GetTimer( tCHAR_FIREFIELDTICK ) < cwmWorldState->GetUICurrentTime() )
|
|
{
|
|
// Set a timer, so another field spell cannot "tick" for this character for a short while
|
|
mChar->SetTimer( tCHAR_FIREFIELDTICK, BuildTimeValue( static_cast<R64>( Magic->spells[28].DamageDelay() )));
|
|
|
|
// Fetch spell damage from Fire Field spell
|
|
auto spellDamage = Magic->spells[28].BaseDmg();
|
|
|
|
// Apply magic damage
|
|
if( !CheckResist( nullptr, mChar, 4 ))
|
|
{
|
|
MagicDamage( mChar, spellDamage, caster, HEAT );
|
|
}
|
|
else
|
|
{
|
|
MagicDamage( mChar, spellDamage / 2, caster, HEAT );
|
|
}
|
|
Effects->PlaySound( mChar, 520 );
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
else if( id >= 0x3914 && id <= 0x3929 ) //poison field
|
|
{
|
|
caster = CalcCharObjFromSer( fieldItem->GetTempVar( CITV_MOREY )); // caster is stored in MOREY
|
|
if( ValidateObject( caster ) && mChar->IsInnocent() )
|
|
{
|
|
if( WillResultInCriminal( caster, mChar ) && ValidateObject( caster ) && !caster->IsGM() && !caster->IsCounselor() )
|
|
{
|
|
MakeCriminal( caster );
|
|
}
|
|
}
|
|
if( mChar->GetTimer( tCHAR_POISONFIELDTICK ) < cwmWorldState->GetUICurrentTime() )
|
|
{
|
|
// Set a timer, so another field spell cannot "tick" for this character for a short while
|
|
mChar->SetTimer( tCHAR_POISONFIELDTICK, BuildTimeValue( static_cast<R64>( Magic->spells[39].DamageDelay() )));
|
|
|
|
// Calculate strength of poison, but disregard range check
|
|
UI08 poisonStrength = 1;
|
|
|
|
// Fetch average skill value of poison field caster's Magery and Poisoning skills
|
|
UI16 skillVal = fieldItem->GetTempVar( CITV_MOREX );
|
|
|
|
// Calculate strength of poison
|
|
poisonStrength = CalculateMagicPoisonStrength( caster, mChar, skillVal, false, 5 );
|
|
|
|
// Apply poison on character
|
|
PoisonDamage( mChar, poisonStrength, caster );
|
|
Effects->PlaySound( mChar, 520 );
|
|
}
|
|
return true;
|
|
}
|
|
else if( id >= 0x3967 && id <= 0x398A ) //paralysis field
|
|
{
|
|
caster = CalcCharObjFromSer( fieldItem->GetTempVar( CITV_MOREY )); // store caster in morey
|
|
if( mChar->IsInnocent() )
|
|
{
|
|
if( WillResultInCriminal( caster, mChar ) && ValidateObject( caster ) && !caster->IsGM() && !caster->IsCounselor() )
|
|
{
|
|
MakeCriminal( caster );
|
|
}
|
|
}
|
|
if( mChar->GetTimer( tCHAR_PARAFIELDTICK ) < cwmWorldState->GetUICurrentTime() )
|
|
{
|
|
// Set a timer, so another field spell cannot "tick" for this character for a short while
|
|
mChar->SetTimer( tCHAR_PARAFIELDTICK, BuildTimeValue( static_cast<R64>( Magic->spells[39].DamageDelay() )));
|
|
|
|
if( !CheckResist( nullptr, mChar, 6 ))
|
|
{
|
|
Effects->TempEffect( caster, mChar, 1, 0, 0, 0 );
|
|
Effects->PlaySound( mChar, 520 );
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
else if( id >= 0x3946 && id <= 0x3964 ) //energy field
|
|
{
|
|
caster = CalcCharObjFromSer( fieldItem->GetTempVar( CITV_MOREY )); // store caster in morey
|
|
if( ValidateObject( caster) )
|
|
{
|
|
if( RandomNum( 0, 2 ) == 1 )
|
|
{
|
|
if( !CheckResist( nullptr, mChar, 4 ))
|
|
{
|
|
MagicDamage( mChar, fieldItem->GetTempVar( CITV_MOREX ) / 50, caster, LIGHTNING );
|
|
}
|
|
else
|
|
{
|
|
MagicDamage( mChar, fieldItem->GetTempVar( CITV_MOREX ) / 100, caster, LIGHTNING );
|
|
}
|
|
Effects->PlaySound( mChar, 520 );
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CMagic::BoxSpell()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Calculate the spell box effect, depending on character's magery skill
|
|
//o------------------------------------------------------------------------------------------------o
|
|
void CMagic::BoxSpell( CSocket *s, CChar *caster, SI16& x1, SI16& x2, SI16& y1, SI16& y2, SI08& z1, SI08& z2 )
|
|
{
|
|
SI16 x, y;
|
|
SI08 z;
|
|
SI16 length;
|
|
|
|
if( s != nullptr )
|
|
{
|
|
x = s->GetWord( 11 );
|
|
y = s->GetWord( 13 );
|
|
z = s->GetByte( 16 );
|
|
}
|
|
else
|
|
{
|
|
x = caster->GetTarg()->GetX();
|
|
y = caster->GetTarg()->GetY();
|
|
z = caster->GetTarg()->GetZ();
|
|
}
|
|
|
|
length = std::max( caster->GetSkill( MAGERY ) / 130, 1 );
|
|
|
|
x1 = x - length;
|
|
x2 = x + length;
|
|
y1 = y - length;
|
|
y2 = y + length;
|
|
z1 = z;
|
|
z2 = z + 3;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CMagic::MagicTrap()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Do the visual effect and apply damage when a player opens a trapped container
|
|
//o------------------------------------------------------------------------------------------------o
|
|
auto CMagic::MagicTrap( CChar *s, CItem *i ) -> void
|
|
{
|
|
if( ValidateObject( s ) && ValidateObject( i ))
|
|
{
|
|
if( FindItemOwner( i ) == s || ObjInRange( s, i, DIST_NEARBY ))
|
|
{
|
|
Effects->PlayStaticAnimation( i, 0x36B0, 0x09, 0x09 );
|
|
Effects->PlayStaticAnimation( s, 0x36B0, 0x09, 0x09 );
|
|
Effects->PlaySound( s, 0x0207 );
|
|
if( CheckResist( nullptr, s, 4 ))
|
|
{
|
|
MagicDamage( s, i->GetTempVar( CITV_MOREZ, 2 ) / 2, nullptr, HEAT );
|
|
}
|
|
else
|
|
{
|
|
MagicDamage( s, i->GetTempVar( CITV_MOREZ, 2 ), nullptr, HEAT );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Player is out of range, possibly opened the trapped container using Telekinesis from a safe distance
|
|
Effects->PlayStaticAnimation( i, 0x36B0, 0x09, 0x09 );
|
|
Effects->PlaySound( i, 0x0207 );
|
|
|
|
// Find nearby players and apply damage to them?
|
|
for( auto &MapArea : MapRegion->PopulateList( s ))
|
|
{
|
|
if( MapArea == nullptr )
|
|
continue;
|
|
|
|
auto regChars = MapArea->GetCharList();
|
|
for( const auto &tempChar :regChars->collection() )
|
|
{
|
|
if( !ValidateObject( tempChar ) || tempChar->GetInstanceId() != s->GetInstanceId() || tempChar->GetSerial() == s->GetSerial() )
|
|
continue;
|
|
|
|
if( ObjInRange( tempChar, i, DIST_NEARBY ))
|
|
{
|
|
if( CheckResist( nullptr, tempChar, 4 ))
|
|
{
|
|
MagicDamage( tempChar, i->GetTempVar( CITV_MOREZ, 2 ) / 2, s, HEAT );
|
|
}
|
|
else
|
|
{
|
|
MagicDamage( tempChar, i->GetTempVar( CITV_MOREZ, 2 ), s, HEAT );
|
|
}
|
|
|
|
// Reveal hidden players impacted by the explosion
|
|
if( tempChar->GetVisible() == VT_TEMPHIDDEN || tempChar->GetVisible() == VT_INVISIBLE )
|
|
{
|
|
tempChar->ExposeToView();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Set first part of MOREZ to 0 to disable trap, but leave other parts intact
|
|
i->SetTempVar( CITV_MOREZ, 1, 0 );
|
|
}
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CMagic::CheckReagents()
|
|
//| Changes - to use reag-st
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Check for required reagents in player's backpack.
|
|
//o------------------------------------------------------------------------------------------------o
|
|
bool CMagic::CheckReagents( CChar *s, const Reag_st *reagents )
|
|
{
|
|
Reag_st failmsg;
|
|
if( s->NoNeedReags() )
|
|
return true;
|
|
|
|
if( reagents->ash != 0 && GetItemAmount( s, 0x0F8C ) < reagents->ash )
|
|
{
|
|
failmsg.ash = 1;
|
|
}
|
|
if( reagents->drake!=0 && GetItemAmount( s, 0x0F86 ) < reagents->drake )
|
|
{
|
|
failmsg.drake = 1;
|
|
}
|
|
if( reagents->garlic != 0 && GetItemAmount( s, 0x0F84 ) < reagents->garlic )
|
|
{
|
|
failmsg.garlic = 1;
|
|
}
|
|
if( reagents->ginseng != 0 && GetItemAmount( s, 0x0F85 ) < reagents->ginseng )
|
|
{
|
|
failmsg.ginseng = 1;
|
|
}
|
|
if( reagents->moss != 0 && GetItemAmount( s, 0x0F7B ) < reagents->moss )
|
|
{
|
|
failmsg.moss = 1;
|
|
}
|
|
if( reagents->pearl != 0 && GetItemAmount( s, 0x0F7A ) < reagents->pearl )
|
|
{
|
|
failmsg.pearl = 1;
|
|
}
|
|
if( reagents->shade != 0 && GetItemAmount( s, 0x0F88 ) < reagents->shade )
|
|
{
|
|
failmsg.shade = 1;
|
|
}
|
|
if( reagents->silk != 0 && GetItemAmount( s, 0x0F8D ) < reagents->silk )
|
|
{
|
|
failmsg.silk = 1;
|
|
}
|
|
if( reagents->batwing != 0 && GetItemAmount( s, 0x0F78 ) < reagents->batwing )
|
|
{
|
|
failmsg.batwing = 1;
|
|
}
|
|
if( reagents->daemonblood != 0 && GetItemAmount( s, 0x0F7D ) < reagents->daemonblood )
|
|
{
|
|
failmsg.daemonblood = 1;
|
|
}
|
|
if( reagents->gravedust != 0 && GetItemAmount( s, 0x0F8F ) < reagents->gravedust )
|
|
{
|
|
failmsg.gravedust = 1;
|
|
}
|
|
if( reagents->noxcrystal != 0 && GetItemAmount( s, 0x0F8E ) < reagents->noxcrystal )
|
|
{
|
|
failmsg.noxcrystal = 1;
|
|
}
|
|
if( reagents->pigiron != 0 && GetItemAmount( s, 0x0F8A ) < reagents->pigiron )
|
|
{
|
|
failmsg.pigiron = 1;
|
|
}
|
|
return RegMsg( s, failmsg );
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CMagic::RegMsg()
|
|
//| Changes - display missing reagents types
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Display an error message if character has not enough regs
|
|
//o------------------------------------------------------------------------------------------------o
|
|
bool CMagic::RegMsg( CChar *s, Reag_st failmsg )
|
|
{
|
|
if( !ValidateObject( s ))
|
|
return true;
|
|
|
|
bool display = false;
|
|
char message[100] = { 0, };
|
|
|
|
// Copy dictionary message into char array
|
|
strcopy( message, 100, Dictionary->GetEntry( 702 ).c_str() ); // You do not have enough reagents to cast that spell.
|
|
|
|
// Create temporary string to hold info on our missing reagents
|
|
std::string tempString;
|
|
tempString = " [";
|
|
|
|
if( failmsg.ash )
|
|
{
|
|
display = true; tempString += "Sa, ";
|
|
}
|
|
if( failmsg.drake )
|
|
{
|
|
display = true; tempString += "Mr, ";
|
|
}
|
|
if( failmsg.garlic )
|
|
{
|
|
display = true; tempString += "Ga, ";
|
|
}
|
|
if( failmsg.ginseng )
|
|
{
|
|
display = true; tempString += "Gi, ";
|
|
}
|
|
if( failmsg.moss )
|
|
{
|
|
display = true; tempString += "Bm, ";
|
|
}
|
|
if( failmsg.pearl )
|
|
{
|
|
display = true; tempString += "Bp, ";
|
|
}
|
|
if( failmsg.shade )
|
|
{
|
|
display = true; tempString += "Ns, ";
|
|
}
|
|
if( failmsg.silk )
|
|
{
|
|
display = true; tempString += "Ss, ";
|
|
}
|
|
if( failmsg.batwing )
|
|
{
|
|
display = true; tempString += "Ba, ";
|
|
}
|
|
if( failmsg.daemonblood )
|
|
{
|
|
display = true; tempString += "Db, ";
|
|
}
|
|
if( failmsg.gravedust )
|
|
{
|
|
display = true; tempString += "Gd, ";
|
|
}
|
|
if( failmsg.noxcrystal )
|
|
{
|
|
display = true; tempString += "Nc, ";
|
|
}
|
|
if( failmsg.pigiron )
|
|
{
|
|
display = true; tempString += "Pi, ";
|
|
}
|
|
|
|
// Append our temporary string to the end of the char array and add an end-bracket
|
|
mstrcat( message, 100, tempString.c_str() );
|
|
message[strlen( message ) - 2] = ']';
|
|
|
|
if( display )
|
|
{
|
|
CSocket *i = s->GetSocket();
|
|
if( i != nullptr )
|
|
{
|
|
i->SysMessage( message );
|
|
}
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CMagic::SpellFail()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Do visual and sound effects when a player fails to cast a spell.
|
|
//o------------------------------------------------------------------------------------------------o
|
|
void CMagic::SpellFail( CSocket *s )
|
|
{
|
|
CChar *mChar = s->CurrcharObj();
|
|
Effects->PlayStaticAnimation( mChar, 0x3735, 0, 30 );
|
|
Effects->PlaySound( mChar, 0x005C );
|
|
mChar->TextMessage( s, 771, EMOTE, false ); // The spell fizzles.
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////
|
|
/////////////////////////////////////////////////////////////////
|
|
/////// PCs CASTING SPELLS RELATED FUNCTIONS ////////////////////
|
|
/////////////////////////////////////////////////////////////////
|
|
/////////////////////////////////////////////////////////////////
|
|
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CMagic::SelectSpell()
|
|
//| Date - 28 August 1999 / 10 September 1999
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Execute the selected spell to cast.
|
|
//|
|
|
//| Changes - Use spells (memory version of script info )
|
|
//| Made memory optionable
|
|
//| Perma cached
|
|
//| Added JS handling
|
|
//o------------------------------------------------------------------------------------------------o
|
|
bool CMagic::SelectSpell( CSocket *mSock, SI32 num )
|
|
{
|
|
if( num < 1 )
|
|
{
|
|
Console.Error( "Invalid spell ID passed to CMagic::SelectSpell() - aborting spellcast attempt!" );
|
|
return false;
|
|
}
|
|
|
|
/*SI16 lowSkill = 0, highSkill = 0;*/
|
|
CChar *mChar = mSock->CurrcharObj();
|
|
|
|
cScript *jsScript = JSMapping->GetScript( spells[num].JSScript() );
|
|
|
|
if( jsScript != nullptr )
|
|
{
|
|
// It is the responsibility of the JS script to call the proper events (ie onSpellSuccess and so forth)
|
|
// They deal with their own mana subtraction and all sorts of things
|
|
// They also deal with valid regions and what not. s is *not* guaranteed to be valid (ie it could be an NPC)
|
|
// Suggested script workflow:
|
|
// * Check if already casting, if so, stop and dump out
|
|
// * Check if frozen, if so, can't cast spell
|
|
// * Check if enabled
|
|
// * Check if scroll, wand or normal cast (scroll reduce requirements, wand do straight away)
|
|
// * Check requirements (min int, dex, str)
|
|
// * Check for reagants
|
|
// * Check if can cast in this area
|
|
// * Determine if the cast "succeeded"
|
|
// * If so, fire onSpellSuccess, otherwise fire onSpellFailure. If failed, speak and return
|
|
// * Set the player as "casting" and freeze
|
|
// * Create timer for when the spell will be complete
|
|
// * Wait for timer to elapse
|
|
// * Upon timer elapsing,
|
|
// * Unfreeze player
|
|
// * Send target identifier if any (based on timer) and wait for callback
|
|
// * If not target, do action (if any)
|
|
// * If target, create onCallback function
|
|
// * On callback, do stuff
|
|
// * NOTE * For area affect spells, use an AreaCharacterFunction
|
|
if( jsScript->MagicSpellCast( mSock, mChar, false, num ))
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
|
|
if( !mChar->GetCanAttack() )
|
|
{
|
|
mSock->SysMessage( 1778 ); // You are currently under the effect of peace and can not attack!
|
|
return false;
|
|
}
|
|
|
|
if( mSock->GetCursorItem() != nullptr )
|
|
{
|
|
// Player is holding an item, disallow casting while holding items on the cursor
|
|
mSock->SysMessage( Dictionary->GetEntry( 2862, mSock->Language() )); // Your hands must be free to cast spells or meditate.
|
|
return false;
|
|
}
|
|
|
|
SI32 type = mSock->CurrentSpellType();
|
|
CSpellInfo curSpellCasting = spells[num];
|
|
|
|
// Spell recovery time active? This timer stars as soon as targeting cursor is ready, and defaults to 1.0 seconds unless set otherwise in spells.dfn
|
|
if( mChar->GetTimer( tCHAR_SPELLRECOVERYTIME ) != 0 )
|
|
{
|
|
if( mChar->GetTimer( tCHAR_SPELLRECOVERYTIME ) > cwmWorldState->GetUICurrentTime() )
|
|
{
|
|
mSock->SysMessage( 1638 ); // You must wait a little while before casting
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// Player already casting a spell?
|
|
if( mChar->GetTimer( tCHAR_SPELLTIME ) != 0 )
|
|
{
|
|
if( mChar->IsCasting() )
|
|
{
|
|
mSock->SysMessage( 762 ); // You are already casting a spell.
|
|
return false;
|
|
}
|
|
else if( mChar->GetTimer( tCHAR_SPELLTIME ) > cwmWorldState->GetUICurrentTime() )
|
|
{
|
|
mSock->SysMessage( 1638 ); // You must wait a little while before casting
|
|
return false;
|
|
}
|
|
}
|
|
|
|
mChar->SetSpellCast( static_cast<SI08>( num ));
|
|
if( num > 63 && num <= static_cast<SI32>( spellCount ) && spellCount <= 70 )
|
|
{
|
|
LogSpell( Dictionary->GetEntry( magic_table[num].spell_name ), mChar, nullptr, "(Attempted)");
|
|
}
|
|
if( mChar->IsJailed() && !mChar->IsGM() )
|
|
{
|
|
mSock->SysMessage( 704 ); // You are in jail and cannot cast spells!
|
|
mChar->StopSpell();
|
|
return false;
|
|
}
|
|
|
|
// Region checks
|
|
CTownRegion *ourReg = mChar->GetRegion();
|
|
if(( num == 45 && !ourReg->CanMark() ) || ( num == 52 && !ourReg->CanGate() ) ||
|
|
( num == 32 && !ourReg->CanRecall() ) || ( num == 22 && !ourReg->CanTeleport() ))
|
|
{
|
|
mSock->SysMessage( 705 ); // This is not allowed here.
|
|
mChar->StopSpell();
|
|
return false;
|
|
}
|
|
|
|
// Check if caster can cast aggressive spells in the region they're in
|
|
if( spells[mChar->GetSpellCast()].AggressiveSpell() )
|
|
{
|
|
bool allowCasting = true;
|
|
if( mChar->GetRegion()->IsSafeZone() )
|
|
{
|
|
mSock->SysMessage( 1799 ); // Hostile actions are not permitted in this safe area.
|
|
allowCasting = false;
|
|
}
|
|
else if( !mChar->GetRegion()->CanCastAggressive() )
|
|
{
|
|
mSock->SysMessage( 706 ); // This is not allowed in town.
|
|
allowCasting = false;
|
|
}
|
|
|
|
if( !allowCasting )
|
|
{
|
|
// Not allowed to cast selected spell in this region, abort
|
|
mChar->StopSpell();
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if( !curSpellCasting.Enabled() )
|
|
{
|
|
mSock->SysMessage( 707 ); // That spell is currently not enabled.
|
|
mChar->StopSpell();
|
|
return false;
|
|
}
|
|
|
|
// The following loop checks to see if any item is currently equipped (if not a GM)
|
|
if( !mChar->IsGM() && type != 2 )
|
|
{
|
|
bool autoUnequipEnabled = cwmWorldState->ServerData()->AutoUnequippedCasting();
|
|
|
|
CItem *itemRHand = mChar->GetItemAtLayer( IL_RIGHTHAND );
|
|
CItem *itemLHand = mChar->GetItemAtLayer( IL_LEFTHAND );
|
|
auto mCharPack = mChar->GetPackItem();
|
|
|
|
// Function to check and possibly unequip an item if it blocks spell casting
|
|
auto handleItem = [&]( CItem* item, auto itemCheck, bool& blockFlag )
|
|
{
|
|
if( item && itemCheck( item ))
|
|
{
|
|
// If auto-unequip is enabled, make sure pack can hold another item before unequipping
|
|
if( autoUnequipEnabled && ValidateObject( mCharPack ) && mCharPack->GetContainsList()->Num() < mCharPack->GetMaxItems() )
|
|
{
|
|
item->SetCont( mCharPack );
|
|
blockFlag = false;
|
|
}
|
|
else
|
|
{
|
|
blockFlag = true;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
blockFlag = false;
|
|
}
|
|
};
|
|
|
|
bool lHandBlocks = true;
|
|
bool rHandBlocks = true;
|
|
|
|
// Evaluate blocking for left and right hand items
|
|
handleItem( itemLHand, []( CItem* item ) { return item->GetType() != IT_SPELLCHANNELING; }, lHandBlocks );
|
|
handleItem( itemRHand, []( CItem* item ) { return item->GetType() != IT_SPELLBOOK && item->GetType() != IT_SPELLCHANNELING; }, rHandBlocks );
|
|
|
|
if( lHandBlocks || rHandBlocks )
|
|
{
|
|
mSock->SysMessage( 708 ); // You cannot cast with a weapon equipped.
|
|
mChar->StopSpell();
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if( mChar->GetVisible() == VT_TEMPHIDDEN || mChar->GetVisible() == VT_INVISIBLE )
|
|
{
|
|
mChar->ExposeToView();
|
|
}
|
|
mChar->BreakConcentration( mSock );
|
|
|
|
// What the JavaScript event has to handle:
|
|
|
|
// - Reag consumption
|
|
// - Health consumption
|
|
// - Mana consumption
|
|
// - Stamina consumption
|
|
|
|
// - Delay measurement
|
|
|
|
SI16 castDelay = -2;
|
|
|
|
// If more than one script contains the onSpellCast/onScrollCast events, whichever script runs last will
|
|
// determine the final delay value
|
|
std::vector<UI16> scriptTriggers = mChar->GetScriptTriggers();
|
|
for( auto scriptTrig : scriptTriggers )
|
|
{
|
|
cScript *toExecute = JSMapping->GetScript( scriptTrig );
|
|
if( toExecute != nullptr )
|
|
{
|
|
// Events:
|
|
// type 0: onSpellCast (SpellBook)
|
|
// type 1: onScrollCast (Scroll)
|
|
// type 2: onScrolllCast (Wand)
|
|
|
|
if( type == 0 )
|
|
{
|
|
castDelay = toExecute->OnSpellCast( mChar, num );
|
|
}
|
|
else
|
|
{
|
|
castDelay = toExecute->OnScrollCast( mChar, num );
|
|
}
|
|
}
|
|
}
|
|
|
|
// If Delay is -1 the spell should be canceled
|
|
if( castDelay == -1 )
|
|
{
|
|
mChar->StopSpell();
|
|
return false;
|
|
}
|
|
|
|
if(( castDelay == -2 ) && !mChar->IsGM() )
|
|
{
|
|
// type == 2 - Wands
|
|
if( type != 2 )
|
|
{
|
|
if( !CheckMana( mChar, num ))
|
|
{
|
|
mSock->SysMessage( 696 ); // You have insufficient mana to cast that spell.
|
|
mChar->StopSpell();
|
|
return false;
|
|
}
|
|
if( !CheckStamina( mChar, num ))
|
|
{
|
|
mSock->SysMessage( 697 ); // You have insufficient stamina to cast that spell.
|
|
mChar->StopSpell();
|
|
return false;
|
|
}
|
|
if( !CheckHealth( mChar, num ))
|
|
{
|
|
mSock->SysMessage( 698 ); // You have insufficient health to cast that spell.
|
|
mChar->StopSpell();
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
mChar->SetNextAct( 75 ); // why 75?
|
|
|
|
// Delay measurement...
|
|
if( castDelay >= 0 )
|
|
{
|
|
mChar->SetTimer( tCHAR_SPELLTIME, BuildTimeValue( static_cast<R64>( castDelay ) / 1000.0 ));
|
|
if( !cwmWorldState->ServerData()->CastSpellsWhileMoving() )
|
|
{
|
|
mChar->SetFrozen( true );
|
|
mChar->Dirty( UT_UPDATE );
|
|
}
|
|
}
|
|
else if( type == 0 && mChar->GetCommandLevel() < CL_GM ) // if they are a gm they don't have a delay :-)
|
|
{
|
|
mChar->SetTimer( tCHAR_SPELLTIME, BuildTimeValue( static_cast<R64>( curSpellCasting.Delay() )));
|
|
if( !cwmWorldState->ServerData()->CastSpellsWhileMoving() )
|
|
{
|
|
mChar->SetFrozen( true );
|
|
mChar->Dirty( UT_UPDATE );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Inform GM why there's no spellcast delay
|
|
mSock->SysMessage( 6280 ); // Spellcast delay ignored due to elevated command level!
|
|
mChar->SetTimer( tCHAR_SPELLTIME, 0 );
|
|
}
|
|
// Delay measurement end
|
|
|
|
//if( !mChar->IsOnHorse() )
|
|
Effects->PlaySpellCastingAnimation( mChar, curSpellCasting.Action(), false, false ); // do the action
|
|
|
|
std::string temp;
|
|
if( spells[num].FieldSpell() )
|
|
{
|
|
if( mChar->GetSkill( MAGERY ) > 600 )
|
|
{
|
|
temp = "Vas " + curSpellCasting.Mantra();
|
|
}
|
|
else
|
|
{
|
|
temp = curSpellCasting.Mantra();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
temp = curSpellCasting.Mantra();
|
|
}
|
|
|
|
mChar->TextMessage( nullptr, temp, TALK, false );
|
|
mChar->SetCasting( true );
|
|
return true;
|
|
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CMagic::GetFieldDir()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Gets field direction
|
|
//o------------------------------------------------------------------------------------------------o
|
|
UI08 CMagic::GetFieldDir( CChar *s, SI16 x, SI16 y )
|
|
{
|
|
UI08 fieldDir = 0;
|
|
switch( Movement->Direction( s, x, y ))
|
|
{
|
|
case NORTH:
|
|
case SOUTH:
|
|
break;
|
|
case EAST:
|
|
case WEST:
|
|
fieldDir = 1;
|
|
break;
|
|
case NORTHEAST:
|
|
case SOUTHEAST:
|
|
case SOUTHWEST:
|
|
case NORTHWEST:
|
|
case UNKNOWNDIR:
|
|
switch( s->GetDir() )
|
|
{
|
|
case NORTH:
|
|
case SOUTH:
|
|
break;
|
|
case NORTHEAST:
|
|
case EAST:
|
|
case SOUTHEAST:
|
|
case SOUTHWEST:
|
|
case WEST:
|
|
case NORTHWEST:
|
|
fieldDir = 1;
|
|
break;
|
|
default:
|
|
Console.Error( " Fallout of switch statement without default. uox3.cpp, GetFieldDir()" );
|
|
break;
|
|
}
|
|
break;
|
|
default:
|
|
Console.Error( " Fallout of switch statement without default. uox3.cpp, GetFieldDir()" );
|
|
break;
|
|
}
|
|
return fieldDir;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CMagic::ConsumeSpellResources()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Handles mana/health/stamina and reagent consumption for spellcasting
|
|
//o------------------------------------------------------------------------------------------------o
|
|
void CMagic::ConsumeSpellResources( CSocket *s, CChar *caster, SI08 curSpell )
|
|
{
|
|
// Consume mana/health/stamina for the spellcast attempt, if
|
|
// caster is an NPC or spelltype is spellbook or scrolls
|
|
bool validSocket = ( s != nullptr );
|
|
if( caster->IsNpc() || ( validSocket && ( s->CurrentSpellType() != 2 )))
|
|
{
|
|
SubtractMana( caster, spells[curSpell].Mana() );
|
|
if( spells[curSpell].Health() > 0 )
|
|
{
|
|
SubtractHealth( caster, spells[curSpell].Health(), curSpell );
|
|
}
|
|
SubtractStamina( caster, spells[curSpell].Stamina() );
|
|
}
|
|
|
|
// Consume reagents for the spellcast attempt
|
|
if( validSocket && s->CurrentSpellType() == 0 && !caster->IsNpc() )
|
|
{
|
|
DelReagents( caster, spells[curSpell].Reagants() );
|
|
}
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CMagic::CheckMagicSkill()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Handles skill checks for spellcasting
|
|
//o------------------------------------------------------------------------------------------------o
|
|
bool CMagic::CheckMagicSkill( CSocket *s, CChar *caster, SI08 curSpell )
|
|
{
|
|
bool validSocket = ( s != nullptr );
|
|
SI16 lowSkill = 0, highSkill = 0;
|
|
if( validSocket && s->CurrentSpellType() == 1 && cwmWorldState->ServerData()->CutScrollRequirementStatus() ) // only if enabled
|
|
{
|
|
lowSkill = spells[curSpell].ScrollLow();
|
|
highSkill = spells[curSpell].ScrollHigh();
|
|
}
|
|
else
|
|
{
|
|
lowSkill = spells[curSpell].LowSkill();
|
|
highSkill = spells[curSpell].HighSkill();
|
|
}
|
|
|
|
// Do the skill check, and fizzle if player fails
|
|
if( !caster->IsNpc() && !caster->IsGM() && ( !Skills->CheckSkill( caster, MAGERY, lowSkill, highSkill )))
|
|
{
|
|
if( validSocket )
|
|
{
|
|
SpellFail( s );
|
|
}
|
|
caster->StopSpell();
|
|
return false;
|
|
}
|
|
else if( caster->IsNpc() )
|
|
{
|
|
// Run a skillcheck for NPC to give them a chance to gain skill - if that option is enabled in ini
|
|
Skills->CheckSkill( caster, MAGERY, lowSkill, highSkill );
|
|
}
|
|
return true;
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CMagic::CastSpell()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Handles a character's attempt to cast spells
|
|
//o------------------------------------------------------------------------------------------------o
|
|
void CMagic::CastSpell( CSocket *s, CChar *caster )
|
|
{
|
|
// for LocationTarget spell like ArchCure, ArchProtection etc...
|
|
SI08 curSpell;
|
|
|
|
curSpell = caster->GetSpellCast();
|
|
|
|
// No spell! Abort
|
|
if( curSpell == -1 )
|
|
return;
|
|
|
|
cScript *jsScript = JSMapping->GetScript( spells[curSpell].JSScript() );
|
|
if( jsScript != nullptr )
|
|
{
|
|
if( jsScript->MagicSpellCast( s, caster, true, curSpell ))
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
|
|
if( caster->IsCasting() )
|
|
return; // interrupted
|
|
|
|
caster->StopSpell();
|
|
|
|
std::vector<UI16> scriptTriggers = caster->GetScriptTriggers();
|
|
for( auto scriptTrig : scriptTriggers )
|
|
{
|
|
cScript *toExecute = JSMapping->GetScript( scriptTrig );
|
|
if( toExecute != nullptr )
|
|
{
|
|
// If script returns true/1, prevent other scripts with event from running
|
|
if( toExecute->OnSpellSuccess( caster, curSpell ) == 1 )
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
CChar *src = caster;
|
|
bool validSocket = ( s != nullptr );
|
|
|
|
// Check if caster can cast aggressive spells in the region they're in
|
|
if( spells[curSpell].AggressiveSpell() )
|
|
{
|
|
bool allowCasting = true;
|
|
if( caster->GetRegion()->IsSafeZone() )
|
|
{
|
|
// Caster is in a safe zone, where all aggressive actions are forbidden
|
|
if( validSocket )
|
|
{
|
|
s->SysMessage( 1799 ); // Hostile actions are not permitted in this safe area.
|
|
}
|
|
allowCasting = false;
|
|
}
|
|
else if( !caster->GetRegion()->CanCastAggressive() )
|
|
{
|
|
// Caster is in a region where casting aggressive spells is forbidden
|
|
if( validSocket )
|
|
{
|
|
s->SysMessage( 709 ); // You can't cast in town!
|
|
}
|
|
allowCasting = false;
|
|
}
|
|
if( !allowCasting )
|
|
return;
|
|
}
|
|
|
|
if( curSpell == 32 || curSpell == 52 )
|
|
{
|
|
if( !cwmWorldState->ServerData()->TravelSpellsWhileAggressor() )
|
|
{
|
|
// Aggressor flag only matters against other players, not against NPCs
|
|
if(( caster->IsAggressor( true ) && ValidateObject( caster->GetTarg() ) && caster->GetTarg()->IsInnocent() ))
|
|
{
|
|
if( validSocket )
|
|
{
|
|
s->SysMessage( 2066 ); // You are not allowed to use Recall or Gate spells while being the aggressor in a fight!
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
|
|
if( caster->IsCriminal() || caster->HasStolen() )
|
|
{
|
|
if( validSocket )
|
|
{
|
|
s->SysMessage( 9278 ); // You cannot use Recall or Gate spells while you have an active criminal flag, or if you have stolen recently!
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
|
|
//Check for enough reagents
|
|
// type == 0 -> SpellBook
|
|
if( validSocket && s->CurrentSpellType() == 0 && !CheckReagents( caster, spells[curSpell].ReagantsPtr() ))
|
|
{
|
|
caster->StopSpell();
|
|
return;
|
|
}
|
|
|
|
// Let human NPC casters say the magic words as they cast spells
|
|
if( caster->IsNpc() && cwmWorldState->creatures[caster->GetId()].IsHuman() )
|
|
{
|
|
std::string temp;
|
|
if( spells[curSpell].FieldSpell() )
|
|
{
|
|
if( caster->GetSkill( MAGERY ) > 600 )
|
|
{
|
|
temp = "Vas " + spells[curSpell].Mantra();
|
|
}
|
|
else
|
|
{
|
|
temp = spells[curSpell].Mantra();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
temp = spells[curSpell].Mantra();
|
|
}
|
|
|
|
caster->TextMessage( nullptr, temp, TALK, false );
|
|
}
|
|
|
|
if( curSpell > 63 && static_cast<UI32>(curSpell) <= spellCount && spellCount <= 70 )
|
|
{
|
|
LogSpell( Dictionary->GetEntry( magic_table[curSpell].spell_name ), caster, nullptr, "(Succeeded)");
|
|
}
|
|
|
|
if( spells[curSpell].RequireTarget() ) // target spells if true
|
|
{
|
|
CItem *i = nullptr;
|
|
if( validSocket && spells[curSpell].TravelSpell() ) // travel spells.... mark, recall and gate
|
|
{
|
|
// Region checks
|
|
CTownRegion *ourReg = caster->GetRegion();
|
|
if(( curSpell == 45 && !ourReg->CanMark() ) || ( curSpell == 52 && !ourReg->CanGate() ) ||
|
|
( curSpell == 32 && !ourReg->CanRecall() ) || ( curSpell == 22 && !ourReg->CanTeleport() ))
|
|
{
|
|
if( validSocket )
|
|
{
|
|
s->SysMessage( 705 ); // This is not allowed here.
|
|
}
|
|
return;
|
|
}
|
|
// mark, recall and gate go here
|
|
if( !caster->IsNpc() )
|
|
{
|
|
i = CalcItemObjFromSer( s->GetDWord( 7 ));
|
|
}
|
|
if( ValidateObject( i ))
|
|
{
|
|
if( i->GetCont() != nullptr || LineOfSight( s, caster, i->GetX(), i->GetY(), i->GetZ(), WALLS_CHIMNEYS + DOORS + FLOORS_FLAT_ROOFING, false ) || caster->IsGM() )
|
|
{
|
|
if(( i->GetType() == IT_RECALLRUNE || (( curSpell == 32 || curSpell == 52 ) && i->GetType() == IT_RUNEBOOK )) || ( curSpell != 45 && i->GetType() == IT_KEY && cwmWorldState->ServerData()->TravelSpellsFromBoatKeys() ))
|
|
{
|
|
switch( curSpell )
|
|
{
|
|
case 32: //////////// (32) RECALL ////////////////
|
|
case 45: //////////// (45) MARK //////////////////
|
|
case 52: //////////// (52) GATE //////////////////
|
|
{
|
|
// Check for onSpellTargetSelect on spell caster
|
|
scriptTriggers.clear();
|
|
scriptTriggers.shrink_to_fit();
|
|
scriptTriggers = caster->GetScriptTriggers();
|
|
for( auto scriptTrig : scriptTriggers )
|
|
{
|
|
cScript *toExecute = JSMapping->GetScript( scriptTrig );
|
|
if( toExecute != nullptr )
|
|
{
|
|
auto retVal = toExecute->OnSpellTargetSelect( caster, i, curSpell );
|
|
if( retVal == 1 )
|
|
{
|
|
break;
|
|
}
|
|
else if( retVal == 2 )
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Check for onSpellTarget on spell target
|
|
scriptTriggers.clear();
|
|
scriptTriggers.shrink_to_fit();
|
|
scriptTriggers = i->GetScriptTriggers();
|
|
for( auto scriptTrig : scriptTriggers )
|
|
{
|
|
cScript *toExecute = JSMapping->GetScript( scriptTrig );
|
|
if( toExecute != nullptr )
|
|
{
|
|
// If script returns true/1, prevent other scripts with event from running
|
|
// If script returns 2, spell being cast on this target was rejected
|
|
auto retVal = toExecute->OnSpellTarget( i, caster, curSpell );
|
|
if( retVal == 1 )
|
|
{
|
|
break;
|
|
}
|
|
else if( retVal == 2 )
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Let's do all these as the final step after everything else has been cleared
|
|
ConsumeSpellResources( s, caster, curSpell );
|
|
if( !CheckMagicSkill( s, caster, curSpell ))
|
|
{
|
|
return;
|
|
}
|
|
PlaySound( src, curSpell );
|
|
DoMoveEffect( curSpell, i, src );
|
|
DoStaticEffect( src, curSpell );
|
|
|
|
(*(( MAGIC_ITEMFUNC )magic_table[curSpell-1].mag_extra ))( s, caster, i, curSpell );
|
|
break;
|
|
}
|
|
default:
|
|
Console.Error( oldstrutil::format( " Unknown Travel spell %i, magic.cpp", curSpell ));
|
|
break;
|
|
}
|
|
}
|
|
else if( validSocket )
|
|
{
|
|
s->SysMessage( 710 ); // That item is not a recall rune.
|
|
}
|
|
}
|
|
else if( validSocket )
|
|
{
|
|
s->SysMessage( 683 ); // There seems to be something in the way.
|
|
}
|
|
}
|
|
else if( validSocket )
|
|
{
|
|
s->SysMessage( 710 ); // That item is not a recall rune.
|
|
}
|
|
return;
|
|
}
|
|
|
|
if( spells[curSpell].RequireCharTarget() )
|
|
{
|
|
// TARGET CALC HERE
|
|
CChar *c = nullptr;
|
|
if( validSocket && !caster->IsNpc() )
|
|
{
|
|
c = CalcCharObjFromSer( s->GetDWord( 7 ));
|
|
}
|
|
else
|
|
{
|
|
c = caster->GetTarg();
|
|
}
|
|
|
|
if( ValidateObject( c )) // we have to have targetted a person to kill them :)
|
|
{
|
|
if( !ObjInRange( c, caster, cwmWorldState->ServerData()->CombatMaxSpellRange() ))
|
|
{
|
|
if( validSocket )
|
|
{
|
|
s->SysMessage( 712 ); // You can't cast on someone that far away!
|
|
}
|
|
return;
|
|
}
|
|
if( LineOfSight( s, caster, c->GetX(), c->GetY(), c->GetZ(), WALLS_CHIMNEYS + DOORS + FLOORS_FLAT_ROOFING, false ) || caster->IsGM() )
|
|
{
|
|
bool attackTarget = false;
|
|
if( spells[curSpell].AggressiveSpell() )
|
|
{
|
|
if( c->GetRegion()->IsSafeZone() )
|
|
{
|
|
// Target is in a safe zone, where all aggressive actions are forbidden
|
|
if( validSocket )
|
|
{
|
|
s->SysMessage( 1799 ); // Hostile actions are not permitted in this safe area.
|
|
}
|
|
return;
|
|
}
|
|
else if( !c->GetRegion()->CanCastAggressive() )
|
|
{
|
|
// Target is in a region where casting aggressive spells is forbidden
|
|
if( validSocket )
|
|
{
|
|
s->SysMessage( 709 ); // You can't cast in town!
|
|
}
|
|
return;
|
|
}
|
|
if( c->GetNpcAiType() == AI_PLAYERVENDOR || c->IsInvulnerable() )
|
|
{
|
|
if( validSocket )
|
|
{
|
|
s->SysMessage( 713 ); // They are invulnerable merchants!
|
|
}
|
|
return;
|
|
}
|
|
attackTarget = true;
|
|
}
|
|
|
|
UI08 spellType = 0;
|
|
switch( curSpell )
|
|
{
|
|
case 1: // Clumsy
|
|
case 3: // Feeblemind
|
|
case 4: // Heal 2-26-00 used OSI values from UO book
|
|
case 5: // Magic Arrow
|
|
case 6: // Night Sight
|
|
case 7: // Reactive Armor
|
|
case 8: // Weaken
|
|
case 9: // Agility
|
|
case 10: // Cunning
|
|
case 11: // Cure
|
|
case 12: // Harm
|
|
case 15: // Protection
|
|
case 16: // Strength
|
|
case 17: // Bless
|
|
case 18: // Fireball
|
|
case 20: // Poison
|
|
case 27: // Curse
|
|
case 29: // Greater Heal
|
|
case 30: // Lightning
|
|
case 31: // Mana drain
|
|
case 37: // Mind Blast
|
|
case 38: // Paralyze
|
|
case 41: // Dispel
|
|
case 42: // Energy Bolt
|
|
case 43: // Explosion
|
|
case 44: // Invisibility
|
|
case 51: // Flamestrike
|
|
case 53: // Mana Vampire
|
|
case 59: // Resurrection
|
|
{
|
|
// Check for onSpellTargetSelect on spell caster
|
|
scriptTriggers.clear();
|
|
scriptTriggers.shrink_to_fit();
|
|
scriptTriggers = caster->GetScriptTriggers();
|
|
for( auto scriptTrig : scriptTriggers )
|
|
{
|
|
cScript *toExecute = JSMapping->GetScript( scriptTrig );
|
|
if( toExecute != nullptr )
|
|
{
|
|
auto retVal = toExecute->OnSpellTargetSelect( caster, c, curSpell );
|
|
if( retVal == 1 )
|
|
{
|
|
break;
|
|
}
|
|
else if( retVal == 2 )
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Check for onSpellTarget event on spell target
|
|
scriptTriggers.clear();
|
|
scriptTriggers.shrink_to_fit();
|
|
scriptTriggers = c->GetScriptTriggers();
|
|
for( auto scriptTrig : scriptTriggers )
|
|
{
|
|
cScript *toExecute = JSMapping->GetScript( scriptTrig );
|
|
if( toExecute != nullptr )
|
|
{
|
|
auto retVal = toExecute->OnSpellTarget( c, caster, curSpell );
|
|
if( retVal == 1 )
|
|
{
|
|
break;
|
|
}
|
|
else if( retVal == 2 )
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
// All ok, continue casting spell
|
|
spellType = 1;
|
|
break;
|
|
}
|
|
case 46: // Mass cure
|
|
case 25: // Arch Cure
|
|
case 26: // Arch Protection
|
|
case 49: // Chain Lightning
|
|
case 54: // Mass Dispel
|
|
case 55: // Meteor Swarm
|
|
{
|
|
// Check for onSpellTargetSelect on spell caster
|
|
scriptTriggers.clear();
|
|
scriptTriggers.shrink_to_fit();
|
|
scriptTriggers = caster->GetScriptTriggers();
|
|
for( auto scriptTrig : scriptTriggers )
|
|
{
|
|
cScript *toExecute = JSMapping->GetScript( scriptTrig );
|
|
if( toExecute != nullptr )
|
|
{
|
|
auto retVal = toExecute->OnSpellTargetSelect( caster, c, curSpell );
|
|
if( retVal == 1 )
|
|
{
|
|
break;
|
|
}
|
|
else if( retVal == 2 )
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Check for onSpellTarget on spell target
|
|
scriptTriggers.clear();
|
|
scriptTriggers.shrink_to_fit();
|
|
scriptTriggers = c->GetScriptTriggers();
|
|
for( auto scriptTrig : scriptTriggers )
|
|
{
|
|
cScript *toExecute = JSMapping->GetScript( scriptTrig );
|
|
if( toExecute != nullptr )
|
|
{
|
|
auto retVal = toExecute->OnSpellTarget( c, caster, curSpell );
|
|
if( retVal == 1 )
|
|
{
|
|
break;
|
|
}
|
|
else if( retVal == 2 )
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
spellType = 2;
|
|
break;
|
|
}
|
|
default:
|
|
Console.Error( oldstrutil::format( " Unknown CharacterTarget spell %i, magic.cpp", curSpell ));
|
|
break;
|
|
}
|
|
|
|
if( spellType != 0 )
|
|
{
|
|
// Let's do all these as the final step after everything else has been cleared
|
|
ConsumeSpellResources( s, caster, curSpell );
|
|
if( !CheckMagicSkill( s, caster, curSpell ))
|
|
{
|
|
return;
|
|
}
|
|
if( attackTarget )
|
|
{
|
|
Combat->AttackTarget( caster, c );
|
|
}
|
|
|
|
if( spells[curSpell].SpellReflectable() )
|
|
{
|
|
if( CheckMagicReflect( c ))
|
|
{
|
|
src = c;
|
|
c = caster;
|
|
}
|
|
}
|
|
|
|
// Don't play sound and effects for these direct damagespells - it's handled
|
|
// in effect.cpp after their damage delay timer has expired. Dispel is also a special case
|
|
if( curSpell != 5 && curSpell != 12 && curSpell != 18 && curSpell != 30 && curSpell != 41
|
|
&& curSpell != 42 && curSpell != 43 && curSpell != 49 && curSpell != 51 && curSpell != 55 )
|
|
{
|
|
if( caster->IsNpc() )
|
|
{
|
|
PlaySound( c, curSpell );
|
|
}
|
|
else
|
|
{
|
|
PlaySound( src, curSpell );
|
|
}
|
|
|
|
DoMoveEffect( curSpell, c, src );
|
|
DoStaticEffect( c, curSpell );
|
|
}
|
|
|
|
if( spellType == 1 )
|
|
{
|
|
(*(( MAGIC_CHARFUNC )magic_table[curSpell-1].mag_extra ))( caster, c, src, curSpell );
|
|
}
|
|
else
|
|
{
|
|
(*(( MAGIC_TESTFUNC )magic_table[curSpell-1].mag_extra ))( s, caster, c, src, curSpell );
|
|
}
|
|
}
|
|
}
|
|
else if( validSocket )
|
|
{
|
|
s->SysMessage( 683 ); // There seems to be something in the way.
|
|
}
|
|
}
|
|
else if( validSocket )
|
|
{
|
|
s->SysMessage( 715 ); // That is not a person.
|
|
}
|
|
}
|
|
else if( spells[curSpell].RequireLocTarget() )
|
|
{
|
|
SI16 x = 0;
|
|
SI16 y = 0;
|
|
SI08 z = 0;
|
|
CBaseObject *getTarg = nullptr;
|
|
if( !caster->IsNpc() )
|
|
{
|
|
if( s->GetDWord( 7 ) != INVALIDSERIAL )
|
|
{
|
|
SERIAL targSer = s->GetDWord( 7 );
|
|
if( targSer >= BASEITEMSERIAL )
|
|
{
|
|
getTarg = CalcItemObjFromSer( targSer );
|
|
}
|
|
else
|
|
{
|
|
getTarg = CalcCharObjFromSer( targSer );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
x = s->GetWord( 11 );
|
|
y = s->GetWord( 13 );
|
|
z = s->GetByte( 16 ) + Map->TileHeight( s->GetWord( 17 ));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
getTarg = caster->GetTarg();
|
|
}
|
|
|
|
if( ValidateObject( getTarg ))
|
|
{
|
|
if( !getTarg->CanBeObjType( OT_ITEM ) || (static_cast<CItem *>(getTarg))->GetCont() == nullptr )
|
|
{
|
|
x = getTarg->GetX();
|
|
y = getTarg->GetY();
|
|
z = getTarg->GetZ();
|
|
}
|
|
else if( validSocket )
|
|
{
|
|
s->SysMessage( 717 ); // That is not a valid location.
|
|
return;
|
|
}
|
|
}
|
|
|
|
if( spells[curSpell].AggressiveSpell() )
|
|
{
|
|
CTownRegion *targetRegion = CalcRegionFromXY( x, y, caster->WorldNumber(), caster->GetInstanceId() );
|
|
if( targetRegion->IsSafeZone() )
|
|
{
|
|
// Target location is in a region where hostile actions are forbidden, disallow
|
|
if( validSocket )
|
|
{
|
|
s->SysMessage( 1799 ); // Hostile actions are not permitted in this safe area.
|
|
}
|
|
return;
|
|
}
|
|
else if( !targetRegion->CanCastAggressive() )
|
|
{
|
|
// Target location is in a region where casting aggressive spells is forbidden, disallow
|
|
if( validSocket )
|
|
{
|
|
s->SysMessage( 709 ); // You can't cast in town!
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
|
|
// Check distance to target location vs CombatMaxSpellRange
|
|
UI16 targDist;
|
|
Point3_st targLocation = Point3_st( x, y, z );
|
|
Point3_st difference = caster->GetLocation() - targLocation;
|
|
targDist = static_cast<UI16>( difference.Mag() );
|
|
if( targDist > cwmWorldState->ServerData()->CombatMaxSpellRange() )
|
|
{
|
|
if( validSocket )
|
|
{
|
|
s->SysMessage( 393 ); // That is too far away.
|
|
}
|
|
return;
|
|
}
|
|
|
|
if( LineOfSight( s, caster, x, y, z, WALLS_CHIMNEYS + DOORS + FLOORS_FLAT_ROOFING, false ))
|
|
{
|
|
if( spells[curSpell].FieldSpell() )
|
|
{
|
|
ConsumeSpellResources( s, caster, curSpell );
|
|
if( !CheckMagicSkill( s, caster, curSpell ))
|
|
{
|
|
return;
|
|
}
|
|
UI08 j = GetFieldDir( caster, x, y );
|
|
PlaySound( src, curSpell );
|
|
DoStaticEffect( src, curSpell );
|
|
(*(( MAGIC_FIELDFUNC )magic_table[curSpell-1].mag_extra ))( s, caster, j, x, y, z, curSpell );
|
|
}
|
|
else if( spells[curSpell].RequireNoTarget() )
|
|
{
|
|
switch( curSpell )
|
|
{
|
|
case 2: //create food
|
|
case 22:// Teleport
|
|
case 25:// Arch Cure
|
|
case 26:// Arch Protection
|
|
case 33:// Blade Spirits
|
|
case 34:// Dispel Field
|
|
case 40:// Summon Creature
|
|
case 46:// Mass curse
|
|
case 48:// Reveal
|
|
case 49:// Chain Lightning
|
|
case 54:// Mass Dispel
|
|
case 55:// Meteor Swarm
|
|
case 60:// Summon Air Elemental
|
|
case 61:// Summon Daemon
|
|
case 62:// Summon Earth Elemental
|
|
case 63:// Summon Fire Elemental
|
|
case 64:// Summon water Elemental
|
|
case 65:// Summon Hero
|
|
case 58:// Energy Vortex
|
|
ConsumeSpellResources( s, caster, curSpell );
|
|
if( !CheckMagicSkill( s, caster, curSpell ))
|
|
{
|
|
return;
|
|
}
|
|
if( curSpell != 48 )
|
|
{
|
|
PlaySound( src, curSpell );
|
|
DoStaticEffect( src, curSpell );
|
|
}
|
|
(*(( MAGIC_LOCFUNC )magic_table[curSpell-1].mag_extra ))( s, caster, x, y, z, curSpell );
|
|
break;
|
|
default:
|
|
Console.Error(oldstrutil::format( " Unknown LocationTarget spell %i", curSpell ));
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
else if( validSocket )
|
|
{
|
|
s->SysMessage( 717 ); // That is not a valid location.
|
|
}
|
|
}
|
|
else if( spells[curSpell].RequireItemTarget() && validSocket )
|
|
{
|
|
i = CalcItemObjFromSer( s->GetDWord( 7 ));
|
|
if( ValidateObject( i ))
|
|
{
|
|
auto iCont = i->GetCont();
|
|
if( iCont != nullptr && FindItemOwner( i ) != caster )
|
|
{
|
|
s->SysMessage( 718 ); // You can't cast on an item that far away!
|
|
return;
|
|
}
|
|
|
|
if( iCont == nullptr && !ObjInRange( caster, i, cwmWorldState->ServerData()->CombatMaxSpellRange() ))
|
|
{
|
|
s->SysMessage( 718 ); // You can't cast on an item that far away!
|
|
return;
|
|
}
|
|
|
|
if( iCont == nullptr && !LineOfSight( s, caster, i->GetX(), i->GetY(), i->GetZ(), WALLS_CHIMNEYS + DOORS + FLOORS_FLAT_ROOFING, false ) && !caster->IsGM() )
|
|
{
|
|
s->SysMessage( 683 ); // There seems to be something in the way.
|
|
return;
|
|
}
|
|
|
|
switch( curSpell )
|
|
{
|
|
case 13: // Magic Trap
|
|
case 14: // Magic Untrap
|
|
case 19: // Magic Lock
|
|
case 23: // Magic Unlock
|
|
case 21: // Telekinesis
|
|
ConsumeSpellResources( s, caster, curSpell );
|
|
if( !CheckMagicSkill( s, caster, curSpell ))
|
|
{
|
|
return;
|
|
}
|
|
(*(( MAGIC_ITEMFUNC )magic_table[curSpell-1].mag_extra))( s, caster, i, curSpell );
|
|
break;
|
|
default:
|
|
Console.Error( oldstrutil::format(" Unknown ItemTarget spell %i, magic.cpp", curSpell ));
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
s->SysMessage( 711 ); // That is not a valid item.
|
|
}
|
|
}
|
|
else if( validSocket )
|
|
{
|
|
s->SysMessage( 720 ); // Can't cope with this spell, requires a target but it doesn't specify what type.
|
|
}
|
|
return;
|
|
}
|
|
else if( spells[curSpell].RequireNoTarget() )
|
|
{
|
|
// non targetted spells
|
|
ConsumeSpellResources( s, caster, curSpell );
|
|
if( !CheckMagicSkill( s, caster, curSpell ))
|
|
{
|
|
return;
|
|
}
|
|
PlaySound( src, curSpell );
|
|
DoStaticEffect( src, curSpell );
|
|
switch( curSpell )
|
|
{
|
|
case 2: // Create food
|
|
case 40: // Summon Monster // summon monster is 40, not 33
|
|
case 35:
|
|
case 36: // Magic Reflection
|
|
case 56: // Poly Morph
|
|
case 57: // Earthquake
|
|
case 60: // Summon Air Elemental
|
|
case 61: // Summon Daemon
|
|
case 62: // Summon Earth Elemental
|
|
case 63: // Summon Fire Elemental
|
|
case 64: // Summon Water Elemental
|
|
case 65: // Summon Hero
|
|
case 67:
|
|
(*(( MAGIC_NOFUNC )magic_table[curSpell-1].mag_extra ))( s, caster, curSpell );
|
|
break;
|
|
default:
|
|
Console.Error( oldstrutil::format( " Unknown NonTarget spell %i, magic.cpp", curSpell ));
|
|
break;
|
|
}
|
|
return;
|
|
}
|
|
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CMagic::LoadScript()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Loads spell data from spell DFNs
|
|
//|
|
|
//| Notes - Avoid multiple reading of the spell script every time a spell is
|
|
//| cast to avoid crippling the server when a mage enters combat
|
|
//o------------------------------------------------------------------------------------------------o
|
|
void CMagic::LoadScript( void )
|
|
{
|
|
spells.resize( 0 );
|
|
|
|
// for some strange reason, spells go from index 1 to SPELL_MAX and
|
|
// apparently index 0 is left unused
|
|
spells.resize( SPELL_MAX + 1 );
|
|
|
|
std::string spEntry;
|
|
std::string tag, data, UTag;
|
|
UI08 i = 0;
|
|
for( auto &spellScp : FileLookup->ScriptListings[spells_def] )
|
|
{
|
|
if( spellScp == nullptr )
|
|
continue;
|
|
|
|
for( const auto &[spEntry, SpellLoad]:spellScp->collection() )
|
|
{
|
|
if( SpellLoad == nullptr )
|
|
continue;
|
|
|
|
auto ssecs = oldstrutil::sections( spEntry, " " );
|
|
if( ssecs[0] == "SPELL" )
|
|
{
|
|
i = static_cast<UI08>( std::stoul( oldstrutil::trim( oldstrutil::removeTrailing( ssecs[1], "//" )), nullptr, 0 ));
|
|
if( i <= SPELL_MAX )
|
|
{
|
|
++spellCount;
|
|
spells[i].Enabled( false );
|
|
Reag_st *mRegs = spells[i].ReagantsPtr();
|
|
|
|
//Console.Log( "Spell number: %i", "spell.log", i ); // Disabled for performance reasons
|
|
for( const auto &sec : SpellLoad->collection() )
|
|
{
|
|
tag = sec->tag;
|
|
data = sec->data;
|
|
UTag = oldstrutil::upper( tag );
|
|
data = oldstrutil::trim( oldstrutil::removeTrailing( data, "//" ));
|
|
//Console.Log( "Tag: %s\tData: %s", "spell.log", UTag.c_str(), data.c_str() ); // Disabled for performance reasons
|
|
switch(( UTag.data()[0] ))
|
|
{
|
|
case 'A':
|
|
if( UTag == "ACTION" )
|
|
{
|
|
spells[i].Action( static_cast<UI16>( std::stoul( data, nullptr, 0 )));
|
|
}
|
|
else if( UTag == "ASH" )
|
|
{
|
|
mRegs->ash =static_cast<UI08>( std::stoul( data, nullptr, 0 ));
|
|
}
|
|
break;
|
|
case 'B':
|
|
if( UTag == "BASEDMG" )
|
|
{
|
|
spells[i].BaseDmg( static_cast<SI16>( std::stoi( data, nullptr, 0 )));
|
|
}
|
|
else if( UTag == "BATWING" )
|
|
{
|
|
mRegs->batwing =static_cast<UI08>( std::stoul( data, nullptr, 0 ));
|
|
}
|
|
break;
|
|
case 'C':
|
|
if( UTag == "CIRCLE" )
|
|
{
|
|
spells[i].Circle( static_cast<UI08>( std::stoul( data, nullptr, 0 )));
|
|
}
|
|
break;
|
|
case 'D':
|
|
if( UTag == "DAMAGEDELAY" )
|
|
{
|
|
spells[i].DamageDelay( static_cast<R64>( std::stod( data )));
|
|
}
|
|
else if( UTag == "DELAY" )
|
|
{
|
|
spells[i].Delay( static_cast<R64>( std::stod( data )));
|
|
}
|
|
else if( UTag == "DAEMONBLOOD" )
|
|
{
|
|
mRegs->daemonblood =static_cast<UI08>( std::stoul( data, nullptr, 0 ));
|
|
}
|
|
else if( UTag == "DRAKE" )
|
|
{
|
|
mRegs->drake = static_cast<UI08>( std::stoul( data, nullptr, 0 ));
|
|
}
|
|
break;
|
|
case 'E':
|
|
if( UTag == "ENABLE" ) // presence of enable is enough to enable it
|
|
{
|
|
spells[i].Enabled( std::stoul( data, nullptr, 0 ) != 0 );
|
|
}
|
|
break;
|
|
case 'F':
|
|
if( UTag == "FLAGS" )
|
|
{
|
|
auto ssecs = oldstrutil::sections( data, " " );
|
|
if( ssecs.size() > 1 )
|
|
{
|
|
// This is used to load flags from old-style spells.dfn, where flags are written as FLAGS=## ## instead of FLAGS=0x####
|
|
spells[i].Flags((( static_cast<UI08>( std::stoul( oldstrutil::trim( oldstrutil::removeTrailing( ssecs[0], "//" )), nullptr, 16 ))) << 8 ) |
|
|
static_cast<UI08>( std::stoul( oldstrutil::trim( oldstrutil::removeTrailing( ssecs[1], "//" )), nullptr, 16 )));
|
|
}
|
|
else
|
|
{
|
|
spells[i].Flags( static_cast<UI16>( std::stoul( data, nullptr, 0 )));
|
|
}
|
|
}
|
|
break;
|
|
case 'G':
|
|
if( UTag == "GARLIC" )
|
|
{
|
|
mRegs->garlic = static_cast<UI08>( std::stoul( data, nullptr, 0 ));
|
|
}
|
|
else if( UTag == "GINSENG" )
|
|
{
|
|
mRegs->ginseng = static_cast<UI08>( std::stoul( data, nullptr, 0 ));
|
|
}
|
|
else if( UTag == "GRAVEDUST" )
|
|
{
|
|
mRegs->gravedust =static_cast<UI08>( std::stoul( data, nullptr, 0 ));
|
|
}
|
|
break;
|
|
case 'H':
|
|
if( UTag == "HISKILL" )
|
|
{
|
|
spells[i].HighSkill( static_cast<SI16>( std::stoi( data, nullptr, 0 )));
|
|
}
|
|
else if( UTag == "HEALTH" )
|
|
{
|
|
spells[i].Health( static_cast<SI16>( std::stoi( data, nullptr, 0 )));
|
|
}
|
|
break;
|
|
case 'L':
|
|
if( UTag == "LOSKILL" )
|
|
{
|
|
spells[i].LowSkill( static_cast<SI16>( std::stoi( data, nullptr, 0 )));
|
|
}
|
|
break;
|
|
case 'M':
|
|
if( UTag == "MANA" )
|
|
{
|
|
spells[i].Mana( static_cast<SI16>( std::stoi( data, nullptr, 0 )));
|
|
}
|
|
else if( UTag == "MANTRA" )
|
|
{
|
|
spells[i].Mantra( data );
|
|
}
|
|
else if( UTag == "MOSS" )
|
|
{
|
|
mRegs->moss = static_cast<UI08>( std::stoul( data, nullptr, 0 ));
|
|
}
|
|
else if( UTag == "MOVEFX" )
|
|
{
|
|
auto ssecs = oldstrutil::sections( data, " " );
|
|
if( ssecs.size() > 1 )
|
|
{
|
|
CMagicMove *mv = spells[i].MoveEffectPtr();
|
|
mv->Effect( static_cast<UI08>( std::stoul( oldstrutil::trim( oldstrutil::removeTrailing( ssecs[0], "//" )), nullptr, 16 )), static_cast<UI08>( std::stoul( oldstrutil::trim( oldstrutil::removeTrailing( ssecs[1], "//" )), nullptr, 16 )));
|
|
mv->Speed( static_cast<UI08>( std::stoul( oldstrutil::trim( oldstrutil::removeTrailing( ssecs[2], "//" )), nullptr, 16 )));
|
|
mv->Loop( static_cast<UI08>( std::stoul( oldstrutil::trim( oldstrutil::removeTrailing( ssecs[3], "//" )), nullptr, 16 )));
|
|
mv->Explode( static_cast<UI08>( std::stoul( oldstrutil::trim( oldstrutil::removeTrailing( ssecs[4], "//" )), nullptr, 16 )));
|
|
}
|
|
}
|
|
break;
|
|
case 'N':
|
|
if( UTag == "NOXCRYSTAL" )
|
|
{
|
|
mRegs->noxcrystal =static_cast<UI08>( std::stoul( data, nullptr, 0 ));
|
|
}
|
|
break;
|
|
case 'P':
|
|
if( UTag == "PEARL" )
|
|
{
|
|
mRegs->pearl = static_cast<UI08>( std::stoul( data, nullptr, 0 ));
|
|
}
|
|
else if( UTag == "PIGIRON" )
|
|
{
|
|
mRegs->pigiron = static_cast<UI08>( std::stoul( data, nullptr, 0 ));
|
|
}
|
|
break;
|
|
case 'R':
|
|
if( UTag == "RECOVERYDELAY" )
|
|
{
|
|
spells[i].RecoveryDelay( static_cast<R64>( std::stod( data )));
|
|
}
|
|
break;
|
|
case 'S':
|
|
if( UTag == "SHADE" )
|
|
{
|
|
mRegs->shade = static_cast<UI08>( std::stoul( data, nullptr, 0 ));
|
|
}
|
|
else if( UTag == "SILK" )
|
|
{
|
|
mRegs->silk = static_cast<UI08>( std::stoul( data, nullptr, 0 ));
|
|
}
|
|
else if( UTag == "SOUNDFX" )
|
|
{
|
|
auto ssecs = oldstrutil::sections( data, " " );
|
|
if( ssecs.size() > 1 )
|
|
{
|
|
// This is used to load sounds from old-style spells.dfn, where soundfx are written as SOUNDFX=## ## instead of SOUNDFX=0x####
|
|
spells[i].Effect(((static_cast<UI08>( std::stoul( oldstrutil::trim( oldstrutil::removeTrailing( ssecs[0], "//" )), nullptr, 16 )) << 8 ) |
|
|
static_cast<UI08>( std::stoul( oldstrutil::trim( oldstrutil::removeTrailing( ssecs[1], "//" )), nullptr, 16 ))));
|
|
}
|
|
else
|
|
{
|
|
spells[i].Effect( static_cast<UI16>( std::stoul( data, nullptr, 0 )));
|
|
}
|
|
}
|
|
else if( UTag == "STATFX" )
|
|
{
|
|
auto ssecs = oldstrutil::sections( data, " " );
|
|
if( ssecs.size() > 1 )
|
|
{
|
|
CMagicStat *stat = spells[i].StaticEffectPtr();
|
|
|
|
stat->Effect( static_cast<UI08>( std::stoul( oldstrutil::trim( oldstrutil::removeTrailing( ssecs[0], "//" )), nullptr, 16 )), static_cast<UI08>( std::stoul( oldstrutil::trim( oldstrutil::removeTrailing( ssecs[1], "//" )), nullptr, 16 )));
|
|
stat->Speed( static_cast<UI08>( std::stoul( oldstrutil::trim( oldstrutil::removeTrailing( ssecs[2], "//" )), nullptr, 16 )));
|
|
stat->Loop( static_cast<UI08>( std::stoul( oldstrutil::trim( oldstrutil::removeTrailing( ssecs[3], "//" )), nullptr, 16 )));
|
|
}
|
|
}
|
|
else if( UTag == "SCLO" )
|
|
{
|
|
spells[i].ScrollLow( static_cast<SI16>( std::stoi( data, nullptr, 0 )));
|
|
}
|
|
else if( UTag == "SCHI" )
|
|
{
|
|
spells[i].ScrollHigh( static_cast<SI16>( std::stoi( data, nullptr, 0 )));
|
|
}
|
|
else if( UTag == "STAMINA" )
|
|
{
|
|
spells[i].Stamina( static_cast<SI16>( std::stoi( data, nullptr, 0 )));
|
|
}
|
|
break;
|
|
case 'T':
|
|
if( UTag == "TARG" )
|
|
{
|
|
spells[i].StringToSay( data );
|
|
}
|
|
else if( UTag == "TITHING" )
|
|
{
|
|
spells[i].Tithing( static_cast<SI32>( std::stoi( data, nullptr, 0 )));
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#if defined( UOX_DEBUG_MODE )
|
|
Console.Print( "Registering spells\n" );
|
|
#endif
|
|
|
|
CJSMappingSection *spellSection = JSMapping->GetSection( SCPT_MAGIC );
|
|
|
|
for( cScript *ourScript = spellSection->First(); !spellSection->Finished(); ourScript = spellSection->Next() )
|
|
{
|
|
if( ourScript )
|
|
{
|
|
ourScript->ScriptRegistration( "Spell" );
|
|
}
|
|
}
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CMagic::DelReagents()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Deletes the specified amount of reagents when a spell is cast
|
|
//o------------------------------------------------------------------------------------------------o
|
|
void CMagic::DelReagents( CChar *s, Reag_st reags )
|
|
{
|
|
if( s->NoNeedReags() )
|
|
return;
|
|
|
|
DeleteItemAmount( s, reags.pearl, 0x0F7A );
|
|
DeleteItemAmount( s, reags.moss, 0x0F7B );
|
|
DeleteItemAmount( s, reags.garlic, 0x0F84 );
|
|
DeleteItemAmount( s, reags.ginseng, 0x0F85 );
|
|
DeleteItemAmount( s, reags.drake, 0x0F86 );
|
|
DeleteItemAmount( s, reags.shade, 0x0F88 );
|
|
DeleteItemAmount( s, reags.ash, 0x0F8C );
|
|
DeleteItemAmount( s, reags.silk, 0x0F8D );
|
|
DeleteItemAmount( s, reags.batwing, 0x0F78 );
|
|
DeleteItemAmount( s, reags.daemonblood, 0x0F7D );
|
|
DeleteItemAmount( s, reags.gravedust, 0x0F8F );
|
|
DeleteItemAmount( s, reags.noxcrystal, 0x0F8E );
|
|
DeleteItemAmount( s, reags.pigiron, 0x0F8A );
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CMagic::PlaySound()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Plays the SFX associated with a spell that is being cast
|
|
//o------------------------------------------------------------------------------------------------o
|
|
void CMagic::PlaySound( CChar *source, SI32 num )
|
|
{
|
|
if( spells[num].Effect() != INVALIDID )
|
|
{
|
|
Effects->PlaySound( source, spells[num].Effect() );
|
|
}
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CMagic::DoStaticEffect()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Plays the static FX associated with a spell that is being cast
|
|
//o------------------------------------------------------------------------------------------------o
|
|
void CMagic::DoStaticEffect( CChar *source, SI32 num )
|
|
{
|
|
CMagicStat temp = spells[num].StaticEffect();
|
|
if( temp.Effect() != INVALIDID )
|
|
{
|
|
Effects->PlayStaticAnimation( source, temp.Effect(), temp.Speed(), temp.Loop() );
|
|
}
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CMagic::DoMoveEffect()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Plays the moving FX associated with a spell that is being cast
|
|
//o------------------------------------------------------------------------------------------------o
|
|
void CMagic::DoMoveEffect( SI32 num, CBaseObject *target, CChar *source )
|
|
{
|
|
CMagicMove temp = spells[num].MoveEffect();
|
|
|
|
if( temp.Effect() != INVALIDID )
|
|
{
|
|
Effects->PlayMovingAnimation( source, target, temp.Effect(), temp.Speed(), temp.Loop(), ( temp.Explode() == 1 ));
|
|
}
|
|
}
|
|
|
|
void HandleCommonGump( CSocket *mSock, CScriptSection *gumpScript, UI16 gumpIndex );
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CMagic::PolymorphMenu()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Opens the polymorph menu to allow player to choose which creature to poly into
|
|
//o------------------------------------------------------------------------------------------------o
|
|
void CMagic::PolymorphMenu( CSocket *s, UI16 gmindex )
|
|
{
|
|
std::string sect = "POLYMORPHMENU " + oldstrutil::number( gmindex );
|
|
CScriptSection *polyStuff = FileLookup->FindEntry( sect, menus_def );
|
|
if( polyStuff == nullptr )
|
|
return;
|
|
|
|
HandleCommonGump( s, polyStuff, gmindex );
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CMagic::Polymorph()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Applies effects of Polymorph spell to caster
|
|
//o------------------------------------------------------------------------------------------------o
|
|
void CMagic::Polymorph( CSocket *s, UI16 polyId )
|
|
{
|
|
UI08 id1 = static_cast<UI08>( polyId >> 8 );
|
|
UI08 id2 = static_cast<UI08>( polyId % 256 );
|
|
CChar *mChar = s->CurrcharObj();
|
|
|
|
// store our original ID
|
|
mChar->SetOrgId( mChar->GetId() );
|
|
Effects->PlaySound( mChar, 0x020F );
|
|
// Temp effect will actually switch our body for us
|
|
Effects->TempEffect( mChar, mChar, 18, id1, id2, 0 );
|
|
mChar->IsPolymorphed( true );
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CMagic::LogSpell()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Writes out spell casting details to spell.log file
|
|
//o------------------------------------------------------------------------------------------------o
|
|
void CMagic::LogSpell( std::string spell, CChar *player1, CChar *player2, const std::string &extraInfo )
|
|
{
|
|
if( spell.empty() || !ValidateObject( player1 ))
|
|
return;
|
|
|
|
std::string logName = cwmWorldState->ServerData()->Directory( CSDDP_LOGS ) + "spell.log";
|
|
std::ofstream logDestination;
|
|
logDestination.open( logName.c_str(), std::ios::out | std::ios::app );
|
|
if( !logDestination.is_open() )
|
|
{
|
|
Console.Error(oldstrutil::format( "Unable to open spell log file %s!", logName.c_str() ));
|
|
return;
|
|
}
|
|
char dateTime[1024];
|
|
RealTime( dateTime );
|
|
|
|
logDestination << "[" << dateTime << "] ";
|
|
|
|
std::string casterName = GetNpcDictName( player1, nullptr, NRS_SYSTEM );
|
|
logDestination << casterName << " (serial: " << std::hex << player1->GetSerial() << " ) ";
|
|
logDestination << "cast spell <" << spell << "> ";
|
|
if( ValidateObject( player2 ))
|
|
{
|
|
std::string targetName = GetNpcDictName( player2, nullptr, NRS_SYSTEM );
|
|
logDestination << "on player " << targetName << " (serial: " << player2->GetSerial() << " ) ";
|
|
}
|
|
logDestination << "Extra Info: " << extraInfo << std::endl;
|
|
logDestination.close();
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CMagic::Register()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Registers a spell in the JS Engine
|
|
//o------------------------------------------------------------------------------------------------o
|
|
void CMagic::Register( cScript *toRegister, SI32 spellNumber, bool isEnabled )
|
|
{
|
|
#if defined( UOX_DEBUG_MODE )
|
|
Console.Print( oldstrutil::format( "Registering spell number %i\n", spellNumber ));
|
|
#endif
|
|
if( spellNumber < 0 || static_cast<size_t>( spellNumber ) >= spells.size() )
|
|
return;
|
|
|
|
if( toRegister == nullptr )
|
|
return;
|
|
|
|
spells[spellNumber].JSScript( JSMapping->GetScriptId( toRegister->Object() ));
|
|
spells[spellNumber].Enabled( isEnabled );
|
|
}
|
|
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Function - CMagic::SetSpellStatus()
|
|
//o------------------------------------------------------------------------------------------------o
|
|
//| Purpose - Sets the enabled state of a given spell
|
|
//o------------------------------------------------------------------------------------------------o
|
|
void CMagic::SetSpellStatus( SI32 spellNumber, bool isEnabled )
|
|
{
|
|
if( spellNumber < 0 || static_cast<size_t>( spellNumber ) >= spells.size() )
|
|
return;
|
|
|
|
spells[spellNumber].Enabled( isEnabled );
|
|
}
|