check if player is looking at object?

DJMaesen Use Vector3::angle_to() get the angle between two vectors. Also if player and ladder basis.z are facing each other you'd want to invert one of the vectors prior to calculating the angle between them.

DJMaesen no, use dot product:

float dot ( Vector3 with ) const

Returns the dot product of this vector and with. This can be used to compare the angle between two vectors. For example, this can be used to determine whether an enemy is facing the player.

The dot product will be 0 for a straight angle (90 degrees), greater than 0 for angles narrower than 90 degrees and lower than 0 for angles wider than 90 degrees.

When using unit (normalized) vectors, the result will always be between -1.0 (180 degree angle) when the vectors are facing opposite directions, and 1.0 (0 degree angle) when the vectors are aligned.

Note: a.dot(b) is equivalent to b.dot(a).

angle_to returns an unsigned value

Jesusemora Here's what the OP said:

DJMaesen what i want is if the angle is not greater then 0.3 the player should climb

They asked about angle.

And here's their code that looks like it tests for boundary angles:

var angle : float = forward.dot(toOther)
		if angle > -0.3 && angle < 0.3:

Using angle_to() is simple, intuitive and totally adequate here. It's more "in the spirit" of what the code tests for. It's stylistically cleaner. Dot product is fine as well but there's nothing to be gained in this case by using it directly. It just obfuscates the actual meaning of that .3 limit literal the code is testing for, as this value doesn't represent an actual angle, but its cosine. Also dot product gradient is not linear and corelates "inversely" with the angle which all just adds to non-intuitiveness. And last but not least, the script code needs to normalize the vectors before using the dot product in this way whereas angle_to() does this under the hood in native code, making the script code faster and shorter.

Also @DJMaesen if dot product is between -.3 and .3, that means that the angle between vectors is between acos(-.3) and acos(.3) which in degrees is a range between 72 and 107.

xyz So to sum it up. Here's a simple and clean way to do it:

if player.global_transform.basis.z.angle_to(-ladder.global_transform.basis.z) < deg_to_rad(30):
	# can climb

Jesusemora do some unknown "under the hood".

Nothing unknown there. We know precisely how it works as there's only one efficient way to do it. Here's a custom GDScript implementation of angle_to():

func angle_to(v1: Vector3, v2: Vector3) -> float:
	return acos(v1.normalized().dot(v2.normalized()))

For 3D vectors there's shorthand version possible that avoids normalization by using cross product:

func angle_to(v1: Vector3, v2: Vector3) -> float:
	return atan(v1.cross(v2).length(), v1.dot(v2))

And this is exactly how Godot does it (from Vector3.h in Godot's source):

real_t Vector3::angle_to(const Vector3 &p_to) const {
	return Math::atan2(cross(p_to).length(), dot(p_to));
}