Java 我在小行星游戏中使用Vector2d类是多余的吗？

我试图通过制作一个简单的小行星游戏来学习Java中的向量和旋转。我一直在尝试Vector2d类，但我觉得我可以用点和双点来完成它。我对矢量2D的使用是多余的吗？你会如何改变我的计划

资料来源：

import java.awt.Color;
import java.awt.Cursor;  
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Point;
import java.awt.Toolkit;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import java.awt.geom.AffineTransform;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import javax.vecmath.Vector2d;
import javax.imageio.ImageIO;
import javax.swing.JFrame;
import javax.swing.JPanel;

public class Asteroids extends JPanel implements Runnable{
    BufferedImage img;
    boolean up, left, right;
    double angle = 0;
    int imgw = 0;
    int imgh = 0;
    int magnitude = 0;
    JFrame f;
    ArrayList<Projectile> bullets;
    Vector2d rocket = new Vector2d();
    Vector2d Magnitude = new Vector2d();
    AffineTransform at = new AffineTransform();

    public Asteroids(JFrame f){
        this.f = f;
        setSize(900, 800);

        try {
            img = ImageIO.read(new File("res/rocket.png"));
        } catch (IOException e) {}

        imgw = img.getWidth();
        imgh = img.getHeight();

        bullets = new ArrayList<Projectile>();

        f.addKeyListener(new KeyAdapter() {
            public void keyPressed(KeyEvent evt) {
                switch (evt.getKeyCode()) {
                case KeyEvent.VK_UP:
                    up= true;
                    break;
                case KeyEvent.VK_LEFT:
                    left = true;
                    right = false;
                    break;
                case KeyEvent.VK_RIGHT:
                    right = true;
                    left = false;
                    break;
                }
            }
            public void keyReleased(KeyEvent evt) {
                switch (evt.getKeyCode()) {
                case KeyEvent.VK_UP:
                    up= false;
                    break;
                case KeyEvent.VK_LEFT:
                    left = false;
                    break;
                case KeyEvent.VK_RIGHT:
                    right = false;
                    break;
                case KeyEvent.VK_SPACE:
                    Vector2d dir = new Vector2d(Math.cos(angle-Math.toRadians(90)),Math.sin(angle-Math.toRadians(90)));
                    bullets.add(new Projectile(dir,rocket));
                    break;
                }
            }
        });         

        Thread t = new Thread(this);
        t.start();
    }

    public static void main(String[] Args){
        JFrame frame = new JFrame();
        BufferedImage cursorImg = new BufferedImage(16, 16, BufferedImage.TYPE_INT_ARGB);
        Cursor blankCursor = Toolkit.getDefaultToolkit().createCustomCursor(cursorImg, new Point(0, 0), "blank cursor");

        frame.getContentPane().setCursor(blankCursor);

        frame.add(new Asteroids(frame));
        frame.setVisible(true);
        frame.setSize(900,500);
    }

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

        Graphics2D g2 = (Graphics2D)g;
        g2.fillRect(0,0,this.getWidth(),this.getHeight());
        g2.drawImage(img,at,this);
        g2.setColor(Color.red);
        for(Projectile p: bullets){
            p.draw(g2);
        }
    }

    public void run(){
        rocket = new Vector2d(100, 400);
        Magnitude = new Vector2d(Magnitude = new Vector2d(magnitude*Math.cos(angle-Math.toRadians(90)),magnitude*Math.sin(angle-Math.toRadians(90))));

        while(true){
            if(left){
                angle-=Math.toRadians(5);
            }
            if(right){
                angle+=Math.toRadians(5);
            }
            if(up){
                Vector2d m2 = new Vector2d(Math.cos(angle-Math.toRadians(90)),Math.sin(angle-Math.toRadians(90)));
                m2.normalize();
                m2.x/=5;
                m2.y/=5;
                Magnitude.add(m2);
            }

            if(angle>=Math.toRadians(360)){
                angle-=Math.toRadians(360);
            }else if(angle<=Math.toRadians(-360)){
                angle+=Math.toRadians(360);
            }

            Vector2d rocketN = new Vector2d(rocket);
            rocketN.normalize();

            rocket.add(Magnitude);

            System.out.println(Math.toDegrees(angle));

            at.setToTranslation(rocket.x-img.getWidth()/2, rocket.y-img.getHeight()/2); 
            at.rotate(angle, imgw/2, imgh/2); 

            Magnitude.x*=0.99;
            Magnitude.y*=0.99;

            for(Projectile p: bullets){
                p.update();
            }

            repaint();

            try {Thread.sleep(25);
            } catch (InterruptedException e) {}
        }
    }

    public class Projectile{

        int magnitude;
        private Vector2d Magnitude, position;

        public Projectile(Vector2d dir, Vector2d Position){
            this.position = new Vector2d(Position);
            magnitude = 10;
            Magnitude = new Vector2d(dir);
            position.x+=(5*Magnitude.x);
            position.y+=(5*Magnitude.y);
            Magnitude.x*=magnitude;
            Magnitude.y*=magnitude;
        }

        public void update(){
            position.add(Magnitude);
        }

        public void draw(Graphics2D g2){
            g2.drawOval((int)position.x, (int)position.y,4,4);
        }
    }
}

导入java.awt.Color；
导入java.awt.Cursor；
导入java.awt.Graphics；
导入java.awt.Graphics2D；
导入java.awt.Point；
导入java.awt.Toolkit；
导入java.awt.event.KeyAdapter；
导入java.awt.event.KeyEvent；
导入java.awt.geom.AffineTransform；
导入java.awt.image.buffereImage；
导入java.io.File；
导入java.io.IOException；
导入java.util.ArrayList；
导入javax.vecmath.Vector2d；
导入javax.imageio.imageio；
导入javax.swing.JFrame；
导入javax.swing.JPanel；
公共类小行星扩展JPanel实现可运行{
缓冲图像img；
布尔向上、左、右；
双角度=0；
int-imgw=0；
int-imgh=0；
整数震级=0；
jf框架；
ArrayList子弹；
Vector2d火箭=新Vector2d（）；
Vector2d幅值=新Vector2d（）；
AffineTransform at=新的AffineTransform（）；
公共小行星（JF框架）{
这个。f=f；
设置大小（900800）；
试一试{
img=ImageIO.read（新文件（“res/rocket.png”）；
}捕获（IOE）{}
imgw=img.getWidth（）；
imgh=img.getHeight（）；
项目符号=新的ArrayList（）；
f、 addKeyListener（新的KeyAdapter（）{
按下公共无效键（KeyEvent evt）{
开关（evt.getKeyCode（））{
case KeyEvent.VK_UP：
向上=真；
打破
case KeyEvent.VK_左：
左=真；
右=假；
打破
case KeyEvent.VK_RIGHT：
右=真；
左=假；
打破
}
}
公共无效密钥已释放（密钥事件evt）{
开关（evt.getKeyCode（））{
case KeyEvent.VK_UP：
向上=错误；
打破
case KeyEvent.VK_左：
左=假；
打破
case KeyEvent.VK_RIGHT：
右=假；
打破
case KeyEvent.VK_空间：
vector2ddir=newvector2d（Math.cos（angle-Math.toRadians（90）），Math.sin（angle-Math.toRadians（90））；
添加（新射弹（直射，火箭））；
打破
}
}
});         
螺纹t=新螺纹（此）；
t、 start（）；
}
公共静态void main（字符串[]Args）{
JFrame=新JFrame（）；
BuffereImage cursorImg=新的BuffereImage（16,16，BuffereImage.TYPE_INT_ARGB）；
Cursor blankCursor=Toolkit.getDefaultToolkit（）.createCustomCursor（cursorImg，新点（0,0），“空白光标”）；
frame.getContentPane（）.setCursor（blankCursor）；
添加（新小行星（帧））；
frame.setVisible（true）；
框架。设置尺寸（900500）；
}
公共组件（图形g）{
超级组件（g）；
图形2d g2=（图形2d）g；
g2.fillRect（0,0，this.getWidth（），this.getHeight（））；
g2.绘图图像（img，at，this）；
g2.设置颜色（颜色为红色）；
用于（射弹p：子弹）{
p、 绘制（g2）；
}
}
公开募捐{
火箭=新矢量2D（100400）；
震级=新矢量2D（震级=新矢量2D（震级*数学常数（90）），震级*数学常数（90））；
while（true）{
如果（左）{
角度-=数学托拉半径（5）；
}
如果（右）{
角度+=数学托拉半径（5）；
}
如果（向上）{
Vector2d m2=新的Vector2d（Math.cos（角度数学.环面（90）），Math.sin（角度数学.环面（90））；
m2.规范化（）；
m2.x/=5；
m2.y/=5；
震级加（m2）；
}
如果（角度>=数学托拉迪安（360））{
角度-=数学托拉半径（360）；
}如果（角度

我认为不是（回答你的问题）

但最重要的是有错误的用法，例如，使用键

（我不擅长图形2D）但另一个问题可能是由方法引起的

公共空白绘图（图形2D g2）{


检查这个如何用图形移动2D，特别是@trashgod的答案我从来没有听说过键绑定，总是使用VK_字母。在那之前，我使用getKeyChar。我认为它们都很好。谢谢！我会研究使用键绑定。很高兴能帮你+1解决关于键绑定的好问题+1；另请参见此。