Add Wiimote support

flixel/input/gamepad/FlxGamepad.hx

@@ -4,10 +4,14 @@ import flixel.input.FlxInput.FlxInputState;
 import flixel.input.gamepad.FlxGamepadInputID;
 import flixel.input.gamepad.id.FlxGamepadAnalogList;
 import flixel.input.gamepad.id.FlxGamepadButtonList;
+import flixel.input.gamepad.id.FlxGamepadMotionValueList;
+import flixel.input.gamepad.id.FlxGamepadPointerValueList;
+import flixel.input.gamepad.id.WiiRemoteID;
 import flixel.math.FlxPoint;
 import flixel.math.FlxVector;
 import flixel.util.FlxDestroyUtil;
 import flixel.util.FlxStringUtil;
+import flixel.util.FlxTimer;
 
 #if FLX_GAMEINPUT_API
 import flash.ui.GameInputControl;
@@ -32,6 +36,12 @@ class FlxGamepad implements IFlxDestroyable
 	 */
 	public var model(default, set):FlxGamepadModel;
 
+	/**
+	 * For gamepads that can have things plugged into them (the Wii Remote, basically).
+	 * Making the user set this helps
+	 */
+	public var attachment(default, set):FlxGamepadModelAttachment;
+
 	/**
 	 * The gamepad model this gamepad has been identified as.
 	 */
@@ -63,6 +73,14 @@ class FlxGamepad implements IFlxDestroyable
 	 * Helper class to get the justMoved, justReleased, and float values of analog input.
 	 */
 	public var analog(default, null):FlxGamepadAnalogList;
+	/**
+	 * Helper class to get the float values of motion-sensing input, if it is available
+	 */
+	public var motion(default, null):FlxGamepadMotionValueList;
+	/**
+	 * Helper class to get the float values of mouse-like pointer nput, if it is available
+	 */
+	public var pointer(default, null):FlxGamepadPointerValueList;
 
 	#if FLX_JOYSTICK_API
 	public var hat(default, null):FlxPoint = FlxPoint.get();
@@ -86,40 +104,93 @@ class FlxGamepad implements IFlxDestroyable
 	private var _isChrome:Bool = false;
 	#end
 
-	public function new(ID:Int, Manager:FlxGamepadManager, ?Model:FlxGamepadModel) 
+	public function new(ID:Int, Manager:FlxGamepadManager, ?Model:FlxGamepadModel, ?Attachment:FlxGamepadModelAttachment) 
 	{
 		id = ID;
 
 		manager = Manager;
 
+		pressed = new FlxGamepadButtonList(FlxInputState.PRESSED, this);
+		justPressed = new FlxGamepadButtonList(FlxInputState.JUST_PRESSED, this);
+		justReleased = new FlxGamepadButtonList(FlxInputState.JUST_RELEASED, this);
+		analog = new FlxGamepadAnalogList(this);
+		motion = new FlxGamepadMotionValueList(this);
+		pointer = new FlxGamepadPointerValueList(this);
+
 		if (Model == null)
 			Model = XBox360;
+
+		if (Attachment == null)
+			Attachment = None;
 
-		buttonIndex = new FlxGamepadMapping(model);
+		buttonIndex = new FlxGamepadMapping(model, attachment);
 		model = Model;
 		detectedModel = Model;
 
 		#if flash
 		_isChrome = (Capabilities.manufacturer == "Google Pepper");
 		#end
-
-		pressed = new FlxGamepadButtonList(FlxInputState.PRESSED, this);
-		justPressed = new FlxGamepadButtonList(FlxInputState.JUST_PRESSED, this);
-		justReleased = new FlxGamepadButtonList(FlxInputState.JUST_RELEASED, this);
-		analog = new FlxGamepadAnalogList(this);
+	}
+
+	public function traceAxes(f:FlxTimer):Void
+	{
+		if (axis == null) return;
+		if (FlxG.gamepads.lastActive != this) return;
+		var str:String = "";
+		for (i in 0...axis.length)
+		{
+			var num = Std.int(axis[i] * 1000) / 1000;
+			str += num;
+			str += " | ";
+		}
+		trace(str);
+	}
+
+	public function traceButtons(f:FlxTimer):Void
+	{
+		if (buttons == null) return;
+		if (FlxG.gamepads.lastActive != this) return;
+		var str:String = "";
+		for (i in 0...buttons.length)
+		{
+			if (buttons[i] != null)
+			{
+				str += buttons[i].ID;
+				str += ":" + (buttons[i].pressed ? "X":"_");
+				str += ",";
+			}
+		}
+		trace(str);
 	}
 
 	public function set_model(Model:FlxGamepadModel):FlxGamepadModel
 	{
 		model = Model;
 		buttonIndex.model = Model;
+
+		motion.available = buttonIndex.supportsMotion();
+
 		#if FLX_JOYSTICK_API
 		leftStick = getRawAnalogStick(FlxGamepadInputID.LEFT_ANALOG_STICK);
 		rightStick = getRawAnalogStick(FlxGamepadInputID.RIGHT_ANALOG_STICK);
 		#end
+
 		return model;
 	}
 
+	private var t:FlxTimer = null;
+
+	public function set_attachment(Attachment:FlxGamepadModelAttachment):FlxGamepadModelAttachment
+	{
+		attachment = Attachment;
+		buttonIndex.attachment = Attachment;
+		#if FLX_JOYSTICK_API
+		leftStick = getRawAnalogStick(FlxGamepadInputID.LEFT_ANALOG_STICK);
+		rightStick = getRawAnalogStick(FlxGamepadInputID.RIGHT_ANALOG_STICK);
+		#end
+		return attachment;
+	}
+
 	/**
 	 * Returns the "universal" gamepad input ID Given a raw integer.
 	 */
@@ -143,6 +214,7 @@ class FlxGamepad implements IFlxDestroyable
 
 	public function getButton(RawID:Int):FlxGamepadButton
 	{
+		if (RawID == -1) return null;
 		var gamepadButton:FlxGamepadButton = buttons[RawID];
 
 		if (gamepadButton == null)
@@ -154,6 +226,11 @@ class FlxGamepad implements IFlxDestroyable
 		return gamepadButton;
 	}
 
+	public inline function getFlipAxis(AxisID:Int):Int
+	{
+		return buttonIndex.getFlipAxis(AxisID);
+	}
+
 	/**
 	 * Updates the key states (for tracking just pressed, just released, etc).
 	 */
@@ -184,6 +261,7 @@ class FlxGamepad implements IFlxDestroyable
 				button.press();
 			}
 		}
+
 		#elseif FLX_JOYSTICK_API
 		for (i in 0...axis.length)
 		{
@@ -193,7 +271,7 @@ class FlxGamepad implements IFlxDestroyable
 			if (button != null)
 			{
 				//TODO: account for circular deadzone if an analog stick input is detected?
-				var value = Math.abs(axis[i]);
+				var value = Math.abs(axis[i]) * getFlipAxis(i);
 				if (value > deadZone)
 				{
 					button.press();
@@ -215,8 +293,19 @@ class FlxGamepad implements IFlxDestroyable
 				button.update();
 			}
 		}
+
+		if (timecounter > timecount)
+		{
+			timecounter = 0;
+			traceButtons(null);
+			//traceAxes(null);
+		}
+		timecounter += FlxG.elapsed;
 	}
 
+	private var timecounter:Float = 0;
+	private var timecount:Float = 1 / 16;
+
 	public function reset():Void
 	{
 		for (button in buttons)
@@ -489,9 +578,28 @@ class FlxGamepad implements IFlxDestroyable
 	 * use this only for things like FlxGamepadButtonID.LEFT_TRIGGER, 
 	 * use getXAxis() / getYAxis() for analog sticks!
 	 */
-	public inline function getAxis(AxisButtonID:FlxGamepadInputID):Float
+	public function getAxis(AxisButtonID:FlxGamepadInputID):Float
 	{
-		return getAxisRaw(getRawID(AxisButtonID));
+		#if !FLX_JOYSTICK_API
+			return getAxisRaw(getRawID(AxisButtonID));
+		#else
+			var fakeAxisRawID:Int = checkForFakeAxis(AxisButtonID);
+
+			if (fakeAxisRawID == -1)
+			{
+				//return the regular axis value
+				var rawID = getRawID(AxisButtonID);
+				return getAxisRaw(rawID) * getFlipAxis(AxisButtonID);
+			}
+			else
+			{
+				//if analog isn't supported for this input, return the correct digital button input instead
+				var btn = getButton(fakeAxisRawID);
+				if (btn == null) return 0;
+				if (btn.pressed) return 1;
+			}
+			return 0;
+		#end
 	}
 
 	/**
@@ -518,12 +626,34 @@ class FlxGamepad implements IFlxDestroyable
 		return buttonIndex.axisIndexToRawID(AxisIndex);
 	}
 
-	public inline function isAxisForAnalogStick(AxisIndex:Int):Bool
+	public inline function checkForFakeAxis(ID:FlxGamepadInputID):Int
+	{
+		return buttonIndex.checkForFakeAxis(ID);
+	}
+
+	public function isAxisForMotion(AxisIndex:Int):Bool
+	{
+		return buttonIndex.isAxisForMotion(AxisIndex);
+	}
+
+	public function isAxisForAnalogStick(AxisIndex:Int):Bool
+	{
+		if (leftStick != null)
+		{
+			if (AxisIndex == leftStick.x  || AxisIndex == leftStick.y)  return true;
+		}
+		if (rightStick != null)
+		{
+			if (AxisIndex == rightStick.x || AxisIndex == rightStick.y) return true;
+		}
+		return false;
+	}
+
+	public inline function getAnalogStickByAxis(AxisIndex:Int):FlxGamepadAnalogStick
 	{
-		return AxisIndex == leftStick.x  ||
-		       AxisIndex == leftStick.y  ||
-		       AxisIndex == rightStick.x ||
-		       AxisIndex == rightStick.y;
+		if (leftStick != null  && AxisIndex == leftStick.x  || AxisIndex == leftStick.y)  return leftStick;
+		if (rightStick != null && AxisIndex == rightStick.x || AxisIndex == rightStick.y) return rightStick;
+		return null;
 	}
 	#end
 
@@ -625,6 +755,10 @@ class FlxGamepad implements IFlxDestroyable
 		var axisValue:Float = 0;
 
 		#if FLX_GAMEINPUT_API
+		if (AxisID == -1)
+		{
+			return 0;
+		}
 		if ((_device != null) && _device.enabled)
 		{
 			axisValue = _device.getControlAt(AxisID).value;
@@ -643,6 +777,7 @@ class FlxGamepad implements IFlxDestroyable
 
 	private function getAnalogXAxisValue(stick:FlxGamepadAnalogStick):Float
 	{
+		if (stick == null) return 0;
 		return if (deadZoneMode == CIRCULAR)
 			getAnalogAxisValueCircular(stick, stick.x);
 		else
@@ -651,6 +786,7 @@ class FlxGamepad implements IFlxDestroyable
 
 	private function getAnalogYAxisValue(stick:FlxGamepadAnalogStick):Float
 	{
+		if (stick == null) return 0;
 		return if (deadZoneMode == CIRCULAR)
 			getAnalogAxisValueCircular(stick, stick.y);
 		else
@@ -659,6 +795,7 @@ class FlxGamepad implements IFlxDestroyable
 
 	private function getAnalogAxisValueCircular(stick:FlxGamepadAnalogStick, axisID:Int):Float
 	{
+		if (stick == null) return 0;
 		var xAxis = getAxisValue(stick.x);
 		var yAxis = getAxisValue(stick.y);
 
@@ -719,13 +856,55 @@ class FlxGamepadAnalogStick
 	public var x(default, null):Int;
 	public var y(default, null):Int;
 
-	public function new(x:Int, y:Int)
+	//these values let the analog stick to send digital inputs to, say, the dpad
+	public var rawUp(default, null):Int = -1;
+	public var rawDown(default, null):Int = -1;
+	public var rawLeft(default, null):Int = -1;
+	public var rawRight(default, null):Int = -1;
+
+	//the value the dpad must be above before digital inputs are sent
+	public var digitalThreshold(default, null):Float = 0.5;
+
+	//when analog inputs are received, how to process them digitally
+	public var mode(default, null):AnalogToDigitalMode = SendOnlyAnalog;
+
+	public function new(x:Int, y:Int, ?settings:FlxGamepadAnalogStickSettings)
 	{
 		this.x = x;
 		this.y = y;
+		if (settings != null)
+		{
+			mode     = (settings.mode  != null ? settings.mode  : SendOnlyAnalog);
+			rawUp    = (settings.up    != null ? settings.up    : -1);
+			rawDown  = (settings.down  != null ? settings.down  : -1);
+			rawLeft  = (settings.left  != null ? settings.left  : -1);
+			rawRight = (settings.right != null ? settings.right : -1);
+			digitalThreshold = (settings.threshold != null ? settings.threshold : -1);
+		}
+	}
+
+	public function toString():String
+	{
+		return("stick(" + x + "," + y + ",(" + rawUp + "," + rawDown + "," + rawLeft + "," + rawRight + ") @" + digitalThreshold + ":" + mode+")");
 	}
 }
 
+typedef FlxGamepadAnalogStickSettings = {
+	@:optional var up:Int;
+	@:optional var down:Int;
+	@:optional var left:Int;
+	@:optional var right:Int;
+	@:optional var threshold:Float;
+	@:optional var mode:AnalogToDigitalMode;
+}
+
+enum AnalogToDigitalMode
+{
+	SendBoth;
+	SendOnlyDigital;
+	SendOnlyAnalog;
+}
+
 enum FlxGamepadModel
 {
 	Logitech;
@@ -734,4 +913,13 @@ enum FlxGamepadModel
 	PS4;
 	XBox360;
 	XInput;
+	MayflashWiiRemote;
+	WiiRemote;
+}
+
+enum FlxGamepadModelAttachment
+{
+	WiiNunchuk;
+	WiiClassicController;
+	None;
 }