คำถามติดแท็ก architecture

http://www.sdltutorials.com/sdl-opengl-tutorial-basics http://www.opengl-tutorial.org/beginners-tutorials/tutorial-2-the-first-triangle/ บทเรียนสองบทนี้ใช้วิธีการต่างกันโดยสิ้นเชิงเพื่อให้ได้ผลลัพธ์ที่ใกล้เคียงกัน แรก ๆ glBegin(GL_QUADS)ที่ใช้สิ่งที่ต้องการ อันที่สองใช้สิ่งที่ชอบvertexBufferObjectsshaders ตาม GLEW แต่ผลลัพธ์ก็เหมือนกัน: คุณจะได้รูปร่างพื้นฐาน ทำไมความแตกต่างเหล่านี้จึงมีอยู่? วิธีแรกดูเหมือนง่ายกว่าที่จะเข้าใจ ข้อดีของวิธีที่สองที่ซับซ้อนคืออะไร

43 opengl  architecture 

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

42 architecture  open-source 

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

41 architecture  databases  text-based  content-generation  dialog-tree 

ฉันมีเกมป้องกันหอคอยพื้นฐาน 2 มิติใน C ++ แต่ละแผนที่เป็นคลาสที่แยกต่างหากซึ่งสืบทอดมาจาก GameState แผนที่จะมอบหมายตรรกะและรหัสการวาดภาพให้กับแต่ละวัตถุในเกมและตั้งค่าข้อมูลเช่นเส้นทางแผนที่ ในโค้ดหลอกส่วนลอจิกอาจมีลักษณะดังนี้: update(): for each creep in creeps: creep.update() for each tower in towers: tower.update() for each missile in missiles: missile.update() วัตถุ (ครีพหอคอยและขีปนาวุธ) ถูกเก็บไว้ในพอยน์เตอร์พอยน์เตอร์ หอคอยต้องมีการเข้าถึง vector-of-creeps และ vector-of-missiles เพื่อสร้างขีปนาวุธใหม่และระบุเป้าหมาย คำถามคือ: ฉันจะประกาศเวกเตอร์ได้ที่ไหน พวกเขาควรเป็นสมาชิกของคลาส Map หรือไม่และส่งผ่านเป็นอาร์กิวเมนต์ไปยังฟังก์ชัน tower.update ()? หรือประกาศทั่วโลก? หรือมีวิธีแก้ไขปัญหาอื่น ๆ ที่ฉันขาดไปทั้งหมดหรือไม่ เมื่อหลาย ๆ คลาสจำเป็นต้องเข้าถึงข้อมูลเดียวกันข้อมูลจะถูกประกาศที่ไหน?

38 c++  architecture  game-loop 

ฉันชอบฟีเจอร์ OOP เมื่อพัฒนาเกมด้วย Unity ฉันมักจะสร้างคลาสพื้นฐาน (ส่วนใหญ่เป็นนามธรรม) และใช้การสืบทอดวัตถุเพื่อแบ่งปันฟังก์ชันการทำงานเดียวกันกับวัตถุอื่น ๆ อย่างไรก็ตามฉันเพิ่งได้ยินจากคนที่ใช้การสืบทอดต้องหลีกเลี่ยงและเราควรใช้อินเทอร์เฟซแทน ดังนั้นฉันจึงถามว่าทำไมและเขาบอกว่า "การสืบทอดวัตถุมีความสำคัญแน่นอน แต่ถ้ามีวัตถุเพิ่มเติมจำนวนมากความสัมพันธ์ระหว่างชั้นเรียนจะถูกเชื่อมโยงกันอย่างลึกซึ้ง ฉันใช้คลาสเบสที่เป็นนามธรรมบางอย่างเช่นWeaponBaseและสร้างคลาสอาวุธที่เฉพาะเจาะจงเช่นShotgunนั้นAssaultRifleเป็นMachinegunอย่างนั้น มีข้อดีมากมายและรูปแบบเดียวที่ฉันชอบคือความแตกต่าง ฉันสามารถปฏิบัติต่อวัตถุที่สร้างโดยคลาสย่อยราวกับว่าพวกเขาเป็นคลาสพื้นฐานเพื่อให้ตรรกะสามารถลดลงอย่างมากและทำให้สามารถนำมาใช้ซ้ำได้มากขึ้น หากฉันต้องการเข้าถึงฟิลด์หรือวิธีการของคลาสย่อยฉันจะส่งกลับไปยังคลาสย่อย ฉันไม่ต้องการที่จะกำหนดเขตข้อมูลเดียวกันที่นิยมใช้ในการเรียนแตกต่างกันเช่นAudioSource/ Rigidbody/ Animatorและจำนวนมากของเขตข้อมูลสมาชิกฉันที่กำหนดไว้เช่นfireRate, damage, range, spreadและอื่น ๆ ในบางกรณีวิธีการบางอย่างอาจถูกเขียนทับ ดังนั้นฉันใช้วิธีเสมือนในกรณีนั้นโดยทั่วไปฉันสามารถเรียกใช้วิธีนั้นโดยใช้วิธีการจากคลาสผู้ปกครอง แต่ถ้าตรรกะควรจะแตกต่างกันในเด็กฉันได้แทนที่พวกเขาด้วยตนเอง ดังนั้นสิ่งเหล่านี้ทั้งหมดควรถูกทอดทิ้งเป็นการปฏิบัติที่ไม่ดี? ฉันควรใช้อินเทอร์เฟซแทนหรือไม่

36 unity  architecture  oop 

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

33 architecture  algorithm  simulations  scalability 

เมื่อเขียนเกมใน C # ที่ใช้ Windows Forms แบบเก่าและกราฟิก API wrapper บางอย่างเช่นSlimDXหรือOpenTKเกมหลักจะต้องมีโครงสร้างอย่างไร แอปพลิเคชันแบบฟอร์มมาตรฐานของ Windows มีจุดเข้าใช้ที่มีลักษณะดังนี้ public static void Main () { Application.Run(new MainForm()); } และในขณะที่บางคนสามารถบรรลุสิ่งที่จำเป็นโดยการเชื่อมโยงเหตุการณ์ต่าง ๆ ของFormชั้นเรียนเหตุการณ์เหล่านั้นไม่ได้ให้สถานที่ที่ชัดเจนในการวางบิตของรหัสเพื่อดำเนินการปรับปรุงเป็นระยะเพื่อวัตถุตรรกะของเกมหรือเริ่มและสิ้นสุดการเรนเดอร์ กรอบ เทคนิคใดที่เกมดังกล่าวควรใช้เพื่อให้ได้สิ่งที่คล้ายกับบัญญัติ while(!done) { update(); render(); } ลูปเกมและจะทำอย่างไรกับประสิทธิภาพที่น้อยที่สุดและผลกระทบ GC?

32 c#  architecture  game-loop  windows-forms 

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

31 architecture 

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

30 architecture  state 

ฉันเพิ่งเริ่มได้รับการออกแบบตามส่วนประกอบ ผมไม่ทราบว่าสิ่งที่เป็น"สิทธิ"วิธีที่จะทำเช่นนี้คือ นี่คือสถานการณ์ ผู้เล่นสามารถใส่เกราะ โล่ถูกวาดเป็นฟองรอบผู้เล่นมันมีรูปร่างการชนที่แยกจากกันและลดความเสียหายที่ผู้เล่นได้รับจากเอฟเฟกต์ในพื้นที่ การหุ้มเกราะนั้นได้รับการออกแบบในเกมที่มีส่วนประกอบเป็นอย่างไร ที่ที่ฉันสับสนคือโล่มีส่วนประกอบสามอย่างที่เกี่ยวข้อง ลดความเสียหาย / กรอง สไปรต์ Collider เพื่อทำให้ความแตกต่างของเกราะที่แย่ลงอาจมีพฤติกรรมมากขึ้นซึ่งทั้งหมดอาจเป็นส่วนประกอบ: เพิ่มสุขภาพสูงสุดของผู้เล่น สุขภาพ regen การโก่งกระสุน ฯลฯ ฉันคิดอย่างนี้ไหม โล่ควรเป็นเพียงองค์ประกอบที่ยอดเยี่ยมหรือไม่ ฉันคิดว่านี่เป็นคำตอบที่ผิด ดังนั้นหากคุณคิดว่านี่เป็นวิธีที่จะไปกรุณาอธิบาย โล่ควรเป็นนิติบุคคลของตัวเองที่ติดตามตำแหน่งของผู้เล่นหรือไม่? นั่นอาจทำให้ยากต่อการใช้การกรองความเสียหาย นอกจากนี้ยังทำให้เส้นแบ่งระหว่างส่วนประกอบที่แนบกับเอนทิตี โล่ควรเป็นส่วนประกอบที่มีส่วนประกอบอื่นหรือไม่? ฉันไม่เคยเห็นหรือได้ยินอะไรแบบนี้ แต่อาจเป็นเรื่องปกติและฉันก็ยังไม่ลึกพอ โล่ควรเป็นชุดของส่วนประกอบที่เพิ่มเข้ากับเครื่องเล่นหรือไม่ อาจเป็นไปได้ที่จะมีองค์ประกอบพิเศษในการจัดการอื่น ๆ เช่นพวกเขาสามารถลบออกเป็นกลุ่ม (ทิ้งไว้เบื้องหลังองค์ประกอบการลดความเสียหายโดยไม่ตั้งใจตอนนี้น่าสนุก) มีอะไรอีกที่เห็นได้ชัดสำหรับคนที่มีประสบการณ์ด้านส่วนประกอบมากกว่าใช่ไหม

29 architecture  component-based  entity-system 

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

28 architecture 

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

28 architecture  algorithm 

ฉันมีคำถามเกี่ยวกับสถาปัตยกรรมเกม: วิธีที่ดีที่สุดในการสื่อสารด้วยส่วนประกอบต่าง ๆ กันคืออะไร? ฉันขอโทษจริง ๆ ถ้าคำถามนี้ถูกถามไปแล้วนับล้านครั้ง แต่ฉันไม่สามารถหาข้อมูลใด ๆ ที่ฉันต้องการได้ ฉันพยายามสร้างเกมตั้งแต่เริ่มต้น (C ++ ถ้าเป็นเรื่องสำคัญ) และได้สังเกตซอฟต์แวร์เกมโอเพ่นซอร์สเพื่อเป็นแรงบันดาลใจ (Super Maryo Chronicles, OpenTTD และอื่น ๆ ) ฉันสังเกตเห็นว่าการออกแบบเกมเหล่านี้จำนวนมากใช้อินสแตนซ์ระดับโลกและ / หรือซิงเกิลตันทั่วสถานที่ (สำหรับสิ่งต่าง ๆ เช่นการเรนเดอร์คิวผู้จัดการเอนทิตีผู้จัดการวิดีโอและอื่น ๆ ) ฉันพยายามหลีกเลี่ยงอินสแตนซ์ระดับโลกและซิงเกิลตันและสร้างเครื่องยนต์ที่มีการเชื่อมโยงอย่างหลวม ๆ เท่าที่จะเป็นไปได้ แต่ฉันตีสิ่งกีดขวางบางอย่าง (ส่วนหนึ่งของแรงจูงใจสำหรับโครงการนี้คือการแก้ไขปัญหานี้ :)) ฉันได้สร้างการออกแบบที่มีGameCoreวัตถุหลักหนึ่งชิ้นที่มีสมาชิกที่คล้ายกับอินสแตนซ์ทั่วโลกที่ฉันเห็นในโครงการอื่น ๆ (เช่นมีตัวจัดการอินพุตผู้จัดการวิดีโอวิดีโอGameStageวัตถุที่ควบคุมเอนทิตีและการเล่นเกมทั้งหมด สำหรับขั้นตอนใดก็ตามที่โหลดอยู่ ฯลฯ ) ปัญหาคือเนื่องจากทุกอย่างรวมอยู่ในGameCoreวัตถุฉันไม่มีวิธีง่าย ๆ สำหรับส่วนประกอบต่าง ๆ ในการสื่อสารซึ่งกันและกัน ยกตัวอย่างเช่นเมื่อมองจาก Super Maryo …

28 c++  architecture 

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

26 architecture  networking  performance  mmo 

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

26 architecture  rpg