raze/source/games/duke/src/funct.h

261 lines
10 KiB
C
Raw Normal View History

2020-06-24 19:21:02 +00:00
#pragma once
2020-07-06 20:23:18 +00:00
#include "screenjob.h"
2020-07-06 16:08:31 +00:00
#include "constants.h"
#include "packet.h"
#include "types.h"
2020-07-06 20:23:18 +00:00
2020-07-07 20:41:31 +00:00
struct MapRecord;
2020-07-06 20:23:18 +00:00
BEGIN_DUKE_NS
2020-07-06 20:23:18 +00:00
// dumping ground for all external function prototypes to keep them out of the important headers.
2020-07-07 07:39:33 +00:00
// This list is not sorted in any way.
void lava_cleararrays();
void addjaildoor(int p1, int p2, int iht, int jlt, int p3, sectortype* h);
void addminecart(int p1, int p2, sectortype* i, int iht, int p3, sectortype* childsectnum);
2021-12-21 20:14:27 +00:00
void addtorch(DDukeActor* i);
void addlightning(DDukeActor* i);
2020-07-06 20:23:18 +00:00
2020-06-24 19:21:02 +00:00
void movecyclers(void);
void movedummyplayers(void);
void resetlanepics(void);
void moveplayers();
void doanimations();
void movefx();
void moveclouds(double interpfrac);
void movefta();
2020-06-24 19:21:02 +00:00
2022-01-21 00:04:08 +00:00
void clearcameras(int i, player_struct* p);
void RANDOMSCRAP(DDukeActor* i);
2020-10-24 08:37:20 +00:00
void movecrane(DDukeActor* i, int crane);
void detonate(DDukeActor* i, int explosion);
void movemasterswitch(DDukeActor* i);
2020-10-21 20:17:25 +00:00
void movetrash(DDukeActor* i);
void movewaterdrip(DDukeActor* i, int drip);
void movedoorshock(DDukeActor* i);
void movetouchplate(DDukeActor* i, int plate);
void movecanwithsomething(DDukeActor* i);
2020-10-21 20:29:35 +00:00
void bounce(DDukeActor* i);
void movetongue(DDukeActor* i, int tongue, int jaw);
void rpgexplode(DDukeActor* i, int j, const DVector3& pos, int EXPLOSION2, int EXPLOSIONBOT2, int newextra, int playsound);
void moveooz(DDukeActor* i, int seenine, int seeninedead, int ooz, int explosion);
void lotsofstuff(DDukeActor* s, int n, int spawntype);
2020-10-21 20:34:45 +00:00
bool respawnmarker(DDukeActor* i, int yellow, int green);
bool rat(DDukeActor* i, bool makesound);
bool queball(DDukeActor* i, int pocket, int queball, int stripeball);
2020-10-21 20:59:56 +00:00
void forcesphere(DDukeActor* i, int forcesphere);
void recon(DDukeActor* i, int explosion, int firelaser, int attacksnd, int painsnd, int roamsnd, int shift, int (*getspawn)(DDukeActor* i));
2020-10-21 21:04:14 +00:00
void ooz(DDukeActor* i);
void reactor(DDukeActor* i, int REACTOR, int REACTOR2, int REACTORBURNT, int REACTOR2BURNT, int REACTORSPARK, int REACTOR2SPARK);
void camera(DDukeActor* i);
void bloodsplats(DDukeActor* actor);
void forcesphereexplode(DDukeActor* i);
void watersplash2(DDukeActor* i);
void frameeffect1(DDukeActor* i);
bool money(DDukeActor* i, int BLOODPOOL);
bool jibs(DDukeActor* i, int JIBS6, bool timeout, bool callsetsprite, bool floorcheck, bool zcheck1, bool zcheck2);
2022-01-26 23:41:33 +00:00
bool bloodpool(DDukeActor* i, bool puke);
void shell(DDukeActor* i, bool morecheck);
void glasspieces(DDukeActor* i);
2020-06-24 19:21:02 +00:00
2022-01-19 09:48:18 +00:00
void handle_se00(DDukeActor* i);
2020-10-21 21:39:12 +00:00
void handle_se01(DDukeActor* i);
void handle_se14(DDukeActor* i, bool checkstat, int RPG, int JIBS6);
2020-10-21 22:00:43 +00:00
void handle_se30(DDukeActor* i, int JIBS6);
2020-10-21 22:10:43 +00:00
void handle_se02(DDukeActor* i);
void handle_se03(DDukeActor* i);
void handle_se04(DDukeActor* i);
2020-10-21 22:14:54 +00:00
void handle_se05(DDukeActor* i, int FIRELASER);
void handle_se08(DDukeActor* i, bool checkhitag1);
void handle_se10(DDukeActor* i, const int *);
2020-10-21 22:20:47 +00:00
void handle_se11(DDukeActor* i);
void handle_se12(DDukeActor* i, int planeonly = 0);
void handle_se13(DDukeActor* i);
2020-10-21 22:25:11 +00:00
void handle_se15(DDukeActor* i);
void handle_se16(DDukeActor* i, int REACTOR, int REACTOR2);
void handle_se17(DDukeActor* i);
2020-10-21 22:30:22 +00:00
void handle_se18(DDukeActor* i, bool morecheck);
void handle_se19(DDukeActor* i, int BIGFORCE);
2020-10-21 22:35:30 +00:00
void handle_se20(DDukeActor* i);
void handle_se21(DDukeActor* i);
void handle_se22(DDukeActor* i);
2022-09-12 19:59:34 +00:00
void handle_se24(DDukeActor* actor, bool scroll, double shift);
2022-09-12 21:35:48 +00:00
void handle_se25(DDukeActor* a, int snd1, int snd2);
2020-10-21 22:35:30 +00:00
void handle_se26(DDukeActor* i);
2020-10-21 22:40:57 +00:00
void handle_se27(DDukeActor* i);
void handle_se29(DDukeActor* actor);
2020-10-21 23:04:13 +00:00
void handle_se31(DDukeActor* a, bool choosedir);
2020-10-21 22:40:57 +00:00
void handle_se32(DDukeActor* i);
void handle_se35(DDukeActor* i, int SMALLSMOKE, int EXPLOSION2);
void handle_se128(DDukeActor* i);
void handle_se130(DDukeActor* i, int countmax, int EXPLOSION2);
2020-06-24 19:21:02 +00:00
void respawn_rrra(DDukeActor* oldact, DDukeActor* newact);
2020-10-22 17:08:10 +00:00
void check_fta_sounds_d(DDukeActor* i);
void check_fta_sounds_r(DDukeActor* i);
2020-06-24 19:21:02 +00:00
int dodge(DDukeActor*);
2020-10-22 14:40:48 +00:00
void alterang(int ang, DDukeActor* actor, int g_p);
void fall_common(DDukeActor* actor, int g_p, int JIBS6, int DRONE, int BLOODPOOL, int SHOTSPARK1, int squished, int thud, int(*fallspecial)(DDukeActor*, int));
2022-02-07 10:04:19 +00:00
void checkavailweapon(player_struct* p);
void deletesprite(DDukeActor* num);
2022-02-07 10:04:19 +00:00
void addammo(int weapon, player_struct* p, int amount);
2020-06-24 19:21:02 +00:00
2020-10-21 17:38:53 +00:00
int ssp(DDukeActor* i, unsigned int cliptype); //The set sprite function
void insertspriteq(DDukeActor *i);
2020-10-22 17:27:59 +00:00
int wakeup(DDukeActor* sn, int pn);
2020-07-06 20:23:18 +00:00
int timedexit(int snum);
void dokneeattack(int snum, const std::initializer_list<int>& respawnlist);
2020-07-06 20:23:18 +00:00
int endoflevel(int snum);
2022-09-14 19:25:27 +00:00
void playerisdead(int snum, int psectlotag, double fz, double cz);
2020-07-06 20:23:18 +00:00
void footprints(int snum);
int makepainsounds(int snum, int type);
void playerCrouch(int snum);
2022-09-14 20:04:41 +00:00
void playerJump(int snum, double fz, double cz);
2020-11-29 08:00:00 +00:00
void checklook(int snum, ESyncBits actions);
2020-07-06 20:23:18 +00:00
void playerCenterView(int snum);
void playerLookUp(int snum, ESyncBits actions);
void playerLookDown(int snum, ESyncBits actions);
void playerAimUp(int snum, ESyncBits actions);
void playerAimDown(int snum, ESyncBits actions);
2022-09-13 21:07:08 +00:00
void tracers(const DVector3& start, const DVector3& dest, int n);
DDukeActor* aim(DDukeActor* s, int aang);
2022-02-07 10:04:19 +00:00
void checkweapons(player_struct* const p);
int findotherplayer(int p, double* d);
2022-02-07 10:04:19 +00:00
void quickkill(player_struct* p);
int setpal(player_struct* p);
2020-07-06 20:23:18 +00:00
int madenoise(int playerNum);
int haskey(sectortype* sect, int snum);
2022-09-13 18:54:34 +00:00
void shootbloodsplat(DDukeActor* i, int p, const DVector3& pos, DAngle ang, int atwith, int BIGFORCE, int OOZFILTER, int NEWBEAST);
2020-07-06 20:23:18 +00:00
2021-11-17 23:32:46 +00:00
void breakwall(int newpn, DDukeActor* spr, walltype* dawallnum);
int callsound(sectortype* sectnum,DDukeActor* snum, bool endstate = false);
2022-09-13 22:11:16 +00:00
double hitasprite(DDukeActor* snum,DDukeActor **hitSprite);
int findplayer(const DDukeActor* s, double* dist);
2020-07-06 20:23:18 +00:00
void operatejaildoors(int hitag);
void allignwarpelevators(void);
bool isablockdoor(int tileNum);
2020-10-23 15:46:46 +00:00
bool activatewarpelevators(DDukeActor* s, int w);
2020-07-06 20:23:18 +00:00
int check_activator_motion(int lotag);
void operateactivators(int l, int w);
2020-10-23 18:02:57 +00:00
void operateforcefields_common(DDukeActor* s, int low, const std::initializer_list<int>& tiles);
2020-07-06 20:23:18 +00:00
void operatemasterswitches(int lotag);
2021-11-18 17:51:19 +00:00
void operatesectors(sectortype* s, DDukeActor* i);
2020-07-06 20:23:18 +00:00
void hud_input(int playerNum);
2022-09-12 17:47:07 +00:00
int getanimationindex(int animtype, sectortype* animindex);
2020-07-06 20:23:18 +00:00
bool isanearoperator(int lotag);
bool isanunderoperator(int lotag);
2022-09-12 17:47:07 +00:00
int setanimation(sectortype* animsect, int animtype, walltype* animtarget, double thegoal, double thevel);
int setanimation(sectortype* animsect, int animtype, sectortype* animtarget, double thegoal, double thevel);
void dofurniture(walltype* wallNum, sectortype* sectnum, int playerNum);
2020-07-06 20:23:18 +00:00
void dotorch();
2022-09-13 22:15:45 +00:00
double hitawall(player_struct* pl, walltype** hitWall);
2022-09-13 22:05:32 +00:00
double hits(DDukeActor* snum);
2020-07-06 20:23:18 +00:00
DDukeActor* LocateTheLocator(int n, sectortype* sectnum);
2020-07-06 20:23:18 +00:00
void clearcamera(player_struct* ps);
2020-10-23 18:27:05 +00:00
void LoadActor(DDukeActor* i, int p, int x);
void execute(DDukeActor* s, int p, double d);
2020-10-21 23:11:38 +00:00
void makeitfall(DDukeActor* s);
DAngle furthestangle(DDukeActor* snum, int angDiv);
2020-10-21 23:10:56 +00:00
void getglobalz(DDukeActor* s);
void OnEvent(int id, int pnum = -1, DDukeActor* snum = nullptr, int dist = -1);
2020-07-06 15:30:23 +00:00
2022-10-07 16:51:29 +00:00
DDukeActor* CreateActor(sectortype* whatsectp, const DVector3& pos, int s_pn, int8_t s_shd, const DVector2& scale, DAngle s_ang, double s_vel, double s_zvel, DDukeActor* s_ow, int8_t s_stat);
DDukeActor* CreateActor(sectortype* whatsectp, const DVector3& pos, PClassActor* cls, int8_t s_shd, const DVector2& scale, DAngle s_ang, double s_vel, double s_zvel, DDukeActor* s_ow, int8_t s_stat);
2022-11-15 09:17:23 +00:00
DDukeActor* SpawnActor(sectortype* whatsectp, const DVector3& pos, PClassActor* cls, int8_t s_shd, const DVector2& scale, DAngle s_ang, double s_vel, double s_zvel, DDukeActor* s_ow, int8_t s_stat = -1);
2022-10-07 16:51:29 +00:00
void ceilingglass(DDukeActor* snum, sectortype* sectnum, int cnt);
void spriteglass(DDukeActor* snum, int cnt);
2021-11-17 23:38:20 +00:00
void lotsofcolourglass(DDukeActor* snum, walltype* wallNum, int cnt);
void lotsofglass(DDukeActor* snum, walltype* wallnum, int cnt);
2022-02-07 10:04:19 +00:00
void checkplayerhurt_d(player_struct* p, const Collision& coll);
void checkplayerhurt_r(player_struct* p, const Collision& coll);
DDukeActor* dospawnsprite(DDukeActor* actj, int pn);
void spriteinit_d(DDukeActor*);
void spriteinit_r(DDukeActor*);
DDukeActor* spawninit_d(DDukeActor* actj, DDukeActor* act, TArray<DDukeActor*>* actors);
DDukeActor* spawninit_r(DDukeActor* actj, DDukeActor* act, TArray<DDukeActor*>* actors);
2020-07-06 16:08:31 +00:00
void addspritetodelete(int spnum=0);
2022-02-07 10:04:19 +00:00
void checkavailinven(player_struct* p);
bool initspriteforspawn(DDukeActor* spn);
2020-11-02 17:58:23 +00:00
void spawninitdefault(DDukeActor* actj, DDukeActor* act);
2020-11-02 20:21:52 +00:00
void spawntransporter(DDukeActor* actj, DDukeActor* acti, bool beam);
int spawnbloodpoolpart1(DDukeActor* acti);
2020-11-02 20:21:52 +00:00
void initfootprint(DDukeActor* actj, DDukeActor* acti);
void initshell(DDukeActor* actj, DDukeActor* acti, bool isshell);
void initwaterdrip(DDukeActor* actj, DDukeActor* acti);
int initreactor(DDukeActor* actj, DDukeActor* acti, bool isrecon);
void spawneffector(DDukeActor* actor, TArray<DDukeActor*>* actors);
2020-07-15 16:10:31 +00:00
int startrts(int lumpNum, int localPlayer);
2020-07-06 16:08:31 +00:00
2020-07-06 19:10:20 +00:00
void pickrandomspot(int pn);
void premapcontroller(DDukeActor* ac);
2020-07-06 19:10:20 +00:00
void resetinventory(int pn);
void resetplayerstats(int pn);
void resetweapons(int pn);
void resetprestat(int snum, int g);
void prelevel_common(int g);
2020-07-07 11:19:09 +00:00
void cacheit_d();
void cacheit_r();
2020-07-06 19:10:20 +00:00
2022-02-07 10:04:19 +00:00
void FTA(int q, player_struct* p);
2020-10-27 05:50:06 +00:00
void OnMotorcycle(player_struct *pl, DDukeActor* snum);
2020-07-06 21:33:33 +00:00
void OffMotorcycle(player_struct *pl);
void OnBoat(player_struct *pl, DDukeActor* snum);
2020-07-06 21:33:33 +00:00
void OffBoat(player_struct *pl);
2020-11-02 23:20:51 +00:00
void cameratext(DDukeActor* i);
void dobonus(int bonusonly, const CompletionFunc& completion);
void drawweapon(double interpfrac);
void drawoverlays(double interpfrac);
void drawbackground(void);
void displayrooms(int32_t playerNum, double interpfrac, bool sceneonly);
void setgamepalette(int palid);
2020-07-07 11:19:09 +00:00
void resetmys();
2020-07-07 15:56:20 +00:00
void resettimevars();
bool setnextmap(bool checksecretexit);
void prelevel_d(int g, TArray<DDukeActor*>&);
void prelevel_r(int g, TArray<DDukeActor*>&);
void e4intro(const CompletionFunc& completion);
void exitlevel(MapRecord *next);
void enterlevel(MapRecord* mi, int gm);
void donewgame(MapRecord* map, int sk);
int playercolor2lookup(int color);
2020-07-15 16:10:31 +00:00
void PlayerColorChanged(void);
bool movementBlocked(player_struct *p);
void loadcons();
void recordoldspritepos();
void DrawStatusBar();
inline int32_t krand(void)
{
randomseed = (randomseed * 27584621) + 1;
return ((uint32_t)randomseed) >> 16;
}
inline double krandf(double span)
{
return (krand() & 0x7fff) * span / 32767;
}
2022-08-22 18:08:45 +00:00
inline double zrand(double spread)
2022-02-12 11:37:27 +00:00
{
2022-08-22 18:08:45 +00:00
int r = krand() % FloatToFixed<8>(spread);
return FixedToFloat<8>(r);
2022-02-12 11:37:27 +00:00
}
2020-07-06 20:23:18 +00:00
END_DUKE_NS