यह मेरा पहला सवाल है और अगर इसे पहले से नहीं रखा गया है तो मैं क्षमा चाहता हूं।

इसलिए, मैं फल बनाने की कोशिश कर रहा हूं (मैं उन्हें कोड में सेब भी कहता हूं) एक ऐसी स्थिति में स्पॉन करता हूं जो कि शीर्षक के अनुसार सांप के शरीर से अलग है। समस्या यह है कि मुझे नहीं पता कि नए फल के निर्देशांक सांप के शरीर के प्रत्येक अंग के बराबर नहीं हैं या नहीं।

public void newApple() {
    tempX = random.nextInt(width/unitSize)*unitSize;
    tempY = random.nextInt(height/unitSize)*unitSize;

    for (int i = 0; i < bodyParts; i++) {
        if (tempX != x[i] && tempY != y[i]){    
            appleX = tempX;
            appleY = tempY;
        }
        else {
            newApple();
        }
    }
}

यह वही है जो मैंने अब तक पाया है: मैं 2 अस्थायी चर का उपयोग कर रहा हूं जो फ्रेम में एक यादृच्छिक स्थिति के अनुरूप होंगे और फिर मैं जांचना चाहता हूं कि क्या वे सांप की प्रत्येक स्थिति के बराबर नहीं हैं। लूप के अंदर अगर स्थिति सिर्फ x [0] और y [0] की जांच करती है जो मेरे सांप के सिर के निर्देशांक हैं।

सेब को खींचने के लिए paintComponent() विधि के अंदर यही है।

//drawing apple
if (appleX != null && appleY != null) {
    g.setColor(Color.red);
    g.fillOval(appleX, appleY, unitSize, unitSize);
}

यदि आपको इसकी आवश्यकता हो तो नीचे परियोजना के मेरे पूरे 2 वर्ग हैं।

public class Main {
    public static void main(String[] args) {
        SwingUtilities.invokeLater(new Runnable() {
            @Override
            public void run() {
                createGame();
            }
        });
    }

    public static void createGame() {
        JFrame frame = new JFrame();
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setResizable(false);
        frame.add(new MyPanel());
        frame.pack();
        frame.setLocationRelativeTo(null);
        frame.setVisible(true);
    }
}

public class MyPanel extends JPanel implements ActionListener {
    final int width = 600;
    final int height = 600;
    final int unitSize = 25;
    final int maxNumberOfUnits = (width*height)/(unitSize*unitSize);
    int[] x = new int[maxNumberOfUnits];
    int[] y = new int[maxNumberOfUnits];
    int bodyParts = 2;
    Integer appleX, appleY, tempX, tempY;
    int score = 0;
    char direction = 'R';
    boolean running;
    int delay = 175;
    Timer timer = new Timer(delay, this);
    Random random = new Random();
    Font font1 = new Font("Ink Free", Font.BOLD, 40);
    Font font2 = new Font("Ink Free", Font.BOLD, 75);

    public Dimension getPreferredSize() {
        return new Dimension(width, height);
    }

    MyPanel() {
        setBackground(new Color(16, 16, 16));
        setFocusable(true);
        timer.start();
        running = true;
        newApple();
        x[0] = 10*unitSize;
        y[0] = 10*unitSize;
        x[1] = 9*unitSize;
        y[1] = 10*unitSize;

        addKeyListener(new KeyAdapter() {
            @Override
            public void keyPressed(KeyEvent e) {
                switch (e.getKeyCode()) {
                    case 37:
                        if (direction !='R') {
                            direction = 'L';
                        }
                        break;
                    case 38:
                        if (direction !='D') {
                            direction = 'U';
                        }
                        break;
                    case 39:
                        if (direction !='L') {
                            direction = 'R';
                        }
                        break;
                    case 40:
                        if (direction !='U') {
                            direction = 'D';
                        }
                        break;
                }
            }
        });
    }

    public void moveSnake() {
        for (int i = bodyParts; i > 0; i--) {
            x[i] = x[i-1];
            y[i] = y[i-1];
        }
        switch (direction) {
            case 'U':
                y[0] -= unitSize;
                break;
            case 'D':
                y[0] += unitSize;
                break;
            case 'L':
                x[0] -= unitSize;
                break;
            case 'R':
                x[0] += unitSize;
                break;
        }
    }

    public void newApple() {
        tempX = random.nextInt(width/unitSize)*unitSize;
        tempY = random.nextInt(height/unitSize)*unitSize;

        for (int i = 0; i < bodyParts; i++) {
            if (tempX != x[i] && tempY != y[i]){
                appleX = tempX;
                appleY = tempY;
            }
            else {
                newApple();
            }
        }
    }

    public void paintComponent(Graphics g) {
        super.paintComponent(g);

        if (running) {
            /*
                //drawing a matrix
                for (int i = 1; i < height/unitSize; i++) {
                    g.drawLine(0, i*unitSize, width, i*unitSize);
                }
                for (int i = 1; i < width/unitSize; i++) {
                    g.drawLine(i*unitSize, 0, i*unitSize, height);
                }
            */

            //drawing apple
            if (appleX != null && appleY != null) {
                g.setColor(Color.red);
                g.fillOval(appleX, appleY, unitSize, unitSize);
            }

            //drawing snake
            g.setColor(Color.green);
            for (int i = 0; i < bodyParts; i++) {
                g.fillRect(x[i], y[i], unitSize, unitSize);
            }

            //drawing score
            g.setColor(Color.red);
            g.setFont(font1);
            FontMetrics metrics1 = getFontMetrics(g.getFont());
            g.drawString("Score: " + score, (width-metrics1.stringWidth("Score: " + score))/2, g.getFont().getSize());
        }
        else {
            g.setColor(Color.red);
            g.setFont(font1);
            FontMetrics metrics1 = getFontMetrics(g.getFont());
            g.drawString("Score: " + score, (width-metrics1.stringWidth("Score: " + score))/2, g.getFont().getSize());

            g.setColor(Color.white);
            g.setFont(font2);
            FontMetrics metrics2 = getFontMetrics(g.getFont());
            g.drawString("Game Over", (width-metrics2.stringWidth("Game Over"))/2, height/2);
        }
    }

    public void checkApple() {
        if (x[0]==appleX && y[0]==appleY) {
            score++;
            bodyParts++;
            newApple();
        }
    }

    public void checkCollisions() {

        //body
        for (int i = bodyParts; i > 0; i--) {
            if (x[0] == x[i] && y[0] == y[i]) {
                running = false;
            }
        }
        if (x[0] < 0) {
            running = false;
        }
        if (x[0] > width) {
            running = false;
        }
        if (y[0] < 0) {
            running = false;
        }
        if (y[0] > height) {
            running = false;
        }
        if (!running) {
            timer.stop();
        }
    }

    @Override
    public void actionPerformed(ActionEvent e) {
        if (running) {
            checkApple();
            moveSnake();
            checkCollisions();
        }
        repaint();
    }
}
0
Davide _- 19 फरवरी 2021, 14:39

5 जवाब

सबसे बढ़िया उत्तर

आपको पुनरावर्ती कॉल की आवश्यकता नहीं है। विधि newApple() स्वयं को कॉल नहीं करना चाहिए। आपको एक लूप चाहिए।

  1. tempX और tempY के लिए मान जेनरेट करें।
  2. साँप के प्रत्येक भाग के लिए जाँच करें कि क्या tempX, साँप के शरीर के अंग x[i] के बराबर है और tempY y[i] के बराबर है।
  3. अगर सांप के शरीर का कम से कम एक हिस्सा निर्देशांक tempX और tempY के बराबर है, तो ऊपर चरण 1 पर वापस जाएं।
  4. यदि सांप के शरीर के अंगों में से कोई भी निर्देशांक के बराबर नहीं है, तो उत्पन्न निर्देशांक को "सेब" को असाइन करें।

यह विधि है newApple()

public void newApple() {
    boolean ok = false;
    while (!ok) {
        ok = true;
        tempX = random.nextInt(width/unitSize)*unitSize;
        tempY = random.nextInt(height/unitSize)*unitSize;
        for (int i = 0; i < bodyParts; i++) {
            if (tempX == x[i] && tempY == y[i]) {
                ok = false;
                break;
            }
        }
        if (ok) {
            appleX = tempX;
            appleY = tempY;
        }
    }
}
0
Abra 19 फरवरी 2021, 15:10

मुझे लगता है कि आपके पास सांपों के शरीर के अंगों के सभी स्थानों की एक सरणी होनी चाहिए क्योंकि शरीर का कोई भी हिस्सा टक्कर कर सकता है (जैसे कि सांप टकराता है तो खेल खत्म हो जाता है)।

आप फ्रूट रिस्पना के लिए उसी ऐरे का उपयोग कर सकते हैं, यह सुनिश्चित करने के लिए कि यह ऐरे में नहीं है।

0
Mohit 19 फरवरी 2021, 14:55

समस्या यह है कि आप केवल यह जांचते हैं कि सेब पहले शरीर के अंगों के सूचकांक में है या नहीं। सेब को रखा जा सकता है या नहीं, यह जांचने से पहले आपको लूप के लिए पूरा करना होगा।

boolean applePlacementOk = true;
while(true){
    applePlacementOk = true;
    tempX = random.nextInt(width/unitSize)*unitSize;
    tempY = random.nextInt(height/unitSize)*unitSize;
    for (int i = 0; i < bodyParts; i++) {
        if (tempX == x[i] && tempY == y[i]){    
            applePlacementOk = false;
            break;
        }
    }
    if(applePlacementOk){
       break;
    }
}
appleX = tempX;
appleY = tempY;

संपादित करें: एसओ के बारे में खेद है। यह बेहतर काम करना चाहिए

संपादित 2: मैंने देखा कि यह अनिवार्य रूप से अबरा के समान उत्तर है।

0
reden 19 फरवरी 2021, 15:24

अगर मैं आपके जूते में होता, तो मैं पुनरावृत्ति से बचने की कोशिश करता और यह गणना करने के लिए एक अलग फ़ंक्शन बनाता कि क्या कोई समन्वय सांप के शरीर से टकराता है।

एक बुनियादी विचार इस तरह होगा:

newApple()
- randomize a new coordinate x,y
- while overlapsWithSnake(x,y)
  - randomize a new coordinate x,y

overlapsWithSnake(x,y)
- iterate through all snake coordinates
  - if coordinate is the same, return true
- return false

अब, मुझे यह इंगित करने की आवश्यकता है कि एल्गोरिथ्म तब विचार नहीं करता है जब स्क्रीन में अधिक खाली स्थान नहीं होता है (खेल का अंत)।

इसके अतिरिक्त, जैसे-जैसे सांप का शरीर बढ़ता है, इस एल्गोरिथम को उपलब्ध निर्देशांक खोजने में अधिक से अधिक समय लगता है। इसे सुधारने के लिए आप जो कर सकते हैं वह निम्नलिखित है:

newApple()
- assign the result of getAvailableSpaces() to a list
- if the list is empty, then is game over
- else, randomize a number between 0 and list size - 1 as p
- select the coordinate at position p of the list

getAvailableSpaces()
- create logic to return a list of all free coordinates
0
Leonardo Kasperavičius 19 फरवरी 2021, 15:13

आपको यह सत्यापित करना चाहिए कि क्या tempX और tempY, x और y arrays के मानों से मेल खाते हैं और newApple() को कॉल करते हैं, यदि वे ऐसा करते हैं और टूट जाते हैं सूचित करते रहना।

इसका मतलब है, कि यदि आप लूप के अंत तक पहुँचते हैं, तो कोई मिलान नहीं मिला। फिर आप सेब के x और y निर्देशांक सुरक्षित रूप से सेट कर सकते हैं:

public void newApple() {
    tempX = random.nextInt(width/unitSize)*unitSize;
    tempY = random.nextInt(height/unitSize)*unitSize;

    for (int i = 0; i < bodyParts; i++) {
        if (tempX == x[i] && tempY == y[i]){    
            newApple();
            break;
        }
        if ( i == bodyParts - 1 ) {
            appleX = tempX;
            appleY = tempY;    
        }
    }
}
0
TimonNetherlands 19 फरवरी 2021, 15:07