2255 lines
63 KiB
YAML
2255 lines
63 KiB
YAML
// WARNING: This output format is intended for human consumers only
|
|
// and is subject to change without notice. Knock yourself out.
|
|
fn main() -> () {
|
|
let mut _0: ();
|
|
let _1: winit::event_loop::EventLoop<()>;
|
|
let mut _2: std::result::Result<winit::event_loop::EventLoop<()>, winit::error::EventLoopError>;
|
|
let mut _4: std::result::Result<winit::window::Window, winit::error::OsError>;
|
|
let mut _5: winit::window::WindowBuilder;
|
|
let _6: &winit::event_loop::EventLoopWindowTarget<()>;
|
|
let _7: &winit::event_loop::EventLoop<()>;
|
|
let _8: ();
|
|
let _9: &winit::event_loop::EventLoopWindowTarget<()>;
|
|
let mut _10: &winit::event_loop::EventLoop<()>;
|
|
let mut _11: winit::event_loop::ControlFlow;
|
|
let _12: ();
|
|
let _13: &winit::event_loop::EventLoopWindowTarget<()>;
|
|
let mut _14: &winit::event_loop::EventLoop<()>;
|
|
let mut _15: winit::event_loop::ControlFlow;
|
|
let mut _17: std::result::Result<softbuffer::Context<winit::raw_window_handle::DisplayHandle<'_>>, softbuffer::SoftBufferError>;
|
|
let mut _18: winit::raw_window_handle::DisplayHandle<'_>;
|
|
let mut _19: std::result::Result<winit::raw_window_handle::DisplayHandle<'_>, winit::raw_window_handle::HandleError>;
|
|
let mut _20: &winit::window::Window;
|
|
let mut _22: std::result::Result<softbuffer::Surface<winit::raw_window_handle::DisplayHandle<'_>, winit::raw_window_handle::WindowHandle<'_>>, softbuffer::SoftBufferError>;
|
|
let _23: &softbuffer::Context<winit::raw_window_handle::DisplayHandle<'_>>;
|
|
let mut _24: winit::raw_window_handle::WindowHandle<'_>;
|
|
let mut _25: std::result::Result<winit::raw_window_handle::WindowHandle<'_>, winit::raw_window_handle::HandleError>;
|
|
let mut _26: &winit::window::Window;
|
|
let _28: ();
|
|
let mut _29: std::result::Result<(), winit::error::EventLoopError>;
|
|
let mut _30: winit::event_loop::EventLoop<()>;
|
|
let mut _31: {closure@src/main.rs:34:14: 34:27};
|
|
let mut _32: &winit::window::Window;
|
|
let mut _33: &mut softbuffer::Surface<winit::raw_window_handle::DisplayHandle<'_>, winit::raw_window_handle::WindowHandle<'_>>;
|
|
let mut _34: &mut game::GameState;
|
|
let mut _35: bool;
|
|
let mut _36: bool;
|
|
scope 1 {
|
|
debug event_loop => _1;
|
|
let _3: winit::window::Window;
|
|
scope 2 {
|
|
debug window => _3;
|
|
let _16: softbuffer::Context<winit::raw_window_handle::DisplayHandle<'_>>;
|
|
scope 3 {
|
|
debug context => _16;
|
|
let mut _21: softbuffer::Surface<winit::raw_window_handle::DisplayHandle<'_>, winit::raw_window_handle::WindowHandle<'_>>;
|
|
scope 4 {
|
|
debug surface => _21;
|
|
let mut _27: game::GameState;
|
|
scope 5 {
|
|
debug game => _27;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
bb0: {
|
|
_36 = const false;
|
|
_35 = const false;
|
|
_2 = EventLoop::<()>::new() -> [return: bb1, unwind continue];
|
|
}
|
|
|
|
bb1: {
|
|
_1 = Result::<EventLoop<()>, EventLoopError>::unwrap(move _2) -> [return: bb2, unwind continue];
|
|
}
|
|
|
|
bb2: {
|
|
_36 = const true;
|
|
_5 = WindowBuilder::new() -> [return: bb3, unwind: bb32];
|
|
}
|
|
|
|
bb3: {
|
|
_35 = const true;
|
|
_7 = &_1;
|
|
_6 = <EventLoop<()> as Deref>::deref(_7) -> [return: bb4, unwind: bb30];
|
|
}
|
|
|
|
bb4: {
|
|
_35 = const false;
|
|
_4 = WindowBuilder::build::<()>(move _5, _6) -> [return: bb5, unwind: bb30];
|
|
}
|
|
|
|
bb5: {
|
|
_35 = const false;
|
|
_3 = Result::<Window, winit::error::OsError>::unwrap(move _4) -> [return: bb6, unwind: bb32];
|
|
}
|
|
|
|
bb6: {
|
|
_10 = &_1;
|
|
_9 = <EventLoop<()> as Deref>::deref(move _10) -> [return: bb7, unwind: bb27];
|
|
}
|
|
|
|
bb7: {
|
|
_11 = winit::event_loop::ControlFlow::Poll;
|
|
_8 = EventLoopWindowTarget::<()>::set_control_flow(_9, move _11) -> [return: bb8, unwind: bb27];
|
|
}
|
|
|
|
bb8: {
|
|
_14 = &_1;
|
|
_13 = <EventLoop<()> as Deref>::deref(move _14) -> [return: bb9, unwind: bb27];
|
|
}
|
|
|
|
bb9: {
|
|
_15 = winit::event_loop::ControlFlow::Wait;
|
|
_12 = EventLoopWindowTarget::<()>::set_control_flow(_13, move _15) -> [return: bb10, unwind: bb27];
|
|
}
|
|
|
|
bb10: {
|
|
_20 = &_3;
|
|
_19 = <Window as HasDisplayHandle>::display_handle(move _20) -> [return: bb11, unwind: bb27];
|
|
}
|
|
|
|
bb11: {
|
|
_18 = Result::<DisplayHandle<'_>, HandleError>::unwrap(move _19) -> [return: bb12, unwind: bb27];
|
|
}
|
|
|
|
bb12: {
|
|
_17 = softbuffer::Context::<DisplayHandle<'_>>::new(move _18) -> [return: bb13, unwind: bb27];
|
|
}
|
|
|
|
bb13: {
|
|
_16 = Result::<softbuffer::Context<DisplayHandle<'_>>, SoftBufferError>::unwrap(move _17) -> [return: bb14, unwind: bb27];
|
|
}
|
|
|
|
bb14: {
|
|
_23 = &_16;
|
|
_26 = &_3;
|
|
_25 = <Window as HasWindowHandle>::window_handle(move _26) -> [return: bb15, unwind: bb26];
|
|
}
|
|
|
|
bb15: {
|
|
_24 = Result::<WindowHandle<'_>, HandleError>::unwrap(move _25) -> [return: bb16, unwind: bb26];
|
|
}
|
|
|
|
bb16: {
|
|
_22 = Surface::<DisplayHandle<'_>, WindowHandle<'_>>::new(_23, move _24) -> [return: bb17, unwind: bb26];
|
|
}
|
|
|
|
bb17: {
|
|
_21 = Result::<Surface<DisplayHandle<'_>, WindowHandle<'_>>, SoftBufferError>::unwrap(move _22) -> [return: bb18, unwind: bb26];
|
|
}
|
|
|
|
bb18: {
|
|
_27 = GameState::init() -> [return: bb19, unwind: bb25];
|
|
}
|
|
|
|
bb19: {
|
|
_36 = const false;
|
|
_30 = move _1;
|
|
_32 = &_3;
|
|
_33 = &mut _21;
|
|
_34 = &mut _27;
|
|
_31 = {closure@src/main.rs:34:14: 34:27} { window: move _32, surface: move _33, game: move _34 };
|
|
_29 = EventLoop::<()>::run::<{closure@src/main.rs:34:14: 34:27}>(move _30, move _31) -> [return: bb20, unwind: bb25];
|
|
}
|
|
|
|
bb20: {
|
|
_28 = Result::<(), EventLoopError>::unwrap(move _29) -> [return: bb21, unwind: bb25];
|
|
}
|
|
|
|
bb21: {
|
|
drop(_21) -> [return: bb22, unwind: bb26];
|
|
}
|
|
|
|
bb22: {
|
|
drop(_16) -> [return: bb23, unwind: bb27];
|
|
}
|
|
|
|
bb23: {
|
|
drop(_3) -> [return: bb24, unwind: bb32];
|
|
}
|
|
|
|
bb24: {
|
|
_36 = const false;
|
|
return;
|
|
}
|
|
|
|
bb25 (cleanup): {
|
|
drop(_21) -> [return: bb26, unwind terminate(cleanup)];
|
|
}
|
|
|
|
bb26 (cleanup): {
|
|
drop(_16) -> [return: bb27, unwind terminate(cleanup)];
|
|
}
|
|
|
|
bb27 (cleanup): {
|
|
drop(_3) -> [return: bb32, unwind terminate(cleanup)];
|
|
}
|
|
|
|
bb28 (cleanup): {
|
|
resume;
|
|
}
|
|
|
|
bb29 (cleanup): {
|
|
drop(_5) -> [return: bb32, unwind terminate(cleanup)];
|
|
}
|
|
|
|
bb30 (cleanup): {
|
|
switchInt(_35) -> [0: bb32, otherwise: bb29];
|
|
}
|
|
|
|
bb31 (cleanup): {
|
|
drop(_1) -> [return: bb28, unwind terminate(cleanup)];
|
|
}
|
|
|
|
bb32 (cleanup): {
|
|
switchInt(_36) -> [0: bb28, otherwise: bb31];
|
|
}
|
|
}
|
|
|
|
fn main::{closure#0}(_1: &mut {closure@src/main.rs:34:14: 34:27}, _2: Event<()>, _3: &EventLoopWindowTarget<()>) -> () {
|
|
debug event => _2;
|
|
debug elwt => _3;
|
|
debug window => (*((*_1).0: &winit::window::Window));
|
|
debug surface => (*((*_1).1: &mut softbuffer::Surface<winit::raw_window_handle::DisplayHandle<'_>, winit::raw_window_handle::WindowHandle<'_>>));
|
|
debug game => (*((*_1).2: &mut game::GameState));
|
|
let mut _0: ();
|
|
let mut _4: isize;
|
|
let mut _5: isize;
|
|
let mut _6: isize;
|
|
let mut _7: isize;
|
|
let _8: winit::window::WindowId;
|
|
let _9: &winit::window::WindowId;
|
|
let mut _10: bool;
|
|
let mut _11: &winit::window::WindowId;
|
|
let _12: winit::window::WindowId;
|
|
let mut _13: (std::option::Option<std::num::NonZero<u32>>, std::option::Option<std::num::NonZero<u32>>);
|
|
let mut _15: std::option::Option<std::num::NonZero<u32>>;
|
|
let mut _16: u32;
|
|
let mut _17: std::option::Option<std::num::NonZero<u32>>;
|
|
let mut _18: u32;
|
|
let mut _19: isize;
|
|
let mut _20: isize;
|
|
let _23: ();
|
|
let mut _24: std::result::Result<(), softbuffer::SoftBufferError>;
|
|
let mut _26: std::result::Result<softbuffer::Buffer<'_, winit::raw_window_handle::DisplayHandle<'_>, winit::raw_window_handle::WindowHandle<'_>>, softbuffer::SoftBufferError>;
|
|
let _27: ();
|
|
let mut _28: &mut [u32];
|
|
let mut _29: &mut softbuffer::Buffer<'_, winit::raw_window_handle::DisplayHandle<'_>, winit::raw_window_handle::WindowHandle<'_>>;
|
|
let _30: ();
|
|
let _31: ();
|
|
let mut _32: &game::GameState;
|
|
let mut _33: &mut softbuffer::Buffer<'_, winit::raw_window_handle::DisplayHandle<'_>, winit::raw_window_handle::WindowHandle<'_>>;
|
|
let mut _34: (std::num::NonZero<u32>, std::num::NonZero<u32>);
|
|
let _35: ();
|
|
let mut _36: std::result::Result<(), softbuffer::SoftBufferError>;
|
|
let mut _37: softbuffer::Buffer<'_, winit::raw_window_handle::DisplayHandle<'_>, winit::raw_window_handle::WindowHandle<'_>>;
|
|
let _38: winit::window::WindowId;
|
|
let _39: &winit::window::WindowId;
|
|
let mut _40: bool;
|
|
let mut _41: &winit::window::WindowId;
|
|
let mut _42: &winit::window::WindowId;
|
|
let _43: winit::window::WindowId;
|
|
let mut _44: bool;
|
|
let mut _45: &winit::window::WindowId;
|
|
let mut _46: &winit::window::WindowId;
|
|
let _47: winit::window::WindowId;
|
|
let _48: ();
|
|
let mut _49: &winit::window::Window;
|
|
let mut _50: &winit::window::Window;
|
|
let mut _51: &mut softbuffer::Surface<winit::raw_window_handle::DisplayHandle<'_>, winit::raw_window_handle::WindowHandle<'_>>;
|
|
let mut _52: &mut softbuffer::Surface<winit::raw_window_handle::DisplayHandle<'_>, winit::raw_window_handle::WindowHandle<'_>>;
|
|
let mut _53: &mut game::GameState;
|
|
let mut _54: &mut game::GameState;
|
|
let mut _55: &winit::window::Window;
|
|
let mut _56: &winit::window::Window;
|
|
let mut _57: bool;
|
|
scope 1 {
|
|
debug window_id => _8;
|
|
debug window_id => _9;
|
|
scope 2 {
|
|
debug width => _21;
|
|
debug height => _22;
|
|
let _14: winit::dpi::PhysicalSize<u32>;
|
|
let _21: std::num::NonZero<u32>;
|
|
let _22: std::num::NonZero<u32>;
|
|
let mut _25: softbuffer::Buffer<'_, winit::raw_window_handle::DisplayHandle<'_>, winit::raw_window_handle::WindowHandle<'_>>;
|
|
scope 3 {
|
|
debug size => _14;
|
|
}
|
|
scope 4 {
|
|
debug buffer => _25;
|
|
}
|
|
}
|
|
}
|
|
scope 5 {
|
|
debug window_id => _38;
|
|
debug window_id => _39;
|
|
}
|
|
|
|
bb0: {
|
|
_57 = const false;
|
|
_7 = discriminant(_2);
|
|
switchInt(move _7) -> [1: bb3, otherwise: bb32];
|
|
}
|
|
|
|
bb1: {
|
|
_5 = discriminant((((((_2 as WindowEvent).1: winit::event::WindowEvent) as KeyboardInput).1: winit::event::KeyEvent).1: winit::keyboard::Key));
|
|
switchInt(move _5) -> [0: bb2, otherwise: bb32];
|
|
}
|
|
|
|
bb2: {
|
|
_4 = discriminant((((((((_2 as WindowEvent).1: winit::event::WindowEvent) as KeyboardInput).1: winit::event::KeyEvent).1: winit::keyboard::Key) as Named).0: winit::keyboard::NamedKey));
|
|
switchInt(move _4) -> [42: bb28, otherwise: bb32];
|
|
}
|
|
|
|
bb3: {
|
|
_9 = &((_2 as WindowEvent).0: winit::window::WindowId);
|
|
_49 = deref_copy ((*_1).0: &winit::window::Window);
|
|
_12 = Window::id(_49) -> [return: bb4, unwind: bb34];
|
|
}
|
|
|
|
bb4: {
|
|
_11 = &_12;
|
|
_10 = <WindowId as PartialEq>::eq(_9, move _11) -> [return: bb5, unwind: bb34];
|
|
}
|
|
|
|
bb5: {
|
|
switchInt(move _10) -> [0: bb7, otherwise: bb6];
|
|
}
|
|
|
|
bb6: {
|
|
_8 = ((_2 as WindowEvent).0: winit::window::WindowId);
|
|
_50 = deref_copy ((*_1).0: &winit::window::Window);
|
|
_14 = Window::inner_size(_50) -> [return: bb8, unwind: bb34];
|
|
}
|
|
|
|
bb7: {
|
|
_6 = discriminant(((_2 as WindowEvent).1: winit::event::WindowEvent));
|
|
switchInt(move _6) -> [3: bb24, 9: bb1, otherwise: bb32];
|
|
}
|
|
|
|
bb8: {
|
|
_16 = (_14.0: u32);
|
|
_15 = NonZero::<u32>::new(move _16) -> [return: bb9, unwind: bb34];
|
|
}
|
|
|
|
bb9: {
|
|
_18 = (_14.1: u32);
|
|
_17 = NonZero::<u32>::new(move _18) -> [return: bb10, unwind: bb34];
|
|
}
|
|
|
|
bb10: {
|
|
_13 = (move _15, move _17);
|
|
_20 = discriminant((_13.0: std::option::Option<std::num::NonZero<u32>>));
|
|
switchInt(move _20) -> [1: bb11, otherwise: bb32];
|
|
}
|
|
|
|
bb11: {
|
|
_19 = discriminant((_13.1: std::option::Option<std::num::NonZero<u32>>));
|
|
switchInt(move _19) -> [1: bb12, otherwise: bb32];
|
|
}
|
|
|
|
bb12: {
|
|
_21 = (((_13.0: std::option::Option<std::num::NonZero<u32>>) as Some).0: std::num::NonZero<u32>);
|
|
_22 = (((_13.1: std::option::Option<std::num::NonZero<u32>>) as Some).0: std::num::NonZero<u32>);
|
|
_51 = deref_copy ((*_1).1: &mut softbuffer::Surface<winit::raw_window_handle::DisplayHandle<'_>, winit::raw_window_handle::WindowHandle<'_>>);
|
|
_24 = Surface::<DisplayHandle<'_>, WindowHandle<'_>>::resize(_51, _21, _22) -> [return: bb13, unwind: bb34];
|
|
}
|
|
|
|
bb13: {
|
|
_23 = Result::<(), SoftBufferError>::unwrap(move _24) -> [return: bb14, unwind: bb34];
|
|
}
|
|
|
|
bb14: {
|
|
_52 = deref_copy ((*_1).1: &mut softbuffer::Surface<winit::raw_window_handle::DisplayHandle<'_>, winit::raw_window_handle::WindowHandle<'_>>);
|
|
_26 = Surface::<DisplayHandle<'_>, WindowHandle<'_>>::buffer_mut(_52) -> [return: bb15, unwind: bb34];
|
|
}
|
|
|
|
bb15: {
|
|
_25 = Result::<Buffer<'_, DisplayHandle<'_>, WindowHandle<'_>>, SoftBufferError>::unwrap(move _26) -> [return: bb16, unwind: bb34];
|
|
}
|
|
|
|
bb16: {
|
|
_57 = const true;
|
|
_29 = &mut _25;
|
|
_28 = <Buffer<'_, DisplayHandle<'_>, WindowHandle<'_>> as DerefMut>::deref_mut(move _29) -> [return: bb17, unwind: bb37];
|
|
}
|
|
|
|
bb17: {
|
|
_27 = core::slice::<impl [u32]>::fill(_28, const 0_u32) -> [return: bb18, unwind: bb37];
|
|
}
|
|
|
|
bb18: {
|
|
_53 = deref_copy ((*_1).2: &mut game::GameState);
|
|
_30 = GameState::update(_53) -> [return: bb19, unwind: bb37];
|
|
}
|
|
|
|
bb19: {
|
|
_54 = deref_copy ((*_1).2: &mut game::GameState);
|
|
_32 = &(*_54);
|
|
_33 = &mut _25;
|
|
_34 = (_21, _22);
|
|
_31 = GameState::render(move _32, _33, move _34) -> [return: bb20, unwind: bb37];
|
|
}
|
|
|
|
bb20: {
|
|
_57 = const false;
|
|
_37 = move _25;
|
|
_36 = Buffer::<'_, DisplayHandle<'_>, WindowHandle<'_>>::present(move _37) -> [return: bb21, unwind: bb37];
|
|
}
|
|
|
|
bb21: {
|
|
_35 = Result::<(), SoftBufferError>::unwrap(move _36) -> [return: bb22, unwind: bb37];
|
|
}
|
|
|
|
bb22: {
|
|
_57 = const false;
|
|
goto -> bb32;
|
|
}
|
|
|
|
bb23: {
|
|
_48 = EventLoopWindowTarget::<()>::exit(_3) -> [return: bb38, unwind: bb34];
|
|
}
|
|
|
|
bb24: {
|
|
_39 = &((_2 as WindowEvent).0: winit::window::WindowId);
|
|
_41 = _39;
|
|
_55 = deref_copy ((*_1).0: &winit::window::Window);
|
|
_43 = Window::id(_55) -> [return: bb25, unwind: bb34];
|
|
}
|
|
|
|
bb25: {
|
|
_42 = &_43;
|
|
_40 = <WindowId as PartialEq>::eq(move _41, move _42) -> [return: bb26, unwind: bb34];
|
|
}
|
|
|
|
bb26: {
|
|
switchInt(move _40) -> [0: bb32, otherwise: bb27];
|
|
}
|
|
|
|
bb27: {
|
|
_38 = ((_2 as WindowEvent).0: winit::window::WindowId);
|
|
goto -> bb23;
|
|
}
|
|
|
|
bb28: {
|
|
_39 = &((_2 as WindowEvent).0: winit::window::WindowId);
|
|
_45 = _39;
|
|
_56 = deref_copy ((*_1).0: &winit::window::Window);
|
|
_47 = Window::id(_56) -> [return: bb29, unwind: bb34];
|
|
}
|
|
|
|
bb29: {
|
|
_46 = &_47;
|
|
_44 = <WindowId as PartialEq>::eq(move _45, move _46) -> [return: bb30, unwind: bb34];
|
|
}
|
|
|
|
bb30: {
|
|
switchInt(move _44) -> [0: bb32, otherwise: bb31];
|
|
}
|
|
|
|
bb31: {
|
|
_38 = ((_2 as WindowEvent).0: winit::window::WindowId);
|
|
goto -> bb23;
|
|
}
|
|
|
|
bb32: {
|
|
drop(_2) -> [return: bb33, unwind continue];
|
|
}
|
|
|
|
bb33: {
|
|
return;
|
|
}
|
|
|
|
bb34 (cleanup): {
|
|
drop(_2) -> [return: bb35, unwind terminate(cleanup)];
|
|
}
|
|
|
|
bb35 (cleanup): {
|
|
resume;
|
|
}
|
|
|
|
bb36 (cleanup): {
|
|
drop(_25) -> [return: bb34, unwind terminate(cleanup)];
|
|
}
|
|
|
|
bb37 (cleanup): {
|
|
switchInt(_57) -> [0: bb34, otherwise: bb36];
|
|
}
|
|
|
|
bb38: {
|
|
goto -> bb32;
|
|
}
|
|
}
|
|
|
|
const PADDLE_SIZE: (u32, u32) = {
|
|
let mut _0: (u32, u32);
|
|
|
|
bb0: {
|
|
_0 = (const 5_u32, const 50_u32);
|
|
return;
|
|
}
|
|
}
|
|
|
|
const BALL_RADIUS: u32 = {
|
|
let mut _0: u32;
|
|
|
|
bb0: {
|
|
_0 = const 10_u32;
|
|
return;
|
|
}
|
|
}
|
|
|
|
const BALL_VEC_RIGHT_UP: (i16, i16) = {
|
|
let mut _0: (i16, i16);
|
|
|
|
bb0: {
|
|
_0 = (const 8_i16, const 12_i16);
|
|
return;
|
|
}
|
|
}
|
|
|
|
const FIELD_SIZE: (u32, u32) = {
|
|
let mut _0: (u32, u32);
|
|
|
|
bb0: {
|
|
_0 = (const 1200_u32, const 700_u32);
|
|
return;
|
|
}
|
|
}
|
|
|
|
const FIELD_BORDER_WIDTH: u32 = {
|
|
let mut _0: u32;
|
|
|
|
bb0: {
|
|
_0 = const 5_u32;
|
|
return;
|
|
}
|
|
}
|
|
|
|
const TICK_LEN: f32 = {
|
|
let mut _0: f32;
|
|
|
|
bb0: {
|
|
_0 = Div(const 1000f32, const 60f32);
|
|
return;
|
|
}
|
|
}
|
|
|
|
fn game::<impl at src/main.rs:102:14: 102:19>::fmt(_1: &BallDirection, _2: &mut Formatter<'_>) -> Result<(), std::fmt::Error> {
|
|
debug self => _1;
|
|
debug f => _2;
|
|
let mut _0: std::result::Result<(), std::fmt::Error>;
|
|
let mut _3: &str;
|
|
let mut _4: isize;
|
|
let _5: &str;
|
|
let _6: &str;
|
|
let _7: &str;
|
|
let _8: &str;
|
|
|
|
bb0: {
|
|
_4 = discriminant((*_1));
|
|
switchInt(move _4) -> [0: bb2, 1: bb3, 2: bb4, 3: bb1, otherwise: bb7];
|
|
}
|
|
|
|
bb1: {
|
|
_8 = const "LeftDown";
|
|
_3 = _8;
|
|
goto -> bb5;
|
|
}
|
|
|
|
bb2: {
|
|
_5 = const "RightUp";
|
|
_3 = _5;
|
|
goto -> bb5;
|
|
}
|
|
|
|
bb3: {
|
|
_6 = const "RightDown";
|
|
_3 = _6;
|
|
goto -> bb5;
|
|
}
|
|
|
|
bb4: {
|
|
_7 = const "LeftUp";
|
|
_3 = _7;
|
|
goto -> bb5;
|
|
}
|
|
|
|
bb5: {
|
|
_0 = Formatter::<'_>::write_str(_2, move _3) -> [return: bb6, unwind continue];
|
|
}
|
|
|
|
bb6: {
|
|
return;
|
|
}
|
|
|
|
bb7: {
|
|
unreachable;
|
|
}
|
|
}
|
|
|
|
fn game::<impl at src/main.rs:102:21: 102:26>::clone(_1: &BallDirection) -> BallDirection {
|
|
debug self => _1;
|
|
let mut _0: game::BallDirection;
|
|
|
|
bb0: {
|
|
_0 = (*_1);
|
|
return;
|
|
}
|
|
}
|
|
|
|
fn game::<impl at src/main.rs:102:34: 102:43>::eq(_1: &BallDirection, _2: &BallDirection) -> bool {
|
|
debug self => _1;
|
|
debug other => _2;
|
|
let mut _0: bool;
|
|
let _3: isize;
|
|
scope 1 {
|
|
debug __self_tag => _3;
|
|
let _4: isize;
|
|
scope 2 {
|
|
debug __arg1_tag => _4;
|
|
}
|
|
}
|
|
|
|
bb0: {
|
|
_3 = discriminant((*_1));
|
|
_4 = discriminant((*_2));
|
|
_0 = Eq(_3, _4);
|
|
return;
|
|
}
|
|
}
|
|
|
|
fn game::<impl at src/main.rs:102:45: 102:47>::assert_receiver_is_total_eq(_1: &BallDirection) -> () {
|
|
debug self => _1;
|
|
let mut _0: ();
|
|
|
|
bb0: {
|
|
return;
|
|
}
|
|
}
|
|
|
|
fn game::<impl at src/main.rs:110:14: 110:19>::fmt(_1: &HorizontalCollisionCheck, _2: &mut Formatter<'_>) -> Result<(), std::fmt::Error> {
|
|
debug self => _1;
|
|
debug f => _2;
|
|
let mut _0: std::result::Result<(), std::fmt::Error>;
|
|
let mut _3: &str;
|
|
let mut _4: isize;
|
|
let _5: &str;
|
|
let _6: &str;
|
|
let _7: &str;
|
|
|
|
bb0: {
|
|
_4 = discriminant((*_1));
|
|
switchInt(move _4) -> [0: bb2, 1: bb3, 2: bb1, otherwise: bb6];
|
|
}
|
|
|
|
bb1: {
|
|
_7 = const "Right";
|
|
_3 = _7;
|
|
goto -> bb4;
|
|
}
|
|
|
|
bb2: {
|
|
_5 = const "None";
|
|
_3 = _5;
|
|
goto -> bb4;
|
|
}
|
|
|
|
bb3: {
|
|
_6 = const "Left";
|
|
_3 = _6;
|
|
goto -> bb4;
|
|
}
|
|
|
|
bb4: {
|
|
_0 = Formatter::<'_>::write_str(_2, move _3) -> [return: bb5, unwind continue];
|
|
}
|
|
|
|
bb5: {
|
|
return;
|
|
}
|
|
|
|
bb6: {
|
|
unreachable;
|
|
}
|
|
}
|
|
|
|
fn game::<impl at src/main.rs:110:21: 110:26>::clone(_1: &HorizontalCollisionCheck) -> HorizontalCollisionCheck {
|
|
debug self => _1;
|
|
let mut _0: game::HorizontalCollisionCheck;
|
|
|
|
bb0: {
|
|
_0 = (*_1);
|
|
return;
|
|
}
|
|
}
|
|
|
|
fn game::<impl at src/main.rs:110:34: 110:43>::eq(_1: &HorizontalCollisionCheck, _2: &HorizontalCollisionCheck) -> bool {
|
|
debug self => _1;
|
|
debug other => _2;
|
|
let mut _0: bool;
|
|
let _3: isize;
|
|
scope 1 {
|
|
debug __self_tag => _3;
|
|
let _4: isize;
|
|
scope 2 {
|
|
debug __arg1_tag => _4;
|
|
}
|
|
}
|
|
|
|
bb0: {
|
|
_3 = discriminant((*_1));
|
|
_4 = discriminant((*_2));
|
|
_0 = Eq(_3, _4);
|
|
return;
|
|
}
|
|
}
|
|
|
|
fn game::<impl at src/main.rs:110:45: 110:47>::assert_receiver_is_total_eq(_1: &HorizontalCollisionCheck) -> () {
|
|
debug self => _1;
|
|
let mut _0: ();
|
|
|
|
bb0: {
|
|
return;
|
|
}
|
|
}
|
|
|
|
fn game::<impl at src/main.rs:117:14: 117:19>::fmt(_1: &VerticalCollisionCheck, _2: &mut Formatter<'_>) -> Result<(), std::fmt::Error> {
|
|
debug self => _1;
|
|
debug f => _2;
|
|
let mut _0: std::result::Result<(), std::fmt::Error>;
|
|
let mut _3: &str;
|
|
let mut _4: isize;
|
|
let _5: &str;
|
|
let _6: &str;
|
|
let _7: &str;
|
|
|
|
bb0: {
|
|
_4 = discriminant((*_1));
|
|
switchInt(move _4) -> [0: bb2, 1: bb3, 2: bb1, otherwise: bb6];
|
|
}
|
|
|
|
bb1: {
|
|
_7 = const "Bottom";
|
|
_3 = _7;
|
|
goto -> bb4;
|
|
}
|
|
|
|
bb2: {
|
|
_5 = const "None";
|
|
_3 = _5;
|
|
goto -> bb4;
|
|
}
|
|
|
|
bb3: {
|
|
_6 = const "Top";
|
|
_3 = _6;
|
|
goto -> bb4;
|
|
}
|
|
|
|
bb4: {
|
|
_0 = Formatter::<'_>::write_str(_2, move _3) -> [return: bb5, unwind continue];
|
|
}
|
|
|
|
bb5: {
|
|
return;
|
|
}
|
|
|
|
bb6: {
|
|
unreachable;
|
|
}
|
|
}
|
|
|
|
fn game::<impl at src/main.rs:117:21: 117:26>::clone(_1: &VerticalCollisionCheck) -> VerticalCollisionCheck {
|
|
debug self => _1;
|
|
let mut _0: game::VerticalCollisionCheck;
|
|
|
|
bb0: {
|
|
_0 = (*_1);
|
|
return;
|
|
}
|
|
}
|
|
|
|
fn game::<impl at src/main.rs:117:34: 117:43>::eq(_1: &VerticalCollisionCheck, _2: &VerticalCollisionCheck) -> bool {
|
|
debug self => _1;
|
|
debug other => _2;
|
|
let mut _0: bool;
|
|
let _3: isize;
|
|
scope 1 {
|
|
debug __self_tag => _3;
|
|
let _4: isize;
|
|
scope 2 {
|
|
debug __arg1_tag => _4;
|
|
}
|
|
}
|
|
|
|
bb0: {
|
|
_3 = discriminant((*_1));
|
|
_4 = discriminant((*_2));
|
|
_0 = Eq(_3, _4);
|
|
return;
|
|
}
|
|
}
|
|
|
|
fn game::<impl at src/main.rs:117:45: 117:47>::assert_receiver_is_total_eq(_1: &VerticalCollisionCheck) -> () {
|
|
debug self => _1;
|
|
let mut _0: ();
|
|
|
|
bb0: {
|
|
return;
|
|
}
|
|
}
|
|
|
|
fn game::<impl at src/main.rs:124:14: 124:19>::fmt(_1: &CollisionCheck, _2: &mut Formatter<'_>) -> Result<(), std::fmt::Error> {
|
|
debug self => _1;
|
|
debug f => _2;
|
|
let mut _0: std::result::Result<(), std::fmt::Error>;
|
|
let _3: &str;
|
|
let mut _4: &dyn std::fmt::Debug;
|
|
let _5: &game::HorizontalCollisionCheck;
|
|
let mut _6: &dyn std::fmt::Debug;
|
|
let _7: &&game::VerticalCollisionCheck;
|
|
let _8: &game::VerticalCollisionCheck;
|
|
|
|
bb0: {
|
|
_3 = const "CollisionCheck";
|
|
_5 = &((*_1).0: game::HorizontalCollisionCheck);
|
|
_4 = _5 as &dyn std::fmt::Debug (PointerCoercion(Unsize));
|
|
_8 = &((*_1).1: game::VerticalCollisionCheck);
|
|
_7 = &_8;
|
|
_6 = _7 as &dyn std::fmt::Debug (PointerCoercion(Unsize));
|
|
_0 = Formatter::<'_>::debug_tuple_field2_finish(_2, _3, move _4, move _6) -> [return: bb1, unwind continue];
|
|
}
|
|
|
|
bb1: {
|
|
return;
|
|
}
|
|
}
|
|
|
|
fn game::<impl at src/main.rs:124:21: 124:26>::clone(_1: &CollisionCheck) -> CollisionCheck {
|
|
debug self => _1;
|
|
let mut _0: game::CollisionCheck;
|
|
scope 1 {
|
|
scope 2 {
|
|
}
|
|
}
|
|
|
|
bb0: {
|
|
_0 = (*_1);
|
|
return;
|
|
}
|
|
}
|
|
|
|
fn game::<impl at src/main.rs:124:34: 124:43>::eq(_1: &CollisionCheck, _2: &CollisionCheck) -> bool {
|
|
debug self => _1;
|
|
debug other => _2;
|
|
let mut _0: bool;
|
|
let mut _3: bool;
|
|
let mut _4: &game::HorizontalCollisionCheck;
|
|
let mut _5: &game::HorizontalCollisionCheck;
|
|
let mut _6: &game::VerticalCollisionCheck;
|
|
let mut _7: &game::VerticalCollisionCheck;
|
|
|
|
bb0: {
|
|
_4 = &((*_1).0: game::HorizontalCollisionCheck);
|
|
_5 = &((*_2).0: game::HorizontalCollisionCheck);
|
|
_3 = <HorizontalCollisionCheck as PartialEq>::eq(move _4, move _5) -> [return: bb1, unwind continue];
|
|
}
|
|
|
|
bb1: {
|
|
switchInt(move _3) -> [0: bb3, otherwise: bb2];
|
|
}
|
|
|
|
bb2: {
|
|
_6 = &((*_1).1: game::VerticalCollisionCheck);
|
|
_7 = &((*_2).1: game::VerticalCollisionCheck);
|
|
_0 = <VerticalCollisionCheck as PartialEq>::eq(move _6, move _7) -> [return: bb4, unwind continue];
|
|
}
|
|
|
|
bb3: {
|
|
_0 = const false;
|
|
goto -> bb4;
|
|
}
|
|
|
|
bb4: {
|
|
return;
|
|
}
|
|
}
|
|
|
|
fn game::<impl at src/main.rs:124:45: 124:47>::assert_receiver_is_total_eq(_1: &CollisionCheck) -> () {
|
|
debug self => _1;
|
|
let mut _0: ();
|
|
scope 1 {
|
|
scope 2 {
|
|
}
|
|
}
|
|
|
|
bb0: {
|
|
return;
|
|
}
|
|
}
|
|
|
|
fn game::<impl at src/main.rs:127:5: 127:24>::check_field(_1: (u32, u32), _2: (u32, u32)) -> CollisionCheck {
|
|
debug obj_pos => _1;
|
|
debug obj_size => _2;
|
|
let mut _0: game::CollisionCheck;
|
|
let _3: game::HorizontalCollisionCheck;
|
|
let mut _4: u32;
|
|
let mut _5: bool;
|
|
let mut _6: u32;
|
|
let mut _7: u32;
|
|
let mut _8: u32;
|
|
let mut _9: (u32, bool);
|
|
let mut _10: u32;
|
|
let mut _11: (u32, u32);
|
|
let mut _13: u32;
|
|
let mut _14: bool;
|
|
let mut _15: u32;
|
|
let mut _16: u32;
|
|
let mut _17: u32;
|
|
let mut _18: (u32, bool);
|
|
let mut _19: u32;
|
|
let mut _20: (u32, u32);
|
|
let mut _21: game::HorizontalCollisionCheck;
|
|
let mut _22: game::VerticalCollisionCheck;
|
|
scope 1 {
|
|
debug horizontal => _3;
|
|
let _12: game::VerticalCollisionCheck;
|
|
scope 2 {
|
|
debug vertical => _12;
|
|
}
|
|
}
|
|
|
|
bb0: {
|
|
_4 = (_1.0: u32);
|
|
switchInt(move _4) -> [0: bb1, otherwise: bb2];
|
|
}
|
|
|
|
bb1: {
|
|
_3 = HorizontalCollisionCheck::Left;
|
|
goto -> bb6;
|
|
}
|
|
|
|
bb2: {
|
|
_7 = (_1.0: u32);
|
|
_8 = (_2.0: u32);
|
|
_9 = CheckedAdd(_7, _8);
|
|
assert(!move (_9.1: bool), "attempt to compute `{} + {}`, which would overflow", move _7, move _8) -> [success: bb3, unwind continue];
|
|
}
|
|
|
|
bb3: {
|
|
_6 = move (_9.0: u32);
|
|
_11 = const _;
|
|
_10 = (_11.0: u32);
|
|
_5 = Ge(move _6, move _10);
|
|
switchInt(move _5) -> [0: bb5, otherwise: bb4];
|
|
}
|
|
|
|
bb4: {
|
|
_3 = HorizontalCollisionCheck::Right;
|
|
goto -> bb6;
|
|
}
|
|
|
|
bb5: {
|
|
_3 = HorizontalCollisionCheck::None;
|
|
goto -> bb6;
|
|
}
|
|
|
|
bb6: {
|
|
_13 = (_1.1: u32);
|
|
switchInt(move _13) -> [0: bb7, otherwise: bb8];
|
|
}
|
|
|
|
bb7: {
|
|
_12 = VerticalCollisionCheck::Top;
|
|
goto -> bb12;
|
|
}
|
|
|
|
bb8: {
|
|
_16 = (_1.1: u32);
|
|
_17 = (_2.1: u32);
|
|
_18 = CheckedAdd(_16, _17);
|
|
assert(!move (_18.1: bool), "attempt to compute `{} + {}`, which would overflow", move _16, move _17) -> [success: bb9, unwind continue];
|
|
}
|
|
|
|
bb9: {
|
|
_15 = move (_18.0: u32);
|
|
_20 = const _;
|
|
_19 = (_20.1: u32);
|
|
_14 = Ge(move _15, move _19);
|
|
switchInt(move _14) -> [0: bb11, otherwise: bb10];
|
|
}
|
|
|
|
bb10: {
|
|
_12 = VerticalCollisionCheck::Bottom;
|
|
goto -> bb12;
|
|
}
|
|
|
|
bb11: {
|
|
_12 = VerticalCollisionCheck::None;
|
|
goto -> bb12;
|
|
}
|
|
|
|
bb12: {
|
|
_21 = _3;
|
|
_22 = _12;
|
|
_0 = CollisionCheck(move _21, move _22);
|
|
return;
|
|
}
|
|
}
|
|
|
|
fn game::<impl at src/main.rs:127:5: 127:24>::no_collisions(_1: &CollisionCheck) -> bool {
|
|
debug self => _1;
|
|
let mut _0: bool;
|
|
let mut _2: isize;
|
|
let mut _3: isize;
|
|
|
|
bb0: {
|
|
_3 = discriminant(((*_1).0: game::HorizontalCollisionCheck));
|
|
switchInt(move _3) -> [0: bb1, otherwise: bb2];
|
|
}
|
|
|
|
bb1: {
|
|
_2 = discriminant(((*_1).1: game::VerticalCollisionCheck));
|
|
_0 = Eq(_2, const 0_isize);
|
|
goto -> bb3;
|
|
}
|
|
|
|
bb2: {
|
|
_0 = const false;
|
|
goto -> bb3;
|
|
}
|
|
|
|
bb3: {
|
|
return;
|
|
}
|
|
}
|
|
|
|
fn game::<impl at src/main.rs:154:5: 154:23>::get_vec(_1: &BallDirection) -> (i16, i16) {
|
|
debug self => _1;
|
|
let mut _0: (i16, i16);
|
|
let mut _2: isize;
|
|
let mut _3: i16;
|
|
let mut _4: (i16, i16);
|
|
let mut _5: i16;
|
|
let mut _6: i16;
|
|
let mut _7: (i16, i16);
|
|
let mut _8: bool;
|
|
let mut _9: i16;
|
|
let mut _10: i16;
|
|
let mut _11: (i16, i16);
|
|
let mut _12: bool;
|
|
let mut _13: i16;
|
|
let mut _14: (i16, i16);
|
|
let mut _15: i16;
|
|
let mut _16: i16;
|
|
let mut _17: (i16, i16);
|
|
let mut _18: bool;
|
|
let mut _19: i16;
|
|
let mut _20: i16;
|
|
let mut _21: (i16, i16);
|
|
let mut _22: bool;
|
|
|
|
bb0: {
|
|
_2 = discriminant((*_1));
|
|
switchInt(move _2) -> [0: bb2, 1: bb3, 2: bb5, 3: bb1, otherwise: bb10];
|
|
}
|
|
|
|
bb1: {
|
|
_17 = const _;
|
|
_16 = (_17.0: i16);
|
|
_18 = Eq(_16, const i16::MIN);
|
|
assert(!move _18, "attempt to negate `{}`, which would overflow", _16) -> [success: bb7, unwind continue];
|
|
}
|
|
|
|
bb2: {
|
|
_0 = const _;
|
|
goto -> bb9;
|
|
}
|
|
|
|
bb3: {
|
|
_4 = const _;
|
|
_3 = (_4.0: i16);
|
|
_7 = const _;
|
|
_6 = (_7.1: i16);
|
|
_8 = Eq(_6, const i16::MIN);
|
|
assert(!move _8, "attempt to negate `{}`, which would overflow", _6) -> [success: bb4, unwind continue];
|
|
}
|
|
|
|
bb4: {
|
|
_5 = Neg(move _6);
|
|
_0 = (move _3, move _5);
|
|
goto -> bb9;
|
|
}
|
|
|
|
bb5: {
|
|
_11 = const _;
|
|
_10 = (_11.0: i16);
|
|
_12 = Eq(_10, const i16::MIN);
|
|
assert(!move _12, "attempt to negate `{}`, which would overflow", _10) -> [success: bb6, unwind continue];
|
|
}
|
|
|
|
bb6: {
|
|
_9 = Neg(move _10);
|
|
_14 = const _;
|
|
_13 = (_14.1: i16);
|
|
_0 = (move _9, move _13);
|
|
goto -> bb9;
|
|
}
|
|
|
|
bb7: {
|
|
_15 = Neg(move _16);
|
|
_21 = const _;
|
|
_20 = (_21.1: i16);
|
|
_22 = Eq(_20, const i16::MIN);
|
|
assert(!move _22, "attempt to negate `{}`, which would overflow", _20) -> [success: bb8, unwind continue];
|
|
}
|
|
|
|
bb8: {
|
|
_19 = Neg(move _20);
|
|
_0 = (move _15, move _19);
|
|
goto -> bb9;
|
|
}
|
|
|
|
bb9: {
|
|
return;
|
|
}
|
|
|
|
bb10: {
|
|
unreachable;
|
|
}
|
|
}
|
|
|
|
fn game::<impl at src/main.rs:174:5: 174:19>::init() -> GameState {
|
|
let mut _0: game::GameState;
|
|
let mut _1: (u32, u32);
|
|
let mut _2: u32;
|
|
let mut _3: u32;
|
|
let mut _4: (u32, u32);
|
|
let mut _5: bool;
|
|
let mut _6: u32;
|
|
let mut _7: u32;
|
|
let mut _8: (u32, u32);
|
|
let mut _9: bool;
|
|
let mut _10: u32;
|
|
let mut _11: u32;
|
|
let mut _12: (u32, u32);
|
|
let mut _13: bool;
|
|
let mut _14: u32;
|
|
let mut _15: u32;
|
|
let mut _16: (u32, u32);
|
|
let mut _17: bool;
|
|
let mut _18: game::BallDirection;
|
|
let mut _19: (u32, u32);
|
|
let mut _20: std::time::Instant;
|
|
|
|
bb0: {
|
|
_4 = const _;
|
|
_3 = (_4.0: u32);
|
|
_5 = Eq(const 2_u32, const 0_u32);
|
|
assert(!move _5, "attempt to divide `{}` by zero", _3) -> [success: bb1, unwind continue];
|
|
}
|
|
|
|
bb1: {
|
|
_2 = Div(move _3, const 2_u32);
|
|
_8 = const _;
|
|
_7 = (_8.1: u32);
|
|
_9 = Eq(const 2_u32, const 0_u32);
|
|
assert(!move _9, "attempt to divide `{}` by zero", _7) -> [success: bb2, unwind continue];
|
|
}
|
|
|
|
bb2: {
|
|
_6 = Div(move _7, const 2_u32);
|
|
_1 = (move _2, move _6);
|
|
_12 = const _;
|
|
_11 = (_12.0: u32);
|
|
_13 = Eq(const 2_u32, const 0_u32);
|
|
assert(!move _13, "attempt to divide `{}` by zero", _11) -> [success: bb3, unwind continue];
|
|
}
|
|
|
|
bb3: {
|
|
_10 = Div(move _11, const 2_u32);
|
|
_16 = const _;
|
|
_15 = (_16.0: u32);
|
|
_17 = Eq(const 2_u32, const 0_u32);
|
|
assert(!move _17, "attempt to divide `{}` by zero", _15) -> [success: bb4, unwind continue];
|
|
}
|
|
|
|
bb4: {
|
|
_14 = Div(move _15, const 2_u32);
|
|
_18 = BallDirection::RightUp;
|
|
_19 = (const 0_u32, const 0_u32);
|
|
_20 = Instant::now() -> [return: bb5, unwind continue];
|
|
}
|
|
|
|
bb5: {
|
|
_0 = GameState { ball_pos: move _1, ball_direction: move _18, paddle_r_pos: move _10, paddle_y_pos: move _14, scores: move _19, last_frame_time: move _20 };
|
|
return;
|
|
}
|
|
}
|
|
|
|
fn game::<impl at src/main.rs:174:5: 174:19>::render(_1: &GameState, _2: &mut Buffer<'_, DisplayHandle<'_>, WindowHandle<'_>>, _3: (NonZero<u32>, NonZero<u32>)) -> () {
|
|
debug self => _1;
|
|
debug buf => _2;
|
|
debug win_size => _3;
|
|
let mut _0: ();
|
|
let _4: (u32, u32);
|
|
let mut _5: u32;
|
|
let mut _6: std::num::NonZero<u32>;
|
|
let mut _7: u32;
|
|
let mut _8: std::num::NonZero<u32>;
|
|
let _9: ();
|
|
let _10: ();
|
|
scope 1 {
|
|
debug win_size => _4;
|
|
}
|
|
|
|
bb0: {
|
|
_6 = (_3.0: std::num::NonZero<u32>);
|
|
_5 = NonZero::<u32>::get(move _6) -> [return: bb1, unwind continue];
|
|
}
|
|
|
|
bb1: {
|
|
_8 = (_3.1: std::num::NonZero<u32>);
|
|
_7 = NonZero::<u32>::get(move _8) -> [return: bb2, unwind continue];
|
|
}
|
|
|
|
bb2: {
|
|
_4 = (move _5, move _7);
|
|
_9 = GameState::render_field(_1, _2, _4) -> [return: bb3, unwind continue];
|
|
}
|
|
|
|
bb3: {
|
|
_10 = GameState::render_ball(_1, _2, _4) -> [return: bb4, unwind continue];
|
|
}
|
|
|
|
bb4: {
|
|
return;
|
|
}
|
|
}
|
|
|
|
fn game::<impl at src/main.rs:174:5: 174:19>::update(_1: &mut GameState) -> () {
|
|
debug self => _1;
|
|
let mut _0: ();
|
|
let _2: f32;
|
|
let mut _3: &game::GameState;
|
|
let mut _4: std::time::Instant;
|
|
let _5: ();
|
|
scope 1 {
|
|
debug delta_t => _2;
|
|
}
|
|
|
|
bb0: {
|
|
_3 = &(*_1);
|
|
_2 = GameState::delta_time(move _3) -> [return: bb1, unwind continue];
|
|
}
|
|
|
|
bb1: {
|
|
_4 = Instant::now() -> [return: bb2, unwind continue];
|
|
}
|
|
|
|
bb2: {
|
|
((*_1).5: std::time::Instant) = move _4;
|
|
_5 = GameState::move_ball(_1) -> [return: bb3, unwind continue];
|
|
}
|
|
|
|
bb3: {
|
|
return;
|
|
}
|
|
}
|
|
|
|
fn game::<impl at src/main.rs:174:5: 174:19>::move_ball(_1: &mut GameState) -> () {
|
|
debug self => _1;
|
|
let mut _0: ();
|
|
let _2: (i16, i16);
|
|
let mut _3: &game::BallDirection;
|
|
let mut _5: &game::GameState;
|
|
let mut _7: u32;
|
|
let mut _8: u32;
|
|
let mut _9: u32;
|
|
let mut _10: i32;
|
|
let mut _11: f32;
|
|
let mut _12: f32;
|
|
let mut _13: i16;
|
|
let mut _14: u32;
|
|
let mut _15: u32;
|
|
let mut _16: (u32, u32);
|
|
let mut _17: (u32, bool);
|
|
let mut _18: u32;
|
|
let mut _19: u32;
|
|
let mut _20: u32;
|
|
let mut _21: i32;
|
|
let mut _22: f32;
|
|
let mut _23: f32;
|
|
let mut _24: i16;
|
|
let mut _25: u32;
|
|
let mut _26: u32;
|
|
let mut _27: (u32, u32);
|
|
let mut _28: (u32, bool);
|
|
let _29: ();
|
|
let mut _30: std::fmt::Arguments<'_>;
|
|
let mut _31: &[&str];
|
|
let mut _32: &[core::fmt::rt::Argument<'_>];
|
|
let _33: &[core::fmt::rt::Argument<'_>; 2];
|
|
let _34: [core::fmt::rt::Argument<'_>; 2];
|
|
let mut _35: core::fmt::rt::Argument<'_>;
|
|
let _36: &(u32, u32);
|
|
let mut _37: core::fmt::rt::Argument<'_>;
|
|
let _38: &(u32, u32);
|
|
let mut _39: (u32, u32);
|
|
let mut _41: (u32, u32);
|
|
let mut _42: u32;
|
|
let mut _43: u32;
|
|
let mut _44: u32;
|
|
let mut _45: u32;
|
|
let mut _46: (u32, u32);
|
|
let mut _47: u32;
|
|
let mut _48: (u32, bool);
|
|
let mut _49: u32;
|
|
let mut _50: (u32, bool);
|
|
let mut _53: game::BallDirection;
|
|
let mut _54: (game::BallDirection, (game::HorizontalCollisionCheck, game::VerticalCollisionCheck));
|
|
let mut _55: game::BallDirection;
|
|
let mut _56: (game::HorizontalCollisionCheck, game::VerticalCollisionCheck);
|
|
let mut _57: isize;
|
|
let mut _58: isize;
|
|
let mut _59: isize;
|
|
let mut _60: isize;
|
|
let mut _61: isize;
|
|
let mut _62: isize;
|
|
let mut _63: isize;
|
|
let mut _64: isize;
|
|
let mut _65: isize;
|
|
let mut _66: isize;
|
|
let mut _67: isize;
|
|
let mut _68: isize;
|
|
let mut _69: isize;
|
|
let _71: !;
|
|
let mut _72: std::fmt::Arguments<'_>;
|
|
let mut _73: &[&str];
|
|
let mut _74: &[core::fmt::rt::Argument<'_>];
|
|
let _75: &[core::fmt::rt::Argument<'_>; 1];
|
|
let _76: [core::fmt::rt::Argument<'_>; 1];
|
|
let mut _77: core::fmt::rt::Argument<'_>;
|
|
let _78: &(game::BallDirection, (game::HorizontalCollisionCheck, game::VerticalCollisionCheck));
|
|
let mut _79: &[core::fmt::rt::Placeholder];
|
|
let _80: &[core::fmt::rt::Placeholder; 1];
|
|
let _81: [core::fmt::rt::Placeholder; 1];
|
|
let mut _82: core::fmt::rt::Placeholder;
|
|
let mut _83: core::fmt::rt::Alignment;
|
|
let mut _84: core::fmt::rt::Count;
|
|
let mut _85: core::fmt::rt::Count;
|
|
let mut _86: core::fmt::rt::UnsafeArg;
|
|
scope 1 {
|
|
debug vec => _2;
|
|
let _4: f32;
|
|
scope 2 {
|
|
debug delta_t => _4;
|
|
let _6: (u32, u32);
|
|
scope 3 {
|
|
debug new_pos => _6;
|
|
let _40: game::CollisionCheck;
|
|
let mut _88: &[&str; 3];
|
|
scope 4 {
|
|
debug check_res => _40;
|
|
let _51: game::HorizontalCollisionCheck;
|
|
let _52: game::VerticalCollisionCheck;
|
|
scope 5 {
|
|
debug horizontal => _51;
|
|
debug vertical => _52;
|
|
let _70: (game::BallDirection, (game::HorizontalCollisionCheck, game::VerticalCollisionCheck));
|
|
scope 6 {
|
|
debug other => _70;
|
|
let mut _87: &[&str; 1];
|
|
scope 7 {
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
bb0: {
|
|
_3 = &((*_1).1: game::BallDirection);
|
|
_2 = BallDirection::get_vec(move _3) -> [return: bb1, unwind continue];
|
|
}
|
|
|
|
bb1: {
|
|
_5 = &(*_1);
|
|
_4 = GameState::delta_time(move _5) -> [return: bb2, unwind continue];
|
|
}
|
|
|
|
bb2: {
|
|
_9 = (((*_1).0: (u32, u32)).0: u32);
|
|
_13 = (_2.0: i16);
|
|
_12 = move _13 as f32 (IntToFloat);
|
|
_11 = Mul(move _12, _4);
|
|
_10 = move _11 as i32 (FloatToInt);
|
|
_8 = core::num::<impl u32>::saturating_add_signed(move _9, move _10) -> [return: bb3, unwind continue];
|
|
}
|
|
|
|
bb3: {
|
|
_16 = const _;
|
|
_15 = (_16.0: u32);
|
|
_17 = CheckedSub(_15, const _);
|
|
assert(!move (_17.1: bool), "attempt to compute `{} - {}`, which would overflow", move _15, const _) -> [success: bb4, unwind continue];
|
|
}
|
|
|
|
bb4: {
|
|
_14 = move (_17.0: u32);
|
|
_7 = <u32 as Ord>::clamp(move _8, const 0_u32, move _14) -> [return: bb5, unwind continue];
|
|
}
|
|
|
|
bb5: {
|
|
_20 = (((*_1).0: (u32, u32)).1: u32);
|
|
_24 = (_2.1: i16);
|
|
_23 = move _24 as f32 (IntToFloat);
|
|
_22 = Mul(move _23, _4);
|
|
_21 = move _22 as i32 (FloatToInt);
|
|
_19 = core::num::<impl u32>::saturating_add_signed(move _20, move _21) -> [return: bb6, unwind continue];
|
|
}
|
|
|
|
bb6: {
|
|
_27 = const _;
|
|
_26 = (_27.1: u32);
|
|
_28 = CheckedSub(_26, const _);
|
|
assert(!move (_28.1: bool), "attempt to compute `{} - {}`, which would overflow", move _26, const _) -> [success: bb7, unwind continue];
|
|
}
|
|
|
|
bb7: {
|
|
_25 = move (_28.0: u32);
|
|
_18 = <u32 as Ord>::clamp(move _19, const 0_u32, move _25) -> [return: bb8, unwind continue];
|
|
}
|
|
|
|
bb8: {
|
|
_6 = (move _7, move _18);
|
|
_88 = const _;
|
|
_31 = _88 as &[&str] (PointerCoercion(Unsize));
|
|
_36 = &((*_1).0: (u32, u32));
|
|
_35 = core::fmt::rt::Argument::<'_>::new_debug::<(u32, u32)>(_36) -> [return: bb9, unwind continue];
|
|
}
|
|
|
|
bb9: {
|
|
_38 = &_6;
|
|
_37 = core::fmt::rt::Argument::<'_>::new_debug::<(u32, u32)>(_38) -> [return: bb10, unwind continue];
|
|
}
|
|
|
|
bb10: {
|
|
_34 = [move _35, move _37];
|
|
_33 = &_34;
|
|
_32 = _33 as &[core::fmt::rt::Argument<'_>] (PointerCoercion(Unsize));
|
|
_30 = Arguments::<'_>::new_v1(move _31, move _32) -> [return: bb11, unwind continue];
|
|
}
|
|
|
|
bb11: {
|
|
_29 = _print(move _30) -> [return: bb12, unwind continue];
|
|
}
|
|
|
|
bb12: {
|
|
_39 = _6;
|
|
((*_1).0: (u32, u32)) = move _39;
|
|
_43 = (_6.0: u32);
|
|
_42 = core::num::<impl u32>::saturating_sub(move _43, const _) -> [return: bb13, unwind continue];
|
|
}
|
|
|
|
bb13: {
|
|
_45 = (_6.1: u32);
|
|
_44 = core::num::<impl u32>::saturating_sub(move _45, const _) -> [return: bb14, unwind continue];
|
|
}
|
|
|
|
bb14: {
|
|
_41 = (move _42, move _44);
|
|
_48 = CheckedMul(const _, const 2_u32);
|
|
assert(!move (_48.1: bool), "attempt to compute `{} * {}`, which would overflow", const _, const 2_u32) -> [success: bb15, unwind continue];
|
|
}
|
|
|
|
bb15: {
|
|
_47 = move (_48.0: u32);
|
|
_50 = CheckedMul(const _, const 2_u32);
|
|
assert(!move (_50.1: bool), "attempt to compute `{} * {}`, which would overflow", const _, const 2_u32) -> [success: bb16, unwind continue];
|
|
}
|
|
|
|
bb16: {
|
|
_49 = move (_50.0: u32);
|
|
_46 = (move _47, move _49);
|
|
_40 = CollisionCheck::check_field(move _41, move _46) -> [return: bb17, unwind continue];
|
|
}
|
|
|
|
bb17: {
|
|
_51 = (_40.0: game::HorizontalCollisionCheck);
|
|
_52 = (_40.1: game::VerticalCollisionCheck);
|
|
_55 = ((*_1).1: game::BallDirection);
|
|
_56 = (_51, _52);
|
|
_54 = (move _55, move _56);
|
|
_69 = discriminant((_54.0: game::BallDirection));
|
|
switchInt(move _69) -> [0: bb18, 1: bb22, 2: bb25, 3: bb28, otherwise: bb40];
|
|
}
|
|
|
|
bb18: {
|
|
_59 = discriminant(((_54.1: (game::HorizontalCollisionCheck, game::VerticalCollisionCheck)).0: game::HorizontalCollisionCheck));
|
|
switchInt(move _59) -> [0: bb19, 2: bb21, otherwise: bb20];
|
|
}
|
|
|
|
bb19: {
|
|
_57 = discriminant(((_54.1: (game::HorizontalCollisionCheck, game::VerticalCollisionCheck)).1: game::VerticalCollisionCheck));
|
|
switchInt(move _57) -> [0: bb31, 1: bb32, otherwise: bb20];
|
|
}
|
|
|
|
bb20: {
|
|
_70 = _54;
|
|
_87 = const _;
|
|
_73 = _87 as &[&str] (PointerCoercion(Unsize));
|
|
_78 = &_70;
|
|
_77 = core::fmt::rt::Argument::<'_>::new_debug::<(BallDirection, (HorizontalCollisionCheck, VerticalCollisionCheck))>(_78) -> [return: bb35, unwind continue];
|
|
}
|
|
|
|
bb21: {
|
|
_58 = discriminant(((_54.1: (game::HorizontalCollisionCheck, game::VerticalCollisionCheck)).1: game::VerticalCollisionCheck));
|
|
switchInt(move _58) -> [0: bb33, 1: bb34, otherwise: bb20];
|
|
}
|
|
|
|
bb22: {
|
|
_62 = discriminant(((_54.1: (game::HorizontalCollisionCheck, game::VerticalCollisionCheck)).0: game::HorizontalCollisionCheck));
|
|
switchInt(move _62) -> [0: bb23, 2: bb24, otherwise: bb20];
|
|
}
|
|
|
|
bb23: {
|
|
_60 = discriminant(((_54.1: (game::HorizontalCollisionCheck, game::VerticalCollisionCheck)).1: game::VerticalCollisionCheck));
|
|
switchInt(move _60) -> [0: bb32, 2: bb31, otherwise: bb20];
|
|
}
|
|
|
|
bb24: {
|
|
_61 = discriminant(((_54.1: (game::HorizontalCollisionCheck, game::VerticalCollisionCheck)).1: game::VerticalCollisionCheck));
|
|
switchInt(move _61) -> [0: bb34, 2: bb33, otherwise: bb20];
|
|
}
|
|
|
|
bb25: {
|
|
_65 = discriminant(((_54.1: (game::HorizontalCollisionCheck, game::VerticalCollisionCheck)).0: game::HorizontalCollisionCheck));
|
|
switchInt(move _65) -> [0: bb26, 1: bb27, otherwise: bb20];
|
|
}
|
|
|
|
bb26: {
|
|
_63 = discriminant(((_54.1: (game::HorizontalCollisionCheck, game::VerticalCollisionCheck)).1: game::VerticalCollisionCheck));
|
|
switchInt(move _63) -> [0: bb33, 1: bb34, otherwise: bb20];
|
|
}
|
|
|
|
bb27: {
|
|
_64 = discriminant(((_54.1: (game::HorizontalCollisionCheck, game::VerticalCollisionCheck)).1: game::VerticalCollisionCheck));
|
|
switchInt(move _64) -> [0: bb31, 1: bb32, otherwise: bb20];
|
|
}
|
|
|
|
bb28: {
|
|
_68 = discriminant(((_54.1: (game::HorizontalCollisionCheck, game::VerticalCollisionCheck)).0: game::HorizontalCollisionCheck));
|
|
switchInt(move _68) -> [0: bb29, 1: bb30, otherwise: bb20];
|
|
}
|
|
|
|
bb29: {
|
|
_66 = discriminant(((_54.1: (game::HorizontalCollisionCheck, game::VerticalCollisionCheck)).1: game::VerticalCollisionCheck));
|
|
switchInt(move _66) -> [0: bb34, 2: bb33, otherwise: bb20];
|
|
}
|
|
|
|
bb30: {
|
|
_67 = discriminant(((_54.1: (game::HorizontalCollisionCheck, game::VerticalCollisionCheck)).1: game::VerticalCollisionCheck));
|
|
switchInt(move _67) -> [0: bb32, 1: bb31, otherwise: bb20];
|
|
}
|
|
|
|
bb31: {
|
|
_53 = BallDirection::RightUp;
|
|
goto -> bb39;
|
|
}
|
|
|
|
bb32: {
|
|
_53 = BallDirection::RightDown;
|
|
goto -> bb39;
|
|
}
|
|
|
|
bb33: {
|
|
_53 = BallDirection::LeftUp;
|
|
goto -> bb39;
|
|
}
|
|
|
|
bb34: {
|
|
_53 = BallDirection::LeftDown;
|
|
goto -> bb39;
|
|
}
|
|
|
|
bb35: {
|
|
_76 = [move _77];
|
|
_75 = &_76;
|
|
_74 = _75 as &[core::fmt::rt::Argument<'_>] (PointerCoercion(Unsize));
|
|
_83 = core::fmt::rt::Alignment::Unknown;
|
|
_84 = core::fmt::rt::Count::Implied;
|
|
_85 = core::fmt::rt::Count::Implied;
|
|
_82 = core::fmt::rt::Placeholder::new(const 0_usize, const ' ', move _83, const 4_u32, move _84, move _85) -> [return: bb36, unwind continue];
|
|
}
|
|
|
|
bb36: {
|
|
_81 = [move _82];
|
|
_80 = &_81;
|
|
_79 = _80 as &[core::fmt::rt::Placeholder] (PointerCoercion(Unsize));
|
|
_86 = core::fmt::rt::UnsafeArg::new() -> [return: bb37, unwind continue];
|
|
}
|
|
|
|
bb37: {
|
|
_72 = Arguments::<'_>::new_v1_formatted(move _73, move _74, move _79, const core::fmt::rt::UnsafeArg {{ _private: () }}) -> [return: bb38, unwind continue];
|
|
}
|
|
|
|
bb38: {
|
|
_71 = panic_fmt(move _72) -> unwind continue;
|
|
}
|
|
|
|
bb39: {
|
|
((*_1).1: game::BallDirection) = move _53;
|
|
return;
|
|
}
|
|
|
|
bb40: {
|
|
unreachable;
|
|
}
|
|
}
|
|
|
|
promoted[0] in game::<impl at src/main.rs:174:5: 174:19>::move_ball: &[&str; 1] = {
|
|
let mut _0: &[&str; 1];
|
|
let mut _1: [&str; 1];
|
|
|
|
bb0: {
|
|
_1 = [const "Invalid collision: "];
|
|
_0 = &_1;
|
|
return;
|
|
}
|
|
}
|
|
|
|
promoted[1] in game::<impl at src/main.rs:174:5: 174:19>::move_ball: &[&str; 3] = {
|
|
let mut _0: &[&str; 3];
|
|
let mut _1: [&str; 3];
|
|
|
|
bb0: {
|
|
_1 = [const "", const " -> ", const "\n"];
|
|
_0 = &_1;
|
|
return;
|
|
}
|
|
}
|
|
|
|
fn game::<impl at src/main.rs:174:5: 174:19>::delta_time(_1: &GameState) -> f32 {
|
|
debug self => _1;
|
|
let mut _0: f32;
|
|
let mut _2: f32;
|
|
let mut _3: u128;
|
|
let mut _4: &std::time::Duration;
|
|
let _5: std::time::Duration;
|
|
let mut _6: &std::time::Instant;
|
|
let _7: std::time::Instant;
|
|
let mut _8: std::time::Instant;
|
|
|
|
bb0: {
|
|
_7 = Instant::now() -> [return: bb1, unwind continue];
|
|
}
|
|
|
|
bb1: {
|
|
_6 = &_7;
|
|
_8 = ((*_1).5: std::time::Instant);
|
|
_5 = Instant::duration_since(move _6, move _8) -> [return: bb2, unwind continue];
|
|
}
|
|
|
|
bb2: {
|
|
_4 = &_5;
|
|
_3 = Duration::as_millis(move _4) -> [return: bb3, unwind continue];
|
|
}
|
|
|
|
bb3: {
|
|
_2 = move _3 as f32 (IntToFloat);
|
|
_0 = Div(move _2, const _);
|
|
return;
|
|
}
|
|
}
|
|
|
|
fn game::<impl at src/main.rs:174:5: 174:19>::render_field(_1: &GameState, _2: &mut Buffer<'_, DisplayHandle<'_>, WindowHandle<'_>>, _3: (u32, u32)) -> () {
|
|
debug self => _1;
|
|
debug buf => _2;
|
|
debug win_size => _3;
|
|
let mut _0: ();
|
|
let _4: (u32, u32);
|
|
let mut _5: u32;
|
|
let mut _6: u32;
|
|
let mut _7: u32;
|
|
let mut _8: bool;
|
|
let mut _9: u32;
|
|
let mut _10: u32;
|
|
let mut _11: (u32, u32);
|
|
let mut _12: bool;
|
|
let mut _13: u32;
|
|
let mut _14: u32;
|
|
let mut _15: u32;
|
|
let mut _16: bool;
|
|
let mut _17: u32;
|
|
let mut _18: u32;
|
|
let mut _19: (u32, u32);
|
|
let mut _20: bool;
|
|
let _21: ();
|
|
let mut _22: (u32, u32);
|
|
let mut _23: u32;
|
|
let mut _24: u32;
|
|
let mut _25: u32;
|
|
let mut _26: u32;
|
|
let mut _27: (u32, u32);
|
|
let mut _28: u32;
|
|
let mut _29: u32;
|
|
let mut _30: (u32, u32);
|
|
let mut _31: u32;
|
|
let mut _32: (u32, bool);
|
|
let _33: ();
|
|
let mut _34: (u32, u32);
|
|
let mut _35: u32;
|
|
let mut _36: u32;
|
|
let mut _37: u32;
|
|
let mut _38: (u32, u32);
|
|
let mut _39: u32;
|
|
let mut _40: (u32, u32);
|
|
let mut _41: u32;
|
|
let mut _42: (u32, u32);
|
|
let _43: ();
|
|
let mut _44: (u32, u32);
|
|
let mut _45: u32;
|
|
let mut _46: u32;
|
|
let mut _47: u32;
|
|
let mut _48: u32;
|
|
let mut _49: u32;
|
|
let mut _50: (u32, u32);
|
|
let mut _51: (u32, u32);
|
|
let mut _52: u32;
|
|
let mut _53: u32;
|
|
let mut _54: (u32, u32);
|
|
let mut _55: u32;
|
|
let mut _56: (u32, bool);
|
|
let _57: ();
|
|
let mut _58: (u32, u32);
|
|
let mut _59: u32;
|
|
let mut _60: u32;
|
|
let mut _61: u32;
|
|
let mut _62: (u32, u32);
|
|
let mut _63: u32;
|
|
let mut _64: (u32, u32);
|
|
let mut _65: (u32, u32);
|
|
let mut _66: u32;
|
|
let mut _67: u32;
|
|
let mut _68: u32;
|
|
let mut _69: bool;
|
|
let mut _70: u32;
|
|
let mut _71: bool;
|
|
let mut _72: (u32, bool);
|
|
let mut _73: u32;
|
|
let mut _74: (u32, u32);
|
|
let mut _75: u32;
|
|
let mut _76: (u32, u32);
|
|
scope 1 {
|
|
debug field_pos => _4;
|
|
}
|
|
|
|
bb0: {
|
|
_7 = (_3.0: u32);
|
|
_8 = Eq(const 2_u32, const 0_u32);
|
|
assert(!move _8, "attempt to divide `{}` by zero", _7) -> [success: bb1, unwind continue];
|
|
}
|
|
|
|
bb1: {
|
|
_6 = Div(move _7, const 2_u32);
|
|
_11 = const _;
|
|
_10 = (_11.0: u32);
|
|
_12 = Eq(const 2_u32, const 0_u32);
|
|
assert(!move _12, "attempt to divide `{}` by zero", _10) -> [success: bb2, unwind continue];
|
|
}
|
|
|
|
bb2: {
|
|
_9 = Div(move _10, const 2_u32);
|
|
_5 = core::num::<impl u32>::saturating_sub(move _6, move _9) -> [return: bb3, unwind continue];
|
|
}
|
|
|
|
bb3: {
|
|
_15 = (_3.1: u32);
|
|
_16 = Eq(const 2_u32, const 0_u32);
|
|
assert(!move _16, "attempt to divide `{}` by zero", _15) -> [success: bb4, unwind continue];
|
|
}
|
|
|
|
bb4: {
|
|
_14 = Div(move _15, const 2_u32);
|
|
_19 = const _;
|
|
_18 = (_19.1: u32);
|
|
_20 = Eq(const 2_u32, const 0_u32);
|
|
assert(!move _20, "attempt to divide `{}` by zero", _18) -> [success: bb5, unwind continue];
|
|
}
|
|
|
|
bb5: {
|
|
_17 = Div(move _18, const 2_u32);
|
|
_13 = core::num::<impl u32>::saturating_sub(move _14, move _17) -> [return: bb6, unwind continue];
|
|
}
|
|
|
|
bb6: {
|
|
_4 = (move _5, move _13);
|
|
_24 = (_4.0: u32);
|
|
_23 = core::num::<impl u32>::saturating_sub(move _24, const _) -> [return: bb7, unwind continue];
|
|
}
|
|
|
|
bb7: {
|
|
_26 = (_4.1: u32);
|
|
_25 = core::num::<impl u32>::saturating_sub(move _26, const _) -> [return: bb8, unwind continue];
|
|
}
|
|
|
|
bb8: {
|
|
_22 = (move _23, move _25);
|
|
_30 = const _;
|
|
_29 = (_30.0: u32);
|
|
_32 = CheckedMul(const _, const 2_u32);
|
|
assert(!move (_32.1: bool), "attempt to compute `{} * {}`, which would overflow", const _, const 2_u32) -> [success: bb9, unwind continue];
|
|
}
|
|
|
|
bb9: {
|
|
_31 = move (_32.0: u32);
|
|
_28 = core::num::<impl u32>::saturating_add(move _29, move _31) -> [return: bb10, unwind continue];
|
|
}
|
|
|
|
bb10: {
|
|
_27 = (move _28, const _);
|
|
_21 = draw_rect(_2, _3, move _22, move _27, const 16711680_u32) -> [return: bb11, unwind continue];
|
|
}
|
|
|
|
bb11: {
|
|
_36 = (_4.0: u32);
|
|
_38 = const _;
|
|
_37 = (_38.0: u32);
|
|
_35 = core::num::<impl u32>::saturating_add(move _36, move _37) -> [return: bb12, unwind continue];
|
|
}
|
|
|
|
bb12: {
|
|
_39 = (_4.1: u32);
|
|
_34 = (move _35, move _39);
|
|
_42 = const _;
|
|
_41 = (_42.1: u32);
|
|
_40 = (const _, move _41);
|
|
_33 = draw_rect(_2, _3, move _34, move _40, const 65280_u32) -> [return: bb13, unwind continue];
|
|
}
|
|
|
|
bb13: {
|
|
_46 = (_4.0: u32);
|
|
_45 = core::num::<impl u32>::saturating_sub(move _46, const _) -> [return: bb14, unwind continue];
|
|
}
|
|
|
|
bb14: {
|
|
_48 = (_4.1: u32);
|
|
_50 = const _;
|
|
_49 = (_50.1: u32);
|
|
_47 = core::num::<impl u32>::saturating_add(move _48, move _49) -> [return: bb15, unwind continue];
|
|
}
|
|
|
|
bb15: {
|
|
_44 = (move _45, move _47);
|
|
_54 = const _;
|
|
_53 = (_54.0: u32);
|
|
_56 = CheckedMul(const _, const 2_u32);
|
|
assert(!move (_56.1: bool), "attempt to compute `{} * {}`, which would overflow", const _, const 2_u32) -> [success: bb16, unwind continue];
|
|
}
|
|
|
|
bb16: {
|
|
_55 = move (_56.0: u32);
|
|
_52 = core::num::<impl u32>::saturating_add(move _53, move _55) -> [return: bb17, unwind continue];
|
|
}
|
|
|
|
bb17: {
|
|
_51 = (move _52, const _);
|
|
_43 = draw_rect(_2, _3, move _44, move _51, const 16711935_u32) -> [return: bb18, unwind continue];
|
|
}
|
|
|
|
bb18: {
|
|
_60 = (_4.0: u32);
|
|
_59 = core::num::<impl u32>::saturating_sub(move _60, const _) -> [return: bb19, unwind continue];
|
|
}
|
|
|
|
bb19: {
|
|
_61 = (_4.1: u32);
|
|
_58 = (move _59, move _61);
|
|
_64 = const _;
|
|
_63 = (_64.1: u32);
|
|
_62 = (const _, move _63);
|
|
_57 = draw_rect(_2, _3, move _58, move _62, const 65535_u32) -> [return: bb20, unwind continue];
|
|
}
|
|
|
|
bb20: {
|
|
_68 = (_3.0: u32);
|
|
_69 = Eq(const 2_u32, const 0_u32);
|
|
assert(!move _69, "attempt to divide `{}` by zero", _68) -> [success: bb21, unwind continue];
|
|
}
|
|
|
|
bb21: {
|
|
_67 = Div(move _68, const 2_u32);
|
|
_71 = Eq(const 2_u32, const 0_u32);
|
|
assert(!move _71, "attempt to divide `{}` by zero", const _) -> [success: bb22, unwind continue];
|
|
}
|
|
|
|
bb22: {
|
|
_70 = Div(const _, const 2_u32);
|
|
_72 = CheckedSub(_67, _70);
|
|
assert(!move (_72.1: bool), "attempt to compute `{} - {}`, which would overflow", move _67, move _70) -> [success: bb23, unwind continue];
|
|
}
|
|
|
|
bb23: {
|
|
_66 = move (_72.0: u32);
|
|
_73 = (_4.1: u32);
|
|
_65 = (move _66, move _73);
|
|
_76 = const _;
|
|
_75 = (_76.1: u32);
|
|
_74 = (const _, move _75);
|
|
_0 = draw_rect(_2, _3, move _65, move _74, const 8355711_u32) -> [return: bb24, unwind continue];
|
|
}
|
|
|
|
bb24: {
|
|
return;
|
|
}
|
|
}
|
|
|
|
fn game::<impl at src/main.rs:174:5: 174:19>::render_ball(_1: &GameState, _2: &mut Buffer<'_, DisplayHandle<'_>, WindowHandle<'_>>, _3: (u32, u32)) -> () {
|
|
debug self => _1;
|
|
debug buf => _2;
|
|
debug win_size => _3;
|
|
let mut _0: ();
|
|
let _4: (u32, u32);
|
|
let mut _5: u32;
|
|
let mut _6: u32;
|
|
let mut _7: u32;
|
|
let mut _8: bool;
|
|
let mut _9: u32;
|
|
let mut _10: u32;
|
|
let mut _11: (u32, u32);
|
|
let mut _12: bool;
|
|
let mut _13: u32;
|
|
let mut _14: u32;
|
|
let mut _15: u32;
|
|
let mut _16: bool;
|
|
let mut _17: u32;
|
|
let mut _18: u32;
|
|
let mut _19: (u32, u32);
|
|
let mut _20: bool;
|
|
let mut _22: u32;
|
|
let mut _23: u32;
|
|
let mut _24: u32;
|
|
let mut _25: u32;
|
|
let mut _26: (u32, bool);
|
|
let mut _27: u32;
|
|
let mut _28: u32;
|
|
let mut _29: u32;
|
|
let mut _30: u32;
|
|
let mut _31: (u32, bool);
|
|
let _32: ();
|
|
let mut _33: (u32, u32);
|
|
let mut _34: u32;
|
|
let mut _35: (u32, bool);
|
|
let mut _36: u32;
|
|
let mut _37: (u32, bool);
|
|
scope 1 {
|
|
debug field_pos => _4;
|
|
let _21: (u32, u32);
|
|
scope 2 {
|
|
debug ball_render_pos => _21;
|
|
}
|
|
}
|
|
|
|
bb0: {
|
|
_7 = (_3.0: u32);
|
|
_8 = Eq(const 2_u32, const 0_u32);
|
|
assert(!move _8, "attempt to divide `{}` by zero", _7) -> [success: bb1, unwind continue];
|
|
}
|
|
|
|
bb1: {
|
|
_6 = Div(move _7, const 2_u32);
|
|
_11 = const _;
|
|
_10 = (_11.0: u32);
|
|
_12 = Eq(const 2_u32, const 0_u32);
|
|
assert(!move _12, "attempt to divide `{}` by zero", _10) -> [success: bb2, unwind continue];
|
|
}
|
|
|
|
bb2: {
|
|
_9 = Div(move _10, const 2_u32);
|
|
_5 = core::num::<impl u32>::saturating_sub(move _6, move _9) -> [return: bb3, unwind continue];
|
|
}
|
|
|
|
bb3: {
|
|
_15 = (_3.1: u32);
|
|
_16 = Eq(const 2_u32, const 0_u32);
|
|
assert(!move _16, "attempt to divide `{}` by zero", _15) -> [success: bb4, unwind continue];
|
|
}
|
|
|
|
bb4: {
|
|
_14 = Div(move _15, const 2_u32);
|
|
_19 = const _;
|
|
_18 = (_19.1: u32);
|
|
_20 = Eq(const 2_u32, const 0_u32);
|
|
assert(!move _20, "attempt to divide `{}` by zero", _18) -> [success: bb5, unwind continue];
|
|
}
|
|
|
|
bb5: {
|
|
_17 = Div(move _18, const 2_u32);
|
|
_13 = core::num::<impl u32>::saturating_sub(move _14, move _17) -> [return: bb6, unwind continue];
|
|
}
|
|
|
|
bb6: {
|
|
_4 = (move _5, move _13);
|
|
_24 = (((*_1).0: (u32, u32)).0: u32);
|
|
_25 = (_4.0: u32);
|
|
_26 = CheckedAdd(_24, _25);
|
|
assert(!move (_26.1: bool), "attempt to compute `{} + {}`, which would overflow", move _24, move _25) -> [success: bb7, unwind continue];
|
|
}
|
|
|
|
bb7: {
|
|
_23 = move (_26.0: u32);
|
|
_22 = core::num::<impl u32>::saturating_sub(move _23, const _) -> [return: bb8, unwind continue];
|
|
}
|
|
|
|
bb8: {
|
|
_29 = (((*_1).0: (u32, u32)).1: u32);
|
|
_30 = (_4.1: u32);
|
|
_31 = CheckedAdd(_29, _30);
|
|
assert(!move (_31.1: bool), "attempt to compute `{} + {}`, which would overflow", move _29, move _30) -> [success: bb9, unwind continue];
|
|
}
|
|
|
|
bb9: {
|
|
_28 = move (_31.0: u32);
|
|
_27 = core::num::<impl u32>::saturating_sub(move _28, const _) -> [return: bb10, unwind continue];
|
|
}
|
|
|
|
bb10: {
|
|
_21 = (move _22, move _27);
|
|
_35 = CheckedMul(const _, const 2_u32);
|
|
assert(!move (_35.1: bool), "attempt to compute `{} * {}`, which would overflow", const _, const 2_u32) -> [success: bb11, unwind continue];
|
|
}
|
|
|
|
bb11: {
|
|
_34 = move (_35.0: u32);
|
|
_37 = CheckedMul(const _, const 2_u32);
|
|
assert(!move (_37.1: bool), "attempt to compute `{} * {}`, which would overflow", const _, const 2_u32) -> [success: bb12, unwind continue];
|
|
}
|
|
|
|
bb12: {
|
|
_36 = move (_37.0: u32);
|
|
_33 = (move _34, move _36);
|
|
_32 = draw_rect(_2, _3, _21, move _33, const 16777215_u32) -> [return: bb13, unwind continue];
|
|
}
|
|
|
|
bb13: {
|
|
return;
|
|
}
|
|
}
|
|
|
|
fn game::<impl at src/main.rs:174:5: 174:19>::render_paddles(_1: &GameState, _2: &mut Buffer<'_, DisplayHandle<'_>, WindowHandle<'_>>, _3: (u32, u32)) -> () {
|
|
debug self => _1;
|
|
debug buf => _2;
|
|
debug win_size => _3;
|
|
let mut _0: ();
|
|
let mut _4: !;
|
|
|
|
bb0: {
|
|
_4 = core::panicking::panic(const "not yet implemented") -> unwind continue;
|
|
}
|
|
}
|
|
|
|
fn game::<impl at src/main.rs:174:5: 174:19>::render_paddle(_1: &GameState, _2: &mut Buffer<'_, DisplayHandle<'_>, WindowHandle<'_>>, _3: (u32, u32)) -> () {
|
|
debug self => _1;
|
|
debug buf => _2;
|
|
debug win_size => _3;
|
|
let mut _0: ();
|
|
let mut _4: !;
|
|
|
|
bb0: {
|
|
_4 = core::panicking::panic(const "not yet implemented") -> unwind continue;
|
|
}
|
|
}
|
|
|
|
fn game::<impl at src/main.rs:174:5: 174:19>::render_scores(_1: &GameState, _2: &mut Buffer<'_, DisplayHandle<'_>, WindowHandle<'_>>, _3: (u32, u32)) -> () {
|
|
debug self => _1;
|
|
debug buf => _2;
|
|
debug win_size => _3;
|
|
let mut _0: ();
|
|
let mut _4: !;
|
|
|
|
bb0: {
|
|
_4 = core::panicking::panic(const "not yet implemented") -> unwind continue;
|
|
}
|
|
}
|
|
|
|
fn draw_rect(_1: &mut Buffer<'_, DisplayHandle<'_>, WindowHandle<'_>>, _2: (u32, u32), _3: (u32, u32), _4: (u32, u32), _5: u32) -> () {
|
|
debug buf => _1;
|
|
debug buf_size => _2;
|
|
debug pos => _3;
|
|
debug size => _4;
|
|
debug color => _5;
|
|
let mut _0: ();
|
|
let mut _6: std::ops::Range<u32>;
|
|
let mut _7: std::ops::Range<u32>;
|
|
let mut _8: u32;
|
|
let mut _9: u32;
|
|
let mut _10: u32;
|
|
let mut _11: u32;
|
|
let mut _12: (u32, bool);
|
|
let mut _13: std::ops::Range<u32>;
|
|
let mut _14: std::option::Option<u32>;
|
|
let mut _15: &mut std::ops::Range<u32>;
|
|
let mut _16: isize;
|
|
let mut _18: std::ops::Range<u32>;
|
|
let mut _19: std::ops::Range<u32>;
|
|
let mut _20: u32;
|
|
let mut _21: u32;
|
|
let mut _22: u32;
|
|
let mut _23: u32;
|
|
let mut _24: (u32, bool);
|
|
let mut _26: std::option::Option<u32>;
|
|
let mut _27: &mut std::ops::Range<u32>;
|
|
let mut _28: isize;
|
|
let mut _31: usize;
|
|
let mut _32: usize;
|
|
let mut _33: usize;
|
|
let mut _34: u32;
|
|
let mut _35: (usize, bool);
|
|
let mut _36: usize;
|
|
let mut _37: (usize, bool);
|
|
let mut _38: &mut [u32];
|
|
let mut _39: usize;
|
|
let mut _40: bool;
|
|
scope 1 {
|
|
debug iter => _13;
|
|
let _17: u32;
|
|
scope 2 {
|
|
debug y => _17;
|
|
let mut _25: std::ops::Range<u32>;
|
|
scope 3 {
|
|
debug iter => _25;
|
|
let _29: u32;
|
|
scope 4 {
|
|
debug x => _29;
|
|
let _30: usize;
|
|
scope 5 {
|
|
debug index => _30;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
bb0: {
|
|
_8 = (_3.1: u32);
|
|
_10 = (_3.1: u32);
|
|
_11 = (_4.1: u32);
|
|
_12 = CheckedAdd(_10, _11);
|
|
assert(!move (_12.1: bool), "attempt to compute `{} + {}`, which would overflow", move _10, move _11) -> [success: bb1, unwind continue];
|
|
}
|
|
|
|
bb1: {
|
|
_9 = move (_12.0: u32);
|
|
_7 = std::ops::Range::<u32> { start: move _8, end: move _9 };
|
|
_6 = <std::ops::Range<u32> as IntoIterator>::into_iter(move _7) -> [return: bb2, unwind continue];
|
|
}
|
|
|
|
bb2: {
|
|
_13 = move _6;
|
|
goto -> bb3;
|
|
}
|
|
|
|
bb3: {
|
|
_15 = &mut _13;
|
|
_14 = <std::ops::Range<u32> as Iterator>::next(_15) -> [return: bb4, unwind continue];
|
|
}
|
|
|
|
bb4: {
|
|
_16 = discriminant(_14);
|
|
switchInt(move _16) -> [0: bb6, 1: bb5, otherwise: bb16];
|
|
}
|
|
|
|
bb5: {
|
|
_17 = ((_14 as Some).0: u32);
|
|
_20 = (_3.0: u32);
|
|
_22 = (_3.0: u32);
|
|
_23 = (_4.0: u32);
|
|
_24 = CheckedAdd(_22, _23);
|
|
assert(!move (_24.1: bool), "attempt to compute `{} + {}`, which would overflow", move _22, move _23) -> [success: bb7, unwind continue];
|
|
}
|
|
|
|
bb6: {
|
|
return;
|
|
}
|
|
|
|
bb7: {
|
|
_21 = move (_24.0: u32);
|
|
_19 = std::ops::Range::<u32> { start: move _20, end: move _21 };
|
|
_18 = <std::ops::Range<u32> as IntoIterator>::into_iter(move _19) -> [return: bb8, unwind continue];
|
|
}
|
|
|
|
bb8: {
|
|
_25 = move _18;
|
|
goto -> bb9;
|
|
}
|
|
|
|
bb9: {
|
|
_27 = &mut _25;
|
|
_26 = <std::ops::Range<u32> as Iterator>::next(_27) -> [return: bb10, unwind continue];
|
|
}
|
|
|
|
bb10: {
|
|
_28 = discriminant(_26);
|
|
switchInt(move _28) -> [0: bb3, 1: bb11, otherwise: bb16];
|
|
}
|
|
|
|
bb11: {
|
|
_29 = ((_26 as Some).0: u32);
|
|
_32 = _17 as usize (IntToInt);
|
|
_34 = (_2.0: u32);
|
|
_33 = move _34 as usize (IntToInt);
|
|
_35 = CheckedMul(_32, _33);
|
|
assert(!move (_35.1: bool), "attempt to compute `{} * {}`, which would overflow", move _32, move _33) -> [success: bb12, unwind continue];
|
|
}
|
|
|
|
bb12: {
|
|
_31 = move (_35.0: usize);
|
|
_36 = _29 as usize (IntToInt);
|
|
_37 = CheckedAdd(_31, _36);
|
|
assert(!move (_37.1: bool), "attempt to compute `{} + {}`, which would overflow", move _31, move _36) -> [success: bb13, unwind continue];
|
|
}
|
|
|
|
bb13: {
|
|
_30 = move (_37.0: usize);
|
|
_38 = <Buffer<'_, DisplayHandle<'_>, WindowHandle<'_>> as DerefMut>::deref_mut(_1) -> [return: bb14, unwind continue];
|
|
}
|
|
|
|
bb14: {
|
|
_39 = Len((*_38));
|
|
_40 = Lt(_30, _39);
|
|
assert(move _40, "index out of bounds: the length is {} but the index is {}", move _39, _30) -> [success: bb15, unwind continue];
|
|
}
|
|
|
|
bb15: {
|
|
(*_38)[_30] = _5;
|
|
goto -> bb9;
|
|
}
|
|
|
|
bb16: {
|
|
unreachable;
|
|
}
|
|
}
|
|
|
|
fn CollisionCheck(_1: HorizontalCollisionCheck, _2: VerticalCollisionCheck) -> CollisionCheck {
|
|
let mut _0: game::CollisionCheck;
|
|
|
|
bb0: {
|
|
_0 = CollisionCheck(move _1, move _2);
|
|
return;
|
|
}
|
|
}
|
|
|
|
// MIR FOR CTFE
|
|
fn CollisionCheck(_1: HorizontalCollisionCheck, _2: VerticalCollisionCheck) -> CollisionCheck {
|
|
let mut _0: game::CollisionCheck;
|
|
|
|
bb0: {
|
|
_0 = CollisionCheck(move _1, move _2);
|
|
return;
|
|
}
|
|
}
|