Add transport system, fix NPC spawning, and improve water rendering

Transport System (Phases 1-7):
- Implement TransportManager with Catmull-Rom spline path interpolation
- Add WMO dynamic transforms for moving transport instances
- Implement player attachment via world position composition
- Add test transport with circular path around Stormwind harbor
- Add /transport board and /transport leave console commands
- Reuse taxi flight spline system and external follow camera mode

NPC Spawn Fixes:
- Add smart ocean spawn filter: blocks land creatures at high altitude over water (Z>50)
- Allow legitimate water creatures at sea level (Z≤50) to spawn correctly
- Fixes Elder Grey Bears, Highland Striders, and Plainscreepers spawning over ocean
- Snap online creatures to terrain height when valid ground exists

NpcManager Removal:
- Remove deprecated NpcManager (offline mode no longer supported)
- Delete npc_manager.hpp and npc_manager.cpp
- Simplify NPC animation callbacks to use only creatureInstances_ map
- Move NPC callbacks to game initialization in application.cpp

Water Rendering:
- Fix tile seam gaps caused by per-vertex wave randomization
- Add distance-based blending: seamless waves up close (<150u), grid effect far away (>400u)
- Smooth transition between seamless and grid modes (150-400 unit range)
- Preserves aesthetic grid pattern at horizon while eliminating gaps when swimming

include/core/application.hpp

@@ -14,7 +14,7 @@ namespace wowee {
 namespace rendering { class Renderer; }
 namespace ui { class UIManager; }
 namespace auth { class AuthHandler; }
-namespace game { class GameHandler; class World; class NpcManager; }
+namespace game { class GameHandler; class World; }
 namespace pipeline { class AssetManager; }
 namespace audio { enum class VoiceType; }
 
@@ -79,7 +79,6 @@ private:
     void render();
     void setupUICallbacks();
     void spawnPlayerCharacter();
-    void spawnNpcs();
     std::string getPlayerModelPath() const;
     static const char* mapIdToName(uint32_t mapId);
     void loadOnlineWorldTerrain(uint32_t mapId, float x, float y, float z);
@@ -93,6 +92,7 @@ private:
     void buildGameObjectDisplayLookups();
     std::string getGameObjectModelPathForDisplayId(uint32_t displayId) const;
     audio::VoiceType detectVoiceTypeFromDisplayId(uint32_t displayId) const;
+    void setupTestTransport();  // Test transport boat for development
 
     static Application* instance;
 
@@ -102,7 +102,6 @@ private:
     std::unique_ptr<auth::AuthHandler> authHandler;
     std::unique_ptr<game::GameHandler> gameHandler;
     std::unique_ptr<game::World> world;
-    std::unique_ptr<game::NpcManager> npcManager;
     std::unique_ptr<pipeline::AssetManager> assetManager;
 
     AppState state = AppState::AUTHENTICATION;

include/game/game_handler.hpp

@@ -17,6 +17,10 @@
 #include <unordered_set>
 #include <map>
 
+namespace wowee::game {
+    class TransportManager;
+}
+
 namespace wowee {
 namespace network { class WorldSocket; class Packet; }
 
@@ -483,6 +487,16 @@ public:
     bool isOnTransport() const { return playerTransportGuid_ != 0; }
     uint64_t getPlayerTransportGuid() const { return playerTransportGuid_; }
     glm::vec3 getPlayerTransportOffset() const { return playerTransportOffset_; }
+    glm::vec3 getComposedWorldPosition();  // Compose transport transform * local offset
+    TransportManager* getTransportManager() { return transportManager_.get(); }
+    void setPlayerOnTransport(uint64_t transportGuid, const glm::vec3& localOffset) {
+        playerTransportGuid_ = transportGuid;
+        playerTransportOffset_ = localOffset;
+    }
+    void clearPlayerTransport() {
+        playerTransportGuid_ = 0;
+        playerTransportOffset_ = glm::vec3(0.0f);
+    }
 
     // Cooldowns
     float getSpellCooldown(uint32_t spellId) const;
@@ -972,6 +986,7 @@ private:
     std::unordered_set<uint64_t> transportGuids_;  // GUIDs of known transport GameObjects
     uint64_t playerTransportGuid_ = 0;             // Transport the player is riding (0 = none)
     glm::vec3 playerTransportOffset_ = glm::vec3(0.0f); // Player offset on transport
+    std::unique_ptr<TransportManager> transportManager_;  // Transport movement manager
     std::vector<uint32_t> knownSpells;
     std::unordered_map<uint32_t, float> spellCooldowns;    // spellId -> remaining seconds
     uint8_t castCount = 0;

include/game/npc_manager.hpp

@@ -1,75 +0,0 @@
-#pragma once
-
-#include <cstdint>
-#include <string>
-#include <vector>
-#include <unordered_map>
-#include <glm/glm.hpp>
-
-namespace wowee {
-namespace pipeline { class AssetManager; }
-namespace rendering { class CharacterRenderer; }
-namespace rendering { class TerrainManager; }
-namespace game {
-
-class EntityManager;
-
-struct NpcSpawnDef {
-    std::string mapName;
-    uint32_t entry = 0;
-    std::string name;
-    std::string m2Path;
-    uint32_t level;
-    uint32_t health;
-    glm::vec3 canonicalPosition; // WoW canonical coords (+X north, +Y west, +Z up)
-    bool inputIsServerCoords = false; // if true, input XYZ are server/wire order
-    float rotation;          // radians around Z
-    float scale;
-    bool isCritter;          // critters don't do humanoid emotes
-    uint32_t faction = 0;    // faction template ID from creature_template
-    uint32_t npcFlags = 0;   // NPC interaction flags from creature_template
-};
-
-struct NpcInstance {
-    uint64_t guid;
-    uint32_t renderInstanceId;
-    float emoteTimer;        // countdown to next random emote
-    float emoteEndTimer;     // countdown until emote animation finishes
-    bool isEmoting;
-    bool isCritter;
-};
-
-class NpcManager {
-public:
-    void clear(rendering::CharacterRenderer* cr, EntityManager* em);
-    void initialize(pipeline::AssetManager* am,
-                    rendering::CharacterRenderer* cr,
-                    EntityManager& em,
-                    const std::string& mapName,
-                    const glm::vec3& playerCanonical,
-                    const rendering::TerrainManager* terrainManager);
-    void update(float deltaTime, rendering::CharacterRenderer* cr);
-
-    uint32_t findRenderInstanceId(uint64_t guid) const;
-
-private:
-    std::vector<NpcSpawnDef> loadSpawnDefsFromFile(const std::string& path) const;
-    std::vector<NpcSpawnDef> loadSpawnDefsFromAzerothCoreDb(
-        const std::string& basePath,
-        const std::string& mapName,
-        const glm::vec3& playerCanonical,
-        pipeline::AssetManager* am) const;
-
-    void loadCreatureModel(pipeline::AssetManager* am,
-                           rendering::CharacterRenderer* cr,
-                           const std::string& m2Path,
-                           uint32_t modelId);
-
-    std::vector<NpcInstance> npcs;
-    std::unordered_map<std::string, uint32_t> loadedModels; // path -> modelId
-    uint64_t nextGuid = 0xF1300000DEAD0001ULL;
-    uint32_t nextModelId = 100;
-};
-
-} // namespace game
-} // namespace wowee

include/game/transport_manager.hpp

@@ -0,0 +1,73 @@
+#pragma once
+
+#include <cstdint>
+#include <vector>
+#include <unordered_map>
+#include <glm/glm.hpp>
+#include <glm/gtc/quaternion.hpp>
+
+namespace wowee::rendering {
+    class WMORenderer;
+}
+
+namespace wowee::game {
+
+struct TransportPath {
+    uint32_t pathId;
+    std::vector<glm::vec3> waypoints;  // Position keyframes
+    std::vector<glm::quat> rotations;  // Optional rotation keyframes
+    bool looping;
+    float speed;  // units/sec (default 18.0f like taxi)
+};
+
+struct ActiveTransport {
+    uint64_t guid;              // Entity GUID
+    uint32_t wmoInstanceId;     // WMO renderer instance ID
+    uint32_t pathId;            // Current path
+    size_t currentSegment;      // Current waypoint index
+    float segmentProgress;      // Distance along segment
+    glm::vec3 position;         // Current world position
+    glm::quat rotation;         // Current world rotation
+    glm::mat4 transform;        // Cached world transform
+    glm::mat4 invTransform;     // Cached inverse for collision
+
+    // Player attachment (single-player for now)
+    bool playerOnBoard;
+    glm::vec3 playerLocalOffset;
+
+    // Optional deck boundaries
+    glm::vec3 deckMin;
+    glm::vec3 deckMax;
+    bool hasDeckBounds;
+};
+
+class TransportManager {
+public:
+    TransportManager();
+    ~TransportManager();
+
+    void setWMORenderer(rendering::WMORenderer* renderer) { wmoRenderer_ = renderer; }
+
+    void update(float deltaTime);
+    void registerTransport(uint64_t guid, uint32_t wmoInstanceId, uint32_t pathId);
+    void unregisterTransport(uint64_t guid);
+
+    ActiveTransport* getTransport(uint64_t guid);
+    glm::vec3 getPlayerWorldPosition(uint64_t transportGuid, const glm::vec3& localOffset);
+    glm::mat4 getTransportInvTransform(uint64_t transportGuid);
+
+    void loadPathFromNodes(uint32_t pathId, const std::vector<glm::vec3>& waypoints, bool looping = true, float speed = 18.0f);
+    void setDeckBounds(uint64_t guid, const glm::vec3& min, const glm::vec3& max);
+
+private:
+    void updateTransportMovement(ActiveTransport& transport, float deltaTime);
+    glm::vec3 interpolatePath(const TransportPath& path, size_t segmentIdx, float t);
+    glm::quat calculateOrientation(const TransportPath& path, size_t segmentIdx, float t);
+    void updateTransformMatrices(ActiveTransport& transport);
+
+    std::unordered_map<uint64_t, ActiveTransport> transports_;
+    std::unordered_map<uint32_t, TransportPath> paths_;
+    rendering::WMORenderer* wmoRenderer_ = nullptr;
+};
+
+} // namespace wowee::game

include/rendering/wmo_renderer.hpp

@@ -82,6 +82,13 @@ public:
      */
     void setInstancePosition(uint32_t instanceId, const glm::vec3& position);
 
+    /**
+     * Update the full transform of an existing instance (for moving transports)
+     * @param instanceId Instance to update
+     * @param transform World transform matrix
+     */
+    void setInstanceTransform(uint32_t instanceId, const glm::mat4& transform);
+
     /**
      * Remove WMO instance
      * @param instanceId Instance to remove