🦕 🧝🏿 👰🏻 स्टेरॉयड पर ZoG 🤷 🧑🏽‍🤝‍🧑🏽 🤓

जब मैंने खेल " थुड! " के विकास के बारे में लिखा , तो मुझे पहले से ही प्राप्त विवरण के कुछ अतिरेक के बारे में शिकायत थी। ZRF भाषा की सादगी का इसका दूसरा पक्ष है - इस पर कुछ कम जटिल लिखने के लिए, अक्सर आपको महत्वपूर्ण महत्वपूर्ण अंशों की नकल करनी होती है। इस तरह की अतिरेक, जैसा कि आप जानते हैं, न केवल मैनुअल काम की मात्रा में वृद्धि की ओर जाता है, बल्कि कोड में विभिन्न त्रुटियों के जोखिम को भी बढ़ाता है (चूंकि ZoG अनुप्रयोगों को डीबग करने की प्रक्रिया बहुत तुच्छ नहीं है, यह एक आवश्यक बिंदु है)।

ऐसे अतिरेक से कोई कैसे निपट सकता है?

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

जैसा कि मैंने ऊपर कहा था, हम एक बाहरी प्रीप्रोसेसर के बारे में बात कर रहे हैं जो स्रोत फ़ाइलों (एक्सटेंशन .prezrf) को नियमित zrf फ़ाइलों में परिवर्तित करता है। प्रीप्रोसेसर स्वयं जावा भाषा में विकसित किया गया है और एक जार फ़ाइल है। प्रीज़्रफ़ फ़ाइल को संसाधित करने के लिए, बस निम्नलिखित कमांड चलाएँ (बशर्ते कि जावा आपके कंप्यूटर पर स्थापित हो)

java -jar prezrf.jar MyFile.prezrf

यदि प्रसंस्करण त्रुटियों के बिना गुजरता है, तो परिणामी zrf फ़ाइल उसी निर्देशिका में बनाई जाएगी।

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

कीवर्ड का विस्तार! निर्दिष्ट कोड स्थान में पहले से परिभाषित मैक्रो के "परिनियोजन" की ओर जाता है। चूंकि यह क्रिया बहुत बार की जाती है, इसलिए इसके लिए संक्षिप्त नाम परिभाषित किया गया है ! '। इस प्रकार, निम्नलिखित कोड को संसाधित करके:

 (define! swap ($2 $1) ) (! swap ab)

... हमें आउटपुट मिलता है:

 (ba)

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

यह सब, शायद, बहुत दिलचस्प नहीं होगा यदि प्रीज़रॉफ़ द्वारा प्रदान की गई नई सुविधाओं के लिए नहीं। एक नए प्रकार के मैक्रो में, हम सूची तर्कों का उपयोग कर सकते हैं! इसके अलावा, हमारी सुविधा के लिए, एक सूची के रूप में मैक्रो को पारित किए गए कई तर्कों से लिंक करने की क्षमता जोड़ी गई है। $ 2 * 4 का निर्माण क्रमिक रूप से 2, 3, और 4 वें तर्कों के मूल्यों को मैक्रो को पारित कर देगा (बशर्ते कि कम से कम चार तर्क पारित किए गए हों)। इसके अलावा, शॉर्टहैंड निर्माण $ n * और $ * m परिभाषित किए गए हैं, जिनमें स्पष्ट शब्दार्थ हैं। इस अवसर का उपयोग करते हुए, हम उदाहरण के लिए, मैक्रो को दिए गए तर्कों की संख्या की गणना कर सकते हैं:

 (define! count (length! ($1*)) ) (! count abc) ; => 3

मैं इस तथ्य पर आपका ध्यान आकर्षित करता हूं कि $ 1 * के आसपास के ब्रैकेट इस उदाहरण में अनिवार्य हैं - हम एक सूची बनाते हैं जिसमें हम मैक्रो के सभी तर्कों के मूल्यों को सूचीबद्ध करते हैं, जो पहले से शुरू होता है। कोष्ठक गुम होने से लंबाई के बाद प्रसंस्करण त्रुटि हो जाएगी ! केवल एक सूची तर्क को स्वीकार करता है। हालाँकि, हमारी मैक्रो इनपुट त्रुटियों से पर्याप्त रूप से सुरक्षित नहीं है। बिना किसी तर्क के एक कॉल (गिनती) विफल हो जाएगी। हम इसे इस प्रकार ठीक कर सकते हैं:

 (define! count ($?1 (length! ($1*)) ) ($!1 0) )

यहां $ 1 को निष्पादित किया जाता है यदि एक या एक से अधिक तर्क मैक्रो को पास किए जाते हैं, और $ 1 अन्यथा। इसके अलावा, $ -n निर्माण का उपयोग करके सूची के अंत से तत्वों को संख्या में करना संभव है। ये सभी सुविधाएँ भविष्य में हमारे लिए बहुत उपयोगी होंगी।

किसी भी स्वाभिमानी प्रोग्रामिंग भाषा की तरह, prezrf हमें सशर्त निष्पादन ( यदि-कम!, अगर-कम-या-बराबर-बराबर! ) और लूप (के लिए ) प्रदान करता है। अगर-कंस्ट्रक्शन (और ऊपर सूचीबद्ध भाषा में उनमें से कुछ अधिक हैं), समान ZRF निर्माण के विपरीत, अन्य शाखा को परिभाषित नहीं करते हैं, लेकिन ! का उपयोग केवल सूची आइटम को ट्रेस करने के लिए किया जा सकता है उदाहरण के लिए, हम खेल में परिभाषित सभी दिशाओं के लिए एक कार्रवाई के निष्पादन को दोहरा सकते हैं (यह बहुत बार आवश्यक है):

 (define! -all-directions (n ne e se s sw w nw)) (define! shift-all (for! $d ($ -all-directions) (shift $d) ) ) (! shift-all)

इस कोड में, नियंत्रण निर्माण ' $ ' का उपयोग किया जाता है, जिसके बारे में अभी बात करने के लिए मेरे पास समय नहीं है। वह क्या कर रही है? वास्तव में, यह एक बहुत ही आमतौर पर इस्तेमाल किए जाने वाले डिज़ाइन के लिए एक शॉर्टहैंड है:

 (!! (! macro))

विस्तार! यहाँ हम पहले से ही परिचित हैं, लेकिन क्या करता है ' !! '? यह कमांड ( विस्तार-पहले! ) प्रीप्रोसेसर को तत्व के मूल्य का उपयोग करने के लिए कहता है, न कि स्वयं पैरेंट कंस्ट्रक्शन में तत्व के लिए (हमारे उदाहरण में)। यह बिंदु बहुत स्पष्ट नहीं हो सकता है, लेकिन भाषा को समझने के लिए यह बहुत महत्वपूर्ण है। यदि आप अभी उपयोग करते हैं, तो आउटपुट कैसा दिखेगा: (-सभी दिशाएँ) :

 (shift !) (shift -all-directions)

यह स्पष्ट रूप से वह नहीं है जो हम चाहते थे। क्षमा करें, के लिए! यह केवल सूचियों के साथ काम करता है और हमें निम्नलिखित अपमान का अनुकूलन करने में मदद नहीं कर सकता है:

इसलिए ट्रोल हो जाओ

 ( define troll-1 ( $1 (verify empty?) (if (enemy? n) (capture n)) (if (enemy? nw) (capture nw)) (if (enemy? s) (capture s)) (if (enemy? ne) (capture ne)) (if (enemy? w) (capture w)) (if (enemy? sw) (capture sw)) (if (enemy? e) (capture e)) (if (enemy? se) (capture se)) add ) ) ( define troll-2 ( mark (opposite $1) (verify friend?) back $1 (verify empty?) $1 (verify empty?) (verify (or (enemy? n) (enemy? nw) (enemy? s) (enemy? ne) (enemy? w) (enemy? sw) (enemy? e) (enemy? se))) (if (enemy? n) (capture n)) (if (enemy? nw) (capture nw)) (if (enemy? s) (capture s)) (if (enemy? ne) (capture ne)) (if (enemy? w) (capture w)) (if (enemy? sw) (capture sw)) (if (enemy? e) (capture e)) (if (enemy? se) (capture se)) add ) ) ( define troll-3 ( mark (opposite $1) (verify friend?) (opposite $1) (verify friend?) back $1 (verify empty?) $1 (verify empty?) $1 (verify empty?) (verify (or (enemy? n) (enemy? nw) (enemy? s) (enemy? ne) (enemy? w) (enemy? sw) (enemy? e) (enemy? se))) (if (enemy? n) (capture n)) (if (enemy? nw) (capture nw)) (if (enemy? s) (capture s)) (if (enemy? ne) (capture ne)) (if (enemy? w) (capture w)) (if (enemy? sw) (capture sw)) (if (enemy? e) (capture e)) (if (enemy? se) (capture se)) add ) ) ( define troll-4 ( mark (opposite $1) (verify friend?) (opposite $1) (verify friend?) (opposite $1) (verify friend?) back $1 (verify empty?) $1 (verify empty?) $1 (verify empty?) $1 (verify empty?) (verify (or (enemy? n) (enemy? nw) (enemy? s) (enemy? ne) (enemy? w) (enemy? sw) (enemy? e) (enemy? se))) (if (enemy? n) (capture n)) (if (enemy? nw) (capture nw)) (if (enemy? s) (capture s)) (if (enemy? ne) (capture ne)) (if (enemy? w) (capture w)) (if (enemy? sw) (capture sw)) (if (enemy? e) (capture e)) (if (enemy? se) (capture se)) add ) ) ( define troll-5 ( mark (opposite $1) (verify friend?) (opposite $1) (verify friend?) (opposite $1) (verify friend?) (opposite $1) (verify friend?) back $1 (verify empty?) $1 (verify empty?) $1 (verify empty?) $1 (verify empty?) $1 (verify empty?) (verify (or (enemy? n) (enemy? nw) (enemy? s) (enemy? ne) (enemy? w) (enemy? sw) (enemy? e) (enemy? se))) (if (enemy? n) (capture n)) (if (enemy? nw) (capture nw)) (if (enemy? s) (capture s)) (if (enemy? ne) (capture ne)) (if (enemy? w) (capture w)) (if (enemy? sw) (capture sw)) (if (enemy? e) (capture e)) (if (enemy? se) (capture se)) add ) ) ( define troll-6 ( mark (opposite $1) (verify friend?) (opposite $1) (verify friend?) (opposite $1) (verify friend?) (opposite $1) (verify friend?) (opposite $1) (verify friend?) back $1 (verify empty?) $1 (verify empty?) $1 (verify empty?) $1 (verify empty?) $1 (verify empty?) $1 (verify empty?) (verify (or (enemy? n) (enemy? nw) (enemy? s) (enemy? ne) (enemy? w) (enemy? sw) (enemy? e) (enemy? se))) (if (enemy? n) (capture n)) (if (enemy? nw) (capture nw)) (if (enemy? s) (capture s)) (if (enemy? ne) (capture ne)) (if (enemy? w) (capture w)) (if (enemy? sw) (capture sw)) (if (enemy? e) (capture e)) (if (enemy? se) (capture se)) add ) ) ( define troll-7 ( mark (opposite $1) (verify friend?) (opposite $1) (verify friend?) (opposite $1) (verify friend?) (opposite $1) (verify friend?) (opposite $1) (verify friend?) (opposite $1) (verify friend?) back $1 (verify empty?) $1 (verify empty?) $1 (verify empty?) $1 (verify empty?) $1 (verify empty?) $1 (verify empty?) $1 (verify empty?) (verify (or (enemy? n) (enemy? nw) (enemy? s) (enemy? ne) (enemy? w) (enemy? sw) (enemy? e) (enemy? se))) (if (enemy? n) (capture n)) (if (enemy? nw) (capture nw)) (if (enemy? s) (capture s)) (if (enemy? ne) (capture ne)) (if (enemy? w) (capture w)) (if (enemy? sw) (capture sw)) (if (enemy? e) (capture e)) (if (enemy? se) (capture se)) add ) )

लेकिन जहां लूप पास होते हैं, हमारी सहायता के लिए पुनरावृत्ति आएगी:

पुनरावृत्ति, जैसा कि कहा गया था

 (define! repeat (if-less! 0 $1 $2* (! repeat (!! (sum! $1 -1)) $2*) ) ) (define! troll-n (if-less! 0 $1 (for! $d ($ -all-directions) ( (if-less! 1 $1 mark (repeat $1 (opposite $d) (verify friend?) ) back ) (repeat $1 $d (verify empty?) ) (if-less! 1 $1 (verify (or (for! $dd ($ -all-directions) (enemy? $dd) ) ) ) ) (for! $dd ($ -all-directions) (if (enemy? $dd) (capture $dd) ) ) add ) ) (! troll-n (!! (sum! $1 -1))) ) ) ... (! troll-n 7)

यह मूल संस्करण की तुलना में समझना कुछ अधिक कठिन है, लेकिन कोई कॉपी-पेस्ट नहीं है। मैं आपको दोहराने के कार्यान्वयन पर विशेष ध्यान देने के लिए कहता हूं। यह मैक्रो बहुत उपयोगी है और भविष्य में हमारे द्वारा बार-बार उपयोग किया जाएगा।

 (! repeat 3 abc) ; => abcabcabc

थुड के मूल कार्यान्वयन में! एक और जगह है जिसे मैं अनुकूलित करना चाहता हूं:

 ( define check-rock ( check-rock-direction n ne e se s sw w nw) ( check-rock-direction ne e se s sw w nw n) ( check-rock-direction e se s sw w nw n ne) ( check-rock-direction se s sw w nw n ne e) ( check-rock-direction s sw w nw n ne e se) ( check-rock-direction sw w nw n ne e se s) ( check-rock-direction w nw n ne e se s sw) ( check-rock-direction nw n ne e se s sw w) )

मैन्युअल रूप से आठ तत्वों के एक सेट के सभी चक्रीय क्रमांकन की गणना करके, गलतियों को करना आसान है। सबसे पहले, हम एक मैक्रो को परिभाषित करते हैं जो हमें सूची का एक टुकड़ा "कट आउट" करने की अनुमति देता है:

 (define! range (if-less-or-equal! $1 $2 (nth! $1 $3) (! range (!! (sum! $1 1)) $2*) ) ) (! range 3 4 (abcde)) ; => cd

फ़ंक्शन (nth! N सूची) , यहां, आपको सूची का nth तत्व प्राप्त करने की अनुमति देता है। आइए सूची को "घुमाने" का प्रयास करें:

 (define! rotate (if-less! 0 $1 $2 (! rotate (!! (sum! $1 -1)) ((splice! ((! range 2 8 $2)) ((nth! 1 $2))))) ) ) (! rotate 2 (abcdefgh)) ; => (abcdefgh) (bcdefgha)

यह सामान्य प्रतीत होता है, लेकिन पहले से ही ((रोटेट 3 (abcdefgh))) एक त्रुटि देता है:

त्रुटि संदेश

विस्तार से [सूची "(nth! 2 ((ब्याह! (!! श्रेणी 2 8 (abc) ...) में तर्क प्रतिस्थापन पर [सूची" (nth! $ 1 $ 3) "t.prezrf, पंक्ति 3] में" सूची "(श्रेणी) के लिए 2 8 (ब्याह! (! (! श्रेणी 2 8 (ab "... विस्तार में!) [सूची"! (! सीमा 2 8 ((ब्याह!)! (श्रेणी 2 8 (a) ... तर्क सूची में तर्क "सूची में" रेंज 2 8 $ 2) "t.prezrf, लाइन 11] के लिए [सूची" (रोटेट 2 ((ब्याह! - (रेंज 2 8) (ab) ... विस्तार में!] [सूची "!)! (रोटेट 2 (ब्याह) के लिए ! ((श्रेणी 2 8 (एक ... [सूची में "तर्क प्रतिस्थापन पर ... (बारी बारी से! (योग! $ 1 -1)) ((ब्याह! (" ... t.prezrf, लाइन 11 पर] के लिए [! सूची "(3 घुमाएँ (abcdefgh))" विस्तार में! [की सूची "((रोटेट 3 (abcdefgh))" पर t.prezrf, लाइन 15]]]]]]]:
इस सूची के लिए t.prezrf, लाइन 3 पर "सूची" (nth! 2 ((!!!! सीमा 2 8 (abc) ...) में तर्क सूची में (nth! $ 1 $ 3) "t.prezrf, लाइन 3 पर" 2 8 (ब्याह! (! (! श्रेणी 2 8 (ab "... विस्तार में!) [सूची"! (! सीमा 2 8 ((ब्याह!)! (श्रेणी 2 8 (a) ... तर्क सूची में तर्क "सूची में" रेंज 2 8 $ 2) "t.prezrf, लाइन 11] के लिए [सूची" (रोटेट 2 ((ब्याह! - (रेंज 2 8) (ab) ... विस्तार में!] [सूची "!)! (रोटेट 2 (ब्याह) के लिए ! ((श्रेणी 2 8 (एक ... [सूची में "तर्क प्रतिस्थापन पर ... (बारी बारी से! (योग! $ 1 -1)) ((ब्याह! (" ... t.prezrf, लाइन 11 पर] के लिए [! सूची "(3 घुमाएँ (abcdefgh))" विस्तार में! [की सूची "((रोटेट 3 (abcdefgh))" पर t.prezrf, लाइन 15]]]]]]]:
1 आइटम के साथ सूची के आइटम # 2 प्राप्त करने की कोशिश कर रहा है

जैसा कि आप देख सकते हैं, यह C ++ टेम्प्लेट संकलित करते समय त्रुटि संदेशों के रूप में व्यापक नहीं है, लेकिन यह बहुत स्पष्ट नहीं है। मैंने काफी समय तक प्रीज़्रफ के साथ काम किया और इसके साथ अपेक्षाकृत दर्द रहित काम के बारे में अपने लिए अंगूठे के दो नियमों के साथ आया:

पुनरावर्ती मैक्रोज़ के तर्क के रूप में उत्परिवर्ती सूचियों को पारित न करें
के उपयोग को सीमित करें ! सबसे सरल मामले

इन नियमों से कोई भी विचलन, कई बार, मेरे दिमाग को उड़ाने की धमकी देता है, जो कुछ हुआ उसका सार समझने की कोशिश करता है। आइए पहले नियम की भावना से हमारे घूमने की कोशिश करें:

 (define! rotate (if-less! 0 $1 ((splice! ((! range (!! (sum! $1 1)) (!! (length! $2)) $2)) ((! range 1 $1 $2)) )) (! rotate (!! (sum! $1 -1)) $2) ) (if-equal! 0 $1 $2 ) )

वह डरावना दिखने लगा, लेकिन वह काम करता है! अब हम उसके साथ क्या करेंगे? हमें एक कारण के लिए क्रमपरिवर्तन की आवश्यकता है, हमें इन तर्कों को चेक-रॉक-दिशा में पास करना होगा। बेशक, मैक्रो को इससे कॉल करके घुमाने के लिए संबंधित परिवर्तन करना संभव होगा, लेकिन यह घुमाएगा सार्वभौमिक नहीं। जाहिर है, कार्यात्मक प्रोग्रामिंग के गुप्त हथियार को उजागर करने का समय आ गया है - उच्च-क्रम के कार्य :

 (define! map ($!3 (! map $1 $2 (!! (length! $2))) ) ($?3 (if-less! 0 $3 ($1 (!! (nth! $3 $2))) (! map $1 $2 (!! (sum! $3 -1))) ) ) ) (define check-rock (! map check-rock-direction (!! ((! rotate (!! (sum! (!! (length! ($ -all-directions))))) ($ -all-directions) ))) ) )

मुझे इसके साथ टिंकर करना था, लेकिन यह इसके लायक था। इस सभी कोड में मुख्य स्थान यहाँ है: ($ 1 ...) । यह भी काम करता है, जो अच्छी खबर है। वास्तव में, हम इस विकल्प पर रोक सकते हैं यदि यह परिणामी ZRF फ़ाइल के आकार के लिए नहीं था। 14-किलोबाइट स्रोत से सभी मैक्रोज़ को तैनात करते समय, प्रीप्रोसेसर को मेगाबाइट विवरण फ़ाइल से अधिक प्राप्त होता है! कहने की जरूरत नहीं है, ZoG इस ZRF-ku को धीरे-धीरे डाउनलोड करता है।

इस दुर्भाग्य से कैसे उबरें? हाँ, मैक्रोज़ की मदद से (हमारे पास और कुछ नहीं है):

मैक्रोज़ मैक्रोज़ बनाते हैं

 (define! troll-n (if-less! 0 $1 (define (concat! troll - $1) ( (if-less! 1 $1 mark (repeat (!! (sum! $1 -1)) (opposite (concat! $ 1)) (verify friend?) ) back ) (repeat $1 (concat! $ 1) (verify empty?) ) (if-less! 1 $1 (verify (or (for! $dd ($ -all-directions) (enemy? $dd) ) ) ) ) (for! $dd ($ -all-directions) (if (enemy? $dd) (capture $dd) ) ) add ) ) (! troll-n (!! (sum! $1 -1))) ) ) (! troll-n 7) (define! troll-all (if-less! 0 $1 (for! $d ($ -all-directions) ( (concat! troll - $1) $d ) ) (! troll-all (!! (sum! $1 -1))) ) )

निर्माण ((ट्रोल-एन 7) क्रमिक रूप से ZRF मैक्रोज़ ट्रोल -1, ट्रोल -2, ... ट्रोल -7 (उनके अनुक्रम का क्रम हमारे लिए महत्वपूर्ण नहीं है) की परिभाषाएँ बनाता है, लेकिन (! ट्रोल-ऑल) , सही जगह पर बुलाया जा रहा है ! उनकी चुनौतियों को सूचीबद्ध करेगा। यह डिजाइन (कॉनटैट! $ 1) पर ध्यान देने योग्य है। इस तरह के जटिल तरीके से, हम ZRF मैक्रो के शरीर में $ 1 बनाते हैं। यदि हम सिर्फ $ 1 कहते हैं, तो यह बहुत अच्छी तरह से काम नहीं करेगा।

परिणाम प्रभावित करने के लिए धीमा नहीं है। परिणामी ZRF फ़ाइल का आकार 28 किलोबाइट तक कम हो जाता है। कोई इसे और भी छोटा बना सकता है, लेकिन मुझे इसमें ज्यादा समझ नहीं है। यह मूल के समान काम करता है, जिसका अर्थ है कि हमारी लंबी यात्रा पर हमने कोई गलती नहीं की।

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

टिप्पणी

लेख के चित्रण के रूप में, प्रसिद्ध कलाकार मौरिस एस्चर के काम का उपयोग किया गया था ।

स्टेरॉयड पर ZoG

More articles: