anima-core 0.3.0 → 1.0.0

data/skills/dragonruby/examples/distribution/game_metadata_hd.txt

@@ -0,0 +1,23 @@
+# HD game with high-DPI and linear scaling
+# For modern desktop/web releases
+
+devid=youritchusername
+devtitle=Your Studio Name
+gameid=my-hd-game
+gametitle=My HD Game
+version=1.0
+icon=metadata/icon.png
+
+# Enable HD rendering (720p, 1080p, 1440p, 4k)
+hd=true
+highdpi=true
+
+# Linear scaling for non-pixel-art games
+# 0=nearest (pixel art), 1=linear, 2=anisotropic
+scale_quality=1
+
+# Letterbox to maintain 16:9 aspect ratio
+hd_letterbox=true
+
+# Maximum scale: 0=stretch, 100=720p, 150=1080p, 200=1440p, 300=4k
+hd_max_scale=0

data/skills/dragonruby/examples/distribution/game_metadata_minimal.txt

@@ -0,0 +1,9 @@
+# Minimal game_metadata.txt - All required fields
+# Location: mygame/metadata/game_metadata.txt
+
+devid=youritchusername
+devtitle=Your Name
+gameid=my-game-slug
+gametitle=My Game Title
+version=0.1
+icon=metadata/icon.png

data/skills/dragonruby/examples/distribution/game_metadata_mobile.txt

@@ -0,0 +1,31 @@
+# Mobile-ready game_metadata.txt
+# For Android/iOS deployment
+
+devid=youritchusername
+devtitle=Your Studio Name
+gameid=my-mobile-game
+gametitle=My Mobile Game
+version=1.0
+icon=metadata/icon.png
+
+# Required for Android/iOS
+packageid=com.yourstudio.mygame
+
+# HD mode for modern devices
+hd=true
+highdpi=true
+
+# Portrait orientation (540x960 logical)
+orientation=portrait
+# Or landscape,portrait for rotation support
+
+# Platform-specific orientation overrides
+orientation_ios=portrait,landscape
+orientation_android=portrait,landscape
+
+# Edge-to-edge rendering (no letterbox)
+hd_letterbox=false
+hd_max_scale=400
+
+# Exclude dev files from builds
+ignore_directories=saves,debug,tmp

data/skills/dragonruby/examples/distribution/platform_detection.rb

@@ -0,0 +1,36 @@
+# Platform-specific behavior at runtime
+
+def tick(args)
+  handle_platform_quirks(args)
+  tick_game(args)
+end
+
+def handle_platform_quirks(args)
+  # Open app store rating page
+  if args.state.show_rating_prompt
+    open_rating_page(args)
+    args.state.show_rating_prompt = false
+  end
+end
+
+def open_rating_page(args)
+  if args.gtk.platform?(:ios)
+    args.gtk.openurl "itms-apps://itunes.apple.com/app/idYOURGAMEID?action=write-review"
+  elsif args.gtk.platform?(:android)
+    args.gtk.openurl "https://play.google.com/store/apps/details?id=com.yourstudio.mygame"
+  elsif args.gtk.platform?(:web)
+    args.gtk.openurl "https://yourusername.itch.io/yourgame/purchase"
+  else
+    # Desktop (Windows, macOS, Linux)
+    args.gtk.openurl "https://yourusername.itch.io/yourgame/rate?source=game"
+  end
+end
+
+# Platform-specific asset paths
+def get_save_path(args)
+  if args.gtk.platform?(:web)
+    "save.dat"  # Web uses IndexedDB via same path
+  else
+    "saves/game.dat"
+  end
+end

data/skills/dragonruby/examples/distribution/steam_metadata.txt

@@ -0,0 +1,19 @@
+# Steam publishing configuration
+# Location: mygame/metadata/steam_metadata.txt
+
+# Enable Steam publishing
+steam.publish=true
+
+# Steam branch to publish to
+steam.branch=public
+
+# Your Steamworks Partner Site login name
+steam.username=YOUR_STEAM_USERNAME
+
+# Your Steam AppID (from Steamworks)
+steam.appid=YOUR_APP_ID
+
+# Platform-specific Depot IDs (from Steamworks)
+steam.linux_depotid=LINUX_DEPOT_ID
+steam.windows_depotid=WINDOWS_DEPOT_ID
+steam.mac_depotid=MAC_DEPOT_ID

data/skills/dragonruby/examples/entities/collision_detection.rb

@@ -0,0 +1,43 @@
+# Collision Detection Patterns
+# Demonstrates intersect_rect? and find_intersect_rect
+
+def tick(args)
+  args.state.player ||= { x: 640, y: 360, w: 32, h: 32 }
+  args.state.enemies ||= 8.map { |i| { x: i * 150 + 50, y: 300, w: 40, h: 40 } }
+
+  # Move player with arrow keys
+  args.state.player.x += args.inputs.left_right * 5
+  args.state.player.y += args.inputs.up_down * 5
+
+  # Reset hit status
+  args.state.enemies.each { |e| e.hit = false }
+
+  # Method 1: intersect_rect? - check each entity
+  args.state.enemies.each do |enemy|
+    if args.state.player.intersect_rect?(enemy)
+      enemy.hit = true
+    end
+  end
+
+  # Method 2: find_intersect_rect - returns first collision (faster)
+  collision = Geometry.find_intersect_rect(
+    args.state.player,
+    args.state.enemies
+  )
+
+  # Method 3: find_all_intersect_rect - returns all collisions
+  all_hits = Geometry.find_all_intersect_rect(
+    args.state.player,
+    args.state.enemies
+  )
+
+  # Render player (green)
+  args.outputs.solids << args.state.player.merge(r: 0, g: 255, b: 0)
+
+  # Render enemies (red if hit, gray otherwise)
+  args.outputs.borders << args.state.enemies.map do |e|
+    e.merge(r: e.hit ? 255 : 128, g: e.hit ? 0 : 128, b: e.hit ? 0 : 128)
+  end
+
+  args.outputs.labels << { x: 10, y: 710, text: "Collisions: #{all_hits.length}" }
+end

data/skills/dragonruby/examples/entities/entity_lifecycle.rb

@@ -0,0 +1,68 @@
+# Entity Lifecycle Pattern
+# Demonstrates: create -> update -> mark dead -> reject
+
+def tick(args)
+  defaults(args)
+  spawn_bullets(args)
+  update_bullets(args)
+  check_collisions(args)
+  cleanup_dead(args)
+  render(args)
+end
+
+def defaults(args)
+  args.state.bullets ||= []
+  args.state.targets ||= 5.map { |i| { x: 1000, y: i * 120 + 100, w: 50, h: 50, dead: false } }
+end
+
+# Step 1: CREATE entities
+def spawn_bullets(args)
+  return unless args.inputs.mouse.click
+
+  args.state.bullets << {
+    x: 0,
+    y: args.inputs.mouse.y,
+    w: 10,
+    h: 10,
+    speed: 12,
+    dead: false
+  }
+end
+
+# Step 2: UPDATE entities
+def update_bullets(args)
+  args.state.bullets.each do |bullet|
+    bullet.x += bullet.speed
+
+    # Mark off-screen bullets as dead
+    bullet.dead = true if bullet.x > args.grid.w
+  end
+end
+
+# Step 3: MARK dead on collision (don't modify arrays during iteration)
+def check_collisions(args)
+  args.state.bullets.each do |bullet|
+    next if bullet.dead
+
+    args.state.targets.each do |target|
+      next if target.dead
+
+      if Geometry.intersect_rect?(bullet, target)
+        bullet.dead = true
+        target.dead = true
+      end
+    end
+  end
+end
+
+# Step 4: REJECT dead entities after all processing
+def cleanup_dead(args)
+  args.state.bullets.reject!(&:dead)
+  args.state.targets.reject!(&:dead)
+end
+
+def render(args)
+  args.outputs.solids << args.state.bullets.map { |b| b.merge(r: 255, g: 200, b: 0) }
+  args.outputs.borders << args.state.targets
+  args.outputs.labels << { x: 10, y: 710, text: "Click to shoot. Targets: #{args.state.targets.length}" }
+end

data/skills/dragonruby/examples/entities/entity_storage.rb

@@ -0,0 +1,38 @@
+# Entity Storage Pattern
+# Demonstrates storing entities in args.state arrays
+
+def tick(args)
+  # Initialize entity collections as empty arrays
+  # The ||= ensures they're only created once
+  args.state.enemies ||= []
+  args.state.bullets ||= []
+
+  # Add entities to collections on input
+  if args.inputs.mouse.click
+    args.state.bullets << {
+      x: 0,
+      y: args.inputs.mouse.y,
+      w: 10,
+      h: 10,
+      speed: 5
+    }
+  end
+
+  # Spawn enemies every 60 frames (1 second)
+  if args.state.tick_count.zmod?(60)
+    args.state.enemies << {
+      x: 1280,
+      y: rand * 720,
+      w: 32,
+      h: 32
+    }
+  end
+
+  # Render all entities from arrays
+  args.outputs.solids << args.state.bullets
+  args.outputs.borders << args.state.enemies
+
+  # Display counts
+  args.outputs.labels << { x: 10, y: 710, text: "Enemies: #{args.state.enemies.length}" }
+  args.outputs.labels << { x: 10, y: 690, text: "Bullets: #{args.state.bullets.length}" }
+end

data/skills/dragonruby/examples/entities/factory_methods.rb

@@ -0,0 +1,45 @@
+# Factory Methods Pattern
+# Demonstrates spawn_* factory methods for entity creation
+
+def tick(args)
+  args.state.enemies ||= []
+  args.state.projectiles ||= []
+
+  # Spawn enemies using factory method
+  spawn_enemy(args) if args.state.tick_count.zmod?(90)
+
+  # Spawn projectiles on click
+  spawn_projectile(args, args.inputs.mouse) if args.inputs.mouse.click
+
+  # Update entities
+  args.state.projectiles.each { |p| p.x += p.speed }
+
+  # Render
+  args.outputs.borders << args.state.enemies
+  args.outputs.solids << args.state.projectiles
+end
+
+# Factory method: encapsulates entity creation logic
+def spawn_enemy(args)
+  size = 40
+  args.state.enemies << {
+    x: args.grid.w + size,
+    y: rand(args.grid.h - size * 2) + size,
+    w: size,
+    h: size,
+    path: 'sprites/enemy.png',
+    speed: rand(3) + 1
+  }
+end
+
+# Factory with parameters
+def spawn_projectile(args, mouse)
+  args.state.projectiles << {
+    x: 0,
+    y: mouse.y,
+    w: 8,
+    h: 8,
+    speed: rand * 8 + 4,
+    r: 255, g: 128, b: 0
+  }
+end

data/skills/dragonruby/examples/entities/random_spawning.rb

@@ -0,0 +1,50 @@
+# Random Spawning with Gutters
+# Demonstrates safe positioning within screen bounds
+
+def tick(args)
+  args.state.enemies ||= []
+
+  # Spawn enemy every 45 frames
+  if args.state.tick_count.zmod?(45)
+    args.state.enemies << spawn_with_gutters(args)
+  end
+
+  # Render enemies
+  args.outputs.sprites << args.state.enemies
+
+  # Show play area boundary
+  gutter = 50
+  args.outputs.primitives << { x: gutter, y: gutter, w: 1280 - gutter * 2, h: 720 - gutter * 2, r: 128, g: 128, b: 128, primitive_marker: :border }
+  args.outputs.labels << { x: 10, y: 710, text: "Enemies spawn within gray boundary" }
+end
+
+# Safe spawn: entities never appear partially off-screen
+def spawn_with_gutters(args)
+  size = 32
+  gutter = 50
+
+  # Available spawn area (screen minus gutters on all sides)
+  play_w = args.grid.w - gutter * 2 - size
+  play_h = args.grid.h - gutter * 2 - size
+
+  {
+    x: gutter + rand * play_w,
+    y: gutter + rand * play_h,
+    w: size,
+    h: size,
+    path: 'sprites/enemy.png'
+  }
+end
+
+# Alternative: spawn only on right side of screen
+def spawn_right_side(args)
+  size = 40
+  {
+    # Right 40% of screen: rand(width * 0.4) + width * 0.6
+    x: rand(args.grid.w * 0.4) + args.grid.w * 0.6,
+    # Full height with top/bottom gutters
+    y: rand(args.grid.h - size * 2) + size,
+    w: size,
+    h: size
+  }
+end

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

@@ -0,0 +1,98 @@
+# Reset Patterns in DragonRuby
+# Demonstrates full reset, partial reset, and custom reset handlers
+
+def tick(args)
+  defaults(args)
+  handle_input(args)
+  render(args)
+end
+
+def defaults(args)
+  args.state.score ||= 0
+  args.state.level ||= 1
+  args.state.high_score ||= 0  # Persists across $gtk.reset
+  args.state.player ||= { x: 640, y: 360 }
+end
+
+def handle_input(args)
+  # Move player
+  args.state.player.x -= 5 if args.inputs.left
+  args.state.player.x += 5 if args.inputs.right
+  args.state.player.y -= 5 if args.inputs.down
+  args.state.player.y += 5 if args.inputs.up
+
+  # Add score
+  if args.inputs.keyboard.key_down.space
+    args.state.score += 10
+    args.state.level += 1 if args.state.score.zmod?(100)
+  end
+
+  # Update high score
+  args.state.high_score = [args.state.high_score, args.state.score].max
+
+  # Pattern 1: Full reset (clears all args.state)
+  if args.inputs.keyboard.key_down.r
+    $gtk.reset
+  end
+
+  # Pattern 2: Partial reset (preserve some state)
+  if args.inputs.keyboard.key_down.p
+    partial_reset(args)
+  end
+
+  # Pattern 3: Soft reset (reset position only)
+  if args.inputs.keyboard.key_down.s
+    soft_reset(args)
+  end
+end
+
+# Full reset clears everything - use ||= with values you want to persist
+# High score persists because of ||= pattern in defaults
+
+# Pattern 2: Partial reset - keep high score, reset game
+def partial_reset(args)
+  # Save what we want to keep
+  high_score = args.state.high_score
+
+  # Clear specific state
+  args.state.score = 0
+  args.state.level = 1
+  args.state.player = { x: 640, y: 360 }
+
+  # Note: high_score wasn't touched, so it remains
+end
+
+# Pattern 3: Soft reset - minimal state change
+def soft_reset(args)
+  args.state.player.x = 640
+  args.state.player.y = 360
+  # Keep score and level
+end
+
+def render(args)
+  # Player
+  args.outputs.solids << {
+    x: args.state.player.x - 25,
+    y: args.state.player.y - 25,
+    w: 50, h: 50, r: 0, g: 150, b: 255
+  }
+
+  # Stats
+  args.outputs.labels << { x: 40, y: 700, text: "Score: #{args.state.score}", size_enum: 5 }
+  args.outputs.labels << { x: 40, y: 660, text: "Level: #{args.state.level}", size_enum: 3 }
+  args.outputs.labels << { x: 40, y: 620, text: "High Score: #{args.state.high_score}", size_enum: 3, r: 255, g: 215, b: 0 }
+
+  # Instructions
+  args.outputs.labels << { x: 40, y: 100, text: "Arrows: Move | SPACE: Score" }
+  args.outputs.labels << { x: 40, y: 70, text: "R: Full reset | P: Partial reset | S: Soft reset" }
+end
+
+# Custom reset handler - called when $gtk.reset executes
+def reset(args)
+  puts "Game reset! Custom cleanup here."
+  # Clear any global variables or class instances
+  $game = nil if defined?($game)
+end
+
+# Development convenience: uncomment to reset on code reload
+# $gtk.reset

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

@@ -0,0 +1,101 @@
+# Save/Load Patterns in DragonRuby
+# Demonstrates file persistence for game data
+
+HIGH_SCORE_FILE = "high-score.txt"
+SAVE_FILE = "game-save.txt"
+
+def tick(args)
+  defaults(args)
+  handle_input(args)
+  render(args)
+end
+
+def defaults(args)
+  args.state.score ||= 0
+  args.state.level ||= 1
+  args.state.player_name ||= "Player"
+
+  # Load high score on first tick (nil-safe with .to_i)
+  args.state.high_score ||= $gtk.read_file(HIGH_SCORE_FILE).to_i
+end
+
+def handle_input(args)
+  # Increment score for testing
+  if args.inputs.keyboard.key_down.space
+    args.state.score += 10
+  end
+
+  # Save high score (simple pattern)
+  if args.inputs.keyboard.key_down.s
+    save_high_score(args)
+  end
+
+  # Full game save (serialize_state)
+  if args.inputs.keyboard.key_down.f5
+    save_game(args)
+  end
+
+  # Load game
+  if args.inputs.keyboard.key_down.f9
+    load_game(args)
+  end
+
+  # Reset
+  if args.inputs.keyboard.key_down.r
+    args.state.score = 0
+    args.state.level = 1
+  end
+end
+
+# Pattern 1: Simple high score save (with save-once flag)
+def save_high_score(args)
+  if args.state.score > args.state.high_score
+    $gtk.write_file(HIGH_SCORE_FILE, args.state.score.to_s)
+    args.state.high_score = args.state.score
+    $gtk.notify!("High score saved!")
+  else
+    $gtk.notify!("Score not high enough")
+  end
+end
+
+# Pattern 2: Full state serialization
+def save_game(args)
+  # Create save data hash (subset of state)
+  save_data = {
+    score: args.state.score,
+    level: args.state.level,
+    player_name: args.state.player_name,
+    saved_at: Time.now.to_i
+  }
+
+  $gtk.serialize_state(SAVE_FILE, save_data)
+  $gtk.notify!("Game saved!")
+end
+
+# Pattern 3: Load with validation
+def load_game(args)
+  loaded = $gtk.deserialize_state(SAVE_FILE)
+
+  if loaded
+    args.state.score = loaded.score || 0
+    args.state.level = loaded.level || 1
+    args.state.player_name = loaded.player_name || "Player"
+    $gtk.notify!("Game loaded!")
+  else
+    $gtk.notify!("No save file found")
+  end
+end
+
+def render(args)
+  args.outputs.labels << { x: 40, y: 700, text: "Score: #{args.state.score}", size_enum: 5 }
+  args.outputs.labels << { x: 40, y: 650, text: "Level: #{args.state.level}", size_enum: 3 }
+  args.outputs.labels << { x: 40, y: 600, text: "High Score: #{args.state.high_score}", size_enum: 3 }
+
+  # File status
+  save_exists = $gtk.stat_file(SAVE_FILE) ? "Yes" : "No"
+  args.outputs.labels << { x: 40, y: 500, text: "Save file exists: #{save_exists}" }
+
+  # Instructions
+  args.outputs.labels << { x: 40, y: 100, text: "SPACE: +10 score | S: Save high score" }
+  args.outputs.labels << { x: 40, y: 70, text: "F5: Save game | F9: Load game | R: Reset" }
+end

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

@@ -0,0 +1,104 @@
+# Scoring System in DragonRuby
+# Demonstrates score tracking, high score persistence, and display
+
+def tick(args)
+  defaults(args)
+  handle_input(args)
+  render(args)
+end
+
+def defaults(args)
+  args.state.score ||= 0
+  args.state.high_score ||= 0  # Persists across $gtk.reset
+  args.state.combo ||= 0
+  args.state.multiplier ||= 1
+end
+
+# Scoring patterns
+def handle_input(args)
+  # Simple score increment
+  if args.inputs.keyboard.key_down.space
+    add_score(args, 10)
+  end
+
+  # Score with multiplier
+  if args.inputs.keyboard.key_down.z
+    add_score_with_combo(args, 100)
+  end
+
+  # Break combo
+  if args.inputs.keyboard.key_down.x
+    reset_combo(args)
+  end
+
+  # Reset game (high score persists)
+  if args.inputs.keyboard.key_down.r
+    args.state.score = 0
+    args.state.combo = 0
+    args.state.multiplier = 1
+  end
+end
+
+# Pattern 1: Simple score increment
+def add_score(args, points)
+  args.state.score += points
+  update_high_score(args)
+end
+
+# Pattern 2: Score with combo multiplier
+def add_score_with_combo(args, base_points)
+  args.state.combo += 1
+  args.state.multiplier = [1 + (args.state.combo / 5), 4].min  # Max 4x
+
+  points = base_points * args.state.multiplier
+  args.state.score += points
+  update_high_score(args)
+end
+
+# Pattern 3: High score tracking
+def update_high_score(args)
+  if args.state.score > args.state.high_score
+    args.state.high_score = args.state.score
+    args.state.new_high_score = true
+  end
+end
+
+def reset_combo(args)
+  args.state.combo = 0
+  args.state.multiplier = 1
+end
+
+def render(args)
+  # Current score
+  args.outputs.labels << {
+    x: 40, y: 700, text: "SCORE: #{args.state.score}",
+    size_enum: 5
+  }
+
+  # High score
+  args.outputs.labels << {
+    x: 40, y: 650, text: "HIGH SCORE: #{args.state.high_score}",
+    size_enum: 3, r: 255, g: 215, b: 0
+  }
+
+  # Combo/multiplier
+  if args.state.combo > 0
+    args.outputs.labels << {
+      x: 40, y: 600, text: "COMBO: #{args.state.combo} (x#{args.state.multiplier})",
+      size_enum: 3, r: 255, g: 100, b: 100
+    }
+  end
+
+  # New high score notification
+  if args.state.new_high_score
+    args.outputs.labels << {
+      x: 640, y: 400, text: "NEW HIGH SCORE!",
+      size_enum: 8, anchor_x: 0.5, r: 255, g: 215, b: 0
+    }
+  end
+
+  # Instructions
+  args.outputs.labels << { x: 40, y: 100, text: "SPACE: +10 points" }
+  args.outputs.labels << { x: 40, y: 70, text: "Z: +100 with combo" }
+  args.outputs.labels << { x: 40, y: 40, text: "X: Break combo | R: Reset score" }
+end