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.

*/

/*

 *

 * New Triggers and Switches.

 *

 */

#include <stdexcept>

#include <stdio.h>

#include <stdlib.h>

#include <math.h>

#include <string.h>

#include "gauges.h"

#include "newmenu.h"

#include "game.h"

#include "switch.h"

#include "inferno.h"

#include "segment.h"

#include "dxxerror.h"

#include "gameseg.h"

#include "wall.h"

#include "texmap.h"

#include "object.h"

#include "fuelcen.h"

#include "cntrlcen.h"

#include "newdemo.h"

#include "player.h"

#include "endlevel.h"

#include "gameseq.h"

#include "multi.h"

#include "palette.h"

#include "hudmsg.h"

#include "robot.h"

#include "bm.h"

#if DXX_USE_EDITOR

#include "editor/editor.h"

#endif

#include "physfs-serial.h"

#include "compiler-range_for.h"

#include "partial_range.h"

#if DXX_USE_EDITOR

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

// Initializes all the switches.

void trigger_init()

{

        auto &Triggers = LevelUniqueWallSubsystemState.Triggers;

        Triggers.set_count(0);

}

#endif

template <typename SF, typename O, typename... Oa>

static inline void trigger_wall_op(const trigger &t, SF &segment_factory, const O &op, Oa &&... oargs)

{

        for (unsigned i = 0, num_links = t.num_links; i != num_links; ++i)

                op(std::forward<Oa>(oargs)..., segment_factory(t.seg[i]), t.side[i]);

}

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

// Executes a link, attached to a trigger.

// Toggles all walls linked to the switch.

// Opens doors, Blasts blast walls, turns off illusions.

static void do_link(const trigger &t)

{

        auto &Walls = LevelUniqueWallSubsystemState.Walls;

        auto &vmwallptr = Walls.vmptr;

        trigger_wall_op(t, vmsegptridx, wall_toggle, vmwallptr);

}

#if defined(DXX_BUILD_DESCENT_II)

namespace dsx {

//close a door

static void do_close_door(const trigger &t)

{

        auto &Walls = LevelUniqueWallSubsystemState.Walls;

        trigger_wall_op(t, vmsegptridx, wall_close_door, Walls);

}

//turns lighting on.  returns true if lights were actually turned on. (they

//would not be if they had previously been shot out).

static int do_light_on(const d_level_shared_destructible_light_state &LevelSharedDestructibleLightState, const d_level_unique_tmap_info_state::TmapInfo_array &TmapInfo, d_flickering_light_state &Flickering_light_state, const trigger &t)

{

        int ret=0;

        const auto op = [&LevelSharedDestructibleLightState, &Flickering_light_state, &TmapInfo, &ret](const vmsegptridx_t segnum, const unsigned sidenum) {

                        //check if tmap2 casts light before turning the light on.  This

                        //is to keep us from turning on blown-out lights

                        if (TmapInfo[segnum->unique_segment::sides[sidenum].tmap_num2 & 0x3fff].lighting) {

                                ret |= add_light(LevelSharedDestructibleLightState, segnum, sidenum);           //any light sets flag

                                enable_flicker(Flickering_light_state, segnum, sidenum);

                        }

        };

        trigger_wall_op(t, vmsegptridx, op);

        return ret;

}

//turns lighting off.  returns true if lights were actually turned off. (they

//would not be if they had previously been shot out).

static int do_light_off(const d_level_shared_destructible_light_state &LevelSharedDestructibleLightState, const d_level_unique_tmap_info_state::TmapInfo_array &TmapInfo, d_flickering_light_state &Flickering_light_state, const trigger &t)

{

        int ret=0;

        const auto op = [&LevelSharedDestructibleLightState, &Flickering_light_state, &TmapInfo, &ret](const vmsegptridx_t segnum, const unsigned sidenum) {

                        //check if tmap2 casts light before turning the light off.  This

                        //is to keep us from turning off blown-out lights

                        if (TmapInfo[segnum->unique_segment::sides[sidenum].tmap_num2 & 0x3fff].lighting) {

                                ret |= subtract_light(LevelSharedDestructibleLightState, segnum, sidenum);      //any light sets flag

                                disable_flicker(Flickering_light_state, segnum, sidenum);

                        }

        };

        trigger_wall_op(t, vmsegptridx, op);

        return ret;

}

// Unlocks all doors linked to the switch.

static void do_unlock_doors(fvcsegptr &vcsegptr, fvmwallptr &vmwallptr, const trigger &t)

{

        const auto op = [&vmwallptr](const shared_segment &segp, const unsigned sidenum) {

                const auto wall_num = segp.sides[sidenum].wall_num;

                auto &w = *vmwallptr(wall_num);

                w.flags &= ~WALL_DOOR_LOCKED;

                w.keys = KEY_NONE;

        };

        trigger_wall_op(t, vcsegptr, op);

}

// Locks all doors linked to the switch.

static void do_lock_doors(fvcsegptr &vcsegptr, fvmwallptr &vmwallptr, const trigger &t)

{

        const auto op = [&vmwallptr](const shared_segment &segp, const unsigned sidenum) {

                const auto wall_num = segp.sides[sidenum].wall_num;

                auto &w = *vmwallptr(wall_num);

                w.flags |= WALL_DOOR_LOCKED;

        };

        trigger_wall_op(t, vcsegptr, op);

}

// Changes walls pointed to by a trigger. returns true if any walls changed

static int do_change_walls(const trigger &t, const uint8_t new_wall_type)

{

        auto &LevelSharedVertexState = LevelSharedSegmentState.get_vertex_state();

        auto &Objects = LevelUniqueObjectState.Objects;

        auto &Vertices = LevelSharedVertexState.get_vertices();

        auto &vmobjptr = Objects.vmptr;

        int ret=0;

        auto &TmapInfo = LevelUniqueTmapInfoState.TmapInfo;

        auto &Walls = LevelUniqueWallSubsystemState.Walls;

        auto &vmwallptr = Walls.vmptr;

        for (unsigned i = 0; i < t.num_links; ++i)

        {

                uint8_t cside;

                const auto &&segp = vmsegptridx(t.seg[i]);

                const auto side = t.side[i];

                        imsegptridx_t csegp = segment_none;

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

                        {

                                cside = side_none;

                        }

                        else

                        {

                                csegp = imsegptridx(segp->children[side]);

                                cside = find_connect_side(segp, csegp);

                                Assert(cside != side_none);

                        }

                        wall *w0p;

                        const auto w0num = segp->shared_segment::sides[side].wall_num;

                        if (const auto &&uw0p = vmwallptr.check_untrusted(w0num))

                                w0p = *uw0p;

                        else

                        {

                                LevelError("trigger %p link %u tried to open segment %hu, side %u which is an invalid wall; ignoring.", std::addressof(t), i, static_cast<segnum_t>(segp), side);

                                continue;

                        }

                        auto &wall0 = *w0p;

                        imwallptr_t wall1 = nullptr;

                        if ((cside == side_none || csegp->shared_segment::sides[cside].wall_num == wall_none ||

                                (wall1 = vmwallptr(csegp->shared_segment::sides[cside].wall_num))->type == new_wall_type) &&

                                wall0.type == new_wall_type)

                                continue;               //already in correct state, so skip

                        ret |= 1;

                        auto &vcvertptr = Vertices.vcptr;

                        switch (t.type)

                        {

                                case trigger_action::open_wall:

                                        if ((TmapInfo[segp->unique_segment::sides[side].tmap_num].flags & TMI_FORCE_FIELD)) {

                                                ret |= 2;

                                                const auto &&pos = compute_center_point_on_side(vcvertptr, segp, side);

                                                digi_link_sound_to_pos( SOUND_FORCEFIELD_OFF, segp, side, pos, 0, F1_0 );

                                                digi_kill_sound_linked_to_segment(segp,side,SOUND_FORCEFIELD_HUM);

                                                wall0.type = new_wall_type;

                                                if (wall1)

                                                {

                                                        wall1->type = new_wall_type;

                                                        digi_kill_sound_linked_to_segment(csegp, cside, SOUND_FORCEFIELD_HUM);

                                                }

                                        }

                                        else

                                                start_wall_cloak(segp,side);

                                        break;

                                case trigger_action::close_wall:

                                        if ((TmapInfo[segp->unique_segment::sides[side].tmap_num].flags & TMI_FORCE_FIELD)) {

                                                ret |= 2;

                                                {

                                                const auto &&pos = compute_center_point_on_side(vcvertptr, segp, side);

                                                digi_link_sound_to_pos(SOUND_FORCEFIELD_HUM,segp,side,pos,1, F1_0/2);

                                                }

                                        case trigger_action::illusory_wall:

                                                wall0.type = new_wall_type;

                                                if (wall1)

                                                        wall1->type = new_wall_type;

                                        }

                                        else

                                                start_wall_decloak(segp,side);

                                        break;

                                default:

                                        return 0;

                        }

                        LevelUniqueStuckObjectState.kill_stuck_objects(vmobjptr, segp->shared_segment::sides[side].wall_num);

                        if (wall1)

                                LevelUniqueStuckObjectState.kill_stuck_objects(vmobjptr, csegp->shared_segment::sides[cside].wall_num);

        }

        flush_fcd_cache();

        return ret;

}

#define print_trigger_message(pnum,trig,shot,message)   \

        ((void)((print_trigger_message(pnum,trig,shot)) &&              \

                HUD_init_message(HM_DEFAULT, message, &"s"[trig.num_links <= 1])))

static int (print_trigger_message)(int pnum, const trigger &t, int shot)

 {

        if (shot && pnum == Player_num && !(t.flags & trigger_behavior_flags::no_message))

                return 1;

        return 0;

 }

}

#endif

static void do_matcen(const trigger &t)

{

        range_for (auto &i, partial_const_range(t.seg, t.num_links))

                trigger_matcen(vmsegptridx(i));

}

static void do_il_on(fvcsegptridx &vcsegptridx, fvmwallptr &vmwallptr, const trigger &t)

{

        trigger_wall_op(t, vcsegptridx, wall_illusion_on, vmwallptr);

}

namespace dsx {

#if defined(DXX_BUILD_DESCENT_I)

static void do_il_off(fvcsegptridx &vcsegptridx, fvmwallptr &vmwallptr, const trigger &t)

{

        trigger_wall_op(t, vcsegptridx, wall_illusion_off, vmwallptr);

}

#elif defined(DXX_BUILD_DESCENT_II)

static void do_il_off(fvcsegptridx &vcsegptridx, fvcvertptr &vcvertptr, fvmwallptr &vmwallptr, const trigger &t)

{

        const auto &&op = [&vcvertptr, &vmwallptr](const vcsegptridx_t seg, const unsigned side) {

                wall_illusion_off(vmwallptr, seg, side);

                const auto &&cp = compute_center_point_on_side(vcvertptr, seg, side);

                digi_link_sound_to_pos(SOUND_WALL_REMOVED, seg, side, cp, 0, F1_0);

        };

        trigger_wall_op(t, vcsegptridx, op);

}

#endif

// Slight variation on window_event_result meaning

// 'ignored' means we still want check_trigger to call multi_send_trigger

// 'handled' or 'close' means we don't

// 'close' will still close the game window

window_event_result check_trigger_sub(object &plrobj, const trgnum_t trigger_num, const playernum_t pnum, const unsigned shot)

{

#if defined(DXX_BUILD_DESCENT_II)

        auto &LevelSharedVertexState = LevelSharedSegmentState.get_vertex_state();

        auto &Vertices = LevelSharedVertexState.get_vertices();

#endif

        auto &LevelUniqueControlCenterState = LevelUniqueObjectState.ControlCenterState;

        auto result = window_event_result::ignored;

        if ((Game_mode & GM_MULTI) && vcplayerptr(pnum)->connected != CONNECT_PLAYING) // as a host we may want to handle triggers for our clients. to do that properly we must check wether we (host) or client is actually playing.

                return window_event_result::handled;

        auto &Triggers = LevelUniqueWallSubsystemState.Triggers;

        auto &vmtrgptr = Triggers.vmptr;

        auto &trigger = *vmtrgptr(trigger_num);

        auto &Walls = LevelUniqueWallSubsystemState.Walls;

        auto &vmwallptr = Walls.vmptr;

#if defined(DXX_BUILD_DESCENT_I)

        (void)shot;

        if (pnum == Player_num) {

                auto &player_info = plrobj.ctype.player_info;

                if (trigger.flags & TRIGGER_SHIELD_DAMAGE) {

                        plrobj.shields -= trigger.value;

                }

                if (trigger.flags & TRIGGER_EXIT)

                {

                        result = start_endlevel_sequence();

                        if (result == window_event_result::handled)

                                result = window_event_result::ignored;  // call multi_send_trigger, or end game anyway

                }

                if (trigger.flags & TRIGGER_SECRET_EXIT) {

                        if (trigger.flags & TRIGGER_EXIT)

                                LevelError("Trigger %u is both a regular and secret exit! This is not a recommended combination.", trigger_num);

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

                                Newdemo_state = ND_STATE_PAUSED;

                        if (Game_mode & GM_MULTI)

                                multi_send_endlevel_start(multi_endlevel_type::secret);

                        if (Game_mode & GM_NETWORK)

                                multi_do_protocol_frame(1, 1);

                        result = std::max(PlayerFinishedLevel(1), result);              //1 means go to secret level

                        LevelUniqueControlCenterState.Control_center_destroyed = 0;

                        return std::max(result, window_event_result::handled);

                }

                if (trigger.flags & TRIGGER_ENERGY_DRAIN) {

                        player_info.energy -= trigger.value;

                }

        }

        if (trigger.flags & TRIGGER_CONTROL_DOORS) {

                do_link(trigger);

        }

        if (trigger.flags & TRIGGER_MATCEN) {

                if (!(Game_mode & GM_MULTI) || (Game_mode & GM_MULTI_ROBOTS))

                        do_matcen(trigger);

        }

        if (trigger.flags & TRIGGER_ILLUSION_ON) {

                do_il_on(vcsegptridx, vmwallptr, trigger);

        }

        if (trigger.flags & TRIGGER_ILLUSION_OFF) {

                do_il_off(vcsegptridx, vmwallptr, trigger);

        }

#elif defined(DXX_BUILD_DESCENT_II)

        if (trigger.flags & trigger_behavior_flags::disabled)

                return window_event_result::handled;            // don't send trigger hit to other players

        if (trigger.flags & trigger_behavior_flags::one_shot)           //if this is a one-shot...

                trigger.flags |= trigger_behavior_flags::disabled;              //..then don't let it happen again

        auto &LevelSharedDestructibleLightState = LevelSharedSegmentState.DestructibleLights;

        auto &TmapInfo = LevelUniqueTmapInfoState.TmapInfo;

        auto &vcvertptr = Vertices.vcptr;

        switch (trigger.type)

        {

                case trigger_action::normal_exit:

                        if (pnum!=Player_num)

                                break;

                        if (!EMULATING_D1)

                                digi_stop_digi_sounds();  //Sound shouldn't cut out when exiting a D1 lvl

                        if (Current_level_num > 0) {

                                result = start_endlevel_sequence();

                        } else if (Current_level_num < 0) {

                                if (plrobj.shields < 0 ||

                                        Player_dead_state != player_dead_state::no)

                                        break;

                                // NMN 04/09/07 Do endlevel movie if we are

                                //             playing a D1 secret level

                                if (EMULATING_D1)

                                {

                                        result = start_endlevel_sequence();

                                } else {

                                        result = ExitSecretLevel();

                                }

                                return std::max(result, window_event_result::handled);

                        } else {

#if DXX_USE_EDITOR

                                        nm_messagebox_str( "Yo!", "You have hit the exit trigger!", "" );

                                #else

                                        Int3();         //level num == 0, but no editor!

                                #endif

                        }

                        return std::max(result, window_event_result::handled);

                        break;

                case trigger_action::secret_exit: {

                        int     truth;

                        if (pnum!=Player_num)

                                break;

                        if (plrobj.shields < 0 ||

                                Player_dead_state != player_dead_state::no)

                                break;

                        if (is_SHAREWARE || is_MAC_SHARE) {

                                HUD_init_message_literal(HM_DEFAULT, "Secret Level Teleporter disabled in Descent 2 Demo");

                                digi_play_sample( SOUND_BAD_SELECTION, F1_0 );

                                break;

                        }

                        if (Game_mode & GM_MULTI) {

                                HUD_init_message_literal(HM_DEFAULT, "Secret Level Teleporter disabled in multiplayer!");

                                digi_play_sample( SOUND_BAD_SELECTION, F1_0 );

                                break;

                        }

                        truth = p_secret_level_destroyed();

                        if (Newdemo_state == ND_STATE_RECORDING)                        // record whether we're really going to the secret level

                                newdemo_record_secret_exit_blown(truth);

                        if ((Newdemo_state != ND_STATE_PLAYBACK) && truth) {

                                HUD_init_message_literal(HM_DEFAULT, "Secret Level destroyed.  Exit disabled.");

                                digi_play_sample( SOUND_BAD_SELECTION, F1_0 );

                                break;

                        }

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

                                Newdemo_state = ND_STATE_PAUSED;

                        digi_stop_digi_sounds();

                        EnterSecretLevel();

                        LevelUniqueControlCenterState.Control_center_destroyed = 0;

                        return window_event_result::handled;

                }

                case trigger_action::open_door:

                        do_link(trigger);

                        print_trigger_message(pnum, trigger, shot, "Door%s opened!");

                        break;

                case trigger_action::close_door:

                        do_close_door(trigger);

                        print_trigger_message(pnum, trigger, shot, "Door%s closed!");

                        break;

                case trigger_action::unlock_door:

                        do_unlock_doors(vcsegptr, vmwallptr, trigger);

                        print_trigger_message(pnum, trigger, shot, "Door%s unlocked!");

                        break;

                case trigger_action::lock_door:

                        do_lock_doors(vcsegptr, vmwallptr, trigger);

                        print_trigger_message(pnum, trigger, shot, "Door%s locked!");

                        break;

                case trigger_action::open_wall:

                        if (const auto w = do_change_walls(trigger, WALL_OPEN))

                                print_trigger_message(pnum, trigger, shot, (w & 2) ? "Force field%s deactivated!" : "Wall%s opened!");

                        break;

                case trigger_action::close_wall:

                        if (const auto w = do_change_walls(trigger, WALL_CLOSED))

                                print_trigger_message(pnum, trigger, shot, (w & 2) ? "Force field%s activated!" : "Wall%s closed!");

                        break;

                case trigger_action::illusory_wall:

                        //don't know what to say, so say nothing

                        do_change_walls(trigger, WALL_ILLUSION);

                        break;

                case trigger_action::matcen:

                        if (!(Game_mode & GM_MULTI) || (Game_mode & GM_MULTI_ROBOTS))

                                do_matcen(trigger);

                        break;

                case trigger_action::illusion_on:

                        do_il_on(vcsegptridx, vmwallptr, trigger);

                        print_trigger_message(pnum, trigger, shot, "Illusion%s on!");

                        break;

                case trigger_action::illusion_off:

                        do_il_off(vcsegptridx, vcvertptr, vmwallptr, trigger);

                        print_trigger_message(pnum, trigger, shot, "Illusion%s off!");

                        break;

                case trigger_action::light_off:

                        if (do_light_off(LevelSharedDestructibleLightState, TmapInfo, Flickering_light_state, trigger))

                                print_trigger_message(pnum, trigger, shot, "Light%s off!");

                        break;

                case trigger_action::light_on:

                        if (do_light_on(LevelSharedDestructibleLightState, TmapInfo, Flickering_light_state, trigger))

                                print_trigger_message(pnum, trigger, shot, "Light%s on!");

                        break;

                default:

                        Int3();

                        break;

        }

#endif

        return result;

}

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

// Checks for a trigger whenever an object hits a trigger side.

window_event_result check_trigger(const vcsegptridx_t seg, const unsigned side, object &plrobj, const vcobjptridx_t objnum, int shot)

{

        if ((Game_mode & GM_MULTI) && (get_local_player().connected != CONNECT_PLAYING)) // as a host we may want to handle triggers for our clients. so this function may be called when we are not playing.

                return window_event_result::ignored;

#if defined(DXX_BUILD_DESCENT_I)

        if (objnum == &plrobj)

#elif defined(DXX_BUILD_DESCENT_II)

        auto &Robot_info = LevelSharedRobotInfoState.Robot_info;

        if (objnum == &plrobj || (objnum->type == OBJ_ROBOT && Robot_info[get_robot_id(objnum)].companion))

#endif

        {

#if defined(DXX_BUILD_DESCENT_I)

                if ( Newdemo_state == ND_STATE_PLAYBACK )

                        return window_event_result::ignored;

#elif defined(DXX_BUILD_DESCENT_II)

                if ( Newdemo_state == ND_STATE_RECORDING )

                        newdemo_record_trigger( seg, side, objnum,shot);

#endif

                const auto wall_num = seg->shared_segment::sides[side].wall_num;

                if ( wall_num == wall_none ) return window_event_result::ignored;

                auto &Walls = LevelUniqueWallSubsystemState.Walls;

                auto &vcwallptr = Walls.vcptr;

                const auto trigger_num = vcwallptr(wall_num)->trigger;

                if (trigger_num == trigger_none)

                        return window_event_result::ignored;

                {

                        auto result = check_trigger_sub(plrobj, trigger_num, Player_num,shot);

                        if (result != window_event_result::ignored)

                                return result;

                }

                if (Game_mode & GM_MULTI)

                        multi_send_trigger(trigger_num);

        }

        return window_event_result::handled;

}

/*

 * reads a v29_trigger structure from a PHYSFS_File

 */

#if defined(DXX_BUILD_DESCENT_I)

void v26_trigger_read(PHYSFS_File *fp, trigger &t)

{

        switch (const auto type = static_cast<trigger_action>(PHYSFSX_readByte(fp)))

        {

                case trigger_action::open_door: // door

                        t.flags = TRIGGER_CONTROL_DOORS;

                        break;

                case trigger_action::matcen: // matcen

                        t.flags = TRIGGER_MATCEN;

                        break;

                case trigger_action::normal_exit: // exit

                        t.flags = TRIGGER_EXIT;

                        break;

                case trigger_action::secret_exit: // secret exit

                        t.flags = TRIGGER_SECRET_EXIT;

                        break;

                case trigger_action::illusion_off: // illusion off

                        t.flags = TRIGGER_ILLUSION_OFF;

                        break;

                case trigger_action::illusion_on: // illusion on

                        t.flags = TRIGGER_ILLUSION_ON;

                        break;

                default:

                        con_printf(CON_URGENT, "error: unsupported trigger type %d", static_cast<int>(type));

                        throw std::runtime_error("unsupported trigger type");

        }

        if (PHYSFSX_readByte(fp) & 2)   // one shot

                t.flags |= TRIGGER_ONE_SHOT;

        t.num_links = PHYSFSX_readShort(fp);

        t.value = PHYSFSX_readInt(fp);

        PHYSFSX_readInt(fp);

        for (unsigned i=0; i < MAX_WALLS_PER_LINK; i++ )

                t.seg[i] = PHYSFSX_readShort(fp);

        for (unsigned i=0; i < MAX_WALLS_PER_LINK; i++ )

                t.side[i] = PHYSFSX_readShort(fp);

}

void v25_trigger_read(PHYSFS_File *fp, trigger *t)

#elif defined(DXX_BUILD_DESCENT_II)

extern void v29_trigger_read(v29_trigger *t, PHYSFS_File *fp)

#endif

{

#if defined(DXX_BUILD_DESCENT_I)

        PHYSFSX_readByte(fp);

#elif defined(DXX_BUILD_DESCENT_II)

        t->type = PHYSFSX_readByte(fp);

#endif

        t->flags = PHYSFSX_readShort(fp);

        t->value = PHYSFSX_readFix(fp);

        PHYSFSX_readFix(fp);

        PHYSFSX_readByte(fp);

        t->num_links = PHYSFSX_readShort(fp);

        for (unsigned i=0; i<MAX_WALLS_PER_LINK; i++ )

                t->seg[i] = PHYSFSX_readShort(fp);

        for (unsigned i=0; i<MAX_WALLS_PER_LINK; i++ )

                t->side[i] = PHYSFSX_readShort(fp);

}

#if defined(DXX_BUILD_DESCENT_II)

/*

 * reads a v30_trigger structure from a PHYSFS_File

 */

extern void v30_trigger_read(v30_trigger *t, PHYSFS_File *fp)

{

        t->flags = PHYSFSX_readShort(fp);

        t->num_links = PHYSFSX_readByte(fp);

        t->pad = PHYSFSX_readByte(fp);

        t->value = PHYSFSX_readFix(fp);

        t->time = PHYSFSX_readFix(fp);

        for (unsigned i=0; i<MAX_WALLS_PER_LINK; i++ )

                t->seg[i] = PHYSFSX_readShort(fp);

        for (unsigned i=0; i<MAX_WALLS_PER_LINK; i++ )

                t->side[i] = PHYSFSX_readShort(fp);

}

/*

 * reads a trigger structure from a PHYSFS_File

 */

extern void trigger_read(trigger *t, PHYSFS_File *fp)

{

        t->type = trigger_action{static_cast<uint8_t>(PHYSFSX_readByte(fp))};

        t->flags = trigger_behavior_flags{static_cast<uint8_t>(PHYSFSX_readByte(fp))};

        t->num_links = PHYSFSX_readByte(fp);

        PHYSFSX_readByte(fp);

        t->value = PHYSFSX_readFix(fp);

        PHYSFSX_readFix(fp);

        for (unsigned i=0; i<MAX_WALLS_PER_LINK; i++ )

                t->seg[i] = PHYSFSX_readShort(fp);

        for (unsigned i=0; i<MAX_WALLS_PER_LINK; i++ )

                t->side[i] = PHYSFSX_readShort(fp);

}

static trigger_action trigger_type_from_flags(short flags)

{

        if (flags & TRIGGER_CONTROL_DOORS)

                return trigger_action::open_door;

        else if (flags & (TRIGGER_SHIELD_DAMAGE | TRIGGER_ENERGY_DRAIN))

        {

        }

        else if (flags & TRIGGER_EXIT)

                return trigger_action::normal_exit;

        else if (flags & TRIGGER_MATCEN)

                return trigger_action::matcen;

        else if (flags & TRIGGER_ILLUSION_OFF)

                return trigger_action::illusion_off;

        else if (flags & TRIGGER_SECRET_EXIT)

                return trigger_action::secret_exit;

        else if (flags & TRIGGER_ILLUSION_ON)

                return trigger_action::illusion_on;

        else if (flags & TRIGGER_UNLOCK_DOORS)

                return trigger_action::unlock_door;

        else if (flags & TRIGGER_OPEN_WALL)

                return trigger_action::open_wall;

        else if (flags & TRIGGER_CLOSE_WALL)

                return trigger_action::close_wall;

        else if (flags & TRIGGER_ILLUSORY_WALL)

                return trigger_action::illusory_wall;

        throw std::runtime_error("unsupported trigger type");

}

static void v30_trigger_to_v31_trigger(trigger &t, const v30_trigger &trig)

{

        t.type        = trigger_type_from_flags(trig.flags);

        t.flags       = (trig.flags & TRIGGER_ONE_SHOT) ? trigger_behavior_flags::one_shot : trigger_behavior_flags{0};

        t.num_links   = trig.num_links;

        t.num_links   = trig.num_links;

        t.value       = trig.value;

        t.seg = trig.seg;

        t.side = trig.side;

}

static void v29_trigger_read_as_v30(PHYSFS_File *fp, v30_trigger &trig)

{

        v29_trigger trig29;

        v29_trigger_read(&trig29, fp);

        trig.flags      = trig29.flags;

        // skip trig29.link_num. v30_trigger does not need it

        trig.num_links  = trig29.num_links;

        trig.value      = trig29.value;

        trig.time       = trig29.time;

        trig.seg = trig29.seg;

        trig.side = trig29.side;

}

void v29_trigger_read_as_v31(PHYSFS_File *fp, trigger &t)

{

        v30_trigger trig;

        v29_trigger_read_as_v30(fp, trig);

        v30_trigger_to_v31_trigger(t, trig);

}

void v30_trigger_read_as_v31(PHYSFS_File *fp, trigger &t)

{

        v30_trigger trig;

        v30_trigger_read(&trig, fp);

        v30_trigger_to_v31_trigger(t, trig);

}

#endif

#if defined(DXX_BUILD_DESCENT_I)

DEFINE_SERIAL_UDT_TO_MESSAGE(trigger, t, (serial::pad<1>(), t.flags, t.value, serial::pad<5>(), t.num_links, t.seg, t.side));

ASSERT_SERIAL_UDT_MESSAGE_SIZE(trigger, 54);

#elif defined(DXX_BUILD_DESCENT_II)

DEFINE_SERIAL_UDT_TO_MESSAGE(trigger, t, (t.type, t.flags, t.num_links, serial::pad<1>(), t.value, serial::pad<4>(), t.seg, t.side));

ASSERT_SERIAL_UDT_MESSAGE_SIZE(trigger, 52);

#endif

}

/*

 * reads n trigger structs from a PHYSFS_File and swaps if specified

 */

void trigger_read(PHYSFS_File *fp, trigger &t)

{

        PHYSFSX_serialize_read(fp, t);

}

void trigger_write(PHYSFS_File *fp, const trigger &t)

{

        PHYSFSX_serialize_write(fp, t);

}

namespace dsx {

void v29_trigger_write(PHYSFS_File *fp, const trigger &rt)

{

        const trigger *t = &rt;

        PHYSFSX_writeU8(fp, 0);         // unused 'type'

#if defined(DXX_BUILD_DESCENT_I)

        PHYSFS_writeSLE16(fp, t->flags);

#elif defined(DXX_BUILD_DESCENT_II)

        const auto one_shot_flag = (t->flags & trigger_behavior_flags::one_shot) ? TRIGGER_ONE_SHOT : TRIGGER_FLAG{0};