Web-Dev-For-Beginners/translations/pa/6-space-game/4-collision-detection/README.md

ਸਪੇਸ ਗੇਮ ਬਣਾਓ ਭਾਗ 4: ਲੇਜ਼ਰ ਜੋੜੋ ਅਤੇ ਟਕਰਾਂ ਦੀ ਪਛਾਣ ਕਰੋ

ਪੂਰਵ-ਵਿਚਾਰ ਕਵਿਜ਼

ਪੂਰਵ-ਵਿਚਾਰ ਕਵਿਜ਼

ਇਸ ਪਾਠ ਵਿੱਚ ਤੁਸੀਂ ਜਾਵਾਸਕ੍ਰਿਪਟ ਦੀ ਮਦਦ ਨਾਲ ਲੇਜ਼ਰ ਚਲਾਉਣਾ ਸਿੱਖੋਗੇ! ਅਸੀਂ ਆਪਣੇ ਗੇਮ ਵਿੱਚ ਦੋ ਚੀਜ਼ਾਂ ਜੋੜਾਂਗੇ:

• ਲੇਜ਼ਰ: ਇਹ ਲੇਜ਼ਰ ਤੁਹਾਡੇ ਹੀਰੋ ਦੇ ਜਹਾਜ਼ ਤੋਂ ਉੱਪਰ ਵੱਲ ਚਲਾਇਆ ਜਾਂਦਾ ਹੈ
• ਟਕਰਾਂ ਦੀ ਪਛਾਣ, ਗੋਲੀ ਚਲਾਉਣ ਦੀ ਸਮਰੱਥਾ ਨੂੰ ਲਾਗੂ ਕਰਨ ਦੇ ਹਿੱਸੇ ਵਜੋਂ ਅਸੀਂ ਕੁਝ ਵਧੀਆ ਗੇਮ ਨਿਯਮ ਵੀ ਜੋੜਾਂਗੇ:
  • ਲੇਜ਼ਰ ਦੁਸ਼ਮਨ ਨੂੰ ਮਾਰਦਾ ਹੈ: ਜੇ ਲੇਜ਼ਰ ਦੁਸ਼ਮਨ ਨੂੰ ਮਾਰਦਾ ਹੈ ਤਾਂ ਦੁਸ਼ਮਨ ਮਰ ਜਾਂਦਾ ਹੈ
  • ਲੇਜ਼ਰ ਸਕਰੀਨ ਦੇ ਉੱਪਰ ਲੱਗਦਾ ਹੈ: ਜੇ ਲੇਜ਼ਰ ਸਕਰੀਨ ਦੇ ਉੱਪਰ ਲੱਗਦਾ ਹੈ ਤਾਂ ਲੇਜ਼ਰ ਨਸ਼ਟ ਹੋ ਜਾਂਦਾ ਹੈ
  • ਦੁਸ਼ਮਨ ਅਤੇ ਹੀਰੋ ਦੀ ਟਕਰ: ਜੇ ਦੁਸ਼ਮਨ ਅਤੇ ਹੀਰੋ ਇੱਕ ਦੂਜੇ ਨਾਲ ਟਕਰਾਂਦੇ ਹਨ ਤਾਂ ਦੋਵੇਂ ਨਸ਼ਟ ਹੋ ਜਾਂਦੇ ਹਨ
  • ਦੁਸ਼ਮਨ ਸਕਰੀਨ ਦੇ ਹੇਠਾਂ ਪਹੁੰਚਦਾ ਹੈ: ਜੇ ਦੁਸ਼ਮਨ ਸਕਰੀਨ ਦੇ ਹੇਠਾਂ ਪਹੁੰਚਦਾ ਹੈ ਤਾਂ ਦੁਸ਼ਮਨ ਅਤੇ ਹੀਰੋ ਦੋਵੇਂ ਨਸ਼ਟ ਹੋ ਜਾਂਦੇ ਹਨ

ਸਾਰ ਵਿੱਚ, ਤੁਸੀਂ -- ਹੀਰੋ -- ਨੂੰ ਸਾਰੇ ਦੁਸ਼ਮਨਾਂ ਨੂੰ ਲੇਜ਼ਰ ਨਾਲ ਮਾਰਨਾ ਹੈ ਜਦੋਂ ਤੱਕ ਉਹ ਸਕਰੀਨ ਦੇ ਹੇਠਾਂ ਨਹੀਂ ਪਹੁੰਚਦੇ।

✅ ਸਭ ਤੋਂ ਪਹਿਲਾ ਲਿਖੇ ਗਏ ਕੰਪਿਊਟਰ ਗੇਮ ਬਾਰੇ ਕੁਝ ਖੋਜ ਕਰੋ। ਇਸ ਦੀ ਕਾਰਗੁਜ਼ਾਰੀ ਕੀ ਸੀ?

ਚਲੋ ਹੀਰੋ ਬਣੀਏ!

ਟਕਰਾਂ ਦੀ ਪਛਾਣ

ਅਸੀਂ ਟਕਰਾਂ ਦੀ ਪਛਾਣ ਕਿਵੇਂ ਕਰਦੇ ਹਾਂ? ਸਾਨੂੰ ਆਪਣੇ ਗੇਮ ਦੇ ਆਬਜੈਕਟਾਂ ਨੂੰ ਚੌਕੋਰਾਂ ਵਜੋਂ ਸੋਚਣਾ ਪਵੇਗਾ ਜੋ ਹਿਲਦੇ ਹਨ। ਤੁਸੀਂ ਪੁੱਛ ਸਕਦੇ ਹੋ ਕਿ ਇਹ ਕਿਉਂ? ਖੈਰ, ਗੇਮ ਆਬਜੈਕਟ ਨੂੰ ਖਿੱਚਣ ਲਈ ਵਰਤੀ ਗਈ ਚਿੱਤਰਕਲਾ ਇੱਕ ਚੌਕੋਰ ਹੈ: ਇਸ ਵਿੱਚ x, y, width ਅਤੇ height ਹੁੰਦੇ ਹਨ।

ਜੇ ਦੋ ਚੌਕੋਰਾਂ, ਜਿਵੇਂ ਕਿ ਹੀਰੋ ਅਤੇ ਦੁਸ਼ਮਨ ਇਕ ਦੂਜੇ ਨਾਲ ਟਕਰਾਂਦੇ ਹਨ, ਤਾਂ ਟਕਰ ਹੋ ਜਾਂਦਾ ਹੈ। ਫਿਰ ਕੀ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ ਇਹ ਗੇਮ ਦੇ ਨਿਯਮਾਂ 'ਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ। ਟਕਰਾਂ ਦੀ ਪਛਾਣ ਲਾਗੂ ਕਰਨ ਲਈ ਤੁਹਾਨੂੰ ਹੇਠਾਂ ਦਿੱਤੇ ਗਏ ਚੀਜ਼ਾਂ ਦੀ ਲੋੜ ਹੈ:

1. ਗੇਮ ਆਬਜੈਕਟ ਦੀ ਚੌਕੋਰ ਪ੍ਰਤੀਨਿਧਤਾ ਪ੍ਰਾਪਤ ਕਰਨ ਦਾ ਇੱਕ ਤਰੀਕਾ, ਕੁਝ ਇਸ ਤਰ੍ਹਾਂ:

   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);
   }
   

ਚੀਜ਼ਾਂ ਨੂੰ ਕਿਵੇਂ ਨਸ਼ਟ ਕਰਨਾ ਹੈ

ਗੇਮ ਵਿੱਚ ਚੀਜ਼ਾਂ ਨੂੰ ਨਸ਼ਟ ਕਰਨ ਲਈ ਤੁਹਾਨੂੰ ਗੇਮ ਨੂੰ ਦੱਸਣਾ ਪਵੇਗਾ ਕਿ ਇਹ ਆਈਟਮ ਹੁਣ ਗੇਮ ਲੂਪ ਵਿੱਚ ਪੇਂਟ ਨਹੀਂ ਹੋਣਾ ਚਾਹੀਦਾ ਜੋ ਇੱਕ ਨਿਰਧਾਰਿਤ ਅੰਤਰਾਲ 'ਤੇ ਚਲਦਾ ਹੈ। ਇਸ ਦਾ ਇੱਕ ਤਰੀਕਾ ਇਹ ਹੈ ਕਿ ਜਦੋਂ ਕੁਝ ਹੁੰਦਾ ਹੈ ਤਾਂ ਗੇਮ ਆਬਜੈਕਟ ਨੂੰ ਮਰਿਆ ਹੋਇਆ ਚਿੰਨ੍ਹਿਤ ਕੀਤਾ ਜਾਵੇ, ਇਸ ਤਰ੍ਹਾਂ:

// collision happened
enemy.dead = true

ਫਿਰ ਤੁਸੀਂ ਮਰਿਆ ਹੋਇਆ ਆਬਜੈਕਟਾਂ ਨੂੰ ਸਕਰੀਨ ਨੂੰ ਦੁਬਾਰਾ ਪੇਂਟ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਛਾਂਟ ਸਕਦੇ ਹੋ, ਇਸ ਤਰ੍ਹਾਂ:

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

ਲੇਜ਼ਰ ਕਿਵੇਂ ਚਲਾਉਣਾ ਹੈ

ਲੇਜ਼ਰ ਚਲਾਉਣਾ ਇੱਕ ਕੁੰਜੀ-ਇਵੈਂਟ ਦਾ ਜਵਾਬ ਦੇਣ ਅਤੇ ਇੱਕ ਆਬਜੈਕਟ ਬਣਾਉਣ ਵਿੱਚ ਅਨੁਵਾਦ ਕਰਦਾ ਹੈ ਜੋ ਇੱਕ ਨਿਰਧਾਰਿਤ ਦਿਸ਼ਾ ਵਿੱਚ ਹਿਲਦਾ ਹੈ। ਇਸ ਲਈ ਸਾਨੂੰ ਹੇਠਾਂ ਦਿੱਤੇ ਕਦਮ ਕਰਨੇ ਪੈਣਗੇ:

1. ਲੇਜ਼ਰ ਆਬਜੈਕਟ ਬਣਾਓ: ਆਪਣੇ ਹੀਰੋ ਦੇ ਜਹਾਜ਼ ਦੇ ਉੱਪਰ ਤੋਂ, ਜੋ ਬਣਨ ਦੇ ਨਾਲ ਹੀ ਸਕਰੀਨ ਦੇ ਉੱਪਰ ਵੱਲ ਹਿਲਣਾ ਸ਼ੁਰੂ ਕਰਦਾ ਹੈ।
2. ਕੁੰਜੀ-ਇਵੈਂਟ ਨਾਲ ਕੋਡ ਜੋੜੋ: ਸਾਨੂੰ ਕੀਬੋਰਡ 'ਤੇ ਇੱਕ ਕੁੰਜੀ ਚੁਣਨੀ ਪਵੇਗੀ ਜੋ ਖਿਡਾਰੀ ਦੇ ਲੇਜ਼ਰ ਚਲਾਉਣ ਦੀ ਨੁਮਾਇੰਦਗੀ ਕਰਦੀ ਹੈ।
3. ਗੇਮ ਆਬਜੈਕਟ ਬਣਾਓ ਜੋ ਲੇਜ਼ਰ ਵਰਗਾ ਲੱਗਦਾ ਹੈ ਜਦੋਂ ਕੁੰਜੀ ਦਬਾਈ ਜਾਂਦੀ ਹੈ।

ਲੇਜ਼ਰ 'ਤੇ ਕੁਲਡਾਊਨ

ਲੇਜ਼ਰ ਨੂੰ ਹਰ ਵਾਰ ਦਬਾਈ ਗਈ ਕੁੰਜੀ, ਜਿਵੇਂ ਕਿ ਸਪੇਸ, 'ਤੇ ਚਲਾਉਣਾ ਚਾਹੀਦਾ ਹੈ। ਗੇਮ ਨੂੰ ਬਹੁਤ ਛੋਟੇ ਸਮੇਂ ਵਿੱਚ ਬਹੁਤ ਸਾਰੇ ਲੇਜ਼ਰ ਬਣਾਉਣ ਤੋਂ ਰੋਕਣ ਲਈ ਸਾਨੂੰ ਇਸ ਨੂੰ ਠੀਕ ਕਰਨਾ ਪਵੇਗਾ। ਇਸ ਨੂੰ ਠੀਕ ਕਰਨ ਦਾ ਤਰੀਕਾ ਕੁਲਡਾਊਨ, ਇੱਕ ਟਾਈਮਰ, ਲਾਗੂ ਕਰਕੇ ਹੈ, ਜੋ ਇਹ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ ਕਿ ਲੇਜ਼ਰ ਸਿਰਫ਼ ਇੱਕ ਨਿਰਧਾਰਿਤ ਸਮੇਂ ਵਿੱਚ ਚਲਾਇਆ ਜਾ ਸਕਦਾ ਹੈ। ਤੁਸੀਂ ਇਸ ਨੂੰ ਹੇਠਾਂ ਦਿੱਤੇ ਤਰੀਕੇ ਨਾਲ ਲਾਗੂ ਕਰ ਸਕਦੇ ਹੋ:

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

class Weapon {
  constructor {
  }
  fire() {
    if (!this.cooldown || this.cooldown.cool) {
      // produce a laser
      this.cooldown = new Cooldown(500);
    } else {
      // do nothing - it hasn't cooled down yet.
    }
  }
}

✅ ਸਪੇਸ ਗੇਮ ਸੀਰੀਜ਼ ਦੇ ਪਾਠ 1 ਨੂੰ ਵੇਖੋ ਤਾਂ ਜੋ ਕੁਲਡਾਊਨ ਬਾਰੇ ਯਾਦ ਕੀਤਾ ਜਾ ਸਕੇ।

ਕੀ ਬਣਾਉਣਾ ਹੈ

ਤੁਸੀਂ ਪਿਛਲੇ ਪਾਠ ਤੋਂ ਮੌਜੂਦਾ ਕੋਡ (ਜਿਸ ਨੂੰ ਤੁਸੀਂ ਸਾਫ਼ ਅਤੇ ਰਿਫੈਕਟਰ ਕੀਤਾ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ) ਲੈ ਕੇ ਇਸਨੂੰ ਵਧਾਉਣਾ ਹੈ। ਜਾਂ ਤਾਂ ਭਾਗ II ਤੋਂ ਕੋਡ ਨਾਲ ਸ਼ੁਰੂ ਕਰੋ ਜਾਂ ਭਾਗ III- ਸ਼ੁਰੂਆਤੀ 'ਤੇ ਕੋਡ ਵਰਤੋ।

ਸੁਝਾਅ: ਲੇਜ਼ਰ ਜੋ ਤੁਸੀਂ ਵਰਤੋਂਗੇ ਉਹ ਪਹਿਲਾਂ ਹੀ ਤੁਹਾਡੇ ਐਸੈਟ ਫੋਲਡਰ ਵਿੱਚ ਹੈ ਅਤੇ ਤੁਹਾਡੇ ਕੋਡ ਦੁਆਰਾ ਰਿਫਰੈਂਸ ਕੀਤਾ ਗਿਆ ਹੈ

• ਟਕਰਾਂ ਦੀ ਪਛਾਣ ਜੋੜੋ, ਜਦੋਂ ਲੇਜ਼ਰ ਕੁਝ ਨਾਲ ਟਕਰਾਂਦਾ ਹੈ ਤਾਂ ਹੇਠਾਂ ਦਿੱਤੇ ਨਿਯਮ ਲਾਗੂ ਹੋਣੇ ਚਾਹੀਦੇ ਹਨ:
  1. ਲੇਜ਼ਰ ਦੁਸ਼ਮਨ ਨੂੰ ਮਾਰਦਾ ਹੈ: ਜੇ ਲੇਜ਼ਰ ਦੁਸ਼ਮਨ ਨੂੰ ਮਾਰਦਾ ਹੈ ਤਾਂ ਦੁਸ਼ਮਨ ਮਰ ਜਾਂਦਾ ਹੈ
  2. ਲੇਜ਼ਰ ਸਕਰੀਨ ਦੇ ਉੱਪਰ ਲੱਗਦਾ ਹੈ: ਜੇ ਲੇਜ਼ਰ ਸਕਰੀਨ ਦੇ ਉੱਪਰ ਲੱਗਦਾ ਹੈ ਤਾਂ ਲੇਜ਼ਰ ਨਸ਼ਟ ਹੋ ਜਾਂਦਾ ਹੈ
  3. ਦੁਸ਼ਮਨ ਅਤੇ ਹੀਰੋ ਦੀ ਟਕਰ: ਜੇ ਦੁਸ਼ਮਨ ਅਤੇ ਹੀਰੋ ਇੱਕ ਦੂਜੇ ਨਾਲ ਟਕਰਾਂਦੇ ਹਨ ਤਾਂ ਦੋਵੇਂ ਨਸ਼ਟ ਹੋ ਜਾਂਦੇ ਹਨ
  4. ਦੁਸ਼ਮਨ ਸਕਰੀਨ ਦੇ ਹੇਠਾਂ ਪਹੁੰਚਦਾ ਹੈ: ਜੇ ਦੁਸ਼ਮਨ ਸਕਰੀਨ ਦੇ ਹੇਠਾਂ ਪਹੁੰਚਦਾ ਹੈ ਤਾਂ ਦੁਸ਼ਮਨ ਅਤੇ ਹੀਰੋ ਦੋਵੇਂ ਨਸ਼ਟ ਹੋ ਜਾਂਦੇ ਹਨ

ਸਿਫਾਰਸ਼ੀ ਕਦਮ

your-work ਸਬ ਫੋਲਡਰ ਵਿੱਚ ਬਣਾਏ ਗਏ ਫਾਈਲਾਂ ਨੂੰ ਲੱਭੋ। ਇਸ ਵਿੱਚ ਹੇਠਾਂ ਦਿੱਤੇ ਹੋਣੇ ਚਾਹੀਦੇ ਹਨ:

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

ਤੁਸੀਂ ਆਪਣਾ ਪ੍ਰੋਜੈਕਟ your_work ਫੋਲਡਰ ਵਿੱਚ ਹੇਠਾਂ ਦਿੱਤੇ ਕਮਾਂਡ ਨਾਲ ਸ਼ੁਰੂ ਕਰਦੇ ਹੋ:

cd your-work
npm start

ਉਪਰੋਕਤ HTTP ਸਰਵਰ ਪਤਾ http://localhost:5000 'ਤੇ ਸ਼ੁਰੂ ਕਰੇਗਾ। ਇੱਕ ਬ੍ਰਾਊਜ਼ਰ ਖੋਲ੍ਹੋ ਅਤੇ ਉਸ ਪਤੇ ਨੂੰ ਦਰਜ ਕਰੋ, ਇਸ ਸਮੇਂ ਇਹ ਹੀਰੋ ਅਤੇ ਸਾਰੇ ਦੁਸ਼ਮਨਾਂ ਨੂੰ ਦਰਸਾਉਣਾ ਚਾਹੀਦਾ ਹੈ, ਕੁਝ ਵੀ ਹਿਲ ਨਹੀਂ ਰਿਹਾ - ਅਜੇ ਤੱਕ :).

ਕੋਡ ਜੋੜੋ

1. ਆਪਣੇ ਗੇਮ ਆਬਜੈਕਟ ਦੀ ਚੌਕੋਰ ਪ੍ਰਤੀਨਿਧਤਾ ਸੈਟਅਪ ਕਰੋ, ਟਕਰਾਂ ਨੂੰ ਸੰਭਾਲਣ ਲਈ ਹੇਠਾਂ ਦਿੱਤਾ ਕੋਡ ਤੁਹਾਨੂੰ GameObject ਦੀ ਚੌਕੋਰ ਪ੍ਰਤੀਨਿਧਤਾ ਪ੍ਰਾਪਤ ਕਰਨ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ। ਆਪਣੇ 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
     );
   }
   

3. ਲੇਜ਼ਰ ਚਲਾਉਣ ਦੀ ਸਮਰੱਥਾ ਜੋੜੋ

   1. ਕੁੰਜੀ-ਇਵੈਂਟ ਸੁਨੇਹਾ ਜੋੜੋ। ਸਪੇਸ ਕੁੰਜੀ ਹੀਰੋ ਜਹਾਜ਼ ਦੇ ਉੱਪਰ ਇੱਕ ਲੇਜ਼ਰ ਬਣਾਉਣੀ ਚਾਹੀਦੀ ਹੈ। Messages ਆਬਜੈਕਟ ਵਿੱਚ ਤਿੰਨ constants ਜੋੜੋ:

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

   2. ਸਪੇਸ ਕੁੰਜੀ ਨੂੰ ਸੰਭਾਲੋ। window.addEventListener keyup ਫੰਕਸ਼ਨ ਨੂੰ ਸਪੇਸ ਨੂੰ ਸੰਭਾਲਣ ਲਈ ਸੋਧੋ:

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

   3. ਸੁਣਨ ਵਾਲੇ ਜੋੜੋ। initGame() ਫੰਕਸ਼ਨ ਨੂੰ ਸੋਧੋ ਤਾਂ ਕਿ ਹੀਰੋ ਸਪੇਸ ਬਾਰ ਦਬਾਉਣ 'ਤੇ ਲੇਜ਼ਰ ਚਲਾ ਸਕੇ:

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

      ਅਤੇ ਇੱਕ ਨਵਾਂ eventEmitter.on() ਫੰਕਸ਼ਨ ਜੋੜੋ ਤਾਂ ਕਿ ਜਦੋਂ ਦੁਸ਼ਮਨ ਲੇਜ਼ਰ ਨਾਲ ਟਕਰਾਂਦਾ ਹੈ ਤਾਂ ਵਿਵਹਾਰ ਯਕੀਨੀ ਬਣਾਇਆ ਜਾ ਸਕੇ:

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

   4. ਆਬਜੈਕਟ ਨੂੰ ਹਿਲਾਓ, ਯਕੀਨੀ ਬਣਾਓ ਕਿ ਲੇਜ਼ਰ ਹੌਲੀ-ਹੌਲੀ ਸਕਰੀਨ ਦੇ ਉੱਪਰ ਵੱਲ ਹਿਲਦਾ ਹੈ। ਤੁਸੀਂ ਇੱਕ ਨਵਾਂ Laser ਕਲਾਸ ਬਣਾਓਗੇ ਜੋ GameObject ਨੂੰ ਵਧਾਉਂਦਾ ਹੈ, ਜਿਵੇਂ ਕਿ ਤੁਸੀਂ ਪਹਿਲਾਂ ਕੀਤਾ ਹੈ:

        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)
        }
      }
      

   5. ਟਕਰਾਂ ਨੂੰ ਸੰਭਾਲੋ, ਲੇਜ਼ਰ ਲਈ ਟਕਰਾਂ ਦੇ ਨਿਯਮ ਲਾਗੂ ਕਰੋ। updateGameObjects() ਫੰਕਸ਼ਨ ਜੋੜੋ ਜੋ ਟਕਰਾਂਦੇ ਆਬਜੈਕਟਾਂ ਦੀ ਜਾਂਚ ਕਰਦਾ ਹੈ

      function updateGameObjects() {
        const enemies = gameObjects.filter(go => go.type === 'Enemy');
        const lasers = gameObjects.filter((go) => go.type === "Laser");
      // laser hit something
        lasers.forEach((l) => {
          enemies.forEach((m) => {
            if (intersectRect(l.rectFromGameObject(), m.rectFromGameObject())) {
            eventEmitter.emit(Messages.COLLISION_ENEMY_LASER, {
              first: l,
              second: m,
            });
          }
         });
      });
      
        gameObjects = gameObjects.filter(go => !go.dead);
      }  
      

      ਯਕੀਨੀ ਬਣਾਓ ਕਿ updateGameObjects() ਨੂੰ ਆਪਣੇ ਗੇਮ ਲੂਪ ਵਿੱਚ window.onload ਵਿੱਚ ਜੋੜੋ।

   6. ਲੇਜ਼ਰ 'ਤੇ ਕੁਲਡਾਊਨ ਲਾਗੂ ਕਰੋ, ਤਾਂ ਜੋ ਇਹ ਸਿਰਫ਼ ਇੱਕ ਨਿਰਧਾਰਿਤ ਸਮੇਂ ਵਿੱਚ ਚਲਾਇਆ ਜਾ ਸਕੇ।

      ਆਖਿਰਕਾਰ, Hero ਕਲਾਸ ਨੂੰ ਸੋਧੋ ਤਾਂ ਕਿ ਇਹ ਕੁਲਡਾਊਨ ਕਰ ਸਕੇ:

      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;
       }
      }
      

ਇਸ ਪੜਾਅ 'ਤੇ, ਤੁਹਾਡੇ ਗੇਮ ਵਿੱਚ ਕੁਝ ਕਾਰਗੁਜ਼ਾਰੀ ਹੈ! ਤੁਸੀਂ ਆਪਣੇ ਐਰੋ ਕੁੰਜੀਆਂ ਨਾਲ ਨੈਵੀਗੇਟ ਕਰ ਸਕਦੇ ਹੋ, ਸਪੇਸ ਬਾਰ ਨਾਲ ਲੇਜ਼ਰ ਚਲਾ ਸਕਦੇ ਹੋ, ਅਤੇ ਜਦੋਂ ਤੁਸੀਂ ਦੁਸ਼ਮਨਾਂ ਨੂੰ ਮਾਰਦੇ ਹੋ ਤਾਂ ਉਹ ਗਾਇਬ ਹੋ ਜਾਂਦੇ ਹਨ। ਸ਼ਾਬਾਸ਼!

---

🚀 ਚੁਣੌਤੀ

ਧਮਾਕਾ ਜੋੜੋ! ਸਪੇਸ ਆਰਟ ਰਿਪੋ ਵਿੱਚ ਗੇਮ ਐਸੈਟਾਂ ਨੂੰ ਵੇਖੋ ਅਤੇ ਜਦੋਂ ਲੇਜ਼ਰ ਐਲੀਅਨ ਨੂੰ ਮਾਰਦਾ ਹੈ ਤਾਂ ਧਮਾਕਾ ਜੋੜਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰੋ

ਪਾਠ-ਪ੍ਰਕ੍ਰਿਆ ਕਵਿਜ਼

ਪਾਠ-ਪ੍ਰਕ੍ਰਿਆ ਕਵਿਜ਼

ਸਮੀਖਿਆ ਅਤੇ ਸਵੈ-ਅਧਿਐਨ

ਆਪਣੇ ਗੇਮ ਵਿੱਚ ਹੁਣ ਤੱਕ ਦੇ ਅੰਤਰਾਲਾਂ ਨਾਲ ਪ੍ਰਯੋਗ ਕਰੋ। ਜਦੋਂ ਤੁਸੀਂ ਇਹਨਾਂ ਨੂੰ ਬਦਲਦੇ ਹੋ ਤਾਂ ਕੀ ਹੁੰਦਾ ਹੈ? ਜਾਵਾਸਕ੍ਰਿਪਟ ਟਾਈਮਿੰਗ ਇਵੈਂਟ ਬਾਰੇ ਹੋਰ ਪੜ੍ਹੋ।

ਅਸਾਈਨਮੈਂਟ

ਟਕਰਾਂ ਦੀ ਖੋਜ ਕਰੋ

---

ਅਸਵੀਕਰਤੀ:
ਇਹ ਦਸਤਾਵੇਜ਼ AI ਅਨੁਵਾਦ ਸੇਵਾ Co-op Translator ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਅਨੁਵਾਦ ਕੀਤਾ ਗਿਆ ਹੈ। ਜਦੋਂ ਕਿ ਅਸੀਂ ਸਹੀ ਹੋਣ ਦਾ ਯਤਨ ਕਰਦੇ ਹਾਂ, ਕਿਰਪਾ ਕਰਕੇ ਧਿਆਨ ਦਿਓ ਕਿ ਸਵੈਚਾਲਿਤ ਅਨੁਵਾਦਾਂ ਵਿੱਚ ਗਲਤੀਆਂ ਜਾਂ ਅਸੁੱਤੀਆਂ ਹੋ ਸਕਦੀਆਂ ਹਨ। ਇਸ ਦੀ ਮੂਲ ਭਾਸ਼ਾ ਵਿੱਚ ਮੌਜੂਦ ਮੂਲ ਦਸਤਾਵੇਜ਼ ਨੂੰ ਪ੍ਰਮਾਣਿਕ ਸਰੋਤ ਮੰਨਿਆ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ। ਮਹੱਤਵਪੂਰਨ ਜਾਣਕਾਰੀ ਲਈ, ਪੇਸ਼ੇਵਰ ਮਨੁੱਖੀ ਅਨੁਵਾਦ ਦੀ ਸਿਫਾਰਸ਼ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਇਸ ਅਨੁਵਾਦ ਦੇ ਪ੍ਰਯੋਗ ਤੋਂ ਪੈਦਾ ਹੋਣ ਵਾਲੇ ਕਿਸੇ ਵੀ ਗਲਤਫਹਿਮੀ ਜਾਂ ਗਲਤ ਵਿਆਖਿਆ ਲਈ ਅਸੀਂ ਜ਼ਿੰਮੇਵਾਰ ਨਹੀਂ ਹਾਂ।