24 કલાકમાં રસ્ટ રમવું: વ્યક્તિગત વિકાસ અનુભવ

આ લેખમાં હું રસ્ટમાં નાની રમત વિકસાવવાના મારા અંગત અનુભવ વિશે વાત કરીશ. વર્કિંગ વર્ઝન બનાવવામાં લગભગ 24 કલાક લાગ્યા હતા (મેં મોટે ભાગે સાંજે અથવા સપ્તાહના અંતે કામ કર્યું હતું). રમત સમાપ્ત થવાથી દૂર છે, પરંતુ મને લાગે છે કે અનુભવ લાભદાયી રહેશે. શરૂઆતથી રમત બનાવતી વખતે મેં જે શીખ્યા તે અને કેટલાક અવલોકનો હું શેર કરીશ.

સ્કિલબોક્સ ભલામણ કરે છે: બે વર્ષનો પ્રેક્ટિકલ કોર્સ "હું પ્રો વેબ ડેવલપર છું".

અમે યાદ કરાવીએ છીએ: Habrના તમામ વાચકો માટે - Habr પ્રોમો કોડનો ઉપયોગ કરીને કોઈપણ સ્કિલબોક્સ કોર્સમાં નોંધણી કરતી વખતે 10 રૂબલ ડિસ્કાઉન્ટ.

શા માટે કાટ?

મેં આ ભાષા પસંદ કરી છે કારણ કે મેં તેના વિશે ઘણી સારી વસ્તુઓ સાંભળી છે અને હું તેને રમત વિકાસમાં વધુને વધુ લોકપ્રિય થતી જોઉં છું. રમત લખતા પહેલા, મને રસ્ટમાં સરળ એપ્લિકેશન વિકસાવવાનો થોડો અનુભવ હતો. આ રમત લખતી વખતે મને સ્વતંત્રતાની ભાવના આપવા માટે પૂરતું હતું.

રમત શા માટે અને કેવા પ્રકારની રમત?

રમતો બનાવવી એ મજા છે! હું ઈચ્છું છું કે ત્યાં વધુ કારણો હોત, પરંતુ "ઘર" પ્રોજેક્ટ્સ માટે હું એવા વિષયો પસંદ કરું છું જે મારા નિયમિત કાર્ય સાથે ખૂબ નજીકથી સંબંધિત નથી. આ કઈ રમત છે? હું ટેનિસ સિમ્યુલેટર જેવું કંઈક બનાવવા માંગતો હતો જે સિટીઝ સ્કાયલાઇન્સ, ઝૂ ટાયકૂન, જેલ આર્કિટેક્ટ અને ટેનિસને જોડે. સામાન્ય રીતે, તે ટેનિસ એકેડમી વિશેની રમત હોવાનું બહાર આવ્યું છે જ્યાં લોકો રમવા આવે છે.

ટેકનિકલ તાલીમ

હું રસ્ટનો ઉપયોગ કરવા માંગતો હતો, પરંતુ મને બરાબર ખબર નહોતી કે તે શરૂ કરવા માટે કેટલું ગ્રાઉન્ડવર્ક લેશે. હું પિક્સેલ શેડર્સ લખવા અને ડ્રેગ-એન-ડ્રોપનો ઉપયોગ કરવા માંગતો ન હતો, તેથી હું સૌથી વધુ લવચીક ઉકેલો શોધી રહ્યો હતો.

મને ઉપયોગી સંસાધનો મળ્યાં છે જે હું તમારી સાથે શેર કરું છું:

• શું આપણે હજી રમીએ છીએ - રમતના વિકાસ માટે જરૂરી રસ્ટ તત્વોની સૂચિ;
• રસ્ટ ગેમ ડેવ સબરેડિટ;
• મફત પિક્સેલ કલા.

મેં ઘણા રસ્ટ ગેમ એન્જિનોની શોધખોળ કરી, આખરે પિસ્ટન અને 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
— વર્તુળ.આરએસ
— 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 જેવી પદ્ધતિઓનો ઉપયોગ કરીને - રેન્ડરિંગ સિસ્ટમમાં.

ECS લાગુ કર્યા પછી આવું જ થયું.

સંસાધનો -> આ તે છે જ્યાં બધી સંપત્તિઓ છે (છબીઓ)
સ્રોત
- ઘટકો
—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 માં વિતરિત લોકો વિશે ડેટા ઉમેર્યો;
• કોર્ટચૂઝિંગ સિસ્ટમ ઉમેર્યું, જે તમને લોકો અને અદાલતોનું વિશ્લેષણ કરવા, ઉપલબ્ધ અદાલતો શોધવા અને તેમને ખેલાડીઓનું વિતરણ કરવાની મંજૂરી આપે છે;
• પર્સન મૂવમેન્ટસિસ્ટમ ઉમેર્યું, જે કોર્ટને સોંપેલ લોકોને શોધે છે, અને જો તેઓ ત્યાં ન હોય, તો પછી લોકોને જ્યાં તેઓની જરૂર હોય ત્યાં મોકલે છે.

એકત્ર કરવું

મને આ સરળ રમત પર કામ કરવામાં ખરેખર આનંદ થયો. તદુપરાંત, મને આનંદ છે કે મેં તેને લખવા માટે રસ્ટનો ઉપયોગ કર્યો, કારણ કે:

• રસ્ટ તમને જે જોઈએ છે તે આપે છે;
• તેની પાસે ઉત્તમ દસ્તાવેજીકરણ છે, રસ્ટ એકદમ ભવ્ય છે;
• સુસંગતતા ઠંડી છે;
• તમારે ક્લોનિંગ, નકલ અથવા અન્ય સમાન ક્રિયાઓનો આશરો લેવાની જરૂર નથી, જે મેં ઘણીવાર C++ માં કર્યું છે;
• વિકલ્પો વાપરવા માટે ખૂબ જ સરળ છે અને ભૂલોને સારી રીતે હેન્ડલ કરે છે;
• જો પ્રોજેક્ટ કમ્પાઈલ કરવામાં સક્ષમ હતો, તો 99% સમય તે કામ કરે છે, અને બરાબર તે જોઈએ. મને લાગે છે કે કમ્પાઈલર ભૂલ સંદેશાઓ મેં જોયેલા શ્રેષ્ઠ છે.

રસ્ટમાં રમત વિકાસ માત્ર શરૂઆત છે. પરંતુ ત્યાં પહેલેથી જ એક સ્થિર અને એકદમ મોટો સમુદાય છે જે રસ્ટને દરેક માટે ખોલવા માટે કામ કરી રહ્યો છે. તેથી, હું ભાષાના ભવિષ્યને આશાવાદ સાથે જોઉં છું, અમારા સામાન્ય કાર્યના પરિણામોની રાહ જોઉં છું.

સ્કિલબોક્સ ભલામણ કરે છે:

• ઓનલાઇન કોર્સ "પ્રોફેશન ફ્રન્ટ એન્ડ ડેવલપર".
• પ્રેક્ટિકલ કોર્સ "મોબાઇલ ડેવલપર પ્રો".
• એક વર્ષનો પ્રેક્ટિકલ કોર્સ "0 થી PRO સુધી PHP વિકાસકર્તા".

સોર્સ: www.habr.com