//

// ID Engine

// ID_US_1.c - User Manager - General routines

// v1.1d1

// By Jason Blochowiak

// Hacked up for Catacomb 3D

//

//

// This module handles dealing with user input & feedback

//

// Depends on: Input Mgr, View Mgr, some variables from the Sound, Caching,

// and Refresh Mgrs, Memory Mgr for background save/restore

//

// Globals:

// ingame - Flag set by game indicating if a game is in progress

// abortgame - Flag set if the current game should be aborted (if a load

// game fails)

// loadedgame - Flag set if a game was loaded

// abortprogram - Normally nil, this points to a terminal error message

// if the program needs to abort

// restartgame - Normally set to gd_Continue, this is set to one of the

// difficulty levels if a new game should be started

// PrintX, PrintY - Where the User Mgr will print (global coords)

// WindowX,WindowY,WindowW,WindowH - The dimensions of the current

// window

//

#include "ID_HEADS.H"

#pragma hdrstop

#pragma warn -pia

// Global variables

char *abortprogram;

// boolean NoWait;

word PrintX,PrintY;

word WindowX,WindowY,WindowW,WindowH;

US_CursorStruct US_CustomCursor; // JAM

boolean use_custom_cursor=false; // JAM

// Internal variables

#define ConfigVersion 1

char far * far US_ParmStrings[] = {"TEDLEVEL","NOWAIT"},

far * far US_ParmStrings2[] = {"COMP","NOCOMP"};

boolean US_Started;

boolean Button0,Button1,

CursorBad;

int CursorX,CursorY;

void (*USL_MeasureString)(char far *,word *,word *) = VW_MeasurePropString,

(*USL_DrawString)(char far *) = VWB_DrawPropString;

SaveGame Games[MaxSaveGames];

HighScore Scores[MaxScores] =

{

{"JAM PRODUCTIONS INC.", 10000,1,0},

{"", 10000,1,0},

{"JERRY JONES", 10000,1,0},

{"MICHAEL MAYNARD", 10000,1,0},

{"JAMES T. ROW", 10000,1,0},

{"", 10000,1,0},

{"", 10000,1,0},

{"TO REGISTER CALL", 10000,1,0},

{" 1-800-GAME123", 10000,1,0},

{"", 10000,1,0},

};

// Internal routines

// Public routines

///////////////////////////////////////////////////////////////////////////

//

// USL_HardError() - Handles the Abort/Retry/Fail sort of errors passed

// from DOS.

//

///////////////////////////////////////////////////////////////////////////

#pragma warn -par

#pragma warn -rch

int

USL_HardError(word errval,int ax,int bp,int si)

{

#define IGNORE 0

#define RETRY 1

#define ABORT 2

extern void ShutdownId(void);

static char buf[32];

static WindowRec wr;

int di;

char c,*s,*t;

di = _DI;

if (ax < 0)

s = "DEVICE ERROR";

else

{

if ((di & 0x00ff) == 0)

s = "DRIVE ~ IS WRITE PROTECTED";

else

s = "ERROR ON DRIVE ~";

for (t = buf;*s;s++,t++) // Can't use sprintf()

if ((*t = *s) == '~')

*t = (ax & 0x00ff) + 'A';

*t = '\0';

s = buf;

}

c = peekb(0x40,0x49); // Get the current screen mode

if ((c < 4) || (c == 7))

goto oh_kill_me;

// DEBUG - handle screen cleanup

fontnumber = 4;

US_SaveWindow(&wr);

US_CenterWindow(30,3);

US_CPrint(s);

US_CPrint("(R)ETRY or (A)BORT?");

VW_UpdateScreen();

IN_ClearKeysDown();

asm sti // Let the keyboard interrupts come through

while (true)

{

switch (IN_WaitForASCII())

{

case key_Escape:

case 'a':

case 'A':

goto oh_kill_me;

break;

case key_Return:

case key_Space:

case 'r':

case 'R':

US_ClearWindow();

VW_UpdateScreen();

US_RestoreWindow(&wr);

return(RETRY);

break;

}

}

oh_kill_me:

abortprogram = s;

ShutdownId();

fprintf(stderr,"TERMINAL ERROR: %s\n",s);

return(ABORT);

#undef IGNORE

#undef RETRY

#undef ABORT

}

#pragma warn +par

#pragma warn +rch

///////////////////////////////////////////////////////////////////////////

//

// US_Shutdown() - Shuts down the User Mgr

//

///////////////////////////////////////////////////////////////////////////

void

US_Shutdown(void)

{

if (!US_Started)

return;

US_Started = false;

}

///////////////////////////////////////////////////////////////////////////

//

// US_CheckParm() - checks to see if a string matches one of a set of

// strings. The check is case insensitive. The routine returns the

// index of the string that matched, or -1 if no matches were found

//

///////////////////////////////////////////////////////////////////////////

int US_CheckParm(char far *parm,char far * far * strings)

{

char cp,cs,

far *p,far *s;

int i;

while (!isalpha(*parm)) // Skip non-alphas

parm++;

for (i = 0;*strings && **strings;i++)

{

for (s = *strings++,p = parm,cs = cp = 0;cs == cp;)

{

cs = *s++;

if (!cs)

return(i);

cp = *p++;

if (isupper(cs))

cs = tolower(cs);

if (isupper(cp))

cp = tolower(cp);

}

}

return(-1);

}

// Window/Printing routines

#if 0

///////////////////////////////////////////////////////////////////////////

//

// US_SetPrintRoutines() - Sets the routines used to measure and print

// from within the User Mgr. Primarily provided to allow switching

// between masked and non-masked fonts

//

///////////////////////////////////////////////////////////////////////////

void

US_SetPrintRoutines(void (*measure)(char far *,word *,word *),void (*print)(char far *))

{

USL_MeasureString = measure;

USL_DrawString = print;

}

#endif

///////////////////////////////////////////////////////////////////////////

//

// US_Print() - Prints a string in the current window. Newlines are

// supported.

//

///////////////////////////////////////////////////////////////////////////

void

US_Print(char far *s)

{

char c,far *se;

word w,h;

while (*s)

{

se = s;

while ((c = *se) && (c != '\n'))

se++;

*se = '\0';

USL_MeasureString(s,&w,&h);

px = PrintX;

py = PrintY;

USL_DrawString(s);

s = se;

if (c)

{

*se = c;

s++;

PrintX = WindowX;

PrintY += h;

}

else

PrintX += w;

}

}

///////////////////////////////////////////////////////////////////////////

//

// US_PrintUnsigned() - Prints an unsigned long

//

///////////////////////////////////////////////////////////////////////////

void

US_PrintUnsigned(longword n)

{

char buffer[32];

US_Print(ultoa(n,buffer,10));

}

#if 0

///////////////////////////////////////////////////////////////////////////

//

// US_PrintSigned() - Prints a signed long

//

///////////////////////////////////////////////////////////////////////////

void

US_PrintSigned(long n)

{

char buffer[32];

US_Print(ltoa(n,buffer,10));

}

#endif

///////////////////////////////////////////////////////////////////////////

//

// USL_PrintInCenter() - Prints a string in the center of the given rect

//

///////////////////////////////////////////////////////////////////////////

void

USL_PrintInCenter(char far *s,Rect r)

{

word w,h,

rw,rh;

USL_MeasureString(s,&w,&h);

rw = r.lr.x - r.ul.x;

rh = r.lr.y - r.ul.y;

px = r.ul.x + ((rw - w) / 2);

py = r.ul.y + ((rh - h) / 2);

USL_DrawString(s);

}

///////////////////////////////////////////////////////////////////////////

//

// US_PrintCentered() - Prints a string centered in the current window.

//

///////////////////////////////////////////////////////////////////////////

void

US_PrintCentered(char far *s)

{

Rect r;

r.ul.x = WindowX;

r.ul.y = WindowY;

r.lr.x = r.ul.x + WindowW;

r.lr.y = r.ul.y + WindowH;

USL_PrintInCenter(s,r);

}

///////////////////////////////////////////////////////////////////////////

//

// US_CPrintLine() - Prints a string centered on the current line and

// advances to the next line. Newlines are not supported.

//

///////////////////////////////////////////////////////////////////////////

void

US_CPrintLine(char far *s)

{

word w,h;

USL_MeasureString(s,&w,&h);

if (w > WindowW)

US1_ERROR(US_CPRINTLINE_WIDTH);

px = WindowX + ((WindowW - w) / 2);

py = PrintY;

USL_DrawString(s);

PrintY += h;

}

///////////////////////////////////////////////////////////////////////////

//

// US_CPrint() - Prints a string in the current window. Newlines are

// supported.

//

///////////////////////////////////////////////////////////////////////////

void

US_CPrint(char far *s)

{

char c,far *se;

while (*s)

{

se = s;

while ((c = *se) && (c != '\n'))

se++;

*se = '\0';

US_CPrintLine(s);

s = se;

if (c)

{

*se = c;

s++;

}

}

}

///////////////////////////////////////////////////////////////////////////

//

// US_ClearWindow() - Clears the current window to white and homes the

// cursor

//

///////////////////////////////////////////////////////////////////////////

void

US_ClearWindow(void)

{

VWB_Bar(WindowX,WindowY,WindowW,WindowH,0xEF);

PrintX = WindowX;

PrintY = WindowY;

}

///////////////////////////////////////////////////////////////////////////

//

// US_DrawWindow() - Draws a frame and sets the current window parms

//

///////////////////////////////////////////////////////////////////////////

void

US_DrawWindow(word x,word y,word w,word h)

{

word i,

sx,sy,sw,sh;

WindowX = x * 8;

WindowY = y * 8;

WindowW = w * 8;

WindowH = h * 8;

PrintX = WindowX;

PrintY = WindowY;

sx = (x - 1) * 8;

sy = (y - 1) * 8;

sw = (w + 1) * 8;

sh = (h + 1) * 8;

US_ClearWindow();

VWB_DrawTile8(sx,sy,0),VWB_DrawTile8(sx,sy + sh,5);

for (i = sx + 8;i <= sx + sw - 8;i += 8)

VWB_DrawTile8(i,sy,1),VWB_DrawTile8(i,sy + sh,6);

VWB_DrawTile8(i,sy,2),VWB_DrawTile8(i,sy + sh,7);

for (i = sy + 8;i <= sy + sh - 8;i += 8)

VWB_DrawTile8(sx,i,3),VWB_DrawTile8(sx + sw,i,4);

}

///////////////////////////////////////////////////////////////////////////

//

// US_CenterWindow() - Generates a window of a given width & height in the

// middle of the screen

//

///////////////////////////////////////////////////////////////////////////

void

US_CenterWindow(word w,word h)

{

US_DrawWindow(((MaxX / 8) - w) / 2,((MaxY / 8) - h) / 2,w,h);

}

///////////////////////////////////////////////////////////////////////////

//

// US_SaveWindow() - Saves the current window parms into a record for

// later restoration

//

///////////////////////////////////////////////////////////////////////////

void

US_SaveWindow(WindowRec *win)

{

win->x = WindowX;

win->y = WindowY;

win->w = WindowW;

win->h = WindowH;

win->px = PrintX;

win->py = PrintY;

}

///////////////////////////////////////////////////////////////////////////

//

// US_RestoreWindow() - Sets the current window parms to those held in the

// record

//

///////////////////////////////////////////////////////////////////////////

void

US_RestoreWindow(WindowRec *win)

{

WindowX = win->x;

WindowY = win->y;

WindowW = win->w;

WindowH = win->h;

PrintX = win->px;

PrintY = win->py;

}

// Input routines

///////////////////////////////////////////////////////////////////////////

//

// USL_XORICursor() - XORs the I-bar text cursor. Used by US_LineInput()

//

///////////////////////////////////////////////////////////////////////////

static void

USL_XORICursor(int x,int y,char *s,word cursor)

{

static boolean status; // VGA doesn't XOR...

char buf[MaxString];

int temp;

word w,h;

strcpy(buf,s);

buf[cursor] = '\0';

USL_MeasureString(buf,&w,&h);

px = x + w - 1;

py = y;

VL_WaitVBL(1);

if (status^=1)

{

USL_DrawString("\x80");

}

else

{

temp = fontcolor;

fontcolor = backcolor;

USL_DrawString("\x80");

fontcolor = temp;

}

}

// JAM BEGIN - New Function

///////////////////////////////////////////////////////////////////////////

//

// USL_CustomCursor() - Toggle Displays the custom text cursor.

// Used by US_LineInput()

//

///////////////////////////////////////////////////////////////////////////

static void USL_CustomCursor(int x,int y,char *s,word cursor)

{

static boolean status; // VGA doesn't XOR...

char buf[MaxString];

int temp,temp_font;

word w,h;

strcpy(buf,s);

buf[cursor] = '\0';

USL_MeasureString(buf,&w,&h);

px = x + w - 1;

py = y;

temp = fontcolor;

temp_font = fontnumber;

fontnumber = US_CustomCursor.font_number;

if (status^=1)

fontcolor = US_CustomCursor.cursor_color;

else

fontcolor = backcolor;

VL_WaitVBL(1);

USL_DrawString(&US_CustomCursor.cursor_char);

fontcolor = temp;

fontnumber = temp_font;

}

// JAM END - New Function

///////////////////////////////////////////////////////////////////////////

//

// US_LineInput() - Gets a line of user input at (x,y), the string defaults

// to whatever is pointed at by def. Input is restricted to maxchars

// chars or maxwidth pixels wide. If the user hits escape (and escok is

// true), nothing is copied into buf, and false is returned. If the

// user hits return, the current string is copied into buf, and true is

// returned

//

///////////////////////////////////////////////////////////////////////////

boolean US_LineInput(int x,int y,char far *buf,char far *def,boolean escok,

int maxchars,int maxwidth)

{

boolean redraw,

cursorvis,cursormoved,

done,result;

ScanCode sc;

char c,

s[MaxString],olds[MaxString];

word i,

cursor,

w,h,

len,temp;

longword lasttime;

if (def)

_fstrcpy(s,def);

else

*s = '\0';

*olds = '\0';

cursor = strlen(s);

cursormoved = redraw = true;

cursorvis = done = false;

lasttime = TimeCount;

LastASCII = key_None;

LastScan = sc_None;

while (!done)

{

if (cursorvis)

{

if (use_custom_cursor) // JAM

USL_CustomCursor(x,y,s,cursor); // JAM

else

USL_XORICursor(x,y,s,cursor);

}

asm pushf

asm cli

sc = LastScan;

LastScan = sc_None;

c = LastASCII;

LastASCII = key_None;

asm popf

switch (sc)

{

#if 0

case sc_LeftArrow:

if (cursor)

cursor--;

c = key_None;

cursormoved = true;

redraw = use_custom_cursor; // JAM -

break;

case sc_RightArrow:

if (s[cursor])

cursor++;

c = key_None;

cursormoved = true;

redraw = use_custom_cursor; // JAM -

break;

case sc_Home:

cursor = 0;

c = key_None;

cursormoved = true;

redraw = use_custom_cursor; // JAM -

break;

case sc_End:

cursor = strlen(s);

c = key_None;

cursormoved = true;

break;

#endif

case sc_Return:

_fstrcpy(buf,s);

done = true;

result = true;

c = key_None;

break;

case sc_Escape:

if (escok)

{

done = true;

result = false;

}

c = key_None;

break;

case sc_BackSpace:

if (cursor)

{

strcpy(s + cursor - 1,s + cursor);

cursor--;

redraw = true;

}

c = key_None;

cursormoved = true;

break;

#if 0

case sc_Delete:

if (s[cursor])

{

strcpy(s + cursor,s + cursor + 1);

redraw = true;

}

c = key_None;

cursormoved = true;

break;

#endif

case 0x4c: // Keypad 5

case sc_UpArrow:

case sc_DownArrow:

case sc_PgUp:

case sc_PgDn:

case sc_Insert:

c = key_None;

break;

}

if (c)

{

len = strlen(s);

USL_MeasureString(s,&w,&h);

if ( isprint(c) && (len < MaxString - 1)

&& ((!maxchars) || (len < maxchars))

&& ((!maxwidth) || (w < maxwidth)))

{

for (i = len + 1;i > cursor;i--)

s[i] = s[i - 1];

s[cursor++] = c;

redraw = true;

}

}

if (redraw)

{

px = x;

py = y;

temp = fontcolor;

fontcolor = backcolor;

USL_DrawString(olds);

fontcolor = temp;

strcpy(olds,s);

px = x;

py = y;

USL_DrawString(s);

redraw = false;

}

if (cursormoved)

{

cursorvis = false;

lasttime = TimeCount - TickBase;

cursormoved = false;

}

if (TimeCount - lasttime > TickBase / 2)

{

lasttime = TimeCount;

cursorvis ^= true;

}

if (cursorvis)

if (use_custom_cursor) // JAM

USL_CustomCursor(x,y,s,cursor); // JAM

else

USL_XORICursor(x,y,s,cursor);

VW_UpdateScreen();

}

if (cursorvis)

if (use_custom_cursor) // JAM

USL_CustomCursor(x,y,s,cursor); // JAM

else

USL_XORICursor(x,y,s,cursor);

if (!result)

{

px = x;

py = y;

USL_DrawString(olds);

}

VW_UpdateScreen();

IN_ClearKeysDown();

return(result);

}