नाटक "मल्टीप्लेयर ऑनलाइन गेम का विकास।" भाग 3: क्लाइंट-सर्वर इंटरैक्शन

भाग 1: वास्तुकला
भाग 2: प्रोटोकॉल
भाग 4: 3 डी में जा रहा है

तीसरे भाग के साथ, मुझे थोड़ी देर हो गई। लेकिन जैसा कि वे कभी नहीं से बेहतर देर से कहते हैं ...

इसलिए, हम बातचीत जारी रखते हैं।

हमारे बयान के तीसरे भाग में, हम प्रोटोकॉल को लागू करते हैं, एक सर्वर और एक क्लाइंट लिखते हैं जो नेटवर्क पर बातचीत करेंगे। और (OMG!) टैंक की सवारी करेंगे!
कटौती के तहत, जो आप लंबे समय से चाहते हैं, लेकिन पूछने से डरते थे ...



विशेष रूप से विचित्र के लिए, मैं आपको याद दिलाता हूं कि लेख का पूरा कोड "SuperPuperMegaFiguishingFasteningIntelligent समाधान सभी समस्याओं का समाधान" शीर्षक होने का दिखावा नहीं करता है। कोड मुख्य बिंदुओं और अधिक को दिखाने के लिए डिज़ाइन किया गया है। यह कुछ जगहों पर बदसूरत है, इष्टतम नहीं है, लेकिन यह सार का सार बताता है।

पिछले लेख के बाद से, कई घटनाएं हुई हैं। उनमें से एक यह है कि मैंने आईडीईए के तहत स्काला के विकास के लिए स्विच किया। कारण सरल है - नेटबीन्स के लिए प्लग-इन पूरी तरह से बकवास है ... इसलिए, बिटबकेट में प्रोजेक्ट को नेटबीन्स से आईडीईए में बदल दिया गया है, इसलिए डरें नहीं। और यद्यपि IDEA के पहले इंप्रेशन बहुत सकारात्मक नहीं हैं, मैं इस कैक्टस को चबाने की कोशिश करूंगा।

भाग तीन कार्रवाई एक: वास्तुकला के साथ क्या मामला है?

याद है कि वहाँ वास्तुकला के साथ ...



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

भाग तीन चरण दो: डेटा ट्रांसफर प्रोटोकॉल।

सबसे पहले, प्लेयर प्लेयर क्लास बनाएं। यह खिलाड़ी आईडी और उसके निर्देशांक को संग्रहीत करेगा।

class Player(idd: Int, xx: Int, yy: Int) { var id = idd var x = xx var y = yy } 

हमारे पास सबसे सरल प्रोटोकॉल है। इसे लागू करने के लिए, आपको 2 कक्षाएं बनाने की आवश्यकता है। वह पैकेट श्रेणी जिसमें संदेश संग्रहीत है।

 class Packet ( comm:Int, player: Player ) { val com = comm //  val id = player.id // id     val x = player.x val y = player.y } 

और वर्ग एन्कोडिंग और डिकोडिंग संदेश

 object Protocol { //  def encode( packet: Packet ): ByteBuffer = { val rez: ByteBuffer = ByteBuffer.allocate(16) rez.putInt(packet.com) rez.putInt(packet.id) rez.putInt(packet.x) rez.putInt(packet.y) rez } //  def decode( buffer: ByteBuffer ): Packet = { val com = buffer.getInt(0) val idd = buffer.getInt(4) val xx = buffer.getInt(8) val yy = buffer.getInt(12) val rez: Packet = new Packet( com, new Player(idd, xx, yy) ) rez } } 

प्रोटोकॉल कार्यान्वयन तैयार है। जैसा कि आप देख सकते हैं, सरलतम मामलों में, यह ठीक है। लेकिन वास्तविक परियोजनाओं में, अपनी बाइक का आविष्कार करने के लिए वजनदार कारण होना चाहिए। तैयार-किए गए, समय-परीक्षण किए गए समाधानों का उपयोग करना बेहतर है।

भाग तीन चरण तीन: सर्वर, इस शब्द का कितना ...

जबकि हम गेम का फ्रेम बना रहे हैं। इसलिए, सर्वर विशुद्ध रूप से नाममात्र का काम करेगा। क्लाइंट कनेक्टिविटी को हैंडल करें और ग्राहकों के बीच संचार प्रदान करें। भविष्य में, हम इसे परिष्कृत करेंगे।

एक GameServer वर्ग बनाएँ

 object GameServer extends Runnable { var isActive = true var selector: Selector = null var numClients = 0 var port = 7778 //              var sessions = new HashMap[ SocketChannel, Actor ] var lock: AnyRef = new Object() //            def addPlayerMsg(player: Player) { lock.synchronized { ..... } } //   def init(portt: Int) { port = portt try { selector = Selector.open println( "Selector opened" ) } catch { case e => println( "Problems during Socket Selector init: " + e ) } } override def run() { //   bindSocket( "", port) //    while ( isActive ) { Loop() } } def Loop() { if ( selector.select > 0 ) { val it = selector.selectedKeys().iterator() while ( it.hasNext ) { val skey = it.next it.remove() if ( !skey.isValid ) { continue() } //  if ( skey.isAcceptable ) { val socket:ServerSocketChannel = skey.channel().asInstanceOf[ServerSocketChannel] try { numClients = numClients + 1 val channel = socket.accept channel.configureBlocking(false) channel.register(selector, SelectionKey.OP_READ) //      val player = new Player(numClients, numClients * 20, numClients * 20) val actor = new ClientHandler(player, channel) actor.start() //      val packet = new Packet( 0, player) actor.packets += packet //     sessions += channel -> actor println( "Accepted connection from:" + channel.socket().getInetAddress + ":" + channel.socket().getPort ) } catch { case e: Exception => println( "Game Loop Exception: " + e.getMessage ) } } //            else { val channel:SocketChannel = skey.channel.asInstanceOf[SocketChannel] val actor = sessions.get(channel).get.asInstanceOf[ClientHandler] if ( actor.packets.size > 0 ) { skey.interestOps(SelectionKey.OP_WRITE) } actor ! skey } } } } def close(remoteAddress:String, channel:SocketChannel) { channel.close(); println("Session close: " + remoteAddress); } //   def bindSocket(address: String, port: Int) { try { //   val hostAddr: InetAddress = null val isa = new InetSocketAddress(hostAddr, port) val serverChannel = ServerSocketChannel.open serverChannel.configureBlocking(false) serverChannel.socket.bind(isa) serverChannel.socket.setReuseAddress(true) serverChannel.register(selector, SelectionKey.OP_ACCEPT ) println( "Listening game on port: " + port ) } catch { case e: IOException => println("Could not listen on port: " + port + ".") System.exit(-1) case e => println("Unknown error " + e) System.exit(-1) } } } 

सर्वर लंबवत के रूप में सरल निकला। इसे एक अलग धागे में लॉन्च किया गया है। वह रोटी नहीं माँगता। यहां केवल ग्राहक सेवा दिखाई जाती है। ग्राहकों के सही कनेक्शन / वियोग को संभालने वाले कोई हिस्से नहीं हैं। कोई सत्र प्रबंधन नहीं। लेकिन हर कोई इसे पसंद कर सकते हैं।

भाग तीन अधिनियम चार: अभिनेता अभी भी अभिनेता है।

अब एक एक्टर बनाएं जो क्लाइंट कनेक्शन को हैंडल करेगा।

 class ClientHandler(player: Player, chanel:SocketChannel) extends Actor { val player_id = player.id val channel = chanel val remoteAddress = channel.socket().getRemoteSocketAddress.toString var packets = new HashSet[ Packet ] def act() { loop { receive { //   case key: SelectionKey => { try { //   if (key.isReadable) { val buffer = ByteBuffer.allocate(16) channel.read(buffer) match { case -1 => close(remoteAddress, channel) case 0 => case x => processMessageRead(key, buffer) } } //   else if (key.isWritable) { packets.synchronized { for(packet <- packets) { processMessageWrite( Protocol.encode(packet) ) packets.remove(packet) } } if(packets.isEmpty) key.interestOps(SelectionKey.OP_READ) } } catch { case e: SocketException => println("ClientHandler SocketException error " + e.getMessage) case e: IOException => println("ClientHandler IOException error " + e.getMessage) case e => println("ClientHandler Unknown error " + e.getMessage) } } } } } //    def processMessageRead(key: SelectionKey, buffer: ByteBuffer) { if ( buffer.limit() == 0 ) { return } buffer.flip val protocol = Protocol.decode( buffer ) println( "Client : " + player.id + " - " + new Date + " - " + "com:" + protocol.com + " x:" + protocol.x + " y:" + protocol.y ) player.x = protocol.x player.y = protocol.y buffer.clear if (protocol.com == 0) { key.interestOps(SelectionKey.OP_WRITE) } else if (protocol.com == 1) { GameServer.addPlayerMsg(player) } } //    def processMessageWrite(buffer: ByteBuffer) { if ( buffer.limit() == 0 ) { return } buffer.flip channel.write(buffer) println( "Client write: " + player.id + " - " + new Date + " - " + buffer.array().mkString(":") ) buffer.clear } def close(remoteAddress: String, channel: SocketChannel) { channel.close() println("Session " + player.id + " close: " + remoteAddress) } } 

अभिनेता छड़ी की तरह सरल निकला। वह केवल संदेशों को स्वीकार करता है और उन्हें भेजता है।

लोड टेस्टिंग के लिए, मैंने अपने कमज़ोर लैपटॉप (1.3 GHz, AMD, WiFi 56Mbit) पर सर्वर लॉन्च किया। और एक ग्राहक के रूप में, मैंने एक कंसोल जावा एप्लिकेशन बनाया जो थ्रेड्स की निर्दिष्ट संख्या को लॉन्च करता है और प्रत्येक में, बिना रुके, सर्वर को पैकेट भेजता है। क्लाइंट को 100 थ्रेड्स में डेस्कटॉप (3.6 GHz, 4 कोर) पर लॉन्च किया गया था।
नतीजतन, सर्वर ने प्रति सेकंड लगभग 6000 संदेशों को पचा लिया। जो आमतौर पर बुरा नहीं होता। एक वास्तविक सर्वर हार्डवेयर पर कंप्यूटिंग लोड के आधार पर, यह कई हजार ग्राहकों को रखने में सक्षम होगा।

भाग तीन पांचवीं कार्रवाई: ग्राहक ... और कौन?

पिछले भाग के ग्राहक नहीं बदले हैं। एक टैंक और प्रोटोकॉल के कार्यान्वयन के रूप में खिलाड़ी का केवल एक चित्रमय प्रदर्शन जोड़ा गया।

खिलाड़ी का वर्णन करने वाला एक वर्ग जोड़ें

  public class Player extends MovieClip { public var Name:String = "Player"; public var id:int = 0; [Embed(source = '../../../../lib/tank.png')] public var _tank: Class; public var tank:Bitmap; public function Player() { width = 30; height = 30; tank = new _tank(); tank.width = 30; tank.height = 30; addChild(tank); } } 

और प्रोटोकॉल को लागू करने के तरीके भी जोड़ें।

  //  public function sendMessage(val:int):void { if (socket.connected) { var bytes:ByteArray = new ByteArray(); bytes.writeInt(val); bytes.writeInt(player.id); bytes.writeInt(player.x); bytes.writeInt(player.y); socket.writeBytes( bytes, 0, 16); socket.flush(); } } //    private function dataHandler(e:ProgressEvent):void { var bytes:ByteArray = new ByteArray(); socket.readBytes(bytes, 0, 16); var com:int = bytes.readInt(); var id:int = bytes.readInt(); var x:int = bytes.readInt(); var y:int = bytes.readInt(); switch (com) { //   case 0: … //  case 1: ... } } 

अब क्लाइंट और सर्वर के बीच बुनियादी बातचीत तैयार है।

ग्राहकों के सही कनेक्शन / वियोग के मुद्दे, ग्राहकों का सिंक्रनाइज़ेशन (जिसके कारण आंदोलन के दौरान टैंक चिकोटी) हल नहीं होते हैं। यह सभी निम्नलिखित भागों में हमारी प्रतीक्षा कर रहा है ...

PS बहुत सारे कोड ... भाग को हटा सकते हैं और केवल विधियों का वर्णन छोड़ सकते हैं?

हमेशा की तरह, सभी स्रोतों को जीथब पर देखा जा सकता है