An dësem Artikel wäert ech iwwer meng perséinlech Erfahrung schwätzen fir e klengt Spill am Rust z'entwéckelen. Et huet ongeféier 24 Stonnen gedauert fir eng funktionéierend Versioun ze kreéieren (ech hunn meeschtens Owes oder Weekend geschafft). D'Spill ass wäit net fäerdeg, awer ech mengen datt d'Erfahrung belount gëtt. Ech deelen wat ech geléiert hunn an e puer Beobachtungen déi ech gemaach hunn beim Bau vum Spill vun Null.
Skillbox recommandéiert: Zwee-Joer praktesch Cours .
Mir erënneren Iech: fir all Habr Lieser - eng Remise vun 10 Rubel wann Dir Iech an all Skillbox Cours aschreift mat dem Habr Promo Code.
Firwat Rust?
Ech hunn dës Sprooch gewielt well ech vill gutt Saachen doriwwer héieren hunn an ech gesinn datt se ëmmer méi populär gëtt an der Spillentwécklung. Ier ech d'Spill geschriwwen hunn, hat ech wéineg Erfahrung fir einfach Uwendungen am Rust z'entwéckelen. Dëst war just genuch fir mech e Gefill vu Fräiheet ze ginn beim Schreiwen vum Spill.
Firwat d'Spill a wéi eng Zort Spill?
Spiller maachen ass Spaass! Ech wënschen et méi Grënn, mee fir "Heem" Projeten wielen ech Themen déi net ze enk mat menger regulärer Aarbecht verbonne sinn. Wéi eng Spill ass dëst? Ech wollt eppes maachen wéi en Tennissimulator deen Cities Skylines, Zoo Tycoon, Prison Architect an Tennis selwer kombinéiert. Am Allgemengen huet sech e Spill iwwer eng Tennisakademie erausgestallt, wou d'Leit kommen ze spillen.
Techneschen Training
Ech wollt Rust benotzen, awer ech wousst net genau wéi vill Grondaarbecht et géif huelen fir unzefänken. Ech wollt keng Pixel Shaders schreiwen an Drag-n-Drop benotzen, also hunn ech no de flexibelste Léisunge gesicht.
Ech hunn nëtzlech Ressourcen fonnt déi ech mat Iech deelen:
- - eng Lëscht vun Rust Elementer néideg fir Spill Entwécklung;
Ech hunn e puer Rust Spillmotoren exploréiert, schlussendlech Piston a ggez gewielt. Ech sinn op si begéint wärend ech un engem fréiere Projet geschafft hunn. Um Enn hunn ech ggez gewielt well et méi gëeegent war fir e klengt 2D Spill ëmzesetzen. Dem Piston seng modulare Struktur ass ze komplex fir en Ufänger Entwéckler (oder een deen fir d'éischte Kéier mat Rust schafft).
Spillstruktur
Ech hunn e bëssen Zäit iwwer d'Architektur vum Projet geduecht. Den éischte Schrëtt ass "Land", Leit an Tennis Geriichter ze maachen. D'Leit musse ronderëm d'Geriicht réckelen a waarden. D'Spiller mussen Fäegkeeten hunn, déi sech mat der Zäit verbesseren. Plus, et soll en Editeur ginn, deen Iech erlaabt nei Leit a Geriichter ze addéieren, awer dëst ass net méi gratis.
Nodeems ech alles iwwerluecht hunn, hunn ech ugefaang ze schaffen.
Spill Kreatioun
Ufank: Kreeser an Abstraktiounen
Ech hunn e Beispill vun ggez geholl a krut e Krees um Écran. Wonnerbar! Elo e puer Abstraktiounen. Ech hu geduecht et wier flott ze abstrakt vun der Iddi vun engem Spillobjekt ewech. All Objet muss rendered an aktualiséiert ginn wéi hei uginn:
// 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(())
}
}Dëst Stéck Code huet mir eng flott Lëscht vun Objekter ginn, déi ech an enger gläicher flotter Loop aktualiséieren an ofginn.
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 ass néideg well et all d'Zeilen vum Code enthält. Ech hunn e bëssen Zäit verbruecht fir d'Dateien ze trennen an d'Verzeichnisstruktur ze optimiséieren. Dëst ass wéi et duerno ausgesinn huet:
Ressourcen -> dat ass wou all Verméigen sinn (Biller)
src
- Entitéiten
— game_object.rs
— Krees.rs
— main.rs -> Haaptschleife
Leit, Etagen a Biller
De nächste Schrëtt ass e Person Spillobjekt ze kreéieren an Biller ze lueden. Alles soll op der Basis vun 32*32 Plättercher gebaut ginn.
Tennis Geriichter
Nodeems ech studéiert hunn wéi Tennis Geriichter ausgesinn, hunn ech decidéiert se aus 4*2 Plättercher ze maachen. Am Ufank war et méiglech e Bild vun dëser Gréisst ze maachen, oder 8 separat Plättercher zesummenzestellen. Awer dunn hunn ech gemierkt datt nëmmen zwee eenzegaarteg Plättercher gebraucht goufen, an hei ass firwat.
Am Ganzen hu mir zwee esou Plättercher: 1 an 2.
All Sektioun vum Geriicht besteet aus Plättercher 1 oder Plättercher 2. Si kënnen als normal geluecht ginn oder 180 Grad ëmgedréint ginn.
Basis Konstruktioun (Montage) Modus
Nodeems ech et fäerdeg bruecht hunn d'Rendering vu Siten, Leit a Kaarten z'erreechen, hunn ech gemierkt datt e Basisversammlungsmodus och gebraucht gouf. Ech hunn et esou ëmgesat: wann de Knäppchen dréckt, gëtt den Objet ausgewielt, an de Klick setzt se op déi gewënscht Plaz. Also, Knäppchen 1 erlaabt Iech e Geriicht ze wielen, a Knäppchen 2 erlaabt Iech e Spiller ze wielen.
Awer mir mussen nach ëmmer drun erënneren wat 1 an 2 bedeiten, also hunn ech e Wireframe bäigefüügt fir kloer ze maachen wéi en Objet ausgewielt gouf. Dëst ass wéi et ausgesäit.
Architektur a Refactoring Froen
Elo hunn ech e puer Spillobjekter: Leit, Geriichter a Buedem. Awer fir datt wireframes funktionnéieren, muss all Objektentitéit gesot ginn ob d'Objete selwer am Demonstratiounsmodus sinn oder ob e Frame einfach gezeechent gëtt. Dëst ass net ganz bequem.
Et huet mir geschéngt datt d'Architektur misst nei iwwerduecht ginn op eng Manéier déi e puer Aschränkungen opgedeckt huet:
- Eng Entitéit ze hunn déi sech selwer rendert an aktualiséiert ass e Problem well dës Entitéit net fäeg ass ze "wësse" wat se soll renderen - e Bild an e Wireframe;
- Mangel un engem Tool fir Eegeschaften a Verhalen tëscht eenzelnen Entitéiten auszetauschen (zum Beispill, d'Is_build_mode Eegeschafte oder Verhalensrendering). Et wier méiglech Ierfschaft ze benotzen, obwuel et kee richtege Wee ass fir et am Rust ëmzesetzen. Wat ech wierklech gebraucht huet war de Layout;
- engem Instrument fir Interaktioun tëscht Entitéite war néideg Leit ze Geriichter ze zouzeschreiwen;
- d'Entitéite selwer waren eng Mëschung aus Daten a Logik, déi séier aus der Kontroll erauskoum.
Ech hunn e puer méi Fuerschung gemaach an d'Architektur entdeckt , déi allgemeng a Spiller benotzt gëtt. Hei sinn d'Virdeeler vun ECS:
- Donnéeën vun der Logik getrennt;
- Zesummesetzung amplaz Ierfschaft;
- datenzentresch Architektur.
ECS ass duerch dräi Basiskonzepter charakteriséiert:
- Entitéiten - d'Zort vum Objet op deen den Identifizéierer bezitt (et kéint e Spiller, e Ball oder soss eppes sinn);
- Komponenten - Entitéite besteet aus hinnen. Beispill - Render- Komponente, Plaze an anerer. Dëst sinn Datelager;
- Systemer - si benotzen souwuel Objeten a Komponenten, plus enthalen Verhalen a Logik déi op dës Donnéeën baséieren. E Beispill ass e Rendering System deen duerch all Entitéite mat Rendering Komponenten iteréiert an de Rendering mécht.
Nom Studium gouf et kloer datt ECS déi folgend Probleemer léist:
- Layout amplaz vun Ierfschaft benotzen fir Entitéite systemesch z'organiséieren;
- lass vun Code Jumble duerch Kontroll Systemer;
- benotzt Methoden wéi is_build_mode fir d'Wireframe Logik op der selwechter Plaz ze halen - am Rendering System.
Dëst ass wat geschitt no der Ëmsetzung vun ECS.
Ressourcen -> dat ass wou all Verméigen sinn (Biller)
src
- Komponenten
- Positioun.rs
- Persoun.rs
- tennis_court.rs
- Buedem.rs
- wireframe.rs
— mouse_tracked.rs
- Ressourcen
- Maus.rs
- Systemer
- Rendering.rs
- konstante.rs
- utils.rs
— world_factory.rs -> Weltfabrikfunktiounen
— main.rs -> Haaptschleife
Mir ginn Leit un d'Geriichter zou
ECS huet d'Liewen méi einfach gemaach. Elo hat ech e systematesch Wee fir Daten un Entitéiten ze addéieren an Logik op Basis vun dësen Donnéeën ze addéieren. An dëst, am Tour, huet et méiglech gemaach d'Verdeelung vun de Leit ënnert de Geriichter ze organiséieren.
Wat hunn ech gemaach:
- bäigefüügt Donnéeën iwwer zougewisen Geriichter fir Persoun;
- dobäi Donnéeën iwwer verdeelt Leit TennisCourt;
- dobäi CourtChoosingSystem, wat erlaabt Iech Leit a Geriichter ze analyséieren, disponibel Geriichter z'entdecken an Spiller hinnen ze verdeelen;
- e PersonMovementSystem bäigefüügt, deen no Leit sicht, déi un d'Geriichter zougewisen sinn, a wa se net do sinn, da schéckt d'Leit wou se musse sinn.
Ze summéieren
Ech hu wierklech gär un dësem einfache Spill geschafft. Ausserdeem sinn ech frou datt ech Rust benotzt hunn fir et ze schreiwen, well:
- Rust gëtt Iech wat Dir braucht;
- et huet excellent Dokumentatioun, Rust ass ganz elegant;
- Konsistenz ass cool;
- Dir musst net op Klonen, Kopie oder aner ähnlech Aktiounen zréckgräifen, wat ech dacks am C++ gemaach hunn;
- Optiounen si ganz einfach ze benotzen an d'Feeler ganz gutt behandelen;
- wann de Projet konnt zesummegestallt ginn, dann 99% vun der Zäit klappt, a genee wéi et soll. Ech mengen de Compiler Feeler Messagen sinn déi bescht ech gesinn hunn.
Spill Entwécklung am Rust fänkt just un. Mä et gëtt schonn eng stabil an zimlech grouss Communautéit schaffen Rust fir jiddereen opzemaachen. Dofir kucken ech optimistesch op d'Zukunft vun der Sprooch, freeën mech op d'Resultater vun eiser gemeinsamer Aarbecht.
Skillbox recommandéiert:
- Online Cours .
- Praktesch Cours .
- Praktesch ee Joer Cours .
Source: will.com