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_bufferpos = (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_bufferpos = (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_bufferpos = (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 It draws either the console input line or the chat input line (if is_console is false)
1502 The input line scrolls horizontally if typing goes beyond the right edge
1503
1504 Modified by EvilTypeGuy eviltypeguy@qeradiant.com
1505 ================
1506 */
1507 static void Con_DrawInput(qboolean is_console, float x, float v, float inputsize)
1508 {
1509         int y, i, col_out, linepos, text_start, prefix_start;
1510         char text[MAX_INPUTLINE + 5 + 9 + 1]; // space for ^xRGB, "say_team:" and \0
1511         float xo;
1512         size_t len_out;
1513         char *prefix;
1514         dp_font_t *fnt;
1515
1516         if (is_console && !key_consoleactive)
1517                 return;         // don't draw anything
1518
1519         if (is_console)
1520         {
1521                 // empty prefix because ] is part of the console edit line
1522                 prefix = "";
1523                 strlcpy(text, key_line, sizeof(text));
1524                 linepos = key_linepos;
1525                 fnt = FONT_CONSOLE;
1526         }
1527         else
1528         {
1529                 if (chat_mode < 0)
1530                         prefix = "]";
1531                 else if(chat_mode)
1532                         prefix = "say_team:";
1533                 else
1534                         prefix = "say:";
1535                 strlcpy(text, chat_buffer, sizeof(text));
1536                 linepos = chat_bufferpos;
1537                 fnt = FONT_CHAT;
1538         }
1539
1540         y = (int)strlen(text);
1541
1542         // make the color code visible when the cursor is inside it
1543         if(text[linepos] != 0)
1544         {
1545                 for(i=1; i < 5 && linepos - i > 0; ++i)
1546                         if(text[linepos-i] == STRING_COLOR_TAG)
1547                         {
1548                                 int caret_pos, ofs = 0;
1549                                 caret_pos = linepos - i;
1550                                 if(i == 1 && text[caret_pos+1] == STRING_COLOR_TAG)
1551                                         ofs = 1;
1552                                 else if(i == 1 && isdigit(text[caret_pos+1]))
1553                                         ofs = 2;
1554                                 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]))
1555                                         ofs = 5;
1556                                 if(ofs && (size_t)(y + ofs + 1) < sizeof(text))
1557                                 {
1558                                         int carets = 1;
1559                                         while(caret_pos - carets >= 1 && text[caret_pos - carets] == STRING_COLOR_TAG)
1560                                                 ++carets;
1561                                         if(carets & 1)
1562                                         {
1563                                                 // str^2ing (displayed as string) --> str^2^^2ing (displayed as str^2ing)
1564                                                 // str^^ing (displayed as str^ing) --> str^^^^ing (displayed as str^^ing)
1565                                                 memmove(&text[caret_pos + ofs + 1], &text[caret_pos], y - caret_pos);
1566                                                 text[caret_pos + ofs] = STRING_COLOR_TAG;
1567                                                 y += ofs + 1;
1568                                                 text[y] = 0;
1569                                         }
1570                                 }
1571                                 break;
1572                         }
1573         }
1574
1575         if (!is_console)
1576         {
1577                 prefix_start = x;
1578                 x += DrawQ_TextWidth(prefix, 0, inputsize, inputsize, false, fnt);
1579         }
1580
1581         len_out = linepos;
1582         col_out = -1;
1583         xo = 0;
1584         if (linepos > 0)
1585                 xo = DrawQ_TextWidth_UntilWidth_TrackColors(text, &len_out, inputsize, inputsize, &col_out, false, fnt, 1000000000);
1586
1587         text_start = x + (vid_conwidth.value - x) * 0.95 - xo; // scroll
1588         if(text_start >= x)
1589                 text_start = x;
1590         else if (!is_console)
1591                 prefix_start -= (x - text_start);
1592
1593         if (!is_console)
1594                 DrawQ_String(prefix_start, v, prefix, 0, inputsize, inputsize, 1.0, 1.0, 1.0, 1.0, 0, NULL, false, fnt);
1595
1596         DrawQ_String(text_start, v, text, y + 3, inputsize, inputsize, 1.0, 1.0, 1.0, 1.0, 0, NULL, false, fnt);
1597
1598         // draw a cursor on top of this
1599         if ((int)(host.realtime*con_cursorspeed) & 1)           // cursor is visible
1600         {
1601                 if (!utf8_enable.integer)
1602                 {
1603                         text[0] = 11 + 130 * key_insert;        // either solid or triangle facing right
1604                         text[1] = 0;
1605                 }
1606                 else
1607                 {
1608                         size_t len;
1609                         const char *curbuf;
1610                         char charbuf16[16];
1611                         curbuf = u8_encodech(0xE000 + 11 + 130 * key_insert, &len, charbuf16);
1612                         memcpy(text, curbuf, len);
1613                         text[len] = 0;
1614                 }
1615                 DrawQ_String(text_start + xo, v, text, 0, inputsize, inputsize, 1.0, 1.0, 1.0, 1.0, 0, &col_out, false, fnt);
1616         }
1617 }
1618
1619 typedef struct
1620 {
1621         dp_font_t *font;
1622         float alignment; // 0 = left, 0.5 = center, 1 = right
1623         float fontsize;
1624         float x;
1625         float y;
1626         float width;
1627         float ymin, ymax;
1628         const char *continuationString;
1629
1630         // PRIVATE:
1631         int colorindex; // init to -1
1632 }
1633 con_text_info_t;
1634
1635 static float Con_WordWidthFunc(void *passthrough, const char *w, size_t *length, float maxWidth)
1636 {
1637         con_text_info_t *ti = (con_text_info_t *) passthrough;
1638         if(w == NULL)
1639         {
1640                 ti->colorindex = -1;
1641                 return ti->fontsize * ti->font->maxwidth;
1642         }
1643         if(maxWidth >= 0)
1644                 return DrawQ_TextWidth_UntilWidth(w, length, ti->fontsize, ti->fontsize, false, ti->font, -maxWidth); // -maxWidth: we want at least one char
1645         else if(maxWidth == -1)
1646                 return DrawQ_TextWidth(w, *length, ti->fontsize, ti->fontsize, false, ti->font);
1647         else
1648         {
1649                 Sys_PrintfToTerminal("Con_WordWidthFunc: can't get here (maxWidth should never be %f)\n", maxWidth);
1650                 // Note: this is NOT a Con_Printf, as it could print recursively
1651                 return 0;
1652         }
1653 }
1654
1655 static int Con_CountLineFunc(void *passthrough, const char *line, size_t length, float width, qboolean isContinuation)
1656 {
1657         (void) passthrough;
1658         (void) line;
1659         (void) length;
1660         (void) width;
1661         (void) isContinuation;
1662         return 1;
1663 }
1664
1665 static int Con_DisplayLineFunc(void *passthrough, const char *line, size_t length, float width, qboolean isContinuation)
1666 {
1667         con_text_info_t *ti = (con_text_info_t *) passthrough;
1668
1669         if(ti->y < ti->ymin - 0.001)
1670                 (void) 0;
1671         else if(ti->y > ti->ymax - ti->fontsize + 0.001)
1672                 (void) 0;
1673         else
1674         {
1675                 int x = (int) (ti->x + (ti->width - width) * ti->alignment);
1676                 if(isContinuation && *ti->continuationString)
1677                         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);
1678                 if(length > 0)
1679                         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);
1680         }
1681
1682         ti->y += ti->fontsize;
1683         return 1;
1684 }
1685
1686 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)
1687 {
1688         int i;
1689         int lines = 0;
1690         int maxlines = (int) floor(height / fontsize + 0.01f);
1691         int startidx;
1692         int nskip = 0;
1693         int continuationWidth = 0;
1694         size_t len;
1695         double t = cl.time; // saved so it won't change
1696         con_text_info_t ti;
1697
1698         ti.font = (mask_must & CON_MASK_CHAT) ? FONT_CHAT : FONT_NOTIFY;
1699         ti.fontsize = fontsize;
1700         ti.alignment = alignment_x;
1701         ti.width = width;
1702         ti.ymin = y;
1703         ti.ymax = y + height;
1704         ti.continuationString = continuationString;
1705
1706         len = 0;
1707         Con_WordWidthFunc(&ti, NULL, &len, -1);
1708         len = strlen(continuationString);
1709         continuationWidth = (int) Con_WordWidthFunc(&ti, continuationString, &len, -1);
1710
1711         // first find the first line to draw by backwards iterating and word wrapping to find their length...
1712         startidx = CON_LINES_COUNT;
1713         for(i = CON_LINES_COUNT - 1; i >= 0; --i)
1714         {
1715                 con_lineinfo_t *l = &CON_LINES(i);
1716                 int mylines;
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                 // WE FOUND ONE!
1726                 // Calculate its actual height...
1727                 mylines = COM_Wordwrap(l->start, l->len, continuationWidth, width, Con_WordWidthFunc, &ti, Con_CountLineFunc, &ti);
1728                 if(lines + mylines >= maxlines)
1729                 {
1730                         nskip = lines + mylines - maxlines;
1731                         lines = maxlines;
1732                         startidx = i;
1733                         break;
1734                 }
1735                 lines += mylines;
1736                 startidx = i;
1737         }
1738
1739         // then center according to the calculated amount of lines...
1740         ti.x = x;
1741         ti.y = y + alignment_y * (height - lines * fontsize) - nskip * fontsize;
1742
1743         // then actually draw
1744         for(i = startidx; i < CON_LINES_COUNT; ++i)
1745         {
1746                 con_lineinfo_t *l = &CON_LINES(i);
1747
1748                 if((l->mask & mask_must) != mask_must)
1749                         continue;
1750                 if(l->mask & mask_mustnot)
1751                         continue;
1752                 if(maxage && (l->addtime < t - maxage))
1753                         continue;
1754
1755                 COM_Wordwrap(l->start, l->len, continuationWidth, width, Con_WordWidthFunc, &ti, Con_DisplayLineFunc, &ti);
1756         }
1757
1758         return lines;
1759 }
1760
1761 /*
1762 ================
1763 Con_DrawNotify
1764
1765 Draws the last few lines of output transparently over the game top
1766 ================
1767 */
1768 void Con_DrawNotify (void)
1769 {
1770         float x, v;
1771         float chatstart, notifystart, inputsize, height;
1772         float align;
1773         int numChatlines;
1774         int chatpos;
1775
1776         if (con_mutex) Thread_LockMutex(con_mutex);
1777         ConBuffer_FixTimes(&con);
1778
1779         numChatlines = con_chat.integer;
1780
1781         chatpos = con_chatpos.integer;
1782
1783         if (con_notify.integer < 0)
1784                 Cvar_SetValueQuick(&con_notify, 0);
1785         if (gamemode == GAME_TRANSFUSION)
1786                 v = 8; // vertical offset
1787         else
1788                 v = 0;
1789
1790         // GAME_NEXUIZ: center, otherwise left justify
1791         align = con_notifyalign.value;
1792         if(!*con_notifyalign.string) // empty string, evaluated to 0 above
1793         {
1794                 if(IS_OLDNEXUIZ_DERIVED(gamemode))
1795                         align = 0.5;
1796         }
1797
1798         if(numChatlines || !con_chatrect.integer)
1799         {
1800                 if(chatpos == 0)
1801                 {
1802                         // first chat, input line, then notify
1803                         chatstart = v;
1804                         notifystart = v + (numChatlines + 1) * con_chatsize.value;
1805                 }
1806                 else if(chatpos > 0)
1807                 {
1808                         // first notify, then (chatpos-1) empty lines, then chat, then input
1809                         notifystart = v;
1810                         chatstart = v + (con_notify.value + (chatpos - 1)) * con_notifysize.value;
1811                 }
1812                 else // if(chatpos < 0)
1813                 {
1814                         // first notify, then much space, then chat, then input, then -chatpos-1 empty lines
1815                         notifystart = v;
1816                         chatstart = vid_conheight.value - (-chatpos-1 + numChatlines + 1) * con_chatsize.value;
1817                 }
1818         }
1819         else
1820         {
1821                 // just notify and input
1822                 notifystart = v;
1823                 chatstart = 0; // shut off gcc warning
1824         }
1825
1826         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, "");
1827
1828         if(con_chatrect.integer)
1829         {
1830                 x = con_chatrect_x.value * vid_conwidth.value;
1831                 v = con_chatrect_y.value * vid_conheight.value;
1832         }
1833         else
1834         {
1835                 x = 0;
1836                 if(numChatlines) // only do this if chat area is enabled, or this would move the input line wrong
1837                         v = chatstart;
1838         }
1839         height = numChatlines * con_chatsize.value;
1840
1841         if(numChatlines)
1842         {
1843                 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 ... ");
1844                 v += height;
1845         }
1846         if (key_dest == key_message)
1847         {
1848                 inputsize = (numChatlines ? con_chatsize : con_notifysize).value;
1849                 Con_DrawInput(false, x, v, inputsize);
1850         }
1851         else
1852                 chat_bufferpos = 0;
1853
1854         if (con_mutex) Thread_UnlockMutex(con_mutex);
1855 }
1856
1857 /*
1858 ================
1859 Con_LineHeight
1860
1861 Returns the height of a given console line; calculates it if necessary.
1862 ================
1863 */
1864 static int Con_LineHeight(int lineno)
1865 {
1866         con_lineinfo_t *li = &CON_LINES(lineno);
1867         if(li->height == -1)
1868         {
1869                 float width = vid_conwidth.value;
1870                 con_text_info_t ti;
1871                 ti.fontsize = con_textsize.value;
1872                 ti.font = FONT_CONSOLE;
1873                 li->height = COM_Wordwrap(li->start, li->len, 0, width, Con_WordWidthFunc, &ti, Con_CountLineFunc, NULL);
1874         }
1875         return li->height;
1876 }
1877
1878 /*
1879 ================
1880 Con_DrawConsoleLine
1881
1882 Draws a line of the console; returns its height in lines.
1883 If alpha is 0, the line is not drawn, but still wrapped and its height
1884 returned.
1885 ================
1886 */
1887 static int Con_DrawConsoleLine(int mask_must, int mask_mustnot, float y, int lineno, float ymin, float ymax)
1888 {
1889         float width = vid_conwidth.value;
1890         con_text_info_t ti;
1891         con_lineinfo_t *li = &CON_LINES(lineno);
1892
1893         if((li->mask & mask_must) != mask_must)
1894                 return 0;
1895         if((li->mask & mask_mustnot) != 0)
1896                 return 0;
1897
1898         ti.continuationString = "";
1899         ti.alignment = 0;
1900         ti.fontsize = con_textsize.value;
1901         ti.font = FONT_CONSOLE;
1902         ti.x = 0;
1903         ti.y = y - (Con_LineHeight(lineno) - 1) * ti.fontsize;
1904         ti.ymin = ymin;
1905         ti.ymax = ymax;
1906         ti.width = width;
1907
1908         return COM_Wordwrap(li->start, li->len, 0, width, Con_WordWidthFunc, &ti, Con_DisplayLineFunc, &ti);
1909 }
1910
1911 /*
1912 ================
1913 Con_LastVisibleLine
1914
1915 Calculates the last visible line index and how much to show of it based on
1916 con_backscroll.
1917 ================
1918 */
1919 static void Con_LastVisibleLine(int mask_must, int mask_mustnot, int *last, int *limitlast)
1920 {
1921         int lines_seen = 0;
1922         int i;
1923
1924         if(con_backscroll < 0)
1925                 con_backscroll = 0;
1926
1927         *last = 0;
1928
1929         // now count until we saw con_backscroll actual lines
1930         for(i = CON_LINES_COUNT - 1; i >= 0; --i)
1931         if((CON_LINES(i).mask & mask_must) == mask_must)
1932         if((CON_LINES(i).mask & mask_mustnot) == 0)
1933         {
1934                 int h = Con_LineHeight(i);
1935
1936                 // line is the last visible line?
1937                 *last = i;
1938                 if(lines_seen + h > con_backscroll && lines_seen <= con_backscroll)
1939                 {
1940                         *limitlast = lines_seen + h - con_backscroll;
1941                         return;
1942                 }
1943
1944                 lines_seen += h;
1945         }
1946
1947         // if we get here, no line was on screen - scroll so that one line is
1948         // visible then.
1949         con_backscroll = lines_seen - 1;
1950         *limitlast = 1;
1951 }
1952
1953 /*
1954 ================
1955 Con_DrawConsole
1956
1957 Draws the console with the solid background
1958 The typing input line at the bottom should only be drawn if typing is allowed
1959 ================
1960 */
1961 void Con_DrawConsole (int lines)
1962 {
1963         float alpha, alpha0;
1964         double sx, sy;
1965         int mask_must = 0;
1966         int mask_mustnot = (developer.integer>0) ? 0 : CON_MASK_DEVELOPER;
1967         cachepic_t *conbackpic;
1968         unsigned int conbackflags;
1969
1970         if (lines <= 0)
1971                 return;
1972
1973         if (con_mutex) Thread_LockMutex(con_mutex);
1974
1975         if (con_backscroll < 0)
1976                 con_backscroll = 0;
1977
1978         con_vislines = lines;
1979
1980         r_draw2d_force = true;
1981
1982 // draw the background
1983         alpha0 = cls.signon == SIGNONS ? scr_conalpha.value : 1.0f; // always full alpha when not in game
1984         if((alpha = alpha0 * scr_conalphafactor.value) > 0)
1985         {
1986                 sx = scr_conscroll_x.value;
1987                 sy = scr_conscroll_y.value;
1988                 conbackflags = CACHEPICFLAG_FAILONMISSING; // So console is readable when game content is missing
1989                 if (sx != 0 || sy != 0)
1990                         conbackflags &= CACHEPICFLAG_NOCLAMP;
1991                 conbackpic = scr_conbrightness.value >= 0.01f ? Draw_CachePic_Flags("gfx/conback", conbackflags) : NULL;
1992                 sx *= host.realtime; sy *= host.realtime;
1993                 sx -= floor(sx); sy -= floor(sy);
1994                 if (Draw_IsPicLoaded(conbackpic))
1995                         DrawQ_SuperPic(0, lines - vid_conheight.integer, conbackpic, vid_conwidth.integer, vid_conheight.integer,
1996                                         0 + sx, 0 + sy, scr_conbrightness.value, scr_conbrightness.value, scr_conbrightness.value, alpha,
1997                                         1 + sx, 0 + sy, scr_conbrightness.value, scr_conbrightness.value, scr_conbrightness.value, alpha,
1998                                         0 + sx, 1 + sy, scr_conbrightness.value, scr_conbrightness.value, scr_conbrightness.value, alpha,
1999                                         1 + sx, 1 + sy, scr_conbrightness.value, scr_conbrightness.value, scr_conbrightness.value, alpha,
2000                                         0);
2001                 else
2002                         DrawQ_Fill(0, lines - vid_conheight.integer, vid_conwidth.integer, vid_conheight.integer, 0.0f, 0.0f, 0.0f, alpha, 0);
2003         }
2004         if((alpha = alpha0 * scr_conalpha2factor.value) > 0)
2005         {
2006                 sx = scr_conscroll2_x.value;
2007                 sy = scr_conscroll2_y.value;
2008                 conbackpic = Draw_CachePic_Flags("gfx/conback2", (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         if((alpha = alpha0 * scr_conalpha3factor.value) > 0)
2020         {
2021                 sx = scr_conscroll3_x.value;
2022                 sy = scr_conscroll3_y.value;
2023                 conbackpic = Draw_CachePic_Flags("gfx/conback3", (sx != 0 || sy != 0) ? CACHEPICFLAG_NOCLAMP : 0);
2024                 sx *= host.realtime; sy *= host.realtime;
2025                 sx -= floor(sx); sy -= floor(sy);
2026                 if(Draw_IsPicLoaded(conbackpic))
2027                         DrawQ_SuperPic(0, lines - vid_conheight.integer, conbackpic, vid_conwidth.integer, vid_conheight.integer,
2028                                         0 + sx, 0 + sy, scr_conbrightness.value, scr_conbrightness.value, scr_conbrightness.value, alpha,
2029                                         1 + sx, 0 + sy, scr_conbrightness.value, scr_conbrightness.value, scr_conbrightness.value, alpha,
2030                                         0 + sx, 1 + sy, scr_conbrightness.value, scr_conbrightness.value, scr_conbrightness.value, alpha,
2031                                         1 + sx, 1 + sy, scr_conbrightness.value, scr_conbrightness.value, scr_conbrightness.value, alpha,
2032                                         0);
2033         }
2034         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);
2035
2036 // draw the text
2037 #if 0
2038         {
2039                 int i;
2040                 int count = CON_LINES_COUNT;
2041                 float ymax = con_vislines - 2 * con_textsize.value;
2042                 float y = ymax + con_textsize.value * con_backscroll;
2043                 for (i = 0;i < count && y >= 0;i++)
2044                         y -= Con_DrawConsoleLine(mask_must, mask_mustnot, y - con_textsize.value, CON_LINES_COUNT - 1 - i, 0, ymax) * con_textsize.value;
2045                 // fix any excessive scrollback for the next frame
2046                 if (i >= count && y >= 0)
2047                 {
2048                         con_backscroll -= (int)(y / con_textsize.value);
2049                         if (con_backscroll < 0)
2050                                 con_backscroll = 0;
2051                 }
2052         }
2053 #else
2054         if(CON_LINES_COUNT > 0)
2055         {
2056                 int i, last, limitlast;
2057                 float y;
2058                 float ymax = con_vislines - 2 * con_textsize.value;
2059                 Con_LastVisibleLine(mask_must, mask_mustnot, &last, &limitlast);
2060                 //Con_LastVisibleLine(mask_must, mask_mustnot, &last, &limitlast);
2061                 y = ymax - con_textsize.value;
2062
2063                 if(limitlast)
2064                         y += (CON_LINES(last).height - limitlast) * con_textsize.value;
2065                 i = last;
2066
2067                 for(;;)
2068                 {
2069                         y -= Con_DrawConsoleLine(mask_must, mask_mustnot, y, i, 0, ymax) * con_textsize.value;
2070                         if(i == 0)
2071                                 break; // top of console buffer
2072                         if(y < 0)
2073                                 break; // top of console window
2074                         limitlast = 0;
2075                         --i;
2076                 }
2077         }
2078 #endif
2079
2080 // draw the input prompt, user text, and cursor if desired
2081         Con_DrawInput(true, 0, con_vislines - con_textsize.value * 2, con_textsize.value);
2082
2083         r_draw2d_force = false;
2084         if (con_mutex) Thread_UnlockMutex(con_mutex);
2085 }
2086
2087 /*
2088 GetMapList
2089
2090 Made by [515]
2091 Prints not only map filename, but also
2092 its format (q1/q2/q3/hl) and even its message
2093 */
2094 //[515]: here is an ugly hack.. two gotos... oh my... *but it works*
2095 //LadyHavoc: rewrote bsp type detection, rewrote message extraction to do proper worldspawn parsing
2096 //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
2097 //LadyHavoc: FIXME: man this GetMapList is STILL ugly code even after my cleanups...
2098 qboolean GetMapList (const char *s, char *completedname, int completednamebufferlength)
2099 {
2100         fssearch_t      *t;
2101         char            message[1024];
2102         int                     i, k, max, p, o, min;
2103         unsigned char *len;
2104         qfile_t         *f;
2105         unsigned char buf[1024];
2106
2107         dpsnprintf(message, sizeof(message), "maps/%s*.bsp", s);
2108         t = FS_Search(message, 1, true);
2109         if(!t)
2110                 return false;
2111         if (t->numfilenames > 1)
2112                 Con_Printf("^1 %i maps found :\n", t->numfilenames);
2113         len = (unsigned char *)Z_Malloc(t->numfilenames);
2114         min = 666;
2115         for(max=i=0;i<t->numfilenames;i++)
2116         {
2117                 k = (int)strlen(t->filenames[i]);
2118                 k -= 9;
2119                 if(max < k)
2120                         max = k;
2121                 else
2122                 if(min > k)
2123                         min = k;
2124                 len[i] = k;
2125         }
2126         o = (int)strlen(s);
2127         for(i=0;i<t->numfilenames;i++)
2128         {
2129                 int lumpofs = 0, lumplen = 0;
2130                 char *entities = NULL;
2131                 const char *data = NULL;
2132                 char keyname[64];
2133                 char entfilename[MAX_QPATH];
2134                 char desc[64];
2135                 desc[0] = 0;
2136                 strlcpy(message, "^1ERROR: open failed^7", sizeof(message));
2137                 p = 0;
2138                 f = FS_OpenVirtualFile(t->filenames[i], true);
2139                 if(f)
2140                 {
2141                         strlcpy(message, "^1ERROR: not a known map format^7", sizeof(message));
2142                         memset(buf, 0, 1024);
2143                         FS_Read(f, buf, 1024);
2144                         if (!memcmp(buf, "IBSP", 4))
2145                         {
2146                                 p = LittleLong(((int *)buf)[1]);
2147                                 if (p == Q3BSPVERSION)
2148                                 {
2149                                         q3dheader_t *header = (q3dheader_t *)buf;
2150                                         lumpofs = LittleLong(header->lumps[Q3LUMP_ENTITIES].fileofs);
2151                                         lumplen = LittleLong(header->lumps[Q3LUMP_ENTITIES].filelen);
2152                                         dpsnprintf(desc, sizeof(desc), "Q3BSP%i", p);
2153                                 }
2154                                 else if (p == Q2BSPVERSION)
2155                                 {
2156                                         q2dheader_t *header = (q2dheader_t *)buf;
2157                                         lumpofs = LittleLong(header->lumps[Q2LUMP_ENTITIES].fileofs);
2158                                         lumplen = LittleLong(header->lumps[Q2LUMP_ENTITIES].filelen);
2159                                         dpsnprintf(desc, sizeof(desc), "Q2BSP%i", p);
2160                                 }
2161                                 else
2162                                         dpsnprintf(desc, sizeof(desc), "IBSP%i", p);
2163                         }
2164                         else if (BuffLittleLong(buf) == BSPVERSION)
2165                         {
2166                                 lumpofs = BuffLittleLong(buf + 4 + 8 * LUMP_ENTITIES);
2167                                 lumplen = BuffLittleLong(buf + 4 + 8 * LUMP_ENTITIES + 4);
2168                                 dpsnprintf(desc, sizeof(desc), "BSP29");
2169                         }
2170                         else if (BuffLittleLong(buf) == 30)
2171                         {
2172                                 lumpofs = BuffLittleLong(buf + 4 + 8 * LUMP_ENTITIES);
2173                                 lumplen = BuffLittleLong(buf + 4 + 8 * LUMP_ENTITIES + 4);
2174                                 dpsnprintf(desc, sizeof(desc), "BSPHL");
2175                         }
2176                         else if (!memcmp(buf, "BSP2", 4))
2177                         {
2178                                 lumpofs = BuffLittleLong(buf + 4 + 8 * LUMP_ENTITIES);
2179                                 lumplen = BuffLittleLong(buf + 4 + 8 * LUMP_ENTITIES + 4);
2180                                 dpsnprintf(desc, sizeof(desc), "BSP2");
2181                         }
2182                         else if (!memcmp(buf, "2PSB", 4))
2183                         {
2184                                 lumpofs = BuffLittleLong(buf + 4 + 8 * LUMP_ENTITIES);
2185                                 lumplen = BuffLittleLong(buf + 4 + 8 * LUMP_ENTITIES + 4);
2186                                 dpsnprintf(desc, sizeof(desc), "BSP2RMQe");
2187                         }
2188                         else
2189                         {
2190                                 dpsnprintf(desc, sizeof(desc), "unknown%i", BuffLittleLong(buf));
2191                         }
2192                         strlcpy(entfilename, t->filenames[i], sizeof(entfilename));
2193                         memcpy(entfilename + strlen(entfilename) - 4, ".ent", 5);
2194                         entities = (char *)FS_LoadFile(entfilename, tempmempool, true, NULL);
2195                         if (!entities && lumplen >= 10)
2196                         {
2197                                 FS_Seek(f, lumpofs, SEEK_SET);
2198                                 entities = (char *)Z_Malloc(lumplen + 1);
2199                                 FS_Read(f, entities, lumplen);
2200                         }
2201                         if (entities)
2202                         {
2203                                 // if there are entities to parse, a missing message key just
2204                                 // means there is no title, so clear the message string now
2205                                 message[0] = 0;
2206                                 data = entities;
2207                                 for (;;)
2208                                 {
2209                                         int l;
2210                                         if (!COM_ParseToken_Simple(&data, false, false, true))
2211                                                 break;
2212                                         if (com_token[0] == '{')
2213                                                 continue;
2214                                         if (com_token[0] == '}')
2215                                                 break;
2216                                         // skip leading whitespace
2217                                         for (k = 0;com_token[k] && ISWHITESPACE(com_token[k]);k++);
2218                                         for (l = 0;l < (int)sizeof(keyname) - 1 && com_token[k+l] && !ISWHITESPACE(com_token[k+l]);l++)
2219                                                 keyname[l] = com_token[k+l];
2220                                         keyname[l] = 0;
2221                                         if (!COM_ParseToken_Simple(&data, false, false, true))
2222                                                 break;
2223                                         if (developer_extra.integer)
2224                                                 Con_DPrintf("key: %s %s\n", keyname, com_token);
2225                                         if (!strcmp(keyname, "message"))
2226                                         {
2227                                                 // get the message contents
2228                                                 strlcpy(message, com_token, sizeof(message));
2229                                                 break;
2230                                         }
2231                                 }
2232                         }
2233                 }
2234                 if (entities)
2235                         Z_Free(entities);
2236                 if(f)
2237                         FS_Close(f);
2238                 *(t->filenames[i]+len[i]+5) = 0;
2239                 Con_Printf("%16s (%-8s) %s\n", t->filenames[i]+5, desc, message);
2240         }
2241         Con_Print("\n");
2242         for(p=o;p<min;p++)
2243         {
2244                 k = *(t->filenames[0]+5+p);
2245                 if(k == 0)
2246                         goto endcomplete;
2247                 for(i=1;i<t->numfilenames;i++)
2248                         if(*(t->filenames[i]+5+p) != k)
2249                                 goto endcomplete;
2250         }
2251 endcomplete:
2252         if(p > o && completedname && completednamebufferlength > 0)
2253         {
2254                 memset(completedname, 0, completednamebufferlength);
2255                 memcpy(completedname, (t->filenames[0]+5), min(p, completednamebufferlength - 1));
2256         }
2257         Z_Free(len);
2258         FS_FreeSearch(t);
2259         return p > o;
2260 }
2261
2262 /*
2263         Con_DisplayList
2264
2265         New function for tab-completion system
2266         Added by EvilTypeGuy
2267         MEGA Thanks to Taniwha
2268
2269 */
2270 void Con_DisplayList(const char **list)
2271 {
2272         int i = 0, pos = 0, len = 0, maxlen = 0, width = (con_linewidth - 4);
2273         const char **walk = list;
2274
2275         while (*walk) {
2276                 len = (int)strlen(*walk);
2277                 if (len > maxlen)
2278                         maxlen = len;
2279                 walk++;
2280         }
2281         maxlen += 1;
2282
2283         while (*list) {
2284                 len = (int)strlen(*list);
2285                 if (pos + maxlen >= width) {
2286                         Con_Print("\n");
2287                         pos = 0;
2288                 }
2289
2290                 Con_Print(*list);
2291                 for (i = 0; i < (maxlen - len); i++)
2292                         Con_Print(" ");
2293
2294                 pos += maxlen;
2295                 list++;
2296         }
2297
2298         if (pos)
2299                 Con_Print("\n\n");
2300 }
2301
2302
2303 // Now it becomes TRICKY :D --blub
2304 static char Nicks_list[MAX_SCOREBOARD][MAX_SCOREBOARDNAME];     // contains the nicks with colors and all that
2305 static char Nicks_sanlist[MAX_SCOREBOARD][MAX_SCOREBOARDNAME];  // sanitized list for completion when there are other possible matches.
2306 // means: when somebody uses a cvar's name as his name, we won't ever get his colors in there...
2307 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
2308 static int Nicks_matchpos;
2309
2310 // co against <<:BLASTER:>> is true!?
2311 static int Nicks_strncasecmp_nospaces(char *a, char *b, unsigned int a_len)
2312 {
2313         while(a_len)
2314         {
2315                 if(tolower(*a) == tolower(*b))
2316                 {
2317                         if(*a == 0)
2318                                 return 0;
2319                         --a_len;
2320                         ++a;
2321                         ++b;
2322                         continue;
2323                 }
2324                 if(!*a)
2325                         return -1;
2326                 if(!*b)
2327                         return 1;
2328                 if(*a == ' ')
2329                         return (*a < *b) ? -1 : 1;
2330                 if(*b == ' ')
2331                         ++b;
2332                 else
2333                         return (*a < *b) ? -1 : 1;
2334         }
2335         return 0;
2336 }
2337 static int Nicks_strncasecmp(char *a, char *b, unsigned int a_len)
2338 {
2339         char space_char;
2340         if(!(con_nickcompletion_flags.integer & NICKS_ALPHANUMERICS_ONLY))
2341         {
2342                 if(con_nickcompletion_flags.integer & NICKS_NO_SPACES)
2343                         return Nicks_strncasecmp_nospaces(a, b, a_len);
2344                 return strncasecmp(a, b, a_len);
2345         }
2346
2347         space_char = (con_nickcompletion_flags.integer & NICKS_NO_SPACES) ? 'a' : ' ';
2348
2349         // ignore non alphanumerics of B
2350         // if A contains a non-alphanumeric, B must contain it as well though!
2351         while(a_len)
2352         {
2353                 qboolean alnum_a, alnum_b;
2354
2355                 if(tolower(*a) == tolower(*b))
2356                 {
2357                         if(*a == 0) // end of both strings, they're equal
2358                                 return 0;
2359                         --a_len;
2360                         ++a;
2361                         ++b;
2362                         continue;
2363                 }
2364                 // not equal, end of one string?
2365                 if(!*a)
2366                         return -1;
2367                 if(!*b)
2368                         return 1;
2369                 // ignore non alphanumerics
2370                 alnum_a = ( (*a >= 'a' && *a <= 'z') || (*a >= 'A' && *a <= 'Z') || (*a >= '0' && *a <= '9') || *a == space_char);
2371                 alnum_b = ( (*b >= 'a' && *b <= 'z') || (*b >= 'A' && *b <= 'Z') || (*b >= '0' && *b <= '9') || *b == space_char);
2372                 if(!alnum_a) // b must contain this
2373                         return (*a < *b) ? -1 : 1;
2374                 if(!alnum_b)
2375                         ++b;
2376                 // otherwise, both are alnum, they're just not equal, return the appropriate number
2377                 else
2378                         return (*a < *b) ? -1 : 1;
2379         }
2380         return 0;
2381 }
2382
2383
2384 /* Nicks_CompleteCountPossible
2385
2386    Count the number of possible nicks to complete
2387  */
2388 static int Nicks_CompleteCountPossible(char *line, int pos, char *s, qboolean isCon)
2389 {
2390         char name[MAX_SCOREBOARDNAME];
2391         int i, p;
2392         int match;
2393         int spos;
2394         int count = 0;
2395
2396         if(!con_nickcompletion.integer)
2397                 return 0;
2398
2399         // changed that to 1
2400         if(!line[0])// || !line[1]) // we want at least... 2 written characters
2401                 return 0;
2402
2403         for(i = 0; i < cl.maxclients; ++i)
2404         {
2405                 p = i;
2406                 if(!cl.scores[p].name[0])
2407                         continue;
2408
2409                 SanitizeString(cl.scores[p].name, name);
2410                 //Con_Printf(" ^2Sanitized: ^7%s -> %s", cl.scores[p].name, name);
2411
2412                 if(!name[0])
2413                         continue;
2414
2415                 match = -1;
2416                 spos = pos - 1; // no need for a minimum of characters :)
2417
2418                 while(spos >= 0)
2419                 {
2420                         if(spos > 0 && line[spos-1] != ' ' && line[spos-1] != ';' && line[spos-1] != '\"' && line[spos-1] != '\'')
2421                         {
2422                                 if(!(isCon && spos == 1)) // console start
2423                                 {
2424                                         --spos;
2425                                         continue;
2426                                 }
2427                         }
2428                         if(isCon && spos == 0)
2429                                 break;
2430                         if(Nicks_strncasecmp(line+spos, name, pos-spos) == 0)
2431                                 match = spos;
2432                         --spos;
2433                 }
2434                 if(match < 0)
2435                         continue;
2436                 //Con_Printf("Possible match: %s|%s\n", cl.scores[p].name, name);
2437                 strlcpy(Nicks_list[count], cl.scores[p].name, sizeof(Nicks_list[count]));
2438
2439                 // the sanitized list
2440                 strlcpy(Nicks_sanlist[count], name, sizeof(Nicks_sanlist[count]));
2441                 if(!count)
2442                 {
2443                         Nicks_matchpos = match;
2444                 }
2445
2446                 Nicks_offset[count] = s - (&line[match]);
2447                 //Con_Printf("offset for %s: %i\n", name, Nicks_offset[count]);
2448
2449                 ++count;
2450         }
2451         return count;
2452 }
2453
2454 static void Cmd_CompleteNicksPrint(int count)
2455 {
2456         int i;
2457         for(i = 0; i < count; ++i)
2458                 Con_Printf("%s\n", Nicks_list[i]);
2459 }
2460
2461 static void Nicks_CutMatchesNormal(int count)
2462 {
2463         // cut match 0 down to the longest possible completion
2464         int i;
2465         unsigned int c, l;
2466         c = (unsigned int)strlen(Nicks_sanlist[0]) - 1;
2467         for(i = 1; i < count; ++i)
2468         {
2469                 l = (unsigned int)strlen(Nicks_sanlist[i]) - 1;
2470                 if(l < c)
2471                         c = l;
2472
2473                 for(l = 0; l <= c; ++l)
2474                         if(tolower(Nicks_sanlist[0][l]) != tolower(Nicks_sanlist[i][l]))
2475                         {
2476                                 c = l-1;
2477                                 break;
2478                         }
2479         }
2480         Nicks_sanlist[0][c+1] = 0;
2481         //Con_Printf("List0: %s\n", Nicks_sanlist[0]);
2482 }
2483
2484 static unsigned int Nicks_strcleanlen(const char *s)
2485 {
2486         unsigned int l = 0;
2487         while(*s)
2488         {
2489                 if( (*s >= 'a' && *s <= 'z') ||
2490                     (*s >= 'A' && *s <= 'Z') ||
2491                     (*s >= '0' && *s <= '9') ||
2492                     *s == ' ')
2493                         ++l;
2494                 ++s;
2495         }
2496         return l;
2497 }
2498
2499 static void Nicks_CutMatchesAlphaNumeric(int count)
2500 {
2501         // cut match 0 down to the longest possible completion
2502         int i;
2503         unsigned int c, l;
2504         char tempstr[sizeof(Nicks_sanlist[0])];
2505         char *a, *b;
2506         char space_char = (con_nickcompletion_flags.integer & NICKS_NO_SPACES) ? 'a' : ' '; // yes this is correct, we want NO spaces when no spaces
2507
2508         c = (unsigned int)strlen(Nicks_sanlist[0]);
2509         for(i = 0, l = 0; i < (int)c; ++i)
2510         {
2511                 if( (Nicks_sanlist[0][i] >= 'a' && Nicks_sanlist[0][i] <= 'z') ||
2512                     (Nicks_sanlist[0][i] >= 'A' && Nicks_sanlist[0][i] <= 'Z') ||
2513                     (Nicks_sanlist[0][i] >= '0' && Nicks_sanlist[0][i] <= '9') || Nicks_sanlist[0][i] == space_char) // this is what's COPIED
2514                 {
2515                         tempstr[l++] = Nicks_sanlist[0][i];
2516                 }
2517         }
2518         tempstr[l] = 0;
2519
2520         for(i = 1; i < count; ++i)
2521         {
2522                 a = tempstr;
2523                 b = Nicks_sanlist[i];
2524                 while(1)
2525                 {
2526                         if(!*a)
2527                                 break;
2528                         if(!*b)
2529                         {
2530                                 *a = 0;
2531                                 break;
2532                         }
2533                         if(tolower(*a) == tolower(*b))
2534                         {
2535                                 ++a;
2536                                 ++b;
2537                                 continue;
2538                         }
2539                         if( (*b >= 'a' && *b <= 'z') || (*b >= 'A' && *b <= 'Z') || (*b >= '0' && *b <= '9') || *b == space_char)
2540                         {
2541                                 // b is alnum, so cut
2542                                 *a = 0;
2543                                 break;
2544                         }
2545                         ++b;
2546                 }
2547         }
2548         // Just so you know, if cutmatchesnormal doesn't kill the first entry, then even the non-alnums fit
2549         Nicks_CutMatchesNormal(count);
2550         //if(!Nicks_sanlist[0][0])
2551         if(Nicks_strcleanlen(Nicks_sanlist[0]) < strlen(tempstr))
2552         {
2553                 // if the clean sanitized one is longer than the current one, use it, it has crap chars which definitely are in there
2554                 strlcpy(Nicks_sanlist[0], tempstr, sizeof(Nicks_sanlist[0]));
2555         }
2556 }
2557
2558 static void Nicks_CutMatchesNoSpaces(int count)
2559 {
2560         // cut match 0 down to the longest possible completion
2561         int i;
2562         unsigned int c, l;
2563         char tempstr[sizeof(Nicks_sanlist[0])];
2564         char *a, *b;
2565
2566         c = (unsigned int)strlen(Nicks_sanlist[0]);
2567         for(i = 0, l = 0; i < (int)c; ++i)
2568         {
2569                 if(Nicks_sanlist[0][i] != ' ') // here it's what's NOT copied
2570                 {
2571                         tempstr[l++] = Nicks_sanlist[0][i];
2572                 }
2573         }
2574         tempstr[l] = 0;
2575
2576         for(i = 1; i < count; ++i)
2577         {
2578                 a = tempstr;
2579                 b = Nicks_sanlist[i];
2580                 while(1)
2581                 {
2582                         if(!*a)
2583                                 break;
2584                         if(!*b)
2585                         {
2586                                 *a = 0;
2587                                 break;
2588                         }
2589                         if(tolower(*a) == tolower(*b))
2590                         {
2591                                 ++a;
2592                                 ++b;
2593                                 continue;
2594                         }
2595                         if(*b != ' ')
2596                         {
2597                                 *a = 0;
2598                                 break;
2599                         }
2600                         ++b;
2601                 }
2602         }
2603         // Just so you know, if cutmatchesnormal doesn't kill the first entry, then even the non-alnums fit
2604         Nicks_CutMatchesNormal(count);
2605         //if(!Nicks_sanlist[0][0])
2606         //Con_Printf("TS: %s\n", tempstr);
2607         if(Nicks_strcleanlen(Nicks_sanlist[0]) < strlen(tempstr))
2608         {
2609                 // if the clean sanitized one is longer than the current one, use it, it has crap chars which definitely are in there
2610                 strlcpy(Nicks_sanlist[0], tempstr, sizeof(Nicks_sanlist[0]));
2611         }
2612 }
2613
2614 static void Nicks_CutMatches(int count)
2615 {
2616         if(con_nickcompletion_flags.integer & NICKS_ALPHANUMERICS_ONLY)
2617                 Nicks_CutMatchesAlphaNumeric(count);
2618         else if(con_nickcompletion_flags.integer & NICKS_NO_SPACES)
2619                 Nicks_CutMatchesNoSpaces(count);
2620         else
2621                 Nicks_CutMatchesNormal(count);
2622 }
2623
2624 static const char **Nicks_CompleteBuildList(int count)
2625 {
2626         const char **buf;
2627         int bpos = 0;
2628         // the list is freed by Con_CompleteCommandLine, so create a char**
2629         buf = (const char **)Mem_Alloc(tempmempool, count * sizeof(const char *) + sizeof (const char *));
2630
2631         for(; bpos < count; ++bpos)
2632                 buf[bpos] = Nicks_sanlist[bpos] + Nicks_offset[bpos];
2633
2634         Nicks_CutMatches(count);
2635
2636         buf[bpos] = NULL;
2637         return buf;
2638 }
2639
2640 /*
2641         Nicks_AddLastColor
2642         Restores the previous used color, after the autocompleted name.
2643 */
2644 static int Nicks_AddLastColor(char *buffer, int pos)
2645 {
2646         qboolean quote_added = false;
2647         int match;
2648         int color = STRING_COLOR_DEFAULT + '0';
2649         char r = 0, g = 0, b = 0;
2650
2651         if(con_nickcompletion_flags.integer & NICKS_ADD_QUOTE && buffer[Nicks_matchpos-1] == '\"')
2652         {
2653                 // we'll have to add a quote :)
2654                 buffer[pos++] = '\"';
2655                 quote_added = true;
2656         }
2657
2658         if((!quote_added && con_nickcompletion_flags.integer & NICKS_ADD_COLOR) || con_nickcompletion_flags.integer & NICKS_FORCE_COLOR)
2659         {
2660                 // add color when no quote was added, or when flags &4?
2661                 // find last color
2662                 for(match = Nicks_matchpos-1; match >= 0; --match)
2663                 {
2664                         if(buffer[match] == STRING_COLOR_TAG)
2665                         {
2666                                 if( isdigit(buffer[match+1]) )
2667                                 {
2668                                         color = buffer[match+1];
2669                                         break;
2670                                 }
2671                                 else if(buffer[match+1] == STRING_COLOR_RGB_TAG_CHAR)
2672                                 {
2673                                         if ( isxdigit(buffer[match+2]) && isxdigit(buffer[match+3]) && isxdigit(buffer[match+4]) )
2674                                         {
2675                                                 r = buffer[match+2];
2676                                                 g = buffer[match+3];
2677                                                 b = buffer[match+4];
2678                                                 color = -1;
2679                                                 break;
2680                                         }
2681                                 }
2682                         }
2683                 }
2684                 if(!quote_added)
2685                 {
2686                         if( pos >= 2 && buffer[pos-2] == STRING_COLOR_TAG && isdigit(buffer[pos-1]) ) // when thes use &4
2687                                 pos -= 2;
2688                         else if( pos >= 5 && buffer[pos-5] == STRING_COLOR_TAG && buffer[pos-4] == STRING_COLOR_RGB_TAG_CHAR
2689                                          && isxdigit(buffer[pos-3]) && isxdigit(buffer[pos-2]) && isxdigit(buffer[pos-1]) )
2690                                 pos -= 5;
2691                 }
2692                 buffer[pos++] = STRING_COLOR_TAG;
2693                 if (color == -1)
2694                 {
2695                         buffer[pos++] = STRING_COLOR_RGB_TAG_CHAR;
2696                         buffer[pos++] = r;
2697                         buffer[pos++] = g;
2698                         buffer[pos++] = b;
2699                 }
2700                 else
2701                         buffer[pos++] = color;
2702         }
2703         return pos;
2704 }
2705
2706 /*
2707         Con_CompleteCommandLine
2708
2709         New function for tab-completion system
2710         Added by EvilTypeGuy
2711         Thanks to Fett erich@heintz.com
2712         Thanks to taniwha
2713         Enhanced to tab-complete map names by [515]
2714
2715 */
2716 int Con_CompleteCommandLine(cmd_state_t *cmd, qboolean is_console)
2717 {
2718         const char *text = "";
2719         char *s;
2720         const char **list[4] = {0, 0, 0, 0};
2721         char s2[512];
2722         char command[512];
2723         int c, v, a, i, cmd_len, pos, k;
2724         int n; // nicks --blub
2725         const char *space, *patterns;
2726         char vabuf[1024];
2727
2728         char *line;
2729         int linestart, linepos;
2730         unsigned int linesize;
2731         if (is_console)
2732         {
2733                 line = key_line;
2734                 linepos = key_linepos;
2735                 linesize = sizeof(key_line);
2736                 linestart = 1;
2737         }
2738         else
2739         {
2740                 line = chat_buffer;
2741                 linepos = chat_bufferpos;
2742                 linesize = sizeof(chat_buffer);
2743                 linestart = 0;
2744         }
2745
2746         //find what we want to complete
2747         pos = linepos;
2748         while(--pos >= linestart)
2749         {
2750                 k = line[pos];
2751                 if(k == '\"' || k == ';' || k == ' ' || k == '\'')
2752                         break;
2753         }
2754         pos++;
2755
2756         s = line + pos;
2757         strlcpy(s2, line + linepos, sizeof(s2)); //save chars after cursor
2758         line[linepos] = 0; //hide them
2759
2760         c = v = a = n = cmd_len = 0;
2761         if (!is_console)
2762                 goto nicks;
2763
2764         space = strchr(line + 1, ' ');
2765         if(space && pos == (space - line) + 1)
2766         {
2767                 strlcpy(command, line + 1, min(sizeof(command), (unsigned int)(space - line)));
2768
2769                 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?
2770                 if(patterns && !*patterns)
2771                         patterns = NULL; // get rid of the empty string
2772
2773                 if(!strcmp(command, "map") || !strcmp(command, "changelevel") || (patterns && !strcmp(patterns, "map")))
2774                 {
2775                         //maps search
2776                         char t[MAX_QPATH];
2777                         if (GetMapList(s, t, sizeof(t)))
2778                         {
2779                                 // first move the cursor
2780                                 linepos += (int)strlen(t) - (int)strlen(s);
2781
2782                                 // and now do the actual work
2783                                 *s = 0;
2784                                 strlcat(line, t, MAX_INPUTLINE);
2785                                 strlcat(line, s2, MAX_INPUTLINE); //add back chars after cursor
2786
2787                                 // and fix the cursor
2788                                 if(linepos > (int) strlen(line))
2789                                         linepos = (int) strlen(line);
2790                         }
2791                         return linepos;
2792                 }
2793                 else
2794                 {
2795                         if(patterns)
2796                         {
2797                                 char t[MAX_QPATH];
2798                                 stringlist_t resultbuf, dirbuf;
2799
2800                                 // Usage:
2801                                 //   // store completion patterns (space separated) for command foo in con_completion_foo
2802                                 //   set con_completion_foo "foodata/*.foodefault *.foo"
2803                                 //   foo <TAB>
2804                                 //
2805                                 // Note: patterns with slash are always treated as absolute
2806                                 // patterns; patterns without slash search in the innermost
2807                                 // directory the user specified. There is no way to "complete into"
2808                                 // a directory as of now, as directories seem to be unknown to the
2809                                 // FS subsystem.
2810                                 //
2811                                 // Examples:
2812                                 //   set con_completion_playermodel "models/player/*.zym models/player/*.md3 models/player/*.psk models/player/*.dpm"
2813                                 //   set con_completion_playdemo "*.dem"
2814                                 //   set con_completion_play "*.wav *.ogg"
2815                                 //
2816                                 // TODO somehow add support for directories; these shall complete
2817                                 // to their name + an appended slash.
2818
2819                                 stringlistinit(&resultbuf);
2820                                 stringlistinit(&dirbuf);
2821                                 while(COM_ParseToken_Simple(&patterns, false, false, true))
2822                                 {
2823                                         fssearch_t *search;
2824                                         if(strchr(com_token, '/'))
2825                                         {
2826                                                 search = FS_Search(com_token, true, true);
2827                                         }
2828                                         else
2829                                         {
2830                                                 const char *slash = strrchr(s, '/');
2831                                                 if(slash)
2832                                                 {
2833                                                         strlcpy(t, s, min(sizeof(t), (unsigned int)(slash - s + 2))); // + 2, because I want to include the slash
2834                                                         strlcat(t, com_token, sizeof(t));
2835                                                         search = FS_Search(t, true, true);
2836                                                 }
2837                                                 else
2838                                                         search = FS_Search(com_token, true, true);
2839                                         }
2840                                         if(search)
2841                                         {
2842                                                 for(i = 0; i < search->numfilenames; ++i)
2843                                                         if(!strncmp(search->filenames[i], s, strlen(s)))
2844                                                                 if(FS_FileType(search->filenames[i]) == FS_FILETYPE_FILE)
2845                                                                         stringlistappend(&resultbuf, search->filenames[i]);
2846                                                 FS_FreeSearch(search);
2847                                         }
2848                                 }
2849
2850                                 // In any case, add directory names
2851                                 {
2852                                         fssearch_t *search;
2853                                         const char *slash = strrchr(s, '/');
2854                                         if(slash)
2855                                         {
2856                                                 strlcpy(t, s, min(sizeof(t), (unsigned int)(slash - s + 2))); // + 2, because I want to include the slash
2857                                                 strlcat(t, "*", sizeof(t));
2858                                                 search = FS_Search(t, true, true);
2859                                         }
2860                                         else
2861                                                 search = FS_Search("*", true, true);
2862                                         if(search)
2863                                         {
2864                                                 for(i = 0; i < search->numfilenames; ++i)
2865                                                         if(!strncmp(search->filenames[i], s, strlen(s)))
2866                                                                 if(FS_FileType(search->filenames[i]) == FS_FILETYPE_DIRECTORY)
2867                                                                         stringlistappend(&dirbuf, search->filenames[i]);
2868                                                 FS_FreeSearch(search);
2869                                         }
2870                                 }
2871
2872                                 if(resultbuf.numstrings > 0 || dirbuf.numstrings > 0)
2873                                 {
2874                                         const char *p, *q;
2875                                         unsigned int matchchars;
2876                                         if(resultbuf.numstrings == 0 && dirbuf.numstrings == 1)
2877                                         {
2878                                                 dpsnprintf(t, sizeof(t), "%s/", dirbuf.strings[0]);
2879                                         }
2880                                         else
2881                                         if(resultbuf.numstrings == 1 && dirbuf.numstrings == 0)
2882                                         {
2883                                                 dpsnprintf(t, sizeof(t), "%s ", resultbuf.strings[0]);
2884                                         }
2885                                         else
2886                                         {
2887                                                 stringlistsort(&resultbuf, true); // dirbuf is already sorted
2888                                                 Con_Printf("\n%i possible filenames\n", resultbuf.numstrings + dirbuf.numstrings);
2889                                                 for(i = 0; i < dirbuf.numstrings; ++i)
2890                                                 {
2891                                                         Con_Printf("^4%s^7/\n", dirbuf.strings[i]);
2892                                                 }
2893                                                 for(i = 0; i < resultbuf.numstrings; ++i)
2894                                                 {
2895                                                         Con_Printf("%s\n", resultbuf.strings[i]);
2896                                                 }
2897                                                 matchchars = sizeof(t) - 1;
2898                                                 if(resultbuf.numstrings > 0)
2899                                                 {
2900                                                         p = resultbuf.strings[0];
2901                                                         q = resultbuf.strings[resultbuf.numstrings - 1];
2902                                                         for(; *p && *p == *q; ++p, ++q);
2903                                                         matchchars = (unsigned int)(p - resultbuf.strings[0]);
2904                                                 }
2905                                                 if(dirbuf.numstrings > 0)
2906                                                 {
2907                                                         p = dirbuf.strings[0];
2908                                                         q = dirbuf.strings[dirbuf.numstrings - 1];
2909                                                         for(; *p && *p == *q; ++p, ++q);
2910                                                         matchchars = min(matchchars, (unsigned int)(p - dirbuf.strings[0]));
2911                                                 }
2912                                                 // now p points to the first non-equal character, or to the end
2913                                                 // of resultbuf.strings[0]. We want to append the characters
2914                                                 // from resultbuf.strings[0] to (not including) p as these are
2915                                                 // the unique prefix
2916                                                 strlcpy(t, (resultbuf.numstrings > 0 ? resultbuf : dirbuf).strings[0], min(matchchars + 1, sizeof(t)));
2917                                         }
2918
2919                                         // first move the cursor
2920                                         linepos += (int)strlen(t) - (int)strlen(s);
2921
2922                                         // and now do the actual work
2923                                         *s = 0;
2924                                         strlcat(line, t, MAX_INPUTLINE);
2925                                         strlcat(line, s2, MAX_INPUTLINE); //add back chars after cursor
2926
2927                                         // and fix the cursor
2928                                         if(linepos > (int) strlen(line))
2929                                                 linepos = (int) strlen(line);
2930                                 }
2931                                 stringlistfreecontents(&resultbuf);
2932                                 stringlistfreecontents(&dirbuf);
2933
2934                                 return linepos; // bail out, when we complete for a command that wants a file name
2935                         }
2936                 }
2937         }
2938
2939         // Count number of possible matches and print them
2940         c = Cmd_CompleteCountPossible(cmd, s);
2941         if (c)
2942         {
2943                 Con_Printf("\n%i possible command%s\n", c, (c > 1) ? "s: " : ":");
2944                 Cmd_CompleteCommandPrint(cmd, s);
2945         }
2946         v = Cvar_CompleteCountPossible(cmd->cvars, s, CVAR_CLIENT | CVAR_SERVER);
2947         if (v)
2948         {
2949                 Con_Printf("\n%i possible variable%s\n", v, (v > 1) ? "s: " : ":");
2950                 Cvar_CompleteCvarPrint(cmd->cvars, s, CVAR_CLIENT | CVAR_SERVER);
2951         }
2952         a = Cmd_CompleteAliasCountPossible(cmd, s);
2953         if (a)
2954         {
2955                 Con_Printf("\n%i possible alias%s\n", a, (a > 1) ? "es: " : ":");
2956                 Cmd_CompleteAliasPrint(cmd, s);
2957         }
2958
2959 nicks:
2960         n = Nicks_CompleteCountPossible(line, linepos, s, is_console);
2961         if (n)
2962         {
2963                 Con_Printf("\n%i possible nick%s\n", n, (n > 1) ? "s: " : ":");
2964                 Cmd_CompleteNicksPrint(n);
2965         }
2966
2967         if (!(c + v + a + n))   // No possible matches
2968         {
2969                 if(s2[0])
2970                         strlcpy(&line[linepos], s2, linesize - linepos);
2971                 return linepos;
2972         }
2973
2974         if (c)
2975                 text = *(list[0] = Cmd_CompleteBuildList(cmd, s));
2976         if (v)
2977                 text = *(list[1] = Cvar_CompleteBuildList(cmd->cvars, s, cmd->cvars_flagsmask));
2978         if (a)
2979                 text = *(list[2] = Cmd_CompleteAliasBuildList(cmd, s));
2980         if (n)
2981         {
2982                 if (is_console)
2983                         text = *(list[3] = Nicks_CompleteBuildList(n));
2984                 else
2985                         text = *(Nicks_CompleteBuildList(n));
2986         }
2987
2988         for (cmd_len = (int)strlen(s);;cmd_len++)
2989         {
2990                 const char **l;
2991                 for (i = 0; i < 3; i++)
2992                         if (list[i])
2993                                 for (l = list[i];*l;l++)
2994                                         if ((*l)[cmd_len] != text[cmd_len])
2995                                                 goto done;
2996                 // all possible matches share this character, so we continue...
2997                 if (!text[cmd_len])
2998                 {
2999                         // if all matches ended at the same position, stop
3000                         // (this means there is only one match)
3001                         break;
3002                 }
3003         }
3004 done:
3005
3006         // prevent a buffer overrun by limiting cmd_len according to remaining space
3007         cmd_len = min(cmd_len, (int)linesize - 1 - pos);
3008         if (text)
3009         {
3010                 linepos = pos;
3011                 memcpy(&line[linepos], text, cmd_len);
3012                 linepos += cmd_len;
3013                 // if there is only one match, add a space after it
3014                 if (c + v + a + n == 1 && linepos < (int)linesize - 1)
3015                 {
3016                         if(n)
3017                         { // was a nick, might have an offset, and needs colors ;) --blub
3018                                 linepos = pos - Nicks_offset[0];
3019                                 cmd_len = (int)strlen(Nicks_list[0]);
3020                                 cmd_len = min(cmd_len, (int)linesize - 3 - pos);
3021
3022                                 memcpy(&line[linepos] , Nicks_list[0], cmd_len);
3023                                 linepos += cmd_len;
3024                                 if(linepos < (int)(linesize - 7)) // space for color code (^[0-9] or ^xrgb), space and \0
3025                                         linepos = Nicks_AddLastColor(line, linepos);
3026                         }
3027                         line[linepos++] = ' ';
3028                 }
3029         }
3030
3031         // use strlcat to avoid a buffer overrun
3032         line[linepos] = 0;
3033         strlcat(line, s2, linesize);
3034
3035         if (!is_console)
3036                 return linepos;
3037
3038         // free the command, cvar, and alias lists
3039         for (i = 0; i < 4; i++)
3040                 if (list[i])
3041                         Mem_Free((void *)list[i]);
3042
3043         return linepos;
3044 }
3045