TEST( Input, KeyInput )
{
Input newInput = {};
Input oldInput = {};
newInput.keys[KEY_SPACE] = true;
EXPECT_TRUE( KeyDown( &newInput, KEY_SPACE ) );
EXPECT_FALSE( KeyDown( &oldInput, KEY_SPACE ) );
EXPECT_TRUE( KeyPressed( &newInput, &oldInput, KEY_SPACE ) );
EXPECT_FALSE( KeyReleased( &newInput, &oldInput, KEY_SPACE ) );
oldInput.keys[KEY_SPACE] = true;
EXPECT_TRUE( KeyDown( &newInput, KEY_SPACE ) );
EXPECT_TRUE( KeyDown( &oldInput, KEY_SPACE ) );
EXPECT_FALSE( KeyPressed( &newInput, &oldInput, KEY_SPACE ) );
EXPECT_FALSE( KeyReleased( &newInput, &oldInput, KEY_SPACE ) );
newInput.keys[KEY_SPACE] = false;
EXPECT_FALSE( KeyDown( &newInput, KEY_SPACE ) );
EXPECT_TRUE( KeyDown( &oldInput, KEY_SPACE ) );
EXPECT_FALSE( KeyPressed( &newInput, &oldInput, KEY_SPACE ) );
EXPECT_TRUE( KeyReleased( &newInput, &oldInput, KEY_SPACE ) );
newInput.keys[KEY_ENTER] = true;
EXPECT_TRUE( KeyDown( &newInput, KEY_ENTER ) );
EXPECT_FALSE( KeyDown( &oldInput, KEY_ENTER ) );
EXPECT_TRUE( KeyPressed( &newInput, &oldInput, KEY_ENTER ) );
EXPECT_FALSE( KeyReleased( &newInput, &oldInput, KEY_ENTER ) );
}
void Application::UpdateCamera(float dt)
{
// don't make movement too sickening in VR
static const float movementSpeed = VREnabled() ? 1.f : 8.f;
if (KeyPressed(KEY_A))
g_cameraDirector.GetActiveCamera()->Strafe(-movementSpeed * dt);
if (KeyPressed(KEY_D))
g_cameraDirector.GetActiveCamera()->Strafe(movementSpeed * dt);
if (KeyPressed(KEY_W))
g_cameraDirector.GetActiveCamera()->MoveForward(-movementSpeed * dt);
if (KeyPressed(KEY_S))
g_cameraDirector.GetActiveCamera()->MoveForward(movementSpeed * dt);
// do the barrel roll!
if (KeyPressed(KEY_Q))
g_cameraDirector.GetActiveCamera()->rotateZ(2.f * dt);
if (KeyPressed(KEY_E))
g_cameraDirector.GetActiveCamera()->rotateZ(-2.f * dt);
// move straight up/down
if (KeyPressed(KEY_R))
g_cameraDirector.GetActiveCamera()->MoveUpward(movementSpeed * dt);
if (KeyPressed(KEY_F))
g_cameraDirector.GetActiveCamera()->MoveUpward(-movementSpeed * dt);
}
STATIC int _QuerySaveState(void)
{
_UpdateInterfaceState();
while (KeyPressed())
{
if (ReadKey() == STOPKEY)
{
UnLockMouse();
DrawFunctionKey(1, "help");
if (QueryUserStop())
{
StopDefragmentationProcess(); /* Just sets a variable in
main\actions.c */
LockMouse(1, 1, 80, 25);
DrawFunctionKey(3, "stop");
return TRUE;
}
else
{
LockMouse(1, 1, 80, 25);
DrawFunctionKey(3, "stop");
return FALSE;
}
}
}
return FALSE;
}
void CUICustomEdit::Update()
{
if(m_bInputFocus)
{
static u32 last_time;
u32 cur_time = Device.TimerAsync();
if(m_iKeyPressAndHold)
{
if(m_bHoldWaitMode)
{
if(cur_time - last_time>HOLD_WAIT_TIME)
{
m_bHoldWaitMode = false;
last_time = cur_time;
}
}
else
{
if(cur_time - last_time>HOLD_REPEAT_TIME)
{
last_time = cur_time;
KeyPressed(m_iKeyPressAndHold);
}
}
}
else
last_time = cur_time;
}
m_lines.SetTextColor(m_textColor[IsEnabled()?0:1]);
CUIWindow::Update();
}
static void
xf86ReleaseKeys(DeviceIntPtr pDev)
{
KeyClassPtr keyc;
int i, j, nevents, sigstate;
if (!pDev || !pDev->key)
return;
keyc = pDev->key;
/*
* Hmm... here is the biggest hack of every time !
* It may be possible that a switch-vt procedure has finished BEFORE
* you released all keys neccessary to do this. That peculiar behavior
* can fool the X-server pretty much, cause it assumes that some keys
* were not released. TWM may stuck alsmost completly....
* OK, what we are doing here is after returning from the vt-switch
* exeplicitely unrelease all keyboard keys before the input-devices
* are reenabled.
*/
for (i = keyc->xkbInfo->desc->min_key_code;
i < keyc->xkbInfo->desc->max_key_code;
i++) {
if (KeyPressed(i)) {
sigstate = xf86BlockSIGIO ();
nevents = GetKeyboardEvents(xf86Events, pDev, KeyRelease, i);
for (j = 0; j < nevents; j++)
mieqEnqueue(pDev, (InternalEvent*)(xf86Events + j)->event);
xf86UnblockSIGIO(sigstate);
}
}
}
LRESULT FileViewNotifyHandler( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam, short win )
{
LV_DISPINFO *pLvdi = (LV_DISPINFO *)lParam;
NM_LISTVIEW *pNm = (NM_LISTVIEW *)lParam;
int itemSel = pNm->iItem;
if (LOWORD(wParam) != IDC_FILEVIEW)
return 0L;
switch(pLvdi->hdr.code) {
case LVN_GETDISPINFO:
itemSel = pLvdi->item.iItem;
break;
case NM_RCLICK:
{
POINT pnt;
GetCursorPos( &pnt );
if (hMenu[win]) {
TrackPopupMenu (GetSubMenu (hMenu[win], 0), 0, pnt.x, pnt.y, 0, hWnd, NULL);
}
}
break;
case -155: // Dunno why this is -155, but it catches keys pressed, trying to catch messages like WM_KEYDOWN
//OutDebugs( "Key: %d", pLvdi->item.cchTextMax );
return KeyPressed( hWnd, pLvdi->item.cchTextMax, win );
default:
break;
}
return 0L;
}
//-------------------------------------------------------------------
void AppWindow :: MessageLoop()
//-------------------------------------------------------------------
{
for ( ; ; ) {
XEvent event;
XNextEvent (dpy, &event);
switch (event.type) {
case ConfigureNotify:
canvas = RectAngle( 0, 0, event.xconfigure.width, event.xconfigure.height );
break;
case Expose:
{
XClearWindow(dpy, win);
ExposeEvent evt( &event.xexpose );
ExposeAll( &evt );
}
break;
case KeyPress:
{
KeyEvent evt( &event.xkey );
KeyPressed( &evt );
}
break;
}
}
}
bool KeyboardFilter::eventFilter (QObject *dist, QEvent *event) {
if (event -> type () == QEvent::KeyPress) {
QKeyEvent *keyEvent = static_cast<QKeyEvent *>(event);
emit KeyPressed (keyEvent -> key ());
return true;
}
return false;
}
PyObject* LMF_KeyPressed (PyObject *self, PyObject *args){
int iKeyCode;
if (!PyArg_ParseTuple(args, "i", &iKeyCode)) {
ParsePyTupleError( __func__, __LINE__ );
return nullptr;
}
int iKeyUp = KeyPressed(iKeyCode);
return Py_BuildValue("i", iKeyUp);
}
/// Called by GLFW when a key event occurs
void EmuWindow_GLFW::OnKeyEvent(GLFWwindow* win, int key, int scancode, int action, int mods) {
auto emu_window = GetEmuWindow(win);
int keyboard_id = emu_window->keyboard_id;
if (action == GLFW_PRESS) {
emu_window->KeyPressed({key, keyboard_id});
} else if (action == GLFW_RELEASE) {
emu_window->KeyReleased({key, keyboard_id});
}
}
int AltKeyPressed (void)
{
if (!AltKeyDown()) return 0;
while (AltKeyDown())
if (KeyPressed())
return 0;
return 1;
}
bool List::HandleEventSelf(const SDL_Event& ev)
{
switch (ev.type) {
case SDL_MOUSEBUTTONDOWN: {
if (gui->MouseOverElement(GetRoot(), ev.motion.x, ev.motion.y))
{
if(!hasFocus) {
hasFocus = true;
MouseMove(ev.motion.x, ev.motion.y, ev.motion.xrel, ev.motion.yrel, ev.motion.state);
}
}
else {
hasFocus = false;
}
if(MouseOver(ev.button.x, ev.button.y)) {
if(hasFocus) {
MousePress(ev.button.x, ev.button.y, ev.button.button);
return true;
}
}
break;
}
case SDL_MOUSEBUTTONUP: {
if (!hasFocus)
break;
if (MouseOver(ev.button.x, ev.button.y) || activeScrollbar)
{
MouseRelease(ev.button.x, ev.button.y, ev.button.button);
return true;
}
break;
}
case SDL_MOUSEMOTION: {
if (!hasFocus)
break;
if (MouseOver(ev.button.x, ev.button.y) || activeScrollbar)
{
MouseMove(ev.motion.x, ev.motion.y, ev.motion.xrel, ev.motion.yrel, ev.motion.state);
return true;
}
break;
}
case SDL_KEYDOWN: {
if (!hasFocus)
break;
if(ev.key.keysym.sym == SDLK_ESCAPE)
{
hasFocus = false;
break;
}
return KeyPressed(ev.key.keysym.sym, false);
}
}
return false;
}
// Function name : CMain::Update
// Description : this function will be called every xx milliseconds
// update your variables through milliseconds
// Return type : void
// Argument : DWORD milliseconds
void CMain::Update(DWORD milliseconds)
{
if (KeyPressed(VK_ESCAPE) == TRUE) // Is ESC Being Pressed?
{
theApp.TerminateApplication (); // Terminate The Program
}
if (KeyPressed(VK_F1) == TRUE) // Is F1 Being Pressed?
{
theApp.ToggleFullScreen (); // Toggle Fullscreen Mode
}
if (KeyPressed(VK_SPACE ) == TRUE) // Is F1 Being Pressed?
{
theApp.ToggleFullScreen (); // Toggle Fullscreen Mode
}
angle += (float)(milliseconds) / 5.0f; // Update angle Based On The Clock
}
D3DXVECTOR3 FirstPersonPlayer::Input(float deltaTime)
{
D3DXVECTOR3 moveDir = D3DXVECTOR3(0,0,0);
int speed = 20;
if(KeyPressed(DIK_LSHIFT))
{
speed = 40;
}
else
{
speed = 20;
}
if(KeyPressed(DIK_R) == 2)
{
checkCollision = true;
isGrounded= false;
}
return moveDir;
}
void Player::onKey()
{
keyActions();
emit KeyPressed();
if (alive == true && (mf == true || mb == true || rl == true || rr == true || hl == true || hr == true || fr == true ||
fireReady == false || tankhrotate->state() == QMediaPlayer::PlayingState || out == true))
{
timer->start(keyDelay);
}
}
void Game::Update() {
// Update the game Manager
Manager.Update();
if (KeyPressed('`')){
bDebugOpen = !bDebugOpen;
}
if (bDebugOpen){
GlobalContainer.Update();
}
}
bool InputLayer::AnyPressed() const
{
for (int32_t i = 0; i < InputLayer::KEYCOUNT; ++i)
{
if (KeyPressed(i))
{
return true;
}
}
return false;
}
// Function name : CMain::Update
// Description : this function will be called every xx milliseconds
// update your variables through milliseconds
// Return type : void
// Argument : DWORD milliseconds
void CMain::Update(DWORD milliseconds)
{
if (KeyPressed(VK_ESCAPE) == TRUE) // Is ESC Being Pressed?
{
theApp.TerminateApplication (); // Terminate The Program
}
if (KeyPressed(VK_F1) == TRUE) // Is F1 Being Pressed?
{
theApp.ToggleFullScreen (); // Toggle Fullscreen Mode
}
if( KeyPressed( VK_UP ) == TRUE ) {
yAngle += 1.0;
}
if( KeyPressed( VK_DOWN ) == TRUE ){
yAngle -= 1.0;
}
if( KeyPressed( VK_LEFT ) == TRUE ) {
xAngle += 1.0;
}
if( KeyPressed( VK_RIGHT ) == TRUE ) {
xAngle -= 1.0;
}
//angle += (float)(milliseconds) / 5.0f; // Update angle Based On The Clock
}
void SugoiGame::PollEvents() {
sr::Event event;
while (m_window->PollEvent(event)) {
switch (event.type) {
case sr::Event::WINDOW_CLOSED:
m_window->Close();
break;
case sr::Event::KEY_PRESSED:
KeyPressed(event.key.keyCode, event.key.alt, event.key.control, event.key.shift, event.key.system);
break;
case sr::Event::KEY_RELEASED:
KeyReleased(event.key.keyCode, event.key.alt, event.key.control, event.key.shift, event.key.system);
break;
case sr::Event::MOUSE_PRESSED:
if (event.mouseClicked.mouseCode == GLFW_MOUSE_BUTTON_1) {
MouseLeftPressed();
}
else if (event.mouseClicked.mouseCode == GLFW_MOUSE_BUTTON_2) {
MouseRightPressed();
}
else if (event.mouseClicked.mouseCode == GLFW_MOUSE_BUTTON_3) {
MouseMiddlePressed();
}
break;
case sr::Event::MOUSE_RELEASED:
if (event.mouseClicked.mouseCode == GLFW_MOUSE_BUTTON_1) {
MouseLeftReleased(event.mouseClicked.x, event.mouseClicked.y);
}
else if (event.mouseClicked.mouseCode == GLFW_MOUSE_BUTTON_2) {
MouseRightReleased();
}
else if (event.mouseClicked.mouseCode == GLFW_MOUSE_BUTTON_3) {
MouseMiddleReleased();
}
break;
case sr::Event::MOUSE_MOVED:
MouseMoved(event.mouseMoved.x, event.mouseMoved.y);
break;
case sr::Event::MOUSE_SCROLLED:
MouseScroll(event.mouseScrolled.xoffset, event.mouseScrolled.yoffset);
break;
}
}
}
void InputContext::TriggerKeyEvent(KeyEvent &key)
{
KeyEventSignalMap::iterator keySignal = registeredKeyEventSignals.find(key.keyCode);
switch(key.eventType)
{
case KeyEvent::KeyPressed:
// 1. First emit the generic KeyEventReceived signal that receives all event types for all key codes.
emit KeyEventReceived(&key);
// 2. Emit the event type -specific signal for all key codes.
emit KeyPressed(&key);
// 3. Emit the key code -specific signal for specific event.
if (keySignal != registeredKeyEventSignals.end())
keySignal->second->OnKeyPressed(key);
break;
case KeyEvent::KeyDown:
if (!IsKeyDownImmediate(key.keyCode))
break; // If we've received a keydown for a key we haven't gotten a corresponding press for before, ignore this event.
emit KeyEventReceived(&key); // 1.
emit KeyDown(&key); // 2.
// if (keySignal != registeredKeyEventSignals.end())
// keySignal->second->OnKeyDown(key); // 3.
break;
case KeyEvent::KeyReleased:
if (!IsKeyDownImmediate(key.keyCode))
break; // If we've received a keydown for a key we haven't gotten a corresponding press for before, ignore this event.
emit KeyEventReceived(&key); // 1.
emit KeyReleased(&key); // 2.
if (keySignal != registeredKeyEventSignals.end())
keySignal->second->OnKeyReleased(key); // 3.
break;
default:
assert(false);
break;
}
// Update the buffered API.
KeyPressInformation info;
info.keyState = key.eventType;
info.keyPressCount = key.keyPressCount;
// info.firstPressTime = key.firstPressTime;
newKeyEvents[key.keyCode] = info;
// Now if this layer is registered to suppress this keypress from being processed further,
// mark it handled.
if (suppressedKeys.find(key.keyCode) != suppressedKeys.end())
key.handled = true;
}
void
ChronTextEdit::keyPressEvent ( QKeyEvent * event)
{
int key (0);
QTextEdit::keyPressEvent (event);
if (listening && event) {
key = event->key();
if (firstKey) {
emit KeyPressed (key);
firstKey = false;
}
if (key == Qt::Key_Return || key == Qt::Key_Enter) {
emit ReturnPressed ();
}
}
}
BOOL CConfigShortcuts::PreTranslateMessage(MSG* pMsg)
{
if (GetFocus() == GetDlgItem(IDC_KEY)) {
switch (pMsg->message) {
case WM_KEYDOWN:
case WM_SYSKEYDOWN:
KeyPressed(pMsg->wParam);
return TRUE;
case WM_KEYUP:
case WM_SYSKEYUP:
KeyReleased(pMsg->wParam);
return TRUE;
}
}
return CPropertyPage::PreTranslateMessage(pMsg);
}
int main(void)
{
Init();
usart_init_intr(9600);
// Timer 0 konfigurieren
TCCR0 = (1<<CS01); //Prescaler 8 | (1<<CS00); // Prescaler 64
// Overflow Interrupt erlauben
TIMSK |= (1<<TOIE0);
// Global Interrupts aktivieren
sei();
while(1)
{
//-----------------------------------------------------------------Einlesen
readData();
//-----------------------------------------------------------------WASD Steuerung
checkData();
//-----------------------------------------------------------------Regelung
usart_putc('E');
usart_puti(curr_error, 3);
usart_puts("\r\n");
//-----------------------------------------------------------------Minimal/Maximalwerte
setMotor(DirLeft, DirRight, IstSpeedLeft, IstSpeedRight);
if (KeyPressed() != 0){
usart_puts("Taster");
}
}
//------------------------------------------------------------------------------------------------Ende while
}
void BaseApp::Run()
{
CStopwatch timer;
int sum = 0;
int counter = 0;
int deltaTime = 0;
while (1)
{
timer.Start();
if (kbhit())
{
KeyPressed (getch());
if (!FlushConsoleInputBuffer(mConsoleIn))
cout<<"FlushConsoleInputBuffer failed with error "<<GetLastError();
}
UpdateF((float)deltaTime / 1000.0f);
Render();
Sleep(1);
while (1)
{
deltaTime = timer.Now();
if (deltaTime > 20)
break;
}
sum += deltaTime;
counter++;
if (sum >= 1000)
{
TCHAR szbuff[255];
StringCchPrintf(szbuff, 255, TEXT("FPS: %d"), counter);
SetConsoleTitle(szbuff);
counter = 0;
sum = 0;
}
}
}
void XWindow::HandleInput()
{
XEvent event;
KeySym key;
char text[255];
if (XCheckMaskEvent(m_pDisplay, ExposureMask | ButtonPressMask | KeyPressMask, &event)) {
if (event.type == Expose && event.xexpose.count == 0) {
Clear();
}
if (event.type == KeyPress && XLookupString(&event.xkey, text, sizeof(text), &key, 0) == 1) {
std::cout << "KeyPressed: " << text[0] << std::endl;
KeyPressed(text[0]);
}
if (event.type == ButtonPress) {
int x = event.xbutton.x;
int y = event.xbutton.y;
std::cout << "ButtonPressed: " << x << " " << y << std::endl;
ButtonPressed(x, y);
}
}
}
bool CUICustomEdit::OnKeyboard(int dik, EUIMessages keyboard_action)
{
if(!m_bInputFocus)
return false;
if(keyboard_action == WINDOW_KEY_PRESSED)
{
m_iKeyPressAndHold = dik;
m_bHoldWaitMode = true;
if(KeyPressed(dik)) return true;
}
else if(keyboard_action == WINDOW_KEY_RELEASED)
{
if(m_iKeyPressAndHold == dik)
{
m_iKeyPressAndHold = 0;
m_bHoldWaitMode = false;
}
if(KeyReleased(dik)) return true;
}
return false;
}
//================================================================================
void ATHInputManager::SendKeyboardEvent()
{
ATHKeyList m_liKeysDown = CheckKeys();
ATHKeyList::iterator itrCurr = m_liKeysDown.begin();
ATHKeyList::iterator itrEnd = m_liKeysDown.end();
ATHEvent keyEvent( AET_KEYBOARD );
unsigned int unKeyDownIndex = 0;
unsigned int unKeyUpIndex = 0;
while( itrCurr != itrEnd )
{
unsigned int szDIKKey = (*itrCurr);
if (KeyPressed( szDIKKey ) && unKeyDownIndex < 8)
{
BYTE chAsciiKeys[ATH_NUM_KEYS] = {};
if (GetKeyboardState(chAsciiKeys))
{
unsigned short szAsciiKey = 0;
// Why do I have to do both opposite conversions????
int nCharCount = ToAsciiEx(MapVirtualKeyEx(szDIKKey, MAPVK_VSC_TO_VK, NULL), MapVirtualKeyEx(szDIKKey, MAPVK_VK_TO_VSC, NULL), chAsciiKeys, &szAsciiKey, 0, NULL);
if (nCharCount > 0)
{
keyEvent.KEY_szKeysPressed[unKeyDownIndex] = (char)szAsciiKey;
unKeyDownIndex++;
}
}
}
itrCurr++;
}
if( unKeyDownIndex > 0|| unKeyUpIndex > 0 )
{
keyEvent.m_EventID = AEI_KEYDOWN;
m_pEventManager->SendEvent( keyEvent, AEP_IMMEDIATE );
}
}
static int OnKeyPressed(void *wnd, int key)
{
GEM_WINDOW *gwnd = (GEM_WINDOW *) wnd ;
HEX_DUMP *hex_dump = (HEX_DUMP *) gwnd->Extension ;
long old_xcursor, old_ycursor, old_ystart, offset ;
int htline, code = GW_EVTCONTINUEROUTING ;
unsigned char new_val, input_valid = 0, plus = 0 ;
old_xcursor = hex_dump->xcursor ;
old_ycursor = hex_dump->ycursor ;
old_ystart = hex_dump->ystart ;
ShowCursor( gwnd, 0 ) ;
switch( key )
{
case FERMER : gwnd->OnClose( gwnd ) ;
code = GW_EVTSTOPROUTING ;
break ;
case SAUVE : SaveFile( gwnd, 0 ) ;
code = GW_EVTSTOPROUTING ;
break ;
case SAUVES : SaveFile( gwnd, 1 ) ;
code = GW_EVTSTOPROUTING ;
break ;
case CURSOR_RT : hex_dump->xcursor++ ;
if ( hex_dump->xcursor >= hex_dump->sizeof_raw_offset_array ) hex_dump->xcursor = hex_dump->sizeof_raw_offset_array - 1 ;
plus = 1 ;
code = GW_EVTSTOPROUTING ;
break ;
case CURSOR_SLT : hex_dump->xcursor = SearchNextBlock( hex_dump, hex_dump->xcursor, -1L ) ;
code = GW_EVTSTOPROUTING ;
break ;
case CURSOR_LT : hex_dump->xcursor-- ;
if ( hex_dump->xcursor < 0 ) hex_dump->xcursor = 0 ;
code = GW_EVTSTOPROUTING ;
break ;
case CURSOR_SRT : hex_dump->xcursor = SearchNextBlock( hex_dump, hex_dump->xcursor, 1L ) ;
code = GW_EVTSTOPROUTING ;
break ;
case CURSOR_UP : hex_dump->ycursor-- ;
if ( hex_dump->ycursor < 0 ) hex_dump->ycursor = 0 ;
code = GW_EVTSTOPROUTING ;
break ;
case CURSOR_SUP : hex_dump->ystart -= hex_dump->nb_lines_on_window ;
hex_dump->ycursor -= hex_dump->nb_lines_on_window ;
code = GW_EVTSTOPROUTING ;
break ;
case CURSOR_DN : hex_dump->ycursor++ ;
if ( hex_dump->ycursor > hex_dump->total_nb_lines ) hex_dump->ycursor = hex_dump->total_nb_lines ;
code = GW_EVTSTOPROUTING ;
break ;
case CURSOR_SDN : hex_dump->ystart += hex_dump->nb_lines_on_window ;
hex_dump->ycursor += hex_dump->nb_lines_on_window ;
code = GW_EVTSTOPROUTING ;
break ;
default : offset = GetOffset( hex_dump, GetRawOffsetForXCursor( hex_dump, hex_dump->xcursor ), hex_dump->ycursor ) ;
key &= 0xFF ;
input_valid = KeyPressed( hex_dump, offset, key, &new_val ) ;
if ( input_valid )
{
int xy[4] ;
hex_dump->raw_data[offset] = new_val ;
FormatLine( hex_dump, hex_dump->ycursor ) ;
hex_dump->xcursor++ ;
if ( hex_dump->xcursor >= hex_dump->sizeof_raw_offset_array ) hex_dump->xcursor = hex_dump->sizeof_raw_offset_array - 1 ;
htline = hex_dump->h_char + hex_dump->interline ;
GWGetWorkXYWH( gwnd, &xy[0], &xy[1], &xy[2], &xy[3] ) ;
xy[1] += (int)( hex_dump->ycursor - hex_dump->ystart ) * htline ;
xy[3] = htline ;
v_hide_c( handle ) ;
OnDraw( gwnd, xy ) ;
v_show_c( handle, 1 ) ;
plus = 1 ;
SetModif( gwnd, 1 ) ;
code = GW_EVTSTOPROUTING ;
}
break ;
}
CheckYCursorValid( hex_dump ) ;
CheckXCursorValid( hex_dump, plus ) ;
CheckValid( hex_dump ) ;
if ( ( old_xcursor != hex_dump->xcursor ) || ( old_ycursor != hex_dump->ycursor ) ) SmartInfos( gwnd ) ;
if ( old_ystart != hex_dump->ystart ) SmartRePaint( gwnd, old_ystart ) ;
return( code ) ;
}
void CEffectsGame::DoPicking()
{
bool hit = false;
Vector3 tileHitPos;
SMapTile *tileHit;
Vector3 start = pCamera->GetWorldPosition();
Vector3 end = start + pCamera->forward * 1000.0f;
Vector3 pos;
pLevel->UnHighlightTile();
// find tile we are pointing at
if (hit = pLevel->CastRay(start, end, OUT tileHitPos, OUT &tileHit, OUT &pos))
{
pLevel->HighlightTile(tileHitPos.x, tileHitPos.y, tileHitPos.z);
}
static float force = 10;
if (gInput.WasKeyPressed(K_PGUP)) force += 5.0f;
if (gInput.WasKeyPressed(K_PGDN)) force -= 5.0f;
//gVGUI.AddTextMessage(300,200,WHITE,"Force: %f",force);
//car->pBarrel->DrawAxis();
// shooting - delete tile
if (gInput.IsKeydown(K_MOUSE1))
{
static float delay = 0;
delay += frametime;
if (delay > 0.05f)
{
// shoot a bullet
CreateBullet(car->pBarrel->GetWorldPosition(), car->pBarrel->up);
float puffSpeed = 0.35;
// add puff effect
for (int i = 0; i<3; i++)
{
static CTexture *puffTex = new CTexture("particles/explosion4.dds");
CParticle *p = new CParticle(puffTex);
p->size = Vector2(0.15, 0.15);
p->position = car->pBarrel->GetWorldPosition() + car->pBarrel->up/2;
p->velocity = Vector3( frand(-puffSpeed,puffSpeed), frand(-puffSpeed,puffSpeed)+1, frand(-puffSpeed,puffSpeed) );
//p->gravity = -10;
p->lifetime = 0.25;
p->color = SRGBA(255,255,255,50);
p->sizeVel = Vector2(1,1);
p->colorChange = SRGBA(255,255,255,0);
particles->Add(p);
}
// add muzzle flash
static CTexture *muzzleTex[] = {
new CTexture("particles/flame1.dds"),
new CTexture("particles/explosion1.dds")
};
{
CParticle *p = new CParticle(muzzleTex[rand()%2]);
p->size = Vector2(0.7, 0.7);
p->position = car->pBarrel->GetWorldPosition() + car->pBarrel->up/2;
p->lifetime = 0.01;
p->additive = true;
//p->color = SRGBA(255,255,255,50);
//p->sizeVel = Vector2(1,1);
//p->colorChange = SRGBA(255,255,255,0);
particles->Add(p);
}
delay = 0;
// if hit a tile, destroy it
/* if (hit)
{
EnterCriticalSection(&renderCS);
tileHit->type = 0;
LeaveCriticalSection(&renderCS);
SMapChunk *chunk = pLevel->GetChunk(
floor(tileHitPos.x/SMapChunk::Size),
floor(tileHitPos.y/SMapChunk::Size),
floor(tileHitPos.z/SMapChunk::Size) );
chunk->dirtyBody = true;
chunk->dirty = true;
//pLevel->UpdateTile(tileHitPos.x, tileHitPos.y, tileHitPos.z);
SSpawnTile s;
s.pos = tileHitPos;
s.vel = pCamera->forward * force;
boxesToSpawn.push(s);
// create a physical entity in this place
/*NewtonBody *box = AddBox(pScene, pWorld, tileHitPos+Vector3(0.5, 0.5, 0.5), Vector3(0.95f,0.95f,0.95f), Vector3(), 100);
// add some velocity
Vector3 vel = pCamera->forward * force;
Vector3 pos;
NewtonBodySetVelocity(box, &vel[0]);*/
// }
}
}
static float lastRocketFire = -100;
if (gInput.WasKeyPressed(K_MOUSE2) )
{
float r = 3;
int x = tileHitPos.x;
int y = tileHitPos.y;
int z = tileHitPos.z;
if (lastRocketFire + 0 < realtime)
{
Debug("Create rocket!");
lastRocketFire = realtime;
if (!hit)
{
CreateRocket(car->pBarrel->GetWorldPosition() + car->pBarrel->up/2, car->pBarrel->up);
}
else
{
Vector3 dir = (p os-(car->pBarrel->GetWorldPosition() + Vector3(0,10,0))).Normalize();
if (dir.y < -0.25)
{
dir.y = -0.25;
dir.Normalize();
}
CreateRocket(car->pBarrel->GetWorldPosition() + car->pBarrel->up/2, dir );
}
}
}
// show car meshes
if (car)
{
CArray<CObject3D*> meshes;
GetMeshesList(car, meshes);
float minT = 99999.0f;
static int current = 0;
if (KeyPressed(']')) { meshes[current]->color = WHITE; current++; if (current == meshes.Size()) current = 0; meshes[current]->color = RED; }
if (KeyPressed('[')) { meshes[current]->color = WHITE; current--; if (current < 0) current = meshes.Size()-1; meshes[current]->color = RED; }
//gVGUI.AddTextMessage(200,90,YELLOW,"%d",current);
car->aimTarget = end;
}
}
void cDialog :: Get_Focus( void )
{
bool focus = 1;
string text_old = text;
int minwidth_old = min_width;
pDialogManager->Update();
boxRGBA( screen, 0, 0, screen->w, screen->h , 0, 0, 0, 32 );
SDL_EnableUNICODE( 1 );
SDL_EnableKeyRepeat( SDL_DEFAULT_REPEAT_DELAY, 50 );
while( focus )
{
Update();
if( rect.w < min_width )
{
rect.w = min_width;
}
else if( rect.w > min_width )
{
min_width = rect.w;
}
SDL_Flip( screen );
while( SDL_PollEvent( &event ) )
{
keys = SDL_GetKeyState( NULL );
if( KeyPressed( KEY_ESC) && event.key.keysym.sym != SDLK_BACKSPACE )
{
text = text_old;
focus = 0;
}
else if ( KeyPressed( KEY_ENTER ) )
{
focus = 0;
}
else if( event.type == SDL_KEYDOWN && event.key.keysym.sym == SDLK_BACKSPACE )
{
if( text.length() && type != DIALOG_ONLY_NUMBERS )
{
text.erase( text.length() - 1, 1 );
Update_Text();
}
}
else if( event.type == SDL_KEYDOWN && event.key.keysym.sym != SDLK_ESCAPE )
{
if( type != DIALOG_ONLY_NUMBERS )
{
if( event.key.keysym.unicode && text.length() < max_length )
{
if( type == DIALOG_ONLY_LETTERS )
{
string s;
s.insert( (string::size_type)0, (string::size_type)1, (char)event.key.keysym.unicode );
if( !is_valid_number( s ) )
{
text.insert( text.length(), s );
}
}
else
{
text.insert( text.length(), 1, (char)event.key.keysym.unicode );
}
Update_Text();
}
}
else
{
if( KeyPressed( KEY_UP ) )
{
text_number += 1;
}
else if( KeyPressed( KEY_DOWN ) )
{
text_number -= 1;
}
else if( KeyPressed( KEY_LEFT ) )
{
text_number -= 10;
}
else if( KeyPressed( KEY_RIGHT ) )
{
text_number += 10;
}
else if( event.type == SDL_KEYDOWN && event.key.keysym.sym == SDLK_PLUS )
{
text_number += 1;
}
else if( event.type == SDL_KEYDOWN && event.key.keysym.sym == SDLK_MINUS )
{
text_number -= 1;
}
else if( event.type == SDL_KEYDOWN && event.key.keysym.sym == SDLK_PAGEUP )
{
text_number += 10;
}
else if( event.type == SDL_KEYDOWN && event.key.keysym.sym == SDLK_PAGEDOWN )
{
text_number -= 10;
}
if( text_number > max_length )
{
text_number = max_length;
}
else if( text_number < 0 )
{
text_number = 0;
}
Update_Text();
}
}
}
Framerate.Update();
}
SDL_EnableUNICODE( 0 );
SDL_EnableKeyRepeat( 0, 0 );
if( text.compare( text_old ) != 0 )
{
changed = 1;
}
min_width = minwidth_old;
Update_Text();
Framerate.Reset();
}
