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

use common::Point2D;
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)
    }
}

#[allow(dead_code)]
struct Axes {
    left_x: u8,
    left_y: u8,
    right_x: u8,
    right_y: u8,
    trigger_left: u8,
    trigger_right: u8,
}

#[allow(dead_code)]
struct Buttons {
    a: u8,
    b: u8,
    x: u8,
    y: u8,
    select: u8,
    start: u8,
    left_stick: u8,
    right_stick: u8,
    left_shoulder: u8,
    right_shoulder: u8,
    left_trigger: u8,
    right_trigger: u8,
    d_pad_up: u8,
    d_pad_down: u8,
    d_pad_left: u8,
    d_pad_right: u8,
}

struct Mapping {
    axis: Axes,
    btn: Buttons,
}

//#[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 mut ctrl = Controller {
	    device,
	    haptic,
	    mov: Default::default(),
	    aim: Default::default(),
	    jump: Default::default(),
	    start: Default::default(),
	    shoot: Default::default(),
	};
	let dualshock3 = Mapping {
	    axis: Axes {
		left_x: 0,
		left_y: 1,
		right_x: 3,
		right_y: 4,
		trigger_left: 2,
		trigger_right: 5,
	    },
	    btn: Buttons {
		a: 0,
		b: 1,
		x: 3,
		y: 2,
		select: 8,
		start: 9,
		left_stick: 11,
		right_stick: 12,
		left_shoulder: 4,
		right_shoulder: 5,
		left_trigger: 6,
		right_trigger: 7,
		d_pad_up: 13,
		d_pad_down: 14,
		d_pad_left: 15,
		d_pad_right: 16,
	    },
	};
	ctrl.set_mapping(&dualshock3);
	ctrl
    }

    fn set_mapping(&mut self, map: &Mapping) {
	self.mov.idx = map.axis.left_x;
	self.mov.idy = map.axis.left_y;
	self.aim.idx = map.axis.right_x;
	self.aim.idy = map.axis.right_y;
	self.jump.id = map.btn.left_shoulder;
	self.shoot.id = map.btn.right_shoulder;
	self.start.id = map.btn.start;
    }

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

//#[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 common::Radians;
	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: Radians,
	70	pub len: f32,
	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	self.len = {
	85	let x = (self.x / self.y).abs().min(1.0);
	86	let y = (self.y / self.x).abs().min(1.0);
	87	(self.x.powi(2) + self.y.powi(2)).sqrt() / (x.powi(2) + y.powi(2)).sqrt()
	88	}
	89	}
	90
	91	#[inline(always)] #[allow(dead_code)] fn up(&self) -> bool { self.y > 0.99 }
	92	#[inline(always)] #[allow(dead_code)] fn down(&self) -> bool { self.y < -0.99 }
	93	#[inline(always)] #[allow(dead_code)] fn left(&self) -> bool { self.x < -0.99 }
	94	#[inline(always)] #[allow(dead_code)] fn right(&self) -> bool { self.x > 0.99 }
	95
	96	pub fn to_point(&self) -> Point2D<f64> {
	97	Point2D {
	98	x: self.x as f64,
	99	y: self.y as f64,
	100	}
	101	}
	102
	103	pub fn to_adjusted_point(&self) -> Point2D<f64> {
	104	Point2D::from(self.a) * self.len as f64
	105	}
	106	}
	107
	108	impl From<&Stick> for Point2D<f64> {
	109	fn from(item: &Stick) -> Self {
	110	Self {
	111	x: item.x as f64,
	112	y: item.y as f64,
	113	}
	114	}
	115	}
	116
	117	impl From<&Stick> for (f64, f64) {
	118	fn from(item: &Stick) -> Self {
	119	(item.x as f64, item.y as f64)
	120	}
	121	}
	122
	123	#[allow(dead_code)]
	124	struct Axes {
	125	left_x: u8,
	126	left_y: u8,
	127	right_x: u8,
	128	right_y: u8,
	129	trigger_left: u8,
	130	trigger_right: u8,
	131	}
	132
	133	#[allow(dead_code)]
	134	struct Buttons {
	135	a: u8,
	136	b: u8,
	137	x: u8,
	138	y: u8,
	139	select: u8,
	140	start: u8,
	141	left_stick: u8,
	142	right_stick: u8,
	143	left_shoulder: u8,
	144	right_shoulder: u8,
	145	left_trigger: u8,
	146	right_trigger: u8,
	147	d_pad_up: u8,
	148	d_pad_down: u8,
	149	d_pad_left: u8,
	150	d_pad_right: u8,
	151	}
	152
	153	struct Mapping {
	154	axis: Axes,
	155	btn: Buttons,
	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 mut ctrl = Controller {
	173	device,
	174	haptic,
	175	mov: Default::default(),
	176	aim: Default::default(),
	177	jump: Default::default(),
	178	start: Default::default(),
	179	shoot: Default::default(),
	180	};
	181	let dualshock3 = Mapping {
	182	axis: Axes {
	183	left_x: 0,
	184	left_y: 1,
	185	right_x: 3,
	186	right_y: 4,
	187	trigger_left: 2,
	188	trigger_right: 5,
	189	},
	190	btn: Buttons {
	191	a: 0,
	192	b: 1,
	193	x: 3,
	194	y: 2,
	195	select: 8,
	196	start: 9,
	197	left_stick: 11,
	198	right_stick: 12,
	199	left_shoulder: 4,
	200	right_shoulder: 5,
	201	left_trigger: 6,
	202	right_trigger: 7,
	203	d_pad_up: 13,
	204	d_pad_down: 14,
	205	d_pad_left: 15,
	206	d_pad_right: 16,
	207	},
	208	};
	209	ctrl.set_mapping(&dualshock3);
	210	ctrl
	211	}
	212
	213	fn set_mapping(&mut self, map: &Mapping) {
	214	self.mov.idx = map.axis.left_x;
	215	self.mov.idy = map.axis.left_y;
	216	self.aim.idx = map.axis.right_x;
	217	self.aim.idy = map.axis.right_y;
	218	self.jump.id = map.btn.left_shoulder;
	219	self.shoot.id = map.btn.right_shoulder;
	220	self.start.id = map.btn.start;
	221	}
	222
	223	pub fn update(&mut self, dt: Duration) {
	224	self.mov.update(&self.device, dt);
	225	self.aim.update(&self.device, dt);
	226	self.jump.update(&self.device, dt);
	227	self.shoot.update(&self.device, dt);
	228	self.start.update(&self.device, dt);
	229	}
	230
	231	/// strength [0 - 1]
	232	pub fn rumble(&self, strength: f32, duration: Duration) {
	233	if let Some(h) = &self.haptic {
	234	h.borrow_mut().rumble_play(strength, duration.whole_milliseconds() as u32);
	235	}
	236	}
	237	}
	238
	239	//#[derive(Debug)]
	240	pub struct ControllerManager {
	241	pub joystick: JoystickSubsystem,
	242	haptic: Rc<HapticSubsystem>,
	243	pub controllers: HashMap<u32, Rc<RefCell<Controller>>>,
	244	}
	245
	246	impl ControllerManager {
	247	pub fn new(joystick: JoystickSubsystem, haptic: HapticSubsystem) -> Self {
	248	joystick.set_event_state(true);
	249	let mut c = ControllerManager {
	250	joystick,
	251	haptic: Rc::new(haptic),
	252	controllers: HashMap::new(),
	253	};
	254	c.init();
	255	c
	256	}
	257
	258	fn init(&mut self) {
	259	for i in 0..self.joystick.num_joysticks().unwrap() {
	260	self.add_device(i);
	261	}
	262	}
	263
	264	pub fn update(&mut self, dt: Duration) {
	265	self.controllers.iter().for_each(\|(_, v)\| v.borrow_mut().update(dt));
	266	}
	267
	268	pub fn handle_event(&mut self, event: &Event) {
	269	match event {
	270	Event::JoyDeviceAdded { which, .. } => { self.add_device(*which) }
	271	Event::JoyDeviceRemoved { which, .. } => { self.remove_device(*which) }
	272	// Event::JoyButtonDown { which, button_idx, .. } => { println!("device {} button {} down!", which, button_idx) }
	273	// Event::JoyButtonUp { which, button_idx, .. } => { println!("device {} button {} up!", which, button_idx) }
	274	// Event::JoyAxisMotion { which, axis_idx, .. } => { println!("device {} axis motion {}!", which, axis_idx) }
	275	_ => {}
	276	}
	277	}
	278
	279	fn add_device(&mut self, id: u32) {
	280	println!("device added ({})!", id);
	281	let mut device = self.joystick.open(id).unwrap();
	282	println!("opened {}", device.name());
	283
	284	/*
	285	note about set_rumble (for dualshock 3 at least):
	286	the active range for the low frequency is from 65536/4 to 65536 and escalates in large steps throughout the range
	287	the active range for the high frequency is from 256 to 65536 and effect is the same throughout the whole range
	288	*/
	289	let haptic = match device.set_rumble(0, 256, 100) {
	290	Ok(_) => self.haptic.open_from_joystick_id(id).ok(),
	291	Err(_) => None
	292	};
	293
	294	if self.controllers.contains_key(&id) {
	295	return;
	296	}
	297
	298	let detached = self.controllers.values().find(\|c\| !c.borrow().device.attached());
	299	match detached {
	300	Some(c) => {
	301	let mut c = c.borrow_mut();
	302	c.device = device;
	303	c.haptic = haptic.map(\|h\| Rc::new(RefCell::new(h)));
	304	}
	305	None => {
	306	let c = Rc::new(RefCell::new(Controller::new(device, haptic.map(\|h\| Rc::new(RefCell::new(h))))));
	307	self.controllers.insert(id, c);
	308	}
	309	};
	310	}
	311
	312	fn remove_device(&mut self, id: i32) {
	313	println!("device removed ({})!", id);
	314	// TODO
	315	}
	316	}