रॉक-पेपर-पेपर ऑनलाइन गेम के उदाहरण का उपयोग करके जावा सर्वर बनाने के लिए Reddwarf: सर्वर

RedDwarf - जावा में ऑनलाइन गेम विकसित करने के लिए सर्वर प्लेटफॉर्म लेख में, मैंने गेम सर्वर बनाने के लिए इस प्लेटफॉर्म की विशेषताओं के बारे में बात की। इस लेख में मैं एक उदाहरण के साथ दिखाने की कोशिश करूंगा कि RedDwarf का उपयोग करके सर्वर कैसे लिखा जाए।
एक उदाहरण के रूप में, खेल "रॉक-पेपर-कैंची" के ऑनलाइन कार्यान्वयन को लिखने का निर्णय लिया गया था।
इस लेख में, हम एक सर्वर लिखेंगे और इसे शुरू करने का प्रयास करेंगे। अगले लेख में, हम इस सर्वर के लिए एक छोटा ग्राहक लिखेंगे और उनके प्रदर्शन की जाँच करेंगे।

काम की तैयारी

सबसे पहले आपको Reddwarf सर्वर को sgs-server-dist-0.10.2.zip संग्रह में यहाँ से डाउनलोड करना होगा और सामग्री को sgs-server-dist-0.10.2 फ़ोल्डर में खोलना होगा।

परियोजना निर्माण

अपने पसंदीदा विकास के माहौल में एक परियोजना बनाएं।
परियोजना सरल होगी, इसलिए हम मावेन का उपयोग नहीं करेंगे।
विकास के लिए, हमें sgs-server-api-0.10.2.jar की जरूरत है sgs-server-dist-0.10.2 \ lib \ निर्देशिका से पुस्तकालय

हम META-INF फ़ोल्डर बनाते हैं, इसमें मैनिफ़ेस्ट फ़ाइल MANIFEST.MF होना चाहिए। इसके बिना, प्लेटफॉर्म प्रोजेक्ट जार-फाइल के साथ काम करने से इनकार करता है। मेरी फ़ाइल में केवल एक पंक्ति है:
प्रकट-संस्करण: 1.0

META-INF फ़ोल्डर में भी, आपको app.properties फ़ाइल बनाना होगा। इस फ़ाइल में सर्वर स्टार्टअप सेटिंग्स हैं। हमारे प्रोजेक्ट के लिए, फ़ाइल में निम्नलिखित गुण हैं:

#  .        com.sun.sgs.app.name=RockPaperScissors # ,   AppListener      com.sun.sgs.app.listener=hello.reddwarf.server.Server #  ,        com.sun.sgs.app.root=data 

यह विकल्पों का न्यूनतम आवश्यक सेट है। विकास के दौरान, निम्नलिखित गुण अभी भी उपयोगी हो सकते हैं:

• com.sun.sgs.impl.transport.tcp.listen.port - वह पोर्ट जिस पर सर्वर सुनता है (डिफ़ॉल्ट रूप से 62964)
• com.sun.sgs.app.authenticators - प्रमाणीकरण के लिए जिम्मेदार वर्गों के नाम (प्रमाणीकरण प्रक्रिया को खेल तर्क से हटा दिया जाता है और एक स्वतंत्र मॉड्यूल के रूप में जा सकते हैं)
• com.sun.sgs.impl.service.session.allow.new.login - कनेक्ट करने के लिए किसी अन्य क्लाइंट से कनेक्टेड खिलाड़ियों को अनुमति देने के लिए। अगर सच है, तो जो अब खेल में है वह फेंकता है। यदि गलत है, तो किसी अन्य क्लाइंट से कनेक्ट करने की अनुमति नहीं देता है।

प्रलेखन में अन्य गुणों के बारे में अधिक पढ़ें।

खेल वास्तुकला

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

यदि वर्ग आरेख के रूप में चित्रित किया गया है, तो यह इस प्रकार है:


सभी गेम इकाइयां (वेपन को छोड़कर) आंतरिक डेटाबेस में संग्रहीत की जाती हैं जो सर्वर के चलने के दौरान लेन-देन प्रदान करती हैं, एक दूसरे को संदर्भित करती हैं, इसलिए उन्हें java.io.Serializable और com.sun.sgs.app.anagedObject इंटरफ़ेस लागू करना होगा।

सर्वर वर्ग। प्लेयर इनिशियलाइज़ेशन एंड कनेक्शन

सर्वर वर्ग सर्वर लॉन्च बिंदु है, इसलिए इसे com.sun.sgs.app.AppListener इंटरफ़ेस लागू करना होगा:

पहली बार सर्वर शुरू होने पर void initialize(Properties props) कहा जाता है। यह काम के लिए आवश्यक प्रारंभिक मूल्यों के साथ आंतरिक डेटाबेस को भरता है। एक महत्वपूर्ण विशेषता: यदि सर्वर को रोक दिया जाता है (या मार दिया जाता है) और फिर फिर से शुरू किया जाता है, तो इस विधि को नहीं बुलाया जाएगा , क्योंकि आंतरिक डेटाबेस सर्वर प्रारंभ के बीच संग्रहीत किया जाता है और आपको उस पल से काम करना जारी रखने की अनुमति देता है जो इसे बंद कर देता है।

ClientSessionListener loggedIn(ClientSession session) को सफल प्रमाणीकरण के बाद कहा जाता है और खिलाड़ी का प्रतिनिधित्व करने वाली एक वस्तु को वापस करना चाहिए। हमारे उदाहरण में, यह प्लेयर होगा।

सर्वर से जुड़े सभी खिलाड़ियों को एक विशेष संग्रह में संग्रहीत किया जाएगा। Reddwarf के पास खेल संस्थाओं के लिए ScalableHashMap का एक विशेष संग्रह है। इस संग्रह के फायदे यह हैं कि जब इसे बदला जाता है, तो इसे ब्लॉक किया जाता है (मतलब आंतरिक डेटाबेस में लॉक करना) पूरी तरह से नहीं, बल्कि आंशिक रूप से। और सर्वर ऑब्जेक्ट में हम संग्रह को स्वयं स्टोर नहीं करेंगे, लेकिन इसके लिए एक लिंक (प्रबंधित)।

शब्दों से कर्मों की ओर बढ़ते हुए, हमें निम्नलिखित कोड मिलते हैं:

 package hello.reddwarf.server; import java.io.Serializable; import com.sun.sgs.app.*; import com.sun.sgs.app.util.ScalableHashMap; import java.util.Properties; /** *  .     , *        . */ public class Server implements AppListener, Serializable, ManagedObject { public ManagedReference<ScalableHashMap<String, Player>> onlinePlayersRef; @Override public void initialize(Properties props) { //      ScalableHashMap<String, Player> onlinePlayers = new ScalableHashMap<String, Player>(); onlinePlayersRef = AppContext.getDataManager().createReference(onlinePlayers); } @Override public ClientSessionListener loggedIn(ClientSession session) { String name = session.getName(); //  .      ,    Player player = loadOrRegister(name); //   .  -  ,    //   -     player.setSession(session); //    ,    player.connected(); //     - onlinePlayersRef.get().put(player.name, player); return player; } } 

डेटाबेस के साथ काम करने के लिए, DataManager का उपयोग किया जाता है, जो आपको डेटाबेस से लिखने, डेटाबेस से पढ़ने और प्रबंधित प्रबंधित लिंक बनाने की अनुमति देता है। चूंकि डेटाबेस एक कुंजी-मूल्य संग्रहण है, उपसर्ग "खिलाड़ी" के साथ खिलाड़ी का नाम। इसका उपयोग कुंजी के रूप में किया जाता है, और पूरे प्लेयर ऑब्जेक्ट को मूल्य पर क्रमबद्ध किया जाता है। हम एक खिलाड़ी को आधार से लोड करने के लिए एक फ़ंक्शन लिखेंगे (यदि खिलाड़ी डेटाबेस में नहीं मिला है, तो इसे बनाएं)।

  private Player loadOrRegister(String name) { try { return (Player) AppContext.getDataManager().getBindingForUpdate("player." + name); } catch (NameNotBoundException e) { //       - //   ,       Player player = new Player(name, this); AppContext.getDataManager().setBinding("player." + name, player); return player; } } 

खिलाड़ी वर्ग और प्रोटोकॉल

खिलाड़ी वर्ग बनाने का समय आ गया है। यह वर्ग खिलाड़ी का प्रतिनिधित्व करता है और मंच से आने वाले संदेशों की सूचनाएं प्राप्त करता है। तो, यह प्रोटोकॉल के बारे में बात करने का समय है। Reddwarf आने वाले और आउटगोइंग संदेशों को बाइट की एक सरणी के रूप में काम करना संभव बनाता है, जिससे गेम डेवलपर के विवेक पर प्रोटोकॉल का कार्यान्वयन होता है। खेल "रॉक-पेपर-कैंची" के लिए हम एक सरल पाठ प्रोटोकॉल का उपयोग करेंगे।

(server -> client) SCORE <नंबर> - सर्वर खिलाड़ी को अंकों की संख्या बताता है
(क्लाइंट -> सर्वर) प्ले - गेम शुरू करने के लिए खिलाड़ी का अनुरोध
(सर्वर -> क्लाइंट) BATLE <name> - निर्दिष्ट खिलाड़ी के साथ लड़ाई शुरू हो गई है
(सर्वर -> क्लाइंट) ERROR - लड़ाई के लिए खिलाड़ी नहीं मिला (सर्वर पर कोई भी नहीं है या लड़ाई में सभी)
(ग्राहक -> सर्वर) रॉक - खिलाड़ी "स्टोन" कहते हैं
(क्लाइंट -> सर्वर) स्कोरर - खिलाड़ी कहते हैं "कैंची"
(ग्राहक -> सर्वर) पेपर - खिलाड़ी कहते हैं "पेपर"
(सर्वर -> ग्राहक) ड्रा - ड्रा
(सर्वर -> क्लाइंट) WON - प्लेयर जीता
(सर्वर -> ग्राहक) LOST - खिलाड़ी खो गया

प्रोटोकॉल से आप खिलाड़ी के कार्यों और क्षमताओं के अनुक्रम को समझ सकते हैं, इसलिए हम इस पर अलग से ध्यान नहीं देंगे।

आप इस कोड का उपयोग करके टेक्स्ट को बाइट्स में उलझा सकते हैं और इसके विपरीत:

 package hello.reddwarf.server; import java.nio.ByteBuffer; public class Messages { public static ByteBuffer encodeString(String s) { return ByteBuffer.wrap(s.getBytes()); } public static String decodeString(ByteBuffer message) { byte[] bytes = new byte[message.remaining()]; message.get(bytes); return new String(bytes); } } 

अब खिलाड़ी के ऑब्जेक्ट को लिखने के लिए आगे बढ़ें।
खिलाड़ी निम्नलिखित फ़ील्ड रखेगा:

• पहला नाम
• अंकों की संख्या
• सर्वर लिंक (ऑनलाइन खिलाड़ियों की सूची तक पहुंच के लिए)
• सत्र का लिंक (ग्राहक को संदेश भेजने के लिए)
• लड़ाई के लिए लिंक (यदि खिलाड़ी अब लड़ाई में है, अन्यथा अशक्त है)

 package hello.reddwarf.server; import com.sun.sgs.app.*; import com.sun.sgs.app.util.ScalableHashMap; import java.io.Serializable; import java.nio.ByteBuffer; import java.util.*; public class Player implements Serializable, ManagedObject, ClientSessionListener { private final static Random random = new Random(); public final String name; private int score; //   ,        private ManagedReference<ClientSession> sessionRef; //        - private ManagedReference<Server> serverRef; //    .      -    null private ManagedReference<Battle> battleRef; public Player(String name, Server server) { this.name = name; serverRef = AppContext.getDataManager().createReference(server); score = 0; } @Override public void receivedMessage(ByteBuffer byteBuffer) { //          String message = Messages.decodeString(byteBuffer); if (message.equals("PLAY")) { play(); } else if (message.equals("ROCK")) { answer(Weapon.ROCK); } else if (message.equals("PAPER")) { answer(Weapon.PAPER); } else if (message.equals("SCISSORS")) { answer(Weapon.SCISSORS); } } @Override public void disconnected(boolean b) { serverRef.get().disconnect(this); } private void answer(Weapon weapon) { if (battleRef != null) { battleRef.getForUpdate().answer(this, weapon); } } private void play() { logger.info("Choosing enemy for "+name); //          Player target = getRandomPlayer(); if (target != null && target.battleRef == null) { Battle battle = new Battle(this, target); this.sessionRef.get().send(Messages.encodeString("BATTLE " + target.name)); target.sessionRef.get().send(Messages.encodeString("BATTLE " + this.name)); target.battleRef = AppContext.getDataManager().createReference(battle); this.battleRef = target.battleRef; battle.start(); } else { this.sessionRef.get().send(Messages.encodeString("ERROR")); } } /** *    (  ) *     ,  null * @return    null,    */ private Player getRandomPlayer() { ScalableHashMap<String,Player> onlineMap = serverRef.get().onlinePlayersRef.get(); Set<String> namesSet = new HashSet<String>(onlineMap.keySet()); namesSet.remove(name); if (namesSet.isEmpty()) { return null; } else { ArrayList<String> namesList = new ArrayList<String>(namesSet); String randomName = namesList.get(random.nextInt(namesList.size())); return onlineMap.get(randomName); } } public void connected() { //      ,     sessionRef.get().send(Messages.encodeString("SCORE " + score)); } /** *  ,      */ public void battleResult(Battle.Result result) { switch (result) { case DRAW: score+=1; sessionRef.get().send(Messages.encodeString("DRAW")); break; case WON: score+=2; sessionRef.get().send(Messages.encodeString("WON")); break; case LOST: sessionRef.get().send(Messages.encodeString("LOST")); break; } sessionRef.get().send(Messages.encodeString("SCORE " + score)); battleRef = null; } public void setSession(ClientSession session) { sessionRef = AppContext.getDataManager().createReference(session); } } 

हथियार और लड़ाई कक्षाएं

हथियार गणना बहुत सरल है और कोई टिप्पणी नहीं की आवश्यकता है।

 package hello.reddwarf.server; public enum Weapon { ROCK, PAPER, SCISSORS; boolean beats(Weapon other) { return other != null && this != other && this.ordinal() == (other.ordinal() + 1) % values().length; } } 

हम लड़ाई के लिए पास।

लड़ाई में एक विशिष्ट पहचानकर्ता होता है, जिसमें दो खिलाड़ियों के लिंक, उनके उत्तर और साथ ही एक गतिविधि ध्वज होता है।

एक बार लड़ाई बनने के बाद, एक अलग कार्य शुरू किया जाता है, जो 5 सेकंड में लड़ाई को पूरा करेगा।
इस समय के बाद, लड़ाई के परिणामों को अभिव्यक्त किया जाता है। यदि केवल एक ही खिलाड़ी जवाब देता है, तो इसे विजेता माना जाता है, यदि दोनों - विजेता को सामान्य नियमों के अनुसार निर्धारित किया जाता है "रॉक-पेपर-कैंची"।

टास्कमैन सेवा का उपयोग करके कार्य को निष्पादित किया जाता है, जिसे AppContext.getTaskManager () का उपयोग करके प्राप्त किया जा सकता है। यह प्रबंधक आपको एक अलग लेनदेन में किए गए कार्यों को तुरंत, या समय की निर्दिष्ट अवधि के बाद, या समय-समय पर चलाने की अनुमति देता है। जैसा कि अपेक्षित था, सभी कार्यों को आंतरिक डेटाबेस में भी संग्रहीत किया जाता है, जिसका अर्थ है कि सर्वर के पुनरारंभ होने के बाद उनका प्रदर्शन किया जाएगा।

तो, क्लास कोड बैटल है।

 package hello.reddwarf.server; import com.sun.sgs.app.AppContext; import com.sun.sgs.app.ManagedObject; import com.sun.sgs.app.ManagedReference; import com.sun.sgs.app.Task; import java.io.Serializable; import java.util.concurrent.atomic.AtomicInteger; public class Battle implements ManagedObject, Serializable { //   5  private static final long BATTLE_TIME_MS = 5000; enum Result { DRAW, WON, LOST } private boolean active; private ManagedReference<Player> starterPlayerRef; private ManagedReference<Player> invitedPlayerRef; private Weapon starterWeapon = null; private Weapon invitedWeapon = null; public Battle(Player starterPlayer, Player invitedPlayer) { starterPlayerRef = AppContext.getDataManager().createReference(starterPlayer); invitedPlayerRef = AppContext.getDataManager().createReference(invitedPlayer); active = false; } /** *  . *  ,  BATTLE_TIME_MS    . */ public void start(){ active = true; AppContext.getTaskManager().scheduleTask(new BattleTimeout(this), BATTLE_TIME_MS); } /** *    . *  ,  . * @param player -  * @param weapon -   */ public void answer(Player player, Weapon weapon){ if (active) { if (player.name.equals(starterPlayerRef.get().name)) { starterWeapon = weapon; } else { invitedWeapon = weapon; } } } /** *  . *  . */ private void finish() { active = false; Player starterPlayer = starterPlayerRef.getForUpdate(); Player invitedPlayer = invitedPlayerRef.getForUpdate(); if (starterWeapon != null && starterWeapon.beats(invitedWeapon)) { starterPlayer.battleResult(Result.WON); invitedPlayer.battleResult(Result.LOST); } else if (invitedWeapon != null && invitedWeapon.beats(starterWeapon)) { invitedPlayer.battleResult(Result.WON); starterPlayer.battleResult(Result.LOST); } else { starterPlayer.battleResult(Result.DRAW); invitedPlayer.battleResult(Result.DRAW); } AppContext.getDataManager().removeObject(this); } /** * ,      . */ private static class BattleTimeout implements Serializable, Task { private ManagedReference<Battle> battleRef; public BattleTimeout(Battle battle) { battleRef = AppContext.getDataManager().createReference(battle); } @Override public void run() throws Exception { battleRef.getForUpdate().finish(); } } } 

इस कोड को पढ़ते समय, यह सवाल उठ सकता है: “आंतरिक बैटलटाइमआउट क्लास को स्थिर क्यों बनाया गया है और लिंक को स्पष्ट रूप से लड़ाई के लिए संग्रहीत करता है? आप इसे गैर-स्थैतिक घोषित कर सकते हैं और सीधे युद्ध क्षेत्रों तक पहुंच सकते हैं। "
तथ्य यह है कि गैर-स्थिर आंतरिक वर्ग लिंक को मूल रूप में मूल लड़ाई के लिए संग्रहीत करेगा और इसके माध्यम से लड़ाई तक पहुंच प्राप्त करेगा। लेकिन Reddwarf प्लेटफ़ॉर्म (ट्रांसेक्शनल) की विशेषताएं ManagedObject (जो कि लड़ाई है) को सीधे किसी अन्य लेनदेन से एक्सेस करने पर रोक लगाती है: इस मामले में, एक अपवाद फेंक दिया जाएगा, क्योंकि किसी अन्य लेनदेन में किसी ऑब्जेक्ट का सीधा संदर्भ गलत है। केवल स्थिर आंतरिक वर्गों का उपयोग करने के लिए मंच रचनाकारों की सिफारिश इसके साथ जुड़ी हुई है।

मैं संदर्भ द्वारा प्रबंधित वस्तु की प्राप्ति पर भी ध्यान देना चाहूंगा।
ManagedReference के लिए उपरोक्त कोड प्राप्त () विधि और getForUpdate () दोनों का उपयोग करता है।
सिद्धांत रूप में, केवल प्राप्त () का उपयोग किया जा सकता है। GetForUpdate () का उपयोग करके सर्वर को लेन-देन पूरा होने से पहले यह पता करने की अनुमति मिलती है कि किन वस्तुओं को बदला जाएगा और, यदि परस्पर विरोधी लेनदेन का पता चला है, तो कार्य को थोड़ा पहले रद्द करने के लिए। यह प्राप्त () का उपयोग करने की तुलना में गति में कुछ लाभ देता है।

अंत में, हमारा सर्वर लगभग तैयार है।
थोड़ी लॉगिंग जोड़ें (सादगी के लिए हम java.util.log का उपयोग करते हैं) और आप परियोजना का निर्माण कर सकते हैं।
असेंबली के परिणामस्वरूप, हमें जार फ़ाइल मिलनी चाहिए।
यदि आप यह सब मैन्युअल रूप से एकत्र नहीं करना चाहते हैं, तो समाप्त परिनियोजित .jar फ़ाइल यहाँ से ली जा सकती है ।
इस फ़ाइल को sgs-server-dist-0.10.2 \ dist में रखा जाना चाहिए।
अब, sgs-server-dist-0.10.2 डायरेक्टरी में होने के कारण, हम निम्नलिखित कमांड निष्पादित करते हैं:

 java -jar bin/sgs-boot.jar 

परिणामस्वरूप, आप कंसोल में निम्न देख सकते हैं:

  02, 2012 9:45:19 PM com.sun.sgs.impl.kernel.Kernel <init> INFO: The Kernel is ready, version: 0.10.2.1  02, 2012 9:45:19 PM com.sun.sgs.impl.service.data.store.DataStoreImpl <init> INFO: Creating database directory : C:\sgs-server-dist-0.10.2.1\data\dsdb  02, 2012 9:45:19 PM com.sun.sgs.impl.service.watchdog.WatchdogServerImpl registerNode INFO: node:com.sun.sgs.impl.service.watchdog.NodeImpl[1,health:GREEN,backup:(none)]@black registered  02, 2012 9:45:19 PM hello.reddwarf.server.Server initialize INFO: Starting new Rock-Paper-Scissors Server. Initialized database.  02, 2012 9:45:19 PM com.sun.sgs.impl.kernel.Kernel startApplication INFO: RockPaperScissors: application is ready 

हुर्रे! सर्वर शुरू हो गया है! अब आप ग्राहक के साथ सौदा कर सकते हैं:
Reddwarf रॉक-पेपर-पेपर ऑनलाइन गेम के उदाहरण का उपयोग करते हुए: क्लाइंट

संदर्भ

सर्वर एपीआई Javadoc
सामुदायिक प्रलेखन
प्रोजेक्ट फोरम