ryzom/server/src/ai_service/continent.h

   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
  18
  19
  20 #ifndef CONTINENT_H
  21 #define CONTINENT_H
  22
  23 #include "nel/misc/string_mapper.h"
  24 #include "child_container.h"
  25 #include "alias_tree_root.h"
  26 #include "manager_parent.h"
  27 #include "family_profile.h"
  28 #include "ai_place_xyr.h"
  29 #include "server_share/mission_messages.h"
  30 #include <set>
  31 #include "family_behavior.h"
  32 #include "ai_outpost.h"
  33 #include "service_dependencies.h"
  34 #include "sheets.h"
  35
  36 class CContinent;
  37 class CRegion;
  38 class COutpost;
  39 class CCellZone;
  40 class CGroupFamily;
  41 class IGroupDesc;
  42 template <class FamilyT>
  43 class CGroupDesc;
  44 template <class FamilyT>
  45 class CBotDesc;
  46 class CCell;
  47 class CFaunaZone;
  48 class CNpcZone;
  49 class CRoad;
  50 class CRoadTrigger;
  51 class CAIInstance;
  52 class CMgrFauna;
  53 class CMgrNpc;
  54 class CGrpFauna;
  55 class CGroupNpc;
  56
  57 //////////////////////////////////////////////////////////////////////////////
  58 // CPopulationRecord                                                        //
  59 //////////////////////////////////////////////////////////////////////////////
  60
  61 // the description of the sets of alternative populations for the group
  62 class CPopulationRecord
  63 {
  64 public:
  65         CPopulationRecord(AISHEETS::ICreatureCPtr const& sheetData, uint count);
  66
  67         bool operator==(CPopulationRecord const& other) const;
  68
  69         AISHEETS::ICreatureCPtr getCreatureSheet() const;
  70         uint getBotCount(bool useCreatureMultiplier) const;
  71
  72         uint32 getEnergyValue(bool useCreatureMultiplier) const;
  73
  74 private:
  75         AISHEETS::ICreatureCPtr _SheetData;
  76         uint                                    _Count;
  77 };
  78
  79 //////////////////////////////////////////////////////////////////////////////
  80 // CPopulationOwner                                                         //
  81 //////////////////////////////////////////////////////////////////////////////
  82
  83 class CPopulationOwner
  84 {
  85 public:
  86         virtual ~CPopulationOwner() { }
  87 //      virtual std::string     getPopulationOwnerIndexString() const = 0;
  88
  89         virtual std::string     getIndexString() const = 0;
  90 //      {
  91 //              return getPopulationOwnerIndexString();
  92 //      }
  93 };
  94
  95 //////////////////////////////////////////////////////////////////////////////
  96 // CPopulation                                                              //
  97 //////////////////////////////////////////////////////////////////////////////
  98
  99 class CPopulation
 100 : public CAliasChild<CPopulationOwner>
 101 , public NLMISC::CRefCount
 102 {
 103 public:
 104         CPopulation(CPopulationOwner* owner, CAIAliasDescriptionNode* aliasDescription = NULL);
 105         CPopulation(CPopulationOwner* owner, uint32 alias, std::string name);
 106
 107         std::string getIndexString() const;
 108
 109         void setSpawnType(AITYPES::TSpawnType spawnType) { _SpawnType = spawnType; }
 110         AITYPES::TSpawnType const& getSpawnType() { return _SpawnType; };       // always/ day/ night/ etc
 111
 112         void setWeight(uint32 weight) { _Weight=weight; }
 113         uint32 const& getWeight() const { return _Weight; }     // random weighting for randomizer
 114
 115         void addPopRecord(CPopulationRecord popRecord);
 116
 117         // passing self off as a vector of CPopulationRecord (to avoid re-writing code)
 118         CPopulationRecord& operator[](size_t idx) const { return const_cast<CPopulationRecord &>(_PopRecords[idx]); }
 119         size_t size() const { return _PopRecords.size(); }
 120
 121 private:
 122         std::vector<CPopulationRecord> _PopRecords;
 123         uint32                          _Weight;                // random weighting for randomizer
 124         AITYPES::TSpawnType     _SpawnType;             // always/ day/ night/ etc
 125 };
 126
 127 //////////////////////////////////////////////////////////////////////////////
 128 // CAICircle                                                                //
 129 //////////////////////////////////////////////////////////////////////////////
 130
 131 /// Description of a circle with coordinate and radius
 132 class CAICircle
 133 {
 134 public:
 135         CAICircle() { }
 136         template <class V, class R>
 137         CAICircle(V const& center, R radius)
 138         : _Center(center)
 139         , _Radius(radius)
 140         {
 141         }
 142
 143         template <class V>
 144         bool isInside(V const& pos)
 145         {
 146                 return (pos - _Center).sqrnorm() <= (_Radius+1)*(_Radius+1);
 147         }
 148
 149         CAIVector const& center() const { return _Center; }
 150         double const& radius() const { return _Radius; }
 151
 152 private:
 153         CAIVector       _Center;
 154         double          _Radius;
 155 };
 156
 157 //////////////////////////////////////////////////////////////////////////////
 158 // CAabb                                                                    //
 159 //////////////////////////////////////////////////////////////////////////////
 160
 161 /// A simple AABB class
 162 class CAabb
 163 {
 164 public:
 165         CAabb();
 166
 167         template <class V>
 168         CAabb(std::vector<V> const& coords)
 169         : _VMax(INT_MIN/CAICoord::UNITS_PER_METER, INT_MIN/CAICoord::UNITS_PER_METER)
 170         , _VMin(INT_MAX/CAICoord::UNITS_PER_METER, INT_MAX/CAICoord::UNITS_PER_METER)
 171         {
 172                 for (uint k=0; k<coords.size(); ++k)
 173                         includePoint(coords[k]);
 174         }
 175
 176         template <class V>
 177         void includePoint(V const& point)
 178         {
 179                 if (point.x() < _VMin.x())
 180                         _VMin.setX(point.x());
 181                 if (point.x() > _VMax.x())
 182                         _VMax.setX(point.x());
 183                 if (point.y() < _VMin.y())
 184                         _VMin.setY(point.y());
 185                 if (point.y() > _VMax.y())
 186                         _VMax.setY(point.y());
 187         }
 188         void includeAabb(CAabb const& box);
 189
 190         void init();
 191
 192         template<class V>
 193         bool isInside(V const& v)
 194         {
 195                 return v.x() >= _VMin.x() && v.y() >= _VMin.y() && v.x() <= _VMax.x() && v.y() <= _VMax.y();
 196         }
 197
 198         CAIVector const& vmin() const { return _VMin; }
 199         CAIVector const& vmax() const { return _VMax; }
 200
 201 private:
 202         CAIVector _VMin;
 203         CAIVector _VMax;
 204 };
 205
 206
 207 //////////////////////////////////////////////////////////////////////////////
 208 // CBaseZone                                                                //
 209 //////////////////////////////////////////////////////////////////////////////
 210
 211 /* Contains properties common to all zones
 212  * (fauna zones, nps zones ...)
 213  */
 214 class CBaseZone
 215 {
 216 public:
 217         typedef CTmpPropertyZone::TTarget TZoneType;
 218         // Add a new Id identifying a substitution CGroupFamily that should be use instead
 219         // of standard CGroupFamily (those defined in CRegion), when spawning fauna on that zone
 220         // Substitution occurs when one or more subtitution id have been added
 221         void addSubstitutionGroupFamilyId(size_t id) { nlassert(id != 0); _SubstitutionGroupFamilyIds.insert(id); }
 222         void removeSubstitutionGroupFamilyId(size_t id) { nlassert(id != 0); _SubstitutionGroupFamilyIds.erase(id); }
 223         bool isSubstituted() const { return !_SubstitutionGroupFamilyIds.empty(); }
 224         bool isSubsitutedForGroupFamily(size_t id) const { return _SubstitutionGroupFamilyIds.count(id) != 0; }
 225         virtual TZoneType getZoneType() const = 0;
 226         virtual AITYPES::CPropertySet& additionalActivities() = 0;
 227         virtual AITYPES::CPropertySet const& additionalActivities () const = 0;
 228         virtual RYAI_MAP_CRUNCH::CWorldPosition const& worldValidPos() const = 0;
 229 private:
 230         std::set<size_t>      _SubstitutionGroupFamilyIds;
 231 };
 232
 233
 234 //////////////////////////////////////////////////////////////////////////////
 235 // CFaunaZone                                                               //
 236 //////////////////////////////////////////////////////////////////////////////
 237
 238 /// Zone for fauna activity
 239 class CFaunaZone
 240 : public CBaseZone
 241 , public NLMISC::CDbgRefCount<CFaunaZone>
 242 , public CAIPlaceXYR
 243 {
 244 public:
 245         CFaunaZone(CCell *owner, CAIAliasDescriptionNode *adn);
 246         ~CFaunaZone();
 247
 248         CCell* getOwner() const;
 249
 250         bool haveActivity(AITYPES::CPropertyId const& activity) const;
 251         bool haveActivity(AITYPES::CPropertySet const& activities) const;
 252         float getFreeAreaScore() const;
 253
 254         AITYPES::CPropertySet& initialActivities() { return _InitialActivities; }
 255         AITYPES::CPropertySet const& initialActivities() const { return _InitialActivities; }
 256
 257         virtual AITYPES::CPropertySet& additionalActivities() { return _AdditionalActivities; }
 258         virtual AITYPES::CPropertySet const& additionalActivities () const { return _AdditionalActivities; }
 259
 260
 261         virtual TZoneType getZoneType() const { return CTmpPropertyZone::Fauna; }
 262
 263         virtual RYAI_MAP_CRUNCH::CWorldPosition const& worldValidPos() const { return CAIPlaceXYR::worldValidPos(); }
 264
 265 private:
 266         uint32 getNbUse() const;
 267 private:
 268         AITYPES::CPropertySet _InitialActivities;
 269         AITYPES::CPropertySet _AdditionalActivities;
 270 };
 271
 272 //////////////////////////////////////////////////////////////////////////////
 273 // CAIRefPlaceXYR                                                           //
 274 //////////////////////////////////////////////////////////////////////////////
 275 class CAIRefPlaceXYR
 276 : public CAIPlace
 277 {
 278 public:
 279         CAIRefPlaceXYR(CPlaceOwner*     owner, CAIPlace const* zone);
 280
 281         operator CAIPlace const*() const;
 282
 283         NLMISC::CSmartPtr<CAIPlace const> const& getZone() const { return _Zone; }
 284         CAIPos const& midPos() const { return _Zone->midPos(); }
 285         RYAI_MAP_CRUNCH::CWorldPosition const& worldValidPos() const { return _Zone->worldValidPos(); }
 286         float getRadius() const { return _Zone->getRadius(); }
 287
 288         bool atPlace(CAIVectorMirror const& pos) const { return _Zone->atPlace(pos); }
 289         bool atPlace(CAIVector const& pos) const { return _Zone->atPlace(pos); }
 290         virtual bool atPlace(CAIEntityPhysical const* entity) const;
 291         void getRandomPos(RYAI_MAP_CRUNCH::CWorldPosition& pos) const { _Zone->getRandomPos(pos); }
 292         AITYPES::TVerticalPos getVerticalPos() const { return _Zone->getVerticalPos(); }
 293         void display(CStringWriter& stringWriter) const { _Zone->display(stringWriter); }
 294
 295 private:
 296         NLMISC::CSmartPtr<CAIPlace const> _Zone;
 297 };
 298
 299 //////////////////////////////////////////////////////////////////////////////
 300 // CAIRefPlaceXYRFauna                                                      //
 301 //////////////////////////////////////////////////////////////////////////////
 302 // Just made to track ref count CFaunaZone ..
 303 class CAIRefPlaceXYRFauna
 304 : public CAIRefPlaceXYR,
 305   public CFaunaGenericPlace
 306 {
 307 public:
 308         CAIRefPlaceXYRFauna(CPlaceOwner*        owner, CAIPlace const* zone);
 309 };
 310
 311
 312
 313
 314 //////////////////////////////////////////////////////////////////////////////
 315 // CNpcZone                                                                 //
 316 //////////////////////////////////////////////////////////////////////////////
 317
 318 /// Zone for npc activity                                                    //
 319 class CNpcZone
 320 : public CBaseZone
 321 , public NLMISC::CDbgRefCount<CNpcZone>
 322 , public virtual NLMISC::CVirtualRefCount
 323 {
 324 public:
 325         virtual ~CNpcZone();
 326         void unlinkNpcZone();
 327
 328         /// @name Abstract interface
 329         //@{
 330         virtual CCell* getOwner() const = 0;
 331         virtual const CAliasTreeOwner& getAliasTreeOwner() const = 0;
 332         virtual uint32 getIndex() const = 0;
 333
 334         virtual CPlaceRandomPos& getPlaceRandomPos() = 0;
 335         virtual const CPlaceRandomPos& getPlaceRandomPos() const = 0;
 336
 337         /// Test whether a position is inside the zone
 338         virtual bool atPlace(const CAIVector &pos) const = 0;
 339         virtual bool atPlace(const CAIVectorMirror &pos) const = 0;
 340         /// Return the position of the middle of the zone
 341         virtual const CAIPos &midPos() const = 0;
 342
 343         /// Returns the area of the zone
 344         virtual float getArea() const = 0;
 345         //@}
 346
 347         /// Returns the number of times this zone is occupied
 348         uint32 getNbUse() const;
 349
 350         /// Returns a score corresponding to the empty space
 351         virtual float getFreeAreaScore() const;
 352
 353         std::string     getIndexString() const;
 354
 355         void unrefZoneInRoads();
 356
 357         /// @name Accessors
 358         //@{
 359         AITYPES::CPropertySet& properties();
 360         const AITYPES::CPropertySet& properties() const;
 361         std::vector<NLMISC::CDbgPtr<CRoad> >& roads();
 362         //@}
 363
 364         virtual TZoneType getZoneType() const { return CTmpPropertyZone::Npc; }
 365
 366         virtual AITYPES::CPropertySet& additionalActivities() { return _Properties; }
 367         virtual AITYPES::CPropertySet const& additionalActivities () const { return _Properties; }
 368
 369 private:
 370         AITYPES::CPropertySet _Properties;
 371         /// The list of road starting from this zone.
 372         std::vector<NLMISC::CDbgPtr<CRoad> > _Roads;
 373 };
 374
 375 // :TODO: check if that inlining is necessary
 376 //inline void CNpcZone::unrefZoneInRoads(); // See at end of this file
 377
 378 //////////////////////////////////////////////////////////////////////////////
 379 // CNpcZonePlace                                                            //
 380 //////////////////////////////////////////////////////////////////////////////
 381
 382 class CNpcZonePlace
 383 : public CNpcZone
 384 , public CPlaceRandomPos
 385 , public CAIPlace
 386 {
 387 public:
 388         CNpcZonePlace(CCell* owner, CAIAliasDescriptionNode* adn);
 389         ~CNpcZonePlace();
 390
 391         /// @name CNpcZone implementation
 392         //@{
 393         CCell* getOwner() const;
 394         CAliasTreeOwner const& getAliasTreeOwner() const;
 395         uint32  getIndex()      const;
 396
 397         CPlaceRandomPos& getPlaceRandomPos();
 398         CPlaceRandomPos const& getPlaceRandomPos() const;
 399
 400         virtual bool atPlace(const CAIVector &pos) const;
 401         virtual bool atPlace(const CAIVectorMirror &pos) const;
 402         virtual bool atPlace(CAIEntityPhysical const* entity) const;
 403
 404         virtual CAIPos const& midPos() const;
 405
 406         virtual float getArea() const;
 407
 408         virtual RYAI_MAP_CRUNCH::CWorldPosition const& worldValidPos() const;
 409
 410         virtual float getRadius() const;
 411
 412         virtual void display(CStringWriter      &stringWriter) const;
 413
 414         virtual AITYPES::TVerticalPos getVerticalPos() const;
 415         virtual void getRandomPos(RYAI_MAP_CRUNCH::CWorldPosition &pos) const;
 416         //@}
 417
 418         void setPosAndRadius(AITYPES::TVerticalPos verticalPos, const CAIPos& pos, uint32 radius);
 419
 420 private:
 421
 422         bool calcRandomPos(CAIPos& pos) const;
 423
 424 private:
 425         RYAI_MAP_CRUNCH::CWorldPosition _worldValidPos;
 426         CAIPos _pos;
 427         float _radius;
 428 };
 429
 430 //////////////////////////////////////////////////////////////////////////////
 431 // CNpcZonePlaceNoPrim                                                      //
 432 //////////////////////////////////////////////////////////////////////////////
 433
 434 class CNpcZonePlaceNoPrim
 435 : public virtual NLMISC::CVirtualRefCount
 436 {
 437 public:
 438         CNpcZonePlaceNoPrim();
 439         ~CNpcZonePlaceNoPrim();
 440
 441         /// @name CNpcZone implementation
 442         //@{
 443         virtual bool atPlace(const CAIVector &pos) const;
 444         virtual bool atPlace(const CAIVectorMirror &pos) const;
 445         virtual bool atPlace(CAIEntityPhysical const* entity) const;
 446
 447         virtual CAIPos const& midPos() const;
 448
 449         virtual float getArea() const;
 450
 451         virtual RYAI_MAP_CRUNCH::CWorldPosition const& worldValidPos() const;
 452
 453         virtual float getRadius() const;
 454
 455         virtual void display(CStringWriter      &stringWriter) const;
 456
 457         virtual AITYPES::TVerticalPos getVerticalPos() const;
 458         virtual void getRandomPos(RYAI_MAP_CRUNCH::CWorldPosition &pos) const;
 459         virtual uint getRandomPosCount() const { return 1; }
 460         //@}
 461
 462         void setPosAndRadius(AITYPES::TVerticalPos verticalPos, const CAIPos& pos, uint32 radius);
 463
 464 private:
 465
 466         bool calcRandomPos(CAIPos& pos) const;
 467
 468 private:
 469         RYAI_MAP_CRUNCH::CWorldPosition _WorldValidPos;
 470         CAIPos                                  _Pos;
 471         float                                   _Radius;
 472         AITYPES::TVerticalPos   _VerticalPos;
 473 };
 474
 475 //////////////////////////////////////////////////////////////////////////////
 476 // CNpcZoneShape                                                            //
 477 //////////////////////////////////////////////////////////////////////////////
 478
 479 class CNpcZoneShape
 480 : public CNpcZone
 481 , public CAIPlace
 482 {
 483 public:
 484         CNpcZoneShape(CCell* owner, CAIAliasDescriptionNode* adn);
 485         ~CNpcZoneShape();
 486
 487         /// @name CNpcZone implementation
 488         //@{
 489         virtual CCell* getOwner() const;
 490         virtual CAliasTreeOwner const& getAliasTreeOwner() const;
 491         virtual uint32 getIndex() const;
 492
 493         virtual CPlaceRandomPos& getPlaceRandomPos();
 494         virtual CPlaceRandomPos const& getPlaceRandomPos() const;
 495
 496         virtual bool atPlace(const CAIVector& pos) const;
 497         virtual bool atPlace(const CAIVectorMirror &pos) const;
 498         virtual bool atPlace(CAIEntityPhysical const* entity) const;
 499         virtual CAIPos const& midPos() const;
 500
 501         virtual float getArea() const;
 502
 503         virtual const RYAI_MAP_CRUNCH::CWorldPosition& worldValidPos() const;
 504
 505         virtual float getRadius() const;
 506
 507         virtual void display(CStringWriter      &stringWriter) const;
 508
 509         virtual AITYPES::TVerticalPos getVerticalPos() const;
 510         virtual void getRandomPos(RYAI_MAP_CRUNCH::CWorldPosition &pos) const;
 511         //@}
 512
 513         void setPatat(AITYPES::TVerticalPos verticalPos, const std::vector<CAIVector>& points);
 514
 515 private:
 516         void buildMidPos();
 517
 518 private:
 519         RYAI_MAP_CRUNCH::CWorldPosition _worldValidPos;
 520         CShape _shape;
 521         CAIPos _midPos;
 522 };
 523
 524 //////////////////////////////////////////////////////////////////////////////
 525 // CLazyProcess                                                             //
 526 //////////////////////////////////////////////////////////////////////////////
 527
 528 class CLazyProcess
 529 : public NLMISC::CRefCount
 530 {
 531 public:
 532         virtual ~CLazyProcess() {}
 533         /// Used to update some dependencies for instance road connections when the first next update of CContinent is called.
 534         virtual void update() const = 0;
 535         /// Used to check if there's no need to add another lazyprocess.
 536         virtual bool absorb(CLazyProcess const& lazyProcess) const = 0;
 537 };
 538
 539 //////////////////////////////////////////////////////////////////////////////
 540 // CRebuildContinentAndOutPost                                              //
 541 //////////////////////////////////////////////////////////////////////////////
 542
 543 class CRebuildContinentAndOutPost
 544 : public CLazyProcess
 545 {
 546 public:
 547         CRebuildContinentAndOutPost(CContinent* continent);
 548
 549 protected:
 550         void update () const;
 551         bool absorb(CLazyProcess const& lazyProcess) const;
 552         bool operator==(CRebuildContinentAndOutPost const& other) const;
 553
 554 private:
 555         CContinent* _Continent;
 556 };
 557
 558 //////////////////////////////////////////////////////////////////////////////
 559 // CContinent                                                               //
 560 //////////////////////////////////////////////////////////////////////////////
 561
 562 /// Store regions and spead energy level.
 563 class CContinent
 564 : public NLMISC::CDbgRefCount<CContinent>
 565 , public CChild<CAIInstance>
 566 , public NLMISC::CRefCount
 567 , public CServiceEvent::CHandler
 568 , public CAIEntity
 569 {
 570 public:
 571         CContinent(CAIInstance* owner);
 572
 573         virtual ~CContinent();
 574
 575         CAIInstance* getAIInstance() const { return getOwner(); }
 576
 577         CAliasCont<CRegion>& regions() { return _Regions;}
 578         CAliasCont<COutpost>& outposts() { return _Outposts;}
 579         CAliasCont<COutpost> const& outposts() const { return _Outposts;}
 580
 581         CNpcZone* findNpcZone(CAIVector const& posInside);
 582
 583         /// Tag all the regions loaded from fileId to delete
 584         bool markTagForDelete(NLMISC::TStringId fileId);
 585         /// Delete all region that are taged
 586         bool deleteTaggedAlias(NLMISC::TStringId fileId);
 587
 588         void rebuildBoundingBox();
 589         /// Update the continent
 590         void    update();
 591
 592         void pushLazyProcess(NLMISC::CSmartPtr<CLazyProcess> lazyProcess);
 593         void updateLazyProcess();
 594
 595         // Some service are up, need to send them data?
 596         void serviceEvent(CServiceEvent const& info);
 597
 598         bool spawn();
 599         bool despawn();
 600
 601         std::string getFullName() const { return getName(); }
 602         std::string getIndexString() const;
 603         virtual std::string     getOneLineInfoString() const;
 604         virtual std::vector<std::string> getMultiLineInfoString() const;
 605
 606         void setName(std::string const& name) { _ContinentName = name; }
 607
 608         std::string getName() const { return _ContinentName; }
 609
 610         /// Bounding box info.
 611         CAabb _BoundingBox;
 612         typedef std::vector<NLMISC::CSmartPtr<CLazyProcess> > TLazyProcessList;
 613         TLazyProcessList _LazyProcess;
 614
 615 private:
 616         /// @name AI service hierarchy
 617         //@{
 618         /// The set of regions stored in this continent
 619         CAliasCont<CRegion> _Regions;
 620         /// The set of outpost stored in this continent
 621         CAliasCont<COutpost> _Outposts;
 622         //@}
 623
 624         /// Name of the continent
 625         std::string _ContinentName;
 626
 627         IAliasCont* getAliasCont(AITYPES::TAIType type);
 628 };
 629
 630 //////////////////////////////////////////////////////////////////////////////
 631 // CRegion                                                                  //
 632 //////////////////////////////////////////////////////////////////////////////
 633
 634 /// Store cell zones, groups templates and roads.
 635 class CRegion
 636 : public CAliasChild<CContinent>
 637 , public NLMISC::CRefCount
 638 , public CAliasTreeRoot
 639 , public CServiceEvent::CHandler
 640 , public CAIEntity
 641 {
 642 public:
 643         CRegion(CContinent* owner, uint32 alias, std::string const& name, std::string const& filename);
 644         virtual ~CRegion();
 645
 646         CAIInstance* getAIInstance() const { return getOwner()->getAIInstance(); }
 647
 648         CAliasCont<CCellZone>& cellZones() { return _CellZones; }
 649
 650         CAliasCont<CGroupFamily>& groupFamilies() { return _GroupFamilies; }
 651
 652         virtual std::string getIndexString() const;
 653         virtual std::string     getOneLineInfoString() const;
 654         virtual std::vector<std::string> getMultiLineInfoString() const;
 655         virtual std::string getFullName() const;
 656
 657         /// Rebuild the bounding box
 658         void rebuildBoundingBox();
 659         /// Rebuild the link road->zone and conectivity graph for cells
 660         void rebuildConnectivity();
 661
 662         /// Update the region
 663         void update();
 664         void serviceEvent(CServiceEvent const& info);
 665
 666         bool spawn();
 667         bool despawn();
 668
 669         /// Bounding box info.
 670         CAabb _BoundingBox;
 671
 672 private:
 673         /// @name AI service hierarchy
 674         //@{
 675         /// Container for owned cellzones
 676         CAliasCont<CCellZone> _CellZones;
 677         /// Container for owner group descs
 678         CAliasCont<CGroupFamily> _GroupFamilies;
 679         //@}
 680
 681         IAliasCont* getAliasCont(AITYPES::TAIType type);
 682         CAliasTreeOwner* createChild(IAliasCont* cont, CAIAliasDescriptionNode* aliasTree);
 683 };
 684
 685 //////////////////////////////////////////////////////////////////////////////
 686 // CRoad                                                                    //
 687 //////////////////////////////////////////////////////////////////////////////
 688
 689 /// Road for npc moving.
 690 class CRoad
 691 : public        NLMISC::CDbgRefCount<CRoad>
 692 , public        NLMISC::CRefCount
 693 , public        CAliasChild<CCell>
 694 {
 695 public:
 696         CRoad(CCell* owner, uint32 alias, std::string const& name);
 697         ~CRoad();
 698
 699         std::string getIndexString() const;
 700
 701         CAIVector const& getLogicStart() const { return _Start; }
 702         CAIVector const& getLogicEnd() const { return   _End; }
 703         AITYPES::TVerticalPos const& verticalPos() const { return _VerticalPos; }
 704         void setVerticalPos(AITYPES::TVerticalPos const& vertPos) { _VerticalPos = vertPos; }
 705         std::vector<RYAI_MAP_CRUNCH::CWorldPosition> const& coords() const { return _Coords; }
 706         void clearCoords() { _Coords.clear(); }
 707
 708         NLMISC::CDbgPtr<CNpcZone> const& startZone() const { return _StartZone; }
 709         NLMISC::CDbgPtr<CNpcZone> const& endZone() const { return _EndZone; }
 710
 711         bool const& startExternal()     const { return _StartExternal; }
 712
 713         bool const& endExternal() const { return _EndExternal; }
 714
 715         void setStartZone(CNpcZone const* npcZone);
 716         void setEndZone(CNpcZone const* npcZone);
 717
 718         void unlinkRoad();
 719
 720         void calcLength();
 721
 722         void setDifficulty(float const& difficulty);
 723
 724         void calCost();
 725
 726         // Pathfinding property.
 727         float getCost() const;
 728
 729         CAliasCont<CRoadTrigger>& triggers() { return _RoadTriggers; }
 730
 731         void setPathPoints(AITYPES::TVerticalPos verticalPos, std::vector<CAIVector> const& points);
 732
 733         std::set<CNpcZone*>      AllZones;
 734
 735 private:
 736         /// @name AI service hierarchy
 737         //@{
 738         CAliasCont<CRoadTrigger> _RoadTriggers;
 739         //@}
 740
 741         IAliasCont* getAliasCont(AITYPES::TAIType type);
 742         CAliasTreeOwner* createChild(IAliasCont* cont, CAIAliasDescriptionNode* aliasTree);
 743
 744         /// The vertical pos
 745         AITYPES::TVerticalPos _VerticalPos;
 746         /// The path of the road
 747         std::vector<RYAI_MAP_CRUNCH::CWorldPosition> _Coords;
 748         /// Pointer to the zone at start of road
 749         NLMISC::CDbgPtr<CNpcZone> _StartZone;
 750         /// Flag that indicate the zone is outside the region
 751         bool _StartExternal;
 752         /// Pointer to the zone at end of road
 753         NLMISC::CDbgPtr<CNpcZone> _EndZone;
 754         /// Flag that indicate the zone is outside the region
 755         bool _EndExternal;
 756
 757         // Data for path finding
 758         /// length of the road segment
 759         float _Length;
 760         /// Difficulty of the road
 761         float _Difficulty;
 762
 763         float _CostCoef;
 764
 765         CAIVector _Start;
 766         CAIVector _End;
 767 };
 768
 769 //////////////////////////////////////////////////////////////////////////////
 770 // CRoadTrigger                                                             //
 771 //////////////////////////////////////////////////////////////////////////////
 772
 773 class CRoadTrigger
 774 : public CAliasChild<CRoad>
 775 , public NLMISC::CRefCount
 776 {
 777 public:
 778         CRoadTrigger(CRoad* owner, uint32 alias, std::string const& name);
 779
 780         std::string getIndexString() const;
 781
 782         CAICircle _Trigger1;
 783         CAICircle _Trigger2;
 784         CAICircle _Spawn;
 785 };
 786
 787 //////////////////////////////////////////////////////////////////////////////
 788 // CZoneScorer                                                              //
 789 //////////////////////////////////////////////////////////////////////////////
 790
 791 class CZoneScorer
 792 {
 793 public:
 794         virtual ~CZoneScorer() { }
 795         virtual float getScore(CNpcZone const& zone) const = 0;
 796         virtual float getParam(CNpcZone const& zone) const { return 0.f; };
 797 };
 798
 799 //////////////////////////////////////////////////////////////////////////////
 800 // CCellZone                                                                //
 801 //////////////////////////////////////////////////////////////////////////////
 802
 803 /// Container for cell and energy levels.
 804 class CCellZone
 805 : public CAliasChild<CRegion>
 806 , public NLMISC::CRefCount
 807 , public CServiceEvent::CHandler
 808 , public CAIEntity
 809 {
 810 public:
 811         CCellZone(CRegion* owner, uint32 alias, std::string const& name);
 812         ~CCellZone();
 813
 814         CAIInstance* getAIInstance() const { return getOwner()->getAIInstance(); }
 815
 816         CAliasCont<CCell>& cells() { return _Cells; }
 817
 818         void unrefZoneInRoads();
 819
 820         std::string getIndexString() const;
 821         virtual std::string     getOneLineInfoString() const;
 822         virtual std::vector<std::string> getMultiLineInfoString() const;
 823         virtual std::string getFullName() const;
 824
 825         void rebuildEnergyLevels();
 826         void update();
 827         void serviceEvent(CServiceEvent const& info);
 828
 829         bool findRestAndFoodFaunaZoneInCellList(CFaunaZone const*& zoneRest, AITYPES::CPropertySet const& rest, CFaunaZone const*& zoneFood, AITYPES::CPropertySet const& food, std::vector<CCell*> const& cells, RYAI_MAP_CRUNCH::TAStarFlag denyflags);
 830
 831
 832         CFaunaZone const* lookupFaunaZone(AITYPES::CPropertySet const& activity, RYAI_MAP_CRUNCH::TAStarFlag denyflags, size_t replacementGroupFamilyId = 0);
 833         const CNpcZone *lookupNpcZone(AITYPES::CPropertySet const& activity, size_t replacementGroupFamilyId = 0);
 834         static CNpcZone const* lookupNpcZoneScorer(std::vector<CCell*> cells, CZoneScorer const& scorer);
 835
 836         const CNpcZone* lookupNpcZoneByName(std::string const& zoneName);
 837
 838         CCont<CFamilyBehavior>& familyBehaviors() { return _Families; }
 839
 840         bool spawn();
 841         bool despawn();
 842
 843         /// Bouding box surrounding all the contained cells.
 844         CAabb _BoundingBox;
 845
 846         /// @name AI service hierarchy
 847         //@{
 848 public:
 849         /// The family behavior container
 850         CCont<CFamilyBehavior> _Families;
 851 private:
 852         CAliasCont<CCell> _Cells;
 853         //@}
 854
 855 private:
 856         // overloads for CAliasChild virtuals
 857         IAliasCont* getAliasCont(AITYPES::TAIType type);
 858         CAliasTreeOwner* createChild(IAliasCont* cont, CAIAliasDescriptionNode* aliasTree);
 859 };
 860
 861 //////////////////////////////////////////////////////////////////////////////
 862 // CCell                                                                    //
 863 //////////////////////////////////////////////////////////////////////////////
 864
 865 /** Cell definition.
 866  *      Contains npc and faune zones.
 867  */
 868 typedef CAliasCont<CNpcZonePlace> TAliasZonePlaceList;
 869 typedef CAliasCont<CNpcZoneShape> TAliasZoneShapeList;
 870
 871 class CCell
 872 : public NLMISC::CDbgRefCount<CCell>
 873 , public NLMISC::CRefCount
 874 , public CAliasChild<CCellZone>
 875 , public CPlaceOwner
 876 {
 877 public:
 878         CCell(CCellZone* owner, uint32 alias, std::string const& name);
 879         ~CCell();
 880
 881         void unlinkCell();
 882
 883         CAliasCont<CRoad>& roads() { return _Roads; }
 884
 885         void connectRoads();
 886
 887         CAliasCont<CFaunaZone>& faunaZones() { return _FaunaZones; }
 888         CAliasCont<CFaunaZone> const& faunaZonesCst() const { return _FaunaZones; }
 889
 890         CNpcZone* findNpcZone(CAIVector const& posInside);
 891
 892         size_t npcZoneCount();
 893         CNpcZone* npcZone(size_t index);
 894         TAliasZonePlaceList& npcZonePlaces() { return _NpcZonePlaces; }
 895         TAliasZoneShapeList& npcZoneShapes() { return _NpcZoneShapes; }
 896         TAliasZonePlaceList     const& npcZonePlacesCst() const { return _NpcZonePlaces; }
 897         TAliasZoneShapeList const& npcZoneShapesCst() const { return _NpcZoneShapes; }
 898
 899         AITYPES::CPropertySet const& properties() const { return _Properties; }
 900         AITYPES::CPropertySet& properties() { return _Properties; }
 901
 902         void getNeighBourgCellList(std::vector<CCell*>& cells) const;
 903
 904         void unrefZoneInRoads();
 905
 906         virtual std::string getIndexString() const;
 907         virtual std::string getFullName() const;
 908
 909         /// The coordinate of the polygon surounding the cell
 910         std::vector<CAIVector> _Coords;
 911         /// The liste of flag for family that can come in this cell
 912
 913         AITYPES::CPropertySet _Properties;
 914
 915         /// The list of neighbour cells
 916         std::set<NLMISC::CDbgPtr<CCell> > _NeighbourCells;
 917
 918         CAabb _BoundingBox;
 919
 920 private:
 921         /// @name AI service hierarchy
 922         //@{
 923         CAliasCont<CFaunaZone> _FaunaZones;
 924
 925         /// Container for owned roads
 926         CAliasCont<CRoad> _Roads;
 927         //@}
 928
 929         TAliasZonePlaceList _NpcZonePlaces;
 930         TAliasZoneShapeList _NpcZoneShapes;
 931
 932         IAliasCont* getAliasCont(AITYPES::TAIType type);
 933         CAliasTreeOwner* createChild(IAliasCont* cont, CAIAliasDescriptionNode* aliasTree);
 934
 935 //      std::string     getPlaceOwnerFullName() const { return getFullName(); }
 936 //      std::string     getPlaceOwnerIndexString() const { return getIndexString(); }
 937 };
 938
 939 //////////////////////////////////////////////////////////////////////////////
 940 // CAggroGroupContainer                                                     //
 941 //////////////////////////////////////////////////////////////////////////////
 942
 943 class CAggroGroupContainer
 944 : public NLMISC::CVirtualRefCount
 945 {
 946 public:
 947         std::vector<uint32> aggroGroupIds;
 948 };
 949
 950
 951 class CZoneMarker;
 952
 953 //////////////////////////////////////////////////////////////////////////////
 954 // CGroupFamily                                                             //
 955 //////////////////////////////////////////////////////////////////////////////
 956
 957 class CGroupFamily
 958 : public NLMISC::CDbgRefCount<CGroupFamily>
 959 , public NLMISC::CRefCount
 960 , public CAliasTreeOwner
 961 , public CLevelEnergy
 962 {
 963 public:
 964         CGroupFamily(CAliasTreeOwner *owner, uint32 alias, std::string const& name);
 965         virtual ~CGroupFamily();
 966
 967         CAliasTreeOwner *getOwner() const { return _Owner; }
 968
 969         void setFamilyTag(std::string const& familyTag) { _FamilyTag = AITYPES::CPropertyId(familyTag); }
 970         AITYPES::CPropertyId const& getFamilyTag() const { return _FamilyTag; }
 971
 972         void setProfileName(std::string const& profileName) { _ProfileName = NLMISC::CStringMapper::map(profileName); }
 973
 974         typedef std::map<NLMISC::TStringId, NLMISC::CSmartPtr<NLMISC::CVirtualRefCount> > TParamsList;
 975         TParamsList     _Params;
 976
 977         void setProfileParams(std::string const& str, NLMISC::CVirtualRefCount* objet);
 978
 979         NLMISC::CVirtualRefCount const* getProfileParams(std::string const& str) const;
 980
 981         CAliasCont<CGroupDesc<CGroupFamily> >& groupDescs() { return _GroupDescs; }
 982
 983         /*
 984         std::string getFullName() const { return std::string(getOwner()->getFullName() +":"+ getName()); }
 985
 986         std::string getIndexString() const { return getOwner()->getIndexString()+NLMISC::toString(":%u", getChildIndex()); }
 987         */
 988
 989
 990         std::string getFullName() const { return "???:" + getName(); }
 991         std::string getIndexString() const { return "???" + NLMISC::toString(":%u", getChildIndex()); }
 992
 993         // mimic CChild behaviour
 994         void setChildIndex(uint32 index)
 995         {
 996                 _Index = index;
 997         }
 998
 999         uint32 getChildIndex() const
1000         {
1001                 return _Index;
1002         }
1003
1004         IAliasCont* getAliasCont(AITYPES::TAIType type);
1005         CAliasTreeOwner* createChild(IAliasCont* cont, CAIAliasDescriptionNode* aliasTree);
1006
1007         CGroupDesc<CGroupFamily> const* getProportionalGroupDesc(CFamilyBehavior const* const familyBehavior, AITYPES::CPropertySet const& needActFlag, AITYPES::CPropertySet const& maskActFlag);
1008
1009         NLMISC::TStringId const& profileName() const { return _ProfileName; }
1010
1011         typedef std::map<NLMISC::TStringId, AITYPES::CPropertySet> TActivityList;
1012
1013         void addProfileProperty(std::string const& propertyName, AITYPES::CPropertySet const& property);
1014         AITYPES::CPropertySet const& getProfileProperty(std::string const& propertyName) const;
1015
1016
1017         // mark this GroupFamily as a substitution group. An id of 0 means this group is not a substitution group (which is the default)
1018         // subtitution GroupFamily will shadow standard GroupFamily group at update
1019         // for the fauna zones that have the same id than this group in their subtitution id list.
1020         // (if the subtitution list is empty then the fauna zone GroupFamilies are not substituted)
1021         void    setSubstitutionId(size_t substitutionId) { _SubstitutionId = substitutionId; }
1022         size_t  getSubstitutionId() const { return _SubstitutionId; }
1023
1024         void    addZoneMarkerRef(CZoneMarker *zm) { _ZoneMarkerRef.insert(zm); }
1025         void    removeZoneMarkerRef(CZoneMarker *zm) { _ZoneMarkerRef.erase(zm); }
1026         bool    hasZoneMarkerRef() const { return !_ZoneMarkerRef.empty(); }
1027
1028         virtual std::string     getOneLineInfoString() const { return std::string("Group family '") + getName() + "'"; }
1029
1030 private:
1031         /// @name AI service hierarchy
1032         //@{
1033         CAliasCont<CGroupDesc<CGroupFamily> >   _GroupDescs;
1034         //@}
1035
1036         TActivityList                   _Properties;
1037         NLMISC::TStringId               _ProfileName;
1038         // If the family is a tribe, the property describe the name of the family (witch is the tribe name for tribe family)
1039         AITYPES::CPropertyId    _FamilyTag;
1040         size_t                                  _SubstitutionId;
1041         uint32                                  _Index;
1042         CAliasTreeOwner                 *_Owner;
1043         std::set<CZoneMarker *> _ZoneMarkerRef;
1044 };
1045
1046
1047
1048 //////////////////////////////////////////////////////////////////////////////
1049 // CGroupDesc                                                               //
1050 //////////////////////////////////////////////////////////////////////////////
1051
1052 class IGroupDesc
1053 : public NLMISC::CRefCount
1054 {
1055 public:
1056         virtual ~IGroupDesc() {}
1057         virtual uint32 groupEnergyValue() const = 0;
1058         virtual float groupEnergyCoef() const = 0;
1059         virtual bool getCountMultiplierFlag() const = 0;
1060         virtual uint32 getWeightForEnergy(size_t levelIndex) const = 0;
1061         virtual bool isValidForSeason(EGSPD::CSeason::TSeason const& season) const = 0;
1062         virtual AITYPES::CPropertySet& properties() = 0;
1063         virtual AITYPES::CPropertySet const& properties() const = 0;
1064         virtual std::string getFullName() const = 0;
1065 };
1066
1067 /// Description of a group template.
1068 template <class FamilyT>
1069 class CGroupDesc
1070 : public NLMISC::CDbgRefCount<CGroupDesc<FamilyT> >
1071 , public CAliasChild<FamilyT>
1072 , public IGroupDesc
1073 {
1074 public:
1075         CGroupDesc(FamilyT* owner, uint32 alias, std::string const& name);
1076
1077         std::string getIndexString() const;
1078
1079         CAliasCont<CBotDesc<FamilyT> >& botDescs() { return _BotDescs; }
1080         CAliasCont<CBotDesc<FamilyT> > const& botDescs() const { return _BotDescs; }
1081
1082         virtual std::string getFullName() const { return std::string(this->getOwner()->getFullName() +":"+ this->getName()); }
1083
1084         virtual bool isValidForSeason(EGSPD::CSeason::TSeason const& season) const { return     _SeasonFlags[season]; }
1085
1086         bool isValidForDayOrNight(bool const& isDay) const;
1087
1088         virtual AITYPES::CPropertySet& properties() { return _Properties; }
1089         virtual AITYPES::CPropertySet const& properties() const { return _Properties; }
1090
1091         void setSheet(AISHEETS::ICreatureCPtr const& sheetPtr);
1092
1093         bool setSheet(std::string const& sheetName);
1094
1095         AISHEETS::ICreatureCPtr sheet(sint32 baseLevel = -1) const;
1096
1097         virtual uint32 groupEnergyValue() const { return _GroupEnergyValue; }
1098
1099         uint32 calcTotalEnergyValue() const;
1100
1101         AITYPES::TSpawnType     const& spawnType() const { return _SpawnType; }
1102
1103         // Return the bot count as specified in the primitives data
1104         uint32 getBaseBotCount() const { return _BotCount; }
1105
1106         // Set the bot count as specified in the primitives data
1107         void setBaseBotCount(uint32 const& botCount) { _BotCount = botCount; }
1108
1109         // Return the 'real' bot count, ie the bot count multiplied by the creature sheet multiplier.
1110         // This is the number of bot we realy want to spawn.
1111         uint32 getRealBotCount() const;
1112
1113         void setCountMultiplierFlag(bool countMultiplier) { _CountMultiplier = countMultiplier; }
1114         virtual bool getCountMultiplierFlag() const { return _CountMultiplier; }
1115         std::vector<std::string> const& grpParameters() const { return _GrpParameters; }
1116         std::vector<std::string>& grpParameters() { return _GrpParameters; }
1117         std::vector<std::string> const& botEquipment() const { return _BotEquipment; }
1118         std::vector<std::string>& botEquipment() { return _BotEquipment; }
1119
1120         void setSeasonFlags(bool const seasonFlags[4]);
1121         void setWeightLevels(uint32 const weights[4]);
1122
1123         void setSpawnType(AITYPES::TSpawnType const& spawnType) { _SpawnType = spawnType; }
1124
1125         void setGroupEnergyCoef(float coef) { _EnergyCoef = coef; }
1126
1127         virtual float groupEnergyCoef() const { return _EnergyCoef; }
1128
1129         CGrpFauna* createFaunaGroup(CFamilyBehavior* familyBehavior) const;
1130
1131         CGroupNpc* createNpcGroup(CMgrNpc* mgr, CAIVector const& pos, double dispersionRadius = 0., sint32 baseLevel = -1, bool spawnBots = true) const;
1132
1133         virtual uint32 getWeightForEnergy(size_t levelIndex) const { return _WeightLevel[levelIndex]; }
1134
1135         std::vector<CPopulationRecord>& populationRecords() { return _PopulationRecords; }
1136
1137         // Don't really like this but have no time to do it on a member.
1138         sint getNbUse() const;
1139
1140         bool getGDPlayerAttackable() const { return _PlayerAttackable; };
1141         void setGDPlayerAttackable(bool playerAttackable) const { _PlayerAttackable = playerAttackable; }
1142
1143         bool getGDBotAttackable() const { return _BotAttackable; };
1144         void setGDBotAttackable(bool botAttackable) const { _BotAttackable = botAttackable; }
1145         void setMultiLevel(bool multiLevel) { _MultiLevel = multiLevel; }
1146         void setLevelDelta(sint32 levelDelta) { _LevelDelta = levelDelta; }
1147         sint32 getLevelDelta() const { return _LevelDelta; }
1148         bool isMultiLevel() const { return _MultiLevel; }
1149
1150 private:
1151         /// @name AI service hierarchy
1152         //@{
1153         /// Container for named bot.
1154         CAliasCont<CBotDesc<FamilyT> > _BotDescs;
1155         //@}
1156
1157         IAliasCont* getAliasCont(AITYPES::TAIType type);
1158         CAliasTreeOwner* createChild(IAliasCont* cont, CAIAliasDescriptionNode* aliasTree);
1159
1160         /// The number of bot (for unamed bots)
1161         uint32 _BotCount;
1162         // If true, the _BotCount is multiplied by the quantity specified in the creature sheet.
1163         bool _CountMultiplier;
1164
1165         // If the group is multilevel it has 20 sheets, else only one
1166         static size_t const _MultiLevelSheetCount;
1167         bool _MultiLevel;
1168         AISHEETS::ICreatureCPtr _Sheet;
1169         std::vector<AISHEETS::ICreatureCPtr> _MultiLevelSheets;
1170         sint32 _LevelDelta;
1171
1172         /// The raw groups parameters
1173         std::vector<std::string> _GrpParameters;
1174         /// The raw bot equipment.
1175         std::vector<std::string> _BotEquipment;
1176         /// The season flags
1177         bool _SeasonFlags[4];
1178
1179         uint32 _WeightLevel[4];
1180
1181         /// The energy value of the group
1182         uint32 _GroupEnergyValue;
1183
1184         /// Activity flags (for npcs)
1185         AITYPES::CPropertySet _Properties;
1186
1187         /// Spawn type (for fauna)
1188         AITYPES::TSpawnType _SpawnType;
1189         // Energy Coef for bot of this group.
1190         float _EnergyCoef;
1191
1192         std::vector<CPopulationRecord> _PopulationRecords;
1193
1194         /** Flag to set the group attackable by players.
1195          *      NB : this flag is set from the family code, not from the
1196          *      primitives datas
1197          */
1198         mutable bool _PlayerAttackable;
1199         // Flag to set the group attackable by other npcs
1200         mutable bool _BotAttackable;
1201 };
1202
1203 //////////////////////////////////////////////////////////////////////////////
1204 // CBotDesc                                                                 //
1205 //////////////////////////////////////////////////////////////////////////////
1206
1207 class IBotDesc {
1208 };
1209
1210 /// Description of a bot
1211 template <class FamilyT>
1212 class CBotDesc
1213 : public CAliasChild<CGroupDesc<FamilyT> >
1214 , public NLMISC::CRefCount
1215 , public IBotDesc
1216 {
1217 public:
1218         CBotDesc(CGroupDesc<FamilyT>* owner, uint32 alias, std::string const& name);
1219
1220         std::string getIndexString() const;
1221
1222         void setSheet(AISHEETS::ICreatureCPtr const& sheetPtr)
1223         {
1224         #ifdef NL_DEBUG
1225                 nlassert(sheetPtr);
1226         #endif
1227                 _Sheet = sheetPtr;
1228         }
1229
1230         void setSheet(std::string const& sheetName);
1231
1232         AISHEETS::ICreatureCPtr sheet(sint32 baseLevel = -1) const;
1233
1234         std::vector<std::string>& equipement() { return _Equipment; }
1235
1236         uint32 energyValue() const;
1237         void setMultiLevel(bool multiLevel) { _MultiLevel = multiLevel; }
1238         void setLevelDelta(sint32 levelDelta) { _LevelDelta = levelDelta; }
1239         sint32 getLevelDelta() const { return _LevelDelta; }
1240         void setUseSheetBotName(bool useSheetBotName) { _UseSheetBotName = useSheetBotName; }
1241
1242         std::string const& getBotName() const;
1243
1244 private:
1245         /// Raw equipement
1246         std::vector<std::string> _Equipment;
1247         // If the bot is multilevel it has 20 sheets, else only one
1248         static size_t const _MultiLevelSheetCount;
1249         bool _MultiLevel;
1250         AISHEETS::ICreatureCPtr _Sheet;
1251         std::vector<AISHEETS::ICreatureCPtr> _MultiLevelSheets;
1252         sint32 _LevelDelta;
1253         bool _UseSheetBotName;
1254 };
1255
1256 //////////////////////////////////////////////////////////////////////////////
1257 // Free functions                                                           //
1258 //////////////////////////////////////////////////////////////////////////////
1259
1260 bool pathFind(const     CNpcZone        *const  start, const    CNpcZone        *const  end, const      AITYPES::CPropertySet   &zoneFilter, std::vector<NLMISC::CSmartPtr<CRoad> > &path, bool logError=true);
1261
1262 #endif // CONTINENT_H
1263