work on enemies, stage loading and rendering

Cargo.lock

@@ -611,6 +611,7 @@ dependencies = [
  "glam",
  "heapless",
  "identconv",
+ "instructions",
  "log",
  "macros",
  "memmap2",
@@ -1594,6 +1595,16 @@ dependencies = [
  "hashbrown 0.15.0",
 ]
 
+[[package]]
+name = "instructions"
+version = "0.1.0"
+dependencies = [
+ "macros",
+ "num-derive",
+ "num-traits",
+ "truth",
+]
+
 [[package]]
 name = "is-terminal"
 version = "0.4.13"

Cargo.toml

@@ -1,3 +1,9 @@
+[workspace]
+resolver = "2"
+members = ["instructions", "macros"]
+[workspace.dependencies]
+truth = { git = "https://github.com/ExpHP/truth" }
+
 [package]
 name = "chireiden-thing"
 version = "0.1.0"
@@ -13,7 +19,7 @@ ndarray = "0.16.1"
 num-derive = "0.4.2"
 num-traits = "0.2.19"
 rand = "0.8.5"
-truth = { git = "https://github.com/ExpHP/truth" }
+truth = { workspace = true }
 anyhow = { version = "1.0", features = ["backtrace"] }
 glam = { version = "0.29", features = ["bytemuck"] }
 bytemuck = { version = "1.18", features = ["derive"] }
@@ -32,6 +38,7 @@ atomic_refcell = "0.1.13"
 pin-project = "1.1.7"
 heapless = "0.8.0"
 bitfield-struct = "0.9.2"
+instructions = { version = "0.1.0", path = "instructions" }
 
 [dev-dependencies]
 csv = "1.3.0"

flake.nix

@@ -40,6 +40,12 @@
               alsa-lib
               (pkgs.callPackage ./thtk.nix {})
               (pkgs.callPackage ./truth.nix {})
+
+                  xorg.libX11
+    xorg.libXcursor
+    xorg.libxcb
+    xorg.libXi
+    libxkbcommon
             ];
             LD_LIBRARY_PATH = libPath;
           };

instructions/Cargo.toml

@@ -0,0 +1,10 @@
+[package]
+name = "instructions"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+macros = { version = "0.1.0", path = "../macros" }
+num-derive = "0.4.2"
+num-traits = "0.2.19"
+truth = { workspace = true }

instructions/src/anm.rs

@@ -2,9 +2,8 @@ use macros::decode_args;
 use num_derive::FromPrimitive;
 use num_traits::FromPrimitive;
 use truth::llir::RawInstr;
-use wgpu::naga::FastHashMap;
 
-use crate::game::param::Param;
+use crate::Param;
 
 #[derive(Debug, FromPrimitive)]
 enum Opcode {
@@ -93,21 +92,21 @@ enum Opcode {
   Color2Time = 78,
   Alpha2Time = 79,
   ColorMode = 80,
-  CaseReturn = 81,
+  ReturnFromInterrupt = 81,
   RotateAuto = 82,
   Ins83CopyPos = 83,
   TexCircle = 84,
   UnknownBitflag = 85,
   SlowdownImmune = 86,
   RandMode = 87,
-  ScriptNew = 88,
+  NewChildBack = 88,
   ResampleMode = 89,
-  ScriptNewUI = 90,
+  NewChildUIBack = 90,
-  ScriptNewFront = 91,
+  NewChildFront = 91,
-  ScriptNewUIFront = 92,
+  NewChildUIFront = 92,
   ScrollXTime = 93,
   ScrollYTime = 94,
-  ScriptNewRoot = 95,
+  NewRootBack = 95,
   ScriptNewPos = 96,
   ScriptNewRootPos = 97,
   MoveBezier = 100,
@@ -163,6 +162,8 @@ pub enum SpriteType {
   Rotate3D = 2,
   RotateZ3D = 3,
   RotateBillboard = 4,
+  Unknown3DA = 6,
+  Unknown3DB = 8,
 }
 
 #[derive(Debug, Clone, Copy)]
@@ -312,38 +313,43 @@ pub enum Op {
   Visible {
     value: i8,
   },
-  ZWriteDisable {
+  ZWriteDisable(bool),
-    value: i32,
-  },
   StdRelatedBitflag {
     enable: i32,
   },
   Wait {
     time: i32,
   },
-  CaseReturn,
+  ReturnFromInterrupt,
   UnknownBitflag {
     enable: i32,
   },
   RandMode {
     mode: i32,
   },
-  ScriptNew {
+  NewChildBack {
     script: i32,
   },
   ResampleMode {
     mode: i32,
   },
-  ScriptNewUI {
+  NewChildUIBack {
     script: i32,
   },
-  ScriptNewFront {
+  NewChildFront {
     script: i32,
   },
-  ScriptNewUIFront {
+  NewChildUIFront {
     script: i32,
   },
   ScrollXTime,
+  NewRootBack {
+    script: i32,
+  },
+  SpriteRand {
+    sprite: i32,
+    end: Param<i32>,
+  },
 }
 
 #[derive(Debug, Clone, Copy)]
@@ -353,7 +359,7 @@ pub struct Instruction {
 }
 
 impl Instruction {
-  pub fn from_raw(inst: RawInstr, instruction_offsets: &FastHashMap<u32, usize>) -> Self {
+  pub fn from_raw(inst: RawInstr, instruction_offsets: &Vec<(u32, usize)>) -> Self {
     let param_int = |value: i32, index: u16| {
       if inst.param_mask & (1 << index) == 0 {
         Param::Value(value)
@@ -385,7 +391,8 @@ impl Instruction {
       );
       value as i32
     };
-    let offset_to_index = |value: i32| instruction_offsets[&(value as u32)];
+    let offset_to_index =
+      |value: i32| instruction_offsets.binary_search_by_key(&(value as u32), |a| a.0).expect("failed to find entry");
 
     let args = &inst.args_blob;
     let opcode_raw = inst.opcode;
@@ -694,6 +701,18 @@ impl Instruction {
         Op::Layer { layer }
       }
       Opcode::StopHide => Op::StopHide,
+      Opcode::ScrollX => {
+        let value = decode_args!(args, "f");
+        Op::ScrollX { value }
+      }
+      Opcode::ScrollY => {
+        let value = decode_args!(args, "f");
+        Op::ScrollY { value }
+      }
+      Opcode::ZWriteDisable => {
+        let value = decode_args!(args, "S");
+        Op::ZWriteDisable(value != 0)
+      }
       Opcode::UnknownBitflag => {
         let enable = decode_args!(args, "S");
 
@@ -703,31 +722,40 @@ impl Instruction {
         let time = decode_args!(args, "S");
         Op::Wait { time }
       }
-      Opcode::CaseReturn => Op::CaseReturn,
+      Opcode::ReturnFromInterrupt => Op::ReturnFromInterrupt,
       Opcode::RandMode => {
         let mode = decode_args!(args, "S");
 
         Op::RandMode { mode }
       }
-      Opcode::ScriptNew => {
+      Opcode::NewChildBack => {
         let script = decode_args!(args, "S");
-        Op::ScriptNew { script }
+        Op::NewChildBack { script }
       }
       Opcode::ResampleMode => {
         let mode = decode_args!(args, "S");
         Op::ResampleMode { mode }
       }
-      Opcode::ScriptNewUI => {
+      Opcode::NewChildUIBack => {
         let script = decode_args!(args, "S");
-        Op::ScriptNewUI { script }
+        Op::NewChildUIBack { script }
       }
-      Opcode::ScriptNewFront => {
+      Opcode::NewChildFront => {
         let script = decode_args!(args, "S");
-        Op::ScriptNewFront { script }
+        Op::NewChildFront { script }
       }
-      Opcode::ScriptNewUIFront => {
+      Opcode::NewChildUIFront => {
         let script = decode_args!(args, "S");
-        Op::ScriptNewUIFront { script }
+        Op::NewChildUIFront { script }
+      }
+      Opcode::NewRootBack => {
+        let script = decode_args!(args, "S");
+        Op::NewRootBack { script }
+      }
+      Opcode::SpriteRand => {
+        let (sprite, end) = decode_args!(args, "SS");
+        let end = param_int(end, 1);
+        Op::SpriteRand { sprite, end }
       }
       opcode => panic!("unsupported instruction {opcode:?} ({opcode_raw})"),
     };

instructions/src/lib.rs

@@ -0,0 +1,5 @@
+pub mod anm;
+mod param;
+pub mod ecl;
+pub mod std;
+pub use param::*;

instructions/src/std.rs

@@ -0,0 +1,149 @@
+use macros::decode_args;
+use num_derive::FromPrimitive;
+use num_traits::FromPrimitive;
+use truth::llir::RawInstr;
+
+#[derive(Debug, FromPrimitive)]
+enum Opcode {
+  Halt = 0,
+  Jump = 1,
+  Position = 2,
+  PositionInterp = 3,
+  Facing = 4,
+  FacingInterp = 5,
+  Rotation = 6,
+  FieldOfView = 7,
+  Fog = 8,
+  FogInterp = 9,
+  PositionInterpBezier = 10,
+  FacingInterpBezier = 11,
+  ShakingMode = 12,
+  BackgroundFillColor = 13,
+  BackgroundSprite = 14,
+}
+
+#[derive(Debug)]
+pub enum Op {
+  Halt,
+  Jump {
+    index: usize,
+    time: i32,
+  },
+  Position {
+    x: f32,
+    y: f32,
+    z: f32,
+  },
+  PositionInterp {
+    time: i32,
+    mode: i32,
+    x: f32,
+    y: f32,
+    z: f32,
+  },
+  Facing {
+    x: f32,
+    y: f32,
+    z: f32,
+  },
+  FacingInterp {
+    time: i32,
+    mode: i32,
+    x: f32,
+    y: f32,
+    z: f32,
+  },
+  Rotation {
+    x: f32,
+    y: f32,
+    z: f32,
+  },
+  FieldOfView(f32),
+  Fog {
+    color: i32,
+    start: f32,
+    end: f32,
+  },
+  FogInterp {
+    time: i32,
+    mode: i32,
+    color: i32,
+    start: f32,
+    end: f32,
+  },
+  ShakingMode {
+    mode: i32,
+  },
+}
+
+pub struct Instruction {
+  pub time: i32,
+  pub op: Op,
+}
+
+impl Instruction {
+  pub fn from_raw(inst: RawInstr, instruction_offsets: &Vec<(u32, usize)>) -> Self {
+    let offset_to_index =
+      |value: i32| instruction_offsets.binary_search_by_key(&(value as u32), |a| a.0).expect("failed to find entry");
+
+    let args = &inst.args_blob;
+    let opcode_raw = inst.opcode;
+    let opcode = Opcode::from_u16(opcode_raw).expect("failed to convert opcode");
+
+    let op = match opcode {
+      Opcode::Halt => Op::Halt,
+      Opcode::Jump => {
+        let (offset, time) = decode_args!(args, "ot");
+        Op::Jump {
+          index: offset_to_index(offset),
+          time,
+        }
+      }
+      Opcode::Position => {
+        let (x, y, z) = decode_args!(args, "fff");
+        Op::Position { x, y, z }
+      }
+      Opcode::PositionInterp => {
+        let (time, mode, x, y, z) = decode_args!(args, "SUfff");
+        Op::PositionInterp { time, mode, x, y, z }
+      }
+      Opcode::Facing => {
+        let (x, y, z) = decode_args!(args, "fff");
+        Op::Facing { x, y, z }
+      }
+      Opcode::FacingInterp => {
+        let (time, mode, x, y, z) = decode_args!(args, "SUfff");
+        Op::FacingInterp { time, mode, x, y, z }
+      }
+      Opcode::Rotation => {
+        let (x, y, z) = decode_args!(args, "fff");
+        Op::Rotation { x, y, z }
+      }
+      Opcode::FieldOfView => {
+        let fov = decode_args!(args, "f");
+        Op::FieldOfView(fov)
+      }
+      Opcode::Fog => {
+        let (color, start, end) = decode_args!(args, "Sff");
+        Op::Fog { color, start, end }
+      }
+      Opcode::FogInterp => {
+        let (time, mode, color, start, end) = decode_args!(args, "SUSff");
+        Op::FogInterp {
+          time,
+          mode,
+          color,
+          start,
+          end,
+        }
+      }
+      Opcode::PositionInterpBezier => todo!(),
+      Opcode::FacingInterpBezier => todo!(),
+      Opcode::ShakingMode => todo!(),
+      Opcode::BackgroundFillColor => todo!(),
+      Opcode::BackgroundSprite => todo!(),
+    };
+
+    Instruction { time: inst.time, op }
+  }
+}

macros/src/lib.rs

@@ -1,20 +1,21 @@
-use proc_macro2::TokenStream;
+use proc_macro2::{Span, TokenStream};
 use quote::quote;
 use syn::{
-  parse::{ParseStream, Parser}, Expr, LitStr, Token
+  parse::{ParseStream, Parser},
+  spanned::Spanned,
+  Expr, ExprLit, Ident, Lit, LitStr, Token, Type, TypeArray,
 };
 use truth::{
-  context::RootEmitter, llir::{ArgEncoding, InstrAbi, StringArgSize}, pos::SourceStr
+  context::RootEmitter,
+  llir::{ArgEncoding, InstrAbi, StringArgSize},
+  pos::SourceStr,
 };
 
 #[proc_macro]
 pub fn decode_args(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
-  match blob_impl.parse(input.clone()) {
+  match blob_impl.parse(input) {
     Ok(data) => data.into(),
-    Err(error) => {
+    Err(error) => error.into_compile_error().into(),
-      // error.span().unwrap().error(error.to_string());
-      error.into_compile_error().into()
-    }
   }
 }
 
@@ -22,11 +23,14 @@ fn blob_impl(input: ParseStream) -> syn::Result<TokenStream> {
   let reader: Expr = input.parse()?;
   let _: Token![,] = input.parse()?;
   let sig_str: LitStr = input.parse()?;
-  let sig = InstrAbi::parse(
+  let sig_str_span = sig_str.span();
-    SourceStr::from_full_source(None, sig_str.value().as_str()),
+  let sig_str = sig_str.value();
-    &RootEmitter::new_stderr(),
+  let (sig_str, variadic) = if sig_str.ends_with('v') {
-  )
+    (&sig_str.as_str()[..sig_str.len() - 1], true)
-  .unwrap();
+  } else {
+    (sig_str.as_str(), false)
+  };
+  let sig = InstrAbi::parse(SourceStr::from_full_source(None, sig_str), &RootEmitter::new_stderr()).unwrap();
   let encodings: Vec<_> = sig
     .arg_encodings()
     .map(|enc| {
@@ -43,22 +47,127 @@ fn blob_impl(input: ParseStream) -> syn::Result<TokenStream> {
         }
         ArgEncoding::JumpTime => quote!(cursor.read_i32().unwrap()),
         ArgEncoding::JumpOffset => quote!(cursor.read_i32().unwrap()),
+        ArgEncoding::Color => quote!(cursor.read_u32().unwrap()),
         ArgEncoding::String {
           size: StringArgSize::Fixed { len, .. },
           ..
-        } => quote!(cursor.read_cstring_exact(#len)),
+        } => quote!(cursor.read_cstring_exact(#len).unwrap().decode(truth::io::DEFAULT_ENCODING).unwrap()),
-        _ => return Err(syn::Error::new(sig_str.span(), "failed...")),
+        ArgEncoding::String {
+          size: StringArgSize::Pascal { block_size },
+          ..
+        } => quote!(cursor.read_cstring_blockwise(#block_size).unwrap().decode(truth::io::DEFAULT_ENCODING).unwrap()),
+        _ => return Err(syn::Error::new(sig_str_span, "failed...")),
       })
     })
     .collect::<syn::Result<_>>()?;
 
+  let variadic = variadic.then(|| {
+    quote! {
+      , {
+        let file_size = cursor.file_size().unwrap();
+        let offset = (file_size - cursor.pos().unwrap()) as usize;
+        cursor.read_byte_vec(offset).unwrap()
+      }
+    }
+  });
+
   Ok(quote! {
     {
       use truth::io::BinRead;
       let mut cursor = ::std::io::Cursor::new(#reader);
       (
         #(#encodings),*
+        #variadic
       )
     }
   })
 }
+
+//spawner_rank_decode_args!(args, "S", [[f32; 2]; 3])
+
+#[proc_macro]
+pub fn spawner_param_decode_args(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
+  match spawner_param_decode_args_impl.parse(input) {
+    Ok(data) => data.into(),
+    Err(error) => error.into_compile_error().into(),
+  }
+}
+
+fn spawner_param_decode_args_impl(input: ParseStream) -> syn::Result<TokenStream> {
+  let reader: Expr = input.parse()?;
+  let _: Token![,] = input.parse()?;
+  let sig_str: LitStr = input.parse()?;
+  let _: Token![,] = input.parse()?;
+  let array = input.parse::<TypeArray>()?;
+
+  let Expr::Lit(ExprLit { lit: Lit::Int(int), .. }) = array.len else {
+    return Err(syn::Error::new(array.len.span(), "length must be a constant number"));
+  };
+  let rank_count = int.base10_parse::<usize>()?;
+  let Type::Array(TypeArray {
+    elem,
+    len: Expr::Lit(ExprLit { lit: Lit::Int(int), .. }),
+    ..
+  }) = array.elem.as_ref()
+  else {
+    return Err(syn::Error::new(
+      array.elem.span(),
+      "element was not an array with constant number ",
+    ));
+  };
+  let entry_count = int.base10_parse::<usize>()?;
+  let Type::Path(path) = elem.as_ref() else {
+    return Err(syn::Error::new(elem.span(), "expected path as element"));
+  };
+  let ident = path.path.get_ident().ok_or(syn::Error::new(path.span(), "path was not a single ident"))?;
+  let type_id = ident.to_string();
+  enum ParamType {
+    Float,
+    Int,
+  }
+  let param_ty = match type_id.as_str() {
+    "f32" => ParamType::Float,
+    "i32" => ParamType::Int,
+    _ => return Err(syn::Error::new(ident.span(), "expected i32 or f32")),
+  };
+
+  let total = entry_count * rank_count;
+  let mut arguments = sig_str.value();
+
+  arguments.extend(std::iter::repeat_n(
+    match param_ty {
+      ParamType::Int => 'S',
+      ParamType::Float => 'f',
+    },
+    total,
+  ));
+
+  let rank_list: Vec<Vec<Ident>> = (0..rank_count)
+    .map(|rank| {
+      (0..entry_count).map(move |entry| Ident::new(&format!("__a_{rank}_{entry}"), Span::call_site())).collect()
+    })
+    .collect();
+
+  let tuple_pat = rank_list.iter().flatten();
+  let rank_array = rank_list.iter().enumerate().map(|(rank_index, list)| {
+    let list = list.iter().enumerate().map(|(entry_index, entry)| {
+      let param_index = rank_index * entry_count + entry_index + 1;
+      let param_index = param_index as u16;
+      let kind = match param_ty {
+        ParamType::Float => quote!(param_float),
+        ParamType::Int => quote!(param_int),
+      };
+      quote!(#kind(#entry, #param_index))
+    });
+    quote! {
+      [#(#list),*]
+    }
+  });
+
+  Ok(quote! {
+    {
+      let (id, #(#tuple_pat),*) = decode_args!(#reader, #arguments);
+      (id, [#(#rank_array),*])
+    }
+  })
+}

src/engine.rs

@@ -1,5 +1,5 @@
 use std::{
-  sync::{Arc, LazyLock, Mutex}, time::{Duration, Instant}
+  cell::Cell, ops::ControlFlow, sync::{Arc, LazyLock}, time::{Duration, Instant}
 };
 
 use wgpu::{
@@ -23,6 +23,7 @@ pub struct Engine<'a> {
   last_frame_instant: Instant,
   last_second: Instant,
   frames: u32,
+  should_exit: Cell<bool>,
 
   state: GameRunner,
   focused: bool,
@@ -48,6 +49,7 @@ impl KeyState {
 #[derive(Default)]
 pub struct Keys {
   values: FastHashMap<KeyCode, KeyState>,
+  down_count: u32,
 }
 
 impl Keys {
@@ -55,8 +57,10 @@ impl Keys {
     let key_state = self.values.entry(key).or_default();
     if key_state.is_down() != state.is_pressed() {
       *key_state = if state.is_pressed() {
+        self.down_count += 1;
         KeyState::Pressed
       } else {
+        self.down_count -= 1;
         KeyState::Released
       }
     }
@@ -85,6 +89,10 @@ impl Keys {
   pub fn was_key_pressed(&self, key: KeyCode) -> bool {
     matches!(self.values.get(&key), Some(KeyState::Pressed))
   }
+
+  pub fn is_any_key_down(&self) -> bool {
+    self.down_count > 0
+  }
 }
 
 impl<'a> Engine<'a> {
@@ -127,7 +135,7 @@ impl<'a> Engine<'a> {
     let caps = surface.get_capabilities(&adapter);
     let format =
       caps.formats.iter().find(|f| matches!(f, TextureFormat::Bgra8Unorm)).cloned().unwrap_or(caps.formats[0]);
-    let config = (SurfaceConfiguration {
+    let config = SurfaceConfiguration {
       usage: TextureUsages::RENDER_ATTACHMENT,
       format,
       width: size.width,
@@ -136,17 +144,19 @@ impl<'a> Engine<'a> {
       desired_maximum_frame_latency: 2,
       alpha_mode: caps.alpha_modes[0],
       view_formats: vec![],
-    });
+    };
 
     surface.configure(&device, &config);
 
     let keys = Keys::default();
+    let should_exit = Cell::new(false);
     let state = GameRunner::new(&UpdateContext {
       device: &device,
       queue: &queue,
       window: &window,
       keys: &keys,
       config: &config,
+      should_exit: &should_exit,
     });
 
     let now = Instant::now();
@@ -163,6 +173,7 @@ impl<'a> Engine<'a> {
       frames: 0,
       keys: Keys::default(),
       focused: false,
+      should_exit,
 
       state,
     }
@@ -206,19 +217,20 @@ impl<'a> Engine<'a> {
           keys: &self.keys,
           window: &self.window,
           config: &self.config,
+          should_exit: &self.should_exit
         },
         new_size,
       );
     }
   }
 
-  pub fn update(&mut self) {
+  pub fn update(&mut self) -> ControlFlow<()> {
-    // fixed step
+    // target game at fixed step 60fps always,
     const TARGET_FRAMERATE: LazyLock<Duration> = LazyLock::new(|| Duration::from_secs_f64(1. / 60.));
     let now = Instant::now();
     let since_last_frame = now - self.last_frame_instant;
     if since_last_frame < *TARGET_FRAMERATE {
-      return;
+      return ControlFlow::Continue(());
     }
     self.last_frame_instant = now;
     self.frames += 1;
@@ -229,6 +241,7 @@ impl<'a> Engine<'a> {
       keys: &self.keys,
       window: &self.window,
       config: &self.config,
+      should_exit: &self.should_exit
     });
     self.keys.tick_keys();
 
@@ -236,6 +249,11 @@ impl<'a> Engine<'a> {
       self.last_second = now;
       self.frames = 0;
     }
+
+    match self.should_exit.get() {
+      true => ControlFlow::Break(()),
+      false => ControlFlow::Continue(())
+    }
   }
 
   pub fn render(&self) -> Result<(), wgpu::SurfaceError> {
@@ -258,6 +276,7 @@ pub struct UpdateContext<'a> {
   pub keys: &'a Keys,
   pub window: &'a Arc<Window>,
   pub config: &'a SurfaceConfiguration,
+  pub should_exit: &'a Cell<bool>,
 }
 
 pub trait EngineState {

src/game/anm/loaded_file.rs

@@ -1,8 +1,9 @@
-use std::{io::Cursor, ops::Add, path::Path, sync::Arc};
+use std::{io::Cursor, ops::Add, sync::Arc};
 
 use async_std::fs;
 use bytemuck::{Pod, Zeroable};
 use glam::Vec2;
+use instructions::anm::{Instruction, Op};
 use nonoverlapping_interval_tree::NonOverlappingIntervalTree;
 use truth::{context::RootEmitter, io::BinReader, AnmFile, Game as TruthGame};
 use wgpu::{
@@ -14,10 +15,7 @@ use winit::dpi::PhysicalSize;
 
 use crate::utils::game::Game;
 
-use super::{
+use super::image::{produce_image_from_entry, Image};
-  image::{produce_image_from_entry, Image},
-  vm::opcodes::{Instruction, Op},
-};
 
 pub struct LoadedEntry {
   _texture: Texture,
@@ -169,10 +167,10 @@ pub struct LoadedScript {
 
 impl LoadedScript {
   fn load(script: &truth::anm::Script) -> Arc<LoadedScript> {
-    let mut offset_instructions: FastHashMap<_, _> = Default::default();
+    let mut offset_instructions: Vec<(_, _)> = Default::default();
     let mut current_offset = 0;
     for (index, inst) in script.instrs.iter().enumerate() {
-      offset_instructions.insert(current_offset, index);
+      offset_instructions.push((current_offset, index));
       current_offset += 8 + inst.args_blob.len() as u32
     }
 
@@ -204,11 +202,12 @@ pub struct LoadedFile {
 }
 
 impl LoadedFile {
-  pub async fn load(device: &Device, queue: &Queue, size: PhysicalSize<u32>, game: Game, file_name: &str) -> Self {
+  pub async fn load(device: Arc<Device>, queue: Arc<Queue>, size: PhysicalSize<u32>, game: Game, file_name: impl Into<String> + Send) -> Self {
-    let file_data = fs::read(game.asset_path(file_name)).await.expect("failed to load anm file");
+    let file_name = file_name.into();
+    let file_data = fs::read(game.asset_path(&file_name)).await.expect("failed to load anm file");
 
     let file = AnmFile::read_from_stream(
-      &mut BinReader::from_reader(&RootEmitter::new_stderr(), file_name, Cursor::new(file_data)),
+      &mut BinReader::from_reader(&RootEmitter::new_stderr(), &file_name, Cursor::new(file_data)),
       match game {
         Game::Mof => TruthGame::Th10,
         Game::Sa => TruthGame::Th11,
@@ -220,7 +219,7 @@ impl LoadedFile {
     let scripts =
       file.entries.iter().flat_map(|entry| &entry.scripts).map(|(_, script)| LoadedScript::load(script)).collect();
 
-    let entries = file.entries.iter().map(|entry| LoadedEntry::load(device, queue, size, entry)).collect::<Vec<_>>();
+    let entries = file.entries.iter().map(|entry| LoadedEntry::load(&device, &queue, size, entry)).collect::<Vec<_>>();
 
     let mut sprite_entries = NonOverlappingIntervalTree::new();
 

src/game/anm/manager/loading.rs

@@ -13,8 +13,8 @@ use super::Manager;
 impl Manager {
   pub fn start_load_anm(
     &mut self,
-    device: Arc<Device>,
+    device: &Arc<Device>,
-    queue: Arc<Queue>,
+    queue: &Arc<Queue>,
     size: PhysicalSize<u32>,
     game: Game,
     file_name: impl Into<String>,
@@ -25,8 +25,9 @@ impl Manager {
     }
 
     let sender = self.anm_sender.clone();
+    let (device, queue) = (device.clone(), queue.clone());
     Soon::new(async move {
-      let file = Arc::new(LoadedFile::load(&device, &queue, size, game, &file_name).await);
+      let file = Arc::new(LoadedFile::load(device, queue, size, game, &file_name).await);
 
       sender.send((file_name, file.clone())).unwrap();
 
@@ -42,8 +43,8 @@ impl Manager {
 
   pub fn load_anm(
     &mut self,
-    device: &Device,
+    device: &Arc<Device>,
-    queue: &Queue,
+    queue: &Arc<Queue>,
     window: &Window,
     game: Game,
     file_name: impl Into<String>,
@@ -54,8 +55,8 @@ impl Manager {
     }
 
     let loaded_anm = Arc::new(async_std::task::block_on(LoadedFile::load(
-      device,
+      device.clone(),
-      queue,
+      queue.clone(),
       window.inner_size(),
       game,
       &file_name,

src/game/anm/manager/mod.rs

@@ -3,7 +3,8 @@ use bytemuck::{Pod, Zeroable};
 use crossbeam::channel::{Receiver, Sender};
 use glam::Mat4;
 use std::{
-  collections::VecDeque, sync::{Arc, Weak}
+  collections::VecDeque,
+  sync::{Arc, Weak},
 };
 use wgpu::{naga::FastHashMap, BindGroup, Buffer, PipelineLayout, RenderPipeline, ShaderModule, Texture};
 
@@ -34,7 +35,7 @@ pub struct Manager {
 
   depth_texture: Texture,
   ui_uniform: Uniform,
-  _world_uniform: Uniform,
+  world_uniform: Uniform,
   uniform_buffer: Buffer,
   render_bind_group: BindGroup,
   render_pipeline_layout: PipelineLayout,
@@ -62,8 +63,6 @@ impl Manager {
       vm.borrow_mut().interrupt(interrupt);
     }
 
-    self.update_single(&vm);
-
     let mut context = ManagerUpdate::new();
     vm.borrow_mut().tick(&mut context);
 
@@ -83,12 +82,17 @@ impl Manager {
     vm
   }
 
-  fn update_single(&mut self, vm: &Vm) {
+  pub fn update_single(&mut self, vm: &Vm) {
     let mut context = ManagerUpdate::new();
     vm.borrow_mut().tick(&mut context);
     context.apply_lists(&mut self.ui_vms, &mut self.world_vms);
   }
 
+  pub fn interrupt_immediately(&mut self, vm: &Vm, interrupt: u32) {
+    vm.borrow_mut().interrupt(interrupt);
+    self.update_single(vm);
+  }
+
   fn update_list(list: &mut VecDeque<WeakVm>, context: &mut ManagerUpdate) {
     list.retain(|value| {
       if let Some(rc) = value.upgrade() {

src/game/anm/manager/rendering.rs

@@ -4,12 +4,20 @@ use bytemuck::{bytes_of, Pod, Zeroable};
 use glam::{Mat4, Vec2, Vec3, Vec4};
 use num_traits::FloatConst;
 use wgpu::{
-  include_wgsl, naga::FastHashMap, util::{BufferInitDescriptor, DeviceExt}, BindGroupDescriptor, BindGroupEntry, BindGroupLayoutDescriptor, BindGroupLayoutEntry, BindingResource, BlendState, BufferDescriptor, BufferUsages, Color, ColorTargetState, ColorWrites, DepthStencilState, Device, Extent3d, FragmentState, LoadOp, Operations, PipelineLayoutDescriptor, PrimitiveState, RenderPass, RenderPassColorAttachment, RenderPassDepthStencilAttachment, RenderPassDescriptor, RenderPipeline, RenderPipelineDescriptor, ShaderStages, StoreOp, TextureDescriptor, TextureFormat, TextureUsages, VertexAttribute, VertexBufferLayout, VertexState
+  include_wgsl,
+  naga::FastHashMap,
+  util::{BufferInitDescriptor, DeviceExt},
+  BindGroupDescriptor, BindGroupEntry, BindGroupLayoutDescriptor, BindGroupLayoutEntry, BindingResource, BlendState,
+  BufferDescriptor, BufferUsages, Color, ColorTargetState, ColorWrites, DepthStencilState, Device, Extent3d,
+  FragmentState, LoadOp, Operations, PipelineLayoutDescriptor, PrimitiveState, RenderPass, RenderPassColorAttachment,
+  RenderPassDepthStencilAttachment, RenderPassDescriptor, RenderPipeline, RenderPipelineDescriptor, ShaderStages,
+  StoreOp, TextureDescriptor, TextureFormat, TextureUsages, VertexAttribute, VertexBufferLayout, VertexState,
 };
 use winit::dpi::PhysicalSize;
 
 use crate::{
-  engine::{Engine, UpdateContext}, game::anm::{loaded_file::SpriteUvs, vm::RenderingState, AnmVm}
+  engine::{Engine, UpdateContext},
+  game::anm::{loaded_file::SpriteUvs, vm::RenderingState, AnmVm},
 };
 
 use super::{Manager, Uniform, WeakVm};
@@ -203,7 +211,7 @@ impl Manager {
 
       depth_texture,
       ui_uniform,
-      _world_uniform: world_uniform,
+      world_uniform,
       uniform_buffer,
       render_bind_group,
       render_pipeline_layout: pipeline_layout,
@@ -292,13 +300,6 @@ impl Manager {
     render_pipeline
   }
 
-  pub fn render_vms(&self, engine: &Engine, pass: &mut RenderPass) {
-    self.render_layer(engine, pass, &self.ui_vms, 21);
-    self.render_layer(engine, pass, &self.ui_vms, 22);
-    self.render_layer(engine, pass, &self.ui_vms, 23);
-    self.render_layer(engine, pass, &self.ui_vms, 29);
-  }
-
   fn render_layer(&self, engine: &Engine, pass: &mut RenderPass, list: &VecDeque<WeakVm>, layer: u32) {
     for vm in list {
       if let Some(vm) = vm.upgrade() {
@@ -369,7 +370,7 @@ impl Manager {
   fn render_ui(&self, engine: &Engine, encoder: &mut wgpu::CommandEncoder, surface: &wgpu::Texture) {
     engine.queue.write_buffer(&self.uniform_buffer, 0, bytes_of(&self.ui_uniform));
     let mut pass = encoder.begin_render_pass(&RenderPassDescriptor {
-      label: Some("anm"),
+      label: Some("ui anms"),
       color_attachments: &[Some(RenderPassColorAttachment {
         view: &surface.create_view(&Default::default()),
         resolve_target: None,
@@ -398,7 +399,50 @@ impl Manager {
       ..Default::default()
     });
 
-    self.render_vms(engine, &mut pass);
+    self.render_layer(engine, &mut pass, &self.ui_vms, 21);
+    self.render_layer(engine, &mut pass, &self.ui_vms, 22);
+    self.render_layer(engine, &mut pass, &self.ui_vms, 23);
+    self.render_layer(engine, &mut pass, &self.ui_vms, 29);
+  }
+
+  fn render_world(&self, engine: &Engine, encoder: &mut wgpu::CommandEncoder, surface: &wgpu::Texture) {
+    engine.queue.write_buffer(&self.uniform_buffer, 0, bytes_of(&self.world_uniform));
+    let mut pass = encoder.begin_render_pass(&RenderPassDescriptor {
+      label: Some("world anms"),
+      color_attachments: &[Some(RenderPassColorAttachment {
+        view: &surface.create_view(&Default::default()),
+        resolve_target: None,
+        ops: Operations {
+          // load: LoadOp::Clear(Color {
+          //   // r: 100. / 255.,
+          //   // g: 149. / 255.,
+          //   // b: 237. / 255.,
+          //   r: 1.0,
+          //   g: 1.0,
+          //   b: 1.0,
+          //   a: 1.0,
+          // }),
+          load: LoadOp::Load,
+          ..Default::default()
+        },
+      })],
+      depth_stencil_attachment: Some(RenderPassDepthStencilAttachment {
+        view: &self.depth_texture.create_view(&Default::default()),
+        depth_ops: Some(Operations {
+          load: LoadOp::Clear(1.0),
+          store: StoreOp::Store,
+        }),
+        stencil_ops: None,
+      }),
+      ..Default::default()
+    });
+
+    self.render_layer(engine, &mut pass, &self.world_vms, 0);
+    self.render_layer(engine, &mut pass, &self.world_vms, 1);
+    self.render_layer(engine, &mut pass, &self.world_vms, 2);
+    self.render_layer(engine, &mut pass, &self.world_vms, 3);
+    self.render_layer(engine, &mut pass, &self.world_vms, 8);
+
   }
 
   fn clear(&self, encoder: &mut wgpu::CommandEncoder, surface: &wgpu::Texture) {
@@ -434,6 +478,7 @@ impl Manager {
 
   pub fn render(&self, engine: &Engine, surface: &wgpu::Texture, encoder: &mut wgpu::CommandEncoder) {
     self.clear(encoder, surface);
+    self.render_world(engine, encoder, surface);
     self.render_ui(engine, encoder, surface);
 
     if let Some(backbuffer_anm) = self.world_backbuffer_anm.upgrade() {

src/game/anm/vm/execute.rs

@@ -1,14 +1,17 @@
 use glam::{Vec2, Vec3};
+use instructions::{
+  anm::{Instruction, Op, PrimOp, PrimSetOp},
+  Param,
+};
 use num_traits::{FloatConst, FromPrimitive};
 use rand::Rng;
 
 use crate::{
-  game::{anm::{manager::ManagerUpdate, VmLocation}, param::Param}, interp::Mode
+  game::anm::{manager::ManagerUpdate, VmLocation},
+  interp::Mode,
 };
 
-use super::{
+use super::AnmVm;
-  opcodes::{Instruction, Op, PrimOp, PrimSetOp}, AnmVm
-};
 
 impl AnmVm {
   fn next_instruction(&mut self) -> Option<Instruction> {
@@ -104,7 +107,9 @@ impl AnmVm {
   }
 
   pub fn interrupt(&mut self, interrupt_id: u32) {
-    self.pending_interrupt = Some(interrupt_id);
+    if self.script.interrupts.contains_key(&interrupt_id) {
+      self.pending_interrupt = Some(interrupt_id);
+    }
 
     for ele in self.children.iter() {
       ele.borrow_mut().interrupt(interrupt_id);
@@ -115,7 +120,7 @@ impl AnmVm {
     if let Some((int_pc, int_time)) =
       self.pending_interrupt.take().and_then(|int| self.script.interrupts.get(&int).cloned())
     {
-      self.interrupt_return = Some((self.pc, self.time));
+      self.interrupt_return.replace((self.pc, self.time));
       self.pc = int_pc;
       self.time = Default::default();
       self.time.set_time(int_time)
@@ -124,6 +129,7 @@ impl AnmVm {
 
   fn return_from_interrupt(&mut self) {
     if let Some((pc, time)) = self.interrupt_return.take() {
+      println!("returned");
       self.pc = pc;
       self.time.set_time(time.time());
     }
@@ -313,26 +319,27 @@ impl AnmVm {
           self.sprite_mode = mode;
         }
         Op::Layer { layer } => self.layer = layer as u32,
+        Op::ZWriteDisable(value) => self.zwrite_disable = value,
         Op::Wait { time } => self.time.wait(time as u32),
-        Op::CaseReturn => {
+        Op::ReturnFromInterrupt => {
           self.return_from_interrupt();
         }
         Op::UnknownBitflag { .. } => {}
         Op::RandMode { mode } => self.random_mode = mode,
-        Op::ScriptNew { script } => {
+        Op::NewChildBack { script } => {
           self.children.push(manager.new_vm(self.file.clone(), script as usize, VmLocation::new_child(self.layer)));
         }
-        Op::ScriptNewUI { script } => {
+        Op::NewChildUIBack { script } => {
           self.children.push(manager.new_vm(self.file.clone(), script as usize, VmLocation::new_child_ui(self.layer)));
         }
-        Op::ScriptNewFront { script } => {
+        Op::NewChildFront { script } => {
           self.children.push(manager.new_vm(
             self.file.clone(),
             script as usize,
             VmLocation::new_child_front(self.layer),
           ));
         }
-        Op::ScriptNewUIFront { script } => {
+        Op::NewChildUIFront { script } => {
           self.children.push(manager.new_vm(
             self.file.clone(),
             script as usize,

src/game/anm/vm/mod.rs

@@ -2,17 +2,21 @@ use std::sync::Arc;
 
 use atomic_refcell::AtomicRefCell;
 use glam::{Quat, Vec2, Vec3};
-use opcodes::SpriteType;
+use instructions::anm::SpriteType;
 use wgpu::{BlendComponent, BlendFactor, BlendOperation, BlendState, Buffer, RenderPipeline};
 
-use crate::{game::timer::Timer, interp::{FloatInterpolator, Vec2Interpolator, Vec3Interpolator}};
+use crate::{
+  game::timer::Timer,
+  interp::{FloatInterpolator, Vec2Interpolator, Vec3Interpolator},
+};
 
 use super::{
-  loaded_file::{LoadedEntry, LoadedFile, LoadedScript, LoadedSprite}, manager::ManagerUpdate, Vm
+  loaded_file::{LoadedEntry, LoadedFile, LoadedScript, LoadedSprite},
+  manager::ManagerUpdate,
+  Vm,
 };
 
 pub mod execute;
-pub(super) mod opcodes;
 
 pub(super) struct RenderingState {
   pub instance_buffer: Buffer,
@@ -48,6 +52,7 @@ pub struct AnmVm {
   pub(super) visible: bool,
   pub(super) sprite: Option<u32>,
   pub(super) layer: u32,
+  pub(super) zwrite_disable: bool,
   random_mode: i32,
   sprite_mode: SpriteType,
   pub(super) blend_state: BlendState,
@@ -87,6 +92,7 @@ impl AnmVm {
       visible: true,
       sprite: None,
       layer: default_layer,
+      zwrite_disable: false,
       sprite_mode: SpriteType::NoRotate,
       blend_state: BlendState::REPLACE,
       random_mode: 0,
@@ -123,6 +129,14 @@ impl AnmVm {
     self.debug = true;
   }
 
+  pub fn child(&self, index: usize) -> Option<&Vm> {
+    self.children.get(index)
+  }
+
+  pub fn file(&self) -> &Arc<LoadedFile> {
+    &self.file
+  }
+
   pub fn scale(&self) -> Vec2 {
     self.scale_interpolator.current()
   }
@@ -210,7 +224,7 @@ impl AnmVm {
         // additive blending
         color: BlendComponent {
           src_factor: BlendFactor::SrcAlpha,
-          dst_factor: BlendFactor::OneMinusSrcAlpha,
+          dst_factor: BlendFactor::One,
           operation: BlendOperation::Add,
         },
         alpha: BlendComponent::OVER,

src/game/enemy/manager.rs

@@ -1,4 +0,0 @@
-pub struct Manager {
-  
-  
-}

src/game/enemy/mod.rs

@@ -1,3 +0,0 @@
-pub mod loaded_file;
-pub mod manager;
-pub mod vm;

src/game/enemy/vm/opcodes.rs

@@ -1,343 +0,0 @@
-use macros::decode_args;
-use num_derive::FromPrimitive;
-use num_traits::FromPrimitive;
-use truth::llir::RawInstr;
-use wgpu::naga::FastHashMap;
-
-use crate::game::param::Param;
-
-#[derive(Debug, FromPrimitive, Clone, Copy)]
-enum Opcode {
-  Nop = 0,
-
-  // control flow
-  Delete = 1,
-  Ret = 10,
-  Call = 11,
-  Jump = 12,
-  JumpEq = 13,
-  JumpNeq = 14,
-  CallAsync = 15,
-  CallAsyncById = 16,
-  KillAsync = 17,
-  KillAllAsync = 21,
-
-  // stack math
-  StackAlloc = 40,
-  PushInt = 42,
-  SetInt = 43,
-  PushFloat = 44,
-  SetFloat = 45,
-  AddInt = 50,
-  AddFloat = 51,
-  SubInt = 52,
-  SubFloat = 53,
-  MulInt = 54,
-  MulFloat = 55,
-  DivInt = 56,
-  DivFloat = 57,
-  ModInt = 58,
-  EqualInt = 59,
-  EqualFloat = 60,
-  NotEqualInt = 61,
-  NotEqualFloat = 62,
-  LessInt = 63,
-  LessFloat = 64,
-  LessEqualInt = 65,
-  LessEqualFloat = 66,
-  GreaterInt = 67,
-  GreaterFloat = 68,
-  GreaterEqualInt = 69,
-  GreaterEqualFloat = 70,
-  NotInt = 71,
-  NotFloat = 72,
-  LogicalOr = 73,
-  LogicalAnd = 74,
-  BitwiseXor = 75,
-  BitwiseOr = 76,
-  BitwiseAnd = 77,
-  DecrementInt = 78,
-  Sin = 79,
-  Cos = 80,
-  CirclePos = 81,
-  ValidRad = 82,
-  Wait = 83,
-  NegateInt = 84,
-  NegateFloat = 85,
-  SquareSum = 86,
-  GetAngle = 87,
-  SquareRoot = 88,
-  Linear = 89,
-  PointRotate = 90,
-  FloatTime = 91,
-  Math92 = 92,
-  Math93 = 93,
-
-  EnemyCreate = 256,
-  EnemyCreateAbsolute = 257,
-  EnemySelectAnm = 258,
-  EnemySetAnmSprite = 259,
-  EnemyCreateMirrored = 260,
-  EnemyCreateMirroredAbsolute = 261,
-  EnemySetMainAnm = 262,
-  EnemyPlayAnm = 263,
-  EnemyPlayAnmAbsolute = 264,
-  EnemyCreateFiller = 265,
-  EnemyCreateFillerAbsolute = 266,
-  EnemyCreateFillerMirrored = 267,
-  EnemyCreateFillerMirroredAbsolute = 268,
-  EnemyPlaySelected = 269,
-  EnemySwitchAnm = 275,
-  EnemyResetAnm = 276,
-  EnemyInst277 = 277,
-  EnemyInst278 = 278,
-
-  MovePos = 280,
-  MovePosTime = 281,
-  MovePosRel = 282,
-  MovePosRelTime = 283,
-  MoveVel = 284,
-  MoveVelTime = 285,
-  MoveVelRel = 286,
-  MoveVelRelTime = 287,
-  MoveCircle = 288,
-  MoveCircleTime = 289,
-  MoveCircleRel = 290,
-  MoveCircleRelTime = 291,
-  MoveRand = 292,
-  MoveRandRel = 293,
-  MoveAdd = 294,
-  MoveAddRel = 295,
-  MoveEllipse = 300,
-  MoveEllipseRel = 301,
-  MoveBezier = 305,
-  MoveReset = 307,
-
-  SetHurtbox = 320,
-  SetHitbox = 321,
-  FlagSet = 322,
-  FlagClear = 323,
-  Movelimit = 324,
-  MoveLimitReset = 325,
-  ClearExtraDrops = 326,
-  AddExtraDrops = 327,
-  SetDropArea = 328,
-  DropItems = 329,
-  SetMainDrop = 330,
-  SetHealth = 331,
-  SetBoss = 332,
-  TimerReset = 333,
-  SetInterrupt = 334,
-  SetInvulnerable = 335,
-  PlaySound = 336,
-  ShakeScreen = 337,
-  StartDialogue = 338,
-  WaitForDialogue = 339,
-  WaitForDeath = 340,
-  SetTimeout = 341,
-  SpellById = 342,
-  EndSpell = 343,
-  SetChapter = 344,
-  KillAllEnemies = 345,
-  ProtectPlayer = 346,
-  LifeMarker = 347,
-  SetByDifficultyInt = 355,
-  SetByDifficultyFloat = 356,
-  SpellDifficulty = 357,
-  SpellDifficultyM1 = 358,
-  SpellDifficultyM2 = 359,
-
-  SpawnerReset = 400,
-  SpawnerEnable = 401,
-  SpawnerSetSprite = 402,
-  SpawnerSetOffset = 403,
-  SpawnerSetAngle = 404,
-  SpawnerSetSpeed = 405,
-  SpawnerSetCount = 406,
-  SpawnerSetAimMode = 407,
-  SpawnerSetSounds,
-  SpawnerSet,
-  SpawnerSetTransformation,
-  SpawnerSetTransformation2,
-  SpawnerAddTransformation,
-  SpawnerAddTransformation2,
-  ClearAllBullets,
-  SpawnerCopy,
-  ShootLaserAimed,
-  CancelBullets,
-}
-
-pub enum PrimOp {
-  Add,
-  Sub,
-  Mul,
-  Div,
-  Equal,
-  NotEqual,
-  LessThan,
-  LessEqual,
-  Greater,
-  GreaterEqual,
-  Not,
-  Negate,
-}
-
-pub enum Op {
-  Nop,
-  Delete,
-  Return,
-  Jump {
-    index: usize,
-    time: i32,
-  },
-  JumpEqual {
-    index: usize,
-    time: i32,
-  },
-  JumpNotEqual {
-    index: usize,
-    time: i32,
-  },
-  CallAsync(String),
-  CallAsyncId(String, u32),
-  StackAlloc(usize),
-  PushInt(Param<i32>),
-  SetInt(i32),
-  PushFloat(Param<f32>),
-  SetFloat(i32),
-  IntOp(PrimOp),
-  ModuloInt,
-  FloatOp(PrimOp),
-  Or,
-  And,
-  BitwiseXor,
-  BitwiseOr,
-  BitwiseAnd,
-  DecrementInt(i32),
-  Sin,
-  Cos,
-  CirclePos {
-    x: f32,
-    y: f32,
-    angle: Param<f32>,
-    radius: Param<f32>,
-  },
-
-  SetFlag(i32),
-  ClearFlag(i32),
-
-  ClearAllBullets,
-  CancelBullets(i32),
-}
-
-pub struct Instruction {
-  time: i32,
-  difficulty: u8,
-  op: Op,
-}
-
-impl Instruction {
-  pub fn from_raw(inst: RawInstr, instruction_offsets: &FastHashMap<u32, usize>) -> Self {
-    let param_int = |value: i32, index: u16| {
-      if inst.param_mask & (1 << index) == 0 {
-        Param::Value(value)
-      } else if value < -9932 || value > 10000 {
-        Param::Value(value)
-      } else {
-        Param::Variable(value)
-      }
-    };
-    let param_float = |value: f32, index: u16| {
-      if inst.param_mask & (1 << index) == 0 {
-        Param::Value(value)
-      } else if value != value.trunc() && value < -9932. || value > 10000. {
-        Param::Value(value)
-      } else {
-        Param::Variable(value as i32)
-      }
-    };
-    let var_int = |value: i32, index: u16| {
-      assert!(inst.param_mask & (1 << index) != 0, "param must be a var");
-      assert!(value >= -9932 && value <= 10000, "value must be a var");
-      value
-    };
-    let var_float = |value: f32, index: u16| {
-      assert!(inst.param_mask & (1 << index) != 0, "param must be a var");
-      assert!(
-        value.trunc() == value && value >= -9932. && value <= 10000.,
-        "value must be a var"
-      );
-      value as i32
-    };
-    let offset_to_index = |value: i32| instruction_offsets[&(value as u32)];
-
-    let args = &inst.args_blob;
-    let opcode_raw = inst.opcode;
-    let opcode = Opcode::from_u16(opcode_raw).unwrap_or_else(|| todo!("failed to convert opcode {opcode_raw}"));
-    let op = match opcode {
-      Opcode::Nop => Op::Nop,
-      Opcode::Delete => todo!(),
-      Opcode::Ret => todo!(),
-      Opcode::Call => todo!(),
-      Opcode::Jump => {
-        let (offset, time) = decode_args!(args, "ot");
-
-        Op::Jump {
-          index: offset_to_index(offset),
-          time,
-        }
-      }
-      Opcode::JumpEq => {
-        let (offset, time) = decode_args!(args, "ot");
-
-        Op::JumpEqual {
-          index: offset_to_index(offset),
-          time,
-        }
-      }
-      Opcode::JumpNeq => {
-        let (offset, time) = decode_args!(args, "ot");
-
-        Op::JumpNotEqual {
-          index: offset_to_index(offset),
-          time,
-        }
-      }
-      Opcode::CallAsync => todo!(),
-      Opcode::CallAsyncById => todo!(),
-      Opcode::KillAsync => todo!(),
-      Opcode::KillAllAsync => todo!(),
-      Opcode::StackAlloc => Op::StackAlloc(decode_args!(args, "S") as usize),
-      Opcode::PushInt => todo!(),
-      Opcode::SetInt => todo!(),
-      Opcode::PushFloat => {
-        let float = decode_args!(args, "f");
-        Op::PushFloat(param_float(float, 0))
-      }
-      Opcode::SetFloat => {
-        let var = decode_args!(args, "f");
-        Op::SetFloat(var_float(var, 0))
-      }
-      Opcode::FlagSet => {
-        let flag = decode_args!(args, "S");
-        Op::SetFlag(flag)
-      }
-      Opcode::FlagClear => {
-        let flag = decode_args!(args, "S");
-        Op::ClearFlag(flag)
-      }
-      Opcode::CancelBullets => {
-        todo!()
-      }
-      _ => {
-        unimplemented!("opcode {opcode:?} not implemented");
-      }
-    };
-
-    Self {
-      time: inst.time,
-      difficulty: inst.difficulty,
-      op,
-    }
-  }
-}

src/game/mod.rs

@@ -1,4 +1,4 @@
-use std::{path::Path, sync::Arc};
+use std::sync::Arc;
 
 use anm::LoadedFile;
 use states::GameStateMachine;
@@ -9,8 +9,7 @@ use crate::{
 };
 
 mod anm;
-mod enemy;
+mod stage;
-mod param;
 mod snd;
 mod states;
 mod timer;
@@ -30,8 +29,8 @@ struct GameContext<'a> {
 impl GameContext<'_> {
   pub fn start_load_anm(&mut self, game: Game, file_name: impl Into<String>) -> Soon<Arc<LoadedFile>> {
     self.anm_manager.start_load_anm(
-      self.engine.device.clone(),
+      self.engine.device,
-      self.engine.queue.clone(),
+      self.engine.queue,
       self.engine.window.inner_size(),
       game,
       file_name,
@@ -40,9 +39,9 @@ impl GameContext<'_> {
 
   pub fn load_anm(&mut self, game: Game, file_name: impl Into<String>) -> Arc<LoadedFile> {
     self.anm_manager.load_anm(
-      &self.engine.device,
+      self.engine.device,
-      &self.engine.queue,
+      self.engine.queue,
-      &self.engine.window,
+      self.engine.window,
       game,
       file_name,
     )

src/game/snd/bgm/format.rs

@@ -52,7 +52,7 @@ impl BgmFormat {
       }
 
       let track_name = track_name.to_str().unwrap().to_owned();
-      println!("track: {:?}", track_name);
+      println!("track {track_name}");
       let track = Track::ref_from_bytes(&bytes[(start + TRACK_NAME_SIZE)..(start + TRACK_SIZE)]).unwrap();
       tracks.insert(
         track_name,
@@ -70,7 +70,9 @@ impl BgmFormat {
   }
 
   pub fn get_track_buffers(&mut self, file_name: &str) -> (Range<usize>, Range<usize>) {
-    let track = self.tracks.get(file_name).expect("failed to find bgm file");
+    let Some(track) = self.tracks.get(file_name) else {
+      panic!("failed to find bgm file: {file_name:?}")
+    };
 
     let intro_start = track.track_offset as usize;
     let track_start = intro_start + track.intro_size as usize;

src/game/snd/bgm/mod.rs

@@ -1,4 +1,4 @@
-use std::{rc::Rc, sync::Arc};
+use std::sync::Arc;
 
 use async_std::fs::read;
 use format::BgmFormat;

src/game/stage/enemy/execute.rs

@@ -0,0 +1,6 @@
+use super::Vm;
+
+impl Vm {
+  pub fn execute(&mut self) {
+  }
+}

src/game/stage/enemy/flags.rs

@@ -7,11 +7,12 @@ pub struct Flags {
   pub disable_offscreen_horizontal: bool,
   pub disable_offscreen_vertical: bool,
   pub invincible: bool,
-  pub intangible: bool,
+  pub intangible: bool, // override: disable_hurtbox | disable_hitbox | invincible | no_global_delete
   pub no_global_delete: bool,
   pub always_global_delete: bool,
   pub graze: bool,
   pub only_delete_on_dialog: bool,
-  #[bits(22)]
+  pub only_delete_on_clear: bool,
+  #[bits(21)]
   _a: u32,
 }

src/game/stage/enemy/loaded_file.rs

@@ -1,4 +1,4 @@
-use std::{io::Cursor, path::Path, sync::Arc};
+use std::{io::Cursor, sync::Arc};
 
 use async_std::fs;
 use futures::future::{join3, join_all};
@@ -8,7 +8,7 @@ use winit::dpi::PhysicalSize;
 
 use crate::{game::anm, utils::game::Game};
 
-use super::vm::opcodes::Instruction;
+use instructions::ecl::Instruction;
 
 pub struct LoadedFile {
   anm_files: Vec<anm::LoadedFile>,
@@ -35,30 +35,41 @@ impl LoadedFile {
     )
     .unwrap();
 
-    let anm_files = join_all(file.anim_list.into_iter().map(|sp| sp.value).map(|anm| {
+    let anm_files = join_all(
-      let (device, queue) = (device.clone(), queue.clone());
+      file
-      async move { anm::LoadedFile::load(&device, &queue, size, game, &anm).await }
+        .anim_list
-    }));
+        .into_iter()
-    let ecl_files = join_all(file.ecli_list.into_iter().map(|sp| sp.value).map(|ecl| {
+        .map(|sp| sp.value)
-      let (device, queue) = (device.clone(), queue.clone());
+        .map(|anm| async_std::task::spawn(anm::LoadedFile::load(device.clone(), queue.clone(), size, game, anm))),
-      async move { LoadedFile::load(device, queue, size, game, ecl).await }
+    );
-    }));
+    let ecl_files = join_all(
+      file
+        .ecli_list
+        .into_iter()
+        .map(|sp| sp.value)
+        .map(|ecl| LoadedFile::load(device.clone(), queue.clone(), size, game, ecl)),
+    );
 
     let subs = file.subs.into_iter().map(|(k, v)| (k.value, v)).collect::<Vec<_>>();
     let subs = async_std::task::spawn_blocking(|| {
       subs
         .into_iter()
         .map(|(sub, instructions)| {
-          let mut offset_instructions: FastHashMap<_, _> = Default::default();
+          let mut offset_instructions: Vec<(_, _)> = Default::default();
           let mut current_offset = 0;
           for (index, inst) in instructions.iter().enumerate() {
-            offset_instructions.insert(current_offset, index);
+            offset_instructions.push((current_offset, index));
-            current_offset += 8 + inst.args_blob.len() as u32
+            current_offset += 16 + inst.args_blob.len() as u32
           }
 
+          println!("hitting {sub}");
           (
             sub,
-            instructions.into_iter().map(|inst| Instruction::from_raw(inst, &offset_instructions)).collect::<Vec<_>>(),
+            instructions
+              .into_iter()
+              .zip(offset_instructions.iter())
+              .map(|(inst, (offset, _))| Instruction::from_raw(inst, *offset, &offset_instructions))
+              .collect::<Vec<_>>(),
           )
         })
         .collect::<FastHashMap<_, _>>()

src/game/stage/enemy/mod.rs

@@ -1,7 +1,8 @@
 use crate::game::timer::Timer;
 
+pub mod loaded_file;
 mod flags;
-pub(super) mod opcodes;
+mod execute;
 
 struct StackFrame {
   pc: usize,
@@ -17,4 +18,6 @@ enum Value {
 pub struct Vm {
   call_stack: heapless::Vec<StackFrame, 8>,
   current_frame: StackFrame,
+
+  
 }

src/game/stage/mod.rs

@@ -0,0 +1,71 @@
+use std::{cell::RefCell, rc::Rc};
+
+use vm::{LoadedFile, StageVm};
+
+use crate::utils::game::Game;
+
+use super::GameContext;
+
+mod enemy;
+mod vm;
+
+#[derive(Debug, Clone, Copy)]
+pub enum StageNumber {
+  Stage1 = 1,
+  Stage2 = 2,
+  Stage3 = 3,
+  Stage4 = 4,
+  Stage5 = 5,
+  Stage6 = 6,
+  Extra = 7,
+}
+
+impl StageNumber {
+  pub fn next(&self) -> Option<Self> {
+    match self {
+      Self::Stage1 => Some(Self::Stage2),
+      Self::Stage2 => Some(Self::Stage3),
+      Self::Stage3 => Some(Self::Stage4),
+      Self::Stage4 => Some(Self::Stage5),
+      Self::Stage5 => Some(Self::Stage6),
+      Self::Stage6 => None,
+      Self::Extra => None,
+    }
+  }
+
+  pub fn stage_music(&self, game: Game, boss: bool) -> &'static str {
+    match (self, game, boss) {
+      (Self::Stage1, Game::Mof, false) => "th10_00.wav",
+      (Self::Stage1, Game::Mof, true) => "th10_01.wav",
+      _ => todo!()
+    }
+  }
+}
+
+pub struct Stage {
+  vm: StageVm,
+  enemies: Vec<Rc<RefCell<enemy::Vm>>>,
+  game: Game,
+  stage_number: StageNumber,
+}
+
+impl Stage {
+  pub async fn new(context: &mut GameContext<'_>, game: Game, stage_number: StageNumber) -> Self {
+    let file = LoadedFile::load(context, game, format!("stage0{}.std", stage_number as u8)).await;
+
+    Self {
+      vm: StageVm::new(file),
+      enemies: vec![],
+      game,
+      stage_number,
+    }
+  }
+
+  pub fn started(&mut self, context: &mut GameContext) {
+    context.sound_manager.get_bgm_manager(self.game).play_track(self.stage_number.stage_music(self.game, false));
+  }
+
+  pub fn update(&mut self, context: &mut GameContext) {
+    self.vm.update(context);
+  }
+}

src/game/stage/vm/loaded_file.rs

@@ -0,0 +1,58 @@
+use std::io::Cursor;
+
+use async_std::fs;
+use instructions::std::Instruction;
+use truth::{context::RootEmitter, io::BinReader, std::StdExtra, Game as TruthGame, StdFile};
+use wgpu::naga::FastHashMap;
+
+use crate::{
+  game::{
+    anm::{self, Vm, VmLocation},
+    GameContext,
+  },
+  utils::game::Game,
+};
+
+pub struct LoadedFile {
+  pub layers: FastHashMap<u16, Vec<Vm>>,
+  pub instructions: Vec<instructions::std::Instruction>,
+}
+
+impl LoadedFile {
+  pub async fn load(context: &mut GameContext<'_>, game: Game, file_name: impl Into<String> + Send) -> LoadedFile {
+    let file_name = file_name.into();
+    let file_data = fs::read(game.asset_path(&file_name)).await.expect("failed to load anm file");
+    let file = StdFile::read_from_stream(
+      &mut BinReader::from_reader(&RootEmitter::new_stderr(), &file_name, Cursor::new(file_data)),
+      match game {
+        Game::Mof => TruthGame::Th10,
+        Game::Sa => TruthGame::Th11,
+      },
+    )
+    .unwrap();
+    let StdExtra::Th10 { anm_path } = file.extra else {
+      unreachable!()
+    };
+    let anm_file = context.start_load_anm(game, anm_path.value).await;
+
+    let mut layers: FastHashMap<u16, Vec<Vm>> = FastHashMap::default();
+
+    for instance in file.instances {
+      let object = file.objects.get(&instance.object).expect("failed to get object");
+      for quad in &object.quads {
+        let vm = context.anm_manager.new_vm(anm_file.clone(), None, quad.anm_script.into(), VmLocation::new());
+        layers.entry(object.layer).or_default().push(vm);
+      }
+    }
+    let mut offset_instructions: Vec<(_, _)> = Default::default();
+    let mut current_offset = 0;
+    for (index, inst) in file.script.iter().enumerate() {
+      offset_instructions.push((current_offset, index));
+      current_offset += 8 + inst.args_blob.len() as u32
+    }
+
+    let instructions =
+      file.script.into_iter().map(|inst| Instruction::from_raw(inst, &offset_instructions)).collect::<Vec<_>>();
+    LoadedFile { layers, instructions }
+  }
+}

src/game/stage/vm/mod.rs

@@ -0,0 +1,27 @@
+pub use loaded_file::LoadedFile;
+
+use crate::game::{timer::Timer, GameContext};
+
+mod loaded_file;
+
+pub struct StageVm {
+  pub file: LoadedFile,
+  pc: usize,
+  timer: Timer,
+}
+
+impl StageVm {
+  pub fn new(file: LoadedFile) -> Self {
+    Self {
+      file,
+      pc: 0,
+      timer: Timer::default()
+    }
+  }
+
+  pub fn update(&mut self, context: &mut GameContext) {
+    self.timer.tick();
+
+    
+  }
+}

src/game/states/gameplay/mod.rs

@@ -1,24 +1,47 @@
-use async_std::task::{block_on, spawn};
+use async_std::task::block_on;
 use sfsm::State;
 
 use crate::{
-  game::{enemy::loaded_file::LoadedFile, GameContext},
+  game::{
+    stage::{Stage, StageNumber},
+    GameContext,
+  },
   utils::game::Game,
 };
 
-pub struct Gameplay {}
+use super::{loading::Loading, title_mof::TitleScreenMof, UPDATE_CONTEXT};
+
+pub struct Gameplay {
+  stage: Stage,
+}
 
 impl Gameplay {
-  pub fn new(context: &GameContext) -> Self {
+  pub fn new_blocking(context: &mut GameContext<'_>, game: Game, stage_number: StageNumber) -> Self {
-    block_on(LoadedFile::load(
+    block_on(Self::new(context, game, stage_number))
-      context.engine.device.clone(),
+  }
-      context.engine.queue.clone(),
+  pub async fn new(context: &mut GameContext<'_>, game: Game, stage_number: StageNumber) -> Self {
-      context.engine.window.inner_size(),
+    let stage = Stage::new(context, game, stage_number).await;
-      Game::Sa,
+    Self { stage }
-      "default.ecl",
-    ));
-    Self {}
   }
 }
 
-impl State for Gameplay {}
+impl State for Gameplay {
+  fn entry(&mut self) {
+    UPDATE_CONTEXT.with(|context| self.stage.started(context));
+  }
+  fn execute(&mut self) {
+    UPDATE_CONTEXT.with(|context| self.stage.update(context));
+  }
+}
+
+impl From<Loading> for Gameplay {
+  fn from(_: Loading) -> Self {
+    UPDATE_CONTEXT.with(|context| Gameplay::new_blocking(context, Game::Mof, StageNumber::Stage1))
+  }
+}
+
+impl From<TitleScreenMof> for Gameplay {
+  fn from(_: TitleScreenMof) -> Self {
+    UPDATE_CONTEXT.with(|context| Gameplay::new_blocking(context, Game::Mof, StageNumber::Stage1))
+  }
+}

src/game/states/loading.rs

@@ -11,11 +11,12 @@ use crate::{
   utils::{game::Game, soon::Soon},
 };
 
-use super::{title::TitleScreen, UPDATE_CONTEXT};
+use super::{gameplay::Gameplay, title_mof::TitleScreenMof, title_sa::TitleScreenSa, UPDATE_CONTEXT};
 
 pub struct Loading {
   _sig: Vm,
   _ascii_loading: Vm,
+  to_gameplay: bool,
 
   title_anm: RefCell<Soon<Arc<LoadedFile>>>,
 }
@@ -31,27 +32,35 @@ impl Loading {
     Loading {
       _sig: sig,
       _ascii_loading: ascii_loading,
+      to_gameplay: true,
 
-      title_anm: context.start_load_anm(Game::Sa, "title.anm").into(),
+      title_anm: context.start_load_anm(Game::Mof, "title.anm").into(),
     }
   }
 }
 
-impl State for Loading {
+sfsm::derive_state!(Loading);
-  fn execute(&mut self) {
-    // if UPDATE_CONTEXT.with(|context| context.sound_manager.get_bgm_manager().is_some()) {
-    //   log::info!("a");
-    // }
-    // if self.title_anm.borrow_mut().is_done() {
-    //   log::info!("b")
-    // }
-  }
-}
 
-impl Transition<TitleScreen> for Loading {
+impl Transition<TitleScreenSa> for Loading {
   fn guard(&self) -> TransitGuard {
     UPDATE_CONTEXT
       .with(|context| context.sound_manager.is_bgm_manager_loaded() && self.title_anm.borrow_mut().is_done())
       .into()
   }
 }
+
+impl Transition<TitleScreenMof> for Loading {
+  fn guard(&self) -> TransitGuard {
+    UPDATE_CONTEXT
+      .with(|context|!self.to_gameplay && context.sound_manager.is_bgm_manager_loaded() && self.title_anm.borrow_mut().is_done())
+      .into()
+  }
+}
+
+impl Transition<Gameplay> for Loading {
+  fn guard(&self) -> TransitGuard {
+    UPDATE_CONTEXT
+      .with(|context| self.to_gameplay && context.sound_manager.is_bgm_manager_loaded() && self.title_anm.borrow_mut().is_done())
+      .into()
+  }
+}

src/game/states/mod.rs

@@ -1,21 +1,24 @@
 mod gameplay;
 mod loading;
-mod title;
+mod title_mof;
-
+mod title_sa;
-use gameplay::Gameplay;
-use sfsm::*;
 
 use crate::utils::context::ContextMut;
+use gameplay::Gameplay;
 use loading::Loading;
-use title::TitleScreen;
+use sfsm::*;
+use title_mof::TitleScreenMof;
+use title_sa::TitleScreenSa;
 
 use super::GameContext;
 
 pub(super) static UPDATE_CONTEXT: ContextMut<GameContext, GameStateMachine> = ContextMut::new();
 
-add_state_machine!(Machine, Loading, {Loading, TitleScreen, Gameplay}, {
+// add_state_machine!(Machine, Gameplay, {Loading, TitleScreen, Gameplay}, {
-  Loading => TitleScreen,
+add_state_machine!(Machine, Loading, {Loading, TitleScreenSa, TitleScreenMof, Gameplay}, {
-  TitleScreen => TitleScreen
+  Loading => TitleScreenMof,
+  Loading => Gameplay,
+  TitleScreenMof => Gameplay,
 });
 
 pub(super) struct GameStateMachine(Machine);

src/game/states/title_mof/main_menu.rs

@@ -0,0 +1,218 @@
+use sfsm::*;
+use winit::keyboard::KeyCode;
+
+use crate::{
+  game::{
+    anm::{Vm, VmLocation},
+    states::UPDATE_CONTEXT,
+  },
+  utils::game::Game,
+};
+
+pub struct MainMenu(MainMenuMachine);
+impl MainMenu {
+  pub fn new() -> MainMenu {
+    UPDATE_CONTEXT.with(|context| {
+      let title = context.load_anm(Game::Mof, "title.anm");
+      let title_ver = context.load_anm(Game::Mof, "title_v.anm");
+
+      let mut main_menu = MainMenu(MainMenuMachine::new());
+      main_menu
+        .0
+        .start(Boot {
+          logo: context.anm_manager.new_vm(title, None, 90, VmLocation::new_ui()),
+          title_ver: context.anm_manager.new_vm(title_ver, None, 0, VmLocation::new_ui()),
+        })
+        .unwrap();
+
+      main_menu
+    })
+  }
+
+  pub fn switch_to_gameplay(&self) -> bool {
+    sfsm::IsState::<StartingGameplay>::is_state(&self.0)
+  }
+}
+impl State for MainMenu {
+  fn execute(&mut self) {
+    self.0.step().unwrap();
+  }
+}
+
+add_state_machine!(MainMenuMachine, Boot, {Boot, Starting, Selecting, StartingGameplay, Exiting}, {
+  Boot => Starting,
+  Starting => Selecting,
+  Selecting => StartingGameplay,
+  Selecting => Exiting,
+});
+struct Boot {
+  logo: Vm,
+  title_ver: Vm,
+}
+impl State for Boot {
+  fn execute(&mut self) {
+    self.exit();
+    UPDATE_CONTEXT.with(|context| {
+      if context.engine.keys.is_any_key_down() {
+        self.logo.borrow_mut().interrupt(6);
+        self.title_ver.borrow_mut().interrupt(1);
+      }
+    });
+  }
+}
+
+impl Transition<Starting> for Boot {
+  fn guard(&self) -> TransitGuard {
+    self.title_ver.borrow_mut().deleted().into()
+  }
+}
+impl From<Boot> for Starting {
+  fn from(value: Boot) -> Self {
+    Starting {
+      logo: value.logo,
+      time_in_state: 0,
+    }
+  }
+}
+
+struct Starting {
+  logo: Vm,
+  time_in_state: u32,
+}
+impl State for Starting {
+  fn execute(&mut self) {
+    self.time_in_state += 1;
+  }
+}
+
+impl Transition<Selecting> for Starting {
+  fn guard(&self) -> TransitGuard {
+    (self.time_in_state >= 30).into()
+  }
+}
+impl From<Starting> for Selecting {
+  fn from(val: Starting) -> Self {
+    UPDATE_CONTEXT.with(|context| {
+      let file = val.logo.borrow().file().clone();
+      Selecting {
+        logo: val.logo,
+        main_ui: context.anm_manager.new_vm(file, None, 0, VmLocation::new_child_ui(0)),
+        selected: 0,
+        selection_changed: false,
+        input_locked: false,
+      }
+    })
+  }
+}
+
+struct Selecting {
+  logo: Vm,
+  main_ui: Vm,
+  selected: u32,
+  selection_changed: bool,
+  input_locked: bool,
+}
+impl Selecting {
+  fn selected(&self, desired: u32) -> TransitGuard {
+    (self.selected == desired && self.input_locked).into()
+  }
+}
+impl State for Selecting {
+  fn execute(&mut self) {
+    UPDATE_CONTEXT.with(|context| {
+      if self.input_locked {
+        return;
+      }
+      if context.engine.keys.was_key_pressed(KeyCode::ArrowUp) {
+        if let Some(prev) = self.selected.checked_sub(1) {
+          self.selected = prev;
+        } else {
+          self.selected = 7;
+        }
+        if self.selected == 1 {
+          self.selected = 0;
+        }
+
+        self.selection_changed = false;
+      }
+
+      if context.engine.keys.was_key_pressed(KeyCode::ArrowDown) {
+        if self.selected >= 7 {
+          self.selected = 0;
+        } else {
+          self.selected += 1;
+        }
+        if self.selected == 1 {
+          self.selected = 2;
+        }
+
+        self.selection_changed = false;
+      }
+
+      if context.engine.keys.was_key_pressed(KeyCode::KeyZ) {
+        self.main_ui.borrow_mut().interrupt(3);
+        self.input_locked = true;
+      }
+
+      if !self.selection_changed {
+        self.selection_changed = true;
+        let main_ui = self.main_ui.borrow_mut();
+        for i in 0..8u32 {
+          let child = main_ui.child(i as usize).unwrap();
+          let child_bg = main_ui.child(8 + i as usize).unwrap();
+          if i == self.selected {
+            child.borrow_mut().interrupt(i + 7);
+            child_bg.borrow_mut().interrupt(i + 7);
+          } else {
+            context.anm_manager.interrupt_immediately(&child, 3);
+            context.anm_manager.interrupt_immediately(&child_bg, 3);
+          }
+        }
+      }
+    });
+  }
+}
+
+#[derive(Default)]
+struct StartingGameplay;
+derive_state!(StartingGameplay);
+derive_transition_into_default!(Selecting, StartingGameplay);
+impl Transition<StartingGameplay> for Selecting {
+  fn guard(&self) -> TransitGuard {
+    self.selected(0)
+  }
+
+  fn action(&mut self) {
+    println!("agmlng")
+  }
+}
+
+impl Transition<Exiting> for Selecting {
+  fn guard(&self) -> TransitGuard {
+    self.selected(7)
+  }
+}
+impl From<Selecting> for Exiting {
+  fn from(value: Selecting) -> Self {
+    Exiting {
+      _logo: value.logo,
+      _main_ui: value.main_ui,
+      timer: 0,
+    }
+  }
+}
+
+struct Exiting {
+  _logo: Vm,
+  _main_ui: Vm,
+  timer: u32,
+}
+
+impl State for Exiting {
+  fn execute(&mut self) {
+    self.timer += 1;
+    if self.timer >= 20 {
+      UPDATE_CONTEXT.with(|context| context.engine.should_exit.set(true));
+    }
+  }
+}

src/game/states/title_mof/mod.rs

@@ -0,0 +1,72 @@
+mod main_menu;
+
+use std::sync::Arc;
+
+use main_menu::MainMenu;
+use sfsm::*;
+use winit::keyboard::KeyCode;
+
+use crate::{
+  game::{
+    anm::{LoadedFile, Vm, VmLocation},
+    GameContext,
+  },
+  utils::game::Game,
+};
+
+use super::{gameplay::Gameplay, loading::Loading, UPDATE_CONTEXT};
+
+pub struct TitleScreenMof {
+  _splash: Vm,
+  _title_anm: Arc<LoadedFile>,
+  machine: TitleScreenMachine,
+}
+
+add_state_machine!(TitleScreenMachine, MainMenu, { MainMenu }, {});
+
+impl TitleScreenMof {
+  fn new(context: &mut GameContext, _: bool) -> Self {
+    let title = context.load_anm(Game::Mof, "title.anm");
+
+    // 79, 83
+    let splash = context.anm_manager.new_vm(title.clone(), None, 88, VmLocation::new_ui());
+
+    Self {
+      _splash: splash,
+      _title_anm: title,
+      machine: TitleScreenMachine::new(),
+    }
+  }
+}
+
+impl State for TitleScreenMof {
+  fn entry(&mut self) {
+    self.machine.start(MainMenu::new()).unwrap();
+  }
+  fn execute(&mut self) {
+    self.machine.step().unwrap();
+  }
+}
+
+impl From<Loading> for TitleScreenMof {
+  fn from(_: Loading) -> Self {
+    UPDATE_CONTEXT.with(|context| {
+      context.sound_manager.get_bgm_manager(Game::Mof).play_track("th10_02.wav");
+      // context.sound_manager.get_bgm_manager(Game::Mof).play_track("th11_00.wav");
+      TitleScreenMof::new(context, true)
+    })
+  }
+}
+
+impl Transition<Gameplay> for TitleScreenMof {
+  fn guard(&self) -> TransitGuard {
+    match &self.machine.states {
+      TitleScreenMachineStates::MainMenuState(Some(main_menu)) => main_menu.switch_to_gameplay().into(),
+      _ => TransitGuard::Remain
+    }
+  }
+
+  fn action(&mut self) {
+    println!("hsttkasdgn")
+  }
+}

src/game/states/title_sa.rs

@@ -11,20 +11,18 @@ use crate::{
 
 use super::{loading::Loading, UPDATE_CONTEXT};
 
-pub struct TitleScreen {
+pub struct TitleScreenSa {
   _logo: Vm,
   _splash: Vm,
 }
 
-impl TitleScreen {
+impl TitleScreenSa {
   fn new(context: &mut GameContext, _: bool) -> Self {
-    let title = context.load_anm(Game::Mof, "title.anm");
+    let title = context.load_anm(Game::Sa, "title.anm");
 
     // 79, 83
-    // let splash = context.anm_manager.new_vm(title.clone(), Some(8), 79, VmLocation::new_ui());
+    let splash = context.anm_manager.new_vm(title.clone(), Some(8), 79, VmLocation::new_ui());
-    // let logo = context.anm_manager.new_vm(title.clone(), Some(8), 83, VmLocation::new_ui());
+    let logo = context.anm_manager.new_vm(title.clone(), Some(8), 83, VmLocation::new_ui());
-    let splash = context.anm_manager.new_vm(title.clone(), Some(8), 88, VmLocation::new_ui());
-    let logo = context.anm_manager.new_vm(title.clone(), Some(8), 90, VmLocation::new_ui());
 
     Self {
       _logo: logo,
@@ -33,7 +31,7 @@ impl TitleScreen {
   }
 }
 
-impl State for TitleScreen {
+impl State for TitleScreenSa {
   fn execute(&mut self) {
     UPDATE_CONTEXT.with(|context| {
       if context.engine.keys.was_key_pressed(KeyCode::Space) {
@@ -43,19 +41,19 @@ impl State for TitleScreen {
   }
 }
 
-impl From<Loading> for TitleScreen {
+impl From<Loading> for TitleScreenSa {
   fn from(_: Loading) -> Self {
     UPDATE_CONTEXT.with(|context| {
-      context.sound_manager.get_bgm_manager(Game::Mof).play_track("th10_02.wav");
+      // context.sound_manager.get_bgm_manager(Game::Mof).play_track("th10_02.wav");
-      // context.sound_manager.get_bgm_manager_sa().play_track("th11_00.wav");
+      context.sound_manager.get_bgm_manager(Game::Sa).play_track("th11_00.wav");
-      TitleScreen::new(context, true)
+      TitleScreenSa::new(context, true)
     })
   }
 }
 
-impl Transition<TitleScreen> for TitleScreen {
+impl Transition<TitleScreenSa> for TitleScreenSa {
   fn action(&mut self) {
-    *self = UPDATE_CONTEXT.with(|context| TitleScreen::new(context, false))
+    *self = UPDATE_CONTEXT.with(|context| TitleScreenSa::new(context, false))
   }
 
   fn guard(&self) -> TransitGuard {

src/main.rs

@@ -4,13 +4,19 @@ pub mod interp;
 pub mod utils;
 
 use std::{
-  sync::{Arc, Mutex}, time::Duration
+  ops::ControlFlow,
+  sync::Arc,
 };
 
 use engine::Engine;
 use wgpu::SurfaceError;
 use winit::{
-  application::ApplicationHandler, dpi::PhysicalSize, event::{ElementState, KeyEvent, StartCause, WindowEvent}, event_loop::EventLoop, keyboard::{KeyCode, PhysicalKey}, platform::pump_events::EventLoopExtPumpEvents, window::Window
+  application::ApplicationHandler,
+  dpi::PhysicalSize,
+  event::{ElementState, KeyEvent, StartCause, WindowEvent},
+  event_loop::EventLoop,
+  keyboard::{KeyCode, PhysicalKey},
+  window::Window,
 };
 
 #[derive(Default)]
@@ -73,8 +79,10 @@ impl<'a> ApplicationHandler for App<'a> {
         self.engine.as_mut().unwrap().resize(new_size);
       }
       WindowEvent::RedrawRequested => {
-        let mut engine = self.engine.as_mut().unwrap();
+        let engine = self.engine.as_mut().unwrap();
-        engine.update();
+        if let ControlFlow::Break(()) = engine.update() {
+          return event_loop.exit();
+        }
         match engine.render() {
           Ok(_) => {}
           Err(SurfaceError::Lost) => {

src/utils/context.rs

@@ -1,4 +1,4 @@
-use std::marker::PhantomData;
+use std::{cell::RefCell, ffi::c_void, marker::PhantomData, thread::LocalKey};
 
 #[doc(hidden)]
 #[derive(Default)]
@@ -12,9 +12,9 @@ impl<T, Key> ContextMut<T, Key> {
     ContextMut(PhantomData)
   }
 
-  fn thread_local() -> &'static std::thread::LocalKey<std::cell::RefCell<Option<*mut std::ffi::c_void>>> {
+  fn thread_local() -> &'static LocalKey<RefCell<Option<*mut c_void>>> {
     std::thread_local! {
-      static CTX: std::cell::RefCell<Option<*mut std::ffi::c_void>> = Default::default();
+      static CTX: RefCell<Option<*mut c_void>> = Default::default();
     }
 
     &CTX
@@ -54,9 +54,9 @@ impl<T, Key> Context<T, Key> {
     Context(PhantomData)
   }
 
-  fn thread_local() -> &'static std::thread::LocalKey<std::cell::RefCell<Option<*const std::ffi::c_void>>> {
+  fn thread_local() -> &'static LocalKey<RefCell<Option<*const c_void>>> {
     std::thread_local! {
-      static CTX: std::cell::RefCell<Option<*const std::ffi::c_void>> = Default::default();
+      static CTX: RefCell<Option<*const c_void>> = Default::default();
     }
 
     &CTX

utils/th10.eclm

@@ -649,7 +649,7 @@
 !ins_intrinsics
 #10 RetStack() ## Internally calls FrameLeave()
 #11 CallStack()
-12 Jmp()
+#12 Jmp()
 #13 StackJmp(op="==")
 #14 StackJmp(op="!=")
 #15 CallStackAsync()