Eksport projektu bez klasy main

Odpowiedz Nowy wątek
2015-10-25 10:34
De Wu
0

Witam. Napisałem grę Snake na podstawie tego poradnika

Wszystko działa pięknie w eclipsie, jednakże projekt ten nie posiada klasy main. Istnieje jakiś sposób na eksport projektu do wykonywalnego pliku jar?

Pozostało 580 znaków

2015-10-25 10:37
0

Oczywiście, żaden projekt (program) nie wymaga klasy Main.
W Eclipse File => Export => Runnable Jar file.


To smutne, że głupcy są tak pewni siebie, a ludzie mądrzy - tak pełni wątpliwości. Bertrand Russell
edytowany 1x, ostatnio: bogdans, 2015-10-25 10:39

Pozostało 580 znaków

2015-10-25 10:48
De Wu
0

No tak, ale po wybraniu Runnable JAR file w Launch configuration nie ma mojego projektu. Są tylko te, które posiadają klasę main

Pozostało 580 znaków

2015-10-25 10:56
1

Mylisz klasę Main z metodą main. Opisany w poradniku program to jest aplet. Aplety uruchamia się inaczej: za pośrednictwem przeglądarki lub programu appletviewer. Dla obu sposobów musisz stworzyć plik HTML. Najprościej podejrzeć jaki HTML tworzy Eclipse w czasie działania programu i skopiować go. W Eclipse tworzysz wtedy "zwyczajny" Jar file.


To smutne, że głupcy są tak pewni siebie, a ludzie mądrzy - tak pełni wątpliwości. Bertrand Russell

Pozostało 580 znaków

2015-10-25 11:07
De Wu
0

Faktycznie, mój błąd. A jest możliwość prostego przerobienia tego appletu na aplikację?

Pozostało 580 znaków

2015-10-25 11:35
0

Tak, tu Wyznacznik macierzy masz opis.


To smutne, że głupcy są tak pewni siebie, a ludzie mądrzy - tak pełni wątpliwości. Bertrand Russell

Pozostało 580 znaków

2015-10-25 12:02
De Wu
0

Jestem w trakcie ale napotkałem problem. Posiadam jedną klasę snakeApplet która dziedziczyła Applet i dokonałem tam opisanych zmian. Ale 'główną' klasą w projekcie jest snakeCanvas, która dziedziczy Canvas i tam już się pogubiłem. Metoda foomainfoo powinna znajdować się w obu tych klasach?

Pozostało 580 znaków

2015-10-25 12:07
0

Dodam, że w klasie snakeCanvas nie ma init() więc nie wiem którą część kodu należy zmienić


import java.awt.Canvas;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Image;
import java.awt.Point;
import java.awt.Toolkit;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.awt.image.BufferedImage;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.net.URL;
import java.util.LinkedList;
import java.util.Random;

public class snakeCanvas extends Canvas implements Runnable, KeyListener
{   

    private final int BOX_HEIGHT =15;
    private final int BOX_WIDTH = 15;
    private final int GRID_WIDTH = 25;
    private final int GRID_HEIGHT = 25;

    private LinkedList<Point> snake;
    private Point fruit;
    private int direction = Direction.NO_DIRECTION;

    private Thread runThread;
    private int score = 0;
    private String highScore = "";
    private Image menuImage = null;
    private boolean isInMenu = true;
    private boolean isAtEndGame = false;
    private boolean won = false;

    public void paint(Graphics g)
    {       
        if (runThread == null)
        {           
            this.setPreferredSize(new Dimension(640, 480));     
            this.addKeyListener(this);
            runThread = new Thread(this);
            runThread.start();
        }
        if (isInMenu)
        {
            DrawMenu(g);
        }
        else if(isAtEndGame)
        {
            DrawEndGame(g);
        }
        else
        {
            if (snake == null)
            {
                snake = new LinkedList<Point>();
                GenerateDefaultSnake();
                PlaceFruit();
            }   
            if (highScore.equals(""))
            {
                highScore = this.GetHighScore();
            }
            DrawFruit(g);
            DrawGrid(g);
            DrawSnake(g);
            DrawScore(g);
        }
    }

    public void DrawEndGame(Graphics g)
    {
        BufferedImage endGameImage = new BufferedImage(this.getPreferredSize().width, this.getPreferredSize().height, BufferedImage.TYPE_INT_ARGB);
        Graphics endGameGraphics = endGameImage.getGraphics();
        endGameGraphics.setColor(Color.BLACK);

        if (won)
        {
            endGameGraphics.drawString("Wygrałeś!", this.getPreferredSize().width / 2, this.getPreferredSize().height / 2);
        }
        else
            endGameGraphics.drawString("Przegrałeś", this.getPreferredSize().width / 2, this.getPreferredSize().height / 2);

        endGameGraphics.drawString("Twój wynik to: " + this.score, this.getPreferredSize().width / 2, (this.getPreferredSize().height / 2) + 20);
        endGameGraphics.drawString("Wciśnij spację aby rozpocząc nową grę", this.getPreferredSize().width / 2, (this.getPreferredSize().height / 2) + 40);

        g.drawImage(endGameImage, 0, 0, this);
    }

    public void DrawMenu (Graphics g)
    {
        if(this.menuImage == null)
        {

            try
            {
                URL imagePath = snakeCanvas.class.getResource("snakemenu.png");
                this.menuImage = Toolkit.getDefaultToolkit().getImage(imagePath);
            }
            catch (Exception e)
            {
                e.printStackTrace();
            }}
        g.drawImage(menuImage, 0, 0, 640, 480, this);

    }

    public void update(Graphics g)
    {
        Graphics offScreenGraphics;
        BufferedImage offscreen = null;
        Dimension d = this.getSize();

        offscreen = new BufferedImage(d.width, d.height, BufferedImage.TYPE_INT_ARGB);
        offScreenGraphics = offscreen.getGraphics();
        offScreenGraphics.setColor(this.getBackground());
        offScreenGraphics.fillRect(0, 0, d.width, d.height);
        offScreenGraphics.setColor(this.getForeground());
        paint(offScreenGraphics);

        g.drawImage(offscreen, 0, 0, this);     
    }

    public void GenerateDefaultSnake()
    {
        score = 0;
        snake.clear();

        snake.add(new Point(2,0));
        snake.add(new Point(1,0));
        snake.add(new Point(0,0));
        direction = Direction.NO_DIRECTION;
    }

    public void Move()
    {
        if (direction == Direction.NO_DIRECTION)
            return;

        Point head = snake.peekFirst();
        Point newPoint = head;
        switch (direction)
        {
        case Direction.NORTH:
            newPoint = new Point(head.x, head.y -1);
            break;
        case Direction.SOUTH:
            newPoint = new Point(head.x, head.y + 1);
            break;
        case Direction.WEST:
            newPoint = new Point(head.x -1, head.y);
            break;
        case Direction.EAST:
            newPoint = new Point(head.x +1, head.y);
            break;
        }

        if (this.direction != Direction.NO_DIRECTION)
            snake.remove(snake.peekLast());

        if (newPoint.equals(fruit))
        {
            // waz zjadl owoc
            score+=10;

            Point addPoint = (Point) newPoint.clone();

            switch (direction)
            {
            case Direction.NORTH:
                newPoint = new Point(head.x, head.y -1);
                break;
            case Direction.SOUTH:
                newPoint = new Point(head.x, head.y + 1);
                break;
            case Direction.WEST:
                newPoint = new Point(head.x -1, head.y);
                break;
            case Direction.EAST:
                newPoint = new Point(head.x +1, head.y);
                break;
            }

            snake.push(addPoint);
            PlaceFruit();

        }
        else if (newPoint.x < 0 || newPoint.x > GRID_WIDTH - 1)
        {
            // waz wyszedl poza plansze
            CheckScore();
            won = false;
            isAtEndGame = true;
            return;

        }
        else if (newPoint.y < 0 || newPoint.y > GRID_HEIGHT - 1)
        {
            // waz wyszedl poza plansze
            CheckScore();
            won = false;
            isAtEndGame = true;
            return;
        }
        else if (snake.contains(newPoint))
        {
            // waz zjadl siebie
            if (direction != Direction.NO_DIRECTION)
            {
                CheckScore();
                won = false;
                isAtEndGame = true;
                return;
            }           
        }
        else if (snake.size() == (GRID_WIDTH * GRID_HEIGHT))
        {
            //wygralismy
            CheckScore();
            won = true;
            isAtEndGame = true;
            return;
        }

        snake.push(newPoint);
    }

    public void DrawScore(Graphics g)
    {
        g.drawString("Score: " + score, 0, BOX_HEIGHT * GRID_HEIGHT + 15);
        g.drawString("Highscore: " + highScore, 0, BOX_HEIGHT * GRID_HEIGHT + 30);
    }

    public void CheckScore()
    {       
        if (highScore.equals(""))
            return;
        if (score > Integer.parseInt((highScore.split(":")[1])))
        {
            String name = JOptionPane.showInputDialog("Ustanowiłeś nowy rekord! Podaj swoje imię"); 
            highScore = name + ":" + score;

            File scoreFile = new File("highscore.dat");
            if (!scoreFile.exists())
            {
                try {
                    scoreFile.createNewFile();
                } 
                catch (IOException e) 
                {

                    e.printStackTrace();
                }
            }
            FileWriter writeFile = null;
            BufferedWriter writer = null;
            try
            {
                writeFile = new FileWriter(scoreFile);
                writer = new BufferedWriter(writeFile);
                writer.write(this.highScore);
            }
            catch (Exception e)
            {

            }
            finally
            {
                try
                {
                    if (writer != null)
                        writer.close();
                }
                catch (Exception e){}
            }
        }
    }

    public void DrawGrid(Graphics g)
    {
        // rysowanie zewnetrznych linii
        g.drawRect(0, 0, GRID_WIDTH * BOX_WIDTH,GRID_HEIGHT * BOX_HEIGHT);

        // rysowanie pionowych linii
        for (int x = BOX_WIDTH; x < GRID_WIDTH * BOX_WIDTH; x+=BOX_WIDTH)
        {
            g.drawLine(x, 0, x,  BOX_HEIGHT * GRID_HEIGHT);
        }

        // rysowanie poziomych linii
        for (int y = BOX_HEIGHT; y < GRID_HEIGHT * BOX_HEIGHT; y+=BOX_HEIGHT)
        {
            g.drawLine(0,  y,  GRID_WIDTH * BOX_WIDTH,  y);
        }
    }
    public void DrawSnake(Graphics g)
    {
        g.setColor(Color.GREEN);
        for (Point p : snake)
        {
            g.fillRect(p.x * BOX_WIDTH, p.y * BOX_HEIGHT, BOX_WIDTH, BOX_HEIGHT);
        }
        g.setColor(Color.BLACK);
    }
    public void DrawFruit(Graphics g)
    {
        g.setColor(Color.RED);
        g.fillOval(fruit.x * BOX_WIDTH, fruit.y * BOX_HEIGHT, BOX_WIDTH, BOX_HEIGHT);
        g.setColor(Color.BLACK);
    }

    public void PlaceFruit()
    {
        Random rand = new Random();
        int randomX = rand.nextInt(GRID_WIDTH);
        int randomY = rand.nextInt(GRID_HEIGHT);
        Point randomPoint = new Point(randomX, randomY);

        while (snake.contains(randomPoint))
        {
            randomX = rand.nextInt(GRID_WIDTH);
            randomY = rand.nextInt(GRID_HEIGHT);
            randomPoint = new Point(randomX, randomY);

        }
        fruit = randomPoint;
    }

    @Override
    public void run() {
        while (true)
        {
            repaint();
            if(!isInMenu && !isAtEndGame)
                Move();
            try
            {
                Thread.currentThread();
                Thread.sleep(120);
            }
            catch (Exception e)
            {
                e.printStackTrace();
            }
        }
    }

    public String GetHighScore()
    {
        FileReader readFile = null;
        BufferedReader reader = null;
        try
        {
            readFile = new FileReader("highscore.dat");
            reader = new BufferedReader(readFile);
            return reader.readLine();
        }
        catch (Exception e)
        {
            return "Nobody:0";
        }
        finally
        {
            try
            {               
                if (reader != null)
                    reader.close();
            }
            catch (IOException e)
            {
                e.printStackTrace();
            }
        }
    }

    @Override
    public void keyTyped(KeyEvent arg0) {}

    @Override
    public void keyPressed(KeyEvent e) {
        switch (e.getKeyCode())
        {
        case KeyEvent.VK_UP:
            if (direction != Direction.SOUTH)
                direction = Direction.NORTH;
            break;
        case KeyEvent.VK_DOWN:
            if (direction != Direction.NORTH)
                direction = Direction.SOUTH;
            break;
        case KeyEvent.VK_RIGHT:
            if (direction != Direction.WEST)
                direction = Direction.EAST;
            break;
        case KeyEvent.VK_LEFT:
            if (direction != Direction.EAST)
                direction = Direction.WEST;
            break;  
        case KeyEvent.VK_ENTER:
            if (isInMenu)
            {
                isInMenu = false;
                repaint();
            }
            break;
        case KeyEvent.VK_ESCAPE:
            isInMenu = true;
            break;
        case KeyEvent.VK_SPACE:
            if (isAtEndGame)
            {
                isAtEndGame = false;
                won = false;
                GenerateDefaultSnake();
                repaint();
            }
            break;
        }
    }

    @Override
    public void keyReleased(KeyEvent arg0) {}

}
edytowany 3x, ostatnio: bogdans, 2015-10-25 16:41

Pozostało 580 znaków

2015-10-25 16:44
0

W tej klasie niczego nie musisz zmieniać.


To smutne, że głupcy są tak pewni siebie, a ludzie mądrzy - tak pełni wątpliwości. Bertrand Russell

Pozostało 580 znaków

Odpowiedz
Liczba odpowiedzi na stronę

1 użytkowników online, w tym zalogowanych: 0, gości: 1, botów: 0