ຫຼິ້ນ Rust ໃນ 24 ຊົ່ວໂມງ: ປະສົບການການພັດທະນາສ່ວນບຸກຄົນ

ໃນບົດຄວາມນີ້ຂ້ອຍຈະເວົ້າກ່ຽວກັບປະສົບການສ່ວນຕົວຂອງຂ້ອຍໃນການພັດທະນາເກມຂະຫນາດນ້ອຍໃນ Rust. ມັນໃຊ້ເວລາປະມານ 24 ຊົ່ວໂມງເພື່ອສ້າງສະບັບທີ່ເຮັດວຽກ (ຂ້ອຍສ່ວນຫຼາຍແມ່ນເຮັດວຽກໃນຕອນແລງຫຼືໃນທ້າຍອາທິດ). ເກມແມ່ນຢູ່ໄກຈາກສໍາເລັດຮູບ, ແຕ່ຂ້າພະເຈົ້າຄິດວ່າປະສົບການຈະໄດ້ຮັບລາງວັນ. ຂ້ອຍຈະແບ່ງປັນສິ່ງທີ່ຂ້ອຍໄດ້ຮຽນຮູ້ ແລະບາງຂໍ້ສັງເກດທີ່ຂ້ອຍໄດ້ເຮັດໃນຂະນະທີ່ສ້າງເກມຕັ້ງແຕ່ຕົ້ນ.

Skillbox ແນະນໍາ: ຫຼັກສູດພາກປະຕິບັດສອງປີ "ຂ້ອຍເປັນນັກພັດທະນາເວັບ PRO".

ພວກເຮົາເຕືອນ: ສໍາລັບຜູ້ອ່ານທັງຫມົດຂອງ "Habr" - ສ່ວນຫຼຸດ 10 rubles ເມື່ອລົງທະບຽນໃນຫຼັກສູດ Skillbox ໂດຍໃຊ້ລະຫັດສົ່ງເສີມ "Habr".

ເປັນຫຍັງ Rust?

ຂ້ອຍເລືອກພາສານີ້ເພາະວ່າຂ້ອຍໄດ້ຍິນຫຼາຍສິ່ງທີ່ດີກ່ຽວກັບມັນແລະຂ້ອຍເຫັນວ່າມັນກາຍເປັນທີ່ນິຍົມຫລາຍຂຶ້ນໃນການພັດທະນາເກມ. ກ່ອນທີ່ຈະຂຽນເກມ, ຂ້ອຍມີປະສົບການພຽງເລັກນ້ອຍໃນການພັດທະນາແອັບພລິເຄຊັນງ່າຍໆໃນ Rust. ນີ້ແມ່ນພຽງພໍທີ່ຈະໃຫ້ຂ້ອຍມີຄວາມຮູ້ສຶກເສລີພາບໃນຂະນະທີ່ຂຽນເກມ.

ເປັນ​ຫຍັງ​ເກມ​ແລະ​ເກມ​ປະ​ເພດ​ໃດ​?

ການສ້າງເກມແມ່ນມ່ວນ! ຂ້ອຍຕ້ອງການເຫດຜົນເພີ່ມເຕີມ, ແຕ່ສໍາລັບໂຄງການ "ເຮືອນ" ຂ້ອຍເລືອກຫົວຂໍ້ທີ່ບໍ່ກ່ຽວຂ້ອງຢ່າງໃກ້ຊິດກັບວຽກປົກກະຕິຂອງຂ້ອຍ. ນີ້ແມ່ນເກມຫຍັງ? ຂ້ອຍຢາກສ້າງເຄື່ອງຈຳລອງເທນນິດທີ່ລວມເອົາ Cities Skylines, Zoo Tycoon, Prison Architect ແລະ tennis ເອງ. ໂດຍທົ່ວໄປ, ມັນໄດ້ຫັນອອກເປັນເກມກ່ຽວກັບໂຮງຮຽນ tennis ບ່ອນທີ່ປະຊາຊົນມາຫຼິ້ນ.

ການຝຶກອົບຮົມດ້ານວິຊາການ

ຂ້ອຍຕ້ອງການໃຊ້ Rust, ແຕ່ຂ້ອຍບໍ່ຮູ້ວ່າມັນຕ້ອງໃຊ້ເວລາຫຼາຍປານໃດເພື່ອເລີ່ມຕົ້ນ. ຂ້ອຍບໍ່ຕ້ອງການຂຽນ pixel shaders ແລະໃຊ້ drag-n-drop, ສະນັ້ນຂ້ອຍກໍາລັງຊອກຫາວິທີແກ້ໄຂທີ່ຍືດຫຍຸ່ນທີ່ສຸດ.

ຂ້ອຍພົບຊັບພະຍາກອນທີ່ເປັນປະໂຫຍດທີ່ຂ້ອຍແບ່ງປັນກັບທ່ານ:

• ພວກເຮົາກຳລັງຫຼິ້ນຢູ່ບໍ - ບັນຊີລາຍຊື່ຂອງອົງປະກອບ Rust ທີ່ຈໍາເປັນສໍາລັບການພັດທະນາເກມ;
• ເກມ Rust dev subreddit;
• ສິນລະປະ pixels ຟຣີ.

ຂ້າພະເຈົ້າໄດ້ຄົ້ນຫາເຄື່ອງຈັກເກມ Rust ຫຼາຍ, ສຸດທ້າຍເລືອກ Piston ແລະ ggez. ຂ້າພະເຈົ້າໄດ້ພົບເຫັນພວກເຂົາໃນຂະນະທີ່ເຮັດວຽກຢູ່ໃນໂຄງການທີ່ຜ່ານມາ. ໃນທີ່ສຸດ, ຂ້ອຍເລືອກ ggez ເພາະວ່າມັນເບິ່ງຄືວ່າເຫມາະສົມສໍາລັບການປະຕິບັດເກມ 2D ຂະຫນາດນ້ອຍກວ່າ. ໂຄງສ້າງ modular ຂອງ Piston ແມ່ນສັບສົນເກີນໄປສໍາລັບນັກພັດທະນາຈົວ (ຫຼືຜູ້ທີ່ເຮັດວຽກກັບ Rust ຄັ້ງທໍາອິດ).

ໂຄງສ້າງເກມ

ຂ້າພະເຈົ້າໄດ້ໃຊ້ເວລາບາງເວລາຄິດກ່ຽວກັບສະຖາປັດຕະຍະກໍາຂອງໂຄງການ. ຂັ້ນຕອນທໍາອິດແມ່ນເພື່ອເຮັດໃຫ້ "ທີ່ດິນ", ປະຊາຊົນແລະສະຫນາມກິລາ tennis. ປະຊາຊົນຕ້ອງຍ້າຍໄປອ້ອມຮອບສານແລະລໍຖ້າ. ຜູ້ນຕ້ອງມີທັກສະທີ່ປັບປຸງໃນໄລຍະເວລາ. ນອກຈາກນັ້ນ, ຄວນມີບັນນາທິການທີ່ຊ່ວຍໃຫ້ທ່ານສາມາດເພີ່ມຄົນໃຫມ່ແລະສານ, ແຕ່ນີ້ບໍ່ແມ່ນຟຣີອີກຕໍ່ໄປ.

ຄິດວ່າທຸກຢ່າງຜ່ານໄປ, ຂ້ອຍໄດ້ໄປເຮັດວຽກ.

ການສ້າງເກມ

ເລີ່ມຕົ້ນ: ວົງມົນ ແລະບົດຄັດຫຍໍ້

ຂ້າພະເຈົ້າໄດ້ເອົາຕົວຢ່າງຈາກ ggez ແລະໄດ້ຮັບຮູບວົງມົນຢູ່ໃນຫນ້າຈໍ. ອັດສະຈັນ! ໃນປັດຈຸບັນບາງ abstractions. ຂ້າ​ພະ​ເຈົ້າ​ຄິດ​ວ່າ​ມັນ​ຈະ​ເປັນ​ການ​ດີ​ທີ່​ຈະ abstract ອອກ​ຈາກ​ຄວາມ​ຄິດ​ຂອງ​ວັດ​ຖຸ​ເກມ​ໄດ້​. ແຕ່ລະວັດຖຸຕ້ອງໄດ້ຮັບການສະແດງແລະປັບປຸງດັ່ງທີ່ໄດ້ກ່າວຢູ່ທີ່ນີ້:

// 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
— circle.rs
— main.rs -> ສາຍຫຼັກ

ຄົນ, ຊັ້ນແລະຮູບພາບ

ຂັ້ນຕອນຕໍ່ໄປແມ່ນການສ້າງວັດຖຸເກມບຸກຄົນແລະໂຫຼດຮູບພາບ. ທຸກສິ່ງທຸກຢ່າງຄວນຈະຖືກສ້າງຂຶ້ນບົນພື້ນຖານຂອງກະເບື້ອງ 32 * 32.

ສະ ໜາມ ເທັນນິດ

ຫຼັງ​ຈາກ​ການ​ສຶກ​ສາ​ວ່າ​ສະ​ຫນາມ tennis ເບິ່ງ​ຄື​ແນວ​ໃດ, ຂ້າ​ພະ​ເຈົ້າ​ໄດ້​ຕັດ​ສິນ​ໃຈ​ທີ່​ຈະ​ເຮັດ​ໃຫ້​ພວກ​ເຂົາ​ຈາກ 4*2 ກະ​ເບື້ອງ. ໃນ​ເບື້ອງ​ຕົ້ນ​, ມັນ​ເປັນ​ໄປ​ໄດ້​ທີ່​ຈະ​ເຮັດ​ໃຫ້​ຮູບ​ພາບ​ທີ່​ມີ​ຂະ​ຫນາດ​ນີ້​, ຫຼື​ເຮັດ​ໃຫ້​ມີ 8 ກະ​ເບື້ອງ​ແຍກ​ຕ່າງ​ຫາກ​. ແຕ່ຫຼັງຈາກນັ້ນຂ້າພະເຈົ້າຮູ້ວ່າພຽງແຕ່ສອງກະເບື້ອງທີ່ເປັນເອກະລັກແມ່ນຈໍາເປັນ, ແລະນີ້ແມ່ນວ່າເປັນຫຍັງ.

ໃນຈໍານວນທັງຫມົດພວກເຮົາມີສອງກະເບື້ອງດັ່ງກ່າວ: 1 ແລະ 2.

ແຕ່ລະພາກສ່ວນຂອງສານປະກອບດ້ວຍກະເບື້ອງ 1 ຫຼືກະເບື້ອງ 2. ພວກເຂົາສາມາດວາງອອກຕາມປົກກະຕິຫຼື flipped 180 ອົງສາ.

ຮູບແບບການກໍ່ສ້າງພື້ນຖານ (ການປະກອບ).

ຫຼັງຈາກທີ່ຂ້ອຍສາມາດບັນລຸການສະແດງສະຖານທີ່, ຄົນແລະແຜນທີ່, ຂ້ອຍຮູ້ວ່າຮູບແບບການປະກອບພື້ນຖານແມ່ນຈໍາເປັນ. ຂ້າພະເຈົ້າໄດ້ປະຕິບັດມັນເຊັ່ນນີ້: ເມື່ອກົດປຸ່ມ, ວັດຖຸຖືກເລືອກ, ແລະການຄລິກວາງມັນໄວ້ໃນບ່ອນທີ່ຕ້ອງການ. ດັ່ງນັ້ນ, ປຸ່ມ 1 ອະນຸຍາດໃຫ້ທ່ານເລືອກເອົາສານ, ແລະປຸ່ມ 2 ອະນຸຍາດໃຫ້ທ່ານເລືອກເອົາຜູ້ນ.

ແຕ່ພວກເຮົາຍັງຈໍາເປັນຕ້ອງຈື່ຈໍາສິ່ງທີ່ 1 ແລະ 2 ຫມາຍຄວາມວ່າ, ດັ່ງນັ້ນຂ້າພະເຈົ້າໄດ້ເພີ່ມ wireframe ເພື່ອເຮັດໃຫ້ມັນຊັດເຈນວ່າວັດຖຸໃດຖືກເລືອກ. ນີ້ແມ່ນສິ່ງທີ່ມັນຄ້າຍຄື.

ຄໍາຖາມກ່ຽວກັບສະຖາປັດຕະຍະກໍາແລະ refactoring

ດຽວນີ້ຂ້ອຍມີວັດຖຸເກມຫຼາຍຢ່າງ: ຄົນ, ສານ ແລະຊັ້ນ. ແຕ່ເພື່ອໃຫ້ wireframes ເຮັດວຽກ, ແຕ່ລະຫນ່ວຍງານຂອງວັດຖຸຈໍາເປັນຕ້ອງໄດ້ຮັບການບອກວ່າວັດຖຸຕົວມັນເອງຢູ່ໃນຮູບແບບການສາທິດ, ຫຼືວ່າກອບແມ່ນແຕ້ມພຽງແຕ່. ອັນນີ້ບໍ່ສະດວກຫຼາຍ.

ມັນເບິ່ງຄືວ່າສະຖາປັດຕະຍະ ກຳ ຕ້ອງໄດ້ຮັບການຄິດຄືນ ໃໝ່ ໃນວິທີທີ່ເປີດເຜີຍຂໍ້ ຈຳ ກັດບາງຢ່າງ:

• ການມີໜ່ວຍງານທີ່ສະແດງ ແລະ ອັບເດດຕົວມັນເອງເປັນບັນຫາເພາະວ່າໜ່ວຍງານນັ້ນຈະບໍ່ສາມາດ “ຮູ້” ສິ່ງທີ່ມັນຄວນຈະສະແດງໄດ້ - ຮູບພາບ ແລະ wireframe;
• ການຂາດເຄື່ອງມືສໍາລັບການແລກປ່ຽນຄຸນສົມບັດແລະພຶດຕິກໍາລະຫວ່າງບຸກຄົນ (ຕົວຢ່າງ, ຄຸນສົມບັດ is_build_mode ຫຼືການສະແດງພຶດຕິກໍາ). ມັນຈະເປັນໄປໄດ້ທີ່ຈະນໍາໃຊ້ມໍລະດົກ, ເຖິງແມ່ນວ່າບໍ່ມີວິທີທີ່ເຫມາະສົມທີ່ຈະປະຕິບັດມັນຢູ່ໃນ Rust. ສິ່ງທີ່ຂ້ອຍຕ້ອງການແທ້ໆແມ່ນຮູບແບບ;
• ເຄື່ອງມືສໍາລັບການປະຕິສໍາພັນລະຫວ່າງຫນ່ວຍງານແມ່ນຈໍາເປັນເພື່ອມອບຫມາຍປະຊາຊົນໃຫ້ກັບສານ;
• ຫນ່ວຍງານຂອງຕົວເອງແມ່ນການປະສົມຂອງຂໍ້ມູນແລະເຫດຜົນທີ່ອອກຈາກການຄວບຄຸມຢ່າງໄວວາ.

ຂ້າພະເຈົ້າໄດ້ຄົ້ນຄ້ວາຕື່ມອີກແລະຄົ້ນພົບສະຖາປັດຕະຍະກໍາ ECS - ລະບົບອົງປະກອບຫົວໜ່ວຍ, ເຊິ່ງຖືກນໍາໃຊ້ທົ່ວໄປໃນເກມ. ນີ້ແມ່ນຜົນປະໂຫຍດຂອງ ECS:

• ຂໍ້ມູນຖືກແຍກອອກຈາກເຫດຜົນ;
• ອົງປະກອບແທນທີ່ຈະເປັນມໍລະດົກ;
• ສະຖາປັດຕະຍະກໍາຂໍ້ມູນເປັນສູນກາງ.

ECS ມີລັກສະນະໂດຍສາມແນວຄວາມຄິດພື້ນຖານ:

• entities - ປະເພດຂອງວັດຖຸທີ່ຕົວລະບຸຫມາຍເຖິງ (ມັນອາດຈະເປັນຜູ້ນ, ບານ, ຫຼືບາງສິ່ງບາງຢ່າງອື່ນ);
• ອົງປະກອບ - ຫນ່ວຍງານແມ່ນປະກອບດ້ວຍພວກມັນ. ຕົວຢ່າງ - rendering component, ສະຖານທີ່ແລະອື່ນໆ. ເຫຼົ່ານີ້ແມ່ນຄັງຂໍ້ມູນ;
• ລະບົບ - ພວກເຂົາໃຊ້ທັງວັດຖຸແລະອົງປະກອບ, ບວກກັບພຶດຕິກໍາແລະເຫດຜົນທີ່ອີງໃສ່ຂໍ້ມູນນີ້. ຕົວຢ່າງແມ່ນລະບົບການສະແດງຜົນທີ່ເຮັດຊ້ຳຜ່ານທຸກຫົວໜ່ວຍທີ່ມີອົງປະກອບການສະແດງຜົນ ແລະເຮັດການສະແດງຜົນ.

ຫຼັງຈາກການສຶກສາມັນ, ມັນເຫັນໄດ້ຊັດເຈນວ່າ ECS ແກ້ໄຂບັນຫາຕໍ່ໄປນີ້:

• ການ​ນໍາ​ໃຊ້​ຮູບ​ແບບ​ແທນ​ທີ່​ຈະ​ເປັນ​ການ​ສືບ​ທອດ​ເພື່ອ​ຈັດ​ຕັ້ງ​ຫນ່ວຍ​ງານ​ເປັນ​ລະ​ບົບ​;
• ການກໍາຈັດລະຫັດ jumble ຜ່ານລະບົບການຄວບຄຸມ;
• ການນໍາໃຊ້ວິທີການເຊັ່ນ is_build_mode ເພື່ອຮັກສາເຫດຜົນຂອງ wireframe ຢູ່ໃນສະຖານທີ່ດຽວກັນ - ໃນລະບົບການສະແດງຜົນ.

ນີ້ແມ່ນສິ່ງທີ່ເກີດຂຶ້ນຫຼັງຈາກການປະຕິບັດ ECS.

ຊັບພະຍາກອນ -> ນີ້ແມ່ນບ່ອນທີ່ຊັບສິນທັງຫມົດ (ຮູບພາບ)
src
- ອົງປະກອບ
— 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;
• ເພີ່ມ CourtChoosingSystem, ເຊິ່ງຊ່ວຍໃຫ້ທ່ານສາມາດວິເຄາະຄົນແລະສານ, ກວດພົບສານທີ່ມີແລະແຈກຢາຍຜູ້ນໃຫ້ພວກເຂົາ;
• ເພີ່ມລະບົບ PersonMovementSystem, ເຊິ່ງຊອກຫາຄົນທີ່ຖືກມອບຫມາຍໃຫ້ສານ, ແລະຖ້າພວກເຂົາບໍ່ຢູ່ທີ່ນັ້ນ, ຫຼັງຈາກນັ້ນສົ່ງຄົນໄປບ່ອນທີ່ພວກເຂົາຕ້ອງການ.

Summing up

ຂ້ອຍມັກເຮັດວຽກຢູ່ໃນເກມງ່າຍໆນີ້ແທ້ໆ. ຍິ່ງໄປກວ່ານັ້ນ, ຂ້ອຍດີໃຈທີ່ຂ້ອຍໃຊ້ Rust ຂຽນມັນ, ເພາະວ່າ:

• Rust ໃຫ້ທ່ານສິ່ງທີ່ທ່ານຕ້ອງການ;
• ມັນມີເອກະສານທີ່ດີເລີດ, Rust ແມ່ນຂ້ອນຂ້າງສະຫງ່າງາມ;
• ຄວາມສອດຄ່ອງແມ່ນເຢັນ;
• ທ່ານບໍ່ຈໍາເປັນຕ້ອງຫັນໄປຫາ cloning, ສໍາເນົາຫຼືການປະຕິບັດທີ່ຄ້າຍຄືກັນອື່ນໆ, ທີ່ຂ້າພະເຈົ້າມັກຈະເຮັດໃນ C ++;
• ທາງເລືອກແມ່ນໃຊ້ງ່າຍຫຼາຍແລະຈັດການຄວາມຜິດພາດໄດ້ດີຫຼາຍ;
• ຖ້າໂຄງການສາມາດລວບລວມໄດ້, ຫຼັງຈາກນັ້ນ 99% ຂອງເວລາທີ່ມັນເຮັດວຽກ, ແລະແນ່ນອນວ່າມັນຄວນຈະເປັນ. ຂ້າພະເຈົ້າຄິດວ່າຂໍ້ຄວາມຄວາມຜິດພາດຂອງ compiler ແມ່ນດີທີ່ສຸດທີ່ຂ້ອຍໄດ້ເຫັນ.

ການພັດທະນາເກມໃນ Rust ແມ່ນພຽງແຕ່ເລີ່ມຕົ້ນ. ແຕ່ມີຊຸມຊົນທີ່ຫມັ້ນຄົງແລະຂະຫນາດໃຫຍ່ພໍສົມຄວນເຮັດວຽກເພື່ອເປີດ Rust ກັບທຸກຄົນ. ດັ່ງນັ້ນ, ຂ້າພະເຈົ້າເບິ່ງອະນາຄົດຂອງພາສາດ້ວຍແງ່ດີ, ຫວັງວ່າຜົນໄດ້ຮັບຂອງການເຮັດວຽກຮ່ວມກັນຂອງພວກເຮົາ.

Skillbox ແນະນໍາ:

• ຫຼັກສູດອອນໄລນ "ນັກພັດທະນາດ້ານຫນ້າດ້ານວິຊາຊີບ".
• ຫຼັກສູດພາກປະຕິບັດ "ຜູ້ພັດທະນາມືຖື PRO".
• ຫຼັກສູດພາກປະຕິບັດ "ນັກພັດທະນາ PHP ຈາກ 0 ເຖິງ PRO".

ແຫຼ່ງຂໍ້ມູນ: www.habr.com