Java-太极

App.java

import java.awt.Canvas;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Point;
import java.awt.RenderingHints;
import java.awt.geom.AffineTransform;
import java.awt.image.BufferStrategy;
import javax.swing.JFrame;

public class App extends JFrame {
    private static final long serialVersionUID = 1L;
    TaiJiCanvas taijiCanvas;

    public App() {
        final int width = 800;

        this.setSize(width, width / 16 * 9);
        this.setTitle("Tai Ji");
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        this.setLocationRelativeTo(null);
        this.setVisible(true);
        
        this.taijiCanvas = new TaiJiCanvas(this.getSize());
        this.add(taijiCanvas);
        this.taijiCanvas.createBufferStrategy(2);
    }

    public static void main(String[] args) {
        App app = new App();

        boolean running = true;
        while (running) {
            app.render();
        }
    }

    void render() {
        this.taijiCanvas.render();
    }
}

class TaiJiCanvas extends Canvas {
    private static final long serialVersionUID = 1L;
    private static final float Speed = 0.5f;

    long lastTick = System.currentTimeMillis();
    float angle = 0.0f;

	public TaiJiCanvas(Dimension size) {
        this.setSize(size);
        this.setBackground(Color.DARK_GRAY);
        this.setVisible(true);
        this.setFocusable(false);
    }

    public void render() {
        BufferStrategy bufferStrategy = this.getBufferStrategy();
        Graphics graphics = bufferStrategy.getDrawGraphics();
        Graphics2D g2d = (Graphics2D)graphics;
        g2d.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
        g2d.setRenderingHint(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY);
        g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
        g2d.clearRect(0, 0, this.getSize().width, this.getSize().height);
        
        updateLogic();
        draw(g2d);

        bufferStrategy.show();
        graphics.dispose();
    }

    private void updateLogic() {
        long currentTick = System.currentTimeMillis();
        float dt = (float)(currentTick - lastTick) / 1000.0f * Speed;
        lastTick = currentTick;

        angle = (angle + dt * Speed * (float)Math.PI * 2) % ((float)Math.PI * 2);
    }

    private void draw(Graphics2D g) {
        Point center = getCenter();
        int r = getR();

        g.setTransform(AffineTransform.getRotateInstance(angle, center.x, center.y));
        
        Point start = getStart(center, r);
        g.setColor(Color.black);
        g.fillArc(start.x, start.y, r * 2, r * 2, 0, 180);
        g.setColor(Color.white);
        g.fillArc(start.x, start.y, r * 2, r * 2, 0, -180);

        g.setColor(Color.black);
        circleAt(g, getCenterOffset(center, -r/2), r/2);        
        g.setColor(Color.white);
        circleAt(g, getCenterOffset(center, r/2), r/2);

        g.setColor(Color.black);
        circleAt(g, getCenterOffset(center, r/2), r/4);
        g.setColor(Color.white);
        circleAt(g, getCenterOffset(center, -r/2), r/4);
    }

    private void circleAt(Graphics2D g, Point center, int r) {
        g.fillArc(center.x - r, center.y - r, r * 2, r * 2, 0, 360);
    }

    private Point getCenter() {
        Dimension size = getSize();
        return new Point(size.width / 2, size.height / 2);
    }

    private int getR() {
        Dimension size = getSize();
        return Math.min(size.width, size.height) / 2 - 5;
    }

    private Point getStart(Point center, int r) {
        return new Point(center.x - r, center.y - r);
    }

    private Point getCenterOffset(Point center, int t) {
        return new Point(center.x - t, center.y);
    }
}