Add ParticleSystem value formats

crates/analysis/src/completion.rs

@@ -502,6 +502,9 @@ fn type_snippet_placeholder(ty: &ValueType, n: usize) -> String {
 
 fn value_snippet(ty: &ValueType) -> Option<String> {
     match ty {
+        ValueType::RandomVariable { .. } => Some("${1:0} ${2:0}$0".into()),
+        ValueType::RandomKeyframe => Some("${1:0} ${2:0} ${3:0}$0".into()),
+        ValueType::ColorKeyframe => Some("R:${1:0} G:${2:0} B:${3:0} ${4:0}$0".into()),
         ValueType::TokenList { tokens } if tokens.len() > 1 => {
             let mut snippet = tokens
                 .iter()
@@ -526,6 +529,19 @@ fn completions_for_type(
     index: Option<&WorkspaceIndex>,
 ) -> Vec<Completion> {
     match ty {
+        ValueType::RandomVariable { value_set } if value_index == 2 => completions_for_type(
+            analyzer,
+            &ValueType::Enum {
+                value_set: value_set.clone(),
+            },
+            0,
+            current_token,
+            first_token,
+            index,
+        ),
+        ValueType::RandomVariable { .. } | ValueType::RandomKeyframe | ValueType::ColorKeyframe => {
+            Vec::new()
+        }
         ValueType::OneOf { variants } => {
             if current_token.is_some() || value_index > 0 {
                 return ty
@@ -776,6 +792,9 @@ fn type_label(ty: &ValueType) -> String {
         ValueType::Reference { ref_kind } => format!("ref {ref_kind:?}"),
         ValueType::W3dModel => "w3d model".into(),
         ValueType::W3dModelMember => "w3d model member".into(),
+        ValueType::RandomVariable { .. } => "real real [distribution]".into(),
+        ValueType::RandomKeyframe => "real real frame".into(),
+        ValueType::ColorKeyframe => "R: G: B: frame".into(),
         ValueType::Prefixed { prefix, value_type } => {
             format!("{prefix}:{}", type_label(value_type))
         }

crates/analysis/src/diagnostics.rs

@@ -1326,6 +1326,50 @@ impl<'a> Ctx<'a> {
                     self.check_reference(*ref_kind, tok);
                 }
             }
+            ValueType::RandomVariable { value_set } => {
+                for tok in tokens.iter().take(2) {
+                    self.check_number(tok, NumKind::Real);
+                }
+                if tokens.len() < 2 {
+                    if let Some(key) = field.key() {
+                        self.warning(
+                            &key,
+                            "missing-value",
+                            format!("`{}` expects at least 2 values", key.text()),
+                        );
+                    }
+                }
+                if let Some(distribution) = tokens.get(2) {
+                    self.check_enum_member(value_set, distribution);
+                }
+            }
+            ValueType::RandomKeyframe => {
+                for tok in tokens.iter().take(2) {
+                    self.check_number(tok, NumKind::Real);
+                }
+                if let Some(frame) = tokens.get(2) {
+                    self.check_number(frame, NumKind::UInt);
+                } else if let Some(key) = field.key() {
+                    self.warning(
+                        &key,
+                        "missing-value",
+                        format!("`{}` expects 3 values", key.text()),
+                    );
+                }
+            }
+            ValueType::ColorKeyframe => {
+                if tokens.len() >= 4 {
+                    let (color, frame) = tokens.split_at(tokens.len() - 1);
+                    self.check_axes(field, color, &["R", "G", "B"], None, true);
+                    self.check_number(&frame[0], NumKind::UInt);
+                } else if let Some(key) = field.key() {
+                    self.warning(
+                        &key,
+                        "missing-value",
+                        format!("`{}` expects a color and frame", key.text()),
+                    );
+                }
+            }
             // A fixed sequence of typed tokens; each listed token is required
             // (the engine's parse function calls getNextToken for each).
             ValueType::TokenList { tokens: specs } => {
@@ -1459,6 +1503,9 @@ impl<'a> Ctx<'a> {
             | ValueType::Color
             | ValueType::Coord2D
             | ValueType::Coord3D
+            | ValueType::RandomVariable { .. }
+            | ValueType::RandomKeyframe
+            | ValueType::ColorKeyframe
             | ValueType::TokenList { .. }
             | ValueType::OneOf { .. }
             | ValueType::Unknown { .. } => {}

crates/analysis/src/semantic.rs

@@ -187,6 +187,17 @@ impl<'a> Sem<'a> {
             .map(|token| token.text().trim_matches('"'))
             .collect::<Vec<_>>();
         for (i, tok) in value_tokens.iter().enumerate() {
+            if matches!(active_ty, Some(ValueType::RandomVariable { .. })) {
+                self.set(
+                    tok,
+                    if i == 2 {
+                        SemKind::EnumMember
+                    } else {
+                        SemKind::Number
+                    },
+                );
+                continue;
+            }
             // Token lists classify each position by its own element type.
             let elem = active_ty.and_then(|ty| ty.token_type_at_input(&input, i));
             self.set(tok, value_token_kind(tok, elem));
@@ -230,6 +241,9 @@ fn value_token_kind(tok: &SyntaxToken, ty: Option<&ValueType>) -> SemKind {
         | Some(ValueType::Velocity)
         | Some(ValueType::Acceleration)
         | Some(ValueType::Color)
+        | Some(ValueType::RandomVariable { .. })
+        | Some(ValueType::RandomKeyframe)
+        | Some(ValueType::ColorKeyframe)
         | Some(ValueType::Coord2D)
         | Some(ValueType::Coord3D) => SemKind::Number,
         Some(ValueType::Reference { .. })
@@ -281,6 +295,19 @@ mod tests {
         assert!(t.iter().any(|(k, s)| *k == SemKind::Number && s == "100"));
     }
 
+    #[test]
+    fn classifies_particle_keyframe_values_as_numbers() {
+        let src = "ParticleSystem Test\n  Alpha1 = 0 1 2\n  Color1 = R:0 G:1 B:2 3\nEnd\n";
+        let t = toks(src);
+        for value in ["0", "1", "2", "R:0", "G:1", "B:2", "3"] {
+            assert!(
+                t.iter()
+                    .any(|(kind, text)| *kind == SemKind::Number && text == value),
+                "{value} was not classified as a number"
+            );
+        }
+    }
+
     #[test]
     fn range_tokens_cover_exactly_the_intersecting_blocks() {
         let a = Analyzer::embedded();

crates/analysis/tests/spec/ParticleSystemValues.ini

@@ -0,0 +1,7 @@
+ParticleSystem ParticleSystemValues
+    AngleZ = 0 1 $1
+    VelocityDamping = 0 1 invalid
+    AngularDamping = invalid 1
+    Alpha1 = 0 1 invalid
+    Color1 = R:0 G:0 B:0 invalid
+End

crates/analysis/tests/spec/ParticleSystemValues.spec.toml

@@ -0,0 +1,27 @@
+[[complete]]
+at = "$1"
+includes = ["CONSTANT", "UNIFORM", "GAUSSIAN", "TRIANGULAR", "LOW_BIAS", "HIGH_BIAS"]
+
+[[diag]]
+severity = "error"
+code = "bad-enum"
+on = "invalid"
+nth = 1
+
+[[diag]]
+severity = "error"
+code = "bad-number"
+on = "invalid"
+nth = 2
+
+[[diag]]
+severity = "error"
+code = "bad-number"
+on = "invalid"
+nth = 3
+
+[[diag]]
+severity = "error"
+code = "bad-number"
+on = "invalid"
+nth = 4