जाओ और कैनवास [सर्वर] पर NanoMMO

प्रत्येक प्रोग्रामर को अपना स्वयं का सेमी , फ्रेमवर्क , mmorpg लिखना चाहिए। वही हम करेंगे।
डेमो

conventionalities

_{सामग्री को समझने के लिए, आपको या तो गो या किसी अन्य सी-लाइक भाषा को जानने की आवश्यकता है, और यह भी कल्पना करें कि js में कैसे लिखें।
इंट्रो टूर पर जाएं
कैनवास ट्यूटोरियल
इस सामग्री का मुख्य उद्देश्य मेरे अपने विचारों को क्रम में रखना है। किसी भी मामले में आपको यहां के पूर्वगामी को एक उदाहरण के रूप में नहीं मानना ​​चाहिए, जहां से आप बिना सोचे समझे कॉपी कर सकते हैं।}

समस्या का बयान

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

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

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

सर्वर

हमारा सर्वर निम्नलिखित कार्य करेगा:

• ग्राहकों से आज्ञा प्राप्त करें
• खेल की दुनिया में बदलाव के बारे में जुड़े ग्राहकों को सूचित करें
• दुनिया की स्थिति को बदलते हुए, एक खेल चक्र का प्रदर्शन करें

दुनिया से हमारा तात्पर्य जुड़े हुए पात्रों और अधिक की सूची से होगा। कोई कार्ड नहीं, कोई बाधा नहीं - केवल खिलाड़ी। पात्रों को एक निश्चित बिंदु पर एक निश्चित गति से स्थानांतरित करने में सक्षम होने वाली एकमात्र चीज होगी।
तब हमारे चरित्र की संरचना इस तरह दिखाई देगी:

/* point.go && character.go */ ... type Point struct { X, Y float64 } ... type Character struct { Pos, Dst Point //     Angle float64 //  Speed uint //  Name string } ... 

आपको याद दिला दूं कि जाने में, एक कैपिटल लेटर के साथ लिखे गए फ़ील्ड एक्सपोर्ट किए जाते हैं (सार्वजनिक), और जब किसी ऑब्जेक्ट को सीरियलाइज़ करते हैं, तो केवल एक्सपोर्ट किए गए फ़ील्ड्स को ही json में जोड़ा जाता है। ( मैंने कई बार इस रेक पर कदम रखा, समझ में नहीं आ रहा था कि प्रतीत होता है कि सही कोड क्यों काम नहीं करता है। यह पता चला है कि खेतों को एक छोटे से पत्र के साथ लिखा गया था )।

क्लाइंट पर, हमें डेटा को सिंक्रनाइज़ करने की आवश्यकता होगी। सभी वर्तमान और भविष्य के क्षेत्रों के लिए character.x = data.X जैसे कोड का एक गुच्छा नहीं लिखने के लिए, हम पुन: सर्वर से डेटा फ़ील्ड के माध्यम से जाएंगे और, यदि नाम मेल खाते हैं, तो उन्हें क्लाइंट ऑब्जेक्ट को असाइन करें। लेकिन जाने वाले क्षेत्रों का पूंजीकरण किया जाता है। इसलिए, हम गो स्टाइल जोंस नामकरण सम्मेलन को स्वीकार करेंगे। इस कारण से, हमने सर्वर को देखकर शुरू किया।

अनुप्रयोग आरंभीकरण और मुख्य लूप

 /* main.go */ package main import ( "fmt" "time" ) const ( MAX_CLIENTS = 100 //      MAX_FPS = 60 //   go    // time.Second      FRAME_DURATION = time.Second / MAX_FPS ) //       var characters map[string]*Character func updateCharacters(k float64) { for _, c := range characters { c.update(k) } } func mainLoop() { //           //  . //    ,       var k float64 for { frameStart := time.Now() updateCharacters(k) duration := time.Now().Sub(frameStart) //    ,      if duration > 0 && duration < FRAME_DURATION { time.Sleep(FRAME_DURATION - duration) } ellapsed := time.Now().Sub(frameStart) //    ,        k = float64(ellapsed) / float64(time.Second) } } func main() { characters = make(map[string]*Character, MAX_CLIENTS) fmt.Println("Server started at ", time.Now()) //    go NanoHandler() mainLoop() } 

Character.update मेथड में, हम कैरेक्टर को ले जाते है अगर वहाँ जाना है जहाँ:

 /* point.go */ ... //        , //     func (p1 *Point) equals(p2 Point, epsilon float64) bool { if epsilon == 0 { epsilon = 1e-6 } return math.Abs(p1.X-p2.X) < epsilon && math.Abs(p1.Y-p2.Y) < epsilon } ... /* chacter.go */ ... func (c *Character) update(k float64) { //         //   ,        //       , //       if c.Pos.equals(c.Dst, float64(c.Speed)*k) { c.Pos = c.Dst return } // !        //         [],        //           lenX := c.Dst.X - c.Pos.X lenY := c.Dst.Y - c.Pos.Y c.Angle = math.Atan2(lenY, lenX) dx := math.Cos(c.Angle) * float64(c.Speed) * k dy := math.Sin(c.Angle) * float64(c.Speed) * k c.Pos.X += dx c.Pos.Y += dy } ... 

अब हम सीधे वेब सॉकेट से गुजरेंगे।

 /* nano.go */ package main import ( "code.google.com/p/go.net/websocket" "fmt" "io" "net/http" "strings" ) const ( MAX_CMD_SIZE = 1024 MAX_OP_LEN = 64 CMD_DELIMITER = "|" ) //  —    ip:port var connections map[string]*websocket.Conn //       json    type packet struct { Characters *map[string]*Character Error string } //      func NanoHandler() { connections = make(map[string]*websocket.Conn, MAX_CLIENTS) fmt.Println("Nano handler started") //  ws://hostname:48888/    NanoServer http.Handle("/", websocket.Handler(NanoServer)) //  48888      err := http.ListenAndServe(":48888", nil) if err != nil { panic("ListenAndServe: " + err.Error()) } } //   func NanoServer(ws *websocket.Conn) { //   MAX_CLIENTS,    ,      if len(connections) >= MAX_CLIENTS { fmt.Println("Cannot handle more requests") return } //  , , 127.0.0.1:52655 addr := ws.Request().RemoteAddr //    connections[addr] = ws //  ,      character := NewCharacter() fmt.Printf("Client %s connected [Total clients connected: %d]\n", addr, len(connections)) cmd := make([]byte, MAX_CMD_SIZE) for { //   n, err := ws.Read(cmd) //  if err == io.EOF { fmt.Printf("Client %s (%s) disconnected\n", character.Name, addr) //    delete(characters, character.Name) delete(connections, addr) //     ,    go notifyClients() //      break } //  ,     if err != nil { fmt.Println(err) continue } fmt.Printf("Received %d bytes from %s (%s): %s\n", n, character.Name, addr, cmd[:n]) //    : operation-name|{"param": "value", ...} //    opIndex := strings.Index(string(cmd[:MAX_OP_LEN]), CMD_DELIMITER) if opIndex < 0 { fmt.Println("Malformed command") continue } op := string(cmd[:opIndex]) //      json  //   ,       n  //   — ,     , //    json data := cmd[opIndex+len(CMD_DELIMITER) : n] //        switch op { case "login": var name string //     websocket.JSON.Unmarshal(data, ws.PayloadType, &name) //     if _, ok := characters[name]; !ok && len(name) > 0 { //  character.Name = name characters[name] = &character fmt.Println(name, " logged in") } else { //    fmt.Println("Login failure: ", character.Name) go sendError(ws, "Cannot login. Try another name") continue } case "set-dst": var p Point //  -      if err := websocket.JSON.Unmarshal(data, ws.PayloadType, &p); err != nil { fmt.Println("Unmarshal error: ", err) } //    //   ,  Character.update    character.Dst = p default: // fmt.Printf("Unknown op: %s\n", op) continue } //     //           go notifyClients() } } //    func sendError(ws *websocket.Conn, error string) { // ,       packet := packet{Error: error} //   json msg, _, err := websocket.JSON.Marshal(packet) if err != nil { fmt.Println(err) return } //   if _, err := ws.Write(msg); err != nil { fmt.Println(err) } } //    func notifyClients() { //       packet := packet{Characters: &characters} //   json msg, _, err := websocket.JSON.Marshal(packet) if err != nil { fmt.Println(err) return } //      for _, ws := range connections { if _, err := ws.Write(msg); err != nil { fmt.Println(err) return } } } 

एक चरित्र का निर्माण, हमें उससे कुछ मापदंडों को पूछना चाहिए। जाने में यह NewTypename प्रपत्र के किसी फ़ंक्शन में ऐसा करने के लिए प्रथागत है

 /* character.go */ ... const ( CHAR_DEFAULT_SPEED = 100 ) ... func NewCharacter() Character { c := Character{Speed: CHAR_DEFAULT_SPEED} c.Pos = Point{100, 100} c.Dst = c.Pos return c } 

वह हमारा पूरा सर्वर है।

---

इस पाठ पर प्रतिक्रिया एकत्र करने के बाद ग्राहक भाग के बारे में एक लेख लिखा जाएगा।

---

संदर्भ

डेमो
कार्ड जेनरेटर (पृष्ठभूमि पर चित्र)
स्रोत कोड