feat: add sound management to sprite, including parsing and serialization

Author: aspizu

src/ast.rs

@@ -13,6 +13,7 @@ mod proc;
 mod project;
 mod references;
 mod rotation_style;
+mod sound;
 mod sprite;
 mod stmt;
 mod struct_;
@@ -37,6 +38,7 @@ pub use proc::*;
 pub use project::*;
 pub use references::*;
 pub use rotation_style::*;
+pub use sound::*;
 pub use sprite::*;
 pub use stmt::*;
 pub use struct_::*;

src/ast/sound.rs

@@ -0,0 +1,26 @@
+use std::path::Path;
+
+use logos::Span;
+
+use crate::misc::SmolStr;
+
+#[derive(Debug)]
+pub struct Sound {
+    pub name: SmolStr,
+    pub path: SmolStr,
+    pub span: Span,
+}
+
+impl Sound {
+    pub fn new(path: SmolStr, alias: Option<SmolStr>, span: Span) -> Self {
+        let name = alias.unwrap_or_else(|| {
+            Path::new(&*path)
+                .file_stem()
+                .unwrap()
+                .to_str()
+                .unwrap()
+                .into()
+        });
+        Self { name, path, span }
+    }
+}

src/ast/sprite.rs

@@ -9,6 +9,7 @@ use crate::misc::SmolStr;
 #[derive(Debug, Default)]
 pub struct Sprite {
     pub costumes: Vec<Costume>,
+    pub sounds: Vec<Sound>,
     pub procs: FxHashMap<SmolStr, Proc>,
     pub proc_definitions: FxHashMap<SmolStr, Vec<Stmt>>,
     pub proc_references: FxHashMap<SmolStr, References>,

src/codegen/sb3.rs

@@ -9,6 +9,7 @@ use std::{
     path::Path,
 };
 
+use base64::write;
 use fxhash::{
     FxHashMap,
     FxHashSet,
@@ -601,6 +602,11 @@ where T: Write + Seek
         }
         write!(self, "]")?; // costumes
         write!(self, r#","sounds":["#)?;
+        let mut comma = false;
+        for sound in &sprite.sounds {
+            write_comma_io(&mut self.zip, &mut comma)?;
+            self.sound(input, sound, d)?;
+        }
         write!(self, "]")?; // sounds
         if let Some(x_position) = &sprite.x_position {
             let x_position = x_position.evaluate();
@@ -834,6 +840,40 @@ where T: Write + Seek
         write!(self, "}}") // costume
     }
 
+    pub fn sound(&mut self, input: &Path, sound: &Sound, d: D) -> io::Result<()> {
+        let path = input.join(&*sound.path);
+        let hash = self
+            .costumes
+            .get(&sound.path)
+            .cloned()
+            .map(Ok::<_, io::Error>)
+            .unwrap_or_else(|| {
+                let mut file = match File::open(&path) {
+                    Ok(file) => file,
+                    Err(error) => {
+                        d.report(DiagnosticKind::IOError(error), &sound.span);
+                        return Ok(Default::default());
+                    }
+                };
+                let mut hasher = Md5::new();
+                io::copy(&mut file, &mut hasher)?;
+                let hash: SmolStr = format!("{:x}", hasher.finalize()).into();
+                self.costumes.insert(sound.path.clone(), hash.clone());
+                Ok(hash)
+            })?;
+        let (_, extension) = sound.path.rsplit_once('.').unwrap_or_default();
+        self.sound_entry(&sound.name, &hash, extension)
+    }
+
+    pub fn sound_entry(&mut self, name: &str, hash: &str, extension: &str) -> io::Result<()> {
+        write!(self, "{{")?;
+        write!(self, r#""name":{}"#, json!(name))?;
+        write!(self, r#","assetId":"{hash}""#)?;
+        write!(self, r#","dataFormat":"{extension}""#)?;
+        write!(self, r#","md5ext":"{hash}.{extension}""#)?;
+        write!(self, "}}") // costume
+    }
+
     pub fn proc(&mut self, s: S, d: D, proc: &Proc, definition: &[Stmt]) -> io::Result<()> {
         let this_id = self.id.new_id();
         let prototype_id = self.id.new_id();

src/parser/grammar.lalrpop

@@ -15,6 +15,7 @@ pub Sprite = Declr*;
 Declr: () = {
     ";",
     COSTUMES Comma<Costume> ";",
+    SOUNDS Comma<Sound> ";",
     HIDE ";" => {
         sprite.hidden = true;
     },
@@ -121,6 +122,12 @@ Costume: () = {
     }
 }
 
+Sound: () = {
+    <l:@L> <path:STR> <r:@R> <alias:(AS <STR>)?> => {
+        sprite.sounds.push(Sound::new(path, alias, l..r));
+    }
+}
+
 Stmts: Vec<Stmt> = "{" <(<Stmt> ";"*)*> "}";
 
 Stmt: Stmt = {

src/visitor/pass0.rs

@@ -21,6 +21,7 @@ pub fn visit_project(project: &mut Project) {
 
 fn visit_sprite(sprite: &mut Sprite, mut stage: Option<&mut Sprite>) {
     visit_costumes(&mut sprite.costumes);
+    visit_sounds(&mut sprite.sounds);
     for enum_ in sprite.enums.values_mut() {
         visit_enum(enum_);
     }
@@ -111,6 +112,33 @@ fn visit_costumes(new: &mut Vec<Costume>) {
     }
 }
 
+fn visit_sounds(new: &mut Vec<Sound>) {
+    let old: Vec<Sound> = std::mem::take(new);
+    for sound in old {
+        if let Some(suffix) = sound.name.strip_prefix("@ascii/") {
+            new.extend((' '..='~').map(|ch| Sound {
+                name: format!("{suffix}{ch}").into(),
+                path: sound.path.clone(),
+                span: sound.span.clone(),
+            }));
+        } else if sound.path.contains('*') {
+            let mut sounds: Vec<Sound> = glob(&sound.path)
+                .unwrap()
+                .map(Result::unwrap)
+                .map(|path| Sound {
+                    name: path.file_stem().unwrap().to_string_lossy().into(),
+                    path: path.to_string_lossy().into(),
+                    span: sound.span.clone(),
+                })
+                .collect();
+            sounds.sort_by(|a, b| a.name.cmp(&b.name));
+            new.extend(sounds);
+        } else {
+            new.push(sound);
+        }
+    }
+}
+
 fn visit_stmts(stmts: &mut Vec<Stmt>, v: &mut V) {
     for stmt in stmts {
         visit_stmt(stmt, v);