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 ਆਬਜੈਕਟ ਵਿੱਚ ਤਿੰਨ ਕਾਂਸਟੈਂਟਸ ਜੋੜੋ:

       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 ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਅਨੁਵਾਦ ਕੀਤਾ ਗਿਆ ਹੈ। ਜਦੋਂ ਕਿ ਅਸੀਂ ਸਹੀਤਾ ਲਈ ਯਤਨਸ਼ੀਲ ਹਾਂ, ਕਿਰਪਾ ਕਰਕੇ ਧਿਆਨ ਦਿਓ ਕਿ ਸਵੈਚਾਲਿਤ ਅਨੁਵਾਦਾਂ ਵਿੱਚ ਗਲਤੀਆਂ ਜਾਂ ਅਸੁਚਨਾਵਾਂ ਹੋ ਸਕਦੀਆਂ ਹਨ। ਮੂਲ ਦਸਤਾਵੇਜ਼ ਨੂੰ ਇਸਦੀ ਮੂਲ ਭਾਸ਼ਾ ਵਿੱਚ ਅਧਿਕਾਰਤ ਸਰੋਤ ਮੰਨਿਆ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ। ਮਹੱਤਵਪੂਰਨ ਜਾਣਕਾਰੀ ਲਈ, ਪੇਸ਼ੇਵਰ ਮਨੁੱਖੀ ਅਨੁਵਾਦ ਦੀ ਸਿਫਾਰਸ਼ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਇਸ ਅਨੁਵਾਦ ਦੀ ਵਰਤੋਂ ਤੋਂ ਪੈਦਾ ਹੋਣ ਵਾਲੇ ਕਿਸੇ ਵੀ ਗਲਤਫਹਿਮੀ ਜਾਂ ਗਲਤ ਵਿਆਖਿਆ ਲਈ ਅਸੀਂ ਜ਼ਿੰਮੇਵਾਰ ਨਹੀਂ ਹਾਂ।