ryzom/client/src/continent_manager.cpp

   1 // Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
   2 // Copyright (C) 2010-2019  Winch Gate Property Limited
   3 //
   4 // This source file has been modified by the following contributors:
   5 // Copyright (C) 2013  Laszlo KIS-ADAM (dfighter) <dfighter1985@gmail.com>
   6 // Copyright (C) 2014-2020  Jan BOON (Kaetemi) <jan.boon@kaetemi.be>
   7 //
   8 // This program is free software: you can redistribute it and/or modify
   9 // it under the terms of the GNU Affero General Public License as
  10 // published by the Free Software Foundation, either version 3 of the
  11 // License, or (at your option) any later version.
  12 //
  13 // This program is distributed in the hope that it will be useful,
  14 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 // GNU Affero General Public License for more details.
  17 //
  18 // You should have received a copy of the GNU Affero General Public License
  19 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
  20
  21
  22
  23 #include "stdpch.h"
  24
  25
  26 /////////////
  27 // INCLUDE //
  28 /////////////
  29 // misc
  30 #include "nel/misc/path.h"
  31 #include "nel/misc/vectord.h"
  32 #include "nel/misc/i18n.h"
  33 #include "nel/misc/progress_callback.h"
  34 // 3D Interface.
  35 #include "nel/3d/u_landscape.h"
  36 // Georges
  37 #include "nel/georges/u_form.h"
  38 #include "nel/georges/u_form_elm.h"
  39 #include "nel/georges/u_form_loader.h"
  40
  41 // Client
  42 #include "continent_manager.h"
  43 #include "client_cfg.h"
  44 #include "sheet_manager.h"
  45 #include "sound_manager.h"
  46 #include "entities.h"   // \todo Hld : a enlever lorsque unselect aura son bool bien pris en compte
  47 #include "init_main_loop.h"
  48 #include "weather.h"
  49 #include "weather_manager_client.h"
  50 #include "interface_v3/interface_manager.h"
  51 #include "interface_v3/group_map.h"
  52 //
  53 #include "input.h"
  54
  55 #include "continent_manager_build.h"
  56 ///////////
  57 // USING //
  58 ///////////
  59 using namespace NLPACS;
  60 using namespace NLMISC;
  61 using namespace NL3D;
  62 using namespace std;
  63 using namespace NLGEORGES;
  64
  65 ////////////
  66 // EXTERN //
  67 ////////////
  68 extern ULandscape               *Landscape;
  69 extern UMoveContainer   *PACS;
  70 extern UGlobalRetriever *GR;
  71 extern URetrieverBank   *RB;
  72 extern class CIGCallback                *IGCallbacks;
  73 extern NLLIGO::CLigoConfig LigoConfig;
  74
  75 UMoveContainer                  *PACSHibernated = NULL;
  76 UGlobalRetriever                *GRHibernated = NULL;
  77 URetrieverBank                  *RBHibernated = NULL;
  78 CIGCallback                             *IGCallbacksHibernated = NULL;
  79
  80 ////////////
  81 // GLOBAL //
  82 ////////////
  83
  84 // Hierarchical timer
  85 H_AUTO_DECL ( RZ_Client_Continent_Mngr_Update_Streamable )
  86
  87 /////////////
  88 // METHODS //
  89 /////////////
  90 //-----------------------------------------------
  91 // CContinentManager :
  92 // Constructor.
  93 //-----------------------------------------------
  94 CContinentManager::CContinentManager()
  95 {
  96         _Current = 0;
  97         _Hibernated = NULL;
  98 }// CContinentManager //
  99
 100
 101
 102 void CContinentManager::reset()
 103 {
 104         // stop the background sound
 105         if (SoundMngr)
 106                 SoundMngr->stopBackgroundSound();
 107
 108         // Unselect continent
 109         if (_Current)
 110                 _Current->unselect();
 111
 112         // Shared data must be NULL now
 113         _Current = NULL;
 114         nlassert (GR == NULL);
 115         nlassert (RB == NULL);
 116         nlassert (PACS == NULL);
 117         nlassert (IGCallbacks == NULL);
 118
 119         // Swap the hibernated data
 120         std::swap(GR, GRHibernated);
 121         std::swap(RB, RBHibernated);
 122         std::swap(PACS, PACSHibernated);
 123         std::swap(_Current, _Hibernated);
 124         std::swap(IGCallbacks, IGCallbacksHibernated);
 125
 126         // Unselect continent
 127         if (_Current)
 128                 _Current->unselect();
 129
 130         // remove villages
 131         removeVillages();
 132
 133         // NB: landscape zones are deleted in USCene::deleteLandscape()
 134
 135         // clear continents DB
 136         for(TContinents::iterator it = _Continents.begin(); it != _Continents.end(); ++it)
 137         {
 138                 delete it->second;
 139         }
 140         _Continents.clear();
 141         _Current = NULL;
 142         _Hibernated = NULL;
 143 }
 144
 145
 146 //-----------------------------------------------
 147 // load :
 148 // Load all continent.
 149 //-----------------------------------------------
 150
 151
 152 /*
 153 // Oldies now all these data are stored in the ryzom.world
 154 const uint32 NBCONTINENT = 8;
 155 SContInit vAllContinents[NBCONTINENT] = {
 156         { "fyros",              "fyros",                                15767,  20385,  -27098, -23769  },
 157         { "tryker",             "tryker",                               15285,  18638,  -34485, -30641  },
 158         { "matis",              "lesfalaises",                  235,    6316,   -7920,  -256    },
 159         { "zorai",              "lepaysmalade",                 6805,   12225,  -5680,  -1235   },
 160         { "bagne",              "lebagne",                              434,    1632,   -11230, -9715   },
 161         { "route",              "laroutedesombres",             5415,   7400,   -17000, -9575   },
 162         { "sources",    "sources",                              2520,   3875,   -11400, -9720   },
 163         { "terres",             "lesterres",                    100,    3075,   -15900, -13000  }
 164 };
 165 */
 166
 167 // Read the ryzom.world which give the names and bboxes
 168
 169
 170 //-----------------------------------------------
 171 void CContinentManager::preloadSheets()
 172 {
 173         reset();
 174
 175         CEntitySheet *sheet = SheetMngr.get(CSheetId("ryzom.world"));
 176
 177         if (!sheet || sheet->type() != CEntitySheet::WORLD)
 178         {
 179                 nlerror("World sheet not found or bad type");
 180         }
 181         uint32 i;
 182
 183         CWorldSheet *ws = (CWorldSheet *) sheet;
 184
 185         // Copy datas from the sheet
 186
 187         for (i = 0; i < ws->ContLocs.size(); ++i)
 188         {
 189                 const SContLoc &clTmp = ws->ContLocs[i];
 190                 std::string continentSheetName = NLMISC::toLowerAscii(clTmp.ContinentName);
 191                 if (continentSheetName.find(".continent") == std::string::npos)
 192                 {
 193                         continentSheetName += ".continent";
 194                 }
 195                 // Get the continent form
 196                 CSheetId continentId(continentSheetName);
 197                 sheet = SheetMngr.get(continentId);
 198                 if (sheet)
 199                 {
 200                         if (sheet->type() == CEntitySheet::CONTINENT)
 201                         {
 202                                 CContinent *pCont = new CContinent;
 203                                 pCont->SheetName = continentSheetName;
 204                                 _Continents.insert(make_pair(clTmp.SelectionName, pCont));
 205                         }
 206                         else
 207                         {
 208                                 nlwarning("Bad type for continent form %s.", continentSheetName.c_str());
 209                         }
 210                 }
 211                 else
 212                 {
 213                         nlwarning("cant find continent sheet : %s.", continentSheetName.c_str());
 214                 }
 215         }
 216 }
 217
 218 //-----------------------------------------------
 219 void CContinentManager::load ()
 220 {
 221         // Continents are preloaded so setup them
 222         TContinents::iterator it = _Continents.begin();
 223         while (it != _Continents.end())
 224         {
 225                 it->second->setup();
 226                 it++;
 227         }
 228
 229         loadContinentLandMarks();
 230
 231         // \todo GUIGUI : Do it better when there will be "ecosystem"/Wind/etc.
 232         // Initialize the Landscape Vegetable.
 233         if(ClientCfg.MicroVeget)
 234         {
 235                 if (Landscape)
 236                 {
 237                         // if configured, enable the vegetable and load the texture.
 238                         Landscape->enableVegetable(true);
 239                         // Default setup. TODO later by gameDev.
 240                         Landscape->setVegetableWind(CVector(0.5, 0.5, 0).normed(), 0.5, 1, 0);
 241                         // Default setup. should work well for night/day transition in 30 minutes.
 242                         // Because all vegetables will be updated every 20 seconds => 90 steps.
 243                         Landscape->setVegetableUpdateLightingFrequency(1/20.f);
 244                         // Density (percentage to ratio)
 245                         Landscape->setVegetableDensity(ClientCfg.MicroVegetDensity/100.f);
 246                 }
 247         }
 248 }// load //
 249
 250 //-----------------------------------------------
 251 // select :
 252 // Select continent from a name.
 253 // \param const string &name : name of the continent to select.
 254 //-----------------------------------------------
 255 void CContinentManager::select(const string &name, const CVectorD &pos, NLMISC::IProgressCallback &progress)
 256 {
 257         CNiceInputAuto niceInputs;
 258         // Find the continent.
 259         TContinents::iterator itCont = _Continents.find(name);
 260         if(itCont == _Continents.end())
 261         {
 262                 nlwarning("CContinentManager::select: Continent '%s' is Unknown. Cannot Select it.", name.c_str());
 263                 return;
 264         }
 265
 266         // Dirt weather
 267
 268         {
 269                 H_AUTO(InitRZWorldSetLoadingContinent)
 270                 // Set the loading continent
 271                 setLoadingContinent (itCont->second);
 272         }
 273
 274         // ** Update the weather manager for loading information
 275
 276         // Update the weather manager
 277         {
 278                 H_AUTO(InitRZWorldUpdateWeatherManager )
 279                 updateWeatherManager (itCont->second);
 280         }
 281
 282
 283         // startup season can be changed now the player is safe
 284         StartupSeason = RT.getRyzomSeason();
 285         // Modify this season according to the continent reached. eg: newbieland continent force the winter to be autumn
 286         if(StartupSeason<EGSPD::CSeason::Invalid)
 287                 StartupSeason= (*itCont).second->ForceDisplayedSeason[StartupSeason];
 288
 289         // Compute the current season according to StartupSeason, Server driver season, R2 Editor season or manual debug season
 290         CurrSeason = computeCurrSeason();
 291
 292
 293         // Is it the same continent than the old one.
 294         {
 295                 H_AUTO(InitRZWorldSelectCont)
 296                 if(((*itCont).second != _Current) || ((*itCont).second->Season != CurrSeason))
 297                 {
 298                         // New continent is not an indoor ?
 299                         if (!(*itCont).second->Indoor && _Current)
 300                         {
 301                                 // Unselect the current continent
 302                                 _Current->unselect();
 303
 304                                 // Shared data must be NULL now
 305                                 _Current = NULL;
 306                                 nlassert (GR == NULL);
 307                                 nlassert (RB == NULL);
 308                                 nlassert (PACS == NULL);
 309                                 nlassert (IGCallbacks == NULL);
 310                         }
 311                         else
 312                         {
 313                                 // Remove the primitive for all entitites (new PACS coming soon and need new primitives).
 314                                 EntitiesMngr.removeCollision();
 315                         }
 316
 317                         // Swap the hibernated data
 318                         std::swap(GR, GRHibernated);
 319                         std::swap(RB, RBHibernated);
 320                         std::swap(PACS, PACSHibernated);
 321                         std::swap(_Current, _Hibernated);
 322                         std::swap(IGCallbacks, IGCallbacksHibernated);
 323
 324                         // Is it the same continent than the old one.
 325                         if(((*itCont).second != _Current) || ((*itCont).second->Season != CurrSeason))
 326                         {
 327                                 // Unselect the old continent.
 328                                 if(_Current)
 329                                         _Current->unselect();
 330                                 _Current = (*itCont).second;
 331
 332                                 // Teleport in a new continent, complete load
 333                                 _Current->select(pos, progress, true, false, CurrSeason);
 334
 335                                 // New continent is not an indoor ?
 336                                 if (!_Current->Indoor)
 337                                 {
 338                                         // Stop the background sound
 339                                         if (SoundMngr)
 340                                                 SoundMngr->stopBackgroundSound();
 341                                 }
 342                         }
 343                         else
 344                         {
 345                                 // Teleport in the hibernated continent
 346                                 _Current->select(pos, progress, false, true, CurrSeason);
 347                         }
 348                 }
 349                 else
 350                 {
 351                         // Teleport in the same continent
 352                         _Current->select(pos, progress, false, false, CurrSeason);
 353                 }
 354         }
 355
 356         {
 357                 H_AUTO(InitRZWorldSound)
 358
 359                 // New continent is not an indoor ?
 360                 if (!_Current->Indoor)
 361                 {
 362                         if(SoundMngr)
 363                                 SoundMngr->loadContinent(name, pos);
 364                 }
 365         }
 366
 367         // Map handling
 368         {
 369                 H_AUTO(InitRZWorldMapHandling)
 370                 CWorldSheet *pWS = dynamic_cast<CWorldSheet*>(SheetMngr.get(CSheetId("ryzom.world")));
 371                 for (uint32 i = 0; i < pWS->Maps.size(); ++i)
 372                 if (pWS->Maps[i].ContinentName == name)
 373                 {
 374                         CInterfaceManager *pIM = CInterfaceManager::getInstance();
 375                         CGroupMap *pMap = dynamic_cast<CGroupMap*>(CWidgetManager::getInstance()->getElementFromId("ui:interface:map:content:map_content:actual_map"));
 376                         if (pMap != NULL)
 377                                 pMap->setMap(pWS->Maps[i].Name);
 378                         pMap = dynamic_cast<CGroupMap*>(CWidgetManager::getInstance()->getElementFromId("ui:interface:respawn_map:content:map_content:actual_map"));
 379                         if (pMap != NULL)
 380                                 pMap->setMap(pWS->Maps[i].Name);
 381                         break;
 382                 }
 383
 384         }
 385
 386 }// select //
 387
 388 //-----------------------------------------------
 389 // select :
 390 // Select closest continent from a vector.
 391 //-----------------------------------------------
 392 void CContinentManager::select(const CVectorD &pos, NLMISC::IProgressCallback &progress)
 393 {
 394
 395         CVector2f fPos;
 396         fPos.x = (float)pos.x;
 397         fPos.y = (float)pos.y;
 398         TContinents::iterator it = _Continents.begin();
 399         while (it != _Continents.end())
 400         {
 401                 CContinent *pCont = it->second;
 402                 nlinfo("Looking into %s", pCont->SheetName.c_str());
 403                 if (!pCont->Zone.VPoints.empty()) // Patch because some continent have not been done yet
 404                 {
 405                         if (pCont->Zone.contains(fPos))
 406                         {
 407                                 // load the continent selected.
 408                                 select (it->first, pos, progress);
 409                                 return;
 410                         }
 411                         else
 412                         {
 413                                 /*
 414                                 nlwarning("**********************************************");
 415                                 nlwarning("Start position (%s) not found in continent %s", NLMISC::toString(pos.asVector()).c_str(), it->first.c_str());
 416                                 for(uint k = 0; k < pCont->Zone.VPoints.size(); ++k)
 417                                 {
 418                                         nlwarning("zone point %d = %s", (int)k, NLMISC::toString(pCont->Zone.VPoints[k]).c_str());
 419                                 }
 420                                 */
 421                         }
 422                 }
 423                 it++;
 424         }
 425
 426         nlwarning("cannot select any continent at pos (%f, %f)", fPos.x, fPos.y);
 427
 428         /* *****************
 429                 PLEASE DO *****NOT***** PUT AN ASSERT HERE
 430                 While this is a bug, it is a data bug. Crashing is not a good solution in this case.
 431                 If you put an assert, it can happens this scenario for example:
 432                 - A levelDesigner put a bad Teleporter which teleport to an invalid position
 433                 - The player teleport, but its position is invalid => crash
 434                 - the next time he logs, it crashes at start, AND HENCE CANNOT ASK A GM TO TELEPORT HIM AWAY
 435
 436                 Other scenarios can happens like Data change, Continent change => Player no more at valid position etc...
 437                 HENCE MUST NOT CRASH, but display a "Lost In Space screen" leaving the player the possibility to ask HELP.
 438            *****************
 439         */
 440         //nlassertex(0, ("can't select any continent"));
 441
 442 }// select //
 443
 444
 445 bool CContinentManager::isLoadingforced(const NLMISC::CVector &playerPos) const
 446 {
 447         if(_Current == 0)
 448                 return false;
 449
 450         return _Current->isLoadingforced(playerPos);
 451 }
 452
 453 void CContinentManager::updateStreamable(const NLMISC::CVector &playerPos)
 454 {
 455         H_AUTO_USE ( RZ_Client_Continent_Mngr_Update_Streamable )
 456         if(_Current)
 457                 _Current->updateStreamable(playerPos);
 458 }
 459
 460 void CContinentManager::forceUpdateStreamable(const NLMISC::CVector &playerPos, NLMISC::IProgressCallback &progress)
 461 {
 462         H_AUTO_USE ( RZ_Client_Continent_Mngr_Update_Streamable )
 463         if (ClientCfg.VillagesEnabled)
 464         {
 465                 if(_Current)
 466                         _Current->forceUpdateStreamable(playerPos, progress);
 467         }
 468 }
 469
 470
 471
 472 void CContinentManager::removeVillages()
 473 {
 474         for(TContinents::iterator it = _Continents.begin(); it != _Continents.end(); ++it)
 475         {
 476                 if (it->second)
 477                         it->second->removeVillages();
 478         }
 479 }
 480
 481 void CContinentManager::getFogState(TFogType fogType, float dayNight, float duskRatio, CLightCycleManager::TLightState lightState, const NLMISC::CVectorD &pos, CFogState &result)
 482 {
 483         if(_Current)
 484                 _Current->getFogState(fogType, dayNight, duskRatio, lightState, pos, result);
 485 }
 486
 487 CContinent *CContinentManager::get(const std::string &contName)
 488 {
 489         TContinents::iterator it = _Continents.find(contName);
 490         if (it != _Continents.end())
 491                 return it->second;
 492         return NULL;
 493 }
 494
 495 void CContinentManager::writeTo(xmlNodePtr node) const
 496 {
 497         // <landmarks continent="bagne" type="user" />
 498         // <landmarks continent="tryker" type="user">
 499         //    <landmark type="0" x="0" y="0" title="landmark title"/>
 500         //    ...
 501         // </landmarks>
 502         for(TContinents::const_iterator it = _Continents.begin(); it != _Continents.end(); ++it)
 503         {
 504                 std::string name = it->first;
 505                 xmlNodePtr contNode = xmlNewChild(node, NULL, (const xmlChar*)"landmarks", NULL);
 506                 xmlSetProp(contNode, (const xmlChar*)"continent", (const xmlChar*)name.c_str());
 507                 xmlSetProp(contNode, (const xmlChar*)"type", (const xmlChar*)"user");
 508
 509                 if (it->second && it->second->UserLandMarks.size() > 0)
 510                 {
 511                         for(uint i = 0; i< it->second->UserLandMarks.size(); ++i)
 512                         {
 513                                 const CUserLandMark& lm = it->second->UserLandMarks[i];
 514
 515                                 xmlNodePtr lmNode = xmlNewChild(contNode, NULL, (const xmlChar*)"landmark", NULL);
 516                                 xmlSetProp(lmNode, (const xmlChar*)"type", (const xmlChar*)toString("%d", (uint32)lm.Type).c_str());
 517                                 xmlSetProp(lmNode, (const xmlChar*)"x", (const xmlChar*)toString("%.2f", lm.Pos.x).c_str());
 518                                 xmlSetProp(lmNode, (const xmlChar*)"y", (const xmlChar*)toString("%.2f", lm.Pos.y).c_str());
 519
 520                                 // sanitize ascii control chars
 521                                 // libxml will encode other special chars itself
 522                                 std::string title = lm.Title.toUtf8();
 523                                 for(uint i = 0; i< title.size(); i++)
 524                                 {
 525                                         if (title[i] >= '\0' && title[i] < ' ' && title[i] != '\n' && title[i] != '\t')
 526                                         {
 527                                                 title[i] = '?';
 528                                         }
 529                                 }
 530                                 xmlSetProp(lmNode, (const xmlChar*)"title", (const xmlChar*)title.c_str());
 531                         }
 532                 }
 533         }
 534 }
 535
 536 void CContinentManager::readFrom(xmlNodePtr node)
 537 {
 538         CXMLAutoPtr prop;
 539
 540         // <landmarks continent="bagne" type="user">
 541         //   <landmark type="0" x="0" y="0" title="landmark title" />
 542         //   ...
 543         // </landmarks>
 544         std::string continent;
 545         prop = xmlGetProp(node, (xmlChar*)"continent");
 546         if (!prop)
 547         {
 548                 nlwarning("Ignore landmarks group 'continent' attribute.");
 549                 return;
 550         }
 551         continent = (const char*)prop;
 552
 553         TContinents::iterator itContinent = _Continents.find(continent);
 554         if (itContinent == _Continents.end() || !itContinent->second)
 555         {
 556                 nlwarning("Ignore landmarks group with unknown 'continent' '%s'", continent.c_str());
 557                 return;
 558         }
 559
 560         std::string lmtype;
 561         prop = xmlGetProp(node, (xmlChar*)"type");
 562         if (!prop)
 563         {
 564                 nlwarning("Ignore landmarks group without 'type' attribute.");
 565                 return;
 566         }
 567         lmtype = toLowerAscii((const char*)prop);
 568         if (lmtype != "user")
 569         {
 570                 nlwarning("Ignore landmarks group with type '%s', expected 'user'.", lmtype.c_str());
 571                 return;
 572         }
 573
 574         node = node->children;
 575         while(node)
 576         {
 577                 if (stricmp((char*)node->name, "landmark") != 0)
 578                 {
 579                         nlwarning("Ignore invalid node '%s' under landmarks group", (const char*)node->name);
 580
 581                         node = node->next;
 582                         continue;
 583                 }
 584
 585                 bool add = true;
 586                 CUserLandMark lm;
 587
 588                 prop = xmlGetProp(node, (xmlChar*)"type");
 589                 if (prop)
 590                         fromString((const char*)prop, lm.Type);
 591                 else
 592                         nlwarning("Using default value for landmark type");
 593
 594                 prop = xmlGetProp(node, (xmlChar*)"x");
 595                 if (prop)
 596                 {
 597                         fromString((const char*)prop, lm.Pos.x);
 598                 }
 599                 else
 600                 {
 601                         nlwarning("Landmark missing 'x' attribute");
 602                         add = false;
 603                 }
 604
 605                 prop = xmlGetProp(node, (xmlChar*)"y");
 606                 if (prop)
 607                 {
 608                         fromString((const char*)prop, lm.Pos.y);
 609                 }
 610                 else
 611                 {
 612                         nlwarning("Landmark missing 'y' attribute");
 613                         add = false;
 614                 }
 615
 616                 prop = xmlGetProp(node, (xmlChar*)"title");
 617                 if (prop)
 618                 {
 619                         lm.Title.fromUtf8((const char*)prop);
 620                 }
 621                 else
 622                 {
 623                         nlwarning("Landmark missing 'title' attribute");
 624                         add = false;
 625                 }
 626
 627                 if (add)
 628                 {
 629                         // before adding, check for duplicate
 630                         // duplicates might be read from .icfg before .xml is read
 631                         add = true;
 632                         for(uint i = 0; i< itContinent->second->UserLandMarks.size(); ++i)
 633                         {
 634                                 const CUserLandMark& test = itContinent->second->UserLandMarks[i];
 635                                 uint xdiff = fabs(test.Pos.x - lm.Pos.x) * 100.f;
 636                                 uint ydiff = fabs(test.Pos.y - lm.Pos.y) * 100.f;
 637                                 if (xdiff == 0 && ydiff == 0)
 638                                 {
 639                                         add = false;
 640                                         break;
 641                                 }
 642                         }
 643
 644                         if (add)
 645                         {
 646                                 itContinent->second->UserLandMarks.push_back(lm);
 647                         }
 648                         else
 649                         {
 650                                 nlwarning("Ignore landmark with duplicate pos (continent:'%s', x:%.2f, y:%.2f, type:%d, title:'%s')", continent.c_str(), lm.Pos.x, lm.Pos.y, (uint8)lm.Type, lm.Title.toUtf8().c_str());
 651                         }
 652                 }
 653                 else
 654                 {
 655                         nlwarning("Landmark not added");
 656                 }
 657
 658                 node = node->next;
 659         }
 660 }
 661
 662 uint32 CContinentManager::serialUserLandMarks(NLMISC::IStream &f)
 663 {
 664         uint32 totalLandmarks = 0;
 665
 666         f.serialVersion(1);
 667         if (!f.isReading())
 668         {
 669                 uint32 numCont = (uint32)_Continents.size();
 670                 f.serial(numCont);
 671                 for(TContinents::iterator it = _Continents.begin(); it != _Continents.end(); ++it)
 672                 {
 673                         std::string name = it->first;
 674                         f.serial(name);
 675                         if (it->second)
 676                         {
 677                                 f.serialCont(it->second->UserLandMarks);
 678                                 totalLandmarks += it->second->UserLandMarks.size();
 679                         }
 680                         else
 681                         {
 682                                 std::vector<CUserLandMark> dummy;
 683                                 f.serialCont(dummy);
 684                         }
 685                 }
 686         }
 687         else
 688         {
 689                 uint32 numCont;
 690                 f.serial(numCont);
 691                 for(uint k = 0; k < numCont; ++k)
 692                 {
 693                         std::string contName;
 694                         f.serial(contName);
 695                         TContinents::iterator it = _Continents.find(contName);
 696                         if (it != _Continents.end() && it->second)
 697                         {
 698                                 f.serialCont(it->second->UserLandMarks);
 699                                 totalLandmarks += it->second->UserLandMarks.size();
 700                         }
 701                         else
 702                         {
 703                                 std::vector<CUserLandMark> dummy;
 704                                 f.serialCont(dummy);
 705                         }
 706                 }
 707         }
 708
 709         return totalLandmarks;
 710 }
 711
 712
 713 //-----------------------------------------------
 714 // updateUserLandMarks
 715 //-----------------------------------------------
 716 void CContinentManager::updateUserLandMarks()
 717 {
 718         CGroupMap *pMap = dynamic_cast<CGroupMap*>(CWidgetManager::getInstance()->getElementFromId("ui:interface:map:content:map_content:actual_map"));
 719         if ( pMap )
 720                 pMap->updateUserLandMarks();
 721 }
 722
 723
 724 //-----------------------------------------------
 725 // serialFOWMaps
 726 //-----------------------------------------------
 727 void CContinentManager::serialFOWMaps()
 728 {
 729         for(TContinents::iterator it = _Continents.begin(); it != _Continents.end(); ++it)
 730         {
 731                 CContinent *pCont = it->second;
 732                 //nlinfo("Saving fow continent %s of name %s", it->first.c_str(), pCont->Name.c_str());
 733                 it->second->FoW.save(pCont->Name);
 734         }
 735 }
 736
 737 const std::string &CContinentManager::getCurrentContinentSelectName()
 738 {
 739         TContinents::iterator it;
 740
 741         for (it = _Continents.begin(); it != _Continents.end(); ++it)
 742         {
 743                 if (it->second == _Current)
 744                         return it->first;
 745         }
 746
 747         static const string emptyString;
 748         return emptyString;
 749 }
 750
 751
 752 void CContinentManager::reloadWeather()
 753 {
 754         WeatherManager.release();
 755         // reload the sheet
 756         std::vector<std::string> extensions;
 757         extensions.push_back("weather_setup");
 758         extensions.push_back("weather_function_params");
 759         extensions.push_back("continent");
 760         extensions.push_back("light_cycle");
 761
 762         NLMISC::IProgressCallback pc;
 763         SheetMngr.loadAllSheet(pc, true, false, true, true, &extensions);
 764
 765         WeatherManager.init();
 766         // Load description of light cycles for each season.
 767         loadWorldLightCycle();
 768         // Load global weather function parameters
 769         loadWeatherFunctionParams();
 770
 771
 772
 773
 774         for(TContinents::iterator it = _Continents.begin(); it != _Continents.end(); ++it)
 775         {
 776                 NLMISC::CSheetId contSI(it->second->SheetName);
 777                 CContinentSheet *cs = dynamic_cast<CContinentSheet *>(SheetMngr.get(contSI));
 778                 if (cs)
 779                 {
 780                         // update continent weather part
 781                         for(uint l = 0; l < EGSPD::CSeason::Invalid; ++l)
 782                         {
 783                                 it->second->WeatherFunction[l].buildFromSheet(cs->WeatherFunction[l], WeatherManager);
 784                         }
 785                         // update misc params
 786                         it->second->FogStart = cs->Continent.FogStart;
 787                         it->second->FogEnd = cs->Continent.FogEnd;
 788                         it->second->RootFogStart = cs->Continent.RootFogStart;
 789                         it->second->RootFogEnd = cs->Continent.RootFogEnd;
 790                         it->second->LandscapeLightDay = cs->Continent.LandscapeLightDay;
 791                         it->second->LandscapeLightDusk = cs->Continent.LandscapeLightDusk;
 792                         it->second->LandscapeLightNight = cs->Continent.LandscapeLightNight;
 793                         it->second->EntityLightDay = cs->Continent.EntityLightDay;
 794                         it->second->EntityLightDusk = cs->Continent.EntityLightDusk;
 795                         it->second->EntityLightNight = cs->Continent.EntityLightNight;
 796                         it->second->RootLightDay = cs->Continent.RootLightDay;
 797                         it->second->RootLightDusk = cs->Continent.RootLightDusk;
 798                         it->second->RootLightNight = cs->Continent.RootLightNight;
 799                 }
 800         }
 801 }
 802
 803 void CContinentManager::reloadSky()
 804 {
 805         // reload new style sky
 806         std::vector<std::string> exts;
 807         CSheetManager sheetManager;
 808         exts.push_back("sky");
 809         exts.push_back("continent");
 810         NLMISC::IProgressCallback progress;
 811         sheetManager.loadAllSheet(progress, true, false, false, true, &exts);
 812         //
 813         const CSheetManager::TEntitySheetMap &sm = SheetMngr.getSheets();
 814         for(CSheetManager::TEntitySheetMap::const_iterator it = sm.begin(); it != sm.end(); ++it)
 815         {
 816                 if (it->second.EntitySheet)
 817                 {
 818                         CEntitySheet::TType type = it->second.EntitySheet->Type;
 819                         if (type == CEntitySheet::CONTINENT)
 820                         {
 821                                 // find matching sheet in new sheetManager
 822                                 const CEntitySheet *other = sheetManager.get(it->first);
 823                                 if (other)
 824                                 {
 825                                         const CContinentParameters &cp = static_cast<const CContinentSheet *>(other)->Continent;
 826                                         // find matching continent in manager
 827                                         for(TContinents::iterator it = _Continents.begin(); it != _Continents.end(); ++it)
 828                                         {
 829                                                 if (it->second && nlstricmp(it->second->Name, cp.Name) == 0)
 830                                                 {
 831                                                         std::copy(cp.SkySheet, cp.SkySheet + EGSPD::CSeason::Invalid, it->second->SkySheet);
 832                                                         break;
 833                                                 }
 834                                         }
 835                                 }
 836                         }
 837                         else if(type == CEntitySheet::SKY)
 838                         {
 839                                 // find matching sheet in new sheetManager
 840                                 const CEntitySheet *other = sheetManager.get(it->first);
 841                                 if (other)
 842                                 {
 843                                         // replace data in place
 844                                         ((CSkySheet &) *it->second.EntitySheet) = ((const CSkySheet &) *other);
 845                                 }
 846                         }
 847                 }
 848         }
 849         if (_Current)
 850         {
 851                 _Current->releaseSky();
 852                 _Current->initSky();
 853         }
 854 }
 855
 856 // ***************************************************************************
 857 void CContinentManager::loadContinentLandMarks()
 858 {
 859         std::string dataPath = "../../client/data";
 860
 861         if (ClientCfg.UpdatePackedSheet == false)
 862         {
 863                 readLMConts(dataPath);
 864         }
 865         else
 866         {
 867                 buildLMConts("ryzom.world", "../../common/data_leveldesign/primitives", dataPath);
 868                 readLMConts(dataPath);
 869         }
 870 }
 871
 872 // ***************************************************************************
 873
 874 void CContinentManager::readLMConts(const std::string &dataPath)
 875 {
 876         CIFile f;
 877
 878         string sPackedFileName = CPath::lookup(LM_PACKED_FILE, false);
 879         if (sPackedFileName.empty())
 880                 sPackedFileName = CPath::standardizePath(dataPath) + LM_PACKED_FILE;
 881
 882         if (f.open(sPackedFileName))
 883         {
 884                 uint32 nNbCont = 0;
 885                 sint ver= f.serialVersion(1);
 886                 f.serial(nNbCont);
 887                 for (uint32 i = 0; i < nNbCont; ++i)
 888                 {
 889                         string sContName;
 890                         f.serial(sContName);
 891                         TContinents::iterator itCont = _Continents.find(sContName);
 892                         if(itCont != _Continents.end())
 893                         {
 894                                 CContinent *pCont = itCont->second;
 895                                 f.serial(pCont->Zone);
 896                                 f.serial(pCont->ZoneCenter);
 897                                 f.serialCont(pCont->ContLandMarks);
 898                         }
 899                         else
 900                         {
 901                                 CContinent dummy;
 902                                 f.serial(dummy.Zone);
 903                                 f.serial(dummy.ZoneCenter);
 904                                 f.serialCont(dummy.ContLandMarks);
 905                                 nlwarning("continent not found : %s", sContName.c_str());
 906                         }
 907                 }
 908                 f.serialCont(WorldMap);
 909
 910                 if (ver >= 1)
 911                         f.serialCont(aliasToRegionMap);
 912         }
 913         else
 914         {
 915                 nlwarning("cannot load " LM_PACKED_FILE);
 916         }
 917 }
 918
 919 // ***************************************************************************
 920
 921 string CContinentManager::getRegionNameByAlias(uint32 i)
 922 {
 923         return aliasToRegionMap[i];
 924 }