Normalize generated sprite scale

app.py

@@ -350,8 +350,9 @@ def build_asset_prompt(role: str, prompt: str, style_hint: str) -> str:
     else:
         asset_instruction = (
             "Create a complete standalone 2D game character or object as a single centered subject. "
-            "Present one complete body in one pose from the required camera direction, fully visible with broad empty "
-            "margin on every side. Use a clean uniform white studio field and a readable game-scale silhouette."
+            "Present one complete body in one pose from the required camera direction. Make the visible subject fill "
+            "about eighty percent of the frame with modest even margins. Use a clean uniform white studio field and "
+            "a readable game-scale silhouette."
         )
     return (
         f"{role} asset: {prompt}. Creative brief: {style_hint}. "
@@ -1733,11 +1734,11 @@ def primary_diffusion_prompt(spec: AssetSpec) -> str:
             f"{camera} Empty playable 2D game environment with connected terrain and clear gameplay space. "
             f"{description}"
         )
-    description = compact_prompt_words(spec.prompt, 24)
+    description = compact_prompt_words(spec.prompt, 18)
     subject = spec.role.replace("_", " ")
     return (
-        f"{camera} Single isolated {subject} subject. One complete body, one pose, centered and fully visible with "
-        f"broad empty margins on a uniform white field. {description}"
+        f"{camera} Single isolated {subject} subject. One complete body, one pose, centered and fully visible. "
+        f"Fill about eighty percent of the frame with modest even margins on a uniform white field. {description}"
     )
 
 
@@ -1784,6 +1785,9 @@ def primary_diffusion_png(spec: AssetSpec, index: int, run_id: int) -> tuple[byt
             if has_implausibly_thin_foreground_subject(content, spec):
                 last_failure_detail = "the last output contained an implausibly thin foreground silhouette"
                 continue
+            if has_undersized_foreground_subject(content):
+                last_failure_detail = "the last output foreground occupied too little of the sprite canvas"
+                continue
             return content, None
 
         return None, f"sprite validation failed after {attempts} model attempts; {last_failure_detail}"
@@ -1882,7 +1886,7 @@ def polish_diffusion_asset(image: Image.Image, spec: AssetSpec) -> bytes:
                 elif dist < 125:
                     a = max(0, min(a, (dist - 64) * 4))
                 pixels[x, y] = (r, g, b, a)
-        image = small.resize((spec.width, spec.height), Image.LANCZOS)
+        image = normalize_sprite_foreground(small, spec)
     else:
         image = image.resize((spec.width, spec.height), Image.LANCZOS)
     out = io.BytesIO()
@@ -1890,9 +1894,9 @@ def polish_diffusion_asset(image: Image.Image, spec: AssetSpec) -> bytes:
     return out.getvalue()
 
 
-def foreground_component_geometry(content: bytes) -> list[tuple[int, tuple[int, int, int, int]]]:
-    """Return alpha-component areas and bounding boxes, largest first."""
-    image = Image.open(io.BytesIO(content)).convert("RGBA")
+def foreground_component_geometry_from_image(image: Image.Image) -> list[tuple[int, tuple[int, int, int, int]]]:
+    """Return alpha-component areas and bounding boxes for an RGBA image, largest first."""
+    image = image.convert("RGBA")
     width, height = image.size
     alpha = image.getchannel("A").tobytes()
     foreground = bytearray(1 if value >= 64 else 0 for value in alpha)
@@ -1934,20 +1938,80 @@ def foreground_component_geometry(content: bytes) -> list[tuple[int, tuple[int,
     return sorted(components, reverse=True)
 
 
-def significant_foreground_component_areas(content: bytes) -> list[int]:
-    """Return material alpha components, ignoring only genuinely small detached details."""
+def foreground_component_geometry(content: bytes) -> list[tuple[int, tuple[int, int, int, int]]]:
+    """Return alpha-component areas and bounding boxes, largest first."""
     image = Image.open(io.BytesIO(content)).convert("RGBA")
-    width, height = image.size
-    components = foreground_component_geometry(content)
+    return foreground_component_geometry_from_image(image)
 
+
+def material_foreground_components_from_image(
+    image: Image.Image,
+) -> list[tuple[int, tuple[int, int, int, int]]]:
+    """Filter alpha components with the same material/noise contract used by validation."""
+    image = image.convert("RGBA")
+    components = foreground_component_geometry_from_image(image)
     if not components:
         return []
     largest = components[0][0]
+    minimum = max(64, int(largest * 0.12), int(image.width * image.height * 0.004))
+    return [(area, bbox) for area, bbox in components if area >= minimum]
+
+
+def significant_foreground_component_areas(content: bytes) -> list[int]:
+    """Return material alpha components, ignoring only genuinely small detached details."""
+    image = Image.open(io.BytesIO(content)).convert("RGBA")
     # A generated miniature duplicate can be much smaller than the primary view.
     # Keep a small absolute/noise floor, but do not discard material components
     # such as the reported 96px duplicate next to a 487px main silhouette.
-    minimum = max(64, int(largest * 0.12), int(width * height * 0.004))
-    return [area for area, _ in components if area >= minimum]
+    return [area for area, _ in material_foreground_components_from_image(image)]
+
+
+def material_foreground_bbox_from_image(image: Image.Image) -> tuple[int, int, int, int] | None:
+    """Return the union bounding box for all material foreground components."""
+    components = material_foreground_components_from_image(image)
+    if not components:
+        return None
+    boxes = [bbox for _, bbox in components]
+    return (
+        min(box[0] for box in boxes),
+        min(box[1] for box in boxes),
+        max(box[2] for box in boxes),
+        max(box[3] for box in boxes),
+    )
+
+
+def normalize_sprite_foreground(image: Image.Image, spec: AssetSpec, target_occupancy: float = 0.88) -> Image.Image:
+    """Scale the model foreground to a stable game-sprite occupancy without changing its shape."""
+    image = image.convert("RGBA")
+    bbox = material_foreground_bbox_from_image(image)
+    if bbox is None:
+        return image.resize((spec.width, spec.height), Image.LANCZOS)
+
+    x0, y0, x1, y1 = bbox
+    padding = max(1, int(min(x1 - x0 + 1, y1 - y0 + 1) * 0.02))
+    crop_box = (
+        max(0, x0 - padding),
+        max(0, y0 - padding),
+        min(image.width, x1 + padding + 1),
+        min(image.height, y1 + padding + 1),
+    )
+    subject = image.crop(crop_box)
+    target_width = max(1, int(spec.width * target_occupancy))
+    target_height = max(1, int(spec.height * target_occupancy))
+    scale = min(target_width / subject.width, target_height / subject.height)
+    resized_width = max(1, int(round(subject.width * scale)))
+    resized_height = max(1, int(round(subject.height * scale)))
+    subject = subject.resize((resized_width, resized_height), Image.LANCZOS)
+
+    normalized = Image.new("RGBA", (spec.width, spec.height), (0, 0, 0, 0))
+    x = (spec.width - resized_width) // 2
+    if spec.camera == "top_down":
+        y = (spec.height - resized_height) // 2
+    else:
+        bottom_margin = max(2, int(spec.height * 0.06))
+        y = max(0, spec.height - resized_height - bottom_margin)
+    normalized.alpha_composite(subject, dest=(x, y))
+    return normalized
 
 
 def has_deep_vertical_foreground_valley(content: bytes) -> bool:
@@ -2012,12 +2076,24 @@ def has_implausibly_thin_foreground_subject(content: bytes, spec: AssetSpec) ->
     bbox_width = x1 - x0 + 1
     bbox_height = y1 - y0 + 1
     return (
-        bbox_width < max(14, int(image.width * 0.12))
+        bbox_width < int(image.width * 0.30)
         and bbox_height >= int(image.height * 0.28)
         and bbox_height >= bbox_width * 3.5
     )
 
 
+def has_undersized_foreground_subject(content: bytes) -> bool:
+    """Detect sprites whose visible model foreground occupies too little of its game canvas."""
+    image = Image.open(io.BytesIO(content)).convert("RGBA")
+    bbox = material_foreground_bbox_from_image(image)
+    if bbox is None:
+        return True
+    x0, y0, x1, y1 = bbox
+    width_ratio = (x1 - x0 + 1) / max(1, image.width)
+    height_ratio = (y1 - y0 + 1) / max(1, image.height)
+    return max(width_ratio, height_ratio) < 0.68
+
+
 def free_diffusion_png(spec: AssetSpec, index: int, run_id: int) -> tuple[bytes | None, str | None]:
     global FREE_DIFFUSION_PIPE, FREE_DIFFUSION_ERROR
     if FREE_DIFFUSION_ERROR:
@@ -2270,6 +2346,8 @@ def validate_asset_png(content: bytes, spec: AssetSpec) -> list[str]:
             warnings.append(f"sprite contains {subject_count} significant foreground subjects")
         elif has_implausibly_thin_foreground_subject(content, spec):
             warnings.append("sprite foreground silhouette is implausibly thin")
+        elif has_undersized_foreground_subject(content):
+            warnings.append("sprite foreground occupies too little of the sprite canvas")
     return warnings
 
 
@@ -2409,7 +2487,8 @@ def model_configuration_summary() -> str:
         f"neural enforcement: `{enforcement}` · primary readiness: `{readiness}`. "
         "Every production image is generated directly from its written prompt by the primary text-to-image model. "
         "Critical camera and subject constraints are placed first inside a conservative CLIP prompt budget. "
-        "Sprite outputs must pass single-subject alpha-component validation and are regenerated with a new seed up to "
+        "Sprite foregrounds are tightly normalized to a consistent game-canvas occupancy, then must pass subject-count, "
+        "silhouette, and scale validation; failures are regenerated with a new seed up to "
         f"{PRIMARY_SPRITE_ATTEMPTS} times. No procedural guide is supplied to the model. The procedural renderer is "
         "development-only and is blocked in the deployed Space when the primary model fails."
     )