mirror of
https://github.com/ZDoom/gzdoom.git
synced 2025-04-26 04:30:58 +00:00
721 lines
14 KiB
C++
721 lines
14 KiB
C++
// Emacs style mode select -*- C++ -*-
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
// $Id:$
|
|
//
|
|
// Copyright (C) 1993-1996 by id Software, Inc.
|
|
//
|
|
// This source is available for distribution and/or modification
|
|
// only under the terms of the DOOM Source Code License as
|
|
// published by id Software. All rights reserved.
|
|
//
|
|
// The source is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License
|
|
// for more details.
|
|
//
|
|
// DESCRIPTION: none
|
|
// Implements special effects:
|
|
// Texture animation, height or lighting changes
|
|
// according to adjacent sectors, respective
|
|
// utility functions, etc.
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
|
|
|
|
#ifndef __P_SPEC__
|
|
#define __P_SPEC__
|
|
|
|
|
|
//jff 2/23/98 identify the special classes that can share sectors
|
|
|
|
typedef enum
|
|
{
|
|
floor_special,
|
|
ceiling_special,
|
|
lighting_special,
|
|
} special_e;
|
|
|
|
// killough 3/7/98: Add generalized scroll effects
|
|
|
|
typedef struct {
|
|
thinker_t thinker; // Thinker structure for scrolling
|
|
fixed_t dx, dy; // (dx,dy) scroll speeds
|
|
int affectee; // Number of affected sidedef, sector, tag, or whatever
|
|
int control; // Control sector (-1 if none) used to control scrolling
|
|
fixed_t last_height; // Last known height of control sector
|
|
fixed_t vdx, vdy; // Accumulated velocity if accelerative
|
|
int accel; // Whether it's accelerative
|
|
enum
|
|
{
|
|
sc_side,
|
|
sc_floor,
|
|
sc_ceiling,
|
|
sc_carry,
|
|
sc_carry_ceiling, // killough 4/11/98: carry objects hanging on ceilings
|
|
} type; // Type of scroll effect
|
|
} scroll_t;
|
|
|
|
// phares 3/20/98: added new model of Pushers for push/pull effects
|
|
|
|
typedef struct {
|
|
thinker_t thinker; // Thinker structure for Pusher
|
|
enum
|
|
{
|
|
p_push,
|
|
p_pull,
|
|
p_wind,
|
|
p_current,
|
|
} type;
|
|
mobj_t* source; // Point source if point pusher
|
|
int x_mag; // X Strength
|
|
int y_mag; // Y Strength
|
|
int magnitude; // Vector strength for point pusher
|
|
int radius; // Effective radius for point pusher
|
|
int x; // X of point source if point pusher
|
|
int y; // Y of point source if point pusher
|
|
int affectee; // Number of affected sector
|
|
} pusher_t;
|
|
|
|
// [RH] Types of keys used by locked doors and scripts
|
|
typedef enum
|
|
{
|
|
NoKey,
|
|
RCard,
|
|
BCard,
|
|
YCard,
|
|
RSkull,
|
|
BSkull,
|
|
YSkull,
|
|
|
|
AnyKey = 100,
|
|
AllKeys = 101,
|
|
|
|
CardIsSkull = 128
|
|
} keytype_t;
|
|
|
|
BOOL P_CheckKeys (player_t *p, keytype_t lock, BOOL remote);
|
|
|
|
// Define values for map objects
|
|
#define MO_TELEPORTMAN 14
|
|
|
|
|
|
// [RH] If a deathmatch game, checks to see if noexit is enabled.
|
|
// If so, it kills the player and returns false. Otherwise,
|
|
// it returns true, and the player is allowed to live.
|
|
BOOL CheckIfExitIsGood (mobj_t *self);
|
|
|
|
// at game start
|
|
void P_InitPicAnims (void);
|
|
|
|
// at map load
|
|
void P_SpawnSpecials (void);
|
|
|
|
// every tic
|
|
void P_UpdateSpecials (void);
|
|
|
|
// when needed
|
|
BOOL P_ActivateLine (line_t *ld, mobj_t *mo, int side, int activationType);
|
|
|
|
void P_PlayerInSpecialSector (player_t *player);
|
|
|
|
int twoSided (int sector, int line);
|
|
|
|
sector_t *getSector (int currentSector, int line, int side);
|
|
|
|
side_t *getSide (int currentSector, int line, int side);
|
|
|
|
fixed_t P_FindLowestFloorSurrounding (sector_t *sec);
|
|
fixed_t P_FindHighestFloorSurrounding (sector_t *sec);
|
|
|
|
fixed_t P_FindNextHighestFloor (sector_t *sec, int currentheight);
|
|
fixed_t P_FindNextLowestFloor (sector_t* sec, int currentheight);
|
|
|
|
fixed_t P_FindLowestCeilingSurrounding (sector_t *sec); // jff 2/04/98
|
|
fixed_t P_FindHighestCeilingSurrounding (sector_t *sec); // jff 2/04/98
|
|
|
|
fixed_t P_FindNextLowestCeiling (sector_t *sec, int currentheight); // jff 2/04/98
|
|
fixed_t P_FindNextHighestCeiling (sector_t *sec, int currentheight); // jff 2/04/98
|
|
|
|
fixed_t P_FindShortestTextureAround (int secnum); // jff 2/04/98
|
|
fixed_t P_FindShortestUpperAround (int secnum); // jff 2/04/98
|
|
|
|
sector_t* P_FindModelFloorSector (fixed_t floordestheight, int secnum); //jff 02/04/98
|
|
sector_t* P_FindModelCeilingSector (fixed_t ceildestheight, int secnum); //jff 02/04/98
|
|
|
|
int P_FindSectorFromTag (int tag, int start);
|
|
int P_FindLineFromID (int id, int start);
|
|
|
|
int P_FindMinSurroundingLight (sector_t *sector, int max);
|
|
|
|
sector_t *getNextSector (line_t *line, sector_t *sec);
|
|
sector_t *P_NextSpecialSector (sector_t *sec, int type, sector_t *back2); // [RH]
|
|
|
|
void T_Scroll (scroll_t *); // killough 3/7/98: scroll effect thinker
|
|
void T_Pusher (pusher_t *); // phares 3/20/98: Push thinker
|
|
|
|
|
|
//
|
|
// SPECIAL
|
|
//
|
|
int EV_DoDonut (int tag, fixed_t pillarspeed, fixed_t slimespeed);
|
|
|
|
|
|
|
|
//
|
|
// P_LIGHTS
|
|
//
|
|
typedef struct
|
|
{
|
|
thinker_t thinker;
|
|
sector_t* sector;
|
|
int count;
|
|
int maxlight;
|
|
int minlight;
|
|
} fireflicker_t;
|
|
|
|
|
|
|
|
typedef struct
|
|
{
|
|
thinker_t thinker;
|
|
sector_t* sector;
|
|
int count;
|
|
int maxlight;
|
|
int minlight;
|
|
int maxtime;
|
|
int mintime;
|
|
} lightflash_t;
|
|
|
|
|
|
|
|
typedef struct
|
|
{
|
|
thinker_t thinker;
|
|
sector_t* sector;
|
|
int count;
|
|
int minlight;
|
|
int maxlight;
|
|
int darktime;
|
|
int brighttime;
|
|
} strobe_t;
|
|
|
|
|
|
|
|
|
|
typedef struct
|
|
{
|
|
thinker_t thinker;
|
|
sector_t* sector;
|
|
int minlight;
|
|
int maxlight;
|
|
int direction;
|
|
} glow_t;
|
|
|
|
// [RH] Glow from Light_Glow and Light_Fade specials
|
|
typedef struct
|
|
{
|
|
thinker_t thinker;
|
|
sector_t *sector;
|
|
int start;
|
|
int end;
|
|
int maxtics;
|
|
int tics;
|
|
BOOL oneshot;
|
|
} glow2_t;
|
|
|
|
// [RH] Phased light thinker
|
|
typedef struct
|
|
{
|
|
thinker_t thinker;
|
|
sector_t *sector;
|
|
byte baselevel;
|
|
byte phase;
|
|
} phased_t;
|
|
|
|
#define GLOWSPEED 8
|
|
#define STROBEBRIGHT 5
|
|
#define FASTDARK 15
|
|
#define SLOWDARK TICRATE
|
|
|
|
void T_FireFlicker (fireflicker_t *flick);
|
|
void P_SpawnFireFlicker (sector_t *sector);
|
|
void T_LightFlash (lightflash_t *flash);
|
|
void P_SpawnLightFlash (sector_t *sector, int min, int max);
|
|
void T_StrobeFlash (strobe_t *flash);
|
|
|
|
void P_SpawnStrobeFlash (sector_t *sector, int upper, int lower,
|
|
int utics, int ltics, int inSync);
|
|
|
|
void T_Flicker (fireflicker_t *flick);
|
|
void EV_StartLightFlickering (int tag, int upper, int lower);
|
|
void EV_StartLightStrobing (int tag, int upper, int lower,
|
|
int utics, int ltics);
|
|
void EV_TurnTagLightsOff (int tag);
|
|
void EV_LightTurnOn (int tag, int bright);
|
|
void EV_LightChange (int tag, int value);
|
|
|
|
void T_Glow (glow_t *g);
|
|
void P_SpawnGlowingLight (sector_t *sector);
|
|
|
|
void T_Glow2 (glow2_t *g);
|
|
void EV_StartLightGlowing (int tag, int upper, int lower, int tics);
|
|
void EV_StartLightFading (int tag, int value, int tics);
|
|
|
|
void T_PhasedLight (phased_t *l);
|
|
void P_SpawnLightSequence (sector_t *sector);
|
|
void P_SpawnLightPhased (sector_t *sector);
|
|
|
|
|
|
//
|
|
// P_SWITCH
|
|
//
|
|
typedef struct
|
|
{
|
|
char name1[9];
|
|
char name2[9];
|
|
short episode;
|
|
|
|
} switchlist_t;
|
|
|
|
|
|
typedef enum
|
|
{
|
|
top,
|
|
middle,
|
|
bottom
|
|
|
|
} bwhere_e;
|
|
|
|
|
|
typedef struct button_s
|
|
{
|
|
struct button_s *next; // [RH] make buttons a singly-linked list
|
|
line_t* line;
|
|
bwhere_e where;
|
|
int btexture;
|
|
int btimer;
|
|
fixed_t x, y; // [RH] Location of switch sound, independent of any mobjs
|
|
|
|
} button_t;
|
|
|
|
|
|
|
|
|
|
// 1 second, in ticks.
|
|
#define BUTTONTIME TICRATE
|
|
|
|
extern button_t *buttonlist;
|
|
|
|
void P_ChangeSwitchTexture (line_t *line, int useAgain);
|
|
|
|
void P_InitSwitchList(void);
|
|
|
|
|
|
//
|
|
// P_PLATS
|
|
//
|
|
typedef enum
|
|
{
|
|
up,
|
|
down,
|
|
waiting,
|
|
in_stasis
|
|
|
|
} plat_e;
|
|
|
|
|
|
|
|
typedef enum
|
|
{
|
|
// [RH] Changed these
|
|
platPerpetualRaise,
|
|
platDownWaitUpStay,
|
|
platUpWaitDownStay,
|
|
platDownByValue,
|
|
platUpByValue,
|
|
platUpByValueStay,
|
|
platRaiseAndStay,
|
|
platToggle,
|
|
platDownToNearestFloor,
|
|
platDownToLowestCeiling
|
|
|
|
} plattype_e;
|
|
|
|
|
|
|
|
typedef struct plat_s
|
|
{
|
|
thinker_t thinker;
|
|
|
|
// [RH] Added next and prev links
|
|
struct plat_s *next, *prev;
|
|
|
|
sector_t* sector;
|
|
fixed_t speed;
|
|
fixed_t low;
|
|
fixed_t high;
|
|
int wait;
|
|
int count;
|
|
plat_e status;
|
|
plat_e oldstatus;
|
|
BOOL crush;
|
|
int tag;
|
|
plattype_e type;
|
|
|
|
} plat_t;
|
|
|
|
|
|
|
|
extern plat_t *activeplats;
|
|
|
|
void T_PlatRaise(plat_t *plat);
|
|
|
|
BOOL EV_DoPlat (int tag, line_t *line, plattype_e type, int height,
|
|
int speed, int delay, int lip, int change);
|
|
|
|
void P_AddActivePlat (plat_t *plat);
|
|
void P_RemoveActivePlat (plat_t *plat);
|
|
void EV_StopPlat (int tag);
|
|
void P_ActivateInStasis (int tag);
|
|
|
|
|
|
//
|
|
// [RH]
|
|
// P_PILLAR
|
|
//
|
|
typedef enum
|
|
{
|
|
pillarBuild,
|
|
pillarOpen
|
|
|
|
} pillar_e;
|
|
|
|
typedef struct
|
|
{
|
|
thinker_t thinker;
|
|
sector_t *sector;
|
|
pillar_e type;
|
|
fixed_t floorspeed;
|
|
fixed_t ceilingspeed;
|
|
fixed_t floortarget;
|
|
fixed_t ceilingtarget;
|
|
int crush;
|
|
|
|
} pillar_t;
|
|
|
|
BOOL EV_DoPillar (pillar_e type, int tag, fixed_t speed, fixed_t height,
|
|
fixed_t height2, int crush);
|
|
|
|
void T_Pillar (pillar_t *pillar);
|
|
|
|
//
|
|
// P_DOORS
|
|
//
|
|
typedef enum
|
|
{
|
|
// [RH] Changed for new specials
|
|
doorClose,
|
|
doorOpen,
|
|
doorRaise,
|
|
doorRaiseIn5Mins,
|
|
doorCloseWaitOpen,
|
|
|
|
} vldoor_e;
|
|
|
|
typedef struct
|
|
{
|
|
thinker_t thinker;
|
|
vldoor_e type;
|
|
sector_t* sector;
|
|
fixed_t topheight;
|
|
fixed_t speed;
|
|
|
|
// 1 = up, 0 = waiting at top, -1 = down
|
|
int direction;
|
|
|
|
// tics to wait at the top
|
|
int topwait;
|
|
// (keep in case a door going down is reset)
|
|
// when it reaches 0, start going down
|
|
int topcountdown;
|
|
|
|
} vldoor_t;
|
|
|
|
|
|
BOOL EV_DoDoor (vldoor_e type, line_t *line, mobj_t *thing,
|
|
int tag, int speed, int delay, keytype_t lock);
|
|
|
|
void T_VerticalDoor (vldoor_t *door);
|
|
void P_SpawnDoorCloseIn30 (sector_t *sec);
|
|
|
|
void P_SpawnDoorRaiseIn5Mins (sector_t *sec);
|
|
|
|
|
|
|
|
//
|
|
// P_CEILNG
|
|
//
|
|
|
|
// [RH] Changed these
|
|
typedef enum
|
|
{
|
|
ceilLowerByValue,
|
|
ceilRaiseByValue,
|
|
ceilMoveToValue,
|
|
ceilLowerToHighestFloor,
|
|
ceilLowerInstant,
|
|
ceilRaiseInstant,
|
|
ceilCrushAndRaise,
|
|
ceilLowerAndCrush,
|
|
ceilCrushRaiseAndStay,
|
|
ceilRaiseToNearest,
|
|
ceilLowerToLowest,
|
|
ceilLowerToFloor,
|
|
|
|
// The following are only used by Generic_Ceiling
|
|
ceilRaiseToHighest,
|
|
ceilLowerToHighest,
|
|
ceilRaiseToLowest,
|
|
ceilLowerToNearest,
|
|
ceilRaiseToHighestFloor,
|
|
ceilRaiseToFloor,
|
|
ceilRaiseByTexture,
|
|
ceilLowerByTexture,
|
|
|
|
genCeilingChg0,
|
|
genCeilingChgT,
|
|
genCeilingChg
|
|
|
|
} ceiling_e;
|
|
|
|
|
|
|
|
typedef struct ceiling_s
|
|
{
|
|
thinker_t thinker;
|
|
|
|
// [RH] Added next and prev links
|
|
struct ceiling_s *next, *prev;
|
|
|
|
ceiling_e type;
|
|
sector_t* sector;
|
|
fixed_t bottomheight;
|
|
fixed_t topheight;
|
|
fixed_t speed;
|
|
fixed_t speed1; // [RH] dnspeed of crushers
|
|
fixed_t speed2; // [RH] upspeed of crushers
|
|
int crush;
|
|
int silent;
|
|
int direction; // 1 = up, 0 = waiting, -1 = down
|
|
|
|
// [RH] Need these for BOOM-ish transfering ceilings
|
|
int texture;
|
|
int newspecial;
|
|
|
|
// ID
|
|
int tag;
|
|
int olddirection;
|
|
} ceiling_t;
|
|
|
|
extern ceiling_t *activeceilings;
|
|
|
|
BOOL EV_DoCeiling (ceiling_e type, line_t *line,
|
|
int tag, fixed_t speed, fixed_t speed2, fixed_t height,
|
|
int crush, int silent, int change);
|
|
|
|
void T_MoveCeiling (ceiling_t *ceiling);
|
|
void P_AddActiveCeiling (ceiling_t *c);
|
|
void P_RemoveActiveCeiling (ceiling_t *c);
|
|
BOOL EV_CeilingCrushStop (int tag);
|
|
void P_ActivateInStasisCeiling(int tag);
|
|
|
|
|
|
//
|
|
// P_FLOOR
|
|
//
|
|
// [RH] Changed these enums
|
|
typedef enum
|
|
{
|
|
floorLowerToLowest,
|
|
floorLowerToNearest,
|
|
floorLowerToHighest,
|
|
floorLowerByValue,
|
|
floorRaiseByValue,
|
|
floorRaiseToHighest,
|
|
floorRaiseToNearest,
|
|
floorRaiseAndCrush,
|
|
floorCrushStop,
|
|
floorLowerInstant,
|
|
floorRaiseInstant,
|
|
floorMoveToValue,
|
|
floorRaiseToLowestCeiling,
|
|
floorRaiseByTexture,
|
|
|
|
floorLowerAndChange,
|
|
floorRaiseAndChange,
|
|
|
|
floorRaiseToLowest,
|
|
floorRaiseToCeiling,
|
|
floorLowerToLowestCeiling,
|
|
floorLowerByTexture,
|
|
floorLowerToCeiling,
|
|
|
|
donutRaise,
|
|
|
|
buildStair,
|
|
waitStair,
|
|
resetStair,
|
|
|
|
// Not to be used as parameters to EV_DoFloor()
|
|
genFloorChg0,
|
|
genFloorChgT,
|
|
genFloorChg
|
|
|
|
} floor_e;
|
|
|
|
//jff 3/15/98 pure texture/type change for better generalized support
|
|
typedef enum
|
|
{
|
|
trigChangeOnly,
|
|
numChangeOnly,
|
|
} change_e;
|
|
|
|
// [RH] Changed to use Hexen-ish specials
|
|
typedef enum
|
|
{
|
|
buildUp,
|
|
buildDown
|
|
|
|
} stair_e;
|
|
|
|
typedef enum
|
|
{
|
|
elevateUp,
|
|
elevateDown,
|
|
elevateCurrent,
|
|
// [RH] For FloorAndCeiling_Raise/Lower
|
|
elevateRaise,
|
|
elevateLower
|
|
} elevator_e;
|
|
|
|
typedef struct
|
|
{
|
|
thinker_t thinker;
|
|
floor_e type;
|
|
int crush;
|
|
sector_t* sector;
|
|
int direction;
|
|
short newspecial;
|
|
short texture;
|
|
fixed_t floordestheight;
|
|
fixed_t speed;
|
|
|
|
// [RH] New parameters use to reset and delayed stairs
|
|
int resetcount;
|
|
int orgheight;
|
|
int delay;
|
|
int pausetime;
|
|
int steptime;
|
|
int persteptime;
|
|
|
|
} floormove_t;
|
|
|
|
typedef struct
|
|
{
|
|
thinker_t thinker;
|
|
elevator_e type;
|
|
sector_t* sector;
|
|
int direction;
|
|
fixed_t floordestheight;
|
|
fixed_t ceilingdestheight;
|
|
fixed_t speed;
|
|
} elevator_t;
|
|
|
|
typedef struct
|
|
{
|
|
thinker_t thinker;
|
|
sector_t *sector;
|
|
fixed_t originalHeight;
|
|
fixed_t accumulator;
|
|
fixed_t accDelta;
|
|
fixed_t targetScale;
|
|
fixed_t scale;
|
|
fixed_t scaleDelta;
|
|
int ticker;
|
|
int state;
|
|
} floorWaggle_t;
|
|
|
|
|
|
typedef enum
|
|
{
|
|
ok,
|
|
crushed,
|
|
pastdest
|
|
|
|
} result_e;
|
|
|
|
result_e T_MovePlane (sector_t *sector, fixed_t speed, fixed_t dest,
|
|
int crush, int floorOrCeiling, int direction);
|
|
|
|
BOOL EV_DoElevator (line_t *line, ceiling_e type, fixed_t speed, fixed_t height, int tag);
|
|
|
|
BOOL EV_BuildStairs (int tag, stair_e type, line_t *line,
|
|
fixed_t stairsize, fixed_t speed, int delay, int reset, int igntxt,
|
|
int usespecials);
|
|
|
|
BOOL EV_DoFloor (floor_e floortype, line_t *line, int tag,
|
|
fixed_t speed, fixed_t height, int crush, int change);
|
|
BOOL EV_FloorCrushStop (int tag);
|
|
BOOL EV_DoChange (line_t *line, change_e changetype, int tag);
|
|
BOOL EV_StartFloorWaggle(int tag, int height, int speed, int offset,
|
|
int timer);
|
|
|
|
void T_FloorWaggle (floorWaggle_t *w);
|
|
void T_MoveFloor (floormove_t *floor);
|
|
void T_MoveElevator (elevator_t *elevator);
|
|
|
|
|
|
//
|
|
// P_TELEPT
|
|
//
|
|
BOOL EV_Teleport (int tid, int side, mobj_t *thing);
|
|
BOOL EV_SilentTeleport (int tid, line_t *line, int side, mobj_t *thing);
|
|
BOOL EV_SilentLineTeleport (line_t *line, int side, mobj_t *thing, int id,
|
|
BOOL reverse);
|
|
|
|
|
|
int P_SectorActive (special_e t, sector_t *s); // [RH] from BOOM
|
|
|
|
|
|
//
|
|
// [RH] ACS (see also p_acs.h)
|
|
//
|
|
|
|
void P_ClearScripts (void);
|
|
|
|
BOOL P_StartScript (mobj_t *who, line_t *where, int script, char *map, int lineSide,
|
|
int arg0, int arg1, int arg2, int always);
|
|
void P_SuspendScript (int script, char *map);
|
|
void P_TerminateScript (int script, char *map);
|
|
void P_StartOpenScripts (void);
|
|
void P_DoDeferedScripts (void);
|
|
|
|
//
|
|
// [RH] p_quake.c
|
|
//
|
|
typedef struct quake_s {
|
|
struct quake_s *next;
|
|
mobj_t *quakespot;
|
|
fixed_t tremorbox[4];
|
|
fixed_t damagebox[4];
|
|
int intensity;
|
|
int countdown;
|
|
} quake_t;
|
|
|
|
extern quake_t *ActiveQuakes;
|
|
|
|
void P_RunQuakes (void);
|
|
BOOL P_StartQuake (int tid, int intensity, int duration, int damrad, int tremrad);
|
|
|
|
#endif
|