Rust-ის თამაში 24 საათში: პირადი განვითარების გამოცდილება

ამ სტატიაში ვისაუბრებ Rust-ში პატარა თამაშის შემუშავების ჩემს პირად გამოცდილებაზე. სამუშაო ვერსიის შექმნას დაახლოებით 24 საათი დასჭირდა (ძირითადად საღამოობით ან შაბათ-კვირას ვმუშაობდი). თამაში შორს არის დასრულებამდე, მაგრამ ვფიქრობ, რომ გამოცდილება დამაკმაყოფილებელი იქნება. მე გაგიზიარებთ იმას, რაც ვისწავლე და რამდენიმე დაკვირვებას, რაც გავაკეთე თამაშის თავიდანვე აგებისას.

Skillbox გირჩევთ: ორწლიანი პრაქტიკული კურსი "მე ვარ PRO ვებ დეველოპერი".

შეგახსენებთ: "Habr"-ის ყველა მკითხველისთვის - ფასდაკლება 10 რუბლიდან Skillbox-ის ნებისმიერ კურსზე ჩარიცხვისას "Habr" სარეკლამო კოდის გამოყენებით.

რატომ Rust?

მე ავირჩიე ეს ენა, რადგან მის შესახებ ბევრი კარგი რამ მსმენია და ვხედავ, რომ ის სულ უფრო პოპულარული ხდება თამაშების განვითარებაში. თამაშის დაწერამდე, მე მქონდა მცირე გამოცდილება Rust-ში მარტივი აპლიკაციების შემუშავებაში. ეს საკმარისი იყო იმისთვის, რომ თამაშის წერისას თავისუფლების განცდა მომეცა.

რატომ თამაში და როგორი თამაში?

თამაშების გაკეთება სახალისოა! ვისურვებდი, რომ მეტი მიზეზი ყოფილიყო, მაგრამ „სახლის“ პროექტებისთვის მე ვირჩევ თემებს, რომლებიც არც თუ ისე მჭიდრო კავშირშია ჩემს რეგულარულ სამუშაოსთან. ეს რა თამაშია? მინდოდა ჩოგბურთის სიმულატორის მსგავსი რამ გამეკეთებინა, რომელიც აერთიანებს Cities Skylines-ს, Zoo Tycoon-ს, Prison Architect-ს და თავად ჩოგბურთს. ზოგადად, ეს იყო თამაში ჩოგბურთის აკადემიაზე, სადაც ხალხი სათამაშოდ მოდის.

ტექნიკური მომზადება

მინდოდა გამომეყენებინა Rust, მაგრამ ზუსტად არ ვიცოდი, რამდენი საფუძველი დასჭირდებოდა დასაწყებად. არ მინდოდა პიქსელების ჩრდილების დაწერა და drag-n-drop გამოყენება, ამიტომ ვეძებდი ყველაზე მოქნილ გადაწყვეტილებებს.

ვიპოვე სასარგებლო რესურსები, რომლებსაც გაგიზიარებთ:

• კიდევ ვთამაშობთ — თამაშის განვითარებისთვის საჭირო Rust ელემენტების სია;
• Rust თამაშის dev subreddit;
• უფასო პიქსელის ხელოვნება.

მე გამოვიკვლიე რამდენიმე Rust თამაშის ძრავა, საბოლოოდ ავირჩიე Piston და ggez. მათ წინა პროექტზე მუშაობისას შევხვდი. საბოლოოდ, მე ავირჩიე ggez, რადგან ის უფრო შესაფერისი ჩანდა პატარა 2D თამაშის განსახორციელებლად. პისტონის მოდულური სტრუქტურა ძალიან რთულია დამწყები დეველოპერისთვის (ან მათთვის, ვინც პირველად მუშაობს 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
- წრე.რს
— main.rs -> main loop

ხალხი, იატაკი და სურათები

შემდეგი ნაბიჯი არის Person თამაშის ობიექტის შექმნა და სურათების ჩატვირთვა. ყველაფერი უნდა აშენდეს 32*32 ფილაზე.

Ტენისის კორტები

მას შემდეგ რაც შევისწავლე როგორ გამოიყურება ჩოგბურთის კორტები, გადავწყვიტე მათი დამზადება 4*2 ფილებისგან. თავდაპირველად შესაძლებელი იყო ამ ზომის გამოსახულების დამზადება, ან 8 ცალკე ფილა. მაგრამ შემდეგ მივხვდი, რომ მხოლოდ ორი უნიკალური ფილა იყო საჭირო და აი რატომ.

საერთო ჯამში გვაქვს ორი ასეთი ფილა: 1 და 2.

კორტის თითოეული განყოფილება შედგება ფილა 1 ან ფილა 2. ისინი შეიძლება განლაგდეს ჩვეულებრივად ან გადატრიალდეს 180 გრადუსით.

ძირითადი კონსტრუქციის (აწყობის) რეჟიმი

მას შემდეგ რაც მოვახერხე საიტების, ადამიანებისა და რუქების რენდერირება, მივხვდი, რომ ასამბლეის ძირითადი რეჟიმიც იყო საჭირო. მე ასე განვახორციელე: ღილაკზე დაჭერისას ობიექტი ირჩევა და დაწკაპუნება სასურველ ადგილას ათავსებს. ასე რომ, ღილაკი 1 გაძლევთ საშუალებას აირჩიოთ კორტი, ხოლო ღილაკი 2 გაძლევთ მოთამაშის არჩევის საშუალებას.

მაგრამ ჩვენ მაინც უნდა გვახსოვდეს, რას ნიშნავს 1 და 2, ამიტომ დავამატე მავთულის ჩარჩო, რათა გამეგო, რომელი ობიექტი იყო არჩეული. ასე გამოიყურება.

არქიტექტურისა და რეფაქტორირების კითხვები

ახლა მაქვს რამდენიმე სათამაშო ობიექტი: ხალხი, კორტები და იატაკები. მაგრამ იმისათვის, რომ მავთულხლართებმა იმუშაონ, თითოეულ ობიექტს უნდა აცნობოს, არის თუ არა თავად ობიექტები დემონსტრაციის რეჟიმში, თუ ჩარჩო უბრალოდ დახატულია. ეს არ არის ძალიან მოსახერხებელი.

მეჩვენებოდა, რომ არქიტექტურას სჭირდებოდა გადახედვა ისე, რომ გამოავლინა გარკვეული შეზღუდვები:

• ერთეულის ქონა, რომელიც ასახავს და განაახლებს თავისთავად, პრობლემაა, რადგან ეს ერთეული ვერ შეძლებს „იცოდეს“ რისი რენდერია - გამოსახულება და მავთულის ჩარჩო;
• ცალკეულ ერთეულებს შორის თვისებებისა და ქცევის გაცვლის ხელსაწყოს არარსებობა (მაგალითად, is_build_mode თვისება ან ქცევის რენდერი). შესაძლებელი იქნებოდა მემკვიდრეობის გამოყენება, თუმცა რუსთში მისი განხორციელების სათანადო გზა არ არსებობს. რაც მე ნამდვილად მჭირდებოდა იყო განლაგება;
• საჭირო იყო სუბიექტებს შორის ურთიერთქმედების ინსტრუმენტი, რათა ადამიანები სასამართლოში მიეყვანათ;
• თავად სუბიექტები იყო მონაცემთა და ლოგიკის ნაზავი, რომელიც სწრაფად გამოვიდა კონტროლიდან.

მე კიდევ რამდენიმე კვლევა ჩავატარე და აღმოვაჩინე არქიტექტურა ECS - Entity Component System, რომელიც ჩვეულებრივ გამოიყენება თამაშებში. აქ მოცემულია ECS-ის უპირატესობები:

• მონაცემები გამოყოფილია ლოგიკისაგან;
• შემადგენლობა მემკვიდრეობის ნაცვლად;
• მონაცემთა ორიენტირებული არქიტექტურა.

ECS ხასიათდება სამი ძირითადი კონცეფციით:

• ერთეულები - ობიექტის ტიპი, რომელსაც ეხება იდენტიფიკატორი (ეს შეიძლება იყოს მოთამაშე, ბურთი ან სხვა რამ);
• კომპონენტები - მათგან შედგება ერთეულები. მაგალითი - კომპონენტის, მდებარეობების და სხვათა რენდერირება. ეს არის მონაცემთა საწყობები;
• სისტემები - ისინი იყენებენ როგორც ობიექტებს, ასევე კომპონენტებს, ასევე შეიცავს ქცევას და ლოგიკას, რომელიც დაფუძნებულია ამ მონაცემებზე. მაგალითი არის რენდერის სისტემა, რომელიც იმეორებს ყველა ერთეულს რენდერის კომპონენტებით და აკეთებს რენდერირებას.

მისი შესწავლის შემდეგ გაირკვა, რომ ECS წყვეტს შემდეგ პრობლემებს:

• განლაგების გამოყენება მემკვიდრეობის ნაცვლად ერთეულების სისტემური ორგანიზებისთვის;
• კონტროლის სისტემების მეშვეობით კოდების შეჯახების მოშორება;
• ისეთი მეთოდების გამოყენებით, როგორიცაა is_build_mode, რათა შევინარჩუნოთ wireframe ლოგიკა იმავე ადგილზე - რენდერის სისტემაში.

ეს არის ის, რაც მოხდა ECS-ის დანერგვის შემდეგ.

რესურსები -> აქ არის ყველა აქტივი (სურათები)
src
- კომპონენტები
- თანამდებობა.რს
- პირი.რს
— tennis_court.rs
- სართული.რს
- wireframe.rs
- მაუსის_ტრეკზე.rs
- რესურსები
-მაუსი.რს
- სისტემები
- გაწევა.რს
- მუდმივები.rs
- utils.rs
— world_factory.rs -> მსოფლიო ქარხნის ფუნქციები
— main.rs -> main loop

ადამიანებს სასამართლოებში ვაბარებთ

ECS-მა გაუადვილა ცხოვრება. ახლა მე მქონდა სისტემატური გზა დავამატო მონაცემები ერთეულებში და დავამატო ლოგიკა ამ მონაცემებზე დაყრდნობით. და ამან, თავის მხრივ, შესაძლებელი გახადა სასამართლოებს შორის ხალხის განაწილების ორგანიზება.

Რა ჩავიდინე:

• პირს დაემატა მონაცემები დაკისრებული სასამართლოების შესახებ;
• დაამატა მონაცემები განაწილებული ადამიანების შესახებ TennisCourt-ში;
• დაემატა CourtChoosingSystem, რომელიც საშუალებას გაძლევთ გაანალიზოთ ადამიანები და კორტები, გამოავლინოთ ხელმისაწვდომი კორტები და გაანაწილოთ მოთამაშეები მათზე;
• დაამატა PersonMovementSystem, რომელიც ეძებს სასამართლოში დანიშნულ ადამიანებს და თუ ისინი იქ არ არიან, მაშინ აგზავნის ხალხს იქ, სადაც უნდა იყვნენ.

შეჯამება

ძალიან მსიამოვნებდა ამ მარტივ თამაშზე მუშაობა. უფრო მეტიც, მიხარია, რომ მის დასაწერად Rust გამოვიყენე, რადგან:

• ჟანგი გაძლევს იმას, რაც გჭირდება;
• აქვს შესანიშნავი დოკუმენტაცია, Rust საკმაოდ ელეგანტურია;
• თანმიმდევრულობა მაგარია;
• თქვენ არ გჭირდებათ კლონირება, კოპირება ან სხვა მსგავსი ქმედებები, რასაც ხშირად ვაკეთებდი C++-ში;
• ოფციები ძალიან მარტივი გამოსაყენებელია და ძალიან კარგად უმკლავდება შეცდომებს;
• თუ პროექტის შედგენა მოხერხდა, მაშინ 99% მუშაობს და ზუსტად ისე, როგორც უნდა. ვფიქრობ, შემდგენელის შეცდომის შეტყობინებები საუკეთესოა, რაც მინახავს.

Rust-ში თამაშის განვითარება ახლახან იწყება. მაგრამ უკვე არსებობს სტაბილური და საკმაოდ დიდი საზოგადოება, რომელიც მუშაობს Rust-ის ყველასთვის გასახსნელად. ამიტომ, ოპტიმიზმით ვუყურებ ენის მომავალს, ველი ჩვენი საერთო მუშაობის შედეგებს.

Skillbox გირჩევთ:

• ონლაინ კურსი "პროფესიის ფრონტენდის დეველოპერი".
• პრაქტიკული კურსი "Mobile Developer PRO".
• პრაქტიკული წლის კურსი "PHP დეველოპერი 0-დან PRO-მდე".

წყარო: www.habr.com