diff --git a/docs/api/cpp/game_state.md b/docs/api/cpp/game_state.md
index df0b5a84c..a698a2558 100644
--- a/docs/api/cpp/game_state.md
+++ b/docs/api/cpp/game_state.md
@@ -72,7 +72,8 @@ Description of the object in the labels buffer.
 
 **objectName / object_name** - ingame object name, many different objects can have the same name (e.g. Medikit, Clip, Zombie).
 
-**objectCategory / object_category** - category of the object (e.g. "Monster", "Weapon", "Player"). Category "Self" is assigned to current player.
+**objectCategory / object_category** - category of the object (e.g. "Monster", "Weapon", "Player"). Category "Self" is assigned to current player. 
+The category assigment may not be accurate, especcialy for custom objects and WADs other than Freedoom/Doom. Note: added in 1.3.0.
 
 **value** - value that represents this particular object in **labelsBuffer**.
 
@@ -89,7 +90,9 @@ See also:
 (`C++ type / Python type` **name**)
 
 - `unsigned int / int` **id**
+- `int / int` **sectorId / sector_id**
 - `std::string / str` **name**
+- `std::string / str` **category**
 - `double / float` **positionX / position_x**
 - `double / float` **positionY / position_y**
 - `double / float` **positionZ / position_z**
@@ -102,12 +105,17 @@ See also:
 
 Description of the object present in the game world.
 
-**id** - unique object ID.
+**id** - unique object ID. This is the value referenced by **Label.objectId / object_id**.
 
 **name** - ingame object name, many different objects can have the same name (e.g. Medikit, Clip, Zombie).
 
+**category** - category of the object (e.g. "Monster", "Weapon", "Player"). Category "Self" is assigned to current player.
+The category assigment may not be accurate, especcialy for custom objects and WADs other than Freedoom/Doom. Note: added in 1.3.1.
+
+**sectorId / sector_id** - ID of the sector the object currently belongs to (same as corresponding **Sector.id**). Note: added in 1.3.1.
+
 See also:
-- [`DoomGame::setObjectsInfoEnabled`](./doom_game.md#setsectorsinfoenabled),
+- [`DoomGame::setObjectsInfoEnabled`](./doom_game.md#setobjectsinfoenabled),
 - [examples/python/objects_and_sectors.py](https://github.com/Farama-Foundation/ViZDoom/tree/master/examples/python/objects_and_sectors.py).
 
 Note: added in 1.1.8.
@@ -141,12 +149,15 @@ Note: added in 1.1.8.
 ### `Sector`
 (`C++ type / Python type` **name**)
 
-- `double / float` **floorHeight / floor_height**
+- `unsigned int / int` **id**
+- `double / float` **floorHeight / floor_height** - Note: before 1.3.1 the value of floorHeight was inverted (negative). The bug was fixed in 1.3.1.
 - `double / float` **ceilingHeight / ceiling_height**
-- `std::vector<Label> / list` **lines**
+- `std::vector<Line> / list` **lines**
 
 Description of the sector, part of the map with the same floor and ceiling height.
 
+**id** - unique sector ID. This is the value referenced by **Object.sectorId / sector_id**. Note: added in 1.3.1.
+
 **floorHeight / floor_height** - height of the sector's floor.
 
 **ceilingHeight / ceiling_height** - height of the sector's ceiling.
diff --git a/docs/api/python/game_state.md b/docs/api/python/game_state.md
index 38dfcf87c..518ca7893 100644
--- a/docs/api/python/game_state.md
+++ b/docs/api/python/game_state.md
@@ -48,12 +48,16 @@ See also:
    :undoc-members:
 ```
 
-**id** - unique object ID.
+**id** - unique object ID. This is the value referenced by **Label.objectId / object_id**.
 
 **name** - ingame object name, many different objects can have the same name (e.g. Medikit, Clip, Zombie).
 
+**category** - category of the object (e.g. "Monster", "Weapon", "Player"). Category "Self" is assigned to current player. Note: added in 1.3.1.
+
+**sector_id** - ID of the sector the object currently belongs to (same as corresponding **Sector.id**). Note: added in 1.3.1.
+
 See also:
-- [`DoomGame.set_objects_info_enabled`](./doom_game.md#vizdoom.DoomGame.set_sectors_info_enabled),
+- [`DoomGame.set_objects_info_enabled`](./doom_game.md#vizdoom.DoomGame.set_objects_info_enabled),
 - [examples/python/objects_and_sectors.py](https://github.com/Farama-Foundation/ViZDoom/tree/master/examples/python/objects_and_sectors.py).
 
 Note: added in 1.1.8.
@@ -83,7 +87,9 @@ Note: added in 1.1.8.
    :undoc-members:
 ```
 
-**floor_height** - height of the sector's floor.
+**id** - unique sector ID. This is the value referenced by **Object.sector_id**. Note: added in 1.3.1.
+
+**floor_height** - height of the sector's floor. Note: before 1.3.1 the value of floorHeight was inverted (negative). The bug was fixed in 1.3.1.
 
 **ceiling_height** - height of the sector's ceiling.
 
diff --git a/examples/python/README.md b/examples/python/README.md
index c43c8f79e..ee16fb616 100644
--- a/examples/python/README.md
+++ b/examples/python/README.md
@@ -84,6 +84,9 @@ Presents different scenarios that come with ViZDoom environment.
 - [seed.py](https://github.com/mwydmuch/ViZDoom/blob/master/examples/python/seed.py)
 Shows how to run deterministic episodes by setting the seed. After setting the seed every episode will look the same (if the agent behaves deterministically).
 
+- [sectors_visualization.py](https://github.com/mwydmuch/ViZDoom/blob/master/examples/python/sectors_visualization.py)
+Renders a one-shot 3D map of sectors (floor/ceiling/walls) and objects, then saves the plot.
+
 - [shaping.py](https://github.com/mwydmuch/ViZDoom/blob/master/examples/python/shaping.py)
 Demonstrates how to make use of the game variables to implement [shaping](https://en.wikipedia.org/wiki/Shaping_(psychology)) using health_guided.wad scenario.
 
diff --git a/examples/python/sectors_visualization.py b/examples/python/sectors_visualization.py
new file mode 100755
index 000000000..989ef826c
--- /dev/null
+++ b/examples/python/sectors_visualization.py
@@ -0,0 +1,209 @@
+#!/usr/bin/env python3
+
+#####################################################################
+# This script captures map sectors information once and renders a 3D
+# sector map (floor/ceiling edges and blocking walls), then exits.
+#####################################################################
+
+import os
+from argparse import ArgumentParser
+
+import matplotlib.colors as mcolors
+import matplotlib.pyplot as plt
+from matplotlib.lines import Line2D
+from mpl_toolkits.mplot3d.art3d import Poly3DCollection
+
+import vizdoom as vzd
+
+
+DEFAULT_CONFIG = os.path.join(vzd.scenarios_path, "basic.cfg")
+
+DEFAULT_OUTPUT = "sectors_3d.png"
+FLOOR_COLOR = "#2ca25f"
+CEILING_COLOR = "#ef6548"
+OBJECT_COLOR = "#3288bd"
+PLAYER_COLOR = "#ffd92f"
+
+
+def draw_sectors_3d(ax, sectors, objects):
+    """Draw floor/ceiling edges, blocking walls, and map objects."""
+    floor_heights = [s.floor_height for s in sectors]
+    min_floor = min(floor_heights)
+    max_floor = max(floor_heights)
+    norm = mcolors.Normalize(
+        vmin=min_floor, vmax=max_floor if max_floor > min_floor else min_floor + 1.0
+    )
+    colormap = plt.get_cmap("viridis")
+    xs, ys, zs = [], [], []
+
+    for sector in sectors:
+        color = colormap(norm(sector.floor_height))
+        fz = sector.floor_height
+        cz = sector.ceiling_height
+        assert cz >= fz, "Ceiling height must be greater than or equal to floor height."
+        zs.extend([fz, cz])
+
+        for line in sector.lines:
+            x = [line.x1, line.x2]
+            y = [line.y1, line.y2]
+            xs.extend(x)
+            ys.extend(y)
+
+            # Floor and ceiling are marked with fixed colors.
+            ax.plot(x, y, [fz, fz], color=FLOOR_COLOR, linewidth=1.4, alpha=0.95)
+            ax.plot(
+                x,
+                y,
+                [cz, cz],
+                color=CEILING_COLOR,
+                linewidth=1.2,
+                alpha=0.95,
+            )
+
+            # Draw vertical walls only for blocking edges.
+            if line.is_blocking:
+                wall = [
+                    (line.x1, line.y1, fz),
+                    (line.x2, line.y2, fz),
+                    (line.x2, line.y2, cz),
+                    (line.x1, line.y1, cz),
+                ]
+                ax.add_collection3d(
+                    Poly3DCollection(
+                        [wall],
+                        facecolors=[color],
+                        edgecolors=[color],
+                        linewidths=0.3,
+                        alpha=0.22,
+                    )
+                )
+
+    for obj in objects:
+        is_player = obj.name == "DoomPlayer"
+        marker_color = PLAYER_COLOR if is_player else OBJECT_COLOR
+        marker_size = 45 if is_player else 20
+        x, y, z = obj.position_x, obj.position_y, obj.position_z
+        xs.append(x)
+        ys.append(y)
+        zs.append(z)
+        ax.scatter(
+            [x],
+            [y],
+            [z],
+            color=marker_color,
+            s=marker_size,
+            edgecolors="black",
+            linewidths=0.3,
+            alpha=0.95,
+        )
+
+    ax.set_title("ViZDoom sectors 3D map")
+    ax.set_xlabel("X")
+    ax.set_ylabel("Y")
+    ax.set_zlabel("Z")
+    ax.grid(alpha=0.2)
+    ax.view_init(elev=35, azim=-60)
+    if xs and ys and zs:
+        x_min, x_max = min(xs), max(xs)
+        y_min, y_max = min(ys), max(ys)
+        z_min, z_max = min(zs), max(zs)
+        max_range = max(x_max - x_min, y_max - y_min, z_max - z_min, 1.0)
+        half = max_range / 2.0
+        x_center = (x_min + x_max) / 2.0
+        y_center = (y_min + y_max) / 2.0
+        z_center = (z_min + z_max) / 2.0
+        ax.set_xlim(x_center - half, x_center + half)
+        ax.set_ylim(y_center - half, y_center + half)
+        ax.set_zlim(z_center - half, z_center + half)
+        ax.set_box_aspect((1.0, 1.0, 1.0))
+    ax.legend(
+        handles=[
+            Line2D([0], [0], color=FLOOR_COLOR, lw=2, label="Floor"),
+            Line2D([0], [0], color=CEILING_COLOR, lw=2, label="Ceiling"),
+            Line2D(
+                [0],
+                [0],
+                marker="o",
+                color="w",
+                markerfacecolor=OBJECT_COLOR,
+                markeredgecolor="black",
+                markersize=7,
+                label="Object",
+            ),
+            Line2D(
+                [0],
+                [0],
+                marker="o",
+                color="w",
+                markerfacecolor=PLAYER_COLOR,
+                markeredgecolor="black",
+                markersize=8,
+                label="Player",
+            ),
+        ],
+        loc="upper right",
+    )
+
+
+if __name__ == "__main__":
+    parser = ArgumentParser(
+        "ViZDoom example showing how to render sectors information as a 3D map."
+    )
+    parser.add_argument(
+        dest="config",
+        default=DEFAULT_CONFIG,
+        nargs="?",
+        help="Path to the configuration file of the scenario."
+        " Please see "
+        "../../scenarios/*cfg for more scenarios.",
+    )
+    parser.add_argument(
+        "--output",
+        default=DEFAULT_OUTPUT,
+        help="Output image path.",
+    )
+    args = parser.parse_args()
+
+    game = vzd.DoomGame()
+    game.load_config(args.config)
+    game.set_window_visible(False)
+    game.set_render_hud(False)
+    game.set_sectors_info_enabled(True)
+    game.set_objects_info_enabled(True)
+
+    game.clear_available_game_variables()
+    game.add_available_game_variable(vzd.GameVariable.POSITION_X)
+    game.add_available_game_variable(vzd.GameVariable.POSITION_Y)
+
+    game.init()
+    game.new_episode()
+    state = game.get_state()
+    if state is None or state.sectors is None or len(state.sectors) == 0:
+        game.close()
+        raise RuntimeError(
+            "Sectors info is unavailable. Ensure '+viz_nocheat' is not enabled and "
+            "the scenario map defines sectors."
+        )
+    if state.objects is None:
+        game.close()
+        raise RuntimeError(
+            "Objects info is unavailable. Ensure '+viz_nocheat' is not enabled."
+        )
+
+    print("Sectors:", len(state.sectors))
+    print("Objects:", len(state.objects))
+
+    output_dir = os.path.dirname(args.output)
+    if output_dir:
+        os.makedirs(output_dir, exist_ok=True)
+
+    fig = plt.figure(figsize=(10, 8))
+    ax = fig.add_subplot(111, projection="3d")
+    draw_sectors_3d(ax, state.sectors, state.objects)
+    fig.tight_layout()
+    fig.savefig(args.output, dpi=180)
+    print("Saved plot:", args.output)
+
+    plt.close(fig)
+
+    game.close()
diff --git a/include/ViZDoomTypes.h b/include/ViZDoomTypes.h
index c5f442373..42a8a3543 100644
--- a/include/ViZDoomTypes.h
+++ b/include/ViZDoomTypes.h
@@ -73,6 +73,7 @@ namespace vizdoom{
     struct Object {
         // Actor properties
         unsigned int id;
+        int sectorId;
 
         double positionX;
         double positionY;
@@ -87,6 +88,7 @@ namespace vizdoom{
         double velocityZ;
 
         std::string name;
+        std::string category;
     };
 
     struct Line{
@@ -98,6 +100,7 @@ namespace vizdoom{
     };
 
     struct Sector{
+        unsigned int id;
         double floorHeight;
         double ceilingHeight;
         std::vector<Line> lines;
diff --git a/src/lib/ViZDoomGame.cpp b/src/lib/ViZDoomGame.cpp
index 3675c3645..d085dd5a4 100644
--- a/src/lib/ViZDoomGame.cpp
+++ b/src/lib/ViZDoomGame.cpp
@@ -382,6 +382,7 @@ namespace vizdoom {
                     this->state->objects.emplace_back();
                     std::memcpy(&this->state->objects.back().id, &smState->OBJECT[i].id, objectPartSize);
                     this->state->objects.back().name = std::string(smState->OBJECT[i].name);
+                    this->state->objects.back().category = std::string(smState->OBJECT[i].category);
                 }
             }
             
@@ -391,6 +392,7 @@ namespace vizdoom {
             if(this->doomController->isSectorsEnabled()){
                 for (unsigned int i = 0; i < smState->SECTOR_COUNT; ++i) {
                     this->state->sectors.emplace_back();
+                    this->state->sectors.back().id = smState->SECTOR[i].id;
                     this->state->sectors.back().ceilingHeight = smState->SECTOR[i].ceilingHeight;
                     this->state->sectors.back().floorHeight = smState->SECTOR[i].floorHeight;
                     for (unsigned int j = 0; j < smState->SECTOR[i].lineCount; ++j) {
diff --git a/src/lib/ViZDoomSharedMemory.h b/src/lib/ViZDoomSharedMemory.h
index 0a9612ef5..c806690fd 100644
--- a/src/lib/ViZDoomSharedMemory.h
+++ b/src/lib/ViZDoomSharedMemory.h
@@ -80,11 +80,14 @@ namespace vizdoom {
 
     struct SMObject {
         unsigned int id;
+        int sectorId;
         double position[9];
+        char category[MAX_NAME_LENGTH];
         char name[MAX_NAME_LENGTH];
     };
 
     struct SMSector{
+        unsigned int id;
         double floorHeight;
         double ceilingHeight;
         unsigned int lineCount;
diff --git a/src/lib_python/ViZDoomGamePython.cpp b/src/lib_python/ViZDoomGamePython.cpp
index e36f20933..ec796086b 100644
--- a/src/lib_python/ViZDoomGamePython.cpp
+++ b/src/lib_python/ViZDoomGamePython.cpp
@@ -118,6 +118,7 @@ namespace vizdoom {
             pyb::list pySectors;
             for (auto& sector : this->state->sectors){
                 SectorPython pySector;
+                pySector.id = sector.id;
                 pySector.floorHeight = sector.floorHeight;
                 pySector.ceilingHeight = sector.ceilingHeight;
                 pySector.lines = DoomGamePython::vectorToPyList<Line>(sector.lines);
diff --git a/src/lib_python/ViZDoomGamePython.h b/src/lib_python/ViZDoomGamePython.h
index 8c96973b5..bd1057561 100644
--- a/src/lib_python/ViZDoomGamePython.h
+++ b/src/lib_python/ViZDoomGamePython.h
@@ -65,6 +65,7 @@ namespace vizdoom {
     };
 
     struct SectorPython {
+        unsigned int id;
         double floorHeight;
         double ceilingHeight;
         pyb::list lines;
diff --git a/src/lib_python/ViZDoomObjectsDocstrings.h b/src/lib_python/ViZDoomObjectsDocstrings.h
index 8bea69e67..27b73e6b1 100644
--- a/src/lib_python/ViZDoomObjectsDocstrings.h
+++ b/src/lib_python/ViZDoomObjectsDocstrings.h
@@ -16,7 +16,7 @@ namespace docstrings {
     const char *Sector = R"DOCSTRING(Represents sectors (floor/ceiling areas) in the game world geometry.)DOCSTRING";
     const char *Object = R"DOCSTRING(Represents objects in the game world with position and other properties.)DOCSTRING";
     const char *ServerState = R"DOCSTRING(Contains the state of the multiplayer server.)DOCSTRING";
-    const char *GameState = R"DOCSTRING(Contains the state of the game including screen buffer, game variables, and world geometry, available information depand on the configuration of the game instance.)DOCSTRING";
+    const char *GameState = R"DOCSTRING(Contains the state of the game including screen buffer, game variables, and world geometry, available information depends on the configuration of the game instance.)DOCSTRING";
     const char *DoomGame = R"DOCSTRING(DoomGame is the main object of the ViZDoom library, representing a single instance of the Doom game and providing the interface for a single agent/player to interact with the game. The object allows sending actions to the game, getting the game state, etc.)DOCSTRING";
 
 } // namespace docstrings
diff --git a/src/lib_python/ViZDoomPythonModule.cpp b/src/lib_python/ViZDoomPythonModule.cpp
index 014af0d92..730810dc3 100644
--- a/src/lib_python/ViZDoomPythonModule.cpp
+++ b/src/lib_python/ViZDoomPythonModule.cpp
@@ -448,6 +448,7 @@ PYBIND11_MODULE(vizdoom, vz){
             [](const Object& o) { // dump
                 return pyb::make_tuple(
                     o.id,
+                    o.sectorId,
                     o.positionX, 
                     o.positionY, 
                     o.positionZ,
@@ -457,13 +458,14 @@ PYBIND11_MODULE(vizdoom, vz){
                     o.velocityX,
                     o.velocityY,
                     o.velocityZ,
-                    o.name
+                    o.name,
+                    o.category
                 );
             },
             [](pyb::tuple t) { // load
                 return Object{
                     t[0].cast<unsigned int>(), 
-                    t[1].cast<double>(),
+                    t[1].cast<int>(),
                     t[2].cast<double>(),
                     t[3].cast<double>(),
                     t[4].cast<double>(),
@@ -472,11 +474,14 @@ PYBIND11_MODULE(vizdoom, vz){
                     t[7].cast<double>(),
                     t[8].cast<double>(),
                     t[9].cast<double>(),
-                    t[10].cast<std::string>()
+                    t[10].cast<double>(),
+                    t[11].cast<std::string>(),
+                    t[12].cast<std::string>()
                 };
             })
         )
         .def_readonly("id", &Object::id)
+        .def_readonly("sector_id", &Object::sectorId)
         .def_readonly("position_x", &Object::positionX)
         .def_readonly("position_y", &Object::positionY)
         .def_readonly("position_z", &Object::positionZ)
@@ -486,7 +491,8 @@ PYBIND11_MODULE(vizdoom, vz){
         .def_readonly("velocity_x", &Object::velocityX)
         .def_readonly("velocity_y", &Object::velocityY)
         .def_readonly("velocity_z", &Object::velocityZ)
-        .def_readonly("name", &Object::name);
+        .def_readonly("name", &Object::name)
+        .def_readonly("category", &Object::category);
 
     pyb::class_<Line>(vz, "Line", docstrings::Line)
         .def(pyb::pickle(
@@ -519,6 +525,7 @@ PYBIND11_MODULE(vizdoom, vz){
         .def(pyb::pickle(
             [](const SectorPython& o) { // dump
                 return pyb::make_tuple(
+                    o.id,
                     o.floorHeight, 
                     o.ceilingHeight, 
                     o.lines
@@ -526,12 +533,14 @@ PYBIND11_MODULE(vizdoom, vz){
             },
             [](pyb::tuple t) { // load
                 return SectorPython{
-                    t[0].cast<double>(), 
+                    t[0].cast<unsigned int>(), 
                     t[1].cast<double>(),
-                    t[2].cast<pyb::list>()
+                    t[2].cast<double>(),
+                    t[3].cast<pyb::list>()
                 };
             })
         )
+        .def_readonly("id", &SectorPython::id)
         .def_readonly("floor_height", &SectorPython::floorHeight)
         .def_readonly("ceiling_height", &SectorPython::ceilingHeight)
         .def_readonly("lines", &SectorPython::lines);
diff --git a/src/lib_python/vizdoom.pyi b/src/lib_python/vizdoom.pyi
index 6bcf64b38..73fdf18d0 100644
--- a/src/lib_python/vizdoom.pyi
+++ b/src/lib_python/vizdoom.pyi
@@ -2566,7 +2566,7 @@ class Mode:
 
 class Object:
     """
-    Represents objects in the game world with position and other properties.
+    Represents objects in the game world with position and other properties, including ``category`` and ``sector_id``.
     """
 
     def __getstate__(self) -> tuple: ...
@@ -2578,6 +2578,8 @@ class Object:
     @property
     def name(self) -> str: ...
     @property
+    def category(self) -> str: ...
+    @property
     def pitch(self) -> float: ...
     @property
     def position_x(self) -> float: ...
@@ -2588,6 +2590,8 @@ class Object:
     @property
     def roll(self) -> float: ...
     @property
+    def sector_id(self) -> int: ...
+    @property
     def velocity_x(self) -> float: ...
     @property
     def velocity_y(self) -> float: ...
@@ -2892,7 +2896,7 @@ class ScreenResolution:
 
 class Sector:
     """
-    Represents sectors (floor/ceiling areas) in the game world geometry.
+    Represents sectors (floor/ceiling areas) in the game world geometry. Each sector has a unique ``id``.
     """
 
     def __getstate__(self) -> tuple: ...
@@ -2902,6 +2906,8 @@ class Sector:
     @property
     def floor_height(self) -> float: ...
     @property
+    def id(self) -> int: ...
+    @property
     def lines(self) -> list: ...
 
 class ServerState:
diff --git a/src/vizdoom/src/viz_game.cpp b/src/vizdoom/src/viz_game.cpp
index b2c7f52e5..09c8eeba1 100644
--- a/src/vizdoom/src/viz_game.cpp
+++ b/src/vizdoom/src/viz_game.cpp
@@ -247,6 +247,61 @@ void VIZ_CopyActorName(AActor* actor, char* name) {
     name[VIZ_MAX_NAME_LEN - 1] = '\0';
 }
 
+static void VIZ_CopyActorInfo(AActor* actor, char* name, char* category) {
+    const PClass *actorClass = actor->GetClass();
+
+    // Handle DehackedPickup names exactly like labels extraction.
+    if (actor->IsKindOf(RUNTIME_CLASS(ADehackedPickup))) {
+        actorClass = static_cast<ADehackedPickup *>(actor)->DetermineType();
+        strncpy(name, actorClass->TypeName.GetChars(), VIZ_MAX_NAME_LEN - 1);
+        name[VIZ_MAX_NAME_LEN - 1] = '\0';
+    } else {
+        VIZ_CopyActorName(actor, name);
+    }
+
+    if (strncmp(name, "Dead", 4) == 0) {
+        strncpy(category, "Gore", VIZ_MAX_NAME_LEN);
+        category[VIZ_MAX_NAME_LEN - 1] = '\0';
+        return;
+    }
+
+    if (VIZ_PLAYER.mo == actor) {
+        strncpy(category, "Self", VIZ_MAX_NAME_LEN);
+        category[VIZ_MAX_NAME_LEN - 1] = '\0';
+        return;
+    }
+
+    PClass *currentClass = const_cast<PClass *>(actorClass);
+    while (currentClass != nullptr) {
+        std::string className = currentClass->TypeName.GetChars();
+
+        // Special case: HealthPickup is parallel to Health but is Health category.
+        if (className.compare("HealthPickup") == 0) {
+            className = "Health";
+        }
+
+        // Class could be a category (like Health for CustomMedikit and Poison).
+        if (std::find(categories.begin(), categories.end(), className) != categories.end()) {
+            strncpy(category, className.c_str(), VIZ_MAX_NAME_LEN);
+            category[VIZ_MAX_NAME_LEN - 1] = '\0';
+            return;
+        }
+
+        std::transform(className.begin(), className.end(), className.begin(), tolower);
+        auto categoryIt = classToCategory.find(className);
+        if (categoryIt != classToCategory.end()) {
+            strncpy(category, categoryIt->second.c_str(), VIZ_MAX_NAME_LEN);
+            category[VIZ_MAX_NAME_LEN - 1] = '\0';
+            return;
+        }
+
+        currentClass = currentClass->ParentClass;
+    }
+
+    strncpy(category, "Unknown", VIZ_MAX_NAME_LEN);
+    category[VIZ_MAX_NAME_LEN - 1] = '\0';
+}
+
 inline unsigned int VIZ_GetActorId(AActor* actor){
     if(actor->viz_id == -1) {
         actor->viz_id = vizUniqueObjectsCount++;
@@ -480,65 +535,9 @@ void VIZ_GameStateUpdateLabels(){
         for(auto& sprite : vizLabels->sprites){
             if(sprite.labeled && sprite.pointCount > 0){
                 VIZLabel *vizLabel = &vizGameStateSM->LABEL[labelCount++];
-                const PClass *actorClass;
-
                 vizLabel->objectId = VIZ_GetActorId(sprite.actor);
                 vizLabel->value = sprite.label;
-
-                // Handle DehackedPickup
-                if (sprite.actor->IsKindOf(RUNTIME_CLASS(ADehackedPickup))) {
-                    actorClass = static_cast<ADehackedPickup *>(sprite.actor)->DetermineType();
-                    strncpy(vizLabel->objectName, actorClass->TypeName.GetChars(), VIZ_MAX_NAME_LEN);
-                } else {
-                    actorClass = sprite.actor->GetClass();
-                    VIZ_CopyActorName(sprite.actor, vizLabel->objectName);
-                }
-
-                // Check for special cases before matching category
-                if (strncmp(vizLabel->objectName, "Dead", 4) == 0) {
-                    // Align with the behavior of VIZ_CopyActorName
-                    strncpy(vizLabel->objectCategory, "Gore", VIZ_MAX_NAME_LEN);
-                } else if (VIZ_PLAYER.mo == sprite.actor) {
-                    // Detect whether this object is current player
-                    strncpy(vizLabel->objectCategory, "Self", VIZ_MAX_NAME_LEN);
-                } else {
-                    PClass *currentClass = const_cast<PClass *>(actorClass);
-                    bool isUnknown = true;
-
-                    while (currentClass != nullptr)
-                    {
-                        // Convert to lowercase for lookup since the mapping uses casefolded names
-                        std::string className = currentClass->TypeName.GetChars();
-
-                        // Special case: HealthPickup is parallel to Health but is Health category
-                        if (className.compare("HealthPickup") == 0) {
-                            className = "Health";
-                        }
-
-                        // Class could be a category (like Health for CustomMedikit and Poison)
-                        if (std::find(categories.begin(), categories.end(), className) != categories.end()) {
-                            strncpy(vizLabel->objectCategory, className.c_str(), VIZ_MAX_NAME_LEN);
-                            isUnknown = false;
-                            break;
-                        }
-
-                        std::transform(className.begin(), className.end(), className.begin(), tolower);
-
-                        auto categoryIt = classToCategory.find(className);
-                        if (categoryIt != classToCategory.end()) {
-                            strncpy(vizLabel->objectCategory, categoryIt->second.c_str(), VIZ_MAX_NAME_LEN);
-                            vizLabel->objectCategory[VIZ_MAX_NAME_LEN-1] = '\0';  // Safe-guard against long names
-                            isUnknown = false;
-                            break;
-                        } else {
-                            currentClass = currentClass->ParentClass;
-                        }
-                    }
-
-                    if (isUnknown) {
-                        strncpy(vizLabel->objectCategory, "Unknown", VIZ_MAX_NAME_LEN);
-                    }
-                }
+                VIZ_CopyActorInfo(sprite.actor, vizLabel->objectName, vizLabel->objectCategory);
 
                 if(sprite.minX >= vizGameStateSM->SCREEN_WIDTH) sprite.minX = vizGameStateSM->SCREEN_WIDTH - 1;
                 if(sprite.minY >= vizGameStateSM->SCREEN_HEIGHT) sprite.minY = vizGameStateSM->SCREEN_HEIGHT - 1;
@@ -578,10 +577,12 @@ void VIZ_GameStateUpdateObjects(){
 
         // Handle all things in sector
         for (AActor *actor = sector->thinglist; actor != NULL; actor = actor->snext) {
+            if(objectCount >= VIZ_MAX_OBJECTS) break;
             VIZObject *vizObject = &vizGameStateSM->OBJECT[objectCount++];
 
             vizObject->id = VIZ_GetActorId(actor);
-            VIZ_CopyActorName(actor, vizObject->name);
+            VIZ_CopyActorInfo(actor, vizObject->name, vizObject->category);
+            vizObject->sectorId = actor->Sector != NULL ? static_cast<int>(actor->Sector - sectors) : -1;
             vizObject->position[0] = VIZ_FixedToDouble(actor->__pos.x);
             vizObject->position[1] = VIZ_FixedToDouble(actor->__pos.y);
             vizObject->position[2] = VIZ_FixedToDouble(actor->__pos.z);
@@ -593,8 +594,8 @@ void VIZ_GameStateUpdateObjects(){
             vizObject->position[8] = VIZ_FixedToDouble(actor->velz);
 
             VIZ_DebugMsg(4, VIZ_FUNC, "objectCount: %d, id: %d, name: %s", objectCount, vizObject->id, vizObject->name);
-            if(objectCount >= VIZ_MAX_OBJECTS) break;
         }
+        if(objectCount >= VIZ_MAX_OBJECTS) break;
     }
 
     vizGameStateSM->OBJECT_COUNT = objectCount;
@@ -636,8 +637,9 @@ void VIZ_GameStateUpdateSectors(){
         sector_t *sector = &sectors[i];
         VIZSector *vizSector = &vizGameStateSM->SECTOR[sectorCount++];
 
+        vizSector->id = i;
         vizSector->ceilingHeight = VIZ_FixedToDouble(sector->ceilingplane.d);
-        vizSector->floorHeight = VIZ_FixedToDouble(sector->floorplane.d);
+        vizSector->floorHeight = -VIZ_FixedToDouble(sector->floorplane.d);
 
         unsigned int sectorLineCount = 0;
         for(int l = 0; l < sector->linecount; ++l){
diff --git a/src/vizdoom/src/viz_game.h b/src/vizdoom/src/viz_game.h
index b86015faf..1accb7ed8 100644
--- a/src/vizdoom/src/viz_game.h
+++ b/src/vizdoom/src/viz_game.h
@@ -97,11 +97,14 @@ struct VIZLabel{
 
 struct VIZObject{
     unsigned int id;
+    int sectorId;
     double position[9];
+    char category[VIZ_MAX_NAME_LEN];
     char name[VIZ_MAX_NAME_LEN];
 };
 
 struct VIZSector{
+    unsigned int id;
     double floorHeight;
     double ceilingHeight;
     unsigned int lineCount;
diff --git a/src/vizdoom/tools/lemon/lemon.c b/src/vizdoom/tools/lemon/lemon.c
index bdc004a17..b5b2cff2e 100644
--- a/src/vizdoom/tools/lemon/lemon.c
+++ b/src/vizdoom/tools/lemon/lemon.c
@@ -53,7 +53,11 @@ extern int access(char *path, int mode);
 #endif
 
 static int showPrecedenceConflict = 0;
-static void *msort(void *list, void *next, int (*cmp)());
+static void *msort(
+  void *list,
+  void *next,
+  int (*cmp)(const char *, const char *)
+);
 
 /*
 ** Compilers are getting increasingly pedantic about type conversions
@@ -72,12 +76,12 @@ static struct action *Action_new(void);
 static struct action *Action_sort(struct action *);
 
 /********** From the file "build.h" ************************************/
-void FindRulePrecedences();
-void FindFirstSets();
-void FindStates();
-void FindLinks();
-void FindFollowSets();
-void FindActions();
+void FindRulePrecedences(struct lemon *);
+void FindFirstSets(struct lemon *);
+void FindStates(struct lemon *);
+void FindLinks(struct lemon *);
+void FindFollowSets(struct lemon *);
+void FindActions(struct lemon *);
 
 /********* From the file "configlist.h" *********************************/
 void Configlist_init(void);
@@ -403,10 +407,10 @@ static struct action *Action_new(void){
 ** positive if the first action is less than, equal to, or greater than
 ** the first
 */
-static int actioncmp(ap1,ap2)
-struct action *ap1;
-struct action *ap2;
+static int actioncmp(const char *_ap1, const char *_ap2)
 {
+  const struct action *ap1 = (const struct action *)_ap1;
+  const struct action *ap2 = (const struct action *)_ap2;
   int rc;
   rc = ap1->sp->index - ap2->sp->index;
   if( rc==0 ){
@@ -1757,7 +1761,12 @@ int main(int argc, char **argv)
 **   The "next" pointers for elements in the lists a and b are
 **   changed.
 */
-static void *merge(void *a,void *b,int (*cmp)(),size_t offset)
+static void *merge(
+  void *a,
+  void *b,
+  int (*cmp)(const char *, const char *),
+  size_t offset
+)
 {
   char *ptr, *head;
 
@@ -1805,7 +1814,11 @@ static void *merge(void *a,void *b,int (*cmp)(),size_t offset)
 **   The "next" pointers for elements in list are changed.
 */
 #define LISTSIZE 30
-static void *msort(void *list,void *next,int (*cmp)())
+static void *msort(
+  void *list,
+  void *next,
+  int (*cmp)(const char *, const char *)
+)
 {
   size_t offset;
   char *ep;
@@ -2714,9 +2727,7 @@ static void preprocess_input(char *z){
   }
 }
 
-int strip_crlf(filebuf, filesize)
-char *filebuf;
-int filesize;
+int strip_crlf(char *filebuf, int filesize)
 {
 	int i, j;
 
diff --git a/tests/manual_test_sectors_and_objects_counts.py b/tests/manual_test_sectors_and_objects_counts.py
new file mode 100644
index 000000000..ba30f3b00
--- /dev/null
+++ b/tests/manual_test_sectors_and_objects_counts.py
@@ -0,0 +1,86 @@
+#!/usr/bin/env python3
+
+# This test should be run manually.
+# It reports number of objects and sectors for MAP01-MAP32.
+
+import os
+import sys
+from argparse import ArgumentParser
+
+import vizdoom as vzd
+
+
+DEFAULT_CONFIG = os.path.join(vzd.scenarios_path, "freedoom2.cfg")
+MAP_NAMES = [f"map{i:02d}" for i in range(1, 33)]
+
+
+def count_objects_and_sectors(config_path, map_name):
+    game = vzd.DoomGame()
+    try:
+        game.load_config(config_path)
+        game.set_window_visible(False)
+        game.set_mode(vzd.Mode.PLAYER)
+        game.set_objects_info_enabled(True)
+        game.set_sectors_info_enabled(True)
+        game.set_doom_map(map_name)
+        game.init()
+
+        state = game.get_state()
+        objects_count = len(state.objects) if state and state.objects is not None else 0
+        sectors_count = len(state.sectors) if state and state.sectors is not None else 0
+        return objects_count, sectors_count, None
+    except Exception as exc:
+        return None, None, str(exc).splitlines()[0]
+    finally:
+        try:
+            game.close()
+        except Exception:
+            pass
+
+
+def main():
+    parser = ArgumentParser(
+        "Manual test that reports object and sector counts for MAP01-MAP32."
+    )
+    parser.add_argument(
+        "config",
+        nargs="?",
+        default=DEFAULT_CONFIG,
+        help="Path to .cfg file. Defaults to scenarios/doom2.cfg.",
+    )
+    args = parser.parse_args()
+
+    print(f"Config: {args.config}")
+    print(f"{'Map':<8}{'Objects':>10}{'Sectors':>10}  Status")
+    print("-" * 50)
+
+    rows = []
+    for map_name in MAP_NAMES:
+        objects_count, sectors_count, error = count_objects_and_sectors(
+            args.config, map_name
+        )
+        if error is None:
+            status = "OK"
+            print(f"{map_name.upper():<8}{objects_count:>10}{sectors_count:>10}  {status}")
+            rows.append((map_name, objects_count, sectors_count))
+        else:
+            status = f"ERROR: {error}"
+            print(f"{map_name.upper():<8}{'-':>10}{'-':>10}  {status}")
+
+    print("-" * 50)
+    if rows:
+        max_objects = max(rows, key=lambda row: row[1])
+        max_sectors = max(rows, key=lambda row: row[2])
+        print(
+            f"Max objects: {max_objects[1]} on {max_objects[0].upper()}, "
+            f"max sectors: {max_sectors[2]} on {max_sectors[0].upper()}."
+        )
+    else:
+        print("No maps initialized successfully.")
+        return 1
+
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/tests/test_get_state.py b/tests/test_get_state.py
index 79d2a4830..e9627d02b 100755
--- a/tests/test_get_state.py
+++ b/tests/test_get_state.py
@@ -14,6 +14,9 @@
 import vizdoom as vzd
 
 
+GEOMETRY_TOLERANCE = 1e-5
+
+
 def _test_get_state(
     num_iterations=10,
     num_states=20,
@@ -339,6 +342,139 @@ def test_types():
     )
 
 
+def _point_on_segment_2d(px, py, x1, y1, x2, y2, tolerance=GEOMETRY_TOLERANCE):
+    dx = x2 - x1
+    dy = y2 - y1
+    cross = (px - x1) * dy - (py - y1) * dx
+    if abs(cross) > tolerance * max(1.0, abs(dx), abs(dy)):
+        return False
+
+    # Dot product is <= 0 when (px, py) is between segment endpoints.
+    dot = (px - x1) * (px - x2) + (py - y1) * (py - y2)
+    return dot <= tolerance
+
+
+def _point_in_sector_2d(px, py, sector, tolerance=GEOMETRY_TOLERANCE):
+    inside = False
+    for line in sector.lines:
+        x1, y1 = line.x1, line.y1
+        x2, y2 = line.x2, line.y2
+
+        if _point_on_segment_2d(px, py, x1, y1, x2, y2, tolerance):
+            return True
+
+        intersects = (y1 > py) != (y2 > py)
+        if intersects:
+            x_intersection = (x2 - x1) * (py - y1) / (y2 - y1) + x1
+            if px < x_intersection:
+                inside = not inside
+
+    return inside
+
+
+def _sector_map_by_id(sectors):
+    return {sector.id: sector for sector in sectors}
+
+
+def test_map01_sectors_floor_not_above_ceiling():
+    game = vzd.DoomGame()
+    try:
+        game.set_window_visible(False)
+        game.set_doom_map("map01")
+        game.set_sectors_info_enabled(True)
+        game.init()
+
+        state = game.get_state()
+        assert state.sectors is not None, "Expected sectors info to be available"
+        assert len(state.sectors) > 0, "Expected at least one sector on map01"
+
+        for i, sector in enumerate(state.sectors):
+            assert sector.floor_height <= sector.ceiling_height, (
+                f"Sector #{i}: floor_height={sector.floor_height} should be <= "
+                f"ceiling_height={sector.ceiling_height}"
+            )
+    finally:
+        game.close()
+
+
+def test_map01_objects_are_above_the_floor_of_their_sector():
+    game = vzd.DoomGame()
+    try:
+        game.set_window_visible(False)
+        game.set_doom_map("map01")
+        game.set_objects_info_enabled(True)
+        game.set_sectors_info_enabled(True)
+        game.init()
+
+        state = game.get_state()
+        assert state.objects is not None, "Expected objects info to be available"
+        assert state.sectors is not None, "Expected sectors info to be available"
+        assert len(state.objects) > 0, "Expected at least one object on map01"
+        assert len(state.sectors) > 0, "Expected at least one sector on map01"
+
+        sectors_by_id = _sector_map_by_id(state.sectors)
+        assert len(sectors_by_id) == len(
+            state.sectors
+        ), "Expected unique sector IDs in map01 sectors"
+
+        errors = []
+        for obj in state.objects:
+            sector = sectors_by_id.get(obj.sector_id)
+            if sector is None:
+                errors.append(
+                    f"Object id={obj.id}, name={obj.name} references unknown sector_id="
+                    f"{obj.sector_id}"
+                )
+                continue
+
+            if not _point_in_sector_2d(
+                obj.position_x, obj.position_y, sector, GEOMETRY_TOLERANCE
+            ):
+                errors.append(
+                    f"Object id={obj.id}, name={obj.name} is outside referenced sector_id="
+                    f"{obj.sector_id} at (x={obj.position_x}, y={obj.position_y})"
+                )
+
+            if obj.position_z + GEOMETRY_TOLERANCE < sector.floor_height:
+                errors.append(
+                    f"Object id={obj.id}, name={obj.name} is below floor: "
+                    f"z={obj.position_z}, sector_floor={sector.floor_height}"
+                )
+
+        assert not errors, "Object-to-sector floor validation failed:\n" + "\n".join(
+            errors
+        )
+    finally:
+        game.close()
+
+
+def test_object_categories_match_label_categories():
+    game = vzd.DoomGame()
+    try:
+        game.set_window_visible(False)
+        game.set_doom_map("map01")
+        game.set_labels_buffer_enabled(True)
+        game.set_objects_info_enabled(True)
+        game.init()
+
+        state = game.get_state()
+        assert state.labels is not None, "Expected labels info to be available"
+        assert state.objects is not None, "Expected objects info to be available"
+
+        objects_by_id = {obj.id: obj for obj in state.objects}
+        for label in state.labels:
+            obj = objects_by_id.get(label.object_id)
+            if obj is None:
+                continue
+            assert obj.category == label.object_category, (
+                f"Object id={obj.id}, name={obj.name} category mismatch: "
+                f"category={obj.category}, "
+                f"label_category={label.object_category}"
+            )
+    finally:
+        game.close()
+
+
 def test_modifing_buffers_while_game_is_running():
     game = vzd.DoomGame()
     game.set_window_visible(False)