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

use geometry::{Angle, ToAngle, Point};
use sdl2::GameControllerSubsystem;
use sdl2::HapticSubsystem;
use sdl2::controller::{GameController, Axis as SDLAxis, Button as SDLButton};
use sdl2::event::Event;
use sdl2::haptic::Haptic;
use std::cell::RefCell;
use std::collections::HashMap;
use std::rc::Rc;
use time::{Duration, prelude::*};
use {hashmap, point};

#[derive(Debug)]
pub struct Button {
    id: SDLButton,
    pub time_pressed: Duration,
    pub time_released: Duration,
    pub is_pressed: bool,
    pub was_pressed: bool,
    pub toggle: bool,
}

impl Button {
    pub fn new(id: SDLButton) -> Self {
    	Button {
	    id,
	    time_pressed: Duration::zero(),
	    time_released: Duration::zero(),
	    is_pressed: false,
	    was_pressed: false,
	    toggle: false,
	}
    }

    fn update(&mut self, device: &GameController, dt: Duration) {
	self.was_pressed = self.is_pressed;
	self.is_pressed = match device.button(self.id) {
	    true => {
		if !self.was_pressed {
		    self.time_pressed = 0.seconds();
		    self.toggle = !self.toggle;
		}
		self.time_pressed += dt;
		true
	    }
	    false => {
		if self.was_pressed {
		    self.time_released = 0.seconds();
		}
		self.time_released += dt;
		false
	    }
	}
    }
}

#[derive(Debug)]
pub struct Axis {
    id: SDLAxis,
    pub val: f32,
}

impl Axis {
    #[allow(dead_code)]
    fn update(&mut self, device: &GameController, _dt: Duration) {
	self.val = device.axis(self.id) as f32 / 32768.0;
    }
}

#[derive(Debug)]
pub struct Stick {
    id: (SDLAxis, SDLAxis),
    pub x: f32,
    pub y: f32,
    pub a: Angle,
}

impl Stick {
    pub fn new(idx: SDLAxis, idy: SDLAxis) -> Self {
    	Stick {
	    id: (idx, idy),
	    x: 0.0,
	    y: 0.0,
	    a: 0.radians(),
	}
    }

    fn update(&mut self, device: &GameController, _dt: Duration) {
	self.x = device.axis(self.id.0) as f32 / 32768.0;
	self.y = device.axis(self.id.1) as f32 / 32768.0;
	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 ActionControls {
    MovementX,
    MovementY,
    AimX,
    AimY,
    Jump,
    Shoot,
    Start,
}
use self::ActionControls::*;

//#[derive(Debug)]
pub struct Controller {
    pub device: GameController,
    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: GameController, haptic: Option<Rc<RefCell<Haptic>>>) -> Self {
	let map = get_action_mapping();
	let mut ctrl = Controller {
	    device,
	    haptic,
	    mov: Stick::new(*map.axes.get(&MovementX).unwrap(), *map.axes.get(&MovementY).unwrap()),
	    aim: Stick::new(*map.axes.get(&AimX).unwrap(), *map.axes.get(&AimY).unwrap()),
	    jump: Button::new(*map.buttons.get(&Jump).unwrap()),
	    start: Button::new(*map.buttons.get(&Start).unwrap()),
	    shoot: Button::new(*map.buttons.get(&Shoot).unwrap()),
	};
	ctrl.set_mapping(&map);
	ctrl
    }

    fn set_mapping(&mut self, map: &ActionMapping) {
    	self.mov.id.0 = *map.axes.get(&MovementX).unwrap();
    	self.mov.id.1 = *map.axes.get(&MovementY).unwrap();
    	self.aim.id.0 = *map.axes.get(&AimX).unwrap();
    	self.aim.id.1 = *map.axes.get(&AimY).unwrap();
    	self.jump.id = *map.buttons.get(&Jump).unwrap();
    	self.shoot.id = *map.buttons.get(&Shoot).unwrap();
    	self.start.id = *map.buttons.get(&Start).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);
	}
    }
}

struct ActionMapping {
    axes: HashMap<ActionControls, SDLAxis>,
    buttons: HashMap<ActionControls, SDLButton>,
}

fn get_action_mapping() -> ActionMapping {
    ActionMapping {
	axes: hashmap!(
	    MovementX => SDLAxis::LeftX,
	    MovementY => SDLAxis::LeftY,
	    AimX => SDLAxis::RightX,
	    AimY => SDLAxis::RightY
	),
	buttons: hashmap!(
	    Jump => SDLButton::A,
	    Shoot => SDLButton::RightShoulder,
	    Start => SDLButton::Start
	)
    }
}

//#[derive(Debug)]
pub struct ControllerManager {
    pub subsystem: GameControllerSubsystem,
    haptic: Rc<HapticSubsystem>,
    pub controllers: HashMap<u32, Rc<RefCell<Controller>>>,
}

impl ControllerManager {
    pub fn new(subsystem: GameControllerSubsystem, haptic: HapticSubsystem) -> Self {
	subsystem.set_event_state(true);
	let mut c = ControllerManager {
	    subsystem,
	    haptic: Rc::new(haptic),
	    controllers: HashMap::new(),
	};
	c.init();
	c
    }

    fn init(&mut self) {
	for i in 0..self.subsystem.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::ControllerDeviceAdded { which, .. } => { self.add_device(*which) }
	    Event::ControllerDeviceRemoved { which, .. } => { self.remove_device(*which) }
	    // Event::ControllerButtonDown { which, button_idx, .. } => { println!("device {} button {} down!", which, button_idx) }
	    // Event::ControllerButtonUp { which, button_idx, .. } => { println!("device {} button {} up!", which, button_idx) }
	    // Event::ControllerAxisMotion { 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.subsystem.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 geometry::{Angle, ToAngle, Point};
	2	use sdl2::GameControllerSubsystem;
	3	use sdl2::HapticSubsystem;
	4	use sdl2::controller::{GameController, Axis as SDLAxis, Button as SDLButton};
	5	use sdl2::event::Event;
	6	use sdl2::haptic::Haptic;
	7	use std::cell::RefCell;
	8	use std::collections::HashMap;
	9	use std::rc::Rc;
	10	use time::{Duration, prelude::*};
	11	use {hashmap, point};
	12
	13	#[derive(Debug)]
	14	pub struct Button {
	15	id: SDLButton,
	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	pub fn new(id: SDLButton) -> Self {
	25	Button {
	26	id,
	27	time_pressed: Duration::zero(),
	28	time_released: Duration::zero(),
	29	is_pressed: false,
	30	was_pressed: false,
	31	toggle: false,
	32	}
	33	}
	34
	35	fn update(&mut self, device: &GameController, dt: Duration) {
	36	self.was_pressed = self.is_pressed;
	37	self.is_pressed = match device.button(self.id) {
	38	true => {
	39	if !self.was_pressed {
	40	self.time_pressed = 0.seconds();
	41	self.toggle = !self.toggle;
	42	}
	43	self.time_pressed += dt;
	44	true
	45	}
	46	false => {
	47	if self.was_pressed {
	48	self.time_released = 0.seconds();
	49	}
	50	self.time_released += dt;
	51	false
	52	}
	53	}
	54	}
	55	}
	56
	57	#[derive(Debug)]
	58	pub struct Axis {
	59	id: SDLAxis,
	60	pub val: f32,
	61	}
	62
	63	impl Axis {
	64	#[allow(dead_code)]
	65	fn update(&mut self, device: &GameController, _dt: Duration) {
	66	self.val = device.axis(self.id) as f32 / 32768.0;
	67	}
	68	}
	69
	70	#[derive(Debug)]
	71	pub struct Stick {
	72	id: (SDLAxis, SDLAxis),
	73	pub x: f32,
	74	pub y: f32,
	75	pub a: Angle,
	76	}
	77
	78	impl Stick {
	79	pub fn new(idx: SDLAxis, idy: SDLAxis) -> Self {
	80	Stick {
	81	id: (idx, idy),
	82	x: 0.0,
	83	y: 0.0,
	84	a: 0.radians(),
	85	}
	86	}
	87
	88	fn update(&mut self, device: &GameController, _dt: Duration) {
	89	self.x = device.axis(self.id.0) as f32 / 32768.0;
	90	self.y = device.axis(self.id.1) as f32 / 32768.0;
	91	self.a = point!(self.x as f64, self.y as f64).to_angle();
	92	}
	93
	94	#[inline(always)] #[allow(dead_code)] pub fn up(&self) -> bool { self.y < -0.99 }
	95	#[inline(always)] #[allow(dead_code)] pub fn down(&self) -> bool { self.y > 0.99 }
	96	#[inline(always)] #[allow(dead_code)] pub fn left(&self) -> bool { self.x < -0.99 }
	97	#[inline(always)] #[allow(dead_code)] pub fn right(&self) -> bool { self.x > 0.99 }
	98
	99	pub fn to_axis_point(&self) -> Point<f64> {
	100	point!(self.x as f64, self.y as f64)
	101	}
	102
	103	pub fn to_point(&self) -> Point<f64> {
	104	let p = point!(self.x as f64, self.y as f64);
	105	if p.length() > 1.0 {
	106	p.normalized()
	107	} else {
	108	p
	109	}
	110	}
	111	}
	112
	113	impl From<&Stick> for Point<f64> {
	114	fn from(item: &Stick) -> Self {
	115	Self {
	116	x: item.x as f64,
	117	y: item.y as f64,
	118	}
	119	}
	120	}
	121
	122	impl From<&Stick> for (f64, f64) {
	123	fn from(item: &Stick) -> Self {
	124	(item.x as f64, item.y as f64)
	125	}
	126	}
	127
	128	#[derive(Eq, PartialEq, Hash)]
	129	enum ActionControls {
	130	MovementX,
	131	MovementY,
	132	AimX,
	133	AimY,
	134	Jump,
	135	Shoot,
	136	Start,
	137	}
	138	use self::ActionControls::*;
	139
	140	//#[derive(Debug)]
	141	pub struct Controller {
	142	pub device: GameController,
	143	haptic: Option<Rc<RefCell<Haptic>>>,
	144
	145	pub mov: Stick,
	146	pub aim: Stick,
	147	pub jump: Button,
	148	pub start: Button,
	149	pub shoot: Button,
	150	}
	151
	152	impl Controller {
	153	pub fn new(device: GameController, haptic: Option<Rc<RefCell<Haptic>>>) -> Self {
	154	let map = get_action_mapping();
	155	let mut ctrl = Controller {
	156	device,
	157	haptic,
	158	mov: Stick::new(map.axes.get(&MovementX).unwrap(), map.axes.get(&MovementY).unwrap()),
	159	aim: Stick::new(map.axes.get(&AimX).unwrap(), map.axes.get(&AimY).unwrap()),
	160	jump: Button::new(*map.buttons.get(&Jump).unwrap()),
	161	start: Button::new(*map.buttons.get(&Start).unwrap()),
	162	shoot: Button::new(*map.buttons.get(&Shoot).unwrap()),
	163	};
	164	ctrl.set_mapping(&map);
	165	ctrl
	166	}
	167
	168	fn set_mapping(&mut self, map: &ActionMapping) {
	169	self.mov.id.0 = *map.axes.get(&MovementX).unwrap();
	170	self.mov.id.1 = *map.axes.get(&MovementY).unwrap();
	171	self.aim.id.0 = *map.axes.get(&AimX).unwrap();
	172	self.aim.id.1 = *map.axes.get(&AimY).unwrap();
	173	self.jump.id = *map.buttons.get(&Jump).unwrap();
	174	self.shoot.id = *map.buttons.get(&Shoot).unwrap();
	175	self.start.id = *map.buttons.get(&Start).unwrap();
	176	}
	177
	178	pub fn update(&mut self, dt: Duration) {
	179	self.mov.update(&self.device, dt);
	180	self.aim.update(&self.device, dt);
	181	self.jump.update(&self.device, dt);
	182	self.shoot.update(&self.device, dt);
	183	self.start.update(&self.device, dt);
	184	}
	185
	186	/// strength [0 - 1]
	187	pub fn rumble(&self, strength: f32, duration: Duration) {
	188	if let Some(h) = &self.haptic {
	189	h.borrow_mut().rumble_play(strength, duration.whole_milliseconds() as u32);
	190	}
	191	}
	192	}
	193
	194	struct ActionMapping {
	195	axes: HashMap<ActionControls, SDLAxis>,
	196	buttons: HashMap<ActionControls, SDLButton>,
	197	}
	198
	199	fn get_action_mapping() -> ActionMapping {
	200	ActionMapping {
	201	axes: hashmap!(
	202	MovementX => SDLAxis::LeftX,
	203	MovementY => SDLAxis::LeftY,
	204	AimX => SDLAxis::RightX,
	205	AimY => SDLAxis::RightY
	206	),
	207	buttons: hashmap!(
	208	Jump => SDLButton::A,
	209	Shoot => SDLButton::RightShoulder,
	210	Start => SDLButton::Start
	211	)
	212	}
	213	}
	214
	215	//#[derive(Debug)]
	216	pub struct ControllerManager {
	217	pub subsystem: GameControllerSubsystem,
	218	haptic: Rc<HapticSubsystem>,
	219	pub controllers: HashMap<u32, Rc<RefCell<Controller>>>,
	220	}
	221
	222	impl ControllerManager {
	223	pub fn new(subsystem: GameControllerSubsystem, haptic: HapticSubsystem) -> Self {
	224	subsystem.set_event_state(true);
	225	let mut c = ControllerManager {
	226	subsystem,
	227	haptic: Rc::new(haptic),
	228	controllers: HashMap::new(),
	229	};
	230	c.init();
	231	c
	232	}
	233
	234	fn init(&mut self) {
	235	for i in 0..self.subsystem.num_joysticks().unwrap() {
	236	self.add_device(i);
	237	}
	238	}
	239
	240	pub fn update(&mut self, dt: Duration) {
	241	self.controllers.iter().for_each(\|(_, v)\| v.borrow_mut().update(dt));
	242	}
	243
	244	pub fn handle_event(&mut self, event: &Event) {
	245	match event {
	246	Event::ControllerDeviceAdded { which, .. } => { self.add_device(*which) }
	247	Event::ControllerDeviceRemoved { which, .. } => { self.remove_device(*which) }
	248	// Event::ControllerButtonDown { which, button_idx, .. } => { println!("device {} button {} down!", which, button_idx) }
	249	// Event::ControllerButtonUp { which, button_idx, .. } => { println!("device {} button {} up!", which, button_idx) }
	250	// Event::ControllerAxisMotion { which, axis_idx, .. } => { println!("device {} axis motion {}!", which, axis_idx) }
	251	_ => {}
	252	}
	253	}
	254
	255	fn add_device(&mut self, id: u32) {
	256	println!("device added ({})!", id);
	257	let mut device = self.subsystem.open(id).unwrap();
	258	println!("opened {}", device.name());
	259
	260	/*
	261	note about set_rumble (for dualshock 3 at least):
	262	the active range for the low frequency is from 65536/4 to 65536 and escalates in large steps throughout the range
	263	the active range for the high frequency is from 256 to 65536 and effect is the same throughout the whole range
	264	*/
	265	let haptic = match device.set_rumble(0, 256, 100) {
	266	Ok(_) => self.haptic.open_from_joystick_id(id).ok(),
	267	Err(_) => None
	268	};
	269
	270	if self.controllers.contains_key(&id) {
	271	return;
	272	}
	273
	274	let detached = self.controllers.values().find(\|c\| !c.borrow().device.attached());
	275	match detached {
	276	Some(c) => {
	277	let mut c = c.borrow_mut();
	278	c.device = device;
	279	c.haptic = haptic.map(\|h\| Rc::new(RefCell::new(h)));
	280	}
	281	None => {
	282	let c = Rc::new(RefCell::new(Controller::new(device, haptic.map(\|h\| Rc::new(RefCell::new(h))))));
	283	self.controllers.insert(id, c);
	284	}
	285	};
	286	}
	287
	288	fn remove_device(&mut self, id: i32) {
	289	println!("device removed ({})!", id);
	290	// TODO
	291	}
	292	}