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

ฉันกำลังคิดเกี่ยวกับวิธีใช้สถานะเกมในเกมของฉัน สิ่งสำคัญที่ฉันต้องการคือ: รัฐชั้นนำกึ่งโปร่งใสสามารถดูผ่านเมนูหยุดชั่วคราวเพื่อเกมที่อยู่เบื้องหลัง บางสิ่งบางอย่าง OO- ฉันพบว่าการใช้และเข้าใจทฤษฎีนี้ง่ายขึ้นรวมถึงการรักษาองค์กรและการเพิ่มมากขึ้น ฉันวางแผนที่จะใช้รายการที่เชื่อมโยงและถือว่าเป็นสแต็ก ซึ่งหมายความว่าฉันสามารถเข้าถึงสถานะด้านล่างเพื่อความโปร่งใสกึ่ง แผน: ให้สถานะสแต็กเป็นรายการเชื่อมโยงของตัวชี้ไปยัง IGameStates สถานะบนสุดจะจัดการคำสั่งอัพเดตและอินพุตของตัวเองจากนั้นมีสมาชิก isTransparent เพื่อตัดสินใจว่าควรดึงสถานะที่อยู่ภายใต้ จากนั้นฉันก็ทำได้: states.push_back(new MainMenuState()); states.push_back(new OptionsMenuState()); states.pop_front(); เพื่อเป็นตัวแทนของผู้เล่นที่โหลดจากนั้นไปที่ตัวเลือกแล้วเมนูหลัก นี่เป็นความคิดที่ดีหรือ ... ฉันควรมองอย่างอื่นไหม ขอบคุณ

52 c++  architecture  state 

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

30 architecture  state 

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

24 state 

http://altdevblogaday.org/2011/02/24/introduction-to-behavior-trees/ เห็นได้ชัดว่าบทความที่น่าสนใจที่สุดที่ฉันพบในเว็บไซต์นี้ คุณคิดยังไงกับเรื่องนี้? มันไม่มีตัวอย่างโค้ดคุณไม่รู้หรือไม่? ฉันยังอ่านว่าสภาพเครื่องจักรไม่ยืดหยุ่นมากเมื่อเทียบกับแผนผังพฤติกรรม ... ด้านบนฉันไม่แน่ใจว่ามีการเชื่อมโยงระหว่างเครื่องรัฐและรูปแบบของรัฐจริงหรือไม่?

23 ai  state  tree  behavior 

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

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

ดังนั้นฉันจึงได้เล่น Mass Effect 2 (PC) และหนึ่งในสิ่งที่ฉันสังเกตเห็นคือคุณสามารถบันทึกเกมของคุณเมื่อคุณไม่ได้มีส่วนร่วมในการต่อสู้เท่านั้น ทันทีที่ศัตรูตัวแรกปรากฏขึ้นบนเรดาร์ของคุณปุ่มบันทึกจะถูกปิดใช้งาน เมื่อการต่อสู้จบลงแล้วให้บันทึกการทำงานอีกครั้ง ดูเหมือนว่ามีเหตุผลที่จะสมมติว่า Mass Effect 2 เป็นเครื่องรัฐและดังนั้นสถานะภายในของโปรแกรมในเวลาใด ๆ สามารถจับภาพและโหลดใหม่ได้ในภายหลัง นี่เป็นปัญหาที่แก้ไขได้ - เกมได้รับการออกแบบมาตั้งแต่ยุคครึ่งชีวิต ดูเหมือนว่าสมเหตุสมผลที่จะถือว่า BioWare รู้ว่าพวกเขาทำอะไรเมื่อตัดสินใจที่จะไม่ทำตามแบบจำลองนี้ - มันเป็นระบบที่พยายามและเป็นจริง BioWare จะไม่ทำอย่างที่พวกเขาทำโดยไม่มีเหตุผลที่ดี เหตุผลอะไรที่จะปิดการใช้งานฟังก์ชั่นบันทึกเกมระหว่างการต่อสู้?

19 game-mechanics  state 

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

16 component-based  entity-system  input  state 

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

16 c++  architecture  software-engineering  game-loop  state 

แก้ไข: เพื่อให้ชัดเจนว่าคำถามของฉันคืออะไร: นี่เป็นวิธีที่ดีในการจัดการภาพเคลื่อนไหว / สถานะภาพเคลื่อนไหวในเอ็นจิ้นเกมด้วยตาการสร้าง / การจัดการเนื้อหาหรือไม่ อะไรคือข้อบกพร่องในการทำเช่นนี้และสิ่งที่จะเป็นทางเลือกในการทำเช่นนั้น? - แม้ว่าคำตอบของฉันจะได้รับคำตอบบางส่วนในความคิดเห็นเพราะมันเป็นหนทางไป ฉันพยายามจัดการกับอนิเมชั่นในโปรเจ็กต์เกมเอนจิ้น 2Dโดยไม่ต้องเข้ารหัสให้ยุ่งยาก สถานะภาพเคลื่อนไหวที่เข้ารหัสยากดูเหมือนว่าจะเป็นปรากฏการณ์ธรรมดา แต่แปลกมากสำหรับฉัน พื้นหลังเล็กน้อย: ฉันกำลังทำงานกับระบบเอนทิตีที่ส่วนประกอบคือถุงของข้อมูลและระบบย่อยทำหน้าที่แทนพวกเขา ฉันเลือกที่จะใช้ระบบการลงคะแนนเพื่ออัพเดทสถานะภาพเคลื่อนไหว ด้วยสถานะภาพเคลื่อนไหวฉันหมายถึง: "walking_left", "running_left", "walking_right", "shooting", ... ความคิดของฉันเพื่อภาพเคลื่อนไหวที่จับคือการออกแบบเป็นรูปแบบข้อมูลที่ขับเคลื่อนด้วย ข้อมูลสามารถเก็บไว้ในไฟล์ xml, rdbms, ... และสามารถโหลดได้ตั้งแต่เริ่มเกม / ระดับ / ... วิธีนี้คุณสามารถแก้ไขภาพเคลื่อนไหวและช่วงการเปลี่ยนภาพได้อย่างง่ายดายโดยไม่ต้องเปลี่ยนรหัสทุกที่ในตัวคุณ เกม. ตัวอย่างเช่นฉันสร้างร่าง xml ของคำจำกัดความข้อมูลที่ฉันมีอยู่ในใจ ชิ้นหนึ่งที่สำคัญมากของข้อมูลก็จะเป็นรายละเอียดของภาพเคลื่อนไหว ภาพเคลื่อนไหวจะมีรหัสเฉพาะ (ชื่อที่สื่อความหมาย) มันจะถือ id อ้างอิงไปยังภาพ (แผ่นงานสไปรท์ที่ใช้เพราะภาพเคลื่อนไหวที่แตกต่างกันอาจใช้แผ่นงานสไปรต์ที่แตกต่างกัน) เฟรมต่อวินาทีเพื่อเปิดภาพเคลื่อนไหว "เล่นซ้ำ" ที่นี่กำหนดว่าควรจะเรียกใช้ภาพเคลื่อนไหวหนึ่งครั้งหรือไม่สิ้นสุด จากนั้นฉันกำหนดรายการสี่เหลี่ยมเป็นเฟรม <animation …

14 animation  state  fsm 

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

14 networking  server  client-server  state  turn-based 

วิธีหรืออัลกอริทึมที่ใช้มากที่สุดสำหรับการบันทึกสถานะของเกม (โปรไฟล์), ไฟล์ข้อความฐานข้อมูลจะมีวิธีการเข้ารหัสและสิ่งที่เกี่ยวข้องได้อย่างไร ฉันเห็น Caesar IV ใช้ mySQL ข้อเสนอแนะใด ๆ

12 state 

ฉันทำเกมที่ออกแบบมาพร้อมกับกระบวนทัศน์นิติบุคคลองค์ประกอบว่าระบบที่ใช้ในการติดต่อสื่อสารระหว่างส่วนประกอบตามที่อธิบายไว้ที่นี่ ฉันได้มาถึงจุดในการพัฒนาของฉันที่ฉันต้องเพิ่มรัฐเกม (เช่นหยุดเล่นระดับเริ่มต้นรอบเริ่มเกมมากกว่า ฯลฯ ) แต่ฉันไม่แน่ใจว่าจะทำอย่างไรกับกรอบของฉัน ฉันได้ดูตัวอย่างโค้ดนี้ในสถานะเกมที่ทุกคนดูเหมือนจะอ้างอิง แต่ฉันคิดว่ามันไม่เหมาะกับกรอบงานของฉัน ดูเหมือนว่าแต่ละรัฐจัดการรูปวาดของตนเองและปรับปรุง เฟรมเวิร์กของฉันมี SystemManager ที่จัดการการอัพเดตทั้งหมดโดยใช้ระบบ ตัวอย่างเช่นนี่คือคลาส RenderingSystem ของฉัน: public class RenderingSystem extends GameSystem { private GameView gameView_; /** * Constructor * Creates a new RenderingSystem. * @param gameManager The game manager. Used to get the game components. */ public RenderingSystem(GameManager gameManager) { super(gameManager); …

11 architecture  component-based  entity-system  state 

ฉันกำลังพยายามออกแบบระบบเอนทิตีที่อิงองค์ประกอบเพื่อการเรียนรู้ (และใช้ในภายหลังในบางเกม) และฉันมีปัญหาบางอย่างเมื่อต้องอัพเดตสถานะเอนทิตี ฉันไม่ต้องการให้มีการอัปเดตวิธี () ภายในคอมโพเนนต์เพื่อป้องกันการพึ่งพาระหว่างคอมโพเนนต์ สิ่งที่ฉันมีอยู่ในใจในขณะนี้คือส่วนประกอบเก็บข้อมูลและส่วนประกอบการปรับปรุงระบบ ดังนั้นถ้าฉันมีเกม 2D ง่าย ๆ ที่มีบางหน่วยงาน (เช่นผู้เล่น, ศัตรู 1, ศัตรู 2) ที่มีองค์ประกอบการแปลง, การเคลื่อนไหว, สถานะ, ภาพเคลื่อนไหวและการแสดงผลฉันคิดว่าฉันควรจะมี: MovementSystem ที่จะทำการเคลื่อนย้ายส่วนประกอบการเคลื่อนไหวทั้งหมดและอัพเดทส่วนประกอบของรัฐ และ RenderSystem ที่อัพเดทองค์ประกอบภาพเคลื่อนไหว (องค์ประกอบภาพเคลื่อนไหวควรมีภาพเคลื่อนไหวหนึ่งภาพ (เช่นชุดของเฟรม / พื้นผิว) สำหรับแต่ละรัฐและอัปเดตหมายถึงการเลือกภาพเคลื่อนไหวที่สอดคล้องกับสถานะปัจจุบัน (เช่นการกระโดด, moving_left ฯลฯ ) และ อัปเดตดัชนีเฟรม) จากนั้น RenderSystem จะอัปเดตส่วนประกอบ Render ด้วยพื้นผิวที่สอดคล้องกับเฟรมปัจจุบันของ Animation ของแต่ละกิจการและแสดงทุกอย่างบนหน้าจอ ฉันเห็นการใช้งานบางอย่างเช่นกรอบงานของ Artemis แต่ฉันไม่รู้วิธีแก้ปัญหานี้: สมมติว่าเกมของฉันมีเอนทิตีต่อไปนี้ แต่ละเอนทิตีมีชุดสถานะและภาพเคลื่อนไหวหนึ่งรายการสำหรับแต่ละสถานะ: ผู้เล่น: …

10 animation  entity-system  component-based  state 

คุณจะเก็บสถานะเกมของคุณไว้ที่ทางออกสำหรับเกม iPhone ที่เขียนใน Objective-C ได้อย่างไร

10 iphone  objective-c  state 

ฉันมีปัญหาในการหาวิธีจัดการกับการจัดการของรัฐในหน่วยงานของฉัน ฉันไม่ได้มีปัญหากับการจัดการสถานะของเกมเช่นหยุดชั่วคราวและเมนูเนื่องจากสิ่งเหล่านี้ไม่ได้รับการจัดการเป็นระบบส่วนประกอบเอนทิตี เพียงแค่มีสถานะในหน่วยงาน / ส่วนประกอบ ภาพวาดจาก Orcs Must Die เป็นตัวอย่างฉันมีตัวหลักและตัวดักของฉันซึ่งมีส่วนประกอบของพวกเขาเช่น PositionComponent, RenderComponent, PhysicsComponent เท่านั้น ในการอัพเดทแต่ละครั้งเอนทิตีจะเรียกการอัพเดทบนส่วนประกอบของมัน ฉันยังมี EventManager สามัญพร้อมฟังสำหรับประเภทเหตุการณ์ที่แตกต่างกัน ตอนนี้ฉันต้องสามารถวางกับดักได้: ก่อนอื่นเลือกตำแหน่งกับดักและกับดักจากนั้นจึงวางกับดัก เมื่อวางกับดักมันควรจะปรากฏขึ้นที่ด้านหน้าของตัวละครหลักที่แสดงในรูปแบบที่แตกต่างกันและติดตามมันไปรอบ ๆ เมื่อวางไว้ก็ควรตอบสนองต่อการชนและแสดงผลตามปกติ สิ่งนี้จัดการได้อย่างไรในระบบที่ใช้ส่วนประกอบเป็นหลัก (ตัวอย่างนี้เป็นแบบเฉพาะ แต่สามารถช่วยหาวิธีทั่วไปในการจัดการกับสถานะเอนทิตี)

9 component-based  state