The way I am guiding my rocket is by using thrust vectoring. Basically, an Arduino with a gyroscope and an accelerometer tell servo motors which way to angle the engine, and the rocket will move to the opposite of the engine’s thrust vector. Lets get this show started with some material lists!
This section should give you a basic idea about what you will need, more details will be explained in future steps
Its critical to save weight on a rocket, and the power distro. board will take power from a 11v lipo battery and distribute it to the servo motors and to the arduino/sensors. Using the diagram i posted, make a distro board.
The gyroscope has to be wired to the arduino in a specific way for it to work/be read. Since this is a fairly cheap module, no directions were provided and I had to figure it out myself. Using the pictures, make a cable for the gyroscope.
The thrust vectoring frame must be powerful enough to take the rocket motor’s thrust and not break. For this reason I went with a custom plasma cut aluminum frame, although if you pick a smaller engine, you could go with a wooden one.
The 2 inner rectangles are going to be used to house the servo motors, while the outer circle moves in the x axis and the inner circle moves in the y axis. The rocket engine will sit in the inner circle. I lost the laser cutting files for this piece so you might have to piece it together yourself
Important! Since the data is parsed as JSON all of the keys will need to be quoted for the plot to render. The use of a tool like JSONLint to check syntax is highly recommended.
The servo motors I am using are metal geared and shave a fairly fast movement time (critical to rockets). The servos are attached to rods, which connect to both the inner and outer circle. I had to epoxy the servo motors in because they kept coming loose.
The electronics bay will house the arduino and power board, along with the battery, and will keep these items safe from the rocket’s thrust. You have to be creative here and I made mine so I could slide a tube over it for launch
The code here will let the rocket fly straight up without fins using artificial stabilization, great for the first test flight!
#include "Wire.h" // allows communication to i2c devices connected to arduino
#include "I2Cdev.h" // I2Connection library (communication to serial port)
#include "MPU6050.h" // IMU library
#include "Servo.h" // servo control library
MPU6050 mpu; //defines the chip as a MPU so it can be called in the future
int16_t ax, ay, az; // x y z orientation values from accelerometer
int16_t gx, gy, gz; // x y z orientation values from gyrscope
///////////////////////////////////////////////////////////////////////////////////////
Servo outer;
Servo inner;
///////////////////////////////////////////////////////////////////////////////////////
int valo; // outer val
int prevValo; // outer prev val
///////////////////////////////////////////////////////////////////////////////////////
int vali; //inner val
int prevVali; //outer prev val
///////////////////////////////////////////////////////////////////////////////////////
//initializes the IMU
void setup()
{
Wire.begin();
Serial.begin(38400);
Serial.println("Initialize MPU");
mpu.initialize();
Serial.println(mpu.testConnection() ? "Connected" : "Connection failed");
outer.attach(9); //servo on pin 9 for large ring y
inner.attach(10);//servo on pin 10 for small ring x
}
///////////////////////////////////////////////////////////////////////////////////////
void loop()
{
mpu.getMotion6(&ax, &ay, &az, &gx, &gy, &gz);
valo = map(ax, -17000, 17000, 179, 0);
if (valo != prevValo)
{
outer.write(valo);
prevValo = valo;
}
vali = map(ay, -17000, 17000, 179, 0);
if (vali != prevVali)
{
inner.write(vali);
prevVali = vali;
}
}
///////////////////////////////////////////////////////////////////////////////////////
Important! Since the data is parsed as JSON all of the keys will need to be quoted for the plot to render. The use of a tool like JSONLint to check syntax is highly recommended.
]]>Slime Soccer est un jeu arcade rétro qui combine des mécaniques de physique réalistes avec une jouabilité simple mais profonde. Deux joueurs contrôlent des créatures gélatineuses (slimes) dans le but de marquer des buts en propulsant une balle dans les filets adverses. Le jeu propose plusieurs modes de jeu chronométrés et une interface intuitive.
Le jeu propose cinq durées de match différentes pour adapter le temps de jeu à vos préférences :
| Mode | Durée | Utilisation |
|---|---|---|
| 1 Minute | 60 secondes | Matchs rapides et intenses |
| 2 Minutes | 120 secondes | Jeu équilibré et accessible |
| 4 Minutes | 240 secondes | Matchs standard |
| 8 Minutes | 480 secondes | Parties longues et stratégiques |
| World Cup | 300 secondes | Mode spécial (5 minutes) |
Joueur de gauche (Slime cyan) ——
| Action | Touche |
|---|---|
| Déplacement gauche | A |
| Déplacement droit | D |
| Saut | W |
| Action | Touche |
|---|---|
| Déplacement gauche | ← |
| Déplacement droit | → |
| Saut | ↑ |
Le projet est construit autour d’un composant React monolithique (SlimeSoccer) qui gère l’ensemble de la logique du jeu. Voici les principaux éléments :
gameStateRef.current = {
leftSlime: { x, y, vx, vy, color },
rightSlime: { x, y, vx, vy, color },
ball: { x, y, vx, vy }
}
| Constante | Valeur | Description |
|---|---|---|
GRAVITY |
0.6 | Accélération gravitationnelle appliquée aux objets |
SLIME_SPEED |
5 | Vitesse de déplacement horizontal des slimes |
SLIME_JUMP_POWER |
-12 | Force initiale du saut (valeur négative = vers le haut) |
BALL_DAMPING |
0.99 | Amortissement de l’air (ralentissement progressif) |
BALL_BOUNCE_DAMPING |
0.8 | Perte d’énergie lors des rebonds |
La boucle de jeu utilise requestAnimationFrame pour assurer une animation fluide à 60 FPS. Elle exécute deux étapes principales à chaque frame :
updatePhysics) : Traite les entrées clavier, met à jour les positions et vérifie les collisionsdraw) : Dessine tous les éléments du jeu sur le canvasLe jeu implémente plusieurs types de collisions :
Le jeu utilise l’API Canvas 2D pour le rendu. Les éléments visuels incluent :
# Cloner le dépôt
git clone <repository-url>
cd slime-soccer-game
# Installer les dépendances
npm install
# ou
pnpm install
# Mode développement
npm run dev
# ou
pnpm dev
Le jeu sera accessible à http://localhost:3000 dans votre navigateur.
# Créer une version optimisée
npm run build
# ou
pnpm build
# Prévisualiser la version de production
npm run preview
# ou
pnpm preview
Les slimes sont contrôlés par le joueur via les touches directionnelles. Leur mouvement est limité à l’axe horizontal, tandis que la gravité affecte leur position verticale. Chaque slime peut sauter une seule fois tant qu’elle est en contact avec le sol.
La balle suit une physique réaliste avec les caractéristiques suivantes :
La détection de collision slime-balle utilise une approche basée sur la distance. Si la distance entre le centre de la balle et le centre du slime est inférieure à la somme de leurs rayons, une collision est détectée. La réponse à la collision repositionne la balle et recalcule sa vélocité en fonction de l’angle de collision.
Vérifiez que vous avez installé toutes les dépendances avec npm install ou pnpm install. Assurez-vous également que vous utilisez une version compatible de Node.js (18+).
Assurez-vous que la fenêtre du navigateur a le focus. Cliquez sur le canvas du jeu avant de commencer à jouer pour vous assurer que les événements clavier sont correctement capturés.
Vérifiez que votre navigateur n’exécute pas d’autres applications gourmandes en ressources. Fermez les onglets inutiles et essayez de relancer le jeu. Si le problème persiste, mettez à jour votre navigateur vers la dernière version.
Les contributions sont bienvenues ! Si vous souhaitez améliorer le jeu, veuillez :
git checkout -b feature/ma-fonctionnalite)git commit -m 'Ajouter ma fonctionnalité')git push origin feature/ma-fonctionnalite)Pour toute question, bug ou suggestion, veuillez ouvrir une issue sur le dépôt GitHub du projet.
Dernière mise à jour : Janvier 2026
Version : 1.0.0
]]>