use core::fmt;
use serde::{Deserialize, Serialize};
use crate::{FinalDisposition, Point, Rect};
const SCENE_FORMAT_VERSION: u16 = 1;
const ABSOLUTE_MAX_NODES: u8 = 48;
const ABSOLUTE_MAX_DEPTH: u8 = 5;
const ABSOLUTE_MAX_ACTIONS: u8 = 8;
const ABSOLUTE_MAX_DIAGRAM_NODES: u8 = 16;
const ABSOLUTE_MAX_DIAGRAM_EDGES: u8 = 24;
const ABSOLUTE_MAX_EFFECTS: u8 = 12;
const ABSOLUTE_MAX_PHASES: u8 = 4;
const ABSOLUTE_MAX_LIVE_EFFECTS: u8 = 5;
const ABSOLUTE_MAX_FRAGMENTS: u8 = 8;
const ABSOLUTE_MAX_DISPLACEMENT: u8 = 3;
const ABSOLUTE_MAX_PHASE_MS: u16 = 2_400;
const ABSOLUTE_MAX_INTERACTION_MS: u32 = 8_000;
const ABSOLUTE_MAX_JSON_BYTES: u32 = 65_536;
const MAX_TEXT_BYTES: usize = 512;
#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize)]
#[serde(rename_all = "snake_case")]
pub enum SceneRecipe {
Calm,
Balanced,
Vivid,
}
#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize)]
pub struct SceneBudgets {
pub max_nodes: u8,
pub max_depth: u8,
pub max_actions: u8,
pub max_diagram_nodes: u8,
pub max_diagram_edges: u8,
pub max_effects: u8,
pub max_phases_per_effect: u8,
pub max_live_effects: u8,
pub max_fragments: u8,
pub max_displacement: u8,
pub max_phase_ms: u16,
pub max_interaction_ms: u32,
pub max_json_bytes: u32,
}
impl Default for SceneBudgets {
fn default() -> Self {
Self {
max_nodes: ABSOLUTE_MAX_NODES,
max_depth: ABSOLUTE_MAX_DEPTH,
max_actions: ABSOLUTE_MAX_ACTIONS,
max_diagram_nodes: ABSOLUTE_MAX_DIAGRAM_NODES,
max_diagram_edges: ABSOLUTE_MAX_DIAGRAM_EDGES,
max_effects: ABSOLUTE_MAX_EFFECTS,
max_phases_per_effect: ABSOLUTE_MAX_PHASES,
max_live_effects: ABSOLUTE_MAX_LIVE_EFFECTS,
max_fragments: ABSOLUTE_MAX_FRAGMENTS,
max_displacement: ABSOLUTE_MAX_DISPLACEMENT,
max_phase_ms: ABSOLUTE_MAX_PHASE_MS,
max_interaction_ms: ABSOLUTE_MAX_INTERACTION_MS,
max_json_bytes: ABSOLUTE_MAX_JSON_BYTES,
}
}
}
#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
pub struct FactContent {
pub label: String,
pub value: String,
}
#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
pub struct ActionContent {
pub key: String,
pub label: String,
}
#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
pub struct ReceiptContent {
pub eyebrow: String,
pub title: String,
pub outcome: FinalDisposition,
pub facts: Vec<FactContent>,
pub evidence: Vec<String>,
pub table_headers: Vec<String>,
pub table_rows: Vec<Vec<String>>,
pub diagram_labels: Vec<String>,
pub actions: Vec<ActionContent>,
pub menu_items: Vec<String>,
}
#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
pub struct SceneRequest {
pub seed: u64,
pub recipe: SceneRecipe,
pub content: ReceiptContent,
pub budgets: SceneBudgets,
}
#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize)]
#[serde(rename_all = "snake_case")]
pub enum LayoutProfile {
Instrument,
Split,
Asymmetric,
ResultLed,
DiagramLed,
Terminal,
Editorial,
}
#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize)]
#[serde(rename_all = "snake_case")]
pub enum SceneNodeKind {
Frame,
Header,
Facts,
List,
Table,
Diagram,
Result,
Actions,
Menu,
}
#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize)]
#[serde(rename_all = "snake_case")]
pub enum GridRole {
Frame,
Lead,
Primary,
Secondary,
Full,
Outcome,
Footer,
}
#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize)]
#[serde(rename_all = "snake_case")]
pub enum VisualRole {
Quiet,
Standard,
Emphasis,
Outcome,
Interactive,
}
#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize)]
#[serde(rename_all = "snake_case")]
pub enum ButtonSize {
Compact,
Regular,
Prominent,
}
#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
pub struct SceneAction {
pub id: String,
pub key: String,
pub label: String,
pub size: ButtonSize,
}
#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
#[serde(tag = "kind", rename_all = "snake_case")]
pub enum SceneNodeContent {
Empty,
Header {
eyebrow: String,
title: String,
},
Facts {
items: Vec<FactContent>,
},
List {
items: Vec<String>,
},
Table {
headers: Vec<String>,
rows: Vec<Vec<String>>,
},
Result {
disposition: FinalDisposition,
},
Actions {
items: Vec<SceneAction>,
},
Menu {
items: Vec<String>,
},
}
#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
pub struct SceneNode {
pub id: String,
pub kind: SceneNodeKind,
pub grid_role: GridRole,
pub visual_role: VisualRole,
pub effect_target: bool,
pub content: SceneNodeContent,
pub children: Vec<Self>,
}
#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize)]
#[serde(rename_all = "snake_case")]
pub enum DiagramForm {
Linear,
Tree,
State,
Network,
}
#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
pub struct DiagramNode {
pub id: String,
pub label: String,
pub terminal: bool,
}
#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
pub struct DiagramEdge {
pub id: String,
pub from: String,
pub to: String,
}
#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
pub struct DiagramPlan {
pub form: DiagramForm,
pub nodes: Vec<DiagramNode>,
pub edges: Vec<DiagramEdge>,
}
#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize)]
#[serde(rename_all = "snake_case")]
pub enum EffectPattern {
Pulse,
Glitch,
Invert,
Fragment,
EdgeTraverse,
Packet,
Scanline,
}
#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
#[serde(tag = "kind", content = "id", rename_all = "snake_case")]
pub enum EffectTarget {
Node(String),
Edge(String),
}
#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize)]
pub struct EffectPhase {
pub at_ms: u32,
pub duration_ms: u16,
}
#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize)]
pub struct EffectParameters {
pub intensity: u8,
pub offset_x: i8,
pub offset_y: i8,
pub fragments: u8,
}
#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
pub struct EffectPlan {
pub id: String,
pub pattern: EffectPattern,
pub target: EffectTarget,
pub parameters: EffectParameters,
pub phases: Vec<EffectPhase>,
}
#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
#[serde(tag = "kind", content = "action_id", rename_all = "snake_case")]
pub enum InteractionTrigger {
Load,
Action(String),
}
#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
pub struct InteractionScript {
pub trigger: InteractionTrigger,
pub effect_ids: Vec<String>,
}
#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
pub struct ScenePlan {
pub format_version: u16,
pub seed: u64,
pub recipe: SceneRecipe,
pub layout: LayoutProfile,
pub root: SceneNode,
pub diagram: DiagramPlan,
pub effects: Vec<EffectPlan>,
pub scripts: Vec<InteractionScript>,
}
impl ScenePlan {
pub fn to_json(&self) -> Result<String, SceneError> {
serde_json::to_string(self).map_err(|error| SceneError::Serialization(error.to_string()))
}
}
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct NodeGeometry {
pub id: String,
pub rect: Rect,
pub incoming: Point,
pub outgoing: Point,
}
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct SceneSimulationInput {
pub plan: ScenePlan,
pub geometry: Vec<NodeGeometry>,
pub trigger: InteractionTrigger,
}
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
#[serde(tag = "kind", rename_all = "snake_case")]
pub enum SceneEvent {
InteractionStarted {
at_ms: u32,
},
PhaseStarted {
effect_id: String,
phase_index: u8,
at_ms: u32,
duration_ms: u16,
},
NodeActivated {
target_id: String,
point: Point,
at_ms: u32,
duration_ms: u16,
intensity: u8,
},
BackingGlitched {
target_id: String,
at_ms: u32,
duration_ms: u16,
offset_x: i8,
offset_y: i8,
},
BackingInverted {
target_id: String,
at_ms: u32,
duration_ms: u16,
},
FragmentsEmitted {
target_id: String,
point: Point,
at_ms: u32,
duration_ms: u16,
count: u8,
},
EdgeTraversed {
edge_id: String,
from: Point,
to: Point,
at_ms: u32,
duration_ms: u16,
},
PacketTraversed {
edge_id: String,
from: Point,
to: Point,
at_ms: u32,
duration_ms: u16,
},
ScanlineSwept {
target_id: String,
rect: Rect,
at_ms: u32,
duration_ms: u16,
},
InteractionFinished {
at_ms: u32,
},
}
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct SceneTrace {
pub format_version: u16,
pub seed: u64,
pub trigger: InteractionTrigger,
pub events: Vec<SceneEvent>,
}
impl SceneTrace {
pub fn to_json(&self) -> Result<String, SceneError> {
serde_json::to_string(self).map_err(|error| SceneError::Serialization(error.to_string()))
}
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub enum SceneError {
ZeroSeed,
InvalidContent(&'static str),
BudgetExceeded(&'static str),
InvalidIdentifier(&'static str),
InvalidGeometry(&'static str),
UnknownInteraction,
Serialization(String),
}
impl fmt::Display for SceneError {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::ZeroSeed => formatter.write_str("scene seed must be nonzero"),
Self::InvalidContent(name) => write!(formatter, "invalid scene content: {name}"),
Self::BudgetExceeded(name) => write!(formatter, "scene budget exceeded: {name}"),
Self::InvalidIdentifier(name) => write!(formatter, "invalid scene identifier: {name}"),
Self::InvalidGeometry(name) => write!(formatter, "invalid scene geometry: {name}"),
Self::UnknownInteraction => formatter.write_str("interaction is not declared by scene"),
Self::Serialization(message) => {
write!(formatter, "scene serialization failed: {message}")
}
}
}
}
impl std::error::Error for SceneError {}
pub fn generate_scene(request: &SceneRequest) -> Result<ScenePlan, SceneError> {
validate_request(request)?;
let mut choice_random = SceneRandom::new(request.seed);
let mut timing_random = SceneRandom::new(request.seed ^ 0xe703_7ed1_a0b4_28db);
let layout = choice_random.layout();
let diagram = generate_diagram(
&request.content.diagram_labels,
choice_random.diagram_form(),
);
let actions = generate_actions(&request.content.actions, &mut choice_random);
let root = generate_tree(&request.content, &actions, layout);
let (effects, scripts) = generate_effects(
request,
&root,
&diagram,
&actions,
&mut choice_random,
&mut timing_random,
)?;
let plan = ScenePlan {
format_version: SCENE_FORMAT_VERSION,
seed: request.seed,
recipe: request.recipe,
layout,
root,
diagram,
effects,
scripts,
};
validate_plan(&plan, request.budgets)?;
let byte_count = plan.to_json()?.len();
let byte_limit = usize::try_from(request.budgets.max_json_bytes)
.map_err(|_| SceneError::BudgetExceeded("serialized scene bytes"))?;
if byte_count > byte_limit {
return Err(SceneError::BudgetExceeded("serialized scene bytes"));
}
Ok(plan)
}
pub fn simulate_scene(input: &SceneSimulationInput) -> Result<SceneTrace, SceneError> {
validate_plan(&input.plan, SceneBudgets::default())?;
validate_geometry(&input.plan, &input.geometry)?;
let script = input
.plan
.scripts
.iter()
.find(|script| script.trigger == input.trigger)
.ok_or(SceneError::UnknownInteraction)?;
let mut events = vec![SceneEvent::InteractionStarted { at_ms: 0 }];
let mut finish_ms = 0_u32;
for effect_id in &script.effect_ids {
let effect = input
.plan
.effects
.iter()
.find(|effect| effect.id == *effect_id)
.ok_or(SceneError::InvalidIdentifier("script effect"))?;
for (phase_index, phase) in effect.phases.iter().enumerate() {
let phase_index = u8::try_from(phase_index)
.map_err(|_| SceneError::BudgetExceeded("phases per effect"))?;
events.push(SceneEvent::PhaseStarted {
effect_id: effect.id.clone(),
phase_index,
at_ms: phase.at_ms,
duration_ms: phase.duration_ms,
});
push_effect_event(&mut events, effect, *phase, &input.plan, &input.geometry)?;
finish_ms = finish_ms.max(phase.at_ms + u32::from(phase.duration_ms));
}
}
events.sort_by_key(event_time);
events.push(SceneEvent::InteractionFinished { at_ms: finish_ms });
Ok(SceneTrace {
format_version: input.plan.format_version,
seed: input.plan.seed,
trigger: input.trigger.clone(),
events,
})
}
fn validate_request(request: &SceneRequest) -> Result<(), SceneError> {
if request.seed == 0 {
return Err(SceneError::ZeroSeed);
}
validate_budgets(request.budgets)?;
validate_text(&request.content.eyebrow, "eyebrow")?;
validate_text(&request.content.title, "title")?;
if request.content.facts.is_empty() || request.content.facts.len() > 12 {
return Err(SceneError::InvalidContent("facts"));
}
for fact in &request.content.facts {
validate_text(&fact.label, "fact label")?;
validate_text(&fact.value, "fact value")?;
}
if request.content.evidence.is_empty() || request.content.evidence.len() > 12 {
return Err(SceneError::InvalidContent("evidence list"));
}
for item in &request.content.evidence {
validate_text(item, "evidence item")?;
}
if request.content.table_headers.is_empty() || request.content.table_headers.len() > 6 {
return Err(SceneError::InvalidContent("table headers"));
}
for header in &request.content.table_headers {
validate_text(header, "table header")?;
}
if request.content.table_rows.is_empty() || request.content.table_rows.len() > 12 {
return Err(SceneError::InvalidContent("table rows"));
}
for row in &request.content.table_rows {
if row.len() != request.content.table_headers.len() {
return Err(SceneError::InvalidContent("table row width"));
}
for cell in row {
validate_text(cell, "table cell")?;
}
}
let diagram_count = request.content.diagram_labels.len();
if !(2..=usize::from(request.budgets.max_diagram_nodes)).contains(&diagram_count) {
return Err(SceneError::InvalidContent("diagram labels"));
}
let worst_case_edges = if diagram_count > 3 {
diagram_count + 1
} else {
diagram_count.saturating_sub(1)
};
if worst_case_edges > usize::from(request.budgets.max_diagram_edges) {
return Err(SceneError::BudgetExceeded("diagram edges"));
}
for label in &request.content.diagram_labels {
validate_text(label, "diagram label")?;
}
if request.content.actions.is_empty()
|| request.content.actions.len() > usize::from(request.budgets.max_actions)
{
return Err(SceneError::InvalidContent("actions"));
}
if request.content.actions.len() >= usize::from(request.budgets.max_effects) {
return Err(SceneError::BudgetExceeded("action and load effects"));
}
if request.content.actions.len() + 9 > usize::from(request.budgets.max_nodes) {
return Err(SceneError::BudgetExceeded("scene and action nodes"));
}
for action in &request.content.actions {
validate_key(&action.key, "action key")?;
validate_text(&action.label, "action label")?;
}
if request.content.menu_items.is_empty() || request.content.menu_items.len() > 8 {
return Err(SceneError::InvalidContent("menu items"));
}
for item in &request.content.menu_items {
validate_text(item, "menu item")?;
}
Ok(())
}
fn validate_budgets(budgets: SceneBudgets) -> Result<(), SceneError> {
let valid = budgets.max_nodes >= 9
&& budgets.max_nodes <= ABSOLUTE_MAX_NODES
&& budgets.max_depth >= 2
&& budgets.max_depth <= ABSOLUTE_MAX_DEPTH
&& budgets.max_actions > 0
&& budgets.max_actions <= ABSOLUTE_MAX_ACTIONS
&& budgets.max_diagram_nodes >= 2
&& budgets.max_diagram_nodes <= ABSOLUTE_MAX_DIAGRAM_NODES
&& budgets.max_diagram_edges > 0
&& budgets.max_diagram_edges <= ABSOLUTE_MAX_DIAGRAM_EDGES
&& budgets.max_effects > 0
&& budgets.max_effects <= ABSOLUTE_MAX_EFFECTS
&& budgets.max_phases_per_effect > 0
&& budgets.max_phases_per_effect <= ABSOLUTE_MAX_PHASES
&& budgets.max_live_effects > 0
&& budgets.max_live_effects <= ABSOLUTE_MAX_LIVE_EFFECTS
&& budgets.max_fragments > 0
&& budgets.max_fragments <= ABSOLUTE_MAX_FRAGMENTS
&& budgets.max_displacement <= ABSOLUTE_MAX_DISPLACEMENT
&& budgets.max_phase_ms >= 60
&& budgets.max_phase_ms <= ABSOLUTE_MAX_PHASE_MS
&& budgets.max_interaction_ms >= u32::from(budgets.max_phase_ms)
&& budgets.max_interaction_ms <= ABSOLUTE_MAX_INTERACTION_MS
&& budgets.max_json_bytes > 0
&& budgets.max_json_bytes <= ABSOLUTE_MAX_JSON_BYTES;
if !valid {
return Err(SceneError::BudgetExceeded("invalid hard limits"));
}
Ok(())
}
fn validate_text(value: &str, name: &'static str) -> Result<(), SceneError> {
if value.trim().is_empty() || value.len() > MAX_TEXT_BYTES {
return Err(SceneError::InvalidContent(name));
}
Ok(())
}
fn validate_key(value: &str, name: &'static str) -> Result<(), SceneError> {
validate_text(value, name)?;
if !value
.bytes()
.all(|byte| byte.is_ascii_alphanumeric() || matches!(byte, b'-' | b'_'))
{
return Err(SceneError::InvalidContent(name));
}
Ok(())
}
fn generate_actions(actions: &[ActionContent], random: &mut SceneRandom) -> Vec<SceneAction> {
actions
.iter()
.enumerate()
.map(|(index, action)| SceneAction {
id: format!("action-{index}"),
key: action.key.clone(),
label: action.label.clone(),
size: random.button_size(),
})
.collect()
}
fn generate_tree(
content: &ReceiptContent,
actions: &[SceneAction],
layout: LayoutProfile,
) -> SceneNode {
let roles = layout_roles(layout);
let children = vec![
scene_node(
"header",
SceneNodeKind::Header,
roles[0],
VisualRole::Emphasis,
true,
SceneNodeContent::Header {
eyebrow: content.eyebrow.clone(),
title: content.title.clone(),
},
),
scene_node(
"facts",
SceneNodeKind::Facts,
roles[1],
VisualRole::Standard,
true,
SceneNodeContent::Facts {
items: content.facts.clone(),
},
),
scene_node(
"evidence",
SceneNodeKind::List,
roles[2],
VisualRole::Quiet,
true,
SceneNodeContent::List {
items: content.evidence.clone(),
},
),
scene_node(
"records",
SceneNodeKind::Table,
roles[3],
VisualRole::Standard,
true,
SceneNodeContent::Table {
headers: content.table_headers.clone(),
rows: content.table_rows.clone(),
},
),
scene_node(
"diagram",
SceneNodeKind::Diagram,
roles[4],
VisualRole::Emphasis,
true,
SceneNodeContent::Empty,
),
scene_node(
"result",
SceneNodeKind::Result,
roles[5],
VisualRole::Outcome,
true,
SceneNodeContent::Result {
disposition: content.outcome,
},
),
scene_node(
"actions",
SceneNodeKind::Actions,
roles[6],
VisualRole::Interactive,
true,
SceneNodeContent::Actions {
items: actions.to_vec(),
},
),
scene_node(
"menu",
SceneNodeKind::Menu,
GridRole::Footer,
VisualRole::Interactive,
true,
SceneNodeContent::Menu {
items: content.menu_items.clone(),
},
),
];
SceneNode {
id: "scene".to_owned(),
kind: SceneNodeKind::Frame,
grid_role: GridRole::Frame,
visual_role: VisualRole::Standard,
effect_target: true,
content: SceneNodeContent::Empty,
children,
}
}
fn scene_node(
id: &str,
kind: SceneNodeKind,
grid_role: GridRole,
visual_role: VisualRole,
effect_target: bool,
content: SceneNodeContent,
) -> SceneNode {
SceneNode {
id: id.to_owned(),
kind,
grid_role,
visual_role,
effect_target,
content,
children: Vec::new(),
}
}
fn layout_roles(layout: LayoutProfile) -> [GridRole; 7] {
match layout {
LayoutProfile::Instrument | LayoutProfile::Terminal => [
GridRole::Lead,
GridRole::Primary,
GridRole::Primary,
GridRole::Full,
GridRole::Full,
GridRole::Outcome,
GridRole::Footer,
],
LayoutProfile::Split | LayoutProfile::Asymmetric => [
GridRole::Lead,
GridRole::Primary,
GridRole::Secondary,
GridRole::Primary,
GridRole::Secondary,
GridRole::Outcome,
GridRole::Footer,
],
LayoutProfile::ResultLed | LayoutProfile::DiagramLed => [
GridRole::Lead,
GridRole::Secondary,
GridRole::Secondary,
GridRole::Full,
GridRole::Primary,
GridRole::Outcome,
GridRole::Footer,
],
LayoutProfile::Editorial => [
GridRole::Lead,
GridRole::Primary,
GridRole::Secondary,
GridRole::Full,
GridRole::Full,
GridRole::Outcome,
GridRole::Footer,
],
}
}
fn generate_diagram(labels: &[String], form: DiagramForm) -> DiagramPlan {
let nodes = labels
.iter()
.enumerate()
.map(|(index, label)| DiagramNode {
id: format!("diagram-node-{index}"),
label: label.clone(),
terminal: index + 1 == labels.len(),
})
.collect::<Vec<_>>();
let mut pairs = Vec::new();
match form {
DiagramForm::Linear | DiagramForm::State => {
for index in 1..nodes.len() {
pairs.push((index - 1, index));
}
if form == DiagramForm::State && nodes.len() > 2 {
pairs.push((nodes.len() - 1, 0));
}
}
DiagramForm::Tree => {
for index in 1..nodes.len() {
pairs.push(((index - 1) / 2, index));
}
}
DiagramForm::Network => {
for index in 1..nodes.len() {
pairs.push((index - 1, index));
}
if nodes.len() > 3 {
pairs.push((0, 2));
pairs.push((1, nodes.len() - 1));
}
}
}
let edges = pairs
.into_iter()
.enumerate()
.map(|(index, (from, to))| DiagramEdge {
id: format!("diagram-edge-{index}"),
from: nodes[from].id.clone(),
to: nodes[to].id.clone(),
})
.collect();
DiagramPlan { form, nodes, edges }
}
fn generate_effects(
request: &SceneRequest,
root: &SceneNode,
diagram: &DiagramPlan,
actions: &[SceneAction],
choice_random: &mut SceneRandom,
timing_random: &mut SceneRandom,
) -> Result<(Vec<EffectPlan>, Vec<InteractionScript>), SceneError> {
let mut node_targets = Vec::new();
collect_effect_targets(root, &mut node_targets);
node_targets.extend(diagram.nodes.iter().map(|node| node.id.clone()));
let desired_load_effects = match request.recipe {
SceneRecipe::Calm => 2,
SceneRecipe::Balanced => 4,
SceneRecipe::Vivid => 6,
};
let action_effects = actions.len();
let effect_limit = usize::from(request.budgets.max_effects);
let load_effects = desired_load_effects.min(effect_limit.saturating_sub(action_effects));
if load_effects == 0 {
return Err(SceneError::BudgetExceeded("load effects"));
}
let mut effects = Vec::with_capacity(load_effects + action_effects);
let mut load_ids = Vec::with_capacity(load_effects);
let mut cursor_ms = 0_u32;
for index in 0..load_effects {
let pattern = choice_random.pattern(!diagram.edges.is_empty());
let target = target_for_pattern(pattern, &node_targets, diagram, choice_random)?;
let effect = generated_effect(
format!("effect-load-{index}"),
pattern,
target,
cursor_ms,
request.budgets,
timing_random,
);
cursor_ms = effect_end(&effect).saturating_add(40);
load_ids.push(effect.id.clone());
effects.push(effect);
}
let mut scripts = vec![InteractionScript {
trigger: InteractionTrigger::Load,
effect_ids: load_ids,
}];
for (index, action) in actions.iter().enumerate() {
let pattern = choice_random.action_pattern();
let target = EffectTarget::Node(action.id.clone());
let effect = generated_effect(
format!("effect-action-{index}"),
pattern,
target,
0,
request.budgets,
timing_random,
);
scripts.push(InteractionScript {
trigger: InteractionTrigger::Action(action.id.clone()),
effect_ids: vec![effect.id.clone()],
});
effects.push(effect);
}
Ok((effects, scripts))
}
fn generated_effect(
id: String,
pattern: EffectPattern,
target: EffectTarget,
start_ms: u32,
budgets: SceneBudgets,
random: &mut SceneRandom,
) -> EffectPlan {
let maximum_phases = budgets.max_phases_per_effect.min(3);
let phase_count = random.range_u8(1, maximum_phases);
let mut phases = Vec::with_capacity(usize::from(phase_count));
let mut cursor_ms = start_ms;
for _ in 0..phase_count {
let maximum_duration = budgets.max_phase_ms.min(640);
let minimum_duration = maximum_duration.min(120);
let duration_ms = random.range_u16(minimum_duration, maximum_duration);
phases.push(EffectPhase {
at_ms: cursor_ms,
duration_ms,
});
cursor_ms = cursor_ms.saturating_add(u32::from(duration_ms) + 30);
}
let displacement = i8::try_from(budgets.max_displacement).map_or(3, |value| value);
EffectPlan {
id,
pattern,
target,
parameters: EffectParameters {
intensity: random.range_u8(1, 3),
offset_x: random.signed_range(displacement),
offset_y: random.signed_range(displacement),
fragments: random.range_u8(1, budgets.max_fragments),
},
phases,
}
}
fn target_for_pattern(
pattern: EffectPattern,
node_targets: &[String],
diagram: &DiagramPlan,
random: &mut SceneRandom,
) -> Result<EffectTarget, SceneError> {
if matches!(pattern, EffectPattern::EdgeTraverse | EffectPattern::Packet) {
let index = random.index(diagram.edges.len());
return diagram
.edges
.get(index)
.map(|edge| EffectTarget::Edge(edge.id.clone()))
.ok_or(SceneError::InvalidContent("diagram edge target"));
}
let index = random.index(node_targets.len());
node_targets
.get(index)
.cloned()
.map(EffectTarget::Node)
.ok_or(SceneError::InvalidContent("scene node target"))
}
fn collect_effect_targets(node: &SceneNode, targets: &mut Vec<String>) {
if node.effect_target {
targets.push(node.id.clone());
}
for child in &node.children {
collect_effect_targets(child, targets);
}
}
fn effect_end(effect: &EffectPlan) -> u32 {
effect.phases.iter().fold(0, |end_ms, phase| {
end_ms.max(phase.at_ms + u32::from(phase.duration_ms))
})
}
fn validate_plan(plan: &ScenePlan, budgets: SceneBudgets) -> Result<(), SceneError> {
if plan.format_version != SCENE_FORMAT_VERSION {
return Err(SceneError::InvalidIdentifier("scene format version"));
}
if plan.seed == 0 {
return Err(SceneError::ZeroSeed);
}
validate_budgets(budgets)?;
let mut node_ids = Vec::new();
validate_tree(&plan.root, 1, budgets, &mut node_ids)?;
let mut action_ids = Vec::new();
collect_action_ids(&plan.root, &mut action_ids)?;
for action_id in &action_ids {
if node_ids.contains(action_id) {
return Err(SceneError::InvalidIdentifier("duplicate action node"));
}
node_ids.push(action_id.clone());
}
if node_ids.len() > usize::from(budgets.max_nodes) {
return Err(SceneError::BudgetExceeded("scene and action nodes"));
}
let diagram_node_limit = usize::from(budgets.max_diagram_nodes);
if plan.diagram.nodes.len() > diagram_node_limit {
return Err(SceneError::BudgetExceeded("diagram nodes"));
}
let diagram_edge_limit = usize::from(budgets.max_diagram_edges);
if plan.diagram.edges.len() > diagram_edge_limit {
return Err(SceneError::BudgetExceeded("diagram edges"));
}
for node in &plan.diagram.nodes {
if node_ids.contains(&node.id) {
return Err(SceneError::InvalidIdentifier("duplicate node"));
}
node_ids.push(node.id.clone());
}
let mut edge_ids = Vec::new();
for edge in &plan.diagram.edges {
if edge_ids.contains(&edge.id)
|| !node_ids.contains(&edge.from)
|| !node_ids.contains(&edge.to)
{
return Err(SceneError::InvalidIdentifier("diagram edge"));
}
edge_ids.push(edge.id.clone());
}
if plan.effects.len() > usize::from(budgets.max_effects) {
return Err(SceneError::BudgetExceeded("effects"));
}
let mut effect_ids = Vec::new();
for effect in &plan.effects {
validate_effect(effect, &node_ids, &edge_ids, budgets)?;
if effect_ids.contains(&effect.id) {
return Err(SceneError::InvalidIdentifier("duplicate effect"));
}
effect_ids.push(effect.id.clone());
}
let mut triggers = Vec::new();
for script in &plan.scripts {
if triggers.contains(&script.trigger) {
return Err(SceneError::InvalidIdentifier("duplicate interaction"));
}
if let InteractionTrigger::Action(action_id) = &script.trigger {
if !action_ids.contains(action_id) {
return Err(SceneError::InvalidIdentifier("interaction action"));
}
}
triggers.push(script.trigger.clone());
if script.effect_ids.is_empty()
|| script
.effect_ids
.iter()
.any(|effect_id| !effect_ids.contains(effect_id))
{
return Err(SceneError::InvalidIdentifier("script effect"));
}
let script_effects = script
.effect_ids
.iter()
.filter_map(|id| plan.effects.iter().find(|effect| effect.id == **id))
.collect::<Vec<_>>();
if script_effects
.iter()
.fold(0, |end_ms, effect| end_ms.max(effect_end(effect)))
> budgets.max_interaction_ms
{
return Err(SceneError::BudgetExceeded("interaction duration"));
}
validate_live_effects(&script_effects, budgets.max_live_effects)?;
}
if !triggers.contains(&InteractionTrigger::Load)
|| action_ids
.iter()
.any(|action_id| !triggers.contains(&InteractionTrigger::Action(action_id.clone())))
{
return Err(SceneError::InvalidIdentifier("missing interaction"));
}
Ok(())
}
fn validate_tree(
node: &SceneNode,
depth: u8,
budgets: SceneBudgets,
ids: &mut Vec<String>,
) -> Result<(), SceneError> {
if depth > budgets.max_depth {
return Err(SceneError::BudgetExceeded("scene depth"));
}
if ids.contains(&node.id) {
return Err(SceneError::InvalidIdentifier("duplicate scene node"));
}
ids.push(node.id.clone());
if ids.len() > usize::from(budgets.max_nodes) {
return Err(SceneError::BudgetExceeded("scene nodes"));
}
for child in &node.children {
validate_tree(child, depth + 1, budgets, ids)?;
}
Ok(())
}
fn collect_action_ids(node: &SceneNode, ids: &mut Vec<String>) -> Result<(), SceneError> {
if let SceneNodeContent::Actions { items } = &node.content {
for action in items {
if ids.contains(&action.id) {
return Err(SceneError::InvalidIdentifier("duplicate action node"));
}
ids.push(action.id.clone());
}
}
for child in &node.children {
collect_action_ids(child, ids)?;
}
Ok(())
}
fn validate_live_effects(effects: &[&EffectPlan], maximum_live: u8) -> Result<(), SceneError> {
let intervals = effects
.iter()
.flat_map(|effect| {
effect
.phases
.iter()
.map(|phase| (phase.at_ms, phase.at_ms + u32::from(phase.duration_ms)))
})
.collect::<Vec<_>>();
let exceeds_limit = intervals.iter().any(|(start, _)| {
intervals
.iter()
.filter(|(other_start, other_end)| other_start <= start && start < other_end)
.count()
> usize::from(maximum_live)
});
if exceeds_limit {
return Err(SceneError::BudgetExceeded("simultaneously live effects"));
}
Ok(())
}
fn validate_effect(
effect: &EffectPlan,
node_ids: &[String],
edge_ids: &[String],
budgets: SceneBudgets,
) -> Result<(), SceneError> {
let target_valid = match &effect.target {
EffectTarget::Node(id) => node_ids.contains(id),
EffectTarget::Edge(id) => edge_ids.contains(id),
};
if !target_valid {
return Err(SceneError::InvalidIdentifier("effect target"));
}
let target_kind_valid = matches!(
(&effect.pattern, &effect.target),
(
EffectPattern::EdgeTraverse | EffectPattern::Packet,
EffectTarget::Edge(_)
) | (
EffectPattern::Pulse
| EffectPattern::Glitch
| EffectPattern::Invert
| EffectPattern::Fragment
| EffectPattern::Scanline,
EffectTarget::Node(_)
)
);
if !target_kind_valid {
return Err(SceneError::InvalidIdentifier("pattern target kind"));
}
if effect.phases.is_empty() || effect.phases.len() > usize::from(budgets.max_phases_per_effect)
{
return Err(SceneError::BudgetExceeded("effect phases"));
}
for phase in &effect.phases {
if phase.duration_ms == 0 || phase.duration_ms > budgets.max_phase_ms {
return Err(SceneError::BudgetExceeded("phase duration"));
}
}
if effect
.phases
.windows(2)
.any(|pair| pair[0].at_ms > pair[1].at_ms)
{
return Err(SceneError::InvalidIdentifier("phase order"));
}
let displacement_limit = i16::from(budgets.max_displacement);
if i16::from(effect.parameters.offset_x).abs() > displacement_limit
|| i16::from(effect.parameters.offset_y).abs() > displacement_limit
|| effect.parameters.fragments == 0
|| effect.parameters.fragments > budgets.max_fragments
|| !(1..=3).contains(&effect.parameters.intensity)
{
return Err(SceneError::BudgetExceeded("effect parameters"));
}
Ok(())
}
fn validate_geometry(plan: &ScenePlan, geometry: &[NodeGeometry]) -> Result<(), SceneError> {
let mut required = Vec::new();
for effect in &plan.effects {
match &effect.target {
EffectTarget::Node(id) => push_unique(&mut required, id),
EffectTarget::Edge(id) => {
let edge = plan
.diagram
.edges
.iter()
.find(|edge| edge.id == *id)
.ok_or(SceneError::InvalidIdentifier("effect edge"))?;
push_unique(&mut required, &edge.from);
push_unique(&mut required, &edge.to);
}
}
}
let mut seen = Vec::new();
for measurement in geometry {
if seen.contains(&measurement.id) {
return Err(SceneError::InvalidGeometry("duplicate node"));
}
seen.push(measurement.id.clone());
if !rect_is_valid(measurement.rect)
|| !point_is_finite(measurement.incoming)
|| !point_is_finite(measurement.outgoing)
{
return Err(SceneError::InvalidGeometry("non-finite node"));
}
}
if required.iter().any(|id| !seen.contains(id)) {
return Err(SceneError::InvalidGeometry("missing required node"));
}
Ok(())
}
fn push_unique(values: &mut Vec<String>, value: &str) {
if !values.iter().any(|existing| existing == value) {
values.push(value.to_owned());
}
}
fn point_is_finite(point: Point) -> bool {
point.x.is_finite() && point.y.is_finite()
}
fn rect_is_valid(rect: Rect) -> bool {
rect.x.is_finite()
&& rect.y.is_finite()
&& rect.width.is_finite()
&& rect.height.is_finite()
&& rect.width > 0.0
&& rect.height > 0.0
}
fn push_effect_event(
events: &mut Vec<SceneEvent>,
effect: &EffectPlan,
phase: EffectPhase,
plan: &ScenePlan,
geometry: &[NodeGeometry],
) -> Result<(), SceneError> {
match (&effect.pattern, &effect.target) {
(EffectPattern::Pulse, EffectTarget::Node(id)) => {
let measurement = find_geometry(geometry, id)?;
events.push(SceneEvent::NodeActivated {
target_id: id.clone(),
point: rect_center(measurement.rect),
at_ms: phase.at_ms,
duration_ms: phase.duration_ms,
intensity: effect.parameters.intensity,
});
}
(EffectPattern::Glitch, EffectTarget::Node(id)) => {
events.push(SceneEvent::BackingGlitched {
target_id: id.clone(),
at_ms: phase.at_ms,
duration_ms: phase.duration_ms,
offset_x: effect.parameters.offset_x,
offset_y: effect.parameters.offset_y,
});
}
(EffectPattern::Invert, EffectTarget::Node(id)) => {
events.push(SceneEvent::BackingInverted {
target_id: id.clone(),
at_ms: phase.at_ms,
duration_ms: phase.duration_ms,
});
}
(EffectPattern::Fragment, EffectTarget::Node(id)) => {
let measurement = find_geometry(geometry, id)?;
events.push(SceneEvent::FragmentsEmitted {
target_id: id.clone(),
point: rect_center(measurement.rect),
at_ms: phase.at_ms,
duration_ms: phase.duration_ms,
count: effect.parameters.fragments,
});
}
(EffectPattern::Scanline, EffectTarget::Node(id)) => {
let measurement = find_geometry(geometry, id)?;
events.push(SceneEvent::ScanlineSwept {
target_id: id.clone(),
rect: measurement.rect,
at_ms: phase.at_ms,
duration_ms: phase.duration_ms,
});
}
(EffectPattern::EdgeTraverse, EffectTarget::Edge(id)) => {
let (from, to) = measured_edge(plan, geometry, id)?;
events.push(SceneEvent::EdgeTraversed {
edge_id: id.clone(),
from,
to,
at_ms: phase.at_ms,
duration_ms: phase.duration_ms,
});
}
(EffectPattern::Packet, EffectTarget::Edge(id)) => {
let (from, to) = measured_edge(plan, geometry, id)?;
events.push(SceneEvent::PacketTraversed {
edge_id: id.clone(),
from,
to,
at_ms: phase.at_ms,
duration_ms: phase.duration_ms,
});
}
_ => return Err(SceneError::InvalidIdentifier("pattern target kind")),
}
Ok(())
}
fn find_geometry<'a>(
geometry: &'a [NodeGeometry],
id: &str,
) -> Result<&'a NodeGeometry, SceneError> {
geometry
.iter()
.find(|measurement| measurement.id == id)
.ok_or(SceneError::InvalidGeometry("missing effect target"))
}
fn measured_edge(
plan: &ScenePlan,
geometry: &[NodeGeometry],
id: &str,
) -> Result<(Point, Point), SceneError> {
let edge = plan
.diagram
.edges
.iter()
.find(|edge| edge.id == id)
.ok_or(SceneError::InvalidIdentifier("diagram edge"))?;
let from = find_geometry(geometry, &edge.from)?;
let to = find_geometry(geometry, &edge.to)?;
Ok((from.outgoing, to.incoming))
}
fn rect_center(rect: Rect) -> Point {
Point::new(rect.x + rect.width / 2.0, rect.y + rect.height / 2.0)
}
fn event_time(event: &SceneEvent) -> u32 {
match event {
SceneEvent::InteractionStarted { at_ms }
| SceneEvent::PhaseStarted { at_ms, .. }
| SceneEvent::NodeActivated { at_ms, .. }
| SceneEvent::BackingGlitched { at_ms, .. }
| SceneEvent::BackingInverted { at_ms, .. }
| SceneEvent::FragmentsEmitted { at_ms, .. }
| SceneEvent::EdgeTraversed { at_ms, .. }
| SceneEvent::PacketTraversed { at_ms, .. }
| SceneEvent::ScanlineSwept { at_ms, .. }
| SceneEvent::InteractionFinished { at_ms } => *at_ms,
}
}
struct SceneRandom {
state: u64,
}
impl SceneRandom {
const fn new(seed: u64) -> Self {
Self {
state: seed ^ 0xa076_1d64_78bd_642f,
}
}
fn next_u64(&mut self) -> u64 {
self.state = self.state.wrapping_add(0x9e37_79b9_7f4a_7c15);
let mut value = self.state;
value = (value ^ (value >> 30)).wrapping_mul(0xbf58_476d_1ce4_e5b9);
value = (value ^ (value >> 27)).wrapping_mul(0x94d0_49bb_1331_11eb);
value ^ (value >> 31)
}
fn index(&mut self, length: usize) -> usize {
if length == 0 {
return 0;
}
usize::from(self.next_u64().to_le_bytes()[0]) % length
}
fn layout(&mut self) -> LayoutProfile {
match self.index(7) {
0 => LayoutProfile::Instrument,
1 => LayoutProfile::Split,
2 => LayoutProfile::Asymmetric,
3 => LayoutProfile::ResultLed,
4 => LayoutProfile::DiagramLed,
5 => LayoutProfile::Terminal,
_ => LayoutProfile::Editorial,
}
}
fn diagram_form(&mut self) -> DiagramForm {
match self.index(4) {
0 => DiagramForm::Linear,
1 => DiagramForm::Tree,
2 => DiagramForm::State,
_ => DiagramForm::Network,
}
}
fn button_size(&mut self) -> ButtonSize {
match self.index(3) {
0 => ButtonSize::Compact,
1 => ButtonSize::Regular,
_ => ButtonSize::Prominent,
}
}
fn pattern(&mut self, allow_edge: bool) -> EffectPattern {
match self.index(if allow_edge { 7 } else { 5 }) {
0 => EffectPattern::Pulse,
1 => EffectPattern::Glitch,
2 => EffectPattern::Invert,
3 => EffectPattern::Fragment,
4 => EffectPattern::Scanline,
5 => EffectPattern::EdgeTraverse,
_ => EffectPattern::Packet,
}
}
fn action_pattern(&mut self) -> EffectPattern {
match self.index(4) {
0 => EffectPattern::Pulse,
1 => EffectPattern::Glitch,
2 => EffectPattern::Invert,
_ => EffectPattern::Fragment,
}
}
fn range_u8(&mut self, minimum: u8, maximum: u8) -> u8 {
let width = maximum - minimum + 1;
minimum + self.next_u64().to_le_bytes()[0] % width
}
fn range_u16(&mut self, minimum: u16, maximum: u16) -> u16 {
let width = maximum - minimum + 1;
let sample = u16::from(self.next_u64().to_le_bytes()[0]);
minimum + sample % width
}
fn signed_range(&mut self, maximum: i8) -> i8 {
if maximum == 0 {
return 0;
}
let width = u8::try_from(i16::from(maximum) * 2 + 1).map_or(1, |value| value);
let sample = self.next_u64().to_le_bytes()[0] % width;
i8::try_from(sample).map_or(0, |value| value) - maximum
}
}