As I mentioned in my previous post, one of the advantages of abstracting game input with a class like KeyActionBinder is that supporting more than one platform is a fairly easy, one-step process: you simply specify the expected inputs during setup of the key binder.

I’m currently building a (fairly fun!) prototype and I plan on running it on the OUYA (and other Android devices) as well as the desktop (I haven’t tested iOS’ new gamepad support yet; I’m not sure Adobe AIR already supports it). The cool thing is that I’m able to use the exact same code for both versions; most of the times, I test the game on the desktop, but I run it on the OUYA once in a while to test performance (this is easier with a second monitor properly connected). This is how I do it.

First, I create the ids for the actions I’ll be using, and of course a variable to hold the KeyActionBinder instance I’ll be using.

// Constants
private static const ACTION_LEFT:String = "left";
private static const ACTION_RIGHT:String = "right";
private static const ACTION_JUMP:String = "jump";

// Instances
private var binder:KeyActionBinder;

Then, during the startup code of my game code, I set up the actions depending on the platform the application is running in, using KeyActionBinder and the accompanying GamepadControls class which contains a list of standard controls.

private function startGame(): void {
	var isAndroid:Boolean = Capabilities.manufacturer == "Android Linux";
	// This can also be : "Adobe iOS" (iOS), "Adobe Windows" (PC Windows), "Adobe Macintosh" (PC Mac)

	// Setup input
	binder = new KeyActionBinder(stage);

	if (isAndroid) {
		// Android and OUYA: use native controller
		binder.addGamepadActionBinding(ACTION_LEFT, GamepadControls.DPAD_LEFT);
		binder.addGamepadActionBinding(ACTION_RIGHT, GamepadControls.DPAD_RIGHT);
		binder.addGamepadActionBinding(ACTION_JUMP, GamepadControls.BUTTON_ACTION_DOWN);
	} else {
		// PC: use keyboard and XBox 360 controller
		binder.addKeyboardActionBinding(ACTION_LEFT, Keyboard.LEFT);
		binder.addKeyboardActionBinding(ACTION_RIGHT, Keyboard.RIGHT);
		binder.addKeyboardActionBinding(ACTION_JUMP, Keyboard.SPACE);

		binder.addGamepadActionBinding(ACTION_LEFT, GamepadControls.XBOX_DPAD_LEFT);
		binder.addGamepadActionBinding(ACTION_RIGHT, GamepadControls.XBOX_DPAD_RIGHT);
		binder.addGamepadActionBinding(ACTION_JUMP, GamepadControls.XBOX_BUTTON_ACTION_A);
	}
}

Then, during my main game loop, I set the speed of the player accordingly, and activate jump actions as needed (in this case I’m using a Box2D-based game, hence the interface being used by playerBody).

private function gameLoop():void {
	var newSpeed:Number = 0;
	var currSpeed:Number = playerBody.GetAngularVelocity();

	// Movement
	if (binder.isActionActivated(ACTION_LEFT)) {
		newSpeed = 10;
		playerBody.SetAngularVelocity(Math.max(currSpeed, currSpeed - (currSpeed - newSpeed) / 20));
	}
	if (binder.isActionActivated(ACTION_RIGHT)) {
		newSpeed = -10;
		playerBody.SetAngularVelocity(Math.min(currSpeed, currSpeed - (currSpeed - newSpeed) / 20));
	}

	// Jump
	if (binder.isActionActivated(ACTION_JUMP)) {
		// Check the number of current "hits" to the player body (meaning it's touching the ground or a wall)
		if (playerBody.GetUserData()["hits"] > 0) {
			// Jumps in any direction, using the last impact normal
			var jmpn:b2Vec2 = playerBody.GetUserData()["contactNormal"].Copy();
			jmpn.x *= 40;
			jmpn.y *= 40;
			playerBody.ApplyImpulse(jmpn, playerBody.GetWorldCenter());
		}
	}
}

With the above code, I’m able to run the project with no modifications and run both on the desktop, using an XBox controller (or the keyboard), and on the OUYA, using the native controller. The result, using a fairly ghetto “level” loaded from a R.U.B.E. file, looks like so (the circle in the middle is playerBody):

The code for the player input above controls the circle’s rotation speed and ability to jump from any surface. Physics wise, it’s still a prototype, but with the simple player input code in place, it’s much easier to test across a variety of platforms.

Note: it must be said that the GamepadControls constants I used in the above code will probably change names in the future, as I add more controls and properly differentiate between desktop and Android/OUYA controls.