🕖 🤱 🥙 विकास के दौरान आपको जो करने की आवश्यकता नहीं है, उसकी कहानी 🌽 👖 🎐

प्रस्तावना: शुरू करने के लिए, मैं इस परियोजना के बारे में बात करूंगा ताकि हम इस बारे में विचार करें कि हमने परियोजना पर कैसे काम किया और उस दर्द को फिर से पैदा किया जो हमें लगा।

एक डेवलपर के रूप में, मैंने 2015-2016 में इस परियोजना में प्रवेश किया, मुझे बिल्कुल याद नहीं है, लेकिन इसने 2-3 साल पहले काम किया था। परियोजना अपने क्षेत्र में बहुत लोकप्रिय थी, अर्थात् खेल सर्वर। यह कितना अजीब लग रहा था, लेकिन आज तक गेम सर्वर पर परियोजनाएं जारी नहीं हैं, हाल ही में मैंने रिक्तियों को देखा और उसी टीम पर थोड़ा काम किया। चूंकि गेम सर्वर पहले से ही बनाए गए गेम पर बनाए गए हैं, इसलिए, एक स्क्रिप्टिंग भाषा का उपयोग विकास के लिए किया जाता है जो गेम इंजन में बनाया गया है।

हम गैरी के मॉड (Gmod) पर एक परियोजना को लगभग खरोंच से विकसित कर रहे हैं, यह ध्यान रखना महत्वपूर्ण है कि लेखन के समय, हैरी पहले से ही असत्य इंजन पर एक नया S & Box प्रोजेक्ट बना रहा है। हम अभी भी सोर्स पर बैठे हैं।

जो आम तौर पर हमारे सर्वर थीम के लिए उपयुक्त नहीं है।

"भयानक अपनी कहानी?" - आप पूछें।

हमारे पास गेम सर्वर के लिए एक मजबूत विषय है, "स्टॉकर" और यहां तक कि रोल-प्लेइंग गेम (आरपी) के तत्वों के साथ, सवाल तुरंत उठता है - "हर कोई एक सर्वर पर इसे कैसे लागू कर सकता है?"।

यह देखते हुए कि स्रोत इंजन पुराना है (2013 संस्करण को Gmod 32 बिट में भी उपयोग किया जाता है), आपने बड़े कार्ड नहीं बनाए हैं, एंटिटी, मेश की संख्या पर छोटे प्रतिबंध हैं, और भी बहुत कुछ।

इंजन पर कौन काम करेगा, समझ जाएगा।

यह पता चला है कि आम तौर पर असंभव काम है, quests के साथ एक स्वच्छ मल्टीप्लेयर शिकारी बनाने के लिए, मूल तत्वों से आरपीजी तत्वों और अधिमानतः एक छोटा सा भूखंड।

सबसे पहले, प्रारंभिक वर्तनी मुश्किल थी (श्रेणी से कई क्रियाएं: किसी वस्तु को फेंकना, किसी वस्तु को उठाना खरोंच से लिखा गया था), उम्मीद है कि इसे जारी रखना आसान होगा, लेकिन आवश्यकताएं बढ़ गईं। खेल का यांत्रिकी तैयार था, जो कुछ बचा था वह खुफिया, उन्नयन और सभी प्रकार की चीजों को करना था। सामान्य तौर पर, सभी के रूप में वे स्थानांतरित कर सकते थे।

समस्याएं पहले रिलीज़ के पहले संस्करण के काम के दौरान शुरू हुईं, अर्थात् (लैग्स, सर्वर देरी)।

जैसा एक शक्तिशाली सर्वर आसानी से अनुरोधों को हैंडल और सभी gamemode रख सकते हैं।

गाममोड का सरल विवरण

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

बड़ी संख्या में खिलाड़ियों के कारण सर्वर साइड पर लैग थे, क्योंकि एक खिलाड़ी लगभग 80-120 एमबी (इन्वेंट्री, स्किल्स इत्यादि में आइटमों की गिनती नहीं करता) की बहुत सारी रैम को खाता है, और क्लाइंट की तरफ से मजबूत कमी आई थी। एफपीएस।

भौतिक विज्ञान प्रसंस्करण के लिए सीपीयू शक्ति पर्याप्त नहीं थी, भौतिक गुणों वाली वस्तुओं का कम उपयोग करना आवश्यक था।

तो इसके अलावा हमारी स्व-लिखित स्क्रिप्ट भी थीं जो बिल्कुल भी अनुकूलित नहीं थीं।

सबसे पहले, निश्चित रूप से, हम लुआ में अनुकूलन पर लेख पढ़ते हैं। यहां तक कि यह ~~आत्महत्या~~ करने के लिए आया था कि वे C ++ में DLL लिखना चाहते थे, लेकिन सर्वर से क्लाइंट तक DLL को डाउनलोड करने में समस्या उत्पन्न हुई। डीएलएल के लिए सी ++ का उपयोग करते हुए, आप एक प्रोग्राम लिख सकते हैं जो चुपचाप डेटा को इंटरसेप्ट करता है; गमोड डेवलपर्स ने क्लाइंट्स द्वारा डाउनलोड करने के अपवादों के लिए एक एक्सटेंशन जोड़ा (सुरक्षा, हालांकि वास्तव में ऐसा कभी नहीं हुआ)। हालांकि यह सुविधाजनक होगा और गमोड अधिक लचीला हो जाएगा, लेकिन अधिक खतरनाक।

अगला, हमने प्रोफाइलर को देखा (सौभाग्य से, स्मार्ट लोगों ने इसे लिखा था) और कार्यों में एक डरावनी थी, यह देखा गया कि पहले से ही गमोड इंजन लाइब्रेरी में बहुत धीमी गति से कार्य थे।

यदि आपने गमोड में लिखने की कोशिश की, तो आप अच्छी तरह से जानते हैं कि एक पुस्तकालय है जिसे गणित कहा जाता है।

और इसमें सबसे धीमे कार्य गणित के हैं। क्लैंप और गणित।

कोड में खुदाई देखा गया है कि लोगों को अलग अलग दिशाओं में काम करता है पहुंचे, यह लगभग हर जगह प्रयोग किया जाता है, लेकिन यह गलत है!

चलो अभ्यास करने के लिए। उदाहरण के लिए, हम इकाई को स्थानांतरित करने के लिए स्थिति वेक्टर के निर्देशांक को गोल करना चाहते हैं (उदाहरण के लिए, एक खिलाड़ी)।

local x = 12.5 local y = 14.9122133 local z = 12.111 LocalPlayer():SetPos( Vector( Math.Round(x), Math.Round(y), Math.Round(z) )

3 जटिल गोलाई कार्य, लेकिन गंभीर कुछ भी नहीं, जब तक कि एक लूप में नहीं है और अक्सर उपयोग नहीं किया जाता है, लेकिन क्लैम्प और भी कठिन है।

निम्नलिखित कोड अक्सर परियोजनाओं में उपयोग किया जाता है और कोई भी कुछ भी बदलना नहीं चाहता है।

 self:setLocalVar("hunger", math.Clamp(current + 1, 0, 100))

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

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

ऑप्टिमाइज़ेशन वास्तव में बहुत सरल है, आप भारी लोड कार्यों को स्थानीय करते हैं। यह आदिम लगता है, लेकिन 3 गेममोड और कई ऐड-ऑन में मैंने यह धीमा कोड देखा।

आप मूल्य प्राप्त करने के लिए और भविष्य में इसका इस्तेमाल की जरूरत है, इसे फिर से नहीं करता है, तो यह नहीं बदला गया है है। आखिरकार, किसी भी स्थिति में सर्वर में प्रवेश करने वाले खिलाड़ी को 100 के बराबर भूख प्राप्त होगी, इसलिए यह कोड कई गुना तेज है।

 local value = math.Clamp(current + 1, 0, 100) self:setLocalVar("hunger", value)

सब ठीक है, उन्होंने आगे देखना शुरू किया कि यह कैसे काम करता है। अंत में, हम उन्माद को बंद कर सभी अनुकूलित।

हमने देखा कि लूप के लिए मानक धीमा है और हमने अपनी बाइक के साथ आने का फैसला किया है जो कि तेज होगी (हम लाठी के बारे में नहीं भूले) और फिर खेल शुरू हुआ।

बिगाड़ने

हमने लुआ गमोड पर सबसे तेज़ लूप बनाने में भी कामयाबी हासिल की, लेकिन इस शर्त पर कि इसमें 100 से अधिक तत्व होने चाहिए।

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

यही कारण है कि लुआ Gmod को scripters होना आम बात है:

 local anomtable = ents.FindByClass("anom_*") for k, v in pairs(anomtable) do v:Remove() end

यहाँ धूम्रपान करने वाले के लिए है:

यह तुरंत स्पष्ट है कि ऐसा ~~जी * स्पष्ट रूप से~~ कोड "जोड़े में" के मानक से धीमा होगा, लेकिन जैसा कि यह निकला नहीं।

 local b, key = ents.FindByClass("anom_*"), nil repeat key = next(b, key) b[key]:Remove() until key != nil

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

वैनिला चक्र:

 local anomtable = { 1, 2, 3, 4, 5 } for k, v in pairs(anomtable) do v = v + 1 end ) करना local anomtable = { 1, 2, 3, 4, 5 } for k, v in pairs(anomtable) do v = v + 1 end

हमारा महान है:

 local b, key = { 1, 2, 3, 4, 5 }, nil repeat key = next(b, key) b[key] = b[key] + 1 until key ~= nil

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

बस मामले में, स्क्रीन से जोंस को हटा दें। मैंने चेतावनी दी।

वेनिला चक्र disassembler

 ; Name: for1.lua ; Defined at line: 0 ; #Upvalues: 0 ; #Parameters: 0 ; Is_vararg: 2 ; Max Stack Size: 7 1 [-]: NEWTABLE R0 5 0 ; R0 := {} 2 [-]: LOADK R1 K0 ; R1 := 1 3 [-]: LOADK R2 K1 ; R2 := 2 4 [-]: LOADK R3 K2 ; R3 := 3 5 [-]: LOADK R4 K3 ; R4 := 4 6 [-]: LOADK R5 K4 ; R5 := 5 7 [-]: SETLIST R0 5 1 ; R0[(1-1)*FPF+i] := R(0+i), 1 <= i <= 5 8 [-]: GETGLOBAL R1 K5 ; R1 := pairs 9 [-]: MOVE R2 R0 ; R2 := R0 10 [-]: CALL R1 2 4 ; R1,R2,R3 := R1(R2) 11 [-]: JMP 13 ; PC := 13 12 [-]: ADD R5 R5 K0 ; R5 := R5 + 1 13 [-]: TFORLOOP R1 2 ; R4,R5 := R1(R2,R3); if R4 ~= nil then begin PC = 12; R3 := R4 end 14 [-]: JMP 12 ; PC := 12 15 [-]: RETURN R0 1 ; return

साइकिल चक्र disassembler

 ; Name: for2.lua ; Defined at line: 0 ; #Upvalues: 0 ; #Parameters: 0 ; Is_vararg: 2 ; Max Stack Size: 6 1 [-]: NEWTABLE R0 5 0 ; R0 := {} 2 [-]: LOADK R1 K0 ; R1 := 1 3 [-]: LOADK R2 K1 ; R2 := 2 4 [-]: LOADK R3 K2 ; R3 := 3 5 [-]: LOADK R4 K3 ; R4 := 4 6 [-]: LOADK R5 K4 ; R5 := 5 7 [-]: SETLIST R0 5 1 ; R0[(1-1)*FPF+i] := R(0+i), 1 <= i <= 5 8 [-]: LOADNIL R1 R1 ; R1 := nil 9 [-]: GETGLOBAL R2 K5 ; R2 := next 10 [-]: MOVE R3 R0 ; R3 := R0 11 [-]: MOVE R4 R1 ; R4 := R1 12 [-]: CALL R2 3 2 ; R2 := R2(R3,R4) 13 [-]: MOVE R1 R2 ; R1 := R2 14 [-]: GETTABLE R2 R0 R1 ; R2 := R0[R1] 15 [-]: ADD R2 R2 K0 ; R2 := R2 + 1 16 [-]: SETTABLE R0 R1 R2 ; R0[R1] := R2 17 [-]: EQ 1 R1 K6 ; if R1 == nil then PC := 9 18 [-]: JMP 9 ; PC := 9 19 [-]: RETURN R0 1 ; return

एक अनुभवहीन व्यक्ति बस यह कहेगा कि एक नियमित चक्र तेज है क्योंकि कम निर्देश हैं (15 बनाम 19)।

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

दूसरे संस्करण में, विधि भिन्न होती है, जो स्मृति के आधार पर अधिक होती है, यह एक तालिका प्राप्त करती है, एक तत्व बदलती है, एक तालिका सेट करती है, शून्य की जांच करती है और फिर से कॉल करती है।
तथ्य के कारण हमारा दूसरा तेजी से चक्र है कि एक पुस्तिका भी कई की स्थिति और कार्यों (R4, R5: = आर 1 (R2, R3) R3; R4 ~ = शून्य तो शुरू करता है, तो पीसी = 12: = R4 अंत) में इस वजह से यह बहुत खाता है , निष्पादन के लिए सीपीयू घड़ी चक्र खाता है, अतीत फिर से स्मृति से बंधा हुआ है।

बड़ी संख्या में तत्वों के साथ निर्देश सभी तत्वों के पारित होने की गति पर हमारे चक्र को आत्मसमर्पण करता है। यह इस तथ्य के कारण है कि सीधे पते से संबोधित करना तेज है, जोड़े से किसी भी उपहार से कम है। (और हमारे पास कोई इनकार नहीं है)

सामान्य तौर पर, गुप्त रूप से, कोड में नकार का कोई भी उपयोग इसे धीमा कर देता है, यह पहले से ही परीक्षण और समय से परीक्षण किया जा चुका है। नकारात्मक तर्क अधिक धीरे-धीरे काम करेगा, क्योंकि प्रोसेसर ALU में एक अलग कंप्यूटिंग यूनिट "इन्वर्टर" है, एकरी ओपरेटरी के लिए (नहीं;) काम करने के लिए, आपको इन्वर्टर एक्सेस करने की आवश्यकता है और इसमें अतिरिक्त समय लगेगा।

निष्कर्ष: सब कुछ मानक हमेशा बेहतर नहीं होता है, आपकी साइकिलें उपयोगी हो सकती हैं, लेकिन फिर से एक वास्तविक परियोजना पर, आपको उनके साथ नहीं आना चाहिए यदि रिलीज़ गति आपके लिए महत्वपूर्ण है। नतीजतन, हमने 2014 से लेकर आज तक का पूरा विकास किया है, एक और "वेटिंग" का। यद्यपि यह एक नियमित गेम सर्वर की तरह लगता है जो 1 दिन में स्थापित होता है और 2 दिनों में गेम के लिए पूरी तरह से कॉन्फ़िगर किया जाता है, आपको कुछ नया पेश करने में सक्षम होना चाहिए।

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

विकास के दौरान आपको जो करने की आवश्यकता नहीं है, उसकी कहानी

More articles: