There's a lot to do what you may be thinking. For example, making the walk seem more real is a whole big area of research in itself. As for turning-in-place to face a direction, you can do that by changing the orientation of the character over several frames until the character is facing the correct direction---a rigid rotation. Now, this won't be realistic, but its really damned easy, relatively speaking. A more realistic, but still reasonably easy approach, would be to build animation cycles specifically to turn the character, e.g., run the "turn-45-degrees-to-the-right" cycle and then walk along the path. As for coding up a way to turn-in-place realistically about an arbitrary angle, that's still being studied and developed at the research level. There are reasonable ways to do this if you aren't looking for super-realism, say with inverse kinematics, but it'd be a bit tedious.

Now, another thing you could do (which does actually deal with pathfinding) is to find a curved path to the destination point. Find a path that begins at the start point----with a tangent direction the faces the character's current direction, and then have the path end at the destination point with a tangent pointing parallel to the vector from the character start point to the end point, or perhaps a different direction if the character must be facing a panel or other character or something. Then have the character just walk the path. As long as the curvature of the path isn't too large, it can look good enough. Commercial games do a hybrid approach. They sometimes have custom turn-X-degrees animation cycles, but for many cases will just have a character walk a curved path that has endpoint tangents the have the character face the correct direction. Some games actually do the stupid rigid rotation thing I mentioned first. You can see this in Halo, for example, if you watch carefully.

It's quite easy. plenty of threads on how to calculate angles from two directions.

To make it easy, for 3D, you can split it into an elevation angle, and a rotation angle.

the rotation angle is derived from the X and Z components of directional vectors.

These don't really have to be normalised but it helps.


to calculate the angular deviation for gun rotation, it's simply

Vector Diff = Target.Position - Gun.Position;

float dot = Diff.x * Gun.Dir.x + Diff.z * Gun.Dir.z;
float cross = Diff.x * Gun.Dir.z - Diff.z * Gun.Dir.x;

float rot_dev = atan2(cross, dot);

for the elevation, it's

Diff.Normalise();

float target_elev = asin(Diff.y);

float elev_dev = target_elev - Gun.ElevationAngle;