static void test_plane(CuTest *tc) {
struct region *r;
plane *pl;
test_setup();
r = test_create_region(0, 0, NULL);
CuAssertPtrEquals(tc, NULL, findplane(0, 0));
CuAssertPtrEquals(tc, NULL, getplane(r));
CuAssertIntEquals(tc, 0, getplaneid(r));
CuAssertPtrEquals(tc, NULL, getplanebyid(0));
CuAssertIntEquals(tc, 0, plane_center_x(0));
CuAssertIntEquals(tc, 0, plane_center_y(0));
CuAssertIntEquals(tc, 0, plane_width(0));
CuAssertIntEquals(tc, 0, plane_height(0));
CuAssertPtrEquals(tc, NULL, get_homeplane());
pl = create_new_plane(1, "Hell", 4, 8, 40, 80, 15);
r = test_create_region(4, 40, 0);
CuAssertIntEquals(tc, 15, pl->flags);
CuAssertIntEquals(tc, 4, pl->minx);
CuAssertIntEquals(tc, 8, pl->maxx);
CuAssertIntEquals(tc, 40, pl->miny);
CuAssertIntEquals(tc, 80, pl->maxy);
CuAssertPtrEquals(tc, NULL, pl->attribs);
CuAssertStrEquals(tc, "Hell", pl->name);
CuAssertPtrEquals(tc, pl, findplane(4, 40));
CuAssertPtrEquals(tc, pl, getplane(r));
CuAssertPtrEquals(tc, pl, getplanebyid(1));
CuAssertIntEquals(tc, 1, getplaneid(r));
CuAssertIntEquals(tc, 6, plane_center_x(pl));
CuAssertIntEquals(tc, 60, plane_center_y(pl));
CuAssertIntEquals(tc, 5, plane_width(pl));
CuAssertIntEquals(tc, 41, plane_height(pl));
test_teardown();
}
static int tolua_plane_get_size(lua_State * L)
{
plane *pl = (plane *)tolua_tousertype(L, 1, 0);
lua_pushinteger(L, plane_width(pl));
lua_pushinteger(L, plane_height(pl));
return 2;
}
// apply_gravity: Applies gravity to the camera
// ----------------------------------------- >>
void apply_gravity()
{
int sector = determine_sector((int)(camera.position.x / SCALE_3D), (int)(camera.position.y / SCALE_3D));
if (sector != -1)
{
float f_h = plane_height(sector_info[sector].f_plane, camera.position.x, camera.position.y) + (40 * SCALE_3D);
float c_h = plane_height(sector_info[sector].c_plane, camera.position.x, camera.position.y);
if (f_h >= c_h)
{
f_h = c_h - (4 * SCALE_3D);
float diff = f_h - camera.position.z;
camera.position.z = f_h;
camera.view.z += diff;
grav = 0.01f;
return;
}
if (camera.position.z > f_h - grav && camera.position.z < f_h + grav)
{
float diff = f_h - camera.position.z;
camera.position.z = f_h;
camera.view.z += diff;
grav = 0.01f;
return;
}
if (camera.position.z > f_h + grav)
{
grav = grav * 1.5;
camera.position.z -= grav;
camera.view.z -= grav;
}
else if (camera.position.z < f_h - grav)
{
grav = grav * 1.5;
camera.position.z += grav;
camera.view.z += grav;
}
}
}
int koor_distance(int x1, int y1, int x2, int y2)
{
const plane *p1 = findplane(x1, y1);
const plane *p2 = findplane(x2, y2);
if (p1 != p2)
return INT_MAX;
else {
int width = plane_width(p1);
int height = plane_height(p1);
if (width && height) {
return koor_distance_wrap_xy(x1, y1, x2, y2, width, height);
}
else {
return koor_distance_orig(x1, y1, x2, y2);
}
}
}
void determine_hilight()
{
float min_dist = 1024;
hl_wrect = NULL;
hl_fpoly = NULL;
hl_thing = NULL;
// List of sectors the camera view ray passes through
vector<int> sectors;
// Check Things
if (render_things > 0)
{
for (int t = 0; t < map.n_things; t++)
{
int f_height = 0;
int height = things_3d[t]->sprite->height;
if (things_3d[t]->parent_sector == -1)
continue;
if (sector_info[things_3d[t]->parent_sector].visible)
{
if (map.things[t]->ttype->hanging)
f_height = map.sectors[things_3d[t]->parent_sector]->c_height - height;
else
f_height = map.sectors[things_3d[t]->parent_sector]->f_height;
}
if (map.things[t]->z != 0 && map.hexen)
f_height += map.things[t]->z;
int r = things_3d[t]->sprite->width / 2;
if (map.things[t]->ttype->radius == -1)
{
r = 4;
height = 8;
f_height -= 4;
}
float x1 = (map.things[t]->x - camera.strafe.x * r) * SCALE_3D;
float y1 = (map.things[t]->y - camera.strafe.y * r) * SCALE_3D;
float x2 = (map.things[t]->x + camera.strafe.x * r) * SCALE_3D;
float y2 = (map.things[t]->y + camera.strafe.y * r) * SCALE_3D;
float dist = line_intersect(camera.position, camera.view, x1, y1, x2, y2);
if (dist != -1 && dist < min_dist)
{
point3_t direction = camera.view - camera.position;
point3_t hit_point(camera.position.x + (direction.x * dist),
camera.position.y + (direction.y * dist),
camera.position.z + (direction.z * dist));
if (hit_point.z >= f_height * SCALE_3D && hit_point.z <= (f_height + height) * SCALE_3D)
{
min_dist = dist;
hl_thing = things_3d[t];
}
}
}
}
// Check Lines
for (int a = 0; a < map.n_lines; a++)
{
if (!lines_3d[a].visible)
continue;
rect_t lrect = map.l_getrect(a);
float dist = line_intersect(camera.position, camera.view,
(float)lrect.x1() * SCALE_3D, (float)lrect.y1() * SCALE_3D,
(float)lrect.x2() * SCALE_3D, (float)lrect.y2() * SCALE_3D);
if (dist != -1 && dist < min_dist)
{
point3_t direction = camera.view - camera.position;
point3_t hit_point(camera.position.x + (direction.x * dist),
camera.position.y + (direction.y * dist),
camera.position.z + (direction.z * dist));
sectors.push_back(map.l_getsector1(a));
sectors.push_back(map.l_getsector2(a));
// For all wallrects on the line
for (int r = 0; r < lines_3d[a].rects.size(); r++)
{
if (!determine_line_side(lines_3d[a].rects[r]->verts[0].x, lines_3d[a].rects[r]->verts[0].y,
lines_3d[a].rects[r]->verts[1].x, lines_3d[a].rects[r]->verts[1].y,
camera.position.x, camera.position.y))
continue;
float up = get_slope_height_point(lines_3d[a].rects[r]->verts[0], lines_3d[a].rects[r]->verts[1], hit_point);
float lo = get_slope_height_point(lines_3d[a].rects[r]->verts[3], lines_3d[a].rects[r]->verts[2], hit_point);
if (up >= hit_point.z && lo <= hit_point.z)
{
hl_thing = NULL;
hl_wrect = lines_3d[a].rects[r];
min_dist = dist;
break;
}
}
}
}
// Check sectors
for (int a = 0; a < ssects_3d.size(); a++)
{
if (!ssects_3d[a].visible)
continue;
point3_t direction = camera.view - camera.position;
for (int b = 0; b < ssects_3d[a].flats.size(); b++)
{
// Get flat plane
flatpoly_t *poly = ssects_3d[a].flats[b];
if (!(vector_exists(sectors, poly->parent_sector)))
continue;
plane_t plane;
if (poly->part == PART_CEIL)
plane = sector_info[poly->parent_sector].c_plane;
else
plane = sector_info[poly->parent_sector].f_plane;
// Check side of plane
float h = plane_height(plane, camera.position.x, camera.position.y);
if (poly->part == PART_CEIL)
{
if (camera.position.z > h)
continue;
}
if (poly->part == PART_FLOOR)
{
if (camera.position.z < h)
continue;
}
float dist = dist_ray_plane(camera.position, direction, plane);
if (dist <= min_dist && dist > 0.0f)
{
point3_t intersection(camera.position.x + (direction.x * dist),
camera.position.y + (direction.y * dist),
camera.position.z + (direction.z * dist));
bool in = true;
DWORD start = gl_ssects[a].startseg;
DWORD end = start + gl_ssects[a].n_segs;
for (DWORD seg = start; seg < end; seg++)
{
if (!determine_seg_side(seg, intersection.x, intersection.y))
{
in = false;
break;
}
}
if (in)
{
hl_wrect = NULL;
hl_thing = NULL;
hl_fpoly = poly;
min_dist = dist;
}
}
}
}
}
