Module · Détail

Space Invaders : Défense contre la formation

Ce module conduit d'un petit module de jeu marchable à un projet structuré Space-Invaders. L'accent est mis sur la construction progressive du contrôle, des données ennemies, de la logique d'impact, du score, du système de vie, de la structure des vagues et du redémarrage.

Temps 90 minutes
Format Codage IA
Technologie frameCraft
Test en ligne Demo
Image prévisualisation : Space Invaders : Défense contre la formation

BuildFromZero avec KI-Coding

Développement structuré du code à partir d'une base minimale

Ce module utilise le KI-Coding comme support contextuel pour la poursuite du développement d'un projet existant. Le point de départ n'est pas un jeu terminé, mais un module minimal et marchable avec vaisseau spatial, marquage de formation, affichage des états et entrées préparées.

Les tâches mènent étape par étape des améliorations visuelles au contrôle et aux valeurs de scène, puis à la logique de tir, aux formations ennemies, aux collisions, aux points, aux vies, aux vagues et au redémarrage. Cela rend le processus de programmation visible comme une séquence compréhensible de petits changements testables et professionnelsment classés.

Cette structure permet un travail transparent avec les modifications générées par l'IA dans l'enseignement : les prompts, ajustements de code et versions restent liés à des sous-objectifs concrets. L'accent est mis sur le développement de code compréhensible, des extensions ciblées et des résultats intermédiaires directement vérifiables.

Classification pédagogique

Le module est intégré de manière compacte dans la matière et la pratique pédagogique.

Fixation d'objectifs subjectifs

Au centre se trouve la construction d'un simple jeu 2D à partir de composants de code clairement séparés : scène, figures, entrées, règles et états. L'accomplissement professionnel consiste à ne pas prendre en charge les mécaniques de jeu comme un produit complet, mais à les modéliser et les implémenter étape par étape via des structures de données, des valeurs d'état et des règles récurrentes.

Développement de compétences

  • Structuration : Le code du projet est divisé en fonctions de construction, fonctions auxiliaires, valeurs de scène et règles de jeu.
  • Modélisation : Les ennemis, les tirs, les points, les vies et les vagues sont représentés comme des données et des états.
  • Pensée algorithmique : Le mouvement, la vérification des limites, les collisions et les changements d'état sont implémentés sous forme de processus basés sur des règles.
  • Débogage et itération : Chaque extension reste suffisamment petite pour être immédiatement vérifiée et corrigée ciblément.

Valeur ajoutée par l'enseignant

  • Le module offre une progression claire de l'orientation visuelle à des états complets du jeu.
  • La décomposition en étapes de travail plus petites facilite la garantie des résultats et la réflexion intermédiaire.
  • Les extensions telles que la vitesse, les vagues ou le redémarrage permettent une différenciation au sein du même contexte projet.

Flux de l'unité de leçon

Les tâches sont présentées dans l'ordre du JSON et condensées sur le plan du contenu.

1

Rendre le champ de jeu plus lisible

La scène de départ est complétée par une ligne de défense visible au bas du champ de jeu. Cela donne à la zone de jeu un repère spatial clair sans modifier pour l'instant les règles du jeu.

2

Améliorer l'engin spatial en tant que figure du joueur

La figure existante défenseur est rendue visuellement plus distinctive. Le changement reste limité à la représentation, ce qui sépare consciemment la conception de la logique et du contrôle du jeu.

3

Préparer le déplacement gauche-droite

Les entrées préparées sont connectées pour la première fois à un mouvement horizontal réel. En outre, la position est limitée afin que l'engin spatial reste dans la fenêtre.

4

Vitesse de déplacement comme valeur de scène

Le nombre fixe de déplacement est remplacé par une valeur de scène. Cela rend visible comment les paramètres du jeu peuvent être libérés de la logique et ajustés plus facilement ultérieurement.

5

Convertir la règle de construction en règle de jeu

La règle précédente d'état est nettoyée afin qu'elle ne surmonte plus permanentement les messages. Le déplacement existant reste et la règle est stabilisée comme point d'ancrage pour une logique de jeu ultérieure.

6

Préparer la figure de tir

Une seule figure de tir est placée et initialement positionnée en dehors de la fenêtre visible. Cela crée la structure pour le tir ultérieur sans construire encore de logique d'activation ou de vol.

7

Démarrage du tir non déclenché

Un marqueur indique si le bouton de tir a déjà été pressé. Cela permet qu'une seule action soit déclenchée lors d'un appui sur la touche, et non répétée à chaque cadre.

8

Déclencher le tir

Le tir préparé commence à l'action de tir reconnue nouvellement, au positionnement du vaisseau spatial. Il continue d'utiliser un seul personnage de tir, ce qui permet de contrôler clairement les ressources et l'état.

9

Déplacer le tir vers le haut

Un tir actif se déplace vers le haut et est réinitialisé lorsqu'il quitte le champ de jeu. Cela implémente une simple vie cyclique d'un objet du jeu.

10

Planifier les données ennemies sous forme de liste

La formation ennemie est initialement préparée comme une liste de noms et positions. Aucun personnage ennemi n'est encore créé, ce qui maintient clairement la séparation entre le modèle de données et la présentation.

11

Afficher la formation ennemie

Les personnages ennemis visibles sont générés à partir des données initiales préparées. Les noms, positions et tags sont adoptés de manière cohérente afin que les règles ultérieures puissent accéder à la formation.

12

Définir l'état actif des ennemis

Une liste séparée suit les ennemis actuellement actifs, les distinguant de tous les personnages créés.

13

Compléter la structure d'impact

Une réaction de collision entre un tir et un ennemi est ajoutée. Un impact valide retire l’ennemi de la liste active, le déplace hors champ de vision, et réinitialise le tir.

14

Ajouter des points

Le score augmente exactement d’un point avec un impact valide. Le calcul reste séparé de l’affichage pour maintenir la séparation entre les modifications de données et leur présentation.

15

Afficher le score dans le HUD

Le score devient visible via un élément UI et est lié à la valeur de scène, établissant le lien entre l'état interne et le retour visuel sur l'écran.

16

Déplacer les ennemis lentement

Les ennemis actifs se déplacent lentement horizontalement. Le mouvement utilise ses propres valeurs de scène pour la direction et la vitesse, et reste limité aux ennemis actuellement présents.

17

Changement d'extrémité pour la formation

Lorsque la formation atteint l'extrémité du champ de jeu, elle change de direction et descend. La vérification est effectuée afin que le changement de direction ne soit pas déclenché plusieurs fois au sein même d'un même cadre.

18

Réinitialiser la formation en toute sécurité

Une fonction d'assistance réinitialise tous les ennemis à leurs positions initiales et restaure la liste des ennemis actifs. La fonction ne crée pas de nouvelles figures et soutient logique future pour les vagues et les redémarrages.

19

Introduire les vies et le danger

Si les ennemis actifs s'approchent trop profondément, une vie est déduite et la formation est réinitialisée. L'état de tir est également nettoyé afin que chaque situation dangereuse puisse être traitée clairement.

20

Afficher les vies dans le HUD

Les vies restantes sont visibles comme une valeur distincte du HUD. L'affichage est placé séparément du titre et du score, afin que différentes informations de jeu demeurent distinguables.

21

Commencer une nouvelle vague

Lorsque tous les ennemis sont vaincus, la vague est augmentée et la formation est préparée à nouveau en utilisant la fonction de réinitialisation. Les points et les vies restent inchangés, créant une progression continue du jeu.

22

Fin du jeu sans redémarrage

Lorsque les vies sont épuisées, un état « Game Over » est défini. Les éléments de gameplay normaux tels que le déplacement, le tir, le mouvement des ennemis et la création de nouvelles vagues ne sont plus continus dans cet état.

23

Redémarrer avec bouton et toucher

Après Game Over, une action de redémarrage non bloquée est ajoutée. Les points, vies, vague, position du joueur, tir et formation sont réinitialisés de manière cohérente à un état initial.

Extrait de code

L'extrait montre la séparation des valeurs de scène, des helpers d'accès et des règles récurrentes comme noyau structurel du module.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

class Zugriff:
    @staticmethod
    def figur(ctx, name):
        return ctx.E(name)
    @staticmethod
    def wert(ctx, name, standard=None):
        return ctx.vars.get(name, standard)
    @staticmethod
    def aktion_aktiv(ctx, name):
        return ctx.down(name)
SZENE('hauptszene', punkte=0, leben=3,
      status='Baustelle: prêt à s'étendre',
      gegner_namen=[], schuss_aktiv=False, welle=1)
def baustellen_regel(ctx):
    spieler = Zugriff.figur(ctx, 'verteidiger')
    if spieler is None:
        return
    if Zugriff.aktion_aktiv(ctx, 'links') or Zugriff.aktion_aktiv(ctx, 'rechts'):
        ctx.vars['status'] = 'Entrée détectée : le déplacement s'étend.'
Ce module relie la modélisation du jeu à son implémentation étape par étape et rend les états, règles et feedbacks traçables.

La séquence claire des tâches soutient l'organisation des leçons, la sécurité intermédiaire et le développement d'un parcours de jeu complet à partir de petites modifications de code. Les extensions telles que le rythme, les vagues ou le redémarrage permettent une adaptation flexible aux différents niveaux d'apprentissage.

Demandez un accès démo et testez le module dans votre propre contexte de cours.

Inscrivez-vous maintenant et testez-le gratuitement