मेलबॉक्स में एक साँप और F # क्या करता है

यह सब क्या है?

यह सब सांप के बारे में है। हर कोई याद करता है कि सांप क्या है: एक आयताकार क्षेत्र पर एक सांप चलता है। भोजन पाता है - लंबाई में बढ़ता है, खुद को या खेत के किनारे को पाता है - मर जाता है। और उपयोगकर्ता केवल कमांड भेज सकता है: बाएं, दाएं, ऊपर, नीचे।
मैंने यहाँ कुछ कार्रवाई जोड़ने और साँप को पैखाने से भागने का फैसला किया। और अभिनेताओं पर यह सब!

इसलिए, आज मैं मानक लाइब्रेरी से MailboxProcessor का उपयोग करके एक मॉडल बनाने के तरीके के बारे में बात करने के लिए एक सांप के उदाहरण का उपयोग करूंगा, जो देखने के लिए बिंदु हैं, और आप क्या उम्मीद कर सकते हैं।

यहां लिखा गया कोड सही नहीं है, कुछ सिद्धांतों का उल्लंघन कर सकता है, और बेहतर लिखा जा सकता है। लेकिन अगर आप शुरुआती हैं और मेलबॉक्स से निपटना चाहते हैं - मुझे उम्मीद है कि यह लेख आपकी मदद करता है।
यदि आप मेरे बिना मेलबॉक्स के बारे में सब कुछ जानते हैं, तो आप यहाँ बोर हो सकते हैं।

अभिनेता क्यों?

अभ्यास के लिए। मैंने अभिनेताओं के मॉडल के बारे में पढ़ा, वीडियो देखा, मुझे सब कुछ पसंद आया, लेकिन मैंने खुद इसे आजमाया नहीं। अब मैंने इसे आजमाया।
इस तथ्य के बावजूद कि वास्तव में मैंने प्रौद्योगिकी के लिए प्रौद्योगिकी को चुना, अवधारणा बहुत सफलतापूर्वक इस कार्य पर गिर गई।

क्यों MailboxProcessor, और नहीं, उदाहरण के लिए, Akka.net?

मेरे कार्य के लिए, MailboxProcessor गौरैया द्वारा कक्षीय स्टेशन से है, MailboxProcessor बहुत सरल है, और यह मानक पुस्तकालय का हिस्सा है, इसलिए आपको किसी भी पैकेज को जोड़ने की आवश्यकता नहीं है।

मेलबॉक्स प्रोसेसर और संबंधित बॉयलरप्लेट के बारे में

बात सरल है। मेलबॉक्स के अंदर एक संदेश लूप और कुछ स्थिति है। आपका संदेश लूप आने वाले नए संदेश के अनुसार इस स्थिति को अपडेट करेगा।

 let actor = MailboxProcessor.Start(fun inbox -> // ,    //   . inbox --    MailboxProcessor let rec messageLoop oldState = async { //   let! msg = inbox.Receive() //    let newState = updateState oldState msg //      return! messageLoop newState } //       .    --     messageLoop (0,0) ) 

कृपया ध्यान दें कि messageLoop पुनरावर्ती है, और अंत में इसे फिर से कॉल किया जाना चाहिए, अन्यथा केवल एक संदेश संसाधित किया जाएगा, जिसके बाद यह अभिनेता मर जाएगा। messageLoop भी अतुल्यकालिक है, और जब नया संदेश प्राप्त होता है, तो प्रत्येक बाद की पुनरावृत्ति की जाती है: let! msg = inbox.Receive() let! msg = inbox.Receive() ।
इस प्रकार, संपूर्ण तार्किक लोड updateState फ़ंक्शन में जाता है, जिसका अर्थ है कि प्रोसेसर का मेलबॉक्स बनाने के लिए, हम एक निर्माता फ़ंक्शन बना सकते हैं जो एक स्टेट अपडेट फ़ंक्शन और एक शून्य स्थिति स्वीकार करता है:

 //   applyMessage       //      (fun inbox -> ...) let buildActor applyMessage zeroState = MailboxProcessor.Start(fun inbox -> let rec loop state = async{ let! msg = inbox.Receive() let newState = applyMessage state msg return! loop newState } loop zeroState ) 

कूल! अब हमें लगातार निगरानी करने की आवश्यकता नहीं है ताकि return! loop newState न भूलें return! loop newState return! loop newState । जैसा कि आप जानते हैं, एक अभिनेता एक राज्य को संग्रहीत करता है, लेकिन अब यह पूरी तरह से स्पष्ट नहीं है कि इस राज्य को बाहर से कैसे प्राप्त किया जाए। प्रोसेसर के मेलबॉक्स में एक PostAndReply विधि होती है, जो एक इनपुट के रूप में AsyncReplyChannel<'Reply> -> 'Msg फ़ंक्शन को ले जाती है। पहले तो इसने मुझे स्तूप में ले जाया - यह पूरी तरह से स्पष्ट नहीं है कि यह कार्य कहां से किया जाए। लेकिन वास्तव में, सब कुछ सरल हो गया: सभी संदेशों को डीयू के आवरण में लपेटा जाना चाहिए, क्योंकि अब हम अपने अभिनेता पर 2 ऑपरेशन करते हैं: संदेश स्वयं भेजें और वर्तमान स्थिति के लिए पूछें। यहाँ यह कैसा दिखता है:

 //     . // Mail<_,_>   ,  Post & Get --  . // F#       , //   compare & equals . //         --   . //   [<Struct>] .       type Mail<'msg, 'state> = | Post of 'msg | Get of AsyncReplyChannel<'state> 

हमारा निर्माण कार्य अब इस तरह दिखता है:

 let buildActor applyMessage zeroState = MailboxProcessor.Start(fun inbox -> let rec loop state = async{ let! msg = inbox.Receive() //    ,     // .    -- ,     //     . //     --      //    .      ! match msg with | Post msg -> let newState = applyMessage state msg return! loop newState | Get channel -> channel.Reply state return! loop state } loop zeroState ) 

अब, मेलबॉक्स के साथ काम करने के लिए, हमें इस Mail.Post में अपने सभी संदेशों को लपेटने की आवश्यकता है। हर बार इसे न लिखने के लिए, इसे छोटे ऐप में लपेटना बेहतर है:

 module Mailbox = let buildAgent applyMessage zeroState = MailboxProcessor.Start(fun inbox -> let rec loop state = async{ let! msg = inbox.Receive() match msg with | Post msg -> let newState = applyMessage state msg return! loop newState | Get channel -> channel.Reply state return! loop state } loop zeroState ) let post (agent: MailboxProcessor<_>) msg = Post msg |> agent.Post let getState (agent: MailboxProcessor<_>) = agent.PostAndReply Get let getStateAsync (agent: MailboxProcessor<_>) = agent.PostAndAsyncReply Get //   Single Case Discriminated Union. // MailboxProcessor   API.      , //  -  ,  ,      //   .       ,     //        . type MailAgent<'msg, 'state> = MailAgent of address:string * mailbox:MailboxProcessor<Mail<'msg, 'state>> //     API with member this.Post msg = //            let (MailAgent (address,this)) = this Mailbox.post this msg member this.GetState() = let (MailAgent (address,this)) = this Mailbox.getState this member this.GetStateAsync() = let (MailAgent (address,this)) = this Mailbox.getStateAsync this member this.Address = let (MailAgent (address, _)) = this address member this.Dispose() = let (MailAgent (_, this)) = this (this:>IDisposable).Dispose() interface IDisposable with member this.Dispose() = this.Dispose() 

मैं आपको बताऊंगा कि क्या address:string थोड़ा बाद में है, लेकिन अब हमारे लिए बॉयलरप्लेट तैयार है।

दरअसल, सांप

सांप में एक सांप होता है, जिसकी कमांड के साथ एक उपयोगकर्ता, एक क्षेत्र और अगले फ्रेम के लिए एक नियमित संक्रमण होता है।
यहां यह सब एक साथ है और हमारे अभिनेताओं को मुस्कुराने की जरूरत है।
मेरा प्रारंभिक लेआउट इस प्रकार था:

• एक टाइमर के साथ अभिनेता। संदेशों को प्रारंभ / रोक / स्वीकार करता है। प्रत्येक n मिलीसेकंड, Flush एक्टर को एक Flush संदेश भेजता है। भंडार प्रणाली। एक राज्य के रूप में
• अभिनेता दल। उपयोगकर्ता से संदेश प्राप्त करें Move Up/Down/Left/Right , AddPerk Speed/Attack (हां, मेरा सांप जल्दी से क्रॉल कर सकता है और खलनायक पर हमला कर सकता है) और टाइमर से Flush । यह एक राज्य के रूप में आदेशों की एक सूची संग्रहीत करता है, और एक फ्लश के साथ यह सूची रीसेट करता है।
• अभिनेता एक सांप है। यह सांप की स्थिति को संग्रहीत करता है - भत्तों, लंबाई, दिशा, झुकता है और निर्देशांक।
  यह कमांड्स के अभिनेता की सूची, Tick संदेश (सांप को 1 सेल को आगे बढ़ाने के लिए) और GrowUp के मिलने पर क्षेत्र के अभिनेता के उत्पाद से संदेश को GrowUp करता है।
• क्षेत्र का अभिनेता। यह कोशिकाओं का एक नक्शा संग्रहीत करता है, एक संदेश में सांप की स्थिति लेता है और मौजूदा तस्वीर पर निर्देशांक खींचता है। यह GrowUp स्नेक अभिनेता और Stop कमांड को टाइमर भी भेजता है।

जैसा कि आप देख सकते हैं, यहां तक ​​कि इतनी कम संख्या में संस्थाओं के साथ, संदेश मानचित्र पहले से ही गैर-तुच्छ है। और पहले से ही इस स्तर पर कठिनाइयां उत्पन्न हुईं: तथ्य यह है कि डिफ़ॉल्ट रूप से एफ # चक्रीय निर्भरता की अनुमति नहीं देता है। कोड की वर्तमान पंक्ति में, आप केवल ऊपर लिखे कोड का उपयोग कर सकते हैं, और परियोजना में फाइलों पर भी यही लागू होता है। यह बग नहीं है, लेकिन एक विशेषता है, और मैं इसे बहुत पसंद करता हूं, क्योंकि यह कोड को साफ रखने में मदद करता है, लेकिन जब डिजाइन द्वारा चक्रीय लिंक की आवश्यकता होती है तो क्या करना है? बेशक, आप rec namespace उपयोग कर सकते हैं - और फिर एक फ़ाइल के अंदर आप इस फ़ाइल में मौजूद हर चीज का उल्लेख कर सकते हैं, जिसका मैंने उपयोग किया था।
कोड गड़बड़ करने की उम्मीद है, लेकिन तब यह एकमात्र विकल्प की तरह लग रहा था। और इसने काम किया।

बाहरी दुनिया की समस्या

जब तक अभिनेताओं की पूरी प्रणाली बाहरी दुनिया से अलग हो जाती थी, तब तक सब कुछ काम करता था, और मैंने कंसोल में केवल डिबेट और प्रदर्शित लाइनों को प्रदर्शित किया। जब updateUI फ़ंक्शन के रूप में निर्भरता को लागू करने का समय आया, जिसे प्रत्येक टिक के लिए फिर से तैयार करना था, तो मैं वर्तमान कार्यान्वयन में इस समस्या को हल नहीं कर सका। न तो बदसूरत और न ही सुंदर - कोई रास्ता नहीं। और फिर मुझे अक्कू की याद आई - आखिरकार, आप रास्ते में ही अभिनेताओं को पैदा कर सकते हैं, और मेरे पास मेरे सभी अभिनेताओं का संकलन चरण में वर्णन है।
समाधान स्पष्ट है - akku का उपयोग करें! नहीं, बेशक, अक्का अभी भी ओवरकिल है, लेकिन मैंने वहां से कुछ बिंदुओं को चाटने का फैसला किया - अर्थात्, अभिनेताओं की एक प्रणाली बनाने के लिए जिसमें आप नए अभिनेताओं को जोड़ सकते हैं और पते पर मौजूदा अभिनेताओं को क्वेरी कर सकते हैं।
चूंकि अभिनेताओं को अब जोड़ा जाता है और रनटाइम में हटा दिया जाता है, लेकिन सीधे लिंक के बजाय पते से प्राप्त किया जाता है, आपको एक परिदृश्य प्रदान करना होगा जहां पता कहीं नहीं दिखता है और अभिनेता वहां नहीं है। उसी acca के उदाहरण के बाद, मैंने मृत अक्षरों के लिए एक बॉक्स जोड़ा, और मैंने इसे अपने पसंदीदा DUs के माध्यम से डिज़ाइन किया:

 // Agent<_,_> --  ,   ,     //     ,      . //      ,    --    Box (mailagent), // ,       ,   ,   , //       Deadbox.      MailAgent,  . //           . //    --    . type Agent<'message,'state> = | Box of MailAgent<'message,'state> | DeadBox of string * MailAgent<string * obj, Map<string,obj list>> with member this.Post msg = match this with | Box box -> box.Post msg | DeadBox (address, deadbox) -> (address, box msg) |> deadbox.Post interface IDisposable with member this.Dispose() = match this with | Box agent -> agent.Dispose() | DeadBox (_,agent) -> agent.Dispose() 

और सिस्टम खुद इस तरह दिखता है:

 //    .     --    . type MailboxNetwork() as this = //      .   ! [<DefaultValue>] val mutable agentRegister: ConcurrentDictionary<string, obj> //       do this.agentRegister <- ConcurrentDictionary<string, obj>() //      , //    Map --     let deadLettersFn deadLetters (address:string, msg:obj) = printfn "Deadletter: %s-%A" address msg match Map.tryFind address deadLetters with //   | None -> Map.add address [msg] deadLetters //   --   | Some letters -> //  --      Map.remove address deadLetters |> Map.add address (msg::letters) let deadLettersAgent() = ("deadLetters", Map.empty |> Mailbox.buildAgent deadLettersFn) |> MailAgent member this.DeadLetters = deadLettersAgent() // -     ,      member this.Box<'message,'state>(address) = match this.agentRegister.TryGetValue address with | (true, agent) when (agent :? MailAgent<'message,'state>) -> // ,       ,   let agent = agent :?> MailAgent<'message, 'state> Box agent | _ -> DeadBox (address, this.DeadLetters) //  --    member this.KillBox address = this.agentRegister.TryRemove(address) |> ignore member this.RespawnBox (agent: MailAgent<'a,'b>) = this.KillBox agent.Address this.agentRegister.TryAdd (agent.Address, agent) |> ignore interface IDisposable with member this.Dispose() = for agent in this.agentRegister.Values do match agent with | :? IDisposable as agent -> agent.Dispose() | _ -> () 

यह वह जगह है जहाँ एक ही address:string , जिसके बारे में मैंने ऊपर लिखा था, काम आया। और फिर से यह काम किया, बाहरी निर्भरता अब प्राप्त करना आसान था जहां आपको आवश्यकता है। अभिनेताओं के निर्माण कार्यों ने अब अभिनेताओं की प्रणाली को तर्क के रूप में स्वीकार कर लिया और वहां से आवश्यक पते प्राप्त किए:

  //    - (  )   - let gameAgent (mailboxNetwork: MailboxNetwork) = mailboxNetwork.Box<Command list, GameState>(gameAddress) //    message loop           let commandAgentFn (mailboxNetwork: MailboxNetwork) commands msg = let gameAgent = gameAgent mailboxNetwork match msg with | Cmd cmd -> cmd::commands | Flush -> commands |> gameAgent.Post [] 

धीरे-धीरे

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

1. उपयोगकर्ता सीधे कमांड अभिनेता को एक अनियंत्रित संख्या भेजता है।
2. टाइमर टीम अभिनेता को एक टिक भेजता है और, एक शुरुआती कार्यान्वयन में, सांप अभिनेता को भी, ताकि वह सांप को अगले सेल में ले जाए
3. कमांड अभिनेता सांप के लिए कमांड की एक सूची भेजता है जब टाइमर से संबंधित संदेश आता है।
4. साँप अभिनेता, 2 ऊपरी संदेशों के अनुसार अपने राज्य को अद्यतन करता है, राज्य को क्षेत्र अभिनेता के पास भेजता है।
5. क्षेत्र अभिनेता सब कुछ redraws। अगर सांप को खाना मिल जाता है, तो वह सांप अभिनेता को एक GrowUp संदेश भेजता है, जिसके बाद वह नए राज्य को फ़ील्ड अभिनेता को वापस भेज देता है।

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

अंतिम संस्करण

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

1. हम Tick और GrowUp संदेशों को हटा दें।
2. हम साँप अभिनेता को क्षेत्र के अभिनेता के रूप में रखते हैं - वह अब इन राज्यों के "टेपला" को संग्रहीत करेगा।
3. हम टाइमर अभिनेता से System.Timers.Timer को हटा देते हैं। इसके बजाय, कार्य की योजना निम्नानुसार होगी: Start कमांड प्राप्त करने के बाद, यह Flush कमांड अभिनेता Flush भेजता है। वह फ़ील्ड + स्नेक अभिनेता को आदेशों की एक सूची भेजता है, अंतिम अभिनेता यह सब प्रक्रिया करता है और टाइमर को एक Next संदेश भेजता है, जिससे उससे एक नई टिक का अनुरोध किया जाता है। टाइमर, Next प्राप्त होने के Next Thread.Sleep(delay) इंतजार करता है और पूरे सर्कल को फिर से शुरू करता है। सब कुछ सरल है।

संक्षेप में देना।

• पिछले कार्यान्वयन में, 500 एमएस न्यूनतम स्वीकार्य देरी थी। वर्तमान देरी में, आप इसे पूरी तरह से हटा सकते हैं - तैयार होने पर फ़ील्ड अभिनेता को एक नए बीट की आवश्यकता होगी। पिछले उपायों से कच्चे संदेश एकत्र करना अब संभव नहीं है।
• मैसेजिंग मैप बहुत सरल है - एक जटिल ग्राफ के बजाय, हमारे पास सबसे सरल लूप है।
• इस सरलीकरण ने बग को हल किया जब नुकसान के मामले में टाइमर को कई बार Stop मिला।
• संदेशों की सूची कम कर दी गई है। कम कोड - कम बुराई!

यह इस तरह दिखता है:

  let [<Literal>] commandAddress = "command" let [<Literal>] timerAddress = "timer" let [<Literal>] gameAddress = "game" // -     let commandAgent (mailboxNetwork: MailboxNetwork) = mailboxNetwork.Box<CommandMessage, Command list>(commandAddress) let timerAgent (mailboxNetwork: MailboxNetwork) = mailboxNetwork.Box<TimerCommand, TimerState>(timerAddress) let gameAgent (mailboxNetwork: MailboxNetwork) = mailboxNetwork.Box<Command list, GameState>(gameAddress) // message loop   let gameAgentFn (mailboxNetwork: MailboxNetwork) updateUi gameState cmd = let timerAgent = timerAgent mailboxNetwork //    match gameState.gameFrame with //     | Frame field -> //       let gameState = Game.updateGameState gameState cmd timerAgent.Post Next //    updateUi gameState //     gameState // ! | End (Win _) -> timerAgent.Post PauseOrResume Game.updateGameState gameState cmd //        | _ -> timerAgent.Post Stop //     gameState // message loop   let commandAgentFn (mailboxNetwork: MailboxNetwork) commands msg = let gameAgent = gameAgent mailboxNetwork match msg with | Cmd cmd -> cmd::commands //       | Flush -> commands |> gameAgent.Post //     [] // message loop   let timerAgentFn (mailboxNetwork: MailboxNetwork) (state: TimerState) cmd = let commandAgent = commandAgent mailboxNetwork match cmd with | Start -> commandAgent.Post Flush; {state with active = true} | Next -> if state.active then //    ,     Threading.Thread.Sleep(state.delay) commandAgent.Post Flush; state | Stop -> printfn "Stop received"; { state with active = false } | PauseOrResume -> if not state.active then //     --   commandAgent.Post Flush { state with active = not state.active } | SetDelay delay -> Threading.Thread.Sleep(delay) if state.active then commandAgent.Post Flush {state with delay = delay} 

संदर्भ

• मेलबॉक्स का परिचय
• सबसे उत्सुक के लिए मेलबॉक्स स्रोत
• अभिनेता मॉडल के लिए स्रोत कोड