X-Git-Url: http://dolda2000.com/gitweb/?a=blobdiff_plain;f=src%2Fcore%2Fcontroller.rs;h=2373cb5e5a3b97eb5e5fb4e22f7ceae29b8c20f3;hb=b1002380f9a0de4510043b09d15fec4590365ab0;hp=127c3096d470b4f852831d94d9e6e4f07299cc00;hpb=bf7b5671bb386ccd3d325ae3dea33046342d129c;p=kaka%2Frust-sdl-test.git diff --git a/src/core/controller.rs b/src/core/controller.rs index 127c309..2373cb5 100644 --- a/src/core/controller.rs +++ b/src/core/controller.rs @@ -1,107 +1,116 @@ -use sdl2::JoystickSubsystem; -use common::Nanoseconds; -use common::Radians; -use common::Point2D; +use geometry::{Angle, ToAngle, Point}; +use sdl2::GameControllerSubsystem; use sdl2::HapticSubsystem; +use sdl2::controller::{GameController, Axis as SDLAxis, Button as SDLButton}; use sdl2::event::Event; use sdl2::haptic::Haptic; -use sdl2::joystick::Joystick; use std::cell::RefCell; use std::collections::HashMap; use std::rc::Rc; +use time::{Duration, prelude::*}; +use {hashmap, point}; -#[derive(Debug, Default)] +#[derive(Debug)] pub struct Button { - pub time_pressed: Nanoseconds, - pub time_released: Nanoseconds, + id: SDLButton, + pub time_pressed: Duration, + pub time_released: Duration, pub is_pressed: bool, pub was_pressed: bool, pub toggle: bool, } impl Button { - fn update(&mut self, device: &Joystick, dt: Nanoseconds, btn: u8) { + pub fn new(id: SDLButton) -> Self { + Button { + id, + time_pressed: Duration::zero(), + time_released: Duration::zero(), + is_pressed: false, + was_pressed: false, + toggle: false, + } + } + + fn update(&mut self, device: &GameController, dt: Duration) { self.was_pressed = self.is_pressed; - self.is_pressed = match device.button(btn as u32) { - Ok(true) => { + self.is_pressed = match device.button(self.id) { + true => { if !self.was_pressed { - self.time_pressed = 0; + self.time_pressed = 0.seconds(); self.toggle = !self.toggle; } self.time_pressed += dt; true } - Ok(false) => { + false => { if self.was_pressed { - self.time_released = 0; + self.time_released = 0.seconds(); } self.time_released += dt; false } - Err(_) => { panic!("invalid button {}", btn) } } } } -#[derive(Debug, Default)] +#[derive(Debug)] pub struct Axis { + id: SDLAxis, pub val: f32, } impl Axis { #[allow(dead_code)] - fn update(&mut self, device: &Joystick, _dt: Nanoseconds, axis: u8) { - self.val = match device.axis(axis as u32) { - Ok(val) => val as f32 / 32768.0, - Err(_) => panic!("invalid axis {}", axis), - } + fn update(&mut self, device: &GameController, _dt: Duration) { + self.val = device.axis(self.id) as f32 / 32768.0; } } -#[derive(Debug, Default)] +#[derive(Debug)] pub struct Stick { + id: (SDLAxis, SDLAxis), pub x: f32, pub y: f32, - pub a: Radians, - pub len: f32, + pub a: Angle, } impl Stick { - fn update(&mut self, device: &Joystick, _dt: Nanoseconds, x_axis: u8, y_axis: u8) { - self.x = match device.axis(x_axis as u32) { - Ok(val) => val as f32 / 32768.0, - Err(_) => panic!("invalid x axis {}", x_axis), - }; - self.y = match device.axis(y_axis as u32) { - Ok(val) => val as f32 / 32768.0, - Err(_) => panic!("invalid y axis {}", y_axis), - }; - self.a = Radians(self.y.atan2(self.x) as f64); - self.len = { - let x = (self.x / self.y).abs().min(1.0); - let y = (self.y / self.x).abs().min(1.0); - (self.x.powi(2) + self.y.powi(2)).sqrt() / (x.powi(2) + y.powi(2)).sqrt() + pub fn new(idx: SDLAxis, idy: SDLAxis) -> Self { + Stick { + id: (idx, idy), + x: 0.0, + y: 0.0, + a: 0.radians(), } } - #[inline(always)] #[allow(dead_code)] fn up(&self) -> bool { self.y > 0.99 } - #[inline(always)] #[allow(dead_code)] fn down(&self) -> bool { self.y < -0.99 } - #[inline(always)] #[allow(dead_code)] fn left(&self) -> bool { self.x < -0.99 } - #[inline(always)] #[allow(dead_code)] fn right(&self) -> bool { self.x > 0.99 } + fn update(&mut self, device: &GameController, _dt: Duration) { + self.x = device.axis(self.id.0) as f32 / 32768.0; + self.y = device.axis(self.id.1) as f32 / 32768.0; + self.a = point!(self.x as f64, self.y as f64).to_angle(); + } - pub fn to_point(&self) -> Point2D { - Point2D { - x: self.x as f64, - y: self.y as f64, - } + #[inline(always)] #[allow(dead_code)] pub fn up(&self) -> bool { self.y < -0.99 } + #[inline(always)] #[allow(dead_code)] pub fn down(&self) -> bool { self.y > 0.99 } + #[inline(always)] #[allow(dead_code)] pub fn left(&self) -> bool { self.x < -0.99 } + #[inline(always)] #[allow(dead_code)] pub fn right(&self) -> bool { self.x > 0.99 } + + pub fn to_axis_point(&self) -> Point { + point!(self.x as f64, self.y as f64) } - pub fn to_adjusted_point(&self) -> Point2D { - Point2D::from(self.a) * self.len as f64 + pub fn to_point(&self) -> Point { + let p = point!(self.x as f64, self.y as f64); + if p.length() > 1.0 { + p.normalized() + } else { + p + } } } -impl From<&Stick> for Point2D { +impl From<&Stick> for Point { fn from(item: &Stick) -> Self { Self { x: item.x as f64, @@ -116,9 +125,21 @@ impl From<&Stick> for (f64, f64) { } } +#[derive(Eq, PartialEq, Hash)] +enum ActionControls { + MovementX, + MovementY, + AimX, + AimY, + Jump, + Shoot, + Start, +} +use self::ActionControls::*; + //#[derive(Debug)] pub struct Controller { - pub device: Joystick, + pub device: GameController, haptic: Option>>, pub mov: Stick, @@ -129,46 +150,80 @@ pub struct Controller { } impl Controller { - pub fn new(device: Joystick, haptic: Option>>) -> Self { - Controller { + pub fn new(device: GameController, haptic: Option>>) -> Self { + let map = get_action_mapping(); + let mut ctrl = Controller { device, haptic, - mov: Default::default(), - aim: Default::default(), - jump: Default::default(), - start: Default::default(), - shoot: Default::default(), - } + mov: Stick::new(*map.axes.get(&MovementX).unwrap(), *map.axes.get(&MovementY).unwrap()), + aim: Stick::new(*map.axes.get(&AimX).unwrap(), *map.axes.get(&AimY).unwrap()), + jump: Button::new(*map.buttons.get(&Jump).unwrap()), + start: Button::new(*map.buttons.get(&Start).unwrap()), + shoot: Button::new(*map.buttons.get(&Shoot).unwrap()), + }; + ctrl.set_mapping(&map); + ctrl + } + + fn set_mapping(&mut self, map: &ActionMapping) { + self.mov.id.0 = *map.axes.get(&MovementX).unwrap(); + self.mov.id.1 = *map.axes.get(&MovementY).unwrap(); + self.aim.id.0 = *map.axes.get(&AimX).unwrap(); + self.aim.id.1 = *map.axes.get(&AimY).unwrap(); + self.jump.id = *map.buttons.get(&Jump).unwrap(); + self.shoot.id = *map.buttons.get(&Shoot).unwrap(); + self.start.id = *map.buttons.get(&Start).unwrap(); } - pub fn update(&mut self, dt: Nanoseconds) { - self.mov.update(&self.device, dt, 0, 1); // left stick - self.aim.update(&self.device, dt, 3, 4); // right stick - self.jump.update(&self.device, dt, 4); // left shoulder - self.shoot.update(&self.device, dt, 5); // right shoulder - self.start.update(&self.device, dt, 9); // start + pub fn update(&mut self, dt: Duration) { + self.mov.update(&self.device, dt); + self.aim.update(&self.device, dt); + self.jump.update(&self.device, dt); + self.shoot.update(&self.device, dt); + self.start.update(&self.device, dt); } /// strength [0 - 1] - pub fn rumble(&self, strength: f32, duration_ms: u32) { + pub fn rumble(&self, strength: f32, duration: Duration) { if let Some(h) = &self.haptic { - h.borrow_mut().rumble_play(strength, duration_ms); + h.borrow_mut().rumble_play(strength, duration.whole_milliseconds() as u32); } } } +struct ActionMapping { + axes: HashMap, + buttons: HashMap, +} + +fn get_action_mapping() -> ActionMapping { + ActionMapping { + axes: hashmap!( + MovementX => SDLAxis::LeftX, + MovementY => SDLAxis::LeftY, + AimX => SDLAxis::RightX, + AimY => SDLAxis::RightY + ), + buttons: hashmap!( + Jump => SDLButton::A, + Shoot => SDLButton::RightShoulder, + Start => SDLButton::Start + ) + } +} + //#[derive(Debug)] pub struct ControllerManager { - pub joystick: JoystickSubsystem, + pub subsystem: GameControllerSubsystem, haptic: Rc, pub controllers: HashMap>>, } impl ControllerManager { - pub fn new(joystick: JoystickSubsystem, haptic: HapticSubsystem) -> Self { - joystick.set_event_state(true); + pub fn new(subsystem: GameControllerSubsystem, haptic: HapticSubsystem) -> Self { + subsystem.set_event_state(true); let mut c = ControllerManager { - joystick, + subsystem, haptic: Rc::new(haptic), controllers: HashMap::new(), }; @@ -177,29 +232,29 @@ impl ControllerManager { } fn init(&mut self) { - for i in 0..self.joystick.num_joysticks().unwrap() { + for i in 0..self.subsystem.num_joysticks().unwrap() { self.add_device(i); } } - pub fn update(&mut self, dt: Nanoseconds) { + pub fn update(&mut self, dt: Duration) { self.controllers.iter().for_each(|(_, v)| v.borrow_mut().update(dt)); } pub fn handle_event(&mut self, event: &Event) { match event { - Event::JoyDeviceAdded { which, .. } => { self.add_device(*which) } - Event::JoyDeviceRemoved { which, .. } => { self.remove_device(*which) } - Event::JoyButtonDown { which, button_idx, .. } => { println!("device {} button {} down!", which, button_idx) } - Event::JoyButtonUp { which, button_idx, .. } => { println!("device {} button {} up!", which, button_idx) } - Event::JoyAxisMotion { which, axis_idx, .. } => { println!("device {} axis motion {}!", which, axis_idx) } + Event::ControllerDeviceAdded { which, .. } => { self.add_device(*which) } + Event::ControllerDeviceRemoved { which, .. } => { self.remove_device(*which) } + // Event::ControllerButtonDown { which, button_idx, .. } => { println!("device {} button {} down!", which, button_idx) } + // Event::ControllerButtonUp { which, button_idx, .. } => { println!("device {} button {} up!", which, button_idx) } + // Event::ControllerAxisMotion { which, axis_idx, .. } => { println!("device {} axis motion {}!", which, axis_idx) } _ => {} } } fn add_device(&mut self, id: u32) { println!("device added ({})!", id); - let mut device = self.joystick.open(id).unwrap(); + let mut device = self.subsystem.open(id).unwrap(); println!("opened {}", device.name()); /*