mmo-ref/uox3
1
0
Fork 0
mirror of https://github.com/UOX3DevTeam/UOX3 synced 2026-08-13 12:27:04 -04:00
Code Issues Projects Releases Packages Wiki Activity
uox3/source/CResponse.cpp
Charles Kerr 9fda6ae389 added bytebuffer_t under CPacketStream
2022-06-17 10:58:36 -04:00

1194 lines
46 KiB
C++
Raw Permalink Blame History

//o-----------------------------------------------------------------------------------------------o
//| File - CResponse.cpp
//| Date - 11/15/2003
//o-----------------------------------------------------------------------------------------------o
//| Changes - Version History
//|
//| 1.0 15th November, 2003
//| Initial implementation. Ripped out 99% of cSpeech::response
//| and relocated contents here in individual handler classes
//|
//| 1.1 16th November, 2003
//| Changed CBaseResponse::Handle() overload to WhichResponse(), and
//| locally declared it wherever it was used, also handles different
//| languages in WhichResponse() now.
//| Added an inline findString() helper function to clean up WhichResponse().
//| Now houses our vendor responses (enabling us to completely remove
//| checkForVendorResponse() and responsevendor().
//| Also handles all currently supported house speech using a single
//| class, enabling the removal of HouseSpeech().
//|
//| 1.2 17th November, 2003
//| We now make use of OSI's trigger words (the few that we actually handle,
//| currently), to remove the need to search through the text string
//o-----------------------------------------------------------------------------------------------o
#include "uox3.h"
#include "CResponse.h"
#include "regions.h"
#include "msgboard.h"
#include "townregion.h"
#include "classes.h"
#include "cEffects.h"
#include "Dictionary.h"
#include "CPacketSend.h"
#include "CJSMapping.h"
#include "cScript.h"
#include "regions.h"
#include "cGuild.h"
#include "skills.h"
#include "StringUtility.hpp"
#include <algorithm>
#include <cctype>
bool BuyShop( CSocket *s, CChar *c );
void callGuards( CChar *mChar );
inline bool findString( std::string toCheck, std::string toFind )
{
return ( toCheck.find( toFind ) != std::string::npos );
}
//o-----------------------------------------------------------------------------------------------o
//| Function - auto findNearbyNPCs( CChar *mChar, distLocs distance ) ->std::vector< CChar* >
//o-----------------------------------------------------------------------------------------------o
//| Purpose - Returns a list of NPCs that are within a certain distance
//o-----------------------------------------------------------------------------------------------o
auto findNearbyNPCs( CChar *mChar, distLocs distance ) ->std::vector< CChar* >{
std::vector< CChar* > ourNpcs;
for (auto &CellResponse : MapRegion->PopulateList( mChar )){
if( CellResponse){
auto regChars = CellResponse->GetCharList();
for (auto &Npc:regChars->collection()){
if (ValidateObject(Npc) && (Npc != mChar) && Npc->IsNpc() && (Npc->GetInstanceID() == mChar->GetInstanceID())){
if( objInRange( mChar, Npc, distance ) ){
ourNpcs.push_back( Npc );
}
}
}
}
}
return ourNpcs;
}
auto findNearbyItems( CBaseObject *mObj, distLocs distance ) ->std::vector< CItem* >;
//o-----------------------------------------------------------------------------------------------o
//| Function - UI08 DoJSResponse( CSocket *mSock, CChar *mChar, const std::string& text )
//o-----------------------------------------------------------------------------------------------o
//| Purpose - Checks if nearby NPCs run scripts that react to speech
//o-----------------------------------------------------------------------------------------------o
UI08 DoJSResponse( CSocket *mSock, CChar *mChar, const std::string& text )
{
for (auto &Npc:findNearbyNPCs( mChar, DIST_CMDRANGE )){
if( ValidateObject(Npc ) ){
if( std::abs( mChar->GetZ() - Npc->GetZ() ) <= 9 )
{
std::vector<UI16> scriptTriggers = Npc->GetScriptTriggers();
for( auto i : scriptTriggers )
{
cScript *toExecute = JSMapping->GetScript( i );
if( toExecute != nullptr )
{
//| -1 => No such function or bad call
//| 0 => Let other NPCs and PCs see it
//| 1 => Let other PCs see it
//| 2 => Let no one else see it
SI08 rVal = -1;
if( Npc->isDisabled() )
Npc->TextMessage( nullptr, 1291, TALK, false );
else
rVal = toExecute->OnSpeech( text.c_str(), mChar, Npc );
switch( rVal )
{
case 1: // No other NPCs to see it, but PCs should
return 1;
case 2: // no one else to see it
return 2;
case 0: // Other NPCs and PCs to see it
case -1: // no function, so do nothing... NOT handled!
default:
break;
}
}
}
}
}
}
// How about items?
if( cwmWorldState->ServerData()->ItemsDetectSpeech() )
{
for (auto &Item : findNearbyItems(mChar, DIST_CMDRANGE)) {
if( ValidateObject( Item ) ){
if( std::abs( mChar->GetZ() - Item->GetZ() ) <= 9 )
{
std::vector<UI16> scriptTriggers = Item->GetScriptTriggers();
for( auto i : scriptTriggers )
{
cScript *toExecute = JSMapping->GetScript( i );
if( toExecute != nullptr )
{
SI08 rVal = -1;
if( Item->isDisabled() )
Item->TextMessage( nullptr, 1291, TALK, false );
else
rVal = toExecute->OnSpeech( text.c_str(), mChar, Item );
switch( rVal )
{
case 1: // No other NPCs to see it, but PCs should
return 1;
case 2: // no one else to see it
return 2;
case 0: // Other NPCs and PCs to see it
case -1: // no function, so do nothing... NOT handled!
default:
break;
}
}
}
}
}
}
}
return 0;
}
//o-----------------------------------------------------------------------------------------------o
//| Function - bool WhichResponse( CSocket *mSock, CChar *mChar, std::string text )
//o-----------------------------------------------------------------------------------------------o
//| Purpose - Handle responses to keywords in player speech
//o-----------------------------------------------------------------------------------------------o
bool WhichResponse( CSocket *mSock, CChar *mChar, std::string text, CChar *tChar = nullptr )
{
UI08 jsResponse = DoJSResponse( mSock, mChar, text );
if( jsResponse == 1 )
return true;
else if( jsResponse == 2 )
return false;
CBaseResponse *tResp = nullptr;
for( UI16 trigWord = mSock->FirstTrigWord(); !mSock->FinishedTrigWords(); trigWord = mSock->NextTrigWord() )
{
switch( trigWord )
{
case TW_COUNT: break;
case TW_GUARDS: callGuards( mChar ); break;
case TW_KILLS: tResp = new CKillsResponse(); break;
case TW_QUESTTAKE: tResp = new CEscortResponse(); break;
case TW_QUESTDEST: tResp = new CEscortResponse( true ); break;
case TW_TRAIN: tResp = new CTrainingResponse( trigWord, tChar ); break;
case TW_FOLLOW:
case TW_FOLLOW2: tResp = new CPetMultiResponse( oldstrutil::upper( text ), false, TARGET_FOLLOW, 1310, false, true ); break;
case TW_COME:
case TW_FOLLOWME: tResp = new CPetComeResponse( false, oldstrutil::upper( text ) ); break;
case TW_ALLFOLLOWME:
case TW_ALLCOME: tResp = new CPetComeResponse( true, oldstrutil::upper( text ) ); break;
case TW_ALLFOLLOW: tResp = new CPetMultiResponse( oldstrutil::upper( text ), false, TARGET_FOLLOW, 1310, true, true ); break;
case TW_KILL:
case TW_ATTACK: tResp = new CPetAttackResponse( false, oldstrutil::upper( text ) ); break;
case TW_ALLKILL:
case TW_ALLATTACK:
/*{
tResp = new CPetAttackResponse( true, oldstrutil::upper( text ) );
tResp->Handle( mSock, mChar );
delete tResp;
tResp = nullptr;
goto endResponseCheck;
}*/
tResp = new CPetAttackResponse( true, oldstrutil::upper( text ) ); break;
case TW_FETCH:
case TW_GET:
case TW_BRING: tResp = new CPetMultiResponse( oldstrutil::upper( text ), false, TARGET_GUARD, 1316, false, true ); break;
case TW_FRIEND: tResp = new CPetMultiResponse( oldstrutil::upper( text ), true, TARGET_FRIEND, 1620, false, true ); break;
case TW_GUARD: tResp = new CPetMultiResponse( oldstrutil::upper( text ), false, TARGET_GUARD, 1104, false, true ); break;
case TW_ALLGUARD:
case TW_ALLGUARDME: tResp = new CPetGuardResponse( true, oldstrutil::upper( text ) ); break;
case TW_STOP:
case TW_STAY: tResp = new CPetStayResponse( false, oldstrutil::upper( text ) ); break;
case TW_ALLSTOP:
case TW_ALLSTAY: tResp = new CPetStayResponse( true, oldstrutil::upper( text ) ); break;
case TW_TRANSFER: tResp = new CPetMultiResponse( oldstrutil::upper( text ), true, TARGET_TRANSFER, 1323, false, false ); break;
case TW_RELEASE: tResp = new CPetReleaseResponse( oldstrutil::upper( text ) ); break;
case TW_VENDORBUY: tResp = new CVendorBuyResponse( true, oldstrutil::upper( text ) ); break;
case TW_BUY: tResp = new CVendorBuyResponse( false, oldstrutil::upper( text ) ); break;
case TW_VENDORSELL: tResp = new CVendorSellResponse( true, oldstrutil::upper( text ) ); break;
case TW_SELL: tResp = new CVendorSellResponse( false, oldstrutil::upper( text ) ); break;
case TW_VENDORVIEW: tResp = new CVendorViewResponse( true, oldstrutil::upper( text ) ); break;
case TW_VIEW: tResp = new CVendorViewResponse( false, oldstrutil::upper( text ) ); break;
case TW_VENDORGOLD: tResp = new CVendorGoldResponse( true, oldstrutil::upper( text ) ); break;
case TW_COLLECT:
case TW_GOLD: tResp = new CVendorGoldResponse( false, oldstrutil::upper( text ) ); break;
case TW_VENDORSTATUS: tResp = new CVendorStatusResponse( true, oldstrutil::upper( text ) ); break;
case TW_STATUS: tResp = new CVendorStatusResponse( false, oldstrutil::upper( text ) ); break;
case TW_VENDORDISMISS: tResp = new CVendorDismissResponse( true, oldstrutil::upper( text ) ); break;
case TW_DISMISS: tResp = new CVendorDismissResponse( false, oldstrutil::upper( text )); break;
case TW_HOUSEBAN: tResp = new CHouseMultiResponse( TARGET_HOUSEBAN, 585 ); break;
case TW_HOUSEEJECT: tResp = new CHouseMultiResponse( TARGET_HOUSEEJECT, 587 ); break;
case TW_HOUSELOCKDOWN: tResp = new CHouseMultiResponse( TARGET_HOUSELOCKDOWN, 589 ); break;
case TW_HOUSERELEASE: tResp = new CHouseMultiResponse( TARGET_HOUSERELEASE, 591 ); break;
case TW_HOUSESECURE: tResp = new CHouseMultiResponse( TARGET_HOUSESECURE, 1816 ); break;
case TW_HOUSESTRONGBOX:
{
// Special case because the phrase "I wish to place a strongbox" will also trigger
// the triggerword for placing a trash barrel!
tResp = new CHouseMultiResponse( TARGET_HOUSESTRONGBOX, -1 );
tResp->Handle( mSock, mChar );
delete tResp;
tResp = nullptr;
goto endResponseCheck; // :
}
case TW_TRASHBARREL: tResp = new CHouseMultiResponse( TARGET_HOUSETRASHBARREL, -1 ); break;
case TW_BOATFORWARD:
case TW_BOATUNFURL: tResp = new CBoatMultiResponse( BOAT_FORWARD ); break;
case TW_BOATBACKWARD: tResp = new CBoatMultiResponse( BOAT_BACKWARD ); break;
case TW_BOATLEFT: tResp = new CBoatMultiResponse( BOAT_LEFT ); break;
case TW_BOATRIGHT: tResp = new CBoatMultiResponse( BOAT_RIGHT ); break;
case TW_BOATFORWARDLEFT: tResp = new CBoatMultiResponse( BOAT_FORWARDLEFT ); break;
case TW_BOATFORWARDRIGHT: tResp = new CBoatMultiResponse( BOAT_FORWARDRIGHT ); break;
case TW_BOATBACKLEFT: tResp = new CBoatMultiResponse( BOAT_BACKWARDLEFT ); break;
case TW_BOATBACKRIGHT: tResp = new CBoatMultiResponse( BOAT_BACKWARDRIGHT ); break;
case TW_BOATONEFORWARD: tResp = new CBoatMultiResponse( BOAT_ONEFORWARD ); break;
case TW_BOATONEBACK: tResp = new CBoatMultiResponse( BOAT_ONEBACKWARD ); break;
case TW_BOATONELEFT: tResp = new CBoatMultiResponse( BOAT_ONELEFT ); break;
case TW_BOATONERIGHT: tResp = new CBoatMultiResponse( BOAT_ONERIGHT ); break;
case TW_BOATONEFORWARDLEFT: tResp = new CBoatMultiResponse( BOAT_ONEFORWARDLEFT ); break;
case TW_BOATONEFORWARDRIGHT:tResp = new CBoatMultiResponse( BOAT_ONEFORWARDRIGHT ); break;
case TW_BOATONEBACKLEFT: tResp = new CBoatMultiResponse( BOAT_ONEBACKWARDLEFT ); break;
case TW_BOATONEBACKRIGHT: tResp = new CBoatMultiResponse( BOAT_ONEBACKWARDRIGHT ); break;
case TW_BOATSLOWFORWARD: tResp = new CBoatMultiResponse( BOAT_SLOWFORWARD ); break;
case TW_BOATSLOWBACK: tResp = new CBoatMultiResponse( BOAT_SLOWBACKWARD ); break;
case TW_BOATSLOWLEFT: tResp = new CBoatMultiResponse( BOAT_SLOWLEFT ); break;
case TW_BOATSLOWRIGHT: tResp = new CBoatMultiResponse( BOAT_SLOWRIGHT ); break;
case TW_BOATSLOWFORWARDLEFT: tResp = new CBoatMultiResponse( BOAT_SLOWFORWARDLEFT ); break;
case TW_BOATSLOWFORWARDRIGHT: tResp = new CBoatMultiResponse( BOAT_SLOWFORWARDRIGHT ); break;
case TW_BOATSLOWBACKLEFT: tResp = new CBoatMultiResponse( BOAT_SLOWBACKWARDLEFT ); break;
case TW_BOATSLOWBACKRIGHT: tResp = new CBoatMultiResponse( BOAT_SLOWBACKWARDRIGHT ); break;
case TW_BOATSTOP:
case TW_STOP2:
case TW_BOATFURL: //tResp = new CBoatMultiResponse( BOAT_STOP ); break;
{
tResp = new CBoatMultiResponse( BOAT_STOP );
tResp->Handle( mSock, mChar );
delete tResp;
tResp = nullptr;
goto endResponseCheck; // :
}
case TW_BOATTURNRIGHT:
case TW_BOATSTARBOARD:
case TW_BOATTURNLEFT:
case TW_BOATPORT:
case TW_BOATTURNAROUND:
case TW_BOATANCHORDROP:
case TW_BOATANCHORRAISE:
case TW_SETNAME: tResp = new CBoatResponse( text, trigWord ); break;
case TW_RESIGN: GuildSys->Resign( mSock ); break;
default:
//This is to handle the "train <skill>" keywords
if(( trigWord >= 0x006D && trigWord <= 0x009C ) || trigWord == 0x154 || trigWord == 0x115 ||
trigWord == 0x17C || trigWord == 0x17D || trigWord == 0x17E )
{
tResp = new CTrainingResponse( trigWord, tChar );
tResp->Handle( mSock, mChar );
delete tResp;
tResp = nullptr;
goto endResponseCheck; // :
break;
}
#if defined( UOX_DEBUG_MODE )
Console.print( oldstrutil::format("Unhandled trigger [%s] sent by the client 0x%X\n", text.c_str(),trigWord) );
#endif
break;
}
if( tResp != nullptr )
{
tResp->Handle( mSock, mChar );
delete tResp;
tResp = nullptr;
}
}
endResponseCheck:
return true;
}
CEscortResponse::CEscortResponse( bool newVal )
{
findDest = newVal;
}
//o-----------------------------------------------------------------------------------------------o
//| Function - void CEscortResponse::Handle( CSocket *mSock, CChar *mChar )
//o-----------------------------------------------------------------------------------------------o
//| Purpose - Handles NPC escort response to player wanting to take on the escorting job
//o-----------------------------------------------------------------------------------------------o
void CEscortResponse::Handle( CSocket *mSock, CChar *mChar )
{
// If the PC is dead then break out, The dead cannot accept quests
if( mChar->IsDead() )
return;
for (auto &Npc : findNearbyNPCs(mChar, DIST_NEARBY)) {
if( Npc->GetQuestType() == QT_ESCORTQUEST )
{
// I WILL TAKE THEE
// If this is a request for hire and the PC is within range of the NPC and the NPC is waiting for an ESCORT
if( !findDest )
{
if( !ValidateObject( Npc->GetFTarg() ) )
{
Npc->SetOwner( mChar );
Npc->SetFTarg( mChar ); // Set the NPC to follow the PC
Npc->SetNpcWander( WT_FOLLOW );
Npc->SetTimer( tNPC_SUMMONTIME, cwmWorldState->ServerData()->BuildSystemTimeValue( tSERVER_ESCORTACTIVE ) ); // Set the expire time if nobody excepts the quest
// Send out the rant about accepting the escort
Npc->TextMessage( nullptr, 1294, TALK, 0, cwmWorldState->townRegions[Npc->GetQuestDestRegion()]->GetName().c_str() );
// Remove post from message board (Mark for deletion only - will be cleaned during cleanup)
MsgBoardQuestEscortRemovePost( Npc );
// Return 1 so that we indicate that we handled the message
return;
}
else
findDest = true; // If the current NPC already has an ftarg then respond to query for quest
}
// DESTINATION
// If this is a request to find out where a NPC wants to go and the PC is within range of the NPC and the NPC is waiting for an ESCORT
if( findDest )
{
if( Npc->GetFTarg() == mChar )
Npc->TextMessage( nullptr, 1295, TALK, 0, cwmWorldState->townRegions[Npc->GetQuestDestRegion()]->GetName().c_str() ); // Send out the rant about accepting the escort
else if( !ValidateObject( Npc->GetFTarg() ) ) // If nobody has been accepted for the quest yet
Npc->TextMessage( nullptr, 1296, TALK, 0, cwmWorldState->townRegions[Npc->GetQuestDestRegion()]->GetName().c_str() ); // Send out the rant about accepting the escort
else // The must be enroute
Npc->TextMessage( nullptr, 1297, TALK, 0, cwmWorldState->townRegions[Npc->GetQuestDestRegion()]->GetName().c_str(), Npc->GetFTarg()->GetNameRequest( mChar ).c_str() ); // Send out a message saying we are already being escorted
// Return success ( we handled the message )
return;
}
}
}
}
CKillsResponse::CKillsResponse( void )
{
}
//o-----------------------------------------------------------------------------------------------o
//| Function - void CKillsResponse::Handle( CSocket *mSock, CChar *mChar )
//o-----------------------------------------------------------------------------------------------o
//| Purpose - Handles response to players wanting to see the status of their kills
//o-----------------------------------------------------------------------------------------------o
void CKillsResponse::Handle( CSocket *mSock, CChar *mChar )
{
if( !mChar->IsDead() && mSock != nullptr )
{
SI16 i = mChar->GetKills();
if( i == 0 )
mSock->sysmessage( 1288 );
else if( i > cwmWorldState->ServerData()->RepMaxKills() )
mSock->sysmessage( 1289, i );
else
mSock->sysmessage( 1290, i );
}
}
CTrainingResponse::CTrainingResponse( UI16 trigWord, CChar *tChar )
{
trigChar = tChar;
ourTrigWord = trigWord;
}
//o-----------------------------------------------------------------------------------------------o
//| Function - void CTrainingResponse::Handle( CSocket *mSock, CChar *mChar )
//o-----------------------------------------------------------------------------------------------o
//| Purpose - Handles response to players wanting to train skills from NPCs
//o-----------------------------------------------------------------------------------------------o
void CTrainingResponse::Handle( CSocket *mSock, CChar *mChar )
{
if( cwmWorldState->ServerData()->NPCTrainingStatus() ) //if the player wants to train
{
constexpr auto maxsize = 512;
std::string temp;
std::string temp2;
// Shuffle the npcList so it doesn't always trigger for the first NPC in the list
std::random_device rd;
std::mt19937 g( rd() );
auto npcList = findNearbyNPCs( mChar, DIST_INRANGE );
std::shuffle( npcList.begin(), npcList.end(), g );
auto skillName = std::string("");
for (auto Npc : npcList){
if( ValidateObject( trigChar ) )
{
Npc = trigChar;
}
if( cwmWorldState->creatures[Npc->GetID()].IsHuman() )
{
// Stop the NPC from moving for a minute while talking with the player
Npc->SetTimer( tNPC_MOVETIME, BuildTimeValue( 60 ) );
mSock->TempObj( nullptr ); //this is to prevent errors when a player says "train <skill>" then doesn't pay the npc
SI16 skill = -1;
// Language independent implementation of training keywords
switch( ourTrigWord )
{
case 340: // anatomy
skill = ANATOMY; break;
case 109: // parrying, parry, battle, defense
skill = PARRYING; break;
case 110: // first, aid, heal, healing, medicine
skill = HEALING; break;
case 111: // hide, hiding
skill = HIDING; break;
case 112: // steal, stealing
skill = STEALING; break;
case 113: // alchemy
skill = ALCHEMY; break;
case 114: // animal, animal lore
skill = ANIMALLORE; break;
case 115: // appraising, identifying, appraise, item, identification, identify
skill = ITEMID; break;
case 116: // armslore, arms
skill = ARMSLORE; break;
case 117: // beg, begging
skill = BEGGING; break;
case 118: // blacksmith, smith, blacksmithy, smithing, blacksmithing
skill = BLACKSMITHING; break;
case 119: // bower, bow, arrow, fletcher, bowcraft, fletching
skill = BOWCRAFT; break;
case 120: // calm, peace, peacemaking
skill = PEACEMAKING; break;
case 121: // camp, camping
skill = CAMPING; break;
case 122: // carpentry, woodwork, woodworking
skill = CARPENTRY; break;
case 123: // cartography, map, mapmaking
skill = CARTOGRAPHY; break;
case 124: // cooking, cook
skill = COOKING; break;
case 125: // detect, detect hidden, hidden
skill = DETECTINGHIDDEN; break;
case 126: // entice, enticement, enticing
skill = ENTICEMENT; break;
case 127: // evaluate, intelligence, evaluating
skill = EVALUATINGINTEL; break;
case 128: // fish, fishing
skill = FISHING; break;
case 129: // incite, provoke, provoking, provocation
skill = PROVOCATION; break;
case 130: // lockpicking, lock, pick, picking, locks
skill = LOCKPICKING; break;
case 131: // magic, magery, sorcery, wizardry, mage, wizard
skill = MAGERY; break;
case 132: // resist, resisting, spells
skill = MAGICRESISTANCE; break;
case 133: // battle, tactic, tactics, fight, fighting
skill = TACTICS; break;
case 134: // peek, peeking, snoop, snooping
skill = SNOOPING; break;
case 135: // disarm, disarming, remove, removing
skill = REMOVETRAP; break;
case 136: // play, instrument, playing, music, musician, musicianship
skill = MUSICIANSHIP; break;
case 137: // poisoning, poison
skill = POISONING; break;
case 138: // ranged, missile, missiles, shoot, shooting, archery, archer
skill = ARCHERY; break;
case 139: // spirit, ghost, seance, spiritualism
skill = SPIRITSPEAK; break;
case 140: // tailoring, tailor, clothier
skill = TAILORING; break;
case 141: // tame, taming
skill = TAMING; break;
case 142: // taste, tasting
skill = TASTEID; break;
case 143: // tinker, tinkering
skill = TINKERING; break;
case 144: // vet, veterinarian, veterinary
skill = VETERINARY; break;
case 145: // forensic, forensics
skill = FORENSICS; break;
case 146: // herd, herding
skill = HERDING; break;
case 147: // tracking, track, hunt, hunting
skill = TRACKING; break;
case 148: // stealth
skill = STEALTH; break;
case 149: // inscribe, scroll, inscribing, inscription
skill = INSCRIPTION; break;
case 150: // sword, swords, blade, blades, swordsman, swordsmanship
skill = SWORDSMANSHIP; break;
case 151: // club, clubs, mace, maces
skill = MACEFIGHTING; break;
case 152: // dagger, daggers, fence, fencing, spear
skill = FENCING; break;
case 153: // hand, wrestle, wrestling
skill = WRESTLING; break;
case 154: // lumberjack, lumberjacking, woodcuttingl
skill = LUMBERJACKING; break;
case 155: // mining, mine, smelt
skill = MINING; break;
case 156: // meditate
skill = MEDITATION; break;
case 380: // necromancy
skill = NECROMANCY; break;
case 381: // chivalry
skill = CHIVALRY; break;
case 382: // focus
skill = FOCUS; break;
default:
break;
}
if( skill == -1 ) // Didn't ask to be trained in a specific skill - Leviathan fix
{
if( !Npc->CanTrain() )
{
Npc->TextMessage( mSock, 1302, TALK, false ); // I am sorry, but I have nothing to teach thee.
continue;
}
Npc->SetTrainingPlayerIn( 255 ); // Like above, this is to prevent errors when a player says "train <skill>" then doesn't pay the npc
temp = Dictionary->GetEntry( 1303 ); // I can teach thee the following skills:
UI08 skillsToTrainIn = 0;
UI08 lastCommaPos = 0;
for( UI08 j = 0; j < ALLSKILLS; ++j )
{
if( Npc->GetBaseSkill( j ) > 10 )
{
temp2= oldstrutil::lower(cwmWorldState->skill[j].name);
if( !skillsToTrainIn ) {
temp2[0] = std::toupper( temp2[0] ); // If it's the first skill, capitalize it, and add a space in front.
temp += (" " + temp2);
}
else if( skillsToTrainIn <= 10 )
{
// Additional skills
lastCommaPos = static_cast<UI08>(temp.size()) + 1;
temp += (", " + temp2);
}
else if( skillsToTrainIn > 10 ) // to stop UOX3 from crashing/sentence being cut off if NPC is too knowledgable!
{
temp += std::string(" and possibly more");
break;
}
++skillsToTrainIn;
}
}
if( skillsToTrainIn <= 10 )
{
// Replace last comma with " and "
temp.replace( lastCommaPos, 1, " and " );
}
if( skillsToTrainIn )
{
temp += '.'; // Make last character a . just to look nicer
Npc->TextMessage( mSock, temp, TALK, false );
}
else
Npc->TextMessage( mSock, 1302, TALK, false ); // I am sorry, but I have nothing to teach thee.
}
else // They do want to learn a specific skill
{
if( !Npc->CanTrain() )
{
Npc->TextMessage( mSock, 1302, TALK, false ); // I am sorry, but I have nothing to teach thee.
continue;
}
if( Npc->GetBaseSkill( static_cast<UI08>( skill )) > 10 )
{
temp = oldstrutil::format(maxsize, Dictionary->GetEntry( 1304 ), oldstrutil::lower(cwmWorldState->skill[skill].name ).c_str() ); // Thou wishest to learn of %s?
if( mChar->GetBaseSkill( static_cast<UI08>( skill )) >= 250 )
{
temp += Dictionary->GetEntry( 1305 ); // I can teach thee no more than thou already knowest!
}
else
{
if( Npc->GetBaseSkill( static_cast<UI08>( skill) ) <= 250 )
{
// Very well I, can train thee up to the level of %i percent for %i gold. Pay for less and I shall teach thee less.
temp2=oldstrutil::format(maxsize, Dictionary->GetEntry( 1306 ),(SI32)( Npc->GetBaseSkill( (UI08)skill ) / 2 / 10 ),(SI32)( Npc->GetBaseSkill( (UI08)skill ) / 2 ) - mChar->GetBaseSkill( (UI08)skill ) );
}
else
{
// Very well I, can train thee up to the level of %i percent for %i gold. Pay for less and I shall teach thee less.
temp2 = oldstrutil::format(maxsize, Dictionary->GetEntry( 1306 ), 25, 250 - mChar->GetBaseSkill( (UI08)skill ) );
}
temp += " " + temp2 ;
mSock->TempObj( Npc );
Npc->SetTrainingPlayerIn( static_cast<UI08>(skill) );
}
Npc->TextMessage( mSock, temp, TALK, false );
}
else
Npc->TextMessage( mSock, 1307, TALK, false ); // I am sorry but I cannot train thee in that skill.
}
break;
}
}
}
}
CBasePetResponse::CBasePetResponse( const std::string &text )
{
ourText = text;
}
//o-----------------------------------------------------------------------------------------------o
//| Function - void CBasePetResponse::Handle( CSocket *mSock, CChar *mChar )
//o-----------------------------------------------------------------------------------------------o
//| Purpose - Handles response to players wanting to execute pet commands
//o-----------------------------------------------------------------------------------------------o
void CBasePetResponse::Handle( CSocket *mSock, CChar *mChar )
{
TAGMAPOBJECT petTagObj = mChar->GetTag( "petTagObjSerial" );
CChar *petCommandObj = calcCharObjFromSer( petTagObj.m_IntValue );
if( ValidateObject( petCommandObj ) )
{
petTagObj.m_Destroy = true;
petTagObj.m_IntValue = 0;
mChar->SetTag( "petCommandObj", petTagObj );
Handle( mSock, mChar, petCommandObj );
}
else
{
for (auto &Npc :findNearbyNPCs( mChar, DIST_CMDRANGE ) ){
if( !Handle( mSock, mChar, Npc ) )
break;
}
}
}
CPetMultiResponse::CPetMultiResponse( const std::string &text, bool restrictVal, TargetIDs targVal, SI32 dictVal, bool saidAll, bool checkControlDifficulty ) : CBasePetResponse( text )
{
isRestricted = restrictVal;
targID = targVal;
dictEntry = dictVal;
allSaid = saidAll;
checkDifficulty = checkControlDifficulty;
}
bool CPetMultiResponse::Handle( CSocket *mSock, CChar *mChar, CChar *Npc )
{
if( allSaid )
{
for (auto &Npc: findNearbyNPCs( mChar, DIST_CMDRANGE )){
if( ValidateObject( Npc ) && Npc->GetOwnerObj() == mChar )
{
if( Npcs->canControlPet( mChar, Npc, isRestricted, checkDifficulty ))
{
UI08 cursorType = 0;
if( targID == 25 ) // Guard
cursorType = 2; // helpful
mSock->TempObj( Npc );
mSock->TempInt( 1 );
mSock->target( 0, targID, cursorType, dictEntry );
return false;
}
}
}
}
else
{
std::string npcName = Npc->GetNameRequest( mChar );
if( npcName == "#" )
{
// If character name is #, use default name from dictionary files instead - using base entry 3000 + character's ID
npcName = Dictionary->GetEntry( 3000 + Npc->GetID() );
}
if( findString( ourText, oldstrutil::upper( npcName )))
{
if( Npcs->canControlPet( mChar, Npc, isRestricted, checkDifficulty ) )
{
mSock->TempObj( Npc );
UI08 cursorType = 0;
if( targID == 25 ) // Guard
cursorType = 2; // helpful
mSock->target( 0, targID, cursorType, dictEntry );
return false;
}
}
}
return true;
}
CPetReleaseResponse::CPetReleaseResponse( const std::string &text ) : CBasePetResponse( text )
{
}
//o-----------------------------------------------------------------------------------------------o
//| Function - bool CPetReleaseResponse::Handle( CSocket *mSock, CChar *mChar, CChar *Npc )
//o-----------------------------------------------------------------------------------------------o
//| Purpose - Handles response to players wanting to release pets
//o-----------------------------------------------------------------------------------------------o
bool CPetReleaseResponse::Handle( CSocket *mSock, CChar *mChar, CChar *Npc )
{
std::string npcName = getNpcDictName( Npc, mSock );
if( findString( ourText, oldstrutil::upper( npcName )))
{
if( Npcs->canControlPet( mChar, Npc, true, false ))
{
// Reduce player's control slot usage by the amount of control slots taken up by the pet
mChar->SetControlSlotsUsed( std::max(0, mChar->GetControlSlotsUsed() - Npc->GetControlSlots()));
// Release the pet
Npcs->releasePet( Npc );
return false;
}
}
return true;
}
CPetAllResponse::CPetAllResponse( bool allVal, const std::string &text ) : CBasePetResponse( text )
{
saidAll = allVal;
}
CPetGuardResponse::CPetGuardResponse( bool allVal, const std::string &text ) : CPetAllResponse( allVal, text )
{
}
//o-----------------------------------------------------------------------------------------------o
//| Function - bool CPetGuardResponse::Handle( CSocket *mSock, CChar *mChar, CChar *Npc )
//o-----------------------------------------------------------------------------------------------o
//| Purpose - Handles response to players wanting their pets to guard an object
//o-----------------------------------------------------------------------------------------------o
bool CPetGuardResponse::Handle( CSocket *mSock, CChar *mChar, CChar *Npc )
{
std::string npcName = getNpcDictName( Npc, mSock );
if( saidAll || findString( ourText, oldstrutil::upper( npcName )))
{
if( Npcs->canControlPet( mChar, Npc, false, true ))
{
Npcs->stopPetGuarding( Npc );
mSock->sysmessage( 1321 ); // Your pet is now guarding you.
Npc->SetNPCAiType( AI_PET_GUARD );
Npc->SetGuarding( mChar );
mChar->SetGuarded( true );
Npc->SetFTarg( mChar );
Npc->SetNpcWander( WT_FOLLOW );
if( !saidAll )
return false;
}
}
return true;
}
CPetAttackResponse::CPetAttackResponse( bool allVal, const std::string &text ) : CPetAllResponse( allVal, text )
{
}
//o-----------------------------------------------------------------------------------------------o
//| Function - bool CPetAttackResponse::Handle( CSocket *mSock, CChar *mChar, CChar *Npc )
//o-----------------------------------------------------------------------------------------------o
//| Purpose - Handles response to players wanting their pets to attack something
//o-----------------------------------------------------------------------------------------------o
bool CPetAttackResponse::Handle( CSocket *mSock, CChar *mChar, CChar *Npc )
{
std::string npcName = getNpcDictName( Npc, mSock );
if( saidAll || findString( ourText, oldstrutil::upper( npcName )))
{
if( Npcs->canControlPet( mChar, Npc, false, true ))
{
Npcs->stopPetGuarding( Npc );
mSock->TempObj( Npc );
if( saidAll )
mSock->TempInt( 1 );
mSock->target( 0, TARGET_ATTACK, 1, 1313 );
//if( !saidAll )
return false;
}
}
return true;
}
CPetComeResponse::CPetComeResponse( bool allVal, const std::string &text ) : CPetAllResponse( allVal, text )
{
}
//o-----------------------------------------------------------------------------------------------o
//| Function - bool CPetComeResponse::Handle( CSocket *mSock, CChar *mChar, CChar *Npc )
//o-----------------------------------------------------------------------------------------------o
//| Purpose - Handles response to players wanting their pets to follow
//o-----------------------------------------------------------------------------------------------o
bool CPetComeResponse::Handle( CSocket *mSock, CChar *mChar, CChar *Npc )
{
std::string npcName = getNpcDictName( Npc, mSock );
if( saidAll || findString( ourText, oldstrutil::upper( npcName )))
{
if( Npcs->canControlPet( mChar, Npc, false, true ))
{
Npcs->stopPetGuarding( Npc );
Npc->SetFTarg( mChar );
Npc->SetNpcWander( WT_FOLLOW );
mSock->sysmessage( 1318 );
if( !saidAll )
return false;
}
}
return true;
}
CPetStayResponse::CPetStayResponse( bool allVal, const std::string &text ) : CPetAllResponse( allVal, text )
{
}
//o-----------------------------------------------------------------------------------------------o
//| Function - bool CPetStayResponse::Handle( CSocket *mSock, CChar *mChar, CChar *Npc )
//o-----------------------------------------------------------------------------------------------o
//| Purpose - Handles response to players wanting their pets to stay
//o-----------------------------------------------------------------------------------------------o
bool CPetStayResponse::Handle( CSocket *mSock, CChar *mChar, CChar *Npc )
{
std::string npcName = getNpcDictName( Npc, mSock );
if( saidAll || findString( ourText, oldstrutil::upper( npcName )))
{
if( Npcs->canControlPet( mChar, Npc, false, true ))
{
Npcs->stopPetGuarding( Npc );
Npc->SetFTarg( nullptr );
Npc->SetTarg( nullptr );
Npc->SetAttacker( nullptr );
if( Npc->IsAtWar() )
Npc->ToggleCombat();
Npc->SetOldNpcWander( WT_NONE );
Npc->SetNpcWander( WT_NONE );
if( mSock != nullptr )
{
mSock->sysmessage( 2413, npcName.c_str() ); // %s stays put.
}
if( !saidAll )
return false;
}
}
return true;
}
CBaseVendorResponse::CBaseVendorResponse( bool vendVal, const std::string &text )
{
saidVendor = vendVal;
ourText = text;
}
//o-----------------------------------------------------------------------------------------------o
//| Function - void CBaseVendorResponse::Handle( CSocket *mSock, CChar *mChar )
//o-----------------------------------------------------------------------------------------------o
//| Purpose - Handles response to players wanting to interact with a vendor
//o-----------------------------------------------------------------------------------------------o
void CBaseVendorResponse::Handle( CSocket *mSock, CChar *mChar )
{
for (auto &Npc: findNearbyNPCs( mChar, DIST_INRANGE )){
if( Npc->IsShop() || Npc->GetNPCAiType() == AI_PLAYERVENDOR )
{
if( !LineOfSight( mSock, mChar, Npc->GetX(), Npc->GetY(), ( Npc->GetZ() + 15 ), WALLS_CHIMNEYS + DOORS + FLOORS_FLAT_ROOFING, false ) )
continue;
std::string npcName = getNpcDictName( Npc, mSock );
if( saidVendor || findString( ourText,oldstrutil::upper( npcName )))
{
if( !Handle( mSock, mChar, Npc ) )
break;
}
}
}
}
CVendorBuyResponse::CVendorBuyResponse( bool vendVal, const std::string &text ) : CBaseVendorResponse( vendVal, text )
{
}
//o-----------------------------------------------------------------------------------------------o
//| Function - bool CVendorBuyResponse::Handle( CSocket *mSock, CChar *mChar, CChar *Npc )
//o-----------------------------------------------------------------------------------------------o
//| Purpose - Handles response to players wanting to buy something from a vendor
//o-----------------------------------------------------------------------------------------------o
bool CVendorBuyResponse::Handle( CSocket *mSock, CChar *mChar, CChar *Npc )
{
Npc->SetTimer( tNPC_MOVETIME, BuildTimeValue( 60 ) );
if( Npc->GetNPCAiType() == AI_PLAYERVENDOR )
{
mSock->TempObj( Npc );
Npc->TextMessage( mSock, 1333, TALK, false );
mSock->target( 0, TARGET_PLVBUY, " " );
return false;
}
else if( BuyShop( mSock, Npc ) )
return false;
return true;
}
CVendorSellResponse::CVendorSellResponse( bool vendVal, const std::string &text ) : CBaseVendorResponse( vendVal, text )
{
}
//o-----------------------------------------------------------------------------------------------o
//| Function - bool CVendorSellResponse::Handle( CSocket *mSock, CChar *mChar, CChar *Npc )
//o-----------------------------------------------------------------------------------------------o
//| Purpose - Handles response to players wanting to sell something to a vendor
//o-----------------------------------------------------------------------------------------------o
bool CVendorSellResponse::Handle( CSocket *mSock, CChar *mChar, CChar *Npc )
{
//Check if vendor has onSell script running
std::vector<UI16> scriptTriggers = Npc->GetScriptTriggers();
for( auto scriptTrig : scriptTriggers )
{
cScript *toExecute = JSMapping->GetScript( scriptTrig );
if( toExecute != nullptr )
{
// -1 == script doesn't exist, or returned -1
// 0 == script returned false, 0, or nothing - don't execute hard code
// 1 == script returned true or 1
if( toExecute->OnSell( mSock, Npc ) == 0 ) //if script returns false, don't continue
{
return false;
}
}
}
Npc->SetTimer( tNPC_MOVETIME, BuildTimeValue( 60 ) );
CPSellList toSend;
if( toSend.CanSellItems( (*mChar), (*Npc) ) )
mSock->Send( &toSend );
else
Npc->TextMessage( mSock, 1341, TALK, false );
return false;
}
CVendorViewResponse::CVendorViewResponse( bool vendVal, const std::string &text ) : CBaseVendorResponse( vendVal, text )
{
}
//o-----------------------------------------------------------------------------------------------o
//| Function - bool CVendorViewResponse::Handle( CSocket *mSock, CChar *mChar, CChar *Npc )
//o-----------------------------------------------------------------------------------------------o
//| Purpose - Handles response to players wanting to view the items a vendor has for sale
//o-----------------------------------------------------------------------------------------------o
bool CVendorViewResponse::Handle( CSocket *mSock, CChar *mChar, CChar *Npc )
{
if( Npc->GetNPCAiType() == AI_PLAYERVENDOR )
{
CItem *pack = nullptr;
Npc->TextMessage( mSock, 385, TALK, false );
pack = Npc->GetPackItem();
if( ValidateObject( pack ) )
mSock->openPack( pack, true );
}
if( !saidVendor )
return false;
return true;
}
CVendorGoldResponse::CVendorGoldResponse( bool vendVal, const std::string &text ) : CBaseVendorResponse( vendVal, text )
{
}
//o-----------------------------------------------------------------------------------------------o
//| Function - bool CVendorGoldResponse::Handle( CSocket *mSock, CChar *mChar, CChar *Npc )
//o-----------------------------------------------------------------------------------------------o
//| Purpose - Handles response to players wanting to withdraw their earnings from their vendor
//o-----------------------------------------------------------------------------------------------o
bool CVendorGoldResponse::Handle( CSocket *mSock, CChar *mChar, CChar *Npc )
{
if( Npc->GetNPCAiType() == AI_PLAYERVENDOR )
{
CChar *mChar = mSock->CurrcharObj();
if( mChar == Npc->GetOwnerObj() )
{
UI32 pay = 0, give = Npc->GetHoldG(), earned = Npc->GetHoldG();
if( Npc->GetHoldG() <= 0 )
{
Npc->TextMessage( mSock, 1326, TALK, false );
Npc->SetHoldG( 0 );
}
else if( Npc->GetHoldG() > 0 && Npc->GetHoldG() <= MAX_STACK )
{
if( Npc->GetHoldG() > 9 )
{
pay = (SI32)( Npc->GetHoldG() / 10 );
give = Npc->GetHoldG() - pay;
}
else
{
pay = Npc->GetHoldG();
give = 0;
}
Npc->SetHoldG( 0 );
}
else
{
UI32 t = Npc->GetHoldG() - MAX_STACK; // yank of 65 grand, then do calculations
Npc->SetHoldG( t );
pay = 6554;
give = 58981;
if( t > 0 )
Npc->TextMessage( mSock, 1327, TALK, false );
}
if( give )
Items->CreateScriptItem( mSock, mChar, "0x0EED", give, OT_ITEM, true );
Npc->TextMessage( mSock, 1328, TALK, 0, earned, pay, give );
}
else
Npc->TextMessage( mSock, 1329, TALK, false );
}
if( !saidVendor )
return false;
return true;
}
CVendorStatusResponse::CVendorStatusResponse( bool vendVal, const std::string &text ) : CBaseVendorResponse( vendVal, text )
{
}
//o-----------------------------------------------------------------------------------------------o
//| Function - bool CVendorStatusResponse::Handle( CSocket *mSock, CChar *mChar, CChar *Npc )
//o-----------------------------------------------------------------------------------------------o
//| Purpose - Handles response to players wanting to see the status of their vendor
//o-----------------------------------------------------------------------------------------------o
bool CVendorStatusResponse::Handle( CSocket *mSock, CChar *mChar, CChar *Npc )
{
if( Npc->GetNPCAiType() == AI_PLAYERVENDOR )
{
CChar *mChar = mSock->CurrcharObj();
if( mChar == Npc->GetOwnerObj() )
{
if( Npc->GetHoldG() <= 0 )
{
Npc->TextMessage( mSock, 1326, TALK, false );
}
else
{
UI32 pay = 0;
if( Npc->GetHoldG() > 9 )
{
pay = (SI32)( Npc->GetHoldG() / 10 );
}
else
{
pay = Npc->GetHoldG();
}
Npc->TextMessage( mSock, 1782, TALK, 0, Npc->GetHoldG(), pay );
}
}
else
Npc->TextMessage( mSock, 1329, TALK, false );
}
if( !saidVendor )
return false;
return true;
}
CVendorDismissResponse::CVendorDismissResponse( bool vendVal, const std::string &text ) : CBaseVendorResponse( vendVal, text )
{
}
//o-----------------------------------------------------------------------------------------------o
//| Function - bool CVendorDismissResponse::Handle( CSocket *mSock, CChar *mChar, CChar *Npc )
//o-----------------------------------------------------------------------------------------------o
//| Purpose - Handles response to players wanting to dismiss their vendor
//o-----------------------------------------------------------------------------------------------o
bool CVendorDismissResponse::Handle( CSocket *mSock, CChar *mChar, CChar *Npc )
{
if( Npc->GetNPCAiType() == AI_PLAYERVENDOR )
{
CChar *mChar = mSock->CurrcharObj();
if( mChar == Npc->GetOwnerObj() )
{
Npc->Delete();
}
else
Npc->TextMessage( mSock, 1329, TALK, false );
}
if( !saidVendor )
return false;
return true;
}
CHouseMultiResponse::CHouseMultiResponse( TargetIDs targVal, SI32 dictVal )
{
targID = targVal;
dictEntry = dictVal;
}
//o-----------------------------------------------------------------------------------------------o
//| Function - void CHouseMultiResponse::Handle( CSocket *mSock, CChar *mChar )
//o-----------------------------------------------------------------------------------------------o
//| Purpose - Handles response to players wanting to use house commands
//o-----------------------------------------------------------------------------------------------o
void CHouseMultiResponse::Handle( CSocket *mSock, CChar *mChar )
{
CMultiObj *realHouse = findMulti( mChar );
if( ValidateObject( realHouse ) && !realHouse->CanBeObjType( OT_BOAT ))
{
if( realHouse->CanBeObjType( OT_MULTI ))
{
std::vector<UI16> scriptTriggers = realHouse->GetScriptTriggers();
for( auto scriptTrig : scriptTriggers )
{
cScript *toExecute = JSMapping->GetScript( scriptTrig );
if( toExecute != nullptr )
{
//-1 == event not found
// 0 == script returned false/0
// 1 == script returned true/1
if( toExecute->OnHouseCommand( mSock, realHouse, targID ) == 1 ) //if script returns true, don't continue
{
return;
}
}
}
if( realHouse->IsOwner( mChar ) )
{
mSock->TempObj( realHouse );
mSock->target( 0, targID, 0, dictEntry );
}
}
}
}
CBoatResponse::CBoatResponse( const std::string &text, UI16 tW )
{
ourText = text;
trigWord = tW;
}
// void CBoatResponse::Handle( CSocket *mSock, CChar *mChar ) in Boats.cpp
CBoatMultiResponse::CBoatMultiResponse( BoatMoveType mType )
{
moveType = mType;
}
CBoatObj * GetBoat( CSocket *s );
//o-----------------------------------------------------------------------------------------------o
//| Function - void CBoatMultiResponse::Handle( CSocket *mSock, CChar *mChar )
//o-----------------------------------------------------------------------------------------------o
//| Purpose - Handles response to players wanting to use boat commands
//o-----------------------------------------------------------------------------------------------o
void CBoatMultiResponse::Handle( CSocket *mSock, CChar *mChar )
{
// Let's do some spam-prevention here
if( mChar->GetTimer( tCHAR_ANTISPAM ) > cwmWorldState->GetUICurrentTime() )
{
return;
}
else
{
mChar->SetTimer( tCHAR_ANTISPAM, BuildTimeValue( (R32)cwmWorldState->ServerData()->CheckBoatSpeed() ) );
}
CBoatObj *boat = GetBoat( mSock );
if( !ValidateObject( boat ) )
{
return;
}
CItem *tiller = calcItemObjFromSer( boat->GetTiller() );
if( boat->GetMoveType() == BOAT_ANCHORED )
{
if( ValidateObject( tiller ) )
{
tiller->TextMessage( mSock, 2024 ); // Ar, the anchor is down sir!
mSock->sysmessage( 2023 ); // You must raise the anchor to pilot the ship.
}
return;
}
boat->SetMoveType( moveType );
if( ValidateObject( tiller ) )
{
tiller->TextMessage( mSock, 10 ); // Aye, sir.
}
}
Reference in a new issue View git blame Copy permalink