[Terrain] Suppress ADT liquid inside WMO interior groups (#313)

FusedTerrain::ColumnAt added tile (ADT) liquid unconditionally, and
getLiquidStatus always took the column's highest liquid surface. In
Vashj'ir, L'ghorek's air-pocket interior sits ~700yd under the ocean
surface, so that outside water always won and bots inside the dome
were reported UNDER_WATER despite standing in a dry interior.

No code in the liquid path consulted MOGP interior flags. Tag ADT
liquid surfaces (Column::Surface::fromAdt, set via
FusedTerrain.cpp's AddLiquid(*adt, true) call), add
Column::HighestLiquid(bool includeAdt) and Column::HasStatic(), and
in getLiquidStatus: when the winning surface is ADT-sourced and the
column also has a baked model, raycast for the group's mogpFlags via
GetAreaInfo and drop the ADT surface if the interior bit (0x2000) is
set, falling back to whatever liquid the WMO itself carries.

Zero extra cost outside a WMO footprint (HasStatic() false). Server
side only, no re-bake needed -- interior flags are already baked.

Author: r-log

src/game/WorldHandlers/GridMap.cpp

@@ -82,6 +82,11 @@ namespace
     const uint32 LIQUID_OUTLAND_OCEAN_ROW = 15;
     const uint32 LIQUID_FIRST_OVERRIDABLE_ROW = 21;
 
+    // MOGP group flag: the group is an interior. Outside (ADT) liquid must not
+    // reach a point inside one -- Vashj'ir's L'ghorek air pocket, a dry hold
+    // under the sea -- only liquid the WMO itself carries counts there.
+    const uint32 MOGP_FLAG_INTERIOR = 0x2000;
+
     // LiquidType.dbc SoundBank is the family the client uses (0 water .. 3 slime), and
     // MAP_LIQUID_TYPE_* is one bit per family in that order. The DBC is the authority:
     // the tile carries the row id, never a pre-chewed category.
@@ -352,11 +357,28 @@ GridMapLiquidStatus TerrainInfo::getLiquidStatus(float x, float y, float z,
     const world::terrain::Column column =
         ColumnAt(x, y, z + FLOOR_BURIED_LIFT, z - FLOOR_SEARCH_DOWN);
 
-    const auto liquid = column.HighestLiquid();
+    auto liquid = column.HighestLiquid();
     if (!liquid || !liquid->liquidEntry)
     {
         return LIQUID_MAP_NO_WATER;
     }
+
+    // Tile liquid is the OUTSIDE water. When the point sits inside a WMO
+    // interior group, drop it and keep only what the model itself carries.
+    if (liquid->fromAdt && column.HasStatic())
+    {
+        uint32 mogpFlags = 0;
+        int32 adtId = 0, rootId = 0, groupId = 0;
+        if (GetAreaInfo(x, y, z, mogpFlags, adtId, rootId, groupId) &&
+            (mogpFlags & MOGP_FLAG_INTERIOR))
+        {
+            liquid = column.HighestLiquid(false);
+            if (!liquid || !liquid->liquidEntry)
+            {
+                return LIQUID_MAP_NO_WATER;
+            }
+        }
+    }
     const LiquidInfo info = liquid->AsLiquid();
 
     uint32 entry = info.entry;

src/shared/terrain/Column.hpp

@@ -29,6 +29,7 @@ namespace world::terrain
         LiquidKind liquid = LiquidKind::None;
         uint16_t liquidEntry = 0;
         bool deep = false;
+        bool fromAdt = false;  ///< tile (ADT) liquid, not carried by a model
 
         bool Solid() const { return kind != SurfaceKind::Liquid; }
 
@@ -54,14 +55,15 @@ namespace world::terrain
                 m_surfaces.push_back(s);
             }
 
-            void AddLiquid(const LiquidInfo& info)
+            void AddLiquid(const LiquidInfo& info, bool fromAdt = false)
             {
                 Surface s;
                 s.z = info.level;
                 s.kind = SurfaceKind::Liquid;
                 s.liquid = info.kind;
                 s.liquidEntry = info.entry;
                 s.deep = info.deep;
+                s.fromAdt = fromAdt;
                 m_surfaces.push_back(s);
             }
 
@@ -118,19 +120,34 @@ namespace world::terrain
                 return LowestSolidAbove(z + tolerance);
             }
 
-            std::optional<Surface> HighestLiquid() const
+            std::optional<Surface> HighestLiquid(bool includeAdt = true) const
             {
                 std::optional<Surface> best;
                 for (const Surface& s : m_surfaces)
                 {
-                    if (s.kind == SurfaceKind::Liquid && (!best || s.z > best->z))
+                    if (s.kind == SurfaceKind::Liquid &&
+                        (includeAdt || !s.fromAdt) && (!best || s.z > best->z))
                     {
                         best = s;
                     }
                 }
                 return best;
             }
 
+            /// Whether any baked model surface lies in the sweep -- the cheap
+            /// pre-test for "could this point be inside a WMO at all".
+            bool HasStatic() const
+            {
+                for (const Surface& s : m_surfaces)
+                {
+                    if (s.kind == SurfaceKind::Static)
+                    {
+                        return true;
+                    }
+                }
+                return false;
+            }
+
         private:
             std::vector<Surface> m_surfaces;
     };

src/shared/terrain/FusedTerrain.cpp

@@ -345,7 +345,7 @@ namespace world::terrain
         {
             if (auto adt = tile->LiquidAt(x, y))
             {
-                column.AddLiquid(*adt);
+                column.AddLiquid(*adt, true);
             }
         }