बैश स्क्रिप्ट सीखें, Xonix लिखें

मैंने हब पर कुछ हफ्ते पहले एक लेख पढ़ा था मैंने यह भी सोचा और याद किया कि मैं लंबे समय से एक्सोनिक्स लिखना चाहता था, मैंने एक बार अपने पुराने 386 वें दिन इस खेल के साथ छेड़खानी की थी। और अब, कुछ रातों की नींद हराम और स्क्रिप्ट तैयार है। यदि यह दिलचस्प है कि यह कैसे लिखा गया था, तो क्या समस्याएं पैदा हुईं, तो हैब्रैट में आपका स्वागत है।



गेम के नियम एक्सोनिक्स को विकिपीडिया पर पढ़ा जा सकता है। लेकिन चूंकि मेरे द्वारा एक बार खेले गए कार्यान्वयन में कोई भूमि विरोधी नहीं थे, इसलिए मेरे कार्यान्वयन में उनमें से कोई भी नहीं होगा।

लिखते समय, बैश और पर्यावरण की कई अलग-अलग विशेषताओं का उपयोग किया गया था, मैं अपनी राय में, सबसे दिलचस्प पर ध्यान केंद्रित करूंगा।

कार्यों

चूंकि यह तुरंत स्पष्ट है कि स्क्रिप्ट बड़ी होगी, इसलिए कार्यों का उपयोग करना बुद्धिमानी है। बाश में कार्यों में कुछ भी जटिल नहीं है। फ़ंक्शन को निम्नानुसार परिभाषित किया गया है।

function func() { cmd1 cmd2 ... cmdn } 

और इसे इस तरह कहा जाता है:

 func param1 param2 ... paramn 

फ़ंक्शन बॉडी में मापदंडों तक पहुंच $1 , $2 का उपयोग करके की जाती है, ... आप स्थानीय का उपयोग करके local चर भी घोषित कर सकते हैं। लेकिन दो विशेषताएं हैं। पहला यह है कि चर में एक गतिशील गुंजाइश है, और सामान्य स्थिर नहीं है, अर्थात, निम्न कोड

 i=3 function f() { echo $i } function g() { local i=5 f } function h() { local i=10 f } g h 

5 और 10 को आउटपुट देगा।

वही जावास्क्रिप्ट कोड

 var i = 3; function f() { alert(i); } function g() { var i = 5; f(); } function h() { var i = 10; f(); } g(); h(); 

आदतन दो बार प्रदर्शित करता है।

दूसरी विशेषता यह है कि फ़ंक्शन बॉडी खाली नहीं हो सकती है (साथ ही बैश में किसी भी ब्लॉक)। यह बृहदान्त्र का उपयोग करके हल किया जाता है। तो स्टब फ़ंक्शन इस तरह दिखेगा:

 function f() { : } 

इसके अलावा, जब किसी कारण से आपको फ़ंक्शन बॉडी पर टिप्पणी करने की आवश्यकता होती है, तो इसके बजाय # आप बस लिख सकते हैं :

 function f() { : cmd1 : cmd2 : cmd3 } 

उपयोगकर्ता सहभागिता

यह कंसोल के लिए रंगीन वर्णों को आउटपुट करने के तरीके के बारे में अच्छी तरह से जाना जाता है, इसके लिए, एस्केप सीक्वेंस "\e[ ; ; m" । कर्सर को एस्केप सीक्वेंस "\e[ ; f" का उपयोग करके तैनात किया गया है। इस मामले में, उलटी गिनती एक से होती है। दो और भागने के क्रम सुविधाजनक हैं: "\e[2K" - संपूर्ण वर्तमान रेखा को साफ़ करें, "\e[2J" - संपूर्ण स्क्रीन को साफ़ करें। आप अधिक से अधिक man console_codes में पढ़ सकते हैं।

हमें कंसोल के आकार को भी जानने की आवश्यकता है, वे वेरिएबल COLUMNS और LINES में संग्रहीत हैं। लेकिन वे केवल ऑनलाइन उपलब्ध हैं, इसलिए पहली पंक्ति लिखना है

 #!/bin/bash -i 

अगला, आपको उपयोगकर्ता से इको आउटपुट को दबाने की जरूरत है, इसके लिए हम लिखते हैं

 stty -echo 

जब आपको इसकी आवश्यकता हो, तो लिखें

 stty echo 

चूंकि हमें निश्चित अंतराल पर क्षेत्र को फिर से बनाना है, और अभी भी यह निर्धारित करता है कि उपयोगकर्ता ने किन कुंजियों को दबाया, मुख्य लूप कुछ इस तरह दिखता है:

 function runLevel() { local -l key local -i time=0 local -i newTime ... while true; do key="" read -t $TIMEOUT -n 1 key newTime=$((`date +%s` * 100 + (10#`date +%N` / 10000000))) case "$key" in $UP_KEY) playerDY=-1 playerDX=0;; $DOWN_KEY) playerDY=1 playerDX=0;; $LEFT_KEY) playerDX=-1 playerDY=0;; $RIGHT_KEY) playerDX=1 playerDY=0;; $EXIT_KEY) break 3;; "") ;; esac if [[ $((newTime - time)) -ge DELAY ]]; then movePlayer moveOpponents time=newTime fi ... done } 

यहाँ निम्नलिखित बिंदु रूचि के हैं। key चर पर -l विशेषता आपको यह भूल जाने की अनुमति देती है कि CAPS LOCK कुंजी को दबाया जा सकता है, क्योंकि चर का मान हमेशा कम होगा। और अभिव्यक्ति, जिसका मूल्य newTime को सौंपा गया है, मिलिसेकंड की सटीकता के साथ समय की गणना करता है।

सरणियों

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

 function initMap() { local -ii local -ij for ((i = 1; i < MAP_HEIGHT - 1; ++i)); do for ((j = 1; j < MAP_WIDTH - 1; ++j)); do map[i * MAP_WIDTH + j]=$SEA done done for ((i = 0; i < MAP_HEIGHT; ++i)); do map[i * MAP_WIDTH]=$LAND map[i * MAP_WIDTH + MAP_WIDTH - 1]=$LAND done for ((j = 0; j < MAP_WIDTH; ++j)); do map[j]=$LAND map[(MAP_HEIGHT - 1) * MAP_WIDTH + j]=$LAND done } 

मैं ध्यान देता हूं कि सरणी में छेद संभव हैं। और बैश में भी साहचर्य सरणियाँ हैं।

अभिलेखों की एक तालिका को व्यवस्थित करने के लिए, आपको फ़ाइल में एक सरणी लिखनी होगी और फ़ाइल से सरणी को पढ़ना होगा। सुविधा के लिए, हम सरणी के प्रत्येक तत्व को एक अलग पंक्ति में लिखेंगे। फिर फ़ाइल से परिणामों के साथ सरणी को पढ़ना इस तरह दिखाई देगा:

 function writeTopScores() { (IFS=$'\n'; echo "${topScores[*]}" > "$TOP_SCORES_FILE_NAME") } 

संक्षिप्त विवरण: ${a[*]} अर्थ है सरणी के सभी तत्वों का प्रतिस्थापन। इसके अलावा, यदि यह अभिव्यक्ति दोहरे उद्धरण चिह्नों में पाई जाती है, तो IFS चर से पहला वर्ण एक विभाजक के रूप में लिया जाएगा।
एक सरणी पढ़ना भी सरल है:

 function readTopScores() { topScores=() if [[ -r "$TOP_SCORES_FILE_NAME" ]]; then readarray -t topScores < "$TOP_SCORES_FILE_NAME" fi } 

समुद्र के विजयी टुकड़ों को हटाना

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

यह पता चला कि समुद्र के पकड़े गए टुकड़ों को हटाने का उपमा एक दिलचस्प उपमा है। सबसे पहले, डोमेन फिलिंग एल्गोरिदम के आधार पर एक सरल एल्गोरिथ्म लागू किया गया था:

 function deleteFreeAreas() { local -a points local -ii for ((i = 0; i < countOpponents; ++i)); do points[i]=$((opponents[4 * i] * mapWidth + opponents[4 * i + 1])) done local -i countPoints=$countOpponents local -i index while [[ countPoints -ne 0 ]]; do index=$((points[--countPoints])) map[index]=$opponentArea if [[ ${map[index + 1]} == $sea ]]; then points[countPoints++]=$((index + 1)) fi if [[ ${map[index - 1]} == $sea ]]; then points[countPoints++]=$((index - 1)) fi if [[ ${map[index + mapWidth]} == $sea ]]; then points[countPoints++]=$((index + mapWidth)) fi if [[ ${map[index - mapWidth]} == $sea ]]; then points[countPoints++]=$((index - mapWidth)) fi done ... } 

लेकिन यह बहुत, बहुत, बहुत धीमा था। अनुकूलन पर दो या तीन घंटे बिताने के बाद, मैंने इस तरह से पुनर्लेखन किया या कि, इसे दो बार तेज किया, महसूस किया कि मुझे एक अलग दृष्टिकोण की आवश्यकता है, और बिस्तर पर चला गया। और सुबह हब्र पर मैंने एक बाइनरी छवि में वस्तुओं को गिनते हुए लेख देखा । भाग 1 जो हमें चाहिए था। तुरंत मैंने एल्गोरिथ्म को वहां लागू किया, जिसका समय काफी संतुष्ट था:

 function deleteFreeAreas() { local -a marks=() local -i mark=MARK_0 ... for ((i = 1; i < MAP_HEIGHT - 1; ++i)); do for ((j = 1; j < MAP_WIDTH - 1; ++j)); do index=$((i * MAP_WIDTH + j)) if [[ ${tracks[index]} ]]; then map[index]=$LAND fi a=${map[index]} b=${map[(i - 1) * MAP_WIDTH + j]} c=${map[i * MAP_WIDTH + j - 1]} if [[ a -eq SEA ]]; then if [[ b -ne LAND && c -ne LAND ]]; then if [[ ${marks[b]} -eq ${marks[c]} ]]; then map[index]=${marks[b]} else d=$(((b < c) ? b : c)) e=$(((b < c) ? c : b)) map[index]=${marks[d]} m=${marks[e]} for ((k = MARK_0; k < mark; ++k)); do if [[ ${marks[k]} -eq m ]]; then marks[k]=${marks[d]} fi done fi elif [[ b -eq LAND && c -eq LAND ]]; then map[index]=$mark marks[mark]=$mark ((++mark)) elif [[ b -ne LAND && c -eq LAND ]]; then map[index]=${marks[b]} elif [[ b -eq LAND && c -ne LAND ]]; then map[index]=${marks[c]} fi fi done done for ((i = 0; i < countOpponents; ++i)); do m=${marks[${map[$(( ${opponents[4 * i]} * MAP_WIDTH + ${opponents[4 * i + 1]}))]}]} for ((j = 0; j < mark; ++j)); do if [[ ${marks[j]} -eq m ]]; then marks[j]=$OPPONENT_AREA fi done done ... } 

हिलते हुए दुश्मन

एक और दिलचस्प उपमा सीमाओं से दुश्मनों को खदेड़ने के लिए एक कोड लिख रहा था। सबसे पहले मैंने विभिन्न विकल्पों के चेक के एक समूह के साथ कोड लिखने की कोशिश की, लेकिन यह भारी और अनाड़ी काम कर रहा था। मुझे फिर से सोचना पड़ा।

यह समझना आसान है कि दुश्मन की अगली स्थिति निर्धारित करने के लिए, आपको एक 3x3 फ़ील्ड का एक टुकड़ा जानने की आवश्यकता है, और यह कि दुश्मन के चारों ओर केवल 2 ^ 8 = 256 वेरिएंट संभव हैं।

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

 _ X _ XXXXX _ _ XX _ 1 _ _ 1 _ _ 1 _ _ 1 _ _ _ 2 _ _ 2 _ _ 2 _ _ 2 

हम संकेतन का परिचय देते हैं: X - भूमि, _ - समुद्र,? - कुछ भी।

फिर उपरोक्त विन्यास और कुछ अन्य को निम्न पैटर्न द्वारा परिभाषित किया गया है:

 ? X ? ? o _ ? _ _ 

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

 function compare() { local -r -a pattern=($1) local -r -ax=($2) local -ii for ((i = 0; i < 8; ++i)); do if [[ ${pattern[i]} -ne ANY && ${pattern[i]} -ne ${x[i]} ]]; then return 1 fi done return 0 } rules=( # pattern dy dx "$ANY $SEA $SEA $ANY $SEA $ANY $ANY $ANY" 1 1 "$ANY $LAND $ANY $ANY $SEA $ANY $SEA $SEA" -1 1 "$SEA $SEA $ANY $SEA $LAND $ANY $ANY $ANY" 1 -1 "$ANY $ANY $LAND $ANY $ANY $LAND $ANY $ANY" 0 0 "$ANY $LAND $ANY $ANY $ANY $ANY $LAND $ANY" 0 0 "$ANY $ANY $ANY $LAND $LAND $ANY $ANY $ANY" 0 0 ... "$ANY $LAND $ANY $ANY $ANY $LAND $ANY $LAND" 0 0 ) declare -r -i COUNT_RULES=$((${#rules[*]} / 3)) function findRule() { local -rx=$1 for ((i = 0; i < COUNT_RULES; ++i)); do if compare "${rules[i * 3]}" "$x"; then echo ${rules[i * 3 + 1]} ${rules[i * 3 + 2]} break fi done } function moveOpponents() { local -ii local -iy local -ix local -i dx local -i dy local -a cells local -a rule for ((i = 0; i < countOpponents; ++i)); do y=${opponents[4 * i]} dy=${opponents[4 * i + 2]} x=${opponents[4 * i + 1]} dx=${opponents[4 * i + 3]} clearOpponent $y $x cells[0]=${map[(y + dy) * MAP_WIDTH + x - dx]} cells[1]=${map[(y + dy) * MAP_WIDTH + x]} cells[2]=${map[(y + dy) * MAP_WIDTH + x + dx]} cells[3]=${map[y * MAP_WIDTH + x - dx]} cells[4]=${map[y * MAP_WIDTH + x + dx]} cells[5]=${map[(y - dy) * MAP_WIDTH + x - dx]} cells[6]=${map[(y - dy) * MAP_WIDTH + x]} cells[7]=${map[(y - dy) * MAP_WIDTH + x + dx]} rule=(`findRule "${cells[*]}"`) ((dy *= rule[0])) ((dx *= rule[1])) ((y += dy)) ((x += dx)) opponents[4 * i]=$y opponents[4 * i + 2]=$dy opponents[4 * i + 1]=$x opponents[4 * i + 3]=$dx drawOpponent $y $x done ... } 

और अंत में, दो मजेदार गलतियाँ जो मैंने स्क्रिप्ट लिखते समय की थी।

• चर, जिसे अब ट्रैक कहा जाता है, मैंने पहली बार PATH का नाम दिया। और तब मुझे समझ नहीं आया कि स्क्रिप्ट अयोग्य त्रुटियों के साथ क्रैश क्यों होती है।
• लाइन
  

   readarray -t topScores < "$TOP_SCORES_FILE_NAME" 

  
  मैंने पहली बार कैसे लिखा
  

   cat "$TOP_SCORES_FILE_NAME" | readarray -t topScores 

  
  हालांकि वह जानता था, वह जानता था कि कन्वेयर को सभी परिणामों के साथ एक अलग प्रक्रिया में निष्पादित किया जाता है।
  

और कितने लापता डॉलर आइकन, रिक्त स्थान - गिने नहीं जा सकते।

स्क्रिप्ट http://codepad.org/UfTfcMxj पर देखी जा सकती है। इसे 80x25 कंसोल में चलाने की सलाह दी जाती है। यदि आप पूर्ण स्क्रीन तक विस्तार करते हैं, तो कमजोर कंप्यूटरों पर ब्रेक संभव है।

UPD1। यदि स्क्रिप्ट को codepad.org से कच्चे कोड के रूप में डाउनलोड किया जाता है, तो लाइन वर्णों के अंत को CRLF के रूप में सहेजा जाता है। और स्टार्टअप में स्क्रिप्ट त्रुटियों में डालना शुरू कर देता है। या तो मैन्युअल रूप से पाठ को फ़ाइल में डालें, या इसे dos2unix फ़ाइल पर सेट करें।

UPD2। यह पता लगाया गया है कि प्रमुख रिवर्स आंदोलन को दबाने के मामले में नियम अलग हैं। अगर कोई इस मामले में जान लेना चाहता है, तो वह पैच tzlom habrayuzer http://codepad.org/slUUrueq का उपयोग कर सकता है।