use common::Point2D;
+use hashmap;
use common::Radians;
use sdl2::HapticSubsystem;
use sdl2::JoystickSubsystem;
#[derive(Debug, Default)]
pub struct Button {
+ id: u8,
pub time_pressed: Duration,
pub time_released: Duration,
pub is_pressed: bool,
}
impl Button {
- fn update(&mut self, device: &Joystick, dt: Duration, btn: u8) {
+ fn update(&mut self, device: &Joystick, dt: Duration) {
self.was_pressed = self.is_pressed;
- self.is_pressed = match device.button(btn as u32) {
+ self.is_pressed = match device.button(self.id as u32) {
Ok(true) => {
if !self.was_pressed {
self.time_pressed = 0.seconds();
self.time_released += dt;
false
}
- Err(_) => { panic!("invalid button {}", btn) }
+ Err(_) => { panic!("invalid button {}", self.id) }
}
}
}
#[derive(Debug, Default)]
pub struct Axis {
+ id: u8,
pub val: f32,
}
impl Axis {
#[allow(dead_code)]
- fn update(&mut self, device: &Joystick, _dt: Duration, axis: u8) {
- self.val = match device.axis(axis as u32) {
+ fn update(&mut self, device: &Joystick, _dt: Duration) {
+ self.val = match device.axis(self.id as u32) {
Ok(val) => val as f32 / 32768.0,
- Err(_) => panic!("invalid axis {}", axis),
+ Err(_) => panic!("invalid axis {}", self.id),
}
}
}
#[derive(Debug, Default)]
pub struct Stick {
+ idx: u8,
+ idy: u8,
pub x: f32,
pub y: f32,
pub a: Radians,
}
impl Stick {
- fn update(&mut self, device: &Joystick, _dt: Duration, x_axis: u8, y_axis: u8) {
- self.x = match device.axis(x_axis as u32) {
+ fn update(&mut self, device: &Joystick, _dt: Duration) {
+ self.x = match device.axis(self.idx as u32) {
Ok(val) => val as f32 / 32768.0,
- Err(_) => panic!("invalid x axis {}", x_axis),
+ Err(_) => panic!("invalid x axis {}", self.idx),
};
- self.y = match device.axis(y_axis as u32) {
+ self.y = match device.axis(self.idy as u32) {
Ok(val) => val as f32 / 32768.0,
- Err(_) => panic!("invalid y axis {}", y_axis),
+ Err(_) => panic!("invalid y axis {}", self.idy),
};
self.a = Radians(self.y.atan2(self.x) as f64);
self.len = {
}
}
+#[derive(Eq, PartialEq, Hash)]
+enum DeviceControls {
+ AxisLX,
+ AxisLY,
+ AxisRX,
+ AxisRY,
+ AxisL2,
+ AxisR2,
+ ButtonA,
+ ButtonB,
+ ButtonY,
+ ButtonX,
+ ButtonSelect,
+ ButtonStart,
+ ButtonHome,
+ ButtonL3,
+ ButtonR3,
+ ButtonL1,
+ ButtonR1,
+ ButtonL2,
+ ButtonR2,
+ ButtonUp,
+ ButtonDown,
+ ButtonLeft,
+ ButtonRight,
+}
+
+#[derive(Eq, PartialEq, Hash)]
+enum ActionControls {
+ MovementX,
+ MovementY,
+ AimX,
+ AimY,
+ Jump,
+ Shoot,
+ Start,
+}
+
//#[derive(Debug)]
pub struct Controller {
pub device: Joystick,
impl Controller {
pub fn new(device: Joystick, haptic: Option<Rc<RefCell<Haptic>>>) -> Self {
- Controller {
+ let action_map = get_action_mapping();
+ let device_map = get_device_mapping(&device.name());
+ let mut ctrl = Controller {
device,
haptic,
mov: Default::default(),
jump: Default::default(),
start: Default::default(),
shoot: Default::default(),
- }
+ };
+ ctrl.set_mapping(&action_map, &device_map);
+ ctrl
+ }
+
+ fn set_mapping(&mut self, action: &HashMap<ActionControls, DeviceControls>, device: &HashMap<DeviceControls, u8>) {
+ self.mov.idx = *action.get(&ActionControls::MovementX).map(|i| device.get(i)).flatten().unwrap();
+ self.mov.idy = *action.get(&ActionControls::MovementY).map(|i| device.get(i)).flatten().unwrap();
+ self.aim.idx = *action.get(&ActionControls::AimX).map(|i| device.get(i)).flatten().unwrap();
+ self.aim.idy = *action.get(&ActionControls::AimY).map(|i| device.get(i)).flatten().unwrap();
+ self.jump.id = *action.get(&ActionControls::Jump).map(|i| device.get(i)).flatten().unwrap();
+ self.shoot.id = *action.get(&ActionControls::Shoot).map(|i| device.get(i)).flatten().unwrap();
+ self.start.id = *action.get(&ActionControls::Start).map(|i| device.get(i)).flatten().unwrap();
}
pub fn update(&mut self, dt: Duration) {
- 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
+ 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]
}
}
+fn get_action_mapping() -> HashMap<ActionControls, DeviceControls> {
+ hashmap!(
+ ActionControls::MovementX => DeviceControls::AxisLX,
+ ActionControls::MovementY => DeviceControls::AxisLY,
+ ActionControls::AimX => DeviceControls::AxisRX,
+ ActionControls::AimY => DeviceControls::AxisRY,
+ ActionControls::Jump => DeviceControls::ButtonL1,
+ ActionControls::Shoot => DeviceControls::ButtonR1,
+ ActionControls::Start => DeviceControls::ButtonStart
+ )
+}
+
+fn get_device_mapping(device_name: &str) -> HashMap<DeviceControls, u8> {
+ match device_name {
+ "Sony PLAYSTATION(R)3 Controller" => hashmap!(
+ DeviceControls::AxisLX => 0,
+ DeviceControls::AxisLY => 1,
+ DeviceControls::AxisRX => 3,
+ DeviceControls::AxisRY => 4,
+ DeviceControls::AxisL2 => 2,
+ DeviceControls::AxisR2 => 5,
+ DeviceControls::ButtonA => 0,
+ DeviceControls::ButtonB => 1,
+ DeviceControls::ButtonY => 3,
+ DeviceControls::ButtonX => 2,
+ DeviceControls::ButtonSelect => 8,
+ DeviceControls::ButtonStart => 9,
+ DeviceControls::ButtonHome => 10,
+ DeviceControls::ButtonL3 => 11,
+ DeviceControls::ButtonR3 => 12,
+ DeviceControls::ButtonL1 => 4,
+ DeviceControls::ButtonR1 => 5,
+ DeviceControls::ButtonL2 => 6,
+ DeviceControls::ButtonR2 => 7,
+ DeviceControls::ButtonUp => 13,
+ DeviceControls::ButtonDown => 14,
+ DeviceControls::ButtonLeft => 15,
+ DeviceControls::ButtonRight => 16
+ ),
+ _ => panic!("No controller mapping for device '{}'", device_name)
+ }
+}
+
//#[derive(Debug)]
pub struct ControllerManager {
pub joystick: JoystickSubsystem,
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::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) }
_ => {}
}
}
Dolda2000 GitWeb / kaka / rust-sdl-test.git / blobdiff