StrafesNET/roblox-bot-player
3
Fork 1
Code Issues 2 Pull Requests Actions Packages Projects Releases Wiki Activity

delete things

Browse Source
This commit is contained in:
Rhys Lloyd
2026-03-08 10:46:01 -07:00
parent fdcf2fc8a5
commit cb371c66a6
5 changed files with 7 additions and 247 deletions
Download Patch File Download Diff File Expand all files Collapse all files

68
video-encoder/src/app.rs
View File

@@ -1,68 +0,0 @@
use crate::window::Instruction;
use strafesnet_common::integer;
use strafesnet_common::instruction::TimedInstruction;
use crate::window::WindowContext;
pub struct App<'a>{
root_time:std::time::Instant,
window_thread:WindowContext<'a>,
}
impl<'a> App<'a>{
pub fn new(
root_time:std::time::Instant,
window_thread:WindowContext<'a>,
)->App<'a>{
Self{
root_time,
window_thread,
}
}
fn send_timed_instruction(&mut self,instruction:Instruction){
let time=integer::Time::from_nanos(self.root_time.elapsed().as_nanos() as i64);
self.window_thread.send(TimedInstruction{time,instruction});
}
}
impl winit::application::ApplicationHandler for App<'_>{
fn resumed(&mut self,_event_loop:&winit::event_loop::ActiveEventLoop){
//
}
fn window_event(
&mut self,
event_loop:&winit::event_loop::ActiveEventLoop,
_window_id:winit::window::WindowId,
event:winit::event::WindowEvent,
){
match event{
winit::event::WindowEvent::KeyboardInput{
event:winit::event::KeyEvent{
logical_key:winit::keyboard::Key::Named(winit::keyboard::NamedKey::Escape),
state:winit::event::ElementState::Pressed,
..
},
..
}
|winit::event::WindowEvent::CloseRequested=>{
event_loop.exit();
},
_=>(),
}
self.send_timed_instruction(Instruction::WindowEvent(event));
}
fn device_event(
&mut self,
_event_loop:&winit::event_loop::ActiveEventLoop,
_device_id:winit::event::DeviceId,
event:winit::event::DeviceEvent,
){
self.send_timed_instruction(Instruction::DeviceEvent(event));
}
fn about_to_wait(
&mut self,
_event_loop:&winit::event_loop::ActiveEventLoop
){
self.send_timed_instruction(Instruction::WindowEvent(winit::event::WindowEvent::RedrawRequested));
}
}

7
video-encoder/src/main.rs
View File

@@ -1,12 +1,7 @@
mod app;
mod file;
mod player;
mod setup;
mod window;
const TITLE:&'static str=concat!("Roblox Bot Player v",env!("CARGO_PKG_VERSION"));
fn main(){
pollster::block_on(setup::setup_and_start(TITLE));
pollster::block_on(setup::setup_and_start());
}

6
video-encoder/src/player.rs
View File

@@ -15,7 +15,7 @@ pub enum SessionControlInstruction{
pub enum Instruction{
SessionControl(SessionControlInstruction),
Render,
Resize(winit::dpi::PhysicalSize<u32>),
Resize(glam::UVec2),
ChangeMap(strafesnet_common::map::CompleteMap),
LoadReplay(strafesnet_roblox_bot_file::v0::Block),
}
@@ -81,8 +81,8 @@ impl<'a> PlayerWorker<'a>{
},
Instruction::Resize(physical_size)=>if let Some(playback)=&self.playback{
let fov_y=playback.playback_head.state().get_fov_y();
let fov_x=fov_y*physical_size.width as f64/physical_size.height as f64;
self.graphics_thread.resize(&self.surface,glam::uvec2(physical_size.width,physical_size.height),glam::vec2(fov_x as f32,fov_y as f32));
let fov_x=fov_y*physical_size.x as f64/physical_size.y as f64;
self.graphics_thread.resize(&self.surface,physical_size,glam::vec2(fov_x as f32,fov_y as f32));
},
Instruction::ChangeMap(complete_map)=>{
self.graphics_thread.change_map(&complete_map);

36
video-encoder/src/setup.rs
View File

@@ -1,16 +1,6 @@
use strafesnet_graphics::setup;
fn create_window(title:&str,event_loop:&winit::event_loop::EventLoop<()>)->Result<winit::window::Window,winit::error::OsError>{
let mut attr=winit::window::WindowAttributes::default();
attr=attr.with_title(title);
event_loop.create_window(attr)
}
pub async fn setup_and_start(title:&str){
let event_loop=winit::event_loop::EventLoop::new().unwrap();
let window=create_window(title,&event_loop).unwrap();
pub async fn setup_and_start(){
println!("Initializing the surface...");
let instance=setup::step1::create_instance();
@@ -24,28 +14,8 @@ pub async fn setup_and_start(title:&str){
let size=window.inner_size();
let config=setup::step5::configure_surface(&adapter,&device,&surface,(size.width,size.height)).unwrap();
//dedicated thread to ping request redraw back and resize the window doesn't seem logical
//the thread that spawns the physics thread
let mut window_thread=crate::window::WindowContext::new(
&window,
device,
queue,
surface,
config,
);
for arg in std::env::args().skip(1){
window_thread.send(strafesnet_common::instruction::TimedInstruction{
time:strafesnet_common::integer::Time::ZERO,
instruction:crate::window::Instruction::WindowEvent(winit::event::WindowEvent::DroppedFile(arg.into())),
});
};
// load files
println!("Entering event loop...");
let mut app=crate::app::App::new(
std::time::Instant::now(),
window_thread
);
event_loop.run_app(&mut app).unwrap();
// render frames here...
}

137
video-encoder/src/window.rs
View File

@@ -1,137 +0,0 @@
use strafesnet_common::instruction::TimedInstruction;
use strafesnet_common::session::Time as SessionTime;
use crate::file::LoadFormat;
use crate::player::{PlayerWorker,Instruction as PhysicsWorkerInstruction,SessionControlInstruction};
pub enum Instruction{
WindowEvent(winit::event::WindowEvent),
DeviceEvent(winit::event::DeviceEvent),
}
//holds thread handles to dispatch to
pub struct WindowContext<'a>{
simulation_paused:bool,
window:&'a winit::window::Window,
physics_thread:PlayerWorker<'a>,
}
impl WindowContext<'_>{
fn window_event(&mut self,time:SessionTime,event:winit::event::WindowEvent){
match event{
winit::event::WindowEvent::DroppedFile(path)=>{
match crate::file::load(path.as_path()){
Ok(LoadFormat::Map(map))=>self.physics_thread.send(TimedInstruction{time,instruction:PhysicsWorkerInstruction::ChangeMap(map)}),
Ok(LoadFormat::Bot(bot))=>self.physics_thread.send(TimedInstruction{time,instruction:PhysicsWorkerInstruction::LoadReplay(bot)}),
Err(e)=>println!("Failed to load file: {e}"),
}
},
winit::event::WindowEvent::Focused(state)=>{
// don't unpause if manually paused
if self.simulation_paused{
return;
}
//pause unpause
self.physics_thread.send(TimedInstruction{
time,
instruction:PhysicsWorkerInstruction::SessionControl(SessionControlInstruction::SetPaused(!state)),
});
//recalculate pressed keys on focus
},
winit::event::WindowEvent::KeyboardInput{
event:winit::event::KeyEvent{state,logical_key,repeat:false,..},
..
}=>{
match (logical_key,state){
(winit::keyboard::Key::Named(winit::keyboard::NamedKey::F11),winit::event::ElementState::Pressed)=>{
if self.window.fullscreen().is_some(){
self.window.set_fullscreen(None);
}else{
self.window.set_fullscreen(Some(winit::window::Fullscreen::Borderless(None)));
}
},
(keycode,state)=>{
let s=state.is_pressed();
macro_rules! session_ctrl{
($variant:ident,$state:expr)=>{
s.then_some(PhysicsWorkerInstruction::SessionControl(SessionControlInstruction::$variant))
};
}
if let Some(instruction)=match keycode{
winit::keyboard::Key::Named(winit::keyboard::NamedKey::Space)=>if s{
let paused=!self.simulation_paused;
self.simulation_paused=paused;
Some(PhysicsWorkerInstruction::SessionControl(SessionControlInstruction::SetPaused(paused)))
}else{None},
winit::keyboard::Key::Named(winit::keyboard::NamedKey::ArrowUp)=>session_ctrl!(IncreaseTimescale,s),
winit::keyboard::Key::Named(winit::keyboard::NamedKey::ArrowDown)=>session_ctrl!(DecreaseTimescale,s),
winit::keyboard::Key::Named(winit::keyboard::NamedKey::ArrowLeft)=>session_ctrl!(SkipBack,s),
winit::keyboard::Key::Named(winit::keyboard::NamedKey::ArrowRight)=>session_ctrl!(SkipForward,s),
winit::keyboard::Key::Character(key)=>match key.as_str(){
"R"|"r"=>session_ctrl!(Restart,s),
_=>None,
},
_=>None,
}{
self.physics_thread.send(TimedInstruction{
time,
instruction,
});
}
},
}
},
winit::event::WindowEvent::Resized(size)=>{
self.physics_thread.send(
TimedInstruction{
time,
instruction:PhysicsWorkerInstruction::Resize(size)
}
);
},
winit::event::WindowEvent::RedrawRequested=>{
self.window.request_redraw();
self.physics_thread.send(
TimedInstruction{
time,
instruction:PhysicsWorkerInstruction::Render
}
);
},
_=>(),
}
}
fn device_event(&mut self,_time:SessionTime,_event:winit::event::DeviceEvent){
}
pub fn send(&mut self,ins:TimedInstruction<Instruction,SessionTime>){
match ins.instruction{
Instruction::WindowEvent(window_event)=>{
self.window_event(ins.time,window_event);
},
Instruction::DeviceEvent(device_event)=>{
self.device_event(ins.time,device_event);
},
}
}
pub fn new<'a>(
window:&'a winit::window::Window,
device:wgpu::Device,
queue:wgpu::Queue,
surface:wgpu::Surface<'a>,
config:wgpu::SurfaceConfiguration,
)->WindowContext<'a>{
let graphics=strafesnet_roblox_bot_player::graphics::Graphics::new(device,queue,config);
WindowContext{
simulation_paused:false,
window,
physics_thread:crate::player::PlayerWorker::new(
surface,
graphics,
),
}
}
}