1. परिचय
आपको क्या बनाना होगा
Flame, Flutter पर आधारित 2D गेम इंजन है. इस कोडलैब में, आपको 70 के दशक के क्लासिक वीडियो गेम में से एक, स्टीव वोज़नियाक के Breakout से प्रेरित एक गेम बनाने का तरीका बताया जाएगा. Google Antigravity का इस्तेमाल करके, एजेंट को सिलसिलेवार तरीके से निर्देश दिए जाएंगे. इससे बैट, बॉल, और ब्रिक के लिए Flame Components बनाए जाएंगे. साथ ही, Flame Effects की मदद से बैट के मूवमेंट को ऐनिमेट किया जाएगा और Flame को Flutter के स्टेट मैनेजमेंट सिस्टम के साथ इंटिग्रेट किया जाएगा.
गेम पूरा होने के बाद, वह इस ऐनिमेटेड GIF की तरह दिखना चाहिए. हालांकि, इसकी स्पीड थोड़ी कम होनी चाहिए:

आपका गेम इन ज़रूरी शर्तों को पूरा करता हो:
- यह Flutter के साथ काम करने वाले सभी छह प्लैटफ़ॉर्म पर काम करता है: Android, iOS, Linux, macOS, Windows, और वेब.
- Flame के गेम लूप का इस्तेमाल करके, कम से कम 60 एफ़पीएस बनाए रखता है.
- यह 70 और 80 के दशक के आर्केड गेमिंग का अनुभव देने के लिए,
google_fontsऔरflutter_animateजैसे Flutter पैकेज का इस्तेमाल करता है.
सीखने का आपका सफ़र
इस कोडलैब में, आपको सिलसिलेवार तरीके से गेम बनाने के बारे में बताया गया है:
- अपना Flutter एनवायरमेंट सेट अप करना - अपने टारगेट प्लैटफ़ॉर्म के लिए, Flutter और Google Antigravity को कॉन्फ़िगर करें.
- प्रोजेक्ट बनाना - Antigravity को Flame,
flutter_animate,google_fonts, औरmaterial_uiके साथ एक खाली Flutter प्रोजेक्ट बनाने के लिए कहें. - गेम बनाएं - फ़िक्स्ड रिज़ॉल्यूशन वाले कैमरे को कॉन्फ़िगर करें और गेम वर्ल्ड में
PlayAreaकॉम्पोनेंट जोड़ें. - गेंद को डिसप्ले करना - Flame के गेम लूप और वेलोसिटी वेक्टर की मदद से, मूव करने वाला
Ballकॉम्पोनेंट जोड़ें. - बाउंस अराउंड - टक्कर का पता लगाने की सुविधा और हिटबॉक्स चालू करें, ताकि बॉल दीवारों से टकराकर बाउंस हो.
- बल्ले से गेंद को मारें - प्लेयर के कंट्रोल वाला
Batजोड़ें, जोMoveToEffectके साथ ड्रैग और कीबोर्ड इनपुट की सुविधा देता हो. - Break down the wall -
Brickकॉम्पोनेंट का ग्रिड जनरेट करें. साथ ही, ईंटें टूटने पर गेंद की स्पीड बढ़ाएं. - गेम जीतना - गेम की स्थितियों को मैनेज करें और
GameWidget.controlledकी मदद से, रेट्रो Flutter विजेट ओवरले दिखाएं. - स्कोर सेव करना -
ValueNotifierका इस्तेमाल करके, खिलाड़ी के स्कोर को Flutter यूज़र इंटरफ़ेस (यूआई) के साथ सिंक करें. साथ ही,flutter_animateका इस्तेमाल करके ओवरले को ऐनिमेट करें.
आपको क्या सीखने को मिलेगा
- Flame गेम को बार-बार बनाने और उसे पसंद के मुताबिक बनाने के लिए, Google Antigravity के साथ मिलकर काम करने का तरीका.
- Flame की बुनियादी सुविधाओं के काम करने का तरीका,
GameWidgetसे शुरू होता है. - फ़्रेम-रेट से अलग मूवमेंट के लिए, गेम लूप का इस्तेमाल करने का तरीका.
- Flame के
Componentकैसे काम करते हैं (Flutter केWidgetकी तरह). - हिटबॉक्स का इस्तेमाल करके, टकराव का पता लगाने और उसका जवाब देने का तरीका.
Componentको ऐनिमेट करने और हटाने के लिए,Effectका इस्तेमाल करने का तरीका.- Flame गेम के ऊपर Flutter
Widgetको ओवरले करने का तरीका. - Flame को Flutter के स्टेट मैनेजमेंट के साथ इंटिग्रेट करने का तरीका.
ज़रूरी शर्तें
- Flutter और Dart सिंटैक्स के बारे में बुनियादी जानकारी.
2. अपना Flutter एनवायरमेंट सेट अप करना
संपादक
इस कोडलैब में, Google Antigravity का इस्तेमाल एआई-फ़र्स्ट डेवलपमेंट एनवायरमेंट के तौर पर किया जाता है. हर चरण में, Antigravity को अपने गेम के कॉम्पोनेंट जनरेट करने या उन्हें बेहतर बनाने के लिए प्रॉम्प्ट दें. साथ ही, जनरेट किए गए कोड में Flame के मुख्य कॉन्सेप्ट की समीक्षा करें. इसके अलावा, आपके पास किसी खास दौर से प्रेरित आर्केड गेम के वैरिएंट एक्सप्लोर करने का विकल्प भी है.
डेवलपमेंट टारगेट चुनना
Flutter, कई प्लैटफ़ॉर्म के लिए ऐप्लिकेशन बनाता है. आपका ऐप्लिकेशन इनमें से किसी भी ऑपरेटिंग सिस्टम पर काम कर सकता है:
- iOS
- Android
- Windows
- macOS
- Linux
- वेब
डेवलपमेंट टारगेट के तौर पर, एक ऑपरेटिंग सिस्टम चुनना आम बात है. यह वह ऑपरेटिंग सिस्टम है जिस पर डेवलपमेंट के दौरान आपका ऐप्लिकेशन चलता है.

उदाहरण के लिए, मान लें कि Flutter ऐप्लिकेशन बनाने के लिए, Windows लैपटॉप का इस्तेमाल किया जा रहा है. अगर आपने डेवलपमेंट के लिए Android को टारगेट के तौर पर चुना है, तो यूएसबी केबल की मदद से Windows लैपटॉप से Android डिवाइस को अटैच करें. इसके बाद, डेवलप किया जा रहा ऐप्लिकेशन, अटैच किए गए Android डिवाइस या Android Emulator पर चलेगा. इसके अलावा, Windows को डेवलपमेंट टारगेट के तौर पर चुना जा सकता है. इससे, डेवलप किया जा रहा ऐप्लिकेशन, आपके एडिटर के साथ-साथ डेस्कटॉप Windows ऐप्लिकेशन के तौर पर चलता है.
जारी रखने से पहले, अपनी पसंद का विकल्प चुनें. आपके पास अपने ऐप्लिकेशन को बाद में, अन्य ऑपरेटिंग सिस्टम पर चलाने का विकल्प हमेशा होता है. डेवलपमेंट टारगेट चुनने से, अगला चरण आसान हो जाता है.
Flutter इंस्टॉल करना
Flutter SDK टूल को इंस्टॉल करने के बारे में अप-टू-डेट निर्देश, हमेशा docs.flutter.dev पर उपलब्ध होते हैं.
Flutter की वेबसाइट पर दिए गए निर्देशों में, एसडीके टूल, प्लैटफ़ॉर्म के हिसाब से टूल, और एडिटर प्लगिन इंस्टॉल करने के बारे में बताया गया है. इस कोडलैब के लिए, यह सॉफ़्टवेयर इंस्टॉल करें:
- Flutter SDK
- Google Antigravity में Dart और Flutter का आधिकारिक प्लगइन चालू होना चाहिए. यह प्लगइन, प्लगइन Marketplace में Build with Google सेक्शन में उपलब्ध है.
- आपके चुने गए डेवलपमेंट टारगेट के लिए कंपाइलर सॉफ़्टवेयर. उदाहरण के लिए, Windows को टारगेट करने के लिए Visual Studio या macOS या iOS को टारगेट करने के लिए Xcode.
अगले चरण में, Antigravity को Flutter प्रोजेक्ट बनाने और शुरुआती Flame गेम को स्कैफ़ोल्ड करने के लिए प्रॉम्प्ट दें.
समस्या का हल
अगर आपको सेटअप करने में समस्याएं आती हैं, तो Stack Overflow पर मौजूद इन सवालों और जवाबों से आपको मदद मिल सकती है:
- मुझे Flutter SDK टूल का पाथ कैसे मिलेगा?
- अगर Flutter कमांड नहीं मिलता है, तो मुझे क्या करना चाहिए?
- मैं "स्टार्टअप लॉक को रिलीज़ करने के लिए, किसी अन्य Flutter कमांड का इंतज़ार किया जा रहा है" समस्या को कैसे ठीक करूं?
- मैं Flutter को कैसे बताऊं कि मेरा Android SDK कहां इंस्टॉल है?
flutter doctor --android-licensesको चलाते समय, Java से जुड़ी गड़बड़ी को कैसे ठीक किया जा सकता है?- Android
sdkmanagerटूल न मिलने की समस्या को कैसे हल करूं? - मैं "
cmdline-toolsकॉम्पोनेंट मौजूद नहीं है" गड़बड़ी को कैसे ठीक करूं? - मैं Apple Silicon (M1) पर CocoaPods कैसे चलाऊं?
3. प्रोजेक्ट बनाना
प्रोजेक्ट बनाने के लिए, Antigravity को प्रॉम्प्ट दें
- Google Antigravity लॉन्च करें और वह खाली डायरेक्ट्री खोलें जहां आपको अपना गेम बनाना है. ऐसा पाथ चुनें जिसके लिए खास सुविधाओं के ऐक्सेस की ज़रूरत न हो या जिसमें स्पेस न हों. जैसे, आपकी होम डायरेक्ट्री या
C:\src\में मौजूद कोई फ़ोल्डर. - Antigravity एजेंट के चैट पैनल में, Flutter प्रोजेक्ट बनाने, डिपेंडेंसी जोड़ने, और एक बुनियादी Flame गेम बनाने के लिए, यह प्रॉम्प्ट भेजें:
Create a new empty Flutter project named `brick_breaker` for a Breakout-style 2D arcade game. Add the `flame`, `flutter_animate`, `google_fonts`, and `material_ui` packages, and update `lib/main.dart` (importing `package:flame/game.dart` and `package:material_ui/material_ui.dart`) to run a basic `FlameGame` inside a `GameWidget`.
जनरेट किए गए कोड को समझना
Antigravity, प्रोजेक्ट को स्कैफ़ोल्ड करने के लिए flutter create --empty को चलाता है. साथ ही, flame, flutter_animate, google_fonts, और material_ui को pubspec.yaml में जोड़ता है. इसके अलावा, Flutter के GameWidget में FlameGame इंस्टेंस को होस्ट करने के लिए, lib/main.dart को अपडेट करता है:
void main() {
final game = FlameGame();
runApp(GameWidget(game: game));
}
गेम को चलाएं और टेस्ट करें
ऐप्लिकेशन को अपने चुने गए डेवलपमेंट टारगेट पर चलाएं, ताकि यह पुष्टि की जा सके कि सब कुछ सही तरीके से काम कर रहा है. इससे एक नई विंडो खुलती है, जिसका बैकग्राउंड खाली और काले रंग का होता है. दुनिया का सबसे आसान वीडियो गेम, अब 60 एफ़पीएस पर रेंडर हो रहा है!

4. गेम जनरेट करें
गेम का साइज़ देखना
दो डाइमेंशन (2D) में खेले जाने वाले गेम के लिए, एक प्ले एरिया की ज़रूरत होती है. इस चरण में, आपको तय डाइमेंशन के हिसाब से गेम खेलने की जगह बनानी होगी. साथ ही, उन डाइमेंशन का इस्तेमाल करके गेम के बाकी कॉम्पोनेंट का साइज़ तय करना होगा.
खेलने की जगह पर निर्देशांकों को सेट करने के कई तरीके हैं. एक तरीके के मुताबिक, स्क्रीन के बीच से दिशा को मेज़र किया जाता है. इसमें ऑरिजिन (0,0) बीच में होता है. इसमें पॉज़िटिव वैल्यू, आइटम को x ऐक्सिस पर दाईं ओर और y ऐक्सिस पर ऊपर की ओर ले जाती हैं. यह स्टैंडर्ड, मॉडर्न 3D गेम इंजन में आम तौर पर इस्तेमाल किया जाता है.
जब ओरिजनल Breakout गेम बनाया गया था, तब ऑरिजिन को सबसे ऊपर बाएं कोने में रखने का नियम था. पॉज़िटिव x दिशा दाईं ओर और पॉज़िटिव y दिशा नीचे की ओर इशारा करती है. उस दौर की यादें ताज़ा करने के लिए, इस गेम में ओरिजिन को सबसे ऊपर बाएं कोने में सेट किया गया है.
Antigravity को गेम और PlayArea बनाने के लिए प्रॉम्प्ट देना
गेम की दुनिया और खेलने की जगह के लिए फ़िक्स्ड रिज़ॉल्यूशन सेट अप करने के लिए, Antigravity में यह प्रॉम्प्ट भेजें:
Create a `BrickBreaker` subclass of `FlameGame` in `lib/src/brick_breaker.dart` with a fixed-resolution camera (820x1600, defined in `lib/src/config.dart`) anchored at the top-left corner. Add a `PlayArea` rectangle component (`lib/src/components/play_area.dart`, re-exported in `lib/src/components/components.dart`) that fills the game's width and height with a warm arcade background color (`0xfff2e8cf`), and wire `BrickBreaker` up in `lib/main.dart`.
जनरेट किए गए कोड को समझना
PlayArea और फ़्लेम Component
Flutter में Widget होते हैं, जबकि Flame में Component होते हैं. Flutter ऐप्लिकेशन में विजेट के ट्री होते हैं, जबकि Flame गेम में कॉम्पोनेंट के ट्री होते हैं.
Flutter का विजेट ट्री, एक ऐसा ब्यौरा है जिसमें बदलाव नहीं किया जा सकता. इसका इस्तेमाल, RenderObject लेयर को अपडेट करने के लिए किया जाता है. इस लेयर में बदलाव किया जा सकता है और यह हमेशा मौजूद रहती है. Flame के कॉम्पोनेंट स्थायी और बदलने लायक होते हैं. इन्हें lib/src/components/play_area.dart में सिम्युलेशन सिस्टम के हिस्से के तौर पर सीधे इस्तेमाल करने के लिए डिज़ाइन किया गया है:
class PlayArea extends RectangleComponent with HasGameReference<BrickBreaker> {
PlayArea() : super(paint: Paint()..color = const Color(0xfff2e8cf));
@override
FutureOr<void> onLoad() async {
super.onLoad();
size = Vector2(game.width, game.height);
}
}
ज़्यादा कॉम्पोनेंट जोड़ने पर, इंपोर्ट की गई फ़ाइलों की संख्या बढ़ जाती है. इसे कंट्रोल करने के लिए, lib/src/components/components.dart, export डायरेक्टिव का इस्तेमाल करता है. इससे हर कॉम्पोनेंट को एक ही बैरल फ़ाइल से फिर से एक्सपोर्ट किया जाता है.
फ़िक्स्ड-रिज़ॉल्यूशन कैमरा और world
lib/src/brick_breaker.dart में, BrickBreaker गेम को 820x1600 रिज़ॉल्यूशन का इस्तेमाल करने के लिए कॉन्फ़िगर करता है:
class BrickBreaker extends FlameGame {
BrickBreaker()
: super(
camera: CameraComponent.withFixedResolution(
width: gameWidth,
height: gameHeight,
),
);
@override
FutureOr<void> onLoad() async {
super.onLoad();
camera.viewfinder.anchor = Anchor.topLeft;
world.add(PlayArea());
}
}
गेम का साइज़, विंडो के साइज़ के हिसाब से बदल जाता है. साथ ही, ज़रूरत के हिसाब से लेटरबॉक्सिंग को जोड़ता है.
onLoad में, कोड दो मुख्य कार्रवाइयां करता है:
- यह नीति, सबसे ऊपर बाएं कोने को
viewfinderके लिए ऐंकर के तौर पर कॉन्फ़िगर करती है. डिफ़ॉल्ट रूप से, यह इलाके के बीच में(0,0)के तौर पर सेट होता है. - यह
PlayAreaकोworldमें जोड़ता है. यहCameraComponentके व्यू ट्रांसफ़ॉर्मेशन की मदद से, अपने सभी चाइल्ड ऑब्जेक्ट को प्रोजेक्ट करता है.
गेम को चलाएं और टेस्ट करें
बदलावों को देखने के लिए, हॉट रीस्टार्ट (या फ़ुल रीस्टार्ट) करें.

अगले चरण में, आपको दुनिया में एक गेंद जोड़नी होगी और उसे मूव करना होगा!
5. बॉल दिखाएं
Antigravity को Ball कॉम्पोनेंट जोड़ने के लिए कहें
स्क्रीन पर मूव करने वाली बॉल दिखाने के लिए, Ball कॉम्पोनेंट को तय करना और उसे गेम वर्ल्ड में जोड़ना ज़रूरी है. Antigravity में यह प्रॉम्प्ट भेजें:
Add a `Ball` circle component (`lib/src/components/ball.dart`) with a radius of 2% of the game width and a velocity vector that updates the ball's position each frame (`position += velocity * dt`). Spawn the ball at the center of the play area in `BrickBreaker.onLoad()` moving downward in a randomized direction at a consistent speed (scaled to a quarter of the game height), and enable `debugMode = true` so we can see component bounds.
जनरेट किए गए कोड को समझना
कॉन्फ़िगरेशन के लिए तय किए गए कॉन्सटेंट
lib/src/config.dart में ballRadius = gameWidth * 0.02 को डिराइव्ड कॉन्स्टेंट के तौर पर तय करने से, टॉप-लेवल gameWidth और gameHeight में बदलाव किया जा सकता है. इससे यह पता चलता है कि गेम के लुक और स्टाइल में क्या बदलाव हुआ है.
Ball में फ़्रेम-रेट से अलग मोशन
CircleComponent, RectangleComponent की तरह ही PositionComponent से लिया गया है. इसलिए, lib/src/components/ball.dart में हर फ़्रेम पर इसके position को अपडेट किया जा सकता है:
final Vector2 velocity;
@override
void update(double dt) {
super.update(dt);
position += velocity * dt;
}
वेग एक Vector2 ऑब्जेक्ट है, क्योंकि वेग में गति और दिशा, दोनों होती हैं. Flame हर फ़्रेम में update को कॉल करता है और dt (पिछले फ़्रेम के बाद से सेकंड में डेल्टा टाइम) को पास करता है. velocity * dt से गुणा करने पर, सिम्युलेशन की स्पीड अलग-अलग डिसप्ले रीफ़्रेश रेट (जैसे, 60 हर्ट्ज़ बनाम 120 हर्ट्ज़) पर एक जैसी रहती है.
शुरुआती वेलोसिटी को सामान्य करना
lib/src/brick_breaker.dart में, गेंद बीच (size / 2) से शुरू होती है और नीचे की ओर रैंडम वेलोसिटी के साथ गिरती है:
world.add(
Ball(
radius: ballRadius,
position: size / 2,
velocity: Vector2(
(rand.nextDouble() - 0.5) * width,
height * 0.2,
).normalized()..scale(height / 4),
),
);
normalized() को कॉल करने पर, एक यूनिट वेक्टर (लंबाई 1) जनरेट होता है, जो उसी रैंडम दिशा में पॉइंट करता है. साथ ही, ..scale(height / 4) इसे स्केल करता है, ताकि बॉल हमेशा एक ही स्पीड से शुरू हो, चाहे उसका ऐंगल कुछ भी हो.
गेम को चलाएं और टेस्ट करें
गेम को हॉट रीस्टार्ट करें. debugMode = true चालू होने पर, Flame कॉम्पोनेंट ट्री पर बैंगनी रंग के बाउंडिंग बॉक्स और निर्देशांक दिखाता है:

अगर गेम को कुछ बार रीस्टार्ट किया जाए, तो आपको दिखेगा कि गेंद, गेम खेलने की जगह के किनारों से होकर गुज़रती है. इसे ठीक करने के लिए, अगले चरण में कोलिज़न डिटेक्शन की सुविधा जोड़ें.
6. बाउंस अराउंड
Antigravity को टक्कर का पता लगाने की सुविधा जोड़ने के लिए कहें
टक्कर का पता लगाने की सुविधा से, आपके गेम को यह पता चलता है कि दो कॉम्पोनेंट कब एक-दूसरे के संपर्क में आते हैं. Antigravity में यह प्रॉम्प्ट भेजें:
Enable collision detection on `BrickBreaker` and add hitboxes to `PlayArea` and `Ball`. In `Ball.onCollisionStart`, bounce the ball off the top, left, and right walls of `PlayArea` by reversing the appropriate velocity axis, and remove the ball when it hits the bottom edge.
जनरेट किए गए कोड को समझना
हिटबॉक्स और HasCollisionDetection
BrickBreaker में HasCollisionDetection मिक्सिन जोड़ने से, कॉम्पोनेंट के हिटबॉक्स (PlayArea पर RectangleHitbox और Ball पर CircleHitbox) ट्रैक होते हैं. साथ ही, गेम की हर टिक पर कोलिज़न कॉलबैक ट्रिगर होते हैं.
Ball में दीवार से टकराने की समस्या को ठीक करना
lib/src/components/ball.dart में, onCollisionStart गेंद के वेग वेक्टर को दिखाता है, जब वह ऊपर, बाईं या दाईं दीवार से टकराती है. साथ ही, गेंद के नीचे टकराने पर उसे हटा देता है:
@override
void onCollisionStart(
Set<Vector2> intersectionPoints,
PositionComponent other,
) {
super.onCollisionStart(intersectionPoints, other);
if (other is PlayArea) {
if (intersectionPoints.first.y <= 0) {
velocity.y = -velocity.y;
} else if (intersectionPoints.first.x <= 0) {
velocity.x = -velocity.x;
} else if (intersectionPoints.first.x >= game.width) {
velocity.x = -velocity.x;
} else if (intersectionPoints.first.y >= game.height) {
removeFromParent();
}
} else {
debugPrint('collision with $other');
}
}
गेम को चलाएं और टेस्ट करें
गेम को हॉट रीस्टार्ट करें. देखें कि बॉल, PlayArea की बाईं और दाईं दीवारों से टकराकर कैसे उछलती है और सबसे नीचे पहुंचने पर कैसे गायब हो जाती है.
अब जब बॉल दीवारों से टकराकर वापस आ रही है, तो खिलाड़ी को एक बैट दें, ताकि वह बॉल को वापस ऊपर की ओर मार सके!
7. बल्ले से गेंद को हिट करें
Antigravity को Bat कॉम्पोनेंट जोड़ने के लिए कहें
Antigravity में यह प्रॉम्प्ट भेजें, ताकि प्लेयर के कंट्रोल वाला Bat कॉम्पोनेंट बनाया जा सके और बैट और बॉल के टकराने की प्रोसेस को मैनेज किया जा सके:
Add a player-controlled `Bat` component (`lib/src/components/bat.dart`) positioned near the bottom of the play area (`height * 0.95`). Render it as a rounded rectangle with a `RectangleHitbox`, and let the player move it horizontally both by dragging (`DragCallbacks`) and with the left and right arrow keys (`KeyboardEvents` on `BrickBreaker` using a short `MoveToEffect`). In `Ball`, replace immediate bottom removal with a delayed `RemoveEffect(delay: 0.35)`, and when the ball hits the `Bat`, reverse its vertical velocity and deflect its horizontal velocity based on how far from the bat's center the ball struck.
जनरेट किए गए कोड को समझना
Bat में कस्टम रेंडरिंग, खींचकर छोड़ना, और MoveToEffect
PlayArea और Ball के उलट, lib/src/components/bat.dart में Bat, PositionComponent को सीधे तौर पर एक्सटेंड करता है और render को ओवरराइड करके, गोल कोनों वाला रेक्टैंगल (RRect) बनाता है:
@override
void render(Canvas canvas) {
super.render(canvas);
canvas.drawRRect(
RRect.fromRectAndRadius(Offset.zero & size.toSize(), cornerRadius),
_paint,
);
}
Offset.zero & size.toSize(), Rect बनाने के लिए, Offset और Size पर & ऑपरेटर का इस्तेमाल करता है.
इनपुट के लिए, Bat दो मोड के साथ काम करता है:
DragCallbacksऔरonDragUpdateका इस्तेमाल करके, माउस और टचपैड से खींचें और छोड़ें.- कीबोर्ड से मूवमेंट के लिए,
moveBy(double dx)का इस्तेमाल किया गया है. यहMoveToEffectको अटैच करता है, ताकि बैट को 100 मिलीसेकंड से ज़्यादा समय तक आसानी से ऐनिमेट किया जा सके:
void moveBy(double dx) {
add(
MoveToEffect(
Vector2((position.x + dx).clamp(0, game.width), position.y),
EffectController(duration: 0.1),
),
);
}
Ball में, देर से हटाने और ऐंगल वाले बैट से बाउंस करने की सुविधा
lib/src/components/ball.dart में, दो सुधारों की वजह से बॉल इंटरैक्शन का अनुभव काफ़ी बेहतर हो गया है:
removeFromParent()कोadd(RemoveEffect(delay: 0.35))से बदलने पर, बॉल गायब होने से पहले सबसे नीचे वाले किनारे से आगे निकल जाती है.Batसे टकराने पर,velocity.xको इस आधार पर अडजस्ट किया जाता है कि गेंद, बल्ले के बीच वाले हिस्से के मुकाबले कहां टकराई:
} else if (other is Bat) {
velocity.y = -velocity.y;
velocity.x =
velocity.x +
(position.x - other.position.x) / other.size.x * game.width * 0.3;
}
गेम को चलाएं और टेस्ट करें
गेम को हॉट रीस्टार्ट करें. बैट को मूव करने के लिए, उसे माउस या उंगली से खींचें और छोड़ें. इसके अलावा, लेफ़्ट और राइट ऐरो बटन दबाकर भी बैट को मूव किया जा सकता है. इसके बाद, बॉल को स्क्रीन के सबसे ऊपर की ओर बाउंस करें.
अब आपके पास गेंद को हिट करने के लिए बैट है. इसलिए, ईंटों की एक दीवार जोड़ें, ताकि उसे तोड़ा जा सके!
8. दीवार तोड़ें
Antigravity को ईंटें जोड़ने के लिए कहें
Brick कॉम्पोनेंट बनाने, ईंटों की ग्रिड लेआउट करने, और ईंटों के टूटने पर गेंद की रफ़्तार बढ़ाने के लिए, Antigravity में यह प्रॉम्प्ट भेजें:
Create a `Brick` rectangle component (`lib/src/components/brick.dart`) with a hitbox and add a 10-column by 5-row grid of colored bricks across the top of the play area using constants in `lib/src/config.dart`. When the ball collides with a brick, remove the brick, reflect the ball's velocity off the side of the brick it hit, and multiply the ball's velocity by a `difficultyModifier` (such as `1.03`) so the game speeds up. When the last brick is destroyed, remove the ball and bat from the world.
जनरेट किए गए कोड को समझना
कॉम्पोनेंट हटाने और विजेता की जांच करने की प्रोसेस को सूची में शामिल करना
lib/src/components/brick.dart में, Brick.onCollisionStart ईंट को हटाता है और यह जांच करता है कि क्या वह दुनिया की आखिरी ईंट थी:
@override
void onCollisionStart(
Set<Vector2> intersectionPoints,
PositionComponent other,
) {
super.onCollisionStart(intersectionPoints, other);
removeFromParent();
if (game.world.children.query<Brick>().length == 1) {
game.world.removeAll(game.world.children.query<Ball>());
game.world.removeAll(game.world.children.query<Bat>());
}
}
removeFromParent() को कॉल करने के बाद, जांच में query की तुलना क्यों की जाती है? Flame में कॉम्पोनेंट को हटाने के लिए, सूची में शामिल कमांड का इस्तेमाल किया जाता है. इसलिए, मौजूदा कॉलबैक पूरा होने के बाद ही, कॉम्पोनेंट ट्री से ब्रिक को हटाया जाता है. ऐसा अगले गेम टिक से पहले किया जाता है.
Ball में मुश्किल लेवल
जब Ball, lib/src/components/ball.dart में Brick से टकराता है, तो यह सही वेलोसिटी ऐक्सिस को दिखाता है और वेलोसिटी वेक्टर को difficultyModifier (1.03) से गुणा करता है. इससे हर ईंट के टूटने के साथ गेंद की स्पीड धीरे-धीरे बढ़ती है:
} else if (other is Brick) {
if (position.y < other.position.y - other.size.y / 2) {
velocity.y = -velocity.y;
} else if (position.y > other.position.y + other.size.y / 2) {
velocity.y = -velocity.y;
} else if (position.x < other.position.x) {
velocity.x = -velocity.x;
} else if (position.x > other.position.x) {
velocity.x = -velocity.x;
}
velocity.setFrom(velocity * difficultyModifier);
}
गेम को चलाएं और टेस्ट करें
पूरी ब्रिक वॉल को ऐक्शन में देखने के लिए, गेम को हॉट रीस्टार्ट करें:

इसके बाद, Flutter विजेट का इस्तेमाल करके, वेलकम, गेम ओवर, और जीत के ओवरले जोड़े जाएंगे!
9. गेम जीतें
Antigravity को PlayState और Flutter ओवरले जोड़ने के लिए कहें
इस चरण में, आपको PlayState enum को शामिल करना होगा. साथ ही, Flame गेम को स्टाइल किए गए Flutter GameApp विजेट में ओवरले के साथ एम्बेड करना होगा. इसके अलावा, google_fonts के लिए प्लैटफ़ॉर्म नेटवर्क की अनुमतियां कॉन्फ़िगर करनी होंगी. Antigravity में यह प्रॉम्प्ट भेजें:
Add a `PlayState` enum (`welcome`, `playing`, `gameOver`, `won`) to `BrickBreaker` that synchronizes with Flame's `overlays`, turn off `debugMode`, and move spawning the ball, bat, and bricks into a `startGame()` method triggered by tapping the screen (`TapCallbacks`) or pressing Space or Enter. Transition to `gameOver` when the ball exits the bottom and `won` when the final brick breaks. Then create a Flutter wrapper `GameApp` (`lib/src/widgets/game_app.dart`, importing `package:material_ui/material_ui.dart`) using the `'Press Start 2P'` Google Font and a gradient background that displays `GameWidget` overlays for `'TAP TO PLAY'`, `'G A M E O V E R'`, and `'Y O U W O N ! ! !'`. Also add the required Android and macOS network permissions for `google_fonts`.
जनरेट किए गए कोड को समझना
PlayState की मदद से ओवरले मैनेज करना
lib/src/brick_breaker.dart में, playState सेटर, गेम की स्थिति को Flame के overlays मैनेजर के साथ सिंक करता है:
late PlayState _playState;
PlayState get playState => _playState;
set playState(PlayState playState) {
_playState = playState;
switch (playState) {
case PlayState.welcome:
case PlayState.gameOver:
case PlayState.won:
overlays.add(playState.name);
case PlayState.playing:
overlays.remove(PlayState.welcome.name);
overlays.remove(PlayState.gameOver.name);
overlays.remove(PlayState.won.name);
}
}
onLoad() में से startGame() को स्प्लिट करने पर, खिलाड़ी स्क्रीन (onTapDown) पर टैप करके या Space या Enter दबाकर, किसी भी समय गेम को शुरू या रीस्टार्ट कर सकता है.
GameWidget में मैपिंग ओवरले
lib/src/widgets/game_app.dart में, GameWidget.controlled, BrickBreaker इंस्टेंस बनाता है और हर PlayState नाम को Flutter विजेट ओवरले से मैप करता है:
child: GameWidget.controlled(
gameFactory: BrickBreaker.new,
overlayBuilderMap: {
PlayState.welcome.name: (context, game) => Center(
child: Text(
'TAP TO PLAY',
style: Theme.of(context).textTheme.headlineLarge,
),
),
// ...
},
),
overlayBuilderMap में मौजूद हर कुंजी, overlays.add(...) और overlays.remove(...) को पास किए गए ओवरले के नाम से मैच होनी चाहिए.
गेम को चलाएं और टेस्ट करें
ऐप्लिकेशन को बंद करें और फिर से चलाएं, क्योंकि google_fonts के लिए प्लैटफ़ॉर्म नेटवर्क की अनुमतियां अपडेट की गई थीं. पुष्टि करें कि ऐप्लिकेशन लॉन्च होने पर 'TAP TO PLAY' दिखे. साथ ही, स्पेसबार पर टैप करने या उसे दबाने से गेम शुरू हो जाए और गेंद खोने पर 'G A M E O V E R' दिखे.
10. स्कोर ट्रैक करें
Antigravity को स्कोर कार्ड और ऐनिमेटेड ओवरले जोड़ने के लिए कहें
इस आखिरी चरण में, ValueNotifier का इस्तेमाल करके, Flame से Flutter तक खिलाड़ी के स्कोर को दिखाया जाता है. साथ ही, flutter_animate की मदद से ओवरले को बेहतर बनाया जाता है. Antigravity में यह प्रॉम्प्ट भेजें:
Track the player's score in `BrickBreaker` using a `ValueNotifier<int> score` that resets in `startGame()` and increments whenever a brick is broken. Using `package:material_ui/material_ui.dart`, create a `ScoreCard` widget (`lib/src/widgets/score_card.dart`) above the `GameWidget` that listens to `score`, and an `OverlayScreen` widget (`lib/src/widgets/overlay_screen.dart`) using `flutter_animate` to slide in the overlay title and pulse the subtitle in and out.
जनरेट किए गए कोड को समझना
ValueNotifier की मदद से, Flame के स्टेट को Flutter से जोड़ना
lib/src/brick_breaker.dart में, BrickBreaker final ValueNotifier को एक्सपोज़ करता है. यह startGame() में रीसेट हो जाता है और हर बार Brick के हिट होने पर बढ़ता है.
lib/src/widgets/score_card.dart में, ScoreCard ValueListenableBuilder का इस्तेमाल करता है, ताकि score.value में बदलाव होने पर सिर्फ़ स्कोर टेक्स्ट फिर से बने:
@override
Widget build(BuildContext context) {
return ValueListenableBuilder<int>(
valueListenable: score,
builder: (context, score, child) {
return Padding(
padding: const EdgeInsets.fromLTRB(12, 6, 12, 18),
child: Text(
'Score: $score'.toUpperCase(),
style: Theme.of(context).textTheme.titleLarge!,
),
);
},
);
}
flutter_animate की मदद से ओवरले ऐनिमेट करना
lib/src/widgets/overlay_screen.dart में, OverlayScreen स्टैंडर्ड Text विजेट पर flutter_animate इफ़ेक्ट को चेन करता है, ताकि टाइटल को स्लाइड किया जा सके और सबटाइटल को पल्स किया जा सके:
Text(
title,
style: Theme.of(context).textTheme.headlineLarge,
).animate().slideY(duration: 750.ms, begin: -3, end: 0),
const SizedBox(height: 16),
Text(subtitle, style: Theme.of(context).textTheme.headlineSmall)
.animate(onPlay: (controller) => controller.repeat())
.fadeIn(duration: 1.seconds)
.then()
.fadeOut(duration: 1.seconds),
flutter_animate और Flutter ऐनिमेशन की सुविधाओं के बारे में ज़्यादा जानने के लिए, flutter_animate पैकेज का दस्तावेज़ और Flutter में ऐनिमेशन कोडलैब देखें.
गेम को चलाएं और टेस्ट करें
गेम को हॉट रीस्टार्ट करें. सभी चीज़ें सेट अप करने के बाद, अब Flutter के इन छह टारगेट प्लैटफ़ॉर्म में से किसी पर भी ब्रिक ब्रेकर गेम खेला जा सकता है:
|
|
11. बधाई हो
बधाई हो! आपने Flutter, Flame, और Google Antigravity का इस्तेमाल करके, 2D आर्केड गेम बनाया है.
आपने क्या बनाया है
- फ़िक्स रिज़ॉल्यूशन वाला 2D Flame गेम वर्ल्ड (
BrickBreakerऔरPlayArea), जो मोबाइल, डेस्कटॉप, और वेब पर आसानी से स्केल और लेटरबॉक्स होता है. HasCollisionDetection, हिटबॉक्स, और फ़्रेम-रेट से अलग वेलोसिटी अपडेट का इस्तेमाल करके, फ़िज़िक्स और कोलिज़न कॉम्पोनेंट (Ball,Bat, औरBrick).- मल्टी-मोडल प्लेयर कंट्रोल और फ़्लेम इफ़ेक्ट. इसमें टच और माउस से खींचने और छोड़ने (
DragCallbacks) की सुविधा के साथ-साथ, कीबोर्ड से कंट्रोल किए जाने वालेMoveToEffectऐनिमेशन और देरी से होने वालेRemoveEffectक्लीनअप की सुविधा भी शामिल है. - Flutter यूज़र इंटरफ़ेस (यूआई) इंटिग्रेशन: इसके लिए,
GameWidget.controlledओवरले, रीयल-टाइम स्कोर अपडेट के लिएValueNotifierस्टेट मैनेजमेंट,google_fonts, औरflutter_animateका इस्तेमाल किया गया है.
यहां से कहां जाएं
गेम को अपनी पसंद के मुताबिक बनाने के लिए, Antigravity को प्रॉम्प्ट देना जारी रखें! यहां कुछ आइडिया दिए गए हैं, जिन्हें आज़माया जा सकता है:
- रेट्रो आर्केड साउंड इफ़ेक्ट: Antigravity को पैडल हिट, वॉल बाउंस, और ब्रिक डिस्ट्रक्शन के लिए
flame_audio(या सिंथसाइज़्ड ऑडियो इफ़ेक्ट) जोड़ने के लिए कहें. - पावर-अप और मल्टी-बॉल: टूटी हुई ईंटों से गिरने वाले पावर-अप कैप्सूल बनाएं. इनसे बैट को चौड़ा किया जा सकता है, गेंद की रफ़्तार को धीमा किया जा सकता है या गेंद को तीन हिस्सों में बांटा जा सकता है.
- कई लेवल और सबसे ज़्यादा स्कोर:
shared_preferencesका इस्तेमाल करके, खिलाड़ी के सबसे ज़्यादा स्कोर को सेव करें. साथ ही, अगले लेवल के लिए ईंटों के नए लेआउट डिज़ाइन करें.
आगे क्या करना है?
इससे जुड़े कुछ कोडलैब देखें:
- Flutter की मदद से शब्दों वाली पहेली बनाएं
- Flutter में ऐनिमेशन
- Material 3 की मदद से, ऐनिमेटेड रिस्पॉन्सिव ऐप्लिकेशन लेआउट बनाएं
- अपने Flutter ऐप्लिकेशन में इन-ऐप्लिकेशन खरीदारी की सुविधा जोड़ना

