// BLANKART //----------------------------------------------------------------------------- // Copyright (C) 1998-2000 by DooM Legacy Team. // Copyright (C) 1999-2020 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 deh_tables.c /// \brief Define DeHackEd tables. #include "d_player.h" #include "d_ticcmd.h" #include "doomdef.h" // Constants #include "s_sound.h" // Sound constants #include "i_sound.h" #include "info.h" // Mobj, state, sprite, etc constants #include "m_menu.h" // Menu constants #include "y_inter.h" // Intermission constants #include "p_local.h" // some more constants #include "r_draw.h" // Colormap constants #include "lua_script.h" // Lua stuff #include "m_cond.h" // Emblem constants #include "v_video.h" // video flags (for lua) #include "i_sound.h" // musictype_t (for lua) #include "g_state.h" // gamestate_t (for lua) #include "r_data.h" // patchalphastyle_t #include "k_boss.h" // spottype_t (for lua) #include "k_follower.h" // followermode_t (for lua) #include "k_bot.h" // bot constants (for lua) #include "g_input.h" // Game controls (for lua) #include "k_kart.h" // awardscaledrings_t #include "k_hud.h" // scoreboardmod_e #include "k_waypoint.h" // waypoint values (for lua) #include "h_timers.h" // timerflags_t #include "deh_tables.h" strbuf_t *statenames; strbuf_t *mobjnames; strbuf_t *skincolornames; strbuf_t *menunames; strbuf_t *kartitemnames; UINT8 used_spr[(NUMSPRITEFREESLOTS / 8) + 1]; // Bitwise flag for sprite freeslot in use! I would use ceil() here if I could, but it only saves 1 byte of memory anyway. const char *DEH_MobjtypeName(mobjtype_t i) { return strbuf_get(mobjnames, mobjinfo[i].info.nameofs); } const char *DEH_StateName(statenum_t i) { return strbuf_get(statenames, states[i].info.nameofs); } const char *DEH_SkincolorName(skincolornum_t i) { return strbuf_get(skincolornames, skincolors[i].info.nameofs); } const char *DEH_MenutypeName(menutype_t i) { return strbuf_get(menunames, menudefs[i].info.nameofs); } const char *DEH_KartItemName(kartitemtype_e i) { return strbuf_get(kartitemnames, kartitems[i].info.nameofs); } mobjtype_t DEH_FindMobjtype(const char *word) { mobjtype_t i; UINT32 hash = HASH32(word, strlen(word)); for (i = 0; i < nummobjtypes; i++) { if (hash != mobjinfo[i].info.namehash) continue; if (fastcmp(word, DEH_MobjtypeName(i))) return i; } return NUMMOBJTYPES; } statenum_t DEH_FindState(const char *word) { statenum_t i; UINT32 hash = HASH32(word, strlen(word)); for (i = 0; i < numstates; i++) { if (hash != states[i].info.namehash) continue; if (fastcmp(word, DEH_StateName(i))) return i; } return NUMSTATES; } skincolornum_t DEH_FindSkincolor(const char *word) { skincolornum_t i; UINT32 hash = HASH32(word, strlen(word)); for (i = 0; i < numskincolors; i++) { if (hash != skincolors[i].info.namehash) continue; if (fastcmp(word, DEH_SkincolorName(i))) return i; } return MAXSKINCOLORS; } menutype_t DEH_FindMenutype(const char *word) { menutype_t i; UINT32 hash = HASH32(word, strlen(word)); for (i = 0; i < nummenutypes; i++) { if (hash != menudefs[i].info.namehash) continue; if (fastcmp(word, DEH_MenutypeName(i))) return i; } return MAXMENUTYPES; } kartitemtype_e DEH_FindKartItem(const char *word) { kartitemtype_e i; UINT32 hash = HASH32(word, strlen(word)); for (i = 0; i < numkartitems; i++) { if (hash != kartitems[i].info.namehash) continue; if (fastcmp(word, DEH_KartItemName(i))) return i; } return MAXKARTITEMS; } struct flickytypes_s FLICKYTYPES[] = { {"BLUEBIRD", MT_FLICKY_01}, // Flicky (Flicky) {"RABBIT", MT_FLICKY_02}, // Pocky (1) {"CHICKEN", MT_FLICKY_03}, // Cucky (1) {"SEAL", MT_FLICKY_04}, // Rocky (1) {"PIG", MT_FLICKY_05}, // Picky (1) {"CHIPMUNK", MT_FLICKY_06}, // Ricky (1) {"PENGUIN", MT_FLICKY_07}, // Pecky (1) {"FISH", MT_FLICKY_08}, // Nicky (CD) {"RAM", MT_FLICKY_09}, // Flocky (CD) {"PUFFIN", MT_FLICKY_10}, // Wicky (CD) {"COW", MT_FLICKY_11}, // Macky (SRB2) {"RAT", MT_FLICKY_12}, // Micky (2) {"BEAR", MT_FLICKY_13}, // Becky (2) {"DOVE", MT_FLICKY_14}, // Docky (CD) {"CAT", MT_FLICKY_15}, // Nyannyan (Flicky) {"CANARY", MT_FLICKY_16}, // Lucky (CD) {"a", 0}, // End of normal flickies - a lower case character so will never fastcmp valid with uppercase tmp //{"FLICKER", MT_FLICKER}, // Flacky (SRB2) {"SPIDER", MT_SECRETFLICKY_01}, // Sticky (SRB2) {"BAT", MT_SECRETFLICKY_02}, // Backy (SRB2) {"SEED", MT_SEED}, // Seed (CD) {NULL, 0} }; actionpointer_t actionpointers[] = { #define _(name, upper, ...) {name, "A_"#upper}, #include "info/actions.h" #undef _ {NULL, "NONE"}, // This NULL entry must be the last in the list {NULL, NULL}, }; //////////////////////////////////////////////////////////////////////////////// // CRAZY LIST OF STATE NAMES AND ALL FROM HERE DOWN // TODO: Make this all a seperate file or something, like part of info.c?? // TODO: Read the list from a text lump in a WAD as necessary instead // or something, don't just keep it all in memory like this. // TODO: Make the lists public so we can start using actual mobj // and state names in warning and error messages! :D struct int_const_s const STATE_ALIASES[] = { {"KART_STND1", S_KART_STILL}, {"KART_STND2" , S_KART_STILL}, {"KART_STND1_L" , S_KART_STILL_L}, {"KART_STND2_L", S_KART_STILL_L}, {"KART_STND1_R", S_KART_STILL_R}, {"KART_STND2_R", S_KART_STILL_R}, {"KART_WALK1", S_KART_SLOW}, {"KART_WALK2", S_KART_SLOW}, {"KART_WALK1_L", S_KART_SLOW_L}, {"KART_WALK2_L", S_KART_SLOW_L}, {"KART_WALK1_R", S_KART_SLOW_R}, {"KART_WALK2_R", S_KART_SLOW_R}, {"KART_RUN1", S_KART_FAST}, {"KART_RUN2", S_KART_FAST}, {"KART_RUN1_L", S_KART_FAST_L}, {"KART_RUN2_L", S_KART_FAST_L}, {"KART_RUN1_R", S_KART_FAST_R}, {"KART_RUN2_R", S_KART_FAST_R}, {"KART_DRIFT1_L", S_KART_DRIFT_L}, {"KART_DRIFT2_L", S_KART_DRIFT_L}, {"KART_DRIFT1_R", S_KART_DRIFT_R}, {"KART_DRIFT2_R", S_KART_DRIFT_R}, {"KART_DRIFT1_L", S_KART_DRIFT_L_OUT}, {"KART_DRIFT2_L", S_KART_DRIFT_L_IN}, {"KART_DRIFT1_R", S_KART_DRIFT_R_OUT}, {"KART_DRIFT2_R", S_KART_DRIFT_R_IN}, {"KART_SPIN", S_KART_SPINOUT}, {"KART_PAIN", S_KART_DEAD}, {"KART_SQUISH", S_KART_SPINOUT}, {"PLAY_SIGN", S_KART_SIGN}, { NULL, 0 } }; struct int_const_s const MOBJ_ALIASES[] = { {"BIRD", MT_FLICKY_01}, {"BUNNY" , MT_FLICKY_02}, {"MOUSE" , MT_FLICKY_12}, {"CHICKEN" , MT_FLICKY_03}, {"REDBIRD", MT_FLICKY_10}, {"COW", MT_FLICKY_11}, { NULL, 0 } }; struct int_const_s const GAMETYPE_ALIASES[] = { {"GT_MATCH", GT_BATTLE}, { NULL, 0 } }; const char *const MOBJFLAG_LIST[] = { "SPECIAL", "SOLID", "SHOOTABLE", "NOSECTOR", "NOBLOCKMAP", "PAPERCOLLISION", "PUSHABLE", "BOSS", "SPAWNCEILING", "NOGRAVITY", "AMBIENT", "SLIDEME", "NOCLIP", "FLOAT", "BOXICON", "MISSILE", "SPRING", "MONITOR", "NOTHINK", "FIRE", "NOCLIPHEIGHT", "ENEMY", "SCENERY", "PAIN", "STICKY", "APPLYTERRAIN", "NOCLIPTHING", "GRENADEBOUNCE", "RUNSPAWNFUNC", "DONTENCOREMAP", "PICKUPFROMBELOW", "BOUNCE", NULL }; // \tMF2_(\S+).*// (.+) --> \t"\1", // \2 const char *const MOBJFLAG2_LIST[] = { "AXIS", // It's a NiGHTS axis! (For faster checking) "SHADOW", // alias for RF_GHOSTLY "DONTRESPAWN", // Don't respawn this object! "DONTDRAW", // alias for RF_DONTDRAW "AUTOMATIC", // Thrown ring has automatic properties "RAILRING", // Thrown ring has rail properties "BOUNCERING", // Thrown ring has bounce properties "EXPLOSION", // Thrown ring has explosive properties "SCATTER", // Thrown ring has scatter properties "BEYONDTHEGRAVE", // Source of this missile has died and has since respawned. "SLIDEPUSH", // MF_PUSHABLE that pushes continuously. "CLASSICPUSH", // Drops straight down when object has negative momz. "INVERTAIMABLE", // Flips whether it's targetable by A_LookForEnemies (enemies no, decoys yes) "INFLOAT", // Floating to a height for a move, don't auto float to target's height. "DEBRIS", // Splash ring from explosion ring "NIGHTSPULL", // Attracted from a paraloop "JUSTATTACKED", // can be pushed by other moving mobjs "FIRING", // turret fire "SUPERFIRE", // Firing something with Super Sonic-stopping properties. Or, if mobj has MF_MISSILE, this is the actual fire from it. "DONTSYNC", // Prevents this mobj from triggering stuff or being sent. Used for sync safety on toggle effects. "STRONGBOX", // Flag used for "strong" random monitors. "OBJECTFLIP", // Flag for objects that always have flipped gravity. "SKULLFLY", // Special handling: skull in flight. "FRET", // Flashing from a previous hit "BOSSNOTRAP", // No Egg Trap after boss "BOSSFLEE", // Boss is fleeing! "BOSSDEAD", // Boss is dead! (Not necessarily fleeing, if a fleeing point doesn't exist.) "AMBUSH", // Alternate behaviour typically set by MTF_AMBUSH "LINKDRAW", // Draw vissprite of mobj immediately before/after tracer's vissprite (dependent on dispoffset and position) "SHIELD", // Thinker calls P_AddShield/P_ShieldLook (must be partnered with MF_SCENERY to use) "WATERRUN", // Mobj is able to run on Water! NULL }; const char *const MOBJEFLAG_LIST[] = { "ONGROUND", // The mobj stands on solid floor (not on another mobj or in air) "JUSTHITFLOOR", // The mobj just hit the floor while falling, this is cleared on next frame "TOUCHWATER", // The mobj stands in a sector with water, and touches the surface "UNDERWATER", // The mobj stands in a sector with water, and his waist is BELOW the water surface "JUSTSTEPPEDDOWN", // used for ramp sectors "VERTICALFLIP", // Vertically flip sprite/allow upside-down physics "GOOWATER", // Goo water "TOUCHLAVA", // The mobj is touching a lava block "PUSHED", // Mobj was already pushed this tic "SPRUNG", // Mobj was already sprung this tic "APPLYPMOMZ", // Platform movement "TRACERANGLE", // Compute and trigger on mobj angle relative to tracer "JUSTBOUNCEDWALL", "\x01", "SLOPELAUNCHED", "\x01", // eflags is only 16 bits wide... "\x01", "\x01", "\x01", "\x01", // but the RF_DONTDRAW flags are in bits 20-23... "DRAWONLYFORP1", "DRAWONLYFORP2", "DRAWONLYFORP3", "DRAWONLYFORP4", // cheeky! NULL }; const char *const MAPTHINGFLAG_LIST[4] = { "EXTRA", // Extra flag for objects. "OBJECTFLIP", // Reverse gravity flag for objects. "OBJECTSPECIAL", // Special flag used with certain objects. "AMBUSH" // Deaf monsters/do not react to sound. }; const char *const PLAYERFLAG_LIST[] = { "GODMODE", // Immortal. "\x01", "\x01", // Look back VFX has been spawned // TODO: Is there a better way to track this? "GAINAX", "KICKSTARTACCEL", // Accessibility feature: Is accelerate in kickstart mode? "\x01", "\x01", "WANTSTOJOIN", // Spectator that wants to join "STASIS", // Player is not allowed to move "FAILEDSTART", // Player failed the startboost "ELIMINATED", // Battle-style elimination, no extra penalty "NOCONTEST", // Did not finish (last place explosion) "LOSTLIFE", // Do not lose life more than once "RINGLOCK", // Prevent picking up rings while locked. Mostly for lua use since SPB no longer locks "DRIFTINPUT", // Drifting! "GETSPARKS", // Can get sparks "DRIFTEND", // Drift has ended, used to adjust character angle after drift "BRAKEDRIFT", // Helper for brake-drift spark spawning "AIRFAILSAFE", // Whenever or not try the air boost "UPDATEMYRESPAWN", "FLIPCAM", "TRUSTWAYPOINTS", // Do not activate lap cheat prevention next time finish line distance is updated "FREEZEWAYPOINTS", // Skip the next waypoint/finish line distance update "HITFINISHLINE", // Already hit the finish line this tic "WRONGWAY", // Moving the wrong way with respect to waypoints? "SHRINKME", // "Shrink me" cheat preference "SHRINKACTIVE", // "Shrink me" cheat is in effect. (Can't be disabled mid-race) "JUSTFLIPPED", // Just got flipped over, handle the bump interaction. "\x01", "USEDOWN", "ATTACKDOWN", "SLIDING", NULL // stop loop here. }; struct int_const_s const PLAYERFLAG_ALIASES[] = { {"TIMEOVER", PF_NOCONTEST}, {"FULLSTASIS", PF_STASIS}, {"SKIDDOWN", PF_FAILEDSTART}, // These do nothing in kart but still exist so we need to "support" them :/ // Mostly for code that are hardcode copies // Input stuff {"JUMPSTASIS", 0}, {"FORCESTRAFE", 0}, {"ANALOGMODE", 0}, // NiGHTS... {"NIGHTSMODE", 0}, {"TRANSFERTOCLOSEST", 0}, {"NIGHTSFALL", 0}, {"DRILLING", 0}, // Hanging..? {"ITEMHANG", 0}, {"ROPEHANG", 0}, {"MACESPIN", 0}, // Base ability shit from SRB2 {"GLIDING", 0}, {"CARRIED", 0}, {"JUMPED", 0}, {"SPINNING", 0}, {"STARTDASH", 0}, {"THOKKED", 0}, // Unused DOWNS {"WPNDOWN", 0}, {"JUMPDOWN", 0}, // Tag, your it! {"TAGGED", 0}, {"TAGIT", 0}, { NULL, 0 } }; const char *const AIRDROPFLAG_LIST[] = { "AIRDROPINPUT", // Wants air drop (active while holding down brake, used for bouncy air drop) "WANTSAIRDROP", // Is in Air Drop (activation / deactivation criteria change if light or heavy) "AIRDROP_LIGHT", // Is in Light Air Drop "AIRDROP_HEAVY", // Is in Heavy Air Drop "AIRDROP_MASK", // Is in any Air Drop state NULL // stop loop here. }; const char *const ITEMFLAG_LIST[] = { "USERINGS", "ITEMOUT", "EGGMANOUT", "HOLDREADY", NULL // stop loop here. }; const char *const GAMETYPERULE_LIST[] = { "CIRCUIT", "RACEODDS", "BOTS", "RINGS", "BUMPERS", "POINTS", "BATTLEODDS", "PAPERITEMS", "WANTED", "WANTEDSPB", "KARMA", "ITEMARROWS", "ITEMBREAKER", "BATTLESTARTS", "CLOSERPLAYERS", "BATTLEBOXES", "BATTLESPEED", "DOUBLEDFLASHTICS", "POINTLIMIT", "TIMELIMIT", "OVERTIME", "TEAMS", "NOTEAMS", "TEAMSTARTS", "LIVES", "SPECIALBOTS", "NOCOUNTDOWN", "ENCORE", NULL }; // Linedef flags const char *const ML_LIST[] = { "IMPASSABLE", "BLOCKMONSTERS", "TWOSIDED", "DONTPEGTOP", "DONTPEGBOTTOM", "SKEWTD", "NOCLIMB", "NOSKEW", "MIDPEG", "MIDSOLID", "WRAPMIDTEX", "NETONLY", "NONET", "EFFECT6", "NOTBOUNCY", "TFERLINE", NULL }; // Linedef flags for Kart const char *const ML_LIST_KART[] = { "IMPASSIBLE", "BLOCKMONSTERS", "TWOSIDED", "DONTPEGTOP", "DONTPEGBOTTOM", "EFFECT1", "NOCLIMB", "EFFECT2", "EFFECT3", "EFFECT4", "EFFECT5", "NOSONIC", "NOTAILS", "NOKNUX", "BOUNCY", "TFERLINE", NULL }; // Sector flags const char *const MSF_LIST[] = { "FLIPSPECIAL_FLOOR", "FLIPSPECIAL_CEILING", "TRIGGERSPECIAL_TOUCH", "TRIGGERSPECIAL_HEADBUMP", "TRIGGERLINE_PLANE", "TRIGGERLINE_MOBJ", "INVERTPRECIP", "GRAVITYFLIP", "HEATWAVE", "NOCLIPCAMERA", "RIPPLE_FLOOR", "RIPPLE_CEILING", "INVERTENCORE", "FLATLIGHTING", "DIRECTIONLIGHTING", "NOEFX", NULL }; // Sector special flags const char *const SSF_LIST[] = { "NOSTEPUP", "DOUBLESTEPUP", "NOSTEPDOWN", "WINDCURRENT", "CONVEYOR", "SPEEDPAD", "STARPOSTACTIVATOR", "EXIT", "DELETEITEMS", "SNEAKERPANEL" , "WATERPANEL" , "REDPOGOSPRING", "YELLOWPOGOSPRING" , "FAN", "FINISHLINE", "ZOOMTUBESTART", "ZOOMTUBEEND", "NOPHYSICSFLOOR", "NOPHYSICSCEILING", "GRAVITYOVERRIDE", "WALLTRANSFER", NULL }; // Sector damagetypes const char *const SD_LIST[] = { "NONE", "GENERIC", "LAVA", "DEATHPIT", "INSTAKILL", "FLIPOVER", NULL }; // Sector triggerer const char *const TO_LIST[] = { "PLAYER", "ALLPLAYERS", "MOBJ", NULL }; const char *const POWERS_LIST[] = { "INVULNERABILITY", "SNEAKERS", "FLASHING", "SHIELD", "TAILSFLY", // tails flying "UNDERWATER", // underwater timer "SPACETIME", // In space, no one can hear you spin! "EXTRALIFE", // Extra Life timer "SUPER", // Are you super? "GRAVITYBOOTS", // gravity boots // Weapon ammunition "INFINITYRING", "AUTOMATICRING", "BOUNCERING", "SCATTERRING", "GRENADERING", "EXPLOSIONRING", "RAILRING", // Power Stones "EMERALDS", // stored like global 'emeralds' variable // NiGHTS powerups "NIGHTS_SUPERLOOP", "NIGHTS_HELPER", "NIGHTS_LINKFREEZE", //for linedef exec 427 "NOCONTROL", "INGOOP" // In goop }; const char *const KARTSTUFF_LIST[] = { "POSITION", "OLDPOSITION", "POSITIONDELAY", "PREVCHECK", "NEXTCHECK", "WAYPOINT", "STARPOSTWP", "STARPOSTFLIP", "RESPAWN", "DROPDASH", "THROWDIR", "LAPANIMATION", "LAPHAND", "CARDANIMATION", "VOICES", "TAUNTVOICES", "INSTASHIELD", "ENGINESND", "FLOORBOOST", "SPINOUTTYPE", "DRIFT", "DRIFTEND", "DRIFTCHARGE", "DRIFTBOOST", "BOOSTCHARGE", "STARTBOOST", "JMP", "OFFROAD", "POGOSPRING", "BRAKESTOP", "WATERSKIP", "DASHPADCOOLDOWN", "BOOSTPOWER", "SPEEDBOOST", "ACCELBOOST", "BOOSTANGLE", "BOOSTCAM", "DESTBOOSTCAM", "TIMEOVERCAM", "AIZDRIFTSTRAT", "BRAKEDRIFT", "ITEMROULETTE", "ROULETTETYPE", "ITEMTYPE", "ITEMAMOUNT", "ITEMHELD", "CURSHIELD", "HYUDOROTIMER", "STEALINGTIMER", "STOLENTIMER", "SNEAKERTIMER", "GROWSHRINKTIMER", "SQUISHEDTIMER", "ROCKETSNEAKERTIMER", "INVINCIBILITYTIMER", "EGGMANHELD", "EGGMANEXPLODE", "EGGMANBLAME", "LASTJAWZTARGET", "BANANADRAG", "SPINOUTTIMER", "WIPEOUTSLOW", "JUSTBUMPED", "COMEBACKTIMER", "SADTIMER", "BUMPER", "COMEBACKPOINTS", "COMEBACKMODE", "WANTED", "YOUGOTEM", "ITEMBLINK", "ITEMBLINKMODE", "GETSPARKS", "JAWZTARGETDELAY", "SPECTATEWAIT", "GROWCANCEL" }; const char *const KARTHUD_LIST[] = { "RINGFRAME", "RINGTICS", "RINGDELAY", "RINGSPBBLOCK", "LAPANIMATION", "LAPHAND", "FAULT", "BOOSTCAM", "DESTBOOSTCAM", "TIMEOVERCAM", "ENGINESND", "VOICES", "TAUNTVOICES", "CARDANIMATION", "YOUGOTEM", }; const char *const HUDITEMS_LIST[] = { "LIVES", "RINGS", "RINGSNUM", "RINGSNUMTICS", "SCORE", "SCORENUM", "TIME", "MINUTES", "TIMECOLON", "SECONDS", "TIMETICCOLON", "TICS", "SS_TOTALRINGS", "GETRINGS", "GETRINGSNUM", "TIMELEFT", "TIMELEFTNUM", "TIMEUP", "HUNTPICS", "POWERUPS" }; struct menu_routine_s const MENU_ROUTINES[] = { { "SINGLEPLAYERMENU", &MR_SinglePlayerMenu }, { "OPTIONS", &MR_Options }, { "ADDONS", &MR_Addons }, { "QUITADDONS", &MR_QuitAddons }, { "QUITSRB2", &MR_QuitSRB2 }, { "STATISTICS", &MR_Statistics }, { "HANDLELEVELSTATS", &MR_HandleLevelStats }, { "REPLAYHUT", &MR_ReplayHut }, { "QUITREPLAYHUT", &MR_QuitReplayHut }, { "HANDLEREPLAYHUTLIST", &MR_HandleReplayHutList }, { "GRANDPRIXTEMP", &MR_GrandPrixTemp }, { "TIMEATTACK", &MR_TimeAttack }, { "STARTGRANDPRIX", &MR_StartGrandPrix }, { "QUITTIMEATTACKMENU", &MR_QuitTimeAttackMenu }, { "CHOOSETIMEATTACK", &MR_ChooseTimeAttack }, { "SETGUESTREPLAY", &MR_SetGuestReplay }, { "REPLAYTIMEATTACK", &MR_ReplayTimeAttack }, { "TIMEATTACKPRESET", &MR_TimeAttackPreset }, { "REPLAYSTAFF", &MR_ReplayStaff }, { "CONNECTIP", &MR_ConnectIP }, { "CONNECTLASTSERVER", &MR_ConnectLastServer }, { "QUITMULTIPLAYERMENU", &MR_QuitMultiPlayerMenu }, { "STARTSERVER", &MR_StartServer }, { "CONNECTMENUMODCHECKS", &MR_ConnectMenuModChecks }, { "CANCELCONNECT", &MR_CancelConnect }, { "SETUPCONTROLSMENU", &MR_SetupControlsMenu }, { "REFRESH", &MR_Refresh }, { "CONNECT", &MR_Connect }, { "VIDEOMODEMENU", &MR_VideoModeMenu }, #ifdef HWRENDER { "OPENGLOPTIONSMENU", &MR_OpenGLOptionsMenu }, #endif { "HANDLEVIDEOMODE", &MR_HandleVideoMode }, { "PLAYSOUND", &MR_PlaySound }, { "MUSICTEST", &MR_MusicTest }, { "QUITMUSICTEST", &MR_QuitMusicTest }, { "SCREENSHOTOPTIONS", &MR_ScreenshotOptions }, { "ADDONSOPTIONS", &MR_AddonsOptions }, { "ERASEDATA", &MR_EraseData }, { "CREDITS", &MR_Credits }, { "BLANCREDITS", &MR_BlanCredits }, { "SECRETCREDITS", &MR_SecretCredits }, { "HANDLEADDONS", &MR_HandleAddons }, { "SELECTABLECLEARMENUS", &MR_SelectableClearMenus }, { "GOBACK", &MR_GoBack }, { "MODEATTACKRETRY", &MR_ModeAttackRetry }, { "MODEATTACKENDGAME", &MR_ModeAttackEndGame }, { "RETRY", &MR_Retry }, { "ENDGAME", &MR_EndGame }, { "SETUPMULTIPLAYER", &MR_SetupMultiPlayer }, { "CONFIRMSPECTATE", &MR_ConfirmSpectate }, { "CONFIRMENTERGAME", &MR_ConfirmEnterGame }, { "CONFIRMTEAMSCRAMBLE", &MR_ConfirmTeamScramble }, { "CONFIRMTEAMCHANGE", &MR_ConfirmTeamChange }, { "CONFIRMSPECTATECHANGE", &MR_ConfirmSpectateChange }, { "CHANGELEVEL", &MR_ChangeLevel }, { "HUTSTARTREPLAY", &MR_HutStartReplay }, { "PLAYBACKREWIND", &MR_PlaybackRewind }, { "PLAYBACKPAUSE", &MR_PlaybackPause }, { "PLAYBACKFASTFORWARD", &MR_PlaybackFastForward }, { "PLAYBACKADVANCE", &MR_PlaybackAdvance }, { "PLAYBACKSETVIEWS", &MR_PlaybackSetViews }, { "PLAYBACKADJUSTVIEW", &MR_PlaybackAdjustView }, { "PLAYBACKTOGGLEFREECAM", &MR_PlaybackToggleFreecam }, { "PLAYBACKQUIT", &MR_PlaybackQuit }, { "HANDLEIMAGEDEF", &MR_HandleImageDef }, { "HANDLEMUSICTEST", &MR_HandleMusicTest }, { "SETUPJOYSTICKMENU", &MR_SetupJoystickMenu }, { "RESETCONTROLS", &MR_ResetControls }, { "CHANGECONTROL", &MR_ChangeControl }, { "ASSIGNJOYSTICK", &MR_AssignJoystick }, { "SETUPMONITORTOGGLES", &MR_SetupMonitorToggles }, { "HANDLEMONITORTOGGLES", &MR_HandleMonitorToggles }, { "RESTARTAUDIO", &MR_RestartAudio }, { "ENTERVIEWSERVER", &MR_EnterViewServer }, { "QUITVIEWSERVER", &MR_QuitViewServer }, { "HANDLEVIEWSERVER", &MR_HandleViewServer }, { "CAMERASETUP", &MR_CameraSetup }, // { "BARCSS", &MR_HandleBarCss }, { "HANDLESETUPMULTIPLAYERMENU", &MR_HandleSetupMultiPlayerMenu }, { "PREPARELEVELPLATTER", &MR_PrepareLevelPlatter }, { "HANDLELEVELPLATTER", &MR_HandleLevelPlatter }, { "LEVELPLATTERRANDOM", &MR_LevelPlatterRandom }, #ifdef HAVE_DISCORDRPC { "HANDLEDISCORDREQUESTS", &MR_HandleDiscordRequests }, #endif { NULL, NULL } }; struct menu_drawer_s const MENU_DRAWERS[] = { { "DRAWGENERICMENU", &MD_DrawGenericMenu }, { "DRAWCHECKLIST", &MD_DrawChecklist }, { "DRAWLEVELSTATS", &MD_DrawLevelStats }, { "DRAWREPLAYHUT", &MD_DrawReplayHut }, { "DRAWTIMEATTACKMENU", &MD_DrawTimeAttackMenu }, { "DRAWMPMAINMENU", &MD_DrawMPMainMenu }, { "DRAWSETUPMULTIPLAYERMENU", &MD_DrawSetupMultiPlayerMenu }, // { "DRAWCSSCHARACTER", &MD_DrawCssCharacter }, // { "DRAWBARCSSSELECTOR", &MD_DrawBarCssSelector }, // { "DRAWGRIDCSSSELECTOR", &MD_DrawGridCssSelector }, { "DRAWVIDEOMODE", &MD_DrawVideoMode }, { "DRAWADDONS", &MD_DrawAddons }, { "DRAWREPLAYSTARTMENU", &MD_DrawReplayStartMenu }, { "DRAWPLAYBACKMENU", &MD_DrawPlaybackMenu }, { "DRAWIMAGEDEF", &MD_DrawImageDef }, { "DRAWMUSICTEST", &MD_DrawMusicTest }, { "DRAWJOYSTICK", &MD_DrawJoystick }, { "DRAWMONITORTOGGLES", &MD_DrawMonitorToggles }, { "DRAWCONNECTMENU", &MD_DrawConnectMenu }, { "DRAWVIEWSERVER", &MD_DrawViewServer }, { "DRAWLEVELPLATTERMENU", &MD_DrawLevelPlatterMenu }, #ifdef HAVE_DISCORDRPC { "DRAWDISCORDREQUESTS", &MD_DrawDiscordRequests }, #endif { NULL, NULL } }; struct odds_func_s const USEODDS_FUNCS[] = { { "SMONITORODDS", &KO_SMonitorOdds }, { "SPBRACEODDS", &KO_SPBRaceOdds }, { NULL, NULL } }; struct int_const_s const INT_CONST[] = { // If a mod removes some variables here, // please leave the names in-tact and just set // the value to 0 or something. // integer type limits, from doomtype.h // INT64 and UINT64 limits not included, they're too big for most purposes anyway // signed {"INT8_MIN",INT8_MIN}, {"INT16_MIN",INT16_MIN}, {"INT32_MIN",INT32_MIN}, {"INT8_MAX",INT8_MAX}, {"INT16_MAX",INT16_MAX}, {"INT32_MAX",INT32_MAX}, // unsigned {"UINT8_MAX",UINT8_MAX}, {"UINT16_MAX",UINT16_MAX}, {"UINT32_MAX",UINT32_MAX}, // fixed_t constants, from m_fixed.h {"FRACUNIT",FRACUNIT}, {"FU" ,FRACUNIT}, {"FRACBITS",FRACBITS}, {"M_TAU_FIXED",M_TAU_FIXED}, // doomdef.h constants {"TICRATE",TICRATE}, {"MUSICRATE",MUSICRATE}, {"RING_DIST",RING_DIST}, {"PUSHACCEL",PUSHACCEL}, {"MODID",MODID}, // I don't know, I just thought it would be cool for a wad to potentially know what mod it was loaded into. {"MODVERSION",MODVERSION}, // or what version of the mod this is. {"CODEBASE",CODEBASE}, // or what release of SRB2 this is. {"NEWTICRATE",NEWTICRATE}, // TICRATE*NEWTICRATERATIO {"NEWTICRATERATIO",NEWTICRATERATIO}, // Special linedef executor tag numbers! {"LE_PINCHPHASE",LE_PINCHPHASE}, // A boss entered pinch phase (and, in most cases, is preparing their pinch phase attack!) {"LE_ALLBOSSESDEAD",LE_ALLBOSSESDEAD}, // All bosses in the map are dead (Egg capsule raise) {"LE_BOSSDEAD",LE_BOSSDEAD}, // A boss in the map died (Chaos mode boss tally) {"LE_BOSS4DROP",LE_BOSS4DROP}, // CEZ boss dropped its cage {"LE_BRAKVILEATACK",LE_BRAKVILEATACK}, // Brak's doing his LOS attack, oh noes {"LE_TURRET",LE_TURRET}, // THZ turret {"LE_BRAKPLATFORM",LE_BRAKPLATFORM}, // v2.0 Black Eggman destroys platform {"LE_CAPSULE2",LE_CAPSULE2}, // Egg Capsule {"LE_CAPSULE1",LE_CAPSULE1}, // Egg Capsule {"LE_CAPSULE0",LE_CAPSULE0}, // Egg Capsule {"LE_KOOPA",LE_KOOPA}, // Distant cousin to Gay Bowser {"LE_AXE",LE_AXE}, // MKB Axe object {"LE_PARAMWIDTH",LE_PARAMWIDTH}, // If an object that calls LinedefExecute has a nonzero parameter value, this times the parameter will be subtracted. (Mostly for the purpose of coexisting bosses...) /// \todo Get all this stuff into its own sections, maybe. Maybe. // Frame settings {"FF_FRAMEMASK",FF_FRAMEMASK}, {"FF_SPR2SUPER",FF_SPR2SUPER}, {"FF_SPR2ENDSTATE",FF_SPR2ENDSTATE}, {"FF_SPR2MIDSTART",FF_SPR2MIDSTART}, {"FF_ANIMATE",FF_ANIMATE}, {"FF_RANDOMANIM",FF_RANDOMANIM}, {"FF_GLOBALANIM",FF_GLOBALANIM}, {"FF_FULLBRIGHT",FF_FULLBRIGHT}, {"FF_FULLDARK",FF_FULLDARK}, {"FF_SEMIBRIGHT",FF_SEMIBRIGHT}, {"FF_VERTICALFLIP",FF_VERTICALFLIP}, {"FF_HORIZONTALFLIP",FF_HORIZONTALFLIP}, {"FF_PAPERSPRITE",FF_PAPERSPRITE}, {"FF_FLOORSPRITE",FF_FLOORSPRITE}, {"FF_NOAFFINE",FF_NOAFFINE}, {"FF_AFFINEPAPER",FF_AFFINEPAPER}, {"FF_BLENDMASK",FF_BLENDMASK}, {"FF_BLENDSHIFT",FF_BLENDSHIFT}, {"FF_ADD",FF_ADD}, {"FF_SUBTRACT",FF_SUBTRACT}, {"FF_REVERSESUBTRACT",FF_REVERSESUBTRACT}, {"FF_MODULATE",FF_MODULATE}, {"FF_OVERLAY",FF_OVERLAY}, {"FF_TRANSMASK",FF_TRANSMASK}, {"FF_TRANSSHIFT",FF_TRANSSHIFT}, // new preshifted translucency (used in source) {"FF_TRANS10",FF_TRANS10}, {"FF_TRANS20",FF_TRANS20}, {"FF_TRANS30",FF_TRANS30}, {"FF_TRANS40",FF_TRANS40}, {"FF_TRANS50",FF_TRANS50}, {"FF_TRANS60",FF_TRANS60}, {"FF_TRANS70",FF_TRANS70}, {"FF_TRANS80",FF_TRANS80}, {"FF_TRANS90",FF_TRANS90}, // temporary, for testing {"FF_TRANSADD",FF_ADD}, {"FF_TRANSSUB",FF_SUBTRACT}, // compatibility // Transparency for SOCs is pre-shifted {"TR_TRANS10",tr_trans10<