我正在和一些人一起开发一个 3D 空间交易游戏，我被指派做的其中一件事是制作一个引导计算机“隧道”，让船通过，隧道由正方形组成用户飞到他们的目的地，随着用户离目的地越来越近，数量会增加。

只需要为船前方的点渲染正方形，因为这是用户可见的全部内容。在前往目的地的途中，船上的计算机应该在 HUD 上放置方 block ，代表您和目的地之间空间中的固定点，这些方 block 在距离上很小，随着点靠近飞船而变大。

我尝试过实现这个，但似乎无法弄清楚，主要是使用对数(Math.log10(x) 等)。我试图获得“对数空间”中的船舶位置，以帮助找出在绘制正方形时从哪个索引开始，但事实上我只有到目的地的距离才能处理，这让事情变得困惑，尤其是当你考虑到正方形的数量必须动态变化以确保它们在空间中保持固定在正确的位置(即，正方形在进行对数变换之前以 200 左右的间隔定位)。

关于这一点，我在 0.0d 开始和 1.0d 结束之间对飞船进行了一个有效的实现，尽管实现不是很好。无论如何，问题本质上归结为一维性质。对于此问题，我们将不胜感激任何建议，包括实现相同效果或解决方案的可能解决方法。

(另外，有一个 Youtube 视频展示了这种效果:http://www.youtube.com/watch?v=79F9Nj7GgfM&t=3m5s)

干杯，
克里斯

编辑:改写了整个问题。

编辑:新的测试平台代码:

package st;

import java.awt.BorderLayout;
import java.awt.Canvas;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Font;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.GraphicsDevice;
import java.awt.GraphicsEnvironment;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.image.BufferStrategy;
import java.text.DecimalFormat;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.SwingUtilities;
import javax.swing.Timer;

public class StUI2 extends JFrame {
    public static final double DEG_TO_RAD = Math.PI / 180.0d;
    public static final DecimalFormat decimalFormat = new DecimalFormat("0.0000");

    public static final Font MONO = new Font("Monospaced", Font.PLAIN, 10);

    public class StPanel extends Canvas {
        protected final Object imgLock  = new Object();
        protected int lastWidth = 1, lastHeight = 1;
        protected boolean first = true;
        protected Color bgColour = Color.DARK_GRAY, gridColour = Color.GRAY;

        double shipWrap = 700;
        double shipFrame = 100;
        double shipPos = 0;
        long lastUpdateTimeMS = -1;
        long currUpdateTimeMS = -1;

        public StPanel() {      
            setFocusable(true);
            setMinimumSize(new Dimension(1, 1));
            setAlwaysOnTop(true);
        }

        public void internalPaint(Graphics2D g) {
            synchronized (imgLock) {
                if (lastUpdateTimeMS < 0) {
                    lastUpdateTimeMS = System.currentTimeMillis();
                }
                currUpdateTimeMS = System.currentTimeMillis();
                long diffMS = currUpdateTimeMS - lastUpdateTimeMS;

                g.setFont(MONO);

                shipPos += (60d * ((double)diffMS / 1000));
                if (shipPos > shipWrap) {
                    shipPos = 0d;
                }

                double shipPosPerc = shipPos / shipWrap;
                double distToDest = shipWrap - shipPos;
                double compression = 1000d / distToDest;

                g.setColor(bgColour);
                Dimension d = getSize();
                g.fillRect(0, 0, (int)d.getWidth(), (int)d.getHeight());

                //int amnt2 = (int)unlog10((1000d / distToDest));

                g.setColor(Color.WHITE);
                g.drawString("shipPos:    " + decimalFormat.format(shipPos),     10, 10);
                g.drawString("distToDest: " + decimalFormat.format(distToDest),  10, 20);

                g.drawString("shipWrap:   " + decimalFormat.format(shipWrap),    150, 10);

                int offset = 40;

                g.setFont(MONO);

                double scalingFactor = 10d;

                double dist = 0;
                int curri = 0;
                int i = 0;
                do {
                    curri = i;
                    g.setColor(Color.GREEN);

                    dist = distToDest - getSquareDistance(distToDest, scalingFactor, i);
                    double sqh = getSquareHeight(dist, 100d * DEG_TO_RAD);
                    g.drawLine(30 + (int)dist, (offset + 50) - (int)(sqh / 2d), 30 + (int)dist, (offset + 50) + (int)(sqh / 2d));
                    g.setColor(Color.LIGHT_GRAY);
                    g.drawString("i: " +  i + ", dist: " + decimalFormat.format(dist), 10, 120 + (i * 10));
                    i++;
                } while (dist < distToDest);

                g.drawLine(10, 122, 200, 122);
                g.drawString("last / i: " +  curri + ", dist: " + decimalFormat.format(dist), 10, 122 + (i * 10));

                g.setColor(Color.MAGENTA);
                g.fillOval(30 + (int)shipPos, offset + 50, 4, 4);

                lastUpdateTimeMS = currUpdateTimeMS;
            }
        }

        public double getSquareDistance(double initialDist, double scalingFactor, int num) {
            return Math.pow(scalingFactor, num) * num * initialDist;
        }

        public double getSquareHeight(double distance, double angle) {
            return distance / Math.tan(angle);
        }

        /* (non-Javadoc)
         * @see java.awt.Canvas#paint(java.awt.Graphics)
         */
        @Override
        public void paint(Graphics g) {
            internalPaint((Graphics2D)g);
        }

        public void redraw() {
            synchronized (imgLock) {
                Dimension d = getSize();
                if (d.width == 0)  d.width = 1;
                if (d.height == 0) d.height = 1;

                if (first || d.getWidth() != lastWidth || d.getHeight() != lastHeight) {
                    first = false;

                    // remake buf
                    GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment();
                    //create an object that represents the device that outputs to screen (video card).
                    GraphicsDevice gd = ge.getDefaultScreenDevice();
                    gd.getDefaultConfiguration();

                    createBufferStrategy(2);

                    lastWidth  = (int)d.getWidth();
                    lastHeight = (int)d.getHeight();
                }

                BufferStrategy strategy = getBufferStrategy();
                Graphics2D g = (Graphics2D)strategy.getDrawGraphics();
                internalPaint(g);
                g.dispose();
                if (!strategy.contentsLost()) strategy.show();
            }
        }
    }

    protected final StPanel canvas;

    protected Timer viewTimer = new Timer(1000 / 60, new ActionListener() {     
        @Override
        public void actionPerformed(ActionEvent e) {
            canvas.redraw();
        }
    });
    {
        viewTimer.setRepeats(true);
        viewTimer.setCoalesce(true);
    }

    /**
     * Create the applet.
     */
    public StUI2() {
        JPanel panel = new JPanel(new BorderLayout());
        setContentPane(panel);
        panel.add(canvas = new StPanel(), BorderLayout.CENTER);
        setVisible(true);
        setDefaultCloseOperation(EXIT_ON_CLOSE);
        setSize(800, 300);
        setTitle("Targetting indicator test #2");
        viewTimer.start();
    }

    public static double unlog10(double x) {  
        return Math.pow(10d, x);
    }   

    public static void main(String[] args) {
        SwingUtilities.invokeLater(new Runnable() {
            @Override
            public void run() {
                StUI2 ui = new StUI2();
            }
        });
    }
}

最佳答案

假设您希望方 block 等高(当您到达它们时)，您可以根据到目的地的距离 (d) 和方 block 所需的高度来计算比例因子到达他们 (h)。

根据这两条信息，您可以计算出连接船舶与目的地的线(水平线)之间的角度(alpha)的反正切(atan)在你的图像中)和连接方 block 顶部与目的地的线(在你的图像中的斜线)。

编辑:更正
公式 使用角度，您可以计算距离目的地任意给定距离处的正方形高度 (h'):您知道到目的地的距离 (d') 并且角度 (alpha); d' 处正方形的高度为 h'=r'*sin(alpha) -- sin(alpha)=cos(alpha)*tan (alpha) 和 r'=d'/cos(alpha)(目的地和正方形顶部之间的距离——“半径”)。或者更简单:h'=d'*tan(alpha)。

注意:采用该算法来改变高度(当你到达它们时)正方形相对简单:计算角度时，只需假设一个固定高度的(幻影)正方形并相对于该正方形缩放正方形。

如果距离 d' 处的正方形高度是由您的图形库为您计算的，那就更好了，您只需要计算出放置正方形的距离即可。

从目的地放置方 block 的距离是多少？

1) 如果您想要显示不同数量的方 block (在船前)，但可能要考虑无限数量的方 block (基于 d)，您可以选择距离距离目的地最近的方格 (d1) 并通过公式 s^k*k*d1 计算其他方格的距离，其中 s (比例因子)是一个大于 1 的数字，表示第 k 个方 block (从目的地开始计数)。当结果大于d时，您可以停止算法。

请注意，如果 d 足够大，距离最近的方 block 会挡住目的地(它们很多，由于角度低，它们的高度很小)。在这种情况下，您可以引入一个最小距离(可能基于 d)，在该距离以下您不显示正方形——您将必须尝试使用​​确切的值来查看什么看起来正确/可接受。

2) 如果您想要始终显示固定数量的方 block (sn)，而不考虑 d，您可以通过计算方 block 与目的地的距离公式d*s^k，其中s是一个<>k是正方形的索引(从船上算起)。除非 sn 很高，否则对小方 block 的考虑可能不适用于此。

要修复更新后的代码，请将相关部分更改为:

double dist = 0;
double d1 = 10;
int curri = 0; 
int i = 1; 
int maxSquareHeight = 40;
double angle = Math.atan(maxSquareHeight/distToDest);
while (true)
{ 
  curri = i; 
  g.setColor(Color.GREEN); 

  dist = getSquareDistance(d1, scalingFactor, i); 
  if (dist > distToDest) {
    break;
  }
  double sqh = getSquareHeight(dist, angle); 
  g.drawLine(30 + (int)(shipWrap - dist), offset+50-(int)(sqh / 2d), 30 + (int)(shipWrap - dist), offset+50+(int)(sqh / 2d)); 
  g.setColor(Color.LIGHT_GRAY); 
  i++; 
}

public double getSquareHeight(double distance, double angle) { 
  return distance * Math.tan(angle); 
} 

您还应该将 scalingFactor 减少到 ~1.5 的数量级。

编辑:如果将公式 s^k*k*d1 替换为 s^(k-1)*k*d1，则第一个方 block 将是正好在距离d1。

编辑:固定方形高度计算公式

编辑:更新代码

关于java - 以同心指示方 block 为目标的 spaceship 模拟器制导计算机，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/9797009/