วิธีตั้งโปรแกรมเกมคอมพิวเตอร์ (พร้อมรูปภาพ)

2024 ผู้เขียน: Robert Blare | [email protected]. แก้ไขล่าสุด: 2024-01-31 12:20

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

ขั้นตอน

ส่วนที่ 1 จาก 3: การสร้างเกมแบบข้อความ

ขั้นตอนที่ 1 เลือกภาษาโปรแกรม

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

• ส่วนใหญ่ใช้ภาษาอะไร

  ภาษาโปรแกรมบางภาษา เช่น JavaScript ได้รับการออกแบบมาเพื่อใช้กับเว็บ ในขณะที่ภาษาอื่นๆ เช่น Python, C หรือ C++ ได้รับการออกแบบมาเพื่อเรียกใช้โปรแกรมคอมพิวเตอร์ สำหรับเกมของคุณ ตั้งเป้าไปที่ภาษาที่มีการใช้งานที่กว้างขึ้น เช่น Python, C, C++ หรือ JavaScript.

• เรียนยากแค่ไหน?

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

• ฉันจะใช้มันได้ที่ไหน?

  คุณอาจต้องการให้ผู้คนในระบบต่างๆ เช่น Linux, Mac หรือ Windows ทุกคนสามารถเล่นเกมของคุณได้ ดังนั้น คุณไม่ควรใช้ภาษาที่ได้รับการสนับสนุนในบางระบบเท่านั้น เช่น Visual Basic ซึ่งได้รับการสนับสนุนบน Windows เท่านั้น

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

ขั้นตอนที่ 2 เตรียมคอมพิวเตอร์ของคุณให้พร้อม

ส่วนประกอบหลักสองอย่างที่คุณต้องการคือโปรแกรมแก้ไขข้อความ ซึ่งคุณจะต้องเขียนโค้ด และคอมไพเลอร์ ซึ่งคุณจะใช้แปลงเป็นเกม หากคุณต้องการทำตามตัวอย่างในบทความนี้ คุณควรติดตั้ง Python และเรียนรู้วิธีเรียกใช้โปรแกรม หากต้องการ คุณสามารถตั้งค่า IDE (Integraded Desktop Environment) ซึ่งรวมการแก้ไข การคอมไพล์ และการดีบักไว้ในโปรแกรมเดียว IDE ของ Python เรียกว่า IDLE แต่คุณยังสามารถใช้โปรแกรมแก้ไขข้อความที่รองรับข้อความธรรมดา เช่น Notepad สำหรับ Windows, TextEdit สำหรับ macOS หรือ Vim สำหรับ Linux

ขั้นตอนที่ 3 เขียนโค้ดเพื่อทักทายผู้เล่น

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

• สิ่งนี้เสร็จสิ้นด้วยฟังก์ชัน print() ใน Python หากต้องการทดลองใช้ ให้เปิดไฟล์ใหม่ที่มีนามสกุล.py ป้อนรหัสต่อไปนี้ บันทึกและเรียกใช้:

  print("ยินดีต้อนรับสู่เกมทายตัวเลข!") print("ป้อนจำนวนเต็มระหว่าง 1 ถึง 1000:")
  

ขั้นตอนที่ 4 สร้างตัวเลขสุ่ม

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

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

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

  rightNum = random.randint(0, 1000)
  

ขั้นตอนที่ 5. รับข้อมูลจากเครื่องเล่น

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

• เนื่องจากรหัสที่คุณป้อนจะพิมพ์คำสั่งให้ป้อนตัวเลขให้กับผู้เล่น จึงควรอ่านตัวเลขที่ป้อนด้วย สิ่งนี้เสร็จสิ้นด้วย input() ใน Python 3 และ raw_input() ใน Python 2 คุณควรเขียนด้วย Python 3 เนื่องจาก Python 2 จะล้าสมัยในไม่ช้า เพิ่มบรรทัดต่อไปนี้ในโค้ดของคุณเพื่อเก็บอินพุตของผู้เล่นในตัวแปรที่เรียกว่า number:

  userNum = อินพุต ()
  

ขั้นตอนที่ 6 เปลี่ยนอินพุตของผู้เล่นให้เป็นประเภทข้อมูลที่ใช้งานได้

ผู้เล่นได้ป้อนหมายเลข-ตอนนี้อะไร?

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

  userNum = int (หมายเลขผู้ใช้)
  

ขั้นตอนที่ 7 เปรียบเทียบหมายเลขผู้เล่นกับหมายเลขที่ถูกต้อง

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

ในขณะที่ userNum != rightNum: userNum = int(input())

ขั้นตอนที่ 8 ให้ข้อเสนอแนะแก่ผู้เล่น

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

• แน่นอน คุณสามารถบอกผู้เล่นว่าหมายเลขของพวกเขาถูกหรือผิด แต่ด้วยวิธีการนั้น ผู้เล่นอาจต้องเดา 1000 ครั้งในกรณีที่เลวร้ายที่สุด ซึ่งคงจะน่าเบื่อมาก
• ดังนั้นบอกผู้เล่นว่าจำนวนของพวกเขาน้อยเกินไปหรือมากเกินไป สิ่งนี้จะลดจำนวนการเดาลงอย่างมาก ตัวอย่างเช่น หากผู้เล่นเดา 500 ก่อน และเกมตอบว่า "ใหญ่เกินไป ลองอีกครั้ง " จะมีเพียง 500 ตัวเลขที่เป็นไปได้แทนที่จะเป็น 1,000 ตัวเลข ซึ่งทำได้ด้วยการสร้าง if ดังนั้นให้แทนที่การพิมพ์ ("Wrong. ลองอีกครั้ง") ด้วยอันเดียว
• โปรดทราบว่าการตรวจสอบว่าตัวเลขสองตัวเหมือนกันหรือไม่โดยใช้ == ไม่ใช่ด้วย = = กำหนดค่าที่ถูกต้องให้กับตัวแปรด้านซ้ายของมัน!

if userNum < rightNum: print("Too small. Try again:") if userNum > rightNum: print("Too big. Try again:")

ขั้นตอนที่ 9 ทดสอบรหัสของคุณ

ในฐานะโปรแกรมเมอร์ คุณควรแน่ใจว่าโค้ดของคุณใช้งานได้ก่อนที่จะพิจารณาว่าโค้ดนั้นเสร็จสิ้น

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

  นำเข้าการพิมพ์แบบสุ่ม ("ยินดีต้อนรับสู่เกมเดาตัวเลข!") พิมพ์ ("ป้อนจำนวนเต็มระหว่าง 1 ถึง 1000:") rightNum = random.randint(0, 1000) userNum = input() userNum = int(userNum) ในขณะที่ userNum != rightNum: if userNum < rightNum: print("Too small. Try again:") if userNum > rightNum: print("Too big. Try again:") userNum = int(input()) print("คุณเดาได้ ถูกต้อง")
  

ขั้นตอนที่ 10. ตรวจสอบอินพุต

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

• เปิดเกมอีกครั้งแล้วลองป้อนอะไรที่ไม่ใช่ตัวเลข เกมจะออกพร้อมกับ ValueError เพื่อหลีกเลี่ยงปัญหานี้ คุณสามารถใช้วิธีตรวจสอบว่าอินพุตเป็นตัวเลขหรือไม่
• กำหนดฟังก์ชัน เนื่องจากการตรวจสอบความถูกต้องของอินพุตนั้นค่อนข้างยาว และคุณต้องทำหลายครั้ง คุณควรกำหนดฟังก์ชัน จะไม่มีข้อโต้แย้งและส่งคืนตัวเลข ขั้นแรก ให้เขียน def numInput(): ที่ด้านบนสุดของโค้ดของคุณ ใต้การนำเข้าแบบสุ่มโดยตรง
• รับข้อมูลของผู้เล่นหนึ่งครั้ง ใช้ฟังก์ชัน input() และกำหนดผลลัพธ์ให้กับตัวแปร inp
• เมื่อข้อมูลของผู้เล่นไม่ใช่ตัวเลข ให้ขอให้ป้อนตัวเลข หากต้องการตรวจสอบว่าสตริงเป็นตัวเลขหรือไม่ ให้ใช้ฟังก์ชัน isdigit() ซึ่งอนุญาตเฉพาะจำนวนเต็มเท่านั้น ดังนั้นคุณจึงไม่ต้องตรวจสอบแยกกัน
• หากอินพุตเป็นตัวเลข ให้แปลงจากสตริงเป็นตัวเลขแล้วส่งกลับผลลัพธ์ ใช้ฟังก์ชัน int() เพื่อแปลงสตริงเป็นจำนวนเต็ม ซึ่งจะทำให้การแปลงในโค้ดหลักไม่จำเป็น และคุณควรลบออกจากที่นั่น
• แทนที่การโทรทั้งหมดไปยัง input() ในรหัสหลักด้วยการโทรไปที่ numInput()
• รหัสของฟังก์ชัน numInput() จะมีลักษณะดังนี้:

def numInput(): inp = input() while not inp.isdigit(): print("คุณได้รับคำสั่งให้ป้อนจำนวนเต็ม! ป้อนจำนวนเต็ม:") inp = input() return int(inp)

ขั้นตอนที่ 11 ทดสอบเกมอีกครั้ง

ป้อนข้อมูลที่ไม่ถูกต้องเพื่อดูว่าเกิดอะไรขึ้น แล้วแก้ไขข้อผิดพลาดที่เกิดขึ้น

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

ขั้นตอนที่ 12. แนะนำให้เริ่มเกมใหม่เมื่อจบเกม

ด้วยวิธีนี้ ผู้เล่นสามารถเล่นเกมของคุณได้นานขึ้นโดยไม่ต้องเริ่มใหม่ตลอดเวลา

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

ขั้นตอนที่ 13 ทดสอบเกม

คุณจะต้องทดสอบเกมของคุณทุกครั้งที่ใช้คุณสมบัติใหม่

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

  นำเข้าสุ่ม def numInput(): inp = input() ในขณะที่ไม่ใช่ inp.isdigit(): print("คุณได้รับคำสั่งให้ป้อนจำนวนเต็ม! ป้อนจำนวนเต็ม:") inp = input() return int(inp) พิมพ์ ("ยินดีต้อนรับสู่เกมทายตัวเลข!") ในขณะที่ True: print("ป้อนจำนวนเต็มระหว่าง 1 ถึง 1000:") rightNum = random.randint(0, 1000) userNum = numInput() ในขณะที่ userNum != rightNum: ถ้า userNum < rightNum: print("Too small. Try again:") if userNum > rightNum: print("Too big. Try again:") userNum = numInput() print("คุณเดาถูก") print("คุณเดาถูกไหม") ต้องการเล่นอีกครั้งหรือไม่ ใส่ No เพื่อออก") ถ้า input() == "No": break
  

ขั้นตอนที่ 14. เขียนเกมแบบข้อความอื่นๆ

แล้วการเขียนการผจญภัยข้อความต่อไปล่ะ? หรือเกมตอบคำถาม? มีความคิดสร้างสรรค์.

เคล็ดลับ: บางครั้งการดูในเอกสารประกอบก็มีประโยชน์ หากคุณไม่แน่ใจว่ามีการดำเนินการใดหรือใช้งานฟังก์ชันอย่างไร เอกสาร Python 3 มีอยู่ที่ https://docs.python.org/3/ บางครั้งการค้นหาสิ่งที่คุณต้องการทำบนอินเทอร์เน็ตก็ให้ผลลัพธ์ที่ดีเช่นกัน

ตอนที่ 2 ของ 3: การสร้างเกมด้วยกราฟิก 2 มิติ

ขั้นตอนที่ 1. เลือกไลบรารีกราฟิก

การสร้างกราฟิกนั้นซับซ้อนมาก และภาษาการเขียนโปรแกรมส่วนใหญ่ (รวมถึง Python, C++, C, JavaScript) ให้การสนับสนุนเพียงเล็กน้อยหรือไม่มีเลยสำหรับกราฟิกในคอร์หรือไลบรารีมาตรฐาน ดังนั้น คุณจะต้องใช้ไลบรารีภายนอกเพื่อสร้างกราฟิก เช่น Pygame สำหรับ Python

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

บทความนี้จะใช้ Python ร่วมกับ Cocos2D เพื่อแสดงวิธีสร้าง platformer 2D อย่างง่าย แนวคิดบางอย่างที่กล่าวถึงอาจไม่มีอยู่ในเอ็นจิ้นเกมอื่น อ้างถึงเอกสารของพวกเขาสำหรับข้อมูลเพิ่มเติม

ขั้นตอนที่ 2 ติดตั้งไลบรารีกราฟิกที่คุณเลือก

Cocos2D สำหรับ Python ติดตั้งง่าย คุณสามารถรับได้จาก https://python.cocos2d.org/index.html หรือโดยการเรียกใช้ sudo pip3 install cocos2d หากคุณใช้ Linux

ขั้นตอนที่ 3 สร้างไดเร็กทอรีใหม่สำหรับเกมและสื่อของคุณ

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

ขั้นตอนที่ 4 สร้างไฟล์โค้ดใหม่ในไดเร็กทอรีใหม่

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

ในตัวอย่างนี้ เราจะสร้างไฟล์ชื่อ main.py ซึ่งจะมีโค้ดทั้งหมดของเรา

ขั้นตอนที่ 5. สร้างหน้าต่างเกม

นี่เป็นข้อกำหนดเบื้องต้นเบื้องต้นสำหรับเกมที่มีกราฟิก

• นำเข้าโมดูลย่อย cocos2d ที่จำเป็น: cocos.director, cocos.scene และ cocos.layer สิ่งนี้ทำได้ด้วย from subModuleName import * โดยที่ชื่อโมดูลย่อยคือโมดูลย่อยที่คุณต้องการนำเข้า ความแตกต่างระหว่าง จาก … นำเข้า * และ นำเข้า … คือ คุณไม่จำเป็นต้องใส่ชื่อโมดูลไว้ข้างหน้าทุกอย่างที่คุณใช้จากโมดูลนั้นกับโมดูลเดิม
• กำหนดคลาสย่อย MainMenuBgr ของ ColorLayer โดยพื้นฐานแล้วหมายความว่าพื้นหลังของเมนูหลักใดๆ ที่คุณสร้างจะทำงานเหมือนเลเยอร์สีที่มีการเปลี่ยนแปลงบางอย่างที่คุณทำ
• เริ่มผู้อำนวยการโคโค่ นี่จะทำให้คุณมีหน้าต่างใหม่ หากคุณไม่ตั้งค่าคำอธิบายภาพ หน้าต่างจะมีคำบรรยายเหมือนกับชื่อไฟล์ (main.py) ซึ่งจะดูไม่เป็นมืออาชีพ อนุญาตให้ปรับขนาดหน้าต่างด้วยการตั้งค่าปรับขนาดได้เป็น True
• กำหนดฟังก์ชัน showMainMenu คุณควรใส่รหัสสำหรับแสดงเมนูหลักลงในฟังก์ชันเพราะจะทำให้คุณสามารถกลับไปที่เมนูหลักได้อย่างง่ายดายโดยการเรียกใช้ฟังก์ชันอีกครั้ง
• สร้างฉาก ฉากประกอบด้วยชั้นเดียวในตอนนี้ ซึ่งเป็นวัตถุของคลาส MainMenuBgr ที่คุณกำหนด
• เรียกใช้ฉากนี้ในหน้าต่าง

จากการนำเข้า cocos.director * จากการนำเข้า cocos.scene * จากการนำเข้า cocos.layer * คลาส MainMenuBgr (ColorLayer): def _init_(ตัวเอง): super(MainMenu, self)._init_(0, 200, 255, 255) def showMainMenu(): menuSc = Scene(MainMenuBgr()) director.run(menuSc) director.init(caption="IcyPlat - a simple platformer", resizable=True) showMainMenu()

ขั้นตอนที่ 6 เพิ่มเมนูหลักไปที่หน้าต่าง

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

• นำเข้า cocos.menu (อีกครั้งด้วยคำสั่ง from) และ pyglet.app (คราวนี้พร้อมการนำเข้า)
• กำหนด MainMenu เป็นคลาสย่อยของ Menu
• ตั้งค่าการจัดตำแหน่งเมนูหลัก คุณต้องตั้งค่าการจัดตำแหน่งแนวตั้งและแนวนอนแยกกัน
• สร้างรายการเมนูและเพิ่มลงในเมนู คุณควรมีรายการเมนู "เริ่มเกม" และ "ออก" อย่างน้อยที่สุด ทุกรายการเมนูควรอยู่ในวงเล็บ แต่ละรายการต้องมีป้ายกำกับและฟังก์ชันเรียกกลับที่กำหนดว่าจะเกิดอะไรขึ้นเมื่อผู้เล่นคลิก สำหรับรายการ "เริ่มเกม" ให้ใช้ฟังก์ชัน startGame (คุณจะเขียนได้ในไม่ช้านี้) สำหรับรายการ "ออก" ให้ใช้ "pyglet.app.exit" (มีอยู่แล้ว) สร้างเมนูจริงโดยเรียก self.create_menu(menuItems)
• กำหนด startGame() เพียงแค่ใส่ลงไปในคำจำกัดความในตอนนี้ คุณจะแทนที่เมื่อคุณเขียนเกมจริง
• ไปที่ตำแหน่งในรหัสของคุณที่คุณสร้างฉาก menuSc และเพิ่มวัตถุ MainMenu ลงไป

• รหัสทั้งหมดของคุณควรมีลักษณะดังนี้:

  จากการนำเข้า cocos.director * จากการนำเข้า cocos.menu * จากการนำเข้า cocos.scene * จากการนำเข้า cocos.layer * นำเข้าคลาส pyglet.app MainMenuBgr (ColorLayer): def _init_(ตนเอง): super(MainMenuBgr, self)._init_(0, 200, 255, 255) คลาส MainMenu(เมนู): def _init_(self): super(MainMenu, self)._init_("") self.menu_valign = CENTER self.menu_halign = CENTER menuItems = [(MenuItem("Start Game) ", startGame)), (MenuItem("Quit", pyglet.app.exit))] self.create_menu(menuItems) def startGame(): pass def showMainMenu(): menuSc = Scene(MainMenuBgr()) menuSc.add() MainMenu()) director.run(menuSc) director.init(caption="IcyPlat - a simple platformer", resizable=True) showMainMenu()
  

ขั้นตอนที่ 7 ทดสอบรหัสของคุณ

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

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

ขั้นตอนที่ 8 สร้างสไปรท์

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

• อิมพอร์ตโมดูลย่อย cocos.sprite ด้วย from-import-expression
• ค้นหาภาพเพื่อเป็นตัวแทนของเทพดา คุณไม่สามารถแสดงสไปรต์ได้หากไม่มีรูปภาพ คุณสามารถวาดหรือหาได้จากอินเทอร์เน็ต (โปรดระวังใบอนุญาต หากคุณวางแผนที่จะเผยแพร่เกมของคุณ) สำหรับตัวอย่างนี้ ให้ไปที่ https://opengameart.org/content/tux-classic-hero-style และบันทึกภาพ-p.webp" />
• สร้างเลเยอร์เป็นวัตถุใหม่ของคลาส ScrollableLayer จากนั้น สร้างสไปรท์เป็นออบเจ็กต์ Sprite และตั้งค่าตำแหน่งเป็น (8, 250) สำหรับการอ้างอิง จุด (0, 0) อยู่ที่มุมล่างซ้าย นี่ค่อนข้างสูง แต่จะทำให้แน่ใจว่าเพนกวินจะไม่ติดอยู่ในน้ำแข็ง
• เพิ่มสไปรท์ลงในเลเยอร์ของสไปรท์
• สร้างฉากใหม่จากเลเยอร์ของสไปรท์แล้วเรียกใช้

def startGame(): figLayer = ScrollableLayer() fig = Sprite('pingu.png') fig.position = (75, 100) figLayer.add(fig) # gameSc = Scene(figLayer) director.run(gameSc)

• เรียกใช้รหัส คุณควรเห็นหุ่นเพนกวินตัวเล็ก (หรือสิ่งที่คุณวาด) บนพื้นหลังสีดำหลังจากที่คุณคลิก เริ่มเกมส์.

ขั้นตอนที่ 9 ฝันถึงภูมิทัศน์ของคุณ

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

• สร้างชุดไทล์ชุดไทล์สำหรับเกมนี้จะเป็นแบบพื้นฐาน: หนึ่งแผ่นสำหรับน้ำแข็งและอีกหนึ่งแผ่นสำหรับท้องฟ้า แผ่นน้ำแข็งที่ใช้ในตัวอย่างนี้มาจากที่นี่ ภายใต้ CC-BY-SA 3.0
• สร้างภาพชุดไทล์ นั่นคือรูปภาพของไทล์ทั้งหมด ซึ่งจะต้องมีขนาดเท่ากันทั้งหมด (แก้ไขได้หากไม่ใช่) และมีขนาดที่คุณต้องการเห็นในเกมวางติดกัน บันทึกรูปภาพของคุณเป็น icyTiles.png

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

ขั้นตอนที่ 10 สร้างแผนที่ย่อยสำหรับภูมิทัศน์ของคุณ

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

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

def สร้างTilemap (): colAmount = ceil(800 / 16)*3 # (ความกว้างหน้าจอ / ขนาดไทล์) * 3 rowAmount = ceil (600 / 16) # ความสูงของหน้าจอ / ขนาดไทล์ไทล์ไฟล์ = เปิด ("levelMap.xml", " w") tileFile.write('\n\n\n') iceHeight = randint(1, 10) สำหรับฉันในช่วง (0, colAmount): tileFile.write('') makeHole = False if randint(0, 50) == 10 และ i != 0: # ไม่อนุญาตให้มีรูที่จุดวางไข่ makeHole = True สำหรับ j ในช่วง (0, rowAmount): if makeHole: tileFile.write('\n') else: if j <= iceHeight: tileFile.write('\n') อื่นๆ: tileFile.write('\n') iceHeight = randint(iceHeight-5, iceHeight+5) ถ้า iceHeight < 0: # จำกัดไทล์ไม่ให้ต่ำเกินไป iceHeight = randint(1, 5) ถ้า iceHeight > rowAmount: # จำกัดไทล์ไม่ให้สูงเกินไป iceHeight = randint(int(rowAmount/2)-5, int(rowAmount/2)+5) tileFile.write('\n') tileFile.write ('\n\n') สำหรับฉันในช่วง (0, colAmount): tileFile.write('') สำหรับ j ในช่วง (0, rowAmount): tileFile.write('\n') tileFile.write('\ n') tileFile.write('\n\n') tileFile.close()

ขั้นตอนที่ 11 แสดงแผนที่ย่อย

นำเข้าทุกอย่างจาก cocos.tiles จากนั้นไปที่ฟังก์ชัน startGame สำหรับสิ่งนั้น

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

• ฟังก์ชั่น startGame ของคุณควรมีลักษณะดังนี้:

  def startGame(): generateTilemap() # fig = Sprite('pingu.png') fig.position = (8, 500) figLayer = ScrollableLayer() figLayer.add(fig) # tileLayer = load('levelMap.xml') solidTiles = tileLayer['solid'] nsoliTiles = tileLayer['not_solid'] # scrMang = ScrollingManager() scrMang.add(nsoliTiles, z=-1) scrMang.add(solidTiles, z=0) scrMang.add(figLayer, z) =1) # gameSc = ฉาก (scrMang) director.run (gameSc)
  

ขั้นตอนที่ 12. ทดสอบรหัสของคุณ

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

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

ขั้นตอนที่ 13 เพิ่มการควบคุม

ผู้เล่นมีหลายวิธีในการโต้ตอบกับโปรแกรมในเกม 2D มากกว่าในเกมแบบข้อความ โดยทั่วไปรวมถึงการขยับร่างเมื่อกดปุ่มที่ถูกต้อง

• นำเข้าทุกอย่างจาก cocos.mapcolliders และจาก cocos.actions นำเข้าคีย์จาก pyglet.window ด้วย

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

  # "ประกาศ" แป้นพิมพ์ตัวแปรทั่วโลก = 0 scrMang = 0
  

• ปรับฟังก์ชัน startGame ของคุณ:

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

  def startGame(): แป้นพิมพ์สากล scrMang generateTilemap() # fig = Sprite('pingu.png') fig.position = (8, 250) figLayer = ScrollableLayer() figLayer.add(fig) # tileLayer = load('levelMap.xml') solidTiles = tileLayer['solid'] nsoliTiles = tileLayer['not_solid'] # แป้นพิมพ์ = คีย์ KeyStateHandler () director.window.push_handlers (แป้นพิมพ์) # fig.do (PlatformerController ()) mapcollider = RectMapCollider_ (velocity_ ='slide') fig.collision_handler = make_collision_handler(mapcollider, solidTiles) # scrMang = ScrollingManager() scrMang.add(nsoliTiles, z=-1) scrMang.add(solidTiles, z=0) scrMang.add(zfig=Layer, z=0) 1) # gameSc = ฉาก (scrMang) director.run (gameSc)
  

• สร้างคอนโทรลเลอร์ platformer นี่คือสิ่งที่จะขยับร่างตามการกดปุ่มของคุณ

  • กำหนดคอนโทรลเลอร์ platformer เป็นคลาสย่อยของ Action
  • กำหนดความเร็วในการเคลื่อนที่ ความเร็วในการกระโดด และแรงโน้มถ่วง
  • กำหนดฟังก์ชั่นเริ่มต้น ฟังก์ชันนี้เรียกว่าหนึ่งครั้ง เมื่อคอนโทรลเลอร์ platformer เชื่อมต่อกับรูป ควรตั้งค่าความเร็วเป็น 0 ทั้งใน x และ y
  • กำหนดฟังก์ชันขั้นตอน มันจะถูกทำซ้ำในขณะที่ฉากกำลังดำเนินอยู่
  • บอกฟังก์ชันขั้นตอนให้ใช้แป้นพิมพ์ตัวแปรส่วนกลางและ scrMang
  • รับและเปลี่ยนความเร็ว บันทึกความเร็ว x และ y ไว้ในตัวแปรแยกกัน ตั้งค่าความเร็ว x เป็น 1 หรือ -1 (ขึ้นอยู่กับว่ากดปุ่มซ้ายหรือขวา) คูณด้วยความเร็วในการเคลื่อนที่ เพิ่มแรงโน้มถ่วงให้กับความเร็ว y คูณด้วยการหยุดทำงานเพื่อให้ทำงานในลักษณะเดียวกันกับอุปกรณ์ที่ช้ากว่า หากกดแป้นเว้นวรรคและร่างนั้นยืนอยู่บนพื้น ให้กระโดดโดยเปลี่ยนความเร็ว y เป็นความเร็วในการกระโดด
  • คำนวณว่าร่างควรย้ายไปที่ใด จากนั้นให้ตัวจัดการการชนปรับตำแหน่งนั้นหากอยู่ภายในแผ่นกระเบื้องทึบ สุดท้าย ย้ายร่างไปยังตำแหน่งที่ปรับใหม่
  • กำหนดโฟกัสของตัวจัดการการเลื่อนบนรูปภาพ ทำให้กล้องเคลื่อนที่ในลักษณะที่เหมาะสมเมื่อร่างเคลื่อนไหว

  คลาส PlatformerController (การกระทำ): แป้นพิมพ์สากล scrMang on_ground = True MOVE_SPEED = 300 JUMP_SPEED = 500 GRAVITY = -1200 def start (ตัวเอง): self.target.velocity = (0, 0) ขั้นตอน def (ตัวเอง, dt): แป้นพิมพ์ทั่วโลก, scroller if dt > 0.1: # อย่าทำอะไรในขณะที่หยุดทำงานเพื่อผลตอบแทนสูง vx, vy = self.target.velocity vx = (แป้นพิมพ์[key. RIGHT] - แป้นพิมพ์[key. LEFT]) * self. MOVE_SPEED vy + = self. GRAVITY * dt ถ้า self.on_ground และแป้นพิมพ์ [key. SPACE]: vy = self. JUMP_SPEED dx = vx * dt dy = vy * dt last = self.target.get_rect() new = last.copy() ใหม่.x += dx new.y += dy self.target.velocity = self.target.collision_handler (สุดท้าย ใหม่ vx, vy) self.on_ground = (ใหม่.y == last.y) self.target.position = new.center scrMang.set_focus(*new.center)
  

ขั้นตอนที่ 14. ทดสอบรหัสของคุณ

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

ขั้นตอนที่ 15. สร้างตอนจบของเกม

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

• ภายในตัวควบคุม platformer หลังจากตั้งโฟกัสแล้ว ให้หาตำแหน่ง x และ y ของตัวเลข หากตำแหน่ง y น้อยกว่า 0 ให้เรียกใช้ฟังก์ชัน finishGame() (คุณจะเขียนในภายหลัง) โดยมี "Game Over" เป็นอาร์กิวเมนต์ หากตำแหน่ง x ใหญ่กว่าขนาดของหน้าจอคูณด้วย 3 (คุณได้ตั้งเป็นขนาดระดับก่อนหน้านี้)

  posX, posY = self.target.position if posY < 0: finishGame("Game Over") return ถ้า posX > 800*3: # level size finishGame("Level Completed") return
  

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

  คลาส FinishMenu(เมนู): def _init_(self, text): super(FinishMenu, self)._init_(text) self.menu_valign = CENTER self.menu_halign = CENTER menuItems = [(MenuItem("Try again", startGame)), (MenuItem("Quit", pyglet.app.exit))] self.create_menu(menuItems)
  

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

  def finishGame(ข้อความ): menuSc = Scene(MainMenuBgr()) menuSc.add(FinishMenu(text)) director.run(menuSc)
  

ขั้นตอนที่ 16 เพิ่มเครดิต

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

• สร้างไฟล์ CREDITS และป้อนเครดิตทั้งหมดของคุณที่นั่น ดังนี้:

  Penguin: Kelvin Shadewing ภายใต้ CC0 Ice block: Michał Banas digit1024 บน opengameart.org ภายใต้ CC-BY-SA 3.0
  

• กลับไปที่โค้ด Python ของคุณและนำเข้า Label จาก cocos.text

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

  เครดิตคลาส (เลเยอร์): def _init_(ตัวเอง): super(เครดิต ตัวเอง)._init_() credFile = open("CREDITS", "r") creds = credFile.read() creds = creds.split("\n ") สำหรับฉันในช่วง (0, len(creds)): credLabel = Label(creds, font_size=32, anchor_x="left", anchor_y="top") credLabel.position = 25, 500-(i +1)*40 ตนเองเพิ่ม (credLabel)
  

• ไปที่คลาสเมนูหลักของคุณ และเพิ่มรายการเมนูชื่อ "เครดิต" ที่เรียกใช้ฟังก์ชัน showCredits เมื่อคลิก

• กำหนดคลาสย่อย BackToMainMenuButton ของ Menu ทำให้เมนูนี้เป็นรายการเดียวที่มีป้ายกำกับว่า "ย้อนกลับ" ซึ่งเรียกใช้ฟังก์ชัน showMainMenu "เมนู" นี้ซึ่งคล้ายกับปุ่มควรจัดแนวในแนวตั้งไปที่ด้านล่างและแนวนอนขึ้นไปด้านบน

  คลาส BackToMainMenuButton(เมนู): def _init_(self): super(BackToMainMenuButton, self)._init_("") self.menu_valign = BOTTOM self.menu_halign = LEFT menuItems = [(MenuItem("Back", showMainMenu))] self. create_menu(รายการเมนู)
  

• กำหนดฟังก์ชัน showCredits มันควรจะสร้างฉากจากเลเยอร์ MainMenuBgr และเลเยอร์ Credits และเรียกใช้ฉากนั้น

  def showCredits(): credSc = Scene(MainMenuBgr()) credSc.add(Credits()) credSc.add(BackToMainMenuButton()) director.run(credSc)
  

ขั้นตอนที่ 17. ตรวจสอบรหัสของคุณ

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

จากการนำเข้า cocos.director * จากการนำเข้า cocos.menu * จากการนำเข้า cocos.scene * จากการนำเข้า cocos.layer * จากการนำเข้า cocos.sprite * จากการนำเข้า cocos.tiles * จากการนำเข้า cocos.mapcolliders * จากการนำเข้า cocos.actions * จาก cocos.text นำเข้าป้ายกำกับนำเข้า pyglet.app จากคีย์นำเข้า pyglet.window จาก ceil นำเข้าคณิตศาสตร์จากสุ่มนำเข้า randint # "ประกาศ" ตัวแปรทั่วโลกแป้นพิมพ์ = 0 scrMang = 0 คลาส MainMenuBgr (ColorLayer): def _init_ (ตัวเอง): super (MainMenuBgr, self)._init_(0, 200, 255, 255) คลาส MainMenu(เมนู): def _init_(self): super(MainMenu, self)._init_("") self.menu_valign = CENTER self.menu_halign = CENTER menuItems = [(MenuItem("Start Game", startGame)), (MenuItem("Credits", showCredits)), (MenuItem("Quit", pyglet.app.exit))] self.create_menu(menuItems) เครดิตคลาส (เลเยอร์): def _init_(self): super(Credits, self)._init_() credFile = open("CREDITS", "r") creds = credFile.read() creds = creds.split("\n") สำหรับฉันในช่วง (0, len(creds)): credLabel = Label(creds, font_size=32, anchor_x="left", anchor_y="top") credLabel.position = 25, 500-(i+1)*40 self.add(credLabel) class BackToMainMenuButton(Menu): def _init_(self): super (BackToMainMenuButton, ตัวเอง)._init_("") self.menu_valign = ด้านล่าง self.menu_halign = LEFT menuItems = [(MenuItem("Back", showMainMenu))] self.create_menu(menuItems) คลาส FinishMenu (เมนู): def _init_(ตัวเอง, ข้อความ): super(FinishMenu, self)._init_(text) self.menu_valign = CENTER self.menu_halign = CENTER menuItems = [(MenuItem("Try again", startGame)), (MenuItem("Quit", pyglet. app.exit))] self.create_menu (menuItems) คลาส PlatformerController (Action): แป้นพิมพ์ทั่วโลก scrMang on_ground = True MOVE_SPEED = 300 JUMP_SPEED = 500 GRAVITY = -1200 def start (ตัวเอง): self.target.velocity = (0, 0) def step(self, dt): global keyboard, scroller if dt > 0.1: # don't do nothing while the downtime too big return vx, vy = self.target.velocity vx = (keyboard[key. RIGHT] - keyboard[คีย์] [key. LEFT]) * self. MOVE_SPEED vy += self. GRAVITY * dt ถ้า self.on _ground และคีย์บอร์ด[key. SPACE]: vy = self. JUMP_SPEED dx = vx * dt dy = vy * dt last = self.target.get_rect() new = last.copy() new.x += dx new.y + = dy self.target.velocity = self.target.collision_handler (สุดท้าย ใหม่ vx, vy) self.on_ground = (ใหม่.y == สุดท้าย.y) self.target.position = new.center scrMang.set_focus (* new.center) posX, posY = self.target.position if posY < 0: finishGame("Game Over") ส่งคืนหาก posX > 800*3: # level size finishGame("Level Completed") return def finishGame(ข้อความ): menuSc = ฉาก (MainMenuBgr ()) menuSc.add (FinishMenu (ข้อความ)) director.run (menuSc) def showCredits (): credSc = ฉาก (MainMenuBgr ()) credSc.add (เครดิต ()) credSc.add (BackToMainMenuButton ()) director.run(credSc) def generateTilemap(): colAmount = ceil(800 / 16)*3 # (ความกว้างหน้าจอ / ขนาดไทล์) * 3 rowAmount = ceil (600 / 16) # ความสูงของหน้าจอ / ขนาดไทล์tileFile = เปิด ("levelMap.xml", "w") tileFile.write('\n\n\n') iceHeight = randint(1, 10) สำหรับฉันในช่วง (0, colAmount): tileFile.write('') makeHole = เท็จถ้า rand int(0, 50) == 10 และ i != 0: # ไม่อนุญาตให้มีรูที่จุดวางไข่ makeHole = True สำหรับ j ในช่วง (0, rowAmount): ถ้า makeHole: tileFile.write('\n') อื่น: ถ้า j <= iceHeight: tileFile.write('\n') อื่น: tileFile.write('\n') iceHeight = randint(iceHeight-5, iceHeight+5) ถ้า iceHeight < 0: # จำกัดไทล์ไม่ให้ไปเช่นกัน iceHeight ต่ำ = randint (1, 5) ถ้า iceHeight > rowAmount: # จำกัดไทล์ไม่ให้สูงเกินไป iceHeight = randint(int(rowAmount/2)-5, int(rowAmount/2)+5) tileFile.write('\n ') tileFile.write('\n\n') สำหรับฉันในช่วง (0, colAmount): tileFile.write('') สำหรับ j ในช่วง (0, rowAmount): tileFile.write('\n') tileFile.write('\n') tileFile.write('\n\n') tileFile.close() def startGame(): แป้นพิมพ์สากล scrMang generateTilemap() # fig = Sprite('pingu.png') fig.position = (8, 250) figLayer = ScrollableLayer() figLayer.add(fig) # tileLayer = load ('levelMap.xml') solidTiles = tileLayer['solid'] nsoliTiles = tileLayer['not_solid'] # แป้นพิมพ์ = key. KeyStateHandler () director.window.push_handlers(คีย์โบ ard) # fig.do (PlatformerController()) mapcollider = RectMapCollider (velocity_on_bump='slide') fig.collision_handler = make_collision_handler (mapcollider, solidTiles) # scrMang = ScrollingManager () scrMang.add (=nsoliTiles) add(solidTiles, z=0) scrMang.add(figLayer, z=1) # gameSc = Scene(scrMang) director.run(gameSc) def showMainMenu(): menuSc = Scene(MainMenuBgr()) menuSc.add(MainMenu())) director.run(menuSc) window = director.init(caption="IcyPlat - a simple platformer", resizable=True) showMainMenu()))))))

• นั่นคือทั้งหมด 168 บรรทัด และ 152 บรรทัดหากคุณนับเฉพาะรหัส ทำให้ดูเหมือนมาก แต่สำหรับเกมที่ซับซ้อนเช่นนี้ จริง ๆ แล้วเป็นจำนวนเล็กน้อย

ขั้นตอนที่ 18 เสร็จแล้ว

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

ส่วนที่ 3 ของ 3: การเผยแพร่เกม

ขั้นตอนที่ 1 เขียนการพึ่งพา

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

ขั้นตอนที่ 2 ตรวจสอบให้แน่ใจว่าคุณได้รับอนุญาตให้ใช้สื่อทั้งหมด

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

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

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

ขั้นตอนที่ 3 ตัดสินใจเกี่ยวกับเงื่อนไขที่คุณต้องการเผยแพร่เกมของคุณ

คุณจะขายเกมของคุณหรือไม่? คุณต้องการอนุญาตให้ผู้อื่นใช้ภาพและความคิดของคุณหรือไม่? ในขณะที่คุณต้องระวังเกี่ยวกับสื่อที่คุณใช้ในโครงการของคุณ โดยปกติแล้ว คุณสามารถตัดสินใจได้ว่าคุณต้องการอนุญาตให้ผู้อื่นใช้เกมของคุณอย่างไร คุณสามารถใช้ใบอนุญาต Creative Commons CC0 เพื่อเผยแพร่เกมของคุณในสาธารณสมบัติ.. หากต้องการอนุญาตการแจกจ่ายและแก้ไขภายใต้เงื่อนไขบางประการโดยที่ยังรักษาสิทธิ์บางประการไว้ ให้ลองใช้ใบอนุญาต Gnu General Public License (GPL) หรือ Berkeley Software Distribution (BSD) หรือคุณสามารถสร้างซอฟต์แวร์ของคุณให้เป็นกรรมสิทธิ์ได้ ซึ่งหมายความว่าไม่มีใครได้รับอนุญาตให้เผยแพร่หรือแก้ไขซอฟต์แวร์โดยไม่ได้รับอนุญาตจากคุณ

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

ขั้นตอนที่ 4 ตัดสินใจว่าคุณต้องการเผยแพร่เกมของคุณอย่างไร

ทุกวิธีมีข้อดีและข้อเสีย ดังนั้นคุณต้องตัดสินใจด้วยตัวเอง

• เผยแพร่บนเว็บไซต์:

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

• การสร้างแพ็คเกจสำหรับตัวจัดการแพ็คเกจ:

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

ขั้นตอนที่ 5. ให้ความสนใจกับโปรแกรมของคุณโดยตรง

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

เคล็ดลับ

• อดทนและเต็มใจที่จะเรียนรู้ การเขียนโปรแกรมอาจทำให้คุณหงุดหงิดในบางครั้ง!
• หากคุณสงสัยว่ามีบางสิ่งเกิดขึ้นในเกมอื่นอย่างไร และเกมนั้นเป็นโอเพ่นซอร์ส คุณสามารถดูซอร์สโค้ดของเกมได้
• เมื่อมองหาสื่อ ให้พยายามค้นหาเนื้อหาที่เป็นสาธารณสมบัติ ค้นหารูปภาพและเพลง "Creative Commons" หรือ "Public Domain" และใช้เว็บไซต์เช่น https://opengameart.org หรือ
• อย่าคัดลอกโค้ดหลักโดยไม่ตรวจสอบใบอนุญาต มักเป็นสิ่งต้องห้าม และหากไม่ใช่ มักจะต้องมีการแสดงที่มา
• อย่าสร้างสแปมหรือโพสต์ในที่ที่ไม่เหมาะสมเมื่อโปรโมตเกมของคุณ การทำเช่นนี้อาจทำให้คุณถูกบล็อกจากเพจ สร้างความรำคาญ และจะสร้างความเสียหายต่อชื่อเสียงของคุณ