Question

当您在框中单击时，它应该从指定的坐标在该框中创建一个圆。除非它已经存在然后将其删除。如何将currentx和currenty坐标放入填充椭圆？

public class Grid extends Applet{

boolean click;

public void init()
{
    click = false;
    addMouseListener(new MyMouseListener());
}

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

    g.drawRect(100, 100, 400, 400);
    //each box
    g.drawRect(100, 100, 100, 100);
    g.drawRect(200, 100, 100, 100);
    g.drawRect(300, 100, 100, 100);
    g.drawRect(400, 100, 100, 100);
    //2y
    g.drawRect(100, 200, 100, 100);
    g.drawRect(200, 200, 100, 100);
    g.drawRect(300, 200, 100, 100);
    g.drawRect(400, 200, 100, 100);
    //3y1x
    g.drawRect(100, 300, 100, 100);
    g.drawRect(200, 300, 100, 100);
    g.drawRect(300, 300, 100, 100);
    g.drawRect(400, 300, 100, 100);
    //4y1x
    g.drawRect(100, 400, 100, 100);
    g.drawRect(200, 400, 100, 100);
    g.drawRect(300, 400, 100, 100);
    g.drawRect(400, 400, 100, 100);


    if (click)
    {
        g.fillOval(currentx, currenty, 100, 100); // problem HERE
    }

}
private class MyMouseListener implements MouseListener
{       
         public void mouseClicked(MouseEvent e)
         {
             int nowx = e.getX();
             int nowy = e.getY();

             nowx = nowx / 100;
             String stringx = Integer.toString(nowx);
             stringx = stringx+"00";
             int currentx = Integer.parseInt(stringx);

             nowy = nowy /100;
             String stringy = Integer.toString(nowy);
             stringy = stringy+"00";
             int currenty = Integer.parseInt(stringy);

             click = true;
             repaint();
         }

    @Override
    public void mousePressed(MouseEvent e) {
        // TODO Auto-generated method stub

    }

    @Override
    public void mouseReleased(MouseEvent e) {
        // TODO Auto-generated method stub

    }

    @Override
    public void mouseEntered(MouseEvent e) {
        // TODO Auto-generated method stub

    }

    @Override
    public void mouseExited(MouseEvent e) {
        // TODO Auto-generated method stub

    }
}
}

Answer 1

你的主要问题是，在Swing / AWT中绘画是破坏性的，也就是说，每次调用paint方法时，都需要重新绘制组件的当前状态。

在这种情况下，你真正需要的是一些模拟游戏状态的方法，所以当调用paint时，你可以用一些有意义的方式重新绘制它。这是Model-View-Controller范例的基本概念，您可以将程序的职责分离到单独的层中。

问题就变成了，你如何从视图转换为模型？

基本思想是获取鼠标的当前x / y坐标并将其除以单元格大小。您还需要确保结果在预期范围内，因为您可以获得超出网格列/行的结果

import java.awt.Color;
import java.awt.Dimension;
import java.awt.EventQueue;
import java.awt.FontMetrics;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Point;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.UIManager;
import javax.swing.UnsupportedLookAndFeelException;

public class Test {

    public static void main(String[] args) {
        new Test();
    }

    public Test() {
        EventQueue.invokeLater(new Runnable() {
            @Override
            public void run() {
                try {
                    UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
                } catch (ClassNotFoundException | InstantiationException | IllegalAccessException | UnsupportedLookAndFeelException ex) {
                    ex.printStackTrace();
                }

                JFrame frame = new JFrame("Testing");
                frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
                frame.add(new TestPane());
                frame.pack();
                frame.setLocationRelativeTo(null);
                frame.setVisible(true);
            }
        });
    }

    public static class TestPane extends JPanel {

        protected static final int CELL_COUNT = 3;

        private int[][] board;
        private int[] cell;

        private boolean isX = true;

        public TestPane() {
            board = new int[CELL_COUNT][CELL_COUNT];

            addMouseListener(new MouseAdapter() {
                @Override
                public void mouseClicked(MouseEvent e) {
                    int[] cell = getCellAt(e.getPoint());
                    if (board[cell[0]][cell[1]] == 0) {
                        board[cell[0]][cell[1]] = isX ? 1 : 2;
                        isX = !isX;
                        repaint();
                    }
                }
            });

            addMouseMotionListener(new MouseAdapter() {
                @Override
                public void mouseMoved(MouseEvent e) {
                    cell = getCellAt(e.getPoint());
                    repaint();
                }
            });
        }

        protected int[] getCellAt(Point p) {
            Point offset = getOffset();
            int cellSize = getCellSize();

            int x = p.x - offset.x;
            int y = p.y - offset.y;

            int gridx = Math.min(Math.max(0, x / cellSize), CELL_COUNT - 1);
            int gridy = Math.min(Math.max(0, y / cellSize), CELL_COUNT - 1);

            return new int[]{gridx, gridy};
        }

        protected Point getOffset() {
            int cellSize = getCellSize();
            int x = (getWidth() - (cellSize * CELL_COUNT)) / 2;
            int y = (getHeight() - (cellSize * CELL_COUNT)) / 2;
            return new Point(x, y);
        }

        protected int getCellSize() {
            return Math.min(getWidth() / CELL_COUNT, getHeight() / CELL_COUNT) - 10;
        }

        @Override
        public Dimension getPreferredSize() {
            return new Dimension(200, 200);
        }

        @Override
        protected void paintComponent(Graphics g) {
            super.paintComponent(g);
            Graphics2D g2d = (Graphics2D) g.create();

            Point offset = getOffset();
            int cellSize = getCellSize();
            if (cell != null) {
                g2d.setColor(new Color(0, 0, 255, 128));
                g2d.fillRect(
                        offset.x + (cellSize * cell[0]),
                        offset.y + (cellSize * cell[1]),
                        cellSize,
                        cellSize);
            }

            g2d.setColor(Color.BLACK);

            FontMetrics fm = g2d.getFontMetrics();
            for (int col = 0; col < CELL_COUNT; col++) {
                for (int row = 0; row < CELL_COUNT; row++) {
                    int value = board[col][row];
                    int x = offset.x + (cellSize * col);
                    int y = offset.y + (cellSize * row);
                    String text = "";
                    switch (value) {
                        case 1:
                            text = "X";
                            break;
                        case 2:
                            text = "O";
                            break;
                    }
                    x = x + ((cellSize - fm.stringWidth(text)) / 2);
                    y = y + ((cellSize - fm.getHeight()) / 2) + fm.getAscent();
                    g2d.drawString(text, x, y);
                }
            }

            int x = offset.x;
            int y = offset.y;
            for (int col = 1; col < CELL_COUNT; col++) {
                x = offset.x + (col * cellSize);
                g2d.drawLine(x, y, x, y + (cellSize * CELL_COUNT));
            }
            x = offset.x;
            for (int row = 1; row < CELL_COUNT; row++) {
                y = offset.x + (row * cellSize);
                g2d.drawLine(x, y, x + (cellSize * CELL_COUNT), y);
            }
            g2d.dispose();
        }

    }

}

Answer 2

首先，如果要将数字截断为最接近的100，例如142变为100，你所要做的就是：

num = (num/100)*100;

这是因为当你划分2个整数时它会自动截断它，你可以将它再乘以得到数字。在这种情况下，我认为你想要的是创建一些字段变量和一些存取方法。在MouseListener类的顶部，您需要添加：

private int mouseX=0;
private int mouseY=0;

然后，为了能够从mouselistener类外部访问这些变量，您需要添加访问器方法：

public int getMouseX(){
    return mouseX;
}

在您的网格类中，您可以添加字段：

private MyMouseListener listener;

然后通过执行以下操作在init中初始化它：

listener = new MyMouseListener();
addMouseListener(listener);

然后你可以对mouseY做同样的事情，最后从你的paint方法中你可以调用：

int mouseX = listener.getMouseX();
int mouseY = listener.getMouseY();

从那里开始就像执行if statements或switch statements一样简单，找到您点击的框！

在油漆中协调

2 个答案: