dusk/src/dusk/script/module/input/moduleinput.c

/**
 * Copyright (c) 2026 Dominic Masters
 * 
 * This software is released under the MIT License.
 * https://opensource.org/licenses/MIT
 */

#include "moduleinput.h"
#include "input/input.h"
#include "assert/assert.h"
#include "util/string.h"

void moduleInput(scriptcontext_t *context) {
  assertNotNull(context, "Script context cannot be NULL");

  // Setup enums.
  scriptContextExec(context, INPUT_ACTION_SCRIPT);

  // Input values.
  scriptContextExec(context,
    ""
    #ifdef DUSK_INPUT_KEYBOARD
      "INPUT_KEYBOARD = true\n"
    #endif
    #ifdef DUSK_INPUT_GAMEPAD
      "INPUT_GAMEPAD = true\n"
    #endif
    #ifdef DUSK_INPUT_POINTER
      "INPUT_POINTER = true\n"
    #endif
    #ifdef DUSK_INPUT_TOUCH
      "INPUT_TOUCH = true\n"
    #endif
  );

  // Metatable
  if(luaL_newmetatable(context->luaState, "input_mt")) {
    lua_pushcfunction(context->luaState, moduleInputIndex);
    lua_setfield(context->luaState, -2, "__index");
  }
  lua_pop(context->luaState, 1);

  // Events
  lua_pushlightuserdata(context->luaState, &INPUT.eventPressed);
  lua_setglobal(context->luaState, "INPUT_EVENT_PRESSED");
  
  lua_pushlightuserdata(context->luaState, &INPUT.eventReleased);
  lua_setglobal(context->luaState, "INPUT_EVENT_RELEASED");

  // Bind methods
  lua_register(context->luaState, "inputBind", moduleInputBind);
  lua_register(context->luaState, "inputIsDown", moduleInputIsDown);
  lua_register(context->luaState, "inputPressed", moduleInputPressed);
  lua_register(context->luaState, "inputReleased", moduleInputReleased);
  lua_register(context->luaState, "inputGetValue", moduleInputGetValue);
  lua_register(context->luaState, "inputAxis", moduleInputAxis);
}

int moduleInputIndex(lua_State *l) {
  assertNotNull(l, "Lua state cannot be NULL");

  const char_t *key = luaL_checkstring(l, 2);
  assertStrLenMin(key, 1, "Key cannot be empty.");

  if(stringCompare(key, "action") == 0) {
    const inputevent_t *event = (const inputevent_t*)lua_touserdata(l, 1);
    if(event == NULL) {
      luaL_error(l, "Expected input event as first argument");
      return 0;
    }

    lua_pushnumber(l, event->action);
    return 1;
  }

  lua_pushnil(l);
  return 1;
}

int moduleInputBind(lua_State *L) {
  assertNotNull(L, "Lua state cannot be NULL");

  // Requires action and button.
  if(!lua_isstring(L, 1)) {
    luaL_error(L, "inputBind: Expected button name as first argument");
    return 0;
  }

  // Expect action ID
  if(!lua_isnumber(L, 2)) {
    luaL_error(L, "inputBind: Expected action ID as second argument");
    return 0;
  }

  const char_t *strBtn = lua_tostring(L, 1);
  const inputaction_t action = (inputaction_t)lua_tonumber(L, 2);
  
  if(strBtn == NULL || strlen(strBtn) == 0) {
    luaL_error(L, "inputBind: Button name cannot be NULL or empty");
    return 0;
  }

  // Validate action
  if(action < INPUT_ACTION_NULL || action >= INPUT_ACTION_COUNT) {
    luaL_error(L, "inputBind: Invalid action ID %d with str %s", action, strBtn);
    return 0;
  }

  // Get button by name
  inputbutton_t btn = inputButtonGetByName(strBtn);
  if(btn.type == INPUT_BUTTON_TYPE_NONE) {
    luaL_error(L, "inputBind: Invalid button name '%s'", strBtn);
    return 0;
  }

  inputBind(btn, action);
  return 0;
}

int moduleInputIsDown(lua_State *L) {
  assertNotNull(L, "Lua state cannot be NULL");

  if(!lua_isnumber(L, 1)) {
    luaL_error(L, "inputIsDown: Expected action ID as first argument");
    return 0;
  }

  const inputaction_t action = (inputaction_t)lua_tonumber(L, 1);
  
  if(action < INPUT_ACTION_NULL || action >= INPUT_ACTION_COUNT) {
    luaL_error(L, "inputIsDown: Invalid action ID %d", action);
    return 0;
  }

  lua_pushboolean(L, inputIsDown(action));
  return 1;
}

int moduleInputPressed(lua_State *L) {
  assertNotNull(L, "Lua state cannot be NULL");

  if(!lua_isnumber(L, 1)) {
    luaL_error(L, "inputPressed: Expected action ID as first argument");
    return 0;
  }

  const inputaction_t action = (inputaction_t)lua_tonumber(L, 1);
  
  if(action < INPUT_ACTION_NULL || action >= INPUT_ACTION_COUNT) {
    luaL_error(L, "inputPressed: Invalid action ID %d", action);
    return 0;
  }

  lua_pushboolean(L, inputPressed(action));
  return 1;
}

int moduleInputReleased(lua_State *L) {
  assertNotNull(L, "Lua state cannot be NULL");

  if(!lua_isnumber(L, 1)) {
    luaL_error(L, "inputReleased: Expected action ID as first argument");
    return 0;
  }

  const inputaction_t action = (inputaction_t)lua_tonumber(L, 1);
  
  if(action < INPUT_ACTION_NULL || action >= INPUT_ACTION_COUNT) {
    luaL_error(L, "inputReleased: Invalid action ID %d", action);
    return 0;
  }

  lua_pushboolean(L, inputReleased(action));
  return 1;
}

int moduleInputGetValue(lua_State *L) {
  assertNotNull(L, "Lua state cannot be NULL");

  if(!lua_isnumber(L, 1)) {
    luaL_error(L, "inputGetValue: Expected action ID as first argument");
    return 0;
  }

  const inputaction_t action = (inputaction_t)lua_tonumber(L, 1);
  if(action < INPUT_ACTION_NULL || action >= INPUT_ACTION_COUNT) {
    luaL_error(L, "inputGetValue: Invalid action ID %d", action);
    return 0;
  }

  lua_pushnumber(L, inputGetCurrentValue(action));
  return 1;
}

int moduleInputAxis(lua_State *L) {
  assertNotNull(L, "Lua state cannot be NULL");

  if(!lua_isnumber(L, 1) || !lua_isnumber(L, 2)) {
    luaL_error(L, "inputAxis: Expected two action IDs as arguments (neg, pos)");
    return 0;
  }

  const inputaction_t neg = (inputaction_t)lua_tonumber(L, 1);
  const inputaction_t pos = (inputaction_t)lua_tonumber(L, 2);

  if(neg < INPUT_ACTION_NULL || neg >= INPUT_ACTION_COUNT) {
    luaL_error(L, "inputAxis: Invalid negative action ID %d", neg);
    return 0;
  }
  if(pos < INPUT_ACTION_NULL || pos >= INPUT_ACTION_COUNT) {
    luaL_error(L, "inputAxis: Invalid positive action ID %d", pos);
    return 0;
  }

  lua_pushnumber(L, inputAxis(neg, pos));
  return 1;
}