bool GameController::open(int c)
{
if (sdl_device)
{
close();
}
if (c < 0 || c >= SDL_NumJoysticks())
{
return false;
}
if (!SDL_IsGameController(c))
{
return false;
}
sdl_device = SDL_GameControllerOpen(c);
if (sdl_device == nullptr)
{
printlog("Error: Failed to open game controller! SDL Error: %s\n", SDL_GetError());
}
else
{
id = c;
printlog("Successfully initialized game controller!\n");
name = (SDL_GameControllerNameForIndex(c));
printlog("Controller name is \"%s\"", name.c_str());
}
return (sdl_device != nullptr);
}
inline std::string controller_name(int index) {
const char* result = SDL_GameControllerNameForIndex(index);
if(result == nullptr) {
return "Unknown";
}
return result;
}
void IN_StartupJoystick (void)
{
int i;
int nummappings;
char controllerdb[MAX_OSPATH];
SDL_GameController *gamecontroller;
if (COM_CheckParm("-nojoy"))
return;
if (SDL_InitSubSystem(SDL_INIT_GAMECONTROLLER) == -1 )
{
Con_Warning("could not initialize SDL Game Controller\n");
return;
}
// Load additional SDL2 controller definitions from gamecontrollerdb.txt
q_snprintf (controllerdb, sizeof(controllerdb), "%s/gamecontrollerdb.txt", com_basedir);
nummappings = SDL_GameControllerAddMappingsFromFile(controllerdb);
if (nummappings > 0)
Con_Printf("%d mappings loaded from gamecontrollerdb.txt\n", nummappings);
// Also try host_parms->userdir
if (host_parms->userdir != host_parms->basedir)
{
q_snprintf (controllerdb, sizeof(controllerdb), "%s/gamecontrollerdb.txt", host_parms->userdir);
nummappings = SDL_GameControllerAddMappingsFromFile(controllerdb);
if (nummappings > 0)
Con_Printf("%d mappings loaded from gamecontrollerdb.txt\n", nummappings);
}
for (i = 0; i < SDL_NumJoysticks(); i++)
{
const char *joyname = SDL_JoystickNameForIndex(i);
if ( SDL_IsGameController(i) )
{
const char *controllername = SDL_GameControllerNameForIndex(i);
gamecontroller = SDL_GameControllerOpen(i);
if (gamecontroller)
{
Con_Printf("detected controller: %s\n", controllername != NULL ? controllername : "NULL");
joy_active_instaceid = SDL_JoystickInstanceID(SDL_GameControllerGetJoystick(gamecontroller));
joy_active_controller = gamecontroller;
break;
}
else
{
Con_Warning("failed to open controller: %s\n", controllername != NULL ? controllername : "NULL");
}
}
else
{
Con_Warning("joystick missing controller mappings: %s\n", joyname != NULL ? joyname : "NULL" );
}
}
}
static const char* sdl_pad_name(unsigned id)
{
#ifdef HAVE_SDL2
if (sdl_pads[id].controller)
return SDL_GameControllerNameForIndex(id);
return SDL_JoystickNameForIndex(id);
#else
return SDL_JoystickName(id);
#endif
}
void Renderer::detect_gamepads(){
if(SDL_NumJoysticks() >= 1){
std::cout << "Found one or more gamepads! Using '" << SDL_GameControllerNameForIndex(0) << "'" << std::endl;
gamepad = SDL_GameControllerOpen(0);
}
else {
std::cout << "No gamepads found. You will be able to control the visualization with mouse & keyboard." << std::endl;
gamepad = NULL;
}
}
static int lua_SDL_GameControllerNameForIndex(State & state){
Stack * stack = state.stack;
const char * name = SDL_GameControllerNameForIndex(stack->to<int>(1));
if (name){
stack->push<const std::string &>(name);
return 1;
}
else{
return 0;
}
}
/*
* SDL.gameControllerNameForIndex(index)
*
* Arguments:
* index the controller index
*
* Returns:
* The name or nil on failure
* The error message
*/
static int
l_gameControllerNameForIndex(lua_State *L)
{
int index = luaL_checkinteger(L, 1);
const char *name;
name = SDL_GameControllerNameForIndex(index);
if (name == NULL)
return commonPushSDLError(L, 1);
return commonPush(L, "s", name);
}
int
main(int argc, char *argv[])
{
const char *name;
int i;
int nController = 0;
SDL_GameController *gamecontroller;
SDL_SetHint( SDL_HINT_GAMECONTROLLERCONFIG, "341a3608000000000000504944564944,Aferglow PS3 Controller,a:b1,b:b2,y:b3,x:b0,start:b9,guide:b12,back:b8,dpup:h0.1,dpleft:h0.8,dpdown:h0.4,dpright:h0.2,leftshoulder:b4,rightshoulder:b5,leftstick:b10,rightstick:b11,leftx:a0,lefty:a1,rightx:a2,righty:a3,lefttrigger:b6,righttrigger:b7" );
/* Initialize SDL (Note: video is required to start event loop) */
if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_JOYSTICK | SDL_INIT_GAMECONTROLLER ) < 0) {
fprintf(stderr, "Couldn't initialize SDL: %s\n", SDL_GetError());
exit(1);
}
/* Print information about the controller */
for (i = 0; i < SDL_NumJoysticks(); ++i) {
if ( SDL_IsGameController(i) )
{
nController++;
name = SDL_GameControllerNameForIndex(i);
printf("Game Controller %d: %s\n", i, name ? name : "Unknown Controller");
}
}
printf("There are %d game controllers attached\n", nController);
if (argv[1]) {
int nreportederror = 0;
SDL_Event event;
gamecontroller = SDL_GameControllerOpen(atoi(argv[1]));
while ( s_ForceQuit == SDL_FALSE ) {
if (gamecontroller == NULL) {
if ( nreportederror == 0 ) {
printf("Couldn't open joystick %d: %s\n", atoi(argv[1]), SDL_GetError());
nreportederror = 1;
}
} else {
nreportederror = 0;
WatchGameController(gamecontroller);
SDL_GameControllerClose(gamecontroller);
}
gamecontroller = NULL;
SDL_WaitEvent( &event );
if ( event.type == SDL_JOYDEVICEADDED )
gamecontroller = SDL_GameControllerOpen(atoi(argv[1]));
}
}
SDL_QuitSubSystem(SDL_INIT_VIDEO | SDL_INIT_JOYSTICK | SDL_INIT_GAMECONTROLLER );
return (0);
}
static const char *sdl_joypad_name(unsigned pad)
{
if (pad >= MAX_USERS)
return NULL;
#ifdef HAVE_SDL2
if (sdl_pads[pad].controller)
return SDL_GameControllerNameForIndex(pad);
return SDL_JoystickNameForIndex(pad);
#else
return SDL_JoystickName(pad);
#endif
}
void SDLFrontend::initJoystickAndHaptic ()
{
if (_haptic != nullptr) {
SDL_HapticClose(_haptic);
_haptic = nullptr;
}
const int joysticks = SDL_NumJoysticks();
SDL_Haptic *haptic = nullptr;
for (int i = 0; i < joysticks; i++) {
const char *name;
if (SDL_IsGameController(i)) {
name = SDL_GameControllerNameForIndex(i);
} else {
name = SDL_JoystickNameForIndex(i);
}
SDL_Joystick *joystick = SDL_JoystickOpen(i);
info(LOG_CLIENT, String::format("found joystick %s", name ? name : "Unknown Joystick"));
info(LOG_CLIENT, String::format("joystick axes: %i", SDL_JoystickNumAxes(joystick)));
info(LOG_CLIENT, String::format("joystick hats: %i", SDL_JoystickNumHats(joystick)));
info(LOG_CLIENT, String::format("joystick balls: %i", SDL_JoystickNumBalls(joystick)));
info(LOG_CLIENT, String::format("joystick buttons: %i", SDL_JoystickNumButtons(joystick)));
if (haptic == nullptr)
haptic = SDL_HapticOpenFromJoystick(joystick);
}
if (!joysticks) {
info(LOG_CLIENT, "no joysticks found");
}
info(LOG_CLIENT, String::format("found %i touch device(s)", SDL_GetNumTouchDevices()));
info(LOG_CLIENT, String::format("%i haptic devices", SDL_NumHaptics()));
if (haptic == nullptr && SDL_MouseIsHaptic()) {
haptic = SDL_HapticOpenFromMouse();
}
if (haptic != nullptr) {
const bool rumbleSupported = SDL_HapticRumbleSupported(haptic) && SDL_HapticRumbleInit(haptic) == 0;
if (rumbleSupported) {
info(LOG_CLIENT, "rumble support");
_haptic = haptic;
}
}
if (_haptic == nullptr) {
info(LOG_CLIENT, "no rumble support");
}
}
static const char* gamepad_device_name_unmapped(int idx) {
const char *name = SDL_GameControllerNameForIndex(idx);
if(name == NULL) {
return "Unknown device";
}
if(!strcasecmp(name, "Xinput Controller")) {
// HACK: let's try to get a more descriptive name...
const char *prev_name = name;
name = SDL_JoystickNameForIndex(idx);
if(name == NULL) {
name = prev_name;
}
}
return name;
}
//===========================================================================
// XJoystickInit
//
// Creates and initializes joysticks.
//
// Parameters:
//
// Returns:
//
//===========================================================================
bool XJoystickInit() {
int i;
SDL_InitSubSystem(SDL_INIT_JOYSTICK);
SDL_InitSubSystem(SDL_INIT_GAMECONTROLLER);
SDL_JoystickEventState(SDL_ENABLE);
SDL_GameControllerEventState(SDL_ENABLE);
if(!SDL_WasInit(SDL_INIT_JOYSTICK) && SDL_InitSubSystem(SDL_INIT_JOYSTICK)) {
std::cout<<"Unable to initialize the joystick subsystem"<<std::endl;
return false;
}
for(i = 0; i < SDL_NumJoysticks(); ++i) {
if (SDL_IsGameController(i)) {
printf("Index \'%i\' is a compatible controller, named \'%s\'\n", i, SDL_GameControllerNameForIndex(i));
ctrl = SDL_GameControllerOpen(i);
joy = SDL_GameControllerGetJoystick(ctrl);
break;
} else {
printf("Index \'%s\' is not a compatible controller.\n", SDL_JoystickNameForIndex(i));
}
}
if (ctrl) {
JoystickAvailable = 1;
return true;
}
for(i = 0; i < SDL_NumJoysticks(); ++i) {
joy = SDL_JoystickOpen(i);
if (joy) {
printf("Index \'%i\' is a compatible joystick, named \'%s\'\n", i, SDL_JoystickNameForIndex(i));
break;
}
}
if (joy) {
JoystickAvailable = 1;
return true;
} else {
return false;
}
}
void Joystick::open() {
if (m_joystickHandle) {
close();
}
m_joystickHandle = SDL_JoystickOpen(m_deviceIndex);
if (m_joystickHandle) {
m_instanceId = SDL_JoystickInstanceID(m_joystickHandle);
char tmp[33];
SDL_JoystickGUID guid = SDL_JoystickGetDeviceGUID(m_deviceIndex);
SDL_JoystickGetGUIDString(guid, tmp, sizeof(tmp));
m_guidStr = std::string(tmp);
openController();
const char* name = SDL_JoystickNameForIndex(m_deviceIndex);
if (isController() && !name) {
name = SDL_GameControllerNameForIndex(m_deviceIndex);
}
m_name = std::string(name);
} else {
throw SDLException(SDL_GetError());
}
}
void PIN_GameControllerManager::AddGameController(int joy_index)
{
printf("Checking joystick #%d...\n",joy_index);
printf("Name: %s\n",SDL_JoystickNameForIndex(joy_index));
if(SDL_IsGameController(joy_index))
{
printf("This joystick is a gamecontroller. Adding to controller pool...\n");
printf("Game controller name: %s\n",SDL_GameControllerNameForIndex(joy_index));
PIN_GameControllerEntry* newEntry = CreateGameControllerEntry();
SDL_GameController* ctrl = SDL_GameControllerOpen(joy_index);
SDL_Joystick* joy = SDL_GameControllerGetJoystick(ctrl);
SDL_JoystickGUID joyGUID = SDL_JoystickGetGUID(joy);
char strGUID[PIN_BUFFER_SIZE];
SDL_JoystickGetGUIDString(joyGUID,strGUID, PIN_BUFFER_SIZE);
printf("Controller GUID: %s\n",strGUID);
SDL_JoystickID joyID = SDL_JoystickInstanceID(joy);
if(joyID < 0)
{
printf("Error: %s\n",SDL_GetError());
delete newEntry;
return;
}
else
{
newEntry->ControllerID = joyID + PIN_ID_JOYSTICK;
}
newEntry->Controller = ctrl;
newEntry->Joystick = joy;
newEntry->AxisDeadZone = 8000;
newEntry->GlobalKeys[PIN_GK_UP] = BuildComboSet(newEntry,SDL_GameControllerGetStringForButton(SDL_CONTROLLER_BUTTON_DPAD_UP));
newEntry->GlobalKeys[PIN_GK_DOWN] = BuildComboSet(newEntry,SDL_GameControllerGetStringForButton(SDL_CONTROLLER_BUTTON_DPAD_DOWN));
newEntry->GlobalKeys[PIN_GK_LEFT] = BuildComboSet(newEntry,SDL_GameControllerGetStringForButton(SDL_CONTROLLER_BUTTON_DPAD_LEFT));
newEntry->GlobalKeys[PIN_GK_RIGHT] = BuildComboSet(newEntry,SDL_GameControllerGetStringForButton(SDL_CONTROLLER_BUTTON_DPAD_RIGHT));
newEntry->GlobalKeys[PIN_GK_ENTER] = BuildComboSet(newEntry,SDL_GameControllerGetStringForButton(SDL_CONTROLLER_BUTTON_A));
newEntry->GlobalKeys[PIN_GK_BACK] = BuildComboSet(newEntry,SDL_GameControllerGetStringForButton(SDL_CONTROLLER_BUTTON_B));
PIN_KeyList lstDef = _controlType->DEFAULT_KEYS;
printf("Setting control type definitions...\n");
AssignKey(newEntry, &(newEntry->GlobalKeys),PIN_GK_UP,lstDef,PIN_KEY_UP);
AssignKey(newEntry, &(newEntry->GlobalKeys),PIN_GK_DOWN,lstDef,PIN_KEY_DOWN);
AssignKey(newEntry, &(newEntry->GlobalKeys),PIN_GK_LEFT,lstDef,PIN_KEY_LEFT);
AssignKey(newEntry, &(newEntry->GlobalKeys),PIN_GK_RIGHT,lstDef,PIN_KEY_RIGHT);
AssignKey(newEntry, &(newEntry->GlobalKeys),PIN_GK_ENTER,lstDef,PIN_KEY_ENTER);
AssignKey(newEntry, &(newEntry->GlobalKeys),PIN_GK_BACK,lstDef,PIN_KEY_BACK);
for(PIN_MappingList::iterator it = _mappingList->begin(); it!= _mappingList->end(); ++it)
{
PIN_Mapping* m = *it;
if(boost::equals(m->GUID,strGUID))
{
printf("Setting mapping-specific definitions...\n");
printf("Mapping name: '%s'\n",m->NAME);
PIN_KeyList m_keys = m->DEFAULT_KEYS;
newEntry->SourceMapping = m;
newEntry->AxisDeadZone = m->DEADZONE;
AssignKey(newEntry, &(newEntry->GlobalKeys),PIN_GK_UP,m_keys,PIN_KEY_UP);
AssignKey(newEntry, &(newEntry->GlobalKeys),PIN_GK_DOWN,m_keys,PIN_KEY_DOWN);
AssignKey(newEntry, &(newEntry->GlobalKeys),PIN_GK_LEFT,m_keys,PIN_KEY_LEFT);
AssignKey(newEntry, &(newEntry->GlobalKeys),PIN_GK_RIGHT,m_keys,PIN_KEY_RIGHT);
AssignKey(newEntry, &(newEntry->GlobalKeys),PIN_GK_ENTER,m_keys,PIN_KEY_ENTER);
AssignKey(newEntry, &(newEntry->GlobalKeys),PIN_GK_BACK,m_keys,PIN_KEY_BACK);
break;
}
}
if(_currentGameMode != NULL)
{
UpdateControllerGameMode(newEntry);
}
//_controllerList.push_back(newEntry);
AddController(newEntry);
}
else
{
printf("This joystick is NOT a gamecontroller. It can't be used.\n");
}
}
int main(int argc, char *argv[]) {
int i;
int nController = 0;
int retcode = 0;
char guid[64];
SDL_GameController *gamecontroller;
/* Enable standard application logging */
SDL_LogSetPriority(SDL_LOG_CATEGORY_APPLICATION, SDL_LOG_PRIORITY_INFO);
/* Initialize SDL (Note: video is required to start event loop) */
if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_JOYSTICK | SDL_INIT_GAMECONTROLLER) <
0) {
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't initialize SDL: %s\n",
SDL_GetError());
return 1;
}
SDL_GameControllerAddMappingsFromFile("gamecontrollerdb.txt");
/* Print information about the controller */
for (i = 0; i < SDL_NumJoysticks(); ++i) {
const char *name;
const char *description;
SDL_JoystickGetGUIDString(SDL_JoystickGetDeviceGUID(i), guid, sizeof(guid));
if (SDL_IsGameController(i)) {
nController++;
name = SDL_GameControllerNameForIndex(i);
description = "Controller";
} else {
name = SDL_JoystickNameForIndex(i);
description = "Joystick";
}
SDL_Log("%s %d: %s (guid %s)\n", description, i, name ? name : "Unknown",
guid);
}
SDL_Log("There are %d game controller(s) attached (%d joystick(s))\n",
nController, SDL_NumJoysticks());
if (argv[1]) {
SDL_bool reportederror = SDL_FALSE;
SDL_bool keepGoing = SDL_TRUE;
SDL_Event event;
int device = atoi(argv[1]);
if (device >= SDL_NumJoysticks()) {
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
"%i is an invalid joystick index.\n", device);
retcode = 1;
} else {
SDL_JoystickGetGUIDString(SDL_JoystickGetDeviceGUID(device), guid,
sizeof(guid));
SDL_Log("Attempting to open device %i, guid %s\n", device, guid);
gamecontroller = SDL_GameControllerOpen(device);
/* - this requires SDL 2.0.4
if (gamecontroller != NULL) {
SDL_assert(SDL_GameControllerFromInstanceID(SDL_JoystickInstanceID(SDL_GameControllerGetJoystick(gamecontroller)))
== gamecontroller);
}
*/
while (keepGoing) {
if (gamecontroller == NULL) {
if (!reportederror) {
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
"Couldn't open gamecontroller %d: %s\n", device,
SDL_GetError());
retcode = 1;
keepGoing = SDL_FALSE;
reportederror = SDL_TRUE;
}
} else {
reportederror = SDL_FALSE;
keepGoing = WatchGameController(gamecontroller);
SDL_GameControllerClose(gamecontroller);
}
gamecontroller = NULL;
if (keepGoing) {
SDL_Log("Waiting for attach\n");
}
while (keepGoing) {
SDL_WaitEvent(&event);
if ((event.type == SDL_QUIT) || (event.type == SDL_FINGERDOWN) ||
(event.type == SDL_MOUSEBUTTONDOWN)) {
keepGoing = SDL_FALSE;
} else if (event.type == SDL_CONTROLLERDEVICEADDED) {
gamecontroller = SDL_GameControllerOpen(event.cdevice.which);
/* - this requires SDL 2.0.4
if (gamecontroller != NULL) {
SDL_assert(SDL_GameControllerFromInstanceID(SDL_JoystickInstanceID(SDL_GameControllerGetJoystick(gamecontroller)))
== gamecontroller);
}
*/
break;
}
}
}
}
}
SDL_QuitSubSystem(SDL_INIT_VIDEO | SDL_INIT_JOYSTICK |
SDL_INIT_GAMECONTROLLER);
return retcode;
}
void Joystick::read_key(int mode) {
SDL_Event event;
int i = 0;
Joystick::intro_read_key();
// IN MENU
if (mode == 0){
while (SDL_PollEvent(&event) && main_event->event_running == true) {
if (event.type == SDL_KEYDOWN) {
switch((event).key.keysym.sym) {
case SDLK_ESCAPE: main_event->exit_free(); break;
case SDLK_DOWN: main_event->menu->move_menu_ver(1); break;
case SDLK_UP: main_event->menu->move_menu_ver(-1); break;
case SDLK_RIGHT: main_event->menu->move_menu_hor(); break;
case SDLK_LEFT: main_event->menu->move_menu_hor(); break;
case SDLK_RETURN: if (false == main_event->menu->introstart)
Joystick::intro_pass();
else if (main_event->draw_winner_multi >= 0
|| main_event->draw_winner_campaign >= 0
|| main_event->draw_lose_campaign >= 0
|| main_event->draw_end_campaign >= 0) {
main_event->draw_winner_multi = -1;
// main_event->draw_winner_campaign = -1;
main_event->draw_lose_campaign = -1;
main_event->draw_end_campaign = -1;
main_event->mode_menu = true;
if (main_event->game_playing == true) {
main_event->game_playing = false;
main_event->free_game();
main_event->menu->menu_selected = BIG_MENU;
main_event->menu->detail_menu_selected = MENU_CAMPAIGN;
}
if (main_event->draw_winner_campaign >= 0) {
main_event->draw_winner_campaign = -1;
main_event->make_new_game(0);
main_event->mode_menu = false;
main_event->game_playing = true;
}
}
else
main_event->menu->change_menu();
break;
case SDLK_p: if (true == main_event->mode_menu && main_event->game_playing == true)
main_event->mode_menu = false;
else if (main_event->game_playing == true)
main_event->mode_menu = true;
break;
case SDLK_1: if (main_event->menu->menu_selected == BIG_MENU
&& main_event->game_playing == true
&& main_event->multi == 0 && main_event->arena == 0) {
main_event->draw_winner_multi = -1;
main_event->draw_winner_campaign = -1;
main_event->draw_lose_campaign = -1;
main_event->draw_end_campaign = -1;
main_event->mode_menu = false;
main_event->make_new_game(1);
main_event->game_playing = true;
}
break;
case SDLK_2: if (main_event->menu->menu_selected == BIG_MENU
&& main_event->game_playing == false) {
this->test = 1;
main_event->make_new_game(0);
main_event->mode_menu = false;
main_event->game_playing = true;
this->test = 0;
}
break;
case SDLK_3: if (main_event->menu->menu_selected == BIG_MENU
&& main_event->game_playing == true) {
main_event->cheat_stats();
}
break;
case SDLK_c: std::cout << "SDL_NumJoysticks(void) " << SDL_NumJoysticks() << std::endl;
case SDLK_k: main_event->save_config->fill_info_config();
main_event->save_config->print_config_debugg();
break;
case SDLK_u: main_event->save_config->save_global_config_to_file();
while ( i < SDL_NumJoysticks() ) {
printf(" %s\n", SDL_GameControllerNameForIndex(i) );
i++;
} break;
default: break;
}
}
// JOYSTICK BUTTON
else if (event.type == SDL_JOYBUTTONDOWN) {
switch (event.cbutton.button) {
case 3: if (false == main_event->menu->introstart) {
main_event->menu->introstart = true;
main_event->mode_menu = true;
}
else if (main_event->draw_winner_multi >= 0
|| main_event->draw_winner_campaign >= 0
|| main_event->draw_lose_campaign >= 0
|| main_event->draw_end_campaign >= 0) {
main_event->draw_winner_multi = -1;
// main_event->draw_winner_campaign = -1;
main_event->draw_lose_campaign = -1;
main_event->draw_end_campaign = -1;
main_event->mode_menu = true;
if (main_event->game_playing == true) {
main_event->game_playing = false;
main_event->free_game();
main_event->menu->menu_selected = BIG_MENU;
main_event->menu->detail_menu_selected = MENU_CAMPAIGN;
}
if (main_event->draw_winner_campaign >= 0) {
main_event->draw_winner_campaign = -1;
main_event->make_new_game(0);
main_event->mode_menu = false;
main_event->game_playing = true;
}
}
else
main_event->menu->change_menu();
break;
case 2: main_event->menu->change_menu_back(); break;
case 4: Gamelauncher::retry_previous_game(); break;
case 9: if (true == main_event->mode_menu && main_event->game_playing == true)
main_event->mode_menu = false;
else if (main_event->game_playing == true)
main_event->mode_menu = true;
break;
// case 0: fprintf(stdout, "joystick[%d] button[%d] state[%d]\n", event.jbutton.which, event.jbutton.button, event.jbutton.state); break;
// case 1: fprintf(stdout, "joystick[%d] button[%d] state[%d]\n", event.jbutton.which, event.jbutton.button, event.jbutton.state); break;
// case 5: fprintf(stdout, "joystick[%d] button[%d] state[%d]\n", event.jbutton.which, event.jbutton.button, event.jbutton.state); break;
// case 6: fprintf(stdout, "joystick[%d] button[%d] state[%d]\n", event.jbutton.which, event.jbutton.button, event.jbutton.state); break;
// case 7: fprintf(stdout, "joystick[%d] button[%d] state[%d]\n", event.jbutton.which, event.jbutton.button, event.jbutton.state); break;
// case 8: fprintf(stdout, "joystick[%d] button[%d] state[%d]\n", event.jbutton.which, event.jbutton.button, event.jbutton.state); break;
// case 10: fprintf(stdout, "joystick[%d] button[%d] state[%d]\n", event.jbutton.which, event.jbutton.button, event.jbutton.state); break;
// case 11: fprintf(stdout, "joystick[%d] button[%d] state[%d]\n", event.jbutton.which, event.jbutton.button, event.jbutton.state); break;
// case 12: fprintf(stdout, "joystick[%d] button[%d] state[%d]\n", event.jbutton.which, event.jbutton.button, event.jbutton.state); break;
default: break;
}
}
else if (event.type == SDL_JOYAXISMOTION) {
if( event.jaxis.axis == 0) {
if (event.jaxis.value > 3200)
main_event->menu->move_menu_hor();
else if (event.jaxis.value < -3200)
main_event->menu->move_menu_hor();
}
if( event.jaxis.axis == 1) {
if (event.jaxis.value > 3200)
main_event->menu->move_menu_ver(1);
else if (event.jaxis.value < -3200)
main_event->menu->move_menu_ver(-1);
}
}
// JOYSTICK CROIX DIRECTIONNEL
else if (event.type == SDL_JOYHATMOTION || event.type == 1536) {
if (0 == event.jhat.hat && 0 != event.jhat.value) {
switch (event.jhat.value) {
case SDL_HAT_UP: main_event->menu->move_menu_ver(-1); break;
case SDL_HAT_LEFT: main_event->menu->move_menu_hor(); break;
case SDL_HAT_DOWN: main_event->menu->move_menu_ver(1); break;
case SDL_HAT_RIGHT: main_event->menu->move_menu_hor(); break;
case SDL_HAT_CENTERED: fprintf(stdout, "joystick[%d] CENTERED state[%d]\n", event.jbutton.which, event.jhat.hat); break;
default: break;
}
}
}
}
}
//In GA ME
else {
while (SDL_PollEvent(&event)) {
if (event.type == SDL_KEYDOWN) {
switch((event).key.keysym.sym) {
case SDLK_ESCAPE: main_event->exit_free(); break;
case SDLK_KP_5: this->arr_key_keyboard[1]->key_up = 1; break;
case SDLK_KP_8: this->arr_key_keyboard[1]->key_down = 1; break;
case SDLK_KP_6: this->arr_key_keyboard[1]->key_right = 1; break;
case SDLK_KP_4: this->arr_key_keyboard[1]->key_left = 1; break;
case SDLK_KP_PLUS: main_event->player_bomb(main_event->config_keyboard[1]); break;
case SDLK_KP_MINUS: main_event->remote_put(main_event->config_keyboard[1]); break;
case SDLK_KP_MULTIPLY: main_event->remote_detonate(main_event->config_keyboard[1]); break;
case SDLK_s: this->arr_key_keyboard[0]->key_up = 1; break;
case SDLK_w: this->arr_key_keyboard[0]->key_down = 1; break;
case SDLK_d: this->arr_key_keyboard[0]->key_right = 1; break;
case SDLK_a: this->arr_key_keyboard[0]->key_left = 1; break;
case SDLK_c: main_event->player_bomb(main_event->config_keyboard[0]); break;
case SDLK_v: main_event->remote_put(main_event->config_keyboard[0]); break;
case SDLK_b: main_event->remote_detonate(main_event->config_keyboard[0]); break;
case SDLK_n: Map_event::debugg_change_timer_lunch_warmup_1(); break;
case SDLK_m: Map_event::debugg_change_timer_lunch_warmup_2(); break;
case SDLK_k: main_event->save_config->fill_info_config();
main_event->save_config->print_config_debugg();
break;
case SDLK_RETURN: if (false == main_event->menu->introstart) {
main_event->menu->introstart = true;
main_event->mode_menu = true;
if (main_event->game_playing == true) {
main_event->game_playing = false;
main_event->free_game();
}
} break;
case SDLK_p: if (true == main_event->mode_menu && main_event->game_playing == true)
main_event->mode_menu = false;
else if (main_event->game_playing == true)
main_event->mode_menu = true;
break;
default: break;
}
}
// JOYSTICK BUTTON
else if (event.type == SDL_JOYBUTTONDOWN) {
switch (event.cbutton.button) {
case 3: main_event->player_bomb(main_event->config[event.jbutton.which]); break;
case 2: main_event->remote_put(main_event->config[event.jbutton.which]); break;
case 1: main_event->remote_detonate(main_event->config[event.jbutton.which]); break;
case 9: if ((main_event->multi > 0 || main_event->arena > 0) \
&& main_event->live_player[main_event->config[event.jbutton.which] - PLAYER1] == true) {
if (true == main_event->mode_menu && main_event->game_playing == true)
main_event->mode_menu = false;
else if (main_event->game_playing == true)
main_event->mode_menu = true;
}
else if (main_event->multi == 0 && main_event->arena == 0) {
if (true == main_event->mode_menu && main_event->game_playing == true)
main_event->mode_menu = false;
else if (main_event->game_playing == true)
main_event->mode_menu = true;
} break;
case 8: if (false == main_event->menu->introstart) {
main_event->menu->introstart = true;
main_event->mode_menu = true;
if (main_event->game_playing == true) {
main_event->game_playing = false;
main_event->free_game();
}
} break;
// case 4: fprintf(stdout, "joystick[%d] button[%d] state[%d]\n", event.jbutton.which, event.jbutton.button, event.jbutton.state); break;
// case 5: fprintf(stdout, "joystick[%d] button[%d] state[%d]\n", event.jbutton.which, event.jbutton.button, event.jbutton.state); break;
// case 6: fprintf(stdout, "joystick[%d] button[%d] state[%d]\n", event.jbutton.which, event.jbutton.button, event.jbutton.state); break;
// case 7: fprintf(stdout, "joystick[%d] button[%d] state[%d]\n", event.jbutton.which, event.jbutton.button, event.jbutton.state); break;
// case 0: fprintf(stdout, "joystick[%d] button[%d] state[%d]\n", event.jbutton.which, event.jbutton.button, event.jbutton.state); break;
// case 10: fprintf(stdout, "joystick[%d] button[%d] state[%d]\n", event.jbutton.which, event.jbutton.button, event.jbutton.state); break;
// case 11: fprintf(stdout, "joystick[%d] button[%d] state[%d]\n", event.jbutton.which, event.jbutton.button, event.jbutton.state); break;
// case 12: fprintf(stdout, "joystick[%d] button[%d] state[%d]\n", event.jbutton.which, event.jbutton.button, event.jbutton.state); break;
default: break;
}
}
// JOYSTICK CROIX DIRECTIONNEL
else if (event.type == SDL_JOYHATMOTION) {
switch (event.jhat.value) {
case SDL_HAT_UP: change_dir_joystick(this->arr_key_controller[event.jbutton.which], DIR_UP); break;
case SDL_HAT_LEFT: change_dir_joystick(this->arr_key_controller[event.jbutton.which], DIR_LEFT); break;
case SDL_HAT_DOWN: change_dir_joystick(this->arr_key_controller[event.jbutton.which], DIR_BOTTOM); break;
case SDL_HAT_RIGHT: change_dir_joystick(this->arr_key_controller[event.jbutton.which], DIR_RIGHT); break;
case SDL_HAT_CENTERED: change_dir_joystick(this->arr_key_controller[event.jbutton.which], -1); break;
default: break;
}
}
else if (event.type == SDL_JOYAXISMOTION) {
if( event.jaxis.axis == 0) {
if (event.jaxis.value > 3200)
change_dir_joystick(this->arr_key_controller[event.jaxis.which], DIR_RIGHT);
else if (event.jaxis.value < -3200)
change_dir_joystick(this->arr_key_controller[event.jaxis.which], DIR_LEFT);
else
change_dir_joystick(this->arr_key_controller[event.jaxis.which], -1);
/* Left-right movement code goes here */
}
if( event.jaxis.axis == 1) {
if (event.jaxis.value > 3200)
change_dir_joystick(this->arr_key_controller[event.jaxis.which], DIR_BOTTOM);
else if (event.jaxis.value < -3200)
change_dir_joystick(this->arr_key_controller[event.jaxis.which], DIR_UP);
else
change_dir_joystick(this->arr_key_controller[event.jaxis.which], -1);
/* Up-Down movement code goes here */
}
// std::cout << "hello" << std::endl;
}
if (event.type == SDL_KEYUP) {
switch((event).key.keysym.sym) {
case SDLK_KP_5: this->arr_key_keyboard[1]->key_up = 0; break;
case SDLK_KP_8: this->arr_key_keyboard[1]->key_down = 0; break;
case SDLK_KP_6: this->arr_key_keyboard[1]->key_right = 0; break;
case SDLK_KP_4: this->arr_key_keyboard[1]->key_left = 0; break;
case SDLK_s: this->arr_key_keyboard[0]->key_up = 0; break;
case SDLK_w: this->arr_key_keyboard[0]->key_down = 0; break;
case SDLK_d: this->arr_key_keyboard[0]->key_right = 0; break;
case SDLK_a: this->arr_key_keyboard[0]->key_left = 0; break;
default: break;
}
}
}
}
this->refresh_all_dir_joystick();
if (this->arr_key_keyboard[0]->key_right)
main_event->player_move(main_event->config_keyboard[0], DIR_RIGHT);
if (this->arr_key_keyboard[0]->key_left)
main_event->player_move(main_event->config_keyboard[0], DIR_LEFT);
if (this->arr_key_keyboard[0]->key_up)
main_event->player_move(main_event->config_keyboard[0], DIR_UP);
if (this->arr_key_keyboard[0]->key_down)
main_event->player_move(main_event->config_keyboard[0], DIR_BOTTOM);
if (this->arr_key_keyboard[1]->key_right)
main_event->player_move(main_event->config_keyboard[1], DIR_RIGHT);
if (this->arr_key_keyboard[1]->key_left)
main_event->player_move(main_event->config_keyboard[1], DIR_LEFT);
if (this->arr_key_keyboard[1]->key_up)
main_event->player_move(main_event->config_keyboard[1], DIR_UP);
if (this->arr_key_keyboard[1]->key_down)
main_event->player_move(main_event->config_keyboard[1], DIR_BOTTOM);
if (this->arr_key_controller[0]->key_right)
main_event->player_move(main_event->config[0], DIR_RIGHT);
if (this->arr_key_controller[0]->key_left)
main_event->player_move(main_event->config[0], DIR_LEFT);
if (this->arr_key_controller[0]->key_up)
main_event->player_move(main_event->config[0], DIR_UP);
if (this->arr_key_controller[0]->key_down)
main_event->player_move(main_event->config[0], DIR_BOTTOM);
if (this->arr_key_controller[1]->key_right)
main_event->player_move(main_event->config[1], DIR_RIGHT);
if (this->arr_key_controller[1]->key_left)
main_event->player_move(main_event->config[1], DIR_LEFT);
if (this->arr_key_controller[1]->key_up)
main_event->player_move(main_event->config[1], DIR_UP);
if (this->arr_key_controller[1]->key_down)
main_event->player_move(main_event->config[1], DIR_BOTTOM);
if (this->arr_key_controller[2]->key_right)
main_event->player_move(main_event->config[2], DIR_RIGHT);
if (this->arr_key_controller[2]->key_left)
main_event->player_move(main_event->config[2], DIR_LEFT);
if (this->arr_key_controller[2]->key_up)
main_event->player_move(main_event->config[2], DIR_UP);
if (this->arr_key_controller[2]->key_down)
main_event->player_move(main_event->config[2], DIR_BOTTOM);
if (this->arr_key_controller[3]->key_right)
main_event->player_move(main_event->config[3], DIR_RIGHT);
if (this->arr_key_controller[3]->key_left)
main_event->player_move(main_event->config[3], DIR_LEFT);
if (this->arr_key_controller[3]->key_up)
main_event->player_move(main_event->config[3], DIR_UP);
if (this->arr_key_controller[3]->key_down)
main_event->player_move(main_event->config[3], DIR_BOTTOM);
if (this->arr_key_controller[4]->key_right)
main_event->player_move(main_event->config[4], DIR_RIGHT);
if (this->arr_key_controller[4]->key_left)
main_event->player_move(main_event->config[4], DIR_LEFT);
if (this->arr_key_controller[4]->key_up)
main_event->player_move(main_event->config[4], DIR_UP);
if (this->arr_key_controller[4]->key_down)
main_event->player_move(main_event->config[4], DIR_BOTTOM);
}
