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

use common::{Angle, Point};
use {hashmap, point};
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: Angle,
}

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 = point!(self.x as f64, self.y as f64).to_angle();
    }

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