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.

*/

/*

 *

 * Code for rendering external scenes

 *

 */

//#define _MARK_ON

#include <algorithm>

#include <stdlib.h>

#include <stdio.h>

#include <string.h>

#include <ctype.h> // for isspace

#include "maths.h"

#include "vecmat.h"

#include "gr.h"

#include "3d.h"

#include "dxxerror.h"

#include "palette.h"

#include "iff.h"

#include "console.h"

#include "texmap.h"

#include "fvi.h"

#include "u_mem.h"

#include "sounds.h"

#include "playsave.h"

#include "inferno.h"

#include "endlevel.h"

#include "object.h"

#include "game.h"

#include "gamepal.h"

#include "screens.h"

#include "gauges.h"

#include "terrain.h"

#include "robot.h"

#include "player.h"

#include "physfsx.h"

#include "bm.h"

#include "gameseg.h"

#include "gameseq.h"

#include "newdemo.h"

#include "gamepal.h"

#include "multi.h"

#include "vclip.h"

#include "fireball.h"

#include "text.h"

#include "digi.h"

#include "songs.h"

#if defined(DXX_BUILD_DESCENT_II)

#include "movie.h"

#endif

#include "render.h"

#include "titles.h"

#include "hudmsg.h"

#if DXX_USE_OGL

#include "ogl_init.h"

#endif

#if DXX_USE_EDITOR

#include "editor/editor.h"

#endif

#include "compiler-range_for.h"

#include "d_enumerate.h"

#include "d_range.h"

#include <iterator>

using std::min;

using std::max;

namespace {

struct flythrough_data

{

        object          *obj;

        vms_angvec      angles;                 //orientation in angles

        vms_vector      step;                           //how far in a second

        vms_vector      angstep;                        //rotation per second

        fix                     speed;                  //how fast object is moving

        vms_vector      headvec;                        //where we want to be pointing

        int                     first_time;             //flag for if first time through

        fix                     offset_frac;    //how far off-center as portion of way

        fix                     offset_dist;    //how far currently off-center

};

#define MAX_FLY_OBJECTS 2

d_unique_endlevel_state UniqueEndlevelState;

}

static std::array<flythrough_data, MAX_FLY_OBJECTS> fly_objects;

//endlevel sequence states

#define EL_OFF                          0               //not in endlevel

#define EL_FLYTHROUGH   1               //auto-flythrough in tunnel

#define EL_LOOKBACK             2               //looking back at player

#define EL_OUTSIDE              3               //flying outside for a while

#define EL_STOPPED              4               //stopped, watching explosion

#define EL_PANNING              5               //panning around, watching player

#define EL_CHASING              6               //chasing player to station

#define SHORT_SEQUENCE  1               //if defined, end sequnce when panning starts

int Endlevel_sequence = 0;

static object *endlevel_camera;

#define FLY_SPEED i2f(50)

static void do_endlevel_flythrough(flythrough_data *flydata);

static void draw_stars(grs_canvas &, const d_unique_endlevel_state::starfield_type &stars);

static int find_exit_side(const object_base &obj);

static void generate_starfield(d_unique_endlevel_state::starfield_type &stars);

static void start_endlevel_flythrough(flythrough_data *flydata,const vmobjptr_t obj,fix speed);

#if defined(DXX_BUILD_DESCENT_II)

constexpr std::array<const char, 24> movie_table{{

        'A','B','C','A',

        'D','F','D','F',

        'G','H','I','G',

        'J','K','L','J',

        'M','O','M','O',

        'P','Q','P','Q'

}};

static int endlevel_movie_played = MOVIE_NOT_PLAYED;

#endif

#define FLY_ACCEL i2f(5)

static fix cur_fly_speed,desired_fly_speed;

static grs_bitmap *satellite_bitmap;

grs_bitmap *terrain_bitmap;     //!!*exit_bitmap,

vms_vector satellite_pos,satellite_upvec;

//!!grs_bitmap **exit_bitmap_list[1];

unsigned exit_modelnum,destroyed_exit_modelnum;

static vms_vector station_pos{0xf8c4<<10,0x3c1c<<12,0x372<<10};

static vms_vector mine_exit_point;

static vms_vector mine_ground_exit_point;

static vms_vector mine_side_exit_point;

static vms_matrix mine_exit_orient;

static int outside_mine;

static grs_main_bitmap terrain_bm_instance, satellite_bm_instance;

//find delta between two angles

static fixang delta_ang(fixang a,fixang b)

{

        fixang delta0,delta1;

        return (abs(delta0 = a - b) < abs(delta1 = b - a)) ? delta0 : delta1;

}

//return though which side of seg0 is seg1

static size_t matt_find_connect_side(const shared_segment &seg0, const vcsegidx_t seg1)

{

        auto &children = seg0.children;

        return std::distance(children.begin(), std::find(children.begin(), children.end(), seg1));

}

#if defined(DXX_BUILD_DESCENT_II)

#define MOVIE_REQUIRED 1

//returns movie played status.  see movie.h

static int start_endlevel_movie()

{

        int r;

        palette_array_t save_pal;

        //Assert(PLAYING_BUILTIN_MISSION); //only play movie for built-in mission

        //Assert(N_MOVIES >= Last_level);

        //Assert(N_MOVIES_SECRET >= -Last_secret_level);

        const auto current_level_num = Current_level_num;

        if (is_SHAREWARE)

                return 0;

        if (!is_D2_OEM)

                if (current_level_num == Last_level)

                        return 1;   //don't play movie

        if (!(current_level_num > 0))

                return 0;       //no escapes for secret level

        char movie_name[] = "ESA.MVE";

        movie_name[2] = movie_table[Current_level_num-1];

        save_pal = gr_palette;

        r=PlayMovie(NULL, movie_name,(Game_mode & GM_MULTI)?0:MOVIE_REQUIRED);

        if (Newdemo_state == ND_STATE_PLAYBACK) {

                set_screen_mode(SCREEN_GAME);

                gr_palette = save_pal;

        }

        return (r);

}

#endif

void free_endlevel_data()

{

        terrain_bm_instance.reset();

        satellite_bm_instance.reset();

        free_light_table();

        free_height_array();

}

static object *external_explosion;

static int ext_expl_playing,mine_destroyed;

static vms_angvec exit_angles={-0xa00,0,0};

vms_matrix surface_orient;

static int endlevel_data_loaded;

static unsigned get_tunnel_length(fvcsegptridx &vcsegptridx, const vcsegptridx_t console_seg, const unsigned exit_console_side)

{

        auto seg = console_seg;

        auto exit_side = exit_console_side;

        unsigned tunnel_length = 0;

        for (;;)

        {

                const auto child = seg->children[exit_side];

                if (child == segment_none)

                        return 0;

                ++tunnel_length;

                if (child == segment_exit)

                {

                        assert(seg == PlayerUniqueEndlevelState.exit_segnum);

                        return tunnel_length;

                }

                const vcsegidx_t old_segidx = seg;

                seg = vcsegptridx(child);

                const auto entry_side = matt_find_connect_side(seg, old_segidx);

                if (entry_side >= Side_opposite.size())

                        return 0;

                exit_side = Side_opposite[entry_side];

        }

}

static vcsegidx_t get_tunnel_transition_segment(const unsigned tunnel_length, const vcsegptridx_t console_seg, const unsigned exit_console_side)

{

        auto seg = console_seg;

        auto exit_side = exit_console_side;

        for (auto i = tunnel_length / 3;; --i)

        {

                /*

                 * If the tunnel ended with segment_none, the caller would have

                 * returned immediately after the prior loop.  If the tunnel

                 * ended with segment_exit, then tunnel_length is the count of

                 * segments to reach the exit.  The termination condition on

                 * this loop quits at (tunnel_length / 3), so the loop will quit

                 * before it reaches segment_exit.

                 */

                const auto child = seg->children[exit_side];

                if (!IS_CHILD(child))

                        /* This is only a sanity check.  It should never execute

                         * unless there is a bug elsewhere.

                         */

                        return seg;

                if (!i)

                        return child;

                const vcsegidx_t old_segidx = seg;

                seg = vcsegptridx(child);

                const auto entry_side = matt_find_connect_side(seg, old_segidx);

                exit_side = Side_opposite[entry_side];

        }

}

namespace dsx {

window_event_result start_endlevel_sequence()

{

        auto &Objects = LevelUniqueObjectState.Objects;

        auto &vmobjptr = Objects.vmptr;

        reset_rear_view(); //turn off rear view if set - NOTE: make sure this happens before we pause demo recording!!

        if (Newdemo_state == ND_STATE_RECORDING)                // stop demo recording

                Newdemo_state = ND_STATE_PAUSED;

        if (Newdemo_state == ND_STATE_PLAYBACK) {               // don't do this if in playback mode

#if defined(DXX_BUILD_DESCENT_II)

                if (PLAYING_BUILTIN_MISSION) // only play movie for built-in mission

                {

                        window_set_visible(Game_wind, 0);       // suspend the game, including drawing

                        start_endlevel_movie();

                        window_set_visible(Game_wind, 1);

                }

                strcpy(last_palette_loaded,"");         //force palette load next time

#endif

                return window_event_result::ignored;

        }

        if (Player_dead_state != player_dead_state::no ||

                (ConsoleObject->flags & OF_SHOULD_BE_DEAD))

                return window_event_result::ignored;                            //don't start if dead!

        con_puts(CON_NORMAL, "You have escaped the mine!");

#if defined(DXX_BUILD_DESCENT_II)

        auto &Robot_info = LevelSharedRobotInfoState.Robot_info;

        //      Dematerialize Buddy!

        range_for (const auto &&objp, vmobjptr)

        {

                if (objp->type == OBJ_ROBOT)

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

                                object_create_explosion(vmsegptridx(objp->segnum), objp->pos, F1_0*7/2, VCLIP_POWERUP_DISAPPEARANCE );

                                objp->flags |= OF_SHOULD_BE_DEAD;

                        }

        }

#endif

        get_local_plrobj().ctype.player_info.homing_object_dist = -F1_0; // Turn off homing sound.

        if (Game_mode & GM_MULTI) {

                multi_send_endlevel_start(multi_endlevel_type::normal);

                multi_do_protocol_frame(1, 1);

        }

#if defined(DXX_BUILD_DESCENT_I)

        if (!endlevel_data_loaded)

#elif defined(DXX_BUILD_DESCENT_II)

        if (PLAYING_BUILTIN_MISSION) // only play movie for built-in mission

                if (!(Game_mode & GM_MULTI))

                {

                        window_set_visible(Game_wind, 0);       // suspend the game, including drawing

                        endlevel_movie_played = start_endlevel_movie();

                        window_set_visible(Game_wind, 1);

                }

        if (!(!(Game_mode & GM_MULTI) && (endlevel_movie_played == MOVIE_NOT_PLAYED) && endlevel_data_loaded))

#endif

        {

                return PlayerFinishedLevel(0);          //done with level

        }

#if defined(DXX_BUILD_DESCENT_II)

        int exit_models_loaded = 0;

        if (Piggy_hamfile_version < 3)

                exit_models_loaded = 1; // built-in for PC shareware

        else

                exit_models_loaded = load_exit_models();

        if (!exit_models_loaded)

                return window_event_result::ignored;

#endif

        {

                //count segments in exit tunnel

                const object_base &console = vmobjptr(ConsoleObject);

                const auto exit_console_side = find_exit_side(console);

                const auto &&console_seg = vcsegptridx(console.segnum);

                const auto tunnel_length = get_tunnel_length(vcsegptridx, console_seg, exit_console_side);

                if (!tunnel_length)

                {

                                return PlayerFinishedLevel(0);          //don't do special sequence

                }

                //now pick transition segnum 1/3 of the way in

                PlayerUniqueEndlevelState.transition_segnum = get_tunnel_transition_segment(tunnel_length, console_seg, exit_console_side);

        }

        if (Game_mode & GM_MULTI) {

                multi_send_endlevel_start(multi_endlevel_type::normal);

                multi_do_protocol_frame(1, 1);

        }

        songs_play_song( SONG_ENDLEVEL, 0 );

        Endlevel_sequence = EL_FLYTHROUGH;

        ConsoleObject->movement_type = MT_NONE;                 //movement handled by flythrough

        ConsoleObject->control_type = CT_NONE;

        Game_suspended |= SUSP_ROBOTS;          //robots don't move

        cur_fly_speed = desired_fly_speed = FLY_SPEED;

        start_endlevel_flythrough(&fly_objects[0], vmobjptr(ConsoleObject), cur_fly_speed);             //initialize

        HUD_init_message_literal(HM_DEFAULT, TXT_EXIT_SEQUENCE );

        outside_mine = ext_expl_playing = 0;

        flash_scale = f1_0;

        generate_starfield(UniqueEndlevelState.stars);

        mine_destroyed=0;

        return window_event_result::handled;

}

}

static vms_angvec player_angles,player_dest_angles;

#ifndef SHORT_SEQUENCE

static vms_angvec camera_desired_angles,camera_cur_angles;

#endif

#define CHASE_TURN_RATE (0x4000/4)              //max turn per second

//returns bitmask of which angles are at dest. bits 0,1,2 = p,b,h

static int chase_angles(vms_angvec *cur_angles,vms_angvec *desired_angles)

{

        vms_angvec delta_angs,alt_angles,alt_delta_angs;

        fix total_delta,alt_total_delta;

        fix frame_turn;

        int mask=0;

        delta_angs.p = desired_angles->p - cur_angles->p;

        delta_angs.h = desired_angles->h - cur_angles->h;

        delta_angs.b = desired_angles->b - cur_angles->b;

        total_delta = abs(delta_angs.p) + abs(delta_angs.b) + abs(delta_angs.h);

        alt_angles.p = f1_0/2 - cur_angles->p;

        alt_angles.b = cur_angles->b + f1_0/2;

        alt_angles.h = cur_angles->h + f1_0/2;

        alt_delta_angs.p = desired_angles->p - alt_angles.p;

        alt_delta_angs.h = desired_angles->h - alt_angles.h;

        alt_delta_angs.b = desired_angles->b - alt_angles.b;

        alt_total_delta = abs(alt_delta_angs.p) + abs(alt_delta_angs.b) + abs(alt_delta_angs.h);

        if (alt_total_delta < total_delta) {

                *cur_angles = alt_angles;

                delta_angs = alt_delta_angs;

        }

        frame_turn = fixmul(FrameTime,CHASE_TURN_RATE);

        if (abs(delta_angs.p) < frame_turn) {

                cur_angles->p = desired_angles->p;

                mask |= 1;

        }

        else

                if (delta_angs.p > 0)

                        cur_angles->p += frame_turn;

                else

                        cur_angles->p -= frame_turn;

        if (abs(delta_angs.b) < frame_turn) {

                cur_angles->b = desired_angles->b;

                mask |= 2;

        }

        else

                if (delta_angs.b > 0)

                        cur_angles->b += frame_turn;

                else

                        cur_angles->b -= frame_turn;

//cur_angles->b = 0;

        if (abs(delta_angs.h) < frame_turn) {

                cur_angles->h = desired_angles->h;

                mask |= 4;

        }

        else

                if (delta_angs.h > 0)

                        cur_angles->h += frame_turn;

                else

                        cur_angles->h -= frame_turn;

        return mask;

}

window_event_result stop_endlevel_sequence()

{

#if !DXX_USE_OGL

        Interpolation_method = 0;

#endif

        select_cockpit(PlayerCfg.CockpitMode[0]);

        Endlevel_sequence = EL_OFF;

        return PlayerFinishedLevel(0);

}

#define VCLIP_BIG_PLAYER_EXPLOSION      58

//--unused-- vms_vector upvec = {0,f1_0,0};

//find the angle between the player's heading & the station

static void get_angs_to_object(vms_angvec &av,const vms_vector &targ_pos,const vms_vector &cur_pos)

{

        const auto tv = vm_vec_sub(targ_pos,cur_pos);

        vm_extract_angles_vector(av,tv);

}

namespace dsx {

window_event_result do_endlevel_frame()

{

        auto &Objects = LevelUniqueObjectState.Objects;

        auto &vmobjptr = Objects.vmptr;

        static fix timer;

        static fix bank_rate;

        static fix explosion_wait1=0;

        static fix explosion_wait2=0;

        static fix ext_expl_halflife;

        auto result = endlevel_move_all_objects();

        if (ext_expl_playing) {

                do_explosion_sequence(vmobjptr(external_explosion));

                if (external_explosion->lifeleft < ext_expl_halflife)

                        mine_destroyed = 1;

                if (external_explosion->flags & OF_SHOULD_BE_DEAD)

                        ext_expl_playing = 0;

        }

        if (cur_fly_speed != desired_fly_speed) {

                fix delta = desired_fly_speed - cur_fly_speed;

                fix frame_accel = fixmul(FrameTime,FLY_ACCEL);

                if (abs(delta) < frame_accel)

                        cur_fly_speed = desired_fly_speed;

                else

                        if (delta > 0)

                                cur_fly_speed += frame_accel;

                        else

                                cur_fly_speed -= frame_accel;

        }

        //do big explosions

        if (!outside_mine) {

                if (Endlevel_sequence==EL_OUTSIDE) {

                        const auto tvec = vm_vec_sub(ConsoleObject->pos,mine_side_exit_point);

                        if (vm_vec_dot(tvec,mine_exit_orient.fvec) > 0) {

                                vms_vector mov_vec;

                                outside_mine = 1;

                                const auto &&exit_segp = vmsegptridx(PlayerUniqueEndlevelState.exit_segnum);

                                const auto &&tobj = object_create_explosion(exit_segp, mine_side_exit_point, i2f(50), VCLIP_BIG_PLAYER_EXPLOSION);

                                if (tobj) {

                                // Move explosion to Viewer to draw it in front of mine exit model

                                vm_vec_normalized_dir_quick(mov_vec,Viewer->pos,tobj->pos);

                                vm_vec_scale_add2(tobj->pos,mov_vec,i2f(30));

                                        external_explosion = tobj;

                                        flash_scale = 0;        //kill lights in mine

                                        ext_expl_halflife = tobj->lifeleft;

                                        ext_expl_playing = 1;

                                }

                                digi_link_sound_to_pos(SOUND_BIG_ENDLEVEL_EXPLOSION, exit_segp, 0, mine_side_exit_point, 0, i2f(3)/4);

                        }

                }

                //do explosions chasing player

                if ((explosion_wait1-=FrameTime) < 0) {

                        static int sound_count;

                        auto tpnt = vm_vec_scale_add(ConsoleObject->pos,ConsoleObject->orient.fvec,-ConsoleObject->size*5);

                        vm_vec_scale_add2(tpnt,ConsoleObject->orient.rvec,(d_rand()-D_RAND_MAX/2)*15);

                        vm_vec_scale_add2(tpnt,ConsoleObject->orient.uvec,(d_rand()-D_RAND_MAX/2)*15);

                        const auto &&segnum = find_point_seg(LevelSharedSegmentState, LevelUniqueSegmentState, tpnt, Segments.vmptridx(ConsoleObject->segnum));

                        if (segnum != segment_none) {

                                object_create_explosion(segnum,tpnt,i2f(20),VCLIP_BIG_PLAYER_EXPLOSION);

                                if (d_rand()<10000 || ++sound_count==7) {               //pseudo-random

                                        digi_link_sound_to_pos( SOUND_TUNNEL_EXPLOSION, segnum, 0, tpnt, 0, F1_0 );

                                        sound_count=0;

                                }

                        }

                        explosion_wait1 = 0x2000 + d_rand()/4;

                }

        }

        //do little explosions on walls

        if (Endlevel_sequence >= EL_FLYTHROUGH && Endlevel_sequence < EL_OUTSIDE)

                if ((explosion_wait2-=FrameTime) < 0) {

                        fvi_query fq;

                        fvi_info hit_data;

                        //create little explosion on wall

                        auto tpnt = vm_vec_copy_scale(ConsoleObject->orient.rvec,(d_rand()-D_RAND_MAX/2)*100);

                        vm_vec_scale_add2(tpnt,ConsoleObject->orient.uvec,(d_rand()-D_RAND_MAX/2)*100);

                        vm_vec_add2(tpnt,ConsoleObject->pos);

                        if (Endlevel_sequence == EL_FLYTHROUGH)

                                vm_vec_scale_add2(tpnt,ConsoleObject->orient.fvec,d_rand()*200);

                        else

                                vm_vec_scale_add2(tpnt,ConsoleObject->orient.fvec,d_rand()*60);

                        //find hit point on wall

                        fq.p0 = &ConsoleObject->pos;

                        fq.p1 = &tpnt;

                        fq.startseg = ConsoleObject->segnum;

                        fq.rad = 0;

                        fq.thisobjnum = object_first;

                        fq.ignore_obj_list.first = nullptr;

                        fq.flags = 0;

                        find_vector_intersection(fq, hit_data);

                        if (hit_data.hit_type==HIT_WALL && hit_data.hit_seg!=segment_none)

                                object_create_explosion(vmsegptridx(hit_data.hit_seg), hit_data.hit_pnt, i2f(3) + d_rand() * 6, VCLIP_SMALL_EXPLOSION);

                        explosion_wait2 = (0xa00 + d_rand()/8)/2;

                }

        switch (Endlevel_sequence) {

                case EL_OFF: return result;

                case EL_FLYTHROUGH: {

                        do_endlevel_flythrough(&fly_objects[0]);

                        if (ConsoleObject->segnum == PlayerUniqueEndlevelState.transition_segnum)

                        {

#if defined(DXX_BUILD_DESCENT_II)

                                if (PLAYING_BUILTIN_MISSION && endlevel_movie_played != MOVIE_NOT_PLAYED)

                                        result = std::max(stop_endlevel_sequence(), result);

                                else

#endif

                                {

                                        //songs_play_song( SONG_ENDLEVEL, 0 );

                                        Endlevel_sequence = EL_LOOKBACK;

                                        auto objnum = obj_create(OBJ_CAMERA, 0,

                                                            vmsegptridx(ConsoleObject->segnum), ConsoleObject->pos, &ConsoleObject->orient, 0,

                                                            CT_NONE,MT_NONE,RT_NONE);

                                        if (objnum == object_none) { //can't get object, so abort

                                                return std::max(stop_endlevel_sequence(), result);

                                        }

                                        Viewer = endlevel_camera = objnum;

                                        select_cockpit(CM_LETTERBOX);

                                        fly_objects[1] = fly_objects[0];

                                        fly_objects[1].obj = endlevel_camera;

                                        fly_objects[1].speed = (5*cur_fly_speed)/4;

                                        fly_objects[1].offset_frac = 0x4000;

                                        vm_vec_scale_add2(endlevel_camera->pos,endlevel_camera->orient.fvec,i2f(7));

                                        timer=0x20000;

                                }

                        }

                        break;

                }

                case EL_LOOKBACK: {

                        do_endlevel_flythrough(&fly_objects[0]);

                        do_endlevel_flythrough(&fly_objects[1]);

                        if (timer>0) {

                                timer -= FrameTime;

                                if (timer < 0)          //reduce speed

                                        fly_objects[1].speed = fly_objects[0].speed;

                        }

                        if (endlevel_camera->segnum == PlayerUniqueEndlevelState.exit_segnum)

                        {

                                Endlevel_sequence = EL_OUTSIDE;

                                timer = i2f(2);

                                vm_vec_negate(endlevel_camera->orient.fvec);

                                vm_vec_negate(endlevel_camera->orient.rvec);

                                const auto cam_angles = vm_extract_angles_matrix(endlevel_camera->orient);

                                const auto exit_seg_angles = vm_extract_angles_matrix(mine_exit_orient);

                                bank_rate = (-exit_seg_angles.b - cam_angles.b)/2;

                                ConsoleObject->control_type = endlevel_camera->control_type = CT_NONE;

                        }

                        break;

                }

                case EL_OUTSIDE: {

                        vm_vec_scale_add2(ConsoleObject->pos,ConsoleObject->orient.fvec,fixmul(FrameTime,cur_fly_speed));

                        vm_vec_scale_add2(endlevel_camera->pos,endlevel_camera->orient.fvec,fixmul(FrameTime,-2*cur_fly_speed));

                        vm_vec_scale_add2(endlevel_camera->pos,endlevel_camera->orient.uvec,fixmul(FrameTime,-cur_fly_speed/10));

                        auto cam_angles = vm_extract_angles_matrix(endlevel_camera->orient);

                        cam_angles.b += fixmul(bank_rate,FrameTime);

                        vm_angles_2_matrix(endlevel_camera->orient,cam_angles);

                        timer -= FrameTime;

                        if (timer < 0) {

                                Endlevel_sequence = EL_STOPPED;

                                vm_extract_angles_matrix(player_angles,ConsoleObject->orient);

                                timer = i2f(3);

                        }

                        break;

                }

                case EL_STOPPED: {

                        get_angs_to_object(player_dest_angles,station_pos,ConsoleObject->pos);

                        chase_angles(&player_angles,&player_dest_angles);

                        vm_angles_2_matrix(ConsoleObject->orient,player_angles);

                        vm_vec_scale_add2(ConsoleObject->pos,ConsoleObject->orient.fvec,fixmul(FrameTime,cur_fly_speed));

                        timer -= FrameTime;

                        if (timer < 0) {

                                #ifdef SHORT_SEQUENCE

                                result = std::max(stop_endlevel_sequence(), result);

                                #else

                                Endlevel_sequence = EL_PANNING;

                                vm_extract_angles_matrix(camera_cur_angles,endlevel_camera->orient);

                                timer = i2f(3);

                                if (Game_mode & GM_MULTI) { // try to skip part of the seq if multiplayer

                                        result = std::max(stop_endlevel_sequence(), result);

                                        return result;

                                }

                                #endif          //SHORT_SEQUENCE

                        }

                        break;

                }

                #ifndef SHORT_SEQUENCE

                case EL_PANNING: {

                        int mask;

                        get_angs_to_object(player_dest_angles,station_pos,ConsoleObject->pos);

                        chase_angles(&player_angles,&player_dest_angles);

                        vm_angles_2_matrix(ConsoleObject->orient,player_angles);

                        vm_vec_scale_add2(ConsoleObject->pos,ConsoleObject->orient.fvec,fixmul(FrameTime,cur_fly_speed));

                        get_angs_to_object(camera_desired_angles,ConsoleObject->pos,endlevel_camera->pos);

                        mask = chase_angles(&camera_cur_angles,&camera_desired_angles);

                        vm_angles_2_matrix(endlevel_camera->orient,camera_cur_angles);

                        if ((mask&5) == 5) {

                                vms_vector tvec;

                                Endlevel_sequence = EL_CHASING;

                                vm_vec_normalized_dir_quick(tvec,station_pos,ConsoleObject->pos);

                                vm_vector_2_matrix(ConsoleObject->orient,tvec,&surface_orient.uvec,nullptr);

                                desired_fly_speed *= 2;

                        }