anima-core 0.3.0 → 1.0.0

data/skills/dragonruby/examples/game-logic/state_transitions.rb

@@ -0,0 +1,103 @@
+# State Transitions in DragonRuby
+# Demonstrates scene management and game over detection
+
+def tick(args)
+  args.state.scene ||= :title
+  send("#{args.state.scene}_tick", args)
+end
+
+# === TITLE SCENE ===
+def title_tick(args)
+  args.outputs.labels << {
+    x: 640, y: 450, text: "MY GAME",
+    size_enum: 15, anchor_x: 0.5
+  }
+  args.outputs.labels << {
+    x: 640, y: 350, text: "Press SPACE to start",
+    size_enum: 3, anchor_x: 0.5
+  }
+
+  if args.inputs.keyboard.key_down.space
+    # Initialize game state
+    args.state.player = { x: 640, y: 100, health: 3 }
+    args.state.score = 0
+    args.state.scene = :gameplay
+    return  # Early return on transition
+  end
+end
+
+# === GAMEPLAY SCENE ===
+def gameplay_tick(args)
+  # Initialize
+  args.state.player ||= { x: 640, y: 100, health: 3 }
+  args.state.score ||= 0
+
+  # Update
+  handle_gameplay_input(args)
+  check_game_over(args)
+
+  # Render
+  render_gameplay(args)
+end
+
+def handle_gameplay_input(args)
+  player = args.state.player
+  player.x -= 5 if args.inputs.left
+  player.x += 5 if args.inputs.right
+
+  # Simulate damage
+  if args.inputs.keyboard.key_down.x
+    player.health -= 1
+  end
+
+  # Simulate scoring
+  if args.inputs.keyboard.key_down.space
+    args.state.score += 10
+  end
+end
+
+def check_game_over(args)
+  if args.state.player.health <= 0
+    args.state.game_over_at = Kernel.tick_count
+    args.state.scene = :game_over
+    return  # Early return critical!
+  end
+end
+
+def render_gameplay(args)
+  # Player
+  args.outputs.solids << {
+    x: args.state.player.x - 25, y: args.state.player.y,
+    w: 50, h: 50, r: 0, g: 200, b: 0
+  }
+
+  # HUD
+  args.outputs.labels << { x: 40, y: 700, text: "Score: #{args.state.score}" }
+  args.outputs.labels << { x: 40, y: 670, text: "Health: #{args.state.player.health}" }
+  args.outputs.labels << { x: 40, y: 40, text: "X: Take damage | SPACE: Score" }
+end
+
+# === GAME OVER SCENE ===
+def game_over_tick(args)
+  args.outputs.labels << {
+    x: 640, y: 450, text: "GAME OVER",
+    size_enum: 15, anchor_x: 0.5, r: 255, g: 0, b: 0
+  }
+  args.outputs.labels << {
+    x: 640, y: 380, text: "Final Score: #{args.state.score}",
+    size_enum: 5, anchor_x: 0.5
+  }
+
+  # Grace period before accepting restart (30 frames = 0.5 sec)
+  elapsed = Kernel.tick_count - args.state.game_over_at
+  if elapsed > 30
+    args.outputs.labels << {
+      x: 640, y: 300, text: "Press SPACE to restart",
+      size_enum: 3, anchor_x: 0.5
+    }
+
+    if args.inputs.keyboard.key_down.space
+      $gtk.reset
+    end
+  end
+end

data/skills/dragonruby/examples/game-logic/timers.rb

@@ -0,0 +1,87 @@
+# Timer Patterns in DragonRuby
+# Demonstrates frame-based timing, countdowns, and periodic execution
+
+FPS = 60
+
+def tick(args)
+  defaults(args)
+  tick_countdown_timer(args)
+  tick_progress_bar(args)
+  tick_periodic_spawner(args)
+  render(args)
+end
+
+def defaults(args)
+  # Countdown timer (30 seconds)
+  args.state.countdown ||= 30 * FPS
+
+  # Progress bar (fills over 5 seconds)
+  args.state.progress ||= 0
+  args.state.progress_max ||= 5 * FPS
+
+  # Periodic spawner
+  args.state.spawn_rate ||= FPS  # Every second
+  args.state.spawned_count ||= 0
+end
+
+# Pattern 1: Countdown Timer
+def tick_countdown_timer(args)
+  return if args.state.countdown <= 0
+
+  args.state.countdown -= 1
+
+  if args.state.countdown <= 0
+    args.state.time_up = true
+  end
+end
+
+# Pattern 2: Progress Bar (fills up)
+def tick_progress_bar(args)
+  return if args.state.progress >= args.state.progress_max
+
+  args.state.progress += 1
+end
+
+# Pattern 3: Periodic Execution with zmod?
+def tick_periodic_spawner(args)
+  # Execute every spawn_rate frames
+  if Kernel.tick_count.zmod?(args.state.spawn_rate)
+    args.state.spawned_count += 1
+  end
+end
+
+def render(args)
+  # Display countdown as seconds
+  seconds_left = (args.state.countdown / FPS).ceil
+  args.outputs.labels << {
+    x: 640, y: 600, text: "Time: #{seconds_left}s",
+    size_enum: 5, anchor_x: 0.5
+  }
+
+  # Display progress percentage
+  progress_pct = (args.state.progress.fdiv(args.state.progress_max) * 100).round
+  args.outputs.labels << {
+    x: 640, y: 500, text: "Progress: #{progress_pct}%",
+    size_enum: 3, anchor_x: 0.5
+  }
+
+  # Progress bar visual
+  bar_width = 400
+  filled = (args.state.progress.fdiv(args.state.progress_max) * bar_width).round
+  args.outputs.solids << { x: 440, y: 450, w: bar_width, h: 20, r: 100, g: 100, b: 100 }
+  args.outputs.solids << { x: 440, y: 450, w: filled, h: 20, r: 0, g: 200, b: 0 }
+
+  # Spawn counter
+  args.outputs.labels << {
+    x: 640, y: 400, text: "Spawned: #{args.state.spawned_count}",
+    size_enum: 3, anchor_x: 0.5
+  }
+
+  # Time up message
+  if args.state.time_up
+    args.outputs.labels << {
+      x: 640, y: 300, text: "TIME UP!",
+      size_enum: 10, anchor_x: 0.5, r: 255, g: 0, b: 0
+    }
+  end
+end

data/skills/dragonruby/examples/input/action_triggers.rb

@@ -0,0 +1,36 @@
+# One-shot actions using key_down pattern
+# Perfect for jump, shoot, interact buttons
+
+def tick args
+  args.state.player ||= { x: 640, y: 100, dy: 0, on_ground: true }
+  args.state.bullets ||= []
+
+  # Jump: only trigger once per press (not while held)
+  if args.inputs.keyboard.key_down.space && args.state.player.on_ground
+    args.state.player.dy = 15  # Jump velocity
+    args.state.player.on_ground = false
+  end
+
+  # Shoot: fire one bullet per keypress
+  if args.inputs.keyboard.key_down.f
+    args.state.bullets << { x: args.state.player.x, y: args.state.player.y,
+                            created_at: Kernel.tick_count }
+  end
+
+  # Simple gravity and ground collision
+  args.state.player.dy -= 0.5
+  args.state.player.y += args.state.player.dy
+
+  if args.state.player.y <= 100
+    args.state.player.y = 100
+    args.state.player.dy = 0
+    args.state.player.on_ground = true
+  end
+
+  # Cleanup old bullets
+  args.state.bullets.reject! { |b| b.created_at.elapsed_time > 60 }
+
+  # Render
+  args.outputs.sprites << args.state.player.merge(w: 32, h: 32, path: 'sprites/square/blue.png')
+  args.outputs.sprites << args.state.bullets.map { |b| b.merge(w: 8, h: 8, path: 'sprites/square/red.png') }
+end

data/skills/dragonruby/examples/input/analog_movement.rb

@@ -0,0 +1,28 @@
+# Smooth analog movement using percentage values
+# Allows for speed variation based on stick deflection
+
+def tick args
+  controller = args.inputs.controller_one
+  args.state.player ||= { x: 640, y: 360, w: 32, h: 32, dx: 0, dy: 0 }
+
+  max_speed = 8
+
+  # Analog stick returns -1.0 to 1.0, multiply by max speed
+  # Small tilts = slow movement, full tilt = max speed
+  args.state.player.dx = controller.left_analog_x_perc * max_speed
+  args.state.player.dy = controller.left_analog_y_perc * max_speed
+
+  # Apply velocity
+  args.state.player.x += args.state.player.dx
+  args.state.player.y += args.state.player.dy
+
+  # Clamp to screen
+  args.state.player.x = args.state.player.x.clamp(0, 1280 - args.state.player.w)
+  args.state.player.y = args.state.player.y.clamp(0, 720 - args.state.player.h)
+
+  # Visual speed indicator
+  speed = Math.sqrt(args.state.player.dx**2 + args.state.player.dy**2)
+  args.outputs.labels << { x: 640, y: 700, text: "Speed: #{speed.to_sf} (tilt stick for variable speed)", size_enum: 5, alignment_enum: 1 }
+
+  args.outputs.sprites << args.state.player.merge(path: 'sprites/square/blue.png')
+end

data/skills/dragonruby/examples/input/controller_input.rb

@@ -0,0 +1,28 @@
+# Controller button and analog stick input
+# Access via args.inputs.controller_one (or controller_two, etc.)
+
+def tick args
+  controller = args.inputs.controller_one
+  args.state.player ||= { x: 640, y: 360, w: 32, h: 32 }
+
+  # Button inputs (key_down, key_held, key_up work like keyboard)
+  if controller.key_down.a
+    args.outputs.labels << { x: 640, y: 600, text: "A button pressed!", size_enum: 5, alignment_enum: 1 }
+  end
+
+  # D-pad directions
+  if controller.key_held.up
+    args.state.player.y += 5
+  end
+
+  # Analog stick positions: left_analog_x_perc and left_analog_y_perc
+  # Returns value from -1.0 to 1.0 (0.0 when centered)
+  args.state.player.x += controller.left_analog_x_perc * 8
+  args.state.player.y += controller.left_analog_y_perc * 8
+
+  # Display analog values
+  args.outputs.labels << { x: 10, y: 700, text: "Left stick X: #{controller.left_analog_x_perc.to_sf}" }
+  args.outputs.labels << { x: 10, y: 670, text: "Left stick Y: #{controller.left_analog_y_perc.to_sf}" }
+
+  args.outputs.sprites << args.state.player.merge(path: 'sprites/square/blue.png')
+end

data/skills/dragonruby/examples/input/directional_input.rb

@@ -0,0 +1,24 @@
+# Basic directional movement using args.inputs.up/down/left/right
+# These shortcuts check keyboard arrows, WASD, and controller d-pad
+
+def tick args
+  # Initialize player on first tick
+  args.state.player ||= { x: 640, y: 360, w: 32, h: 32,
+                          path: 'sprites/square/blue.png' }
+
+  # Check directional inputs - returns true when pressed or held
+  if args.inputs.up
+    args.state.player.y += 5
+  elsif args.inputs.down
+    args.state.player.y -= 5
+  end
+
+  if args.inputs.left
+    args.state.player.x -= 5
+  elsif args.inputs.right
+    args.state.player.x += 5
+  end
+
+  # Render player
+  args.outputs.sprites << args.state.player
+end

data/skills/dragonruby/examples/input/keyboard_input.rb

@@ -0,0 +1,28 @@
+# Detecting specific keyboard events: key_down, key_held, key_up
+# key_down: fires once when key is first pressed
+# key_held: fires every frame while key is held
+# key_up: fires once when key is released
+
+def tick args
+  args.state.bullets ||= []
+
+  # key_down: fires ONCE per press (good for actions)
+  if args.inputs.keyboard.key_down.space
+    args.state.bullets << { x: 100, y: 100, created_at: Kernel.tick_count }
+  end
+
+  # key_held: fires EVERY FRAME while pressed (good for continuous movement)
+  if args.inputs.keyboard.key_held.w
+    args.outputs.labels << { x: 640, y: 360, text: "W is being held", size_enum: 5, alignment_enum: 1 }
+  end
+
+  # key_up: fires ONCE when released (good for charging mechanics)
+  if args.inputs.keyboard.key_up.escape
+    args.state.menu_opened_at = Kernel.tick_count
+  end
+
+  # Display status
+  args.outputs.labels << { x: 10, y: 700, text: "Press SPACE to fire (key_down)" }
+  args.outputs.labels << { x: 10, y: 670, text: "Hold W for message (key_held)" }
+  args.outputs.labels << { x: 10, y: 640, text: "Press ESC to log release (key_up)" }
+end

data/skills/dragonruby/examples/input/mouse_click.rb

@@ -0,0 +1,26 @@
+# Handling mouse clicks and position
+# args.inputs.mouse.click returns event info when clicked
+
+def tick args
+  # Check for mouse click this frame
+  if args.inputs.mouse.click
+    # Store the click event (has x, y, created_at properties)
+    args.state.last_click = args.inputs.mouse.click
+  end
+
+  # Display click information
+  if args.state.last_click
+    click = args.state.last_click
+
+    # Access click position
+    args.outputs.labels << { x: 640, y: 400, text: "Clicked at: #{click.x}, #{click.y}", size_enum: 5, alignment_enum: 1 }
+
+    # How many frames ago did it happen?
+    args.outputs.labels << { x: 640, y: 350, text: "Clicked #{click.created_at_elapsed} ticks ago", size_enum: 5, alignment_enum: 1 }
+
+    # Draw a marker at click position
+    args.outputs.primitives << { x: click.x - 5, y: click.y - 5, w: 10, h: 10, r: 255, g: 0, b: 0, primitive_marker: :solid }
+  else
+    args.outputs.labels << { x: 640, y: 360, text: "Click anywhere!", size_enum: 5, alignment_enum: 1 }
+  end
+end

data/skills/dragonruby/examples/input/movement_with_bounds.rb

@@ -0,0 +1,22 @@
+# Movement with screen boundary clamping using .clamp method
+# Prevents player from moving outside screen bounds
+
+def tick args
+  args.state.player ||= { x: 640, y: 360, w: 64, h: 64 }
+
+  speed = 5
+
+  # Apply movement using unified directional helpers
+  args.state.player.x += args.inputs.left_right * speed
+  args.state.player.y += args.inputs.up_down * speed
+
+  # Clamp position to stay within screen bounds
+  # args.grid.w is 1280, args.grid.h is 720 by default
+  args.state.player.x = args.state.player.x.clamp(0, args.grid.w - args.state.player.w)
+  args.state.player.y = args.state.player.y.clamp(0, args.grid.h - args.state.player.h)
+
+  # Visual feedback at boundaries
+  args.outputs.primitives << { x: 0, y: 0, w: args.grid.w, h: args.grid.h, r: 255, g: 0, b: 0, primitive_marker: :border }
+  args.outputs.sprites << args.state.player.merge(path: 'sprites/square/blue.png')
+  args.outputs.labels << { x: 640, y: 700, text: "Try moving off screen - player is clamped", size_enum: 5, alignment_enum: 1 }
+end

data/skills/dragonruby/examples/input/normalized_movement.rb

@@ -0,0 +1,32 @@
+# Normalized diagonal movement using left_right and up_down
+# Prevents faster diagonal movement by normalizing the vector
+
+def tick args
+  args.state.player ||= { x: 640, y: 360, w: 32, h: 32 }
+
+  speed = 5
+
+  # args.inputs.left_right returns -1, 0, or 1
+  # args.inputs.up_down returns -1, 0, or 1
+  dx = args.inputs.left_right
+  dy = args.inputs.up_down
+
+  # Calculate vector length (diagonal movement without normalization = 1.41x speed)
+  length = Math.sqrt(dx * dx + dy * dy)
+
+  # Normalize: divide by length to get unit vector, then multiply by speed
+  if length > 0
+    dx = (dx / length) * speed
+    dy = (dy / length) * speed
+  end
+
+  # Apply normalized movement
+  args.state.player.x += dx
+  args.state.player.y += dy
+
+  # Show speed comparison
+  args.outputs.labels << { x: 640, y: 700, text: "Move diagonally - speed stays constant", size_enum: 5, alignment_enum: 1 }
+  args.outputs.labels << { x: 640, y: 670, text: "Current speed: #{Math.sqrt(dx**2 + dy**2).to_sf}", size_enum: 5, alignment_enum: 1 }
+
+  args.outputs.sprites << args.state.player.merge(path: 'sprites/square/blue.png')
+end

data/skills/dragonruby/examples/rendering/frame_animation.rb

@@ -0,0 +1,32 @@
+# Frame animation using separate PNG files
+
+def tick args
+  # Looping animation: 6 frames, 4 ticks each, repeat forever
+  looping_frame = 0.frame_index(6, 4, true)
+
+  args.outputs.sprites << {
+    x: 200, y: 400, w: 100, h: 100,
+    path: "sprites/dragon_fly_#{looping_frame}.png"
+  }
+
+  # One-time animation triggered by spacebar
+  if args.inputs.keyboard.key_down.space
+    args.state.attack_at = Kernel.tick_count
+  end
+
+  if args.state.attack_at
+    frame = args.state.attack_at.frame_index(6, 4, false)
+    frame ||= 0  # Stay on first frame when complete
+
+    args.outputs.sprites << {
+      x: 600, y: 400, w: 100, h: 100,
+      path: "sprites/dragon_fly_#{frame}.png"
+    }
+  end
+
+  args.outputs.labels << {
+    x: 640, y: 100,
+    text: "Press SPACE for one-time animation",
+    anchor_x: 0.5
+  }
+end

data/skills/dragonruby/examples/rendering/labels.rb

@@ -0,0 +1,32 @@
+# Text rendering with alignment and sizing
+
+def tick args
+  # Size options
+  args.outputs.labels << { x: 640, y: 650, text: "Basic Label" }
+  args.outputs.labels << { x: 640, y: 600, text: "Small",  size_enum: -1 }
+  args.outputs.labels << { x: 640, y: 570, text: "Medium", size_enum: 0 }
+  args.outputs.labels << { x: 640, y: 540, text: "Large",  size_enum: 1 }
+  args.outputs.labels << { x: 640, y: 500, text: "Custom", size_px: 32 }
+
+  # Alignment with anchors
+  args.outputs.labels << { x: 640, y: 450, text: "Left",   anchor_x: 0,   anchor_y: 0.5 }
+  args.outputs.labels << { x: 640, y: 420, text: "Center", anchor_x: 0.5, anchor_y: 0.5 }
+  args.outputs.labels << { x: 640, y: 390, text: "Right",  anchor_x: 1,   anchor_y: 0.5 }
+
+  # Colors
+  args.outputs.labels << { x: 640, y: 340, text: "Red",   r: 255, g: 0,   b: 0 }
+  args.outputs.labels << { x: 640, y: 310, text: "Green", r: 0,   g: 255, b: 0 }
+  args.outputs.labels << { x: 640, y: 280, text: "Blue",  r: 0,   g: 0,   b: 255 }
+  args.outputs.labels << { x: 640, y: 250, text: "Faded", a: 128 }
+
+  # Custom font
+  args.outputs.labels << {
+    x: 640, y: 200,
+    text: "Custom Font",
+    font: "fonts/manaspc.ttf",
+    size_px: 24, anchor_x: 0.5
+  }
+
+  # Reference line
+  args.outputs.lines << { x: 640, y: 0, x2: 640, y2: 720, r: 100, g: 100, b: 100 }
+end

data/skills/dragonruby/examples/rendering/layering.rb

@@ -0,0 +1,51 @@
+# FIFO render order demonstration using args.outputs.primitives
+# Items render in insertion order - first added = behind, last added = on top
+
+def tick args
+  # All rendering uses args.outputs.primitives for FIFO control
+  # Each primitive renders ON TOP of previously added primitives
+
+  # 1. Background (rendered first = bottom layer)
+  args.outputs.primitives << {
+    x: 0, y: 0, w: 1280, h: 720,
+    r: 50, g: 50, b: 80,
+    primitive_marker: :solid
+  }
+
+  # 2. Ground
+  args.outputs.primitives << {
+    x: 0, y: 0, w: 1280, h: 200,
+    r: 100, g: 150, b: 100,
+    primitive_marker: :solid
+  }
+
+  # 3. Objects (back to front based on insertion order)
+  args.outputs.primitives << { x: 100, y: 150, w: 100, h: 150, path: :solid, r: 34, g: 100, b: 34 }
+  args.outputs.primitives << { x: 180, y: 150, w: 100, h: 150, path: :solid, r: 34, g: 139, b: 34 }
+  args.outputs.primitives << { x: 260, y: 150, w: 100, h: 150, path: :solid, r: 50, g: 200, b: 50 }
+
+  # Labels for objects
+  args.outputs.primitives << { x: 150, y: 120, text: "Back",   anchor_x: 0.5 }
+  args.outputs.primitives << { x: 230, y: 120, text: "Middle", anchor_x: 0.5 }
+  args.outputs.primitives << { x: 310, y: 120, text: "Front",  anchor_x: 0.5 }
+
+  # 4. UI bar (rendered last = top layer)
+  args.outputs.primitives << {
+    x: 0, y: 680, w: 1280, h: 40,
+    r: 0, g: 0, b: 0, a: 200,
+    primitive_marker: :solid
+  }
+
+  args.outputs.primitives << {
+    x: 640, y: 700,
+    text: "UI Layer - rendered last with primitives, appears on top",
+    anchor_x: 0.5, r: 255, g: 255, b: 255
+  }
+
+  # Explanation
+  args.outputs.primitives << {
+    x: 640, y: 550,
+    text: "FIFO: First In = Behind, Last In = On Top",
+    anchor_x: 0.5, size_px: 20
+  }
+end

data/skills/dragonruby/examples/rendering/solids.rb

@@ -0,0 +1,61 @@
+# Filled rectangles and borders using args.outputs.primitives
+# Use primitive_marker: :solid or :border for rectangle types
+
+def tick args
+  # Background using primitives
+  args.outputs.primitives << {
+    x: 0, y: 0, w: 1280, h: 720,
+    r: 32, g: 32, b: 32,
+    primitive_marker: :solid
+  }
+
+  # Solids with primitive_marker (recommended for FIFO control)
+  args.outputs.primitives << {
+    x: 100, y: 500, w: 100, h: 100,
+    primitive_marker: :solid
+  }
+
+  args.outputs.primitives << {
+    x: 220, y: 500, w: 100, h: 100,
+    r: 255, g: 0, b: 0,
+    primitive_marker: :solid
+  }
+
+  args.outputs.primitives << {
+    x: 340, y: 500, w: 100, h: 100,
+    r: 0, g: 255, b: 0, a: 128,
+    primitive_marker: :solid
+  }
+
+  args.outputs.primitives << {
+    x: 460, y: 500, w: 100, h: 100,
+    r: 0, g: 128, b: 255, a: 200,
+    primitive_marker: :solid
+  }
+
+  # path: :solid for better performance with many rectangles
+  # (auto-detected as sprite, no primitive_marker needed)
+  args.outputs.primitives << {
+    x: 580, y: 500, w: 100, h: 100,
+    path: :solid,
+    r: 255, g: 255, b: 0
+  }
+
+  # Borders with primitive_marker
+  args.outputs.primitives << {
+    x: 100, y: 300, w: 100, h: 100,
+    r: 255, g: 255, b: 255,
+    primitive_marker: :border
+  }
+
+  args.outputs.primitives << {
+    x: 220, y: 300, w: 100, h: 100,
+    r: 0, g: 255, b: 255,
+    primitive_marker: :border
+  }
+
+  # Labels explaining the approach
+  args.outputs.primitives << { x: 340, y: 640, text: "primitive_marker: :solid", size_px: 18 }
+  args.outputs.primitives << { x: 580, y: 640, text: "path: :solid (performance)", size_px: 18 }
+  args.outputs.primitives << { x: 160, y: 440, text: "primitive_marker: :border", size_px: 18 }
+end

data/skills/dragonruby/examples/rendering/sprites.rb

@@ -0,0 +1,33 @@
+# Image rendering with anchors, rotation, and color tinting
+
+def tick args
+  # Basic sprite
+  args.outputs.sprites << {
+    x: 100, y: 500, w: 128, h: 101,
+    path: 'dragonruby.png'
+  }
+
+  # Centered with anchors
+  args.outputs.sprites << {
+    x: 400, y: 500, w: 128, h: 101,
+    path: 'dragonruby.png',
+    anchor_x: 0.5, anchor_y: 0.5
+  }
+
+  # Rotation around center
+  args.outputs.sprites << {
+    x: 700, y: 500, w: 128, h: 101,
+    path: 'dragonruby.png',
+    angle: Kernel.tick_count % 360,
+    angle_anchor_x: 0.5, angle_anchor_y: 0.5
+  }
+
+  # Color tinting, transparency, flipping
+  args.outputs.sprites << {
+    x: 1000, y: 500, w: 128, h: 101,
+    path: 'dragonruby.png',
+    r: 255, g: 128, b: 128,
+    a: Kernel.tick_count % 255,
+    flip_horizontally: true
+  }
+end

data/skills/dragonruby/examples/rendering/spritesheet_animation.rb

@@ -0,0 +1,39 @@
+# Spritesheet animation using tile_x and tile_y
+
+def tick args
+  args.state.player ||= { x: 640, y: 360, w: 64, h: 64 }
+
+  moving = args.inputs.left || args.inputs.right
+
+  if moving
+    args.state.run_start ||= Kernel.tick_count
+
+    # 6 frames, 3 ticks each, looping
+    tile_index = args.state.run_start.frame_index(6, 3, true)
+
+    args.outputs.sprites << {
+      x: args.state.player.x,
+      y: args.state.player.y,
+      w: args.state.player.w,
+      h: args.state.player.h,
+      path: 'sprites/horizontal-run.png',
+      tile_x: tile_index * 64,
+      tile_y: 0,
+      tile_w: 64,
+      tile_h: 64,
+      flip_horizontally: args.inputs.left
+    }
+  else
+    args.state.run_start = nil
+
+    args.outputs.sprites << {
+      x: args.state.player.x,
+      y: args.state.player.y,
+      w: args.state.player.w,
+      h: args.state.player.h,
+      path: 'sprites/horizontal-stand.png'
+    }
+  end
+
+  args.outputs.labels << { x: 640, y: 100, text: "Hold LEFT/RIGHT to run", anchor_x: 0.5 }
+end