มุมมองโพสต์: 19374

เราได้พูดคุยเกี่ยวกับวิธีสร้างเกมของคุณเองบน Android โดยใช้ Unreal Engine ในบทความนี้เราจะมาดูเครื่องมือพัฒนาเกมที่ได้รับความนิยมไม่แพ้กัน - ความสามัคคี.

Unity เป็นเครื่องมือที่มีชื่อเสียงมากในหมู่นักพัฒนาอินดี้ โดยพื้นฐานแล้วมันเป็นเอนจิ้นข้ามแพลตฟอร์มที่ช่วยให้คุณพัฒนา 3D- และ 2 มิติ-เกม. คุณลักษณะที่ทำให้ Unity แตกต่างจากเครื่องยนต์อื่น ๆ คืออุปสรรคต่ำในการเข้าสำหรับผู้เริ่มต้นด้วยชุดเครื่องมือสำหรับมืออาชีพ ลักษณะข้ามแพลตฟอร์มช่วยให้คุณพัฒนาแอปพลิเคชันสำหรับทุกแพลตฟอร์มตั้งแต่เกมเดสก์ท็อปไปจนถึงมือถือ

ควรกล่าวถึงระบบการสมัครสมาชิกแยกกันเนื่องจาก Unity ไม่ใช่ผลิตภัณฑ์ฟรีอย่างสมบูรณ์ การสมัครสมาชิกมีหลายประเภท:

• ส่วนบุคคล... เวอร์ชันฟรีที่มีคุณสมบัติหลักทั้งหมดของเครื่องยนต์ มีข้อ จำกัด ดังต่อไปนี้: รายได้ต่อปีหรือจำนวนเงินที่ระดมทุนได้ไม่ควรเกิน 100000$ .
• บวก... ข้างหลัง 35 เหรียญต่อเดือน มีการจัดทำรายงานและการวิเคราะห์ต่างๆรวมถึงความสามารถในการเปลี่ยนหน้าจอเริ่มต้น 20% - ส่วนลดสำหรับการซื้อใน ที่เก็บสินทรัพย์ และสิทธิประโยชน์เล็กน้อยต่างๆ มีข้อ จำกัด ดังต่อไปนี้: รายได้สำหรับปีหรือจำนวนเงินที่ระดมทุนไม่ควรเกิน 200000$ .
• มือโปร... ข้างหลัง 125 เหรียญต่อเดือน รวมถึงประโยชน์ทั้งหมดของเวอร์ชันนี้ บวก และบริการระดับมืออาชีพเพิ่มเติมและการสนับสนุนระดับพรีเมียม ไม่มีข้อ จำกัด ในการหมุนเวียนหรือจำนวนเงินทุน
• แยกเวอร์ชันสำหรับธุรกิจ (ใช้โดย บริษัท ขนาดใหญ่)

ดังนั้นสำหรับนักพัฒนาอินดี้ที่มีงบประมาณน้อยเวอร์ชันนี้ ส่วนบุคคล หรือ บวกมิฉะนั้นคุณจะต้องสมัครสมาชิก มือโปร... ในบทความนี้เราจะใช้เวอร์ชันฟรีสำหรับการเปิดตัวครั้งแรก

ขั้นตอนที่ 1. การติดตั้ง Unity

ในการเริ่มติดตั้ง Unity คุณต้องไปที่เว็บไซต์ Unity Store ซึ่งคุณจะได้รับแจ้งให้เลือกประเภทการสมัครสมาชิก ดังกล่าวข้างต้นเราเลือก ส่วนบุคคล.

จากนั้นคุณจะได้รับแจ้งให้ยอมรับเงื่อนไขการใช้งานและดาวน์โหลดตัวติดตั้ง คุณยังสามารถดูข้อกำหนดของระบบสำหรับการทำงานกับ Unity

หลังจากเริ่มโปรแกรมติดตั้งคุณจะได้รับแจ้งให้เลือกส่วนประกอบที่คุณต้องการติดตั้ง เนื่องจากเราจำเป็นต้องสร้างแอปพลิเคชันสำหรับ Android ให้ทำเครื่องหมายที่ช่อง รองรับ Android Build... นอกจากนี้หากต้องการแทนที่จะใช้ Unity คุณสามารถติดตั้งได้ Visual Studio Community 2017 สำหรับการเขียนโปรแกรมบน ค #.

หลังจากนั้นสิ่งที่เหลืออยู่คือเลือกเส้นทางการติดตั้งและเริ่มติดตั้ง Unity

ขั้นตอนที่ 2. ลงทะเบียนและกำหนดค่า Unity

หลังจากเสร็จสิ้นการติดตั้งและเปิดใช้ Unity เราได้รับเชิญให้เข้าสู่ระบบด้วยบัญชีของเรา

จากนั้นอีกครั้งคุณจะถูกขอให้เลือกการสมัครสมาชิกเราจะเน้นที่ส่วนบุคคล ในกรณีนี้คุณจะต้องยืนยันว่า บริษัท มีรายได้ต่อปีน้อยกว่า $ 100,000 หรือ Unity ถูกใช้เพื่อวัตถุประสงค์ในการฝึกอบรม

ในตอนท้ายระบบจะขอให้คุณกรอกแบบสำรวจขนาดเล็กซึ่งคุณต้องตอบว่าคุณกำลังทำอะไรอยู่และคุณกำลังติดตั้ง Unity เพื่อจุดประสงค์ใด

ขั้นตอนที่ 3. การสร้างโครงการใหม่

หลังจากกำหนดค่า Unity แล้วเราจะไปที่หน้าจอการเลือกโครงการสร้าง ที่นี่คุณต้องคลิก ใหม่เพื่อสร้างโครงการใหม่ของคุณ

หลังจากนั้นในหน้าต่างที่ปรากฏขึ้นคุณจะได้รับแจ้งให้ป้อนชื่อของโครงการและไดเร็กทอรีที่จะอยู่ อย่าลืมทำเครื่องหมายในช่อง 3Dเพื่อใช้โปรแกรมแก้ไขในรูปแบบ 3 มิติ

เมื่อคุณทำเสร็จแล้วให้คลิก สร้างโครงการเพื่อสร้างโครงการ หลังจากนั้นหน้าต่างแก้ไขจะเปิดขึ้นพร้อมฉากที่สร้างไว้ล่วงหน้า

เราจะยังไม่จัดการกับความซับซ้อนของการเขียนโปรแกรมและนำเกมสำเร็จรูปมาเป็นตัวอย่าง สำหรับสิ่งนี้มี ที่เก็บสินทรัพย์ซึ่งมีโมเดลสำเร็จรูปภาพเคลื่อนไหวเสียง (และแม้แต่เกม) จำนวนมากทั้งแบบชำระเงินและฟรี

ในการเปิดที่เก็บสินทรัพย์คุณต้องอยู่ในเมนู หน้าต่าง เลือก ที่เก็บสินทรัพย์ (คีย์ผสม Ctrl-9).

หน้าต่างร้านจะเปิดขึ้น เข้าไปในแถบค้นหากันเถอะ " เกมตัวอย่างสไตล์นกเครื่องปัด"และเปิดตัวอย่างฟรีที่เราจะใช้ในโครงการของเรา

โดยคลิก ดาวน์โหลด และเมื่อดาวน์โหลดแล้วคุณสามารถนำเข้าสู่โครงการของคุณได้ ในการดำเนินการนี้ให้คลิก นำเข้าหลังจากนั้นคำเตือนจะปรากฏขึ้นโดยระบุว่าการตั้งค่าโปรเจ็กต์จะเปลี่ยนไปหลังจากนำเข้า

หลังจากตกลงที่จะนำเข้าคุณจะเห็นหน้าต่างที่คุณต้องเลือกส่วนประกอบที่จะนำเข้า เลือกทุกอย่างแล้วคลิก นำเข้า.

หลังจากการนำเข้าเสร็จสมบูรณ์คุณจะเห็นไฟล์ใหม่ใน Project Explorer นี่คือไฟล์เกม หากต้องการเปิดฉากในตัวแก้ไขให้ขยาย สไตล์นกเครื่องปัด - ฉาก และดับเบิลคลิกที่ หลัก.

ด้วยเหตุนี้ฉากของเกมจะปรากฏในหน้าต่างตัวแก้ไข 3D

คุณสามารถตรวจสอบวิธีการทำงานของเกมได้ใน Unity โดยคลิกที่ปุ่ม เล่น เหนือหน้าต่างตัวแก้ไข

ขั้นตอนที่ 4. การกำหนดค่าเครื่องมือ Android

บันทึก: ถ้าคุณใช้ Android Studioจากนั้นคุณได้ติดตั้งส่วนประกอบที่จำเป็นทั้งหมดแล้วดังนั้นคุณสามารถดำเนินการขั้นตอนต่อไปได้อย่างปลอดภัย

ในการสร้างเกมบน Android คุณต้องติดตั้งเครื่องมือต่อไปนี้:

• Java Development Kit (JDK) คุณสามารถดาวน์โหลดได้จากเว็บไซต์ Java เมื่อคลิกที่ลิงค์คุณจะเห็นที่ด้านบนสุด แพลตฟอร์ม 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 Analyzerซึ่งมาพร้อมกับ Android Studio

ขนาดไฟล์ APK ที่ไม่บีบอัดคือ 21.1 ลบในการบีบอัด 20.9 ลบ... ดังที่คุณเห็นจากกราฟปริมาณส่วนใหญ่จะถูกนำมาจากไลบรารีของบุคคลที่สามที่เพิ่มโดย Unity จากนั้นใน สินทรัพย์ทรัพยากรทั้งหมดที่ใช้ในฉากประกอบจะอยู่ ไฟล์ class.dex มีทั้งหมด 89 ชั้นเรียนและ 479 วิธีการ

นอกจากนี้หากคุณมองเข้าไป AndroidManifest.xmlแอปพลิเคชันประกอบด้วยกิจกรรมเดียว

สรุป

นั่นคือทั้งหมด ในบทความนี้เราได้เรียนรู้วิธีการติดตั้งและกำหนดค่า Unity และยังรวบรวมแอปพลิเคชัน Android ตัวแรกของเราไว้ด้วย

วิธีเขียนเกม Android อย่างรวดเร็วใน Unity

ทุกวันนี้ใคร ๆ ก็สามารถเป็นผู้พัฒนาเกมหรือแอปพลิเคชันบนมือถือที่ประสบความสำเร็จได้โดยไม่ต้องใช้ความพยายาม ตัวอย่างของกรณีดังกล่าวคือ Dong Nguyen ผู้พัฒนา Flappy Bird เกมดังกล่าวไม่มีกลไกหรือกราฟิกที่ซับซ้อน แต่นั่นก็ไม่ได้หยุดยั้งไม่ให้เป็นที่นิยมและทำให้ผู้สร้างได้รับเงินห้าหมื่นดอลลาร์ต่อวัน อย่างไรก็ตามไม่มีอะไรน่าทึ่งเกี่ยวกับเกมนี้ สิ่งที่ต้องทำเพื่อให้ประสบความสำเร็จคือการมาถูกที่ถูกเวลาและโชคดีเล็กน้อย สิ่งนี้สามารถเกิดขึ้นได้ในวันนี้คุณเพียงแค่ต้องมีความคิดที่ถูกต้อง

เพื่อแสดงให้เห็นว่าการเขียนสิ่งนี้ง่ายเพียงใดวันนี้เราจะเขียน Flappy Bird ด้วย Unity ในเวลาเพียง 10 นาที

ตัวละครที่เล่นได้

ขั้นแรกให้สร้างโครงการใหม่และตรวจสอบให้แน่ใจว่าได้เลือก 2D แล้ว

ใส่สไปรท์นกของคุณเข้าฉาก อย่าลืมเปิดจินตนาการของคุณ!

จากนั้นปรับขนาดของสไปรท์ตามที่คุณต้องการโดยลากไปรอบ ๆ มุมในทิศทางที่ต้องการ สไปรท์ควรมองเห็นได้ในหน้าต่างลำดับชั้นทางด้านซ้าย วัตถุทั้งหมดในฉากนั้นสามารถมองเห็นได้และในขณะนี้ควรมีเพียงสองชิ้นเท่านั้น: กล้องและนก

ลากกล้องไปที่นกแล้วปล่อย กล้องควรอยู่ใต้ตัวนกซึ่งหมายความว่าตอนนี้กล้องเป็น "ลูก" ของนก ตอนนี้ตำแหน่งกล้องจะได้รับการแก้ไขโดยสัมพันธ์กับนก หากนกเคลื่อนที่ไปข้างหน้ากล้องจะทำเช่นเดียวกัน

เลือกนกอีกครั้งในฉากหรือในหน้าต่างลำดับชั้น คุณจะเห็นรายการตัวเลือกและแอตทริบิวต์ทางด้านขวาในหน้าต่างที่เรียกว่า Inspector ที่นี่คุณสามารถจัดการตัวแปรต่างๆที่เชื่อมโยงกับวัตถุเฉพาะได้

ตอนนี้คลิกที่เพิ่มส่วนประกอบ เลือก Physics2D\u003e Rigidbody2D - นี่คือชุดคำสั่งสำเร็จรูปสำหรับการใช้แรงโน้มถ่วงกับตัวละครของเรา คลิกที่ข้อ จำกัด ในแผงนี้จากนั้นเลือกหยุดการหมุน Z วิธีนี้จะป้องกันไม่ให้นกหมุนด้วยกล้องเป็นวงกลม

ในทำนองเดียวกันให้เพิ่ม Polygon Collider ที่บอก Unity ว่าขอบเขตของตัวละครอยู่ที่ใด กดเล่นและดูว่าสไปรท์พร้อมกับกล้องตกลงไปอย่างไม่มีที่สิ้นสุดได้อย่างไร

จนถึงตอนนี้ดีมาก!

ตอนนี้ได้เวลาเริ่มบินตัวละครแล้วเพราะมันจะไม่ยาก

ก่อนอื่นคุณต้องสร้างสคริปต์ C # สร้างโฟลเดอร์ขึ้นมา (คลิกขวาที่ใดก็ได้ในเนื้อหาและสร้างโฟลเดอร์ "สคริปต์") คลิกขวาแล้วเลือกสร้าง\u003e สคริปต์ C #

ขอเรียกว่า "ตัวละคร" ดับเบิลคลิกเพื่อเปิดใน IDE ของคุณไม่ว่าจะเป็น MonoDevelop หรือ Visual Studio จากนั้นเพิ่มรหัสต่อไปนี้:

ตัวละครคลาสสาธารณะ: MonoBehaviour (public Rigidbody2D rb; public float moveSpeed; public float flapHeight; // สิ่งนี้จำเป็นสำหรับการเริ่มต้นเป็นโมฆะ Start () (rb \u003d GetComponent ();) // Update ถูกเรียกหนึ่งครั้งต่อเฟรมโมฆะ Update () (rb .velocity \u003d Vector2 ใหม่ (moveSpeed, rb.velocity.y); if (Input.GetMouseButtonDown (0)) (rb.velocity \u003d Vector2 ใหม่ (rb.velocity.x, flapHeight);) if (transform.position.y\u003e 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 \u200b\u200bจะรับผิดชอบต่อความเร็วในการเคลื่อนที่และตัวแปร flapHeight - สำหรับการเพิ่มความสูงในการบินของนกหลังจากการคลิกแต่ละครั้ง เนื่องจากตัวแปรเหล่านี้ได้รับการประกาศให้เป็นสาธารณะเราจึงสามารถเปลี่ยนแปลงได้นอกสคริปต์

นอกจากนี้เมธอด Death () ยังประกาศต่อสาธารณะซึ่งหมายความว่าอ็อบเจ็กต์และสคริปต์อื่น ๆ สามารถเรียกมันได้ วิธีนี้เพียงแค่คืนตำแหน่งของตัวละครไปยังจุดเริ่มต้น นอกจากนี้ยังใช้ทุกครั้งที่ตัวละครบินสูงหรือต่ำเกินไป คุณจะเข้าใจในไม่ช้าว่าเหตุใดจึงประกาศเป็นสาธารณะ บรรทัด rb.velocity \u003d Vector3.zero; จำเป็นต้องลบแรงกระตุ้น - เราไม่ต้องการให้ตัวละครล้มลงเร็วขึ้นและเร็วขึ้นหลังจากการตายแต่ละครั้ง?

ตอนนี้คุณสามารถออกจาก IDE และเพิ่มสคริปต์เป็นส่วนประกอบให้กับตัวละครของคุณได้ ทำได้โดยเลือกนกของเราแล้วคลิกเพิ่มส่วนประกอบ\u003e สคริปต์\u003e ตัวละคร ตอนนี้เราสามารถกำหนด moveSpeed \u200b\u200bและ flapHeight ในตัวตรวจสอบได้แล้ว (นั่นคือตัวแปรสาธารณะสำหรับ) ลองกำหนดตัวแปรเป็นค่า 3 และ 5 ตามลำดับ

และอีกอย่างหนึ่ง: ในตัวตรวจสอบคุณต้องเพิ่มแท็กให้กับตัวละคร ทำได้โดยคลิกตรงที่มีข้อความว่า Tag: Untagged จากนั้นเลือก Player ในรายการดรอปดาวน์

อุปสรรค

ตอนนี้ขอเพิ่มอุปสรรค: ท่อ มีคนพบเห็ดในท่อและมีคนพบการตายของพวกเขา

ลากไปป์สไปรท์เข้าไปในฉากที่ควรจะเป็นอุปสรรคแรกและตั้งชื่อว่า pipe_up
ตอนนี้มาสร้างสคริปต์ใหม่ชื่อ Pipe:

Public class Pipe: MonoBehaviour (private Character character; // สิ่งนี้จำเป็นสำหรับการเริ่มต้น void Start () (character \u003d FindObjectOfType ();) // Update ถูกเรียกหนึ่งครั้งต่อ frame void Update () (if (character.transform.position.x - transform.position.x\u003e

เพิ่มสคริปต์นี้ไปยังไพพ์สไปรต์ในลักษณะเดียวกับก่อนหน้านี้ ดังนั้นท่อจะกลับไปที่หน้าจอหลังจากเลยเส้นขอบด้านซ้ายไปแล้ว เรายังไม่ได้ทำอะไรที่นี่ แต่เราจะกลับมาที่นี่

เมธอด OnCollisionEnter2D () ถูกเรียกทุกครั้งที่ไปป์โต้ตอบกับอักขระ หลังจากนั้นจะเรียกใช้เมธอด Death () ที่สร้างไว้ก่อนหน้านี้โดยให้ผู้เล่นกลับไปที่จุดเริ่ม

ดังนั้นเราจึงมีท่อหนึ่งเส้นที่จะเลือนเข้าและออกเป็นครั้งคราวที่ปลายอีกด้านหนึ่งของหน้าจอ ถ้าคุณตีมันคุณจะตาย

ท่อกลับหัว

ตอนนี้เรามีสไปรท์ท่อเพียงตัวเดียว ขอเพิ่มอีกอัน ในการดำเนินการนี้ให้คลิกขวาในหน้าต่างลำดับชั้นคลิก New 2D Object\u003e Sprite จากนั้นเลือกสไปรต์ที่คุณต้องการใช้ ง่ายยิ่งขึ้นเพียงลากและวางไฟล์ลงในฉากอีกครั้ง

ตั้งชื่อสไปรต์ pipe_down นี้ ในตัวตรวจสอบภายใต้ Sprite Renderer ให้เลือกตัวเลือก Flip Y เพื่อพลิกท่อกลับหัว เพิ่ม RigidBody2D เดียวกัน

ตอนนี้เรามาเขียนสคริปต์ C # ใหม่ชื่อ PipeD จะมีรหัสที่คล้ายกัน:

คลาสสาธารณะ PipeD: MonoBehaviour (อักขระตัวละครส่วนตัว // สิ่งนี้จำเป็นสำหรับการเริ่มต้น void Start () (character \u003d FindObjectOfType ();) // Update ถูกเรียกหนึ่งครั้งต่อหนึ่งเฟรมโมฆะ Update () (if (character.transform.position.x - transform.position.x\u003e 30) ()) เป็นโมฆะ OnCollisionEnter2D (Collision2D other) (if (other.gameObject.tag \u003d\u003d "Player") (character.Death ();)))

รูปแบบสำเร็จรูป

ดังนั้นรหัสนี้เพียงพอสำหรับเราที่จะสร้างเกมทั้งหมด เราสามารถย้ายท่อไปทางด้านขวาของหน้าจอทุกครั้งที่มันหายไปหรือคัดลอกและวางท่อให้มากที่สุดเท่าที่เราอยากจะเห็นตลอดทั้งเกม

หากคุณไปทางแรกตรวจสอบให้แน่ใจว่าท่อยืนตามที่ควรจะเป็นหลังจากการสร้างแบบสุ่มและการรักษาความยุติธรรมจะเป็นเรื่องยาก หลังจากการตายของตัวละครพวกมันอาจปรากฏขึ้นจากท่อแรกเป็นกิโลเมตร!

หากคุณไปทางที่สองทุกอย่างจะจบลงด้วยการใช้หน่วยความจำโดยไม่จำเป็นด้วยการชะลอตัวของเกมและความสามารถในการเล่นซ้ำที่ จำกัด เนื่องจาก ทุกอย่างอยู่ในที่เดียวกันทุกครั้ง

มาใช้รูปแบบสำเร็จรูปแทน พูดง่ายๆก็คือเราจะเปลี่ยนท่อของเราให้เป็นเทมเพลตที่เราสามารถใช้เพื่อสร้างท่อได้อย่างมีประสิทธิภาพตามที่ต้องการ หากมีโปรแกรมเมอร์อยู่ที่นี่ให้ถือว่า Pipe script เป็นคลาสและไปป์เป็นอินสแตนซ์ของอ็อบเจ็กต์นี้

ในการดำเนินการนี้ให้สร้างโฟลเดอร์ใหม่ "Prefabs" จากนั้นลาก pipe_up และ pipe_down จากหน้าต่างลำดับชั้นไปยังโฟลเดอร์

ทุกครั้งที่คุณลากวัตถุจากโฟลเดอร์นี้เข้าไปในฉากวัตถุนั้นจะมีคุณสมบัติเหมือนกันดังนั้นคุณจึงไม่ต้องเพิ่มส่วนประกอบตลอดเวลา ยิ่งไปกว่านั้นหากคุณปรับขนาดองค์ประกอบในโฟลเดอร์มันจะส่งผลต่อไปป์ทั้งหมดในเกมและคุณไม่จำเป็นต้องเปลี่ยนแต่ละส่วนแยกกัน

อย่างที่คุณสามารถจินตนาการได้สิ่งนี้จะช่วยประหยัดทรัพยากรของเราได้อย่างมาก นอกจากนี้ยังหมายความว่าเราสามารถโต้ตอบกับวัตถุจากรหัส เราสามารถสร้างอินสแตนซ์ของท่อของเรา

ขั้นแรกให้เพิ่มรหัสนี้ในคำสั่งเงื่อนไขในเมธอด Update () ของสคริปต์ Pipe ซึ่งเราเว้นว่างไว้:

Void Update () (if (character.transform.position.x - transform.position.x\u003e 30) (float xRan \u003d Random.Range (0, 10); float yRan \u003d Random.Range (-5, 5); Instantiate (gameObject, Vector2 ใหม่ (character.transform.position.x + 15 + xRan, -10 + yRan), transform.rotation); ทำลาย (gameObject);))

สิ่งนี้จำเป็นในการสร้างอินสแตนซ์ของ gameObject ของเรา ผลลัพธ์คือสำเนาใหม่ที่เหมือนกัน ใน Unity เมื่อใดก็ตามที่คุณใช้คำว่า gameObject มันหมายถึงออบเจ็กต์ที่แนบสคริปต์อยู่ในกรณีของเราคือไปป์

เรากำลังสร้างท่อของเราขึ้นมาใหม่ในรูปแบบสุ่มเพื่อให้สนุกยิ่งขึ้น

แต่แทนที่จะทำสิ่งเดียวกันในสคริปต์ PipeD เราสร้างวัตถุทั้งสองในที่เดียวกัน ดังนั้นเราจึงสามารถกำหนดตำแหน่งของท่อที่สองเทียบกับท่อแรกได้อย่างง่ายดาย นอกจากนี้ยังหมายความว่าเราต้องการรหัสน้อยกว่าสำหรับ PipeD

สร้าง gameObject สาธารณะชื่อ pipeDown จากนั้นอัปเดตรหัสของคุณดังนี้:

ถ้า (character.transform.position.x - transform.position.x\u003e 30) (float xRan \u003d Random.Range (0, 10); float yRan \u003d Random.Range (-5, 5); float gapRan \u003d Random.Range (0, 3); Instantiate (gameObject, Vector2 ใหม่ (character.transform.position.x + 15 + xRan, -11 + yRan), transform.rotation); Instantiate (pipeDown, Vector2 ใหม่ (character.transform.position.x + 15 + xRan, 12 + gapRan + yRan), transform.rotation); ทำลาย (gameObject);)

กลับไปที่ Unity และลาก pipe_down prefab จากโฟลเดอร์ prefab (นี่สำคัญ!) ไปยังตำแหน่งที่ระบุว่า "Pipe Down" (สังเกตว่ากรณีอูฐของเราถูกแทนที่ด้วยช่องว่างอย่างไร) บนสไปรต์ต่อท่อ ถ้าคุณจำได้เรากำหนดให้ Pipe Down เป็น gameObject สาธารณะซึ่งทำให้เราสามารถระบุได้ว่าวัตถุนี้มาจากที่ใด - ในกรณีนี้คือผ่านผู้ตรวจสอบ ด้วยการเลือกพรีแฟบสำหรับอ็อบเจ็กต์นี้เราต้องแน่ใจว่าเมื่อไพพ์ถูกสร้างอินสแตนซ์มันจะรวมคุณสมบัติและสคริปต์ทั้งหมดที่เราเพิ่มไว้ก่อนหน้านี้ เราไม่ใช่แค่สร้างสไปรท์ แต่สร้างวัตถุขึ้นมาใหม่ด้วย collider ที่สามารถฆ่าตัวละครได้

ทุกสิ่งที่เราเพิ่มในที่เดียวกันในสคริปต์ PipeD เป็นเพียงแค่ทำลาย (gameObject) เพื่อที่ท่อจะทำลายตัวเองเมื่อหลุดออกจากขอบด้านซ้ายของหน้าจอ

หากคุณเริ่มเกมตอนนี้หน้าจอจะเลื่อนไปอีกโดยอัตโนมัติและคุณจะตายถ้าคุณวิ่งเข้าไปในท่อใด ๆ บินไปไกลพอสมควรแล้วท่อเหล่านี้จะหายไปและปรากฏขึ้นอีกครั้งข้างหน้า

น่าเสียดายที่มีช่องว่างระหว่างท่อมากและหน้าจอดูว่างเปล่า เราสามารถแก้ไขปัญหานี้ได้โดยการเพิ่มรูปแบบสำเร็จรูปในฉากของเราเพื่อสร้างไปป์ไลน์ที่ปรากฏอยู่ตลอดเวลา อย่างไรก็ตามการสร้างไปป์ในสคริปต์จะดีกว่า นี่เป็นสิ่งสำคัญเพราะมิฉะนั้นหลังจากการตายของตัวละครท่อที่จุดเริ่มต้นของเส้นทางจะถูกทำลายและพื้นที่ว่างจะก่อตัวขึ้นอีกครั้ง

ดังนั้นเราสามารถสร้างท่อสองสามท่อแรกในระหว่างการโหลดแต่ละครั้งของเกมและส่งคืนทุกอย่างกลับสู่ตำแหน่งหลังจากการตายของตัวละคร

เที่ยวบินที่ไม่มีที่สิ้นสุด

ตอนนี้ให้สร้างตัวแปรสาธารณะ pipe_up และ pipe_down ในสคริปต์อักขระ สิ่งนี้จะช่วยให้คุณสามารถอ้างอิงวัตถุที่สร้างขึ้นโดยการลากและวางพรีแฟบลงบนวัตถุอักขระเช่นเดียวกับเมื่อเราเพิ่ม pipe_down ลงในสคริปต์ Pipe

เราจำเป็นต้องเพิ่มตัวแปรเหล่านี้:

สาธารณะ GameObject pipe_up; สาธารณะ GameObject pipe_down;

จากนั้นเราจะเขียนวิธีการดังนี้:

โมฆะสาธารณะ BuildLevel () (Instantiate (pipe_down, new Vector3 (14, 12), transform.rotation); Instantiate (pipe_up, new Vector3 (14, -11), transform.rotation); Instantiate (pipe_down, new Vector3 (26, 14), transform.rotation); Instantiate (pipe_up, new Vector3 (26, -10), transform.rotation); Instantiate (pipe_down, new Vector3 (38, 10), transform.rotation); Instantiate (pipe_up, new Vector3 ( 38, -14), transform.rotation); Instantiate (pipe_down, new Vector3 (50, 16), transform.rotation); Instantiate (pipe_up, new Vector3 (50, -8), transform.rotation); Instantiate (pipe_down, ใหม่ Vector3 (61, 11), transform.rotation); Instantiate (pipe_up, Vector3 ใหม่ (61, -13), transform.rotation);)

เราจะเรียกมันหนึ่งครั้งในเมธอด Update () และหนึ่งครั้งในเมธอด Death ()

หลังจากเกมเริ่มขึ้นจะมีการเรียกอัปเดต () และไปป์ของเราได้รับการติดตั้งตามการกำหนดค่าที่กำหนด ด้วยเหตุนี้อุปสรรคสองสามประการแรกจะอยู่ที่เดิมเสมอ หลังจากการตายของผู้เล่นท่อจะไปยังสถานที่เดียวกัน

กลับไปที่ฉากใน Unity และลบสองท่อที่มีอยู่ในปัจจุบัน "เกม" ของคุณจะดูเหมือนหน้าจอว่างที่มีนก กดเล่นและท่อจะปรากฏขึ้นหลังจากสองสามครั้งแรกตำแหน่งของพวกเขาจะถูกกำหนดแบบสุ่ม

สุดท้าย

เราจึงสร้างทั้งเกม! เพิ่มตัวนับคะแนนพยายามทำให้เป็นต้นฉบับมากขึ้นและเพิ่มความยากของเกมเมื่อคุณเล่นไปเรื่อย ๆ นอกจากนี้ยังจะไม่ฟุ่มเฟือยในการทำเมนู นอกจากนี้ยังควรทำลายท่อบนหน้าจอหลังจากการตายของตัวละคร เมื่อคุณทำเสร็จแล้วให้พิจารณาเตรียมเกมที่พร้อมใช้งาน Play Store ไว้ในกระเป๋าของคุณ! เกมที่คล้ายกันครั้งหนึ่งทำให้นักพัฒนารายอื่นร่ำรวยมากซึ่งพิสูจน์ได้ว่าคุณไม่จำเป็นต้องเป็นอัจฉริยะด้านการเขียนโปรแกรมหรือมีผู้เผยแพร่ที่ร่ำรวยอยู่เบื้องหลังคุณจึงจะประสบความสำเร็จ คุณต้องมีความคิดที่ดีและสิบนาที!

อยากเขียนแอพ Android แต่ไม่รู้จะเริ่มจากตรงไหน? จากนั้นตรวจสอบสิ่งที่ยอดเยี่ยมสำหรับการเรียนรู้การพัฒนา Android

การพัฒนาแอปบนอุปกรณ์เคลื่อนที่เป็นหนึ่งในการแสวงหาผลกำไรมากที่สุดในอุตสาหกรรมคอมพิวเตอร์ มีค่าใช้จ่ายหลายร้อยหรือหลายพันดอลลาร์ในการสร้างเกมบน Android และกำไรอาจสูงถึงหนึ่งล้านดอลลาร์ ในเรื่องนี้หลายคนสนใจที่จะพัฒนาแอพพลิเคชั่นสำหรับโทรศัพท์ ในบทความนี้คุณจะได้เรียนรู้วิธีสร้างเกม Android ตั้งแต่เริ่มต้นผ่านคอมพิวเตอร์ว่าจะเลือกเอนจิ้นและตัวสร้างใดดีกว่ากัน

ไม่มีเกมใดที่ประสบความสำเร็จสมบูรณ์หากไม่มีกราฟิกที่สวยงามดังนั้นการสร้างการออกแบบจึงเป็นขั้นตอนที่สำคัญที่สุดในการพัฒนา การออกแบบ Android ถูกนำไปใช้โดยใช้ "เอกสารการออกแบบ" หรือแท่นวางดีไซน์ คุณต้องเริ่มสร้างของเล่นอย่างแม่นยำด้วยการศึกษารายละเอียด ไฟล์ประกอบด้วย:

1. แบบจำลองวัตถุ
2. ข้อกำหนดการใช้งาน
3. เนื้อหาเกม;
4. อินเตอร์เฟซ.

ลองพิจารณาแต่ละประเด็นโดยละเอียด

โมเดลวัตถุ

นี่คือข้อมูลเกี่ยวกับฟังก์ชันการทำงานของแต่ละรายการ โมเดลออบเจ็กต์รับผิดชอบต่อความสามารถในการซื้อและขายไอเท็มตลอดจนปรับปรุงลักษณะการเล่นของตัวละคร

ข้อกำหนดการใช้งาน

เป็นการอธิบายถึงการเล่นเกมคุณสมบัติหลักของตัวละครแต่ละตัว นอกจากนี้ยังมีคำอธิบายคุณสมบัติของไอเท็มในเกมเช่นอาวุธชุดปฐมพยาบาลชุดเกราะและอื่น ๆ โดยพื้นฐานแล้วข้อกำหนดการใช้งานเป็นกฎที่ใช้ในการเล่นเกม ยิ่งส่วนนี้ทำงานได้ดีเท่าไหร่การสร้างเกม Android คุณภาพสูงก็จะง่ายขึ้นเท่านั้น

เนื้อหาเกม

นี่คือการเติมข้อความของเกม จะอธิบายถึงบทสนทนาของตัวละครและอาวุธที่สามารถใช้สร้างความเสียหายได้, จำนวนพลังชีวิตที่จะได้รับ, ลักษณะที่จะเพิ่มขึ้นเมื่อใช้อุปกรณ์ต่างๆ นอกจากนี้ยังมีคำอธิบายโดยละเอียดของแต่ละรายการ

อินเตอร์เฟซ

อินเทอร์เฟซคือวิธีที่ผู้ใช้จะโต้ตอบกับเกม ประกอบด้วยปุ่มที่คุณสามารถควบคุมตัวละครและส่วนเมนูเช่นเล่นคะแนนการตั้งค่าผู้เล่นอันดับต้น ๆ ความช่วยเหลือ หากคุณไม่มีประสบการณ์ในการสร้างแอปพลิเคชันสำหรับ Android ก่อนที่จะสร้างแอปพลิเคชันของคุณเองให้ดาวน์โหลดจาก Play Store และวิเคราะห์เกมยอดนิยมและโอนโซลูชันที่ดีที่สุดไปยังโครงการของคุณ

เครื่องยนต์เกม

แกนหลักของเกมคือเครื่องยนต์ เป็นซอฟต์แวร์ที่ช่วยให้คุณพัฒนาและเรียกใช้งานได้ ประกอบด้วยชุดโปรแกรมทั้งหมดรวมถึงเอนจิ้นการเรนเดอร์เอ็นจินฟิสิกส์เสียงภาพเคลื่อนไหวและอื่น ๆ เพื่ออำนวยความสะดวกในกระบวนการเขียนโปรแกรมนักพัฒนาบุคคลที่สามจึงสร้างเอนจิ้นเกมของตนเองสำหรับแอปพลิเคชัน Android โดยเฉพาะ

แต่ละตัวมีฟังก์ชั่นที่แตกต่างกัน: บางส่วนได้รับการออกแบบมาสำหรับ 3 มิติ, อื่น ๆ สำหรับ 2D, รองรับหลายแพลตฟอร์มได้ มีเครื่องยนต์ดังกล่าวจำนวนมาก แต่ถ้าคุณเป็นมือใหม่ควรเลือกหนึ่งในเครื่องยนต์ที่ได้รับความนิยมมากที่สุดเนื่องจากจะมีฟังก์ชั่นที่จำเป็นทั้งหมดอยู่ที่นั่น

UDK

แรงบิด 2d / 3d

Game Builder คืออะไร?

Constructor เป็นโปรแกรมที่รวมเอาเอนจิ้นเกมและสภาพแวดล้อมการพัฒนาแบบบูรณาการ ผู้ออกแบบทำให้กระบวนการพัฒนาสามารถเข้าถึงได้สำหรับผู้ที่ไม่มีทักษะการเขียนโปรแกรม ตัวสร้างบางตัวอนุญาตให้คุณสร้างเกมบางประเภทในขณะที่บางประเภทมีฟังก์ชันการทำงานสูงสุด แต่มีค่าใช้จ่ายสูงกว่ามาก สำหรับนักพัฒนาแอปพลิเคชันมือถือมือใหม่การเลือกนักออกแบบถือเป็นช่วงเวลาที่สำคัญที่สุดช่วงหนึ่งเนื่องจากชะตากรรมของแอปพลิเคชันในอนาคตจะขึ้นอยู่กับความสามารถของมัน

ตัวสร้างช่วยให้คุณสร้างเกมประเภทต่างๆสำหรับ Windows, Android และ iOS มีสถานที่สำเร็จรูปวัตถุตัวละครและการออกแบบเสียงให้เลือกมากมายดังนั้นการสร้างเกม Android เกมแรกจะใช้เวลาไม่นาน ผู้ใช้ที่คุ้นเคยกับภาษาโปรแกรม JS และ C ++ สามารถใช้ GML แบบฝังได้ ข้อเสียเปรียบเพียงประการเดียวคือโปรแกรมไม่ได้แปลเป็นภาษารัสเซีย

สรุป

การสร้างเกมสำหรับ Android ไม่ใช่เรื่องง่าย แต่ทำกำไรได้มาก หากคุณตัดสินใจที่จะพัฒนาเกมและสร้างรายได้ก่อนอื่นให้คิดออก จากนั้นเขียน "เอกสารการออกแบบ" และตัดสินใจเลือกเอนจินเกมที่สามารถเพิ่มศักยภาพสูงสุดได้ หลังจากนั้นคุณสามารถเริ่มสร้างแอปพลิเคชันได้โดยตรงในตัวออกแบบ

วิดีโอ

หากต้องการเรียนรู้เพิ่มเติมเกี่ยวกับขั้นตอนการสร้างเกม Android โปรดดูชุดวิดีโอที่ทุ่มเทให้กับบทเรียนนี้

Unity เป็นเครื่องมือที่อยู่เบื้องหลังเกมส่วนใหญ่ในทุกแพลตฟอร์มในปัจจุบัน การใช้เอนจิ้นทำให้สามารถสร้างเกมที่มุ่งเป้าไปที่การเปิดตัวบนคอมพิวเตอร์ (Windows, Linux, MacOS), โทรศัพท์มือถือ, แท็บเล็ต (Android, iOS) และแม้แต่ PlayStation, Xbox, Nintendo เกมคอนโซล

ฉันจะสร้างเกมใน 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 นั้นรวดเร็วและค่อนข้างง่ายเพียงใด อ่านเกี่ยวกับเรื่องนี้ในบทความด้านล่างซึ่งกล่าวถึงการทำงานกับเอนจิ้น Unity3D

คุณเล่นเกมคอมพิวเตอร์หรือไม่? ถ้าใช่แน่นอนว่าในระหว่างการผ่านเกมลูกระเบิดเกมถัดไปบางครั้งคุณมีความคิดเช่น: "แต่นี่ฉันคงทำผิด!" คุณต้องการเป็นนักพัฒนาด้วยตัวเองหรือไม่? จากนั้นฉันขอแนะนำให้คุณ "การผจญภัย" เล็ก ๆ แต่สนุกสนานมาก;)

เครื่องยนต์คืออะไรและทำไมถึงต้องการ?

ก่อนหน้านี้ย้อนกลับไปในสมัยของคอมพิวเตอร์เกมและโปรแกรมแรก ๆ ถูกสร้างขึ้นโดยใช้วิธีที่เรียกว่า "ฮาร์ดคอร์" นั่นคือสำหรับการพัฒนาเต็มรูปแบบจำเป็นต้องเป็นโปรแกรมเมอร์ที่มีประสบการณ์พอสมควรซึ่งรู้ภาษาโปรแกรมของเขาอย่างละเอียดและสามารถเขียนได้เกือบทั้งเกม (รวมถึงกราฟิกพิกเซลและเอฟเฟกต์พิเศษ!) ใน Notepad แบบธรรมดา มีคนแบบนี้ไม่กี่คนและพวกเขาก็ชื่นชมมาก (และพวกเขาก็ยังคงชื่นชม) ...

วันนี้เกณฑ์ในการเข้าสู่หัวข้อการเขียนโปรแกรมลดลงอย่างมาก และสิ่งนี้ไม่เพียง แต่อำนวยความสะดวกโดยการมีเอกสารและสื่อการฝึกอบรมทุกประเภทเท่านั้น แต่ยังรวมถึงกระบวนการพัฒนาที่ง่ายขึ้นอีกด้วย ปัจจุบันหาคน "ฮาร์ดคอร์" ตัวจริงได้ยากอยู่แล้วเนื่องจากมีการพัฒนาสภาพแวดล้อมที่ค่อนข้างสะดวกซึ่งเรียกว่า "เครื่องยนต์"

สาระสำคัญของเอ็นจิ้นคือช่วยให้คุณสามารถนำเข้าออบเจ็กต์เกมที่จำเป็นทั้งหมดในโหมดภาพที่เรียบง่ายจัดเรียงบนเวทีเสมือนและกำหนดค่าพารามิเตอร์ทั้งหมด นั่นคืองานของโปรแกรมเมอร์คือการเขียนตรรกะของเกมให้ถูกต้องเท่านั้น!

อย่างไรก็ตามเพื่อความสะดวกในการทำงานคุณต้องจ่ายเงินเพิ่มขึ้นตามขนาดของโครงการ (บางครั้งก็หลายครั้ง!) เมื่อเทียบกับอะนาล็อกที่เขียนด้วยวิธี "ฮาร์ดคอร์" แบบเก่า ด้วยเหตุนี้นักพัฒนาบางคนจึงไม่ชอบเอนจิ้นหรือพยายามเขียนของตัวเองซึ่งใช้เฉพาะส่วนประกอบที่จำเป็นเท่านั้น ...

แต่เราคุณและฉันอยู่ไกลจากโปรแกรมเมอร์แรงงาน :) ดังนั้นเรามาเริ่มสร้างเกมง่ายๆสำหรับ Android โดยใช้เอนจิ้น Unity3D ยอดนิยม

เริ่มต้นกับโปรเจ็กต์ใน Unity3D

เหตุใดเราจึงตัดสินใจใช้ Unity3D:

• ความสามารถในการสร้างเกม 2D และ 3D เต็มรูปแบบ
• ความสามารถในการรวบรวมเกมสำเร็จรูปสำหรับอุปกรณ์ใด ๆ
• ความสะดวกในการควบคุมเครื่องยนต์
• การเพิ่มฟังก์ชันการทำงานที่ดีโดยการเชื่อมต่อปลั๊กอิน
• ขนาดที่ค่อนข้างเล็กของการประกอบสุดท้ายของเกม (เมื่อเปรียบเทียบกับเอนจิ้นอื่น ๆ )

แน่นอนว่าการ์ดหลักของ Unity3D คือความสามารถรอบด้านและการทำงานหลายแพลตฟอร์ม คุณสามารถพอร์ตเกมที่เล่นเสร็จแล้ว (อาจมีการปรับเปลี่ยนเล็กน้อย) แม้กระทั่งไปยังพีซี (ที่ใช้ Windows, Linux หรือ MacOS) แม้กระทั่งไปยัง Android หรือแม้แต่ไปยัง PlayStation หรือ XBox! ในการดำเนินการนี้เราจะต้องดาวน์โหลดเอนจิ้นเองเท่านั้นซึ่งโดยวิธีการที่ "มีน้ำหนัก" มากกว่ากิกะไบต์และ SDK ที่จำเป็น (หากมีการวางแผนการพัฒนาสำหรับแพลตฟอร์มมือถือหรือคอนโซล) หากคุณต้องการสร้างเกมสำหรับ Windows คุณก็ไม่จำเป็นต้องดาวน์โหลดอะไรเพิ่มเติม แต่เนื่องจากเรากำลังจะสร้างเกมสำหรับ Android เราจึงต้องดาวน์โหลด Android SDK (Software Development Kit) ด้วย ฉันแนะนำให้คุณดาวน์โหลด SDK ในไฟล์ ZIP เพื่อความสะดวกยิ่งขึ้นในการทำงานกับมัน

เมื่อดาวน์โหลดทุกอย่างแล้วคุณสามารถคลายไฟล์ลงในโฟลเดอร์ Android SDK ที่คุณสะดวกจากนั้นดำเนินการติดตั้ง Unity3D เอง มีการติดตั้งเหมือนกับโปรแกรมทั่วไปใน Windows ดังนั้นจึงไม่มีปัญหาในการติดตั้ง หลังจากการติดตั้งเครื่องยนต์จะเริ่มทำงานและก่อนอื่นเราต้องสร้างโครงการใหม่:

ในการดำเนินการนี้เราจะต้องปิดหน้าต่างต้อนรับและช่วงแนะนำทั้งหมดจากนั้นเลือกรายการ "โครงการใหม่" จากเมนู "ไฟล์" ในหน้าต่างที่เปิดขึ้น (ดูภาพหน้าจอด้านบน) เราจะถูกขอให้ระบุโฟลเดอร์สำหรับบันทึกโครงการ (ชื่อจะตรงกับชื่อของโครงการ) นำเข้าชุดฟังก์ชันมาตรฐานบางชุด (เราไม่ต้องการ) และระบุโหมดการทำงาน เลือก 2D เป็นโหมดแล้วกดปุ่ม "สร้าง" เสร็จสิ้นการเตรียมงาน :)

ส่วนต่อประสานเครื่องยนต์และลำดับชั้นของโครงการ

หลังจากสร้างโครงการแล้วโครงการจะถูกโหลดลงในพื้นที่ทำงาน Unity3D:

พื้นที่ทำงานนี้มีโครงสร้างแบบแยกส่วนและประกอบด้วยหน้าต่างซ้อนกันหลายบานที่สามารถเคลื่อนย้ายได้ตามที่คุณต้องการ ฉันกำหนดค่าไว้เช่นนี้ (จากซ้ายไปขวาและบนลงล่าง):

1. หน้าต่างลำดับชั้น - แสดงตำแหน่งลำดับชั้นของวัตถุที่ใช้งานและไม่ได้ใช้งานบนฉาก ตามค่าเริ่มต้นวัตถุเดียวในรายการคือกล้องหลัก
2. หน้าต่างฉาก - แสดงฉากของเกมและวัตถุทั้งหมดบนนั้น (รวมถึงกล้องเสียงพื้นผิว ฯลฯ )
3. หน้าต่างตัวตรวจสอบ - แสดงคุณสมบัติทั้งหมดของวัตถุที่เลือกในลำดับชั้นหรือบนฉากและช่วยให้คุณแก้ไขเสริมหรือลบออกได้
4. หน้าต่างเกม - แสดงโลกของเกมตามที่กล้องมองเห็นและให้คุณเลือกขนาดของหน้าต่างเกมทดสอบเสมือนจริงเป็นพิกเซล นอกจากนี้ยังช่วยให้คุณสามารถเปิดใช้งานการขยายหน้าต่างเกมในขนาดเต็ม (ขยายใหญ่สุดในการเล่น) และเปิด / ปิดการแสดงข้อมูลต่างๆสำหรับผู้พัฒนา
5. หน้าต่างโครงการและคอนโซล หน้าต่างโปรเจ็กต์ใช้เพื่อนำทางทรัพยากรของโปรเจ็กต์: รูปภาพที่โหลดเสียงโมเดล ฯลฯ นอกจากนี้เมื่อใช้หน้าต่างนี้ (เมนูบริบท) คุณสามารถสร้างออบเจ็กต์เกมเปล่าใหม่ที่มีประเภทและสคริปต์ต่างๆได้ หน้าต่างคอนโซลใช้เพื่อแสดงข้อความแสดงข้อผิดพลาด (สีแดง) คำเตือน (สีเหลือง) และข้อมูลการดีบักต่างๆที่คุณร้องขอ (สีเทา)
6. หน้าต่างป้ายกำกับเนื้อหา - ส่วนล่างของหน้าต่างตัวตรวจสอบซึ่งจะแสดงตัวอย่างของวัตถุหรือไฟล์ที่เลือกในหน้าต่างโครงการ

นอกเหนือจากทั้งหมดที่กล่าวมาแล้วให้ใส่ใจกับปุ่มสามปุ่มที่อยู่ตรงกลางด้านบน ช่วยให้คุณสามารถเริ่มโปรเจ็กต์ของคุณหยุดชั่วคราว (บางครั้งก็มีประโยชน์เมื่อทำการดีบั๊กเพื่อดูสิ่งที่กำลังทำในลำดับชั้นเป็นต้น) และปิดโปรเจ็กต์

เราจะสร้างเครื่องจำลองเครื่องดนตรี: กลองพื้นบ้านของอินเดียที่เรียกว่า "tabla" ดังนั้นในการเริ่มต้นเราจะสร้างโฟลเดอร์ว่างสองโฟลเดอร์ในโครงการซึ่งจะเก็บเสียงและรูปภาพ คุณสามารถสร้างโฟลเดอร์ใหม่โดยเรียกเมนูบริบทในหน้าต่างตัวนำทางโครงการและเลือกรายการ "โฟลเดอร์" ในรายการ "สร้าง"

ควรพูดคำไม่กี่คำเกี่ยวกับวิธีตั้งชื่อโฟลเดอร์เหล่านี้ สำหรับเกมง่ายๆเช่นโปรแกรมจำลองของเราโดยหลักการแล้วโฟลเดอร์สามารถ "เรียก" ตามที่คุณต้องการอย่างไรก็ตามมีอย่างน้อยสองชื่อที่ดีกว่าที่จะไม่ใช้เนื่องจากเอนจิ้นสงวนไว้ นี่คือชื่อทรัพยากรและปลั๊กอิน ในโปรเจ็กต์ขนาดใหญ่โฟลเดอร์ทรัพยากรจะถูกสร้างขึ้นพร้อมกันและ "อะไหล่" ของเกมทั้งหมด (รูปภาพเสียงโมเดลพื้นผิวและพรีแฟบ) จะถูกเก็บไว้ในนั้น (เรียงตามโฟลเดอร์ย่อย) ตามชื่อที่แนะนำจะจัดเก็บชุดคุณลักษณะของบุคคลที่สามเพิ่มเติมทั้งหมด (ที่เรียกว่า "เนื้อหา") ซึ่งมีอยู่ไม่กี่รายการในที่เก็บสินทรัพย์ซึ่งเป็นที่เก็บส่วนขยายสำหรับ Unity3D

การนำเข้าไฟล์และสร้างวัตถุในเกม

ก่อนที่จะสร้างโครงการเกมใหม่ขอแนะนำให้เตรียมไฟล์ทั้งหมดที่จำเป็นสำหรับการใช้งานไว้ล่วงหน้า ในกรณีของเราไฟล์ดังกล่าวเป็นภาพและเสียง วิธีที่ง่ายที่สุดในการนำเข้าสู่โปรเจ็กต์คือการลากและวางลงในโฟลเดอร์ที่ต้องการ เริ่มจากภาพ ...

หลังจากภาพปรากฏในโฟลเดอร์รูปภาพของเราแล้วภาพเหล่านั้นจะต้องได้รับการปรับแต่งเล็กน้อย:

ความจริงก็คือโดยค่าเริ่มต้น Unity3D จะบีบอัดรูปภาพทั้งหมดที่เพิ่มลงในโครงการโดยสูญเสียคุณภาพ หากเราไม่ต้องการการสูญเสียดังกล่าว (สำคัญอย่างยิ่งสำหรับเกมที่มีกราฟิก HD) เราควรเลือกแต่ละภาพและในหน้าต่างตัวตรวจสอบให้เปลี่ยนค่าของพารามิเตอร์ "รูปแบบ" จาก "บีบอัด" เป็น "Truecolor" ในแท็บ "ค่าเริ่มต้น" คุณอาจต้องเปลี่ยนพารามิเตอร์ "ขนาดสูงสุด" หากมีค่าน้อยกว่าความกว้างจริงของรูปภาพ (โดยค่าเริ่มต้นคือ 1024 พิกเซล) หลังจากการเปลี่ยนแปลงทั้งหมดอย่าลืมคลิกปุ่ม "ใช้" เพื่อนำไปใช้ หากจำเป็นให้ดำเนินการที่คล้ายกันกับรูปภาพอื่น ๆ ทั้งหมด

ตอนนี้มาสร้างวัตถุเกมจากรูปภาพของเรา ในการดำเนินการนี้เพียงลากรูปภาพที่ต้องการลงในหน้าต่างลำดับชั้น รูปภาพหรือโมเดล 3 มิติจะถูกแปลงเป็น Game Object โดยอัตโนมัติและแสดงที่จุดเริ่มต้นที่ด้านหน้าของกล้อง

ก่อนอื่นเราได้เพิ่มภาพพื้นหลังที่ควรแสดงแบบเต็มหน้าจอ คุณสามารถตรวจสอบว่าเป็นเช่นนั้นหรือไม่โดยเลือกกล้องในหน้าต่างลำดับชั้นและดูว่าเฟรมแสดงผลอย่างไร ในภาพหน้าจอด้านบนคุณจะเห็นว่าส่วนหนึ่งของพื้นหลังของเรายังคงอยู่นอกมุมมองของกล้องดังนั้นคุณต้องปรับขนาดของมุมมองนี้โดยการลากกรอบไปทางขวาบนพื้นที่งานหรือแก้ไขพารามิเตอร์ "ขนาด" ในหน้าต่างตัวตรวจสอบ ในกรณีของเราเราต้องเปลี่ยนค่าเริ่มต้น (5) เป็น 5.4

เพียงเท่านี้เราก็ไม่แตะต้องกล้องอีกต่อไป แต่เพิ่มและปรับภาพที่เหลือ เมื่อเราเพิ่มเราเห็นว่าบางส่วนใหญ่เกินไปสำหรับเกมของเรา สามารถลดลงได้ทั้งทางกายภาพในโปรแกรมแก้ไขกราฟิกหรือโดยใช้เครื่องยนต์ มาลองวิธีสุดท้าย ในการดำเนินการนี้ให้เลือกรูปภาพในหน้าต่างลำดับชั้นและในหน้าต่างตัวตรวจสอบให้เปลี่ยนค่า "มาตราส่วน" สำหรับพิกัด X และ Y จาก 1 เป็น 0.5 (นั่นคือลดลงครึ่งหนึ่ง) ในสถานที่เดียวกันเป็นที่พึงปรารถนาเพื่อหลีกเลี่ยงการทับซ้อนเพื่อกำหนดวัตถุเกมทั้งหมด (ยกเว้นพื้นหลัง) ลำดับที่ไม่ใช่ศูนย์ใน Layer:

ขั้นตอนสุดท้ายในการเตรียมวัตถุในเกมจากรูปภาพคือการ "แขวน" colliders ไว้ที่พวกมัน ใน Unity3D colliders ถูกใช้เป็นตัวตรวจจับการโต้ตอบระหว่างออบเจ็กต์ นั่นคือในความเป็นจริงเชลล์เสมือนวางอยู่บนรูปภาพของเราซึ่งสามารถลงทะเบียนสัมผัสกับมันได้

ในการเพิ่ม collider ให้กับวัตถุให้เลือกในหน้าต่างลำดับชั้นจากนั้นในหน้าต่างตัวตรวจสอบให้กดปุ่ม "เพิ่มส่วนประกอบ" ในรายการส่วนประกอบที่ปรากฏขึ้นเรากำลังมองหา Physics 2D (ฟิสิกส์ 3 มิติธรรมดาในโหมดของเราจะไม่ทำงาน) และจากตัวเลือกทั้งหมด "Circle Collider 2D" เหมาะสำหรับเรามากที่สุด เราเลือกเลย โครงร่างสีเขียวจะปรากฏขึ้นรอบ ๆ วัตถุของเราซึ่งแสดงถึงขอบเขตของ collider เหลือเพียงการทำเครื่องหมายในช่อง "Is Trigger" เพื่อให้ collider ของเราบันทึกเฉพาะการคลิกและไม่โต้ตอบกับพื้นที่เกมโดยรอบอีกต่อไป:

เราทำซ้ำการกระทำที่คล้ายกันสำหรับวัตถุที่เหลือทั้งหมด พื้นหลังของเราเท่านั้นที่จะแตกต่างจากวัตถุอื่น ๆ สำหรับสิ่งนี้เราจะใช้ Box Collider 2D และตั้งค่าตำแหน่ง Z ให้มากกว่าศูนย์เพื่อดัน collider และพื้นหลังไปที่พื้นหลัง (ซึ่งจะมีประโยชน์ในภายหลัง)

ทำงานกับเสียง

เสียงใน Unity 3D ดูสับสนเล็กน้อยในตอนแรก แต่เรามาลองคิดตามลำดับกันเถอะ :)

สิ่งแรกที่เราต้องทำคือลากเสียงทั้งหมดลงในโฟลเดอร์ Sounds และปรับแต่งเล็กน้อยด้วย:

หากระดับเสียงของเสียงทั้งหมดได้รับการปรับในตอนแรกสิ่งที่คุณต้องทำคือปิดการประมวลผลเสียง 3 มิติ ในเกม 3 มิติจำเป็นต้องมีการประมวลผลนี้เพื่อจำลองแนวทางของแหล่งกำเนิดเสียงเมื่อกล้องเข้าใกล้ แต่ใน 2D เราไม่จำเป็นต้องใช้ดังนั้นให้เลือกแต่ละเสียงแล้วยกเลิกการเลือกช่องทำเครื่องหมาย "เสียง 3D"

ตอนนี้เราสามารถเริ่มเพิ่มเสียงให้กับวัตถุในเกมได้แล้ว ในการดำเนินการนี้เราต้องเลือกแต่ละปุ่มและเพิ่มองค์ประกอบ "แหล่งที่มาของเสียง" ใหม่จากส่วน "เสียง" เมื่อเพิ่มคอมโพเนนต์แล้วให้เลือกปุ่ม "คลิปเสียง" ที่เกี่ยวข้องและยกเลิกการเลือกช่องทำเครื่องหมาย "เล่นเมื่อตื่น" (ใช้งานโดยค่าเริ่มต้น):

เมื่อเสียงทั้งหมดติดอยู่กับปุ่มที่ต้องการก็ถึงเวลาสนุก - การเขียนสคริปต์ ...

สคริปต์แรก

ก่อนที่จะเริ่มแยกวิเคราะห์สคริปต์แรกของเราคุณควรพูดคำสองสามคำเกี่ยวกับระบบสคริปต์ใน Unity 3D

Unity ช่วยให้คุณสามารถเขียนโค้ดได้สามภาษาพร้อมกัน: JavaScript (อย่างแม่นยำยิ่งขึ้น, UnityScript เวอร์ชันที่แก้ไขเล็กน้อย), C # และ Boo ในหนังสือและแบบฝึกหัดจำนวนมากคุณสามารถพบความคิดเห็นที่ว่าสำหรับผู้เริ่มต้นการเขียนสคริปต์ใน Unity นั้นง่ายกว่าในการเรียนรู้โดยใช้ JavaScript เป็นตัวอย่าง อย่างไรก็ตามภาษานี้ไม่ได้ใช้งานง่ายเหมือนกับภาษาอื่น ๆ และในอนาคตคุณจะต้องเรียนรู้ใหม่ ดังนั้นจึงเป็นการดีกว่าที่จะเริ่มต้นทันทีด้วยการเรียนรู้ C # (Boo ก็ไม่เลวเช่นกัน แต่ก็ไม่มีบทช่วยสอนมากมาย)

ตอนนี้เกี่ยวกับตำแหน่งที่จะเขียนโค้ด โปรแกรมแก้ไขโค้ดเริ่มต้นใน Unity 3D คือ MonoDevelop IDE ข้อได้เปรียบของสภาพแวดล้อมการพัฒนานี้คือมีคำแนะนำสำหรับการป้อนวิธีการคลาสและฟังก์ชันมาตรฐานอย่างรวดเร็วรวมถึงระบบตรวจสอบไวยากรณ์ อย่างไรก็ตามสำหรับฉันข้อเสียคือความยุ่งยากและความเข้มข้นของทรัพยากรสูง โชคดีที่ในการตั้งค่า Unity คุณสามารถตั้งค่าอะไรก็ได้เป็นโปรแกรมแก้ไขข้อความดังนั้นฉันจึง "แขวน" Notepad ++ ที่มีน้ำหนักเบาและใช้งานได้สำหรับตัวเอง (จะแสดงตัวอย่างเกือบทั้งหมดในนั้น)

และสิ่งสุดท้าย โดยธรรมชาติแล้วคุณจะไม่ไปไหนไกลหากไม่มีเอกสารอ้างอิงในการควบคุมความซับซ้อนทั้งหมดของเครื่องยนต์ดังนั้นนี่คือรายการแหล่งข้อมูลอินเทอร์เน็ตที่เหมาะสมหลายอย่างในหัวข้อ Unity 3D:

• http://docs.unity3d.com/ru/current/Manual/UnityManualRestructured.html - คู่มืออย่างเป็นทางการสำหรับเครื่องยนต์ที่มีการแปลบางส่วนเป็นภาษารัสเซีย (ปรากฏเมื่อไม่นานมานี้และบางครั้งก็ยังไม่เสถียร)
• http://docs.unity3d.com/ru/current/ScriptReference/index.html - คู่มือการเขียนสคริปต์อย่างเป็นทางการเป็นภาษาอังกฤษ
• http://unity3d.ru/distribution/index.php - ฟอรัมภาษารัสเซียสำหรับนักพัฒนา Unity 3D
• http://habrahabr.ru/post/141362/ - ชุดบทเรียนเกี่ยวกับการสร้างเกมสามมิติบน Habrahabr
• http://msdn.microsoft.com/ru-ru/library/618ayhy6.aspx - การอ้างอิง C # อย่างเป็นทางการจาก Microsoft ในภาษารัสเซีย

เพื่อไม่ให้ล่าช้าเป็นเวลานานฉันขอเสนอให้สร้างสคริปต์แรกทันที สำหรับสคริปต์หากมีจำนวนมากควรเลือกโฟลเดอร์แยกต่างหาก แต่เกมของเราจะเรียบง่ายดังนั้นเราจึงสามารถสร้างสคริปต์ได้ในโฟลเดอร์รูทของโปรเจ็กต์ ในการดำเนินการนี้ให้เรียกเมนูบริบทในหน้าต่างโครงการเลือกรายการสร้างและคลิก "สคริปต์ C #" มาตั้งชื่อสคริปต์ใหม่ของเราเช่น Sounds และเปิดด้วยการดับเบิลคลิก การลบวิธีการอัปเดตและเริ่มมาตรฐานจากนั้นลงทะเบียนสิ่งที่จำเป็นเราได้รับสคริปต์ประเภทต่อไปนี้

หากคุณไม่ได้กำหนดค่าตัวแก้ไขใหม่สคริปต์ของเราจะเปิดขึ้นใน MonoDevelop มาวิเคราะห์โครงสร้างกัน ...

ในความเป็นจริงสคริปต์ C # ทุกตัวมีสามส่วนหลัก:

1. ที่ด้านบนสุดคือไลบรารีที่ต้องเชื่อมต่อเพื่อให้สคริปต์ทำงานได้ (ตัวอย่างเช่น "การใช้ Unity.Engine" เชื่อมต่อเอนจิ้นเองและ "ใช้ System.Collections" - ไลบรารีที่มีคลาสในตัวจำนวนมากเพื่อให้สคริปต์ทำงานภายใต้ระบบที่แตกต่างกัน)
2. การประกาศคลาสและตัวแปร ใน C # ไม่มีแนวคิดของสคริปต์เช่นนี้ แต่จะใช้แนวคิดของ "คลาส" ซึ่งรวมถึงวิธีการและฟังก์ชันต่างๆ แม้ว่าในบริบทของ Unity 3D จะเป็นสิ่งเดียวกันจริง ๆ :) สิ่งสำคัญที่ต้องจำคือชื่อของคลาสจะต้องตรงกับชื่อที่เราตั้งให้กับสคริปต์ ความไม่ชอบมาพากลของตัวแปรใน C # คือต้องพิมพ์ (ยกเว้นตัวแปรชั่วคราวซึ่งจะประกาศในสคริปต์เอง) ในทางปฏิบัติหมายความว่าต้องระบุระดับการเข้าถึง (ส่วนตัวหรือสาธารณะ) และประเภท (int, float, bool หรือเช่นเดียวกับในสคริปต์ของเราคือ AudioClip) สำหรับตัวแปรในกรณีนี้คุณสามารถตั้งชื่อให้กับตัวแปรใดก็ได้หรือคุณสามารถให้ค่าได้ทันที อธิบาย
3. ชุดวิธีการและฟังก์ชัน เกือบทุกฟังก์ชันที่ดำเนินการเฉพาะเรียกว่าวิธีการใน C # โดยพื้นฐานแล้วในวรรณกรรมเกี่ยวกับ Unity 3D จะเรียกว่าฟังก์ชัน แต่ถ้าเรากำลังพูดถึง C # เป็นภาษาการเขียนโปรแกรมแยกต่างหากนี่คือวิธีการ :) ฟังก์ชันในรูปแบบบริสุทธิ์ใน Unity ได้แก่ ฟังก์ชันมาตรฐานสำหรับเอาต์พุตเสียงการเรนเดอร์องค์ประกอบ GUI เป็นต้นซึ่งใช้ภายในวิธีการ

เมื่อรู้โครงสร้างของสคริปต์แล้วก็ง่ายต่อการเข้าใจความหมายซึ่งมีดังต่อไปนี้ ... ในคลาส Sounds (สคริปต์) เราประกาศตัวแปรประเภท AudioClip 9 ตัวแปรพร้อมชื่อที่เราต้องการเพื่อความสะดวกในการแยกแยะ เรากำหนดให้เป็นแบบสาธารณะ (ส่วนตัวจะไม่ปรากฏในตัวแก้ไขและเราจะต้อง "แขวน" เสียงผ่านตัวแก้ไข) จากนั้นในเนื้อหาของสคริปต์เราใช้เมธอด "void OnMouseDown ()" มาตรฐาน ก่อนหน้านี้มีหน้าที่จัดการกับการคลิกเมาส์เท่านั้น แต่ในเวอร์ชันที่ใหม่กว่าจะตีความว่าสัมผัสหน้าจอสัมผัสด้วย ในนั้นเราเขียนเงื่อนไขที่เราตรวจสอบชื่อของคอลไลเดอร์ที่กดและหากเราตรวจพบการกดของหนึ่งในนั้นเราจะส่งเสียงที่สอดคล้องกัน (เราใช้เสียงมาตรฐาน PlayOneShot (); ฟังก์ชัน)

เมื่อเขียนโค้ดให้ตรวจสอบการมีอยู่ของวงเล็บเปิดและปิดทั้งหมดอย่างระมัดระวังมิฉะนั้นคุณจะได้รับรายงานข้อผิดพลาดในคอนโซลตลอดเวลาและจะไม่สามารถเปิดโครงการของคุณได้เลย! นอกจากนี้ให้ใส่ใจกับการใช้ตัวพิมพ์ใหญ่ในชื่อวิธีการและฟังก์ชัน นอกจากนี้ยังมักเป็นสาเหตุของข้อผิดพลาด และแน่นอนให้สังเกตสัญลักษณ์ทั้งหมด (จุดเครื่องหมายทวิภาคและเครื่องหมายวงเล็บ) ในระยะสั้นไวยากรณ์ของภาษา มันจะยากในตอนแรก แต่เมื่อเวลาผ่านไปคุณจะเริ่มเขียนตั้งแต่ต้นโดยไม่ผิดพลาด!

เมื่อสคริปต์พร้อมให้เลือกและกำหนดเสียงให้กับตัวแปรแต่ละตัวในหน้าต่างตัวตรวจสอบ ตอนนี้เราต้องใช้สคริปต์ของเรากับวัตถุในฉาก วิธีที่ง่ายที่สุดในการทำเช่นนี้อีกครั้งคือการลากสคริปต์ไปยังออบเจ็กต์เกมที่ต้องการโดยตรงในรายการลำดับชั้น:

หากสคริปต์ถูกลากและวางอย่างถูกต้องสคริปต์ควรปรากฏในหน้าต่างตัวตรวจสอบของวัตถุที่เราลากไป ดังนั้นเราลากสคริปต์ไปยังวัตถุทั้งหมดที่ควรจะเป็นเสียงในเกมและเราสามารถลองเปิดใช้งานได้ เมื่อคุณคลิกที่ปุ่มเกมของเราเสียงที่ตั้งไว้จะดังขึ้นในที่สุด!

รู้เบื้องต้นเกี่ยวกับ GUI

โดยหลักการแล้วเกมกำลังทำงานให้เราอยู่แล้ว แต่มันก็ "หัวล้าน" เกินไป มีบางอย่างหายไป ... และอย่างน้อยก็มีจารึกชื่อของสิ่งที่อยู่ตรงหน้าเรา! กล่าวอีกนัยหนึ่งคุณต้องใช้อินเทอร์เฟซผู้ใช้ที่เชื่อมโยงกัน

จริงๆแล้ว GUI นั้นย่อมาจากภาษาอังกฤษ "Graphical User Interface" ได้แก่ ส่วนติดต่อผู้ใช้แบบกราฟิก ตามเนื้อผ้าจะมีส่วนประกอบต่างๆเช่น:

• ปุ่ม;
• หน้าต่าง;
• พื้นที่ข้อความ
• ช่องทำเครื่องหมายและ / หรือปุ่มตัวเลือก
• แถบเลื่อน (แถบเลื่อน) ฯลฯ

ใน Unity 3D ทั้งหมดนี้ (และอื่น ๆ อีกมากมาย) มีอยู่อย่างสมบูรณ์ สิ่งสำคัญคือการเรียนรู้วิธีใช้! ลองพิจารณาวิธีการใช้ GUI ใน Unity คุณสามารถสร้างป้ายชื่อเรื่องง่ายๆ

ในการดำเนินการนี้ให้สร้างสคริปต์ใหม่ชื่ออินเทอร์เฟซและเปลี่ยนแปลงดังนี้:

มาดูสคริปต์ในภาพหน้าจอกันดีกว่า ที่นี่เราเขียนตัวแปรสาธารณะเพียงตัวเดียวของ GUIStyle ประเภทใหม่สำหรับเรา ประเภทนี้ช่วยให้คุณสามารถเปลี่ยนลักษณะที่ปรากฏขององค์ประกอบที่กำหนดลักษณะนี้ได้ สไตล์มีประโยชน์เมื่อมีองค์ประกอบอินเทอร์เฟซประเภทเดียวกันจำนวนมาก (เช่นปุ่ม) แต่ต้องมีรูปลักษณ์ที่แตกต่างกัน

จากนั้นเราจะสร้างปุ่ม ("GUI Button") ซึ่งมีไวยากรณ์ต่อไปนี้: เงื่อนไข - พิกัด 4 (ออฟเซ็ตแนวนอนจากขอบด้านซ้าย, ออฟเซ็ตแนวตั้งจากขอบด้านบน, ความกว้าง, ความสูง) - ข้อความที่มองเห็นได้ในเครื่องหมายคำพูดและอื่น ๆ ไม่บังคับ บ่งบอกสไตล์ ฟังก์ชันที่จำเป็นจะถูกเขียนขึ้นภายในเงื่อนไขปุ่ม ในกรณีของเราเราได้ลงทะเบียนการเปลี่ยนแปลงไปยังไซต์ของนักพัฒนา ("Application.OpenURL (" ");")

สคริปต์ GUI สามารถทำงานได้จากวัตถุในเกมใด ๆ แต่โดยปกติแล้วพวกเขาจะแนะนำให้ "แขวน" ไว้ที่กล้องซึ่งเราจะทำได้โดยการลากสคริปต์ไปที่วัตถุกล้องหลัก ตอนนี้ถ้าคุณเลือกในหน้าต่างลำดับชั้นจากนั้นในหน้าต่างตัวตรวจสอบเราจะสามารถเห็นตัวแปรสาธารณะของสไตล์ของเราซึ่งเราจะสามารถเข้าถึงการตั้งค่าของสไตล์นี้ได้อย่างเต็มที่!

เราสามารถระบุสีของข้อความและพื้นผิวสำหรับพื้นหลังได้ในทุกสถานการณ์ (สำหรับปุ่มคุณต้องลงทะเบียนตัวแปรสามแบบ (มุมมองปกติ - มุมมองปกติวางเมาส์เหนือและใช้งาน - เมื่อคลิก) ตั้งค่าการเยื้องและปรับแบบอักษรโดยค่าเริ่มต้นปุ่มเดียวที่มีใน Unity 3D แบบอักษรคือ Arial แต่คุณสามารถโหลดแบบอักษรอื่น ๆ ในโปรเจ็กต์ด้วยตนเองและนำไปใช้ในช่อง "แบบอักษร" โดยปรับพารามิเตอร์ที่มาพร้อมกันทั้งหมด

สิ่งที่น่าสนใจและในเวลาเดียวกันก็ไม่ค่อยสะดวกองค์ประกอบ GUI จะไม่แสดงบนพื้นที่งานจนกว่าเราจะเปิดตัวโครงการดังนั้นการปรับพารามิเตอร์ของแต่ละองค์ประกอบอาจใช้เวลามาก เริ่มโครงการกันเลยและดูว่าปุ่มของเราที่สร้างขึ้นด้านบนจะมีลักษณะอย่างไร:

การปรับเปลี่ยนอินเทอร์เฟซตามเงื่อนไขและตัวแปรคงที่

เราได้ทำหลายอย่างแล้ว แต่ยังมีช่องว่างสำหรับการปรับปรุงอยู่เสมอ :) ดังนั้นในตัวอย่างสุดท้ายฉันขอเสนอให้สร้างหน้าต่างวิธีใช้ซึ่งโดยปกตินักพัฒนาจะจัดหาเกมและแอปพลิเคชัน ในการดำเนินการนี้ให้เพิ่มรูปภาพสำหรับปุ่มดังกล่าวในรูปแบบของเครื่องหมายคำถามลงในโฟลเดอร์ที่มีรูปภาพและสร้างวัตถุในเกมออกมา มาแขวนคอลไลเดอร์แล้วเขียนสคริปต์ด้วยชื่อตัวอย่างเช่น "Help" โดยมีเนื้อหาต่อไปนี้:

ในสคริปต์นี้เรามีสองตัวแปร ตัวแปรแรกกำหนดสกินที่จะใช้สำหรับองค์ประกอบอินเทอร์เฟซทั้งหมดที่อธิบายไว้ในคลาสนี้ แตกต่างจากสไตล์ที่เรากล่าวถึงข้างต้นสกินช่วยให้คุณสามารถเปลี่ยนลักษณะที่ปรากฏไม่เพียง แต่ขององค์ประกอบเดียวที่กำหนดให้เท่านั้น แต่ยังรวมถึงองค์ประกอบทั้งหมดในบางประเภทพร้อมกัน นอกจากนี้สกินไม่ได้ถูกกำหนดให้กับองค์ประกอบต่างจากสไตล์ แต่จะประกาศสำหรับวิธีการทั้งหมดพร้อมกันและทำงานจนกว่าจะมีการประกาศสกินอื่น นอกจากนี้ควรจำไว้ว่าสกินมีอยู่ไม่เพียง แต่เป็นตัวแปรเท่านั้น แต่ยังเป็นไฟล์แยกต่างหาก ดังนั้นก่อนประกาศสกินคุณต้องสร้างสกินทันทีในหน้าต่าง "โปรเจ็กต์" จากเมนูบริบท: "สร้าง" - "GUI สกิน"

ตัวแปรที่สองคือบูลีน (หรืออีกนัยหนึ่งคือบูลีน) โดยสามารถมีได้สองค่าเท่านั้น: "จริง" (จริง) หรือ "เท็จ" (เท็จ) เนื่องจากลักษณะไบนารีตัวแปรดังกล่าวจึงเหมาะอย่างยิ่งสำหรับการใช้งานสวิตช์ทุกชนิด ในกรณีของเราจะต้องรับผิดชอบในการแสดงข้อความอธิบายเกมของเรา

อย่างไรก็ตามหากคุณมองอย่างใกล้ชิดคุณจะสังเกตเห็นว่าตัวแปรสุดท้ายมีพารามิเตอร์ที่ยอดเยี่ยมอยู่ตัวหนึ่งนั่นคือ "คงที่" การเพิ่มพารามิเตอร์ดังกล่าวให้กับตัวแปรช่วยให้คุณสามารถกำหนดให้เป็นแบบคงที่และเข้าถึงได้จากสคริปต์อื่น ๆ !

แต่กลับไปที่ส่วนที่เหลือของรหัส เมธอด "void OnMouseDown ()" ซึ่งคุ้นเคยกับเราอยู่แล้วที่นี่จะทำหน้าที่เป็นสวิตช์สำหรับตัวแปร "isVisible" โดยใช้เงื่อนไขง่ายๆ อย่างไรก็ตามมีอีกหนึ่งฟังก์ชันหลังจากเงื่อนไข ฟังก์ชันนี้ ("Debug.Log ();") ใช้เพื่อแสดง "ทันที" ในคอนโซลค่าของตัวแปรที่เราต้องการ (เราป้อนโดยไม่ใส่เครื่องหมายคำพูดในวงเล็บ) อย่างที่คุณเห็นภายในฟังก์ชันคุณสามารถรวมทั้งข้อความที่ไม่เปลี่ยนรูป (เขียนด้วยเครื่องหมายคำพูด) และตัวแปร (โดยไม่มีเครื่องหมายคำพูด) สิ่งสำคัญคือมีเครื่องหมาย "+" ระหว่างข้อมูลทั้งหมด

นอกจากนี้ในข้อความของสคริปต์เรามีวิธีการแสดงผลอินเทอร์เฟซ ("void OnGUI () ()") ซึ่งเราจะเห็นการประกาศสกินใหม่ ("GUI.skin \u003d HelpSkin;") และองค์ประกอบอินเทอร์เฟซใหม่ของประเภท GUI.Box ไม่เหมือนกับปุ่มคือกล่องเป็นองค์ประกอบที่ไม่ได้ใช้งานและโดยปกติจะใช้เพื่อแสดงข้อความหรือข้อมูลกราฟิกต่างๆ

สังเกตว่าเราวางตำแหน่งกล่องอย่างไร ที่นี่ไม่ได้ระบุค่าทั้งหมดโดยตรง แต่ใช้นิพจน์ทางคณิตศาสตร์ซึ่งในความเป็นจริงนั้นคล้ายคลึงกับ "เค้าโครงแบบไหล" ในการพัฒนาเว็บ ปัญหาคือเมื่อระบุขนาดที่แน่นอนขององค์ประกอบ GUI ที่ความละเอียดหน้าจอที่แตกต่างกันพวกเขาจะไม่ปรับตัวและอาจมีขนาดเล็กเกินไปหรือในทางกลับกันก็ใหญ่ ในเครื่องยนต์เวอร์ชันถัดไปผู้พัฒนาสัญญาว่าจะทำให้ GUI ตอบสนอง แต่จนถึงตอนนี้เราต้องบิดเบือน :(

ขั้นตอนสุดท้ายบนเส้นทางสู่ความสำเร็จคือการปรับแต่งผิวของเรา ระบุไฟล์สกินในตัวแปรสคริปต์จากนั้นเลือกไฟล์นี้ในหน้าต่างโปรเจ็กต์ เช่นเดียวกับไฟล์อื่น ๆ การตั้งค่าสกินจะแสดงในหน้าต่างตัวตรวจสอบ ที่นี่เรากำลังมองหาองค์ประกอบที่อาจมีการเปลี่ยนแปลง (ในกรณีของเราคือ Box) ขยายและกำหนดค่าให้คล้ายกับสไตล์ที่กล่าวไว้ข้างต้น:

หากต้องการดูว่าสคริปต์ของเราทำงานถูกต้องหรือไม่ให้เปิดโครงการและลองคลิกที่ปุ่มความช่วยเหลือ:

ตอนนี้ทุกอย่างใช้งานได้ แต่การกดปุ่มความช่วยเหลือเพื่อซ่อนคำอธิบายกลับไม่สะดวกเสมอไป เป็นเรื่องปกติมากขึ้นที่จะโผล่พื้นที่ว่างเพื่อให้การแจ้งเตือนหายไปมากกว่าการเล็งไปที่ปุ่ม และที่นี่เราต้องการความจริงที่ว่าเราสร้างตัวแปร "isVisible" แบบคงที่รวมถึง collider ที่แขวนอยู่บนภาพพื้นหลัง ...

กลับไปที่สคริปต์แรกของเรา ("เสียง") ซึ่งติดตามการคลิกปุ่มเพื่อเล่นเสียง ในนั้น (อย่างแม่นยำยิ่งขึ้นภายในเมธอด "void OnMouseDown ()") เราต้องเขียนเพียงบรรทัดเดียว:

ถ้า (this.name! \u003d "HelpButton") (Help.isVisible \u003d false;)

ด้วยบรรทัดนี้เรากำหนดเงื่อนไข: หากชื่อของ collider ที่กดไม่เท่ากับชื่อของปุ่มวิธีใช้ตัวแปร "isVisible" ในสคริปต์ "Help" จะเท่ากับ "false" คุณเพียงแค่ต้องการตัวแปร "isVisible" เพื่อให้มีคำลงท้าย "คงที่" มิฉะนั้นเราจะได้รับข้อผิดพลาด

ตอนนี้เมื่อเปิดตัวเราจะเห็นว่าหน้าต่างความช่วยเหลือของเราปิดลงเมื่อเราคลิกไม่เพียง แต่บนปุ่มที่มุมขวาบนเท่านั้น แต่ยังรวมถึงเมื่อเราแตะส่วนที่ว่างของหน้าจอด้วย สิ่งเดียวที่สามารถปรับปรุงได้คือทำให้หน้าต่างซ่อนและคลิกที่มัน ... นี่จะเป็นการ "ทำการบ้าน" ของคุณ) ฉันบอกได้แค่ว่าจะต้องเปลี่ยนกล่อง GUI เป็นปุ่มที่ออกแบบคล้ายกันอีกครั้งด้วยการตั้งค่า ผิวหนังและกำหนดฟังก์ชันที่เปลี่ยนแปลงตัวแปร "isVisible" แค่นั้นแหละฉันจะเงียบ :)

รวบรวมเกมและบันทึกโครงการ

ในที่สุดทุกอย่างก็เหมาะกับเรา! ซึ่งหมายความว่าถึงเวลาบันทึกเกมของเราและทดสอบบนอุปกรณ์จริง และในการดำเนินการนี้จะต้องรวบรวมเป็นไฟล์ปฏิบัติการ (สำหรับ Windows เช่นใน EXE และสำหรับ Android ใน APK)

หากคุณต้องการรวบรวมเกมสำหรับพีซีคุณไม่จำเป็นต้องทำการตั้งค่าเบื้องต้นใด ๆ อย่างไรก็ตามสำหรับ Android คุณจะต้องเชื่อมต่อ Android SDK ที่เราดาวน์โหลดมาในตอนต้นก่อน สิ่งนี้ทำได้ค่อนข้างง่าย: ไปที่เมนู "แก้ไข" เรียกรายการ "ค่ากำหนด" และในหน้าต่างที่เปิดขึ้นให้ไปที่แท็บ "เครื่องมือภายนอก" ที่นี่เรากำลังมองหาบรรทัด "ตำแหน่ง Android SDK" และในนั้นเราระบุเส้นทางไปยังที่เก็บถาวรที่ไม่ได้บรรจุด้วย SDK (ดูภาพหน้าจอด้านล่าง) อย่างไรก็ตามที่นี่คุณยังสามารถเปลี่ยนโปรแกรมแก้ไขข้อความ monstrous เริ่มต้นที่ใช้งานได้ MonoDevelop เป็นรายการโปรดของคุณ :)

และตอนนี้ความจริงก็มาถึงแล้ว! ไปที่เมนู "ไฟล์" และมองหารายการ "Build Settings" ในหน้าต่างที่เปิดขึ้นเราจะต้องเพิ่มฉากสำหรับการประกอบทันที หากมีเพียงฉากเดียว (เช่นเดียวกับในโครงการของเรา) ก็จะเพียงพอที่จะกดปุ่ม "เพิ่มปัจจุบัน" หากมีหลายรายการคุณจะต้องเปิดแต่ละฉากและเพิ่มลงในรายการฉากในลักษณะเดียวกันจากนั้นโดยการลากและวางให้กำหนดค่าลำดับที่ต้องการ:

ขั้นตอนต่อไปคือการเลือกแพลตฟอร์มการสร้าง (เรากำลังวางแผนเกมสำหรับ Android ซึ่งหมายความว่าเราเลือก) และกดปุ่ม "การตั้งค่าผู้เล่น" ด้านล่าง การตั้งค่าจำนวนมากจะเปิดขึ้นในหน้าต่างตัวตรวจสอบซึ่งบางส่วนจำเป็นหรือเป็นที่ต้องการมาก ขอแนะนำให้ระบุชื่อ บริษัท ผู้พัฒนาโปรแกรมและไอคอน (ชื่อ บริษัท ชื่อผลิตภัณฑ์และไอคอนเริ่มต้นตามลำดับ) ที่ด้านบนของรายการการตั้งค่า

ที่ด้านล่างในส่วน "การตั้งค่าอื่น ๆ " มีพารามิเตอร์ที่จำเป็น 2 รายการ ได้แก่ "Bundle Identifier" และ "Bundle Version" เวอร์ชันเริ่มต้นถูกตั้งค่าเป็น 1.0 แต่จะต้องสร้างตัวระบุด้วยตนเองและโดยเฉพาะอย่างยิ่งไม่ซ้ำกัน ควรประกอบด้วยสามส่วนโดยแยกออกจากกันตามช่วงเวลา ได้แก่ คำสงวน "com" ตามด้วยชื่อ บริษัท ผู้พัฒนาและต่อท้ายชื่อแอปพลิเคชัน

การตั้งค่าการประกอบที่เหลือสามารถเปลี่ยนแปลงได้ตามดุลยพินิจของคุณหรือไม่เปลี่ยนแปลงเลย สิ่งสำคัญคือตอนนี้การรวบรวมสามารถเริ่มต้นได้แล้ว ในการดำเนินการนี้เพียงคลิกปุ่ม "สร้าง" ในหน้าต่าง "การตั้งค่าการสร้าง" และรอจนกว่าโปรแกรมต่างๆจะมอบแอปพลิเคชันสำเร็จรูปให้เราบรรจุลงในไฟล์ APK :)

สรุป

นี่เป็นการสรุปการทบทวนบทเรียนของเราเกี่ยวกับการสร้างแอปพลิเคชันที่ง่ายที่สุดสำหรับ Android สิ้นสุดลงแล้ว เพื่อให้คุณสามารถทำซ้ำทุกสิ่งที่เราพูดถึงในตอนท้ายของบทความฉันจะให้ลิงก์ไปยังที่เก็บถาวรซึ่งจะจัดเก็บทรัพยากรทั้งหมดของเกมเป็นโฟลเดอร์แยกต่างหาก (หากคุณต้องการทำทุกอย่างตั้งแต่เริ่มต้น) และเป็นไฟล์ที่มีนามสกุล Unitypackage หลังช่วยให้คุณสามารถนำเข้าโครงการทั้งหมดไปยัง Unity ได้ในครั้งเดียวรวมถึงการอ้างอิง ฯลฯ

ในการนำเข้าโปรเจ็กต์ของเรา (และโดยวิธีการที่ปลั๊กอินที่ดาวน์โหลดจากอินเทอร์เน็ตหรือ Assets Store) คุณต้องไปที่เมนู "เนื้อหา" เลือกรายการ "นำเข้าแพ็กเกจ" และในนั้นเป็น "Custom Packege" จากนั้นระบุเส้นทางไปยังไฟล์ของเราและ คลิกปุ่ม "นำเข้า" อย่างไรก็ตามคุณสามารถสำรองข้อมูลทั้งหมดของโครงการของคุณด้วยการบันทึกในแพคเกจเอกภาพจากเมนูเดียวกัน ("สินทรัพย์") โดยคลิกที่รายการ "แพ็กเกจการส่งออก"

ชอบทุกอย่าง :) ในฐานะคนที่เชี่ยวชาญ Unity 3D ตั้งแต่เริ่มต้นในบทความฉันพยายามให้คำตอบสำหรับจำนวนคำถามสูงสุดและเน้นความแตกต่างหลักของการทำงานกับเอ็นจิ้นที่เกิดขึ้นในตอนแรก แต่บางทีสิ่งนี้อาจไม่เพียงพอสำหรับใครบางคนดังนั้นหากคุณมีคำถามใด ๆ คุณสามารถติดต่อฉันได้โดยตรงทางอีเมลหรือในฟอรัม: ฉันจะช่วยคุณให้มากที่สุด!

ขอให้ทุกท่านโชคดีและประสบความสำเร็จในการดำเนินโครงการทั้งหมด!

ป.ล. อนุญาตให้คัดลอกและอ้างอิงบทความนี้ได้อย่างอิสระโดยมีการระบุลิงก์ที่เปิดใช้งานไปยังแหล่งที่มาและการประพันธ์ของ Ruslan Tertyshny จะถูกเก็บรักษาไว้