วิธีสร้าง Infinite Runner บน iOS: Cocos2D, Automation และอื่นๆ

การพัฒนาเกม iOS สามารถเป็นประสบการณ์ที่มีคุณค่าทั้งในแง่ของการเติบโตส่วนบุคคลและทางการเงิน เมื่อต้นปีนี้ ฉันได้ปรับใช้เกม Bee Race ที่ใช้ Cocos2D ใน App Store รูปแบบการเล่นนั้นเรียบง่าย: นักวิ่งที่ไม่มีที่สิ้นสุดซึ่งผู้เล่น (ในกรณีนี้คือผึ้ง) รวบรวมคะแนนและหลีกเลี่ยงอุปสรรค ดูที่นี่สำหรับการสาธิต

ในบทช่วยสอนนี้ ฉันจะอธิบายขั้นตอนเบื้องหลังการพัฒนาเกมสำหรับ iOS ตั้งแต่ Cocos2D ไปจนถึงการเผยแพร่ สำหรับการอ้างอิง นี่คือสารบัญสั้น ๆ :

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

สไปรท์และวัตถุทางกายภาพ

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

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

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

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

โดยที่ในใจ…

บทช่วยสอนสั้นๆ เกี่ยวกับการพัฒนาเกม Cocos2D iOS

Cocos2D-iphone เป็นเฟรมเวิร์กโอเพ่นซอร์สสำหรับ iOS ที่ใช้ OpenGL สำหรับการเร่งกราฟิกด้วยฮาร์ดแวร์และรองรับเอ็นจิ้นฟิสิกส์ Chipmunk และ Box2D

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

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

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

การใช้ Cocos2D กับกระดานเรื่องราว

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

ประการแรก มันช่วยให้ฉันสามารถลากและวางตำแหน่งองค์ประกอบกราฟิกทั้งหมดของฉันสำหรับเกมวิ่งที่ไม่มีที่สิ้นสุดด้วยเมาส์ของฉัน ประการที่สอง Storyboard API มีประโยชน์มาก (และใช่ ฉันรู้เกี่ยวกับ Cocos Builder)

นี่คือภาพรวมคร่าวๆ ของสตอรี่บอร์ดของฉัน:

ตัวควบคุมมุมมองหลักของเกมมีเพียงฉาก Cocos2D ที่มีองค์ประกอบ HUD อยู่ด้านบน:

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

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

รายละเอียดการเล่นเกมและ (สั้น ๆ ) โปรเจ็กต์

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

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

Cocos2D มีวัตถุกล้องที่ออกแบบมาเพื่อติดตามตัวละคร ในทางปฏิบัติ การจัดการ CCLayer ที่มีโลกของเกมนั้นซับซ้อนน้อยกว่า

การควบคุมทำได้ง่าย: การแตะหน้าจอจะเลื่อนผึ้งขึ้น และแตะอีกครั้งจะเลื่อนลง

จริง ๆ แล้ว เลเยอร์โลกนั้นมีสองเลเยอร์ย่อย เมื่อเกมเริ่มต้น เลเยอร์ย่อยแรกจะถูกเติมจาก 0 ถึง BUF_LEN และแสดงขึ้นในตอนแรก เลเยอร์ย่อยที่สองถูกเติมล่วงหน้าจาก BUF_LEN ถึง 2*BUF_LEN เมื่อผึ้งมาถึง BUF_LEN เลเยอร์ย่อยแรกจะถูกล้างและเติมทันทีจาก 2*BUF_LEN ถึง 3*BUF_LEN และจะแสดงเลเยอร์ย่อยที่สอง ด้วยวิธีนี้ เราสลับไปมาระหว่างเลเยอร์โดยไม่เก็บวัตถุที่ล้าสมัย ซึ่งเป็นส่วนสำคัญในการหลีกเลี่ยงการรั่วไหลของหน่วยความจำ

ในแง่ของเครื่องยนต์ฟิสิกส์ ฉันใช้ Chipmunk ด้วยเหตุผลสองประการ:

1. มันเขียนด้วย Objective-C ล้วนๆ
2. ฉันเคยทำงานกับ Box2D มาก่อน ดังนั้นฉันจึงต้องการเปรียบเทียบทั้งสอง

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

งานอัตโนมัติ ใช้เครื่องมือ ใจเย็น.

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

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

ตัวอย่างเช่น ในเกม iOS อื่นที่ฉันกำลังพัฒนา ฉันสร้างเฟรมเวิร์กเพื่อสร้างเลย์เอาต์โดยใช้เครื่องมือพิเศษ (มีให้ใน GitHub) กรอบงานนี้มีข้อจำกัด (เช่น ไม่มีช่วงการเปลี่ยนภาพที่ดีระหว่างฉาก) แต่การใช้กรอบนี้ช่วยให้ฉันสร้างฉากได้ภายในหนึ่งในสิบของเวลา

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

ในการสร้างนักวิ่งที่ไม่มีที่สิ้นสุดนี้ ระบบอัตโนมัติเป็นกุญแจสำคัญอีกครั้ง ตัวอย่างเช่น ศิลปินของฉันจะส่งกราฟิกความละเอียดสูงให้ฉันผ่านโฟลเดอร์ Dropbox พิเศษ เพื่อประหยัดเวลา ฉันได้เขียนสคริปต์เพื่อสร้างชุดไฟล์โดยอัตโนมัติสำหรับความละเอียดเป้าหมายต่างๆ ที่ App Store ต้องการ โดยเพิ่ม -hd หรือ @2x ด้วยเช่นกัน (สคริปต์ดังกล่าวใช้ ImageMagick)

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

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

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

ในกรณีของเรา เราต้องใช้รูปแบบ plist:

 <real>%.5f</real><real>%.5f</real>

ต่อไป เราสร้างไฟล์ plist พร้อมคำอธิบายวัตถุ:

 <?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd"> <plist version="1.0"> <dict> <key>jet_ant</key> <dict> <key>vertices</key> <array> <real>-0.18262</real><real>0.08277</real> <real>-0.14786</real><real>-0.22326</real> <real>0.20242</real><real>-0.55282</real> <real>0.47047</real><real>0.41234</real> <real>0.03823</real><real>0.41234</real> </array> </dict> </dict> </plist>

และตัวโหลดวัตถุ:

 - (void)createBodyAtLocation:(CGPoint)location{ float mass = 1.0; body = cpBodyNew(mass, cpMomentForBox(mass, self.sprite.contentSize.width*self.sprite.scale, self.sprite.contentSize.height*self.sprite.scale)); body->p = location; cpSpaceAddBody(space, body); NSString *path =[[NSBundle mainBundle] pathForResource:@"obj _descriptions" ofType:@"plist"]; // <- load plist NSDictionary *objConfigs = [[[NSDictionary alloc] initWithContentsOfFile:path] autorelease]; NSArray *vertices = [[objConfigs objectForKey:namePrefix] objectForKey:@"vertices"]; shape = [ChipmunkUtil polyShapeWithVertArray:vertices withBody:body width:self.sprite.contentSize.width height:self.sprite.contentSize.height]; shape->e = 0.7; shape->u = 1.0; shape->collision_type = OBJ_COLLISION_TYPE; cpSpaceAddShape(space, shape); }

หากต้องการทดสอบว่าสไปรท์สอดคล้องกับร่างกายอย่างไร ให้ดูที่นี่

ดีขึ้นมากใช่ไหม?

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

การเรียกเก็บเงินในแอป

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

สำหรับข้อมูลเพิ่มเติม Ray Wenderlich มีบทแนะนำการเรียกเก็บเงินในแอปที่สมบูรณ์แบบ

การเล่นเกมแบบผู้เล่นหลายคนด้วย Game Center

ในเกมบนมือถือ การ เข้าสังคม เป็นมากกว่าการเพิ่มปุ่ม 'ถูกใจ' ของ Facebook หรือการตั้งค่ากระดานผู้นำ เพื่อทำให้เกมน่าตื่นเต้นยิ่งขึ้น ฉันจึงใช้เวอร์ชันผู้เล่นหลายคน

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

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

คุณจำการอภิปรายเรื่องการสร้างโลกแบบแบ่งส่วนได้หรือไม่? ที่เรามีเลเยอร์ย่อยสองอัน อันหนึ่งจาก 0 ถึง BUF_LEN และอีกอันจาก BUF_LEN ถึง 2*BUF_LEN สถาปัตยกรรมนี้ไม่ได้ใช้โดยบังเอิญ—จำเป็นต้องจัดเตรียมกราฟิกที่ราบรื่นบนเครือข่ายที่ล่าช้า เมื่อส่วนหนึ่งของวัตถุถูกสร้างขึ้น วัตถุนั้นจะถูกบรรจุลงใน plist และส่งไปยังผู้เล่นอื่น บัฟเฟอร์มีขนาดใหญ่พอที่จะให้ผู้เล่นคนที่สองเล่นได้แม้เครือข่ายจะล่าช้า ผู้เล่นทั้งสองส่งตำแหน่งปัจจุบันของตนให้กันโดยใช้เวลาครึ่งวินาทีและส่งการเคลื่อนไหวขึ้นลงทันที เพื่อให้ประสบการณ์ราบรื่นขึ้น ตำแหน่งและความเร็วจะได้รับการแก้ไขทุก 0.5 วินาทีด้วยแอนิเมชั่นที่ราบรื่น ดังนั้นในทางปฏิบัติดูเหมือนว่าผู้เล่นคนอื่นกำลังเคลื่อนที่หรือเร่งความเร็วทีละน้อย

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

ห้องสำหรับการปรับปรุง

เกมส์ไม่เคยจบ เป็นที่ยอมรับว่ามีหลายด้านที่ฉันอยากจะปรับปรุงตัวเอง กล่าวคือ:

1. ปัญหาการควบคุม: การแตะมักเป็นท่าทางที่ไม่เป็นธรรมชาติสำหรับผู้เล่นที่ต้องการสไลด์

2. เลเยอร์โลกถูกย้ายโดยใช้การกระทำ CCMoveBy นี่เป็นเรื่องปกติเมื่อความเร็วของเลเยอร์โลกคงที่ เนื่องจากการกระทำของ CCMoveBy ถูกวนรอบด้วย CCRepeatForever:

    -(void) infiniteMove{ id actionBy = [CCMoveBy actionWithDuration: BUFFER_DURATION position: ccp(-BUFFER_LENGTH, 0)]; id actionCallFunc = [CCCallFunc actionWithTarget:self selector:@selector(requestFillingNextBuffer)]; id actionSequence = [CCSequence actions: actionBy, actionCallFunc, nil]; id repeateForever = [CCRepeatForever actionWithAction:actionSequence]; [self.bufferContainer runAction:repeateForever]; }

   แต่ต่อมา ฉันได้เพิ่มความเร็วของโลกเพื่อทำให้เกมยากขึ้น:

    -(void) infiniteMoveWithAccel { float duration = BUFFER_DURATION-BUFFER_ACCEL*self.lastBufferNumber; duration = max(duration, MIN_BUFFER_DURATION); id actionBy = [CCMoveBy actionWithDuration: duration position: ccp(-BUFFER_LENGTH, 0)]; id restartMove = [CCCallFunc actionWithTarget:self selector:@selector(infiniteMoveWithAccel)]; id fillBuffer = [CCCallFunc actionWithTarget:self selector:@selector(requestFillingNextBuffer)]; id actionSequence = [CCSequence actions: actionBy, restartMove, fillBuffer, nil]; [self.bufferContainer runAction:actionSequence]; }

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

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

บทสรุป

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

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

นอกจากนี้ ฉันแนะนำให้ใช้ AppAnnie เพื่อตรวจสอบข้อมูลต่างๆ เกี่ยวกับแอปพลิเคชันทั้งหมดใน App Store และการลงทะเบียนกับบริการวิเคราะห์บางอย่าง เช่น Flurry Analytics ก็มีประโยชน์เช่นกัน

และหากเกมนี้ทำให้คุณสนใจ อย่าลืมลองเล่น Bee Race ในร้าน