?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Add infos into target window
[ryzomcore.git] / ryzom / server / src / entities_game_service / client_messages.cpp
blob38c78f8b1052361b6bca83d0e3d5ebbaa4e98e8f
1 // Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
2 // Copyright (C) 2010 Winch Gate Property Limited
3 //
4 // This source file has been modified by the following contributors:
5 // Copyright (C) 2019-2020 Jan BOON (Kaetemi) <jan.boon@kaetemi.be>
6 //
7 // This program is free software: you can redistribute it and/or modify
8 // it under the terms of the GNU Affero General Public License as
9 // published by the Free Software Foundation, either version 3 of the
10 // License, or (at your option) any later version.
11 //
12 // This program is distributed in the hope that it will be useful,
13 // but WITHOUT ANY WARRANTY; without even the implied warranty of
14 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 // GNU Affero General Public License for more details.
16 //
17 // You should have received a copy of the GNU Affero General Public License
18 // along with this program. If not, see <http://www.gnu.org/licenses/>.
19
20
21
22 #include "stdpch.h"
23
24 //net
25 #include "nel/net/message.h"
26 #include "nel/misc/command.h"
27 #include "nel/misc/algo.h"
28 #include "nel/misc/common.h"
29 //game_share
30 #include "game_share/generic_xml_msg_mngr.h"
31 #include "game_share/sphrase_com.h"
32 #include "game_share/security_check.h"
33 #include "server_share/log_item_gen.h"
34 //egs
35 #include "client_messages.h"
36 #include "player_manager/player_manager.h"
37 #include "player_manager/player.h"
38 #include "player_manager/character.h"
39 #include "entity_manager/entity_callbacks.h"
40 #include "phrase_manager/phrase_manager_callbacks.h"
41 #include "zone_manager.h"
42 #include "phrase_manager/phrase_manager.h"
43 #include "mission_manager/mission_queue_manager.h"
44 #include "building_manager/building_manager.h"
45 #include "team_manager/team_manager.h"
46 #include "creature_manager/creature_manager.h"
47 #include "egs_sheets/egs_sheets.h"
48 #include "pvp_manager/pvp_manager.h"
49 #include "pvp_manager/pvp_manager_2.h"
50 #include "pvp_manager/pvp.h"
51 #include "building_manager/room_instance.h"
52 #include "player_manager/gear_latency.h"
53 #include "outpost_manager/outpost_manager.h"
54 #include "pvp_manager/pvp_faction_reward_manager/pvp_faction_reward_manager.h"
55 #include "guild_manager/guild_member.h"
56 #include "guild_manager/guild.h"
57 #include "guild_manager/guild_manager.h"
58 #include "modules/r2_mission_item.h"
59 #include "modules/r2_give_item.h"
60 #include "game_share/scenario.h"
61 #include "server_share/r2_vision.h"
62
63 using namespace NLMISC;
64 using namespace NLNET;
65 using namespace std;
66
67 extern CGenericXmlMsgHeaderManager GenericMsgManager;
68
69 CVariable<bool> BuildSpireActive( "egs", "BuildSpireActive", "Activate build spire", true, 0, true );
70
71
72 ///////////////////////////////////////////////////////////////////////////////////////////////////
73 ///////////////////////////////////////////////////////////////////////////////////////////////////
74 // CLIENT:ITEM
75 ///////////////////////////////////////////////////////////////////////////////////////////////////
76 ///////////////////////////////////////////////////////////////////////////////////////////////////
77
78 //
79 void cbClientItemDrop( CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId)
80 {
81 cbItemDrop(msgin, serviceName, serviceId);
82 }
83
84 //
85
86 void cbClientItemPickUpClose( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId )
87 {
88 cbItemClosePickup(msgin, serviceName, serviceId);
89 }
90
91 //
92 void cbClientItemSwap( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId)
93 {
94 cbItemSwap(msgin, serviceName, serviceId);
95 }
96
97 //
98 void cbClientItemHarvest( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId)
99 {
100 cbHarvest(msgin, serviceName, serviceId);
101 }
102
103 //
104 void cbClientItemHarvestClose( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId)
105 {
106 cbHarvestClose(msgin, serviceName, serviceId);
107 }
108
109 //
110 void cbClientItemEquip( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId)
111 {
112 H_AUTO(cbClientItemEquip);
113
114 uint16 equippedInventory, equippedSlot, bagSlot;
115 CEntityId id;
116
117 try
118 {
119 msgin.serial( id );
120 msgin.serial( equippedInventory );
121 msgin.serial( equippedSlot );
122 msgin.serial( bagSlot );
123 }
124 catch(const Exception &e)
125 {
126 nlwarning("Bad cbClientItemEquip serialisation '%s'", e.what());
127 return;
128 }
129
130
131 CCharacter *c = (CCharacter * ) CEntityBaseManager::getEntityBasePtr( id );
132 if( c )
133 {
134 c->setAfkState(false);
135 c->incInterfaceCounter();
136
137 // if player is stunned or dead cancel action
138 if (c->isDead() || c->isStunned())
139 return;
140 c->equipCharacter( INVENTORIES::TInventory(equippedInventory), equippedSlot, bagSlot, false );
141 }
142 }
143
144 //
145 void cbClientItemUnequip( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId)
146 {
147 H_AUTO(cbClientItemUnequip);
148
149 uint16 equippedInventory, equippedSlot;
150 CEntityId id;
151 try
152 {
153 msgin.serial( id );
154 msgin.serial( equippedInventory );
155 msgin.serial( equippedSlot );
156 }
157 catch(const Exception &e)
158 {
159 nlwarning("Bad cbClientItemUnequip serialisation '%s'", e.what());
160 return;
161 }
162
163 CCharacter *c = (CCharacter * ) CEntityBaseManager::getEntityBasePtr( id );
164 if( c )
165 {
166 c->setAfkState(false);
167 c->incInterfaceCounter();
168
169 // if player is stunned or dead cancel action
170 if (c->isDead() || c->isStunned())
171 return;
172
173 c->unequipCharacter( INVENTORIES::TInventory(equippedInventory), equippedSlot, false );
174 }
175 }
176
177
178 //----------------------------
179 // cbItemDestroy
180 //----------------------------
181 void cbClientItemDestroy( CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId )
182 {
183 H_AUTO(cbClientItemDestroy);
184
185 CEntityId user;
186 uint16 inventory,slot,quantity;
187
188 try
189 {
190 msgin.serial(user);
191 msgin.serial(inventory);
192 msgin.serial(slot);
193 msgin.serial(quantity);
194 }
195 catch(const Exception &e)
196 {
197 nlwarning("Bad cbClientItemDestroy serialisation '%s'", e.what());
198 return;
199 }
200
201 CCharacter *character = PlayerManager.getChar( user );
202 if (character == NULL)
203 {
204 nlwarning("<cbItemDestroy> Invalid player Id %s", user.toString().c_str() );
205 return;
206 }
207
208 // check character is ready
209 if (!character->getEnterFlag())
210 {
211 nlwarning("<cbItemDestroy> player Id %s not yet ready", user.toString().c_str() );
212 return;
213 }
214
215 character->setAfkState(false);
216 character->destroyItem( INVENTORIES::TInventory(inventory), slot, quantity, true );
217 }
218
219 // take an item from temp inventory to bag
220 void cbClientItemTempToBag( CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId )
221 {
222 H_AUTO(cbClientItemTempToBag);
223
224 CEntityId user;
225 uint16 slot;
226
227 try
228 {
229 msgin.serial(user);
230 msgin.serial(slot);
231 }
232 catch(const Exception &e)
233 {
234 nlwarning("Bad cbClientItemTempToBag serialisation '%s'", e.what());
235 return;
236 }
237
238 CCharacter *character = PlayerManager.getChar( user );
239 if (character == NULL)
240 {
241 nlwarning("<cbClientItemTempToBag> Invalid player Id %s", user.toString().c_str() );
242 return;
243 }
244
245 // check character is ready
246 if (!character->getEnterFlag())
247 {
248 nlwarning("<cbClientItemTempToBag> player Id %s not yet ready", user.toString().c_str() );
249 return;
250 }
251
252 character->setAfkState(false);
253 character->itemTempInventoryToBag( slot );
254 vector<string> params = character->getCustomMissionParams("__TAKE_TEMP_INV__");
255 if (params.size() >= 2)
256 {
257 character->validateDynamicMissionStep(params[0]+"&take_items=one");
258 character->setCustomMissionParams("__TAKE_TEMP_INV__", "");
259 }
260 }
261
262 // get all item from temp inventory
263 void cbClientItemAllTemp( CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId )
264 {
265 H_AUTO(cbClientItemAllTemp);
266
267 CEntityId user;
268 try
269 {
270 msgin.serial(user);
271 }
272 catch(const Exception &e)
273 {
274 nlwarning("Bad cbClientItemAllTemp serialisation '%s'", e.what());
275 return;
276 }
277
278 CCharacter *character = PlayerManager.getChar( user );
279 if (character == NULL)
280 {
281 nlwarning("<cbClientItemAllTemp> Invalid player Id %s", user.toString().c_str() );
282 return;
283 }
284 // check character is ready
285 if (!character->getEnterFlag())
286 {
287 nlwarning("<cbClientItemAllTemp> player Id %s not yet ready", user.toString().c_str() );
288 return;
289 }
290
291 character->setAfkState(false);
292 character->sendCloseTempInventoryImpulsion();
293 vector<string> params = character->getCustomMissionParams("__TAKE_TEMP_INV__");
294 if (params.size() >= 2)
295 {
296 character->validateDynamicMissionStep(params[0]+"&take_items=all");
297 character->setCustomMissionParams("__TAKE_TEMP_INV__", "");
298 }
299 }
300
301 // clear temp inventory
302 void cbClientItemNoTemp( CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId )
303 {
304 H_AUTO(cbClientItemNoTemp);
305
306 CEntityId user;
307 try
308 {
309 msgin.serial(user);
310 }
311 catch(const Exception &e)
312 {
313 nlwarning("Bad cbClientItemNoTemp serialisation '%s'", e.what());
314 return;
315 }
316
317 CCharacter *character = PlayerManager.getChar( user );
318 if (character == NULL)
319 {
320 nlwarning("<cbClientItemNoTemp> Invalid player Id %s", user.toString().c_str() );
321 return;
322 }
323 // check character is ready
324 if (!character->getEnterFlag())
325 {
326 nlwarning("<cbClientItemAllTemp> player Id %s not yet ready", user.toString().c_str() );
327 return;
328 }
329
330 TLogContext_Item_DropTempInventory dropTemp(user);
331
332 character->setAfkState(false);
333 character->clearTempInventory();
334 vector<string> params = character->getCustomMissionParams("__TAKE_TEMP_INV__");
335 if (params.size() >= 2)
336 {
337 character->validateDynamicMissionStep(params[0]+"&take_items=none");
338 character->setCustomMissionParams("__TAKE_TEMP_INV__", "");
339 }
340 }
341
342 // Enchant or recharge an item
343 void cbClientItemEnchant( CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId )
344 {
345 H_AUTO(cbClientItemEnchant);
346
347 CEntityId user;
348 uint8 inv;
349 uint16 slot;
350
351 try
352 {
353 msgin.serial(user);
354 msgin.serial(inv, slot);
355 }
356 catch(const Exception &e)
357 {
358 nlwarning("Bad cbClientItemEnchant serialisation '%s'", e.what());
359 return;
360 }
361
362 CCharacter *character = PlayerManager.getChar( user );
363 if (character == NULL)
364 {
365 nlwarning("<cbClientItemEnchant> Invalid player Id %s", user.toString().c_str() );
366 return;
367 }
368 // check character is ready
369 if (!character->getEnterFlag())
370 {
371 nlwarning("<cbClientItemEnchant> player Id %s not yet ready", user.toString().c_str() );
372 return;
373 }
374
375 // if player is dead or stunned don't reload or enchant
376 if (character->isDead() || character->isStunned())
377 return;
378
379 character->enchantOrRechargeItem( (INVENTORIES::TInventory) inv, slot );
380 character->setAfkState(false);
381 }
382
383 // use a tp item
384 void cbClientItemUseItem( CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId )
385 {
386 H_AUTO(cbClientItemUseItem);
387
388 CEntityId user;
389 msgin.serial(user);
390
391 uint16 slot;
392 msgin.serial(slot);
393
394 CCharacter *character = PlayerManager.getChar( user );
395 if (character == NULL)
396 {
397 nlwarning("<USEITEM> Invalid player Id %s", user.toString().c_str() );
398 return;
399 }
400 // check character is ready
401 if (!character->getEnterFlag())
402 {
403 nlwarning("<USEITEM> player Id %s not yet ready", user.toString().c_str() );
404 return;
405 }
406
407 character->useItem(slot);
408 }
409
410 void cbClientItemStopUseXpCat( CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId )
411 {
412 H_AUTO(cbClientItemStopUseXpCat);
413
414 CEntityId user;
415 msgin.serial(user);
416
417 bool isRingCatalyser;
418 msgin.serial(isRingCatalyser);
419
420 CCharacter *character = PlayerManager.getChar( user );
421 if (character == NULL)
422 {
423 nlwarning("<cbClientItemStopUseXpCat> Invalid player Id %s", user.toString().c_str() );
424 return;
425 }
426 // check character is ready
427 if (!character->getEnterFlag())
428 {
429 nlwarning("<cbClientItemStopUseXpCat> player Id %s not yet ready", user.toString().c_str() );
430 return;
431 }
432
433 character->stopUseItem( isRingCatalyser );
434 }
435
436
437 ///////////////////////////////////////////////////////////////////////////////////////////////////
438 ///////////////////////////////////////////////////////////////////////////////////////////////////
439 // CLIENT:HARVEST
440 ///////////////////////////////////////////////////////////////////////////////////////////////////
441 ///////////////////////////////////////////////////////////////////////////////////////////////////
442
443 void cbClientHarvestDeposit( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId)
444 {
445 cbHarvestDeposit(msgin, serviceName, serviceId);
446 }
447
448
449 ///////////////////////////////////////////////////////////////////////////////////////////////////
450 ///////////////////////////////////////////////////////////////////////////////////////////////////
451 // CLIENT:PHRASE
452 ///////////////////////////////////////////////////////////////////////////////////////////////////
453 ///////////////////////////////////////////////////////////////////////////////////////////////////
454
455 // execute client sentence
456 void cbClientPhraseExecute( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId)
457 {
458 H_AUTO(cbClientPhraseExecute);
459
460 CEntityId Id;
461 msgin.serial( Id );
462
463 uint8 set,slot;
464 msgin.serial(set,slot);
465
466 CCharacter *ch = PlayerManager.getChar( Id );
467 if ( !ch )
468 {
469 nlwarning("<cbClientPhraseExecute> Unknown character %s", Id.toString().c_str() );
470 return;
471 }
472 // check character is ready
473 if (!ch->getEnterFlag())
474 {
475 nlwarning("<cbClientPhraseExecute> player Id %s not yet ready", Id.toString().c_str() );
476 return;
477 }
478
479 ch->executeMemorizedPhrase( set, slot, false , false);
480 ch->setAfkState(false);
481 }
482
483
484 //
485 void cbClientPhraseExecuteCyclic( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId)
486 {
487 H_AUTO(cbClientPhraseExecuteCyclic);
488
489 CEntityId Id;
490 msgin.serial( Id );
491
492 uint8 set,slot;
493 msgin.serial(set,slot);
494
495 CCharacter *ch = PlayerManager.getChar( Id );
496 if ( !ch )
497 {
498 nlwarning("<cbClientPhraseExecuteCyclic> Unknown character %s", Id.toString().c_str() );
499 return;
500 }
501 // check character is ready
502 if (!ch->getEnterFlag())
503 {
504 nlwarning("<cbClientPhraseExecuteCyclic> player Id %s not yet ready", Id.toString().c_str() );
505 return;
506 }
507
508 ch->setAfkState(false);
509 ch->executeMemorizedPhrase( set, slot, true,false );
510 }
511
512
513 //
514 void cbClientPhraseExecuteFaber( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId)
515 {
516 H_AUTO(cbClientPhraseExecuteFaber);
517
518 CEntityId Id;
519 msgin.serial( Id );
520
521 NLMISC::CSheetId craftPlan;
522 msgin.serial( craftPlan );
523
524 uint8 set,slot;
525 msgin.serial(set,slot);
526
527 CCharacter *ch = PlayerManager.getChar( Id );
528 if ( !ch )
529 {
530 nlwarning("Unknown character %s", Id.toString().c_str() );
531 return;
532 }
533 // check character is ready
534 if (!ch->getEnterFlag())
535 {
536 nlwarning("player Id %s not yet ready", Id.toString().c_str() );
537 return;
538 }
539
540
541 if ( ch->getKnownBricks().find( craftPlan ) == ch->getKnownBricks().end())
542 {
543 string name = CEntityIdTranslator::getInstance()->getByEntity(Id).toString();
544 nlwarning("HACK: %s %s tries to craft a brick he doesn't know %s", Id.toString().c_str(), name.c_str(), craftPlan.toString().c_str());
545 return;
546 }
547
548 ch->abortExchange();
549
550 ch->setCraftPlan( craftPlan );
551
552 ch->clearFaberRms();
553 msgin.serialCont( ch->getFaberRmsNoConst() );
554 msgin.serialCont( ch->getFaberRmsFormulaNoConst() );
555
556 ch->executeMemorizedPhrase( set, slot, false,false );
557 ch->setAfkState(false);
558 }
559
560
561 //
562 void cbClientPhraseMemorize( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId)
563 {
564 H_AUTO(cbClientPhraseMemorize);
565
566 CEntityId Id;
567 msgin.serial( Id );
568
569 uint8 set,slot;
570 msgin.serial(set, slot);
571
572 uint16 phraseId;
573 msgin.serial( phraseId );
574
575 CSPhraseCom phraseDesc;
576 msgin.serial( phraseDesc );
577
578 CCharacter *ch = PlayerManager.getChar( Id );
579 if ( !ch )
580 {
581 nlwarning("<cbClientPhraseMemorize> Unknown character %s", Id.toString().c_str() );
582 return;
583 }
584 // check character is ready
585 if (!ch->getEnterFlag())
586 {
587 nlwarning("<cbClientPhraseMemorize> player Id %s not yet ready", Id.toString().c_str() );
588 return;
589 }
590
591 // memorize
592 ch->memorize(set, slot,phraseId,phraseDesc.Bricks);
593 ch->setAfkState(false);
594 }
595
596 //
597 void cbClientPhraseForget( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId)
598 {
599 H_AUTO(cbClientPhraseForget);
600
601 CEntityId Id;
602 msgin.serial( Id );
603
604 uint8 set,slot;
605 msgin.serial(set,slot);
606
607 CCharacter *ch = PlayerManager.getChar( Id );
608 if ( !ch )
609 {
610 nlwarning("<cbClientPhraseForget> Unknown character %s", Id.toString().c_str() );
611 return;
612 }
613 // check character is ready
614 if (!ch->getEnterFlag())
615 {
616 nlwarning("<cbClientPhraseForget> player Id %s not yet ready", Id.toString().c_str() );
617 return;
618 }
619
620 ch->forgetPhrase( set, slot);
621 ch->setAfkState(false);
622 }
623
624 //
625 void cbClientPhraseDelete( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId)
626 {
627 H_AUTO(cbClientPhraseDelete);
628
629 CEntityId Id;
630 msgin.serial( Id );
631
632 uint16 phraseId;
633 msgin.serial( phraseId );
634
635 CCharacter *ch = PlayerManager.getChar( Id );
636 if ( !ch )
637 {
638 nlwarning("<cbClientPhraseDelete> Unknown character %s", Id.toString().c_str() );
639 return;
640 }
641 // check character is ready
642 if (!ch->getEnterFlag())
643 {
644 nlwarning("<cbClientPhraseDelete> player Id %s not yet ready", Id.toString().c_str() );
645 return;
646 }
647
648 ch->deleteKnownPhrase(phraseId);
649 ch->setAfkState(false);
650 }
651
652 //
653 void cbClientPhraseLearn( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId)
654 {
655 H_AUTO(cbClientPhraseLearn);
656
657 CEntityId Id;
658 msgin.serial( Id );
659
660 uint16 phraseId;
661 msgin.serial( phraseId );
662
663 CSPhraseCom phrase;
664 msgin.serial( phrase );
665
666 CCharacter *ch = PlayerManager.getChar( Id );
667 if ( !ch )
668 {
669 nlwarning("<cbClientPhraseLearn> Unknown character %s", Id.toString().c_str() );
670 return;
671 }
672 // check character is ready
673 if (!ch->getEnterFlag())
674 {
675 nlwarning("<cbClientPhraseLearn> player Id %s not yet ready", Id.toString().c_str() );
676 return;
677 }
678
679 ch->learnPhrase( phrase.Bricks, phraseId, phrase.Name, phrase.IconIndex );
680 ch->setAfkState(false);
681 }
682
683
684 void cbClientPhraseBuyByIndex( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId)
685 {
686 H_AUTO(cbClientPhraseBuyByIndex);
687
688 CEntityId Id;
689 msgin.serial( Id );
690
691 uint8 botChatIndex;
692 msgin.serial( botChatIndex );
693
694 uint16 phraseId;
695 msgin.serial( phraseId );
696
697 CCharacter *ch = PlayerManager.getChar( Id );
698 if ( !ch )
699 {
700 nlwarning("<cbClientPhraseBuyByIndex> Unknown character %s", Id.toString().c_str() );
701 return;
702 }
703 // check character is ready
704 if (!ch->getEnterFlag())
705 {
706 nlwarning("<cbClientPhraseBuyByIndex> player Id %s not yet ready", Id.toString().c_str() );
707 return;
708 }
709
710 ch->incInterfaceCounter();
711 ch->buyPhraseByIndex( botChatIndex, phraseId);
712 ch->setAfkState(false);
713 }
714
715 void cbClientPhraseBuyBySheet( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId)
716 {
717 H_AUTO(cbClientPhraseBuyBySheet);
718
719 CEntityId Id;
720 msgin.serial( Id );
721
722 CSheetId phraseSheetId;
723 uint32 val;
724 msgin.serial( val );
725 phraseSheetId = val;
726
727 uint16 index;
728 msgin.serial( index );
729
730 CCharacter *ch = PlayerManager.getChar( Id );
731 if ( !ch )
732 {
733 nlwarning("<cbClientPhraseBuyBySheet> Unknown character %s", Id.toString().c_str() );
734 return;
735 }
736 // check character is ready
737 if (!ch->getEnterFlag())
738 {
739 nlwarning("<cbClientPhraseBuyBySheet> player Id %s not yet ready", Id.toString().c_str() );
740 return;
741 }
742
743 ch->incInterfaceCounter();
744 ch->buyPhraseBySheet(phraseSheetId,index);
745 ch->setAfkState(false);
746 }
747
748 void cbClientPhraseCancelTop( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId )
749 {
750 H_AUTO(cbClientPhraseCancelTop);
751
752 if ( ! Mirror.mirrorIsReady() )
753 {
754 nlwarning("<cbClientPhraseCancelTop> Received from %s service but mirror not yet ready", serviceName.c_str() );
755 return;
756 }
757
758 NLMISC::CEntityId entityId;
759 msgin.serial( entityId );
760
761 TDataSetRow entityRowId = TheDataset.getDataSetRow(entityId);
762
763 CPhraseManager::getInstance().cancelTopPhrase(entityRowId);
764 } // cbClientPhraseCancelTop //
765
766 void cbClientPhraseCancelAll( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId )
767 {
768 H_AUTO(cbClientPhraseCancelAll);
769
770 if ( ! Mirror.mirrorIsReady() )
771 {
772 nlwarning("<cbClientPhraseCancelAll> Received from %s service but mirror not yet ready", serviceName.c_str() );
773 return;
774 }
775
776 NLMISC::CEntityId entityId;
777 msgin.serial( entityId );
778
779 TDataSetRow entityRowId = TheDataset.getDataSetRow(entityId);
780
781 CPhraseManager::getInstance().cancelAllPhrases(entityRowId);
782 } // cbClientPhraseCancelAll //
783
784 void cbClientPhraseCristalize( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId )
785 {
786 H_AUTO(cbClientPhraseCristalize);
787
788 CEntityId Id;
789 msgin.serial( Id );
790
791 uint8 set,slot;
792 msgin.serial(set,slot);
793
794 CCharacter *ch = PlayerManager.getChar( Id );
795 if ( !ch )
796 {
797 nlwarning("<cbClientPhraseCristalize> Unknown character %s", Id.toString().c_str() );
798 return;
799 }
800 // check character is ready
801 if (!ch->getEnterFlag())
802 {
803 nlwarning("<cbClientPhraseCristalize> player Id %s not yet ready", Id.toString().c_str() );
804 return;
805 }
806
807 ch->executeMemorizedPhrase( set, slot, false, true );
808 ch->setAfkState(false);
809 }
810
811 ///////////////////////////////////////////////////////////////////////////////////////////////////
812 ///////////////////////////////////////////////////////////////////////////////////////////////////
813 // CLIENT:COMBAT
814 ///////////////////////////////////////////////////////////////////////////////////////////////////
815 ///////////////////////////////////////////////////////////////////////////////////////////////////
816
817 //
818 void cbClientCombatEngage( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId)
819 {
820 cbEngage(msgin, serviceName, serviceId);
821 }
822
823 //
824 void cbClientCombatDisengage( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId)
825 {
826 cbDisengage( msgin, serviceName, serviceId);
827 }
828
829 //
830 void cbClientCombatDefaultAttack( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId)
831 {
832 cbDefaultAttack(msgin, serviceName, serviceId);
833 }
834
835
836 void cbClientValidateMeleeCombat( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId)
837 {
838 H_AUTO(cbClientValidateMeleeCombat);
839
840 CEntityId idPlayer;
841 msgin.serial( idPlayer );
842
843 uint8 flag;
844 msgin.serial(flag);
845
846 CCharacter *ch = PlayerManager.getChar( idPlayer );
847 if ( ch && ch->getEnterFlag() )
848 {
849 ch->validateMeleeCombat(flag != 0);
850 //ch->setAfkState(false);
851 }
852 }
853
854 void cbClientCombatProtectedSlot( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId)
855 {
856 H_AUTO(cbClientCombatProtectedSlot);
857
858 CEntityId idPlayer;
859 msgin.serial( idPlayer );
860
861 uint8 slot;
862 msgin.serial( slot );
863
864 CCharacter *ch = PlayerManager.getChar( idPlayer );
865 if ( ch && ch->getEnterFlag() )
866 {
867 ch->protectedSlot( SLOT_EQUIPMENT::TSlotEquipment(slot) );
868 ch->setAfkState(false);
869 }
870 }
871
872 void cbClientCombatParry( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId)
873 {
874 H_AUTO(cbClientCombatParry);
875
876 CEntityId idPlayer;
877 msgin.serial( idPlayer );
878
879 CCharacter *ch = PlayerManager.getChar( idPlayer );
880 if ( ch && ch->getEnterFlag() )
881 {
882 ch->dodgeAsDefense( false );
883 ch->setAfkState(false);
884 }
885 }
886
887 void cbClientCombatDodge( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId)
888 {
889 H_AUTO(cbClientCombatDodge);
890
891 CEntityId idPlayer;
892 msgin.serial( idPlayer );
893
894 CCharacter *ch = PlayerManager.getChar( idPlayer );
895 if ( ch && ch->getEnterFlag() )
896 {
897 ch->dodgeAsDefense( true );
898 ch->setAfkState(false);
899 }
900 }
901
902 void cbClientAutoPact( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId)
903 {
904 H_AUTO(cbClientAutoPact);
905
906 CEntityId charId;
907 msgin.serial(charId);
908
909 bool activate = false;
910
911 CCharacter *character = PlayerManager.getChar(charId);
912 if (character && character->getEnterFlag())
913 {
914 uint8 bval;
915 msgin.serial(bval);
916
917 if (bval)
918 activate = true;
919 character->doPact(activate);
920 }
921 else
922 nlwarning("%s is invalid", charId.toString().c_str());
923 }
924
925
926 ///////////////////////////////////////////////////////////////////////////////////////////////////
927 ///////////////////////////////////////////////////////////////////////////////////////////////////
928 // CLIENT:LEAGUE
929 ///////////////////////////////////////////////////////////////////////////////////////////////////
930 ///////////////////////////////////////////////////////////////////////////////////////////////////
931
932 //
933 void cbClientLeagueJoin( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId)
934 {
935 cbJoinLeague(msgin, serviceName, serviceId);
936 }
937
938 //
939 void cbClientLeagueJoinProposal( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId)
940 {
941 cbJoinLeagueProposal(msgin, serviceName, serviceId);
942 }
943
944 //
945 void cbClientLeagueJoinProposalDecline( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId)
946 {
947 cbJoinLeagueDecline(msgin, serviceName, serviceId);
948 }
949
950
951 ///////////////////////////////////////////////////////////////////////////////////////////////////
952 ///////////////////////////////////////////////////////////////////////////////////////////////////
953 // CLIENT:TEAM
954 ///////////////////////////////////////////////////////////////////////////////////////////////////
955 ///////////////////////////////////////////////////////////////////////////////////////////////////
956
957 //
958 void cbClientTeamLeave( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId)
959 {
960 cbLeaveTeam(msgin, serviceName, serviceId);
961 }
962
963 //
964 void cbClientTeamJoin( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId)
965 {
966 cbJoinTeam(msgin, serviceName, serviceId);
967 }
968
969 //
970 void cbClientTeamKick( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId)
971 {
972 cbKickTeammate(msgin, serviceName, serviceId);
973 }
974
975 //
976 void cbClientTeamJoinProposal( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId)
977 {
978 cbJoinTeamProposal(msgin, serviceName, serviceId);
979 }
980
981 //
982 void cbClientTeamJoinProposalDecline( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId)
983 {
984 cbJoinTeamDecline(msgin, serviceName, serviceId);
985 }
986
987 void cbClientTeamSetSuccessor( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId)
988 {
989 H_AUTO(cbClientTeamSetSuccessor);
990
991 CEntityId id;
992 uint8 idx;
993 msgin.serial(id);
994 msgin.serial(idx);
995 CCharacter* user = PlayerManager.getChar( id );
996 if ( !user )
997 {
998 nlwarning("<TEAM> Invalid user %s",id.toString().c_str() );
999 return;
1000 }
1001 CTeam * team = TeamManager.getTeam( user->getTeamId() );
1002 if ( !team )
1003 {
1004 nlwarning("<TEAM> Invalid team for user %s",id.toString().c_str() );
1005 return;
1006 }
1007 if ( team->getLeader() != id )
1008 {
1009 nlwarning("<TEAM> user %s is not leader: cant set successor",id.toString().c_str() );
1010 return;
1011 }
1012 if (team->getSuccessor() == id)
1013 {
1014 nlwarning("<TEAM> user %s already is successor", id.toString().c_str() );
1015 return;
1016 }
1017
1018 // increment the target index as the leader is not in its team list
1019 ++idx;
1020 team->setSuccessor( idx );
1021
1022 }
1023
1024 void cbClientTeamShareValidItem( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId)
1025 {
1026 H_AUTO(cbClientTeamShareValidItem);
1027
1028 CEntityId id;
1029 msgin.serial(id);
1030 CCharacter * user = PlayerManager.getChar(id);
1031 if ( !user )
1032 {
1033 nlwarning("<cbClientTeamShareValidItem>invalid char %s",id.toString().c_str());
1034 return;
1035 }
1036 // check character is ready
1037 if (!user->getEnterFlag())
1038 {
1039 nlwarning("<cbClientTeamShareValidItem> player Id %s not yet ready", id.toString().c_str() );
1040 return;
1041 }
1042
1043 user->setAfkState(false);
1044 CTeam * team = TeamManager.getRealTeam(user->getTeamId());
1045 if (!team)
1046 {
1047 nlwarning("<cbClientTeamShareValidItem>char %s has no valid team",id.toString().c_str());
1048 return;
1049 }
1050 if ( !team->getReward() )
1051 {
1052 nlwarning("<cbClientTeamShareValidItem>char %s: his team has no reward",id.toString().c_str());
1053 return;
1054 }
1055
1056 uint8 pos,state;
1057 msgin.serial(pos);
1058 msgin.serial(state);
1059 team->getReward()->userItemSelect(user->getEntityRowId(),pos,state);
1060 }
1061
1062 void cbClientTeamShareInvalidItem( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId)
1063 {
1064 H_AUTO(cbClientTeamShareInvalidItem);
1065
1066 CEntityId id;
1067 msgin.serial(id);
1068 CCharacter * user = PlayerManager.getChar(id);
1069 if ( !user )
1070 {
1071 nlwarning("<cbClientTeamShareInvalidItem>invalid char %s",id.toString().c_str());
1072 return;
1073 }
1074 // check character is ready
1075 if (!user->getEnterFlag())
1076 {
1077 nlwarning("<cbClientTeamShareInvalidItem> player Id %s not yet ready", id.toString().c_str() );
1078 return;
1079 }
1080 user->setAfkState(false);
1081 CTeam * team = TeamManager.getRealTeam(user->getTeamId());
1082 if (!team)
1083 {
1084 nlwarning("<cbClientTeamShareInvalidItem>char %s has no valid team",id.toString().c_str());
1085 return;
1086 }
1087 if ( !team->getReward() )
1088 {
1089 nlwarning("<cbClientTeamShareInvalidItem>char %s: his team has no reward",id.toString().c_str());
1090 return;
1091 }
1092
1093 uint8 pos,state;
1094 msgin.serial(pos);
1095 msgin.serial(state);
1096 team->getReward()->userItemSelect(user->getEntityRowId(),pos,state);
1097 }
1098
1099 void cbClientTeamShareValid( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId)
1100 {
1101 H_AUTO(cbClientTeamShareValid);
1102
1103 CEntityId id;
1104 msgin.serial(id);
1105 CCharacter * user = PlayerManager.getChar(id);
1106 if ( !user )
1107 {
1108 nlwarning("<cbClientTeamShareValid>invalid char %s",id.toString().c_str());
1109 return;
1110 }
1111 // check character is ready
1112 if (!user->getEnterFlag())
1113 {
1114 nlwarning("<cbClientTeamShareValid> player Id %s not yet ready", id.toString().c_str() );
1115 return;
1116 }
1117 user->setAfkState(false);
1118 CTeam * team = TeamManager.getRealTeam(user->getTeamId());
1119 if (!team)
1120 {
1121 nlwarning("<cbClientTeamShareValid>char %s has no valid team",id.toString().c_str());
1122 return;
1123 }
1124 if ( !team->getReward() )
1125 {
1126 nlwarning("<cbClientTeamShareValid>char %s: his team has no reward",id.toString().c_str());
1127 return;
1128 }
1129
1130 uint8 state;
1131 msgin.serial(state);
1132 if ( team->getReward()->userValidSelect(user->getEntityRowId(),state) )
1133 team->clearReward();
1134 }
1135
1136 //---------------------------------------------------
1137 // Add a player to contact list or ignore list
1138 //---------------------------------------------------
1139 void cbClientAddToContactList( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId )
1140 {
1141 H_AUTO(cbClientAddToContactList);
1142
1143 CEntityId charId;
1144 ucstring playerName;
1145 uint8 list;
1146
1147 msgin.serial(charId);
1148 msgin.serial(playerName);
1149 msgin.serial(list);
1150
1151 CCharacter * c = PlayerManager.getChar( charId );
1152 if( c && c->getEnterFlag() )
1153 {
1154 c->setAfkState(false);
1155 if (list == 0)
1156 {
1157 c->addPlayerToFriendList(playerName);
1158 }
1159 else
1160 {
1161 c->addPlayerToIgnoreList(playerName);
1162 }
1163 }
1164 else
1165 nlwarning("<cbAddToContactList> Unknown character %s", charId.toString().c_str() );
1166 }
1167
1168 //---------------------------------------------------
1169 // remove a player from contact list or ignore list
1170 //---------------------------------------------------
1171 void cbClientRemoveFromContactList( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId )
1172 {
1173 H_AUTO(cbClientRemoveFromContactList);
1174
1175 CEntityId charId;
1176 uint32 contactId;
1177 uint8 list;
1178
1179 msgin.serial(charId);
1180 msgin.serial(contactId);
1181 msgin.serial(list);
1182
1183 CCharacter * c = PlayerManager.getChar( charId );
1184 if( c && c->getEnterFlag() )
1185 {
1186 c->setAfkState(false);
1187 if (list == 0)
1188 {
1189 c->removePlayerFromFriendListByContactId(contactId);
1190 }
1191 else
1192 {
1193 c->removePlayerFromIgnoreListByContactId(contactId);
1194 }
1195 }
1196 else
1197 nlwarning("<cbAddToContactList> Unknown character %s", charId.toString().c_str() );
1198 }
1199
1200 //---------------------------------------------------
1201 // Mobe a player from a contact list to an another one
1202 //---------------------------------------------------
1203 void cbClientMoveInContactLists( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId )
1204 {
1205 H_AUTO(cbClientMoveInContactLists);
1206
1207 CEntityId charId;
1208 uint32 contactIdOrigin;
1209 uint8 listOrigin;
1210
1211 msgin.serial(charId);
1212 msgin.serial(contactIdOrigin);
1213 msgin.serial(listOrigin);
1214
1215 CCharacter * c = PlayerManager.getChar( charId );
1216 if( c && c->getEnterFlag() )
1217 {
1218 c->setAfkState(false);
1219 if (listOrigin == 0)
1220 {
1221 NLMISC::CEntityId eid= c->getFriendByContactId(contactIdOrigin);
1222 // allows the whole operation or nothing if player does not exist
1223 if (eid != CEntityId::Unknown)
1224 {
1225 c->removePlayerFromFriendListByEntityId(eid);
1226 c->addPlayerToIgnoreList(eid);
1227 }
1228 else
1229 {
1230 // player not found => message
1231 PHRASE_UTILITIES::sendDynamicSystemMessage( c->getEntityRowId(), "OPERATION_NOTEXIST");
1232 }
1233 }
1234 else
1235 {
1236 NLMISC::CEntityId eid= c->getIgnoreByContactId(contactIdOrigin);
1237 // allows the whole operation or nothing if player is not present
1238 if(eid != CEntityId::Unknown)
1239 {
1240 c->removePlayerFromIgnoreListByEntityId(eid);
1241 c->addPlayerToFriendList(eid);
1242 }
1243 else
1244 {
1245 // player not found => message
1246 PHRASE_UTILITIES::sendDynamicSystemMessage( c->getEntityRowId(), "OPERATION_NOTEXIST");
1247 }
1248 }
1249 }
1250 else
1251 nlwarning("<cbAddToContactList> Unknown character %s", charId.toString().c_str() );
1252 }
1253
1254 ///////////////////////////////////////////////////////////////////////////////////////////////////
1255 ///////////////////////////////////////////////////////////////////////////////////////////////////
1256 // CLIENT:TP
1257 ///////////////////////////////////////////////////////////////////////////////////////////////////
1258 ///////////////////////////////////////////////////////////////////////////////////////////////////
1259
1260 // teleport near a bot
1261 /*void cbClientTpBot( NLNET::CMessage& msgin, const std::string &serviceName, uint16 serviceId)
1262 {
1263 CEntityId idPlayer;
1264 string name;
1265 CEntityId botId;
1266 msgin.serial( idPlayer );
1267 msgin.serial( name );
1268
1269 CCharacter *ch = PlayerManager.getChar( idPlayer );
1270 if ( ch && ch->havePriv(PriviliegeGameMaster))
1271 {
1272 CEntityBase* entity = PlayerManager.getCharacterByName( name );
1273 if( ! entity )
1274 {
1275 TAIAlias alias = CAIAliasTranslator::getInstance()->getNPCAliasFromName(name);
1276 if ( ! CAIAliasTranslator::getInstance()->getEntityId(alias,botId) )
1277 {
1278 nlwarning("<cbClientTpBot> Unknown alias %d", alias );
1279 return;
1280 }
1281 entity = CreatureManager.getCreature( botId );
1282 }
1283 if ( entity )
1284 {
1285 sint32 x = entity->getState().X + sint32( cos(entity->getState().Heading) * 2000 );
1286 sint32 y = entity->getState().Y + sint32( sin(entity->getState().Heading) * 2000 );
1287 ch->allowNearPetTp();
1288 ch->tpWanted( x,y, entity->getState().Z );
1289 }
1290 else
1291 {
1292 nlwarning("<cbClientTpBot> Unknown bot %s", botId.toString().c_str() );
1293 }
1294 }
1295 else
1296 {
1297 nlwarning("<cbClientTpBot> Unknown character %s or don't have priv", idPlayer.toString().c_str() );
1298 }
1299 }*/
1300
1301 //
1302 /*void cbClientTpWanted( NLNET::CMessage& msgin, const std::string &serviceName, uint16 serviceId)
1303 {
1304 CEntityId Id;
1305 sint32 x, y, z;
1306
1307 msgin.serial( Id );
1308 msgin.serial( x );
1309 msgin.serial( y );
1310 msgin.serial( z );
1311
1312 CCharacter *ch = PlayerManager.getChar( Id );
1313 if ( ch && ch->havePriv(PriviliegeGameMaster))
1314 {
1315 ch->forbidNearPetTp();
1316 ch->tpWanted( x, y , z );
1317 }
1318 else
1319 {
1320 nlwarning("<cbClientTpWanted> Unknown character %s or don't have priv", Id.toString().c_str() );
1321 }
1322
1323 }*/
1324
1325
1326 // client want tp at respawn point (beta test features for work-arround stuck collide)
1327 /*void cbClientTpRespawn( NLNET::CMessage& msgin, const std::string &serviceName, uint16 serviceId)
1328 {
1329 CEntityId characterId;
1330 msgin.serial( characterId );
1331
1332 CCharacter *ch = PlayerManager.getChar( characterId );
1333 if ( ch )
1334 {
1335 COfflineEntityState state = PlayerManager.getStartState( ch->getActiveRole() );
1336 ch->allowNearPetTp();
1337 ch->tpWanted( state.X, state.Y, state.Z );
1338 }
1339 }*/
1340
1341
1342 ///////////////////////////////////////////////////////////////////////////////////////////////////
1343 ///////////////////////////////////////////////////////////////////////////////////////////////////
1344 // CLIENT:ANIMALS
1345 ///////////////////////////////////////////////////////////////////////////////////////////////////
1346 ///////////////////////////////////////////////////////////////////////////////////////////////////
1347
1348 //
1349 void cbClientAnimalsBeast( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId)
1350 {
1351 cbAnimalCommand(msgin, serviceName, serviceId);
1352 }
1353
1354 /*
1355 void cbClientAnimalsDisbandConvoy( NLNET::CMessage& msgin, const std::string &serviceName, uint16 serviceId)
1356 {
1357 CEntityId id;
1358 msgin.serial( id );
1359
1360 CCharacter * c = PlayerManager.getChar( id );
1361 if( c && c->getEnterFlag() )
1362 {
1363 c->setAfkState(false);
1364 c->clearBeastTrain();
1365 }
1366 else
1367 {
1368 nlwarning("<cbClientAnimalsDisbandConvoy> received message from unknown client %s", id.toString().c_str() );
1369 }
1370 }
1371 */
1372
1373
1374 /*
1375 ///////////////////////////////////////////////////////////////////////////////////////////////////
1376 ///////////////////////////////////////////////////////////////////////////////////////////////////
1377 // CLIENT:TRADE
1378 ///////////////////////////////////////////////////////////////////////////////////////////////////
1379 ///////////////////////////////////////////////////////////////////////////////////////////////////
1380
1381
1382 void cbClientTradeNextPage( NLNET::CMessage& msgin, const std::string &serviceName, uint16 serviceId)
1383 {
1384 CEntityId userId;
1385 uint16 session;
1386 msgin.serial(userId);
1387 msgin.serial(session);
1388 CCharacter * c = PlayerManager.getChar( userId );
1389 if ( c )
1390 ;//c->tradeNextPage(session);
1391 else
1392 nlwarning("<cbClientTradeNextPage> Invalid user %s",userId.toString().c_str());
1393
1394 }
1395
1396
1397 void cbClientTradeMissionNextPage( NLNET::CMessage& msgin, const std::string &serviceName, uint16 serviceId)
1398 {
1399 CEntityId userId;
1400 uint16 session;
1401 msgin.serial(userId);
1402 msgin.serial(session);
1403 CCharacter * c = PlayerManager.getChar( userId );
1404 if ( c )
1405 ;//c->tradeMissionNextPage(session);
1406 else
1407 nlwarning("<cbClientTradeNextPage> Invalid user %s",userId.toString().c_str());
1408 }
1409
1410 // Client want buy an item
1411 void cbClientTradeBuy( NLNET::CMessage& msgin, const std::string &serviceName, uint16 serviceId)
1412 {
1413 cbTradeBuySomething(msgin, serviceName, serviceId);
1414 }
1415
1416
1417 // Client ask selling price of an item
1418 void cbClientTradeQuerySellPrice( NLNET::CMessage& msgin, const std::string &serviceName, uint16 serviceId)
1419 {
1420 CEntityId id;
1421 uint16 Inventory, Slot;
1422
1423 msgin.serial( id );
1424 msgin.serial( Inventory );
1425 msgin.serial( Slot );
1426
1427 CCharacter * c = PlayerManager.getChar( id );
1428 if( c )
1429 {
1430 c->askSellPrice( Inventory, Slot );
1431 }
1432 else
1433 {
1434 nlwarning("<cbClientTradeQuerySellPrice> received message from unknown client %s", id.toString().c_str() );
1435 }
1436 }
1437
1438 // Client sell an item
1439 void cbClientTradeSellItem( NLNET::CMessage& msgin, const std::string &serviceName, uint16 serviceId)
1440 {
1441 CEntityId id;
1442 uint16 Inventory, Slot;
1443 uint16 Quantity;
1444
1445 msgin.serial( id );
1446 msgin.serial( Inventory );
1447 msgin.serial( Slot );
1448 msgin.serial( Quantity );
1449
1450 CCharacter * c = PlayerManager.getChar( id );
1451 if( c )
1452 {
1453 c->sellItem( Inventory, Slot, Quantity );
1454 }
1455 else
1456 {
1457 nlwarning("<cbClientTradeSellItem> received message from unknown client %s", id.toString().c_str() );
1458 }
1459 }
1460 */
1461 ///////////////////////////////////////////////////////////////////////////////////////////////////
1462 ///////////////////////////////////////////////////////////////////////////////////////////////////
1463 // CLIENT:EXCHANGE
1464 ///////////////////////////////////////////////////////////////////////////////////////////////////
1465 ///////////////////////////////////////////////////////////////////////////////////////////////////
1466
1467 //
1468 void cbClientExchangeProposal( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId)
1469 {
1470 cbExchangeProposal(msgin, serviceName, serviceId);
1471 }
1472
1473 //
1474 void cbClientExchangeAcceptInvitation( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId)
1475 {
1476 cbAcceptExchangeInvitation(msgin, serviceName, serviceId);
1477 }
1478
1479 //
1480 void cbClientExchangeDeclineInvitation( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId)
1481 {
1482 cbDeclineExchangeInvitation(msgin, serviceName, serviceId);
1483 }
1484
1485 //
1486 void cbClientExchangeSeeds( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId)
1487 {
1488 cbExchangeSeeds(msgin, serviceName, serviceId);
1489 }
1490
1491 //
1492 void cbClientExchangeEnd( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId)
1493 {
1494 cbEndExchange(msgin, serviceName, serviceId);
1495 }
1496
1497 //
1498 void cbClientExchangeValidate( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId)
1499 {
1500 cbAcceptExchange(msgin, serviceName, serviceId);
1501 }
1502
1503
1504 void cbClientExchangeInvalidate( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId)
1505 {
1506 H_AUTO(cbClientExchangeInvalidate);
1507
1508 CEntityId id;
1509 msgin.serial(id);
1510 CCharacter * c = PlayerManager.getChar( id );
1511 if (c && c->getEnterFlag() )
1512 {
1513 c->setAfkState(false);
1514 c->invalidateExchange();
1515 }
1516 else
1517 nlwarning("<cbClientExchangeInvalidate : invalid char %s>",id.toString().c_str());
1518 }
1519
1520 void cbClientExchangeAdd( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId)
1521 {
1522 H_AUTO(cbClientExchangeAdd);
1523
1524 CEntityId id;
1525 msgin.serial(id);
1526
1527 uint16 invSrc, slotSrc, slotDest;
1528 uint16 quantity;
1529
1530 msgin.serial(invSrc);
1531 msgin.serial(slotSrc);
1532 msgin.serial(slotDest);
1533 msgin.serial(quantity);
1534
1535 CCharacter * c = PlayerManager.getChar( id );
1536 if (c && c->getEnterFlag() )
1537 {
1538 c->setAfkState(false);
1539 c->incInterfaceCounter();
1540 c->itemInvToExchange(invSrc, slotSrc, slotDest, quantity);
1541 }
1542 else
1543 nlwarning("<cbClientExchangeAdd : invalid char %s>",id.toString().c_str());
1544 }
1545
1546 void cbClientExchangeRemove( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId)
1547 {
1548 H_AUTO(cbClientExchangeRemove);
1549
1550 CEntityId id;
1551 msgin.serial(id);
1552
1553 uint16 slotSrc;
1554 msgin.serial(slotSrc);
1555
1556 CCharacter * c = PlayerManager.getChar( id );
1557 if (c && c->getEnterFlag() )
1558 {
1559 c->setAfkState(false);
1560 c->incInterfaceCounter();
1561 c->itemExchangeToBag(slotSrc);
1562 }
1563 else
1564 nlwarning("<cbClientExchangeRemove : invalid char %s>",id.toString().c_str());
1565 }
1566
1567 ///////////////////////////////////////////////////////////////////////////////////////////////////
1568 ///////////////////////////////////////////////////////////////////////////////////////////////////
1569 // BRICK/SENTENCE RELATED COMMANDS
1570 ///////////////////////////////////////////////////////////////////////////////////////////////////
1571 ///////////////////////////////////////////////////////////////////////////////////////////////////
1572
1573 //
1574 /*void cbClientSentenceCancelCurrent( NLNET::CMessage& msgin, const std::string &serviceName, uint16 serviceId )
1575 {
1576 cbCancelCurrentSentence(msgin, serviceName, serviceId);
1577 }
1578
1579 //
1580 void cbClientSentenceCancel( NLNET::CMessage& msgin, const std::string &serviceName, uint16 serviceId )
1581 {
1582 cbCancelSentence(msgin, serviceName, serviceId);
1583 }
1584
1585 //
1586 void cbClientSentenceCancelAll( NLNET::CMessage& msgin, const std::string &serviceName, uint16 serviceId )
1587 {
1588 cbCancelAllSentences(msgin, serviceName, serviceId);
1589 }
1590 */
1591
1592
1593
1594
1595 ///////////////////////////////////////////////////////////////////////////////////////////////////
1596 ///////////////////////////////////////////////////////////////////////////////////////////////////
1597 // bot chat missions commands
1598 ///////////////////////////////////////////////////////////////////////////////////////////////////
1599 ///////////////////////////////////////////////////////////////////////////////////////////////////
1600
1601 /// start the static mission interface
1602 void cbClientBotChatChooseStaticMission( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId );
1603
1604 /// ask for the next mission page
1605 void cbClientBotChatNextMissionPage( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId );
1606
1607 /// pick a static mission
1608 void cbClientBotChatPickStaticMission( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId );
1609
1610 ///continue a mission by ending the current step
1611 void cbClientContinueMission( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId );
1612
1613 ///validate a gift to a bot
1614 void cbClientValidateMissionGift( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId );
1615
1616 /// client ends a bot gift
1617 void cbClientBotChatEndGift( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId );
1618
1619 /// client sends a dynamic bot chat nswer
1620 void cbClientBotChatDynChatSend( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId );
1621
1622 // client abandons a mission
1623 void cbClientAbandonMission( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId );
1624
1625 // client abandons a group mission
1626 void cbClientGroupAbandonMission( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId );
1627
1628
1629 ///////////////////////////////////////////////////////////////////////////////////////////////////
1630 ///////////////////////////////////////////////////////////////////////////////////////////////////
1631 // bot chat trade
1632 ///////////////////////////////////////////////////////////////////////////////////////////////////
1633 ///////////////////////////////////////////////////////////////////////////////////////////////////
1634
1635
1636 /// open interface for item trade
1637 void cbClientBotChatStartTradeItem( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId )
1638 {
1639 H_AUTO(cbClientBotChatStartTradeItem);
1640
1641 uint16 session;
1642 CEntityId userId;
1643 msgin.serial(userId,session);
1644 CCharacter * user = PlayerManager.getChar(userId);
1645
1646 if ( !user )
1647 {
1648 nlwarning("<cbClientBotChatStartTradeItem> Invalid char %s",userId.toString().c_str());
1649 return;
1650 }
1651 // check character is ready
1652 if (!user->getEnterFlag())
1653 {
1654 nlwarning("<cbClientBotChatStartTradeItem> player Id %s not yet ready", userId.toString().c_str() );
1655 return;
1656 }
1657
1658 // start a bot chat
1659 if ( !user->startBotChat( BOTCHATTYPE::TradeItemFlag ) )
1660 {
1661 return;
1662 }
1663
1664 user->resetRawMaterialItemPartFilter();
1665 user->resetItemTypeFilter();
1666 user->startTradeItemSession(session);
1667 user->setAfkState(false);
1668 }
1669
1670 /// open interface for teleport trade
1671 void cbClientBotChatStartTradeTp( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId )
1672 {
1673 H_AUTO(cbClientBotChatStartTradeTp);
1674
1675 uint16 session;
1676 CEntityId userId;
1677 msgin.serial(userId,session);
1678 CCharacter * user = PlayerManager.getChar(userId);
1679
1680 if ( !user )
1681 {
1682 nlwarning("<cbClientBotChatStartTradeTp> Invalid char %s",userId.toString().c_str());
1683 return;
1684 }
1685 // check character is ready
1686 if (!user->getEnterFlag())
1687 {
1688 nlwarning("<cbClientBotChatStartTradeTp> player Id %s not yet ready", userId.toString().c_str() );
1689 return;
1690 }
1691
1692 // start a bot chat
1693 if ( !user->startBotChat( BOTCHATTYPE::TradeTeleportFlag ) )
1694 {
1695 return;
1696 }
1697 user->startTradeItemSession(session);
1698 user->setAfkState(false);
1699 }
1700
1701 /// open interface for faction item trade
1702 void cbClientBotChatStartTradeFaction( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId )
1703 {
1704 H_AUTO(cbClientBotChatStartTradeFaction);
1705
1706 uint16 session;
1707 CEntityId userId;
1708 msgin.serial(userId,session);
1709 CCharacter * user = PlayerManager.getChar(userId);
1710
1711 if ( !user )
1712 {
1713 nlwarning("<cbClientBotChatStartTradeFaction> Invalid char %s",userId.toString().c_str());
1714 return;
1715 }
1716 // check character is ready
1717 if (!user->getEnterFlag())
1718 {
1719 nlwarning("<cbClientBotChatStartTradeFaction> player Id %s not yet ready", userId.toString().c_str() );
1720 return;
1721 }
1722
1723 // start a bot chat
1724 if ( !user->startBotChat( BOTCHATTYPE::TradeFactionFlag ) )
1725 {
1726 return;
1727 }
1728 user->startTradeItemSession(session);
1729 user->setAfkState(false);
1730 }
1731
1732 /// start trade guild options
1733 void cbClientBotChatStartTradeGuildOptions( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId )
1734 {
1735 H_AUTO(cbClientBotChatStartTradeGuildOptions);
1736 uint16 session;
1737 CEntityId userId;
1738 msgin.serial(userId,session);
1739 CBuildingManager::getInstance()->buildBuildingTradeList(userId,session);
1740 }
1741
1742 /// buy a guild option
1743 void cbClientBotChatBuyGuildOptions( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId )
1744 {
1745 H_AUTO(cbClientBotChatBuyGuildOptions);
1746 uint8 idx;
1747 CEntityId userId;
1748 msgin.serial( userId,idx );
1749 CBuildingManager::getInstance()->buyBuildingOption( userId,idx );
1750 }
1751
1752 /// start research with a guild bot
1753 void cbClientBotChatStartGuildResearch( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId )
1754 {
1755 H_AUTO(cbClientBotChatStartGuildResearch);
1756
1757 uint16 session;
1758 CEntityId userId;
1759 msgin.serial(userId,session);
1760
1761 /// todo appart
1762 // CGuildManager::getInstance()->buildGuildResearchList(userId,session);
1763 }
1764
1765
1766 /// trade next page
1767 void cbClientBotChatTradeNextPage( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId )
1768 {
1769 H_AUTO(cbClientBotChatTradeNextPage);
1770
1771 uint16 session;
1772 CEntityId userId;
1773 msgin.serial(userId,session);
1774 CCharacter * user = PlayerManager.getChar(userId);
1775
1776 if ( !user )
1777 {
1778 nlwarning("<cbClientBotChatTradeNextPage> Invalid char %s",userId.toString().c_str());
1779 return;
1780 }
1781 // check character is ready
1782 if (!user->getEnterFlag())
1783 {
1784 nlwarning("<cbClientBotChatTradeNextPage> player Id %s not yet ready", userId.toString().c_str() );
1785 return;
1786 }
1787 user->fillTradePage(session);
1788
1789 }
1790
1791 /// buy an item
1792 void cbClientBotChatTradeBuy( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId )
1793 {
1794 H_AUTO(cbClientBotChatTradeBuy);
1795
1796 uint16 idx;
1797 uint16 quantity;
1798 CEntityId userId;
1799 msgin.serial(userId,idx,quantity);
1800 CCharacter * user = PlayerManager.getChar(userId);
1801
1802 if ( !user )
1803 {
1804 nlwarning("<cbClientBotChatTradeBuy> Invalid char %s",userId.toString().c_str());
1805 return;
1806 }
1807 // check character is ready
1808 if (!user->getEnterFlag())
1809 {
1810 nlwarning("<cbClientBotChatTradeBuy> player Id %s not yet ready", userId.toString().c_str() );
1811 return;
1812 }
1813 user->buyItem( idx,quantity);
1814 user->setAfkState(false);
1815 }
1816
1817 // destroy an item in sale store
1818 void cbClientBotChatTradeDestroy( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId )
1819 {
1820 H_AUTO(cbClientBotChatTradeDestroy);
1821 uint16 idx;
1822 uint16 quantity;
1823 CEntityId userId;
1824 try
1825 {
1826 msgin.serial(userId,idx,quantity);
1827 }
1828 catch(const Exception &e)
1829 {
1830 nlwarning("Bad cbClientBotChatTradeDestroy serialisation '%s'", e.what());
1831 return;
1832 }
1833 CCharacter * user = PlayerManager.getChar(userId);
1834
1835 if ( !user )
1836 {
1837 nlwarning("<cbClientBotChatTradeDestroy> Invalid char %s",userId.toString().c_str());
1838 return;
1839 }
1840 // check character is ready
1841 if (!user->getEnterFlag())
1842 {
1843 nlwarning("<cbClientBotChatTradeDestroy> player Id %s not yet ready", userId.toString().c_str() );
1844 return;
1845 }
1846 user->destroySaleItem( idx,quantity);
1847 user->setAfkState(false);
1848 }
1849
1850 // sell item
1851 void cbClientBotChatTradeSell( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId )
1852 {
1853 H_AUTO(cbClientBotChatTradeSell);
1854
1855 uint8 inv;
1856 uint16 idx;
1857 uint16 quantity;
1858 uint32 price;
1859 CEntityId userId;
1860
1861 try
1862 {
1863 msgin.serial(userId,inv,idx,quantity,price);
1864 }
1865 catch(const Exception &e)
1866 {
1867 nlwarning("Bad cbClientBotChatTradeSell serialisation '%s'", e.what());
1868 return;
1869 }
1870
1871 CCharacter * user = PlayerManager.getChar(userId);
1872 if ( !user )
1873 {
1874 nlwarning("<cbClientBotChatTradeSell> Invalid char %s",userId.toString().c_str());
1875 return;
1876 }
1877 // check character is ready
1878 if (!user->getEnterFlag())
1879 {
1880 nlwarning("<cbClientBotChatTradeSell> player Id %s not yet ready", userId.toString().c_str() );
1881 return;
1882 }
1883 user->sellItem(INVENTORIES::TInventory(inv),idx,quantity,price);
1884 user->setAfkState(false);
1885 }
1886
1887 // start a guild creation session
1888 void cbClientBotChatStartGuildCreation( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId )
1889 {
1890 H_AUTO(cbClientBotChatStartGuildCreation);
1891
1892 CEntityId id;
1893 msgin.serial(id);
1894 CCharacter * user = PlayerManager.getChar(id);
1895 if ( !user )
1896 {
1897 nlwarning("<cbClientBotChatStartGuildCreation> Invalid char %s",id.toString().c_str());
1898 return;
1899 }
1900 // check character is ready
1901 if (!user->getEnterFlag())
1902 {
1903 nlwarning("<cbClientBotChatStartGuildCreation> player Id %s not yet ready", id.toString().c_str() );
1904 return;
1905 }
1906
1907 user->setAfkState(false);
1908
1909 if ( !user->startBotChat( BOTCHATTYPE::CreateGuildFlag ) )
1910 return;
1911 }
1912
1913
1914 // start trade actions
1915 void cbClientBotChatStartTradeAction( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId )
1916 {
1917 H_AUTO(cbClientBotChatStartTradeAction);
1918
1919 uint16 sessionId;
1920 CEntityId userId;
1921
1922 msgin.serial(userId, sessionId);
1923
1924 CCharacter * user = PlayerManager.getChar(userId);
1925 if ( !user )
1926 {
1927 nlwarning("<cbClientBotChatStartTradeAction> Invalid char %s",userId.toString().c_str());
1928 return;
1929 }
1930 // check character is ready
1931 if (!user->getEnterFlag())
1932 {
1933 nlwarning("<cbClientBotChatStartTradeAction> player Id %s not yet ready", userId.toString().c_str() );
1934 return;
1935 }
1936 user->setAfkState(false);
1937
1938 // start a bot chat
1939 if ( !user->startBotChat( BOTCHATTYPE::TradePhraseFlag ) )
1940 {
1941 return;
1942 }
1943
1944 user->startTradePhrases(sessionId);
1945 }
1946
1947
1948 void cbClientBotChatSetFilters( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId )
1949 {
1950 H_AUTO(cbClientBotChatSetFilters);
1951 CEntityId userId;
1952
1953 uint32 minQuality, maxQuality, minPrice, maxPrice;
1954 uint8 minClass, maxClass;
1955 uint8 itemPartFilter;
1956 uint8 itemTypeFilter;
1957
1958 msgin.serial(userId, minQuality, maxQuality, minPrice, maxPrice);
1959 msgin.serial(minClass, maxClass, itemPartFilter, itemTypeFilter);
1960
1961 CCharacter * user = PlayerManager.getChar(userId);
1962 if ( !user )
1963 {
1964 nlwarning("<cbClientBotChatSetFilters> Invalid char %s",userId.toString().c_str());
1965 return;
1966 }
1967
1968 user->setAfkState(false);
1969 user->setFilters( minQuality, maxQuality, minPrice, maxPrice, (RM_CLASS_TYPE::TRMClassType)minClass, (RM_CLASS_TYPE::TRMClassType)maxClass, (RM_FABER_TYPE::TRMFType)itemPartFilter, (ITEM_TYPE::TItemType)itemTypeFilter );
1970 }
1971
1972 void cbRefreshTradeList( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId )
1973 {
1974 H_AUTO(cbRefreshTradeList);
1975 CEntityId userId;
1976
1977 msgin.serial( userId );
1978 CCharacter * user = PlayerManager.getChar(userId);
1979 if ( !user )
1980 {
1981 nlwarning("<cbClientBotChatSetFilters> Invalid char %s",userId.toString().c_str());
1982 return;
1983 }
1984 user->refreshTradeList();
1985 }
1986
1987
1988
1989 ///////////////////////////////////////////////////////////////////////////////////////////////////
1990 ///////////////////////////////////////////////////////////////////////////////////////////////////
1991 // Client bot chat end
1992 ///////////////////////////////////////////////////////////////////////////////////////////////////
1993 ///////////////////////////////////////////////////////////////////////////////////////////////////
1994 void cbClientBotChatEnd( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId )
1995 {
1996 H_AUTO(cbClientBotChatEnd);
1997
1998 CEntityId userId;
1999 msgin.serial(userId);
2000 CCharacter* user = PlayerManager.getChar( userId );
2001 if (user && user->getEnterFlag())
2002 {
2003 user->endBotChat();
2004 user->incInterfaceCounter();
2005 user->setAfkState(false);
2006 }
2007 else
2008 nlwarning("<cbClientBotChatEnd> invalid character %s", userId.toString().c_str());
2009 }
2010
2011 ///////////////////////////////////////////////////////////////////////////////////////////////////
2012 ///////////////////////////////////////////////////////////////////////////////////////////////////
2013 // PLAYER COMMAND
2014 ///////////////////////////////////////////////////////////////////////////////////////////////////
2015 ///////////////////////////////////////////////////////////////////////////////////////////////////
2016
2017 // client send an emote
2018 void cbClientSendEmote( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId )
2019 {
2020 H_AUTO(cbClientSendEmote);
2021
2022 CEntityId id;
2023 MBEHAV::EBehaviour behaviour = MBEHAV::IDLE;
2024 uint16 emoteTextId;
2025 try
2026 {
2027 msgin.serial( id );
2028 msgin.serialEnum( behaviour );
2029 msgin.serial( emoteTextId );
2030 }
2031 catch(const Exception &e)
2032 {
2033 nlwarning("Bad emote serialisation '%s'", e.what());
2034 return;
2035 }
2036
2037 CCharacter * c = PlayerManager.getChar( id );
2038 if( c && c->getEnterFlag() )
2039 {
2040 // check if client can launch this emote from his UI
2041 const CStaticTextEmotes & emotes = CSheets::getTextEmoteList();
2042 const CStaticTextEmotes::CTextEmotePhrases * phraseCont = emotes.getPhrase( emoteTextId );
2043 if ( phraseCont != NULL )
2044 {
2045 if( phraseCont->UsableFromClientUI == false )
2046 {
2047 nlwarning("<cbClientSendEmote> client %s sent a forbidden emote : %u",c->getId().toString().c_str(),emoteTextId );
2048 return;
2049 }
2050 }
2051
2052 c->sendEmote( id, behaviour, emoteTextId );
2053 }
2054 else
2055 {
2056 nlwarning("<cbClientSendEmote> received message from unknown client %s", id.toString().c_str() );
2057 }
2058 }
2059
2060
2061 // client send a custom emote
2062 void cbClientSendCustomEmote( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId )
2063 {
2064 H_AUTO(cbClientSendCustomEmote);
2065
2066 CEntityId id;
2067 MBEHAV::EBehaviour behaviour = MBEHAV::IDLE;
2068 ucstring emoteCustomText;
2069 try
2070 {
2071 msgin.serial( id );
2072 msgin.serialEnum( behaviour );
2073 msgin.serial( emoteCustomText );
2074 }
2075 catch(const Exception &e)
2076 {
2077 nlwarning("Bad custom emote serialisation '%s'", e.what());
2078 return;
2079 }
2080
2081 if (behaviour >= (MBEHAV::EMOTE_BEGIN + 80) && behaviour <= (MBEHAV::EMOTE_BEGIN + 109))
2082 {
2083 string name = CEntityIdTranslator::getInstance()->getByEntity(id).toString();
2084 nlwarning("HACK: %s %s tries to launch a firework %d", id.toString().c_str(), name.c_str(), behaviour);
2085 return;
2086 }
2087
2088 CCharacter * c = PlayerManager.getChar( id );
2089 if( c && c->getEnterFlag() )
2090 {
2091 c->sendCustomEmote( id, behaviour, emoteCustomText );
2092 }
2093 else
2094 {
2095 nlwarning("<cbClientSendCustomEmote> received message from unknown client %s", id.toString().c_str() );
2096 }
2097 }
2098
2099 // client send a command where for known where is it
2100 void cbClientSendWhere( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId )
2101 {
2102 H_AUTO(cbClientSendWhere);
2103
2104 CEntityId id;
2105 msgin.serial( id );
2106 CZoneManager::getInstance().answerWhere(id);
2107 }
2108
2109 // client send a command where for known where is it
2110 void cbClientSendAfk( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId )
2111 {
2112 H_AUTO(cbClientSendAfk);
2113
2114 CEntityId id;
2115 bool afk;
2116 msgin.serial( id );
2117 msgin.serial( afk );
2118 CCharacter * user = PlayerManager.getChar( id );
2119 if ( !user )
2120 {
2121 nlwarning("<AFK>'%s' is not a valid user",id.toString().c_str() );
2122 return;
2123 }
2124 user->setAfkState( afk );
2125 }
2126
2127 // client send a command to kill its player
2128 void cbClientSelfKill( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId )
2129 {
2130 H_AUTO(cbClientSelfKill);
2131
2132 CEntityId id;
2133 msgin.serial( id );
2134 CCharacter * user = PlayerManager.getChar( id );
2135
2136 if ( !user )
2137 {
2138 nlwarning("<cbClientSelfKill> Invalid char %s", id.toString().c_str());
2139 return;
2140 }
2141 // check character is ready
2142 if (!user->getEnterFlag())
2143 {
2144 nlwarning("<cbClientSelfKill> player Id %s not yet ready", id.toString().c_str() );
2145 return;
2146 }
2147
2148 if (!user->havePriv(":DEV:SGM:GM:VG:SG:G:EM:EG:"))
2149 return;
2150
2151 // disable command if pvp flagged recent (red flag)
2152 if (user->getPvPRecentActionFlag())
2153 {
2154 CCharacter::sendDynamicSystemMessage(id, "PVP_COMMAND_FORBIDDEN");
2155 return;
2156 }
2157
2158 user->setAfkState(false);
2159 user->killMe();
2160 }
2161
2162 // client send a command to roll a dice
2163 void cbClientRollDice( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId )
2164 {
2165 H_AUTO(cbClientRollDice);
2166
2167 CEntityId entityId;
2168 sint16 min;
2169 sint16 max;
2170 sint16 roll;
2171 msgin.serial( entityId );
2172 msgin.serial( min );
2173 msgin.serial( max );
2174
2175 static NLMISC::CRandom* dice = (NLMISC::CRandom*)NULL;
2176 if (!dice)
2177 {
2178 dice = new NLMISC::CRandom;
2179 dice->srand(CTickEventHandler::getGameCycle());
2180 }
2181
2182 roll = min + (sint16)dice->rand(max-min);
2183
2184 SM_STATIC_PARAMS_4(params, STRING_MANAGER::player, STRING_MANAGER::integer, STRING_MANAGER::integer, STRING_MANAGER::integer);
2185 params[0].setEIdAIAlias(entityId, CAIAliasTranslator::getInstance()->getAIAlias(entityId));
2186 params[1].Int = min;
2187 params[2].Int = max;
2188 params[3].Int = roll;
2189
2190 TDataSetRow playerRowId = TheDataset.getDataSetRow( entityId );
2191 if ( !TheDataset.isAccessible(playerRowId) )
2192 return;
2193
2194 PHRASE_UTILITIES::sendDynamicSystemMessage(playerRowId, "ROLL_DICE", params);
2195 STRING_MANAGER::sendSystemStringToClientAudience(playerRowId, std::vector<NLMISC::CEntityId>(), CChatGroup::shout, "ROLL_DICE", params);
2196 }
2197
2198 // client send command sit (for sit/up)
2199 void cbClientSit( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId )
2200 {
2201 H_AUTO(cbClientSit);
2202
2203 CEntityId id;
2204 bool sit;
2205 msgin.serial( id );
2206 msgin.serial( sit );
2207
2208 CCharacter * c = PlayerManager.getChar( id );
2209 if( c && c->getEnterFlag() )
2210 {
2211 c->setAfkState(false);
2212 if( sit )
2213 {
2214 if( !c->isInWater() && c->getMode()!=MBEHAV::MOUNT_NORMAL && c->getMode()!=MBEHAV::DEATH )
2215 {
2216 c->setMode( MBEHAV::SIT );
2217 // only if player is'nt equipping an item
2218 //( to prevent exploit "sit to reduce equip latency time")
2219 if( !c->getGearLatency().isLatent() )
2220 {
2221 c->cancelStaticActionInProgress(STATIC_ACT_TYPES::Neutral, false, false);
2222 }
2223 c->cancelStaticEffects();
2224 }
2225 }
2226 else
2227 {
2228 c->setMode( MBEHAV::NORMAL );
2229 }
2230 }
2231 else
2232 {
2233 nlwarning("<cbClientSendWhere> received message from unknown client %s", id.toString().c_str() );
2234 }
2235 }
2236
2237
2238 // client send a command to change guild motd
2239 void cbClientGuildMotd( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId )
2240 {
2241 H_AUTO(cbClientGuildMotd);
2242
2243 CEntityId entityId;
2244 string motd;
2245 msgin.serial( entityId );
2246 msgin.serial( motd );
2247
2248 CCharacter * user = PlayerManager.getChar( entityId );
2249 if (!user)
2250 {
2251 nlwarning("<cbClientGuildMotd>'%s' is not a valid char",entityId.toString().c_str());
2252 return;
2253 }
2254 if (!user->getEnterFlag())
2255 {
2256 nlwarning("<cbClientGuildMotd>'%s' is not entered", entityId.toString().c_str());
2257 return;
2258 }
2259 if (!TheDataset.isAccessible(user->getEntityRowId()))
2260 {
2261 nlwarning("<cbClientGuildMotd>'%s' is not valid in mirror", entityId.toString().c_str());
2262 return;
2263 }
2264
2265 CGuild * guild = CGuildManager::getInstance()->getGuildFromId( user->getGuildId() );
2266 if( guild )
2267 {
2268 guild->setMOTD(motd, entityId);
2269 }
2270 }
2271
2272
2273 ///////////////////////////////////////////////////////////////////////////////////////////////////
2274 ///////////////////////////////////////////////////////////////////////////////////////////////////
2275 // CLIENT:CHEAT
2276 ///////////////////////////////////////////////////////////////////////////////////////////////////
2277 ///////////////////////////////////////////////////////////////////////////////////////////////////
2278
2279 // turn character to god mod
2280 //void cbGodMode( NLNET::CMessage& msgin, const std::string &serviceName, uint16 serviceId);
2281 /*void cbClientCheatGod( NLNET::CMessage& msgin, const std::string &serviceName, uint16 serviceId)
2282 {
2283 CEntityId id;
2284 msgin.serial( id );
2285
2286 CCharacter * c = PlayerManager.getChar( id );
2287 if( c && c->havePriv(PriviliegeGameMaster))
2288 {
2289 c->ToggleGodMode();
2290 }
2291
2292 // cbGodMode(msgin, serviceName, serviceId);
2293 }*/
2294
2295 /*
2296 void cbClientCreateItemInBag( NLNET::CMessage& msgin, const std::string &serviceName, uint16 serviceId)
2297 {
2298 CEntityId charId;
2299 msgin.serial( charId );
2300
2301 CSheetId itemSheetId;
2302 msgin.serial( itemSheetId );
2303
2304 uint16 quantity;
2305 msgin.serial( quantity );
2306
2307 uint16 quality;
2308 msgin.serial( quality );
2309
2310 // get character
2311 CCharacter *c = PlayerManager.getChar( charId );
2312 if (c&& c->havePriv(PriviliegeGameMaster))
2313 {
2314 nlwarning("<cbClientCreateItemInBag> Invalid player Id %s", charId.toString().c_str() );
2315 return;
2316 }
2317
2318 c->createItemInBag( quality, quantity, itemSheetId );
2319 }*/
2320
2321 /*// character learn all existing bricks
2322 void cbClientLearnAllBricks( NLNET::CMessage& msgin, const std::string &serviceName, uint16 serviceId)
2323 {
2324 CEntityId id;
2325 msgin.serial( id );
2326
2327 CCharacter * c = PlayerManager.getChar( id );
2328 if( c && c->havePriv(PriviliegeGameMaster))
2329 GameItemManager.learnAllBricks( c );
2330 else
2331 nlwarning("cbClientLearnAllBricks, unknown player '%s'", id.toString().c_str() );
2332 }
2333 */
2334
2335 // client ask to add money to his character
2336 /*void cbClientMoney( NLNET::CMessage& msgin, const std::string &serviceName, uint16 serviceId )
2337 {
2338 CEntityId id;
2339 msgin.serial ( id );
2340
2341 sint32 vb, b, m, s;
2342
2343 msgin.serial ( vb );
2344 msgin.serial ( b );
2345 msgin.serial ( m );
2346 msgin.serial ( s );
2347
2348 CCharacter * c = PlayerManager.getChar( id );
2349 if( c && c->havePriv(PriviliegeGameMaster))
2350 {
2351 c->giveSeed( CSeeds( vb, b, m, s ) );
2352 }
2353 }*/
2354
2355 /*// Client want set Ryzom Time
2356 void cbClientRyzomTime( NLNET::CMessage& msgin, const std::string &serviceName, uint16 serviceId )
2357 {
2358 CEntityId Id;
2359 msgin.serial( Id );
2360
2361 if (!PlayerManager.havePriv(Id, PriviliegeGameMaster))
2362 return;
2363
2364 float Time;
2365 msgin.serial( Time );
2366
2367 CMessage msgout( "SET_RYZOM_TIME" );
2368 msgout.serial( Time );
2369 sendMessageViaMirror( "WOS", msgout );
2370 }
2371
2372 // Client want set Ryzom Day
2373 void cbClientRyzomDay( NLNET::CMessage& msgin, const std::string &serviceName, uint16 serviceId )
2374 {
2375 CEntityId Id;
2376 msgin.serial( Id );
2377
2378 if (!PlayerManager.havePriv(Id, PriviliegeGameMaster))
2379 return;
2380
2381 uint32 Day;
2382 msgin.serial( Day );
2383
2384 CMessage msgout( "SET_RYZOM_DAY" );
2385 msgout.serial( Day );
2386 sendMessageViaMirror( "WOS", msgout );
2387 }
2388 */
2389 // Client want gain xp in indicated skill
2390 /*void cbClientGainXp( NLNET::CMessage& msgin, const std::string &serviceName, uint16 serviceId )
2391 {
2392 CEntityId Id;
2393 string Skill, Speciality;
2394 uint32 Xp;
2395
2396 msgin.serial( Id );
2397 msgin.serial( Xp );
2398 msgin.serial( Skill );
2399
2400 CCharacter * c = PlayerManager.getChar( Id );
2401 if( c && c->havePriv(PriviliegeGameMaster))
2402 {
2403 c->addXpToSkill( (double) Xp, Skill );
2404 }
2405 }
2406 */
2407 // Client create a new character
2408 /*void cbClientCreateCharacter( NLNET::CMessage& msgin, const std::string &serviceName, uint16 serviceId )
2409 {
2410 CEntityId id;
2411 string characterName;
2412 EGSPD::CPeople::TPeople people;
2413 GSGENDER::EGender gender;
2414 //Deprecated
2415 // ROLES::ERole role;
2416 uint16 level;
2417
2418 msgin.serial( id );
2419 msgin.serial( characterName );
2420 msgin.serialEnum( people );
2421 msgin.serialEnum( gender );
2422 // msgin.serialEnum( role );
2423 msgin.serial( level );
2424
2425 CCharacter * c = PlayerManager.getChar( id );
2426 if( c && c->havePriv(PriviliegeGameMaster))
2427 {
2428 uint32 playerId = PlayerManager.getPlayerId( id );
2429 CPlayer * player = PlayerManager.getPlayer( playerId );
2430 if( player )
2431 {
2432 player->replaceCharacter( characterName, people, gender, level );
2433 PlayerManager.savePlayer( playerId );
2434 }
2435 }
2436 }
2437 */
2438 // Client create a new character
2439 /*void cbClientAddRole( NLNET::CMessage& msgin, const std::string &serviceName, uint16 serviceId )
2440 {
2441 CEntityId id;
2442 ROLES::ERole role;
2443 uint16 level;
2444
2445 msgin.serial( id );
2446 msgin.serialEnum( role );
2447 msgin.serial( level );
2448
2449 CCharacter * c = PlayerManager.getChar( id );
2450 if( c && c->havePriv(PriviliegeGameMaster))
2451 {
2452 c->getRoles().addNewJob( JOBS::getJobForRace( role, (EGSPD::CPeople::TPeople) c->getRace() ) );
2453 }
2454 }
2455 */
2456 // Client want to learn bricks
2457 /*void cbClientLearnBrick( NLNET::CMessage& msgin, const std::string &serviceName, uint16 serviceId )
2458 {
2459 CEntityId id;
2460 ROLES::ERole role;
2461 uint16 level;
2462
2463 msgin.serial( id );
2464 msgin.serialEnum( role );
2465 msgin.serial( level );
2466
2467 CCharacter * c = PlayerManager.getChar( id );
2468 if( c && c->havePriv(PriviliegeGameMaster))
2469 {
2470 GameItemManager.learnAllBricksForRoleAndRace( c, role, (EGSPD::CPeople::TPeople) c->getRace(), level );
2471 }
2472 }*/
2473
2474 /// cient want to learn all faber plans
2475 /*void cbClientLearnAllFaberPlans( NLNET::CMessage& msgin, const std::string &serviceName, uint16 serviceId )
2476 {
2477 CEntityId id;
2478
2479 msgin.serial( id );
2480
2481 CCharacter * c = PlayerManager.getChar( id );
2482 if( c && c->havePriv(PriviliegeGameMaster))
2483 {
2484 c->learnAllFaberPlans();
2485 }
2486 } // cbClientLearnAllFaberPlans //
2487 */
2488
2489 /*
2490 * CLIENT:DEBUG
2491 */
2492
2493 // Send server client coordinate
2494 void cbClientWhere( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId )
2495 {
2496 H_AUTO(cbClientWhere);
2497
2498 CEntityId id;
2499 msgin.serial( id );
2500 CCharacter * c = PlayerManager.getChar( id );
2501 if( c && c->getEnterFlag() )
2502 {
2503 c->setAfkState(false);
2504 CMessage msgout( "IMPULSION_ID" );
2505 msgout.serial( id );
2506 CBitMemStream bms;
2507 if ( ! GenericMsgManager.pushNameToStream( "DEBUG:REPLY_WHERE", bms) )
2508 {
2509 nlwarning("<cbClientWhere> Msg name DEBUG:REPLY_WHERE not found");
2510 return;
2511 }
2512 bms.serial( const_cast< sint32& > (c->getState().X.getValue()) );
2513 bms.serial( const_cast< sint32& > (c->getState().Y.getValue()) );
2514 bms.serial( const_cast< sint32& > (c->getState().Z.getValue()) );
2515 msgout.serialBufferWithSize((uint8*)bms.buffer(), bms.length());
2516 CUnifiedNetwork::getInstance()->send( NLNET::TServiceId(id.getDynamicId()), msgout );
2517 }
2518 }
2519
2520
2521 // local macro definition ( undef below )
2522 #define SEND_GM_WHO_ANSWER( _code_ , _msg_) {\
2523 gms = PlayerManager.getSpecialUsers(_code_);\
2524 if ( gms && !gms->empty() )\
2525 {\
2526 for ( uint i = 0; i < gms->size(); i++ )\
2527 {\
2528 TDataSetRow row = TheDataset.getDataSetRow( (*gms)[i] );\
2529 if ( TheDataset.isAccessible( row ) )\
2530 {\
2531 CMirrorPropValue<TYPE_WHO_SEES_ME> whoSeesMe(TheDataset, row, DSPropertyWHO_SEES_ME );\
2532 if ( R2_VISION::isEntityVisibleToPlayers(whoSeesMe) )\
2533 {\
2534 params[0].setEId((*gms)[i]);\
2535 CCharacter::sendDynamicSystemMessage( id,_msg_,params );\
2536 nbAnswers++;\
2537 }\
2538 }\
2539 }\
2540 }\
2541 }
2542
2543 // local macro definition ( undef below )
2544 #define SEND_GM_WHO_ANSWER_INVIS( _code_ , _msg_) {\
2545 gms = PlayerManager.getSpecialUsers(_code_);\
2546 if ( gms && !gms->empty() )\
2547 {\
2548 for ( uint i = 0; i < gms->size(); i++ )\
2549 {\
2550 TDataSetRow row = TheDataset.getDataSetRow( (*gms)[i] );\
2551 if ( TheDataset.isAccessible( row ) )\
2552 {\
2553 CMirrorPropValue<TYPE_WHO_SEES_ME> whoSeesMe(TheDataset, row, DSPropertyWHO_SEES_ME );\
2554 if ( !R2_VISION::isEntityVisibleToPlayers(whoSeesMe) )\
2555 {\
2556 params[0].setEId( (*gms)[i] );\
2557 CCharacter::sendDynamicSystemMessage( id,_msg_,params );\
2558 nbAnswers++;\
2559 }\
2560 }\
2561 }\
2562 }\
2563 }
2564
2565 // Send list of connected character name / account to client
2566 void cbClientWho( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId )
2567 {
2568 H_AUTO(cbClientWho);
2569
2570 CEntityId id;
2571 std::string opt;
2572 msgin.serial( id,opt );
2573 const std::vector<CEntityId> * gms = NULL;
2574
2575 // Make sure opt is not like "A(c)" for e acute
2576 ucstring ucopt;
2577 ucopt.fromUtf8(opt);
2578 opt = ucopt.toString();
2579
2580 uint nbAnswers = 0;
2581
2582 // standard who
2583 if ( opt.empty() )
2584 {
2585 CCharacter * user = PlayerManager.getChar( id );
2586 if ( !user )
2587 {
2588 nlwarning("<WHO>'%s' is invalid", id.toString().c_str() );
2589 return;
2590 }
2591 CRegion* region = dynamic_cast<CRegion*>( CZoneManager::getInstance().getPlaceFromId( user->getCurrentRegion() ) );
2592 if ( region == NULL )
2593 {
2594 nlwarning("<WHO>'%s' Invalid region %u", id.toString().c_str(), user->getCurrentRegion() );
2595 return;
2596 }
2597
2598 {
2599 SM_STATIC_PARAMS_1(params, STRING_MANAGER::place);
2600 params[0].Identifier = region->getName();
2601 CCharacter::sendDynamicSystemMessage( id,"WHO_REGION_INTRO",params );
2602 }
2603
2604 // send all users in region
2605 {
2606 SM_STATIC_PARAMS_1(params, STRING_MANAGER::player);
2607 for ( set<CEntityId>::const_iterator it = region->getPlayersInside().begin(); it != region->getPlayersInside().end(); ++it )
2608 {
2609 TDataSetRow row = TheDataset.getDataSetRow( (*it) );
2610 if ( TheDataset.isAccessible( row ) )
2611 {
2612 CCharacter *ch = PlayerManager.getChar( *it );
2613
2614 // check that user are visible to each other and in the same instance
2615 if ( R2_VISION::isEntityVisibleToPlayers(ch->getWhoSeesMe())
2616 && user->getInstanceNumber() == ch->getInstanceNumber())
2617 {
2618 params[0].setEId( (*it) );
2619 CCharacter::sendDynamicSystemMessage( id,"WHO_REGION_LIST", params );
2620 nbAnswers++;
2621 }
2622 }
2623 }
2624 }
2625
2626 }
2627 // GM who
2628 else if ( NLMISC::nlstricmp( opt.c_str(), "GM" ) == 0)
2629 {
2630 TVectorParamCheck params(1);
2631 params[0].Type = STRING_MANAGER::player;
2632 CCharacter::sendDynamicSystemMessage( id,"WHO_GM_INTRO" );
2633 SEND_GM_WHO_ANSWER( ":SGM:","WHO_SGM_LIST" );
2634 SEND_GM_WHO_ANSWER( ":GM:","WHO_GM_LIST" );
2635 SEND_GM_WHO_ANSWER( ":VG:","WHO_VG_LIST" );
2636 SEND_GM_WHO_ANSWER( ":SG:","WHO_SG_LIST" );
2637 SEND_GM_WHO_ANSWER( ":G:","WHO_G_LIST" );
2638
2639 CCharacter * user = PlayerManager.getChar( id );
2640 if ( user )
2641 {
2642 CPlayer *p = PlayerManager.getPlayer(PlayerManager.getPlayerId(user->getId()));
2643 if (p != NULL)
2644 {
2645 bool allowIt = p->havePriv(":DEV:");
2646 if( allowIt || p->havePriv(":SGM:GM:VG:SG:G:") )
2647 {
2648 nbAnswers = 0;
2649 TVectorParamCheck params(1);
2650 params[0].Type = STRING_MANAGER::player;
2651 CCharacter::sendDynamicSystemMessage( id,"WHO_INVISIBLE_GM_INTRO" );
2652 if ( allowIt || p->havePriv(":SGM:") )
2653 {
2654 SEND_GM_WHO_ANSWER_INVIS( ":SGM:","WHO_SGM_LIST" );
2655 allowIt = true;
2656 }
2657 if ( allowIt || p->havePriv(":SGM:GM:") )
2658 {
2659 SEND_GM_WHO_ANSWER_INVIS( ":GM:","WHO_GM_LIST" );
2660 allowIt = true;
2661 }
2662 if ( allowIt || p->havePriv(":SGM:GM:VG:") )
2663 {
2664 SEND_GM_WHO_ANSWER_INVIS( ":VG:","WHO_VG_LIST" );
2665 }
2666 if ( allowIt || p->havePriv(":SGM:GM:VG:SG:") )
2667 {
2668 SEND_GM_WHO_ANSWER_INVIS( ":SG:","WHO_SG_LIST" );
2669 }
2670 SEND_GM_WHO_ANSWER_INVIS( ":G:","WHO_G_LIST" );
2671 }
2672 }
2673 }
2674 }
2675 else
2676 {
2677 TChanID chanID;
2678
2679 CCharacter * user = PlayerManager.getChar( id );
2680 if ( !user )
2681 {
2682 nlwarning("<WHO>'%s' is invalid", id.toString().c_str() );
2683 return;
2684 }
2685 CPlayer *p = PlayerManager.getPlayer(PlayerManager.getPlayerId(user->getId()));
2686
2687 if (NLMISC::nlstricmp( opt.c_str(), "league" ) == 0)
2688 {
2689 chanID = user->getLeagueId();
2690 }
2691 else
2692 {
2693 chanID = DynChatEGS.getChanIDFromName(opt);
2694 }
2695
2696 if (chanID == DYN_CHAT_INVALID_CHAN)
2697 {
2698 CCharacter::sendDynamicSystemMessage( id, "WHO_CHANNEL_NOT_FOUND" );
2699 return;
2700 }
2701
2702 bool havePriv = p->havePriv(":DEV:SGM:GM:EM:");
2703 bool hasChannel = false;
2704 nbAnswers = 0;
2705
2706 vector<NLMISC::CEntityId> players;
2707 DynChatEGS.getPlayersInChan(chanID, players);
2708 ucstring playerNames("");
2709 uint32 shardId = CEntityIdTranslator::getInstance()->getEntityShardId(id);
2710
2711 for (uint i = 0; i < players.size(); i++)
2712 {
2713 if (players[i] == id)
2714 hasChannel = true;
2715
2716 ucstring name = CEntityIdTranslator::getInstance()->getByEntity(players[i]);
2717 if (shardId == CEntityIdTranslator::getInstance()->getEntityShardId(players[i]))
2718 {
2719 // Same shard, remove shard from name
2720 CEntityIdTranslator::removeShardFromName(name);
2721 }
2722 playerNames += ((i > 0) ? "\n" : "") + name ;
2723 }
2724
2725 if (!hasChannel && !havePriv)
2726 {
2727 SM_STATIC_PARAMS_1(params, STRING_MANAGER::literal);
2728 params[0].Literal = opt;
2729 CCharacter::sendDynamicSystemMessage( id, "WHO_CHANNEL_NOT_CONNECTED", params );
2730
2731 return;
2732 }
2733
2734 if (!playerNames.empty())
2735 {
2736 SM_STATIC_PARAMS_1(params, STRING_MANAGER::literal);
2737 params[0].Literal = opt;
2738 CCharacter::sendDynamicSystemMessage( id, "WHO_CHANNEL_INTRO", params);
2739 //playerNames = "Players in channel \"" + opt + "\":" + playerNames;
2740 params[0].Literal = playerNames;
2741 CCharacter::sendDynamicSystemMessage( id, "LITERAL", params );
2742 return;
2743 }
2744 }
2745
2746 if ( nbAnswers == 0 )
2747 {
2748 CCharacter::sendDynamicSystemMessage( id,"WHO_NO_ANSWER" );
2749 }
2750 }
2751
2752 #undef SEND_GM_WHO_ANSWER_INVIS
2753 #undef SEND_GM_WHO_ANSWER
2754
2755 // received a ping from a client, write it to client database
2756 void cbClientPing( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId )
2757 {
2758 CEntityId id;
2759 msgin.serial( id );
2760
2761 TGameCycle time;
2762 msgin.serial( time );
2763
2764 CCharacter * c = PlayerManager.getChar( id );
2765 if( c )
2766 {
2767 // c->_PropertyDatabase.setProp( c->getDataIndexReminder()->DATABASE_PING.PING, time );
2768 CBankAccessor_PLR::getDEBUG_INFO().setPing(c->_PropertyDatabase, time );
2769 }
2770 }
2771
2772
2773 extern void cbClientAdmin( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId);
2774 extern void cbClientAdminOffline( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId);
2775 extern void cbClientRemoteAdmin( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId);
2776
2777
2778 /************************************************************************/
2779 /* GUILD CALLBACKS */
2780 /* implemented in guild_client_callbacks.cpp */
2781 /************************************************************************/
2782
2783 // client wants to create a guild
2784 void cbClientGuildCreate( NLNET::CMessage& msgin, const std::string & serviceName, NLNET::TServiceId serviceId );
2785 /// set the leader
2786 void cbClientGuildSetLeader( NLNET::CMessage& msgin, const std::string & serviceName, NLNET::TServiceId serviceId );
2787 /// set playergrade
2788 void cbClientGuildSetGrade( NLNET::CMessage& msgin, const std::string & serviceName, NLNET::TServiceId serviceId );
2789 //client asked another to join his guild
2790 void cbClientGuildJoinInvitation( NLNET::CMessage& msgin, const std::string & serviceName, NLNET::TServiceId serviceId );
2791 //client accept invitation
2792 void cbClientGuildAcceptJoinInvitation( NLNET::CMessage& msgin, const std::string & serviceName, NLNET::TServiceId serviceId );
2793 //client refused invitation
2794 void cbClientGuildRefuseJoinInvitation( NLNET::CMessage& msgin, const std::string & serviceName, NLNET::TServiceId serviceId );
2795 /// kick a member
2796 void cbClientGuildKickMember( NLNET::CMessage& msgin, const std::string & serviceName, NLNET::TServiceId serviceId );
2797 /// quit the guild
2798 void cbClientGuildQuit( NLNET::CMessage& msgin, const std::string & serviceName, NLNET::TServiceId serviceId );
2799 /// item : bag to guild
2800 //void cbClientBagToGuild( NLNET::CMessage& msgin, const std::string & serviceName, uint16 serviceId );
2801 /// item : guild to bag
2802 //void cbClientGuildToBag( NLNET::CMessage& msgin, const std::string & serviceName, uint16 serviceId );
2803 /// money : bag to guild
2804 void cbClientGuildPutMoney( NLNET::CMessage& msgin, const std::string & serviceName, NLNET::TServiceId serviceId );
2805 /// money : guild to bag
2806 void cbClientGuildTakeMoney( NLNET::CMessage& msgin, const std::string & serviceName, NLNET::TServiceId serviceId );
2807
2808 /// outpost callbacks (implemented in guild_client_callbacks.cpp)
2809 void cbClientOutpostSetSquad(NLNET::CMessage & msgin, const std::string & serviceName, NLNET::TServiceId serviceId);
2810 void cbClientOutpostSetSquadSpawnZone(NLNET::CMessage & msgin, const std::string & serviceName, NLNET::TServiceId serviceId);
2811 void cbClientOutpostInsertSquad(NLNET::CMessage & msgin, const std::string & serviceName, NLNET::TServiceId serviceId);
2812 void cbClientOutpostRemoveSquad(NLNET::CMessage & msgin, const std::string & serviceName, NLNET::TServiceId serviceId);
2813 void cbClientOutpostSetExpenseLimit(NLNET::CMessage & msgin, const std::string & serviceName, NLNET::TServiceId serviceId);
2814 //void cbClientOutpostBuyBuilding(NLNET::CMessage & msgin, const std::string & serviceName, uint16 serviceId);
2815 //void cbClientOutpostDestroyBuilding(NLNET::CMessage & msgin, const std::string & serviceName, uint16 serviceId);
2816 void cbClientOutpostSideChosen( NLNET::CMessage& msgin, const std::string & serviceName, NLNET::TServiceId serviceId );
2817 void cbClientOutpostSelect(NLNET::CMessage & msgin, const std::string & serviceName, NLNET::TServiceId serviceId);
2818 void cbClientOutpostUnselect(NLNET::CMessage & msgin, const std::string & serviceName, NLNET::TServiceId serviceId);
2819 void cbClientOutpostWarStart(NLNET::CMessage & msgin, const std::string & serviceName, NLNET::TServiceId serviceId);
2820 void cbClientOutpostWarValidate(NLNET::CMessage & msgin, const std::string & serviceName, NLNET::TServiceId serviceId);
2821 void cbClientOutpostGiveup(NLNET::CMessage & msgin, const std::string & serviceName, NLNET::TServiceId serviceId);
2822 void cbClientOutpostBanishPlayer(NLNET::CMessage & msgin, const std::string & serviceName, NLNET::TServiceId serviceId);
2823 void cbClientOutpostBanishGuild(NLNET::CMessage & msgin, const std::string & serviceName, NLNET::TServiceId serviceId);
2824 void cbClientOutpostSetDefensePeriod(NLNET::CMessage & msgin, const std::string & serviceName, NLNET::TServiceId serviceId);
2825
2826 // client asked for a lift destination
2827 void cbClientGuildLiftDestAsked( NLNET::CMessage& msgin, const std::string & serviceName, NLNET::TServiceId serviceId )
2828 {
2829 CEntityId eId;
2830 msgin.serial( eId );
2831 uint16 session;
2832 msgin.serial(session);
2833 CBuildingManager::getInstance()->fillTriggerPage(eId, session,true );
2834 }
2835
2836 // client asked for a lift next page
2837 void cbClientGuildLiftNextPage( NLNET::CMessage& msgin, const std::string & serviceName, NLNET::TServiceId serviceId )
2838 {
2839 CEntityId eId;
2840 msgin.serial( eId );
2841 uint16 session;
2842 msgin.serial(session);
2843 CBuildingManager::getInstance()->fillTriggerPage(eId, session, false );
2844 }
2845
2846 // client asked for a lift teleport
2847 void cbClientGuildLiftTeleport( NLNET::CMessage& msgin, const std::string & serviceName, NLNET::TServiceId serviceId )
2848 {
2849 CEntityId eId;
2850 msgin.serial( eId );
2851 uint16 index;
2852 msgin.serial(index);
2853 CCharacter * user = PlayerManager.getChar( eId );
2854 if ( user )
2855 CBuildingManager::getInstance()->triggerTeleport(user,index);
2856 }
2857
2858 void cbClientSetCharacterTitle( NLNET::CMessage& msgin, const std::string & serviceName, NLNET::TServiceId serviceId )
2859 {
2860 CEntityId eId;
2861 uint8 title;
2862 msgin.serial( eId );
2863 msgin.serial( title );
2864
2865 CCharacter * c = PlayerManager.getChar(eId);
2866 if ( !c )
2867 {
2868 nlwarning("<cbClientSetCharacterTitle> Invalid user %s",eId.toString().c_str());
2869 return;
2870 }
2871 c->setAfkState(false);
2872
2873 const uint32 userId = PlayerManager.getPlayerId(eId);
2874 CPlayer * p = PlayerManager.getPlayer(userId);
2875 if (p == NULL)
2876 {
2877 nlwarning("<cbClientSetCharacterTitle> Invalid player %u", userId);
2878 return;
2879 }
2880
2881 if ( title == uint8(CHARACTER_TITLE::FBT) )
2882 {
2883 if ( !p->isBetaTester() )
2884 return;
2885 }
2886 else if ( title == uint8(CHARACTER_TITLE::WIND) )
2887 {
2888 if ( !p->isWindermeerCommunity() )
2889 return;
2890 }
2891 else if ( title >= uint8(CHARACTER_TITLE::BeginGmTitle) && title <= uint8(CHARACTER_TITLE::EndGmTitle) )
2892 {
2893 return;
2894 }
2895
2896 // kxu: TODO: check validity of title chosen by player
2897 c->setNewTitle(CHARACTER_TITLE::toString((CHARACTER_TITLE::ECharacterTitle)title));
2898 c->registerName();
2899 }
2900
2901
2902 ///////////////////////////////////////////////////////////////////////////////////////////////////
2903 ///////////////////////////////////////////////////////////////////////////////////////////////////
2904 // CLIENT:ITEM_INFO
2905 ///////////////////////////////////////////////////////////////////////////////////////////////////
2906 ///////////////////////////////////////////////////////////////////////////////////////////////////
2907 void cbClientItemInfos( NLNET::CMessage& msgin, const std::string & serviceName, NLNET::TServiceId serviceId )
2908 {
2909 CEntityId userId;
2910 uint16 slotId;
2911 msgin.serial(userId,slotId);
2912 CCharacter * user = PlayerManager.getChar(userId);
2913 if ( user && user->getEnterFlag() && TheDataset.isAccessible( user->getEntityRowId() ) )
2914 user->sendItemInfos( slotId );
2915 }
2916
2917 ///////////////////////////////////////////////////////////////////////////////////////////////////
2918 ///////////////////////////////////////////////////////////////////////////////////////////////////
2919 // CLIENT:MISSION_PREREQ
2920 ///////////////////////////////////////////////////////////////////////////////////////////////////
2921 ///////////////////////////////////////////////////////////////////////////////////////////////////
2922 void cbClientMissionPrereq( NLNET::CMessage& msgin, const std::string & serviceName, NLNET::TServiceId serviceId )
2923 {
2924 CEntityId userId;
2925 uint8 slotId;
2926 msgin.serial(userId, slotId);
2927 CCharacter * user = PlayerManager.getChar(userId);
2928 if ( user && user->getEnterFlag() && TheDataset.isAccessible( user->getEntityRowId() ) )
2929 user->sendMissionPrerequisitInfos( slotId );
2930 }
2931
2932
2933 ///////////////////////////////////////////////////////////////////////////////////////////////////
2934 ///////////////////////////////////////////////////////////////////////////////////////////////////
2935 // CLIENT:DEATH:ASK_RESPAWN
2936 ///////////////////////////////////////////////////////////////////////////////////////////////////
2937 ///////////////////////////////////////////////////////////////////////////////////////////////////
2938 void cbClientAskRespawn( NLNET::CMessage& msgin, const std::string & serviceName, NLNET::TServiceId serviceId )
2939 {
2940 CEntityId userId;
2941 uint16 index;
2942 msgin.serial(userId,index);
2943
2944 CCharacter * user = PlayerManager.getChar(userId);
2945 if ( user && user->getEnterFlag() )
2946 {
2947 user->respawn( index );
2948 user->setAfkState(false);
2949 }
2950 }
2951
2952 ///////////////////////////////////////////////////////////////////////////////////////////////////
2953 ///////////////////////////////////////////////////////////////////////////////////////////////////
2954 // CLIENT:TARGET
2955 ///////////////////////////////////////////////////////////////////////////////////////////////////
2956 ///////////////////////////////////////////////////////////////////////////////////////////////////
2957 void cbClientCompassEnableDynamic( NLNET::CMessage& msgin, const std::string & serviceName, NLNET::TServiceId serviceId )
2958 {
2959 CEntityId userId;
2960 //TDataSetIndex compressedIndex;
2961 uint32 compressedIndex;
2962
2963 msgin.serial(userId);
2964 msgin.serial(compressedIndex);
2965
2966 TDataSetRow index = TheDataset.getCurrentDataSetRow( compressedIndex );
2967 if ( ! TheDataset.isAccessible(index) )
2968 {
2969 nlwarning("<cbClientCompassEnableDynamic>: compressed index results in an invalid datasetrow");
2970 return;
2971 }
2972
2973 CCharacter * user = PlayerManager.getChar(userId);
2974 if ( user && user->getEnterFlag() )
2975 {
2976 user->setCompassTarget( index );
2977 }
2978 }
2979
2980 void cbClientCompassDisableDynamic( NLNET::CMessage& msgin, const std::string & serviceName, NLNET::TServiceId serviceId )
2981 {
2982 static const TDataSetRow invalidRow;
2983
2984 CEntityId userId;
2985 msgin.serial(userId);
2986
2987 CCharacter * user = PlayerManager.getChar(userId);
2988 if ( user && user->getEnterFlag() )
2989 {
2990 user->setCompassTarget( invalidRow );
2991 }
2992 }
2993
2994
2995 ///////////////////////////////////////////////////////////////////////////////////////////////////
2996 ///////////////////////////////////////////////////////////////////////////////////////////////////
2997 // CLIENT: PVP choose clan
2998 ///////////////////////////////////////////////////////////////////////////////////////////////////
2999 ///////////////////////////////////////////////////////////////////////////////////////////////////
3000 /*
3001 void cbClientPvpChooseClan( NLNET::CMessage& msgin, const std::string & serviceName, uint16 serviceId )
3002 {
3003 CEntityId userId;
3004 uint8 clan;
3005
3006 msgin.serial(userId,clan);
3007
3008 CCharacter * user = PlayerManager.getChar(userId);
3009 if ( user && user->getEnterFlag() )
3010 {
3011 if ( user->getPVPInterface().isValid() )
3012 user->getPVPInterface().setUserClan( clan );
3013 }
3014 }
3015 */
3016
3017 ///////////////////////////////////////////////////////////////////////////////////////////////////
3018 ///////////////////////////////////////////////////////////////////////////////////////////////////
3019 // CLIENT:MISSION
3020 ///////////////////////////////////////////////////////////////////////////////////////////////////
3021 ///////////////////////////////////////////////////////////////////////////////////////////////////
3022 void cbClientMissionEnterCritical( NLNET::CMessage& msgin, const std::string & serviceName, NLNET::TServiceId serviceId )
3023 {
3024 CEntityId userId;
3025 msgin.serial(userId);
3026
3027 bool accept;
3028 msgin.serial(accept);
3029
3030 CCharacter *player = PlayerManager.getChar(userId);
3031 if (player)
3032 CMissionQueueManager::getInstance()->playerEntersCriticalArea(userId, player->getEnterCriticalZoneProposalQueueId(), accept);
3033
3034
3035 }
3036
3037 void cbClientMissionWake( NLNET::CMessage& msgin, const std::string & serviceName, NLNET::TServiceId serviceId );
3038
3039 void cbClientMissionGroupWake( NLNET::CMessage& msgin, const std::string & serviceName, NLNET::TServiceId serviceId );
3040
3041 ///////////////////////////////////////////////////////////////////////////////////////////////////
3042 ///////////////////////////////////////////////////////////////////////////////////////////////////
3043 // CLIENT:DUEL
3044 ///////////////////////////////////////////////////////////////////////////////////////////////////
3045 ///////////////////////////////////////////////////////////////////////////////////////////////////
3046
3047 void cbClientDuelAsked( NLNET::CMessage& msgin, const std::string & serviceName, NLNET::TServiceId serviceId )
3048 {
3049 CEntityId userId;
3050 msgin.serial(userId);
3051 CPVPManager2::getInstance()->askForDuel( userId );
3052 }
3053
3054 void cbClientDuelAccept( NLNET::CMessage& msgin, const std::string & serviceName, NLNET::TServiceId serviceId )
3055 {
3056 CEntityId userId;
3057 msgin.serial(userId);
3058 CPVPManager2::getInstance()->acceptDuel( userId );
3059 }
3060
3061 void cbClientDuelRefuse( NLNET::CMessage& msgin, const std::string & serviceName, NLNET::TServiceId serviceId )
3062 {
3063 CEntityId userId;
3064 msgin.serial(userId);
3065 CPVPManager2::getInstance()->refuseDuel( userId );
3066 }
3067
3068 void cbClientDuelAbandon( NLNET::CMessage& msgin, const std::string & serviceName, NLNET::TServiceId serviceId )
3069 {
3070 CEntityId userId;
3071 msgin.serial(userId);
3072 CPVPManager2::getInstance()->abandonDuel( userId );
3073 }
3074
3075 ///////////////////////////////////////////////////////////////////////////////////////////////////
3076 ///////////////////////////////////////////////////////////////////////////////////////////////////
3077 // CLIENT:PVP CHALLENGE
3078 ///////////////////////////////////////////////////////////////////////////////////////////////////
3079 ///////////////////////////////////////////////////////////////////////////////////////////////////
3080
3081 void cbClientPVPChallengeAsked( NLNET::CMessage& msgin, const std::string & serviceName, NLNET::TServiceId serviceId )
3082 {
3083 CEntityId userId;
3084 msgin.serial(userId);
3085 CPVPManager::getInstance()->askForPVPChallenge( userId );
3086 }
3087
3088 void cbClientPVPChallengeAccept( NLNET::CMessage& msgin, const std::string & serviceName, NLNET::TServiceId serviceId )
3089 {
3090 CEntityId userId;
3091 msgin.serial(userId);
3092 CPVPManager::getInstance()->acceptPVPChallenge( userId );
3093 }
3094
3095 void cbClientPVPChallengeRefuse( NLNET::CMessage& msgin, const std::string & serviceName, NLNET::TServiceId serviceId )
3096 {
3097 CEntityId userId;
3098 msgin.serial(userId);
3099 CPVPManager::getInstance()->refusePVPChallenge( userId );
3100 }
3101
3102 void cbClientPVPChallengeAbandon( NLNET::CMessage& msgin, const std::string & serviceName, NLNET::TServiceId serviceId )
3103 {
3104 CEntityId userId;
3105 msgin.serial(userId);
3106 CCharacter * user = PlayerManager.getChar( userId );
3107 if ( !user )
3108 {
3109 nlwarning("<PVP>%s is invalid",userId.toString().c_str());
3110 return;
3111 }
3112 CTeam * team = TeamManager.getTeam( user->getTeamId() );
3113 if ( team && team->getLeader() != userId )
3114 {
3115 CCharacter::sendDynamicSystemMessage( userId,"CHALLENGE_ABANDON_NOT_LEADER" );
3116 return;
3117 }
3118
3119 if ( user->getPVPInterface().isValid() )
3120 user->getPVPInterface().leavePVP( IPVP::AbandonChallenge );
3121 }
3122
3123 ///////////////////////////////////////////////////////////////////////////////////////////////////
3124 ///////////////////////////////////////////////////////////////////////////////////////////////////
3125 // CLIENT:PVP FACTION / GUILDE / ALLEGIANCE
3126 ///////////////////////////////////////////////////////////////////////////////////////////////////
3127 ///////////////////////////////////////////////////////////////////////////////////////////////////
3128 void cbClientPvPSetTag( NLNET::CMessage& msgin, const std::string & serviceName, NLNET::TServiceId serviceId )
3129 {
3130 CEntityId charId;
3131 msgin.serial(charId);
3132
3133 bool tagPVP = false;
3134 uint8 flag;
3135 msgin.serial(flag);
3136 if(flag) tagPVP = true;
3137
3138 CCharacter * c = PlayerManager.getOnlineChar(charId);
3139 if( c != 0)
3140 {
3141 c->setPVPFlag( tagPVP );
3142 }
3143 else
3144 {
3145 nlwarning("<cbClientPvPSetTag> %s is invalid", charId.toString().c_str());
3146 }
3147 }
3148
3149 void cbClientPvPSetNeutralAllegiance( NLNET::CMessage& msgin, const std::string & serviceName, NLNET::TServiceId serviceId )
3150 {
3151 CEntityId charId;
3152 msgin.serial(charId);
3153
3154 uint8 allegianceU8;
3155 msgin.serial(allegianceU8);
3156
3157 PVP_CLAN::TPVPClan allegiance = (PVP_CLAN::TPVPClan)allegianceU8;
3158
3159 CCharacter * c = PlayerManager.getOnlineChar(charId);
3160 if( c != 0)
3161 {
3162 c->setAllegianceFromIndeterminedStatus(allegiance);
3163 }
3164 else
3165 {
3166 nlwarning("<cbClientPvPSetNeutralAllegiance> %s is invalid", charId.toString().c_str());
3167 }
3168 }
3169
3170 void cbClientPvPSetNeutralAllegianceGuild( NLNET::CMessage& msgin, const std::string & serviceName, NLNET::TServiceId serviceId )
3171 {
3172 CEntityId charId;
3173 msgin.serial(charId);
3174
3175 uint8 allegianceU8;
3176 msgin.serial(allegianceU8);
3177
3178 PVP_CLAN::TPVPClan allegiance = (PVP_CLAN::TPVPClan)allegianceU8;
3179
3180 CCharacter * c = PlayerManager.getOnlineChar(charId);
3181 if( c != 0)
3182 {
3183 CGuild * guild = CGuildManager::getInstance()->getGuildFromId(c->getGuildId());
3184 if( guild )
3185 {
3186 CGuildMember * gm = guild->getMemberFromEId(charId);
3187 if( gm->getGrade() == EGSPD::CGuildGrade::Leader )
3188 {
3189 guild->setAllegianceFromIndeterminedStatus(allegiance);
3190 }
3191 else
3192 {
3193 CCharacter::sendDynamicSystemMessage( charId,"GUILD_INSUFFICIENT_GRADE" );
3194 }
3195 }
3196 else
3197 {
3198 nlwarning("<cbClientPvPSetNeutralAllegianceGuild> Player Character % have no guild", charId.toString().c_str());
3199 }
3200 }
3201 else
3202 {
3203 nlwarning("<cbClientPvPSetNeutralAllegiance> %s is invalid", charId.toString().c_str());
3204 }
3205 }
3206
3207
3208 ///////////////////////////////////////////////////////////////////////////////////////////////////
3209 void cbClientQuitGameRequest( NLNET::CMessage& msgin, const std::string & serviceName, NLNET::TServiceId serviceId )
3210 {
3211 CEntityId charId;
3212 bool bypassDisconnectionTimer = false;
3213
3214 try
3215 {
3216 msgin.serial(charId);
3217 CPlayer *player = PlayerManager.getPlayer(uint32(charId.getShortId()) >> 4);
3218
3219 if (IsRingShard)
3220 bypassDisconnectionTimer = true;
3221 /*else
3222 {
3223 msgin.serial(bypassDisconnectionTimer);
3224 if (bypassDisconnectionTimer)
3225 {
3226 // For fast-disconnection on a mainland shard, one needs to produce credentials!
3227 H_AUTO(BypassDiscoTimer);
3228 CSecurityCheckForFastDisconnection securityCheck;
3229 securityCheck.receiveSecurityCode(msgin);
3230 if (player)
3231 securityCheck.setCookie(player->getLoginCookie()); // if not set (null player), the check won't pass
3232
3233 securityCheck.check("QtXp1o1t?");
3234 }
3235 }*/
3236
3237 if (IsDevShard || (player != NULL && player->havePriv( ":DEV:SGM:GM:" )))
3238 bypassDisconnectionTimer = true;
3239 }
3240 catch (const Exception &e) // will catch any serialization/security exception
3241 {
3242 GIVEUP_IF(charId.isUnknownId(), "cbClientQuitGameRequest: unknown char", return);
3243 nldebug("BypassDisconnectionTimer denied for %s: %s", charId.toString().c_str(), e.what());
3244 bypassDisconnectionTimer = false;
3245 }
3246
3247 TDataSetRow rowId = TheDataset.getDataSetRow(charId);
3248 const uint32 playerId = PlayerManager.getPlayerId(charId);
3249
3250 if (!rowId.isValid())
3251 {
3252 PlayerManager.disconnectPlayer(playerId);
3253 }
3254 else
3255 {
3256 // stop all phrases in execution for character
3257 CPhraseManager::getInstance().cancelAllPhrases(rowId);
3258
3259 if (bypassDisconnectionTimer)
3260 {
3261 // send the disconnection acknowledgement at once
3262 PlayerManager.disconnectPlayer(playerId);
3263 }
3264 else
3265 {
3266 // add disconnection phrase in manager
3267 static CSheetId decoBrick("bapa02.sbrick");
3268 vector<CSheetId> bricks;
3269 bricks.push_back(decoBrick);
3270 if ( CPhraseManager::getInstance().executePhrase(rowId, rowId, bricks) == NULL )
3271 {
3272 // error while building the phrase, can happen when character isn't really online (connection failed)
3273 PlayerManager.userDisconnected( playerId ); // still waits for the timer before really disconnecting
3274 }
3275 }
3276 }
3277 }
3278
3279 ///////////////////////////////////////////////////////////////////////////////////////////////////
3280 void cbClientReturnToMainland( NLNET::CMessage& msgin, const std::string & serviceName, NLNET::TServiceId serviceId )
3281 {
3282 uint32 userId;
3283 msgin.serial(userId);
3284 uint8 charIndex;
3285 msgin.serial(charIndex);
3286 TSessionId rejectedSessionId;
3287 msgin.serial(rejectedSessionId);
3288
3289 CCharacter *character = PlayerManager.getChar( userId, (uint32)charIndex );
3290 if (character)
3291 character->returnToPreviousSession( userId, (sint32)charIndex, rejectedSessionId );
3292 else
3293 nlwarning( "Char not found for %u/%u", userId, (uint)charIndex );
3294 }
3295
3296
3297 ///////////////////////////////////////////////////////////////////////////////////////////////////
3298 ///////////////////////////////////////////////////////////////////////////////////////////////////
3299 // CLIENT:EVENT
3300 ///////////////////////////////////////////////////////////////////////////////////////////////////
3301 ///////////////////////////////////////////////////////////////////////////////////////////////////
3302
3303 /// returns 0 on success, anything else is error:
3304 /// -1: Invalid inventory
3305 /// -2: Invalid slot
3306 /// -3: Empty slot
3307 sint32 clientEventSetItemCustomText(CCharacter* character, INVENTORIES::TInventory inventory, uint32 slot, ucstring const& text)
3308 {
3309 if (inventory==INVENTORIES::UNDEFINED)
3310 {
3311 return -1;
3312 }
3313 CInventoryPtr invent = character->getInventory(inventory);
3314 if (slot >= invent->getSlotCount())
3315 {
3316 return -2;
3317 }
3318 if (invent->getItem(slot) == NULL)
3319 {
3320 return -3;
3321 }
3322
3323 CGameItemPtr item = invent->getItem(slot);
3324 item->setCustomText(text);
3325 // Following line was commented out by trap, reason unknown
3326 character->incSlotVersion(inventory, slot);
3327
3328 return 0;
3329 }
3330
3331 void cbClientEventSetItemCustomText( NLNET::CMessage& msgin, const std::string & serviceName, NLNET::TServiceId serviceId )
3332 {
3333 CEntityId eid;
3334 INVENTORIES::TInventory inventory;
3335 uint32 uiInventory;
3336 uint32 slot;
3337 ucstring text;
3338 msgin.serial(eid);
3339 msgin.serial(uiInventory);
3340 inventory = (INVENTORIES::TInventory)uiInventory;
3341 msgin.serial(slot);
3342 msgin.serial(text);
3343
3344 CCharacter* character = PlayerManager.getChar(eid);
3345 if(!character) return;
3346
3347 if (!character->havePriv(":DEV:SGM:GM:EM:"))
3348 {
3349 // it should be the crafter of the item, check
3350 if (inventory==INVENTORIES::UNDEFINED) return;
3351 CInventoryPtr invent = character->getInventory(inventory);
3352 if (slot >= invent->getSlotCount()) return;
3353 if (invent->getItem(slot) == NULL) return;
3354 CGameItemPtr item = invent->getItem(slot);
3355
3356 const NLMISC::CEntityId &crafterEId = item->getCreator();
3357 const NLMISC::CEntityId &userEId = character->getId();
3358
3359 if(crafterEId != userEId)
3360 {
3361 string name = CEntityIdTranslator::getInstance()->getByEntity(userEId).toString();
3362 nlwarning("HACK: %s %s tries to set custom text on an item he didn't crafted", userEId.toString().c_str(), name.c_str());
3363 return;
3364 }
3365
3366 // text must not be too big
3367 if(text.size() > 256)
3368 {
3369 string name = CEntityIdTranslator::getInstance()->getByEntity(userEId).toString();
3370 nlwarning("HACK: %s %s tries to set custom text of a size > 256 (%d)", userEId.toString().c_str(), name.c_str(), text.size());
3371 return;
3372 }
3373
3374 // the item must have the good family
3375 const CStaticItem * form = item->getStaticForm();
3376 if (!form) return;
3377 ITEMFAMILY::EItemFamily family = form->Family;
3378 if (!ITEMFAMILY::isTextCustomizable(family))
3379 {
3380 string name = CEntityIdTranslator::getInstance()->getByEntity(userEId).toString();
3381 nlwarning("HACK: %s %s tries to set custom text on a item that is not text customizable (%s)", userEId.toString().c_str(), name.c_str(), ITEMFAMILY::toString(family).c_str());
3382 return;
3383 }
3384
3385 // prevent use of @WEB at begin
3386 if (text.size() > 3 && text[0]=='@' && text[1]=='W' && text[2]=='E' && text[3]=='B')
3387 text = text.substr(4, text.size() - 4);
3388
3389 // prevent use of @LUA at begin
3390 if (text.size() > 3 && text[0]=='@' && text[1]=='L' && text[2]=='U' && text[3]=='A')
3391 text = text.substr(4, text.size() - 4);
3392
3393 // force that the begin of the text for non admin is %mfc
3394 if(!text.empty() && text.substr(0, 4) != ucstring("%mfc"))
3395 {
3396 text = ucstring("%mfc") + text;
3397 }
3398 }
3399
3400 clientEventSetItemCustomText(character, inventory, slot, text);
3401 }
3402
3403
3404
3405 ///////////////////////////////////////////////////////////////////////////////////////////////////
3406 ///////////////////////////////////////////////////////////////////////////////////////////////////
3407 // CLIENT:TOTEM
3408 ///////////////////////////////////////////////////////////////////////////////////////////////////
3409 ///////////////////////////////////////////////////////////////////////////////////////////////////
3410 void cbTotemBuild( NLNET::CMessage& msgin, const std::string & serviceName, NLNET::TServiceId serviceId )
3411 {
3412 if( BuildSpireActive == false )
3413 return;
3414 CEntityId Id;
3415 msgin.serial( Id );
3416
3417 CCharacter *ch = PlayerManager.getChar( Id );
3418
3419 if ( !ch )
3420 {
3421 nlwarning("Totem build aborted: no character");
3422 return;
3423 }
3424 if ( !ch->getPVPFlag() )
3425 {
3426 nlwarning("Totem build aborted: character has no pvp flag");
3427 return;
3428 }
3429
3430 CGuild::TAllegiances allegiance = ch->getAllegiance();
3431 if ( allegiance.first == PVP_CLAN::Neutral )
3432 {
3433 nlwarning("Totem build aborted: character has no cult allegiance");
3434 return;
3435 }
3436 NLMISC::CVector pos( (float)ch->getX() / 1000.0f, (float)ch->getY() / 1000.0f, 0 );
3437 CRegion* region = CZoneManager::getInstance().getRegion( pos );
3438
3439 if ( !region )
3440 {
3441 nlwarning("Totem build aborted: no region where character is");
3442 return;
3443 }
3444 if ( !CPVPFactionRewardManager::getInstance().canBuildTotem( ch ) )
3445 {
3446 nlwarning("Totem build aborted: can't build totem");
3447 return;
3448 }
3449 CPVPFactionRewardManager::getInstance().startTotemBuilding( region->getId(), ch );
3450 nlinfo( "<cbTotemBuild> : %s is building a totem in region %s", Id.toString().c_str(), region->getName().c_str() );
3451 }
3452
3453
3454
3455
3456 ///////////////////////////////////////////////////////////////////////////////////////////////////
3457 ///////////////////////////////////////////////////////////////////////////////////////////////////
3458 // CLIENT:DM_GIFT
3459 ///////////////////////////////////////////////////////////////////////////////////////////////////
3460 ///////////////////////////////////////////////////////////////////////////////////////////////////
3461 void cbDMGiftBegin( NLNET::CMessage& msgin, const std::string & serviceName, NLNET::TServiceId serviceId )
3462 {
3463 CEntityId eid;
3464 msgin.serial( eid );
3465
3466 if(!IsRingShard)
3467 {
3468 string name = CEntityIdTranslator::getInstance()->getByEntity(eid).toString();
3469 nlwarning("HACK: %s %s tries to start a GM gift on a non ring shard", eid.toString().c_str(), name.c_str());
3470 return;
3471 }
3472
3473 CR2MissionItem::getInstance().dmGiftBegin( eid );
3474 }
3475
3476 void cbDMGiftValidate( NLNET::CMessage& msgin, const std::string & serviceName, NLNET::TServiceId serviceId )
3477 {
3478 CEntityId eid;
3479 msgin.serial( eid );
3480
3481 if(!IsRingShard)
3482 {
3483 string name = CEntityIdTranslator::getInstance()->getByEntity(eid).toString();
3484 nlwarning("HACK: %s %s tries to validate a GM gift on a non ring shard", eid.toString().c_str(), name.c_str());
3485 return;
3486 }
3487
3488 std::vector< R2::TItemAndQuantity > items;
3489 CSheetId sheet;
3490 uint8 quantity;
3491
3492 while( msgin.getPos() < (sint32) msgin.length() )
3493 {
3494 msgin.serial( sheet );
3495 msgin.serial( quantity );
3496 if( sheet != CSheetId::Unknown && quantity != 0)
3497 {
3498 R2::TItemAndQuantity item;
3499 item.SheetId = sheet;
3500 item.Quantity = quantity;
3501
3502 const CStaticItem * form = CSheets::getForm(sheet);
3503 if (form == NULL)
3504 {
3505 string name = CEntityIdTranslator::getInstance()->getByEntity(eid).toString();
3506 nlwarning("HACK: %s %s tries to create an item that has a null form", eid.toString().c_str(), name.c_str());
3507 return;
3508 }
3509 if(form->Family != ITEMFAMILY::SCROLL_R2)
3510 {
3511 string name = CEntityIdTranslator::getInstance()->getByEntity(eid).toString();
3512 nlwarning("HACK: %s %s tries to create an item that is not a plot item", eid.toString().c_str(), name.c_str());
3513 return;
3514 }
3515 items.push_back( item );
3516 }
3517 }
3518 CR2MissionItem::getInstance().dmGiftValidate( eid, items );
3519 }
3520
3521
3522 ///////////////////////////////////////////////////////////////////////////////////////////////////
3523 ///////////////////////////////////////////////////////////////////////////////////////////////////
3524 // CLIENT:RING_MISSION
3525 ///////////////////////////////////////////////////////////////////////////////////////////////////
3526 ///////////////////////////////////////////////////////////////////////////////////////////////////
3527 void cbRingMissionSelectAction( NLNET::CMessage& msgin, const std::string & serviceName, NLNET::TServiceId serviceId )
3528 {
3529 CEntityId eid;
3530 uint32 actionId;
3531
3532 msgin.serial( eid );
3533 msgin.serial( actionId );
3534
3535 CCharacter *ch = PlayerManager.getChar( eid );
3536 if( ch )
3537 {
3538 CR2GiveItem::getInstance().giveItemGranted( ch->getTargetDataSetRow(), actionId );
3539 }
3540 }
3541
3542
3543 ///////////////////////////////////////////////////////////////////////////////////////////////////
3544 ///////////////////////////////////////////////////////////////////////////////////////////////////
3545 // CLIENT:NPC_ICON
3546 ///////////////////////////////////////////////////////////////////////////////////////////////////
3547 ///////////////////////////////////////////////////////////////////////////////////////////////////
3548 void cbGetNpcIconDesc( NLNET::CMessage& msgin, const std::string & serviceName, NLNET::TServiceId serviceId )
3549 {
3550 CEntityId eid;
3551 vector<uint32> npcKeys;
3552
3553 msgin.serial( eid );
3554 msgin.serialCont( npcKeys );
3555
3556 CCharacter *ch = PlayerManager.getChar( eid );
3557 if( ch )
3558 {
3559 ch->sendNpcMissionGiverIconDesc( npcKeys );
3560 }
3561 }
3562
3563
3564 //----------------------------
3565 // CbClientArray
3566 //----------------------------
3567 TUnifiedCallbackItem CbClientArray[]=
3568 {
3569 { "CLIENT:CONNECTION:CLIENT_QUIT_REQUEST", cbClientQuitGameRequest },
3570 { "RET_MAINLAND", cbClientReturnToMainland },
3571
3572 { "CLIENT:ITEM:DROP", cbClientItemDrop },
3573 { "CLIENT:ITEM:PICK_UP_CLOSE", cbClientItemPickUpClose },
3574 { "CLIENT:ITEM:SWAP", cbClientItemSwap },
3575 { "CLIENT:ITEM:HARVEST", cbClientItemHarvest },
3576 { "CLIENT:ITEM:HARVEST_CLOSE", cbClientItemHarvestClose },
3577 { "CLIENT:ITEM:DESTROY", cbClientItemDestroy },
3578 { "CLIENT:ITEM:EQUIP", cbClientItemEquip },
3579 { "CLIENT:ITEM:UNEQUIP", cbClientItemUnequip },
3580 { "CLIENT:ITEM:TEMP_TO_BAG", cbClientItemTempToBag },
3581 { "CLIENT:ITEM:ALL_TEMP", cbClientItemAllTemp },
3582 { "CLIENT:ITEM:NO_TEMP", cbClientItemNoTemp },
3583 { "CLIENT:ITEM:ENCHANT", cbClientItemEnchant },
3584 { "CLIENT:ITEM:USE_ITEM", cbClientItemUseItem },
3585 { "CLIENT:ITEM:STOP_USE_XP_CAT", cbClientItemStopUseXpCat },
3586
3587
3588 { "CLIENT:ITEM_INFO:GET", cbClientItemInfos },
3589 { "CLIENT:MISSION_PREREQ:GET", cbClientMissionPrereq },
3590
3591 { "CLIENT:HARVEST:DEPOSIT", cbClientHarvestDeposit },
3592
3593 { "CLIENT:PHRASE:MEMORIZE", cbClientPhraseMemorize },
3594 { "CLIENT:PHRASE:FORGET", cbClientPhraseForget },
3595 { "CLIENT:PHRASE:LEARN", cbClientPhraseLearn },
3596 { "CLIENT:PHRASE:DELETE", cbClientPhraseDelete },
3597 { "CLIENT:PHRASE:EXECUTE", cbClientPhraseExecute },
3598 { "CLIENT:PHRASE:EXECUTE_CYCLIC", cbClientPhraseExecuteCyclic },
3599 { "CLIENT:PHRASE:EXECUTE_FABER", cbClientPhraseExecuteFaber },
3600 { "CLIENT:PHRASE:BUY", cbClientPhraseBuyByIndex },
3601 { "CLIENT:PHRASE:BUY_SHEET", cbClientPhraseBuyBySheet },
3602
3603 { "CLIENT:PHRASE:CANCEL_TOP", cbClientPhraseCancelTop },
3604 { "CLIENT:PHRASE:CANCEL_ALL", cbClientPhraseCancelAll },
3605 { "CLIENT:PHRASE:CRISTALIZE", cbClientPhraseCristalize },
3606
3607
3608 { "CLIENT:COMBAT:ENGAGE", cbClientCombatEngage },
3609 { "CLIENT:COMBAT:DISENGAGE", cbClientCombatDisengage },
3610 { "CLIENT:COMBAT:DEFAULT_ATTACK", cbClientCombatDefaultAttack },
3611 { "CLIENT:COMBAT:VALIDATE_MELEE", cbClientValidateMeleeCombat },
3612 { "CLIENT:COMBAT:PARRY", cbClientCombatParry },
3613 { "CLIENT:COMBAT:DODGE", cbClientCombatDodge },
3614 { "CLIENT:COMBAT:PROTECTED_SLOT", cbClientCombatProtectedSlot },
3615
3616 { "CLIENT:TEAM:LEAVE", cbClientTeamLeave },
3617 { "CLIENT:TEAM:JOIN", cbClientTeamJoin },
3618 { "CLIENT:TEAM:KICK", cbClientTeamKick },
3619 { "CLIENT:TEAM:JOIN_PROPOSAL", cbClientTeamJoinProposal },
3620 { "CLIENT:TEAM:JOIN_PROPOSAL_DECLINE", cbClientTeamJoinProposalDecline },
3621 { "CLIENT:TEAM:SET_SUCCESSOR", cbClientTeamSetSuccessor },
3622
3623 { "CLIENT:TEAM:SHARE_VALID_ITEM", cbClientTeamShareValidItem },
3624 { "CLIENT:TEAM:SHARE_INVALID_ITEM", cbClientTeamShareInvalidItem },
3625 { "CLIENT:TEAM:SHARE_VALID", cbClientTeamShareValid },
3626
3627 { "CLIENT:TEAM:CONTACT_ADD", cbClientAddToContactList },
3628 { "CLIENT:TEAM:CONTACT_DEL", cbClientRemoveFromContactList },
3629 { "CLIENT:TEAM:CONTACT_MOVE", cbClientMoveInContactLists },
3630
3631
3632 // { "CLIENT:TP:BOT", cbClientTpBot },
3633 // { "CLIENT:TP:WANTED", cbClientTpWanted },
3634 { "CLIENT:TP:ACK", cbClientTpAck },
3635 // { "CLIENT:TP:RESPAWN", cbClientTpRespawn },
3636
3637 // { "CLIENT:ANIMALS:DISBAND_CONVOY", cbClientAnimalsDisbandConvoy },
3638 { "CLIENT:ANIMALS:BEAST", cbClientAnimalsBeast },
3639 // { "CLIENT:ANIMALS:MOUNT", cbAnimalMount },
3640 // { "CLIENT:ANIMALS:UNSEAT", cbAnimalUnseat },
3641
3642 /*
3643 { "CLIENT:TRADE:NEXT_PAGE_ITEM", cbClientTradeNextPage },
3644 { "CLIENT:TRADE:NEXT_PAGE_MISSION_ITEM",cbClientTradeMissionNextPage },
3645 { "CLIENT:TRADE:BUY", cbClientTradeBuy },
3646 { "CLIENT:TRADE:QUERY_PRICE", cbClientTradeQuerySellPrice },
3647 { "CLIENT:TRADE:SELL", cbClientTradeSellItem },
3648 */
3649
3650 { "CLIENT:EXCHANGE:PROPOSAL", cbClientExchangeProposal },
3651 { "CLIENT:EXCHANGE:ACCEPT_INVITATION", cbClientExchangeAcceptInvitation },
3652 { "CLIENT:EXCHANGE:DECLINE_INVITATION", cbClientExchangeDeclineInvitation },
3653 { "CLIENT:EXCHANGE:SEEDS", cbClientExchangeSeeds },
3654 { "CLIENT:EXCHANGE:END", cbClientExchangeEnd },
3655 { "CLIENT:EXCHANGE:VALIDATE", cbClientExchangeValidate },
3656 { "CLIENT:EXCHANGE:INVALIDATE", cbClientExchangeInvalidate },
3657 { "CLIENT:EXCHANGE:ADD", cbClientExchangeAdd },
3658 { "CLIENT:EXCHANGE:REMOVE", cbClientExchangeRemove },
3659
3660
3661 // { "CLIENT:SENTENCE:CANCEL_CURRENT", cbClientSentenceCancelCurrent },
3662 // { "CLIENT:SENTENCE:CANCEL", cbClientSentenceCancel },
3663 // { "CLIENT:SENTENCE:CANCEL_ALL", cbClientSentenceCancelAll },
3664
3665 { "CLIENT:COMMAND:EMOTE", cbClientSendEmote },
3666 { "CLIENT:COMMAND:CUSTOM_EMOTE", cbClientSendCustomEmote },
3667 { "CLIENT:COMMAND:WHERE", cbClientSendWhere },
3668 { "CLIENT:COMMAND:ADMIN", cbClientAdmin },
3669 { "CLIENT:COMMAND:ADMIN_OFFLINE", cbClientAdminOffline },
3670 { "CLIENT:COMMAND:REMOTE_ADMIN_ANSWER", cbClientRemoteAdmin },
3671 { "CLIENT:COMMAND:SIT", cbClientSit },
3672 { "CLIENT:COMMAND:AFK", cbClientSendAfk },
3673 { "CLIENT:COMMAND:SELFKILL", cbClientSelfKill },
3674 { "CLIENT:COMMAND:RANDOM", cbClientRollDice },
3675 { "CLIENT:COMMAND:GUILDMOTD", cbClientGuildMotd },
3676 { "CLIENT:COMMAND:AUTOPACT", cbClientAutoPact },
3677
3678
3679 // For all these commented commands, now you have to use the CLIENT:COMMAND:ADMIN message using /a client command
3680
3681 // { "CLIENT:CHEAT:GOD", cbClientCheatGod },
3682 // { "CLIENT:CHEAT:CREATE_ITEM_IN_BAG", cbClientCreateItemInBag },
3683 // { "CLIENT:CHEAT:LEARN_ALL_BRICKS", cbClientLearnAllBricks },
3684 // { "CLIENT:CHEAT:MONEY", cbClientMoney },
3685 // { "CLIENT:CHEAT:SET_TIME", cbClientRyzomTime },
3686 // { "CLIENT:CHEAT:SET_DAY", cbClientRyzomDay },
3687 // { "CLIENT:CHEAT:XP", cbClientGainXp },
3688 // { "CLIENT:CHEAT:CREATE_CHARACTER", cbClientCreateCharacter },
3689 // { "CLIENT:CHEAT:ADD_ROLE", cbClientAddRole },
3690 // { "CLIENT:CHEAT:LEARN_BRICK", cbClientLearnBrick },
3691 // { "CLIENT:CHEAT:LEARN_ALL_FABER_PLANS", cbClientLearnAllFaberPlans },
3692
3693 { "CLIENT:DEBUG:WHERE", cbClientWhere },
3694 { "CLIENT:DEBUG:WHO", cbClientWho },
3695 { "CLIENT:DEBUG:PING", cbClientPing },
3696
3697 { "CLIENT:BOTCHAT:START_CHOOSE_MISSION", cbClientBotChatChooseStaticMission },
3698 { "CLIENT:BOTCHAT:NEXT_PAGE_MISSION", cbClientBotChatNextMissionPage },
3699 { "CLIENT:BOTCHAT:PICK_MISSION", cbClientBotChatPickStaticMission },
3700 { "CLIENT:BOTCHAT:CONTINUE_MISSION", cbClientContinueMission },
3701 { "CLIENT:BOTCHAT:VALIDATE_PLAYER_GIFT", cbClientValidateMissionGift },
3702
3703
3704 { "CLIENT:BOTCHAT:START_TRADE_ITEM", cbClientBotChatStartTradeItem },
3705 { "CLIENT:BOTCHAT:START_TRADE_TELEPORT", cbClientBotChatStartTradeTp },
3706 { "CLIENT:BOTCHAT:START_TRADE_FACTION", cbClientBotChatStartTradeFaction },
3707
3708 { "CLIENT:BOTCHAT:START_TRADE_GUILD_OPTIONS", cbClientBotChatStartTradeGuildOptions },
3709 { "CLIENT:BOTCHAT:BUY_GUILD_OPTION", cbClientBotChatBuyGuildOptions },
3710 { "CLIENT:BOTCHAT:START_GUILD_RESEARCH", cbClientBotChatStartGuildResearch },
3711
3712
3713 /* { "CLIENT:BOTCHAT:START_TRADE_SKILL", cbClientBotChatStartTradeSkill },
3714 { "CLIENT:BOTCHAT:START_TRADE_PACT", cbClientBotChatStartTradePact },*/
3715 { "CLIENT:BOTCHAT:START_TRADE_ACTION", cbClientBotChatStartTradeAction },
3716
3717 { "CLIENT:BOTCHAT:SET_FILTERS", cbClientBotChatSetFilters },
3718
3719
3720 { "CLIENT:BOTCHAT:NEXT_PAGE_ITEM", cbClientBotChatTradeNextPage },
3721 { "CLIENT:BOTCHAT:BUY", cbClientBotChatTradeBuy },
3722 { "CLIENT:BOTCHAT:DESTROY_ITEM", cbClientBotChatTradeDestroy },
3723 { "CLIENT:BOTCHAT:SELL", cbClientBotChatTradeSell },
3724 { "CLIENT:BOTCHAT:REFRESH_TRADE_LIST", cbRefreshTradeList },
3725
3726 { "CLIENT:BOTCHAT:START_CREATE_GUILD", cbClientBotChatStartGuildCreation },
3727
3728 { "CLIENT:BOTCHAT:END", cbClientBotChatEnd },
3729 { "CLIENT:BOTCHAT:END_GIFT", cbClientBotChatEndGift },
3730
3731 { "CLIENT:BOTCHAT:DYNCHAT_SEND", cbClientBotChatDynChatSend },
3732
3733
3734 // mission journal related commands
3735 { "CLIENT:JOURNAL:MISSION_ABANDON", cbClientAbandonMission },
3736 { "CLIENT:JOURNAL:GROUP_MISSION_ABANDON", cbClientGroupAbandonMission },
3737
3738 // guild related messages
3739 { "CLIENT:GUILD:CREATE", cbClientGuildCreate },
3740 { "CLIENT:GUILD:INVITATION", cbClientGuildJoinInvitation },
3741 { "CLIENT:GUILD:ACCEPT_INVITATION", cbClientGuildAcceptJoinInvitation },
3742 { "CLIENT:GUILD:REFUSE_INVITATION", cbClientGuildRefuseJoinInvitation },
3743
3744 { "CLIENT:GUILD:SET_GRADE", cbClientGuildSetGrade },
3745 { "CLIENT:GUILD:KICK_MEMBER", cbClientGuildKickMember },
3746
3747
3748 { "CLIENT:GUILD:QUIT", cbClientGuildQuit },
3749 { "CLIENT:GUILD:TELEPORT", cbClientGuildLiftTeleport },
3750 { "CLIENT:GUILD:FIRST_ASCENSOR_PAGE", cbClientGuildLiftDestAsked },
3751 { "CLIENT:GUILD:NEXT_ASCENSOR_PAGE", cbClientGuildLiftNextPage },
3752 { "CLIENT:GUILD:SET_PLAYER_TITLE", cbClientSetCharacterTitle },
3753 //{ "CLIENT:GUILD:BAG_TO_GUILD", cbClientBagToGuild },
3754 //{ "CLIENT:GUILD:GUILD_TO_BAG", cbClientGuildToBag },
3755 { "CLIENT:GUILD:PUT_MONEY", cbClientGuildPutMoney },
3756 { "CLIENT:GUILD:TAKE_MONEY", cbClientGuildTakeMoney },
3757
3758 // outpost related messages
3759 { "CLIENT:OUTPOST:SET_SQUAD", cbClientOutpostSetSquad },
3760 { "CLIENT:OUTPOST:SET_SQUAD_SPAWN", cbClientOutpostSetSquadSpawnZone },
3761 { "CLIENT:OUTPOST:INSERT_SQUAD", cbClientOutpostInsertSquad },
3762 { "CLIENT:OUTPOST:REMOVE_SQUAD", cbClientOutpostRemoveSquad },
3763 { "CLIENT:OUTPOST:SET_SQUAD_CAPITAL", cbClientOutpostSetExpenseLimit },
3764 // { "CLIENT:OUTPOST:BUY_BUILDING", cbClientOutpostBuyBuilding },
3765 // { "CLIENT:OUTPOST:DESTROY_BUILDING", cbClientOutpostDestroyBuilding },
3766 { "CLIENT:OUTPOST:SIDE_CHOSEN", cbClientOutpostSideChosen },
3767 { "CLIENT:OUTPOST:SELECT", cbClientOutpostSelect },
3768 { "CLIENT:OUTPOST:UNSELECT", cbClientOutpostUnselect },
3769 { "CLIENT:OUTPOST:DECLARE_WAR_START", cbClientOutpostWarStart },
3770 { "CLIENT:OUTPOST:DECLARE_WAR_VALIDATE", cbClientOutpostWarValidate },
3771 { "CLIENT:OUTPOST:GIVEUP_OUTPOST", cbClientOutpostGiveup },
3772 { "CLIENT:OUTPOST:BANISH_PLAYER", cbClientOutpostBanishPlayer },
3773 { "CLIENT:OUTPOST:BANISH_GUILD", cbClientOutpostBanishGuild },
3774 { "CLIENT:OUTPOST:SET_DEF_PERIOD", cbClientOutpostSetDefensePeriod },
3775
3776 // death management messages
3777 { "CLIENT:DEATH:ASK_RESPAWN", cbClientAskRespawn },
3778
3779 // set compass target
3780 { "CLIENT:TARGET:COMPASS_DYNAMIC", cbClientCompassEnableDynamic },
3781 { "CLIENT:TARGET:COMPASS_NOT_DYNAMIC", cbClientCompassDisableDynamic },
3782
3783 { "CLIENT:DUEL:ASK", cbClientDuelAsked },
3784 { "CLIENT:DUEL:ACCEPT", cbClientDuelAccept },
3785 { "CLIENT:DUEL:REFUSE", cbClientDuelRefuse },
3786 { "CLIENT:DUEL:ABANDON", cbClientDuelAbandon },
3787
3788 { "CLIENT:PVP_CHALLENGE:ASK", cbClientLeagueJoinProposal },
3789 { "CLIENT:PVP_CHALLENGE:ACCEPT", cbClientLeagueJoin },
3790 { "CLIENT:PVP_CHALLENGE:REFUSE", cbClientLeagueJoinProposalDecline },
3791 { "CLIENT:PVP_CHALLENGE:ABANDON", cbClientPVPChallengeAbandon },
3792
3793 // { "CLIENT:PVP_VERSUS:CLAN", cbClientPvpChooseClan },
3794 { "CLIENT:PVP:PVP_TAG", cbClientPvPSetTag },
3795 { "CLIENT:PVP:SET_NEUTRAL_ALLEGIANCE", cbClientPvPSetNeutralAllegiance },
3796 { "CLIENT:PVP:SET_NEUTRAL_ALLEGIANCE_GUILD",cbClientPvPSetNeutralAllegianceGuild },
3797
3798 { "CLIENT:MISSION:ENTER_CRITICAL", cbClientMissionEnterCritical },
3799 { "CLIENT:MISSION:WAKE", cbClientMissionWake },
3800 { "CLIENT:MISSION:GROUP_WAKE", cbClientMissionGroupWake },
3801
3802 { "CLIENT:EVENT:SET_ITEM_CUSTOM_TEXT", cbClientEventSetItemCustomText },
3803
3804 { "CLIENT:TOTEM:BUILD", cbTotemBuild },
3805
3806 { "CLIENT:DM_GIFT:BEGIN", cbDMGiftBegin },
3807 { "CLIENT:DM_GIFT:VALIDATE", cbDMGiftValidate },
3808
3809 { "CLIENT:RING_MISSION:MISSION_RING_SELECT",cbRingMissionSelectAction },
3810
3811 { "CLIENT:NPC_ICON:GET_DESC", cbGetNpcIconDesc },
3812 };
3813
3814
3815
3816 void CClientMessages::init()
3817 {
3818 // setup the callback array
3819 CUnifiedNetwork::getInstance()->addCallbackArray( CbClientArray, sizeof(CbClientArray)/sizeof(CbClientArray[0]) );
3820 }
3821
3822 void CClientMessages::release()
3823 {
3824 }