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.

*/

/*

 *

 * Autonomous Individual movement.

 *

 */

#include <algorithm>

#include <cstdlib>

#include <stdio.h>

#include <time.h>

#include "inferno.h"

#include "game.h"

#include "console.h"

#include "3d.h"

#include "object.h"

#include "render.h"

#include "dxxerror.h"

#include "ai.h"

#include "escort.h"

#include "laser.h"

#include "fvi.h"

#include "physfsx.h"

#include "physfs-serial.h"

#include "robot.h"

#include "bm.h"

#include "weapon.h"

#include "physics.h"

#include "collide.h"

#include "player.h"

#include "wall.h"

#include "vclip.h"

#include "fireball.h"

#include "morph.h"

#include "effects.h"

#include "timer.h"

#include "sounds.h"

#include "gameseg.h"

#include "cntrlcen.h"

#include "multibot.h"

#include "multi.h"

#include "gameseq.h"

#include "key.h"

#include "powerup.h"

#include "gauges.h"

#include "text.h"

#include "args.h"

#include "fuelcen.h"

#include "controls.h"

#include "kconfig.h"

#if DXX_USE_EDITOR

#include "editor/editor.h"

#include "editor/esegment.h"

#include "editor/kdefs.h"

#endif

//added 05/17/99 Matt Mueller

#include "u_mem.h"

//end addition -MM

#include "compiler-range_for.h"

#include "segiter.h"

#include "d_enumerate.h"

#include "d_range.h"

#include <utility>

using std::min;

#define AI_TURN_SCALE   1

#define BABY_SPIDER_ID  14

namespace dsx {

static void init_boss_segments(const segment_array &segments, const object &boss_objnum, d_level_shared_boss_state::special_segment_array_t &a, int size_check, int one_wall_hack);

static void ai_multi_send_robot_position(object &objnum, int force);

#if defined(DXX_BUILD_DESCENT_I)

#define BOSS_DEATH_SOUND_DURATION       0x2ae14         //      2.68 seconds

constexpr d_level_shared_boss_state::D1_Boss_cloak_interval d_level_shared_boss_state::Boss_cloak_interval;

constexpr d_level_shared_boss_state::D1_Boss_teleport_interval d_level_shared_boss_state::Boss_teleport_interval;

#elif defined(DXX_BUILD_DESCENT_II)

#define FIRE_AT_NEARBY_PLAYER_THRESHOLD (F1_0*40)

#define FIRE_K  8               //      Controls average accuracy of robot firing.  Smaller numbers make firing worse.  Being power of 2 doesn't matter.

// ====================================================================================================================

#define MIN_LEAD_SPEED          (F1_0*4)

#define MAX_LEAD_DISTANCE       (F1_0*200)

#define LEAD_RANGE                      (F1_0/2)

constexpr std::array<std::array<int, 3>, NUM_D2_BOSSES> Spew_bots{{

        {{38, 40, -1}},

        {{37, -1, -1}},

        {{43, 57, -1}},

        {{26, 27, 58}},

        {{59, 58, 54}},

        {{60, 61, 54}},

        {{69, 29, 24}},

        {{72, 60, 73}}

}};

constexpr std::array<int, NUM_D2_BOSSES> Max_spew_bots{{2, 1, 2, 3, 3, 3, 3, 3}};

static fix Dist_to_last_fired_upon_player_pos;

#endif

}

namespace dcx {

constexpr std::integral_constant<int, F1_0 * 8> CHASE_TIME_LENGTH{};

constexpr std::integral_constant<int, F1_0> Robot_sound_volume{};

enum {

        Flinch_scale = 4,

        Attack_scale = 24,

};

#define ANIM_RATE               (F1_0/16)

#define DELTA_ANG_SCALE 16

constexpr std::array<int8_t, 8> Mike_to_matt_xlate{{

        AS_REST, AS_REST, AS_ALERT, AS_ALERT, AS_FLINCH, AS_FIRE, AS_RECOIL, AS_REST

}};

#define OVERALL_AGITATION_MAX   100

#define         MAX_AI_CLOAK_INFO       8       //      Must be a power of 2!

#define BOSS_CLOAK_DURATION     Boss_cloak_duration

#define BOSS_DEATH_DURATION     (F1_0*6)

//      Amount of time since the current robot was last processed for things such as movement.

//      It is not valid to use FrameTime because robots do not get moved every frame.

// ---------- John: These variables must be saved as part of gamesave. --------

static int             Overall_agitation;

point_seg_array_t       Point_segs;

point_seg_array_t::iterator       Point_segs_free_ptr;

static std::array<ai_cloak_info, MAX_AI_CLOAK_INFO>   Ai_cloak_info;

// ------ John: End of variables which must be saved as part of gamesave. -----

//      0       mech

//      1       green claw

//      2       spider

//      3       josh

//      4       violet

//      5       cloak vulcan

//      6       cloak mech

//      7       brain

//      8       onearm

//      9       plasma

//      10      toaster

//      11      bird

//      12      missile bird

//      13      polyhedron

//      14      baby spider

//      15      mini boss

//      16      super mech

//      17      shareware boss

//      18      cloak-green     ; note, gating in this guy benefits player, cloak objects

//      19      vulcan

//      20      toad

//      21      4-claw

//      22      quad-laser

// 23 super boss

// byte Super_boss_gate_list[] = {0, 1, 2, 9, 11, 16, 18, 19, 21, 22, 0, 9, 9, 16, 16, 18, 19, 19, 22, 22};

constexpr std::array<int8_t, 21> Super_boss_gate_list{{

        0, 1, 8, 9, 10, 11, 12, 15, 16, 18, 19, 20, 22, 0, 8, 11, 19, 20, 8, 20, 8

}};

}

#define MAX_GATE_INDEX  (Super_boss_gate_list.size())

#if defined(DXX_BUILD_DESCENT_II)

namespace dsx {

// ------ John: End of variables which must be saved as part of gamesave. -----

vms_vector      Last_fired_upon_player_pos;

// -- ubyte Boss_cloaks[NUM_D2_BOSSES]              = {1,1,1,1,1,1};      // Set byte if this boss can cloak

const boss_flags_t Boss_teleports{{1,1,1,1,1,1, 1,1}}; // Set byte if this boss can teleport

const boss_flags_t Boss_spew_more{{0,1,0,0,0,0, 0,0}}; // If set, 50% of time, spew two bots.

const boss_flags_t Boss_spews_bots_energy{{1,1,0,1,0,1, 1,1}}; // Set byte if boss spews bots when hit by energy weapon.

const boss_flags_t Boss_spews_bots_matter{{0,0,1,1,1,1, 0,1}}; // Set byte if boss spews bots when hit by matter weapon.

const boss_flags_t Boss_invulnerable_energy{{0,0,1,1,0,0, 0,0}}; // Set byte if boss is invulnerable to energy weapons.

const boss_flags_t Boss_invulnerable_matter{{0,0,0,0,1,1, 1,0}}; // Set byte if boss is invulnerable to matter weapons.

const boss_flags_t Boss_invulnerable_spot{{0,0,0,0,0,1, 0,1}}; // Set byte if boss is invulnerable in all but a certain spot.  (Dot product fvec|vec_to_collision < BOSS_INVULNERABLE_DOT)

segnum_t             Believed_player_seg;

}

#endif

namespace dcx {

namespace {

struct robot_to_player_visibility_state

{

        vms_vector vec_to_player;

        player_visibility_state visibility;

        uint8_t initialized = 0;

};

struct awareness_t : std::array<player_awareness_type_t, MAX_SEGMENTS>

{

};

}

}

static int ai_evaded;

// These globals are set by a call to find_vector_intersection, which is a slow routine,

// so we don't want to call it again (for this object) unless we have to.

static vms_vector  Hit_pos;

static int         Hit_type;

static fvi_info    Hit_data;

namespace dcx {

vms_vector      Believed_player_pos;

static bool silly_animation_angle(fixang vms_angvec::*const a, const vms_angvec &jp, const vms_angvec &pobjp, const int flinch_attack_scale, vms_angvec &goal_angles, vms_angvec &delta_angles)

{

        const fix delta_angle = jp.*a - pobjp.*a;

        if (!delta_angle)

                return false;

        goal_angles.*a = jp.*a;

        const fix delta_anim_rate = (delta_angle >= F1_0/2)

                ? -ANIM_RATE

                : (delta_angle >= 0)

                        ? ANIM_RATE

                        : (delta_angle >= -F1_0/2)

                                ? -ANIM_RATE

                                : ANIM_RATE

        ;

        const fix delta_2 = (flinch_attack_scale != 1)

                ? delta_anim_rate * flinch_attack_scale

                : delta_anim_rate;

        delta_angles.*a = delta_2 / DELTA_ANG_SCALE;            // complete revolutions per second

        return true;

}

static void frame_animation_angle(fixang vms_angvec::*const a, const fix frametime, const vms_angvec &deltaang, const vms_angvec &goalang, vms_angvec &curang)

{

        fix delta_to_goal = goalang.*a - curang.*a;

        if (delta_to_goal > 32767)

                delta_to_goal = delta_to_goal - 65536;

        else if (delta_to_goal < -32767)

                delta_to_goal = 65536 + delta_to_goal;

        if (delta_to_goal)

        {

                // Due to deltaang.*a being usually small values and frametime getting smaller with higher FPS, the usual use of fixmul will have scaled_delta_angle result in 0 way too often and long, making the robot animation run circles around itself. So multiply deltaang by DELTA_ANG_SCALE when passed to fixmul.

                const fix scaled_delta_angle = fixmul(deltaang.*a * DELTA_ANG_SCALE, frametime); // fixmul(deltaang.*a, frametime) * DELTA_ANG_SCALE;

                auto &ca = curang.*a;

                if (abs(delta_to_goal) < abs(scaled_delta_angle))

                        ca = goalang.*a;

                else

                        ca += scaled_delta_angle;

        }

}

static void move_toward_vector_component_assign(fix vms_vector::*const p, const vms_vector &vec_goal, const fix frametime32, vms_vector &velocity)

{

        velocity.*p = (velocity.*p / 2) + fixmul(vec_goal.*p, frametime32);

}

static void move_toward_vector_component_add(fix vms_vector::*const p, const vms_vector &vec_goal, const fix frametime64, const fix difficulty_scale, vms_vector &velocity)

{

        velocity.*p += fixmul(vec_goal.*p, frametime64) * difficulty_scale / 4;

}

}

#define AIS_MAX 8

#define AIE_MAX 4

#ifndef NDEBUG

#if PARALLAX

#if defined(DXX_BUILD_DESCENT_I)

// Index into this array with ailp->mode

constexpr char mode_text[][16] = {

        "STILL",

        "WANDER",

        "FOL_PATH",

        "CHASE_OBJ",

        "RUN_FROM",

        "HIDE",

        "FOL_PATH2",

        "OPEN_DOOR",

};

//      Index into this array with aip->behavior

constexpr std::array<char[9], 6> behavior_text{

        "STILL   ",

        "NORMAL  ",

        "HIDE    ",

        "RUN_FROM",

        "FOLPATH ",

        "STATION "

};

#endif

#endif

#endif

// Current state indicates where the robot current is, or has just done.

// Transition table between states for an AI object.

// First dimension is trigger event.

// Second dimension is current state.

// Third dimension is goal state.

// Result is new goal state.

// ERR_ means something impossible has happened.

constexpr int8_t Ai_transition_table[AI_MAX_EVENT][AI_MAX_STATE][AI_MAX_STATE] = {

        {

                // Event = AIE_FIRE, a nearby object fired

                // none     rest      srch      lock      flin      fire      reco        // CURRENT is rows, GOAL is columns

                { AIS_ERR_, AIS_LOCK, AIS_LOCK, AIS_LOCK, AIS_FLIN, AIS_FIRE, AIS_RECO }, // none

                { AIS_ERR_, AIS_LOCK, AIS_LOCK, AIS_LOCK, AIS_FLIN, AIS_FIRE, AIS_RECO }, // rest

                { AIS_ERR_, AIS_LOCK, AIS_LOCK, AIS_LOCK, AIS_FLIN, AIS_FIRE, AIS_RECO }, // search

                { AIS_ERR_, AIS_LOCK, AIS_LOCK, AIS_LOCK, AIS_FLIN, AIS_FIRE, AIS_RECO }, // lock

                { AIS_ERR_, AIS_REST, AIS_LOCK, AIS_LOCK, AIS_LOCK, AIS_FIRE, AIS_RECO }, // flinch

                { AIS_ERR_, AIS_FIRE, AIS_FIRE, AIS_FIRE, AIS_FLIN, AIS_FIRE, AIS_RECO }, // fire

                { AIS_ERR_, AIS_LOCK, AIS_LOCK, AIS_LOCK, AIS_FLIN, AIS_FIRE, AIS_FIRE }  // recoil

        },

        // Event = AIE_HITT, a nearby object was hit (or a wall was hit)

        {

                { AIS_ERR_, AIS_LOCK, AIS_LOCK, AIS_LOCK, AIS_FLIN, AIS_FIRE, AIS_RECO},

                { AIS_ERR_, AIS_LOCK, AIS_LOCK, AIS_LOCK, AIS_FLIN, AIS_FIRE, AIS_RECO},

                { AIS_ERR_, AIS_LOCK, AIS_LOCK, AIS_LOCK, AIS_FLIN, AIS_FIRE, AIS_RECO},

                { AIS_ERR_, AIS_LOCK, AIS_LOCK, AIS_LOCK, AIS_FLIN, AIS_FIRE, AIS_RECO},

                { AIS_ERR_, AIS_LOCK, AIS_LOCK, AIS_LOCK, AIS_LOCK, AIS_FLIN, AIS_FLIN},

                { AIS_ERR_, AIS_REST, AIS_LOCK, AIS_LOCK, AIS_LOCK, AIS_FIRE, AIS_RECO},

                { AIS_ERR_, AIS_LOCK, AIS_LOCK, AIS_LOCK, AIS_FLIN, AIS_FIRE, AIS_FIRE}

        },

        // Event = AIE_COLL, player collided with robot

        {

                { AIS_ERR_, AIS_LOCK, AIS_LOCK, AIS_LOCK, AIS_FLIN, AIS_FIRE, AIS_RECO},

                { AIS_ERR_, AIS_LOCK, AIS_LOCK, AIS_LOCK, AIS_FLIN, AIS_FIRE, AIS_RECO},

                { AIS_ERR_, AIS_LOCK, AIS_LOCK, AIS_LOCK, AIS_FLIN, AIS_FIRE, AIS_RECO},

                { AIS_ERR_, AIS_LOCK, AIS_LOCK, AIS_LOCK, AIS_FLIN, AIS_FIRE, AIS_RECO},

                { AIS_ERR_, AIS_FLIN, AIS_FLIN, AIS_FLIN, AIS_LOCK, AIS_FLIN, AIS_FLIN},

                { AIS_ERR_, AIS_REST, AIS_LOCK, AIS_LOCK, AIS_LOCK, AIS_FIRE, AIS_RECO},

                { AIS_ERR_, AIS_LOCK, AIS_LOCK, AIS_LOCK, AIS_FLIN, AIS_FIRE, AIS_FIRE}

        },

        // Event = AIE_HURT, player hurt robot (by firing at and hitting it)

        // Note, this doesn't necessarily mean the robot JUST got hit, only that that is the most recent thing that happened.

        {

                { AIS_ERR_, AIS_FLIN, AIS_FLIN, AIS_FLIN, AIS_FLIN, AIS_FLIN, AIS_FLIN},

                { AIS_ERR_, AIS_FLIN, AIS_FLIN, AIS_FLIN, AIS_FLIN, AIS_FLIN, AIS_FLIN},

                { AIS_ERR_, AIS_FLIN, AIS_FLIN, AIS_FLIN, AIS_FLIN, AIS_FLIN, AIS_FLIN},

                { AIS_ERR_, AIS_FLIN, AIS_FLIN, AIS_FLIN, AIS_FLIN, AIS_FLIN, AIS_FLIN},

                { AIS_ERR_, AIS_FLIN, AIS_FLIN, AIS_FLIN, AIS_FLIN, AIS_FLIN, AIS_FLIN},

                { AIS_ERR_, AIS_FLIN, AIS_FLIN, AIS_FLIN, AIS_FLIN, AIS_FLIN, AIS_FLIN},

                { AIS_ERR_, AIS_FLIN, AIS_FLIN, AIS_FLIN, AIS_FLIN, AIS_FLIN, AIS_FLIN}

        }

};

namespace dsx {

weapon_id_type get_robot_weapon(const robot_info &ri, const unsigned gun_num)

{

#if defined(DXX_BUILD_DESCENT_I)

        (void)gun_num;

#elif defined(DXX_BUILD_DESCENT_II)

        if (ri.weapon_type2 != weapon_none && !gun_num)

                return ri.weapon_type2;

#endif

        return ri.weapon_type;

}

static int ready_to_fire_weapon1(const ai_local &ailp, fix threshold)

{

        return ailp.next_fire <= threshold;

}

static int ready_to_fire_weapon2(const robot_info &robptr, const ai_local &ailp, fix threshold)

{

#if defined(DXX_BUILD_DESCENT_I)

        (void)robptr;

        (void)ailp;

        (void)threshold;

        return 0;

#elif defined(DXX_BUILD_DESCENT_II)

        if (robptr.weapon_type2 == weapon_none)

                return 0;

        return ailp.next_fire2 <= threshold;

#endif

}

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

// Return firing status.

// If ready to fire a weapon, return true, else return false.

// Ready to fire a weapon if next_fire <= 0 or next_fire2 <= 0.

static int ready_to_fire_any_weapon(const robot_info &robptr, const ai_local &ailp, fix threshold)

{

        return ready_to_fire_weapon1(ailp, threshold) || ready_to_fire_weapon2(robptr, ailp, threshold);

}

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

//      Given a behavior, set initial mode.

ai_mode ai_behavior_to_mode(ai_behavior behavior)

{

        switch (behavior) {

                case ai_behavior::AIB_STILL:

                        return ai_mode::AIM_STILL;

                case ai_behavior::AIB_NORMAL:

                        return ai_mode::AIM_CHASE_OBJECT;

                case ai_behavior::AIB_RUN_FROM:

                        return ai_mode::AIM_RUN_FROM_OBJECT;

                case ai_behavior::AIB_STATION:

                        return ai_mode::AIM_STILL;

#if defined(DXX_BUILD_DESCENT_I)

                case ai_behavior::AIB_HIDE:

                        return ai_mode::AIM_HIDE;

                case ai_behavior::AIB_FOLLOW_PATH:

                        return ai_mode::AIM_FOLLOW_PATH;

#elif defined(DXX_BUILD_DESCENT_II)

                case ai_behavior::AIB_BEHIND:

                        return ai_mode::AIM_BEHIND;

                case ai_behavior::AIB_SNIPE:

                        return ai_mode::AIM_STILL;      //      Changed, 09/13/95, MK, snipers are still until they see you or are hit.

                case ai_behavior::AIB_FOLLOW:

                        return ai_mode::AIM_FOLLOW_PATH;

#endif

                default:        Int3(); //      Contact Mike: Error, illegal behavior type

        }

        return ai_mode::AIM_STILL;

}

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

//      Call every time the player starts a new ship.

void ai_init_boss_for_ship(void)

{

#if defined(DXX_BUILD_DESCENT_II)

        auto &BossUniqueState = LevelUniqueObjectState.BossState;

        BossUniqueState.Boss_hit_time = -F1_0*10;

#endif

}

static void boss_init_all_segments(const segment_array &Segments, const object &boss_objnum)

{

        auto &Boss_gate_segs = LevelSharedBossState.Gate_segs;

        auto &Boss_teleport_segs = LevelSharedBossState.Teleport_segs;

        if (!Boss_teleport_segs.empty())

                return; // already have boss segs

        init_boss_segments(Segments, boss_objnum, Boss_gate_segs, 0, 0);

        init_boss_segments(Segments, boss_objnum, Boss_teleport_segs, 1, 0);

#if defined(DXX_BUILD_DESCENT_II)

        if (Boss_teleport_segs.size() < 2)

                init_boss_segments(Segments, boss_objnum, Boss_teleport_segs, 1, 1);

#endif

}

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

//      initial_mode == -1 means leave mode unchanged.

void init_ai_object(const vmobjptridx_t objp, ai_behavior behavior, const imsegidx_t hide_segment)

{

        auto &BossUniqueState = LevelUniqueObjectState.BossState;

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

        ai_local                *const ailp = &aip->ail;

        *ailp = {};

        if (static_cast<unsigned>(behavior) == 0) {

                behavior = ai_behavior::AIB_NORMAL;

                aip->behavior = behavior;

        }

        //      mode is now set from the Robot dialog, so this should get overwritten.

        ailp->mode = ai_mode::AIM_STILL;

        ailp->previous_visibility = player_visibility_state::no_line_of_sight;

        {

                aip->behavior = behavior;

                ailp->mode = ai_behavior_to_mode(aip->behavior);

        }

        auto &Robot_info = LevelSharedRobotInfoState.Robot_info;

        auto &robptr = Robot_info[get_robot_id(objp)];

#if defined(DXX_BUILD_DESCENT_II)

        if (robot_is_companion(robptr)) {

                auto &BuddyState = LevelUniqueObjectState.BuddyState;

                BuddyState.Buddy_objnum = objp;

                ailp->mode = ai_mode::AIM_GOTO_PLAYER;

        }

        if (robot_is_thief(robptr)) {

                aip->behavior = ai_behavior::AIB_SNIPE;

                ailp->mode = ai_mode::AIM_THIEF_WAIT;

        }

        if (robptr.attack_type) {

                aip->behavior = ai_behavior::AIB_NORMAL;

                ailp->mode = ai_behavior_to_mode(aip->behavior);

        }

#endif

        // This is astonishingly stupid!  This routine gets called by matcens! KILL KILL KILL!!! Point_segs_free_ptr = Point_segs;

        objp->mtype.phys_info.velocity = {};

        ailp->player_awareness_time = 0;

        ailp->player_awareness_type = player_awareness_type_t::PA_NONE;

        aip->GOAL_STATE = AIS_SRCH;

        aip->CURRENT_STATE = AIS_REST;

        ailp->time_player_seen = GameTime64;

        ailp->next_misc_sound_time = GameTime64;

        ailp->time_player_sound_attacked = GameTime64;

        aip->hide_segment = hide_segment;

        ailp->goal_segment = hide_segment;

        aip->hide_index = -1;                   // This means the path has not yet been created.

        aip->cur_path_index = 0;

        aip->SKIP_AI_COUNT = 0;

        if (robptr.cloak_type == RI_CLOAKED_ALWAYS)

                aip->CLOAKED = 1;

        else

                aip->CLOAKED = 0;

        objp->mtype.phys_info.flags |= (PF_BOUNCE | PF_TURNROLL);

        aip->REMOTE_OWNER = -1;

#if defined(DXX_BUILD_DESCENT_II)

        aip->dying_sound_playing = 0;

        aip->dying_start_time = 0;

#endif

        aip->danger_laser_num = object_none;

        if (robptr.boss_flag

#if DXX_USE_EDITOR

                && !EditorWindow

#endif

                )

        {

                BossUniqueState = {};

                boss_init_all_segments(Segments, objp);

        }

}

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

void init_ai_objects(void)

{

        auto &BossUniqueState = LevelUniqueObjectState.BossState;

        auto &Boss_gate_segs = LevelSharedBossState.Gate_segs;

        auto &Boss_teleport_segs = LevelSharedBossState.Teleport_segs;

        auto &Objects = LevelUniqueObjectState.Objects;

        auto &vmobjptridx = Objects.vmptridx;

        Point_segs_free_ptr = Point_segs.begin();

        Boss_gate_segs.clear();

        Boss_teleport_segs.clear();

        range_for (const auto &&o, vmobjptridx)

        {

                auto &obj = *o;

                if (obj.type == OBJ_ROBOT && obj.control_type == CT_AI)

                        init_ai_object(o, obj.ctype.ai_info.behavior, obj.ctype.ai_info.hide_segment);

        }

        BossUniqueState.Boss_dying_sound_playing = 0;

        BossUniqueState.Boss_dying = 0;

        const auto Difficulty_level = GameUniqueState.Difficulty_level;

#define D1_Boss_gate_interval   F1_0*5 - Difficulty_level*F1_0/2

#if defined(DXX_BUILD_DESCENT_I)

        GameUniqueState.Boss_gate_interval = D1_Boss_gate_interval;

#elif defined(DXX_BUILD_DESCENT_II)

        ai_do_cloak_stuff();

        init_buddy_for_level();

        if (EMULATING_D1)

        {

                LevelSharedBossState.Boss_cloak_interval = d_level_shared_boss_state::D1_Boss_cloak_interval::value;

                LevelSharedBossState.Boss_teleport_interval = d_level_shared_boss_state::D1_Boss_teleport_interval::value;

                GameUniqueState.Boss_gate_interval = D1_Boss_gate_interval;

        }

        else

        {

                GameUniqueState.Boss_gate_interval = F1_0*4 - Difficulty_level*i2f(2)/3;

                if (Current_level_num == Last_level)

                {

                LevelSharedBossState.Boss_teleport_interval = F1_0*10;

                LevelSharedBossState.Boss_cloak_interval = F1_0*15;                                     //      Time between cloaks

                } else

                {

                LevelSharedBossState.Boss_teleport_interval = F1_0*7;

                LevelSharedBossState.Boss_cloak_interval = F1_0*10;                                     //      Time between cloaks

                }

        }

#endif

#undef D1_Boss_gate_interval

}

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

void ai_turn_towards_vector(const vms_vector &goal_vector, object_base &objp, fix rate)

{

        //      Not all robots can turn, eg, SPECIAL_REACTOR_ROBOT

        if (rate == 0)

                return;

        if (objp.type == OBJ_ROBOT && (get_robot_id(objp) == BABY_SPIDER_ID)) {

                physics_turn_towards_vector(goal_vector, objp, rate);

                return;

        }

        auto new_fvec = goal_vector;

        const fix dot = vm_vec_dot(goal_vector, objp.orient.fvec);

        if (dot < (F1_0 - FrameTime/2)) {

                fix     new_scale = fixdiv(FrameTime * AI_TURN_SCALE, rate);

                vm_vec_scale(new_fvec, new_scale);

                vm_vec_add2(new_fvec, objp.orient.fvec);

                auto mag = vm_vec_normalize_quick(new_fvec);

                if (mag < F1_0/256) {

                        new_fvec = goal_vector;         //      if degenerate vector, go right to goal

                }

        }

#if defined(DXX_BUILD_DESCENT_II)

        auto &Robot_info = LevelSharedRobotInfoState.Robot_info;

        if (const auto Seismic_tremor_magnitude = LevelUniqueSeismicState.Seismic_tremor_magnitude)

        {

                fix                     scale;

                scale = fixdiv(2*Seismic_tremor_magnitude, Robot_info[get_robot_id(objp)].mass);

                vm_vec_scale_add2(new_fvec, make_random_vector(), scale);

        }

#endif

        vm_vector_2_matrix(objp.orient, new_fvec, nullptr, &objp.orient.rvec);

}

#if defined(DXX_BUILD_DESCENT_I)

static void ai_turn_randomly(const vms_vector &vec_to_player, object_base &obj, const fix rate, const player_visibility_state previous_visibility)

{

        vms_vector      curvec;

        //      Random turning looks too stupid, so 1/4 of time, cheat.

        if (player_is_visible(previous_visibility))

                if (d_rand() > 0x7400) {

                        ai_turn_towards_vector(vec_to_player, obj, rate);

                        return;

                }

//--debug--     if (d_rand() > 0x6000)

//--debug--             Prevented_turns++;

        curvec = obj.mtype.phys_info.rotvel;

        curvec.y += F1_0/64;

        curvec.x += curvec.y/6;

        curvec.y += curvec.z/4;

        curvec.z += curvec.x/10;

        if (abs(curvec.x) > F1_0/8) curvec.x /= 4;

        if (abs(curvec.y) > F1_0/8) curvec.y /= 4;

        if (abs(curvec.z) > F1_0/8) curvec.z /= 4;

        obj.mtype.phys_info.rotvel = curvec;

}

#endif

//      Overall_agitation affects:

//              Widens field of view.  Field of view is in range 0..1 (specified in bitmaps.tbl as N/360 degrees).

//                      Overall_agitation/128 subtracted from field of view, making robots see wider.

//              Increases distance to which robot will search to create path to player by Overall_agitation/8 segments.

//              Decreases wait between fire times by Overall_agitation/64 seconds.

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

//      Returns:

//              0               Player is not visible from object, obstruction or something.

//              1               Player is visible, but not in field of view.

//              2               Player is visible and in field of view.

//      Note: Uses Believed_player_pos as player's position for cloak effect.

//      NOTE: Will destructively modify *pos if *pos is outside the mine.

player_visibility_state player_is_visible_from_object(const vmobjptridx_t objp, vms_vector &pos, const fix field_of_view, const vms_vector &vec_to_player)

{

        fix                     dot;

        fvi_query       fq;

#if defined(DXX_BUILD_DESCENT_II)

        //      Assume that robot's gun tip is in same segment as robot's center.

        if (objp->control_type == CT_AI)

                objp->ctype.ai_info.SUB_FLAGS &= ~SUB_FLAGS_GUNSEG;

#endif

        fq.p0                                           = &pos;

        if ((pos.x != objp->pos.x) || (pos.y != objp->pos.y) || (pos.z != objp->pos.z)) {

                auto &Segments = LevelSharedSegmentState.get_segments();

                const auto &&segnum = find_point_seg(LevelSharedSegmentState, pos, Segments.vcptridx(objp->segnum));

                if (segnum == segment_none) {

                        fq.startseg = objp->segnum;

                        pos = objp->pos;

                        move_towards_segment_center(LevelSharedSegmentState, objp);

                } else

                {

#if defined(DXX_BUILD_DESCENT_II)

                        if (segnum != objp->segnum) {

                                if (objp->control_type == CT_AI)

                                        objp->ctype.ai_info.SUB_FLAGS |= SUB_FLAGS_GUNSEG;

                        }

#endif

                        fq.startseg = segnum;

                }

        } else

                fq.startseg                     = objp->segnum;

        fq.p1                                           = &Believed_player_pos;

        fq.rad                                  = F1_0/4;

        fq.thisobjnum                   = objp;

        fq.ignore_obj_list.first = nullptr;

        fq.flags                                        = FQ_TRANSWALL; // -- Why were we checking objects? | FQ_CHECK_OBJS;            //what about trans walls???

        Hit_type = find_vector_intersection(fq, Hit_data);

        Hit_pos = Hit_data.hit_pnt;

        if (Hit_type == HIT_NONE)

        {

                dot = vm_vec_dot(vec_to_player, objp->orient.fvec);

                if (dot > field_of_view - (Overall_agitation << 9)) {

                        return player_visibility_state::visible_and_in_field_of_view;

                } else {

                        return player_visibility_state::visible_not_in_field_of_view;

                }

        } else {

                return player_visibility_state::no_line_of_sight;

        }

}

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

//      Return 1 if animates, else return 0

static int do_silly_animation(object &objp)

{

        int                             robot_type, gun_num, robot_state;

        polyobj_info    *const pobj_info = &objp.rtype.pobj_info;

        auto &aip = objp.ctype.ai_info;

        int                             num_guns, at_goal;

        int                             attack_type;

        int                             flinch_attack_scale = 1;

        robot_type = get_robot_id(objp);

        auto &Robot_info = LevelSharedRobotInfoState.Robot_info;

        auto &Robot_joints = LevelSharedRobotJointState.Robot_joints;

        auto &robptr = Robot_info[robot_type];

        num_guns = robptr.n_guns;

        attack_type = robptr.attack_type;

        if (num_guns == 0) {

                return 0;

        }

        //      This is a hack.  All positions should be based on goal_state, not GOAL_STATE.

        robot_state = Mike_to_matt_xlate[aip.GOAL_STATE];

        // previous_robot_state = Mike_to_matt_xlate[aip->CURRENT_STATE];

        if (attack_type) // && ((robot_state == AS_FIRE) || (robot_state == AS_RECOIL)))

                flinch_attack_scale = Attack_scale;

        else if ((robot_state == AS_FLINCH) || (robot_state == AS_RECOIL))

                flinch_attack_scale = Flinch_scale;

        at_goal = 1;

        auto &Polygon_models = LevelSharedPolygonModelState.Polygon_models;

        for (gun_num=0; gun_num <= num_guns; gun_num++) {

                const auto &&ras = robot_get_anim_state(Robot_info, Robot_joints, robot_type, gun_num, robot_state);

                auto &ail = aip.ail;

                range_for (auto &jr, ras)

                {

                        unsigned jointnum = jr.jointnum;

                        auto &jp = jr.angles;

                        vms_angvec      *pobjp = &pobj_info->anim_angles[jointnum];

                        if (jointnum >= Polygon_models[objp.rtype.pobj_info.model_num].n_models) {

                                Int3();         // Contact Mike: incompatible data, illegal jointnum, problem in pof file?

                                continue;

                        }

                        auto &goal_angles = ail.goal_angles[jointnum];

                        auto &delta_angles = ail.delta_angles[jointnum];

                        const auto animate_p = silly_animation_angle(&vms_angvec::p, jp, *pobjp, flinch_attack_scale, goal_angles, delta_angles);