anima-core 0.3.0 → 1.0.0

data/skills/dragonruby/examples/scenes/case_dispatch.rb

@@ -0,0 +1,60 @@
+# Case-Based Scene Dispatch
+# Explicit control flow with validation
+# Source: DragonRuby samples/02_input_basics/07_managing_scenes
+
+def tick args
+  args.state.current_scene ||= :title
+
+  case args.state.current_scene
+  when :title
+    tick_title args
+  when :game
+    tick_game args
+  when :game_over
+    tick_game_over args
+  else
+    # Catch undefined scenes
+    args.outputs.labels << {
+      x: 640, y: 360,
+      text: "Unknown scene: #{args.state.current_scene}",
+      anchor_x: 0.5,
+      r: 255, g: 0, b: 0
+    }
+  end
+end
+
+def tick_title args
+  args.outputs.labels << {
+    x: 640, y: 360,
+    text: "Title Scene (click to start)",
+    anchor_x: 0.5
+  }
+
+  if args.inputs.mouse.click
+    args.state.current_scene = :game
+  end
+end
+
+def tick_game args
+  args.outputs.labels << {
+    x: 640, y: 360,
+    text: "Game Scene (click for game over)",
+    anchor_x: 0.5
+  }
+
+  if args.inputs.mouse.click
+    args.state.current_scene = :game_over
+  end
+end
+
+def tick_game_over args
+  args.outputs.labels << {
+    x: 640, y: 360,
+    text: "Game Over (click to restart)",
+    anchor_x: 0.5
+  }
+
+  if args.inputs.mouse.click
+    args.state.current_scene = :title
+  end
+end

data/skills/dragonruby/examples/scenes/class_based.rb

@@ -0,0 +1,150 @@
+# Class-Based Scene Management
+# Full OOP approach for complex games
+# Source: DragonRuby samples/02_input_basics/07_managing_scenes_advanced
+
+class Game
+  attr :args, :hp
+
+  def initialize
+    @hp = 100
+  end
+
+  def take_damage
+    @hp -= 10
+  end
+
+  def heal
+    @hp += 10
+  end
+
+  def dead?
+    @hp <= 0
+  end
+
+  def restart
+    @hp = 100
+  end
+end
+
+class TitleScene
+  attr :args
+
+  def id
+    :title
+  end
+
+  def tick
+    args.outputs.labels << {
+      x: 640, y: 400,
+      text: "Click to Start",
+      anchor_x: 0.5
+    }
+
+    if args.inputs.mouse.click
+      args.state.next_scene = :gameplay
+    end
+  end
+end
+
+class GameplayScene
+  attr :game, :args
+
+  def initialize(game)
+    @game = game
+  end
+
+  def id
+    :gameplay
+  end
+
+  def tick
+    # Damage on Enter
+    if args.inputs.keyboard.key_down.enter
+      @game.take_damage
+    end
+
+    # Check death
+    if @game.dead?
+      args.state.next_scene = :game_over
+    end
+
+    # Render
+    args.outputs.labels << {
+      x: 640, y: 400,
+      text: "HP: #{@game.hp} (press Enter to take damage)",
+      anchor_x: 0.5
+    }
+  end
+end
+
+class GameOverScene
+  attr :game, :args
+
+  def initialize(game)
+    @game = game
+  end
+
+  def id
+    :game_over
+  end
+
+  def tick
+    args.outputs.labels << {
+      x: 640, y: 400,
+      text: "Game Over! Click to restart",
+      anchor_x: 0.5
+    }
+
+    if args.inputs.mouse.click
+      @game.restart
+      args.state.next_scene = :title
+    end
+  end
+end
+
+class SceneManager
+  attr :args
+
+  def initialize
+    @game = Game.new
+    @scenes = [
+      TitleScene.new,
+      GameplayScene.new(@game),
+      GameOverScene.new(@game)
+    ]
+  end
+
+  def tick
+    args.state.scene ||= :title
+
+    scene_before = args.state.scene
+
+    # Find and tick current scene
+    scene = @scenes.find { |s| s.id == args.state.scene }
+    raise "Scene #{args.state.scene} not found!" unless scene
+
+    scene.args = args
+    scene.tick
+
+    # Validate no mid-tick change
+    if args.state.scene != scene_before
+      raise "Don't change scene directly. Use args.state.next_scene"
+    end
+
+    # Apply deferred transition
+    if args.state.next_scene
+      args.state.scene = args.state.next_scene
+      args.state.next_scene = nil
+    end
+  end
+end
+
+def tick args
+  $manager ||= SceneManager.new
+  $manager.args = args
+  $manager.tick
+end
+
+def reset args
+  $manager = nil
+end

data/skills/dragonruby/examples/scenes/pause_overlay.rb

@@ -0,0 +1,100 @@
+# Pause Overlay Pattern
+# Overlay pause menu on frozen gameplay
+# Source: DragonRuby samples/99_genre_arcade/flappy_dragon
+
+def tick args
+  args.state.scene ||= :gameplay
+
+  # Toggle pause
+  if args.inputs.keyboard.key_down.escape
+    if args.state.scene == :gameplay
+      args.state.scene = :paused
+      args.state.paused_at = Kernel.tick_count
+    elsif args.state.scene == :paused
+      args.state.scene = :gameplay
+    end
+    return
+  end
+
+  send("#{args.state.scene}_tick", args)
+end
+
+def gameplay_tick args
+  args.state.player ||= { x: 640, y: 360, w: 64, h: 64 }
+  args.state.score ||= 0
+
+  # Handle input
+  speed = 5
+  args.state.player.x += speed if args.inputs.right
+  args.state.player.x -= speed if args.inputs.left
+  args.state.player.y += speed if args.inputs.up
+  args.state.player.y -= speed if args.inputs.down
+
+  # Clamp to screen
+  args.state.player.x = args.state.player.x.clamp(0, 1280 - 64)
+  args.state.player.y = args.state.player.y.clamp(0, 720 - 64)
+
+  args.state.score += 1
+
+  render_gameplay args
+end
+
+def paused_tick args
+  # Render frozen gameplay (no updates)
+  render_gameplay args
+
+  # Dark overlay
+  args.outputs.primitives << {
+    x: 0, y: 0, w: 1280, h: 720,
+    r: 0, g: 0, b: 0, a: 180
+  }.to_solid
+
+  # Pause menu
+  args.outputs.labels << {
+    x: 640, y: 450,
+    text: "PAUSED",
+    size_enum: 15,
+    anchor_x: 0.5,
+    r: 255, g: 255, b: 255
+  }
+  args.outputs.labels << {
+    x: 640, y: 350,
+    text: "Press ESC to resume",
+    anchor_x: 0.5,
+    r: 255, g: 255, b: 255
+  }
+  args.outputs.labels << {
+    x: 640, y: 300,
+    text: "Press Q to quit",
+    anchor_x: 0.5,
+    r: 255, g: 255, b: 255
+  }
+
+  if args.inputs.keyboard.key_down.q
+    $gtk.reset
+  end
+end
+
+def render_gameplay args
+  # Background
+  args.outputs.solids << {
+    x: 0, y: 0, w: 1280, h: 720,
+    r: 50, g: 80, b: 120
+  }
+
+  # Player (simple box)
+  args.outputs.solids << {
+    x: args.state.player.x,
+    y: args.state.player.y,
+    w: args.state.player.w,
+    h: args.state.player.h,
+    r: 255, g: 200, b: 100
+  }
+
+  # Score
+  args.outputs.labels << {
+    x: 40, y: 700,
+    text: "Score: #{args.state.score}",
+    r: 255, g: 255, b: 255
+  }
+end

data/skills/dragonruby/examples/scenes/safe_transitions.rb

@@ -0,0 +1,68 @@
+# Safe Scene Transitions
+# Prevents mid-tick scene changes for easier debugging
+# Source: DragonRuby samples/02_input_basics/07_managing_scenes
+
+def tick args
+  args.state.current_scene ||= :title
+
+  # Capture scene before tick
+  scene_before = args.state.current_scene
+
+  # Dispatch to scene
+  case args.state.current_scene
+  when :title
+    tick_title args
+  when :game
+    tick_game args
+  when :game_over
+    tick_game_over args
+  end
+
+  # Validate: scene should not change mid-tick
+  if args.state.current_scene != scene_before
+    raise "Scene changed mid-tick! Set args.state.next_scene instead."
+  end
+
+  # Apply deferred transition at end of tick
+  if args.state.next_scene
+    args.state.current_scene = args.state.next_scene
+    args.state.next_scene = nil
+  end
+end
+
+def tick_title args
+  args.outputs.labels << {
+    x: 640, y: 360,
+    text: "Title (click to start)",
+    anchor_x: 0.5
+  }
+
+  if args.inputs.mouse.click
+    # Use next_scene for deferred transition
+    args.state.next_scene = :game
+  end
+end
+
+def tick_game args
+  args.outputs.labels << {
+    x: 640, y: 360,
+    text: "Game (click for game over)",
+    anchor_x: 0.5
+  }
+
+  if args.inputs.mouse.click
+    args.state.next_scene = :game_over
+  end
+end
+
+def tick_game_over args
+  args.outputs.labels << {
+    x: 640, y: 360,
+    text: "Game Over (click to restart)",
+    anchor_x: 0.5
+  }
+
+  if args.inputs.mouse.click
+    args.state.next_scene = :title
+  end
+end

data/skills/dragonruby/examples/scenes/scene_transitions.rb

@@ -0,0 +1,98 @@
+# Scene Transition Patterns
+# Various ways to handle scene changes
+
+# --- Pattern 1: Instant Transition ---
+def instant_transition args
+  args.state.scene = :new_scene
+  return  # Important: early return
+end
+
+# --- Pattern 2: Tracked Transition ---
+# Track when scene changed for animations/effects
+def change_to_scene args, scene
+  args.state.scene = scene
+  args.state.scene_at = Kernel.tick_count
+  args.inputs.keyboard.clear  # Prevent input bleed
+end
+
+def title_tick_with_fade args
+  elapsed = Kernel.tick_count - (args.state.scene_at || 0)
+  alpha = [255, elapsed * 8].min  # Fade in over ~32 frames
+
+  args.outputs.labels << {
+    x: 640, y: 400,
+    text: "Title",
+    anchor_x: 0.5,
+    a: alpha
+  }
+end
+
+# --- Pattern 3: State Reset on Transition ---
+def transition_to_gameplay args
+  # Reset gameplay state
+  args.state.player = nil  # Will reinitialize
+  args.state.enemies = []
+  args.state.score = 0
+  args.state.timer = 60 * 60
+
+  # Keep persistent state
+  # args.state.high_score preserved
+
+  args.state.scene = :gameplay
+end
+
+# --- Pattern 4: Full Game Reset ---
+def restart_game
+  $gtk.reset  # Clears ALL state, tick_count resets
+end
+
+# --- Pattern 5: Grace Period ---
+# Prevent accidental input after scene change
+def game_over_tick args
+  args.state.grace_timer ||= 60  # 1 second grace period
+  args.state.grace_timer -= 1
+
+  args.outputs.labels << {
+    x: 640, y: 400,
+    text: "Game Over!",
+    anchor_x: 0.5
+  }
+
+  # Don't accept input during grace period
+  return if args.state.grace_timer > 0
+
+  args.outputs.labels << {
+    x: 640, y: 300,
+    text: "Press SPACE to restart",
+    anchor_x: 0.5
+  }
+
+  if args.inputs.keyboard.key_down.space
+    $gtk.reset
+  end
+end
+
+# --- Example: Complete Flow ---
+def tick args
+  args.state.scene ||= :title
+
+  case args.state.scene
+  when :title
+    args.outputs.labels << { x: 640, y: 400, text: "Title - Press SPACE", anchor_x: 0.5 }
+    if args.inputs.keyboard.key_down.space
+      transition_to_gameplay args
+    end
+
+  when :gameplay
+    args.state.timer ||= 60 * 60
+    args.state.timer -= 1
+    args.outputs.labels << { x: 640, y: 400, text: "Time: #{(args.state.timer / 60).ceil}", anchor_x: 0.5 }
+    if args.state.timer <= 0
+      args.state.scene = :game_over
+      args.state.grace_timer = nil  # Reset for game_over_tick
+    end
+
+  when :game_over
+    game_over_tick args
+  end
+end

data/skills/dragonruby/examples/scenes/send_dispatch.rb

@@ -0,0 +1,88 @@
+# Send-Based Scene Dispatch
+# Simplest pattern using Ruby's dynamic method dispatch
+# Source: DragonRuby book Chapter 11
+
+def tick args
+  args.state.scene ||= :title
+  send("#{args.state.scene}_tick", args)
+end
+
+def title_tick args
+  args.outputs.labels << {
+    x: 640, y: 500,
+    text: "My Game",
+    size_enum: 10,
+    anchor_x: 0.5
+  }
+  args.outputs.labels << {
+    x: 640, y: 300,
+    text: "Press SPACE to start",
+    anchor_x: 0.5
+  }
+
+  if args.inputs.keyboard.key_down.space
+    args.state.scene = :gameplay
+    return  # Early return prevents old scene code
+  end
+end
+
+def gameplay_tick args
+  args.state.player ||= { x: 640, y: 360, w: 64, h: 64, path: "sprites/player.png" }
+  args.state.score ||= 0
+  args.state.timer ||= 30 * 60
+
+  args.state.timer -= 1
+
+  if args.state.timer <= 0
+    args.state.scene = :game_over
+    return
+  end
+
+  # Handle input
+  speed = 5
+  args.state.player.x += speed if args.inputs.right
+  args.state.player.x -= speed if args.inputs.left
+  args.state.player.y += speed if args.inputs.up
+  args.state.player.y -= speed if args.inputs.down
+
+  # Render
+  args.outputs.sprites << args.state.player
+  args.outputs.labels << {
+    x: 40, y: 700,
+    text: "Score: #{args.state.score}"
+  }
+  args.outputs.labels << {
+    x: 1240, y: 700,
+    text: "Time: #{(args.state.timer / 60).ceil}",
+    anchor_x: 1
+  }
+end
+
+def game_over_tick args
+  args.state.timer -= 1
+
+  args.outputs.labels << {
+    x: 640, y: 450,
+    text: "Game Over!",
+    size_enum: 10,
+    anchor_x: 0.5
+  }
+  args.outputs.labels << {
+    x: 640, y: 350,
+    text: "Score: #{args.state.score}",
+    size_enum: 4,
+    anchor_x: 0.5
+  }
+  args.outputs.labels << {
+    x: 640, y: 200,
+    text: "Press SPACE to restart",
+    anchor_x: 0.5
+  }
+
+  # Grace period before accepting input
+  return if args.state.timer > -30
+
+  if args.inputs.keyboard.key_down.space
+    $gtk.reset
+  end
+end