]> git.xonotic.org Git - xonotic/darkplaces.git/blob - console.c
Remove Con_Warnf and Errorf. Use macros to change color and identify the message
[xonotic/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
27 #include "quakedef.h"
28 #include "thread.h"
29
30 // for u8_encodech
31 #include "ft2.h"
32
33 float con_cursorspeed = 4;
34
35 // lines up from bottom to display
36 int con_backscroll;
37
38 conbuffer_t con;
39 void *con_mutex = NULL;
40
41 #define CON_LINES(i) CONBUFFER_LINES(&con, i)
42 #define CON_LINES_LAST CONBUFFER_LINES_LAST(&con)
43 #define CON_LINES_COUNT CONBUFFER_LINES_COUNT(&con)
44
45 cvar_t con_notifytime = {CVAR_CLIENT | CVAR_SAVE, "con_notifytime","3", "how long notify lines last, in seconds"};
46 cvar_t con_notify = {CVAR_CLIENT | CVAR_SAVE, "con_notify","4", "how many notify lines to show"};
47 cvar_t con_notifyalign = {CVAR_CLIENT | CVAR_SAVE, "con_notifyalign", "", "how to align notify lines: 0 = left, 0.5 = center, 1 = right, empty string = game default)"};
48
49 cvar_t con_chattime = {CVAR_CLIENT | CVAR_SAVE, "con_chattime","30", "how long chat lines last, in seconds"};
50 cvar_t con_chat = {CVAR_CLIENT | CVAR_SAVE, "con_chat","0", "how many chat lines to show in a dedicated chat area"};
51 cvar_t con_chatpos = {CVAR_CLIENT | CVAR_SAVE, "con_chatpos","0", "where to put chat (negative: lines from bottom of screen, positive: lines below notify, 0: at top)"};
52 cvar_t con_chatrect = {CVAR_CLIENT | CVAR_SAVE, "con_chatrect","0", "use con_chatrect_x and _y to position con_notify and con_chat freely instead of con_chatpos"};
53 cvar_t con_chatrect_x = {CVAR_CLIENT | CVAR_SAVE, "con_chatrect_x","", "where to put chat, relative x coordinate of left edge on screen (use con_chatwidth for width)"};
54 cvar_t con_chatrect_y = {CVAR_CLIENT | CVAR_SAVE, "con_chatrect_y","", "where to put chat, relative y coordinate of top edge on screen (use con_chat for line count)"};
55 cvar_t con_chatwidth = {CVAR_CLIENT | CVAR_SAVE, "con_chatwidth","1.0", "relative chat window width"};
56 cvar_t con_textsize = {CVAR_CLIENT | CVAR_SAVE, "con_textsize","8", "console text size in virtual 2D pixels"};
57 cvar_t con_notifysize = {CVAR_CLIENT | CVAR_SAVE, "con_notifysize","8", "notify text size in virtual 2D pixels"};
58 cvar_t con_chatsize = {CVAR_CLIENT | CVAR_SAVE, "con_chatsize","8", "chat text size in virtual 2D pixels (if con_chat is enabled)"};
59 cvar_t con_chatsound = {CVAR_CLIENT | CVAR_SAVE, "con_chatsound","1", "enables chat sound to play on message"};
60 cvar_t con_chatsound_file = {CVAR_CLIENT, "con_chatsound_file","sound/misc/talk.wav", "The sound to play for chat messages"};
61 cvar_t con_chatsound_team_file = {CVAR_CLIENT, "con_chatsound_team_file","sound/misc/talk2.wav", "The sound to play for team chat messages"};
62 cvar_t con_chatsound_team_mask = {CVAR_CLIENT, "con_chatsound_team_mask","40","Magic ASCII code that denotes a team chat message"};
63
64 cvar_t sys_specialcharactertranslation = {CVAR_CLIENT | CVAR_SERVER, "sys_specialcharactertranslation", "1", "terminal console conchars to ASCII translation (set to 0 if your conchars.tga is for an 8bit character set or if you want raw output)"};
65 #ifdef WIN32
66 cvar_t sys_colortranslation = {CVAR_CLIENT | CVAR_SERVER, "sys_colortranslation", "0", "terminal console color translation (supported values: 0 = strip color codes, 1 = translate to ANSI codes, 2 = no translation)"};
67 #else
68 cvar_t sys_colortranslation = {CVAR_CLIENT | CVAR_SERVER, "sys_colortranslation", "1", "terminal console color translation (supported values: 0 = strip color codes, 1 = translate to ANSI codes, 2 = no translation)"};
69 #endif
70
71
72 cvar_t con_nickcompletion = {CVAR_CLIENT | CVAR_SAVE, "con_nickcompletion", "1", "tab-complete nicks in console and message input"};
73 cvar_t con_nickcompletion_flags = {CVAR_CLIENT | CVAR_SAVE, "con_nickcompletion_flags", "11", "Bitfield: "
74                                    "0: add nothing after completion. "
75                                    "1: add the last color after completion. "
76                                    "2: add a quote when starting a quote instead of the color. "
77                                    "4: will replace 1, will force color, even after a quote. "
78                                    "8: ignore non-alphanumerics. "
79                                    "16: ignore spaces. "};
80 #define NICKS_ADD_COLOR 1
81 #define NICKS_ADD_QUOTE 2
82 #define NICKS_FORCE_COLOR 4
83 #define NICKS_ALPHANUMERICS_ONLY 8
84 #define NICKS_NO_SPACES 16
85
86 cvar_t con_completion_playdemo = {CVAR_CLIENT | CVAR_SAVE, "con_completion_playdemo", "*.dem", "completion pattern for the playdemo command"};
87 cvar_t con_completion_timedemo = {CVAR_CLIENT | CVAR_SAVE, "con_completion_timedemo", "*.dem", "completion pattern for the timedemo command"};
88 cvar_t con_completion_exec = {CVAR_CLIENT | CVAR_SAVE, "con_completion_exec", "*.cfg", "completion pattern for the exec command"};
89
90 cvar_t condump_stripcolors = {CVAR_CLIENT | CVAR_SERVER| CVAR_SAVE, "condump_stripcolors", "0", "strip color codes from console dumps"};
91
92 int con_linewidth;
93 int con_vislines;
94
95 qboolean con_initialized;
96
97 // used for server replies to rcon command
98 lhnetsocket_t *rcon_redirect_sock = NULL;
99 lhnetaddress_t *rcon_redirect_dest = NULL;
100 int rcon_redirect_bufferpos = 0;
101 char rcon_redirect_buffer[1400];
102 qboolean rcon_redirect_proquakeprotocol = false;
103
104 // generic functions for console buffers
105
106 void ConBuffer_Init(conbuffer_t *buf, int textsize, int maxlines, mempool_t *mempool)
107 {
108         buf->active = true;
109         buf->textsize = textsize;
110         buf->text = (char *) Mem_Alloc(mempool, textsize);
111         buf->maxlines = maxlines;
112         buf->lines = (con_lineinfo_t *) Mem_Alloc(mempool, maxlines * sizeof(*buf->lines));
113         buf->lines_first = 0;
114         buf->lines_count = 0;
115 }
116
117 /*! The translation table between the graphical font and plain ASCII  --KB */
118 static char qfont_table[256] = {
119         '\0', '#',  '#',  '#',  '#',  '.',  '#',  '#',
120         '#',  9,    10,   '#',  ' ',  13,   '.',  '.',
121         '[',  ']',  '0',  '1',  '2',  '3',  '4',  '5',
122         '6',  '7',  '8',  '9',  '.',  '<',  '=',  '>',
123         ' ',  '!',  '"',  '#',  '$',  '%',  '&',  '\'',
124         '(',  ')',  '*',  '+',  ',',  '-',  '.',  '/',
125         '0',  '1',  '2',  '3',  '4',  '5',  '6',  '7',
126         '8',  '9',  ':',  ';',  '<',  '=',  '>',  '?',
127         '@',  'A',  'B',  'C',  'D',  'E',  'F',  'G',
128         'H',  'I',  'J',  'K',  'L',  'M',  'N',  'O',
129         'P',  'Q',  'R',  'S',  'T',  'U',  'V',  'W',
130         'X',  'Y',  'Z',  '[',  '\\', ']',  '^',  '_',
131         '`',  'a',  'b',  'c',  'd',  'e',  'f',  'g',
132         'h',  'i',  'j',  'k',  'l',  'm',  'n',  'o',
133         'p',  'q',  'r',  's',  't',  'u',  'v',  'w',
134         'x',  'y',  'z',  '{',  '|',  '}',  '~',  '<',
135
136         '<',  '=',  '>',  '#',  '#',  '.',  '#',  '#',
137         '#',  '#',  ' ',  '#',  ' ',  '>',  '.',  '.',
138         '[',  ']',  '0',  '1',  '2',  '3',  '4',  '5',
139         '6',  '7',  '8',  '9',  '.',  '<',  '=',  '>',
140         ' ',  '!',  '"',  '#',  '$',  '%',  '&',  '\'',
141         '(',  ')',  '*',  '+',  ',',  '-',  '.',  '/',
142         '0',  '1',  '2',  '3',  '4',  '5',  '6',  '7',
143         '8',  '9',  ':',  ';',  '<',  '=',  '>',  '?',
144         '@',  'A',  'B',  'C',  'D',  'E',  'F',  'G',
145         'H',  'I',  'J',  'K',  'L',  'M',  'N',  'O',
146         'P',  'Q',  'R',  'S',  'T',  'U',  'V',  'W',
147         'X',  'Y',  'Z',  '[',  '\\', ']',  '^',  '_',
148         '`',  'a',  'b',  'c',  'd',  'e',  'f',  'g',
149         'h',  'i',  'j',  'k',  'l',  'm',  'n',  'o',
150         'p',  'q',  'r',  's',  't',  'u',  'v',  'w',
151         'x',  'y',  'z',  '{',  '|',  '}',  '~',  '<'
152 };
153
154 /*
155         SanitizeString strips color tags from the string in
156         and writes the result on string out
157 */
158 static void SanitizeString(char *in, char *out)
159 {
160         while(*in)
161         {
162                 if(*in == STRING_COLOR_TAG)
163                 {
164                         ++in;
165                         if(!*in)
166                         {
167                                 out[0] = STRING_COLOR_TAG;
168                                 out[1] = 0;
169                                 return;
170                         }
171                         else if (*in >= '0' && *in <= '9') // ^[0-9] found
172                         {
173                                 ++in;
174                                 if(!*in)
175                                 {
176                                         *out = 0;
177                                         return;
178                                 } else if (*in == STRING_COLOR_TAG) // ^[0-9]^ found, don't print ^[0-9]
179                                         continue;
180                         }
181                         else if (*in == STRING_COLOR_RGB_TAG_CHAR) // ^x found
182                         {
183                                 if ( isxdigit(in[1]) && isxdigit(in[2]) && isxdigit(in[3]) )
184                                 {
185                                         in+=4;
186                                         if (!*in)
187                                         {
188                                                 *out = 0;
189                                                 return;
190                                         } else if (*in == STRING_COLOR_TAG) // ^xrgb^ found, don't print ^xrgb
191                                                 continue;
192                                 }
193                                 else in--;
194                         }
195                         else if (*in != STRING_COLOR_TAG)
196                                 --in;
197                 }
198                 *out = qfont_table[*(unsigned char*)in];
199                 ++in;
200                 ++out;
201         }
202         *out = 0;
203 }
204
205 /*
206 ================
207 ConBuffer_Clear
208 ================
209 */
210 void ConBuffer_Clear (conbuffer_t *buf)
211 {
212         buf->lines_count = 0;
213 }
214
215 /*
216 ================
217 ConBuffer_Shutdown
218 ================
219 */
220 void ConBuffer_Shutdown(conbuffer_t *buf)
221 {
222         buf->active = false;
223         if (buf->text)
224                 Mem_Free(buf->text);
225         if (buf->lines)
226                 Mem_Free(buf->lines);
227         buf->text = NULL;
228         buf->lines = NULL;
229 }
230
231 /*
232 ================
233 ConBuffer_FixTimes
234
235 Notifies the console code about the current time
236 (and shifts back times of other entries when the time
237 went backwards)
238 ================
239 */
240 void ConBuffer_FixTimes(conbuffer_t *buf)
241 {
242         int i;
243         if(buf->lines_count >= 1)
244         {
245                 double diff = cl.time - CONBUFFER_LINES_LAST(buf).addtime;
246                 if(diff < 0)
247                 {
248                         for(i = 0; i < buf->lines_count; ++i)
249                                 CONBUFFER_LINES(buf, i).addtime += diff;
250                 }
251         }
252 }
253
254 /*
255 ================
256 ConBuffer_DeleteLine
257
258 Deletes the first line from the console history.
259 ================
260 */
261 void ConBuffer_DeleteLine(conbuffer_t *buf)
262 {
263         if(buf->lines_count == 0)
264                 return;
265         --buf->lines_count;
266         buf->lines_first = (buf->lines_first + 1) % buf->maxlines;
267 }
268
269 /*
270 ================
271 ConBuffer_DeleteLastLine
272
273 Deletes the last line from the console history.
274 ================
275 */
276 void ConBuffer_DeleteLastLine(conbuffer_t *buf)
277 {
278         if(buf->lines_count == 0)
279                 return;
280         --buf->lines_count;
281 }
282
283 /*
284 ================
285 ConBuffer_BytesLeft
286
287 Checks if there is space for a line of the given length, and if yes, returns a
288 pointer to the start of such a space, and NULL otherwise.
289 ================
290 */
291 static char *ConBuffer_BytesLeft(conbuffer_t *buf, int len)
292 {
293         if(len > buf->textsize)
294                 return NULL;
295         if(buf->lines_count == 0)
296                 return buf->text;
297         else
298         {
299                 char *firstline_start = buf->lines[buf->lines_first].start;
300                 char *lastline_onepastend = CONBUFFER_LINES_LAST(buf).start + CONBUFFER_LINES_LAST(buf).len;
301                 // the buffer is cyclic, so we first have two cases...
302                 if(firstline_start < lastline_onepastend) // buffer is contiguous
303                 {
304                         // put at end?
305                         if(len <= buf->text + buf->textsize - lastline_onepastend)
306                                 return lastline_onepastend;
307                         // put at beginning?
308                         else if(len <= firstline_start - buf->text)
309                                 return buf->text;
310                         else
311                                 return NULL;
312                 }
313                 else // buffer has a contiguous hole
314                 {
315                         if(len <= firstline_start - lastline_onepastend)
316                                 return lastline_onepastend;
317                         else
318                                 return NULL;
319                 }
320         }
321 }
322
323 /*
324 ================
325 ConBuffer_AddLine
326
327 Appends a given string as a new line to the console.
328 ================
329 */
330 void ConBuffer_AddLine(conbuffer_t *buf, const char *line, int len, int mask)
331 {
332         char *putpos;
333         con_lineinfo_t *p;
334
335         // developer_memory 1 during shutdown prints while conbuffer_t is being freed
336         if (!buf->active)
337                 return;
338
339         ConBuffer_FixTimes(buf);
340
341         if(len >= buf->textsize)
342         {
343                 // line too large?
344                 // only display end of line.
345                 line += len - buf->textsize + 1;
346                 len = buf->textsize - 1;
347         }
348         while(!(putpos = ConBuffer_BytesLeft(buf, len + 1)) || buf->lines_count >= buf->maxlines)
349                 ConBuffer_DeleteLine(buf);
350         memcpy(putpos, line, len);
351         putpos[len] = 0;
352         ++buf->lines_count;
353
354         //fprintf(stderr, "Now have %d lines (%d -> %d).\n", buf->lines_count, buf->lines_first, CON_LINES_LAST);
355
356         p = &CONBUFFER_LINES_LAST(buf);
357         p->start = putpos;
358         p->len = len;
359         p->addtime = cl.time;
360         p->mask = mask;
361         p->height = -1; // calculate when needed
362 }
363
364 int ConBuffer_FindPrevLine(conbuffer_t *buf, int mask_must, int mask_mustnot, int start)
365 {
366         int i;
367         if(start == -1)
368                 start = buf->lines_count;
369         for(i = start - 1; i >= 0; --i)
370         {
371                 con_lineinfo_t *l = &CONBUFFER_LINES(buf, i);
372
373                 if((l->mask & mask_must) != mask_must)
374                         continue;
375                 if(l->mask & mask_mustnot)
376                         continue;
377
378                 return i;
379         }
380
381         return -1;
382 }
383
384 const char *ConBuffer_GetLine(conbuffer_t *buf, int i)
385 {
386         static char copybuf[MAX_INPUTLINE]; // client only
387         con_lineinfo_t *l = &CONBUFFER_LINES(buf, i);
388         size_t sz = l->len+1 > sizeof(copybuf) ? sizeof(copybuf) : l->len+1;
389         strlcpy(copybuf, l->start, sz);
390         return copybuf;
391 }
392
393 /*
394 ==============================================================================
395
396 LOGGING
397
398 ==============================================================================
399 */
400
401 /// \name Logging
402 //@{
403 cvar_t log_file = {CVAR_CLIENT | CVAR_SERVER, "log_file", "", "filename to log messages to"};
404 cvar_t log_file_stripcolors = {CVAR_CLIENT | CVAR_SERVER, "log_file_stripcolors", "0", "strip color codes from log messages"};
405 cvar_t log_dest_udp = {CVAR_CLIENT | CVAR_SERVER, "log_dest_udp", "", "UDP address to log messages to (in QW rcon compatible format); multiple destinations can be separated by spaces; DO NOT SPECIFY DNS NAMES HERE"};
406 char log_dest_buffer[1400]; // UDP packet
407 size_t log_dest_buffer_pos;
408 unsigned int log_dest_buffer_appending;
409 char crt_log_file [MAX_OSPATH] = "";
410 qfile_t* logfile = NULL;
411
412 unsigned char* logqueue = NULL;
413 size_t logq_ind = 0;
414 size_t logq_size = 0;
415
416 void Log_ConPrint (const char *msg);
417 //@}
418 static void Log_DestBuffer_Init(void)
419 {
420         memcpy(log_dest_buffer, "\377\377\377\377n", 5); // QW rcon print
421         log_dest_buffer_pos = 5;
422 }
423
424 static void Log_DestBuffer_Flush_NoLock(void)
425 {
426         lhnetaddress_t log_dest_addr;
427         lhnetsocket_t *log_dest_socket;
428         const char *s = log_dest_udp.string;
429         qboolean have_opened_temp_sockets = false;
430         if(s) if(log_dest_buffer_pos > 5)
431         {
432                 ++log_dest_buffer_appending;
433                 log_dest_buffer[log_dest_buffer_pos++] = 0;
434
435                 if(!NetConn_HaveServerPorts() && !NetConn_HaveClientPorts()) // then temporarily open one
436                 {
437                         have_opened_temp_sockets = true;
438                         NetConn_OpenServerPorts(true);
439                 }
440
441                 while(COM_ParseToken_Console(&s))
442                         if(LHNETADDRESS_FromString(&log_dest_addr, com_token, 26000))
443                         {
444                                 log_dest_socket = NetConn_ChooseClientSocketForAddress(&log_dest_addr);
445                                 if(!log_dest_socket)
446                                         log_dest_socket = NetConn_ChooseServerSocketForAddress(&log_dest_addr);
447                                 if(log_dest_socket)
448                                         NetConn_WriteString(log_dest_socket, log_dest_buffer, &log_dest_addr);
449                         }
450
451                 if(have_opened_temp_sockets)
452                         NetConn_CloseServerPorts();
453                 --log_dest_buffer_appending;
454         }
455         log_dest_buffer_pos = 0;
456 }
457
458 /*
459 ====================
460 Log_DestBuffer_Flush
461 ====================
462 */
463 void Log_DestBuffer_Flush(void)
464 {
465         if (con_mutex)
466                 Thread_LockMutex(con_mutex);
467         Log_DestBuffer_Flush_NoLock();
468         if (con_mutex)
469                 Thread_UnlockMutex(con_mutex);
470 }
471
472 static const char* Log_Timestamp (const char *desc)
473 {
474         static char timestamp [128]; // init/shutdown only
475         time_t crt_time;
476 #if _MSC_VER >= 1400
477         struct tm crt_tm;
478 #else
479         struct tm *crt_tm;
480 #endif
481         char timestring [64];
482
483         // Build the time stamp (ex: "Wed Jun 30 21:49:08 1993");
484         time (&crt_time);
485 #if _MSC_VER >= 1400
486         localtime_s (&crt_tm, &crt_time);
487         strftime (timestring, sizeof (timestring), "%a %b %d %H:%M:%S %Y", &crt_tm);
488 #else
489         crt_tm = localtime (&crt_time);
490         strftime (timestring, sizeof (timestring), "%a %b %d %H:%M:%S %Y", crt_tm);
491 #endif
492
493         if (desc != NULL)
494                 dpsnprintf (timestamp, sizeof (timestamp), "====== %s (%s) ======\n", desc, timestring);
495         else
496                 dpsnprintf (timestamp, sizeof (timestamp), "====== %s ======\n", timestring);
497
498         return timestamp;
499 }
500
501 static void Log_Open (void)
502 {
503         if (logfile != NULL || log_file.string[0] == '\0')
504                 return;
505
506         logfile = FS_OpenRealFile(log_file.string, "a", false);
507         if (logfile != NULL)
508         {
509                 strlcpy (crt_log_file, log_file.string, sizeof (crt_log_file));
510                 FS_Print (logfile, Log_Timestamp ("Log started"));
511         }
512 }
513
514 /*
515 ====================
516 Log_Close
517 ====================
518 */
519 void Log_Close (void)
520 {
521         if (logfile == NULL)
522                 return;
523
524         FS_Print (logfile, Log_Timestamp ("Log stopped"));
525         FS_Print (logfile, "\n");
526         FS_Close (logfile);
527
528         logfile = NULL;
529         crt_log_file[0] = '\0';
530 }
531
532
533 /*
534 ====================
535 Log_Start
536 ====================
537 */
538 void Log_Start (void)
539 {
540         size_t pos;
541         size_t n;
542         Log_Open ();
543
544         // Dump the contents of the log queue into the log file and free it
545         if (logqueue != NULL)
546         {
547                 unsigned char *temp = logqueue;
548                 logqueue = NULL;
549                 if(logq_ind != 0)
550                 {
551                         if (logfile != NULL)
552                                 FS_Write (logfile, temp, logq_ind);
553                         if(*log_dest_udp.string)
554                         {
555                                 for(pos = 0; pos < logq_ind; )
556                                 {
557                                         if(log_dest_buffer_pos == 0)
558                                                 Log_DestBuffer_Init();
559                                         n = min(sizeof(log_dest_buffer) - log_dest_buffer_pos - 1, logq_ind - pos);
560                                         memcpy(log_dest_buffer + log_dest_buffer_pos, temp + pos, n);
561                                         log_dest_buffer_pos += n;
562                                         Log_DestBuffer_Flush_NoLock();
563                                         pos += n;
564                                 }
565                         }
566                 }
567                 Mem_Free (temp);
568                 logq_ind = 0;
569                 logq_size = 0;
570         }
571 }
572
573
574
575 /*
576 ================
577 Log_ConPrint
578 ================
579 */
580 void Log_ConPrint (const char *msg)
581 {
582         static qboolean inprogress = false;
583
584         // don't allow feedback loops with memory error reports
585         if (inprogress)
586                 return;
587         inprogress = true;
588
589         // Until the host is completely initialized, we maintain a log queue
590         // to store the messages, since the log can't be started before
591         if (logqueue != NULL)
592         {
593                 size_t remain = logq_size - logq_ind;
594                 size_t len = strlen (msg);
595
596                 // If we need to enlarge the log queue
597                 if (len > remain)
598                 {
599                         size_t factor = ((logq_ind + len) / logq_size) + 1;
600                         unsigned char* newqueue;
601
602                         logq_size *= factor;
603                         newqueue = (unsigned char *)Mem_Alloc (tempmempool, logq_size);
604                         memcpy (newqueue, logqueue, logq_ind);
605                         Mem_Free (logqueue);
606                         logqueue = newqueue;
607                         remain = logq_size - logq_ind;
608                 }
609                 memcpy (&logqueue[logq_ind], msg, len);
610                 logq_ind += len;
611
612                 inprogress = false;
613                 return;
614         }
615
616         // Check if log_file has changed
617         if (strcmp (crt_log_file, log_file.string) != 0)
618         {
619                 Log_Close ();
620                 Log_Open ();
621         }
622
623         // If a log file is available
624         if (logfile != NULL)
625         {
626                 if (log_file_stripcolors.integer)
627                 {
628                         // sanitize msg
629                         size_t len = strlen(msg);
630                         char* sanitizedmsg = (char*)Mem_Alloc(tempmempool, len + 1);
631                         memcpy (sanitizedmsg, msg, len);
632                         SanitizeString(sanitizedmsg, sanitizedmsg); // SanitizeString's in pointer is always ahead of the out pointer, so this should work.
633                         FS_Print (logfile, sanitizedmsg);
634                         Mem_Free(sanitizedmsg);
635                 }
636                 else 
637                 {
638                         FS_Print (logfile, msg);
639                 }
640         }
641
642         inprogress = false;
643 }
644
645
646 /*
647 ================
648 Log_Printf
649 ================
650 */
651 void Log_Printf (const char *logfilename, const char *fmt, ...)
652 {
653         qfile_t *file;
654
655         file = FS_OpenRealFile(logfilename, "a", true);
656         if (file != NULL)
657         {
658                 va_list argptr;
659
660                 va_start (argptr, fmt);
661                 FS_VPrintf (file, fmt, argptr);
662                 va_end (argptr);
663
664                 FS_Close (file);
665         }
666 }
667
668
669 /*
670 ==============================================================================
671
672 CONSOLE
673
674 ==============================================================================
675 */
676
677 /*
678 ================
679 Con_ToggleConsole_f
680 ================
681 */
682 void Con_ToggleConsole_f(cmd_state_t *cmd)
683 {
684         if (COM_CheckParm ("-noconsole"))
685                 if (!(key_consoleactive & KEY_CONSOLEACTIVE_USER))
686                         return; // only allow the key bind to turn off console
687
688         // toggle the 'user wants console' bit
689         key_consoleactive ^= KEY_CONSOLEACTIVE_USER;
690         Con_ClearNotify();
691 }
692
693 /*
694 ================
695 Con_ClearNotify
696 ================
697 */
698 void Con_ClearNotify (void)
699 {
700         int i;
701         for(i = 0; i < CON_LINES_COUNT; ++i)
702                 if(!(CON_LINES(i).mask & CON_MASK_CHAT))
703                         CON_LINES(i).mask |= CON_MASK_HIDENOTIFY;
704 }
705
706
707 /*
708 ================
709 Con_MessageMode_f
710 ================
711 */
712 static void Con_MessageMode_f(cmd_state_t *cmd)
713 {
714         key_dest = key_message;
715         chat_mode = 0; // "say"
716         if(Cmd_Argc(cmd) > 1)
717         {
718                 dpsnprintf(chat_buffer, sizeof(chat_buffer), "%s ", Cmd_Args(cmd));
719                 chat_bufferlen = (unsigned int)strlen(chat_buffer);
720         }
721 }
722
723
724 /*
725 ================
726 Con_MessageMode2_f
727 ================
728 */
729 static void Con_MessageMode2_f(cmd_state_t *cmd)
730 {
731         key_dest = key_message;
732         chat_mode = 1; // "say_team"
733         if(Cmd_Argc(cmd) > 1)
734         {
735                 dpsnprintf(chat_buffer, sizeof(chat_buffer), "%s ", Cmd_Args(cmd));
736                 chat_bufferlen = (unsigned int)strlen(chat_buffer);
737         }
738 }
739
740 /*
741 ================
742 Con_CommandMode_f
743 ================
744 */
745 static void Con_CommandMode_f(cmd_state_t *cmd)
746 {
747         key_dest = key_message;
748         if(Cmd_Argc(cmd) > 1)
749         {
750                 dpsnprintf(chat_buffer, sizeof(chat_buffer), "%s ", Cmd_Args(cmd));
751                 chat_bufferlen = (unsigned int)strlen(chat_buffer);
752         }
753         chat_mode = -1; // command
754 }
755
756 /*
757 ================
758 Con_CheckResize
759 ================
760 */
761 void Con_CheckResize (void)
762 {
763         int i, width;
764         float f;
765
766         f = bound(1, con_textsize.value, 128);
767         if(f != con_textsize.value)
768                 Cvar_SetValueQuick(&con_textsize, f);
769         width = (int)floor(vid_conwidth.value / con_textsize.value);
770         width = bound(1, width, con.textsize/4);
771                 // FIXME uses con in a non abstracted way
772
773         if (width == con_linewidth)
774                 return;
775
776         con_linewidth = width;
777
778         for(i = 0; i < CON_LINES_COUNT; ++i)
779                 CON_LINES(i).height = -1; // recalculate when next needed
780
781         Con_ClearNotify();
782         con_backscroll = 0;
783 }
784
785 //[515]: the simplest command ever
786 //LadyHavoc: not so simple after I made it print usage...
787 static void Con_Maps_f(cmd_state_t *cmd)
788 {
789         if (Cmd_Argc(cmd) > 2)
790         {
791                 Con_Printf("usage: maps [mapnameprefix]\n");
792                 return;
793         }
794         else if (Cmd_Argc(cmd) == 2)
795                 GetMapList(Cmd_Argv(cmd, 1), NULL, 0);
796         else
797                 GetMapList("", NULL, 0);
798 }
799
800 static void Con_ConDump_f(cmd_state_t *cmd)
801 {
802         int i;
803         qfile_t *file;
804         if (Cmd_Argc(cmd) != 2)
805         {
806                 Con_Printf("usage: condump <filename>\n");
807                 return;
808         }
809         file = FS_OpenRealFile(Cmd_Argv(cmd, 1), "w", false);
810         if (!file)
811         {
812                 Con_Printf(CON_ERROR "condump: unable to write file \"%s\"\n", Cmd_Argv(cmd, 1));
813                 return;
814         }
815         if (con_mutex) Thread_LockMutex(con_mutex);
816         for(i = 0; i < CON_LINES_COUNT; ++i)
817         {
818                 if (condump_stripcolors.integer)
819                 {
820                         // sanitize msg
821                         size_t len = CON_LINES(i).len;
822                         char* sanitizedmsg = (char*)Mem_Alloc(tempmempool, len + 1);
823                         memcpy (sanitizedmsg, CON_LINES(i).start, len);
824                         SanitizeString(sanitizedmsg, sanitizedmsg); // SanitizeString's in pointer is always ahead of the out pointer, so this should work.
825                         FS_Write(file, sanitizedmsg, strlen(sanitizedmsg));
826                         Mem_Free(sanitizedmsg);
827                 }
828                 else 
829                 {
830                         FS_Write(file, CON_LINES(i).start, CON_LINES(i).len);
831                 }
832                 FS_Write(file, "\n", 1);
833         }
834         if (con_mutex) Thread_UnlockMutex(con_mutex);
835         FS_Close(file);
836 }
837
838 void Con_Clear_f(cmd_state_t *cmd)
839 {
840         if (con_mutex) Thread_LockMutex(con_mutex);
841         ConBuffer_Clear(&con);
842         if (con_mutex) Thread_UnlockMutex(con_mutex);
843 }
844
845 /*
846 ================
847 Con_Init
848 ================
849 */
850 void Con_Init (void)
851 {
852         con_linewidth = 80;
853         ConBuffer_Init(&con, CON_TEXTSIZE, CON_MAXLINES, zonemempool);
854         if (Thread_HasThreads())
855                 con_mutex = Thread_CreateMutex();
856
857         // Allocate a log queue, this will be freed after configs are parsed
858         logq_size = MAX_INPUTLINE;
859         logqueue = (unsigned char *)Mem_Alloc (tempmempool, logq_size);
860         logq_ind = 0;
861
862         Cvar_RegisterVariable (&sys_colortranslation);
863         Cvar_RegisterVariable (&sys_specialcharactertranslation);
864
865         Cvar_RegisterVariable (&log_file);
866         Cvar_RegisterVariable (&log_file_stripcolors);
867         Cvar_RegisterVariable (&log_dest_udp);
868
869         // support for the classic Quake option
870 // COMMANDLINEOPTION: Console: -condebug logs console messages to qconsole.log, see also log_file
871         if (COM_CheckParm ("-condebug") != 0)
872                 Cvar_SetQuick (&log_file, "qconsole.log");
873
874         // register our cvars
875         Cvar_RegisterVariable (&con_chat);
876         Cvar_RegisterVariable (&con_chatpos);
877         Cvar_RegisterVariable (&con_chatrect_x);
878         Cvar_RegisterVariable (&con_chatrect_y);
879         Cvar_RegisterVariable (&con_chatrect);
880         Cvar_RegisterVariable (&con_chatsize);
881         Cvar_RegisterVariable (&con_chattime);
882         Cvar_RegisterVariable (&con_chatwidth);
883         Cvar_RegisterVariable (&con_notify);
884         Cvar_RegisterVariable (&con_notifyalign);
885         Cvar_RegisterVariable (&con_notifysize);
886         Cvar_RegisterVariable (&con_notifytime);
887         Cvar_RegisterVariable (&con_textsize);
888         Cvar_RegisterVariable (&con_chatsound);
889         Cvar_RegisterVariable (&con_chatsound_file);
890         Cvar_RegisterVariable (&con_chatsound_team_file);
891         Cvar_RegisterVariable (&con_chatsound_team_mask);
892
893         // --blub
894         Cvar_RegisterVariable (&con_nickcompletion);
895         Cvar_RegisterVariable (&con_nickcompletion_flags);
896
897         Cvar_RegisterVariable (&con_completion_playdemo); // *.dem
898         Cvar_RegisterVariable (&con_completion_timedemo); // *.dem
899         Cvar_RegisterVariable (&con_completion_exec); // *.cfg
900
901         Cvar_RegisterVariable (&condump_stripcolors);
902
903         // register our commands
904         Cmd_AddCommand(CMD_CLIENT, "toggleconsole", Con_ToggleConsole_f, "opens or closes the console");
905         Cmd_AddCommand(CMD_CLIENT, "messagemode", Con_MessageMode_f, "input a chat message to say to everyone");
906         Cmd_AddCommand(CMD_CLIENT, "messagemode2", Con_MessageMode2_f, "input a chat message to say to only your team");
907         Cmd_AddCommand(CMD_CLIENT, "commandmode", Con_CommandMode_f, "input a console command");
908         Cmd_AddCommand(CMD_SHARED, "clear", Con_Clear_f, "clear console history");
909         Cmd_AddCommand(CMD_SHARED, "maps", Con_Maps_f, "list information about available maps");
910         Cmd_AddCommand(CMD_SHARED, "condump", Con_ConDump_f, "output console history to a file (see also log_file)");
911
912         con_initialized = true;
913         // initialize console window (only used by sys_win.c)
914         Sys_InitConsole();
915         
916         Con_DPrint("Console initialized.\n");
917 }
918
919 void Con_Shutdown (void)
920 {
921         if (con_mutex) Thread_LockMutex(con_mutex);
922         ConBuffer_Shutdown(&con);
923         if (con_mutex) Thread_UnlockMutex(con_mutex);
924         if (con_mutex) Thread_DestroyMutex(con_mutex);con_mutex = NULL;
925 }
926
927 /*
928 ================
929 Con_PrintToHistory
930
931 Handles cursor positioning, line wrapping, etc
932 All console printing must go through this in order to be displayed
933 If no console is visible, the notify window will pop up.
934 ================
935 */
936 static void Con_PrintToHistory(const char *txt, int mask)
937 {
938         // process:
939         //   \n goes to next line
940         //   \r deletes current line and makes a new one
941
942         static int cr_pending = 0;
943         static char buf[CON_TEXTSIZE]; // con_mutex
944         static int bufpos = 0;
945
946         if(!con.text) // FIXME uses a non-abstracted property of con
947                 return;
948
949         for(; *txt; ++txt)
950         {
951                 if(cr_pending)
952                 {
953                         ConBuffer_DeleteLastLine(&con);
954                         cr_pending = 0;
955                 }
956                 switch(*txt)
957                 {
958                         case 0:
959                                 break;
960                         case '\r':
961                                 ConBuffer_AddLine(&con, buf, bufpos, mask);
962                                 bufpos = 0;
963                                 cr_pending = 1;
964                                 break;
965                         case '\n':
966                                 ConBuffer_AddLine(&con, buf, bufpos, mask);
967                                 bufpos = 0;
968                                 break;
969                         default:
970                                 buf[bufpos++] = *txt;
971                                 if(bufpos >= con.textsize - 1) // FIXME uses a non-abstracted property of con
972                                 {
973                                         ConBuffer_AddLine(&con, buf, bufpos, mask);
974                                         bufpos = 0;
975                                 }
976                                 break;
977                 }
978         }
979 }
980
981 void Con_Rcon_Redirect_Init(lhnetsocket_t *sock, lhnetaddress_t *dest, qboolean proquakeprotocol)
982 {
983         rcon_redirect_sock = sock;
984         rcon_redirect_dest = dest;
985         rcon_redirect_proquakeprotocol = proquakeprotocol;
986         if (rcon_redirect_proquakeprotocol)
987         {
988                 // reserve space for the packet header
989                 rcon_redirect_buffer[0] = 0;
990                 rcon_redirect_buffer[1] = 0;
991                 rcon_redirect_buffer[2] = 0;
992                 rcon_redirect_buffer[3] = 0;
993                 // this is a reply to a CCREQ_RCON
994                 rcon_redirect_buffer[4] = (unsigned char)CCREP_RCON;
995         }
996         else
997                 memcpy(rcon_redirect_buffer, "\377\377\377\377n", 5); // QW rcon print
998         rcon_redirect_bufferpos = 5;
999 }
1000
1001 static void Con_Rcon_Redirect_Flush(void)
1002 {
1003         if(rcon_redirect_sock)
1004         {
1005                 rcon_redirect_buffer[rcon_redirect_bufferpos] = 0;
1006                 if (rcon_redirect_proquakeprotocol)
1007                 {
1008                         // update the length in the packet header
1009                         StoreBigLong((unsigned char *)rcon_redirect_buffer, NETFLAG_CTL | (rcon_redirect_bufferpos & NETFLAG_LENGTH_MASK));
1010                 }
1011                 NetConn_Write(rcon_redirect_sock, rcon_redirect_buffer, rcon_redirect_bufferpos, rcon_redirect_dest);
1012         }
1013         memcpy(rcon_redirect_buffer, "\377\377\377\377n", 5); // QW rcon print
1014         rcon_redirect_bufferpos = 5;
1015         rcon_redirect_proquakeprotocol = false;
1016 }
1017
1018 void Con_Rcon_Redirect_End(void)
1019 {
1020         Con_Rcon_Redirect_Flush();
1021         rcon_redirect_dest = NULL;
1022         rcon_redirect_sock = NULL;
1023 }
1024
1025 void Con_Rcon_Redirect_Abort(void)
1026 {
1027         rcon_redirect_dest = NULL;
1028         rcon_redirect_sock = NULL;
1029 }
1030
1031 /*
1032 ================
1033 Con_Rcon_AddChar
1034 ================
1035 */
1036 /// Adds a character to the rcon buffer.
1037 static void Con_Rcon_AddChar(int c)
1038 {
1039         if(log_dest_buffer_appending)
1040                 return;
1041         ++log_dest_buffer_appending;
1042
1043         // if this print is in response to an rcon command, add the character
1044         // to the rcon redirect buffer
1045
1046         if (rcon_redirect_dest)
1047         {
1048                 rcon_redirect_buffer[rcon_redirect_bufferpos++] = c;
1049                 if(rcon_redirect_bufferpos >= (int)sizeof(rcon_redirect_buffer) - 1)
1050                         Con_Rcon_Redirect_Flush();
1051         }
1052         else if(*log_dest_udp.string) // don't duplicate rcon command responses here, these are sent another way
1053         {
1054                 if(log_dest_buffer_pos == 0)
1055                         Log_DestBuffer_Init();
1056                 log_dest_buffer[log_dest_buffer_pos++] = c;
1057                 if(log_dest_buffer_pos >= sizeof(log_dest_buffer) - 1) // minus one, to allow for terminating zero
1058                         Log_DestBuffer_Flush_NoLock();
1059         }
1060         else
1061                 log_dest_buffer_pos = 0;
1062
1063         --log_dest_buffer_appending;
1064 }
1065
1066 /**
1067  * Convert an RGB color to its nearest quake color.
1068  * I'll cheat on this a bit by translating the colors to HSV first,
1069  * S and V decide if it's black or white, otherwise, H will decide the
1070  * actual color.
1071  * @param _r Red (0-255)
1072  * @param _g Green (0-255)
1073  * @param _b Blue (0-255)
1074  * @return A quake color character.
1075  */
1076 static char Sys_Con_NearestColor(const unsigned char _r, const unsigned char _g, const unsigned char _b)
1077 {
1078         float r = ((float)_r)/255.0;
1079         float g = ((float)_g)/255.0;
1080         float b = ((float)_b)/255.0;
1081         float min = min(r, min(g, b));
1082         float max = max(r, max(g, b));
1083
1084         int h; ///< Hue angle [0,360]
1085         float s; ///< Saturation [0,1]
1086         float v = max; ///< In HSV v == max [0,1]
1087
1088         if(max == min)
1089                 s = 0;
1090         else
1091                 s = 1.0 - (min/max);
1092
1093         // Saturation threshold. We now say 0.2 is the minimum value for a color!
1094         if(s < 0.2)
1095         {
1096                 // If the value is less than half, return a black color code.
1097                 // Otherwise return a white one.
1098                 if(v < 0.5)
1099                         return '0';
1100                 return '7';
1101         }
1102
1103         // Let's get the hue angle to define some colors:
1104         if(max == min)
1105                 h = 0;
1106         else if(max == r)
1107                 h = (int)(60.0 * (g-b)/(max-min))%360;
1108         else if(max == g)
1109                 h = (int)(60.0 * (b-r)/(max-min) + 120);
1110         else // if(max == b) redundant check
1111                 h = (int)(60.0 * (r-g)/(max-min) + 240);
1112
1113         if(h < 36) // *red* to orange
1114                 return '1';
1115         else if(h < 80) // orange over *yellow* to evilish-bright-green
1116                 return '3';
1117         else if(h < 150) // evilish-bright-green over *green* to ugly bright blue
1118                 return '2';
1119         else if(h < 200) // ugly bright blue over *bright blue* to darkish blue
1120                 return '5';
1121         else if(h < 270) // darkish blue over *dark blue* to cool purple
1122                 return '4';
1123         else if(h < 330) // cool purple over *purple* to ugly swiny red
1124                 return '6';
1125         else // ugly red to red closes the circly
1126                 return '1';
1127 }
1128
1129 /*
1130 ================
1131 Con_MaskPrint
1132 ================
1133 */
1134 extern cvar_t timestamps;
1135 extern cvar_t timeformat;
1136 extern qboolean sys_nostdout;
1137 void Con_MaskPrint(int additionalmask, const char *msg)
1138 {
1139         static int mask = 0;
1140         static int index = 0;
1141         static char line[MAX_INPUTLINE];
1142
1143         if (con_mutex)
1144                 Thread_LockMutex(con_mutex);
1145
1146         for (;*msg;msg++)
1147         {
1148                 Con_Rcon_AddChar(*msg);
1149                 // if this is the beginning of a new line, print timestamp
1150                 if (index == 0)
1151                 {
1152                         const char *timestamp = timestamps.integer ? Sys_TimeString(timeformat.string) : "";
1153                         // reset the color
1154                         // FIXME: 1. perhaps we should use a terminal system 2. use a constant instead of 7!
1155                         line[index++] = STRING_COLOR_TAG;
1156                         // assert( STRING_COLOR_DEFAULT < 10 )
1157                         line[index++] = STRING_COLOR_DEFAULT + '0';
1158                         // special color codes for chat messages must always come first
1159                         // for Con_PrintToHistory to work properly
1160                         if (*msg == 1 || *msg == 2 || *msg == 3)
1161                         {
1162                                 // play talk wav
1163                                 if (*msg == 1)
1164                                 {
1165                                         if (con_chatsound.value)
1166                                         {
1167                                                 if(msg[1] == con_chatsound_team_mask.integer && cl.foundteamchatsound)
1168                                                         S_LocalSound (con_chatsound_team_file.string);
1169                                                 else
1170                                                         S_LocalSound (con_chatsound_file.string);
1171                                         }
1172                                 }
1173                                 // Send to chatbox for say/tell (1) and messages (3)
1174                                 // 3 is just so that a message can be sent to the chatbox without a sound.
1175                                 if (*msg == 1 || *msg == 3)
1176                                         mask = CON_MASK_CHAT;
1177
1178                                 line[index++] = STRING_COLOR_TAG;
1179                                 line[index++] = '3';
1180                                 msg++;
1181                                 Con_Rcon_AddChar(*msg);
1182                         }
1183                         // store timestamp
1184                         for (;*timestamp;index++, timestamp++)
1185                                 if (index < (int)sizeof(line) - 2)
1186                                         line[index] = *timestamp;
1187                         // add the mask
1188                         mask |= additionalmask;
1189                 }
1190                 // append the character
1191                 line[index++] = *msg;
1192                 // if this is a newline character, we have a complete line to print
1193                 if (*msg == '\n' || index >= (int)sizeof(line) / 2)
1194                 {
1195                         // terminate the line
1196                         line[index] = 0;
1197                         // send to log file
1198                         Log_ConPrint(line);
1199                         // send to scrollable buffer
1200                         if (con_initialized && cls.state != ca_dedicated)
1201                         {
1202                                 Con_PrintToHistory(line, mask);
1203                         }
1204                         // send to terminal or dedicated server window
1205                         if (!sys_nostdout)
1206                         if (developer.integer || !(mask & CON_MASK_DEVELOPER))
1207                         {
1208                                 if(sys_specialcharactertranslation.integer)
1209                                 {
1210                                         char *p;
1211                                         const char *q;
1212                                         p = line;
1213                                         while(*p)
1214                                         {
1215                                                 int ch = u8_getchar(p, &q);
1216                                                 if(ch >= 0xE000 && ch <= 0xE0FF && ((unsigned char) qfont_table[ch - 0xE000]) >= 0x20)
1217                                                 {
1218                                                         *p = qfont_table[ch - 0xE000];
1219                                                         if(q > p+1)
1220                                                                 memmove(p+1, q, strlen(q)+1);
1221                                                         p = p + 1;
1222                                                 }
1223                                                 else
1224                                                         p = p + (q - p);
1225                                         }
1226                                 }
1227
1228                                 if(sys_colortranslation.integer == 1) // ANSI
1229                                 {
1230                                         static char printline[MAX_INPUTLINE * 4 + 3];
1231                                                 // 2 can become 7 bytes, rounding that up to 8, and 3 bytes are added at the end
1232                                                 // a newline can transform into four bytes, but then prevents the three extra bytes from appearing
1233                                         int lastcolor = 0;
1234                                         const char *in;
1235                                         char *out;
1236                                         int color;
1237                                         for(in = line, out = printline; *in; ++in)
1238                                         {
1239                                                 switch(*in)
1240                                                 {
1241                                                         case STRING_COLOR_TAG:
1242                                                                 if( in[1] == STRING_COLOR_RGB_TAG_CHAR && isxdigit(in[2]) && isxdigit(in[3]) && isxdigit(in[4]) )
1243                                                                 {
1244                                                                         char r = tolower(in[2]);
1245                                                                         char g = tolower(in[3]);
1246                                                                         char b = tolower(in[4]);
1247                                                                         // it's a hex digit already, so the else part needs no check --blub
1248                                                                         if(isdigit(r)) r -= '0';
1249                                                                         else r -= 87;
1250                                                                         if(isdigit(g)) g -= '0';
1251                                                                         else g -= 87;
1252                                                                         if(isdigit(b)) b -= '0';
1253                                                                         else b -= 87;
1254                                                                         
1255                                                                         color = Sys_Con_NearestColor(r * 17, g * 17, b * 17);
1256                                                                         in += 3; // 3 only, the switch down there does the fourth
1257                                                                 }
1258                                                                 else
1259                                                                         color = in[1];
1260                                                                 
1261                                                                 switch(color)
1262                                                                 {
1263                                                                         case STRING_COLOR_TAG:
1264                                                                                 ++in;
1265                                                                                 *out++ = STRING_COLOR_TAG;
1266                                                                                 break;
1267                                                                         case '0':
1268                                                                         case '7':
1269                                                                                 // normal color
1270                                                                                 ++in;
1271                                                                                 if(lastcolor == 0) break; else lastcolor = 0;
1272                                                                                 *out++ = 0x1B; *out++ = '['; *out++ = 'm';
1273                                                                                 break;
1274                                                                         case '1':
1275                                                                                 // light red
1276                                                                                 ++in;
1277                                                                                 if(lastcolor == 1) break; else lastcolor = 1;
1278                                                                                 *out++ = 0x1B; *out++ = '['; *out++ = '1'; *out++ = ';'; *out++ = '3'; *out++ = '1'; *out++ = 'm';
1279                                                                                 break;
1280                                                                         case '2':
1281                                                                                 // light green
1282                                                                                 ++in;
1283                                                                                 if(lastcolor == 2) break; else lastcolor = 2;
1284                                                                                 *out++ = 0x1B; *out++ = '['; *out++ = '1'; *out++ = ';'; *out++ = '3'; *out++ = '2'; *out++ = 'm';
1285                                                                                 break;
1286                                                                         case '3':
1287                                                                                 // yellow
1288                                                                                 ++in;
1289                                                                                 if(lastcolor == 3) break; else lastcolor = 3;
1290                                                                                 *out++ = 0x1B; *out++ = '['; *out++ = '1'; *out++ = ';'; *out++ = '3'; *out++ = '3'; *out++ = 'm';
1291                                                                                 break;
1292                                                                         case '4':
1293                                                                                 // light blue
1294                                                                                 ++in;
1295                                                                                 if(lastcolor == 4) break; else lastcolor = 4;
1296                                                                                 *out++ = 0x1B; *out++ = '['; *out++ = '1'; *out++ = ';'; *out++ = '3'; *out++ = '4'; *out++ = 'm';
1297                                                                                 break;
1298                                                                         case '5':
1299                                                                                 // light cyan
1300                                                                                 ++in;
1301                                                                                 if(lastcolor == 5) break; else lastcolor = 5;
1302                                                                                 *out++ = 0x1B; *out++ = '['; *out++ = '1'; *out++ = ';'; *out++ = '3'; *out++ = '6'; *out++ = 'm';
1303                                                                                 break;
1304                                                                         case '6':
1305                                                                                 // light magenta
1306                                                                                 ++in;
1307                                                                                 if(lastcolor == 6) break; else lastcolor = 6;
1308                                                                                 *out++ = 0x1B; *out++ = '['; *out++ = '1'; *out++ = ';'; *out++ = '3'; *out++ = '5'; *out++ = 'm';
1309                                                                                 break;
1310                                                                         // 7 handled above
1311                                                                         case '8':
1312                                                                         case '9':
1313                                                                                 // bold normal color
1314                                                                                 ++in;
1315                                                                                 if(lastcolor == 8) break; else lastcolor = 8;
1316                                                                                 *out++ = 0x1B; *out++ = '['; *out++ = '0'; *out++ = ';'; *out++ = '1'; *out++ = 'm';
1317                                                                                 break;
1318                                                                         default:
1319                                                                                 *out++ = STRING_COLOR_TAG;
1320                                                                                 break;
1321                                                                 }
1322                                                                 break;
1323                                                         case '\n':
1324                                                                 if(lastcolor != 0)
1325                                                                 {
1326                                                                         *out++ = 0x1B; *out++ = '['; *out++ = 'm';
1327                                                                         lastcolor = 0;
1328                                                                 }
1329                                                                 *out++ = *in;
1330                                                                 break;
1331                                                         default:
1332                                                                 *out++ = *in;
1333                                                                 break;
1334                                                 }
1335                                         }
1336                                         if(lastcolor != 0)
1337                                         {
1338                                                 *out++ = 0x1B;
1339                                                 *out++ = '[';
1340                                                 *out++ = 'm';
1341                                         }
1342                                         *out++ = 0;
1343                                         Sys_PrintToTerminal(printline);
1344                                 }
1345                                 else if(sys_colortranslation.integer == 2) // Quake
1346                                 {
1347                                         Sys_PrintToTerminal(line);
1348                                 }
1349                                 else // strip
1350                                 {
1351                                         static char printline[MAX_INPUTLINE]; // it can only get shorter here
1352                                         const char *in;
1353                                         char *out;
1354                                         for(in = line, out = printline; *in; ++in)
1355                                         {
1356                                                 switch(*in)
1357                                                 {
1358                                                         case STRING_COLOR_TAG:
1359                                                                 switch(in[1])
1360                                                                 {
1361                                                                         case STRING_COLOR_RGB_TAG_CHAR:
1362                                                                                 if ( isxdigit(in[2]) && isxdigit(in[3]) && isxdigit(in[4]) )
1363                                                                                 {
1364                                                                                         in+=4;
1365                                                                                         break;
1366                                                                                 }
1367                                                                                 *out++ = STRING_COLOR_TAG;
1368                                                                                 *out++ = STRING_COLOR_RGB_TAG_CHAR;
1369                                                                                 ++in;
1370                                                                                 break;
1371                                                                         case STRING_COLOR_TAG:
1372                                                                                 ++in;
1373                                                                                 *out++ = STRING_COLOR_TAG;
1374                                                                                 break;
1375                                                                         case '0':
1376                                                                         case '1':
1377                                                                         case '2':
1378                                                                         case '3':
1379                                                                         case '4':
1380                                                                         case '5':
1381                                                                         case '6':
1382                                                                         case '7':
1383                                                                         case '8':
1384                                                                         case '9':
1385                                                                                 ++in;
1386                                                                                 break;
1387                                                                         default:
1388                                                                                 *out++ = STRING_COLOR_TAG;
1389                                                                                 break;
1390                                                                 }
1391                                                                 break;
1392                                                         default:
1393                                                                 *out++ = *in;
1394                                                                 break;
1395                                                 }
1396                                         }
1397                                         *out++ = 0;
1398                                         Sys_PrintToTerminal(printline);
1399                                 }
1400                         }
1401                         // empty the line buffer
1402                         index = 0;
1403                         mask = 0;
1404                 }
1405         }
1406
1407         if (con_mutex)
1408                 Thread_UnlockMutex(con_mutex);
1409 }
1410
1411 /*
1412 ================
1413 Con_MaskPrintf
1414 ================
1415 */
1416 void Con_MaskPrintf(int mask, const char *fmt, ...)
1417 {
1418         va_list argptr;
1419         char msg[MAX_INPUTLINE];
1420
1421         va_start(argptr,fmt);
1422         dpvsnprintf(msg,sizeof(msg),fmt,argptr);
1423         va_end(argptr);
1424
1425         Con_MaskPrint(mask, msg);
1426 }
1427
1428 /*
1429 ================
1430 Con_Print
1431 ================
1432 */
1433 void Con_Print(const char *msg)
1434 {
1435         Con_MaskPrint(CON_MASK_PRINT, msg);
1436 }
1437
1438 /*
1439 ================
1440 Con_Printf
1441 ================
1442 */
1443 void Con_Printf(const char *fmt, ...)
1444 {
1445         va_list argptr;
1446         char msg[MAX_INPUTLINE];
1447
1448         va_start(argptr,fmt);
1449         dpvsnprintf(msg,sizeof(msg),fmt,argptr);
1450         va_end(argptr);
1451
1452         Con_MaskPrint(CON_MASK_PRINT, msg);
1453 }
1454
1455 /*
1456 ================
1457 Con_DPrint
1458 ================
1459 */
1460 void Con_DPrint(const char *msg)
1461 {
1462         if(developer.integer < 0) // at 0, we still add to the buffer but hide
1463                 return;
1464
1465         Con_MaskPrint(CON_MASK_DEVELOPER, msg);
1466 }
1467
1468 /*
1469 ================
1470 Con_DPrintf
1471 ================
1472 */
1473 void Con_DPrintf(const char *fmt, ...)
1474 {
1475         va_list argptr;
1476         char msg[MAX_INPUTLINE];
1477
1478         if(developer.integer < 0) // at 0, we still add to the buffer but hide
1479                 return;
1480
1481         va_start(argptr,fmt);
1482         dpvsnprintf(msg,sizeof(msg),fmt,argptr);
1483         va_end(argptr);
1484
1485         Con_MaskPrint(CON_MASK_DEVELOPER, msg);
1486 }
1487
1488
1489 /*
1490 ==============================================================================
1491
1492 DRAWING
1493
1494 ==============================================================================
1495 */
1496
1497 /*
1498 ================
1499 Con_DrawInput
1500
1501 The input line scrolls horizontally if typing goes beyond the right edge
1502
1503 Modified by EvilTypeGuy eviltypeguy@qeradiant.com
1504 ================
1505 */
1506 static void Con_DrawInput (void)
1507 {
1508         int             y;
1509         int             i;
1510         char text[sizeof(key_line)+5+1]; // space for ^^xRGB too
1511         float x, xo;
1512         size_t len_out;
1513         int col_out;
1514
1515         if (!key_consoleactive)
1516                 return;         // don't draw anything
1517
1518         strlcpy(text, key_line, sizeof(text));
1519
1520         // Advanced Console Editing by Radix radix@planetquake.com
1521         // Added/Modified by EvilTypeGuy eviltypeguy@qeradiant.com
1522
1523         y = (int)strlen(text);
1524
1525         // make the color code visible when the cursor is inside it
1526         if(text[key_linepos] != 0)
1527         {
1528                 for(i=1; i < 5 && key_linepos - i > 0; ++i)
1529                         if(text[key_linepos-i] == STRING_COLOR_TAG)
1530                         {
1531                                 int caret_pos, ofs = 0;
1532                                 caret_pos = key_linepos - i;
1533                                 if(i == 1 && text[caret_pos+1] == STRING_COLOR_TAG)
1534                                         ofs = 1;
1535                                 else if(i == 1 && isdigit(text[caret_pos+1]))
1536                                         ofs = 2;
1537                                 else if(text[caret_pos+1] == STRING_COLOR_RGB_TAG_CHAR && isxdigit(text[caret_pos+2]) && isxdigit(text[caret_pos+3]) && isxdigit(text[caret_pos+4]))
1538                                         ofs = 5;
1539                                 if(ofs && (size_t)(y + ofs + 1) < sizeof(text))
1540                                 {
1541                                         int carets = 1;
1542                                         while(caret_pos - carets >= 1 && text[caret_pos - carets] == STRING_COLOR_TAG)
1543                                                 ++carets;
1544                                         if(carets & 1)
1545                                         {
1546                                                 // str^2ing (displayed as string) --> str^2^^2ing (displayed as str^2ing)
1547                                                 // str^^ing (displayed as str^ing) --> str^^^^ing (displayed as str^^ing)
1548                                                 memmove(&text[caret_pos + ofs + 1], &text[caret_pos], y - caret_pos);
1549                                                 text[caret_pos + ofs] = STRING_COLOR_TAG;
1550                                                 y += ofs + 1;
1551                                                 text[y] = 0;
1552                                         }
1553                                 }
1554                                 break;
1555                         }
1556         }
1557
1558         len_out = key_linepos;
1559         col_out = -1;
1560         xo = DrawQ_TextWidth_UntilWidth_TrackColors(text, &len_out, con_textsize.value, con_textsize.value, &col_out, false, FONT_CONSOLE, 1000000000);
1561         x = vid_conwidth.value * 0.95 - xo; // scroll
1562         if(x >= 0)
1563                 x = 0;
1564
1565         // draw it
1566         DrawQ_String(x, con_vislines - con_textsize.value*2, text, y + 3, con_textsize.value, con_textsize.value, 1.0, 1.0, 1.0, 1.0, 0, NULL, false, FONT_CONSOLE );
1567
1568         // draw a cursor on top of this
1569         if ((int)(host.realtime*con_cursorspeed) & 1)           // cursor is visible
1570         {
1571                 if (!utf8_enable.integer)
1572                 {
1573                         text[0] = 11 + 130 * key_insert;        // either solid or triangle facing right
1574                         text[1] = 0;
1575                 }
1576                 else
1577                 {
1578                         size_t len;
1579                         const char *curbuf;
1580                         char charbuf16[16];
1581                         curbuf = u8_encodech(0xE000 + 11 + 130 * key_insert, &len, charbuf16);
1582                         memcpy(text, curbuf, len);
1583                         text[len] = 0;
1584                 }
1585                 DrawQ_String(x + xo, con_vislines - con_textsize.value*2, text, 0, con_textsize.value, con_textsize.value, 1.0, 1.0, 1.0, 1.0, 0, &col_out, false, FONT_CONSOLE);
1586         }
1587 }
1588
1589 typedef struct
1590 {
1591         dp_font_t *font;
1592         float alignment; // 0 = left, 0.5 = center, 1 = right
1593         float fontsize;
1594         float x;
1595         float y;
1596         float width;
1597         float ymin, ymax;
1598         const char *continuationString;
1599
1600         // PRIVATE:
1601         int colorindex; // init to -1
1602 }
1603 con_text_info_t;
1604
1605 static float Con_WordWidthFunc(void *passthrough, const char *w, size_t *length, float maxWidth)
1606 {
1607         con_text_info_t *ti = (con_text_info_t *) passthrough;
1608         if(w == NULL)
1609         {
1610                 ti->colorindex = -1;
1611                 return ti->fontsize * ti->font->maxwidth;
1612         }
1613         if(maxWidth >= 0)
1614                 return DrawQ_TextWidth_UntilWidth(w, length, ti->fontsize, ti->fontsize, false, ti->font, -maxWidth); // -maxWidth: we want at least one char
1615         else if(maxWidth == -1)
1616                 return DrawQ_TextWidth(w, *length, ti->fontsize, ti->fontsize, false, ti->font);
1617         else
1618         {
1619                 Sys_PrintfToTerminal("Con_WordWidthFunc: can't get here (maxWidth should never be %f)\n", maxWidth);
1620                 // Note: this is NOT a Con_Printf, as it could print recursively
1621                 return 0;
1622         }
1623 }
1624
1625 static int Con_CountLineFunc(void *passthrough, const char *line, size_t length, float width, qboolean isContinuation)
1626 {
1627         (void) passthrough;
1628         (void) line;
1629         (void) length;
1630         (void) width;
1631         (void) isContinuation;
1632         return 1;
1633 }
1634
1635 static int Con_DisplayLineFunc(void *passthrough, const char *line, size_t length, float width, qboolean isContinuation)
1636 {
1637         con_text_info_t *ti = (con_text_info_t *) passthrough;
1638
1639         if(ti->y < ti->ymin - 0.001)
1640                 (void) 0;
1641         else if(ti->y > ti->ymax - ti->fontsize + 0.001)
1642                 (void) 0;
1643         else
1644         {
1645                 int x = (int) (ti->x + (ti->width - width) * ti->alignment);
1646                 if(isContinuation && *ti->continuationString)
1647                         x = (int) DrawQ_String(x, ti->y, ti->continuationString, strlen(ti->continuationString), ti->fontsize, ti->fontsize, 1.0, 1.0, 1.0, 1.0, 0, NULL, false, ti->font);
1648                 if(length > 0)
1649                         DrawQ_String(x, ti->y, line, length, ti->fontsize, ti->fontsize, 1.0, 1.0, 1.0, 1.0, 0, &(ti->colorindex), false, ti->font);
1650         }
1651
1652         ti->y += ti->fontsize;
1653         return 1;
1654 }
1655
1656 static int Con_DrawNotifyRect(int mask_must, int mask_mustnot, float maxage, float x, float y, float width, float height, float fontsize, float alignment_x, float alignment_y, const char *continuationString)
1657 {
1658         int i;
1659         int lines = 0;
1660         int maxlines = (int) floor(height / fontsize + 0.01f);
1661         int startidx;
1662         int nskip = 0;
1663         int continuationWidth = 0;
1664         size_t len;
1665         double t = cl.time; // saved so it won't change
1666         con_text_info_t ti;
1667
1668         ti.font = (mask_must & CON_MASK_CHAT) ? FONT_CHAT : FONT_NOTIFY;
1669         ti.fontsize = fontsize;
1670         ti.alignment = alignment_x;
1671         ti.width = width;
1672         ti.ymin = y;
1673         ti.ymax = y + height;
1674         ti.continuationString = continuationString;
1675
1676         len = 0;
1677         Con_WordWidthFunc(&ti, NULL, &len, -1);
1678         len = strlen(continuationString);
1679         continuationWidth = (int) Con_WordWidthFunc(&ti, continuationString, &len, -1);
1680
1681         // first find the first line to draw by backwards iterating and word wrapping to find their length...
1682         startidx = CON_LINES_COUNT;
1683         for(i = CON_LINES_COUNT - 1; i >= 0; --i)
1684         {
1685                 con_lineinfo_t *l = &CON_LINES(i);
1686                 int mylines;
1687
1688                 if((l->mask & mask_must) != mask_must)
1689                         continue;
1690                 if(l->mask & mask_mustnot)
1691                         continue;
1692                 if(maxage && (l->addtime < t - maxage))
1693                         continue;
1694
1695                 // WE FOUND ONE!
1696                 // Calculate its actual height...
1697                 mylines = COM_Wordwrap(l->start, l->len, continuationWidth, width, Con_WordWidthFunc, &ti, Con_CountLineFunc, &ti);
1698                 if(lines + mylines >= maxlines)
1699                 {
1700                         nskip = lines + mylines - maxlines;
1701                         lines = maxlines;
1702                         startidx = i;
1703                         break;
1704                 }
1705                 lines += mylines;
1706                 startidx = i;
1707         }
1708
1709         // then center according to the calculated amount of lines...
1710         ti.x = x;
1711         ti.y = y + alignment_y * (height - lines * fontsize) - nskip * fontsize;
1712
1713         // then actually draw
1714         for(i = startidx; i < CON_LINES_COUNT; ++i)
1715         {
1716                 con_lineinfo_t *l = &CON_LINES(i);
1717
1718                 if((l->mask & mask_must) != mask_must)
1719                         continue;
1720                 if(l->mask & mask_mustnot)
1721                         continue;
1722                 if(maxage && (l->addtime < t - maxage))
1723                         continue;
1724
1725                 COM_Wordwrap(l->start, l->len, continuationWidth, width, Con_WordWidthFunc, &ti, Con_DisplayLineFunc, &ti);
1726         }
1727
1728         return lines;
1729 }
1730
1731 /*
1732 ================
1733 Con_DrawNotify
1734
1735 Draws the last few lines of output transparently over the game top
1736 ================
1737 */
1738 void Con_DrawNotify (void)
1739 {
1740         float   x, v, xr;
1741         float chatstart, notifystart, inputsize, height;
1742         float align;
1743         char    temptext[MAX_INPUTLINE];
1744         int numChatlines;
1745         int chatpos;
1746
1747         if (con_mutex) Thread_LockMutex(con_mutex);
1748         ConBuffer_FixTimes(&con);
1749
1750         numChatlines = con_chat.integer;
1751
1752         chatpos = con_chatpos.integer;
1753
1754         if (con_notify.integer < 0)
1755                 Cvar_SetValueQuick(&con_notify, 0);
1756         if (gamemode == GAME_TRANSFUSION)
1757                 v = 8; // vertical offset
1758         else
1759                 v = 0;
1760
1761         // GAME_NEXUIZ: center, otherwise left justify
1762         align = con_notifyalign.value;
1763         if(!*con_notifyalign.string) // empty string, evaluated to 0 above
1764         {
1765                 if(IS_OLDNEXUIZ_DERIVED(gamemode))
1766                         align = 0.5;
1767         }
1768
1769         if(numChatlines || !con_chatrect.integer)
1770         {
1771                 if(chatpos == 0)
1772                 {
1773                         // first chat, input line, then notify
1774                         chatstart = v;
1775                         notifystart = v + (numChatlines + 1) * con_chatsize.value;
1776                 }
1777                 else if(chatpos > 0)
1778                 {
1779                         // first notify, then (chatpos-1) empty lines, then chat, then input
1780                         notifystart = v;
1781                         chatstart = v + (con_notify.value + (chatpos - 1)) * con_notifysize.value;
1782                 }
1783                 else // if(chatpos < 0)
1784                 {
1785                         // first notify, then much space, then chat, then input, then -chatpos-1 empty lines
1786                         notifystart = v;
1787                         chatstart = vid_conheight.value - (-chatpos-1 + numChatlines + 1) * con_chatsize.value;
1788                 }
1789         }
1790         else
1791         {
1792                 // just notify and input
1793                 notifystart = v;
1794                 chatstart = 0; // shut off gcc warning
1795         }
1796
1797         v = notifystart + con_notifysize.value * Con_DrawNotifyRect(0, CON_MASK_INPUT | CON_MASK_HIDENOTIFY | (numChatlines ? CON_MASK_CHAT : 0) | CON_MASK_DEVELOPER, con_notifytime.value, 0, notifystart, vid_conwidth.value, con_notify.value * con_notifysize.value, con_notifysize.value, align, 0.0, "");
1798
1799         if(con_chatrect.integer)
1800         {
1801                 x = con_chatrect_x.value * vid_conwidth.value;
1802                 v = con_chatrect_y.value * vid_conheight.value;
1803         }
1804         else
1805         {
1806                 x = 0;
1807                 if(numChatlines) // only do this if chat area is enabled, or this would move the input line wrong
1808                         v = chatstart;
1809         }
1810         height = numChatlines * con_chatsize.value;
1811
1812         if(numChatlines)
1813         {
1814                 Con_DrawNotifyRect(CON_MASK_CHAT, CON_MASK_INPUT, con_chattime.value, x, v, vid_conwidth.value * con_chatwidth.value, height, con_chatsize.value, 0.0, 1.0, "^3 ... ");
1815                 v += height;
1816         }
1817         if (key_dest == key_message)
1818         {
1819                 //static char *cursor[2] = { "\xee\x80\x8a", "\xee\x80\x8b" }; // { off, on }
1820                 int colorindex = -1;
1821                 const char *cursor;
1822                 char charbuf16[16];
1823                 cursor = u8_encodech(0xE00A + ((int)(host.realtime * con_cursorspeed)&1), NULL, charbuf16);
1824
1825                 // LadyHavoc: speedup, and other improvements
1826                 if (chat_mode < 0)
1827                         dpsnprintf(temptext, sizeof(temptext), "]%s%s", chat_buffer, cursor);
1828                 else if(chat_mode)
1829                         dpsnprintf(temptext, sizeof(temptext), "say_team:%s%s", chat_buffer, cursor);
1830                 else
1831                         dpsnprintf(temptext, sizeof(temptext), "say:%s%s", chat_buffer, cursor);
1832
1833                 // FIXME word wrap
1834                 inputsize = (numChatlines ? con_chatsize : con_notifysize).value;
1835                 xr = vid_conwidth.value - DrawQ_TextWidth(temptext, 0, inputsize, inputsize, false, FONT_CHAT);
1836                 x = min(xr, x);
1837                 DrawQ_String(x, v, temptext, 0, inputsize, inputsize, 1.0, 1.0, 1.0, 1.0, 0, &colorindex, false, FONT_CHAT);
1838         }
1839         if (con_mutex) Thread_UnlockMutex(con_mutex);
1840 }
1841
1842 /*
1843 ================
1844 Con_LineHeight
1845
1846 Returns the height of a given console line; calculates it if necessary.
1847 ================
1848 */
1849 static int Con_LineHeight(int lineno)
1850 {
1851         con_lineinfo_t *li = &CON_LINES(lineno);
1852         if(li->height == -1)
1853         {
1854                 float width = vid_conwidth.value;
1855                 con_text_info_t ti;
1856                 ti.fontsize = con_textsize.value;
1857                 ti.font = FONT_CONSOLE;
1858                 li->height = COM_Wordwrap(li->start, li->len, 0, width, Con_WordWidthFunc, &ti, Con_CountLineFunc, NULL);
1859         }
1860         return li->height;
1861 }
1862
1863 /*
1864 ================
1865 Con_DrawConsoleLine
1866
1867 Draws a line of the console; returns its height in lines.
1868 If alpha is 0, the line is not drawn, but still wrapped and its height
1869 returned.
1870 ================
1871 */
1872 static int Con_DrawConsoleLine(int mask_must, int mask_mustnot, float y, int lineno, float ymin, float ymax)
1873 {
1874         float width = vid_conwidth.value;
1875         con_text_info_t ti;
1876         con_lineinfo_t *li = &CON_LINES(lineno);
1877
1878         if((li->mask & mask_must) != mask_must)
1879                 return 0;
1880         if((li->mask & mask_mustnot) != 0)
1881                 return 0;
1882
1883         ti.continuationString = "";
1884         ti.alignment = 0;
1885         ti.fontsize = con_textsize.value;
1886         ti.font = FONT_CONSOLE;
1887         ti.x = 0;
1888         ti.y = y - (Con_LineHeight(lineno) - 1) * ti.fontsize;
1889         ti.ymin = ymin;
1890         ti.ymax = ymax;
1891         ti.width = width;
1892
1893         return COM_Wordwrap(li->start, li->len, 0, width, Con_WordWidthFunc, &ti, Con_DisplayLineFunc, &ti);
1894 }
1895
1896 /*
1897 ================
1898 Con_LastVisibleLine
1899
1900 Calculates the last visible line index and how much to show of it based on
1901 con_backscroll.
1902 ================
1903 */
1904 static void Con_LastVisibleLine(int mask_must, int mask_mustnot, int *last, int *limitlast)
1905 {
1906         int lines_seen = 0;
1907         int i;
1908
1909         if(con_backscroll < 0)
1910                 con_backscroll = 0;
1911
1912         *last = 0;
1913
1914         // now count until we saw con_backscroll actual lines
1915         for(i = CON_LINES_COUNT - 1; i >= 0; --i)
1916         if((CON_LINES(i).mask & mask_must) == mask_must)
1917         if((CON_LINES(i).mask & mask_mustnot) == 0)
1918         {
1919                 int h = Con_LineHeight(i);
1920
1921                 // line is the last visible line?
1922                 *last = i;
1923                 if(lines_seen + h > con_backscroll && lines_seen <= con_backscroll)
1924                 {
1925                         *limitlast = lines_seen + h - con_backscroll;
1926                         return;
1927                 }
1928
1929                 lines_seen += h;
1930         }
1931
1932         // if we get here, no line was on screen - scroll so that one line is
1933         // visible then.
1934         con_backscroll = lines_seen - 1;
1935         *limitlast = 1;
1936 }
1937
1938 /*
1939 ================
1940 Con_DrawConsole
1941
1942 Draws the console with the solid background
1943 The typing input line at the bottom should only be drawn if typing is allowed
1944 ================
1945 */
1946 void Con_DrawConsole (int lines)
1947 {
1948         float alpha, alpha0;
1949         double sx, sy;
1950         int mask_must = 0;
1951         int mask_mustnot = (developer.integer>0) ? 0 : CON_MASK_DEVELOPER;
1952         cachepic_t *conbackpic;
1953         unsigned int conbackflags;
1954
1955         if (lines <= 0)
1956                 return;
1957
1958         if (con_mutex) Thread_LockMutex(con_mutex);
1959
1960         if (con_backscroll < 0)
1961                 con_backscroll = 0;
1962
1963         con_vislines = lines;
1964
1965         r_draw2d_force = true;
1966
1967 // draw the background
1968         alpha0 = cls.signon == SIGNONS ? scr_conalpha.value : 1.0f; // always full alpha when not in game
1969         if((alpha = alpha0 * scr_conalphafactor.value) > 0)
1970         {
1971                 sx = scr_conscroll_x.value;
1972                 sy = scr_conscroll_y.value;
1973                 conbackflags = CACHEPICFLAG_FAILONMISSING; // So console is readable when game content is missing
1974                 if (sx != 0 || sy != 0)
1975                         conbackflags &= CACHEPICFLAG_NOCLAMP;
1976                 conbackpic = scr_conbrightness.value >= 0.01f ? Draw_CachePic_Flags("gfx/conback", conbackflags) : NULL;
1977                 sx *= host.realtime; sy *= host.realtime;
1978                 sx -= floor(sx); sy -= floor(sy);
1979                 if (Draw_IsPicLoaded(conbackpic))
1980                         DrawQ_SuperPic(0, lines - vid_conheight.integer, conbackpic, vid_conwidth.integer, vid_conheight.integer,
1981                                         0 + sx, 0 + sy, scr_conbrightness.value, scr_conbrightness.value, scr_conbrightness.value, alpha,
1982                                         1 + sx, 0 + sy, scr_conbrightness.value, scr_conbrightness.value, scr_conbrightness.value, alpha,
1983                                         0 + sx, 1 + sy, scr_conbrightness.value, scr_conbrightness.value, scr_conbrightness.value, alpha,
1984                                         1 + sx, 1 + sy, scr_conbrightness.value, scr_conbrightness.value, scr_conbrightness.value, alpha,
1985                                         0);
1986                 else
1987                         DrawQ_Fill(0, lines - vid_conheight.integer, vid_conwidth.integer, vid_conheight.integer, 0.0f, 0.0f, 0.0f, alpha, 0);
1988         }
1989         if((alpha = alpha0 * scr_conalpha2factor.value) > 0)
1990         {
1991                 sx = scr_conscroll2_x.value;
1992                 sy = scr_conscroll2_y.value;
1993                 conbackpic = Draw_CachePic_Flags("gfx/conback2", (sx != 0 || sy != 0) ? CACHEPICFLAG_NOCLAMP : 0);
1994                 sx *= host.realtime; sy *= host.realtime;
1995                 sx -= floor(sx); sy -= floor(sy);
1996                 if(Draw_IsPicLoaded(conbackpic))
1997                         DrawQ_SuperPic(0, lines - vid_conheight.integer, conbackpic, vid_conwidth.integer, vid_conheight.integer,
1998                                         0 + sx, 0 + sy, scr_conbrightness.value, scr_conbrightness.value, scr_conbrightness.value, alpha,
1999                                         1 + sx, 0 + sy, scr_conbrightness.value, scr_conbrightness.value, scr_conbrightness.value, alpha,
2000                                         0 + sx, 1 + sy, scr_conbrightness.value, scr_conbrightness.value, scr_conbrightness.value, alpha,
2001                                         1 + sx, 1 + sy, scr_conbrightness.value, scr_conbrightness.value, scr_conbrightness.value, alpha,
2002                                         0);
2003         }
2004         if((alpha = alpha0 * scr_conalpha3factor.value) > 0)
2005         {
2006                 sx = scr_conscroll3_x.value;
2007                 sy = scr_conscroll3_y.value;
2008                 conbackpic = Draw_CachePic_Flags("gfx/conback3", (sx != 0 || sy != 0) ? CACHEPICFLAG_NOCLAMP : 0);
2009                 sx *= host.realtime; sy *= host.realtime;
2010                 sx -= floor(sx); sy -= floor(sy);
2011                 if(Draw_IsPicLoaded(conbackpic))
2012                         DrawQ_SuperPic(0, lines - vid_conheight.integer, conbackpic, vid_conwidth.integer, vid_conheight.integer,
2013                                         0 + sx, 0 + sy, scr_conbrightness.value, scr_conbrightness.value, scr_conbrightness.value, alpha,
2014                                         1 + sx, 0 + sy, scr_conbrightness.value, scr_conbrightness.value, scr_conbrightness.value, alpha,
2015                                         0 + sx, 1 + sy, scr_conbrightness.value, scr_conbrightness.value, scr_conbrightness.value, alpha,
2016                                         1 + sx, 1 + sy, scr_conbrightness.value, scr_conbrightness.value, scr_conbrightness.value, alpha,
2017                                         0);
2018         }
2019         DrawQ_String(vid_conwidth.integer - DrawQ_TextWidth(engineversion, 0, con_textsize.value, con_textsize.value, false, FONT_CONSOLE), lines - con_textsize.value, engineversion, 0, con_textsize.value, con_textsize.value, 1, 0, 0, 1, 0, NULL, true, FONT_CONSOLE);
2020
2021 // draw the text
2022 #if 0
2023         {
2024                 int i;
2025                 int count = CON_LINES_COUNT;
2026                 float ymax = con_vislines - 2 * con_textsize.value;
2027                 float y = ymax + con_textsize.value * con_backscroll;
2028                 for (i = 0;i < count && y >= 0;i++)
2029                         y -= Con_DrawConsoleLine(mask_must, mask_mustnot, y - con_textsize.value, CON_LINES_COUNT - 1 - i, 0, ymax) * con_textsize.value;
2030                 // fix any excessive scrollback for the next frame
2031                 if (i >= count && y >= 0)
2032                 {
2033                         con_backscroll -= (int)(y / con_textsize.value);
2034                         if (con_backscroll < 0)
2035                                 con_backscroll = 0;
2036                 }
2037         }
2038 #else
2039         if(CON_LINES_COUNT > 0)
2040         {
2041                 int i, last, limitlast;
2042                 float y;
2043                 float ymax = con_vislines - 2 * con_textsize.value;
2044                 Con_LastVisibleLine(mask_must, mask_mustnot, &last, &limitlast);
2045                 //Con_LastVisibleLine(mask_must, mask_mustnot, &last, &limitlast);
2046                 y = ymax - con_textsize.value;
2047
2048                 if(limitlast)
2049                         y += (CON_LINES(last).height - limitlast) * con_textsize.value;
2050                 i = last;
2051
2052                 for(;;)
2053                 {
2054                         y -= Con_DrawConsoleLine(mask_must, mask_mustnot, y, i, 0, ymax) * con_textsize.value;
2055                         if(i == 0)
2056                                 break; // top of console buffer
2057                         if(y < 0)
2058                                 break; // top of console window
2059                         limitlast = 0;
2060                         --i;
2061                 }
2062         }
2063 #endif
2064
2065 // draw the input prompt, user text, and cursor if desired
2066         Con_DrawInput ();
2067
2068         r_draw2d_force = false;
2069         if (con_mutex) Thread_UnlockMutex(con_mutex);
2070 }
2071
2072 /*
2073 GetMapList
2074
2075 Made by [515]
2076 Prints not only map filename, but also
2077 its format (q1/q2/q3/hl) and even its message
2078 */
2079 //[515]: here is an ugly hack.. two gotos... oh my... *but it works*
2080 //LadyHavoc: rewrote bsp type detection, rewrote message extraction to do proper worldspawn parsing
2081 //LadyHavoc: 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
2082 //LadyHavoc: FIXME: man this GetMapList is STILL ugly code even after my cleanups...
2083 qboolean GetMapList (const char *s, char *completedname, int completednamebufferlength)
2084 {
2085         fssearch_t      *t;
2086         char            message[1024];
2087         int                     i, k, max, p, o, min;
2088         unsigned char *len;
2089         qfile_t         *f;
2090         unsigned char buf[1024];
2091
2092         dpsnprintf(message, sizeof(message), "maps/%s*.bsp", s);
2093         t = FS_Search(message, 1, true);
2094         if(!t)
2095                 return false;
2096         if (t->numfilenames > 1)
2097                 Con_Printf("^1 %i maps found :\n", t->numfilenames);
2098         len = (unsigned char *)Z_Malloc(t->numfilenames);
2099         min = 666;
2100         for(max=i=0;i<t->numfilenames;i++)
2101         {
2102                 k = (int)strlen(t->filenames[i]);
2103                 k -= 9;
2104                 if(max < k)
2105                         max = k;
2106                 else
2107                 if(min > k)
2108                         min = k;
2109                 len[i] = k;
2110         }
2111         o = (int)strlen(s);
2112         for(i=0;i<t->numfilenames;i++)
2113         {
2114                 int lumpofs = 0, lumplen = 0;
2115                 char *entities = NULL;
2116                 const char *data = NULL;
2117                 char keyname[64];
2118                 char entfilename[MAX_QPATH];
2119                 char desc[64];
2120                 desc[0] = 0;
2121                 strlcpy(message, "^1ERROR: open failed^7", sizeof(message));
2122                 p = 0;
2123                 f = FS_OpenVirtualFile(t->filenames[i], true);
2124                 if(f)
2125                 {
2126                         strlcpy(message, "^1ERROR: not a known map format^7", sizeof(message));
2127                         memset(buf, 0, 1024);
2128                         FS_Read(f, buf, 1024);
2129                         if (!memcmp(buf, "IBSP", 4))
2130                         {
2131                                 p = LittleLong(((int *)buf)[1]);
2132                                 if (p == Q3BSPVERSION)
2133                                 {
2134                                         q3dheader_t *header = (q3dheader_t *)buf;
2135                                         lumpofs = LittleLong(header->lumps[Q3LUMP_ENTITIES].fileofs);
2136                                         lumplen = LittleLong(header->lumps[Q3LUMP_ENTITIES].filelen);
2137                                         dpsnprintf(desc, sizeof(desc), "Q3BSP%i", p);
2138                                 }
2139                                 else if (p == Q2BSPVERSION)
2140                                 {
2141                                         q2dheader_t *header = (q2dheader_t *)buf;
2142                                         lumpofs = LittleLong(header->lumps[Q2LUMP_ENTITIES].fileofs);
2143                                         lumplen = LittleLong(header->lumps[Q2LUMP_ENTITIES].filelen);
2144                                         dpsnprintf(desc, sizeof(desc), "Q2BSP%i", p);
2145                                 }
2146                                 else
2147                                         dpsnprintf(desc, sizeof(desc), "IBSP%i", p);
2148                         }
2149                         else if (BuffLittleLong(buf) == BSPVERSION)
2150                         {
2151                                 lumpofs = BuffLittleLong(buf + 4 + 8 * LUMP_ENTITIES);
2152                                 lumplen = BuffLittleLong(buf + 4 + 8 * LUMP_ENTITIES + 4);
2153                                 dpsnprintf(desc, sizeof(desc), "BSP29");
2154                         }
2155                         else if (BuffLittleLong(buf) == 30)
2156                         {
2157                                 lumpofs = BuffLittleLong(buf + 4 + 8 * LUMP_ENTITIES);
2158                                 lumplen = BuffLittleLong(buf + 4 + 8 * LUMP_ENTITIES + 4);
2159                                 dpsnprintf(desc, sizeof(desc), "BSPHL");
2160                         }
2161                         else if (!memcmp(buf, "BSP2", 4))
2162                         {
2163                                 lumpofs = BuffLittleLong(buf + 4 + 8 * LUMP_ENTITIES);
2164                                 lumplen = BuffLittleLong(buf + 4 + 8 * LUMP_ENTITIES + 4);
2165                                 dpsnprintf(desc, sizeof(desc), "BSP2");
2166                         }
2167                         else if (!memcmp(buf, "2PSB", 4))
2168                         {
2169                                 lumpofs = BuffLittleLong(buf + 4 + 8 * LUMP_ENTITIES);
2170                                 lumplen = BuffLittleLong(buf + 4 + 8 * LUMP_ENTITIES + 4);
2171                                 dpsnprintf(desc, sizeof(desc), "BSP2RMQe");
2172                         }
2173                         else
2174                         {
2175                                 dpsnprintf(desc, sizeof(desc), "unknown%i", BuffLittleLong(buf));
2176                         }
2177                         strlcpy(entfilename, t->filenames[i], sizeof(entfilename));
2178                         memcpy(entfilename + strlen(entfilename) - 4, ".ent", 5);
2179                         entities = (char *)FS_LoadFile(entfilename, tempmempool, true, NULL);
2180                         if (!entities && lumplen >= 10)
2181                         {
2182                                 FS_Seek(f, lumpofs, SEEK_SET);
2183                                 entities = (char *)Z_Malloc(lumplen + 1);
2184                                 FS_Read(f, entities, lumplen);
2185                         }
2186                         if (entities)
2187                         {
2188                                 // if there are entities to parse, a missing message key just
2189                                 // means there is no title, so clear the message string now
2190                                 message[0] = 0;
2191                                 data = entities;
2192                                 for (;;)
2193                                 {
2194                                         int l;
2195                                         if (!COM_ParseToken_Simple(&data, false, false, true))
2196                                                 break;
2197                                         if (com_token[0] == '{')
2198                                                 continue;
2199                                         if (com_token[0] == '}')
2200                                                 break;
2201                                         // skip leading whitespace
2202                                         for (k = 0;com_token[k] && ISWHITESPACE(com_token[k]);k++);
2203                                         for (l = 0;l < (int)sizeof(keyname) - 1 && com_token[k+l] && !ISWHITESPACE(com_token[k+l]);l++)
2204                                                 keyname[l] = com_token[k+l];
2205                                         keyname[l] = 0;
2206                                         if (!COM_ParseToken_Simple(&data, false, false, true))
2207                                                 break;
2208                                         if (developer_extra.integer)
2209                                                 Con_DPrintf("key: %s %s\n", keyname, com_token);
2210                                         if (!strcmp(keyname, "message"))
2211                                         {
2212                                                 // get the message contents
2213                                                 strlcpy(message, com_token, sizeof(message));
2214                                                 break;
2215                                         }
2216                                 }
2217                         }
2218                 }
2219                 if (entities)
2220                         Z_Free(entities);
2221                 if(f)
2222                         FS_Close(f);
2223                 *(t->filenames[i]+len[i]+5) = 0;
2224                 Con_Printf("%16s (%-8s) %s\n", t->filenames[i]+5, desc, message);
2225         }
2226         Con_Print("\n");
2227         for(p=o;p<min;p++)
2228         {
2229                 k = *(t->filenames[0]+5+p);
2230                 if(k == 0)
2231                         goto endcomplete;
2232                 for(i=1;i<t->numfilenames;i++)
2233                         if(*(t->filenames[i]+5+p) != k)
2234                                 goto endcomplete;
2235         }
2236 endcomplete:
2237         if(p > o && completedname && completednamebufferlength > 0)
2238         {
2239                 memset(completedname, 0, completednamebufferlength);
2240                 memcpy(completedname, (t->filenames[0]+5), min(p, completednamebufferlength - 1));
2241         }
2242         Z_Free(len);
2243         FS_FreeSearch(t);
2244         return p > o;
2245 }
2246
2247 /*
2248         Con_DisplayList
2249
2250         New function for tab-completion system
2251         Added by EvilTypeGuy
2252         MEGA Thanks to Taniwha
2253
2254 */
2255 void Con_DisplayList(const char **list)
2256 {
2257         int i = 0, pos = 0, len = 0, maxlen = 0, width = (con_linewidth - 4);
2258         const char **walk = list;
2259
2260         while (*walk) {
2261                 len = (int)strlen(*walk);
2262                 if (len > maxlen)
2263                         maxlen = len;
2264                 walk++;
2265         }
2266         maxlen += 1;
2267
2268         while (*list) {
2269                 len = (int)strlen(*list);
2270                 if (pos + maxlen >= width) {
2271                         Con_Print("\n");
2272                         pos = 0;
2273                 }
2274
2275                 Con_Print(*list);
2276                 for (i = 0; i < (maxlen - len); i++)
2277                         Con_Print(" ");
2278
2279                 pos += maxlen;
2280                 list++;
2281         }
2282
2283         if (pos)
2284                 Con_Print("\n\n");
2285 }
2286
2287
2288 // Now it becomes TRICKY :D --blub
2289 static char Nicks_list[MAX_SCOREBOARD][MAX_SCOREBOARDNAME];     // contains the nicks with colors and all that
2290 static char Nicks_sanlist[MAX_SCOREBOARD][MAX_SCOREBOARDNAME];  // sanitized list for completion when there are other possible matches.
2291 // means: when somebody uses a cvar's name as his name, we won't ever get his colors in there...
2292 static int Nicks_offset[MAX_SCOREBOARD]; // when nicks use a space, we need this to move the completion list string starts to avoid invalid memcpys
2293 static int Nicks_matchpos;
2294
2295 // co against <<:BLASTER:>> is true!?
2296 static int Nicks_strncasecmp_nospaces(char *a, char *b, unsigned int a_len)
2297 {
2298         while(a_len)
2299         {
2300                 if(tolower(*a) == tolower(*b))
2301                 {
2302                         if(*a == 0)
2303                                 return 0;
2304                         --a_len;
2305                         ++a;
2306                         ++b;
2307                         continue;
2308                 }
2309                 if(!*a)
2310                         return -1;
2311                 if(!*b)
2312                         return 1;
2313                 if(*a == ' ')
2314                         return (*a < *b) ? -1 : 1;
2315                 if(*b == ' ')
2316                         ++b;
2317                 else
2318                         return (*a < *b) ? -1 : 1;
2319         }
2320         return 0;
2321 }
2322 static int Nicks_strncasecmp(char *a, char *b, unsigned int a_len)
2323 {
2324         char space_char;
2325         if(!(con_nickcompletion_flags.integer & NICKS_ALPHANUMERICS_ONLY))
2326         {
2327                 if(con_nickcompletion_flags.integer & NICKS_NO_SPACES)
2328                         return Nicks_strncasecmp_nospaces(a, b, a_len);
2329                 return strncasecmp(a, b, a_len);
2330         }
2331
2332         space_char = (con_nickcompletion_flags.integer & NICKS_NO_SPACES) ? 'a' : ' ';
2333
2334         // ignore non alphanumerics of B
2335         // if A contains a non-alphanumeric, B must contain it as well though!
2336         while(a_len)
2337         {
2338                 qboolean alnum_a, alnum_b;
2339
2340                 if(tolower(*a) == tolower(*b))
2341                 {
2342                         if(*a == 0) // end of both strings, they're equal
2343                                 return 0;
2344                         --a_len;
2345                         ++a;
2346                         ++b;
2347                         continue;
2348                 }
2349                 // not equal, end of one string?
2350                 if(!*a)
2351                         return -1;
2352                 if(!*b)
2353                         return 1;
2354                 // ignore non alphanumerics
2355                 alnum_a = ( (*a >= 'a' && *a <= 'z') || (*a >= 'A' && *a <= 'Z') || (*a >= '0' && *a <= '9') || *a == space_char);
2356                 alnum_b = ( (*b >= 'a' && *b <= 'z') || (*b >= 'A' && *b <= 'Z') || (*b >= '0' && *b <= '9') || *b == space_char);
2357                 if(!alnum_a) // b must contain this
2358                         return (*a < *b) ? -1 : 1;
2359                 if(!alnum_b)
2360                         ++b;
2361                 // otherwise, both are alnum, they're just not equal, return the appropriate number
2362                 else
2363                         return (*a < *b) ? -1 : 1;
2364         }
2365         return 0;
2366 }
2367
2368
2369 /* Nicks_CompleteCountPossible
2370
2371    Count the number of possible nicks to complete
2372  */
2373 static int Nicks_CompleteCountPossible(char *line, int pos, char *s, qboolean isCon)
2374 {
2375         char name[MAX_SCOREBOARDNAME];
2376         int i, p;
2377         int match;
2378         int spos;
2379         int count = 0;
2380
2381         if(!con_nickcompletion.integer)
2382                 return 0;
2383
2384         // changed that to 1
2385         if(!line[0])// || !line[1]) // we want at least... 2 written characters
2386                 return 0;
2387
2388         for(i = 0; i < cl.maxclients; ++i)
2389         {
2390                 p = i;
2391                 if(!cl.scores[p].name[0])
2392                         continue;
2393
2394                 SanitizeString(cl.scores[p].name, name);
2395                 //Con_Printf(" ^2Sanitized: ^7%s -> %s", cl.scores[p].name, name);
2396
2397                 if(!name[0])
2398                         continue;
2399
2400                 match = -1;
2401                 spos = pos - 1; // no need for a minimum of characters :)
2402
2403                 while(spos >= 0)
2404                 {
2405                         if(spos > 0 && line[spos-1] != ' ' && line[spos-1] != ';' && line[spos-1] != '\"' && line[spos-1] != '\'')
2406                         {
2407                                 if(!(isCon && line[spos-1] == ']' && spos == 1) && // console start
2408                                    !(spos > 1 && line[spos-1] >= '0' && line[spos-1] <= '9' && line[spos-2] == STRING_COLOR_TAG)) // color start
2409                                 {
2410                                         --spos;
2411                                         continue;
2412                                 }
2413                         }
2414                         if(isCon && spos == 0)
2415                                 break;
2416                         if(Nicks_strncasecmp(line+spos, name, pos-spos) == 0)
2417                                 match = spos;
2418                         --spos;
2419                 }
2420                 if(match < 0)
2421                         continue;
2422                 //Con_Printf("Possible match: %s|%s\n", cl.scores[p].name, name);
2423                 strlcpy(Nicks_list[count], cl.scores[p].name, sizeof(Nicks_list[count]));
2424
2425                 // the sanitized list
2426                 strlcpy(Nicks_sanlist[count], name, sizeof(Nicks_sanlist[count]));
2427                 if(!count)
2428                 {
2429                         Nicks_matchpos = match;
2430                 }
2431
2432                 Nicks_offset[count] = s - (&line[match]);
2433                 //Con_Printf("offset for %s: %i\n", name, Nicks_offset[count]);
2434
2435                 ++count;
2436         }
2437         return count;
2438 }
2439
2440 static void Cmd_CompleteNicksPrint(int count)
2441 {
2442         int i;
2443         for(i = 0; i < count; ++i)
2444                 Con_Printf("%s\n", Nicks_list[i]);
2445 }
2446
2447 static void Nicks_CutMatchesNormal(int count)
2448 {
2449         // cut match 0 down to the longest possible completion
2450         int i;
2451         unsigned int c, l;
2452         c = (unsigned int)strlen(Nicks_sanlist[0]) - 1;
2453         for(i = 1; i < count; ++i)
2454         {
2455                 l = (unsigned int)strlen(Nicks_sanlist[i]) - 1;
2456                 if(l < c)
2457                         c = l;
2458
2459                 for(l = 0; l <= c; ++l)
2460                         if(tolower(Nicks_sanlist[0][l]) != tolower(Nicks_sanlist[i][l]))
2461                         {
2462                                 c = l-1;
2463                                 break;
2464                         }
2465         }
2466         Nicks_sanlist[0][c+1] = 0;
2467         //Con_Printf("List0: %s\n", Nicks_sanlist[0]);
2468 }
2469
2470 static unsigned int Nicks_strcleanlen(const char *s)
2471 {
2472         unsigned int l = 0;
2473         while(*s)
2474         {
2475                 if( (*s >= 'a' && *s <= 'z') ||
2476                     (*s >= 'A' && *s <= 'Z') ||
2477                     (*s >= '0' && *s <= '9') ||
2478                     *s == ' ')
2479                         ++l;
2480                 ++s;
2481         }
2482         return l;
2483 }
2484
2485 static void Nicks_CutMatchesAlphaNumeric(int count)
2486 {
2487         // cut match 0 down to the longest possible completion
2488         int i;
2489         unsigned int c, l;
2490         char tempstr[sizeof(Nicks_sanlist[0])];
2491         char *a, *b;
2492         char space_char = (con_nickcompletion_flags.integer & NICKS_NO_SPACES) ? 'a' : ' '; // yes this is correct, we want NO spaces when no spaces
2493
2494         c = (unsigned int)strlen(Nicks_sanlist[0]);
2495         for(i = 0, l = 0; i < (int)c; ++i)
2496         {
2497                 if( (Nicks_sanlist[0][i] >= 'a' && Nicks_sanlist[0][i] <= 'z') ||
2498                     (Nicks_sanlist[0][i] >= 'A' && Nicks_sanlist[0][i] <= 'Z') ||
2499                     (Nicks_sanlist[0][i] >= '0' && Nicks_sanlist[0][i] <= '9') || Nicks_sanlist[0][i] == space_char) // this is what's COPIED
2500                 {
2501                         tempstr[l++] = Nicks_sanlist[0][i];
2502                 }
2503         }
2504         tempstr[l] = 0;
2505
2506         for(i = 1; i < count; ++i)
2507         {
2508                 a = tempstr;
2509                 b = Nicks_sanlist[i];
2510                 while(1)
2511                 {
2512                         if(!*a)
2513                                 break;
2514                         if(!*b)
2515                         {
2516                                 *a = 0;
2517                                 break;
2518                         }
2519                         if(tolower(*a) == tolower(*b))
2520                         {
2521                                 ++a;
2522                                 ++b;
2523                                 continue;
2524                         }
2525                         if( (*b >= 'a' && *b <= 'z') || (*b >= 'A' && *b <= 'Z') || (*b >= '0' && *b <= '9') || *b == space_char)
2526                         {
2527                                 // b is alnum, so cut
2528                                 *a = 0;
2529                                 break;
2530                         }
2531                         ++b;
2532                 }
2533         }
2534         // Just so you know, if cutmatchesnormal doesn't kill the first entry, then even the non-alnums fit
2535         Nicks_CutMatchesNormal(count);
2536         //if(!Nicks_sanlist[0][0])
2537         if(Nicks_strcleanlen(Nicks_sanlist[0]) < strlen(tempstr))
2538         {
2539                 // if the clean sanitized one is longer than the current one, use it, it has crap chars which definitely are in there
2540                 strlcpy(Nicks_sanlist[0], tempstr, sizeof(Nicks_sanlist[0]));
2541         }
2542 }
2543
2544 static void Nicks_CutMatchesNoSpaces(int count)
2545 {
2546         // cut match 0 down to the longest possible completion
2547         int i;
2548         unsigned int c, l;
2549         char tempstr[sizeof(Nicks_sanlist[0])];
2550         char *a, *b;
2551
2552         c = (unsigned int)strlen(Nicks_sanlist[0]);
2553         for(i = 0, l = 0; i < (int)c; ++i)
2554         {
2555                 if(Nicks_sanlist[0][i] != ' ') // here it's what's NOT copied
2556                 {
2557                         tempstr[l++] = Nicks_sanlist[0][i];
2558                 }
2559         }
2560         tempstr[l] = 0;
2561
2562         for(i = 1; i < count; ++i)
2563         {
2564                 a = tempstr;
2565                 b = Nicks_sanlist[i];
2566                 while(1)
2567                 {
2568                         if(!*a)
2569                                 break;
2570                         if(!*b)
2571                         {
2572                                 *a = 0;
2573                                 break;
2574                         }
2575                         if(tolower(*a) == tolower(*b))
2576                         {
2577                                 ++a;
2578                                 ++b;
2579                                 continue;
2580                         }
2581                         if(*b != ' ')
2582                         {
2583                                 *a = 0;
2584                                 break;
2585                         }
2586                         ++b;
2587                 }
2588         }
2589         // Just so you know, if cutmatchesnormal doesn't kill the first entry, then even the non-alnums fit
2590         Nicks_CutMatchesNormal(count);
2591         //if(!Nicks_sanlist[0][0])
2592         //Con_Printf("TS: %s\n", tempstr);
2593         if(Nicks_strcleanlen(Nicks_sanlist[0]) < strlen(tempstr))
2594         {
2595                 // if the clean sanitized one is longer than the current one, use it, it has crap chars which definitely are in there
2596                 strlcpy(Nicks_sanlist[0], tempstr, sizeof(Nicks_sanlist[0]));
2597         }
2598 }
2599
2600 static void Nicks_CutMatches(int count)
2601 {
2602         if(con_nickcompletion_flags.integer & NICKS_ALPHANUMERICS_ONLY)
2603                 Nicks_CutMatchesAlphaNumeric(count);
2604         else if(con_nickcompletion_flags.integer & NICKS_NO_SPACES)
2605                 Nicks_CutMatchesNoSpaces(count);
2606         else
2607                 Nicks_CutMatchesNormal(count);
2608 }
2609
2610 static const char **Nicks_CompleteBuildList(int count)
2611 {
2612         const char **buf;
2613         int bpos = 0;
2614         // the list is freed by Con_CompleteCommandLine, so create a char**
2615         buf = (const char **)Mem_Alloc(tempmempool, count * sizeof(const char *) + sizeof (const char *));
2616
2617         for(; bpos < count; ++bpos)
2618                 buf[bpos] = Nicks_sanlist[bpos] + Nicks_offset[bpos];
2619
2620         Nicks_CutMatches(count);
2621
2622         buf[bpos] = NULL;
2623         return buf;
2624 }
2625
2626 /*
2627         Nicks_AddLastColor
2628         Restores the previous used color, after the autocompleted name.
2629 */
2630 static int Nicks_AddLastColor(char *buffer, int pos)
2631 {
2632         qboolean quote_added = false;
2633         int match;
2634         int color = STRING_COLOR_DEFAULT + '0';
2635         char r = 0, g = 0, b = 0;
2636
2637         if(con_nickcompletion_flags.integer & NICKS_ADD_QUOTE && buffer[Nicks_matchpos-1] == '\"')
2638         {
2639                 // we'll have to add a quote :)
2640                 buffer[pos++] = '\"';
2641                 quote_added = true;
2642         }
2643
2644         if((!quote_added && con_nickcompletion_flags.integer & NICKS_ADD_COLOR) || con_nickcompletion_flags.integer & NICKS_FORCE_COLOR)
2645         {
2646                 // add color when no quote was added, or when flags &4?
2647                 // find last color
2648                 for(match = Nicks_matchpos-1; match >= 0; --match)
2649                 {
2650                         if(buffer[match] == STRING_COLOR_TAG)
2651                         {
2652                                 if( isdigit(buffer[match+1]) )
2653                                 {
2654                                         color = buffer[match+1];
2655                                         break;
2656                                 }
2657                                 else if(buffer[match+1] == STRING_COLOR_RGB_TAG_CHAR)
2658                                 {
2659                                         if ( isxdigit(buffer[match+2]) && isxdigit(buffer[match+3]) && isxdigit(buffer[match+4]) )
2660                                         {
2661                                                 r = buffer[match+2];
2662                                                 g = buffer[match+3];
2663                                                 b = buffer[match+4];
2664                                                 color = -1;
2665                                                 break;
2666                                         }
2667                                 }
2668                         }
2669                 }
2670                 if(!quote_added)
2671                 {
2672                         if( pos >= 2 && buffer[pos-2] == STRING_COLOR_TAG && isdigit(buffer[pos-1]) ) // when thes use &4
2673                                 pos -= 2;
2674                         else if( pos >= 5 && buffer[pos-5] == STRING_COLOR_TAG && buffer[pos-4] == STRING_COLOR_RGB_TAG_CHAR
2675                                          && isxdigit(buffer[pos-3]) && isxdigit(buffer[pos-2]) && isxdigit(buffer[pos-1]) )
2676                                 pos -= 5;
2677                 }
2678                 buffer[pos++] = STRING_COLOR_TAG;
2679                 if (color == -1)
2680                 {
2681                         buffer[pos++] = STRING_COLOR_RGB_TAG_CHAR;
2682                         buffer[pos++] = r;
2683                         buffer[pos++] = g;
2684                         buffer[pos++] = b;
2685                 }
2686                 else
2687                         buffer[pos++] = color;
2688         }
2689         return pos;
2690 }
2691
2692 int Nicks_CompleteChatLine(char *buffer, size_t size, unsigned int pos)
2693 {
2694         int n;
2695         /*if(!con_nickcompletion.integer)
2696           return; is tested in Nicks_CompletionCountPossible */
2697         n = Nicks_CompleteCountPossible(buffer, pos, &buffer[pos], false);
2698         if(n == 1)
2699         {
2700                 size_t len;
2701                 char *msg;
2702
2703                 msg = Nicks_list[0];
2704                 len = min(size - Nicks_matchpos - 3, strlen(msg));
2705                 memcpy(&buffer[Nicks_matchpos], msg, len);
2706                 if(len < size - 7) // space for color code (^[0-9] or ^xrgb), space and \0
2707                         len = (int)Nicks_AddLastColor(buffer, Nicks_matchpos+(int)len);
2708                 buffer[len++] = ' ';
2709                 buffer[len] = 0;
2710                 return (int)len;
2711         } else if(n > 1)
2712         {
2713                 int len;
2714                 char *msg;
2715                 Con_Printf("\n%i possible nicks:\n", n);
2716                 Cmd_CompleteNicksPrint(n);
2717
2718                 Nicks_CutMatches(n);
2719
2720                 msg = Nicks_sanlist[0];
2721                 len = (int)min(size - Nicks_matchpos, strlen(msg));
2722                 memcpy(&buffer[Nicks_matchpos], msg, len);
2723                 buffer[Nicks_matchpos + len] = 0;
2724                 //pos += len;
2725                 return Nicks_matchpos + len;
2726         }
2727         return pos;
2728 }
2729
2730
2731 /*
2732         Con_CompleteCommandLine
2733
2734         New function for tab-completion system
2735         Added by EvilTypeGuy
2736         Thanks to Fett erich@heintz.com
2737         Thanks to taniwha
2738         Enhanced to tab-complete map names by [515]
2739
2740 */
2741 void Con_CompleteCommandLine (cmd_state_t *cmd)
2742 {
2743         const char *text = "";
2744         char *s;
2745         const char **list[4] = {0, 0, 0, 0};
2746         char s2[512];
2747         char command[512];
2748         int c, v, a, i, cmd_len, pos, k;
2749         int n; // nicks --blub
2750         const char *space, *patterns;
2751         char vabuf[1024];
2752
2753         //find what we want to complete
2754         pos = key_linepos;
2755         while(--pos)
2756         {
2757                 k = key_line[pos];
2758                 if(k == '\"' || k == ';' || k == ' ' || k == '\'')
2759                         break;
2760         }
2761         pos++;
2762
2763         s = key_line + pos;
2764         strlcpy(s2, key_line + key_linepos, sizeof(s2));        //save chars after cursor
2765         key_line[key_linepos] = 0;                                      //hide them
2766
2767         space = strchr(key_line + 1, ' ');
2768         if(space && pos == (space - key_line) + 1)
2769         {
2770                 strlcpy(command, key_line + 1, min(sizeof(command), (unsigned int)(space - key_line)));
2771
2772                 patterns = Cvar_VariableString(cmd->cvars, va(vabuf, sizeof(vabuf), "con_completion_%s", command), CVAR_CLIENT | CVAR_SERVER); // TODO maybe use a better place for this?
2773                 if(patterns && !*patterns)
2774                         patterns = NULL; // get rid of the empty string
2775
2776                 if(!strcmp(command, "map") || !strcmp(command, "changelevel") || (patterns && !strcmp(patterns, "map")))
2777                 {
2778                         //maps search
2779                         char t[MAX_QPATH];
2780                         if (GetMapList(s, t, sizeof(t)))
2781                         {
2782                                 // first move the cursor
2783                                 key_linepos += (int)strlen(t) - (int)strlen(s);
2784
2785                                 // and now do the actual work
2786                                 *s = 0;
2787                                 strlcat(key_line, t, MAX_INPUTLINE);
2788                                 strlcat(key_line, s2, MAX_INPUTLINE); //add back chars after cursor
2789
2790                                 // and fix the cursor
2791                                 if(key_linepos > (int) strlen(key_line))
2792                                         key_linepos = (int) strlen(key_line);
2793                         }
2794                         return;
2795                 }
2796                 else
2797                 {
2798                         if(patterns)
2799                         {
2800                                 char t[MAX_QPATH];
2801                                 stringlist_t resultbuf, dirbuf;
2802
2803                                 // Usage:
2804                                 //   // store completion patterns (space separated) for command foo in con_completion_foo
2805                                 //   set con_completion_foo "foodata/*.foodefault *.foo"
2806                                 //   foo <TAB>
2807                                 //
2808                                 // Note: patterns with slash are always treated as absolute
2809                                 // patterns; patterns without slash search in the innermost
2810                                 // directory the user specified. There is no way to "complete into"
2811                                 // a directory as of now, as directories seem to be unknown to the
2812                                 // FS subsystem.
2813                                 //
2814                                 // Examples:
2815                                 //   set con_completion_playermodel "models/player/*.zym models/player/*.md3 models/player/*.psk models/player/*.dpm"
2816                                 //   set con_completion_playdemo "*.dem"
2817                                 //   set con_completion_play "*.wav *.ogg"
2818                                 //
2819                                 // TODO somehow add support for directories; these shall complete
2820                                 // to their name + an appended slash.
2821
2822                                 stringlistinit(&resultbuf);
2823                                 stringlistinit(&dirbuf);
2824                                 while(COM_ParseToken_Simple(&patterns, false, false, true))
2825                                 {
2826                                         fssearch_t *search;
2827                                         if(strchr(com_token, '/'))
2828                                         {
2829                                                 search = FS_Search(com_token, true, true);
2830                                         }
2831                                         else
2832                                         {
2833                                                 const char *slash = strrchr(s, '/');
2834                                                 if(slash)
2835                                                 {
2836                                                         strlcpy(t, s, min(sizeof(t), (unsigned int)(slash - s + 2))); // + 2, because I want to include the slash
2837                                                         strlcat(t, com_token, sizeof(t));
2838                                                         search = FS_Search(t, true, true);
2839                                                 }
2840                                                 else
2841                                                         search = FS_Search(com_token, true, true);
2842                                         }
2843                                         if(search)
2844                                         {
2845                                                 for(i = 0; i < search->numfilenames; ++i)
2846                                                         if(!strncmp(search->filenames[i], s, strlen(s)))
2847                                                                 if(FS_FileType(search->filenames[i]) == FS_FILETYPE_FILE)
2848                                                                         stringlistappend(&resultbuf, search->filenames[i]);
2849                                                 FS_FreeSearch(search);
2850                                         }
2851                                 }
2852
2853                                 // In any case, add directory names
2854                                 {
2855                                         fssearch_t *search;
2856                                         const char *slash = strrchr(s, '/');
2857                                         if(slash)
2858                                         {
2859                                                 strlcpy(t, s, min(sizeof(t), (unsigned int)(slash - s + 2))); // + 2, because I want to include the slash
2860                                                 strlcat(t, "*", sizeof(t));
2861                                                 search = FS_Search(t, true, true);
2862                                         }
2863                                         else
2864                                                 search = FS_Search("*", true, true);
2865                                         if(search)
2866                                         {
2867                                                 for(i = 0; i < search->numfilenames; ++i)
2868                                                         if(!strncmp(search->filenames[i], s, strlen(s)))
2869                                                                 if(FS_FileType(search->filenames[i]) == FS_FILETYPE_DIRECTORY)
2870                                                                         stringlistappend(&dirbuf, search->filenames[i]);
2871                                                 FS_FreeSearch(search);
2872                                         }
2873                                 }
2874
2875                                 if(resultbuf.numstrings > 0 || dirbuf.numstrings > 0)
2876                                 {
2877                                         const char *p, *q;
2878                                         unsigned int matchchars;
2879                                         if(resultbuf.numstrings == 0 && dirbuf.numstrings == 1)
2880                                         {
2881                                                 dpsnprintf(t, sizeof(t), "%s/", dirbuf.strings[0]);
2882                                         }
2883                                         else
2884                                         if(resultbuf.numstrings == 1 && dirbuf.numstrings == 0)
2885                                         {
2886                                                 dpsnprintf(t, sizeof(t), "%s ", resultbuf.strings[0]);
2887                                         }
2888                                         else
2889                                         {
2890                                                 stringlistsort(&resultbuf, true); // dirbuf is already sorted
2891                                                 Con_Printf("\n%i possible filenames\n", resultbuf.numstrings + dirbuf.numstrings);
2892                                                 for(i = 0; i < dirbuf.numstrings; ++i)
2893                                                 {
2894                                                         Con_Printf("^4%s^7/\n", dirbuf.strings[i]);
2895                                                 }
2896                                                 for(i = 0; i < resultbuf.numstrings; ++i)
2897                                                 {
2898                                                         Con_Printf("%s\n", resultbuf.strings[i]);
2899                                                 }
2900                                                 matchchars = sizeof(t) - 1;
2901                                                 if(resultbuf.numstrings > 0)
2902                                                 {
2903                                                         p = resultbuf.strings[0];
2904                                                         q = resultbuf.strings[resultbuf.numstrings - 1];
2905                                                         for(; *p && *p == *q; ++p, ++q);
2906                                                         matchchars = (unsigned int)(p - resultbuf.strings[0]);
2907                                                 }
2908                                                 if(dirbuf.numstrings > 0)
2909                                                 {
2910                                                         p = dirbuf.strings[0];
2911                                                         q = dirbuf.strings[dirbuf.numstrings - 1];
2912                                                         for(; *p && *p == *q; ++p, ++q);
2913                                                         matchchars = min(matchchars, (unsigned int)(p - dirbuf.strings[0]));
2914                                                 }
2915                                                 // now p points to the first non-equal character, or to the end
2916                                                 // of resultbuf.strings[0]. We want to append the characters
2917                                                 // from resultbuf.strings[0] to (not including) p as these are
2918                                                 // the unique prefix
2919                                                 strlcpy(t, (resultbuf.numstrings > 0 ? resultbuf : dirbuf).strings[0], min(matchchars + 1, sizeof(t)));
2920                                         }
2921
2922                                         // first move the cursor
2923                                         key_linepos += (int)strlen(t) - (int)strlen(s);
2924
2925                                         // and now do the actual work
2926                                         *s = 0;
2927                                         strlcat(key_line, t, MAX_INPUTLINE);
2928                                         strlcat(key_line, s2, MAX_INPUTLINE); //add back chars after cursor
2929
2930                                         // and fix the cursor
2931                                         if(key_linepos > (int) strlen(key_line))
2932                                                 key_linepos = (int) strlen(key_line);
2933                                 }
2934                                 stringlistfreecontents(&resultbuf);
2935                                 stringlistfreecontents(&dirbuf);
2936
2937                                 return; // bail out, when we complete for a command that wants a file name
2938                         }
2939                 }
2940         }
2941
2942         // Count number of possible matches and print them
2943         c = Cmd_CompleteCountPossible(cmd, s);
2944         if (c)
2945         {
2946                 Con_Printf("\n%i possible command%s\n", c, (c > 1) ? "s: " : ":");
2947                 Cmd_CompleteCommandPrint(cmd, s);
2948         }
2949         v = Cvar_CompleteCountPossible(cmd->cvars, s, CVAR_CLIENT | CVAR_SERVER);
2950         if (v)
2951         {
2952                 Con_Printf("\n%i possible variable%s\n", v, (v > 1) ? "s: " : ":");
2953                 Cvar_CompleteCvarPrint(cmd->cvars, s, CVAR_CLIENT | CVAR_SERVER);
2954         }
2955         a = Cmd_CompleteAliasCountPossible(cmd, s);
2956         if (a)
2957         {
2958                 Con_Printf("\n%i possible alias%s\n", a, (a > 1) ? "es: " : ":");
2959                 Cmd_CompleteAliasPrint(cmd, s);
2960         }
2961         n = Nicks_CompleteCountPossible(key_line, key_linepos, s, true);
2962         if (n)
2963         {
2964                 Con_Printf("\n%i possible nick%s\n", n, (n > 1) ? "s: " : ":");
2965                 Cmd_CompleteNicksPrint(n);
2966         }
2967
2968         if (!(c + v + a + n))   // No possible matches
2969         {
2970                 if(s2[0])
2971                         strlcpy(&key_line[key_linepos], s2, sizeof(key_line) - key_linepos);
2972                 return;
2973         }
2974
2975         if (c)
2976                 text = *(list[0] = Cmd_CompleteBuildList(cmd, s));
2977         if (v)
2978                 text = *(list[1] = Cvar_CompleteBuildList(cmd->cvars, s, cmd->cvars_flagsmask));
2979         if (a)
2980                 text = *(list[2] = Cmd_CompleteAliasBuildList(cmd, s));
2981         if (n)
2982                 text = *(list[3] = Nicks_CompleteBuildList(n));
2983
2984         for (cmd_len = (int)strlen(s);;cmd_len++)
2985         {
2986                 const char **l;
2987                 for (i = 0; i < 3; i++)
2988                         if (list[i])
2989                                 for (l = list[i];*l;l++)
2990                                         if ((*l)[cmd_len] != text[cmd_len])
2991                                                 goto done;
2992                 // all possible matches share this character, so we continue...
2993                 if (!text[cmd_len])
2994                 {
2995                         // if all matches ended at the same position, stop
2996                         // (this means there is only one match)
2997                         break;
2998                 }
2999         }
3000 done:
3001
3002         // prevent a buffer overrun by limiting cmd_len according to remaining space
3003         cmd_len = min(cmd_len, (int)sizeof(key_line) - 1 - pos);
3004         if (text)
3005         {
3006                 key_linepos = pos;
3007                 memcpy(&key_line[key_linepos], text, cmd_len);
3008                 key_linepos += cmd_len;
3009                 // if there is only one match, add a space after it
3010                 if (c + v + a + n == 1 && key_linepos < (int)sizeof(key_line) - 1)
3011                 {
3012                         if(n)
3013                         { // was a nick, might have an offset, and needs colors ;) --blub
3014                                 key_linepos = pos - Nicks_offset[0];
3015                                 cmd_len = (int)strlen(Nicks_list[0]);
3016                                 cmd_len = min(cmd_len, (int)sizeof(key_line) - 3 - pos);
3017
3018                                 memcpy(&key_line[key_linepos] , Nicks_list[0], cmd_len);
3019                                 key_linepos += cmd_len;
3020                                 if(key_linepos < (int)(sizeof(key_line) - 7)) // space for color code (^[0-9] or ^xrgb), space and \0
3021                                         key_linepos = Nicks_AddLastColor(key_line, key_linepos);
3022                         }
3023                         key_line[key_linepos++] = ' ';
3024                 }
3025         }
3026
3027         // use strlcat to avoid a buffer overrun
3028         key_line[key_linepos] = 0;
3029         strlcat(key_line, s2, sizeof(key_line));
3030
3031         // free the command, cvar, and alias lists
3032         for (i = 0; i < 4; i++)
3033                 if (list[i])
3034                         Mem_Free((void *)list[i]);
3035 }
3036