คำถามติดแท็ก turn-based

ฉันเคยเห็นเกมเทิร์นเบสจำนวนมากซึ่งการโจมตีระยะประชิดบนยูนิตอื่นทำให้ยูนิตที่ถูกโจมตีสร้างความเสียหายต่อหน่วยจู่โจมในขณะที่การโจมตีระยะไกลไม่ได้รับผลกระทบจากกลไก "ตอบโต้" นี้ ตัวอย่าง ได้แก่ ชุด Heroes of Might และ Magic, ชุด Civilization, ชุดใหม่ของ King's Bounty และอื่น ๆ มีเหตุผลการออกแบบเฉพาะสำหรับเรื่องนี้หรือไม่? อะไรคือเหตุผลเบื้องหลังที่ทำให้หน่วยโจมตีโจมตีแบบพิเศษซึ่งไม่คุ้มกับการโจมตี? และทำไมการโจมตีระยะไกลจึงถูกแยกออกจากการตอบโต้

54 game-design  turn-based 

เอาล่ะความคิดนี้ได้เกิดขึ้นเป็นครั้งที่ 3 ในการสนทนาตอนนี้และมันก็บั๊กฉันมาหลายปีแล้ว แนวคิดนี้เป็นเกมที่ผู้เล่นทุกคนตัดสินใจ / สั่งการออกหน่วยในขณะที่เกมอยู่ในสถานะหยุดชั่วคราวและการกระทำทั้งหมดจะถูกดำเนินการทันทีในเวลาจริง สิ่งนี้อาจอยู่ในระดับใดก็ได้ตั้งแต่ TRPG (เช่น Final Fantasy Tactics) ไปจนถึงการต่อสู้แบบชุลมุนขนาดเล็ก (เช่น Worms) ไปจนถึงเกมที่มีฐานและหลายหน่วย (เช่น Advance Wars) ไปจนถึงเกมประเภทเสี่ยง (เช่น Risk) ) ข้อเสียเปรียบหลักของสิ่งนี้ที่ฉันเห็นคือผู้เล่นไม่เห็นผลลัพธ์ของการกระทำทันที ในเกมวางแผนแบบเทิร์นเบสหรือเรียลไทม์ผู้ใช้คลิกที่ "การโจมตีที่หลอก" และมีการระเบิดในทันที อาจมีสถานการณ์แปลก ๆ (เช่นคุณส่งหน่วยของคุณไปสู่การโต้เถียงกันเรื่องหน่วยที่วิ่งไปในทิศทางตรงกันข้ามเช่น) แต่นั่นเป็นรายละเอียดระดับต่ำ นักออกแบบเกมที่ดีควรจะได้รับสิ่งเหล่านี้ ในที่สุดมันก็มีความยากลำบากโดยทั่วไปของเกมเทิร์นเบส แต่พวกเขาเสนอระดับความลึกทางยุทธวิธีที่เป็นไปไม่ได้ในเกมกลยุทธ์แบบเรียลไทม์และมีตลาดสำหรับพวกเขาอยู่เสมอ (TBSes ใหม่ ๆ ปรากฏขึ้นทุกปี) มีเกมใดบ้างที่ใช้กระบวนทัศน์นี้ ทำไมถึงไม่มีอะไรเพิ่มเติม สิ่งใดที่จำเป็นต่อการทำงานนี้ สิ่งที่อาจเป็นปัญหาที่คุณคาดการณ์ได้? เพื่ออธิบายชัดเจนฉันหมายถึงกลยุทธ์ที่บริสุทธิ์ คำสั่งนั้นป้อนเข้ามาล่วงหน้าและความละเอียดเป็นแบบเรียลไทม์ แต่มันไม่จำเป็นต้องใช้อินพุต "twitch" แบบเรียลไทม์โดยผู้เล่น แก้ไข: คำตอบของ Iainชี้ให้ฉันเห็นLaser …

39 game-design  turn-based 

ฉันพยายามหาสูตรที่ดีในการพิจารณาการโจมตีเมื่อผู้เล่นโจมตีศัตรูใน Roguelike ฉันต้องการที่จะคิดอะไรง่ายๆ แต่ก็ยังคงเป็นความจริงกับวิธีที่ทำใน D&D หรือ Roguelikes ยอดนิยมเช่น AngBand หรือ NetHack สิ่งที่ฉันมีจนถึงตอนนี้คือการเพิ่มความแตกต่างระหว่างผู้เล่นและคุณลักษณะของศัตรูพร้อมกับจำนวนเต็มแบบสุ่ม: if ((player.dex - enemy.dex) + (player.speed - enemy.speed) + (player.luck - enemy.luck) + random_integer_below_6()) >= 10) { hit(enemy); } สิ่งนี้ทำให้การเล่นเกมที่ผิดธรรมชาติ: ผู้เล่นจะไม่พลาดศัตรูที่อ่อนแอและในทางกลับกันสำหรับผู้ที่แข็งแกร่ง ไม่มีใครรู้คำแนะนำเกี่ยวกับการต่อสู้ตามคุณลักษณะที่ใช้ในการเปิดเกมตาม ฯลฯ ? ฉันควร (และฉัน) คัดลอกกฎคำต่อคำทุกคำ D & D หรือไม่

22 roguelikes  turn-based 

ผมเขียนรุ่นคอมพิวเตอร์ของเกมการปกครอง มันเป็นเกมไพ่เทิร์นเบสที่การ์ดแอคชั่นการ์ดขุมทรัพย์และการ์ดแต้มชัยชนะจะถูกสะสมไว้ในเด็คส่วนบุคคลของผู้เล่น ฉันมีโครงสร้างของชั้นเรียนที่พัฒนาค่อนข้างดีและฉันเริ่มออกแบบตรรกะของเกม ฉันใช้หลามและฉันอาจเพิ่ม GUI อย่างง่ายด้วย pygame ในภายหลัง ลำดับการหมุนของผู้เล่นนั้นควบคุมโดยกลไกของรัฐที่ง่ายมาก หมุนตามเข็มนาฬิกาและผู้เล่นไม่สามารถออกจากเกมก่อนที่จะจบ การเล่นของเทิร์นเดี่ยวยังเป็นกลไกของรัฐ โดยทั่วไปผู้เล่นจะผ่าน "ขั้นตอนการกระทำ", "ขั้นตอนการซื้อ" และ "ขั้นตอนการทำความสะอาด" (ตามลำดับ) ตามคำตอบของคำถามวิธีการใช้เอ็นจิ้นเกมเทิร์นเบส เครื่องสถานะเป็นเทคนิคมาตรฐานสำหรับสถานการณ์นี้ ปัญหาของฉันคือในระหว่างขั้นตอนการกระทำของผู้เล่นเธอสามารถใช้การ์ดแอคชั่นที่มีผลข้างเคียงไม่ว่าจะด้วยตัวเองหรือกับผู้เล่นคนอื่นอย่างน้อยหนึ่งคน ตัวอย่างเช่นการ์ดแอคชั่นหนึ่งใบอนุญาตให้ผู้เล่นทำการเลี้ยวที่สองทันทีตามข้อสรุปของเทิร์นปัจจุบัน การ์ดการกระทำอีกใบหนึ่งทำให้ผู้เล่นคนอื่น ๆ ทิ้งการ์ดสองใบจากมือของพวกเขา อีกหนึ่งการ์ดแอคชั่นไม่ทำอะไรเลยสำหรับเทิร์นปัจจุบัน แต่อนุญาตให้ผู้เล่นวาดการ์ดพิเศษในเทิร์นถัดไปของเธอ เพื่อให้สิ่งต่าง ๆ มีความซับซ้อนยิ่งขึ้นมีการขยายเกมใหม่ ๆ เพิ่มการ์ดใหม่บ่อยครั้ง สำหรับฉันแล้วดูเหมือนว่าการเขียนโค้ดผลลัพธ์ของแอ็คชั่นการ์ดทุกใบลงในเครื่องสถานะของเกมจะน่าเกลียดและไม่สามารถปรับเปลี่ยนได้ คำตอบของTurn-based Strategy Loop ไม่เข้าสู่ระดับรายละเอียดที่เน้นการออกแบบเพื่อแก้ไขปัญหานี้ ฉันควรใช้รูปแบบการเขียนโปรแกรมประเภทใดเพื่อครอบคลุมข้อเท็จจริงที่ว่ารูปแบบทั่วไปสำหรับการเลี้ยวสามารถแก้ไขได้ด้วยการกระทำที่เกิดขึ้นภายในเทิร์น? วัตถุของเกมควรติดตามผลของการ์ดทุกใบหรือไม่ หรือหากการ์ดควรใช้เอฟเฟ็กต์ของตนเอง (เช่นโดยใช้อินเทอร์เฟซ) จำเป็นต้องมีการตั้งค่าใดเพื่อให้มีพลังงานเพียงพอ ฉันคิดวิธีแก้ปัญหานี้เล็กน้อย แต่ฉันสงสัยว่ามีวิธีมาตรฐานในการแก้ปัญหาหรือไม่ โดยเฉพาะฉันต้องการทราบว่าวัตถุ / คลาส / อะไรก็ตามที่รับผิดชอบในการติดตามการกระทำที่ผู้เล่นทุกคนจะต้องทำตามผลของการ์ดแอ็คชั่นที่กำลังเล่นและวิธีการที่เกี่ยวข้องกับการเปลี่ยนแปลงชั่วคราวในลำดับปกติของ เครื่องเปลี่ยนสถานะ

19 game-loop  design-patterns  state  turn-based  card-game 

ลองจินตนาการถึงเกมอย่าง Heroes of Might and Magic หรือ Master of Orion หรือเกมเทิร์นเบสที่คุณเลือก ตรรกะของเกมที่อยู่เบื้องหลังการเปิดรอบต่อไปคืออะไร? มีวัสดุหรือหนังสือให้อ่านเกี่ยวกับหัวข้อหรือไม่ โดยเฉพาะลองจินตนาการถึงวงเกม: void eventsHandler(); //something that responds to input void gameLogic(); //something that decides whats going to be output on the screen void render(); //this function outputs stuff on screen สิ่งเหล่านี้จะถูกเรียกว่า 60 ครั้งต่อวินาที แต่วิธีการเลี้ยวเข้ามาที่นี่ได้อย่างไร ฉันอาจจินตนาการว่าใน gameLogic () มีฟังก์ชั่นเช่น …

17 turn-based 

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

15 turn-based 

ฉันกำลังทำงานกับเซิร์ฟเวอร์เกมทั่วไปที่จัดการเกมให้กับไคลเอนต์เครือข่ายซ็อกเก็ต TCP จำนวนหนึ่งที่เล่นเกม ฉันมี 'การออกแบบ' ที่แฮ็คพร้อมกับเทปพันสายไฟที่ใช้งานได้ แต่ดูเหมือนว่าทั้งบอบบางและไม่ยืดหยุ่น มีรูปแบบที่ดีขึ้นสำหรับวิธีการเขียนการสื่อสารลูกค้า / เซิร์ฟเวอร์ที่แข็งแกร่งและยืดหยุ่นหรือไม่? (ถ้าไม่คุณจะปรับปรุงสิ่งที่ฉันมีด้านล่างได้อย่างไร) ประมาณฉันมีสิ่งนี้: ในขณะที่ตั้งค่าเกมเซิร์ฟเวอร์จะมีหนึ่งเธรดสำหรับแต่ละซ็อกเก็ตผู้เล่นที่จัดการคำขอที่ซิงโครนัสจากไคลเอนต์และการตอบสนองจากเซิร์ฟเวอร์ อย่างไรก็ตามเมื่อเกมดำเนินไปเธรดทั้งหมดยกเว้นหนึ่งสลีปและเธรดจะวนไปตามผู้เล่นทุกคนทีละครั้งเพื่อสื่อสารเกี่ยวกับการเคลื่อนไหวของพวกเขา (ในการตอบกลับคำร้องขอ) นี่คือแผนภาพของสิ่งที่ฉันมีอยู่ในปัจจุบัน; คลิกเพื่อดู / รุ่นที่สามารถอ่านได้ที่มีขนาดใหญ่หรือ66kB รูปแบบไฟล์ PDF ปัญหา: มันต้องการให้ผู้เล่นตอบกลับอย่างแม่นยำด้วยข้อความที่ถูกต้อง (ฉันคิดว่าฉันสามารถให้ผู้เล่นแต่ละคนตอบสนองด้วยอึแบบสุ่มและย้ายต่อเมื่อพวกเขาให้การเคลื่อนไหวที่ถูกต้องแก่ฉัน) ไม่อนุญาตให้ผู้เล่นคุยกับเซิร์ฟเวอร์เว้นแต่จะเป็นตาของพวกเขา (ฉันอาจให้เซิร์ฟเวอร์ส่งการอัปเดตเกี่ยวกับผู้เล่นอื่น แต่ไม่สามารถดำเนินการตามคำขอแบบอะซิงโครนัสได้) ข้อกำหนดขั้นสุดท้าย: ประสิทธิภาพไม่สำคัญยิ่ง ส่วนใหญ่จะใช้สำหรับเกมที่ไม่ใช่เรียลไทม์และส่วนใหญ่สำหรับการเจาะ AIs ต่อกันไม่ใช่มนุษย์ที่กระตุก การเล่นเกมจะเป็นแบบเทิร์นเบสเสมอ (แม้ว่าจะมีความละเอียดสูงมาก) ผู้เล่นแต่ละคนจะได้รับการดำเนินการหนึ่งครั้งก่อนที่ผู้เล่นอื่นจะได้รับการเปิด การนำเซิร์ฟเวอร์ไปใช้จะเกิดขึ้นใน Ruby หากสร้างความแตกต่าง

14 networking  server  client-server  state  turn-based 

GKTurnBasedMatch ของ Game Center ดูเหมือนจะให้บริการที่มีประสิทธิภาพในการจัดการเกมเทิร์นเบสและ OpenFeint ดูเหมือนจะมีบางสิ่งที่คล้ายคลึงกัน ปัญหาคือฉันต้องการบางอย่างเช่นนี้สำหรับเดสก์ทอป ฉันกำลังคิดที่จะกลิ้งบริการที่ใช้ REST ของฉันเองบน Rails แต่หลังจากดูที่เอกสารของ GameKit ฉันรู้ว่ามันใช้เวลานานกว่าที่ฉันต้องการจะทำให้มันมั่นคง ฉันไม่คิดว่ามีสิ่งนี้มีอยู่แล้วที่ฉันพลาดในการค้นหา

14 server  turn-based 

เห็นได้ชัดว่าพยายามใช้อัลกอริธึม min-max บนทรีของการย้ายที่สมบูรณ์ใช้ได้กับเกมเล็ก ๆ เท่านั้น (ฉันขอโทษผู้ที่ชื่นชอบการเล่นหมากรุกทุกคนโดย "เล็ก" ฉันไม่ได้หมายถึง "แบบง่าย") สำหรับเกมวางแผนแบบเทิร์นเบสโดยทั่วไปซึ่งบอร์ดมักจะกว้างกว่า 100 แผ่นและทุกชิ้นในด้านสามารถเคลื่อนไหวได้พร้อมกันอัลกอริทึม min-max จะไม่สามารถใช้ได้ ฉันสงสัยว่าอัลกอริธึม min-max บางส่วนที่ จำกัด ตัวเองกับการกำหนดค่า N board ในแต่ละระดับความลึกนั้นไม่ดีพอหรือไม่? การใช้อัลกอริธึมทางพันธุกรรมอาจเป็นไปได้ที่จะหาจำนวนของการกำหนดค่าบอร์ดที่ดีกับฟังก์ชันการประเมินผล หวังว่าการกำหนดค่าเหล่านี้อาจเป็นเป้าหมายที่ดีในระยะยาว ฉันจะแปลกใจถ้านี่ไม่เคยคิดมาก่อนและลอง มันได้หรือไม่ มันทำงานยังไง?

13 ai  turn-based 

จนถึงขณะนี้ระบบส่วนประกอบเอนทิตีที่ฉันใช้เคยทำงานเหมือนอาร์ทิมิสของ Java: ข้อมูลทั้งหมดในส่วนประกอบ ระบบอิสระไร้สัญชาติ (อย่างน้อยถึงระดับที่พวกเขาไม่ต้องการอินพุตในการกำหนดค่าเริ่มต้น) วนซ้ำแต่ละเอนทิตีที่มีเฉพาะส่วนประกอบที่ระบบเฉพาะสนใจ ทุกระบบประมวลผลเอนทิตีของพวกเขาหนึ่งขีดแล้วทุกอย่างก็เริ่มต้นขึ้น ตอนนี้ฉันพยายามที่จะใช้สิ่งนี้กับเกมเทิร์นเบสเป็นครั้งแรกโดยมีเหตุการณ์และคำตอบมากมายที่ต้องเกิดขึ้นตามลำดับที่สัมพันธ์กับแต่ละคนก่อนที่เกมจะสามารถเดินหน้าต่อไปได้ ตัวอย่าง: ผู้เล่น A ได้รับความเสียหายจากดาบ ในการตอบสนองต่อสิ่งนี้เกราะของ A จะเข้ามาและลดความเสียหายที่ได้รับ ความเร็วในการเคลื่อนที่ของ A นั้นลดลงด้วยเช่นกันเนื่องจากความอ่อนแอ ความเสียหายที่ได้รับนั้นเป็นสิ่งที่ทำให้เกิดปฏิสัมพันธ์ทั้งหมด เกราะจะต้องคำนวณและนำไปใช้กับความเสียหายที่เข้ามาก่อนที่ความเสียหายจะถูกนำไปใช้กับผู้เล่น การลดความเร็วในการเคลื่อนที่ไม่สามารถใช้กับยูนิตได้จนกว่าจะได้รับความเสียหายจริง ๆ แล้วเนื่องจากมันขึ้นอยู่กับจำนวนดาเมจสุดท้าย เหตุการณ์ยังสามารถทริกเกอร์เหตุการณ์อื่น ๆ การลดความเสียหายของดาบโดยใช้เกราะสามารถทำให้ดาบแตก (ต้องเกิดขึ้นก่อนที่การลดความเสียหายจะเสร็จสิ้น) ซึ่งจะทำให้เกิดเหตุการณ์เพิ่มเติมในการตอบสนองต่อมัน สรุปทั้งหมดนี้ดูเหมือนจะนำไปสู่ปัญหาเล็กน้อย: วงจรการประมวลผลที่สูญเปล่ามากมาย: ระบบส่วนใหญ่ (บันทึกสำหรับสิ่งต่าง ๆ ที่ทำงานอยู่ตลอดเวลาเช่นการเรนเดอร์) ก็ไม่มีอะไรคุ้มค่าที่จะทำเมื่อมันไม่ใช่ "การเลี้ยว" ในการทำงานและใช้เวลาส่วนใหญ่รอเกม สถานะการทำงานที่ถูกต้อง litters นี้ทุกระบบดังกล่าวด้วยการตรวจสอบที่มีการเติบโตในขนาดที่รัฐเพิ่มเติมจะถูกเพิ่มเข้าไปในเกม ในการตรวจสอบว่าระบบสามารถประมวลผลเอนทิตีที่มีอยู่ในเกมได้หรือไม่พวกเขาต้องการวิธีในการตรวจสอบสถานะเอนทิตี / ระบบอื่น ๆ ที่ไม่เกี่ยวข้อง (ระบบที่รับผิดชอบในการจัดการความเสียหายจำเป็นต้องรู้ว่ามีการใช้เกราะหรือไม่) นี่อาจทำให้ระบบยุ่งเหยิงด้วยความรับผิดชอบหลายอย่างหรือสร้างความต้องการระบบเพิ่มเติมโดยไม่มีจุดประสงค์อื่น แต่เพื่อสแกนคอลเล็กชั่นเอนทิตีหลังจากแต่ละรอบการประมวลผลและสื่อสารกับกลุ่มผู้ฟังโดยบอกพวกเขาเมื่อมันไม่เป็นไร จุดสองจุดด้านบนสมมติว่าระบบทำงานบนเอนทิตีชุดเดียวกันซึ่งจบลงด้วยการเปลี่ยนสถานะโดยใช้แฟล็กในส่วนประกอบ อีกวิธีในการแก้ปัญหาก็คือการเพิ่ม …

9 turn-based  entity 

คุณจัดการกับการแยกอนิเมชั่นจากสภาวะโลกในเกมที่มีการเปิดได้อย่างไร? ฉันกำลังทำงานกับเกม 2D กริดในปัจจุบัน โค้ดด้านล่างนี้ง่ายต่อการอธิบายได้ดีขึ้น เมื่อนักแสดงเคลื่อนไหวฉันต้องการที่จะหยุดการไหลของการหมุนในขณะที่สิ่งมีชีวิตเคลื่อนไหวและย้ายไปยังตำแหน่งใหม่ มิฉะนั้นหน้าจออาจล้าหลังสถานะโลกอย่างมีนัยสำคัญซึ่งอาจทำให้เกิดรูปลักษณ์ที่แปลกประหลาด ฉันต้องการมีภาพเคลื่อนไหวที่ไม่ปิดกั้นการไหลของเกม - เอฟเฟกต์ของอนุภาคสามารถเปิดออกได้หลายรอบโดยไม่ส่งผลต่อการเล่นเกม สิ่งที่ฉันทำคือแนะนำภาพเคลื่อนไหวสองประเภทซึ่งฉันเรียกว่าการปิดกั้นภาพเคลื่อนไหวและภาพเคลื่อนไหวที่ไม่ปิดกั้น เมื่อผู้เล่นต้องการย้ายรหัสที่ถูกเรียกใช้งานคือ class Actor { void move(PositionInfo oldPosition, PositionInfo newPosition) { if(isValidMove(oldPosition, newPosition) { getGame().pushBlockingAnimation(new MoveAnimation(this, oldPosition, newPosition, ....)); player.setPosition(newPosition); } } } จากนั้นห่วงการอัพเดทหลักจะ: class Game { void update(float dt) { updateNonBlockingAnimations(dt); //Effects like particle explosions, damage numbers, etc. Things …

9 java  animation  turn-based 

ขณะนี้ฉันกำลังเขียนโปรแกรมเกม iPhone และฉันต้องการสร้างโหมดผู้เล่นหลายคนออนไลน์ ในอนาคตแอพนี้จะเป็นพอร์ตไปยังอุปกรณ์ Android ดังนั้นฉันสงสัยว่าจะสร้างเซิร์ฟเวอร์เกมได้อย่างไร? ก่อนอื่นเลยฉันควรเลือกภาษาใด วิธีการทำให้เซิร์ฟเวอร์สามารถสื่อสารทั้งสองกับโปรแกรมที่เขียนในวัตถุประสงค์ -c และ Java? จากนั้นจะทำอย่างไรให้มีประสิทธิภาพ มันจะดีถ้าฉันเปิดซ็อกเก็ตโดยลูกค้า (จะมี 2)? ฉันควรส่งข้อมูลประเภทใดไปยังเซิร์ฟเวอร์ ให้กับลูกค้าหรือไม่

9 iphone  android  server  client-server  turn-based 

หากคุณใช้เกมอาร์พีจีเทิร์นใดก็ตามจะมีช่วงเวลาที่ยาวนานเมื่อไม่มีอะไรเกิดขึ้นเพราะเกมดังกล่าววนลูปมากกว่า 'wait_for_player_input' ดูเหมือนเป็นเรื่องสมเหตุสมผลที่จะใช้เวลานี้เพื่ออัปเดตสิ่งต่าง ๆ อย่างไรก็ตามสิ่งนี้ดูเหมือนจะแนะนำทันทีว่าจะต้องมีเธรด การออกแบบแบบนี้มีความเป็นไปได้ไหมในเธรดเดี่ยว? loop: if not check_something_pressed: update_a_very_small_amount else keep going แต่ถ้าเราบอกว่า 'a_very_small_amount' เป็นเพียงการอัปเดตวัตถุชิ้นเดียวในแต่ละลูปมันจะช้ามากในการอัปเดต คุณจะไปเกี่ยวกับเรื่องนี้โดยเฉพาะอย่างยิ่งในหัวข้อเดียวหรือไม่ แก้ไข: ฉันติดแท็กผู้ไม่เชื่อเรื่องภาษานี้เนื่องจากดูเหมือนว่าเป็นสิ่งที่สมเหตุสมผลแม้ว่าสิ่งใดที่เฉพาะเจาะจงกับงูหลามก็จะยิ่งใหญ่ ;-) การแก้ไขครั้งที่สอง: เกมนี้ไม่ได้วางแผนที่จะมีองค์ประกอบแบบเคลื่อนไหว นั่นคือตอนนี้ฉันกำลังใช้งานมันเพื่อรอให้ผู้เล่นป้อนข้อมูลแล้วอัปเดตทุกอย่างแล้ววาด ดังนั้นแทนที่จะเป็น X FPS มันขึ้นอยู่กับความเร็วของผู้ใช้

9 architecture  game-loop  rpg  turn-based