static mrb_value
mrb_sdl2_keyboard_key_from_name(mrb_state *mrb, mrb_value mod)
{
mrb_value name;
mrb_get_args(mrb, "S", &name);
return mrb_fixnum_value(SDL_GetKeyFromName(RSTRING_PTR(name)));
}
Event InputManager::text_to_key_event(const std::string &key_str, const int mod) {
SDL_Keycode key_code = SDL_GetKeyFromName(key_str.c_str());
if (key_code == SDLK_UNKNOWN) {
throw 0;
}
return sdl_key(key_code, static_cast<SDL_Keymod>(mod));
}
extern int
game_is_pressed_name(const char *name)
{
SDL_Keycode key = SDL_GetKeyFromName(name);
int idx = SDL_GetScancodeFromKey(key);
return game_is_pressed(idx);
}
int ConfigManager::mapKey (const std::string& name)
{
const std::string converted = string::replaceAll(name, "_", " ");
const SDL_Keycode keycode = SDL_GetKeyFromName(converted.c_str());
if (keycode == 0)
return -1;
return keycode;
}
static void config_key(const char *s, int i)
{
SDL_Keycode c = SDL_GetKeyFromName(s);
if (c == SDLK_UNKNOWN)
config_set_d(i, option_d[i].def);
else
config_set_d(i, c);
}
//
// Initialize input subsystem
//
void SDL2_InitInput(void)
{
// initialize keyboard key bindings
for(size_t i = 0; i < KBJK_MAX; i++)
{
if(estrempty(kbKeyNames[i]))
kbKeyNames[i] = estrdup(SDL_GetKeyName(kbKeyCodes[i]));
else
kbKeyCodes[i] = SDL_GetKeyFromName(kbKeyNames[i]);
}
}
Gosu::Button Gosu::Input::charToId(wchar_t ch)
{
std::wstring string(1, ch);
SDL_Keycode keycode = SDL_GetKeyFromName(wstringToUTF8(string).c_str());
if (keycode == SDLK_UNKNOWN) {
return noButton;
}
else {
return Button(SDL_GetScancodeFromKey(keycode));
}
}
int ConfigManager::mapModifier (const std::string& name)
{
const std::string converted = string::replaceAll(name, "_", " ");
const SDL_Keycode keycode = SDL_GetKeyFromName(converted.c_str());
if (keycode & KMOD_SHIFT) {
return KMOD_SHIFT;
} else if (keycode & KMOD_ALT) {
return KMOD_ALT;
} else if (keycode & KMOD_CTRL) {
return KMOD_CTRL;
}
return KMOD_NONE;
}
key_type get_key_sym(const std::string& s)
{
if(s == "UP" || s == (("↑"))) {
return SDLK_UP;
} else if(s == "DOWN" || s == (("↓"))) {
return SDLK_DOWN;
} else if(s == "LEFT" || s == (("←"))) {
return SDLK_LEFT;
} else if(s == "RIGHT" || s == (("→"))) {
return SDLK_RIGHT;
}
return SDL_GetKeyFromName(s.c_str());
}
/**
* @brief Gets the key id from its name.
*
* @param name Name of the key to get id from.
* @return ID of the key.
*/
SDLKey input_keyConv( const char *name )
{
#if SDL_VERSION_ATLEAST(2,0,0)
SDLKey k;
k = SDL_GetKeyFromName( name );
if (k == SDLK_UNKNOWN)
WARN("Keyname '%s' doesn't match any key.", name);
return k;
#else /* SDL_VERSION_ATLEAST(2,0,0) */
SDLKey k, m;
size_t l;
char buf;
l = strlen(name);
buf = tolower(name[0]);
/* Compare for single character. */
if (l == 1) {
m = MIN(256, INPUT_NUMKEYS);
for (k=0; k < m; k++) { /* Only valid for char range. */
/* Must not be NULL. */
if (keyconv[k] == NULL)
continue;
/* Check if is also a single char. */
if ((buf == tolower(keyconv[k][0])) && (keyconv[k][1] == '\0'))
return k;
}
}
/* Compare for strings. */
else {
for (k=0; k < INPUT_NUMKEYS; k++) {
/* Must not be NULL. */
if (keyconv[k] == NULL)
continue;
/* Compare strings. */
if (strcmp(name , keyconv[k])==0)
return k;
}
}
WARN("Keyname '%s' doesn't match any key.", name);
return SDLK_UNKNOWN;
#endif /* SDL_VERSION_ATLEAST(2,0,0) */
}
KeyboardFilter KEY(std::initializer_list<std::string> keys) {
std::set<SDL_Keycode> keyset;
for (std::string key : keys) {
SDL_Keycode keycode = SDL_GetKeyFromName(key.c_str());
if (keycode == SDLK_UNKNOWN) {
throw std::runtime_error("unrecognized key: " + key);
}
keyset.insert(keycode);
}
return [keyset] (KeyboardInputEvent event) {
return keyset.find(event.key_code) != keyset.end();
};
}
int LuaEnv_Input::IsKeyPressed(lua_State *state)
{
// First argument is keyboard key
std::string keyboardKeyName = luaL_checkstring(state, 1);
lua_settop(state, 0);
SDL_Keycode keyCode = SDL_GetKeyFromName(keyboardKeyName.c_str());
if(keyCode == SDLK_UNKNOWN)
lua_pushboolean(state, 0);
else
{
const Uint8 *keyboardState = SDL_GetKeyboardState(NULL);
lua_pushboolean(state, keyboardState[SDL_GetScancodeFromKey(keyCode)]);
}
return 1;
}
/**
* @brief Check call to SDL_GetKeyFromName for known, unknown and invalid name.
*
* @sa http://wiki.libsdl.org/moin.cgi/SDL_GetKeyFromName
*/
int
keyboard_getKeyFromName(void *arg)
{
SDL_Keycode result;
/* Case where Key is known, 1 character input */
result = SDL_GetKeyFromName("A");
SDLTest_AssertPass("Call to SDL_GetKeyFromName(known/single)");
SDLTest_AssertCheck(result == SDLK_a, "Verify result from call, expected: %i, got: %i", SDLK_a, result);
/* Case where Key is known, 2 character input */
result = SDL_GetKeyFromName("F1");
SDLTest_AssertPass("Call to SDL_GetKeyFromName(known/double)");
SDLTest_AssertCheck(result == SDLK_F1, "Verify result from call, expected: %i, got: %i", SDLK_F1, result);
/* Case where Key is known, 3 character input */
result = SDL_GetKeyFromName("End");
SDLTest_AssertPass("Call to SDL_GetKeyFromName(known/triple)");
SDLTest_AssertCheck(result == SDLK_END, "Verify result from call, expected: %i, got: %i", SDLK_END, result);
/* Case where Key is known, 4 character input */
result = SDL_GetKeyFromName("Find");
SDLTest_AssertPass("Call to SDL_GetKeyFromName(known/quad)");
SDLTest_AssertCheck(result == SDLK_FIND, "Verify result from call, expected: %i, got: %i", SDLK_FIND, result);
/* Case where Key is known, multiple character input */
result = SDL_GetKeyFromName("AudioStop");
SDLTest_AssertPass("Call to SDL_GetKeyFromName(known/multi)");
SDLTest_AssertCheck(result == SDLK_AUDIOSTOP, "Verify result from call, expected: %i, got: %i", SDLK_AUDIOSTOP, result);
/* Case where Key is unknown */
result = SDL_GetKeyFromName("NotThere");
SDLTest_AssertPass("Call to SDL_GetKeyFromName(unknown)");
SDLTest_AssertCheck(result == SDLK_UNKNOWN, "Verify result from call is UNKNOWN, expected: %i, got: %i", SDLK_UNKNOWN, result);
/* Case where input is NULL/invalid */
result = SDL_GetKeyFromName(NULL);
SDLTest_AssertPass("Call to SDL_GetKeyFromName(NULL)");
SDLTest_AssertCheck(result == SDLK_UNKNOWN, "Verify result from call is UNKNOWN, expected: %i, got: %i", SDLK_UNKNOWN, result);
return TEST_COMPLETED;
}
int load_settings(const char *filename, struct settings *s)
{
char line_buff[256];
FILE *f = fopen(filename, "r");
if(f == NULL) { return 1; }
while(fgets(line_buff, 256, f))
{
char *k = strchr(line_buff, '=');
char *b = strchr(line_buff, '\r');
if (b == NULL) b = strchr(line_buff, '\n'); // this accounts for \r\n line endings (windows style)
if(k == NULL) continue;
*k = 0;
k++;
if(b != NULL) *b = 0;
char *name = line_buff;
int key_index;
if(strncmp(name, "kb", 2) == 0)
{
name += 2;
key_index = find_key(name);
if(key_index == -1) continue;
s->bindings[0][key_index].type = TYPE_KEY;
s->bindings[0][key_index].key = SDL_GetKeyFromName(k);
if(s->bindings[0][key_index].key == SDLK_UNKNOWN)
{
s->bindings[0][key_index].type = TYPE_NONE;
}
}
else if(strncmp(name, "pad", 3) == 0)
{
name += 3;
key_index = find_key(name);
if(key_index == -1) continue;
if(strncmp(k, "button", 6) == 0)
{
k += 6;
s->bindings[1][key_index].type = TYPE_BUTTON;
s->bindings[1][key_index].button = atoi(k);
}
else if(strncmp(k, "hat", 3) == 0)
{
k += 3;
s->bindings[1][key_index].type = TYPE_HAT;
s->bindings[1][key_index].hat = atoi(k);
}
else if(strncmp(k, "axis", 4) == 0)
{
k += 4;
s->bindings[1][key_index].type = TYPE_AXIS;
s->bindings[1][key_index].axis.invert = *k++ == '+' ? 0 : 1;
s->bindings[1][key_index].axis.axis = atoi(k);
}
}
else if(strncmp(name, "ip", 2) == 0)
{
strncpy(s->ip, k, 15);
s->ip_len = strlen(k);
}
else if(strncmp(name, "frame_ms", 8) == 0)
{
s->frame_ms = atoi(k);
}
}
fclose(f);
return 0;
}
bool Input::get_key_press(const char* name) const
{
return _key_press.find(SDL_GetKeyFromName(name)) != _key_press.end();
}
int bind_command_name(enum CommandCode command, const char *symbol) {
/*
* Bind the given symbol to the given command code
*/
return bind_command_key_code(command, SDL_GetKeyFromName(symbol));
}
int MovementManager::Initialize()
{
if (map != NULL) { return 1; }
map = new MoveEventMap;
MoveEvent * ev;
SDL_Keycode key;
ev = new MoveEvent;
key = SDL_GetKeyFromName((*cfg)["Keys"]["Left"].asCString());
ev->timer = SingletonEvents::RegisterTimer(PhysicsDeltaTime, std::bind<void>([this](double dt, double elapsed) {
this->ControlBody->ApplyLinearImpulse(b2Vec2(1.0,0.0), this->ControlBody->GetWorldCenter(), true);
}, _1, _2));
SingletonEvents::ToggleTimer(ev->timer, false);
ev->key_down = SingletonEvents::Register(SDL_KEYDOWN, std::bind<void>([this, key, ev](SDL_Event &e) {
if (key == e.key.keysym.sym && ControlBody != NULL && !ev->is_down) {
SingletonEvents::ToggleTimer(ev->timer, true);
ev->is_down = true;
}
}, _1));
ev->key_up = SingletonEvents::Register(SDL_KEYUP, std::bind<void>([this, key, ev](SDL_Event &e) {
if (key == e.key.keysym.sym && ControlBody != NULL) {
SingletonEvents::ToggleTimer(ev->timer, false);
ev->is_down = false;
}
}, _1));
map->emplace(key, ev);
ev = new MoveEvent;
key = SDL_GetKeyFromName((*cfg)["Keys"]["Right"].asCString());
ev->timer = SingletonEvents::RegisterTimer(PhysicsDeltaTime, std::bind<void>([this](double dt, double elapsed) {
this->ControlBody->ApplyLinearImpulse(b2Vec2(-1.0,0.0), this->ControlBody->GetWorldCenter(), true);
}, _1, _2));
SingletonEvents::ToggleTimer(ev->timer, false);
ev->key_down = SingletonEvents::Register(SDL_KEYDOWN, std::bind<void>([this, key, ev](SDL_Event &e) {
if (key == e.key.keysym.sym && ControlBody != NULL && !ev->is_down) {
SingletonEvents::ToggleTimer(ev->timer, true);
ev->is_down = true;
}
}, _1));
ev->key_up = SingletonEvents::Register(SDL_KEYUP, std::bind<void>([this, key, ev](SDL_Event &e) {
if (key == e.key.keysym.sym && ControlBody != NULL) {
SingletonEvents::ToggleTimer(ev->timer, false);
ev->is_down = false;
}
}, _1));
map->emplace(key, ev);
ev = new MoveEvent;
key = SDL_GetKeyFromName((*cfg)["Keys"]["Jump"].asCString());
ev->key_down = SingletonEvents::Register(SDL_KEYDOWN, std::bind<void>([this, key, ev](SDL_Event &e) {
if (key == e.key.keysym.sym && ControlBody != NULL && !ev->is_down) {
this->ControlBody->ApplyLinearImpulse(b2Vec2(0.0,-22.0), this->ControlBody->GetWorldCenter(), true);
ev->is_down = true;
}
}, _1));
ev->key_up = SingletonEvents::Register(SDL_KEYUP, std::bind<void>([this, key, ev](SDL_Event &e) {
if (key == e.key.keysym.sym && ControlBody != NULL) {
ev->is_down = false;
}
}, _1));
map->emplace(key, ev);
UpdateTimer = SingletonEvents::RegisterTimer(PhysicsDeltaTime, std::bind(&MovementManager::UpdateDynamicPositions, this, _1, _2));
return 0;
}
unsigned int readCode(const char* name) {
return SDL_GetKeyFromName(name);
}
inline int32_t from_string(const std::string& str) noexcept {
return SDL_GetKeyFromName(str.c_str());
}
