Sommaire :

Gérer le clavier
Projet de démo
Introduction
Avertissement
Appui continu
Appui simple

Gérer la souris
Projet de démo
Coordonnées
Clic continu
Clic simple

Gérer le joystick
Détecter sa présence
Lire les valeurs des boutons
Lire les valeurs du stick analogique

Gérer le clavier

Projet de démo
📁 ​Voir le projet de démo​ (dans le dossier "Clavier")
Introduction
Ce qui est important de comprendre, pour gérer correctement le clavier, c'est qu'on a 2 cas
de figure :

- On veut détecter qu'une touche est enfoncée "en continu" par exemple pour gérer un
déplacement via les touches de directions. Cela signifie que tant qu'on appuie sur la
touche en question (maintient enfoncé), il se passe quelque chose. Clair ?

- On veut détecter qu'une touche a été pressée, et ne réagir qu'une seule fois ! Par
exemple "Touche I pour inventaire" (et globalement toutes les touches de menu ou
d'options dans un jeu) ou encore le tir, si on veut un seul tir à la fois et obliger le
joueur à relâcher la touche et la re-enfoncer pour avoir un 2ème tir.

Avertissement
Pour avoir un code propre et maintenable, il faut séparer la logique de l'affichage.
Je ne veux donc pas voir de tests du clavier, de la souris ou du joystick, dans la fonction
système love.draw !

Imaginez que vous voulez gérer la pause dans un jeu… Si vous avez mis des tests de
clavier partout, et donc dans le draw, vous ne vous en sortirez pas ! Même en pause le
joueur pourra continuer à interagir avec le jeu.

Alors que si tout est dans l'update, il suffit de ne pas exécuter le code de gameplay si la
pause est active (via un simple "if"). L'affichage lui, sera figé. Comme une vrai pause quoi !

Appui continu
Pour gérer l'appui continu c'est assez simple :

if​ love.keyboard.isDown(​"right"​) ​then

...

On fait ça dans love.update :

function​ ​love.update​(dt)
​if​ love.keyboard.isDown(​"right"​) ​then
hero.x = hero.x + ​10​*dt
​end
end

Ici c'est la touche "flèche droite" qui est testée. On passe donc la constante "right" à la
fonction isDown.

A consulter absolument, pour la liste de toutes les valeurs pour désigner une touche :

https://love2d.org/wiki/KeyConstant

Appui simple
Parfois (souvent même) on ne veut réagir qu'une seule fois.

Love2D nous mâche me travail avec une fonction système (au même titre que love.load /
love.update et love.draw) :

function​ ​love.keypressed​(key)

Cette fonction est appelée "une fois" quand une touche est enfoncée, et reçoit la constante
de la touche en paramètre. Pour réagir 2 fois à la même touche, il faut donc relâcher la
touche et la re-enfoncer.
Exemple pour afficher une trace de la touche enfoncée, et pour réagir une seule fois si le
joueur presse la touche ECHAP (dans ce cas là on quitte le jeu) :

function​ ​love.keypressed​(key)
​print​(​"La touche "​..key..​" vient d'être enfoncée !"​)

​if​ key == ​"escape"​ ​then

love.event.quit()
​end
end

A consulter absolument, pour la liste de toutes les valeurs pour désigner une touche :

https://love2d.org/wiki/KeyConstant

Gérer la souris

Projet de démo
📁 ​Voir le projet de démo​ (dans le dossier "Souris")
Coordonnées
Vous avez 3 façons de récupérer les coordonnées de la souris :

1) Par getX et getY :

hero.x = love.mouse.getX()
hero.y = love.mouse.getY()

2) Par getPosition :

​local​ x,y = love.mouse.getPosition()

hero.x = x
hero.y = y

3) Au moment où la fonction système love.mousePressed/Released/Moved :

function​ ​love.mousepressed​(x, y, button)

​if​ button == ​2​ ​then
hero.x = x
 hero.y = y
​end
end

Clic continu
Pour détecter un clic continu, je vous conseille de faire comme pour le clavier. Vous
détectez l'appui sur un bouton dans love.update :

function​ ​love.update​(dt)
​if​ love.mouse.isDown(​1​) ​then
hero.x = love.mouse.getX()
hero.y = love.mouse.getY()
​end
end

Note : le bouton de gauche vaut 1, le bouton de droite vaut 2 et le bouton du milieu vaut 3.

Clic simple
Pour détecter un clic unique, encore une fois c'est comme pour le clavier. On a une fonction
système pour ça :

function​ ​love.mousepressed​(x, y, button)

​if​ button == ​2​ ​then
hero.x = x
hero.y = y
​end
end

A noter qu'il existe 3 autres fonctions systèmes pour la souris. Voyez si ça peut vous être
utile :

function​ ​love.mousereleased​(x, y, button)

​print​(​"Le bouton "​..​tostring​(button)..​" vient d'être relaché"​)
end

function​ ​love.mousemoved​(x, y)
​print​(​"La souris s'est déplacée en "​..​tostring​(x)..​","​..​tostring​(y))
end

function​ ​love.wheelmoved​(x, y)
​print​(​"La roulette vient de tourner de (x,y) : "
..​tostring​(x)..​","​..​tostring​(y))
 end

Dans le projet de démo vous pouvez tester qu'avec le clic gauche vous pouvez maintenir le
bouton enfoncé pour déplacer le personnage, alors que le personnage ne se déplace qu'une
fois à chaque clic avec le bouton droit.

Gérer le joystick

Introduction
Gérer un joystick c'est un peu complexe. Vu que le monstre est équipé de milliers de
boutons, dont des sticks analogiques qui peuvent d'incliner à différents degrés, etc.

Mais en gros, tout est là :

https://love2d.org/wiki/love.joystick

Note :

Il existe aussi plusieurs fonctions système (comme load / draw / keypressed…) :

● love.gamepadpressed
● love.gamepadreleased
● love.joystickpressed
● love.joystickreleased
● love.joystickadded
● love.joystickremoved

Je vous invite à en lire la doc si vous souhaitez les utiliser. Moi je me focalise dans mes
exemples sur du code exploitant directement le joystick connecté, en le lisant directement.

Détecter sa présence
C'est assez trivial. On demande la liste des joysticks… si il n'y en a pas au moins 1, alors
c'est qu'il n'y en a pas.

local​ joysticks = love.joystick.getJoysticks()

if​ #joysticks>​0​ ​then
​-- Joysticks détectés (au moins 1)
else
​-- Pas de Joysticks !
end

Facile !
Lire les valeurs des boutons

Déjà, avant de lire quoi que ce soit, il faut choper le joystick que vous voulez tester.

Disons, à tout hasard, que c'est le 1er joystick que vous voulez lire… (je blague, c'est
toujours le 1er qu'on teste hein…).

Ce qui est pratique pour alléger votre code (à mon goût) c'est de prendre référence du
joystick 1, 2… etc. dans une variable au nom court :

if​ #joysticks > ​0​ ​then

​local​ joy1 = joysticks[​1​]
… suite de votre code qui peut utiliser "joy1" au lieu de joysticks[1]

Ensuite, il faut comprendre la notion de Joystick / Gamepad, que j'ai eu du mal à

comprendre au départ.

Il s'agit soit :
- De traiter un joystick comme un appareil branché dont on ne connait pas la position
des boutons, des sticks, etc. Du coup, techniquement à vous de 'mapper' les
boutons, etc.
- Soit de traiter le joystick comme un "Gamepad" standard, genre un Pad XBOX 360,
et donc Love nous 'mappe' les boutons X, Y, B, A, etc. comme il faut de manière
standard.

Mon code source travaille sur un Gamepad pour diriger le personnage, mais pour référence
je montre dans le code comment lire les boutons de manière indépendante du mapping,
juste avec leur numéro :
 buttons = {}
​if​ #joysticks > ​0​ ​then
​local​ joy1 = joysticks[​1​]
​for​ b=​1​,joy1:getButtonCount() ​do
buttons[b] = joy1:isDown(b)
​end
​end

C'est bien plus simple pour un Gamepad. Voici un exemple avec les principales données
dont vous pourrez avoir besoin :

​if​ #joysticks > ​0​ ​then

​local​ joy1 = joysticks[​1​]
​-- Directions du D-Pad :
jRight = joy1:isGamepadDown(​"dpright"​)
jLeft = joy1:isGamepadDown(​"dpleft"​)
jUp = joy1:isGamepadDown(​"dpup"​)
jDown = joy1:isGamepadDown(​"dpdown"​)
​-- Directions du stick analogique
xAxis = joy1:getGamepadAxis(​"leftx"​)
yAxis = joy1:getGamepadAxis(​"lefty"​)
​-- Les boutons principaux
butA = joy:isGamepadDown(​"a"​)
butB = joy:isGamepadDown(​"b"​)
butX = joy:isGamepadDown(​"x"​)
butY = joy:isGamepadDown(​"y"​)
​end

Pour aller plus loin voir les autres valeurs pour les autres boutons du pad :
https://love2d.org/wiki/GamepadButton

Lire les valeurs du stick analogique

Regardez votre stick analogique.

Il peut être incliné verticalement (axe Y) et horizontalement (axe X).

Le truc le plus important à comprendre, c'est qu'un axe de stick analogique retourne une
valeur entre -1 et 1.

0 étant sensé être le milieu de l'axe.

1 c'est quand il est penché au maximum.

On peut donc incliner le stick à moitié et lire "0.5" (ou pas loin) sur son axe.

Clair ?

Dans le projet de démo je déplace le personnage en fonction du stick analogique, avec un

max de 40 pixels par seconde à vitesse maximale (donc axe incliné au max).

Mais comme l'axe n'est jamais totalement centré, je ne m'y intéresse que si il a une valeur
supérieure à 0.2 :

xAxis = joy1:getGamepadAxis(​"leftx"​)
yAxis = joy1:getGamepadAxis(​"lefty"​)

if​ m​ ath​.​abs​(xAxis) > ​0.2​ ​then

hero.x = hero.x + (xAxis*​40​)*dt
end
if​ ​math​.​abs​(yAxis) > ​0.2​ ​then
hero.y = hero.y + (yAxis*​40​)*dt
end