617 lines
21 KiB
Python
617 lines
21 KiB
Python
#!/usr/bin/env python3
|
|
"""
|
|
McRogueFace Animation Sizzle Reel
|
|
=================================
|
|
|
|
This script demonstrates EVERY animation type on EVERY UI object type.
|
|
It showcases all 30 easing functions, all animatable properties, and
|
|
special animation modes (delta, sprite sequences, text effects).
|
|
|
|
The script creates a comprehensive visual demonstration of the animation
|
|
system's capabilities, cycling through different objects and effects.
|
|
|
|
Author: Claude
|
|
Purpose: Complete animation system demonstration
|
|
"""
|
|
|
|
import mcrfpy
|
|
from mcrfpy import Color, Frame, Caption, Sprite, Grid, Entity, Texture, Animation
|
|
import sys
|
|
import math
|
|
|
|
# Configuration
|
|
SCENE_WIDTH = 1280
|
|
SCENE_HEIGHT = 720
|
|
DEMO_DURATION = 5.0 # Duration for each demo section
|
|
|
|
# All available easing functions
|
|
EASING_FUNCTIONS = [
|
|
"linear", "easeIn", "easeOut", "easeInOut",
|
|
"easeInQuad", "easeOutQuad", "easeInOutQuad",
|
|
"easeInCubic", "easeOutCubic", "easeInOutCubic",
|
|
"easeInQuart", "easeOutQuart", "easeInOutQuart",
|
|
"easeInSine", "easeOutSine", "easeInOutSine",
|
|
"easeInExpo", "easeOutExpo", "easeInOutExpo",
|
|
"easeInCirc", "easeOutCirc", "easeInOutCirc",
|
|
"easeInElastic", "easeOutElastic", "easeInOutElastic",
|
|
"easeInBack", "easeOutBack", "easeInOutBack",
|
|
"easeInBounce", "easeOutBounce", "easeInOutBounce"
|
|
]
|
|
|
|
# Track current demo state
|
|
current_demo = 0
|
|
demo_start_time = 0
|
|
demos = []
|
|
|
|
# Handle ESC key to exit
|
|
def handle_keypress(scene_name, keycode):
|
|
if keycode == 256: # ESC key
|
|
print("Exiting animation sizzle reel...")
|
|
sys.exit(0)
|
|
|
|
def create_demo_scene():
|
|
"""Create the main demo scene with title"""
|
|
mcrfpy.createScene("sizzle_reel")
|
|
mcrfpy.setScene("sizzle_reel")
|
|
mcrfpy.keypressScene(handle_keypress)
|
|
|
|
ui = mcrfpy.sceneUI("sizzle_reel")
|
|
|
|
# Title caption
|
|
title = Caption("McRogueFace Animation Sizzle Reel",
|
|
SCENE_WIDTH/2 - 200, 20)
|
|
title.fill_color = Color(255, 255, 0)
|
|
title.outline = 2
|
|
title.outline_color = Color(0, 0, 0)
|
|
ui.append(title)
|
|
|
|
# Subtitle showing current demo
|
|
global subtitle
|
|
subtitle = Caption("Initializing...",
|
|
SCENE_WIDTH/2 - 150, 60)
|
|
subtitle.fill_color = Color(200, 200, 200)
|
|
ui.append(subtitle)
|
|
|
|
return ui
|
|
|
|
def demo_frame_basic_animations(ui):
|
|
"""Demo 1: Basic frame animations - position, size, colors"""
|
|
subtitle.text = "Demo 1: Frame Basic Animations (Position, Size, Colors)"
|
|
|
|
# Create test frame
|
|
frame = Frame(100, 150, 200, 100)
|
|
frame.fill_color = Color(50, 50, 150)
|
|
frame.outline = 3
|
|
frame.outline_color = Color(255, 255, 255)
|
|
ui.append(frame)
|
|
|
|
# Position animations with different easings
|
|
x_anim = Animation("x", 800.0, 2.0, "easeInOutBack")
|
|
y_anim = Animation("y", 400.0, 2.0, "easeInOutElastic")
|
|
x_anim.start(frame)
|
|
y_anim.start(frame)
|
|
|
|
# Size animations
|
|
w_anim = Animation("w", 400.0, 3.0, "easeInOutCubic")
|
|
h_anim = Animation("h", 200.0, 3.0, "easeInOutCubic")
|
|
w_anim.start(frame)
|
|
h_anim.start(frame)
|
|
|
|
# Color animations - use tuples instead of Color objects
|
|
fill_anim = Animation("fill_color", (255, 100, 50, 200), 4.0, "easeInOutSine")
|
|
outline_anim = Animation("outline_color", (0, 255, 255, 255), 4.0, "easeOutBounce")
|
|
fill_anim.start(frame)
|
|
outline_anim.start(frame)
|
|
|
|
# Outline thickness animation
|
|
thickness_anim = Animation("outline", 10.0, 4.5, "easeInOutQuad")
|
|
thickness_anim.start(frame)
|
|
|
|
return frame
|
|
|
|
def demo_frame_opacity_zindex(ui):
|
|
"""Demo 2: Frame opacity and z-index animations"""
|
|
subtitle.text = "Demo 2: Frame Opacity & Z-Index Animations"
|
|
|
|
frames = []
|
|
colors = [
|
|
Color(255, 0, 0, 200),
|
|
Color(0, 255, 0, 200),
|
|
Color(0, 0, 255, 200),
|
|
Color(255, 255, 0, 200)
|
|
]
|
|
|
|
# Create overlapping frames
|
|
for i in range(4):
|
|
frame = Frame(200 + i*80, 200 + i*40, 200, 150)
|
|
frame.fill_color = colors[i]
|
|
frame.outline = 2
|
|
frame.z_index = i
|
|
ui.append(frame)
|
|
frames.append(frame)
|
|
|
|
# Animate opacity in waves
|
|
opacity_anim = Animation("opacity", 0.3, 2.0, "easeInOutSine")
|
|
opacity_anim.start(frame)
|
|
|
|
# Reverse opacity animation
|
|
opacity_back = Animation("opacity", 1.0, 2.0, "easeInOutSine", delta=False)
|
|
mcrfpy.setTimer(f"opacity_back_{i}", lambda t, f=frame, a=opacity_back: a.start(f), 2000)
|
|
|
|
# Z-index shuffle animation
|
|
z_anim = Animation("z_index", (i + 2) % 4, 3.0, "linear")
|
|
z_anim.start(frame)
|
|
|
|
return frames
|
|
|
|
def demo_caption_animations(ui):
|
|
"""Demo 3: Caption text animations and effects"""
|
|
subtitle.text = "Demo 3: Caption Animations (Text, Color, Position)"
|
|
|
|
# Basic caption with position animation
|
|
caption1 = Caption("Moving Text!", 100, 200)
|
|
caption1.fill_color = Color(255, 255, 255)
|
|
caption1.outline = 1
|
|
ui.append(caption1)
|
|
|
|
# Animate across screen with bounce
|
|
x_anim = Animation("x", 900.0, 3.0, "easeOutBounce")
|
|
x_anim.start(caption1)
|
|
|
|
# Color cycling caption
|
|
caption2 = Caption("Rainbow Colors", 400, 300)
|
|
caption2.outline = 2
|
|
ui.append(caption2)
|
|
|
|
# Cycle through colors - use tuples
|
|
color_anim1 = Animation("fill_color", (255, 0, 0, 255), 1.0, "linear")
|
|
color_anim2 = Animation("fill_color", (0, 255, 0, 255), 1.0, "linear")
|
|
color_anim3 = Animation("fill_color", (0, 0, 255, 255), 1.0, "linear")
|
|
color_anim4 = Animation("fill_color", (255, 255, 255, 255), 1.0, "linear")
|
|
|
|
color_anim1.start(caption2)
|
|
mcrfpy.setTimer("color2", lambda t: color_anim2.start(caption2), 1000)
|
|
mcrfpy.setTimer("color3", lambda t: color_anim3.start(caption2), 2000)
|
|
mcrfpy.setTimer("color4", lambda t: color_anim4.start(caption2), 3000)
|
|
|
|
# Typewriter effect caption
|
|
caption3 = Caption("", 100, 400)
|
|
caption3.fill_color = Color(0, 255, 255)
|
|
ui.append(caption3)
|
|
|
|
typewriter = Animation("text", "This text appears one character at a time...", 3.0, "linear")
|
|
typewriter.start(caption3)
|
|
|
|
# Size animation caption
|
|
caption4 = Caption("Growing Text", 400, 500)
|
|
caption4.fill_color = Color(255, 200, 0)
|
|
ui.append(caption4)
|
|
|
|
# Note: size animation would require font size property support
|
|
# For now, animate position to simulate growth
|
|
scale_sim = Animation("y", 480.0, 2.0, "easeInOutElastic")
|
|
scale_sim.start(caption4)
|
|
|
|
return [caption1, caption2, caption3, caption4]
|
|
|
|
def demo_sprite_animations(ui):
|
|
"""Demo 4: Sprite animations including sprite sequences"""
|
|
subtitle.text = "Demo 4: Sprite Animations (Position, Scale, Sprite Sequences)"
|
|
|
|
# Load a test texture (you'll need to adjust path)
|
|
try:
|
|
texture = Texture("assets/sprites/player.png", grid_size=(32, 32))
|
|
except:
|
|
# Fallback if texture not found
|
|
texture = None
|
|
|
|
if texture:
|
|
# Basic sprite with position animation
|
|
sprite1 = Sprite(100, 200, texture, sprite_index=0)
|
|
sprite1.scale = 2.0
|
|
ui.append(sprite1)
|
|
|
|
# Circular motion using sin/cos animations
|
|
# We'll use delta mode to create circular motion
|
|
x_circle = Animation("x", 300.0, 4.0, "easeInOutSine")
|
|
y_circle = Animation("y", 300.0, 4.0, "easeInOutCubic")
|
|
x_circle.start(sprite1)
|
|
y_circle.start(sprite1)
|
|
|
|
# Sprite sequence animation (walking cycle)
|
|
sprite2 = Sprite(500, 300, texture, sprite_index=0)
|
|
sprite2.scale = 3.0
|
|
ui.append(sprite2)
|
|
|
|
# Animate through sprite indices for animation
|
|
walk_cycle = Animation("sprite_index", [0, 1, 2, 3, 2, 1], 2.0, "linear")
|
|
walk_cycle.start(sprite2)
|
|
|
|
# Scale pulsing sprite
|
|
sprite3 = Sprite(800, 400, texture, sprite_index=4)
|
|
ui.append(sprite3)
|
|
|
|
# Note: scale animation would need to be supported
|
|
# For now use position to simulate
|
|
pulse_y = Animation("y", 380.0, 0.5, "easeInOutSine")
|
|
pulse_y.start(sprite3)
|
|
|
|
# Z-index animation for layering
|
|
sprite3_z = Animation("z_index", 10, 2.0, "linear")
|
|
sprite3_z.start(sprite3)
|
|
|
|
return [sprite1, sprite2, sprite3]
|
|
else:
|
|
# Create placeholder caption if no texture
|
|
no_texture = Caption("(Sprite demo requires texture file)", 400, 350)
|
|
no_texture.fill_color = Color(255, 100, 100)
|
|
ui.append(no_texture)
|
|
return [no_texture]
|
|
|
|
def demo_grid_animations(ui):
|
|
"""Demo 5: Grid animations (position, camera, zoom)"""
|
|
subtitle.text = "Demo 5: Grid Animations (Position, Camera Effects)"
|
|
|
|
# Create a grid
|
|
try:
|
|
texture = Texture("assets/sprites/tiles.png", grid_size=(16, 16))
|
|
except:
|
|
texture = None
|
|
|
|
# Grid constructor: Grid(grid_x, grid_y, texture, position, size)
|
|
# Note: tile dimensions are determined by texture's grid_size
|
|
grid = Grid(20, 15, texture, (100, 150), (480, 360)) # 20x24, 15x24
|
|
grid.fill_color = Color(20, 20, 40)
|
|
ui.append(grid)
|
|
|
|
# Fill with some test pattern
|
|
for y in range(15):
|
|
for x in range(20):
|
|
point = grid.at(x, y)
|
|
point.tilesprite = (x + y) % 4
|
|
point.walkable = ((x + y) % 3) != 0
|
|
if not point.walkable:
|
|
point.color = Color(100, 50, 50, 128)
|
|
|
|
# Animate grid position
|
|
grid_x = Animation("x", 400.0, 3.0, "easeInOutBack")
|
|
grid_x.start(grid)
|
|
|
|
# Camera pan animation (if supported)
|
|
# center_x = Animation("center", (10.0, 7.5), 4.0, "easeInOutCubic")
|
|
# center_x.start(grid)
|
|
|
|
# Create entities in the grid
|
|
if texture:
|
|
entity1 = Entity((5.0, 5.0), texture, 8) # position tuple, texture, sprite_index
|
|
entity1.scale = 1.5
|
|
grid.entities.append(entity1)
|
|
|
|
# Animate entity movement
|
|
entity_pos = Animation("position", (15.0, 10.0), 3.0, "easeInOutQuad")
|
|
entity_pos.start(entity1)
|
|
|
|
# Create patrolling entity
|
|
entity2 = Entity((10.0, 2.0), texture, 12) # position tuple, texture, sprite_index
|
|
grid.entities.append(entity2)
|
|
|
|
# Animate sprite changes
|
|
entity2_sprite = Animation("sprite_index", [12, 13, 14, 15, 14, 13], 2.0, "linear")
|
|
entity2_sprite.start(entity2)
|
|
|
|
return grid
|
|
|
|
def demo_complex_combinations(ui):
|
|
"""Demo 6: Complex multi-property animations"""
|
|
subtitle.text = "Demo 6: Complex Multi-Property Animations"
|
|
|
|
# Create a complex UI composition
|
|
main_frame = Frame(200, 200, 400, 300)
|
|
main_frame.fill_color = Color(30, 30, 60, 200)
|
|
main_frame.outline = 2
|
|
ui.append(main_frame)
|
|
|
|
# Child elements
|
|
title = Caption("Multi-Animation Demo", 20, 20)
|
|
title.fill_color = Color(255, 255, 255)
|
|
main_frame.children.append(title)
|
|
|
|
# Animate everything at once
|
|
# Frame animations
|
|
frame_x = Animation("x", 600.0, 3.0, "easeInOutElastic")
|
|
frame_w = Animation("w", 300.0, 2.5, "easeOutBack")
|
|
frame_fill = Animation("fill_color", (60, 30, 90, 220), 4.0, "easeInOutSine")
|
|
frame_outline = Animation("outline", 8.0, 3.0, "easeInOutQuad")
|
|
|
|
frame_x.start(main_frame)
|
|
frame_w.start(main_frame)
|
|
frame_fill.start(main_frame)
|
|
frame_outline.start(main_frame)
|
|
|
|
# Title animations
|
|
title_color = Animation("fill_color", (255, 200, 0, 255), 2.0, "easeOutBounce")
|
|
title_color.start(title)
|
|
|
|
# Add animated sub-frames
|
|
for i in range(3):
|
|
sub_frame = Frame(50 + i * 100, 100, 80, 80)
|
|
sub_frame.fill_color = Color(100 + i*50, 50, 200 - i*50, 180)
|
|
main_frame.children.append(sub_frame)
|
|
|
|
# Rotate positions using delta animations
|
|
sub_y = Animation("y", 50.0, 2.0, "easeInOutSine", delta=True)
|
|
sub_y.start(sub_frame)
|
|
|
|
return main_frame
|
|
|
|
def demo_easing_showcase(ui):
|
|
"""Demo 7: Showcase all 30 easing functions"""
|
|
subtitle.text = "Demo 7: All 30 Easing Functions Showcase"
|
|
|
|
# Create small frames for each easing function
|
|
frames_per_row = 6
|
|
frame_size = 180
|
|
spacing = 10
|
|
|
|
for i, easing in enumerate(EASING_FUNCTIONS[:12]): # First 12 easings
|
|
row = i // frames_per_row
|
|
col = i % frames_per_row
|
|
|
|
x = 50 + col * (frame_size + spacing)
|
|
y = 150 + row * (60 + spacing)
|
|
|
|
# Create indicator frame
|
|
frame = Frame(x, y, 20, 20)
|
|
frame.fill_color = Color(100, 200, 255)
|
|
frame.outline = 1
|
|
ui.append(frame)
|
|
|
|
# Label
|
|
label = Caption(easing, x, y - 20)
|
|
label.fill_color = Color(200, 200, 200)
|
|
ui.append(label)
|
|
|
|
# Animate using this easing
|
|
move_anim = Animation("x", x + frame_size - 20, 3.0, easing)
|
|
move_anim.start(frame)
|
|
|
|
# Continue with remaining easings after a delay
|
|
def show_more_easings(runtime):
|
|
for j, easing in enumerate(EASING_FUNCTIONS[12:24]): # Next 12
|
|
row = j // frames_per_row + 2
|
|
col = j % frames_per_row
|
|
|
|
x = 50 + col * (frame_size + spacing)
|
|
y = 150 + row * (60 + spacing)
|
|
|
|
frame2 = Frame(x, y, 20, 20)
|
|
frame2.fill_color = Color(255, 150, 100)
|
|
frame2.outline = 1
|
|
ui.append(frame2)
|
|
|
|
label2 = Caption(easing, x, y - 20)
|
|
label2.fill_color = Color(200, 200, 200)
|
|
ui.append(label2)
|
|
|
|
move_anim2 = Animation("x", x + frame_size - 20, 3.0, easing)
|
|
move_anim2.start(frame2)
|
|
|
|
mcrfpy.setTimer("more_easings", show_more_easings, 1000)
|
|
|
|
# Show final easings
|
|
def show_final_easings(runtime):
|
|
for k, easing in enumerate(EASING_FUNCTIONS[24:]): # Last 6
|
|
row = k // frames_per_row + 4
|
|
col = k % frames_per_row
|
|
|
|
x = 50 + col * (frame_size + spacing)
|
|
y = 150 + row * (60 + spacing)
|
|
|
|
frame3 = Frame(x, y, 20, 20)
|
|
frame3.fill_color = Color(150, 255, 150)
|
|
frame3.outline = 1
|
|
ui.append(frame3)
|
|
|
|
label3 = Caption(easing, x, y - 20)
|
|
label3.fill_color = Color(200, 200, 200)
|
|
ui.append(label3)
|
|
|
|
move_anim3 = Animation("x", x + frame_size - 20, 3.0, easing)
|
|
move_anim3.start(frame3)
|
|
|
|
mcrfpy.setTimer("final_easings", show_final_easings, 2000)
|
|
|
|
def demo_delta_animations(ui):
|
|
"""Demo 8: Delta mode animations (relative movements)"""
|
|
subtitle.text = "Demo 8: Delta Mode Animations (Relative Movements)"
|
|
|
|
# Create objects that will move relative to their position
|
|
frames = []
|
|
start_positions = [(100, 200), (300, 200), (500, 200), (700, 200)]
|
|
colors = [Color(255, 100, 100), Color(100, 255, 100),
|
|
Color(100, 100, 255), Color(255, 255, 100)]
|
|
|
|
for i, (x, y) in enumerate(start_positions):
|
|
frame = Frame(x, y, 80, 80)
|
|
frame.fill_color = colors[i]
|
|
frame.outline = 2
|
|
ui.append(frame)
|
|
frames.append(frame)
|
|
|
|
# Delta animations - move relative to current position
|
|
# Each frame moves by different amounts
|
|
dx = (i + 1) * 50
|
|
dy = math.sin(i) * 100
|
|
|
|
x_delta = Animation("x", dx, 2.0, "easeInOutBack", delta=True)
|
|
y_delta = Animation("y", dy, 2.0, "easeInOutElastic", delta=True)
|
|
|
|
x_delta.start(frame)
|
|
y_delta.start(frame)
|
|
|
|
# Create caption showing delta mode
|
|
delta_label = Caption("Delta mode: Relative animations from current position", 200, 400)
|
|
delta_label.fill_color = Color(255, 255, 255)
|
|
ui.append(delta_label)
|
|
|
|
# Animate the label with delta mode text append
|
|
text_delta = Animation("text", " - ANIMATED!", 2.0, "linear", delta=True)
|
|
text_delta.start(delta_label)
|
|
|
|
return frames
|
|
|
|
def demo_color_component_animations(ui):
|
|
"""Demo 9: Individual color channel animations"""
|
|
subtitle.text = "Demo 9: Color Component Animations (R, G, B, A channels)"
|
|
|
|
# Create frames to demonstrate individual color channel animations
|
|
base_frame = Frame(300, 200, 600, 300)
|
|
base_frame.fill_color = Color(128, 128, 128, 255)
|
|
base_frame.outline = 3
|
|
ui.append(base_frame)
|
|
|
|
# Labels for each channel
|
|
labels = ["Red", "Green", "Blue", "Alpha"]
|
|
positions = [(50, 50), (200, 50), (350, 50), (500, 50)]
|
|
|
|
for i, (label_text, (x, y)) in enumerate(zip(labels, positions)):
|
|
# Create label
|
|
label = Caption(label_text, x, y - 30)
|
|
label.fill_color = Color(255, 255, 255)
|
|
base_frame.children.append(label)
|
|
|
|
# Create demo frame for this channel
|
|
demo_frame = Frame(x, y, 100, 100)
|
|
demo_frame.fill_color = Color(100, 100, 100, 200)
|
|
demo_frame.outline = 2
|
|
base_frame.children.append(demo_frame)
|
|
|
|
# Animate individual color channel
|
|
if i == 0: # Red
|
|
r_anim = Animation("fill_color.r", 255, 3.0, "easeInOutSine")
|
|
r_anim.start(demo_frame)
|
|
elif i == 1: # Green
|
|
g_anim = Animation("fill_color.g", 255, 3.0, "easeInOutSine")
|
|
g_anim.start(demo_frame)
|
|
elif i == 2: # Blue
|
|
b_anim = Animation("fill_color.b", 255, 3.0, "easeInOutSine")
|
|
b_anim.start(demo_frame)
|
|
else: # Alpha
|
|
a_anim = Animation("fill_color.a", 50, 3.0, "easeInOutSine")
|
|
a_anim.start(demo_frame)
|
|
|
|
# Animate main frame outline color components in sequence
|
|
outline_r = Animation("outline_color.r", 255, 1.0, "linear")
|
|
outline_g = Animation("outline_color.g", 255, 1.0, "linear")
|
|
outline_b = Animation("outline_color.b", 0, 1.0, "linear")
|
|
|
|
outline_r.start(base_frame)
|
|
mcrfpy.setTimer("outline_g", lambda t: outline_g.start(base_frame), 1000)
|
|
mcrfpy.setTimer("outline_b", lambda t: outline_b.start(base_frame), 2000)
|
|
|
|
return base_frame
|
|
|
|
def demo_performance_stress_test(ui):
|
|
"""Demo 10: Performance test with many simultaneous animations"""
|
|
subtitle.text = "Demo 10: Performance Stress Test (100+ Simultaneous Animations)"
|
|
|
|
# Create many small objects with different animations
|
|
num_objects = 100
|
|
|
|
for i in range(num_objects):
|
|
# Random starting position
|
|
x = 100 + (i % 20) * 50
|
|
y = 150 + (i // 20) * 50
|
|
|
|
# Create small frame
|
|
size = 20 + (i % 3) * 10
|
|
frame = Frame(x, y, size, size)
|
|
|
|
# Random color
|
|
r = (i * 37) % 256
|
|
g = (i * 73) % 256
|
|
b = (i * 113) % 256
|
|
frame.fill_color = Color(r, g, b, 200)
|
|
frame.outline = 1
|
|
ui.append(frame)
|
|
|
|
# Random animation properties
|
|
target_x = 100 + (i % 15) * 70
|
|
target_y = 150 + (i // 15) * 70
|
|
duration = 2.0 + (i % 30) * 0.1
|
|
easing = EASING_FUNCTIONS[i % len(EASING_FUNCTIONS)]
|
|
|
|
# Start multiple animations per object
|
|
x_anim = Animation("x", target_x, duration, easing)
|
|
y_anim = Animation("y", target_y, duration, easing)
|
|
opacity_anim = Animation("opacity", 0.3 + (i % 7) * 0.1, duration, "easeInOutSine")
|
|
|
|
x_anim.start(frame)
|
|
y_anim.start(frame)
|
|
opacity_anim.start(frame)
|
|
|
|
# Performance counter
|
|
perf_caption = Caption(f"Animating {num_objects * 3} properties simultaneously", 400, 600)
|
|
perf_caption.fill_color = Color(255, 255, 0)
|
|
ui.append(perf_caption)
|
|
|
|
def next_demo(runtime):
|
|
"""Cycle to the next demo"""
|
|
global current_demo, demo_start_time
|
|
|
|
# Clear the UI except title and subtitle
|
|
ui = mcrfpy.sceneUI("sizzle_reel")
|
|
|
|
# Keep only the first two elements (title and subtitle)
|
|
while len(ui) > 2:
|
|
# Remove from the end to avoid index issues
|
|
ui.remove(len(ui) - 1)
|
|
|
|
# Run the next demo
|
|
if current_demo < len(demos):
|
|
demos[current_demo](ui)
|
|
current_demo += 1
|
|
|
|
# Schedule next demo
|
|
if current_demo < len(demos):
|
|
mcrfpy.setTimer("next_demo", next_demo, int(DEMO_DURATION * 1000))
|
|
else:
|
|
# All demos complete
|
|
subtitle.text = "Animation Showcase Complete! Press ESC to exit."
|
|
complete = Caption("All animation types demonstrated!", 400, 350)
|
|
complete.fill_color = Color(0, 255, 0)
|
|
complete.outline = 2
|
|
ui.append(complete)
|
|
|
|
def run_sizzle_reel(runtime):
|
|
"""Main entry point - start the demo sequence"""
|
|
global demos
|
|
|
|
# List of all demo functions
|
|
demos = [
|
|
demo_frame_basic_animations,
|
|
demo_frame_opacity_zindex,
|
|
demo_caption_animations,
|
|
demo_sprite_animations,
|
|
demo_grid_animations,
|
|
demo_complex_combinations,
|
|
demo_easing_showcase,
|
|
demo_delta_animations,
|
|
demo_color_component_animations,
|
|
demo_performance_stress_test
|
|
]
|
|
|
|
# Start the first demo
|
|
next_demo(runtime)
|
|
|
|
# Initialize scene
|
|
ui = create_demo_scene()
|
|
|
|
|
|
# Start the sizzle reel after a short delay
|
|
mcrfpy.setTimer("start_sizzle", run_sizzle_reel, 500)
|
|
|
|
print("Starting McRogueFace Animation Sizzle Reel...")
|
|
print("This will demonstrate ALL animation types on ALL objects.")
|
|
print("Press ESC at any time to exit.")
|