ryzom/server/src/gpm_service/messages.cpp

   1 // Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
   2 // Copyright (C) 2010  Winch Gate Property Limited
   3 //
   4 // This program is free software: you can redistribute it and/or modify
   5 // it under the terms of the GNU Affero General Public License as
   6 // published by the Free Software Foundation, either version 3 of the
   7 // License, or (at your option) any later version.
   8 //
   9 // This program is distributed in the hope that it will be useful,
  10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 // GNU Affero General Public License for more details.
  13 //
  14 // You should have received a copy of the GNU Affero General Public License
  15 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
  16
  17 #include "stdpch.h"
  18
  19 // include files
  20 #include "nel/misc/types_nl.h"
  21
  22 #include "game_share/utils.h"
  23
  24 #include "server_share/r2_variables.h"
  25 #include "game_share/r2_messages.h"
  26
  27 #include "gpm_service.h"
  28 #include "messages.h"
  29 #include "world_position_manager.h"
  30
  31 //#include "game_share/tick_event_handler.h"
  32 //#include "game_share/msg_client_server.h"
  33 //#include "game_share/mode_and_behaviour.h" //TEMP!!!
  34 //#include "game_share/news_types.h"
  35 //#include "game_share/bot_chat_types.h"
  36 //#include "game_share/brick_types.h"
  37 //#include "game_share/loot_harvest_state.h"
  38 //#include "game_share/synchronised_message.h"
  39
  40 using namespace std;
  41 using namespace NLMISC;
  42 using namespace NLNET;
  43
  44
  45
  46
  47 /****************************************************************\
  48                                                 cbAddEntity()
  49 \****************************************************************/
  50 /*
  51 void cbAddEntity( CMessage& msgin, const string &serviceName, uint16 serviceId )
  52 {
  53         // Only for invisible group entities (other entities use the mirror system)
  54
  55         CEntityId id;
  56         msgin.serial( id );
  57
  58         // entity pos (x, y, z, theta) at tick
  59         sint32 x;
  60         msgin.serial( x );
  61         sint32 y;
  62         msgin.serial( y );
  63         sint32 z;
  64         msgin.serial( z );
  65         float t;
  66         msgin.serial( t );
  67
  68         // the tick when this entity should be added
  69 //--------------------------------- DEBUG ONLY--------------------------------
  70         NLMISC::TGameCycle tick;
  71         //msgin.serial( tick );
  72         tick = CTickEventHandler::getGameCycle();
  73 //--------------------------------- DEBUG ONLY--------------------------------
  74
  75         // entity sheet
  76         CSheetId        sheet;
  77         msgin.serial( sheet );
  78
  79         uint8   continent = INVALID_CONTINENT_INDEX;
  80         if (msgin.getPos() != (sint32)msgin.length())
  81                 msgin.serial(continent);
  82
  83         sint32  cell = 0;
  84         if (msgin.getPos() != (sint32)msgin.length())
  85                 msgin.serial(cell);
  86
  87         nlinfo("<cbAddEntity> Add entity %s at pos (%d,%d,%d)", id.toString().c_str(), x,y,z );
  88         CWorldPositionManager::addEntity( id, x, y, z, t, continent, cell, tick, sheet, id.getDynamicId() );
  89 } // cbAddEntity //
  90 */
  91
  92 /****************************************************************\
  93                                                 cbAddIAObject()
  94 \****************************************************************/
  95 /*
  96 void cbAddIAObject( CMessage& msgin, const string &serviceName, uint16 serviceId )
  97 {
  98         nlerror( "TODO: process ADD_IA_OBJECT" );
  99
 100 }
 101 */
 102
 103 /****************************************************************\
 104                                                 cbAddEntities()
 105 \****************************************************************/
 106 /*void cbAddEntities( CMessage& msgin, const string &serviceName, uint16 serviceId )
 107 {
 108         //nlinfo("received ADD_ENTITIES request");
 109
 110         uint32 entitiesCount;
 111         msgin.serial( entitiesCount );
 112
 113         for( uint32 i = 0; i < entitiesCount; i++ )
 114         {
 115                 CEntityId id;
 116                 msgin.serial( id );
 117
 118                 // entity pos (x, y, z, theta) at tick
 119                 sint32 x;
 120                 msgin.serial( x );
 121                 sint32 y;
 122                 msgin.serial( y );
 123                 sint32 z;
 124                 msgin.serial( z );
 125                 float t;
 126                 msgin.serial( t );
 127
 128                 // the tick when this entity should be added
 129 //--------------------------------- DEBUG ONLY--------------------------------
 130                 NLMISC::TGameCycle tick;
 131                 //msgin.serial( tick );
 132                 tick = CTickEventHandler::getGameCycle();
 133 //--------------------------------- DEBUG ONLY--------------------------------
 134
 135                 // entity sheet
 136                 CSheetId        sheet;
 137                 msgin.serial( sheet );
 138
 139                 nlinfo("<cbAddEntities> Add entity %s at pos (%d,%d,%d)", id.toString().c_str(), x,y,z );
 140                 CWorldPositionManager::addEntity(id, x, y, z, t, INVALID_CONTINENT_INDEX, 0, tick, sheet, id.getDynamicId() );
 141         }
 142 } // cbAddEntities //
 143 /*
 144
 145   /****************************************************************\
 146                                         cbRemoveEntity()
 147 \****************************************************************/
 148 /*
 149 void cbRemoveEntity( CMessage& msgin, const string &serviceName, uint16 serviceId )
 150 {
 151         // Only for invisible group entities (other entities use the mirror system)
 152
 153         CEntityId id;
 154         id.serial( msgin );
 155
 156         nlinfo("received REMOVE_ENTITY request for id %s", id.toString().c_str() );
 157
 158         CWorldPositionManager::onRemoveEntity( id );
 159
 160 } // cbRemoveEntity //
 161 */
 162
 163 /****************************************************************\
 164                                         cbRemoveEntities()
 165 \****************************************************************/
 166 /*void cbRemoveEntities( CMessage& msgin, const string &serviceName, uint16 serviceId )
 167 {
 168         nlinfo("received REMOVE_ENTITIES request");
 169
 170         list<CEntityId> ids;
 171         msgin.serialCont( ids );
 172
 173         list<CEntityId> idsAgents;
 174
 175         list<CEntityId>::iterator it;
 176         for( it = ids.begin(); it!=ids.end(); ++it )
 177         {
 178                 CWorldPositionManager::removeEntity( *it );
 179                 nlinfo("        REMOVE_ENTITY id %s", (*it).toString().c_str() );
 180
 181                 if( (*it).getType() == RYZOMID::npc )
 182                 {
 183                         idsAgents.push_back( *it );
 184                 }
 185         }
 186
 187         if( idsAgents.size() != 0 )
 188         {
 189                 CMessage msgout("REMOVE_ENTITY");
 190
 191                 for ( it = idsAgents.begin() ; it != idsAgents.end() ; ++it)
 192                         msgout.serial( const_cast<CEntityId&> (*it) );
 193
 194                 sendMessageViaMirror( "AgS", msgout );
 195         }
 196
 197 }*/ // cbRemoveEntities //
 198
 199
 200 /****************************************************************\
 201                                         CGPMPlayerPrivilegeInst::callback
 202 \****************************************************************/
 203 void    CGPMPlayerPrivilegeInst::callback (const std::string &name, NLNET::TServiceId id)
 204 {
 205         CWorldEntity*   entity = CWorldPositionManager::getEntityPtr(PlayerIndex);
 206
 207         if (entity == NULL || entity->PlayerInfos == NULL)
 208         {
 209                 nlwarning("CGPMPlayerPrivilegeInst::callback(): entity '%d' is not a player", PlayerIndex.getIndex());
 210                 return;
 211         }
 212
 213         // enable/disable speed checking, only enabled for basic players
 214         entity->PlayerInfos->CheckSpeed = (Type == CGPMPlayerPrivilege::Player);
 215 }
 216
 217 /****************************************************************\
 218                                         cbSetPlayerFlags()
 219 \****************************************************************/
 220 void cbSetPlayerFlags( CMessage& msgin, const string &serviceName, NLNET::TServiceId serviceId )
 221 {
 222         R2::CMessageSetGPMSPlayerFlags msgData;
 223         msgin.serial(msgData);
 224
 225         CWorldEntity*   entity = CWorldPositionManager::getEntityPtr(msgData.PlayerIndex);
 226
 227         DROP_IF(entity == NULL || entity->PlayerInfos == NULL, NLMISC::toString("cbSetPlayerFlags(): entity '%d' is not a player", msgData.PlayerIndex.getIndex()), return);
 228
 229         // enable/disable speed checking, only enabled for basic players
 230         entity->PlayerInfos->CheckSpeed = msgData.LimitSpeed;
 231 }
 232
 233 /****************************************************************\
 234                                         cbBag()
 235 \****************************************************************/
 236 void cbBag( CMessage& msgin, const string &serviceName, NLNET::TServiceId serviceId )
 237 {
 238         CEntityId                                                       id;
 239         vector<CEntitySheetId>                          content;
 240
 241         msgin.serial(id);
 242         msgin.serialCont(content);
 243
 244         TDataSetRow                                                     index = CWorldPositionManager::getEntityIndex(id);
 245
 246         CWorldPositionManager::setContent(index, content);
 247
 248 } // cbBag //
 249
 250
 251 /****************************************************************\
 252                                         cbLoadContinent()
 253 \****************************************************************/
 254 void    cbLoadContinent( CMessage& msgin, const string &serviceName, NLNET::TServiceId serviceId )
 255 {
 256         uint8   continent;
 257         string  name;
 258         string  file;
 259
 260         // load continent index
 261         msgin.serial(continent);
 262
 263         // load continent name
 264         msgin.serial(name);
 265
 266         // load continent filename
 267         msgin.serial(file);
 268
 269         // load continent in position manager
 270         CWorldPositionManager::loadContinent(name, file, continent);
 271 }
 272
 273 /****************************************************************\
 274                                         cbRemoveContinent()
 275 \****************************************************************/
 276 void    cbRemoveContinent( CMessage& msgin, const string &serviceName, NLNET::TServiceId serviceId )
 277 {
 278         uint8   continent;
 279
 280         // load continent index
 281         msgin.serial(continent);
 282
 283         // remove continent from position manager
 284         CWorldPositionManager::removeContinent(continent);
 285 }
 286
 287
 288 /****************************************************************\
 289                                         cbCreateIndoorUnit()
 290 \****************************************************************/
 291 void cbCreateIndoorUnit( CMessage& msgin, const string &serviceName, NLNET::TServiceId serviceId )
 292 {
 293         DROP_IF(IsRingShard,"Creating indoor units not supported on ring shards!",return);
 294
 295         sint32  cell;
 296
 297         // cell id (should be >= 2)
 298         msgin.serial(cell);
 299
 300         if (cell < 2)
 301         {
 302                 nlwarning("cbCreateIndoorUnit(): try to create unit using id < 2");
 303                 return;
 304         }
 305
 306         CWorldPositionManager::createIndoorCell(cell);
 307
 308         nlinfo("MSG: Creating indoor unit %d",cell);
 309 }
 310
 311 /****************************************************************\
 312                                         cbCreateBuilding()
 313 \****************************************************************/
 314 void cbCreateBuilding( CMessage& msgin, const string &serviceName, NLNET::TServiceId serviceId )
 315 {
 316         uint8           continent;
 317         string          id;
 318         CVectorD        position;
 319
 320         msgin.serial(continent);
 321         msgin.serial(id);
 322         msgin.serial(position);
 323
 324         CWorldPositionManager::createBuildingInstance(continent, id, position);
 325 }
 326
 327 /****************************************************************\
 328                                         cbCreateObstacle()
 329 \****************************************************************/
 330 void cbCreateObstacle( CMessage& msgin, const string &serviceName, NLNET::TServiceId serviceId )
 331 {
 332         string          id, file;
 333         CVectorD        position;
 334         float           angle;
 335
 336         while (msgin.getPos() < (sint32)msgin.length())
 337         {
 338                 msgin.serial(id, file, position, angle);
 339                 CWorldPositionManager::instanciatePacsPrim(id, file, position, angle);
 340         }
 341 }
 342
 343 /****************************************************************\
 344                                         cbRemoveObstacle()
 345 \****************************************************************/
 346 void cbRemoveObstacle( CMessage& msgin, const string &serviceName, NLNET::TServiceId serviceId )
 347 {
 348         string          id;
 349
 350         while (msgin.getPos() < (sint32)msgin.length())
 351         {
 352                 msgin.serial(id);
 353                 CWorldPositionManager::removePacsPrim(id);
 354         }
 355 }
 356
 357 /****************************************************************\
 358                                         cbSetObstacle()
 359 \****************************************************************/
 360 void cbSetObstacle( CMessage& msgin, const string &serviceName, NLNET::TServiceId serviceId )
 361 {
 362         string          id;
 363         bool            obstacle;
 364
 365         while (msgin.getPos() < (sint32)msgin.length())
 366         {
 367                 msgin.serial(id, obstacle);
 368                 CWorldPositionManager::setObstacle(id, obstacle);
 369         }
 370 }
 371
 372 /****************************************************************\
 373                                         cbUpdateEntityPosition()
 374 \****************************************************************/
 375 /*
 376 void cbUpdateEntityPosition( CMessage& msgin, const string &serviceName, uint16 serviceId )
 377 {
 378         H_BEFORE(cbUpdatePosition);
 379         //Use only for tp, update position and clear behaviours list
 380         //nlinfo("received UPDATE_ENTITY_POSITION request");
 381
 382         CEntityId id;
 383         id.serial( msgin );
 384
 385         // entity pos (x, y, z, theta) at tick
 386         sint32 x;
 387         msgin.serial( x );
 388         sint32 y;
 389         msgin.serial( y );
 390         sint32 z;
 391         msgin.serial( z );
 392         float t;
 393         msgin.serial( t );
 394         NLMISC::TGameCycle tick;
 395         msgin.serial( tick );
 396
 397 //      nlwarning("GPMS Received Update Position, Pos(%.3f,%.3f,%.3f), theta = %.3f", x, y, z,t );
 398
 399         CWorldPositionManager::setEntityPosition(id, x, y, z, t, tick);
 400         H_AFTER(cbUpdatePosition);
 401 } // cbUpdateEntityPosition //
 402 */
 403
 404 /****************************************************************\
 405                                         cbUpdateEntitiesPositions()
 406 \****************************************************************/
 407 /*
 408 void cbUpdateEntitiesPositions( CMessage& msgin, const string &serviceName, uint16 serviceId )
 409 {
 410         H_BEFORE(cbUpdatePositions);
 411         //Use only for tp, update position and clear behaviours list
 412         //nlinfo("received UPDATE_ENTITIES_POSITIONS request");
 413
 414         uint16 entitiesCount;
 415         msgin.serial( entitiesCount );
 416
 417         NLMISC::CEntityId       sid;
 418         sint32                          x, y, z;
 419         float                           t;
 420         NLMISC::TGameCycle      tick;
 421
 422         for (uint16 i = 0 ; i < entitiesCount ; ++i)
 423         {
 424                 msgin.serial( sid );
 425                 msgin.serial( x );
 426                 msgin.serial( y );
 427                 msgin.serial( z );
 428                 msgin.serial( t );
 429                 msgin.serial( tick );
 430
 431                 //nlinfo("Entity %s: received (%.3f,%.3f,%.3f), theta = %.3f", sid.toString().c_str(), x*0.001, y*0.001, z*0.001,t );
 432
 433                 CWorldPositionManager::setEntityPosition(sid, x, y, z, t, tick);
 434         }
 435
 436         H_AFTER(cbUpdatePositions);
 437 } // cbUpdateEntitiesPositions //
 438 */
 439
 440 /****************************************************************\
 441                                         cbUpdateEntitiesPositions()
 442 \****************************************************************/
 443 /*
 444 void cbUpdateEntitiesPositionsUsingSize( CMessage& msgin, const string &serviceName, uint16 serviceId )
 445 {
 446         H_BEFORE(cbUpdatePositions);
 447         //nlinfo("received UPDATE_ENTITIES_POSITIONS request");
 448
 449         NLMISC::CEntityId       sid;
 450         sint32                          x, y, z;
 451         float                           t;
 452         NLMISC::TGameCycle      tick;
 453
 454         while (msgin.getPos() < (sint32)msgin.length())
 455         {
 456                 msgin.serial( sid );
 457                 msgin.serial( x );
 458                 msgin.serial( y );
 459                 msgin.serial( z );
 460                 msgin.serial( t );
 461                 msgin.serial( tick );
 462
 463                 //nlinfo("Entity %s: received (%.3f,%.3f,%.3f), theta = %.3f", id.toString().c_str(), x*0.001, y*0.001, z*0.001,t );
 464
 465                 CWorldPositionManager::setEntityPosition(sid, x, y, z, t, tick);
 466         }
 467
 468         H_AFTER(cbUpdatePositions);
 469 } // cbUpdateEntitiesPositions //
 470 */
 471
 472 /*
 473 /// Update orientation of several entities
 474 void cbUpdateEntitiesOrientations( CMessage& msgin, const string &serviceName, uint16 serviceId )
 475
 476 /// Update position of several entities (for re-spawn, position correction, server resync...)
 477 void cbUpdateEntitiesPositionsUsingSize( CMessage& msgin, const string &serviceName, uint16 serviceId )
 478
 479 /// Update orientation of several entities
 480 void cbUpdateEntitiesOrientationsUsingSize( CMessage& msgin, const string &serviceName, uint16 serviceId )
 481 */
 482
 483
 484
 485 /****************************************************************\
 486                                         cbEntityTeleport()
 487 \****************************************************************/
 488 void cbEntityTeleportation( CMessage& msgin, const string &serviceName, NLNET::TServiceId serviceId )
 489 {
 490         CEntityId id;
 491         NLMISC::TGameCycle tick;
 492
 493         id.serial( msgin );
 494         TDataSetRow     index = CWorldPositionManager::getEntityIndex(id);
 495
 496         if (!index.isValid())
 497                 return;
 498
 499         // if no position provided, teleport entity to nowhere
 500         if (msgin.getPos() == (sint32)msgin.length())
 501         {
 502                 if (IsRingShard)
 503                 {
 504                         // update the entity position in the ring vision universe
 505                         pCGPMS->RingVisionUniverse->setEntityPosition(index,0,0);
 506
 507                         // update the player coordinates in the mirror
 508                         CMirrorPropValue1DS<sint32>( TheDataset, index, DSPropertyPOSX )= 0;
 509                         CMirrorPropValue1DS<sint32>( TheDataset, index, DSPropertyPOSY )= 0;
 510                         CMirrorPropValue1DS<sint32>( TheDataset, index, DSPropertyPOSZ )= 0;
 511                 }
 512                 else
 513                 {
 514                         CWorldPositionManager::teleport(index, 0, 0, 0, 0.0f, NO_CONTINENT_INDEX, 0, CTickEventHandler::getGameCycle());
 515                 }
 516
 517                 nlinfo("MSG: Teleporting entity %d to continent 0 (0, 0, 0)",index.getIndex());
 518                 return;
 519         }
 520
 521         // entity pos (x, y, z, theta) at tick
 522         sint32 x;
 523         msgin.serial( x );
 524         sint32 y;
 525         msgin.serial( y );
 526         sint32 z;
 527         msgin.serial( z );
 528         float t;
 529         msgin.serial( t );
 530
 531         msgin.serial( tick );
 532
 533         // use default continent 0
 534         uint8   continent = INVALID_CONTINENT_INDEX;
 535         if (msgin.getPos() != (sint32)msgin.length())
 536                 msgin.serial(continent);
 537
 538         sint32  cell = 0;
 539         if (msgin.getPos() != (sint32)msgin.length())
 540                 msgin.serial(cell);
 541
 542         if (cell > 0)
 543         {
 544                 //nlwarning("cbEntityTeleportation(): cell=%d for %s should be zero or negative, forced to 0", cell, id.toString().c_str());
 545                 cell = 0;
 546         }
 547
 548         uint8 move_to_new_cell = 0;
 549         if (msgin.getPos() != (sint32)msgin.length())
 550                 msgin.serial(move_to_new_cell);
 551
 552         if (IsRingShard)
 553         {
 554                 // update the ring vision universe position
 555                 pCGPMS->RingVisionUniverse->setEntityPositionDelayed(index,x,y,tick);
 556
 557                 // tell the move checker to teleport the entity too
 558                 pCGPMS->MoveChecker->teleport(index, x, y, tick);
 559
 560                 // update the player coordinates in the mirror
 561                 CMirrorPropValue1DS<sint32>( TheDataset, index, DSPropertyPOSX )= x;
 562                 CMirrorPropValue1DS<sint32>( TheDataset, index, DSPropertyPOSY )= y;
 563                 CMirrorPropValue1DS<sint32>( TheDataset, index, DSPropertyPOSZ )= z;
 564                 CMirrorPropValue1DS<float>( TheDataset, index, DSPropertyORIENTATION )= t;
 565         }
 566         else
 567         {
 568                 if (move_to_new_cell == 1)
 569                 {
 570                         //nlinfo("MSG: Sliding entity %d to cell %d) at tick: %d",index.getIndex(),cell,tick);
 571                         CWorldPositionManager::updateEntityPosition(CWorldPositionManager::getEntityPtr(index), cell);
 572                 }
 573                 else
 574                 {
 575                         //nlinfo("MSG: Teleporting entity %d to continent %d cell %d (%d, %d, %d) at tick: %d",index.getIndex(),continent,cell,x,y,z,tick);
 576                         CWorldPositionManager::teleport(index, x, y, z, t, continent, cell, tick);
 577                 }
 578         }
 579
 580
 581         // lock entity after a real teleport
 582         CWorldPositionManager::lock(index, 10);
 583
 584 } // cbEntityTeleportation //
 585
 586
 587 /****************************************************************\
 588                                         cbEntityPosition()
 589 \****************************************************************/
 590 void cbEntityPosition( CMessage& msgin, const string &serviceName, NLNET::TServiceId serviceId )
 591 {
 592 //      CEntityId sender;
 593 //      sender.serial( msgin );
 594
 595         CEntityId id;
 596         id.serial( msgin );
 597
 598         TDataSetRow     index = CWorldPositionManager::getEntityIndex(id);
 599
 600         const CWorldEntity *pEntity = CWorldPositionManager::getEntity( index );
 601
 602         if( pEntity )
 603         {
 604                 CMessage msgout( "ENTITY_POS" );
 605
 606 //              msgout.serial( sender );
 607                 msgout.serial( id );
 608
 609                 sint32 val;
 610                 val = pEntity->X();
 611                 msgout.serial( val );
 612
 613                 val = pEntity->Y();
 614                 msgout.serial( val );
 615
 616                 val = pEntity->Z();
 617                 msgout.serial( val );
 618
 619                 float t = pEntity->Theta();
 620                 msgout.serial( t );
 621
 622                 sendMessageViaMirror (serviceId, msgout);
 623         }
 624         else
 625         {
 626                 nlwarning("Entity position : entity %s is not in the GPMS", id.toString().c_str());
 627         }
 628
 629 } // cbEntityPosition //
 630
 631 /****************************************************************\
 632                         Attach child entity to a father
 633 \****************************************************************/
 634 void cbAttach( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId )
 635 {
 636         CEntityId       father, child;
 637         sint32  x, y, z;
 638
 639         msgin.serial(father);
 640         msgin.serial(child);
 641         msgin.serial(x, y, z);
 642
 643         TDataSetRow     indexFather = CWorldPositionManager::getEntityIndex(father);
 644         TDataSetRow     indexChild = CWorldPositionManager::getEntityIndex(child);
 645
 646         CWorldPositionManager::attach(indexFather, indexChild, x, y, z);
 647 }
 648
 649 /****************************************************************\
 650                         Detach child entity of its current father
 651 \****************************************************************/
 652 void cbDetach( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId )
 653 {
 654         CEntityId       child;
 655
 656         msgin.serial(child);
 657
 658         TDataSetRow     childIndex = CWorldPositionManager::getEntityIndex(child);
 659
 660         CWorldPositionManager::detach(childIndex);
 661 }
 662
 663 /****************************************************************\
 664                         set player dead status
 665 \****************************************************************/
 666 void cbSetDeadStatus( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId )
 667 {
 668         CEntityId       player;
 669         bool status;
 670
 671         msgin.serial(player);
 672         msgin.serial(status);
 673
 674         TDataSetRow     index = CWorldPositionManager::getEntityIndex(player);
 675         CWorldEntity    *entity = CWorldPositionManager::getEntityPtr(index);
 676         entity->Dead = status;
 677         if (status)
 678                 nlinfo("player status changed to dead");
 679         else
 680                 nlinfo("player status changed to alive");
 681 }
 682
 683
 684 /****************************************************************\
 685                         acquire control
 686 \****************************************************************/
 687 void cbAcquireControl( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId )
 688 {
 689         CEntityId       slave, master;
 690         sint32          x, y, z;
 691
 692         msgin.serial(slave, master);
 693         msgin.serial(x, y, z);
 694
 695         TDataSetRow     indexSlave = CWorldPositionManager::getEntityIndex(slave);
 696         TDataSetRow     indexMaster = CWorldPositionManager::getEntityIndex(master);
 697
 698         CWorldPositionManager::acquireControl(indexSlave, indexMaster, x, y, z);
 699
 700         if (IsRingShard)
 701         {
 702                 pCGPMS->RingVisionUniverse->setEntityPosition(indexMaster,x,y);
 703                 pCGPMS->RingVisionUniverse->setEntityPosition(indexSlave,x,y);
 704         }
 705
 706         nlinfo("MSG: Master %s acquire control of slave %s at (%d, %d, %d)",master.toString().c_str(),slave.toString().c_str(),x,y,z);
 707 }
 708
 709
 710
 711 /****************************************************************\
 712                         leave control
 713 \****************************************************************/
 714 void cbLeaveControl( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId )
 715 {
 716         CEntityId       master;
 717
 718         msgin.serial(master);
 719
 720         TDataSetRow     indexMaster = CWorldPositionManager::getEntityIndex(master);
 721
 722         CWorldPositionManager::leaveControl(indexMaster);
 723
 724         nlinfo("MSG: Master %s release control of slave",master.toString().c_str());
 725 }
 726
 727
 728 /****************************************************************\
 729                         activate player self slot
 730 \****************************************************************/
 731 void cbActivateSelf( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId )
 732 {
 733 #ifdef HANDLE_SLOT0_SPECIAL
 734         CEntityId       id;
 735
 736         msgin.serial(id);
 737
 738         TDataSetRow             index = CWorldPositionManager::getEntityIndex(id);
 739         CWorldEntity    *entity = CWorldPositionManager::getEntityPtr(index);
 740         CWorldPositionManager::activateSelfSlot(entity);
 741 #endif
 742 }
 743
 744 /****************************************************************\
 745                         desactivate player self slot
 746 \****************************************************************/
 747 void cbDesactivateSelf( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId )
 748 {
 749 #ifdef HANDLE_SLOT0_SPECIAL
 750         CEntityId       id;
 751
 752         msgin.serial(id);
 753
 754         TDataSetRow             index = CWorldPositionManager::getEntityIndex(id);
 755         CWorldEntity    *entity = CWorldPositionManager::getEntityPtr(index);
 756         CWorldPositionManager::desactivateSelfSlot(entity);
 757 #endif
 758 }
 759
 760 // The following removed by Sadge because the entity has been removed from the mirror by the time the message arrives,
 761 // making it redundant
 762 ///****************************************************************\
 763 //                      disable vision processing
 764 //\****************************************************************/
 765 //void cbDisableVisionProcessing( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId )
 766 //{
 767 //      CEntityId       id;
 768 //
 769 //      msgin.serial(id);
 770 //
 771 //      TDataSetRow             index = CWorldPositionManager::getEntityIndex(id);
 772 //      CWorldPositionManager::setPlayerVisionProcessing(index, false);
 773 //}
 774
 775
 776 /****************************************************************\
 777                         Subscribe to a trigger
 778 \****************************************************************/
 779 void    cbTriggerSubscribe( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId )
 780 {
 781         while ((uint32)msgin.getPos() < msgin.length())
 782         {
 783                 string  name;
 784                 uint16  id;
 785                 msgin.serial(name, id);
 786                 CWorldPositionManager::triggerSubscribe(serviceId, name, id);
 787         }
 788 }
 789
 790 /****************************************************************\
 791                         Unsubscribe to a trigger
 792 \****************************************************************/
 793 void    cbTriggerUnsubscribe( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId )
 794 {
 795         while ((uint32)msgin.getPos() < msgin.length())
 796         {
 797                 uint16  id;
 798                 msgin.serial(id);
 799                 CWorldPositionManager::triggerUnsubscribe(serviceId, id);
 800         }
 801 }
 802
 803
 804 /****************************************************************\
 805                         request all entities arround an entity
 806 \****************************************************************/
 807 void cbEntitiesArroundEntity( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId )
 808 {
 809         CEntityId id;   // base entity for decide list of entities arround this
 810         list< string > propertySubscribe; // list of properties subscribe
 811
 812         msgin.serial( id );
 813         msgin.serialCont( propertySubscribe );
 814
 815         CWorldPositionManager::requestForEntityAround( serviceId, id, propertySubscribe );
 816
 817         nlinfo("Service %s asked for local mirror around entity %s",serviceName.c_str(), id.toString().c_str() );
 818 }
 819
 820 /****************************************************************\
 821           end subscription for all entities arround an entity
 822 \****************************************************************/
 823 void cbEndEntitiesArroundEntity( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId )
 824 {
 825         CEntityId id;   // base entity for decide list of entities arround this
 826
 827         msgin.serial( id );
 828
 829         CWorldPositionManager::unrequestForEntityAround( serviceId, id );
 830         nlinfo("Service %s unsubscribe for local mirror around entity %s",serviceName.c_str(), id.toString().c_str() );
 831 }
 832
 833
 834 /****************************************************************\
 835           ponctual vision request
 836 \****************************************************************/
 837 void cbVisionRequest( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId )
 838 {
 839         sint32  rid;
 840         sint32  x, y;
 841         sint32  range;
 842
 843         msgin.serial(rid, x, y, range);
 844
 845         static vector<pair<CEntityId, sint32> > entities;
 846         entities.clear();
 847
 848         // get vision
 849         CWorldPositionManager::visionRequest(x, y, range, entities);
 850
 851         // build vision answer
 852         CMessage        msgout("VISION_ANSWER");
 853         msgout.serial(rid);
 854         uint    i;
 855         const uint size = (uint)entities.size();
 856         for ( i = 0 ; i < size ; ++i)
 857                 msgout.serial(entities[i].first, entities[i].second);
 858
 859         // send it to requester
 860         sendMessageViaMirror(serviceId, msgout);
 861 }
 862
 863 /****************************************************************\
 864           ponctual vision request
 865 \****************************************************************/
 866 void cbR2ForceVisionReset( NLNET::CMessage& msgin, const std::string &serviceName, NLNET::TServiceId serviceId )
 867 {
 868         CEntityId       eid;
 869
 870         msgin.serial(eid);
 871
 872
 873         TDataSetRow entityIndex = TheDataset.getDataSetRow( eid );
 874         BOMB_IF(!entityIndex.isValid() , "Try to reset the vision of a invalid player "+eid.toString(), return);
 875
 876         pCGPMS->RingVisionUniverse->forceResetVision(entityIndex);
 877
 878 }
 879
 880
 881
 882
 883 //----------------------------
 884 //      CbArray
 885 //----------------------------
 886 TUnifiedCallbackItem CbGPMSArray[]=
 887 {
 888 // Callbacks for all service use GPMS
 889         //{ "ADD_ENTITY",                                       cbAddEntity },                                  // create a single entity
 890         //{ "ADD_ENTITIES",                             cbAddEntities },                                // create a set of entities
 891         //{ "ADD_IA_OBJECT",                            cbAddIAObject },                        // create an object only visible from ia agents
 892         //{ "REPLACE_ENTITY",                           cbReplaceEntity},                               // replace an entity by another entity
 893         //{ "REMOVE_ENTITY",                            cbRemoveEntity },                               // remove a single entity
 894         //{ "REMOVE_ENTITIES",                  cbRemoveEntities },                             // removes a set of entities
 895 /*?DEAD?*/      { "BAG",                                                cbBag },                                                // updates content of an entity (bag only ?)
 896
 897 /*?DEAD?*/      { "LOAD_CONTINENT",                             cbLoadContinent },                              // load a continent
 898 /*?DEAD?*/      { "REMOVE_CONTINENT",                   cbRemoveContinent },                    // remove a continent
 899         { "CREATE_INDOOR_UNIT",                 cbCreateIndoorUnit },                   // create an indoor unit, for latter teleport
 900 /*?DEAD?*/      { "CREATE_BUILDING",                    cbCreateBuilding },                             // create a dynamic outdoor building
 901 /*?DEAD?*/      { "CREATE_OBSTACLE",                    cbCreateObstacle },                             // create a dynamic obstacle from a pacs_prim file
 902 /*?DEAD?*/      { "REMOVE_OBSTACLE",                    cbRemoveObstacle },                             // remove a dynamic obstacle
 903 /*?DEAD?*/      { "SET_OBSTACLE",                               cbSetObstacle },                                // set dynamic obstacle state
 904
 905 /*?DEAD?*/      { "TRIGGER_SUBSCRIBE",                  cbTriggerSubscribe },
 906 /*?DEAD?*/      { "TRIGGER_UNSUBSCRIBE",                cbTriggerUnsubscribe },
 907
 908         //{ "UPDATE_ENTITY_POS",                        cbUpdateEntityPosition},                // update a single entity position
 909         //{ "UPDATE_ENTITIES_POSITIONS",  cbUpdateEntitiesPositions},           // update a set of entities positions
 910         //{ "UPDATE_ENTITIES_POS",              cbUpdateEntitiesPositionsUsingSize },   // update a set of entities positions
 911         { "ENTITY_TELEPORTATION",               cbEntityTeleportation},                 // teleport a single entity (if no position, remove from cell map)
 912
 913 /*?DEAD?*/      { "ATTACH",                                             cbAttach },                                             // attach an entity (child) to an another (father) using direct local position
 914 /*?DEAD?*/      { "DETACH",                                             cbDetach },                                             // detach an entity of its father
 915         { "SET_DEAD_STATUS",                    cbSetDeadStatus },                              // entity acquire control of another entity
 916         { "ACQUIRE_CONTROL",                    cbAcquireControl },                             // entity acquire control of another entity
 917         { "LEAVE_CONTROL",                              cbLeaveControl },                               // entity leave control of another entity
 918
 919 /*?DEAD?*/      { "ACTIV_SELF",                                 cbActivateSelf },
 920 /*?DEAD?*/      { "DESACTIV_SELF",                              cbDesactivateSelf },
 921
 922 // The following removed by Sadge because the entity has been removed from the mirror by the time the message arrives,
 923 // making it redundant
 924 // / *?DEAD?* / { "DISABLE_VISION_PROC",                cbDisableVisionProcessing },    // ask for player vision not to be updated any longer
 925
 926 /*?DEAD?*/      { "ENTITY_POS",                                 cbEntityPosition },                             // ask for position of an entity
 927
 928 /*?DEAD?*/      { "ASK_VISION_ARROUND_ENTITY",  cbEntitiesArroundEntity },              // ask for vision update around an entity
 929 /*?DEAD?*/      { "UNASK_VISION_ARROUND_ENTITY",cbEndEntitiesArroundEntity },   // remove vision update around an entity
 930
 931 /*?DEAD?*/      { "VISION_REQUEST",                             cbVisionRequest },
 932         { "SET_PLAYER_FLAGS",                   cbSetPlayerFlags },                             // set flags for player (limit speed, etc)
 933         { "R2_VISION_REFRESH",                  cbR2ForceVisionReset },                         // force the update of the vision (because some message must have been discared in Ring (in edition mode the network is not listen)
 934 };
 935
 936
 937
 938 //-------------------------------------------------------------------------
 939 // singleton initialisation and release
 940
 941 void CMessages::init()
 942 {
 943         // setup the callback array
 944         CUnifiedNetwork::getInstance()->addCallbackArray( CbGPMSArray, sizeof(CbGPMSArray)/sizeof(CbGPMSArray[0]) );
 945 }
 946
 947 void CMessages::release()
 948 {
 949 }
 950