Игра на Rust за 24 часа: опит за лично развитие

В тази статия ще говоря за моя личен опит в разработването на малка игра в Rust. Създаването на работеща версия отне около 24 часа (повечето работех вечер или през почивните дни). Играта далеч не е завършена, но мисля, че опитът ще бъде възнаграждаващ. Ще споделя какво научих и някои наблюдения, които направих, докато създавах играта от нулата.

Skillbox препоръчва: Двугодишен практически курс „Аз съм PRO уеб разработчик“.

Напомняме ви: за всички читатели на "Habr" - отстъпка от 10 000 рубли при записване във всеки курс Skillbox, използвайки промоционалния код на "Habr".

Защо Rust?

Избрах този език, защото съм чувал много добри неща за него и виждам, че става все по-популярен в разработката на игри. Преди да напиша играта, имах малко опит в разработването на прости приложения в Rust. Това беше достатъчно, за да ми даде усещане за свобода, докато пиша играта.

Защо играта и какъв вид игра?

Създаването на игри е забавно! Иска ми се да има повече причини, но за „домашни“ проекти избирам теми, които не са твърде тясно свързани с обичайната ми работа. каква игра е това Исках да направя нещо като тенис симулатор, който комбинира Cities Skylines, Zoo Tycoon, Prison Architect и самия тенис. Като цяло се оказа игра за тенис академия, където хората идват да играят.

Техническо обучение

Исках да използвам Rust, но не знаех колко много работа ще е необходима, за да започна. Не исках да пиша пикселни шейдъри и да използвам drag-n-drop, така че търсех най-гъвкавите решения.

Намерих полезни ресурси, които споделям с вас:

• Играем ли вече — списък с Rust елементи, необходими за разработката на играта;
• Subreddit за разработчик на игри Rust;
• Безплатно пикселно изкуство.

Проучих няколко игрални двигателя на 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 -> основен цикъл

Хора, подове и изображения

Следващата стъпка е да създадете обект за игра Person и да заредите изображения. Всичко трябва да бъде изградено на базата на плочки 32*32.

Тенис кортове

След като проучих как изглеждат тенис кортовете, реших да ги направя от плочки 4*2. Първоначално беше възможно да се направи изображение с такъв размер или да се сглобят 8 отделни плочки. Но тогава разбрах, че са необходими само две уникални плочки и ето защо.

Общо имаме две такива плочки: 1 и 2.

Всяка секция на игрището се състои от плочка 1 или плочка 2. Те могат да бъдат разположени нормално или обърнати на 180 градуса.

Основен режим на конструиране (монтаж).

След като успях да постигна изобразяване на сайтове, хора и карти, осъзнах, че е необходим и основен режим на сглобяване. Реализирах го така: при натискане на бутона обектът се избира и щракването го поставя на желаното място. И така, бутон 1 ви позволява да изберете корт, а бутон 2 ви позволява да изберете играч.

Но все още трябва да помним какво означават 1 и 2, така че добавих телена рамка, за да стане ясно кой обект е избран. Ето как изглежда.

Архитектура и въпроси за рефакторинг

Сега имам няколко обекта за игра: хора, кортове и подове. Но за да работят телените рамки, на всеки обект трябва да се каже дали самите обекти са в демонстрационен режим или рамката просто е начертана. Това не е много удобно.

Струваше ми се, че архитектурата трябва да бъде преосмислена по начин, който разкрива някои ограничения:

• Наличието на обект, който сам се изобразява и обновява, е проблем, защото този обект няма да може да „знае“ какво трябва да изобразява – изображение и телена рамка;
• липса на инструмент за обмен на свойства и поведение между отделни обекти (например свойството is_build_mode или рендиране на поведение). Би било възможно да се използва наследяване, въпреки че няма правилен начин да се приложи в Rust. Това, от което наистина се нуждаех, беше оформлението;
• беше необходим инструмент за взаимодействие между субектите за назначаване на хора в съдилищата;
• самите обекти бяха смесица от данни и логика, която бързо излезе извън контрол.

Направих още малко проучване и открих архитектурата ECS - Entity Component System, който обикновено се използва в игрите. Ето предимствата на ECS:

• данните са отделени от логиката;
• композиция вместо наследство;
• ориентирана към данни архитектура.

ECS се характеризира с три основни концепции:

• entities - типът обект, към който се отнася идентификаторът (може да е играч, топка или нещо друго);
• компоненти - същностите са съставени от тях. Пример - рендиращ компонент, местоположения и други. Това са складове за данни;
• системи - те използват както обекти, така и компоненти, плюс съдържат поведение и логика, които се основават на тези данни. Пример е система за изобразяване, която преминава през всички обекти с компоненти за изобразяване и извършва изобразяването.

След проучването му стана ясно, че ECS решава следните проблеми:

• използване на оформление вместо наследяване за системно организиране на обекти;
• премахване на бъркания код чрез системи за управление;
• използвайки методи като is_build_mode, за да запазите wireframe логиката на едно и също място - в системата за изобразяване.

Това се случи след въвеждането на ECS.

ресурси -> тук са всички активи (изображения)
SRC
- компоненти
—позиция.rs
— човек.rs
— tennis_court.rs
— етаж.rs
- wireframe.rs
— mouse_tracked.rs
- ресурси
— мишка.rs
- системи
— rendering.rs
— константи.rs
— utils.rs
— world_factory.rs -> функции на световната фабрика
— main.rs -> основен цикъл

Назначаваме хора в съдилищата

ECS направи живота по-лесен. Сега имах систематичен начин за добавяне на данни към обекти и добавяне на логика въз основа на тези данни. А това от своя страна даде възможност да се организира разпределението на хората по съдилищата.

Какво съм направил:

• добавени данни за определени съдилища на Лице;
• добавени данни за разпределени хора към TennisCourt;
• добавен CourtChoosingSystem, който ви позволява да анализирате хора и кортове, да откривате налични кортове и да разпределяте играчи към тях;
• добави PersonMovementSystem, която търси хора, назначени в съдилищата, и ако не са там, изпраща хората, където трябва.

Резюмиране

Наистина ми хареса да работя върху тази проста игра. Освен това се радвам, че използвах Rust, за да го напиша, защото:

• Rust ви дава това, от което се нуждаете;
• има отлична документация, Rust е доста елегантен;
• консистенцията е хладна;
• не е нужно да прибягвате до клониране, копиране или други подобни действия, които често правех в C++;
• Опциите са много лесни за използване и се справят много добре с грешките;
• Ако проектът е успял да бъде компилиран, тогава 99% от времето работи и точно както трябва. Мисля, че съобщенията за грешки на компилатора са най-добрите, които съм виждал.

Разработката на игри в Rust едва започва. Но вече има стабилна и доста голяма общност, която работи, за да отвори Rust за всички. Затова гледам с оптимизъм на бъдещето на езика, очаквайки резултатите от съвместната ни работа.

Skillbox препоръчва:

• Онлайн курс „Професия фронтенд разработчик“.
• Практически курс „Мобилен разработчик PRO“.
• Практически годишен курс „PHP разработчик от 0 до PRO“.

Източник: www.habr.com