Ouya controller support broken?

[Rybar]

Been trying to get Ouya controller input working and not having much luck.  In a plain openFL project (no haxeflixel) it's simply a JoystickEvent. I read the axes and buttons and it just works.  FlxGamepadManager seems to have code referencing the openfl-ouya lib which I've been told by singmajesty isn't necessary, and conditionals preventing openFL.events.JoystickEvent from being compiled for the android target which isn't right. I've tried fixing the conditionals myself, but still haven't had any luck getting any controller input going on the OUYA.  I see there's an OUYAcontroller map put together, so obviously it worked at some point?  

Anyone here working on an OUYA game with the current version of haxeflixel?  Need assistance please.

[Alexander]

Can you attach working openfl sample project (which works with OUYA) and list of ids for buttons, axis, etc.

I don't have an OUYA device. That's why gamepad manager haven't been updated for some time. But i know how it works and i'd like to help you to solve this problem.

[James Grimwood]

I'm also trying to use Haxeflixel on my Ouya.

I'm a bit confused how Haxeflixel/OpenFL knows the difference between Android and Ouya - i.e am I supposed to do anything with the Ouya Dev kit that can be downloaded from their website? Currently I just choose "Android" from FlashDevelop, hit F5 and it appears on my Ouya (just then with no controls).

Also... where do trace() messages go?

[Gama11]

HaxeFlixel doesn't know, it only knows when you use the openfl-ouya lib because in that case, the openfl_ouya define is set.

traces are redirected to the flixel debugger by default. You can turn that off with FlxG.log.redirectTraces = false; 

[James Grimwood]

I am having ... inconsistent ... results.

Some trial and error has lead me to discover the controller is number 3. If you then use the 

flixel.system.input.gamepad.OUYAButtonID

constants to refer to the controller, most of it seems to work (although the right thumbstick doesn't seem to do anything).

Including openfl-ouya in my projects causes them to crash. It didn't used to, then I updated OpenFL and Haxeflixel. I've now got OpenFL 1.2.2 and Flixel 3.0.3

What does openfl-ouya do anyway?

Turning the controller off stops it from working and it becomes controller "4". I seem to recall this being a general problem with joypads?

[Beeblerox]

yes, i heard about problems with device id on OUYA.
openfl-ouya used to be some sort of "glue", but in newer versions of openfl it isn't required anymore.
so what about sample project for ouya? or it works the same way as any other type of gamepad?

[Rybar]

I had only gotten so far as getting a thumbstick to respond, but yes it works without the openfl-ouya library, which like James mentioned, causes current openfl projects to crash in ouya.  Again, this is just super simple openfl moving a sprite around with the thumbstick, no haxeflixel. Just the HandlingKeyboardInput example that comes with OpenFL, with JoystickEvent tacked on.

package;

import flash.display.Bitmap;

import flash.display.Sprite;

import flash.events.Event;

import flash.events.KeyboardEvent;

import flash.ui.Keyboard;

import openfl.Assets;

import openfl.events.JoystickEvent;

class Main extends Sprite {

private var Logo:Sprite;

private var movingDown:Bool;

private var movingLeft:Bool;

private var movingRight:Bool;

private var movingUp:Bool;

public function new () {

super ();

Logo = new Sprite ();

Logo.addChild (new Bitmap (Assets.getBitmapData ("assets/openfl.png")));

Logo.x = 100;

Logo.y = 100;

Logo.buttonMode = true;

addChild (Logo);

stage.addEventListener (KeyboardEvent.KEY_DOWN, stage_onKeyDown);

stage.addEventListener (JoystickEvent.AXIS_MOVE, stage_onJoystickAxisMove);

stage.addEventListener (KeyboardEvent.KEY_UP, stage_onKeyUp);

stage.addEventListener (Event.ENTER_FRAME, this_onEnterFrame);

}

// Event Handlers

private function stage_onKeyDown (event:KeyboardEvent):Void {

switch (event.keyCode) {

case Keyboard.DOWN: movingDown = true;

case Keyboard.LEFT: movingLeft = true;

case Keyboard.RIGHT: movingRight = true;

case Keyboard.UP: movingUp = true;

}

}

private function stage_onJoystickAxisMove(e:JoystickEvent):Void 

{

Logo.x += e.axis[0] * 5;

Logo.y += e.axis[1] * 5;

}

private function stage_onKeyUp (event:KeyboardEvent):Void {

switch (event.keyCode) {

case Keyboard.DOWN: movingDown = false;

case Keyboard.LEFT: movingLeft = false;

case Keyboard.RIGHT: movingRight = false;

case Keyboard.UP: movingUp = false;

}

}

private function this_onEnterFrame (event:Event):Void {

if (movingDown) {

Logo.y += 5;

}

if (movingLeft) {

Logo.x -= 5;

}

if (movingRight) {

Logo.x += 5;

}

if (movingUp) {

Logo.y -= 5;

}

}

}

[James Grimwood]

From my limited pokings around it seems to work like an XBox controller, but you use different constants...

 

var g:FlxGamepad = FlxG.gamepads.get(3);

if (g.anyInput()) {...}
if (g.pressed(OUYAButtonID.O)) {...}
if ((g.getAxis(OUYAButtonID.RIGHT_ANALOGUE_X)) > 0.3) {...}

I'm going to have a look in FlxGamepadManager to see if I can create a simple "Give me the ID of whatever controller just created some input" function that I can poll to check the controller hasn't gone away. It'll break horribly on games that require more than one controller though.

There's no way to give specific physical controllers unique IDs, is there? Flixel just has a map of controllers it's found somehow, doesn't it?

[James Grimwood]

On Friday, 27 December 2013 16:22:04 UTC, Rybar wrote:

I had only gotten so far as getting a thumbstick to respond, but yes it works without the openfl-ouya library, which like James mentioned, causes current openfl projects to crash in ouya.  

I wish FlashDevelop displayed the debugging output from adb (and then had a way to filter just the "I/trace" parts. It's a bit hard to call up the handy Flixel debugger when you've got no keyboard ;-)

[Gama11]

You can do that via code, like FlxG.debugger.visible = true, and hook that up to a key or a button if you want.

[Samuel Batista]

OUYA controls behave just like regular gamepads on an Android platform. Building for Android should give you access to gamepad access.

The one thing that might be problematic is the controller IDs. You can't assume the controller is on ID 1. You could have a "title screen" that subscribes directly to the Joystick events (instead of using HaxeFlixel gamepad API), and when any button is pressed, you store which controller ID is active.

You can then use the HaxeFlixel API to read controller inputs for the active controller ID. I haven't compiled for the OUYA yet, but I used the gamepad API on my Nexus 7 and it worked fine (it was a while ago though, so there might be a bug with HaxeFlixel).

We appreciate any help in tracking these types of issues down.

[Beeblerox]

Here is a slightly modified Xbox controller demo https://github.com/Beeblerox/OUYA_gamepad_test you'll need to use dev version of HaxeFlixel to compile it (i've added couple functions for gamepad detection and removed openfl_ouya specific code). Don't look at the graphic (there is XBox controller image), it's just for visualisation
I hope it will work on OUYA (i don't have such device, so i can't test it). Please tell me how it works on a real device and sorry for such delay between my answers

[James Grimwood]

On Saturday, 4 January 2014 08:48:17 UTC, Beeblerox wrote:

Here is a slightly modified Xbox controller demo https://github.com/Beeblerox/OUYA_gamepad_test you'll need to use dev version of HaxeFlixel to compile it (i've added couple functions for gamepad detection and removed openfl_ouya specific code). Don't look at the graphic (there is XBox controller image), it's just for visualisation

Thanks! I'll give this a go later.

If I switch to the dev branch to use this, are there any differences in Haxeflixel dev (compared to the regular version) I should know about?

Also... Is there any reason why the XBox 360 D-Pad doesn't work in Windows? All the DPad stuff is only compiled on a Mac according to its #defines.

Or is that what the "hat" thing refers to in your Ouya demo? (In the Windows XBox controller control panel the D-Pad is seen as a 'Hat')

 

I hope it will work on OUYA (i don't have such device, so i can't test it). Please tell me how it works on a real device and sorry for such delay between my answers

Don't worry about it :-) 

[Beeblerox]

There is no big differencies between dev and master branch you should worry about (just new features and bugfixes). And yes D-Pad is called 'Hat' in the code.
if you're talking about the demo i've provided today then it's okay - it shouldn't work with XBox controller - if you look into the code then you'll see that i've changed keycodes for OUAY's buttons, axis and everything else (and just left original graphics). And the main problem while working with different gamepads is that they have different codes for buttons (and other input elements)
if you want demo which works with an XBox controller then you can look at this one: https://github.com/HaxeFlixel/flixel-demos/tree/dev/Input/Xbox-Gamepad

[Rybar]

Yes, it works!  The ouya button mappings aren't quite right, I think I can get that figured out though. Thanks Beeblerox.  I had actually tried to do this exact thing, but ran into issues when trying to get rid of all the ouya specific code in both the example and flixel.

[Gama11]

Be sure to report back with correct mappings once you got them so the OuyaButtonID class can be fixed. :)

[Beeblerox]

It would be great if you provide correct codes for buttons on OUYA controller

суббота, 4 января 2014 г., 21:28:48 UTC+4 пользователь Rybar написал:

[Rybar]

I got everything working except for the home/menu button. The docs at https://devs.ouya.tv/developers/docs/controllers seem to suggest that the home button is a special case, not sure what that means for haxe/openfl/flixel's inner workings:

NOTE: Because the menu button press is emulated, the up and down events happen at once. This means you won't be able to detect it being pressed using the passive anytime state querying. It's much more reliable to detect the menu press in your onKeyUp/Down code.

The button id's were just educated stabs in the dark. Most of my time was spent trying to figure out why I couldn't get the trigger axes working; then I discovered FlxGamepad was creating an array for them that was only 1x4.  Changed the array to 6 to account for the 2 more axes on the triggers, and re-used the existing xbox example assets to show them. 

Changes to FlxGamepad:

public function new(ID:Int, GlobalDeadZone:Float = 0) 

{

buttons = new Map<Int, FlxGamepadButton>();

ball = new FlxPoint();

axis = new Array<Float>();

axis = [for (i in 0...6) 0];

hat = new FlxPoint();

id = ID;

OUYAbuttonID:

public static inline var O:Int = 0; // 96

                public static inline var U:Int = 3; // 99

public static inline var Y:Int = 4; // 100

public static inline var A:Int = 1; // 97

public static inline var LB:Int = 6; // 102

public static inline var RB:Int = 7; // 103

//public static inline var BACK:Int = 5;

//public static inline var START:Int = 4;

public static inline var LEFT_ANALOGUE:Int = 10; // 106

public static inline var RIGHT_ANALOGUE:Int = 11; // 107

public static inline var HOME:Int = 2; // 82

public static inline var DPAD_UP:Int = 19;

public static inline var DPAD_DOWN:Int = 20;

public static inline var DPAD_LEFT:Int = 21;

public static inline var DPAD_RIGHT:Int = 22;

public static inline var LEFT_ANALOGUE_X:Int = 0;

public static inline var LEFT_ANALOGUE_Y:Int = 1;

public static inline var RIGHT_ANALOGUE_X:Int = 11;

public static inline var RIGHT_ANALOGUE_Y:Int = 14;

public static inline var LEFT_TRIGGER:Int = 8;

public static inline var RIGHT_TRIGGER:Int = 9;

public static inline var LEFT_TRIGGER_ANALOG:Int = 17;

public static inline var RIGHT_TRIGGER_ANALOG:Int = 18;

New Playstate of beeblerox's modified gamepad example:

package;

import flixel.FlxG;

import flixel.FlxSprite;

import flixel.FlxState;

#if cpp

import flixel.system.input.gamepad.FlxGamepad;

import flixel.system.input.gamepad.XboxButtonID;

import flixel.system.input.gamepad.OUYAButtonID;

#end

import flixel.util.FlxColor;

import flixel.util.FlxPoint;

class PlayState extends FlxState

{

inline static private var STICK_MOVEMENT_RANGE:Float = 10;

inline static private var ALPHA_OFF:Float = 0.5;

inline static private var ALPHA_ON:Float = 1;

inline static private var LB_Y:Float = 2;

inline static private var RB_Y:Float = 2;

static private var LEFT_STICK_POS:FlxPoint = new FlxPoint(80, 48);

static private var RIGHT_STICK_POS:FlxPoint = new FlxPoint(304, 136);

private var _controllerBg:FlxSprite;

private var _leftStick:FlxSprite;

private var _rightStick:FlxSprite;

private var _dPad:FlxSprite;

private var _xButton:FlxSprite;

private var _yButton:FlxSprite;

private var _aButton:FlxSprite;

private var _bButton:FlxSprite;

private var _backButton:FlxSprite;

private var _startButton:FlxSprite;

private var _LB:FlxSprite;

private var _RB:FlxSprite;

private var _LT:FlxSprite;

private var _RT:FlxSprite;

private var _LTA:FlxSprite;

private var _RTA:FlxSprite;

private var _homeButton:FlxSprite;

#if cpp

public static var GAMEPAD_ID:Int = -1;

private var _gamePad:FlxGamepad;

#end

override public function create():Void 

{

FlxG.cameras.bgColor = FlxColor.GRAY;

#if cpp

// Getting first availble gamepad

_gamePad = FlxG.gamepads.get(GAMEPAD_ID);

_LB = createSprite(71, LB_Y, "assets/LB.png", 0.8);

_RB = createSprite(367, RB_Y, "assets/RB.png", 0.8);

_LT = createSprite(10, LB_Y, "assets/LB.png", 0.8);

_RT = createSprite(450, RB_Y, "assets/RB.png", 0.8);

_LTA = createSprite(10, LB_Y+6, "assets/LB.png", 0.8);

_RTA = createSprite(450, RB_Y+6, "assets/RB.png", 0.8);

_controllerBg = createSprite(0, 0, "assets/xbox360_gamepad.png", 1);

_leftStick = createSprite(LEFT_STICK_POS.x, LEFT_STICK_POS.y, "assets/Stick.png");

_rightStick = createSprite(RIGHT_STICK_POS.x, RIGHT_STICK_POS.y, "assets/Stick.png");

_dPad = new FlxSprite(144, 126);

_dPad.loadGraphic("assets/DPad.png", true, false, 87, 87);

_dPad.alpha = ALPHA_OFF;

add(_dPad);

_xButton = createSprite(357, 70, "assets/X.png");

_yButton = createSprite(395, 34, "assets/Y.png");

_aButton = createSprite(395, 109, "assets/A.png");

_bButton = createSprite(433, 70, "assets/B.png");

_homeButton = createSprite((526 / 2)-16, 70, "assets/A.png");

_backButton = createSprite(199, 79, "assets/Back.png");

_startButton = createSprite(306, 79, "assets/Start.png");

//_startButton.alpha = ALPHA_OFF;

//_backButton.alpha = ALPHA_OFF;

#else

FlxG.log.add("GamePad is only supported on CPP Targets");

#end

}

#if cpp

private function createSprite(X:Float, Y:Float, Graphic:String, Alpha:Float = -1):FlxSprite

{

if (Alpha == -1)

{

Alpha = ALPHA_OFF;

}

var button:FlxSprite = new FlxSprite(X, Y, Graphic);

button.alpha = Alpha;

add(button);

return button;

}

override public function update():Void 

{

super.update();

if (_gamePad.pressed(OUYAButtonID.HOME))

{

_homeButton.alpha = ALPHA_ON;

}

else

{

_homeButton.alpha = ALPHA_OFF;

}

if (_gamePad.pressed(OUYAButtonID.LEFT_TRIGGER))

{

_LT.alpha = ALPHA_ON;

}

else

{

_LT.alpha = ALPHA_OFF;

}

if (_gamePad.pressed(OUYAButtonID.RIGHT_TRIGGER))

{

_RT.alpha = ALPHA_ON;

}

else

{

_RT.alpha = ALPHA_OFF;

}

if (_gamePad.pressed(OUYAButtonID.RIGHT_ANALOGUE))

{

_rightStick.alpha = ALPHA_ON;

_rightStick.color = 0x00FF00;

}

else

{

_rightStick.alpha = ALPHA_OFF;

_rightStick.color = 0xFFFFFF;

}

if (_gamePad.pressed(OUYAButtonID.LEFT_ANALOGUE))

{

_leftStick.alpha = ALPHA_ON;

_leftStick.color = 0x00FF00;

}

else

{

_leftStick.alpha = ALPHA_OFF;

_leftStick.color = 0xFFFFFF;

}

if (_gamePad.pressed(OUYAButtonID.O))

{

_aButton.alpha = ALPHA_ON;

}

else

{

_aButton.alpha = ALPHA_OFF;

}

if (_gamePad.pressed(OUYAButtonID.A))

{

_bButton.alpha = ALPHA_ON;

}

else

{

_bButton.alpha = ALPHA_OFF;

}

if (_gamePad.pressed(OUYAButtonID.U))

{

_xButton.alpha = ALPHA_ON;

}

else

{

_xButton.alpha = ALPHA_OFF;

}

if (_gamePad.pressed(OUYAButtonID.Y))

{

_yButton.alpha = ALPHA_ON;

}

else

{

_yButton.alpha = ALPHA_OFF;

}

if (_gamePad.pressed(OUYAButtonID.LB))

{

_LB.y = LB_Y + 5;

}

else

{

_LB.y = LB_Y;

}

if (_gamePad.pressed(OUYAButtonID.RB))

{

_RB.y = RB_Y + 5;

}

else

{

_RB.y = RB_Y;

}

_LTA.alpha = _gamePad.getAxis(OUYAButtonID.LEFT_TRIGGER_ANALOG);

_RTA.alpha = _gamePad.getAxis(OUYAButtonID.RIGHT_TRIGGER_ANALOG);

var angle:Float = 0;

if (Math.abs(_gamePad.getAxis(OUYAButtonID.LEFT_ANALOGUE_X)) > _gamePad.deadZone || Math.abs(_gamePad.getAxis(OUYAButtonID.LEFT_ANALOGUE_Y)) > _gamePad.deadZone)

{

angle = Math.atan2(_gamePad.getAxis(OUYAButtonID.LEFT_ANALOGUE_Y), _gamePad.getAxis(OUYAButtonID.LEFT_ANALOGUE_X));

_leftStick.x = LEFT_STICK_POS.x + STICK_MOVEMENT_RANGE * Math.cos(angle);

_leftStick.y = LEFT_STICK_POS.y + STICK_MOVEMENT_RANGE * Math.sin(angle);

_leftStick.alpha = ALPHA_ON;

}

else

{

_leftStick.x = LEFT_STICK_POS.x;

_leftStick.y = LEFT_STICK_POS.y;

_leftStick.alpha = ALPHA_OFF;

}

if (Math.abs(_gamePad.getAxis(OUYAButtonID.RIGHT_ANALOGUE_X)) > _gamePad.deadZone || Math.abs(_gamePad.getAxis(OUYAButtonID.RIGHT_ANALOGUE_Y)) > _gamePad.deadZone)

{

angle = Math.atan2(_gamePad.getAxis(OUYAButtonID.RIGHT_ANALOGUE_Y), _gamePad.getAxis(OUYAButtonID.RIGHT_ANALOGUE_X));

_rightStick.x = RIGHT_STICK_POS.x + STICK_MOVEMENT_RANGE * Math.cos(angle);

_rightStick.y = RIGHT_STICK_POS.y + STICK_MOVEMENT_RANGE * Math.sin(angle);

_rightStick.alpha = ALPHA_ON;

}

else

{

_rightStick.x = RIGHT_STICK_POS.x;

_rightStick.y = RIGHT_STICK_POS.y;

_rightStick.alpha = ALPHA_OFF;

}

if (_gamePad.hat.x != 0 || _gamePad.hat.y != 0)

{

if (_gamePad.hat.x > 0)

{

if (_gamePad.hat.y > 0)

{

_dPad.animation.frameIndex = 6;

}

else if (_gamePad.hat.y < 0)

{

_dPad.animation.frameIndex = 5;

}

else // gamePad.hat.y == 0

{

_dPad.animation.frameIndex = 2;

}

}

else if (_gamePad.hat.x < 0)

{

if (_gamePad.hat.y > 0)

{

_dPad.animation.frameIndex = 7;

}

else if (_gamePad.hat.y < 0)

{

_dPad.animation.frameIndex = 8;

}

else // gamePad.hat.y == 0

{

_dPad.animation.frameIndex = 4;

}

}

else // gamePad.hat.x == 0

{

if (_gamePad.hat.y > 0)

{

_dPad.animation.frameIndex = 3;

}

else if (_gamePad.hat.y < 0)

{

_dPad.animation.frameIndex = 1;

}

}

_dPad.alpha = ALPHA_ON;

}

else

{

_dPad.animation.frameIndex = 0;

_dPad.alpha = ALPHA_OFF;

}

}

#end

}

I have Ouya controller and button graphics; going to start putting together a  proper example with 4 controllers detected. If anyone figures out how to read the menu/home button, please share. Because of its special case, I can't just plug numbers til I stumble upon it I don't think.

[Beeblerox]

Thanks for button codes and note about axis number! I've pushed it to dev branch.
Here is simple test state which should help to detect codes for all gamepad buttons: https://gist.github.com/Beeblerox/8266663
Just run it on device and press/release buttons on your gamepad (with some delay - to be sure that there is delay between down and up events)
I hope it will help somehow

[Samuel Batista]

That gist looks pretty useful... perhaps it could be merged with the Gamepad demo in flixel-demos? That would help us point to an existing project when adding support for new button codes.

[Beeblerox]

 Please let me know if this gist will help you to detech Menu button code

[TOODX]

The home button took me awhile to figure out too. It's actually an android keyboard event :p

I made my own controller handler class, so I'm not using the built in flixel stuff, but you should be able to add this to the flixel gamepad stuff:

When you initialize the controller button listeners, add this:

  #if android

    // For the OUYA home button

    Lib.current.stage.addEventListener(KeyboardEvent.KEY_UP, onHome);

  #end

Then, your onHome function will trigger when any home button is pressed:

#if android

  private function onHome(e:KeyboardEvent):Void

  {

    if(e.keyCode == 16777234)

    {

      // do stuff here

    }

  }

#end

That keycode of 16777234 is the home button's key code. I also had to write my code a bit odd in that I had to always update the gamepad's key state to false then true when the button was hit. But I left that out of this snippet, in case that's just an issue with my controller handler code.

[Beeblerox]

Thanks a lot for Menu button keycode! i'll add it to Keyboard class

[Samuel Batista]

There's an FlxAndroidKeyboard class. This should probably belong there..

https://github.com/HaxeFlixel/flixel/blob/523c5707bf7c07742a0fbf91defefe9976e76619/flixel/system/input/android/FlxAndroidKeys.hx

On Jan 6, 2014 1:05 AM, "Beeblerox" <zaphy....@gmail.com> wrote:

Thanks a lot for Menu button keycode! i'll add it to Keyboard class

--
HaxeFlixel Development Community
See our github https://github.com/haxeflixel/ and our documentation http://haxeflixel.com/documentation/
---
You received this message because you are subscribed to a topic in the Google Groups "HaxeFlixel" group.
To unsubscribe from this topic, visit https://groups.google.com/d/topic/haxeflixel/hoOnjaN2XnI/unsubscribe.
To unsubscribe from this group and all its topics, send an email to haxeflixel+unsubscribe@googlegroups.com.
Visit this group at http://groups.google.com/group/haxeflixel.
To view this discussion on the web visit https://groups.google.com/d/msgid/haxeflixel/bef6914f-e1b7-4fa7-b1ee-1f43702d8ffc%40googlegroups.com.
For more options, visit https://groups.google.com/groups/opt_out.

[Beeblerox]

so it can be accessed like: FlxG.android.justPressed("MENU");

[Gama11]

We already had that in there since it was merged, right? :s