Нетбинс - игры

package swing.life;
 
import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Insets;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.util.Arrays;
 
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JSlider;
import javax.swing.JToolBar;
import javax.swing.SwingUtilities;
import javax.swing.UIManager;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;
 
/**
 * Модель данных "Жизни". Поле завернуто в тороид, т.е. и левый и правый края, и
 * верхний и нижний, являются замкнутыми. При симуляции используется принцип
 * двойной буферизации: данные берутся из главного массива mainField, после
 * расчета результат складывается во вспомогательный массив backField. По
 * окончании расчета одного шага ссылки на эти массивы меняются местами. В
 * массивах хранятся значения: 0, если клетка мертва, и 1, если жива.
 */
class LifeModel {
 
    private byte[] mainField = null;
    private byte[] backField = null;
 
    private int width, height;
    private int[] neighborOffsets = null;
    private int[][] neighborXYOffsets = null;
 
    /**
     * Инициализация модели.
     * 
     * @param width
     *            ширина поля данных
     * @param height
     *            высота поля данных
     */
    public LifeModel(int width, int height) {
        this.width = width;
        this.height = height;
        mainField = new byte[width * height];
        backField = new byte[width * height];
        neighborOffsets = new int[] { -width - 1, -width, -width + 1, -1, 1, width - 1, width, width + 1 };
        neighborXYOffsets = new int[][] { { -1, -1 }, { 0, -1 }, { 1, -1 }, { -1, 0 }, { 1, 0 }, { -1, 1 }, { 0, 1 },
                { 1, 1 } };
    }
 
    public int getWidth() {
        return width;
    }
 
    public int getHeight() {
        return height;
    }
 
    public void clear() {
        Arrays.fill(mainField, (byte) 0);
    }
 
    public void setCell(int x, int y, byte c) {
        mainField[y * width + x] = c;
    }
 
    public byte getCell(int x, int y) {
        return mainField[y * width + x];
    }
 
    /**
     * Один шаг симуляции.
     */
    public void simulate() {
        // обрабатываем клетки, не касающиеся краев поля
        for (int y = 1; y < height - 1; y++) {
            for (int x = 1; x < width - 1; x++) {
                int j = y * width + x;
                byte n = countNeighbors(j);
                backField[j] = simulateCell(mainField[j], n);
            }
        }
 
        // обрабатываем граничные клетки
        // верхняя и нижняя строки
        for (int x = 0; x < width; x++) {
            int j = width * (height - 1);
            byte n = countBorderNeighbors(x, 0);
            backField[x] = simulateCell(mainField[x], n);
            n = countBorderNeighbors(x, height - 1);
            backField[x + j] = simulateCell(mainField[x + j], n);
        }
        // крайние левый и правый столбцы
        for (int y = 1; y < height - 1; y++) {
            int j = width * y;
            byte n = countBorderNeighbors(0, y);
            backField[j] = simulateCell(mainField[j], n);
            n = countBorderNeighbors(width - 1, y);
            backField[j + width - 1] = simulateCell(mainField[j + width - 1], n);
        }
 
        // обмениваем поля местами
        byte[] t = mainField;
        mainField = backField;
        backField = t;
    }
 
    /**
     * Подсчет соседей для не касающихся краев клеток.
     * 
     * @param j
     *            смещение клетки в массиве
     * @return кол-во соседей
     */
    private byte countNeighbors(int j) {
        byte n = 0;
        for (int i = 0; i < 8; i++) {
            n += mainField[j + neighborOffsets[i]];
        }
        return n;
    }
 
    /**
     * Подсчет соседей для граничных клеток.
     * 
     * @param x
     * @param y
     * @return кол-во соседей
     */
    private byte countBorderNeighbors(int x, int y) {
        byte n = 0;
        for (int i = 0; i < 8; i++) {
            int bx = (x + neighborXYOffsets[i][0] + width) % width;
            int by = (y + neighborXYOffsets[i][1] + height) % height;
            n += mainField[by * width + bx];
        }
        return n;
    }
 
    /**
     * Симуляция для одной клетки.
     * 
     * @param self
     *            собственное состояние клетки: 0/1
     * @param neighbors
     *            кол-во соседей
     * @return новое состояние клетки: 0/1
     */
    private byte simulateCell(byte self, byte neighbors) {
        return (byte) (self == 0 ? (neighbors == 3 ? 1 : 0) : neighbors == 2 || neighbors == 3 ? 1 : 0);
    }
}
 
/**
 * Панель симулятора с редактором поля. Левой кнопкой мыши можно ставить клетки,
 * правой - стирать. Редактирование доступно в любое время, даже когда симуляция
 * запущена. Процесс симуляции выполняется в отдельном потоке.
 */
class LifePanel extends JPanel implements Runnable {
 
    private static final long serialVersionUID = -7705111475296001684L;
 
    private Thread simThread = null;
    private LifeModel life = null;
    /**
     * Задержка в мс между шагами симуляции.
     */
    private int updateDelay = 100;
    /**
     * Размер клетки на экране.
     */
    private int cellSize = 8;
    /**
     * Промежуток между клетками.
     */
    private int cellGap = 1;
    /**
     * Цвет мертвой клетки.
     */
    private static final Color c0 = new Color(0x505050);
    /**
     * Цвет живой клетки.
     */
    private static final Color c1 = new Color(0xFFFFFF);
 
    public LifePanel() {
        setBackground(Color.BLACK);
 
        // редактор поля
        MouseAdapter ma = new MouseAdapter() {
            private boolean pressedLeft = false; // нажата левая кнопка мыши
            private boolean pressedRight = false; // нажата правая кнопка мыши
 
            @Override
            public void mouseDragged(MouseEvent e) {
                setCell(e);
            }
 
            @Override
            public void mousePressed(MouseEvent e) {
                if (e.getButton() == MouseEvent.BUTTON1) {
                    pressedLeft = true;
                    pressedRight = false;
                    setCell(e);
                } else if (e.getButton() == MouseEvent.BUTTON3) {
                    pressedLeft = false;
                    pressedRight = true;
                    setCell(e);
                }
            }
 
            @Override
            public void mouseReleased(MouseEvent e) {
                if (e.getButton() == MouseEvent.BUTTON1) {
                    pressedLeft = false;
                } else if (e.getButton() == MouseEvent.BUTTON3) {
                    pressedRight = false;
                }
            }
 
            /**
             * Устанавливает/стирает клетку.
             * 
             * @param e
             */
            private void setCell(MouseEvent e) {
                if (life != null) {
                    synchronized (life) {
                        // рассчитываем координаты клетки, на которую указывает
                        // курсор мыши
                        int x = e.getX() / (cellSize + cellGap);
                        int y = e.getY() / (cellSize + cellGap);
                        if (x >= 0 && y >= 0 && x < life.getWidth() && y < life.getHeight()) {
                            if (pressedLeft == true) {
                                life.setCell(x, y, (byte) 1);
                                repaint();
                            }
                            if (pressedRight == true) {
                                life.setCell(x, y, (byte) 0);
                                repaint();
                            }
                        }
                    }
                }
            }
        };
        addMouseListener(ma);
        addMouseMotionListener(ma);
    }
 
    public LifeModel getLifeModel() {
        return life;
    }
 
    public void initialize(int width, int height) {
        life = new LifeModel(width, height);
    }
 
    public void setUpdateDelay(int updateDelay) {
        this.updateDelay = updateDelay;
    }
 
    /**
     * Запуск симуляции.
     */
    public void startSimulation() {
        if (simThread == null) {
            simThread = new Thread(this);
            simThread.start();
        }
    }
 
    /**
     * Остановка симуляции.
     */
    public void stopSimulation() {
        simThread = null;
    }
 
    public boolean isSimulating() {
        return simThread != null;
    }
 
    @Override
    public void run() {
        repaint();
        while (simThread != null) {
            try {
                Thread.sleep(updateDelay);
            } catch (InterruptedException e) {
            }
            // синхронизация используется для того, чтобы метод paintComponent
            // не выводил на экран
            // содержимое поля, которое в данный момент меняется
            synchronized (life) {
                life.simulate();
            }
            repaint();
        }
        repaint();
    }
 
    /*
     * Возвращает размер панели с учетом размера поля и клеток.
     */
    @Override
    public Dimension getPreferredSize() {
        if (life != null) {
            Insets b = getInsets();
            return new Dimension((cellSize + cellGap) * life.getWidth() + cellGap + b.left + b.right,
                    (cellSize + cellGap) * life.getHeight() + cellGap + b.top + b.bottom);
        } else
            return new Dimension(100, 100);
    }
 
    /*
     * Прорисовка содержимого панели.
     */
    @Override
    protected void paintComponent(Graphics g) {
        if (life != null) {
            synchronized (life) {
                super.paintComponent(g);
                Insets b = getInsets();
                for (int y = 0; y < life.getHeight(); y++) {
                    for (int x = 0; x < life.getWidth(); x++) {
                        byte c = life.getCell(x, y);
                        g.setColor(c == 1 ? c1 : c0);
                        g.fillRect(b.left + cellGap + x * (cellSize + cellGap), b.top + cellGap + y
                                * (cellSize + cellGap), cellSize, cellSize);
                    }
                }
            }
        }
    }
 
}
 
public class LifeSim extends JFrame {
 
    private static final long serialVersionUID = 3400265056061021539L;
 
    private LifePanel lifePanel = null;
    private JButton button1 = null;
    private JButton button2 = null;
    private JSlider slider = null;
 
    public LifeSim(String title) {
        super(title);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setResizable(false);
        lifePanel = new LifePanel();
        // размеры поля
        lifePanel.initialize(100, 70);
        add(lifePanel);
 
        JToolBar toolBar = new JToolBar();
        toolBar.setFloatable(false);
        add(toolBar, BorderLayout.NORTH);
 
        button1 = new JButton("Запустить");
        toolBar.add(button1);
        button2 = new JButton("Очистить поле");
        toolBar.add(button2);
 
        // бегунок, регулирующий скорость симуляции (задержка в мс между шагами
        // симуляции)
        slider = new JSlider(1, 200);
        slider.setValue(50);
        lifePanel.setUpdateDelay(slider.getValue());
        slider.addChangeListener(new ChangeListener() {
            @Override
            public void stateChanged(ChangeEvent e) {
                lifePanel.setUpdateDelay(slider.getValue());
            }
        });
 
        toolBar.addSeparator();
        toolBar.add(new JLabel(" Быстро"));
        toolBar.add(slider);
        toolBar.add(new JLabel("Медленно"));
 
        // запуск/остановка симуляции; попутно меняется надпись на кнопке
        button1.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                if (lifePanel.isSimulating()) {
                    lifePanel.stopSimulation();
                    button1.setText("Запустить");
                } else {
                    lifePanel.startSimulation();
                    button1.setText("Остановить");
                }
            }
        });
        // очистка поля
        button2.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                synchronized (lifePanel.getLifeModel()) {
                    lifePanel.getLifeModel().clear();
                    lifePanel.repaint();
                }
            }
        });
        button1.setMaximumSize(new Dimension(100, 50));
        button2.setMaximumSize(new Dimension(100, 50));
        slider.setMaximumSize(new Dimension(300, 50));
        pack();
        setVisible(true);
    }
 
    public static void main(String... args) {
        try {
            UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
        } catch (Exception e) {
        }
 
        SwingUtilities.invokeLater(new Runnable() {
            public void run() {
                new LifeSim("LifeSim");
            }
        });
    }
 
}