[kaka/rust-sdl-test.git] / src / core / controller.rs

use common::Point2D;
use {hashmap, point};
use common::Radians;
use sdl2::HapticSubsystem;
use sdl2::JoystickSubsystem;
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::*};

#[derive(Debug, Default)]
pub struct Button {
    id: u8,
    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: Duration) {
	self.was_pressed = self.is_pressed;
	self.is_pressed = match device.button(self.id as u32) {
	    Ok(true) => {
		if !self.was_pressed {
		    self.time_pressed = 0.seconds();
		    self.toggle = !self.toggle;
		}
		self.time_pressed += dt;
		true
	    }
	    Ok(false) => {
		if self.was_pressed {
		    self.time_released = 0.seconds();
		}
		self.time_released += dt;
		false
	    }
	    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) {
	self.val = match device.axis(self.id as u32) {
	    Ok(val) => val as f32 / 32768.0,
	    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) {
	self.x = match device.axis(self.idx as u32) {
	    Ok(val) => val as f32 / 32768.0,
	    Err(_) => panic!("invalid x axis {}", self.idx),
	};
	self.y = match device.axis(self.idy as u32) {
	    Ok(val) => val as f32 / 32768.0,
	    Err(_) => panic!("invalid y axis {}", self.idy),
	};
	self.a = Radians(self.y.atan2(self.x) 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) -> Point2D<f64> {
	point!(self.x as f64, self.y as f64)
    }

    pub fn to_point(&self) -> Point2D<f64> {
	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<f64> {
    fn from(item: &Stick) -> Self {
	Self {
	    x: item.x as f64,
	    y: item.y as f64,
	}
    }
}

impl From<&Stick> for (f64, f64) {
    fn from(item: &Stick) -> Self {
	(item.x as f64, item.y as f64)
    }
}

#[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,
    haptic: Option<Rc<RefCell<Haptic>>>,

    pub mov: Stick,
    pub aim: Stick,
    pub jump: Button,
    pub start: Button,
    pub shoot: Button,
}

impl Controller {
    pub fn new(device: Joystick, haptic: Option<Rc<RefCell<Haptic>>>) -> Self {
	let action_map = get_action_mapping();
	let device_map = get_device_mapping(&device.name());
	let mut ctrl = Controller {
	    device,
	    haptic,
	    mov: Default::default(),
	    aim: 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);
	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: Duration) {
	if let Some(h) = &self.haptic {
	    h.borrow_mut().rumble_play(strength, duration.whole_milliseconds() as u32);
	}
    }
}

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::ButtonA,
	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,
    haptic: Rc<HapticSubsystem>,
    pub controllers: HashMap<u32, Rc<RefCell<Controller>>>,
}

impl ControllerManager {
    pub fn new(joystick: JoystickSubsystem, haptic: HapticSubsystem) -> Self {
	joystick.set_event_state(true);
	let mut c = ControllerManager {
	    joystick,
	    haptic: Rc::new(haptic),
	    controllers: HashMap::new(),
	};
	c.init();
	c
    }

    fn init(&mut self) {
	for i in 0..self.joystick.num_joysticks().unwrap() {
	    self.add_device(i);
	}
    }

    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) }
	    _ => {}
	}
    }

    fn add_device(&mut self, id: u32) {
	println!("device added ({})!", id);
	let mut device = self.joystick.open(id).unwrap();
	println!("opened {}", device.name());

	/*
	note about set_rumble (for dualshock 3 at least):
	the active range for the low frequency is from 65536/4 to 65536 and escalates in large steps throughout the range
	the active range for the high frequency is from 256 to 65536 and effect is the same throughout the whole range
	 */
	let haptic = match device.set_rumble(0, 256, 100) {
	    Ok(_) => self.haptic.open_from_joystick_id(id).ok(),
	    Err(_) => None
	};

	if self.controllers.contains_key(&id) {
	    return;
	}

	let detached = self.controllers.values().find(|c| !c.borrow().device.attached());
	match detached {
	    Some(c) => {
		let mut c = c.borrow_mut();
		c.device = device;
		c.haptic = haptic.map(|h| Rc::new(RefCell::new(h)));
	    }
	    None => {
		let c = Rc::new(RefCell::new(Controller::new(device, haptic.map(|h| Rc::new(RefCell::new(h))))));
		self.controllers.insert(id, c);
	    }
	};
    }

    fn remove_device(&mut self, id: i32) {
	println!("device removed ({})!", id);
	// TODO
    }
}
Commit	Line	Data
bf7b5671	1	use common::Point2D;
eca25591	2	use {hashmap, point};
902b2b31	3	use common::Radians;
3f344b63	4	use sdl2::HapticSubsystem;
902b2b31	5	use sdl2::JoystickSubsystem;
3f344b63	6	use sdl2::event::Event;
bf7b5671 TW	7	use sdl2::haptic::Haptic;
	8	use sdl2::joystick::Joystick;
	9	use std::cell::RefCell;
	10	use std::collections::HashMap;
3f344b63	11	use std::rc::Rc;
902b2b31	12	use time::{Duration, prelude::*};
3f344b63	13
bf7b5671 TW	14	#[derive(Debug, Default)]
bf7b5671 TW	15	pub struct Button {
5d731022	16	id: u8,
902b2b31 TW	17	pub time_pressed: Duration,
902b2b31 TW	18	pub time_released: Duration,
bf7b5671 TW	19	pub is_pressed: bool,
	20	pub was_pressed: bool,
	21	pub toggle: bool,
	22	}
	23
	24	impl Button {
5d731022	25	fn update(&mut self, device: &Joystick, dt: Duration) {
bf7b5671	26	self.was_pressed = self.is_pressed;
5d731022	27	self.is_pressed = match device.button(self.id as u32) {
bf7b5671 TW	28	Ok(true) => {
bf7b5671 TW	29	if !self.was_pressed {
902b2b31	30	self.time_pressed = 0.seconds();
bf7b5671 TW	31	self.toggle = !self.toggle;
	32	}
	33	self.time_pressed += dt;
	34	true
	35	}
	36	Ok(false) => {
	37	if self.was_pressed {
902b2b31	38	self.time_released = 0.seconds();
bf7b5671 TW	39	}
	40	self.time_released += dt;
	41	false
	42	}
5d731022	43	Err(_) => { panic!("invalid button {}", self.id) }
bf7b5671 TW	44	}
	45	}
	46	}
	47
	48	#[derive(Debug, Default)]
	49	pub struct Axis {
5d731022	50	id: u8,
bf7b5671 TW	51	pub val: f32,
	52	}
	53
	54	impl Axis {
	55	#[allow(dead_code)]
5d731022 TW	56	fn update(&mut self, device: &Joystick, _dt: Duration) {
5d731022 TW	57	self.val = match device.axis(self.id as u32) {
bf7b5671	58	Ok(val) => val as f32 / 32768.0,
5d731022	59	Err(_) => panic!("invalid axis {}", self.id),
bf7b5671 TW	60	}
	61	}
	62	}
	63
	64	#[derive(Debug, Default)]
	65	pub struct Stick {
5d731022 TW	66	idx: u8,
5d731022 TW	67	idy: u8,
bf7b5671 TW	68	pub x: f32,
	69	pub y: f32,
	70	pub a: Radians,
bf7b5671 TW	71	}
	72
	73	impl Stick {
5d731022 TW	74	fn update(&mut self, device: &Joystick, _dt: Duration) {
5d731022 TW	75	self.x = match device.axis(self.idx as u32) {
bf7b5671	76	Ok(val) => val as f32 / 32768.0,
5d731022	77	Err(_) => panic!("invalid x axis {}", self.idx),
bf7b5671	78	};
5d731022	79	self.y = match device.axis(self.idy as u32) {
bf7b5671	80	Ok(val) => val as f32 / 32768.0,
5d731022	81	Err(_) => panic!("invalid y axis {}", self.idy),
bf7b5671 TW	82	};
bf7b5671 TW	83	self.a = Radians(self.y.atan2(self.x) as f64);
bf7b5671 TW	84	}
bf7b5671 TW	85
3fd8761b TW	86	#[inline(always)] #[allow(dead_code)] pub fn up(&self) -> bool { self.y < -0.99 }
	87	#[inline(always)] #[allow(dead_code)] pub fn down(&self) -> bool { self.y > 0.99 }
	88	#[inline(always)] #[allow(dead_code)] pub fn left(&self) -> bool { self.x < -0.99 }
	89	#[inline(always)] #[allow(dead_code)] pub fn right(&self) -> bool { self.x > 0.99 }
bf7b5671	90
eca25591 TW	91	pub fn to_axis_point(&self) -> Point2D<f64> {
eca25591 TW	92	point!(self.x as f64, self.y as f64)
bf7b5671 TW	93	}
bf7b5671 TW	94
eca25591 TW	95	pub fn to_point(&self) -> Point2D<f64> {
	96	let p = point!(self.x as f64, self.y as f64);
	97	if p.length() > 1.0 {
93fc5734	98	p.normalized()
eca25591 TW	99	} else {
	100	p
	101	}
bf7b5671 TW	102	}
	103	}
	104
	105	impl From<&Stick> for Point2D<f64> {
	106	fn from(item: &Stick) -> Self {
	107	Self {
	108	x: item.x as f64,
	109	y: item.y as f64,
	110	}
	111	}
	112	}
	113
	114	impl From<&Stick> for (f64, f64) {
	115	fn from(item: &Stick) -> Self {
	116	(item.x as f64, item.y as f64)
	117	}
3f344b63 TW	118	}
3f344b63 TW	119
05ba0976 TW	120	#[derive(Eq, PartialEq, Hash)]
	121	enum DeviceControls {
	122	AxisLX,
	123	AxisLY,
	124	AxisRX,
	125	AxisRY,
	126	AxisL2,
	127	AxisR2,
	128	ButtonA,
	129	ButtonB,
	130	ButtonY,
	131	ButtonX,
	132	ButtonSelect,
	133	ButtonStart,
	134	ButtonHome,
	135	ButtonL3,
	136	ButtonR3,
	137	ButtonL1,
	138	ButtonR1,
	139	ButtonL2,
	140	ButtonR2,
	141	ButtonUp,
	142	ButtonDown,
	143	ButtonLeft,
	144	ButtonRight,
5d731022 TW	145	}
5d731022 TW	146
05ba0976 TW	147	#[derive(Eq, PartialEq, Hash)]
	148	enum ActionControls {
	149	MovementX,
	150	MovementY,
	151	AimX,
	152	AimY,
	153	Jump,
	154	Shoot,
	155	Start,
5d731022 TW	156	}
5d731022 TW	157
3f344b63 TW	158	//#[derive(Debug)]
3f344b63 TW	159	pub struct Controller {
bf7b5671	160	pub device: Joystick,
3f344b63	161	haptic: Option<Rc<RefCell<Haptic>>>,
bf7b5671 TW	162
	163	pub mov: Stick,
	164	pub aim: Stick,
	165	pub jump: Button,
	166	pub start: Button,
	167	pub shoot: Button,
	168	}
	169
	170	impl Controller {
	171	pub fn new(device: Joystick, haptic: Option<Rc<RefCell<Haptic>>>) -> Self {
05ba0976 TW	172	let action_map = get_action_mapping();
05ba0976 TW	173	let device_map = get_device_mapping(&device.name());
5d731022	174	let mut ctrl = Controller {
bf7b5671 TW	175	device,
	176	haptic,
	177	mov: Default::default(),
	178	aim: Default::default(),
	179	jump: Default::default(),
	180	start: Default::default(),
	181	shoot: Default::default(),
5d731022	182	};
05ba0976	183	ctrl.set_mapping(&action_map, &device_map);
5d731022 TW	184	ctrl
	185	}
	186
05ba0976 TW	187	fn set_mapping(&mut self, action: &HashMap<ActionControls, DeviceControls>, device: &HashMap<DeviceControls, u8>) {
	188	self.mov.idx = *action.get(&ActionControls::MovementX).map(\|i\| device.get(i)).flatten().unwrap();
	189	self.mov.idy = *action.get(&ActionControls::MovementY).map(\|i\| device.get(i)).flatten().unwrap();
	190	self.aim.idx = *action.get(&ActionControls::AimX).map(\|i\| device.get(i)).flatten().unwrap();
	191	self.aim.idy = *action.get(&ActionControls::AimY).map(\|i\| device.get(i)).flatten().unwrap();
	192	self.jump.id = *action.get(&ActionControls::Jump).map(\|i\| device.get(i)).flatten().unwrap();
	193	self.shoot.id = *action.get(&ActionControls::Shoot).map(\|i\| device.get(i)).flatten().unwrap();
	194	self.start.id = *action.get(&ActionControls::Start).map(\|i\| device.get(i)).flatten().unwrap();
bf7b5671 TW	195	}
bf7b5671 TW	196
902b2b31	197	pub fn update(&mut self, dt: Duration) {
5d731022 TW	198	self.mov.update(&self.device, dt);
	199	self.aim.update(&self.device, dt);
	200	self.jump.update(&self.device, dt);
	201	self.shoot.update(&self.device, dt);
	202	self.start.update(&self.device, dt);
bf7b5671 TW	203	}
	204
	205	/// strength [0 - 1]
902b2b31	206	pub fn rumble(&self, strength: f32, duration: Duration) {
bf7b5671	207	if let Some(h) = &self.haptic {
902b2b31	208	h.borrow_mut().rumble_play(strength, duration.whole_milliseconds() as u32);
bf7b5671 TW	209	}
	210	}
	211	}
	212
05ba0976 TW	213	fn get_action_mapping() -> HashMap<ActionControls, DeviceControls> {
	214	hashmap!(
	215	ActionControls::MovementX => DeviceControls::AxisLX,
	216	ActionControls::MovementY => DeviceControls::AxisLY,
	217	ActionControls::AimX => DeviceControls::AxisRX,
	218	ActionControls::AimY => DeviceControls::AxisRY,
3fd8761b	219	ActionControls::Jump => DeviceControls::ButtonA,
05ba0976 TW	220	ActionControls::Shoot => DeviceControls::ButtonR1,
	221	ActionControls::Start => DeviceControls::ButtonStart
	222	)
	223	}
	224
	225	fn get_device_mapping(device_name: &str) -> HashMap<DeviceControls, u8> {
	226	match device_name {
	227	"Sony PLAYSTATION(R)3 Controller" => hashmap!(
	228	DeviceControls::AxisLX => 0,
	229	DeviceControls::AxisLY => 1,
	230	DeviceControls::AxisRX => 3,
	231	DeviceControls::AxisRY => 4,
	232	DeviceControls::AxisL2 => 2,
	233	DeviceControls::AxisR2 => 5,
	234	DeviceControls::ButtonA => 0,
	235	DeviceControls::ButtonB => 1,
	236	DeviceControls::ButtonY => 3,
	237	DeviceControls::ButtonX => 2,
	238	DeviceControls::ButtonSelect => 8,
	239	DeviceControls::ButtonStart => 9,
	240	DeviceControls::ButtonHome => 10,
	241	DeviceControls::ButtonL3 => 11,
	242	DeviceControls::ButtonR3 => 12,
	243	DeviceControls::ButtonL1 => 4,
	244	DeviceControls::ButtonR1 => 5,
	245	DeviceControls::ButtonL2 => 6,
	246	DeviceControls::ButtonR2 => 7,
	247	DeviceControls::ButtonUp => 13,
	248	DeviceControls::ButtonDown => 14,
	249	DeviceControls::ButtonLeft => 15,
	250	DeviceControls::ButtonRight => 16
	251	),
	252	_ => panic!("No controller mapping for device '{}'", device_name)
	253	}
	254	}
	255
bf7b5671 TW	256	//#[derive(Debug)]
	257	pub struct ControllerManager {
	258	pub joystick: JoystickSubsystem,
	259	haptic: Rc<HapticSubsystem>,
	260	pub controllers: HashMap<u32, Rc<RefCell<Controller>>>,
3f344b63 TW	261	}
	262
	263	impl ControllerManager {
bf7b5671 TW	264	pub fn new(joystick: JoystickSubsystem, haptic: HapticSubsystem) -> Self {
bf7b5671 TW	265	joystick.set_event_state(true);
b0566120	266	let mut c = ControllerManager {
bf7b5671	267	joystick,
3f344b63	268	haptic: Rc::new(haptic),
b0566120 TW	269	controllers: HashMap::new(),
	270	};
	271	c.init();
	272	c
	273	}
	274
	275	fn init(&mut self) {
bf7b5671	276	for i in 0..self.joystick.num_joysticks().unwrap() {
b0566120	277	self.add_device(i);
3f344b63 TW	278	}
	279	}
	280
902b2b31	281	pub fn update(&mut self, dt: Duration) {
bf7b5671 TW	282	self.controllers.iter().for_each(\|(_, v)\| v.borrow_mut().update(dt));
	283	}
	284
3f344b63 TW	285	pub fn handle_event(&mut self, event: &Event) {
3f344b63 TW	286	match event {
bf7b5671 TW	287	Event::JoyDeviceAdded { which, .. } => { self.add_device(*which) }
bf7b5671 TW	288	Event::JoyDeviceRemoved { which, .. } => { self.remove_device(*which) }
5d731022 TW	289	// Event::JoyButtonDown { which, button_idx, .. } => { println!("device {} button {} down!", which, button_idx) }
	290	// Event::JoyButtonUp { which, button_idx, .. } => { println!("device {} button {} up!", which, button_idx) }
	291	// Event::JoyAxisMotion { which, axis_idx, .. } => { println!("device {} axis motion {}!", which, axis_idx) }
3f344b63 TW	292	_ => {}
	293	}
	294	}
	295
bf7b5671	296	fn add_device(&mut self, id: u32) {
3f344b63	297	println!("device added ({})!", id);
bf7b5671 TW	298	let mut device = self.joystick.open(id).unwrap();
bf7b5671 TW	299	println!("opened {}", device.name());
ca99d4d7 TW	300
	301	/*
	302	note about set_rumble (for dualshock 3 at least):
	303	the active range for the low frequency is from 65536/4 to 65536 and escalates in large steps throughout the range
	304	the active range for the high frequency is from 256 to 65536 and effect is the same throughout the whole range
	305	*/
bf7b5671	306	let haptic = match device.set_rumble(0, 256, 100) {
3f344b63 TW	307	Ok(_) => self.haptic.open_from_joystick_id(id).ok(),
	308	Err(_) => None
	309	};
	310
b0566120 TW	311	if self.controllers.contains_key(&id) {
	312	return;
	313	}
	314
bf7b5671	315	let detached = self.controllers.values().find(\|c\| !c.borrow().device.attached());
ca99d4d7 TW	316	match detached {
	317	Some(c) => {
	318	let mut c = c.borrow_mut();
bf7b5671	319	c.device = device;
ca99d4d7 TW	320	c.haptic = haptic.map(\|h\| Rc::new(RefCell::new(h)));
	321	}
	322	None => {
bf7b5671	323	let c = Rc::new(RefCell::new(Controller::new(device, haptic.map(\|h\| Rc::new(RefCell::new(h))))));
b0566120	324	self.controllers.insert(id, c);
ca99d4d7 TW	325	}
ca99d4d7 TW	326	};
3f344b63 TW	327	}
3f344b63 TW	328
bf7b5671	329	fn remove_device(&mut self, id: i32) {
3f344b63	330	println!("device removed ({})!", id);
ca99d4d7	331	// TODO
3f344b63 TW	332	}
3f344b63 TW	333	}