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

use common::Point;
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) -> Point<f64> {
	point!(self.x as f64, self.y as f64)
    }

    pub fn to_point(&self) -> Point<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 Point<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
	1	use common::Point;
	2	use {hashmap, point};
	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	}
	72
	73	impl Stick {
	74	fn update(&mut self, device: &Joystick, _dt: Duration) {
	75	self.x = match device.axis(self.idx as u32) {
	76	Ok(val) => val as f32 / 32768.0,
	77	Err(_) => panic!("invalid x axis {}", self.idx),
	78	};
	79	self.y = match device.axis(self.idy as u32) {
	80	Ok(val) => val as f32 / 32768.0,
	81	Err(_) => panic!("invalid y axis {}", self.idy),
	82	};
	83	self.a = Radians(self.y.atan2(self.x) as f64);
	84	}
	85
	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 }
	90
	91	pub fn to_axis_point(&self) -> Point<f64> {
	92	point!(self.x as f64, self.y as f64)
	93	}
	94
	95	pub fn to_point(&self) -> Point<f64> {
	96	let p = point!(self.x as f64, self.y as f64);
	97	if p.length() > 1.0 {
	98	p.normalized()
	99	} else {
	100	p
	101	}
	102	}
	103	}
	104
	105	impl From<&Stick> for Point<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	}
	118	}
	119
	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,
	145	}
	146
	147	#[derive(Eq, PartialEq, Hash)]
	148	enum ActionControls {
	149	MovementX,
	150	MovementY,
	151	AimX,
	152	AimY,
	153	Jump,
	154	Shoot,
	155	Start,
	156	}
	157
	158	//#[derive(Debug)]
	159	pub struct Controller {
	160	pub device: Joystick,
	161	haptic: Option<Rc<RefCell<Haptic>>>,
	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 {
	172	let action_map = get_action_mapping();
	173	let device_map = get_device_mapping(&device.name());
	174	let mut ctrl = Controller {
	175	device,
	176	haptic,
	177	mov: Default::default(),
	178	aim: Default::default(),
	179	jump: Default::default(),
	180	start: Default::default(),
	181	shoot: Default::default(),
	182	};
	183	ctrl.set_mapping(&action_map, &device_map);
	184	ctrl
	185	}
	186
	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();
	195	}
	196
	197	pub fn update(&mut self, dt: Duration) {
	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);
	203	}
	204
	205	/// strength [0 - 1]
	206	pub fn rumble(&self, strength: f32, duration: Duration) {
	207	if let Some(h) = &self.haptic {
	208	h.borrow_mut().rumble_play(strength, duration.whole_milliseconds() as u32);
	209	}
	210	}
	211	}
	212
	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,
	219	ActionControls::Jump => DeviceControls::ButtonA,
	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
	256	//#[derive(Debug)]
	257	pub struct ControllerManager {
	258	pub joystick: JoystickSubsystem,
	259	haptic: Rc<HapticSubsystem>,
	260	pub controllers: HashMap<u32, Rc<RefCell<Controller>>>,
	261	}
	262
	263	impl ControllerManager {
	264	pub fn new(joystick: JoystickSubsystem, haptic: HapticSubsystem) -> Self {
	265	joystick.set_event_state(true);
	266	let mut c = ControllerManager {
	267	joystick,
	268	haptic: Rc::new(haptic),
	269	controllers: HashMap::new(),
	270	};
	271	c.init();
	272	c
	273	}
	274
	275	fn init(&mut self) {
	276	for i in 0..self.joystick.num_joysticks().unwrap() {
	277	self.add_device(i);
	278	}
	279	}
	280
	281	pub fn update(&mut self, dt: Duration) {
	282	self.controllers.iter().for_each(\|(_, v)\| v.borrow_mut().update(dt));
	283	}
	284
	285	pub fn handle_event(&mut self, event: &Event) {
	286	match event {
	287	Event::JoyDeviceAdded { which, .. } => { self.add_device(*which) }
	288	Event::JoyDeviceRemoved { which, .. } => { self.remove_device(*which) }
	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) }
	292	_ => {}
	293	}
	294	}
	295
	296	fn add_device(&mut self, id: u32) {
	297	println!("device added ({})!", id);
	298	let mut device = self.joystick.open(id).unwrap();
	299	println!("opened {}", device.name());
	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	*/
	306	let haptic = match device.set_rumble(0, 256, 100) {
	307	Ok(_) => self.haptic.open_from_joystick_id(id).ok(),
	308	Err(_) => None
	309	};
	310
	311	if self.controllers.contains_key(&id) {
	312	return;
	313	}
	314
	315	let detached = self.controllers.values().find(\|c\| !c.borrow().device.attached());
	316	match detached {
	317	Some(c) => {
	318	let mut c = c.borrow_mut();
	319	c.device = device;
	320	c.haptic = haptic.map(\|h\| Rc::new(RefCell::new(h)));
	321	}
	322	None => {
	323	let c = Rc::new(RefCell::new(Controller::new(device, haptic.map(\|h\| Rc::new(RefCell::new(h))))));
	324	self.controllers.insert(id, c);
	325	}
	326	};
	327	}
	328
	329	fn remove_device(&mut self, id: i32) {
	330	println!("device removed ({})!", id);
	331	// TODO
	332	}
	333	}