2015-05-19 21:54:34 +00:00
|
|
|
//-------------------------------------------------------------------------
|
|
|
|
/*
|
|
|
|
Copyright (C) 1997, 2005 - 3D Realms Entertainment
|
|
|
|
|
|
|
|
This file is part of Shadow Warrior version 1.2
|
|
|
|
|
|
|
|
Shadow Warrior is free software; you can redistribute it and/or
|
|
|
|
modify it under the terms of the GNU General Public License
|
|
|
|
as published by the Free Software Foundation; either version 2
|
|
|
|
of the License, or (at your option) any later version.
|
|
|
|
|
|
|
|
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.
|
|
|
|
|
|
|
|
Original Source: 1997 - Frank Maddin and Jim Norwood
|
|
|
|
Prepared for public release: 03/28/2005 - Charlie Wiederhold, 3D Realms
|
|
|
|
*/
|
|
|
|
//-------------------------------------------------------------------------
|
|
|
|
|
2019-10-09 16:09:05 +00:00
|
|
|
#include "ns.h"
|
2015-05-19 21:54:34 +00:00
|
|
|
// CTW NOTE
|
|
|
|
/*
|
|
|
|
Known remaining issues:
|
|
|
|
- Audio stuttering.
|
|
|
|
- CD Audio not looping properly (currently hard coded to restart about every 200 seconds.
|
|
|
|
- Hitting F5 to change resolution causes a crash (currently disabled).
|
|
|
|
- Multiplayer untested.
|
|
|
|
|
|
|
|
Things required to make savegames work:
|
|
|
|
- Load makesym.wpj and build it.
|
|
|
|
- In a DOS prompt, run "makesym sw.map swdata.map swcode.map"
|
|
|
|
- Copy swcode.map to swcode.sym and swdata.map to swdata.sym
|
|
|
|
*/
|
|
|
|
// CTW NOTE END
|
|
|
|
|
|
|
|
#define MAIN
|
|
|
|
#define QUIET
|
|
|
|
#include "build.h"
|
|
|
|
#include "baselayer.h"
|
|
|
|
#include "cache1d.h"
|
|
|
|
#include "osd.h"
|
2019-10-30 05:51:44 +00:00
|
|
|
#include "renderlayer.h"
|
2015-05-19 21:54:34 +00:00
|
|
|
|
|
|
|
#include "keys.h"
|
|
|
|
#include "names2.h"
|
|
|
|
#include "panel.h"
|
|
|
|
#include "game.h"
|
|
|
|
#include "tags.h"
|
|
|
|
#include "sector.h"
|
|
|
|
#include "sprite.h"
|
|
|
|
#include "weapon.h"
|
|
|
|
#include "player.h"
|
|
|
|
#include "lists.h"
|
2019-03-21 02:24:19 +00:00
|
|
|
#include "network.h"
|
2015-05-19 21:54:34 +00:00
|
|
|
#include "pal.h"
|
|
|
|
#include "fx_man.h"
|
2019-11-06 18:22:14 +00:00
|
|
|
#include "input.h"
|
2015-05-19 21:54:34 +00:00
|
|
|
|
|
|
|
#include "mytypes.h"
|
|
|
|
//#include "config.h"
|
|
|
|
|
|
|
|
#include "menus.h"
|
|
|
|
|
|
|
|
#include "control.h"
|
2019-10-25 22:32:49 +00:00
|
|
|
#include "gamecontrol.h"
|
2015-05-19 21:54:34 +00:00
|
|
|
#include "gamedefs.h"
|
|
|
|
#include "config.h"
|
|
|
|
|
|
|
|
#include "demo.h"
|
|
|
|
#include "cache.h"
|
|
|
|
//#include "exports.h"
|
|
|
|
|
|
|
|
#include "anim.h"
|
|
|
|
|
|
|
|
#include "colormap.h"
|
|
|
|
#include "break.h"
|
|
|
|
#include "ninja.h"
|
|
|
|
#include "light.h"
|
|
|
|
#include "track.h"
|
|
|
|
#include "jsector.h"
|
|
|
|
#include "keyboard.h"
|
|
|
|
#include "text.h"
|
|
|
|
#include "music.h"
|
|
|
|
|
2015-05-19 22:07:18 +00:00
|
|
|
#include "common.h"
|
2015-05-19 22:05:20 +00:00
|
|
|
#include "common_game.h"
|
2019-10-27 15:53:00 +00:00
|
|
|
#include "gameconfigfile.h"
|
2019-11-01 07:24:10 +00:00
|
|
|
#include "printf.h"
|
2019-11-01 18:25:42 +00:00
|
|
|
#include "m_argv.h"
|
2015-05-19 22:05:20 +00:00
|
|
|
|
2019-10-09 17:58:09 +00:00
|
|
|
//#include "crc32.h"
|
2015-05-19 21:54:34 +00:00
|
|
|
|
2019-10-09 16:09:05 +00:00
|
|
|
BEGIN_SW_NS
|
|
|
|
|
2019-10-09 17:58:09 +00:00
|
|
|
void pClearSpriteList(PLAYERp pp);
|
|
|
|
signed char MNU_InputSmallString(char*, short);
|
|
|
|
signed char MNU_InputString(char*, short);
|
2019-11-17 17:02:17 +00:00
|
|
|
SWBOOL IsCommand(const char* str);
|
2019-10-09 17:58:09 +00:00
|
|
|
SWBOOL MNU_StartNetGame(void);
|
|
|
|
|
2019-04-08 06:28:54 +00:00
|
|
|
|
2015-05-19 21:54:34 +00:00
|
|
|
#if DEBUG
|
|
|
|
#define BETA 0
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#define STAT_SCREEN_PIC 5114
|
|
|
|
#define TITLE_PIC 2324
|
|
|
|
#define THREED_REALMS_PIC 2325
|
|
|
|
#define TITLE_ROT_FLAGS (ROTATE_SPRITE_CORNER|ROTATE_SPRITE_SCREEN_CLIP|ROTATE_SPRITE_NON_MASK)
|
|
|
|
#define PAL_SIZE (256*3)
|
|
|
|
|
|
|
|
char DemoName[15][16];
|
|
|
|
|
|
|
|
// Stupid WallMart version!
|
|
|
|
//#define PLOCK_VERSION TRUE
|
|
|
|
|
|
|
|
#if PLOCK_VERSION
|
2015-05-19 21:58:29 +00:00
|
|
|
SWBOOL Global_PLock = TRUE;
|
2015-05-19 21:54:34 +00:00
|
|
|
#else
|
2015-05-19 21:58:29 +00:00
|
|
|
SWBOOL Global_PLock = FALSE;
|
2015-05-19 21:54:34 +00:00
|
|
|
#endif
|
|
|
|
|
|
|
|
int GameVersion = 13; // 12 was original source release. For future releases increment by two.
|
|
|
|
char DemoText[3][64];
|
|
|
|
int DemoTextYstart = 0;
|
|
|
|
|
2015-05-19 21:58:29 +00:00
|
|
|
SWBOOL DoubleInitAWE32 = FALSE;
|
2015-05-19 21:54:34 +00:00
|
|
|
int Follow_posx=0,Follow_posy=0;
|
|
|
|
|
2015-05-19 21:58:29 +00:00
|
|
|
SWBOOL NoMeters = FALSE;
|
2015-05-19 21:54:34 +00:00
|
|
|
short IntroAnimCount = 0;
|
|
|
|
short PlayingLevel = -1;
|
2015-05-19 21:58:29 +00:00
|
|
|
SWBOOL GraphicsMode = FALSE;
|
2015-05-19 21:54:34 +00:00
|
|
|
char CacheLastLevel[32] = "";
|
|
|
|
char PlayerNameArg[32] = "";
|
2015-05-19 21:58:29 +00:00
|
|
|
SWBOOL CleanExit = FALSE;
|
|
|
|
SWBOOL DemoModeMenuInit = FALSE;
|
|
|
|
SWBOOL FinishAnim = 0;
|
|
|
|
SWBOOL ShortGameMode = FALSE;
|
|
|
|
SWBOOL ReloadPrompt = FALSE;
|
|
|
|
SWBOOL ReloadPromptMode = FALSE;
|
|
|
|
SWBOOL NewGame = TRUE;
|
|
|
|
SWBOOL InMenuLevel = FALSE;
|
|
|
|
SWBOOL LoadGameOutsideMoveLoop = FALSE;
|
|
|
|
SWBOOL LoadGameFromDemo = FALSE;
|
|
|
|
SWBOOL ArgCheat = FALSE;
|
|
|
|
extern SWBOOL NetBroadcastMode, NetModeOverride;
|
|
|
|
SWBOOL MultiPlayQuitFlag = FALSE;
|
2015-05-19 21:54:34 +00:00
|
|
|
//Miscellaneous variables
|
|
|
|
char MessageInputString[256];
|
|
|
|
char MessageOutputString[256];
|
2015-05-19 21:58:29 +00:00
|
|
|
SWBOOL MessageInputMode = FALSE;
|
|
|
|
SWBOOL ConInputMode = FALSE;
|
|
|
|
SWBOOL ConPanel = FALSE;
|
|
|
|
SWBOOL FinishedLevel = FALSE;
|
|
|
|
SWBOOL HelpInputMode = FALSE;
|
|
|
|
SWBOOL PanelUpdateMode = TRUE;
|
2015-05-19 21:54:34 +00:00
|
|
|
short HelpPage = 0;
|
|
|
|
short HelpPagePic[] = { 5115, 5116, 5117 };
|
2015-05-19 21:58:29 +00:00
|
|
|
SWBOOL InputMode = FALSE;
|
|
|
|
SWBOOL MessageInput = FALSE;
|
|
|
|
extern SWBOOL GamePaused;
|
2015-05-19 21:54:34 +00:00
|
|
|
short screenpeek = 0;
|
2015-05-19 21:58:29 +00:00
|
|
|
SWBOOL NoDemoStartup = FALSE;
|
|
|
|
SWBOOL FirstTimeIntoGame;
|
|
|
|
extern uint8_t RedBookSong[40];
|
2015-05-19 21:54:34 +00:00
|
|
|
|
2015-05-19 21:58:29 +00:00
|
|
|
SWBOOL BorderAdjust = TRUE;
|
|
|
|
SWBOOL LocationInfo = 0;
|
|
|
|
void drawoverheadmap(int cposx, int cposy, int czoom, short cang);
|
2015-05-19 21:54:34 +00:00
|
|
|
int DispFrameRate = FALSE;
|
|
|
|
int DispMono = TRUE;
|
|
|
|
int Fog = FALSE;
|
|
|
|
int FogColor;
|
2015-05-19 22:10:03 +00:00
|
|
|
SWBOOL PreCaching = TRUE;
|
2015-05-19 21:54:34 +00:00
|
|
|
int GodMode = FALSE;
|
2015-05-19 22:10:03 +00:00
|
|
|
SWBOOL BotMode = FALSE;
|
2015-05-19 21:54:34 +00:00
|
|
|
short Skill = 2;
|
|
|
|
short BetaVersion = 900;
|
|
|
|
short TotalKillable;
|
|
|
|
|
|
|
|
AUTO_NET Auto;
|
2015-05-19 21:58:29 +00:00
|
|
|
SWBOOL AutoNet = FALSE;
|
|
|
|
SWBOOL HasAutoColor = FALSE;
|
|
|
|
uint8_t AutoColor;
|
2015-05-19 21:54:34 +00:00
|
|
|
|
|
|
|
const GAME_SET gs_defaults =
|
|
|
|
{
|
|
|
|
2, // border
|
|
|
|
0, // border tile
|
|
|
|
|
|
|
|
// Network game settings
|
|
|
|
0, // GameType
|
|
|
|
0, // Level
|
|
|
|
0, // Monsters
|
|
|
|
FALSE, // HurtTeammate
|
|
|
|
TRUE, // SpawnMarkers Markers
|
|
|
|
FALSE, // TeamPlay
|
|
|
|
0, // Kill Limit
|
|
|
|
0, // Time Limit
|
|
|
|
0, // Color
|
|
|
|
TRUE, // nuke
|
2015-05-19 22:05:45 +00:00
|
|
|
"Track??", // waveform track name
|
2015-05-19 21:54:34 +00:00
|
|
|
};
|
|
|
|
GAME_SET gs;
|
|
|
|
|
2015-05-19 21:58:29 +00:00
|
|
|
SWBOOL PlayerTrackingMode = FALSE;
|
|
|
|
SWBOOL PauseMode = FALSE;
|
|
|
|
SWBOOL PauseKeySet = FALSE;
|
|
|
|
SWBOOL SlowMode = FALSE;
|
|
|
|
SWBOOL FrameAdvanceTics = 3;
|
|
|
|
SWBOOL ScrollMode2D = FALSE;
|
|
|
|
|
|
|
|
SWBOOL DebugSO = FALSE;
|
|
|
|
SWBOOL DebugPanel = FALSE;
|
|
|
|
SWBOOL DebugSector = FALSE;
|
|
|
|
SWBOOL DebugActor = FALSE;
|
|
|
|
SWBOOL DebugAnim = FALSE;
|
|
|
|
SWBOOL DebugOperate = FALSE;
|
|
|
|
SWBOOL DebugActorFreeze = FALSE;
|
|
|
|
void LoadingLevelScreen(char *level_name);
|
|
|
|
|
|
|
|
uint8_t FakeMultiNumPlayers;
|
2015-05-19 21:54:34 +00:00
|
|
|
|
|
|
|
int totalsynctics;
|
|
|
|
int turn_scale = 256;
|
|
|
|
int move_scale = 256;
|
|
|
|
|
|
|
|
short Level = 0;
|
2015-05-19 21:58:29 +00:00
|
|
|
SWBOOL ExitLevel = FALSE;
|
|
|
|
int16_t OrigCommPlayers=0;
|
|
|
|
extern uint8_t CommPlayers;
|
|
|
|
extern SWBOOL CommEnabled;
|
2015-05-19 21:54:34 +00:00
|
|
|
extern int bufferjitter;
|
|
|
|
|
2015-05-19 21:58:29 +00:00
|
|
|
SWBOOL CameraTestMode = FALSE;
|
2015-05-19 21:54:34 +00:00
|
|
|
|
2019-11-17 17:02:17 +00:00
|
|
|
char ds[645]; // debug string
|
2015-05-19 21:54:34 +00:00
|
|
|
|
|
|
|
extern short NormalVisibility;
|
|
|
|
|
|
|
|
extern int quotebot, quotebotgoal; // Multiplayer typing buffer
|
|
|
|
char recbuf[80]; // Used as a temp buffer to hold typing text
|
|
|
|
|
|
|
|
extern unsigned char palette_data[256][3]; // Global palette array
|
|
|
|
|
|
|
|
#define ACT_STATUE 0
|
|
|
|
|
|
|
|
int score;
|
2015-05-19 21:58:29 +00:00
|
|
|
SWBOOL QuitFlag = FALSE;
|
|
|
|
SWBOOL InGame = FALSE;
|
2015-05-19 21:54:34 +00:00
|
|
|
|
2015-05-19 21:58:29 +00:00
|
|
|
SWBOOL CommandSetup = FALSE;
|
2015-05-19 21:54:34 +00:00
|
|
|
|
|
|
|
char UserMapName[80]="", buffer[80], ch;
|
|
|
|
char LevelName[20];
|
|
|
|
|
2015-05-19 21:58:29 +00:00
|
|
|
uint8_t DebugPrintColor = 255;
|
2015-05-19 21:54:34 +00:00
|
|
|
|
|
|
|
int krandcount;
|
|
|
|
|
|
|
|
/// L O C A L P R O T O T Y P E S /////////////////////////////////////////////////////////
|
|
|
|
void BOT_DeleteAllBots(void);
|
2015-05-19 21:58:29 +00:00
|
|
|
void BotPlayerInsert(PLAYERp pp);
|
|
|
|
void SybexScreen(void);
|
|
|
|
void DosScreen(void);
|
2019-10-30 05:51:53 +00:00
|
|
|
void PlayTheme(void);
|
2015-05-19 21:58:29 +00:00
|
|
|
void MenuLevel(void);
|
|
|
|
void StatScreen(PLAYERp mpp);
|
|
|
|
void InitRunLevel(void);
|
|
|
|
void RunLevel(void);
|
2015-05-19 21:54:34 +00:00
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
|
|
static FILE *debug_fout = NULL;
|
|
|
|
|
2015-05-19 21:58:29 +00:00
|
|
|
void DebugWriteString(char *string)
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
|
|
|
|
|
|
|
#if BETA || !DEBUG
|
|
|
|
return;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
if (!debug_fout)
|
|
|
|
{
|
|
|
|
if ((debug_fout = fopen("dbg.foo", "ab+")) == NULL)
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
fprintf(debug_fout, "%s\n", string);
|
|
|
|
|
|
|
|
//fclose(debug_fout);
|
|
|
|
//debug_fout = NULL;
|
|
|
|
|
|
|
|
fflush(debug_fout);
|
|
|
|
}
|
|
|
|
|
2015-05-19 21:58:29 +00:00
|
|
|
void DebugWriteLoc(char *fname, int line)
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
|
|
|
|
|
|
|
#if BETA || !DEBUG
|
|
|
|
return;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
if (!debug_fout)
|
|
|
|
{
|
|
|
|
if ((debug_fout = fopen("dbg.foo", "ab+")) == NULL)
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
fprintf(debug_fout, "%s, %d\n", fname, line);
|
|
|
|
|
|
|
|
//fclose(debug_fout);
|
|
|
|
//debug_fout = NULL;
|
|
|
|
|
|
|
|
fflush(debug_fout);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Mono_Print(char *str)
|
|
|
|
{
|
|
|
|
MONO_PRINT(str);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2015-05-19 21:58:29 +00:00
|
|
|
extern SWBOOL DrawScreen;
|
2015-05-19 21:54:34 +00:00
|
|
|
#if RANDOM_DEBUG
|
|
|
|
FILE *fout_err;
|
2015-05-19 21:58:29 +00:00
|
|
|
SWBOOL RandomPrint;
|
2015-05-19 21:54:34 +00:00
|
|
|
int krand1(char *file, unsigned line)
|
|
|
|
{
|
|
|
|
ASSERT(!DrawScreen);
|
|
|
|
if (RandomPrint && !Prediction)
|
|
|
|
{
|
2015-05-19 21:58:29 +00:00
|
|
|
extern uint32_t MoveThingsCount;
|
2015-05-19 21:54:34 +00:00
|
|
|
sprintf(ds,"mtc %d, %s, line %d, %d",MoveThingsCount,file,line,randomseed);
|
|
|
|
DebugWriteString(ds);
|
|
|
|
}
|
|
|
|
randomseed = ((randomseed * 21 + 1) & 65535);
|
|
|
|
return randomseed;
|
|
|
|
}
|
|
|
|
|
|
|
|
int krand2()
|
|
|
|
{
|
|
|
|
ASSERT(!DrawScreen);
|
|
|
|
randomseed = ((randomseed * 21 + 1) & 65535);
|
|
|
|
return randomseed;
|
|
|
|
}
|
|
|
|
|
|
|
|
#else
|
|
|
|
int krand1(void)
|
|
|
|
{
|
|
|
|
ASSERT(!DrawScreen);
|
|
|
|
krandcount++;
|
|
|
|
randomseed = ((randomseed * 21 + 1) & 65535);
|
|
|
|
return randomseed;
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if DEBUG
|
2015-05-19 21:58:29 +00:00
|
|
|
SWBOOL
|
|
|
|
ValidPtr(void *ptr)
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
|
|
|
MEM_HDRp mhp;
|
2015-05-19 21:58:29 +00:00
|
|
|
uint8_t* check;
|
2015-05-19 21:54:34 +00:00
|
|
|
|
|
|
|
ASSERT(ptr != NULL);
|
|
|
|
|
2015-05-19 21:58:29 +00:00
|
|
|
mhp = (MEM_HDRp)(((uint8_t*) ptr) - sizeof(MEM_HDR));
|
2015-05-19 21:54:34 +00:00
|
|
|
|
|
|
|
if (mhp->size == 0 || mhp->checksum == 0)
|
|
|
|
{
|
|
|
|
printf("ValidPtr(): Size or Checksum == 0!\n");
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
|
2015-05-19 21:58:29 +00:00
|
|
|
check = (uint8_t*) & mhp->size;
|
2015-05-19 21:54:34 +00:00
|
|
|
|
|
|
|
if (mhp->checksum == check[0] + check[1] + check[2] + check[3])
|
|
|
|
return TRUE;
|
|
|
|
|
|
|
|
printf("ValidPtr(): Checksum bad!\n");
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
|
2015-05-19 21:58:29 +00:00
|
|
|
void
|
|
|
|
PtrCheckSum(void *ptr, unsigned int *stored, unsigned int *actual)
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
|
|
|
MEM_HDRp mhp;
|
2015-05-19 21:58:29 +00:00
|
|
|
uint8_t* check;
|
2015-05-19 21:54:34 +00:00
|
|
|
|
|
|
|
ASSERT(ptr != NULL);
|
|
|
|
|
2015-05-19 21:58:29 +00:00
|
|
|
mhp = (MEM_HDRp)(((uint8_t*) ptr) - sizeof(MEM_HDR));
|
2015-05-19 21:54:34 +00:00
|
|
|
|
2015-05-19 21:58:29 +00:00
|
|
|
check = (uint8_t*) & mhp->size;
|
2015-05-19 21:54:34 +00:00
|
|
|
|
|
|
|
*stored = mhp->checksum;
|
|
|
|
*actual = check[0] + check[1] + check[2] + check[3];
|
|
|
|
}
|
|
|
|
|
2015-05-19 21:58:29 +00:00
|
|
|
void *
|
2015-05-19 21:54:34 +00:00
|
|
|
AllocMem(int size)
|
|
|
|
{
|
2015-05-19 21:58:29 +00:00
|
|
|
uint8_t* bp;
|
2015-05-19 21:54:34 +00:00
|
|
|
MEM_HDRp mhp;
|
2015-05-19 21:58:29 +00:00
|
|
|
uint8_t* check;
|
2015-05-19 21:54:34 +00:00
|
|
|
|
|
|
|
ASSERT(size != 0);
|
|
|
|
|
2015-05-19 21:58:29 +00:00
|
|
|
bp = (uint8_t*) malloc(size + sizeof(MEM_HDR));
|
2015-05-19 21:54:34 +00:00
|
|
|
|
|
|
|
// Used for debugging, we can remove this at ship time
|
|
|
|
if (bp == NULL)
|
|
|
|
{
|
|
|
|
TerminateGame();
|
|
|
|
printf("Memory could NOT be allocated in AllocMem: size = %d\n",size);
|
|
|
|
exit(0);
|
|
|
|
}
|
|
|
|
|
|
|
|
ASSERT(bp != NULL);
|
|
|
|
|
|
|
|
mhp = (MEM_HDRp) bp;
|
|
|
|
|
|
|
|
mhp->size = size;
|
2015-05-19 21:58:29 +00:00
|
|
|
check = (uint8_t*) & mhp->size;
|
2015-05-19 21:54:34 +00:00
|
|
|
mhp->checksum = check[0] + check[1] + check[2] + check[3];
|
|
|
|
|
|
|
|
bp += sizeof(MEM_HDR);
|
|
|
|
|
|
|
|
return bp;
|
|
|
|
}
|
|
|
|
|
2015-05-19 21:58:29 +00:00
|
|
|
void *
|
|
|
|
ReAllocMem(void *ptr, int size)
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
2015-05-19 21:58:29 +00:00
|
|
|
uint8_t* bp;
|
2015-05-19 21:54:34 +00:00
|
|
|
MEM_HDRp mhp;
|
2015-05-19 21:58:29 +00:00
|
|
|
uint8_t* check;
|
2015-05-19 21:54:34 +00:00
|
|
|
|
|
|
|
ASSERT(size != 0);
|
|
|
|
|
|
|
|
ASSERT(ValidPtr(ptr));
|
|
|
|
|
2015-05-19 21:58:29 +00:00
|
|
|
mhp = (MEM_HDRp)(((uint8_t*) ptr) - sizeof(MEM_HDR));
|
2015-05-19 21:54:34 +00:00
|
|
|
|
2015-05-19 21:58:29 +00:00
|
|
|
bp = (uint8_t*) realloc(mhp, size + sizeof(MEM_HDR));
|
2015-05-19 21:54:34 +00:00
|
|
|
|
|
|
|
ASSERT(bp != NULL);
|
|
|
|
|
|
|
|
mhp = (MEM_HDRp) bp;
|
|
|
|
|
|
|
|
mhp->size = size;
|
2015-05-19 21:58:29 +00:00
|
|
|
check = (uint8_t*) & mhp->size;
|
2015-05-19 21:54:34 +00:00
|
|
|
mhp->checksum = check[0] + check[1] + check[2] + check[3];
|
|
|
|
|
|
|
|
bp += sizeof(MEM_HDR);
|
|
|
|
|
|
|
|
ASSERT(ValidPtr(bp));
|
|
|
|
|
|
|
|
return bp;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2015-05-19 21:58:29 +00:00
|
|
|
void *
|
2015-05-19 21:54:34 +00:00
|
|
|
CallocMem(int size, int num)
|
|
|
|
{
|
2015-05-19 21:58:29 +00:00
|
|
|
uint8_t* bp;
|
2015-05-19 21:54:34 +00:00
|
|
|
MEM_HDRp mhp;
|
2015-05-19 21:58:29 +00:00
|
|
|
uint8_t* check;
|
2015-05-19 21:54:34 +00:00
|
|
|
int num_bytes;
|
|
|
|
|
|
|
|
ASSERT(size != 0 && num != 0);
|
|
|
|
|
|
|
|
num_bytes = (size * num) + sizeof(MEM_HDR);
|
2015-05-19 21:58:29 +00:00
|
|
|
bp = (uint8_t*) calloc(num_bytes, 1);
|
2015-05-19 21:54:34 +00:00
|
|
|
|
|
|
|
// Used for debugging, we can remove this at ship time
|
|
|
|
if (bp == NULL)
|
|
|
|
{
|
|
|
|
TerminateGame();
|
|
|
|
printf("Memory could NOT be allocated in CallocMem: size = %d, num = %d\n",size,num);
|
|
|
|
exit(0);
|
|
|
|
}
|
|
|
|
|
|
|
|
ASSERT(bp != NULL);
|
|
|
|
|
|
|
|
mhp = (MEM_HDRp) bp;
|
|
|
|
|
|
|
|
mhp->size = size;
|
2015-05-19 21:58:29 +00:00
|
|
|
check = (uint8_t*) & mhp->size;
|
2015-05-19 21:54:34 +00:00
|
|
|
mhp->checksum = check[0] + check[1] + check[2] + check[3];
|
|
|
|
|
|
|
|
bp += sizeof(MEM_HDR);
|
|
|
|
|
|
|
|
return bp;
|
|
|
|
}
|
|
|
|
|
2015-05-19 21:58:29 +00:00
|
|
|
void
|
|
|
|
FreeMem(void *ptr)
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
|
|
|
MEM_HDRp mhp;
|
2015-05-19 21:58:29 +00:00
|
|
|
uint8_t* check;
|
2015-05-19 21:54:34 +00:00
|
|
|
|
|
|
|
ASSERT(ptr != NULL);
|
|
|
|
|
|
|
|
ASSERT(ValidPtr(ptr));
|
|
|
|
|
2015-05-19 21:58:29 +00:00
|
|
|
mhp = (MEM_HDRp)(((uint8_t*) ptr) - sizeof(MEM_HDR));
|
|
|
|
check = (uint8_t*)&mhp->size;
|
2015-05-19 21:54:34 +00:00
|
|
|
|
|
|
|
memset(mhp, 0xCC, mhp->size + sizeof(MEM_HDR));
|
|
|
|
|
|
|
|
free(mhp);
|
|
|
|
}
|
|
|
|
|
|
|
|
#else
|
2015-05-19 21:58:29 +00:00
|
|
|
SWBOOL
|
|
|
|
ValidPtr(void *ptr)
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
2015-05-19 21:58:29 +00:00
|
|
|
void *
|
2015-05-19 21:54:34 +00:00
|
|
|
AllocMem(int size)
|
|
|
|
{
|
|
|
|
return malloc(size);
|
|
|
|
}
|
|
|
|
|
2015-05-19 21:58:29 +00:00
|
|
|
void *
|
2015-05-19 21:54:34 +00:00
|
|
|
CallocMem(int size, int num)
|
|
|
|
{
|
|
|
|
return calloc(size, num);
|
|
|
|
}
|
|
|
|
|
2015-05-19 21:58:29 +00:00
|
|
|
void *
|
|
|
|
ReAllocMem(void *ptr, int size)
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
|
|
|
return realloc(ptr, size);
|
|
|
|
}
|
|
|
|
|
2015-05-19 21:58:29 +00:00
|
|
|
void
|
|
|
|
FreeMem(void *ptr)
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
|
|
|
free(ptr);
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
int PointOnLine(int x, int y, int x1, int y1, int x2, int y2)
|
|
|
|
{
|
|
|
|
// the closer to 0 the closer to the line the point is
|
|
|
|
return ((x2 - x1) * (y - y1)) - ((y2 - y1) * (x - x1));
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
Distance(int x1, int y1, int x2, int y2)
|
|
|
|
{
|
|
|
|
int min;
|
|
|
|
|
|
|
|
if ((x2 = x2 - x1) < 0)
|
|
|
|
x2 = -x2;
|
|
|
|
|
|
|
|
if ((y2 = y2 - y1) < 0)
|
|
|
|
y2 = -y2;
|
|
|
|
|
|
|
|
if (x2 > y2)
|
|
|
|
min = y2;
|
|
|
|
else
|
|
|
|
min = x2;
|
|
|
|
|
|
|
|
return x2 + y2 - DIV2(min);
|
|
|
|
}
|
|
|
|
|
2015-05-19 21:58:29 +00:00
|
|
|
void
|
|
|
|
MapSetAll2D(uint8_t fill)
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < (MAXWALLS >> 3); i++)
|
|
|
|
show2dwall[i] = fill;
|
|
|
|
for (i = 0; i < (MAXSPRITES >> 3); i++)
|
|
|
|
show2dsprite[i] = fill;
|
|
|
|
|
|
|
|
//for (i = 0; i < (MAXSECTORS >> 3); i++)
|
|
|
|
for (i = 0; i < MAXSECTORS; i++)
|
|
|
|
{
|
|
|
|
if (sector[i].ceilingpicnum != 342 && sector[i].floorpicnum != 342)
|
|
|
|
show2dsector[i>>3] |= (1<<(i&7));
|
|
|
|
//show2dsector[i] = fill;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-05-19 21:58:29 +00:00
|
|
|
void
|
|
|
|
MapSetup(void)
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
|
|
|
MapSetAll2D(0xFF);
|
|
|
|
}
|
|
|
|
|
2015-05-19 21:58:29 +00:00
|
|
|
void
|
|
|
|
setup2dscreen(void)
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
|
|
|
// qsetmode640350();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
2019-11-17 17:02:17 +00:00
|
|
|
void TerminateGame(void)
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
|
|
|
int i,j;
|
|
|
|
int oldtotalclock;
|
|
|
|
|
|
|
|
DemoTerm();
|
|
|
|
|
|
|
|
ErrorCorrectionQuit();
|
|
|
|
|
2019-10-09 17:58:09 +00:00
|
|
|
// uninitmultiplayers();
|
2015-05-19 21:54:34 +00:00
|
|
|
|
|
|
|
if (CleanExit)
|
|
|
|
{
|
|
|
|
SybexScreen();
|
|
|
|
//TenScreen();
|
|
|
|
}
|
|
|
|
|
2019-04-08 06:26:36 +00:00
|
|
|
engineUnInit();
|
2015-05-19 21:54:34 +00:00
|
|
|
|
|
|
|
//Terminate3DSounds(); // Kill the sounds linked list
|
|
|
|
UnInitSound();
|
|
|
|
|
2019-04-08 06:26:36 +00:00
|
|
|
timerUninit();
|
2015-05-19 21:54:34 +00:00
|
|
|
|
|
|
|
if (CleanExit)
|
|
|
|
DosScreen();
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2019-11-17 17:02:17 +00:00
|
|
|
void LoadLevel(const char *filename)
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
|
|
|
int pos;
|
|
|
|
|
2019-04-08 06:26:36 +00:00
|
|
|
if (engineLoadBoard(filename, SW_SHAREWARE ? 1 : 0, (vec3_t *)&Player[0], &Player[0].pang, &Player[0].cursectnum) == -1)
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
|
|
|
TerminateGame();
|
|
|
|
#ifdef RENDERTYPEWIN
|
|
|
|
{
|
|
|
|
char msg[256];
|
|
|
|
Bsnprintf(msg, 256, "Level not found: %s", filename);
|
|
|
|
wm_msgbox(apptitle, msg);
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
printf("Level Not Found: %s\n", filename);
|
|
|
|
#endif
|
|
|
|
exit(0);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void LoadDemoRun(void)
|
|
|
|
{
|
|
|
|
short i;
|
|
|
|
FILE *fin;
|
|
|
|
|
|
|
|
fin = fopen("demos.run","r");
|
|
|
|
if (fin)
|
|
|
|
{
|
|
|
|
memset(DemoName,'\0',sizeof(DemoName));
|
|
|
|
for (i = 0; TRUE; i++)
|
|
|
|
{
|
|
|
|
if (fscanf(fin, "%s", DemoName[i]) == EOF)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
fclose(fin);
|
|
|
|
}
|
|
|
|
|
|
|
|
memset(DemoText,'\0',sizeof(DemoText));
|
|
|
|
fin = fopen("demotxt.run","r");
|
|
|
|
if (fin)
|
|
|
|
{
|
|
|
|
fgets(ds, 6, fin);
|
|
|
|
sscanf(ds,"%d",&DemoTextYstart);
|
|
|
|
for (i = 0; TRUE; i++)
|
|
|
|
{
|
|
|
|
if (fgets(DemoText[i], SIZ(DemoText[0])-1, fin) == NULL)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
fclose(fin);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void DisplayDemoText(void)
|
|
|
|
{
|
|
|
|
short w,h;
|
|
|
|
short i;
|
|
|
|
|
|
|
|
for (i = 0; i < 3; i++)
|
|
|
|
{
|
|
|
|
MNU_MeasureString(DemoText[i], &w, &h);
|
|
|
|
PutStringTimer(Player, TEXT_TEST_COL(w), DemoTextYstart+(i*12), DemoText[i], 999);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void Set_GameMode(void)
|
|
|
|
{
|
|
|
|
int result;
|
|
|
|
char ch;
|
|
|
|
|
|
|
|
//DSPRINTF(ds,"ScreenMode %d, ScreenWidth %d, ScreenHeight %d",ScreenMode, ScreenWidth, ScreenHeight);
|
|
|
|
//MONO_PRINT(ds);
|
|
|
|
result = COVERsetgamemode(ScreenMode, ScreenWidth, ScreenHeight, ScreenBPP);
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
void MultiSharewareCheck(void)
|
|
|
|
{
|
|
|
|
if (!SW_SHAREWARE) return;
|
|
|
|
if (numplayers > 4)
|
|
|
|
{
|
|
|
|
#ifdef RENDERTYPEWIN
|
|
|
|
wm_msgbox(apptitle,"To play a Network game with more than 4 players you must purchase "
|
|
|
|
"the full version. Read the Ordering Info screens for details.");
|
|
|
|
#else
|
|
|
|
printf(
|
|
|
|
"\n\nTo play a Network game with more than 4 players you must purchase the\n"
|
|
|
|
"full version. Read the Ordering Info screens for details.\n\n");
|
|
|
|
#endif
|
2019-10-09 17:58:09 +00:00
|
|
|
//uninitmultiplayers();
|
2015-05-19 21:54:34 +00:00
|
|
|
//uninitkeys();
|
2019-04-08 06:26:36 +00:00
|
|
|
engineUnInit();
|
2015-05-19 21:54:34 +00:00
|
|
|
UnInitSound();
|
2019-04-08 06:26:36 +00:00
|
|
|
timerUninit();
|
2019-10-27 15:53:00 +00:00
|
|
|
Bexit(0);
|
2015-05-19 21:54:34 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// Some mem crap for Jim
|
|
|
|
// I reserve 1 meg of heap space for our use out side the cache
|
|
|
|
int TotalMemory = 0;
|
|
|
|
int ActualHeap = 0;
|
|
|
|
|
2015-05-19 21:58:29 +00:00
|
|
|
void InitAutoNet(void)
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
|
|
|
if (!AutoNet)
|
|
|
|
return;
|
|
|
|
|
|
|
|
gs.NetGameType = Auto.Rules;
|
|
|
|
gs.NetLevel = Auto.Level;
|
|
|
|
gs.NetMonsters = Auto.Enemy;
|
|
|
|
gs.NetSpawnMarkers = Auto.Markers;
|
|
|
|
gs.NetTeamPlay = Auto.Team;
|
|
|
|
gs.NetHurtTeammate = Auto.HurtTeam;
|
|
|
|
gs.NetKillLimit = Auto.Kill;
|
|
|
|
gs.NetTimeLimit = Auto.Time;
|
|
|
|
gs.NetColor = Auto.Color;
|
|
|
|
gs.NetNuke = Auto.Nuke;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void AnimateCacheCursor(void)
|
|
|
|
{
|
|
|
|
#if 0
|
|
|
|
struct rccoord old_pos;
|
|
|
|
static short cursor_num = 0;
|
|
|
|
static char cache_cursor[] = {'|','/','-','\\'};
|
|
|
|
|
|
|
|
if (GraphicsMode)
|
|
|
|
return;
|
|
|
|
|
|
|
|
cursor_num++;
|
|
|
|
if (cursor_num > 3)
|
|
|
|
cursor_num = 0;
|
|
|
|
|
|
|
|
//old_pos = _gettextposition();
|
|
|
|
//_settextposition( old_pos.row, old_pos.col );
|
|
|
|
//_settextposition( 24, 25);
|
|
|
|
_settextposition(25, 0);
|
|
|
|
sprintf(ds,"Loading sound and graphics %c", cache_cursor[cursor_num]);
|
|
|
|
_outtext(ds);
|
|
|
|
//_settextposition( old_pos.row, old_pos.col );
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
void COVERsetbrightness(int bright, unsigned char *pal)
|
|
|
|
{
|
2019-10-30 05:51:58 +00:00
|
|
|
paletteSetColorTable(BASEPAL, pal);
|
|
|
|
videoSetPalette(bright, BASEPAL, 0);
|
2015-05-19 21:54:34 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static int firstnet = 0; // JBF
|
|
|
|
int nextvoxid = 0; // JBF
|
|
|
|
|
|
|
|
|
2015-09-23 17:54:42 +00:00
|
|
|
static void SW_FatalEngineError(void)
|
|
|
|
{
|
2019-11-01 07:24:10 +00:00
|
|
|
I_Error("There was a problem initialising the Build engine: %s", engineerrstr);
|
2015-09-23 17:54:42 +00:00
|
|
|
}
|
|
|
|
|
2019-11-17 17:02:17 +00:00
|
|
|
void InitGame()
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
|
|
|
extern int MovesPerPacket;
|
|
|
|
//void *ReserveMem=NULL;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
DSPRINTF(ds,"InitGame...");
|
|
|
|
MONO_PRINT(ds);
|
|
|
|
|
2019-04-08 06:26:36 +00:00
|
|
|
if (engineInit())
|
2015-09-23 17:54:42 +00:00
|
|
|
SW_FatalEngineError();
|
2015-05-19 21:54:34 +00:00
|
|
|
|
|
|
|
InitAutoNet();
|
|
|
|
|
2019-04-08 06:26:36 +00:00
|
|
|
timerInit(120);
|
2015-05-19 21:54:34 +00:00
|
|
|
|
|
|
|
CON_InitConsole(); // Init console command list
|
|
|
|
|
|
|
|
////DSPRINTF(ds,"%s, %d",__FILE__,__LINE__); MONO_PRINT(ds);
|
|
|
|
|
|
|
|
//InitFX();
|
|
|
|
|
|
|
|
memcpy(palette_data,palette,768);
|
|
|
|
InitPalette();
|
|
|
|
// sets numplayers, connecthead, connectpoint2, myconnectindex
|
|
|
|
|
2019-10-09 17:58:09 +00:00
|
|
|
#if 0
|
2015-05-19 21:54:34 +00:00
|
|
|
if (!firstnet)
|
|
|
|
initmultiplayers(0, NULL, 0, 0, 0);
|
2015-05-19 22:03:04 +00:00
|
|
|
else if (initmultiplayersparms(argc - firstnet, &argv[firstnet]))
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
|
|
|
buildputs("Waiting for players...\n");
|
|
|
|
while (initmultiplayerscycle())
|
|
|
|
{
|
|
|
|
handleevents();
|
|
|
|
if (quitevent)
|
|
|
|
{
|
|
|
|
QuitFlag = TRUE;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2019-11-19 21:35:52 +00:00
|
|
|
#else
|
|
|
|
numplayers = 1; myconnectindex = 0;
|
|
|
|
connecthead = 0; connectpoint2[0] = -1;
|
2019-10-09 17:58:09 +00:00
|
|
|
#endif
|
2015-05-19 21:54:34 +00:00
|
|
|
initsynccrc();
|
|
|
|
|
|
|
|
// code to duplicate packets
|
|
|
|
if (numplayers > 4 && MovesPerPacket == 1)
|
|
|
|
{
|
|
|
|
MovesPerPacket = 2;
|
|
|
|
}
|
|
|
|
|
|
|
|
MultiSharewareCheck();
|
|
|
|
|
|
|
|
if (numplayers > 1)
|
|
|
|
{
|
|
|
|
CommPlayers = numplayers;
|
|
|
|
OrigCommPlayers = CommPlayers;
|
|
|
|
CommEnabled = TRUE;
|
|
|
|
if (!BotMode)
|
|
|
|
gNet.MultiGameType = MULTI_GAME_COMMBAT;
|
|
|
|
else
|
|
|
|
gNet.MultiGameType = MULTI_GAME_AI_BOTS;
|
|
|
|
|
|
|
|
#if 0 //def NET_MODE_MASTER_SLAVE
|
|
|
|
if (!NetModeOverride)
|
|
|
|
{
|
|
|
|
if (numplayers <= 4)
|
|
|
|
NetBroadcastMode = TRUE;
|
|
|
|
else
|
|
|
|
NetBroadcastMode = FALSE;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
LoadDemoRun();
|
|
|
|
// Save off total heap for later calculations
|
|
|
|
//TotalMemory = Z_AvailHeap();
|
|
|
|
//DSPRINTF(ds,"Available Heap before LoadImages = %d", TotalMemory);
|
|
|
|
//MONO_PRINT(ds);
|
|
|
|
// Reserve 1.5 megs for normal program use
|
|
|
|
// Generally, SW is consuming about a total of 11 megs including
|
|
|
|
// all the cached in graphics, etc. per level, so even on a 16 meg
|
|
|
|
// system, reserving 1.5 megs is fine.
|
|
|
|
// Note that on a 16 meg machine, Ken was leaving us about
|
|
|
|
// 24k for use outside the cache! This was causing out of mem problems
|
|
|
|
// when songs, etc., greater than the remaining heap were being loaded.
|
|
|
|
// Even if you pre-cache songs, etc. to help, reserving some heap is
|
|
|
|
// a very smart idea since the game uses malloc throughout execution.
|
|
|
|
//ReserveMem = AllocMem(1L<<20);
|
|
|
|
//if(ReserveMem == 0) MONO_PRINT("Could not allocate 1.5 meg reserve!");
|
|
|
|
|
|
|
|
// LoadImages will now proceed to steal all the remaining heap space
|
|
|
|
//_outtext("\n\n\n\n\n\n\n\n");
|
2019-11-29 07:53:31 +00:00
|
|
|
//buildputs("Loading sound and graphics...\n");
|
2015-05-19 21:54:34 +00:00
|
|
|
//AnimateCacheCursor();
|
2019-10-30 19:13:43 +00:00
|
|
|
TileFiles.LoadArtSet("tiles%03d.art");
|
2015-05-19 21:54:34 +00:00
|
|
|
|
|
|
|
// Now free it up for later use
|
|
|
|
/*
|
|
|
|
if(ReserveMem)
|
|
|
|
{
|
|
|
|
// Recalc TotalMemory for later reference
|
|
|
|
ActualHeap = Z_AvailHeap() + 1536000L;
|
|
|
|
FreeMem(ReserveMem);
|
|
|
|
}
|
|
|
|
*/
|
|
|
|
|
|
|
|
Connect();
|
|
|
|
SortBreakInfo();
|
|
|
|
parallaxtype = 1;
|
2015-05-19 22:05:20 +00:00
|
|
|
SW_InitMultiPsky();
|
2015-05-19 21:54:34 +00:00
|
|
|
|
|
|
|
memset(Track, 0, sizeof(Track));
|
|
|
|
|
|
|
|
memset(Player, 0, sizeof(Player));
|
|
|
|
for (i = 0; i < MAX_SW_PLAYERS; i++)
|
|
|
|
INITLIST(&Player[i].PanelSpriteList);
|
|
|
|
|
|
|
|
LoadKVXFromScript("swvoxfil.txt"); // Load voxels from script file
|
|
|
|
LoadPLockFromScript("swplock.txt"); // Get Parental Lock setup info
|
|
|
|
if (!SW_SHAREWARE)
|
|
|
|
LoadCustomInfoFromScript("swcustom.txt"); // Load user customisation information
|
|
|
|
|
2015-05-19 22:07:18 +00:00
|
|
|
if (!loaddefinitionsfile(G_DefFile())) buildputs("Definitions file loaded.\n");
|
|
|
|
|
2019-11-01 18:25:42 +00:00
|
|
|
userConfig.AddDefs.reset();
|
2015-05-19 21:54:34 +00:00
|
|
|
|
2019-04-08 06:26:36 +00:00
|
|
|
if (enginePostInit())
|
2015-09-23 17:54:42 +00:00
|
|
|
SW_FatalEngineError();
|
|
|
|
|
2015-05-19 21:54:34 +00:00
|
|
|
DemoModeMenuInit = TRUE;
|
|
|
|
// precache as much stuff as you can
|
|
|
|
if (UserMapName[0] == '\0')
|
|
|
|
{
|
|
|
|
AnimateCacheCursor();
|
|
|
|
LoadLevel("$dozer.map");
|
|
|
|
AnimateCacheCursor();
|
|
|
|
SetupPreCache();
|
|
|
|
DoTheCache();
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
AnimateCacheCursor();
|
|
|
|
LoadLevel(UserMapName);
|
|
|
|
AnimateCacheCursor();
|
|
|
|
SetupPreCache();
|
|
|
|
DoTheCache();
|
|
|
|
}
|
|
|
|
|
|
|
|
Set_GameMode();
|
|
|
|
GraphicsMode = TRUE;
|
|
|
|
SetupAspectRatio();
|
|
|
|
|
2019-10-27 12:40:24 +00:00
|
|
|
COVERsetbrightness(0, &palette_data[0][0]);
|
2015-05-19 21:54:34 +00:00
|
|
|
|
|
|
|
InitFX(); // JBF: do it down here so we get a hold of the window handle
|
|
|
|
InitMusic();
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
Directory of C:\DEV\SW\MIDI
|
|
|
|
EXECUT11 MID
|
|
|
|
HROSHMA6 MID
|
|
|
|
HOSHIA02 MID
|
|
|
|
INTRO131 MID
|
|
|
|
KOTEC2 MID
|
|
|
|
KOTOKI12 MID
|
|
|
|
NIPPON34 MID
|
|
|
|
NOKI41 MID
|
|
|
|
SANAI MID
|
|
|
|
SIANRA23 MID
|
|
|
|
TKYO2007 MID
|
|
|
|
TYTAIK16 MID
|
|
|
|
YOKOHA03 MID
|
|
|
|
*/
|
|
|
|
|
|
|
|
char LevelSong[16];
|
|
|
|
short SongLevelNum;
|
|
|
|
//#ifndef SW_SHAREWARE
|
|
|
|
LEVEL_INFO LevelInfo[MAX_LEVELS_REG+2] =
|
|
|
|
{
|
|
|
|
{"title.map", "theme.mid", " ", " ", " " },
|
|
|
|
{"$bullet.map", "e1l01.mid", "Seppuku Station", "0 : 55", "5 : 00" },
|
|
|
|
{"$dozer.map", "e1l03.mid", "Zilla Construction", "4 : 59", "8 : 00" },
|
|
|
|
{"$shrine.map", "e1l02.mid", "Master Leep's Temple", "3 : 16", "10 : 00" },
|
|
|
|
{"$woods.map", "e1l04.mid", "Dark Woods of the Serpent", "7 : 06", "16 : 00" },
|
|
|
|
{"$whirl.map", "yokoha03.mid", "Rising Son", "5 : 30", "10 : 00" },
|
|
|
|
{"$tank.map", "nippon34.mid", "Killing Fields", "1 : 46", "4 : 00" },
|
|
|
|
{"$boat.map", "execut11.mid", "Hara-Kiri Harbor", "1 : 56", "4 : 00" },
|
|
|
|
{"$garden.map", "execut11.mid", "Zilla's Villa", "1 : 06", "2 : 00" },
|
|
|
|
{"$outpost.map", "sanai.mid", "Monastery", "1 : 23", "3 : 00" },
|
|
|
|
{"$hidtemp.map", "kotec2.mid", "Raider of the Lost Wang", "2 : 05", "4 : 10" },
|
|
|
|
{"$plax1.map", "kotec2.mid", "Sumo Sky Palace", "6 : 32", "12 : 00" },
|
|
|
|
{"$bath.map", "yokoha03.mid", "Bath House", "10 : 00", "10 : 00" },
|
|
|
|
{"$airport.map", "nippon34.mid", "Unfriendly Skies", "2 : 59", "6 : 00" },
|
|
|
|
{"$refiner.map", "kotoki12.mid", "Crude Oil", "2 : 40", "5 : 00" },
|
|
|
|
{"$newmine.map", "hoshia02.mid", "Coolie Mines", "2 : 48", "6 : 00" },
|
|
|
|
{"$subbase.map", "hoshia02.mid", "Subpen 7", "2 : 02", "4 : 00" },
|
|
|
|
{"$rock.map", "kotoki12.mid", "The Great Escape", "3 : 18", "6 : 00" },
|
|
|
|
{"$yamato.map", "sanai.mid", "Floating Fortress", "11 : 38", "20 : 00" },
|
|
|
|
{"$seabase.map", "kotec2.mid", "Water Torture", "5 : 07", "10 : 00" },
|
|
|
|
{"$volcano.map", "kotec2.mid", "Stone Rain", "9 : 15", "20 : 00" },
|
|
|
|
{"$shore.map", "kotec2.mid", "Shanghai Shipwreck", "3 : 58", "8 : 00" },
|
|
|
|
{"$auto.map", "kotec2.mid", "Auto Maul", "4 : 07", "8 : 00" },
|
|
|
|
{"tank.map", "kotec2.mid", "Heavy Metal (DM only)", "10 : 00", "10 : 00" },
|
|
|
|
{"$dmwoods.map", "kotec2.mid", "Ripper Valley (DM only)", "10 : 00", "10 : 00" },
|
|
|
|
{"$dmshrin.map", "kotec2.mid", "House of Wang (DM only)", "10 : 00", "10 : 00" },
|
|
|
|
{"$rush.map", "kotec2.mid", "Lo Wang Rally (DM only)", "10 : 00", "10 : 00" },
|
|
|
|
{"shotgun.map", "kotec2.mid", "Ruins of the Ronin (CTF)", "10 : 00", "10 : 00" },
|
|
|
|
{"$dmdrop.map", "kotec2.mid", "Killing Fields (CTF)", "10 : 00", "10 : 00" },
|
|
|
|
{NULL, NULL, NULL, NULL, NULL}
|
|
|
|
};
|
|
|
|
/*#else
|
|
|
|
LEVEL_INFO LevelInfo[MAX_LEVELS+2] = // Shareware
|
|
|
|
{
|
|
|
|
{"title.map", "theme.mid", " ", " ", " " },
|
|
|
|
{"$bullet.map", "e1l01.mid", "Seppuku Station", "0 : 55", "5 : 00" },
|
|
|
|
{"$dozer.map", "e1l03.mid", "Zilla Construction", "4 : 59", "8 : 00" },
|
|
|
|
{"$shrine.map", "e1l02.mid", "Master Leep's Temple", "3 : 16", "10 : 00" },
|
|
|
|
{"$woods.map", "e1l04.mid", "Dark Woods of the Serpent", "7 : 06", "16 : 00" },
|
|
|
|
{NULL, NULL, NULL, NULL, NULL}
|
|
|
|
};
|
|
|
|
#endif*/
|
|
|
|
|
2019-11-17 17:02:17 +00:00
|
|
|
const char *ThemeSongs[6] =
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
2019-11-17 17:02:17 +00:00
|
|
|
"THEME.MID",
|
|
|
|
"ENDLEV3.VOC",
|
|
|
|
"SERPENT.MID",
|
|
|
|
"SUMO.MID",
|
|
|
|
"ZILLA.MID"
|
|
|
|
"ENDING.MID"
|
2015-05-19 21:54:34 +00:00
|
|
|
};
|
2019-11-17 17:02:17 +00:00
|
|
|
|
|
|
|
int ThemeTrack[6] =
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
2019-11-17 17:02:17 +00:00
|
|
|
2,3,13,13,13,14
|
2015-05-19 21:54:34 +00:00
|
|
|
};
|
2019-11-17 17:02:17 +00:00
|
|
|
|
|
|
|
char EpisodeNames[3][MAX_EPISODE_NAME_LEN+2] =
|
|
|
|
{
|
|
|
|
"^Enter the Wang",
|
|
|
|
"^Code of Honor",
|
|
|
|
"^User Maps",
|
|
|
|
};
|
|
|
|
|
|
|
|
char EpisodeSubtitles[3][MAX_EPISODE_SUBTITLE_LEN+1] =
|
|
|
|
{
|
|
|
|
"Four levels (Shareware Version)",
|
|
|
|
"Eighteen levels (Full Version Only)",
|
|
|
|
"Select a user map to play",
|
|
|
|
};
|
|
|
|
|
2015-05-19 21:54:34 +00:00
|
|
|
char SkillNames[4][MAX_SKILL_NAME_LEN+2] =
|
|
|
|
{
|
2019-11-17 17:02:17 +00:00
|
|
|
"^Tiny grasshopper",
|
|
|
|
"^I Have No Fear",
|
|
|
|
"^Who Wants Wang",
|
|
|
|
"^No Pain, No Gain"
|
2015-05-19 21:54:34 +00:00
|
|
|
};
|
|
|
|
|
2015-05-19 21:58:29 +00:00
|
|
|
void InitNewGame(void)
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
|
|
|
int i, ready_bak;
|
|
|
|
int ver_bak;
|
|
|
|
|
|
|
|
//waitforeverybody(); // since ready flag resets after this point, need to carefully sync
|
|
|
|
|
|
|
|
for (i = 0; i < MAX_SW_PLAYERS; i++)
|
|
|
|
{
|
|
|
|
// don't jack with the playerreadyflag
|
|
|
|
ready_bak = Player[i].playerreadyflag;
|
|
|
|
ver_bak = Player[i].PlayerVersion;
|
|
|
|
memset(&Player[i], 0, sizeof(Player[i]));
|
|
|
|
Player[i].playerreadyflag = ready_bak;
|
|
|
|
Player[i].PlayerVersion = ver_bak;
|
|
|
|
INITLIST(&Player[i].PanelSpriteList);
|
|
|
|
}
|
|
|
|
|
|
|
|
memset(puser, 0, sizeof(puser));
|
|
|
|
}
|
|
|
|
|
|
|
|
void FindLevelInfo(char *map_name, short *level)
|
|
|
|
{
|
|
|
|
char *ptr;
|
|
|
|
char buff[16];
|
|
|
|
short i,j;
|
|
|
|
|
|
|
|
for (j = 1; j <= MAX_LEVELS; j++)
|
|
|
|
{
|
|
|
|
if (LevelInfo[j].LevelName)
|
|
|
|
{
|
|
|
|
if (Bstrcasecmp(map_name, LevelInfo[j].LevelName) == 0)
|
|
|
|
{
|
|
|
|
*level = j;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
*level = 0;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
int ChopTics;
|
2015-05-19 21:58:29 +00:00
|
|
|
void InitLevelGlobals(void)
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
|
|
|
extern char PlayerGravity;
|
|
|
|
extern short wait_active_check_offset;
|
|
|
|
//extern short Zombies;
|
|
|
|
extern int PlaxCeilGlobZadjust, PlaxFloorGlobZadjust;
|
2015-05-19 21:58:29 +00:00
|
|
|
extern SWBOOL left_foot;
|
|
|
|
extern SWBOOL serpwasseen;
|
|
|
|
extern SWBOOL sumowasseen;
|
|
|
|
extern SWBOOL zillawasseen;
|
2015-05-19 21:54:34 +00:00
|
|
|
extern short BossSpriteNum[3];
|
|
|
|
|
|
|
|
// A few IMPORTANT GLOBAL RESETS
|
|
|
|
// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!1
|
|
|
|
MapSetup();
|
|
|
|
//Zombies = 0;
|
|
|
|
ChopTics = 0;
|
|
|
|
dimensionmode = 3;
|
|
|
|
zoom = 768;
|
|
|
|
PlayerGravity = 24;
|
|
|
|
wait_active_check_offset = 0;
|
|
|
|
PlaxCeilGlobZadjust = PlaxFloorGlobZadjust = Z(500);
|
|
|
|
FinishedLevel = FALSE;
|
|
|
|
AnimCnt = 0;
|
|
|
|
left_foot = FALSE;
|
|
|
|
screenpeek = myconnectindex;
|
|
|
|
|
|
|
|
gNet.TimeLimitClock = gNet.TimeLimit;
|
|
|
|
|
|
|
|
serpwasseen = FALSE;
|
|
|
|
sumowasseen = FALSE;
|
|
|
|
zillawasseen = FALSE;
|
|
|
|
memset(BossSpriteNum,-1,sizeof(BossSpriteNum));
|
|
|
|
}
|
|
|
|
|
2015-05-19 21:58:29 +00:00
|
|
|
void InitLevelGlobals2(void)
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
|
|
|
extern short Bunny_Count;
|
|
|
|
// GLOBAL RESETS NOT DONE for LOAD GAME
|
|
|
|
// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
|
|
|
|
InitTimingVars();
|
|
|
|
TotalKillable = 0;
|
|
|
|
Bunny_Count = 0;
|
|
|
|
}
|
|
|
|
|
2015-05-19 21:58:29 +00:00
|
|
|
void
|
|
|
|
InitLevel(void)
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
|
|
|
static int DemoNumber = 0;
|
|
|
|
|
|
|
|
Terminate3DSounds();
|
|
|
|
|
|
|
|
// A few IMPORTANT GLOBAL RESETS
|
|
|
|
InitLevelGlobals();
|
|
|
|
if (!DemoMode)
|
|
|
|
StopSong();
|
|
|
|
|
|
|
|
if (LoadGameOutsideMoveLoop)
|
|
|
|
{
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
InitLevelGlobals2();
|
|
|
|
if (DemoMode)
|
|
|
|
{
|
|
|
|
Level = 0;
|
|
|
|
NewGame = TRUE;
|
|
|
|
DemoInitOnce = FALSE;
|
|
|
|
strcpy(DemoFileName, DemoName[DemoNumber]);
|
|
|
|
DemoNumber++;
|
|
|
|
if (!DemoName[DemoNumber][0])
|
|
|
|
DemoNumber = 0;
|
|
|
|
|
|
|
|
// read header and such
|
|
|
|
DemoPlaySetup();
|
|
|
|
|
|
|
|
strcpy(LevelName, DemoLevelName);
|
|
|
|
|
|
|
|
FindLevelInfo(LevelName, &Level);
|
|
|
|
if (Level > 0)
|
|
|
|
{
|
|
|
|
strcpy(LevelSong, LevelInfo[Level].SongName);
|
|
|
|
strcpy(LevelName, LevelInfo[Level].LevelName);
|
|
|
|
UserMapName[0] = '\0';
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
strcpy(UserMapName, DemoLevelName);
|
|
|
|
Level = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (Level < 0)
|
|
|
|
Level = 0;
|
|
|
|
|
|
|
|
if (Level > MAX_LEVELS)
|
|
|
|
Level = 1;
|
|
|
|
|
|
|
|
// extra code in case something is resetting these values
|
|
|
|
if (NewGame)
|
|
|
|
{
|
|
|
|
//Level = 1;
|
|
|
|
//DemoPlaying = FALSE;
|
|
|
|
DemoMode = FALSE;
|
|
|
|
//DemoRecording = FALSE;
|
|
|
|
//DemoEdit = FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (UserMapName[0])
|
|
|
|
{
|
|
|
|
strcpy(LevelName, UserMapName);
|
|
|
|
|
|
|
|
Level = 0;
|
|
|
|
FindLevelInfo(UserMapName, &Level);
|
|
|
|
|
|
|
|
if (Level > 0)
|
|
|
|
{
|
|
|
|
// user map is part of game - treat it as such
|
|
|
|
strcpy(LevelSong, LevelInfo[Level].SongName);
|
|
|
|
strcpy(LevelName, LevelInfo[Level].LevelName);
|
|
|
|
UserMapName[0] = '\0';
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
strcpy(LevelName, LevelInfo[Level].LevelName);
|
|
|
|
strcpy(LevelSong, LevelInfo[Level].SongName);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
PlayingLevel = Level;
|
|
|
|
|
|
|
|
if (NewGame)
|
|
|
|
InitNewGame();
|
|
|
|
|
|
|
|
LoadingLevelScreen(LevelName);
|
|
|
|
MONO_PRINT("LoadintLevelScreen");
|
|
|
|
if (!DemoMode && !DemoInitOnce)
|
|
|
|
DemoPlaySetup();
|
|
|
|
|
|
|
|
LoadLevel(LevelName);
|
|
|
|
|
|
|
|
if (Bstrcasecmp(CacheLastLevel, LevelName) != 0)
|
|
|
|
// clears gotpic and does some bit setting
|
|
|
|
SetupPreCache();
|
|
|
|
else
|
|
|
|
memset(gotpic,0,sizeof(gotpic));
|
|
|
|
|
|
|
|
if (sector[0].extra != -1)
|
|
|
|
{
|
2015-05-19 22:03:30 +00:00
|
|
|
NormalVisibility = g_visibility = sector[0].extra;
|
2015-05-19 21:54:34 +00:00
|
|
|
sector[0].extra = 0;
|
|
|
|
}
|
|
|
|
else
|
2015-05-19 22:03:30 +00:00
|
|
|
NormalVisibility = g_visibility;
|
2015-05-19 21:54:34 +00:00
|
|
|
|
|
|
|
//
|
|
|
|
// Do Player stuff first
|
|
|
|
//
|
|
|
|
|
|
|
|
InitAllPlayers();
|
|
|
|
|
|
|
|
#if DEBUG
|
|
|
|
// fake Multi-player game setup
|
|
|
|
if (FakeMultiNumPlayers && !BotMode)
|
|
|
|
{
|
2015-05-19 21:58:29 +00:00
|
|
|
uint8_t i;
|
2015-05-19 21:54:34 +00:00
|
|
|
|
|
|
|
// insert all needed players except the first one - its already tere
|
|
|
|
for (i = 0; i < FakeMultiNumPlayers - 1; i++)
|
|
|
|
{
|
|
|
|
ManualPlayerInsert(Player);
|
|
|
|
// reset control back to 1st player
|
|
|
|
myconnectindex = 0;
|
|
|
|
screenpeek = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
// Put in the BOTS if called for
|
|
|
|
if (FakeMultiNumPlayers && BotMode)
|
|
|
|
{
|
2015-05-19 21:58:29 +00:00
|
|
|
uint8_t i;
|
2015-05-19 21:54:34 +00:00
|
|
|
|
|
|
|
// insert all needed players except the first one - its already tere
|
|
|
|
for (i = 0; i < FakeMultiNumPlayers; i++)
|
|
|
|
{
|
|
|
|
BotPlayerInsert(Player);
|
|
|
|
// reset control back to 1st player
|
|
|
|
myconnectindex = 0;
|
|
|
|
screenpeek = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
QueueReset();
|
|
|
|
PreMapCombineFloors();
|
|
|
|
InitMultiPlayerInfo();
|
|
|
|
InitAllPlayerSprites();
|
|
|
|
|
|
|
|
//
|
|
|
|
// Do setup for sprite, track, panel, sector, etc
|
|
|
|
//
|
|
|
|
|
|
|
|
// Set levels up
|
|
|
|
InitTimingVars();
|
|
|
|
|
|
|
|
SpriteSetup();
|
|
|
|
SpriteSetupPost(); // post processing - already gone once through the loop
|
|
|
|
InitLighting();
|
|
|
|
|
|
|
|
TrackSetup();
|
|
|
|
|
|
|
|
PlayerPanelSetup();
|
|
|
|
MapSetup();
|
|
|
|
SectorSetup();
|
|
|
|
JS_InitMirrors();
|
|
|
|
JS_InitLockouts(); // Setup the lockout linked lists
|
|
|
|
JS_ToggleLockouts(); // Init lockouts on/off
|
|
|
|
|
|
|
|
PlaceSectorObjectsOnTracks();
|
|
|
|
PlaceActorsOnTracks();
|
|
|
|
PostSetupSectorObject();
|
|
|
|
SetupMirrorTiles();
|
|
|
|
initlava();
|
|
|
|
|
|
|
|
SongLevelNum = Level;
|
|
|
|
|
|
|
|
if (DemoMode)
|
|
|
|
{
|
|
|
|
DisplayDemoText();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
if (ArgCheat)
|
|
|
|
{
|
2019-10-27 15:53:00 +00:00
|
|
|
SWBOOL bak = hud_messages;
|
|
|
|
hud_messages = FALSE;
|
2015-05-19 21:54:34 +00:00
|
|
|
EveryCheatToggle(&Player[0],NULL);
|
2019-10-27 15:53:00 +00:00
|
|
|
hud_messages = bak;
|
2015-05-19 21:54:34 +00:00
|
|
|
GodMode = TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
// reset NewGame
|
|
|
|
NewGame = FALSE;
|
|
|
|
|
|
|
|
DSPRINTF(ds,"End of InitLevel...");
|
|
|
|
MONO_PRINT(ds);
|
|
|
|
|
|
|
|
#if 0
|
|
|
|
#if DEBUG
|
|
|
|
if (!cansee(43594, -92986, 0x3fffffff, 290,
|
|
|
|
43180, -91707, 0x3fffffff, 290))
|
|
|
|
{
|
|
|
|
DSPRINTF(ds,"cansee failed");
|
|
|
|
MONO_PRINT(ds);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
#endif
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2015-05-19 21:58:29 +00:00
|
|
|
void
|
|
|
|
TerminateLevel(void)
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
|
|
|
int i, nexti, stat, pnum, ndx;
|
|
|
|
SECT_USERp *sectu;
|
|
|
|
|
|
|
|
//HEAP_CHECK();
|
|
|
|
|
|
|
|
DemoTerm();
|
|
|
|
|
|
|
|
// Free any track points
|
|
|
|
for (ndx = 0; ndx < MAX_TRACKS; ndx++)
|
|
|
|
{
|
|
|
|
if (Track[ndx].TrackPoint)
|
|
|
|
{
|
|
|
|
FreeMem(Track[ndx].TrackPoint);
|
|
|
|
// !JIM! I added null assigner
|
|
|
|
Track[ndx].TrackPoint = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Clear the tracks
|
|
|
|
memset(Track, 0, sizeof(Track));
|
|
|
|
|
|
|
|
StopSound();
|
|
|
|
Terminate3DSounds(); // Kill the 3d sounds linked list
|
|
|
|
//ClearSoundLocks();
|
|
|
|
|
|
|
|
// Clear all anims and any memory associated with them
|
|
|
|
// Clear before killing sprites - save a little time
|
|
|
|
//AnimClear();
|
|
|
|
|
|
|
|
for (stat = STAT_PLAYER0; stat < STAT_PLAYER0 + numplayers; stat++)
|
|
|
|
{
|
|
|
|
|
|
|
|
pnum = stat - STAT_PLAYER0;
|
|
|
|
|
|
|
|
TRAVERSE_SPRITE_STAT(headspritestat[stat], i, nexti)
|
|
|
|
{
|
|
|
|
if (User[i])
|
|
|
|
memcpy(&puser[pnum], User[i], sizeof(USER));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Kill User memory and delete sprites
|
|
|
|
// for (stat = 0; stat < STAT_ALL; stat++)
|
|
|
|
for (stat = 0; stat < MAXSTATUS; stat++)
|
|
|
|
{
|
|
|
|
TRAVERSE_SPRITE_STAT(headspritestat[stat], i, nexti)
|
|
|
|
{
|
|
|
|
KillSprite(i);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Free SectUser memory
|
|
|
|
for (sectu = &SectUser[0];
|
|
|
|
sectu < &SectUser[MAXSECTORS];
|
|
|
|
sectu++)
|
|
|
|
{
|
|
|
|
if (*sectu)
|
|
|
|
{
|
|
|
|
////DSPRINTF(ds,"Sect User Free %d",sectu-SectUser);
|
|
|
|
//MONO_PRINT(ds);
|
|
|
|
FreeMem(*sectu);
|
|
|
|
*sectu = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//memset(&User[0], 0, sizeof(User));
|
|
|
|
memset(&SectUser[0], 0, sizeof(SectUser));
|
|
|
|
|
|
|
|
TRAVERSE_CONNECT(pnum)
|
|
|
|
{
|
|
|
|
PLAYERp pp = Player + pnum;
|
|
|
|
|
|
|
|
// Free panel sprites for players
|
|
|
|
pClearSpriteList(pp);
|
|
|
|
|
|
|
|
pp->DoPlayerAction = NULL;
|
|
|
|
|
|
|
|
pp->SpriteP = NULL;
|
|
|
|
pp->PlayerSprite = -1;
|
|
|
|
|
|
|
|
pp->UnderSpriteP = NULL;
|
|
|
|
pp->PlayerUnderSprite = -1;
|
|
|
|
|
|
|
|
memset(pp->HasKey, 0, sizeof(pp->HasKey));
|
|
|
|
|
|
|
|
//pp->WpnFlags = 0;
|
|
|
|
pp->CurWpn = NULL;
|
|
|
|
|
|
|
|
memset(pp->Wpn, 0, sizeof(pp->Wpn));
|
|
|
|
memset(pp->InventorySprite, 0, sizeof(pp->InventorySprite));
|
|
|
|
memset(pp->InventoryTics, 0, sizeof(pp->InventoryTics));
|
|
|
|
|
|
|
|
pp->Killer = -1;
|
|
|
|
|
|
|
|
INITLIST(&pp->PanelSpriteList);
|
|
|
|
}
|
|
|
|
|
|
|
|
JS_UnInitLockouts();
|
|
|
|
|
|
|
|
//HEAP_CHECK();
|
|
|
|
}
|
|
|
|
|
2019-11-17 17:02:17 +00:00
|
|
|
void NewLevel(void)
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
|
|
|
if (DemoPlaying)
|
|
|
|
{
|
|
|
|
FX_SetVolume(0); // Shut the hell up while game is loading!
|
|
|
|
InitLevel();
|
|
|
|
InitRunLevel();
|
|
|
|
|
|
|
|
DemoInitOnce = FALSE;
|
|
|
|
if (DemoMode)
|
|
|
|
{
|
|
|
|
if (DemoModeMenuInit)
|
|
|
|
{
|
|
|
|
DemoModeMenuInit = FALSE;
|
2019-10-28 05:47:49 +00:00
|
|
|
inputState.ClearKeyStatus(sc_Escape);
|
|
|
|
}
|
2015-05-19 21:54:34 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
DemoPlayBack();
|
|
|
|
|
|
|
|
if (DemoRecording && DemoEdit)
|
|
|
|
{
|
|
|
|
RunLevel();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
FX_SetVolume(0); // Shut the hell up while game is loading!
|
|
|
|
InitLevel();
|
|
|
|
RunLevel();
|
|
|
|
|
|
|
|
if (!QuitFlag)
|
|
|
|
{
|
|
|
|
// for good measure do this
|
|
|
|
ready2send = 0;
|
|
|
|
waitforeverybody();
|
|
|
|
}
|
|
|
|
|
|
|
|
StatScreen(&Player[myconnectindex]);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (LoadGameFromDemo)
|
|
|
|
LoadGameFromDemo = FALSE;
|
|
|
|
else
|
|
|
|
TerminateLevel();
|
|
|
|
|
|
|
|
InGame = FALSE;
|
|
|
|
|
|
|
|
if (SW_SHAREWARE)
|
|
|
|
{
|
|
|
|
if (FinishAnim)
|
2019-10-30 05:51:53 +00:00
|
|
|
{
|
|
|
|
PlayTheme();
|
2015-05-19 21:54:34 +00:00
|
|
|
MenuLevel();
|
|
|
|
}
|
2019-10-30 05:51:53 +00:00
|
|
|
}
|
2015-05-19 21:54:34 +00:00
|
|
|
else
|
|
|
|
{
|
|
|
|
if (FinishAnim == ANIM_ZILLA || FinishAnim == ANIM_SERP)
|
2019-10-30 05:51:53 +00:00
|
|
|
{
|
|
|
|
PlayTheme();
|
2015-05-19 21:54:34 +00:00
|
|
|
MenuLevel();
|
|
|
|
}
|
2019-10-30 05:51:53 +00:00
|
|
|
}
|
2015-05-19 21:54:34 +00:00
|
|
|
FinishAnim = 0;
|
|
|
|
}
|
|
|
|
|
2015-05-19 21:58:29 +00:00
|
|
|
void
|
|
|
|
ResetKeys(void)
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
2019-10-28 05:47:49 +00:00
|
|
|
inputState.ClearAllKeyStatus();
|
2015-05-19 21:54:34 +00:00
|
|
|
}
|
|
|
|
|
2019-11-17 17:02:17 +00:00
|
|
|
|
|
|
|
SWBOOL KeyPressed(void)
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
2019-10-28 05:47:49 +00:00
|
|
|
for (i = 0; i < NUMKEYS; i++)
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
2019-11-03 23:53:55 +00:00
|
|
|
if (inputState.GetKeyStatus(i))
|
2015-05-19 21:54:34 +00:00
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
|
2019-11-17 17:02:17 +00:00
|
|
|
uint8_t* KeyPressedRange(uint8_t* kb, uint8_t* ke)
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
2015-05-19 21:58:29 +00:00
|
|
|
uint8_t* k;
|
2015-05-19 21:54:34 +00:00
|
|
|
|
|
|
|
for (k = kb; k <= ke; k++)
|
|
|
|
{
|
|
|
|
if (*k)
|
|
|
|
return k;
|
|
|
|
}
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2019-11-17 17:02:17 +00:00
|
|
|
void ResetKeyRange(uint8_t* kb, uint8_t* ke)
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
2015-05-19 21:58:29 +00:00
|
|
|
uint8_t* k;
|
2015-05-19 21:54:34 +00:00
|
|
|
|
|
|
|
for (k = kb; k <= ke; k++)
|
|
|
|
{
|
|
|
|
*k = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-10-30 05:51:53 +00:00
|
|
|
void PlayTheme()
|
|
|
|
{
|
|
|
|
// start music at logo
|
|
|
|
strcpy(LevelSong,"theme.mid");
|
|
|
|
PlaySong(LevelSong, RedBookSong[0], TRUE, TRUE);
|
|
|
|
|
|
|
|
DSPRINTF(ds,"After music stuff...");
|
|
|
|
MONO_PRINT(ds);
|
|
|
|
}
|
2015-05-19 21:54:34 +00:00
|
|
|
|
2019-11-17 17:02:17 +00:00
|
|
|
void LogoLevel(void)
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
|
|
|
char called;
|
|
|
|
int fin;
|
|
|
|
|
|
|
|
DSPRINTF(ds,"LogoLevel...");
|
|
|
|
MONO_PRINT(ds);
|
|
|
|
|
|
|
|
// PreCache Anim
|
|
|
|
LoadAnm(0);
|
|
|
|
|
2019-10-20 18:08:17 +00:00
|
|
|
auto pal = kloadfile("3drealms.pal", 0);
|
|
|
|
if (pal.Size() >= 768)
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
2019-10-30 05:51:58 +00:00
|
|
|
|
|
|
|
|
|
|
|
for (auto & c : pal)
|
|
|
|
c <<= 2;
|
|
|
|
|
2019-10-30 18:26:55 +00:00
|
|
|
paletteSetColorTable(DREALMSPAL, pal.Data());
|
2019-10-30 05:51:58 +00:00
|
|
|
videoSetPalette(0, DREALMSPAL, 2);
|
2015-05-19 21:54:34 +00:00
|
|
|
}
|
|
|
|
DSPRINTF(ds,"Just read in 3drealms.pal...");
|
|
|
|
MONO_PRINT(ds);
|
|
|
|
|
|
|
|
//FadeOut(0, 0);
|
|
|
|
ready2send = 0;
|
|
|
|
totalclock = 0;
|
|
|
|
ototalclock = 0;
|
|
|
|
|
|
|
|
DSPRINTF(ds,"About to display 3drealms pic...");
|
|
|
|
MONO_PRINT(ds);
|
|
|
|
|
2019-04-08 06:26:36 +00:00
|
|
|
videoClearViewableArea(0L);
|
2015-05-19 21:54:34 +00:00
|
|
|
rotatesprite(0, 0, RS_SCALE, 0, THREED_REALMS_PIC, 0, 0, TITLE_ROT_FLAGS, 0, 0, xdim - 1, ydim - 1);
|
2019-04-08 06:26:36 +00:00
|
|
|
videoNextPage();
|
2015-05-19 21:54:34 +00:00
|
|
|
//FadeIn(0, 3);
|
|
|
|
|
|
|
|
ResetKeys();
|
|
|
|
while (TRUE)
|
|
|
|
{
|
|
|
|
handleevents();
|
|
|
|
if (quitevent) { QuitFlag = TRUE; break; }
|
|
|
|
|
|
|
|
// taken from top of faketimerhandler
|
|
|
|
// limits checks to max of 40 times a second
|
|
|
|
if (totalclock >= ototalclock + synctics)
|
|
|
|
{
|
|
|
|
ototalclock += synctics;
|
|
|
|
}
|
|
|
|
|
2019-11-06 18:22:14 +00:00
|
|
|
if (totalclock > 5*120 || I_GeneralTrigger())
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
2019-11-06 18:22:14 +00:00
|
|
|
I_GeneralTriggerClear();
|
2015-05-19 21:54:34 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-04-08 06:26:36 +00:00
|
|
|
videoClearViewableArea(0L);
|
|
|
|
videoNextPage();
|
2019-10-30 05:51:58 +00:00
|
|
|
videoSetPalette(0, BASEPAL, 2);
|
2015-05-19 21:54:34 +00:00
|
|
|
|
|
|
|
// put up a blank screen while loading
|
|
|
|
|
|
|
|
DSPRINTF(ds,"End of LogoLevel...");
|
|
|
|
MONO_PRINT(ds);
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2019-11-17 17:02:17 +00:00
|
|
|
void CreditsLevel(void)
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
|
|
|
char called;
|
|
|
|
int fin;
|
|
|
|
int i;
|
|
|
|
int curpic;
|
|
|
|
int handle;
|
2015-05-19 21:58:29 +00:00
|
|
|
uint32_t timer = 0;
|
2015-05-19 21:54:34 +00:00
|
|
|
int zero=0;
|
|
|
|
short save;
|
|
|
|
#define CREDITS1_PIC 5111
|
|
|
|
#define CREDITS2_PIC 5118
|
|
|
|
|
|
|
|
// put up a blank screen while loading
|
|
|
|
|
|
|
|
// get rid of all PERM sprites!
|
2019-04-08 06:26:36 +00:00
|
|
|
renderFlushPerms();
|
2015-05-19 21:54:34 +00:00
|
|
|
save = gs.BorderNum;
|
|
|
|
SetBorder(Player + myconnectindex,0);
|
|
|
|
ClearStartMost();
|
|
|
|
gs.BorderNum = save;
|
2019-04-08 06:26:36 +00:00
|
|
|
videoClearViewableArea(0L);
|
|
|
|
videoNextPage();
|
2015-05-19 21:54:34 +00:00
|
|
|
|
|
|
|
// Lo Wang feel like singing!
|
|
|
|
handle = PlaySound(DIGI_JG95012,&zero,&zero,&zero,v3df_none);
|
|
|
|
|
|
|
|
if (handle > 0)
|
|
|
|
while (FX_SoundActive(handle)) ;
|
|
|
|
|
|
|
|
// try 14 then 2 then quit
|
|
|
|
if (!PlaySong(NULL, 14, FALSE, TRUE))
|
|
|
|
{
|
|
|
|
if (!PlaySong(NULL, 2, FALSE, TRUE))
|
|
|
|
{
|
|
|
|
handle = PlaySound(DIGI_NOLIKEMUSIC,&zero,&zero,&zero,v3df_none);
|
|
|
|
if (handle > 0)
|
|
|
|
while (FX_SoundActive(handle)) handleevents();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
ready2send = 0;
|
|
|
|
totalclock = 0;
|
|
|
|
ototalclock = 0;
|
|
|
|
|
|
|
|
ResetKeys();
|
|
|
|
curpic = CREDITS1_PIC;
|
|
|
|
|
|
|
|
while (TRUE)
|
|
|
|
{
|
|
|
|
// taken from top of faketimerhandler
|
|
|
|
// limits checks to max of 40 times a second
|
|
|
|
if (totalclock >= ototalclock + synctics)
|
|
|
|
{
|
|
|
|
ototalclock += synctics;
|
|
|
|
timer += synctics;
|
|
|
|
}
|
|
|
|
|
|
|
|
rotatesprite(0, 0, RS_SCALE, 0, curpic, 0, 0, TITLE_ROT_FLAGS, 0, 0, xdim - 1, ydim - 1);
|
|
|
|
|
2019-04-08 06:26:36 +00:00
|
|
|
videoNextPage();
|
2015-05-19 21:54:34 +00:00
|
|
|
|
|
|
|
if (timer > 8*120)
|
|
|
|
{
|
|
|
|
curpic = CREDITS2_PIC;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (timer > 16*120)
|
|
|
|
{
|
|
|
|
timer = 0;
|
|
|
|
curpic = CREDITS1_PIC;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
if (!SongIsPlaying())
|
|
|
|
break;
|
|
|
|
|
2019-11-03 23:53:55 +00:00
|
|
|
if (inputState.GetKeyStatus(KEYSC_ESC))
|
2015-05-19 21:54:34 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
// put up a blank screen while loading
|
2019-04-08 06:26:36 +00:00
|
|
|
videoClearViewableArea(0L);
|
|
|
|
videoNextPage();
|
2015-05-19 21:54:34 +00:00
|
|
|
ResetKeys();
|
|
|
|
StopSong();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2019-11-17 17:02:17 +00:00
|
|
|
void SybexScreen(void)
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
|
|
|
if (!SW_SHAREWARE) return;
|
|
|
|
|
|
|
|
if (CommEnabled)
|
|
|
|
return;
|
|
|
|
|
|
|
|
rotatesprite(0, 0, RS_SCALE, 0, 5261, 0, 0, TITLE_ROT_FLAGS, 0, 0, xdim - 1, ydim - 1);
|
2019-04-08 06:26:36 +00:00
|
|
|
videoNextPage();
|
2015-05-19 21:54:34 +00:00
|
|
|
|
|
|
|
ResetKeys();
|
|
|
|
while (!KeyPressed() && !quitevent) handleevents();
|
|
|
|
}
|
|
|
|
|
|
|
|
// CTW REMOVED END
|
|
|
|
|
2015-05-19 21:58:29 +00:00
|
|
|
void
|
|
|
|
TitleLevel(void)
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
|
|
|
char called;
|
|
|
|
int fin;
|
|
|
|
unsigned char backup_pal[256*3];
|
|
|
|
unsigned char pal[PAL_SIZE];
|
2017-01-23 11:21:04 +00:00
|
|
|
char tempbuf[256];
|
|
|
|
char *palook_bak = palookup[0];
|
2015-05-19 21:54:34 +00:00
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < 256; i++)
|
|
|
|
tempbuf[i] = i;
|
|
|
|
palookup[0] = tempbuf;
|
|
|
|
|
2019-04-08 06:26:36 +00:00
|
|
|
videoClearViewableArea(0L);
|
|
|
|
videoNextPage();
|
2015-05-19 21:54:34 +00:00
|
|
|
|
2019-11-01 21:17:15 +00:00
|
|
|
ready2send = 0;
|
2015-05-19 21:54:34 +00:00
|
|
|
totalclock = 0;
|
|
|
|
ototalclock = 0;
|
|
|
|
|
|
|
|
rotatesprite(0, 0, RS_SCALE, 0, TITLE_PIC, 0, 0, TITLE_ROT_FLAGS, 0, 0, xdim - 1, ydim - 1);
|
2019-04-08 06:26:36 +00:00
|
|
|
videoNextPage();
|
2015-05-19 21:54:34 +00:00
|
|
|
//FadeIn(0, 3);
|
|
|
|
|
|
|
|
ResetKeys();
|
|
|
|
while (TRUE)
|
|
|
|
{
|
|
|
|
handleevents();
|
|
|
|
OSD_DispatchQueued();
|
|
|
|
|
|
|
|
// taken from top of faketimerhandler
|
|
|
|
// limits checks to max of 40 times a second
|
|
|
|
if (totalclock >= ototalclock + synctics)
|
|
|
|
{
|
|
|
|
//void MNU_CheckForMenusAnyKey( void );
|
|
|
|
|
|
|
|
ototalclock += synctics;
|
|
|
|
//MNU_CheckForMenusAnyKey();
|
|
|
|
}
|
|
|
|
|
|
|
|
//if (UsingMenus)
|
|
|
|
// MNU_DrawMenu();
|
|
|
|
|
|
|
|
//drawscreen as fast as you can
|
|
|
|
rotatesprite(0, 0, RS_SCALE, 0, TITLE_PIC, 0, 0, TITLE_ROT_FLAGS, 0, 0, xdim - 1, ydim - 1);
|
|
|
|
|
2019-04-08 06:26:36 +00:00
|
|
|
videoNextPage();
|
2015-05-19 21:54:34 +00:00
|
|
|
|
|
|
|
if (totalclock > 5*120 || KeyPressed())
|
|
|
|
{
|
|
|
|
DemoMode = TRUE;
|
|
|
|
DemoPlaying = TRUE;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
palookup[0] = palook_bak;
|
|
|
|
|
|
|
|
// clearview(0);
|
|
|
|
// nextpage();
|
|
|
|
//SetPaletteToVESA(backup_pal);
|
|
|
|
|
|
|
|
// put up a blank screen while loading
|
|
|
|
// clearview(0);
|
|
|
|
// nextpage();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2015-05-19 21:58:29 +00:00
|
|
|
void DrawMenuLevelScreen(void)
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
2019-04-08 06:26:36 +00:00
|
|
|
renderFlushPerms();
|
|
|
|
videoClearViewableArea(0L);
|
2015-05-19 21:54:34 +00:00
|
|
|
rotatesprite(0, 0, RS_SCALE, 0, TITLE_PIC, 20, 0, TITLE_ROT_FLAGS, 0, 0, xdim - 1, ydim - 1);
|
|
|
|
}
|
|
|
|
|
2015-05-19 21:58:29 +00:00
|
|
|
void DrawStatScreen(void)
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
2019-04-08 06:26:36 +00:00
|
|
|
renderFlushPerms();
|
|
|
|
videoClearViewableArea(0L);
|
2015-05-19 21:54:34 +00:00
|
|
|
rotatesprite(0, 0, RS_SCALE, 0, STAT_SCREEN_PIC, 0, 0, TITLE_ROT_FLAGS, 0, 0, xdim - 1, ydim - 1);
|
|
|
|
}
|
|
|
|
|
2015-05-19 21:58:29 +00:00
|
|
|
void DrawLoadLevelScreen(void)
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
2019-04-08 06:26:36 +00:00
|
|
|
renderFlushPerms();
|
|
|
|
videoClearViewableArea(0L);
|
2015-05-19 21:54:34 +00:00
|
|
|
rotatesprite(0, 0, RS_SCALE, 0, TITLE_PIC, 20, 0, TITLE_ROT_FLAGS, 0, 0, xdim - 1, ydim - 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
short PlayerQuitMenuLevel = -1;
|
|
|
|
|
2019-11-17 17:02:17 +00:00
|
|
|
void IntroAnimLevel(void)
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
|
|
|
DSPRINTF(ds,"IntroAnimLevel");
|
|
|
|
MONO_PRINT(ds);
|
|
|
|
playanm(0);
|
|
|
|
}
|
|
|
|
|
2019-11-17 17:02:17 +00:00
|
|
|
void MenuLevel(void)
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
|
|
|
char called;
|
|
|
|
int fin;
|
|
|
|
short w,h;
|
|
|
|
|
|
|
|
DSPRINTF(ds,"MenuLevel...");
|
|
|
|
MONO_PRINT(ds);
|
|
|
|
|
|
|
|
|
|
|
|
// do demos only if not playing multi play
|
|
|
|
if (!CommEnabled && numplayers <= 1 && !FinishAnim && !NoDemoStartup)
|
|
|
|
{
|
|
|
|
// demos exist - do demo instead
|
|
|
|
if (DemoName[0][0] != '\0')
|
|
|
|
{
|
|
|
|
DemoMode = TRUE;
|
|
|
|
DemoPlaying = TRUE;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
DemoMode = FALSE;
|
|
|
|
DemoPlaying = FALSE;
|
|
|
|
|
2019-04-08 06:26:36 +00:00
|
|
|
videoClearViewableArea(0L);
|
|
|
|
videoNextPage();
|
2015-05-19 21:54:34 +00:00
|
|
|
|
|
|
|
//FadeOut(0, 0);
|
|
|
|
ready2send = 0;
|
|
|
|
totalclock = 0;
|
|
|
|
ototalclock = 0;
|
|
|
|
ExitLevel = FALSE;
|
|
|
|
InMenuLevel = TRUE;
|
|
|
|
|
|
|
|
DrawMenuLevelScreen();
|
|
|
|
|
|
|
|
if (CommEnabled)
|
|
|
|
{
|
|
|
|
sprintf(ds,"Lo Wang is waiting for other players...");
|
|
|
|
MNU_MeasureString(ds, &w, &h);
|
|
|
|
MNU_DrawString(TEXT_TEST_COL(w), 170, ds, 1, 16);
|
|
|
|
|
|
|
|
sprintf(ds,"They are afraid!");
|
|
|
|
MNU_MeasureString(ds, &w, &h);
|
|
|
|
MNU_DrawString(TEXT_TEST_COL(w), 180, ds, 1, 16);
|
|
|
|
}
|
|
|
|
|
2019-04-08 06:26:36 +00:00
|
|
|
videoNextPage();
|
2015-05-19 21:54:34 +00:00
|
|
|
//FadeIn(0, 3);
|
|
|
|
|
|
|
|
waitforeverybody();
|
|
|
|
|
|
|
|
// don't allow BorderAdjusting in these menus
|
|
|
|
BorderAdjust = FALSE;
|
|
|
|
|
|
|
|
ResetKeys();
|
|
|
|
|
|
|
|
if (SW_SHAREWARE)
|
|
|
|
{
|
|
|
|
// go to ordering menu only if shareware
|
|
|
|
if (FinishAnim)
|
|
|
|
{
|
2019-10-28 05:47:49 +00:00
|
|
|
inputState.ClearKeyStatus(sc_Escape);
|
|
|
|
ControlPanelType = ct_ordermenu;
|
2015-05-19 21:54:34 +00:00
|
|
|
FinishAnim = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
FinishAnim = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
while (TRUE)
|
|
|
|
{
|
|
|
|
handleevents();
|
|
|
|
OSD_DispatchQueued();
|
|
|
|
|
|
|
|
if (quitevent) QuitFlag = TRUE;
|
|
|
|
|
|
|
|
// taken from top of faketimerhandler
|
|
|
|
// limits checks to max of 40 times a second
|
|
|
|
if (totalclock >= ototalclock + synctics)
|
|
|
|
{
|
|
|
|
ototalclock += synctics;
|
|
|
|
MNU_CheckForMenusAnyKey();
|
|
|
|
if (CommEnabled)
|
|
|
|
getpackets();
|
|
|
|
}
|
|
|
|
|
|
|
|
if (CommEnabled)
|
|
|
|
{
|
|
|
|
if (MultiPlayQuitFlag)
|
|
|
|
{
|
|
|
|
short pnum;
|
2015-05-19 21:58:29 +00:00
|
|
|
uint8_t pbuf[1];
|
2015-05-19 21:54:34 +00:00
|
|
|
QuitFlag = TRUE;
|
|
|
|
pbuf[0] = PACKET_TYPE_MENU_LEVEL_QUIT;
|
|
|
|
netbroadcastpacket(pbuf, 1); // TENSW
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (PlayerQuitMenuLevel >= 0)
|
|
|
|
{
|
|
|
|
MenuCommPlayerQuit(PlayerQuitMenuLevel);
|
|
|
|
PlayerQuitMenuLevel = -1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ExitLevel)
|
|
|
|
{
|
|
|
|
// Quiting Level
|
|
|
|
ExitLevel = FALSE;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (QuitFlag)
|
|
|
|
{
|
|
|
|
// Quiting Game
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
// force the use of menus at all time
|
|
|
|
if (!UsingMenus && !ConPanel)
|
|
|
|
{
|
2019-10-28 05:47:49 +00:00
|
|
|
inputState.SetKeyStatus(sc_Escape);
|
2015-05-19 21:54:34 +00:00
|
|
|
MNU_CheckForMenusAnyKey();
|
|
|
|
}
|
|
|
|
|
|
|
|
// must lock the clock for drawing so animations will happen
|
|
|
|
totalclocklock = totalclock;
|
|
|
|
|
|
|
|
//drawscreen as fast as you can
|
|
|
|
DrawMenuLevelScreen();
|
|
|
|
|
|
|
|
if (UsingMenus)
|
|
|
|
MNU_DrawMenu();
|
|
|
|
|
2019-04-08 06:26:36 +00:00
|
|
|
videoNextPage();
|
2015-05-19 21:54:34 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
BorderAdjust = TRUE;
|
|
|
|
//LoadGameOutsideMoveLoop = FALSE;
|
2019-10-28 05:47:49 +00:00
|
|
|
inputState.ClearKeyStatus(sc_Escape);
|
2019-11-03 23:53:55 +00:00
|
|
|
inputState.ClearKeysDown();
|
2015-05-19 21:54:34 +00:00
|
|
|
//ExitMenus();
|
|
|
|
UsingMenus = FALSE;
|
|
|
|
InMenuLevel = FALSE;
|
2019-04-08 06:26:36 +00:00
|
|
|
videoClearViewableArea(0L);
|
|
|
|
videoNextPage();
|
2015-05-19 21:54:34 +00:00
|
|
|
}
|
|
|
|
|
2019-11-17 17:02:17 +00:00
|
|
|
void SceneLevel(void)
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
2015-05-19 21:58:29 +00:00
|
|
|
SWBOOL dp_bak;
|
|
|
|
SWBOOL dm_bak;
|
2015-05-19 21:54:34 +00:00
|
|
|
FILE *fin;
|
|
|
|
#define CINEMATIC_DEMO_FILE "$scene.dmo"
|
|
|
|
|
|
|
|
// make sure it exists
|
|
|
|
if ((fin = fopen(CINEMATIC_DEMO_FILE,"rb")) == NULL)
|
|
|
|
return;
|
|
|
|
else
|
|
|
|
fclose(fin);
|
|
|
|
|
|
|
|
strcpy(DemoFileName,CINEMATIC_DEMO_FILE);
|
|
|
|
|
|
|
|
dp_bak = DemoPlaying;
|
|
|
|
dm_bak = DemoMode;
|
|
|
|
|
|
|
|
DemoMode = TRUE;
|
|
|
|
DemoPlaying = TRUE;
|
|
|
|
DemoOverride = TRUE;
|
|
|
|
InitLevel();
|
|
|
|
DemoOverride = FALSE;
|
|
|
|
|
|
|
|
ScenePlayBack();
|
|
|
|
TerminateLevel();
|
|
|
|
DemoMode = dm_bak;
|
|
|
|
DemoPlaying = dp_bak;
|
|
|
|
}
|
|
|
|
|
2019-11-17 17:02:17 +00:00
|
|
|
void LoadingLevelScreen(char *level_name)
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
|
|
|
short w,h;
|
2015-05-19 21:58:29 +00:00
|
|
|
extern SWBOOL DemoMode;
|
2015-05-19 21:54:34 +00:00
|
|
|
extern char *MNU_LevelName[28];
|
|
|
|
DrawLoadLevelScreen();
|
|
|
|
|
|
|
|
if (DemoMode)
|
|
|
|
sprintf(ds,"DEMO");
|
|
|
|
else
|
|
|
|
sprintf(ds,"ENTERING");
|
|
|
|
|
|
|
|
MNU_MeasureString(ds, &w, &h);
|
|
|
|
MNU_DrawString(TEXT_TEST_COL(w), 170, ds,1,16);
|
|
|
|
|
|
|
|
if (UserMapName[0])
|
|
|
|
sprintf(ds,"%s",UserMapName);
|
|
|
|
else
|
|
|
|
sprintf(ds,"%s",LevelInfo[Level].Description);
|
|
|
|
|
|
|
|
MNU_MeasureString(ds, &w, &h);
|
|
|
|
MNU_DrawString(TEXT_TEST_COL(w), 180, ds,1,16);
|
|
|
|
|
2019-04-08 06:26:36 +00:00
|
|
|
videoNextPage();
|
2015-05-19 21:54:34 +00:00
|
|
|
}
|
|
|
|
|
2019-11-17 17:02:17 +00:00
|
|
|
void gNextState(STATEp *State)
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
|
|
|
// Transition to the next state
|
|
|
|
*State = (*State)->NextState;
|
|
|
|
|
|
|
|
if (TEST((*State)->Tics, SF_QUICK_CALL))
|
|
|
|
{
|
|
|
|
(*(*State)->Animator)(0);
|
|
|
|
*State = (*State)->NextState;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Generic state control
|
2019-11-17 17:02:17 +00:00
|
|
|
void gStateControl(STATEp *State, int *tics)
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
|
|
|
*tics += synctics;
|
|
|
|
|
|
|
|
// Skip states if too much time has passed
|
|
|
|
while (*tics >= (*State)->Tics)
|
|
|
|
{
|
|
|
|
// Set Tics
|
|
|
|
*tics -= (*State)->Tics;
|
|
|
|
gNextState(State);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Call the correct animator
|
|
|
|
if ((*State)->Animator)
|
|
|
|
(*(*State)->Animator)(0);
|
|
|
|
}
|
|
|
|
|
|
|
|
int BonusPunchSound(short SpriteNum)
|
|
|
|
{
|
|
|
|
PLAYERp pp = Player + myconnectindex;
|
|
|
|
PlaySound(DIGI_PLAYERYELL3, &pp->posx, &pp->posy, &pp->posz, v3df_none);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int BonusKickSound(short SpriteNum)
|
|
|
|
{
|
|
|
|
PLAYERp pp = Player + myconnectindex;
|
|
|
|
PlaySound(DIGI_PLAYERYELL2, &pp->posx, &pp->posy, &pp->posz, v3df_none);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int BonusGrabSound(short SpriteNum)
|
|
|
|
{
|
|
|
|
PLAYERp pp = Player + myconnectindex;
|
|
|
|
PlaySound(DIGI_BONUS_GRAB, &pp->posx, &pp->posy, &pp->posz, v3df_none);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2019-11-17 17:02:17 +00:00
|
|
|
void BonusScreen(PLAYERp pp)
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
|
|
|
int minutes,seconds,second_tics;
|
2015-05-19 21:58:29 +00:00
|
|
|
extern SWBOOL FinishedLevel;
|
2015-05-19 21:54:34 +00:00
|
|
|
extern int PlayClock;
|
|
|
|
extern short LevelSecrets;
|
|
|
|
extern short TotalKillable;
|
|
|
|
short w,h;
|
|
|
|
short pic,limit;
|
|
|
|
int zero=0;
|
|
|
|
int handle = 0;
|
|
|
|
short LI_Num;
|
|
|
|
|
|
|
|
|
|
|
|
#define BONUS_SCREEN_PIC 5120
|
|
|
|
#define BONUS_ANIM 5121
|
|
|
|
#define BONUS_ANIM_FRAMES (5159-5121)
|
|
|
|
|
|
|
|
#define BREAK_LIGHT_RATE 18
|
|
|
|
|
|
|
|
#define BONUS_PUNCH 5121
|
|
|
|
#define BONUS_KICK 5136
|
|
|
|
#define BONUS_GRAB 5151
|
|
|
|
#define BONUS_REST 5121
|
|
|
|
|
|
|
|
#define BONUS_TICS 8
|
|
|
|
#define BONUS_GRAB_TICS 20
|
|
|
|
#define BONUS_REST_TICS 50
|
|
|
|
|
|
|
|
static STATE s_BonusPunch[] =
|
|
|
|
{
|
|
|
|
{BONUS_PUNCH + 0, BONUS_TICS, NULL, &s_BonusPunch[1]},
|
|
|
|
{BONUS_PUNCH + 1, BONUS_TICS, NULL, &s_BonusPunch[2]},
|
|
|
|
{BONUS_PUNCH + 2, BONUS_TICS, NULL, &s_BonusPunch[3]},
|
|
|
|
{BONUS_PUNCH + 2, 0|SF_QUICK_CALL, BonusPunchSound, &s_BonusPunch[4]},
|
|
|
|
{BONUS_PUNCH + 3, BONUS_TICS, NULL, &s_BonusPunch[5]},
|
|
|
|
{BONUS_PUNCH + 4, BONUS_TICS, NULL, &s_BonusPunch[6]},
|
|
|
|
{BONUS_PUNCH + 5, BONUS_TICS, NULL, &s_BonusPunch[7]},
|
|
|
|
{BONUS_PUNCH + 6, BONUS_TICS, NULL, &s_BonusPunch[8]},
|
|
|
|
{BONUS_PUNCH + 7, BONUS_TICS, NULL, &s_BonusPunch[9]},
|
|
|
|
{BONUS_PUNCH + 8, BONUS_TICS, NULL, &s_BonusPunch[10]},
|
|
|
|
{BONUS_PUNCH + 9, BONUS_TICS, NULL, &s_BonusPunch[11]},
|
|
|
|
{BONUS_PUNCH + 10, BONUS_TICS, NULL, &s_BonusPunch[12]},
|
|
|
|
{BONUS_PUNCH + 11, BONUS_TICS, NULL, &s_BonusPunch[13]},
|
|
|
|
{BONUS_PUNCH + 12, BONUS_TICS, NULL, &s_BonusPunch[14]},
|
|
|
|
{BONUS_PUNCH + 14, 90, NULL, &s_BonusPunch[15]},
|
|
|
|
{BONUS_PUNCH + 14, BONUS_TICS, NULL, &s_BonusPunch[15]},
|
|
|
|
};
|
|
|
|
|
|
|
|
static STATE s_BonusKick[] =
|
|
|
|
{
|
|
|
|
{BONUS_KICK + 0, BONUS_TICS, NULL, &s_BonusKick[1]},
|
|
|
|
{BONUS_KICK + 1, BONUS_TICS, NULL, &s_BonusKick[2]},
|
|
|
|
{BONUS_KICK + 2, BONUS_TICS, NULL, &s_BonusKick[3]},
|
|
|
|
{BONUS_KICK + 2, 0|SF_QUICK_CALL, BonusKickSound, &s_BonusKick[4]},
|
|
|
|
{BONUS_KICK + 3, BONUS_TICS, NULL, &s_BonusKick[5]},
|
|
|
|
{BONUS_KICK + 4, BONUS_TICS, NULL, &s_BonusKick[6]},
|
|
|
|
{BONUS_KICK + 5, BONUS_TICS, NULL, &s_BonusKick[7]},
|
|
|
|
{BONUS_KICK + 6, BONUS_TICS, NULL, &s_BonusKick[8]},
|
|
|
|
{BONUS_KICK + 7, BONUS_TICS, NULL, &s_BonusKick[9]},
|
|
|
|
{BONUS_KICK + 8, BONUS_TICS, NULL, &s_BonusKick[10]},
|
|
|
|
{BONUS_KICK + 9, BONUS_TICS, NULL, &s_BonusKick[11]},
|
|
|
|
{BONUS_KICK + 10, BONUS_TICS, NULL, &s_BonusKick[12]},
|
|
|
|
{BONUS_KICK + 11, BONUS_TICS, NULL, &s_BonusKick[13]},
|
|
|
|
{BONUS_KICK + 12, BONUS_TICS, NULL, &s_BonusKick[14]},
|
|
|
|
{BONUS_KICK + 14, 90, NULL, &s_BonusKick[15]},
|
|
|
|
{BONUS_KICK + 14, BONUS_TICS, NULL, &s_BonusKick[15]},
|
|
|
|
};
|
|
|
|
|
|
|
|
static STATE s_BonusGrab[] =
|
|
|
|
{
|
|
|
|
{BONUS_GRAB + 0, BONUS_GRAB_TICS, NULL, &s_BonusGrab[1]},
|
|
|
|
{BONUS_GRAB + 1, BONUS_GRAB_TICS, NULL, &s_BonusGrab[2]},
|
|
|
|
{BONUS_GRAB + 2, BONUS_GRAB_TICS, NULL, &s_BonusGrab[3]},
|
|
|
|
{BONUS_GRAB + 2, 0|SF_QUICK_CALL, BonusGrabSound, &s_BonusGrab[4]},
|
|
|
|
{BONUS_GRAB + 3, BONUS_GRAB_TICS, NULL, &s_BonusGrab[5]},
|
|
|
|
{BONUS_GRAB + 4, BONUS_GRAB_TICS, NULL, &s_BonusGrab[6]},
|
|
|
|
{BONUS_GRAB + 5, BONUS_GRAB_TICS, NULL, &s_BonusGrab[7]},
|
|
|
|
{BONUS_GRAB + 6, BONUS_GRAB_TICS, NULL, &s_BonusGrab[8]},
|
|
|
|
{BONUS_GRAB + 7, BONUS_GRAB_TICS, NULL, &s_BonusGrab[9]},
|
|
|
|
{BONUS_GRAB + 8, BONUS_GRAB_TICS, NULL, &s_BonusGrab[10]},
|
|
|
|
{BONUS_GRAB + 9, 90, NULL, &s_BonusGrab[11]},
|
|
|
|
{BONUS_GRAB + 9, BONUS_GRAB_TICS, NULL, &s_BonusGrab[11]},
|
|
|
|
};
|
|
|
|
|
|
|
|
#if 1 // Turned off the standing animate because he looks like a FAG!
|
|
|
|
static STATE s_BonusRest[] =
|
|
|
|
{
|
|
|
|
{BONUS_REST + 0, BONUS_REST_TICS, NULL, &s_BonusRest[1]},
|
|
|
|
{BONUS_REST + 1, BONUS_REST_TICS, NULL, &s_BonusRest[2]},
|
|
|
|
{BONUS_REST + 2, BONUS_REST_TICS, NULL, &s_BonusRest[3]},
|
|
|
|
{BONUS_REST + 1, BONUS_REST_TICS, NULL, &s_BonusRest[0]},
|
|
|
|
};
|
|
|
|
#else
|
|
|
|
static STATE s_BonusRest[] =
|
|
|
|
{
|
|
|
|
{BONUS_REST + 0, BONUS_REST_TICS, NULL, &s_BonusRest[1]},
|
|
|
|
{BONUS_REST + 0, BONUS_REST_TICS, NULL, &s_BonusRest[0]},
|
|
|
|
};
|
|
|
|
#endif
|
|
|
|
|
|
|
|
static STATEp s_BonusAnim[] =
|
|
|
|
{
|
|
|
|
s_BonusPunch,
|
|
|
|
s_BonusKick,
|
|
|
|
s_BonusGrab
|
|
|
|
};
|
|
|
|
|
|
|
|
STATEp State = s_BonusRest;
|
|
|
|
|
|
|
|
int Tics = 0;
|
|
|
|
int line = 0;
|
2015-05-19 21:58:29 +00:00
|
|
|
SWBOOL BonusDone;
|
2015-05-19 21:54:34 +00:00
|
|
|
|
|
|
|
if (Level < 0) Level = 0;
|
|
|
|
|
2019-04-08 06:26:36 +00:00
|
|
|
videoClearViewableArea(0L);
|
|
|
|
videoNextPage();
|
2015-05-19 21:54:34 +00:00
|
|
|
|
2019-11-03 23:53:55 +00:00
|
|
|
inputState.ClearKeysDown();
|
2015-05-19 21:54:34 +00:00
|
|
|
|
|
|
|
totalclock = ototalclock = 0;
|
|
|
|
limit = synctics;
|
|
|
|
|
2019-10-28 21:19:50 +00:00
|
|
|
if (MusicEnabled())
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
|
|
|
PlaySong(voc[DIGI_ENDLEV].name, 3, TRUE, TRUE);
|
|
|
|
}
|
|
|
|
|
|
|
|
// special case code because I don't care any more!
|
|
|
|
if (FinishAnim)
|
|
|
|
{
|
2019-04-08 06:26:36 +00:00
|
|
|
renderFlushPerms();
|
2015-05-19 21:54:34 +00:00
|
|
|
rotatesprite(0, 0, RS_SCALE, 0, 5120, 0, 0, TITLE_ROT_FLAGS, 0, 0, xdim - 1, ydim - 1);
|
|
|
|
rotatesprite(158<<16, 86<<16, RS_SCALE, 0, State->Pic, 0, 0, TITLE_ROT_FLAGS, 0, 0, xdim - 1, ydim - 1);
|
2019-04-08 06:26:36 +00:00
|
|
|
videoNextPage();
|
2015-05-19 21:54:34 +00:00
|
|
|
FadeIn(0,0);
|
|
|
|
}
|
|
|
|
|
|
|
|
BonusDone = FALSE;
|
|
|
|
while (!BonusDone)
|
|
|
|
{
|
|
|
|
handleevents();
|
|
|
|
|
|
|
|
// taken from top of faketimerhandler
|
|
|
|
if (totalclock < ototalclock + limit)
|
|
|
|
{
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
ototalclock += limit;
|
|
|
|
|
2019-11-06 18:22:14 +00:00
|
|
|
if (I_GeneralTrigger())
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
2019-11-06 18:22:14 +00:00
|
|
|
I_GeneralTriggerClear();
|
2015-05-19 21:54:34 +00:00
|
|
|
if (State >= s_BonusRest && State < &s_BonusRest[SIZ(s_BonusRest)])
|
|
|
|
{
|
|
|
|
State = s_BonusAnim[STD_RANDOM_RANGE(SIZ(s_BonusAnim))];
|
|
|
|
Tics = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
gStateControl(&State, &Tics);
|
2019-11-26 08:25:03 +00:00
|
|
|
|
|
|
|
videoClearViewableArea(0L);
|
|
|
|
|
2015-05-19 21:54:34 +00:00
|
|
|
rotatesprite(0, 0, RS_SCALE, 0, 5120, 0, 0, TITLE_ROT_FLAGS, 0, 0, xdim - 1, ydim - 1);
|
|
|
|
|
|
|
|
if (UserMapName[0])
|
|
|
|
{
|
|
|
|
sprintf(ds,"%s",UserMapName);
|
|
|
|
MNU_MeasureString(ds, &w, &h);
|
|
|
|
MNU_DrawString(TEXT_TEST_COL(w), 20, ds,1,19);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (PlayingLevel <= 1)
|
|
|
|
PlayingLevel = 1;
|
|
|
|
sprintf(ds,"%s",LevelInfo[PlayingLevel].Description);
|
|
|
|
MNU_MeasureString(ds, &w, &h);
|
|
|
|
MNU_DrawString(TEXT_TEST_COL(w), 20, ds,1,19);
|
|
|
|
}
|
|
|
|
|
|
|
|
sprintf(ds,"Completed");
|
|
|
|
MNU_MeasureString(ds, &w, &h);
|
|
|
|
MNU_DrawString(TEXT_TEST_COL(w), 30, ds,1,19);
|
|
|
|
|
|
|
|
rotatesprite(158<<16, 86<<16, RS_SCALE, 0, State->Pic, 0, 0, TITLE_ROT_FLAGS, 0, 0, xdim - 1, ydim - 1);
|
|
|
|
|
|
|
|
#define BONUS_LINE(i) (50 + ((i)*20))
|
|
|
|
|
|
|
|
line = 0;
|
|
|
|
second_tics = (PlayClock/120);
|
|
|
|
minutes = (second_tics/60);
|
|
|
|
seconds = (second_tics%60);
|
|
|
|
sprintf(ds,"Your Time: %2d : %02d", minutes, seconds);
|
|
|
|
MNU_MeasureString(ds, &w, &h);
|
|
|
|
MNU_DrawString(60, BONUS_LINE(line), ds,1,16);
|
|
|
|
|
|
|
|
if (!UserMapName[0])
|
|
|
|
{
|
|
|
|
line++;
|
|
|
|
sprintf(ds,"3D Realms Best Time: %s", LevelInfo[PlayingLevel].BestTime);
|
|
|
|
MNU_MeasureString(ds, &w, &h);
|
|
|
|
MNU_DrawString(40, BONUS_LINE(line), ds,1,16);
|
|
|
|
|
|
|
|
line++;
|
|
|
|
sprintf(ds,"Par Time: %s", LevelInfo[PlayingLevel].ParTime);
|
|
|
|
MNU_MeasureString(ds, &w, &h);
|
|
|
|
MNU_DrawString(40, BONUS_LINE(line), ds,1,16);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// always read secrets and kills from the first player
|
|
|
|
line++;
|
|
|
|
sprintf(ds,"Secrets: %d / %d", Player->SecretsFound, LevelSecrets);
|
|
|
|
MNU_MeasureString(ds, &w, &h);
|
|
|
|
MNU_DrawString(60, BONUS_LINE(line), ds,1,16);
|
|
|
|
|
|
|
|
line++;
|
|
|
|
sprintf(ds,"Kills: %d / %d", Player->Kills, TotalKillable);
|
|
|
|
MNU_MeasureString(ds, &w, &h);
|
|
|
|
MNU_DrawString(60, BONUS_LINE(line), ds,1,16);
|
|
|
|
|
|
|
|
|
|
|
|
sprintf(ds,"Press SPACE to continue");
|
|
|
|
MNU_MeasureString(ds, &w, &h);
|
|
|
|
MNU_DrawString(TEXT_TEST_COL(w), 185, ds,1,19);
|
|
|
|
|
2019-04-08 06:26:36 +00:00
|
|
|
videoNextPage();
|
2015-05-19 21:54:34 +00:00
|
|
|
ScreenCaptureKeys();
|
|
|
|
|
|
|
|
if (State == State->NextState)
|
|
|
|
BonusDone = TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
StopSound();
|
|
|
|
Terminate3DSounds();
|
|
|
|
}
|
|
|
|
|
2015-05-19 21:58:29 +00:00
|
|
|
void EndGameSequence(void)
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
2015-05-19 21:58:29 +00:00
|
|
|
SWBOOL anim_ok = TRUE;
|
2015-05-19 21:54:34 +00:00
|
|
|
FadeOut(0, 5);
|
|
|
|
|
2019-10-27 12:40:24 +00:00
|
|
|
if ((adult_lockout || Global_PLock) && FinishAnim == ANIM_SUMO)
|
2015-05-19 21:54:34 +00:00
|
|
|
anim_ok = FALSE;
|
|
|
|
|
|
|
|
if (anim_ok)
|
|
|
|
playanm(FinishAnim);
|
|
|
|
|
|
|
|
BonusScreen(Player + myconnectindex);
|
|
|
|
|
|
|
|
ExitLevel = FALSE;
|
|
|
|
QuitFlag = FALSE;
|
|
|
|
AutoNet = FALSE;
|
|
|
|
|
|
|
|
if (FinishAnim == ANIM_ZILLA)
|
|
|
|
CreditsLevel();
|
|
|
|
|
|
|
|
ExitLevel = FALSE;
|
|
|
|
QuitFlag = FALSE;
|
|
|
|
AutoNet = FALSE;
|
|
|
|
|
|
|
|
if (SW_SHAREWARE)
|
|
|
|
{
|
|
|
|
Level = 0;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (Level == 4 || Level == 20)
|
|
|
|
{
|
|
|
|
Level=0;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
Level++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-11-17 17:02:17 +00:00
|
|
|
void StatScreen(PLAYERp mpp)
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
|
|
|
int minutes,seconds,second_tics;
|
2015-05-19 21:58:29 +00:00
|
|
|
extern SWBOOL FinishedLevel;
|
2015-05-19 21:54:34 +00:00
|
|
|
extern int PlayClock;
|
|
|
|
extern short LevelSecrets;
|
|
|
|
extern short TotalKillable;
|
|
|
|
short w,h;
|
|
|
|
int zero=0;
|
|
|
|
int handle=0;
|
|
|
|
|
|
|
|
short rows,cols,i,j;
|
|
|
|
PLAYERp pp = NULL;
|
|
|
|
int x,y;
|
|
|
|
short death_total[MAX_SW_PLAYERS_REG];
|
|
|
|
short kills[MAX_SW_PLAYERS_REG];
|
|
|
|
short pal;
|
|
|
|
|
|
|
|
#define STAT_START_X 20
|
|
|
|
#define STAT_START_Y 85
|
|
|
|
#define STAT_OFF_Y 9
|
|
|
|
#define STAT_HEADER_Y 14
|
|
|
|
|
|
|
|
#define SM_SIZ(num) ((num)*4)
|
|
|
|
|
|
|
|
#define STAT_TABLE_X (STAT_START_X + SM_SIZ(15))
|
|
|
|
#define STAT_TABLE_XOFF SM_SIZ(6)
|
|
|
|
|
|
|
|
// No stats in bot games
|
|
|
|
//if (BotMode) return;
|
|
|
|
|
|
|
|
ResetPalette(mpp);
|
|
|
|
COVER_SetReverb(0); // Reset reverb
|
|
|
|
StopSound();
|
|
|
|
|
|
|
|
if (FinishAnim)
|
|
|
|
{
|
|
|
|
EndGameSequence();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (gNet.MultiGameType != MULTI_GAME_COMMBAT)
|
|
|
|
{
|
|
|
|
if (!FinishedLevel)
|
|
|
|
return;
|
|
|
|
BonusScreen(mpp);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2019-04-08 06:26:36 +00:00
|
|
|
renderFlushPerms();
|
2015-05-19 21:54:34 +00:00
|
|
|
DrawStatScreen();
|
|
|
|
|
|
|
|
memset(death_total,0,sizeof(death_total));
|
|
|
|
memset(kills,0,sizeof(kills));
|
|
|
|
|
|
|
|
sprintf(ds,"MULTIPLAYER TOTALS");
|
|
|
|
MNU_MeasureString(ds, &w, &h);
|
|
|
|
MNU_DrawString(TEXT_TEST_COL(w), 68, ds, 0, 0);
|
|
|
|
|
|
|
|
sprintf(ds,"PRESS SPACE BAR TO CONTINUE");
|
|
|
|
MNU_MeasureString(ds, &w, &h);
|
|
|
|
MNU_DrawString(TEXT_TEST_COL(w), 189, ds, 0, 0);
|
|
|
|
|
|
|
|
x = STAT_START_X;
|
|
|
|
y = STAT_START_Y;
|
|
|
|
|
|
|
|
sprintf(ds," NAME 1 2 3 4 5 6 7 8 KILLS");
|
|
|
|
DisplayMiniBarSmString(mpp, x, y, 0, ds);
|
|
|
|
rows = OrigCommPlayers;
|
|
|
|
cols = OrigCommPlayers;
|
|
|
|
mpp = Player + myconnectindex;
|
|
|
|
|
|
|
|
y += STAT_HEADER_Y;
|
|
|
|
|
|
|
|
for (i = 0; i < rows; i++)
|
|
|
|
{
|
|
|
|
x = STAT_START_X;
|
|
|
|
pp = Player + i;
|
|
|
|
|
|
|
|
sprintf(ds,"%d", i+1);
|
|
|
|
DisplayMiniBarSmString(mpp, x, y, 0, ds);
|
|
|
|
|
|
|
|
sprintf(ds," %-13s", pp->PlayerName);
|
|
|
|
DisplayMiniBarSmString(mpp, x, y, User[pp->PlayerSprite]->spal, ds);
|
|
|
|
|
|
|
|
x = STAT_TABLE_X;
|
|
|
|
for (j = 0; j < cols; j++)
|
|
|
|
{
|
|
|
|
pal = 0;
|
|
|
|
death_total[j] += pp->KilledPlayer[j];
|
|
|
|
|
|
|
|
if (i == j)
|
|
|
|
{
|
|
|
|
// don't add kill for self or team player
|
|
|
|
pal = PALETTE_PLAYER0 + 4;
|
|
|
|
kills[i] -= pp->KilledPlayer[j]; // subtract self kills
|
|
|
|
}
|
|
|
|
else if (gNet.TeamPlay)
|
|
|
|
{
|
|
|
|
if (User[pp->PlayerSprite]->spal == User[Player[j].PlayerSprite]->spal)
|
|
|
|
{
|
|
|
|
// don't add kill for self or team player
|
|
|
|
pal = PALETTE_PLAYER0 + 4;
|
|
|
|
kills[i] -= pp->KilledPlayer[j]; // subtract self kills
|
|
|
|
}
|
|
|
|
else
|
|
|
|
kills[i] += pp->KilledPlayer[j]; // kills added here
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
kills[i] += pp->KilledPlayer[j]; // kills added here
|
|
|
|
}
|
|
|
|
|
|
|
|
sprintf(ds,"%d", pp->KilledPlayer[j]);
|
|
|
|
DisplayMiniBarSmString(mpp, x, y, pal, ds);
|
|
|
|
x += STAT_TABLE_XOFF;
|
|
|
|
}
|
|
|
|
|
|
|
|
y += STAT_OFF_Y;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// Deaths
|
|
|
|
|
|
|
|
x = STAT_START_X;
|
|
|
|
y += STAT_OFF_Y;
|
|
|
|
|
|
|
|
sprintf(ds," DEATHS");
|
|
|
|
DisplayMiniBarSmString(mpp, x, y, 0, ds);
|
|
|
|
x = STAT_TABLE_X;
|
|
|
|
|
|
|
|
for (j = 0; j < cols; j++)
|
|
|
|
{
|
|
|
|
sprintf(ds,"%d",death_total[j]);
|
|
|
|
DisplayMiniBarSmString(mpp, x, y, 0, ds);
|
|
|
|
x += STAT_TABLE_XOFF;
|
|
|
|
}
|
|
|
|
|
|
|
|
x = STAT_START_X;
|
|
|
|
y += STAT_OFF_Y;
|
|
|
|
|
|
|
|
// Kills
|
|
|
|
x = STAT_TABLE_X + SM_SIZ(50);
|
|
|
|
y = STAT_START_Y + STAT_HEADER_Y;
|
|
|
|
|
|
|
|
for (i = 0; i < rows; i++)
|
|
|
|
{
|
|
|
|
pp = Player + i;
|
|
|
|
|
|
|
|
sprintf(ds,"%d", kills[i]); //pp->Kills);
|
|
|
|
DisplayMiniBarSmString(mpp, x, y, 0, ds);
|
|
|
|
|
|
|
|
y += STAT_OFF_Y;
|
|
|
|
}
|
|
|
|
|
2019-04-08 06:26:36 +00:00
|
|
|
videoNextPage();
|
2015-05-19 21:54:34 +00:00
|
|
|
|
|
|
|
if (KeyPressed())
|
|
|
|
{
|
|
|
|
while (KeyPressed()) ;
|
|
|
|
}
|
|
|
|
|
2019-10-28 05:47:49 +00:00
|
|
|
inputState.ClearKeyStatus(KEYSC_SPACE);
|
|
|
|
inputState.ClearKeyStatus(KEYSC_ENTER);
|
2015-05-19 21:54:34 +00:00
|
|
|
|
2019-10-28 21:19:50 +00:00
|
|
|
if (MusicEnabled())
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
|
|
|
PlaySong(voc[DIGI_ENDLEV].name, 3, TRUE, TRUE);
|
|
|
|
}
|
|
|
|
|
2019-11-03 23:53:55 +00:00
|
|
|
while (!inputState.GetKeyStatus(KEYSC_SPACE) && !inputState.GetKeyStatus(KEYSC_ENTER))
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
|
|
|
handleevents();
|
|
|
|
|
|
|
|
ScreenCaptureKeys();
|
|
|
|
}
|
|
|
|
|
|
|
|
StopSound();
|
|
|
|
Terminate3DSounds();
|
|
|
|
}
|
|
|
|
|
2019-11-17 17:02:17 +00:00
|
|
|
void GameIntro(void)
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
|
|
|
|
|
|
|
DSPRINTF(ds,"GameIntro...");
|
|
|
|
MONO_PRINT(ds);
|
|
|
|
|
|
|
|
if (DemoPlaying)
|
|
|
|
return;
|
|
|
|
|
|
|
|
// this could probably be taken out and you could select skill level
|
|
|
|
// from menu to start the game
|
|
|
|
if (!CommEnabled && UserMapName[0])
|
|
|
|
return;
|
|
|
|
|
|
|
|
Level = 1;
|
|
|
|
|
|
|
|
|
|
|
|
|
2019-10-30 05:51:53 +00:00
|
|
|
PlayTheme();
|
2015-05-19 21:54:34 +00:00
|
|
|
|
|
|
|
if (!AutoNet)
|
|
|
|
{
|
|
|
|
LogoLevel();
|
|
|
|
//CreditsLevel();
|
|
|
|
//SceneLevel();
|
|
|
|
//TitleLevel();
|
|
|
|
IntroAnimLevel();
|
|
|
|
IntroAnimCount = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
MenuLevel();
|
|
|
|
}
|
|
|
|
|
2019-11-17 17:02:17 +00:00
|
|
|
void Control()
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
2019-10-31 23:32:56 +00:00
|
|
|
InitGame();
|
2015-05-19 21:54:34 +00:00
|
|
|
|
|
|
|
MONO_PRINT("InitGame done");
|
|
|
|
MNU_InitMenus();
|
|
|
|
InGame = TRUE;
|
|
|
|
GameIntro();
|
|
|
|
|
|
|
|
while (!QuitFlag)
|
|
|
|
{
|
|
|
|
handleevents();
|
|
|
|
OSD_DispatchQueued();
|
|
|
|
|
|
|
|
if (quitevent) QuitFlag = TRUE;
|
|
|
|
|
|
|
|
NewLevel();
|
|
|
|
}
|
|
|
|
|
|
|
|
CleanExit = TRUE;
|
|
|
|
TerminateGame();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2019-11-17 17:02:17 +00:00
|
|
|
void _Assert(const char *expr, const char *strFile, unsigned uLine)
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
2019-11-30 06:10:16 +00:00
|
|
|
buildprintf(ds, "Assertion failed: %s %s, line %u", expr, strFile, uLine);
|
|
|
|
debug_break();
|
|
|
|
|
2015-05-19 21:54:34 +00:00
|
|
|
TerminateGame();
|
2019-11-30 06:10:16 +00:00
|
|
|
|
2015-05-19 21:54:34 +00:00
|
|
|
#if 1 //def RENDERTYPEWIN
|
2019-04-10 01:00:15 +00:00
|
|
|
wm_msgbox(apptitle, "%s", ds);
|
2015-05-19 21:54:34 +00:00
|
|
|
#else
|
|
|
|
printf("Assertion failed: %s\n %s, line %u\n", expr, strFile, uLine);
|
|
|
|
#endif
|
|
|
|
exit(0);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2019-11-17 17:02:17 +00:00
|
|
|
void _ErrMsg(const char *strFile, unsigned uLine, const char *format, ...)
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
|
|
|
va_list arglist;
|
|
|
|
|
|
|
|
//DSPRINTF(ds, "Error: %s, line %u", strFile, uLine);
|
|
|
|
//MONO_PRINT(ds);
|
|
|
|
TerminateGame();
|
|
|
|
|
|
|
|
#if 1 //def RENDERTYPEWIN
|
|
|
|
{
|
|
|
|
char msg[256], *p;
|
|
|
|
Bsnprintf(msg, sizeof(msg), "Error: %s, line %u\n", strFile, uLine);
|
|
|
|
p = &msg[strlen(msg)];
|
|
|
|
va_start(arglist, format);
|
|
|
|
Bvsnprintf(msg, sizeof(msg) - (p-msg), format, arglist);
|
|
|
|
va_end(arglist);
|
2019-04-10 01:00:15 +00:00
|
|
|
wm_msgbox(apptitle, "%s", msg);
|
2015-05-19 21:54:34 +00:00
|
|
|
}
|
|
|
|
#else
|
|
|
|
printf("Error: %s, line %u\n", strFile, uLine);
|
|
|
|
|
|
|
|
va_start(arglist, format);
|
|
|
|
vprintf(format, arglist);
|
|
|
|
va_end(arglist);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
exit(0);
|
|
|
|
}
|
|
|
|
|
2019-11-17 17:02:17 +00:00
|
|
|
void dsprintf(char *str, const char *format, ...)
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
|
|
|
va_list arglist;
|
|
|
|
|
|
|
|
va_start(arglist, format);
|
|
|
|
vsprintf(str, format, arglist);
|
|
|
|
va_end(arglist);
|
|
|
|
}
|
|
|
|
|
2019-11-17 17:02:17 +00:00
|
|
|
void dsprintf_null(char *str, const char *format, ...)
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
|
|
|
va_list arglist;
|
|
|
|
}
|
|
|
|
|
|
|
|
void MoveLoop(void)
|
|
|
|
{
|
|
|
|
int pnum;
|
|
|
|
|
|
|
|
getpackets();
|
|
|
|
|
|
|
|
if (PredictionOn && CommEnabled)
|
|
|
|
{
|
|
|
|
while (predictmovefifoplc < Player[myconnectindex].movefifoend)
|
|
|
|
{
|
|
|
|
DoPrediction(ppp);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//While you have new input packets to process...
|
|
|
|
if (!CommEnabled)
|
|
|
|
bufferjitter = 0;
|
|
|
|
|
|
|
|
while (Player[myconnectindex].movefifoend - movefifoplc > bufferjitter)
|
|
|
|
{
|
|
|
|
//Make sure you have at least 1 packet from everyone else
|
|
|
|
for (pnum=connecthead; pnum>=0; pnum=connectpoint2[pnum])
|
|
|
|
{
|
|
|
|
if (movefifoplc == Player[pnum].movefifoend)
|
|
|
|
{
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//Pnum is >= 0 only if last loop was broken, meaning a player wasn't caught up
|
|
|
|
if (pnum >= 0)
|
|
|
|
break;
|
|
|
|
|
|
|
|
domovethings();
|
|
|
|
|
|
|
|
#if DEBUG
|
|
|
|
//if (DemoSyncRecord)
|
|
|
|
// demosync_record();
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!InputMode && !PauseKeySet)
|
|
|
|
MNU_CheckForMenus();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void InitPlayerGameSettings(void)
|
|
|
|
{
|
|
|
|
int pnum;
|
|
|
|
|
|
|
|
// don't jack with auto aim settings if DemoMode is going
|
|
|
|
// what the hell did I do this for?????????
|
|
|
|
//if (DemoMode)
|
|
|
|
// return;
|
|
|
|
|
|
|
|
if (CommEnabled)
|
|
|
|
{
|
|
|
|
// everyone gets the same Auto Aim
|
|
|
|
TRAVERSE_CONNECT(pnum)
|
|
|
|
{
|
|
|
|
if (gNet.AutoAim)
|
|
|
|
SET(Player[pnum].Flags, PF_AUTO_AIM);
|
|
|
|
else
|
|
|
|
RESET(Player[pnum].Flags, PF_AUTO_AIM);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2019-10-21 22:05:21 +00:00
|
|
|
if (cl_autoaim)
|
2015-05-19 21:54:34 +00:00
|
|
|
SET(Player[myconnectindex].Flags, PF_AUTO_AIM);
|
|
|
|
else
|
|
|
|
RESET(Player[myconnectindex].Flags, PF_AUTO_AIM);
|
|
|
|
}
|
|
|
|
|
2019-10-27 15:53:00 +00:00
|
|
|
g_MyAimMode = in_aimmode;
|
2015-05-19 21:54:34 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2015-05-19 21:58:29 +00:00
|
|
|
void InitRunLevel(void)
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
if (DemoEdit)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (LoadGameOutsideMoveLoop)
|
|
|
|
{
|
|
|
|
int SavePlayClock;
|
|
|
|
extern int PlayClock;
|
|
|
|
LoadGameOutsideMoveLoop = FALSE;
|
|
|
|
// contains what is needed from calls below
|
2019-10-22 00:01:05 +00:00
|
|
|
if (snd_ambience)
|
2015-05-19 21:54:34 +00:00
|
|
|
StartAmbientSound();
|
|
|
|
SetCrosshair();
|
|
|
|
PlaySong(LevelSong, -1, TRUE, TRUE);
|
|
|
|
SetRedrawScreen(Player + myconnectindex);
|
|
|
|
// crappy little hack to prevent play clock from being overwritten
|
|
|
|
// for load games
|
|
|
|
SavePlayClock = PlayClock;
|
|
|
|
InitTimingVars();
|
|
|
|
PlayClock = SavePlayClock;
|
|
|
|
MONO_PRINT("Done with InitRunLevel");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
#if 0
|
|
|
|
// ensure we are through the initialization code before sending the game
|
|
|
|
// version. Otherwise, it is possible to send this too early and have it
|
|
|
|
// blown away on the other side.
|
|
|
|
waitforeverybody();
|
|
|
|
#endif
|
|
|
|
|
|
|
|
SendVersion(GameVersion);
|
|
|
|
|
|
|
|
waitforeverybody();
|
|
|
|
|
|
|
|
StopSong();
|
|
|
|
|
|
|
|
if (Bstrcasecmp(CacheLastLevel, LevelName) != 0)
|
|
|
|
DoTheCache();
|
|
|
|
|
|
|
|
// auto aim / auto run / etc
|
|
|
|
InitPlayerGameSettings();
|
|
|
|
|
|
|
|
// send packets with player info
|
|
|
|
InitNetPlayerOptions();
|
|
|
|
|
|
|
|
// Initialize Game part of network code (When ready2send != 0)
|
|
|
|
InitNetVars();
|
|
|
|
|
|
|
|
{
|
|
|
|
int track;
|
|
|
|
if (Level == 0)
|
|
|
|
{
|
|
|
|
track = RedBookSong[4+RANDOM_RANGE(10)];
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
track = RedBookSong[Level];
|
|
|
|
}
|
|
|
|
PlaySong(LevelSong, track, TRUE, TRUE);
|
|
|
|
}
|
|
|
|
|
|
|
|
InitPrediction(&Player[myconnectindex]);
|
|
|
|
|
|
|
|
if (!DemoInitOnce)
|
|
|
|
DemoRecordSetup();
|
|
|
|
|
|
|
|
// everything has been inited at least once for RECORD
|
|
|
|
DemoInitOnce = TRUE;
|
|
|
|
|
|
|
|
//DebugWriteLoc(__FILE__, __LINE__);
|
|
|
|
waitforeverybody();
|
|
|
|
|
|
|
|
CheckVersion(GameVersion);
|
|
|
|
|
|
|
|
// IMPORTANT - MUST be right before game loop AFTER waitforeverybody
|
|
|
|
InitTimingVars();
|
|
|
|
|
|
|
|
SetRedrawScreen(Player + myconnectindex);
|
2019-10-22 00:01:05 +00:00
|
|
|
|
|
|
|
snd_reversestereo.Callback();
|
|
|
|
snd_fxvolume.Callback();
|
2019-10-27 15:53:00 +00:00
|
|
|
FX_SetVolume(snd_fxvolume); // Turn volume back up
|
2019-10-22 00:01:05 +00:00
|
|
|
if (snd_ambience)
|
2015-05-19 21:54:34 +00:00
|
|
|
StartAmbientSound();
|
|
|
|
}
|
|
|
|
|
2019-11-20 18:33:36 +00:00
|
|
|
void faketimerhandler();
|
|
|
|
|
2019-11-17 17:02:17 +00:00
|
|
|
void RunLevel(void)
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
InitRunLevel();
|
|
|
|
|
2019-10-27 15:53:00 +00:00
|
|
|
FX_SetVolume(snd_fxvolume);
|
2019-10-22 00:01:05 +00:00
|
|
|
SetSongVolume(mus_volume);
|
2015-05-19 21:54:34 +00:00
|
|
|
|
|
|
|
#if 0
|
|
|
|
waitforeverybody();
|
|
|
|
#endif
|
|
|
|
ready2send = 1;
|
|
|
|
|
|
|
|
while (TRUE)
|
|
|
|
{
|
|
|
|
handleevents();
|
|
|
|
OSD_DispatchQueued();
|
2019-11-20 21:01:44 +00:00
|
|
|
D_ProcessEvents();
|
2019-11-20 18:33:36 +00:00
|
|
|
faketimerhandler();
|
2015-05-19 21:54:34 +00:00
|
|
|
|
|
|
|
if (quitevent) QuitFlag = TRUE;
|
|
|
|
|
|
|
|
MoveLoop();
|
2019-11-20 21:01:44 +00:00
|
|
|
|
|
|
|
|
2015-05-19 21:54:34 +00:00
|
|
|
drawscreen(Player + screenpeek);
|
|
|
|
|
|
|
|
if (QuitFlag)
|
|
|
|
break;
|
|
|
|
|
|
|
|
if (ExitLevel)
|
|
|
|
{
|
|
|
|
ExitLevel = FALSE;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
ready2send = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
void swexit(int exitval)
|
|
|
|
{
|
|
|
|
exit(exitval);
|
|
|
|
}
|
|
|
|
|
2015-05-19 21:58:29 +00:00
|
|
|
void DosScreen(void)
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
typedef struct
|
|
|
|
{
|
|
|
|
char notshareware;
|
2019-04-08 06:25:22 +00:00
|
|
|
const char *arg_switch;
|
2015-05-19 21:54:34 +00:00
|
|
|
short arg_match_len;
|
2019-04-08 06:25:22 +00:00
|
|
|
const char *arg_fmt;
|
|
|
|
const char *arg_descr;
|
2015-05-19 21:54:34 +00:00
|
|
|
} CLI_ARG;
|
|
|
|
|
|
|
|
#if DEBUG
|
|
|
|
CLI_ARG cli_dbg_arg[] =
|
|
|
|
{
|
|
|
|
{0, "/demosyncrecord", 13, "-demosyncrecord", "Demo sync record" },
|
|
|
|
{0, "/demosynctest", 13, "-demosynctest", "Demo sync test" },
|
|
|
|
{0, "/cam", 4, "-cam", "Camera test mode" },
|
|
|
|
{0, "/debugactor", 11, "-debugactor", "No Actors" },
|
|
|
|
{0, "/debuganim", 10, "-debuganim", "No Anims" },
|
|
|
|
{0, "/debugso", 8, "-debugso", "No Sector Objects" },
|
|
|
|
{0, "/debugsector", 12, "-debugsector", "No Sector Movement" },
|
|
|
|
{0, "/debugpanel", 11, "-debugpanel", "No Panel" },
|
|
|
|
{0, "/mono", 5, "-mono", "Mono" },
|
|
|
|
};
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
|
|
CLI_ARG cli_arg[] =
|
|
|
|
{
|
|
|
|
{0, "/?", 2, "-?", "This help message" },
|
|
|
|
//#ifndef SW_SHAREWARE
|
|
|
|
//{"/l", 2, "-l#", "Level (1-11)" },
|
|
|
|
//{"/v", 2, "-v#", "Volume (1-3)" },
|
|
|
|
{1, "/map", 4, "-map [mapname]", "Load a map" },
|
|
|
|
{1, "/nocdaudio", 5, "-nocd<audio>", "No CD Red Book Audio" },
|
|
|
|
//#endif
|
|
|
|
|
|
|
|
{0, "/name", 5, "-name [playername]", "Player Name" },
|
|
|
|
{0, "/s", 2, "-s#", "Skill (1-4)" },
|
|
|
|
{0, "/f#", 3, "-f#", "Packet Duplication - 2, 4, 8" },
|
|
|
|
{0, "/nopredict", 7, "-nopred<ict>", "Disable Net Prediction Method" },
|
|
|
|
{0, "/level#", 5, "-level#", "Start at level# (Shareware: 1-4, full version 1-28)" },
|
|
|
|
{0, "/dr", 3, "-dr[filename.dmo]", "Demo record. NOTE: Must use -level# with this option." },
|
|
|
|
{0, "/dp", 3, "-dp[filename.dmo]", "Demo playback. NOTE: Must use -level# with this option." },
|
|
|
|
{0, "/m", 6, "-monst<ers>", "No Monsters" },
|
|
|
|
{0, "/nodemo", 6, "-nodemo", "No demos on game startup" },
|
|
|
|
{0, "/nometers", 9, "-nometers", "Don't show air or boss meter bars in game"},
|
|
|
|
{0, "/movescale #", 9, "-movescale", "Adjust movement scale: 256 = 1 unit"},
|
|
|
|
{0, "/turnscale #", 9, "-turnscale", "Adjust turning scale: 256 = 1 unit"},
|
|
|
|
{0, "/extcompat", 9, "-extcompat", "Controller compatibility mode (with Duke 3D)"},
|
|
|
|
{1, "/g#", 2, "-g[filename.grp]", "Load an extra GRP or ZIP file"},
|
|
|
|
{1, "/h#", 2, "-h[filename.def]", "Use filename.def instead of SW.DEF"},
|
|
|
|
{0, "/setup", 5, "-setup", "Displays the configuration dialogue box"},
|
|
|
|
#if DEBUG
|
|
|
|
{0, "/coop", 5, "-coop#", "Single Player Cooperative Mode" },
|
|
|
|
{0, "/commbat", 8, "-commbat#", "Single Player Commbat Mode" },
|
|
|
|
{0, "/debug", 6, "-debug", "Debug Help Options" },
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if 0 //def NET_MODE_MASTER_SLAVE
|
|
|
|
{0, "/broadcast", 6, "-broad<cast>", "Broadcast network method (default)" },
|
|
|
|
{0, "/masterslave", 7, "-master<slave>", "Master/Slave network method" },
|
|
|
|
#endif
|
|
|
|
};
|
|
|
|
|
|
|
|
#if 0
|
2019-11-17 17:02:17 +00:00
|
|
|
Map -> User Map Name
|
|
|
|
Auto -> Auto Start Game
|
|
|
|
Rules -> 0=WangBang 1=WangBang (No Respawn) 2=CoOperative
|
|
|
|
Level -> 0 to 24(?)
|
|
|
|
Enemy -> 0=None 1=Easy 2=Norm 3=Hard 4=Insane
|
|
|
|
Markers -> 0=Off 1=On
|
|
|
|
Team -> 0=Off 1=On
|
|
|
|
HurtTeam -> 0=Off 1=On
|
|
|
|
KillLimit -> 0=Infinite 1=10 2=20 3=30 4=40 5=50 6=60 7=70 8=80 9=90 10=100
|
|
|
|
TimeLimit -> 0=Infinite 1=3 2=5 3=10 4=20 5=30 6=45 7=60
|
|
|
|
Color -> 0=Brown 1=Purple 2=Red 3=Yellow 4=Olive 5=Green
|
|
|
|
Nuke -> 0=Off 1=On
|
2015-05-19 21:54:34 +00:00
|
|
|
|
|
|
|
Example Command Line :
|
|
|
|
sw -map testmap.map -autonet 0,0,1,1,1,0,3,2,1,1 -f4 -name 1234567890 -net 12345678
|
|
|
|
commit -map grenade -autonet 0,0,1,1,1,0,3,2,1,1 -name frank
|
|
|
|
#endif
|
|
|
|
|
|
|
|
char isShareware = FALSE, useDarts = FALSE;
|
|
|
|
|
|
|
|
int DetectShareware(void)
|
|
|
|
{
|
|
|
|
#define DOS_SCREEN_NAME_SW "SHADSW.BIN"
|
|
|
|
#define DOS_SCREEN_NAME_REG "SWREG.BIN"
|
|
|
|
|
|
|
|
int h;
|
|
|
|
|
2019-10-20 18:08:17 +00:00
|
|
|
if (testkopen(DOS_SCREEN_NAME_SW, 1))
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
|
|
|
isShareware = TRUE;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2019-10-20 18:08:17 +00:00
|
|
|
if (testkopen(DOS_SCREEN_NAME_REG, 1))
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
|
|
|
isShareware = FALSE;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 1; // heavens knows what this is...
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2016-01-12 10:30:56 +00:00
|
|
|
void CommandLineHelp(char const * const * argv)
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2019-11-03 11:32:58 +00:00
|
|
|
int32_t GameInterface::app_main()
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
int stat, nexti;
|
|
|
|
char type;
|
|
|
|
extern int MovesPerPacket;
|
2015-05-19 21:58:29 +00:00
|
|
|
void DoSector(void);
|
|
|
|
void gameinput(void);
|
2015-05-19 21:54:34 +00:00
|
|
|
int cnt = 0;
|
2015-05-19 21:58:29 +00:00
|
|
|
uint32_t TotalMemory;
|
2015-05-19 21:54:34 +00:00
|
|
|
|
2019-10-30 05:51:44 +00:00
|
|
|
SW_ExtInit();
|
|
|
|
|
2019-11-01 08:30:28 +00:00
|
|
|
CONFIG_ReadSetup();
|
2015-05-19 21:54:34 +00:00
|
|
|
|
2019-04-08 06:26:36 +00:00
|
|
|
if (enginePreInit())
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
2019-11-01 07:24:10 +00:00
|
|
|
I_Error("There was a problem initialising the Build engine: %s", engineerrstr);
|
2015-05-19 21:54:34 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (!DetectShareware())
|
|
|
|
{
|
|
|
|
if (SW_SHAREWARE) buildputs("Detected shareware GRP\n");
|
|
|
|
else buildputs("Detected registered GRP\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
if (SW_SHAREWARE)
|
|
|
|
{
|
|
|
|
// Zero out the maps that aren't in shareware version
|
|
|
|
memset(&LevelInfo[MAX_LEVELS_SW+1], 0, sizeof(LEVEL_INFO)*(MAX_LEVELS_REG-MAX_LEVELS_SW));
|
|
|
|
GameVersion++;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0; i < MAX_SW_PLAYERS; i++)
|
|
|
|
INITLIST(&Player[i].PanelSpriteList);
|
|
|
|
|
|
|
|
DebugOperate = TRUE;
|
|
|
|
|
2019-11-29 07:53:31 +00:00
|
|
|
if (SW_SHAREWARE)
|
|
|
|
buildputs("SHADOW WARRIOR(tm) Version 1.2 (Shareware Version)\n");
|
|
|
|
else
|
|
|
|
buildputs("SHADOW WARRIOR(tm) Version 1.2\n");
|
2015-05-19 21:54:34 +00:00
|
|
|
|
2019-11-29 07:53:31 +00:00
|
|
|
buildputs("Copyright (c) 1997 3D Realms Entertainment\n");
|
2015-05-19 21:54:34 +00:00
|
|
|
|
|
|
|
UserMapName[0] = '\0';
|
|
|
|
|
2019-10-31 23:32:56 +00:00
|
|
|
Control();
|
2015-05-19 21:54:34 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2019-11-17 17:02:17 +00:00
|
|
|
void ManualPlayerInsert(PLAYERp pp)
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
|
|
|
PLAYERp npp = Player + numplayers;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
if (numplayers < MAX_SW_PLAYERS)
|
|
|
|
{
|
|
|
|
connectpoint2[numplayers - 1] = numplayers;
|
|
|
|
connectpoint2[numplayers] = -1;
|
|
|
|
|
|
|
|
npp->posx = pp->posx;
|
|
|
|
npp->posy = pp->posy;
|
|
|
|
npp->posz = pp->posz;
|
|
|
|
npp->pang = pp->pang;
|
|
|
|
npp->cursectnum = pp->cursectnum;
|
|
|
|
|
|
|
|
myconnectindex = numplayers;
|
|
|
|
screenpeek = numplayers;
|
|
|
|
|
|
|
|
sprintf(Player[myconnectindex].PlayerName,"PLAYER %d",myconnectindex+1);
|
|
|
|
|
|
|
|
Player[numplayers].movefifoend = Player[0].movefifoend;
|
|
|
|
|
|
|
|
// If IsAI = TRUE, new player will be a bot
|
|
|
|
Player[myconnectindex].IsAI = FALSE;
|
|
|
|
|
|
|
|
numplayers++;
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2019-11-17 17:02:17 +00:00
|
|
|
void BotPlayerInsert(PLAYERp pp)
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
|
|
|
PLAYERp npp = Player + numplayers;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
if (numplayers < MAX_SW_PLAYERS)
|
|
|
|
{
|
|
|
|
connectpoint2[numplayers - 1] = numplayers;
|
|
|
|
connectpoint2[numplayers] = -1;
|
|
|
|
|
|
|
|
npp->posx = pp->posx;
|
|
|
|
npp->posy = pp->posy;
|
|
|
|
npp->posz = pp->posz-Z(100);
|
|
|
|
npp->pang = pp->pang;
|
|
|
|
npp->cursectnum = pp->cursectnum;
|
|
|
|
|
|
|
|
//myconnectindex = numplayers;
|
|
|
|
//screenpeek = numplayers;
|
|
|
|
|
|
|
|
sprintf(Player[numplayers].PlayerName,"BOT %d",numplayers+1);
|
|
|
|
|
|
|
|
Player[numplayers].movefifoend = Player[0].movefifoend;
|
|
|
|
|
|
|
|
// If IsAI = TRUE, new player will be a bot
|
|
|
|
Player[numplayers].IsAI = TRUE;
|
|
|
|
|
|
|
|
numplayers++;
|
|
|
|
}
|
|
|
|
|
|
|
|
// SetFragBar(pp);
|
|
|
|
}
|
|
|
|
|
2019-11-17 17:02:17 +00:00
|
|
|
void ManualPlayerDelete(PLAYERp cur_pp)
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
|
|
|
short i, nexti;
|
|
|
|
USERp u;
|
|
|
|
short save_myconnectindex;
|
|
|
|
PLAYERp pp;
|
|
|
|
|
|
|
|
if (numplayers > 1)
|
|
|
|
{
|
|
|
|
numplayers--;
|
|
|
|
connectpoint2[numplayers - 1] = -1;
|
|
|
|
|
|
|
|
pp = Player + numplayers;
|
|
|
|
|
|
|
|
KillSprite(pp->PlayerSprite);
|
|
|
|
pp->PlayerSprite = -1;
|
|
|
|
|
|
|
|
// Make sure enemys "forget" about deleted player
|
|
|
|
TRAVERSE_SPRITE_STAT(headspritestat[STAT_ENEMY], i, nexti)
|
|
|
|
{
|
|
|
|
u = User[i];
|
|
|
|
if (u->tgt_sp == pp->SpriteP)
|
|
|
|
u->tgt_sp = Player[0].SpriteP;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (myconnectindex >= numplayers)
|
|
|
|
myconnectindex = 0;
|
|
|
|
|
|
|
|
if (screenpeek >= numplayers)
|
|
|
|
screenpeek = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#if DEBUG
|
2019-11-17 17:02:17 +00:00
|
|
|
void SinglePlayInput(PLAYERp pp)
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
|
|
|
int pnum = myconnectindex;
|
2015-05-19 21:58:29 +00:00
|
|
|
uint8_t* kp;
|
2015-05-19 21:54:34 +00:00
|
|
|
|
2019-11-04 22:01:50 +00:00
|
|
|
if (buttonMap.ButtonDown(gamefunc_See_Co_Op_View) && !UsingMenus && !ConPanel && dimensionmode == 3)
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
|
|
|
short oldscreenpeek = screenpeek;
|
|
|
|
|
2019-11-04 22:01:50 +00:00
|
|
|
buttonMap.ClearButton(gamefunc_See_Co_Op_View);
|
2015-05-19 21:54:34 +00:00
|
|
|
|
|
|
|
screenpeek = connectpoint2[screenpeek];
|
|
|
|
|
|
|
|
if (screenpeek < 0)
|
|
|
|
screenpeek = connecthead;
|
|
|
|
|
|
|
|
if (dimensionmode == 2 || dimensionmode == 5 || dimensionmode == 6)
|
|
|
|
setup2dscreen();
|
|
|
|
|
|
|
|
if (dimensionmode != 2)
|
|
|
|
{
|
|
|
|
PLAYERp tp;
|
|
|
|
|
|
|
|
tp = Player + screenpeek;
|
|
|
|
PlayerUpdatePanelInfo(tp);
|
2019-10-27 12:40:24 +00:00
|
|
|
setpalettefade(0,0,0,0);
|
2015-05-19 21:54:34 +00:00
|
|
|
memcpy(pp->temp_pal, palette_data, sizeof(palette_data));
|
|
|
|
DoPlayerDivePalette(tp);
|
|
|
|
DoPlayerNightVisionPalette(tp);
|
|
|
|
// printf("SingPlayInput set_pal: tp->PlayerSprite = %d\n",tp->PlayerSprite);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2019-11-17 17:02:17 +00:00
|
|
|
void DebugKeys(PLAYERp pp)
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
|
|
|
short w, h;
|
|
|
|
|
2019-11-03 23:53:55 +00:00
|
|
|
if (!(inputState.GetKeyStatus(KEYSC_ALT) || inputState.GetKeyStatus(KEYSC_RALT)))
|
2015-05-19 21:54:34 +00:00
|
|
|
return;
|
|
|
|
|
|
|
|
if (InputMode)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (CommEnabled)
|
|
|
|
return;
|
|
|
|
|
|
|
|
//
|
|
|
|
// visiblity adjust
|
|
|
|
//
|
|
|
|
|
2019-11-03 23:53:55 +00:00
|
|
|
if (inputState.GetKeyStatus(KEYSC_L) > 0)
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
2019-11-03 23:53:55 +00:00
|
|
|
if (inputState.GetKeyStatus(KEYSC_LSHIFT) | inputState.GetKeyStatus(KEYSC_RSHIFT)) // SHIFT
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
2015-05-19 22:03:30 +00:00
|
|
|
g_visibility = g_visibility - (g_visibility >> 3);
|
2015-05-19 21:54:34 +00:00
|
|
|
|
2015-05-19 22:03:30 +00:00
|
|
|
if (g_visibility < 128)
|
|
|
|
g_visibility = 16348;
|
2015-05-19 21:54:34 +00:00
|
|
|
|
2015-05-19 22:03:30 +00:00
|
|
|
//if (g_visibility > 16384)
|
|
|
|
// g_visibility = 128;
|
2015-05-19 21:54:34 +00:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2019-11-03 23:53:55 +00:00
|
|
|
inputState.GetKeyStatus(KEYSC_L) = 0;
|
2015-05-19 21:54:34 +00:00
|
|
|
|
2015-05-19 22:03:30 +00:00
|
|
|
g_visibility = g_visibility - (g_visibility >> 3);
|
2015-05-19 21:54:34 +00:00
|
|
|
|
2015-05-19 22:03:30 +00:00
|
|
|
if (g_visibility > 16384)
|
|
|
|
g_visibility = 128;
|
2015-05-19 21:54:34 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//
|
|
|
|
// parallax changes
|
|
|
|
//
|
|
|
|
|
2019-11-03 23:53:55 +00:00
|
|
|
if (inputState.GetKeyStatus(KEYSC_X))
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
2019-11-03 23:53:55 +00:00
|
|
|
if (inputState.GetKeyStatus(KEYSC_LSHIFT))
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
2019-11-03 23:53:55 +00:00
|
|
|
inputState.GetKeyStatus(KEYSC_LSHIFT) = FALSE;
|
|
|
|
inputState.GetKeyStatus(KEYSC_X) = 0;
|
2015-05-19 21:54:34 +00:00
|
|
|
|
2015-05-19 22:05:20 +00:00
|
|
|
parallaxyoffs_override += 10;
|
2015-05-19 21:54:34 +00:00
|
|
|
|
2015-05-19 22:05:20 +00:00
|
|
|
if (parallaxyoffs_override > 100)
|
|
|
|
parallaxyoffs_override = 0;
|
2015-05-19 21:54:34 +00:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2019-11-03 23:53:55 +00:00
|
|
|
inputState.GetKeyStatus(KEYSC_X) = 0;
|
2015-05-19 21:54:34 +00:00
|
|
|
parallaxtype++;
|
|
|
|
if (parallaxtype > 2)
|
|
|
|
parallaxtype = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
2019-11-17 17:02:17 +00:00
|
|
|
void ConKey(void)
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
|
|
|
#if DEBUG
|
|
|
|
// Console Input Panel
|
|
|
|
if (!ConPanel && dimensionmode == 3)
|
|
|
|
{
|
2019-11-03 23:53:55 +00:00
|
|
|
//if (inputState.GetKeyStatus(KEYSC_TILDE) && inputState.GetKeyStatus(KEYSC_LSHIFT))
|
|
|
|
if (inputState.GetKeyStatus(KEYSC_TILDE))
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
2019-11-03 23:53:55 +00:00
|
|
|
inputState.GetKeyStatus(KEYSC_TILDE) = FALSE;
|
|
|
|
//inputState.GetKeyStatus(KEYSC_LSHIFT) = FALSE;
|
|
|
|
inputState.keyFlushChars();
|
2015-05-19 21:54:34 +00:00
|
|
|
ConPanel = TRUE;
|
|
|
|
InputMode = TRUE;
|
|
|
|
ConInputMode = TRUE;
|
|
|
|
if (!CommEnabled)
|
|
|
|
GamePaused = TRUE;
|
|
|
|
memset(MessageInputString, '\0', sizeof(MessageInputString));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (ConPanel)
|
|
|
|
{
|
2019-11-03 23:53:55 +00:00
|
|
|
//if (inputState.GetKeyStatus(KEYSC_TILDE) && inputState.GetKeyStatus(KEYSC_LSHIFT))
|
|
|
|
if (inputState.GetKeyStatus(KEYSC_TILDE))
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
2019-11-03 23:53:55 +00:00
|
|
|
inputState.GetKeyStatus(KEYSC_TILDE) = FALSE;
|
|
|
|
//inputState.GetKeyStatus(KEYSC_LSHIFT) = FALSE;
|
|
|
|
inputState.keyFlushChars();
|
2015-05-19 21:54:34 +00:00
|
|
|
ConPanel = FALSE;
|
|
|
|
ConInputMode = FALSE;
|
|
|
|
InputMode = FALSE;
|
|
|
|
if (!CommEnabled)
|
|
|
|
GamePaused = FALSE;
|
|
|
|
memset(MessageInputString, '\0', sizeof(MessageInputString));
|
|
|
|
SetFragBar(Player + myconnectindex);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2019-11-17 17:02:17 +00:00
|
|
|
void FunctionKeys(PLAYERp pp)
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
2015-05-19 21:58:29 +00:00
|
|
|
extern SWBOOL GamePaused;
|
2015-05-19 21:54:34 +00:00
|
|
|
extern short QuickLoadNum;
|
|
|
|
static int rts_delay = 0;
|
|
|
|
int fn_key = 0;
|
|
|
|
|
|
|
|
rts_delay++;
|
|
|
|
|
2019-11-03 23:53:55 +00:00
|
|
|
if (inputState.GetKeyStatus(sc_F1)) { fn_key = 1; }
|
|
|
|
if (inputState.GetKeyStatus(sc_F2)) { fn_key = 2; }
|
|
|
|
if (inputState.GetKeyStatus(sc_F3)) { fn_key = 3; }
|
|
|
|
if (inputState.GetKeyStatus(sc_F4)) { fn_key = 4; }
|
|
|
|
if (inputState.GetKeyStatus(sc_F5)) { fn_key = 5; }
|
|
|
|
if (inputState.GetKeyStatus(sc_F6)) { fn_key = 6; }
|
|
|
|
if (inputState.GetKeyStatus(sc_F7)) { fn_key = 7; }
|
|
|
|
if (inputState.GetKeyStatus(sc_F8)) { fn_key = 8; }
|
|
|
|
if (inputState.GetKeyStatus(sc_F9)) { fn_key = 9; }
|
|
|
|
if (inputState.GetKeyStatus(sc_F10)) { fn_key = 10; }
|
2015-05-19 21:54:34 +00:00
|
|
|
|
2019-10-28 06:02:42 +00:00
|
|
|
if (inputState.AltPressed())
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
2019-10-27 12:40:24 +00:00
|
|
|
if (rts_delay > 16 && fn_key && CommEnabled && !adult_lockout && !Global_PLock)
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
2019-10-28 05:47:49 +00:00
|
|
|
inputState.ClearKeyStatus(sc_F1 + fn_key - 1);
|
2015-05-19 21:54:34 +00:00
|
|
|
|
|
|
|
rts_delay = 0;
|
|
|
|
|
|
|
|
PlaySoundRTS(fn_key);
|
|
|
|
|
|
|
|
if (CommEnabled)
|
|
|
|
{
|
|
|
|
PACKET_RTS p;
|
|
|
|
|
|
|
|
p.PacketType = PACKET_TYPE_RTS;
|
|
|
|
p.RTSnum = fn_key;
|
|
|
|
|
2015-05-19 21:58:29 +00:00
|
|
|
netbroadcastpacket((uint8_t*)(&p), sizeof(p)); // TENSW
|
2015-05-19 21:54:34 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2019-10-28 06:02:42 +00:00
|
|
|
if (inputState.ShiftPressed())
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
|
|
|
if (fn_key && CommEnabled)
|
|
|
|
{
|
2019-10-28 05:47:49 +00:00
|
|
|
inputState.ClearKeyStatus(sc_Escape);
|
|
|
|
inputState.ClearKeyStatus(sc_F1 + fn_key - 1);
|
2015-05-19 21:54:34 +00:00
|
|
|
|
|
|
|
if (CommEnabled)
|
|
|
|
{
|
|
|
|
short pnum;
|
|
|
|
|
2019-10-27 07:14:58 +00:00
|
|
|
sprintf(ds,"SENT: %s",**CombatMacros[fn_key-1]);
|
2015-05-19 21:54:34 +00:00
|
|
|
adduserquote(ds);
|
|
|
|
|
|
|
|
TRAVERSE_CONNECT(pnum)
|
|
|
|
{
|
|
|
|
if (pnum != myconnectindex)
|
|
|
|
{
|
2019-10-27 07:14:58 +00:00
|
|
|
sprintf(ds,"%s: %s",pp->PlayerName, **CombatMacros[fn_key - 1]);
|
2015-05-19 21:59:39 +00:00
|
|
|
SW_SendMessage(pnum, ds);
|
2015-05-19 21:54:34 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
if (numplayers <= 1)
|
|
|
|
{
|
|
|
|
// F2 save menu
|
2019-11-03 23:53:55 +00:00
|
|
|
if (inputState.GetKeyStatus(KEYSC_F2))
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
2019-10-28 05:47:49 +00:00
|
|
|
inputState.ClearKeyStatus(KEYSC_F2);
|
2015-05-19 21:54:34 +00:00
|
|
|
if (!TEST(pp->Flags, PF_DEAD))
|
|
|
|
{
|
2019-10-28 05:47:49 +00:00
|
|
|
inputState.SetKeyStatus(sc_Escape);
|
|
|
|
ControlPanelType = ct_savemenu;
|
2015-05-19 21:54:34 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// F3 load menu
|
2019-11-03 23:53:55 +00:00
|
|
|
if (inputState.GetKeyStatus(KEYSC_F3))
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
2019-10-28 05:47:49 +00:00
|
|
|
inputState.ClearKeyStatus(KEYSC_F3);
|
|
|
|
if (!TEST(pp->Flags, PF_DEAD))
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
2019-10-28 05:47:49 +00:00
|
|
|
inputState.SetKeyStatus(sc_Escape);
|
|
|
|
ControlPanelType = ct_loadmenu;
|
2015-05-19 21:54:34 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// F6 option menu
|
2019-11-03 23:53:55 +00:00
|
|
|
if (inputState.GetKeyStatus(KEYSC_F6))
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
2015-05-19 21:58:29 +00:00
|
|
|
extern SWBOOL QuickSaveMode;
|
2019-10-28 05:47:49 +00:00
|
|
|
inputState.ClearKeyStatus(KEYSC_F6);
|
|
|
|
if (!TEST(pp->Flags, PF_DEAD))
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
2019-10-28 05:47:49 +00:00
|
|
|
inputState.SetKeyStatus(sc_Escape);
|
|
|
|
ControlPanelType = ct_savemenu;
|
2015-05-19 21:54:34 +00:00
|
|
|
QuickSaveMode = TRUE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// F9 quick load
|
2019-11-03 23:53:55 +00:00
|
|
|
if (inputState.GetKeyStatus(KEYSC_F9))
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
2019-10-28 05:47:49 +00:00
|
|
|
inputState.ClearKeyStatus(KEYSC_F9);
|
2015-05-19 21:54:34 +00:00
|
|
|
|
|
|
|
if (!TEST(pp->Flags, PF_DEAD))
|
|
|
|
{
|
|
|
|
if (QuickLoadNum < 0)
|
|
|
|
{
|
|
|
|
PutStringInfoLine(pp, "Last saved game not found.");
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2019-11-03 23:53:55 +00:00
|
|
|
inputState.ClearKeysDown();
|
2019-10-28 05:47:49 +00:00
|
|
|
inputState.SetKeyStatus(sc_Escape);
|
|
|
|
ControlPanelType = ct_quickloadmenu;
|
2015-05-19 21:54:34 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// F4 sound menu
|
2019-11-03 23:53:55 +00:00
|
|
|
if (inputState.GetKeyStatus(KEYSC_F4))
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
2019-10-28 05:47:49 +00:00
|
|
|
inputState.ClearKeyStatus(KEYSC_F4);
|
|
|
|
inputState.SetKeyStatus(sc_Escape);
|
|
|
|
ControlPanelType = ct_soundmenu;
|
2015-05-19 21:54:34 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// F7 VIEW control
|
2019-11-03 23:53:55 +00:00
|
|
|
if (inputState.GetKeyStatus(KEYSC_F7))
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
2019-10-28 05:47:49 +00:00
|
|
|
inputState.ClearKeyStatus(KEYSC_F7);
|
2015-05-19 21:54:34 +00:00
|
|
|
|
2019-11-03 23:53:55 +00:00
|
|
|
if (inputState.GetKeyStatus(KEYSC_LSHIFT) || inputState.GetKeyStatus(KEYSC_RSHIFT))
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
|
|
|
if (TEST(pp->Flags, PF_VIEW_FROM_OUTSIDE))
|
|
|
|
pp->view_outside_dang = NORM_ANGLE(pp->view_outside_dang + 256);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (TEST(pp->Flags, PF_VIEW_FROM_OUTSIDE))
|
|
|
|
{
|
|
|
|
RESET(pp->Flags, PF_VIEW_FROM_OUTSIDE);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
SET(pp->Flags, PF_VIEW_FROM_OUTSIDE);
|
|
|
|
pp->camera_dist = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// F8 toggle messages
|
2019-11-03 23:53:55 +00:00
|
|
|
if (inputState.GetKeyStatus(KEYSC_F8))
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
2019-10-28 05:47:49 +00:00
|
|
|
inputState.ClearKeyStatus(KEYSC_F8);
|
2015-05-19 21:54:34 +00:00
|
|
|
|
2019-10-27 15:53:00 +00:00
|
|
|
hud_messages = !hud_messages;
|
2015-05-19 21:54:34 +00:00
|
|
|
|
2019-10-27 15:53:00 +00:00
|
|
|
if (hud_messages)
|
2015-05-19 21:54:34 +00:00
|
|
|
PutStringInfoLine(pp, "Messages ON");
|
|
|
|
else
|
|
|
|
PutStringInfoLine(pp, "Messages OFF");
|
|
|
|
}
|
|
|
|
|
|
|
|
// F10 quit menu
|
2019-11-03 23:53:55 +00:00
|
|
|
if (inputState.GetKeyStatus(KEYSC_F10))
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
2019-10-28 05:47:49 +00:00
|
|
|
inputState.ClearKeyStatus(KEYSC_F10);
|
|
|
|
inputState.SetKeyStatus(sc_Escape);
|
|
|
|
ControlPanelType = ct_quitmenu;
|
2015-05-19 21:54:34 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// F11 gamma correction
|
2019-11-03 23:53:55 +00:00
|
|
|
if (inputState.GetKeyStatus(KEYSC_F11) > 0)
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
2019-10-28 05:47:49 +00:00
|
|
|
inputState.ClearKeyStatus(KEYSC_F11);
|
2019-10-27 12:40:24 +00:00
|
|
|
// Do this entirely in the video backend.
|
2015-05-19 21:54:34 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2015-05-19 21:58:29 +00:00
|
|
|
void PauseKey(PLAYERp pp)
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
2015-05-19 21:58:29 +00:00
|
|
|
extern SWBOOL GamePaused,CheatInputMode;
|
2015-05-19 21:54:34 +00:00
|
|
|
extern short QuickLoadNum;
|
2015-05-19 21:58:29 +00:00
|
|
|
extern SWBOOL enabled;
|
2015-05-19 21:54:34 +00:00
|
|
|
|
2019-11-03 23:53:55 +00:00
|
|
|
if (inputState.GetKeyStatus(sc_Pause) && !CommEnabled && !InputMode && !UsingMenus && !CheatInputMode && !ConPanel)
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
2019-10-28 05:47:49 +00:00
|
|
|
inputState.ClearKeyStatus(sc_Pause);
|
2015-05-19 21:54:34 +00:00
|
|
|
|
|
|
|
PauseKeySet ^= 1;
|
|
|
|
|
|
|
|
if (PauseKeySet)
|
|
|
|
GamePaused = TRUE;
|
|
|
|
else
|
|
|
|
GamePaused = FALSE;
|
|
|
|
|
|
|
|
if (GamePaused)
|
|
|
|
{
|
|
|
|
short w,h;
|
|
|
|
#define MSG_GAME_PAUSED "Game Paused"
|
|
|
|
MNU_MeasureString(MSG_GAME_PAUSED, &w, &h);
|
|
|
|
PutStringTimer(pp, TEXT_TEST_COL(w), 100, MSG_GAME_PAUSED, 999);
|
|
|
|
PauseSong(TRUE);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
pClearTextLine(pp, 100);
|
|
|
|
PauseSong(FALSE);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!CommEnabled && TEST(pp->Flags, PF_DEAD))
|
|
|
|
{
|
|
|
|
if (ReloadPrompt)
|
|
|
|
{
|
|
|
|
if (QuickLoadNum < 0)
|
|
|
|
{
|
|
|
|
ReloadPrompt = FALSE;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2019-10-28 05:47:49 +00:00
|
|
|
inputState.SetKeyStatus(sc_Escape);
|
|
|
|
ControlPanelType = ct_quickloadmenu;
|
2015-05-19 21:54:34 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
2015-05-19 21:58:29 +00:00
|
|
|
void GetMessageInput(PLAYERp pp)
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
|
|
|
int pnum = myconnectindex;
|
|
|
|
short w,h;
|
2015-05-19 21:58:29 +00:00
|
|
|
static SWBOOL cur_show;
|
|
|
|
static SWBOOL TeamSendAll, TeamSendTeam;
|
2015-05-19 21:54:34 +00:00
|
|
|
#define TEAM_MENU "A - Send to ALL, T - Send to TEAM"
|
|
|
|
static char HoldMessageInputString[256];
|
|
|
|
int i;
|
|
|
|
|
|
|
|
if (!MessageInputMode && !ConInputMode)
|
|
|
|
{
|
2019-11-04 22:01:50 +00:00
|
|
|
if (buttonMap.ButtonDown(gamefunc_SendMessage))
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
2019-11-04 22:01:50 +00:00
|
|
|
buttonMap.ClearButton(gamefunc_SendMessage);
|
2019-11-03 23:53:55 +00:00
|
|
|
inputState.keyFlushChars();
|
2015-05-19 21:54:34 +00:00
|
|
|
MessageInputMode = TRUE;
|
|
|
|
InputMode = TRUE;
|
|
|
|
TeamSendTeam = FALSE;
|
|
|
|
TeamSendAll = FALSE;
|
|
|
|
|
|
|
|
if (MessageInputMode)
|
|
|
|
{
|
|
|
|
memset(MessageInputString, '\0', sizeof(MessageInputString));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (MessageInputMode && !ConInputMode)
|
|
|
|
{
|
|
|
|
if (gs.BorderNum > BORDER_BAR+1)
|
|
|
|
SetRedrawScreen(pp);
|
|
|
|
|
|
|
|
// get input
|
|
|
|
switch (MNU_InputSmallString(MessageInputString, 320-20))
|
|
|
|
{
|
|
|
|
case -1: // Cancel Input (pressed ESC) or Err
|
|
|
|
MessageInputMode = FALSE;
|
|
|
|
InputMode = FALSE;
|
2019-11-03 23:53:55 +00:00
|
|
|
inputState.ClearKeysDown();
|
|
|
|
inputState.keyFlushChars();
|
2015-05-19 21:54:34 +00:00
|
|
|
break;
|
|
|
|
case FALSE: // Input finished (RETURN)
|
|
|
|
if (MessageInputString[0] == '\0')
|
|
|
|
{
|
|
|
|
// no input
|
|
|
|
MessageInputMode = FALSE;
|
|
|
|
InputMode = FALSE;
|
2019-11-03 23:53:55 +00:00
|
|
|
inputState.ClearKeysDown();
|
|
|
|
inputState.keyFlushChars();
|
2019-11-04 22:01:50 +00:00
|
|
|
buttonMap.ClearButton(gamefunc_Inventory);
|
2015-05-19 21:54:34 +00:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (gNet.TeamPlay)
|
|
|
|
{
|
|
|
|
if (memcmp(MessageInputString, TEAM_MENU, sizeof(TEAM_MENU)) != 0)
|
|
|
|
{
|
|
|
|
// see if its a command
|
|
|
|
if (IsCommand(MessageInputString))
|
|
|
|
{
|
|
|
|
TeamSendAll = TRUE;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
strcpy(HoldMessageInputString, MessageInputString);
|
|
|
|
strcpy(MessageInputString, TEAM_MENU);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (memcmp(MessageInputString, TEAM_MENU, sizeof(TEAM_MENU)) == 0)
|
|
|
|
{
|
|
|
|
strcpy(MessageInputString, HoldMessageInputString);
|
|
|
|
TeamSendAll = TRUE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
SEND_MESSAGE:
|
|
|
|
|
|
|
|
// broadcast message
|
|
|
|
MessageInputMode = FALSE;
|
|
|
|
InputMode = FALSE;
|
2019-11-03 23:53:55 +00:00
|
|
|
inputState.ClearKeysDown();
|
|
|
|
inputState.keyFlushChars();
|
2019-11-04 22:01:50 +00:00
|
|
|
buttonMap.ClearButton(gamefunc_Inventory);
|
2015-05-19 21:54:34 +00:00
|
|
|
CON_ProcessUserCommand(); // Check to see if it's a cheat or command
|
|
|
|
|
|
|
|
for (i = 0; i < NUMGAMEFUNCTIONS; i++)
|
2019-11-04 22:01:50 +00:00
|
|
|
buttonMap.ClearButton(i);
|
2015-05-19 21:54:34 +00:00
|
|
|
|
|
|
|
// Put who sent this
|
|
|
|
sprintf(ds,"%s: %s",pp->PlayerName,MessageInputString);
|
|
|
|
|
|
|
|
if (gNet.TeamPlay)
|
|
|
|
{
|
|
|
|
TRAVERSE_CONNECT(pnum)
|
|
|
|
{
|
|
|
|
if (pnum != myconnectindex)
|
|
|
|
{
|
|
|
|
if (TeamSendAll)
|
2015-05-19 21:59:39 +00:00
|
|
|
SW_SendMessage(pnum, ds);
|
2015-05-19 21:54:34 +00:00
|
|
|
else if (User[pp->PlayerSprite]->spal == User[Player[pnum].PlayerSprite]->spal)
|
2015-05-19 21:59:39 +00:00
|
|
|
SW_SendMessage(pnum, ds);
|
2015-05-19 21:54:34 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
TRAVERSE_CONNECT(pnum)
|
|
|
|
{
|
|
|
|
if (pnum != myconnectindex)
|
|
|
|
{
|
2015-05-19 21:59:39 +00:00
|
|
|
SW_SendMessage(pnum, ds);
|
2015-05-19 21:54:34 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
adduserquote(MessageInputString);
|
|
|
|
quotebot += 8;
|
|
|
|
quotebotgoal = quotebot;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case TRUE: // Got input
|
|
|
|
|
|
|
|
if (gNet.TeamPlay)
|
|
|
|
{
|
|
|
|
if (memcmp(MessageInputString, TEAM_MENU "a", sizeof(TEAM_MENU)+1) == 0)
|
|
|
|
{
|
|
|
|
strcpy(MessageInputString, HoldMessageInputString);
|
|
|
|
TeamSendAll = TRUE;
|
|
|
|
goto SEND_MESSAGE;
|
|
|
|
}
|
|
|
|
else if (memcmp(MessageInputString, TEAM_MENU "t", sizeof(TEAM_MENU)+1) == 0)
|
|
|
|
{
|
|
|
|
strcpy(MessageInputString, HoldMessageInputString);
|
|
|
|
TeamSendTeam = TRUE;
|
|
|
|
goto SEND_MESSAGE;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
// reset the string if anything else is typed
|
|
|
|
if (strlen(MessageInputString)+1 > sizeof(TEAM_MENU))
|
|
|
|
{
|
|
|
|
strcpy(MessageInputString, TEAM_MENU);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-05-19 21:58:29 +00:00
|
|
|
void GetConInput(PLAYERp pp)
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
|
|
|
int pnum = myconnectindex;
|
|
|
|
short w,h;
|
2015-05-19 21:58:29 +00:00
|
|
|
static SWBOOL cur_show;
|
2015-05-19 21:54:34 +00:00
|
|
|
|
|
|
|
if (MessageInputMode || HelpInputMode)
|
|
|
|
return;
|
|
|
|
|
|
|
|
ConKey();
|
|
|
|
|
|
|
|
// Console input commands
|
|
|
|
if (ConInputMode && !MessageInputMode)
|
|
|
|
{
|
|
|
|
// get input
|
|
|
|
switch (MNU_InputSmallString(MessageInputString, 250))
|
|
|
|
{
|
|
|
|
case -1: // Cancel Input (pressed ESC) or Err
|
|
|
|
InputMode = FALSE;
|
2019-11-03 23:53:55 +00:00
|
|
|
inputState.ClearKeysDown();
|
|
|
|
inputState.keyFlushChars();
|
2015-05-19 21:54:34 +00:00
|
|
|
memset(MessageInputString, '\0', sizeof(MessageInputString));
|
|
|
|
break;
|
|
|
|
case FALSE: // Input finished (RETURN)
|
|
|
|
if (MessageInputString[0] == '\0')
|
|
|
|
{
|
|
|
|
InputMode = FALSE;
|
2019-11-03 23:53:55 +00:00
|
|
|
inputState.ClearKeysDown();
|
|
|
|
inputState.keyFlushChars();
|
2019-11-04 22:01:50 +00:00
|
|
|
buttonMap.ClearButton(gamefunc_Inventory);
|
2015-05-19 21:54:34 +00:00
|
|
|
memset(MessageInputString, '\0', sizeof(MessageInputString));
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
InputMode = FALSE;
|
2019-11-03 23:53:55 +00:00
|
|
|
inputState.ClearKeysDown();
|
|
|
|
inputState.keyFlushChars();
|
2019-11-04 22:01:50 +00:00
|
|
|
buttonMap.ClearButton(gamefunc_Inventory);
|
2019-04-10 01:00:15 +00:00
|
|
|
CON_ConMessage("%s", MessageInputString);
|
2015-05-19 21:54:34 +00:00
|
|
|
CON_ProcessUserCommand(); // Check to see if it's a cheat or command
|
|
|
|
|
|
|
|
conbot += 6;
|
|
|
|
conbotgoal = conbot;
|
|
|
|
//addconquote(MessageInputString);
|
|
|
|
// Clear it out after every entry
|
|
|
|
memset(MessageInputString, '\0', sizeof(MessageInputString));
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case TRUE: // Got input
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2015-05-19 21:58:29 +00:00
|
|
|
void GetHelpInput(PLAYERp pp)
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
2015-05-19 21:58:29 +00:00
|
|
|
extern SWBOOL GamePaused;
|
2015-05-19 21:54:34 +00:00
|
|
|
|
2019-11-03 23:53:55 +00:00
|
|
|
if (inputState.GetKeyStatus(KEYSC_ALT) || inputState.GetKeyStatus(KEYSC_RALT))
|
2015-05-19 21:54:34 +00:00
|
|
|
return;
|
|
|
|
|
2019-11-03 23:53:55 +00:00
|
|
|
if (inputState.GetKeyStatus(KEYSC_LSHIFT) || inputState.GetKeyStatus(KEYSC_RSHIFT))
|
2015-05-19 21:54:34 +00:00
|
|
|
return;
|
|
|
|
|
|
|
|
if (MessageInputMode || ConInputMode)
|
|
|
|
return;
|
|
|
|
|
|
|
|
// F1 help menu
|
|
|
|
if (!HelpInputMode)
|
|
|
|
{
|
2019-11-03 23:53:55 +00:00
|
|
|
if (inputState.GetKeyStatus(KEYSC_F1))
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
2019-10-28 05:47:49 +00:00
|
|
|
inputState.ClearKeyStatus(KEYSC_F11);
|
|
|
|
HelpPage = 0;
|
2015-05-19 21:54:34 +00:00
|
|
|
HelpInputMode = TRUE;
|
|
|
|
PanelUpdateMode = FALSE;
|
|
|
|
InputMode = TRUE;
|
|
|
|
if (!CommEnabled)
|
|
|
|
GamePaused = TRUE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (HelpInputMode)
|
|
|
|
{
|
2019-11-03 23:53:55 +00:00
|
|
|
if (inputState.GetKeyStatus(KEYSC_ESC))
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
2019-10-28 05:47:49 +00:00
|
|
|
inputState.ClearKeyStatus(sc_Escape);
|
2019-11-03 23:53:55 +00:00
|
|
|
inputState.ClearKeysDown();
|
2015-05-19 21:54:34 +00:00
|
|
|
PanelUpdateMode = TRUE;
|
|
|
|
HelpInputMode = FALSE;
|
|
|
|
InputMode = FALSE;
|
|
|
|
if (!CommEnabled)
|
|
|
|
GamePaused = FALSE;
|
|
|
|
SetRedrawScreen(pp);
|
|
|
|
}
|
|
|
|
|
2019-11-03 23:53:55 +00:00
|
|
|
if (inputState.GetKeyStatus(KEYSC_SPACE) || inputState.GetKeyStatus(KEYSC_ENTER) || inputState.GetKeyStatus(KEYSC_PGDN) || inputState.GetKeyStatus(KEYSC_DOWN) || inputState.GetKeyStatus(KEYSC_RIGHT) || inputState.GetKeyStatus(sc_kpad_3) || inputState.GetKeyStatus(sc_kpad_2) || inputState.GetKeyStatus(sc_kpad_6))
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
2019-10-28 05:47:49 +00:00
|
|
|
inputState.ClearKeyStatus(KEYSC_SPACE);
|
|
|
|
inputState.ClearKeyStatus(KEYSC_ENTER);
|
|
|
|
inputState.ClearKeyStatus(KEYSC_PGDN);
|
|
|
|
inputState.ClearKeyStatus(KEYSC_DOWN);
|
|
|
|
inputState.ClearKeyStatus(KEYSC_RIGHT);
|
|
|
|
inputState.ClearKeyStatus(sc_kpad_3);
|
|
|
|
inputState.ClearKeyStatus(sc_kpad_2);
|
|
|
|
inputState.ClearKeyStatus(sc_kpad_6);
|
2015-05-19 21:54:34 +00:00
|
|
|
|
|
|
|
HelpPage++;
|
|
|
|
if (HelpPage >= (int)SIZ(HelpPagePic))
|
|
|
|
// CTW MODIFICATION
|
|
|
|
// "Oops! I did it again..."
|
|
|
|
// HelpPage = SIZ(HelpPagePic) - 1;
|
|
|
|
HelpPage = 0;
|
|
|
|
// CTW MODIFICATION END
|
|
|
|
}
|
|
|
|
|
2019-11-03 23:53:55 +00:00
|
|
|
if (inputState.GetKeyStatus(KEYSC_PGUP) || inputState.GetKeyStatus(KEYSC_UP) || inputState.GetKeyStatus(KEYSC_LEFT) || inputState.GetKeyStatus(sc_kpad_9) || inputState.GetKeyStatus(sc_kpad_8) || inputState.GetKeyStatus(sc_kpad_4))
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
2019-10-28 05:47:49 +00:00
|
|
|
inputState.ClearKeyStatus(KEYSC_PGUP);
|
|
|
|
inputState.ClearKeyStatus(KEYSC_UP);
|
|
|
|
inputState.ClearKeyStatus(KEYSC_LEFT);
|
|
|
|
inputState.ClearKeyStatus(sc_kpad_8);
|
|
|
|
inputState.ClearKeyStatus(sc_kpad_9);
|
|
|
|
inputState.ClearKeyStatus(sc_kpad_4);
|
2015-05-19 21:54:34 +00:00
|
|
|
|
|
|
|
HelpPage--;
|
|
|
|
if (HelpPage < 0)
|
|
|
|
// CTW MODIFICATION
|
|
|
|
// "Played with the logic, got lost in the game..."
|
|
|
|
HelpPage = SIZ(HelpPagePic) - 1;
|
|
|
|
// CTW MODIFICATION END
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
short MirrorDelay;
|
|
|
|
|
2019-11-17 17:02:17 +00:00
|
|
|
void getinput(SW_PACKET *loc)
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
2015-05-19 21:58:29 +00:00
|
|
|
SWBOOL found = FALSE;
|
2015-05-19 21:54:34 +00:00
|
|
|
int i;
|
|
|
|
PLAYERp pp = Player + myconnectindex;
|
|
|
|
PLAYERp newpp = Player + myconnectindex;
|
|
|
|
int pnum = myconnectindex;
|
|
|
|
int inv_hotkey = 0;
|
|
|
|
|
|
|
|
#define TURBOTURNTIME (120/8)
|
|
|
|
#define NORMALTURN (12+6)
|
|
|
|
#define RUNTURN (28)
|
|
|
|
#define PREAMBLETURN 3
|
|
|
|
#define NORMALKEYMOVE 35
|
|
|
|
#define MAXVEL ((NORMALKEYMOVE*2)+10)
|
|
|
|
#define MAXSVEL ((NORMALKEYMOVE*2)+10)
|
|
|
|
#define MAXANGVEL 100
|
2019-11-26 08:24:19 +00:00
|
|
|
#define MAXAIMVEL 128
|
2015-05-19 21:54:34 +00:00
|
|
|
#define SET_LOC_KEY(loc, sync_num, key_test) SET(loc, ((!!(key_test)) << (sync_num)))
|
|
|
|
|
2015-05-19 21:58:29 +00:00
|
|
|
static int32_t turnheldtime;
|
|
|
|
int32_t momx, momy;
|
2015-05-19 21:54:34 +00:00
|
|
|
|
2015-05-19 21:58:29 +00:00
|
|
|
extern SWBOOL MenuButtonAutoRun;
|
|
|
|
extern SWBOOL MenuButtonAutoAim;
|
2015-05-19 21:54:34 +00:00
|
|
|
|
|
|
|
if (Prediction && CommEnabled)
|
|
|
|
{
|
|
|
|
newpp = ppp;
|
|
|
|
}
|
|
|
|
|
|
|
|
// reset all syncbits
|
|
|
|
loc->bits = 0;
|
|
|
|
|
|
|
|
// MAKE SURE THIS WILL GET SET
|
|
|
|
SET_LOC_KEY(loc->bits, SK_QUIT_GAME, MultiPlayQuitFlag);
|
|
|
|
|
2019-10-27 15:53:00 +00:00
|
|
|
if (in_aimmode)
|
|
|
|
g_MyAimMode = 0;
|
|
|
|
|
2019-11-04 22:01:50 +00:00
|
|
|
if (buttonMap.ButtonDown(gamefunc_Mouse_Aiming))
|
2019-10-27 15:53:00 +00:00
|
|
|
{
|
|
|
|
if (in_aimmode)
|
|
|
|
g_MyAimMode = 1;
|
|
|
|
else
|
|
|
|
{
|
2019-11-04 22:01:50 +00:00
|
|
|
buttonMap.ClearButton(gamefunc_Mouse_Aiming);
|
2019-10-27 15:53:00 +00:00
|
|
|
g_MyAimMode = !g_MyAimMode;
|
|
|
|
if (g_MyAimMode)
|
|
|
|
{
|
|
|
|
PutStringInfo(pp, "Mouse Aiming Off");
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
PutStringInfo(pp, "Mouse Aiming On");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2015-05-19 21:54:34 +00:00
|
|
|
|
2019-11-26 08:24:19 +00:00
|
|
|
int const aimMode = TEST(pp->Flags, PF_MOUSE_AIMING_ON);
|
2015-05-19 21:54:34 +00:00
|
|
|
|
2019-11-26 08:24:19 +00:00
|
|
|
ControlInfo info;
|
2015-05-19 21:54:34 +00:00
|
|
|
CONTROL_GetInput(&info);
|
|
|
|
|
2019-11-20 21:50:37 +00:00
|
|
|
if (in_mousedeadzone)
|
|
|
|
{
|
|
|
|
if (info.mousey > 0)
|
|
|
|
info.mousey = max(info.mousey - in_mousedeadzone, 0);
|
|
|
|
else if (info.mousey < 0)
|
|
|
|
info.mousey = min(info.mousey + in_mousedeadzone, 0);
|
|
|
|
|
|
|
|
if (info.mousex > 0)
|
|
|
|
info.mousex = max(info.mousex - in_mousedeadzone, 0);
|
|
|
|
else if (info.mousex < 0)
|
|
|
|
info.mousex = min(info.mousex + in_mousedeadzone, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (in_mousebias)
|
|
|
|
{
|
|
|
|
if (klabs(info.mousex) > klabs(info.mousey))
|
|
|
|
info.mousey = tabledivide32_noinline(info.mousey, in_mousebias);
|
|
|
|
else
|
|
|
|
info.mousex = tabledivide32_noinline(info.mousex, in_mousebias);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
//info.dz = (info.dz * move_scale)>>8;
|
|
|
|
//info.dyaw = (info.dyaw * turn_scale)>>8;
|
2015-05-19 21:54:34 +00:00
|
|
|
|
|
|
|
PauseKey(pp);
|
|
|
|
|
|
|
|
if (PauseKeySet)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (!MenuInputMode && !UsingMenus)
|
|
|
|
{
|
|
|
|
GetMessageInput(pp);
|
|
|
|
GetConInput(pp);
|
|
|
|
GetHelpInput(pp);
|
|
|
|
}
|
|
|
|
|
|
|
|
// MAP KEY
|
2019-11-04 22:01:50 +00:00
|
|
|
if (buttonMap.ButtonDown(gamefunc_Map))
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
2019-11-04 22:01:50 +00:00
|
|
|
buttonMap.ClearButton(gamefunc_Map);
|
2015-05-19 21:54:34 +00:00
|
|
|
|
|
|
|
// Init follow coords
|
|
|
|
Follow_posx = pp->posx;
|
|
|
|
Follow_posy = pp->posy;
|
|
|
|
|
|
|
|
if (dimensionmode == 3)
|
|
|
|
dimensionmode = 5;
|
|
|
|
else if (dimensionmode == 5)
|
|
|
|
dimensionmode = 6;
|
|
|
|
else
|
|
|
|
{
|
|
|
|
MirrorDelay = 1;
|
|
|
|
dimensionmode = 3;
|
|
|
|
SetFragBar(pp);
|
|
|
|
ScrollMode2D = FALSE;
|
|
|
|
SetRedrawScreen(pp);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Toggle follow map mode on/off
|
|
|
|
if (dimensionmode == 5 || dimensionmode == 6)
|
|
|
|
{
|
2019-11-04 22:01:50 +00:00
|
|
|
if (buttonMap.ButtonDown(gamefunc_Map_Follow_Mode))
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
2019-11-04 22:01:50 +00:00
|
|
|
buttonMap.ClearButton(gamefunc_Map_Follow_Mode);
|
2015-05-19 21:54:34 +00:00
|
|
|
ScrollMode2D = !ScrollMode2D;
|
|
|
|
Follow_posx = pp->posx;
|
|
|
|
Follow_posy = pp->posy;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// If in 2D follow mode, scroll around using glob vars
|
|
|
|
// Tried calling this in domovethings, but key response it too poor, skips key presses
|
|
|
|
// Note: ScrollMode2D = Follow mode, so this get called only during follow mode
|
|
|
|
if (ScrollMode2D && pp == Player + myconnectindex && !Prediction)
|
|
|
|
MoveScrollMode2D(Player + myconnectindex);
|
|
|
|
|
|
|
|
// !JIM! Added UsingMenus so that you don't move at all while using menus
|
|
|
|
if (MenuInputMode || UsingMenus || ScrollMode2D || InputMode)
|
|
|
|
return;
|
|
|
|
|
2019-11-04 22:01:50 +00:00
|
|
|
SET_LOC_KEY(loc->bits, SK_SPACE_BAR, ((!!inputState.GetKeyStatus(KEYSC_SPACE)) | buttonMap.ButtonDown(gamefunc_Open)));
|
2015-05-19 21:54:34 +00:00
|
|
|
|
2019-11-26 08:25:00 +00:00
|
|
|
int const running = G_CheckAutorun(buttonMap.ButtonDown(gamefunc_Run));
|
2019-11-26 08:24:19 +00:00
|
|
|
int32_t turnamount;
|
|
|
|
int32_t keymove;
|
|
|
|
constexpr int const analogExtent = 32767; // KEEPINSYNC sdlayer.cpp
|
2019-11-20 21:50:37 +00:00
|
|
|
|
2015-05-19 21:54:34 +00:00
|
|
|
if (running)
|
|
|
|
{
|
|
|
|
if (pp->sop_control)
|
|
|
|
turnamount = RUNTURN * 3;
|
|
|
|
else
|
|
|
|
turnamount = RUNTURN;
|
|
|
|
|
|
|
|
keymove = NORMALKEYMOVE << 1;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (pp->sop_control)
|
|
|
|
turnamount = NORMALTURN * 3;
|
|
|
|
else
|
|
|
|
turnamount = NORMALTURN;
|
|
|
|
|
|
|
|
keymove = NORMALKEYMOVE;
|
|
|
|
}
|
|
|
|
|
2019-11-26 08:24:19 +00:00
|
|
|
info.dz = (info.dz * move_scale)>>8;
|
|
|
|
info.dyaw = (info.dyaw * turn_scale)>>8;
|
|
|
|
|
|
|
|
int32_t svel = 0, vel = 0, angvel = 0, aimvel = 0;
|
|
|
|
|
|
|
|
if (buttonMap.ButtonDown(gamefunc_Strafe) && !pp->sop)
|
|
|
|
{
|
|
|
|
svel = -info.mousex;
|
|
|
|
svel -= info.dyaw * keymove / analogExtent;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
angvel = info.mousex / 32;
|
|
|
|
angvel += info.dyaw * (turnamount << 1) / analogExtent;
|
|
|
|
}
|
|
|
|
|
2019-11-26 18:10:24 +00:00
|
|
|
if (true)//aimMode)
|
2019-11-26 08:24:19 +00:00
|
|
|
aimvel = -info.mousey / 64;
|
|
|
|
else
|
|
|
|
vel = -(info.mousey >> 6);
|
|
|
|
|
2019-11-26 18:10:24 +00:00
|
|
|
if (in_mouseflip)
|
2019-11-26 08:24:19 +00:00
|
|
|
aimvel = -aimvel;
|
|
|
|
|
|
|
|
aimvel -= info.dpitch * turnamount / analogExtent;
|
|
|
|
svel -= info.dx * keymove / analogExtent;
|
|
|
|
vel -= info.dz * keymove / analogExtent;
|
|
|
|
|
2019-11-04 22:01:50 +00:00
|
|
|
if (buttonMap.ButtonDown(gamefunc_Strafe) && !pp->sop)
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
2019-11-04 22:01:50 +00:00
|
|
|
if (buttonMap.ButtonDown(gamefunc_Turn_Left))
|
2015-05-19 21:54:34 +00:00
|
|
|
svel -= -keymove;
|
2019-11-04 22:01:50 +00:00
|
|
|
if (buttonMap.ButtonDown(gamefunc_Turn_Right))
|
2015-05-19 21:54:34 +00:00
|
|
|
svel -= keymove;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2019-11-04 22:01:50 +00:00
|
|
|
if (buttonMap.ButtonDown(gamefunc_Turn_Left))
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
|
|
|
turnheldtime += synctics;
|
|
|
|
if (turnheldtime >= TURBOTURNTIME)
|
|
|
|
angvel -= turnamount;
|
|
|
|
else
|
|
|
|
angvel -= PREAMBLETURN;
|
|
|
|
}
|
2019-11-04 22:01:50 +00:00
|
|
|
else if (buttonMap.ButtonDown(gamefunc_Turn_Right))
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
|
|
|
turnheldtime += synctics;
|
|
|
|
if (turnheldtime >= TURBOTURNTIME)
|
|
|
|
angvel += turnamount;
|
|
|
|
else
|
|
|
|
angvel += PREAMBLETURN;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
turnheldtime = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-11-04 22:01:50 +00:00
|
|
|
if (buttonMap.ButtonDown(gamefunc_Strafe_Left) && !pp->sop)
|
2015-05-19 21:54:34 +00:00
|
|
|
svel += keymove;
|
|
|
|
|
2019-11-04 22:01:50 +00:00
|
|
|
if (buttonMap.ButtonDown(gamefunc_Strafe_Right) && !pp->sop)
|
2015-05-19 21:54:34 +00:00
|
|
|
svel += -keymove;
|
|
|
|
|
2019-11-04 22:01:50 +00:00
|
|
|
if (buttonMap.ButtonDown(gamefunc_Move_Forward))
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
|
|
|
vel += keymove;
|
|
|
|
//DSPRINTF(ds,"vel key %d",vel);
|
|
|
|
//DebugWriteString(ds);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
//DSPRINTF(ds,"vel %d",vel);
|
|
|
|
//DebugWriteString(ds);
|
|
|
|
}
|
|
|
|
|
2019-11-04 22:01:50 +00:00
|
|
|
if (buttonMap.ButtonDown(gamefunc_Move_Backward))
|
2015-05-19 21:54:34 +00:00
|
|
|
vel += -keymove;
|
|
|
|
|
2019-11-26 08:24:19 +00:00
|
|
|
vel = clamp(vel, -MAXVEL, MAXVEL);
|
|
|
|
svel = clamp(svel, -MAXSVEL, MAXSVEL);
|
2015-05-19 21:54:34 +00:00
|
|
|
|
2019-11-26 08:24:19 +00:00
|
|
|
angvel = clamp(angvel, -MAXANGVEL, MAXANGVEL);
|
|
|
|
aimvel = clamp(aimvel, -MAXAIMVEL, MAXAIMVEL);
|
2015-05-19 21:54:34 +00:00
|
|
|
|
2017-06-24 09:20:21 +00:00
|
|
|
momx = mulscale9(vel, sintable[NORM_ANGLE(newpp->pang + 512)]);
|
|
|
|
momy = mulscale9(vel, sintable[NORM_ANGLE(newpp->pang)]);
|
2015-05-19 21:54:34 +00:00
|
|
|
|
2017-06-24 09:20:21 +00:00
|
|
|
momx += mulscale9(svel, sintable[NORM_ANGLE(newpp->pang)]);
|
|
|
|
momy += mulscale9(svel, sintable[NORM_ANGLE(newpp->pang + 1536)]);
|
2015-05-19 21:54:34 +00:00
|
|
|
|
|
|
|
loc->vel = momx;
|
|
|
|
loc->svel = momy;
|
|
|
|
loc->angvel = angvel;
|
|
|
|
loc->aimvel = aimvel;
|
|
|
|
|
|
|
|
if (!CommEnabled)
|
|
|
|
{
|
|
|
|
if (MenuButtonAutoAim)
|
|
|
|
{
|
|
|
|
MenuButtonAutoAim = FALSE;
|
2019-10-21 22:05:21 +00:00
|
|
|
if ((!!TEST(pp->Flags, PF_AUTO_AIM)) != !!cl_autoaim)
|
2015-05-19 21:54:34 +00:00
|
|
|
SET_LOC_KEY(loc->bits, SK_AUTO_AIM, TRUE);
|
|
|
|
}
|
|
|
|
}
|
2019-11-03 23:53:55 +00:00
|
|
|
else if (inputState.GetKeyStatus(sc_Pause))
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
2019-11-03 23:53:55 +00:00
|
|
|
SET_LOC_KEY(loc->bits, SK_PAUSE, inputState.GetKeyStatus(sc_Pause));
|
2019-10-28 05:47:49 +00:00
|
|
|
inputState.ClearKeyStatus(sc_Pause);
|
|
|
|
}
|
2015-05-19 21:54:34 +00:00
|
|
|
|
2019-11-04 22:01:50 +00:00
|
|
|
SET_LOC_KEY(loc->bits, SK_CENTER_VIEW, buttonMap.ButtonDown(gamefunc_Center_View));
|
2015-05-19 21:54:34 +00:00
|
|
|
|
2019-11-04 22:01:50 +00:00
|
|
|
SET_LOC_KEY(loc->bits, SK_RUN, buttonMap.ButtonDown(gamefunc_Run));
|
|
|
|
SET_LOC_KEY(loc->bits, SK_SHOOT, buttonMap.ButtonDown(gamefunc_Fire));
|
2015-05-19 21:54:34 +00:00
|
|
|
|
|
|
|
// actually snap
|
2019-11-04 22:01:50 +00:00
|
|
|
SET_LOC_KEY(loc->bits, SK_SNAP_UP, buttonMap.ButtonDown(gamefunc_Aim_Up));
|
|
|
|
SET_LOC_KEY(loc->bits, SK_SNAP_DOWN, buttonMap.ButtonDown(gamefunc_Aim_Down));
|
2015-05-19 21:54:34 +00:00
|
|
|
|
|
|
|
// actually just look
|
2019-11-04 22:01:50 +00:00
|
|
|
SET_LOC_KEY(loc->bits, SK_LOOK_UP, buttonMap.ButtonDown(gamefunc_Look_Up));
|
|
|
|
SET_LOC_KEY(loc->bits, SK_LOOK_DOWN, buttonMap.ButtonDown(gamefunc_Look_Down));
|
2015-05-19 21:54:34 +00:00
|
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < MAX_WEAPONS_KEYS; i++)
|
|
|
|
{
|
2019-11-04 22:01:50 +00:00
|
|
|
if (buttonMap.ButtonDown(gamefunc_Weapon_1 + i))
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
|
|
|
SET(loc->bits, i + 1);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-11-04 22:01:50 +00:00
|
|
|
if (buttonMap.ButtonDown(gamefunc_Next_Weapon))
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
|
|
|
USERp u = User[pp->PlayerSprite];
|
|
|
|
short next_weapon = u->WeaponNum + 1;
|
|
|
|
short start_weapon;
|
|
|
|
|
2019-11-04 22:01:50 +00:00
|
|
|
buttonMap.ClearButton(gamefunc_Next_Weapon);
|
2015-05-19 21:54:34 +00:00
|
|
|
|
|
|
|
start_weapon = u->WeaponNum + 1;
|
|
|
|
|
|
|
|
if (u->WeaponNum == WPN_SWORD)
|
|
|
|
start_weapon = WPN_STAR;
|
|
|
|
|
|
|
|
if (u->WeaponNum == WPN_FIST)
|
|
|
|
{
|
|
|
|
next_weapon = 14;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
next_weapon = -1;
|
|
|
|
for (i = start_weapon; TRUE; i++)
|
|
|
|
{
|
|
|
|
if (i >= MAX_WEAPONS_KEYS)
|
|
|
|
{
|
|
|
|
next_weapon = 13;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (TEST(pp->WpnFlags, BIT(i)) && pp->WpnAmmo[i])
|
|
|
|
{
|
|
|
|
next_weapon = i;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
SET(loc->bits, next_weapon + 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2019-11-04 22:01:50 +00:00
|
|
|
if (buttonMap.ButtonDown(gamefunc_Previous_Weapon))
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
|
|
|
USERp u = User[pp->PlayerSprite];
|
|
|
|
short prev_weapon = u->WeaponNum - 1;
|
|
|
|
short start_weapon;
|
|
|
|
|
2019-11-04 22:01:50 +00:00
|
|
|
buttonMap.ClearButton(gamefunc_Previous_Weapon);
|
2015-05-19 21:54:34 +00:00
|
|
|
|
|
|
|
start_weapon = u->WeaponNum - 1;
|
|
|
|
|
|
|
|
if (u->WeaponNum == WPN_SWORD)
|
|
|
|
{
|
|
|
|
prev_weapon = 13;
|
|
|
|
}
|
|
|
|
else if (u->WeaponNum == WPN_STAR)
|
|
|
|
{
|
|
|
|
prev_weapon = 14;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
prev_weapon = -1;
|
|
|
|
for (i = start_weapon; TRUE; i--)
|
|
|
|
{
|
|
|
|
if (i <= -1)
|
|
|
|
i = WPN_HEART;
|
|
|
|
|
|
|
|
if (TEST(pp->WpnFlags, BIT(i)) && pp->WpnAmmo[i])
|
|
|
|
{
|
|
|
|
prev_weapon = i;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
SET(loc->bits, prev_weapon + 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
inv_hotkey = 0;
|
2019-11-04 22:01:50 +00:00
|
|
|
if (buttonMap.ButtonDown(gamefunc_Med_Kit))
|
2015-05-19 21:54:34 +00:00
|
|
|
inv_hotkey = INVENTORY_MEDKIT+1;
|
2019-11-04 22:01:50 +00:00
|
|
|
if (buttonMap.ButtonDown(gamefunc_Smoke_Bomb))
|
2015-05-19 21:54:34 +00:00
|
|
|
inv_hotkey = INVENTORY_CLOAK+1;
|
2019-11-04 22:01:50 +00:00
|
|
|
if (buttonMap.ButtonDown(gamefunc_Night_Vision))
|
2015-05-19 21:54:34 +00:00
|
|
|
inv_hotkey = INVENTORY_NIGHT_VISION+1;
|
2019-11-04 22:01:50 +00:00
|
|
|
if (buttonMap.ButtonDown(gamefunc_Gas_Bomb))
|
2015-05-19 21:54:34 +00:00
|
|
|
inv_hotkey = INVENTORY_CHEMBOMB+1;
|
2019-11-04 22:01:50 +00:00
|
|
|
if (buttonMap.ButtonDown(gamefunc_Flash_Bomb) && dimensionmode == 3)
|
2015-05-19 21:54:34 +00:00
|
|
|
inv_hotkey = INVENTORY_FLASHBOMB+1;
|
2019-11-04 22:01:50 +00:00
|
|
|
if (buttonMap.ButtonDown(gamefunc_Caltrops))
|
2015-05-19 21:54:34 +00:00
|
|
|
inv_hotkey = INVENTORY_CALTROPS+1;
|
|
|
|
|
|
|
|
SET(loc->bits, inv_hotkey<<SK_INV_HOTKEY_BIT0);
|
|
|
|
|
2019-11-04 22:01:50 +00:00
|
|
|
SET_LOC_KEY(loc->bits, SK_INV_USE, buttonMap.ButtonDown(gamefunc_Inventory));
|
2015-05-19 21:54:34 +00:00
|
|
|
|
2019-11-04 22:01:50 +00:00
|
|
|
SET_LOC_KEY(loc->bits, SK_OPERATE, buttonMap.ButtonDown(gamefunc_Open));
|
|
|
|
SET_LOC_KEY(loc->bits, SK_JUMP, buttonMap.ButtonDown(gamefunc_Jump));
|
|
|
|
SET_LOC_KEY(loc->bits, SK_CRAWL, buttonMap.ButtonDown(gamefunc_Crouch));
|
2015-05-19 21:54:34 +00:00
|
|
|
|
2019-11-04 22:01:50 +00:00
|
|
|
SET_LOC_KEY(loc->bits, SK_TURN_180, buttonMap.ButtonDown(gamefunc_TurnAround));
|
2015-05-19 21:54:34 +00:00
|
|
|
|
2019-11-04 22:01:50 +00:00
|
|
|
SET_LOC_KEY(loc->bits, SK_INV_LEFT, buttonMap.ButtonDown(gamefunc_Inventory_Left));
|
|
|
|
SET_LOC_KEY(loc->bits, SK_INV_RIGHT, buttonMap.ButtonDown(gamefunc_Inventory_Right));
|
2015-05-19 21:54:34 +00:00
|
|
|
|
2019-11-04 22:01:50 +00:00
|
|
|
SET_LOC_KEY(loc->bits, SK_HIDE_WEAPON, buttonMap.ButtonDown(gamefunc_Holster_Weapon));
|
2015-05-19 21:54:34 +00:00
|
|
|
|
|
|
|
// need BUTTON
|
2019-11-03 23:53:55 +00:00
|
|
|
SET_LOC_KEY(loc->bits, SK_CRAWL_LOCK, inputState.GetKeyStatus(KEYSC_NUM));
|
2015-05-19 21:54:34 +00:00
|
|
|
|
|
|
|
if (gNet.MultiGameType == MULTI_GAME_COOPERATIVE)
|
|
|
|
{
|
2019-11-04 22:01:50 +00:00
|
|
|
if (buttonMap.ButtonDown(gamefunc_See_Co_Op_View))
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
2019-11-04 22:01:50 +00:00
|
|
|
buttonMap.ClearButton(gamefunc_See_Co_Op_View);
|
2015-05-19 21:54:34 +00:00
|
|
|
|
|
|
|
screenpeek = connectpoint2[screenpeek];
|
|
|
|
|
|
|
|
if (screenpeek < 0)
|
|
|
|
screenpeek = connecthead;
|
|
|
|
|
|
|
|
if (dimensionmode != 2 && screenpeek == myconnectindex)
|
|
|
|
{
|
|
|
|
// JBF: figure out what's going on here
|
|
|
|
memcpy(pp->temp_pal, palette_data, sizeof(palette_data));
|
|
|
|
DoPlayerDivePalette(pp); // Check Dive again
|
|
|
|
DoPlayerNightVisionPalette(pp); // Check Night Vision again
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
PLAYERp tp = Player+screenpeek;
|
|
|
|
|
|
|
|
if (tp->FadeAmt<=0)
|
|
|
|
memcpy(pp->temp_pal, palette_data, sizeof(palette_data));
|
|
|
|
else
|
|
|
|
memcpy(pp->temp_pal, tp->temp_pal, sizeof(tp->temp_pal));
|
|
|
|
DoPlayerDivePalette(tp);
|
|
|
|
DoPlayerNightVisionPalette(tp);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#if DEBUG
|
|
|
|
DebugKeys(pp);
|
|
|
|
|
|
|
|
if (!CommEnabled) // Single player only keys
|
|
|
|
SinglePlayInput(pp);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
FunctionKeys(pp);
|
|
|
|
|
2019-11-04 22:01:50 +00:00
|
|
|
if (buttonMap.ButtonDown(gamefunc_Toggle_Crosshair))
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
2019-11-04 22:01:50 +00:00
|
|
|
buttonMap.ClearButton(gamefunc_Toggle_Crosshair);
|
2015-05-19 21:54:34 +00:00
|
|
|
pToggleCrosshair(pp);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#define MAP_WHITE_SECTOR (LT_GREY + 2)
|
|
|
|
#define MAP_RED_SECTOR (RED + 6)
|
|
|
|
#define MAP_FLOOR_SPRITE (RED + 8)
|
|
|
|
#define MAP_ENEMY (RED + 10)
|
|
|
|
#define MAP_SPRITE (FIRE + 8)
|
|
|
|
#define MAP_PLAYER (GREEN + 6)
|
|
|
|
|
|
|
|
#define MAP_BLOCK_SPRITE (DK_BLUE + 6)
|
|
|
|
|
|
|
|
void drawoverheadmap(int cposx, int cposy, int czoom, short cang)
|
|
|
|
{
|
|
|
|
int i, j, k, l, x1, y1, x2, y2, x3, y3, x4, y4, ox, oy, xoff, yoff;
|
|
|
|
int dax, day, cosang, sinang, xspan, yspan, sprx, spry;
|
|
|
|
int xrepeat, yrepeat, z1, z2, startwall, endwall, tilenum, daang;
|
|
|
|
int xvect, yvect, xvect2, yvect2;
|
|
|
|
char col;
|
|
|
|
walltype *wal, *wal2;
|
|
|
|
spritetype *spr;
|
|
|
|
short p;
|
|
|
|
static int pspr_ndx[8]= {0,0,0,0,0,0,0,0};
|
2015-05-19 21:58:29 +00:00
|
|
|
SWBOOL sprisplayer = FALSE;
|
2015-05-19 21:54:34 +00:00
|
|
|
short txt_x, txt_y;
|
|
|
|
|
|
|
|
// draw location text
|
|
|
|
if (gs.BorderNum <= BORDER_BAR-1)
|
|
|
|
{
|
|
|
|
txt_x = 7;
|
|
|
|
txt_y = 168;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
txt_x = 7;
|
|
|
|
txt_y = 147;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ScrollMode2D)
|
|
|
|
{
|
|
|
|
minigametext(txt_x,txt_y-7,"Follow Mode",0,2+8);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (UserMapName[0])
|
|
|
|
sprintf(ds,"%s",UserMapName);
|
|
|
|
else
|
|
|
|
sprintf(ds,"%s",LevelInfo[Level].Description);
|
|
|
|
|
|
|
|
minigametext(txt_x,txt_y,ds,0,2+8);
|
|
|
|
|
|
|
|
//////////////////////////////////
|
|
|
|
|
|
|
|
xvect = sintable[(2048 - cang) & 2047] * czoom;
|
|
|
|
yvect = sintable[(1536 - cang) & 2047] * czoom;
|
2017-06-24 09:20:21 +00:00
|
|
|
xvect2 = mulscale16(xvect, yxaspect);
|
|
|
|
yvect2 = mulscale16(yvect, yxaspect);
|
2015-05-19 21:54:34 +00:00
|
|
|
|
|
|
|
// Draw red lines
|
|
|
|
for (i = 0; i < numsectors; i++)
|
|
|
|
{
|
|
|
|
startwall = sector[i].wallptr;
|
|
|
|
endwall = sector[i].wallptr + sector[i].wallnum - 1;
|
|
|
|
|
|
|
|
z1 = sector[i].ceilingz;
|
|
|
|
z2 = sector[i].floorz;
|
|
|
|
|
|
|
|
for (j = startwall, wal = &wall[startwall]; j <= endwall; j++, wal++)
|
|
|
|
{
|
|
|
|
k = wal->nextwall;
|
2019-11-27 07:33:34 +00:00
|
|
|
if ((unsigned)k >= MAXWALLS)
|
2015-05-19 21:54:34 +00:00
|
|
|
continue;
|
|
|
|
|
|
|
|
if ((show2dwall[j >> 3] & (1 << (j & 7))) == 0)
|
|
|
|
continue;
|
|
|
|
if ((k > j) && ((show2dwall[k >> 3] & (1 << (k & 7))) > 0))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (sector[wal->nextsector].ceilingz == z1)
|
|
|
|
if (sector[wal->nextsector].floorz == z2)
|
|
|
|
if (((wal->cstat | wall[wal->nextwall].cstat) & (16 + 32)) == 0)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
col = 152;
|
|
|
|
|
|
|
|
//if (dimensionmode == 2)
|
|
|
|
if (dimensionmode == 6)
|
|
|
|
{
|
|
|
|
if (sector[i].floorz != sector[i].ceilingz)
|
|
|
|
if (sector[wal->nextsector].floorz != sector[wal->nextsector].ceilingz)
|
|
|
|
if (((wal->cstat | wall[wal->nextwall].cstat) & (16 + 32)) == 0)
|
|
|
|
if (sector[i].floorz == sector[wal->nextsector].floorz)
|
|
|
|
continue;
|
|
|
|
if (sector[i].floorpicnum != sector[wal->nextsector].floorpicnum)
|
|
|
|
continue;
|
|
|
|
if (sector[i].floorshade != sector[wal->nextsector].floorshade)
|
|
|
|
continue;
|
2019-11-17 17:02:17 +00:00
|
|
|
col = 12; // 1=white / 31=black / 44=green / 56=pink / 128=yellow / 210=blue / 248=orange / 255=purple
|
2015-05-19 21:54:34 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
ox = wal->x - cposx;
|
|
|
|
oy = wal->y - cposy;
|
2017-06-24 09:20:21 +00:00
|
|
|
x1 = mulscale16(ox, xvect) - mulscale16(oy, yvect);
|
|
|
|
y1 = mulscale16(oy, xvect2) + mulscale16(ox, yvect2);
|
2015-05-19 21:54:34 +00:00
|
|
|
|
|
|
|
wal2 = &wall[wal->point2];
|
|
|
|
ox = wal2->x - cposx;
|
|
|
|
oy = wal2->y - cposy;
|
2017-06-24 09:20:21 +00:00
|
|
|
x2 = mulscale16(ox, xvect) - mulscale16(oy, yvect);
|
|
|
|
y2 = mulscale16(oy, xvect2) + mulscale16(ox, yvect2);
|
2015-05-19 21:54:34 +00:00
|
|
|
|
2019-04-08 06:26:36 +00:00
|
|
|
renderDrawLine(x1 + (xdim << 11), y1 + (ydim << 11), x2 + (xdim << 11), y2 + (ydim << 11), col);
|
2015-05-19 21:54:34 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Draw sprites
|
|
|
|
k = Player[screenpeek].PlayerSprite;
|
|
|
|
for (i = 0; i < numsectors; i++)
|
|
|
|
for (j = headspritesect[i]; j >= 0; j = nextspritesect[j])
|
|
|
|
{
|
|
|
|
for (p=connecthead; p >= 0; p=connectpoint2[p])
|
|
|
|
{
|
|
|
|
if (Player[p].PlayerSprite == j)
|
|
|
|
{
|
|
|
|
if (sprite[Player[p].PlayerSprite].xvel > 16)
|
2019-08-27 13:39:54 +00:00
|
|
|
pspr_ndx[myconnectindex] = (((int32_t) totalclock>>4)&3);
|
2015-05-19 21:54:34 +00:00
|
|
|
sprisplayer = TRUE;
|
|
|
|
|
|
|
|
goto SHOWSPRITE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if ((show2dsprite[j >> 3] & (1 << (j & 7))) > 0)
|
|
|
|
{
|
|
|
|
SHOWSPRITE:
|
|
|
|
spr = &sprite[j];
|
|
|
|
|
2019-11-17 17:02:17 +00:00
|
|
|
col = 56; // 1=white / 31=black / 44=green / 56=pink / 128=yellow / 210=blue / 248=orange / 255=purple
|
2015-05-19 21:54:34 +00:00
|
|
|
if ((spr->cstat & 1) > 0)
|
|
|
|
col = 248;
|
|
|
|
if (j == k)
|
|
|
|
col = 31;
|
|
|
|
|
|
|
|
sprx = spr->x;
|
|
|
|
spry = spr->y;
|
|
|
|
|
|
|
|
k = spr->statnum;
|
|
|
|
if ((k >= 1) && (k <= 8) && (k != 2)) // Interpolate moving
|
|
|
|
{
|
|
|
|
sprx = sprite[j].x;
|
|
|
|
spry = sprite[j].y;
|
|
|
|
}
|
|
|
|
|
|
|
|
switch (spr->cstat & 48)
|
|
|
|
{
|
|
|
|
case 0: // Regular sprite
|
|
|
|
if (Player[p].PlayerSprite == j)
|
|
|
|
{
|
|
|
|
ox = sprx - cposx;
|
|
|
|
oy = spry - cposy;
|
2017-06-24 09:20:21 +00:00
|
|
|
x1 = mulscale16(ox, xvect) - mulscale16(oy, yvect);
|
|
|
|
y1 = mulscale16(oy, xvect2) + mulscale16(ox, yvect2);
|
2015-05-19 21:54:34 +00:00
|
|
|
|
|
|
|
if (dimensionmode == 5 && (gNet.MultiGameType != MULTI_GAME_COMMBAT || j == Player[screenpeek].PlayerSprite))
|
|
|
|
{
|
|
|
|
ox = (sintable[(spr->ang + 512) & 2047] >> 7);
|
|
|
|
oy = (sintable[(spr->ang) & 2047] >> 7);
|
2017-06-24 09:20:21 +00:00
|
|
|
x2 = mulscale16(ox, xvect) - mulscale16(oy, yvect);
|
|
|
|
y2 = mulscale16(oy, xvect) + mulscale16(ox, yvect);
|
2015-05-19 21:54:34 +00:00
|
|
|
|
|
|
|
if (j == Player[screenpeek].PlayerSprite)
|
|
|
|
{
|
|
|
|
x2 = 0L;
|
|
|
|
y2 = -(czoom << 5);
|
|
|
|
}
|
|
|
|
|
2017-06-24 09:20:21 +00:00
|
|
|
x3 = mulscale16(x2, yxaspect);
|
|
|
|
y3 = mulscale16(y2, yxaspect);
|
2015-05-19 21:54:34 +00:00
|
|
|
|
2019-04-08 06:26:36 +00:00
|
|
|
renderDrawLine(x1 - x2 + (xdim << 11), y1 - y3 + (ydim << 11),
|
|
|
|
x1 + x2 + (xdim << 11), y1 + y3 + (ydim << 11), col);
|
|
|
|
renderDrawLine(x1 - y2 + (xdim << 11), y1 + x3 + (ydim << 11),
|
|
|
|
x1 + x2 + (xdim << 11), y1 + y3 + (ydim << 11), col);
|
|
|
|
renderDrawLine(x1 + y2 + (xdim << 11), y1 - x3 + (ydim << 11),
|
|
|
|
x1 + x2 + (xdim << 11), y1 + y3 + (ydim << 11), col);
|
2015-05-19 21:54:34 +00:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (((gotsector[i >> 3] & (1 << (i & 7))) > 0) && (czoom > 192))
|
|
|
|
{
|
|
|
|
daang = (spr->ang - cang) & 2047;
|
|
|
|
if (j == Player[screenpeek].PlayerSprite)
|
|
|
|
{
|
|
|
|
x1 = 0;
|
|
|
|
//y1 = (yxaspect << 2);
|
|
|
|
y1 = 0;
|
|
|
|
daang = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Special case tiles
|
|
|
|
if (spr->picnum == 3123) break;
|
|
|
|
|
|
|
|
if (sprisplayer)
|
|
|
|
{
|
|
|
|
if (gNet.MultiGameType != MULTI_GAME_COMMBAT || j == Player[screenpeek].PlayerSprite)
|
2017-06-24 09:20:21 +00:00
|
|
|
rotatesprite((x1 << 4) + (xdim << 15), (y1 << 4) + (ydim << 15), mulscale16(czoom * (spr->yrepeat), yxaspect), daang, 1196+pspr_ndx[myconnectindex], spr->shade, spr->pal, (spr->cstat & 2) >> 1, windowxy1.x, windowxy1.y, windowxy2.x, windowxy2.y);
|
2015-05-19 21:54:34 +00:00
|
|
|
}
|
|
|
|
else
|
2017-06-24 09:20:21 +00:00
|
|
|
rotatesprite((x1 << 4) + (xdim << 15), (y1 << 4) + (ydim << 15), mulscale16(czoom * (spr->yrepeat), yxaspect), daang, spr->picnum, spr->shade, spr->pal, (spr->cstat & 2) >> 1, windowxy1.x, windowxy1.y, windowxy2.x, windowxy2.y);
|
2015-05-19 21:54:34 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case 16: // Rotated sprite
|
|
|
|
x1 = sprx;
|
|
|
|
y1 = spry;
|
|
|
|
tilenum = spr->picnum;
|
2015-05-19 22:01:44 +00:00
|
|
|
xoff = (int)picanm[tilenum].xofs + (int)spr->xoffset;
|
2015-05-19 21:54:34 +00:00
|
|
|
if ((spr->cstat & 4) > 0)
|
|
|
|
xoff = -xoff;
|
|
|
|
k = spr->ang;
|
|
|
|
l = spr->xrepeat;
|
|
|
|
dax = sintable[k & 2047] * l;
|
|
|
|
day = sintable[(k + 1536) & 2047] * l;
|
2015-05-19 22:02:25 +00:00
|
|
|
l = tilesiz[tilenum].x;
|
2015-05-19 21:54:34 +00:00
|
|
|
k = (l >> 1) + xoff;
|
2017-06-24 09:20:21 +00:00
|
|
|
x1 -= mulscale16(dax, k);
|
|
|
|
x2 = x1 + mulscale16(dax, l);
|
|
|
|
y1 -= mulscale16(day, k);
|
|
|
|
y2 = y1 + mulscale16(day, l);
|
2015-05-19 21:54:34 +00:00
|
|
|
|
|
|
|
ox = x1 - cposx;
|
|
|
|
oy = y1 - cposy;
|
2017-06-24 09:20:21 +00:00
|
|
|
x1 = mulscale16(ox, xvect) - mulscale16(oy, yvect);
|
|
|
|
y1 = mulscale16(oy, xvect2) + mulscale16(ox, yvect2);
|
2015-05-19 21:54:34 +00:00
|
|
|
|
|
|
|
ox = x2 - cposx;
|
|
|
|
oy = y2 - cposy;
|
2017-06-24 09:20:21 +00:00
|
|
|
x2 = mulscale16(ox, xvect) - mulscale16(oy, yvect);
|
|
|
|
y2 = mulscale16(oy, xvect2) + mulscale16(ox, yvect2);
|
2015-05-19 21:54:34 +00:00
|
|
|
|
2019-04-08 06:26:36 +00:00
|
|
|
renderDrawLine(x1 + (xdim << 11), y1 + (ydim << 11),
|
|
|
|
x2 + (xdim << 11), y2 + (ydim << 11), col);
|
2015-05-19 21:54:34 +00:00
|
|
|
|
|
|
|
break;
|
|
|
|
case 32: // Floor sprite
|
|
|
|
if (dimensionmode == 5)
|
|
|
|
{
|
|
|
|
tilenum = spr->picnum;
|
2015-05-19 22:01:44 +00:00
|
|
|
xoff = (int)picanm[tilenum].xofs + (int)spr->xoffset;
|
|
|
|
yoff = (int)picanm[tilenum].yofs + (int)spr->yoffset;
|
2015-05-19 21:54:34 +00:00
|
|
|
if ((spr->cstat & 4) > 0)
|
|
|
|
xoff = -xoff;
|
|
|
|
if ((spr->cstat & 8) > 0)
|
|
|
|
yoff = -yoff;
|
|
|
|
|
|
|
|
k = spr->ang;
|
|
|
|
cosang = sintable[(k + 512) & 2047];
|
|
|
|
sinang = sintable[k];
|
2015-05-19 22:02:25 +00:00
|
|
|
xspan = tilesiz[tilenum].x;
|
2015-05-19 21:54:34 +00:00
|
|
|
xrepeat = spr->xrepeat;
|
2015-05-19 22:02:25 +00:00
|
|
|
yspan = tilesiz[tilenum].y;
|
2015-05-19 21:54:34 +00:00
|
|
|
yrepeat = spr->yrepeat;
|
|
|
|
|
|
|
|
dax = ((xspan >> 1) + xoff) * xrepeat;
|
|
|
|
day = ((yspan >> 1) + yoff) * yrepeat;
|
2017-06-24 09:20:21 +00:00
|
|
|
x1 = sprx + mulscale16(sinang, dax) + mulscale16(cosang, day);
|
|
|
|
y1 = spry + mulscale16(sinang, day) - mulscale16(cosang, dax);
|
2015-05-19 21:54:34 +00:00
|
|
|
l = xspan * xrepeat;
|
2017-06-24 09:20:21 +00:00
|
|
|
x2 = x1 - mulscale16(sinang, l);
|
|
|
|
y2 = y1 + mulscale16(cosang, l);
|
2015-05-19 21:54:34 +00:00
|
|
|
l = yspan * yrepeat;
|
2017-06-24 09:20:21 +00:00
|
|
|
k = -mulscale16(cosang, l);
|
2015-05-19 21:54:34 +00:00
|
|
|
x3 = x2 + k;
|
|
|
|
x4 = x1 + k;
|
2017-06-24 09:20:21 +00:00
|
|
|
k = -mulscale16(sinang, l);
|
2015-05-19 21:54:34 +00:00
|
|
|
y3 = y2 + k;
|
|
|
|
y4 = y1 + k;
|
|
|
|
|
|
|
|
ox = x1 - cposx;
|
|
|
|
oy = y1 - cposy;
|
2017-06-24 09:20:21 +00:00
|
|
|
x1 = mulscale16(ox, xvect) - mulscale16(oy, yvect);
|
|
|
|
y1 = mulscale16(oy, xvect2) + mulscale16(ox, yvect2);
|
2015-05-19 21:54:34 +00:00
|
|
|
|
|
|
|
ox = x2 - cposx;
|
|
|
|
oy = y2 - cposy;
|
2017-06-24 09:20:21 +00:00
|
|
|
x2 = mulscale16(ox, xvect) - mulscale16(oy, yvect);
|
|
|
|
y2 = mulscale16(oy, xvect2) + mulscale16(ox, yvect2);
|
2015-05-19 21:54:34 +00:00
|
|
|
|
|
|
|
ox = x3 - cposx;
|
|
|
|
oy = y3 - cposy;
|
2017-06-24 09:20:21 +00:00
|
|
|
x3 = mulscale16(ox, xvect) - mulscale16(oy, yvect);
|
|
|
|
y3 = mulscale16(oy, xvect2) + mulscale16(ox, yvect2);
|
2015-05-19 21:54:34 +00:00
|
|
|
|
|
|
|
ox = x4 - cposx;
|
|
|
|
oy = y4 - cposy;
|
2017-06-24 09:20:21 +00:00
|
|
|
x4 = mulscale16(ox, xvect) - mulscale16(oy, yvect);
|
|
|
|
y4 = mulscale16(oy, xvect2) + mulscale16(ox, yvect2);
|
2015-05-19 21:54:34 +00:00
|
|
|
|
2019-04-08 06:26:36 +00:00
|
|
|
renderDrawLine(x1 + (xdim << 11), y1 + (ydim << 11),
|
|
|
|
x2 + (xdim << 11), y2 + (ydim << 11), col);
|
2015-05-19 21:54:34 +00:00
|
|
|
|
2019-04-08 06:26:36 +00:00
|
|
|
renderDrawLine(x2 + (xdim << 11), y2 + (ydim << 11),
|
|
|
|
x3 + (xdim << 11), y3 + (ydim << 11), col);
|
2015-05-19 21:54:34 +00:00
|
|
|
|
2019-04-08 06:26:36 +00:00
|
|
|
renderDrawLine(x3 + (xdim << 11), y3 + (ydim << 11),
|
|
|
|
x4 + (xdim << 11), y4 + (ydim << 11), col);
|
2015-05-19 21:54:34 +00:00
|
|
|
|
2019-04-08 06:26:36 +00:00
|
|
|
renderDrawLine(x4 + (xdim << 11), y4 + (ydim << 11),
|
|
|
|
x1 + (xdim << 11), y1 + (ydim << 11), col);
|
2015-05-19 21:54:34 +00:00
|
|
|
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// Draw white lines
|
|
|
|
for (i = 0; i < numsectors; i++)
|
|
|
|
{
|
|
|
|
startwall = sector[i].wallptr;
|
|
|
|
endwall = sector[i].wallptr + sector[i].wallnum - 1;
|
|
|
|
|
|
|
|
for (j = startwall, wal = &wall[startwall]; j <= endwall; j++, wal++)
|
|
|
|
{
|
2019-11-27 07:33:34 +00:00
|
|
|
if ((uint16_t)wal->nextwall < MAXWALLS)
|
2015-05-19 21:54:34 +00:00
|
|
|
continue;
|
|
|
|
|
|
|
|
if ((show2dwall[j >> 3] & (1 << (j & 7))) == 0)
|
|
|
|
continue;
|
|
|
|
|
2015-05-19 22:02:25 +00:00
|
|
|
if (tilesiz[wal->picnum].x == 0)
|
2015-05-19 21:54:34 +00:00
|
|
|
continue;
|
2015-05-19 22:02:25 +00:00
|
|
|
if (tilesiz[wal->picnum].y == 0)
|
2015-05-19 21:54:34 +00:00
|
|
|
continue;
|
|
|
|
|
|
|
|
ox = wal->x - cposx;
|
|
|
|
oy = wal->y - cposy;
|
2017-06-24 09:20:21 +00:00
|
|
|
x1 = mulscale16(ox, xvect) - mulscale16(oy, yvect);
|
|
|
|
y1 = mulscale16(oy, xvect2) + mulscale16(ox, yvect2);
|
2015-05-19 21:54:34 +00:00
|
|
|
|
|
|
|
wal2 = &wall[wal->point2];
|
|
|
|
ox = wal2->x - cposx;
|
|
|
|
oy = wal2->y - cposy;
|
2017-06-24 09:20:21 +00:00
|
|
|
x2 = mulscale16(ox, xvect) - mulscale16(oy, yvect);
|
|
|
|
y2 = mulscale16(oy, xvect2) + mulscale16(ox, yvect2);
|
2015-05-19 21:54:34 +00:00
|
|
|
|
2019-04-08 06:26:36 +00:00
|
|
|
renderDrawLine(x1 + (xdim << 11), y1 + (ydim << 11), x2 + (xdim << 11), y2 + (ydim << 11), 24);
|
2015-05-19 21:54:34 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
#if RANDOM_DEBUG
|
2019-11-17 17:02:17 +00:00
|
|
|
int RandomRange(int range, char *file, unsigned line)
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
2015-05-19 21:58:29 +00:00
|
|
|
uint32_t rand_num;
|
|
|
|
uint32_t value;
|
2015-05-19 21:54:34 +00:00
|
|
|
extern FILE *fout_err;
|
2015-05-19 21:58:29 +00:00
|
|
|
extern uint32_t MoveThingsCount;
|
2015-05-19 21:54:34 +00:00
|
|
|
|
|
|
|
if (RandomPrint && !Prediction)
|
|
|
|
{
|
|
|
|
sprintf(ds,"mtc %d, %s, line %d, %d",MoveThingsCount,file,line,randomseed);
|
|
|
|
DebugWriteString(ds);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (range <= 0)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
rand_num = krand2();
|
|
|
|
|
|
|
|
if (rand_num == 65535U)
|
|
|
|
rand_num--;
|
|
|
|
|
|
|
|
// shift values to give more precision
|
|
|
|
value = (rand_num << 14) / ((65535UL << 14) / range);
|
|
|
|
|
|
|
|
if (value >= range)
|
|
|
|
value = range - 1;
|
|
|
|
|
|
|
|
return value;
|
|
|
|
}
|
|
|
|
#else
|
2019-11-17 17:02:17 +00:00
|
|
|
int RandomRange(int range)
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
2015-05-19 21:58:29 +00:00
|
|
|
uint32_t rand_num;
|
|
|
|
uint32_t value;
|
2015-05-19 21:54:34 +00:00
|
|
|
|
|
|
|
if (range <= 0)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
rand_num = RANDOM();
|
|
|
|
|
|
|
|
if (rand_num == 65535U)
|
|
|
|
rand_num--;
|
|
|
|
|
|
|
|
// shift values to give more precision
|
|
|
|
value = (rand_num << 14) / ((65535UL << 14) / range);
|
|
|
|
|
2015-05-19 21:58:29 +00:00
|
|
|
if (value >= (uint32_t)range)
|
2015-05-19 21:54:34 +00:00
|
|
|
value = range - 1;
|
|
|
|
|
|
|
|
return value;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2019-11-17 17:02:17 +00:00
|
|
|
int StdRandomRange(int range)
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
2015-05-19 21:58:29 +00:00
|
|
|
uint32_t rand_num;
|
|
|
|
uint32_t value;
|
2015-05-19 21:54:34 +00:00
|
|
|
|
|
|
|
if (range <= 0)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
rand_num = STD_RANDOM();
|
|
|
|
|
|
|
|
if (rand_num == RAND_MAX)
|
|
|
|
rand_num--;
|
|
|
|
|
|
|
|
// shift values to give more precision
|
|
|
|
#if (RAND_MAX > 0x7fff)
|
|
|
|
value = rand_num / (((int)RAND_MAX) / range);
|
|
|
|
#else
|
|
|
|
value = (rand_num << 14) / ((((int)RAND_MAX) << 14) / range);
|
|
|
|
#endif
|
|
|
|
|
2015-05-19 21:58:29 +00:00
|
|
|
if (value >= (uint32_t)range)
|
2015-05-19 21:54:34 +00:00
|
|
|
value = range - 1;
|
|
|
|
|
|
|
|
return value;
|
|
|
|
}
|
|
|
|
|
2019-04-08 06:27:15 +00:00
|
|
|
// [JM] Probably will need some doing over. !CHECKME!
|
|
|
|
void G_Polymer_UnInit(void) { }
|
|
|
|
|
|
|
|
|
2015-05-19 21:54:34 +00:00
|
|
|
#include "saveable.h"
|
|
|
|
|
2019-11-28 23:22:01 +00:00
|
|
|
saveable_module saveable_build{};
|
2015-05-19 21:54:34 +00:00
|
|
|
|
2019-11-28 23:22:01 +00:00
|
|
|
void Saveable_Init_Dynamic()
|
2015-05-19 21:54:34 +00:00
|
|
|
{
|
2019-11-28 23:22:01 +00:00
|
|
|
static saveable_data saveable_build_data[] =
|
|
|
|
{
|
|
|
|
{sector, MAXSECTORS*sizeof(sectortype)},
|
|
|
|
{sprite, MAXSPRITES*sizeof(spritetype)},
|
|
|
|
{wall, MAXWALLS*sizeof(walltype)},
|
|
|
|
};
|
2015-05-19 21:54:34 +00:00
|
|
|
|
2019-11-28 23:22:01 +00:00
|
|
|
saveable_build.data = saveable_build_data;
|
|
|
|
saveable_build.numdata = NUM_SAVEABLE_ITEMS(saveable_build_data);
|
|
|
|
}
|
2015-05-19 21:54:34 +00:00
|
|
|
|
2019-11-03 11:32:58 +00:00
|
|
|
/*extern*/ bool GameInterface::validate_hud(int requested_size) { return requested_size; }
|
|
|
|
/*extern*/ void GameInterface::set_hud_layout(int requested_size) { /* the relevant setting is gs.BorderNum */}
|
|
|
|
/*extern*/ void GameInterface::set_hud_scale(int requested_size) { /* the relevant setting is gs.BorderNum */ }
|
|
|
|
|
2019-11-06 18:22:14 +00:00
|
|
|
bool GameInterface::mouseInactiveConditional(bool condition)
|
|
|
|
{
|
|
|
|
return condition;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2019-11-03 11:32:58 +00:00
|
|
|
::GameInterface* CreateInterface()
|
|
|
|
{
|
|
|
|
return new GameInterface;
|
|
|
|
}
|
|
|
|
|
2019-10-09 18:14:04 +00:00
|
|
|
|
2019-10-09 16:09:05 +00:00
|
|
|
END_SW_NS
|