👨‍👩‍👧 📽️ 👩🏼‍🏭 मैंने अपना ऑनलाइन गेम कैसे बनाया। भाग 1: नेटवर्किंग 🖕🏾 🤚🏻 🔅

सभी को नमस्कार! मेरे पास हाल ही में एक छुट्टी थी, और मेरे घर की परियोजनाओं को शांत करने के लिए समय था। इसलिए, मैं रुस्त पर अपना सरल ऑनलाइन गेम बनाना चाहता था। अधिक सटीक, एक साधारण 2D शूटर। मैंने पहले नेटवर्क का हिस्सा बनाने का फैसला किया, और वहां पहले से ही यह देखा जाएगा कि क्या और कैसे। चूंकि शैली में सभी क्षेत्रों में कार्रवाई शामिल है, इसलिए मैंने यूडीपी प्रोटोकॉल का उपयोग करने का निर्णय लिया। उन्होंने नेटवर्क के हिस्से की वास्तुकला को डिजाइन करना शुरू किया। मुझे एहसास हुआ कि आप इसे एक अलग पुस्तकालय में रख सकते हैं। मैंने MIT लाइसेंस के तहत परिणामी लाइब्रेरी को crates.io पर भी अपलोड किया, क्योंकि: ए) यह तब मेरे लिए इसे अपनी परियोजनाओं से जोड़ने के लिए अधिक सुविधाजनक होगा। ख) शायद यह किसी और के लिए उपयोगी होगा और लाभ लाएगा। विवरण के लिए, बिल्ली में आपका स्वागत है।

संदर्भ

-> स्रोत
-> पुस्तकालय crates.io पर
-> प्रलेखन

उदाहरण का उपयोग करें

ग्राहक

//   use victorem; fn main() -> Result<(), victorem::Exception> { // ,    11111      127.0.0.1:22222 let mut socket = victorem::ClientSocket::new("11111", "127.0.0.1:22222")?; loop { //    socket.send(b"Client!".to_vec()); //    .             socket.recv().map(|v| String::from_utf8(v).map(|s| println!("{}",s))); } }

सर्वर

 //   use victorem; use std::time::Duration; use std::net::SocketAddr; //,  .            . struct ClientServerGame; //     Game,         impl victorem::Game for ClientServerGame { //,     .       false,   . fn handle_command(&mut self, delta_time: Duration, commands: Vec<Vec<u8>>, from: SocketAddr) -> bool { for command in commands { String::from_utf8(command).map(|s| println!("{}",s)); } true } //     30 .     ,     .      ,     . fn draw(&mut self, delta_time: Duration) -> Vec<u8> { b"Server!".to_vec() } } fn main() -> Result<(), victorem::Exception> { // ,      ClientServerGame     22222 let mut server = victorem::GameServer::new(ClientServerGame, "22222")?; //       . server.run(); Ok(()) }

आंतरिक रूप से डिवाइस

सामान्य तौर पर, अगर मैं लामिनार के नेटवर्क भाग के लिए कच्चे यूडीपी सॉकेट के बजाय कच्चे यूडीपी सॉकेट का उपयोग करता हूं, तो कोड को 100 के कारक से कम किया जा सकता है, और मैं लेखों की इस श्रृंखला में वर्णित एल्गोरिदम का उपयोग करता हूं - गेम डेवलपर्स के लिए नेटवर्क प्रोग्रामिंग ।
सर्वर आर्किटेक्चर में क्लाइंट्स से कमांड प्राप्त करना शामिल है (उदाहरण के लिए, माउस बटन या कीबोर्ड पर कुछ बटन दबाकर) और उन्हें एक राज्य भेजना (उदाहरण के लिए, यूनिट्स की वर्तमान स्थिति और वे जिस दिशा में देख रहे हैं) जिसके साथ क्लाइंट प्लेयर को एक तस्वीर प्रदर्शित कर सकता है।

सर्वर पर

 //         u32     ,  0 -  , 1 -   ,      . pub fn get_lost(&self) -> (u32, u32) { let mut sequence: u32 = 0; let mut x = 0; let mut y = self.last_received_packet_id; while x < 32 && y > 1 { y -= 1; if !self.received.contains(&y) { let mask = 1u32 << x; sequence |= mask; } x += 1; } (sequence, self.last_received_packet_id) }

क्लाइंट पर

 //      (max_id)         (sequence)  .           fn get_lost(&mut self, max_id: u32, sequence: u32) -> Vec<CommandPacket> { let mut x = max_id; let mut y = 0; let mut ids = Vec::<u32>::new(); //      , ,     ,      . let max_cached = self.cache.get_max_id(); if max_cached != max_id { ids.push(max_cached); } while x > 0 && y < 32 { x -= 1; let mask = 1u32 << y; y += 1; let res = sequence & mask; if res > 0 { ids.push(x); } } self.cache.get_range(&ids) }

उपसंहार

वास्तव में, कमांड डिलीवरी एल्गोरिदम बनाना आसान था। सर्वर पर, केवल उस पैकेट को स्वीकार करें जिसके साथ +1 से प्राप्त अंतिम पैकेट पर जाने से ज्यादा बाकी है, और बाकी को छोड़ दें। ग्राहक को प्राप्त अंतिम पैकेट भेजें। क्लाइंट पर, उन सभी कमांड्स का कैश रखें, जिन्हें यूजर ने सर्वर पर भेजने की कोशिश की थी। हर बार एक नया राज्य आईडी के साथ सर्वर से आता है, सर्वर द्वारा प्राप्त अंतिम पैकेट, इसे कैश से हटा दें और आईडी के साथ सभी पैकेट कम से कम है। शेष सभी पैकेट फिर से सर्वर पर भेजे जाते हैं।
इसके अलावा, जब मैं गेम को खुद बनाऊंगा, उपयोग की प्रक्रिया में मैं आगे और सुधार करूंगा और लाइब को अनुकूलित करूंगा। शायद मुझे कुछ और कीड़े मिलेंगे।

मुझे यहां C # में एक गेम सर्वर प्रोजेक्ट मिला - Rust पर Networker +, एक पत्ता है, गो - लीफ पर गेम सर्वर के एनालॉग की तरह। केवल प्रगति में विकास है।

PS प्रिय मित्र, यदि आप एक शुरुआत हैं और इस परियोजना के लिए मेरे कोड को पढ़ने और मेरे द्वारा लिखे गए परीक्षणों को देखने का फैसला किया है। इसलिए यहाँ मेरी सलाह है - जैसा मैं करता हूँ वैसा मत करो। मैंने परीक्षणों में सब कुछ मिलाया और "एएए" टेम्पलेट का पालन नहीं किया (Google यह क्या है)। आपको यह उत्पादन में नहीं करना है एक सामान्य परीक्षण में एक चीज को सत्यापित करना चाहिए, एक साथ कई स्थितियों को नहीं, और चरणों से मिलकर होना चाहिए:

आपने अपने चर निर्धारित किए;
आप जिस क्रिया का परीक्षण करना चाहते हैं, उसे आप करते हैं;
आप परिणाम की अपेक्षा के साथ करते हैं।

उदाहरण के लिए

  fn add_one(x:usize) -> usize { x+1 } #[test] fn add_one_fn_should_add_one_to_it_argument(){ let x = 2; let expected = x+1; ///////////////////////// let result = add_one(x); ////////////////////////////////// assert_eq!(expected,result); }

मैंने अपना ऑनलाइन गेम कैसे बनाया। भाग 1: नेटवर्किंग