void
ProcessUtilityKeys (void)
{
if (ImmediateInputState.menu[KEY_ABORT])
{
log_showBox (false, false);
exit (EXIT_SUCCESS);
}
if (ImmediateInputState.menu[KEY_FULLSCREEN])
{
int flags = GfxFlags ^ TFB_GFXFLAGS_FULLSCREEN;
// clear ImmediateInputState so we don't repeat this next frame
FlushInput ();
TFB_DrawScreen_ReinitVideo (GraphicsDriver, flags, ScreenWidthActual,
ScreenHeightActual);
}
#if defined(DEBUG) || defined(USE_DEBUG_KEY)
if (ImmediateInputState.menu[KEY_DEBUG])
{
// clear ImmediateInputState so we don't repeat this next frame
FlushInput ();
debugKeyPressed ();
}
#endif /* DEBUG */
}
/*** printerror - print error message on status line
*
* prints a formatted error message on the status line, and then waits for a
* keystroke. Once hit, the message is cleared.
*
* Input:
* printf style parameters
*
* Output:
* Number of characters output in error message
*
*************************************************************************/
int
printerror (
char *pszFmt,
...
) {
buffer bufLocal;
va_list Arguments;
REGISTER int cch;
va_start(Arguments, pszFmt);
ZFormat (bufLocal, pszFmt, Arguments);
fReDraw = TRUE;
bell ();
FlushInput ();
cch = soutb (0, YSIZE, bufLocal, errColor);
if (fErrPrompt) {
asserte (*GetMsg (MSG_PRESS_ANY, bufLocal));
soutb (XSIZE-strlen(bufLocal)-1, YSIZE, bufLocal, errColor);
SetEvent( semIdle );
ReadChar ();
WaitForSingleObject(semIdle, INFINITE);
bufLocal[0] = ' ';
bufLocal[1] = '\0';
soutb(0, YSIZE, bufLocal, errColor);
}
va_end(Arguments);
return cch;
}
void
DoInput (void *pInputState, BOOLEAN resetInput)
{
if (resetInput)
FlushInput ();
do
{
MENU_SOUND_FLAGS soundFlags;
Async_process ();
TaskSwitch ();
UpdateInputState ();
#if DEMO_MODE || CREATE_JOURNAL
if (ArrowInput != DemoInput)
#endif
{
#if CREATE_JOURNAL
JournalInput (InputState);
#endif /* CREATE_JOURNAL */
}
soundFlags = MenuKeysToSoundFlags (&PulsedInputState);
if (MenuSounds && (soundFlags & (sound_0 | sound_1)))
{
SOUND S;
S = MenuSounds;
if (soundFlags & sound_1)
S = SetAbsSoundIndex (S, MENU_SOUND_SUCCESS);
PlaySoundEffect (S, 0, NotPositional (), NULL, 0);
}
if (inputCallback)
inputCallback ();
} while (((INPUT_STATE_DESC*)pInputState)->InputFunc (pInputState));
if (resetInput)
FlushInput ();
}
CH263PayloadFormat::~CH263PayloadFormat()
{
HX_RELEASE(m_pCCF);
FlushInput();
FlushOutput();
delete m_pDepackHlpr;
m_pDepackHlpr = 0;
}
STDMETHODIMP CH263PayloadFormat::Reset()
{
// Called on Seeks
DPRINTF(D_H263, ("CH263PayloadFormat::Reset()\n"));
FlushInput();
FlushOutput();
m_state = NeedPSC;
return HXR_OK;
}
int GrToggleFullScreenGame (void)
{
static char szFullscreen [2][30] = {"toggling fullscreen mode off", "toggling fullscreen mode on"};
int i = GrToggleFullScreen ();
FlushInput ();
if (gameStates.app.bGameRunning) {
HUDMessage (MSGC_GAME_FEEDBACK, szFullscreen [i]);
StopPlayerMovement ();
}
return i;
}
int edit_message(const char *filename, SEND_HEADER *shdr,
const char *sel_editor)
{
/* Return 0 if successful, -1 on error. */
char buffer[SLEN];
int rc, return_value = 0, err;
/* pick default editor on NULL */
if (sel_editor == NULL)
sel_editor = (IS_BUILTIN(editor) ? alternative_editor : editor);
/* handle request for the builtin editor */
if (IS_BUILTIN(sel_editor))
return builtin_editor(filename, shdr);
/* we will be running an external editor */
PutLine(LINES, 0, catgets(elm_msg_cat, ElmSet, ElmInvokeEditor,
"Invoking editor..."));
if (strstr(sel_editor, "%s") != NULL)
sprintf(buffer, sel_editor, filename);
else
sprintf(buffer, "%s %s", sel_editor, filename);
chown(filename, userid, groupid);
if ((rc = system_call(buffer, SY_COOKED|SY_ENAB_SIGHUP|SY_DUMPSTATE)) < 0) {
err = errno;
dprint(1, (debugfile,
"System call failed with status %d (edit_message)\n", rc));
dprint(1, (debugfile, "** %s **\n", strerror(err)));
ClearLine(LINES-1);
show_error(catgets(elm_msg_cat, ElmSet, ElmCantInvokeEditor,
"Can't invoke editor '%s' for composition."), sel_editor);
if (sleepmsg > 0)
sleep(sleepmsg);
return_value = -1;
}
/* Flush input buffer. This is especially important under X,
* where accidental keystrokes in the elm window could make
* things messy.
*/
if (edit_flush)
FlushInput();
return return_value;
}
int32
PlainTextMessageIOGateway ::
DoInputImplementation(AbstractGatewayMessageReceiver & receiver, uint32 maxBytes)
{
TCHECKPOINT;
int32 ret = 0;
const int tempBufSize = 2048;
char buf[tempBufSize];
int32 bytesRead = GetDataIO()()->Read(buf, muscleMin(maxBytes, (uint32)(sizeof(buf)-1)));
if (bytesRead < 0)
{
FlushInput(receiver);
return -1;
}
if (bytesRead > 0)
{
uint32 filteredBytesRead = bytesRead;
FilterInputBuffer(buf, filteredBytesRead, sizeof(buf)-1);
ret += filteredBytesRead;
buf[filteredBytesRead] = '\0';
MessageRef inMsg; // demand-allocated
int32 beginAt = 0;
for (uint32 i=0; i<filteredBytesRead; i++)
{
char nextChar = buf[i];
if ((nextChar == '\r')||(nextChar == '\n'))
{
buf[i] = '\0'; // terminate the string here
if ((nextChar == '\r')||(_prevCharWasCarriageReturn == false)) inMsg = AddIncomingText(inMsg, &buf[beginAt]);
beginAt = i+1;
}
_prevCharWasCarriageReturn = (nextChar == '\r');
}
if (beginAt < (int32)filteredBytesRead)
{
if (_flushPartialIncomingLines) inMsg = AddIncomingText(inMsg, &buf[beginAt]);
else _incomingText += &buf[beginAt];
}
if (inMsg()) receiver.CallMessageReceivedFromGateway(inMsg);
}
return ret;
}
void
OpenJournal (void)
{
DWORD start_seed;
#if CREATE_JOURNAL
if (create_journal)
{
if (journal_fh = copen (journal_buf, MEMORY_STREAM, STREAM_WRITE))
{
start_seed = SeedRandomNumbers ();
cwrite ((PBYTE)&start_seed, sizeof (start_seed), 1, journal_fh);
}
}
else
#endif /* CREATE_JOURNAL */
{
uio_Stream *fp;
if (fp = res_OpenResFile ("starcon.jnl", "rb"))
{
ReadResFile (journal_buf, 1, sizeof (journal_buf), fp);
res_CloseResFile (fp);
if (journal_fh = copen (journal_buf, MEMORY_STREAM, STREAM_READ))
{
OldArrowInput = ArrowInput;
ArrowInput = DemoInput;
PlayerInput[0] = PlayerInput[1] = DemoInput;
FlushInput ();
cread ((PBYTE)&start_seed, sizeof (start_seed), 1, journal_fh);
TFB_SeedRandom (start_seed);
}
}
}
}
VIDEO_TYPE
VidPlay (VIDEO_REF VidRef, const char *loopname, BOOLEAN uninit)
// uninit was used to uninit the game kernel
// before spawning duck exe
{
VIDEO_TYPE ret;
TFB_VideoClip* vid = (TFB_VideoClip*) VidRef;
if (!vid)
return NO_FMV;
if (_cur_video)
TFB_StopVideo (_cur_video);
_cur_video = NULL_VIDEO_REF;
TFB_FadeClearScreen ();
FlushInput ();
LockMutex (GraphicsLock);
SetContext (ScreenContext);
// play video in the center of the screen
if (TFB_PlayVideo (VidRef, (SCREEN_WIDTH - vid->w) / 2,
(SCREEN_HEIGHT - vid->h) / 2))
{
_cur_video = VidRef;
ret = SOFTWARE_FMV;
}
else
{
ret = NO_FMV;
}
UnlockMutex (GraphicsLock);
/* dodge compiler warnings */
(void) loopname;
(void) uninit;
return ret;
}
//------------------------------------------------------------------------------
//returns number of item chosen
int MainMenu (void)
{
CMenu m;
int i, nChoice = 0, nOptions = 0;
IpxClose ();
//paletteManager.Load (MENU_PALETTE, NULL, 0, 1, 0); //get correct palette
if (!LOCALPLAYER.callsign [0]) {
SelectPlayer ();
return 0;
}
if (gameData.multiplayer.autoNG.bValid) {
ExecMultiMenuOption (mainOpts.nMulti);
return 0;
}
PrintLog ("launching main menu\n");
do {
nOptions = SetupMainMenu (m); // may have to change, eg, maybe selected pilot and no save games.
gameStates.input.keys.xLastPressTime = TimerGetFixedSeconds (); // .. 20 seconds from now!
if (nChoice < 0)
nChoice = 0;
gameStates.menus.bDrawCopyright = 1;
i = m.Menu ("", NULL, AutoDemoMenuCheck, &nChoice, BackgroundName (BG_MENU));
if (gameStates.app.bNostalgia)
gameOpts->app.nVersionFilter = 3;
if (i > -1) {
ExecMainMenuOption (nChoice);
SavePlayerProfile ();
}
} while (gameStates.app.nFunctionMode == FMODE_MENU);
if (gameStates.app.nFunctionMode == FMODE_GAME)
paletteManager.DisableEffect ();
FlushInput ();
return mainOpts.nChoice;
}
/*** disperr - display error message on status line
*
* prints a formatted error message on the status line, and then waits for a
* keystroke. Once hit, the message is cleared.
*
* Input:
* iMsg = index for message string to be retrieved and displayed.
* The string may have embedded printf formatting.
* ... = variable number of args per the formatted string
*
* Output:
* returns FALSE
*
*************************************************************************/
flagType
disperr (
int iMsg,
...
) {
buffer pszFmt; /* retrieved formatting string */
buffer bufLocal; /* formatted output line */
va_list Arguments;
assert (iMsg);
GetMsg (iMsg, pszFmt);
va_start(Arguments, iMsg);
ZFormat (bufLocal, pszFmt, Arguments);
fReDraw = TRUE;
bell ();
FlushInput ();
soutb (0, YSIZE, bufLocal, errColor);
if (fErrPrompt) {
asserte (*GetMsg (MSG_PRESS_ANY, bufLocal));
soutb (XSIZE-strlen(bufLocal)-1, YSIZE, bufLocal, errColor);
SetEvent( semIdle );
ReadChar ();
WaitForSingleObject(semIdle, INFINITE);
bufLocal[0] = ' ';
bufLocal[1] = '\0';
soutb(0, YSIZE, bufLocal, errColor);
}
va_end(Arguments);
return FALSE;
}
BOOLEAN
PauseGame (void)
{
RECT r;
STAMP s;
BOOLEAN ClockActive;
CONTEXT OldContext;
FRAME F;
HOT_SPOT OldHot;
if (ActivityFrame == 0
|| (GLOBAL (CurrentActivity) & (CHECK_ABORT | CHECK_PAUSE))
|| (LastActivity & (CHECK_LOAD | CHECK_RESTART)))
return (FALSE);
GLOBAL (CurrentActivity) |= CHECK_PAUSE;
ClockActive = (BOOLEAN)(
LOBYTE (GLOBAL (CurrentActivity)) != SUPER_MELEE
&& GameClockRunning ()
);
if (ClockActive)
SuspendGameClock ();
else if (CommData.ConversationPhrases && PlayingTrack ())
PauseTrack ();
SetSemaphore (GraphicsSem);
OldContext = SetContext (ScreenContext);
OldHot = SetFrameHot (Screen, MAKE_HOT_SPOT (0, 0));
GetFrameRect (ActivityFrame, &r);
r.corner.x = (SCREEN_WIDTH - r.extent.width) >> 1;
r.corner.y = (SCREEN_HEIGHT - r.extent.height) >> 1;
s.origin = r.corner;
s.frame = ActivityFrame;
F = CaptureDrawable (LoadDisplayPixmap (&r, (FRAME)0));
DrawStamp (&s);
FlushGraphics ();
{
BYTE scan;
scan = KBDToUNICODE (SK_F1);
while (KeyDown (scan))
TaskSwitch ();
}
FlushInput ();
while (KeyHit () != SK_F1)
TaskSwitch ();
s.frame = F;
DrawStamp (&s);
DestroyDrawable (ReleaseDrawable (s.frame));
SetFrameHot (Screen, OldHot);
SetContext (OldContext);
WaitForNoInput (ONE_SECOND / 4);
FlushInput ();
ClearSemaphore (GraphicsSem);
if (ClockActive)
ResumeGameClock ();
else if (CommData.ConversationPhrases && PlayingTrack ())
ResumeTrack ();
TaskSwitch ();
GLOBAL (CurrentActivity) &= ~CHECK_PAUSE;
return (TRUE);
}
void
DoStatus (
void
) {
struct lineAttr rglaStatus[10]; /* color array for status line */
int cch;
int ilaStatus = 0; /* index into color array */
int i;
char *pchEndBuf; /* save for end of buffer */
char buf[512];
/*
* Start with filename, and file type
*/
strcpy (buf, pFileHead->pName);
strcat (buf, " (");
strcpy ((char *)strend(buf), GetFileTypeName ());
/*
* Add other file characterisctics
*/
if (!TESTFLAG (FLAGS (pFileHead), DOSFILE)) {
strcat (buf," NL");
}
if (TESTFLAG (FLAGS (pFileHead), TEMP)) {
strcat (buf, " temp");
}
if ((TESTFLAG (FLAGS (pFileHead), READONLY)) | fGlobalRO) {
strcat (buf, " No-Edit");
}
if (TESTFLAG (FLAGS (pFileHead), DISKRO)) {
strcat (buf, " RO-File");
}
rglaStatus[ilaStatus].attr = CINDEX(staColor);
rglaStatus[ilaStatus++].len = (unsigned char) strlen (buf);
if (TESTFLAG (FLAGS(pFileHead), DIRTY)) {
strcat (buf, " modified");
rglaStatus[ilaStatus].attr = CINDEX(errColor);
rglaStatus[ilaStatus++].len = 9;
}
pchEndBuf = strend (buf);
sprintf (strend(buf), ") Length=%ld ", pFileHead->cLines);
/*
* Add current location
*/
if (fDisplayCursorLoc) {
sprintf (strend(buf), "Cursor=(%ld,%d)", YCUR(pInsCur)+1, XCUR(pInsCur)+1);
} else {
sprintf (strend(buf), "Window=(%ld,%d)", YWIN(pInsCur)+1, XWIN(pInsCur)+1);
}
rglaStatus[ilaStatus].attr = CINDEX(staColor);
rglaStatus[ilaStatus++].len = (unsigned char) (strend(buf) - pchEndBuf);
/*
* Add global state indicators
*/
if (fInsert | fMeta | fCtrlc | fMacroRecord) {
rglaStatus[ilaStatus].attr = CINDEX(infColor);
rglaStatus[ilaStatus].len = 0;
if (fInsert) {
strcat (buf, " insert");
rglaStatus[ilaStatus].len += 7;
}
if (fMeta) {
strcat (buf, " meta");
rglaStatus[ilaStatus].len += 5;
}
if (fCtrlc) {
strcat (buf, " cancel");
rglaStatus[ilaStatus].len += 7;
fCtrlc = FALSE;
FlushInput ();
}
if (fMacroRecord) {
strcat (buf, " REC");
rglaStatus[ilaStatus].len += 4;
}
ilaStatus++;
}
rglaStatus[ilaStatus].attr = CINDEX(staColor);
rglaStatus[ilaStatus].len = 0xffff;
pchEndBuf = buf;
/*
* if the net result is too long, eat the first part of the filename with
* an elipses (Leave room for BC as well).
*/
cch = strlen(buf) - (XSIZE - 4);
if (cch > 0) {
pchEndBuf = buf + cch;
pchEndBuf[0] = '.';
pchEndBuf[1] = '.';
pchEndBuf[2] = '.';
i = 0;
while ( cch && i <= ilaStatus ) {
if ( (int)rglaStatus[i].len > cch ) {
rglaStatus[i].len -= cch;
cch = 0;
} else {
cch -= rglaStatus[i].len;
rglaStatus[i].len = 0;
}
i++;
}
}
fReDraw = FALSE;
coutb (0, YSIZE+1, pchEndBuf, strlen(pchEndBuf), rglaStatus);
fReDraw = TRUE;
voutb (XSIZE-2, YSIZE+1, BTWorking() ? "BP" : " ", 2, errColor);
RSETFLAG (fDisplay, RSTATUS);
}
BOOLEAN
DoConfirmExit (void)
{
BOOLEAN result;
if (PlayingTrack ())
PauseTrack ();
LockMutex (GraphicsLock);
{
RECT r;
STAMP s;
RECT ctxRect;
CONTEXT oldContext;
RECT oldRect;
BOOLEAN response = FALSE, done;
oldContext = SetContext (ScreenContext);
GetContextClipRect (&oldRect);
SetContextClipRect (NULL);
GetContextClipRect (&ctxRect);
r.extent.width = CONFIRM_WIN_WIDTH + 4;
r.extent.height = CONFIRM_WIN_HEIGHT + 4;
r.corner.x = (ctxRect.extent.width - r.extent.width) >> 1;
r.corner.y = (ctxRect.extent.height - r.extent.height) >> 1;
s = SaveContextFrame (&r);
SetSystemRect (&r);
DrawConfirmationWindow (response);
FlushGraphics ();
FlushInput ();
done = FALSE;
do {
// Forbid recursive calls or pausing here!
ExitRequested = FALSE;
GamePaused = FALSE;
UpdateInputState ();
if (GLOBAL (CurrentActivity) & CHECK_ABORT)
{ // something else triggered an exit
done = TRUE;
response = TRUE;
}
else if (PulsedInputState.menu[KEY_MENU_SELECT])
{
done = TRUE;
PlayMenuSound (MENU_SOUND_SUCCESS);
}
else if (PulsedInputState.menu[KEY_MENU_CANCEL])
{
done = TRUE;
response = FALSE;
}
else if (PulsedInputState.menu[KEY_MENU_LEFT] || PulsedInputState.menu[KEY_MENU_RIGHT])
{
response = !response;
DrawConfirmationWindow (response);
PlayMenuSound (MENU_SOUND_MOVE);
}
SleepThread (ONE_SECOND / 30);
} while (!done);
// Restore the screen under the confirmation window
DrawStamp (&s);
DestroyDrawable (ReleaseDrawable (s.frame));
ClearSystemRect ();
if (response || (GLOBAL (CurrentActivity) & CHECK_ABORT))
{
result = TRUE;
GLOBAL (CurrentActivity) |= CHECK_ABORT;
}
else
{
result = FALSE;
}
ExitRequested = FALSE;
GamePaused = FALSE;
FlushInput ();
SetContextClipRect (&oldRect);
SetContext (oldContext);
}
UnlockMutex (GraphicsLock);
if (PlayingTrack ())
ResumeTrack ();
return (result);
}
void FBGfx::WaitForKeyPress()
{
FlushInput();
while (!KeyPressed()) glfwPollEvents();
}
int32
PlainTextMessageIOGateway ::
DoInputImplementation(AbstractGatewayMessageReceiver & receiver, uint32 maxBytes)
{
TCHECKPOINT;
int32 ret = 0;
const int tempBufSize = 2048;
char buf[tempBufSize];
const uint32 mtuSize = GetMaximumPacketSize();
if (mtuSize > 0)
{
// Packet-IO implementation
char * pbuf = buf;
int pbufSize = tempBufSize;
ByteBufferRef bigBuf;
if (mtuSize > tempBufSize)
{
// Just in case our MTU size is too big for our on-stack buffer
bigBuf = GetByteBufferFromPool(mtuSize);
if (bigBuf())
{
pbuf = (char *) bigBuf()->GetBuffer();
pbufSize = bigBuf()->GetNumBytes();
}
}
while(true)
{
IPAddressAndPort sourceIAP;
const int32 bytesRead = GetPacketDataIO()->ReadFrom(pbuf, muscleMin(maxBytes, (uint32)(pbufSize-1)), sourceIAP);
if (bytesRead < 0) return (ret > 0) ? ret : -1;
else if (bytesRead > 0)
{
uint32 filteredBytesRead = bytesRead;
FilterInputBuffer(pbuf, filteredBytesRead, pbufSize-1);
ret += filteredBytesRead;
pbuf[filteredBytesRead] = '\0';
bool prevCharWasCarriageReturn = false; // deliberately a local var, since UDP packets should be independent of each other
MessageRef inMsg; // demand-allocated
int32 beginAt = 0;
for (uint32 i=0; i<filteredBytesRead; i++)
{
char nextChar = pbuf[i];
if ((nextChar == '\r')||(nextChar == '\n'))
{
pbuf[i] = '\0'; // terminate the string here
if ((nextChar == '\r')||(prevCharWasCarriageReturn == false)) inMsg = AddIncomingText(inMsg, &pbuf[beginAt]);
beginAt = i+1;
}
prevCharWasCarriageReturn = (nextChar == '\r');
}
if (beginAt < (int32)filteredBytesRead) inMsg = AddIncomingText(inMsg, &pbuf[beginAt]);
if (inMsg())
{
(void) inMsg()->AddFlat(PR_NAME_PACKET_REMOTE_LOCATION, sourceIAP);
receiver.CallMessageReceivedFromGateway(inMsg);
inMsg.Reset();
}
ret += bytesRead;
}
else return ret;
}
}
else
{
// Stream-IO implementation
const int32 bytesRead = GetDataIO()()->Read(buf, muscleMin(maxBytes, (uint32)(sizeof(buf)-1)));
if (bytesRead < 0)
{
FlushInput(receiver);
return -1;
}
if (bytesRead > 0)
{
uint32 filteredBytesRead = bytesRead;
FilterInputBuffer(buf, filteredBytesRead, sizeof(buf)-1);
ret += filteredBytesRead;
buf[filteredBytesRead] = '\0';
MessageRef inMsg; // demand-allocated
int32 beginAt = 0;
for (uint32 i=0; i<filteredBytesRead; i++)
{
char nextChar = buf[i];
if ((nextChar == '\r')||(nextChar == '\n'))
{
buf[i] = '\0'; // terminate the string here
if ((nextChar == '\r')||(_prevCharWasCarriageReturn == false)) inMsg = AddIncomingText(inMsg, &buf[beginAt]);
beginAt = i+1;
}
_prevCharWasCarriageReturn = (nextChar == '\r');
}
if (beginAt < (int32)filteredBytesRead)
{
if (_flushPartialIncomingLines) inMsg = AddIncomingText(inMsg, &buf[beginAt]);
else _incomingText += &buf[beginAt];
}
if (inMsg()) receiver.CallMessageReceivedFromGateway(inMsg);
}
}
return ret;
}
void ReadFlyingControls (CObject *objP)
{
fix forwardThrustTime;
CObject* gmObjP;
int bMulti;
if (gameData.time.xFrame <= 0)
return;
if (gameStates.app.bPlayerIsDead || gameStates.app.bEnterGame) {
StopPlayerMovement ();
FlushInput ();
/*
VmVecZero(&objP->mType.physInfo.rotThrust);
VmVecZero(&objP->mType.physInfo.thrust);
VmVecZero(&objP->mType.physInfo.velocity);
*/
gameStates.app.bEnterGame--;
return;
}
if ((objP->info.nType != OBJ_PLAYER) || (objP->info.nId != gameData.multiplayer.nLocalPlayer))
return; //references to CPlayerShip require that this obj be the CPlayerData
tGuidedMissileInfo *gmiP = gameData.objs.guidedMissile + gameData.multiplayer.nLocalPlayer;
gmObjP = gmiP->objP;
if (gmObjP && (gmObjP->info.nSignature == gmiP->nSignature)) {
CAngleVector vRotAngs;
CFixMatrix mRot, mOrient;
fix speed;
//this is a horrible hack. guided missile stuff should not be
//handled in the middle of a routine that is dealing with the CPlayerData
objP->mType.physInfo.rotThrust.SetZero ();
vRotAngs [PA] = Controls [0].pitchTime / 2 + gameStates.gameplay.seismic.nMagnitude / 64;
vRotAngs [BA] = Controls [0].bankTime / 2 + gameStates.gameplay.seismic.nMagnitude / 16;
vRotAngs [HA] = Controls [0].headingTime / 2 + gameStates.gameplay.seismic.nMagnitude / 64;
mRot = CFixMatrix::Create (vRotAngs);
mOrient = gmObjP->info.position.mOrient * mRot;
gmObjP->info.position.mOrient = mOrient;
speed = WI_speed (gmObjP->info.nId, gameStates.app.nDifficultyLevel);
gmObjP->mType.physInfo.velocity = gmObjP->info.position.mOrient.FVec () * speed;
if(IsMultiGame)
MultiSendGuidedInfo (gmObjP, 0);
}
else {
#if DBG
if (Controls [0].headingTime)
Controls [0].headingTime = Controls [0].headingTime;
#endif
objP->mType.physInfo.rotThrust = CFixVector::Create (Controls [0].pitchTime,
Controls [0].headingTime, //Controls [0].headingTime ? I2X (1) / 4 : 0; //Controls [0].headingTime;
Controls [0].bankTime);
}
forwardThrustTime = Controls [0].forwardThrustTime;
if ((LOCALPLAYER.flags & PLAYER_FLAGS_AFTERBURNER) && (d_rand () < OBJECTS [gameData.multiplayer.nLocalPlayer].DriveDamage ())) {
if (Controls [0].afterburnerState) { //CPlayerData has key down
fix afterburner_scale;
int oldCount,newCount;
//add in value from 0..1
afterburner_scale = I2X (1) + min (I2X (1) / 2, gameData.physics.xAfterburnerCharge) * 2;
forwardThrustTime = FixMul (gameData.time.xFrame, afterburner_scale); //based on full thrust
oldCount = (gameData.physics.xAfterburnerCharge / (DROP_DELTA_TIME / AFTERBURNER_USE_SECS));
if (!gameStates.gameplay.bAfterburnerCheat)
gameData.physics.xAfterburnerCharge -= gameData.time.xFrame / AFTERBURNER_USE_SECS;
if (gameData.physics.xAfterburnerCharge < 0)
gameData.physics.xAfterburnerCharge = 0;
newCount = (gameData.physics.xAfterburnerCharge / (DROP_DELTA_TIME / AFTERBURNER_USE_SECS));
if (gameStates.app.bNostalgia && (oldCount != newCount))
gameStates.render.bDropAfterburnerBlob = 1; //drop blob (after physics called)
}
else {
fix xChargeUp = min (gameData.time.xFrame / 8, I2X (1) - gameData.physics.xAfterburnerCharge); //recharge over 8 seconds
if (xChargeUp > 0) {
fix xCurEnergy = LOCALPLAYER.energy - I2X (10);
xCurEnergy = max (xCurEnergy, 0) / 10; //don't drop below 10
if (xCurEnergy > 0) { //maybe limit charge up by energy
xChargeUp = min (xChargeUp, xCurEnergy / 10);
if (xChargeUp > 0) {
gameData.physics.xAfterburnerCharge += xChargeUp;
LOCALPLAYER.energy -= xChargeUp * 100 / 10; //full charge uses 10% of energy
}
}
}
}
}
// Set CObject's thrust vector for forward/backward
objP->mType.physInfo.thrust = objP->info.position.mOrient.FVec () * forwardThrustTime;
// slide left/right
objP->mType.physInfo.thrust += objP->info.position.mOrient.RVec () * Controls [0].sidewaysThrustTime;
// slide up/down
objP->mType.physInfo.thrust += objP->info.position.mOrient.UVec () * Controls [0].verticalThrustTime;
objP->mType.physInfo.thrust *= 2 * objP->DriveDamage ();
if (!gameStates.input.bSkipControls)
memcpy (&gameData.physics.playerThrust, &objP->mType.physInfo.thrust, sizeof (gameData.physics.playerThrust));
bMulti = IsMultiGame;
if ((objP->mType.physInfo.flags & PF_WIGGLE) && !gameData.objs.speedBoost [objP->Index ()].bBoosted) {
#if 1//!DBG
WiggleObject (objP);
#endif
}
// As of now, objP->mType.physInfo.thrust & objP->mType.physInfo.rotThrust are
// in units of time... In other words, if thrust==gameData.time.xFrame, that
// means that the user was holding down the MaxThrust key for the
// whole frame. So we just scale them up by the max, and divide by
// gameData.time.xFrame to make them independant of framerate
// Prevent divide overflows on high frame rates.
// In a signed divide, you get an overflow if num >= div<<15
fix ft = gameData.time.xFrame;
// Note, you must check for ft < I2X (1)/2, else you can get an overflow on the << 15.
if ((ft < I2X (1)/2) && ((ft << 15) <= gameData.pig.ship.player->maxThrust))
ft = (gameData.pig.ship.player->maxThrust >> 15) + 1;
objP->mType.physInfo.thrust *= FixDiv (gameData.pig.ship.player->maxThrust, ft);
if ((ft < I2X (1)/2) && ((ft << 15) <= gameData.pig.ship.player->maxRotThrust))
ft = (gameData.pig.ship.player->maxThrust >> 15) + 1;
objP->mType.physInfo.rotThrust *= FixDiv (gameData.pig.ship.player->maxRotThrust, ft);
}
/* This code assumes that you aren't in Character Mode. This is
* currently safe because VControl doesn't see keystrokes when you
* are, and thus cannot conclude that an exit is necessary. */
BOOLEAN
DoConfirmExit (void)
{
BOOLEAN result;
static BOOLEAN in_confirm = FALSE;
if (LOBYTE (GLOBAL (CurrentActivity)) != SUPER_MELEE &&
LOBYTE (GLOBAL (CurrentActivity)) != WON_LAST_BATTLE &&
!(LastActivity & CHECK_RESTART))
SuspendGameClock ();
if (CommData.ConversationPhrases && PlayingTrack ())
PauseTrack ();
LockMutex (GraphicsLock);
if (in_confirm)
{
result = FALSE;
ExitRequested = FALSE;
}
else
{
RECT r;
STAMP s;
FRAME F;
CONTEXT oldContext;
RECT oldRect;
BOOLEAN response = FALSE, done;
in_confirm = TRUE;
oldContext = SetContext (ScreenContext);
GetContextClipRect (&oldRect);
SetContextClipRect (NULL_PTR);
r.extent.width = CONFIRM_WIN_WIDTH + 4;
r.extent.height = CONFIRM_WIN_HEIGHT + 4;
r.corner.x = (SCREEN_WIDTH - r.extent.width) >> 1;
r.corner.y = (SCREEN_HEIGHT - r.extent.height) >> 1;
s.origin = r.corner;
F = CaptureDrawable (LoadDisplayPixmap (&r, (FRAME)0));
SetSystemRect (&r);
DrawConfirmationWindow (response);
// Releasing the lock lets the rotate_planet_task
// draw a frame. PauseRotate can still allow one more frame
// to be drawn, so it is safer to just not release the lock
//UnlockMutex (GraphicsLock);
FlushGraphics ();
//LockMutex (GraphicsLock);
GLOBAL (CurrentActivity) |= CHECK_ABORT;
FlushInput ();
done = FALSE;
do {
// Forbid recursive calls or pausing here!
ExitRequested = FALSE;
GamePaused = FALSE;
UpdateInputState ();
if (PulsedInputState.menu[KEY_MENU_SELECT])
{
done = TRUE;
PlayMenuSound (MENU_SOUND_SUCCESS);
}
else if (PulsedInputState.menu[KEY_MENU_CANCEL])
{
done = TRUE;
response = FALSE;
}
else if (PulsedInputState.menu[KEY_MENU_LEFT] || PulsedInputState.menu[KEY_MENU_RIGHT])
{
response = !response;
DrawConfirmationWindow (response);
PlayMenuSound (MENU_SOUND_MOVE);
}
TaskSwitch ();
} while (!done);
s.frame = F;
DrawStamp (&s);
DestroyDrawable (ReleaseDrawable (s.frame));
ClearSystemRect ();
if (response)
{
result = TRUE;
}
else
{
result = FALSE;
GLOBAL (CurrentActivity) &= ~CHECK_ABORT;
}
ExitRequested = FALSE;
GamePaused = FALSE;
FlushInput ();
SetContextClipRect (&oldRect);
SetContext (oldContext);
}
UnlockMutex (GraphicsLock);
if (LOBYTE (GLOBAL (CurrentActivity)) != SUPER_MELEE &&
LOBYTE (GLOBAL (CurrentActivity)) != WON_LAST_BATTLE &&
!(LastActivity & CHECK_RESTART))
ResumeGameClock ();
if (CommData.ConversationPhrases && PlayingTrack ())
{
ResumeTrack ();
if (CommData.AlienTransitionDesc.AnimFlags & TALK_DONE)
do_subtitles ((void *)~0);
}
in_confirm = FALSE;
return (result);
}
void
DoPopupWindow(const char *msg)
{
stringbank *bank = StringBank_Create ();
const char *lines[30];
WIDGET_LABEL label;
RECT r;
STAMP s;
FRAME F;
CONTEXT oldContext;
RECT oldRect;
POPUP_STATE state;
MENU_SOUND_FLAGS s0, s1;
if (!bank)
{
log_add (log_Fatal, "FATAL: Memory exhaustion when preparing popup window");
exit (EXIT_FAILURE);
}
label.tag = WIDGET_TYPE_LABEL;
label.parent = NULL;
label.handleEvent = Widget_HandleEventIgnoreAll;
label.receiveFocus = Widget_ReceiveFocusRefuseFocus;
label.draw = Widget_DrawLabel;
label.height = Widget_HeightLabel;
label.width = Widget_WidthFullScreen;
label.line_count = SplitString (msg, '\n', 30, lines, bank);
label.lines = lines;
LockMutex (GraphicsLock);
oldContext = SetContext (ScreenContext);
GetContextClipRect (&oldRect);
SetContextClipRect (NULL_PTR);
/* TODO: Better measure of dimensions than this */
r.extent.width = SCREEN_WIDTH;
r.extent.height = SCREEN_HEIGHT;
r.corner.x = (SCREEN_WIDTH - r.extent.width) >> 1;
r.corner.y = (SCREEN_HEIGHT - r.extent.height) >> 1;
F = CaptureDrawable (LoadDisplayPixmap (&r, (FRAME)0));
s.origin = r.corner;
s.frame = F;
DrawLabelAsWindow (&label);
GetMenuSounds (&s0, &s1);
SetMenuSounds (MENU_SOUND_NONE, MENU_SOUND_NONE);
state.InputFunc = DoPopup;
DoInput (&state, TRUE);
DrawStamp (&s);
DestroyDrawable (ReleaseDrawable (s.frame));
FlushInput ();
SetContextClipRect (&oldRect);
SetContext (oldContext);
UnlockMutex (GraphicsLock);
SetMenuSounds (s0, s1);
StringBank_Free (bank);
}
void COMXCoreComponent::FlushAll()
{
FlushInput();
FlushOutput();
}
static BOOLEAN
RestartMenu (PMENU_STATE pMS)
{
DWORD TimeOut;
BYTE black_buf[1];
ReinitQueue (&race_q[0]);
ReinitQueue (&race_q[1]);
black_buf[0] = FadeAllToBlack;
SetContext (ScreenContext);
GLOBAL (CurrentActivity) |= CHECK_ABORT;
if (GLOBAL_SIS (CrewEnlisted) == (COUNT)~0
&& GET_GAME_STATE (UTWIG_BOMB_ON_SHIP)
&& !GET_GAME_STATE (UTWIG_BOMB))
{ // player blew himself up with Utwig bomb
BYTE white_buf[] = {FadeAllToWhite};
SET_GAME_STATE (UTWIG_BOMB_ON_SHIP, 0);
SleepThreadUntil (XFormColorMap ((COLORMAPPTR)white_buf,
ONE_SECOND / 8) + ONE_SECOND / 60);
SetContextBackGroundColor (BUILD_COLOR (MAKE_RGB15 (0x1F, 0x1F, 0x1F), 0x0F));
ClearDrawable ();
FlushColorXForms ();
TimeOut = ONE_SECOND / 8;
}
else
{
TimeOut = ONE_SECOND / 2;
if (LOBYTE (LastActivity) == WON_LAST_BATTLE)
{
GLOBAL (CurrentActivity) = WON_LAST_BATTLE;
Victory ();
Credits (TRUE);
FreeGameData ();
TimeOut = ONE_SECOND / 2;
GLOBAL (CurrentActivity) = CHECK_ABORT;
}
}
LastActivity = NextActivity = 0;
SleepThreadUntil (XFormColorMap ((COLORMAPPTR)black_buf, TimeOut));
if (TimeOut == ONE_SECOND / 8)
SleepThread (ONE_SECOND * 3);
DrawRestartMenuGraphic (pMS);
FlushInput ();
GLOBAL (CurrentActivity) &= ~CHECK_ABORT;
SetMenuSounds (MENU_SOUND_UP | MENU_SOUND_DOWN, MENU_SOUND_SELECT);
DoInput (pMS, TRUE);
StopMusic ();
if (pMS->hMusic)
{
DestroyMusic (pMS->hMusic);
pMS->hMusic = 0;
}
LockMutex (GraphicsLock);
SetFlashRect (NULL_PTR, (FRAME)0);
UnlockMutex (GraphicsLock);
DestroyDrawable (ReleaseDrawable (pMS->CurFrame));
if (GLOBAL (CurrentActivity) == (ACTIVITY)~0)
return (FALSE); // timed out
if (GLOBAL (CurrentActivity) & CHECK_ABORT)
return (FALSE); // quit
TimeOut = XFormColorMap ((COLORMAPPTR)black_buf, ONE_SECOND / 2);
SleepThreadUntil (TimeOut);
FlushColorXForms ();
SeedRandomNumbers ();
return (LOBYTE (GLOBAL (CurrentActivity)) != SUPER_MELEE);
}