499 lines
17 KiB
C
499 lines
17 KiB
C
// SONIC ROBO BLAST 2
|
|
//-----------------------------------------------------------------------------
|
|
// Copyright (C) 1993-1996 by id Software, Inc.
|
|
// Copyright (C) 1998-2000 by DooM Legacy Team.
|
|
// Copyright (C) 1999-2018 by Sonic Team Junior.
|
|
//
|
|
// This program is free software distributed under the
|
|
// terms of the GNU General Public License, version 2.
|
|
// See the 'LICENSE' file for more details.
|
|
//-----------------------------------------------------------------------------
|
|
/// \file p_local.h
|
|
/// \brief Play functions, animation, global header
|
|
|
|
#ifndef __P_LOCAL__
|
|
#define __P_LOCAL__
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
#include "command.h"
|
|
#include "d_player.h"
|
|
#include "d_think.h"
|
|
#include "m_fixed.h"
|
|
#include "m_bbox.h"
|
|
#include "p_tick.h"
|
|
#include "r_defs.h"
|
|
#include "p_maputl.h"
|
|
#include "doomstat.h" // MAXSPLITSCREENPLAYERS
|
|
|
|
#define FLOATSPEED (FRACUNIT*4)
|
|
|
|
//#define VIEWHEIGHTS "41"
|
|
|
|
// Maximum player score.
|
|
#define MAXSCORE 999999990
|
|
|
|
// mapblocks are used to check movement
|
|
// against lines and things
|
|
#define MAPBLOCKUNITS 128
|
|
#define MAPBLOCKSIZE (MAPBLOCKUNITS*FRACUNIT)
|
|
#define MAPBLOCKSHIFT (FRACBITS+7)
|
|
#define MAPBMASK (MAPBLOCKSIZE-1)
|
|
#define MAPBTOFRAC (MAPBLOCKSHIFT-FRACBITS)
|
|
|
|
// Convenience macro to fix issue with collision along bottom/left edges of blockmap -Red
|
|
#define BMBOUNDFIX(xl, xh, yl, yh) {if (xl > xh) xl = 0; if (yl > yh) yl = 0;}
|
|
|
|
// MAXRADIUS is for precalculated sector block boxes
|
|
// the spider demon is larger,
|
|
// but we do not have any moving sectors nearby
|
|
#define MAXRADIUS (32*FRACUNIT)
|
|
|
|
// max Z move up or down without jumping
|
|
// above this, a height difference is considered as a 'dropoff'
|
|
#define MAXSTEPMOVE (24*FRACUNIT)
|
|
|
|
#define USERANGE (64*FRACUNIT)
|
|
#define MELEERANGE (64*FRACUNIT)
|
|
#define MISSILERANGE (32*64*FRACUNIT)
|
|
|
|
#define AIMINGTOSLOPE(aiming) FINESINE((aiming>>ANGLETOFINESHIFT) & FINEMASK)
|
|
|
|
#define mariomode (maptol & TOL_MARIO)
|
|
#define twodlevel (maptol & TOL_2D)
|
|
|
|
//
|
|
// P_TICK
|
|
//
|
|
|
|
// both the head and tail of the thinker list
|
|
extern thinker_t thinkercap;
|
|
extern thinker_t precipcap;
|
|
|
|
void P_InitThinkers(void);
|
|
void P_AddThinker(thinker_t *thinker);
|
|
void P_AddPrecipThinker(thinker_t *thinker);
|
|
void P_RemoveThinker(thinker_t *thinker);
|
|
void P_UnlinkThinker(thinker_t *thinker);
|
|
|
|
//
|
|
// P_USER
|
|
//
|
|
|
|
typedef struct camera_s
|
|
{
|
|
boolean chase;
|
|
boolean freecam;
|
|
|
|
angle_t localangle;
|
|
INT32 localaiming;
|
|
|
|
angle_t aiming;
|
|
|
|
// Freecam: A button was held since entering from menu, so don't move camera
|
|
UINT8 button_a_held;
|
|
|
|
// Freecam: aiming needs to be reset after switching from chasecam
|
|
boolean reset_aiming;
|
|
|
|
// Hold up/down to pan the camera vertically
|
|
SINT8 dpad_y_held;
|
|
|
|
// Things used by FS cameras.
|
|
fixed_t viewheight;
|
|
angle_t startangle;
|
|
|
|
// Camera demobjerization
|
|
// Info for drawing: position.
|
|
fixed_t x, y, z;
|
|
boolean reset;
|
|
|
|
//More drawing info: to determine current sprite.
|
|
angle_t angle; // orientation
|
|
|
|
struct subsector_s *subsector;
|
|
|
|
// The closest interval over all contacted Sectors (or Things).
|
|
fixed_t floorz;
|
|
fixed_t ceilingz;
|
|
|
|
// For movement checking.
|
|
fixed_t radius;
|
|
fixed_t height;
|
|
|
|
fixed_t relativex;
|
|
|
|
// Momentums, used to update position.
|
|
fixed_t momx, momy, momz;
|
|
|
|
// SRB2Kart: camera pans while drifting
|
|
fixed_t pan;
|
|
|
|
// SRB2Kart: camera pitches on slopes
|
|
angle_t pitch;
|
|
|
|
// postproccess effects
|
|
UINT8 postimg;
|
|
} camera_t;
|
|
|
|
// post process types
|
|
enum
|
|
{
|
|
POSTIMG_WATER = 1, // Underwater screen effect.
|
|
POSTIMG_MOTION = 1<<1, // Unused motion blur effect.
|
|
POSTIMG_FLIP = 1<<2, // Flipcam screen effect.
|
|
POSTIMG_HEAT = 1<<3, // Heatwave screen effect.
|
|
POSTIMG_MIRROR = 1<<4, // encore screen effect.
|
|
};
|
|
|
|
extern camera_t camera[MAXSPLITSCREENPLAYERS];
|
|
extern consvar_t cv_cam_dist[MAXSPLITSCREENPLAYERS];
|
|
extern consvar_t cv_cam_height[MAXSPLITSCREENPLAYERS];
|
|
extern consvar_t cv_cam_pitch[MAXSPLITSCREENPLAYERS];
|
|
extern consvar_t cv_cam_speed[MAXSPLITSCREENPLAYERS];
|
|
extern consvar_t cv_cam_lookbackmom[MAXSPLITSCREENPLAYERS];
|
|
extern consvar_t cv_cam_still[MAXSPLITSCREENPLAYERS];
|
|
extern consvar_t cv_cam_rotate[MAXSPLITSCREENPLAYERS];
|
|
extern consvar_t cv_cam_timeover[MAXSPLITSCREENPLAYERS];
|
|
|
|
extern consvar_t cv_freecam_speed[MAXSPLITSCREENPLAYERS];
|
|
|
|
extern consvar_t cv_tilting;
|
|
extern consvar_t cv_quaketilt;
|
|
extern consvar_t cv_tiltsmoothing;
|
|
|
|
extern consvar_t cv_actionmovie;
|
|
|
|
extern consvar_t cv_screenquake;
|
|
|
|
extern consvar_t cv_verticallook[MAXSPLITSCREENPLAYERS];
|
|
|
|
extern fixed_t t_cam_rotate[MAXSPLITSCREENPLAYERS];
|
|
|
|
fixed_t P_GetPlayerHeight(player_t *player);
|
|
fixed_t P_GetPlayerSpinHeight(player_t *player);
|
|
void P_AddPlayerScore(player_t *player, UINT32 amount);
|
|
|
|
void P_SetupCamera(camera_t *cam);
|
|
void P_ResetCamera(player_t *player, camera_t *thiscam);
|
|
boolean P_TryCameraMove(fixed_t x, fixed_t y, camera_t *thiscam);
|
|
#ifndef NOCLIPCAM
|
|
void P_SlideCameraMove(camera_t *thiscam);
|
|
#endif
|
|
boolean P_MoveChaseCamera(player_t *player, camera_t *thiscam, boolean resetcalled);
|
|
void P_ResetLocalCamAiming(player_t *player);
|
|
void P_ToggleDemoCamera(UINT8 viewnum);
|
|
void P_CalcChasePostImg(player_t *player, camera_t *thiscam);
|
|
|
|
boolean P_PlayerInPain(player_t *player);
|
|
void P_DoPlayerPain(player_t *player, mobj_t *source, mobj_t *inflictor);
|
|
void P_ResetPlayer(player_t *player);
|
|
player_t *P_GetLocalPlayerForNum(UINT8 pnum);
|
|
INT32 P_GetLocalPlayerNumForNum(UINT8 pnum);
|
|
boolean P_IsLocalPlayer(const player_t *player);
|
|
boolean P_IsLocalPlayerNum(UINT8 pnum);
|
|
boolean P_IsDisplayPlayer(const player_t *player);
|
|
|
|
boolean P_SpectatorJoinGame(player_t *player);
|
|
|
|
boolean P_IsObjectInGoop(mobj_t *mo);
|
|
boolean P_IsObjectOnGround(mobj_t *mo);
|
|
boolean P_IsObjectOnGroundIn(mobj_t *mo, sector_t *sec);
|
|
boolean P_IsObjectOnRealGround(mobj_t *mo, sector_t *sec); // SRB2Kart
|
|
boolean P_InSpaceSector(mobj_t *mo);
|
|
boolean P_InQuicksand(mobj_t *mo);
|
|
|
|
void P_SetObjectMomZ(mobj_t *mo, fixed_t value, boolean relative);
|
|
void P_RestoreMusic(player_t *player);
|
|
boolean P_EndingMusic(player_t *player);
|
|
void P_SpawnShieldOrb(player_t *player);
|
|
mobj_t *P_SpawnGhostMobj(mobj_t *mobj);
|
|
void P_GivePlayerRings(player_t *player, INT32 num_rings);
|
|
void P_GivePlayerLives(player_t *player, INT32 numlives);
|
|
UINT8 P_GetNextEmerald(void);
|
|
void P_GiveEmerald(boolean spawnObj);
|
|
void P_ResetScore(player_t *player);
|
|
boolean P_AutoPause(void);
|
|
|
|
void P_DoJumpShield(player_t *player);
|
|
void P_BlackOw(player_t *player);
|
|
void P_ElementalFireTrail(player_t *player);
|
|
|
|
//void P_DoPityCheck(player_t *player);
|
|
void P_PlayerThink(player_t *player);
|
|
void P_PlayerAfterThink(player_t *player);
|
|
void P_DoPlayerExit(player_t *player);
|
|
void P_DoTimeOver(player_t *player);
|
|
//void P_NightserizePlayer(player_t *player, INT32 ptime);
|
|
|
|
void P_InstaThrust(mobj_t *mo, angle_t angle, fixed_t move);
|
|
fixed_t P_ReturnThrustX(mobj_t *mo, angle_t angle, fixed_t move);
|
|
fixed_t P_ReturnThrustY(mobj_t *mo, angle_t angle, fixed_t move);
|
|
void P_InstaThrustEvenIn2D(mobj_t *mo, angle_t angle, fixed_t move);
|
|
|
|
boolean P_LookForEnemies(player_t *player);
|
|
void P_NukeEnemies(mobj_t *inflictor, mobj_t *source, fixed_t radius);
|
|
void P_HomingAttack(mobj_t *source, mobj_t *enemy); /// \todo doesn't belong in p_user
|
|
//boolean P_SuperReady(player_t *player);
|
|
boolean P_AnalogMove(player_t *player);
|
|
/*boolean P_TransferToNextMare(player_t *player);
|
|
UINT8 P_FindLowestMare(void);*/
|
|
UINT8 P_FindLowestLap(void);
|
|
UINT8 P_FindHighestLap(void);
|
|
void P_FindEmerald(void);
|
|
//void P_TransferToAxis(player_t *player, INT32 axisnum);
|
|
boolean P_PlayerMoving(INT32 pnum);
|
|
void P_Telekinesis(player_t *player, fixed_t thrust, fixed_t range);
|
|
|
|
void P_PlayLivesJingle(player_t *player);
|
|
void P_PlayRinglossSound(mobj_t *source, mobj_t *damager);
|
|
void P_PlayDeathSound(mobj_t *source);
|
|
void P_PlayVictorySound(mobj_t *source);
|
|
|
|
//
|
|
// P_MOBJ
|
|
//
|
|
#define ONFLOORZ INT32_MIN
|
|
#define ONCEILINGZ INT32_MAX
|
|
|
|
// Time interval for item respawning.
|
|
// WARNING MUST be a power of 2
|
|
#define ITEMQUESIZE 1024
|
|
|
|
extern mapthing_t *itemrespawnque[ITEMQUESIZE];
|
|
extern tic_t itemrespawntime[ITEMQUESIZE];
|
|
extern size_t iquehead, iquetail;
|
|
extern consvar_t cv_gravity;
|
|
|
|
void P_RespawnSpecials(void);
|
|
|
|
mobj_t *P_AllocateMobj(void);
|
|
mobj_t *P_SpawnMobj(fixed_t x, fixed_t y, fixed_t z, mobjtype_t type);
|
|
|
|
mobj_t *P_SpawnShadowMobj(mobj_t * caster);
|
|
|
|
void P_PrecipitationEffects(void);
|
|
|
|
void P_RemoveMobj(mobj_t *th);
|
|
|
|
void P_RemoveSavegameMobj(mobj_t *th);
|
|
boolean P_SetPlayerMobjState(mobj_t *mobj, statenum_t state);
|
|
boolean P_SetMobjState(mobj_t *mobj, statenum_t state);
|
|
//void P_RunShields(void);
|
|
void P_RunOverlays(void);
|
|
void P_RunShadows(void);
|
|
void P_MobjThinker(mobj_t *mobj);
|
|
boolean P_RailThinker(mobj_t *mobj);
|
|
void P_PushableThinker(mobj_t *mobj);
|
|
void P_SceneryThinker(mobj_t *mobj);
|
|
|
|
// This does not need to be added to Lua.
|
|
// To test it in Lua, check mobj.valid
|
|
FUNCINLINE static ATTRINLINE boolean P_MobjWasRemoved(const mobj_t *mobj)
|
|
{
|
|
return (!mobj || mobj->thinker.function != (actionf_p1)P_MobjThinker);
|
|
}
|
|
|
|
fixed_t P_MobjFloorZ(mobj_t *mobj, sector_t *sector, sector_t *boundsec, fixed_t x, fixed_t y, line_t *line, boolean lowest, boolean perfect);
|
|
fixed_t P_MobjCeilingZ(mobj_t *mobj, sector_t *sector, sector_t *boundsec, fixed_t x, fixed_t y, line_t *line, boolean lowest, boolean perfect);
|
|
#define P_GetFloorZ(mobj, sector, x, y, line) P_MobjFloorZ(mobj, sector, NULL, x, y, line, false, false)
|
|
#define P_GetCeilingZ(mobj, sector, x, y, line) P_MobjCeilingZ(mobj, sector, NULL, x, y, line, true, false)
|
|
#define P_GetFOFTopZ(mobj, sector, fof, x, y, line) P_MobjCeilingZ(mobj, sectors + fof->secnum, sector, x, y, line, false, false)
|
|
#define P_GetFOFBottomZ(mobj, sector, fof, x, y, line) P_MobjFloorZ(mobj, sectors + fof->secnum, sector, x, y, line, true, false)
|
|
#define P_GetSpecialBottomZ(mobj, src, bound) P_MobjFloorZ(mobj, src, bound, mobj->x, mobj->y, NULL, src != bound, true)
|
|
#define P_GetSpecialTopZ(mobj, src, bound) P_MobjCeilingZ(mobj, src, bound, mobj->x, mobj->y, NULL, src == bound, true)
|
|
|
|
fixed_t P_CameraFloorZ(camera_t *mobj, sector_t *sector, sector_t *boundsec, fixed_t x, fixed_t y, line_t *line, boolean lowest, boolean perfect);
|
|
fixed_t P_CameraCeilingZ(camera_t *mobj, sector_t *sector, sector_t *boundsec, fixed_t x, fixed_t y, line_t *line, boolean lowest, boolean perfect);
|
|
#define P_CameraGetFloorZ(mobj, sector, x, y, line) P_CameraFloorZ(mobj, sector, NULL, x, y, line, false, false)
|
|
#define P_CameraGetCeilingZ(mobj, sector, x, y, line) P_CameraCeilingZ(mobj, sector, NULL, x, y, line, true, false)
|
|
#define P_CameraGetFOFTopZ(mobj, sector, fof, x, y, line) P_CameraCeilingZ(mobj, sectors + fof->secnum, sector, x, y, line, false, false)
|
|
#define P_CameraGetFOFBottomZ(mobj, sector, fof, x, y, line) P_CameraFloorZ(mobj, sectors + fof->secnum, sector, x, y, line, true, false)
|
|
|
|
boolean P_InsideANonSolidFFloor(mobj_t *mobj, ffloor_t *rover);
|
|
boolean P_CheckDeathPitCollide(mobj_t *mo);
|
|
boolean P_CheckSolidLava(mobj_t *mo, ffloor_t *rover);
|
|
|
|
mobj_t *P_SpawnMissile(mobj_t *source, mobj_t *dest, mobjtype_t type);
|
|
mobj_t *P_SpawnXYZMissile(mobj_t *source, mobj_t *dest, mobjtype_t type, fixed_t x, fixed_t y, fixed_t z);
|
|
mobj_t *P_SpawnPointMissile(mobj_t *source, fixed_t xa, fixed_t ya, fixed_t za, mobjtype_t type, fixed_t x, fixed_t y, fixed_t z);
|
|
mobj_t *P_SpawnAlteredDirectionMissile(mobj_t *source, mobjtype_t type, fixed_t x, fixed_t y, fixed_t z, INT32 shiftingAngle);
|
|
mobj_t *P_SPMAngle(mobj_t *source, mobjtype_t type, angle_t angle, UINT8 aimtype, UINT32 flags2);
|
|
#define P_SpawnPlayerMissile(s,t,f) P_SPMAngle(s,t,s->angle,true,f)
|
|
#ifdef SEENAMES
|
|
#define P_SpawnNameFinder(s,t) P_SPMAngle(s,t,s->angle,true,0)
|
|
#endif
|
|
void P_ColorTeamMissile(mobj_t *missile, player_t *source);
|
|
|
|
// P_MobjFlip
|
|
// Special utility to return +1 or -1 depending on mobj's gravity
|
|
FUNCINLINE static ATTRINLINE SINT8 P_MobjFlip(const mobj_t *mobj)
|
|
{
|
|
return (mobj && (mobj->eflags & MFE_VERTICALFLIP)) ? -1 : 1;
|
|
}
|
|
|
|
fixed_t P_GetMobjGravity(mobj_t *mo);
|
|
FUNCMATH boolean P_WeaponOrPanel(mobjtype_t type);
|
|
|
|
boolean P_CameraThinker(player_t *player, camera_t *thiscam, boolean resetcalled);
|
|
|
|
void P_Attract(mobj_t *source, mobj_t *enemy, boolean nightsgrab);
|
|
mobj_t *P_GetClosestAxis(mobj_t *source);
|
|
|
|
void P_FlashPal(player_t *pl, UINT16 type, UINT16 duration);
|
|
#define PAL_WHITE 1
|
|
#define PAL_MIXUP 2
|
|
#define PAL_RECYCLE 3
|
|
#define PAL_NUKE 4
|
|
|
|
//
|
|
// P_ENEMY
|
|
//
|
|
|
|
// Is there a better place for these?
|
|
extern INT32 var1;
|
|
extern INT32 var2;
|
|
|
|
boolean P_CheckMeleeRange(mobj_t *actor);
|
|
boolean P_JetbCheckMeleeRange(mobj_t *actor);
|
|
boolean P_FaceStabCheckMeleeRange(mobj_t *actor);
|
|
boolean P_SkimCheckMeleeRange(mobj_t *actor);
|
|
boolean P_CheckMissileRange(mobj_t *actor);
|
|
|
|
void P_NewChaseDir(mobj_t *actor);
|
|
boolean P_LookForPlayers(mobj_t *actor, boolean allaround, boolean tracer, fixed_t dist);
|
|
|
|
//
|
|
// P_MAP
|
|
//
|
|
|
|
// If "floatok" true, move would be ok
|
|
// if within "tmfloorz - tmceilingz".
|
|
extern boolean floatok;
|
|
extern fixed_t tmfloorz;
|
|
extern fixed_t tmceilingz;
|
|
extern mobj_t *tmfloorthing, *tmhitthing, *tmthing;
|
|
extern camera_t *mapcampointer;
|
|
extern fixed_t tmx;
|
|
extern fixed_t tmy;
|
|
extern pslope_t *tmfloorslope, *tmceilingslope;
|
|
|
|
/* cphipps 2004/08/30 */
|
|
extern void P_MapStart(void);
|
|
extern void P_MapEnd(void);
|
|
|
|
extern line_t *ceilingline;
|
|
extern line_t *blockingline;
|
|
extern msecnode_t *sector_list;
|
|
|
|
void P_UnsetThingPosition(mobj_t *thing);
|
|
void P_SetThingPosition(mobj_t *thing);
|
|
void P_SetUnderlayPosition(mobj_t *thing);
|
|
|
|
boolean P_CheckPosition(mobj_t *thing, fixed_t x, fixed_t y);
|
|
boolean P_TryMove(mobj_t *thing, fixed_t x, fixed_t y, boolean allowdropoff);
|
|
boolean P_Move(mobj_t *actor, fixed_t speed);
|
|
boolean P_SetOrigin(mobj_t *thing, fixed_t x, fixed_t y, fixed_t z);
|
|
boolean P_MoveOrigin(mobj_t *thing, fixed_t x, fixed_t y, fixed_t z);
|
|
void P_SlideMove(mobj_t *mo, boolean forceslide);
|
|
void P_BouncePlayerMove(mobj_t *mo);
|
|
void P_BounceMove(mobj_t *mo);
|
|
|
|
#define P_CheckSight(t1, t2) P_CheckSight2(t1, t2, false)
|
|
#define P_CheckSightFast(t1, t2) P_CheckSight2(t1, t2, true)
|
|
boolean P_CheckSight2(mobj_t *t1, mobj_t *t2, boolean fast);
|
|
|
|
void P_CheckHoopPosition(mobj_t *hoopthing, fixed_t x, fixed_t y, fixed_t z, fixed_t radius);
|
|
|
|
boolean P_CheckSector(sector_t *sector, boolean crunch);
|
|
|
|
void P_DelSeclist(msecnode_t *node);
|
|
|
|
void P_CreateSecNodeList(mobj_t *thing, fixed_t x, fixed_t y);
|
|
|
|
void P_RadiusAttack(mobj_t *spot, mobj_t *source, fixed_t damagedist);
|
|
|
|
fixed_t P_FloorzAtPos(fixed_t x, fixed_t y, fixed_t z, fixed_t height);
|
|
boolean PIT_PushableMoved(mobj_t *thing);
|
|
|
|
boolean P_DoSpring(mobj_t *spring, mobj_t *object);
|
|
|
|
//
|
|
// P_SETUP
|
|
//
|
|
extern UINT8 *rejectmatrix; // for fast sight rejection
|
|
extern INT32 *blockmaplump; // offsets in blockmap are from here
|
|
extern INT32 *blockmap; // Big blockmap
|
|
extern INT32 bmapwidth;
|
|
extern INT32 bmapheight; // in mapblocks
|
|
extern fixed_t bmaporgx;
|
|
extern fixed_t bmaporgy; // origin of block map
|
|
extern mobj_t **blocklinks; // for thing chains
|
|
extern precipmobj_t **precipblocklinks; // special blockmap for precip rendering
|
|
|
|
extern struct minimapinfo
|
|
{
|
|
patch_t *minimap_pic;
|
|
INT32 min_x, min_y;
|
|
INT32 max_x, max_y;
|
|
INT32 map_w, map_h;
|
|
INT32 minimap_w, minimap_h;
|
|
fixed_t offs_x, offs_y;
|
|
fixed_t zoom;
|
|
} minimapinfo;
|
|
|
|
//
|
|
// P_INTER
|
|
//
|
|
|
|
// replace damage magic numbers with smth readable
|
|
#define DMG_INSTAKILL 10000
|
|
#define DMG_SPECTATOR 42000
|
|
|
|
void P_RemoveShield(player_t *player);
|
|
boolean P_DamageMobj(mobj_t *target, mobj_t *inflictor, mobj_t *source, INT32 damage);
|
|
void P_KillMobj(mobj_t *target, mobj_t *inflictor, mobj_t *source);
|
|
void P_PlayerRingBurst(player_t *player, INT32 num_rings); /// \todo better fit in p_user.c
|
|
void P_PlayerWeaponPanelBurst(player_t *player);
|
|
void P_PlayerWeaponAmmoBurst(player_t *player);
|
|
void P_PlayerEmeraldBurst(player_t *player, boolean toss);
|
|
|
|
void P_TouchSpecialThing(mobj_t *special, mobj_t *toucher, boolean heightcheck);
|
|
void P_PlayerFlagBurst(player_t *player, boolean toss);
|
|
void P_CheckTimeLimit(void);
|
|
void P_CheckPointLimit(void);
|
|
boolean P_CheckRacers(void);
|
|
|
|
boolean P_CanPickupItem(player_t *player, UINT8 weapon);
|
|
void P_DoNightsScore(player_t *player);
|
|
|
|
//
|
|
// P_SPEC
|
|
//
|
|
#include "p_spec.h"
|
|
|
|
extern INT32 ceilmovesound;
|
|
|
|
// Factor to scale scrolling effect into mobj-carrying properties = 3/32.
|
|
// (This is so scrolling floors and objects on them can move at same speed.)
|
|
#define CARRYFACTOR (FRACUNIT-ORIG_FRICTION)
|
|
|
|
void P_MixUp(mobj_t *thing, fixed_t x, fixed_t y, fixed_t z, angle_t angle,
|
|
INT16 starpostx, INT16 starposty, INT16 starpostz,
|
|
INT32 starpostnum, tic_t starposttime, angle_t starpostangle,
|
|
INT32 flags2);
|
|
boolean P_Teleport(mobj_t *thing, fixed_t x, fixed_t y, fixed_t z, angle_t angle, boolean flash, boolean dontstopmove);
|
|
boolean P_SetMobjStateNF(mobj_t *mobj, statenum_t state);
|
|
boolean P_CheckMissileSpawn(mobj_t *th);
|
|
void P_Thrust(mobj_t *mo, angle_t angle, fixed_t move);
|
|
void P_ExplodeMissile(mobj_t *mo);
|
|
void P_CheckGravity(mobj_t *mo, boolean affect);
|
|
|
|
#ifdef __cplusplus
|
|
} // extern "C"
|
|
#endif
|
|
|
|
#endif // __P_LOCAL__
|