छद्म 3 डी ग्राफिक्स के साथ एक शूटर ... बैश

हैलो, Habrachelovek!

मैंने किसी तरह तय किया कि "हैलो वर्ल्ड!" को बैश में लिखना सीखना अच्छा होगा। आखिरकार, मैं छह महीने के लिए ubunt पर काम कर रहा हूं, यह ऐसा करने में सक्षम नहीं होने के लिए शर्म की बात है। मैंने हैबे को देखा और महसूस किया कि आजकल मैनुअल पढ़ना फैशनेबल नहीं है, आपको अपना खेल लिखने की ज़रूरत है। यह कौन सा चुनना है। शतरंज , ज़ोनिक्स , सोकोबन , सागर लड़ाई पहले ही लिखी जा चुकी है, टेट्रिस भी लगता है (हालांकि मुझे लिंक नहीं मिला), क्या चुनना है? पहला विचार एक रणनीति थी, लेकिन पूर्ण पागलपन के कारण इसे वापस फेंक दिया गया था (हालांकि मुझे उम्मीद है कि उन लोगों में से एक जो बैश पर खेल के बारे में विषयों के इतिहास को जारी रखेंगे, वे इसे भी लिखेंगे)। इसलिए मैं निशानेबाज पर बस गया।


* चित्र एक गलियारे और एक राक्षस को कुछ कदम आगे दिखाता है

स्क्रिप्ट लिंक: github.com/EvilTosha/labirinth/blob/master/lab2.sh

कटौती के तहत आप खेल के अंदर के एक बिल्कुल निर्बाध और अनावश्यक विवरण पाएंगे।

रेखाचित्र, परिप्रेक्ष्य और सामान्य विचार।

यह सब कागज के एक टुकड़े पर स्केच के साथ शुरू हुआ।



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

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

#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <cmath>
#include <vector>

using namespace std;

// p ,
// p1 p2
bool overLine(pair< int , int > p1, pair< int , int > p2, pair< int , int > p){
return (p1.second - p2.second) * p.first + (p2.first - p1.first) * p.second >
-(p1.first * p2.second - p2.first * p1.second);
}

const int width = 128;
const int height = 36;
//
const int delta_ceil = 20;
const int delta_floor = 20;

int main(){
freopen( ".out" , "w" , stdout);
char field[height][width];
//
pair< int , int > p3(11, width / 2), p6(12, width / 2);
//
pair< int , int > p1(0, delta_ceil), p2(0, width - delta_ceil);
pair< int , int > p4(height, delta_floor), p5(height, width - delta_floor);
//
int depths[8] = {10, 27, 39, 48, 54, 58, 61, 65};
for ( int x = 0; x < height; ++x){
for ( int y = 0; y < width; ++y){
pair< int , int > p(x, y);
//
if (!overLine(p2, p3, p) && !overLine(p3, p1, p))
field[x][y] = 'c' ;
//
else if (overLine(p6, p4, p) && overLine(p5, p6, p))
field[x][y] = 'f' ;
//
else {
int wall = min(y, width - y);
int d = 0;
while (wall > depths[d])
++d;
field[x][y] = '0' + d;
}
}
}
//
for ( int x = 0; x < height; ++x){
for ( int y = 0; y < width; ++y){
cout << field[x][y];
}
cout << endl;
}
return 0;
}

* This source code was highlighted with Source Code Highlighter .

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

इसलिए, कुछ क्षेत्र कोशिकाओं की दीवार बनाने का निर्णय लिया गया। लेकिन प्रतिपादन के साथ कुछ समस्याएं हैं। ऐसी स्थिति में क्या करना है?

इसलिए, उत्पन्न भूलभुलैया पर प्रतिबंध लगाया जाता है - इसमें दीवारों के बिना एक 2 * 2 वर्ग नहीं होना चाहिए। अब इस चक्रव्यूह को उत्पन्न करने की आवश्यकता है।

भूलभुलैया पीढ़ी

यह एक गहरी खोज के समान एक एल्गोरिथ्म का उपयोग करता है। यानी हम पूरे क्षेत्र को दीवारों से भरते हैं, शुरुआती बिंदु का चयन करते हैं, और फ़ील्ड को ग्राफ़ के रूप में बायपास करना शुरू करते हैं, केवल हम सभी पड़ोसियों के माध्यम से एक विशिष्ट क्रम में नहीं, बल्कि यादृच्छिक रूप से सॉर्ट करते हैं। इसके अलावा, हम जांचते हैं कि क्या "निषिद्ध" 2 * 2 वर्ग का गठन किया गया है। हमें कुछ ऐसा मिलता है

पीढ़ी लंबे समय तक काम करती है (20 * 20 सेकंड के एक जोड़े के लिए), संभवतः स्टैक पर एक पुनरावृत्ति को चालू करने से गति में ध्यान देने योग्य वृद्धि होगी, लेकिन हमें इतने बड़े mazes की आवश्यकता क्यों है?

त्वरित रेंडर

प्रारंभ में, प्रत्येक "पिक्सेल" को अपनी प्रतिध्वनि द्वारा प्रदर्शित किया गया था। "स्क्रीन" 36 * 128 के आकार के साथ, एक "फ्रेम" खींचना लगभग एक सेकंड लगा, और मुझे वास्तव में यह पसंद नहीं आया। यदि आप केवल उन "पिक्सेल" को खींचते हैं जो बदल गए हैं, तो गति और भी अधिक गिर जाती है। इसलिए, निम्नलिखित कार्य किया गया: हमने सभी वर्णों को एक सरणी में रखा, और फिर कॉल किया

प्रतिध्वनि "$ {स्क्रीन [*]}"

सभी तत्वों का उत्पादन करने के लिए। लेकिन ऐसी कॉल के साथ, सरणी के तत्व रिक्त स्थान से अलग हो जाते हैं। मेरे लिए आउटपुट स्क्रीन में केवल बहु-रंगीन रिक्त स्थान होते हैं, इसलिए यह मेरी आँखें बंद करना संभव होगा, लेकिन मैं कुछ सार्वभौमिकता चाहता था। इसका समाधान यह था: IFS (आंतरिक क्षेत्र विभाजक) को बदलें, जो प्रारंभ में "\ n \ t" (पंक्ति फ़ीड, टैब और स्थान) को खाली करने के लिए सेट किया गया है, और स्क्रिप्ट के अंत में, इसे वापस बदल दें (ताकि आप पुन: संशोधित किए बिना जारी रख सकें टर्मिनल)। इससे समस्या पूरी तरह से हल हो गई। लेकिन वैसे, 5 से अधिक एफपीएस प्राप्त करना संभव नहीं था, इसलिए "रियलटाइम-मोड" को शुरू में अक्षम कर दिया गया था और शूटर कदम से कदम उठाता है। लेकिन अगर आप स्क्रीन की "टिमटिमा" के साथ अपनी आंखों का मजाक बनाना चाहते हैं, तो आप इसे स्थिरांक में बदल सकते हैं।
वैसे, संपूर्ण स्क्रिप्ट पाठ और पृष्ठभूमि के लिए केवल मानक 8 रंगों का उपयोग करती है। यदि आप बहुत सारे रंगों के साथ भ्रमित हो जाते हैं, तो आप सुंदर ढाल प्रकाश व्यवस्था कर सकते हैं, और रंग अधिक प्राकृतिक हैं ...

मैं एक राक्षस के निर्माण, शूट करने की क्षमता और अन्य trifles का वर्णन नहीं करूंगा, वहां सब कुछ सरल और उबाऊ है।

निष्कर्ष

बहुत सी चीजें थीं जो मैं करना चाहता था, लेकिन धैर्य की कमी थी (अधिक सटीक रूप से, ब्याज लागू होने से पहले ही गायब हो गया था)। यह एक के बजाय कई राक्षसों के लिए है, जीवन का सही काम (अब वे केवल सुंदरता के लिए प्रदर्शित किए जाते हैं), हथियारों का एक परिवर्तन (और तदनुसार विभिन्न विशेषताओं), एक सांत्वना (iddqd, लेकिन क्या? =)) और, ज़ाहिर है, एक नेटवर्क गेम।

मैं गेम प्रक्रिया का एक और वीडियो अपलोड करना चाहता था, लेकिन जब मैंने रिकॉर्डिंग के लिए आवश्यक सॉफ़्टवेयर स्थापित किया, तो वर्चुअल बॉक्स पर ऑबंट टूट गया। = (

आपके ध्यान के लिए धन्यवाद, मुझे किसी भी आलोचना में खुशी होगी!