mkxp/src/input.cpp

662 lines
13 KiB
C++
Raw Normal View History

2013-09-01 14:27:21 +00:00
/*
** input.cpp
**
** This file is part of mkxp.
**
** Copyright (C) 2013 Jonas Kulla <Nyocurio@gmail.com>
**
** mkxp is free software: you can redistribute it and/or modify
** it under the terms of the GNU General Public License as published by
** the Free Software Foundation, either version 2 of the License, or
** (at your option) any later version.
**
** mkxp is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
** GNU General Public License for more details.
**
** You should have received a copy of the GNU General Public License
** along with mkxp. If not, see <http://www.gnu.org/licenses/>.
*/
#include "input.h"
#include "sharedstate.h"
2013-09-01 14:27:21 +00:00
#include "eventthread.h"
#include "exception.h"
#include "util.h"
#include <SDL_scancode.h>
#include <SDL_mouse.h>
2013-09-01 14:27:21 +00:00
#include <vector>
#include <string.h>
2013-09-01 14:27:21 +00:00
#define BUTTON_CODE_COUNT 24
2013-09-01 14:27:21 +00:00
struct ButtonState
{
bool pressed;
bool triggered;
bool repeated;
ButtonState()
: pressed(false),
triggered(false),
repeated(false)
{}
};
struct KbBindingData
{
SDL_Scancode source;
Input::ButtonCode target;
};
struct JsBindingData
{
2013-09-02 10:31:02 +00:00
int source;
2013-09-01 14:27:21 +00:00
Input::ButtonCode target;
};
struct Binding
{
Binding(Input::ButtonCode target = Input::None)
: target(target)
{}
virtual bool sourceActive() const = 0;
virtual bool sourceRepeatable() const = 0;
Input::ButtonCode target;
};
/* Keyboard binding */
struct KbBinding : public Binding
{
KbBinding() {}
KbBinding(const KbBindingData &data)
: Binding(data.target),
source(data.source)
{}
bool sourceActive() const
{
return EventThread::keyStates[source];
}
bool sourceRepeatable() const
{
return (source >= SDL_SCANCODE_A && source <= SDL_SCANCODE_0) ||
(source >= SDL_SCANCODE_RIGHT && source <= SDL_SCANCODE_UP) ||
(source >= SDL_SCANCODE_F1 && source <= SDL_SCANCODE_F12);
}
SDL_Scancode source;
};
/* Joystick button binding */
struct JsButtonBinding : public Binding
{
JsButtonBinding() {}
JsButtonBinding(const JsBindingData &data)
: Binding(data.target),
source(data.source)
{}
bool sourceActive() const
{
return EventThread::joyState.buttons[source];
}
bool sourceRepeatable() const
{
return true;
}
2013-09-02 10:31:02 +00:00
int source;
2013-09-01 14:27:21 +00:00
};
/* Joystick axis binding */
struct JsAxisBinding : public Binding
{
JsAxisBinding() {}
JsAxisBinding(int *source,
int compareValue,
2014-05-24 16:24:51 +00:00
Input::ButtonCode target)
2013-09-01 14:27:21 +00:00
: Binding(target),
source(source),
compareValue(compareValue)
{}
bool sourceActive() const
{
return (*source == compareValue);
}
bool sourceRepeatable() const
{
return true;
}
int *source;
int compareValue;
};
/* Mouse button binding */
struct MsBinding : public Binding
{
MsBinding() {}
MsBinding(int buttonIndex,
Input::ButtonCode target)
: Binding(target),
index(buttonIndex)
{}
bool sourceActive() const
{
return EventThread::mouseState.buttons[index];
}
bool sourceRepeatable() const
{
return false;
}
int index;
};
/* Not rebindable */
static const KbBindingData staticKbBindings[] =
{
{ SDL_SCANCODE_LEFT, Input::Left },
{ SDL_SCANCODE_RIGHT, Input::Right },
{ SDL_SCANCODE_UP, Input::Up },
{ SDL_SCANCODE_DOWN, Input::Down },
{ SDL_SCANCODE_LSHIFT, Input::Shift },
{ SDL_SCANCODE_RSHIFT, Input::Shift },
{ SDL_SCANCODE_LCTRL, Input::Ctrl },
{ SDL_SCANCODE_RCTRL, Input::Ctrl },
{ SDL_SCANCODE_LALT, Input::Alt },
{ SDL_SCANCODE_RALT, Input::Alt },
{ SDL_SCANCODE_F5, Input::F5 },
{ SDL_SCANCODE_F6, Input::F6 },
{ SDL_SCANCODE_F7, Input::F7 },
{ SDL_SCANCODE_F8, Input::F8 },
{ SDL_SCANCODE_F9, Input::F9 }
};
static elementsN(staticKbBindings);
/* Rebindable */
static const KbBindingData defaultKbBindings[] =
{
{ SDL_SCANCODE_SPACE, Input::C },
{ SDL_SCANCODE_RETURN, Input::C },
{ SDL_SCANCODE_KP_ENTER, Input::C }, /* Treated as alias of RETURN */
{ SDL_SCANCODE_ESCAPE, Input::B },
{ SDL_SCANCODE_KP_0, Input::B },
{ SDL_SCANCODE_LSHIFT, Input::A },
{ SDL_SCANCODE_RSHIFT, Input::A },
{ SDL_SCANCODE_X, Input::B },
{ SDL_SCANCODE_B, Input::None },
{ SDL_SCANCODE_D, Input::Z },
{ SDL_SCANCODE_Q, Input::L },
2014-09-23 20:08:13 +00:00
{ SDL_SCANCODE_W, Input::R },
{ SDL_SCANCODE_V, Input::None },
{ SDL_SCANCODE_A, Input::X },
{ SDL_SCANCODE_S, Input::Y }
};
/* RGSS1 */
static const KbBindingData defaultKbBindings1[] =
{
{ SDL_SCANCODE_Z, Input::A },
{ SDL_SCANCODE_C, Input::C },
};
/* RGSS2 and higher */
static const KbBindingData defaultKbBindings2[] =
{
{ SDL_SCANCODE_Z, Input::C },
{ SDL_SCANCODE_C, Input::None },
2013-09-01 14:27:21 +00:00
};
static elementsN(defaultKbBindings);
static elementsN(defaultKbBindings1);
static elementsN(defaultKbBindings2);
2013-09-01 14:27:21 +00:00
/* Rebindable */
static const JsBindingData defaultJsBindings[] =
{
{ 0, Input::A },
{ 1, Input::B },
{ 2, Input::C },
{ 3, Input::X },
{ 4, Input::Y },
{ 5, Input::Z },
{ 6, Input::L },
{ 7, Input::R },
{ 8, Input::None },
{ 9, Input::None }
};
static elementsN(defaultJsBindings);
2013-09-02 10:31:02 +00:00
/* Maps ButtonCode enum values to indices
* in the button state array */
2013-09-01 14:27:21 +00:00
static const int mapToIndex[] =
{
0, 0,
1, 0, 2, 0, 3, 0, 4, 0,
0,
5, 6, 7, 8, 9, 10, 11, 12,
0, 0,
13, 14, 15,
0,
16, 17, 18, 19, 20,
2013-09-02 04:14:26 +00:00
0, 0, 0, 0, 0, 0, 0, 0,
21, 22, 23
2013-09-01 14:27:21 +00:00
};
static elementsN(mapToIndex);
static const Input::ButtonCode dirs[] =
{ Input::Down, Input::Left, Input::Right, Input::Up };
static const int dirFlags[] =
{
2013-09-02 04:14:26 +00:00
1 << Input::Down,
1 << Input::Left,
1 << Input::Right,
1 << Input::Up
2013-09-01 14:27:21 +00:00
};
/* Dir4 is always zero on these combinations */
static const int deadDirFlags[] =
{
2013-09-02 04:14:26 +00:00
dirFlags[0] | dirFlags[3],
dirFlags[1] | dirFlags[2]
2013-09-01 14:27:21 +00:00
};
static const Input::ButtonCode otherDirs[4][3] =
{
2013-09-02 10:31:02 +00:00
{ Input::Left, Input::Right, Input::Up }, /* Down */
{ Input::Down, Input::Up, Input::Right }, /* Left */
{ Input::Down, Input::Up, Input::Left }, /* Right */
{ Input::Left, Input::Right, Input::Up } /* Up */
2013-09-01 14:27:21 +00:00
};
struct InputPrivate
{
std::vector<KbBinding> kbBindings;
std::vector<JsAxisBinding> jsABindings;
std::vector<JsButtonBinding> jsBBindings;
std::vector<MsBinding> msBindings;
2013-09-01 14:27:21 +00:00
/* Collective binding array */
std::vector<Binding*> bindings;
2013-09-01 14:27:21 +00:00
ButtonState stateArray[BUTTON_CODE_COUNT*2];
2013-10-01 16:27:22 +00:00
2013-09-01 14:27:21 +00:00
ButtonState *states;
ButtonState *statesOld;
Input::ButtonCode repeating;
unsigned int repeatCount;
struct
{
int active;
Input::ButtonCode previous;
} dir4Data;
struct
{
int active;
} dir8Data;
InputPrivate()
{
initKbBindings();
initJsBindings();
initMsBindings();
2013-10-01 16:27:22 +00:00
states = stateArray;
statesOld = stateArray + BUTTON_CODE_COUNT;
2013-09-01 14:27:21 +00:00
2013-09-28 19:30:51 +00:00
/* Clear buffers */
2013-09-01 14:27:21 +00:00
clearBuffer();
swapBuffers();
clearBuffer();
repeating = Input::None;
repeatCount = 0;
dir4Data.active = 0;
dir4Data.previous = Input::None;
dir8Data.active = 0;
}
inline ButtonState &getStateCheck(int code)
{
int index;
if (code < 0 || (size_t) code > mapToIndexN-1)
2013-09-01 14:27:21 +00:00
index = 0;
else
index = mapToIndex[code];
return states[index];
}
inline ButtonState &getState(Input::ButtonCode code)
{
return states[mapToIndex[code]];
}
inline ButtonState &getOldState(Input::ButtonCode code)
{
return statesOld[mapToIndex[code]];
}
void swapBuffers()
{
ButtonState *tmp = states;
states = statesOld;
statesOld = tmp;
}
void clearBuffer()
{
const size_t size = sizeof(ButtonState) * BUTTON_CODE_COUNT;
2013-09-01 14:27:21 +00:00
memset(states, 0, size);
}
void initKbBindings()
{
kbBindings.clear();
for (size_t i = 0; i < staticKbBindingsN; ++i)
kbBindings.push_back(KbBinding(staticKbBindings[i]));
2013-09-01 14:27:21 +00:00
for (size_t i = 0; i < defaultKbBindingsN; ++i)
kbBindings.push_back(KbBinding(defaultKbBindings[i]));
if (rgssVer == 1)
for (size_t i = 0; i < defaultKbBindings1N; ++i)
kbBindings.push_back(KbBinding(defaultKbBindings1[i]));
else
for (size_t i = 0; i < defaultKbBindings2N; ++i)
kbBindings.push_back(KbBinding(defaultKbBindings2[i]));
2013-09-01 14:27:21 +00:00
/* Add to binging array */
for (size_t i = 0; i < kbBindings.size(); ++i)
bindings.push_back(&kbBindings[i]);
2013-09-01 14:27:21 +00:00
}
void initJsBindings()
{
/* Create axis bindings */
jsABindings.resize(4);
size_t i = 0;
2013-09-01 14:27:21 +00:00
jsABindings[i++] = JsAxisBinding(&EventThread::joyState.xAxis, 0x7FFF, Input::Right);
jsABindings[i++] = JsAxisBinding(&EventThread::joyState.xAxis, -0x8000, Input::Left);
jsABindings[i++] = JsAxisBinding(&EventThread::joyState.yAxis, 0x7FFF, Input::Down);
jsABindings[i++] = JsAxisBinding(&EventThread::joyState.yAxis, -0x8000, Input::Up);
/* Create button bindings */
jsBBindings.resize(defaultJsBindingsN);
for (size_t i = 0; i < defaultJsBindingsN; ++i)
2013-09-01 14:27:21 +00:00
jsBBindings[i] = JsButtonBinding(defaultJsBindings[i]);
/* Add to binging array */
for (size_t i = 0; i < jsABindings.size(); ++i)
bindings.push_back(&jsABindings[i]);
2013-09-01 14:27:21 +00:00
for (size_t i = 0; i < jsBBindings.size(); ++i)
bindings.push_back(&jsBBindings[i]);
2013-09-01 14:27:21 +00:00
}
void initMsBindings()
{
msBindings.resize(3);
size_t i = 0;
2013-09-01 14:27:21 +00:00
msBindings[i++] = MsBinding(SDL_BUTTON_LEFT, Input::MouseLeft);
msBindings[i++] = MsBinding(SDL_BUTTON_MIDDLE, Input::MouseMiddle);
msBindings[i++] = MsBinding(SDL_BUTTON_RIGHT, Input::MouseRight);
/* Add to binding array */
for (size_t i = 0; i < msBindings.size(); ++i)
bindings.push_back(&msBindings[i]);
2013-09-01 14:27:21 +00:00
}
void pollBindings(Input::ButtonCode &repeatCand)
{
for (size_t i = 0; i < bindings.size(); ++i)
2013-09-02 10:31:02 +00:00
pollBindingPriv(*bindings[i], repeatCand);
2013-09-01 14:27:21 +00:00
updateDir4();
updateDir8();
}
void pollBindingPriv(const Binding &b,
2013-09-28 19:30:51 +00:00
Input::ButtonCode &repeatCand)
2013-09-01 14:27:21 +00:00
{
if (!b.sourceActive())
return;
if (b.target == Input::None)
return;
ButtonState &state = getState(b.target);
ButtonState &oldState = getOldState(b.target);
state.pressed = true;
/* Must have been released before to trigger */
if (!oldState.pressed)
state.triggered = true;
/* Unbound keys don't create/break repeat */
if (repeatCand != Input::None)
return;
if (repeating != b.target &&
!oldState.pressed)
{
if (b.sourceRepeatable())
repeatCand = b.target;
else
/* Unrepeatable keys still break current repeat */
repeating = Input::None;
}
}
void updateDir4()
{
int dirFlag = 0;
for (size_t i = 0; i < 4; ++i)
2013-09-01 14:27:21 +00:00
dirFlag |= (getState(dirs[i]).pressed ? dirFlags[i] : 0);
if (dirFlag == deadDirFlags[0] || dirFlag == deadDirFlags[1])
{
dir4Data.active = Input::None;
return;
}
if (dir4Data.previous != Input::None)
{
/* Check if prev still pressed */
if (getState(dir4Data.previous).pressed)
{
for (size_t i = 0; i < 3; ++i)
2013-09-01 14:27:21 +00:00
{
Input::ButtonCode other =
otherDirs[(dir4Data.previous/2)-1][i];
if (!getState(other).pressed)
continue;
dir4Data.active = other;
return;
}
}
}
for (size_t i = 0; i < 4; ++i)
2013-09-01 14:27:21 +00:00
{
if (!getState(dirs[i]).pressed)
continue;
dir4Data.active = dirs[i];
dir4Data.previous = dirs[i];
return;
}
dir4Data.active = Input::None;
dir4Data.previous = Input::None;
}
void updateDir8()
{
static const int combos[4][4] =
{
{ 2, 1, 3, 0 },
{ 1, 4, 0, 7 },
{ 3, 0, 6, 9 },
{ 0, 7, 9, 8 }
};
dir8Data.active = 0;
for (size_t i = 0; i < 4; ++i)
2013-09-01 14:27:21 +00:00
{
Input::ButtonCode one = dirs[i];
if (!getState(one).pressed)
continue;
for (int j = 0; j < 3; ++j)
{
Input::ButtonCode other = otherDirs[i][j];
if (!getState(other).pressed)
continue;
dir8Data.active = combos[(one/2)-1][(other/2)-1];
return;
}
dir8Data.active = one;
return;
}
}
};
Input::Input()
{
p = new InputPrivate;
}
void Input::update()
{
shState->checkShutdown();
2013-09-01 14:27:21 +00:00
p->swapBuffers();
p->clearBuffer();
ButtonCode repeatCand = None;
/* Poll all bindings */
p->pollBindings(repeatCand);
/* Check for new repeating key */
if (repeatCand != None && repeatCand != p->repeating)
{
p->repeating = repeatCand;
p->repeatCount = 0;
p->getState(repeatCand).repeated = true;
return;
}
/* Check if repeating key is still pressed */
if (p->getState(p->repeating).pressed)
{
p->repeatCount++;
2014-09-02 17:11:56 +00:00
bool repeated;
if (rgssVer >= 2)
repeated = p->repeatCount >= 23 && ((p->repeatCount+1) % 6) == 0;
2014-09-02 17:11:56 +00:00
else
repeated = p->repeatCount >= 15 && ((p->repeatCount+1) % 4) == 0;
2014-09-02 17:11:56 +00:00
p->getState(p->repeating).repeated |= repeated;
2013-09-01 14:27:21 +00:00
return;
}
p->repeating = None;
}
bool Input::isPressed(int button)
{
return p->getStateCheck(button).pressed;
}
bool Input::isTriggered(int button)
{
return p->getStateCheck(button).triggered;
}
bool Input::isRepeated(int button)
{
return p->getStateCheck(button).repeated;
}
int Input::dir4Value()
{
return p->dir4Data.active;
}
int Input::dir8Value()
{
return p->dir8Data.active;
}
int Input::mouseX()
{
RGSSThreadData &rtData = shState->rtData();
if (!EventThread::mouseState.inWindow)
return -20;
2013-09-23 08:39:16 +00:00
return (EventThread::mouseState.x - rtData.screenOffset.x) * rtData.sizeResoRatio.x;
2013-09-01 14:27:21 +00:00
}
int Input::mouseY()
{
RGSSThreadData &rtData = shState->rtData();
if (!EventThread::mouseState.inWindow)
return -20;
2013-09-23 08:39:16 +00:00
return (EventThread::mouseState.y - rtData.screenOffset.y) * rtData.sizeResoRatio.y;
2013-09-01 14:27:21 +00:00
}
Input::~Input()
{
delete p;
}