input_handler.h File Reference

Exposes functions for working with input. More...

#include "input_types.h"
#include <notcurses/notcurses.h>

Go to the source code of this file.

Functions
bool	init_input_handler (struct notcurses *nc)
	Initialize the input handler.
bool	get_input_blocking (input_event_t *event)
	Get the next input event (blocking)
bool	get_input_nonblocking (input_event_t *event)
	Get the next input event (non-blocking)
input_t	translate_input (const ncinput *raw_input)
	Translate a raw Notcurses input to a logical input type.
void	shutdown_input_handler (void)
	Shutdown the input handler.

Detailed Description

Exposes functions for working with input.

Definition in file input_handler.h.

Function Documentation

get_input_blocking()

bool get_input_blocking

(

input_event_t *

event

)

Get the next input event (blocking)

Waits for an input event and translates it to a logical input type. This function blocks until input is received.

Parameters

[out]

event

Pointer to an input_event_t structure to fill with the input event

Returns

true if an event was retrieved, false on error

Definition at line 147 of file input_handler.c.

                                              {
    if (!event || !nc) {
        log_msg(ERROR, "input_handler", "Null event pointer or uninitialized handler");
        return false;
    }
 
    // Get input directly using notcurses
    ncinput raw_input;
    memset(&raw_input, 0, sizeof(ncinput));
 
    // Set default values in case we return early
    event->type = INPUT_NONE;
    memset(&event->raw_input, 0, sizeof(ncinput));
 
    // Loop until we get a valid input or notcurses returns an error
    while (true) {
        uint32_t ret = notcurses_get_blocking(nc, &raw_input);
        if (ret <= 0) {
            // Error or no input
            return false;
        }
 
        // Debounce - if we're getting keys too fast, ignore some
        if (!should_process_key()) {
            continue;
        }
 
        // Translate and fill the event structure
        event->type = translate_input(&raw_input);
        event->raw_input = raw_input;
        return true;
    }
}

get_input_nonblocking()

bool get_input_nonblocking

(

input_event_t *

event

)

Get the next input event (non-blocking)

Checks for an input event and translates it to a logical input type. This function does not block if no input is available.

Parameters

[out]

event

Pointer to an input_event_t structure to fill with the input event

Returns

true if an event was retrieved, false if no events are available

Definition at line 181 of file input_handler.c.

                                                 {
    if (!event || !nc) {
        log_msg(ERROR, "input_handler", "Null event pointer or uninitialized handler");
        return false;
    }
 
    // Get input directly using notcurses
    ncinput raw_input;
    memset(&raw_input, 0, sizeof(ncinput));
 
    // Set default values in case we return early
    event->type = INPUT_NONE;
    memset(&event->raw_input, 0, sizeof(ncinput));
 
    uint32_t ret = notcurses_get_nblock(nc, &raw_input);
    if (ret <= 0) {
        // No input available
        return false;
    }
 
    // Debounce - if we're getting keys too fast, ignore some
    if (!should_process_key()) {
        return false;
    }
 
    // Translate and fill the event structure
    event->type = translate_input(&raw_input);
    event->raw_input = raw_input;
    return true;
}

init_input_handler()

bool init_input_handler

(

struct notcurses *

nc

)

Initialize the input handler.

Sets up the input handling system. This function must be called before any other input functions.

Parameters

nc	The Notcurses instance to use for input handling

Returns

true on success, false on failure

Definition at line 100 of file input_handler.c.

                                                         {
    if (!notcurses_ptr) {
        log_msg(ERROR, "input_handler", "Null Notcurses instance provided");
        return false;
    }
 
    // Assign to the global variable
    nc = notcurses_ptr;
 
    // Initialize input timing
    input_timing.first_key = true;
 
    return true;
}

shutdown_input_handler()

void shutdown_input_handler

(

void

)

Shutdown the input handler.

Cleans up resources. This function should be called when shutting down the game.

Definition at line 212 of file input_handler.c.

                                  {
    nc = NULL;
}

translate_input()

input_t translate_input

(

const ncinput *

raw_input

)

Translate a raw Notcurses input to a logical input type.

Helper function to convert from hardware-specific to logical inputs.

Parameters

raw_input

The raw Notcurses input

Returns

The corresponding logical input type

Definition at line 62 of file input_handler.c.

                                                  {
    if (!raw_input) {
        return INPUT_NONE;
    }
 
    // Handle special case for Ctrl+C to quit
    if (raw_input->id == 'c' && (raw_input->modifiers & NCKEY_MOD_CTRL)) {
        return INPUT_QUIT;
    }
 
    // Check if this is a key event (allow both NCTYPE_UNKNOWN and NCTYPE_PRESS)
    if (raw_input->evtype == NCTYPE_PRESS || raw_input->evtype == NCTYPE_UNKNOWN) {
        // Arrow keys for navigation
        if (raw_input->id == NCKEY_UP) return INPUT_UP;
        if (raw_input->id == NCKEY_DOWN) return INPUT_DOWN;
        if (raw_input->id == NCKEY_LEFT) return INPUT_LEFT;
        if (raw_input->id == NCKEY_RIGHT) return INPUT_RIGHT;
 
        // Enter key for confirmation
        if (raw_input->id == NCKEY_ENTER || raw_input->id == ' ') return INPUT_CONFIRM;
 
        // Cancel key (C)
        if (raw_input->id == 'c' || raw_input->id == 'C') return INPUT_CANCEL;
 
        // Menu key (M)
        if (raw_input->id == 'm' || raw_input->id == 'M') return INPUT_MENU;
 
        // Stats key (L)
        if (raw_input->id == 'l' || raw_input->id == 'L') return INPUT_STATS;
 
        // Inventory key (I)
        if (raw_input->id == 'i' || raw_input->id == 'I') return INPUT_INVENTORY;
    }
 
    // If we didn't match anything, return INPUT_NONE
    return INPUT_NONE;
}