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

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

20 architecture  entity-system  component-based 

ฉันใช้เวลา 48 ชั่วโมงในการอ่านข้อมูลเกี่ยวกับระบบ Object Component และรู้สึกว่าฉันพร้อมที่จะเริ่มนำไปใช้งานแล้ว ฉันได้รับคลาส Object และ Component พื้นฐานแล้ว แต่ตอนนี้ฉันต้องเริ่มสร้างส่วนประกอบจริงฉันสับสนเล็กน้อย เมื่อฉันนึกถึงพวกเขาในแง่ของ HealthComponent หรืออะไรบางอย่างที่โดยพื้นฐานแล้วจะเป็นเพียงแค่คุณสมบัติมันก็สมเหตุสมผลดี เมื่อมันเป็นเรื่องทั่วไปมากขึ้นในส่วนของฟิสิกส์ / กราฟิกฉันสับสนเล็กน้อย คลาส Object ของฉันมีลักษณะเช่นนี้จนถึงตอนนี้ (หากคุณสังเกตเห็นการเปลี่ยนแปลงใด ๆ ที่ฉันควรทำโปรดแจ้งให้เราทราบยังใหม่ต่อเรื่องนี้) ... typedef unsigned int ID; class GameObject { public: GameObject(ID id, Ogre::String name = ""); ~GameObject(); ID &getID(); Ogre::String &getName(); virtual void update() = 0; // …

19 architecture  physics  graphics  component-based  game-component 

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

16 component-based  entity-system  input  state 

นี่คือการติดตามคำถามนี้ซึ่งฉันตอบไป แต่สิ่งนี้จะจัดการกับหัวข้อที่เฉพาะเจาะจงมากขึ้น คำตอบนี้ช่วยให้ฉันเข้าใจระบบ Entity ได้ดีกว่าบทความ ฉันได้อ่าน(ใช่แล้ว) บทความเกี่ยวกับระบบ Entity และมันบอกฉันต่อไปนี้: เอนทิตีเป็นเพียง id และอาร์เรย์ของส่วนประกอบ (บทความบอกว่าการเก็บเอนทิตีในส่วนประกอบไม่ใช่วิธีที่ดีในการทำสิ่งต่าง ๆ แต่ไม่มีทางเลือกอื่น) ส่วนประกอบคือชิ้นส่วนของข้อมูลที่บ่งบอกถึงสิ่งที่สามารถทำได้กับเอนทิตีที่แน่นอน ระบบคือ "วิธีการ" พวกเขาทำการจัดการข้อมูลกับเอนทิตี ดูเหมือนว่าจะใช้งานได้จริงในหลาย ๆ สถานการณ์ แต่ส่วนที่เกี่ยวกับส่วนประกอบที่เป็นเพียงคลาสข้อมูลกำลังรบกวนฉัน ตัวอย่างเช่นฉันจะใช้คลาส Vector2D ของฉัน (ตำแหน่ง) ในระบบกิจการได้อย่างไร ชั้น Vector2D เก็บข้อมูล: พิกัด x และ y แต่ก็มีวิธีการซึ่งมีความสำคัญต่อความมีประโยชน์และแยกความแตกต่างของชั้นเรียนจากเพียงแค่องค์ประกอบสองแถว วิธีการตัวอย่างเช่น: add(), rotate(point, r, angle), substract(), normalize()และมาตรฐานอื่น ๆ ที่มีประโยชน์และจำเป็นอย่างยิ่งวิธีการที่ตำแหน่ง (ซึ่งเป็นกรณีของชั้น Vector2D) ควรจะมี หากองค์ประกอบนั้นเป็นเพียงตัวยึดข้อมูลมันจะไม่สามารถมีวิธีการเหล่านี้ได้! ทางออกหนึ่งที่อาจปรากฏขึ้นก็คือการใช้พวกเขาภายในระบบ …

16 entity-system  component-based 

ฉันกำลังเขียนปืน (เช่น 1942, กราฟิก 2D แบบคลาสสิก) และฉันต้องการใช้การอนุมัติตามส่วนประกอบ จนถึงตอนนี้ฉันคิดถึงการออกแบบต่อไปนี้: องค์ประกอบแต่ละเกม (เรือเหาะขีปนาวุธเพิ่มพลังศัตรู) เป็นเอนทิตี แต่ละหน่วยงานคือชุดของส่วนประกอบที่สามารถเพิ่มหรือลบได้ในเวลาทำงาน ตัวอย่างเช่นตำแหน่ง, Sprite, Health, IA, Damage, BoundingBox เป็นต้น แนวคิดคือ Airship, Projectile, Enemy, Powerup ไม่ใช่คลาสเกม เอนทิตีถูกกำหนดโดยส่วนประกอบที่เป็นเจ้าของเท่านั้น (และสามารถเปลี่ยนแปลงได้ในช่วงเวลา) ดังนั้นผู้เล่นเรือเหาะเริ่มต้นด้วย Sprite, ตำแหน่ง, สุขภาพและส่วนประกอบอินพุต Powerup มี Sprite, Position, BoundingBox และอื่น ๆ หลักวนรอบจัดการเกม "ฟิสิกส์" นั่นคือส่วนประกอบต่าง ๆ มีปฏิสัมพันธ์กันอย่างไร: foreach(entity (let it be entity1) with a …

16 c++  design-patterns  component-based 

ฉันกำลังพยายามทำให้การออกแบบเอนทิตีอิงองค์ประกอบ ขั้นตอนแรกของฉันคือการสร้างส่วนประกอบต่าง ๆ ที่สามารถเพิ่มไปยังวัตถุ สำหรับส่วนประกอบทุกประเภทที่ฉันมีผู้จัดการซึ่งจะเรียกฟังก์ชั่นการอัพเดทของทุกองค์ประกอบผ่านสิ่งต่าง ๆ เช่นสถานะแป้นพิมพ์ ฯลฯ ตามต้องการ สิ่งต่อไปที่ฉันทำคือลบวัตถุออกและมีส่วนประกอบแต่ละอันที่มีรหัส ดังนั้นวัตถุจะถูกกำหนดโดยส่วนประกอบที่มีรหัสเดียวกัน ตอนนี้ฉันกำลังคิดว่าฉันไม่ต้องการผู้จัดการสำหรับส่วนประกอบทั้งหมดของฉันเช่นฉันมี a SizeComponentซึ่งเพิ่งมีSizeคุณสมบัติ) ดังนั้นSizeComponentวิธีนี้จึงไม่มีวิธีการอัพเดทและวิธีการอัพเดทของผู้จัดการก็ไม่ได้ทำอะไรเลย ความคิดแรกของฉันคือการมีObjectPropertyคลาสที่ส่วนประกอบสามารถสอบถามได้แทนที่จะให้เป็นคุณสมบัติของส่วนประกอบ ดังนั้นวัตถุจะมีจำนวนและObjectProperty ObjectComponentส่วนประกอบจะมีลอจิกการอัพเดทที่สอบถามวัตถุสำหรับคุณสมบัติ ผู้จัดการจะจัดการโทรวิธีการปรับปรุงองค์ประกอบ ดูเหมือนว่าจะเกินความเป็นจริงสำหรับฉัน แต่ฉันไม่คิดว่าฉันจะสามารถกำจัดองค์ประกอบได้เพราะฉันต้องการวิธีที่ผู้จัดการจะต้องรู้ว่าวัตถุใดที่ต้องใช้ตรรกะขององค์ประกอบที่จะเรียกใช้ (มิฉะนั้นฉันจะลบองค์ประกอบออก สมบูรณ์และผลักดันตรรกะการอัปเดตเป็นผู้จัดการ) นี้คือ (มีObjectProperty, ObjectComponentและComponentManagerชั้นเรียน) มากกว่าวิศวกรรม? อะไรจะเป็นทางเลือกที่ดี?

15 architecture  component-based  design-patterns 

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

15 component-based  source-code 

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

14 2d  component-based  gui 

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

14 architecture  unity  component-based 

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

14 game-design  architecture  xna  c#  component-based 

ตามที่เป็นอยู่ในปัจจุบันคำถามนี้ไม่เหมาะสำหรับรูปแบบคำถาม & คำตอบของเรา เราคาดหวังคำตอบที่จะได้รับการสนับสนุนจากข้อเท็จจริงการอ้างอิงหรือความเชี่ยวชาญ แต่คำถามนี้มีแนวโน้มที่จะเรียกร้องให้มีการอภิปรายโต้แย้งโต้แย้งหรือการอภิปรายเพิ่มเติม หากคุณรู้สึกว่าคำถามนี้สามารถปรับปรุงและเปิดใหม่ได้โปรดไปที่ศูนย์ช่วยเหลือเพื่อขอคำแนะนำ ปิดให้บริการใน7 ปีที่ผ่านมา ฉันยอมรับว่าฉันได้ทำบาปมากเกินไปและแม้กระทั่งการละเมิดมรดก โครงการเกมแรก (ข้อความ) ที่ฉันทำเมื่อฉันเรียนหลักสูตร OOP ไปจนถึง "ล็อคประตู" และ "ปลดล็อคประตู" จาก "ประตู" และ "ห้องที่มีประตูเดียว", "ห้องที่มีสองประตู" และ ต่อจาก "ห้อง" ด้วยเกม (กราฟิก) ที่ฉันทำงานเมื่อเร็ว ๆ นี้ฉันคิดว่าฉันได้เรียนรู้บทเรียนและ จำกัด การใช้การสืบทอด อย่างไรก็ตามฉันสังเกตเห็นปัญหาเริ่มปรากฏขึ้นในไม่ช้า คลาสรูทของฉันเริ่มขยายตัวมากขึ้นเรื่อย ๆ และคลาสลีฟของฉันก็เต็มไปด้วยรหัสที่ซ้ำกัน ฉันคิดว่าฉันยังคงทำสิ่งผิดปกติและหลังจากค้นหาทางออนไลน์ฉันพบว่าฉันไม่ใช่คนเดียวที่มีปัญหานี้ มันเป็นวิธีการที่ฉันค้นพบระบบ Entity หลังจากการวิจัยอย่างละเอียด (อ่าน: googlefu) เมื่อฉันเริ่มอ่านมันฉันก็สามารถเห็นได้อย่างชัดเจนว่ามันสามารถแก้ปัญหาที่ฉันมีกับลำดับชั้นของ OOP ดั้งเดิมที่มีส่วนประกอบ สิ่งเหล่านี้อยู่ในการอ่านครั้งแรกอย่างไรก็ตาม เมื่อผมเจอมากขึ้น ... “รุนแรง” ES …

13 java  component-based  entity-system  oop 

ฉันออกแบบเอ็นจิ้นเกมสำหรับเกมยิง 2D แบบผู้เล่นหลายคนจากบนลงล่างซึ่งฉันต้องการใช้ซ้ำได้อย่างมีเหตุผลสำหรับเกมยิงจากบนลงล่างอื่น ๆ ในขณะนี้ฉันกำลังคิดว่าควรออกแบบระบบเอนทิตี้ของมันอย่างไร ครั้งแรกที่ฉันคิดเกี่ยวกับเรื่องนี้: ฉันมีคลาสชื่อ EntityManager ควรใช้วิธีการที่เรียกว่าการปรับปรุงและอีกวิธีหนึ่งที่เรียกว่าการวาด เหตุผลที่ฉันแยกลอจิกและการเรนเดอร์ก็เพราะฉันสามารถตัดเมธอด Draw ได้หากรันเซิร์ฟเวอร์สแตนด์อะโลน EntityManager เป็นเจ้าของรายการของวัตถุประเภท BaseEntity แต่ละเอนทิตีเป็นเจ้าของรายการของส่วนประกอบเช่น EntityModel (การนำเสนอที่เป็นไปได้ของเอนทิตี), EntityNetworkInterface และ EntityPhysicalBody EntityManager ยังเป็นเจ้าของรายชื่อผู้จัดการองค์ประกอบเช่น EntityRenderManager, EntityNetworkManager และ EntityPhysicsManager ตัวจัดการส่วนประกอบแต่ละตัวจะอ้างอิงถึงองค์ประกอบของเอนทิตี มีสาเหตุหลายประการในการย้ายรหัสนี้ออกจากคลาสของเอนทิตีและดำเนินการโดยรวมแทน ตัวอย่างเช่นฉันใช้ไลบรารีฟิสิกส์ภายนอก Box2D สำหรับเกม ใน Box2D คุณต้องเพิ่มเนื้อหาและรูปร่างให้กับโลก (เป็นเจ้าของโดย EntityPhysicsManager ในกรณีนี้) และเพิ่มการโทรกลับการชนกันของข้อมูล (ซึ่งจะถูกส่งไปยังวัตถุเอนทิตีในระบบของฉัน) จากนั้นคุณเรียกใช้ฟังก์ชันที่จำลองทุกอย่างในระบบ ฉันพบว่ามันยากที่จะหาทางออกที่ดีกว่าในการทำเช่นนี้ในการจัดการส่วนประกอบภายนอกเช่นนี้ การสร้างเอนทิตีทำเช่นนี้: EntityManager ใช้เมธอด RegisterEntity (entityClass, factory) ซึ่งลงทะเบียนวิธีสร้างเอนทิตีของคลาสนั้น นอกจากนี้ยังใช้เมธอด …

13 entity-system  component-based 

การปรับใช้ E / C ของฉันเป็นสิ่งพื้นฐานที่หน่วยงานเป็นเพียง ID ของคอมโพเนนต์คือข้อมูลและระบบดำเนินการกับข้อมูล ตอนนี้ฉันมีปัญหากับวัสดุวัตถุและการแสดงผลโดยทั่วไป สำหรับ objetcs ธรรมดาที่ฉันมี a ModelComponent, เชื่อมโยงกับ a RenderSystem, ModelComponentจะมีรหัสจุดสุดยอดบัฟเฟอร์ที่ระบบการเรนเดอร์ใช้ ง่ายMaterialComponentอาจจะมีสีหรือความแข็งแรง specular ฯลฯ แต่ผมอยากให้มันเป็นพอมีความยืดหยุ่นเพื่อให้สามารถมากกว่าหนึ่งทำให้ผ่านและ "ผลกระทบ" MaterialComponentทั่วไปที่ไม่ได้เป็นเรื่องง่ายเป็นตัวแปรที่เรียบง่ายใน พยายามแก้ไขปัญหาเหล่านี้ฉันหาวิธีแก้ไขสองวิธี: 1 - ส่วนประกอบวัสดุที่มีความพิเศษมาก บางสิ่งเช่นนี้ struct Material : public Component { ShaderData* shader; std::vector<std::pair<std::string, boost::any>> uniforms; [...] }; และในระบบเรนเดอร์ฉันจะวนซ้ำและส่งชุดไปที่ shader ฉันคิดว่านี่จะช้า แต่เร็วพอสำหรับจุดประสงค์ของฉัน 2 - อีกชั้นหนึ่งของนามธรรม, MaterialData การมีคลาสเพื่อห่อวัสดุเฉพาะที่สามารถสืบทอดได้โดยวัสดุพิเศษอะไรก็ตามคลาสพื้นฐานจะมีบางอย่างเช่นvoid …

13 component-based  entity-system  entity-component 

ฉันอ่านกรอบ Entity System เป็นพิเศษโดยเฉพาะอาร์ทิมิส ฉันพยายามตัดสินใจว่ามันเหมาะสมกับฉันหรือไม่ ฉันทำงานบนเกมอาร์ตพิกเซล 2d อย่างเคร่งครัดและฉันไม่คิดว่าพวกเขาจะต้องใช้ทรัพยากรมากนัก ฉันเคยใช้ OOP มาตรฐานมาแล้วและมีมรดกมากมายในอดีต ความเข้าใจของฉันเกี่ยวกับ Entity System Framework ตอนนี้ (ฉันไม่แน่ใจว่าฉันเข้าใจทั้งหมดหรือไม่) คือ: เอนทิตีเป็นอะไรนอกจาก ID ส่วนประกอบคืออะไร แต่ข้อมูลที่เป็นใบ้เพิ่มไปยังกลุ่มส่วนประกอบเอนทิตี ระบบคือฟังก์ชั่นอัปเดตที่เชื่อมต่อกับโลกเพื่อจัดการทุกเอนทิตีที่ตรงกับลายเซ็นองค์ประกอบของระบบ หากความเข้าใจของฉันถูกต้องฉันก็มีปัญหานิดหน่อยที่จะเพิ่มแนวความคิดในการเพิ่ม tilemaps และ AI Behavioral Trees ในกรอบนี้ ฉันจะถามเกี่ยวกับ AI ในอนาคต ควรมีการสร้าง tilemap ในเฟรมเวิร์กนี้หรือไม่? หรือควรแยกไว้ต่างหากเพื่อให้ง่ายต่อการสร้างด้วยโปรแกรมแก้ไข tilemap? ถ้า tilemap ควรสร้างไว้ในเฟรมเวิร์กนี้แต่ละไทล์เป็นเอนทิตีที่แตกต่างกันหรือไม่? และ tilemap เป็นระบบ? หรือเป็น tilemap เองเอนทิตีเดียวที่มีการสืบทอดสร้างขึ้นจากมัน? หาก tilemap กระจายตัวอะไรจะเป็นวิธีที่ดีที่สุดในการตรวจจับการชนกันของเอนทิตีเทียบกับ …

12 tiles  component-based  entity-system  tilemap 

ฉันรู้ว่าคำถามนี้ถูกถามหลายครั้ง แต่ฉันยังไม่แน่ใจว่าจะใช้การจัดการอินพุตในเอนจินที่ใช้ส่วนประกอบได้อย่างไร การออกแบบที่ใช้ส่วนประกอบที่ฉันใช้นั้นเป็นไปตามชุดบล็อกของT = MachineและArtemisซึ่ง Entities เป็นแค่รหัส มีสามแนวคิดหลักที่ฉันมีในการใช้การจัดการอินพุต: องค์ประกอบอินพุตจะจัดกิจกรรมที่สนใจ ระบบอินพุตจะแปลเหตุการณ์ของคีย์และเมาส์เป็นเหตุการณ์ของเกมและวนลูปผ่านเอนทิตีที่มีองค์ประกอบอินพุตและหากพวกเขาสนใจในเหตุการณ์ระบบจะดำเนินการที่เหมาะสม การกระทำนี้จะถูกเข้ารหัสอย่างหนักในระบบอินพุต ไม่มีองค์ประกอบอินพุต คุณจะลงทะเบียนเอนทิตีที่มีเหตุการณ์เฉพาะไปยังระบบอินพุต จากนั้นระบบอินพุตจะส่งข้อความ (พร้อมรหัสเอนทิตีและประเภทเหตุการณ์) ไปยังระบบอื่นเพื่อให้สามารถดำเนินการที่เหมาะสมได้ หรือในกรณีแรกการกระทำจะถูกกำหนดค่าตายตัวในระบบอินพุต คล้ายกับวิธีแรก แต่แทนที่จะเขียนโค้ดการดำเนินการกับระบบอินพุตอย่างหนักส่วนประกอบจะมีแผนที่ของเหตุการณ์ไปยังฟังก์ชั่น (เช่นstd::map<std::function>) ซึ่งจะถูกเรียกโดยระบบอินพุต สิ่งนี้มีผลกระทบเพิ่มเติมจากความสามารถในการจับคู่เหตุการณ์เดียวกันกับการกระทำที่แตกต่างกัน คุณจะแนะนำวิธีการใด ๆ ข้างต้นหรือคุณมีข้อเสนอแนะใด ๆ ที่จะช่วยให้ฉันใช้ระบบจัดการอินพุตที่ยืดหยุ่นได้หรือไม่? นอกจากนี้ฉันยังไม่คุ้นเคยกับหลายเธรด แต่ข้อเสนอแนะใด ๆ ที่จะทำให้การใช้เธรดเป็นมิตรก็ยินดีด้วย หมายเหตุ: ข้อกำหนดเพิ่มเติมหนึ่งข้อที่ฉันต้องการให้มีการนำไปใช้เพื่อเติมเต็มคือฉันสามารถส่งผ่านอินพุตเดียวกันไปยังเอนทิตีหลาย ๆ อย่างเช่นการย้ายเอนทิตีกล้องและผู้เล่นในเวลาเดียวกัน

12 component-based  entity-system  input