លេង Rust ក្នុងរយៈពេល 24 ម៉ោង៖ បទពិសោធន៍អភិវឌ្ឍន៍ផ្ទាល់ខ្លួន

នៅក្នុងអត្ថបទនេះខ្ញុំនឹងនិយាយអំពីបទពិសោធន៍ផ្ទាល់ខ្លួនរបស់ខ្ញុំក្នុងការអភិវឌ្ឍន៍ហ្គេមតូចមួយនៅក្នុង Rust ។ វាត្រូវចំណាយពេលប្រហែល 24 ម៉ោងដើម្បីបង្កើតកំណែធ្វើការ (ភាគច្រើនខ្ញុំធ្វើការនៅពេលល្ងាច ឬថ្ងៃចុងសប្តាហ៍)។ ហ្គេមនេះគឺនៅឆ្ងាយពីការបញ្ចប់ ប៉ុន្តែខ្ញុំគិតថាបទពិសោធន៍នឹងផ្តល់រង្វាន់។ ខ្ញុំនឹងចែករំលែកនូវអ្វីដែលខ្ញុំបានរៀន និងការសង្កេតមួយចំនួនដែលខ្ញុំបានធ្វើនៅពេលបង្កើតហ្គេមតាំងពីដំបូង។

Skillbox ណែនាំ៖ វគ្គសិក្សាជាក់ស្តែងរយៈពេលពីរឆ្នាំ "ខ្ញុំជាអ្នកបង្កើតគេហទំព័រ PRO".

យើងរំលឹក៖ សម្រាប់អ្នកអានទាំងអស់នៃ "Habr" - ការបញ្ចុះតម្លៃ 10 rubles នៅពេលចុះឈ្មោះក្នុងវគ្គសិក្សា Skillbox ណាមួយដោយប្រើលេខកូដផ្សព្វផ្សាយ "Habr" ។

ហេតុអ្វីបានជាច្រេះ?

ខ្ញុំបានជ្រើសរើសភាសានេះ ដោយសារខ្ញុំបានលឺរឿងល្អៗជាច្រើនអំពីវា ហើយខ្ញុំឃើញថាវាកាន់តែមានប្រជាប្រិយភាពនៅក្នុងការអភិវឌ្ឍន៍ហ្គេម។ មុនពេលសរសេរហ្គេម ខ្ញុំមានបទពិសោធន៍តិចតួចក្នុងការអភិវឌ្ឍន៍កម្មវិធីសាមញ្ញនៅក្នុង Rust ។ នេះគឺគ្រប់គ្រាន់ដើម្បីផ្តល់ឱ្យខ្ញុំនូវអារម្មណ៍នៃសេរីភាពនៅពេលសរសេរហ្គេម។

ហេតុអ្វីបានជាហ្គេម និងប្រភេទហ្គេមអ្វី?

ការបង្កើតហ្គេមគឺសប្បាយ! ខ្ញុំប្រាថ្នាថាមានហេតុផលច្រើនទៀត ប៉ុន្តែសម្រាប់គម្រោង "ផ្ទះ" ខ្ញុំជ្រើសរើសប្រធានបទដែលមិនទាក់ទងជិតស្និទ្ធពេកជាមួយការងារធម្មតារបស់ខ្ញុំ។ តើនេះជាហ្គេមអ្វី? ខ្ញុំ​ចង់​បង្កើត​អ្វី​មួយ​ដូច​ជា​ម៉ាស៊ីន​ក្លែង​ធ្វើ​កីឡា​វាយ​កូន​បាល់​ដែល​រួម​បញ្ចូល​ទាំង Cities Skylines, Zoo Tycoon, Prison Architect និង​កីឡា​វាយ​កូនបាល់​ខ្លួន​ឯង។ ជាទូទៅ វា​បាន​ក្លាយ​ជា​ហ្គេម​អំពី​សាលា​វាយ​កូន​បាល់​ដែល​មាន​មនុស្ស​មក​លេង។

ការបណ្តុះបណ្តាលបច្ចេកទេស

ខ្ញុំ​ចង់​ប្រើ Rust ប៉ុន្តែ​ខ្ញុំ​មិន​ដឹង​ច្បាស់​ថា​តើ​វា​ត្រូវ​ចំណាយ​ពេល​ប៉ុន្មាន​ដើម្បី​ចាប់​ផ្តើម។ ខ្ញុំមិនចង់សរសេរ pixel shaders និងប្រើ drag-n-drop ទេ ដូច្នេះខ្ញុំកំពុងស្វែងរកដំណោះស្រាយដែលអាចបត់បែនបានបំផុត។

ខ្ញុំបានរកឃើញធនធានមានប្រយោជន៍ ដែលខ្ញុំចែករំលែកជាមួយអ្នក៖

• តើយើងកំពុងលេងនៅឡើយ - បញ្ជីនៃធាតុ Rust ដែលត្រូវការសម្រាប់ការអភិវឌ្ឍន៍ហ្គេម។
• ហ្គេម Rust dev subreddit;
• សិល្បៈភីកសែលឥតគិតថ្លៃ។

ខ្ញុំបានរុករកម៉ាស៊ីនហ្គេម Rust ជាច្រើន ទីបំផុតជ្រើសរើស Piston និង ggez។ ខ្ញុំបានជួបពួកគេពេលកំពុងធ្វើការលើគម្រោងមុន។ នៅទីបញ្ចប់ ខ្ញុំបានជ្រើសរើស ggez ព្រោះវាហាក់ដូចជាសមរម្យជាងសម្រាប់ការអនុវត្តហ្គេម 2D តូចមួយ។ រចនាសម្ព័ន្ធម៉ូឌុលរបស់ Piston គឺស្មុគស្មាញពេកសម្រាប់អ្នកអភិវឌ្ឍន៍ថ្មីថ្មោង (ឬអ្នកដែលធ្វើការជាមួយ Rust ជាលើកដំបូង) ។

រចនាសម្ព័ន្ធហ្គេម

ខ្ញុំបានចំណាយពេលខ្លះគិតអំពីស្ថាបត្យកម្មនៃគម្រោង។ ជំហានដំបូងគឺធ្វើឱ្យ "ដី" ប្រជាជននិងទីលានវាយកូនបាល់។ ប្រជាជនត្រូវរើជុំវិញតុលាការ ហើយរង់ចាំ។ អ្នកលេងត្រូវតែមានជំនាញដែលប្រសើរឡើងតាមពេលវេលា។ លើសពីនេះ វាគួរតែមានកម្មវិធីនិពន្ធដែលអនុញ្ញាតឱ្យអ្នកបន្ថែមមនុស្សថ្មី និងតុលាការ ប៉ុន្តែវាមិនគិតថ្លៃទៀតទេ។

ដោយបានគិតគ្រប់យ៉ាង ខ្ញុំបានទៅធ្វើការ។

ការបង្កើតហ្គេម

ការចាប់ផ្តើម៖ រង្វង់ និងអរូបី

ខ្ញុំបានយកឧទាហរណ៍ពី 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 គឺចាំបាច់ព្រោះវាមានគ្រប់បន្ទាត់នៃកូដ។ ខ្ញុំបានចំណាយពេលបន្តិចដើម្បីបំបែកឯកសារ និងបង្កើនប្រសិទ្ធភាពរចនាសម្ព័ន្ធថត។ នេះជាអ្វីដែលមើលទៅបន្ទាប់ពីនោះ៖
ធនធាន -> នេះគឺជាកន្លែងដែលទ្រព្យសម្បត្តិទាំងអស់ស្ថិតនៅ (រូបភាព)
src
- អង្គភាព
- game_object.rs
— រង្វង់.rs
- main.rs -> រង្វិលជុំមេ

មនុស្ស ជាន់ និងរូបភាព

ជំហានបន្ទាប់គឺបង្កើតវត្ថុហ្គេមបុគ្គល ហើយផ្ទុករូបភាព។ អ្វីគ្រប់យ៉ាងគួរតែត្រូវបានសាងសង់នៅលើមូលដ្ឋាននៃ 32 * 32 ក្បឿង។

តុលាការកីឡាវាយកូនបាល់

បន្ទាប់​ពី​បាន​សិក្សា​ពី​អ្វី​ដែល​ទីលាន​វាយ​កូន​បាល់​មើល​ទៅ​ដូច​ជា ខ្ញុំ​បាន​សម្រេច​ចិត្ត​ធ្វើ​វា​ពី​ក្បឿង 4*2។ ដំបូង​គេ​អាច​ធ្វើ​ជា​រូប​ទំហំ​នេះ​បាន ឬ​អាច​ដាក់​ក្រឡា​ចំនួន 8 ដាច់​ពី​គ្នា។ ប៉ុន្តែបន្ទាប់មកខ្ញុំបានដឹងថាមានតែក្បឿងពីរប៉ុណ្ណោះដែលត្រូវការ ហើយនេះជាមូលហេតុ។

សរុបមកយើងមានក្រឡាពីរបែបនេះ៖ ១ និង ២។

ផ្នែកនីមួយៗនៃតុលាការមានក្រឡាក្បឿង 1 ឬ ក្បឿង 2 ។ ពួកវាអាចត្រូវបានដាក់ចេញជាធម្មតា ឬត្រឡប់ 180 ដឺក្រេ។

របៀបសាងសង់មូលដ្ឋាន (ការជួបប្រជុំគ្នា)

បន្ទាប់​ពី​ខ្ញុំ​អាច​សម្រេច​បាន​ការ​បង្ហាញ​គេហទំព័រ មនុស្ស និង​ផែនទី ខ្ញុំ​បាន​ដឹង​ថា​របៀប​ដំឡើង​មូលដ្ឋាន​ក៏​ត្រូវ​ការ​ដែរ។ ខ្ញុំបានអនុវត្តវាដូចនេះ៖ នៅពេលចុចប៊ូតុង វត្ថុត្រូវបានជ្រើសរើស ហើយការចុចដាក់វានៅកន្លែងដែលចង់បាន។ ដូច្នេះ ប៊ូតុង 1 អនុញ្ញាតឱ្យអ្នកជ្រើសរើសតុលាការ ហើយប៊ូតុង 2 អនុញ្ញាតឱ្យអ្នកជ្រើសរើសអ្នកលេង។

ប៉ុន្តែយើងនៅតែត្រូវចាំថា 1 និង 2 មានន័យយ៉ាងណា ដូច្នេះខ្ញុំបានបន្ថែម wireframe ដើម្បីឱ្យវាច្បាស់ថាតើវត្ថុមួយណាត្រូវបានជ្រើសរើស។ នេះជាអ្វីដែលវាមើលទៅ។

សំណួរស្ថាបត្យកម្ម និងការកែលម្អ

ឥឡូវនេះខ្ញុំមានវត្ថុហ្គេមជាច្រើន៖ មនុស្ស តុលាការ និងជាន់។ ប៉ុន្តែដើម្បីឱ្យ wireframes ដំណើរការ អង្គភាពវត្ថុនីមួយៗចាំបាច់ត្រូវប្រាប់ថាតើវត្ថុខ្លួនឯងស្ថិតនៅក្នុងរបៀបបង្ហាញ ឬថាតើស៊ុមត្រូវបានគូរយ៉ាងសាមញ្ញ។ នេះមិនងាយស្រួលទេ។

វាហាក់ដូចជាខ្ញុំថា ស្ថាបត្យកម្មចាំបាច់ត្រូវគិតឡើងវិញតាមរបៀបដែលបង្ហាញពីដែនកំណត់មួយចំនួន៖

• ការមានអង្គភាពដែលបង្ហាញ និងអាប់ដេតខ្លួនឯងគឺជាបញ្ហាមួយ ពីព្រោះអង្គភាពនោះនឹងមិនអាច "ដឹង" នូវអ្វីដែលវាត្រូវបានសន្មត់ថាត្រូវបង្ហាញ - រូបភាព និងស៊ុមខ្សែ។
• កង្វះឧបករណ៍សម្រាប់ផ្លាស់ប្តូរលក្ខណៈសម្បត្តិ និងអាកប្បកិរិយារវាងអង្គភាពនីមួយៗ (ឧទាហរណ៍ លក្ខណៈសម្បត្តិ is_build_mode ឬការបង្ហាញអាកប្បកិរិយា)។ វានឹងអាចប្រើមរតកបាន ទោះបីជាមិនមានវិធីត្រឹមត្រូវដើម្បីអនុវត្តវានៅក្នុង Rust ក៏ដោយ។ អ្វីដែលខ្ញុំត្រូវការគឺប្លង់។
• ឧបករណ៍សម្រាប់អន្តរកម្មរវាងអង្គភាពគឺចាំបាច់ដើម្បីចាត់តាំងមនុស្សទៅតុលាការ។
• អង្គភាពខ្លួនគេគឺជាល្បាយនៃទិន្នន័យ និងតក្កវិជ្ជាដែលចេញពីការគ្រប់គ្រងយ៉ាងឆាប់រហ័ស។

ខ្ញុំ​បាន​ធ្វើ​ការ​ស្រាវ​ជ្រាវ​មួយ​ចំនួន​បន្ថែម​ទៀត ហើយ​បាន​រក​ឃើញ​ស្ថាបត្យកម្ម ECS - ប្រព័ន្ធសមាសភាគអង្គភាពដែលត្រូវបានប្រើប្រាស់ជាទូទៅនៅក្នុងហ្គេម។ នេះគឺជាអត្ថប្រយោជន៍របស់ ECS៖

• ទិន្នន័យត្រូវបានបំបែកចេញពីតក្កវិជ្ជា;
• សមាសភាពជំនួសឱ្យមរតក;
• ស្ថាបត្យកម្មដែលផ្តោតលើទិន្នន័យ។

ECS ត្រូវបានកំណត់លក្ខណៈដោយគោលគំនិតជាមូលដ្ឋានចំនួនបី៖

• អង្គភាព - ប្រភេទនៃវត្ថុដែលអ្នកកំណត់អត្តសញ្ញាណសំដៅទៅលើ (វាអាចជាអ្នកលេង បាល់ ឬអ្វីផ្សេងទៀត);
• សមាសធាតុ - អង្គភាពត្រូវបានបង្កើតឡើងពីពួកគេ។ ឧទាហរណ៍ - បង្ហាញសមាសភាគ ទីតាំង និងផ្សេងៗទៀត។ ទាំងនេះគឺជាឃ្លាំងទិន្នន័យ;
• ប្រព័ន្ធ - ពួកគេប្រើទាំងវត្ថុ និងសមាសធាតុ បូករួមទាំងឥរិយាបទ និងតក្កវិជ្ជាដែលផ្អែកលើទិន្នន័យនេះ។ ឧទាហរណ៍​មួយ​គឺ​ជា​ប្រព័ន្ធ​បង្ហាញ​ដែល​ធ្វើ​ឡើង​វិញ​តាម​គ្រប់​អង្គភាព​ទាំងអស់​ដែល​មាន​សមាសធាតុ​បង្ហាញ​ ហើយ​ធ្វើ​ការ​បង្ហាញ។

បន្ទាប់ពីសិក្សាវាច្បាស់ថា ECS ដោះស្រាយបញ្ហាដូចខាងក្រោមៈ

• ការប្រើប្រាស់ប្លង់ជំនួសឱ្យមរតកដើម្បីរៀបចំអង្គភាពជាប្រព័ន្ធ។
• កម្ចាត់ភាពច្របូកច្របល់តាមរយៈប្រព័ន្ធគ្រប់គ្រង;
• ដោយប្រើវិធីសាស្រ្តដូចជា is_build_mode ដើម្បីរក្សាតក្កវិជ្ជា wireframe នៅកន្លែងដដែល - នៅក្នុងប្រព័ន្ធបង្ហាញ។

នេះជាអ្វីដែលបានកើតឡើងបន្ទាប់ពីអនុវត្ត ECS ។

ធនធាន -> នេះគឺជាកន្លែងដែលទ្រព្យសម្បត្តិទាំងអស់ស្ថិតនៅ (រូបភាព)
src
- សមាសធាតុ
— 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 បានធ្វើឱ្យជីវិតកាន់តែងាយស្រួល។ ឥឡូវនេះខ្ញុំមានវិធីជាប្រព័ន្ធដើម្បីបន្ថែមទិន្នន័យទៅអង្គភាព និងបន្ថែមតក្កវិជ្ជាដោយផ្អែកលើទិន្នន័យនោះ។ ហើយនេះ, នៅក្នុងវេន, ធ្វើឱ្យវាអាចធ្វើទៅបានដើម្បីរៀបចំការចែកចាយប្រជាជនក្នុងចំណោមតុលាការ។

តើខ្ញុំបានធ្វើអ្វីខ្លះ៖

• បន្ថែមទិន្នន័យអំពីតុលាការដែលបានកំណត់ទៅបុគ្គល;
• បានបន្ថែមទិន្នន័យអំពីមនុស្សដែលបានចែកចាយទៅ TennisCourt;
• បានបន្ថែមប្រព័ន្ធ CourtChoosingSystem ដែលអនុញ្ញាតឱ្យអ្នកវិភាគមនុស្ស និងតុលាការ រកឃើញតុលាការដែលមាន និងចែកចាយអ្នកលេងឱ្យពួកគេ។
• បានបន្ថែមប្រព័ន្ធ PersonMovementSystem ដែលស្វែងរកមនុស្សដែលត្រូវបានប្រគល់ឱ្យតុលាការ ហើយប្រសិនបើពួកគេមិននៅទីនោះ នោះបញ្ជូនមនុស្សទៅកន្លែងដែលពួកគេត្រូវការ។

សង្ខេប

ខ្ញុំពិតជារីករាយក្នុងការធ្វើការលើហ្គេមដ៏សាមញ្ញនេះ។ លើសពីនេះទៅទៀត ខ្ញុំរីករាយដែលខ្ញុំបានប្រើ Rust ដើម្បីសរសេរវា ពីព្រោះ៖

• ច្រែះផ្តល់ឱ្យអ្នកនូវអ្វីដែលអ្នកត្រូវការ;
• វា​មាន​ឯកសារ​ល្អ​ឥត​ខ្ចោះ, Rust គឺ​ជា​ស្រស់​ស្អាត​ណាស់;
• ភាពស្ថិតស្ថេរគឺត្រជាក់;
• អ្នកមិនចាំបាច់ងាកទៅរកការក្លូន ការចម្លង ឬសកម្មភាពស្រដៀងគ្នាផ្សេងទៀត ដែលខ្ញុំបានធ្វើជាញឹកញាប់នៅក្នុង C++ ។
• ជម្រើសគឺងាយស្រួលប្រើ និងដោះស្រាយកំហុសបានយ៉ាងល្អ។
• ប្រសិនបើគម្រោងអាចចងក្រងបាន នោះ 99% នៃពេលវេលាដែលវាដំណើរការ ហើយពិតជាដូចដែលវាគួរតែ។ ខ្ញុំគិតថាសារកំហុសអ្នកចងក្រងគឺល្អបំផុតដែលខ្ញុំបានឃើញ។

ការអភិវឌ្ឍន៍ហ្គេមនៅក្នុង Rust ទើបតែចាប់ផ្តើម។ ប៉ុន្តែ​មាន​សហគមន៍​ដ៏​ធំ​មួយ​ដែល​មាន​ស្ថិរភាព និង​យុត្តិធម៌​កំពុង​ធ្វើ​ការ​ដើម្បី​បើក Rust ដល់​អ្នក​រាល់​គ្នា។ ដូច្នេះហើយ ខ្ញុំមើលទៅអនាគតនៃភាសាដោយសុទិដ្ឋិនិយម ដោយទន្ទឹងរង់ចាំលទ្ធផលនៃការងាររួមរបស់យើង។

Skillbox ណែនាំ៖

• វគ្គសិក្សាតាមអ៊ីនធឺណិត "អ្នកអភិវឌ្ឍន៍មុខជំនាញ".
• វគ្គសិក្សាជាក់ស្តែង "អ្នកអភិវឌ្ឍន៍ចល័ត PRO".
• វគ្គសិក្សាជាក់ស្តែងឆ្នាំ "អ្នកអភិវឌ្ឍន៍ PHP ពី 0 ដល់ PRO".

ប្រភព: www.habr.com