🙎🏿 🛂 🌀 खेल में मल्टीप्लेयर: एक अंदर देखो 🛂 🗿 ✏️

नमस्कार।

मैंने हाल ही में एंड्रॉइड के लिए एक मोबाइल गेम बनाया है, जिसमें संभावित रूप से मल्टीप्लेयर हो सकते हैं, जो कि उपयोगकर्ताओं ने अनुरोध किया है।
मल्टीप्लेयर प्रदान नहीं किया गया था, क्योंकि यह मॉडल और प्रस्तुति के अलगाव का अनुपालन नहीं करता था।
इस लेख में मैं खेल के नेटवर्क मोड के एक सरल कार्यान्वयन पर विचार करूंगा और खेल की वास्तुकला के माध्यम से सोचने के चरण में हुई गलतियों के बारे में बात करूंगा।
लेख गोबलिन युद्धों II से प्रेरित होकर , खेल की संरचना को स्वतंत्र ब्लॉकों में विभाजित किया गया था, जो अंततः उपयोगकर्ताओं को नेटवर्क पर खेलने की अनुमति देता था।

सभी गेम ऑब्जेक्ट के लिए बेस क्लास में एमवीसी मॉडल के सभी तर्क निहित थे - यह खुद को आकर्षित करने और अपनी स्थिति को बदलने में सक्षम था।

public abstract class BaseObject { public byte type; public byte state; public Rectangle body; public abstract void update(float delta); public abstract void draw(float delta); }

मॉडल को दृश्य से अलग करें।
खेल वस्तुओं को खींचने वाला कोई भी वर्ग एक इंटरफ़ेस लागू करेगा।

 public interface Drawer { void draw(BaseObject obj, float delta); }

मल्टीप्लेयर के लिए वास्तुकला पर विचार करते हुए, अर्थात्, क्लाइंट को अलग करने और सर्वर को लागू करने के लिए, हम ऑब्जेक्ट को एक अलग वर्ग में खींचने के लिए आवश्यक फ़ील्ड निकालते हैं।

 public abstract class State { public byte type; public float x, y; }

इस प्रकार, हम केवल ग्राहक पक्ष पर एक प्रतिनिधित्व स्टोर कर सकते हैं, और मॉडल ऑब्जेक्ट बनाने की कोई आवश्यकता नहीं होगी।

जब खेल में बहुत सारे ऑब्जेक्ट होते हैं, तो इस तरह के कोड को बनाए रखना और नई सुविधाओं को जोड़ना बहुत मुश्किल हो गया।
घटकों के लिए संक्रमण ने नई गेम ऑब्जेक्ट्स के निर्माण की सुविधा प्रदान की, क्योंकि संक्षेप में एक नई इकाई का निर्माण एक निर्माता था।
खेल में सभी वस्तुओं को एंटिटी बेस क्लास से विरासत में मिला है, और एकमात्र अंतर getState () विधि और घटकों के एक अलग सेट द्वारा लौटाए गए राज्य में है।

ऐसे वर्ग का एक उदाहरण

 public class StoneBox extends Entity { private StoneBoxState stoneBoxState = new StoneBoxState(); private SolidBodyComponent solidBody; private MapBodyComponent mapBody; public StoneBox(SorterEntityManager entityManager, float x, float y) { super(entityManager); type = EntityType.BRICK_STONE; solidBody = new SolidBodyComponent(this); solidBody.isStatic = true; solidBody.rectangle.x = x; solidBody.rectangle.y = y; mapBody = new MapBodyComponent(this); SorterComponent sorterComponent = new SorterComponent(this, entityManager); addComponent(solidBody); addComponent(mapBody); addComponent(sorterComponent); } @Override public State getState() { stoneBoxState.x = solidBody.rectangle.x; stoneBoxState.y = solidBody.rectangle.y; return stoneBoxState; } }

खेल की संरचना में काफी बदलाव आया है, और संस्थाओं के अलगाव ने हमें इस तरह का एक गुच्छा बनाने की अनुमति दी है:
Server -> ServerImplementation <-> ClientImplementation <- Client
एक नेटवर्क गेम और एक स्थानीय एक के बीच सभी अंतर अलग-अलग कार्यान्वयन के लिए नीचे आते हैं।

सर्वर वर्ग की क्रियाएं प्रत्येक फ्रेम हैं - यह ServerImplementation लिए राज्यों की वर्तमान सरणी देता है और इसे क्लाइंट को ServerImplementation ।
यह इस तरह दिखता है:

 public class LocalServerImpl { ... public void update(float delta){ clientImpl.states = server.getStates(); ... } }

Client वर्ग, प्रत्येक फ़्रेम ClientImplementation से वर्तमान स्थिति लेता है, और फिर स्क्रीन पर प्राप्त डेटा प्रदर्शित करता है।
बेशक, न केवल राज्यों को प्रेषित किया जाता है, बल्कि खेल की शुरुआत, उपयोगकर्ता आदेशों और अन्य के बारे में भी घटनाएं होती हैं। उनका तर्क राज्य स्थानांतरण से अलग नहीं है।

अब, नेटवर्क मोड को लागू करने के लिए, हमें ServerImplementation <-> ClientImplementation के कार्यान्वयन को बदलने की आवश्यकता है ServerImplementation <-> ClientImplementation , और राज्य वर्गों के लिए भी, ServerImplementation <-> ClientImplementation और ServerImplementation <-> ClientImplementation लिए एक इंटरफ़ेस लागू करें:

 public interface BinaryParser { void parseBinary(DataInputStream stream); void fillBinary(DataOutputStream stream); }

ऐसे वर्ग का एक उदाहरण

 public class StoneBoxState extends State { public StoneBoxState() { super(StateType.STONE_BOX); } @Override public void parseBinary(DataInputStream stream) { x = StreamUtils.readFloat(stream); y = StreamUtils.readFloat(stream); } @Override public void fillBinary(DataOutputStream stream) { StreamUtils.writeByte(stream, type); StreamUtils.writeFloat(stream, x); StreamUtils.writeFloat(stream, y); } }

परसिंग में हम टाइप के लिए जिम्मेदार बाइट को क्यों नहीं पढ़ते हैं? इनपुट बाइट सरणी से हमें जिस इकाई की आवश्यकता है, उसे बनाने के लिए ऑब्जेक्ट के प्रकार का निर्धारण करते समय हम इसे पढ़ते हैं।

राज्य की पार्सिंग

 public static State parseState(DataInputStream stream) { byte type = StreamUtils.readByte(stream); State state = null; switch (type) { case STONE_BOX: state = new StoneBoxState(); break; ... } state.parseBinary(stream); return state; }

मैंने नेटवर्क के साथ काम करने के लिए क्रायोनेट लाइब्रेरी का उपयोग किया, यह बहुत सुविधाजनक है यदि आप जानना नहीं चाहते हैं कि डेटा पैकेट कैसे प्रसारित किया जाता है, और केवल परिणाम आपके लिए महत्वपूर्ण है।
LocalServerImpl को NetworkServerImpl बदल देते हैं, डेटा स्थानांतरित करना अधिक कठिन नहीं है:

खेल की स्थिति भेज रहा है

  Array<State> states = entityManager.getStates(); ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream(); DataOutputStream dataOutputStream = new DataOutputStream(byteArrayOutputStream); StreamUtils.writeByte(dataOutputStream, GameMessages.MESSAGE_SNAPSHOT); for (int i = 0; i < states.size; i++) { states.get(i).fillBinary(dataOutputStream); } byte[] array = byteArrayOutputStream.toByteArray(); byte[] compressedData = CompressionUtils.compress(array); sendToAllUDP(compressedData);

हमें वर्तमान स्थिति मिलती है, इसे बाइट सरणी में लिखें, इसे संग्रहित करें, इसे ग्राहकों को भेजें।
क्लाइंट पर, अंतर भी न्यूनतम हैं, यह राज्यों को भी प्राप्त होगा, लेकिन वे पहले से ही नेटवर्क पर आ जाएंगे:

खेल की स्थिति प्राप्त करना

 private void onReceivedData(byte[] data) { byte[] result = CompressionUtils.decompress(data); ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(result); DataInputStream dataInputStream = new DataInputStream(byteArrayInputStream); byte messageType = StreamUtils.readByte(dataInputStream); switch (messageType) { ... case GameMessages.MESSAGE_SNAPSHOT: snapshot.clear(); try { while (dataInputStream.available() > 0) { snapshot.add(StateType.parseState(dataInputStream)); } } catch (IOException e) { e.printStackTrace(); } break; } }

क्लाइंट और सर्वर के बीच संदेश के प्रकार

  public static final byte MESSAGE_PLAYER_ACTION = 0; public static final byte MESSAGE_SNAPSHOT = 1; public static final byte MESSAGE_ADD_PLAYER = 2; public static final byte MESSAGE_GAME_OVER = 3; public static final byte MESSAGE_LEVEL_COMPLETE = 4; public static final byte MESSAGE_LOADED_NEW_LEVEL = 5; public static final byte MESSAGE_CHANGE_ZOOM_LEVEL = 6;

क्लाइंट साइड पर कोई भी कार्रवाई पहले सर्वर पर भेजी जाती है, सर्वर पर स्थिति बदल जाती है और यह डेटा क्लाइंट को वापस कर दिया जाता है।
मैंने एक छोटा वीडियो रिकॉर्ड किया है जो नेटवर्क मोड को प्रदर्शित करता है (libgdx इंजन आपको पीसी पर एप्लिकेशन चलाने की अनुमति देता है)

खेल में मल्टीप्लेयर: एक अंदर देखो

More articles: