டைனமிக் கார்டு மேம்படுத்தல்களுக்கான மாஸ்டரிங் செயல்பாடு மாற்றீடு
ஒவ்வொரு அட்டையும் புதிய திறன்களுடன் மாறும் வகையில் உருவாகக்கூடிய ஒரு அட்டை விளையாட்டை வடிவமைப்பதை கற்பனை செய்து பாருங்கள். Rain இயக்க நேரத்தில் ஒரு கார்டின் பிளே () செயல்பாட்டை மாற்ற விரும்புகிறீர்கள், "மில் ஏ கார்டு" அல்லது "அதை இரண்டு முறை விளையாடுங்கள்" போன்ற விளைவுகளைச் சேர்க்கிறீர்கள். இது மிகவும் நெகிழ்வான அமைப்பை உருவாக்குகிறது, அங்கு கார்டுகள் மேம்படுத்தல்களுக்கு தடையின்றி மாற்றியமைக்கின்றன.
பாரம்பரியமாக, சி ++ இல் மாறும் செயல்பாடுகளை மாற்றியமைப்பது அதன் நிலையான தன்மை காரணமாக தந்திரமானது. உள்ளமைக்கப்பட்ட செயல்பாட்டு மறுசீரமைப்புகளைக் கொண்ட மொழிகளைப் போலல்லாமல், சி ++ க்கு செயல்பாட்டு சுட்டிகள், லாம்ப்டாஸ் அல்லது எஸ்.டி.டி :: செயல்பாடு போன்ற கட்டமைக்கப்பட்ட அணுகுமுறை தேவைப்படுகிறது. சரியான முறையைத் தேர்ந்தெடுப்பது செயல்திறன் மற்றும் பராமரிப்பை உறுதி செய்கிறது.
ஒரு சவால் அசல் செயல்பாட்டைப் பாதுகாப்பது, அதே நேரத்தில் பெரிய அளவிலான குறியீட்டை மீண்டும் எழுதாமல் மேம்படுத்தல்களை அடுக்குகிறது. தற்போதுள்ள நாடகம் () செயல்பாட்டை மடிக்கவும், பயன்படுத்தப்பட்ட மேம்படுத்தல்களின் அடிப்படையில் அதன் நடத்தையை நீட்டிக்கவும் உங்களுக்கு ஒரு முறை தேவை. ஒரு கேக்கை அலங்கரிப்பதைப் போல சிந்தியுங்கள் - ஒவ்வொரு அடுக்கும் முழு கேக்கையும் மாற்றாமல் ஒரு தனித்துவமான சுவையை சேர்க்கிறது! .
இந்த கட்டுரையில், சி ++ இல் செயல்பாட்டு மாற்றீட்டை மாறும் வகையில் எவ்வாறு செயல்படுத்துவது என்பதை ஆராய்வோம். செயல்பாட்டு சுட்டிகள் மற்றும் எஸ்.டி.டி :: செயல்பாடு போன்ற உத்திகளைப் பார்ப்போம். நீங்கள் சி ++ க்கு புதியதாக இருந்தாலும் அல்லது ஏற்கனவே உள்ள கணினியைச் செம்மைப்படுத்தினாலும், இந்த நுட்பங்கள் மிகவும் நெகிழ்வான மற்றும் அளவிடக்கூடிய விளையாட்டு வடிவமைப்பை உருவாக்க உதவும்.
| கட்டளை | பயன்பாட்டின் எடுத்துக்காட்டு |
|---|---|
| std::function<void()> | இயக்க நேரத்தில் டைனமிக் செயல்பாடு மாற்றீட்டை அனுமதிக்கும் நெகிழ்வான செயல்பாட்டு ரேப்பர். நாடக () செயல்பாட்டை மாறும் வகையில் சேமித்து மாற்ற பயன்படுகிறது. |
| typedef void (*PlayFunc)(); | ஒரு செயல்பாட்டு சுட்டிக்காட்டி வகையை வரையறுக்கிறது, பிளே செயல்பாட்டை வெவ்வேறு நடத்தைகளுக்கு மாறும் வகையில் மீண்டும் நியமிக்க உதவுகிறது. |
| auto oldPlay = card.PlayFunction; | அசல் செயல்பாட்டை மாற்றுவதற்கு முன் பிடிக்கிறது, முந்தைய நடத்தை பாதுகாக்கப்படுவதை உறுதிசெய்கிறது மற்றும் நீட்டிக்க முடியும். |
| card.PlayFunction = [=]() { oldPlay(); MillCard(); }; | அசல் செயல்பாட்டை மடிக்கவும், கூடுதல் விளைவுகளை மாறும் வகையில் சேர்க்கவும் ஒரு லாம்ப்டா செயல்பாட்டைப் பயன்படுத்துகிறது. |
| virtual void Play() | இயக்க நேர பாலிமார்பிஸத்திற்கான பெறப்பட்ட வகுப்புகளில் மீற அனுமதிக்க ஒரு அடிப்படை வகுப்பில் ஒரு மெய்நிகர் முறையை வரையறுக்கிறது. |
| class UpgradedCard : public Card | அடிப்படை வகுப்பை நேரடியாக மாற்றாமல் நாடக செயல்பாட்டின் நடத்தையை விரிவுபடுத்தும் ஒரு துணைப்பிரிவை உருவாக்குகிறது. |
| delete myCard; | நினைவக கசிவைத் தடுக்க மாறும் வகையில் உருவாக்கப்பட்ட பொருளுக்கு ஒதுக்கப்பட்ட நினைவகத்தை வெளிப்படையாக கையாளுகிறது. |
| std::cout << "Milling a card\n"; | செயல்பாட்டு செயல்படுத்தல் வரிசையை பிழைத்திருத்துவதற்கும் காட்சிப்படுத்துவதற்கும் பயன்படுத்தப்படும் கன்சோலுக்கு உரையை வெளியிடுகிறது. |
| PlayFunc playFunction = &BasePlay; | ஏற்கனவே உள்ள செயல்பாட்டிற்கு ஒரு செயல்பாட்டு சுட்டிக்காட்டி ஒதுக்குகிறது, இது நெகிழ்வான இயக்க நேர மறுசீரமைப்பை அனுமதிக்கிறது. |
அட்டை விளையாட்டில் டைனமிக் செயல்பாடு மாற்றீட்டை செயல்படுத்துகிறது
டைனமிக் கார்டு விளையாட்டில், இயக்க நேரத்தில் பிளே () செயல்பாட்டை மாற்றியமைப்பது விளையாட்டில் அதிக நெகிழ்வுத்தன்மையை அனுமதிக்கிறது. ஒவ்வொரு மேம்படுத்தலுக்கும் ப்ளே செயல்பாட்டின் தனி பதிப்புகளை எழுதுவதற்கு பதிலாக, நாங்கள் பயன்படுத்துகிறோம் செயல்பாட்டு சுட்டிகள்அருவடிக்கு லாம்ப்டாஸ், மற்றும் std :: செயல்பாடு அட்டையின் நடத்தையை மாறும் வகையில் மாற்ற. இந்த அணுகுமுறை ஏற்கனவே உள்ள தர்க்கத்தை மீண்டும் எழுதாமல் "மில் ஏ கார்டு" அல்லது "இரண்டு முறை விளையாடுங்கள்" போன்ற மேம்பாடுகளைப் பெற அட்டைகளுக்கு உதவுகிறது. சேகரிக்கக்கூடிய அட்டை விளையாட்டை விளையாடுவதை கற்பனை செய்து பாருங்கள், அங்கு நீங்கள் ஒரு அட்டை நடுப்பகுதியில் விளையாட்டின் திறனை இணைத்து, அதன் விளைவை உடனடியாக மாற்றும்! .
பயன்படுத்தப்படும் முக்கிய நுட்பங்களில் ஒன்று செயல்பாட்டு ரேப்பர் std :: செயல்பாடு வழங்கியது. இது ஒரு செயல்பாட்டை சேமிக்க அனுமதிக்கிறது, பின்னர் கூடுதல் நடத்தைகளுடன் மாற்றியமைக்கவும். எடுத்துக்காட்டாக, மேம்படுத்தல் பயன்படுத்தப்படும்போது, முந்தைய நாடகம் () செயல்பாட்டைக் கைப்பற்றி அதன் நடத்தையை விரிவுபடுத்தும் ஒரு புதிய செயல்பாட்டிற்குள் அதை மடிக்கவும். இது ஒரு விளையாட்டில் கூடுதல் மூலோபாயத்தை சேர்ப்பதைப் போன்றது -ஒரு ஆர்பிஜியில் ஒரு கதாபாத்திரத்தில் பஃப்ஸை அடுக்கி வைப்பது போன்றது! .
நாங்கள் ஆராய்ந்த மற்றொரு முறை செயல்பாட்டு சுட்டிகள் பயன்படுத்துவதாகும். இயக்க நேரத்தில் எந்த செயல்பாடு அழைக்கப்படுகிறது என்பதை மாற்ற செயல்பாட்டு சுட்டிகள் நம்மை அனுமதிக்கின்றன, இது செயல்திறன் முக்கியமான நிகழ்வுகளுக்கு ஏற்றதாக அமைகிறது. அவை நெகிழ்வுத்தன்மையை வழங்கும் போது, அவை எஸ்.டி.டி :: செயல்பாட்டை விட நிர்வகிக்க கடினமாக இருக்கும், குறிப்பாக உள்ளூர் மாறிகள் கைப்பற்றும்போது. இருப்பினும், நிகழ்நேர அட்டை இடைவினைகள் அல்லது ஒரு அட்டை விளையாட்டில் AI முடிவெடுப்பது போன்ற செயல்திறன்-உணர்திறன் காட்சிகளில் செயல்பாட்டு சுட்டிகள் பயனுள்ளதாக இருக்கும்.
இறுதியாக, ஒரு பொருள் சார்ந்த அணுகுமுறை பயன்படுத்துதல் பரம்பரை மற்றும் முறை மேலெழுதும் செயல்படுத்தப்பட்டது. இந்த முறை அதன் நடத்தையை மாற்றியமைக்கும் பெறப்பட்ட வகுப்புகளை உருவாக்குவதன் மூலம் நாடகம் () செயல்பாட்டை நீட்டிக்க அனுமதிக்கிறது. எடுத்துக்காட்டாக, ஒரு சிறப்பு அட்டை வகை அடிப்படை அட்டை வகுப்பிலிருந்து பெறலாம் மற்றும் கூடுதல் விளைவுகளைச் சேர்க்க நாடகத்தை மேலெழுதும் (). குறிப்பிட்ட அட்டை வகைகளுக்கு தனித்துவமான நடத்தைகள் தேவைப்படும் மிகவும் சிக்கலான விளையாட்டு இயக்கவியலை வடிவமைக்கும்போது இது பயனுள்ளதாக இருக்கும். இந்த நுட்பங்களை இணைப்பதன் மூலம், டெவலப்பர்கள் மிகவும் மட்டு மற்றும் விரிவாக்கக்கூடிய அட்டை விளையாட்டு அமைப்பை உருவாக்க முடியும், இது டைனமிக் மேம்படுத்தல்களை தடையின்றி ஆதரிக்கிறது.
சி ++ அட்டை விளையாட்டில் இயக்க நேரத்தில் செயல்பாட்டை மாற்றியமைத்தல்
செயல்பாட்டு சுட்டிகள், லாம்ப்டாஸ் மற்றும் எஸ்.டி.டி :: டைனமிக் நடத்தை மாற்றத்திற்காக சி ++ இல் செயல்பாடு
#include <iostream>#include <functional>class Card {public:std::function<void()> PlayFunction;Card() {PlayFunction = [&]() { std::cout << "Playing base card\n"; };}void Play() { PlayFunction(); }};void MillCard() { std::cout << "Milling a card\n"; }void UpgradeWithMill(Card &card) {auto oldPlay = card.PlayFunction;card.PlayFunction = [=]() { oldPlay(); MillCard(); };}int main() {Card myCard;UpgradeWithMill(myCard);myCard.Play();return 0;}
சி ++ இல் ஒரு முறையை மாறும் வகையில் செயல்பாட்டு சுட்டிகள் பயன்படுத்துதல்
இயக்க நேர மாற்றங்களில் சிறந்த கட்டுப்பாட்டுக்கு செயல்பாட்டு சுட்டிகள் பயன்படுத்தி செயல்படுத்தல்
#include <iostream>typedef void (*PlayFunc)();void BasePlay() { std::cout << "Base play function\n"; }void PlayTwice() {std::cout << "Playing twice!\n";BasePlay();BasePlay();}int main() {PlayFunc playFunction = &BasePlay;playFunction();playFunction = &PlayTwice;playFunction();return 0;}
மேலும் விரிவாக்கக்கூடிய அட்டை மேம்படுத்தல்களுக்கு வர்க்க அடிப்படையிலான அணுகுமுறையைப் பயன்படுத்துதல்
பரம்பரை மற்றும் முறை மீறுவதைப் பயன்படுத்தி பொருள் சார்ந்த முறை
#include <iostream>class Card {public:virtual void Play() { std::cout << "Playing base card\n"; }};class UpgradedCard : public Card {public:void Play() override {Card::Play();std::cout << "Additional effect triggered!\n";}};int main() {Card* myCard = new UpgradedCard();myCard->Play();delete myCard;return 0;}
அலங்காரக்காரர்கள் மற்றும் மிடில்வேர் உடன் இயக்க நேர செயல்பாடு மாற்றீட்டை மேம்படுத்துதல்
C ++ இல் மாறும் செயல்பாடுகளை மாற்றுவதற்கான மற்றொரு சக்திவாய்ந்த வழி a பயன்படுத்துவதன் மூலம் அலங்கார முறை. முக்கிய தர்க்கத்தை அப்படியே வைத்திருக்கும்போது கூடுதல் நடத்தைகளுடன் ஏற்கனவே இருக்கும் செயல்பாட்டை மடிக்க இந்த முறை நம்மை அனுமதிக்கிறது. நாடகம் () செயல்பாட்டை நேரடியாக மாற்றுவதற்கு பதிலாக, ஒரு ரோல்-பிளேமிங் விளையாட்டில் பஃப்ஸைப் பயன்படுத்துவதைப் போலவே மாற்றங்களின் சங்கிலியை உருவாக்குகிறோம். சேதத்தை கையாளும் ஒரு அடிப்படை அட்டை உங்களிடம் இருப்பதாக கற்பனை செய்து பாருங்கள், மேலும் நீங்கள் ஒரு "எரியும்" விளைவைச் சேர்க்கிறீர்கள் -அட்டை விளையாடும் நேரம், எதிரியும் காலப்போக்கில் சேதத்தை எடுக்கிறார். .
மிடில்வேர்-பாணி செயல்பாட்டு மடக்குதல் என்பது வலை அபிவிருத்தியால் ஈர்க்கப்பட்ட மற்றொரு அணுகுமுறையாகும், ஆனால் விளையாட்டு இயக்கவியலுக்கு பொருந்தும். இங்கே, ஒவ்வொரு விளைவும் முக்கிய செயல்பாட்டிற்கு முன் அல்லது அதற்குப் பிறகு செயல்படுத்தப்படும் ஒரு அடுக்காக செயல்படுகிறது. பயன்படுத்துகிறது std :: திசையன் பல செயல்பாட்டு ரேப்பர்களை சேமிக்க பல மேம்பாடுகளை மாறும் வகையில் அடுக்கி வைக்க அனுமதிக்கிறது. எடுத்துக்காட்டாக, ஒரு அட்டை முந்தைய விளைவுகளை மேலெழுதாமல் "இரண்டு முறை விளையாடுங்கள்" மற்றும் "ஒரு அட்டை” திறன்களைப் பெறலாம். இது ஒரு விளையாட்டில் பல பவர்-அப்களை சித்தப்படுத்துவதற்கு ஒத்ததாகும், அங்கு ஒவ்வொரு விரிவாக்கமும் புதிய திறன்களைச் சேர்க்கிறது.
இறுதியாக, கருத்தில் கொள்ளுங்கள் நிகழ்வு சார்ந்த நிரலாக்க இயக்க நேர மாற்றங்களை மேலும் மேம்படுத்தலாம். ஒரு பார்வையாளர் முறையைப் பயன்படுத்துவதன் மூலம், கார்டுகள் விளைவுகளை மாறும் வகையில் பதிவு செய்யலாம் மற்றும் தூண்டுதல்களுக்கு பதிலளிக்கலாம். குறிப்பிட்ட நிபந்தனைகளின் அடிப்படையில் பல விளைவுகளைச் சங்கிலி செய்வது போன்ற சிக்கலான தொடர்புகளைக் கையாளும் போது இது பயனுள்ளதாக இருக்கும். உதாரணமாக, சில சூழ்நிலைகளில் விளையாடியிருந்தால் ஒரு அட்டை வேறுபட்ட விளைவைப் பெறக்கூடும், முன்பு மற்றொரு அட்டை விளையாடியிருந்தால் கூடுதல் அட்டையை வரைவது போன்றது. இந்த நுட்பங்கள் சி ++ இல் செயல்பாட்டை மாற்றுவதை மிகவும் நெகிழ்வானதாகவும் அளவிடக்கூடியதாகவும் ஆக்குகின்றன. .
சி ++ இல் இயக்க நேர செயல்பாடு மாற்றீட்டைப் பற்றிய பொதுவான கேள்விகள்
- சி ++ இல் இயக்க நேரத்தில் ஒரு செயல்பாட்டை மாற்ற சிறந்த வழி எது?
- பயன்படுத்துகிறது std::function வாசிப்புத்திறனை பராமரிக்கும் போது நெகிழ்வுத்தன்மையை வழங்குகிறது. செயல்திறன்-சிக்கலான பயன்பாடுகளுக்கும் செயல்பாட்டு சுட்டிகள் பயனுள்ளதாக இருக்கும்.
- அசல் செயல்பாட்டை மாற்றியமைக்கும்போது அதை எவ்வாறு பாதுகாப்பது?
- அசல் செயல்பாட்டை மாற்றுவதற்கு முன் ஒரு மாறியில் சேமிக்கவும், பின்னர் லாம்ப்டா ரேப்பரைப் பயன்படுத்தி புதிய செயல்பாட்டிற்குள் அழைக்கவும்.
- பல செயல்பாட்டு மாற்றீடுகளை நான் ஒன்றாக சங்கிலி செய்யலாமா?
- ஆம்! பயன்படுத்துகிறது std::vector செயல்பாட்டு ரேப்பர்களை சேமிக்க பல மேம்பாடுகளை மாறும் வகையில் அடுக்கி வைக்க அனுமதிக்கிறது.
- இயக்க நேரத்தில் செயல்பாடுகளை மாற்றும்போது செயல்திறன் பரிசீலனைகள் என்ன?
- செயல்பாட்டு சுட்டிகள் வேகமானவை, ஆனால் குறைவான நெகிழ்வானவை. std::function சிறிய மேல்நிலை சேர்க்கிறது, ஆனால் பராமரிப்பை மேம்படுத்துகிறது.
- நடத்தையை மாற்றுவதற்கு பரம்பரை பயன்படுத்துவதை இது எவ்வாறு ஒப்பிடுகிறது?
- முன் வரையறுக்கப்பட்ட நடத்தை மாற்றங்களுக்கு பரம்பரை நன்றாக வேலை செய்கிறது, அதே நேரத்தில் செயல்பாட்டு மாற்றீடு மாறும், இயக்க நேர மாற்றங்களுக்கு சிறந்தது.
டைனமிக் செயல்பாடு மாற்றீடு குறித்த இறுதி எண்ணங்கள்
சி ++ இல் இயக்க நேர செயல்பாடு மாற்றீட்டைப் பயன்படுத்துவது ஒரு விளையாட்டு அமைப்பில் நெகிழ்வுத்தன்மையைச் சேர்ப்பதற்கான ஒரு சக்திவாய்ந்த நுட்பமாகும். செயல்பாட்டு சுட்டிகள், லாம்ப்டா வெளிப்பாடுகள் மற்றும் எஸ்.டி.டி :: செயல்பாட்டை மேம்படுத்துவதன் மூலம், டெவலப்பர்கள் அட்டை நடத்தைகளை மாறும் வகையில் மாற்றலாம். அதிகப்படியான மறுபயன்பாடுகள் அல்லது சிக்கலான வர்க்க வரிசைமுறைகள் தேவையில்லாமல் விளையாட்டு இயக்கவியல் தழுவிக்கொள்வதை இந்த முறை உறுதி செய்கிறது.
அட்டை விளையாட்டுகளுக்கு அப்பால், இந்த அணுகுமுறை AI நடத்தை மாற்றங்கள், சொருகி அமைப்புகள் மற்றும் மாறும் நிகழ்வு கையாளுதலில் பயனுள்ளதாக இருக்கும். பயன்பாட்டை மறுதொடக்கம் செய்யாமல் நிகழ்நேர மாற்றங்களை இது அனுமதிக்கிறது. நீங்கள் ஒரு டிஜிட்டல் கார்டு விளையாட்டு அல்லது ஊடாடும் உருவகப்படுத்துதலை வடிவமைக்கிறீர்கள் என்றாலும், மாஸ்டரிங் செயல்பாட்டு மாற்று நுட்பங்கள் உங்கள் மேம்பாட்டு பணிப்பாய்வுகளை பெரிதும் மேம்படுத்தும். .
மேலும் வாசிப்பு மற்றும் குறிப்புகள்
- விரிவான விளக்கம் std :: செயல்பாடு மற்றும் அதன் பயன்பாடுகள் C ++ இல்: cppreference.com
- பயன்படுத்துகிறது லாம்ப்டா செயல்பாடுகள் நடத்தை மாறும் வகையில் மாற்ற: Learncpp.com
- செயல்பாட்டு சுட்டிகள் மற்றும் அவற்றின் மாற்றுகளுக்கான சிறந்த நடைமுறைகள்: ஐஎஸ்ஓ சி ++ கேள்விகள்
- புரிந்துகொள்ளுதல் அலங்கார முறை விளையாட்டு வளர்ச்சியில்: விளையாட்டு நிரலாக்க வடிவங்கள்