找到最小的小行星c ++位置

Question

游戏小行星在圆环表面上播放。

Answer 1

Well, since you can wrap around any edge of the screen, there are always 4 straight lines between the asteroid and the ship (up and left, up and right, down and left, and down and right). I would just calculate the length of each and take the smallest result.

int dx1 = abs(ship_x - asteroid_x);
int dx2 = screen_width - dx1;

int dy1 = abs(ship_y - asertoid_y);
int dy2 = screen_height - dy1;

// Now calculate the psuedo-distances as Pete suggests:
int psuedo1 = (dx1 * dx1) + (dy1 * dy1);
int psuedo2 = (dx2 * dx2) + (dy1 * dy1);
int psuedo3 = (dx1 * dx1) + (dy2 * dy2);
int psuedo4 = (dx2 * dx2) + (dy2 * dy2);

This shows how to calculate the various distances involved. There is a little complication around mapping each one to the appropriate direction.

Answer 2

我推荐A *搜索算法

Answer 3

Find the sphere in reference to the ship.

To avoid decimals in my example. let the range of x & y = [0 ... 511] where 511 == 0 when wrapped

Lets make the middle the origin.

So subtract vec2(256,256) from both the sphere and the ship's position

sphere.position(-255,255) = sphere.position(1 - 256 ,511 - 256);

ship.position(255,-255) = ship.position(511 - 256, 1 - 256)

firstDistance(-510,510) = sphere.position(-255,255) - ship.position(255,-255)

wrappedPosition(254,-254) = wrapNewPositionToScreenBounds(firstDistance(-510,510)) // under flow / over flow using origin offset of 256

secondDistance(1,-1) = ship.position(255,-255) - wrappedPosition(254,-254)

Answer 4

#include <iostream>

template<typename Scalar>
struct vector2d {
  Scalar x;
  Scalar y;
};
template<typename Scalar>
struct position2d {
  Scalar x;
  Scalar y;
};

template<typename S>
S absolute( S in ) {
  if (in < S())
    return -in;
  return in;
}

template<typename S>
S ShortestPathScalar( S ship, S rock, S wrap ) {
  S direct = rock-ship;
  S indirect = (wrap-ship) + (rock);
  if (absolute( direct ) > absolute( indirect ) ) {
    return indirect;
  }
  return direct;
}

template<typename S>
vector2d<S> ShortestPath( position2d<S> ship, position2d<S> rock, position2d<S> wrap ) {
  vector2d<S> retval;
  retval.x = ShortestPathScalar( ship.x, rock.x, wrap.x );
  retval.y = ShortestPathScalar( ship.y, rock.y, wrap.y );
  return retval;
}


int main() {
  position2d<int> world = {1000, 1000};
  position2d<int> rock = {10, 10};
  position2d<int> ship = {500, 900};
  vector2d<int> path = ShortestPath( ship, rock, world );
  std::cout << "(" << path.x << "," << path.y << ")\n";
}

No point in doing crap with squaring stuff in a simple universe like that.

Scalar support for any type that supports a < b , and default construction for a zero. Like double or int or long long .

Note that copy/pasting the above code and handing it in as an assignment at the level of course where you are playing with that problem will get you looked at strangely. However, the algorithm should be pretty easy to follow.

Answer 5

If you need the smallest way to the asteroid, you don't need to calculate the actual smallest distance to it. If I understand you correctly, you need the shortest way not the length of the shortest path.

This, I think, is computationally the least expensive method to do that:

Let the meteor's position be (Mx, My) and the ship position (Sx, Sy). The width of the viewport is W and the height is H. Now,

dx = Mx - Sx, dy = My - Sy.

if abs(dx) > W/2 (which is 256 in this case) your ship needs to go LEFT, if abs(dx) < W/2 your ship needs to go RIGHT. IMPORTANT - Invert your result if dx was negative. (Thanks to @Toad for pointing this out!)

Similarly, if abs(dy) > H/2 ship goes UP, abs(dy) < H/2 ship goes DOWN. Like with dx, flip your result if dy is -ve.

This takes wrapping into account and should work for every case. No squares or pythagoras theorem involved, I doubt it can be done any cheaper. Also if you HAVE to find the actual shortest distance, you'll only have to apply it once now (since you already know which one of the four possible paths you need to take). @Peter's post gives an elegant way to do that while taking wrapping into account.