read the sectornode list stuff this means we reuse old stale data in some cases, which also causes strange bugs with orbiting items in some cases, but thats what vanilla does and we HAVE to keep vanilla compat after all i really hope this does not cause any fun impossible to debug crashes, but what can you do
504 lines
17 KiB
C
504 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__
|
|
|
|
#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
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
#define FLOATSPEED (FRACUNIT*4)
|
|
|
|
// 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)
|
|
|
|
// unused modes, kept for compat
|
|
#define nightsmode (UNLIKELY(maptol & TOL_NIGHTS))
|
|
#define nightsplayer(player) (UNLIKELY((player)->pflags & PF_NIGHTSMODE))
|
|
#define mariomode (UNLIKELY(maptol & TOL_MARIO))
|
|
#define twodlevel (UNLIKELY(maptol & TOL_2D))
|
|
#define twodmo(mobj) (UNLIKELY(twodlevel || ((mobj)->flags2 & MF2_TWOD)))
|
|
|
|
//
|
|
// 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;
|
|
|
|
// 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;
|
|
|
|
// 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);
|
|
INT32 P_GetLocalPlayerNumForPlayer(const player_t *player);
|
|
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_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_PlayerThink(player_t *player);
|
|
void P_PlayerAfterThink(player_t *player);
|
|
void P_DoPlayerExit(player_t *player);
|
|
void P_DoTimeOver(player_t *player);
|
|
|
|
angle_t P_GetLocalAngle(player_t *player);
|
|
void P_ForceLocalAngle(player_t *player, angle_t angle);
|
|
|
|
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_AnalogMove(player_t *player);
|
|
UINT8 P_FindLowestLap(void);
|
|
UINT8 P_FindHighestLap(void);
|
|
void P_FindEmerald(void);
|
|
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);
|
|
|
|
extern mobjtype_t g_doomednum_to_mobjtype[MAXDOOMEDNUM+1];
|
|
void CalculateDoomednumToMobjtype(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_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);
|
|
}
|
|
|
|
// stupid, but kart allows mobjs that are marked to be removed to be accessed and modified in many cases
|
|
// so can only check if its not NULL in vanilla compat mode
|
|
FUNCINLINE static ATTRINLINE boolean P_MobjWasRemovedCompat(const mobj_t *mobj)
|
|
{
|
|
#ifdef PHOBOS_BUILD
|
|
return P_MobjWasRemoved(mobj);
|
|
#else
|
|
return !mobj;
|
|
#endif
|
|
}
|
|
|
|
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_Initsecnode(void);
|
|
|
|
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"
|
|
|
|
// 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__
|