AIMBOT 2.0
ન્યૂ ગેમ 2 ના 1 એપિસોડમાં, 9:40 ની આસપાસ, નેનેએ લખેલા કોડનો શોટ છે:
ભાષાંતરિત ટિપ્પણીઓ સાથે તે અહીં ટેક્સ્ટ સ્વરૂપમાં છે:
// the calculation of damage when attacked void DestructibleActor::ReceiveDamage(float sourceDamage) { // apply debuffs auto resolvedDamage = sourceDamage; for (const auto& debuf:m_debufs) { resolvedDamage = debuf.ApplyToDamage(resolvedDamage); m_currentHealth -= resolvedDamage if (m_currentHealth <= 0.f) { m_currentHealth = 0.f; DestroyMe(); } } } શોટ પછી, ઉમિકોએ, લૂપ તરફ ઇશારો કરતાં કહ્યું કે કોડ ક્રેશ થવાનું કારણ એ છે કે ત્યાં અનંત લૂપ છે.
હું ખરેખર સી ++ જાણતો નથી તેથી તેણી જે કહે છે તે સાચું છે કે નહીં તેની મને ખાતરી નથી.
હું જે જોઈ શકું છું તેનાથી, અભિનેતા પાસે હાલમાં આવેલા ડબ્સ દ્વારા ફક્ત લૂપ ફરી વળવું છે. જ્યાં સુધી અભિનેતા પાસે અનંત માત્રામાં ડિબ્સ નથી, મને નથી લાગતું કે તે કદાચ અનંત લૂપ બની શકે.
પરંતુ મને ખાતરી નથી કારણ કે કોડનો શોટ હોવાના એકમાત્ર કારણ એ છે કે તેઓ અહીં ઇસ્ટર ઇંડા મૂકવા માગે છે, બરાબર? અમે લેપટોપના પાછલા ભાગનો શોટ મેળવ્યો હોત અને ઉમિકોને "ઓહ તમને ત્યાં અનંત લૂપ મળ્યો છે" એમ કહેતા સાંભળ્યા હોત. હકીકત એ છે કે તેઓએ ખરેખર કેટલાક કોડ બતાવ્યાં છે તે મને લાગે છે કે કોઈક કોડ કોઈ પ્રકારનો ઇસ્ટર ઇંડું છે.
શું કોડ ખરેખર અનંત લૂપ બનાવશે?
8- સંભવત સહાયક: ઉમિકોનો અતિરિક્ત સ્ક્રીનશ sayingટ કહેતા કે "તે હતું એ જ કામગીરીને બોલાવી રહ્યા છીએ ફરીથી અને ફરીથી ", જે કદાચ કોડમાં બતાવવામાં ન આવે.
- ઓહ! મને તે ખબર નહોતી! @ અકીટાનાકા સબ જે મેં જોયું તે કહે છે "અનંત લૂપ"
- @ LoganM હું ખરેખર સહમત નથી તે ફક્ત એટલું જ નથી કે ઓપીમાં કેટલાક સ્રોત કોડ વિશે કોઈ પ્રશ્ન છે જે એનાઇમથી આવવા માટે બન્યો હતો; ઓ.પી.નો પ્રશ્ન એક નિવેદનમાં કરવામાં આવેલા નિવેદનો વિશે છે વિશે એનાઇમના પાત્ર દ્વારા સ્રોત કોડ, અને એનાઇમથી સંબંધિત જવાબ છે, એટલે કે "ક્રંચાયરોલ ડૂફ ગોફ્ડ અને લાઇનનો ખોટો અર્થ".
- @ સેનશિન મને લાગે છે કે તમે ખરેખર જે પૂછવામાં આવ્યું છે તેના કરતા તમે જે પ્રશ્ન પૂછવા માંગો છો તે વાંચી રહ્યાં છો. પ્રશ્ન કેટલાક સ્રોત કોડ પ્રદાન કરે છે અને પૂછે છે કે શું તે રીઅલ-લાઇફ સી ++ કોડ તરીકે અનંત લૂપ ઉત્પન્ન કરે છે. નવી રમત! એક કાલ્પનિક કૃતિ છે; વાસ્તવિક જીવન ધોરણોને અનુરૂપ બનાવવા માટે તેમાં કોઈ કોડ રજૂ કરવાની જરૂર નથી. ઉમિકો કોડ વિશે શું કહે છે તે કોઈપણ સી ++ ધોરણો અથવા કમ્પાઇલર્સ કરતા વધુ અધિકૃત છે. ઉચ્ચ (સ્વીકૃત) જવાબમાં બ્રહ્માંડની કોઈપણ માહિતીનો ઉલ્લેખ નથી. મને લાગે છે કે સારા વિષય સાથે આ વિષય પર કોઈ સવાલ પૂછવામાં આવી શકે છે, પરંતુ શબ્દો મુજબ આ તે નથી.
કોડ અનંત લૂપ નથી પરંતુ તે ભૂલ છે.
ત્યાં બે (સંભવત three ત્રણ) મુદ્દાઓ છે:
- જો કોઈ ડિબફ્સ હાજર ન હોય તો કોઈ નુકસાન બિલકુલ લાગુ કરવામાં આવશે નહીં
- જો 1 થી વધુ ડિબફ હોય તો વધારે નુકસાન લાગુ કરવામાં આવશે
- જો ડિસ્ટ્રોમાઇ () તુરંત જ deleબ્જેક્ટને કા .ી નાખશે અને હજી પણ પ્રક્રિયા કરવા માટે m_debufs છે, તો લૂપ કા deletedી નાખેલ objectબ્જેક્ટ પર ચલાવવામાં આવશે અને મેમરીને ટ્રેશ કરવામાં આવશે. મોટાભાગના રમત એન્જિનો પાસે આનાથી વધુ કામ કરવા માટે વિનાશની કતાર હોય છે અને તેથી વધુ કે જેથી તે કોઈ મુદ્દો ન હોઈ શકે.
નુકસાનની એપ્લિકેશન લૂપની બહાર હોવી જોઈએ.
અહીં સુધારેલ કાર્ય છે:
// the calculation of damage when attacked void DestructibleActor::ReceiveDamage(float sourceDamage) { // apply debuffs auto resolvedDamage = sourceDamage; for (const auto& debuf:m_debufs) { resolvedDamage = debuf.ApplyToDamage(resolvedDamage); } m_currentHealth -= resolvedDamage if (m_currentHealth <= 0.f) { m_currentHealth = 0.f; DestroyMe(); } } - 15 શું આપણે કોડ રિવ્યુ પર છીએ? : ડી
- જો તમે 16777216 HP કરતા ઉપર ન જાઓ તો 4 ફ્લોટ્સ આરોગ્ય માટે શ્રેષ્ઠ છે. તમે સ્વાસ્થ્યને અનંતમાં સેટ કરી શકો છો તે દુશ્મન બનાવવા માટે કે જેને તમે ફટકારી શકો છો, પરંતુ મરી શકશે નહીં, અને અનંત નુકસાનનો ઉપયોગ કરીને એક-હુમલો કરી શકો છો જે હજી પણ અનંત એચપી પાત્રને નહીં मार શકે (INF-INF નું પરિણામ NaN છે) પરંતુ બીજું બધું મારી નાખશે. તેથી તે ખૂબ ઉપયોગી છે.
- 1 @ કેટ કેટલાંક કોડિંગ ધોરણોમાં સંમેલન દ્વારા
m_ઉપસર્ગનો અર્થ એ છે કે તે સભ્ય ચલ છે. આ કિસ્સામાં સભ્ય ચલDestructibleActor. - 2 @ હોટેલકાલીફોર્નીયા, હું સંમત છું ત્યાં થોડી તક છે
ApplyToDamageઅપેક્ષા મુજબ કામ કરતું નથી પણ ઉદાહરણ તરીકે તમે આપી શકશો હું કહીશApplyToDamageપણ તેને મૂળ પસાર કરવાની જરૂરિયાત માટે ફરીથી કાર્ય કરવાની જરૂર છેsourceDamageતેમજ જેથી તે તે કેસોમાં ડેબફની યોગ્ય ગણતરી કરી શકે. એક સંપૂર્ણ પેડન્ટ બનવા માટે: આ સમયે ડીએમજી માહિતી એક સ્ટ્રક્ટ હોવી જોઈએ જેમાં મૂળ ડીએમજી, વર્તમાન ડીએમજી, અને નુકસાન (ઓ) ની પ્રકૃતિ શામેલ હોવી જોઈએ તેમજ જો ડિફફ્સમાં "ફાયરની નબળાઈ" જેવી વસ્તુઓ હોય. અનુભવમાંથી, ડેબફ્સ સાથેની કોઈપણ રમત ડિઝાઇન આ માંગ કરે તે પહેલાં તે લાંબું સમય નથી. - 1 @StephaneHockenhull સારી રીતે કહ્યું!
કોડ અનંત લૂપ બનાવતો હોય તેવું લાગતું નથી.
લૂપ અનંત હશે એકમાત્ર રસ્તો જો હશે
debuf.ApplyToDamage(resolvedDamage); અથવા
DestroyMe(); માં નવી આઇટમ્સ ઉમેરવાની હતી m_debufs કન્ટેનર
આ અસંભવિત લાગે છે. અને જો તે સ્થિતિ હોત, તો પુનરાવર્તિત થતાં કન્ટેનર બદલવાના કારણે પ્રોગ્રામ ક્રેશ થઈ શકે છે.
પ્રોગ્રામ મોટા ભાગે ક theલ કરવાને કારણે ક્રેશ થઈ જશે DestroyMe(); જે સંભવત the વર્તમાન લૂપને નષ્ટ કરે છે જે હાલમાં લૂપ ચલાવી રહ્યું છે.
આપણે તે કાર્ટૂન તરીકે વિચારી શકીએ છીએ જ્યાં 'ખરાબ વ્યક્તિ' તેની સાથે 'સારા વ્યક્તિ' પડવા માટે એક શાખા જોયો છે, પરંતુ ખૂબ મોડું થઈ ગયું છે કે તે કાપી નાખવાની ખોટી બાજુ છે. અથવા મિડગાર્ડ સાપ તેની પોતાની પૂંછડી ખાય છે.
મારે એ પણ ઉમેરવું જોઈએ કે અનંત લૂપનું સૌથી સામાન્ય લક્ષણ તે છે કે તે પ્રોગ્રામને સ્થિર કરે છે અથવા તેને પ્રતિભાવશીલ નથી બનાવે છે. તે પ્રોગ્રામને ક્રેશ કરશે જો તે મેમરીને વારંવાર ફાળવે છે, અથવા કંઈક કરે છે જે શૂન્ય દ્વારા વિભાજીત થાય છે અથવા પસંદ કરે છે.
અકી તનાકાની ટિપ્પણીના આધારે,
સંભવત સહાયક: ઉમિકોનો અતિરિક્ત સ્ક્રીનશ sayingટ કહેતા કે "તે ફરીથી તે જ ઓપરેશનને વારંવાર કહે છે", જે કોડમાં બતાવવામાં આવતું નથી.
"તે ફરી એક જ ઓપરેશનને બોલાવે છે." આ શક્યતા વધારે છે.
એમ ધારીને DestroyMe(); એકથી વધુ વખત કહેવા માટે રચાયેલ નથી, તે ક્રેશ થવાની સંભાવના વધારે છે.
આ મુદ્દાને ઠીક કરવાની રીત એ છે કે બદલાવ if આના જેવું કંઈક માટે:
if (m_currentHealth <= 0.f) { m_currentHealth = 0.f; DestroyMe(); break; } જ્યારે ડિસ્ટ્રોક્ટીબલ ctક્ટરનો નાશ થાય ત્યારે લૂપમાંથી બહાર નીકળી જશો, ખાતરી કરો કે 1) DestroyMe પદ્ધતિ ફક્ત એક જ વાર કહેવામાં આવે છે અને 2) onceબ્જેક્ટ પહેલેથી જ મૃત માનવામાં આવે છે તે પછી નકામું રીતે બફ્સ લાગુ ન કરો.
- 1 જ્યારે આરોગ્ય <= 0 તંદુરસ્તી તપાસવા માટે લૂપ પછી ન આવે ત્યાં સુધી રાહ જોતા કરતાં લૂપમાંથી બહાર નીકળવું એ ચોક્કસપણે એક સારું ફિક્સ છે.
- મને લાગે છે કે હું સંભવત
breakલૂપની બહાર, અને પછી ક callલ કરોDestroyMe(), ફક્ત સલામત રહેવા માટે
કોડ સાથે અનેક સમસ્યાઓ છે:
- જો ત્યાં કોઈ ડિબફ ન હોય તો, નુકસાન નહીં થાય.
DestroyMe()કાર્ય નામ ખતરનાક લાગે છે. તેના અમલના આધારે, તે કોઈ મુદ્દો હોઈ શકે છે અથવા નહીં પણ. જો તે ફંક્શનમાં વીંટળાયેલા વર્તમાન objectબ્જેક્ટના ડિસ્ટ્રક્ટરને ફક્ત એક ક callલ છે, તો પછી એક મુદ્દો છે, કારણ કે theબ્જેક્ટ તેની વચ્ચે ચલાવવામાં આવતા કોડને એક્ઝેક્યુટ કરશે. જો તે કોઈ ફંક્શન માટેનો ક callલ છે જે વર્તમાન objectબ્જેક્ટના ડિલીટિંગ ઇવેન્ટને કતાર કરે છે, તો પછી કોઈ વાંધો નથી, કારણ કે તેનો એક્ઝેક્યુશન સમાપ્ત થાય અને ઇવેન્ટ લૂપ કિક થાય તે પછી destroyedબ્જેક્ટ નાશ પામશે.- વાસ્તવિક મુદ્દો કે જે એનાઇમમાં ઉલ્લેખ કર્યો હોય તેવું લાગે છે, "તે ફરીથી તે જ ઓપરેશનને ફરીથી કહેતું હતું" - તે બોલાવશે
DestroyMe()જ્યાં સુધીm_currentHealth <= 0.fઅને પુનરાવર્તિત કરવા માટે ત્યાં વધુ બરાબર બાકી છે, જેના પરિણામે આવી શકે છેDestroyMe()ઘણી વાર, વારંવાર અને વારંવાર કહેવાતું. લૂપ પ્રથમ પછી બંધ થવું જોઈએDestroyMe()ક callલ કરો, કારણ કે onceબ્જેક્ટને એક કરતા વધુ વખત કાtingી નાખવાથી મેમરીમાં ભ્રષ્ટાચાર થાય છે, જે સંભવિત લાંબા ગાળે ક્રેશ થઈ શકે છે.
મને ખાતરી નથી હોતી કે દરેક ડેબ્યુ આરોગ્યને માત્ર એક જ વાર દૂર કરવાને બદલે આરોગ્યને કેમ દૂર કરે છે, તેના લીધે પ્રારંભિક નુકસાન પરના તમામ ડિફોઝની અસર લાગુ થાય છે, પરંતુ હું માનું છું કે તે યોગ્ય રમતનો તર્ક છે.
સાચો કોડ હશે
// the calculation of damage when attacked void DestructibleActor::ReceiveDamage(float sourceDamage) { // apply debuffs auto resolvedDamage = sourceDamage; for (const auto& debuf:m_debufs) { resolvedDamage = debuf.ApplyToDamage(resolvedDamage); m_currentHealth -= resolvedDamage if (m_currentHealth <= 0.f) { m_currentHealth = 0.f; DestroyMe(); break; } } } - મારે તે દર્શાવવું જોઈએ કે જેમ જેમ મેં ભૂતકાળમાં મેમરી ફાળવણીકારો લખ્યા છે, તે જ મેમરીને કાtingી નાખવું એ કોઈ સમસ્યા હોવાની જરૂર નથી. તે નિરર્થક પણ હોઈ શકે છે. તે બધા ફાળવનારની વર્તણૂક પર આધારિત છે. ખાણ માત્ર એક નીચલા સ્તરની લિંક્ડ સૂચિની જેમ અભિનય કરે છે જેથી કા deletedી નાખેલા ડેટા માટેનો "નોડ" કાં તો ઘણી વખત નિ: શુલ્ક તરીકે સેટ થઈ જાય છે અથવા ઘણી વખત રિડેલેટ થાય છે (જે ફક્ત રીડન્ડન્ટ પોઇન્ટર રીડાયરેક્શનને અનુરૂપ હશે). સારી કેચ છતાં.
- ડબલ-ફ્રી એ ભૂલ છે અને તે સામાન્ય રીતે અસ્પષ્ટ વર્તન અને ક્રેશ તરફ દોરી જાય છે. જો તમારી પાસે કસ્ટમ ફાળવણીકાર છે જે કોઈક રીતે સમાન મેમરી સરનામાંના ફરીથી ઉપયોગને મંજૂરી આપતું નથી, તો ડબલ-ફ્રી એ દુર્ગંધવાળું કોડ છે કારણ કે તેનો કોઈ અર્થ નથી અને તમે સ્થિર કોડ વિશ્લેષકો દ્વારા ચિકિત્સામાં આવશે.
- અલબત્ત! મેં તે હેતુ માટે તેની રચના કરી નથી. કેટલીક ભાષાઓમાં સુવિધાઓના અભાવે ફાળવણીકારની જરૂર હોય છે. ના ના ના. હું માત્ર કહેતો હતો કે ક્રેશની ખાતરી નથી. ચોક્કસ ડિઝાઇન વર્ગીકરણ હંમેશા ક્રેશ થતું નથી.
