अगर यह मायने रखता है, तो मैं एकता में सी # के साथ काम कर रहा हूं।

वैसे भी, मैं एक 2D टॉप-डाउन गेम पर काम कर रहा हूं और, हमारे पानी (और विभिन्न अन्य पर्यावरणीय खतरों, जिनकी प्रत्यक्ष गेमप्ले प्रासंगिकता है) का अनुकरण करने के लिए, मैं एक बड़े 2D ग्रिड का उपयोग करता हूं जो स्टोर करता है कि किसी दिए गए स्थान में क्या खतरा है। एक अंतराल पर, मैं ग्रिड के माध्यम से पुनरावृति करता हूं और प्रत्येक स्थान अपने 4 आसन्न स्थानों पर प्रतिक्रिया करता है। यह प्रक्रिया समस्याग्रस्त रूप से धीमी नहीं है, लेकिन मुझे यह नापसंद है कि यह सब एक धागे से कैसे जुड़ा है और नकली क्षेत्र में बड़ी मात्रा में खतरे होने पर समय का एक अच्छा हिस्सा लेता है।

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

-2
Khide Hoskins 15 मार्च 2020, 20:01

1 उत्तर

सबसे बढ़िया उत्तर

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

0
Khide Hoskins 28 मार्च 2020, 06:15