[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,
}
use self::DeviceControls::*;

#[derive(Eq, PartialEq, Hash)]
enum ActionControls {
    MovementX,
    MovementY,
    AimX,
    AimY,
    Jump,
    Shoot,
    Start,
}
use self::ActionControls::*;

//#[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(&MovementX).map(|i| device.get(i)).flatten().unwrap();
    	self.mov.idy = *action.get(&MovementY).map(|i| device.get(i)).flatten().unwrap();
    	self.aim.idx = *action.get(&AimX).map(|i| device.get(i)).flatten().unwrap();
    	self.aim.idy = *action.get(&AimY).map(|i| device.get(i)).flatten().unwrap();
    	self.jump.id = *action.get(&Jump).map(|i| device.get(i)).flatten().unwrap();
    	self.shoot.id = *action.get(&Shoot).map(|i| device.get(i)).flatten().unwrap();
    	self.start.id = *action.get(&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!(
	MovementX => AxisLX,
	MovementY => AxisLY,
	AimX => AxisRX,
	AimY => AxisRY,
	Jump => ButtonA,
	Shoot => ButtonR1,
	Start => ButtonStart
    )
}

fn get_device_mapping(device_name: &str) -> HashMap<DeviceControls, u8> {
    match device_name {
	"Sony PLAYSTATION(R)3 Controller" => hashmap!(
	    AxisLX => 0,
	    AxisLY => 1,
	    AxisRX => 3,
	    AxisRY => 4,
	    AxisL2 => 2,
	    AxisR2 => 5,
	    ButtonA => 0,
	    ButtonB => 1,
	    ButtonY => 3,
	    ButtonX => 2,
	    ButtonSelect => 8,
	    ButtonStart => 9,
	    ButtonHome => 10,
	    ButtonL3 => 11,
	    ButtonR3 => 12,
	    ButtonL1 => 4,
	    ButtonR1 => 5,
	    ButtonL2 => 6,
	    ButtonR2 => 7,
	    ButtonUp => 13,
	    ButtonDown => 14,
	    ButtonLeft => 15,
	    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	use self::DeviceControls::*;
	147
	148	#[derive(Eq, PartialEq, Hash)]
	149	enum ActionControls {
	150	MovementX,
	151	MovementY,
	152	AimX,
	153	AimY,
	154	Jump,
	155	Shoot,
	156	Start,
	157	}
	158	use self::ActionControls::*;
	159
	160	//#[derive(Debug)]
	161	pub struct Controller {
	162	pub device: Joystick,
	163	haptic: Option<Rc<RefCell<Haptic>>>,
	164
	165	pub mov: Stick,
	166	pub aim: Stick,
	167	pub jump: Button,
	168	pub start: Button,
	169	pub shoot: Button,
	170	}
	171
	172	impl Controller {
	173	pub fn new(device: Joystick, haptic: Option<Rc<RefCell<Haptic>>>) -> Self {
	174	let action_map = get_action_mapping();
	175	let device_map = get_device_mapping(&device.name());
	176	let mut ctrl = Controller {
	177	device,
	178	haptic,
	179	mov: Default::default(),
	180	aim: Default::default(),
	181	jump: Default::default(),
	182	start: Default::default(),
	183	shoot: Default::default(),
	184	};
	185	ctrl.set_mapping(&action_map, &device_map);
	186	ctrl
	187	}
	188
	189	fn set_mapping(&mut self, action: &HashMap<ActionControls, DeviceControls>, device: &HashMap<DeviceControls, u8>) {
	190	self.mov.idx = *action.get(&MovementX).map(\|i\| device.get(i)).flatten().unwrap();
	191	self.mov.idy = *action.get(&MovementY).map(\|i\| device.get(i)).flatten().unwrap();
	192	self.aim.idx = *action.get(&AimX).map(\|i\| device.get(i)).flatten().unwrap();
	193	self.aim.idy = *action.get(&AimY).map(\|i\| device.get(i)).flatten().unwrap();
	194	self.jump.id = *action.get(&Jump).map(\|i\| device.get(i)).flatten().unwrap();
	195	self.shoot.id = *action.get(&Shoot).map(\|i\| device.get(i)).flatten().unwrap();
	196	self.start.id = *action.get(&Start).map(\|i\| device.get(i)).flatten().unwrap();
	197	}
	198
	199	pub fn update(&mut self, dt: Duration) {
	200	self.mov.update(&self.device, dt);
	201	self.aim.update(&self.device, dt);
	202	self.jump.update(&self.device, dt);
	203	self.shoot.update(&self.device, dt);
	204	self.start.update(&self.device, dt);
	205	}
	206
	207	/// strength [0 - 1]
	208	pub fn rumble(&self, strength: f32, duration: Duration) {
	209	if let Some(h) = &self.haptic {
	210	h.borrow_mut().rumble_play(strength, duration.whole_milliseconds() as u32);
	211	}
	212	}
	213	}
	214
	215	fn get_action_mapping() -> HashMap<ActionControls, DeviceControls> {
	216	hashmap!(
	217	MovementX => AxisLX,
	218	MovementY => AxisLY,
	219	AimX => AxisRX,
	220	AimY => AxisRY,
	221	Jump => ButtonA,
	222	Shoot => ButtonR1,
	223	Start => ButtonStart
	224	)
	225	}
	226
	227	fn get_device_mapping(device_name: &str) -> HashMap<DeviceControls, u8> {
	228	match device_name {
	229	"Sony PLAYSTATION(R)3 Controller" => hashmap!(
	230	AxisLX => 0,
	231	AxisLY => 1,
	232	AxisRX => 3,
	233	AxisRY => 4,
	234	AxisL2 => 2,
	235	AxisR2 => 5,
	236	ButtonA => 0,
	237	ButtonB => 1,
	238	ButtonY => 3,
	239	ButtonX => 2,
	240	ButtonSelect => 8,
	241	ButtonStart => 9,
	242	ButtonHome => 10,
	243	ButtonL3 => 11,
	244	ButtonR3 => 12,
	245	ButtonL1 => 4,
	246	ButtonR1 => 5,
	247	ButtonL2 => 6,
	248	ButtonR2 => 7,
	249	ButtonUp => 13,
	250	ButtonDown => 14,
	251	ButtonLeft => 15,
	252	ButtonRight => 16
	253	),
	254	_ => panic!("No controller mapping for device '{}'", device_name)
	255	}
	256	}
	257
	258	//#[derive(Debug)]
	259	pub struct ControllerManager {
	260	pub joystick: JoystickSubsystem,
	261	haptic: Rc<HapticSubsystem>,
	262	pub controllers: HashMap<u32, Rc<RefCell<Controller>>>,
	263	}
	264
	265	impl ControllerManager {
	266	pub fn new(joystick: JoystickSubsystem, haptic: HapticSubsystem) -> Self {
	267	joystick.set_event_state(true);
	268	let mut c = ControllerManager {
	269	joystick,
	270	haptic: Rc::new(haptic),
	271	controllers: HashMap::new(),
	272	};
	273	c.init();
	274	c
	275	}
	276
	277	fn init(&mut self) {
	278	for i in 0..self.joystick.num_joysticks().unwrap() {
	279	self.add_device(i);
	280	}
	281	}
	282
	283	pub fn update(&mut self, dt: Duration) {
	284	self.controllers.iter().for_each(\|(_, v)\| v.borrow_mut().update(dt));
	285	}
	286
	287	pub fn handle_event(&mut self, event: &Event) {
	288	match event {
	289	Event::JoyDeviceAdded { which, .. } => { self.add_device(*which) }
	290	Event::JoyDeviceRemoved { which, .. } => { self.remove_device(*which) }
	291	// Event::JoyButtonDown { which, button_idx, .. } => { println!("device {} button {} down!", which, button_idx) }
	292	// Event::JoyButtonUp { which, button_idx, .. } => { println!("device {} button {} up!", which, button_idx) }
	293	// Event::JoyAxisMotion { which, axis_idx, .. } => { println!("device {} axis motion {}!", which, axis_idx) }
	294	_ => {}
	295	}
	296	}
	297
	298	fn add_device(&mut self, id: u32) {
	299	println!("device added ({})!", id);
	300	let mut device = self.joystick.open(id).unwrap();
	301	println!("opened {}", device.name());
	302
	303	/*
	304	note about set_rumble (for dualshock 3 at least):
	305	the active range for the low frequency is from 65536/4 to 65536 and escalates in large steps throughout the range
	306	the active range for the high frequency is from 256 to 65536 and effect is the same throughout the whole range
	307	*/
	308	let haptic = match device.set_rumble(0, 256, 100) {
	309	Ok(_) => self.haptic.open_from_joystick_id(id).ok(),
	310	Err(_) => None
	311	};
	312
	313	if self.controllers.contains_key(&id) {
	314	return;
	315	}
	316
	317	let detached = self.controllers.values().find(\|c\| !c.borrow().device.attached());
	318	match detached {
	319	Some(c) => {
	320	let mut c = c.borrow_mut();
	321	c.device = device;
	322	c.haptic = haptic.map(\|h\| Rc::new(RefCell::new(h)));
	323	}
	324	None => {
	325	let c = Rc::new(RefCell::new(Controller::new(device, haptic.map(\|h\| Rc::new(RefCell::new(h))))));
	326	self.controllers.insert(id, c);
	327	}
	328	};
	329	}
	330
	331	fn remove_device(&mut self, id: i32) {
	332	println!("device removed ({})!", id);
	333	// TODO
	334	}
	335	}