ฉันจะใช้ซิงเกิลตันอย่างถูกต้องในการเขียนโปรแกรมเอ็นจิน C ++ ได้อย่างไร?

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

ปัญหาคือการวาดอะไรบางอย่างใน SFML คุณใช้ที่เป็นหน้าต่างwindow.draw(sprite) sf::RenderWindowมี 2 ​​ตัวเลือกที่ฉันเห็นอยู่ที่นี่:

1. สร้างวัตถุเกม Singleton ที่ทุกหน่วยงานในเกมดึง (สิ่งที่ฉันใช้มาก่อน)
2. ทำให้นี่เป็นตัวสร้างสำหรับเอนทิตี: Entity(x, y, window, view, ...etc)(นี่เป็นเพียงเรื่องไร้สาระและน่ารำคาญ)

อะไรจะเป็นวิธีที่เหมาะสมในการทำเช่นนี้ในขณะที่รักษานวกรรมิกของ Entity ให้เป็นแค่ x และ y

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

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

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

ดังนั้นการอัพเดตเกมในคลาสระดับบนของคุณอาจมีลักษณะดังนี้:

EntityList entities = mCurrentLevel.getEntities();
for(auto& i : entities){
  // Run game logic...
  i->update(...);
}
// Render all the entities
for(auto& i : entities){
  mRenderer->draw(i->getSprite());
}

วิธีการง่าย ๆ คือทำสิ่งที่เคยSingleton<T>เป็นโลกTแทน Globals มีปัญหาด้วยเช่นกัน แต่พวกเขาไม่ได้เป็นตัวแทนของงานพิเศษและรหัสสำเร็จรูปเพื่อบังคับใช้ข้อ จำกัด เล็กน้อย นี่เป็นเพียงแนวทางเดียวที่จะไม่เกี่ยวข้องกับการสัมผัสกับตัวสร้างเอนทิตี

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

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

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

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

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

รับช่วงจาก sf :: RenderWindow

SFML สนับสนุนให้คุณสืบทอดจากคลาสของจริง

class GameWindow: public sf::RenderWindow{};

จากที่นี่คุณสร้างฟังก์ชั่นการวาดสมาชิกสำหรับเอนทิตีการวาด

class GameWindow: public sf::RenderWindow{
public:
 void draw(const Entity& entity);
};

ตอนนี้คุณสามารถทำได้:

GameWindow window;
Entity entity;

window.draw(entity);

คุณสามารถทำขั้นตอนนี้ให้ไกลขึ้นได้ถ้าเอนทิตีของคุณจะมีสไปรท์ที่เป็นเอกลักษณ์ของตัวเองโดยการทำให้เอนทิตีสืบทอดจาก sf :: Sprite

class Entity: public sf::Sprite{};

ตอนนี้ sf::RenderWindowก็สามารถดึงหน่วยงานและหน่วยงานในขณะนี้มีการทำงานเช่นการและsetTexture() setColor()เอนทิตีสามารถใช้ตำแหน่งของสไปรท์เป็นตำแหน่งของตัวเองทำให้คุณสามารถใช้setPosition()ฟังก์ชั่นสำหรับทั้งการเคลื่อนย้ายเอนทิตีและสไปรท์

ในท้ายที่สุดมันก็ค่อนข้างดีถ้าคุณมี:

window.draw(game);

ด้านล่างคือตัวอย่างการใช้งานอย่างรวดเร็ว

class GameWindow: public sf::RenderWindow{
 sf::Sprite entitySprite; //assuming your Entities don't need unique sprites.
public:
 void draw(const Entity& entity){
  entitySprite.setPosition(entity.getPosition());
  sf::RenderWindow::draw(entitySprite);
 }
};

หรือ

class GameWindow: public sf::RenderWindow{
public:
 void draw(const Entity& entity){
  sf::RenderWindow::draw(entity.getSprite()); //assuming Entities hold their own sprite.
 }
};

คุณหลีกเลี่ยงซิงเกิลตันในการพัฒนาเกมเช่นเดียวกับที่คุณหลีกเลี่ยงในการพัฒนาซอฟต์แวร์ทุกประเภท: คุณผ่านการอ้างอิง

ด้วยการออกมาจากวิธีการที่คุณสามารถเลือกที่จะผ่านการอ้างอิงโดยตรงเป็นชนิดเปลือย (เช่นint,Window*ฯลฯ ) หรือคุณสามารถเลือกที่จะผ่านพวกเขาในหนึ่งหรือที่กำหนดเองเสื้อคลุมประเภท (ชอบEntityInitializationOptions)

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

Singletons ไม่เลว แทนที่จะเป็นเรื่องง่ายที่จะละเมิด ในทางกลับกัน globals ง่ายยิ่งขึ้นที่จะละเมิดและมีปัญหามากขึ้น

เหตุผลที่ถูกต้องเพียงอย่างเดียวในการแทนที่ซิงเกิลตันด้วยระดับโลกคือการทำให้ผู้เกลียดชังซิงเกิลทางศาสนาสงบลง

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

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

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

RenderSystem(IWindow* window);

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

ตอนนี้มันเป็นโมดูลาร์ที่ทดสอบได้มากกว่าและยังแยกได้จากการใช้งานเฉพาะ มันขึ้นอยู่กับอินเตอร์เฟสเท่านั้นไม่ใช่การใช้งานที่เป็นรูปธรรม