การเขียนโปรแกรมเกมด้วยความสามัคคี: คู่มือสำหรับผู้เริ่มต้น

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

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

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

---

---

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

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

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

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

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

---

---

§1–เวอร์ชันของ Unity

§2–การติดตั้ง Unity

---

---

§3–บทนำสั้นๆ เกี่ยวกับกระบวนทัศน์เชิงวัตถุ

§4–ข้อมูลพื้นฐานเกี่ยวกับความสามัคคี

§5–ตัวอย่าง: องค์ประกอบพื้นฐานของเกม

§6–การเขียนสคริปต์ใน Unity

§7–ตัวอย่าง: การเขียนสคริปต์ Pong

§8–สำรวจเอกสาร / เรียนรู้เพิ่มเติม

§9–การสร้างเกมของคุณ / การคอมไพล์ไปยังแอปพลิเคชันแบบสแตนด์อโลน

§10-บันทึกย่อ

1. เวอร์ชันของ Unity

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

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

1.1 ราคา

แน่นอนว่า Unity เวอร์ชันฟรีนั้นฟรี อย่างไรก็ตาม มีข้อ จำกัด บางประการ: Unity เวอร์ชันฟรีไม่สามารถออกใบอนุญาตให้กับ บริษัท ใด ๆ ที่มีรายได้ต่อปีมากกว่า $ 100,000 . แม้ว่าองค์กรดังกล่าวจะอยู่นอกเหนือขอบเขตของคู่มือนี้ หากคุณสงสัยว่าคุณอาจกลายเป็นองค์กรดังกล่าว ก็ควรที่จะปรับใช้เวอร์ชัน Pro

Unity เวอร์ชัน Pro คือ $ 75 เดือนหรือ $ 1500 สำหรับใบอนุญาตถาวร และไม่มีข้อจำกัดเกี่ยวกับสิ่งที่คุณสามารถทำได้กับเกมที่สร้างขึ้นด้วย นอกจากนี้ยังมีการทดลองใช้ฟรี 30 วัน ซึ่งเราจะใช้สำหรับคู่มือนี้ เพื่อให้คุณเห็นภาพรวมที่สมบูรณ์ของคุณสมบัติที่มีให้มากที่สุด ใบอนุญาตนักเรียนหนึ่งปียังมีให้ผ่าน ศึกษา สำหรับ $ 129 .

1.2 คุณสมบัติ

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

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

2. การติดตั้ง Unity

Unity ติดตั้งง่าย คุณสามารถดาวน์โหลดไฟล์ปฏิบัติการได้จาก unity3d.com/get-unity/download .

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

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

วิธีแปลง Kindle book เป็น pdf

3. บทนำโดยสังเขปเกี่ยวกับกระบวนทัศน์เชิงวัตถุ

ก่อนเริ่มต้นใช้งาน Unity เราต้องทบทวนพื้นฐานเล็กน้อยก่อน สามัคคีสนับสนุนทั้งคู่ ค # และ JavaScript สำหรับ การเขียนโปรแกรมเกม ; เราจะทำงานกับ C# สำหรับบทช่วยสอนนี้

ก่อนอื่น หากคุณไม่เคยตั้งโปรแกรมมาก่อน ให้เลิกใช้บทช่วยสอนนี้และใช้เวลาสองสามวันทำงานผ่าน Microsoft's C # ภาษารองพื้น จนกว่าคุณจะรู้สึกสบายใจกับการใช้ภาษาสำหรับงานง่ายๆ

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

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

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

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

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

การแนบสคริปต์ใหม่เข้ากับวัตถุมีลักษณะดังนี้:

อันดับแรก, เลือกวัตถุ และไปที่ สารวัตร . คลิกที่ เพิ่มส่วนประกอบ ปุ่ม.

ไปที่ สคริปต์ใหม่ ป้อนชื่อที่คุณต้องการแล้วคลิก สร้างและเพิ่ม .

ตอนนี้คุณมีสคริปต์ใหม่ที่คุณสามารถแก้ไขได้โดยดับเบิลคลิกที่มัน!

ไฟล์คลาสมีลักษณะดังนี้:

using UnityEngine;
public class Mook : MonoBehaviour {
private float health;
void Start () {
health = 100;
}
void Update(){
if (health > 0) {
/* Search for player
if you encounter the player on the road, kill him
if you get shot, remove a random amount of health */
}
}
}

มาทำลายสิ่งนี้กันเถอะ:

• ใช้ UnityEngine: บรรทัดนี้บอก C# ว่าเราต้องการใช้ไลบรารีของ Unity ซึ่งช่วยให้เราเชื่อมต่อกับเอ็นจิ้นเกม Unity ได้
• หมู่มหาชน มุก : MonoBehavior: บรรทัดนี้ประกาศคลาสและชื่อ -- มุก .
• สุขภาพลอยส่วนตัว: นี่เป็นการประกาศตัวแปรคลาสส่วนตัว (ซึ่งสามารถเปลี่ยนได้จากภายในคลาสเท่านั้น) ตัวแปรจะได้รับค่าเป็น เริ่ม .
• เริ่มต้นเป็นโมฆะ (): นี้ประกาศวิธีการที่เรียกว่า เริ่ม . เริ่มเป็นวิธีพิเศษที่ทำงานเพียงครั้งเดียวเมื่อเกมเปิดตัวครั้งแรก
• การอัปเดตเป็นโมฆะ (): การอัปเดตเป็นวิธีการพิเศษอีกวิธีหนึ่งซึ่งทำงานบนทุกเฟรม ตรรกะของเกมส่วนใหญ่จะอยู่ที่นี่
• // หากคุณพบผู้เล่นบนถนน ให้ฆ่าเขา: บรรทัดนี้เป็นความคิดเห็น (บรรทัดใดๆ ที่ขึ้นต้นด้วยเครื่องหมายทับคู่จะถูกละเว้นโดย C#) ความคิดเห็นใช้เพื่อเตือนตัวเองว่าโค้ดบางส่วนทำอะไรได้บ้าง ในกรณีนี้ ความคิดเห็นนี้ถูกใช้เพื่อยืนหยัดในบล็อกของโค้ดที่ซับซ้อนมากขึ้น ซึ่งทำในสิ่งที่ความคิดเห็นอธิบายไว้จริงๆ

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

public float addTwoNumbers(float a, float b) {
return a+b;
}

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

เรียกวิธีนี้จากในคลาสเดียวกัน (พูดจากภายใน อัปเดต ) มีลักษณะดังนี้:

float result = addTwoNumbers(1, 2);

การเรียกเมธอดจากคลาสอื่นนั้นคล้ายกัน:

addTwoNumbers instance;
float result = instance.addTwoNumbers(1, 2);

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

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

ไวยากรณ์สำหรับที่มีลักษณะดังนี้:

GetComponent().Play();

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

4. พื้นฐานความสามัคคี

ในส่วนนี้ เราจะดำเนินการตามกลไกพื้นฐานของเอ็นจิ้น Unity เวิร์กโฟลว์ใน Unity มีลักษณะดังนี้:

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

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

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

ดูแผนภาพด้านล่างสำหรับตำแหน่งของสิ่งเหล่านี้ทั้งหมด:

4.1 เอกภาพ

4.1.1 ตาข่าย

ตาข่ายเป็นวิธี เรขาคณิต 3 มิติ แสดงใน Unity คุณสามารถใช้เครื่องมือในตัวของ Unity ก็ได้ ดั้งเดิม วัตถุ (ลูกบาศก์ ทรงกลม ทรงกระบอก ฯลฯ) หรือนำเข้าโมเดล 3 มิติของคุณเองจากแพ็คเกจการสร้างแบบจำลอง เช่น เครื่องปั่น หรือ มายา . Unity รองรับรูปแบบ 3D ที่หลากหลาย รวมถึง .fbx , และ .3ds .

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

4.1.2 องค์ประกอบ GUI

สามารถแสดงสไปรต์และข้อความ GUI แบบดั้งเดิมได้โดยใช้ปุ่ม GUI Text และ GUI Texture GameObjects ในตัวแก้ไข อย่างไรก็ตาม วิธีที่มีประสิทธิภาพและสมจริงยิ่งขึ้นในการจัดการองค์ประกอบ UI คือการใช้ ข้อความ 3 มิติ และ Quad GameObjects (ที่มีพื้นผิวโปร่งใสและ shader โปร่งใสที่ไม่มีแสง) เพื่อวางองค์ประกอบ HUD ในโลกของเกมเป็นเอนทิตี

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

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

4.1.3 วัสดุ

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

หากต้องการนำเข้าพื้นผิว ให้แปลงเป็น a .jpg , .png , หรือ .bmp และลากเข้าไปใน ทรัพย์สิน โฟลเดอร์ภายใต้ไดเร็กทอรีโครงการ Unity (ซึ่งปรากฏใน เอกสารของฉัน โดยค่าเริ่มต้น). หลังจากนั้นไม่กี่วินาที แถบการโหลดจะปรากฏขึ้นในตัวแก้ไข เมื่อเสร็จแล้ว คุณจะสามารถค้นหาภาพเป็นพื้นผิวภายใต้ โครงการ แท็บ

4.1.5 ไฟ

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

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

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

แสงสามประเภทหลักคือ จุด , จุด , และ ทิศทาง .

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

ไฟส่องเฉพาะจุด มีตำแหน่งในพื้นที่ 3 มิติ และกระจายแสงอย่างสม่ำเสมอในทุกทิศทาง ไฟส่องเฉพาะจุดไม่ทำให้เกิดเงา

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

4.1.6 ระบบอนุภาค

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

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

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

5. ตัวอย่าง: องค์ประกอบพื้นฐานของเกม

สำหรับบทช่วยสอนนี้ เราจะทำเกมง่ายๆ ของ โป่ง -- สิ่งที่เราได้กล่าวถึงหลายครั้งใน DIY ก่อนหน้านี้:

• Arduino Classic Pong
• Arduino OLED Pong

ในส่วนนี้ เราจะพูดถึงการจัดเรียงองค์ประกอบหลัก -- บทช่วยสอนการเขียนสคริปต์จะมาในภายหลัง

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

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

ขั้นแรก สร้าง a เสาลูกบาศก์ สำหรับไม้พาย

ปรับขนาดให้เหมาะสม ทำซ้ำ และใส่ a ทรงกลม ระหว่างไม้พายสำหรับลูกบอล

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

ต่อไป สร้างสอง ระบบอนุภาค เลือกลักษณะที่คุณต้องการแล้วติดเข้ากับแป้นพาย

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

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

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

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

6. การเขียนสคริปต์ใน Unity

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

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

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

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

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

1. แปลง
2. Cube (ตัวกรองตาข่าย)
3. กล่องชนกัน
4. เรนเดอร์ตาข่าย

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

6.1 การแปลงร่าง

ฟังก์ชันการแปลงสำหรับ GameObject ใน Unity ควบคุมพารามิเตอร์ทางกายภาพของวัตถุนั้น: its มาตราส่วน , ของมัน ตำแหน่ง , และมัน ปฐมนิเทศ . คุณสามารถเข้าถึงได้จากภายในสคริปต์ดังนี้:

transform.position = newPositionVector3;
transform.rotation = newRotationQuaternion;
transform.localScale = newScaleVector3;

ในตัวอย่างข้างต้น ตัวแปรที่มีชื่อเป็นประเภทที่ระบุในชื่อ มีรายละเอียดสำคัญสองสามประการที่นี่: ตำแหน่งและมาตราส่วนถูกจัดเก็บเป็น . อย่างที่คุณคาดหวัง Vector3s . คุณสามารถเข้าถึง NS , และ , และ กับ ส่วนประกอบแต่ละอย่าง (เช่น transform.position.y ให้ระยะห่างของวัตถุเหนือระนาบศูนย์)

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

transform.rotation = Quaternion.Euler(pitch, yaw, roll);

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

transform.position = Vector3.Slerp(startPositionVector3, newDestinationVector3, 1);

6.2 เรนเดอร์

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

renderer.enabled = false;
renderer.material.color = new Color(0, 255, 0);
renderer.material.mainTexture = myTexture;
renderer.material.shader = newShader;

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

6.3 ฟิสิกส์

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

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

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

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

ตัวอย่าง:

rigidbody.angularDrag = 0.1f;
rigidbody.mass = 100;
rigidbody.isKinematic = false;
rigidbody.useGravity = true;
rigidbody.AddForce(transform.forward * 100);

ทั้งหมดนี้ค่อนข้างอธิบายตนเองได้ สิ่งเดียวที่ควรทราบที่นี่คือการใช้ transform.forward . Vector3 ทั้งหมดมีสามองค์ประกอบ ( .ซึ่งไปข้างหน้า , .ขึ้น , และ .ขวา ) ที่เกี่ยวข้องกับพวกเขา ซึ่งสามารถเข้าถึงได้และหมุนเวียนกับพวกเขา ( ซึ่งไปข้างหน้า คือทิศทางของลูกศรสีน้ำเงินในตัวแก้ไข) NS transform.forward คำหลักเป็นเพียงเวกเตอร์ไปข้างหน้าสำหรับวัตถุปัจจุบันที่มีขนาด 1 สามารถคูณด้วยทุ่นเพื่อสร้างแรงมากขึ้นบนวัตถุ คุณยังสามารถอ้างอิง transform.up และ แปลง.ขวา และปฏิเสธพวกเขาเพื่อให้ได้ผลกลับกัน

6.4 การชน

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

มีการเตรียมการบางอย่างที่จำเป็นสำหรับการตรวจจับการชนกันใน Unity อย่างแรก อย่างน้อยหนึ่งวัตถุในการชนกันต้องการ a ร่างกายไม่แข็งกระด้าง ติดอยู่กับมัน อ็อบเจ็กต์ทั้งสองต้องมี colliders ที่ถูกต้อง ตั้งค่าเป็น non-trigger ความเร็วรวมของวัตถุทั้งสองต้องต่ำพอที่จะชนกันจริง ๆ แทนที่จะข้ามผ่านกันและกัน

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

void OnCollisionEnter(Collision other) {
//do things here
}

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

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

RaycastHit hit;
if (Physics.Raycast(transform.position, -Vector3.up, out hit)) {
float distanceToGround = hit.distance;
}

สิ่งนี้จะส่งรังสีจากตำแหน่งของวัตถุปัจจุบันไปตาม -Vector3.up (ตรงลง) และเชื่อมโยงตัวแปร ตี กับวัตถุแรกที่มันชนกัน เมื่อรังสีของคุณโดนอะไรบางอย่าง คุณสามารถเข้าถึง hit.distance เพื่อกำหนดว่าอยู่ไกลแค่ไหน หรือ hit.GameObject เพื่อจัดการกับวัตถุที่คุณตี

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

6.5 การแก้ไขเวลา

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

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

6.6 แหล่งเสียงและผู้ฟัง

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

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

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

วิธีค้นหาคีย์ความปลอดภัยเครือข่ายบนโทรศัพท์ Android ของฉัน

คุณสามารถใช้ได้ myAudioSource.Pause () และ myAudioSource.Play () เพื่อควบคุมไฟล์เสียงเหล่านั้น คุณสามารถปรับพฤติกรรมการหลุดออก ระดับเสียง และการเปลี่ยนดอปเปลอร์ของเสียงภายใต้เครื่องหมาย สารวัตร แท็บสำหรับแหล่งเสียง

6.7 อินพุต

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

Vector3 mousePos = Input.mousePosition;
bool isLeftClicking = Input.GetMouseButton(0);
bool isPressingSpace = Input.GetKey(KeyCode.Space);

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

6.8 การดีบักสคริปต์

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

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

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

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

7. ตัวอย่าง: สคริปโป่ง

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

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

BallHandler.cs

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

PaddleHandler.cs

ต่อไป เราต้องการ AI ของศัตรู: สิ่งที่จะทำให้ไม้พายของศัตรูติดตามลูกบอลในอัตราคงที่ เราจะใช้ Vector3.Slerp เพื่อความเรียบง่ายสูงสุด เราต้องการพฤติกรรมของอนุภาคแบบเดียวกับที่เราเห็นบนไม้พายของเราเอง

ศัตรูAI.cs

สุดท้ายนี้ เราต้องการสคริปต์เพื่ออัปเดตกระดานคะแนนและรีเซ็ตลูกบอลเมื่อออกนอกสนาม

ScoreboardUpdater.cs

ด้วยสคริปต์เหล่านั้นที่แนบมาและการอ้างอิงที่กรอก เมื่อเราเรียกใช้เกม Pong ของเรา เราสัมผัสประสบการณ์การเล่นเกม!

คุณสามารถ ดาวน์โหลดสาธิตพงษ์ของฉัน ถ้าคุณต้องการเห็นทุกสิ่งที่ฉันได้สรุปเอาไว้ในการดำเนินการ มันทำงานบนระบบ Windows, Mac และ Linux

8. สำรวจเอกสาร / เรียนรู้เพิ่มเติม

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

ทรัพยากรที่สำคัญที่นี่คือ Unity ScriptReference . ScriptReference เป็นฐานข้อมูลที่สามารถค้นหาได้ ซึ่งสามารถใช้ได้ทั้ง C# และ Javascript ซึ่งมีรายการคำสั่งและคุณลักษณะทั้งหมดของ Unity พร้อมคำอธิบายฟังก์ชันและตัวอย่างสั้นๆ ของไวยากรณ์

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

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

9. สร้างเกมของคุณ / รวบรวมเป็นแอปพลิเคชันแบบสแตนด์อโลน

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

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

> NS . นี่จะแสดงกล่องโต้ตอบอย่างง่ายที่ให้คุณสร้างเกมของคุณสำหรับหลายแพลตฟอร์ม

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

10. ปิดบันทึก

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

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

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

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

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

แบ่งปัน แบ่งปัน ทวีต อีเมล 3 วิธีในการตรวจสอบว่าอีเมลจริงหรือปลอม

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

อ่านต่อไป หัวข้อที่เกี่ยวข้อง

• การเขียนโปรแกรม
• การเขียนโปรแกรม
• Longform
• คู่มือแบบยาว

เกี่ยวกับผู้เขียน อังเดร อินฟานเต(131 บทความที่ตีพิมพ์)

นักเขียนและนักข่าวที่อยู่ในภาคตะวันตกเฉียงใต้ อังเดรรับประกันว่าจะยังคงทำงานได้ถึง 50 องศาเซลเซียส และกันน้ำได้ลึกสิบสองฟุต

เพิ่มเติมจาก Andre Infante

สมัครรับจดหมายข่าวของเรา

เข้าร่วมจดหมายข่าวของเราสำหรับเคล็ดลับทางเทคนิค บทวิจารณ์ eBook ฟรี และดีลพิเศษ!

คลิกที่นี่เพื่อสมัครสมาชิก