print outliers

src/main.rs

@@ -1,5 +1,6 @@
 use strafesnet_roblox_bot_file::v0;
 
+use std::path::{Path,PathBuf};
 use futures::{StreamExt,TryStreamExt};
 
 #[expect(dead_code)]
@@ -8,7 +9,7 @@ enum Error{
 	InvalidArgs,
 	Io(std::io::Error),
 	BotFile{
-		path:std::path::PathBuf,
+		path:PathBuf,
 		err:v0::Error
 	},
 	Join(tokio::task::JoinError),
@@ -38,12 +39,37 @@ async fn main()->Result<(),Error>{
 		jumps:u64,
 		duration:u64,
 		settings:u64,
+		outliers:Vec<PathBuf>,
 	}
 	impl std::fmt::Display for FoldState{
 		fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
 			write!(f,"count={} jumps={} duration={} settings={}",self.count,self.jumps,self.duration as f64/(ONE_SECOND as f64),self.settings)
 		}
 	}
+	impl FoldState{
+		fn accumulate(&mut self,path:&Path,block:&v0::Block){
+			if let (Some(first),Some(last))=(block.output_events.first(),block.output_events.last()){
+				let last=last.time*(ONE_SECOND as f64);
+				let first=first.time*(ONE_SECOND as f64);
+				let duration=last as u64-first as u64;
+				if 30000<duration{
+					self.outliers.push(path.to_owned());
+					return;
+				}
+				self.duration+=duration;
+			}
+			self.count+=1;
+			self.jumps+=block.sound_events.iter()
+				.filter(|event|event.event.sound_type==v0::SoundType::JumpGround)
+				.count() as u64;
+			// find settings events after run has started
+			if let Some(run_start)=block.run_events.iter().find(|event|matches!(event.event,v0::RunEvent::Start(_))){
+				self.settings+=block.setting_events.iter()
+					.filter(|event|run_start.time<event.time)
+					.count() as u64;
+			}
+		}
+	}
 
 	let available_parallelism=std::thread::available_parallelism()?.get();
 	let read_dir=tokio::fs::read_dir(dir).await?;
@@ -64,24 +90,13 @@ async fn main()->Result<(),Error>{
 	})
 	.buffer_unordered(available_parallelism)
 	.try_fold(FoldState::default(),async|mut state,(path,block)|{
-		state.count+=1;
-		state.jumps+=block.sound_events.iter()
-			.filter(|event|event.event.sound_type==v0::SoundType::JumpGround)
-			.count() as u64;
-		if let (Some(first),Some(last))=(block.output_events.first(),block.output_events.last()){
-			let last=last.time*(ONE_SECOND as f64);
-			let first=first.time*(ONE_SECOND as f64);
-			state.duration+=last as u64-first as u64;
-		}
-		// find settings events after run has started
-		if let Some(run_start)=block.run_events.iter().find(|event|matches!(event.event,v0::RunEvent::Start(_))){
-			state.settings+=block.setting_events.iter()
-				.filter(|event|run_start.time<event.time)
-				.count() as u64;
-		}
+		state.accumulate(&path,&block);
 		println!("{:?} {}",path.file_name(),state);
 		Ok(state)
 	}).await?;
+	for path in &tally.outliers{
+		println!("outlier: {:?}",path.file_name());
+	}
 	println!("{}",tally);
 	Ok(())
 }