🦌 📠 🔣 Libgdx का उपयोग करके एक शून्य प्लेयर गेम बनाना 🦉 🕑 🐔

विचार

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

Libgdx क्यों?

मैंने विभिन्न उपकरणों से विकास का संचालन किया, ubuntu पर घरेलू कंप्यूटर और win8 पर टैबलेट, java + ग्रहण बंडल ने मुझे समस्याओं के बिना ऐसा करने की अनुमति दी। Libgdx का उपयोग कैमरे के साथ काम करने की सुविधा, भविष्य में ग्राफिक्स जोड़ने की क्षमता के साथ-साथ Android के लिए एक संस्करण बनाने के लिए किया जाता है।

इस लेख में

एक खेल की कटाई जिसमें इसे लागू किया जाता है:

खेल का मैदान
भूलभुलैया पीढ़ी
मानचित्र पर क्लिक करके एक जानवर बनाना
क्षेत्र का एक पूरा नक्शा बनाने के लिए क्षेत्र में, बाधाओं से बचने वाले जीवों को ले जाना।

परिणाम:

शुरुआत

ग्रहण में परियोजना को बनाने और आयात करने के बाद, आवश्यक फ़ील्ड जोड़ें (libgdx के संस्करण के आधार पर, कुछ पहले से ही हो सकते हैं)

SpriteBatch batch;//       OrthographicCamera camera;//    Texture texture;// (   png  -     )

बनाने () विधि में, उन्हें आरंभ करें:

 batch = new SpriteBatch(); batch.disableBlending(); camera = new OrthographicCamera(FIELD_SIZE, FIELD_SIZE);

आवश्यक स्थिरांक जोड़ें:

 public static final int FIELD_SIZE = 51;// ( ) public static float UPDATE_TIME = 0.001f;//  ""

इसके अलावा, अमूर्त वर्ग सेल उपयोगी है, जो कोशिकाओं की सामान्य कार्यक्षमता का वर्णन करेगा।

 public abstract class Cell { public Color color; Sprite sprite; public Cell(Texture texture, Color color){ this.color = color; sprite = new Sprite(texture); sprite.setColor(color); sprite.setSize(1, 1); } public abstract void update(Cell[][] map, int x, int y, Texture texture); public void setColor(Color color){ this.color = color; sprite.setColor(color); } public void draw(SpriteBatch batch,int x, int y){ sprite.setPosition(x-Main.FIELD_SIZE/2-sprite.getWidth()/2, y-Main.FIELD_SIZE/2-sprite.getHeight()/2); sprite.draw(batch); } }

तुरंत इसके दो वारिस दीवार और खाली पर विचार करें।

 public class Wall extends Cell { public Wall(Texture texture) { super(texture, new Color(0f, 0f, 0f, 1)); } @Override public void update(Cell[][] map, int x, int y, Texture texture) { } } public class Empty extends Cell { public Empty(Texture texture) { super(texture, new Color(1, 1, 1, 1)); } @Override public void update(Cell[][] map, int x, int y, Texture texture) { } }

अब आपको एक भूलभुलैया बनाने की आवश्यकता है। मैं एल्गोरिथ्म की व्याख्या नहीं करूंगा, यह अच्छी तरह से यहां प्रस्तुत किया गया है । मैंने इस एल्गोरिथ्म को एक सिंगल गेटमेज़ेनेटर क्लास में सिंगल गेटमैज़ (इंट साइज़) विधि से चुना है जो दो-आयामी सरणी शून्य और लोगों को देता है, जहां 0 एक खाली सेल है, 1 एक दीवार है।

खेल मैदान को एक सरल दो-आयामी सरणी में संग्रहीत किया जाएगा:

 Cell[][] map;

फ़ील्ड बनाना इस तरह दिखता है:

 map = new Cell[FIELD_SIZE][FIELD_SIZE]; texture = new Texture(Gdx.files.internal("tile.png"));//    char[][] bmap = (new MazeGenerator()).getMaze(FIELD_SIZE - 1); for (int i = 0; i < FIELD_SIZE; i++) for (int j = 0; j < FIELD_SIZE; j++) { if (bmap[i][j] == 0) map[i][j] = new Empty(texture); if (bmap[i][j] == 1) map[i][j] = new Wall(texture); }

अब कार्यक्रम शुरू होने पर हर बार हमारे पास एक यादृच्छिक भूलभुलैया है। आप स्थिरांक के साथ चारों ओर खेल सकते हैं और अपने लिए सबसे अच्छा संयोजन निर्धारित कर सकते हैं।

हां, इस स्क्रीन टाइल पर। पीएनजी सिर्फ एक सफेद वर्ग है।

जानवर

यह दुनिया को जीवन से भरने का समय है।

एक सेल वंशज बनाएँ:

 public class Unit extends Cell { Cell[][] my_map = new Cell[3][3];// ,      float update_time = Main.UPDATE_TIME;//  int mapX = 1, mapY = 1;//     Vector<Action> queue = new Vector<Action>();//    enum Action { left, right, up, down//  } public Unit(Texture texture, Cell[][] map, int x, int y) { super(texture, new Color(1f, 0, 0, 1)); for (int i = x - 1; i <= x + 1; i++) for (int j = y - 1; j <= y + 1; j++) my_map[i - x + 1][j - y + 1] = map[i][Main.FIELD_SIZE - j - 1]; my_map[1][1] = this; homeX = 1; homeY = 1; } private int goRight(Cell[][] map, int x, int y, Texture texture) {...}//map - ,   , x,y -     private int goLeft(Cell[][] map, int x, int y, Texture texture) {...} private int goUp(Cell[][] map, int x, int y, Texture texture) {...} private int goDown(Cell[][] map, int x, int y, Texture texture) {...}

मैं पोस्ट को कोड के साथ लोड नहीं करना चाहता, इसलिए मैंने पूरी अपडेट विधि नहीं दी।

काम का एल्गोरिथ्म सरल है: हम क्रियाओं की कतार की जांच करते हैं, यदि यह खाली नहीं है, तो स्पर्श काउंटर को कम करें, यदि यह खाली है, तो इसे फिर से बढ़ाएं और कार्रवाई करें और नक्शे पर पड़ोस को अपडेट करें। यदि कोई कार्रवाई नहीं होती है, तो हम एक नया मार्ग बना रहे हैं, लेकिन उस पर और बाद में, और अब हम चरित्र के कदम पर विचार करेंगे।

सुविधा के लिए, प्रत्येक दिशा में एक कदम के लिए एक अलग विधि बनाएं:

 private int goRight(Cell[][] map, int x, int y, Texture texture) {...}//map - ,    private int goLeft(Cell[][] map, int x, int y, Texture texture) {...}//x,y -     private int goUp(Cell[][] map, int x, int y, Texture texture) {...} private int goDown(Cell[][] map, int x, int y, Texture texture) {...}

एक "चरण" में कई क्रियाएं शामिल होंगी।

जाँच करें कि क्या आपको अपने स्वयं के मानचित्र का विस्तार करने की आवश्यकता है
नक्शा विस्तार (एक नया बढ़े हुए एरे को बनाना और पुराने मैप को उसमें कॉपी करना)
एक नए सेल में जाएं
MapX, mapY में परिवर्तन लिखना

मार्ग की परिभाषा

मेरी राय में, सबसे सरल समाधान एक तरंग एल्गोरिथ्म है जो एक यादृच्छिक खाली सेल में मार्ग बनाता है

ऐसा करने के लिए, मैंने एक स्थिर विधि के साथ एक नया WavePath वर्ग जोड़ा:

 public static Vector<Action> getPath(Cell[][] my_map, int x, int y, int nx,int ny){...}

यह विधि बेतरतीब ढंग से चयनित बिंदु तक पहुंचने के लिए चरणों का क्रम देती है।

अंतिम स्पर्श

अब यह केवल स्क्रीन पर यह सब खींचने के लिए बना हुआ है और, मानचित्र सरणी के माध्यम से छंटनी करके, कोशिकाओं की स्थिति को अपडेट करता है

 @Override public void render() { this.update();//  Gdx.gl.glClearColor(0, 0, 0, 1); Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT); batch.setProjectionMatrix(camera.combined); batch.begin(); for (int i = 0; i < FIELD_SIZE; i++) for (int j = 0; j < FIELD_SIZE; j++) if(!(map[i][j] instanceof Wall))//       map[i][j].draw(batch, i, j); batch.end(); } public void update() { Input input = Gdx.input; for (int i = 0; i < FIELD_SIZE; i++) for (int j = 0; j < FIELD_SIZE; j++) map[i][j].update(map, i, j, texture);// if(input.isKeyPressed(Input.Keys.W))// , , ,  camera.zoom-=Gdx.graphics.getDeltaTime(); if(input.isKeyPressed(Input.Keys.S)) camera.zoom+=Gdx.graphics.getDeltaTime(); if(input.isKeyPressed(Input.Keys.Q)) camera.rotate(Gdx.graphics.getDeltaTime()*90); if(input.isKeyPressed(Input.Keys.E)) camera.rotate(-Gdx.graphics.getDeltaTime()*90); if(input.isKeyPressed(Input.Keys.CONTROL_LEFT)) UPDATE_TIME+=Gdx.graphics.getDeltaTime(); if(input.isKeyPressed(Input.Keys.SHIFT_LEFT)) UPDATE_TIME-=Gdx.graphics.getDeltaTime(); if(input.isKeyPressed(Input.Keys.LEFT)) camera.translate(new Vector2(-Gdx.graphics.getDeltaTime()*50,0)); if(input.isKeyPressed(Input.Keys.RIGHT)) camera.translate(new Vector2(Gdx.graphics.getDeltaTime()*50,0)); if(input.isKeyPressed(Input.Keys.UP)) camera.translate(new Vector2(0,Gdx.graphics.getDeltaTime()*50)); if(input.isKeyPressed(Input.Keys.DOWN)) camera.translate(new Vector2(0,-Gdx.graphics.getDeltaTime()*50)); if(input.isKeyPressed(Input.Keys.SPACE)){//  UPDATE_TIME = 1f; camera = new OrthographicCamera(FIELD_SIZE, FIELD_SIZE); } camera.update(); if (input.isTouched()) {//    float stepX = Gdx.graphics.getWidth() / FIELD_SIZE; float stepY = Gdx.graphics.getHeight() / FIELD_SIZE; float x = input.getX(); float y = input.getY(); for (int i = 0; i < FIELD_SIZE; i++) for (int j = 0; j < FIELD_SIZE; j++) { if (x >= stepX * i && x <= stepX * (i + 1) && y >= stepY * j && y <= stepY * (j + 1)) if (map[i][FIELD_SIZE - j - 1] instanceof Empty) map[i][FIELD_SIZE - j - 1] = new Unit(texture, map, i, j); } } }

निष्कर्ष

मैं त्रुटियों के लिए अग्रिम में माफी चाहता हूं, और सामग्री की पूरी प्रस्तुति नहीं। गीथूब पर सूत्र।

अगर किसी को दिलचस्पी है, तो मैं एक अगली कड़ी लिखूंगा।

Libgdx का उपयोग करके एक शून्य प्लेयर गेम बनाना