การสร้างเกม 3 มิติสำหรับความสามัคคีของ Android การสร้างเกมบน Android นักออกแบบเกมคืออะไร

การพัฒนาเกมสำหรับอุปกรณ์ Android OS ต้องใช้แนวทางที่คล้ายกับการพัฒนาสำหรับ iOS ในทางกลับกัน ฮาร์ดแวร์ของอุปกรณ์ Android ไม่ได้อยู่ภายใต้มาตรฐานที่ชัดเจน ซึ่งทำให้จำเป็นต้องแก้ไขปัญหาที่ขาดหายไปเมื่อทำงานกับ iOS นอกจากนี้ยังมีความแตกต่างระหว่าง Unity เวอร์ชัน Android และ iOS

การเตรียมสภาพแวดล้อมการพัฒนา Android

ก่อนที่คุณจะสามารถทดสอบเกมของคุณบนอุปกรณ์ คุณจะต้องเตรียมสภาพแวดล้อมการพัฒนาของคุณ โดยเฉพาะอย่างยิ่ง ให้ดาวน์โหลดและติดตั้ง Android SDK ของแพลตฟอร์มที่ต้องการ และเพิ่มอุปกรณ์ของคุณลงในระบบ (กระบวนการนี้จะต่างกันสำหรับ Windows และ Mac) มีเขียนรายละเอียดไว้บนเว็บไซต์ Android Developers รวมถึง ข้อมูลเพิ่มเติมผู้ผลิตอุปกรณ์ของคุณอาจจัดหาให้ เนื่องจากเป็นกระบวนการที่ค่อนข้างซับซ้อน เราจึงได้เตรียมคำแนะนำเล็กๆ น้อยๆ ที่จะช่วยให้คุณเตรียมทุกสิ่งที่จำเป็นสำหรับการพัฒนา หากต้องการข้อมูลเพิ่มเติม คุณสามารถรับได้จากพอร์ทัลนักพัฒนาซอฟต์แวร์ 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 บิตจะเป็นตัวเลือกที่ดีที่สุดในแง่ของคุณภาพ ขนาด และความเร็วในการเรนเดอร์ซึ่งจำเป็นต้องใช้อัลฟาแชนเนล

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

ผลิตภัณฑ์สำเร็จรูปที่สร้างใน Unity 3D เข้ากันได้กับแพลตฟอร์มยอดนิยมเกือบทั้งหมด - ตั้งแต่ โทรศัพท์มือถือและปิดท้ายด้วยสมาร์ททีวี

คุณสมบัติของโปรแกรม:

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

หลักการทำงาน

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

นอกจากเวอร์ชันฟรีแล้ว คุณยังสามารถสมัครรับเวอร์ชันขั้นสูงอีกสองเวอร์ชัน:

Unity Plus (~ $25 ต่อเดือน) - ให้การเข้าถึงบริการ Customer Success Advisor อย่างจำกัด รวบรวมข้อมูลเกี่ยวกับความล้มเหลวในอุปกรณ์ของผู้ใช้ ตรวจสอบคำติชม

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

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

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

ควรสังเกตว่าในการทำงานกับกราฟิก 3D คุณต้องมีคอมพิวเตอร์ที่ทันสมัยพร้อมการ์ดวิดีโอฮาร์ดแวร์

ข้อดี:

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

ข้อเสีย:

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

คุณสามารถดาวน์โหลด Unity 3D ไม่เพียงแต่เพื่อเตรียมคู่แข่งให้พร้อมสำหรับของเล่นออนไลน์ยอดนิยม Juggernaut (ซึ่งถูกวาดด้วยเครื่องมือของฮีโร่ในรีวิวของเรา) แต่ยังสร้างงานนำเสนอ 3 มิติสุดเก๋อีกด้วย ปล่อยให้ใช้เวลานานขึ้นเล็กน้อย แต่รับประกันเอฟเฟกต์ว้าวสำหรับผู้ชม

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

แอนะล็อก:

  • บรรณาธิการเกม- แอพฟรีเพื่อสร้างเกม
  • Construct 2 เป็นตัวสร้างเกมยอดนิยมที่มีอินเทอร์เฟซที่เรียบง่าย
  • Construct 2 เป็นโปรแกรมที่ทรงพลังสำหรับการสร้างโปรเจ็กต์ 2D

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

1. การเรียนรู้โปรแกรม

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

พิจารณาภาพหน้าจอด้านบน:

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


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

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

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

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

ขั้นแรก ให้สร้างอาณาเขต Create-Terrain เพิ่มหญ้าและต้นไม้ เมื่อคลิกที่พื้นดินทางด้านขวา หน้าต่างจะปรากฏขึ้น เลือกต้นไม้ หญ้า


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


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

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

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

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

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

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

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

โมเดลวัตถุ

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

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

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

เนื้อหาเกม

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

อินเตอร์เฟซ

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

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

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

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

UDK

แรงบิด 2d/3d

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

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

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

บทสรุป

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

วีดีโอ

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

จะสร้างเกมหรือแอพพลิเคชั่นสำหรับ 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. หน้าต่างป้ายชื่อสินทรัพย์คือส่วนล่างของหน้าต่างตัวตรวจสอบ ซึ่งแสดงตัวอย่างวัตถุหรือไฟล์ที่เลือกในหน้าต่างโครงการ

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

สคริปต์แรก

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

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

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

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

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

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

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

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

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

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

บทนำสู่ GUI

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

if (this.name != "HelpButton")(Help.isVisible = false;)

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

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

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

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

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

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

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

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

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

บทสรุป

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

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

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

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

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

กระทู้ที่คล้ายกัน