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

use common::Point2D;
use hashmap;
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,
    pub len: f32,
}

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);
	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()
	}
    }

    #[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 }

    pub fn to_point(&self) -> Point2D<f64> {
	Point2D {
	    x: self.x as f64,
	    y: self.y as f64,
	}
    }

    pub fn to_adjusted_point(&self) -> Point2D<f64> {
	Point2D::from(self.a) * self.len as f64
    }
}

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