X-Git-Url: http://git.xonotic.org/?a=blobdiff_plain;f=console.c;h=9856e8e3bf307bd482c6f3486447773e75991b26;hb=f8310c7ac538900f83222787acc7971d113f79b7;hp=67618ab9863f156a27ee031beaed92016efe9a6b;hpb=cdf059c8126a4e32e2e203ad295534002619f91f;p=xonotic%2Fdarkplaces.git

diff --git a/console.c b/console.c
index 67618ab9..9856e8e3 100644
--- a/console.c
+++ b/console.c
@@ -19,29 +19,26 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 */
 // console.c
 
-#include "quakedef.h"
-
 #if !defined(WIN32) || defined(__MINGW32__)
 # include <unistd.h>
 #endif
 #include <time.h>
 
-float con_cursorspeed = 4;
+#include "quakedef.h"
 
-#define		CON_TEXTSIZE	1048576
-#define		CON_MAXLINES	  16384
+// for u8_encodech
+#include "ft2.h"
+
+float con_cursorspeed = 4;
 
 // lines up from bottom to display
 int con_backscroll;
 
 conbuffer_t con;
 
-#define CON_LINES_IDX(i) CONBUF_LINES_IDX(&con, i)
-#define CON_LINES_UNIDX(i) CONBUF_LINES_UNIDX(&con, i)
-#define CON_LINES_LAST CONBUF_LINES_LAST(&con)
-#define CON_LINES(i) CONBUF_LINES(&con, i)
-#define CON_LINES_PRED(i) CONBUF_LINES_PRED(&con, i)
-#define CON_LINES_SUCC(i) CONBUF_LINES_SUCC(&con, i)
+#define CON_LINES(i) CONBUFFER_LINES(&con, i)
+#define CON_LINES_LAST CONBUFFER_LINES_LAST(&con)
+#define CON_LINES_COUNT CONBUFFER_LINES_COUNT(&con)
 
 cvar_t con_notifytime = {CVAR_SAVE, "con_notifytime","3", "how long notify lines last, in seconds"};
 cvar_t con_notify = {CVAR_SAVE, "con_notify","4", "how many notify lines to show"};
@@ -50,10 +47,14 @@ cvar_t con_notifyalign = {CVAR_SAVE, "con_notifyalign", "", "how to align notify
 cvar_t con_chattime = {CVAR_SAVE, "con_chattime","30", "how long chat lines last, in seconds"};
 cvar_t con_chat = {CVAR_SAVE, "con_chat","0", "how many chat lines to show in a dedicated chat area"};
 cvar_t con_chatpos = {CVAR_SAVE, "con_chatpos","0", "where to put chat (negative: lines from bottom of screen, positive: lines below notify, 0: at top)"};
+cvar_t con_chatrect = {CVAR_SAVE, "con_chatrect","0", "use con_chatrect_x and _y to position con_notify and con_chat freely instead of con_chatpos"};
+cvar_t con_chatrect_x = {CVAR_SAVE, "con_chatrect_x","", "where to put chat, relative x coordinate of left edge on screen (use con_chatwidth for width)"};
+cvar_t con_chatrect_y = {CVAR_SAVE, "con_chatrect_y","", "where to put chat, relative y coordinate of top edge on screen (use con_chat for line count)"};
 cvar_t con_chatwidth = {CVAR_SAVE, "con_chatwidth","1.0", "relative chat window width"};
 cvar_t con_textsize = {CVAR_SAVE, "con_textsize","8", "console text size in virtual 2D pixels"};
 cvar_t con_notifysize = {CVAR_SAVE, "con_notifysize","8", "notify text size in virtual 2D pixels"};
 cvar_t con_chatsize = {CVAR_SAVE, "con_chatsize","8", "chat text size in virtual 2D pixels (if con_chat is enabled)"};
+cvar_t con_chatsound = {CVAR_SAVE, "con_chatsound","1", "enables chat sound to play on message"};
 
 
 cvar_t sys_specialcharactertranslation = {0, "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)"};
@@ -78,9 +79,9 @@ cvar_t con_nickcompletion_flags = {CVAR_SAVE, "con_nickcompletion_flags", "11",
 #define NICKS_ALPHANUMERICS_ONLY 8
 #define NICKS_NO_SPACES 16
 
-cvar_t con_completion_playdemo = {CVAR_SAVE, "con_completion_playdemo", "*.dem"};
-cvar_t con_completion_timedemo = {CVAR_SAVE, "con_completion_timedemo", "*.dem"};
-cvar_t con_completion_exec = {CVAR_SAVE, "con_completion_exec", "*.cfg"};
+cvar_t con_completion_playdemo = {CVAR_SAVE, "con_completion_playdemo", "*.dem", "completion pattern for the playdemo command"};
+cvar_t con_completion_timedemo = {CVAR_SAVE, "con_completion_timedemo", "*.dem", "completion pattern for the timedemo command"};
+cvar_t con_completion_exec = {CVAR_SAVE, "con_completion_exec", "*.cfg", "completion pattern for the exec command"};
 
 int con_linewidth;
 int con_vislines;
@@ -92,15 +93,17 @@ lhnetsocket_t *rcon_redirect_sock = NULL;
 lhnetaddress_t *rcon_redirect_dest = NULL;
 int rcon_redirect_bufferpos = 0;
 char rcon_redirect_buffer[1400];
+qboolean rcon_redirect_proquakeprotocol = false;
 
 // generic functions for console buffers
 
 void ConBuffer_Init(conbuffer_t *buf, int textsize, int maxlines, mempool_t *mempool)
 {
+	buf->active = true;
 	buf->textsize = textsize;
-	buf->text = Mem_Alloc(mempool, textsize);
+	buf->text = (char *) Mem_Alloc(mempool, textsize);
 	buf->maxlines = maxlines;
-	buf->lines = Mem_Alloc(mempool, maxlines * sizeof(*buf->lines));
+	buf->lines = (con_lineinfo_t *) Mem_Alloc(mempool, maxlines * sizeof(*buf->lines));
 	buf->lines_first = 0;
 	buf->lines_count = 0;
 }
@@ -122,8 +125,13 @@ ConBuffer_Shutdown
 */
 void ConBuffer_Shutdown(conbuffer_t *buf)
 {
-	Mem_Free(buf->text);
-	Mem_Free(buf->lines);
+	buf->active = false;
+	if (buf->text)
+		Mem_Free(buf->text);
+	if (buf->lines)
+		Mem_Free(buf->lines);
+	buf->text = NULL;
+	buf->lines = NULL;
 }
 
 /*
@@ -140,11 +148,11 @@ void ConBuffer_FixTimes(conbuffer_t *buf)
 	int i;
 	if(buf->lines_count >= 1)
 	{
-		double diff = cl.time - (buf->lines + CONBUF_LINES_LAST(buf))->addtime;
+		double diff = cl.time - CONBUFFER_LINES_LAST(buf).addtime;
 		if(diff < 0)
 		{
 			for(i = 0; i < buf->lines_count; ++i)
-				CONBUF_LINES(buf, i).addtime += diff;
+				CONBUFFER_LINES(buf, i).addtime += diff;
 		}
 	}
 }
@@ -161,7 +169,7 @@ void ConBuffer_DeleteLine(conbuffer_t *buf)
 	if(buf->lines_count == 0)
 		return;
 	--buf->lines_count;
-	buf->lines_first = CONBUF_LINES_IDX(buf, 1);
+	buf->lines_first = (buf->lines_first + 1) % buf->maxlines;
 }
 
 /*
@@ -195,7 +203,7 @@ static char *ConBuffer_BytesLeft(conbuffer_t *buf, int len)
 	else
 	{
 		char *firstline_start = buf->lines[buf->lines_first].start;
-		char *lastline_onepastend = buf->lines[CONBUF_LINES_LAST(buf)].start + buf->lines[CONBUF_LINES_LAST(buf)].len;
+		char *lastline_onepastend = CONBUFFER_LINES_LAST(buf).start + CONBUFFER_LINES_LAST(buf).len;
 		// the buffer is cyclic, so we first have two cases...
 		if(firstline_start < lastline_onepastend) // buffer is contiguous
 		{
@@ -230,6 +238,10 @@ void ConBuffer_AddLine(conbuffer_t *buf, const char *line, int len, int mask)
 	char *putpos;
 	con_lineinfo_t *p;
 
+	// developer_memory 1 during shutdown prints while conbuffer_t is being freed
+	if (!buf->active)
+		return;
+
 	ConBuffer_FixTimes(buf);
 
 	if(len >= buf->textsize)
@@ -247,7 +259,7 @@ void ConBuffer_AddLine(conbuffer_t *buf, const char *line, int len, int mask)
 
 	//fprintf(stderr, "Now have %d lines (%d -> %d).\n", buf->lines_count, buf->lines_first, CON_LINES_LAST);
 
-	p = buf->lines + CONBUF_LINES_LAST(buf);
+	p = &CONBUFFER_LINES_LAST(buf);
 	p->start = putpos;
 	p->len = len;
 	p->addtime = cl.time;
@@ -262,7 +274,7 @@ int ConBuffer_FindPrevLine(conbuffer_t *buf, int mask_must, int mask_mustnot, in
 		start = buf->lines_count;
 	for(i = start - 1; i >= 0; --i)
 	{
-		con_lineinfo_t *l = &CONBUF_LINES(buf, i);
+		con_lineinfo_t *l = &CONBUFFER_LINES(buf, i);
 
 		if((l->mask & mask_must) != mask_must)
 			continue;
@@ -280,7 +292,7 @@ int Con_FindNextLine(conbuffer_t *buf, int mask_must, int mask_mustnot, int star
 	int i;
 	for(i = start + 1; i < buf->lines_count; ++i)
 	{
-		con_lineinfo_t *l = &CONBUF_LINES(buf, i);
+		con_lineinfo_t *l = &CONBUFFER_LINES(buf, i);
 
 		if((l->mask & mask_must) != mask_must)
 			continue;
@@ -296,7 +308,7 @@ int Con_FindNextLine(conbuffer_t *buf, int mask_must, int mask_mustnot, int star
 const char *ConBuffer_GetLine(conbuffer_t *buf, int i)
 {
 	static char copybuf[MAX_INPUTLINE];
-	con_lineinfo_t *l = &CONBUF_LINES(buf, i);
+	con_lineinfo_t *l = &CONBUFFER_LINES(buf, i);
 	size_t sz = l->len+1 > sizeof(copybuf) ? sizeof(copybuf) : l->len+1;
 	strlcpy(copybuf, l->start, sz);
 	return copybuf;
@@ -310,6 +322,8 @@ LOGGING
 ==============================================================================
 */
 
+/// \name Logging
+//@{
 cvar_t log_file = {0, "log_file","", "filename to log messages to"};
 cvar_t log_dest_udp = {0, "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"};
 char log_dest_buffer[1400]; // UDP packet
@@ -323,13 +337,13 @@ size_t logq_ind = 0;
 size_t logq_size = 0;
 
 void Log_ConPrint (const char *msg);
-
+//@}
 /*
 ====================
 Log_DestBuffer_Init
 ====================
 */
-static void Log_DestBuffer_Init()
+static void Log_DestBuffer_Init(void)
 {
 	memcpy(log_dest_buffer, "\377\377\377\377n", 5); // QW rcon print
 	log_dest_buffer_pos = 5;
@@ -340,7 +354,7 @@ static void Log_DestBuffer_Init()
 Log_DestBuffer_Flush
 ====================
 */
-void Log_DestBuffer_Flush()
+void Log_DestBuffer_Flush(void)
 {
 	lhnetaddress_t log_dest_addr;
 	lhnetsocket_t *log_dest_socket;
@@ -590,14 +604,12 @@ void Con_ToggleConsole_f (void)
 /*
 ================
 Con_ClearNotify
-
-Clear all notify lines.
 ================
 */
 void Con_ClearNotify (void)
 {
 	int i;
-	for(i = 0; i < con.lines_count; ++i)
+	for(i = 0; i < CON_LINES_COUNT; ++i)
 		CON_LINES(i).mask |= CON_MASK_HIDENOTIFY;
 }
 
@@ -611,6 +623,8 @@ void Con_MessageMode_f (void)
 {
 	key_dest = key_message;
 	chat_mode = 0; // "say"
+	chat_bufferlen = 0;
+	chat_buffer[0] = 0;
 }
 
 
@@ -623,6 +637,8 @@ void Con_MessageMode2_f (void)
 {
 	key_dest = key_message;
 	chat_mode = 1; // "say_team"
+	chat_bufferlen = 0;
+	chat_buffer[0] = 0;
 }
 
 /*
@@ -644,8 +660,6 @@ void Con_CommandMode_f (void)
 /*
 ================
 Con_CheckResize
-
-If the line width has changed, reformat the buffer.
 ================
 */
 void Con_CheckResize (void)
@@ -658,13 +672,14 @@ void Con_CheckResize (void)
 		Cvar_SetValueQuick(&con_textsize, f);
 	width = (int)floor(vid_conwidth.value / con_textsize.value);
 	width = bound(1, width, con.textsize/4);
+		// FIXME uses con in a non abstracted way
 
 	if (width == con_linewidth)
 		return;
 
 	con_linewidth = width;
 
-	for(i = 0; i < con.lines_count; ++i)
+	for(i = 0; i < CON_LINES_COUNT; ++i)
 		CON_LINES(i).height = -1; // recalculate when next needed
 
 	Con_ClearNotify();
@@ -701,7 +716,7 @@ void Con_ConDump_f (void)
 		Con_Printf("condump: unable to write file \"%s\"\n", Cmd_Argv(1));
 		return;
 	}
-	for(i = 0; i < con.lines_count; ++i)
+	for(i = 0; i < CON_LINES_COUNT; ++i)
 	{
 		FS_Write(file, CON_LINES(i).start, CON_LINES(i).len);
 		FS_Write(file, "\n", 1);
@@ -709,7 +724,7 @@ void Con_ConDump_f (void)
 	FS_Close(file);
 }
 
-void Con_Clear_f ()
+void Con_Clear_f (void)
 {
 	ConBuffer_Clear(&con);
 }
@@ -743,6 +758,9 @@ void Con_Init (void)
 	// register our cvars
 	Cvar_RegisterVariable (&con_chat);
 	Cvar_RegisterVariable (&con_chatpos);
+	Cvar_RegisterVariable (&con_chatrect_x);
+	Cvar_RegisterVariable (&con_chatrect_y);
+	Cvar_RegisterVariable (&con_chatrect);
 	Cvar_RegisterVariable (&con_chatsize);
 	Cvar_RegisterVariable (&con_chattime);
 	Cvar_RegisterVariable (&con_chatwidth);
@@ -751,6 +769,7 @@ void Con_Init (void)
 	Cvar_RegisterVariable (&con_notifysize);
 	Cvar_RegisterVariable (&con_notifytime);
 	Cvar_RegisterVariable (&con_textsize);
+	Cvar_RegisterVariable (&con_chatsound);
 
 	// --blub
 	Cvar_RegisterVariable (&con_nickcompletion);
@@ -773,6 +792,10 @@ void Con_Init (void)
 	Con_DPrint("Console initialized.\n");
 }
 
+void Con_Shutdown (void)
+{
+	ConBuffer_Shutdown(&con);
+}
 
 /*
 ================
@@ -793,6 +816,9 @@ void Con_PrintToHistory(const char *txt, int mask)
 	static char buf[CON_TEXTSIZE];
 	static int bufpos = 0;
 
+	if(!con.text) // FIXME uses a non-abstracted property of con
+		return;
+
 	for(; *txt; ++txt)
 	{
 		if(cr_pending)
@@ -815,7 +841,7 @@ void Con_PrintToHistory(const char *txt, int mask)
 				break;
 			default:
 				buf[bufpos++] = *txt;
-				if(bufpos >= con.textsize - 1)
+				if(bufpos >= con.textsize - 1) // FIXME uses a non-abstracted property of con
 				{
 					ConBuffer_AddLine(&con, buf, bufpos, mask);
 					bufpos = 0;
@@ -825,7 +851,7 @@ void Con_PrintToHistory(const char *txt, int mask)
 	}
 }
 
-/* The translation table between the graphical font and plain ASCII  --KB */
+/*! The translation table between the graphical font and plain ASCII  --KB */
 static char qfont_table[256] = {
 	'\0', '#',  '#',  '#',  '#',  '.',  '#',  '#',
 	'#',  9,    10,   '#',  ' ',  13,   '.',  '.',
@@ -862,30 +888,48 @@ static char qfont_table[256] = {
 	'x',  'y',  'z',  '{',  '|',  '}',  '~',  '<'
 };
 
-void Con_Rcon_Redirect_Init(lhnetsocket_t *sock, lhnetaddress_t *dest)
+void Con_Rcon_Redirect_Init(lhnetsocket_t *sock, lhnetaddress_t *dest, qboolean proquakeprotocol)
 {
 	rcon_redirect_sock = sock;
 	rcon_redirect_dest = dest;
-	memcpy(rcon_redirect_buffer, "\377\377\377\377n", 5); // QW rcon print
+	rcon_redirect_proquakeprotocol = proquakeprotocol;
+	if (rcon_redirect_proquakeprotocol)
+	{
+		// reserve space for the packet header
+		rcon_redirect_buffer[0] = 0;
+		rcon_redirect_buffer[1] = 0;
+		rcon_redirect_buffer[2] = 0;
+		rcon_redirect_buffer[3] = 0;
+		// this is a reply to a CCREQ_RCON
+		rcon_redirect_buffer[4] = CCREP_RCON;
+	}
+	else
+		memcpy(rcon_redirect_buffer, "\377\377\377\377n", 5); // QW rcon print
 	rcon_redirect_bufferpos = 5;
 }
 
-void Con_Rcon_Redirect_Flush()
+void Con_Rcon_Redirect_Flush(void)
 {
 	rcon_redirect_buffer[rcon_redirect_bufferpos] = 0;
-	NetConn_WriteString(rcon_redirect_sock, rcon_redirect_buffer, rcon_redirect_dest);
+	if (rcon_redirect_proquakeprotocol)
+	{
+		// update the length in the packet header
+		StoreBigLong((unsigned char *)rcon_redirect_buffer, NETFLAG_CTL | (rcon_redirect_bufferpos & NETFLAG_LENGTH_MASK));
+	}
+	NetConn_Write(rcon_redirect_sock, rcon_redirect_buffer, rcon_redirect_bufferpos, rcon_redirect_dest);
 	memcpy(rcon_redirect_buffer, "\377\377\377\377n", 5); // QW rcon print
 	rcon_redirect_bufferpos = 5;
+	rcon_redirect_proquakeprotocol = false;
 }
 
-void Con_Rcon_Redirect_End()
+void Con_Rcon_Redirect_End(void)
 {
 	Con_Rcon_Redirect_Flush();
 	rcon_redirect_dest = NULL;
 	rcon_redirect_sock = NULL;
 }
 
-void Con_Rcon_Redirect_Abort()
+void Con_Rcon_Redirect_Abort(void)
 {
 	rcon_redirect_dest = NULL;
 	rcon_redirect_sock = NULL;
@@ -894,10 +938,9 @@ void Con_Rcon_Redirect_Abort()
 /*
 ================
 Con_Rcon_AddChar
-
-Adds a character to the rcon buffer
 ================
 */
+/// Adds a character to the rcon buffer.
 void Con_Rcon_AddChar(int c)
 {
 	if(log_dest_buffer_appending)
@@ -992,15 +1035,13 @@ static char Sys_Con_NearestColor(const unsigned char _r, const unsigned char _g,
 
 /*
 ================
-Con_Print
-
-Prints to all appropriate console targets, and adds timestamps
+Con_MaskPrint
 ================
 */
 extern cvar_t timestamps;
 extern cvar_t timeformat;
 extern qboolean sys_nostdout;
-void Con_Print(const char *msg)
+void Con_MaskPrint(int additionalmask, const char *msg)
 {
 	static int mask = 0;
 	static int index = 0;
@@ -1025,19 +1066,22 @@ void Con_Print(const char *msg)
 				// play talk wav
 				if (*msg == 1)
 				{
-					if(gamemode == GAME_NEXUIZ)
+					if (con_chatsound.value)
 					{
-						if(msg[1] == '\r' && cl.foundtalk2wav)
-							S_LocalSound ("sound/misc/talk2.wav");
-						else
-							S_LocalSound ("sound/misc/talk.wav");
-					}
-					else
-					{
-						if (msg[1] == '(' && cl.foundtalk2wav)
-							S_LocalSound ("sound/misc/talk2.wav");
+						if(gamemode == GAME_NEXUIZ || gamemode == GAME_XONOTIC)
+						{
+							if(msg[1] == '\r' && cl.foundtalk2wav)
+								S_LocalSound ("sound/misc/talk2.wav");
+							else
+								S_LocalSound ("sound/misc/talk.wav");
+						}
 						else
-							S_LocalSound ("sound/misc/talk.wav");
+						{
+							if (msg[1] == '(' && cl.foundtalk2wav)
+								S_LocalSound ("sound/misc/talk2.wav");
+							else
+								S_LocalSound ("sound/misc/talk.wav");
+						}
 					}
 					mask = CON_MASK_CHAT;
 				}
@@ -1050,6 +1094,8 @@ void Con_Print(const char *msg)
 			for (;*timestamp;index++, timestamp++)
 				if (index < (int)sizeof(line) - 2)
 					line[index] = *timestamp;
+			// add the mask
+			mask |= additionalmask;
 		}
 		// append the character
 		line[index++] = *msg;
@@ -1064,16 +1110,29 @@ void Con_Print(const char *msg)
 			if (con_initialized && cls.state != ca_dedicated)
 			{
 				Con_PrintToHistory(line, mask);
-				mask = 0;
 			}
 			// send to terminal or dedicated server window
 			if (!sys_nostdout)
+			if (developer.integer || !(mask & CON_MASK_DEVELOPER))
 			{
-				unsigned char *p;
 				if(sys_specialcharactertranslation.integer)
 				{
-					for (p = (unsigned char *) line;*p; p++)
-						*p = qfont_table[*p];
+					char *p;
+					const char *q;
+					p = line;
+					while(*p)
+					{
+						int ch = u8_getchar(p, &q);
+						if(ch >= 0xE000 && ch <= 0xE0FF)
+						{
+							*p = qfont_table[ch - 0xE000];
+							if(q > p+1)
+								memmove(p+1, q, strlen(q)+1);
+							p = p + 1;
+						}
+						else
+							p = p + (q - p);
+					}
 				}
 
 				if(sys_colortranslation.integer == 1) // ANSI
@@ -1251,16 +1310,41 @@ void Con_Print(const char *msg)
 			}
 			// empty the line buffer
 			index = 0;
+			mask = 0;
 		}
 	}
 }
 
+/*
+================
+Con_MaskPrintf
+================
+*/
+void Con_MaskPrintf(int mask, const char *fmt, ...)
+{
+	va_list argptr;
+	char msg[MAX_INPUTLINE];
+
+	va_start(argptr,fmt);
+	dpvsnprintf(msg,sizeof(msg),fmt,argptr);
+	va_end(argptr);
+
+	Con_MaskPrint(mask, msg);
+}
 
 /*
 ================
-Con_Printf
+Con_Print
+================
+*/
+void Con_Print(const char *msg)
+{
+	Con_MaskPrint(CON_MASK_PRINT, msg);
+}
 
-Prints to all appropriate console targets
+/*
+================
+Con_Printf
 ================
 */
 void Con_Printf(const char *fmt, ...)
@@ -1272,28 +1356,25 @@ void Con_Printf(const char *fmt, ...)
 	dpvsnprintf(msg,sizeof(msg),fmt,argptr);
 	va_end(argptr);
 
-	Con_Print(msg);
+	Con_MaskPrint(CON_MASK_PRINT, msg);
 }
 
 /*
 ================
 Con_DPrint
-
-A Con_Print that only shows up if the "developer" cvar is set
 ================
 */
 void Con_DPrint(const char *msg)
 {
-	if (!developer.integer)
-		return;			// don't confuse non-developers with techie stuff...
-	Con_Print(msg);
+	if(developer.integer < 0) // at 0, we still add to the buffer but hide
+		return;
+
+	Con_MaskPrint(CON_MASK_DEVELOPER, msg);
 }
 
 /*
 ================
 Con_DPrintf
-
-A Con_Printf that only shows up if the "developer" cvar is set
 ================
 */
 void Con_DPrintf(const char *fmt, ...)
@@ -1301,14 +1382,14 @@ void Con_DPrintf(const char *fmt, ...)
 	va_list argptr;
 	char msg[MAX_INPUTLINE];
 
-	if (!developer.integer)
-		return;			// don't confuse non-developers with techie stuff...
+	if(developer.integer < 0) // at 0, we still add to the buffer but hide
+		return;
 
 	va_start(argptr,fmt);
 	dpvsnprintf(msg,sizeof(msg),fmt,argptr);
 	va_end(argptr);
 
-	Con_Print(msg);
+	Con_MaskPrint(CON_MASK_DEVELOPER, msg);
 }
 
 
@@ -1329,12 +1410,15 @@ The input line scrolls horizontally if typing goes beyond the right edge
 Modified by EvilTypeGuy eviltypeguy@qeradiant.com
 ================
 */
+extern cvar_t r_font_disable_freetype;
 void Con_DrawInput (void)
 {
 	int		y;
 	int		i;
 	char editlinecopy[MAX_INPUTLINE+1], *text;
-	float x;
+	float x, xo;
+	size_t len_out;
+	int col_out;
 
 	if (!key_consoleactive)
 		return;		// don't draw anything
@@ -1349,22 +1433,68 @@ void Con_DrawInput (void)
 
 	y = (int)strlen(text);
 
-// fill out remainder with spaces
-	for (i = y; i < (int)sizeof(editlinecopy)-1; i++)
-		text[i] = ' ';
+	// append enoug nul-bytes to cover the utf8-versions of the cursor too
+	for (i = y; i < y + 4 && i < (int)sizeof(editlinecopy); ++i)
+		text[i] = 0;
 
 	// add the cursor frame
-	if ((int)(realtime*con_cursorspeed) & 1)		// cursor is visible
-		text[key_linepos] = 11 + 130 * key_insert;	// either solid or triangle facing right
+	if (r_font_disable_freetype.integer)
+	{
+		// this code is freetype incompatible!
+		if ((int)(realtime*con_cursorspeed) & 1)		// cursor is visible
+		{
+			if (!utf8_enable.integer)
+				text[key_linepos] = 11 + 130 * key_insert;	// either solid or triangle facing right
+			else if (y + 3 < (int)sizeof(editlinecopy)-1)
+			{
+				int ofs = u8_bytelen(text + key_linepos, 1);
+				size_t len;
+				const char *curbuf;
+				curbuf = u8_encodech(0xE000 + 11 + 130 * key_insert, &len);
+
+				if (curbuf)
+				{
+					memmove(text + key_linepos + len, text + key_linepos + ofs, sizeof(editlinecopy) - key_linepos - len);
+					memcpy(text + key_linepos, curbuf, len);
+				}
+			} else
+				text[key_linepos] = '-' + ('+' - '-') * key_insert;
+		}
+	}
 
 //	text[key_linepos + 1] = 0;
 
-	x = vid_conwidth.value * 0.95 - DrawQ_TextWidth_Font(text, key_linepos, false, FONT_CONSOLE) * con_textsize.value;
+	len_out = key_linepos;
+	col_out = -1;
+	xo = DrawQ_TextWidth_UntilWidth_TrackColors(text, &len_out, con_textsize.value, con_textsize.value, &col_out, false, FONT_CONSOLE, 1000000000);
+	x = vid_conwidth.value * 0.95 - xo; // scroll
 	if(x >= 0)
 		x = 0;
 
 	// draw it
-	DrawQ_String_Font(x, con_vislines - con_textsize.value*2, text, 0, con_textsize.value, con_textsize.value, 1.0, 1.0, 1.0, 1.0, 0, NULL, false, FONT_CONSOLE );
+	DrawQ_String(x, con_vislines - con_textsize.value*2, text, y + 3, con_textsize.value, con_textsize.value, 1.0, 1.0, 1.0, 1.0, 0, NULL, false, FONT_CONSOLE );
+
+	// add a cursor on top of this (when using freetype)
+	if (!r_font_disable_freetype.integer)
+	{
+		if ((int)(realtime*con_cursorspeed) & 1)		// cursor is visible
+		{
+			if (!utf8_enable.integer)
+			{
+				text[0] = 11 + 130 * key_insert;	// either solid or triangle facing right
+				text[1] = 0;
+			}
+			else
+			{
+				size_t len;
+				const char *curbuf;
+				curbuf = u8_encodech(0xE000 + 11 + 130 * key_insert, &len);
+				memcpy(text, curbuf, len);
+				text[len] = 0;
+			}
+			DrawQ_String(x + xo, con_vislines - con_textsize.value*2, text, 0, con_textsize.value, con_textsize.value, 1.0, 1.0, 1.0, 1.0, 0, &col_out, false, FONT_CONSOLE);
+		}
+	}
 
 	// remove cursor
 //	key_line[key_linepos] = 0;
@@ -1395,9 +1525,9 @@ float Con_WordWidthFunc(void *passthrough, const char *w, size_t *length, float
 		return ti->fontsize * ti->font->maxwidth;
 	}
 	if(maxWidth >= 0)
-		return DrawQ_TextWidth_Font_UntilWidth(w, length, false, ti->font, maxWidth / ti->fontsize) * ti->fontsize;
+		return DrawQ_TextWidth_UntilWidth(w, length, ti->fontsize, ti->fontsize, false, ti->font, -maxWidth); // -maxWidth: we want at least one char
 	else if(maxWidth == -1)
-		return DrawQ_TextWidth_Font(w, *length, false, ti->font) * ti->fontsize;
+		return DrawQ_TextWidth(w, *length, ti->fontsize, ti->fontsize, false, ti->font);
 	else
 	{
 		printf("Con_WordWidthFunc: can't get here (maxWidth should never be %f)\n", maxWidth);
@@ -1428,9 +1558,9 @@ int Con_DisplayLineFunc(void *passthrough, const char *line, size_t length, floa
 	{
 		int x = (int) (ti->x + (ti->width - width) * ti->alignment);
 		if(isContinuation && *ti->continuationString)
-			x += (int) DrawQ_String_Font(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);
+			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);
 		if(length > 0)
-			DrawQ_String_Font(x, ti->y, line, length, ti->fontsize, ti->fontsize, 1.0, 1.0, 1.0, 1.0, 0, &(ti->colorindex), false, ti->font);
+			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);
 	}
 
 	ti->y += ti->fontsize;
@@ -1463,8 +1593,8 @@ int Con_DrawNotifyRect(int mask_must, int mask_mustnot, float maxage, float x, f
 	continuationWidth = (int) Con_WordWidthFunc(&ti, continuationString, &l, -1);
 
 	// first find the first line to draw by backwards iterating and word wrapping to find their length...
-	startidx = con.lines_count;
-	for(i = con.lines_count - 1; i >= 0; --i)
+	startidx = CON_LINES_COUNT;
+	for(i = CON_LINES_COUNT - 1; i >= 0; --i)
 	{
 		con_lineinfo_t *l = &CON_LINES(i);
 		int mylines;
@@ -1495,7 +1625,7 @@ int Con_DrawNotifyRect(int mask_must, int mask_mustnot, float maxage, float x, f
 	ti.y = y + alignment_y * (height - lines * fontsize) - nskip * fontsize;
 
 	// then actually draw
-	for(i = startidx; i < con.lines_count; ++i)
+	for(i = startidx; i < CON_LINES_COUNT; ++i)
 	{
 		con_lineinfo_t *l = &CON_LINES(i);
 
@@ -1521,8 +1651,8 @@ Draws the last few lines of output transparently over the game top
 */
 void Con_DrawNotify (void)
 {
-	float	x, v;
-	float chatstart, notifystart, inputsize;
+	float	x, v, xr;
+	float chatstart, notifystart, inputsize, height;
 	float align;
 	char	temptext[MAX_INPUTLINE];
 	int numChatlines;
@@ -1531,6 +1661,7 @@ void Con_DrawNotify (void)
 	ConBuffer_FixTimes(&con);
 
 	numChatlines = con_chat.integer;
+
 	chatpos = con_chatpos.integer;
 
 	if (con_notify.integer < 0)
@@ -1548,7 +1679,7 @@ void Con_DrawNotify (void)
 			align = 0.5;
 	}
 
-	if(numChatlines)
+	if(numChatlines || !con_chatrect.integer)
 	{
 		if(chatpos == 0)
 		{
@@ -1576,57 +1707,49 @@ void Con_DrawNotify (void)
 		chatstart = 0; // shut off gcc warning
 	}
 
-	v = notifystart + con_notifysize.value * Con_DrawNotifyRect(0, CON_MASK_INPUT | CON_MASK_HIDENOTIFY | (numChatlines ? CON_MASK_CHAT : 0), con_notifytime.value, 0, notifystart, vid_conwidth.value, con_notify.value * con_notifysize.value, con_notifysize.value, align, 0.0, "");
+	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, "");
 
-	// chat?
-	if(numChatlines)
+	if(con_chatrect.integer)
 	{
-		v = chatstart + numChatlines * con_chatsize.value;
-		Con_DrawNotifyRect(CON_MASK_CHAT, CON_MASK_INPUT, con_chattime.value, 0, chatstart, vid_conwidth.value * con_chatwidth.value, v - chatstart, con_chatsize.value, 0.0, 1.0, "^3\014\014\014 "); // 015 is ·> character in conchars.tga
+		x = con_chatrect_x.value * vid_conwidth.value;
+		v = con_chatrect_y.value * vid_conheight.value;
+	}
+	else
+	{
+		x = 0;
+		if(numChatlines) // only do this if chat area is enabled, or this would move the input line wrong
+			v = chatstart;
 	}
+	height = numChatlines * con_chatsize.value;
 
+	if(numChatlines)
+	{
+		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, (utf8_enable.integer ? "^3\xee\x80\x8c\xee\x80\x8c\xee\x80\x8c " : "^3\014\014\014 ")); // 015 is ·> character in conchars.tga
+		v += height;
+	}
 	if (key_dest == key_message)
 	{
+		//static char *cursor[2] = { "\xee\x80\x8a", "\xee\x80\x8b" }; // { off, on }
 		int colorindex = -1;
+		const char *cursor;
+		cursor = u8_encodech(0xE00A + ((int)(realtime * con_cursorspeed)&1), NULL);
 
 		// LordHavoc: speedup, and other improvements
 		if (chat_mode < 0)
-			dpsnprintf(temptext, sizeof(temptext), "]%s%c", chat_buffer, (int) 10+((int)(realtime*con_cursorspeed)&1));
+			dpsnprintf(temptext, sizeof(temptext), "]%s%s", chat_buffer, cursor);
 		else if(chat_mode)
-			dpsnprintf(temptext, sizeof(temptext), "say_team:%s%c", chat_buffer, (int) 10+((int)(realtime*con_cursorspeed)&1));
+			dpsnprintf(temptext, sizeof(temptext), "say_team:%s%s", chat_buffer, cursor);
 		else
-			dpsnprintf(temptext, sizeof(temptext), "say:%s%c", chat_buffer, (int) 10+((int)(realtime*con_cursorspeed)&1));
+			dpsnprintf(temptext, sizeof(temptext), "say:%s%s", chat_buffer, cursor);
 
 		// FIXME word wrap
 		inputsize = (numChatlines ? con_chatsize : con_notifysize).value;
-		x = vid_conwidth.value - DrawQ_TextWidth_Font(temptext, 0, false, FONT_CHAT) * inputsize;
-		if(x > 0)
-			x = 0;
-		DrawQ_String_Font(x, v, temptext, 0, inputsize, inputsize, 1.0, 1.0, 1.0, 1.0, 0, &colorindex, false, FONT_CHAT);
+		xr = vid_conwidth.value - DrawQ_TextWidth(temptext, 0, inputsize, inputsize, false, FONT_CHAT);
+		x = min(xr, x);
+		DrawQ_String(x, v, temptext, 0, inputsize, inputsize, 1.0, 1.0, 1.0, 1.0, 0, &colorindex, false, FONT_CHAT);
 	}
 }
 
-/*
-================
-Con_MeasureConsoleLine
-
-Counts the number of lines for a line on the console.
-================
-*/
-int Con_MeasureConsoleLine(int lineno)
-{
-	float width = vid_conwidth.value;
-	con_text_info_t ti;
-
-	//if(con.lines[lineno].mask & CON_MASK_LOADEDHISTORY)
-	//	return 0;
-
-	ti.fontsize = con_textsize.value;
-	ti.font = FONT_CONSOLE;
-
-	return COM_Wordwrap(con.lines[lineno].start, con.lines[lineno].len, 0, width, Con_WordWidthFunc, &ti, Con_CountLineFunc, NULL);
-}
-
 /*
 ================
 Con_LineHeight
@@ -1634,12 +1757,19 @@ Con_LineHeight
 Returns the height of a given console line; calculates it if necessary.
 ================
 */
-int Con_LineHeight(int i)
+int Con_LineHeight(int lineno)
 {
-	int h = con.lines[i].height;
-	if(h != -1)
-		return h;
-	return con.lines[i].height = Con_MeasureConsoleLine(i);
+	con_lineinfo_t *li = &CON_LINES(lineno);
+	if(li->height == -1)
+	{
+		float width = vid_conwidth.value;
+		con_text_info_t ti;
+		con_lineinfo_t *li = &CON_LINES(lineno);
+		ti.fontsize = con_textsize.value;
+		ti.font = FONT_CONSOLE;
+		li->height = COM_Wordwrap(li->start, li->len, 0, width, Con_WordWidthFunc, &ti, Con_CountLineFunc, NULL);
+	}
+	return li->height;
 }
 
 /*
@@ -1651,13 +1781,16 @@ If alpha is 0, the line is not drawn, but still wrapped and its height
 returned.
 ================
 */
-int Con_DrawConsoleLine(float y, int lineno, float ymin, float ymax)
+int Con_DrawConsoleLine(int mask_must, int mask_mustnot, float y, int lineno, float ymin, float ymax)
 {
 	float width = vid_conwidth.value;
 	con_text_info_t ti;
+	con_lineinfo_t *li = &CON_LINES(lineno);
 
-	//if(con.lines[lineno].mask & CON_MASK_LOADEDHISTORY)
-	//	return 0;
+	if((li->mask & mask_must) != mask_must)
+		return 0;
+	if((li->mask & mask_mustnot) != 0)
+		return 0;
 
 	ti.continuationString = "";
 	ti.alignment = 0;
@@ -1669,7 +1802,7 @@ int Con_DrawConsoleLine(float y, int lineno, float ymin, float ymax)
 	ti.ymax = ymax;
 	ti.width = width;
 
-	return COM_Wordwrap(con.lines[lineno].start, con.lines[lineno].len, 0, width, Con_WordWidthFunc, &ti, Con_DisplayLineFunc, &ti);
+	return COM_Wordwrap(li->start, li->len, 0, width, Con_WordWidthFunc, &ti, Con_DisplayLineFunc, &ti);
 }
 
 /*
@@ -1680,24 +1813,27 @@ Calculates the last visible line index and how much to show of it based on
 con_backscroll.
 ================
 */
-void Con_LastVisibleLine(int *last, int *limitlast)
+static void Con_LastVisibleLine(int mask_must, int mask_mustnot, int *last, int *limitlast)
 {
 	int lines_seen = 0;
-	int ic;
+	int i;
 
 	if(con_backscroll < 0)
 		con_backscroll = 0;
 
+	*last = 0;
+
 	// now count until we saw con_backscroll actual lines
-	for(ic = 0; ic < con.lines_count; ++ic)
+	for(i = CON_LINES_COUNT - 1; i >= 0; --i)
+	if((CON_LINES(i).mask & mask_must) == mask_must)
+	if((CON_LINES(i).mask & mask_mustnot) == 0)
 	{
-		int i = CON_LINES_IDX(con.lines_count - 1 - ic);
 		int h = Con_LineHeight(i);
 
 		// line is the last visible line?
+		*last = i;
 		if(lines_seen + h > con_backscroll && lines_seen <= con_backscroll)
 		{
-			*last = i;
 			*limitlast = lines_seen + h - con_backscroll;
 			return;
 		}
@@ -1708,7 +1844,6 @@ void Con_LastVisibleLine(int *last, int *limitlast)
 	// if we get here, no line was on screen - scroll so that one line is
 	// visible then.
 	con_backscroll = lines_seen - 1;
-	*last = con.lines_first;
 	*limitlast = 1;
 }
 
@@ -1722,43 +1857,121 @@ The typing input line at the bottom should only be drawn if typing is allowed
 */
 void Con_DrawConsole (int lines)
 {
-	int i, last, limitlast;
-	float y;
+	float alpha, alpha0;
+	double sx, sy;
+	int mask_must = 0;
+	int mask_mustnot = (developer.integer>0) ? 0 : CON_MASK_DEVELOPER;
+	cachepic_t *conbackpic;
 
 	if (lines <= 0)
 		return;
 
+	if (con_backscroll < 0)
+		con_backscroll = 0;
+
 	con_vislines = lines;
 
+	r_draw2d_force = true;
+
 // draw the background
-	DrawQ_Pic(0, lines - vid_conheight.integer, scr_conbrightness.value >= 0.01f ? Draw_CachePic ("gfx/conback") : NULL, vid_conwidth.integer, vid_conheight.integer, scr_conbrightness.value, scr_conbrightness.value, scr_conbrightness.value, cls.signon == SIGNONS ? scr_conalpha.value : 1.0, 0); // always full alpha when not in game
-	DrawQ_String_Font(vid_conwidth.integer - DrawQ_TextWidth_Font(engineversion, 0, false, FONT_CONSOLE) * con_textsize.value, lines - con_textsize.value, engineversion, 0, con_textsize.value, con_textsize.value, 1, 0, 0, 1, 0, NULL, true, FONT_CONSOLE);
+	alpha0 = cls.signon == SIGNONS ? scr_conalpha.value : 1.0f; // always full alpha when not in game
+	if((alpha = alpha0 * scr_conalphafactor.value) > 0)
+	{
+		sx = scr_conscroll_x.value;
+		sy = scr_conscroll_y.value;
+		conbackpic = scr_conbrightness.value >= 0.01f ? Draw_CachePic_Flags("gfx/conback", (sx != 0 || sy != 0) ? CACHEPICFLAG_NOCLAMP : 0) : NULL;
+		sx *= realtime; sy *= realtime;
+		sx -= floor(sx); sy -= floor(sy);
+		if (conbackpic && conbackpic->tex != r_texture_notexture)
+			DrawQ_SuperPic(0, lines - vid_conheight.integer, conbackpic, vid_conwidth.integer, vid_conheight.integer,
+					0 + sx, 0 + sy, scr_conbrightness.value, scr_conbrightness.value, scr_conbrightness.value, alpha,
+					1 + sx, 0 + sy, scr_conbrightness.value, scr_conbrightness.value, scr_conbrightness.value, alpha,
+					0 + sx, 1 + sy, scr_conbrightness.value, scr_conbrightness.value, scr_conbrightness.value, alpha,
+					1 + sx, 1 + sy, scr_conbrightness.value, scr_conbrightness.value, scr_conbrightness.value, alpha,
+					0);
+		else
+			DrawQ_Fill(0, lines - vid_conheight.integer, vid_conwidth.integer, vid_conheight.integer, 0.0f, 0.0f, 0.0f, alpha, 0);
+	}
+	if((alpha = alpha0 * scr_conalpha2factor.value) > 0)
+	{
+		sx = scr_conscroll2_x.value;
+		sy = scr_conscroll2_y.value;
+		conbackpic = Draw_CachePic_Flags("gfx/conback2", (sx != 0 || sy != 0) ? CACHEPICFLAG_NOCLAMP : 0);
+		sx *= realtime; sy *= realtime;
+		sx -= floor(sx); sy -= floor(sy);
+		if(conbackpic && conbackpic->tex != r_texture_notexture)
+			DrawQ_SuperPic(0, lines - vid_conheight.integer, conbackpic, vid_conwidth.integer, vid_conheight.integer,
+					0 + sx, 0 + sy, scr_conbrightness.value, scr_conbrightness.value, scr_conbrightness.value, alpha,
+					1 + sx, 0 + sy, scr_conbrightness.value, scr_conbrightness.value, scr_conbrightness.value, alpha,
+					0 + sx, 1 + sy, scr_conbrightness.value, scr_conbrightness.value, scr_conbrightness.value, alpha,
+					1 + sx, 1 + sy, scr_conbrightness.value, scr_conbrightness.value, scr_conbrightness.value, alpha,
+					0);
+	}
+	if((alpha = alpha0 * scr_conalpha3factor.value) > 0)
+	{
+		sx = scr_conscroll3_x.value;
+		sy = scr_conscroll3_y.value;
+		conbackpic = Draw_CachePic_Flags("gfx/conback3", (sx != 0 || sy != 0) ? CACHEPICFLAG_NOCLAMP : 0);
+		sx *= realtime; sy *= realtime;
+		sx -= floor(sx); sy -= floor(sy);
+		if(conbackpic && conbackpic->tex != r_texture_notexture)
+			DrawQ_SuperPic(0, lines - vid_conheight.integer, conbackpic, vid_conwidth.integer, vid_conheight.integer,
+					0 + sx, 0 + sy, scr_conbrightness.value, scr_conbrightness.value, scr_conbrightness.value, alpha,
+					1 + sx, 0 + sy, scr_conbrightness.value, scr_conbrightness.value, scr_conbrightness.value, alpha,
+					0 + sx, 1 + sy, scr_conbrightness.value, scr_conbrightness.value, scr_conbrightness.value, alpha,
+					1 + sx, 1 + sy, scr_conbrightness.value, scr_conbrightness.value, scr_conbrightness.value, alpha,
+					0);
+	}
+	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);
 
 // draw the text
-	if(con.lines_count > 0)
+#if 0
 	{
+		int i;
+		int count = CON_LINES_COUNT;
 		float ymax = con_vislines - 2 * con_textsize.value;
-		Con_LastVisibleLine(&last, &limitlast);
+		float y = ymax + con_textsize.value * con_backscroll;
+		for (i = 0;i < count && y >= 0;i++)
+			y -= Con_DrawConsoleLine(mask_must, mask_mustnot, y - con_textsize.value, CON_LINES_COUNT - 1 - i, 0, ymax) * con_textsize.value;
+		// fix any excessive scrollback for the next frame
+		if (i >= count && y >= 0)
+		{
+			con_backscroll -= (int)(y / con_textsize.value);
+			if (con_backscroll < 0)
+				con_backscroll = 0;
+		}
+	}
+#else
+	if(CON_LINES_COUNT > 0)
+	{
+		int i, last, limitlast;
+		float y;
+		float ymax = con_vislines - 2 * con_textsize.value;
+		Con_LastVisibleLine(mask_must, mask_mustnot, &last, &limitlast);
+		//Con_LastVisibleLine(mask_must, mask_mustnot, &last, &limitlast);
 		y = ymax - con_textsize.value;
 
 		if(limitlast)
-			y += (con.lines[last].height - limitlast) * con_textsize.value;
+			y += (CON_LINES(last).height - limitlast) * con_textsize.value;
 		i = last;
 
 		for(;;)
 		{
-			y -= Con_DrawConsoleLine(y, i, 0, ymax) * con_textsize.value;
-			if(i == con.lines_first)
+			y -= Con_DrawConsoleLine(mask_must, mask_mustnot, y, i, 0, ymax) * con_textsize.value;
+			if(i == 0)
 				break; // top of console buffer
 			if(y < 0)
 				break; // top of console window
 			limitlast = 0;
-			i = CON_LINES_PRED(i);
+			--i;
 		}
 	}
+#endif
 
 // draw the input prompt, user text, and cursor if desired
 	Con_DrawInput ();
+
+	r_draw2d_force = false;
 }
 
 /*
@@ -1831,7 +2044,7 @@ qboolean GetMapList (const char *s, char *completedname, int completednamebuffer
 					lumplen = LittleLong(header->lumps[Q2LUMP_ENTITIES].filelen);
 				}
 			}
-			else if((p = LittleLong(((int *)buf)[0])) == BSPVERSION || p == 30)
+			else if((p = BuffLittleLong(buf)) == BSPVERSION || p == 30)
 			{
 				dheader_t *header = (dheader_t *)buf;
 				lumpofs = LittleLong(header->lumps[LUMP_ENTITIES].fileofs);
@@ -1870,8 +2083,8 @@ qboolean GetMapList (const char *s, char *completedname, int completednamebuffer
 					keyname[l] = 0;
 					if (!COM_ParseToken_Simple(&data, false, false))
 						break;
-					if (developer.integer >= 100)
-						Con_Printf("key: %s %s\n", keyname, com_token);
+					if (developer_extra.integer)
+						Con_DPrintf("key: %s %s\n", keyname, com_token);
 					if (!strcmp(keyname, "message"))
 					{
 						// get the message contents
@@ -2097,7 +2310,6 @@ int Nicks_CompleteCountPossible(char *line, int pos, char *s, qboolean isCon)
 {
 	char name[128];
 	int i, p;
-	int length;
 	int match;
 	int spos;
 	int count = 0;
@@ -2121,7 +2333,6 @@ int Nicks_CompleteCountPossible(char *line, int pos, char *s, qboolean isCon)
 		if(!name[0])
 			continue;
 
-		length = strlen(name);
 		match = -1;
 		spos = pos - 1; // no need for a minimum of characters :)
 
@@ -2679,7 +2890,7 @@ void Con_CompleteCommandLine (void)
 	a = Cmd_CompleteAliasCountPossible(s);
 	if (a)
 	{
-		Con_Printf("\n%i possible aliases%s\n", a, (a > 1) ? "s: " : ":");
+		Con_Printf("\n%i possible alias%s\n", a, (a > 1) ? "es: " : ":");
 		Cmd_CompleteAliasPrint(s);
 	}
 	n = Nicks_CompleteCountPossible(key_line, key_linepos, s, true);