34 KiB

Raw Blame History

स्पेस गेम बनाउनुहोस् भाग ४: लेजर थप्नुहोस् र टक्कर पत्ता लगाउनुहोस्

प्रि-लेक्चर क्विज

स्टार वार्सको त्यो क्षण सम्झनुहोस् जब लुकको प्रोटोन टार्पिडोले डेथ स्टारको एक्जस्ट पोर्टलाई हान्यो। त्यो सटीक टक्करले ग्यालेक्सीको भाग्य परिवर्तन गर्यो! खेलहरूमा, टक्कर पत्ता लगाउने प्रणाली पनि त्यस्तै काम गर्छ - यो वस्तुहरू कहिले अन्तरक्रिया गर्छन् र त्यसपछि के हुन्छ भनेर निर्धारण गर्छ।

यस पाठमा, तपाईं आफ्नो स्पेस गेममा लेजर हतियारहरू थप्नुहुनेछ र टक्कर पत्ता लगाउने प्रणाली कार्यान्वयन गर्नुहुनेछ। नासाको मिशन योजनाकारहरूले अन्तरिक्ष यानको मार्गहरू मलबा टार्न गणना गरेजस्तै, तपाईं खेलका वस्तुहरू कहिले एकअर्कासँग ठोक्किन्छन् भनेर पत्ता लगाउन सिक्नुहुनेछ। हामी यसलाई व्यवस्थित चरणहरूमा तोड्नेछौं जसले एकअर्कालाई निर्माण गर्छ।

पाठको अन्त्यसम्ममा, तपाईंको खेलमा लेजरहरूले शत्रुहरूलाई नष्ट गर्ने र टक्करहरूले खेलका घटनाहरू ट्रिगर गर्ने कार्य प्रणाली हुनेछ। यी समान टक्कर सिद्धान्तहरू भौतिक विज्ञानको सिमुलेशनदेखि अन्तरक्रियात्मक वेब इन्टरफेससम्म सबैमा प्रयोग गरिन्छ।

✅ पहिलो कम्प्युटर गेम कहिले लेखिएको थियो भनेर थोरै अनुसन्धान गर्नुहोस्। यसको कार्यक्षमता के थियो?

टक्कर पत्ता लगाउने प्रणाली

टक्कर पत्ता लगाउने प्रणाली अपोलो चन्द्रमा मोड्युलको नजिकको सेन्सरहरू जस्तै काम गर्छ - यो लगातार दूरीहरू जाँच गर्छ र वस्तुहरू धेरै नजिक आउँदा चेतावनी दिन्छ। खेलहरूमा, यो प्रणालीले वस्तुहरू कहिले अन्तरक्रिया गर्छन् र त्यसपछि के हुन्छ भनेर निर्धारण गर्छ।

हामीले प्रयोग गर्ने विधिले प्रत्येक खेलको वस्तुलाई आयतको रूपमा व्यवहार गर्छ, जस्तै हवाई यातायात नियन्त्रण प्रणालीहरूले विमान ट्र्याक गर्न सरल ज्यामितीय आकारहरू प्रयोग गर्छन्। यो आयत विधि आधारभूत लाग्न सक्छ, तर यो गणनात्मक रूपमा प्रभावकारी छ र अधिकांश खेल परिदृश्यहरूको लागि राम्रोसँग काम गर्छ।

आयतको प्रतिनिधित्व

प्रत्येक खेलको वस्तुमा समन्वय सीमा आवश्यक छ, जस्तै मर्स पाथफाइन्डर रोभरले मर्सको सतहमा आफ्नो स्थान म्याप गरेको थियो। यहाँ हामीले यी सीमा समन्वयहरू कसरी परिभाषित गर्छौं:

rectFromGameObject() {
  return {
    top: this.y,
    left: this.x,
    bottom: this.y + this.height,
    right: this.x + this.width
  }
}

यसलाई तोडेर बुझौं:

माथिल्लो किनारा: यो वस्तु ठ्याक्कै कहाँबाट ठाडो रूपमा सुरु हुन्छ (यसको y स्थिति)
बायाँ किनारा: यो वस्तु कहाँबाट तेर्सो रूपमा सुरु हुन्छ (यसको x स्थिति)
तल्लो किनारा: y स्थितिमा उचाइ थप्नुहोस् - अब तपाईंलाई यो कहाँ समाप्त हुन्छ थाहा छ!
दायाँ किनारा: x स्थितिमा चौडाइ थप्नुहोस् - र तपाईंले पूर्ण सीमा पाउनुभयो।

अन्तरालको एल्गोरिदम

आयतको अन्तराल पत्ता लगाउने प्रणाली हबल स्पेस टेलिस्कोपले आफ्नो दृश्य क्षेत्रमा आकाशीय वस्तुहरू ओभरल्याप गरिरहेका छन् कि छैनन् भनेर निर्धारण गर्ने तरिकासँग मिल्दोजुल्दो तर्क प्रयोग गर्छ। एल्गोरिदमले छुट्टै परीक्षण गर्छ:

function intersectRect(r1, r2) {
  return !(r2.left > r1.right ||
    r2.right < r1.left ||
    r2.top > r1.bottom ||
    r2.bottom < r1.top);
}

छुट्टै परीक्षण राडार प्रणाली जस्तै काम गर्छ:

के आयत २ पूर्ण रूपमा आयत १ को दायाँ छ?
के आयत २ पूर्ण रूपमा आयत १ को बायाँ छ?
के आयत २ पूर्ण रूपमा आयत १ को तल छ?
के आयत २ पूर्ण रूपमा आयत १ को माथि छ?

यदि यी कुनै पनि सर्तहरू सत्य छैनन् भने, आयतहरू ओभरल्याप गरिरहेका हुनुपर्छ। यो विधि राडार अपरेटरहरूले दुई विमान सुरक्षित दूरीमा छन् कि छैनन् भनेर निर्धारण गर्ने तरिकासँग मिल्दोजुल्दो छ।

वस्तुहरूको जीवनचक्र व्यवस्थापन

जब लेजरले शत्रुलाई हान्छ, दुबै वस्तुहरू खेलबाट हटाउन आवश्यक छ। तर, लूपको बीचमा वस्तुहरू मेट्दा क्र्यास हुन सक्छ - अपोलो गाइडेन्स कम्प्युटर जस्ता प्रारम्भिक कम्प्युटर प्रणालीहरूमा सिकिएको पाठ। यसको सट्टा, हामी "मेट्नको लागि चिन्ह लगाउने" विधि प्रयोग गर्छौं जसले फ्रेमहरू बीच सुरक्षित रूपमा वस्तुहरू हटाउँछ।

यहाँ हामी कसरी मेट्नको लागि चिन्ह लगाउँछौं:

// Mark object for removal
enemy.dead = true;

यो विधि किन काम गर्छ:

हामी वस्तुलाई "मरेको" भनेर चिन्ह लगाउँछौं तर तुरुन्तै मेट्दैनौं।
यसले हालको खेल फ्रेमलाई सुरक्षित रूपमा समाप्त गर्न दिन्छ।
पहिले नै मेटिएको वस्तु प्रयोग गर्न खोज्दा कुनै क्र्यास हुँदैन!

अनि अर्को रेंडर चक्र अघि चिन्ह लगाइएका वस्तुहरू फिल्टर गर्नुहोस्:

gameObjects = gameObjects.filter(go => !go.dead);

यो फिल्टरले के गर्छ:

केवल "जिउँदो" वस्तुहरू भएको नयाँ सूची बनाउँछ।
"मरेको" भनेर चिन्ह लगाइएका वस्तुहरू हटाउँछ।
तपाईंको खेललाई सहज रूपमा चलाउँछ।
नष्ट गरिएका वस्तुहरूबाट मेमोरी बृद्धि रोक्छ।

लेजर यान्त्रिकी कार्यान्वयन

खेलहरूमा लेजर प्रोजेक्टाइलहरू स्टार ट्रेकका फोटोन टार्पिडोहरू जस्तै काम गर्छन् - ती छुट्टै वस्तुहरू हुन् जो सीधा रेखामा यात्रा गर्छन् जबसम्म तिनीहरूले केही हान्दैनन्। प्रत्येक स्पेसबार थिच्दा नयाँ लेजर वस्तु सिर्जना हुन्छ जुन स्क्रिनमा सर्छ।

यसलाई काम गर्न बनाउन, हामीले केही फरक टुक्राहरू समन्वय गर्न आवश्यक छ:

कार्यान्वयन गर्नका लागि मुख्य घटकहरू:

सिर्जना गर्नुहोस् लेजर वस्तुहरू जो नायकको स्थितिबाट उत्पन्न हुन्छन्।
ह्यान्डल गर्नुहोस् किबोर्ड इनपुटले लेजर सिर्जना ट्रिगर गर्छ।
व्यवस्थापन गर्नुहोस् लेजरको गति र जीवनचक्र।
लेजर प्रोजेक्टाइलहरूको दृश्य प्रतिनिधित्व कार्यान्वयन गर्नुहोस्।

फायरिङ दर नियन्त्रण कार्यान्वयन

असीमित फायरिङ दरले खेल इन्जिनलाई अभिभूत पार्नेछ र खेललाई धेरै सजिलो बनाउनेछ। वास्तविक हतियार प्रणालीहरूले यस्तै सीमाहरू सामना गर्छन् - USS एंटरप्राइजका फेजरहरूलाई पनि शटहरू बीच रिचार्ज गर्न समय चाहिन्थ्यो।

हामी एक कूलडाउन प्रणाली कार्यान्वयन गर्नेछौं जसले स्प्याम फायरिङ रोक्छ जबकि उत्तरदायी नियन्त्रणहरू कायम राख्छ:

class Cooldown {
  constructor(time) {
    this.cool = false;
    setTimeout(() => {
      this.cool = true;
    }, time);
  }
}

class Weapon {
  constructor() {
    this.cooldown = null;
  }
  
  fire() {
    if (!this.cooldown || this.cooldown.cool) {
      // Create laser projectile
      this.cooldown = new Cooldown(500);
    } else {
      // Weapon is still cooling down
    }
  }
}

कूलडाउन कसरी काम गर्छ:

सिर्जना गर्दा, हतियार "तातो" हुन्छ (अहिलेसम्म फायर गर्न सक्दैन)।
टाइमआउट अवधि पछि, यो "चिसो" हुन्छ (फायर गर्न तयार)।
फायरिङ अघि, हामी जाँच गर्छौं: "के हतियार चिसो छ?"
यसले स्प्याम-क्लिकिङ रोक्छ जबकि नियन्त्रणहरू उत्तरदायी राख्छ।

✅ स्पेस गेम श्रृंखलाको पाठ १ मा फर्केर कूलडाउनको बारेमा सम्झनुहोस्।

टक्कर प्रणाली निर्माण गर्नुहोस्

तपाईं आफ्नो स्पेस गेमको कोडलाई टक्कर पत्ता लगाउने प्रणाली सिर्जना गर्न विस्तार गर्नुहुनेछ। अन्तर्राष्ट्रिय स्पेस स्टेशनको स्वचालित टक्कर टार्ने प्रणाली जस्तै, तपाईंको खेलले निरन्तर वस्तुहरूको स्थिति अनुगमन गर्नेछ र अन्तरालहरूमा प्रतिक्रिया दिनेछ।

तपाईंको अघिल्लो पाठको कोडबाट सुरु गर्दै, तपाईं टक्कर पत्ता लगाउने प्रणाली थप्नुहुनेछ जसले वस्तु अन्तरक्रियालाई शासित गर्ने विशिष्ट नियमहरू समावेश गर्दछ।

💡 प्रो टिप: लेजर स्प्राइट पहिले नै तपाईंको सम्पत्ति फोल्डरमा समावेश गरिएको छ र तपाईंको कोडमा सन्दर्भ गरिएको छ, कार्यान्वयनको लागि तयार।

कार्यान्वयन गर्न टक्कर नियमहरू

खेल यान्त्रिकी थप्नका लागि:

लेजरले शत्रुलाई हान्छ: लेजर प्रोजेक्टाइलले हान्दा शत्रु वस्तु नष्ट हुन्छ।
लेजर स्क्रिनको सीमा हान्छ: स्क्रिनको माथिल्लो किनारमा पुग्दा लेजर हटाइन्छ।
शत्रु र नायकको टक्कर: दुबै वस्तुहरू ठोक्किँदा नष्ट हुन्छन्।
शत्रु तल पुग्छ: स्क्रिनको तल शत्रुहरू पुग्दा खेल समाप्त हुने अवस्था।

तपाईंको विकास वातावरण सेटअप गर्नुहोस्

राम्रो समाचार - हामीले तपाईंको लागि अधिकांश आधारभूत संरचना पहिले नै सेटअप गरिसकेका छौं! तपाईंको सबै खेल सम्पत्ति र आधारभूत संरचना your-work सबफोल्डरमा पर्खिरहेका छन्, तपाईंले चाखलाग्दो टक्कर सुविधाहरू थप्न तयार।

परियोजना संरचना

-| assets
  -| enemyShip.png
  -| player.png
  -| laserRed.png
-| index.html
-| app.js
-| package.json

फाइल संरचना बुझ्दै:

समावेश गर्दछ खेल वस्तुहरूको लागि आवश्यक सबै स्प्राइट छविहरू।
सामेल छ मुख्य HTML दस्तावेज र जाभास्क्रिप्ट एप्लिकेसन फाइल।
प्रदान गर्दछ स्थानीय विकास सर्भरको लागि प्याकेज कन्फिगरेसन।

विकास सर्भर सुरु गर्दै

तपाईंको परियोजना फोल्डरमा नेभिगेट गर्नुहोस् र स्थानीय सर्भर सुरु गर्नुहोस्:

cd your-work
npm start

यो कमाण्ड अनुक्रम:

डाइरेक्टरी परिवर्तन गर्छ तपाईंको कार्य परियोजना फोल्डरमा।
सुरु गर्छ स्थानीय HTTP सर्भर http://localhost:5000 मा।
सर्भ गर्छ तपाईंको खेल फाइलहरू परीक्षण र विकासको लागि।
सक्षम बनाउँछ स्वत: रीलोडिङको साथ लाइभ विकास।

तपाईंको ब्राउजर खोल्नुहोस् र http://localhost:5000 मा नेभिगेट गर्नुहोस् ताकि तपाईं आफ्नो हालको खेल अवस्था नायक र शत्रुहरू स्क्रिनमा रेंडर भएको देख्न सक्नुहुन्छ।

चरण-दर-चरण कार्यान्वयन

नासाले भ्वायजर स्पेसक्राफ्ट प्रोग्राम गर्न प्रयोग गरेको व्यवस्थित दृष्टिकोण जस्तै, हामी टक्कर पत्ता लगाउने प्रणालीलाई विधिवत रूपमा कार्यान्वयन गर्नेछौं, प्रत्येक घटकलाई चरण-दर-चरण निर्माण गर्दै।

1. आयत टक्कर सीमा थप्नुहोस्

पहिले, हाम्रो खेलका वस्तुहरूलाई आफ्नो सीमा वर्णन गर्न सिकाऔं। तपाईंको GameObject क्लासमा यो विधि थप्नुहोस्:

rectFromGameObject() {
    return {
      top: this.y,
      left: this.x,
      bottom: this.y + this.height,
      right: this.x + this.width,
    };
  }

यो विधिले के पूरा गर्छ:

सिर्जना गर्छ सटीक सीमा समन्वय भएको आयत वस्तु।
गणना गर्छ तल्लो र दायाँ किनाराहरू स्थिति प्लस आयाम प्रयोग गरेर।
फर्काउँछ टक्कर पत्ता लगाउने एल्गोरिदमहरूको लागि तयार वस्तु।
प्रदान गर्छ सबै खेल वस्तुहरूको लागि मानकीकृत इन्टरफेस।

2. अन्तराल पत्ता लगाउने प्रणाली कार्यान्वयन गर्नुहोस्

अब हाम्रो टक्कर जासूस बनाऔं - एउटा फंक्शन जसले दुई आयतहरू ओभरल्याप गरिरहेका छन् कि छैनन् भनेर बताउन सक्छ:

function intersectRect(r1, r2) {
  return !(
    r2.left > r1.right ||
    r2.right < r1.left ||
    r2.top > r1.bottom ||
    r2.bottom < r1.top
  );
}

यो एल्गोरिदमले काम गर्छ:

परीक्षण गर्छ आयतहरू बीच चार छुट्टै सर्तहरू।
फर्काउँछ false यदि कुनै छुट्टै सर्त सत्य छ भने।
संकेत गर्छ टक्कर जब कुनै छुट्टै अवस्था छैन।
प्रयोग गर्छ नकारात्मक तर्क कुशल अन्तराल परीक्षणको लागि।

3. लेजर फायरिङ प्रणाली कार्यान्वयन गर्नुहोस्

अब रोमाञ्चक भाग सुरु हुन्छ! लेजर फायरिङ प्रणाली सेटअप गरौं।

सन्देश स्थिरांकहरू

पहिले, केही सन्देश प्रकारहरू परिभाषित गरौं ताकि हाम्रो खेलका विभिन्न भागहरू एकअर्कासँग कुरा गर्न सकून्:

KEY_EVENT_SPACE: "KEY_EVENT_SPACE",
COLLISION_ENEMY_LASER: "COLLISION_ENEMY_LASER",
COLLISION_ENEMY_HERO: "COLLISION_ENEMY_HERO",

यी स्थिरांकहरूले प्रदान गर्छ:

मानकीकरण गर्छ एप्लिकेसनभरि घटना नामहरू।
सक्षम बनाउँछ खेल प्रणालीहरू बीच निरन्तर सञ्चार।
रोक्छ घटना ह्यान्डलर दर्तामा टाइपोहरू।

किबोर्ड इनपुट ह्यान्डलिङ

तपाईंको की इभेन्ट लिस्नरमा स्पेस की पत्ता लगाउने प्रणाली थप्नुहोस्:

} else if(evt.keyCode === 32) {
  eventEmitter.emit(Messages.KEY_EVENT_SPACE);
}

यो इनपुट ह्यान्डलर:

पत्ता लगाउँछ स्पेस की प्रेसहरू keyCode 32 प्रयोग गरेर।
प्रसारण गर्छ मानकीकृत घटना सन्देश।
सक्षम बनाउँछ फायरिङ तर्कलाई अलग राख्न।

इभेन्ट लिस्नर सेटअप

तपाईंको initGame() फंक्शनमा फायरिङ व्यवहार दर्ता गर्नुहोस्:

eventEmitter.on(Messages.KEY_EVENT_SPACE, () => {
 if (hero.canFire()) {
   hero.fire();
 }
});

यो इभेन्ट लिस्नर:

प्रतिक्रिया दिन्छ स्पेस की घटनाहरूमा।
जाँच गर्छ फायरिङ कूलडाउन स्थिति।
ट्रिगर गर्छ लेजर सिर्जना जब अनुमति छ।

लेजर-शत्रु अन्तरक्रियाको लागि टक्कर ह्यान्डलिङ थप्नुहोस्:

eventEmitter.on(Messages.COLLISION_ENEMY_LASER, (_, { first, second }) => {
  first.dead = true;
  second.dead = true;
});

यो टक्कर ह्यान्डलर:

प्राप्त गर्छ टक्कर घटना डेटा दुबै वस्तुहरूसँग।
चिन्ह लगाउँछ दुबै वस्तुहरू मेट्नको लागि।
सुनिश्चित गर्छ टक्करपछि उचित सफाइ।

4. लेजर क्लास सिर्जना गर्नुहोस्

लेजर प्रोजेक्टाइल कार्यान्वयन गर्नुहोस् जसले माथि सर्छ र आफ्नो जीवनचक्र व्यवस्थापन गर्छ:

class Laser extends GameObject {
  constructor(x, y) {
    super(x, y);
    this.width = 9;
    this.height = 33;
    this.type = 'Laser';
    this.img = laserImg;
    
    let id = setInterval(() => {
      if (this.y > 0) {
        this.y -= 15;
      } else {
        this.dead = true;
        clearInterval(id);
      }
    }, 100);
  }
}

यो क्लास कार्यान्वयन:

विस्तार गर्छ GameObject आधारभूत कार्यक्षमता प्राप्त गर्न।
सेट गर्छ लेजर स्प्राइटको लागि उपयुक्त आयामहरू।
सिर्जना गर्छ setInterval() प्रयोग गरेर स्वचालित माथि सर्ने गति।
ह्यान्डल गर्छ स्क्रिनको माथि पुग्दा आत्म-विनाश।
व्यवस्थापन गर्छ आफ्नो एनिमेसन टाइमिङ र सफाइ।

5. टक्कर पत्ता लगाउने प्रणाली कार्यान्वयन गर्नुहोस्

व्यापक टक्कर पत्ता लगाउने फंक्शन सिर्जना गर्नुहोस्:

function updateGameObjects() {
  const enemies = gameObjects.filter(go => go.type === 'Enemy');
  const lasers = gameObjects.filter(go => go.type === "Laser");
  
  // Test laser-enemy collisions
  lasers.forEach((laser) => {
    enemies.forEach((enemy) => {
      if (intersectRect(laser.rectFromGameObject(), enemy.rectFromGameObject())) {
        eventEmitter.emit(Messages.COLLISION_ENEMY_LASER, {
          first: laser,
          second: enemy,
        });
      }
    });
  });

  // Remove destroyed objects
  gameObjects = gameObjects.filter(go => !go.dead);
}

यो टक्कर प्रणाली:

फिल्टर गर्छ खेल वस्तुहरू प्रकार अनुसार कुशल परीक्षणको लागि।
परीक्षण गर्छ प्रत्येक लेजरलाई प्रत्येक शत्रुसँग अन्तरालको लागि।
प्रसारण गर्छ टक्कर घटनाहरू जब अन्तरालहरू पत्ता लाग्छ।
सफाइ गर्छ टक्कर प्रक्रिया पछि नष्ट गरिएका वस्तुहरू।

⚠️ महत्वपूर्ण: updateGameObjects() तपाईंको मुख्य खेल लूपमा window.onload मा थप्नुहोस् ताकि टक्कर पत्ता लगाउने प्रणाली सक्षम होस्।

6. नायक क्लासमा कूलडाउन प्रणाली थप्नुहोस्

फायरिङ यान्त्रिकी र दर सीमितता सहित नायक क्लासलाई सुधार गर्नुहोस्:

class Hero extends GameObject {
  constructor(x, y) {
    super(x, y);
    this.width = 99;
    this.height = 75;
    this.type = "Hero";
    this.speed = { x: 0, y: 0 };
    this.cooldown = 0;
  }
  
  fire() {
    gameObjects.push(new Laser(this.x + 45, this.y - 10));
    this.cooldown = 500;

    let id = setInterval(() => {
      if (this.cooldown > 0) {
        this.cooldown -= 100;
      } else {
        clearInterval(id);
      }
    }, 200);
  }
  
  canFire() {
    return this.cooldown === 0;
  }
}

सुधारिएको नायक क्लास बुझ्दै:

सुरु गर्छ कूलडाउन टाइमर शून्यमा (फायर गर्न तयार)।
सिर्जना गर्छ नायक जहाजको माथि स्थित लेजर वस्तुहरू।
सेट गर्छ कूलडाउन अवधि स्प्याम फायरिङ रोक्न।
घटाउँछ कूलडाउन टाइमर अन्तराल-आधारित अपडेटहरू प्रयोग गरेर।
प्रदान गर्छ canFire() विधि मार्फत फायरिङ स्थिति जाँच।

तपाईंको कार्यान्वयन परीक्षण गर्दै

तपाईंको स्पेस गेममा अब पूर्ण टक्कर पत्ता लगाउने र युद्ध यान्त्रिकी छ। 🚀 यी नयाँ क्षमताहरू परीक्षण गर्नुहोस्:

नेभिगेट गर्नुहोस् एरो कीहरू प्रयोग गरेर गति नियन्त्रणहरू जाँच गर्न।
लेजर फायर गर्नुहोस् स्पेसबार प्रयोग गरेर - कूलडाउनले स्प्याम-क्लिकिङ रोक्छ भन्ने कुरा ध्यान दिनुहोस्।
टक्करहरू अवलोकन गर्नुहोस् जब लेजरले शत्रुहरूलाई हान्छ, जसले हटाउने ट्रिगर गर्छ।
सफाइ जाँच गर्नुहोस् नष्ट गरिएका वस्तुहरू खेलबाट गायब हुँदा।

तपाईंले अन्तरिक्ष यान नेभिगेसन र रोबोटिक्सलाई मार्गदर्शन गर्ने समान गणितीय सिद्धान्तहरू प्रयोग गरेर टक्कर पत्ता लगाउने प्रणाली सफलतापूर्वक कार्यान्वयन गर्नुभएको छ।

GitHub Copilot एजेन्ट चुनौती 🚀

एजेन्ट मोड प्रयोग गरेर निम्न चुनौती पूरा गर्नुहोस्:

विवरण: टक्कर पत्ता लगाउने प्रणालीलाई सुधार गर्दै पावर-अपहरू कार्यान्वयन गर्नुहोस् जसले नायक जहाजले संकलन गर्दा अस्थायी क्षमताहरू प्रदान गर्छ।

प्रोम्प्ट: PowerUp क्लास सिर्जना गर्नुहोस् जसले GameObject विस्तार गर्छ र नायक र पावर-अपहरू बीच टक्कर पत्ता लगाउने प्रणाली कार्यान्वयन गर्नुहोस्। कम

अस्वीकरण:
यो दस्तावेज AI अनुवाद सेवा Co-op Translator प्रयोग गरेर अनुवाद गरिएको छ। हामी शुद्धताको लागि प्रयास गर्छौं, तर कृपया ध्यान दिनुहोस् कि स्वचालित अनुवादमा त्रुटिहरू वा अशुद्धताहरू हुन सक्छ। यसको मूल भाषा मा रहेको मूल दस्तावेजलाई आधिकारिक स्रोत मानिनुपर्छ। महत्वपूर्ण जानकारीको लागि, व्यावसायिक मानव अनुवाद सिफारिस गरिन्छ। यस अनुवादको प्रयोगबाट उत्पन्न हुने कुनै पनि गलतफहमी वा गलत व्याख्याको लागि हामी जिम्मेवार हुने छैनौं।

34 KiB Raw Blame History