24 മണിക്കൂറിനുള്ളിൽ റസ്റ്റ് കളിക്കുന്നു: വ്യക്തിഗത വികസന അനുഭവം

ഈ ലേഖനത്തിൽ ഞാൻ റസ്റ്റിൽ ഒരു ചെറിയ ഗെയിം വികസിപ്പിക്കുന്ന എന്റെ വ്യക്തിപരമായ അനുഭവത്തെക്കുറിച്ച് സംസാരിക്കും. ഒരു പ്രവർത്തന പതിപ്പ് സൃഷ്ടിക്കാൻ ഏകദേശം 24 മണിക്കൂർ എടുത്തു (ഞാൻ കൂടുതലും വൈകുന്നേരങ്ങളിലോ വാരാന്ത്യങ്ങളിലോ ആണ് ജോലി ചെയ്തിരുന്നത്). ഗെയിം പൂർത്തിയായിട്ടില്ല, പക്ഷേ അനുഭവം പ്രതിഫലദായകമാകുമെന്ന് ഞാൻ കരുതുന്നു. ആദ്യം മുതൽ ഗെയിം നിർമ്മിക്കുമ്പോൾ ഞാൻ പഠിച്ചതും ചില നിരീക്ഷണങ്ങളും ഞാൻ പങ്കിടും.

സ്കിൽബോക്സ് ശുപാർശ ചെയ്യുന്നു: രണ്ടുവർഷത്തെ പ്രാക്ടിക്കൽ കോഴ്സ് "ഞാൻ ഒരു PRO വെബ് ഡെവലപ്പർ ആണ്".

ഞങ്ങൾ ഓർമ്മിപ്പിക്കുന്നു: "Habr"-ന്റെ എല്ലാ വായനക്കാർക്കും - "Habr" പ്രൊമോഷണൽ കോഡ് ഉപയോഗിച്ച് ഏതെങ്കിലും സ്കിൽബോക്സ് കോഴ്സിൽ ചേരുമ്പോൾ 10 റൂബിൾസ് കിഴിവ്.

എന്തുകൊണ്ട് തുരുമ്പ്?

ഞാൻ ഈ ഭാഷ തിരഞ്ഞെടുത്തത് ഇതിനെക്കുറിച്ച് ധാരാളം നല്ല കാര്യങ്ങൾ കേട്ടതിനാലും ഗെയിം ഡെവലപ്‌മെന്റിൽ ഇത് കൂടുതൽ കൂടുതൽ ജനപ്രിയമാകുന്നത് ഞാൻ കാണുന്നതിനാലും. ഗെയിം എഴുതുന്നതിന് മുമ്പ്, റസ്റ്റിൽ ലളിതമായ ആപ്ലിക്കേഷനുകൾ വികസിപ്പിക്കുന്നതിൽ എനിക്ക് കുറച്ച് അനുഭവം മാത്രമേ ഉണ്ടായിരുന്നുള്ളൂ. ഗെയിം എഴുതുമ്പോൾ എനിക്ക് ഒരു സ്വാതന്ത്ര്യബോധം നൽകാൻ ഇത് മതിയായിരുന്നു.

എന്തുകൊണ്ടാണ് ഗെയിം, ഏത് തരത്തിലുള്ള ഗെയിം?

ഗെയിമുകൾ നിർമ്മിക്കുന്നത് രസകരമാണ്! കൂടുതൽ കാരണങ്ങൾ ഉണ്ടായിരുന്നെങ്കിൽ എന്ന് ഞാൻ ആഗ്രഹിക്കുന്നു, എന്നാൽ "ഹോം" പ്രോജക്റ്റുകൾക്കായി ഞാൻ എന്റെ പതിവ് ജോലിയുമായി വളരെ അടുത്ത ബന്ധമില്ലാത്ത വിഷയങ്ങൾ തിരഞ്ഞെടുക്കുന്നു. ഇത് എന്ത് കളിയാണ്? സിറ്റി സ്കൈലൈനുകൾ, സൂ ടൈക്കൂൺ, പ്രിസൺ ആർക്കിടെക്റ്റ്, ടെന്നീസ് എന്നിവയെ സംയോജിപ്പിക്കുന്ന ടെന്നീസ് സിമുലേറ്റർ പോലെയുള്ള ഒന്ന് നിർമ്മിക്കാൻ ഞാൻ ആഗ്രഹിച്ചു. പൊതുവേ, ആളുകൾ കളിക്കാൻ വരുന്ന ഒരു ടെന്നീസ് അക്കാദമിയെക്കുറിച്ചുള്ള ഗെയിമായി ഇത് മാറി.

സാങ്കേതിക പരിശീലനം

എനിക്ക് റസ്റ്റ് ഉപയോഗിക്കാൻ ആഗ്രഹമുണ്ടായിരുന്നു, എന്നാൽ ഇത് ആരംഭിക്കാൻ എത്രത്തോളം അടിസ്ഥാന വർക്ക് വേണ്ടിവരുമെന്ന് എനിക്ക് കൃത്യമായി അറിയില്ലായിരുന്നു. എനിക്ക് പിക്സൽ ഷേഡറുകൾ എഴുതാനും ഡ്രാഗ്-എൻ-ഡ്രോപ്പ് ഉപയോഗിക്കാനും താൽപ്പര്യമില്ല, അതിനാൽ ഞാൻ ഏറ്റവും വഴക്കമുള്ള പരിഹാരങ്ങൾക്കായി തിരയുകയായിരുന്നു.

ഞാൻ നിങ്ങളുമായി പങ്കിടുന്ന ഉപയോഗപ്രദമായ ഉറവിടങ്ങൾ ഞാൻ കണ്ടെത്തി:

• നമ്മൾ ഇതുവരെ കളിക്കുകയാണോ - ഗെയിം വികസനത്തിന് ആവശ്യമായ റസ്റ്റ് ഘടകങ്ങളുടെ ഒരു ലിസ്റ്റ്;
• റസ്റ്റ് ഗെയിം ദേവ് സബ്‌റെഡിറ്റ്;
• സൗജന്യ പിക്സൽ ആർട്ട്.

ഞാൻ നിരവധി റസ്റ്റ് ഗെയിം എഞ്ചിനുകൾ പര്യവേക്ഷണം ചെയ്തു, ഒടുവിൽ പിസ്റ്റണും ഗെസും തിരഞ്ഞെടുത്തു. മുമ്പത്തെ ഒരു പ്രൊജക്റ്റിൽ ജോലി ചെയ്യുമ്പോഴാണ് ഞാൻ അവരെ കണ്ടത്. അവസാനം, ഒരു ചെറിയ 2D ഗെയിം നടപ്പിലാക്കാൻ കൂടുതൽ അനുയോജ്യമെന്ന് തോന്നിയതിനാൽ ഞാൻ ggez തിരഞ്ഞെടുത്തു. പിസ്റ്റണിന്റെ മോഡുലാർ ഘടന ഒരു പുതിയ ഡെവലപ്പർക്ക് (അല്ലെങ്കിൽ ആദ്യമായി റസ്റ്റിനൊപ്പം പ്രവർത്തിക്കുന്ന ഒരാൾക്ക്) വളരെ സങ്കീർണ്ണമാണ്.

ഗെയിം ഘടന

പ്രോജക്റ്റിന്റെ വാസ്തുവിദ്യയെക്കുറിച്ച് ഞാൻ കുറച്ച് സമയം ചിന്തിച്ചു. "ഭൂമി", ആളുകൾ, ടെന്നീസ് കോർട്ടുകൾ എന്നിവ ഉണ്ടാക്കുക എന്നതാണ് ആദ്യപടി. ജനങ്ങൾ കോടതികൾ ചുറ്റിനടന്ന് കാത്തിരിക്കണം. കളിക്കാർക്ക് കാലക്രമേണ മെച്ചപ്പെടുന്ന കഴിവുകൾ ഉണ്ടായിരിക്കണം. കൂടാതെ, പുതിയ ആളുകളെയും കോടതികളെയും ചേർക്കാൻ നിങ്ങളെ അനുവദിക്കുന്ന ഒരു എഡിറ്റർ ഉണ്ടായിരിക്കണം, എന്നാൽ ഇത് ഇനി സൗജന്യമല്ല.

എല്ലാം ആലോചിച്ച് ഞാൻ ജോലിയിൽ പ്രവേശിച്ചു.

ഗെയിം സൃഷ്ടിക്കൽ

തുടക്കം: സർക്കിളുകളും അമൂർത്തങ്ങളും

ഞാൻ 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
—വൃത്തം.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 പോലുള്ള രീതികൾ ഉപയോഗിക്കുന്നു - റെൻഡറിംഗ് സിസ്റ്റത്തിൽ.

ഇസിഎസ് നടപ്പിലാക്കിയതിന് ശേഷം ഇതാണ് സംഭവിച്ചത്.

ഉറവിടങ്ങൾ -> ഇവിടെയാണ് എല്ലാ അസറ്റുകളും (ചിത്രങ്ങൾ)
ഉറവിട
- ഘടകങ്ങൾ
-position.rs
— person.rs
— tennis_court.rs
— floor.rs
- wireframe.rs
— mouse_tracked.rs
- വിഭവങ്ങൾ
— mouse.rs
- സിസ്റ്റങ്ങൾ
- rendering.rs
— നിരന്തരം.rs
— utils.rs
— world_factory.rs -> ലോക ഫാക്ടറി പ്രവർത്തനങ്ങൾ
— main.rs -> പ്രധാന ലൂപ്പ്

ഞങ്ങൾ ആളുകളെ കോടതികളിലേക്ക് നിയോഗിക്കുന്നു

ഇസിഎസ് ജീവിതം എളുപ്പമാക്കി. എന്റിറ്റികളിലേക്ക് ഡാറ്റ ചേർക്കാനും ആ ഡാറ്റയെ അടിസ്ഥാനമാക്കി ലോജിക് ചേർക്കാനും ഇപ്പോൾ എനിക്ക് ഒരു ചിട്ടയായ മാർഗമുണ്ടായിരുന്നു. ഇത്, കോടതികൾക്കിടയിൽ ആളുകളുടെ വിതരണം സംഘടിപ്പിക്കുന്നത് സാധ്യമാക്കി.

ഞാൻ എന്തു ചെയ്തു:

• വ്യക്തിക്ക് നിയുക്ത കോടതികളെക്കുറിച്ചുള്ള ഡാറ്റ ചേർത്തു;
• വിതരണം ചെയ്ത ആളുകളെക്കുറിച്ചുള്ള വിവരങ്ങൾ ടെന്നീസ്കോർട്ടിലേക്ക് ചേർത്തു;
• ആളുകളെയും കോടതികളെയും വിശകലനം ചെയ്യാനും ലഭ്യമായ കോർട്ടുകൾ കണ്ടെത്താനും അവർക്ക് കളിക്കാരെ വിതരണം ചെയ്യാനും നിങ്ങളെ അനുവദിക്കുന്ന CourtChoosingSystem ചേർത്തു;
• ഒരു PersonMovementSystem ചേർത്തു, അത് കോടതികളിൽ നിയോഗിക്കപ്പെട്ട ആളുകളെ തിരയുന്നു, അവർ അവിടെ ഇല്ലെങ്കിൽ, ആളുകളെ ആവശ്യമുള്ളിടത്തേക്ക് അയയ്ക്കുന്നു.

സംഗ്രഹിക്കുന്നു

ഈ ലളിതമായ ഗെയിമിൽ പ്രവർത്തിക്കുന്നത് ഞാൻ ശരിക്കും ആസ്വദിച്ചു. മാത്രമല്ല, ഇത് എഴുതാൻ ഞാൻ റസ്റ്റ് ഉപയോഗിച്ചതിൽ എനിക്ക് സന്തോഷമുണ്ട്, കാരണം:

• തുരുമ്പ് നിങ്ങൾക്ക് ആവശ്യമുള്ളത് നൽകുന്നു;
• ഇതിന് മികച്ച ഡോക്യുമെന്റേഷൻ ഉണ്ട്, തുരുമ്പ് വളരെ ഗംഭീരമാണ്;
• സ്ഥിരത തണുത്തതാണ്;
• നിങ്ങൾ ക്ലോണിംഗ്, പകർത്തൽ അല്ലെങ്കിൽ മറ്റ് സമാന പ്രവർത്തനങ്ങൾ അവലംബിക്കേണ്ടതില്ല, അത് ഞാൻ പലപ്പോഴും C++ ൽ ചെയ്തു;
• ഓപ്ഷനുകൾ ഉപയോഗിക്കാൻ വളരെ എളുപ്പമാണ് കൂടാതെ പിശകുകൾ വളരെ നന്നായി കൈകാര്യം ചെയ്യുന്നു;
• പ്രോജക്റ്റ് കംപൈൽ ചെയ്യാൻ കഴിയുമെങ്കിൽ, അത് 99% സമയവും പ്രവർത്തിക്കുന്നു, അത് കൃത്യമായി പ്രവർത്തിക്കുന്നു. കംപൈലർ പിശക് സന്ദേശങ്ങൾ ഞാൻ കണ്ടതിൽ വച്ച് ഏറ്റവും മികച്ചതാണെന്ന് ഞാൻ കരുതുന്നു.

റസ്റ്റിലെ ഗെയിം വികസനം ആരംഭിക്കുന്നതേയുള്ളൂ. എന്നാൽ എല്ലാവർക്കുമായി റസ്റ്റ് തുറക്കാൻ സുസ്ഥിരവും സാമാന്യം വലിയതുമായ ഒരു കമ്മ്യൂണിറ്റി ഇതിനകം പ്രവർത്തിക്കുന്നുണ്ട്. അതിനാൽ, ഭാഷയുടെ ഭാവിയെ ഞാൻ ശുഭാപ്തിവിശ്വാസത്തോടെ നോക്കുന്നു, ഞങ്ങളുടെ പൊതുവായ ജോലിയുടെ ഫലങ്ങൾക്കായി കാത്തിരിക്കുന്നു.

സ്കിൽബോക്സ് ശുപാർശ ചെയ്യുന്നു:

• ഓൺലൈൻ കോഴ്സ് "പ്രൊഫഷൻ ഫ്രണ്ടൻഡ് ഡെവലപ്പർ".
• പ്രായോഗിക കോഴ്സ് "മൊബൈൽ ഡെവലപ്പർ PRO".
• പ്രായോഗിക വർഷ കോഴ്സ് "0 മുതൽ PRO വരെയുള്ള PHP ഡവലപ്പർ".

അവലംബം: www.habr.com