synth-ai 0.2.8.dev2__py3-none-any.whl → 0.4.3__py3-none-any.whl

synth_ai/environments/examples/crafter_custom/agent_demos/trace_eval.py

@@ -1,202 +0,0 @@
-#!/usr/bin/env python3
-"""
-Trace evaluation functions for Crafter episodes.
-Scores traces based on achievements and invalid actions.
-"""
-
-import json
-from collections import defaultdict
-from pathlib import Path
-from typing import Any, Dict, List, Tuple
-
-# Scoring weights
-WEIGHTS = {
-    'easy_achievement': 1.0,      # Easy achievement (e.g., collect_wood)
-    'medium_achievement': 2.5,    # Medium achievement (e.g., make_wood_pickaxe)
-    'hard_achievement': 5.0,      # Hard achievement (e.g., make_iron_sword)
-    'invalid_action': -0.05,      # Invalid action penalty (50 invalid = -1 medium achievement)
-}
-
-# Map hook names to scoring categories
-HOOK_TO_SCORE_TYPE = {
-    'easy_achievement': 'easy_achievement',
-    'medium_achievement': 'medium_achievement', 
-    'hard_achievement': 'hard_achievement',
-    'invalid_action': 'invalid_action'
-}
-
-
-def evaluate_event(event: Dict[str, Any]) -> Tuple[float, str]:
-    """
-    Evaluate a single event based on its hooks.
-    Returns: (score, symbol) where symbol is '+', '-', or '0'
-    """
-    score = 0.0
-    symbol = '0'
-    
-    # Check if event has metadata from hooks
-    event_metadata = event.get('event_metadata', [])
-    
-    for metadata in event_metadata:
-        hook_name = metadata.get('hook_name', '')
-        
-        if hook_name in HOOK_TO_SCORE_TYPE:
-            score_type = HOOK_TO_SCORE_TYPE[hook_name]
-            weight = WEIGHTS[score_type]
-            score += weight
-            
-            # Determine symbol
-            if weight > 0:
-                symbol = '+'
-            elif weight < 0:
-                symbol = '-'
-    
-    return score, symbol
-
-
-def evaluate_trace(trace_path: Path) -> Dict[str, Any]:
-    """
-    Evaluate an entire trace file.
-    Returns detailed scoring breakdown and trajectory visualization.
-    """
-    with open(trace_path, 'r') as f:
-        trace_data = json.load(f)
-    
-    # Track counts
-    counts = defaultdict(int)
-    total_score = 0.0
-    trajectory_symbols = []
-    
-    # Process event history
-    event_history = trace_data.get('event_history', [])
-    
-    for event in event_history:
-        event_score, symbol = evaluate_event(event)
-        total_score += event_score
-        
-        # Only add symbol if score is non-zero
-        if event_score != 0:
-            trajectory_symbols.append(symbol)
-        
-        # Count hook types
-        for metadata in event.get('event_metadata', []):
-            hook_name = metadata.get('hook_name', '')
-            if hook_name in HOOK_TO_SCORE_TYPE:
-                score_type = HOOK_TO_SCORE_TYPE[hook_name]
-                counts[score_type] += 1
-    
-    # Create trajectory string
-    trajectory_str = ''.join(trajectory_symbols) if trajectory_symbols else '(no scored events)'
-    
-    return {
-        'total_score': total_score,
-        'counts': dict(counts),
-        'trajectory': trajectory_str,
-        'num_events': len(event_history),
-        'trace_file': trace_path.name
-    }
-
-
-def print_trace_evaluation(eval_result: Dict[str, Any]):
-    """Print a formatted evaluation result for a single trace."""
-    print(f"\n📊 Trace: {eval_result['trace_file']}")
-    print(f"   Score: {eval_result['total_score']:.2f}")
-    print(f"   Events: {eval_result['num_events']}")
-    
-    counts = eval_result['counts']
-    if counts:
-        print("   Breakdown:")
-        if 'easy_achievement' in counts:
-            print(f"     Easy achievements: {counts['easy_achievement']} × {WEIGHTS['easy_achievement']} = {counts['easy_achievement'] * WEIGHTS['easy_achievement']:.2f}")
-        if 'medium_achievement' in counts:
-            print(f"     Medium achievements: {counts['medium_achievement']} × {WEIGHTS['medium_achievement']} = {counts['medium_achievement'] * WEIGHTS['medium_achievement']:.2f}")
-        if 'hard_achievement' in counts:
-            print(f"     Hard achievements: {counts['hard_achievement']} × {WEIGHTS['hard_achievement']} = {counts['hard_achievement'] * WEIGHTS['hard_achievement']:.2f}")
-        if 'invalid_action' in counts:
-            print(f"     Invalid actions: {counts['invalid_action']} × {WEIGHTS['invalid_action']} = {counts['invalid_action'] * WEIGHTS['invalid_action']:.2f}")
-    
-    print(f"   Trajectory: {eval_result['trajectory']}")
-
-
-def evaluate_all_traces(trace_dir: Path, pattern: str = "*.json") -> List[Dict[str, Any]]:
-    """
-    Evaluate all trace files in a directory.
-    Returns list of evaluation results sorted by score.
-    """
-    trace_files = list(trace_dir.glob(pattern))
-    results = []
-    
-    for trace_file in trace_files:
-        try:
-            result = evaluate_trace(trace_file)
-            results.append(result)
-        except Exception as e:
-            print(f"⚠️  Error evaluating {trace_file.name}: {e}")
-    
-    # Sort by score (descending)
-    results.sort(key=lambda x: x['total_score'], reverse=True)
-    
-    return results
-
-
-def print_evaluation_summary(results: List[Dict[str, Any]]):
-    """Print a summary of all trace evaluations."""
-    if not results:
-        print("No traces to evaluate.")
-        return
-    
-    print("\n" + "=" * 80)
-    print("📈 TRACE EVALUATION SUMMARY")
-    print("=" * 80)
-    print(f"{'Rank':<6} {'Score':<10} {'Trajectory':<50} {'File':<30}")
-    print("-" * 80)
-    
-    for i, result in enumerate(results, 1):
-        trajectory = result['trajectory']
-        if len(trajectory) > 50:
-            trajectory = trajectory[:47] + "..."
-        print(f"{i:<6} {result['total_score']:<10.2f} {trajectory:<50} {result['trace_file'][:30]:<30}")
-    
-    print("-" * 80)
-    
-    # Summary statistics
-    scores = [r['total_score'] for r in results]
-    avg_score = sum(scores) / len(scores) if scores else 0
-    max_score = max(scores) if scores else 0
-    min_score = min(scores) if scores else 0
-    
-    print(f"Average Score: {avg_score:.2f}")
-    print(f"Best Score: {max_score:.2f}")
-    print(f"Worst Score: {min_score:.2f}")
-    print("=" * 80)
-
-
-if __name__ == "__main__":
-    import argparse
-    
-    parser = argparse.ArgumentParser(description="Evaluate Crafter trace files")
-    parser.add_argument("trace_path", type=str, help="Directory containing trace files or single trace file")
-    parser.add_argument("--pattern", type=str, default="*.json", help="File pattern to match (for directories)")
-    parser.add_argument("--verbose", action="store_true", help="Show detailed evaluation for each trace")
-    
-    args = parser.parse_args()
-    
-    trace_path = Path(args.trace_path)
-    if not trace_path.exists():
-        print(f"❌ Path not found: {trace_path}")
-        exit(1)
-    
-    # Check if it's a file or directory
-    if trace_path.is_file():
-        print(f"🔍 Evaluating single trace: {trace_path}")
-        result = evaluate_trace(trace_path)
-        print_trace_evaluation(result)
-    else:
-        print(f"🔍 Evaluating traces in: {trace_path}")
-        results = evaluate_all_traces(trace_path, args.pattern)
-        
-        if args.verbose:
-            for result in results:
-                print_trace_evaluation(result)
-        
-        print_evaluation_summary(results)

synth_ai/environments/examples/crafter_custom/crafter/__init__.py

@@ -1,7 +0,0 @@
-from . import constants
-from .config import PRESETS, WorldGenConfig
-from .env import Env
-from .recorder import Recorder
-
-# Note: We don't register with gym since this is a custom version
-# Users should import directly from this module

synth_ai/environments/examples/crafter_custom/crafter/config.py

@@ -1,182 +0,0 @@
-"""
-Configuration system for customizable Crafter environment.
-"""
-
-import json
-import os
-from dataclasses import asdict, dataclass, field
-from typing import Any, Dict, Optional
-
-
-@dataclass
-class WorldGenConfig:
-    """Configuration for world generation parameters."""
-
-    # Material generation thresholds and probabilities
-    coal_threshold: float = 0.0
-    coal_probability: float = 0.15
-    iron_threshold: float = 0.4
-    iron_probability: float = 0.25
-    diamond_threshold: float = 0.18
-    diamond_probability: float = 0.006
-    tree_threshold: float = 0.0
-    tree_probability: float = 0.2
-    lava_threshold: float = 0.35
-
-    # Cave generation
-    cave_threshold: float = 0.6
-
-    # Initial spawn configuration
-    cow_spawn_probability: float = 0.015
-    cow_min_distance: int = 3
-    zombie_spawn_probability: float = 0.007
-    zombie_min_distance: int = 10
-    skeleton_spawn_probability: float = 0.05
-
-    # Dynamic spawn configuration for zombies
-    zombie_spawn_rate: float = 0.3
-    zombie_despawn_rate: float = 0.4
-    zombie_min_spawn_distance: int = 6
-    zombie_max_count: float = 3.5
-    zombie_min_count: float = 0.0
-
-    # Dynamic spawn configuration for skeletons
-    skeleton_spawn_rate: float = 0.1
-    skeleton_despawn_rate: float = 0.1
-    skeleton_min_spawn_distance: int = 7
-    skeleton_max_count: float = 2.0
-    skeleton_min_count: float = 0.0
-
-    # Dynamic spawn configuration for cows
-    cow_spawn_rate: float = 0.01
-    cow_despawn_rate: float = 0.1
-    cow_min_spawn_distance: int = 5
-    cow_max_count: float = 2.5
-    cow_min_count: float = 0.0
-
-    # World generation areas
-    spawn_clear_radius: int = 4
-    water_threshold: float = -0.3
-    sand_threshold: float = -0.2
-    mountain_threshold: float = 0.15
-
-    @classmethod
-    def from_json(cls, path: str) -> "WorldGenConfig":
-        """Load configuration from JSON file."""
-        with open(path, "r") as f:
-            data = json.load(f)
-        return cls(**data)
-
-    @classmethod
-    def from_preset(cls, preset: str) -> "WorldGenConfig":
-        """Load configuration from preset name."""
-        config_dir = os.path.dirname(__file__)
-        preset_path = os.path.join(config_dir, "config", f"{preset}.json")
-        if os.path.exists(preset_path):
-            return cls.from_json(preset_path)
-        else:
-            print(f"Warning: preset '{preset}' not found, using default config")
-            return cls()
-
-    def to_json(self, path: str) -> None:
-        """Save configuration to JSON file."""
-        with open(path, "w") as f:
-            json.dump(asdict(self), f, indent=2)
-
-
-# Preset configurations
-PRESETS = {
-    "easy": WorldGenConfig(
-        # More resources
-        coal_threshold=-0.2,
-        coal_probability=0.25,
-        iron_threshold=0.2,
-        iron_probability=0.35,
-        diamond_threshold=0.15,
-        diamond_probability=0.02,
-        tree_threshold=-0.2,
-        tree_probability=0.35,
-        lava_threshold=0.5,
-        # More friendly spawns
-        cow_spawn_probability=0.03,
-        cow_min_distance=2,
-        zombie_spawn_probability=0.003,
-        zombie_min_distance=15,
-        skeleton_spawn_probability=0.01,
-        # Fewer dynamic enemies
-        zombie_spawn_rate=0.1,
-        zombie_despawn_rate=0.6,
-        zombie_min_spawn_distance=10,
-        zombie_max_count=1.5,
-        skeleton_spawn_rate=0.02,
-        skeleton_despawn_rate=0.3,
-        skeleton_min_spawn_distance=12,
-        skeleton_max_count=0.5,
-        cow_spawn_rate=0.03,
-        cow_despawn_rate=0.05,
-        cow_min_spawn_distance=3,
-        cow_max_count=4.0,
-    ),
-    "hard": WorldGenConfig(
-        # Fewer resources
-        coal_threshold=0.2,
-        coal_probability=0.08,
-        iron_threshold=0.5,
-        iron_probability=0.15,
-        diamond_threshold=0.25,
-        diamond_probability=0.002,
-        tree_threshold=0.2,
-        tree_probability=0.1,
-        lava_threshold=0.25,
-        # More dangerous spawns
-        cow_spawn_probability=0.005,
-        cow_min_distance=5,
-        zombie_spawn_probability=0.02,
-        zombie_min_distance=6,
-        skeleton_spawn_probability=0.15,
-        # Many dynamic enemies
-        zombie_spawn_rate=0.5,
-        zombie_despawn_rate=0.2,
-        zombie_min_spawn_distance=4,
-        zombie_max_count=6.0,
-        skeleton_spawn_rate=0.3,
-        skeleton_despawn_rate=0.05,
-        skeleton_min_spawn_distance=5,
-        skeleton_max_count=4.0,
-        cow_spawn_rate=0.002,
-        cow_despawn_rate=0.2,
-        cow_min_spawn_distance=8,
-        cow_max_count=1.0,
-    ),
-    "peaceful": WorldGenConfig(
-        # Abundant resources
-        coal_threshold=-0.3,
-        coal_probability=0.3,
-        iron_threshold=0.1,
-        iron_probability=0.4,
-        diamond_threshold=0.1,
-        diamond_probability=0.03,
-        tree_threshold=-0.3,
-        tree_probability=0.4,
-        lava_threshold=0.6,
-        # No enemies, many cows
-        cow_spawn_probability=0.05,
-        cow_min_distance=2,
-        zombie_spawn_probability=0.0,
-        zombie_min_distance=100,
-        skeleton_spawn_probability=0.0,
-        # No dynamic enemies
-        zombie_spawn_rate=0.0,
-        zombie_despawn_rate=1.0,
-        zombie_min_spawn_distance=100,
-        zombie_max_count=0.0,
-        skeleton_spawn_rate=0.0,
-        skeleton_despawn_rate=1.0,
-        skeleton_min_spawn_distance=100,
-        skeleton_max_count=0.0,
-        cow_spawn_rate=0.05,
-        cow_despawn_rate=0.02,
-        cow_min_spawn_distance=2,
-        cow_max_count=5.0,
-    ),
-}

synth_ai/environments/examples/crafter_custom/crafter/constants.py

@@ -1,8 +0,0 @@
-import pathlib
-
-import ruamel.yaml
-
-root = pathlib.Path(__file__).parent
-yaml = ruamel.yaml.YAML(typ="safe", pure=True)
-for key, value in yaml.load((root / "data.yaml").read_text()).items():
-    globals()[key] = value

synth_ai/environments/examples/crafter_custom/crafter/engine.py

@@ -1,269 +0,0 @@
-import collections
-import functools
-import pathlib
-
-import imageio.v3 as imageio
-import numpy as np
-from PIL import Image, ImageEnhance
-
-
-class AttrDict(dict):
-    __getattr__ = dict.__getitem__
-
-
-class staticproperty:
-    def __init__(self, function):
-        self.function = function
-
-    def __get__(self, instance, owner=None):
-        return self.function()
-
-
-class World:
-    def __init__(self, area, materials, chunk_size):
-        self.area = area
-        self._chunk_size = chunk_size
-        self._mat_names = {i: x for i, x in enumerate([None] + materials)}
-        self._mat_ids = {x: i for i, x in enumerate([None] + materials)}
-        self.reset()
-
-    def reset(self, seed=None):
-        self.random = np.random.RandomState(seed)
-        self.daylight = 0.0
-        self._chunks = collections.defaultdict(set)
-        self._objects = [None]
-        self._mat_map = np.zeros(self.area, np.uint8)
-        self._obj_map = np.zeros(self.area, np.uint32)
-
-    @property
-    def objects(self):
-        # Return a new list so the objects cannot change while being iterated over.
-        return [obj for obj in self._objects if obj]
-
-    @property
-    def chunks(self):
-        return self._chunks.copy()
-
-    def add(self, obj):
-        assert hasattr(obj, "pos")
-        obj.pos = np.array(obj.pos)
-        assert self._obj_map[tuple(obj.pos)] == 0
-        index = len(self._objects)
-        self._objects.append(obj)
-        self._obj_map[tuple(obj.pos)] = index
-        self._chunks[self.chunk_key(obj.pos)].add(obj)
-
-    def remove(self, obj):
-        if obj.removed:
-            return
-        self._objects[self._obj_map[tuple(obj.pos)]] = None
-        self._obj_map[tuple(obj.pos)] = 0
-        self._chunks[self.chunk_key(obj.pos)].remove(obj)
-        obj.removed = True
-
-    def move(self, obj, pos):
-        if obj.removed:
-            return
-        pos = np.array(pos)
-        assert self._obj_map[tuple(pos)] == 0
-        index = self._obj_map[tuple(obj.pos)]
-        self._obj_map[tuple(pos)] = index
-        self._obj_map[tuple(obj.pos)] = 0
-        old_chunk = self.chunk_key(obj.pos)
-        new_chunk = self.chunk_key(pos)
-        if old_chunk != new_chunk:
-            self._chunks[old_chunk].remove(obj)
-            self._chunks[new_chunk].add(obj)
-        obj.pos = pos
-
-    def __setitem__(self, pos, material):
-        if material not in self._mat_ids:
-            id_ = len(self._mat_ids)
-            self._mat_ids[material] = id_
-        self._mat_map[tuple(pos)] = self._mat_ids[material]
-
-    def __getitem__(self, pos):
-        if not _inside((0, 0), pos, self.area):
-            return None, None
-        material = self._mat_names[self._mat_map[tuple(pos)]]
-        obj = self._objects[self._obj_map[tuple(pos)]]
-        return material, obj
-
-    def nearby(self, pos, distance):
-        (x, y), d = pos, distance
-        ids = set(self._mat_map[x - d : x + d + 1, y - d : y + d + 1].flatten().tolist())
-        materials = tuple(self._mat_names[x] for x in ids)
-        indices = self._obj_map[x - d : x + d + 1, y - d : y + d + 1].flatten().tolist()
-        objs = {self._objects[i] for i in indices if i > 0}
-        return materials, objs
-
-    def mask(self, xmin, xmax, ymin, ymax, material):
-        region = self._mat_map[xmin:xmax, ymin:ymax]
-        return region == self._mat_ids[material]
-
-    def count(self, material):
-        return (self._mat_map == self._mat_ids[material]).sum()
-
-    def chunk_key(self, pos):
-        (x, y), (csx, csy) = pos, self._chunk_size
-        xmin, ymin = (x // csx) * csx, (y // csy) * csy
-        xmax = min(xmin + csx, self.area[0])
-        ymax = min(ymin + csy, self.area[1])
-        return (xmin, xmax, ymin, ymax)
-
-
-class Textures:
-    def __init__(self, directory):
-        self._originals = {}
-        self._textures = {}
-        for filename in pathlib.Path(directory).glob("*.png"):
-            image = imageio.imread(filename.read_bytes())
-            image = image.transpose((1, 0) + tuple(range(2, len(image.shape))))
-            self._originals[filename.stem] = image
-            self._textures[(filename.stem, image.shape[:2])] = image
-
-    def get(self, name, size):
-        if name is None:
-            name = "unknown"
-        size = int(size[0]), int(size[1])
-        key = name, size
-        if key not in self._textures:
-            image = self._originals[name]
-            image = Image.fromarray(image)
-            image = image.resize(size[::-1], resample=Image.NEAREST)
-            image = np.array(image)
-            self._textures[key] = image
-        return self._textures[key]
-
-
-class GlobalView:
-    pass
-
-
-class UncoverView:
-    pass
-
-
-class LocalView:
-    def __init__(self, world, textures, grid):
-        self._world = world
-        self._textures = textures
-        self._grid = np.array(grid)
-        self._offset = self._grid // 2
-        self._area = np.array(self._world.area)
-        self._center = None
-
-    def __call__(self, player, unit):
-        self._unit = np.array(unit)
-        self._center = np.array(player.pos)
-        canvas = np.zeros(tuple(self._grid * unit) + (3,), np.uint8) + 127
-        for x in range(self._grid[0]):
-            for y in range(self._grid[1]):
-                pos = self._center + np.array([x, y]) - self._offset
-                if not _inside((0, 0), pos, self._area):
-                    continue
-                texture = self._textures.get(self._world[pos][0], unit)
-                _draw(canvas, np.array([x, y]) * unit, texture)
-        for obj in self._world.objects:
-            pos = obj.pos - self._center + self._offset
-            if not _inside((0, 0), pos, self._grid):
-                continue
-            texture = self._textures.get(obj.texture, unit)
-            _draw_alpha(canvas, pos * unit, texture)
-        canvas = self._light(canvas, self._world.daylight)
-        if player.sleeping:
-            canvas = self._sleep(canvas)
-        # if player.health < 1:
-        #   canvas = self._tint(canvas, (128, 0, 0), 0.6)
-        return canvas
-
-    def _light(self, canvas, daylight):
-        night = canvas
-        if daylight < 0.5:
-            night = self._noise(night, 2 * (0.5 - daylight), 0.5)
-        night = np.array(ImageEnhance.Color(Image.fromarray(night.astype(np.uint8))).enhance(0.4))
-        night = self._tint(night, (0, 16, 64), 0.5)
-        return daylight * canvas + (1 - daylight) * night
-
-    def _sleep(self, canvas):
-        canvas = np.array(ImageEnhance.Color(Image.fromarray(canvas.astype(np.uint8))).enhance(0.0))
-        canvas = self._tint(canvas, (0, 0, 16), 0.5)
-        return canvas
-
-    def _tint(self, canvas, color, amount):
-        color = np.array(color)
-        return (1 - amount) * canvas + amount * color
-
-    def _noise(self, canvas, amount, stddev):
-        noise = self._world.random.uniform(32, 127, canvas.shape[:2])[..., None]
-        mask = amount * self._vignette(canvas.shape, stddev)[..., None]
-        return (1 - mask) * canvas + mask * noise
-
-    @functools.lru_cache(10)
-    def _vignette(self, shape, stddev):
-        xs, ys = np.meshgrid(np.linspace(-1, 1, shape[0]), np.linspace(-1, 1, shape[1]))
-        return 1 - np.exp(-0.5 * (xs**2 + ys**2) / (stddev**2)).T
-
-
-class ItemView:
-    def __init__(self, textures, grid):
-        self._textures = textures
-        self._grid = np.array(grid)
-
-    def __call__(self, inventory, unit):
-        unit = np.array(unit)
-        canvas = np.zeros(tuple(self._grid * unit) + (3,), np.uint8)
-        for index, (item, amount) in enumerate(inventory.items()):
-            if amount < 1:
-                continue
-            self._item(canvas, index, item, unit)
-            self._amount(canvas, index, amount, unit)
-        return canvas
-
-    def _item(self, canvas, index, item, unit):
-        pos = index % self._grid[0], index // self._grid[0]
-        pos = (pos * unit + 0.1 * unit).astype(np.int32)
-        texture = self._textures.get(item, 0.8 * unit)
-        _draw_alpha(canvas, pos, texture)
-
-    def _amount(self, canvas, index, amount, unit):
-        pos = index % self._grid[0], index // self._grid[0]
-        pos = (pos * unit + 0.4 * unit).astype(np.int32)
-        text = str(amount) if amount in list(range(10)) else "unknown"
-        texture = self._textures.get(text, 0.6 * unit)
-        _draw_alpha(canvas, pos, texture)
-
-
-class SemanticView:
-    def __init__(self, world, obj_types):
-        self._world = world
-        self._mat_ids = world._mat_ids.copy()
-        self._obj_ids = {c: len(self._mat_ids) + i for i, c in enumerate(obj_types)}
-
-    def __call__(self):
-        canvas = self._world._mat_map.copy()
-        for obj in self._world.objects:
-            canvas[tuple(obj.pos)] = self._obj_ids[type(obj)]
-        return canvas
-
-
-def _inside(lhs, mid, rhs):
-    return (lhs[0] <= mid[0] < rhs[0]) and (lhs[1] <= mid[1] < rhs[1])
-
-
-def _draw(canvas, pos, texture):
-    (x, y), (w, h) = pos, texture.shape[:2]
-    if texture.shape[-1] == 4:
-        texture = texture[..., :3]
-    canvas[x : x + w, y : y + h] = texture
-
-
-def _draw_alpha(canvas, pos, texture):
-    (x, y), (w, h) = pos, texture.shape[:2]
-    if texture.shape[-1] == 4:
-        alpha = texture[..., 3:].astype(np.float32) / 255
-        texture = texture[..., :3].astype(np.float32) / 255
-        current = canvas[x : x + w, y : y + h].astype(np.float32) / 255
-        blended = alpha * texture + (1 - alpha) * current
-        texture = (255 * blended).astype(np.uint8)
-    canvas[x : x + w, y : y + h] = texture