0

过去一周的搜索并没有为试图弄清楚如何做到这一点提供任何工作帮助。当用户按下退格键时，它会保存游戏。我设置它在顶部显示一个小框，上面写着“正在保存..”，我希望它在那里停留大约 2 秒钟。我可以在使用以下代码按下按钮时显示它：

if (key.save) {
    font = new Font(null, 0, 16);
    g.setFont(font);
    g.setColor(Color.DARK_GRAY);
    g.fillRect(getWidth() / 2 - 40, -1, 80, 35);
    g.setColor(Color.BLACK);
    g.drawRect(getWidth() / 2 - 40, -1, 80, 35);
    g.setColor(Color.white);
    g.drawString("Saving..", getWidth() / 2 - 30, 22);
}

但是这段代码不起作用，它甚至不会显示顶部的框：

if (key.save) {
    ActionListener action = new ActionListener() {
        public void actionPerformed(ActionEvent e) {
            Font font = new Font(null, 0, 16);
            g.setFont(font);
            g.setColor(Color.DARK_GRAY);
            g.fillRect(getWidth() / 2 - 40, -1, 80, 35);
            g.setColor(Color.BLACK);
            g.drawRect(getWidth() / 2 - 40, -1, 80, 35);
            g.setColor(Color.white);
            g.drawString("Saving..", getWidth() / 2 - 30, 22);
        }
    };

    timer = new Timer(0, action);
    timer.start();
}
4

3 回答 3

2

在此处输入图像描述

这是使用可随时间更新的可渲染工件列表的基本概念的示例。

基本思想是有一个中央绘制循环负责根据您要呈现的内容更新 UI 的当前状态。这意味着对 UI 的任何更改都必须经过这个中心循环。

这个例子只使用了 Swing，但这个概念应该很容易翻译。

import java.awt.BorderLayout;
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.Shape;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.geom.Ellipse2D;
import java.util.ArrayList;
import java.util.List;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.Timer;
import javax.swing.UIManager;
import javax.swing.UnsupportedLookAndFeelException;

public class QuickPaint01 {

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

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

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

    public class TestPane extends JPanel implements Environment {

        private List<Drawable> drawables;

        public TestPane() {
            drawables = new ArrayList<>(25);
            Timer update = new Timer(40, new ActionListener() {
                @Override
                public void actionPerformed(ActionEvent e) {
                    Drawable[] draws = drawables.toArray(new Drawable[drawables.size()]);
                    for (Drawable drawable : draws) {
                        if (drawable instanceof Moveable) {
                            ((Moveable)drawable).update(TestPane.this);
                        }
                    }
                    repaint();
                }
            });
            update.setCoalesce(true);
            update.setRepeats(true);
            update.start();
            drawables.add(new Ball());
        }

        @Override
        public void add(Drawable drawable) {
            drawables.add(drawable);
        }

        @Override
        public void remove(Drawable drawable) {
            drawables.remove(drawable);
        }

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

        @Override
        protected void paintComponent(Graphics g) {
            super.paintComponent(g);
            Graphics2D g2d = (Graphics2D) g.create();
            for (Drawable drawable : drawables) {
                drawable.draw(this, g2d);
            }
            g2d.dispose();
        }
    }

    public interface Environment {

        public Dimension getSize();
        public void add(Drawable drawable);
        public void remove(Drawable drawable);

    }

    public interface Drawable {

        public void draw(Environment env, Graphics2D g);

    }

    public interface Moveable extends Drawable {

        public void update(Environment env);

    }

    public class Ball implements Moveable {

        private int radius = 20;

        private int x = 0;
        private int y = 0;

        private int xDelta = 4;

        private Shape shape;

        public Ball() {
            shape = new Ellipse2D.Float(0, 0, radius, radius);
        }

        @Override
        public void update(Environment env) {
            x += xDelta;
            if (x + radius > env.getSize().width) {

                x = env.getSize().width - radius;
                xDelta *= -1;

                env.add(new Message(env, "<< Bounce", 1));

            } else if (x < 0) {

                x = 0;
                xDelta *= -1;

                env.add(new Message(env, "Bounce >> ", 1));

            }
            y = (env.getSize().height - radius) / 2;
        }

        @Override
        public void draw(Environment env, Graphics2D g) {
            Graphics2D g2d = (Graphics2D) g.create();
            g2d.translate(x, y);
            g2d.setColor(Color.BLUE);
            g2d.fill(shape);
            g2d.dispose();
        }

    }

    public class Message implements Drawable {

        private Environment environment;
        private String message;
        private int delay;

        public Message(Environment environment, String message, int delay) {
            this.environment = environment;
            this.message = message;
            this.delay = delay;

            Timer timer = new Timer(delay * 1000, new ActionListener() {
                @Override
                public void actionPerformed(ActionEvent e) {
                    Message.this.environment.remove(Message.this);
                }
            });
            timer.start();
        }

        @Override
        public void draw(Environment env, Graphics2D g) {
            Graphics2D g2d = (Graphics2D) g.create();
            g2d.setColor(Color.RED);
            FontMetrics fm = g2d.getFontMetrics();
            g2d.drawString(message, env.getSize().width - fm.stringWidth(message), 0 + fm.getAscent());
            g2d.dispose();
        }

    }

}
于 2013-07-10T05:06:36.470 回答
0

要在给定的时间段内执行任务，您可以执行以下操作：

ExecutorService service = Executors.newSingleThreadExecutor();
try {
    Runnable r = new Runnable() {
       @Override
       public void run() {
         // task
       }
    };

    Future<?> f = service.submit(r);

    f.get(2, TimeUnit.MINUTES);     // attempt the task for two minutes
} catch (Exception e) {
     //Handele Exception
} finally {
     service.shutdown();
}
于 2013-07-10T04:56:11.323 回答
0

用伪代码编写，您可以使用几个部分构建解决方案：

  • 引入一个字段，该字段saveMessageIsVisible设置为false
  • 内键处理方法
    • 克隆游戏状态
    • 启动一个新线程并保存状态
    • 在此线程结束时，设置saveMessageIsVisible为 true（并可选择执行无效屏幕）
    • 还启动一个持续时间为 2 秒的计时器，然后再次将该字段设置为 false。
  • 在绘画例程中检查该字段并绘制您的保存框。
于 2013-07-10T04:40:12.040 回答