24 ਘੰਟਿਆਂ ਵਿੱਚ ਜੰਗਾਲ ਖੇਡਣਾ: ਨਿੱਜੀ ਵਿਕਾਸ ਦਾ ਤਜਰਬਾ

ਇਸ ਲੇਖ ਵਿਚ ਮੈਂ ਰਸਟ ਵਿਚ ਇਕ ਛੋਟੀ ਜਿਹੀ ਖੇਡ ਨੂੰ ਵਿਕਸਤ ਕਰਨ ਦੇ ਆਪਣੇ ਨਿੱਜੀ ਅਨੁਭਵ ਬਾਰੇ ਗੱਲ ਕਰਾਂਗਾ. ਇੱਕ ਕੰਮ ਕਰਨ ਵਾਲਾ ਸੰਸਕਰਣ ਬਣਾਉਣ ਵਿੱਚ ਲਗਭਗ 24 ਘੰਟੇ ਲੱਗ ਗਏ (ਮੈਂ ਜਿਆਦਾਤਰ ਸ਼ਾਮ ਨੂੰ ਜਾਂ ਸ਼ਨੀਵਾਰ ਨੂੰ ਕੰਮ ਕਰਦਾ ਸੀ)। ਖੇਡ ਖਤਮ ਹੋਣ ਤੋਂ ਬਹੁਤ ਦੂਰ ਹੈ, ਪਰ ਮੈਨੂੰ ਲਗਦਾ ਹੈ ਕਿ ਅਨੁਭਵ ਫਲਦਾਇਕ ਹੋਵੇਗਾ. ਮੈਂ ਜੋ ਕੁਝ ਸਿੱਖਿਆ ਹੈ ਅਤੇ ਕੁਝ ਨਿਰੀਖਣ ਜੋ ਮੈਂ ਸ਼ੁਰੂ ਤੋਂ ਖੇਡ ਨੂੰ ਬਣਾਉਣ ਦੌਰਾਨ ਕੀਤੇ ਹਨ, ਉਹਨਾਂ ਨੂੰ ਸਾਂਝਾ ਕਰਾਂਗਾ।

ਸਕਿੱਲਬਾਕਸ ਸਿਫ਼ਾਰਿਸ਼ ਕਰਦਾ ਹੈ: ਦੋ ਸਾਲਾ ਪ੍ਰੈਕਟੀਕਲ ਕੋਰਸ "ਮੈਂ ਇੱਕ ਪ੍ਰੋ ਵੈੱਬ ਡਿਵੈਲਪਰ ਹਾਂ".

ਅਸੀਂ ਯਾਦ ਦਿਵਾਉਂਦੇ ਹਾਂ: "Habr" ਦੇ ਸਾਰੇ ਪਾਠਕਾਂ ਲਈ - "Habr" ਪ੍ਰਚਾਰ ਕੋਡ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਕਿਸੇ ਵੀ ਸਕਿੱਲਬਾਕਸ ਕੋਰਸ ਵਿੱਚ ਦਾਖਲਾ ਲੈਣ ਵੇਲੇ 10 ਰੂਬਲ ਦੀ ਛੋਟ।

ਜੰਗਾਲ ਕਿਉਂ?

ਮੈਂ ਇਸ ਭਾਸ਼ਾ ਨੂੰ ਚੁਣਿਆ ਹੈ ਕਿਉਂਕਿ ਮੈਂ ਇਸ ਬਾਰੇ ਬਹੁਤ ਸਾਰੀਆਂ ਚੰਗੀਆਂ ਗੱਲਾਂ ਸੁਣੀਆਂ ਹਨ ਅਤੇ ਮੈਂ ਇਸਨੂੰ ਖੇਡ ਵਿਕਾਸ ਵਿੱਚ ਹੋਰ ਅਤੇ ਵਧੇਰੇ ਪ੍ਰਸਿੱਧ ਹੁੰਦੇ ਦੇਖਦਾ ਹਾਂ। ਗੇਮ ਲਿਖਣ ਤੋਂ ਪਹਿਲਾਂ, ਮੇਰੇ ਕੋਲ ਰਸਟ ਵਿੱਚ ਸਧਾਰਨ ਐਪਲੀਕੇਸ਼ਨਾਂ ਨੂੰ ਵਿਕਸਤ ਕਰਨ ਦਾ ਬਹੁਤ ਘੱਟ ਅਨੁਭਵ ਸੀ। ਇਹ ਖੇਡ ਲਿਖਣ ਵੇਲੇ ਮੈਨੂੰ ਆਜ਼ਾਦੀ ਦੀ ਭਾਵਨਾ ਦੇਣ ਲਈ ਕਾਫ਼ੀ ਸੀ।

ਖੇਡ ਕਿਉਂ ਅਤੇ ਕਿਸ ਤਰ੍ਹਾਂ ਦੀ ਖੇਡ?

ਖੇਡਾਂ ਬਣਾਉਣਾ ਮਜ਼ੇਦਾਰ ਹੈ! ਮੈਂ ਚਾਹੁੰਦਾ ਹਾਂ ਕਿ ਹੋਰ ਕਾਰਨ ਹੁੰਦੇ, ਪਰ "ਘਰ" ਪ੍ਰੋਜੈਕਟਾਂ ਲਈ ਮੈਂ ਅਜਿਹੇ ਵਿਸ਼ਿਆਂ ਦੀ ਚੋਣ ਕਰਦਾ ਹਾਂ ਜੋ ਮੇਰੇ ਨਿਯਮਤ ਕੰਮ ਨਾਲ ਬਹੁਤ ਨੇੜਿਓਂ ਸਬੰਧਤ ਨਹੀਂ ਹਨ। ਇਹ ਕਿਹੜੀ ਖੇਡ ਹੈ? ਮੈਂ ਇੱਕ ਟੈਨਿਸ ਸਿਮੂਲੇਟਰ ਵਰਗਾ ਕੁਝ ਬਣਾਉਣਾ ਚਾਹੁੰਦਾ ਸੀ ਜੋ ਸਿਟੀਜ਼ ਸਕਾਈਲਾਈਨਜ਼, ਚਿੜੀਆਘਰ ਟਾਈਕੂਨ, ਜੇਲ੍ਹ ਆਰਕੀਟੈਕਟ ਅਤੇ ਖੁਦ ਟੈਨਿਸ ਨੂੰ ਜੋੜਦਾ ਹੈ। ਆਮ ਤੌਰ 'ਤੇ, ਇਹ ਇੱਕ ਟੈਨਿਸ ਅਕੈਡਮੀ ਬਾਰੇ ਇੱਕ ਖੇਡ ਬਣ ਗਈ ਜਿੱਥੇ ਲੋਕ ਖੇਡਣ ਲਈ ਆਉਂਦੇ ਹਨ।

ਤਕਨੀਕੀ ਸਿਖਲਾਈ

ਮੈਂ Rust ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਚਾਹੁੰਦਾ ਸੀ, ਪਰ ਮੈਨੂੰ ਬਿਲਕੁਲ ਨਹੀਂ ਪਤਾ ਸੀ ਕਿ ਇਸ ਨੂੰ ਸ਼ੁਰੂ ਕਰਨ ਲਈ ਕਿੰਨਾ ਕੁ ਆਧਾਰ ਕਾਰਜ ਲੱਗੇਗਾ। ਮੈਂ ਪਿਕਸਲ ਸ਼ੈਡਰ ਲਿਖਣਾ ਅਤੇ ਡਰੈਗ-ਐਨ-ਡ੍ਰੌਪ ਦੀ ਵਰਤੋਂ ਨਹੀਂ ਕਰਨਾ ਚਾਹੁੰਦਾ ਸੀ, ਇਸ ਲਈ ਮੈਂ ਸਭ ਤੋਂ ਲਚਕਦਾਰ ਹੱਲ ਲੱਭ ਰਿਹਾ ਸੀ।

ਮੈਨੂੰ ਲਾਭਦਾਇਕ ਸਰੋਤ ਮਿਲੇ ਹਨ ਜੋ ਮੈਂ ਤੁਹਾਡੇ ਨਾਲ ਸਾਂਝੇ ਕਰਦਾ ਹਾਂ:

• ਕੀ ਅਸੀਂ ਅਜੇ ਖੇਡ ਰਹੇ ਹਾਂ - ਖੇਡ ਦੇ ਵਿਕਾਸ ਲਈ ਲੋੜੀਂਦੇ ਜੰਗਾਲ ਤੱਤਾਂ ਦੀ ਸੂਚੀ;
• ਜੰਗਾਲ ਖੇਡ dev subreddit;
• ਮੁਫਤ ਪਿਕਸਲ ਕਲਾ।

ਮੈਂ ਕਈ Rust ਗੇਮ ਇੰਜਣਾਂ ਦੀ ਪੜਚੋਲ ਕੀਤੀ, ਆਖਰਕਾਰ ਪਿਸਟਨ ਅਤੇ ggez ਦੀ ਚੋਣ ਕੀਤੀ। ਪਿਛਲੇ ਪ੍ਰੋਜੈਕਟ 'ਤੇ ਕੰਮ ਕਰਦੇ ਹੋਏ ਮੈਂ ਉਨ੍ਹਾਂ ਨੂੰ ਮਿਲਿਆ। ਅੰਤ ਵਿੱਚ, ਮੈਂ ggez ਨੂੰ ਚੁਣਿਆ ਕਿਉਂਕਿ ਇਹ ਇੱਕ ਛੋਟੀ 2D ਗੇਮ ਨੂੰ ਲਾਗੂ ਕਰਨ ਲਈ ਵਧੇਰੇ ਢੁਕਵਾਂ ਜਾਪਦਾ ਸੀ. ਪਿਸਟਨ ਦੀ ਮਾਡਯੂਲਰ ਬਣਤਰ ਇੱਕ ਨਵੇਂ ਡਿਵੈਲਪਰ (ਜਾਂ ਕੋਈ ਵਿਅਕਤੀ ਜੋ ਪਹਿਲੀ ਵਾਰ ਜੰਗਾਲ ਨਾਲ ਕੰਮ ਕਰ ਰਿਹਾ ਹੈ) ਲਈ ਬਹੁਤ ਗੁੰਝਲਦਾਰ ਹੈ।

ਖੇਡ ਬਣਤਰ

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

ਸਭ ਕੁਝ ਸੋਚਣ ਤੋਂ ਬਾਅਦ, ਮੈਂ ਕੰਮ 'ਤੇ ਲੱਗ ਗਿਆ।

ਖੇਡ ਰਚਨਾ

ਸ਼ੁਰੂਆਤ: ਚੱਕਰ ਅਤੇ ਐਬਸਟਰੈਕਸ਼ਨ

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

// the game object trait
trait GameObject {
    fn update(&mut self, _ctx: &mut Context) -> GameResult<()>;
    fn draw(&mut self, ctx: &mut Context) -> GameResult<()>;
}
 
// a specific game object - Circle
struct Circle {
    position: Point2,
}
 
 impl Circle {
    fn new(position: Point2) -> Circle {
        Circle { position }
    }
}
impl GameObject for Circle {
    fn update(&mut self, _ctx: &mut Context) -> GameResult<()> {
        Ok(())
    }
    fn draw(&mut self, ctx: &mut Context) -> GameResult<()> {
        let circle =
            graphics::Mesh::new_circle(ctx, graphics::DrawMode::Fill, self.position, 100.0, 2.0)?;
 
         graphics::draw(ctx, &circle, na::Point2::new(0.0, 0.0), 0.0)?;
        Ok(())
    }
}

ਕੋਡ ਦੇ ਇਸ ਟੁਕੜੇ ਨੇ ਮੈਨੂੰ ਵਸਤੂਆਂ ਦੀ ਇੱਕ ਚੰਗੀ ਸੂਚੀ ਦਿੱਤੀ ਹੈ ਜੋ ਮੈਂ ਇੱਕ ਬਰਾਬਰ ਵਧੀਆ ਲੂਪ ਵਿੱਚ ਅਪਡੇਟ ਅਤੇ ਰੈਂਡਰ ਕਰ ਸਕਦਾ ਹਾਂ.

mpl event::EventHandler for MainState {
    fn update(&mut self, context: &mut Context) -> GameResult<()> {
        // Update all objects
        for object in self.objects.iter_mut() {
            object.update(context)?;
        }
 
        Ok(())
    }
 
    fn draw(&mut self, context: &mut Context) -> GameResult<()> {
        graphics::clear(context);
 
        // Draw all objects
        for object in self.objects.iter_mut() {
            object.draw(context)?;
        }
 
        graphics::present(context);
 
        Ok(())
    }
}

main.rs ਜ਼ਰੂਰੀ ਹੈ ਕਿਉਂਕਿ ਇਸ ਵਿੱਚ ਕੋਡ ਦੀਆਂ ਸਾਰੀਆਂ ਲਾਈਨਾਂ ਹਨ। ਮੈਂ ਫਾਈਲਾਂ ਨੂੰ ਵੱਖ ਕਰਨ ਅਤੇ ਡਾਇਰੈਕਟਰੀ ਢਾਂਚੇ ਨੂੰ ਅਨੁਕੂਲ ਬਣਾਉਣ ਵਿੱਚ ਥੋੜ੍ਹਾ ਸਮਾਂ ਬਿਤਾਇਆ। ਇਸ ਤੋਂ ਬਾਅਦ ਇਹ ਇਸ ਤਰ੍ਹਾਂ ਦਿਖਾਈ ਦਿੰਦਾ ਹੈ:
ਸਰੋਤ -> ਇਹ ਉਹ ਥਾਂ ਹੈ ਜਿੱਥੇ ਸਾਰੀਆਂ ਸੰਪਤੀਆਂ ਹਨ (ਚਿੱਤਰ)
ਝਰੋਖੇ
- ਇਕਾਈਆਂ
— game_object.rs
— circul.rs
— main.rs -> ਮੁੱਖ ਲੂਪ

ਲੋਕ, ਮੰਜ਼ਿਲਾਂ ਅਤੇ ਚਿੱਤਰ

ਅਗਲਾ ਕਦਮ ਇੱਕ ਵਿਅਕਤੀ ਗੇਮ ਆਬਜੈਕਟ ਬਣਾਉਣਾ ਅਤੇ ਚਿੱਤਰ ਲੋਡ ਕਰਨਾ ਹੈ। ਹਰ ਚੀਜ਼ ਨੂੰ 32*32 ਟਾਈਲਾਂ ਦੇ ਆਧਾਰ 'ਤੇ ਬਣਾਇਆ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ।

ਟੈਨਿਸ ਕੋਰਟਸ

ਇਹ ਅਧਿਐਨ ਕਰਨ ਤੋਂ ਬਾਅਦ ਕਿ ਟੈਨਿਸ ਕੋਰਟ ਕਿਸ ਤਰ੍ਹਾਂ ਦੇ ਦਿਖਾਈ ਦਿੰਦੇ ਹਨ, ਮੈਂ ਉਹਨਾਂ ਨੂੰ 4*2 ਟਾਈਲਾਂ ਤੋਂ ਬਣਾਉਣ ਦਾ ਫੈਸਲਾ ਕੀਤਾ। ਸ਼ੁਰੂ ਵਿੱਚ, ਇਸ ਆਕਾਰ ਦਾ ਚਿੱਤਰ ਬਣਾਉਣਾ, ਜਾਂ 8 ਵੱਖਰੀਆਂ ਟਾਇਲਾਂ ਨੂੰ ਇਕੱਠਾ ਕਰਨਾ ਸੰਭਵ ਸੀ। ਪਰ ਫਿਰ ਮੈਨੂੰ ਅਹਿਸਾਸ ਹੋਇਆ ਕਿ ਸਿਰਫ਼ ਦੋ ਵਿਲੱਖਣ ਟਾਈਲਾਂ ਦੀ ਲੋੜ ਸੀ, ਅਤੇ ਇੱਥੇ ਕਿਉਂ ਹੈ।

ਕੁੱਲ ਮਿਲਾ ਕੇ ਸਾਡੇ ਕੋਲ ਦੋ ਅਜਿਹੀਆਂ ਟਾਈਲਾਂ ਹਨ: 1 ਅਤੇ 2.

ਅਦਾਲਤ ਦੇ ਹਰ ਭਾਗ ਵਿੱਚ ਟਾਇਲ 1 ਜਾਂ ਟਾਈਲ 2 ਹੁੰਦੀ ਹੈ। ਇਹਨਾਂ ਨੂੰ ਆਮ ਵਾਂਗ ਰੱਖਿਆ ਜਾ ਸਕਦਾ ਹੈ ਜਾਂ 180 ਡਿਗਰੀ 'ਤੇ ਫਲਿਪ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ।

ਬੁਨਿਆਦੀ ਉਸਾਰੀ (ਅਸੈਂਬਲੀ) ਮੋਡ

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

ਪਰ ਸਾਨੂੰ ਅਜੇ ਵੀ ਯਾਦ ਰੱਖਣ ਦੀ ਜ਼ਰੂਰਤ ਹੈ ਕਿ 1 ਅਤੇ 2 ਦਾ ਕੀ ਅਰਥ ਹੈ, ਇਸਲਈ ਮੈਂ ਇਹ ਸਪੱਸ਼ਟ ਕਰਨ ਲਈ ਇੱਕ ਵਾਇਰਫ੍ਰੇਮ ਜੋੜਿਆ ਕਿ ਕਿਹੜੀ ਵਸਤੂ ਚੁਣੀ ਗਈ ਸੀ। ਇਹ ਇਸ ਤਰ੍ਹਾਂ ਦਿਖਾਈ ਦਿੰਦਾ ਹੈ।

ਆਰਕੀਟੈਕਚਰ ਅਤੇ ਰੀਫੈਕਟਰਿੰਗ ਸਵਾਲ

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

ਇਹ ਮੈਨੂੰ ਜਾਪਦਾ ਸੀ ਕਿ ਆਰਕੀਟੈਕਚਰ ਨੂੰ ਮੁੜ ਵਿਚਾਰ ਕਰਨ ਦੀ ਲੋੜ ਹੈ ਤਾਂ ਜੋ ਕੁਝ ਸੀਮਾਵਾਂ ਪ੍ਰਗਟ ਕੀਤੀਆਂ ਜਾਣ:

• ਆਪਣੇ ਆਪ ਨੂੰ ਪੇਸ਼ ਕਰਨ ਅਤੇ ਅੱਪਡੇਟ ਕਰਨ ਵਾਲੀ ਇਕਾਈ ਦਾ ਹੋਣਾ ਇੱਕ ਸਮੱਸਿਆ ਹੈ ਕਿਉਂਕਿ ਉਹ ਇਕਾਈ "ਜਾਣਨ" ਦੇ ਯੋਗ ਨਹੀਂ ਹੋਵੇਗੀ ਕਿ ਇਸਨੂੰ ਕੀ ਪੇਸ਼ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ - ਇੱਕ ਚਿੱਤਰ ਅਤੇ ਇੱਕ ਵਾਇਰਫ੍ਰੇਮ;
• ਵਿਅਕਤੀਗਤ ਇਕਾਈਆਂ (ਉਦਾਹਰਨ ਲਈ, is_build_mode ਜਾਇਦਾਦ ਜਾਂ ਵਿਵਹਾਰ ਰੈਂਡਰਿੰਗ) ਦੇ ਵਿਚਕਾਰ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਅਤੇ ਵਿਵਹਾਰ ਦਾ ਆਦਾਨ-ਪ੍ਰਦਾਨ ਕਰਨ ਲਈ ਇੱਕ ਸਾਧਨ ਦੀ ਘਾਟ। ਵਿਰਾਸਤ ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਸੰਭਵ ਹੋਵੇਗਾ, ਹਾਲਾਂਕਿ ਇਸ ਨੂੰ ਜੰਗਾਲ ਵਿੱਚ ਲਾਗੂ ਕਰਨ ਦਾ ਕੋਈ ਸਹੀ ਤਰੀਕਾ ਨਹੀਂ ਹੈ। ਮੈਨੂੰ ਅਸਲ ਵਿੱਚ ਕੀ ਲੋੜ ਸੀ ਖਾਕਾ ਸੀ;
• ਲੋਕਾਂ ਨੂੰ ਅਦਾਲਤਾਂ ਵਿਚ ਸੌਂਪਣ ਲਈ ਇਕਾਈਆਂ ਵਿਚਕਾਰ ਆਪਸੀ ਤਾਲਮੇਲ ਲਈ ਇੱਕ ਸਾਧਨ ਦੀ ਲੋੜ ਸੀ;
• ਇਕਾਈਆਂ ਆਪਣੇ ਆਪ ਵਿੱਚ ਡੇਟਾ ਅਤੇ ਤਰਕ ਦਾ ਮਿਸ਼ਰਣ ਸਨ ਜੋ ਜਲਦੀ ਕਾਬੂ ਤੋਂ ਬਾਹਰ ਹੋ ਗਈਆਂ।

ਮੈਂ ਕੁਝ ਹੋਰ ਖੋਜ ਕੀਤੀ ਅਤੇ ਆਰਕੀਟੈਕਚਰ ਦੀ ਖੋਜ ਕੀਤੀ ECS - ਇਕਾਈ ਕੰਪੋਨੈਂਟ ਸਿਸਟਮ, ਜੋ ਆਮ ਤੌਰ 'ਤੇ ਖੇਡਾਂ ਵਿੱਚ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। ਇੱਥੇ ECS ਦੇ ਫਾਇਦੇ ਹਨ:

• ਡੇਟਾ ਨੂੰ ਤਰਕ ਤੋਂ ਵੱਖ ਕੀਤਾ ਗਿਆ ਹੈ;
• ਵਿਰਾਸਤ ਦੀ ਬਜਾਏ ਰਚਨਾ;
• ਡਾਟਾ-ਕੇਂਦ੍ਰਿਤ ਆਰਕੀਟੈਕਚਰ।

ECS ਨੂੰ ਤਿੰਨ ਬੁਨਿਆਦੀ ਸੰਕਲਪਾਂ ਦੁਆਰਾ ਦਰਸਾਇਆ ਗਿਆ ਹੈ:

• ਇਕਾਈਆਂ - ਵਸਤੂ ਦੀ ਕਿਸਮ ਜਿਸਦਾ ਪਛਾਣਕਰਤਾ ਸੰਕੇਤ ਕਰਦਾ ਹੈ (ਇਹ ਇੱਕ ਖਿਡਾਰੀ, ਇੱਕ ਗੇਂਦ, ਜਾਂ ਕੁਝ ਹੋਰ ਹੋ ਸਕਦਾ ਹੈ);
• ਕੰਪੋਨੈਂਟਸ - ਇਕਾਈਆਂ ਉਹਨਾਂ ਤੋਂ ਬਣੀਆਂ ਹਨ। ਉਦਾਹਰਨ - ਰੈਂਡਰਿੰਗ ਕੰਪੋਨੈਂਟ, ਸਥਾਨ ਅਤੇ ਹੋਰ। ਇਹ ਡਾਟਾ ਵੇਅਰਹਾਊਸ ਹਨ;
• ਸਿਸਟਮ - ਉਹ ਆਬਜੈਕਟ ਅਤੇ ਕੰਪੋਨੈਂਟ ਦੋਵਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਨ, ਨਾਲ ਹੀ ਇਸ ਡੇਟਾ 'ਤੇ ਅਧਾਰਤ ਵਿਵਹਾਰ ਅਤੇ ਤਰਕ ਸ਼ਾਮਲ ਕਰਦੇ ਹਨ। ਇੱਕ ਉਦਾਹਰਨ ਇੱਕ ਰੈਂਡਰਿੰਗ ਸਿਸਟਮ ਹੈ ਜੋ ਰੈਂਡਰਿੰਗ ਕੰਪੋਨੈਂਟਸ ਦੇ ਨਾਲ ਸਾਰੀਆਂ ਇਕਾਈਆਂ ਦੁਆਰਾ ਦੁਹਰਾਉਂਦਾ ਹੈ ਅਤੇ ਰੈਂਡਰਿੰਗ ਕਰਦਾ ਹੈ।

ਇਸਦਾ ਅਧਿਐਨ ਕਰਨ ਤੋਂ ਬਾਅਦ, ਇਹ ਸਪੱਸ਼ਟ ਹੋ ਗਿਆ ਕਿ ECS ਹੇਠ ਲਿਖੀਆਂ ਸਮੱਸਿਆਵਾਂ ਨੂੰ ਹੱਲ ਕਰਦਾ ਹੈ:

• ਇਕਾਈਆਂ ਨੂੰ ਪ੍ਰਣਾਲੀਗਤ ਤੌਰ 'ਤੇ ਸੰਗਠਿਤ ਕਰਨ ਲਈ ਵਿਰਾਸਤ ਦੀ ਬਜਾਏ ਲੇਆਉਟ ਦੀ ਵਰਤੋਂ ਕਰਨਾ;
• ਕੰਟਰੋਲ ਸਿਸਟਮ ਦੁਆਰਾ ਕੋਡ ਉਲਝਣ ਤੋਂ ਛੁਟਕਾਰਾ ਪਾਉਣਾ;
• ਵਾਇਰਫ੍ਰੇਮ ਤਰਕ ਨੂੰ ਉਸੇ ਥਾਂ 'ਤੇ ਰੱਖਣ ਲਈ is_build_mode ਵਰਗੇ ਤਰੀਕਿਆਂ ਦੀ ਵਰਤੋਂ ਕਰਨਾ - ਰੈਂਡਰਿੰਗ ਸਿਸਟਮ ਵਿੱਚ।

ਈਸੀਐਸ ਲਾਗੂ ਕਰਨ ਤੋਂ ਬਾਅਦ ਅਜਿਹਾ ਹੋਇਆ ਹੈ।

ਸਰੋਤ -> ਇਹ ਉਹ ਥਾਂ ਹੈ ਜਿੱਥੇ ਸਾਰੀਆਂ ਸੰਪਤੀਆਂ ਹਨ (ਚਿੱਤਰ)
ਝਰੋਖੇ
- ਭਾਗ
—position.rs
— person.rs
— tennis_court.rs
— floor.rs
- wireframe.rs
— mouse_tracked.rs
- ਸਰੋਤ
—mouse.rs
- ਸਿਸਟਮ
— rendering.rs
— constants.rs
— utils.rs
— world_factory.rs -> ਵਿਸ਼ਵ ਫੈਕਟਰੀ ਫੰਕਸ਼ਨ
— main.rs -> ਮੁੱਖ ਲੂਪ

ਅਸੀਂ ਲੋਕਾਂ ਨੂੰ ਅਦਾਲਤਾਂ ਵਿਚ ਸੌਂਪਦੇ ਹਾਂ

ECS ਨੇ ਜ਼ਿੰਦਗੀ ਨੂੰ ਆਸਾਨ ਬਣਾ ਦਿੱਤਾ ਹੈ। ਹੁਣ ਮੇਰੇ ਕੋਲ ਇਕਾਈਆਂ ਵਿੱਚ ਡੇਟਾ ਜੋੜਨ ਅਤੇ ਉਸ ਡੇਟਾ ਦੇ ਅਧਾਰ ਤੇ ਤਰਕ ਜੋੜਨ ਦਾ ਇੱਕ ਯੋਜਨਾਬੱਧ ਤਰੀਕਾ ਸੀ। ਅਤੇ ਇਸ ਨੇ, ਬਦਲੇ ਵਿੱਚ, ਅਦਾਲਤਾਂ ਵਿੱਚ ਲੋਕਾਂ ਦੀ ਵੰਡ ਨੂੰ ਸੰਗਠਿਤ ਕਰਨਾ ਸੰਭਵ ਬਣਾਇਆ.

ਮੈਂ ਕੀ ਕੀਤਾ ਹੈ:

• ਵਿਅਕਤੀ ਨੂੰ ਸੌਂਪੀਆਂ ਅਦਾਲਤਾਂ ਬਾਰੇ ਡਾਟਾ ਜੋੜਿਆ ਗਿਆ;
• ਟੈਨਿਸ ਕੋਰਟ ਵਿੱਚ ਵੰਡੇ ਗਏ ਲੋਕਾਂ ਬਾਰੇ ਡਾਟਾ ਜੋੜਿਆ;
• ਕੋਰਟਚੂਜ਼ਿੰਗ ਸਿਸਟਮ ਸ਼ਾਮਲ ਕੀਤਾ ਗਿਆ ਹੈ, ਜੋ ਤੁਹਾਨੂੰ ਲੋਕਾਂ ਅਤੇ ਅਦਾਲਤਾਂ ਦਾ ਵਿਸ਼ਲੇਸ਼ਣ ਕਰਨ, ਉਪਲਬਧ ਅਦਾਲਤਾਂ ਦਾ ਪਤਾ ਲਗਾਉਣ ਅਤੇ ਉਹਨਾਂ ਨੂੰ ਖਿਡਾਰੀਆਂ ਨੂੰ ਵੰਡਣ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ;
• ਇੱਕ Person MovementSystem ਸ਼ਾਮਲ ਕੀਤਾ ਗਿਆ ਹੈ, ਜੋ ਅਦਾਲਤਾਂ ਨੂੰ ਸੌਂਪੇ ਗਏ ਲੋਕਾਂ ਦੀ ਭਾਲ ਕਰਦਾ ਹੈ, ਅਤੇ ਜੇਕਰ ਉਹ ਉੱਥੇ ਨਹੀਂ ਹਨ, ਤਾਂ ਲੋਕਾਂ ਨੂੰ ਉੱਥੇ ਭੇਜਦਾ ਹੈ ਜਿੱਥੇ ਉਹਨਾਂ ਨੂੰ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ।

ਸੰਖੇਪ

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

• ਜੰਗਾਲ ਤੁਹਾਨੂੰ ਉਹ ਦਿੰਦਾ ਹੈ ਜੋ ਤੁਹਾਨੂੰ ਚਾਹੀਦਾ ਹੈ;
• ਇਸ ਵਿੱਚ ਸ਼ਾਨਦਾਰ ਦਸਤਾਵੇਜ਼ ਹਨ, ਜੰਗਾਲ ਕਾਫ਼ੀ ਸ਼ਾਨਦਾਰ ਹੈ;
• ਇਕਸਾਰਤਾ ਠੰਡਾ ਹੈ;
• ਤੁਹਾਨੂੰ ਕਲੋਨਿੰਗ, ਨਕਲ ਜਾਂ ਹੋਰ ਸਮਾਨ ਕਿਰਿਆਵਾਂ ਦਾ ਸਹਾਰਾ ਲੈਣ ਦੀ ਲੋੜ ਨਹੀਂ ਹੈ, ਜੋ ਮੈਂ ਅਕਸਰ C++ ਵਿੱਚ ਕਰਦਾ ਸੀ;
• ਵਿਕਲਪ ਵਰਤਣ ਲਈ ਬਹੁਤ ਆਸਾਨ ਹਨ ਅਤੇ ਗਲਤੀਆਂ ਨੂੰ ਬਹੁਤ ਵਧੀਆ ਢੰਗ ਨਾਲ ਸੰਭਾਲਦੇ ਹਨ;
• ਜੇ ਪ੍ਰੋਜੈਕਟ ਕੰਪਾਇਲ ਕੀਤਾ ਜਾ ਸਕਦਾ ਸੀ, ਤਾਂ 99% ਸਮਾਂ ਇਹ ਕੰਮ ਕਰਦਾ ਹੈ, ਅਤੇ ਬਿਲਕੁਲ ਉਸੇ ਤਰ੍ਹਾਂ ਜਿਵੇਂ ਇਹ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ। ਮੈਨੂੰ ਲਗਦਾ ਹੈ ਕਿ ਕੰਪਾਈਲਰ ਗਲਤੀ ਸੁਨੇਹੇ ਸਭ ਤੋਂ ਵਧੀਆ ਹਨ ਜੋ ਮੈਂ ਦੇਖਿਆ ਹੈ.

ਜੰਗਾਲ ਵਿੱਚ ਖੇਡ ਵਿਕਾਸ ਹੁਣੇ ਹੀ ਸ਼ੁਰੂ ਹੈ. ਪਰ ਪਹਿਲਾਂ ਹੀ ਇੱਕ ਸਥਿਰ ਅਤੇ ਕਾਫ਼ੀ ਵੱਡਾ ਭਾਈਚਾਰਾ ਹਰ ਕਿਸੇ ਲਈ ਜੰਗ ਨੂੰ ਖੋਲ੍ਹਣ ਲਈ ਕੰਮ ਕਰ ਰਿਹਾ ਹੈ। ਇਸ ਲਈ, ਮੈਂ ਭਾਸ਼ਾ ਦੇ ਭਵਿੱਖ ਨੂੰ ਆਸ਼ਾਵਾਦ ਨਾਲ ਵੇਖਦਾ ਹਾਂ, ਸਾਡੇ ਸਾਂਝੇ ਕੰਮ ਦੇ ਨਤੀਜਿਆਂ ਦੀ ਉਡੀਕ ਕਰਦਾ ਹਾਂ।

ਸਕਿੱਲਬਾਕਸ ਸਿਫ਼ਾਰਿਸ਼ ਕਰਦਾ ਹੈ:

• Onlineਨਲਾਈਨ ਕੋਰਸ "ਪ੍ਰੋਫੈਸ਼ਨ ਫਰੰਟਐਂਡ ਡਿਵੈਲਪਰ".
• ਪ੍ਰੈਕਟੀਕਲ ਕੋਰਸ "ਮੋਬਾਈਲ ਡਿਵੈਲਪਰ ਪ੍ਰੋ".
• ਪ੍ਰੈਕਟੀਕਲ ਸਾਲ ਦਾ ਕੋਰਸ "0 ਤੋਂ PRO ਤੱਕ PHP ਡਿਵੈਲਪਰ".

ਸਰੋਤ: www.habr.com