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- அநேகமாக உதவியாக இருக்கும்: உமிகோவின் கூடுதல் ஸ்கிரீன் ஷாட் "அது இருந்தது அதே செயல்பாட்டை அழைக்கிறது மீண்டும் மீண்டும் ", இது குறியீட்டில் காட்டப்படாமல் போகலாம்.
- ஓ! எனக்கு அது தெரியாது! K நான் பார்த்த துணை அகிதானகா "எல்லையற்ற வளையம்" என்று கூறுகிறது
- Og லோகன் நான் உண்மையில் உடன்படவில்லை. அனிமேட்டிலிருந்து வந்த சில மூலக் குறியீட்டைப் பற்றி OP க்கு ஒரு கேள்வி உள்ளது என்பது மட்டுமல்ல; OP இன் கேள்வி ஒரு குறிப்பிட்ட அறிக்கையைப் பற்றியது பற்றி அனிமில் உள்ள ஒரு எழுத்தின் மூலக் குறியீடு, மற்றும் அனிம் தொடர்பான பதில் உள்ளது, அதாவது "க்ரஞ்ச்ரோல் முட்டாள்தனமாக செய்யப்பட்டு வரியை தவறாக மொழிபெயர்த்தது".
- encenshin உண்மையில் கேட்கப்பட்டதை விட, கேள்வி என்னவாக இருக்க வேண்டும் என்று நீங்கள் படிக்கிறீர்கள் என்று நினைக்கிறேன். கேள்வி சில மூலக் குறியீட்டை வழங்குகிறது மற்றும் இது நிஜ வாழ்க்கை சி ++ குறியீடாக எல்லையற்ற சுழற்சியை உருவாக்குகிறதா என்று கேட்கிறது. புதிய விளையாட்டு! ஒரு கற்பனை வேலை; நிஜ வாழ்க்கைத் தரங்களுக்கு இணங்க அதில் வழங்கப்பட்ட குறியீடு தேவையில்லை. குறியீட்டைப் பற்றி உமிகோ என்ன கூறுகிறார் என்பது எந்த சி ++ தரநிலைகள் அல்லது தொகுப்பாளர்களைக் காட்டிலும் அதிக அங்கீகாரமானது. மேல் (ஏற்றுக்கொள்ளப்பட்ட) பதிலில் பிரபஞ்சத்தில் உள்ள எந்த தகவலும் குறிப்பிடப்படவில்லை. இதைப் பற்றி ஒரு நல்ல பதிலுடன் ஒரு தலைப்பில் கேள்வி கேட்கப்படலாம் என்று நான் நினைக்கிறேன், ஆனால் சொற்றொடராக இது இல்லை.
குறியீடு எல்லையற்ற வளையமல்ல, ஆனால் அது ஒரு பிழை.
இரண்டு (சாத்தியமான மூன்று) சிக்கல்கள் உள்ளன:
- பிழைத்திருத்தங்கள் எதுவும் இல்லை என்றால் எந்த சேதமும் பயன்படுத்தப்படாது
- 1 பிழைத்திருத்தத்திற்கு மேல் இருந்தால் அதிகப்படியான சேதம் பயன்படுத்தப்படும்
- DestroyMe () உடனடியாக பொருளை நீக்கிவிட்டு, இன்னும் செயலாக்க m_debufs இருந்தால், நீக்கப்பட்ட பொருளின் மீது சுழற்சி இயங்கும் மற்றும் நினைவகத்தை குப்பைத்தொட்டியாக இருக்கும். பெரும்பாலான கேம் என்ஜின்கள் இதைச் சுற்றி வேலை செய்ய அழிக்கும் வரிசையைக் கொண்டுள்ளன, மேலும் இது ஒரு சிக்கலாக இருக்காது.
சேதத்தின் பயன்பாடு வளையத்திற்கு வெளியே இருக்க வேண்டும்.
சரி செய்யப்பட்ட செயல்பாடு இங்கே:
// 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(); } } - நாங்கள் குறியீடு மதிப்பாய்வில் இருக்கிறோமா? : டி
- நீங்கள் 16777216 ஹெச்பிக்கு மேலே செல்லாவிட்டால் 4 மிதவைகள் ஆரோக்கியத்திற்கு சிறந்தவை. நீங்கள் தாக்கக்கூடிய, ஆனால் இறக்காத ஒரு எதிரியை உருவாக்க நீங்கள் ஆரோக்கியத்தை எல்லையற்றதாக அமைக்கலாம், மேலும் எல்லையற்ற சேதத்தைப் பயன்படுத்தி ஒரு கொலை தாக்குதலைக் கொண்டிருக்கலாம், அது எல்லையற்ற ஹெச்பி தன்மையைக் கொல்லாது (ஐ.என்.எஃப்-ஐ.என்.எஃப் இன் விளைவாக NaN) ஆனால் எல்லாவற்றையும் கொல்லும். எனவே இது மிகவும் பயனுள்ளதாக இருக்கிறது.
- 1 atcat பல குறியீட்டு தரங்களில் மாநாட்டின் மூலம்
m_முன்னொட்டு என்றால் அது ஒரு உறுப்பினர் மாறி. இந்த வழக்கில் ஒரு உறுப்பினர் மாறிDestructibleActor. - 2 ot ஹோட்டல் கலிஃபோர்னியா ஒரு சிறிய வாய்ப்பு இருப்பதாக நான் ஒப்புக்கொள்கிறேன்
ApplyToDamageஎதிர்பார்த்தபடி வேலை செய்யாது, ஆனால் நீங்கள் கொடுக்கும் எடுத்துக்காட்டில் நான் சொல்வேன்ApplyToDamageமேலும் அசல் கடந்து செல்ல வேண்டும் என மறுவேலை செய்ய வேண்டும்sourceDamageஅதேபோல் அந்த சந்தர்ப்பங்களில் பிழைத்திருத்தத்தை சரியாக கணக்கிட முடியும். ஒரு முழுமையான பதக்கமாக இருக்க வேண்டும்: இந்த கட்டத்தில் டி.எம்.ஜி தகவல் அசல் டி.எம்.ஜி, தற்போதைய டி.எம்.ஜி மற்றும் சேதத்தின் தன்மை ஆகியவற்றை உள்ளடக்கிய ஒரு கட்டமைப்பாக இருக்க வேண்டும், மேலும் பிழைத்திருத்தங்களுக்கு "தீக்கு பாதிப்பு" போன்ற விஷயங்கள் இருந்தால். அனுபவத்திலிருந்து, பிழைத்திருத்தங்களுடன் எந்த விளையாட்டு வடிவமைப்பும் இவற்றைக் கோருவதற்கு நீண்ட காலத்திற்கு முன்பே இல்லை. - 1 te ஸ்டீபன்ஹோகன்ஹல் நன்றாக கூறினார்!
குறியீடு எல்லையற்ற சுழற்சியை உருவாக்குவதாகத் தெரியவில்லை.
லூப் எல்லையற்றதாக இருக்கும் ஒரே வழி
debuf.ApplyToDamage(resolvedDamage); அல்லது
DestroyMe(); புதிய உருப்படிகளைச் சேர்க்க வேண்டும் m_debufs கொள்கலன்.
இது சாத்தியமில்லை. அப்படியானால், மீண்டும் செயல்படுத்தப்படும்போது கொள்கலனை மாற்றுவதால் நிரல் செயலிழக்கக்கூடும்.
அழைப்பின் காரணமாக நிரல் பெரும்பாலும் செயலிழந்துவிடும் DestroyMe(); இது தற்போது வளையத்தை இயக்கும் தற்போதைய பொருளை அழிக்கிறது.
கார்ட்டூன் என்று நாம் நினைக்கலாம், அங்கு 'கெட்ட பையன்' ஒரு கிளையை 'நல்ல பையன்' வீழ்த்துவதைக் காண்கிறான், ஆனால் அவன் வெட்டலின் தவறான பக்கத்தில் இருப்பதை மிகவும் தாமதமாக உணர்கிறான். அல்லது மிட்கார்ட் பாம்பு சாப்பிடுவது அதன் சொந்த வால்.
எல்லையற்ற வளையத்தின் பொதுவான அறிகுறி என்னவென்றால், அது நிரலை உறைகிறது அல்லது பதிலளிக்கவில்லை. நினைவகத்தை மீண்டும் மீண்டும் ஒதுக்கினால், அல்லது பூஜ்ஜியத்தால் அல்லது விருப்பங்களால் வகுக்கப்படுவதற்கு ஏதேனும் செய்தால் அது நிரலை செயலிழக்கும்.
அகி தனகாவின் கருத்தின் அடிப்படையில்,
அநேகமாக உதவியாக இருக்கும்: "இது ஒரே செயல்பாட்டை மீண்டும் மீண்டும் அழைக்கிறது" என்று உமிகோவின் கூடுதல் ஸ்கிரீன் ஷாட், இது குறியீட்டில் காட்டப்படாமல் போகலாம்.
"இது மீண்டும் மீண்டும் அதே செயல்பாட்டை அழைக்கிறது" இது அதிக வாய்ப்புள்ளது.
என்று கருதி DestroyMe(); ஒன்றுக்கு மேற்பட்ட முறை அழைக்கப்படுவதற்கு வடிவமைக்கப்படவில்லை, இது விபத்துக்குள்ளாகும் வாய்ப்பு அதிகம்.
இந்த சிக்கலை சரிசெய்ய ஒரு வழி மாற்ற வேண்டும் if இது போன்ற ஏதாவது:
if (m_currentHealth <= 0.f) { m_currentHealth = 0.f; DestroyMe(); break; } டிஸ்ட்ரக்டிபிள் ஆக்டர் அழிக்கப்படும் போது இது சுழற்சியில் இருந்து வெளியேறும், இது 1) தி DestroyMe முறை ஒரு முறை மட்டுமே அழைக்கப்படுகிறது மற்றும் 2) பொருள் ஏற்கனவே இறந்ததாகக் கருதப்பட்டவுடன் பயனற்ற முறையில் பஃப்ஸைப் பயன்படுத்த வேண்டாம்.
- உடல்நலம் <= 0 என்பது ஆரோக்கியத்தை சரிபார்க்க வளையத்திற்குப் பிறகு காத்திருப்பதை விட நிச்சயமாக ஒரு சிறந்த தீர்வாகும்.
- நான் அநேகமாக நினைப்பேன்
breakவளையத்திற்கு வெளியே, மற்றும் பிறகு அழைப்புDestroyMe(), பாதுகாப்பாக இருக்க வேண்டும்
குறியீட்டில் பல சிக்கல்கள் உள்ளன:
- பிழைத்திருத்தங்கள் இல்லை என்றால், எந்த சேதமும் எடுக்கப்படாது.
DestroyMe()செயல்பாட்டு பெயர் ஆபத்தானது. இது எவ்வாறு செயல்படுத்தப்பட்டது என்பதைப் பொறுத்து, இது ஒரு சிக்கலாக இருக்கலாம் அல்லது இல்லாமல் இருக்கலாம். இது ஒரு செயல்பாட்டில் மூடப்பட்டிருக்கும் தற்போதைய பொருளை அழிப்பவருக்கான அழைப்பு என்றால், ஒரு சிக்கல் உள்ளது, ஏனெனில் அது குறியீட்டை இயக்கும் நடுவில் பொருள் அழிக்கப்படும். தற்போதைய பொருளின் நீக்குதல் நிகழ்வை வரிசைப்படுத்தும் ஒரு செயல்பாட்டிற்கான அழைப்பு இதுவாக இருந்தால், எந்தப் பிரச்சினையும் இல்லை, ஏனெனில் அதன் செயல்பாட்டை முடித்ததும், நிகழ்வு வளையமும் உதைத்தபின் அது அழிக்கப்படும்.- அனிமேஷில் குறிப்பிடப்பட்டுள்ளதாகத் தோன்றும் உண்மையான பிரச்சினை, "இது மீண்டும் மீண்டும் அதே செயல்பாட்டை அழைத்தது" - இது அழைக்கும்
DestroyMe()வரைm_currentHealth <= 0.fமேலும் மீண்டும் செய்ய இன்னும் பிழைத்திருத்தங்கள் உள்ளன, இதன் விளைவாக ஏற்படக்கூடும்DestroyMe()பல முறை அழைக்கப்பட்டு, மீண்டும் மீண்டும். முதல் பிறகு லூப் நிறுத்தப்பட வேண்டும்DestroyMe()அழைப்பு, ஏனென்றால் ஒரு பொருளை ஒன்றுக்கு மேற்பட்ட முறை நீக்குவதால் நினைவக சிதைவு ஏற்படுகிறது, இது நீண்ட காலத்திற்கு செயலிழக்க நேரிடும்.
ஆரம்ப பிழையின் மீது அனைத்து பிழைத்திருத்தங்களின் விளைவுகளும் பயன்படுத்தப்படுவதால், ஒவ்வொரு பிழைத்திருத்தமும் ஆரோக்கியத்தை ஒரு முறை மட்டுமே எடுத்துச் செல்வதற்குப் பதிலாக ஏன் ஆரோக்கியத்தை எடுத்துச் செல்கிறது என்பது எனக்குத் தெரியவில்லை, ஆனால் அது சரியான விளையாட்டு தர்க்கம் என்று நான் கருதுவேன்.
சரியான குறியீடு இருக்கும்
// 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; } } } - கடந்த காலத்தில் நினைவக ஒதுக்கீட்டாளர்களை நான் எழுதியுள்ளதால், அதே நினைவகத்தை நீக்குவது ஒரு சிக்கலாக இருக்க வேண்டியதில்லை என்பதை நான் சுட்டிக்காட்ட வேண்டும். இது தேவையற்றதாகவும் இருக்கலாம். இது அனைத்தும் ஒதுக்கீட்டாளரின் நடத்தையைப் பொறுத்தது. என்னுடையது குறைந்த அளவிலான இணைக்கப்பட்ட பட்டியலைப் போலவே செயல்பட்டது, எனவே நீக்கப்பட்ட தரவிற்கான "முனை" பல முறை இலவசமாக அமைக்கப்படும் அல்லது பல முறை மறுவடிவமைக்கப்படும் (இது தேவையற்ற சுட்டிக்காட்டி வழிமாற்றுகளுக்கு ஒத்திருக்கும்). நல்ல கேட்ச் என்றாலும்.
- இரட்டை-இலவசம் என்பது ஒரு பிழை, பொதுவாக வரையறுக்கப்படாத நடத்தை மற்றும் செயலிழப்புகளுக்கு வழிவகுக்கிறது. அதே நினைவக முகவரியை மறுபயன்படுத்துவதை எப்படியாவது அனுமதிக்காத தனிப்பயன் ஒதுக்கீட்டாளர் உங்களிடம் இருந்தாலும், இரட்டை-இலவசமானது ஒரு மணமான குறியீடாகும், ஏனெனில் இது எந்த அர்த்தமும் இல்லை, மேலும் நிலையான குறியீடு பகுப்பாய்வாளர்களால் நீங்கள் கத்தப்படுவீர்கள்.
- நிச்சயமாக! அந்த நோக்கத்திற்காக நான் அதை வடிவமைக்கவில்லை. அம்சங்கள் இல்லாததால் சில மொழிகளுக்கு ஒதுக்கீடு தேவைப்படுகிறது. இல்லை இல்லை இல்லை. விபத்துக்கு உத்தரவாதம் இல்லை என்று நான் கூறிக்கொண்டிருந்தேன். சில வடிவமைப்பு வகைப்பாடுகள் எப்போதும் செயலிழக்காது.
