Level Design Tools

Creating Powerful Level Design Tools

Understanding Level Design Systems

Interactive Level Editor Demo

Level Editor Implementation

import pygame
import json
from enum import Enum
from typing import List, Dict, Optional, Tuple

class ObjectType(Enum):
    """Level object types"""
    PLATFORM = "platform"
    SPIKE = "spike"
    COIN = "coin"
    SPRING = "spring"
    ENEMY = "enemy"
    CHECKPOINT = "checkpoint"
    MOVING_PLATFORM = "moving_platform"
    PORTAL = "portal"

class LevelObject:
    """Base class for level objects"""
    def __init__(self, obj_type: ObjectType, x: float, y: float, 
                 width: float = 32, height: float = 32):
        self.type = obj_type
        self.x = x
        self.y = y
        self.width = width
        self.height = height
        self.properties = {}
        self.selected = False
        
        # Path for moving objects
        self.path = []
        self.path_index = 0
        self.path_progress = 0.0
        
    def get_rect(self) -> pygame.Rect:
        """Get collision rectangle"""
        return pygame.Rect(self.x, self.y, self.width, self.height)
    
    def update(self, dt: float):
        """Update object logic"""
        if self.type == ObjectType.MOVING_PLATFORM and len(self.path) > 1:
            self.update_path_movement(dt)
    
    def update_path_movement(self, dt: float):
        """Update movement along path"""
        if len(self.path) < 2:
            return
        
        speed = self.properties.get('speed', 50)
        current = self.path[self.path_index]
        next_point = self.path[(self.path_index + 1) % len(self.path)]
        
        # Move along path
        self.path_progress += speed * dt / 100
        
        if self.path_progress >= 1.0:
            self.path_progress = 0.0
            self.path_index = (self.path_index + 1) % len(self.path)
        
        # Interpolate position
        t = self.path_progress
        self.x = current[0] + (next_point[0] - current[0]) * t
        self.y = current[1] + (next_point[1] - current[1]) * t
    
    def to_dict(self) -> Dict:
        """Serialize to dictionary"""
        return {
            'type': self.type.value,
            'x': self.x,
            'y': self.y,
            'width': self.width,
            'height': self.height,
            'properties': self.properties,
            'path': self.path
        }
    
    @classmethod
    def from_dict(cls, data: Dict) -> 'LevelObject':
        """Deserialize from dictionary"""
        obj = cls(
            ObjectType(data['type']),
            data['x'],
            data['y'],
            data.get('width', 32),
            data.get('height', 32)
        )
        obj.properties = data.get('properties', {})
        obj.path = data.get('path', [])
        return obj

class LevelEditor:
    """Visual level editor"""
    def __init__(self, screen_width: int, screen_height: int):
        self.screen_width = screen_width
        self.screen_height = screen_height
        
        # Level objects
        self.objects: List[LevelObject] = []
        self.selected_objects: List[LevelObject] = []
        
        # Editor state
        self.mode = 'place'  # place, select, delete, path
        self.current_tool = ObjectType.PLATFORM
        self.grid_size = 32
        self.snap_to_grid = True
        self.show_grid = True
        
        # Camera
        self.camera_x = 0
        self.camera_y = 0
        
        # History for undo/redo
        self.history = []
        self.history_index = -1
        self.max_history = 50
        
        # Clipboard
        self.clipboard = []
        
    def place_object(self, x: float, y: float):
        """Place new object at position"""
        if self.snap_to_grid:
            x = round(x / self.grid_size) * self.grid_size
            y = round(y / self.grid_size) * self.grid_size
        
        # Default sizes for different object types
        sizes = {
            ObjectType.PLATFORM: (64, 32),
            ObjectType.SPIKE: (32, 32),
            ObjectType.COIN: (24, 24),
            ObjectType.SPRING: (32, 32),
            ObjectType.ENEMY: (32, 32),
            ObjectType.CHECKPOINT: (32, 64),
            ObjectType.MOVING_PLATFORM: (64, 32),
            ObjectType.PORTAL: (48, 64)
        }
        
        width, height = sizes.get(self.current_tool, (32, 32))
        obj = LevelObject(self.current_tool, x, y, width, height)
        
        self.objects.append(obj)
        self.save_history()
    
    def select_at_point(self, x: float, y: float, add_to_selection: bool = False):
        """Select object at point"""
        if not add_to_selection:
            self.clear_selection()
        
        for obj in reversed(self.objects):  # Check top objects first
            if obj.get_rect().collidepoint(x, y):
                obj.selected = True
                self.selected_objects.append(obj)
                break
    
    def clear_selection(self):
        """Clear all selections"""
        for obj in self.selected_objects:
            obj.selected = False
        self.selected_objects.clear()
    
    def delete_selected(self):
        """Delete selected objects"""
        for obj in self.selected_objects:
            if obj in self.objects:
                self.objects.remove(obj)
        self.clear_selection()
        self.save_history()
    
    def move_selected(self, dx: float, dy: float):
        """Move selected objects"""
        for obj in self.selected_objects:
            obj.x += dx
            obj.y += dy
            
            if self.snap_to_grid:
                obj.x = round(obj.x / self.grid_size) * self.grid_size
                obj.y = round(obj.y / self.grid_size) * self.grid_size
    
    def copy_selected(self):
        """Copy selected objects to clipboard"""
        self.clipboard = [obj.to_dict() for obj in self.selected_objects]
    
    def paste(self, x: float, y: float):
        """Paste objects from clipboard"""
        if not self.clipboard:
            return
        
        self.clear_selection()
        
        # Calculate offset from first object
        if self.clipboard:
            offset_x = x - self.clipboard[0]['x']
            offset_y = y - self.clipboard[0]['y']
            
            for data in self.clipboard:
                new_data = data.copy()
                new_data['x'] += offset_x
                new_data['y'] += offset_y
                
                obj = LevelObject.from_dict(new_data)
                obj.selected = True
                self.objects.append(obj)
                self.selected_objects.append(obj)
        
        self.save_history()
    
    def save_history(self):
        """Save current state to history"""
        # Truncate future history
        if self.history_index < len(self.history) - 1:
            self.history = self.history[:self.history_index + 1]
        
        # Save state
        state = [obj.to_dict() for obj in self.objects]
        self.history.append(state)
        self.history_index += 1
        
        # Limit history size
        if len(self.history) > self.max_history:
            self.history.pop(0)
            self.history_index -= 1
    
    def undo(self):
        """Undo last action"""
        if self.history_index > 0:
            self.history_index -= 1
            self.restore_state(self.history[self.history_index])
    
    def redo(self):
        """Redo action"""
        if self.history_index < len(self.history) - 1:
            self.history_index += 1
            self.restore_state(self.history[self.history_index])
    
    def restore_state(self, state: List[Dict]):
        """Restore objects from state"""
        self.clear_selection()
        self.objects = [LevelObject.from_dict(data) for data in state]
    
    def save_level(self, filename: str):
        """Save level to file"""
        level_data = {
            'objects': [obj.to_dict() for obj in self.objects],
            'properties': {
                'width': self.screen_width,
                'height': self.screen_height
            }
        }
        
        with open(filename, 'w') as f:
            json.dump(level_data, f, indent=2)
    
    def load_level(self, filename: str):
        """Load level from file"""
        with open(filename, 'r') as f:
            level_data = json.load(f)
        
        self.clear_selection()
        self.objects = [LevelObject.from_dict(data) 
                       for data in level_data['objects']]
        self.save_history()
    
    def validate_level(self) -> List[str]:
        """Validate level design"""
        issues = []
        
        # Check for spawn point
        has_spawn = any(obj.type == ObjectType.CHECKPOINT 
                       for obj in self.objects)
        if not has_spawn:
            issues.append("No spawn point/checkpoint")
        
        # Check for unreachable areas
        # (Simplified - would need pathfinding for full validation)
        
        # Check for impossible jumps
        # (Would need physics simulation)
        
        return issues

Best Practices

Key Takeaways

import pygame
import json
import sys
from copy import deepcopy

pygame.init()
SCREEN_W, SCREEN_H = 800, 480
GRID = 32

screen = pygame.display.set_mode((SCREEN_W, SCREEN_H))
pygame.display.set_caption("Mini Level Editor — Place, Snap, Undo, Save")
clock = pygame.time.Clock()
font = pygame.font.SysFont(None, 22)

# Tool palette: number key → (kind, (w, h), color)
TOOLS = {
    pygame.K_1: ('platform',   (96, 32), (130,  90,  50)),
    pygame.K_2: ('spike',      (32, 32), (200,  50,  50)),
    pygame.K_3: ('coin',       (24, 24), (255, 215,   0)),
    pygame.K_4: ('checkpoint', (32, 64), ( 50, 200,  50)),
}

current_key = pygame.K_1
objects = []                 # list of (kind, x, y, w, h, color)
history = [[]]               # snapshot stack; history[0] = empty level
history_index = 0
status = "Click to place. Z=undo  S=save  V=validate  1/2/3/4=tool"

def snap(v):
    """Round-to-nearest — picks the closest grid line, NOT the floor.
    Click at 49 snaps to 64 (49 is closer to 64 than to 32). Distinct from
    chat-46 M2 world_to_tile floor: different operations for different intents."""
    return round(v / GRID) * GRID

def push_history():
    """Snapshot-based undo. Truncate redo tail BEFORE appending so history
    always matches the actual edit path applied to objects."""
    global history, history_index
    history = history[:history_index + 1]
    history.append(deepcopy(objects))
    history_index += 1

def undo():
    """Pointer walk + snapshot restore. No inverse logic per action type."""
    global objects, history_index
    if history_index > 0:
        history_index -= 1
        objects = deepcopy(history[history_index])

def save_json(path='level.json'):
    """Design data → portable JSON via to_dict round-trip pattern."""
    with open(path, 'w') as f:
        json.dump([{'kind': k, 'x': x, 'y': y, 'w': w, 'h': h}
                   for (k, x, y, w, h, _) in objects], f, indent=2)
    return path

def validate():
    """Design-time invariant. Catches missing checkpoint BEFORE play, when
    the cost of fixing is one click in the editor instead of a re-ship."""
    if not any(o[0] == 'checkpoint' for o in objects):
        return "MISSING: at least one checkpoint required"
    return f"OK: {len(objects)} objects pass design-invariants"

while True:
    clock.tick(60)
    for e in pygame.event.get():
        if e.type == pygame.QUIT:
            pygame.quit(); sys.exit()
        elif e.type == pygame.KEYDOWN:
            if e.key in TOOLS:
                current_key = e.key
                status = f"Tool: {TOOLS[e.key][0]}"
            elif e.key == pygame.K_z:
                undo(); status = f"Undo: {len(objects)} obj, history@{history_index}"
            elif e.key == pygame.K_s:
                status = f"Saved {len(objects)} obj to {save_json()}"
            elif e.key == pygame.K_v:
                status = validate()
        elif e.type == pygame.MOUSEBUTTONDOWN and e.button == 1:
            kind, (w, h), color = TOOLS[current_key]
            x, y = snap(e.pos[0]), snap(e.pos[1])
            objects.append((kind, x, y, w, h, color))
            push_history()
            status = f"Placed {kind} at ({x},{y})  history@{history_index}"

    # Draw
    screen.fill((28, 28, 40))
    for gx in range(0, SCREEN_W, GRID):
        pygame.draw.line(screen, (50, 50, 70), (gx, 0), (gx, SCREEN_H))
    for gy in range(0, SCREEN_H, GRID):
        pygame.draw.line(screen, (50, 50, 70), (0, gy), (SCREEN_W, gy))
    for (kind, x, y, w, h, color) in objects:
        pygame.draw.rect(screen, color, (x, y, w, h))
    # Snapped cursor outline preview
    mx, my = pygame.mouse.get_pos()
    px, py = snap(mx), snap(my)
    _, (w, h), color = TOOLS[current_key]
    pygame.draw.rect(screen, color, (px, py, w, h), 2)
    screen.blit(font.render(status, True, (240, 240, 240)), (10, SCREEN_H - 30))
    pygame.display.flip()

What's Next?

With powerful level design tools mastered, next we'll add visual depth with parallax scrolling to create immersive game worlds!