जंग, स्टार या किसी अन्य भाषा में Starcraft के लिए एक बॉट

स्टारक्राफ्ट: ब्रूड वॉर । यह खेल मेरे लिए बहुत मायने रखता है! और आप में से कई, मुझे लगता है। इतना, कि मुझे आश्चर्य है कि मुझे विकिपीडिया पर इसके पृष्ठ का लिंक भी देना चाहिए या नहीं।

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

निम्नलिखित लेख समाधान खोजने और प्रौद्योगिकियों और तकनीकों का उपयोग करने की प्रक्रिया का वर्णन करेगा जो आपको जंग और इसके पारिस्थितिकी तंत्र के बारे में नई चीजें सीखने की अनुमति देगा। आपको अपनी पसंदीदा भाषा का उपयोग करके एक बॉट को लागू करने के लिए प्रेरित किया जा सकता है, चाहे वह सी, सी ++, रूबी, पायथन, आदि हो।

इस लेख को पढ़ते हुए दक्षिण कोरिया के भजन को सुनना निश्चित रूप से लायक है:

BWAPI

यह खेल लगभग 20 साल पुराना है। और यह अभी भी लोकप्रिय है ; चैंपियनशिप संयुक्त राज्य अमेरिका में लोगों की भीड़ को आकर्षित करती है यहां तक कि 2017 में जहां ग्रैंड मास्टर्स जैडॉन्ग बनाम बिसू की लड़ाई हुई थी। मानव खिलाड़ियों के अलावा, स्मेललेस मशीनें भी SC की लड़ाई में हिस्सा लेती हैं! और यह BWAPI की वजह से संभव है। अधिक उपयोगी लिंक ।

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

तो, एक प्रशंसक टीम ने कई साल पहले स्टारक्राफ्ट बैक-एंड को उलट दिया और सी ++ में एक एपीआई विकसित किया, जो आपको बॉट बनाने, खेल प्रक्रिया में इंजेक्शन बनाने और दुखी मनुष्यों पर हावी होने की अनुमति देता है।

जैसा कि अक्सर होता है, पहले एक घर का निर्माण, अयस्क, फोर्ज टूल्स को खान देना आवश्यक है एक बॉट बनाने के लिए, आपको एक एपीआई लागू करने की आवश्यकता है। Rust की पेशकश क्या है?

FFI

रुस्त से अन्य भाषाओं के साथ काम करना काफी सरल है। इसके लिए एक एफएफआई है। मैं आपको प्रलेखन से एक छोटा सा अंश देता हूं।

कल्पना कीजिए कि हमारे पास एक तड़क-भड़क वाली लाइब्रेरी है, जिसमें हेडर फाइल snappy-ch है , जिसमें फ़ंक्शन डिक्लेरेशन हैं।

चलो कार्गो का उपयोग करके एक परियोजना बनाते हैं।

$ cargo new --bin snappy Created binary (application) `snappy` project $ cd snappy snappy$ tree . ├── Cargo.toml └── src └── main.rs 1 directory, 2 files 

कार्गो ने परियोजना के लिए एक मानक फ़ाइल संरचना बनाई है।

Cargo.toml हम libc पर निर्भरता निर्दिष्ट करते हैं:

 [dependencies] libc = "0.2" 

src/main.rs फ़ाइल इस तरह दिखाई देगी:

 extern crate libc; // To import C types, in our case for size_t use libc::size_t; #[link(name = "snappy")] // Specify the name of the library for linking the function extern { // We write the declaration of the function which we want to import // in C the declaration looks like this: // size_t snappy_max_compressed_length(size_t source_length); fn snappy_max_compressed_length(source_length: size_t) -> size_t; } fn main() { let x = unsafe { snappy_max_compressed_length(100) }; println!("max compressed length of a 100 byte buffer: {}", x); } 

आइए प्रोजेक्ट बनाएं और चलाएं:

 snappy$ cargo build ... snappy$ cargo run Finished dev [unoptimized + debuginfo] target(s) in 0.02s Running `target/debug/snappy` max compressed length of a 100 byte buffer: 148 

आप cargo run केवल कॉल कर सकते हैं, जो रन से पहले cargo build कहते हैं। अन्य विकल्प परियोजना का निर्माण करना और बाइनरी को सीधे कॉल करना है:

 snappy$ ./target/debug/snappy max compressed length of a 100 byte buffer: 148 

यदि स्नैपी लाइब्रेरी स्थापित है, तो कोड संकलित किया जाएगा (उबंटू के लिए आपको libsnappy-dev पैकेज स्थापित करना चाहिए)।

 snappy$ ldd target/debug/snappy ... libsnappy.so.1 => /usr/lib/x86_64-linux-gnu/libsnappy.so.1 (0x00007f8de07cf000) 

जैसा कि आप देख सकते हैं, हमारा द्विआधारी libsnappy साझा पुस्तकालय से जुड़ा हुआ है। और हमारे कोड में snappy_max_compressed_length के लिए एक कॉल इस लाइब्रेरी से एक फ़ंक्शन कॉल है।

जंग-bindgen

यह अच्छा होगा यदि हम अपने एफएफआई को स्वतः उत्पन्न कर सकें। सौभाग्य से, रस्ट एडिक्ट के टूलबॉक्स में रस्ट -बिंडगेन नामक एक उपयोगिता है। यह C (और कुछ C ++) लाइब्रेरी के लिए FFI बाइंडिंग उत्पन्न करने में सक्षम है।

स्थापना:

 $ cargo install bindgen 

जंग-बिंदेन कैसा दिखता है? हम C / C ++ हेडर फ़ाइलों को लेते हैं, हम उन पर bindgen उपयोगिता को इंगित करते हैं, और हमें जो आउटपुट मिलता है, वह उचित संरचनाओं के साथ Rust कोड उत्पन्न होता है, ताकि हम C संरचनाओं और कार्यों का उपयोग कर सकें। यहां बताया गया है कि bindgen लिए क्या bindgen करता है:

 $ bindgen /usr/include/snappy-ch | grep -C 1 snappy_max_compressed_length extern "C" { pub fn snappy_max_compressed_length(source_length: usize) -> usize; } 

यह पता चलता है कि bindgen BWAPI हेडर के साथ सामना नहीं कर सकता है, गैर-उपयोग करने योग्य कोड के टन पैदा करता है (क्योंकि वर्चुअल सदस्य फ़ंक्शन, std :: string in a public API, आदि)। बात यह है कि BWAPI C ++ में लिखा गया है। C ++ आमतौर पर C ++ प्रोजेक्ट से भी उपयोग करना मुश्किल है। एक बार लाइब्रेरी इकट्ठी हो जाने के बाद, इसे उसी लिंकर (एक ही संस्करण) के साथ जोड़ना बेहतर होता है, हेडर फ़ाइलों को एक ही कंपाइलर (एक ही संस्करण) के साथ पार्स किया जाना चाहिए। ये सभी कारक परिणाम को प्रभावित कर सकते हैं। उदाहरण के लिए मंगलिंग , जिसे अभी भी जीएनयू जीसीसी में त्रुटियों के बिना लागू नहीं किया जा सकता है । ये कारक इतने महत्वपूर्ण हैं कि gtest भी इसे दूर नहीं कर सका। और प्रलेखन में यह कहता है: आप उसी कंपाइलर और समान लिंकर द्वारा प्रोजेक्ट के एक हिस्से के रूप में बेहतर तरीके से गाइस्ट का निर्माण करेंगे।

BWAPI-सी

C सॉफ्टवेयर इंजीनियरिंग का लिंगुआ फ्रेंका है। यदि जंग-बिंदगेन सी भाषा के लिए अच्छी तरह से काम करता है, तो सी के लिए BWAPI क्यों नहीं लागू किया जाता है, और फिर इसके एपीआई का उपयोग करें? अच्छा विचार है!

हां, यह एक अच्छा विचार है जब तक आप BWAPI के इनसाइड में नहीं देखते हैं और आपको लागू होने वाली कक्षाओं और विधियों की संख्या देखनी चाहिए। विशेष रूप से इन सभी मेमोरी लेआउट, एएसएम कोड, मेमोरी पैचिंग और अन्य "भयावहता" जिनके लिए हमारे पास समय नहीं है। मौजूदा समाधान का पूरी तरह से उपयोग करना आवश्यक है।

लेकिन हमें किसी भी तरह से मैंगलिंग, सी ++ कोड, इनहेरिटेंस और वर्चुअल मेंबर फंक्शन को हराने की जरूरत है।

C ++ में, दो शक्तिशाली उपकरण हैं जो हम अपनी समस्या को हल करने के लिए उपयोग करेंगे: अपारदर्शी संकेत और extern "C" ।

extern "C" {} C ++ के तहत C ++ कोड को स्वयं "मास्क" करने की अनुमति देता है। यह बिना मेन्यूलेशन के फ़ंक्शन नाम उत्पन्न करना संभव बनाता है।

अपारदर्शी संकेत हमें इसके कार्यान्वयन को प्रदान किए बिना "स्पष्ट प्रकार" के लिए एक प्रकार का सूचक और "कुछ प्रकार" बनाने के लिए अनुमति देते हैं। चूंकि यह केवल कुछ प्रकार की घोषणा है, इसलिए मूल्य द्वारा इस प्रकार का उपयोग करना असंभव है, आप इसे केवल सूचक द्वारा उपयोग कर सकते हैं।

आइए कल्पना करें कि हमारे पास यह C ++ कोड है:

 namespace cpp { struct Foo { int bar; virtual int get_bar() { return this->bar; } }; } // namespace cpp 

हम इसे C हेडर में बदल सकते हैं:

 extern "C" { typedef struct Foo_ Foo; // Opaque pointer to Foo // call cpp::Foo::get_bar int Foo_get_bar(Foo* self); } 

और यहाँ C ++ भाग है जो C हैडर और C ++ कार्यान्वयन के बीच की कड़ी होगी:

 int Foo_get_bar(Foo* self) { // cast the opaque pointer to the certain cpp::Foo and call the method ::get_bar return reinterpret_cast<cpp::Foo*>(self)->get_bar(); } 

वर्गों के सभी तरीकों को इस तरह से संसाधित नहीं किया जाना था। BWAPI में, ऐसी कक्षाएं हैं जो आप इन संरचनाओं के क्षेत्रों का उपयोग करके खुद को लागू कर सकते हैं, उदाहरण के लिए typedef struct Position { int x; int y; } Position; typedef struct Position { int x; int y; } Position; और Position::get_distance जैसे तरीके Position::get_distance

ऐसी कक्षाएं थीं जिन्हें मुझे एक विशेष तरीके से इलाज करना था। उदाहरण के लिए, AIModule वर्चुअल सदस्य कार्यों के एक विशिष्ट सेट के साथ C ++ वर्ग का एक संकेतक होना चाहिए। फिर भी, यहाँ हेडर और कार्यान्वयन है ।

इसलिए, कई महीनों की मेहनत के बाद, 554 तरीके और एक दर्जन कक्षाएं, क्रॉस-प्लेटफॉर्म लाइब्रेरी BWAPI-C का जन्म हुआ, जो आपको सी में बॉट बनाने की अनुमति देता है। एक उप-उत्पाद क्रॉस-संकलन और एफएफआई और सीडीईसी कॉल सम्मेलन का समर्थन करने वाली किसी अन्य भाषा में एपीआई को लागू करने की क्षमता थी।

यदि आप एक पुस्तकालय लिख रहे हैं, तो कृपया सी में इसका एपीआई लिखें।

BWAPI-C की सबसे महत्वपूर्ण विशेषता अन्य प्रोग्रामिंग भाषाओं के साथ व्यापक संभव एकीकरण है। Python , Ruby , Rust , PHP , Java और कई अन्य लोग सी के साथ काम करने में सक्षम हैं, इसलिए यदि आप किंक को बाहर निकालते हैं और स्वयं के आवरण को लागू करते हैं, तो आप उनकी मदद से एक बॉट भी लिख सकते हैं।

C में बॉट लिखना

यह हिस्सा Starcraft मॉड्यूल के आंतरिक संगठन के सामान्य सिद्धांतों का वर्णन करता है।

बॉट्स 2 प्रकार के होते हैं: मॉड्यूल और क्लाइंट। आइए एक मॉड्यूल लिखने का एक उदाहरण देखें।

मॉड्यूल एक गतिशील पुस्तकालय है। गतिशील पुस्तकालयों को लोड करने का सामान्य सिद्धांत यहां देखा जा सकता है । मॉड्यूल को 2 फ़ंक्शन निर्यात करना चाहिए: newAIModule और gameInit ।

gameInit आसान है। इस फ़ंक्शन को एक वर्तमान गेम के लिए एक पॉइंटर पास करने के लिए कहा जाता है। यह सूचक बहुत महत्वपूर्ण है, क्योंकि BWAPI के wilds में वैश्विक स्थिर वैरिएबल है, जिसका उपयोग कोड के कुछ अनुभागों में किया जाता है। चलो gameInit का वर्णन gameInit :

 DLLEXPORT void gameInit(void* game) { BWAPIC_setGame(game); } 

newAIModule कुछ अधिक जटिल है। इसे पॉइंटर को C ++ क्लास में लौटा देना चाहिए, जिसमें onXXXXX जैसे नामों के साथ एक वर्चुअल मेथड टेबल होता है, जिसे कुछ गेम इवेंट्स में बुलाया जाता है। आइए मॉड्यूल की संरचना की घोषणा करें:

 typedef struct ExampleAIModule { const AIModule_vtable* vtable_; const char* name; } ExampleAIModule; 

पहला क्षेत्र विधि तालिका का सूचक होना चाहिए (यह एक प्रकार का जादू है)। यहाँ newAIModule फ़ंक्शन है:

 DLLEXPORT void* newAIModule() { ExampleAIModule* const module = (ExampleAIModule*) malloc( sizeof(ExampleAIModule) ); module->name = "ExampleAIModule"; module->vtable_ = &module_vtable; return createAIModuleWrapper( (AIModule*) module ); } 

createAIModuleWrapper एक और मैजिक ट्रिक है जो C पॉइंटर को पॉइंटर में C ++ क्लास के साथ बदल देती है आभासी तरीके सदस्य कार्य।

module_vtable विधि तालिका पर एक स्थिर चर है, विधि मान वैश्विक कार्यों के लिए संकेत से भरे हुए हैं:

 static AIModule_vtable module_vtable = { onStart, onEnd, onFrame, onSendText, onReceiveText, onPlayerLeft, onNukeDetect, onUnitDiscover, onUnitEvade, onUnitShow, onUnitHide, onUnitCreate, onUnitDestroy, onUnitMorph, onUnitRenegade, onSaveGame, onUnitComplete }; void onEnd(AIModule* module, bool isWinner) { } void onFrame(AIModule* module) {} void onSendText(AIModule* module, const char* text) {} void onReceiveText(AIModule* module, Player* player, const char* text) {} void onPlayerLeft(AIModule* module, Player* player) {} void onNukeDetect(AIModule* module, Position target) {} void onUnitDiscover(AIModule* module, Unit* unit) {} void onUnitEvade(AIModule* module, Unit* unit) {} void onUnitShow(AIModule* module, Unit* unit) {} void onUnitHide(AIModule* module, Unit* unit) {} void onUnitCreate(AIModule* module, Unit* unit) {} void onUnitDestroy(AIModule* module, Unit* unit) {} void onUnitMorph(AIModule* module, Unit* unit) {} void onUnitRenegade(AIModule* module, Unit* unit) {} void onSaveGame(AIModule* module, const char* gameName) {} void onUnitComplete(AIModule* module, Unit* unit) {} 

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

 void onStart(AIModule* module) { ExampleAIModule* self = (ExampleAIModule*) module; Game* game = BWAPIC_getGame(); Game_sendText(game, "Hello from bwapi-c!"); Game_sendText(game, "My name is %s", self->name); } 

खेल चलने पर इस फंक्शन को कहा जाता है। तर्क वर्तमान मॉड्यूल का एक संकेतक है। BWAPIC_getGame गेम के लिए एक वैश्विक पॉइंटर लौटाता है, जिसे हम BWAPIC_setGame कॉल का उपयोग करके सेट करते हैं। तो, आइए एक मॉड्यूल को क्रॉस-कंपाइल करने का कार्यशील उदाहरण दिखाएं:

 bwapi-c/example$ tree . ├── BWAPIC.dll └── Dll.c 0 directories, 2 files bwapi-c/example$ i686-w64-mingw32-gcc -mabi=ms -shared -o Dll.dll Dll.c -I../include -L. -lBWAPIC bwapi-c/example$ cp Dll.dll ~/Starcraft/bwapi-data/ bwapi-c/example$ cd ~/Starcraft/bwapi-data/ Starcraft$ wine bwheadless.exe -e StarCraft.exe -l bwapi-data/BWAPI.dll --headful ... ... ... 

बटन दबाएं और खेल को चलाएं। संकलन और निष्पादन के बारे में अधिक जानकारी BWAPI वेबसाइट और BWAPI-C पर देखी जा सकती है ।

मॉड्यूल का परिणाम:

आप एक मॉड्यूल का थोड़ा और अधिक जटिल उदाहरण पा सकते हैं जो दिखाता है कि इटवेअटर्स , यूनिट मैनेजमेंट, मिनरल सर्च और सांख्यिकी आउटपुट के साथ कैसे काम करना है। bwapi-c / example / Dll.c.

bwapi-सिस

रस्ट इकोसिस्टम में नामकरण पैकेजों का एक निश्चित तरीका है जो मूल पुस्तकालयों से लिंक होता है। कोई भी पैकेज foo-sys दो महत्वपूर्ण कार्य निष्पादित करता है:

• मूल पुस्तकालय libfoo के साथ लिंक;
• लिबफू पुस्तकालय से कार्यों के लिए घोषणाएं प्रदान करता है। लेकिन घोषणाएं ही! * -एसटी क्रेट में उच्च-स्तरीय अमूर्त प्रदान नहीं किए जाते हैं।

* -Sys पैकेज को सफलतापूर्वक लिंक करने में सक्षम होने के लिए, आपको कार्गो को मूल पुस्तकालय और / या स्रोतों से लाइब्रेरी बनाने के लिए खोजना होगा ।

घोषणाओं को प्रदान करने के लिए * -sys पैकेज के लिए, आपको या तो उन्हें स्वयं लिखना होगा या बिंडगेन का उपयोग करके उन्हें उत्पन्न करना होगा। फिर से बांधना। प्रयास नंबर दो =)

बाइंडिंग की पीढ़ी सुपर आसान है:

 bindgen BWAPI.h -o lib.rs \ --opaque-type ".+_" \ --blacklist-type "std.*|__.+|.+_$|Game_v(Send|Print|Draw).*|va_list|.+_t$" \ --no-layout-tests \ --no-derive-debug \ --raw-line "#![allow(improper_ctypes, non_snake_case)]" \ -- -I../submodules/bwapi-c/include sed -i -r -- 's/.+\s+(.+)_;/pub struct \1;/' lib.rs 

BWAPI.h BWAPI-C के सभी C हेडर के साथ एक फाइल है।

उदाहरण के लिए, ऊपर दिए गए कार्यों के लिए bindgen ने पहले ही ऐसी घोषणाएं कर दी हैं:

 extern "C" { /// BWAPIC_setGame must be called from gameInit to initialize BWAPI::BroodwarPtr pub fn BWAPIC_setGame(game: *mut Game); } extern "C" { pub fn BWAPIC_getGame() -> *mut Game; } 

दो रणनीतियाँ हैं: रिपॉजिटरी में जेनरेट किए गए कोड को स्टोर करना और बिल्ड के दौरान फ्लाई पर कोड को जेनरेट करना। दोनों दृष्टिकोणों के अपने फायदे और नुकसान हैं ।

ख़ुशी है आपसे मिलकर बोवापी-सीस ; हमारे लक्ष्य के लिए एक और छोटा कदम।

क्या आपको याद है कि पहले मैं क्रॉस-प्लेटफ़ॉर्म के बारे में बात कर रहा था? nlinker परियोजना में शामिल हो गया और एक चालाक रणनीति लागू की। यदि लक्ष्य होस्ट विंडोज है, तो GitHub से पहले से ही इकट्ठे BWAPIC को डाउनलोड करें। और शेष लक्ष्यों के लिए हम OpenBW के लिए स्रोतों से BWAPI-C इकट्ठा करते हैं (मैं आपको इसके बारे में थोड़ा बाद में बताऊंगा)।

bwapi-रु

अब हमारे पास बाइंडिंग है और हम उच्च-स्तरीय अमूर्तताओं को परिभाषित कर सकते हैं। हमारे पास काम करने के दो प्रकार हैं: शुद्ध मूल्य और अपारदर्शी बिंदु।

शुद्ध मूल्यों के साथ सब कुछ सरल है। एक उदाहरण के रूप में रंग लेते हैं। हमें सुविधाजनक और प्राकृतिक तरीके से रंगों का उपयोग करने के लिए रस्ट कोड से उपयोग करना आसान बनाने की आवश्यकता है:

 game.draw_line(CoordinateType::Screen, (10, 20), (30, 40), Color::Red); ^^^ 

इसलिए, सुविधाजनक उपयोग के लिए यह आवश्यक होगा कि C ++ स्थिरांक के साथ संलयन को परिभाषित किया जाए, लेकिन जंग के लिए मुहावरेदार भी, और इसे bwapi_sys में परिवर्तित करने के तरीकों को परिभाषित करें :: रंग का उपयोग करके std :: Convert :: से:

 // FFI version #[repr(C)] #[derive(Copy, Clone)] pub struct Color { pub color: ::std::os::raw::c_int, } // Idiomatic version #[derive(PartialEq, PartialOrd, Copy, Clone)] pub enum Color { Black = 0, Brown = 19, ... 

अपनी सुविधा के लिए आप enum-primitive-derive crate का उपयोग कर सकते हैं।

अपारदर्शी बिंदुओं का उपयोग करना भी आसान है। चलिए न्यूटाइप पैटर्न का उपयोग करते हैं:

 pub struct Player(*mut sys::Player); 

इसका मतलब यह है कि प्लेयर एक निजी क्षेत्र के साथ एक तरह की संरचना है - सी से एक कच्चा अपारदर्शी सूचक और यहाँ आप प्लेयर को परिभाषित कर सकते हैं जिस तरह से :: रंग:

 impl Player { // so the method is declared Player::getColor in bwapi-sys //extern "C" { // pub fn Player_getColor(self_: *mut Player) -> Color; //} pub fn color(&self) -> Color { // bwapi_sys::Player_getColor - wrapper function from BWAPI-C // self.0 - opaque pointer let color = unsafe { bwapi_sys::Player_getColor(self.0) }; color.into() // cast bwapi_sys::Color -> Color } } 

अब हम रस्ट में अपना पहला बॉट लिख सकते हैं!

जंग में बॉट बनाना

अवधारणा के प्रमाण के रूप में बॉट एक प्रसिद्ध काउंटररू के समान होगा: संपूर्ण कार्य श्रमिकों को किराए पर लेना और खनिजों को इकट्ठा करना है।

चलो आवश्यक कार्यों के साथ शुरू करते हैं gameInit और newAIModule :

 #[no_mangle] pub unsafe extern "C" fn gameInit(game: *mut void) { bwapi_sys::BWAPIC_setGame(game as *mut bwapi_sys::Game); } #[no_mangle] pub unsafe extern "C" fn newAIModule() -> *mut void { let module = ExampleAIModule { name: String::from("ExampleAIModule") }; let result = wrap_handler(Box::new(module)); result } 

#[no_mangle] C ++ में #[no_mangle] फ़ंक्शन extern "C" के समान कार्य करता है। वर्चुअल फ़ंक्शन टेबल के प्रतिस्थापन और "मास्किंग" सी ++ वर्ग के साथ, wrap_handler अंदर सभी जादू होता है।

मॉड्यूल संरचना की परिभाषा सी की तुलना में और भी सरल और कट्टर है:

 struct ExampleAIModule { name: String, } 

आइए आंकड़ों को प्रस्तुत करने और आदेश देने के लिए कुछ तरीके जोड़ें:

 impl ExampleAIModule { fn draw_stat(&mut self) { let game = Game::get(); let message = format!("Frame {}", game.frame_count()); game.draw_text(CoordinateType::Screen, (10, 10), &message); } fn give_orders(&mut self) { let player = Game::get().self_player(); for unit in player.units() { match unit.get_type() { UnitType::Terran_SCV | UnitType::Zerg_Drone | UnitType::Protoss_Probe => { if !unit.is_idle() { continue; } if unit.is_carrying_gas() || unit.is_carrying_minerals() { unit.return_cargo(false); continue; } if let Some(mineral) = Game::get() .minerals() .min_by_key(|m| unit.distance_to(m)) { // WE REQUIRE MORE MINERALS unit.right_click(&mineral, false); } } UnitType::Terran_Command_Center => { unit.train(UnitType::Terran_SCV); } UnitType::Protoss_Nexus => { unit.train(UnitType::Protoss_Probe); } UnitType::Zerg_Hatchery | UnitType::Zerg_Lair | UnitType::Zerg_Hive => { unit.train(UnitType::Zerg_Drone); } _ => {} }; } } } 

ExampleAIModule प्रकार को एक वास्तविक मॉड्यूल में बदलने के लिए आपको इसे onXXXX घटनाओं पर प्रतिक्रिया देने की आवश्यकता है। ऐसा करने के लिए आपको EventHandler प्रकार को लागू करने की आवश्यकता है, जो कि AIModule_vtable वर्चुअल टेबल का एक एनालॉग है:

 impl EventHandler for ExampleAIModule { fn on_start(&mut self) { Game::get().send_text(&format!("Hello from Rust! My name is {}", self.name)); } fn on_end(&mut self, _is_winner: bool) {} fn on_frame(&mut self) { self.draw_stat(); self.give_orders(); } fn on_send_text(&mut self, _text: &str) {} fn on_receive_text(&mut self, _player: &mut Player, _text: &str) {} fn on_player_left(&mut self, _player: &mut Player) {} fn on_nuke_detect(&mut self, _target: Position) {} fn on_unit_discover(&mut self, _unit: &mut Unit) {} fn on_unit_evade(&mut self, _unit: &mut Unit) {} fn on_unit_show(&mut self, _unit: &mut Unit) {} fn on_unit_hide(&mut self, _unit: &mut Unit) {} fn on_unit_create(&mut self, _unit: &mut Unit) {} fn on_unit_destroy(&mut self, _unit: &mut Unit) {} fn on_unit_morph(&mut self, _unit: &mut Unit) {} fn on_unit_renegade(&mut self, _unit: &mut Unit) {} fn on_save_game(&mut self, _game_name: &str) {} fn on_unit_complete(&mut self, _unit: &mut Unit) {} } 

मॉड्यूल बनाना और चलाना C के लिए जितना सरल है:

 bwapi-rs$ cargo build --example dll --target=i686-pc-windows-gnu bwapi-rs$ cp ./target/i686-pc-windows-gnu/debug/examples/dll.dll ~/Starcraft/bwapi-data/Dll.dll bwapi-rs$ cd ~/Starcraft/bwapi-data/ Starcraft$ wine bwheadless.exe -e StarCraft.exe -l bwapi-data/BWAPI.dll --headful ... ... ... 

और काम का वीडियो:

OpenBW

ये लोग और भी आगे बढ़ गए। उन्होंने SC: BW का एक ओपन-सोर्स संस्करण लिखने का फैसला किया! और वे इसमें अच्छे हैं। उनका एक लक्ष्य एचडी छवियों को लागू करना था, लेकिन एससी: रीमास्टर्ड उनके आगे था = (इस समय, आप बॉट लिखने के लिए उनके एपीआई का उपयोग कर सकते हैं (हां, सी ++ में भी), लेकिन सबसे आश्चर्यजनक विशेषता देखने की क्षमता है आपके ब्राउज़र में सीधे रिप्ले करता है ।

निष्कर्ष

कार्यान्वयन के साथ एक अनसुलझी समस्या थी: हम अद्वितीय होने के लिए संदर्भों को नियंत्रित नहीं करते हैं, इसलिए वस्तु के संशोधित होने पर &mut और उसी क्षेत्र के अस्तित्व का अपरिभाषित व्यवहार होगा। एक मुसीबत की तरह। हाल्ट ने मुहावरेदार बाइंडिंग को लागू करने की कोशिश की , लेकिन उन्होंने इसका हल खोजने का प्रबंधन नहीं किया। यदि आप इस कार्य को पूरा करना चाहते हैं, तो भी आपको सी ++ एपीआई को सावधानीपूर्वक "फावड़ा" करना होगा और const क्वालिफायर को सही ढंग से const होगा।

मुझे वास्तव में इस परियोजना पर काम करने में बहुत मज़ा आया, मैंने रिप्ले 종일 this को देखा और वातावरण में गहराई से डूब गया। इस गेम ने एक ब्रह्मांड में 놀라운 सेंध लगाई। SC: BW के साथ लोकप्रियता से कोई खेल game 비교할 비교할 नहीं हो सकता है, और 정치 에게 대한민국 पर इसका प्रभाव अकल्पनीय था। कोरिया में प्रो-गेमर्स as as 배우 들 in कोरियन डोरम्स के प्राइम टाइम में प्रसारित होने के साथ ही लोकप्रिय हैं। 한국, 한국 한국 한국 한국 한국 한국 한국 한국 한국 한국 한국 한국 한국।

लंबे समय तक जीवित StarCraft!

लिंक

• reddit
• bwapi-रु
• bwapi-सिस
• bwapi-सी
• bwapi
• openbw

लेख की समीक्षा करने में मेरी मदद करने के लिए स्टीव क्लाबनिक को बहुत धन्यवाद।