client.py

# client.py
import json
import os
from pathlib import Path

_cfg_path = Path('launch_config.json')
if _cfg_path.exists():
    try:
        _cfg = json.loads(_cfg_path.read_text())
        os.environ['TOKENTORCH_SEED']       = str(_cfg.get('seed',       876567))
        os.environ['TOKENTORCH_WORLD_SIZE'] = str(_cfg.get('world_size', 32768))
    except Exception:
        pass

import uuid
import time
import math
import numpy as np
from concurrent.futures import ThreadPoolExecutor
import threading
import asyncio
import moderngl
import moderngl_window
import pyrr
from moderngl_window import BaseWindow

from cave_generation import scan_and_remove_floaters
from client_state import ClientState, WaterData
from constants import ClientConstants, GenerationConstants
from fluid_simulator import ChunkFluidSimulator, _NEIGHBOR_OFFSETS
from graphics_resources import GraphicsResources
from network import NetworkClient
from player_commands import PlayerController
from profiler import FrameProfiler
from shaders import ShaderLibrary
from skybox import ProceduralSky
from world_generation import (finished_chunks_queue, fetch_chunk_threaded,
                              mesh_volume, save_chunk_to_disk_threaded,
                              set_active_database, find_shoreline_spawn)

from entity_manager import (SkinnedCharacter, LaserBeam,
                            HeldItemModel, ItemDropRenderer,
                            ArachnoidModel)


class TokenTorchClient(moderngl_window.WindowConfig, ClientState):
    gl_version = (3, 3)
    title = "TokenTorch Client"
    window_size = (1600, 900)
    aspect_ratio = 16 / 9
    fullscreen = False
    resizable = True
    resource_dir = os.path.normpath(os.path.dirname(__file__))
    ctx = moderngl.create_context(standalone=True)
    wnd: BaseWindow

    def __init__(self, **kwargs):
        super().__init__(**kwargs)
        ClientState.__init__(self)
        self._strand_pool = ThreadPoolExecutor(
            max_workers=2,
            thread_name_prefix='strand'
        )
        self.ctx: moderngl.Context
        self.texture_array: moderngl.TextureArray | None = None
        self.shaders = ShaderLibrary(ctx=self.ctx)
        self.assets = GraphicsResources(self.ctx)
        self.assets.bind_textures(self.shaders.chunk)
        self.const = ClientConstants
        self.con = GenerationConstants
        self.show_profiler = False
        self.profiler = FrameProfiler()
        self.current_engine_time = 0.0
        self.last_seen_network_time = 0.0
        self.last_server_time_update = 0.0
        self.wnd.mouse_exclusivity = False
        self.show_inventory = False
        self.engine_started = False
        self.camera_mode = 'TPS'
        self.torch_on = True

        # ── Load launch config written by main_menu.py ─────────────────────
        _cfg: dict = {}
        _cfg_path = Path('launch_config.json')
        if _cfg_path.exists():
            try:
                _cfg = json.loads(_cfg_path.read_text())
            except Exception:
                pass

        _host = _cfg.get('host_ip', '')
        if _host and _host != '127.0.0.1':
            os.environ['TOKENTORCH_SERVER_HOST'] = _host

        self.my_player_id = str(uuid.uuid4())[:8]
        self.world_name = _cfg.get('world_name', 'World')
        self.server_host = _cfg.get('host_ip', '127.0.0.1')
        self.server_port = int(_cfg.get('port', 5555))
        _mode = _cfg.get('mode', 'singleplayer')
        self.is_multiplayer = _mode in ('singleplayer', 'multiplayer', 'host', 'host_creative')

        # ==========================================
        # CONNECTION & ROUTING LOGIC
        # ==========================================
        if self.is_multiplayer:
            # 1. Determine the cache name based on the server IP
            self.network = NetworkClient(host=self.server_host, port=self.server_port)
            safe_ip = self.network.server_addr[0].replace('.', '_')
            cache_name = f"mp_cache_{safe_ip}.db"

            # 2. Anti-Cheat: The Pre-Emptive Strike
            if os.path.exists(cache_name):
                try:
                    os.remove(cache_name)
                    print("[Security] Purged compromised cache file from previous session.")
                except Exception:
                    pass

            # 3. Route the background threads!
            set_active_database(cache_name)
            self.active_cache_file = cache_name
            print(f"[Network] Connected! Spun up secure temp cache: {cache_name}")

        else:
            # Singleplayer — named world save
            set_active_database(f'worlds/sp_{self.world_name}.db')

        # --- PREFAB EXPORTER ---
        self.prefab_pos_a = None
        self.prefab_pos_b = None
        os.makedirs('prefabs', exist_ok=True)

        # --- FIRST-SPAWN: Land the player on a shoreline beach (hashed) ---
        spawn_x, spawn_y, spawn_z = find_shoreline_spawn()
        print(f"[Spawn] Surface beach spawn → ({spawn_x:.0f}, {spawn_y:.0f}, {spawn_z:.0f})")

        if self.is_multiplayer:
            self._pending_spawn_request = (spawn_x, spawn_y, spawn_z)
            self._spawn_request_sent = False

        self.last_safe_position = (spawn_x, spawn_y, spawn_z)
        self._clip_frames = 0

        self.controller = PlayerController(spawn_x, spawn_y, spawn_z)
        self.last_mouse_pos = (self.window_size[0] // 2, self.window_size[1] // 2)

        self.assets.load_textures()
        self.skybox = ProceduralSky(self.ctx)
        self.active_tasks = set()

        # --- UI SYSTEM INITIALIZATION ---
        from ui_renderer import UIRenderer

        self.ui_renderer = UIRenderer(self.ctx)
        base_ui_path = 'art/textures/ui/'

        self._frame_hit = None
        self._frame_empty = None

        # Load Crosshair and Inventory Background
        self.ui_renderer.load_texture('crosshair', base_ui_path + 'crosshair.png')
        self.ui_renderer.load_texture('slot_bg', base_ui_path + 'slot_bg.png')

        self._view_proj_cache = np.eye(4, dtype='f4')

        # Load block icons for the inventory (Matching your client.py texture array order)
        block_filenames = [
            'obsidian_bedrock.png',  # ID 1
            'stone_granite.png',  # ID 2
            'dirt.png',  # ID 3
            'grass_top.png',  # ID 4
            'snow.png',  # ID 5
            'log_oak.png',  # ID 6
            'leaves_oak.png',  # ID 7
            'mahogany_crate.png',  # ID 8
            'log_birch.png',  # ID 9
            'leaves_birch.png',  # ID 10
            'grass_long.png',  # ID 11
            'red_sandstone_top.png',  # ID 12
            'cut_bricks.png',  # ID 13
            'red_cut_bricks.png',  # ID 14
            'planks_oak.png',  # ID 15
            'sand.png'  # ID 16
        ]

        # TODO: ADD ITEM FILENAMES FOR INVENTORY DISPLAY

        for i, filename in enumerate(block_filenames):
            block_id = i + 1  # 0-index list to 1-based Block ID
            self.ui_renderer.load_texture(f'block_{block_id}', f'art/textures/blocks/{filename}')

        # Load Health Hearts
        for state in ['full', 'three_quarters', 'half', 'quarter', 'empty']:
            self.ui_renderer.load_texture(f'heart_{state}', f'{base_ui_path}heart_{state}.png')

        # Load Stamina Hearts
        for state in ['full', 'three_quarters', 'half', 'quarter', 'empty']:
            self.ui_renderer.load_texture(f'stamina_{state}', f'{base_ui_path}stamina_{state}.png')

        self.last_fluid_tick = 0.0
        self.last_physics_tick = 0.0

        self.requested_chunks = set()
        self.last_chunk_pos = None
        self.last_chunk_upload_time = 0.0
        self.pending_chunk_requests = []
        self.last_chunk_request_time = 0.0

        # --- CHARACTER SYSTEM ---
        self.active_character_id = 'blockman'  # The one we are currently playing as

        self.last_pvp_tick = 0.0
        self.last_water_heartbeat = 0.0
        self._charge_threat: float = 0.0

        # Load the models into the dictionary
        try:
            self.characters['blockman'] = SkinnedCharacter(
                self, 'art/models/entities/players/blockman.glb'
            )
            self.characters['blockman'].scale = 1.0
        except Exception as e:
            print(f"WARNING: Could not load character model: {e}")

        self.monster_models: dict = {}

        # --- WEAPON SYSTEM ---
        from entity_manager import WeaponModel
        # Scale 0.02 makes it 50x smaller!
        self.blaster = WeaponModel(self, 'art/models/entities/mining_blaster_alpha.obj',
                                   'art/textures/colors/mining_blaster_alpha.png', scale=0.25)
        self.laser_effect = LaserBeam(self)

        self.bucket_model = HeldItemModel(
            self,
            model_path='art/models/items/bucket01.obj',
            texture_path='art/textures/items/colors/castletexture.png',
            scale=0.5,  # Adjust if it's too huge/tiny
            offset=(0.6, -0.4, -1.2),  # Bottom right of the screen
            rotation=(0.0, math.radians(-45), 0.0)  # Angled slightly inward
        )

        self.mining_target = None  # Coordinates of the block we are currently beaming
        self.mining_start_time = 0.0  # When did we start shooting this block?

        # --- INVENTORY SYSTEM ---
        # 50 slots total. Indices 0-9 are the hotbar.
        self.inventory = [{'id': 0, 'count': 0} for _ in range(50)]

        # Some starter items!
        self.inventory[0] = {'id': 14, 'count': 64}  # Oak Planks
        self.inventory[1] = {'id': 12, 'count': 32}  # Cut Bricks
        self.inventory[2] = {'id': 7, 'count': 16}  # Mahogany Crate

        # --- NEW: THE BUCKETS ---
        self.ITEM_WOODEN_BUCKET_EMPTY = 1000
        self.ITEM_WOODEN_BUCKET_WATER = 1001
        self.inventory[3] = {'id': self.ITEM_WOODEN_BUCKET_EMPTY, 'count': 1}  # Starter bucket!

        self.active_hotbar_slot = 0

        self.item_renderer = ItemDropRenderer(self)

        self.chat_history = []
        self.is_typing = False
        self.input_text = ""
        self.player_name = f"Player_{self.my_player_id[:4]}"

        self.model_matrix = pyrr.Matrix44.identity()
        self.proj_matrix = pyrr.matrix44.create_perspective_projection(
            fovy=60.0, aspect=self.aspect_ratio, near=0.1, far=500.0
        )
        self.shaders.chunk['m_proj'].write(self.proj_matrix.astype('f4').tobytes())

        # Cache the orthographic UI projection — rebuilt only on resize
        self._ui_proj = pyrr.matrix44.create_orthogonal_projection(
            0, self.window_size[0], 0, self.window_size[1], -1, 1
        ).astype('f4')

        # Cache view*proj — updated every frame in _calculate_camera_and_environment
        self._view_proj_cache = np.eye(4, dtype=np.float32)
        self.ctx.enable(moderngl.DEPTH_TEST | moderngl.CULL_FACE)

        self._gatherer_running = True
        self._gatherer_thread = threading.Thread(
            target=self._water_gatherer_worker, daemon=True
        )
        self._gatherer_thread.start()

    def _check_clip_through_terrain(self, current_time):
        pos = self.controller.get_position()
        passable = getattr(self.controller, 'passable_blocks', {0, 11})

        # Sample the block occupying the player's torso and feet
        torso_id = self.get_block_at(pos[0], pos[1], pos[2])
        foot_id = self.get_block_at(pos[0], pos[1] - 0.5, pos[2])

        clipping = (torso_id not in passable) or (foot_id not in passable)

        if clipping:
            self._clip_frames += 1
            # 3-frame debounce — ignores single-frame edge grazes
            if self._clip_frames >= 3:
                lsp = self.last_safe_position
                self.controller.position = pyrr.Vector3([lsp[0], lsp[1], lsp[2]])
                self.controller.velocity_y = 0.0
                self._clip_frames = 0
                print(f"[Safety] Clip detected — returned to ({lsp[0]:.1f}, {lsp[1]:.1f}, {lsp[2]:.1f})")
        else:
            self._clip_frames = 0
            # Only checkpoint when solidly grounded, not mid-air
            ground_id = self.get_block_at(pos[0], pos[1] - 1.1, pos[2])
            if ground_id not in passable:
                self.last_safe_position = (float(pos[0]), float(pos[1]), float(pos[2]))

    def _water_gatherer_worker(self):
        while self._gatherer_running:
            pending = list(self.water_gather_needed)

            for chunk_coord in pending:
                water_data = self.water_state.get(chunk_coord)
                if water_data is None:
                    self.water_gather_needed.discard(chunk_coord)
                    continue

                arr = water_data.vol
                wx, wy, wz = np.nonzero(arr > 0.0)
                if len(wx) == 0:
                    self.water_gather_needed.discard(chunk_coord)
                    continue

                cx, cy, cz = chunk_coord

                # Optional: validate against heightmap seeding math
                # world_ys = wy + cy * 16
                # valid = world_ys <= GenerationConstants.SEA_LEVEL
                # wx, wy, wz = wx[valid], wy[valid], wz[valid]
                # if len(wx) == 0: ...

                instance_data = np.column_stack((
                    wx + cx * 16,
                    wy + cy * 16,
                    wz + cz * 16,
                    arr[wx, wy, wz]
                )).astype('f4')

                self.water_upload_queue.append((chunk_coord, instance_data))
                self.water_gather_needed.discard(chunk_coord)

            time.sleep(0.008)

    @staticmethod
    async def _gather_chunk_prep(batch):
        """
        Gather any remaining CPU prep across 4 strands concurrently.
        Each coroutine is initialized cheaply upfront, then the event
        loop runs their parts without sequential frame overhead.
        """
        loop = asyncio.get_running_loop()

        async def _prep(item):
            cx, cy, cz, serialized, volume, water_vol = item
            cube_bytes, sprite_bytes, water_bytes, nc, ns, nw = serialized
            return cx, cy, cz, cube_bytes, sprite_bytes, water_bytes, nc, ns, nw, volume, water_vol

        return await asyncio.gather(*[_prep(item) for item in batch])

    def _drain_water_upload_queue(self):
        """Main thread only — GPU uploads from gatherer output."""
        while self.water_upload_queue:
            chunk_coord, instance_data = self.water_upload_queue.popleft()

            if chunk_coord not in self.chunk_data:
                continue

            # Release old
            if 'water' in self.chunk_data[chunk_coord]:
                self.chunk_data[chunk_coord]['water'][0].release()
                del self.chunk_data[chunk_coord]['water']
            if 'water_vbo_obj' in self.chunk_data[chunk_coord]:
                self.chunk_data[chunk_coord]['water_vbo_obj'].release()
                del self.chunk_data[chunk_coord]['water_vbo_obj']

            # Upload
            water_vbo = self.ctx.buffer(instance_data.tobytes())
            water_vao = self.ctx.vertex_array(
                self.shaders.water,
                [(self.assets.vbo, '3f 8x', 'in_position'),
                 (water_vbo, '4f /i', 'in_instance')],
                index_buffer=self.assets.ibo
            )
            self.chunk_data[chunk_coord]['water'] = (water_vao, len(instance_data))
            self.chunk_data[chunk_coord]['water_vbo_obj'] = water_vbo

    def _drain_boundary_remesh(self, budget: int = 2):
        """
        Re-meshes up to `budget` chunks per frame whose boundary faces may
        have been occluded by a newly loaded neighbor.  Runs after
        process_finished_chunks so world_state is already updated.
        """
        processed = 0
        while self.pending_boundary_remesh and processed < budget:
            chunk_coord = self.pending_boundary_remesh.pop()
            cx, cy, cz = chunk_coord

            # Skip if the chunk was unloaded between enqueue and drain
            if chunk_coord not in self.world_state or chunk_coord not in self.chunk_data:
                continue

            volume = self.world_state[chunk_coord]
            water_data = self.water_state.get(chunk_coord)
            water_vol = water_data.vol if water_data is not None else \
                np.zeros((self.con.CHUNK_SIZE,) * 3, dtype=np.float32)

            ghost_solid, ghost_water = self.build_ghosted_arrays(
                chunk_coord, self.world_state, self.water_state
            )
            cube_data, sprite_data, water_mesh = mesh_volume(
                volume, water_vol, cx, cy, cz,
                ghost_water=ghost_water, ghost_solid=ghost_solid
            )

            old = self.chunk_data[chunk_coord]

            # Release stale GPU memory
            for key in ('cube', 'sprite', 'water'):
                if key in old:           old[key][0].release()
                if f'{key}_vbo_obj' in old: old[f'{key}_vbo_obj'].release()

            chunk_render_data = {}

            if len(cube_data) > 0:
                cube_vbo = self.ctx.buffer(cube_data.tobytes())
                cube_vao = self.ctx.vertex_array(
                    self.shaders.chunk,
                    [(self.assets.vbo, '3f 2f', 'in_position', 'in_uv'),
                     (cube_vbo, '4f 1f 1f /i', 'in_instance', 'in_ao_1', 'in_ao_2')],
                    index_buffer=self.assets.ibo
                )
                chunk_render_data['cube'] = (cube_vao, len(cube_data))
                chunk_render_data['cube_vbo_obj'] = cube_vbo

            if len(sprite_data) > 0:
                sprite_vbo = self.ctx.buffer(sprite_data.tobytes())
                sprite_vao = self.ctx.vertex_array(
                    self.shaders.chunk,
                    [(self.assets.sprite_vbo, '3f 2f', 'in_position', 'in_uv'),
                     (sprite_vbo, '4f 1f 1f /i', 'in_instance', 'in_ao_1', 'in_ao_2')],
                    index_buffer=self.assets.sprite_ibo
                )
                chunk_render_data['sprite'] = (sprite_vao, len(sprite_data))
                chunk_render_data['sprite_vbo_obj'] = sprite_vbo

            if len(water_mesh) > 0:
                water_vbo = self.ctx.buffer(water_mesh.tobytes())
                water_vao = self.ctx.vertex_array(
                    self.shaders.water,
                    [(self.assets.vbo, '3f 8x', 'in_position'),
                     (water_vbo, '4f /i', 'in_instance')],
                    index_buffer=self.assets.ibo
                )
                chunk_render_data['water'] = (water_vao, len(water_mesh))
                chunk_render_data['water_vbo_obj'] = water_vbo

            # Preserve fluid bookkeeping keys — the mesh changed, not the sim state
            for key in ('water_dirty', 'water_settle_time'):
                if key in old:
                    chunk_render_data[key] = old[key]

            self.chunk_data[chunk_coord] = chunk_render_data
            processed += 1

    def on_resize(self, width: int, height: int):
        self._ui_proj = pyrr.matrix44.create_orthogonal_projection(
            0, width, 0, height, -1, 1
        ).astype('f4')

    def get_specific_block_at(self, x, y, z):
        """Helper to get a block ID from the raw world state array safely."""
        x, y, z = int(math.floor(x)), int(math.floor(y)), int(math.floor(z))
        cx, cy, cz = x // self.con.CHUNK_SIZE, y // self.con.CHUNK_SIZE, z // self.con.CHUNK_SIZE
        lx, ly, lz = x % self.con.CHUNK_SIZE, y % self.con.CHUNK_SIZE, z % self.con.CHUNK_SIZE

        chunk_coord = (cx, cy, cz)
        if chunk_coord in self.world_state:
            return self.world_state[chunk_coord][lx, ly, lz]
        return 0

    def get_block_at(self, x, y, z):
        """Helper to read the voxel array at a specific world coordinate."""
        # Because geometry is drawn from -0.5 to 0.5, the true center of block (0,0,0) is at 0.0.
        # To map a floating point position to the correct integer voxel bucket,
        # we must add 0.5 before taking the floor.
        bx = int(math.floor(x + 0.5))
        by = int(math.floor(y + 0.5))
        bz = int(math.floor(z + 0.5))

        cx, cy, cz = bx // self.con.CHUNK_SIZE, by // self.con.CHUNK_SIZE, bz // self.con.CHUNK_SIZE
        chunk_coord = (cx, cy, cz)

        if chunk_coord in self.world_state:
            lx, ly, lz = bx % self.con.CHUNK_SIZE, by % self.con.CHUNK_SIZE, bz % self.con.CHUNK_SIZE
            try:
                return self.world_state[chunk_coord][lx, ly, lz]
            except IndexError:
                return 0
        return 0

    def raycast(self, max_dist=10.0, step=0.05):
        """
        Fires a ray from the camera.
        Returns (hit_block_coord, previous_empty_coord) or (None, None).
        """
        pos = self.controller.get_position().copy()
        if not self.controller.is_flying:
            pos[1] += 0.0  # Eye level is origin

        front = self.controller.front
        traveled = 0.0

        last_empty = None

        while traveled < max_dist:
            # Shift by +0.5 to match the visual geometry center!
            bx = int(math.floor(pos[0] + 0.5))
            by = int(math.floor(pos[1] + 0.5))
            bz = int(math.floor(pos[2] + 0.5))

            # get_block_at will internally do the +0.5 shift, so we pass the raw float pos
            block_id = self.get_block_at(pos[0], pos[1], pos[2])

            if block_id > 0 and block_id not in self.controller.passable_blocks:
                return (bx, by, bz), last_empty

            last_empty = (bx, by, bz)
            pos += front * step
            traveled += step

        return None, None

    def set_block_at(self, x, y, z, block_id):
        """Modifies the voxel array and instantly rebuilds the chunk mesh."""
        if self.ctx is None:
            return

        bx, by, bz = int(math.floor(x)), int(math.floor(y)), int(math.floor(z))
        cx, cy, cz = bx // self.con.CHUNK_SIZE, by // self.con.CHUNK_SIZE, bz // self.con.CHUNK_SIZE
        lx, ly, lz = bx % self.con.CHUNK_SIZE, by % self.con.CHUNK_SIZE, bz % self.con.CHUNK_SIZE

        chunk_coord = (cx, cy, cz)

        # 1. Update the local data
        self.world_state[chunk_coord][lx, ly, lz] = block_id

        # Pre-fill broken position with water if any face neighbor has water
        if block_id == 0:
            water_data = self.water_state.get(chunk_coord)
            if water_data is not None:
                arr = water_data.vol
                for dlx, dly, dlz in [(1, 0, 0), (-1, 0, 0), (0, 1, 0), (0, -1, 0), (0, 0, 1), (0, 0, -1)]:
                    nlx, nly, nlz = lx + dlx, ly + dly, lz + dlz
                    if 0 <= nlx < self.con.CHUNK_SIZE and \
                            0 <= nly < self.con.CHUNK_SIZE and \
                            0 <= nlz < self.con.CHUNK_SIZE and \
                            arr[nlx, nly, nlz] > 0.0:
                        arr[lx, ly, lz] = 1.0
                        break

        # 2. Update fluid simulator first so water adapts to the new geometry
        if chunk_coord in self.fluid_simulators:
            ghost_solid, ghost_water = self.build_ghosted_arrays(chunk_coord, self.world_state, self.water_state)
            sim = self.fluid_simulators[chunk_coord]
            sim.update_solid_geometry(ghost_solid)
            sim.step_simulation(cx, cy, cz)
            vol_np = sim.get_render_arrays()
            self.water_state[chunk_coord] = WaterData(vol=vol_np)
        else:
            # Wake up the simulator if we interact with a dormant water chunk!
            water_data = self.water_state.get(chunk_coord)
            if water_data is not None and bool(np.any(water_data.vol > 0.0)):
                ghost_solid, ghost_water = self.build_ghosted_arrays(chunk_coord, self.world_state, self.water_state)
                sim = ChunkFluidSimulator()
                sim.initialize_gpu_memory(ghost_water, ghost_solid)
                self.fluid_simulators[chunk_coord] = sim
                if chunk_coord not in self.chunk_data:
                    self.chunk_data[chunk_coord] = {}
                self.chunk_data[chunk_coord]['water_dirty'] = True

        # 3. Fetch water volume (may have just been updated above)
        water_data = self.water_state.get(chunk_coord)
        water_volume = water_data.vol if water_data is not None else np.zeros(
            (self.con.CHUNK_SIZE,) * 3, dtype=np.float32
        )

        # 4. Build ghost for seam-free water meshing
        ghost_solid, ghost_water = self.build_ghosted_arrays(chunk_coord, self.world_state, self.water_state)

        # 5. Mesh the chunk
        cube_data, sprite_data, water_mesh = mesh_volume(
            self.world_state[chunk_coord], water_volume, cx, cy, cz,
            ghost_water=ghost_water, ghost_solid=ghost_solid
        )

        # 6. Release old GPU memory
        if chunk_coord in self.chunk_data:
            old = self.chunk_data[chunk_coord]
            for key in ('cube', 'sprite', 'water'):
                if key in old:
                    old[key][0].release()
                if f'{key}_vbo_obj' in old:
                    old[f'{key}_vbo_obj'].release()

        # 7. Upload new geometry
        chunk_render_data = {}

        if len(cube_data) > 0:
            cube_vbo = self.ctx.buffer(cube_data.tobytes())
            cube_vao = self.ctx.vertex_array(
                self.shaders.chunk,
                [(self.assets.vbo, '3f 2f', 'in_position', 'in_uv'),
                 (cube_vbo, '4f 1f 1f /i', 'in_instance', 'in_ao_1', 'in_ao_2')],
                index_buffer=self.assets.ibo
            )
            chunk_render_data['cube'] = (cube_vao, len(cube_data))
            chunk_render_data['cube_vbo_obj'] = cube_vbo

        if len(sprite_data) > 0:
            sprite_instance_vbo = self.ctx.buffer(sprite_data.tobytes())
            sprite_vao = self.ctx.vertex_array(
                self.shaders.chunk,
                [(self.assets.sprite_vbo, '3f 2f', 'in_position', 'in_uv'),
                 (sprite_instance_vbo, '4f 1f 1f /i', 'in_instance', 'in_ao_1', 'in_ao_2')],
                index_buffer=self.assets.sprite_ibo
            )
            chunk_render_data['sprite'] = (sprite_vao, len(sprite_data))
            chunk_render_data['sprite_vbo_obj'] = sprite_instance_vbo

        if len(water_mesh) > 0:
            water_vbo = self.ctx.buffer(water_mesh.tobytes())
            water_vao = self.ctx.vertex_array(
                self.shaders.water,
                [(self.assets.vbo, '3f 8x', 'in_position'),
                 (water_vbo, '4f /i', 'in_instance')],
                index_buffer=self.assets.ibo
            )
            chunk_render_data['water'] = (water_vao, len(water_mesh))
            chunk_render_data['water_vbo_obj'] = water_vbo

        self.chunk_data[chunk_coord] = chunk_render_data

    def on_mouse_press_event(self, x, y, button):
        if self.camera_mode != 'FPS':
            return

        hit_coord, empty_coord = self.raycast(max_dist=15.0)

        if button == 1 and hasattr(self, 'blaster'):
            # Just read it directly! Clean and safe.
            current_time = self.current_engine_time

            self.blaster.fire(current_time)

            cam_pos = self.controller.get_position()
            start_pos = cam_pos + pyrr.Vector3([0.0, -0.2, 0.0]) + (self.controller.front * 0.5)

            if hit_coord:
                end_pos = pyrr.Vector3([hit_coord[0], hit_coord[1], hit_coord[2]])
            else:
                end_pos = start_pos + (self.controller.front * 15.0)

            self.laser_effect.shoot(start_pos, end_pos, current_time)

        if hit_coord:
            if button == 2 and empty_coord:
                active_slot = self.inventory[self.active_hotbar_slot]

                if active_slot['count'] > 0:
                    selected_id = active_slot['id']

                    # ==========================================
                    # INTERACTIVE TOOL: EMPTY BUCKET (SCOOP)
                    # ==========================================
                    if selected_id == self.ITEM_WOODEN_BUCKET_EMPTY:
                        wx, wy, wz = hit_coord
                        cx, cy, cz = (wx // self.con.CHUNK_SIZE,
                                      wy // self.con.CHUNK_SIZE,
                                      wz // self.con.CHUNK_SIZE)
                        lx, ly, lz = wx % self.con.CHUNK_SIZE, wy % self.con.CHUNK_SIZE, wz % self.con.CHUNK_SIZE
                        chunk = (cx, cy, cz)

                        if chunk in self.water_state:
                            # THE FIX: Extract the actual volume array from the tuple
                            water_data = self.water_state[chunk]
                            water_array = water_data.vol

                            if water_array[lx, ly, lz] > 0.05:
                                new_vol = max(0.0, water_array[lx, ly, lz] - 0.1)
                                water_array[lx, ly, lz] = new_vol
                                active_slot['id'] = self.ITEM_WOODEN_BUCKET_WATER

                                # Sync to Server
                                if hasattr(self, 'network') and getattr(self, 'is_multiplayer', True):
                                    self.network.send_water_update(self.my_player_id, wx, wy, wz, new_vol)

                                print("Scooped water!")

                                # THE GPU FIX: Surgically inject the 1 block change into the 18x18x18 boundary!
                                if chunk in self.fluid_simulators:
                                    self.fluid_simulators[chunk].inject_server_state({(lx, ly, lz): new_vol})

                                # Wake up the mesh builder!
                                if chunk in self.chunk_data:
                                    self.chunk_data[chunk]['water_dirty'] = True
                                    self.chunk_data[chunk]['water_settle_time'] = self.current_engine_time

                    # ==========================================
                    # INTERACTIVE TOOL: WATER BUCKET (POUR)
                    # ==========================================
                    elif selected_id == self.ITEM_WOODEN_BUCKET_WATER:
                        wx, wy, wz = empty_coord
                        cx, cy, cz = (wx // self.con.CHUNK_SIZE, wy // self.con.CHUNK_SIZE, wz // self.con.CHUNK_SIZE)
                        lx, ly, lz = (wx % self.con.CHUNK_SIZE, wy % self.con.CHUNK_SIZE, wz % self.con.CHUNK_SIZE)

                        chunk = (cx, cy, cz)
                        if chunk not in self.water_state:
                            empty = np.zeros((self.con.CHUNK_SIZE,) * 3, dtype=np.float32)
                            self.water_state[chunk] = WaterData(
                                vol=empty
                            )

                        water_array = self.water_state[chunk].vol
                        new_vol = min(1.0, water_array[lx, ly, lz] + 0.1)
                        water_array[lx, ly, lz] = new_vol
                        active_slot['id'] = self.ITEM_WOODEN_BUCKET_EMPTY

                        # Sync to Server
                        if hasattr(self, 'network') and getattr(self, 'is_multiplayer', True):
                            self.network.send_water_update(self.my_player_id, wx, wy, wz, new_vol)
                        print("Poured water!")

                        if chunk not in self.fluid_simulators:
                            ghost_solid, ghost_water = self.build_ghosted_arrays(
                                chunk, self.world_state, self.water_state
                            )
                            sim = ChunkFluidSimulator()
                            sim.initialize_gpu_memory(ghost_water, ghost_solid)
                            self.fluid_simulators[chunk] = sim
                        else:
                            # Safely inject the new water directly into the GPU
                            self.fluid_simulators[chunk].inject_server_state({(lx, ly, lz): new_vol})

                        if chunk in self.chunk_data:
                            self.chunk_data[chunk]['water_dirty'] = True
                            self.chunk_data[chunk]['water_settle_time'] = self.current_engine_time

                    # ==========================================
                    # STANDARD SOLID BLOCK PLACEMENT
                    # ==========================================
                    elif selected_id < 1000:  # Ensure it's a solid block ID
                        self.set_block_at(empty_coord[0], empty_coord[1], empty_coord[2], selected_id)
                        active_slot['count'] -= 1
                        if active_slot['count'] == 0:
                            active_slot['id'] = 0

                        if hasattr(self, 'network') and getattr(self, 'is_multiplayer', True):
                            self.network.send_block_update(
                                self.my_player_id,
                                empty_coord[0], empty_coord[1], empty_coord[2],
                                selected_id
                            )

    def break_block(self, bx, by, bz, is_player_action=True):
        """Centralized block breaking logic."""
        block_id = self.get_block_at(bx, by, bz)
        if block_id == 0: return

        # 1. Set to air locally
        self.set_block_at(bx, by, bz, 0)

        # 2. Spawn the 3D item drop!
        if hasattr(self, 'item_renderer'):
            self.item_renderer.add_drop(bx, by, bz, block_id)

        # 3. Network Sync
        if hasattr(self, 'network') and getattr(self, 'is_multiplayer', True) and is_player_action:
            self.network.send_block_update(self.my_player_id, bx, by, bz, 0)

        # 4. Tree Felling Chain Reaction (Only if initiated by the player)
        # 6=Oak Log, 9=Birch Log
        if is_player_action and block_id in [6, 9]:
            self._felling_check(bx, by, bz)

    def add_to_inventory(self, block_id, amount=1):
        """Attempts to add an item to the inventory. Returns True if successful."""
        # 1. Try to stack with existing items
        for slot in self.inventory:
            if slot['id'] == block_id and slot['count'] < 64:
                space = 64 - slot['count']
                add = min(space, amount)
                slot['count'] += add
                amount -= add
                if amount <= 0:
                    return True

        # 2. If we still have items, find an empty slot
        for slot in self.inventory:
            if slot['id'] == 0:
                slot['id'] = block_id
                slot['count'] = amount
                return True

        return False  # Inventory is full!

    def process_finished_chunks(self, current_time):
        if self.ctx is None:
            return

        batch = []
        budget_start = time.perf_counter()

        while not finished_chunks_queue.empty():
            if time.perf_counter() - budget_start > self.const.chunk_upload_budget:
                break
            batch.append(finished_chunks_queue.get())

        for item in batch:
            cx, cy, cz, serialized, volume, water_vol = item
            cube_b, sprite_b, water_b, nc, ns, nw = serialized
            self._upload_chunk_to_gpu(cx, cy, cz, cube_b, sprite_b, water_b, nc, ns, nw, volume, water_vol)

    def _upload_chunk_to_gpu(
            self, cx, cy, cz,
            cube_b, sprite_b, water_b,
            nc, ns, nw,
            volume, water_vol
    ):
        """Pure GPU calls only — no CPU work here."""
        chunk_coord = (cx, cy, cz)
        self.world_state[chunk_coord] = volume
        self.water_state[chunk_coord] = WaterData(vol=water_vol)

        # Release old
        if chunk_coord in self.chunk_data:
            old = self.chunk_data[chunk_coord]
            for key in ('cube', 'sprite', 'water'):
                if key in old: old[key][0].release()
                if f'{key}_vbo_obj' in old: old[f'{key}_vbo_obj'].release()

        chunk_render_data = {}

        if nc > 0:
            cube_vbo = self.ctx.buffer(cube_b)
            cube_vao = self.ctx.vertex_array(
                self.shaders.chunk,
                [(self.assets.vbo, '3f 2f', 'in_position', 'in_uv'),
                 (cube_vbo, '4f 1f 1f /i', 'in_instance', 'in_ao_1', 'in_ao_2')],
                index_buffer=self.assets.ibo
            )
            chunk_render_data['cube'] = (cube_vao, nc)
            chunk_render_data['cube_vbo_obj'] = cube_vbo

        if ns > 0:
            sprite_vbo = self.ctx.buffer(sprite_b)
            sprite_vao = self.ctx.vertex_array(
                self.shaders.chunk,
                [(self.assets.sprite_vbo, '3f 2f', 'in_position', 'in_uv'),
                 (sprite_vbo, '4f 1f 1f /i', 'in_instance', 'in_ao_1', 'in_ao_2')],
                index_buffer=self.assets.sprite_ibo
            )
            chunk_render_data['sprite'] = (sprite_vao, ns)
            chunk_render_data['sprite_vbo_obj'] = sprite_vbo

        if nw > 0:
            water_vbo = self.ctx.buffer(water_b)
            water_vao = self.ctx.vertex_array(
                self.shaders.water,
                [(self.assets.vbo, '3f 8x', 'in_position'),
                 (water_vbo, '4f /i', 'in_instance')],
                index_buffer=self.assets.ibo
            )
            chunk_render_data['water'] = (water_vao, nw)
            chunk_render_data['water_vbo_obj'] = water_vbo

        self.chunk_data[chunk_coord] = chunk_render_data

        # ONLY spawn fluid sim if the chunk is actively flowing/dirty!
        # Deep ocean chunks will stay completely dormant until disturbed.
        is_dirty = self.chunk_data.get(chunk_coord, {}).get('water_dirty', False)

        if is_dirty and bool(np.any(water_vol > 0.0)) and chunk_coord not in self.fluid_simulators:
            ghost_solid, ghost_water = self.build_ghosted_arrays(chunk_coord, self.world_state, self.water_state)
            sim = ChunkFluidSimulator()
            sim.initialize_gpu_memory(ghost_water, ghost_solid)
            self.fluid_simulators[chunk_coord] = sim

        # Flag face-adjacent loaded neighbors for boundary re-mesh.
        # Their outward-facing boundary faces are now potentially occluded
        # by the chunk that just arrived.
        for ddx, ddy, ddz in [(1, 0, 0), (-1, 0, 0), (0, 1, 0), (0, -1, 0), (0, 0, 1), (0, 0, -1)]:
            neighbor = (cx + ddx, cy + ddy, cz + ddz)
            if neighbor in self.world_state and neighbor in self.chunk_data:
                self.pending_boundary_remesh.add(neighbor)

        self._frustum_dirty = True

        if hasattr(self, 'network') and getattr(self, 'is_multiplayer', True):
            try:
                packet = {"type": "chunk_loaded", "id": self.my_player_id, "chunk": [cx, cy, cz]}
                self.network.sock.sendto(json.dumps(packet).encode('utf-8'), self.network.server_addr)
            except Exception:
                pass

    def block_physics_tick(self, current_time):
        if self.ctx is None:
            return

        if current_time - self.last_physics_tick < 1.0:
            return
        self.last_physics_tick = current_time

        pos = self.controller.get_position()
        cx, cy, cz = int(pos.x // self.con.CHUNK_SIZE), int(pos.y // self.con.CHUNK_SIZE), int(
            pos.z // self.con.CHUNK_SIZE)

        for nx in range(cx - 1, cx + 2):
            for ny in range(cy - 1, cy + 2):
                for nz in range(cz - 1, cz + 2):
                    chunk_coord = (nx, ny, nz)

                    if chunk_coord not in self.world_state:
                        continue

                    volume = self.world_state[chunk_coord]
                    changed = scan_and_remove_floaters(volume)

                    if not changed:
                        continue

                    water_data = self.water_state.get(chunk_coord)
                    water_volume = water_data.vol if water_data is not None else np.zeros(
                        (self.con.CHUNK_SIZE,) * 3, dtype=np.float32
                    )

                    # Release old GPU memory
                    if chunk_coord in self.chunk_data:
                        old = self.chunk_data[chunk_coord]
                        for key in ('cube', 'sprite', 'water'):
                            if key in old:
                                old[key][0].release()
                            if f'{key}_vbo_obj' in old:
                                old[f'{key}_vbo_obj'].release()

                    # Ghost for seam-free water
                    ghost_solid, ghost_water = self.build_ghosted_arrays(chunk_coord, self.world_state,
                                                                         self.water_state)
                    cube_data, sprite_data, water_mesh = mesh_volume(
                        volume, water_volume, nx, ny, nz,
                        ghost_water=ghost_water, ghost_solid=ghost_solid
                    )

                    chunk_render_data = {}

                    if len(cube_data) > 0:
                        cube_vbo = self.ctx.buffer(cube_data.tobytes())
                        cube_vao = self.ctx.vertex_array(
                            self.shaders.chunk,
                            [(self.assets.vbo, '3f 2f', 'in_position', 'in_uv'),
                             (cube_vbo, '4f 1f 1f /i', 'in_instance', 'in_ao_1', 'in_ao_2')],
                            index_buffer=self.assets.ibo
                        )
                        chunk_render_data['cube'] = (cube_vao, len(cube_data))
                        chunk_render_data['cube_vbo_obj'] = cube_vbo

                    if len(sprite_data) > 0:
                        sprite_instance_vbo = self.ctx.buffer(sprite_data.tobytes())
                        sprite_vao = self.ctx.vertex_array(
                            self.shaders.chunk,
                            [(self.assets.sprite_vbo, '3f 2f', 'in_position', 'in_uv'),
                             (sprite_instance_vbo, '4f 1f 1f /i', 'in_instance', 'in_ao_1', 'in_ao_2')],
                            index_buffer=self.assets.sprite_ibo
                        )
                        chunk_render_data['sprite'] = (sprite_vao, len(sprite_data))
                        chunk_render_data['sprite_vbo_obj'] = sprite_instance_vbo

                    if len(water_mesh) > 0:
                        water_vbo = self.ctx.buffer(water_mesh.tobytes())
                        water_vao = self.ctx.vertex_array(
                            self.shaders.water,
                            [(self.assets.vbo, '3f 8x', 'in_position'),
                             (water_vbo, '4f /i', 'in_instance')],
                            index_buffer=self.assets.ibo
                        )
                        chunk_render_data['water'] = (water_vao, len(water_mesh))
                        chunk_render_data['water_vbo_obj'] = water_vbo

                    self.chunk_data[chunk_coord] = chunk_render_data

    def _sync_settled_water_to_server(self, chunk_coord, water_volume):
        """Extracts non-zero water blocks and sends them as a single batch update."""
        if not hasattr(self, 'network'): return

        cx, cy, cz = chunk_coord
        wx_idx, wy_idx, wz_idx = np.nonzero(water_volume > 0.0)

        # Format into a compact dictionary for the JSON payload
        settled_data = {}
        for i in range(len(wx_idx)):
            lx, ly, lz = wx_idx[i], wy_idx[i], wz_idx[i]
            world_x = (cx * self.con.CHUNK_SIZE) + lx
            world_y = (cy * self.con.CHUNK_SIZE) + ly
            world_z = (cz * self.con.CHUNK_SIZE) + lz
            # Round the float32 to 2 decimal places to save UDP bandwidth
            settled_data[f"{world_x},{world_y},{world_z}"] = round(float(water_volume[lx, ly, lz]), 2)

        # Send the payload!
        packet = {
            "type": "batched_water_sync",
            "id": self.my_player_id,
            "chunk": [cx, cy, cz],
            "water_data": settled_data
        }
        try:
            self.network.sock.sendto(json.dumps(packet).encode('utf-8'), self.network.server_addr)
        except Exception as e:
            print(f"Failed to sync settled water: {e}")

    def on_key_event(self, key, action, modifiers):
        if self.wnd is None: return

        if action == self.wnd.keys.ACTION_PRESS:
            if key == self.wnd.keys.ENTER:
                if self.is_typing:
                    if self.input_text.strip():
                        packet = {"type": "chat", "id": self.my_player_id, "name": self.player_name,
                                  "text": self.input_text}
                        self.network.sock.sendto(json.dumps(packet).encode('utf-8'), self.network.server_addr)
                    self.input_text = ""
                    self.is_typing = False
                    self.wnd.mouse_exclusivity = True
                else:
                    self.is_typing = True
                    self.wnd.mouse_exclusivity = False
                return

            if self.is_typing and key == self.wnd.keys.BACKSPACE:
                self.input_text = self.input_text[:-1]
                return

        if getattr(self, 'is_typing', True):
            return

        if key == self.wnd.keys.ESCAPE and action == self.wnd.keys.ACTION_PRESS:
            self.wnd.close()

        # --- VIEW TOGGLE (V) ---
        if key == self.wnd.keys.V and action == self.wnd.keys.ACTION_PRESS:
            self.camera_mode = 'TPS' if self.camera_mode == 'FPS' else 'FPS'
            # Leaving FPS always drops focus so the FOV resets cleanly
            if self.camera_mode != 'FPS':
                self.focus_mode = False

        # --- FLIGHT TOGGLE (F) ---
        if key == self.wnd.keys.F and action == self.wnd.keys.ACTION_PRESS:
            self.controller.is_flying = not self.controller.is_flying

        # --- TORCH TOGGLE (T) ---
        if key == self.wnd.keys.T and action == self.wnd.keys.ACTION_PRESS:
            self.torch_on = not self.torch_on

        # --- TOGGLE PROFILER (P) ---
        if key == self.wnd.keys.P and action == self.wnd.keys.ACTION_PRESS:
            self.show_profiler = not self.show_profiler

        # --- INVENTORY TOGGLE (I) ---
        if key == self.wnd.keys.I and action == self.wnd.keys.ACTION_PRESS:
            self.show_inventory = not self.show_inventory
            self.wnd.mouse_exclusivity = not self.show_inventory

        # --- FOCUS MODE TOGGLE (Z) ---
        # Only available in FPS. Narrows FOV, extends PvP range, tightens aim cone.
        if key == self.wnd.keys.Z and action == self.wnd.keys.ACTION_PRESS:
            if self.camera_mode == 'FPS':
                self.focus_mode = not self.focus_mode

        if action == self.wnd.keys.ACTION_PRESS:
            if key == self.wnd.keys.NUMBER_1: self.active_hotbar_slot = 0
            if key == self.wnd.keys.NUMBER_2: self.active_hotbar_slot = 1
            if key == self.wnd.keys.NUMBER_3: self.active_hotbar_slot = 2
            if key == self.wnd.keys.NUMBER_4: self.active_hotbar_slot = 3
            if key == self.wnd.keys.NUMBER_5: self.active_hotbar_slot = 4
            if key == self.wnd.keys.NUMBER_6: self.active_hotbar_slot = 5
            if key == self.wnd.keys.NUMBER_7: self.active_hotbar_slot = 6
            if key == self.wnd.keys.NUMBER_8: self.active_hotbar_slot = 7
            if key == self.wnd.keys.NUMBER_9: self.active_hotbar_slot = 8
            if key == self.wnd.keys.NUMBER_0: self.active_hotbar_slot = 9

        if key == self.wnd.keys.E and action == self.wnd.keys.ACTION_PRESS:
            cam_pos = self.controller.get_position()
            front = self.controller.front
            grab_range = 10.0
            pickup_radius = 1.5

            for i in range(len(self.item_renderer.drops) - 1, -1, -1):
                drop = self.item_renderer.drops[i]
                drop_pos = pyrr.Vector3([drop['x'], drop['y'], drop['z']])
                v = drop_pos - cam_pos
                t = pyrr.vector.dot(v, front)
                if 0 < t < grab_range:
                    proj_p = cam_pos + (front * t)
                    dist = pyrr.vector.length(drop_pos - proj_p)
                    if dist < pickup_radius:
                        if self.add_to_inventory(drop['layer'] + 1, 1):
                            self.item_renderer.drops.pop(i)
                            print("Grabbed item!")

        if key == self.wnd.keys.LEFT_BRACKET and action == self.wnd.keys.ACTION_PRESS:
            pos = self.controller.get_position()
            self.prefab_pos_a = (int(math.floor(pos.x)), int(math.floor(pos.y)), int(math.floor(pos.z)))
            print(f"Prefab Point A set to {self.prefab_pos_a}")

        if key == self.wnd.keys.RIGHT_BRACKET and action == self.wnd.keys.ACTION_PRESS:
            pos = self.controller.get_position()
            self.prefab_pos_b = (int(math.floor(pos.x)), int(math.floor(pos.y)), int(math.floor(pos.z)))
            print(f"Prefab Point B set to {self.prefab_pos_b}")

        if key == self.wnd.keys.BACKSLASH and action == self.wnd.keys.ACTION_PRESS:
            if self.prefab_pos_a is not None and self.prefab_pos_b is not None:
                self.export_prefab()
            else:
                print("You must set Point A '[' and Point B ']' first!")

    def on_unicode_char_entered(self, char):
        """Captures typed text from moderngl_window."""
        if getattr(self, 'is_typing', False) and char.isprintable():
            self.input_text += char

    def on_mouse_position_event(self, x, y, dx, dy):
        if getattr(self, 'show_inventory', False):
            return  # Don't rotate the camera if we are trying to click items!

        if dx == 0 and dy == 0:
            dx, dy = x - self.last_mouse_pos[0], y - self.last_mouse_pos[1]
        self.last_mouse_pos = (x, y)
        self.controller.process_mouse(dx, dy)

    def export_prefab(self, name="custom_structure"):
        # Wrap everything in int() to make the type-checker happy
        min_x = int(min(self.prefab_pos_a[0], self.prefab_pos_b[0]))
        max_x = int(max(self.prefab_pos_a[0], self.prefab_pos_b[0]))
        min_y = int(min(self.prefab_pos_a[1], self.prefab_pos_b[1]))
        max_y = int(max(self.prefab_pos_a[1], self.prefab_pos_b[1]))
        min_z = int(min(self.prefab_pos_a[2], self.prefab_pos_b[2]))
        max_z = int(max(self.prefab_pos_a[2], self.prefab_pos_b[2]))

        # Calculate bounding box (+1 to include the end blocks)
        width = (max_x - min_x) + 1
        height = (max_y - min_y) + 1
        depth = (max_z - min_z) + 1

        prefab_data = np.zeros((width, height, depth), dtype=np.uint8)

        # Scan the world and copy the blocks into our local array
        for x in range(width):
            for y in range(height):
                for z in range(depth):
                    prefab_data[x, y, z] = self.get_block_at(min_x + x, min_y + y, min_z + z)

        filename = f"prefabs/{name}_{time.perf_counter()}.npy"
        np.save(filename, prefab_data)
        print(f"\nSUCCESS! Saved prefab {width}x{height}x{depth} to '{filename}'!")

        # Reset selection
        self.prefab_pos_a = None
        self.prefab_pos_b = None

    def process_mining_laser(self, current_time):
        """Runs every frame to check if the user is holding left-click to mine or shoot players."""
        if self.camera_mode != 'FPS': return
        if self.wnd is None:
            return

        is_firing = self.wnd.mouse_states.left
        if not is_firing:
            self.mining_target = None
            return

        cam_pos = self.controller.get_position()
        front = self.controller.front

        # Focus mode widens range and narrows the aim cone
        pvp_range = self.const.FOCUS_PVP_RANGE if self.focus_mode else self.const.BASE_PVP_RANGE
        aim_threshold = self.const.FOCUS_AIM_THRESHOLD if self.focus_mode else self.const.BASE_AIM_THRESHOLD

        # 1. PvP AIM-LOCKING
        hit_player_id = None

        # 1.5. MONSTER AIM-LOCKING (only if no player was locked)
        hit_monster_id = None

        if not hit_player_id and hasattr(self, 'network') and getattr(self, 'is_multiplayer', True):
            for mid, m_data in self.network.remote_monsters.copy().items():
                if 'x' not in m_data:
                    continue

                target_pos = pyrr.Vector3([m_data['x'], m_data['y'], m_data['z']])
                to_target = target_pos - cam_pos
                distance = pyrr.vector.length(to_target)

                if pvp_range > distance > 0.1:
                    to_target_norm = pyrr.vector.normalize(to_target)
                    aim_accuracy = pyrr.vector.dot(front, to_target_norm)

                    if aim_accuracy > aim_threshold:
                        hit_monster_id = mid
                        break

        # 2. Fire against the locked target — runs ONCE, after the loop
        if hit_player_id:
            p_data = self.network.remote_players.get(hit_player_id, {})
            target_pos = pyrr.Vector3([p_data['x'], p_data['y'], p_data['z']])

            if current_time - getattr(self, 'last_pvp_tick', 0) > 0.1:
                self.last_pvp_tick = current_time
                self.network.sock.sendto(
                    json.dumps({
                        "type": "damage",
                        "id": self.my_player_id,
                        "target_id": hit_player_id,
                        "amount": 10.0
                    }).encode('utf-8'),
                    self.network.server_addr
                )

            if hasattr(self, 'blaster'):
                self.blaster.fire(current_time)
                start_pos = cam_pos + pyrr.Vector3([0.0, -0.2, 0.0]) + (front * 0.5)
                self.laser_effect.shoot(start_pos, target_pos, current_time)

            self.mining_target = None
            return

        # 2.5. Fire against a locked monster
        if hit_monster_id:
            m_data = self.network.remote_monsters.get(hit_monster_id, {})
            target_pos = pyrr.Vector3([m_data['x'], m_data['y'], m_data['z']])

            if current_time - self.last_pvp_tick > 0.1:
                self.last_pvp_tick = current_time
                self.network.sock.sendto(
                    json.dumps({
                        "type": "monster_damage",
                        "id": self.my_player_id,
                        "target_id": hit_monster_id,
                        "amount": 25.0
                    }).encode('utf-8'),
                    self.network.server_addr
                )

            if hasattr(self, 'blaster'):
                self.blaster.fire(current_time)
                start_pos = cam_pos + pyrr.Vector3([0.0, -0.2, 0.0]) + (front * 0.5)
                self.laser_effect.shoot(start_pos, target_pos, current_time)

            self.mining_target = None
            return

        # 3. Block Mining
        hit_coord, empty_coord = self._frame_hit, self._frame_empty

        if hit_coord:
            if self.mining_target != hit_coord:
                self.mining_target = hit_coord
                self.mining_start_time = current_time

            if hasattr(self, 'blaster'):
                self.blaster.fire(current_time)
                start_pos = cam_pos + pyrr.Vector3([0.0, -0.2, 0.0]) + (front * 0.5)
                end_pos = pyrr.Vector3([hit_coord[0], hit_coord[1], hit_coord[2]])
                self.laser_effect.shoot(start_pos, end_pos, current_time)

            if current_time - self.mining_start_time >= self.const.MINING_DURATION:
                self.break_block(hit_coord[0], hit_coord[1], hit_coord[2], is_player_action=True)
                self.mining_target = None
        else:
            self.mining_target = None
            if hasattr(self, 'blaster'):
                self.blaster.fire(current_time)
                start_pos = cam_pos + pyrr.Vector3([0.0, -0.2, 0.0]) + (front * 0.5)
                end_pos = start_pos + (front * 15.0)
                self.laser_effect.shoot(start_pos, end_pos, current_time)

    def on_render(self, current_time: float, frame_time: float):
        if self.ctx is None:
            return
        self.current_engine_time = current_time

        self.profiler.begin('raycast')
        self._frame_hit, self._frame_empty = self.raycast(max_dist=15.0)
        self.profiler.end('raycast')

        # 1. Physics, Generation & Logic Steps
        self.profiler.begin('fluid_physics')
        self._step_fluid_physics(current_time)
        self.profiler.end('fluid_physics')

        self.profiler.begin('block_physics')
        self.block_physics_tick(current_time)
        self.profiler.end('block_physics')

        self.profiler.begin('chunk_update')
        self.update_chunks()
        self._drain_pending_unloads()
        self.profiler.end('chunk_update')

        self.profiler.begin('chunk_dispatch')
        self.dispatch_pending_chunks(current_time)
        self.profiler.end('chunk_dispatch')

        self.profiler.begin('chunk_upload')
        self.process_finished_chunks(current_time)
        self._drain_boundary_remesh()
        self.profiler.end('chunk_upload')

        # 2. Network Sync
        self.profiler.begin('network_sync')
        self._process_network_heartbeat(current_time)
        self._process_incoming_network_data()
        self.profiler.end('network_sync')

        # 3. Input & Player Actions
        self.profiler.begin('player_input')
        self.controller.process_movement(self.wnd, frame_time, self.get_block_at)
        self._check_clip_through_terrain(current_time)
        self.process_mining_laser(current_time)
        self.profiler.end('player_input')

        # 4. View Matrices & Environment
        self.profiler.begin('camera_env')
        view_matrix, camera_eye, day_factor, sun_dir = self._calculate_camera_and_environment(current_time)
        self.profiler.end('camera_env')

        # 5. Drain water uploads
        self.profiler.begin('water_drain')
        self._drain_water_upload_queue()
        self.profiler.end('water_drain')

        # 6. RENDER PASSES
        self.ctx.clear(0.0, 0.0, 0.0)

        self.profiler.begin('skybox')
        self.skybox.render(self.proj_matrix, view_matrix, day_factor, sun_dir)
        self.profiler.end('skybox')

        self.profiler.begin('render_3d')
        drawn_chunks = self._render_3d_world(view_matrix, day_factor)
        self.profiler.end('render_3d')

        self.profiler.begin('entities')
        self._render_entities_and_effects(view_matrix, current_time, day_factor, frame_time)
        self.profiler.end('entities')

        self.profiler.begin('render_ui')
        self._render_2d_ui(view_matrix, frame_time, camera_eye)
        self.profiler.end('render_ui')

        # 7. Final State Management
        self._manage_engine_state(frame_time, drawn_chunks)

    def _calculate_camera_and_environment(self, current_time):
        """Handles Day/Night math, Camera Matrices, and FOV lerp for focus mode."""
        pos = self.controller.get_position()
        front = self.controller.front

        if self.camera_mode == 'FPS':
            view_matrix = self.controller.get_view_matrix()
            camera_eye = pos
        else:
            camera_eye = pos - (front * 5.0)
            camera_eye.y += 1.5
            view_matrix = pyrr.matrix44.create_look_at(
                eye=camera_eye, target=pos, up=pyrr.Vector3([0.0, 0.65, 0.0])
            )

        # --- FOV lerp ---
        # Smoothly interpolates between BASE_FOV and FOCUS_FOV each frame.
        # player_commands.py can read self.controller.is_focused to gate sprint.
        target_fov = (self.const.FOCUS_FOV
                      if self.focus_mode and self.camera_mode == 'FPS'
                      else self.const.BASE_FOV)
        self._active_fov += (target_fov - self._active_fov) * self.const.FOV_LERP_SPEED
        self.controller.is_focused = self.focus_mode  # expose for player_commands.py

        # Rebuild proj matrix only when the lerped value has shifted meaningfully
        if abs(self._active_fov - getattr(self, '_last_written_fov', -1)) > 0.05:
            self._last_written_fov = self._active_fov
            self.proj_matrix = pyrr.matrix44.create_perspective_projection(
                fovy=self._active_fov, aspect=self.aspect_ratio, near=0.1, far=500.0
            )
            self.shaders.chunk['m_proj'].write(self.proj_matrix.astype('f4').tobytes())

        self._view_proj_cache = pyrr.matrix44.multiply(
            view_matrix, self.proj_matrix
        ).astype('f4')

        cycle_speed = 0.01
        time_to_use = (self.network.world_time
                       if hasattr(self, 'network') and self.network.world_time
                       else current_time)
        sun_angle = time_to_use * cycle_speed
        sun_x, sun_y, sun_z = math.cos(sun_angle), math.sin(sun_angle), 0.4
        length = math.sqrt(sun_x ** 2 + sun_y ** 2 + sun_z ** 2)
        sun_dir = (sun_x / length, sun_y / length, sun_z / length)
        day_factor = max(0.0, min(1.0, sun_y + 0.2))

        self.shaders.chunk['m_view'].write(view_matrix.astype('f4').tobytes())
        self.shaders.chunk['m_model'].write(self.model_matrix.astype('f4').tobytes())
        self.shaders.chunk['u_camera_pos'].write(pos.astype('f4').tobytes())
        self.shaders.chunk['u_torch_active'].value = 1.0 if self.torch_on else 0.0
        self.shaders.chunk['u_day_factor'].value = float(day_factor)
        self._view_proj_cache = pyrr.matrix44.multiply(
            view_matrix, self.proj_matrix
        ).astype('f4')

        self._last_day_factor = day_factor
        return view_matrix, camera_eye, day_factor, sun_dir

    def _step_fluid_physics(self, current_time):
        """Steps the GPU fluid simulation and handles the MMO water auto-save."""
        if current_time - self.last_fluid_tick < self.const.FLUID_TICK_RATE:
            return
        self.last_fluid_tick = current_time
        pos = self.controller.get_position()

        chunks_to_wake = set()
        dried_up_chunks = []
        px, py, pz = (int(pos.x // self.con.CHUNK_SIZE),
                      int(pos.y // self.con.CHUNK_SIZE),
                      int(pos.z // self.con.CHUNK_SIZE))

        for chunk_coord, sim in list(self.fluid_simulators.items()):
            cx, cy, cz = chunk_coord

            is_near = abs(cx - px) <= 3 and abs(cy - py) <= 2 and abs(cz - pz) <= 3
            is_flowing = chunk_coord in self.flowing_chunks

            if not is_near and not is_flowing:
                continue

            ghost_solid, ghost_water = self.build_ghosted_arrays(chunk_coord, self.world_state, self.water_state)
            sim.sync_boundaries(ghost_water, ghost_solid)

            had_movement = sim.step_simulation(cx, cy, cz)

            if not had_movement:
                self.flowing_chunks.discard(chunk_coord)

                settle_timer = self.chunk_data.get(chunk_coord, {}).get('water_settle_time', current_time)
                is_dirty = self.chunk_data.get(chunk_coord, {}).get('water_dirty', False)

                if is_dirty and (current_time - settle_timer > 2.0):
                    water_data = self.water_state.get(chunk_coord)
                    if water_data is not None:
                        self._sync_settled_water_to_server(chunk_coord, water_data.vol)
                    self.chunk_data[chunk_coord]['water_dirty'] = False

                water_data = self.water_state.get(chunk_coord)
                if water_data is None or not bool(np.any(water_data.vol > 0.0)):
                    dried_up_chunks.append(chunk_coord)
                continue

            # Only pull from GPU when water actually moved
            vol_array = sim.get_render_arrays()
            self.water_state[chunk_coord] = WaterData(vol=vol_array)

            # Wake neighbors using the freshly pulled CPU array
            if np.ndarray.max(vol_array[0, :, :]) > 0.0: chunks_to_wake.add((cx - 1, cy, cz))
            if np.ndarray.max(vol_array[15, :, :]) > 0.0: chunks_to_wake.add((cx + 1, cy, cz))
            if np.ndarray.max(vol_array[:, 0, :]) > 0.0: chunks_to_wake.add((cx, cy - 1, cz))
            if np.ndarray.max(vol_array[:, 15, :]) > 0.0: chunks_to_wake.add((cx, cy + 1, cz))
            if np.ndarray.max(vol_array[:, :, 0]) > 0.0: chunks_to_wake.add((cx, cy, cz - 1))
            if np.ndarray.max(vol_array[:, :, 15]) > 0.0: chunks_to_wake.add((cx, cy, cz + 1))

            if chunk_coord not in self.chunk_data:
                self.chunk_data[chunk_coord] = {}

            self.chunk_data[chunk_coord]['water_dirty'] = True
            self.chunk_data[chunk_coord]['water_settle_time'] = current_time
            self.water_gather_needed.add(chunk_coord)

        for wake_coord in chunks_to_wake:
            if wake_coord in self.chunk_data and wake_coord not in self.fluid_simulators:
                ghost_solid, ghost_water = self.build_ghosted_arrays(wake_coord, self.world_state,
                                                                     self.water_state)
                new_sim = ChunkFluidSimulator()
                new_sim.initialize_gpu_memory(ghost_water, ghost_solid)
                self.fluid_simulators[wake_coord] = new_sim

                # Bridge ghost ring → interior: seed boundary cells so the kernel
                # can propagate inward. Ghost ring is frozen; interior cells are live.
                seeds = {}
                S = self.con.CHUNK_SIZE  # 16
                for a in range(1, S + 1):
                    for b in range(1, S + 1):
                        la, lb = a - 1, b - 1
                        for v, key in [
                            (ghost_water[0, a, b], (0, la, lb)),  # -x face
                            (ghost_water[17, a, b], (15, la, lb)),  # +x face
                            (ghost_water[a, 0, b], (la, 0, lb)),  # -y face
                            (ghost_water[a, 17, b], (la, 15, lb)),  # +y face
                            (ghost_water[a, b, 0], (la, lb, 0)),  # -z face
                            (ghost_water[a, b, 17], (la, lb, 15)),  # +z face
                        ]:
                            if v > 0.0:
                                seeds[key] = max(seeds.get(key, 0.0), float(v))

                if seeds:
                    new_sim.inject_server_state(seeds)

            if wake_coord in self.chunk_data:
                self.flowing_chunks.add(wake_coord)
                self.chunk_data[wake_coord]['water_dirty'] = True
                self.chunk_data[wake_coord]['water_settle_time'] = current_time

        # Cleanup empty simulations
        for coord in dried_up_chunks:
            if coord in self.fluid_simulators:
                del self.fluid_simulators[coord]

    def _process_network_heartbeat(self, current_time):
        """Checks if the server is still alive, triggers offline mode if not."""
        if getattr(self, 'is_multiplayer', True) and hasattr(self, 'network'):
            if not hasattr(self, 'last_server_time_update'):
                self.last_server_time_update = current_time

            if self.network.world_time != getattr(self, 'last_seen_network_time', None):
                self.last_seen_network_time = self.network.world_time
                self.last_server_time_update = current_time

                if (not getattr(self, '_spawn_request_sent', True)
                        and hasattr(self, '_pending_spawn_request')):
                    sx, sy, sz = self._pending_spawn_request
                    try:
                        packet = {
                            "type": "monster_spawn_request",
                            "id": self.my_player_id,
                            "x": sx,
                            "z": sz
                        }
                        self.network.sock.sendto(
                            json.dumps(packet).encode('utf-8'),
                            self.network.server_addr
                        )
                        self._spawn_request_sent = True
                        print(f"[Spawn] Sent monster spawn request at ({sx:.0f}, {sz:.0f})")
                    except Exception as e:
                        print(f"[Spawn] Failed to send spawn request: {e}")

            if current_time - self.last_server_time_update > 5.0:
                self.trigger_offline_fallback()

    def _process_incoming_network_data(self):
        """Processes block updates, water syncs, and player events from the UDP queues."""
        if hasattr(self, 'network') and getattr(self, 'is_multiplayer', True):
            # Process Block Updates
            while not self.network.incoming_block_updates.empty():
                update = self.network.incoming_block_updates.get()
                bx, by, bz, b_id = update["bx"], update["by"], update["bz"], update["block_id"]
                cx, cy, cz = bx // self.con.CHUNK_SIZE, by // self.con.CHUNK_SIZE, bz // self.con.CHUNK_SIZE
                lx, ly, lz = bx % self.con.CHUNK_SIZE, by % self.con.CHUNK_SIZE, bz % self.con.CHUNK_SIZE
                chunk_coord = (cx, cy, cz)

                if chunk_coord not in self.server_chunk_changes:
                    self.server_chunk_changes[chunk_coord] = {}
                self.server_chunk_changes[chunk_coord][(lx, ly, lz)] = b_id

                if chunk_coord in self.world_state:
                    self.set_block_at(bx, by, bz, b_id)

            # Process Events (Health, Respawn, Water Sync)
            while not self.network.incoming_events.empty():
                event = self.network.incoming_events.get()

                # --- Process Chat Events ---
                if event["type"] == "chat":
                    self.chat_history.append((
                        self.current_engine_time,
                        event.get("name", "Unknown"),
                        event.get("text", ""))
                    )

                    # Keep history from growing forever
                    if len(self.chat_history) > 20:
                        self.chat_history.pop(0)

                elif event["type"] == "health_update":
                    self.controller.health = event["hp"]

                elif event["type"] == "respawn":
                    self.controller.health = event["hp"]
                    self.controller.position = pyrr.Vector3([event["x"], event["y"], event["z"]])
                    self.controller.velocity_y = 0.0
                    print("\n[💀] You were obliterated! Respawning...")

                elif event["type"] == "batch_monsters":
                    for m_data in event.get("monsters", []):
                        mid = m_data["id"]
                        # Lazy-load one shared ArachnoidModel per unique ID
                        if mid not in self.monster_models:
                            try:
                                self.monster_models[mid] = ArachnoidModel(
                                    self,
                                    'art/models/entities/arachnoid.obj',
                                    'art/textures/colors/arachnoid.png'
                                )
                                print(f"[Monster] Loaded ArachnoidModel for {mid}")
                            except Exception as e:
                                print(f"[Monster] WARNING: Could not load ArachnoidModel for {mid}: {e}")
                                self.monster_models[mid] = None  # Sentinel — don't retry every frame
                        # Store live position for the renderer
                        self.network.remote_monsters[mid] = m_data

                elif event["type"] == "monster_killed":
                    mid = event.get("monster_id")
                    if mid in self.network.remote_monsters:
                        del self.network.remote_monsters[mid]
                    if mid in self.monster_models:
                        del self.monster_models[mid]

                elif event["type"] == "player_leave":
                    p_id = event["id"]
                    if p_id in self.network.remote_players: del self.network.remote_players[p_id]
                    if p_id in self.characters: del self.characters[p_id]

                elif event["type"] == "world_sync":
                    for coord_str, b_id in event.get("changes", {}).items():
                        bx, by, bz = map(int, coord_str.split(','))
                        cx, cy, cz = bx // self.con.CHUNK_SIZE, by // self.con.CHUNK_SIZE, bz // self.con.CHUNK_SIZE
                        lx, ly, lz = bx % self.con.CHUNK_SIZE, by % self.con.CHUNK_SIZE, bz % self.con.CHUNK_SIZE
                        chunk = (cx, cy, cz)

                        if chunk not in getattr(self, 'server_chunk_changes', {}):
                            if not hasattr(self, 'server_chunk_changes'): self.server_chunk_changes = {}
                            self.server_chunk_changes[chunk] = {}
                        self.server_chunk_changes[chunk][(lx, ly, lz)] = b_id

                        if chunk in self.world_state:
                            self.set_block_at(bx, by, bz, b_id)

                    event["type"] = "water_consensus_sync"
                    event["water_data"] = event.get("water_changes", {})

                elif event["type"] == "water_consensus_sync":
                    if not hasattr(self, 'server_water_changes'): self.server_water_changes = {}
                    updates_by_chunk = {}
                    for coord_str, vol in event.get("water_data", {}).items():
                        wx, wy, wz = map(int, coord_str.split(','))
                        cx, cy, cz = wx // self.con.CHUNK_SIZE, wy // self.con.CHUNK_SIZE, wz // self.con.CHUNK_SIZE
                        lx, ly, lz = wx % self.con.CHUNK_SIZE, wy % self.con.CHUNK_SIZE, wz % self.con.CHUNK_SIZE
                        chunk = (cx, cy, cz)

                        if chunk not in self.server_water_changes: self.server_water_changes[chunk] = {}
                        self.server_water_changes[chunk][(lx, ly, lz)] = vol

                        if chunk not in updates_by_chunk: updates_by_chunk[chunk] = {}
                        updates_by_chunk[chunk][(lx, ly, lz)] = vol

                    for chunk, local_updates in updates_by_chunk.items():
                        if chunk in self.world_state:
                            water_data = self.water_state.get(chunk)
                            if water_data is None:
                                water_array = np.zeros((self.con.CHUNK_SIZE,) * 3, dtype=np.float32)
                                self.water_state[chunk] = WaterData(
                                    vol=water_array,
                                )
                            else:
                                water_array = water_data.vol

                            for (lx, ly, lz), vol in local_updates.items():
                                water_array[lx, ly, lz] = vol

                            if chunk not in self.fluid_simulators:
                                ghost_solid, ghost_water = self.build_ghosted_arrays(
                                    chunk, self.world_state, self.water_state
                                )
                                self.dirty_chunks.add(chunk)
                                sim = ChunkFluidSimulator()
                                sim.initialize_gpu_memory(ghost_water, ghost_solid)
                                self.fluid_simulators[chunk] = sim
                            else:
                                self.fluid_simulators[chunk].inject_server_state(local_updates)

                            if chunk in self.chunk_data:
                                self.chunk_data[chunk]['water_dirty'] = True
                                self.chunk_data[chunk]['water_settle_time'] = self.current_engine_time

                elif event["type"] == "request_fluid_state":
                    cx, cy, cz = event["chunk"]
                    chunk = (cx, cy, cz)
                    if (chunk in self.fluid_simulators and
                            self.chunk_data.get(chunk, {}).get('water_dirty', False)
                    ):
                        water_volume = self.water_state[chunk].vol
                        wx_idx, wy_idx, wz_idx = np.nonzero(water_volume > 0.0)
                        active_data = {}
                        for i in range(len(wx_idx)):
                            lx, ly, lz = wx_idx[i], wy_idx[i], wz_idx[i]
                            active_data[
                                (f"{(cx * self.con.CHUNK_SIZE) + lx},"
                                 f"{(cy * self.con.CHUNK_SIZE) + ly},"
                                 f"{(cz * self.con.CHUNK_SIZE) + lz}")] = (round(float(water_volume[lx, ly, lz]), 2))
                        if active_data:
                            try:
                                self.network.sock.sendto(json.dumps(
                                    {"type": "relay_fluid_state", "target_id": event["target"],
                                     "water_data": active_data}).encode('utf-8'), self.network.server_addr)
                            except Exception:
                                pass

    def update_chunks(self):
        pos = self.controller.get_position()
        cx, cy, cz = (
            int(pos.x // self.con.CHUNK_SIZE),
            int(pos.y // self.con.CHUNK_SIZE),
            int(pos.z // self.con.CHUNK_SIZE)
        )

        # --- 1. UNLOAD DISTANT CHUNKS ---
        unload_dist = 8  # Slightly larger than render_dist so we don't rapidly load/unload
        chunks_to_remove = []

        for chunk_coord in list(self.chunk_data.keys()):
            nx, ny, nz = chunk_coord
            if abs(nx - cx) > unload_dist or abs(ny - cy) > unload_dist or abs(nz - cz) > unload_dist:
                chunks_to_remove.append(chunk_coord)

        for coord in chunks_to_remove:
            # 1. Save block data to disk IN THE BACKGROUND
            if coord in self.world_state:
                # Copy the array so the thread has its own version to save safely
                volume_copy = self.world_state[coord].copy()

                if coord in self.water_state:
                    water_copy = self.water_state[coord].vol.copy()
                else:
                    water_copy = np.zeros((
                        self.con.CHUNK_SIZE,
                        self.con.CHUNK_SIZE,
                        self.con.CHUNK_SIZE),
                        dtype=np.float32
                    )

                # Pass both arrays to the background saver!
                save_chunk_to_disk_threaded(*coord, volume_copy, water_copy)

                del self.world_state[coord]

            if coord in self.water_state:
                del self.water_state[coord]

            # 2. Free ALL VAOs and VBOs safely!
            if coord in self.chunk_data:
                chunk_data = self.chunk_data[coord]
                for key in ('cube', 'sprite', 'water'):
                    # Destroy the VAO
                    if key in chunk_data:
                        chunk_data[key][0].release()
                    # Destroy the VBO!
                    if f'{key}_vbo_obj' in chunk_data:
                        chunk_data[f'{key}_vbo_obj'].release()

                del self.chunk_data[coord]

            if coord in self.fluid_simulators:
                del self.fluid_simulators[coord]

            if coord in self.requested_chunks:
                self.requested_chunks.remove(coord)

        self._pending_unloads.extend(
            c for c in chunks_to_remove if c not in self._pending_unloads
        )

        # Set dirty for frustum cleanup
        self._frustum_dirty = True

        # --- LOAD NEARBY CHUNKS ---
        current_chunk_pos = (cx, cy, cz)
        if current_chunk_pos == self.last_chunk_pos: return
        self.last_chunk_pos = current_chunk_pos

        render_dist_h, render_dist_v = 6, 5
        new_discoveries = False

        for nx in range(cx - render_dist_h, cx + render_dist_h + 1):
            for ny in range(cy - render_dist_v, cy + render_dist_v + 1):
                for nz in range(cz - render_dist_h, cz + render_dist_h + 1):
                    chunk_coord = (nx, ny, nz)
                    if (chunk_coord not
                            in self.chunk_data and chunk_coord not
                            in self.requested_chunks and chunk_coord not
                            in self.pending_chunk_requests
                    ):
                        self.pending_chunk_requests.append(chunk_coord)
                        new_discoveries = True

        if new_discoveries:
            # Sort so we load chunks closest to the player first
            self.pending_chunk_requests.sort(
                key=lambda c: (c[0] - cx) ** 2 + (c[1] - cy) ** 2 + (c[2] - cz) ** 2, reverse=True
            )

    def _drain_pending_unloads(self, budget: int = 2):
        """Unloads at most `budget` chunks per frame to prevent unload spikes."""
        for _ in range(min(budget, len(self._pending_unloads))):
            coord = self._pending_unloads.pop(0)

            # Guard — player may have moved back into range before drain ran
            cx, cy, cz = coord
            pos = self.controller.get_position()
            pcx = int(pos.x // self.con.CHUNK_SIZE)
            pcy = int(pos.y // self.con.CHUNK_SIZE)
            pcz = int(pos.z // self.con.CHUNK_SIZE)
            unload_dist = 8

            if (abs(cx - pcx) <= unload_dist and
                    abs(cy - pcy) <= unload_dist and
                    abs(cz - pcz) <= unload_dist):
                continue  # Player came back — skip unload

            if coord in self.world_state:
                volume_copy = self.world_state[coord].copy()
                water_copy = self.water_state[coord].vol.copy() \
                    if coord in self.water_state \
                    else np.zeros((self.con.CHUNK_SIZE,) * 3, dtype=np.float32)
                save_chunk_to_disk_threaded(*coord, volume_copy, water_copy)
                del self.world_state[coord]

            if coord in self.water_state:        del self.water_state[coord]
            if coord in self.fluid_simulators:   del self.fluid_simulators[coord]
            if coord in self.requested_chunks:   self.requested_chunks.remove(coord)

            if coord in self.chunk_data:
                old = self.chunk_data[coord]
                for key in ('cube', 'sprite', 'water'):
                    if key in old:              old[key][0].release()
                    if f'{key}_vbo_obj' in old: old[f'{key}_vbo_obj'].release()
                del self.chunk_data[coord]

            self._frustum_dirty = True

    def dispatch_pending_chunks(self, current_time):
        if current_time - self.last_chunk_request_time < self.const.CHUNK_PIPELINE_DELAY: return

        if self.pending_chunk_requests:
            nx, ny, nz = self.pending_chunk_requests.pop()
            self.requested_chunks.add((nx, ny, nz))
            chunk_coord = (nx, ny, nz)

            # --- Grab any server edits we have vaulted in RAM ---
            block_overrides = getattr(self, 'server_chunk_changes', {}).get(chunk_coord, {})
            water_overrides = getattr(self, 'server_water_changes', {}).get(chunk_coord, {})

            # Pass them to the background thread!
            fetch_chunk_threaded(nx, ny, nz, block_overrides, water_overrides)

            self.last_chunk_request_time = current_time

    def _render_3d_world(self, view_matrix, day_factor):
        """Handles frustum culling and draws opaque terrain and opaque water."""
        drawn_chunks = []
        pos = self.controller.get_position()
        front = self.controller.front
        px, py, pz = pos.x, pos.y, pos.z

        player_chunk = (
            int(px // self.con.CHUNK_SIZE),
            int(py // self.con.CHUNK_SIZE),
            int(pz // self.con.CHUNK_SIZE),
        )

        # Rebuild sorted list only when the player crosses a chunk boundary
        if player_chunk != self._last_frustum_chunk or self._frustum_dirty:
            self._sorted_chunk_coords = sorted(
                self.chunk_data.keys(),
                key=lambda c: (c[0] - player_chunk[0]) ** 2 +
                              (c[1] - player_chunk[1]) ** 2 +
                              (c[2] - player_chunk[2]) ** 2
            )
            self._last_frustum_chunk = player_chunk
            self._frustum_dirty = False

        # PASS 1: OPAQUE BLOCKS
        self.ctx.enable(moderngl.DEPTH_TEST | moderngl.CULL_FACE)
        self.ctx.depth_mask = True

        for chunk_coord in self._sorted_chunk_coords:
            if chunk_coord not in self.chunk_data:
                continue  # was unloaded since last sort
            chunk_render_data = self.chunk_data[chunk_coord]
            cx, cy, cz = chunk_coord

            dx = cx * self.con.CHUNK_SIZE + self.con.CHUNK_SIZE / 2 - px
            dy = cy * self.con.CHUNK_SIZE + self.con.CHUNK_SIZE / 2 - py
            dz = cz * self.con.CHUNK_SIZE + self.con.CHUNK_SIZE / 2 - pz
            dist_sq = dx * dx + dy * dy + dz * dz
            is_near = dist_sq < (self.con.CHUNK_SIZE * 2) ** 2

            is_visible = False
            if not is_near:
                dot_raw = dx * front[0] + dy * front[1] + dz * front[2]
                if dot_raw > 0:
                    is_visible = (dot_raw * dot_raw) > (0.09 * dist_sq)

            if not (is_near or is_visible):
                continue

            drawn_chunks.append(chunk_coord)
            if 'cube' in chunk_render_data:
                vao, count = chunk_render_data['cube']
                vao.render(moderngl.TRIANGLES, instances=count)
            if 'sprite' in chunk_render_data:
                vao, count = chunk_render_data['sprite']
                vao.render(moderngl.TRIANGLES, instances=count)

        # --- PASS 2: WATER (opaque, no blend) ---
        if hasattr(self, 'shaders') and hasattr(self.shaders, 'water'):
            self.shaders.water['m_view'].write(view_matrix.astype('f4').tobytes())
            self.shaders.water['m_model'].write(self.model_matrix.astype('f4').tobytes())
            self.shaders.water['u_day_factor'].value = float(day_factor)
            self.shaders.water['m_proj'].write(self.proj_matrix.astype('f4').tobytes())
            if 'u_time' in self.shaders.water:
                self.shaders.water['u_time'].value = float(self.current_engine_time)

            WATER_DRAW_DIST_SQ = (self.con.CHUNK_SIZE * 6) ** 2

            for chunk_coord in drawn_chunks:
                if 'water' not in self.chunk_data[chunk_coord]:
                    continue
                cx, cy, cz = chunk_coord
                dx = (cx * self.con.CHUNK_SIZE + self.con.CHUNK_SIZE / 2) - pos.x
                dy = (cy * self.con.CHUNK_SIZE + self.con.CHUNK_SIZE / 2) - pos.y
                dz = (cz * self.con.CHUNK_SIZE + self.con.CHUNK_SIZE / 2) - pos.z
                if dx * dx + dy * dy + dz * dz > WATER_DRAW_DIST_SQ:
                    continue
                vao, count = self.chunk_data[chunk_coord]['water']
                vao.render(moderngl.TRIANGLES, instances=count)

            # Restore depth mask before entities draw
            self.ctx.depth_mask = True
            self.ctx.disable(moderngl.BLEND)
            self.ctx.enable(moderngl.CULL_FACE)

        return drawn_chunks

    def _felling_check(self, start_x, start_y, start_z):
        tree_blocks = [6, 9, 7, 10]
        to_check = [(start_x, start_y + 1, start_z)]
        checked = set()

        while to_check:
            if len(checked) >= self.const.MAX_TREE_BLOCKS:  # <-- the cap
                break
            cx, cy, cz = to_check.pop(0)
            if (cx, cy, cz) in checked:
                continue
            checked.add((cx, cy, cz))

            cid = self.get_block_at(cx, cy, cz)
            if cid in tree_blocks:
                # Break it and spawn drop
                self.set_block_at(cx, cy, cz, 0)
                self.item_renderer.add_drop(cx, cy, cz, cid)

                # Sync the chain-reaction breaks
                if hasattr(self, 'network') and getattr(self, 'is_multiplayer', True):
                    self.network.send_block_update(self.my_player_id, cx, cy, cz, 0)

                # Add neighbors to the queue (mostly upwards and outwards for leaves)
                for nx in [-1, 0, 1]:
                    for ny in [0, 1]:  # Only search level and upwards
                        for nz in [-1, 0, 1]:
                            if nx == 0 and ny == 0 and nz == 0: continue
                            to_check.append((cx + nx, cy + ny, cz + nz))

    def _render_entities_and_effects(self, view_matrix, current_time, day_factor, frame_time=0.016):
        """Draws players, ghosts, item drops, lasers, FPS hand models, and arachnoids."""
        pos = self.controller.get_position()
        front = self.controller.front

        if hasattr(self, 'shaders'):
            self.shaders.entity['u_camera_pos'].write(pos.astype('f4').tobytes())
            self.shaders.entity['u_torch_active'].value = 1.0 if self.torch_on else 0.0
            self.shaders.entity['u_day_factor'].value = float(day_factor)

        player_rotation_y = math.atan2(-front[0], front[2])

        # ── Local Player TPS ──────────────────────────────────────────
        if self.camera_mode == 'TPS' and self.active_character_id in self.characters:
            active_char = self.characters[self.active_character_id]
            active_char.position = pyrr.Vector3([float(pos[0]), float(pos[1]) - 1.5, float(pos[2])])
            active_char.rotation_y = player_rotation_y + math.pi

            is_walking = (self.wnd.is_key_pressed(self.wnd.keys.W) or
                          self.wnd.is_key_pressed(self.wnd.keys.A) or
                          self.wnd.is_key_pressed(self.wnd.keys.S) or
                          self.wnd.is_key_pressed(self.wnd.keys.D))
            is_sprinting = is_walking and self.wnd.is_key_pressed(self.wnd.keys.LEFT_SHIFT)
            is_firing = self.wnd.mouse_states.left

            # Track health drops for hit-reaction animation
            hp = self.controller.health
            if not hasattr(self, '_prev_player_hp'):
                self._prev_player_hp = hp

            if hp <= 0:
                active_char.play(SkinnedCharacter.ANIM_DEATH, loop=False)
            elif hp < self._prev_player_hp:
                active_char.play(SkinnedCharacter.ANIM_HIT, loop=False, restart=True)
            elif not active_char.anim_finished:
                pass  # let one-shot animations (hit, death) finish uninterrupted
            else:
                if is_sprinting and is_firing:
                    active_char.play(SkinnedCharacter.ANIM_RUN_SHOOT)
                elif is_sprinting:
                    active_char.play(SkinnedCharacter.ANIM_RUN)
                elif is_walking and is_firing:
                    active_char.play(SkinnedCharacter.ANIM_WALK)
                elif is_walking:
                    active_char.play(SkinnedCharacter.ANIM_WALK)
                elif is_firing:
                    active_char.play(SkinnedCharacter.ANIM_SHOOT)
                else:
                    active_char.play(SkinnedCharacter.ANIM_IDLE)

            self._prev_player_hp = hp
            active_char.update_and_render(self.proj_matrix, view_matrix, frame_time, current_time)

        # ── Remote Human Players ──────────────────────────────────────
        if hasattr(self, 'network') and getattr(self, 'is_multiplayer', True):
            self.network.send_position(
                self.my_player_id, float(pos[0]), float(pos[1]), float(pos[2]), player_rotation_y
            )
            for p_id, p_data in self.network.remote_players.copy().items():
                if p_id == self.my_player_id:
                    continue
                if p_id not in self.characters:
                    is_villager = p_data.get("npc_type") == "villager"
                    colormap = 'art/textures/colors/villager.png' if is_villager else None
                    self.characters[p_id] = SkinnedCharacter(
                        self,
                        'art/models/entities/players/blockman.glb',
                        texture_path=colormap
                    )
                    self._remote_last_pos[p_id] = (p_data['x'], p_data['z'])

                ghost = self.characters[p_id]
                ghost.position = pyrr.Vector3([p_data['x'], p_data['y'] - 1.5, p_data['z']])
                ghost.rotation_y = p_data['r']

                last = self._remote_last_pos.get(p_id, (p_data['x'], p_data['z']))
                dx, dz = p_data['x'] - last[0], p_data['z'] - last[1]
                remote_speed = math.hypot(dx, dz) / max(frame_time, 0.001)
                self._remote_last_pos[p_id] = (p_data['x'], p_data['z'])

                if remote_speed > 0.15:
                    ghost.play(SkinnedCharacter.ANIM_WALK)
                else:
                    ghost.play(SkinnedCharacter.ANIM_IDLE)

                ghost.update_and_render(self.proj_matrix, view_matrix, frame_time, current_time)

        max_threat = 0.0
        player_pos = pyrr.Vector3([float(pos[0]), float(pos[1]), float(pos[2])])

        for mid, m_data in list(getattr(self.network, 'remote_monsters', {}).items()):
            model = self.monster_models.get(mid)
            if model is None:
                continue

            model.position = [m_data['x'], m_data['y'] - 1.5, m_data['z']]
            model.rotation_y = m_data.get('r', 0.0)

            model.is_charging = m_data.get('charging', False)
            model.is_firing = m_data.get('firing', False)

            if model.is_charging or model.is_firing:
                model.fire_at(player_pos, current_time)
            else:
                model.orb.stop()

            is_moving = m_data.get('state', 'IDLE') not in ('IDLE', 'IGNORE')
            model.render(self.proj_matrix, view_matrix, current_time, is_moving=is_moving)

            # Threat level: full strength at 0 blocks, zero at 20 blocks
            if model.is_charging:
                dist = math.hypot(m_data['x'] - pos[0], m_data['z'] - pos[2])
                threat = max(0.0, 1.0 - dist / 20.0)
                max_threat = max(max_threat, threat)

        self._charge_threat = max_threat  # read by the UI pass

        # ── Item Drops & Effects ──────────────────────────────────────
        if hasattr(self, 'item_renderer'):
            self.item_renderer.update_and_render(
                0.016, current_time, self.get_block_at,
                self.proj_matrix, view_matrix, self.assets.block_texture_array
            )
        if hasattr(self, 'laser_effect'):
            self.laser_effect.render(self.proj_matrix, view_matrix, current_time)

        # ── FPS Hand Models ───────────────────────────────────────────
        if self.camera_mode == 'FPS':
            is_moving = (self.controller.is_flying or abs(self.controller.velocity_y) > 0.1
                         or self.wnd.is_key_pressed(self.wnd.keys.W))
            active_slot = self.inventory[self.active_hotbar_slot]
            selected_id = active_slot['id']

            if selected_id in [self.ITEM_WOODEN_BUCKET_EMPTY, self.ITEM_WOODEN_BUCKET_WATER] \
                    and hasattr(self, 'bucket_model'):
                self.bucket_model.render_fps(self.proj_matrix, current_time, is_moving)
            elif hasattr(self, 'blaster'):
                self.blaster.render_fps(self.proj_matrix, current_time, is_moving)

    def _render_2d_ui(self, view_matrix, frame_time, camera_eye):
        w, h = self.wnd.size
        ui_proj = self._ui_proj

        self.ctx.disable(moderngl.DEPTH_TEST)
        self.ctx.enable(moderngl.BLEND)
        self.ctx.blend_func = moderngl.SRC_ALPHA, moderngl.ONE_MINUS_SRC_ALPHA

        # Underwater overlay — first so everything else draws on top
        if self._is_camera_in_water(camera_eye):
            pulse = 0.18 + math.sin(self.current_engine_time * 1.2) * 0.04
            self.ui_renderer.draw_color_rect(0, 0, w, h, (0.02, 0.12, 0.45, pulse), ui_proj)

        threat = getattr(self, '_charge_threat', 0.0)
        if threat > 0.01:
            pulse = 0.5 + 0.5 * abs(math.sin(self.current_engine_time * (4.0 + threat * 6.0)))
            intensity = threat * pulse
            edge_color = (0.75, 0.04, 0.0, intensity * 0.72)
            bar_w = int(w * 0.18)
            bar_h = int(h * 0.18)
            # Four screen-edge bars — simulates a threat vignette / charge blur
            self.ui_renderer.draw_color_rect(0, 0, bar_w, h, edge_color, ui_proj)
            self.ui_renderer.draw_color_rect(w - bar_w, 0, bar_w, h, edge_color, ui_proj)
            self.ui_renderer.draw_color_rect(0, 0, w, bar_h, edge_color, ui_proj)
            self.ui_renderer.draw_color_rect(0, h - bar_h, w, bar_h, edge_color, ui_proj)

        # --- FOCUS MODE SCOPE OVERLAY ---
        # Two dark letterbox bars that slide in as the FOV lerps down.
        # Bar height scales with how close _active_fov is to FOCUS_FOV
        # so the overlay animates in sync with the zoom.
        if self.camera_mode == 'FPS':
            fov_progress = max(0.0, min(1.0,
                                        (self.const.BASE_FOV - self._active_fov) /
                                        (self.const.BASE_FOV - self.const.FOCUS_FOV)
                                        ))
            if fov_progress > 0.01:
                bar_h = int(h * 0.14 * fov_progress)
                bar_alpha = 0.92 * fov_progress
                # Top bar
                self.ui_renderer.draw_color_rect(0, h - bar_h, w, bar_h,
                                                 (0.0, 0.0, 0.0, bar_alpha), ui_proj)
                # Bottom bar
                self.ui_renderer.draw_color_rect(0, 0, w, bar_h,
                                                 (0.0, 0.0, 0.0, bar_alpha), ui_proj)
                # Thin green scope reticle lines (horizontal + vertical hair)
                line_alpha = 0.55 * fov_progress
                line_w, line_h = int(w * 0.12), 1
                cx_s, cy_s = w // 2, h // 2
                self.ui_renderer.draw_color_rect(cx_s - line_w, cy_s, line_w - 6, line_h,
                                                 (0.2, 1.0, 0.2, line_alpha), ui_proj)
                self.ui_renderer.draw_color_rect(cx_s + 6, cy_s, line_w - 6, line_h,
                                                 (0.2, 1.0, 0.2, line_alpha), ui_proj)
                self.ui_renderer.draw_color_rect(cx_s, cy_s - line_w, line_h, line_w - 6,
                                                 (0.2, 1.0, 0.2, line_alpha), ui_proj)
                self.ui_renderer.draw_color_rect(cx_s, cy_s + 6, line_h, line_w - 6,
                                                 (0.2, 1.0, 0.2, line_alpha), ui_proj)

        # Crosshair Projection
        hit_coord = self._frame_hit
        crosshair_size = 32
        target_screen_x, target_screen_y = w / 2, h / 2

        if hit_coord:
            block_center = np.array([hit_coord[0], hit_coord[1], hit_coord[2], 1.0], dtype='f4')
            view_proj = pyrr.matrix44.multiply(view_matrix, self.proj_matrix)
            clip_coord = np.dot(block_center, view_proj)
            if clip_coord[3] > 0:
                ndc = clip_coord[:3] / clip_coord[3]
                target_screen_x = ((ndc[0] + 1.0) / 2.0) * w
                target_screen_y = ((ndc[1] + 1.0) / 2.0) * h

        self.ui_renderer.draw_sprite('crosshair', target_screen_x - (crosshair_size / 2),
                                     target_screen_y - (crosshair_size / 2), crosshair_size, crosshair_size, ui_proj)

        # Hotbar
        slot_size, padding = 48, 4
        hotbar_width = (10 * slot_size) + (9 * padding)
        start_x = (w / 2) - (hotbar_width / 2)
        hotbar_y = 56

        for i in range(10):
            x = start_x + (i * (slot_size + padding))
            self.ui_renderer.draw_sprite('slot_bg', x, hotbar_y, slot_size, slot_size, ui_proj)
            slot_data = self.inventory[i]
            if slot_data['id'] > 0:
                self.ui_renderer.draw_sprite(f"block_{slot_data['id']}", x + 6, hotbar_y + 6, slot_size - 12,
                                             slot_size - 12, ui_proj)
                text_tex = self.ui_renderer.get_text_texture(slot_data['count'])
                self.ui_renderer.draw_sprite(text_tex, x + 16, hotbar_y + 2, 32, 32, ui_proj)

        # Health & Stamina
        heart_size, heart_padding, hearts_y = 24, 2, 20
        hp, stm = self.controller.health, self.controller.stamina

        for i in range(10):
            remainder = hp - (i * 10)
            state = (
                'full' if remainder >= 10 else
                'three_quarters' if remainder >= 7.5 else
                'half' if remainder >= 5.0 else
                'quarter' if remainder >= 2.5 else
                'empty'
            )
            self.ui_renderer.draw_sprite(
                f'heart_{state}',
                start_x + (i * (heart_size + heart_padding)),
                hearts_y, heart_size, heart_size, ui_proj
            )

        stm_start_x = (start_x + hotbar_width) - ((10 * heart_size) + (9 * heart_padding))
        for i in range(10):
            remainder = stm - (i * 10)
            state = (
                'full' if remainder >= 10 else
                'three_quarters' if remainder >= 7.5 else
                'half' if remainder >= 5.0 else
                'quarter' if remainder >= 2.5 else
                'empty'
            )
            self.ui_renderer.draw_sprite(
                f'stamina_{state}',
                stm_start_x + (i * (heart_size + heart_padding)),
                hearts_y, heart_size, heart_size, ui_proj
            )

        # Inventory Grid
        if getattr(self, 'show_inventory', False):
            inv_cols, inv_rows = 10, 4
            inv_width = (inv_cols * slot_size) + ((inv_cols - 1) * padding)
            inv_start_x = (w / 2) - (inv_width / 2)
            inv_start_y = hotbar_y + slot_size + 40

            for row in range(inv_rows):
                for col in range(inv_cols):
                    x = inv_start_x + (col * (slot_size + padding))
                    y = inv_start_y + (row * (slot_size + padding))
                    inv_index = 10 + (row * inv_cols) + col

                    self.ui_renderer.draw_sprite('slot_bg', x, y, slot_size, slot_size, ui_proj)
                    slot_data = self.inventory[inv_index]
                    if slot_data['id'] > 0:
                        self.ui_renderer.draw_sprite(f"block_{slot_data['id']}", x + 6, y + 6, slot_size - 12,
                                                     slot_size - 12, ui_proj)
                        text_tex = self.ui_renderer.get_text_texture(slot_data['count'])
                        self.ui_renderer.draw_sprite(text_tex, x + 16, y + 2, 32, 32, ui_proj)

        # --- Chat ---
        chat_x = 20
        chat_base_y = 120

        # Render History (Only show recent messages unless typing)
        # Ensure we use msg[0] for the timestamp tuple index!
        visible_chat = [msg for msg in getattr(self, 'chat_history', [])
                        if self.current_engine_time - msg[0] < 15.0 or getattr(self, 'is_typing', False)]

        # Dynamic stacking offset
        current_y_offset = chat_base_y + 30

        for i, (timestamp, name, text) in enumerate(reversed(visible_chat)):
            age = self.current_engine_time - timestamp
            alpha = 255 if (age < 10.0 or self.is_typing) else int(255 * (1.0 - (age - 10.0) / 5.0))

            # Draw the text and get exactly how tall the bounding box was
            msg_height = self.ui_renderer.draw_text(
                f"chat_msg_{i}", f"[{name}]: {text}",
                chat_x, current_y_offset,
                600, 24,
                ui_proj,
                fg=(255, 255, 255, alpha), bg=(0, 0, 0, int(alpha * 0.5))
            )

            # Push the next older message up by the height of this message + 4px of padding
            current_y_offset += msg_height + 4

        # Render Input Box
        if getattr(self, 'is_typing', False):
            self.ui_renderer.draw_text(
                "chat_input_active", f"> {self.input_text}_",
                chat_x, chat_base_y,
                600, 24,
                ui_proj,
                fg=(0, 255, 0, 255), bg=(0, 0, 0, 200)
            )

        if self.show_profiler:
            report = self.profiler.report()
            for i, (label, ms) in enumerate(report):
                bar = '█' * int(ms * 4)
                text = f'{label:<20} {ms:5.2f}ms  {bar}'
                self.ui_renderer.draw_text(
                    label, text,
                    10, h - 40 - (i * 22),
                    400, 20,
                    ui_proj
                )

        # Reset State
        self.ctx.disable(moderngl.BLEND)
        self.ctx.enable(moderngl.DEPTH_TEST)

    def _is_camera_in_water(self, camera_eye):
        cx = int(math.floor(camera_eye[0])) // self.con.CHUNK_SIZE
        cy = int(math.floor(camera_eye[1])) // self.con.CHUNK_SIZE
        cz = int(math.floor(camera_eye[2])) // self.con.CHUNK_SIZE
        chunk = (cx, cy, cz)
        if chunk not in self.water_state:
            return False
        lx = int(math.floor(camera_eye[0])) % self.con.CHUNK_SIZE
        ly = int(math.floor(camera_eye[1])) % self.con.CHUNK_SIZE
        lz = int(math.floor(camera_eye[2])) % self.con.CHUNK_SIZE
        return self.water_state[chunk].vol[lx, ly, lz] > 0.0

    def _manage_engine_state(self, frame_time, drawn_chunks):
        """Handles UI telemetry and Window Focus/Mouse Capture."""
        # 1. Force the mouse to behave based on inventory state!
        if getattr(self, 'show_inventory', False):
            self.wnd.mouse_exclusivity = False
        else:
            self.wnd.mouse_exclusivity = True

        if not self.engine_started:
            self.wnd.visible = True
            self.wnd.focussed = True
            self.engine_started = True

        # 2. Telemetry
        pos = self.controller.get_position()
        sea_level = 40.0
        dist_km = abs(pos.y - sea_level) / 1000.0
        pos_text = f"Elevation: {dist_km:.2f} km" if pos.y > sea_level else f"Depth: {dist_km:.2f} km"

        fps = 1.0 / frame_time if frame_time > 0 else 0
        hp, stm = int(self.controller.health), int(self.controller.stamina)

        self.wnd.title = (f"TokenTorch | {pos_text} | HP: {hp} | STM: {stm} | "
                          f"FPS: {fps:.0f} | Chunks: {len(drawn_chunks)}/{len(self.chunk_data)}")

    def trigger_offline_fallback(self):
        """Emergency protocol to preserve the player's immediate surroundings when the server dies."""
        if not getattr(self, 'is_multiplayer', True):
            return  # We are already offline!

        print("\n[🚨] SERVER CONNECTION LOST! Initiating Offline Fallback...")
        self.is_multiplayer = False

        # 1. Muzzle the Network Stream
        if hasattr(self, 'network'):
            # Close the socket so we stop throwing UDP packets into the void
            try:
                self.network.sock.close()
            except Exception:
                pass

        # 2. THE RAM DUMP: Force-save every active chunk to the local SQLite disk
        saved_count = 0
        for chunk_coord in list(self.world_state.keys()):
            # Copy the arrays so the background thread doesn't crash if the player edits a block
            volume_copy = self.world_state[chunk_coord].copy()

            if chunk_coord in self.water_state:
                water_copy = self.water_state[chunk_coord].vol.copy()
            else:
                water_copy = (np.zeros((
                    self.con.CHUNK_SIZE,
                    self.con.CHUNK_SIZE,
                    self.con.CHUNK_SIZE), dtype=np.float32)
                )

            # Fire it to the background database worker!
            save_chunk_to_disk_threaded(*chunk_coord, volume_copy, water_copy)
            saved_count += 1

        # 3. Update the UI
        if self.wnd:
            self.wnd.title = f"TokenTorch | [OFFLINE MODE] Saved {saved_count} chunks to local cache."

        print(f"[✔️] RAM Dump Complete! Preserved {saved_count} chunks. Welcome to Single Player.")

    # def on_close(self):
    #print("\n[System] Shutting down client...")
    # ANTI-CHEAT: GRACEFUL WIPE
    # if getattr(self, 'is_multiplayer', False) and hasattr(self, 'active_cache_file'):
    # if os.path.exists(self.active_cache_file):
    # try:
    # time.sleep(0.1)
    # os.remove(self.active_cache_file)
    # print(f"[Security] Successfully burned secure temp cache: {self.active_cache_file}")
    # except Exception as e:
    # print(f"[Security Warning] Failed to burn cache on exit: {e}")

    def build_ghosted_arrays(self, chunk_coord, world_state_dict, water_state_dict):
        """
        Expands a 16x16x16 chunk into an 18x18x18 array by stitching in the 1-block
        perimeter from ALL 26 neighbors (Faces, Edges, and Corners).
        """
        cx, cy, cz = chunk_coord
        GHOST_SIZE = self.con.CHUNK_SIZE + 2

        # Initialize with 1s (Solid) so unloaded void chunks act as walls!
        ghost_solid = np.ones((GHOST_SIZE, GHOST_SIZE, GHOST_SIZE), dtype=np.uint8)
        ghost_water = np.zeros((GHOST_SIZE, GHOST_SIZE, GHOST_SIZE), dtype=np.float32)

        # Stitch own chunk data into the 18x18x18 center
        if chunk_coord in world_state_dict:
            ghost_solid[1:-1, 1:-1, 1:-1] = world_state_dict[chunk_coord]
        if chunk_coord in water_state_dict:
            ghost_water[1:-1, 1:-1, 1:-1] = water_state_dict[chunk_coord].vol

        # Sweep through all 27 permutations (3x3x3 grid)
        for nx, ny, nz in _NEIGHBOR_OFFSETS:
            neighbor_coord = (cx + nx, cy + ny, cz + nz)

            # --- 1. STITCH SOLID BLOCKS ---
            if neighbor_coord in world_state_dict:
                n_solid = world_state_dict[neighbor_coord]

                # Source Slice (From neighbor chunk)
                sx = slice(0, 1) if nx == 1 else slice(-1, None) if nx == -1 else slice(None)
                sy = slice(0, 1) if ny == 1 else slice(-1, None) if ny == -1 else slice(None)
                sz = slice(0, 1) if nz == 1 else slice(-1, None) if nz == -1 else slice(None)

                # Destination Slice (To 18x18x18 Ghost Layer)
                dx = slice(-1, None) if nx == 1 else slice(0, 1) if nx == -1 else slice(1, -1)
                dy = slice(-1, None) if ny == 1 else slice(0, 1) if ny == -1 else slice(1, -1)
                dz = slice(-1, None) if nz == 1 else slice(0, 1) if nz == -1 else slice(1, -1)

                ghost_solid[dx, dy, dz] = n_solid[sx, sy, sz]

            # --- 2. STITCH WATER BLOCKS ---
            if neighbor_coord in water_state_dict:
                water_data = water_state_dict[neighbor_coord]
                n_water = water_data.vol

                sx = slice(0, 1) if nx == 1 else slice(-1, None) if nx == -1 else slice(None)
                sy = slice(0, 1) if ny == 1 else slice(-1, None) if ny == -1 else slice(None)
                sz = slice(0, 1) if nz == 1 else slice(-1, None) if nz == -1 else slice(None)

                dx = slice(-1, None) if nx == 1 else slice(0, 1) if nx == -1 else slice(1, -1)
                dy = slice(-1, None) if ny == 1 else slice(0, 1) if ny == -1 else slice(1, -1)
                dz = slice(-1, None) if nz == 1 else slice(0, 1) if nz == -1 else slice(1, -1)

                ghost_water[dx, dy, dz] = n_water[sx, sy, sz]

        return ghost_solid, ghost_water