X-Git-Url: http://de.git.xonotic.org/?a=blobdiff_plain;ds=sidebyside;f=console.c;h=ae73809b9d8decedd2274775a520f37f270a88bb;hb=294762940c3d8fb26989ce5fa0f8d2588d5e5a2e;hp=6087f169124397d64fff298abc8f2d525d7d43a9;hpb=fd9860c8c2d7ff69fe2e49958e93cc9ed6c179ac;p=xonotic%2Fdarkplaces.git

diff --git a/console.c b/console.c
index 6087f169..ae73809b 100644
--- a/console.c
+++ b/console.c
@@ -19,47 +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	131072
-#define		CON_MAXLINES	  4096
+// for u8_encodech
+#include "ft2.h"
+
+float con_cursorspeed = 4;
 
 // lines up from bottom to display
 int con_backscroll;
 
-// console buffer
-char con_text[CON_TEXTSIZE];
-
-#define CON_MASK_HIDENOTIFY 128
-#define CON_MASK_CHAT 1
-
-typedef struct
-{
-	char *start;
-	int len;
-
-	double addtime;
-	int mask;
-
-	int height; // recalculated line height when needed (-1 to unset)
-}
-con_lineinfo;
-con_lineinfo con_lines[CON_MAXLINES];
+conbuffer_t con;
 
-int con_lines_first; // cyclic buffer
-int con_lines_count;
-#define CON_LINES_IDX(i) ((con_lines_first + (i)) % CON_MAXLINES)
-#define CON_LINES_LAST CON_LINES_IDX(con_lines_count - 1)
-#define CON_LINES(i) con_lines[CON_LINES_IDX(i)]
-#define CON_LINES_PRED(i) (((i) + CON_MAXLINES - 1) % CON_MAXLINES)
-#define CON_LINES_SUCC(i) (((i) + 1) % CON_MAXLINES)
+#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"};
@@ -68,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)"};
@@ -96,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;
@@ -110,7 +93,226 @@ 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 = (char *) Mem_Alloc(mempool, textsize);
+	buf->maxlines = maxlines;
+	buf->lines = (con_lineinfo_t *) Mem_Alloc(mempool, maxlines * sizeof(*buf->lines));
+	buf->lines_first = 0;
+	buf->lines_count = 0;
+}
+
+/*
+================
+ConBuffer_Clear
+================
+*/
+void ConBuffer_Clear (conbuffer_t *buf)
+{
+	buf->lines_count = 0;
+}
+
+/*
+================
+ConBuffer_Shutdown
+================
+*/
+void ConBuffer_Shutdown(conbuffer_t *buf)
+{
+	buf->active = false;
+	if (buf->text)
+		Mem_Free(buf->text);
+	if (buf->lines)
+		Mem_Free(buf->lines);
+	buf->text = NULL;
+	buf->lines = NULL;
+}
+
+/*
+================
+ConBuffer_FixTimes
+
+Notifies the console code about the current time
+(and shifts back times of other entries when the time
+went backwards)
+================
+*/
+void ConBuffer_FixTimes(conbuffer_t *buf)
+{
+	int i;
+	if(buf->lines_count >= 1)
+	{
+		double diff = cl.time - CONBUFFER_LINES_LAST(buf).addtime;
+		if(diff < 0)
+		{
+			for(i = 0; i < buf->lines_count; ++i)
+				CONBUFFER_LINES(buf, i).addtime += diff;
+		}
+	}
+}
+
+/*
+================
+ConBuffer_DeleteLine
+
+Deletes the first line from the console history.
+================
+*/
+void ConBuffer_DeleteLine(conbuffer_t *buf)
+{
+	if(buf->lines_count == 0)
+		return;
+	--buf->lines_count;
+	buf->lines_first = (buf->lines_first + 1) % buf->maxlines;
+}
+
+/*
+================
+ConBuffer_DeleteLastLine
+
+Deletes the last line from the console history.
+================
+*/
+void ConBuffer_DeleteLastLine(conbuffer_t *buf)
+{
+	if(buf->lines_count == 0)
+		return;
+	--buf->lines_count;
+}
+
+/*
+================
+ConBuffer_BytesLeft
+
+Checks if there is space for a line of the given length, and if yes, returns a
+pointer to the start of such a space, and NULL otherwise.
+================
+*/
+static char *ConBuffer_BytesLeft(conbuffer_t *buf, int len)
+{
+	if(len > buf->textsize)
+		return NULL;
+	if(buf->lines_count == 0)
+		return buf->text;
+	else
+	{
+		char *firstline_start = buf->lines[buf->lines_first].start;
+		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
+		{
+			// put at end?
+			if(len <= buf->text + buf->textsize - lastline_onepastend)
+				return lastline_onepastend;
+			// put at beginning?
+			else if(len <= firstline_start - buf->text)
+				return buf->text;
+			else
+				return NULL;
+		}
+		else // buffer has a contiguous hole
+		{
+			if(len <= firstline_start - lastline_onepastend)
+				return lastline_onepastend;
+			else
+				return NULL;
+		}
+	}
+}
 
+/*
+================
+ConBuffer_AddLine
+
+Appends a given string as a new line to the console.
+================
+*/
+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)
+	{
+		// line too large?
+		// only display end of line.
+		line += len - buf->textsize + 1;
+		len = buf->textsize - 1;
+	}
+	while(!(putpos = ConBuffer_BytesLeft(buf, len + 1)) || buf->lines_count >= buf->maxlines)
+		ConBuffer_DeleteLine(buf);
+	memcpy(putpos, line, len);
+	putpos[len] = 0;
+	++buf->lines_count;
+
+	//fprintf(stderr, "Now have %d lines (%d -> %d).\n", buf->lines_count, buf->lines_first, CON_LINES_LAST);
+
+	p = &CONBUFFER_LINES_LAST(buf);
+	p->start = putpos;
+	p->len = len;
+	p->addtime = cl.time;
+	p->mask = mask;
+	p->height = -1; // calculate when needed
+}
+
+int ConBuffer_FindPrevLine(conbuffer_t *buf, int mask_must, int mask_mustnot, int start)
+{
+	int i;
+	if(start == -1)
+		start = buf->lines_count;
+	for(i = start - 1; i >= 0; --i)
+	{
+		con_lineinfo_t *l = &CONBUFFER_LINES(buf, i);
+
+		if((l->mask & mask_must) != mask_must)
+			continue;
+		if(l->mask & mask_mustnot)
+			continue;
+
+		return i;
+	}
+
+	return -1;
+}
+
+int Con_FindNextLine(conbuffer_t *buf, int mask_must, int mask_mustnot, int start)
+{
+	int i;
+	for(i = start + 1; i < buf->lines_count; ++i)
+	{
+		con_lineinfo_t *l = &CONBUFFER_LINES(buf, i);
+
+		if((l->mask & mask_must) != mask_must)
+			continue;
+		if(l->mask & mask_mustnot)
+			continue;
+
+		return i;
+	}
+
+	return -1;
+}
+
+const char *ConBuffer_GetLine(conbuffer_t *buf, int i)
+{
+	static char copybuf[MAX_INPUTLINE];
+	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;
+}
 
 /*
 ==============================================================================
@@ -120,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
@@ -133,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;
@@ -150,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;
@@ -397,28 +601,15 @@ void Con_ToggleConsole_f (void)
 	Con_ClearNotify();
 }
 
-/*
-================
-Con_Clear_f
-================
-*/
-void Con_Clear_f (void)
-{
-	con_lines_count = 0;
-}
-
-
 /*
 ================
 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;
 }
 
@@ -432,6 +623,8 @@ void Con_MessageMode_f (void)
 {
 	key_dest = key_message;
 	chat_mode = 0; // "say"
+	chat_bufferlen = 0;
+	chat_buffer[0] = 0;
 }
 
 
@@ -444,6 +637,8 @@ void Con_MessageMode2_f (void)
 {
 	key_dest = key_message;
 	chat_mode = 1; // "say_team"
+	chat_bufferlen = 0;
+	chat_buffer[0] = 0;
 }
 
 /*
@@ -465,8 +660,6 @@ void Con_CommandMode_f (void)
 /*
 ================
 Con_CheckResize
-
-If the line width has changed, reformat the buffer.
 ================
 */
 void Con_CheckResize (void)
@@ -478,14 +671,15 @@ void Con_CheckResize (void)
 	if(f != con_textsize.value)
 		Cvar_SetValueQuick(&con_textsize, f);
 	width = (int)floor(vid_conwidth.value / con_textsize.value);
-	width = bound(1, width, CON_TEXTSIZE/4);
+	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();
@@ -522,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);
@@ -530,6 +724,11 @@ void Con_ConDump_f (void)
 	FS_Close(file);
 }
 
+void Con_Clear_f (void)
+{
+	ConBuffer_Clear(&con);
+}
+
 /*
 ================
 Con_Init
@@ -538,8 +737,7 @@ Con_Init
 void Con_Init (void)
 {
 	con_linewidth = 80;
-	con_lines_first = 0;
-	con_lines_count = 0;
+	ConBuffer_Init(&con, CON_TEXTSIZE, CON_MAXLINES, zonemempool);
 
 	// Allocate a log queue, this will be freed after configs are parsed
 	logq_size = MAX_INPUTLINE;
@@ -560,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);
@@ -568,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);
@@ -590,134 +792,9 @@ void Con_Init (void)
 	Con_DPrint("Console initialized.\n");
 }
 
-
-/*
-================
-Con_DeleteLine
-
-Deletes the first line from the console history.
-================
-*/
-void Con_DeleteLine()
-{
-	if(con_lines_count == 0)
-		return;
-	--con_lines_count;
-	con_lines_first = CON_LINES_IDX(1);
-}
-
-/*
-================
-Con_DeleteLastLine
-
-Deletes the last line from the console history.
-================
-*/
-void Con_DeleteLastLine()
-{
-	if(con_lines_count == 0)
-		return;
-	--con_lines_count;
-}
-
-/*
-================
-Con_BytesLeft
-
-Checks if there is space for a line of the given length, and if yes, returns a
-pointer to the start of such a space, and NULL otherwise.
-================
-*/
-char *Con_BytesLeft(int len)
-{
-	if(len > CON_TEXTSIZE)
-		return NULL;
-	if(con_lines_count == 0)
-		return con_text;
-	else
-	{
-		char *firstline_start = con_lines[con_lines_first].start;
-		char *lastline_onepastend = con_lines[CON_LINES_LAST].start + con_lines[CON_LINES_LAST].len;
-		// the buffer is cyclic, so we first have two cases...
-		if(firstline_start < lastline_onepastend) // buffer is contiguous
-		{
-			// put at end?
-			if(len <= con_text + CON_TEXTSIZE - lastline_onepastend)
-				return lastline_onepastend;
-			// put at beginning?
-			else if(len <= firstline_start - con_text)
-				return con_text;
-			else
-				return NULL;
-		}
-		else // buffer has a contiguous hole
-		{
-			if(len <= firstline_start - lastline_onepastend)
-				return lastline_onepastend;
-			else
-				return NULL;
-		}
-	}
-}
-
-/*
-================
-Con_FixTimes
-
-Notifies the console code about the current time
-(and shifts back times of other entries when the time
-went backwards)
-================
-*/
-void Con_FixTimes()
-{
-	int i;
-	if(con_lines_count >= 1)
-	{
-		double diff = cl.time - (con_lines + CON_LINES_LAST)->addtime;
-		if(diff < 0)
-		{
-			for(i = 0; i < con_lines_count; ++i)
-				CON_LINES(i).addtime += diff;
-		}
-	}
-}
-
-/*
-================
-Con_AddLine
-
-Appends a given string as a new line to the console.
-================
-*/
-void Con_AddLine(const char *line, int len, int mask)
+void Con_Shutdown (void)
 {
-	char *putpos;
-	con_lineinfo *p;
-
-	Con_FixTimes();
-
-	if(len >= CON_TEXTSIZE)
-	{
-		// line too large?
-		// only display end of line.
-		line += len - CON_TEXTSIZE + 1;
-		len = CON_TEXTSIZE - 1;
-	}
-	while(!(putpos = Con_BytesLeft(len + 1)) || con_lines_count >= CON_MAXLINES)
-		Con_DeleteLine();
-	memcpy(putpos, line, len);
-	putpos[len] = 0;
-	++con_lines_count;
-
-	//fprintf(stderr, "Now have %d lines (%d -> %d).\n", con_lines_count, con_lines_first, CON_LINES_LAST);
-
-	p = con_lines + CON_LINES_LAST;
-	p->start = putpos;
-	p->len = len;
-	p->addtime = cl.time;
-	p->mask = mask;
-	p->height = -1; // calculate when needed
+	ConBuffer_Shutdown(&con);
 }
 
 /*
@@ -739,11 +816,14 @@ 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)
 		{
-			Con_DeleteLastLine();
+			ConBuffer_DeleteLastLine(&con);
 			cr_pending = 0;
 		}
 		switch(*txt)
@@ -751,19 +831,19 @@ void Con_PrintToHistory(const char *txt, int mask)
 			case 0:
 				break;
 			case '\r':
-				Con_AddLine(buf, bufpos, mask);
+				ConBuffer_AddLine(&con, buf, bufpos, mask);
 				bufpos = 0;
 				cr_pending = 1;
 				break;
 			case '\n':
-				Con_AddLine(buf, bufpos, mask);
+				ConBuffer_AddLine(&con, buf, bufpos, mask);
 				bufpos = 0;
 				break;
 			default:
 				buf[bufpos++] = *txt;
-				if(bufpos >= CON_TEXTSIZE - 1)
+				if(bufpos >= con.textsize - 1) // FIXME uses a non-abstracted property of con
 				{
-					Con_AddLine(buf, bufpos, mask);
+					ConBuffer_AddLine(&con, buf, bufpos, mask);
 					bufpos = 0;
 				}
 				break;
@@ -771,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,   '.',  '.',
@@ -808,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] = (char)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;
@@ -840,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)
@@ -938,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;
@@ -971,19 +1066,22 @@ void Con_Print(const char *msg)
 				// play talk wav
 				if (*msg == 1)
 				{
-					if(gamemode == GAME_NEXUIZ)
-					{
-						if(msg[1] == '\r' && cl.foundtalk2wav)
-							S_LocalSound ("sound/misc/talk2.wav");
-						else
-							S_LocalSound ("sound/misc/talk.wav");
-					}
-					else
+					if (con_chatsound.value)
 					{
-						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;
 				}
@@ -996,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;
@@ -1010,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
@@ -1197,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_Print
+================
+*/
+void Con_Print(const char *msg)
+{
+	Con_MaskPrint(CON_MASK_PRINT, msg);
+}
 
 /*
 ================
 Con_Printf
-
-Prints to all appropriate console targets
 ================
 */
 void Con_Printf(const char *fmt, ...)
@@ -1218,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, ...)
@@ -1247,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);
 }
 
 
@@ -1275,17 +1410,20 @@ 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
 
-	strlcpy(editlinecopy, key_lines[edit_line], sizeof(editlinecopy));
+	strlcpy(editlinecopy, key_line, sizeof(editlinecopy));
 	text = editlinecopy;
 
 	// Advanced Console Editing by Radix radix@planetquake.com
@@ -1295,25 +1433,71 @@ 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_lines[edit_line][key_linepos] = 0;
+//	key_line[key_linepos] = 0;
 }
 
 typedef struct
@@ -1341,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);
@@ -1374,16 +1558,15 @@ 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;
 	return 1;
 }
 
-
 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)
 {
 	int i;
@@ -1410,10 +1593,10 @@ 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 *l = &CON_LINES(i);
+		con_lineinfo_t *l = &CON_LINES(i);
 		int mylines;
 
 		if((l->mask & mask_must) != mask_must)
@@ -1442,9 +1625,9 @@ 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 *l = &CON_LINES(i);
+		con_lineinfo_t *l = &CON_LINES(i);
 
 		if((l->mask & mask_must) != mask_must)
 			continue;
@@ -1468,16 +1651,17 @@ 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;
 	int chatpos;
 
-	Con_FixTimes();
+	ConBuffer_FixTimes(&con);
 
 	numChatlines = con_chat.integer;
+
 	chatpos = con_chatpos.integer;
 
 	if (con_notify.integer < 0)
@@ -1495,7 +1679,7 @@ void Con_DrawNotify (void)
 			align = 0.5;
 	}
 
-	if(numChatlines)
+	if(numChatlines || !con_chatrect.integer)
 	{
 		if(chatpos == 0)
 		{
@@ -1523,53 +1707,49 @@ void Con_DrawNotify (void)
 		chatstart = 0; // shut off gcc warning
 	}
 
-	v = notifystart + con_notifysize.value * Con_DrawNotifyRect(0, 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)
+	{
+		x = con_chatrect_x.value * vid_conwidth.value;
+		v = con_chatrect_y.value * vid_conheight.value;
+	}
+	else
 	{
-		v = chatstart + numChatlines * con_chatsize.value;
-		Con_DrawNotifyRect(CON_MASK_CHAT, 0, 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 = 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;
-	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
@@ -1577,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;
 }
 
 /*
@@ -1594,11 +1781,17 @@ 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((li->mask & mask_must) != mask_must)
+		return 0;
+	if((li->mask & mask_mustnot) != 0)
+		return 0;
+
 	ti.continuationString = "";
 	ti.alignment = 0;
 	ti.fontsize = con_textsize.value;
@@ -1609,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);
 }
 
 /*
@@ -1620,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;
 		}
@@ -1648,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;
 }
 
@@ -1662,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;
+		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(&last, &limitlast);
+		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;
 }
 
 /*
@@ -1771,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);
@@ -1810,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
@@ -2037,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;
@@ -2061,11 +2333,10 @@ 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 :)
 
-		while(spos >= 0 && (spos - pos) < length) // search-string-length < name length
+		while(spos >= 0)
 		{
 			if(spos > 0 && line[spos-1] != ' ' && line[spos-1] != ';' && line[spos-1] != '\"' && line[spos-1] != '\'')
 			{
@@ -2334,32 +2605,22 @@ int Nicks_AddLastColor(char *buffer, int pos)
 		}
 		if(!quote_added)
 		{
-			if( buffer[pos-2] == STRING_COLOR_TAG && isdigit(buffer[pos-1]) ) // when thes use &4
-			{
+			if( pos >= 2 && buffer[pos-2] == STRING_COLOR_TAG && isdigit(buffer[pos-1]) ) // when thes use &4
 				pos -= 2;
-			}
-			else if( pos >= 5 && buffer[pos-5] == STRING_COLOR_TAG && buffer[pos-4] == STRING_COLOR_RGB_TAG_CHAR)
-			{
-				if ( isxdigit(buffer[pos-3]) && isxdigit(buffer[pos-2]) && isxdigit(buffer[pos-1]) )
-				{
-					pos -= 5;
-					color = -1;
-				}
-			}
+			else if( pos >= 5 && buffer[pos-5] == STRING_COLOR_TAG && buffer[pos-4] == STRING_COLOR_RGB_TAG_CHAR
+					 && isxdigit(buffer[pos-3]) && isxdigit(buffer[pos-2]) && isxdigit(buffer[pos-1]) )
+				pos -= 5;
 		}
+		buffer[pos++] = STRING_COLOR_TAG;
 		if (color == -1)
 		{
-			buffer[pos++] = STRING_COLOR_TAG;
 			buffer[pos++] = STRING_COLOR_RGB_TAG_CHAR;
 			buffer[pos++] = r;
 			buffer[pos++] = g;
 			buffer[pos++] = b;
 		}
 		else
-		{
-			buffer[pos++] = STRING_COLOR_TAG;
 			buffer[pos++] = color;
-		}
 	}
 	return pos;
 }
@@ -2387,7 +2648,7 @@ int Nicks_CompleteChatLine(char *buffer, size_t size, unsigned int pos)
 	{
 		int len;
 		char *msg;
-		Con_Printf("\n%i possible nick%s\n", n, (n > 1) ? "s: " : ":");
+		Con_Printf("\n%i possible nicks:\n", n);
 		Cmd_CompleteNicksPrint(n);
 
 		Nicks_CutMatches(n);
@@ -2428,20 +2689,20 @@ void Con_CompleteCommandLine (void)
 	pos = key_linepos;
 	while(--pos)
 	{
-		k = key_lines[edit_line][pos];
+		k = key_line[pos];
 		if(k == '\"' || k == ';' || k == ' ' || k == '\'')
 			break;
 	}
 	pos++;
 
-	s = key_lines[edit_line] + pos;
-	strlcpy(s2, key_lines[edit_line] + key_linepos, sizeof(s2));	//save chars after cursor
-	key_lines[edit_line][key_linepos] = 0;					//hide them
+	s = key_line + pos;
+	strlcpy(s2, key_line + key_linepos, sizeof(s2));	//save chars after cursor
+	key_line[key_linepos] = 0;					//hide them
 
-	space = strchr(key_lines[edit_line] + 1, ' ');
-	if(space && pos == (space - key_lines[edit_line]) + 1)
+	space = strchr(key_line + 1, ' ');
+	if(space && pos == (space - key_line) + 1)
 	{
-		strlcpy(command, key_lines[edit_line] + 1, min(sizeof(command), (unsigned int)(space - key_lines[edit_line])));
+		strlcpy(command, key_line + 1, min(sizeof(command), (unsigned int)(space - key_line)));
 
 		patterns = Cvar_VariableString(va("con_completion_%s", command)); // TODO maybe use a better place for this?
 		if(patterns && !*patterns)
@@ -2458,12 +2719,12 @@ void Con_CompleteCommandLine (void)
 
 				// and now do the actual work
 				*s = 0;
-				strlcat(key_lines[edit_line], t, MAX_INPUTLINE);
-				strlcat(key_lines[edit_line], s2, MAX_INPUTLINE); //add back chars after cursor
+				strlcat(key_line, t, MAX_INPUTLINE);
+				strlcat(key_line, s2, MAX_INPUTLINE); //add back chars after cursor
 
 				// and fix the cursor
-				if(key_linepos > (int) strlen(key_lines[edit_line]))
-					key_linepos = (int) strlen(key_lines[edit_line]);
+				if(key_linepos > (int) strlen(key_line))
+					key_linepos = (int) strlen(key_line);
 			}
 			return;
 		}
@@ -2565,7 +2826,7 @@ void Con_CompleteCommandLine (void)
 						Con_Printf("\n%i possible filenames\n", resultbuf.numstrings + dirbuf.numstrings);
 						for(i = 0; i < dirbuf.numstrings; ++i)
 						{
-							Con_Printf("%s/\n", dirbuf.strings[i]);
+							Con_Printf("^4%s^7/\n", dirbuf.strings[i]);
 						}
 						for(i = 0; i < resultbuf.numstrings; ++i)
 						{
@@ -2598,12 +2859,12 @@ void Con_CompleteCommandLine (void)
 
 					// and now do the actual work
 					*s = 0;
-					strlcat(key_lines[edit_line], t, MAX_INPUTLINE);
-					strlcat(key_lines[edit_line], s2, MAX_INPUTLINE); //add back chars after cursor
+					strlcat(key_line, t, MAX_INPUTLINE);
+					strlcat(key_line, s2, MAX_INPUTLINE); //add back chars after cursor
 
 					// and fix the cursor
-					if(key_linepos > (int) strlen(key_lines[edit_line]))
-						key_linepos = (int) strlen(key_lines[edit_line]);
+					if(key_linepos > (int) strlen(key_line))
+						key_linepos = (int) strlen(key_line);
 				}
 				stringlistfreecontents(&resultbuf);
 				stringlistfreecontents(&dirbuf);
@@ -2629,10 +2890,10 @@ 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_lines[edit_line], key_linepos, s, true);
+	n = Nicks_CompleteCountPossible(key_line, key_linepos, s, true);
 	if (n)
 	{
 		Con_Printf("\n%i possible nick%s\n", n, (n > 1) ? "s: " : ":");
@@ -2642,7 +2903,7 @@ void Con_CompleteCommandLine (void)
 	if (!(c + v + a + n))	// No possible matches
 	{
 		if(s2[0])
-			strlcpy(&key_lines[edit_line][key_linepos], s2, sizeof(key_lines[edit_line]) - key_linepos);
+			strlcpy(&key_line[key_linepos], s2, sizeof(key_line) - key_linepos);
 		return;
 	}
 
@@ -2674,33 +2935,33 @@ void Con_CompleteCommandLine (void)
 done:
 
 	// prevent a buffer overrun by limiting cmd_len according to remaining space
-	cmd_len = min(cmd_len, (int)sizeof(key_lines[edit_line]) - 1 - pos);
+	cmd_len = min(cmd_len, (int)sizeof(key_line) - 1 - pos);
 	if (cmd)
 	{
 		key_linepos = pos;
-		memcpy(&key_lines[edit_line][key_linepos], cmd, cmd_len);
+		memcpy(&key_line[key_linepos], cmd, cmd_len);
 		key_linepos += cmd_len;
 		// if there is only one match, add a space after it
-		if (c + v + a + n == 1 && key_linepos < (int)sizeof(key_lines[edit_line]) - 1)
+		if (c + v + a + n == 1 && key_linepos < (int)sizeof(key_line) - 1)
 		{
 			if(n)
 			{ // was a nick, might have an offset, and needs colors ;) --blub
 				key_linepos = pos - Nicks_offset[0];
 				cmd_len = strlen(Nicks_list[0]);
-				cmd_len = min(cmd_len, (int)sizeof(key_lines[edit_line]) - 3 - pos);
+				cmd_len = min(cmd_len, (int)sizeof(key_line) - 3 - pos);
 
-				memcpy(&key_lines[edit_line][key_linepos] , Nicks_list[0], cmd_len);
+				memcpy(&key_line[key_linepos] , Nicks_list[0], cmd_len);
 				key_linepos += cmd_len;
-				if(key_linepos < (int)(sizeof(key_lines[edit_line])-4)) // space for ^, X and space and \0
-					key_linepos = Nicks_AddLastColor(key_lines[edit_line], key_linepos);
+				if(key_linepos < (int)(sizeof(key_line)-4)) // space for ^, X and space and \0
+					key_linepos = Nicks_AddLastColor(key_line, key_linepos);
 			}
-			key_lines[edit_line][key_linepos++] = ' ';
+			key_line[key_linepos++] = ' ';
 		}
 	}
 
 	// use strlcat to avoid a buffer overrun
-	key_lines[edit_line][key_linepos] = 0;
-	strlcat(key_lines[edit_line], s2, sizeof(key_lines[edit_line]));
+	key_line[key_linepos] = 0;
+	strlcat(key_line, s2, sizeof(key_line));
 
 	// free the command, cvar, and alias lists
 	for (i = 0; i < 4; i++)