Index: code/fred2/management.cpp =================================================================== --- code/fred2/management.cpp (revision 11169) +++ code/fred2/management.cpp (working copy) @@ -1473,28 +1473,6 @@ return 0; } -// What does this do? -void add_ship_to_wing() -{ - int org_object = cur_object_index; - vec3d tvec; - - set_cur_object_index(); - if (Objects[org_object].type == OBJ_NONE) { - vm_vec_make(&tvec, 10.0f, 10.0f, 10.0f); - create_object(&tvec); - - } else { - Objects[cur_object_index] = Objects[org_object]; - Objects[cur_object_index].pos.xyz.x += 3.0f; - Objects[cur_object_index].pos.xyz.y += 3.0f; - physics_init(&Objects[cur_object_index].phys_info); - Objects[cur_object_index].orient = Objects[org_object].orient; - } - - set_modified(); -} - // Return true if current object is valid and is in a wing. // Else return false. int query_object_in_wing(int obj) Index: code/fred2/management.h =================================================================== --- code/fred2/management.h (revision 11169) +++ code/fred2/management.h (working copy) @@ -90,7 +90,6 @@ void delete_reinforcement(int num); int delete_ship_from_wing(int ship = cur_ship); int find_free_wing(); -void add_ship_to_wing(); int query_object_in_wing(int obj = cur_object_index); void mark_object(int obj); void unmark_object(int obj); Index: code/fred2/wing.cpp =================================================================== --- code/fred2/wing.cpp (revision 11169) +++ code/fred2/wing.cpp (working copy) @@ -512,108 +512,3 @@ return -1; } - -// Create a wing. -// wing_type is the type of wing from the Wing_formations array to create. -// leader_index is the index in Objects of the leader object. This object must -// have a position and an orientation. -// *wingmen is a list of indices of existing ships to be added to the wing. -// The wingmen list is terminated by -1. -// max_size is the maximum number of ships to add to the wing -// fill_flag is set if more ships are to be added to fill out the wing to max_size -void create_wing(int wing_type, int leader_index, int *wingmen, int max_size, int fill_flag) -{ - int num_placed, num_vectors, cur_vec_index; - object *lobjp = &Objects[leader_index]; - formation *wingp; - object *parent; - int wing_list[MAX_OBJECTS]; - matrix rotmat; - - initialize_wings(); - - Assert((wing_type >= 0) && (wing_type < MAX_WING_FORMATIONS)); - Assert(Wing_formations[wing_type].num_vectors > 0); - Assert(Wing_formations[wing_type].num_vectors < MAX_WING_VECTORS); - - Assert(Objects[leader_index].type != OBJ_NONE); - Assert(max_size < MAX_SHIPS_PER_WING); - - num_placed = 0; - wingp = &Wing_formations[wing_type]; - num_vectors = wingp->num_vectors; - cur_vec_index = 0; - parent = lobjp; - vm_copy_transpose_matrix(&rotmat, &lobjp->orient); - - while (num_placed < max_size) { - vec3d wvec; - int curobj; - - if (*wingmen == -1) { - if (!fill_flag) - break; - else { - curobj = get_free_objnum(); - Assert(curobj != -1); - Objects[curobj].type = lobjp->type; - Assert(Wings[cur_wing].wave_count < MAX_SHIPS_PER_WING); -// JEH Wings[cur_wing].ship_list[Wings[cur_wing].count] = curobj; - Wings[cur_wing].wave_count++; - } - } else - curobj = *wingmen++; - - Objects[curobj] = *lobjp; - vm_vec_rotate(&wvec, &wingp->offsets[cur_vec_index], &rotmat); - cur_vec_index = (cur_vec_index + 1) % num_vectors; - - if (num_placed < num_vectors) - parent = lobjp; - else - parent = &Objects[wing_list[num_placed - num_vectors]]; - - wing_list[num_placed] = curobj; - - vm_vec_add(&Objects[curobj].pos, &parent->pos, &wvec); - - num_placed++; - } - -} - -// Create a wing. -// cur_object_index becomes the leader. -// If count == -1, then all objects of wing cur_wing get added to the wing. -// If count == +n, then n objects are added to the wing. -void test_form_wing(int count) -{ - int i, wingmen[MAX_OBJECTS]; - int j, fill_flag; - - j = 0; - - Assert(cur_object_index != -1); - Assert(Objects[cur_object_index].type != OBJ_NONE); - Assert(get_wingnum(cur_object_index) != -1); - get_wingnum(cur_object_index); - - wingmen[0] = -1; - - for (i=1; i 0) { - fill_flag = 1; - j += count; - } - - set_wingnum(cur_object_index, cur_wing); - create_wing(0, cur_object_index, wingmen, j, fill_flag); -} Index: code/object/objcollide.cpp =================================================================== --- code/object/objcollide.cpp (revision 11169) +++ code/object/objcollide.cpp (working copy) @@ -668,15 +668,16 @@ // is useful if a moving object wants to prevent a collision. int objects_will_collide(object *A, object *B, float duration, float radius_scale) { - object A_future; + vec3d prev_pos; vec3d hitpos; + int ret; - A_future = *A; - vm_vec_scale_add2(&A_future.pos, &A->phys_info.vel, duration); + prev_pos = A->pos; + vm_vec_scale_add2(&A->pos, &A->phys_info.vel, duration); if (radius_scale == 0.0f) { - return ship_check_collision_fast(B, &A_future, &hitpos ); + ret = ship_check_collision_fast(B, A, &hitpos); } else { float size_A, size_B, dist, r; vec3d nearest_point; @@ -686,18 +687,23 @@ // If A is moving, check along vector. if (A->phys_info.speed != 0.0f) { - r = find_nearest_point_on_line(&nearest_point, &A->pos, &A_future.pos, &B->pos); + r = find_nearest_point_on_line(&nearest_point, &prev_pos, &A->pos, &B->pos); if (r < 0) { + nearest_point = prev_pos; + } else if (r > 1) { nearest_point = A->pos; - } else if (r > 1) { - nearest_point = A_future.pos; } dist = vm_vec_dist_quick(&B->pos, &nearest_point); - return (dist < size_A + size_B); + ret = (dist < size_A + size_B); } else { - return vm_vec_dist_quick(&B->pos, &A->pos) < size_A + size_B; + ret = vm_vec_dist_quick(&B->pos, &prev_pos) < size_A + size_B; } } + + // Reset the position to the previous value + A->pos = prev_pos; + + return ret; } // Return true if the vector from *start_pos to *end_pos is within objp->radius*radius_scale of *objp Index: code/object/object.h =================================================================== --- code/object/object.h (revision 11169) +++ code/object/object.h (working copy) @@ -170,6 +170,11 @@ object(); ~object(); void clear(); + +private: + // An object should never be copied; there are allocated pointers, and linked list shenanigans. + object(const object& other); // no implementation + object& operator= (const object & other); // no implementation }; struct object_h {