This translation is community contributed and may not be up to date. We only maintain the English version of the documentation. Read this manual in English
Todo el input del usuario es capturado por el motor y se despacha como acciones a componentes script y scripts GUI en objetos de juego que han adquirido el foco de input y que implementan la función on_input(). Este manual explica cómo configurar bindings para capturar input y cómo crear código que responda a él.
El sistema de input usa un conjunto de conceptos simples y potentes que te permiten gestionar el input como mejor se adapte a tu juego.

Los bindings de input son una tabla global del proyecto que te permite especificar cómo debe traducirse el input de dispositivos a acciones con nombre antes de que se despachen a tus componentes script y scripts GUI. Puedes crear un nuevo archivo de binding de input haciendo click derecho en una ubicación de la vista Assets y seleccionando New... ▸ Input Binding. Para hacer que el motor use el archivo nuevo, cambia la entrada Game Binding en game.project.

Un archivo de binding de input predeterminado se crea automáticamente con todas las plantillas de proyecto nuevas, así que normalmente no necesitas crear un archivo de binding nuevo. El archivo predeterminado se llama game.input_binding y se encuentra en la carpeta input en la raíz del proyecto. Haz doble click en el archivo para abrirlo en el editor:

Para crear un binding nuevo, haz click en el botón + en la parte inferior de la sección del tipo de trigger correspondiente. Cada entrada tiene dos campos:
A del gamepad a la acción jump. Ten en cuenta que existe un bug conocido por el cual los inputs táctiles, lamentablemente, no pueden tener los mismos nombres de acción que otros inputs.Hay cinco tipos de triggers específicos de dispositivo que puedes crear:
Además de los cinco tipos de triggers distintos enumerados arriba, Defold también admite input de acelerómetro en aplicaciones nativas de Android y iOS. Marca la casilla Use Accelerometer en la sección Input de tu archivo game.project.
function on_input(self, action_id, action)
if action.acc_x and action.acc_y and action.acc_z then
-- reaccionar a los datos del acelerómetro
end
end
Para escuchar acciones de input en un componente script o script GUI, se debe enviar el mensaje acquire_input_focus al objeto de juego que contiene el componente:
-- indica al objeto de juego actual (".") que adquiera el foco de input
msg.post(".", "acquire_input_focus")
Este mensaje indica al motor que agregue a la pila de input los componentes capaces de recibir input (componentes script, componentes GUI y proxies de colección) de los objetos de juego. Los componentes del objeto de juego se colocan en la parte superior de la pila de input; el componente que se agregue al final quedará en la parte superior de la pila. Ten en cuenta que si el objeto de juego contiene más de un componente capaz de recibir input, todos los componentes se agregarán a la pila:

Si un objeto de juego que ya ha adquirido el foco de input lo vuelve a adquirir, sus componentes se moverán a la parte superior de la pila.
Las acciones de input se despachan según la pila de input, de arriba hacia abajo.

A todo componente que esté en la pila y contenga una función on_input() se le llamará esa función, una vez por cada acción de input durante el frame, con los siguientes argumentos:
selfaction_idnil para el movimiento del puntero y las muestras del acelerómetro. Usa action.source para distinguir estas acciones sin nombre.actionpressed, etc. Consulta on_input() para ver detalles sobre los campos de acción disponibles.function on_input(self, action_id, action)
if action_id == hash("left") and action.pressed then
-- mover a la izquierda
local pos = go.get_position()
pos.x = pos.x - 100
go.set_position(pos)
elseif action_id == hash("right") and action.pressed then
-- mover a la derecha
local pos = go.get_position()
pos.x = pos.x + 100
go.set_position(pos)
end
end
action.source identifica la categoría del dispositivo de input independientemente del nombre de la acción. Está disponible en los callbacks on_input() tanto de scripts como de scripts GUI y tiene uno de estos hashes:
action.source |
Categoría de input |
|---|---|
hash("keyboard") |
Entrada de teclas individuales de Key Triggers. |
hash("text") |
Entrada de texto y texto marcado de Text Triggers, incluido el texto introducido con un teclado físico. |
hash("mouse") |
Botones de ratón físico, rueda y movimiento del puntero. |
hash("touch") |
Entrada táctil, incluidos los clicks de ratón y el movimiento del puntero simulados desde ella. |
hash("gamepad") |
Entrada de gamepad, incluidos datos sin interpretar y eventos de conexión. |
hash("accelerometer") |
Muestras del acelerómetro. |
Compara action.source con un hash, como hash("touch"), en lugar de una cadena. Por ejemplo, una acción del botón izquierdo del ratón puede proceder de un ratón físico o de un toque. El origen los distingue incluso en la pulsación inicial; consulta Distinguir clicks de ratón de toques.
Cuando varios dispositivos comparten una acción con nombre, sus contribuciones pueden combinarse. Los orígenes se procesan en este orden: teclado, texto, ratón y entrada táctil; se notifica el último origen que contribuye a la acción. Al soltar una tecla o un botón de ratón se conserva el origen anterior, salvo que otra entrada contribuya en el mismo frame. Las acciones de gamepad se mantienen separadas por mando. Usa nombres de acción distintos cuando necesites procesar cada asignación por separado.
El movimiento del puntero y las muestras del acelerómetro no tienen nombre de acción, por lo que ambos usan action_id == nil. Llegan en callbacks separados: el movimiento del puntero tiene coordenadas y origen de ratón o entrada táctil, mientras que las muestras del acelerómetro tienen acc_x, acc_y y acc_z y origen de acelerómetro. Si ambos ocurren en un frame, cada callback puede consumirse por separado. Las muestras del acelerómetro se entregan aunque sus valores no hayan cambiado.
El siguiente ejemplo procesa estas acciones sin nombre. Configura al menos un Mouse Trigger para recibir el movimiento del puntero y activa Use Accelerometer en un dispositivo compatible para recibir muestras del acelerómetro:
function init(self)
msg.post(".", "acquire_input_focus")
end
function on_input(self, action_id, action)
if action_id == nil then
if action.source == hash("mouse") or action.source == hash("touch") then
print("Pointer position:", action.x, action.y)
elseif action.source == hash("accelerometer") then
print("Acceleration:", action.acc_x, action.acc_y, action.acc_z)
end
end
end
Cada mundo de juego cargado dinámicamente mediante un proxy de colección tiene su propia pila de input. Para que el despacho de acciones alcance la pila de input del mundo cargado, el componente proxy debe estar en la pila de input del mundo principal. Todos los componentes en la pila de un mundo cargado se manejan antes de que el despacho continúe hacia abajo por la pila principal:

Es un error común olvidar enviar acquire_input_focus al objeto de juego que contiene el componente proxy de colección. Omitir este paso impide que el input llegue a cualquiera de los componentes en la pila de input del mundo cargado.
Para dejar de escuchar acciones de input, envía un mensaje release_input_focus al objeto de juego. Este mensaje eliminará de la pila de input todos los componentes del objeto de juego:
-- indica al objeto de juego actual (".") que libere el foco de input.
msg.post(".", "release_input_focus")
La función on_input() de un componente puede controlar activamente si las acciones deben pasarse más abajo en la pila o no:
on_input() devuelve false, o se omite el return (esto implica un retorno nil, que es un valor falso en Lua), las acciones de input se pasarán al siguiente componente de la pila de input.on_input() devuelve true, el input se consume. Ningún componente más abajo en la pila de input recibirá el input. Ten en cuenta que esto se aplica a todas las pilas de input. Un componente en la pila de un mundo cargado por proxy puede consumir input, lo que impide que los componentes en la pila principal reciban input:
Hay muchos buenos casos de uso en los que consumir input proporciona una forma simple y potente de mover el input entre distintas partes de un juego. Por ejemplo, si necesitas un menú popup que temporalmente sea la única parte del juego que escucha input:

El menú de pausa está inicialmente oculto (deshabilitado) y se habilita cuando el jugador toca el elemento HUD PAUSE:
function on_input(self, action_id, action)
if action_id == hash("mouse_press") and action.pressed then
-- ¿El jugador presionó PAUSE?
local pausenode = gui.get_node("pause")
if gui.pick_node(pausenode, action.x, action.y) then
-- Indica al menú de pausa que tome el control.
msg.post("pause_menu", "show")
end
end
end

El menú GUI de pausa adquiere el foco de input y consume input, lo que impide cualquier input que no sea relevante para el menú popup:
function on_message(self, message_id, message, sender)
if message_id == hash("show") then
-- Muestra el menú de pausa.
local node = gui.get_node("pause_menu")
gui.set_enabled(node, true)
-- Adquiere foco de input.
msg.post(".", "acquire_input_focus")
end
end
function on_input(self, action_id, action)
if action_id == hash("mouse_press") and action.pressed then
-- hacer cosas...
local resumenode = gui.get_node("resume")
if gui.pick_node(resumenode, action.x, action.y) then
-- Oculta el menú de pausa
local node = gui.get_node("pause_menu")
gui.set_enabled(node, false)
-- Libera foco de input.
msg.post(".", "release_input_focus")
end
end
-- Consume todo el input. Cualquier cosa por debajo de nosotros en la pila de input
-- no verá input hasta que liberemos el foco de input.
return true
end