X-Git-Url: http://de.git.xonotic.org/?p=xonotic%2Fdarkplaces.git;a=blobdiff_plain;f=console.c;h=ae73809b9d8decedd2274775a520f37f270a88bb;hp=12df5d1adb31790f2b096855797522be6a2f6a6e;hb=294762940c3d8fb26989ce5fa0f8d2588d5e5a2e;hpb=c72641f5e795ed0e0d58a38d79860cc92597e4da

diff --git a/console.c b/console.c
index 12df5d1a..ae73809b 100644
--- a/console.c
+++ b/console.c
@@ -19,17 +19,17 @@ 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;
@@ -47,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)"};
@@ -89,11 +93,13 @@ 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;
@@ -119,8 +125,11 @@ 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;
 }
@@ -229,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)
@@ -330,7 +343,7 @@ 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;
@@ -341,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;
@@ -711,7 +724,7 @@ void Con_ConDump_f (void)
 	FS_Close(file);
 }
 
-void Con_Clear_f ()
+void Con_Clear_f (void)
 {
 	ConBuffer_Clear(&con);
 }
@@ -745,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);
@@ -753,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);
@@ -871,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;
@@ -1000,13 +1035,13 @@ static char Sys_Con_NearestColor(const unsigned char _r, const unsigned char _g,
 
 /*
 ================
-Con_Print
+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;
@@ -1031,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;
 				}
@@ -1056,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;
@@ -1070,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
@@ -1257,10 +1310,37 @@ 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);
+}
 
 /*
 ================
@@ -1276,7 +1356,7 @@ void Con_Printf(const char *fmt, ...)
 	dpvsnprintf(msg,sizeof(msg),fmt,argptr);
 	va_end(argptr);
 
-	Con_Print(msg);
+	Con_MaskPrint(CON_MASK_PRINT, msg);
 }
 
 /*
@@ -1286,9 +1366,10 @@ Con_DPrint
 */
 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);
 }
 
 /*
@@ -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;
@@ -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,58 +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;
-	con_lineinfo_t *li = &CON_LINES(lineno);
-
-	//if(con.lines[lineno].mask & CON_MASK_LOADEDHISTORY)
-	//	return 0;
-
-	ti.fontsize = con_textsize.value;
-	ti.font = FONT_CONSOLE;
-
-	return COM_Wordwrap(li->start, li->len, 0, width, Con_WordWidthFunc, &ti, Con_CountLineFunc, NULL);
-}
-
 /*
 ================
 Con_LineHeight
@@ -1635,13 +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)
 {
-	con_lineinfo_t *li = &CON_LINES(i);
-	int h = li->height;
-	if(h != -1)
-		return h;
-	return li->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;
 }
 
 /*
@@ -1653,14 +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;
@@ -1683,7 +1813,7 @@ 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 i;
@@ -1691,15 +1821,19 @@ void Con_LastVisibleLine(int *last, int *limitlast)
 	if(con_backscroll < 0)
 		con_backscroll = 0;
 
+	*last = 0;
+
 	// now count until we saw con_backscroll actual lines
 	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 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;
 		}
@@ -1710,8 +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;
-		// FIXME uses con in a non abstracted way
 	*limitlast = 1;
 }
 
@@ -1725,33 +1857,107 @@ 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 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;
-				// FIXME uses con in a non abstracted way
 		i = last;
 
 		for(;;)
 		{
-			y -= Con_DrawConsoleLine(y, i, 0, ymax) * con_textsize.value;
+			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)
@@ -1760,9 +1966,12 @@ void Con_DrawConsole (int lines)
 			--i;
 		}
 	}
+#endif
 
 // draw the input prompt, user text, and cursor if desired
 	Con_DrawInput ();
+
+	r_draw2d_force = false;
 }
 
 /*
@@ -1835,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);
@@ -1874,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
@@ -2101,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;
@@ -2125,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 :)
 
@@ -2619,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)
 						{
@@ -2683,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);