Borland C++ compile fixes
[divverent/darkplaces.git] / console.c
1 /*
2 Copyright (C) 1996-1997 Id Software, Inc.
3
4 This program is free software; you can redistribute it and/or
5 modify it under the terms of the GNU General Public License
6 as published by the Free Software Foundation; either version 2
7 of the License, or (at your option) any later version.
8
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  
12
13 See the GNU General Public License for more details.
14
15 You should have received a copy of the GNU General Public License
16 along with this program; if not, write to the Free Software
17 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
18
19 */
20 // console.c
21
22 #ifdef NeXT
23 #include <libc.h>
24 #endif
25 #ifndef _MSC_VER
26 #ifndef __BORLANDC__
27 #include <unistd.h>
28 #endif
29 #endif
30 #ifdef WIN32
31 #include <io.h>
32 #endif
33 #include <fcntl.h>
34 #include "quakedef.h"
35
36 int             con_linewidth;
37
38 float           con_cursorspeed = 4;
39
40 #define         CON_TEXTSIZE    16384
41
42 qboolean        con_forcedup;           // because no entities to refresh
43
44 int                     con_totallines;         // total lines in console scrollback
45 int                     con_backscroll;         // lines up from bottom to display
46 int                     con_current;            // where next message will be printed
47 int                     con_x;                          // offset in current line for next print
48 char            *con_text=0;
49
50 cvar_t          con_notifytime = {"con_notifytime","3"};                //seconds
51 cvar_t          logfile = {"logfile","0"};
52
53 #define NUM_CON_TIMES 4
54 float           con_times[NUM_CON_TIMES];       // realtime time the line was generated
55                                                                 // for transparent notify lines
56
57 int                     con_vislines;
58
59 qboolean        con_debuglog;
60
61 #define         MAXCMDLINE      256
62 extern  char    key_lines[32][MAXCMDLINE];
63 extern  int             edit_line;
64 extern  int             key_linepos;
65                 
66
67 qboolean        con_initialized;
68
69 int                     con_notifylines;                // scan lines to clear for notify lines
70
71 extern void M_Menu_Main_f (void);
72
73 /*
74 ================
75 Con_ToggleConsole_f
76 ================
77 */
78 void Con_ToggleConsole_f (void)
79 {
80         if (key_dest == key_console)
81         {
82                 if (cls.state == ca_connected)
83                 {
84                         key_dest = key_game;
85                         key_lines[edit_line][1] = 0;    // clear any typing
86                         key_linepos = 1;
87                 }
88                 else
89                 {
90                         M_Menu_Main_f ();
91                 }
92         }
93         else
94                 key_dest = key_console;
95         
96         SCR_EndLoadingPlaque ();
97         memset (con_times, 0, sizeof(con_times));
98 }
99
100 /*
101 ================
102 Con_Clear_f
103 ================
104 */
105 void Con_Clear_f (void)
106 {
107         if (con_text)
108                 memset (con_text, ' ', CON_TEXTSIZE);
109 }
110
111                                                 
112 /*
113 ================
114 Con_ClearNotify
115 ================
116 */
117 void Con_ClearNotify (void)
118 {
119         int             i;
120         
121         for (i=0 ; i<NUM_CON_TIMES ; i++)
122                 con_times[i] = 0;
123 }
124
125                                                 
126 /*
127 ================
128 Con_MessageMode_f
129 ================
130 */
131 extern qboolean team_message;
132
133 void Con_MessageMode_f (void)
134 {
135         key_dest = key_message;
136         team_message = false;
137 }
138
139                                                 
140 /*
141 ================
142 Con_MessageMode2_f
143 ================
144 */
145 void Con_MessageMode2_f (void)
146 {
147         key_dest = key_message;
148         team_message = true;
149 }
150
151                                                 
152 /*
153 ================
154 Con_CheckResize
155
156 If the line width has changed, reformat the buffer.
157 ================
158 */
159 void Con_CheckResize (void)
160 {
161         int             i, j, width, oldwidth, oldtotallines, numlines, numchars;
162         char    tbuf[CON_TEXTSIZE];
163
164         width = (vid.width >> 3) - 2;
165
166         if (width == con_linewidth)
167                 return;
168
169         if (width < 1)                  // video hasn't been initialized yet
170         {
171                 width = 78; // LordHavoc: changed from 38 to 78 (320 -> 640 conversion)
172                 con_linewidth = width;
173                 con_totallines = CON_TEXTSIZE / con_linewidth;
174                 memset (con_text, ' ', CON_TEXTSIZE);
175         }
176         else
177         {
178                 oldwidth = con_linewidth;
179                 con_linewidth = width;
180                 oldtotallines = con_totallines;
181                 con_totallines = CON_TEXTSIZE / con_linewidth;
182                 numlines = oldtotallines;
183
184                 if (con_totallines < numlines)
185                         numlines = con_totallines;
186
187                 numchars = oldwidth;
188         
189                 if (con_linewidth < numchars)
190                         numchars = con_linewidth;
191
192                 memcpy (tbuf, con_text, CON_TEXTSIZE);
193                 memset (con_text, ' ', CON_TEXTSIZE);
194
195                 for (i=0 ; i<numlines ; i++)
196                 {
197                         for (j=0 ; j<numchars ; j++)
198                         {
199                                 con_text[(con_totallines - 1 - i) * con_linewidth + j] =
200                                                 tbuf[((con_current - i + oldtotallines) %
201                                                           oldtotallines) * oldwidth + j];
202                         }
203                 }
204
205                 Con_ClearNotify ();
206         }
207
208         con_backscroll = 0;
209         con_current = con_totallines - 1;
210 }
211
212
213 /*
214 ================
215 Con_Init
216 ================
217 */
218 void Con_Init (void)
219 {
220 #define MAXGAMEDIRLEN   1000
221         char    temp[MAXGAMEDIRLEN+1];
222         char    *t2 = "/qconsole.log";
223
224         Cvar_RegisterVariable(&logfile);
225         con_debuglog = COM_CheckParm("-condebug");
226
227         if (con_debuglog)
228         {
229                 if (strlen (com_gamedir) < (MAXGAMEDIRLEN - strlen (t2)))
230                 {
231                         sprintf (temp, "%s%s", com_gamedir, t2);
232                         unlink (temp);
233                 }
234                 logfile.value = 1;
235         }
236
237         con_text = Hunk_AllocName (CON_TEXTSIZE, "context");
238         memset (con_text, ' ', CON_TEXTSIZE);
239         con_linewidth = -1;
240         Con_CheckResize ();
241         
242         Con_Printf ("Console initialized.\n");
243
244 //
245 // register our commands
246 //
247         Cvar_RegisterVariable (&con_notifytime);
248
249         Cmd_AddCommand ("toggleconsole", Con_ToggleConsole_f);
250         Cmd_AddCommand ("messagemode", Con_MessageMode_f);
251         Cmd_AddCommand ("messagemode2", Con_MessageMode2_f);
252         Cmd_AddCommand ("clear", Con_Clear_f);
253         con_initialized = true;
254 }
255
256
257 /*
258 ===============
259 Con_Linefeed
260 ===============
261 */
262 void Con_Linefeed (void)
263 {
264         con_x = 0;
265         con_current++;
266         memset (&con_text[(con_current%con_totallines)*con_linewidth]
267         , ' ', con_linewidth);
268 }
269
270 /*
271 ================
272 Con_Print
273
274 Handles cursor positioning, line wrapping, etc
275 All console printing must go through this in order to be logged to disk
276 If no console is visible, the notify window will pop up.
277 ================
278 */
279 void Con_Print (char *txt)
280 {
281         int             y;
282         int             c, l;
283         static int      cr;
284         int             mask;
285         
286         con_backscroll = 0;
287
288         if (txt[0] == 1)
289         {
290                 mask = 128;             // go to colored text
291                 S_LocalSound ("misc/talk.wav");
292         // play talk wav
293                 txt++;
294         }
295         else if (txt[0] == 2)
296         {
297                 mask = 128;             // go to colored text
298                 txt++;
299         }
300         else
301                 mask = 0;
302
303
304         while ( (c = *txt) )
305         {
306         // count word length
307                 for (l=0 ; l< con_linewidth ; l++)
308                         if ( txt[l] <= ' ')
309                                 break;
310
311         // word wrap
312                 if (l != con_linewidth && (con_x + l > con_linewidth) )
313                         con_x = 0;
314
315                 txt++;
316
317                 if (cr)
318                 {
319                         con_current--;
320                         cr = false;
321                 }
322
323                 
324                 if (!con_x)
325                 {
326                         Con_Linefeed ();
327                 // mark time for transparent overlay
328                         if (con_current >= 0)
329                                 con_times[con_current % NUM_CON_TIMES] = realtime;
330                 }
331
332                 switch (c)
333                 {
334                 case '\n':
335                         con_x = 0;
336                         break;
337
338                 case '\r':
339                         con_x = 0;
340                         cr = 1;
341                         break;
342
343                 default:        // display character and advance
344                         y = con_current % con_totallines;
345                         con_text[y*con_linewidth+con_x] = c | mask;
346                         con_x++;
347                         if (con_x >= con_linewidth)
348                                 con_x = 0;
349                         break;
350                 }
351                 
352         }
353 }
354
355
356 /*
357 ================
358 Con_DebugLog
359 ================
360 */
361 void Con_DebugLog(char *file, char *fmt, ...)
362 {
363     va_list argptr; 
364     static char data[1024];
365     int fd;
366     
367     va_start(argptr, fmt);
368     vsprintf(data, fmt, argptr);
369     va_end(argptr);
370     fd = open(file, O_WRONLY | O_CREAT | O_APPEND, 0666);
371     write(fd, data, strlen(data));
372     close(fd);
373 }
374
375
376 /*
377 ================
378 Con_Printf
379
380 Handles cursor positioning, line wrapping, etc
381 ================
382 */
383 // LordHavoc: increased from 4096 to 16384
384 #define MAXPRINTMSG     16384
385 // FIXME: make a buffer size safe vsprintf?
386 void Con_Printf (char *fmt, ...)
387 {
388         va_list         argptr;
389         char            msg[MAXPRINTMSG];
390         static qboolean inupdate;
391         
392         va_start (argptr,fmt);
393         vsprintf (msg,fmt,argptr);
394         va_end (argptr);
395         
396 // also echo to debugging console
397         Sys_Printf ("%s", msg); // also echo to debugging console
398
399 // log all messages to file
400         if (con_debuglog)
401                 Con_DebugLog(va("%s/qconsole.log",com_gamedir), "%s", msg);
402
403         if (!con_initialized)
404                 return;
405                 
406         if (cls.state == ca_dedicated)
407                 return;         // no graphics mode
408
409 // write it to the scrollable buffer
410         Con_Print (msg);
411         
412 // update the screen if the console is displayed
413         // LordHavoc: don't print text while loading scripts
414         if (cls.state != ca_disconnected)
415         if (cls.signon != SIGNONS && !scr_disabled_for_loading )
416         {
417         // protect against infinite loop if something in SCR_UpdateScreen calls
418         // Con_Printf
419                 if (!inupdate)
420                 {
421                         inupdate = true;
422                         SCR_UpdateScreen ();
423                         inupdate = false;
424                 }
425         }
426 }
427
428 /*
429 ================
430 Con_DPrintf
431
432 A Con_Printf that only shows up if the "developer" cvar is set
433 ================
434 */
435 void Con_DPrintf (char *fmt, ...)
436 {
437         va_list         argptr;
438         char            msg[MAXPRINTMSG];
439                 
440         if (!developer.value)
441                 return;                 // don't confuse non-developers with techie stuff...
442
443         va_start (argptr,fmt);
444         vsprintf (msg,fmt,argptr);
445         va_end (argptr);
446         
447         Con_Printf ("%s", msg);
448 }
449
450
451 /*
452 ==================
453 Con_SafePrintf
454
455 Okay to call even when the screen can't be updated
456 ==================
457 */
458 void Con_SafePrintf (char *fmt, ...)
459 {
460         va_list         argptr;
461         char            msg[1024];
462         int                     temp;
463                 
464         va_start (argptr,fmt);
465         vsprintf (msg,fmt,argptr);
466         va_end (argptr);
467
468         temp = scr_disabled_for_loading;
469         scr_disabled_for_loading = true;
470         Con_Printf ("%s", msg);
471         scr_disabled_for_loading = temp;
472 }
473
474
475 /*
476 ==============================================================================
477
478 DRAWING
479
480 ==============================================================================
481 */
482
483
484 /*
485 ================
486 Con_DrawInput
487
488 The input line scrolls horizontally if typing goes beyond the right edge
489 ================
490 */
491 void Con_DrawInput (void)
492 {
493         int             y;
494         char    *text;
495
496         if (key_dest != key_console && !con_forcedup)
497                 return;         // don't draw anything
498
499         text = key_lines[edit_line];
500         
501 // add the cursor frame
502         text[key_linepos] = 10+((int)(realtime*con_cursorspeed)&1);
503         
504         text[key_linepos+1] = 0; // LordHavoc: null terminate, rather than padding with spaces
505 // fill out remainder with spaces
506 //      for (i=key_linepos+1 ; i< con_linewidth ; i++)
507 //              text[i] = ' ';
508                 
509 //      prestep if horizontally scrolling
510         if (key_linepos >= con_linewidth)
511                 text += 1 + key_linepos - con_linewidth;
512                 
513 // draw it
514         y = con_vislines-16;
515
516 //      for (i=0 ; i<con_linewidth ; i++)
517 //              Draw_Character ( (i+1)<<3, con_vislines - 16, text[i]);
518         // LordHavoc: speedup
519         Draw_String(8, con_vislines - 16, text, con_linewidth);
520
521 // remove cursor
522         key_lines[edit_line][key_linepos] = 0;
523 }
524
525
526 /*
527 ================
528 Con_DrawNotify
529
530 Draws the last few lines of output transparently over the game top
531 ================
532 */
533 void Con_DrawNotify (void)
534 {
535         int             x, v;
536         char    *text;
537         int             i;
538         float   time;
539         extern char chat_buffer[];
540         char    temptext[256];
541
542         v = 0;
543         for (i= con_current-NUM_CON_TIMES+1 ; i<=con_current ; i++)
544         {
545                 if (i < 0)
546                         continue;
547                 time = con_times[i % NUM_CON_TIMES];
548                 if (time == 0)
549                         continue;
550                 time = realtime - time;
551                 if (time > con_notifytime.value)
552                         continue;
553                 text = con_text + (i % con_totallines)*con_linewidth;
554                 
555                 clearnotify = 0;
556                 scr_copytop = 1;
557
558 //              for (x = 0 ; x < con_linewidth ; x++)
559 //                      Draw_Character ( (x+1)<<3, v, text[x]);
560                 // LordHavoc: speedup
561                 Draw_String(8, v, text, con_linewidth);
562
563                 v += 8;
564         }
565
566
567         if (key_dest == key_message)
568         {
569                 clearnotify = 0;
570                 scr_copytop = 1;
571         
572                 x = 0;
573                 
574                 // LordHavoc: speedup, and other improvements
575                 if (team_message)
576                         sprintf(temptext, "say_team:%s%c", chat_buffer, (int) 10+((int)(realtime*con_cursorspeed)&1));
577                 else
578                         sprintf(temptext, "say:%s%c", chat_buffer, (int) 10+((int)(realtime*con_cursorspeed)&1));
579                 while (strlen(temptext) >= con_linewidth)
580                 {
581                         Draw_String (8, v, temptext, con_linewidth);
582                         strcpy(temptext, &temptext[con_linewidth]);
583                         v += 8;
584                 }
585                 if (strlen(temptext) > 0)
586                 {
587                         Draw_String (8, v, temptext, 0);
588                         v += 8;
589                 }
590 //              Draw_String (8, v, "say:", 0);
591 //              while(chat_buffer[x])
592 //              {
593 //                      Draw_Character ( (x+5)<<3, v, chat_buffer[x]);
594 //                      x++;
595 //              }
596 //              Draw_Character ( (x+5)<<3, v, 10+((int)(realtime*con_cursorspeed)&1));
597 //              v += 8;
598         }
599         
600         if (v > con_notifylines)
601                 con_notifylines = v;
602 }
603
604 /*
605 ================
606 Con_DrawConsole
607
608 Draws the console with the solid background
609 The typing input line at the bottom should only be drawn if typing is allowed
610 ================
611 */
612 void Con_DrawConsole (int lines, qboolean drawinput)
613 {
614         int                             i, y;
615         int                             rows;
616         char                    *text;
617         int                             j;
618         
619         if (lines <= 0)
620                 return;
621
622 // draw the background
623         Draw_ConsoleBackground (lines);
624
625 // draw the text
626         con_vislines = lines;
627
628         rows = (lines-16)>>3;           // rows of text to draw
629         y = lines - 16 - (rows<<3);     // may start slightly negative
630
631         for (i= con_current - rows + 1 ; i<=con_current ; i++, y+=8 )
632         {
633                 j = i - con_backscroll;
634                 if (j<0)
635                         j = 0;
636                 text = con_text + (j % con_totallines)*con_linewidth;
637
638 //              for (x=0 ; x<con_linewidth ; x++)
639 //                      Draw_Character ( (x+1)<<3, y, text[x]);
640                 // LordHavoc: speedup
641                 Draw_String(8, y, text, con_linewidth);
642         }
643
644 // draw the input prompt, user text, and cursor if desired
645         if (drawinput)
646                 Con_DrawInput ();
647 }
648
649
650 /*
651 ==================
652 Con_NotifyBox
653 ==================
654 */
655 void Con_NotifyBox (char *text)
656 {
657         double          t1, t2;
658
659 // during startup for sound / cd warnings
660         Con_Printf("\n\n\35\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\37\n");
661
662         Con_Printf (text);
663
664         Con_Printf ("Press a key.\n");
665         Con_Printf("\35\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\37\n");
666
667         key_count = -2;         // wait for a key down and up
668         key_dest = key_console;
669
670         do
671         {
672                 t1 = Sys_FloatTime ();
673                 SCR_UpdateScreen ();
674                 Sys_SendKeyEvents ();
675                 t2 = Sys_FloatTime ();
676                 realtime += t2-t1;              // make the cursor blink
677         } while (key_count < 0);
678
679         Con_Printf ("\n");
680         key_dest = key_game;
681         realtime = 0;                           // put the cursor back to invisible
682 }
683