Merge pull request #15 from dhcold/dhc/confident-knuth

Share hash, ramp/corner fixes, prop rotation, UI tooltips

Author: dhcold

main.py

@@ -1,13 +1,37 @@
 #!/usr/bin/env python3
 """Turnt-o-mapper -- launch entry point."""
 
+import argparse
 import sys
+
+from PyQt6.QtCore import QTimer
 from PyQt6.QtWidgets import QApplication
 from turnt_o_mapper.app import App, DARK_QSS
 
-if __name__ == "__main__":
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Turnt-o-mapper: Quake3 .map generator for Turnt and Diabotical .rbe converter")
+    parser.add_argument(
+        "--hash", type=str, default=None,
+        help="Apply a tom1_... config hash on startup")
+    parser.add_argument(
+        "--auto-generate", action="store_true",
+        help="Automatically generate after applying --hash")
+    args = parser.parse_args()
+
     app = QApplication(sys.argv)
     app.setStyleSheet(DARK_QSS)
     window = App()
+
+    if args.hash:
+        window._apply_hash(args.hash)
+        if args.auto_generate:
+            QTimer.singleShot(100, window._on_generate)
+
     window.show()
     sys.exit(app.exec())
+
+
+if __name__ == "__main__":
+    main()

turnt_o_mapper/app.py

@@ -13,7 +13,7 @@
 
 from .constants import (
     WALL_T, DOOR_H, HIDDEN_TEX,
-    SLOPE_RATIO, MAX_RAMP_ANGLE, MIN_SLOPE_RATIO,
+    SLOPE_RATIO, MIN_RAMP_ANGLE, MAX_RAMP_ANGLE, MIN_SLOPE_RATIO,
     RAMP_TEX, OUTLINE_W,
 )
 from .layout import _clip_footprint, _clip_intervals
@@ -463,19 +463,16 @@ def wy(ylo, yhi, xlo, xhi, zlo, zhi, lbl):
 
 
 def _adaptive_ramp_len(dz: int, max_available: int) -> int:
-    """Choose ramp horizontal length with a progressive random angle.
+    """Choose ramp horizontal length — as gentle as possible.
 
-    Picks a random target angle between 15 deg and 25 deg, computes the
-    corresponding ramp length, then clamps to the available space.
-    **Never returns more than max_available** — the caller must reduce
-    dz if the resulting angle would exceed 30 deg.
+    Computes the ideal length for the shallowest angle (MIN_RAMP_ANGLE,
+    10°).  If that doesn't fit, uses all available space — the ramp gets
+    steeper but never exceeds 30° (layout caps dz accordingly).
     """
     if max_available <= 0:
         return max(abs(dz), 1)
-    # Random target between 15° and 25° — variety in ramp feel
-    target_angle = random.uniform(15, 25)
-    target_len = int(dz / math.tan(math.radians(target_angle)))
-    return min(target_len, max_available)
+    ideal_len = int(dz / math.tan(math.radians(MIN_RAMP_ANGLE)))
+    return min(ideal_len, max_available)
 
 
 def compute_bridge_footprint(ax, ay, az, bx, by, bz,
@@ -539,14 +536,12 @@ def corridor_brushes(ax, ay, az, bx, by, bz,
         hi_far = rb_far if ax <= bx else ra_far
 
         def _clamp_dz(actual_len, cur_dz, cur_lo, cur_hi):
-            """Reduce dz so the ramp angle never exceeds 30 deg."""
-            if actual_len <= 0:
-                return cur_lo, cur_hi
-            max_dz = int(actual_len / MIN_SLOPE_RATIO)
-            if cur_hi - cur_lo > max_dz:
-                mid = (cur_lo + cur_hi) // 2
-                cur_lo = mid - max_dz // 2
-                cur_hi = mid + max_dz // 2
+            """Keep ramp endpoints pinned to room floors.
+
+            Layout already caps dz so the angle stays reasonable.
+            A steeper-than-ideal ramp is always better than one that
+            floats in the air and cannot be reached via crouchslide.
+            """
             return cur_lo, cur_hi
 
         if axis == 'x':

turnt_o_mapper/brushes.py

@@ -18,7 +18,7 @@
 ALL_TEXTURES: Dict[str, int] = {
     "NULL":2,"common/caulk":2,"common/lavacaulk":4,"common/nodraw":2,
     "common/nodrawnonsolid":2,"common/slick":5,"common/slimecaulk":4,
-    "common/watercaulk":3,"common/weapclip":2,"common/playerclip":2,
+    "common/watercaulk":3,"common/weapclip":2,
     "turnt/temp_blue":8,"turnt/temp_dark":0,"turnt/temp_green":7,
     "turnt/temp_light":1,"turnt/temp_orange":9,"turnt/temp_purple":10,
     "turnt/temp_red":6,"turnt/temp_yellow":11,
@@ -68,10 +68,11 @@
 # ══════════════════════════════════════════════════════════════════════════════
 #  RAMP PHYSICS CONSTANTS
 # ══════════════════════════════════════════════════════════════════════════════
-SLOPE_RATIO    = 3.73  # horizontal / vertical ~= 15deg -- shallowest target
+MIN_RAMP_ANGLE = 10    # degrees -- shallowest (ideal) ramp angle
 MAX_RAMP_ANGLE = 30    # degrees -- steepest allowed ramp
-# Minimum slope ratio that keeps angle <= MAX_RAMP_ANGLE: 1/tan(30deg) ~= 1.732
-MIN_SLOPE_RATIO = 1.0 / math.tan(math.radians(MAX_RAMP_ANGLE))
+# Slope ratios: horizontal / vertical
+SLOPE_RATIO     = 1.0 / math.tan(math.radians(MIN_RAMP_ANGLE))  # ~5.67 for 10°
+MIN_SLOPE_RATIO = 1.0 / math.tan(math.radians(MAX_RAMP_ANGLE))  # ~1.73 for 30°
 
 # ══════════════════════════════════════════════════════════════════════════════
 #  THEME PALETTES

turnt_o_mapper/constants.py

@@ -10,10 +10,96 @@
 """
 
 import math
+import struct
 import sys
 import time
 from typing import Dict, List, Optional
 
+
+# ── Color → texture mapping ──────────────────────────────────────────────────
+# Maps hex RGB colours found on invisible props to the nearest turnt texture.
+
+_COLOR_PALETTE = [
+    # (R, G, B, texture_name)
+    (0,   0,   0,   "turnt/temp_dark"),
+    (255, 255, 255, "turnt/temp_light"),
+    (255, 0,   0,   "turnt/temp_red"),
+    (0,   128, 0,   "turnt/temp_green"),
+    (0,   0,   255, "turnt/temp_blue"),
+    (255, 165, 0,   "turnt/temp_orange"),
+    (128, 0,   128, "turnt/temp_purple"),
+    (255, 255, 0,   "turnt/temp_yellow"),
+    (0,   255, 255, "turnt/turnt_cyan"),
+    (255, 0,   255, "turnt/turnt_magenta"),
+    (0,   255, 128, "turnt/turnt_mint"),
+    (128, 255, 0,   "turnt/turnt_lime"),
+    (255, 215, 0,   "turnt/turnt_gold"),
+    (0,   128, 128, "turnt/turnt_teal"),
+    (128, 0,   255, "turnt/turnt_violet"),
+    (255, 128, 128, "turnt/turnt_coral"),
+    (135, 206, 235, "turnt/turnt_sky"),
+]
+
+# Material name → texture fallback
+_MATERIAL_MAP: Dict[str, str] = {
+    "concrete":    "turnt/turnt_concrete",
+    "asphalt":     "turnt/turnt_asphalt",
+    "tech":        "turnt/turnt_tech",
+    "slick":       "common/slick",
+    "boost":       "turnt/turnt_boost",
+    "speed":       "turnt/turnt_speed",
+    "hazard":      "turnt/turnt_hazard",
+    "checkpoint":  "turnt/turnt_checkpoint",
+    "platform":    "turnt/turnt_platform",
+}
+
+
+def _parse_hex_color(s: str) -> Optional[tuple]:
+    """Parse hex color string (AARRGGBB, RRGGBB, #RRGGBB) → (R, G, B) or None."""
+    s = s.strip().lstrip("#")
+    if not s:
+        return None
+    try:
+        if len(s) == 8:          # AARRGGBB
+            r, g, b = int(s[2:4], 16), int(s[4:6], 16), int(s[6:8], 16)
+        elif len(s) == 6:        # RRGGBB
+            r, g, b = int(s[0:2], 16), int(s[2:4], 16), int(s[4:6], 16)
+        else:
+            return None
+        return (r, g, b)
+    except ValueError:
+        return None
+
+
+def _nearest_texture(r: int, g: int, b: int) -> str:
+    """Find the turnt texture with the closest RGB distance."""
+    best_dist = float("inf")
+    best_tex = "turnt/temp_dark"
+    for pr, pg, pb, tex in _COLOR_PALETTE:
+        d = (r - pr) ** 2 + (g - pg) ** 2 + (b - pb) ** 2
+        if d < best_dist:
+            best_dist = d
+            best_tex = tex
+    return best_tex
+
+
+def _resolve_prop_texture(props: dict, fallback: str) -> str:
+    """Pick a texture for an invisible prop based on color/material properties."""
+    # Material takes priority (exact name match)
+    mat = props.get("material", "").lower()
+    if mat:
+        for key, tex in _MATERIAL_MAP.items():
+            if key in mat:
+                return tex
+
+    # Color fallback — parse hex and find nearest palette entry
+    color_str = props.get("color", "")
+    rgb = _parse_hex_color(color_str)
+    if rgb:
+        return _nearest_texture(*rgb)
+
+    return fallback
+
 # Allow running this file directly (e.g. for quick testing)
 try:
     from .constants import ALL_TEXTURES, NODRAW_TEX
@@ -440,17 +526,17 @@ def rbe_entities_to_map(entities, sx, sy, sz, opaque_tex="turnt/turnt_concrete")
             clip_v  = props.get("clip", "fullclip").lower()
 
             if no_show:
-                prop_tex = "common/clip"
+                prop_tex = _resolve_prop_texture(props, "common/nodraw")
             elif slide_v == "1" or slide_v == "2":
                 prop_tex = "common/slick"
             elif clip_v == "noclip":
                 prop_tex = NODRAW_TEX
             elif clip_v == "playerclip":
-                prop_tex = "common/clip"
+                prop_tex = _resolve_prop_texture(props, "common/nodraw")
             elif clip_v == "weapon":
                 prop_tex = "common/weapclip"
             else:
-                prop_tex = opaque_tex   # fullclip + visible → solid
+                prop_tex = _resolve_prop_texture(props, opaque_tex)
 
             # ── Size: base differs per shape ─────────────────────────
             # All coords in DBT world-units (1 block = 40 X/Z, 20 Y).
@@ -480,18 +566,24 @@ def rbe_entities_to_map(entities, sx, sy, sz, opaque_tex="turnt/turnt_concrete")
             zrot = e.get("zrot", 0.0)
 
             def _rot3d(lx, ly, lz):
-                """Rotate local offset (lx, ly, lz) by xrot/yrot/zrot."""
-                # Yaw (around Q-Z axis = DBT Y-up)
-                cy_, sy_ = math.cos(yrot), math.sin(yrot)
-                x1 =  cy_ * lx + sy_ * ly
-                y1 = -sy_ * lx + cy_ * ly
-                z1 =  lz
-                # Pitch (around Q-X axis = DBT X)
+                """Rotate local offset (lx, ly, lz) by xrot/yrot/zrot.
+
+                The Y↔Z axis swap (DBT→Q3) has determinant -1, so all
+                rotation angles are effectively negated.  Using CW
+                matrices with the original angles achieves this.
+                Order: Pitch → Yaw → Roll.
+                """
+                # Pitch — around Q-X, angle = -xrot
                 cx_, sx_ = math.cos(xrot), math.sin(xrot)
-                x2 =  x1
-                y2 =  cx_ * y1 - sx_ * z1
-                z2 =  sx_ * y1 + cx_ * z1
-                # Roll (around Q-Y axis = DBT Z)
+                x1 =  lx
+                y1 =  cx_ * ly + sx_ * lz
+                z1 = -sx_ * ly + cx_ * lz
+                # Yaw — around Q-Z, angle = -yrot
+                cy_, sy_ = math.cos(yrot), math.sin(yrot)
+                x2 =  cy_ * x1 + sy_ * y1
+                y2 = -sy_ * x1 + cy_ * y1
+                z2 =  z1
+                # Roll — around Q-Y, angle = -zrot
                 cz_, sz_ = math.cos(zrot), math.sin(zrot)
                 x3 =  cz_ * x2 - sz_ * z2
                 y3 =  y2
@@ -571,14 +663,15 @@ def _rotated_box(ox, oy, oz, hx, hy, hz, tex, label):
 
             # ── cylinder ─────────────────────────────────────────────
             elif prop_shape == "cylinder":
-                cyl_ang = e.get("yrot", 0.0)
                 outer_r = max(MIN_HALF, abs(e.get("xscale", 1.0)) * sx * 4)
-                wall_t  = sx / 2.0
-                inner_r = outer_r - wall_t
+                wall_t  = max(4.0, sx / 4.0)
+                inner_r = max(MIN_HALF, outer_r - wall_t)
                 fz_cyl  = max(MIN_HALF, abs(e.get("yscale", 1.0)) * 100 * EFZ)
                 z_bot   = qz - fz_cyl / 2
                 z_top   = qz + fz_cyl / 2
                 arc_step = float(sx)
+                # Quarter circle (π/2) starting at entity yaw
+                cyl_ang = e.get("yrot", 0.0)
                 cyl_strs = cylinder_brushes(
                     qx, qy, z_bot, z_top,
                     inner_r, outer_r,
@@ -672,7 +765,7 @@ def _log(msg, level="plain"):
     CLIP_TEX = {
         2: "common/caulk",
         4: "common/weapclip",
-        5: "common/clip",
+        5: "common/nodraw",
     }
     solid_blocks  = [b for b in blocks if b["type"] == 1]
     corner_blocks = [b for b in blocks if b["type"] == 3]

turnt_o_mapper/dbt_import.py

@@ -10,14 +10,15 @@
 6. Runs connectivity (BFS) and ramp-angle validation.
 7. Places spawn, timer, and checkpoint entities.
 
-Returns ``(map_string, rooms, bridges, warnings)``.
+Returns ``(map_string, rooms, bridges, warnings, share_hash)``.
 """
 
 import math
 import random
 from typing import Dict, List
 
 from .constants import DOOR_H, WALL_T, SLOPE_RATIO, MAX_RAMP_ANGLE, MIN_SLOPE_RATIO
+from .share import encode_cfg
 from .models import Room, Bridge
 from .layout import place_rooms, build_bridges, _snap
 from .brushes import (
@@ -155,10 +156,12 @@ def generate_map(cfg: dict):
         if fp is not None:
             bridge_footprints.append((*fp, br.room_a, br.room_b))
 
+    share_hash = encode_cfg(cfg)
+
     lines = [
         "// Game: Quake 3",
         "// Format: Quake3 (Valve)",
-        f"// Generated by Turnt-o-mapper | rooms={cfg['n_rooms']} seed={seed}",
+        f"// Generated by Turnt-o-mapper | rooms={cfg['n_rooms']} seed={seed} | {share_hash}",
         "{",
         '"classname" "worldspawn"',
         '"mapversion" "220"',
@@ -458,4 +461,4 @@ def generate_map(cfg: dict):
                                 count=str(cp_n)))
             ei += 1
 
-    return "\n".join(lines), rooms, bridges, warnings
+    return "\n".join(lines), rooms, bridges, warnings, share_hash

turnt_o_mapper/generation.py

@@ -224,18 +224,22 @@ def _zone_tex(_zone: int):
 
         room_len, room_cross, room_h, door_hw, u_i = _room_dims_from_physics(i, cfg)
 
-        # Corner rooms: constrain travel dim so the room does not
-        # protrude beyond the footprint of the previous room.
-        # Widen cross dim (1.3x) so there is space for a crouchslide
-        # turn.  The room right after a corner also gets a wider cross.
+        # Corner rooms: constrain dimensions so the room does not
+        # protrude beyond the footprint of its neighbours, eliminating
+        # misleading "tails" that look like valid routes.
+        #   • room_len  (old direction) ≤ width of room X-1
+        #   • room_cross (new direction) ≤ depth of room X+1  (forward-look)
         if is_corner_room and i > 0:
             prev = rooms[i - 1]
             prev_cross = prev.d if prev.travel_axis == 'x' else prev.w
             max_d = cfg.get("max_d", 512)
             room_cross = _snap(min(int(room_cross * 1.3), max_d))
-            # Ensure travel dim (old direction) never exceeds cross (turn
-            # direction) so the "tail" always points toward the new route.
             room_len   = _snap(min(room_len, prev_cross, room_cross))
+            # Forward-look: cap cross to the next room's expected cross
+            # so the corner doesn't extend beyond the post-turn corridor.
+            if i + 1 < n:
+                _next_len, next_cross, *_ = _room_dims_from_physics(i + 1, cfg)
+                room_cross = _snap(min(room_cross, next_cross))
             corr_frac  = cfg.get("corridor_width_frac", 0.67)
             door_hw    = _snap(_clamp(int(room_cross * corr_frac / 2), 32, room_cross // 2))
         elif prev_was_corner_room and i > 0:
@@ -298,6 +302,11 @@ def _zone_tex(_zone: int):
                     half     = max_step // 2
                     dz_choices = [half, max_step, -half, -max_step]
                 dz = random.choice(dz_choices)
+                # Early rooms: up-ramps from room 3+ (i>=2), down-ramps from room 2+ (i>=1)
+                if dz > 0 and i < 2:
+                    dz = 0    # no up-ramps before room 3
+                if dz < 0 and i < 1:
+                    dz = 0    # no down-ramps before room 2 (dead code: i>0 above)
             cz += dz
             cz  = _snap(cz, 32)
             prev_ceil = rooms[i - 1].z1 + rooms[i - 1].h