mob_movement_manager.cpp 28 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196
  1. #include "mob_movement_manager.h"
  2. #include "../Entity.h"
  3. #include "../zoneserver.h"
  4. #include "water_map.h"
  5. #include "map.h"
  6. #include "../../common/timer.h"
  7. #include "pathfinder_interface.h"
  8. #include "position.h"
  9. #include "../../common/Log.h"
  10. #include <vector>
  11. #include <deque>
  12. #include <map>
  13. #include <stdlib.h>
  14. #ifdef WIN32
  15. #include <windows.h>
  16. #endif
  17. extern double frame_time;
  18. class IMovementCommand {
  19. public:
  20. IMovementCommand() = default;
  21. virtual ~IMovementCommand() = default;
  22. virtual bool Process(MobMovementManager* mob_movement_manager, Entity* mob) = 0;
  23. virtual bool Started() const = 0;
  24. };
  25. class RotateToCommand : public IMovementCommand {
  26. public:
  27. RotateToCommand(double rotate_to, double dir, MobMovementMode mob_movement_mode)
  28. {
  29. m_rotate_to = rotate_to;
  30. m_rotate_to_dir = dir;
  31. m_rotate_to_mode = mob_movement_mode;
  32. m_started = false;
  33. }
  34. virtual ~RotateToCommand()
  35. {
  36. }
  37. virtual bool Process(MobMovementManager* mob_movement_manager, Entity* mob)
  38. {
  39. auto rotate_to_speed = m_rotate_to_mode == MovementRunning ? 200.0 : 16.0; //todo: get this from mob
  40. auto from = mob_movement_manager->FixHeading(mob->GetHeading());
  41. auto to = mob_movement_manager->FixHeading(m_rotate_to);
  42. auto diff = to - from;
  43. while (diff < -256.0) {
  44. diff += 512.0;
  45. }
  46. while (diff > 256) {
  47. diff -= 512.0;
  48. }
  49. auto dist = std::abs(diff);
  50. if (!m_started) {
  51. m_started = true;
  52. //mob->SetMoving(true);
  53. /*if (dist > 15.0f && rotate_to_speed > 0.0 && rotate_to_speed <= 25.0) { //send basic rotation
  54. mob_movement_manager->SendCommandToClients(
  55. mob,
  56. 0.0,
  57. 0.0,
  58. 0.0,
  59. m_rotate_to_dir * rotate_to_speed,
  60. 0,
  61. ClientRangeClose
  62. );
  63. }*/
  64. }
  65. auto td = rotate_to_speed * 19.0 * frame_time;
  66. if (td >= dist) {
  67. mob->SetHeading(to);
  68. //mob->SetMoving(false);
  69. //mob_movement_manager->SendCommandToClients(mob, 0.0, 0.0, 0.0, 0.0, 0, ClientRangeCloseMedium);
  70. return true;
  71. }
  72. from += td * m_rotate_to_dir;
  73. mob->SetHeading(mob_movement_manager->FixHeading(from));
  74. return false;
  75. }
  76. virtual bool Started() const
  77. {
  78. return m_started;
  79. }
  80. private:
  81. double m_rotate_to;
  82. double m_rotate_to_dir;
  83. MobMovementMode m_rotate_to_mode;
  84. bool m_started;
  85. };
  86. class MoveToCommand : public IMovementCommand {
  87. public:
  88. MoveToCommand(float x, float y, float z, MobMovementMode mob_movement_mode)
  89. {
  90. m_distance_moved_since_correction = 0.0;
  91. m_move_to_x = x;
  92. m_move_to_y = y;
  93. m_move_to_z = z;
  94. m_move_to_mode = mob_movement_mode;
  95. m_last_sent_time = 0.0;
  96. m_last_sent_speed = 0;
  97. m_started = false;
  98. m_total_h_dist = 0.0;
  99. m_total_v_dist = 0.0;
  100. }
  101. virtual ~MoveToCommand()
  102. {
  103. }
  104. /**
  105. * @param mob_movement_manager
  106. * @param mob
  107. * @return
  108. */
  109. virtual bool Process(MobMovementManager* mob_movement_manager, Entity* mob)
  110. {
  111. //Send a movement packet when you start moving
  112. double current_time = static_cast<double>(Timer::GetCurrentTime2()) / 1000.0;
  113. int current_speed = 0;
  114. if (m_move_to_mode == MovementRunning) {
  115. current_speed = ((Spawn*)mob)->GetSpeed();
  116. }
  117. if (!m_started) {
  118. m_started = true;
  119. //rotate to the point
  120. //mob->SetMoving(true);
  121. mob->SetHeading(mob->GetFaceTarget(m_move_to_x, m_move_to_z));
  122. m_last_sent_speed = current_speed;
  123. m_last_sent_time = current_time;
  124. // Z/Y are flipped due to EverQuest 2 using Y as up/down
  125. m_total_h_dist = DistanceNoZ(glm::vec4(mob->GetX(),mob->GetZ(),mob->GetY(),mob->GetHeading()), glm::vec4(m_move_to_x, m_move_to_z, 0.0f, 0.0f));
  126. m_total_v_dist = m_move_to_y - mob->GetY();
  127. //mob_movement_manager->SendCommandToClients(mob, 0.0, 0.0, 0.0, 0.0, current_speed, ClientRangeCloseMedium);
  128. }
  129. //When speed changes
  130. if (current_speed != m_last_sent_speed) {
  131. //if (RuleB(Map, FixZWhenPathing)) {
  132. // mob->FixZ();
  133. //}
  134. m_distance_moved_since_correction = 0.0;
  135. m_last_sent_speed = current_speed;
  136. m_last_sent_time = current_time;
  137. //mob_movement_manager->SendCommandToClients(mob, 0.0, 0.0, 0.0, 0.0, current_speed, ClientRangeCloseMedium);
  138. }
  139. //If x seconds have passed without sending an update.
  140. if (current_time - m_last_sent_time >= 5.0) {
  141. //if (RuleB(Map, FixZWhenPathing)) {
  142. //mob->FixZ();
  143. //}
  144. m_distance_moved_since_correction = 0.0;
  145. m_last_sent_speed = current_speed;
  146. m_last_sent_time = current_time;
  147. //mob_movemesnt_manager->SendCommandToClients(mob, 0.0, 0.0, 0.0, 0.0, current_speed, ClientRangeCloseMedium);
  148. }
  149. glm::vec3 p = glm::vec3(mob->GetX(), mob->GetY(), mob->GetZ());
  150. // our X/Z versus the mobs X/Z
  151. glm::vec2 tar(m_move_to_x, m_move_to_z);
  152. glm::vec2 pos(p.x, p.z);
  153. double len = glm::distance(pos, tar);
  154. if (len < .01) {
  155. return true;
  156. }
  157. //mob->SetMoved(true);
  158. glm::vec2 dir = tar - pos;
  159. glm::vec2 ndir = glm::normalize(dir);
  160. double distance_moved = frame_time * current_speed * 0.4f * 1.45f;
  161. //mob->SetX(m_move_to_x);
  162. //mob->SetY(m_move_to_z);
  163. //mob->SetZ(m_move_to_y);
  164. mob->ClearRunningLocations();
  165. if (distance_moved > len) {
  166. //if (RuleB(Map, FixZWhenPathing)) {
  167. //mob->FixZ();
  168. //}
  169. // we use npos.y because higher up that is the equilvaent Z
  170. mob->AddRunningLocation(m_move_to_x, m_move_to_y, m_move_to_z, current_speed, distance_moved, true, true, "", true);
  171. return false;
  172. }
  173. else {
  174. glm::vec2 npos = pos + (ndir * static_cast<float>(distance_moved));
  175. len -= distance_moved;
  176. double total_distance_traveled = m_total_h_dist - len;
  177. double start_y = m_move_to_y - m_total_v_dist;
  178. double y_at_pos = start_y + (m_total_v_dist * (total_distance_traveled / m_total_h_dist));
  179. // we use npos.y because higher up that is the equilvaent Z
  180. mob->AddRunningLocation(m_move_to_x, m_move_to_y, m_move_to_z, current_speed, distance_moved, true, true, "", true);
  181. // mob->SetX(npos.x);
  182. // mob->SetY(z_at_pos);
  183. // mob->SetZ(npos.y);
  184. //if (RuleB(Map, FixZWhenPathing)) {
  185. // m_distance_moved_since_correction += distance_moved;
  186. // if (m_distance_moved_since_correction > 10.0f /*RuleR(Map, DistanceCanTravelBeforeAdjustment)*/) {
  187. // m_distance_moved_since_correction = 0.0;
  188. //mob->FixZ();
  189. //}
  190. // }
  191. }
  192. return false;
  193. }
  194. virtual bool Started() const
  195. {
  196. return m_started;
  197. }
  198. protected:
  199. double m_distance_moved_since_correction;
  200. double m_move_to_x;
  201. double m_move_to_y;
  202. double m_move_to_z;
  203. MobMovementMode m_move_to_mode;
  204. bool m_started;
  205. double m_last_sent_time;
  206. int m_last_sent_speed;
  207. double m_total_h_dist;
  208. double m_total_v_dist;
  209. };
  210. class SwimToCommand : public MoveToCommand {
  211. public:
  212. SwimToCommand(float x, float y, float z, MobMovementMode mob_movement_mode) : MoveToCommand(x, y, z, mob_movement_mode)
  213. {
  214. }
  215. virtual bool Process(MobMovementManager* mob_movement_manager, Entity* mob)
  216. {
  217. //Send a movement packet when you start moving
  218. double current_time = static_cast<double>(Timer::GetCurrentTime2()) / 1000.0;
  219. int current_speed = 0;
  220. if (m_move_to_mode == MovementRunning) {
  221. if (mob->IsFeared()) {
  222. current_speed = mob->GetBaseSpeed();
  223. }
  224. else {
  225. //runback overrides
  226. if (mob->GetSpeed() > mob->GetMaxSpeed())
  227. current_speed = mob->GetSpeed();
  228. else
  229. current_speed = mob->GetMaxSpeed();
  230. }
  231. }
  232. else {
  233. current_speed = mob->GetBaseSpeed();
  234. }
  235. if (!m_started) {
  236. m_started = true;
  237. //rotate to the point
  238. //mob->SetMoving(true);
  239. mob->SetHeading(mob->GetFaceTarget(m_move_to_x, m_move_to_z));
  240. m_last_sent_speed = current_speed;
  241. m_last_sent_time = current_time;
  242. m_total_h_dist = DistanceNoZ(glm::vec4(mob->GetX(),mob->GetZ(),mob->GetY(),mob->GetHeading()), glm::vec4(m_move_to_x, m_move_to_z, 0.0f, 0.0f));
  243. m_total_v_dist = m_move_to_y - mob->GetY();
  244. //mob_movement_manager->SendCommandToClients(mob, 0.0, 0.0, 0.0, 0.0, current_speed, ClientRangeCloseMedium);
  245. }
  246. //When speed changes
  247. if (current_speed != m_last_sent_speed) {
  248. m_last_sent_speed = current_speed;
  249. m_last_sent_time = current_time;
  250. //mob_movement_manager->SendCommandToClients(mob, 0.0, 0.0, 0.0, 0.0, current_speed, ClientRangeCloseMedium);
  251. }
  252. //If x seconds have passed without sending an update.
  253. if (current_time - m_last_sent_time >= 1.5) {
  254. m_last_sent_speed = current_speed;
  255. m_last_sent_time = current_time;
  256. //mob_movement_manager->SendCommandToClients(mob, 0.0, 0.0, 0.0, 0.0, current_speed, ClientRangeCloseMedium);
  257. }
  258. glm::vec4 p = glm::vec4(mob->GetX(), mob->GetZ(), mob->GetY(), mob->GetHeading());
  259. glm::vec2 tar(m_move_to_x, m_move_to_y);
  260. glm::vec2 pos(p.x, p.y);
  261. double len = glm::distance(pos, tar);
  262. if (len == 0) {
  263. return true;
  264. }
  265. //mob->SetMoved(true);
  266. glm::vec2 dir = tar - pos;
  267. glm::vec2 ndir = glm::normalize(dir);
  268. double distance_moved = frame_time * current_speed * 0.4f * 1.45f;
  269. mob->SetX(m_move_to_x);
  270. mob->SetZ(m_move_to_z);
  271. mob->SetY(m_move_to_y);
  272. if (distance_moved > len) {
  273. return true;
  274. }
  275. else {
  276. glm::vec2 npos = pos + (ndir * static_cast<float>(distance_moved));
  277. len -= distance_moved;
  278. double total_distance_traveled = m_total_h_dist - len;
  279. double start_y = m_move_to_y - m_total_v_dist;
  280. double y_at_pos = start_y + (m_total_v_dist * (total_distance_traveled / m_total_h_dist));
  281. mob->SetX(npos.x);
  282. mob->SetZ(npos.y);
  283. mob->SetY(y_at_pos);
  284. }
  285. return false;
  286. }
  287. };
  288. class TeleportToCommand : public IMovementCommand {
  289. public:
  290. TeleportToCommand(float x, float y, float z, float heading)
  291. {
  292. m_teleport_to_x = x;
  293. m_teleport_to_y = y;
  294. m_teleport_to_z = z;
  295. m_teleport_to_heading = heading;
  296. }
  297. virtual ~TeleportToCommand()
  298. {
  299. }
  300. virtual bool Process(MobMovementManager* mob_movement_manager, Entity* mob)
  301. {
  302. mob->SetX(m_teleport_to_x);
  303. mob->SetZ(m_teleport_to_z);
  304. mob->SetY(m_teleport_to_y);
  305. mob->SetHeading(mob_movement_manager->FixHeading(m_teleport_to_heading));
  306. //mob_movement_manager->SendCommandToClients(mob, 0.0, 0.0, 0.0, 0.0, 0, ClientRangeAny);
  307. return true;
  308. }
  309. virtual bool Started() const
  310. {
  311. return false;
  312. }
  313. private:
  314. double m_teleport_to_x;
  315. double m_teleport_to_y;
  316. double m_teleport_to_z;
  317. double m_teleport_to_heading;
  318. };
  319. class StopMovingCommand : public IMovementCommand {
  320. public:
  321. StopMovingCommand()
  322. {
  323. }
  324. virtual ~StopMovingCommand()
  325. {
  326. }
  327. virtual bool Process(MobMovementManager* mob_movement_manager, Entity* mob)
  328. {
  329. mob->ClearRunningLocations();
  330. return true;
  331. }
  332. virtual bool Started() const
  333. {
  334. return false;
  335. }
  336. };
  337. class EvadeCombatCommand : public IMovementCommand {
  338. public:
  339. EvadeCombatCommand()
  340. {
  341. }
  342. virtual ~EvadeCombatCommand()
  343. {
  344. }
  345. virtual bool Process(MobMovementManager* mob_movement_manager, Entity* mob)
  346. {
  347. if (mob->IsRunning()) {
  348. mob->StopMoving();
  349. }
  350. return true;
  351. }
  352. virtual bool Started() const
  353. {
  354. return false;
  355. }
  356. };
  357. struct MovementStats {
  358. MovementStats()
  359. {
  360. LastResetTime = static_cast<double>(Timer::GetCurrentTime2()) / 1000.0;
  361. TotalSent = 0ULL;
  362. TotalSentMovement = 0ULL;
  363. TotalSentPosition = 0ULL;
  364. TotalSentHeading = 0ULL;
  365. }
  366. double LastResetTime;
  367. uint64_t TotalSent;
  368. uint64_t TotalSentMovement;
  369. uint64_t TotalSentPosition;
  370. uint64_t TotalSentHeading;
  371. };
  372. struct NavigateTo {
  373. NavigateTo()
  374. {
  375. navigate_to_x = 0.0;
  376. navigate_to_y = 0.0;
  377. navigate_to_z = 0.0;
  378. navigate_to_heading = 0.0;
  379. last_set_time = 0.0;
  380. }
  381. double navigate_to_x;
  382. double navigate_to_y;
  383. double navigate_to_z;
  384. double navigate_to_heading;
  385. double last_set_time;
  386. };
  387. struct MobMovementEntry {
  388. std::deque<std::unique_ptr<IMovementCommand>> Commands;
  389. NavigateTo NavTo;
  390. };
  391. void AdjustRoute(std::list<IPathfinder::IPathNode> &nodes, Entity *who)
  392. {
  393. if (who->GetZone() == nullptr || !who->GetZone()->zonemap /*|| !zone->HasWaterMap()*/) {
  394. return;
  395. }
  396. auto offset = who->GetYOffset();
  397. for (auto &node : nodes) {
  398. //if (!zone->watermap->InLiquid(node.pos)) {
  399. auto best_z = who->GetZone()->zonemap->FindBestZ(node.pos, nullptr);
  400. if (best_z != BEST_Z_INVALID) {
  401. node.pos.z = best_z + offset;
  402. }
  403. //} // todo: floating logic?
  404. }
  405. }
  406. struct MobMovementManager::Implementation {
  407. std::map<Entity *, MobMovementEntry> Entries;
  408. std::vector<Client *> Clients;
  409. MovementStats Stats;
  410. };
  411. MobMovementManager::MobMovementManager()
  412. {
  413. MobListMutex.SetName("MobMovementManager");
  414. _impl.reset(new Implementation());
  415. }
  416. MobMovementManager::~MobMovementManager()
  417. {
  418. }
  419. void MobMovementManager::Process()
  420. {
  421. MobListMutex.readlock();
  422. for (auto &iter : _impl->Entries) {
  423. auto &ent = iter.second;
  424. auto &commands = ent.Commands;
  425. while (true != commands.empty()) {
  426. auto &cmd = commands.front();
  427. auto r = cmd->Process(this, iter.first);
  428. if (true != r) {
  429. break;
  430. }
  431. commands.pop_front();
  432. }
  433. }
  434. MobListMutex.releasereadlock();
  435. }
  436. /**
  437. * @param mob
  438. */
  439. void MobMovementManager::AddMob(Entity *mob)
  440. {
  441. MobListMutex.writelock();
  442. _impl->Entries.insert(std::make_pair(mob, MobMovementEntry()));
  443. MobListMutex.releasewritelock();
  444. }
  445. /**
  446. * @param mob
  447. */
  448. void MobMovementManager::RemoveMob(Entity *mob)
  449. {
  450. MobListMutex.writelock();
  451. _impl->Entries.erase(mob);
  452. MobListMutex.releasewritelock();
  453. }
  454. /**
  455. * @param client
  456. */
  457. void MobMovementManager::AddClient(Client *client)
  458. {
  459. _impl->Clients.push_back(client);
  460. }
  461. /**
  462. * @param client
  463. */
  464. void MobMovementManager::RemoveClient(Client *client)
  465. {
  466. auto iter = _impl->Clients.begin();
  467. while (iter != _impl->Clients.end()) {
  468. if (client == *iter) {
  469. _impl->Clients.erase(iter);
  470. return;
  471. }
  472. ++iter;
  473. }
  474. }
  475. /**
  476. * @param who
  477. * @param to
  478. * @param mob_movement_mode
  479. */
  480. void MobMovementManager::RotateTo(Entity *who, float to, MobMovementMode mob_movement_mode)
  481. {
  482. MobListMutex.readlock();
  483. auto iter = _impl->Entries.find(who);
  484. auto &ent = (*iter);
  485. if (true != ent.second.Commands.empty()) {
  486. return;
  487. }
  488. PushRotateTo(ent.second, who, to, mob_movement_mode);
  489. MobListMutex.releasereadlock();
  490. }
  491. /**
  492. * @param who
  493. * @param x
  494. * @param y
  495. * @param z
  496. * @param heading
  497. */
  498. void MobMovementManager::Teleport(Entity *who, float x, float y, float z, float heading)
  499. {
  500. MobListMutex.readlock();
  501. auto iter = _impl->Entries.find(who);
  502. auto &ent = (*iter);
  503. ent.second.Commands.clear();
  504. PushTeleportTo(ent.second, x, y, z, heading);
  505. MobListMutex.releasereadlock();
  506. }
  507. /**
  508. * @param who
  509. * @param x
  510. * @param y
  511. * @param z
  512. * @param mode
  513. */
  514. void MobMovementManager::NavigateTo(Entity *who, float x, float y, float z, MobMovementMode mode, bool overrideDistance)
  515. {
  516. if (who->IsRunning())
  517. return;
  518. glm::vec3 targPos(x, z, y);
  519. glm::vec3 origPos(who->GetX(), who->GetZ(), who->GetY());
  520. if (IsPositionEqualWithinCertainZ(targPos, origPos, 6.0f)) {
  521. return;
  522. }
  523. MobListMutex.readlock();
  524. auto iter = _impl->Entries.find(who);
  525. auto &ent = (*iter);
  526. auto &nav = ent.second.NavTo;
  527. double current_time = static_cast<double>(Timer::GetCurrentTime2()) / 1000.0;
  528. if ((current_time - nav.last_set_time) > 0.5) {
  529. //Can potentially recalc
  530. auto within = IsPositionWithinSimpleCylinder(
  531. glm::vec3(who->GetX(), who->GetZ(), who->GetY()),
  532. glm::vec3(nav.navigate_to_x, nav.navigate_to_z, nav.navigate_to_y),
  533. 1.5f,
  534. 6.0f
  535. );
  536. if (within && ent.second.Commands.size() > 0 && nav.last_set_time != 0)
  537. {
  538. //who->ClearRunningLocations();
  539. //StopNavigation((Entity*)who);
  540. MobListMutex.releasereadlock();
  541. return;
  542. }
  543. else if (!within && ent.second.Commands.size() > 0 && nav.last_set_time != 0)
  544. {
  545. MobListMutex.releasereadlock();
  546. return;
  547. }
  548. LogWrite(MAP__DEBUG, 0, "Map", "%s %f %f %f: within: %i, commands: %i, lastnav: %f %f %f", who->GetName(),
  549. who->GetX(),who->GetY(),who->GetZ(),within,
  550. ent.second.Commands.size(), nav.navigate_to_x, nav.navigate_to_y, nav.navigate_to_z);
  551. //auto heading_match = IsHeadingEqual(0.0, nav.navigate_to_heading);
  552. //if (/*false == within ||*/ false == heading_match || ent.second.Commands.size() == 0) {
  553. ent.second.Commands.clear();
  554. //Path is no longer valid, calculate a new path
  555. UpdatePath(who, x, y, z, mode);
  556. nav.navigate_to_x = x;
  557. nav.navigate_to_y = y;
  558. nav.navigate_to_z = z;
  559. nav.navigate_to_heading = 0.0;
  560. nav.last_set_time = current_time;
  561. //}
  562. }
  563. MobListMutex.releasereadlock();
  564. }
  565. /**
  566. * @param who
  567. */
  568. void MobMovementManager::StopNavigation(Entity *who)
  569. {
  570. MobListMutex.readlock();
  571. auto iter = _impl->Entries.find(who);
  572. auto &ent = (*iter);
  573. auto &nav = ent.second.NavTo;
  574. nav.navigate_to_x = 0.0;
  575. nav.navigate_to_y = 0.0;
  576. nav.navigate_to_z = 0.0;
  577. nav.navigate_to_heading = 0.0;
  578. nav.last_set_time = 0.0;
  579. if (true == ent.second.Commands.empty()) {
  580. PushStopMoving(ent.second);
  581. MobListMutex.releasereadlock();
  582. return;
  583. }
  584. if (!who->IsRunning()) {
  585. ent.second.Commands.clear();
  586. MobListMutex.releasereadlock();
  587. return;
  588. }
  589. ent.second.Commands.clear();
  590. PushStopMoving(ent.second);
  591. MobListMutex.releasereadlock();
  592. }
  593. void MobMovementManager::DisruptNavigation(Entity* who)
  594. {
  595. MobListMutex.readlock();
  596. auto iter = _impl->Entries.find(who);
  597. auto& ent = (*iter);
  598. auto& nav = ent.second.NavTo;
  599. nav.navigate_to_x = 0.0;
  600. nav.navigate_to_y = 0.0;
  601. nav.navigate_to_z = 0.0;
  602. nav.navigate_to_heading = 0.0;
  603. nav.last_set_time = 0.0;
  604. if (!who->IsRunning()) {
  605. ent.second.Commands.clear();
  606. MobListMutex.releasereadlock();
  607. return;
  608. }
  609. }
  610. /**
  611. * @param in
  612. * @return
  613. */
  614. float MobMovementManager::FixHeading(float in)
  615. {
  616. auto h = in;
  617. while (h > 512.0) {
  618. h -= 512.0;
  619. }
  620. while (h < 0.0) {
  621. h += 512.0;
  622. }
  623. return h;
  624. }
  625. void MobMovementManager::ClearStats()
  626. {
  627. _impl->Stats.LastResetTime = static_cast<double>(Timer::GetCurrentTime2()) / 1000.0;
  628. _impl->Stats.TotalSent = 0;
  629. _impl->Stats.TotalSentHeading = 0;
  630. _impl->Stats.TotalSentMovement = 0;
  631. _impl->Stats.TotalSentPosition = 0;
  632. }
  633. /**
  634. * @param who
  635. * @param x
  636. * @param y
  637. * @param z
  638. * @param mob_movement_mode
  639. */
  640. void MobMovementManager::UpdatePath(Entity *who, float x, float y, float z, MobMovementMode mob_movement_mode)
  641. {
  642. if (!who->GetZone()->zonemap /*|| !zone->HasWaterMap()*/) {
  643. MobListMutex.readlock();
  644. auto iter = _impl->Entries.find(who);
  645. auto &ent = (*iter);
  646. PushMoveTo(ent.second, x, y, z, mob_movement_mode);
  647. PushStopMoving(ent.second);
  648. MobListMutex.releasereadlock();
  649. return;
  650. }
  651. /*
  652. if (who-?()) {
  653. UpdatePathBoat(who, x, y, z, mob_movement_mode);
  654. }
  655. else if (who->IsUnderwaterOnly()) {
  656. UpdatePathUnderwater(who, x, y, z, mob_movement_mode);
  657. }*/
  658. //else {
  659. UpdatePathGround(who, x, y, z, mob_movement_mode);
  660. //}
  661. }
  662. /**
  663. * @param who
  664. * @param x
  665. * @param y
  666. * @param z
  667. * @param mode
  668. */
  669. void MobMovementManager::UpdatePathGround(Entity *who, float x, float y, float z, MobMovementMode mode)
  670. {
  671. PathfinderOptions opts;
  672. opts.smooth_path = true;
  673. opts.step_size = 100.0f;//RuleR(Pathing, NavmeshStepSize);
  674. opts.offset = who->GetYOffset()+1.0f;
  675. opts.flags = PathingNotDisabled ^ PathingZoneLine;
  676. //This is probably pointless since the nav mesh tool currently sets zonelines to disabled anyway
  677. auto partial = false;
  678. auto stuck = false;
  679. auto route = who->GetZone()->pathing->FindPath(
  680. glm::vec3(who->GetX(), who->GetZ(), who->GetY()),
  681. glm::vec3(x, z, y),
  682. partial,
  683. stuck,
  684. opts
  685. );
  686. MobListMutex.readlock();
  687. auto eiter = _impl->Entries.find(who);
  688. auto &ent = (*eiter);
  689. if (route.size() == 0) {
  690. HandleStuckBehavior(who, x, y, z, mode);
  691. MobListMutex.releasereadlock();
  692. return;
  693. }
  694. AdjustRoute(route, who);
  695. //avoid doing any processing if the mob is stuck to allow normal stuck code to work.
  696. if (!stuck) {
  697. //there are times when the routes returned are no differen than where the mob is currently standing. What basically happens
  698. //is a mob will get 'stuck' in such a way that it should be moving but the 'moving' place is the exact same spot it is at.
  699. //this is a problem and creates an area of ground that if a mob gets to, will stay there forever. If socal this creates a
  700. //"Ball of Death" (tm). This code tries to prevent this by simply warping the mob to the requested x/y. Better to have a warp than
  701. //have stuck mobs.
  702. auto routeNode = route.begin();
  703. bool noValidPath = true;
  704. while (routeNode != route.end() && noValidPath == true) {
  705. auto &currentNode = (*routeNode);
  706. if (routeNode == route.end()) {
  707. continue;
  708. }
  709. if (!(currentNode.pos.x == who->GetX() && currentNode.pos.y == who->GetZ())) {
  710. //if one of the nodes to move to, is not our current node, pass it.
  711. noValidPath = false;
  712. break;
  713. }
  714. //move to the next node
  715. routeNode++;
  716. }
  717. if (noValidPath) {
  718. //we are 'stuck' in a path, lets just get out of this by 'teleporting' to the next position.
  719. PushTeleportTo(
  720. ent.second,
  721. x,
  722. y,
  723. z,
  724. CalculateHeadingAngleBetweenPositions(who->GetX(), who->GetZ(), x, z)
  725. );
  726. MobListMutex.releasereadlock();
  727. return;
  728. }
  729. }
  730. auto iter = route.begin();
  731. glm::vec3 previous_pos(who->GetX(), who->GetZ(), who->GetY());
  732. bool first_node = true;
  733. while (iter != route.end()) {
  734. auto &current_node = (*iter);
  735. iter++;
  736. if (iter == route.end()) {
  737. continue;
  738. }
  739. previous_pos = current_node.pos;
  740. auto &next_node = (*iter);
  741. if (first_node) {
  742. if (mode == MovementWalking) {
  743. auto h = who->GetFaceTarget(next_node.pos.x, next_node.pos.y);
  744. PushRotateTo(ent.second, who, h, mode);
  745. }
  746. first_node = false;
  747. }
  748. //move to / teleport to node + 1
  749. if (next_node.teleport && next_node.pos.x != 0.0f && next_node.pos.y != 0.0f) {
  750. float calcedHeading =
  751. CalculateHeadingAngleBetweenPositions(
  752. current_node.pos.x,
  753. current_node.pos.y,
  754. next_node.pos.x,
  755. next_node.pos.y
  756. );
  757. PushTeleportTo(
  758. ent.second,
  759. next_node.pos.x,
  760. next_node.pos.z,
  761. next_node.pos.y,
  762. calcedHeading
  763. );
  764. }
  765. else {
  766. /* if (who->GetZone()->watermap->InLiquid(previous_pos)) {
  767. PushSwimTo(ent.second, next_node.pos.x, next_node.pos.y, next_node.pos.z, mode);
  768. }
  769. else {*/
  770. PushMoveTo(ent.second, next_node.pos.x, next_node.pos.z, next_node.pos.y, mode);
  771. // }
  772. }
  773. }
  774. if (stuck) {
  775. HandleStuckBehavior(who, x, y, z, mode);
  776. }
  777. else {
  778. PushStopMoving(ent.second);
  779. }
  780. MobListMutex.releasereadlock();
  781. }
  782. /**
  783. * @param who
  784. * @param x
  785. * @param y
  786. * @param z
  787. * @param movement_mode
  788. */
  789. void MobMovementManager::UpdatePathUnderwater(Entity *who, float x, float y, float z, MobMovementMode movement_mode)
  790. {
  791. MobListMutex.readlock();
  792. auto eiter = _impl->Entries.find(who);
  793. auto &ent = (*eiter);
  794. if (/*zone->watermap->InLiquid(who->GetPosition()) && zone->watermap->InLiquid(glm::vec3(x, y, z)) &&*/
  795. who->GetZone()->zonemap->CheckLoS(glm::vec3(who->GetX(),who->GetZ(),who->GetY()), glm::vec3(x, y, z))) {
  796. PushSwimTo(ent.second, x, y, z, movement_mode);
  797. PushStopMoving(ent.second);
  798. MobListMutex.releasereadlock();
  799. return;
  800. }
  801. PathfinderOptions opts;
  802. opts.smooth_path = true;
  803. opts.step_size = 100.0f;// RuleR(Pathing, NavmeshStepSize);
  804. opts.offset = who->GetYOffset();
  805. opts.flags = PathingNotDisabled ^ PathingZoneLine;
  806. auto partial = false;
  807. auto stuck = false;
  808. auto route = who->GetZone()->pathing->FindPath(
  809. glm::vec3(who->GetX(), who->GetY(), who->GetZ()),
  810. glm::vec3(x, y, z),
  811. partial,
  812. stuck,
  813. opts
  814. );
  815. if (route.size() == 0) {
  816. HandleStuckBehavior(who, x, z, y, movement_mode);
  817. MobListMutex.releasereadlock();
  818. return;
  819. }
  820. AdjustRoute(route, who);
  821. auto iter = route.begin();
  822. glm::vec3 previous_pos(who->GetX(), who->GetY(), who->GetZ());
  823. bool first_node = true;
  824. while (iter != route.end()) {
  825. auto &current_node = (*iter);
  826. /* if (!zone->watermap->InLiquid(current_node.pos)) {
  827. stuck = true;
  828. while (iter != route.end()) {
  829. iter = route.erase(iter);
  830. }
  831. break;
  832. }
  833. else {*/
  834. iter++;
  835. // }
  836. }
  837. if (route.size() == 0) {
  838. HandleStuckBehavior(who, x, y, z, movement_mode);
  839. MobListMutex.releasereadlock();
  840. return;
  841. }
  842. iter = route.begin();
  843. while (iter != route.end()) {
  844. auto &current_node = (*iter);
  845. iter++;
  846. if (iter == route.end()) {
  847. continue;
  848. }
  849. previous_pos = current_node.pos;
  850. auto &next_node = (*iter);
  851. if (first_node) {
  852. if (movement_mode == MovementWalking) {
  853. auto h = who->GetFaceTarget(next_node.pos.x, next_node.pos.y);
  854. PushRotateTo(ent.second, who, h, movement_mode);
  855. }
  856. first_node = false;
  857. }
  858. //move to / teleport to node + 1
  859. if (next_node.teleport && next_node.pos.x != 0.0f && next_node.pos.y != 0.0f) {
  860. float calcHeading = CalculateHeadingAngleBetweenPositions(
  861. current_node.pos.x,
  862. current_node.pos.y,
  863. next_node.pos.x,
  864. next_node.pos.y
  865. );
  866. PushTeleportTo(
  867. ent.second, next_node.pos.x, next_node.pos.z, next_node.pos.y, calcHeading);
  868. }
  869. else {
  870. PushSwimTo(ent.second, next_node.pos.x, next_node.pos.z, next_node.pos.y, movement_mode);
  871. }
  872. }
  873. if (stuck) {
  874. HandleStuckBehavior(who, x, y, z, movement_mode);
  875. }
  876. else {
  877. PushStopMoving(ent.second);
  878. }
  879. MobListMutex.releasereadlock();
  880. }
  881. /**
  882. * @param who
  883. * @param x
  884. * @param y
  885. * @param z
  886. * @param mode
  887. */
  888. void MobMovementManager::UpdatePathBoat(Entity *who, float x, float y, float z, MobMovementMode mode)
  889. {
  890. MobListMutex.readlock();
  891. auto eiter = _impl->Entries.find(who);
  892. auto &ent = (*eiter);
  893. PushSwimTo(ent.second, x, y, z, mode);
  894. PushStopMoving(ent.second);
  895. MobListMutex.releasereadlock();
  896. }
  897. /**
  898. * @param ent
  899. * @param x
  900. * @param y
  901. * @param z
  902. * @param heading
  903. */
  904. void MobMovementManager::PushTeleportTo(MobMovementEntry &ent, float x, float y, float z, float heading)
  905. {
  906. ent.Commands.push_back(std::unique_ptr<IMovementCommand>(new TeleportToCommand(x, y, z, heading)));
  907. }
  908. /**
  909. * @param ent
  910. * @param x
  911. * @param y
  912. * @param z
  913. * @param mob_movement_mode
  914. */
  915. void MobMovementManager::PushMoveTo(MobMovementEntry &ent, float x, float y, float z, MobMovementMode mob_movement_mode)
  916. {
  917. ent.Commands.push_back(std::unique_ptr<IMovementCommand>(new MoveToCommand(x, y, z, mob_movement_mode)));
  918. }
  919. /**
  920. * @param ent
  921. * @param x
  922. * @param y
  923. * @param z
  924. * @param mob_movement_mode
  925. */
  926. void MobMovementManager::PushSwimTo(MobMovementEntry &ent, float x, float y, float z, MobMovementMode mob_movement_mode)
  927. {
  928. ent.Commands.push_back(std::unique_ptr<IMovementCommand>(new SwimToCommand(x, y, z, mob_movement_mode)));
  929. }
  930. /**
  931. * @param ent
  932. * @param who
  933. * @param to
  934. * @param mob_movement_mode
  935. */
  936. void MobMovementManager::PushRotateTo(MobMovementEntry &ent, Entity *who, float to, MobMovementMode mob_movement_mode)
  937. {
  938. auto from = FixHeading(who->GetHeading());
  939. to = FixHeading(to);
  940. float diff = to - from;
  941. if (std::abs(diff) < 0.001f) {
  942. return;
  943. }
  944. while (diff < -256.0) {
  945. diff += 512.0;
  946. }
  947. while (diff > 256) {
  948. diff -= 512.0;
  949. }
  950. ent.Commands.push_back(std::unique_ptr<IMovementCommand>(new RotateToCommand(to, diff > 0 ? 1.0 : -1.0, mob_movement_mode)));
  951. }
  952. /**
  953. * @param mob_movement_entry
  954. */
  955. void MobMovementManager::PushStopMoving(MobMovementEntry &mob_movement_entry)
  956. {
  957. mob_movement_entry.Commands.push_back(std::unique_ptr<IMovementCommand>(new StopMovingCommand()));
  958. }
  959. /**
  960. * @param mob_movement_entry
  961. */
  962. void MobMovementManager::PushEvadeCombat(MobMovementEntry &mob_movement_entry)
  963. {
  964. mob_movement_entry.Commands.push_back(std::unique_ptr<IMovementCommand>(new EvadeCombatCommand()));
  965. }
  966. /**
  967. * @param who
  968. * @param x
  969. * @param y
  970. * @param z
  971. * @param mob_movement_mode
  972. */
  973. void MobMovementManager::HandleStuckBehavior(Entity *who, float x, float y, float z, MobMovementMode mob_movement_mode)
  974. {
  975. //LogDebug("Handle stuck behavior for {0} at ({1}, {2}, {3}) with movement_mode {4}", who->GetName(), x, y, z, mob_movement_mode);
  976. MobListMutex.readlock();
  977. auto sb = RunToTarget;//who->GetStuckBehavior();
  978. MobStuckBehavior behavior = RunToTarget;
  979. if (sb >= 0 && sb < MaxStuckBehavior) {
  980. behavior = (MobStuckBehavior) sb;
  981. }
  982. auto eiter = _impl->Entries.find(who);
  983. auto &ent = (*eiter);
  984. switch (sb) {
  985. case RunToTarget:
  986. PushMoveTo(ent.second, x, y, z, mob_movement_mode);
  987. PushStopMoving(ent.second);
  988. break;
  989. case WarpToTarget:
  990. PushTeleportTo(ent.second, x, y, z, 0.0f);
  991. PushStopMoving(ent.second);
  992. break;
  993. case TakeNoAction:
  994. PushStopMoving(ent.second);
  995. break;
  996. case EvadeCombat:
  997. PushEvadeCombat(ent.second);
  998. break;
  999. }
  1000. MobListMutex.releasereadlock();
  1001. }