मैं इकाई-घटक प्रतिमान के साथ एक गेम तैयार कर रहा हूं जो यहां बताए अनुसार घटकों के बीच संवाद करने के लिए सिस्टम का उपयोग करता है । मैं अपने विकास में इस बिंदु पर पहुंच गया हूं कि मुझे खेल राज्य (जैसे ठहराव, खेल, स्तर शुरू, गोल शुरू, खेल खत्म, आदि) जोड़ने की आवश्यकता है, लेकिन मुझे यकीन नहीं है कि यह मेरे ढांचे के साथ कैसे किया जाए। मैंने इस कोड उदाहरण को गेम स्टेट्स पर देखा है जिसे हर कोई संदर्भ देता है, लेकिन मुझे नहीं लगता कि यह मेरे ढांचे के साथ फिट बैठता है। ऐसा लगता है कि प्रत्येक राज्य अपने स्वयं के ड्राइंग और अद्यतन को संभाल रहा है। मेरे ढांचे में एक SystemManager है जो सिस्टम का उपयोग करके सभी अद्यतन को संभालता है। उदाहरण के लिए, यहाँ मेरा प्रतिपादन प्रणाली है:
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);
}
/**
* Method: registerGameView
* Registers gameView into the RenderingSystem.
* @param gameView The game view registered.
*/
public void registerGameView(GameView gameView) {
gameView_ = gameView;
}
/**
* Method: triggerRender
* Adds a repaint call to the event queue for the dirty rectangle.
*/
public void triggerRender() {
Rectangle dirtyRect = new Rectangle();
for (GameObject object : getRenderableObjects()) {
GraphicsComponent graphicsComponent =
object.getComponent(GraphicsComponent.class);
dirtyRect.add(graphicsComponent.getDirtyRect());
}
gameView_.repaint(dirtyRect);
}
/**
* Method: renderGameView
* Renders the game objects onto the game view.
* @param g The graphics object that draws the game objects.
*/
public void renderGameView(Graphics g) {
for (GameObject object : getRenderableObjects()) {
GraphicsComponent graphicsComponent =
object.getComponent(GraphicsComponent.class);
if (!graphicsComponent.isVisible()) continue;
GraphicsComponent.Shape shape = graphicsComponent.getShape();
BoundsComponent boundsComponent =
object.getComponent(BoundsComponent.class);
Rectangle bounds = boundsComponent.getBounds();
g.setColor(graphicsComponent.getColor());
if (shape == GraphicsComponent.Shape.RECTANGULAR) {
g.fill3DRect(bounds.x, bounds.y, bounds.width, bounds.height,
true);
} else if (shape == GraphicsComponent.Shape.CIRCULAR) {
g.fillOval(bounds.x, bounds.y, bounds.width, bounds.height);
}
}
}
/**
* Method: getRenderableObjects
* @return The renderable game objects.
*/
private HashSet<GameObject> getRenderableObjects() {
return gameManager.getGameObjectManager().getRelevantObjects(
getClass());
}
}साथ ही मेरे गेम का सभी अपडेट ईवेंट-चालित है। मेरे पास उनकी तरह एक लूप नहीं है जो एक ही समय में सब कुछ अपडेट करता है।
मुझे मेरा ढांचा पसंद है क्योंकि नए गेमऑब्जेक्ट्स को जोड़ना आसान बनाता है, लेकिन घटकों के बीच संचार करते समय कुछ घटक-आधारित डिज़ाइन मुठभेड़ की समस्या नहीं होती है। मैं सिर्फ काम करने के लिए ठहराव पाने के लिए इसे चकना चाहूंगा। क्या कोई ऐसा तरीका है जिससे मैं इकाई-घटक डिज़ाइन को हटाए बिना गेम स्टेट्स को अपने गेम में जोड़ सकता हूँ? क्या खेल राज्य का उदाहरण वास्तव में मेरे ढांचे में फिट बैठता है, और मैं सिर्फ कुछ याद कर रहा हूं?
संपादित करें: मैंने अपने ढांचे को अच्छी तरह से समझाया नहीं होगा। मेरे घटक सिर्फ डेटा हैं। अगर मैं C ++ में कोडिंग कर रहा था, तो वे शायद स्ट्रक्चर होंगे। यहाँ एक उदाहरण है:
public class BoundsComponent implements GameComponent {
/**
* The position of the game object.
*/
private Point pos_;
/**
* The size of the game object.
*/
private Dimension size_;
/**
* Constructor
* Creates a new BoundsComponent for a game object with initial position
* initialPos and initial size initialSize. The position and size combine
* to make up the bounds.
* @param initialPos The initial position of the game object.
* @param initialSize The initial size of the game object.
*/
public BoundsComponent(Point initialPos, Dimension initialSize) {
pos_ = initialPos;
size_ = initialSize;
}
/**
* Method: getBounds
* @return The bounds of the game object.
*/
public Rectangle getBounds() {
return new Rectangle(pos_, size_);
}
/**
* Method: setPos
* Sets the position of the game object to newPos.
* @param newPos The value to which the position of the game object is
* set.
*/
public void setPos(Point newPos) {
pos_ = newPos;
}
}मेरे घटक एक दूसरे के साथ संवाद नहीं करते हैं। सिस्टम अंतर-घटक संचार को संभालते हैं। मेरे सिस्टम भी एक दूसरे के साथ संवाद नहीं करते हैं। उनकी अलग कार्यक्षमता होती है और उन्हें आसानी से अलग रखा जा सकता है। MovementSystem को यह जानने की आवश्यकता नहीं है कि गेम ऑब्जेक्ट्स को सही ढंग से स्थानांतरित करने के लिए RenderingSystem क्या प्रदान कर रहा है; इसे बस घटकों पर सही मान सेट करने की आवश्यकता है, ताकि जब रेंडरिंगसिस्टम गेम ऑब्जेक्ट्स को प्रस्तुत करे, तो इसमें सटीक डेटा हो।
खेल राज्य एक प्रणाली नहीं हो सकता है, क्योंकि इसे घटकों के बजाय सिस्टम के साथ बातचीत करने की आवश्यकता है। यह डेटा सेट नहीं कर रहा है; यह निर्धारित करना है कि किन कार्यों को बुलाया जाना चाहिए।
एक GameStateComponent से कोई मतलब नहीं होगा क्योंकि सभी गेम ऑब्जेक्ट एक गेम स्टेट साझा करते हैं। घटक वे होते हैं जो वस्तुओं को बनाते हैं और प्रत्येक एक अलग वस्तु के लिए अलग होता है। उदाहरण के लिए, गेम ऑब्जेक्ट में समान सीमा नहीं हो सकती। उनके पास अतिव्यापी सीमा हो सकती है, लेकिन यदि वे एक BoundsComponent साझा करते हैं, तो वे वास्तव में एक ही वस्तु हैं। उम्मीद है, यह स्पष्टीकरण मेरे ढांचे को कम भ्रमित करता है।