raze/source/blood/src/blood.cpp

1324 lines
36 KiB
C++
Raw Normal View History

2019-09-19 22:42:45 +00:00
//-------------------------------------------------------------------------
/*
Copyright (C) 2010-2019 EDuke32 developers and contributors
Copyright (C) 2019 Nuke.YKT
This file is part of NBlood.
NBlood is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License version 2
as published by the Free Software Foundation.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
//-------------------------------------------------------------------------
#include "ns.h" // Must come before everything else!
2019-09-19 22:42:45 +00:00
#include "build.h"
#include "mmulti.h"
#include "compat.h"
2019-12-29 16:04:38 +00:00
#include "baselayer.h"
2019-09-19 22:42:45 +00:00
#include "common.h"
#include "common_game.h"
#include "db.h"
#include "blood.h"
#include "choke.h"
#include "controls.h"
#include "dude.h"
#include "endgame.h"
#include "eventq.h"
#include "fx.h"
#include "gib.h"
2019-09-19 22:42:45 +00:00
#include "globals.h"
#include "levels.h"
#include "loadsave.h"
#include "network.h"
#include "sectorfx.h"
#include "seq.h"
#include "sound.h"
#include "triggers.h"
#include "view.h"
#include "misc.h"
#include "gameconfigfile.h"
#include "gamecontrol.h"
#include "m_argv.h"
#include "statistics.h"
#include "menu.h"
#include "raze_sound.h"
#include "nnexts.h"
#include "secrets.h"
#include "gamestate.h"
#include "screenjob.h"
2019-09-19 22:42:45 +00:00
BEGIN_BLD_NS
void LocalKeys(void);
void InitCheats();
2019-09-19 22:42:45 +00:00
char bAddUserMap = false;
bool bNoDemo = false;
bool bQuickStart = true;
char gUserMapFilename[BMAX_PATH];
short BloodVersion = 0x115;
int gNetPlayers;
int gChokeCounter = 0;
double g_gameUpdateTime, g_gameUpdateAndDrawTime;
double g_gameUpdateAvgTime = 0.001;
bool gQuitGame;
int gQuitRequest;
2019-09-19 22:42:45 +00:00
enum gametokens
{
T_INCLUDE = 0,
T_INTERFACE = 0,
T_LOADGRP = 1,
T_MODE = 1,
T_CACHESIZE = 2,
T_ALLOW = 2,
T_NOAUTOLOAD,
T_INCLUDEDEFAULT,
T_SOUND,
T_FILE,
//T_CUTSCENE,
//T_ANIMSOUNDS,
//T_NOFLOORPALRANGE,
T_ID,
T_MINPITCH,
T_MAXPITCH,
T_PRIORITY,
T_TYPE,
T_DISTANCE,
T_VOLUME,
T_DELAY,
T_RENAMEFILE,
T_GLOBALGAMEFLAGS,
T_ASPECT,
T_FORCEFILTER,
T_FORCENOFILTER,
T_TEXTUREFILTER,
T_RFFDEFINEID,
T_TILEFROMTEXTURE,
T_IFCRC, T_IFMATCH, T_CRC32,
T_SIZE,
T_SURFACE,
T_VOXEL,
T_VIEW,
T_SHADE,
2019-09-19 22:42:45 +00:00
};
int blood_globalflags;
void QuitGame(void)
{
throw CExitEvent(0);
2019-09-19 22:42:45 +00:00
}
void PrecacheDude(spritetype *pSprite)
{
DUDEINFO *pDudeInfo = getDudeInfo(pSprite->type);
2019-09-19 22:42:45 +00:00
seqPrecacheId(pDudeInfo->seqStartID);
seqPrecacheId(pDudeInfo->seqStartID+5);
seqPrecacheId(pDudeInfo->seqStartID+1);
seqPrecacheId(pDudeInfo->seqStartID+2);
switch (pSprite->type)
{
case kDudeCultistTommy:
case kDudeCultistShotgun:
case kDudeCultistTesla:
case kDudeCultistTNT:
2019-09-19 22:42:45 +00:00
seqPrecacheId(pDudeInfo->seqStartID+6);
seqPrecacheId(pDudeInfo->seqStartID+7);
seqPrecacheId(pDudeInfo->seqStartID+8);
seqPrecacheId(pDudeInfo->seqStartID+9);
seqPrecacheId(pDudeInfo->seqStartID+13);
seqPrecacheId(pDudeInfo->seqStartID+14);
seqPrecacheId(pDudeInfo->seqStartID+15);
break;
case kDudeZombieButcher:
case kDudeGillBeast:
2019-09-19 22:42:45 +00:00
seqPrecacheId(pDudeInfo->seqStartID+6);
seqPrecacheId(pDudeInfo->seqStartID+7);
seqPrecacheId(pDudeInfo->seqStartID+8);
seqPrecacheId(pDudeInfo->seqStartID+9);
seqPrecacheId(pDudeInfo->seqStartID+10);
seqPrecacheId(pDudeInfo->seqStartID+11);
break;
case kDudeGargoyleStatueFlesh:
case kDudeGargoyleStatueStone:
2019-09-19 22:42:45 +00:00
seqPrecacheId(pDudeInfo->seqStartID+6);
seqPrecacheId(pDudeInfo->seqStartID+6);
fallthrough__;
case kDudeGargoyleFlesh:
case kDudeGargoyleStone:
2019-09-19 22:42:45 +00:00
seqPrecacheId(pDudeInfo->seqStartID+6);
seqPrecacheId(pDudeInfo->seqStartID+7);
seqPrecacheId(pDudeInfo->seqStartID+8);
seqPrecacheId(pDudeInfo->seqStartID+9);
break;
case kDudePhantasm:
case kDudeHellHound:
case kDudeSpiderBrown:
case kDudeSpiderRed:
case kDudeSpiderBlack:
case kDudeSpiderMother:
case kDudeTchernobog:
2019-09-19 22:42:45 +00:00
seqPrecacheId(pDudeInfo->seqStartID+6);
seqPrecacheId(pDudeInfo->seqStartID+7);
seqPrecacheId(pDudeInfo->seqStartID+8);
break;
case kDudeCerberusTwoHead:
2019-09-19 22:42:45 +00:00
seqPrecacheId(pDudeInfo->seqStartID+6);
seqPrecacheId(pDudeInfo->seqStartID+7);
fallthrough__;
case kDudeHand:
case kDudeBoneEel:
case kDudeBat:
case kDudeRat:
2019-09-19 22:42:45 +00:00
seqPrecacheId(pDudeInfo->seqStartID+6);
seqPrecacheId(pDudeInfo->seqStartID+7);
break;
case kDudeCultistBeast:
2019-09-19 22:42:45 +00:00
seqPrecacheId(pDudeInfo->seqStartID+6);
break;
case kDudeZombieAxeBuried:
2019-09-19 22:42:45 +00:00
seqPrecacheId(pDudeInfo->seqStartID+12);
seqPrecacheId(pDudeInfo->seqStartID+9);
fallthrough__;
case kDudeZombieAxeLaying:
2019-09-19 22:42:45 +00:00
seqPrecacheId(pDudeInfo->seqStartID+10);
fallthrough__;
case kDudeZombieAxeNormal:
2019-09-19 22:42:45 +00:00
seqPrecacheId(pDudeInfo->seqStartID+6);
seqPrecacheId(pDudeInfo->seqStartID+7);
seqPrecacheId(pDudeInfo->seqStartID+8);
seqPrecacheId(pDudeInfo->seqStartID+11);
seqPrecacheId(pDudeInfo->seqStartID+13);
seqPrecacheId(pDudeInfo->seqStartID+14);
break;
}
}
void PrecacheThing(spritetype *pSprite) {
switch (pSprite->type) {
case kThingGlassWindow: // worthless...
case kThingFluorescent:
seqPrecacheId(12);
break;
case kThingSpiderWeb:
seqPrecacheId(15);
break;
case kThingMetalGrate:
seqPrecacheId(21);
break;
case kThingFlammableTree:
seqPrecacheId(25);
seqPrecacheId(26);
break;
case kTrapMachinegun:
seqPrecacheId(38);
seqPrecacheId(40);
seqPrecacheId(28);
break;
case kThingObjectGib:
//case kThingObjectExplode: weird that only gib object is precached and this one is not
break;
2019-09-19 22:42:45 +00:00
}
tilePrecacheTile(pSprite->picnum);
2019-09-19 22:42:45 +00:00
}
void PreloadTiles(void)
{
2020-04-11 07:12:23 +00:00
nPrecacheCount = 0;
2019-09-19 22:42:45 +00:00
int skyTile = -1;
memset(gotpic,0,sizeof(gotpic));
2020-01-02 09:45:31 +00:00
// Fonts
2019-09-19 22:42:45 +00:00
for (int i = 0; i < numsectors; i++)
{
tilePrecacheTile(sector[i].floorpicnum, 0);
tilePrecacheTile(sector[i].ceilingpicnum, 0);
if ((sector[i].ceilingstat&1) != 0 && skyTile == -1)
skyTile = sector[i].ceilingpicnum;
}
for (int i = 0; i < numwalls; i++)
{
tilePrecacheTile(wall[i].picnum, 0);
if (wall[i].overpicnum >= 0)
tilePrecacheTile(wall[i].overpicnum, 0);
}
for (int i = 0; i < kMaxSprites; i++)
{
if (sprite[i].statnum < kMaxStatus)
{
spritetype *pSprite = &sprite[i];
switch (pSprite->statnum)
{
case kStatDude:
2019-09-19 22:42:45 +00:00
PrecacheDude(pSprite);
break;
case kStatThing:
2019-09-19 22:42:45 +00:00
PrecacheThing(pSprite);
break;
default:
tilePrecacheTile(pSprite->picnum);
break;
}
}
}
// Precache common SEQs
for (int i = 0; i < 100; i++)
2019-09-19 22:42:45 +00:00
{
seqPrecacheId(i);
2019-09-19 22:42:45 +00:00
}
tilePrecacheTile(1147); // water drip
tilePrecacheTile(1160); // blood drip
// Player SEQs
seqPrecacheId(dudeInfo[31].seqStartID+6);
seqPrecacheId(dudeInfo[31].seqStartID+7);
seqPrecacheId(dudeInfo[31].seqStartID+8);
seqPrecacheId(dudeInfo[31].seqStartID+9);
seqPrecacheId(dudeInfo[31].seqStartID+10);
seqPrecacheId(dudeInfo[31].seqStartID+14);
seqPrecacheId(dudeInfo[31].seqStartID+15);
seqPrecacheId(dudeInfo[31].seqStartID+12);
seqPrecacheId(dudeInfo[31].seqStartID+16);
seqPrecacheId(dudeInfo[31].seqStartID+17);
seqPrecacheId(dudeInfo[31].seqStartID+18);
2019-09-19 22:42:45 +00:00
if (skyTile > -1 && skyTile < kMaxTiles)
{
for (int i = 1; i < gSkyCount; i++)
tilePrecacheTile(skyTile+i, 0);
}
WeaponPrecache();
viewPrecacheTiles();
fxPrecache();
gibPrecache();
gameHandleEvents();
2019-09-19 22:42:45 +00:00
}
void PreloadCache(void)
{
PreloadTiles();
ClockTicks clock = totalclock;
2019-09-19 22:42:45 +00:00
int cnt = 0;
int percentDisplayed = -1;
for (int i=0; i<kMaxTiles && !inputState.GetKeyStatus(sc_Space); i++)
2019-09-19 22:42:45 +00:00
{
if (TestBitString(gotpic, i))
{
// For the hardware renderer precaching the raw pixel data is pointless.
if (videoGetRenderMode() < REND_POLYMOST)
tileLoad(i);
2019-09-19 22:42:45 +00:00
2019-10-23 12:39:33 +00:00
if (r_precache) PrecacheHardwareTextures(i);
2019-09-19 22:42:45 +00:00
if ((++cnt & 7) == 0)
gameHandleEvents();
}
}
2019-09-19 22:42:45 +00:00
memset(gotpic,0,sizeof(gotpic));
}
void EndLevel(void)
{
gViewPos = VIEWPOS_0;
sndKillAllSounds();
sfxKillAllSounds();
ambKillAll();
seqKillAll();
}
2019-09-19 22:42:45 +00:00
PLAYER gPlayerTemp[kMaxPlayers];
int gHealthTemp[kMaxPlayers];
vec3_t startpos;
int16_t startang, startsectnum;
void StartLevel(GAMEOPTIONS *gameOptions)
{
STAT_Update(0);
2019-09-19 22:42:45 +00:00
EndLevel();
gInput = {};
2019-09-19 22:42:45 +00:00
gStartNewGame = 0;
ready2send = 0;
netWaitForEveryone(0);
currentLevel = FindMapByLevelNum(levelnum(gGameOptions.nEpisode, gGameOptions.nLevel));
2019-09-19 22:42:45 +00:00
if (gGameOptions.nGameType == 0)
{
if (!(gGameOptions.uGameFlags&1))
levelSetupOptions(gGameOptions.nEpisode, gGameOptions.nLevel);
if (gEpisodeInfo[gGameOptions.nEpisode].cutALevel == gGameOptions.nLevel
&& gEpisodeInfo[gGameOptions.nEpisode].cutsceneAName)
2019-09-19 22:42:45 +00:00
gGameOptions.uGameFlags |= 4;
///////
gGameOptions.weaponsV10x = gWeaponsV10x;
///////
2019-09-19 22:42:45 +00:00
}
else if (gGameOptions.nGameType > 0 && !(gGameOptions.uGameFlags&1))
{
gGameOptions.nEpisode = gPacketStartGame.episodeId;
gGameOptions.nLevel = gPacketStartGame.levelId;
gGameOptions.nGameType = gPacketStartGame.gameType;
gGameOptions.nDifficulty = gPacketStartGame.difficulty;
gGameOptions.nMonsterSettings = gPacketStartGame.monsterSettings;
gGameOptions.nWeaponSettings = gPacketStartGame.weaponSettings;
gGameOptions.nItemSettings = gPacketStartGame.itemSettings;
gGameOptions.nRespawnSettings = gPacketStartGame.respawnSettings;
gGameOptions.bFriendlyFire = gPacketStartGame.bFriendlyFire;
gGameOptions.bKeepKeysOnRespawn = gPacketStartGame.bKeepKeysOnRespawn;
2019-09-19 22:42:45 +00:00
if (gPacketStartGame.userMap)
levelAddUserMap(gPacketStartGame.userMapName);
else
levelSetupOptions(gGameOptions.nEpisode, gGameOptions.nLevel);
///////
gGameOptions.weaponsV10x = gPacketStartGame.weaponsV10x;
///////
gBlueFlagDropped = false;
gRedFlagDropped = false;
2019-09-19 22:42:45 +00:00
}
if (gameOptions->uGameFlags&1)
{
for (int i = connecthead; i >= 0; i = connectpoint2[i])
{
memcpy(&gPlayerTemp[i],&gPlayer[i],sizeof(PLAYER));
gHealthTemp[i] = xsprite[gPlayer[i].pSprite->extra].health;
}
}
bVanilla = false;
enginecompatibility_mode = ENGINECOMPATIBILITY_19960925;//bVanilla;
2019-09-19 22:42:45 +00:00
memset(xsprite,0,sizeof(xsprite));
memset(sprite,0,kMaxSprites*sizeof(spritetype));
//drawLoadingScreen();
if (dbLoadMap(currentLevel->fileName,(int*)&startpos.x,(int*)&startpos.y,(int*)&startpos.z,&startang,&startsectnum,(unsigned int*)&gameOptions->uMapCRC))
{
I_Error("Unable to load map");
}
SECRET_SetMapName(currentLevel->DisplayName(), currentLevel->name);
STAT_NewLevel(currentLevel->fileName);
G_LoadMapHack(currentLevel->fileName);
2019-09-19 22:42:45 +00:00
wsrand(gameOptions->uMapCRC);
gKillMgr.Clear();
gSecretMgr.Clear();
gLevelTime = 0;
automapping = 1;
int modernTypesErased = 0;
2019-09-19 22:42:45 +00:00
for (int i = 0; i < kMaxSprites; i++)
{
spritetype *pSprite = &sprite[i];
if (pSprite->statnum < kMaxStatus && pSprite->extra > 0) {
2019-09-19 22:42:45 +00:00
XSPRITE *pXSprite = &xsprite[pSprite->extra];
if ((pXSprite->lSkill & (1 << gameOptions->nDifficulty)) || (pXSprite->lS && gameOptions->nGameType == 0)
|| (pXSprite->lB && gameOptions->nGameType == 2) || (pXSprite->lT && gameOptions->nGameType == 3)
|| (pXSprite->lC && gameOptions->nGameType == 1)) {
DeleteSprite(i);
continue;
}
#ifdef NOONE_EXTENSIONS
if (!gModernMap && nnExtEraseModernStuff(pSprite, pXSprite))
modernTypesErased++;
#endif
}
}
#ifdef NOONE_EXTENSIONS
if (!gModernMap)
Printf("> Modern types erased: %d.\n", modernTypesErased);
#endif
2019-09-19 22:42:45 +00:00
startpos.z = getflorzofslope(startsectnum,startpos.x,startpos.y);
for (int i = 0; i < kMaxPlayers; i++) {
2019-09-19 22:42:45 +00:00
gStartZone[i].x = startpos.x;
gStartZone[i].y = startpos.y;
gStartZone[i].z = startpos.z;
gStartZone[i].sectnum = startsectnum;
gStartZone[i].ang = startang;
#ifdef NOONE_EXTENSIONS
// Create spawn zones for players in teams mode.
if (gModernMap && i <= kMaxPlayers / 2) {
2019-09-19 22:42:45 +00:00
gStartZoneTeam1[i].x = startpos.x;
gStartZoneTeam1[i].y = startpos.y;
gStartZoneTeam1[i].z = startpos.z;
gStartZoneTeam1[i].sectnum = startsectnum;
gStartZoneTeam1[i].ang = startang;
gStartZoneTeam2[i].x = startpos.x;
gStartZoneTeam2[i].y = startpos.y;
gStartZoneTeam2[i].z = startpos.z;
gStartZoneTeam2[i].sectnum = startsectnum;
gStartZoneTeam2[i].ang = startang;
}
#endif
2019-09-19 22:42:45 +00:00
}
InitSectorFX();
warpInit();
actInit(false);
2019-09-19 22:42:45 +00:00
evInit();
for (int i = connecthead; i >= 0; i = connectpoint2[i])
{
if (!(gameOptions->uGameFlags&1))
{
if (numplayers == 1)
{
gProfile[i].skill = gSkill;
2019-10-21 22:05:21 +00:00
gProfile[i].nAutoAim = cl_autoaim;
2019-10-22 00:31:14 +00:00
gProfile[i].nWeaponSwitch = cl_weaponswitch;
2019-09-19 22:42:45 +00:00
}
playerInit(i,0);
}
playerStart(i, 1);
2019-09-19 22:42:45 +00:00
}
if (gameOptions->uGameFlags&1)
{
for (int i = connecthead; i >= 0; i = connectpoint2[i])
{
PLAYER *pPlayer = &gPlayer[i];
pPlayer->pXSprite->health &= 0xf000;
pPlayer->pXSprite->health |= gHealthTemp[i];
pPlayer->weaponQav = gPlayerTemp[i].weaponQav;
pPlayer->curWeapon = gPlayerTemp[i].curWeapon;
pPlayer->weaponState = gPlayerTemp[i].weaponState;
pPlayer->weaponAmmo = gPlayerTemp[i].weaponAmmo;
pPlayer->qavCallback = gPlayerTemp[i].qavCallback;
pPlayer->qavLoop = gPlayerTemp[i].qavLoop;
pPlayer->weaponTimer = gPlayerTemp[i].weaponTimer;
pPlayer->nextWeapon = gPlayerTemp[i].nextWeapon;
2019-09-19 22:42:45 +00:00
}
}
gameOptions->uGameFlags &= ~3;
PreloadCache();
InitMirrors();
gFrameClock = 0;
trInit();
if (!bVanilla && !gMe->packSlots[1].isActive) // if diving suit is not active, turn off reverb sound effect
2019-09-19 22:42:45 +00:00
sfxSetReverb(0);
ambInit();
netReset();
2019-09-19 22:42:45 +00:00
gFrame = 0;
gChokeCounter = 0;
M_ClearMenus();
2019-09-19 22:42:45 +00:00
// viewSetMessage("");
viewSetErrorMessage("");
viewResizeView(gViewSize);
netWaitForEveryone(0);
totalclock = 0;
2020-05-29 01:20:40 +00:00
paused = 0;
2019-09-19 22:42:45 +00:00
ready2send = 1;
}
2019-09-24 02:14:59 +00:00
2019-09-19 22:42:45 +00:00
bool gRestartGame = false;
void ProcessFrame(void)
{
char buffer[128];
for (int i = connecthead; i >= 0; i = connectpoint2[i])
{
gPlayer[i].input.buttonFlags = gFifoInput[gNetFifoTail&255][i].buttonFlags;
gPlayer[i].input.keyFlags.word |= gFifoInput[gNetFifoTail&255][i].keyFlags.word;
gPlayer[i].input.useFlags.byte |= gFifoInput[gNetFifoTail&255][i].useFlags.byte;
2019-09-19 22:42:45 +00:00
if (gFifoInput[gNetFifoTail&255][i].newWeapon)
gPlayer[i].input.newWeapon = gFifoInput[gNetFifoTail&255][i].newWeapon;
gPlayer[i].input.forward = gFifoInput[gNetFifoTail&255][i].forward;
gPlayer[i].input.q16turn = gFifoInput[gNetFifoTail&255][i].q16turn;
gPlayer[i].input.strafe = gFifoInput[gNetFifoTail&255][i].strafe;
gPlayer[i].input.q16mlook = gFifoInput[gNetFifoTail&255][i].q16mlook;
2019-09-19 22:42:45 +00:00
}
gNetFifoTail++;
#if 0
2020-01-30 15:20:31 +00:00
if (!(gFrame&7))
{
CalcGameChecksum();
memcpy(gCheckFifo[gCheckHead[myconnectindex]&255][myconnectindex], gChecksum, sizeof(gChecksum));
gCheckHead[myconnectindex]++;
}
#endif
2019-09-19 22:42:45 +00:00
for (int i = connecthead; i >= 0; i = connectpoint2[i])
{
if (gPlayer[i].input.keyFlags.quit)
2019-09-19 22:42:45 +00:00
{
gPlayer[i].input.keyFlags.quit = 0;
2019-09-19 22:42:45 +00:00
netBroadcastPlayerLogoff(i);
if (i == myconnectindex)
{
// netBroadcastMyLogoff(gQuitRequest == 2);
gQuitGame = true;
gRestartGame = gQuitRequest == 2;
netDeinitialize();
netResetToSinglePlayer();
return;
}
}
if (gPlayer[i].input.keyFlags.restart)
2019-09-19 22:42:45 +00:00
{
gPlayer[i].input.keyFlags.restart = 0;
2019-09-19 22:42:45 +00:00
levelRestart();
return;
}
if (gPlayer[i].input.keyFlags.pause)
2019-09-19 22:42:45 +00:00
{
gPlayer[i].input.keyFlags.pause = 0;
2020-05-29 01:20:40 +00:00
if (paused && gGameOptions.nGameType > 0 && numplayers > 1)
2019-09-19 22:42:45 +00:00
{
sprintf(buffer,"%s paused the game",gProfile[i].name);
viewSetMessage(buffer);
}
}
}
viewClearInterpolations();
{
2020-05-29 01:20:40 +00:00
if (paused || gEndGameMgr.at0 || (gGameOptions.nGameType == 0 && M_Active()))
2019-09-19 22:42:45 +00:00
return;
}
for (int i = connecthead; i >= 0; i = connectpoint2[i])
{
viewBackupView(i);
playerProcess(&gPlayer[i]);
}
trProcessBusy();
evProcess((int)gFrameClock);
2019-09-19 22:42:45 +00:00
seqProcess(4);
DoSectorPanning();
actProcessSprites();
actPostProcess();
#ifdef POLYMER
G_RefreshLights();
#endif
2019-09-19 22:42:45 +00:00
viewCorrectPrediction();
ambProcess();
viewUpdateDelirium();
viewUpdateShake();
sfxUpdate3DSounds();
if (gMe->hand == 1)
2019-09-19 22:42:45 +00:00
{
#define CHOKERATE 8
#define TICRATE 30
gChokeCounter += CHOKERATE;
while (gChokeCounter >= TICRATE)
{
gChoke.at1c(gMe);
gChokeCounter -= TICRATE;
}
}
gLevelTime++;
gFrame++;
gFrameClock += 4;
if ((gGameOptions.uGameFlags&1) != 0 && !gStartNewGame)
{
ready2send = 0;
if (gNetPlayers > 1 && gNetMode == NETWORK_SERVER && gPacketMode == PACKETMODE_1 && myconnectindex == connecthead)
{
while (gNetFifoMasterTail < gNetFifoTail)
{
gameHandleEvents();
2019-09-19 22:42:45 +00:00
netMasterUpdate();
}
}
seqKillAll();
if (gGameOptions.uGameFlags&2)
{
STAT_Update(true);
2019-09-19 22:42:45 +00:00
if (gGameOptions.nGameType == 0)
{
auto completion = [] (bool) {
gamestate = GS_DEMOSCREEN;
M_StartControlPanel(false);
M_SetMenu(NAME_CreditsMenu);
gGameOptions.uGameFlags &= ~3;
gRestartGame = 1;
gQuitGame = 1;
};
2019-09-19 22:42:45 +00:00
if (gGameOptions.uGameFlags&8)
{
levelPlayEndScene(gGameOptions.nEpisode, completion);
}
else completion(false);
2019-09-19 22:42:45 +00:00
}
else
{
gGameOptions.uGameFlags &= ~3;
gRestartGame = 1;
gQuitGame = 1;
}
2019-09-19 22:42:45 +00:00
}
else
{
gEndGameMgr.Setup();
viewResizeView(gViewSize);
}
}
}
2019-09-19 22:42:45 +00:00
void ParseOptions(void)
{
2019-09-19 22:42:45 +00:00
}
void ClockStrobe()
{
//gGameClock++;
2019-09-19 22:42:45 +00:00
}
void ReadAllRFS();
static const char* actions[] = {
"Move_Forward",
"Move_Backward",
"Turn_Left",
"Turn_Right",
"Strafe",
"Fire",
"Open",
"Run",
"Alt_Fire", // Duke3D", Blood
"Jump",
"Crouch",
"Look_Up",
"Look_Down",
"Look_Left",
"Look_Right",
"Strafe_Left",
"Strafe_Right",
"Aim_Up",
"Aim_Down",
"SendMessage",
"Map",
"Shrink_Screen",
"Enlarge_Screen",
"Show_Opponents_Weapon",
"Map_Follow_Mode",
"See_Coop_View",
"Mouse_Aiming",
"Toggle_Crosshair",
"Dpad_Select",
"Dpad_Aiming",
"Third_Person_View",
"Toggle_Crouch",
};
static void app_init()
2019-09-19 22:42:45 +00:00
{
InitCheats();
buttonMap.SetButtons(actions, NUM_ACTIONS);
2019-09-19 22:42:45 +00:00
memcpy(&gGameOptions, &gSingleGameOptions, sizeof(GAMEOPTIONS));
gGameOptions.nMonsterSettings = !userConfig.nomonsters;
bQuickStart = userConfig.nologo;
ReadAllRFS();
2019-09-19 22:42:45 +00:00
HookReplaceFunctions();
2019-09-19 22:42:45 +00:00
Printf("Initializing Build 3D engine\n");
engineInit();
Printf("Loading tiles\n");
if (!tileInit(0, NULL))
I_FatalError("TILES###.ART files not found");
2019-09-19 22:42:45 +00:00
levelLoadDefaults();
2019-08-09 18:25:44 +00:00
loaddefinitionsfile(BLOODWIDESCREENDEF);
loaddefinitions_game(BLOODWIDESCREENDEF, FALSE);
const char* defsfile = G_DefFile();
2019-09-19 22:42:45 +00:00
uint32_t stime = timerGetTicks();
if (!loaddefinitionsfile(defsfile))
{
uint32_t etime = timerGetTicks();
Printf("Definitions file \"%s\" loaded in %d ms.\n", defsfile, etime - stime);
2019-09-19 22:42:45 +00:00
}
loaddefinitions_game(defsfile, FALSE);
powerupInit();
Printf("Loading cosine table\n");
2020-04-11 21:54:33 +00:00
trigInit();
Printf("Initializing view subsystem\n");
2019-09-19 22:42:45 +00:00
viewInit();
Printf("Initializing dynamic fire\n");
2019-09-19 22:42:45 +00:00
FireInit();
Printf("Initializing weapon animations\n");
2019-09-19 22:42:45 +00:00
WeaponInit();
LoadSaveSetup();
LoadSavedInfo();
Printf("Loading control setup\n");
2019-09-19 22:42:45 +00:00
ctrlInit();
timerInit(120);
timerSetCallback(ClockStrobe);
Printf("Initializing network users\n");
2019-09-19 22:42:45 +00:00
netInitialize(true);
videoInit();
hud_size.Callback();
Printf("Initializing sound system\n");
2019-09-19 22:42:45 +00:00
sndInit();
registerosdcommands();
registerinputcommands();
2019-09-19 22:42:45 +00:00
gChoke.sub_83ff0(518, sub_84230);
if (bAddUserMap)
{
levelAddUserMap(gUserMapFilename);
gStartNewGame = 1;
}
videoSetViewableArea(0, 0, xdim - 1, ydim - 1);
UpdateDacs(0, true);
}
static void gameInit()
{
//RESTART:
netReset();
2019-09-19 22:42:45 +00:00
gViewIndex = myconnectindex;
gMe = gView = &gPlayer[myconnectindex];
netBroadcastPlayerInfo(myconnectindex);
#if 0
Printf("Waiting for network players!\n");
2019-09-19 22:42:45 +00:00
netWaitForEveryone(0);
if (gRestartGame)
{
// Network error
gQuitGame = false;
gRestartGame = false;
netDeinitialize();
netResetToSinglePlayer();
goto RESTART;
}
#endif
UpdateNetworkMenus();
2019-09-19 22:42:45 +00:00
gQuitGame = 0;
gRestartGame = 0;
if (gGameOptions.nGameType > 0)
{
2020-01-01 10:35:47 +00:00
inputState.ClearAllInput();
2019-09-19 22:42:45 +00:00
}
}
static void gameTicker()
{
bool gameUpdate = false;
double const gameUpdateStartTime = timerGetHiTicks();
while (gPredictTail < gNetFifoHead[myconnectindex] && !paused)
2019-09-19 22:42:45 +00:00
{
viewUpdatePrediction(&gFifoInput[gPredictTail & 255][myconnectindex]);
}
if (numplayers == 1)
gBufferJitter = 0;
while (totalclock >= gNetFifoClock && ready2send)
{
gNetInput = gInput;
gInput = {};
netGetInput();
gNetFifoClock += 4;
while (gNetFifoHead[myconnectindex] - gNetFifoTail > gBufferJitter && !gStartNewGame && !gQuitGame)
2019-09-19 22:42:45 +00:00
{
int i;
for (i = connecthead; i >= 0; i = connectpoint2[i])
if (gNetFifoHead[i] == gNetFifoTail)
break;
if (i >= 0)
2020-01-29 13:19:05 +00:00
break;
ProcessFrame();
gameUpdate = true;
}
}
if (gameUpdate)
{
g_gameUpdateTime = timerGetHiTicks() - gameUpdateStartTime;
if (g_gameUpdateAvgTime < 0.f)
g_gameUpdateAvgTime = g_gameUpdateTime;
g_gameUpdateAvgTime = ((GAMEUPDATEAVGTIMENUMSAMPLES - 1.f) * g_gameUpdateAvgTime + g_gameUpdateTime) / ((float)GAMEUPDATEAVGTIMENUMSAMPLES);
}
if (gQuitRequest && gQuitGame)
videoClearScreen(0);
else
{
netCheckSync();
viewDrawScreen();
g_gameUpdateAndDrawTime = g_beforeSwapTime/* timerGetHiTicks()*/ - gameUpdateStartTime;
}
}
2020-01-29 13:19:05 +00:00
static void drawBackground()
{
twod->ClearScreen();
2020-07-31 19:05:09 +00:00
DrawTexture(twod, tileGetTexture(2518, true), 0, 0, DTA_FullscreenEx, 3, TAG_DONE);
if (gQuitRequest && !gQuitGame)
netBroadcastMyLogoff(gQuitRequest == 2);
}
static void commonTicker(bool &playvideo)
{
if (TestBitString(gotpic, 2342))
{
FireProcess();
ClearBitString(gotpic, 2342);
}
if (gStartNewGame)
{
StartLevel(&gGameOptions);
auto completion = [](bool = false)
{
levelTryPlayMusicOrNothing(gGameOptions.nEpisode, gGameOptions.nLevel);
gNetFifoClock = gFrameClock = totalclock;
gamestate = GS_LEVEL;
};
if ((gGameOptions.uGameFlags & 4))
levelPlayIntroScene(gGameOptions.nEpisode, completion);
else
completion(false);
2019-09-19 22:42:45 +00:00
}
if (gRestartGame)
{
Mus_Stop();
soundEngine->StopAllChannels();
2019-09-19 22:42:45 +00:00
gQuitGame = 0;
gQuitRequest = 0;
gRestartGame = 0;
levelSetupOptions(0, 0);
2019-09-19 22:42:45 +00:00
if (gGameOptions.nGameType != 0)
{
playvideo = !bQuickStart;
2019-09-19 22:42:45 +00:00
}
else playvideo = false;
gamestate = GS_STARTUP;
2019-09-19 22:42:45 +00:00
}
}
int GameInterface::app_main()
{
app_init();
gamestate = GS_STARTUP;
bool playvideo = !bQuickStart;
while (true)
{
if (gamestate == GS_STARTUP) gameInit();
2019-09-19 22:42:45 +00:00
commonTicker(playvideo);
gameHandleEvents();
D_ProcessEvents();
ctrlGetInput();
switch (gamestate)
{
default:
case GS_STARTUP:
if (playvideo) playlogos();
else
{
gamestate = GS_DEMOSCREEN;
M_StartControlPanel(false);
M_SetMenu(NAME_Mainmenu);
}
break;
case GS_DEMOSCREEN:
2020-08-10 20:02:58 +00:00
case GS_FULLCONSOLE:
drawBackground();
break;
case GS_INTRO:
case GS_INTERMISSION:
RunScreenJobFrame(); // This handles continuation through its completion callback.
break;
case GS_LEVEL:
gameTicker();
LocalKeys();
break;
case GS_FINALE:
gEndGameMgr.ProcessKeys();
gEndGameMgr.Draw();
break;
}
videoNextPage();
}
2019-09-19 22:42:45 +00:00
return 0;
}
static int parsedefinitions_game(scriptfile *, int);
static void parsedefinitions_game_include(const char *fileName, scriptfile *pScript, const char *cmdtokptr, int const firstPass)
{
scriptfile *included = scriptfile_fromfile(fileName);
if (!included)
{
if (!Bstrcasecmp(cmdtokptr,"null") || pScript == NULL) // this is a bit overboard to prevent unused parameter warnings
{
// Printf("Warning: Failed including %s as module\n", fn);
2019-09-19 22:42:45 +00:00
}
/*
else
{
Printf("Warning: Failed including %s on line %s:%d\n",
2019-09-19 22:42:45 +00:00
fn, script->filename,scriptfile_getlinum(script,cmdtokptr));
}
*/
}
else
{
parsedefinitions_game(included, firstPass);
scriptfile_close(included);
}
}
static int parsedefinitions_game(scriptfile *pScript, int firstPass)
{
int token;
char *pToken;
static const tokenlist tokens[] =
{
{ "include", T_INCLUDE },
{ "#include", T_INCLUDE },
{ "includedefault", T_INCLUDEDEFAULT },
{ "#includedefault", T_INCLUDEDEFAULT },
{ "loadgrp", T_LOADGRP },
{ "cachesize", T_CACHESIZE },
{ "noautoload", T_NOAUTOLOAD },
{ "sound", T_SOUND },
//{ "cutscene", T_CUTSCENE },
//{ "animsounds", T_ANIMSOUNDS },
{ "renamefile", T_RENAMEFILE },
{ "globalgameflags", T_GLOBALGAMEFLAGS },
{ "rffdefineid", T_RFFDEFINEID },
{ "tilefromtexture", T_TILEFROMTEXTURE },
2019-09-19 22:42:45 +00:00
};
static const tokenlist soundTokens[] =
{
{ "id", T_ID },
{ "file", T_FILE },
{ "minpitch", T_MINPITCH },
{ "maxpitch", T_MAXPITCH },
{ "priority", T_PRIORITY },
{ "type", T_TYPE },
{ "distance", T_DISTANCE },
{ "volume", T_VOLUME },
};
#if 0
static const tokenlist animTokens [] =
{
{ "delay", T_DELAY },
{ "aspect", T_ASPECT },
{ "sounds", T_SOUND },
{ "forcefilter", T_FORCEFILTER },
{ "forcenofilter", T_FORCENOFILTER },
{ "texturefilter", T_TEXTUREFILTER },
};
#endif
do
{
token = getatoken(pScript, tokens, ARRAY_SIZE(tokens));
pToken = pScript->ltextptr;
switch (token)
{
case T_LOADGRP:
{
char *fileName;
if (!scriptfile_getstring(pScript,&fileName) && firstPass)
{
fileSystem.AddAdditionalFile(fileName);
2019-09-19 22:42:45 +00:00
}
}
break;
case T_CACHESIZE:
{
int32_t cacheSize;
if (scriptfile_getnumber(pScript, &cacheSize) || !firstPass)
break;
}
break;
case T_INCLUDE:
{
char *fileName;
if (!scriptfile_getstring(pScript, &fileName))
parsedefinitions_game_include(fileName, pScript, pToken, firstPass);
break;
}
case T_INCLUDEDEFAULT:
{
parsedefinitions_game_include(G_DefaultDefFile(), pScript, pToken, firstPass);
break;
}
case T_NOAUTOLOAD:
if (firstPass)
gNoAutoLoad = true;
2019-09-19 22:42:45 +00:00
break;
case T_RFFDEFINEID:
{
char *resName = NULL;
char *resType = NULL;
char *rffName = NULL;
int resID;
if (scriptfile_getstring(pScript, &resName))
break;
if (scriptfile_getstring(pScript, &resType))
break;
if (scriptfile_getnumber(pScript, &resID))
break;
if (scriptfile_getstring(pScript, &rffName))
break;
if (!firstPass)
{
FStringf name("%s.%s", resName, resType);
fileSystem.CreatePathlessCopy(resName, resID, 0);
2019-09-19 22:42:45 +00:00
}
}
break;
case T_TILEFROMTEXTURE:
{
char *texturetokptr = pScript->ltextptr, *textureend;
int32_t tile = -1;
int32_t havesurface = 0, havevox = 0, haveview = 0, haveshade = 0;
int32_t surface = 0, vox = 0, view = 0, shade = 0;
int32_t tile_crc32 = 0;
vec2_t tile_size{};
uint8_t have_crc32 = 0;
uint8_t have_size = 0;
static const tokenlist tilefromtexturetokens[] =
{
{ "surface", T_SURFACE },
{ "voxel", T_VOXEL },
{ "ifcrc", T_IFCRC },
{ "view", T_VIEW },
{ "shade", T_SHADE },
};
if (scriptfile_getsymbol(pScript,&tile)) break;
if (scriptfile_getbraces(pScript,&textureend)) break;
while (pScript->textptr < textureend)
{
int32_t token = getatoken(pScript,tilefromtexturetokens,ARRAY_SIZE(tilefromtexturetokens));
switch (token)
{
case T_IFCRC:
scriptfile_getsymbol(pScript, &tile_crc32);
have_crc32 = 1;
break;
case T_IFMATCH:
{
char *ifmatchend;
static const tokenlist ifmatchtokens[] =
{
{ "crc32", T_CRC32 },
{ "size", T_SIZE },
};
if (scriptfile_getbraces(pScript,&ifmatchend)) break;
while (pScript->textptr < ifmatchend)
{
int32_t token = getatoken(pScript,ifmatchtokens,ARRAY_SIZE(ifmatchtokens));
switch (token)
{
case T_CRC32:
scriptfile_getsymbol(pScript, &tile_crc32);
have_crc32 = 1;
break;
case T_SIZE:
scriptfile_getsymbol(pScript, &tile_size.x);
scriptfile_getsymbol(pScript, &tile_size.y);
have_size = 1;
break;
default:
break;
}
}
break;
}
case T_SURFACE:
havesurface = 1;
scriptfile_getsymbol(pScript, &surface);
break;
case T_VOXEL:
havevox = 1;
scriptfile_getsymbol(pScript, &vox);
break;
case T_VIEW:
haveview = 1;
scriptfile_getsymbol(pScript, &view);
break;
case T_SHADE:
haveshade = 1;
scriptfile_getsymbol(pScript, &shade);
break;
}
}
2019-08-09 18:25:44 +00:00
if (!firstPass)
{
2019-08-09 18:25:44 +00:00
if (EDUKE32_PREDICT_FALSE((unsigned)tile >= MAXUSERTILES))
{
Printf("Error: missing or invalid 'tile number' for texture definition near line %s:%d\n",
2019-08-09 18:25:44 +00:00
pScript->filename, scriptfile_getlinum(pScript,texturetokptr));
break;
}
if (have_crc32)
{
int32_t const orig_crc32 = tileGetCRC32(tile);
if (orig_crc32 != tile_crc32)
{
// Printf("CRC32 of tile %d doesn't match! CRC32: %d, Expected: %d\n", tile, orig_crc32, tile_crc32);
break;
}
}
if (have_size)
2019-08-09 18:25:44 +00:00
{
2019-12-29 21:47:40 +00:00
vec2_16_t const orig_size = tilesiz[tile];
if (orig_size.x != tile_size.x && orig_size.y != tile_size.y)
2019-08-09 18:25:44 +00:00
{
// Printf("Size of tile %d doesn't match! Size: (%d, %d), Expected: (%d, %d)\n", tile, orig_size.x, orig_size.y, tile_size.x, tile_size.y);
2019-08-09 18:25:44 +00:00
break;
}
}
if (havesurface)
surfType[tile] = surface;
if (havevox)
voxelIndex[tile] = vox;
if (haveshade)
tileShade[tile] = shade;
if (haveview)
picanm[tile].extra = view&7;
}
}
break;
2019-09-19 22:42:45 +00:00
case T_GLOBALGAMEFLAGS: scriptfile_getnumber(pScript, &blood_globalflags); break;
case T_EOF: return 0;
default: break;
}
}
while (1);
return 0;
}
int loaddefinitions_game(const char *fileName, int32_t firstPass)
{
scriptfile *pScript = scriptfile_fromfile(fileName);
if (pScript)
parsedefinitions_game(pScript, firstPass);
if (userConfig.AddDefs) for (auto & m : *userConfig.AddDefs)
2019-09-19 22:42:45 +00:00
parsedefinitions_game_include(m, NULL, "null", firstPass);
if (pScript)
scriptfile_close(pScript);
scriptfile_clearsymbols();
return 0;
}
bool DemoRecordStatus(void) {
return false;
2019-09-19 22:42:45 +00:00
}
bool VanillaMode() {
return false;
2019-09-19 22:42:45 +00:00
}
int sndTryPlaySpecialMusic(int nMusic)
{
if (Mus_Play(nullptr, quoteMgr.GetQuote(nMusic), true))
{
return 0;
}
return 1;
}
void sndPlaySpecialMusicOrNothing(int nMusic)
{
if (sndTryPlaySpecialMusic(nMusic))
{
Mus_Stop();
}
}
extern IniFile* BloodINI;
void GameInterface::FreeGameData()
{
if (BloodINI) delete BloodINI;
netDeinitialize();
}
void GameInterface::UpdateScreenSize()
{
viewResizeView(gViewSize);
}
::GameInterface* CreateInterface()
{
return new GameInterface;
}
END_BLD_NS