💻 Koder og Eksempler

# 🐍 SIMPLE 3-SNAKE PARKOUR - EASY SETUP
# Perfect for 12-year-olds and beginners!

# ================================================================
# 📍 STEP 1: CHANGE THESE COORDINATES TO YOUR WORLD!
# ================================================================

# Starting point (where Snake 1 will be)
START_X = 53
START_Y = -58
START_Z = -76

# Ending point (where Snake 3 will be)
END_X = 92
END_Y = -58
END_Z = -76

# Trigger location (where to place EMERALD_BLOCK to start)
TRIGGER_X = 52
TRIGGER_Y = -57
TRIGGER_Z = -75

# ================================================================
# 🎮 STEP 2: CHANGE SNAKE SETTINGS (EASY TO CUSTOMIZE!)
# ================================================================

# Snake 1 settings (EASY - Horizontal movement)
SNAKE1_LENGTH = 6        # How many blocks long
SNAKE1_RANGE = 8         # How far it moves (left-right)
SNAKE1_SPEED = 800       # How fast (bigger = slower)

# Snake 2 settings (MEDIUM - Vertical movement)
SNAKE2_LENGTH = 5        # How many blocks long
SNAKE2_RANGE = 6         # How far it moves (up-down)
SNAKE2_SPEED = 600       # How fast (bigger = slower)

# Snake 3 settings (HARD - Diagonal movement)
SNAKE3_LENGTH = 4        # How many blocks long
SNAKE3_RANGE = 10        # How far it moves (diagonal)
SNAKE3_SPEED = 400       # How fast (bigger = slower)

# ================================================================
# 🐍 SNAKE 1: GREEN HORIZONTAL SNAKE (EASIEST)
# ================================================================
def snake_1():
    snake_blocks = []
    step = 0
    
    while True:
        # Move left and right
        if step < SNAKE1_RANGE:
            x_pos = START_X + step
        else:
            x_pos = START_X + (SNAKE1_RANGE * 2 - 1 - step)
        
        # Reset when reaching end
        if step >= SNAKE1_RANGE * 2 - 1:
            step = 0
        else:
            step += 1
        
        # Create snake head
        head_pos = world(x_pos, START_Y, START_Z)
        snake_blocks.append(head_pos)
        blocks.place(EMERALD_BLOCK, head_pos)  # Green blocks
        
        # Remove tail to keep snake length
        if len(snake_blocks) > SNAKE1_LENGTH:
            tail_pos = snake_blocks.pop(0)
            blocks.place(AIR, tail_pos)
        
        loops.pause(SNAKE1_SPEED)

# ================================================================
# 🐍 SNAKE 2: GOLD SPIRAL STAIR SNAKE (MEDIUM)
# ================================================================
def snake_2():
    snake_blocks = []
    step = 0
    
    # Snake 2 position (10 blocks away from Snake 1)
    snake2_x = START_X + 10
    snake2_z = START_Z + 5
    
    # Spiral stair pattern (8 positions around a circle, going up)
    spiral_pattern = [
        (0, 0),    # Center-ish start
        (2, 0),    # Right
        (2, 2),    # Right-Back
        (0, 2),    # Back
        (-2, 2),   # Left-Back
        (-2, 0),   # Left
        (-2, -2),  # Left-Front
        (0, -2)    # Front
    ]
    
    while True:
        # Get current spiral position
        pattern_step = step % len(spiral_pattern)
        x_offset, z_offset = spiral_pattern[pattern_step]
        
        # Go up one block every 2 steps in the spiral
        y_offset = (step // 2) % 8  # Goes 0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7 then repeats
        
        # Reset when completing full spiral cycle
        if step >= len(spiral_pattern) * 8:  # 8 height levels * 8 positions = 64 steps
            step = 0
        else:
            step += 1
        
        # Create snake head at spiral position
        head_pos = world(snake2_x + x_offset, START_Y + y_offset, snake2_z + z_offset)
        snake_blocks.append(head_pos)
        blocks.place(GOLD_BLOCK, head_pos)  # Gold blocks
        
        # Remove tail to keep snake length
        if len(snake_blocks) > SNAKE2_LENGTH:
            tail_pos = snake_blocks.pop(0)
            blocks.place(AIR, tail_pos)
        
        loops.pause(SNAKE2_SPEED)

# ================================================================
# 🐍 SNAKE 3: DIAMOND ZIGZAG SNAKE WITH GAPS (HARDEST)
# ================================================================
def snake_3():
    snake_blocks = []
    step = 0
    
    # Snake 3 position (10 blocks away from Snake 2)
    snake3_start_x = START_X + 20
    snake3_start_z = START_Z + 10
    
    # Zigzag pattern with permanent gaps that players must memorize
    # 1 = place block, 0 = gap (no block)
    zigzag_gaps = [1, 1, 0, 1, 1, 1, 0, 0, 1, 1, 0, 1, 1, 1, 0, 1]  # 16-step pattern
    
    # Zigzag movement pattern (left-right-left-right)
    zigzag_offsets = [0, 1, 2, 1, 0, -1, -2, -1, 0, 1, 2, 1, 0, -1, -2, -1]  # 16-step pattern
    
    while True:
        # Get current position in patterns
        pattern_step = step % len(zigzag_gaps)
        
        # Calculate zigzag position
        z_offset = zigzag_offsets[pattern_step]
        x_pos = snake3_start_x + (step // 4)  # Move forward every 4 steps
        z_pos = snake3_start_z + z_offset
        
        # Only place block if gap pattern says so (1 = block, 0 = gap)
        if zigzag_gaps[pattern_step] == 1:
            head_pos = world(x_pos, END_Y, z_pos)
            snake_blocks.append(head_pos)
            blocks.place(DIAMOND_BLOCK, head_pos)  # Diamond blocks
        else:
            # Create a "ghost" position for timing but don't place block
            player.say(f"Gap at step {pattern_step + 1}!")  # Help players learn the pattern
        
        # Remove tail to keep snake length
        if len(snake_blocks) > SNAKE3_LENGTH:
            tail_pos = snake_blocks.pop(0)
            blocks.place(AIR, tail_pos)
        
        # Reset pattern when reaching end
        if step >= SNAKE3_RANGE * 4:  # 4 steps per forward movement
            step = 0
        else:
            step += 1
        
        loops.pause(SNAKE3_SPEED)

# ================================================================
# 🎮 CONTROL SYSTEM - START THE PARKOUR!
# ================================================================
def start_parkour():
    """Start all 3 snakes when emerald block is placed"""
    player.say("🐍 STARTING 3-SNAKE PARKOUR! 🐍")
    player.say("Snake 1: GREEN blocks moving left-right (EASY)")
    loops.pause(500)
    
    player.say("Snake 2: GOLD blocks in spiral stair (MEDIUM)")
    loops.pause(500)
    
    player.say("Snake 3: DIAMOND zigzag with gaps - memorize the pattern! (HARD)")
    loops.pause(500)
    
    # Start all snakes in background
    loops.run_in_background(snake_1)
    loops.pause(300)
    loops.run_in_background(snake_2)
    loops.pause(300)
    loops.run_in_background(snake_3)
    
    player.say("All snakes active! Jump carefully! 🎮")
    player.say("Goal: Jump from green → gold → diamond!")

def clear_parkour():
    """Clear all snakes from the area"""
    player.say("Clearing parkour area...")
    
    # Clear large area to remove all snake blocks
    blocks.fill(AIR,
                world(START_X - 5, START_Y - 2, START_Z - 5),
                world(END_X + 5, END_Y + 10, END_Z + 5))
    
    player.say("Area cleared!")

# ================================================================
# 🎯 MAIN CONTROLLER - WATCHES FOR TRIGGER BLOCK
# ================================================================
def parkour_controller():
    """Main controller - watches for emerald block trigger"""
    player.say("🎮 SNAKE PARKOUR READY!")
    player.say(f"Place EMERALD_BLOCK at coordinates: {TRIGGER_X}, {TRIGGER_Y}, {TRIGGER_Z}")
    player.say("Place REDSTONE_BLOCK at same location to clear area")
    
    while True:
        # Check for start trigger (emerald block)
        if blocks.test_for_block(EMERALD_BLOCK, world(TRIGGER_X, TRIGGER_Y, TRIGGER_Z)):
            blocks.place(AIR, world(TRIGGER_X, TRIGGER_Y, TRIGGER_Z))  # Remove trigger
            start_parkour()
        
        # Check for clear trigger (redstone block)
        elif blocks.test_for_block(REDSTONE_BLOCK, world(TRIGGER_X, TRIGGER_Y, TRIGGER_Z)):
            blocks.place(AIR, world(TRIGGER_X, TRIGGER_Y, TRIGGER_Z))  # Remove trigger
            clear_parkour()
        
        loops.pause(500)  # Check twice per second

# ================================================================
# 🚀 START THE SYSTEM!
# ================================================================

# Start the controller automatically
loops.run_in_background(parkour_controller)

# Welcome message
player.say("🐍 3-SNAKE PARKOUR LOADED! 🐍")
player.say("📍 Step 1: Change coordinates at top of code")
player.say("📍 Step 2: Place EMERALD_BLOCK to start")
player.say("📍 Step 3: Jump and have fun!")

# ================================================================
# 📝 QUICK REFERENCE FOR KIDS:
# ================================================================
#
# HOW TO USE:
# 1. Change START_X, START_Y, START_Z to your location
# 2. Change END_X, END_Y, END_Z to where you want Snake 3
# 3. Change TRIGGER_X, TRIGGER_Y, TRIGGER_Z to where you'll place the emerald block
# 4. Place an EMERALD_BLOCK at the trigger location
# 5. Watch the snakes start moving!
# 6. Jump from green → gold → diamond blocks
#
# TO MAKE EASIER:
# - Make SNAKE_SPEED numbers bigger (slower snakes)
# - Make SNAKE_LENGTH numbers bigger (longer platforms)
# - Make SNAKE_RANGE numbers smaller (shorter movements)
#
# TO MAKE HARDER:
# - Make SNAKE_SPEED numbers smaller (faster snakes)
# - Make SNAKE_LENGTH numbers smaller (shorter platforms)
# - Make SNAKE_RANGE numbers bigger (longer movements)
#
# COLORS:
# - Snake 1: GREEN (emerald blocks) - moves left-right
# - Snake 2: GOLD (gold blocks) - spiral stair pattern
# - Snake 3: DIAMOND (diamond blocks) - zigzag with memorizable gaps
#
# SNAKE 3 DANGER PATTERN TO MEMORIZE:
# Safe-Safe-Safe-GAP-GAP-Safe-Safe-GAP-Safe-Safe-Safe-GAP-GAP-GAP-Safe-Safe
# EXTREME WIDE zigzag: 33 blocks total width! Goes from -15 to +18 blocks!
# Random positions: 0,5,-8,12,-3,15,-12,8,-5,18,-15,2,-10,14,-7,10
# (Completely unpredictable jumps - master the chaos!)
#
# ================================================================