คู่มือเริ่มต้นขั้นสูงสุดสำหรับการพัฒนาเกมด้วยความสามัคคี

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

ก่อนอื่นเล็กน้อยเกี่ยวกับฉัน: ฉันเป็นนักพัฒนาเอกภาพมือสมัครเล่นนักสร้างโมเดล 3 มิติและนักออกแบบกราฟิกที่ทำงานร่วมกับ Unity and Blender มานานกว่า 5 ปี ตอนนี้ฉันเป็นนักศึกษา Financial Maths ที่ University College Dublin และบางครั้งฉันก็ทำงานออกแบบกราฟิกอิสระการสร้างต้นแบบเว็บและการสร้างต้นแบบเกม

บทนำ

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

ทำไมต้อง Unity?

หากคุณต้องการทำเกม

มีตัวเลือกน้อยมากสำหรับการพัฒนาเกมอินดี้ สามตัวเลือกหลักหากคุณต้องการสร้างเกม ได้แก่ Unreal, Unity หรือ GameMaker

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

มีเกมที่ประสบความสำเร็จมากมายเช่น Escape from Tarkov (FPS), Monument Valley (Puzzler) และ This War of Mine (Strategy / Survival) ทั้งหมดนี้สร้างขึ้นใน Unity

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

หากคุณต้องการสร้างต้นแบบประสบการณ์ผู้ใช้

เนื่องจากเอกภาพเป็นเพียงเครื่องมือที่มีฟิสิกส์แอนิเมชั่นและการเรนเดอร์ 3 มิติแบบเรียลไทม์จึงเป็นพื้นที่ที่ดีในการสร้างต้นแบบเชิงโต้ตอบที่สมบูรณ์สำหรับการศึกษา UX

Unity รองรับ VR และ AR เต็มรูปแบบและด้วยเหตุนี้จึงอาจเป็นเครื่องมือที่ยอดเยี่ยมสำหรับการสำรวจสถาปัตยกรรมระบบอัตโนมัติและการจำลองกับลูกค้า

ส่วนของบทความนี้

  • ทำไมต้อง Unity?
  • หน้าต่าง Unity Editor
  • Unity Game Objects
  • ส่วนประกอบ Unity Builtin
  • การสร้างส่วนประกอบที่กำหนดเอง
  • โครงสร้างของ MonoBehaviour
  • การจัดการ GameObjects
  • เรย์คาสติ้ง
  • การตรวจจับการชน
  • คุณสมบัติขั้นสูง
  • คำแนะนำสำหรับผู้มาใหม่
  • ทรัพยากรและชุมชนที่ดี
  • สรุป

หน้าต่างตัวแก้ไข Unity

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

มุมมองฉาก:อนุญาตให้จัดวางและเคลื่อนไหวของ GameObjects ใน Scene Game View: ดูตัวอย่างว่าผู้เล่นจะเห็นฉากจากตัวตรวจสอบกล้องอย่างไร:ให้รายละเอียดเกี่ยวกับ GameObject ที่เลือกในฉาก เนื้อหา / โครงการ: รูปแบบสำเร็จรูปพื้นผิวโมเดลสคริปต์และอื่น ๆ ทั้งหมดจะถูกเก็บไว้ที่นี่ลำดับชั้น:เปิดใช้งานการซ้อนและการจัดโครงสร้างของ GameObjects ภายในฉาก

ตอนนี้เราพร้อมที่จะเริ่มแล้ว!

Unity Game Objects

GameObjects คืออะไร

GameObjects เป็นส่วนประกอบหลักของทุกสิ่งในเอ็นจิ้นเกม Unity ชื่อเกือบจะทำให้มันหายไป:

สิ่งใดก็ตามที่คุณวางไว้ในฉากใน Unity จะต้องห่อด้วย 'วัตถุเกม'

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

แท้จริงทุกอย่างตั้งแต่เอฟเฟกต์อนุภาคกล้องผู้เล่นองค์ประกอบ UI ... (รายการต่อไป) เป็น GameObject

การสร้างลำดับชั้น

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

ตรรกะเบื้องหลังการซ้อนออบเจ็กต์ของเกมนั้นเหมือนกับการพัฒนาเว็บฉันจะให้ตัวอย่างบางส่วน ...

ความยุ่งเหยิงและประสิทธิภาพ

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

การวางตำแหน่ง

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

ส่วนประกอบ Unity Builtin

โมเดลส่วนประกอบของนักแสดง

GameObjects ด้วยตัวมันเองนั้นค่อนข้างไร้ประโยชน์อย่างที่เราเห็นว่ามันเป็นแค่คอนเทนเนอร์เท่านั้น ในการเพิ่มฟังก์ชันการทำงานเราต้องเพิ่มส่วนประกอบซึ่งโดยพื้นฐานแล้วสคริปต์ที่เขียนด้วยภาษา C # หรือ Javascript

Unity ทำงานจากโมเดล Actor Component โดยใส่เพียงว่า GameObjects เป็นตัวแสดงและส่วนประกอบคือสคริปต์ของคุณ

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

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

ส่วนประกอบในตัวที่สำคัญ

ฉันคิดว่าถึงเวลาแล้วสำหรับตัวอย่างบางส่วนของส่วนประกอบที่สร้างขึ้นโดยเอนจิน Unity Games

  • MeshFilter:ช่วยให้คุณกำหนดวัสดุให้กับตาข่าย 3 มิติให้กับ GameObject
  • MeshRender:ให้คุณกำหนดวัสดุให้กับ 3D Mesh
  • [กล่อง | Mesh] Collider:เปิดใช้งานการตรวจจับ GameObject ระหว่างการชน
  • Rigidbody:เปิดใช้งานการจำลองทางฟิสิกส์ที่สมจริงเพื่อดำเนินการกับ GameObjects ด้วยตาข่าย 3 มิติและจะเป็นเหตุการณ์การตรวจจับทริกเกอร์บนกล่อง colliders
  • แสง:ส่องสว่างบางส่วนของฉากของคุณ
  • กล้อง:กำหนดวิวพอร์ตของผู้เล่นที่จะเชื่อมต่อกับ GameObject
  • ส่วนประกอบ UI Canvas ต่างๆสำหรับการแสดง GUI

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

การสร้างส่วนประกอบที่กำหนดเอง

ส่วนประกอบในตัวจะควบคุมฟิสิกส์และภาพเป็นหลัก แต่ในการสร้างเกมจริงๆคุณจะต้องยอมรับการป้อนข้อมูลของผู้ใช้และจัดการกับส่วนประกอบมาตรฐานเหล่านั้นรวมถึง GameObjects ด้วยตัวเอง

ในการเริ่มสร้างส่วนประกอบให้ไปที่ GameObject> Add Component> พิมพ์ชื่อส่วนประกอบใหม่ของคุณในแถบค้นหา> สคริปต์ใหม่ (c #)

ตามคำแนะนำทั่วไปฉันไม่แนะนำให้ใช้ Javascript ใน Unity มันไม่ได้รับการอัปเดตกับสิ่งดีๆทั้งหมดที่มาพร้อมกับ ES6 และสิ่งที่ก้าวหน้ากว่านั้นส่วนใหญ่อาศัยสิ่ง C # ที่ส่งต่อไปยัง Javascript ... มันกลายเป็นวิธีแก้ปัญหาที่ยิ่งใหญ่ในประสบการณ์ของฉัน

โครงสร้างของ MonoBehaviour

ฟังก์ชั่นที่สำคัญ

ส่วนประกอบทั้งหมดสืบทอดมาจากคลาส MonoBehaviour รวมถึงวิธีการมาตรฐานหลายอย่างที่สำคัญที่สุด:

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

ตัวแปรตัวตรวจสอบ

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

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

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

ยอมรับการป้อนข้อมูลของผู้ใช้

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

  • Input.GetKey (KeyCode.W) ส่งคืนคีย์ True W ถูกกดค้างไว้
  • Input.GetKeyDown (KeyCode.W) คืนค่า True เมื่อกดปุ่ม W ครั้งแรก
  • Input.GetAxis (“ แนวตั้ง”), Input.GetAxis (“ แนวนอน”) ส่งกลับระหว่างการเคลื่อนไหวของอินพุตเมาส์ -1,1

การจัดการ GameObjects

เมื่อเราป้อนข้อมูลผู้ใช้แล้วเราต้องการให้ GameObjects ภายในฉากของเราตอบสนอง มีคำตอบหลายประเภทที่เราอาจพิจารณา:

  • การแปลการหมุนมาตราส่วน
  • สร้าง GameObjects ใหม่
  • การส่งข้อความไปยัง GameObjects / Components ที่มีอยู่

การเปลี่ยนแปลง

GameObjects ทั้งหมดมีคุณสมบัติการแปลงซึ่งเปิดใช้งานการปรับแต่งที่มีประโยชน์ต่างๆในออบเจ็กต์เกมปัจจุบันที่จะดำเนินการ

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

โดยทั่วไปเป็นแนวทางปฏิบัติที่ดีในการใช้[ตำแหน่งการหมุน] ในพื้นที่แทนที่จะใช้ตำแหน่งบนโลก / การหมุนของวัตถุ โดยปกติจะทำให้ง่ายต่อการเคลื่อนย้ายวัตถุในลักษณะที่เหมาะสมเนื่องจากแกนอวกาศในพื้นที่จะวางแนวและอยู่กึ่งกลางบนวัตถุแม่แทนที่จะเป็นจุดเริ่มต้นของโลกและทิศทาง x, y, z

หากคุณต้องการแปลงระหว่างพื้นที่ในท้องถิ่นและโลก (ซึ่งมักจะเป็นเช่นนั้น) คุณสามารถใช้สิ่งต่อไปนี้:

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

การสร้าง GameObjects ใหม่

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

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

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

เมื่อเรามีส่วนประกอบสำเร็จรูปเหล่านี้แล้วเราสามารถกำหนดให้กับตัวแปรตัวตรวจสอบ (ดังที่เราได้พูดถึงก่อนหน้านี้) บนส่วนประกอบใด ๆ ในฉากเพื่อให้เราสามารถสร้าง GameObjects ใหม่ตามที่ prefab ระบุได้ตลอดเวลา

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

การเข้าถึง GameObjects และส่วนประกอบอื่น ๆ

บ่อยครั้งที่เราจำเป็นต้องสื่อสารกับ GameObjects อื่น ๆ รวมทั้งส่วนประกอบที่เกี่ยวข้อง เมื่อคุณมีการอ้างอิงถึงออบเจ็กต์เกมมันค่อนข้างง่าย

คอมโพเนนต์ชื่อคอมพ์ = some_game_object.GetComponent ();

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

เข้าถึงผ่านตัวแปรตัวตรวจสอบ

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

เข้าถึงผ่านการติดแท็ก

เราสามารถติดแท็ก GameObjects หรือ prefabs ผ่านตัวตรวจสอบจากนั้นใช้ฟังก์ชัน find game object เพื่อค้นหาการอ้างอิงถึง

ทำได้ง่ายๆดังนี้

GameObject some_game_object = GameObject.FindGameObjectWithTag ("อิฐ");

เข้าถึงผ่านการแปลง

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

คอมโพเนนต์ชื่อคอมพ์ = gameObject.transform.parent.GetComponent ();

เข้าถึงผ่าน SendMessage

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

gameObject.SendMessage (“ MethodName”, params); // ออกอากาศ messagegameObject.SendMessageUpwards (“ MethodName”, params); // รับเฉพาะส่วนประกอบที่ซ้อนกันด้านบน

เรย์คาสติ้ง

คุณอาจเคยได้ยินเรื่องนี้มาก่อนเมื่อมีคนเปรียบเทียบเกม FPS ที่ 'อิงตามฟิสิกส์' หรือ 'อิงเรย์' โดยพื้นฐานแล้ว Raycasting ก็เหมือนกับการมีตัวชี้เลเซอร์ซึ่งเมื่อสัมผัสกับ 'collider' หรือ 'rigidbody' มันจะส่งกลับค่า 'hit' และส่งกลับรายละเอียดของวัตถุ

มีสองสถานการณ์ที่มีประโยชน์ (อาจมีอีกมาก):

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

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

การตรวจจับการชน

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

เมื่อตั้งค่าภายในส่วนประกอบที่กำหนดเองใด ๆ ที่แนบมากับวัตถุเราสามารถใช้เมธอด OnCollisionEnter, OnCollisionStay และ OnCollisionExit เพื่อตอบสนองต่อการชนกัน เมื่อเรามีข้อมูลการชนกันแล้วเราจะให้ GameObject รับผิดชอบและใช้สิ่งที่เราเรียนรู้มาก่อนหน้านี้เพื่อโต้ตอบกับส่วนประกอบที่แนบมาด้วย

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

คุณสมบัติขั้นสูง

เราจะไม่พูดถึงเรื่องนี้ในตอนนี้ แต่อาจจะเป็นบทความในอนาคต - เพียงเพื่อให้คุณทราบว่ามีอยู่จริง

การสร้าง GUI

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

การขยาย Unity Editor

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

ภาพเคลื่อนไหว

Unity มีระบบแอนิเมชั่นที่ใช้กราฟซึ่งช่วยให้คุณสามารถผสมผสานและควบคุมภาพเคลื่อนไหวบนวัตถุต่างๆเช่นผู้เล่นใช้ระบบแอนิเมชั่นที่ใช้กระดูก

วัสดุและ PBR

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

คำแนะนำสำหรับผู้มาใหม่

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

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

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

ทรัพยากรและชุมชนที่ดี

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

แนวคิดศิลปะ

  • Feng Zhu Design School (บทเรียนศิลปะแนวคิดยาวกว่า 90 ชั่วโมง)
  • Tyler Edlin Art (ชุมชนศิลปะ BST ที่ยอดเยี่ยมพร้อมข้อเสนอแนะจากผู้เชี่ยวชาญเกี่ยวกับความท้าทายรายเดือน)
  • Art Cafe (สัมภาษณ์และเวิร์คช็อปกับ Concept Artists ชื่อดัง)
  • Trent Kaniuga (นักวาดภาพประกอบและศิลปิน 2D ที่กำลังสร้างเกมของตัวเองด้วย)

การสร้างแบบจำลอง 3 มิติ

  • CG Cookie (พื้นฐานการสร้างแบบจำลองตาข่ายที่ดีที่สุดใน Blender เคยมีเนื้อหาที่ยอดเยี่ยมอื่น ๆ มากมายสำหรับเครื่องปั่น)
  • Tor Frick (ผู้สร้างแบบจำลองพื้นผิวแข็งและช่างแกะสลักในเครื่องปั่น)
  • Gleb Alexandrov (บทช่วยสอนการเรนเดอร์ที่มีประสิทธิภาพสั้น ๆ ใน Blender)

การออกแบบเกม

  • DoubleFine Amnesia Fortnight (GameDevs ที่ทำ Hackathon 2 สัปดาห์และบันทึกกระบวนการออกแบบทั้งหมด)
  • GameMakers Toolkit (ตรวจสอบหลักการออกแบบเกม)

การเขียนโปรแกรม

  • แฮนด์เมดฮีโร่ (การเขียนเกมและเอนจิ้นตั้งแต่เริ่มต้นในภาษา C)
  • Jonathan Blow (นักพัฒนาอินดี้ที่ถ่ายทอดสดการพัฒนาเกมของเขา)
  • Brackeys (บทเรียนความสามัคคีที่ดี)

สรุป

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

แฟ้มสะสมผลงาน| LinkedIn