Bon, allez, je t'aide. Mais attention ! Je ne suis pas là pour travailler à ta place. Lis attentivement mes explications afin de bien comprendre les techniques et d'ainsi pouvoir les réutiliser dans d'autres circonstances.
Théoriquement, à la fin du tuto, tu devrais obtenir ceci pour les LogicBricks de Plane.001 :

Je vais commencer par t'expliquer du mieux que je peux ce que tu vois ci-dessus. Non que les explications de Granarc ne sont pas bien, mais qu'il est toujours plus aisé de comprendre quelque chose quand on nous l'explique de deux façons différentes.
Dans la première ligne, on a un sensor Always relié à un controller AND relié lui-même à un actuator Visibility que l'on peut schématiser comme ceci :
+--------+ +-----+ +------------------------+
| Always +-----+ AND +-----+ Visibility : Invisible |
+--------+ +-----+ +------------------------+
Commençons par les définitions :
1)Sensor : C'est une condition qui renvoie pour toute réponse Vrai (1) ou Faux (0).
2)Controller : C'est une logicbrick permettant l'interraction entre les sensors et les actuators. Il existe à ce jour (dans la version 2.48) 8 types de controllers (ce sont les fonctions logiques) :
- AND, 'et' (par défaut) : "Si tous les sensors qui lui sont reliés retournent Vrai, alors exécution des actuators qui lui sont reliés".
- OR, 'ou' : "Si un ou plusieurs sensors qui lui sont reliés retournent la valeur Vrai, alors exécution des actuators qui lui sont reliés".
- XOR, 'ou exclusif' : "Si et seulement si
un seul sensors qui lui sont reliés retournent la valeur Vrai, alors exécution des actuators qui lui sont reliés".
- NAND, 'non et' : "Si tous les sensors qui lui sont reliés retournent Vrai, alors
pas d'exécution des actuators qui lui sont reliés".
- NOR, 'non ou' : "Si un ou plusieurs sensors qui lui sont reliés retournent la valeur Vrai, alors
pas d'exécution des actuators qui lui sont reliés".
- XNOR, 'non ou exclusif' : "Si et seulement si
un seul sensors qui lui sont reliés retournent la valeur Vrai, alors
pas d'exécution des actuators qui lui sont reliés".
- Expression : Heu...je sais pas en fait...


peut être une expression régulière...nan en fait c'est complètement absurde, oublit...désolé, mais je l'utilise jamais moi, aussi !
- Python : permet d'utiliser un script Python pour gérer la réception des sensors et l'exécution des actuators.
3)Actuator : permet d'agir en modifiant le jeu en temps réel (déplacements, rotations, gestion de caméras, gestion des scènes, gestion du son, modification des variables (properties)...).Les actuators sont déclenchés par les controllers.
Dans l'onglet GameLogic, les sensors sont à gauche, les controllers au milieu et les actuators à droite.
Pour en revenir à notre première ligne : nous avions un sensor Always. Le sensor Always est le plus simple à comprendre : il retourne en permanace Vrai !
Ensuite, nous avions un controller AND, suivit d'un actuator Visibility. Cet actuator permet de définir si un objet est visible ou invisible. Ici, Plane.001 est invisible.
Notre première ligne signifie donc :
En permanance, Plane.001 est invisible
Nous avons à la ligne suivante :
+--------------------+ +-----+ +---------------------------------+
| Mouse : LeftButton +-----+ AND +--+--+ EditObject : AddObject Cube.001 |
+--------------------+ +-----+ | +---------------------------------+
|
| +----------------------------+
+--+ Property : Add Munitions 1 |
+----------------------------+
Le sensor Mouse : LeftButton retourne Vrai tant que le bouton gauche de la souris est enfoncé.
L'actuator Edit Object : AddObject crée un nouvel objet à partir de l'objet passé en paramètre (ici Cube.001).
L'actuator Property : Add ajoute à la variable passée en paramètre (ici Munitions) la valeur passée en paramètre (ici 1).
Avec tout ça, tu peux normalement trouver la signification de cette ligne.
Cherche un peu tout seul...
...
...
...
...
...
Cherche...
...
...
...
...
...
Encore un peu...
...
...
...
...
...
Bon voici la ligne de LogicBricks traduite en français (presque) correct :
Si le bouton gauche de la souris est enfoncé, ajouter un objet à l'image de Cube.001 et ajouter 1 à la valeur de Munitions
En gros, à chaque fois que tu appuies sur le bouton de ta souris, tu tires et Munition augment de 1.
Et la dernière partie :
+----------------------------------------------------+ +-----+ +-------------------------------+
| Property 'Recharge' entre 2 et 10000... (beaucoup) +--+--+ AND +--+--+ Property : Assign Recharge->0 |
+----------------------------------------------------+ | +-----+ | +-------------------------------+
| |
+-------------------------------+ | | +--------------------------------+
| Property 'Munitions' égal à 5 +-----------------------+ +--+ Property : Assign Munitions->0 |
+-------------------------------+ +--------------------------------+
Le sensor Property : Interval retourne Vrai lorsque la valeur de la variable passée en paramètre (ici Recharge) est dans l'interval définit par Min et Max.
Le sensor Property : Equal retourne Vrai lorsque la valeur de la variable passée en paramètre (ici Munitions) est égale à Value.
L'actuator Property : Assign donne à la variable passée en paramètre la valeur de Value.
Cette dernière ligne de LogicBricks signifie donc :
Si Recharge est entre 2 et beaucoup ET Munitions égal à 5, Recharge = 0 et Munitions = 0
C'est-à-dire, lorsque tu as tiré 5 fois et que 2 secondes sont passées depuis le dernier rechargement, alors le nombre de munitions tirées revient à 0 et le temps depuis le dernier rechargement également.
Maintenant que j'ai éclaircit le résultat du tutoriel, nous allons passé à l'étape suivante : modification à notre sauce pour obtenir notre propre jeu personnalisé.
Tu veux donc que l'on doive recharger manuellement en appuyant sur R toutes les quinze munitions tirées.
Nous allons commencer par le plus simple : augmenter le nombre de munitions. Il suffit pour cela d'augmenter la valeur du dernier sensor (Property 'Munitions' égal à 15) mais je crois que ça, tu l'avais déjà trouvé.
Ensuite, nous allons remplacer le déclenchement du rechargement par le temps par un déclenchement au clavier. Nous allons pour cela remplacer le sensor Property 'Recharge' entre 2 et beaucoup par un sensor de type keyboard. Clique sur la case à droite de key puis appuis sur R. Tu dois obtenir ceci :

Ainsi, quand tu appuyeras sur R, ce sensor retournera Vrai, tout comme lorsque le compteur était supérieur à 2.
Tu peux maintenant supprimer la remise à zéro du compteur (actuator Property : Assign 'Recharge'->0), ainsi que la variable Recharge.
Tu obtiens alors quelqe chose comme ça :

J'ai fait exprès de laisser un bug : on peut tirer plus de 15 coups sans recharger !
A toi de corriger l'erreur
Merci d'avoir pris la peine de lire mon super long message que j'ai mis super du temps (ouais ! c'est français) à écrire. (Sauf si t'as lu que la fin

)