C++ 使用Allegro 5.0.2获取操纵杆输入

我是Allegro 5的新手，我已经用到目前为止仅有的几个教程编写了一些代码，但是我无法获得操纵杆输入

在这里的代码中，它只是两个垂直移动的条（这是一种非常懒惰的方法，只是在第二个条上交换x和y坐标）

#杂注注释（lib，“allegro-5.0.2-monolith-md-debug.lib”）
#包括
#包括
#包括
#包括
#包括
#包括
#定义FPS 0xFF
#定义屏幕\u W 1000
#定义屏幕_h750
#定义BAR_W 75
#定义BAR_H 10
枚举键
{
左键，右键
};
int main（int argc，字符**argv）
{
快板显示*显示=NULL；
快板事件队列*事件队列=空；
快板操纵杆*操纵杆=空；
快板计时器*计时器=空；
ALLEGRO_位图*bouncer=NULL；
浮动弹跳器x=屏幕W/2.0-条形W/2.0；
浮动弹跳器_y=屏幕_H-杆_H；
布尔键[2]={false，false}；
布尔重绘=真；
bool-doexit=false；
如果（！al_init（））
{
fprintf（stderr，“未能初始化快板！\n”）；
返回-1；
}
如果（！al_安装_键盘（））
{
fprintf（stderr，“未能初始化键盘！\n”）；
返回-1；
}
如果（！al_安装操纵杆（））
{
fprintf（stderr，“未能初始化操纵杆！\n”）；
}
重新配置操纵杆（）；
操纵杆=手动操作杆（手动操作杆（）-1）；
计时器=所有创建计时器（1.0/FPS）；
如果（！计时器）
{
fprintf（stderr，“未能创建计时器！\n”）；
返回-1；
}
显示=所有创建显示（屏幕W、屏幕H）；
如果（！显示）
{
fprintf（stderr，“未能创建显示！\n”）；
al_销毁_定时器（定时器）；
返回-1；
}
bouncer=al_创建_位图（条形图W、条形图H）；
如果（！保镖）
{
fprintf（stderr，“创建弹跳器位图失败！\n”）；
铝显示器（显示器）；
al_销毁_定时器（定时器）；
返回-1；
}
al_设置_目标_位图（弹跳器）；
alu-clear-to-color（alu-map-rgb（0,0255））；
al_设置\目标\位图（al_获取\后缓冲（显示））；
event_queue=al_create_event_queue（）；
如果（！事件队列）
{
fprintf（stderr，“创建事件队列失败！\n”）；
al_销毁_位图（弹跳器）；
铝显示器（显示器）；
al_销毁_定时器（定时器）；
返回-1；
}
al_寄存器\事件\源（事件\队列，al_获取\显示\事件\源（显示））；
al_寄存器\事件\源（事件\队列，al_获取\计时器\事件\源（计时器））；
al_寄存器\事件\源（事件\队列，al_获取\键盘\事件\源（））；
al_寄存器\事件\源（事件\队列，al_获取\事件\源（））；
al_clear_to_color（al_map_rgb（0,0,0））；
al_flip_display（）；
启动定时器（定时器）；
而（！doexit）
{
快板；
等待事件（事件队列和ev）；
如果（ev.type==快板事件计时器）
{
如果（键[左键]&&bouncer\u x>=2.0）
弹跳器_x-=2.0；
如果（key[key_RIGHT]&&bouncer_x 0&&bouncer_x我看不出你做错了什么，但我的游戏中使用了控制器，所以我的代码可能会透露一些信息。顺便说一句，我使用的是Xbox 360控制器。实际上，我使用的是GameStop品牌的360控制器，所以它在技术上不是官方的。总之，这是我的相关代码（完整来源是怪物）：

你是否运行过ex_操纵杆事件示例？可用@。它应该有助于确定要使用的杆/轴。我在你的链接中没有找到任何东西，只是论坛的一些其他链接，它们是无助的。单击ex_操纵杆事件链接或在此处下载所有示例：。O明白了，没有看到它们，tnx；
#pragma comment (lib,"allegro-5.0.2-monolith-md-debug.lib")
#include <stdio.h>
#include <string>
#include <iostream>
#include <allegro5/allegro.h>
#include <allegro5/allegro_font.h>
#include <allegro5/allegro_ttf.h>

#define FPS 0xFF
#define SCREEN_W 1000
#define SCREEN_H 750
#define BAR_W 75
#define BAR_H 10

enum KEYS
{
    KEY_LEFT, KEY_RIGHT
};

int main(int argc, char **argv)
{
    ALLEGRO_DISPLAY *display = NULL;
    ALLEGRO_EVENT_QUEUE *event_queue = NULL;
    ALLEGRO_JOYSTICK *joystick = NULL;
    ALLEGRO_TIMER *timer = NULL;
    ALLEGRO_BITMAP *bouncer = NULL;
    float bouncer_x = SCREEN_W / 2.0 - BAR_W / 2.0;
    float bouncer_y = SCREEN_H - BAR_H;
    bool key[2] = {false, false};
    bool redraw = true;
    bool doexit = false;

    if(!al_init())
    {
        fprintf(stderr, "failed to initialize allegro!\n");
        return -1;
    }

    if(!al_install_keyboard())
    {
        fprintf(stderr, "failed to initialize the keyboard!\n");
        return -1;
    }

    if(!al_install_joystick())
    {
        fprintf(stderr, "failed to initialize the joystick!\n");
    }
    al_reconfigure_joysticks();
    joystick=al_get_joystick(al_get_num_joysticks()-1);

    timer = al_create_timer(1.0 / FPS);
    if(!timer)
    {
        fprintf(stderr, "failed to create timer!\n");
        return -1;
    }

    display = al_create_display(SCREEN_W, SCREEN_H);
    if(!display)
    {
        fprintf(stderr, "failed to create display!\n");
        al_destroy_timer(timer);
        return -1;
    }

    bouncer = al_create_bitmap(BAR_W, BAR_H);
    if(!bouncer)
    {
        fprintf(stderr, "failed to create bouncer bitmap!\n");
        al_destroy_display(display);
        al_destroy_timer(timer);
        return -1;
    }

    al_set_target_bitmap(bouncer);
    al_clear_to_color(al_map_rgb(0, 0, 255));
    al_set_target_bitmap(al_get_backbuffer(display));

    event_queue = al_create_event_queue();
    if(!event_queue)
    {
        fprintf(stderr, "failed to create event_queue!\n");
        al_destroy_bitmap(bouncer);
        al_destroy_display(display);
        al_destroy_timer(timer);
        return -1;
    }

    al_register_event_source(event_queue, al_get_display_event_source(display));
    al_register_event_source(event_queue, al_get_timer_event_source(timer));
    al_register_event_source(event_queue, al_get_keyboard_event_source());
    al_register_event_source(event_queue, al_get_joystick_event_source());
    al_clear_to_color(al_map_rgb(0,0,0));

    al_flip_display();
    al_start_timer(timer);

    while(!doexit)
    {
        ALLEGRO_EVENT ev;
        al_wait_for_event(event_queue, &ev);


        if(ev.type == ALLEGRO_EVENT_TIMER)
        {

            if(key[KEY_LEFT] && bouncer_x >= 2.0)
                bouncer_x -= 2.0;

            if(key[KEY_RIGHT] && bouncer_x <= SCREEN_W - BAR_W - 2.0)
                bouncer_x += 2.0;

            redraw = true;
        }

        else if(ev.type == ALLEGRO_EVENT_JOYSTICK_AXIS
                && ev.joystick.stick == 0
                && ev.joystick.axis == 0)
        {        
            float joypos=ev.joystick.pos;

            if(joypos<0 && bouncer_x >= 2.0)
                bouncer_x-=joypos;

            if(joypos>0 && bouncer_x <= SCREEN_W - BAR_W - 2.0)
                bouncer_x+=joypos;

            if(joypos=0)
                bouncer_x=SCREEN_W/2;
        }

        else if(ev.type == ALLEGRO_EVENT_DISPLAY_CLOSE)
            break;

        else if(ev.type == ALLEGRO_EVENT_KEY_DOWN)
        {
            switch(ev.keyboard.keycode)
            {
            case ALLEGRO_KEY_LEFT:
                key[KEY_LEFT] = true;
                break;

            case ALLEGRO_KEY_RIGHT:
                key[KEY_RIGHT] = true;
                break;
            }
        }
        else if(ev.type == ALLEGRO_EVENT_KEY_UP)
        {
            switch(ev.keyboard.keycode)
            {
            case ALLEGRO_KEY_LEFT: 
                key[KEY_LEFT] = false;
                break;

            case ALLEGRO_KEY_RIGHT:
                key[KEY_RIGHT] = false;
                break;

            case ALLEGRO_KEY_ESCAPE:
                doexit = true;
                break;
            }
        }

        if(redraw && al_is_event_queue_empty(event_queue))
        {
            std::string str=al_get_joystick_name(joystick);
            redraw = false;

            al_clear_to_color(al_map_rgb(0,0,0));

            al_draw_bitmap(bouncer, bouncer_x, bouncer_y, 0);
            al_draw_bitmap(bouncer, bouncer_y, bouncer_x, 0);

            std::cout << ev.joystick.pos << " ";
            std::cout << str << " ";
            std::cout << al_get_joystick_active(joystick) << std::endl;

            al_flip_display();
        }
    }

    al_destroy_bitmap(bouncer);
    al_destroy_timer(timer);
    al_destroy_display(display);
    al_destroy_event_queue(event_queue);

    return 0;
}

    if(ev.type == ALLEGRO_EVENT_JOYSTICK_AXIS){
        if(ev.type == ALLEGRO_EVENT_JOYSTICK_AXIS){
        if(ev.joystick.stick == 0){ //float joys[3][2]
            joys[ev.joystick.stick][ev.joystick.axis] = ev.joystick.pos;
        }
     }


    void SetPosition(){

    int leftStick = 0;
    int rightStick = 1;
    int dPad = 2;

    int x = 0;
    int y = 1;
    int z = 2;

    bitmapX += joys[leftStick][x];
    bitmapY += joys[leftStick][y];
    }