การสร้างแอพพลิเคชั่นสำหรับ Android การใช้ Unity ในการพัฒนาแอพพลิเคชั่น การสร้างเกม 3D สำหรับ Android

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

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

1. โมเดลวัตถุ
2. ข้อกำหนดด้านการทำงาน
3. เนื้อหาเกม
4. อินเตอร์เฟซ.

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

แบบจำลองวัตถุ

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

ข้อมูลจำเพาะด้านการทำงาน

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

เนื้อหาของเกม

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

อินเตอร์เฟซ

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

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

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

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

ยูดีเค

แรงบิด 2d/3d

นักออกแบบเกมคืออะไร?

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

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

บทสรุป

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

วีดีโอ

หากต้องการเรียนรู้เพิ่มเติมเกี่ยวกับกระบวนการสร้างเกม Android โปรดดูชุดวิดีโอสำหรับกิจกรรมนี้โดยเฉพาะ

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

จะสร้างเกมใน Unity ได้อย่างไร?

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

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

แพลตฟอร์มที่รองรับ

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

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

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

จะพัฒนาเกมบนเอ็นจิ้นได้อย่างไรและที่ไหน?

เราสามารถดำเนินการพัฒนาเกมอันยาวนานได้ทั้งภายใน Windows และ Mac OS X มีตัวแก้ไขเวอร์ชันสำหรับ Linux อยู่แล้ว แต่เรายังไม่สามารถไว้วางใจการทำงานที่เสถียรได้ นักพัฒนาใช้เวลาส่วนใหญ่ในการสร้างเกมภายในโปรแกรมแก้ไข Unity นอกจากนี้เรายังต้องใช้เวลามากในการเขียนโค้ดสคริปต์ เราสามารถสร้างมันขึ้นมาใน MonoDevelop มาตรฐานหรือในโปรแกรมแก้ไขของบุคคลที่สาม ทุกวันนี้พวกเขาใช้ Visual Studio เช่นเดียวกับ Sublime Text แต่มีการกำหนดค่าที่เหมาะสมเท่านั้น

สวัสดีทุกคน! เมื่อได้เรียนรู้วิธีสร้างเกมบนเอนจิ้นนี้แล้ว ฉันก็อยากจะสอนคุณเหมือนกัน ประการแรก เราต้องการ Unity3d ตัวแก้ไขโมเดล 3 มิติ และแขนตรงที่ยื่นออกมาจากไหล่

1. ศึกษาโปรแกรม

ดูภาพหน้าจอด้านบน:

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

ตอนนี้คุณเห็นเมนูออบเจ็กต์ที่คุณสามารถเพิ่มภาพเคลื่อนไหว สคริปต์ และอื่นๆ ได้

ฉันคิดว่าคุณจะไม่มีปัญหากับเมนูนี้
หากต้องการสร้างวัตถุใด ๆ ให้คลิก

โดยทั่วไปเราได้ศึกษาโปรแกรมไว้แล้ว อีกไม่นาน เราก็จะสามารถเขียนเกมของเราเองได้

2.สร้างเกมง่ายๆ

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

หากต้องการเพิ่มเพลง ให้ลากไปยังวัตถุที่ต้องการ
เกมพร้อมแล้ว แต่จะคอมไพล์ยังไงล่ะ?

หากต้องการทำสิ่งนี้ ให้ไปที่การตั้งค่า File-Build-การตั้งค่าเครื่องเล่น (สำหรับทางลัดและชื่อ) เลือกแพลตฟอร์มและ voila คุณทำเสร็จแล้ว ในการดำเนินการนี้ คุณจะต้องติดตั้ง Android SDK แต่คุณต้องระบุโฟลเดอร์ด้วย SDK และคุณไม่จำเป็นต้องมีเพียงแค่ SDK แต่ต้องมี API ในระดับที่ต้องการ (เช่นสำหรับ Android 4.2 - API 17) ตัวอย่างเช่น เพื่อให้เกมใช้ Android 4.0 ขึ้นไป คุณจะต้องติดตั้ง API เหล่านี้

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

ยอดดูโพสต์: 19,374

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

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

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

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

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

ขั้นตอนที่ 1: ติดตั้ง Unity

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

ขั้นตอนที่ 4: ตั้งค่าเครื่องมือ Android

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

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

• ชุดพัฒนาจาวา (JDK)คุณสามารถดาวน์โหลดได้จากเว็บไซต์ Java ตามลิงค์คุณจะเห็นที่ด้านบนสุด แพลตฟอร์มจาวา (JDK), คลิกที่ ดาวน์โหลดข้างคำบรรยาย จากนั้นเลือกคำบรรยายของคุณ ระบบปฏิบัติการและเริ่มดาวน์โหลด หลังจากนั้น เพียงทำตามคำแนะนำของโปรแกรมติดตั้ง
• ระบบปฏิบัติการ Android. ที่สุด ด้วยวิธีง่ายๆหากต้องการติดตั้งเวอร์ชันปัจจุบันให้ดาวน์โหลด Android Studio ซึ่งมี SDK นี้มาด้วย โดยไปที่เว็บไซต์ Android Studio แล้วคลิก ดาวน์โหลด แอนดรอยด์ สตูดิโอ. ตัวติดตั้ง Android Studio จะติดตั้งส่วนประกอบ Android SDK พื้นฐานที่จำเป็นสำหรับการพัฒนา Android

ขั้นตอนที่ 5. เตรียมโครงการเพื่อเปิดตัว

ขั้นแรก คุณต้องเปลี่ยนแพลตฟอร์มการพัฒนาเป็น Android หากต้องการทำสิ่งนี้ใน Unity ให้เปิดเมนูไฟล์แล้วเลือกการตั้งค่าบิวด์

ในหน้าต่างที่ปรากฏขึ้น คุณต้องเลือก หุ่นยนต์แล้วกด สลับแพลตฟอร์ม.

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

ตอนนี้เราจำเป็นต้องระบุชื่อแพ็คเกจสำหรับแอปพลิเคชัน

บันทึก:ชื่อแพ็กเกจคือตัวระบุเฉพาะของแอปพลิเคชัน และเขียนในรูปแบบ DNS แบบย้อนกลับในรูปแบบ com.CompanyName.ProductName. หลังจากเผยแพร่ใบสมัครไปที่ Google Playชื่อแพ็คเกจไม่สามารถเปลี่ยนแปลงได้อีกต่อไป

โดยไปที่เมนู แก้ไขและเลือก การตั้งค่าโครงการ - ผู้เล่น.

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

ตอนนี้สิ่งที่เหลืออยู่คือการระบุเส้นทางไปยัง Android SDK และ JDK โดยไปที่เมนูแล้วเลือก แก้ไข - การตั้งค่า.

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

ขั้นตอนที่ 6 สร้างและเรียกใช้แอปพลิเคชัน

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

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

บันทึก:บน ช่วงเวลานี้หากคุณมีเวอร์ชันอัลฟ่าติดตั้งอยู่ใน Android SDK สร้างเครื่องมือ(เวอร์ชั่น 28.0.0-rc1) Gradle จะเกิดข้อผิดพลาดขณะสร้าง หากต้องการแก้ไขปัญหานี้ เพียงลบเวอร์ชันนี้ออกจาก Android SDK

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

มาดูกันว่ามีอะไรอยู่ใน APK ที่ประกอบกัน ในการทำเช่นนี้เราจะใช้ยูทิลิตี้นี้ ตัววิเคราะห์ APKซึ่งรวมอยู่ใน Android Studio

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

อีกอย่างถ้าดูที่ AndroidManifest.xmlการสมัครประกอบด้วยหนึ่งกิจกรรม

บทสรุป

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

จะสร้างเกมหรือแอพพลิเคชั่นง่ายๆ สำหรับ Android ได้อย่างรวดเร็วและค่อนข้างง่ายดายได้อย่างไร? อ่านเกี่ยวกับสิ่งนี้ในบทความด้านล่าง ซึ่งกล่าวถึงการทำงานกับเอนจิ้น Unity3D

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

เครื่องยนต์คืออะไรและทำไมจึงจำเป็น?

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

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

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

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

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

เริ่มต้นใช้งานโปรเจ็กต์ใน Unity3D

แล้วทำไมเราถึงตัดสินใจใช้ Unity3D:

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

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

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

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

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

เมื่อสร้างโปรเจ็กต์แล้ว มันจะถูกโหลดลงในพื้นที่ทำงาน Unity3D:

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

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

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

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

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

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

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

หลังจากที่รูปภาพปรากฏในโฟลเดอร์รูปภาพของเราแล้ว ควรกำหนดค่ารูปภาพเหล่านั้นเล็กน้อย:

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

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

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

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

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

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

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

ทำงานด้วยเสียง

ด้วยเสียงใน Unity 3D เมื่อมองแวบแรก ทุกอย่างค่อนข้างสับสน แต่ลองคิดดูตามลำดับ :)

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

หากปรับระดับเสียงของเสียงทั้งหมดในตอนแรก สิ่งที่คุณต้องทำก็แค่ปิดการประมวลผลเสียง 3D ในเกม 3D การประมวลผลนี้จำเป็นเพื่อจำลองแหล่งกำเนิดเสียงที่เข้ามาใกล้เมื่อกล้องเข้าใกล้ แต่ในแบบ 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/UnityManualRestructed.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#" ลองเรียกสคริปต์ใหม่ของเรา เช่น เสียง แล้วเปิดด้วยการดับเบิลคลิก ด้วยการลบวิธีการอัปเดตและเริ่มต้นมาตรฐานแล้วระบุวิธีที่จำเป็นเราจะได้รับสคริปต์ประเภทต่อไปนี้:

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

ที่จริงแล้ว สคริปต์ C# ทุกตัวประกอบด้วยสามส่วนหลัก:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

รวบรวมเกมและบันทึกโปรเจ็กต์

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

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

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

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

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

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

บทสรุป

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

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

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

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

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