d72e24bfec35d0279ba708333abc034f967bb715
[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 #if !defined(WIN32) || defined(__MINGW32__)
23 # include <unistd.h>
24 #endif
25 #include <time.h>
26 #include "quakedef.h"
27
28 int con_linewidth;
29
30 float con_cursorspeed = 4;
31
32 #define         CON_TEXTSIZE    131072
33
34 // total lines in console scrollback
35 int con_totallines;
36 // lines up from bottom to display
37 int con_backscroll;
38 // where next message will be printed
39 int con_current;
40 // offset in current line for next print
41 int con_x;
42 char con_text[CON_TEXTSIZE];
43
44 cvar_t con_notifytime = {CVAR_SAVE, "con_notifytime","3", "how long notify lines last, in seconds"};
45 cvar_t con_notify = {CVAR_SAVE, "con_notify","4", "how many notify lines to show (0-32)"};
46 cvar_t con_textsize = {CVAR_SAVE, "con_textsize","8", "console text size in virtual 2D pixels"};        //[515]: console text size in pixels
47
48 #define MAX_NOTIFYLINES 32
49 // cl.time time the line was generated for transparent notify lines
50 float con_times[MAX_NOTIFYLINES];
51
52 int con_vislines;
53
54 qboolean con_initialized;
55
56 // used for server replies to rcon command
57 qboolean rcon_redirect = false;
58 int rcon_redirect_bufferpos = 0;
59 char rcon_redirect_buffer[1400];
60
61
62 /*
63 ==============================================================================
64
65 LOGGING
66
67 ==============================================================================
68 */
69
70 cvar_t log_file = {0, "log_file","", "filename to log messages to"};
71 char crt_log_file [MAX_OSPATH] = "";
72 qfile_t* logfile = NULL;
73
74 unsigned char* logqueue = NULL;
75 size_t logq_ind = 0;
76 size_t logq_size = 0;
77
78 void Log_ConPrint (const char *msg);
79
80 /*
81 ====================
82 Log_Timestamp
83 ====================
84 */
85 const char* Log_Timestamp (const char *desc)
86 {
87         static char timestamp [128];
88         time_t crt_time;
89         const struct tm *crt_tm;
90         char timestring [64];
91
92         // Build the time stamp (ex: "Wed Jun 30 21:49:08 1993");
93         time (&crt_time);
94         crt_tm = localtime (&crt_time);
95         strftime (timestring, sizeof (timestring), "%a %b %d %H:%M:%S %Y", crt_tm);
96
97         if (desc != NULL)
98                 dpsnprintf (timestamp, sizeof (timestamp), "====== %s (%s) ======\n", desc, timestring);
99         else
100                 dpsnprintf (timestamp, sizeof (timestamp), "====== %s ======\n", timestring);
101
102         return timestamp;
103 }
104
105
106 /*
107 ====================
108 Log_Open
109 ====================
110 */
111 void Log_Open (void)
112 {
113         if (logfile != NULL || log_file.string[0] == '\0')
114                 return;
115
116         logfile = FS_Open (log_file.string, "ab", false, false);
117         if (logfile != NULL)
118         {
119                 strlcpy (crt_log_file, log_file.string, sizeof (crt_log_file));
120                 FS_Print (logfile, Log_Timestamp ("Log started"));
121         }
122 }
123
124
125 /*
126 ====================
127 Log_Close
128 ====================
129 */
130 void Log_Close (void)
131 {
132         if (logfile == NULL)
133                 return;
134
135         FS_Print (logfile, Log_Timestamp ("Log stopped"));
136         FS_Print (logfile, "\n");
137         FS_Close (logfile);
138
139         logfile = NULL;
140         crt_log_file[0] = '\0';
141 }
142
143
144 /*
145 ====================
146 Log_Start
147 ====================
148 */
149 void Log_Start (void)
150 {
151         Log_Open ();
152
153         // Dump the contents of the log queue into the log file and free it
154         if (logqueue != NULL)
155         {
156                 unsigned char *temp = logqueue;
157                 logqueue = NULL;
158                 if (logfile != NULL && logq_ind != 0)
159                         FS_Write (logfile, temp, logq_ind);
160                 Mem_Free (temp);
161                 logq_ind = 0;
162                 logq_size = 0;
163         }
164 }
165
166
167 /*
168 ================
169 Log_ConPrint
170 ================
171 */
172 void Log_ConPrint (const char *msg)
173 {
174         static qboolean inprogress = false;
175
176         // don't allow feedback loops with memory error reports
177         if (inprogress)
178                 return;
179         inprogress = true;
180
181         // Until the host is completely initialized, we maintain a log queue
182         // to store the messages, since the log can't be started before
183         if (logqueue != NULL)
184         {
185                 size_t remain = logq_size - logq_ind;
186                 size_t len = strlen (msg);
187
188                 // If we need to enlarge the log queue
189                 if (len > remain)
190                 {
191                         size_t factor = ((logq_ind + len) / logq_size) + 1;
192                         unsigned char* newqueue;
193
194                         logq_size *= factor;
195                         newqueue = (unsigned char *)Mem_Alloc (tempmempool, logq_size);
196                         memcpy (newqueue, logqueue, logq_ind);
197                         Mem_Free (logqueue);
198                         logqueue = newqueue;
199                         remain = logq_size - logq_ind;
200                 }
201                 memcpy (&logqueue[logq_ind], msg, len);
202                 logq_ind += len;
203
204                 inprogress = false;
205                 return;
206         }
207
208         // Check if log_file has changed
209         if (strcmp (crt_log_file, log_file.string) != 0)
210         {
211                 Log_Close ();
212                 Log_Open ();
213         }
214
215         // If a log file is available
216         if (logfile != NULL)
217                 FS_Print (logfile, msg);
218         inprogress = false;
219 }
220
221
222 /*
223 ================
224 Log_Printf
225 ================
226 */
227 void Log_Printf (const char *logfilename, const char *fmt, ...)
228 {
229         qfile_t *file;
230
231         file = FS_Open (logfilename, "ab", true, false);
232         if (file != NULL)
233         {
234                 va_list argptr;
235
236                 va_start (argptr, fmt);
237                 FS_VPrintf (file, fmt, argptr);
238                 va_end (argptr);
239
240                 FS_Close (file);
241         }
242 }
243
244
245 /*
246 ==============================================================================
247
248 CONSOLE
249
250 ==============================================================================
251 */
252
253 /*
254 ================
255 Con_ToggleConsole_f
256 ================
257 */
258 void Con_ToggleConsole_f (void)
259 {
260         // toggle the 'user wants console' bit
261         key_consoleactive ^= KEY_CONSOLEACTIVE_USER;
262         memset (con_times, 0, sizeof(con_times));
263 }
264
265 /*
266 ================
267 Con_Clear_f
268 ================
269 */
270 void Con_Clear_f (void)
271 {
272         if (con_text)
273                 memset (con_text, ' ', CON_TEXTSIZE);
274 }
275
276
277 /*
278 ================
279 Con_ClearNotify
280 ================
281 */
282 void Con_ClearNotify (void)
283 {
284         int i;
285
286         for (i=0 ; i<MAX_NOTIFYLINES ; i++)
287                 con_times[i] = 0;
288 }
289
290
291 /*
292 ================
293 Con_MessageMode_f
294 ================
295 */
296 void Con_MessageMode_f (void)
297 {
298         key_dest = key_message;
299         chat_team = false;
300 }
301
302
303 /*
304 ================
305 Con_MessageMode2_f
306 ================
307 */
308 void Con_MessageMode2_f (void)
309 {
310         key_dest = key_message;
311         chat_team = true;
312 }
313
314
315 /*
316 ================
317 Con_CheckResize
318
319 If the line width has changed, reformat the buffer.
320 ================
321 */
322 void Con_CheckResize (void)
323 {
324         int i, j, width, oldwidth, oldtotallines, numlines, numchars;
325         float f;
326         char tbuf[CON_TEXTSIZE];
327
328         f = bound(1, con_textsize.value, 128);
329         if(f != con_textsize.value)
330                 Cvar_SetValueQuick(&con_textsize, f);
331         width = (int)floor(vid_conwidth.value / con_textsize.value);
332         width = bound(1, width, CON_TEXTSIZE/4);
333
334         if (width == con_linewidth)
335                 return;
336
337         oldwidth = con_linewidth;
338         con_linewidth = width;
339         oldtotallines = con_totallines;
340         con_totallines = CON_TEXTSIZE / con_linewidth;
341         numlines = oldtotallines;
342
343         if (con_totallines < numlines)
344                 numlines = con_totallines;
345
346         numchars = oldwidth;
347
348         if (con_linewidth < numchars)
349                 numchars = con_linewidth;
350
351         memcpy (tbuf, con_text, CON_TEXTSIZE);
352         memset (con_text, ' ', CON_TEXTSIZE);
353
354         for (i=0 ; i<numlines ; i++)
355         {
356                 for (j=0 ; j<numchars ; j++)
357                 {
358                         con_text[(con_totallines - 1 - i) * con_linewidth + j] =
359                                         tbuf[((con_current - i + oldtotallines) %
360                                                   oldtotallines) * oldwidth + j];
361                 }
362         }
363
364         Con_ClearNotify ();
365
366         con_backscroll = 0;
367         con_current = con_totallines - 1;
368 }
369
370 //[515]: the simplest command ever
371 //LordHavoc: not so simple after I made it print usage...
372 static void Con_Maps_f (void)
373 {
374         if (Cmd_Argc() > 2)
375         {
376                 Con_Printf("usage: maps [mapnameprefix]\n");
377                 return;
378         }
379         else if (Cmd_Argc() == 2)
380                 GetMapList(Cmd_Argv(1), NULL, 0);
381         else
382                 GetMapList("", NULL, 0);
383 }
384
385 /*
386 ================
387 Con_Init
388 ================
389 */
390 void Con_Init (void)
391 {
392         memset (con_text, ' ', CON_TEXTSIZE);
393         con_linewidth = 80;
394         con_totallines = CON_TEXTSIZE / con_linewidth;
395
396         // Allocate a log queue, this will be freed after configs are parsed
397         logq_size = MAX_INPUTLINE;
398         logqueue = (unsigned char *)Mem_Alloc (tempmempool, logq_size);
399         logq_ind = 0;
400
401         Cvar_RegisterVariable (&log_file);
402
403         // support for the classic Quake option
404 // COMMANDLINEOPTION: Console: -condebug logs console messages to qconsole.log, see also log_file
405         if (COM_CheckParm ("-condebug") != 0)
406                 Cvar_SetQuick (&log_file, "qconsole.log");
407 }
408
409 void Con_Init_Commands (void)
410 {
411         // register our cvars
412         Cvar_RegisterVariable (&con_notifytime);
413         Cvar_RegisterVariable (&con_notify);
414         Cvar_RegisterVariable (&con_textsize);
415
416         // register our commands
417         Cmd_AddCommand ("toggleconsole", Con_ToggleConsole_f, "opens or closes the console");
418         Cmd_AddCommand ("messagemode", Con_MessageMode_f, "input a chat message to say to everyone");
419         Cmd_AddCommand ("messagemode2", Con_MessageMode2_f, "input a chat message to say to only your team");
420         Cmd_AddCommand ("clear", Con_Clear_f, "clear console history");
421         Cmd_AddCommand ("maps", Con_Maps_f, "list information about available maps");   // By [515]
422
423         con_initialized = true;
424         Con_Print("Console initialized.\n");
425 }
426
427
428 /*
429 ===============
430 Con_Linefeed
431 ===============
432 */
433 void Con_Linefeed (void)
434 {
435         if (con_backscroll)
436                 con_backscroll++;
437
438         con_x = 0;
439         con_current++;
440         memset (&con_text[(con_current%con_totallines)*con_linewidth], ' ', con_linewidth);
441 }
442
443 /*
444 ================
445 Con_PrintToHistory
446
447 Handles cursor positioning, line wrapping, etc
448 All console printing must go through this in order to be displayed
449 If no console is visible, the notify window will pop up.
450 ================
451 */
452 void Con_PrintToHistory(const char *txt, int mask)
453 {
454         int y, c, l;
455         static int cr;
456
457         while ( (c = *txt) )
458         {
459         // count word length
460                 for (l=0 ; l< con_linewidth ; l++)
461                         if ( txt[l] <= ' ')
462                                 break;
463
464         // word wrap
465                 if (l != con_linewidth && (con_x + l > con_linewidth) )
466                         con_x = 0;
467
468                 txt++;
469
470                 if (cr)
471                 {
472                         con_current--;
473                         cr = false;
474                 }
475
476
477                 if (!con_x)
478                 {
479                         Con_Linefeed ();
480                 // mark time for transparent overlay
481                         if (con_current >= 0)
482                         {
483                                 if (con_notify.integer < 0)
484                                         Cvar_SetValueQuick(&con_notify, 0);
485                                 if (con_notify.integer > MAX_NOTIFYLINES)
486                                         Cvar_SetValueQuick(&con_notify, MAX_NOTIFYLINES);
487                                 if (con_notify.integer > 0)
488                                         con_times[con_current % con_notify.integer] = cl.time;
489                         }
490                 }
491
492                 switch (c)
493                 {
494                 case '\n':
495                         con_x = 0;
496                         break;
497
498                 case '\r':
499                         con_x = 0;
500                         cr = 1;
501                         break;
502
503                 default:        // display character and advance
504                         y = con_current % con_totallines;
505                         con_text[y*con_linewidth+con_x] = c | mask;
506                         con_x++;
507                         if (con_x >= con_linewidth)
508                                 con_x = 0;
509                         break;
510                 }
511
512         }
513 }
514
515 /* The translation table between the graphical font and plain ASCII  --KB */
516 static char qfont_table[256] = {
517         '\0', '#',  '#',  '#',  '#',  '.',  '#',  '#',
518         '#',  9,    10,   '#',  ' ',  13,   '.',  '.',
519         '[',  ']',  '0',  '1',  '2',  '3',  '4',  '5',
520         '6',  '7',  '8',  '9',  '.',  '<',  '=',  '>',
521         ' ',  '!',  '"',  '#',  '$',  '%',  '&',  '\'',
522         '(',  ')',  '*',  '+',  ',',  '-',  '.',  '/',
523         '0',  '1',  '2',  '3',  '4',  '5',  '6',  '7',
524         '8',  '9',  ':',  ';',  '<',  '=',  '>',  '?',
525         '@',  'A',  'B',  'C',  'D',  'E',  'F',  'G',
526         'H',  'I',  'J',  'K',  'L',  'M',  'N',  'O',
527         'P',  'Q',  'R',  'S',  'T',  'U',  'V',  'W',
528         'X',  'Y',  'Z',  '[',  '\\', ']',  '^',  '_',
529         '`',  'a',  'b',  'c',  'd',  'e',  'f',  'g',
530         'h',  'i',  'j',  'k',  'l',  'm',  'n',  'o',
531         'p',  'q',  'r',  's',  't',  'u',  'v',  'w',
532         'x',  'y',  'z',  '{',  '|',  '}',  '~',  '<',
533
534         '<',  '=',  '>',  '#',  '#',  '.',  '#',  '#',
535         '#',  '#',  ' ',  '#',  ' ',  '>',  '.',  '.',
536         '[',  ']',  '0',  '1',  '2',  '3',  '4',  '5',
537         '6',  '7',  '8',  '9',  '.',  '<',  '=',  '>',
538         ' ',  '!',  '"',  '#',  '$',  '%',  '&',  '\'',
539         '(',  ')',  '*',  '+',  ',',  '-',  '.',  '/',
540         '0',  '1',  '2',  '3',  '4',  '5',  '6',  '7',
541         '8',  '9',  ':',  ';',  '<',  '=',  '>',  '?',
542         '@',  'A',  'B',  'C',  'D',  'E',  'F',  'G',
543         'H',  'I',  'J',  'K',  'L',  'M',  'N',  'O',
544         'P',  'Q',  'R',  'S',  'T',  'U',  'V',  'W',
545         'X',  'Y',  'Z',  '[',  '\\', ']',  '^',  '_',
546         '`',  'a',  'b',  'c',  'd',  'e',  'f',  'g',
547         'h',  'i',  'j',  'k',  'l',  'm',  'n',  'o',
548         'p',  'q',  'r',  's',  't',  'u',  'v',  'w',
549         'x',  'y',  'z',  '{',  '|',  '}',  '~',  '<'
550 };
551
552 /*
553 ================
554 Con_Print
555
556 Prints to all appropriate console targets, and adds timestamps
557 ================
558 */
559 extern cvar_t timestamps;
560 extern cvar_t timeformat;
561 extern qboolean sys_nostdout;
562 void Con_Print(const char *msg)
563 {
564         int mask = 0;
565         static int index = 0;
566         static char line[MAX_INPUTLINE];
567
568         for (;*msg;msg++)
569         {
570                 // if this print is in response to an rcon command, add the character
571                 // to the rcon redirect buffer
572                 if (rcon_redirect && rcon_redirect_bufferpos < (int)sizeof(rcon_redirect_buffer) - 1)
573                         rcon_redirect_buffer[rcon_redirect_bufferpos++] = *msg;
574                 // if this is the beginning of a new line, print timestamp
575                 if (index == 0)
576                 {
577                         const char *timestamp = timestamps.integer ? Sys_TimeString(timeformat.string) : "";
578                         // reset the color
579                         // FIXME: 1. perhaps we should use a terminal system 2. use a constant instead of 7!
580                         line[index++] = STRING_COLOR_TAG;
581                         // assert( STRING_COLOR_DEFAULT < 10 )
582                         line[index++] = STRING_COLOR_DEFAULT + '0';
583                         // special color codes for chat messages must always come first
584                         // for Con_PrintToHistory to work properly
585                         if (*msg <= 2)
586                         {
587                                 if (*msg == 1)
588                                 {
589                                         // play talk wav
590                                         S_LocalSound ("sound/misc/talk.wav");
591                                 }
592                                 //if (gamemode == GAME_NEXUIZ)
593                                 //{
594                                         line[index++] = STRING_COLOR_TAG;
595                                         line[index++] = '3';
596                                 //}
597                                 //else
598                                 //{
599                                 //      // go to colored text
600                                 //      mask = 128;
601                                 //}
602                                 msg++;
603                         }
604                         // store timestamp
605                         for (;*timestamp;index++, timestamp++)
606                                 if (index < (int)sizeof(line) - 2)
607                                         line[index] = *timestamp;
608                 }
609                 // append the character
610                 line[index++] = *msg;
611                 // if this is a newline character, we have a complete line to print
612                 if (*msg == '\n' || index >= (int)sizeof(line) / 2)
613                 {
614                         // terminate the line
615                         line[index] = 0;
616                         // send to log file
617                         Log_ConPrint(line);
618                         // send to scrollable buffer
619                         if (con_initialized && cls.state != ca_dedicated)
620                                 Con_PrintToHistory(line, mask);
621                         // send to terminal or dedicated server window
622                         if (!sys_nostdout)
623                         {
624                                 unsigned char *p;
625                                 for (p = (unsigned char *) line;*p; p++)
626                                         *p = qfont_table[*p];
627                                 Sys_PrintToTerminal(line);
628                         }
629                         // empty the line buffer
630                         index = 0;
631                 }
632         }
633 }
634
635
636 /*
637 ================
638 Con_Printf
639
640 Prints to all appropriate console targets
641 ================
642 */
643 void Con_Printf(const char *fmt, ...)
644 {
645         va_list argptr;
646         char msg[MAX_INPUTLINE];
647
648         va_start(argptr,fmt);
649         dpvsnprintf(msg,sizeof(msg),fmt,argptr);
650         va_end(argptr);
651
652         Con_Print(msg);
653 }
654
655 /*
656 ================
657 Con_DPrint
658
659 A Con_Print that only shows up if the "developer" cvar is set
660 ================
661 */
662 void Con_DPrint(const char *msg)
663 {
664         if (!developer.integer)
665                 return;                 // don't confuse non-developers with techie stuff...
666         Con_Print(msg);
667 }
668
669 /*
670 ================
671 Con_DPrintf
672
673 A Con_Printf that only shows up if the "developer" cvar is set
674 ================
675 */
676 void Con_DPrintf(const char *fmt, ...)
677 {
678         va_list argptr;
679         char msg[MAX_INPUTLINE];
680
681         if (!developer.integer)
682                 return;                 // don't confuse non-developers with techie stuff...
683
684         va_start(argptr,fmt);
685         dpvsnprintf(msg,sizeof(msg),fmt,argptr);
686         va_end(argptr);
687
688         Con_Print(msg);
689 }
690
691
692 /*
693 ==============================================================================
694
695 DRAWING
696
697 ==============================================================================
698 */
699
700 /*
701 ================
702 Con_DrawInput
703
704 The input line scrolls horizontally if typing goes beyond the right edge
705
706 Modified by EvilTypeGuy eviltypeguy@qeradiant.com
707 ================
708 */
709 void Con_DrawInput (void)
710 {
711         int             y;
712         int             i;
713         char editlinecopy[MAX_INPUTLINE+1], *text;
714
715         if (!key_consoleactive)
716                 return;         // don't draw anything
717
718         text = strcpy(editlinecopy, key_lines[edit_line]);
719
720         // Advanced Console Editing by Radix radix@planetquake.com
721         // Added/Modified by EvilTypeGuy eviltypeguy@qeradiant.com
722         // use strlen of edit_line instead of key_linepos to allow editing
723         // of early characters w/o erasing
724
725         y = (int)strlen(text);
726
727 // fill out remainder with spaces
728         for (i = y; i < (int)sizeof(editlinecopy)-1; i++)
729                 text[i] = ' ';
730
731         // add the cursor frame
732         if ((int)(realtime*con_cursorspeed) & 1)                // cursor is visible
733                 text[key_linepos] = 11 + 130 * key_insert;      // either solid or triangle facing right
734
735 //      text[key_linepos + 1] = 0;
736
737         // prestep if horizontally scrolling
738         if (key_linepos >= con_linewidth)
739                 text += 1 + key_linepos - con_linewidth;
740
741         // draw it
742         DrawQ_ColoredString(0, con_vislines - con_textsize.value*2, text, con_linewidth, con_textsize.value, con_textsize.value, 1.0, 1.0, 1.0, 1.0, 0, NULL );
743
744         // remove cursor
745 //      key_lines[edit_line][key_linepos] = 0;
746 }
747
748
749 /*
750 ================
751 Con_DrawNotify
752
753 Draws the last few lines of output transparently over the game top
754 ================
755 */
756 void Con_DrawNotify (void)
757 {
758         float   x, v;
759         char    *text;
760         int             i;
761         float   time;
762         char    temptext[MAX_INPUTLINE];
763         int colorindex = -1; //-1 for default
764
765         if (con_notify.integer < 0)
766                 Cvar_SetValueQuick(&con_notify, 0);
767         if (con_notify.integer > MAX_NOTIFYLINES)
768                 Cvar_SetValueQuick(&con_notify, MAX_NOTIFYLINES);
769         if (gamemode == GAME_TRANSFUSION)
770                 v = 8;
771         else
772                 v = 0;
773         for (i= con_current-con_notify.integer+1 ; i<=con_current ; i++)
774         {
775
776                 if (i < 0)
777                         continue;
778                 time = con_times[i % con_notify.integer];
779                 if (time == 0)
780                         continue;
781                 time = cl.time - time;
782                 if (time > con_notifytime.value)
783                         continue;
784                 text = con_text + (i % con_totallines)*con_linewidth;
785
786                 if (gamemode == GAME_NEXUIZ) {
787                         int linewidth;
788
789                         for (linewidth = con_linewidth; linewidth && text[linewidth-1] == ' '; linewidth--);
790                         x = (vid_conwidth.integer - linewidth * con_textsize.value) * 0.5;
791                 } else
792                         x = 0;
793
794                 DrawQ_ColoredString( x, v, text, con_linewidth, con_textsize.value, con_textsize.value, 1.0, 1.0, 1.0, 1.0, 0, &colorindex );
795
796                 v += con_textsize.value;
797         }
798
799
800         if (key_dest == key_message)
801         {
802                 int colorindex = -1;
803
804                 x = 0;
805
806                 // LordHavoc: speedup, and other improvements
807                 if (chat_team)
808                         sprintf(temptext, "say_team:%s%c", chat_buffer, (int) 10+((int)(realtime*con_cursorspeed)&1));
809                 else
810                         sprintf(temptext, "say:%s%c", chat_buffer, (int) 10+((int)(realtime*con_cursorspeed)&1));
811                 while ((int)strlen(temptext) >= con_linewidth)
812                 {
813                         DrawQ_ColoredString( 0, v, temptext, con_linewidth, con_textsize.value, con_textsize.value, 1.0, 1.0, 1.0, 1.0, 0, &colorindex );
814                         strcpy(temptext, &temptext[con_linewidth]);
815                         v += con_textsize.value;
816                 }
817                 if (strlen(temptext) > 0)
818                 {
819                         DrawQ_ColoredString( 0, v, temptext, 0, con_textsize.value, con_textsize.value, 1.0, 1.0, 1.0, 1.0, 0, &colorindex );
820                         v += con_textsize.value;
821                 }
822         }
823 }
824
825 /*
826 ================
827 Con_DrawConsole
828
829 Draws the console with the solid background
830 The typing input line at the bottom should only be drawn if typing is allowed
831 ================
832 */
833 void Con_DrawConsole (int lines)
834 {
835         int i, rows, j;
836         float y;
837         char *text;
838         int colorindex = -1;
839
840         if (lines <= 0)
841                 return;
842
843 // draw the background
844         DrawQ_Pic(0, lines - vid_conheight.integer, scr_conbrightness.value >= 0.01f ? Draw_CachePic("gfx/conback", true) : NULL, vid_conwidth.integer, vid_conheight.integer, scr_conbrightness.value, scr_conbrightness.value, scr_conbrightness.value, scr_conalpha.value, 0);
845         DrawQ_String(vid_conwidth.integer - strlen(engineversion) * con_textsize.value - con_textsize.value, lines - con_textsize.value, engineversion, 0, con_textsize.value, con_textsize.value, 1, 0, 0, 1, 0);
846
847 // draw the text
848         con_vislines = lines;
849
850         rows = (int)ceil((lines/con_textsize.value)-2);         // rows of text to draw
851         y = lines - (rows+2)*con_textsize.value;        // may start slightly negative
852
853         for (i = con_current - rows + 1;i <= con_current;i++, y += con_textsize.value)
854         {
855                 j = max(i - con_backscroll, 0);
856                 text = con_text + (j % con_totallines)*con_linewidth;
857
858                 DrawQ_ColoredString( 0, y, text, con_linewidth, con_textsize.value, con_textsize.value, 1.0, 1.0, 1.0, 1.0, 0, &colorindex );
859         }
860
861 // draw the input prompt, user text, and cursor if desired
862         Con_DrawInput ();
863 }
864
865 /*
866 GetMapList
867
868 Made by [515]
869 Prints not only map filename, but also
870 its format (q1/q2/q3/hl) and even its message
871 */
872 //[515]: here is an ugly hack.. two gotos... oh my... *but it works*
873 //LordHavoc: rewrote bsp type detection, added mcbsp support and rewrote message extraction to do proper worldspawn parsing
874 //LordHavoc: added .ent file loading, and redesigned error handling to still try the .ent file even if the map format is not recognized, this also eliminated one goto
875 //LordHavoc: FIXME: man this GetMapList is STILL ugly code even after my cleanups...
876 qboolean GetMapList (const char *s, char *completedname, int completednamebufferlength)
877 {
878         fssearch_t      *t;
879         char            message[64];
880         int                     i, k, max, p, o, min;
881         unsigned char *len;
882         qfile_t         *f;
883         unsigned char buf[1024];
884
885         sprintf(message, "maps/%s*.bsp", s);
886         t = FS_Search(message, 1, true);
887         if(!t)
888                 return false;
889         if (t->numfilenames > 1)
890                 Con_Printf("^1 %i maps found :\n", t->numfilenames);
891         len = Z_Malloc(t->numfilenames);
892         min = 666;
893         for(max=i=0;i<t->numfilenames;i++)
894         {
895                 k = (int)strlen(t->filenames[i]);
896                 k -= 9;
897                 if(max < k)
898                         max = k;
899                 else
900                 if(min > k)
901                         min = k;
902                 len[i] = k;
903         }
904         o = (int)strlen(s);
905         for(i=0;i<t->numfilenames;i++)
906         {
907                 int lumpofs = 0, lumplen = 0;
908                 char *entities = NULL;
909                 const char *data = NULL;
910                 char keyname[64];
911                 char entfilename[MAX_QPATH];
912                 strcpy(message, "^1**ERROR**^7");
913                 p = 0;
914                 f = FS_Open(t->filenames[i], "rb", true, false);
915                 if(f)
916                 {
917                         memset(buf, 0, 1024);
918                         FS_Read(f, buf, 1024);
919                         if (!memcmp(buf, "IBSP", 4))
920                         {
921                                 p = LittleLong(((int *)buf)[1]);
922                                 if (p == Q3BSPVERSION)
923                                 {
924                                         q3dheader_t *header = (q3dheader_t *)buf;
925                                         lumpofs = LittleLong(header->lumps[Q3LUMP_ENTITIES].fileofs);
926                                         lumplen = LittleLong(header->lumps[Q3LUMP_ENTITIES].filelen);
927                                 }
928                                 else if (p == Q2BSPVERSION)
929                                 {
930                                         q2dheader_t *header = (q2dheader_t *)buf;
931                                         lumpofs = LittleLong(header->lumps[Q2LUMP_ENTITIES].fileofs);
932                                         lumplen = LittleLong(header->lumps[Q2LUMP_ENTITIES].filelen);
933                                 }
934                         }
935                         else if (!memcmp(buf, "MCBSPpad", 8))
936                         {
937                                 p = LittleLong(((int *)buf)[2]);
938                                 if (p == MCBSPVERSION)
939                                 {
940                                         int numhulls = LittleLong(((int *)buf)[3]);
941                                         lumpofs = LittleLong(((int *)buf)[3 + numhulls + LUMP_ENTITIES*2+0]);
942                                         lumplen = LittleLong(((int *)buf)[3 + numhulls + LUMP_ENTITIES*2+1]);
943                                 }
944                         }
945                         else if((p = LittleLong(((int *)buf)[0])) == BSPVERSION || p == 30)
946                         {
947                                 dheader_t *header = (dheader_t *)buf;
948                                 lumpofs = LittleLong(header->lumps[LUMP_ENTITIES].fileofs);
949                                 lumplen = LittleLong(header->lumps[LUMP_ENTITIES].filelen);
950                         }
951                         else
952                                 p = 0;
953                         strlcpy(entfilename, t->filenames[i], sizeof(entfilename));
954                         strcpy(entfilename + strlen(entfilename) - 4, ".ent");
955                         entities = (char *)FS_LoadFile(entfilename, tempmempool, true, NULL);
956                         if (!entities && lumplen >= 10)
957                         {
958                                 FS_Seek(f, lumpofs, SEEK_SET);
959                                 entities = Z_Malloc(lumplen + 1);
960                                 FS_Read(f, entities, lumplen);
961                         }
962                         if (entities)
963                         {
964                                 // if there are entities to parse, a missing message key just
965                                 // means there is no title, so clear the message string now
966                                 message[0] = 0;
967                                 data = entities;
968                                 for (;;)
969                                 {
970                                         int l;
971                                         if (!COM_ParseToken(&data, false))
972                                                 break;
973                                         if (com_token[0] == '{')
974                                                 continue;
975                                         if (com_token[0] == '}')
976                                                 break;
977                                         // skip leading whitespace
978                                         for (k = 0;com_token[k] && com_token[k] <= ' ';k++);
979                                         for (l = 0;l < (int)sizeof(keyname) - 1 && com_token[k+l] && com_token[k+l] > ' ';l++)
980                                                 keyname[l] = com_token[k+l];
981                                         keyname[l] = 0;
982                                         if (!COM_ParseToken(&data, false))
983                                                 break;
984                                         if (developer.integer >= 2)
985                                                 Con_Printf("key: %s %s\n", keyname, com_token);
986                                         if (!strcmp(keyname, "message"))
987                                         {
988                                                 // get the message contents
989                                                 strlcpy(message, com_token, sizeof(message));
990                                                 break;
991                                         }
992                                 }
993                         }
994                 }
995                 if (entities)
996                         Z_Free(entities);
997                 if(f)
998                         FS_Close(f);
999                 *(t->filenames[i]+len[i]+5) = 0;
1000                 switch(p)
1001                 {
1002                 case Q3BSPVERSION:      strcpy((char *)buf, "Q3");break;
1003                 case Q2BSPVERSION:      strcpy((char *)buf, "Q2");break;
1004                 case BSPVERSION:        strcpy((char *)buf, "Q1");break;
1005                 case MCBSPVERSION:      strcpy((char *)buf, "MC");break;
1006                 case 30:                        strcpy((char *)buf, "HL");break;
1007                 default:                        strcpy((char *)buf, "??");break;
1008                 }
1009                 Con_Printf("%16s (%s) %s\n", t->filenames[i]+5, buf, message);
1010         }
1011         Con_Print("\n");
1012         for(p=o;p<min;p++)
1013         {
1014                 k = *(t->filenames[0]+5+p);
1015                 if(k == 0)
1016                         goto endcomplete;
1017                 for(i=1;i<t->numfilenames;i++)
1018                         if(*(t->filenames[i]+5+p) != k)
1019                                 goto endcomplete;
1020         }
1021 endcomplete:
1022         if(p > o)
1023         {
1024                 memset(completedname, 0, completednamebufferlength);
1025                 memcpy(completedname, (t->filenames[0]+5), min(p, completednamebufferlength - 1));
1026         }
1027         Z_Free(len);
1028         FS_FreeSearch(t);
1029         return p > o;
1030 }
1031
1032 /*
1033         Con_DisplayList
1034
1035         New function for tab-completion system
1036         Added by EvilTypeGuy
1037         MEGA Thanks to Taniwha
1038
1039 */
1040 void Con_DisplayList(const char **list)
1041 {
1042         int i = 0, pos = 0, len = 0, maxlen = 0, width = (con_linewidth - 4);
1043         const char **walk = list;
1044
1045         while (*walk) {
1046                 len = (int)strlen(*walk);
1047                 if (len > maxlen)
1048                         maxlen = len;
1049                 walk++;
1050         }
1051         maxlen += 1;
1052
1053         while (*list) {
1054                 len = (int)strlen(*list);
1055                 if (pos + maxlen >= width) {
1056                         Con_Print("\n");
1057                         pos = 0;
1058                 }
1059
1060                 Con_Print(*list);
1061                 for (i = 0; i < (maxlen - len); i++)
1062                         Con_Print(" ");
1063
1064                 pos += maxlen;
1065                 list++;
1066         }
1067
1068         if (pos)
1069                 Con_Print("\n\n");
1070 }
1071
1072 /*
1073         Con_CompleteCommandLine
1074
1075         New function for tab-completion system
1076         Added by EvilTypeGuy
1077         Thanks to Fett erich@heintz.com
1078         Thanks to taniwha
1079         Enhanced to tab-complete map names by [515]
1080
1081 */
1082 void Con_CompleteCommandLine (void)
1083 {
1084         const char *cmd = "";
1085         char *s;
1086         const char **list[3] = {0, 0, 0};
1087         char s2[512];
1088         int c, v, a, i, cmd_len, pos, k;
1089
1090         //find what we want to complete
1091         pos = key_linepos;
1092         while(--pos)
1093         {
1094                 k = key_lines[edit_line][pos];
1095                 if(k == '\"' || k == ';' || k == ' ' || k == '\'')
1096                         break;
1097         }
1098         pos++;
1099
1100         s = key_lines[edit_line] + pos;
1101         strlcpy(s2, key_lines[edit_line] + key_linepos, sizeof(s2));    //save chars after cursor
1102         key_lines[edit_line][key_linepos] = 0;                                  //hide them
1103
1104         //maps search
1105         for(k=pos-1;k>2;k--)
1106                 if(key_lines[edit_line][k] != ' ')
1107                 {
1108                         if(key_lines[edit_line][k] == '\"' || key_lines[edit_line][k] == ';' || key_lines[edit_line][k] == '\'')
1109                                 break;
1110                         if      ((pos+k > 2 && !strncmp(key_lines[edit_line]+k-2, "map", 3))
1111                                 || (pos+k > 10 && !strncmp(key_lines[edit_line]+k-10, "changelevel", 11)))
1112                         {
1113                                 char t[MAX_QPATH];
1114                                 if (GetMapList(s, t, sizeof(t)))
1115                                 {
1116                                         // first move the cursor
1117                                         key_linepos += (int)strlen(t) - (int)strlen(s);
1118
1119                                         // and now do the actual work
1120                                         *s = 0;
1121                                         strlcat(key_lines[edit_line], t, MAX_INPUTLINE);
1122                                         strlcat(key_lines[edit_line], s2, MAX_INPUTLINE); //add back chars after cursor
1123
1124                                         // and fix the cursor
1125                                         if(key_linepos > (int) strlen(key_lines[edit_line]))
1126                                                 key_linepos = (int) strlen(key_lines[edit_line]);
1127                                 }
1128                                 return;
1129                         }
1130                 }
1131
1132         // Count number of possible matches and print them
1133         c = Cmd_CompleteCountPossible(s);
1134         if (c)
1135         {
1136                 Con_Printf("\n%i possible command%s\n", c, (c > 1) ? "s: " : ":");
1137                 Cmd_CompleteCommandPrint(s);
1138         }
1139         v = Cvar_CompleteCountPossible(s);
1140         if (v)
1141         {
1142                 Con_Printf("\n%i possible variable%s\n", v, (v > 1) ? "s: " : ":");
1143                 Cvar_CompleteCvarPrint(s);
1144         }
1145         a = Cmd_CompleteAliasCountPossible(s);
1146         if (a)
1147         {
1148                 Con_Printf("\n%i possible aliases%s\n", a, (a > 1) ? "s: " : ":");
1149                 Cmd_CompleteAliasPrint(s);
1150         }
1151
1152         if (!(c + v + a))       // No possible matches
1153         {
1154                 if(s2[0])
1155                         strcpy(&key_lines[edit_line][key_linepos], s2);
1156                 return;
1157         }
1158
1159         if (c)
1160                 cmd = *(list[0] = Cmd_CompleteBuildList(s));
1161         if (v)
1162                 cmd = *(list[1] = Cvar_CompleteBuildList(s));
1163         if (a)
1164                 cmd = *(list[2] = Cmd_CompleteAliasBuildList(s));
1165
1166         for (cmd_len = (int)strlen(s);;cmd_len++)
1167         {
1168                 const char **l;
1169                 for (i = 0; i < 3; i++)
1170                         if (list[i])
1171                                 for (l = list[i];*l;l++)
1172                                         if ((*l)[cmd_len] != cmd[cmd_len])
1173                                                 goto done;
1174                 // all possible matches share this character, so we continue...
1175                 if (!cmd[cmd_len])
1176                 {
1177                         // if all matches ended at the same position, stop
1178                         // (this means there is only one match)
1179                         break;
1180                 }
1181         }
1182 done:
1183
1184         // prevent a buffer overrun by limiting cmd_len according to remaining space
1185         cmd_len = min(cmd_len, (int)sizeof(key_lines[edit_line]) - 1 - pos);
1186         if (cmd)
1187         {
1188                 key_linepos = pos;
1189                 memcpy(&key_lines[edit_line][key_linepos], cmd, cmd_len);
1190                 key_linepos += cmd_len;
1191                 // if there is only one match, add a space after it
1192                 if (c + v + a == 1 && key_linepos < (int)sizeof(key_lines[edit_line]) - 1)
1193                         key_lines[edit_line][key_linepos++] = ' ';
1194         }
1195
1196         // use strlcat to avoid a buffer overrun
1197         key_lines[edit_line][key_linepos] = 0;
1198         strlcat(key_lines[edit_line], s2, sizeof(key_lines[edit_line]));
1199
1200         // free the command, cvar, and alias lists
1201         for (i = 0; i < 3; i++)
1202                 if (list[i])
1203                         Mem_Free((void *)list[i]);
1204 }
1205