mirror of
https://github.com/UOX3DevTeam/UOX3
synced 2026-08-13 12:27:04 -04:00
68e57b0756
Increased world load speed by almost 20% by reducing how often loading progress is written to the console Increased world save speed by almost 50% through the use of binary mode and buffer tweaks for ofstream combined with a cached newline char and std::to_string instead of static_cast Fixed a server crash involving killing NPCs of a specific spawn region using the 'spawnkill # command Fixed a server crash involving moving items from decaying corpses to the ground Fixed a server crash involving carving up human corpses Fixed a server crash related to AreaCharacterFunction JS function, which could trigger for any script that potentially kills any NPC this function iterates over (like explosion potions) Fixed a server crash related to GMs attempting to add items from add-menu while having no backpack Fixed a client crash issue caused by attempting to sell house deeds back to architect NPCs Fixed an issue where players would get incorrect amounts of gold for selling house deeds back to architect NPCs Fixed an issue with characters dying onboard boats which prevented players from packing up the boats later Added new item property in code (via bools bitset) that can be used to enable/disable maker's mark on crafted items. This property can be set to true for items crafted at exceptional quality by GM craftsmen Exposed the new item property to JS engine: .isMarkedByMaker // If true, maker's mark will be displayed Updated default item tooltip to display " of exceptional quality" for items crafted with exceptional quality Updated default item tooltip to display "[Crafted] by [Crafter's Name]" for exceptional quality items crafted by GM craftsmen. The [Crafted] text comes from the MADEWORD defined in dfndata/skills/skills.dfn for the primary skill used to craft the item Updated old-school single-click names for items (when AoS bit is disabled in client/server features) to display exceptional status and/or maker's mark for appropriate items Fixed an issue with the display of titles for NPCs that used dictionary lookups for their title Added new UOX.INI settings under the [settings] section: DISPLAYMAKERSMARK=1/0 // Controls if maker's marks on crafted items are shown on a global level SHOWNPCTITLESOVERHEAD=1/0 // Controls whether NPC titles are shown over their heads SHOWINVULNERABLETAGOVERHEAD=0/1 // Controls whether invulnerable tags are shown overhead GLOBALRESTOCKMULTIPLIER=1.0 // Global multiplier applied to RESTOCK property of items when loaded from DFNs Added new UOX.INI settings under the [combat] section: PETCOMBATTRAINING=1/0 // Controls whether pets can gain skills/stats from combat HIRELINGCOMBATTRAINING=1/0 // Controls whether hirelings can gain skills/stats from combat NPCCOMBATTRAINING=0/1 // Controls whether NPCs in general can gain skills/stats from combat Fixed an issue where a player meeting the exact minimum requirements for crafting an item would always fail Fixed a bug with teleporting off boats to valid nearby locations when double-clicking boat planks while standing on it Updated behaviour of planks on boats: Boat key can unlock plank, but won't automatically open it Boat key used on an open, unlocked plank will lock and automatically close the plank Boat key used on an open, locked plank will unlock the plank and leave it open Player using an unlocked plank now opens it Player using an open plank will disembark (if onboard) or embark (if not) the boat Player can always open a locked plank if they're on the boat, even with no key, to allow disembarking the boat. Planks that are open, but locked cannot be accessed from outside the boat, and will close automatically after five of seconds Updated behaviour of Magic Lock/Unlock spells: Magic Lock cannot be used on objects inside a multi Magic Lock applies difficulty to lock based on caster's Magery skill Magic Lock effect will last between 7 to 50 seconds (depending on caster's Magery skill) Any object that can be locked via Magic Lock spell can also be unlocked via Magic Unlock spell, if caster has high enough Magery skill Fixed a bug where certain JS Functions, Methods and Properties would occasionally pass incorrect values to scripts that called upon them. Scripts that rely on the GetCurrentClock() Function, the .GetTimer() Method, .decayTime, .logTime, .oreTime and .fishTime Properties might need to be updated to account for the fix, which causes larger values to be passed in than before. Fixed a bug related to GetCurrentClock() that caused decay and respawning of dungeon chests from working properly Fixed a bug related to GetCurrentClock() and .logTime/.fishTime that prevented consumption and regeneration of log/fish resources from working properly Added a new JS Function: GetStartTime() // Returns a timestamp for when server started up Fixed a bug related to GetCurrentClock() where server uptime stats in help menu was showing up incorrectly Fixed a bug related to GetCurrentClock() and purging of registrations of visitors in public houses so their visits can be counted again later Fixed a bug related to GetCurrentClock() that caused monster speech to not work properly Fixed a Z-related issue that sometimes prevented players from fishing when standing on the shoreline next to the sea Fixed an issue with Animal Lore skill that would always return a pet's loyalty level as "Wild" Increased max range pets can be from their owner in order to still be included in moongate/teleporter travel from 12 to 24 tiles Fixed an issue where the alchemy bonus damage for explosion potions was off by an order of magnitude Fixed an issue where food IDs from foodlists referenced by other foodlists was not detected as valid food for tamed pets or NPCs Fixed an issue where Alchemy crafting skill did not properly check for the existence of the crafting tool before proceeding with the crafting process Fixed an issue that prevented the Teleport spell from working as intended Fixed an issue where players would still get 1 gold even if STARTGOLD in uox.ini was set to 0 Fixed an issue with mount restrictions script that prevented players from mounting Unicorns, Ki-rins and Cu Sidhes Fixed an issue where aggressive creatures wouldn't stop attacking player after being tamed (js/skill/taming.js) Added a system message to inform the player when they've dropped out of stealth due to taking too many steps Fixed an issue where hunger level of NPCs instantly dropped upon spawning because hunger timer was not active yet Fixed a bug where character corpses would appear with a [unidentified] tag attached Fixed an issue where the [unidentified] tag did not show up for unidentified magic items Added ANIMAL tag to a small bunch of creature definitions (dfndata/creatures/creatures.dfn) Fixed an issue with Bowcraft skill where player could not gain enough skill from crafting bows to reach min requirement for crossbows, and similiarly could not reach min requirement for heavy crossbows from crossbows Updated default value of MURDERDECAYTIMER INI setting from 60 seconds to 28800 seconds (8 hours), to match the amount of time it would take for one (short term) murder count to decay on LBR-era OSI shards.
2846 lines
106 KiB
C++
2846 lines
106 KiB
C++
//o-----------------------------------------------------------------------------------------------o
|
|
//| File: walking.cpp
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
//| This File is part of UOX3
|
|
//| Ultima Offline eXperiment III
|
|
//| UO Server Emulation Program
|
|
//|
|
|
//| Copyright 1998 - 2021 by UOX3 contributors
|
|
//| Copyright 1997 - 2001 by Marcus Rating (Cironian)
|
|
//|
|
|
//| This program is free software; you can redistribute it and/or modify
|
|
//| it under the terms of the GNU General Public License as published by
|
|
//| the Free Software Foundation; either version 2 of the License, or
|
|
//| (at your option) any later version.
|
|
//|
|
|
//| This program is distributed in the hope that it will be useful,
|
|
//| but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
//| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
//| GNU General Public License for more details.
|
|
//|
|
|
//| You should have received a copy of the GNU General Public License
|
|
//| along with this program; if not, write to the Free Software
|
|
//| Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
|
//|
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
//|
|
|
//| TODO:
|
|
//| Modify path struct to use only directions, not store x,y
|
|
//| Add running support in PathFind
|
|
//| Modify flying
|
|
//|
|
|
//| An explination of each function precedes it in the code. Hope I can provide ample enough
|
|
//| information to help out the future bug fixers. I will try to explain EVERY bit of logic
|
|
//| behind what I've done to make things easier.
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
#include "uox3.h"
|
|
#include "movement.h"
|
|
#include "weight.h"
|
|
#include "combat.h"
|
|
#include "msgboard.h"
|
|
#include "cRaces.h"
|
|
#include "cMagic.h"
|
|
#include "CJSMapping.h"
|
|
#include "cScript.h"
|
|
#include "cEffects.h"
|
|
#include "CPacketSend.h"
|
|
#include "regions.h"
|
|
#include "cServerDefinitions.h"
|
|
#include "cWeather.hpp"
|
|
#include "Dictionary.h"
|
|
#include "StringUtility.hpp"
|
|
#include "EventTimer.hpp"
|
|
|
|
#include <algorithm>
|
|
|
|
cMovement *Movement;
|
|
|
|
// These are defines that I'll use. I have a history of working with properties, so that's why
|
|
// I'm using custom definitions here versus what may be defined in the other includes.
|
|
// NOTE: P = Property, P_C = Property for Characters, P_PF = Property for Pathfinding
|
|
// P_M = Property for Movement
|
|
|
|
// These are the debugging defines
|
|
|
|
// These are the errors that we should want to see. RARELY results in any console spam unless
|
|
// someone is trying to use an exploit or is sending invalid data directly to the server.
|
|
|
|
#define DEBUG_WALKING 0
|
|
#define DEBUG_NPCWALK 0
|
|
#define DEBUG_PATHFIND 0
|
|
|
|
#undef DBGFILE
|
|
#define DBGFILE "movement.cpp"
|
|
|
|
#define XYMAX 256 // Maximum items UOX can handle on one X/Y square
|
|
|
|
inline UI08 turn_clock_wise( UI08 dir )
|
|
{
|
|
UI08 t = ((dir & 0x07 ) + 1) % 8;
|
|
return (UI08)(dir & 0x80) ? ( t | 0x80) : t;
|
|
}
|
|
|
|
inline UI08 turn_counter_clock_wise( UI08 dir )
|
|
{
|
|
UI08 t = (dir - 1) & 7;
|
|
return (UI08)(dir & 0x80) ? ( t | 0x80) : t;
|
|
}
|
|
|
|
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
//| Function - inline SI08 calcTileHeight( SI08 h )
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
//| Purpose - Out of some strange reason the tile height seems to be an absolute value of a
|
|
//| two's complement of the last four bit. Don't know if it has a special meaning
|
|
//| if the tile is height is "negative" (stairs in despise blocking bug)
|
|
//|
|
|
//| Arguments - SI08 h orignial height as saved in mul file
|
|
//|
|
|
//| Returns - The absoulte value of the two's complement if the value was "negative"
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
inline SI08 calcTileHeight( SI08 h )
|
|
{
|
|
return (SI08)((h & 0x8) ? ((h & 0xF) >> 1) : h & 0xF);
|
|
}
|
|
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
//| Function - void HandleTeleporters( CChar *s )
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
//| Purpose - If character is on a teleport location, teleport him
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
auto HandleTeleporters( CChar *s )->void {
|
|
|
|
if( ValidateObject( s ) ){
|
|
UI08 charWorld = s->WorldNumber();
|
|
CTeleLocationEntry *getTeleLoc = nullptr;
|
|
bool isOnTeleporter;
|
|
for( size_t i = 0; i < cwmWorldState->teleLocs.size(); ++i ) {
|
|
isOnTeleporter = false;
|
|
getTeleLoc = &cwmWorldState->teleLocs[i];
|
|
if( getTeleLoc){
|
|
if(( getTeleLoc->SourceWorld() == 0xFF && charWorld <= 1 ) || getTeleLoc->SourceWorld() == charWorld ) {
|
|
if( getTeleLoc->SourceLocation().z != ILLEGAL_Z ){
|
|
isOnTeleporter = ( getTeleLoc->SourceLocation() == s->GetLocation() );
|
|
}
|
|
else{
|
|
isOnTeleporter = ( getTeleLoc->SourceLocation().x == s->GetX() && getTeleLoc->SourceLocation().y == s->GetY() );
|
|
}
|
|
if( isOnTeleporter ) {
|
|
UI08 targetWorld = 0;
|
|
if( getTeleLoc->SourceWorld() == 0xFF ) {
|
|
targetWorld = s->WorldNumber();
|
|
}
|
|
else {
|
|
targetWorld = getTeleLoc->TargetWorld();
|
|
}
|
|
|
|
s->SetLocation( (SI16)getTeleLoc->TargetLocation().x, (SI16)getTeleLoc->TargetLocation().y, (UI08)getTeleLoc->TargetLocation().z, targetWorld, s->GetInstanceID() );
|
|
if( !s->IsNpc() ) {
|
|
if( targetWorld != charWorld ){
|
|
SendMapChange( getTeleLoc->TargetWorld(), s->GetSocket() );
|
|
}
|
|
|
|
// Teleport player's pets
|
|
auto myPets = s->GetPetList();
|
|
for (const auto &myPet : myPets->collection()){
|
|
if( ValidateObject( myPet ) ){
|
|
if( !myPet->GetMounted() && myPet->IsNpc() && myPet->GetOwnerObj() == s ) {
|
|
if( objInOldRange( s, myPet, DIST_CMDRANGE ) ){
|
|
myPet->SetLocation( s );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
else if( s->GetX() < getTeleLoc->SourceLocation().x ){
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void checkRegion( CSocket *mSock, CChar& mChar, bool forceUpdateLight );
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
//| Function - void Walking( CSocket *mSock, CChar *c, UI08 dir, SI16 sequence )
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
//| Purpose - Handles both player requests for walking and NPCs walking
|
|
//|
|
|
//| Notes - This function is called whenever we get a message from the client
|
|
//| to walk/run somewhere. It is also called by the NPC movement functions in this
|
|
//| class to make the NPCs move. The arguments are fairly fixed because we don't
|
|
//| have a lot of control about what the client gives us.
|
|
//|
|
|
//| CChar c - Obviously the character index of the character trying to move.
|
|
//|
|
|
//| dir - Which direction the character is trying to move in. The first nibble holds
|
|
//| the cardinal direction. If the bit 0x80 is set, it means the character is
|
|
//| running instead of walking.
|
|
//| 0: // North
|
|
//| 1: // Northeast
|
|
//| 2: // East
|
|
//| 3: // Southeast
|
|
//| 4: // South
|
|
//| 5: // Southwest
|
|
//| 6: // West
|
|
//| 7: // Northwest
|
|
//|
|
|
//| sequence - This is what point in the walking sequence we are at, this seems to
|
|
//| roll over once it hits 256
|
|
//|
|
|
//| Sometimes the NPC movement code comes up with -1, for example, if we are
|
|
//| following someone and we are directly on top of them.
|
|
//| ^ That's because chardir returns -1 when direction is the same. Actually, this
|
|
//| should only happen when a player walks on top of an NPC and the NPC tries to move.
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
void cMovement::Walking( CSocket *mSock, CChar *c, UI08 dir, SI16 sequence )
|
|
{
|
|
if( !isValidDirection( dir ) )
|
|
{
|
|
std::string charName = getNpcDictName( c );
|
|
Console.error( oldstrutil::format("%s (cMovement::Walking) caught bad direction = %s %d 0x%x\n", DBGFILE, charName.c_str(), dir, dir ));
|
|
// If I don't do this, the NPC will keep trying to walk on the same step, which is
|
|
// where he's already at. Can cause an infinite loop. (Trust me, was one of the things
|
|
// that locked up NW Alpha 2)
|
|
// Will call something like NPCRandomMove in the future.
|
|
if( c->IsNpc() )
|
|
c->FlushPath();
|
|
return;
|
|
}
|
|
|
|
if( !VerifySequence( c, mSock, sequence ) )
|
|
return;
|
|
|
|
// If checking for weight is more expensive, shouldn't we check for frozen first?
|
|
if( isFrozen( c, mSock, sequence ) )
|
|
return;
|
|
|
|
if( isOverloaded( c, mSock, sequence ) )
|
|
return;
|
|
|
|
// save our original location before we even think about moving
|
|
const SI16 oldx = c->GetX();
|
|
const SI16 oldy = c->GetY();
|
|
|
|
// see if we have stopped to turn or if we are moving
|
|
const bool amTurning = ( (dir&0x07) != c->GetDir() );
|
|
if( !amTurning )
|
|
{
|
|
if( !CheckForRunning( c, dir ) )
|
|
return;
|
|
|
|
if( !CheckForStealth( c ) )
|
|
return;
|
|
|
|
SI08 myz = ILLEGAL_Z;
|
|
const SI16 myx = GetXfromDir( dir, oldx );
|
|
const SI16 myy = GetYfromDir( dir, oldy );
|
|
if( !calc_move( c, oldx, oldy, myz, dir ) )
|
|
{
|
|
#if DEBUG_WALKING
|
|
std::string charName = getNpcDictName( c );
|
|
Console.print( oldstrutil::format( "DEBUG: %s (cMovement::Walking) Character Walk Failed for %s\n", DBGFILE, charName ));
|
|
Console.print( oldstrutil::format( "DEBUG: %s (cMovement::Walking) sx (%d) sy (%d) sz (%d)\n", DBGFILE, oldx, oldy, c->GetZ() ));
|
|
Console.print( oldstrutil::format( "DEBUG: %s (cMovement::Walking) dx (%d) dy (%d) dz (%d)\n", DBGFILE, myx, myy, myz ));
|
|
#endif
|
|
if( mSock != nullptr )
|
|
deny( mSock, c, sequence );
|
|
if( c->IsNpc() )
|
|
{
|
|
c->FlushPath();
|
|
|
|
//The following bits are to stop NPCs from constantly pathfinding
|
|
//if the server thinks the paths they're finding are valid, but they
|
|
//can't actually move there!
|
|
const SI16 fx1 = c->GetFx( 0 );
|
|
const SI16 fx2 = c->GetFx( 1 );
|
|
const SI16 fy1 = c->GetFy( 0 );
|
|
const SI16 fy2 = c->GetFy( 1 );
|
|
|
|
c->SetPathFail( c->GetPathFail() + 1 );
|
|
if( c->GetPathFail() > 10 )
|
|
{
|
|
UI16 fx2Actual = 0;
|
|
UI16 fy2Actual = 0;
|
|
SI08 npcWanderType = c->GetNpcWander();
|
|
if( npcWanderType == WT_FLEE )
|
|
{
|
|
// If NPC fails to flee, make him re-attack instead!
|
|
c->SetFleeAt( 0 );
|
|
c->SetReattackAt( 1 );
|
|
c->SetNpcWander( c->GetOldNpcWander() );
|
|
if( c->GetMounted() )
|
|
c->SetTimer( tNPC_MOVETIME, BuildTimeValue( c->GetMountedRunningSpeed() ) );
|
|
else
|
|
c->SetTimer( tNPC_MOVETIME, BuildTimeValue( c->GetRunningSpeed() ) );
|
|
c->SetOldNpcWander( WT_NONE ); // so it won't save this at the wsc file
|
|
}
|
|
else if( npcWanderType == WT_FOLLOW )
|
|
{
|
|
// If NPC following fails to follow, make it stop
|
|
c->SetOldTargLocX( 0 );
|
|
c->SetOldTargLocY( 0 );
|
|
c->SetNpcWander( WT_NONE );
|
|
c->TextMessage( nullptr, "[Stops following]", SYSTEM, false );
|
|
}
|
|
else if( npcWanderType == WT_BOX )
|
|
{
|
|
fx2Actual = fx2;
|
|
fy2Actual = fy2;
|
|
BoundingBoxTeleport( c, fx2Actual, fy2Actual, oldx, oldy );
|
|
}
|
|
else if( npcWanderType == WT_CIRCLE )
|
|
{
|
|
fx2Actual = fx1 + fx2;
|
|
fy2Actual = fy1 + fx2;
|
|
BoundingBoxTeleport( c, fx2Actual, fy2Actual, oldx, oldy );
|
|
}
|
|
else
|
|
c->SetNpcWander( WT_FREE );
|
|
c->SetPathFail( 0 );
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
#if DEBUG_WALKING
|
|
std::string charName = getNpcDictName( c );
|
|
Console.print( oldstrutil::format( "DEBUG: %s (cMovement::Walking) Character Walk Passed for %s\n", DBGFILE, charName ));
|
|
Console.print( oldstrutil::format( "DEBUG: %s (cMovement::Walking) sx (%d) sy (%d) sz (%d)\n", DBGFILE, oldx, oldy, c->GetZ() ));
|
|
Console.print( oldstrutil::format( "DEBUG: %s (cMovement::Walking) dx (%d) dy (%d) dz (%d)\n", DBGFILE, myx, myy, myz ));
|
|
#endif
|
|
|
|
if( c->IsNpc() && CheckForCharacterAtXYZ( c, myx, myy, myz ) )
|
|
{
|
|
c->SetPathFail( c->GetPathFail() + 1 );
|
|
|
|
if( c->GetPathFail() < 3 && !c->IsEvading() ) // Try again up to 3 times
|
|
{
|
|
c->FlushPath();
|
|
|
|
// If advanced pathfinding is enabled, calculate a new path!
|
|
if( cwmWorldState->ServerData()->AdvancedPathfinding() )
|
|
{
|
|
bool newPath = false;
|
|
newPath = AdvancedPathfinding( c, c->GetPathTargX(), c->GetPathTargY(), (c->GetRunning() > 0) );
|
|
if( !newPath )
|
|
c->SetPathResult( 0 ); // partial success
|
|
#if DEBUG_WALKING
|
|
std::string charName = getNpcDictName( c );
|
|
Console.print( oldstrutil::format("DEBUG: Walking() - NPC (%s) failed to pathfind (%d times). Calculating new path!\n", charName.c_str(), c->GetPathFail() ));
|
|
#endif
|
|
}
|
|
return;
|
|
}
|
|
else if( c->GetPathFail() < 10 && !c->IsEvading() )
|
|
{
|
|
#if DEBUG_WALKING
|
|
std::string charName = getNpcDictName( c );
|
|
Console.print( oldstrutil::format( "DEBUG: %s (cMovement::Walking) Character Walk Passed for %s\n", DBGFILE, charName ));
|
|
Console.print( oldstrutil::format( "DEBUG: %s (cMovement::Walking) sx (%d) sy (%d) sz (%d)\n", DBGFILE, oldx, oldy, c->GetZ() ));
|
|
Console.print( oldstrutil::format( "DEBUG: %s (cMovement::Walking) dx (%d) dy (%d) dz (%d)\n", DBGFILE, myx, myy, myz ));
|
|
Console.print( oldstrutil::format( "DEBUG: Walking() - NPC (%s) failed to pathfind (%d times, but less than 10). Invalidating old target location!\n", charName.c_str(), c->GetPathFail() ));
|
|
#endif
|
|
|
|
c->FlushPath();
|
|
c->SetPathResult( 0 ); // partial success, but blocked by character
|
|
|
|
// Forget it, find a new target location for pathfinding
|
|
c->SetOldTargLocX( 0 );
|
|
c->SetOldTargLocY( 0 );
|
|
|
|
// Temporary change NPC's wandermode to none, and try pathfinding again in 5 seconds
|
|
if( c->GetNpcWander() != WT_NONE )
|
|
c->SetOldNpcWander( c->GetNpcWander() );
|
|
c->SetNpcWander( WT_NONE );
|
|
c->SetTimer( tNPC_MOVETIME, BuildTimeValue( 5 ) );
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
#if DEBUG_WALKING
|
|
std::string charName = getNpcDictName( c );
|
|
Console.print( oldstrutil::format("DEBUG: Walking() - NPC (%s) failed to pathfind %d times! Pausing pathfinding for some time.\n", charName.c_str(), c->GetPathFail() ));
|
|
#endif
|
|
c->FlushPath();
|
|
c->SetPathResult( 0 ); // partial success, but blocked by character
|
|
c->SetPathFail( 0 );
|
|
|
|
// Pause attempts to move if pathfind keeps failing
|
|
// Wandermode will be restored in HandleNPCWander()
|
|
auto npcWanderType = c->GetNpcWander();
|
|
if( npcWanderType == WT_BOX || npcWanderType == WT_CIRCLE || npcWanderType == WT_FREE )
|
|
{
|
|
c->SetOldNpcWander( npcWanderType );
|
|
c->SetNpcWander( WT_NONE );
|
|
c->SetTimer( tNPC_MOVETIME, BuildTimeValue( 30 ) );
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
|
|
if( cwmWorldState->ServerData()->AmbientFootsteps() )
|
|
Effects->playTileSound( c, mSock );
|
|
|
|
MoveCharForDirection( c, myx, myy, myz );
|
|
c->SetPathFail( 0 );
|
|
|
|
// i actually moved this for now after the z = illegal_z, in the end of CrazyXYBlockStuff()
|
|
// can't see how that would hurt anything
|
|
if( !CheckForHouseBan( c, mSock ) )
|
|
return;
|
|
|
|
//
|
|
// OK AT THIS POINT IT IS NOW OFFICIALLY A LEGAL MOVE TO MAKE, LETS GO FOR IT!
|
|
//
|
|
// That means any bugs concerning if a move was legal must be before this point!
|
|
//
|
|
}
|
|
|
|
// do all of the following regardless of whether turning or moving i guess
|
|
|
|
// set the player direction to contain only the cardinal direction bits
|
|
c->WalkDir( (dir&0x07) );
|
|
|
|
SendWalkToPlayer( c, mSock, sequence );
|
|
SendWalkToOtherPlayers( c, dir, oldx, oldy );
|
|
|
|
// Update timestamp for when character last moved
|
|
c->LastMoveTime( cwmWorldState->GetUICurrentTime() );
|
|
|
|
// i'm going ahead and optimizing this, if you haven't really moved, should be
|
|
// no need to check for teleporters and the weather shouldn't change
|
|
if( !amTurning )
|
|
{
|
|
OutputShoveMessage( c, mSock );
|
|
|
|
HandleItemCollision( c, mSock, oldx, oldy );
|
|
HandleTeleporters( c );
|
|
CheckCharInsideBuilding( c, mSock, true);
|
|
checkRegion( mSock, (*c), false );
|
|
}
|
|
}
|
|
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
//| Function - bool isValidDirection( UI08 dir )
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
//| Purpose - Check if a given direction is valid
|
|
//| Notes - Return true on the below values:
|
|
//| Direction Walking Value Running Value
|
|
//| North 0 0x00 128 0x80
|
|
//| Northeast 1 0x01 129 0x81
|
|
//| East 2 0x02 130 0x82
|
|
//| Southeast 3 0x03 131 0x83
|
|
//| South 4 0x04 132 0x84
|
|
//| Southwest 5 0x05 133 0x85
|
|
//| West 6 0x06 134 0x86
|
|
//| Northwest 7 0x07 135 0x87
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
bool cMovement::isValidDirection( UI08 dir )
|
|
{
|
|
return ( dir == ( dir & 0x87 ) );
|
|
}
|
|
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
//| Function - bool isFrozen( CChar *c, CSocket *mSock, SI16 sequence )
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
//| Purpose - Check if a character is frozen or casting a spell
|
|
//| Notes - Because of the way the source uses the frozen flag, I decided to change
|
|
//| something in how this works. If the character is casting a spell (chars.casting is true)
|
|
//| OR if they're frozen (chars.priv2 & FROZEN_BIT) then they can't walk. Why? If a player/npc
|
|
//| has their frozen bit set, and they cast a spell, they will lose their frozen bit at the
|
|
//| end of the spell cast. With this new check, we don't even need to set the frozen bit when
|
|
//| casting a spell!
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
bool cMovement::isFrozen( CChar *c, CSocket *mSock, SI16 sequence )
|
|
{
|
|
if( c->IsCasting() )
|
|
{
|
|
if( mSock != nullptr )
|
|
{
|
|
mSock->sysmessage( 1380 );
|
|
deny( mSock, c, sequence );
|
|
}
|
|
#if DEBUG_WALKING
|
|
std::string charName = getNpcDictName( c );
|
|
Console.print( oldstrutil::format( "DEBUG: %s (cMovement::isFrozen) casting char %s\n", DBGFILE, charName ));
|
|
#endif
|
|
return true;
|
|
}
|
|
if( c->IsFrozen() )
|
|
{
|
|
if( mSock != nullptr )
|
|
{
|
|
mSock->sysmessage( 1381 );
|
|
deny( mSock, c, sequence );
|
|
}
|
|
#if DEBUG_WALKING
|
|
std::string charName = getNpcDictName( c );
|
|
Console.print( oldstrutil::format( "DEBUG: %s (cMovement::isFrozen) frozen char %s\n", DBGFILE, charName ));
|
|
#endif
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
//| Function - bool isOverloaded( CChar *c, CSocket *mSock, SI16 sequence )
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
//| Purpose - Checks if character is overloaded with weight, and returns true or false
|
|
//| Notes - CheckForWeight was confusing...
|
|
//|
|
|
//| Old code called check weight first then checked socket... I changed it the other way.
|
|
//| Why, well odds are (I may be wrong) if you don't have a socket, you're an NPC and if you
|
|
//| have one, you're a character. We said in the first line that we didn't want to restrict
|
|
//| based upon NPC, so if you're an NPC, the socket/checkweight will never be called anyway.
|
|
//|
|
|
//| Rewrote to deny the client... We'll see if it works.
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
bool cMovement::isOverloaded( CChar *c, CSocket *mSock, SI16 sequence )
|
|
{
|
|
// Who are we going to check for weight restrictions?
|
|
if( !c->IsDead() && !c->IsNpc() && c->GetCommandLevel() < CL_CNS )
|
|
{
|
|
if( mSock != nullptr )
|
|
{
|
|
if( Weight->isOverloaded( c ) )
|
|
c->IncStamina( -5 );
|
|
if( c->GetStamina() <= 0 )
|
|
{
|
|
c->SetStamina( 0 );
|
|
mSock->sysmessage( 1783 );
|
|
deny( mSock, c, sequence );
|
|
#if DEBUG_WALKING
|
|
std::string charName = getNpcDictName( c );
|
|
Console.print( oldstrutil::format( "DEBUG: %s (cMovement::Walking) overloaded char %s\n", DBGFILE, charName ));
|
|
#endif
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
//| Function - bool CheckForCharacterAtXYZ( CChar *c, SI16 cx, SI16 cy, SI08 cz )
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
//| Purpose - Examins a location (cx, cy, cz) to determine if a character is found there.
|
|
//| If so, return true. If not, return false. Used for the npc stacking problem
|
|
//| Notes - Here's how I'm going to use it for now. Movement Type may be used for races, that's why
|
|
//| I put it as an integer. Here are the values I'm going to use:
|
|
//| BTW, bird doesn't work right now! These values should be scripted, as well, but I want
|
|
//| to test walking before another var is added to chars struct.
|
|
//| GM Body 0x01
|
|
//| Player 0x02
|
|
//| Bird 0x20 (basically, a fish and an NPC, so I could use 0xc0, but I don't wanna)
|
|
//| NPC 0x40
|
|
//| Fish 0x80 (So they can swim!)
|
|
//| I left a gap between Player and NPC because someone may want to implement race
|
|
//| restrictions...
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
auto cMovement::CheckForCharacterAtXYZ( CChar *c, SI16 cx, SI16 cy, SI08 cz ) ->bool {
|
|
CMapRegion *MapArea = MapRegion->GetMapRegion( MapRegion->GetGridX( cx ), MapRegion->GetGridY( cy ), c->WorldNumber() ); // check 3 cols... do we really NEED to?
|
|
if( MapArea ){ // no valid region
|
|
|
|
auto regChars = MapArea->GetCharList();
|
|
for (const auto &tempChar : regChars->collection()){
|
|
if( ValidateObject( tempChar ) && tempChar->GetInstanceID() == c->GetInstanceID() ) {
|
|
if( tempChar != c && ( ( isOnline( (*tempChar) ) && !tempChar->IsDead() ) || tempChar->IsNpc() ) ) { // x=x,y=y, and distance btw z's <= MAX STEP
|
|
if( tempChar->GetX() == cx && tempChar->GetY() == cy && tempChar->GetZ() >= cz && tempChar->GetZ() <= (cz + 5) ){
|
|
// 2 people will still bump into each other, if slightly offset
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
//| Function - bool VerifySequence( CChar *c, CSocket *mSock, SI16 sequence )
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
//| Purpose - Verifies if walk sequence is in sync, and if not, denies movement
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
bool cMovement::VerifySequence( CChar *c, CSocket *mSock, SI16 sequence )
|
|
{
|
|
if( mSock != nullptr )
|
|
{
|
|
if( mSock->WalkSequence() + 1 != sequence && sequence != 256 )
|
|
{
|
|
deny( mSock, c, sequence );
|
|
return false;
|
|
}
|
|
else if( mSock->WalkSequence() == sequence )
|
|
{
|
|
deny( mSock, c, sequence );
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
//| Function - bool CheckForRunning( CChar *c, UI08 dir )
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
//| Purpose - Checks if character is running, and updates character accordingly
|
|
//| Notes - returns true if updatechar required, or false if not
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
bool cMovement::CheckForRunning( CChar *c, UI08 dir )
|
|
{
|
|
// if we are running
|
|
if( dir&0x80 )
|
|
{
|
|
// if we are using stealth
|
|
if( c->GetStealth() != -1 ) // Stealth - stop hiding if player runs
|
|
c->ExposeToView();
|
|
//Don't regenerate stamina while running
|
|
c->SetRegen( cwmWorldState->ServerData()->BuildSystemTimeValue( tSERVER_STAMINAREGEN ), 1 );
|
|
c->SetRunning( c->GetRunning() + 1 );
|
|
|
|
if( !c->IsDead() && c->GetCommandLevel() < CL_CNS )
|
|
{
|
|
bool reduceStamina = (( c->IsFlying() || c->IsOnHorse() ) && c->GetRunning() > ( cwmWorldState->ServerData()->MaxStaminaMovement() * 2 ) );
|
|
if( !reduceStamina )
|
|
reduceStamina = ( c->GetRunning() > ( cwmWorldState->ServerData()->MaxStaminaMovement() * 4 ) );
|
|
if( reduceStamina )
|
|
{
|
|
c->SetRunning( 1 );
|
|
c->SetStamina( c->GetStamina() - 1 );
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
c->SetRunning( 0 );
|
|
}
|
|
return true;
|
|
}
|
|
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
//| Function - bool CheckForStealth( CChar *c )
|
|
//| Date - 09/22/2002
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
//| Purpose - Check to see if character is in stealth mode.
|
|
//|
|
|
//| Changes - 09/22/2002 - Unhide characters who are mounted while trying to stealth.
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
bool cMovement::CheckForStealth( CChar *c )
|
|
{
|
|
if( c->GetVisible() == VT_TEMPHIDDEN || c->GetVisible() == VT_INVISIBLE )
|
|
{
|
|
if( c->IsOnHorse() || c->IsFlying() ) // Consider Gargoyle flying as mounted for this context
|
|
{
|
|
if( !cwmWorldState->ServerData()->CharHideWhileMounted() )
|
|
c->ExposeToView();
|
|
}
|
|
//
|
|
if( c->GetStealth() != -1 )
|
|
{
|
|
c->SetStealth( c->GetStealth() + 1 );
|
|
if( c->GetStealth() > ( cwmWorldState->ServerData()->MaxStealthMovement() * c->GetSkill( STEALTH ) / 1000 ))
|
|
{
|
|
c->ExposeToView();
|
|
auto cSock = c->GetSocket();
|
|
if( cSock != nullptr )
|
|
{
|
|
cSock->sysmessage( 6250 ); // You step out of the shadows
|
|
}
|
|
}
|
|
}
|
|
else
|
|
c->ExposeToView();
|
|
}
|
|
return true;
|
|
}
|
|
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
//| Function - bool CheckForHouseBan( CChar *c, CSocket *mSock )
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
//| Purpose - See if a player has tried to move into a house they were banned from
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
bool cMovement::CheckForHouseBan( CChar *c, CSocket *mSock )
|
|
{
|
|
CMultiObj *house = findMulti( c );
|
|
if( ValidateObject( house ) )
|
|
{
|
|
if( c->GetMultiObj() != house )
|
|
c->SetMulti( house );//Set them inside the multi!
|
|
}
|
|
else
|
|
{
|
|
if( c->GetMultiObj() != nullptr )
|
|
c->SetMulti( INVALIDSERIAL );
|
|
}
|
|
return true;
|
|
}
|
|
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
//| Function - bool MoveCharForDirection( CChar *c, SI16 newX, SI16 newY, SI08 newZ )
|
|
//| Date - 21/09/2000
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
//| Purpose - I already made sure I could move there (even the crazy XY block stuff) so
|
|
//| this IS a valid move. Just move the directions. Oh, and since I we already
|
|
//| have the GetX/YfromDir functions (and we need those) why don't we just
|
|
//| use them here?
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
void cMovement::MoveCharForDirection( CChar *c, SI16 newX, SI16 newY, SI08 newZ )
|
|
{
|
|
if( !c->IsNpc() )
|
|
{ // if we're a PC in combat, or casting, we want to break/adjust their timers
|
|
const bool casting = (c->IsCasting() || c->IsJSCasting());
|
|
if( ( c->IsAtWar() || c->GetAttacker() != nullptr || casting ) && isOnline( *c ) )
|
|
{ // if it's not an NPC, in combat or casting, and it's online
|
|
if( casting )
|
|
{
|
|
Effects->PlayStaticAnimation( c, 0x3735, 0, 30 );
|
|
Effects->PlaySound( c, 0x005C );
|
|
c->TextMessage( c->GetSocket(), 771, EMOTE, false );
|
|
c->StopSpell();
|
|
c->SetJSCasting( false );
|
|
}
|
|
}
|
|
}
|
|
MapRegion->ChangeRegion( c, newX, newY, c->WorldNumber() );
|
|
c->WalkXY( newX, newY );
|
|
c->WalkZ( newZ );
|
|
}
|
|
|
|
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
//| Function - void GetBlockingStatics( SI16 x, SI16 y, std::vector<tile_t> &xyblock, UI16 &xycount, UI08 worldNumber )
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
//| Purpose - Get a list of static items that block character movement
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
void cMovement::GetBlockingStatics( SI16 x, SI16 y, std::vector<tile_t> &xyblock, UI16 &xycount, UI08 worldNumber )
|
|
{
|
|
if( xycount >= XYMAX ) // don't overflow
|
|
return;
|
|
|
|
auto artwork = Map->artAt(x, y, worldNumber);
|
|
for (auto &art : artwork){
|
|
xyblock.push_back(art);
|
|
++xycount;
|
|
if( xycount >= XYMAX ) // don't overflow
|
|
break;
|
|
}
|
|
}
|
|
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
//| Function - void GetBlockingDynamics( SI16 x, SI16 y, std::vector<tile_t> xyblock, UI16 &xycount, UI08 worldNumber, UI16 instanceID )
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
//| Purpose - Get a list of dynamic items that block character movement
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
auto cMovement::GetBlockingDynamics( SI16 x, SI16 y,std::vector<tile_t> &xyblock, UI16 &xycount, UI08 worldNumber, UI16 instanceID ) ->void {
|
|
if( xycount < XYMAX ){ // don't overflow
|
|
for (auto &MapArea : MapRegion->PopulateList( x, y, worldNumber )){
|
|
if( MapArea){
|
|
auto regItems = MapArea->GetItemList();
|
|
for (const auto &tItem : regItems->collection()){
|
|
if( ValidateObject( tItem ) && tItem->GetInstanceID() == instanceID ){
|
|
if( !tItem->CanBeObjType( OT_MULTI ) ) {
|
|
#if DEBUG_WALKING
|
|
Console.print( oldstrutil::format( "DEBUG: Item X: %i\nItem Y: %i\n", tItem->GetX(), tItem->GetY() ));
|
|
#endif
|
|
if( tItem->GetX() == x && tItem->GetY() == y ) {
|
|
auto tile = tile_t(tiletype_t::dyn);
|
|
tile.tileid =tItem->GetID();
|
|
tile.altitude = tItem->GetZ();
|
|
tile.artInfo = &Map->SeekTile( tItem->GetID() );
|
|
xyblock.push_back(tile);
|
|
++xycount;
|
|
if( xycount >= XYMAX ){ // don't overflow
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
else if( std::abs( tItem->GetX() - x ) <= DIST_BUILDRANGE && std::abs( tItem->GetY() - y) <= DIST_BUILDRANGE ) { // implication, is, this is now a CMultiObj
|
|
const UI16 multiID = (tItem->GetID() - 0x4000);
|
|
SI32 length = 0;
|
|
|
|
if( !Map->multiExists( multiID )) {
|
|
Console.error( "Walking() - Bad length in multi file. Avoiding stall" );
|
|
auto map1 = Map->SeekMap( tItem->GetX(), tItem->GetY(), tItem->WorldNumber() );
|
|
|
|
|
|
if( map1.CheckFlag( TF_WET ) ) // is it water?
|
|
tItem->SetID( 0x4001 );
|
|
else
|
|
tItem->SetID( 0x4064 );
|
|
length = 0;
|
|
}
|
|
else {
|
|
for( auto &multi : Map->SeekMulti( multiID ).items ) {
|
|
if( multi.flag && (tItem->GetX() + multi.offsetx) == x && (tItem->GetY() + multi.offsety) == y ) {
|
|
auto tile = tile_t(tiletype_t::dyn);
|
|
tile.artInfo = &Map->SeekTile( multi.tileid );
|
|
tile.altitude = multi.altitude + tItem->GetZ();
|
|
xyblock.push_back(tile) ;
|
|
++xycount;
|
|
if( xycount >= XYMAX ){ // don't overflow
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
//| Function - void SendWalkToPlayer( CChar *c, CSocket *mSock, SI16 sequence )
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
//| Purpose - Actually send the walk command back to the player and increment the sequence
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
void cMovement::SendWalkToPlayer( CChar *c, CSocket *mSock, SI16 sequence )
|
|
{
|
|
if( mSock != nullptr )
|
|
{
|
|
CPWalkOK toSend;
|
|
|
|
toSend.SequenceNumber( mSock->GetByte( 2 ) );
|
|
if( c->GetVisible() != VT_VISIBLE )
|
|
toSend.FlagColour( 0 );
|
|
else
|
|
toSend.FlagColour( static_cast<UI08>(c->FlagColour( c )));
|
|
|
|
mSock->Send( &toSend );
|
|
mSock->WalkSequence( sequence );
|
|
if( mSock->WalkSequence() == 255 )
|
|
mSock->WalkSequence( 1 );
|
|
}
|
|
}
|
|
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
//| Function - void SendWalkToOtherPlayers( CChar *c, UI08 dir, SI16 oldx, SI16 oldy )
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
//| Purpose - Send the character's walk action to other players in range
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
void cMovement::SendWalkToOtherPlayers( CChar *c, UI08 dir, SI16 oldx, SI16 oldy )
|
|
{
|
|
// lets cache these vars in advance
|
|
const SI16 newx = c->GetX();
|
|
const SI16 newy = c->GetY();
|
|
|
|
bool checkX = (oldx != newx);
|
|
bool checkY = (oldy != newy);
|
|
UI16 effRange;
|
|
UI08 worldnumber = c->WorldNumber();
|
|
UI16 instanceID = c->GetInstanceID();
|
|
|
|
CPExtMove toSend = (*c);
|
|
|
|
for (auto &tSend : Network->connClients) {
|
|
if( tSend ){
|
|
auto mChar = tSend->CurrcharObj();
|
|
if( ValidateObject( mChar ) ){
|
|
if( (worldnumber == mChar->WorldNumber()) && (instanceID == mChar->GetInstanceID()) ){
|
|
|
|
effRange = static_cast<UI16>( tSend->Range() );
|
|
const auto visibleRange = static_cast<UI16>( tSend->Range() + Races->VisRange( mChar->GetRace() ));
|
|
if( visibleRange >= effRange ){
|
|
effRange = visibleRange;
|
|
}
|
|
|
|
if( c != mChar ){
|
|
// We need to ensure they are within range of our X AND Y location regardless of how they moved.
|
|
const auto dxNew = static_cast<UI16>(abs( newx - mChar->GetX() ));
|
|
const auto dyNew = static_cast<UI16>(abs( newy - mChar->GetY() ));
|
|
if( checkX && dyNew <= (effRange+2) ){
|
|
// Only check X Plane if their x changed
|
|
UI16 dxOld = static_cast<UI16>(abs( oldx - mChar->GetX() ));
|
|
if( ( dxNew == effRange ) && ( dxOld > effRange ) ){
|
|
c->SendToSocket( tSend );
|
|
continue; // Incase they moved diagonally, lets not update the same character multiple times
|
|
}
|
|
else if( ( dxNew > (effRange+1) ) && ( dxOld == (effRange+1) ) ){
|
|
c->RemoveFromSight( tSend );
|
|
continue; // Incase they moved diagonally, lets not update the same character multiple times
|
|
}
|
|
}
|
|
if( checkY && dxNew <= (effRange+2) ){
|
|
// Only check Y plane if their y changed
|
|
UI16 dyOld = static_cast<UI16>(abs( oldy - mChar->GetY() ));
|
|
if( ( dyNew == effRange ) && ( dyOld > effRange ) ){
|
|
c->SendToSocket( tSend );
|
|
continue;
|
|
}
|
|
else if( ( dyNew > (effRange+1) ) && ( dyOld == (effRange+1) ) ){
|
|
c->RemoveFromSight( tSend );
|
|
continue;
|
|
}
|
|
}
|
|
toSend.FlagColour( static_cast<UI08>(c->FlagColour( mChar )) );
|
|
tSend->Send( &toSend );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
//| Function - void OutputShoveMessage( CChar *c, CSocket *mSock )
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
//| Purpose - See if we should mention that we shove something out of the way
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
auto cMovement::OutputShoveMessage( CChar *c, CSocket *mSock ) ->void {
|
|
if( mSock){
|
|
|
|
// GMs, counselors, and ghosts don't shove things
|
|
if( c->GetCommandLevel() < CL_CNS && !IsGMBody( c ) ){
|
|
// lets cache these vars in advance
|
|
auto grid = MapRegion->GetMapRegion( c );
|
|
if( grid){
|
|
|
|
auto regChars = grid->GetCharList();
|
|
bool didShove = false;
|
|
const SI16 x = c->GetX();
|
|
const SI16 y = c->GetY();
|
|
const SI08 z = c->GetZ();
|
|
const UI16 instanceID = c->GetInstanceID();
|
|
|
|
std::vector<UI16> scriptTriggers = c->GetScriptTriggers();
|
|
std::vector<UI16> ourScriptTriggers;
|
|
cScript *toExecute;
|
|
for (const auto &ourChar : regChars->collection()){
|
|
if( ValidateObject( ourChar ) && ourChar != c && ourChar->GetInstanceID() == instanceID ){
|
|
if( ourChar->GetX() == x && ourChar->GetY() == y && std::abs(ourChar->GetZ() - z ) <= 4 ) {
|
|
if(( ourChar->GetVisible() != VT_PERMHIDDEN )
|
|
&& ( !IsGMBody( ourChar )
|
|
&& ( ourChar->IsNpc() || isOnline( (*ourChar) ) ) && ourChar->GetCommandLevel() < CL_CNS )) {
|
|
// Assume character shoved other character
|
|
didShove = true;
|
|
|
|
// Run onCollide event on character doing the shoving
|
|
for( auto scriptTrig : scriptTriggers ) {
|
|
toExecute = JSMapping->GetScript( scriptTrig );
|
|
if( toExecute ) {
|
|
auto retVal = toExecute->OnCollide( mSock, c, ourChar );
|
|
if( retVal == 0 ) {
|
|
// Event found, script returned false. Disallow hardcoded functionality, but keep checking
|
|
didShove = false;
|
|
}
|
|
else if( retVal == 1 ) {
|
|
// Event found, script returned true. Allow hardcoded functionality
|
|
didShove = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Run onCollide event on character being shoved
|
|
ourScriptTriggers.clear();
|
|
ourScriptTriggers.shrink_to_fit();
|
|
ourScriptTriggers = ourChar->GetScriptTriggers();
|
|
for( auto scriptTrig : ourScriptTriggers ) {
|
|
toExecute = JSMapping->GetScript( scriptTrig );
|
|
if( toExecute) {
|
|
auto retVal = toExecute->OnCollide( ourChar->GetSocket(), c, ourChar );
|
|
if( retVal == 0 ) {
|
|
// Event found, script returned false. Disallow hardcoded functionality, but keep checking
|
|
didShove = false;
|
|
}
|
|
else if( retVal == 1 ) {
|
|
// Event found, script returned true. Allow hardcoded functionality
|
|
didShove = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if( ourChar->GetVisible() == VT_TEMPHIDDEN || ourChar->GetVisible() == VT_INVISIBLE ) {
|
|
mSock->sysmessage( 1384 ); // Being perfectly rested, you shove something invisible out of the way.
|
|
}
|
|
else {
|
|
std::string charName = getNpcDictName( ourChar );
|
|
mSock->sysmessage( 1383, charName.c_str() ); // Being perfectly rested, you shove %s out of the way.
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if( didShove ){
|
|
c->SetStamina( std::max( c->GetStamina() - 4, 0 ) );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
//| Function - void DoJSInRange( CBaseObject *mObj, CBaseObject *objInRange )
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
//| Purpose - Trigger InRange JS event
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
void DoJSInRange( CBaseObject *mObj, CBaseObject *objInRange )
|
|
{
|
|
std::vector<UI16> scriptTriggers = mObj->GetScriptTriggers();
|
|
for( auto scriptTrig : scriptTriggers )
|
|
{
|
|
cScript *toExecute = JSMapping->GetScript( scriptTrig );
|
|
if( toExecute != nullptr )
|
|
{
|
|
toExecute->InRange( mObj, objInRange );
|
|
}
|
|
}
|
|
}
|
|
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
//| Function - void DoJSOutOfRange( CBaseObject *mObj, CBaseObject *objOutOfRange )
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
//| Purpose - Trigger OutOfRange JS event
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
void DoJSOutOfRange( CBaseObject *mObj, CBaseObject *objOutOfRange )
|
|
{
|
|
std::vector<UI16> scriptTriggers = mObj->GetScriptTriggers();
|
|
for( auto scriptTrig : scriptTriggers )
|
|
{
|
|
cScript *toExecute = JSMapping->GetScript( scriptTrig );
|
|
if( toExecute != nullptr )
|
|
{
|
|
toExecute->OutOfRange( mObj, objOutOfRange );
|
|
}
|
|
}
|
|
}
|
|
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
//| Function - bool UpdateItemsOnPlane( CSocket *mSock, CChar *mChar, CItem *tItem, UI16 id, UI16 dNew, UI16 dOld, UI16 visibleRange, bool isGM )
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
//| Purpose - Update items that come within range or go out of range of the player
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
bool UpdateItemsOnPlane( CSocket *mSock, CChar *mChar, CItem *tItem, UI16 id, UI16 dNew, UI16 dOld, UI16 visibleRange, bool isGM )
|
|
{
|
|
if( isGM || tItem->GetVisible() == VT_VISIBLE || ( tItem->GetVisible() == VT_TEMPHIDDEN && tItem->GetOwnerObj() == mChar ) )
|
|
{
|
|
if( mSock != nullptr && ( (id >= 0x407A && id <= 0x407F) || id == 0x5388 ) )
|
|
{
|
|
if( dNew == DIST_BUILDRANGE && dOld > DIST_BUILDRANGE ) // It's a large building
|
|
{
|
|
tItem->SendToSocket( mSock );
|
|
return true;
|
|
}
|
|
else if( dOld == DIST_BUILDRANGE && dNew > DIST_BUILDRANGE )
|
|
{
|
|
tItem->RemoveFromSight( mSock );
|
|
return true;
|
|
}
|
|
}
|
|
else if( dNew == visibleRange && dOld > visibleRange ) // Just came into range
|
|
{
|
|
if( mSock != nullptr )
|
|
tItem->SendToSocket( mSock );
|
|
DoJSInRange( mChar, tItem );
|
|
DoJSInRange( tItem, mChar );
|
|
return true;
|
|
}
|
|
else if( dOld == (visibleRange+1) && dNew > (visibleRange+1) ) // Just went out of range
|
|
{
|
|
#pragma note( "Is it necessary to send packets with item removal when they go out of range, or does client handle this itself?" )
|
|
if( mSock != nullptr )
|
|
tItem->RemoveFromSight( mSock );
|
|
DoJSOutOfRange( mChar, tItem );
|
|
DoJSOutOfRange( tItem, mChar );
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
//| Function - bool UpdateCharsOnPlane( CSocket *mSock, CChar *mChar, CChar *tChar, UI16 dNew, UI16 dOld, UI16 visibleRange )
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
//| Purpose - Update characters that come within range or go out of range of the player
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
bool UpdateCharsOnPlane( CSocket *mSock, CChar *mChar, CChar *tChar, UI16 dNew, UI16 dOld, UI16 visibleRange )
|
|
{
|
|
if( dNew == visibleRange && dOld > visibleRange ) // Just came into range
|
|
{
|
|
if( mSock != nullptr )
|
|
tChar->SendToSocket( mSock );
|
|
DoJSInRange( mChar, tChar );
|
|
DoJSInRange( tChar, mChar );
|
|
return true;
|
|
}
|
|
if( dOld == (visibleRange+1) && dNew > (visibleRange+1) ) // Just went out of range
|
|
{
|
|
if( mSock != nullptr )
|
|
tChar->RemoveFromSight( mSock );
|
|
DoJSOutOfRange( mChar, tChar );
|
|
DoJSOutOfRange( tChar, mChar );
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void MonsterGate( CChar *s, const std::string& scriptEntry );
|
|
void advanceObj( CChar *s, UI16 x, bool multiUse );
|
|
void SocketMapChange( CSocket *sock, CChar *charMoving, CItem *gate );
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
//| Function - void HandleObjectCollisions( CSocket *mSock, CChar *mChar, CItem *itemCheck, ItemTypes type )
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
//| Purpose - Handle character collision with items of various item types
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
void HandleObjectCollisions( CSocket *mSock, CChar *mChar, CItem *itemCheck, ItemTypes type )
|
|
{
|
|
switch( type )
|
|
{
|
|
case IT_OBJTELEPORTER: // teleporters
|
|
if( itemCheck->GetTempVar( CITV_MOREX ) + itemCheck->GetTempVar( CITV_MOREY ) + itemCheck->GetTempVar( CITV_MOREZ ) > 0 )
|
|
mChar->SetLocation( static_cast<UI16>(itemCheck->GetTempVar( CITV_MOREX )), static_cast<UI16>(itemCheck->GetTempVar( CITV_MOREY )), static_cast<SI08>(itemCheck->GetTempVar( CITV_MOREZ )) );
|
|
break;
|
|
case IT_ADVANCEGATE: // advancement gates
|
|
case IT_MULTIADVANCEGATE:
|
|
if( !mChar->IsNpc() )
|
|
advanceObj( mChar, static_cast<UI16>(itemCheck->GetTempVar( CITV_MOREX )), ( itemCheck->GetType() == IT_MULTIADVANCEGATE ) );
|
|
break;
|
|
case IT_MONSTERGATE: MonsterGate( mChar, itemCheck->GetDesc() ); break; // monster gates
|
|
case IT_RACEGATE: // race gates
|
|
Races->gate( mChar, static_cast<RACEID>(itemCheck->GetTempVar( CITV_MOREX )), itemCheck->GetTempVar( CITV_MOREY ) != 0 );
|
|
break;
|
|
case IT_DAMAGEOBJECT: // damage objects
|
|
if( !mChar->IsInvulnerable() )
|
|
{
|
|
[[maybe_unused]] bool retVal = mChar->Damage( itemCheck->GetTempVar( CITV_MOREX ) + RandomNum( itemCheck->GetTempVar( CITV_MOREY ), itemCheck->GetTempVar( CITV_MOREZ ) ), PHYSICAL, nullptr );
|
|
}
|
|
break;
|
|
case IT_SOUNDOBJECT: // sound objects
|
|
if( static_cast<UI32>(RandomNum( 1, 100 )) <= itemCheck->GetTempVar( CITV_MOREZ ) )
|
|
Effects->PlaySound( itemCheck, static_cast<UI16>(itemCheck->GetTempVar( CITV_MOREX )) );
|
|
break;
|
|
case IT_MAPCHANGEOBJECT:
|
|
SocketMapChange( mSock, mChar, itemCheck );
|
|
break;
|
|
case IT_ZEROKILLSGATE: mChar->SetKills( 0 ); break; // zero kill gate
|
|
case IT_WORLDCHANGEGATE:
|
|
if( !mChar->IsNpc() ) // world change gate
|
|
{
|
|
if( mSock != nullptr )
|
|
{
|
|
CPWorldChange wrldChange( (WorldType)itemCheck->GetTempVar( CITV_MOREX ), 1 );
|
|
mSock->Send( &wrldChange );
|
|
}
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
//| Function - void HandleItemCollision( CChar *mChar, CSocket *mSock, SI16 oldx, SI16 oldy )
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
//| Purpose - Handle item collisions, make items that appear on the edge of our sight because
|
|
//| visible, buildings when they get in range, and if the character steps on something
|
|
//| that might cause damage
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
void cMovement::HandleItemCollision( CChar *mChar, CSocket *mSock, SI16 oldx, SI16 oldy )
|
|
{
|
|
// lets cache these vars in advance
|
|
UI16 visibleRange = static_cast<UI16>(MAX_VISRANGE + Races->VisRange( mChar->GetRace() ));
|
|
if( mSock != nullptr )
|
|
visibleRange = static_cast<UI16>(mSock->Range() + Races->VisRange( mChar->GetRace() ));
|
|
|
|
const SI16 newx = mChar->GetX();
|
|
const SI16 newy = mChar->GetY();
|
|
const UI16 instanceID = mChar->GetInstanceID();
|
|
UI16 id;
|
|
ItemTypes type;
|
|
bool EffRange;
|
|
bool inMoveDetectRange = false;
|
|
UI08 moveDetectRange = 1;
|
|
|
|
bool isGM = mChar->IsGM();
|
|
UI16 dxNew, dyNew, dxOld, dyOld;
|
|
const bool checkX = (oldx != newx);
|
|
const bool checkY = (oldy != newy);
|
|
/*
|
|
A note to future people (from 2/10/02)
|
|
|
|
The OSI client MAY be ignoring certain items that it thinks fall out of the vis Range...
|
|
|
|
Currently, UOX calculates vis in a square... meaning if an item in the corner of our
|
|
'square' is sent to the OSI client, it MAY ignore it because it falls out of the client's
|
|
apparent circle of visibility.
|
|
|
|
At this time, I'm not sure this is causing problems, or whether problems are steming from
|
|
a region issue (fixed now). So I have not updated this code. If this problem pops up in
|
|
the future, and I'm no longer around... This is your piece of the puzzle.
|
|
|
|
Update from future people (from 23/05/2021):
|
|
While UOX calculated vis in a square during movement, it calculated vis in a radius on logins,
|
|
teleports, object additions/removals. This means someone could log in, get sent all objects
|
|
within a radius of X, then when they started moving, they would get sent all objects entering
|
|
a square boundary around character (with distance X) - skipping any objects trapped in the
|
|
area between the circle and the square.
|
|
|
|
Logins, teleports, object additions and removals all now calculate vis range via square
|
|
pattern instead of a circular one, which seems to fix most of these 20+ year old issues.
|
|
*/
|
|
std::vector<UI16> scriptTriggers = mChar->GetScriptTriggers();
|
|
std::vector<UI16> itemScriptTriggers;
|
|
for (auto &MapArea : MapRegion->PopulateList( newx, newy, mChar->WorldNumber())){
|
|
if( MapArea){
|
|
if( mSock ) { // Only send char stuff if we have a valid socket
|
|
auto regChars = MapArea->GetCharList();
|
|
for (const auto &tempChar : regChars->collection()){
|
|
if( ValidateObject( tempChar ) && tempChar->GetInstanceID() == instanceID ){
|
|
// Character Send Stuff
|
|
if( tempChar->IsNpc() || isOnline( (*tempChar) ) || ( isGM && cwmWorldState->ServerData()->ShowOfflinePCs() ) ) {
|
|
dxNew = static_cast<UI16>(abs( tempChar->GetX() - newx ));
|
|
dyNew = static_cast<UI16>(abs( tempChar->GetY() - newy ));
|
|
if( checkX && dyNew <= (visibleRange+2) ) {// Only update on x plane if our x changed
|
|
dxOld = static_cast<UI16>(abs( tempChar->GetX() - oldx ));
|
|
if( UpdateCharsOnPlane( mSock, mChar, tempChar, dxNew, dxOld, visibleRange ) ){
|
|
continue; // If we moved diagonally, don't update the same char twice.
|
|
}
|
|
}
|
|
if( checkY && dxNew <= (visibleRange+2) ){ // Only update on y plane if our y changed
|
|
dyOld = static_cast<UI16>(abs( tempChar->GetY() - oldy ));
|
|
|
|
if( UpdateCharsOnPlane( mSock, mChar, tempChar, dyNew, dyOld, visibleRange ) ){
|
|
continue; // ?? this will continue anyway
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
auto regItems = MapArea->GetItemList();
|
|
for (const auto &tItem: regItems->collection()){
|
|
if( ValidateObject( tItem ) && tItem->GetInstanceID() == instanceID ){
|
|
id = tItem->GetID();
|
|
type = tItem->GetType();
|
|
EffRange = ( tItem->GetX() == newx && tItem->GetY() == newy &&
|
|
std::abs(mChar->GetZ() - tItem->GetZ()) <= 4 );
|
|
|
|
// Get max movement detection range from item's MORE property (part 1)
|
|
moveDetectRange = tItem->GetTempVar( CITV_MORE, 1 );
|
|
|
|
// Determine if character is moving within the moveDetectRange limit
|
|
inMoveDetectRange = ( std::abs(tItem->GetX() - newx) <= moveDetectRange && std::abs(tItem->GetY() - newy) <= moveDetectRange &&
|
|
std::abs(mChar->GetZ() - tItem->GetZ()) <= 5 );
|
|
|
|
if( EffRange || inMoveDetectRange ) {
|
|
if( !Magic->HandleFieldEffects( mChar, tItem, id )) {
|
|
if( !tItem->CanBeObjType( OT_MULTI )) {
|
|
bool scriptExecuted = false;
|
|
auto scriptTriggers = tItem->GetScriptTriggers();
|
|
for( auto i : scriptTriggers ) {
|
|
// Loop through all scriptIDs registered for item, check for scripts
|
|
cScript *toExecute = JSMapping->GetScript( i );
|
|
if( toExecute) {
|
|
if( EffRange ) {
|
|
// Script was found, let's check for onCollide event
|
|
SI08 retVal = toExecute->OnCollide( mSock, mChar, tItem );
|
|
if( retVal != -1 ) {
|
|
scriptExecuted = true;
|
|
if( retVal == 1 ) {
|
|
// Script returned 1 - don't continue with other scripts on item
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if( inMoveDetectRange ) {
|
|
UI08 rangeToChar = getDist( point3(tItem->GetX(), tItem->GetY(), tItem->GetZ()), point3(newx, newy, mChar->GetZ()) );
|
|
|
|
// Script was found, let's check for onMoveDetect event
|
|
SI08 retVal = toExecute->OnMoveDetect( tItem, mChar, rangeToChar, oldx, oldy );
|
|
if( retVal != -1 ) {
|
|
scriptExecuted = true;
|
|
if( retVal == 1 ) {
|
|
// Script returned 1 - don't continue with other scripts on item
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Handle envoke stuff outside for loop, as we only want this to execute once
|
|
cScript *toExecute = nullptr;
|
|
if( scriptTriggers.size() == 0 || !scriptExecuted ) {
|
|
UI16 envTrig = 0;
|
|
if( JSMapping->GetEnvokeByType()->Check( static_cast<UI16>(type) ) ) {
|
|
envTrig = JSMapping->GetEnvokeByType()->GetScript( static_cast<UI16>(type) );
|
|
toExecute = JSMapping->GetScript( envTrig );
|
|
}
|
|
else if( JSMapping->GetEnvokeByID()->Check( id ) ) {
|
|
envTrig = JSMapping->GetEnvokeByID()->GetScript( id );
|
|
toExecute = JSMapping->GetScript( envTrig );
|
|
}
|
|
}
|
|
|
|
if( toExecute ) {
|
|
if( EffRange ) {
|
|
// We don't care about the return value from onCollide here, so suppress the warning
|
|
[[maybe_unused]] SI08 retVal = toExecute->OnCollide( mSock, mChar, tItem );
|
|
}
|
|
if( inMoveDetectRange ) {
|
|
UI08 rangeToChar = getDist( point3(tItem->GetX(), tItem->GetY(), tItem->GetZ()), point3(newx, newy, mChar->GetZ()) );
|
|
|
|
// We don't care about the return value from onCollide here, so suppress the warning
|
|
[[maybe_unused]] SI08 retVal = toExecute->OnMoveDetect( tItem, mChar, rangeToChar, oldx, oldy );
|
|
}
|
|
}
|
|
|
|
// Ok let's trigger onCollide for the character as well
|
|
if( EffRange ) {
|
|
std::vector<UI16> charScriptTriggers = mChar->GetScriptTriggers();
|
|
for( auto scriptTrig : charScriptTriggers ) {
|
|
toExecute = JSMapping->GetScript( scriptTrig );
|
|
if( toExecute) {
|
|
if( toExecute->OnCollide( mSock, mChar, tItem ) == 1 ) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if( EffRange ) {
|
|
HandleObjectCollisions( mSock, mChar, tItem, type );
|
|
Magic->GateCollision( mSock, mChar, tItem, type );
|
|
}
|
|
}
|
|
|
|
dxNew = static_cast<UI16>(abs( tItem->GetX() - newx ));
|
|
dyNew = static_cast<UI16>(abs( tItem->GetY() - newy ));
|
|
if( checkX && dyNew <= (visibleRange+2) ) // Only update items on furthest x plane if our x changed
|
|
{
|
|
dxOld = static_cast<UI16>(abs( tItem->GetX() - oldx ));
|
|
if( UpdateItemsOnPlane( mSock, mChar, tItem, id, dxNew, dxOld, visibleRange, isGM ) )
|
|
continue; // If we moved diagonally, lets not update an item twice (since it could match the furthest x and y)
|
|
}
|
|
if( checkY && dxNew <= (visibleRange+2) ) {
|
|
// Only update items on furthest y plane if our y changed
|
|
|
|
dyOld = static_cast<UI16>(abs( tItem->GetY() - oldy ));
|
|
if( UpdateItemsOnPlane( mSock, mChar, tItem, id, dyNew, dyOld, visibleRange, isGM ) ){
|
|
continue; // ?????
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
//| Function - bool IsGMBody( CChar *c )
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
//| Purpose - Checks if character's body is to be considered a GM body for the purposes of
|
|
//| shove messages and walking through doors.
|
|
//| Includes GMs, Counsellors, and Ghosts; Better name may be IsEthereal()
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
bool cMovement::IsGMBody( CChar *c )
|
|
{
|
|
if( c->IsGM() || c->GetID() == 0x03DB || c->GetID() == 0x0192 ||
|
|
c->GetID() == 0x0193 || c->GetID() == 0x025F || c->GetID() == 0x0260 ||
|
|
c->GetID() == 0x02B6 || c->GetID() == 0x02B7 || c->IsDead() )
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
//| Function - void CombatWalk( CChar *i )
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
//| Purpose - Send combat toggle to nearby players. Only for switching to combat mode
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
void cMovement::CombatWalk( CChar *i )
|
|
{
|
|
if( !ValidateObject( i ) )
|
|
return;
|
|
CPExtMove toSend = (*i);
|
|
|
|
if( !i->IsAtWar() )
|
|
i->SetTarg( nullptr );
|
|
|
|
for (auto &sock : FindNearbyPlayers( i )){
|
|
CChar *mChar = sock->CurrcharObj();
|
|
if( mChar != i )
|
|
{
|
|
toSend.FlagColour( static_cast<UI08>(i->FlagColour( mChar )) );
|
|
sock->Send( &toSend );
|
|
}
|
|
}
|
|
}
|
|
|
|
bool checkBoundingBox( SI16 xPos, SI16 yPos, SI16 fx1, SI16 fy1, SI08 fz1, SI16 fx2, SI16 fy2, UI08 worldNumber, UI16 instanceID );
|
|
bool checkBoundingCircle( SI16 xPos, SI16 yPos, SI16 fx1, SI16 fy1, SI08 fz1, SI16 radius, UI08 worldNumber, UI16 instanceID );
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
//| Function - void NpcWalk( CChar *i, UI08 j, SI08 getWander )
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
//| Purpose - Handle NPCs walking in boxes and circles
|
|
//| Notes - getWander is npcwalk mode (0 for normal, 1 for follow, 2 for free, 3 for box,
|
|
//| 4 for circle, 5 for frozen, 6 for flee, 7 for pathfind
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
void cMovement::NpcWalk( CChar *i, UI08 j, SI08 getWander )
|
|
{
|
|
const SI16 fx1 = i->GetFx( 0 );
|
|
const SI16 fx2 = i->GetFx( 1 );
|
|
const SI16 fy1 = i->GetFy( 0 );
|
|
const SI16 fy2 = i->GetFy( 1 );
|
|
const SI08 fz1 = i->GetFz();
|
|
// if we are walking in an area, and the area is not properly defined, just don't bother with the area anymore
|
|
if( ( ( getWander == WT_BOX ) && ( fx1 == -1 || fx2 == -1 || fy1 == -1 || fy2 == -1 ) ) ||
|
|
( ( getWander == WT_CIRCLE ) && ( fx1 == -1 || fx2 == -1 || fy1 == -1 ) ) ) // circle's don't use fy2, so don't require them! 10/30/1999
|
|
{
|
|
i->SetNpcWander( WT_FREE ); // Wander freely from now on
|
|
}
|
|
// New Stuff 2000.09.21
|
|
const SI16 newx = GetXfromDir( j, i->GetX() );
|
|
const SI16 newy = GetYfromDir( j, i->GetY() );
|
|
const UI08 worldNumber = i->WorldNumber();
|
|
const UI16 instanceID = i->GetInstanceID();
|
|
// Let's make this a little more readable.
|
|
const UI08 jMod = (j & 0x87);
|
|
bool pathFound = true;
|
|
UI16 fx2Actual = 0;
|
|
UI16 fy2Actual = 0;
|
|
switch( getWander )
|
|
{
|
|
case WT_FREE: // Wander freely
|
|
case WT_FLEE: // Wander freely after fleeing
|
|
Walking( nullptr, i, jMod, 256 );
|
|
break;
|
|
case WT_BOX: // Wander inside a box
|
|
if( checkBoundingBox( newx, newy, fx1, fy1, fz1, fx2, fy2, worldNumber, instanceID ) )
|
|
{
|
|
Walking( nullptr, i, jMod, 256 );
|
|
}
|
|
// The NPC is outside it's area, send it back
|
|
else if( !checkBoundingBox( i->GetX(), i->GetY(), fx1, fy1, fz1, fx2, fy2, worldNumber, instanceID ) )
|
|
{
|
|
i->SetOldNpcWander( WT_BOX );
|
|
i->SetNpcWander( WT_PATHFIND );
|
|
|
|
if( cwmWorldState->ServerData()->AdvancedPathfinding() )
|
|
pathFound = AdvancedPathfinding( i, fx1, fy1, true );
|
|
else
|
|
PathFind( i, fx1, fy2, true );
|
|
|
|
fx2Actual = fx2;
|
|
fy2Actual = fy2;
|
|
|
|
if( pathFound )
|
|
{
|
|
j = i->PopDirection();
|
|
Walking( nullptr, i, j, 256 );
|
|
}
|
|
}
|
|
break;
|
|
case WT_CIRCLE: // Wander inside a circle
|
|
if( checkBoundingCircle( newx, newy, fx1, fy1, fz1, fx2, worldNumber, instanceID ) )
|
|
{
|
|
Walking( nullptr, i, jMod, 256 );
|
|
}
|
|
// The NPC is outside it's area, send it back
|
|
else if( !checkBoundingCircle( i->GetX(), i->GetY(), fx1, fy1, fz1, fx2, worldNumber, instanceID ) )
|
|
{
|
|
i->SetOldNpcWander( WT_CIRCLE );
|
|
i->SetNpcWander( WT_PATHFIND );
|
|
if( cwmWorldState->ServerData()->AdvancedPathfinding() )
|
|
pathFound = AdvancedPathfinding( i, fx1, fy1, true );
|
|
else
|
|
PathFind( i, fx1, fy2, true );
|
|
|
|
fx2Actual = fx1 + fx2;
|
|
fy2Actual = fy1 + fx2;
|
|
|
|
if( pathFound )
|
|
{
|
|
j = i->PopDirection();
|
|
Walking( nullptr, i, j, 256 );
|
|
}
|
|
}
|
|
break;
|
|
default:
|
|
Console.error( oldstrutil::format("Bad NPC Wander type passed to NpcWalk: %i", getWander ));
|
|
break;
|
|
}
|
|
// If path back can't be found, use alternative route - through the magical ether! (teleport)
|
|
if( cwmWorldState->ServerData()->AdvancedPathfinding() && !pathFound )
|
|
BoundingBoxTeleport( i, fx2Actual, fy2Actual, newx, newy );
|
|
}
|
|
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
//| Function - void BoundingBoxTeleport( CChar *nChar, UI16 fx2Actual, UI16 fy2Actual, SI16 newx, SI16 newy )
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
//| Purpose - Teleport NPC back to BoundingBox if path wasn't found
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
void cMovement::BoundingBoxTeleport( CChar *nChar, UI16 fx2Actual, UI16 fy2Actual, SI16 newx, SI16 newy )
|
|
{
|
|
const SI16 fx1 = nChar->GetFx( 0 );
|
|
const SI16 fx2 = nChar->GetFx( 1 );
|
|
const SI16 fy1 = nChar->GetFy( 0 );
|
|
const SI16 fy2 = nChar->GetFy( 1 );
|
|
const SI08 fz1 = nChar->GetFz();
|
|
const UI08 worldNumber = nChar->WorldNumber();
|
|
const UI16 instanceID = nChar->GetInstanceID();
|
|
bool checkSuccess = true;
|
|
|
|
if( !nChar->GetOldNpcWander() )
|
|
nChar->SetOldNpcWander( nChar->GetNpcWander() );
|
|
|
|
switch( nChar->GetOldNpcWander() )
|
|
{
|
|
case WT_BOX:
|
|
if( !checkBoundingBox( newx, newy, fx1, fy1, fz1, fx2, fy2, worldNumber, instanceID ))
|
|
checkSuccess = false;
|
|
break;
|
|
case WT_CIRCLE:
|
|
if( !checkBoundingCircle( newx, newy, fx1, fy1, fz1, fx2, worldNumber, instanceID ) )
|
|
checkSuccess = false;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
if( checkSuccess == false )
|
|
{
|
|
bool boundingBoxTeleport = false;
|
|
bool waterWalk = cwmWorldState->creatures[nChar->GetID()].IsWater();
|
|
bool amphibWalk = cwmWorldState->creatures[nChar->GetID()].IsAmphibian();
|
|
for( UI16 m = fx1; m < fx2Actual; m++ )
|
|
{
|
|
for( UI16 n = fy1; n < fy2Actual; n++ )
|
|
{
|
|
if(( !waterWalk || amphibWalk ) && Map->ValidSpawnLocation( m, n, fz1, worldNumber, false ))
|
|
{
|
|
boundingBoxTeleport = true;
|
|
}
|
|
else if( waterWalk && Map->ValidSpawnLocation( m, n, fz1, worldNumber, true ))
|
|
{
|
|
boundingBoxTeleport = true;
|
|
}
|
|
if( boundingBoxTeleport == true )
|
|
{
|
|
#if defined( UOX_DEBUG_MODE )
|
|
std::string charName = getNpcDictName( nChar );
|
|
Console.warning( oldstrutil::format("NPC: %s with serial 0x%X was unable to path back to bounding box, teleporting NPC back.\n", charName.c_str(), nChar->GetSerial() ));
|
|
#endif
|
|
nChar->SetLocation( m, n, fz1, nChar->WorldNumber(), nChar->GetInstanceID() );
|
|
nChar->SetNpcWander( nChar->GetOldNpcWander() );
|
|
nChar->SetOldNpcWander( WT_NONE );
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
// If a valid teleport-location hasn't been found at this point, despawn NPC
|
|
#if defined( UOX_DEBUG_MODE )
|
|
std::string charName = getNpcDictName( nChar );
|
|
Console.warning(oldstrutil::format("NPC: %s with serial 0x%X was unable to path back to bounding box, no valid teleport location found. Deleting NPC!\n", charName.c_str(), nChar->GetSerial()) );
|
|
#endif
|
|
nChar->Delete();
|
|
}
|
|
}
|
|
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
//| Function - SI16 GetYfromDir( UI08 dir, SI16 y )ewy )
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
//| Purpose - Return the new y from given dir
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
SI16 cMovement::GetYfromDir( UI08 dir, SI16 y )
|
|
{
|
|
switch( dir & 0x07 )
|
|
{
|
|
case NORTH:
|
|
case NORTHEAST:
|
|
case NORTHWEST:
|
|
--y;
|
|
break;
|
|
case SOUTH:
|
|
case SOUTHEAST:
|
|
case SOUTHWEST:
|
|
++y;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
return y;
|
|
}
|
|
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
//| Function - SI16 GetXfromDir( UI08 dir, SI16 x )
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
//| Purpose - Return the new x from given dir
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
SI16 cMovement::GetXfromDir( UI08 dir, SI16 x )
|
|
{
|
|
switch( dir & 0x07 )
|
|
{
|
|
case EAST:
|
|
case NORTHEAST:
|
|
case SOUTHEAST:
|
|
++x;
|
|
break;
|
|
case WEST:
|
|
case NORTHWEST:
|
|
case SOUTHWEST:
|
|
--x;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
return x;
|
|
}
|
|
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
//| Function - void PathFind( CChar *c, SI16 gx, SI16 gy, bool willRun, UI08 pathLen )
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
//| Purpose - Calculate a path from A to B for NPC movement
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
//| Notes - Ok, I'm going to babble here, but here's my thinking process...
|
|
//| Max Heuristic is 5 (for now) and I'm not concerned about walls... I'll add that later
|
|
//| Easiest way I think would be for recursive call for now... Will change later if need be
|
|
//| pathfind will call itself with new stuff... as long as the distance get's shorter
|
|
//| We have to take into consideration if the NPC is going to a point or to a character
|
|
//| if we don't want NPCs to walk over each other, this has to be known, because the NPC
|
|
//| that's walking will never reach destination if it's another character.
|
|
//| We must pass, that way if we get chardist=1 then we're ok. We are basically searching
|
|
//| for the shortest path, which is always a diagonal line, followed by lateral to target
|
|
//| (barring obstacles) On calculation, for the FIRST step, we need to know if a character
|
|
//| is there or not, then after that no biggie because if so we can just recalc the path if
|
|
//| something is blocking. If we don't check on that first step, NPCs will get stuck behind horses
|
|
//| and stuff... Kinda exploitable if I'm on a horse attacking, then step off and behind to hide
|
|
//| while I heal. The first thing we need to do when walking is determine if i'm blocked... then
|
|
//| if I'm an NPC, recalculate my path and step... I'm also gonna take out the path structure
|
|
//| in chars_st... all we need is to hold the directions, not the x and y... Hopefully this will
|
|
//| save memory.
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
void cMovement::PathFind( CChar *c, SI16 gx, SI16 gy, bool willRun, UI08 pathLen )
|
|
{
|
|
// Make sure this is a valid character before proceeding
|
|
if( !ValidateObject( c ) )
|
|
return;
|
|
|
|
// Make sure the character has taken used all of their previously saved steps
|
|
if( c->StillGotDirs() )
|
|
return;
|
|
|
|
// Set target location in NPC's mind
|
|
c->SetPathTargX( gx );
|
|
c->SetPathTargY( gy );
|
|
|
|
// 2000.09.21
|
|
// initial rewrite of pathfinding...
|
|
|
|
const SI16 oldx = c->GetX();
|
|
const SI16 oldy = c->GetY();
|
|
SI16 newx = oldx;
|
|
SI16 newy = oldy;
|
|
SI08 newz = c->GetZ();
|
|
UI08 olddir = c->GetDir();
|
|
UI08 pf_dir = Direction( newx, newy, gx, gy );
|
|
|
|
for( UI08 pn = 0; pn < pathLen; ++pn )
|
|
{
|
|
bool bFound = false;
|
|
SI32 pf_neg = ( ( RandomNum( 0, 1 ) ) ? 1 : -1 );
|
|
UI08 newDir = Direction( newx, newy, gx, gy );
|
|
|
|
bool canMoveInDir = false;
|
|
if( newDir < 8 && calc_move( c, newx, newy, newz, newDir ) )
|
|
{
|
|
pf_dir = newDir;
|
|
canMoveInDir = true;
|
|
}
|
|
for( UI08 i = 0; i < 7; ++i )
|
|
{
|
|
if( canMoveInDir || ( pf_dir < 8 && calc_move( c, newx, newy, newz, pf_dir ) ) )
|
|
{
|
|
newx = GetXfromDir( pf_dir, newx ); // moved inside if to reduce calculations
|
|
newy = GetYfromDir( pf_dir, newy );
|
|
if( ( pn < P_PF_MRV ) && CheckForCharacterAtXYZ( c, newx, newy, newz ) )
|
|
{
|
|
// Character is blocking the way. Let's try to find a way around by
|
|
// randomizing the direction a bit!
|
|
SI08 rndDir = pf_dir + RandomNum( -2, 2 );
|
|
if( rndDir < 0 )
|
|
rndDir = 7 + ( rndDir + 1 );
|
|
else if( rndDir > 7 )
|
|
rndDir = 0 + abs( 7 - ( rndDir - 1 ) );
|
|
pf_dir = rndDir;
|
|
}
|
|
|
|
UI08 dirToPush = pf_dir;
|
|
if( willRun )
|
|
dirToPush |= 0x80;
|
|
|
|
c->PushDirection( dirToPush );
|
|
|
|
if( olddir != UNKNOWNDIR && olddir != pf_dir )
|
|
c->PushDirection( dirToPush );
|
|
|
|
olddir = pf_dir;
|
|
|
|
bFound = true;
|
|
break;
|
|
}
|
|
pf_neg *= -1;
|
|
pf_dir = static_cast<UI08>((UI08)(pf_dir + ( i * pf_neg )) % 8);
|
|
}
|
|
if( !bFound )
|
|
{
|
|
#if DEBUG_PATHFIND
|
|
Console << "Character stuck!" << myendl;
|
|
#endif
|
|
break;
|
|
}
|
|
if( newx == gx && newy == gy )
|
|
break;
|
|
}
|
|
}
|
|
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
//| Function - bool HandleNPCWander( CChar& mChar )
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
//| Purpose - Handle NPC movement when in wander modes
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
bool cMovement::HandleNPCWander( CChar& mChar )
|
|
{
|
|
bool shouldRun = false;
|
|
bool canRun = false;
|
|
CChar *kChar = nullptr;
|
|
UI08 j;
|
|
SI08 npcWanderType = mChar.GetNpcWander();
|
|
switch( npcWanderType )
|
|
{
|
|
case WT_NONE: // No movement
|
|
if( mChar.GetOldNpcWander() != WT_NONE && mChar.GetTimer( tNPC_MOVETIME ) <= cwmWorldState->GetUICurrentTime() )
|
|
mChar.SetNpcWander( mChar.GetOldNpcWander() );
|
|
break;
|
|
case WT_FOLLOW: // Follow the follow target
|
|
kChar = mChar.GetFTarg();
|
|
if( !ValidateObject( kChar ) )
|
|
break;
|
|
|
|
// Don't allow NPCs to follow characters who are in a different world/instance!
|
|
if( mChar.WorldNumber() != kChar->WorldNumber() || mChar.GetInstanceID() != kChar->GetInstanceID() )
|
|
break;
|
|
|
|
if( isOnline( (*kChar) ) || kChar->IsNpc() )
|
|
{
|
|
const UI16 charDist = getDist( &mChar, kChar );
|
|
if( !objInRange( &mChar, kChar, DIST_NEXTTILE ) && Direction( &mChar, kChar->GetX(), kChar->GetY() ) < 8 )
|
|
{
|
|
if( mChar.GetStamina() > 0 )
|
|
{
|
|
if(kChar->GetRunning() > 0)
|
|
canRun = true;
|
|
else if( charDist >= DIST_INRANGE )
|
|
canRun = true;
|
|
else if( (mChar.GetRunning() > 0) && (charDist > DIST_NEARBY) )
|
|
canRun = true;
|
|
}
|
|
|
|
// Don't always re-calculate pathfinding on every step
|
|
// Update some of the time if target moves, but also use what we already have
|
|
SI16 oldTargX = 0;
|
|
SI16 oldTargY = 0;
|
|
oldTargX = mChar.GetOldTargLocX();
|
|
oldTargY = mChar.GetOldTargLocY();
|
|
|
|
if( !mChar.StillGotDirs() || (( oldTargX != kChar->GetX() || oldTargY != kChar->GetY() ) && RandomNum( 0, 10 ) >= 6 ))
|
|
{
|
|
if( cwmWorldState->ServerData()->AdvancedPathfinding() )
|
|
{
|
|
if( !AdvancedPathfinding( &mChar, kChar->GetX(), kChar->GetY(), canRun ))
|
|
{
|
|
// If NPC is unable to follow owner, teleport to owner
|
|
if( mChar.GetOwnerObj() == kChar )
|
|
{
|
|
mChar.SetLocation( kChar );
|
|
}
|
|
else
|
|
{
|
|
// If NPC following fails to follow, make it stop
|
|
mChar.SetOldTargLocX( 0 );
|
|
mChar.SetOldTargLocY( 0 );
|
|
mChar.TextMessage( nullptr, Dictionary->GetEntry( 9048 ), SYSTEM, false ); // [Stops following]
|
|
mChar.SetNpcWander( WT_NONE );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
mChar.SetOldTargLocX( kChar->GetX() );
|
|
mChar.SetOldTargLocY( kChar->GetY() );
|
|
}
|
|
}
|
|
else
|
|
PathFind( &mChar, kChar->GetX(), kChar->GetY(), canRun );
|
|
}
|
|
|
|
j = mChar.PopDirection();
|
|
Walking( nullptr, &mChar, j, 256 );
|
|
shouldRun = (( j&0x80 ) != 0);
|
|
}
|
|
// Has the Escortee reached the destination ??
|
|
if( !kChar->IsDead() && mChar.GetQuestDestRegion() == mChar.GetRegionNum() )
|
|
MsgBoardQuestEscortArrive( kChar->GetSocket(), &mChar );
|
|
}
|
|
break;
|
|
case WT_FREE: // Wander freely, avoiding obstacles.
|
|
case WT_BOX: // Wander freely, within a defined box
|
|
case WT_CIRCLE: // Wander freely, within a defined circle
|
|
j = RandomNum( 1, 5 );
|
|
if( j == 1 )
|
|
break;
|
|
else if( j == 2 )
|
|
j = RandomNum( 0, 7 );
|
|
else // Move in the same direction the majority of the time
|
|
j = mChar.GetDir();
|
|
shouldRun = (( j&0x80 ) != 0);
|
|
NpcWalk( &mChar, j, npcWanderType );
|
|
break;
|
|
case WT_FROZEN: // No movement whatsoever!
|
|
break;
|
|
case WT_FLEE: //FLEE!!!!!!
|
|
kChar = mChar.GetTarg();
|
|
if( !ValidateObject( kChar ) )
|
|
break;
|
|
|
|
if(( mChar.WorldNumber() == kChar->WorldNumber() && mChar.GetInstanceID() == kChar->GetInstanceID() )
|
|
|| getDist( &mChar, kChar ) < P_PF_MFD )
|
|
{ // calculate a x,y to flee towards
|
|
const UI16 mydist = P_PF_MFD - getDist( &mChar, kChar ) + 1;
|
|
j = Direction( &mChar, kChar->GetX(), kChar->GetY() );
|
|
SI16 myx = GetXfromDir( j, mChar.GetX() );
|
|
SI16 myy = GetYfromDir( j, mChar.GetY() );
|
|
|
|
SI16 xfactor = 0;
|
|
SI16 yfactor = 0;
|
|
// Sept 22, 2002
|
|
if( myx != mChar.GetX() )
|
|
{
|
|
if( myx < mChar.GetX() )
|
|
xfactor = 1;
|
|
else
|
|
xfactor = -1;
|
|
}
|
|
|
|
if( myy != mChar.GetY() )
|
|
{
|
|
if( myy < mChar.GetY() )
|
|
yfactor = 1;
|
|
else
|
|
yfactor = -1;
|
|
}
|
|
|
|
myx += (SI16)( xfactor * mydist );
|
|
myy += (SI16)( yfactor * mydist );
|
|
|
|
canRun = (mChar.GetStamina() > 0);
|
|
|
|
// now, got myx, myy... lets go.
|
|
|
|
// Don't re-calculate pathfinding on every step. Use what we have, with a random chance to recalculate
|
|
if( !mChar.StillGotDirs() || RandomNum( 0, 10 ) >= 6 )
|
|
{
|
|
if( cwmWorldState->ServerData()->AdvancedPathfinding() )
|
|
{
|
|
if( !AdvancedPathfinding( &mChar, myx, myy, true ))
|
|
{
|
|
// If NPC fails to flee, make him re-attack instead!
|
|
mChar.SetFleeAt( 0 );
|
|
mChar.SetReattackAt( 1 );
|
|
mChar.SetNpcWander( mChar.GetOldNpcWander() );
|
|
if( mChar.GetMounted() )
|
|
mChar.SetTimer( tNPC_MOVETIME, BuildTimeValue( mChar.GetMountedRunningSpeed() ) );
|
|
else
|
|
mChar.SetTimer( tNPC_MOVETIME, BuildTimeValue( mChar.GetRunningSpeed() ) );
|
|
mChar.SetOldNpcWander( WT_NONE ); // so it won't save this at the wsc file
|
|
}
|
|
}
|
|
else
|
|
PathFind( &mChar, myx, myy, true );
|
|
}
|
|
|
|
j = mChar.PopDirection();
|
|
shouldRun = (( j&0x80 ) != 0);
|
|
Walking( nullptr, &mChar, j, 256 );
|
|
}
|
|
else
|
|
{ // wander freely... don't just stop because I'm out of range.
|
|
j = RandomNum( 1, 5 );
|
|
if( j == 1 )
|
|
break;
|
|
else if( j == 2 )
|
|
j = RandomNum( 0, 8 );
|
|
else // Move in the same direction the majority of the time
|
|
j = mChar.GetDir();
|
|
shouldRun = (( j&0x80 ) != 0);
|
|
NpcWalk( &mChar, j, npcWanderType );
|
|
}
|
|
break;
|
|
case WT_PATHFIND: // Pathfinding!!!!
|
|
if( mChar.StillGotDirs() )
|
|
{
|
|
j = mChar.PopDirection();
|
|
shouldRun = (( j&0x80 ) != 0);
|
|
Walking( nullptr, &mChar, j, 256 );
|
|
}
|
|
else
|
|
{
|
|
mChar.SetNpcWander( mChar.GetOldNpcWander() );
|
|
|
|
std::vector<UI16> scriptTriggers = mChar.GetScriptTriggers();
|
|
for( auto scriptTrig : scriptTriggers )
|
|
{
|
|
cScript *toExecute = JSMapping->GetScript( scriptTrig );
|
|
if( toExecute != nullptr )
|
|
{
|
|
// Reached end of pathfinding, if script returns true/1, prevent other scripts with event from running
|
|
if( toExecute->OnPathfindEnd( &mChar, mChar.GetPathResult() ) == 1 )
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
return shouldRun;
|
|
}
|
|
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
//| Function - void NpcMovement( CChar& mChar )
|
|
//| Date - 09/22/2002
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
//| Purpose - Calculate, and handle NPC AI movement
|
|
//|
|
|
//| Changes - 09/22/2002 - Fixed fleeing NPCs by reversing values for
|
|
//| xfactor & yfactor lines
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
void cMovement::NpcMovement( CChar& mChar )
|
|
{
|
|
if( mChar.IsFrozen() || !mChar.IsNpc() || mChar.GetNpcWander() == WT_FROZEN )
|
|
return;
|
|
|
|
bool canRun = ( (mChar.GetStamina() > 0) && mChar.CanRun() );
|
|
|
|
if( mChar.GetTimer( tNPC_MOVETIME ) <= cwmWorldState->GetUICurrentTime() || cwmWorldState->GetOverflow() )
|
|
{
|
|
#if DEBUG_NPCWALK
|
|
std::string charName = getNpcDictName( mChar );
|
|
Console.print( oldstrutil::format( "DEBUG: ENTER (%s): %d AI %d WAR %d J\n", charName, mChar.GetNpcWander(), mChar.IsAtWar(), j ));
|
|
#endif
|
|
bool shouldRun = false;
|
|
if( mChar.IsAtWar() && mChar.GetNpcWander() != WT_FLEE )
|
|
{
|
|
CChar *l = mChar.GetAttacker();
|
|
if( ValidateObject( l ) && ( isOnline( (*l) ) || l->IsNpc() ) )
|
|
{
|
|
const UI08 charDir = Direction( &mChar, l->GetX(), l->GetY() );
|
|
const UI16 charDist = getDist( &mChar, l );
|
|
|
|
// NPC is using a ranged weapon, and is within range to shoot at the target
|
|
CItem *equippedWeapon = Combat->getWeapon( &mChar );
|
|
if( charDir < 8 && ( charDist <= 1 || (( Combat->getCombatSkill( equippedWeapon ) == ARCHERY || Combat->getCombatSkill( equippedWeapon ) == THROWING ) && charDist <= equippedWeapon->GetMaxRange() ) ) )
|
|
{
|
|
bool los = LineOfSight( nullptr, &mChar, l->GetX(), l->GetY(), ( l->GetZ() + 15 ), WALLS_CHIMNEYS + DOORS + FLOORS_FLAT_ROOFING, false );
|
|
if( los )
|
|
{
|
|
// Turn towards target
|
|
if( charDir != mChar.GetDir() )
|
|
mChar.SetDir( charDir );
|
|
|
|
// No need to move any closer
|
|
mChar.FlushPath();
|
|
mChar.SetOldTargLocX( 0 );
|
|
mChar.SetOldTargLocY( 0 );
|
|
return;
|
|
}
|
|
else if(( !los && charDist <= 1 ) || ( !los && mChar.GetZ() - l->GetZ() >= 20 ))
|
|
{
|
|
// We're right next to target, but still have no LoS - or height difference is too large
|
|
mChar.FlushPath();
|
|
mChar.SetOldTargLocX( 0 );
|
|
mChar.SetOldTargLocY( 0 );
|
|
mChar.SetTimer( tNPC_EVADETIME, BuildTimeValue( 10 ) );
|
|
mChar.TextMessage( nullptr, Dictionary->GetEntry( 9049 ), SYSTEM, false ); // [Evading]
|
|
mChar.SetHP( mChar.GetMaxHP() );
|
|
mChar.SetEvadeState( true );
|
|
Combat->InvalidateAttacker( &mChar );
|
|
//Console.warning( oldstrutil::format( "EvadeTimer started for NPC (%s, 0x%X, at %i, %i, %i, %i). Could no longer see or reach target.\n", mChar.GetName().c_str(), mChar.GetSerial(), mChar.GetX(), mChar.GetY(), mChar.GetZ(), mChar.WorldNumber() ));
|
|
|
|
std::vector<UI16> scriptTriggers = mChar.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->OnEnterEvadeState( &mChar, l ) == 1 )
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
|
|
if( cwmWorldState->ServerData()->AdvancedPathfinding() )
|
|
{
|
|
// Don't always re-calculate pathfinding on every step
|
|
// Update some of the time if target moves, but also use what we already have
|
|
SI16 targX = 0;
|
|
SI16 targY = 0;
|
|
SI16 oldTargX = 0;
|
|
SI16 oldTargY = 0;
|
|
oldTargX = mChar.GetOldTargLocX();
|
|
oldTargY = mChar.GetOldTargLocY();
|
|
|
|
if( mChar.GetPathFail() > 10 && mChar.GetSpAttack() > 0 && mChar.GetMana() > 0 && charDist <= cwmWorldState->ServerData()->CombatMaxSpellRange() )
|
|
{
|
|
// NPC already within spellcasting distance, we can forgive a lack of pathfinding to target
|
|
UI08 NewDir = Direction( &mChar, l->GetX(), l->GetY() );
|
|
|
|
// Turn towards target
|
|
if( NewDir != mChar.GetDir() )
|
|
mChar.SetDir( NewDir );
|
|
|
|
// Clear pathfinding data
|
|
mChar.FlushPath();
|
|
mChar.SetOldTargLocX( 0 );
|
|
mChar.SetOldTargLocY( 0 );
|
|
mChar.SetPathFail( 0 );
|
|
|
|
// Temporary change NPC's wandermode to none, and try pathfinding again in 5 seconds
|
|
if( mChar.GetNpcWander() != WT_NONE )
|
|
mChar.SetOldNpcWander( mChar.GetNpcWander() );
|
|
mChar.SetNpcWander( WT_NONE );
|
|
mChar.SetTimer( tNPC_MOVETIME, BuildTimeValue( 5 ) );
|
|
return;
|
|
}
|
|
else if( mChar.GetSpAttack() > 0 && mChar.GetMana() > 0 )
|
|
{
|
|
targX = mChar.GetPathTargX();
|
|
targY = mChar.GetPathTargY();
|
|
}
|
|
else
|
|
{
|
|
targX = l->GetX();
|
|
targY = l->GetY();
|
|
}
|
|
|
|
if( !mChar.StillGotDirs() || (( oldTargX != targX || oldTargY != targY ) && RandomNum( 0, 10 ) >= 6 ))
|
|
{
|
|
if( !AdvancedPathfinding( &mChar, l->GetX(), l->GetY(), canRun ) )
|
|
{
|
|
mChar.SetPathFail( mChar.GetPathFail() + 1 );
|
|
|
|
if( mChar.GetSpAttack() > 0 && mChar.GetMana() > 0 )
|
|
{
|
|
// What if we try another location that's nearby the target, but not exactly the target?
|
|
SI16 rndNum1 = RandomNum( -2, 2 );
|
|
SI16 rndNum2 = RandomNum( -2, 2 );
|
|
SI16 rndTargX = l->GetX() + rndNum1;
|
|
SI16 rndTargY = l->GetY() + rndNum2;
|
|
|
|
if( AdvancedPathfinding( &mChar, rndTargX, rndTargY, canRun ) )
|
|
{
|
|
mChar.SetPathFail( 0 );
|
|
mChar.SetOldTargLocX( rndTargX );
|
|
mChar.SetOldTargLocY( rndTargY );
|
|
mChar.SetPathTargX( static_cast<UI16>( rndTargX ));
|
|
mChar.SetPathTargY( static_cast<UI16>( rndTargY ));
|
|
}
|
|
else
|
|
{
|
|
mChar.SetPathFail( mChar.GetPathFail() + 1 );
|
|
}
|
|
}
|
|
|
|
if( mChar.IsAtWar() && mChar.GetNpcWander() != WT_FLEE )
|
|
{
|
|
if( mChar.GetSpAttack() > 0 && mChar.GetMana() > 0 && charDist <= cwmWorldState->ServerData()->CombatMaxSpellRange() )
|
|
{
|
|
// NPC already within spellcasting distance, we can forgive a lack of pathfinding to target
|
|
UI08 NewDir = Direction( &mChar, l->GetX(), l->GetY() );
|
|
if( NewDir != mChar.GetDir() )
|
|
mChar.SetDir( NewDir );
|
|
return;
|
|
}
|
|
|
|
if( mChar.GetPathFail() < 10 )
|
|
{
|
|
// Let's try just resetting the target first - maybe NPC will find another target that's closer?
|
|
mChar.SetTarg( nullptr );
|
|
mChar.SetWar( false );
|
|
return;
|
|
}
|
|
|
|
mChar.FlushPath();
|
|
mChar.SetOldTargLocX( 0 );
|
|
mChar.SetOldTargLocY( 0 );
|
|
mChar.SetTimer( tNPC_EVADETIME, BuildTimeValue( 10 ) );
|
|
mChar.TextMessage( nullptr, Dictionary->GetEntry( 9049 ), SYSTEM, false ); // [Evading]
|
|
mChar.SetHP( mChar.GetMaxHP() );
|
|
mChar.SetEvadeState( true );
|
|
Combat->InvalidateAttacker( &mChar );
|
|
//Console.warning( oldstrutil::format( "EvadeTimer started for NPC (%s, 0x%X, at %i, %i, %i, %i).\n", mChar.GetName().c_str(), mChar.GetSerial(), mChar.GetX(), mChar.GetY(), mChar.GetZ(), mChar.WorldNumber() ));
|
|
|
|
std::vector<UI16> scriptTriggers = mChar.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->OnEnterEvadeState( &mChar, l ) == 1 )
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Pathfinding ok!
|
|
mChar.SetPathFail( 0 );
|
|
mChar.SetOldTargLocX( l->GetX() );
|
|
mChar.SetOldTargLocY( l->GetY() );
|
|
}
|
|
}
|
|
}
|
|
else
|
|
PathFind( &mChar, l->GetX(), l->GetY(), canRun ); // Non-advanced pathfinding
|
|
const UI08 j = mChar.PopDirection();
|
|
shouldRun = (( j&0x80 ) != 0);
|
|
Walking( nullptr, &mChar, j, 256 );
|
|
}
|
|
else
|
|
mChar.FlushPath();
|
|
}
|
|
else
|
|
shouldRun = HandleNPCWander( mChar );
|
|
|
|
SI08 npcWanderType = mChar.GetNpcWander();
|
|
if( shouldRun )
|
|
{
|
|
if( npcWanderType == WT_FOLLOW )
|
|
{
|
|
if( mChar.GetMounted() )
|
|
mChar.SetTimer( tNPC_MOVETIME, BuildTimeValue( mChar.GetMountedRunningSpeed() ) );
|
|
else
|
|
mChar.SetTimer( tNPC_MOVETIME, BuildTimeValue( mChar.GetRunningSpeed() / 1.5 ) ); // Increase follow speed so NPC pets/escorts can keep up with players
|
|
}
|
|
else if( npcWanderType != WT_FLEE )
|
|
{
|
|
if( mChar.GetMounted() )
|
|
mChar.SetTimer( tNPC_MOVETIME, BuildTimeValue( mChar.GetMountedRunningSpeed() ) );
|
|
else
|
|
mChar.SetTimer( tNPC_MOVETIME, BuildTimeValue( mChar.GetRunningSpeed() ) );
|
|
}
|
|
else
|
|
{
|
|
if( mChar.GetMounted() )
|
|
mChar.SetTimer( tNPC_MOVETIME, BuildTimeValue( mChar.GetMountedFleeingSpeed() ) );
|
|
else
|
|
mChar.SetTimer( tNPC_MOVETIME, BuildTimeValue( mChar.GetFleeingSpeed() ) );
|
|
}
|
|
}
|
|
else if( npcWanderType == WT_NONE && mChar.GetOldNpcWander() != WT_NONE && !mChar.IsAtWar() )
|
|
return;
|
|
else
|
|
{
|
|
if( mChar.GetMounted() )
|
|
mChar.SetTimer( tNPC_MOVETIME, BuildTimeValue( mChar.GetMountedWalkingSpeed() ) );
|
|
else
|
|
mChar.SetTimer( tNPC_MOVETIME, BuildTimeValue( mChar.GetWalkingSpeed() ) );
|
|
}
|
|
}
|
|
}
|
|
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
//| Function - void GetAverageZ( UI08 nm, SI16 x, SI16 y, SI08& z, SI08& avg, SI08& top )
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
//| Purpose - Get the average Z height level of the maptile at a given coordinate
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
void cMovement::GetAverageZ( UI08 nm, SI16 x, SI16 y, SI08& z, SI08& avg, SI08& top )
|
|
{
|
|
SI08 zTop = Map->MapElevation( x, y, nm );
|
|
SI08 zLeft = Map->MapElevation( x, y + 1, nm );
|
|
SI08 zRight = Map->MapElevation( x + 1, y, nm );
|
|
SI08 zBottom = Map->MapElevation( x + 1, y + 1, nm );
|
|
|
|
z = zTop;
|
|
if( zLeft < z )
|
|
z = zLeft;
|
|
if( zRight < z )
|
|
z = zRight;
|
|
if( zBottom < z )
|
|
z = zBottom;
|
|
|
|
top = zTop;
|
|
if( zLeft > top )
|
|
top = zLeft;
|
|
if( zRight > top )
|
|
top = zRight;
|
|
if( zBottom > top )
|
|
top = zBottom;
|
|
|
|
if( abs( zTop - zBottom ) > abs( zLeft - zRight ))
|
|
avg = ( zLeft + zRight ) / 2;
|
|
else
|
|
avg = ( zTop + zBottom ) / 2;
|
|
}
|
|
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
//| Function - bool IsOk( UI08 world, SI08 ourZ, SI08 ourTop, SI16 x, SI16 y, UI16 instanceID, bool ignoreDoor, bool waterWalk )
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
//| Purpose - Checks that target location has no blocking tiles within range of
|
|
//| character's potential new Z and the top of their head
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
bool cMovement::IsOk( std::vector<tile_t> &xyblock, UI16 &xycount, UI08 world, SI08 ourZ, SI08 ourTop, SI16 x, SI16 y, UI16 instanceID, bool ignoreDoor, bool waterWalk )
|
|
{
|
|
for (auto &tile:xyblock){
|
|
|
|
|
|
if( tile.CheckFlag( TF_WET ) )
|
|
{
|
|
// If blocking object is WET and character can swim, ignore object
|
|
if( waterWalk )
|
|
continue;
|
|
}
|
|
|
|
if( tile.CheckFlag(TF_BLOCKING) || tile.CheckFlag(TF_SURFACE) )
|
|
{
|
|
// If character ignores doors (GMs/Counselors/Ghosts), and this is a door, ignore.
|
|
if( ignoreDoor && tile.type == tiletype_t::dyn && (tile.CheckFlag(TF_DOOR) || tile.tileid == 0x692 || tile.tileid == 0x846 || tile.tileid == 0x873 || (tile.tileid >= 0x6F5 && tile.tileid <= 0x6F6)) )
|
|
continue;
|
|
SI08 checkz = tile.altitude;
|
|
SI08 checkTop = tile.top();
|
|
|
|
if( checkTop > ourZ && ourTop > checkz )
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
//| Function - void GetStartZ( UI08 world, CChar *c, SI16 x, SI16 y, SI08 z, SI08& zlow, SI08& ztop, UI16 instanceID, bool waterwalk )
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
//| Purpose - Calculate the Z height at the character's feet at specified location
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
void cMovement::GetStartZ( UI08 world, CChar *c, SI16 x, SI16 y, SI08 z, SI08& zlow, SI08& ztop, UI16 instanceID, bool waterwalk )
|
|
{
|
|
SI08 landz = 0;
|
|
SI08 landcent = 0;
|
|
SI08 landtop = 0;
|
|
bool landBlock = true;
|
|
|
|
auto map = Map->SeekMap( x, y, world );
|
|
|
|
landBlock = map.CheckFlag( TF_BLOCKING );
|
|
if( landBlock && waterwalk && map.CheckFlag( TF_WET ))
|
|
landBlock = false;
|
|
|
|
|
|
std::vector<tile_t> xyblock;
|
|
UI16 xycount = 0;
|
|
GetBlockingStatics( x, y, xyblock, xycount, world );
|
|
GetBlockingDynamics( x, y, xyblock, xycount, world, instanceID );
|
|
|
|
bool considerLand = !Map->IsIgnored( map.tileid );
|
|
GetAverageZ( world, x, y, landz, landcent, landtop );
|
|
|
|
bool isset = false;
|
|
SI08 zcenter = zlow = ztop = 0;
|
|
|
|
if( considerLand && !landBlock && z >= landcent )
|
|
{
|
|
zlow = landz;
|
|
zcenter = landcent;
|
|
|
|
if( !isset || landtop > ztop )
|
|
ztop = landtop;
|
|
|
|
isset = true;
|
|
}
|
|
|
|
for( auto &tile:xyblock ){
|
|
|
|
// If the tile is a surface that can be walked on, or swam on...
|
|
if(( !isset || tile.top() >= zcenter ) && ( tile.CheckFlag( TF_SURFACE ) || ( waterwalk && tile.CheckFlag( TF_WET ))) && z >= tile.top() )
|
|
{
|
|
// Fetch the base Z position of surface tile
|
|
zlow = tile.altitude;
|
|
|
|
// Fetch the top Z position of surface tile as zcenter
|
|
zcenter = tile.top();
|
|
|
|
SI08 top = tile.altitude + tile.height();
|
|
|
|
if( !isset || top > ztop )
|
|
ztop = top;
|
|
|
|
isset = true;
|
|
}
|
|
}
|
|
|
|
if( !isset )
|
|
zlow = ztop = z;
|
|
else if( z > ztop )
|
|
ztop = z;
|
|
}
|
|
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
//| Function - UI08 Direction( CChar *mChar, SI16 x, SI16 y )
|
|
//| UI08 Direction( SI16 sx, SI16 sy, SI16 dx, SI16 dy )
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
//| Purpose - Modified the old CheckWalkable function so that it can be utilized throughout
|
|
//| the walking code. Ever wonder why NPCs can walk through walls and stuff in
|
|
//| combat mode? This is the fix, plus more.
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
UI08 cMovement::Direction( CChar *mChar, SI16 x, SI16 y )
|
|
{
|
|
return Direction( mChar->GetX(), mChar->GetY(), x, y );
|
|
}
|
|
UI08 cMovement::Direction( SI16 sx, SI16 sy, SI16 dx, SI16 dy )
|
|
{
|
|
UI08 dir;
|
|
|
|
const SI16 xdif = static_cast<SI16>(dx - sx);
|
|
const SI16 ydif = static_cast<SI16>(dy - sy);
|
|
|
|
if( xdif == 0 && ydif < 0 )
|
|
dir = NORTH;
|
|
else if( xdif > 0 && ydif < 0 )
|
|
dir = NORTHEAST;
|
|
else if( xdif > 0 && ydif == 0 )
|
|
dir = EAST;
|
|
else if( xdif > 0 && ydif > 0 )
|
|
dir = SOUTHEAST;
|
|
else if( xdif == 0 && ydif > 0 )
|
|
dir = SOUTH;
|
|
else if( xdif < 0 && ydif > 0 )
|
|
dir = SOUTHWEST;
|
|
else if( xdif < 0 && ydif == 0 )
|
|
dir = WEST;
|
|
else if( xdif < 0 && ydif < 0 )
|
|
dir = NORTHWEST;
|
|
else
|
|
dir = UNKNOWNDIR;
|
|
|
|
return dir;
|
|
}
|
|
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
//| Function - SI08 calc_walk( CChar *c, SI16 x, SI16 y, SI16 oldx, SI16 oldy, SI08 oldz, bool justask, bool waterWalk )
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
//| Purpose - Calculates new Z height position for a walking character (PC or NPC) and
|
|
//| checks if movement is blocked
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
//| Notes - Rewritten checkwalk-function, it calculates new z-position for a walking
|
|
//| creature( PC or NPC ) walks, and checks if movement is blocked.
|
|
//|
|
|
//| This function takes a little more calculation time, than the last one, since it
|
|
//| walks two times through the static - tile set. However at least this one is( more )
|
|
//| correct, and these VERy guys now hit their noses on the walls.
|
|
//|
|
|
//| In principle it is the same as the World - kernel in UMelange.
|
|
//|
|
|
//| Parameters:
|
|
//| CChar *c Character
|
|
//| SI16 x, y new cords.
|
|
//| SI16 oldx, oldy old cords.
|
|
//| bool justask don't make any changes, the func. is just asked "what if"..
|
|
//| bool waterWalk Character can swim (true/false)
|
|
//|
|
|
//| Return code:
|
|
//| new z - value if not blocked
|
|
//| illegal_z == -128, if walk is blocked
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
SI08 cMovement::calc_walk( CChar *c, SI16 x, SI16 y, SI16 oldx, SI16 oldy, SI08 oldz, bool justask, bool waterWalk )
|
|
{
|
|
if( !ValidateObject( c ) )
|
|
return ILLEGAL_Z;
|
|
const bool isGM = IsGMBody( c );
|
|
SI08 newz = ILLEGAL_Z;
|
|
SI08 charHeight = 16;
|
|
UI16 xycount = 0;
|
|
UI08 worldNumber = c->WorldNumber();
|
|
UI16 instanceID = c->GetInstanceID();
|
|
bool landBlock = true;
|
|
|
|
std::vector<tile_t> xyblock ;
|
|
GetBlockingStatics( x, y, xyblock, xycount, worldNumber );
|
|
GetBlockingDynamics( x, y, xyblock, xycount, worldNumber, instanceID );
|
|
|
|
auto map = Map->SeekMap( x, y, c->WorldNumber() );
|
|
|
|
|
|
// Does landtile in target location block movement?
|
|
landBlock = map.CheckFlag( TF_BLOCKING );
|
|
|
|
// If it does, but it's WET and character can swim, it doesn't block!
|
|
if( landBlock && waterWalk )
|
|
{
|
|
// Don't count the underwater coastal landtiles as blocking
|
|
if( map.CheckFlag( TF_WET ) || ( map.terrainInfo->TextureID() >= 76 && map.terrainInfo->TextureID() <= 111 ))
|
|
landBlock = false;
|
|
}
|
|
|
|
bool considerLand = Map->IsIgnored( map.tileid ); //Special case for a couple of land-tiles. Returns true if tile being checked equals one of those tiles.
|
|
|
|
SI08 startTop = 0;
|
|
SI08 startz = 0;
|
|
SI08 landz, landCenter, landtop;
|
|
|
|
// Calculate the average Z of landtile at target location
|
|
GetAverageZ( c->WorldNumber(), x, y, landz, landCenter, landtop );
|
|
|
|
// Calculate the character's starting height at source location
|
|
GetStartZ( c->WorldNumber(), c, oldx, oldy, oldz, startz, startTop, c->GetInstanceID(), waterWalk );
|
|
|
|
// Define the maximum height the character can step up to
|
|
SI08 stepTop = startTop + 2;
|
|
|
|
// Define the initial Z position of the character's position + height
|
|
SI08 checkTop = startz + charHeight;
|
|
|
|
// Assume move is NOT ok by default
|
|
bool moveIsOk = false;
|
|
|
|
// first calculate newZ value
|
|
|
|
// Loop through all objects in the target location
|
|
for (auto &tile : xyblock){
|
|
|
|
|
|
if(( !tile.CheckFlag( TF_BLOCKING ) && tile.CheckFlag( TF_SURFACE ) && !waterWalk ) || ( waterWalk && tile.CheckFlag( TF_WET )))
|
|
{
|
|
SI08 itemz = tile.altitude; // Object's current Z position
|
|
SI08 itemTop = itemz;
|
|
SI08 potentialNewZ = tile.top(); // Character's potential new Z position on top of object
|
|
SI08 testTop = checkTop;
|
|
|
|
if( moveIsOk )
|
|
{
|
|
SI08 cmp = std::abs( potentialNewZ - c->GetZ() ) - std::abs( newz - c->GetZ() );
|
|
if( cmp > 0 || ( cmp == 0 && potentialNewZ > newz ))
|
|
continue;
|
|
}
|
|
|
|
if( potentialNewZ + charHeight > testTop )
|
|
testTop = potentialNewZ + charHeight;
|
|
|
|
if( !tile.CheckFlag( TF_CLIMBABLE ))
|
|
itemTop += tile.height();
|
|
|
|
// Check if the character can step up onto the item at target location
|
|
if( stepTop >= itemTop )
|
|
{
|
|
SI08 landCheck = itemz;
|
|
|
|
if( tile.height() >= 2 )
|
|
landCheck += 2;
|
|
else
|
|
landCheck += tile.height();
|
|
|
|
if( !considerLand && landCheck < landCenter && landCenter > potentialNewZ && testTop > landz )
|
|
continue;
|
|
|
|
// Check if target location is OK and doesn't have any tiles on it with blocking flags within the range of character's potential new Z and the top of their head
|
|
if( IsOk( xyblock, xycount, c->WorldNumber(), potentialNewZ, testTop, x, y, c->GetInstanceID(), isGM, waterWalk ))
|
|
{
|
|
newz = potentialNewZ;
|
|
landCenter = potentialNewZ;
|
|
moveIsOk = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if( !considerLand && !landBlock && stepTop >= landz )
|
|
{
|
|
SI08 potentialNewZ = landCenter;
|
|
SI08 testTop = checkTop;
|
|
|
|
if( potentialNewZ + charHeight > testTop )
|
|
testTop = potentialNewZ + charHeight;
|
|
|
|
bool shouldCheck = true;
|
|
|
|
if( moveIsOk )
|
|
{
|
|
SI08 cmp = abs( potentialNewZ - c->GetZ() ) - abs( newz - c->GetZ() );
|
|
if( cmp > 0 || ( cmp == 0 && potentialNewZ > newz ))
|
|
shouldCheck = false;
|
|
}
|
|
|
|
// Check if there are any blocking objects at the target landtile location
|
|
if( shouldCheck && IsOk( xyblock, xycount, c->WorldNumber(), potentialNewZ, testTop, x, y, c->GetInstanceID(), isGM, waterWalk ))
|
|
{
|
|
newz = potentialNewZ;
|
|
moveIsOk = true;
|
|
}
|
|
}
|
|
|
|
if( !moveIsOk )
|
|
newz = ILLEGAL_Z;
|
|
|
|
return newz;
|
|
}
|
|
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
//| Function - bool calc_move( CChar *c, SI16 x, SI16 y, SI08 &z, UI08 dir)
|
|
//| Date - 17.09.2000
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
//| Purpose - Check if a character can walk in a specific direction from a given location
|
|
//| - This handles the funky diagonal moves.
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
bool cMovement::calc_move( CChar *c, SI16 x, SI16 y, SI08 &z, UI08 dir)
|
|
{
|
|
// NPCs that walk on land
|
|
if( !cwmWorldState->creatures[c->GetID()].IsWater() )
|
|
{
|
|
// Is the character moving diagonally (NW, NE, SE, SW)? If so, we should check the nearby directions for blocking items too
|
|
if( (dir&0x07)%2 )
|
|
{
|
|
// Check direction counter-clockwise to actual direction
|
|
UI08 ndir = turn_counter_clock_wise( dir );
|
|
if( calc_walk( c, GetXfromDir( ndir, x ), GetYfromDir( ndir, y ), x, y, c->GetZ(), true ) == ILLEGAL_Z && !cwmWorldState->creatures[c->GetID()].IsAmphibian() )
|
|
return false;
|
|
|
|
// Check direction clockwise to actual direction
|
|
ndir = turn_clock_wise( dir );
|
|
if( calc_walk( c, GetXfromDir( ndir, x ), GetYfromDir( ndir, y ), x, y, c->GetZ(), true ) == ILLEGAL_Z && !cwmWorldState->creatures[c->GetID()].IsAmphibian() )
|
|
return false;
|
|
}
|
|
|
|
// Check actual direction character is moving
|
|
z = calc_walk( c, GetXfromDir( dir, x ), GetYfromDir( dir, y ), x, y, c->GetZ(), false );
|
|
}
|
|
|
|
// NPCs that can swim
|
|
if( cwmWorldState->creatures[c->GetID()].IsWater() || ( cwmWorldState->creatures[c->GetID()].IsAmphibian() && z == ILLEGAL_Z) )
|
|
{
|
|
// Is the character moving diagonally (NW, NE, SE, SW)? If so, we should check the nearby directions for blocking items too
|
|
if( (dir&0x07)%2 )
|
|
{
|
|
// Check direction counter-clockwise to actual direction
|
|
UI08 ndir = turn_counter_clock_wise( dir );
|
|
if( calc_walk( c, GetXfromDir( ndir, x ), GetYfromDir( ndir, y ), x, y, c->GetZ(), true, true ) == ILLEGAL_Z )
|
|
return false;
|
|
|
|
// Check direction clockwise to actual direction
|
|
ndir = turn_clock_wise( dir );
|
|
if( calc_walk( c, GetXfromDir( ndir, x ), GetYfromDir( ndir, y ), x, y, c->GetZ(), true, true ) == ILLEGAL_Z )
|
|
return false;
|
|
}
|
|
|
|
// Check actual direction character is moving
|
|
z = calc_walk( c, GetXfromDir( dir, x ), GetYfromDir( dir, y ), x, y, c->GetZ(), false, true );
|
|
}
|
|
return (z != ILLEGAL_Z);
|
|
}
|
|
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
//| Function - void deny( CSocket *mSock, CChar *s, SI16 sequence )
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
//| Purpose - Deny player movement and send character's previous location back to client
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
void cMovement::deny( CSocket *mSock, CChar *s, SI16 sequence )
|
|
{
|
|
CPWalkDeny denPack;
|
|
|
|
denPack.SequenceNumber( (SI08)sequence );
|
|
denPack.X( s->GetX() );
|
|
denPack.Y( s->GetY() );
|
|
denPack.Direction( s->GetDir() );
|
|
denPack.Z( s->GetZ() );
|
|
|
|
if( mSock != nullptr )
|
|
{
|
|
mSock->Send( &denPack );
|
|
mSock->WalkSequence( -1 );
|
|
}
|
|
}
|
|
|
|
bool operator==(const nodeFCost& x, const nodeFCost& y)
|
|
{
|
|
return ( x.fCost == y.fCost );
|
|
}
|
|
|
|
bool operator<(const nodeFCost& x, const nodeFCost& y)
|
|
{
|
|
return ( x.fCost < y.fCost );
|
|
}
|
|
|
|
bool operator>(const nodeFCost& x, const nodeFCost& y)
|
|
{
|
|
return ( x.fCost > y.fCost );
|
|
}
|
|
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
//| Function - bool PFGrabNodes(
|
|
//| CChar *mChar, UI16 targX, UI16 targY, UI16 curX, UI16 curY, SI08 curZ,
|
|
//| UI32 parentSer, std::map< UI32, pfNode >& openList, std::map< UI32,
|
|
//| UI32 >& closedList, std::deque< nodeFCost >& fCostList )
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
//| Purpose - Calculate nodes from source to target location for advanced pathfinding
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
bool cMovement::PFGrabNodes( CChar *mChar, UI16 targX, UI16 targY, UI16 curX, UI16 curY, SI08 curZ,
|
|
UI32 parentSer, std::map< UI32, pfNode >& openList, std::map< UI32, UI32 >& closedList, std::deque< nodeFCost >& fCostList )
|
|
{
|
|
std::map< UI32, bool > blockList;
|
|
blockList.clear();
|
|
|
|
bool waterWalk = cwmWorldState->creatures[mChar->GetID()].IsWater();
|
|
bool amphibianWalk = cwmWorldState->creatures[mChar->GetID()].IsAmphibian();
|
|
|
|
SI08 newZ = ILLEGAL_Z;
|
|
for( SI08 xOff = -1; xOff < 2; ++xOff )
|
|
{
|
|
SI16 checkX = curX + xOff;
|
|
for( SI08 yOff = -1; yOff < 2; ++yOff )
|
|
{
|
|
if( !yOff && !xOff )
|
|
continue;
|
|
|
|
SI16 checkY = curY + yOff;
|
|
UI32 locSer = (checkY + (checkX<<16));
|
|
|
|
if( amphibianWalk || !waterWalk )
|
|
newZ = calc_walk( mChar, checkX, checkY, curX, curY, curZ, false );
|
|
if( waterWalk || ( amphibianWalk && newZ == ILLEGAL_Z ))
|
|
newZ = calc_walk( mChar, checkX, checkY, curX, curY, curZ, false, true );
|
|
if( ILLEGAL_Z == newZ )
|
|
{
|
|
blockList[locSer] = true;
|
|
continue;
|
|
}
|
|
|
|
//if( blockList.find( locSer ) != blockList.end() )
|
|
// continue;
|
|
|
|
// Let's make this more expensive by checking for potential blocking characters as well!
|
|
if(( checkX != targX || checkY != targY ) && CheckForCharacterAtXYZ( mChar, checkX, checkY, curZ ))
|
|
{
|
|
blockList[locSer] = true;
|
|
continue;
|
|
}
|
|
|
|
// Don't Cut Corners
|
|
bool cornerBlocked = false;
|
|
if( xOff != 0 && yOff != 0 )
|
|
{
|
|
UI32 check1Ser = (checkY + (curX<<16));
|
|
UI32 check2Ser = (curY + (checkX<<16));
|
|
if( blockList.find( check1Ser ) != blockList.end() || blockList.find( check2Ser ) != blockList.end() )
|
|
cornerBlocked = true;
|
|
else
|
|
{
|
|
if( calc_walk( mChar, curX, checkY, curX, curY, curZ, true ) == ILLEGAL_Z )
|
|
{
|
|
cornerBlocked = true;
|
|
blockList[check1Ser] = true;
|
|
}
|
|
else if( calc_walk( mChar, checkX, curY, curX, curY, curZ, true ) == ILLEGAL_Z )
|
|
{
|
|
cornerBlocked = true;
|
|
blockList[check2Ser] = true;
|
|
}
|
|
}
|
|
}
|
|
if( cornerBlocked )
|
|
continue;
|
|
|
|
if( checkX == targX && checkY == targY )
|
|
return true;
|
|
|
|
UI08 gCost = 10;
|
|
if( xOff && yOff )
|
|
gCost = 14;
|
|
|
|
std::map< UI32, pfNode >::const_iterator olIter;
|
|
olIter = openList.find( locSer );
|
|
if( olIter != openList.end() )
|
|
{
|
|
pfNode mNode = olIter->second;
|
|
if( mNode.gCost > gCost )
|
|
{
|
|
for( std::deque< nodeFCost >::iterator fcIter = fCostList.begin(); fcIter != fCostList.end(); ++fcIter )
|
|
{
|
|
if( (*fcIter).xySer == locSer )
|
|
{
|
|
(*fcIter).fCost = mNode.hCost + gCost;
|
|
break;
|
|
}
|
|
}
|
|
mNode.z = newZ;
|
|
mNode.parent = parentSer;
|
|
mNode.gCost = gCost;
|
|
std::sort( fCostList.begin(), fCostList.end() );
|
|
}
|
|
}
|
|
else if( closedList.find( locSer ) == closedList.end() )
|
|
{
|
|
UI16 hCost = 10*(abs(checkX - targX) + abs(checkY - targY));
|
|
UI16 fCost = gCost + hCost;
|
|
|
|
openList[locSer] = pfNode( hCost, gCost, parentSer, newZ );
|
|
fCostList.push_back( nodeFCost( fCost, locSer ) );
|
|
std::sort( fCostList.begin(), fCostList.end() );
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
//| Function - bool AdvancedPathfinding( CChar *mChar, UI16 targX, UI16 targY, bool willRun )
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
//| Purpose - Handle the advanced variant of NPC pathfinding
|
|
//| Enabled/Disabled throuugh UOX.INI setting - ADVANCEDPATHFINDING=0/1
|
|
//o-----------------------------------------------------------------------------------------------o
|
|
bool cMovement::AdvancedPathfinding( CChar *mChar, UI16 targX, UI16 targY, bool willRun, UI16 maxSteps )
|
|
{
|
|
UI16 startX = mChar->GetX();
|
|
UI16 startY = mChar->GetY();
|
|
UI16 curX = mChar->GetX();
|
|
UI16 curY = mChar->GetY();
|
|
SI08 curZ = mChar->GetZ();;
|
|
UI08 oldDir = mChar->GetDir();
|
|
UI16 loopCtr = 0;
|
|
EVENT_TIMER(mytimer, EVENT_TIMER_OFF);
|
|
// Set target location in NPC's mind
|
|
mChar->SetPathTargX( targX );
|
|
mChar->SetPathTargY( targY );
|
|
EVENT_TIMER_RESET(mytimer);
|
|
|
|
// If no maxSteps was provided, set appropriate value based on current scenario
|
|
if( maxSteps == 0 )
|
|
{
|
|
SI08 npcWanderType = mChar->GetNpcWander();
|
|
if( mChar->IsAtWar() )
|
|
{
|
|
if( getDist( mChar->GetLocation(), point3( targX, targY, curZ ) ) >= 30 )
|
|
maxSteps = 150;
|
|
else
|
|
maxSteps = 50;
|
|
}
|
|
else
|
|
{
|
|
if( npcWanderType == WT_FREE || npcWanderType == WT_BOX || npcWanderType == WT_CIRCLE )
|
|
{
|
|
if( mChar->IsEvading() ) // If they are evading, they might be attempting to move back to original wanderZone
|
|
maxSteps = 75;
|
|
else
|
|
maxSteps = 2; // Out of combat wandering
|
|
}
|
|
else if( npcWanderType == WT_FLEE )
|
|
maxSteps = 37;
|
|
else if( npcWanderType == WT_FOLLOW )
|
|
maxSteps = 50;
|
|
else
|
|
maxSteps = 250;
|
|
}
|
|
}
|
|
|
|
std::map< UI32, pfNode > openList;
|
|
std::map< UI32, UI32 > closedList;
|
|
std::deque< nodeFCost > fCostList;
|
|
|
|
openList.clear();
|
|
closedList.clear();
|
|
fCostList.resize( 0 );
|
|
|
|
UI32 parentSer = (curY + (curX<<16));
|
|
openList[parentSer] = pfNode();
|
|
openList[parentSer].z = curZ;
|
|
fCostList.push_back( nodeFCost( 0, parentSer ) );
|
|
while( ( curX != targX || curY != targY ) && loopCtr < maxSteps )
|
|
{
|
|
parentSer = fCostList[0].xySer;
|
|
curX = static_cast<UI16>(parentSer>>16);
|
|
curY = static_cast<UI16>(parentSer%65536);
|
|
curZ = openList[parentSer].z;
|
|
|
|
closedList[parentSer] = static_cast<UI32>(openList[parentSer].parent);
|
|
openList.erase( openList.find( parentSer ) );
|
|
fCostList.pop_front();
|
|
|
|
if( PFGrabNodes( mChar, targX, targY, curX, curY, curZ, parentSer, openList, closedList, fCostList ) )
|
|
{
|
|
while( parentSer != 0 )
|
|
{
|
|
UI08 newDir = Direction( curX, curY, targX, targY );
|
|
|
|
if( willRun )
|
|
newDir |= 0x80;
|
|
|
|
if( oldDir != UNKNOWNDIR && oldDir != newDir )
|
|
mChar->PushDirection( newDir, true ); // NPC's need to "walk" twice when turning
|
|
mChar->PushDirection( newDir, true );
|
|
|
|
oldDir = newDir;
|
|
targX = curX;
|
|
targY = curY;
|
|
parentSer = closedList[parentSer];
|
|
curX = static_cast<UI16>(parentSer>>16);
|
|
curY = static_cast<UI16>(parentSer%65536);
|
|
}
|
|
break;
|
|
}
|
|
else if( fCostList.empty() )
|
|
break;
|
|
++loopCtr;
|
|
}
|
|
if( loopCtr == maxSteps )
|
|
{
|
|
#if defined( UOX_DEBUG_MODE )
|
|
std::string charName = getNpcDictName( mChar );
|
|
Console.warning( oldstrutil::format("AdvancedPathfinding: NPC (%s at %i %i %i %i) unable to find a path, max steps limit (%i) reached, aborting.\n",
|
|
charName.c_str(), mChar->GetX(), mChar->GetY(), mChar->GetZ(), mChar->WorldNumber(), maxSteps) );
|
|
#endif
|
|
mChar->SetPathResult( -1 ); // Pathfinding failed
|
|
EVENT_TIMER_NOW(mytimer, Time when loopCtr == maxSteps, 1);
|
|
return false;
|
|
}
|
|
else if( loopCtr == 0 && getDist( mChar->GetLocation(), point3( targX, targY, curZ ) ) > 1 )
|
|
{
|
|
#if defined( UOX_DEBUG_MODE )
|
|
Console.warning( "AdvancedPathfinding: Unable to pathfind beyond 0 steps, aborting.\n" );
|
|
#endif
|
|
mChar->SetPathResult( -1 ); // Pathfinding failed
|
|
EVENT_TIMER_NOW(mytimer, Time when loopCtr == 0 and distance >1, 1);
|
|
return false;
|
|
}
|
|
else if( mChar->GetX() == startX && mChar->GetY() == startY && getDist( mChar->GetLocation(), point3( targX, targY, curZ ) ) > 1 )
|
|
{
|
|
// NPC never moved, and target location is not nearby
|
|
mChar->SetPathResult( -1 ); // Pathfinding failed
|
|
EVENT_TIMER_NOW(mytimer, Time when NPC never moved, 1);
|
|
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
#if defined( UOX_DEBUG_MODE )
|
|
Console.print( oldstrutil::format("AdvancedPathfinding: %u loops to find path.\n", loopCtr) );
|
|
#endif
|
|
if( getDist( mChar->GetLocation(), point3( targX, targY, curZ ) ) > 1 )
|
|
mChar->SetPathResult( 0 ); // Partial pathfinding success
|
|
else
|
|
mChar->SetPathResult( 1 ); // Pathfinding success
|
|
}
|
|
EVENT_TIMER_NOW(mytimer, Time when total pathfinding used , 1);
|
|
return true;
|
|
}
|