ดาวน์โหลดแอป unity 3d สำหรับ Android การใช้ Unity ในการพัฒนาแอพพลิเคชั่น วิธีสร้างเกมใน Unity
การพัฒนาเกมสำหรับอุปกรณ์ Android OS ต้องใช้แนวทางที่คล้ายกับการพัฒนาสำหรับ iOS ในทางกลับกัน ฮาร์ดแวร์ของอุปกรณ์ Android ไม่ได้อยู่ภายใต้มาตรฐานที่ชัดเจน ซึ่งทำให้จำเป็นต้องแก้ไขปัญหาที่ขาดหายไปเมื่อทำงานกับ iOS นอกจากนี้ยังมีความแตกต่างระหว่าง Unity เวอร์ชัน Android และ iOS
การเตรียมสภาพแวดล้อมการพัฒนา Android
ก่อนที่คุณจะสามารถทดสอบเกมของคุณบนอุปกรณ์ คุณจะต้องเตรียมสภาพแวดล้อมการพัฒนาของคุณ โดยเฉพาะอย่างยิ่ง ให้ดาวน์โหลดและติดตั้ง Android SDK ของแพลตฟอร์มที่ต้องการ และเพิ่มอุปกรณ์ของคุณลงในระบบ (กระบวนการนี้จะต่างกันสำหรับ Windows และ Mac) รายละเอียดนี้เขียนไว้บนเว็บไซต์นักพัฒนา Android และผู้ผลิตอุปกรณ์ของคุณอาจให้ข้อมูลเพิ่มเติม เนื่องจากเป็นกระบวนการที่ค่อนข้างซับซ้อน เราจึงได้เตรียมคำแนะนำเล็กๆ น้อยๆ ที่จะช่วยให้คุณเตรียมทุกสิ่งที่จำเป็นสำหรับการพัฒนา หากต้องการข้อมูลเพิ่มเติม คุณสามารถรับได้จากพอร์ทัลนักพัฒนาซอฟต์แวร์ Android
เข้าถึงคุณสมบัติของ Android
Unity มี API สำหรับเข้าถึงอินพุตและการตั้งค่าของ Android คลาสที่มีอยู่ได้รับการบันทึกไว้ในหน้า Code for Android Assemblies
การเชื่อมโยงรหัส C, C++ หรือ Java กับสคริปต์
Unity อนุญาตให้คุณเรียกใช้ฟังก์ชันที่เขียนด้วย C/C++ ได้โดยตรงจากสคริปต์ (ฟังก์ชัน Java สามารถเรียกทางอ้อมได้) หากต้องการเรียนรู้วิธีเข้าถึงฟังก์ชันจากโค้ดเนทีฟจาก Unity ให้ไปที่หน้าการสร้างปลั๊กอิน Android
Occlusion Culling (การตัดรูปเรขาคณิตที่มองไม่เห็น)
Unity ให้การสนับสนุนการคัดแยกการบดเคี้ยว ซึ่งมีประโยชน์มากเมื่อทำการเพิ่มประสิทธิภาพสำหรับแพลตฟอร์มมือถือ ดูข้อมูลเพิ่มเติมได้ในหน้าการเลือกการบดเคี้ยว
การปรับแต่งหน้าจอเริ่มต้น
หน้าจอเริ่มต้นที่แสดงเมื่อเริ่มเกมสามารถปรับแต่งได้ - ดูหน้านี้สำหรับข้อมูลเพิ่มเติม
การแก้ไขปัญหาและการรายงานข้อผิดพลาด
มีสาเหตุหลายประการที่ทำให้แอปของคุณขัดข้องหรือทำงานไม่ถูกต้อง คำแนะนำในการแก้ปัญหาเฉพาะของ Android จะช่วยคุณจัดการกับสาเหตุของข้อผิดพลาดในเวลาที่สั้นที่สุด หากหลังจากอ่านคู่มือแล้ว คุณคิดว่าปัญหาอยู่ใน Unity คุณควรยื่นรายงานข้อบกพร่อง อ้างถึงหน้านี้สำหรับคำแนะนำ
Unity สำหรับ Android แตกต่างจากเวอร์ชันเดสก์ท็อปอย่างไร
JavaScript พร้อมการพิมพ์ที่แข็งแกร่ง
เพื่อปรับปรุงประสิทธิภาพใน Unity เวอร์ชัน Android การพิมพ์แบบไดนามิกใน JavaScript จะถูกปิดใช้งานเสมอ (ราวกับว่า #pragma strict ถูกนำไปใช้กับแต่ละสคริปต์โดยอัตโนมัติ) นี่เป็นสิ่งสำคัญที่ต้องจำไว้ว่า หากคุณกำลังพอร์ตโปรเจ็กต์ไปยัง Android จากแพลตฟอร์มรุ่นเก่า และหากคุณพบข้อผิดพลาดในการรวบรวม ปัญหาควรได้รับการมองหาก่อนอื่นในการพิมพ์ ข้อผิดพลาดดังกล่าวมักจะจัดการได้ง่ายโดยตรวจสอบให้แน่ใจว่าได้ระบุประเภทของตัวแปรทั้งหมดอย่างชัดเจนหรือส่งในระหว่างการเริ่มต้น
แม้ว่า Unity Android จะรองรับพื้นผิว DXT/PVRTC/ATC แต่ Unity จะขยายขนาดพื้นผิวให้อยู่ในรูปแบบ RGB(A) บนรันไทม์ หากวิธีการบีบอัดเหล่านี้ไม่ได้รับการสนับสนุนบนอุปกรณ์เฉพาะ ซึ่งอาจส่งผลต่อประสิทธิภาพการเรนเดอร์ GPU อย่างจริงจัง ดังนั้นจึงขอแนะนำให้ใช้รูปแบบ ETC เป็นมาตรฐานโดยพฤตินัยสำหรับ Android และควรได้รับการสนับสนุนจากอุปกรณ์ที่ทันสมัยทั้งหมด ในทางกลับกัน ETC ไม่รองรับอัลฟาแชนเนล และบางครั้งพื้นผิว RGBA แบบ 16 บิตจะเป็นตัวเลือกที่ดีที่สุดในแง่ของคุณภาพ ขนาด และความเร็วในการเรนเดอร์ซึ่งจำเป็นต้องใช้อัลฟาแชนเนล
โพสต์จำนวนการดู: 19 374
เราได้พูดคุยเกี่ยวกับวิธีสร้างเกมของคุณเองบน Android โดยใช้ Unreal Engine ในบทความนี้ เราจะมาดูกลไกการพัฒนาเกมที่ได้รับความนิยมไม่แพ้กัน - ความสามัคคี
ความสามัคคีเป็นเครื่องมือที่มีชื่อเสียงมากในหมู่นักพัฒนาอินดี้ อันที่จริงมันเป็นเอ็นจิ้นข้ามแพลตฟอร์มที่ให้คุณพัฒนาได้ 3D- และ 2D-เกม. คุณลักษณะที่ทำให้ Unity แตกต่างจากเอ็นจิ้นอื่นๆ คือเกณฑ์การเข้าต่ำสำหรับผู้เริ่มต้น ในขณะที่มีชุดเครื่องมือที่หลากหลายสำหรับมืออาชีพ ข้ามแพลตฟอร์มช่วยให้คุณพัฒนาแอปพลิเคชันสำหรับแพลตฟอร์มใดก็ได้ตั้งแต่เกมเดสก์ท็อปไปจนถึงมือถือ
แยกเป็นมูลค่าการกล่าวขวัญระบบการสมัครสมาชิกเนื่องจาก Unity ไม่ใช่ผลิตภัณฑ์ฟรีโดยสมบูรณ์ การสมัครสมาชิกมีหลายประเภท:
- ส่วนตัว. รุ่นฟรีที่มีคุณสมบัติหลักทั้งหมดของเครื่องยนต์ โดยมีข้อจำกัดดังนี้ รายได้ต่อปีหรือจำนวนเงินที่ระดมได้ต้องไม่เกิน 100000$ .
- พลัส. ต่อ $35 ต่อเดือนมีรายงานและการวิเคราะห์ต่างๆ รวมถึงความสามารถในการเปลี่ยนหน้าจอสแปลช 20% - ส่วนลดเมื่อซื้อสินค้าใน ร้านค้าสินทรัพย์และประโยชน์เล็กน้อยต่างๆ โดยมีข้อจำกัดดังนี้ รายได้สำหรับปีหรือจำนวนเงินที่ระดมได้ต้องไม่เกิน 200000$ .
- มือโปร. ต่อ 125 เหรียญต่อเดือนรวมคุณประโยชน์ทั้งหมดของเวอร์ชันนี้ด้วย พลัสและบริการระดับมืออาชีพเพิ่มเติมและการสนับสนุนระดับพรีเมียม ไม่มีข้อ จำกัด ในการหมุนเวียนหรือจำนวนเงิน
- แยกเวอร์ชันสำหรับธุรกิจ (ใช้โดยบริษัทขนาดใหญ่)
ดังนั้นนักพัฒนาอินดี้ที่มีงบประมาณน้อยจึงควรพอใจกับเวอร์ชันนี้ ส่วนตัวหรือ พลัสมิฉะนั้นคุณจะต้องสมัครสมาชิก มือโปร. ในบทความนี้เราจะใช้ รุ่นฟรีสำหรับการวิ่งครั้งแรก
ขั้นตอนที่ 1 ติดตั้ง Unity
ในการเริ่มติดตั้ง Unity คุณต้องไปที่เว็บไซต์ Unity Store ซึ่งคุณจะได้รับแจ้งให้เลือกประเภทการสมัคร ตามที่กล่าวไว้ข้างต้น เราเลือก ส่วนตัว.
จากนั้น คุณจะได้รับแจ้งให้ยอมรับข้อกำหนดการใช้งานและดาวน์โหลดตัวติดตั้ง นอกจากนี้คุณยังสามารถตรวจสอบ ความต้องการของระบบเพื่อร่วมงานกับสามัคคี
หลังจากเปิดตัวติดตั้ง คุณจะได้รับแจ้งให้เลือกส่วนประกอบที่จะติดตั้ง เนื่องจากเราต้องสร้างแอปพลิเคชัน Android เราจะทำเครื่องหมายในช่องสำหรับ รองรับ Android Build. นอกจากนี้ หากต้องการ แทนที่จะติดตั้งด้วย Unity คุณสามารถติดตั้ง Visual Studio Community 2017สำหรับการเขียนโปรแกรมบน ค#.
หลังจากนั้น ที่เหลือก็แค่เลือกพาธการติดตั้งและเริ่มการติดตั้ง Unity
ขั้นตอนที่ 2: การลงทะเบียนและตั้งค่า Unity
หลังจากเสร็จสิ้นการติดตั้งและเรียกใช้ Unity เราจะได้รับแจ้งให้เข้าสู่ระบบด้วยบัญชีของเรา
จากนั้นอีกครั้ง ระบบจะขอให้คุณเลือกการสมัครรับข้อมูล เราจะเน้นที่ Personal ด้วย ในกรณีนี้ คุณจะต้องยืนยันว่ารายได้ต่อปีของบริษัทน้อยกว่า $100,000 หรือ Unity ใช้เพื่อวัตถุประสงค์ในการฝึกอบรม
ในตอนท้าย ขอเสนอให้ทำแบบสำรวจเล็กๆ น้อยๆ ซึ่งคุณต้องตอบสิ่งที่คุณทำและเพื่อจุดประสงค์ที่คุณติดตั้ง Unity
ขั้นตอนที่ 3 สร้างโครงการใหม่
เมื่อกำหนดค่า Unity เราก็ไปที่หน้าจอเพื่อเลือก / สร้างโครงการ คลิกที่นี่ ใหม่เพื่อสร้าง .ของคุณ โครงการใหม่.
หลังจากนั้น ในหน้าต่างที่ปรากฏขึ้น ระบบจะขอให้คุณป้อนชื่อโครงการและไดเร็กทอรีที่จะตั้งอยู่ อย่าลืมทำเครื่องหมายที่ช่อง 3Dเพื่อใช้ตัวแก้ไขในโหมด 3 มิติ
เมื่อเสร็จแล้วให้คลิก สร้างโครงการเพื่อสร้างโครงการ หลังจากนั้น หน้าต่างตัวแก้ไขจะเปิดขึ้นพร้อมกับฉากที่สร้างไว้ล่วงหน้า
เราจะยังไม่จัดการกับความซับซ้อนของการเขียนโปรแกรมและยกตัวอย่าง จบเกม. สำหรับสิ่งนี้มี ร้านค้าสินทรัพย์ซึ่งมีโมเดลสำเร็จรูป แอนิเมชั่น เสียง (และแม้แต่เกม) สำเร็จรูปจำนวนมาก ทั้งแบบชำระเงินและแบบฟรี
ในการเปิด Asset Store คุณต้องมีในเมนู หน้าต่างเลือก ร้านค้าสินทรัพย์(คีย์ผสม ctrl-9).
หน้าต่างร้านค้าจะเปิดขึ้น เข้าสู่แถบค้นหา " เกมตัวอย่างสไตล์เครื่องปัดนก" และเปิดตัวอย่างฟรีที่เราจะใช้ในโครงการของเรา
คลิก ดาวน์โหลดและเมื่อดาวน์โหลดแล้ว คุณสามารถนำเข้าไปยังโครงการของคุณได้ เมื่อต้องการทำเช่นนี้ คลิก นำเข้าหลังจากนั้นจะมีคำเตือนปรากฏขึ้นว่าการตั้งค่าโปรเจ็กต์จะเปลี่ยนไปหลังจากนำเข้า
หลังจากตกลงที่จะนำเข้า คุณจะเห็นหน้าต่างที่คุณต้องเลือกส่วนประกอบที่จะนำเข้า เลือกทั้งหมดแล้วคลิก นำเข้า.
เมื่อการนำเข้าเสร็จสมบูรณ์ คุณจะเห็นไฟล์ใหม่ใน Project Browser นี่คือไฟล์เกม ในการเปิดฉากในตัวแก้ไข ให้ขยาย สไตล์เครื่องปัดนก - ฉากและดับเบิ้ลคลิกที่ หลัก.
ด้วยเหตุนี้ ฉากเกมจะปรากฏในหน้าต่างตัวแก้ไข 3 มิติ
คุณสามารถตรวจสอบว่าเกมทำงานอย่างไรใน Unity โดยคลิกที่ปุ่ม เล่นเหนือหน้าต่างตัวแก้ไข
ขั้นตอนที่ 4กำหนดค่าเครื่องมือ Android
บันทึก:หากคุณกำลังใช้ หุ่นยนต์สตูดิโอแสดงว่าคุณได้ติดตั้งทุกอย่างเรียบร้อยแล้ว ส่วนประกอบที่จำเป็นเพื่อให้คุณสามารถไปยังขั้นตอนต่อไปได้อย่างปลอดภัย
ในการประกอบเกมที่ได้บน Android คุณต้องติดตั้งเครื่องมือต่อไปนี้:
- ชุดพัฒนา Java (JDK)คุณสามารถดาวน์โหลดได้จากเว็บไซต์ Java โดยคลิกที่ลิงค์คุณจะเห็นที่ด้านบนสุด แพลตฟอร์มจาวา (JDK), คลิกที่ ดาวน์โหลดข้างคำจารึก จากนั้นเลือกระบบปฏิบัติการของคุณและเริ่มดาวน์โหลด หลังจากนั้นเพียงทำตามคำแนะนำของโปรแกรมติดตั้ง
- Android SDK. โดยมากที่สุด ด้วยวิธีง่ายๆการติดตั้งเวอร์ชันล่าสุดคือการดาวน์โหลด Android Studio ที่ SDK นี้มา โดยไปที่เว็บไซต์ Android Studio แล้วคลิก ดาวน์โหลด Android Studio. โปรแกรมติดตั้ง Android Studio จะติดตั้งส่วนประกอบ Android SDK หลักที่จำเป็นสำหรับการพัฒนา Android
ขั้นตอนที่ 5. เตรียมโครงการสำหรับการเปิดตัว
ก่อนอื่น คุณต้องเปลี่ยนแพลตฟอร์มการพัฒนาเป็น Android ในการดำเนินการนี้ ใน Unity ให้เปิดเมนูไฟล์และเลือกการตั้งค่าบิลด์
ในหน้าต่างที่ปรากฏขึ้น ให้เลือก Androidแล้วกด สลับแพลตฟอร์ม.
สวิตช์แพลตฟอร์มบอกเราว่าเรากำลังสร้างแอป Android ซึ่งหมายความว่าเมื่อเราสร้างแอปพลิเคชัน Unity จะสร้าง ไฟล์ APK. สวิตช์แพลตฟอร์มยังบังคับให้ Unity นำเข้าสินทรัพย์ทั้งหมดในโครงการอีกครั้ง การดำเนินการนี้จะใช้เวลาไม่นานสำหรับโปรเจ็กต์ขนาดเล็ก แต่โปรดทราบว่าการดำเนินการนี้อาจใช้เวลานานสำหรับโปรเจ็กต์ขนาดใหญ่
ตอนนี้เราต้องระบุชื่อแพ็คเกจสำหรับแอปพลิเคชัน
บันทึก:ชื่อแพ็คเกจเป็นตัวระบุเฉพาะสำหรับแอปพลิเคชันและเขียนด้วยรูปแบบ DNS ย้อนกลับในรูปแบบ com.CompanyName.ProductName. เมื่อเผยแพร่แอปบน Google Play แล้ว จะไม่สามารถเปลี่ยนชื่อแพ็กเกจได้อีกต่อไป
โดยไปที่เมนู แก้ไขแล้วเลือก การตั้งค่าโปรเจ็กต์ - ผู้เล่น.
ทางด้านขวาของ Unity หน้าต่างจะเปิดขึ้นพร้อมการตั้งค่าต่างๆ เช่น เวอร์ชันแอปพลิเคชัน เป้าหมายและ SDK ขั้นต่ำ การเลือกไอคอน ฯลฯ ที่นี่เราต้องการในบล็อก การตั้งค่าอื่นๆหา บัตรประจำตัวและตั้งชื่อแพ็คเกจในช่อง ชื่อแพ็คเกจ. คุณยังสามารถเปลี่ยนการตั้งค่าอื่นๆ ได้หากต้องการ
ตอนนี้เหลือเพียงการระบุเส้นทางไปยัง Android SDK และ JDK ในการดำเนินการนี้ ให้ไปที่เมนูแล้วเลือก แก้ไขการตั้งค่า.
ในหน้าต่างที่ปรากฏขึ้น ให้ไปที่ เครื่องมือภายนอกและในทุ่งนา SDKและ JDKระบุเส้นทางที่เหมาะสม แล้วปิดหน้าต่าง
ขั้นตอนที่ 6: การสร้างและเรียกใช้แอปพลิเคชัน
ได้เวลาสร้างแอป Unity แรกของคุณแล้ว โดยเลือกจากเมนู ไฟล์ - การตั้งค่าบิลด์. หน้าต่างจะเปิดขึ้น ซึ่งคุณจะต้องเพิ่มฉากที่คุณต้องการประกอบ เนื่องจากเรามีฉากนี้เปิดอยู่ในตัวแก้ไขอยู่แล้ว ให้คลิก เพิ่มฉากเปิดเพื่อเพิ่มลงในแอสเซมบลี หลังจากเพิ่มแล้ว คุณจะเห็นมันในรายการฉาก
เหลือเพียงกด สร้างหลังจากนั้น Unity จะเริ่มสร้างแอปพลิเคชัน ก่อนหน้านั้น ระบบอาจขอให้คุณเลือกโฟลเดอร์ที่จะบันทึกไฟล์แอปพลิเคชันที่รวบรวมไว้ รวมทั้งชื่อไฟล์ APK
บันทึก:ในขณะนี้ หากคุณมีเวอร์ชันอัลฟ่าติดตั้งอยู่ใน Android SDK เครื่องมือสร้าง(เวอร์ชั่น 28.0.0-rc1) เมื่อสร้าง Gradle จะเกิดข้อผิดพลาด ในการแก้ไขปัญหานี้ เพียงลบเวอร์ชันนี้ออกจาก Android SDK
ด้วยเหตุนี้ ไฟล์ APK ที่สร้างขึ้นจะปรากฏในโฟลเดอร์ที่คุณระบุ พร้อมที่จะติดตั้งบนอีมูเลเตอร์หรือบนอุปกรณ์จริง
มาดูกันว่ามีอะไรอยู่ใน APK ที่สร้างขึ้น ในการดำเนินการนี้ เราใช้ยูทิลิตี้ ตัววิเคราะห์ APKซึ่งรวมอยู่ใน Android Studio
ขนาดไฟล์ APK ที่ไม่บีบอัดคือ 21.1MBในการบีบอัด 20.9MB. ดังที่คุณเห็นจากกราฟ โวลุ่มส่วนใหญ่ถูกครอบครองโดยไลบรารีของบุคคลที่สามที่เพิ่มโดย Unity จากนั้นใน ทรัพย์สินทรัพยากรทั้งหมดที่ใช้ในฉากประกอบตั้งอยู่ ไฟล์ class.dexมีเพียง 89 ชั้นเรียนและ 479 วิธีการ
ยิ่งกว่านั้นถ้าคุณดู AndroidManifest.xml, แอปพลิเคชันประกอบด้วยหนึ่งกิจกรรม
บทสรุป
นั่นคือทั้งหมดที่ ในบทความนี้ เราได้เรียนรู้วิธีติดตั้งและกำหนดค่า Unity และสร้างแอป Android เครื่องแรกของเราด้วย
ความสามัคคีเป็นเครื่องมือที่ส่วนใหญ่ เกมสมัยใหม่บนแพลตฟอร์มต่างๆ ด้วยเอ็นจิ้น มันเป็นไปได้ที่จะสร้างเกมที่เน้นให้ทำงานบนคอมพิวเตอร์ (Windows, Linux, MacOS) โทรศัพท์มือถือ, คอมพิวเตอร์แท็บเล็ต (Android, iOS) และแม้กระทั่ง เครื่องเล่นเกมเพลย์สเตชัน เอกซ์บอกซ์ นินเทนโด
จะสร้างเกมใน Unity ได้อย่างไร?
ความสามัคคีขึ้นอยู่กับแนวคิดเชิงองค์ประกอบ อันที่จริง เกมใดๆ ก็ตามประกอบด้วยวัตถุจำนวนมากที่เจือจางด้วยส่วนประกอบเพิ่มเติม ตัวอย่างเช่น ในระหว่างการสร้าง platformer เราสร้าง GameObject แนบองค์ประกอบกราฟิกเพิ่มเติมซึ่งมีหน้าที่ในการแสดงตัวละครและส่วนประกอบควบคุม ให้การควบคุมตัวละครโดยใช้เมาส์ คีย์บอร์ด จอยสติ๊กหรือ หน้าจอสัมผัส. เครื่องยนต์ไม่ได้กำหนดข้อจำกัดจำนวนโมดูลดังกล่าว เราสามารถเพิ่มส่วนประกอบให้กับ GameObject ได้มากเท่าที่ต้องการ การทำงานทั้งหมดบนเอ็นจิ้นนั้นขึ้นอยู่กับการสร้าง GameObject และการใช้ส่วนประกอบที่เหมาะสมกับพวกมัน
ผู้เริ่มต้นอาจเข้าใจผิดโดยความเรียบง่ายที่ชัดเจนของกระบวนการ แม้ว่าจะไม่ใช่กรณีนี้ก็ตาม ในการสร้างเกมที่มีเอกลักษณ์และเป็นที่นิยม คุณต้องเขียนส่วนประกอบจำนวนมากตั้งแต่เริ่มต้น โดยเฉพาะอย่างยิ่งในสภาพแวดล้อม Unity สิ่งนี้เรียกว่าสคริปต์ ภาษาสคริปต์ดั้งเดิมคือ C# แต่ JavaScript และ Boo (เวอร์ชันที่ครอบตัดของ Python) ก็ถูกใช้บางส่วนเช่นกัน การสร้างส่วนประกอบของคุณเองไม่ใช่เรื่องง่าย บางคนอาจกล่าวได้ว่ามันเป็นขั้นตอนที่ซับซ้อน ซึ่งเชื่อมโยงโดยตรงกับการเขียนโปรแกรมแบบคลาสสิก หากไม่มีความรู้ด้านการเขียนโปรแกรมเพียงพอก็จะยาก
แพลตฟอร์มที่รองรับ
โปรเจ็กต์ขนาดใหญ่จำนวนมากชอบ Unity เพราะมีรายการแพลตฟอร์มจำนวนมากที่เข้ากันได้กับเอ็นจิ้น แอปพลิเคชันที่เสร็จสิ้นแล้วสามารถเปิดใช้บนระบบปฏิบัติการคอมพิวเตอร์ แพลตฟอร์มมือถือยอดนิยม และ SmartTV เราจะพูดอะไรได้ แม้แต่เกมเบราว์เซอร์และแอปพลิเคชันสำหรับแพลตฟอร์มเฉพาะ ( เช่น Tizen OS) ได้รับการพัฒนาอย่างเด่นชัดใน Unity
อย่างไรก็ตามไม่ใช่ทุกอย่างจะราบรื่นที่นี่ หากจำเป็น คุณสามารถเขียนอัลกอริทึมเฉพาะตามโค้ดระดับต่ำ สำหรับ Android เครื่องเดียวกัน คุณต้องมีความรู้เกี่ยวกับ Java อย่างละเอียด
เช่นเดียวกับ iOS คุณลักษณะอื่นของ iOS คือสามารถพัฒนาได้จากคอมพิวเตอร์หรือแท็บเล็ตจาก Apple เท่านั้น ในกรณีที่ไม่มี Macbook หรืออุปกรณ์ที่คล้ายคลึงกัน การเปิดตัวเกมจะหยุดลงอย่างรวดเร็วและ Unity ไม่มีส่วนเกี่ยวข้องกับมัน Apple เองกำหนดข้อ จำกัด ที่คล้ายกัน ข้อสรุปนั้นง่าย: หากมีการพัฒนา iOS ในแผน คุณควรเลือกอุปกรณ์ที่เหมาะสมสำหรับการประกอบล่วงหน้า
จะพัฒนาเกมบนเอ็นจิ้นได้อย่างไรและที่ไหน?
เราสามารถดำเนินการพัฒนาเกมได้ยาวนานทั้งภายใน Windows และ Mac OS X มีตัวแก้ไขสำหรับ Linux อยู่แล้ว แต่จนถึงขณะนี้ เราไม่สามารถวางใจได้ว่าจะมีความเสถียรในการทำงาน นักพัฒนาซอฟต์แวร์ใช้เวลาส่วนใหญ่ในการสร้างเกมในตัวแก้ไข Unity เรายังมีเวลาอีกมากในการเขียนโค้ดสคริปต์ เราสามารถสร้างโค้ดได้ใน MonoDevelop มาตรฐานหรือในโปรแกรมแก้ไขของบริษัทอื่น ตอนนี้พวกเขาใช้ Visual Studio เช่นเดียวกับ Sublime Text แต่มีการกำหนดค่าที่เหมาะสมเท่านั้น
การพัฒนา แอปพลิเคชั่นมือถือเป็นหนึ่งในอาชีพที่ทำกำไรได้มากที่สุดในอุตสาหกรรมคอมพิวเตอร์ การสร้างเกม Android มีค่าใช้จ่ายหลายร้อยหรือหลายพันดอลลาร์ และกำไรอาจสูงถึงหนึ่งล้านเหรียญ ในเรื่องนี้หลายคนสนใจที่จะพัฒนาแอพพลิเคชั่นสำหรับโทรศัพท์ ในบทความนี้ คุณจะได้เรียนรู้วิธีสร้างเกม Android ตั้งแต่เริ่มต้นโดยใช้คอมพิวเตอร์ เลือกเอ็นจิ้นและนักออกแบบตัวไหนดีกว่ากัน
ไม่มี เกมที่ประสบความสำเร็จไม่สามารถทำได้หากไม่มีกราฟิกที่สวยงาม ดังนั้นการสร้างการออกแบบจึงเป็นหนึ่งในขั้นตอนที่สำคัญที่สุดของการพัฒนา การออกแบบบนระบบปฏิบัติการ Android ดำเนินการโดยใช้ "เอกสารการออกแบบ" หรือเอกสารการออกแบบ คุณต้องเริ่มสร้างของเล่นด้วยการศึกษาอย่างละเอียด ไฟล์ประกอบด้วย:
- แบบจำลองวัตถุ;
- ข้อกำหนดด้านการทำงาน
- เนื้อหาของเกม;
- อินเตอร์เฟซ.
ลองพิจารณาแต่ละประเด็นโดยละเอียดยิ่งขึ้น
โมเดลวัตถุ
นี่คือข้อมูลเกี่ยวกับการทำงานของแต่ละรายการ โมเดลวัตถุมีหน้าที่ในการซื้อและขายสินค้า ตลอดจนปรับปรุงคุณลักษณะของเกมของตัวละคร
ข้อมูลจำเพาะด้านการทำงาน
มันอธิบายการเล่นเกม คุณสมบัติหลักของตัวละครแต่ละตัว นอกจากนี้ยังอธิบายคุณสมบัติ ไอเทมในเกม- อาวุธ ชุดปฐมพยาบาล เกราะ และอื่นๆ โดยพื้นฐานแล้ว ข้อมูลจำเพาะด้านฟังก์ชันคือกฎซึ่ง กระบวนการของเกม. ยิ่งส่วนนี้ทำงานได้ดีเท่าไหร่ การสร้างเกม Android คุณภาพสูงก็จะยิ่งง่ายขึ้นเท่านั้น
เนื้อหาเกม
นี่คือการกรอกข้อความของเกม มันอธิบายบทสนทนาของตัวละครและอาวุธชนิดใดที่สามารถใช้เพื่อสร้างความเสียหายได้ พลังชีวิตที่โจมตีจะได้รับ จะเพิ่มคุณสมบัติอะไรบ้างเมื่อใช้อุปกรณ์ต่างๆ ประกอบด้วย คำอธิบายโดยละเอียดแต่ละรายการ.
อินเตอร์เฟซ
อินเทอร์เฟซเป็นวิธีที่ผู้ใช้โต้ตอบกับเกม มันมีปุ่มที่คุณสามารถควบคุมตัวละครและส่วนเมนู: ตัวอย่างเช่น เล่น คะแนน การตั้งค่า ผู้เล่นอันดับต้น ๆ ความช่วยเหลือ หากคุณไม่มีประสบการณ์ในการสร้างแอปพลิเคชัน Android ก่อนสร้างแอปพลิเคชันของคุณเอง ให้ดาวน์โหลดจาก Play Market และวิเคราะห์ เกมส์ดังและส่งต่อโซลูชันที่ดีที่สุดให้กับโครงการของคุณ
เครื่องยนต์เกม
แก่นของทุกเกมคือเครื่องยนต์ มัน ซอฟต์แวร์ช่วยให้คุณพัฒนาและดำเนินการได้ มันมีโปรแกรมมากมาย รวมถึงเอ็นจิ้นการเรนเดอร์ เอ็นจิ้นฟิสิกส์ เสียง แอนิเมชั่น และอีกมากมาย เพื่ออำนวยความสะดวกในกระบวนการเขียนโปรแกรม นักพัฒนาบุคคลที่สามจึงสร้างเอ็นจิ้นเกมของตนเองขึ้นสำหรับแอปพลิเคชัน Android โดยเฉพาะ
แต่ละรายการมีคุณสมบัติที่แตกต่างกัน: บางส่วนได้รับการออกแบบสำหรับ 3D, อื่น ๆ สำหรับ 2D, รองรับหลายแพลตฟอร์ม มีเอ็นจิ้นดังกล่าวจำนวนมาก แต่ถ้าคุณเป็นมือใหม่ จะดีกว่าถ้าเลือกหนึ่งในเอ็นจิ้นที่ได้รับความนิยมมากที่สุดเนื่องจากจะมีฟังก์ชั่นที่จำเป็นทั้งหมดอยู่ที่นั่น
UDK
แรงบิด 2d/3d
นักออกแบบเกมคืออะไร?
ตัวสร้างเป็นโปรแกรมที่รวมเอ็นจิ้นเกมและสภาพแวดล้อมการพัฒนาแบบบูรณาการ คอนสตรัคเตอร์ทำให้กระบวนการพัฒนาเข้าถึงได้สำหรับผู้ที่ไม่มีทักษะในการเขียนโปรแกรม นักออกแบบบางคนอนุญาตให้คุณสร้างเกมบางประเภท คนอื่น ๆ มีฟังก์ชันการทำงานสูงสุด แต่ใช้เงินมากกว่ามาก สำหรับผู้สร้างแอปพลิเคชั่นมือถือมือใหม่ การเลือกนักออกแบบเป็นหนึ่งในช่วงเวลาที่สำคัญที่สุด เพราะชะตากรรมของแอปพลิเคชั่นในอนาคตจะขึ้นอยู่กับความสามารถของมัน
ตัวสร้างช่วยให้คุณสร้างเกมประเภทต่างๆ สำหรับ Windows, Android และ iOS ข้อเสนอ ทางเลือกที่ยิ่งใหญ่สถานที่ วัตถุ ตัวละคร และการออกแบบเสียงสำเร็จรูป ดังนั้นการสร้างเกม Android เกมแรกจะใช้เวลาไม่นาน ผู้ใช้ที่คุ้นเคยกับภาษาโปรแกรม JS และ C++ สามารถใช้ GML แบบฝังได้ ข้อเสียเปรียบเพียงอย่างเดียวคือโปรแกรมนี้ไม่ได้แปลเป็นภาษารัสเซีย
บทสรุป
การสร้างเกม Android ไม่ใช่เรื่องง่าย แต่ให้ผลกำไรสูง หากคุณตัดสินใจที่จะพัฒนาเกมและสร้างรายได้จากมัน ให้คิดหาแนวคิดก่อน ถัดไป เขียน "เอกสารการออกแบบ" และตัดสินใจเกี่ยวกับเอ็นจิ้นเกมที่สามารถเพิ่มศักยภาพสูงสุดได้ หลังจากนั้นคุณสามารถดำเนินการสร้างแอปพลิเคชันในตัวสร้างได้โดยตรง
วีดีโอ
หากต้องการเรียนรู้เพิ่มเติมเกี่ยวกับกระบวนการสร้างเกม Android โปรดดูชุดวิดีโอสำหรับกิจกรรมนี้โดยเฉพาะ
วิธีเขียนเกม Android อย่างรวดเร็วด้วย Unity
ในปัจจุบันนี้ ใครๆ ก็สามารถเป็นผู้พัฒนาเกมมือถือหรือแอพพลิเคชั่นที่ประสบความสำเร็จได้โดยไม่ต้องใช้ความพยายามอย่างมาก ตัวอย่างของกรณีดังกล่าวคือ Dong Nguyen ผู้พัฒนา Flappy Bird เกมดังกล่าวไม่มีกลไกหรือกราฟิกที่ซับซ้อน แต่ก็ไม่ได้ขัดขวางไม่ให้เกมดังกล่าวได้รับความนิยมและทำให้ผู้สร้างเกมนี้ได้รับเงินห้าหมื่นเหรียญต่อวัน อย่างไรก็ตาม ไม่มีอะไรโดดเด่นเกี่ยวกับเกม ทั้งหมดที่จำเป็นในการประสบความสำเร็จคือการอยู่ในสถานที่ที่ถูกต้องในเวลาที่เหมาะสมและโชคดีเล็กน้อย สิ่งที่คล้ายกันสามารถเกิดขึ้นได้ในวันนี้ คุณเพียงแค่ต้องมีความคิดที่ถูกต้อง
เพื่อแสดงให้เห็นว่าการเขียนแบบนี้ง่ายเพียงใด วันนี้เราจะเขียน Flappy Bird ของเราเองโดยใช้ Unity ในเวลาเพียง 10 นาที
ตัวละครเกม
ขั้นแรกให้สร้างโครงการใหม่และตรวจสอบให้แน่ใจว่าได้เลือกตัวเลือก 2D แล้ว
โหลดสไปรท์นกของคุณเข้าสู่ฉาก อย่าลืมเปิดจินตนาการของคุณ!
จากนั้นปรับขนาดของสไปรท์ตามที่คุณต้องการโดยลากไปรอบ ๆ มุมในทิศทางที่คุณต้องการ สไปรต์ควรมองเห็นได้ในหน้าต่างลำดับชั้นทางด้านซ้าย วัตถุทั้งหมดในฉากสามารถมองเห็นได้ในนั้นและในขณะนี้ควรมีเพียงสองอย่างเท่านั้น: กล้องและนก
ลากกล้องไปที่นกแล้วปล่อย กล้องควรอยู่ใต้นกซึ่งหมายความว่าตอนนี้กล้องเป็น "ลูก" ของนกแล้ว ตอนนี้ตำแหน่งกล้องจะคงที่เมื่อเทียบกับนก หากนกเคลื่อนที่ไปข้างหน้า กล้องก็จะทำเช่นเดียวกัน
เลือกนกอีกครั้งในฉากหรือในหน้าต่างลำดับชั้น คุณจะเห็นรายการตัวเลือกและแอตทริบิวต์ทางด้านขวาในหน้าต่างที่เรียกว่า Inspector ที่นี่คุณสามารถจัดการตัวแปรต่างๆ ที่ผูกไว้กับวัตถุเฉพาะได้
ตอนนี้คลิกที่ เพิ่มส่วนประกอบ เลือก Physics2D > Rigidbody2D - นี่คือ ชุดพร้อมคำแนะนำในการใช้แรงโน้มถ่วงกับตัวละครของเรา คลิกที่ข้อจำกัดในแผงนี้แล้วเลือกหยุดการหมุน Z วิธีนี้จะป้องกันไม่ให้นกหมุนไปรอบๆ ด้วยกล้อง
ในทำนองเดียวกัน เพิ่ม Polygon Collider ที่บอก Unity ว่าเส้นขอบของตัวละครอยู่ที่ใด กดเล่นและดูว่าสไปรท์พร้อมกับกล้องตกลงไปอย่างไม่รู้จบได้อย่างไร
จนถึงตอนนี้ทุกอย่างเป็นไปด้วยดี!
ตอนนี้ได้เวลาเริ่มบินตัวละครแล้วเพราะมันจะไม่ใช่เรื่องยาก
ก่อนอื่นคุณต้องสร้างสคริปต์ C# สร้างโฟลเดอร์สำหรับมัน (คลิกขวาที่ใดที่หนึ่งในสินทรัพย์และสร้างโฟลเดอร์ "สคริปต์") คลิกขวาและเลือก Create > C# Script
ให้เรียกว่า "ตัวละคร" ดับเบิลคลิกเพื่อเปิดใน IDE ของคุณ ไม่ว่าจะเป็น MonoDevelop หรือ Visual Studio จากนั้นเพิ่มรหัสต่อไปนี้:
ตัวละครคลาสสาธารณะ: MonoBehaviour ( public Rigidbody2D rb; public float moveSpeed; public float flapHeight; // ใช้สำหรับการเริ่มต้นเป็นโมฆะ Start () ( rb = GetComponent(); ) // Update ถูกเรียกหนึ่งครั้งต่อเฟรม void Update () ( rb .velocity = Vector2 ใหม่(moveSpeed, rb.velocity.y); if (Input.GetMouseButtonDown(0)) ( rb.velocity = new Vector2(rb.velocity.x, flapHeight); ) if (transform.position.y > 18 || transform.position.y< -19) { Death(); } } public void Death() { rb.velocity = Vector3.zero; transform.position = new Vector2(0, 0); } }
รหัสนี้ทำสองสิ่ง มันทำให้ตัวละครเคลื่อนที่ไปข้างหน้าด้วยความเร็วที่เรากำหนดในตัวตรวจสอบและให้ความรู้สึกเหมือนนกกำลังบินอยู่ เมธอด Update() ถูกเรียกซ้ำๆ ตลอดทั้งเกม ดังนั้นสิ่งที่คุณใส่ที่นี่จะทำงานอย่างต่อเนื่อง ในกรณีนี้ เรากำลังเพิ่มความเร็วให้กับวัตถุของเรา ตัวแปร rb คือสคริปต์ RigidBody2D ที่เรานำไปใช้กับวัตถุของเราก่อนหน้านี้ ดังนั้นเมื่อเราเขียน rb.velocity เราหมายถึงความเร็วของวัตถุ
การแตะบนหน้าจอจะตีความโดย Unity เป็นการคลิกเมาส์หากคุณใช้อุปกรณ์เคลื่อนที่ หลังจากกด เราบังคับตัวละครให้ลุกขึ้นเล็กน้อย
ตัวแปร moveSpeed จะรับผิดชอบความเร็วของการเคลื่อนที่และตัวแปร flapHeight - สำหรับการเพิ่มความสูงของการบินของนกหลังจากการคลิกแต่ละครั้ง เนื่องจากตัวแปรเหล่านี้เป็นตัวแปรสาธารณะ เราจึงสามารถเปลี่ยนแปลงได้นอกสคริปต์
นอกจากนี้ Death() ยังประกาศให้เป็น public ซึ่งหมายความว่าอ็อบเจ็กต์และสคริปต์อื่น ๆ สามารถเรียกมันได้ วิธีนี้จะคืนค่าตำแหน่งของตัวละครไปที่จุดเริ่มต้น นอกจากนี้ยังจะใช้ทุกครั้งที่ตัวละครบินสูงหรือต่ำเกินไป ในไม่ช้าคุณจะเข้าใจว่าทำไมจึงมีการประกาศให้เป็นสาธารณะ เส้น rb.velocity = Vector3.zero; จำเป็นต้องลบโมเมนตัม - เราไม่ต้องการให้ตัวละครตกเร็วขึ้นและเร็วขึ้นหลังจากการตายแต่ละครั้งใช่ไหม
ตอนนี้คุณสามารถออกจาก IDE และเพิ่มสคริปต์เป็นส่วนประกอบให้กับอักขระได้ ในการดำเนินการนี้ ให้เลือกนกของเราแล้วคลิก เพิ่มส่วนประกอบ > สคริปต์ > ตัวละคร ตอนนี้เราสามารถกำหนด moveSpeed และ flapHeight ในตัวตรวจสอบได้ (นั่นคือสิ่งที่ตัวแปรสาธารณะมีไว้สำหรับ) กำหนด ค่าตัวแปร 3 และ 5 ตามลำดับ
และอีกอย่างหนึ่ง: ในตัวตรวจสอบ คุณต้องเพิ่มแท็กให้กับตัวละคร ในการดำเนินการนี้ ให้คลิกตรงตำแหน่งที่มีข้อความว่า Tag: Untagged แล้วเลือก Player จากรายการดรอปดาวน์
อุปสรรค
ตอนนี้ขอเพิ่มสิ่งกีดขวาง: ท่อ มีคนพบเห็ดในท่อ และมีคนพบความตายของเขาเอง
ลากไปป์สไปรท์เข้าไปในฉากไปยังตำแหน่งที่คุณต้องการให้สิ่งกีดขวางแรกเป็นและตั้งชื่อมันว่า pipe_up
ตอนนี้เรามาสร้างสคริปต์ใหม่ชื่อ Pipe:
Public class Pipe: MonoBehaviour ( private Character character; // Needed for initialization void Start () ( character = FindObjectOfType(); ) // Update ถูกเรียกหนึ่งครั้งต่อเฟรม void Update () ( if (character.transform.position.x - transform.position.x >
เพิ่มสคริปต์นี้ไปยังไปป์สไปรต์ในลักษณะเดียวกับเมื่อก่อน ดังนั้นท่อจะกลับไปที่หน้าจอหลังจากออกจากขอบด้านซ้าย เรายังไม่ได้ทำอะไรที่นี่ แต่เราจะกลับไปทำใหม่
OnCollisionEnter2D() วิธีการถูกเรียกทุกครั้งที่ไปป์โต้ตอบกับอักขระ หลังจากนั้น ระบบจะเรียกเมธอด Death() ที่สร้างไว้ก่อนหน้านี้ นำผู้เล่นกลับไปยังจุดเริ่มต้น
ดังนั้นเราจึงมีไปป์ที่จะหายไปเป็นครั้งคราวและปรากฏขึ้นอีกครั้งที่ปลายอีกด้านหนึ่งของหน้าจอ ตีเธอคุณตาย
ท่อคว่ำ
ตอนนี้เรามีสไปรท์ท่อเพียงตัวเดียว มาเพิ่มอีกตัวครับ ในการดำเนินการนี้ ให้คลิกขวาในหน้าต่างลำดับชั้น คลิก New 2D Object > Sprite จากนั้นเลือกสไปรต์ที่คุณต้องการใช้ แค่ลากไฟล์ไปที่ฉากอีกครั้งจะง่ายยิ่งขึ้นไปอีก
ตั้งชื่อ sprite pipe_down นี้ ในตัวตรวจสอบ ภายใต้ Sprite Renderer ให้เลือกตัวเลือก Flip Y เพื่อพลิกไปป์กลับด้าน เพิ่ม RigidBody2D เดียวกัน
ตอนนี้เรามาเขียนสคริปต์ C# ใหม่ชื่อ PipeD มันจะมีรหัสที่คล้ายกัน:
Public class PipeD: MonoBehaviour ( private Character character; //นี่เป็นสิ่งจำเป็นสำหรับการเริ่มต้นเป็นโมฆะ Start() ( character = FindObjectOfType(); ) // Update ถูกเรียกหนึ่งครั้งต่อเฟรม void Update() ( if (character.transform.position. x - transform.position.x > 30) ( ) ) เป็นโมฆะ OnCollisionEnter2D(Collision2D อื่นๆ) ( if (other.gameObject.tag == "Player") ( character.Death(); ) ) )
รูปแบบสำเร็จรูป
ดังนั้นโค้ดนี้จึงเพียงพอสำหรับเราที่จะสร้างทั้งเกม เราสามารถย้ายท่อไปทางด้านขวาของหน้าจอทุกครั้งที่มันหายไป หรือคัดลอกและวางท่อได้มากเท่าที่เราต้องการตลอดทั้งเกม
หากคุณไปทางแรก ให้ตรวจสอบให้แน่ใจว่าท่อนั้นถูกต้องหลังจากการสร้างแบบสุ่ม และเป็นการยากที่จะรักษาแนวทางที่ยุติธรรม หลังจากการตายของตัวละคร พวกเขาสามารถปรากฏเป็นกิโลเมตรจากท่อแรก!
หากคุณไปทางที่สอง ทุกอย่างจะจบลงด้วยการใช้หน่วยความจำที่มากเกินไป ส่งผลให้เกมช้าลงและค่าการเล่นซ้ำที่จำกัดเพราะ ทุกอย่างอยู่ในที่เดิมทุกครั้ง
ให้ใช้รูปแบบสำเร็จรูปแทน พูดง่ายๆ ก็คือ เราจะเปลี่ยนไปป์ของเราให้เป็นเทมเพลตที่เราสามารถใช้เพื่อสร้างไพพ์เพิ่มเติมได้ตามต้องการ หากมีโปรแกรมเมอร์อยู่ที่นี่ ให้พิจารณาสคริปต์ไปป์เป็นคลาส และไพพ์เป็นอินสแตนซ์ของวัตถุนี้
ในการดำเนินการนี้ ให้สร้างโฟลเดอร์ "Prefabs" ใหม่ จากนั้นลาก pipe_up และ pipe_down จากหน้าต่างลำดับชั้นไปยังโฟลเดอร์
ทุกครั้งที่คุณลากวัตถุจากโฟลเดอร์นี้ไปยังฉาก วัตถุนั้นจะมีคุณสมบัติเหมือนกัน คุณจึงไม่ต้องเพิ่มส่วนประกอบต่อไป ยิ่งไปกว่านั้น หากคุณปรับขนาดส่วนประกอบในโฟลเดอร์ มันจะส่งผลต่อท่อทั้งหมดในเกม และคุณไม่จำเป็นต้องปรับขนาดแต่ละรายการแยกกัน
อย่างที่คุณสามารถจินตนาการได้ สิ่งนี้จะช่วยประหยัดทรัพยากรของเราได้อย่างมาก นอกจากนี้ยังหมายความว่าเราสามารถโต้ตอบกับวัตถุจากโค้ดได้ เราสามารถยกตัวอย่างไปป์ของเราได้
ขั้นแรก เพิ่มรหัสนี้ในนิพจน์เงื่อนไขในเมธอด Update() ของสคริปต์ไปป์ที่เราเว้นว่างไว้:
การอัปเดตเป็นโมฆะ () ( if (character.transform.position.x - transform.position.x > 30) ( float xRan = Random.Range(0, 10); float yRan = Random.Range(-5, 5); สร้างอินสแตนซ์ (gameObject, Vector2 ใหม่(character.transform.position.x + 15 + xRan, -10 + yRan), transform.rotation); Destroy(gameObject); ) )
นี่เป็นสิ่งจำเป็นในการสร้างอินสแตนซ์ของ gameObject ของเรา ผลที่ได้คือสำเนาใหม่ที่เหมือนกัน ใน Unity เมื่อใดก็ตามที่คุณใช้คำว่า gameObject มันหมายถึงอ็อบเจ็กต์ที่สคริปต์เชื่อมโยงอยู่ในปัจจุบัน - ในกรณีของเราคือไปป์
เราสร้างท่อใหม่ในรูปแบบสุ่มเพื่อให้สนุกยิ่งขึ้น
แต่แทนที่จะทำแบบเดียวกันทั้งหมดในสคริปต์ PipeD เราสร้างวัตถุทั้งสองในที่เดียวกัน ดังนั้นเราจึงสามารถกำหนดตำแหน่งของท่อที่สองที่สัมพันธ์กับท่อแรกได้อย่างง่ายดาย นอกจากนี้ยังหมายความว่าเราต้องการโค้ดน้อยลงสำหรับ PipeD
สร้าง gameObject สาธารณะชื่อ pipeDown จากนั้นอัปเดตรหัสดังนี้:
ถ้า (character.transform.position.x - transform.position.x > 30) ( float xRan = Random.Range(0, 10); float yRan = Random.Range(-5, 5); float gapRan = Random.Range (0, 3); สร้างอินสแตนซ์ (gameObject, Vector2 ใหม่ (character.transform.position.x + 15 + xRan, -11 + yRan), transform.rotation); สร้างอินสแตนซ์ (pipeDown, Vector2 ใหม่ (character.transform.position.x + 15 + xRan, 12 + gapRan + yRan), transform.rotation); ทำลาย(gameObject); )
กลับไปที่ Unity แล้วลาก pipe_down prefab จากโฟลเดอร์ prefabs (นี่เป็นสิ่งสำคัญ!) ไปยังตำแหน่งที่มีข้อความว่า "Pipe Down" (สังเกตว่ากล่องอูฐของเราถูกแทนที่ด้วยช่องว่างอย่างไร) ลงบนไพพ์สไปรท์ pipe up หากคุณจำได้ เราได้กำหนดให้ Pipe Down เป็นเกมสาธารณะ Object ซึ่งทำให้เราสามารถระบุได้ว่าอ็อบเจกต์นี้มาจากที่ใดก็ได้ - ในกรณีนี้ผ่านตัวตรวจสอบ โดยการเลือกรูปแบบสำเร็จรูปสำหรับวัตถุนี้ เราตรวจสอบให้แน่ใจว่าเมื่อมีการสร้างอินสแตนซ์ของไพพ์ มันจะรวมแอตทริบิวต์และสคริปต์ทั้งหมดที่เราเพิ่มไว้ก่อนหน้านี้ เราไม่เพียงแค่สร้างสไปรต์ แต่เราสร้างวัตถุขึ้นใหม่ด้วย collider ที่สามารถฆ่าตัวละครได้
ทั้งหมดที่เราจะเพิ่มในที่เดียวกันในสคริปต์ PipeD เป็นเพียง Destroy(gameObject) เพื่อให้ไปป์จะทำลายตัวเองเมื่อมันไปทางด้านซ้ายของหน้าจอ
หากคุณเริ่มเกมตอนนี้ หน้าจอจะเลื่อนไปข้างหน้าโดยอัตโนมัติ และคุณจะตายหากคุณตีท่อใดๆ บินให้ไกลพอ ท่อเหล่านั้นจะหายไปและปรากฏขึ้นอีกครั้งข้างหน้า
น่าเสียดายที่มีระยะห่างระหว่างท่อกับหน้าจอค่อนข้างมาก เราสามารถแก้ไขได้โดยเพิ่มรูปแบบสำเร็จรูปบางส่วนลงในฉากของเราเพื่อสร้างท่อส่งวางไข่อย่างต่อเนื่อง อย่างไรก็ตาม จะเป็นการดีกว่าถ้าสร้างไพพ์ในสคริปต์ นี่เป็นสิ่งสำคัญเพราะไม่เช่นนั้นหลังจากการตายของตัวละครท่อที่จุดเริ่มต้นของเส้นทางจะถูกทำลายและพื้นที่ว่างจะก่อตัวขึ้นอีกครั้ง
ด้วยวิธีนี้ เราสามารถสร้างไพพ์สองสามอันแรกในระหว่างการโหลดแต่ละเกมและนำทุกอย่างกลับคืนสู่ตำแหน่งเดิมหลังจากที่ตัวละครตาย
เที่ยวบินที่ไม่มีที่สิ้นสุด
ตอนนี้เรามาสร้างตัวแปรสาธารณะ pipe_up และ pipe_down ในสคริปต์อักขระ สิ่งนี้จะทำให้คุณสามารถอ้างอิงวัตถุที่สร้างขึ้นได้โดยการลากรูปแบบสำเร็จรูปไปยังวัตถุตัวละคร เช่นเดียวกับเมื่อเราเพิ่ม pipe_down ให้กับสคริปต์ท่อ
เราจำเป็นต้องเพิ่มตัวแปรเหล่านี้:
สาธารณะ GameObject pipe_up; สาธารณะ GameObject pipe_down;
จากนั้นเราจะเขียนวิธีการดังนี้:
โมฆะสาธารณะ BuildLevel() ( สร้างอินสแตนซ์ (pipe_down, Vector3 ใหม่ (14, 12), transform.rotation); สร้างอินสแตนซ์ (pipe_up, Vector3 ใหม่ (14, -11), transform.rotation); สร้างอินสแตนซ์ (pipe_down, Vector3 ใหม่ (26, 14), transform.rotation); สร้างอินสแตนซ์ (pipe_up, Vector3 ใหม่ (26, -10), transform.rotation); สร้างอินสแตนซ์ (pipe_down, Vector3 ใหม่ (38, 10), transform.rotation); สร้างอินสแตนซ์ (pipe_up, Vector3 ใหม่ ( 38, -14), transform.rotation); สร้างอินสแตนซ์ (pipe_down, Vector3 ใหม่ (50, 16), transform.rotation); สร้างอินสแตนซ์ (pipe_up, Vector3 ใหม่ (50, -8), transform.rotation); สร้างอินสแตนซ์ (pipe_down, ใหม่ Vector3(61, 11), transform.rotation); สร้างอินสแตนซ์ (pipe_up, Vector3 ใหม่ (61, -13), transform.rotation); )
เราจะเรียกมันหนึ่งครั้งในเมธอด Update() และอีกครั้งในเมธอด Death()
หลังจากที่เกมเริ่มต้นขึ้น จะมีการเรียก Update() และไพพ์ของเราจะถูกวางตามการกำหนดค่าที่กำหนด ด้วยเหตุนี้ อุปสรรคสองสามอย่างแรกจะอยู่ที่เดิมเสมอ หลังจากผู้เล่นเสียชีวิต ท่อจะกลับสู่ที่เดิม
กลับไปที่ฉากใน Unity และลบสองท่อที่มีอยู่ตอนนี้ "เกม" ของคุณจะดูเหมือนหน้าจอเปล่าที่มีนก กดเล่นและไปป์จะปรากฏขึ้น หลังจากสองสามตัวแรก ตำแหน่งของพวกมันจะถูกกำหนดแบบสุ่ม
ในที่สุด
นั่นคือสิ่งที่เราทำ ทั้งเกม! เพิ่มตัวนับคะแนน พยายามทำให้มันเป็นต้นฉบับมากขึ้นและเพิ่มความยากของเกมในขณะที่คุณคืบหน้า อีกทั้งการทำเมนูก็ไม่ฟุ่มเฟือย อีกความคิดที่ดีคือการทำลายท่อบนหน้าจอหลังจากการตายของตัวละคร เมื่อคุณทำเสร็จแล้ว - พิจารณาว่าพร้อมสำหรับการเปิดตัวใน ร้านขายของเล่นเกมในกระเป๋าของคุณ! กาลครั้งหนึ่ง เกมที่คล้ายกันทำให้นักพัฒนารายอื่นร่ำรวยมาก ซึ่งพิสูจน์ได้ว่าคุณไม่จำเป็นต้องเป็นอัจฉริยะด้านการเขียนโปรแกรมหรือมีผู้เผยแพร่ที่ร่ำรวยอยู่เบื้องหลังคุณจึงจะประสบความสำเร็จ คุณเพียงแค่ต้องมีความคิดที่ดีและสิบนาที!
ต้องการเขียนแอป Android แต่ไม่รู้ว่าจะเริ่มต้นอย่างไร จากนั้นดูบทแนะนำที่ยอดเยี่ยมสำหรับการเรียนรู้การพัฒนา Android
