Slyvtt/Shmup
Slyvtt
/
Shmup
1
0
Fork 0
Code Issues Pull Requests Projects Releases 1 Wiki Activity

Brand new KeyboardExtra class to handle complex keyboard events (1 layer above gint\keyboard.h

This commit is contained in:
Sylvain PILLOT 2023-01-29 12:12:24 +01:00
parent a17ce759dd
commit 2b6f492419
3 changed files with 157 additions and 150 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

179
src/extrakeyboard.cpp
View File

@ -7,30 +7,18 @@
typedef struct
{
bool pressed;
bool has_been_pressed;
bool has_been_released;
bool is_hold_pressed;
bool is_hold_released;
uint32_t lasttickevent;
uint32_t since = 0;
} keyinfo;
keyinfo MyKeyMapper[MYKEY_LASTENUM+1];
KeyboardExtra::KeyboardExtra()
{
uint32_t timer = rtc_ticks();
for(int i=0; i<=MYKEY_LASTENUM; i++)
{
MyKeyMapper[i].pressed=false;
MyKeyMapper[i].has_been_pressed=false;
MyKeyMapper[i].has_been_released=false;
MyKeyMapper[i].is_hold_pressed=false;
MyKeyMapper[i].is_hold_released=false;
MyKeyMapper[i].lasttickevent=timer;
}
now = timer;
for(int i=0; i<=MYKEY_LASTENUM; i++) MyKeyMapper[i] = { .pressed = false, .since = timer };
}
@ -43,94 +31,99 @@ KeyboardExtra::~KeyboardExtra()
void KeyboardExtra::Update( float dt )
{
uint32_t timer = rtc_ticks();
now = timer;
key_event_t ev;
int keycode = -1;
while((ev = pollevent()).type != KEYEV_NONE)
{
if(ev.key == KEY_F3) // Manage the key sequence for KEY_F3
if (ev.key == KEY_F1) keycode = MYKEY_F1;
else if(ev.key == KEY_F2) keycode = MYKEY_F2;
else if(ev.key == KEY_F3) keycode = MYKEY_F3;
else if(ev.key == KEY_F4) keycode = MYKEY_F4;
else if(ev.key == KEY_F5) keycode = MYKEY_F5;
else if(ev.key == KEY_F6) keycode = MYKEY_F6;
else if(ev.key == KEY_SHIFT) keycode = MYKEY_SHIFT;
else if(ev.key == KEY_OPTN) keycode = MYKEY_OPTN;
else if(ev.key == KEY_VARS) keycode = MYKEY_VARS;
else if(ev.key == KEY_MENU) keycode = MYKEY_MENU;
else if(ev.key == KEY_LEFT) keycode = MYKEY_LEFT;
else if(ev.key == KEY_UP) keycode = MYKEY_UP;
else if(ev.key == KEY_ALPHA) keycode = MYKEY_ALPHA;
else if(ev.key == KEY_SQUARE) keycode = MYKEY_SQUARE;
else if(ev.key == KEY_POWER) keycode = MYKEY_POWER;
else if(ev.key == KEY_EXIT) keycode = MYKEY_EXIT;
else if(ev.key == KEY_DOWN) keycode = MYKEY_DOWN;
else if(ev.key == KEY_RIGHT) keycode = MYKEY_RIGHT;
else if(ev.key == KEY_XOT) keycode = MYKEY_XOT;
else if(ev.key == KEY_LOG) keycode = MYKEY_LOG;
else if(ev.key == KEY_LN) keycode = MYKEY_LN;
else if(ev.key == KEY_SIN) keycode = MYKEY_SIN;
else if(ev.key == KEY_COS) keycode = MYKEY_COS;
else if(ev.key == KEY_TAN) keycode = MYKEY_TAN;
else if(ev.key == KEY_FRAC) keycode = MYKEY_FRAC;
else if(ev.key == KEY_FD) keycode = MYKEY_FD;
else if(ev.key == KEY_LEFTP) keycode = MYKEY_LEFTP;
else if(ev.key == KEY_RIGHTP) keycode = MYKEY_RIGHTP;
else if(ev.key == KEY_COMMA) keycode = MYKEY_COMMA;
else if(ev.key == KEY_ARROW) keycode = MYKEY_ARROW;
else if(ev.key == KEY_7) keycode = MYKEY_7;
else if(ev.key == KEY_8) keycode = MYKEY_8;
else if(ev.key == KEY_9) keycode = MYKEY_9;
else if(ev.key == KEY_DEL) keycode = MYKEY_DEL;
else if(ev.key == KEY_4) keycode = MYKEY_4;
else if(ev.key == KEY_5) keycode = MYKEY_5;
else if(ev.key == KEY_6) keycode = MYKEY_6;
else if(ev.key == KEY_MUL) keycode = MYKEY_MUL;
else if(ev.key == KEY_DIV) keycode = MYKEY_DIV;
else if(ev.key == KEY_1) keycode = MYKEY_1;
else if(ev.key == KEY_2) keycode = MYKEY_2;
else if(ev.key == KEY_3) keycode = MYKEY_3;
else if(ev.key == KEY_ADD) keycode = MYKEY_ADD;
else if(ev.key == KEY_SUB) keycode = MYKEY_SUB;
else if(ev.key == KEY_0) keycode = MYKEY_0;
else if(ev.key == KEY_DOT) keycode = MYKEY_DOT;
else if(ev.key == KEY_EXP) keycode = MYKEY_EXP;
else if(ev.key == KEY_NEG) keycode = MYKEY_NEG;
else if(ev.key == KEY_EXE) keycode = MYKEY_EXE;
else if(ev.key == KEY_ACON) keycode = MYKEY_ACON;
if(keycode!=-1)
{
if (ev.type == KEYEV_DOWN) // We have a keydown event detected in the pollevent queue
{
if(MyKeyMapper[MYKEY_F3].pressed) // the key was already pressed so nothing changed
{
MyKeyMapper[MYKEY_F3].has_been_pressed = false;
MyKeyMapper[MYKEY_F3].has_been_released = false;
MyKeyMapper[MYKEY_F3].lasttickevent = timer;
MyKeyMapper[MYKEY_F3].is_hold_pressed = true;
MyKeyMapper[MYKEY_F3].is_hold_released = false;
MyKeyMapper[MYKEY_F3].pressed = true;
}
else // the key was not pressed, so we can raise the keypressed event
{
MyKeyMapper[MYKEY_F3].has_been_pressed = true;
MyKeyMapper[MYKEY_F3].has_been_released = false;
MyKeyMapper[MYKEY_F3].lasttickevent = timer;
MyKeyMapper[MYKEY_F3].is_hold_pressed = false;
MyKeyMapper[MYKEY_F3].is_hold_released = false;
MyKeyMapper[MYKEY_F3].pressed = true;
}
}
else if (ev.type == KEYEV_UP) // We have a keyup event detected in the pollevent queue
{
if(MyKeyMapper[MYKEY_F3].pressed) // the key was pressed, so we can raise the keypressed event
{
MyKeyMapper[MYKEY_F3].has_been_pressed = false;
MyKeyMapper[MYKEY_F3].has_been_released = true;
MyKeyMapper[MYKEY_F3].lasttickevent = timer;
MyKeyMapper[MYKEY_F3].is_hold_pressed = false;
MyKeyMapper[MYKEY_F3].is_hold_released = false;
MyKeyMapper[MYKEY_F3].pressed = false;
}
else // the key was already not pressed so nothing changed
{
MyKeyMapper[MYKEY_F3].has_been_pressed = false;
MyKeyMapper[MYKEY_F3].has_been_released = false;
MyKeyMapper[MYKEY_F3].lasttickevent = timer;
MyKeyMapper[MYKEY_F3].is_hold_pressed = false;
MyKeyMapper[MYKEY_F3].is_hold_released = true;
MyKeyMapper[MYKEY_F3].pressed = false;
}
}
if (ev.type == KEYEV_DOWN) MyKeyMapper[keycode] = { .pressed = true, .since = timer };
else if (ev.type == KEYEV_UP) MyKeyMapper[keycode] = { .pressed = false, .since = timer };
else if (ev.type == KEYEV_HOLD) {}
}
else
{
MyKeyMapper[MYKEY_F3].has_been_pressed = false;
MyKeyMapper[MYKEY_F3].has_been_released = false;
if (MyKeyMapper[MYKEY_F3].pressed)
{
MyKeyMapper[MYKEY_F3].is_hold_pressed = true;
MyKeyMapper[MYKEY_F3].is_hold_released = false;
}
else
{
MyKeyMapper[MYKEY_F3].is_hold_pressed = false;
MyKeyMapper[MYKEY_F3].is_hold_released = true;
}
}
if(ev.key == KEY_EXIT)
{
if (ev.type == KEYEV_DOWN)
{
MyKeyMapper[MYKEY_EXIT].pressed = true;
}
}
// do nothing, just unstack the event from the events queue
};
}
}
bool KeyboardExtra::IsKeyPressedEvent( int key )
{
return MyKeyMapper[key].has_been_pressed;
return (MyKeyMapper[key].pressed && MyKeyMapper[key].since == now);
}
bool KeyboardExtra::IsKeyReleasedEvent( int key )
{
return MyKeyMapper[key].has_been_released;
return (!MyKeyMapper[key].pressed && MyKeyMapper[key].since == now);
}
@ -148,26 +141,20 @@ bool KeyboardExtra::IsKeyReleased( int key )
uint32_t KeyboardExtra::IsKeyHoldPressed( int key )
{
if (MyKeyMapper[key].is_hold_pressed)
{
uint32_t a = rtc_ticks();
return (uint32_t) (a - MyKeyMapper[key].lasttickevent);
}
if (MyKeyMapper[key].pressed && MyKeyMapper[key].since < now)
return (uint32_t) (now-MyKeyMapper[key].since);
else return 0;
}
uint32_t KeyboardExtra::IsKeyHoldReleased( int key )
{
if (MyKeyMapper[key].is_hold_released)
{
uint32_t a = rtc_ticks();
return (uint32_t) (a - MyKeyMapper[key].lasttickevent);
}
else return 0;
if (!MyKeyMapper[key].pressed && MyKeyMapper[key].since < now)
return (uint32_t) (now-MyKeyMapper[key].since);
else return 0;
}
uint32_t KeyboardExtra::GetLastTickKeyEvent( int key )
{
return MyKeyMapper[key].lasttickevent;
return (uint32_t) MyKeyMapper[key].since;
}

53
src/extrakeyboard.h
View File

@ -14,19 +14,57 @@ enum
MYKEY_F6,
MYKEY_SHIFT,
MYKEY_OPT,
MYKEY_VAR,
MYKEY_OPTN,
MYKEY_VARS,
MYKEY_MENU,
MYKEY_LEFT,
MYKEY_UP,
MYKEY_ALPHA,
MYKEY_SQUARE,
MYKEY_POWER,
MYKEY_EXIT,
MYKEY_LEFT,
MYKEY_RIGHT,
MYKEY_DOWN,
MYKEY_UP,
MYKEY_RIGHT,
MYKEY_XOT,
MYKEY_LOG,
MYKEY_LN,
MYKEY_SIN,
MYKEY_COS,
MYKEY_TAN,
MYKEY_FRAC,
MYKEY_FD,
MYKEY_LEFTP,
MYKEY_RIGHTP,
MYKEY_COMMA,
MYKEY_ARROW,
MYKEY_7,
MYKEY_8,
MYKEY_9,
MYKEY_DEL,
MYKEY_4,
MYKEY_5,
MYKEY_6,
MYKEY_MUL,
MYKEY_DIV,
MYKEY_1,
MYKEY_2,
MYKEY_3,
MYKEY_ADD,
MYKEY_SUB,
MYKEY_0,
MYKEY_DOT,
MYKEY_EXP,
MYKEY_NEG,
MYKEY_EXE,
MYKEY_ACON,
MYKEY_LASTENUM,
};
@ -47,6 +85,9 @@ class KeyboardExtra
uint32_t IsKeyHoldPressed( int key );
uint32_t IsKeyHoldReleased( int key );
uint32_t GetLastTickKeyEvent( int key );
private:
uint32_t now;
};

75
src/main.cpp
View File

@ -111,7 +111,7 @@ static void hook_prefrag(int id, void *fragment, int size)
if(id == azrp_frag_count - 1) {
usb_commit_sync(pipe);
//screenshot = false;
screenshot = false;
}
}
@ -214,24 +214,17 @@ static void render( void )
#if(BIAS)
if (texttodraw>=1) Azur_draw_text(1,01, "FPS = %.0f", (float) (1000000.0f / elapsedTime) );
if (texttodraw>=1) Azur_draw_text(1,11, "Render = %.0f mc secs", (float) time_render / 1000.0f );
if (texttodraw>=1) Azur_draw_text(1,21, "Hold Down : %d ", MyKeyboard.IsKeyHoldPressed(MYKEY_F3));
if (texttodraw>=1) Azur_draw_text(1,31, "Hold Up : %d ", MyKeyboard.IsKeyHoldReleased(MYKEY_F3));
if (texttodraw>=1) Azur_draw_text(1,41, "Last Tick Event : %d ", MyKeyboard.GetLastTickKeyEvent(MYKEY_F3));
/* if (texttodraw>=1) Azur_draw_text(1,11, "Part.= %d - Bull.= %d", MyParticles.size(), MyPlayerBullets.size() );
if (texttodraw>=1) Azur_draw_text(1,11, "Part.= %d - Bull.= %d", MyParticles.size(), MyPlayerBullets.size() );
if (texttodraw>=1 && !MyEnemies.empty()) Azur_draw_text(1,21, "Ennmy Life= %d", MyEnemies[0]->life );
if (texttodraw>=2) Azur_draw_text(1,31, "Update = %.0f mc secs", (float) time_update );
if (texttodraw>=2) Azur_draw_text(1,41, "Render = %.0f mc secs", (float) time_render );
if (texttodraw>=2) Azur_draw_text(1,51, ">Total = %.3f ml secs", (float) elapsedTime / 1000.0f );
if (texttodraw>=2) Azur_draw_text(1,61, ">Total = %.0f seconds", (float) elapsedTime );
if (texttodraw>=3) Azur_draw_text(1,81, "Mem Used : %d", _uram_stats->used_memory + extram_stats->used_memory);
if (texttodraw>=3) Azur_draw_text(1,91, "Mem Free : %d", _uram_stats->free_memory + extram_stats->free_memory);
if (texttodraw>=3) Azur_draw_text(1,101, "Mem Peak Used : %d", _uram_stats->peak_used_memory + extram_stats->peak_used_memory );
if (texttodraw>=3) Azur_draw_text(1,121, "Size of Particles : %d bytes", sizeof(Particle) );
if (texttodraw>=3) Azur_draw_text(1,131, "Size of Bullets : %d bytes", sizeof(Bullet) );
*/
#endif
}
@ -242,60 +235,45 @@ static void get_inputs( float dt )
uint8_t speed = 4;
uint32_t tempshoot = rtc_ticks();
key_event_t ev;
while((ev = pollevent()).type != KEYEV_NONE)
{
}
//if(keydown(KEY_F3)) {Create_Explosion();}
if(keydown(KEY_F1))
if(MyKeyboard.IsKeyPressed(MYKEY_F1))
{
if (MyPlayer->Shoot_OK(tempshoot, 0)) Create_Player_Shoot(0);
}
if(keydown(KEY_F2))
if(MyKeyboard.IsKeyPressed(MYKEY_F2))
{
if (MyPlayer->Shoot_OK(tempshoot, 1)) Create_Player_Shoot(1);
}
//if(keydown(KEY_F3))
if(MyKeyboard.IsKeyPressedEvent(MYKEY_F3))
{
if (MyPlayer->Shoot_OK(tempshoot, 2)) Create_Player_Shoot(2);
}
// if (MyKeyboard.IsKeyPressed(MYKEY_F3)) color=C_RED;
// if (MyKeyboard.IsKeyReleased(MYKEY_F3)) color=C_GREEN;
if (MyKeyboard.IsKeyPressed(MYKEY_EXIT)) {exitToOS = true; };
if(keydown(KEY_EXIT)) {exitToOS = true; };
if (MyKeyboard.IsKeyPressed(MYKEY_SHIFT) && MyKeyboard.IsKeyHoldPressed(MYKEY_EXIT)) {exitToOS = true; };
#if(DEBUG_MODE)
if(keydown(KEY_7) && usb_is_open() ) {screenshot = true;};
if(keydown(KEY_8) && usb_is_open()) {record = true; };
if(keydown(KEY_9) && usb_is_open()) {record = false; };
if(keydown(KEY_DEL) && usb_is_open()) {textoutput = true;};
if(MyKeyboard.IsKeyPressedEvent(MYKEY_7) && usb_is_open() ) {screenshot = true;};
if(MyKeyboard.IsKeyPressedEvent(MYKEY_8) && usb_is_open()) {record = true; };
if(MyKeyboard.IsKeyPressedEvent(MYKEY_9) && usb_is_open()) {record = false; };
if(MyKeyboard.IsKeyPressedEvent(MYKEY_DEL) && usb_is_open()) {textoutput = true;};
#endif
if(keydown(KEY_SHIFT) && keydown(KEY_F1)) {texttodraw=0;}
if(keydown(KEY_SHIFT) && keydown(KEY_F2)) {texttodraw=1;}
if(keydown(KEY_SHIFT) && keydown(KEY_F3)) {texttodraw=2;}
if(keydown(KEY_SHIFT) && keydown(KEY_F4)) {texttodraw=3;}
if(keydown(KEY_SHIFT) && keydown(KEY_F6))
if(MyKeyboard.IsKeyPressed(MYKEY_SHIFT) && MyKeyboard.IsKeyPressedEvent(MYKEY_F1)) {texttodraw=0;}
if(MyKeyboard.IsKeyPressed(MYKEY_SHIFT) && MyKeyboard.IsKeyPressedEvent(MYKEY_F2)) {texttodraw=1;}
if(MyKeyboard.IsKeyPressed(MYKEY_SHIFT) && MyKeyboard.IsKeyPressedEvent(MYKEY_F3)) {texttodraw=2;}
if(MyKeyboard.IsKeyPressed(MYKEY_SHIFT) && MyKeyboard.IsKeyPressedEvent(MYKEY_F4)) {texttodraw=3;}
if(MyKeyboard.IsKeyPressed(MYKEY_SHIFT) && MyKeyboard.IsKeyPressedEvent(MYKEY_F6))
{
azrp_starfield_close( );
azrp_starfield_init( 100 );
azrp_starfield_init( 250 );
}
// if(keydown(KEY_F5)) drawback = !drawback;
// if(keydown(KEY_F6)) drawstars = !drawstars;
if(keydown(KEY_LEFT)) { MyPlayer->Go_Left( dt ); }
if(keydown(KEY_RIGHT)) { MyPlayer->Go_Right( dt ); }
if(keydown(KEY_UP)) { MyPlayer->Go_Up( dt ); }
if(keydown(KEY_DOWN)) { MyPlayer->Go_Down( dt ); }
if(MyKeyboard.IsKeyPressed(MYKEY_LEFT)) { MyPlayer->Go_Left( dt ); }
if(MyKeyboard.IsKeyPressed(MYKEY_RIGHT)) { MyPlayer->Go_Right( dt ); }
if(MyKeyboard.IsKeyPressed(MYKEY_UP)) { MyPlayer->Go_Up( dt ); }
if(MyKeyboard.IsKeyPressed(MYKEY_DOWN)) { MyPlayer->Go_Down( dt ); }
}
@ -376,7 +354,7 @@ int main(void)
azrp_shader_image_p4_configure();
azrp_hook_set_prefrag(hook_prefrag);
azrp_starfield_init( 100 );
azrp_starfield_init( 250 );
Create_Ennemies( );
@ -432,8 +410,9 @@ int main(void)
#if(DEBUG_MODE)
if (textoutput && usb_is_open())
{
azrp_starfield_USBDEBUG( SHOW_PIXELS );
azrp_starfield_USBDEBUG( SHOW_STARS );
// to add here what must be sent to USB for Text mode debugging
textoutput = false;
}
#endif