So I'm writing an adventure game for DOS, don't ask why, its because I like to torture myself. I'm working on pathfinding and I need a way to figure out if a point is in a convex quad, but here's the catch: processors prior to the 486dx which my game targets (specifically a 286 or 386sx) had no builtin floating point support, this makes anything using floating point extremely slow, unfortunately most of the algorithms I've seen use floating point. Any know how I might do this?

EDIT: I should mention that this is all using 2D co-ordinates.

For starters, have a look at something like a triangle rasterizer that uses fixed precision math.

That being said, I'm sure you can hack your way to an approximate result by either:

1) scaling the triangle up to the point where you compensate for floating point precision

2) using fixed point arithmetic that you'll have to google for

However, if you don't have too many test, then as a solid alternative you can essentially do an occlusion query pass: draw the triangle into a color buffer using a fixed point algorithm (your options are essentially a scanline or a barycentric approach) and test if the pixel at the point's coordinates is shaded or not.

Edit: you mentioned you have a convex shape, which is trivially divisible into triangles, which you'll want to deal with regardless of whether you're doing it fixed point or not.

So here's what I managed to do, I get the sign of the determinant for each edge and make sure all the edges have the same sign if they do then the point is in the quad. Seems to work ok so far.

bool pointInBox(quad q, point p)
{
	point* v = q.vertices;
	
	bool d0 = ((int32_t)(v[1].x - v[0].x) * (int32_t)(p.y - v[0].y)) > ((int32_t)(v[1].y - v[0].y) * (int32_t)(p.x - v[0].x));
	bool d1 = ((int32_t)(v[2].x - v[1].x) * (int32_t)(p.y - v[1].y)) > ((int32_t)(v[2].y - v[1].y) * (int32_t)(p.x - v[1].x));
	bool d2 = ((int32_t)(v[3].x - v[2].x) * (int32_t)(p.y - v[2].y)) > ((int32_t)(v[3].y - v[2].y) * (int32_t)(p.x - v[2].x));
	bool d3 = ((int32_t)(v[0].x - v[3].x) * (int32_t)(p.y - v[3].y)) > ((int32_t)(v[0].y - v[3].y) * (int32_t)(p.x - v[3].x));

	return d0 == d1 &&  d1 == d2 && d2 == d3;
}