Immersive.SharedQuestMoneyPercent (All your alts get a percent of max…

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "src/modules/Bots"]
+	path = src/modules/Bots
+	url = https://github.com/celguar/mangosbot-bots.git

CMakeLists.txt

@@ -327,6 +327,21 @@ if(NOT BUILD_GAME_SERVER AND BUILD_PLAYERBOT)
   message(STATUS "BUILD_PLAYERBOT forced to OFF due to BUILD_GAME_SERVER is not set")
 endif()
 
+if(NOT BUILD_GAME_SERVER AND BUILD_IKE3_BOTS)
+  set(BUILD_IKE3_BOTS OFF)
+  message(STATUS "BUILD_PLAYERBOTS forced to OFF due to BUILD_GAME_SERVER is not set")
+endif()
+
+if(BUILD_IKE3_BOTS)
+  set(BUILD_PLAYERBOT OFF)
+  message(STATUS "CMaNGOS bots DISABLED because Ike3 bots enabled")
+endif()
+
+if(BUILD_PLAYERBOT)
+  set(BUILD_IKE3_BOTS OFF)
+  message(STATUS "Ike3 bots DISABLED because CMaNGOS bots enabled")
+endif()
+
 if(PCH)
   if(${CMAKE_VERSION} VERSION_LESS "3.16") 
     message("PCH is not supported by your CMake version")

cmake/options.cmake

@@ -7,6 +7,8 @@ option(BUILD_LOGIN_SERVER   "Build login server"                    ON)
 option(BUILD_EXTRACTORS     "Build map/dbc/vmap/mmap extractors"    OFF)
 option(BUILD_SCRIPTDEV      "Build ScriptDev. (OFF Speedup build)"  ON)
 option(BUILD_PLAYERBOT      "Build Playerbot mod"                   OFF)
+option(BUILD_IKE3_BOTS      "Build ike3 Playerbots"                 OFF)
+option(BUILD_ACHIEVEMENTS   "Build Achievements"              OFF)
 option(BUILD_AHBOT          "Build Auction House Bot mod"           OFF)
 option(BUILD_METRICS        "Build Metrics, generate data for Grafana" OFF)
 option(BUILD_RECASTDEMOMOD  "Build map/vmap/mmap viewer"            OFF)
@@ -35,6 +37,8 @@ message(STATUS
     BUILD_EXTRACTORS        Build map/dbc/vmap/mmap extractor
     BUILD_SCRIPTDEV         Build scriptdev. (Disable it to speedup build in dev mode by not including scripts)
     BUILD_PLAYERBOT         Build Playerbot mod
+    BUILD_IKE3_BOTS         Build Ike3 Playerbot mod
+    BUILD_ACHIEVEMENTS      Build Achievements System
     BUILD_AHBOT             Build Auction House Bot mod
     BUILD_METRICS           Build Metrics, generate data for Grafana
     BUILD_RECASTDEMOMOD     Build map/vmap/mmap viewer

cmake/showoptions.cmake

@@ -67,6 +67,12 @@ else()
   message(STATUS "Build Playerbot       : No  (default)")
 endif()
 
+if(BUILD_IKE3_BOTS)
+  message(STATUS "Build ike3 Playerbots : Yes")
+else()
+  message(STATUS "Build ike3 Playerbots : No  (default)")
+endif()
+
 if(BUILD_EXTRACTORS)
   message(STATUS "Build extractors      : Yes")
 else()

contrib/mmap/src/MapBuilder.cpp

@@ -288,7 +288,7 @@ namespace MMAP
         rcCalcGridSize(config.bmin, config.bmax, config.cs, &config.width, &config.height);
 
         Tile tile;
-        buildCommonTile(modelName.data(), tile, config, tVerts, tVertCount, tTris, tTriCount, nullptr, 0, nullptr, 0, 0);
+        buildCommonTile(modelName.data(), tile, config, tVerts, tVertCount, tTris, tTriCount, nullptr, 0, nullptr, 0, 0, meshData);
 
         IntermediateValues iv;
         iv.polyMesh = tile.pmesh;
@@ -484,8 +484,16 @@ namespace MMAP
 
         // make sure we process maps which don't have tiles
         // initialize the static tree, which loads WDT models
-        if (!m_terrainBuilder->loadVMap(mapID, 64, 64, meshData))
+        IVMapManager* vmapManager = new VMapManager2();
+        if (!m_terrainBuilder->loadVMap(mapID, 64, 64, meshData, vmapManager))
+        {
+            vmapManager->unloadMap(mapID, 64, 64);
+            delete vmapManager;
             return;
+        }
+
+        vmapManager->unloadMap(mapID, 64, 64);
+        delete vmapManager;
 
         // get the coord bounds of the model data
         if (meshData.solidVerts.size() + meshData.liquidVerts.size() == 0)
@@ -601,6 +609,92 @@ namespace MMAP
         dtFreeNavMesh(navMesh);
     }
 
+    static void calcTriNormal(const float* v0, const float* v1, const float* v2, float* norm)
+    {
+        float e0[3], e1[3];
+        rcVsub(e0, v1, v0);
+        rcVsub(e1, v2, v0);
+        rcVcross(norm, e0, e1);
+        rcVnormalize(norm);
+    }
+
+    void filterSteepSlopeTriangles(rcContext* ctx,
+        const float* verts, int nv,
+        const int* tris, int nt,
+        unsigned char* areas, MeshData& meshData, TerrainBuilder* m_terrainBuilder, VMAP::IVMapManager* vmapManager)
+    {
+        rcIgnoreUnused(ctx);
+        rcIgnoreUnused(nv);
+
+        float norm[3];
+
+        const float playerClimbLimit = cosf(50.0f / 180.0f * RC_PI);
+        const float maxClimbLimitTerrain = cosf(75.0f / 180.0f * RC_PI);
+        const float maxClimbLimitVmaps = cosf(61.0f / 180.0f * RC_PI);
+
+        uint32 terrainPolysSlope = 0;
+        uint32 terrainPolysNull = 0;
+        uint32 nonTerrainPolysSlope = 0;
+        uint32 nonTerrainPolysNull = 0;
+        uint32 undermapPolys = 0;
+
+        for (int i = 0; i < nt; ++i)
+        {
+            if (areas[i] & RC_WALKABLE_AREA)
+            {
+                const int* tri = &tris[i * 3];
+                calcTriNormal(&verts[tri[0] * 3], &verts[tri[1] * 3], &verts[tri[2] * 3], norm);
+
+                bool terrain = meshData.IsTerrainTriangle(i);
+                // Check if the face is walkable: different angle for different type of triangle
+                // NPCs, charges, ... can climb up to the HardLimit
+                // blinks, randomPosGenerator ... can climb up to playerClimbLimit
+                // With playerClimbLimit < HardLimit
+                float climbHardLimit = terrain ? maxClimbLimitTerrain : maxClimbLimitVmaps;
+
+                if (norm[1] <= playerClimbLimit)
+                {
+                    areas[i] = NAV_AREA_GROUND_STEEP;
+                    if (terrain)
+                        terrainPolysSlope++;
+                    else
+                        nonTerrainPolysSlope++;
+                }
+                if (norm[1] <= climbHardLimit)
+                {
+                    areas[i] = RC_NULL_AREA;
+                    if (terrain)
+                        terrainPolysNull++;
+                    else
+                        nonTerrainPolysNull++;
+                }
+
+                // Now we remove underterrain triangles (actually set flags to 0)
+                // This prevents selecting wrong poly for a player in the server later.
+                if (vmapManager && !terrain && areas[i])
+                {
+                    // Get triangle corners (as usual, yzx positions)
+                    // (actually we push these corners towards the center a bit to prevent collision with border models etc...)
+                    float cVerts[9];
+                    for (int c = 0; c < 3; ++c) // Corner
+                        for (int v = 0; v < 3; ++v) // Coordinate
+                            cVerts[3 * c + v] = (5 * verts[tri[c] * 3 + v] + verts[tri[(c + 1) % 3] * 3 + v] + verts[tri[(c + 2) % 3] * 3 + v]) / 7;
+
+                    // A triangle is undermap if all corners are undermap
+                    if (m_terrainBuilder->IsUnderMap(&cVerts[0], vmapManager) && m_terrainBuilder->IsUnderMap(&cVerts[3], vmapManager) && m_terrainBuilder->IsUnderMap(&cVerts[6], vmapManager))
+                    {
+                        areas[i] = RC_NULL_AREA;
+                        undermapPolys++;
+                        continue;
+                    }
+                }
+            }
+        }
+        //printf("Slopes filtered: terrain: %u vmaps: %u     \n", terrainPolysSlope, nonTerrainPolysSlope);
+        //printf("Unwalkable filtered: terrain: %u vmaps: %u     \n", terrainPolysNull, nonTerrainPolysNull);
+        //printf("Undermap polygons filtered: %u     \n", undermapPolys);
+    }
+
     /**************************************************************************/
     void MapBuilder::buildTile(uint32 mapID, uint32 tileX, uint32 tileY, dtNavMesh* navMesh, uint32 curTile, uint32 tileCount)
     {
@@ -612,11 +706,16 @@ namespace MMAP
         m_terrainBuilder->loadMap(mapID, tileX, tileY, meshData);
 
         // get model data
-        m_terrainBuilder->loadVMap(mapID, tileY, tileX, meshData);
+        IVMapManager* vmapManager = new VMapManager2();
+        m_terrainBuilder->loadVMap(mapID, tileY, tileX, meshData, vmapManager);
 
         // if there is no data, give up now
         if (!meshData.solidVerts.size() && !meshData.liquidVerts.size())
+        {
+            vmapManager->unloadMap(mapID, tileX, tileY);
+            delete vmapManager;
             return;
+        }
 
         // remove unused vertices
         TerrainBuilder::cleanVertices(meshData.solidVerts, meshData.solidTris);
@@ -637,7 +736,11 @@ namespace MMAP
         m_terrainBuilder->loadOffMeshConnections(mapID, tileX, tileY, meshData, m_offMeshFilePath);
 
         // build navmesh tile
-        buildMoveMapTile(mapID, tileX, tileY, meshData, bmin, bmax, navMesh);
+        buildMoveMapTile(mapID, tileX, tileY, meshData, bmin, bmax, navMesh, vmapManager);
+
+        // clean up
+        vmapManager->unloadMap(mapID, tileX, tileY);
+        delete vmapManager;
     }
 
     /**************************************************************************/
@@ -720,7 +823,7 @@ namespace MMAP
     /**************************************************************************/
     void MapBuilder::buildMoveMapTile(uint32 mapID, uint32 tileX, uint32 tileY,
                                       MeshData& meshData, float bmin[3], float bmax[3],
-                                      dtNavMesh* navMesh)
+                                      dtNavMesh* navMesh, IVMapManager* vmapManager)
     {
         // console output
         char tileString[20];
@@ -747,6 +850,18 @@ namespace MMAP
         rcVcopy(config.bmin, bmin);
         rcVcopy(config.bmax, bmax);
 
+        /*printf("Parameters:                  \n");
+        printf("ch: %f                       \n", config.ch);
+        printf("cs: %f                       \n", config.cs);
+        printf("walkableHeight: %u           \n", config.walkableHeight);
+        printf("walkableClimb: %u            \n", config.walkableClimb);
+        printf("walkableRadius: %u           \n", config.walkableRadius);
+        printf("walkableSlopeAngle: %f       \n", config.walkableSlopeAngle);
+        printf("maxEdgeLen: %u               \n", config.maxEdgeLen);
+        printf("borderSize: %u               \n", config.borderSize);
+        printf("detailSampleDist: %f         \n", config.detailSampleDist);
+        printf("detailSampleMaxError: %f     \n", config.detailSampleMaxError);*/
+
         // this sets the dimensions of the heightfield - should maybe happen before border padding
         rcCalcGridSize(config.bmin, config.bmax, config.cs, &config.width, &config.height);
 
@@ -777,7 +892,7 @@ namespace MMAP
                 tileCfg.bmax[0] += tileCfg.borderSize * tileCfg.cs;
                 tileCfg.bmax[2] += tileCfg.borderSize * tileCfg.cs;
 
-                buildCommonTile(tileString, tile, tileCfg, tVerts, tVertCount, tTris, tTriCount, lVerts, lVertCount, lTris, lTriCount, lTriFlags);
+                buildCommonTile(tileString, tile, tileCfg, tVerts, tVertCount, tTris, tTriCount, lVerts, lVertCount, lTris, lTriCount, lTriFlags, meshData, vmapManager);
             }
         }
 
@@ -833,10 +948,26 @@ namespace MMAP
         {
             if (uint8 area = iv.polyMesh->areas[i] & NAV_AREA_ALL_MASK)
             {
-                if (area >= NAV_AREA_MIN_VALUE)
-                    iv.polyMesh->flags[i] = 1 << (NAV_AREA_MAX_VALUE - area);
-                else
-                    iv.polyMesh->flags[i] = NAV_GROUND; // TODO: these will be dynamic in future
+                switch (area)
+                {
+                case NAV_AREA_EMPTY:
+                    break;
+                case NAV_AREA_GROUND:
+                    iv.polyMesh->flags[i] |= NAV_GROUND;
+                    break;
+                case NAV_AREA_GROUND_STEEP:
+                    iv.polyMesh->flags[i] |= (NAV_GROUND | NAV_GROUND_STEEP);
+                    break;
+                case NAV_AREA_WATER:
+                    iv.polyMesh->flags[i] |= NAV_WATER;
+                    break;
+                case NAV_AREA_MAGMA_SLIME:
+                    iv.polyMesh->flags[i] |= NAV_MAGMA_SLIME;
+                    break;
+                default:
+                    iv.polyMesh->flags[i] |= NAV_GROUND; // TODO: these will be dynamic in future
+                    break;
+                }
             }
         }
 
@@ -950,7 +1081,7 @@ namespace MMAP
                 continue;
             }
 
-            printf("%s Writing to file...                                 \r", tileString);
+            printf("%s Writing to file...                                 \n", tileString);
 
             // write header
             MmapTileHeader header;
@@ -983,7 +1114,7 @@ namespace MMAP
     }
 
     bool MapBuilder::buildCommonTile(const char* tileString, Tile& tile, rcConfig& tileCfg, float* tVerts, int tVertCount, int* tTris, int tTriCount, float* lVerts, int lVertCount,
-                                     int* lTris, int lTriCount, uint8* lTriFlags)
+                                     int* lTris, int lTriCount, uint8* lTriFlags, MeshData& meshData, IVMapManager* vmapManager)
     {
         // Build heightfield for walkable area
         tile.solid = rcAllocHeightfield();
@@ -997,6 +1128,7 @@ namespace MMAP
         unsigned char* triFlags = new unsigned char[tTriCount];
         memset(triFlags, NAV_AREA_GROUND, tTriCount * sizeof(unsigned char));
         rcClearUnwalkableTriangles(m_rcContext, tileCfg.walkableSlopeAngle, tVerts, tVertCount, tTris, tTriCount, triFlags);
+        filterSteepSlopeTriangles(m_rcContext, tVerts, tVertCount, tTris, tTriCount, triFlags, meshData, m_terrainBuilder, vmapManager);
         rcRasterizeTriangles(m_rcContext, tVerts, tVertCount, tTris, triFlags, tTriCount, *tile.solid, tileCfg.walkableClimb);
         delete[] triFlags;
 
@@ -1185,7 +1317,7 @@ namespace MMAP
             {"walkableClimb", 4},
             {"walkableHeight", 6},
             {"walkableRadius", 2},
-            {"walkableSlopeAngle", 60.0f},
+            {"walkableSlopeAngle", 75.0f},
             {"liquidFlagMergeThreshold", 0.0f},
         };
     }

contrib/mmap/src/MapBuilder.h

@@ -118,10 +118,10 @@ namespace MMAP
 
             void buildTile(uint32 mapID, uint32 tileX, uint32 tileY, dtNavMesh* navMesh, uint32 curTile, uint32 tileCount);
             bool buildCommonTile(const char* tileString, Tile& tile, rcConfig& tileCfg, float* tVerts, int tVertCount, int* tTris, int tTriCount, float* lVerts, int lVertCount,
-                                 int* lTris, int lTriCount, uint8* lTriFlags);
+                                 int* lTris, int lTriCount, uint8* lTriFlags, MeshData& meshData, IVMapManager* vmapManager = nullptr);
 
             // move map building
-            void buildMoveMapTile(uint32 mapID, uint32 tileX, uint32 tileY, MeshData& meshData, float bmin[3], float bmax[3], dtNavMesh* navMesh);
+            void buildMoveMapTile(uint32 mapID, uint32 tileX, uint32 tileY, MeshData& meshData, float bmin[3], float bmax[3], dtNavMesh* navMesh, IVMapManager* vmapManager);
             void getTileBounds(uint32 tileX, uint32 tileY, float* verts, int vertCount, float* bmin, float* bmax);
             void getGridBounds(uint32 mapID, uint32& minX, uint32& minY, uint32& maxX, uint32& maxY);