Subversion Repositories Games.Descent

/*

 * Portions of this file are copyright Rebirth contributors and licensed as

 * described in COPYING.txt.

 * Portions of this file are copyright Parallax Software and licensed

 * according to the Parallax license below.

 * See COPYING.txt for license details.

THE COMPUTER CODE CONTAINED HEREIN IS THE SOLE PROPERTY OF PARALLAX

SOFTWARE CORPORATION ("PARALLAX").  PARALLAX, IN DISTRIBUTING THE CODE TO

END-USERS, AND SUBJECT TO ALL OF THE TERMS AND CONDITIONS HEREIN, GRANTS A

ROYALTY-FREE, PERPETUAL LICENSE TO SUCH END-USERS FOR USE BY SUCH END-USERS

IN USING, DISPLAYING,  AND CREATING DERIVATIVE WORKS THEREOF, SO LONG AS

SUCH USE, DISPLAY OR CREATION IS FOR NON-COMMERCIAL, ROYALTY OR REVENUE

FREE PURPOSES.  IN NO EVENT SHALL THE END-USER USE THE COMPUTER CODE

CONTAINED HEREIN FOR REVENUE-BEARING PURPOSES.  THE END-USER UNDERSTANDS

AND AGREES TO THE TERMS HEREIN AND ACCEPTS THE SAME BY USE OF THIS FILE.

COPYRIGHT 1993-1999 PARALLAX SOFTWARE CORPORATION.  ALL RIGHTS RESERVED.

*/

/*

 *

 * AI path forming stuff.

 *

 */

#include <stdio.h>              //      for printf()

#include <stdlib.h>             // for d_rand() and qsort()

#include <string.h>             // for memset()

#include "inferno.h"

#include "console.h"

#include "3d.h"

#include "object.h"

#include "dxxerror.h"

#include "ai.h"

#include "robot.h"

#include "fvi.h"

#include "gameseg.h"

#include "physics.h"

#include "wall.h"

#if DXX_USE_EDITOR

#include "editor/editor.h"

#include "editor/esegment.h"

#endif

#include "player.h"

#include "fireball.h"

#include "game.h"

#include "compiler-range_for.h"

#include "d_enumerate.h"

//      Length in segments of avoidance path

#define AVOID_SEG_LENGTH        7

#ifdef NDEBUG

#define PATH_VALIDATION 0

#else

#define PATH_VALIDATION 1

#endif

namespace dsx {

static void ai_path_set_orient_and_vel(object &objp, const vms_vector &goal_point

#if defined(DXX_BUILD_DESCENT_II)

                                                                , player_visibility_state player_visibility, const vms_vector *vec_to_player

#endif

                                                                );

static void maybe_ai_path_garbage_collect(void);

static void ai_path_garbage_collect(void);

#if PATH_VALIDATION

static void validate_all_paths();

static int validate_path(int, point_seg* psegs, uint_fast32_t num_points);

#endif

}

//      ------------------------------------------------------------------------

static void create_random_xlate(std::array<uint8_t, MAX_SIDES_PER_SEGMENT> &xt)

{

        for (int i = 0; i<MAX_SIDES_PER_SEGMENT; i++)

                xt[i] = i;

        range_for (auto &i, xt)

        {

                uint_fast32_t j = (d_rand()*MAX_SIDES_PER_SEGMENT)/(D_RAND_MAX+1);

                Assert(j < xt.size());

                using std::swap;

                swap(i, xt[j]);

        }

}

namespace dsx {

//      -----------------------------------------------------------------------------------------------------------

//      Insert the point at the center of the side connecting two segments between the two points.

// This is messy because we must insert into the list.  The simplest (and not too slow) way to do this is to start

// at the end of the list and go backwards.

static uint_fast32_t insert_center_points(segment_array &segments, point_seg *psegs, uint_fast32_t count)

{

        auto &LevelSharedVertexState = LevelSharedSegmentState.get_vertex_state();

        auto &Vertices = LevelSharedVertexState.get_vertices();

        auto &vcsegptr = segments.vcptr;

        auto &vcsegptridx = segments.vcptridx;

        if (count < 2)

                return count;

        uint_fast32_t last_point = count - 1;

        for (uint_fast32_t i = last_point; i; --i)

        {

                psegs[2*i] = psegs[i];

                const auto &&seg1 = vcsegptr(psegs[i-1].segnum);

                auto connect_side = find_connect_side(vcsegptridx(psegs[i].segnum), seg1);

                Assert(connect_side != side_none);      //      Impossible!  These two segments must be connected, they were created by create_path_points (which was created by mk!)

                if (connect_side == side_none)                  //      Try to blow past the assert, this should at least prevent a hang.

                        connect_side = 0;

                auto &vcvertptr = Vertices.vcptr;

                const auto &&center_point = compute_center_point_on_side(vcvertptr, seg1, connect_side);

                auto new_point = vm_vec_sub(psegs[i-1].point, center_point);

                new_point.x /= 16;

                new_point.y /= 16;

                new_point.z /= 16;

                vm_vec_sub(psegs[2*i-1].point, center_point, new_point);

#if defined(DXX_BUILD_DESCENT_II)

                const auto &&segp = segments.imptridx(psegs[2*i].segnum);

                const auto &&temp_segnum = find_point_seg(LevelSharedSegmentState, psegs[2*i-1].point, segp);

                if (temp_segnum == segment_none) {

                        psegs[2*i-1].point = center_point;

                        find_point_seg(LevelSharedSegmentState, psegs[2*i-1].point, segp);

                }

#endif

                psegs[2*i-1].segnum = psegs[2*i].segnum;

                count++;

        }

#if defined(DXX_BUILD_DESCENT_II)

        //      Now, remove unnecessary center points.

        //      A center point is unnecessary if it is close to the line between the two adjacent points.

        //      MK, OPTIMIZE!  Can get away with about half the math since every vector gets computed twice.

        for (uint_fast32_t i = 1; i < count - 1; i += 2)

        {

                vms_vector      temp1, temp2;

                fix                     dot;

                dot = vm_vec_dot(vm_vec_sub(temp1, psegs[i].point, psegs[i-1].point), vm_vec_sub(temp2, psegs[i+1].point, psegs[i].point));

                if (dot * 9/8 > fixmul(vm_vec_mag(temp1), vm_vec_mag(temp2)))

                        psegs[i].segnum = segment_none;

        }

        //      Now, scan for points with segnum == -1

        auto predicate = [](const point_seg &p) { return p.segnum == segment_none; };

        count = std::distance(psegs, std::remove_if(psegs, psegs + count, predicate));

#endif

        return count;

}

#if defined(DXX_BUILD_DESCENT_II)

//      -----------------------------------------------------------------------------------------------------------

//      Move points halfway to outside of segment.

static void move_towards_outside(const d_level_shared_segment_state &LevelSharedSegmentState, point_seg *const psegs, const unsigned num_points, const vmobjptridx_t objp, const create_path_random_flag rand_flag)

{

        int     i;

        std::array<point_seg, 200> new_psegs;

        assert(num_points < new_psegs.size());

        auto &Segments = LevelSharedSegmentState.get_segments();

        auto &LevelSharedVertexState = LevelSharedSegmentState.get_vertex_state();

        auto &Vertices = LevelSharedVertexState.get_vertices();

        auto &vcvertptr = Vertices.vcptr;

        for (i = 1; i < num_points - 1; ++i)

        {

                fix                     segment_size;

                segnum_t                        segnum;

                vms_vector      e;

                int                     count;

                const auto &&temp_segnum = find_point_seg(LevelSharedSegmentState, psegs[i].point, Segments.vcptridx(psegs[i].segnum));

                Assert(temp_segnum != segment_none);

                psegs[i].segnum = temp_segnum;

                segnum = psegs[i].segnum;

                //      I don't think we can use quick version here and this is _very_ rarely called. --MK, 07/03/95

                const auto a = vm_vec_normalized_quick(vm_vec_sub(psegs[i].point, psegs[i-1].point));

                const auto b = vm_vec_normalized_quick(vm_vec_sub(psegs[i+1].point, psegs[i].point));

                const auto c = vm_vec_sub(psegs[i+1].point, psegs[i-1].point);

                if (abs(vm_vec_dot(a, b)) > 3*F1_0/4 ) {

                        if (abs(a.z) < F1_0/2) {

                                if (rand_flag != create_path_random_flag::nonrandom)

                                {

                                        e.x = (d_rand()-16384)/2;

                                        e.y = (d_rand()-16384)/2;

                                        e.z = abs(e.x) + abs(e.y) + 1;

                                        vm_vec_normalize_quick(e);

                                } else {

                                        e.x = 0;

                                        e.y = 0;

                                        e.z = F1_0;

                                }

                        } else {

                                if (rand_flag != create_path_random_flag::nonrandom)

                                {

                                        e.y = (d_rand()-16384)/2;

                                        e.z = (d_rand()-16384)/2;

                                        e.x = abs(e.y) + abs(e.z) + 1;

                                        vm_vec_normalize_quick(e);

                                } else {

                                        e.x = F1_0;

                                        e.y = 0;

                                        e.z = 0;

                                }

                        }

                } else {

                        const auto d = vm_vec_cross(a, b);

                        vm_vec_cross(e, c, d);

                        vm_vec_normalize_quick(e);

                }

                if (vm_vec_mag_quick(e) < F1_0/2)

        Int3();

                const shared_segment &segp = *vcsegptr(segnum);

                segment_size = vm_vec_dist_quick(vcvertptr(segp.verts[0]), vcvertptr(segp.verts[6]));

                if (segment_size > F1_0*40)

                        segment_size = F1_0*40;

                auto goal_pos = vm_vec_scale_add(psegs[i].point, e, segment_size/4);

                count = 3;

                while (count) {

                        fvi_query       fq;

                        fvi_info                hit_data;

                        int                     hit_type;

                        fq.p0                                           = &psegs[i].point;

                        fq.startseg                             = psegs[i].segnum;

                        fq.p1                                           = &goal_pos;

                        fq.rad                                  = objp->size;

                        fq.thisobjnum                   = objp;

                        fq.ignore_obj_list.first = nullptr;

                        fq.flags                                        = 0;

                        hit_type = find_vector_intersection(fq, hit_data);

                        if (hit_type == HIT_NONE)

                                count = 0;

                        else {

                                if ((count == 3) && (hit_type == HIT_BAD_P0))

                                        Int3();

                                goal_pos.x = (fq.p0->x + hit_data.hit_pnt.x)/2;

                                goal_pos.y = (fq.p0->y + hit_data.hit_pnt.y)/2;

                                goal_pos.z = (fq.p0->z + hit_data.hit_pnt.z)/2;

                                count--;

                                if (count == 0) {       //      Couldn't move towards outside, that's ok, sometimes things can't be moved.

                                        goal_pos = psegs[i].point;

                                }

                        }

                }

                //      Only move towards outside if remained inside segment.

                const auto &&new_segnum = find_point_seg(LevelSharedSegmentState, goal_pos, Segments.vcptridx(psegs[i].segnum));

                if (new_segnum == psegs[i].segnum) {

                        new_psegs[i].point = goal_pos;

                        new_psegs[i].segnum = new_segnum;

                } else {

                        new_psegs[i].point = psegs[i].point;

                        new_psegs[i].segnum = psegs[i].segnum;

                }

        }

        for (i = 1; i < num_points - 1; ++i)

                psegs[i] = new_psegs[i];

}

#endif

//      -----------------------------------------------------------------------------------------------------------

//      Create a path from objp->pos to the center of end_seg.

//      Return a list of (segment_num, point_locations) at psegs

//      Return number of points in *num_points.

//      if max_depth == -1, then there is no maximum depth.

//      If unable to create path, return -1, else return 0.

//      If random_flag !0, then introduce randomness into path by looking at sides in random order.  This means

//      that a path between two segments won't always be the same, unless it is unique.

//      If safety_flag is set, then additional points are added to "make sure" that points are reachable.  I would

//      like to say that it ensures that the object can move between the points, but that would require knowing what

//      the object is (which isn't passed, right?) and making fvi calls (slow, right?).  So, consider it the more_or_less_safe_flag.

//      If end_seg == -2, then end seg will never be found and this routine will drop out due to depth (probably called by create_n_segment_path).

std::pair<create_path_result, unsigned> create_path_points(const vmobjptridx_t objp, const vcsegidx_t start_seg, icsegidx_t end_seg, point_seg_array_t::iterator psegs, const unsigned max_depth, create_path_random_flag random_flag, const create_path_safety_flag safety_flag, icsegidx_t avoid_seg)

{

#if defined(DXX_BUILD_DESCENT_II)

        auto &Objects = LevelUniqueObjectState.Objects;

        auto &vmobjptr = Objects.vmptr;

#endif

        segnum_t                cur_seg;

        int             qtail = 0, qhead = 0;

        int             i;

        std::array<seg_seg, MAX_SEGMENTS> seg_queue;

        int             cur_depth;

        std::array<uint8_t, MAX_SIDES_PER_SEGMENT> random_xlate;

        DXX_POISON_VAR(random_xlate, 0xcc);

        point_seg_array_t::iterator     original_psegs = psegs;

        unsigned l_num_points = 0;

#if PATH_VALIDATION

        validate_all_paths();

#endif

if ((objp->type == OBJ_ROBOT) && (objp->ctype.ai_info.behavior == ai_behavior::AIB_RUN_FROM)) {

        random_flag = create_path_random_flag::random;

        avoid_seg = ConsoleObject->segnum;

        // Int3();

}

        visited_segment_bitarray_t visited;

        std::array<uint16_t, MAX_SEGMENTS> depth{};

        //      If there is a segment we're not allowed to visit, mark it.

        if (avoid_seg != segment_none) {

                Assert(avoid_seg <= Highest_segment_index);

                if ((start_seg != avoid_seg) && (end_seg != avoid_seg)) {

                        visited[avoid_seg] = true;

                }

        }

        if (random_flag != create_path_random_flag::nonrandom)

                create_random_xlate(random_xlate);

        cur_seg = start_seg;

        visited[cur_seg] = true;

        cur_depth = 0;

        auto &LevelSharedVertexState = LevelSharedSegmentState.get_vertex_state();

        auto &Vertices = LevelSharedVertexState.get_vertices();

        auto &vcvertptr = Vertices.vcptr;

        auto &Walls = LevelUniqueWallSubsystemState.Walls;

        auto &vcwallptr = Walls.vcptr;

        while (cur_seg != end_seg) {

                const auto &&segp = vcsegptr(cur_seg);

#if defined(DXX_BUILD_DESCENT_II)

                if (random_flag != create_path_random_flag::nonrandom)

                        if (d_rand() < 8192)

                                create_random_xlate(random_xlate);

#endif

                range_for (const auto &&es, enumerate(random_xlate))

                {

                        const unsigned snum = (random_flag != create_path_random_flag::nonrandom) ? es.value : es.idx;

                        if (!IS_CHILD(segp->children[snum]))

                                continue;

#if defined(DXX_BUILD_DESCENT_I)

#define AI_DOOR_OPENABLE_PLAYER_FLAGS

#elif defined(DXX_BUILD_DESCENT_II)

#define AI_DOOR_OPENABLE_PLAYER_FLAGS   player_info.powerup_flags,

                        auto &player_info = get_local_plrobj().ctype.player_info;

#endif

                        if ((WALL_IS_DOORWAY(GameBitmaps, Textures, vcwallptr, segp, snum) & WID_FLY_FLAG) || ai_door_is_openable(objp, AI_DOOR_OPENABLE_PLAYER_FLAGS segp, snum))

#undef AI_DOOR_OPENABLE_PLAYER_FLAGS

                        {

                                const auto this_seg = segp->children[snum];

#if defined(DXX_BUILD_DESCENT_II)

                                Assert(this_seg != segment_none);

                                if (((cur_seg == avoid_seg) || (this_seg == avoid_seg)) && (ConsoleObject->segnum == avoid_seg)) {

                                        fvi_query       fq;

                                        fvi_info                hit_data;

                                        int                     hit_type;

                                        const auto &&center_point = compute_center_point_on_side(vcvertptr, segp, snum);

                                        fq.p0                                           = &objp->pos;

                                        fq.startseg                             = objp->segnum;

                                        fq.p1                                           = &center_point;

                                        fq.rad                                  = objp->size;

                                        fq.thisobjnum                   = objp;

                                        fq.ignore_obj_list.first = nullptr;

                                        fq.flags                                        = 0;

                                        hit_type = find_vector_intersection(fq, hit_data);

                                        if (hit_type != HIT_NONE) {

                                                goto dont_add;

                                        }

                                }

#endif

                                if (!visited[this_seg]) {

                                        seg_queue[qtail].start = cur_seg;

                                        seg_queue[qtail].end = this_seg;

                                        visited[this_seg] = true;

                                        depth[qtail++] = cur_depth+1;

                                        if (depth[qtail-1] == max_depth) {

                                                end_seg = seg_queue[qtail-1].end;

                                                goto cpp_done1;

                                        }       // end if (depth[...

                                }       // end if (!visited...

                        }       // if (WALL_IS_DOORWAY(...

#if defined(DXX_BUILD_DESCENT_II)

dont_add: ;

#endif

                }

                if (qtail <= 0)

                        break;

                if (qhead >= qtail) {

                        //      Couldn't get to goal, return a path as far as we got, which probably acceptable to the unparticular caller.

                        end_seg = seg_queue[qtail-1].end;

                        break;

                }

                cur_seg = seg_queue[qhead].end;

                cur_depth = depth[qhead];

                qhead++;

cpp_done1: ;

        }       //      while (cur_seg ...

        if (qtail > 0)

        {

                //      Set qtail to the segment which ends at the goal.

                while (seg_queue[--qtail].end != end_seg)

                        if (qtail < 0) {

                                return std::make_pair(create_path_result::early, l_num_points);

                        }

        }

        else

                qtail = -1;

#if defined(DXX_BUILD_DESCENT_I)

#if DXX_USE_EDITOR

        Selected_segs.clear();

        #endif

#endif

        while (qtail >= 0) {

                segnum_t        parent_seg, this_seg;

                this_seg = seg_queue[qtail].end;

                parent_seg = seg_queue[qtail].start;

                psegs->segnum = this_seg;

                compute_segment_center(vcvertptr, psegs->point, vcsegptr(this_seg));

                psegs++;

                l_num_points++;

#if defined(DXX_BUILD_DESCENT_I)

#if DXX_USE_EDITOR

                Selected_segs.emplace_back(this_seg);

                #endif

#endif

                if (parent_seg == start_seg)

                        break;

                while (seg_queue[--qtail].end != parent_seg)

                        Assert(qtail >= 0);

        }

        psegs->segnum = start_seg;

        compute_segment_center(vcvertptr, psegs->point, vcsegptr(start_seg));

        psegs++;

        l_num_points++;

#if PATH_VALIDATION

        validate_path(1, original_psegs, l_num_points);

#endif

        //      Now, reverse point_segs in place.

        for (i=0; i< l_num_points/2; i++) {

                point_seg               temp_point_seg = *(original_psegs + i);

                *(original_psegs + i) = *(original_psegs + l_num_points - i - 1);

                *(original_psegs + l_num_points - i - 1) = temp_point_seg;

        }

#if PATH_VALIDATION

        validate_path(2, original_psegs, l_num_points);

#endif

        //      Now, if safety_flag set, then insert the point at the center of the side connecting two segments

        //      between the two points.  This is messy because we must insert into the list.  The simplest (and not too slow)

        //      way to do this is to start at the end of the list and go backwards.

        if (safety_flag != create_path_safety_flag::unsafe) {

                if (psegs - Point_segs + l_num_points + 2 > MAX_POINT_SEGS) {

                        //      Ouch!  Cannot insert center points in path.  So return unsafe path.

                        ai_reset_all_paths();

                        return std::make_pair(create_path_result::early, l_num_points);

                } else {

                        l_num_points = insert_center_points(Segments, original_psegs, l_num_points);

                }

        }

#if PATH_VALIDATION

        validate_path(3, original_psegs, l_num_points);

#endif

#if defined(DXX_BUILD_DESCENT_II)

// -- MK, 10/30/95 -- This code causes apparent discontinuities in the path, moving a point

//      into a new segment.  It is not necessarily bad, but it makes it hard to track down actual

//      discontinuity problems.

        auto &Robot_info = LevelSharedRobotInfoState.Robot_info;

        if (objp->type == OBJ_ROBOT)

                if (Robot_info[get_robot_id(objp)].companion)

                        move_towards_outside(LevelSharedSegmentState, original_psegs, l_num_points, objp, create_path_random_flag::nonrandom);

#endif

#if PATH_VALIDATION

        validate_path(4, original_psegs, l_num_points);

#endif

        return std::make_pair(create_path_result::finished, l_num_points);

}

#if defined(DXX_BUILD_DESCENT_II)

//      -------------------------------------------------------------------------------------------------------

//      polish_path

//      Takes an existing path and makes it nicer.

//      Drops as many leading points as possible still maintaining direct accessibility

//      from current position to first point.

//      Will not shorten path to fewer than 3 points.

//      Returns number of points.

//      Starting position in psegs doesn't change.

//      Changed, MK, 10/18/95.  I think this was causing robots to get hung up on walls.

//                              Only drop up to the first three points.

int polish_path(const vmobjptridx_t objp, point_seg *psegs, int num_points)

{

        auto &BuddyState = LevelUniqueObjectState.BuddyState;

        int     i, first_point=0;

        if (num_points <= 4)

                return num_points;

        //      Prevent the buddy from polishing his path twice in one tick, which can cause him to get hung up.  Pretty ugly, huh?

        auto &Robot_info = LevelSharedRobotInfoState.Robot_info;

        if (Robot_info[get_robot_id(objp)].companion)

        {

                if (d_tick_count == BuddyState.Last_buddy_polish_path_tick)

                        return num_points;

                else

                        BuddyState.Last_buddy_polish_path_tick = d_tick_count;

        }

        // -- MK: 10/18/95: for (i=0; i<num_points-3; i++)

        for (i=0; i<2; i++) {

                fvi_query       fq;

                fvi_info                hit_data;

                int                     hit_type;

                fq.p0                                           = &objp->pos;

                fq.startseg                             = objp->segnum;

                fq.p1                                           = &psegs[i].point;

                fq.rad                                  = objp->size;

                fq.thisobjnum                   = objp;

                fq.ignore_obj_list.first = nullptr;

                fq.flags                                        = 0;

                hit_type = find_vector_intersection(fq, hit_data);

                if (hit_type == HIT_NONE)

                        first_point = i+1;

                else

                        break;         

        }

        if (first_point) {

                //      Scrunch down all the psegs.

                for (i=first_point; i<num_points; i++)

                        psegs[i-first_point] = psegs[i];

        }

        return num_points - first_point;

}

#endif

#ifndef NDEBUG

//      -------------------------------------------------------------------------------------------------------

//      Make sure that there are connections between all segments on path.

//      Note that if path has been optimized, connections may not be direct, so this function is useless, or worse.

//      Return true if valid, else return false.

int validate_path(int, point_seg *psegs, uint_fast32_t num_points)

{

#if PATH_VALIDATION

        auto curseg = psegs->segnum;

        if (curseg > Highest_segment_index)

        {

                //Int3();               //      Contact Mike: Debug trap for elusive, nasty bug.

                return 0;

        }

        range_for (const auto &ps, unchecked_partial_range(psegs, 1u, num_points))

        {

                auto nextseg = ps.segnum;

                if (curseg != nextseg) {

                        const auto &&csegp = vcsegptr(curseg);

                        const auto &children = csegp->children;

                        if (std::find(children.begin(), children.end(), nextseg) == children.end())

                        {

                        // Assert(sidenum != MAX_SIDES_PER_SEGMENT);    //      Hey, created path is not contiguous, why!?

                                //Int3();

                                return 0;

                        }

                        curseg = nextseg;

                }

        }

#endif

        return 1;

}

//      -----------------------------------------------------------------------------------------------------------

void validate_all_paths(void)

{

#if PATH_VALIDATION

        auto &Objects = LevelUniqueObjectState.Objects;

        auto &vmobjptr = Objects.vmptr;

        range_for (const auto &&objp, vmobjptr)

        {

                auto &obj = *objp;

                if (obj.type == OBJ_ROBOT) {

                        auto &aip = obj.ctype.ai_info;

                        if (obj.control_type == CT_AI) {

                                if ((aip.hide_index != -1) && (aip.path_length > 0))

                                        if (!validate_path(4, &Point_segs[aip.hide_index], aip.path_length))

                                        {

                                                //Int3();       //      This path is bogus!  Who corrupted it!  Danger! Danger!

                                                                        //      Contact Mike, he caused this mess.

                                                //force_dump_ai_objects_all("Error in validate_all_paths");

                                                aip.path_length=0;      //      This allows people to resume without harm...

                                        }

                        }

                }

        }

#endif

}

#endif

//      -------------------------------------------------------------------------------------------------------

//      Creates a path from the objects current segment (objp->segnum) to the specified segment for the object to

//      hide in Ai_local_info[objnum].goal_segment.

//      Sets    objp->ctype.ai_info.hide_index,         a pointer into Point_segs, the first point_seg of the path.

//                      objp->ctype.ai_info.path_length,                length of path

//                      Point_segs_free_ptr                             global pointer into Point_segs array

void create_path_to_segment(const vmobjptridx_t objp, const unsigned max_length, const create_path_safety_flag safety_flag, const icsegidx_t goal_segment)

{

        ai_static       *aip = &objp->ctype.ai_info;

        ai_local                *ailp = &objp->ctype.ai_info.ail;

        ailp->time_player_seen = GameTime64;                    //      Prevent from resetting path quickly.

        ailp->goal_segment = goal_segment;

        segnum_t                        start_seg;

        start_seg = objp->segnum;

        const auto end_seg = goal_segment;

        if (end_seg == segment_none) {

                ;

        } else {

                aip->path_length = create_path_points(objp, start_seg, end_seg, Point_segs_free_ptr, max_length, create_path_random_flag::random, safety_flag, segment_none).second;

#if defined(DXX_BUILD_DESCENT_II)

                aip->path_length = polish_path(objp, Point_segs_free_ptr, aip->path_length);

#endif

                aip->hide_index = Point_segs_free_ptr - Point_segs;

                aip->cur_path_index = 0;

#if defined(DXX_BUILD_DESCENT_I)

#ifndef NDEBUG

                validate_path(6, Point_segs_free_ptr, aip->path_length);

#endif

#endif

                Point_segs_free_ptr += aip->path_length;

                if (Point_segs_free_ptr - Point_segs + MAX_PATH_LENGTH*2 > MAX_POINT_SEGS) {

                        //Int3();       //      Contact Mike: This is stupid.  Should call maybe_ai_garbage_collect before the add.

                        //force_dump_ai_objects_all("Error in create_path_to_player");

                        ai_reset_all_paths();

                        return;

                }

//              Assert(Point_segs_free_ptr - Point_segs + MAX_PATH_LENGTH*2 < MAX_POINT_SEGS);

                aip->PATH_DIR = 1;              //      Initialize to moving forward.

#if defined(DXX_BUILD_DESCENT_I)

                aip->SUBMODE = AISM_GOHIDE;             //      This forces immediate movement.

#endif

                ailp->mode = ai_mode::AIM_FOLLOW_PATH;

                ailp->player_awareness_type = player_awareness_type_t::PA_NONE;         //      If robot too aware of player, will set mode to chase

        }

        maybe_ai_path_garbage_collect();

}

//      Change, 10/07/95: Used to create path to ConsoleObject->pos.  Now creates path to Believed_player_pos.

void create_path_to_believed_player_segment(const vmobjptridx_t objp, const unsigned max_length, const create_path_safety_flag safety_flag)

{

#if defined(DXX_BUILD_DESCENT_I)

        const auto goal_segment = ConsoleObject->segnum;

#elif defined(DXX_BUILD_DESCENT_II)

        const auto goal_segment = Believed_player_seg;

#endif

        create_path_to_segment(objp, max_length, safety_flag, goal_segment);

}

#if defined(DXX_BUILD_DESCENT_II)

void create_path_to_guidebot_player_segment(const vmobjptridx_t objp, const unsigned max_length, const create_path_safety_flag safety_flag)

{

        auto &BuddyState = LevelUniqueObjectState.BuddyState;

        auto &Objects = LevelUniqueObjectState.Objects;

        auto &plr = get_player_controlling_guidebot(BuddyState, Players);

        if (plr.objnum == object_none)

                return;

        auto &plrobj = *Objects.vcptr(plr.objnum);

        const auto goal_segment = plrobj.segnum;

        create_path_to_segment(objp, max_length, safety_flag, goal_segment);

}

//      -------------------------------------------------------------------------------------------------------

//      Creates a path from the object's current segment (objp->segnum) to segment goalseg.

void create_path_to_segment(const vmobjptridx_t objp, segnum_t goalseg, const unsigned max_length, const create_path_safety_flag safety_flag)

{

        ai_static       *aip = &objp->ctype.ai_info;

        ai_local                *ailp = &objp->ctype.ai_info.ail;

        ailp->time_player_seen = GameTime64;                    //      Prevent from resetting path quickly.

        ailp->goal_segment = goalseg;

        segnum_t                        start_seg, end_seg;

        start_seg = objp->segnum;

        end_seg = ailp->goal_segment;

        if (end_seg == segment_none) {

                ;

        } else {

                aip->path_length = create_path_points(objp, start_seg, end_seg, Point_segs_free_ptr, max_length, create_path_random_flag::random, safety_flag, segment_none).second;

                aip->hide_index = Point_segs_free_ptr - Point_segs;

                aip->cur_path_index = 0;

                Point_segs_free_ptr += aip->path_length;

                if (Point_segs_free_ptr - Point_segs + MAX_PATH_LENGTH*2 > MAX_POINT_SEGS) {

                        ai_reset_all_paths();

                        return;

                }

                aip->PATH_DIR = 1;              //      Initialize to moving forward.

                // -- UNUSED! aip->SUBMODE = AISM_GOHIDE;               //      This forces immediate movement.

                ailp->player_awareness_type = player_awareness_type_t::PA_NONE;         //      If robot too aware of player, will set mode to chase

        }

        maybe_ai_path_garbage_collect();

}

#endif

//      -------------------------------------------------------------------------------------------------------

//      Creates a path from the objects current segment (objp->segnum) to the specified segment for the object to

//      hide in Ai_local_info[objnum].goal_segment

//      Sets    objp->ctype.ai_info.hide_index,         a pointer into Point_segs, the first point_seg of the path.

//                      objp->ctype.ai_info.path_length,                length of path

//                      Point_segs_free_ptr                             global pointer into Point_segs array

void create_path_to_station(const vmobjptridx_t objp, int max_length)

{

        ai_static       *aip = &objp->ctype.ai_info;

        ai_local                *ailp = &objp->ctype.ai_info.ail;

        if (max_length == -1)

                max_length = MAX_DEPTH_TO_SEARCH_FOR_PLAYER;

        ailp->time_player_seen = GameTime64;                    //      Prevent from resetting path quickly.

        segnum_t                        start_seg, end_seg;

        start_seg = objp->segnum;

        end_seg = aip->hide_segment;

        if (end_seg == segment_none) {

                ;

        } else {

                aip->path_length = create_path_points(objp, start_seg, end_seg, Point_segs_free_ptr, max_length, create_path_random_flag::random, create_path_safety_flag::safe, segment_none).second;

#if defined(DXX_BUILD_DESCENT_II)

                aip->path_length = polish_path(objp, Point_segs_free_ptr, aip->path_length);