From 8abeae7805eb1350a5a12ced1074276d971162d6 Mon Sep 17 00:00:00 2001
From: wolfy852 <wolfy852@hotmail.com>
Date: Fri, 15 Jun 2018 05:20:01 -0500
Subject: [PATCH 01/10] Chat Manager

---
 src/d_main.c           |   1 +
 src/d_netcmd.c         |   7 +
 src/doomdef.h          |   1 +
 src/g_game.c           |  26 ++
 src/g_game.h           |   1 +
 src/hardware/hw_draw.c | 105 +++++
 src/hardware/hw_main.h |   1 +
 src/hu_stuff.c         | 990 +++++++++++++++++++++++++++++++++++++----
 src/hu_stuff.h         |   6 +
 src/lua_baselib.c      |  47 ++
 src/lua_hook.h         |   2 +-
 src/lua_hooklib.c      |  19 +-
 src/v_video.c          | 151 ++++++-
 src/v_video.h          |   3 +
 14 files changed, 1262 insertions(+), 98 deletions(-)

diff --git a/src/d_main.c b/src/d_main.c
index b12dcdbf..367a0e08 100644
--- a/src/d_main.c
+++ b/src/d_main.c
@@ -184,6 +184,7 @@ void D_PostEvent_end(void) {};
 UINT8 shiftdown = 0; // 0x1 left, 0x2 right
 UINT8 ctrldown = 0; // 0x1 left, 0x2 right
 UINT8 altdown = 0; // 0x1 left, 0x2 right
+boolean capslock = 0; // jeez i wonder what this does.
 //
 // D_ModifierKeyResponder
 // Sets global shift/ctrl/alt variables, never actually eats events
diff --git a/src/d_netcmd.c b/src/d_netcmd.c
index 2f2657d7..5a4227c3 100644
--- a/src/d_netcmd.c
+++ b/src/d_netcmd.c
@@ -776,6 +776,13 @@ void D_RegisterClientCommands(void)
 	CV_RegisterVar(&cv_usegamma);
 
 	// m_menu.c
+	CV_RegisterVar(&cv_compactscoreboard);
+	CV_RegisterVar(&cv_chatheight);
+	CV_RegisterVar(&cv_chatwidth);
+	CV_RegisterVar(&cv_chattime);
+	CV_RegisterVar(&cv_chatspamprotection);
+	CV_RegisterVar(&cv_consolechat);
+	CV_RegisterVar(&cv_chatnotifications);
 	CV_RegisterVar(&cv_crosshair);
 	CV_RegisterVar(&cv_crosshair2);
 	CV_RegisterVar(&cv_crosshair3);
diff --git a/src/doomdef.h b/src/doomdef.h
index 175838c0..278dc002 100644
--- a/src/doomdef.h
+++ b/src/doomdef.h
@@ -434,6 +434,7 @@ extern INT32 cv_debug;
 
 // Modifier key variables, accessible anywhere
 extern UINT8 shiftdown, ctrldown, altdown;
+extern boolean capslock;
 
 // if we ever make our alloc stuff...
 #define ZZ_Alloc(x) Z_Malloc(x, PU_STATIC, NULL)
diff --git a/src/g_game.c b/src/g_game.c
index bbce2d3e..9224ad84 100644
--- a/src/g_game.c
+++ b/src/g_game.c
@@ -397,6 +397,32 @@ static CV_PossibleValue_t joyaxis_cons_t[] = {{0, "None"},
 #endif
 #endif
 
+// don't mind me putting these here, I was lazy to figure out where else I could put those without blowing up the compiler.
+
+// it automatically becomes compact with 20+ players, but if you like it, I guess you can turn that on!
+consvar_t cv_compactscoreboard= {"compactscoreboard", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
+
+// chat timer thingy
+static CV_PossibleValue_t chattime_cons_t[] = {{5, "MIN"}, {999, "MAX"}, {0, NULL}};
+consvar_t cv_chattime = {"chattime", "8", CV_SAVE, chattime_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL};
+
+// chatwidth
+static CV_PossibleValue_t chatwidth_cons_t[] = {{64, "MIN"}, {150, "MAX"}, {0, NULL}};
+consvar_t cv_chatwidth = {"chatwidth", "150", CV_SAVE, chatwidth_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL};
+
+// chatheight
+static CV_PossibleValue_t chatheight_cons_t[] = {{6, "MIN"}, {22, "MAX"}, {0, NULL}};
+consvar_t cv_chatheight= {"chatheight", "8", CV_SAVE, chatheight_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL};
+
+// chat notifications (do you want to hear beeps? I'd understand if you didn't.)
+consvar_t cv_chatnotifications= {"chatnotifications", "On", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
+
+// chat spam protection (why would you want to disable that???)
+consvar_t cv_chatspamprotection= {"chatspamprotection", "On", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
+
+// old shit console chat. (mostly exists for stuff like terminal, not because I cared if anyone liked the old chat.)
+consvar_t cv_consolechat= {"consolechat", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
+
 consvar_t cv_crosshair = {"crosshair", "Cross", CV_SAVE, crosshair_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL};
 consvar_t cv_crosshair2 = {"crosshair2", "Cross", CV_SAVE, crosshair_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL};
 consvar_t cv_crosshair3 = {"crosshair3", "Cross", CV_SAVE, crosshair_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL};
diff --git a/src/g_game.h b/src/g_game.h
index f59641fb..fa188824 100644
--- a/src/g_game.h
+++ b/src/g_game.h
@@ -54,6 +54,7 @@ extern tic_t timeinmap; // Ticker for time spent in level (used for levelcard di
 extern INT16 rw_maximums[NUM_WEAPONS];
 
 // used in game menu
+extern consvar_t cv_chatwidth, cv_chatnotifications, cv_chatheight, cv_chattime, cv_consolechat, cv_chatspamprotection, cv_compactscoreboard;
 extern consvar_t cv_crosshair, cv_crosshair2, cv_crosshair3, cv_crosshair4;
 extern consvar_t cv_invertmouse, cv_alwaysfreelook, cv_mousemove;
 extern consvar_t cv_turnaxis,cv_moveaxis,cv_brakeaxis,cv_aimaxis,cv_lookaxis,cv_fireaxis,cv_driftaxis;
diff --git a/src/hardware/hw_draw.c b/src/hardware/hw_draw.c
index c142e74c..99cc3613 100644
--- a/src/hardware/hw_draw.c
+++ b/src/hardware/hw_draw.c
@@ -900,6 +900,111 @@ void HWR_DrawFill(INT32 x, INT32 y, INT32 w, INT32 h, INT32 color)
 		PF_Modulated|PF_NoTexture|PF_NoDepthTest);
 }
 
+// -------------------+
+// HWR_DrawConsoleFill     : draw flat coloured transparent rectangle because that's cool, and hw sucks less than sw for that.
+// -------------------+
+void HWR_DrawConsoleFill(INT32 x, INT32 y, INT32 w, INT32 h, UINT32 color, INT32 options)
+{
+	FOutVector v[4];
+	FSurfaceInfo Surf;
+	float fx, fy, fw, fh;
+
+	if (w < 0 || h < 0)
+		return; // consistency w/ software
+
+//  3--2
+//  | /|
+//  |/ |
+//  0--1
+
+	fx = (float)x;
+	fy = (float)y;
+	fw = (float)w;
+	fh = (float)h;
+
+	if (!(options & V_NOSCALESTART))
+	{
+		float dupx = (float)vid.dupx, dupy = (float)vid.dupy;
+
+		if (x == 0 && y == 0 && w == BASEVIDWIDTH && h == BASEVIDHEIGHT)
+		{
+			RGBA_t rgbaColour = V_GetColor(color);
+			FRGBAFloat clearColour;
+			clearColour.red = (float)rgbaColour.s.red / 255;
+			clearColour.green = (float)rgbaColour.s.green / 255;
+			clearColour.blue = (float)rgbaColour.s.blue / 255;
+			clearColour.alpha = 1;
+			HWD.pfnClearBuffer(true, false, &clearColour);
+			return;
+		}
+
+		fx *= dupx;
+		fy *= dupy;
+		fw *= dupx;
+		fh *= dupy;
+
+		if (vid.width != BASEVIDWIDTH * vid.dupx)
+		{
+			if (options & V_SNAPTORIGHT)
+				fx += ((float)vid.width - ((float)BASEVIDWIDTH * dupx));
+			else if (!(options & V_SNAPTOLEFT))
+				fx += ((float)vid.width - ((float)BASEVIDWIDTH * dupx)) / 2;
+		}
+		if (vid.height != BASEVIDHEIGHT * dupy)
+		{
+			// same thing here
+			if (options & V_SNAPTOBOTTOM)
+				fy += ((float)vid.height - ((float)BASEVIDHEIGHT * dupy));
+			else if (!(options & V_SNAPTOTOP))
+				fy += ((float)vid.height - ((float)BASEVIDHEIGHT * dupy)) / 2;
+		}
+	}
+
+	if (fx >= vid.width || fy >= vid.height)
+		return;
+	if (fx < 0)
+	{
+		fw += fx;
+		fx = 0;
+	}
+	if (fy < 0)
+	{
+		fh += fy;
+		fy = 0;
+	}
+
+	if (fw <= 0 || fh <= 0)
+		return;
+	if (fx + fw > vid.width)
+		fw = (float)vid.width - fx;
+	if (fy + fh > vid.height)
+		fh = (float)vid.height - fy;
+
+	fx = -1 + fx / (vid.width / 2);
+	fy = 1 - fy / (vid.height / 2);
+	fw = fw / (vid.width / 2);
+	fh = fh / (vid.height / 2);
+
+	v[0].x = v[3].x = fx;
+	v[2].x = v[1].x = fx + fw;
+	v[0].y = v[1].y = fy;
+	v[2].y = v[3].y = fy - fh;
+
+	//Hurdler: do we still use this argb color? if not, we should remove it
+	v[0].argb = v[1].argb = v[2].argb = v[3].argb = 0xff00ff00; //;
+	v[0].z = v[1].z = v[2].z = v[3].z = 1.0f;
+
+	v[0].sow = v[3].sow = 0.0f;
+	v[2].sow = v[1].sow = 1.0f;
+	v[0].tow = v[1].tow = 0.0f;
+	v[2].tow = v[3].tow = 1.0f;
+	
+	Surf.FlatColor.rgba = UINT2RGBA(color);
+	Surf.FlatColor.s.alpha = 0x80;
+
+	HWD.pfnDrawPolygon(&Surf, v, 4, PF_NoTexture|PF_Modulated|PF_Translucent|PF_NoDepthTest);
+}
+
 #ifdef HAVE_PNG
 
 #ifndef _MSC_VER
diff --git a/src/hardware/hw_main.h b/src/hardware/hw_main.h
index fce17062..f0efc1c5 100644
--- a/src/hardware/hw_main.h
+++ b/src/hardware/hw_main.h
@@ -52,6 +52,7 @@ void HWR_CreatePlanePolygons(INT32 bspnum);
 void HWR_CreateStaticLightmaps(INT32 bspnum);
 void HWR_PrepLevelCache(size_t pnumtextures);
 void HWR_DrawFill(INT32 x, INT32 y, INT32 w, INT32 h, INT32 color);
+void HWR_DrawConsoleFill(INT32 x, INT32 y, INT32 w, INT32 h, UINT32 color, INT32 options);	// Lat: separate flags from color since color needs to be an uint to work right.
 void HWR_DrawPic(INT32 x,INT32 y,lumpnum_t lumpnum);
 
 void HWR_AddCommands(void);
diff --git a/src/hu_stuff.c b/src/hu_stuff.c
index c3c04bed..135cedfc 100644
--- a/src/hu_stuff.c
+++ b/src/hu_stuff.c
@@ -76,6 +76,7 @@ patch_t *cred_font[CRED_FONTSIZE];
 static player_t *plr;
 boolean chat_on; // entering a chat message?
 static char w_chat[HU_MAXMSGLEN];
+static INT32 c_input = 0;	// let's try to make the chat input less shitty.
 static boolean headsupactive = false;
 boolean hu_showscores; // draw rankings
 static char hu_tick;
@@ -336,6 +337,74 @@ void HU_Start(void)
 //======================================================================
 
 #ifndef NONET
+
+// EVERY CHANGE IN THIS SCRIPT IS LOL XD! BY VINCYTM
+
+static UINT32 chat_nummsg_log = 0;
+static UINT32 chat_nummsg_min = 0;
+static UINT32 chat_scroll = 0;		
+static tic_t chat_scrolltime = 0;
+
+static INT32 chat_maxscroll = 0;	// how far can we scroll? 
+
+//static chatmsg_t chat_mini[CHAT_BUFSIZE];	// Display the last few messages sent.
+//static chatmsg_t chat_log[CHAT_BUFSIZE];	// Keep every message sent to us in memory so we can scroll n shit, it's cool.
+
+static char chat_log[CHAT_BUFSIZE][255];	// hold the last 48 or so messages in that log.
+static char chat_mini[8][255];			// display up to 8 messages that will fade away / get overwritten
+static tic_t chat_timers[8];
+
+static boolean chat_scrollmedown = false;	// force instant scroll down on the chat log. Happens when you open it / send a message.
+
+// remove text from minichat table
+
+static INT16 addy = 0;	// use this to make the messages scroll smoothly when one fades away 
+
+static void HU_removeChatText_Mini(void)
+{
+    // MPC: Don't create new arrays, just iterate through an existing one
+	int i;
+    for(i=0;i<chat_nummsg_min-1;i++) {
+        strcpy(chat_mini[i], chat_mini[i+1]);
+        chat_timers[i] = chat_timers[i+1];
+    }
+	chat_nummsg_min--;	// lost 1 msg.
+
+	// use addy and make shit slide smoothly af.
+	addy += (vid.width < 640) ? 8 : 6;
+
+}
+
+// same but w the log. TODO: optimize this and maybe merge in a single func? im bad at C.
+static void HU_removeChatText_Log(void)
+{
+	// MPC: Don't create new arrays, just iterate through an existing one
+	int i;
+    for(i=0;i<chat_nummsg_log-1;i++) {
+        strcpy(chat_log[i], chat_log[i+1]);
+    }
+    chat_nummsg_log--;	// lost 1 msg.
+}
+	
+void HU_AddChatText(const char *text)
+{
+	
+	// TODO: check if we're oversaturating the log (we can only log CHAT_BUFSIZE messages.)
+	
+	if (chat_nummsg_log >= CHAT_BUFSIZE)
+		HU_removeChatText_Log();
+	
+	strcpy(chat_log[chat_nummsg_log], text);
+	chat_nummsg_log++;
+	
+	if (chat_nummsg_min >= 8)
+		HU_removeChatText_Mini();
+	
+	strcpy(chat_mini[chat_nummsg_min], text);
+	chat_timers[chat_nummsg_min] = TICRATE*cv_chattime.value;
+	chat_nummsg_min++;
+}
+
 /** Runs a say command, sending an ::XD_SAY message.
   * A say command consists of a signed 8-bit integer for the target, an
   * unsigned 8-bit flag variable, and then the message itself.
@@ -364,14 +433,14 @@ static void DoSayCommand(SINT8 target, size_t usedargs, UINT8 flags)
 	numwords = COM_Argc() - usedargs;
 	I_Assert(numwords > 0);
 
-	if (cv_mute.value && !(server || IsPlayerAdmin(consoleplayer)))
+	if (cv_mute.value && !(server || IsPlayerAdmin(consoleplayer)))	// TODO: Per Player mute.
 	{
-		CONS_Alert(CONS_NOTICE, M_GetText("The chat is muted. You can't say anything at the moment.\n"));
+		HU_AddChatText(va("%s>ERROR: The chat is muted. You can't say anything.", "\x85"));
 		return;
 	}
 
 	// Only servers/admins can CSAY.
-	if(!server && IsPlayerAdmin(consoleplayer))
+	if(!server && !(IsPlayerAdmin(consoleplayer)))
 		flags &= ~HU_CSAY;
 
 	// We handle HU_SERVER_SAY, not the caller.
@@ -389,6 +458,52 @@ static void DoSayCommand(SINT8 target, size_t usedargs, UINT8 flags)
 			strlcat(msg, " ", msgspace);
 		strlcat(msg, COM_Argv(ix + usedargs), msgspace);
 	}
+	
+	if (strlen(msg) > 4 && strnicmp(msg, "/pm", 3) == 0)	// used /pm
+	{
+		// what we're gonna do now is check if the node exists
+		// with that logic, characters 4 and 5 are our numbers:
+		int spc = 1;	// used if nodenum[1] is a space.
+		char *nodenum = (char*) malloc(3);
+		strncpy(nodenum, msg+3, 5);
+		// check for undesirable characters in our "number"
+		if 	(((nodenum[0] < '0') || (nodenum[0] > '9')) || ((nodenum[1] < '0') || (nodenum[1] > '9')))
+		{	
+			// check if nodenum[1] is a space
+			if (nodenum[1] == ' ')
+				spc = 0;
+				// let it slide
+			else
+			{	
+				HU_AddChatText("\x82NOTICE: \x80Invalid command format. Correct format is \'/pm<node> \'.");
+				return;
+			}	
+		}
+		// I'm very bad at C, I swear I am, additional checks eww!
+			if (spc != 0)
+			{	
+				if (msg[5] != ' ')
+				{
+					HU_AddChatText("\x82NOTICE: \x80Invalid command format. Correct format is \'/pm<node> \'.");
+					return;
+				}
+			}
+		
+		target = atoi((const char*) nodenum);	// turn that into a number
+		//CONS_Printf("%d\n", target);
+		
+		// check for target player, if it doesn't exist then we can't send the message!
+		if (playeringame[target])	// player exists
+			target++;				// even though playernums are from 0 to 31, target is 1 to 32, so up that by 1 to have it work!
+		else
+		{
+			HU_AddChatText(va("\x82NOTICE: \x80Player %d does not exist.", target));	// same
+			return;
+		}
+		buf[0] = target;
+		const char *newmsg = msg+5+spc;
+		memcpy(msg, newmsg, 255);
+	}
 
 	SendNetXCmd(XD_SAY, buf, strlen(msg) + 1 + msg-buf);
 }
@@ -473,6 +588,7 @@ static void Command_CSay_f(void)
 
 	DoSayCommand(0, 1, HU_CSAY);
 }
+static tic_t stop_spamming_you_cunt[MAXPLAYERS];
 
 /** Receives a message, processing an ::XD_SAY command.
   * \sa DoSayCommand
@@ -486,7 +602,7 @@ static void Got_Saycmd(UINT8 **p, INT32 playernum)
 	char *msg;
 	boolean action = false;
 	char *ptr;
-
+	
 	CONS_Debug(DBG_NETPLAY,"Received SAY cmd from Player %d (%s)\n", playernum+1, player_names[playernum]);
 
 	target = READSINT8(*p);
@@ -494,7 +610,7 @@ static void Got_Saycmd(UINT8 **p, INT32 playernum)
 	msg = (char *)*p;
 	SKIPSTRING(*p);
 
-	if ((cv_mute.value || flags & (HU_CSAY|HU_SERVER_SAY)) && playernum != serverplayer && !IsPlayerAdmin(playernum))
+	if ((cv_mute.value || flags & (HU_CSAY|HU_SERVER_SAY)) && playernum != serverplayer && !(IsPlayerAdmin(playernum)))
 	{
 		CONS_Alert(CONS_WARNING, cv_mute.value ?
 			M_GetText("Illegal say command received from %s while muted\n") : M_GetText("Illegal csay command received from non-admin %s\n"),
@@ -531,12 +647,31 @@ static void Got_Saycmd(UINT8 **p, INT32 playernum)
 			}
 		}
 	}
-
+	
+	int spam_eatmsg = 0;
+	
+	// before we do anything, let's verify the guy isn't spamming, get this easier on us.
+	
+	//if (stop_spamming_you_cunt[playernum] != 0 && cv_chatspamprotection.value && !(flags & HU_CSAY))
+	if (stop_spamming_you_cunt[playernum] != 0 && consoleplayer != playernum && cv_chatspamprotection.value && !(flags & HU_CSAY))
+	{	
+		CONS_Debug(DBG_NETPLAY,"Received SAY cmd too quickly from Player %d (%s), assuming as spam and blocking message.\n", playernum+1, player_names[playernum]);
+		stop_spamming_you_cunt[playernum] = 4;
+		spam_eatmsg = 1;
+	}
+	else
+		stop_spamming_you_cunt[playernum] = 4;	// you can hold off for 4 tics, can you?
+	
+	// run the lua hook even if we were supposed to eat the msg, netgame consistency goes first.
+	
 #ifdef HAVE_BLUA
-	if (LUAh_PlayerMsg(playernum, target, flags, msg))
+	if (LUAh_PlayerMsg(playernum, target, flags, msg, spam_eatmsg))
 		return;
 #endif
-
+	
+	if (spam_eatmsg)
+		return;	// don't proceed if we were supposed to eat the message.
+	
 	// If it's a CSAY, just CECHO and be done with it.
 	if (flags & HU_CSAY)
 	{
@@ -576,18 +711,23 @@ static void Got_Saycmd(UINT8 **p, INT32 playernum)
 	|| target == 0 // To everyone
 	|| consoleplayer == target-1) // To you
 	{
-		const char *cstart = "", *cend = "", *adminchar = "~", *remotechar = "@", *fmt;
+		const char *prefix = "", *cstart = "", *cend = "", *adminchar = "\x82~\x83", *remotechar = "\x82@\x83", *fmt, *fmt2;
 		char *tempchar = NULL;
-
+		
 		// In CTF and team match, color the player's name.
 		if (G_GametypeHasTeams())
 		{
-			cend = "\x80";
-			if (players[playernum].ctfteam == 1) // red
-				cstart = "\x85";
+			cend = "";
+			if (players[playernum].ctfteam == 1) // red	
+				cstart = "\x85";		
 			else if (players[playernum].ctfteam == 2) // blue
 				cstart = "\x84";
+			
 		}
+		
+		// player is a spectator?
+		if (players[playernum].spectator)
+				cstart = "\x86";	// grey name
 
 		// Give admins and remote admins their symbols.
 		if (playernum == serverplayer)
@@ -596,11 +736,11 @@ static void Got_Saycmd(UINT8 **p, INT32 playernum)
 			tempchar = (char *)Z_Calloc(strlen(cstart) + strlen(remotechar) + 1, PU_STATIC, NULL);
 		if (tempchar)
 		{
-			strcat(tempchar, cstart);
 			if (playernum == serverplayer)
 				strcat(tempchar, adminchar);
 			else
 				strcat(tempchar, remotechar);
+			strcat(tempchar, cstart);
 			cstart = tempchar;
 		}
 
@@ -609,21 +749,61 @@ static void Got_Saycmd(UINT8 **p, INT32 playernum)
 		// name, color end, and the message itself.
 		// '\4' makes the message yellow and beeps; '\3' just beeps.
 		if (action)
-			fmt = "\4* %s%s%s \x82%s\n";
+		{	
+			fmt = "\3* %s%s%s%s \x82%s\n";	// don't make /me yellow, yellow will be for mentions and PMs!
+			fmt2 = "* %s%s%s%s \x82%s";
+		}	
 		else if (target == 0) // To everyone
-			fmt = "\3<%s%s%s> %s\n";
+		{
+			fmt = "\3%s\x83<%s%s%s\x83>\x80 %s\n";
+			fmt2 = "%s\x83<%s%s%s\x83>\x80 %s";
+		}	
 		else if (target-1 == consoleplayer) // To you
-			fmt = "\3*%s%s%s* %s\n";
+		{
+			prefix = "\x82[PM]";
+			cstart = "\x82";
+			fmt = "\4%s<%s%s>%s\x80 %s\n";	// make this yellow, however.
+			fmt2 = "%s<%s%s>%s\x80 %s";
+		}
 		else if (target > 0) // By you, to another player
 		{
 			// Use target's name.
 			dispname = player_names[target-1];
-			fmt = "\3->*%s%s%s* %s\n";
+			/*fmt = "\3\x82[TO]\x80%s%s%s* %s\n";
+			fmt2 = "\x82[TO]\x80%s%s%s* %s";*/
+			prefix = "\x82[TO]";
+			cstart = "\x82";
+			fmt = "\4%s<%s%s>%s\x80 %s\n";	// make this yellow, however.
+			fmt2 = "%s<%s%s>%s\x80 %s";
+			
 		}
 		else // To your team
-			fmt = "\3>>%s%s%s<< (team) %s\n";
-
-		CONS_Printf(fmt, cstart, dispname, cend, msg);
+		{
+			if (players[playernum].ctfteam == 1) // red	
+				prefix = "\x85[TEAM]";		
+			else if (players[playernum].ctfteam == 2) // blue
+				prefix = "\x84[TEAM]";
+			else
+				prefix = "\x83";	// makes sure this doesn't implode if you sayteam on non-team gamemodes
+				
+			fmt = "\3%s<%s%s>\x80%s %s\n";
+			fmt2 = "%s<%s%s>\x80%s %s";
+		
+		}		
+		
+		if (cv_consolechat.value)
+		{	
+			CONS_Printf(fmt, prefix, cstart, dispname, cend, msg);	
+			HU_AddChatText(va(fmt2, prefix, cstart, dispname, cend, msg));	// add it reguardless, in case we decide to change our mind about our chat type.
+		}	
+		else
+		{	
+			HU_AddChatText(va(fmt2, prefix, cstart, dispname, cend, msg));
+			CON_LogMessage(va(fmt, prefix, cstart, dispname, cend, msg));	// save to log.txt
+			if (cv_chatnotifications.value)
+				S_StartSound(NULL, sfx_radio);
+		}	
+		
 		if (tempchar)
 			Z_Free(tempchar);
 	}
@@ -650,19 +830,48 @@ static inline boolean HU_keyInChatString(char *s, char ch)
 		l = strlen(s);
 		if (l < HU_MAXMSGLEN - 1)
 		{
-			s[l++] = ch;
-			s[l]=0;
+			if (c_input >= strlen(s))	// don't do anything complicated
+			{
+				s[l++] = ch;
+				s[l]=0;
+			}	
+			else
+			{	
+				
+				// move everything past c_input for new characters:
+				INT32 m = HU_MAXMSGLEN-1;
+				for (;(m>=c_input);m--)
+				{
+					if (s[m])
+						s[m+1] = (s[m]);
+				}
+				s[c_input] = ch;		// and replace this.
+			}
+			c_input++;
 			return true;
 		}
 		return false;
 	}
 	else if (ch == KEY_BACKSPACE)
 	{
-		l = strlen(s);
-		if (l)
-			s[--l] = 0;
-		else
+		if (c_input <= 0)
 			return false;
+		size_t i = c_input;
+		if (!s[i-1])
+			return false;
+		
+		if (i >= strlen(s)-1)
+		{	
+			s[strlen(s)-1] = 0;
+			c_input--;
+			return false;
+		}	
+		
+		for (; (i < HU_MAXMSGLEN); i++)
+		{	
+			s[i-1] = s[i];
+		}
+		c_input--;
 	}
 	else if (ch != KEY_ENTER)
 		return false; // did not eat key
@@ -686,29 +895,9 @@ void HU_Ticker(void)
 		hu_showscores = false;
 }
 
-#define QUEUESIZE 256
 
 static boolean teamtalk = false;
-static char chatchars[QUEUESIZE];
-static INT32 head = 0, tail = 0;
-
-//
-// HU_dequeueChatChar
-//
-char HU_dequeueChatChar(void)
-{
-	char c;
-
-	if (head != tail)
-	{
-		c = chatchars[tail];
-		tail = (tail + 1) & (QUEUESIZE-1);
-	}
-	else
-		c = 0;
-
-	return c;
-}
+// WHY DO YOU OVERCOMPLICATE EVERYTHING?????????
 
 //
 //
@@ -719,79 +908,130 @@ static void HU_queueChatChar(char c)
 	{
 		char buf[2+256];
 		size_t ci = 2;
-
+		char *msg = &buf[2];
 		do {
-			c = HU_dequeueChatChar();
+			c = w_chat[-2+ci++];
 			if (!c || (c >= ' ' && !(c & 0x80))) // copy printable characters and terminating '\0' only.
-				buf[ci++]=c;
+				buf[ci-1]=c;
 		} while (c);
-
+		size_t i = 0;
+		for (;(i<HU_MAXMSGLEN);i++)
+			w_chat[i] = 0;	// reset this.
+		
+		c_input = 0;
+		
 		// last minute mute check
 		if (cv_mute.value && !(server || IsPlayerAdmin(consoleplayer)))
 		{
-			CONS_Alert(CONS_NOTICE, M_GetText("The chat is muted. You can't say anything at the moment.\n"));
+			HU_AddChatText(va("%s>ERROR: The chat is muted. You can't say anything.", "\x85"));
 			return;
 		}
-
+		
+		INT32 target = 0;
+		
+		if (strlen(msg) > 4 && strnicmp(msg, "/pm", 3) == 0)	// used /pm
+		{
+			// what we're gonna do now is check if the node exists
+			// with that logic, characters 4 and 5 are our numbers:
+			
+			// teamtalk can't send PMs, just don't send it, else everyone would be able to see it, and no one wants to see your sex RP sicko.
+			if (teamtalk)
+			{
+				HU_AddChatText(va("%sCannot send sayto in Say-Team.", "\x85"));
+				return;
+			}	
+			
+			int spc = 1;	// used if nodenum[1] is a space.
+			char *nodenum = (char*) malloc(3);
+			strncpy(nodenum, msg+3, 5);
+			// check for undesirable characters in our "number"
+			if 	(((nodenum[0] < '0') || (nodenum[0] > '9')) || ((nodenum[1] < '0') || (nodenum[1] > '9')))
+			{	
+				// check if nodenum[1] is a space
+				if (nodenum[1] == ' ')
+					spc = 0;
+					// let it slide
+				else
+				{	
+					HU_AddChatText("\x82NOTICE: \x80Invalid command format. Correct format is \'/pm<node> \'.");
+					return;
+				}	
+			}
+			// I'm very bad at C, I swear I am, additional checks eww!
+			if (spc != 0)
+			{	
+				if (msg[5] != ' ')
+				{
+					HU_AddChatText("\x82NOTICE: \x80Invalid command format. Correct format is \'/pm<node> \'.");
+					return;
+				}
+			}
+			
+			target = atoi((const char*) nodenum);	// turn that into a number
+			//CONS_Printf("%d\n", target);
+		
+			// check for target player, if it doesn't exist then we can't send the message!
+			if (playeringame[target])	// player exists
+				target++;				// even though playernums are from 0 to 31, target is 1 to 32, so up that by 1 to have it work!
+			else
+			{
+				HU_AddChatText(va("\x82NOTICE: \x80Player %d does not exist.", target));	// same
+				return;
+			}
+			// we need to get rid of the /pm<node>
+			const char *newmsg = msg+5+spc;
+			memcpy(msg, newmsg, 255);
+		}	
 		if (ci > 3) // don't send target+flags+empty message.
 		{
 			if (teamtalk)
 				buf[0] = -1; // target
 			else
-				buf[0] = 0; // target
+				buf[0] = target;
+			
 			buf[1] = 0; // flags
 			SendNetXCmd(XD_SAY, buf, 2 + strlen(&buf[2]) + 1);
 		}
 		return;
 	}
-
-	if (((head + 1) & (QUEUESIZE-1)) == tail)
-		CONS_Printf(M_GetText("[Message unsent]\n")); // message not sent
-	else
-	{
-		if (c == KEY_BACKSPACE)
-		{
-			if (tail != head)
-				head = (head - 1) & (QUEUESIZE-1);
-		}
-		else
-		{
-			chatchars[head] = c;
-			head = (head + 1) & (QUEUESIZE-1);
-		}
-	}
 }
 
 void HU_clearChatChars(void)
 {
-	while (tail != head)
-		HU_queueChatChar(KEY_BACKSPACE);
+	size_t i = 0;
+	for (;i<HU_MAXMSGLEN;i++)
+		w_chat[i] = 0;	// reset this.
 	chat_on = false;
+	c_input = 0;
 }
 
+static boolean justscrolleddown;
+static boolean justscrolledup;
+
 //
 // Returns true if key eaten
 //
 boolean HU_Responder(event_t *ev)
 {
-	UINT8 c;
-
+	UINT8 c=0;
+		
 	if (ev->type != ev_keydown)
 		return false;
 
 	// only KeyDown events now...
-
+	
 	if (!chat_on)
 	{
 		// enter chat mode
 		if ((ev->data1 == gamecontrol[gc_talkkey][0] || ev->data1 == gamecontrol[gc_talkkey][1])
-			&& netgame && (!cv_mute.value || server || IsPlayerAdmin(consoleplayer)))
+			&& netgame && (!cv_mute.value || server || (IsPlayerAdmin(consoleplayer))))
 		{
 			if (cv_mute.value && !(server || IsPlayerAdmin(consoleplayer)))
 				return false;
 			chat_on = true;
 			w_chat[0] = 0;
 			teamtalk = false;
+			chat_scrollmedown = true;
 			return true;
 		}
 		if ((ev->data1 == gamecontrol[gc_teamkey][0] || ev->data1 == gamecontrol[gc_teamkey][1])
@@ -802,11 +1042,13 @@ boolean HU_Responder(event_t *ev)
 			chat_on = true;
 			w_chat[0] = 0;
 			teamtalk = true;
+			chat_scrollmedown = true;
 			return true;
 		}
 	}
 	else // if chat_on
 	{
+		
 		// Ignore modifier keys
 		// Note that we do this here so users can still set
 		// their chat keys to one of these, if they so desire.
@@ -816,18 +1058,95 @@ boolean HU_Responder(event_t *ev)
 			return true;
 
 		c = (UINT8)ev->data1;
-
-		// use console translations
-		if (shiftdown)
+		
+		// capslock
+		if (c && c == KEY_CAPSLOCK)	// it's a toggle.
+		{	
+			if (capslock)
+				capslock = false;
+			else	
+				capslock = true;
+			return true;
+		}	
+		
+		// use console translations		
+		if (shiftdown ^ capslock)
 			c = shiftxform[c];
-
+		
+		// TODO: make chat behave like the console, so that we can go back and edit stuff when we fuck up.
+		
+		// pasting. pasting is cool. chat is a bit limited, though :(
+		if ((c == 'v' || c == 'V') && ctrldown)
+		{
+			const char *paste = I_ClipboardPaste();
+			
+			// create a dummy string real quickly
+			
+			if (paste == NULL)
+				return true;
+			
+			size_t chatlen = strlen(w_chat);
+			size_t pastelen = strlen(paste);
+			if (chatlen+pastelen > HU_MAXMSGLEN)
+				return true; // we can't paste this!!
+			
+			if (c_input >= strlen(w_chat))	// add it at the end of the string.
+			{
+				memcpy(&w_chat[chatlen], paste, pastelen);	// copy all of that.
+				c_input += pastelen;
+				/*size_t i = 0;
+				for (;i<pastelen;i++)
+				{
+					HU_queueChatChar(paste[i]);				// queue it so that it's actually sent. (this chat write thing is REALLY messy.)
+				}*/
+				return true;
+			}
+			else	// otherwise, we need to shift everything and make space, etc etc
+			{	
+				size_t i = HU_MAXMSGLEN-1;
+				for (; i>=c_input;i--)
+				{
+					if (w_chat[i])
+						w_chat[i+pastelen] = w_chat[i];
+					
+				}
+				memcpy(&w_chat[c_input], paste, pastelen);	// copy all of that.
+				c_input += pastelen;
+				return true;
+			}
+		}
+		
 		if (HU_keyInChatString(w_chat,c))
+		{	
 			HU_queueChatChar(c);
+		}	
 		if (c == KEY_ENTER)
+		{	
 			chat_on = false;
+			c_input = 0;			// reset input cursor
+			chat_scrollmedown = true; // you hit enter, so you might wanna autoscroll to see what you just sent. :)
+		}	
 		else if (c == KEY_ESCAPE)
+		{	
 			chat_on = false;
-
+			c_input = 0;			// reset input cursor
+		}	
+		else if ((c == KEY_UPARROW || c == KEY_MOUSEWHEELUP) && chat_scroll > 0)	// CHAT SCROLLING YAYS!
+		{
+			chat_scroll--;
+			justscrolledup = true;
+			chat_scrolltime = 4;
+		}	
+		else if ((c == KEY_DOWNARROW || c == KEY_MOUSEWHEELDOWN) && chat_scroll < chat_maxscroll && chat_maxscroll > 0)
+		{	
+			chat_scroll++;
+			justscrolleddown = true;
+			chat_scrolltime = 4;
+		}
+		else if (c == KEY_LEFTARROW && c_input != 0)	// i said go back
+			c_input--;
+		else if (c == KEY_RIGHTARROW && c_input < strlen(w_chat))
+			c_input++;	
 		return true;
 	}
 	return false;
@@ -837,12 +1156,412 @@ boolean HU_Responder(event_t *ev)
 //                         HEADS UP DRAWING
 //======================================================================
 
+// Gets string colormap, used for 0x80 color codes
+//
+static UINT8 *CHAT_GetStringColormap(INT32 colorflags)	// pasted from video.c, sorry for the mess.
+{
+	switch ((colorflags & V_CHARCOLORMASK) >> V_CHARCOLORSHIFT)
+	{
+	case 1: // 0x81, purple
+		return purplemap;
+	case 2: // 0x82, yellow
+		return yellowmap;
+	case 3: // 0x83, lgreen
+		return lgreenmap;
+	case 4: // 0x84, blue
+		return bluemap;
+	case 5: // 0x85, red
+		return redmap;
+	case 6: // 0x86, gray
+		return graymap;
+	case 7: // 0x87, orange
+		return orangemap;
+	default: // reset
+		return NULL;
+	}
+}
+
+// Precompile a wordwrapped string to any given width.
+// This is a muuuch better method than V_WORDWRAP.
+// again stolen and modified a bit from video.c, don't mind me, will need to rearrange this one day.
+// this one is simplified for the chat drawer.
+char *CHAT_WordWrap(INT32 x, INT32 w, INT32 option, const char *string)
+{
+	int c;
+	size_t chw, i, lastusablespace = 0;
+	size_t slen;
+	char *newstring = Z_StrDup(string);
+	INT32 spacewidth = (vid.width < 640) ? 8 : 4, charwidth = (vid.width < 640) ? 8 : 4;
+
+	slen = strlen(string);
+	x = 0;
+
+	for (i = 0; i < slen; ++i)
+	{
+		c = newstring[i];
+		if ((UINT8)c >= 0x80 && (UINT8)c <= 0x89) //color parsing! -Inuyasha 2.16.09
+			continue;
+
+		if (c == '\n')
+		{
+			x = 0;
+			lastusablespace = 0;
+			continue;
+		}
+
+		if (!(option & V_ALLOWLOWERCASE))
+			c = toupper(c);
+		c -= HU_FONTSTART;
+
+		if (c < 0 || c >= HU_FONTSIZE || !hu_font[c])
+		{
+			chw = spacewidth;
+			lastusablespace = i;
+		}
+		else
+			chw = charwidth;
+
+		x += chw;
+
+		if (lastusablespace != 0 && x > w)
+		{
+			//CONS_Printf("Wrap at index %d\n", i);
+			newstring[lastusablespace] = '\n';
+			i = lastusablespace+1;	
+			lastusablespace = 0;
+			x = 0;
+		}
+	}
+	return newstring;
+}
+
+INT16 chatx = 160, chaty = 16;	// let's use this as our coordinates, shh
+
+// chat stuff by VincyTM LOL XD!
+
+// HU_DrawMiniChat
+
+static void HU_drawMiniChat(void)
+{
+	INT32 charwidth = (vid.width < 640) ? 8 : 4, charheight = (vid.width < 640) ? 8 : 6;
+	INT32 x = chatx+2, y = chaty+2, dx = 0, dy = 0;
+	size_t i = 0;
+	
+	for (i=0; i<chat_nummsg_min; i++)	// iterate through our hot messages
+	{
+		
+		INT32 clrflag = 0;
+		
+		INT32 timer = ((cv_chattime.value*TICRATE)-chat_timers[i]) - cv_chattime.value*TICRATE+9;	// see below...		
+		INT32 transflag = (timer >= 0 && timer <= 9) ? (timer*V_10TRANS) : 0;	// you can make bad jokes out of this one.
+		size_t j = 0;
+		const char *msg = CHAT_WordWrap(x, cv_chatwidth.value-charwidth, V_SNAPTOTOP|V_SNAPTOLEFT|V_ALLOWLOWERCASE, chat_mini[i]);	// get the current message, and word wrap it.
+		while(msg[j])	// iterate through msg
+		{	
+			if (msg[j] < HU_FONTSTART)	// don't draw
+			{			
+				if (msg[j] == '\n')	// get back down.
+				{
+					++j;
+					dy += charheight;
+					dx = 0;
+					continue;
+				}
+				else if (msg[j] & 0x80) // stolen from video.c, nice.
+				{
+					clrflag = ((msg[j] & 0x7f) << V_CHARCOLORSHIFT) & V_CHARCOLORMASK;
+					++j;
+					continue;
+				}
+				
+				++j;	
+			}
+			else
+			{
+				UINT8 *colormap = CHAT_GetStringColormap(clrflag);
+				V_DrawChatCharacter(x + dx + 2, y+dy+addy, msg[j++] |V_SNAPTOTOP|V_SNAPTORIGHT|transflag, !cv_allcaps.value, colormap);
+			}
+			
+			dx += charwidth;
+			if (dx >= cv_chatwidth.value)
+			{
+				dx = 0;
+				dy += charheight;
+			}
+		}
+		dy += charheight;
+		dx = 0;
+	}
+	
+	// decrement addy and make that shit smooth:
+	addy /= 2;
+	
+}
+
+// HU_DrawUpArrow
+// You see, we don't have arrow graphics in 2.1 and I'm too lazy to include a 2 bytes file for it.
+
+static void HU_DrawUpArrow(INT32 x, INT32 y, INT32 options)
+{
+	// Ok I'm super lazy so let's make this as the worst draw function:
+	V_DrawFill(x+2, y, 1, 1, 103|options);
+	V_DrawFill(x+1, y+1, 3, 1, 103|options);
+	V_DrawFill(x, y+2, 5, 1, 103|options);	// that's the yellow part, I swear
+	
+	V_DrawFill(x+3, y, 1, 1, 26|options);
+	V_DrawFill(x+4, y+1, 1, 1, 26|options);
+	V_DrawFill(x+5, y+2, 1, 1, 26|options);
+	V_DrawFill(x, y+3, 6, 1, 26|options);	// that's the black part. no racism intended. i swear.
+}
+
+// HU_DrawDownArrow
+// Should we talk about anime waifus to pass the time? This feels retarded.
+
+static void HU_DrawDownArrow(INT32 x, INT32 y, INT32 options)
+{
+	// Ok I'm super lazy so let's make this as the worst draw function:
+	V_DrawFill(x, y, 6, 1, 26|options);
+	V_DrawFill(x, y+1, 5, 1, 26|options);
+	V_DrawFill(x+1, y+2, 3, 1, 26|options);
+	V_DrawFill(x+2, y+3, 1, 1, 26|options);	// that's the black part. no racism intended. i swear.
+	
+	V_DrawFill(x, y, 5, 1, 103|options);
+	V_DrawFill(x+1, y+1, 3, 1, 103|options);
+	V_DrawFill(x+2, y+2, 1, 1, 103|options);	// that's the yellow part, I swear
+}	
+
+// HU_DrawChatLog
+// TODO: fix dumb word wrapping issues
+
+static void HU_drawChatLog(void)
+{
+	
+	// before we do anything, make sure that our scroll position isn't "illegal";
+	if (chat_scroll > chat_maxscroll)
+		chat_scroll = chat_maxscroll;
+	
+	INT32 charwidth = (vid.width < 640) ? 8 : 4, charheight = (vid.width < 640) ? 8 : 6;
+	INT32 x = chatx+2, y = chaty+2-(chat_scroll*charheight), dx = 0, dy = 0;
+	size_t i = 0;
+	boolean atbottom = false;
+	
+	V_DrawFillConsoleMap(chatx, chaty, cv_chatwidth.value, cv_chatheight.value*charheight +2, 239|V_SNAPTOTOP|V_SNAPTORIGHT);	// INUT
+		
+	for (i=0; i<chat_nummsg_log; i++)	// iterate through our chatlog
+	{
+		INT32 clrflag = 0;
+		size_t j = 0;
+		const char *msg = CHAT_WordWrap(x, cv_chatwidth.value-charwidth, V_SNAPTOTOP|V_SNAPTOLEFT|V_ALLOWLOWERCASE, chat_log[i]);	// get the current message, and word wrap it.
+		while(msg[j])	// iterate through msg
+		{	
+			if (msg[j] < HU_FONTSTART)	// don't draw
+			{			
+				if (msg[j] == '\n')	// get back down.
+				{
+					++j;
+					dy += charheight;
+					dx = 0;
+					continue;
+				}
+				else if (msg[j] & 0x80) // stolen from video.c, nice.
+				{
+					clrflag = ((msg[j] & 0x7f) << V_CHARCOLORSHIFT) & V_CHARCOLORMASK;
+					++j;
+					continue;
+				}
+				
+				++j;	
+			}
+			else
+			{
+				if ((y+dy > chaty) && (y+dy < (chaty+cv_chatheight.value*charheight)))
+				{	
+					UINT8 *colormap = CHAT_GetStringColormap(clrflag);
+					V_DrawChatCharacter(x + dx + 2, y+dy, msg[j++] |V_SNAPTOTOP|V_SNAPTORIGHT, !cv_allcaps.value, colormap);
+				}
+				else
+					j++;	// don't forget to increment this or we'll get stuck in the limbo.
+			}
+			
+			dx += charwidth;
+			if (dx >= cv_chatwidth.value-charwidth-2 && i<chat_nummsg_log && msg[j] >= HU_FONTSTART) // end of message shouldn't count, nor should invisible characters!!!!
+			{
+				dx = 0;
+				dy += charheight;
+			}
+		}
+		dy += charheight;
+		dx = 0;
+	}
+	
+	if (((chat_scroll >= chat_maxscroll) || (chat_scrollmedown)) && !(justscrolleddown || justscrolledup || chat_scrolltime))	// was already at the bottom of the page before new maxscroll calculation and was NOT scrolling.
+	{
+		atbottom = true;	// we should scroll
+	}
+	chat_scrollmedown = false;
+	
+	// getmaxscroll through a lazy hack. We do all these loops, so let's not do more loops that are gonna lag the game more. :P
+	chat_maxscroll = (dy/charheight)-cv_chatheight.value;	// welcome to C, we don't know what min() and max() are.
+	if (chat_maxscroll < 0)
+		chat_maxscroll = 0;
+	
+	// if we're not bound by the time, autoscroll for next frame:
+	if (atbottom)
+		chat_scroll = chat_maxscroll;
+	
+	// draw arrows to indicate that we can (or not) scroll.
+	
+	if (chat_scroll > 0)
+		HU_DrawUpArrow(chatx-8, ((justscrolledup) ? (chaty-1) : (chaty)), V_SNAPTOTOP | V_SNAPTORIGHT);
+	if (chat_scroll < chat_maxscroll)
+		HU_DrawDownArrow(chatx-8, chaty+(cv_chatheight.value*charheight)-((justscrolleddown) ? 3 : 4), V_SNAPTOTOP | V_SNAPTORIGHT);
+	
+	justscrolleddown = false;
+	justscrolledup = false;
+}	
+
 //
 // HU_DrawChat
 //
 // Draw chat input
 //
+
+static INT16 typelines = 1;	// number of drawfill lines we need. it's some weird hack and might be one frame off but I'm lazy to make another loop.
 static void HU_DrawChat(void)
+{	
+	INT32 charwidth = (vid.width < 640) ? 8 : 4, charheight = (vid.width < 640) ? 8 : 6;
+	INT32 t = 0, c = 0, y = chaty + 4 + cv_chatheight.value*charheight;
+	size_t i = 0;
+	const char *ntalk = "Say: ", *ttalk = "Team: ";
+	const char *talk = ntalk;
+	
+	if (teamtalk)
+	{
+		talk = ttalk;
+#if 0
+		if (players[consoleplayer].ctfteam == 1)
+			t = 0x500;  // Red
+		else if (players[consoleplayer].ctfteam == 2)
+			t = 0x400; // Blue
+#endif
+	}
+			
+	HU_drawChatLog();
+	V_DrawFillConsoleMap(chatx, y-1, cv_chatwidth.value, (vid.width < 640 ) ? (typelines*charheight+2) : (typelines*charheight), 239 | V_SNAPTOTOP | V_SNAPTORIGHT);
+	
+	while (talk[i])
+	{
+		if (talk[i] < HU_FONTSTART)
+			++i;
+		else
+			V_DrawChatCharacter(chatx + c + 2, y, talk[i++] |V_SNAPTOTOP|V_SNAPTORIGHT, !cv_allcaps.value, NULL);
+
+		c += charwidth;
+	}
+	
+	i = 0;
+	typelines = 1;
+	
+	if ((strlen(w_chat) == 0 || c_input == 0) && hu_tick < 4)
+		V_DrawChatCharacter(chatx + 2 + c, y+1, '_' |V_SNAPTOTOP|V_SNAPTORIGHT|t, !cv_allcaps.value, NULL);
+	
+	while (w_chat[i])
+	{
+		
+		if (c_input == (i+1) && hu_tick < 4)
+		{
+			int cursorx = (c+charwidth < cv_chatwidth.value-charwidth) ? (chatx + 2 + c+charwidth) : (chatx);	// we may have to go down.
+			int cursory = (cursorx != chatx) ? (y) : (y+charheight);
+			V_DrawChatCharacter(cursorx, cursory+1, '_' |V_SNAPTOTOP|V_SNAPTORIGHT|t, !cv_allcaps.value, NULL);	
+		}	
+		
+		//Hurdler: isn't it better like that?
+		if (w_chat[i] < HU_FONTSTART)
+			++i;
+		else
+			V_DrawChatCharacter(chatx + c + 2, y, w_chat[i++] | V_SNAPTOTOP|V_SNAPTORIGHT | t, !cv_allcaps.value, NULL);
+
+		c += charwidth;
+		if (c > cv_chatwidth.value-charwidth)
+		{
+			c = 0;
+			y += charheight;
+			typelines += 1;
+		}
+	}
+
+	// handle /pm list.
+	if (strnicmp(w_chat, "/pm", 3) == 0 && vid.width >= 400 && !teamtalk)	// 320x200 unsupported kthxbai
+	{	
+		i = 0;
+		int count = 0;
+		INT32 p_dispy = chaty+2;
+		V_DrawFillConsoleMap(chatx-50, p_dispy-2, 48, 2, 239 | V_SNAPTOTOP | V_SNAPTORIGHT);	// top (don't mind me)
+		for(i=0; (i<MAXPLAYERS); i++)
+		{
+			
+			// filter: (code needs optimization pls help I'm bad with C)
+			if (w_chat[3])
+			{
+				
+				// right, that's half important: (w_chat[4] may be a space since /pm0 msg is perfectly acceptable!)
+				if ( ( ((w_chat[3] != 0) && ((w_chat[3] < '0') || (w_chat[3] > '9'))) || ((w_chat[4] != 0) && (((w_chat[4] < '0') || (w_chat[4] > '9'))))) && (w_chat[4] != ' '))
+					break;
+					
+				
+				char *nodenum = (char*) malloc(3);
+				strncpy(nodenum, w_chat+3, 4);
+				INT32 n = atoi((const char*) nodenum);	// turn that into a number
+				// special cases:
+				
+				if ((n == 0) && !(w_chat[4] == '0'))
+				{	
+					if (!(i<10))
+						continue;		
+				}
+				else if ((n == 1) && !(w_chat[3] == '0'))
+				{	
+					if (!((i == 1) || ((i >= 10) && (i <= 19))))
+						continue;
+				}
+				else if ((n == 2) && !(w_chat[3] == '0'))
+				{	
+					if (!((i == 2) || ((i >= 20) && (i <= 29))))
+						continue;
+				}
+				else if ((n == 3) && !(w_chat[3] == '0'))
+				{	
+					if (!((i == 3) || ((i >= 30) && (i <= 31))))
+						continue;
+				}
+				else	// general case.
+				{	
+					if (i != n)
+						continue;
+				}
+			}
+			
+			if ((playeringame[i]))
+			{	
+				char name[MAXPLAYERNAME+1];
+				strlcpy(name, player_names[i], 7);	// shorten name to 7 characters.
+				V_DrawFillConsoleMap(chatx-50, p_dispy+ (6*count), 48, 6, 239 | V_SNAPTOTOP | V_SNAPTORIGHT);	// fill it like the chat so the text doesn't become hard to read because of the hud.
+				V_DrawSmallString(chatx-48, p_dispy+ (6*count), V_SNAPTOTOP|V_SNAPTORIGHT|V_ALLOWLOWERCASE, va("\x82%d\x80 - %s", i, name));
+				count++;
+			}
+		}
+		if (count == 0)	// no results.
+		{
+			V_DrawFillConsoleMap(chatx-50, p_dispy+ (6*count), 48, 6, 239 | V_SNAPTOTOP | V_SNAPTORIGHT);	// fill it like the chat so the text doesn't become hard to read because of the hud.
+			V_DrawSmallString(chatx-48, p_dispy+ (6*count), V_SNAPTOTOP|V_SNAPTORIGHT|V_ALLOWLOWERCASE, "NO RESULT.");
+		}	
+	}
+	
+}
+
+// why the fuck would you use this...
+
+static void HU_DrawChat_Old(void)
 {
 	INT32 t = 0, c = 0, y = HU_INPUTY;
 	size_t i = 0;
@@ -850,7 +1569,6 @@ static void HU_DrawChat(void)
 	const char *talk = ntalk;
 	INT32 charwidth = 8 * con_scalefactor; //SHORT(hu_font['A'-HU_FONTSTART]->width) * con_scalefactor;
 	INT32 charheight = 8 * con_scalefactor; //SHORT(hu_font['A'-HU_FONTSTART]->height) * con_scalefactor;
-
 	if (teamtalk)
 	{
 		talk = ttalk;
@@ -876,10 +1594,21 @@ static void HU_DrawChat(void)
 		}
 		c += charwidth;
 	}
-
+	
+	if ((strlen(w_chat) == 0 || c_input == 0) && hu_tick < 4)
+		V_DrawCharacter(HU_INPUTX+c, y+2*con_scalefactor, '_' |cv_constextsize.value | V_NOSCALESTART|t, !cv_allcaps.value);
+	
 	i = 0;
 	while (w_chat[i])
 	{
+		
+		if (c_input == (i+1) && hu_tick < 4)
+		{
+			int cursorx = (HU_INPUTX+c+charwidth < vid.width) ? (HU_INPUTX + c + charwidth) : (HU_INPUTX);	// we may have to go down.
+			int cursory = (cursorx != HU_INPUTX) ? (y) : (y+charheight);
+			V_DrawCharacter(cursorx, cursory+2*con_scalefactor, '_' |cv_constextsize.value | V_NOSCALESTART|t, !cv_allcaps.value);	
+		}	
+		
 		//Hurdler: isn't it better like that?
 		if (w_chat[i] < HU_FONTSTART)
 		{
@@ -899,12 +1628,8 @@ static void HU_DrawChat(void)
 			y += charheight;
 		}
 	}
-
-	if (hu_tick < 4)
-		V_DrawCharacter(HU_INPUTX + c, y, '_' | cv_constextsize.value |V_NOSCALESTART|t, !cv_allcaps.value);
 }
 
-
 // draw the Crosshair, at the exact center of the view.
 //
 // Crosshairs are pre-cached at HU_Init
@@ -1175,7 +1900,45 @@ void HU_Drawer(void)
 {
 	// draw chat string plus cursor
 	if (chat_on)
-		HU_DrawChat();
+	{	
+		// count down the scroll timer. 
+		if (chat_scrolltime > 0)
+			chat_scrolltime--;
+		if (!cv_consolechat.value)
+			HU_DrawChat();
+		else
+			HU_DrawChat_Old();	// why the fuck.........................
+	}
+	else
+	{
+		if (!cv_consolechat.value)
+		{	
+			HU_drawMiniChat();		// draw messages in a cool fashion.
+			chat_scrolltime = 0;	// do scroll anyway.
+			typelines = 0;			// make sure that the chat doesn't have a weird blinking huge ass square if we typed a lot last time.
+		}	
+	}
+	
+	if (netgame)	// would handle that in hu_drawminichat, but it's actually kinda awkward when you're typing a lot of messages. (only handle that in netgames duh)
+	{
+		size_t i = 0;
+		
+		// handle spam while we're at it:
+		for(; (i<MAXPLAYERS); i++)
+		{	
+			if (stop_spamming_you_cunt[i] > 0)
+				stop_spamming_you_cunt[i]--;
+		}	
+		
+		// handle chat timers
+		for (i=0; (i<chat_nummsg_min); i++)
+		{	
+			if (chat_timers[i] > 0)
+				chat_timers[i]--;
+			else
+				HU_removeChatText_Mini();
+		}
+	}
 
 	if (cechotimer)
 		HU_DrawCEcho();
@@ -1319,6 +2082,40 @@ void HU_Erase(void)
 //                   IN-LEVEL MULTIPLAYER RANKINGS
 //======================================================================
 
+//
+// HU_drawPing
+//
+void HU_drawPing(INT32 x, INT32 y, INT32 ping, boolean notext)
+{
+	UINT8 numbars = 1;		// how many ping bars do we draw?
+	UINT8 barcolor = 128;	// color we use for the bars (green, yellow or red)
+	SINT8 i = 0;
+	SINT8 yoffset = 6;
+	if (ping < 128)
+	{	
+		numbars = 3;
+		barcolor = 184;
+	}	
+	else if (ping < 256)
+	{	
+		numbars = 2;	// Apparently ternaries w/ multiple statements don't look good in C so I decided against it.
+		barcolor = 103;
+	}	
+	
+	INT32 dx = x+1 - (V_SmallStringWidth(va("%dms", ping), V_ALLOWLOWERCASE)/2);
+	if (!notext || vid.width >= 640)	// how sad, we're using a shit resolution.
+		V_DrawSmallString(dx, y+4, V_ALLOWLOWERCASE, va("%dms", ping));
+	
+	for (i=0; (i<3); i++)		// Draw the ping bar
+	{	
+		V_DrawFill(x+2 *(i-1), y+yoffset-4, 2, 8-yoffset, 31);
+		if (i < numbars)
+			V_DrawFill(x+2 *(i-1), y+yoffset-3, 1, 8-yoffset-1, barcolor);
+		
+		yoffset -= 2;
+	}
+}	
+
 //
 // HU_DrawTabRankings
 //
@@ -1336,7 +2133,13 @@ void HU_DrawTabRankings(INT32 x, INT32 y, playersort_t *tab, INT32 scorelines, I
 	{
 		if (players[tab[i].num].spectator)
 			continue; //ignore them.
-
+		
+		if (!splitscreen)	// don't draw it on splitscreen,
+		{
+			if (!(tab[i].num == serverplayer))
+				HU_drawPing(x+ 253, y+2, playerpingtable[tab[i].num], false);
+		}	
+		
 		V_DrawString(x + 20, y,
 		             ((tab[i].num == whiteplayer) ? V_YELLOWMAP : 0)
 		             | ((players[tab[i].num].health > 0) ? 0 : V_60TRANS)
@@ -1493,6 +2296,11 @@ void HU_DrawTeamTabRankings(playersort_t *tab, INT32 whiteplayer)
 				V_DrawSmallMappedPatch (x, y-4, 0, faceprefix[players[tab[i].num].skin], colormap);
 		}
 		V_DrawRightAlignedThinString(x+120, y-1, ((players[tab[i].num].health > 0) ? 0 : V_TRANSLUCENT), va("%u", tab[i].count));
+		if (!splitscreen)
+		{	
+			if (!(tab[i].num == serverplayer))
+				HU_drawPing(x+ 113, y+2, playerpingtable[tab[i].num], false);
+		}	
 	}
 }
 
@@ -1515,6 +2323,8 @@ void HU_DrawDualTabRankings(INT32 x, INT32 y, playersort_t *tab, INT32 scoreline
 			continue; //ignore them.
 
 		strlcpy(name, tab[i].name, 9);
+		if (!(tab[i].num == serverplayer))
+			HU_drawPing(x+ 113, y+2, playerpingtable[tab[i].num], false);
 		V_DrawString(x + 20, y,
 		             ((tab[i].num == whiteplayer) ? V_YELLOWMAP : 0)
 		             | ((players[tab[i].num].health > 0) ? 0 : V_TRANSLUCENT)
diff --git a/src/hu_stuff.h b/src/hu_stuff.h
index 451cc8d8..2a99be4b 100644
--- a/src/hu_stuff.h
+++ b/src/hu_stuff.h
@@ -80,6 +80,11 @@ extern patch_t *tagico;
 extern patch_t *tallminus;
 extern patch_t *iconprefix[MAXSKINS];
 
+#define CHAT_BUFSIZE 64		// that's enough messages, right? We'll delete the older ones when that gets out of hand.
+
+// some functions
+void HU_AddChatText(const char *text);
+
 // set true when entering a chat message
 extern boolean chat_on;
 
@@ -105,6 +110,7 @@ char HU_dequeueChatChar(void);
 void HU_Erase(void);
 void HU_clearChatChars(void);
 void HU_DrawTabRankings(INT32 x, INT32 y, playersort_t *tab, INT32 scorelines, INT32 whiteplayer);
+void HU_drawPing(INT32 x, INT32 y, INT32 ping, boolean notext);	// Lat': Ping drawer for scoreboard.
 void HU_DrawTeamTabRankings(playersort_t *tab, INT32 whiteplayer);
 void HU_DrawDualTabRankings(INT32 x, INT32 y, playersort_t *tab, INT32 scorelines, INT32 whiteplayer);
 void HU_DrawEmeralds(INT32 x, INT32 y, INT32 pemeralds);
diff --git a/src/lua_baselib.c b/src/lua_baselib.c
index b49cdd72..5cdd31f0 100644
--- a/src/lua_baselib.c
+++ b/src/lua_baselib.c
@@ -86,6 +86,51 @@ static int lib_print(lua_State *L)
 	return 0;
 }
 
+// Print stuff in the chat, or in the console if we can't.
+static int lib_chatprint(lua_State *L)
+{
+	const char *str = luaL_checkstring(L, 1);	// retrieve string
+	if (str == NULL)	// error if we don't have a string!
+		return luaL_error(L, LUA_QL("tostring") " must return a string to " LUA_QL("chatprint"));
+	int len = strlen(str);
+	if (len > 255)	// string is too long!!!
+		return luaL_error(L, "String exceeds the 255 characters limit of the chat buffer.");
+	
+	if (cv_consolechat.value || !netgame)
+		CONS_Printf("%s\n", str);
+	else
+		HU_AddChatText(str);
+	return 0;
+}
+
+// Same as above, but do it for only one player.
+static int lib_chatprintf(lua_State *L)
+{
+	int n = lua_gettop(L);  /* number of arguments */
+	player_t *plr;
+	if (n < 2)
+		return luaL_error(L, "chatprintf requires at least two arguments: player and text.");
+	
+	plr = *((player_t **)luaL_checkudata(L, 1, META_PLAYER));	// retrieve player
+	if (!plr)
+		return LUA_ErrInvalid(L, "player_t");
+	if (plr != &players[consoleplayer])
+		return 0;
+	
+	const char *str = luaL_checkstring(L, 2);	// retrieve string
+	if (str == NULL)	// error if we don't have a string!
+		return luaL_error(L, LUA_QL("tostring") " must return a string to " LUA_QL("chatprintf"));
+	int len = strlen(str);
+	if (len > 255)	// string is too long!!!
+		return luaL_error(L, "String exceeds the 255 characters limit of the chat buffer.");
+	
+	if (cv_consolechat.value || !netgame)
+		CONS_Printf("%s\n", str);
+	else
+		HU_AddChatText(str);
+	return 0;
+}
+
 static int lib_evalMath(lua_State *L)
 {
 	const char *word = luaL_checkstring(L, 1);
@@ -2165,6 +2210,8 @@ static int lib_kGetKartFlashing(lua_State *L)
 
 static luaL_Reg lib[] = {
 	{"print", lib_print},
+	{"chatprint", lib_chatprint},
+	{"chatprintf", lib_chatprintf},
 	{"EvalMath", lib_evalMath},
 
 	// m_random
diff --git a/src/lua_hook.h b/src/lua_hook.h
index 53e0a7d8..7acc0d0f 100644
--- a/src/lua_hook.h
+++ b/src/lua_hook.h
@@ -74,7 +74,7 @@ boolean LUAh_MobjDeath(mobj_t *target, mobj_t *inflictor, mobj_t *source); // Ho
 boolean LUAh_BotTiccmd(player_t *bot, ticcmd_t *cmd); // Hook for B_BuildTiccmd
 boolean LUAh_BotAI(mobj_t *sonic, mobj_t *tails, ticcmd_t *cmd); // Hook for B_BuildTailsTiccmd by skin name
 boolean LUAh_LinedefExecute(line_t *line, mobj_t *mo, sector_t *sector); // Hook for linedef executors
-boolean LUAh_PlayerMsg(int source, int target, int flags, char *msg); // Hook for chat messages
+boolean LUAh_PlayerMsg(int source, int target, int flags, char *msg, int mute); // Hook for chat messages
 boolean LUAh_HurtMsg(player_t *player, mobj_t *inflictor, mobj_t *source); // Hook for hurt messages
 #define LUAh_PlayerSpawn(player) LUAh_PlayerHook(player, hook_PlayerSpawn) // Hook for G_SpawnPlayer
 
diff --git a/src/lua_hooklib.c b/src/lua_hooklib.c
index eadd0153..5b05b77c 100644
--- a/src/lua_hooklib.c
+++ b/src/lua_hooklib.c
@@ -952,7 +952,9 @@ boolean LUAh_LinedefExecute(line_t *line, mobj_t *mo, sector_t *sector)
 }
 
 // Hook for player chat
-boolean LUAh_PlayerMsg(int source, int target, int flags, char *msg)
+// Added the "mute" field. It's set to true if the message was supposed to be eaten by spam protection. 
+// But for netgame consistency purposes, this hook is ran first reguardless, so this boolean allows for modders to adapt if they so desire.
+boolean LUAh_PlayerMsg(int source, int target, int flags, char *msg, int mute)
 {
 	hook_p hookp;
 	boolean hooked = false;
@@ -981,14 +983,19 @@ boolean LUAh_PlayerMsg(int source, int target, int flags, char *msg)
 					LUA_PushUserdata(gL, &players[target-1], META_PLAYER); // target
 				}
 				lua_pushstring(gL, msg); // msg
+				if (mute)
+					lua_pushboolean(gL, true); // the message was supposed to be eaten by spamprotecc.
+				else
+					lua_pushboolean(gL, false);	
 			}
 			lua_pushfstring(gL, FMT_HOOKID, hookp->id);
 			lua_gettable(gL, LUA_REGISTRYINDEX);
-			lua_pushvalue(gL, -5);
-			lua_pushvalue(gL, -5);
-			lua_pushvalue(gL, -5);
-			lua_pushvalue(gL, -5);
-			if (lua_pcall(gL, 4, 1, 0)) {
+			lua_pushvalue(gL, -6);
+			lua_pushvalue(gL, -6);
+			lua_pushvalue(gL, -6);
+			lua_pushvalue(gL, -6);
+			lua_pushvalue(gL, -6);
+			if (lua_pcall(gL, 5, 1, 0)) {
 				if (!hookp->error || cv_debug & DBG_LUA)
 					CONS_Alert(CONS_WARNING,"%s\n",lua_tostring(gL, -1));
 				lua_pop(gL, 1);
diff --git a/src/v_video.c b/src/v_video.c
index ac0eed17..44319dd7 100644
--- a/src/v_video.c
+++ b/src/v_video.c
@@ -303,7 +303,7 @@ void VID_BlitLinearScreen(const UINT8 *srcptr, UINT8 *destptr, INT32 width, INT3
 #endif
 }
 
-//static UINT8 hudplusalpha[11]  = { 10,  8,  6,  4,  2,  0,  0,  0,  0,  0,  0};
+static UINT8 hudplusalpha[11]  = { 10,  8,  6,  4,  2,  0,  0,  0,  0,  0,  0};
 static UINT8 hudminusalpha[11] = { 10,  9,  9,  8,  8,  7,  7,  6,  6,  5,  5};
 
 static const UINT8 *v_colormap = NULL;
@@ -840,6 +840,129 @@ void V_DrawFill(INT32 x, INT32 y, INT32 w, INT32 h, INT32 c)
 		memset(dest, (UINT8)(c&255), w * vid.bpp);
 }
 
+// THANK YOU MPC!!!
+
+void V_DrawFillConsoleMap(INT32 x, INT32 y, INT32 w, INT32 h, INT32 c)
+{
+	UINT8 *dest;
+    INT32 u, v;
+	UINT32 alphalevel = 0;
+
+	if (rendermode == render_none)
+		return;
+
+#ifdef HWRENDER
+	if (rendermode != render_soft && rendermode != render_none)
+	{
+		UINT32 hwcolor;
+		switch (cons_backcolor.value)
+		{
+			case 0:		hwcolor = 0xffffff00;	break; // White
+			case 1:		hwcolor = 0x80808000;	break; // Gray
+			case 2:		hwcolor = 0x40201000;	break; // Brown
+			case 3:		hwcolor = 0xff000000;	break; // Red
+			case 4:		hwcolor = 0xff800000;	break; // Orange
+			case 5:		hwcolor = 0x80800000;	break; // Yellow
+			case 6:		hwcolor = 0x00800000;	break; // Green
+			case 7:		hwcolor = 0x0000ff00;	break; // Blue
+			case 8:		hwcolor = 0x4080ff00;	break; // Cyan
+			// Default green
+			default:	hwcolor = 0x00800000;	break;
+		}
+		HWR_DrawConsoleFill(x, y, w, h, hwcolor, c);	// we still use the regular color stuff but only for flags. actual draw color is "hwcolor" for this.
+		return;
+	}
+#endif
+
+	if (!(c & V_NOSCALESTART))
+	{
+		INT32 dupx = vid.dupx, dupy = vid.dupy;
+
+		if (x == 0 && y == 0 && w == BASEVIDWIDTH && h == BASEVIDHEIGHT)
+		{ // Clear the entire screen, from dest to deststop. Yes, this really works.
+			memset(screens[0], (UINT8)(c&255), vid.width * vid.height * vid.bpp);
+			return;
+		}
+
+		x *= dupx;
+		y *= dupy;
+		w *= dupx;
+		h *= dupy;
+
+		// Center it if necessary
+		if (vid.width != BASEVIDWIDTH * dupx)
+		{
+			// dupx adjustments pretend that screen width is BASEVIDWIDTH * dupx,
+			// so center this imaginary screen
+			if (c & V_SNAPTORIGHT)
+				x += (vid.width - (BASEVIDWIDTH * dupx));
+			else if (!(c & V_SNAPTOLEFT))
+				x += (vid.width - (BASEVIDWIDTH * dupx)) / 2;
+		}
+		if (vid.height != BASEVIDHEIGHT * dupy)
+		{
+			// same thing here
+			if (c & V_SNAPTOBOTTOM)
+				y += (vid.height - (BASEVIDHEIGHT * dupy));
+			else if (!(c & V_SNAPTOTOP))
+				y += (vid.height - (BASEVIDHEIGHT * dupy)) / 2;
+		}
+	}
+
+	if (x >= vid.width || y >= vid.height)
+		return; // off the screen
+	if (x < 0) {
+		w += x;
+		x = 0;
+	}
+	if (y < 0) {
+		h += y;
+		y = 0;
+	}
+
+	if (w <= 0 || h <= 0)
+		return; // zero width/height wouldn't draw anything
+	if (x + w > vid.width)
+		w = vid.width-x;
+	if (y + h > vid.height)
+		h = vid.height-y;
+
+	dest = screens[0] + y*vid.width + x;
+
+	if ((alphalevel = ((c & V_ALPHAMASK) >> V_ALPHASHIFT)))
+	{
+		if (alphalevel == 13)
+			alphalevel = hudminusalpha[cv_translucenthud.value];
+		else if (alphalevel == 14)
+			alphalevel = 10 - cv_translucenthud.value;
+		else if (alphalevel == 15)
+			alphalevel = hudplusalpha[cv_translucenthud.value];
+
+		if (alphalevel >= 10)
+			return; // invis
+	}
+
+	c &= 255;
+
+	if (!alphalevel) {
+        for (v = 0; v < h; v++, dest += vid.width) {
+            for (u = 0; u < w; u++) {
+                dest[u] = consolebgmap[dest[u]];
+            }
+        }
+	} else {        // mpc 12-04-2018
+        const UINT8 *fadetable = ((UINT8 *)transtables + ((alphalevel-1)<<FF_TRANSSHIFT) + (c*256));
+        #define clip(x,y) (x>y) ? y : x
+        w = clip(w,vid.width);
+        h = clip(h,vid.height);
+        for (v = 0; v < h; v++, dest += vid.width) {
+            for (u = 0; u < w; u++) {
+                dest[u] = fadetable[consolebgmap[dest[u]]];
+            }
+        }
+	}
+}
+
 //
 // Fills a box of pixels using a flat texture as a pattern, scaled to screen size.
 //
@@ -1060,6 +1183,32 @@ void V_DrawCharacter(INT32 x, INT32 y, INT32 c, boolean lowercaseallowed)
 		V_DrawScaledPatch(x, y, flags, hu_font[c]);
 }
 
+// Writes a single character for the chat. (draw WHITE if bit 7 set)
+// Essentially the same as the above but it's small or big depending on what resolution you've chosen to huge..
+//
+void V_DrawChatCharacter(INT32 x, INT32 y, INT32 c, boolean lowercaseallowed, UINT8 *colormap)
+{
+	INT32 w, flags;
+	//const UINT8 *colormap = V_GetStringColormap(c);
+
+	flags = c & ~(V_CHARCOLORMASK | V_PARAMMASK);
+	c &= 0x7f;
+	if (lowercaseallowed)
+		c -= HU_FONTSTART;
+	else
+		c = toupper(c) - HU_FONTSTART;
+	if (c < 0 || c >= HU_FONTSIZE || !hu_font[c])
+		return;
+
+	w = (vid.width < 640 ) ? (SHORT(hu_font[c]->width)/2) : (SHORT(hu_font[c]->width));	// use normal sized characters if we're using a terribly low resolution.
+	if (x + w > vid.width)
+		return;
+	
+	V_DrawFixedPatch(x*FRACUNIT, y*FRACUNIT, (vid.width < 640) ? (FRACUNIT) : (FRACUNIT/2), flags, hu_font[c], colormap);
+
+	
+}
+
 // Precompile a wordwrapped string to any given width.
 // This is a muuuch better method than V_WORDWRAP.
 char *V_WordWrap(INT32 x, INT32 w, INT32 option, const char *string)
diff --git a/src/v_video.h b/src/v_video.h
index 990f9b13..ffa1038c 100644
--- a/src/v_video.h
+++ b/src/v_video.h
@@ -139,6 +139,7 @@ void V_DrawScaledPic (INT32 px1, INT32 py1, INT32 scrn, INT32 lumpnum);
 
 // fill a box with a single color
 void V_DrawFill(INT32 x, INT32 y, INT32 w, INT32 h, INT32 c);
+void V_DrawFillConsoleMap(INT32 x, INT32 y, INT32 w, INT32 h, INT32 c);
 // fill a box with a flat as a pattern
 void V_DrawFlatFill(INT32 x, INT32 y, INT32 w, INT32 h, lumpnum_t flatnum);
 
@@ -149,6 +150,8 @@ void V_DrawFadeConsBack(INT32 plines);
 
 // draw a single character
 void V_DrawCharacter(INT32 x, INT32 y, INT32 c, boolean lowercaseallowed);
+// draw a single character, but for the chat
+void V_DrawChatCharacter(INT32 x, INT32 y, INT32 c, boolean lowercaseallowed, UINT8 *colormap);
 
 void V_DrawLevelTitle(INT32 x, INT32 y, INT32 option, const char *string);
 

From 0dddf7623a1afcfb8b9390a02fdbe5e9574c5a27 Mon Sep 17 00:00:00 2001
From: toaster <rollerorbital@gmail.com>
Date: Sun, 29 Jul 2018 23:07:10 +0100
Subject: [PATCH 02/10] Buggy netgame! Sorry yalls. * Fix free play on
 intermission. * Fix crash in killing/damaging mobj with null death/pain
 state.

---
 src/p_inter.c | 27 +++++++++++++++------------
 src/y_inter.c | 21 ++-------------------
 2 files changed, 17 insertions(+), 31 deletions(-)

diff --git a/src/p_inter.c b/src/p_inter.c
index 474cf148..6ca5e6c2 100644
--- a/src/p_inter.c
+++ b/src/p_inter.c
@@ -3492,22 +3492,25 @@ boolean P_DamageMobj(mobj_t *target, mobj_t *inflictor, mobj_t *source, INT32 da
 			break;
 		}
 
-	target->reactiontime = 0; // we're awake now...
-
-	if (source && source != target)
+	if (!P_MobjWasRemoved(target))
 	{
-		// if not intent on another player,
-		// chase after this one
-		P_SetTarget(&target->target, source);
-		if (target->state == &states[target->info->spawnstate] && target->info->seestate != S_NULL)
+		target->reactiontime = 0; // we're awake now...
+
+		if (source && source != target)
 		{
-			if (player)
+			// if not intent on another player,
+			// chase after this one
+			P_SetTarget(&target->target, source);
+			if (target->state == &states[target->info->spawnstate] && target->info->seestate != S_NULL)
 			{
-				if (!(player->powers[pw_super] && ALL7EMERALDS(player->powers[pw_emeralds])))
-					P_SetPlayerMobjState(target, target->info->seestate);
+				if (player)
+				{
+					if (!(player->powers[pw_super] && ALL7EMERALDS(player->powers[pw_emeralds])))
+						P_SetPlayerMobjState(target, target->info->seestate);
+				}
+				else
+					P_SetMobjState(target, target->info->seestate);
 			}
-			else
-				P_SetMobjState(target, target->info->seestate);
 		}
 	}
 
diff --git a/src/y_inter.c b/src/y_inter.c
index a77c12a0..cb171ed9 100644
--- a/src/y_inter.c
+++ b/src/y_inter.c
@@ -493,25 +493,8 @@ void Y_IntermissionDrawer(void)
 
 dotimer:
 
-	if (netgame) //  FREE PLAY?
-	{
-		i = MAXPLAYERS;
-
-		if (!forcefreeplay)
-		{
-			// check to see if there's anyone else at all
-			for (i = 0; i < MAXPLAYERS; i++)
-			{
-				if (i == consoleplayer)
-					continue;
-				if (playeringame[i] && !stplyr->spectator)
-					break;
-			}
-		}
-
-		if (i == MAXPLAYERS)
-			K_drawKartFreePlay(intertic);
-	}
+	if (netgame && forcefreeplay) // FREE PLAY?
+		K_drawKartFreePlay(intertic);
 
 	if (timer)
 	{

From 65a956259b597fd15818d2b0b6b6c352df725b80 Mon Sep 17 00:00:00 2001
From: toaster <rollerorbital@gmail.com>
Date: Sun, 29 Jul 2018 23:51:08 +0100
Subject: [PATCH 03/10] * Re-enable kartvoices controls for K_PlayTauntSound
 and K_PlayOvertakeSound. * Make the three P_Play<?>Sounds from p_local.h
 actual functions that acknowledge the kartvoices cvar.

---
 src/k_kart.c  |  4 ++--
 src/p_local.h |  6 +++---
 src/p_user.c  | 25 +++++++++++++++++++++++++
 3 files changed, 30 insertions(+), 5 deletions(-)

diff --git a/src/k_kart.c b/src/k_kart.c
index 50d03c1e..d546a06f 100644
--- a/src/k_kart.c
+++ b/src/k_kart.c
@@ -1339,7 +1339,7 @@ static void K_RegularVoiceTimers(player_t *player)
 
 static void K_PlayTauntSound(mobj_t *source)
 {
-#if 0
+#if 1
 	sfxenum_t pick = P_RandomKey(4); // Gotta roll the RNG every time this is called for sync reasons
 	boolean tasteful = (!source->player || !source->player->kartstuff[k_tauntvoices]);
 
@@ -1362,7 +1362,7 @@ static void K_PlayTauntSound(mobj_t *source)
 
 static void K_PlayOvertakeSound(mobj_t *source)
 {
-#if 0
+#if 1
 	boolean tasteful = (!source->player || !source->player->kartstuff[k_voices]);
 
 	if (!G_RaceGametype()) // Only in race
diff --git a/src/p_local.h b/src/p_local.h
index 42b70543..3bf98bee 100644
--- a/src/p_local.h
+++ b/src/p_local.h
@@ -194,9 +194,9 @@ void P_SpawnSpinMobj(player_t *player, mobjtype_t type);
 void P_Telekinesis(player_t *player, fixed_t thrust, fixed_t range);
 
 void P_PlayLivesJingle(player_t *player);
-#define P_PlayRinglossSound(s)	S_StartSound(s, (mariomode) ? sfx_mario8 : sfx_altow1 + P_RandomKey(4));
-#define P_PlayDeathSound(s)		S_StartSound(s, sfx_altdi1 + P_RandomKey(4));
-#define P_PlayVictorySound(s)	S_StartSound(s, sfx_victr1 + P_RandomKey(4));
+void P_PlayRinglossSound(mobj_t *source);
+void P_PlayDeathSound(mobj_t *source);
+void P_PlayVictorySound(mobj_t *source);
 
 
 //
diff --git a/src/p_user.c b/src/p_user.c
index f33aeffd..9ba02714 100644
--- a/src/p_user.c
+++ b/src/p_user.c
@@ -1118,6 +1118,31 @@ void P_PlayLivesJingle(player_t *player)
 	}
 }
 
+void P_PlayRinglossSound(mobj_t *source)
+{
+	sfxenum_t key = P_RandomKey(4);
+	if (cv_kartvoices.value)
+		S_StartSound(source, (mariomode) ? sfx_mario8 : sfx_altow1 + key);
+	else
+		S_StartSound(source, sfx_slip);
+}
+
+void P_PlayDeathSound(mobj_t *source)
+{
+	sfxenum_t key = P_RandomKey(4);
+	if (cv_kartvoices.value)
+		S_StartSound(source, sfx_altdi1 + key);
+	else
+		S_StartSound(source, sfx_s3k35);
+}
+
+void P_PlayVictorySound(mobj_t *source)
+{
+	sfxenum_t key = P_RandomKey(4);
+	if (cv_kartvoices.value)
+		S_StartSound(source, sfx_victr1 + key);
+}
+
 //
 // P_EndingMusic
 //

From 7f509c7c2737084dae76b39298af8d165bbe804a Mon Sep 17 00:00:00 2001
From: toaster <rollerorbital@gmail.com>
Date: Mon, 30 Jul 2018 21:53:54 +0100
Subject: [PATCH 04/10] Some UI stuff. * Place FREE PLAY in a less contentous
 location. * Fix comeback timer being incorrectly offset from the center of
 the screen. * Prevent vote drawer from nuking itself (visual-wise) at the
 start of the level fade following it.

---
 src/k_kart.c  | 25 ++++++++++++-------------
 src/y_inter.c | 10 +++++-----
 2 files changed, 17 insertions(+), 18 deletions(-)

diff --git a/src/k_kart.c b/src/k_kart.c
index d546a06f..6792895a 100644
--- a/src/k_kart.c
+++ b/src/k_kart.c
@@ -5730,19 +5730,16 @@ static void K_drawBattleFullscreen(void)
 	}
 	else if (stplyr->kartstuff[k_bumper] <= 0 && stplyr->kartstuff[k_comebacktimer] && comeback)
 	{
-		INT32 t = stplyr->kartstuff[k_comebacktimer]/TICRATE;
-		INT32 txoff = 0;
+		UINT16 t = stplyr->kartstuff[k_comebacktimer]/(10*TICRATE);
+		INT32 txoff, adjust = (splitscreen > 1) ? 4 : 6; // normal string is 8, kart string is 12, half of that for ease
 		INT32 ty = (BASEVIDHEIGHT/2)+66;
 
-		if (t == 0)
-			txoff = 8;
-		else
+		txoff = adjust;
+
+		while (t)
 		{
-			while (t)
-			{
-				txoff += 8;
-				t /= 10;
-			}
+			txoff += adjust;
+			t /= 10;
 		}
 
 		if (splitscreen)
@@ -5763,7 +5760,7 @@ static void K_drawBattleFullscreen(void)
 			V_DrawFixedPatch(x<<FRACBITS, y<<FRACBITS, scale, splitflags, kp_battlewait, NULL);
 
 		if (splitscreen > 1)
-			V_DrawString(x-(txoff/2), ty, 0, va("%d", stplyr->kartstuff[k_comebacktimer]/TICRATE));
+			V_DrawString(x-txoff, ty, 0, va("%d", stplyr->kartstuff[k_comebacktimer]/TICRATE));
 		else
 		{
 			V_DrawFixedPatch(x<<FRACBITS, ty<<FRACBITS, scale, 0, kp_timeoutsticker, NULL);
@@ -6054,11 +6051,13 @@ static void K_drawCheckpointDebugger(void)
 
 void K_drawKartFreePlay(UINT32 flashtime)
 {
+	// no splitscreen support because it's not FREE PLAY if you have more than one player in-game
+
 	if ((flashtime % TICRATE) < TICRATE/2)
 		return;
 
-	V_DrawKartString(BASEVIDWIDTH/2 - (6*9), // horizontally centered, nice
-		LAPS_Y+3, V_SNAPTOBOTTOM, "FREE PLAY");
+	V_DrawKartString((BASEVIDWIDTH - (LAPS_X+1)) - (12*9), // mirror the laps thingy
+		LAPS_Y+3, V_SNAPTOBOTTOM|V_SNAPTORIGHT, "FREE PLAY");
 }
 
 void K_drawKartHUD(void)
diff --git a/src/y_inter.c b/src/y_inter.c
index cb171ed9..f07e8e2f 100644
--- a/src/y_inter.c
+++ b/src/y_inter.c
@@ -499,13 +499,13 @@ dotimer:
 	if (timer)
 	{
 		INT32 tickdown = (timer+1)/TICRATE;
-		V_DrawCenteredString(BASEVIDWIDTH/2, 188, hilicol|V_SNAPTOBOTTOM,
+		V_DrawCenteredString(BASEVIDWIDTH/2, 188, hilicol,
 			va("start in %d second%s", tickdown, (tickdown == 1 ? "" : "s")));
 	}
 
 	// Make it obvious that scrambling is happening next round.
 	if (cv_scrambleonchange.value && cv_teamscramble.value && (intertic/TICRATE % 2 == 0))
-		V_DrawCenteredString(BASEVIDWIDTH/2, BASEVIDHEIGHT/2, hilicol|V_SNAPTOBOTTOM, M_GetText("Teams will be scrambled next round!"));
+		V_DrawCenteredString(BASEVIDWIDTH/2, BASEVIDHEIGHT/2, hilicol, M_GetText("Teams will be scrambled next round!"));
 }
 
 //
@@ -936,11 +936,11 @@ void Y_VoteDrawer(void)
 	if (votetic >= voteendtic && voteendtic != -1)
 		return;
 
-	V_DrawFill(0, 0, BASEVIDWIDTH, BASEVIDHEIGHT, 31);
-
 	if (!voteclient.loaded)
 		return;
 
+	V_DrawFill(0, 0, BASEVIDWIDTH, BASEVIDHEIGHT, 31);
+
 	if (widebgpatch && rendermode == render_soft && vid.width / vid.dupx > 320)
 		V_DrawScaledPatch(((vid.width/2) / vid.dupx) - (SHORT(widebgpatch->width)/2),
 							(vid.height / vid.dupy) - SHORT(widebgpatch->height),
@@ -1138,7 +1138,7 @@ void Y_VoteDrawer(void)
 			hilicol = V_SKYMAP;
 		else //if (gametype == GT_MATCH)
 			hilicol = V_REDMAP;
-		V_DrawCenteredString(BASEVIDWIDTH/2, 188, hilicol|V_SNAPTOBOTTOM,
+		V_DrawCenteredString(BASEVIDWIDTH/2, 188, hilicol,
 			va("Vote ends in %d second%s", tickdown, (tickdown == 1 ? "" : "s")));
 	}
 }

From 057bc4120305a112ce57f4380c03ea8145feabb6 Mon Sep 17 00:00:00 2001
From: toaster <rollerorbital@gmail.com>
Date: Mon, 30 Jul 2018 22:07:28 +0100
Subject: [PATCH 05/10] Fix dropped else in tab rankings view, leading to the
 exiting text being drawn on top of other text for no good reason.

---
 src/hu_stuff.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/hu_stuff.c b/src/hu_stuff.c
index fd71470b..dd08d26e 100644
--- a/src/hu_stuff.c
+++ b/src/hu_stuff.c
@@ -1363,7 +1363,7 @@ void HU_DrawTabRankings(INT32 x, INT32 y, playersort_t *tab, INT32 scorelines, I
 				V_DrawRightAlignedString(x, y-4, hilicol, "FIN");
 				V_DrawRightAlignedString(x+rightoffset, y, hilicol, timestring(players[tab[i].num].realtime));
 			}
-			if (players[tab[i].num].pflags & PF_TIMEOVER)
+			else if (players[tab[i].num].pflags & PF_TIMEOVER)
 				V_DrawRightAlignedThinString(x+rightoffset, y-1, 0, "TIME OVER...");
 			else if (circuitmap)
 			{

From 731b05e26389bb847a9b72bd9e9971f096abc9c0 Mon Sep 17 00:00:00 2001
From: toaster <rollerorbital@gmail.com>
Date: Mon, 30 Jul 2018 23:17:01 +0100
Subject: [PATCH 06/10] More UI crap! * Fix minor additional error in tab
 rankings. * Remove FREE PLAY from intermission drawer, per Sal's request. *
 Remove "second%s" from the end of the "Start in %d"/"Vote ends in %d" string.
 * Rename cv_advancemap's "Off" value to "Same", to make the behaviour
 clearer. * Make the "Start in %d" string now begin with cv_advancemap's
 string (ie, "Vote in %d", "Same in %d", "Random in %d, Next in %d"...

---
 src/d_netcmd.c |  2 +-
 src/hu_stuff.c |  2 +-
 src/m_menu.c   |  2 +-
 src/y_inter.c  | 13 ++-----------
 4 files changed, 5 insertions(+), 14 deletions(-)

diff --git a/src/d_netcmd.c b/src/d_netcmd.c
index f7954747..78531be3 100644
--- a/src/d_netcmd.c
+++ b/src/d_netcmd.c
@@ -432,7 +432,7 @@ consvar_t cv_maxping = {"maxping", "0", CV_SAVE, CV_Unsigned, NULL, 0, NULL, NUL
 static CV_PossibleValue_t inttime_cons_t[] = {{0, "MIN"}, {3600, "MAX"}, {0, NULL}};
 consvar_t cv_inttime = {"inttime", "20", CV_NETVAR, inttime_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL};
 
-static CV_PossibleValue_t advancemap_cons_t[] = {{0, "Off"}, {1, "Next"}, {2, "Random"}, {3, "Vote"}, {0, NULL}};
+static CV_PossibleValue_t advancemap_cons_t[] = {{0, "Same"}, {1, "Next"}, {2, "Random"}, {3, "Vote"}, {0, NULL}};
 consvar_t cv_advancemap = {"advancemap", "Vote", CV_NETVAR, advancemap_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL};
 static CV_PossibleValue_t playersforexit_cons_t[] = {{0, "One"}, {1, "All"}, {0, NULL}};
 consvar_t cv_playersforexit = {"playersforexit", "One", CV_NETVAR, playersforexit_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL};
diff --git a/src/hu_stuff.c b/src/hu_stuff.c
index dd08d26e..4122b398 100644
--- a/src/hu_stuff.c
+++ b/src/hu_stuff.c
@@ -1376,7 +1376,7 @@ void HU_DrawTabRankings(INT32 x, INT32 y, playersort_t *tab, INT32 scorelines, I
 #undef timestring
 		}
 		else
-			V_DrawRightAlignedString(x+rightoffset, y, ((players[tab[i].num].health > 0) ? 0 : V_60TRANS), va("%u", tab[i].count));
+			V_DrawRightAlignedString(x+rightoffset, y, 0, va("%u", tab[i].count));
 
 		y += 16;
 		if (i == 9)
diff --git a/src/m_menu.c b/src/m_menu.c
index ce4e7486..63eae220 100644
--- a/src/m_menu.c
+++ b/src/m_menu.c
@@ -1436,7 +1436,7 @@ static menuitem_t OP_ServerOptionsMenu[] =
 
 	{IT_STRING | IT_CVAR,    NULL, "Intermission Timer",			&cv_inttime,			 40},
 	{IT_STRING | IT_CVAR,    NULL, "Voting Timer",					&cv_votetime,			 50},
-	{IT_STRING | IT_CVAR,    NULL, "Advance to Next Level",		&cv_advancemap,			 60},
+	{IT_STRING | IT_CVAR,    NULL, "Advance to Next Level",			&cv_advancemap,			 60},
 
 #ifndef NONET
 	{IT_STRING | IT_CVAR,    NULL, "Max Player Count",				&cv_maxplayers,			 80},
diff --git a/src/y_inter.c b/src/y_inter.c
index f07e8e2f..29c81df0 100644
--- a/src/y_inter.c
+++ b/src/y_inter.c
@@ -263,7 +263,6 @@ static void Y_CalculateMatchData(boolean rankingsmode, void (*comparison)(INT32)
 //
 void Y_IntermissionDrawer(void)
 {
-	boolean forcefreeplay = false;
 	INT32 i, whiteplayer = MAXPLAYERS, x = 4, hilicol = V_YELLOWMAP; // fallback
 
 	if (intertype == int_none || rendermode == render_none)
@@ -370,11 +369,7 @@ void Y_IntermissionDrawer(void)
 		if (data.match.rankingsmode)
 			timeheader = "RANK";
 		else
-		{
 			timeheader = (intertype == int_race ? "TIME" : "SCORE");
-			if (data.match.numplayers <= 1)
-				forcefreeplay = true;
-		}
 
 		// draw the level name
 		V_DrawCenteredString(-4 + x + BASEVIDWIDTH/2, 20, 0, data.match.levelstring);
@@ -492,15 +487,11 @@ void Y_IntermissionDrawer(void)
 	}
 
 dotimer:
-
-	if (netgame && forcefreeplay) // FREE PLAY?
-		K_drawKartFreePlay(intertic);
-
 	if (timer)
 	{
 		INT32 tickdown = (timer+1)/TICRATE;
 		V_DrawCenteredString(BASEVIDWIDTH/2, 188, hilicol,
-			va("start in %d second%s", tickdown, (tickdown == 1 ? "" : "s")));
+			va("%s in %d", cv_advancemap.string, tickdown));
 	}
 
 	// Make it obvious that scrambling is happening next round.
@@ -1139,7 +1130,7 @@ void Y_VoteDrawer(void)
 		else //if (gametype == GT_MATCH)
 			hilicol = V_REDMAP;
 		V_DrawCenteredString(BASEVIDWIDTH/2, 188, hilicol,
-			va("Vote ends in %d second%s", tickdown, (tickdown == 1 ? "" : "s")));
+			va("Vote ends in %d", tickdown));
 	}
 }
 

From f2070ba6d1b9bb5aab42649c7cdbdc2cb2652e2f Mon Sep 17 00:00:00 2001
From: toaster <rollerorbital@gmail.com>
Date: Mon, 30 Jul 2018 23:20:04 +0100
Subject: [PATCH 07/10] Some tidbits for countdowns. * Fix an inconsistency in
 timing re a time over that involves a single person (the number of tics
 exiting usually takes), versus a time over that involves multiple people
 (8*TICRATE). * Barebones preparatory work for F-Zero explosion, since I was
 futzing around in this already.

---
 src/p_user.c | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

diff --git a/src/p_user.c b/src/p_user.c
index 9ba02714..86e404ac 100644
--- a/src/p_user.c
+++ b/src/p_user.c
@@ -1747,8 +1747,8 @@ void P_DoPlayerExit(player_t *player)
 			P_EndingMusic(player);
 
 		// SRB2kart 120217
-		if (!countdown2)
-			countdown2 = countdown + 8*TICRATE;
+		//if (!countdown2)
+			//countdown2 = countdown + 8*TICRATE;
 
 		if (P_CheckRacers())
 			player->exiting = (14*TICRATE)/5 + 1;
@@ -9088,6 +9088,12 @@ void P_DoTimeOver(player_t *player)
 	player->lives = 0;
 
 	P_EndingMusic(player);
+
+#if 0
+	// sal, when you do the f-zero explosion, this is how you make sure the map doesn't end before it's done ^u^ ~toast
+	if (!countdown2)
+		countdown2 = 5*TICRATE;
+#endif
 }
 
 //

From 9109bb1ee77252410a9fc85ed1bdbaacd0f168c1 Mon Sep 17 00:00:00 2001
From: Latapostrophe <hyperclassic3@gmail.com>
Date: Tue, 31 Jul 2018 23:35:16 +0200
Subject: [PATCH 08/10] Fix console leftover + positionning

---
 src/console.c  |  16 ++++-
 src/hu_stuff.c | 154 +++++++++++++++++++++++++++++++++++--------------
 2 files changed, 125 insertions(+), 45 deletions(-)

diff --git a/src/console.c b/src/console.c
index 43d5df2d..e6ec039e 100644
--- a/src/console.c
+++ b/src/console.c
@@ -1037,7 +1037,17 @@ boolean CON_Responder(event_t *ev)
 	else if (key == KEY_KPADSLASH)
 		key = '/';
 
-	if (shiftdown)
+	// capslock
+	if (key == KEY_CAPSLOCK)	// it's a toggle.
+	{	
+		if (capslock)
+			capslock = false;
+		else	
+			capslock = true;
+		return true;
+	}	
+	
+	if (capslock ^ shiftdown)	// gets capslock to work because capslock is cool
 		key = shiftxform[key];
 
 	// enter a char into the command prompt
@@ -1045,7 +1055,7 @@ boolean CON_Responder(event_t *ev)
 		return true; // even if key can't be printed, eat it anyway
 
 	// add key to cmd line here
-	if (key >= 'A' && key <= 'Z' && !shiftdown) //this is only really necessary for dedicated servers
+	if (key >= 'A' && key <= 'Z' && !(shiftdown ^ capslock)) //this is only really necessary for dedicated servers
 		key = key + 'a' - 'A';
 
 	if (input_sel != input_cur)
@@ -1432,7 +1442,7 @@ static void CON_DrawHudlines(void)
 	if (con_hudlines <= 0)
 		return;
 
-	if (chat_on)
+	if (chat_on && (cv_consolechat.value || vid.width < 640))
 		y = charheight; // leave place for chat input in the first row of text
 	else
 		y = 0;
diff --git a/src/hu_stuff.c b/src/hu_stuff.c
index 6114748b..29f9c356 100644
--- a/src/hu_stuff.c
+++ b/src/hu_stuff.c
@@ -1167,7 +1167,7 @@ static UINT8 *CHAT_GetStringColormap(INT32 colorflags)	// pasted from video.c, s
 	case 2: // 0x82, yellow
 		return yellowmap;
 	case 3: // 0x83, lgreen
-		return lgreenmap;
+		return greenmap;
 	case 4: // 0x84, blue
 		return bluemap;
 	case 5: // 0x85, red
@@ -1176,6 +1176,8 @@ static UINT8 *CHAT_GetStringColormap(INT32 colorflags)	// pasted from video.c, s
 		return graymap;
 	case 7: // 0x87, orange
 		return orangemap;
+	case 8: // 0x88, sky
+		return skymap;
 	default: // reset
 		return NULL;
 	}
@@ -1235,7 +1237,9 @@ char *CHAT_WordWrap(INT32 x, INT32 w, INT32 option, const char *string)
 	return newstring;
 }
 
-INT16 chatx = 160, chaty = 16;	// let's use this as our coordinates, shh
+// 30/7/18: chaty is now the distance at which the lowest point of the chat will be drawn if that makes any sense.
+
+INT16 chatx = 13, chaty = 169;	// let's use this as our coordinates, shh
 
 // chat stuff by VincyTM LOL XD!
 
@@ -1243,19 +1247,75 @@ INT16 chatx = 160, chaty = 16;	// let's use this as our coordinates, shh
 
 static void HU_drawMiniChat(void)
 {
-	INT32 charwidth = (vid.width < 640) ? 8 : 4, charheight = (vid.width < 640) ? 8 : 6;
-	INT32 x = chatx+2, y = chaty+2, dx = 0, dy = 0;
-	size_t i = 0;
 	
-	for (i=0; i<chat_nummsg_min; i++)	// iterate through our hot messages
+	if (!chat_nummsg_min)
+		return;	// needless to say it's useless to do anything if we don't have anything to draw.
+	
+	
+	INT32 x = chatx+2; 
+	INT32 charwidth = 4, charheight = 6;	
+	INT32 dx = 0, dy = 0;
+	size_t i = chat_nummsg_min;
+	
+	INT32 msglines = 0;
+	// process all messages once without rendering anything or doing anything fancy so that we know how many lines each message has...
+	
+	for (; i>0; i--)
+	{	
+		const char *msg = CHAT_WordWrap(x, cv_chatwidth.value-charwidth, V_SNAPTOBOTTOM|V_SNAPTOLEFT|V_ALLOWLOWERCASE, chat_mini[i-1]);
+		size_t j = 0;
+		INT32 linescount = 0;
+		
+		while(msg[j])	// iterate through msg
+		{	
+			if (msg[j] < HU_FONTSTART)	// don't draw
+			{			
+				if (msg[j] == '\n')	// get back down.
+				{
+					++j;
+					linescount += 1;
+					dx = 0;
+					continue;
+				}
+				else if (msg[j] & 0x80) // stolen from video.c, nice.
+				{
+					++j;
+					continue;
+				}
+				
+				++j;	
+			}
+			else
+			{
+				j++;
+			}
+			
+			dx += charwidth;
+			if (dx >= cv_chatwidth.value)
+			{
+				dx = 0;
+				linescount += 1;
+			}
+		}
+		dy = 0;
+		dx = 0;
+		msglines += linescount+1;
+	}
+	
+	INT32 y = chaty - charheight*(msglines+1) - (cv_kartspeedometer.value ? 16 : 0);
+	dx = 0; 
+	dy = 0;
+	i = 0;
+	
+	for (; i<=(chat_nummsg_min-1); i++)	// iterate through our hot messages
 	{
 		
 		INT32 clrflag = 0;
-		
 		INT32 timer = ((cv_chattime.value*TICRATE)-chat_timers[i]) - cv_chattime.value*TICRATE+9;	// see below...		
 		INT32 transflag = (timer >= 0 && timer <= 9) ? (timer*V_10TRANS) : 0;	// you can make bad jokes out of this one.
 		size_t j = 0;
-		const char *msg = CHAT_WordWrap(x, cv_chatwidth.value-charwidth, V_SNAPTOTOP|V_SNAPTOLEFT|V_ALLOWLOWERCASE, chat_mini[i]);	// get the current message, and word wrap it.
+		const char *msg = CHAT_WordWrap(x, cv_chatwidth.value-charwidth, V_SNAPTOBOTTOM|V_SNAPTOLEFT|V_ALLOWLOWERCASE, chat_mini[i]);	// get the current message, and word wrap it.
+		
 		while(msg[j])	// iterate through msg
 		{	
 			if (msg[j] < HU_FONTSTART)	// don't draw
@@ -1279,7 +1339,7 @@ static void HU_drawMiniChat(void)
 			else
 			{
 				UINT8 *colormap = CHAT_GetStringColormap(clrflag);
-				V_DrawChatCharacter(x + dx + 2, y+dy+addy, msg[j++] |V_SNAPTOTOP|V_SNAPTORIGHT|transflag, !cv_allcaps.value, colormap);
+				V_DrawChatCharacter(x + dx + 2, y+dy, msg[j++] |V_SNAPTOBOTTOM|V_SNAPTOLEFT|transflag, !cv_allcaps.value, colormap);
 			}
 			
 			dx += charwidth;
@@ -1292,7 +1352,7 @@ static void HU_drawMiniChat(void)
 		dy += charheight;
 		dx = 0;
 	}
-	
+		
 	// decrement addy and make that shit smooth:
 	addy /= 2;
 	
@@ -1333,25 +1393,27 @@ static void HU_DrawDownArrow(INT32 x, INT32 y, INT32 options)
 // HU_DrawChatLog
 // TODO: fix dumb word wrapping issues
 
-static void HU_drawChatLog(void)
+static void HU_drawChatLog(INT32 offset)
 {
 	
 	// before we do anything, make sure that our scroll position isn't "illegal";
 	if (chat_scroll > chat_maxscroll)
 		chat_scroll = chat_maxscroll;
 	
-	INT32 charwidth = (vid.width < 640) ? 8 : 4, charheight = (vid.width < 640) ? 8 : 6;
-	INT32 x = chatx+2, y = chaty+2-(chat_scroll*charheight), dx = 0, dy = 0;
+	INT32 charwidth = 4, charheight = 6;
+	INT32 x = chatx+2, y = chaty - offset*charheight - (chat_scroll*charheight) - cv_chatheight.value*charheight - 12 - (cv_kartspeedometer.value ? 16 : 0), dx = 0, dy = 0;
 	size_t i = 0;
+	INT32 chat_topy = y + chat_scroll*charheight;
+	INT32 chat_bottomy = chat_topy + cv_chatheight.value*charheight;
 	boolean atbottom = false;
 	
-	V_DrawFillConsoleMap(chatx, chaty, cv_chatwidth.value, cv_chatheight.value*charheight +2, 239|V_SNAPTOTOP|V_SNAPTORIGHT);	// INUT
+	V_DrawFillConsoleMap(chatx, chat_topy, cv_chatwidth.value, cv_chatheight.value*charheight +2, 239|V_SNAPTOBOTTOM|V_SNAPTOLEFT);	// log box
 		
 	for (i=0; i<chat_nummsg_log; i++)	// iterate through our chatlog
 	{
 		INT32 clrflag = 0;
 		size_t j = 0;
-		const char *msg = CHAT_WordWrap(x, cv_chatwidth.value-charwidth, V_SNAPTOTOP|V_SNAPTOLEFT|V_ALLOWLOWERCASE, chat_log[i]);	// get the current message, and word wrap it.
+		const char *msg = CHAT_WordWrap(x, cv_chatwidth.value-charwidth, V_SNAPTOBOTTOM|V_SNAPTOLEFT|V_ALLOWLOWERCASE, chat_log[i]);	// get the current message, and word wrap it.
 		while(msg[j])	// iterate through msg
 		{	
 			if (msg[j] < HU_FONTSTART)	// don't draw
@@ -1374,10 +1436,10 @@ static void HU_drawChatLog(void)
 			}
 			else
 			{
-				if ((y+dy > chaty) && (y+dy < (chaty+cv_chatheight.value*charheight)))
+				if ((y+dy+2 >= chat_topy) && (y+dy < (chat_bottomy)))
 				{	
 					UINT8 *colormap = CHAT_GetStringColormap(clrflag);
-					V_DrawChatCharacter(x + dx + 2, y+dy, msg[j++] |V_SNAPTOTOP|V_SNAPTORIGHT, !cv_allcaps.value, colormap);
+					V_DrawChatCharacter(x + dx + 2, y+dy+2, msg[j++] |V_SNAPTOBOTTOM|V_SNAPTOLEFT, !cv_allcaps.value, colormap);
 				}
 				else
 					j++;	// don't forget to increment this or we'll get stuck in the limbo.
@@ -1412,9 +1474,9 @@ static void HU_drawChatLog(void)
 	// draw arrows to indicate that we can (or not) scroll.
 	
 	if (chat_scroll > 0)
-		HU_DrawUpArrow(chatx-8, ((justscrolledup) ? (chaty-1) : (chaty)), V_SNAPTOTOP | V_SNAPTORIGHT);
+		HU_DrawUpArrow(chatx-8, ((justscrolledup) ? (chat_topy-1) : (chat_topy)), V_SNAPTOBOTTOM | V_SNAPTOLEFT);
 	if (chat_scroll < chat_maxscroll)
-		HU_DrawDownArrow(chatx-8, chaty+(cv_chatheight.value*charheight)-((justscrolleddown) ? 3 : 4), V_SNAPTOTOP | V_SNAPTORIGHT);
+		HU_DrawDownArrow(chatx-8, chat_bottomy-((justscrolleddown) ? 3 : 4), V_SNAPTOBOTTOM | V_SNAPTOLEFT);
 	
 	justscrolleddown = false;
 	justscrolledup = false;
@@ -1429,8 +1491,8 @@ static void HU_drawChatLog(void)
 static INT16 typelines = 1;	// number of drawfill lines we need. it's some weird hack and might be one frame off but I'm lazy to make another loop.
 static void HU_DrawChat(void)
 {	
-	INT32 charwidth = (vid.width < 640) ? 8 : 4, charheight = (vid.width < 640) ? 8 : 6;
-	INT32 t = 0, c = 0, y = chaty + 4 + cv_chatheight.value*charheight;
+	INT32 charwidth = 4, charheight = 6;
+	INT32 t = 0, c = 0, y = chaty - (typelines*charheight)  - (cv_kartspeedometer.value ? 16 : 0);
 	size_t i = 0;
 	const char *ntalk = "Say: ", *ttalk = "Team: ";
 	const char *talk = ntalk;
@@ -1446,15 +1508,14 @@ static void HU_DrawChat(void)
 #endif
 	}
 			
-	HU_drawChatLog();
-	V_DrawFillConsoleMap(chatx, y-1, cv_chatwidth.value, (vid.width < 640 ) ? (typelines*charheight+2) : (typelines*charheight), 239 | V_SNAPTOTOP | V_SNAPTORIGHT);
+	V_DrawFillConsoleMap(chatx, y-1, cv_chatwidth.value, (typelines*charheight), 239 | V_SNAPTOBOTTOM | V_SNAPTOLEFT);
 	
 	while (talk[i])
 	{
 		if (talk[i] < HU_FONTSTART)
 			++i;
 		else
-			V_DrawChatCharacter(chatx + c + 2, y, talk[i++] |V_SNAPTOTOP|V_SNAPTORIGHT, !cv_allcaps.value, NULL);
+			V_DrawChatCharacter(chatx + c + 2, y, talk[i++] |V_SNAPTOBOTTOM|V_SNAPTOLEFT, !cv_allcaps.value, NULL);
 
 		c += charwidth;
 	}
@@ -1463,26 +1524,34 @@ static void HU_DrawChat(void)
 	typelines = 1;
 	
 	if ((strlen(w_chat) == 0 || c_input == 0) && hu_tick < 4)
-		V_DrawChatCharacter(chatx + 2 + c, y+1, '_' |V_SNAPTOTOP|V_SNAPTORIGHT|t, !cv_allcaps.value, NULL);
-	
+		V_DrawChatCharacter(chatx + 2 + c, y+1, '_' |V_SNAPTOBOTTOM|V_SNAPTOLEFT|t, !cv_allcaps.value, NULL);
+		
 	while (w_chat[i])
 	{
-		
-		if (c_input == (i+1) && hu_tick < 4)
+		boolean skippedline = false;
+		if (c_input == (i+1))
 		{
-			int cursorx = (c+charwidth < cv_chatwidth.value-charwidth) ? (chatx + 2 + c+charwidth) : (chatx);	// we may have to go down.
-			int cursory = (cursorx != chatx) ? (y) : (y+charheight);
-			V_DrawChatCharacter(cursorx, cursory+1, '_' |V_SNAPTOTOP|V_SNAPTORIGHT|t, !cv_allcaps.value, NULL);	
+			int cursorx = (c+charwidth < cv_chatwidth.value-charwidth) ? (chatx + 2 + c+charwidth) : (chatx+1);	// we may have to go down.
+			int cursory = (cursorx != chatx+1) ? (y) : (y+charheight);
+			if (hu_tick < 4)
+				V_DrawChatCharacter(cursorx, cursory+1, '_' |V_SNAPTOBOTTOM|V_SNAPTOLEFT|t, !cv_allcaps.value, NULL);	
+			
+			if (cursorx == chatx+1)	// a weirdo hack
+			{
+				typelines += 1;
+				skippedline = true;
+			}	
+			
 		}	
 		
 		//Hurdler: isn't it better like that?
 		if (w_chat[i] < HU_FONTSTART)
 			++i;
 		else
-			V_DrawChatCharacter(chatx + c + 2, y, w_chat[i++] | V_SNAPTOTOP|V_SNAPTORIGHT | t, !cv_allcaps.value, NULL);
+			V_DrawChatCharacter(chatx + c + 2, y, w_chat[i++] | V_SNAPTOBOTTOM|V_SNAPTOLEFT | t, !cv_allcaps.value, NULL);
 
 		c += charwidth;
-		if (c > cv_chatwidth.value-charwidth)
+		if (c > cv_chatwidth.value-(charwidth*2) && !skippedline)
 		{
 			c = 0;
 			y += charheight;
@@ -1495,8 +1564,7 @@ static void HU_DrawChat(void)
 	{	
 		i = 0;
 		int count = 0;
-		INT32 p_dispy = chaty+2;
-		V_DrawFillConsoleMap(chatx-50, p_dispy-2, 48, 2, 239 | V_SNAPTOTOP | V_SNAPTORIGHT);	// top (don't mind me)
+		INT32 p_dispy = chaty - charheight -1;
 		for(i=0; (i<MAXPLAYERS); i++)
 		{
 			
@@ -1541,22 +1609,24 @@ static void HU_DrawChat(void)
 				}
 			}
 			
-			if ((playeringame[i]))
+			if (playeringame[i])
 			{	
 				char name[MAXPLAYERNAME+1];
 				strlcpy(name, player_names[i], 7);	// shorten name to 7 characters.
-				V_DrawFillConsoleMap(chatx-50, p_dispy+ (6*count), 48, 6, 239 | V_SNAPTOTOP | V_SNAPTORIGHT);	// fill it like the chat so the text doesn't become hard to read because of the hud.
-				V_DrawSmallString(chatx-48, p_dispy+ (6*count), V_SNAPTOTOP|V_SNAPTORIGHT|V_ALLOWLOWERCASE, va("\x82%d\x80 - %s", i, name));
+				V_DrawFillConsoleMap(chatx+ cv_chatwidth.value + 2, p_dispy- (6*count), 48, 6, 239 | V_SNAPTOBOTTOM | V_SNAPTOLEFT);	// fill it like the chat so the text doesn't become hard to read because of the hud.
+				V_DrawSmallString(chatx+ cv_chatwidth.value + 4, p_dispy- (6*count), V_SNAPTOBOTTOM|V_SNAPTOLEFT|V_ALLOWLOWERCASE, va("\x82%d\x80 - %s", i, name));
 				count++;
 			}
 		}
 		if (count == 0)	// no results.
 		{
-			V_DrawFillConsoleMap(chatx-50, p_dispy+ (6*count), 48, 6, 239 | V_SNAPTOTOP | V_SNAPTORIGHT);	// fill it like the chat so the text doesn't become hard to read because of the hud.
-			V_DrawSmallString(chatx-48, p_dispy+ (6*count), V_SNAPTOTOP|V_SNAPTORIGHT|V_ALLOWLOWERCASE, "NO RESULT.");
+			V_DrawFillConsoleMap(chatx-50, p_dispy- (6*count), 48, 6, 239 | V_SNAPTOBOTTOM | V_SNAPTOLEFT);	// fill it like the chat so the text doesn't become hard to read because of the hud.
+			V_DrawSmallString(chatx-48, p_dispy- (6*count), V_SNAPTOBOTTOM|V_SNAPTOLEFT|V_ALLOWLOWERCASE, "NO RESULT.");
 		}	
 	}
 	
+	HU_drawChatLog(typelines-1);	// typelines is the # of lines we're typing. If there's more than 1 then the log should scroll up to give us more space.
+	
 }
 
 // why the fuck would you use this...
@@ -1887,7 +1957,7 @@ void HU_Drawer(void)
 		// count down the scroll timer. 
 		if (chat_scrolltime > 0)
 			chat_scrolltime--;
-		if (!cv_consolechat.value)
+		if (!cv_consolechat.value && vid.width > 320)	// don't even try using newchat sub 400p, I'm too fucking lazy
 			HU_DrawChat();
 		else
 			HU_DrawChat_Old();	// why the fuck.........................
@@ -1898,7 +1968,7 @@ void HU_Drawer(void)
 		{	
 			HU_drawMiniChat();		// draw messages in a cool fashion.
 			chat_scrolltime = 0;	// do scroll anyway.
-			typelines = 0;			// make sure that the chat doesn't have a weird blinking huge ass square if we typed a lot last time.
+			typelines = 1;			// make sure that the chat doesn't have a weird blinking huge ass square if we typed a lot last time.
 		}	
 	}
 	

From ad119af07b7770ef15557ea28026deb9ddda0cef Mon Sep 17 00:00:00 2001
From: toaster <rollerorbital@gmail.com>
Date: Thu, 2 Aug 2018 23:52:07 +0100
Subject: [PATCH 09/10] * Get chat to compile with errormode on. * Add chat
 options to the HUD and Sound Option menus.

---
 src/console.c     |   8 +-
 src/g_game.c      |   9 +-
 src/hu_stuff.c    | 441 +++++++++++++++++++++++-----------------------
 src/lua_baselib.c |   1 +
 src/m_menu.c      |  39 ++--
 5 files changed, 254 insertions(+), 244 deletions(-)

diff --git a/src/console.c b/src/console.c
index e6ec039e..eaa98550 100644
--- a/src/console.c
+++ b/src/console.c
@@ -1039,14 +1039,14 @@ boolean CON_Responder(event_t *ev)
 
 	// capslock
 	if (key == KEY_CAPSLOCK)	// it's a toggle.
-	{	
+	{
 		if (capslock)
 			capslock = false;
-		else	
+		else
 			capslock = true;
 		return true;
-	}	
-	
+	}
+
 	if (capslock ^ shiftdown)	// gets capslock to work because capslock is cool
 		key = shiftxform[key];
 
diff --git a/src/g_game.c b/src/g_game.c
index 223e203d..762cac85 100644
--- a/src/g_game.c
+++ b/src/g_game.c
@@ -413,16 +413,17 @@ consvar_t cv_chatwidth = {"chatwidth", "150", CV_SAVE, chatwidth_cons_t, NULL, 0
 
 // chatheight
 static CV_PossibleValue_t chatheight_cons_t[] = {{6, "MIN"}, {22, "MAX"}, {0, NULL}};
-consvar_t cv_chatheight= {"chatheight", "8", CV_SAVE, chatheight_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL};
+consvar_t cv_chatheight = {"chatheight", "8", CV_SAVE, chatheight_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL};
 
 // chat notifications (do you want to hear beeps? I'd understand if you didn't.)
-consvar_t cv_chatnotifications= {"chatnotifications", "On", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
+consvar_t cv_chatnotifications = {"chatnotifications", "On", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
 
 // chat spam protection (why would you want to disable that???)
-consvar_t cv_chatspamprotection= {"chatspamprotection", "On", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
+consvar_t cv_chatspamprotection = {"chatspamprotection", "On", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
 
 // old shit console chat. (mostly exists for stuff like terminal, not because I cared if anyone liked the old chat.)
-consvar_t cv_consolechat= {"consolechat", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
+//static CV_PossibleValue_t consolechat_cons_t[] = {{0, "Box"}, {1, "Console"}, {0, NULL}}; -- for menu, but menu disabled...
+consvar_t cv_consolechat = {"consolechat", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
 
 consvar_t cv_crosshair = {"crosshair", "Cross", CV_SAVE, crosshair_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL};
 consvar_t cv_crosshair2 = {"crosshair2", "Cross", CV_SAVE, crosshair_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL};
diff --git a/src/hu_stuff.c b/src/hu_stuff.c
index 29f9c356..dd0d61fe 100644
--- a/src/hu_stuff.c
+++ b/src/hu_stuff.c
@@ -76,7 +76,7 @@ patch_t *cred_font[CRED_FONTSIZE];
 static player_t *plr;
 boolean chat_on; // entering a chat message?
 static char w_chat[HU_MAXMSGLEN];
-static INT32 c_input = 0;	// let's try to make the chat input less shitty.
+static UINT32 c_input = 0;	// let's try to make the chat input less shitty.
 static boolean headsupactive = false;
 boolean hu_showscores; // draw rankings
 static char hu_tick;
@@ -342,10 +342,10 @@ void HU_Start(void)
 
 static UINT32 chat_nummsg_log = 0;
 static UINT32 chat_nummsg_min = 0;
-static UINT32 chat_scroll = 0;		
+static UINT32 chat_scroll = 0;
 static tic_t chat_scrolltime = 0;
 
-static INT32 chat_maxscroll = 0;	// how far can we scroll? 
+static UINT32 chat_maxscroll = 0;	// how far can we scroll?
 
 //static chatmsg_t chat_mini[CHAT_BUFSIZE];	// Display the last few messages sent.
 //static chatmsg_t chat_log[CHAT_BUFSIZE];	// Keep every message sent to us in memory so we can scroll n shit, it's cool.
@@ -358,12 +358,12 @@ static boolean chat_scrollmedown = false;	// force instant scroll down on the ch
 
 // remove text from minichat table
 
-static INT16 addy = 0;	// use this to make the messages scroll smoothly when one fades away 
+static INT16 addy = 0;	// use this to make the messages scroll smoothly when one fades away
 
 static void HU_removeChatText_Mini(void)
 {
     // MPC: Don't create new arrays, just iterate through an existing one
-	int i;
+	UINT32 i;
     for(i=0;i<chat_nummsg_min-1;i++) {
         strcpy(chat_mini[i], chat_mini[i+1]);
         chat_timers[i] = chat_timers[i+1];
@@ -379,27 +379,27 @@ static void HU_removeChatText_Mini(void)
 static void HU_removeChatText_Log(void)
 {
 	// MPC: Don't create new arrays, just iterate through an existing one
-	int i;
+	UINT32 i;
     for(i=0;i<chat_nummsg_log-1;i++) {
         strcpy(chat_log[i], chat_log[i+1]);
     }
     chat_nummsg_log--;	// lost 1 msg.
 }
-	
+
 void HU_AddChatText(const char *text)
 {
-	
+
 	// TODO: check if we're oversaturating the log (we can only log CHAT_BUFSIZE messages.)
-	
+
 	if (chat_nummsg_log >= CHAT_BUFSIZE)
 		HU_removeChatText_Log();
-	
+
 	strcpy(chat_log[chat_nummsg_log], text);
 	chat_nummsg_log++;
-	
+
 	if (chat_nummsg_min >= 8)
 		HU_removeChatText_Mini();
-	
+
 	strcpy(chat_mini[chat_nummsg_min], text);
 	chat_timers[chat_nummsg_min] = TICRATE*cv_chattime.value;
 	chat_nummsg_min++;
@@ -458,7 +458,7 @@ static void DoSayCommand(SINT8 target, size_t usedargs, UINT8 flags)
 			strlcat(msg, " ", msgspace);
 		strlcat(msg, COM_Argv(ix + usedargs), msgspace);
 	}
-	
+
 	if (strlen(msg) > 4 && strnicmp(msg, "/pm", 3) == 0)	// used /pm
 	{
 		// what we're gonna do now is check if the node exists
@@ -468,30 +468,30 @@ static void DoSayCommand(SINT8 target, size_t usedargs, UINT8 flags)
 		strncpy(nodenum, msg+3, 5);
 		// check for undesirable characters in our "number"
 		if 	(((nodenum[0] < '0') || (nodenum[0] > '9')) || ((nodenum[1] < '0') || (nodenum[1] > '9')))
-		{	
+		{
 			// check if nodenum[1] is a space
 			if (nodenum[1] == ' ')
 				spc = 0;
 				// let it slide
 			else
-			{	
+			{
 				HU_AddChatText("\x82NOTICE: \x80Invalid command format. Correct format is \'/pm<node> \'.");
 				return;
-			}	
+			}
 		}
 		// I'm very bad at C, I swear I am, additional checks eww!
 			if (spc != 0)
-			{	
+			{
 				if (msg[5] != ' ')
 				{
 					HU_AddChatText("\x82NOTICE: \x80Invalid command format. Correct format is \'/pm<node> \'.");
 					return;
 				}
 			}
-		
+
 		target = atoi((const char*) nodenum);	// turn that into a number
 		//CONS_Printf("%d\n", target);
-		
+
 		// check for target player, if it doesn't exist then we can't send the message!
 		if (playeringame[target])	// player exists
 			target++;				// even though playernums are from 0 to 31, target is 1 to 32, so up that by 1 to have it work!
@@ -502,7 +502,7 @@ static void DoSayCommand(SINT8 target, size_t usedargs, UINT8 flags)
 		}
 		buf[0] = target;
 		const char *newmsg = msg+5+spc;
-		memcpy(msg, newmsg, 255);
+		memcpy(msg, newmsg, 252);
 	}
 
 	SendNetXCmd(XD_SAY, buf, strlen(msg) + 1 + msg-buf);
@@ -602,7 +602,7 @@ static void Got_Saycmd(UINT8 **p, INT32 playernum)
 	char *msg;
 	boolean action = false;
 	char *ptr;
-	
+
 	CONS_Debug(DBG_NETPLAY,"Received SAY cmd from Player %d (%s)\n", playernum+1, player_names[playernum]);
 
 	target = READSINT8(*p);
@@ -647,31 +647,31 @@ static void Got_Saycmd(UINT8 **p, INT32 playernum)
 			}
 		}
 	}
-	
+
 	int spam_eatmsg = 0;
-	
+
 	// before we do anything, let's verify the guy isn't spamming, get this easier on us.
-	
+
 	//if (stop_spamming_you_cunt[playernum] != 0 && cv_chatspamprotection.value && !(flags & HU_CSAY))
 	if (stop_spamming_you_cunt[playernum] != 0 && consoleplayer != playernum && cv_chatspamprotection.value && !(flags & HU_CSAY))
-	{	
+	{
 		CONS_Debug(DBG_NETPLAY,"Received SAY cmd too quickly from Player %d (%s), assuming as spam and blocking message.\n", playernum+1, player_names[playernum]);
 		stop_spamming_you_cunt[playernum] = 4;
 		spam_eatmsg = 1;
 	}
 	else
 		stop_spamming_you_cunt[playernum] = 4;	// you can hold off for 4 tics, can you?
-	
+
 	// run the lua hook even if we were supposed to eat the msg, netgame consistency goes first.
-	
+
 #ifdef HAVE_BLUA
 	if (LUAh_PlayerMsg(playernum, target, flags, msg, spam_eatmsg))
 		return;
 #endif
-	
+
 	if (spam_eatmsg)
 		return;	// don't proceed if we were supposed to eat the message.
-	
+
 	// If it's a CSAY, just CECHO and be done with it.
 	if (flags & HU_CSAY)
 	{
@@ -713,18 +713,18 @@ static void Got_Saycmd(UINT8 **p, INT32 playernum)
 	{
 		const char *prefix = "", *cstart = "", *cend = "", *adminchar = "\x82~\x83", *remotechar = "\x82@\x83", *fmt, *fmt2;
 		char *tempchar = NULL;
-		
+
 		// In CTF and team match, color the player's name.
 		if (G_GametypeHasTeams())
 		{
 			cend = "";
-			if (players[playernum].ctfteam == 1) // red	
-				cstart = "\x85";		
+			if (players[playernum].ctfteam == 1) // red
+				cstart = "\x85";
 			else if (players[playernum].ctfteam == 2) // blue
 				cstart = "\x84";
-			
+
 		}
-		
+
 		// player is a spectator?
 		if (players[playernum].spectator)
 				cstart = "\x86";	// grey name
@@ -749,15 +749,15 @@ static void Got_Saycmd(UINT8 **p, INT32 playernum)
 		// name, color end, and the message itself.
 		// '\4' makes the message yellow and beeps; '\3' just beeps.
 		if (action)
-		{	
+		{
 			fmt = "\3* %s%s%s%s \x82%s\n";	// don't make /me yellow, yellow will be for mentions and PMs!
 			fmt2 = "* %s%s%s%s \x82%s";
-		}	
+		}
 		else if (target == 0) // To everyone
 		{
 			fmt = "\3%s\x83<%s%s%s\x83>\x80 %s\n";
 			fmt2 = "%s\x83<%s%s%s\x83>\x80 %s";
-		}	
+		}
 		else if (target-1 == consoleplayer) // To you
 		{
 			prefix = "\x82[PM]";
@@ -775,35 +775,35 @@ static void Got_Saycmd(UINT8 **p, INT32 playernum)
 			cstart = "\x82";
 			fmt = "\4%s<%s%s>%s\x80 %s\n";	// make this yellow, however.
 			fmt2 = "%s<%s%s>%s\x80 %s";
-			
+
 		}
 		else // To your team
 		{
-			if (players[playernum].ctfteam == 1) // red	
-				prefix = "\x85[TEAM]";		
+			if (players[playernum].ctfteam == 1) // red
+				prefix = "\x85[TEAM]";
 			else if (players[playernum].ctfteam == 2) // blue
 				prefix = "\x84[TEAM]";
 			else
 				prefix = "\x83";	// makes sure this doesn't implode if you sayteam on non-team gamemodes
-				
+
 			fmt = "\3%s<%s%s>\x80%s %s\n";
 			fmt2 = "%s<%s%s>\x80%s %s";
-		
-		}		
-		
+
+		}
+
 		if (cv_consolechat.value)
-		{	
-			CONS_Printf(fmt, prefix, cstart, dispname, cend, msg);	
+		{
+			CONS_Printf(fmt, prefix, cstart, dispname, cend, msg);
 			HU_AddChatText(va(fmt2, prefix, cstart, dispname, cend, msg));	// add it reguardless, in case we decide to change our mind about our chat type.
-		}	
+		}
 		else
-		{	
+		{
 			HU_AddChatText(va(fmt2, prefix, cstart, dispname, cend, msg));
 			CON_LogMessage(va(fmt, prefix, cstart, dispname, cend, msg));	// save to log.txt
 			if (cv_chatnotifications.value)
 				S_StartSound(NULL, sfx_radio);
-		}	
-		
+		}
+
 		if (tempchar)
 			Z_Free(tempchar);
 	}
@@ -834,12 +834,12 @@ static inline boolean HU_keyInChatString(char *s, char ch)
 			{
 				s[l++] = ch;
 				s[l]=0;
-			}	
+			}
 			else
-			{	
-				
+			{
+
 				// move everything past c_input for new characters:
-				INT32 m = HU_MAXMSGLEN-1;
+				UINT32 m = HU_MAXMSGLEN-1;
 				for (;(m>=c_input);m--)
 				{
 					if (s[m])
@@ -859,16 +859,16 @@ static inline boolean HU_keyInChatString(char *s, char ch)
 		size_t i = c_input;
 		if (!s[i-1])
 			return false;
-		
+
 		if (i >= strlen(s)-1)
-		{	
+		{
 			s[strlen(s)-1] = 0;
 			c_input--;
 			return false;
-		}	
-		
+		}
+
 		for (; (i < HU_MAXMSGLEN); i++)
-		{	
+		{
 			s[i-1] = s[i];
 		}
 		c_input--;
@@ -901,7 +901,7 @@ static boolean teamtalk = false;
 
 //
 //
-static void HU_queueChatChar(char c)
+static void HU_queueChatChar(INT32 c)
 {
 	// send automaticly the message (no more chat char)
 	if (c == KEY_ENTER)
@@ -917,59 +917,59 @@ static void HU_queueChatChar(char c)
 		size_t i = 0;
 		for (;(i<HU_MAXMSGLEN);i++)
 			w_chat[i] = 0;	// reset this.
-		
+
 		c_input = 0;
-		
+
 		// last minute mute check
 		if (cv_mute.value && !(server || IsPlayerAdmin(consoleplayer)))
 		{
 			HU_AddChatText(va("%s>ERROR: The chat is muted. You can't say anything.", "\x85"));
 			return;
 		}
-		
+
 		INT32 target = 0;
-		
+
 		if (strlen(msg) > 4 && strnicmp(msg, "/pm", 3) == 0)	// used /pm
 		{
 			// what we're gonna do now is check if the node exists
 			// with that logic, characters 4 and 5 are our numbers:
-			
+
 			// teamtalk can't send PMs, just don't send it, else everyone would be able to see it, and no one wants to see your sex RP sicko.
 			if (teamtalk)
 			{
 				HU_AddChatText(va("%sCannot send sayto in Say-Team.", "\x85"));
 				return;
-			}	
-			
+			}
+
 			int spc = 1;	// used if nodenum[1] is a space.
 			char *nodenum = (char*) malloc(3);
 			strncpy(nodenum, msg+3, 5);
 			// check for undesirable characters in our "number"
 			if 	(((nodenum[0] < '0') || (nodenum[0] > '9')) || ((nodenum[1] < '0') || (nodenum[1] > '9')))
-			{	
+			{
 				// check if nodenum[1] is a space
 				if (nodenum[1] == ' ')
 					spc = 0;
 					// let it slide
 				else
-				{	
+				{
 					HU_AddChatText("\x82NOTICE: \x80Invalid command format. Correct format is \'/pm<node> \'.");
 					return;
-				}	
+				}
 			}
 			// I'm very bad at C, I swear I am, additional checks eww!
 			if (spc != 0)
-			{	
+			{
 				if (msg[5] != ' ')
 				{
 					HU_AddChatText("\x82NOTICE: \x80Invalid command format. Correct format is \'/pm<node> \'.");
 					return;
 				}
 			}
-			
+
 			target = atoi((const char*) nodenum);	// turn that into a number
 			//CONS_Printf("%d\n", target);
-		
+
 			// check for target player, if it doesn't exist then we can't send the message!
 			if (playeringame[target])	// player exists
 				target++;				// even though playernums are from 0 to 31, target is 1 to 32, so up that by 1 to have it work!
@@ -981,14 +981,14 @@ static void HU_queueChatChar(char c)
 			// we need to get rid of the /pm<node>
 			const char *newmsg = msg+5+spc;
 			memcpy(msg, newmsg, 255);
-		}	
+		}
 		if (ci > 3) // don't send target+flags+empty message.
 		{
 			if (teamtalk)
 				buf[0] = -1; // target
 			else
 				buf[0] = target;
-			
+
 			buf[1] = 0; // flags
 			SendNetXCmd(XD_SAY, buf, 2 + strlen(&buf[2]) + 1);
 		}
@@ -1013,13 +1013,13 @@ static boolean justscrolledup;
 //
 boolean HU_Responder(event_t *ev)
 {
-	UINT8 c=0;
-		
+	INT32 c=0;
+
 	if (ev->type != ev_keydown)
 		return false;
 
 	// only KeyDown events now...
-	
+
 	if (!chat_on)
 	{
 		// enter chat mode
@@ -1048,7 +1048,7 @@ boolean HU_Responder(event_t *ev)
 	}
 	else // if chat_on
 	{
-		
+
 		// Ignore modifier keys
 		// Note that we do this here so users can still set
 		// their chat keys to one of these, if they so desire.
@@ -1057,39 +1057,39 @@ boolean HU_Responder(event_t *ev)
 		 || ev->data1 == KEY_LALT || ev->data1 == KEY_RALT)
 			return true;
 
-		c = (UINT8)ev->data1;
-		
+		c = (INT32)ev->data1;
+
 		// capslock
 		if (c && c == KEY_CAPSLOCK)	// it's a toggle.
-		{	
+		{
 			if (capslock)
 				capslock = false;
-			else	
+			else
 				capslock = true;
 			return true;
-		}	
-		
-		// use console translations		
+		}
+
+		// use console translations
 		if (shiftdown ^ capslock)
 			c = shiftxform[c];
-		
+
 		// TODO: make chat behave like the console, so that we can go back and edit stuff when we fuck up.
-		
+
 		// pasting. pasting is cool. chat is a bit limited, though :(
 		if ((c == 'v' || c == 'V') && ctrldown)
 		{
 			const char *paste = I_ClipboardPaste();
-			
+
 			// create a dummy string real quickly
-			
+
 			if (paste == NULL)
 				return true;
-			
+
 			size_t chatlen = strlen(w_chat);
 			size_t pastelen = strlen(paste);
 			if (chatlen+pastelen > HU_MAXMSGLEN)
 				return true; // we can't paste this!!
-			
+
 			if (c_input >= strlen(w_chat))	// add it at the end of the string.
 			{
 				memcpy(&w_chat[chatlen], paste, pastelen);	// copy all of that.
@@ -1102,43 +1102,43 @@ boolean HU_Responder(event_t *ev)
 				return true;
 			}
 			else	// otherwise, we need to shift everything and make space, etc etc
-			{	
+			{
 				size_t i = HU_MAXMSGLEN-1;
 				for (; i>=c_input;i--)
 				{
 					if (w_chat[i])
 						w_chat[i+pastelen] = w_chat[i];
-					
+
 				}
 				memcpy(&w_chat[c_input], paste, pastelen);	// copy all of that.
 				c_input += pastelen;
 				return true;
 			}
 		}
-		
+
 		if (HU_keyInChatString(w_chat,c))
-		{	
+		{
 			HU_queueChatChar(c);
-		}	
+		}
 		if (c == KEY_ENTER)
-		{	
+		{
 			chat_on = false;
 			c_input = 0;			// reset input cursor
 			chat_scrollmedown = true; // you hit enter, so you might wanna autoscroll to see what you just sent. :)
-		}	
+		}
 		else if (c == KEY_ESCAPE)
-		{	
+		{
 			chat_on = false;
 			c_input = 0;			// reset input cursor
-		}	
+		}
 		else if ((c == KEY_UPARROW || c == KEY_MOUSEWHEELUP) && chat_scroll > 0)	// CHAT SCROLLING YAYS!
 		{
 			chat_scroll--;
 			justscrolledup = true;
 			chat_scrolltime = 4;
-		}	
+		}
 		else if ((c == KEY_DOWNARROW || c == KEY_MOUSEWHEELDOWN) && chat_scroll < chat_maxscroll && chat_maxscroll > 0)
-		{	
+		{
 			chat_scroll++;
 			justscrolleddown = true;
 			chat_scrolltime = 4;
@@ -1146,7 +1146,7 @@ boolean HU_Responder(event_t *ev)
 		else if (c == KEY_LEFTARROW && c_input != 0)	// i said go back
 			c_input--;
 		else if (c == KEY_RIGHTARROW && c_input < strlen(w_chat))
-			c_input++;	
+			c_input++;
 		return true;
 	}
 	return false;
@@ -1187,7 +1187,7 @@ static UINT8 *CHAT_GetStringColormap(INT32 colorflags)	// pasted from video.c, s
 // This is a muuuch better method than V_WORDWRAP.
 // again stolen and modified a bit from video.c, don't mind me, will need to rearrange this one day.
 // this one is simplified for the chat drawer.
-char *CHAT_WordWrap(INT32 x, INT32 w, INT32 option, const char *string)
+static char *CHAT_WordWrap(INT32 x, INT32 w, INT32 option, const char *string)
 {
 	int c;
 	size_t chw, i, lastusablespace = 0;
@@ -1229,7 +1229,7 @@ char *CHAT_WordWrap(INT32 x, INT32 w, INT32 option, const char *string)
 		{
 			//CONS_Printf("Wrap at index %d\n", i);
 			newstring[lastusablespace] = '\n';
-			i = lastusablespace+1;	
+			i = lastusablespace+1;
 			lastusablespace = 0;
 			x = 0;
 		}
@@ -1247,29 +1247,27 @@ INT16 chatx = 13, chaty = 169;	// let's use this as our coordinates, shh
 
 static void HU_drawMiniChat(void)
 {
-	
 	if (!chat_nummsg_min)
 		return;	// needless to say it's useless to do anything if we don't have anything to draw.
-	
-	
-	INT32 x = chatx+2; 
-	INT32 charwidth = 4, charheight = 6;	
+
+	INT32 x = chatx+2;
+	INT32 charwidth = 4, charheight = 6;
 	INT32 dx = 0, dy = 0;
 	size_t i = chat_nummsg_min;
-	
+
 	INT32 msglines = 0;
 	// process all messages once without rendering anything or doing anything fancy so that we know how many lines each message has...
-	
+
 	for (; i>0; i--)
-	{	
+	{
 		const char *msg = CHAT_WordWrap(x, cv_chatwidth.value-charwidth, V_SNAPTOBOTTOM|V_SNAPTOLEFT|V_ALLOWLOWERCASE, chat_mini[i-1]);
 		size_t j = 0;
 		INT32 linescount = 0;
-		
+
 		while(msg[j])	// iterate through msg
-		{	
+		{
 			if (msg[j] < HU_FONTSTART)	// don't draw
-			{			
+			{
 				if (msg[j] == '\n')	// get back down.
 				{
 					++j;
@@ -1282,14 +1280,14 @@ static void HU_drawMiniChat(void)
 					++j;
 					continue;
 				}
-				
-				++j;	
+
+				++j;
 			}
 			else
 			{
 				j++;
 			}
-			
+
 			dx += charwidth;
 			if (dx >= cv_chatwidth.value)
 			{
@@ -1301,25 +1299,24 @@ static void HU_drawMiniChat(void)
 		dx = 0;
 		msglines += linescount+1;
 	}
-	
+
 	INT32 y = chaty - charheight*(msglines+1) - (cv_kartspeedometer.value ? 16 : 0);
-	dx = 0; 
+	dx = 0;
 	dy = 0;
 	i = 0;
-	
+
 	for (; i<=(chat_nummsg_min-1); i++)	// iterate through our hot messages
 	{
-		
 		INT32 clrflag = 0;
-		INT32 timer = ((cv_chattime.value*TICRATE)-chat_timers[i]) - cv_chattime.value*TICRATE+9;	// see below...		
+		INT32 timer = ((cv_chattime.value*TICRATE)-chat_timers[i]) - cv_chattime.value*TICRATE+9;	// see below...
 		INT32 transflag = (timer >= 0 && timer <= 9) ? (timer*V_10TRANS) : 0;	// you can make bad jokes out of this one.
 		size_t j = 0;
 		const char *msg = CHAT_WordWrap(x, cv_chatwidth.value-charwidth, V_SNAPTOBOTTOM|V_SNAPTOLEFT|V_ALLOWLOWERCASE, chat_mini[i]);	// get the current message, and word wrap it.
-		
+
 		while(msg[j])	// iterate through msg
-		{	
+		{
 			if (msg[j] < HU_FONTSTART)	// don't draw
-			{			
+			{
 				if (msg[j] == '\n')	// get back down.
 				{
 					++j;
@@ -1333,15 +1330,15 @@ static void HU_drawMiniChat(void)
 					++j;
 					continue;
 				}
-				
-				++j;	
+
+				++j;
 			}
 			else
 			{
 				UINT8 *colormap = CHAT_GetStringColormap(clrflag);
 				V_DrawChatCharacter(x + dx + 2, y+dy, msg[j++] |V_SNAPTOBOTTOM|V_SNAPTOLEFT|transflag, !cv_allcaps.value, colormap);
 			}
-			
+
 			dx += charwidth;
 			if (dx >= cv_chatwidth.value)
 			{
@@ -1352,10 +1349,10 @@ static void HU_drawMiniChat(void)
 		dy += charheight;
 		dx = 0;
 	}
-		
+
 	// decrement addy and make that shit smooth:
 	addy /= 2;
-	
+
 }
 
 // HU_DrawUpArrow
@@ -1367,7 +1364,7 @@ static void HU_DrawUpArrow(INT32 x, INT32 y, INT32 options)
 	V_DrawFill(x+2, y, 1, 1, 103|options);
 	V_DrawFill(x+1, y+1, 3, 1, 103|options);
 	V_DrawFill(x, y+2, 5, 1, 103|options);	// that's the yellow part, I swear
-	
+
 	V_DrawFill(x+3, y, 1, 1, 26|options);
 	V_DrawFill(x+4, y+1, 1, 1, 26|options);
 	V_DrawFill(x+5, y+2, 1, 1, 26|options);
@@ -1384,40 +1381,40 @@ static void HU_DrawDownArrow(INT32 x, INT32 y, INT32 options)
 	V_DrawFill(x, y+1, 5, 1, 26|options);
 	V_DrawFill(x+1, y+2, 3, 1, 26|options);
 	V_DrawFill(x+2, y+3, 1, 1, 26|options);	// that's the black part. no racism intended. i swear.
-	
+
 	V_DrawFill(x, y, 5, 1, 103|options);
 	V_DrawFill(x+1, y+1, 3, 1, 103|options);
 	V_DrawFill(x+2, y+2, 1, 1, 103|options);	// that's the yellow part, I swear
-}	
+}
 
 // HU_DrawChatLog
 // TODO: fix dumb word wrapping issues
 
 static void HU_drawChatLog(INT32 offset)
 {
-	
+
 	// before we do anything, make sure that our scroll position isn't "illegal";
 	if (chat_scroll > chat_maxscroll)
 		chat_scroll = chat_maxscroll;
-	
+
 	INT32 charwidth = 4, charheight = 6;
 	INT32 x = chatx+2, y = chaty - offset*charheight - (chat_scroll*charheight) - cv_chatheight.value*charheight - 12 - (cv_kartspeedometer.value ? 16 : 0), dx = 0, dy = 0;
-	size_t i = 0;
+	UINT32 i = 0;
 	INT32 chat_topy = y + chat_scroll*charheight;
 	INT32 chat_bottomy = chat_topy + cv_chatheight.value*charheight;
 	boolean atbottom = false;
-	
+
 	V_DrawFillConsoleMap(chatx, chat_topy, cv_chatwidth.value, cv_chatheight.value*charheight +2, 239|V_SNAPTOBOTTOM|V_SNAPTOLEFT);	// log box
-		
+
 	for (i=0; i<chat_nummsg_log; i++)	// iterate through our chatlog
 	{
 		INT32 clrflag = 0;
-		size_t j = 0;
+		INT32 j = 0;
 		const char *msg = CHAT_WordWrap(x, cv_chatwidth.value-charwidth, V_SNAPTOBOTTOM|V_SNAPTOLEFT|V_ALLOWLOWERCASE, chat_log[i]);	// get the current message, and word wrap it.
 		while(msg[j])	// iterate through msg
-		{	
+		{
 			if (msg[j] < HU_FONTSTART)	// don't draw
-			{			
+			{
 				if (msg[j] == '\n')	// get back down.
 				{
 					++j;
@@ -1431,20 +1428,20 @@ static void HU_drawChatLog(INT32 offset)
 					++j;
 					continue;
 				}
-				
-				++j;	
+
+				++j;
 			}
 			else
 			{
 				if ((y+dy+2 >= chat_topy) && (y+dy < (chat_bottomy)))
-				{	
+				{
 					UINT8 *colormap = CHAT_GetStringColormap(clrflag);
 					V_DrawChatCharacter(x + dx + 2, y+dy+2, msg[j++] |V_SNAPTOBOTTOM|V_SNAPTOLEFT, !cv_allcaps.value, colormap);
 				}
 				else
 					j++;	// don't forget to increment this or we'll get stuck in the limbo.
 			}
-			
+
 			dx += charwidth;
 			if (dx >= cv_chatwidth.value-charwidth-2 && i<chat_nummsg_log && msg[j] >= HU_FONTSTART) // end of message shouldn't count, nor should invisible characters!!!!
 			{
@@ -1455,32 +1452,34 @@ static void HU_drawChatLog(INT32 offset)
 		dy += charheight;
 		dx = 0;
 	}
-	
+
 	if (((chat_scroll >= chat_maxscroll) || (chat_scrollmedown)) && !(justscrolleddown || justscrolledup || chat_scrolltime))	// was already at the bottom of the page before new maxscroll calculation and was NOT scrolling.
 	{
 		atbottom = true;	// we should scroll
 	}
 	chat_scrollmedown = false;
-	
+
 	// getmaxscroll through a lazy hack. We do all these loops, so let's not do more loops that are gonna lag the game more. :P
-	chat_maxscroll = (dy/charheight)-cv_chatheight.value;	// welcome to C, we don't know what min() and max() are.
-	if (chat_maxscroll < 0)
+	chat_maxscroll = (dy/charheight);	// welcome to C, we don't know what min() and max() are.
+	if (chat_maxscroll <= (UINT32)cv_chatheight.value)
 		chat_maxscroll = 0;
-	
+	else
+		chat_maxscroll -= cv_chatheight.value;
+
 	// if we're not bound by the time, autoscroll for next frame:
 	if (atbottom)
 		chat_scroll = chat_maxscroll;
-	
+
 	// draw arrows to indicate that we can (or not) scroll.
-	
+
 	if (chat_scroll > 0)
 		HU_DrawUpArrow(chatx-8, ((justscrolledup) ? (chat_topy-1) : (chat_topy)), V_SNAPTOBOTTOM | V_SNAPTOLEFT);
 	if (chat_scroll < chat_maxscroll)
 		HU_DrawDownArrow(chatx-8, chat_bottomy-((justscrolleddown) ? 3 : 4), V_SNAPTOBOTTOM | V_SNAPTOLEFT);
-	
+
 	justscrolleddown = false;
 	justscrolledup = false;
-}	
+}
 
 //
 // HU_DrawChat
@@ -1490,13 +1489,13 @@ static void HU_drawChatLog(INT32 offset)
 
 static INT16 typelines = 1;	// number of drawfill lines we need. it's some weird hack and might be one frame off but I'm lazy to make another loop.
 static void HU_DrawChat(void)
-{	
+{
 	INT32 charwidth = 4, charheight = 6;
 	INT32 t = 0, c = 0, y = chaty - (typelines*charheight)  - (cv_kartspeedometer.value ? 16 : 0);
-	size_t i = 0;
+	UINT32 i = 0;
 	const char *ntalk = "Say: ", *ttalk = "Team: ";
 	const char *talk = ntalk;
-	
+
 	if (teamtalk)
 	{
 		talk = ttalk;
@@ -1507,9 +1506,9 @@ static void HU_DrawChat(void)
 			t = 0x400; // Blue
 #endif
 	}
-			
+
 	V_DrawFillConsoleMap(chatx, y-1, cv_chatwidth.value, (typelines*charheight), 239 | V_SNAPTOBOTTOM | V_SNAPTOLEFT);
-	
+
 	while (talk[i])
 	{
 		if (talk[i] < HU_FONTSTART)
@@ -1519,13 +1518,13 @@ static void HU_DrawChat(void)
 
 		c += charwidth;
 	}
-	
+
 	i = 0;
 	typelines = 1;
-	
+
 	if ((strlen(w_chat) == 0 || c_input == 0) && hu_tick < 4)
 		V_DrawChatCharacter(chatx + 2 + c, y+1, '_' |V_SNAPTOBOTTOM|V_SNAPTOLEFT|t, !cv_allcaps.value, NULL);
-		
+
 	while (w_chat[i])
 	{
 		boolean skippedline = false;
@@ -1534,16 +1533,16 @@ static void HU_DrawChat(void)
 			int cursorx = (c+charwidth < cv_chatwidth.value-charwidth) ? (chatx + 2 + c+charwidth) : (chatx+1);	// we may have to go down.
 			int cursory = (cursorx != chatx+1) ? (y) : (y+charheight);
 			if (hu_tick < 4)
-				V_DrawChatCharacter(cursorx, cursory+1, '_' |V_SNAPTOBOTTOM|V_SNAPTOLEFT|t, !cv_allcaps.value, NULL);	
-			
+				V_DrawChatCharacter(cursorx, cursory+1, '_' |V_SNAPTOBOTTOM|V_SNAPTOLEFT|t, !cv_allcaps.value, NULL);
+
 			if (cursorx == chatx+1)	// a weirdo hack
 			{
 				typelines += 1;
 				skippedline = true;
-			}	
-			
-		}	
-		
+			}
+
+		}
+
 		//Hurdler: isn't it better like that?
 		if (w_chat[i] < HU_FONTSTART)
 			++i;
@@ -1561,56 +1560,56 @@ static void HU_DrawChat(void)
 
 	// handle /pm list.
 	if (strnicmp(w_chat, "/pm", 3) == 0 && vid.width >= 400 && !teamtalk)	// 320x200 unsupported kthxbai
-	{	
+	{
 		i = 0;
-		int count = 0;
+		INT32 count = 0;
 		INT32 p_dispy = chaty - charheight -1;
 		for(i=0; (i<MAXPLAYERS); i++)
 		{
-			
+
 			// filter: (code needs optimization pls help I'm bad with C)
 			if (w_chat[3])
 			{
-				
+
 				// right, that's half important: (w_chat[4] may be a space since /pm0 msg is perfectly acceptable!)
 				if ( ( ((w_chat[3] != 0) && ((w_chat[3] < '0') || (w_chat[3] > '9'))) || ((w_chat[4] != 0) && (((w_chat[4] < '0') || (w_chat[4] > '9'))))) && (w_chat[4] != ' '))
 					break;
-					
-				
+
+
 				char *nodenum = (char*) malloc(3);
 				strncpy(nodenum, w_chat+3, 4);
-				INT32 n = atoi((const char*) nodenum);	// turn that into a number
+				UINT32 n = atoi((const char*) nodenum);	// turn that into a number
 				// special cases:
-				
+
 				if ((n == 0) && !(w_chat[4] == '0'))
-				{	
+				{
 					if (!(i<10))
-						continue;		
+						continue;
 				}
 				else if ((n == 1) && !(w_chat[3] == '0'))
-				{	
+				{
 					if (!((i == 1) || ((i >= 10) && (i <= 19))))
 						continue;
 				}
 				else if ((n == 2) && !(w_chat[3] == '0'))
-				{	
+				{
 					if (!((i == 2) || ((i >= 20) && (i <= 29))))
 						continue;
 				}
 				else if ((n == 3) && !(w_chat[3] == '0'))
-				{	
+				{
 					if (!((i == 3) || ((i >= 30) && (i <= 31))))
 						continue;
 				}
 				else	// general case.
-				{	
+				{
 					if (i != n)
 						continue;
 				}
 			}
-			
+
 			if (playeringame[i])
-			{	
+			{
 				char name[MAXPLAYERNAME+1];
 				strlcpy(name, player_names[i], 7);	// shorten name to 7 characters.
 				V_DrawFillConsoleMap(chatx+ cv_chatwidth.value + 2, p_dispy- (6*count), 48, 6, 239 | V_SNAPTOBOTTOM | V_SNAPTOLEFT);	// fill it like the chat so the text doesn't become hard to read because of the hud.
@@ -1622,11 +1621,11 @@ static void HU_DrawChat(void)
 		{
 			V_DrawFillConsoleMap(chatx-50, p_dispy- (6*count), 48, 6, 239 | V_SNAPTOBOTTOM | V_SNAPTOLEFT);	// fill it like the chat so the text doesn't become hard to read because of the hud.
 			V_DrawSmallString(chatx-48, p_dispy- (6*count), V_SNAPTOBOTTOM|V_SNAPTOLEFT|V_ALLOWLOWERCASE, "NO RESULT.");
-		}	
+		}
 	}
-	
+
 	HU_drawChatLog(typelines-1);	// typelines is the # of lines we're typing. If there's more than 1 then the log should scroll up to give us more space.
-	
+
 }
 
 // why the fuck would you use this...
@@ -1664,21 +1663,21 @@ static void HU_DrawChat_Old(void)
 		}
 		c += charwidth;
 	}
-	
+
 	if ((strlen(w_chat) == 0 || c_input == 0) && hu_tick < 4)
 		V_DrawCharacter(HU_INPUTX+c, y+2*con_scalefactor, '_' |cv_constextsize.value | V_NOSCALESTART|t, !cv_allcaps.value);
-	
+
 	i = 0;
 	while (w_chat[i])
 	{
-		
+
 		if (c_input == (i+1) && hu_tick < 4)
 		{
 			int cursorx = (HU_INPUTX+c+charwidth < vid.width) ? (HU_INPUTX + c + charwidth) : (HU_INPUTX);	// we may have to go down.
 			int cursory = (cursorx != HU_INPUTX) ? (y) : (y+charheight);
-			V_DrawCharacter(cursorx, cursory+2*con_scalefactor, '_' |cv_constextsize.value | V_NOSCALESTART|t, !cv_allcaps.value);	
-		}	
-		
+			V_DrawCharacter(cursorx, cursory+2*con_scalefactor, '_' |cv_constextsize.value | V_NOSCALESTART|t, !cv_allcaps.value);
+		}
+
 		//Hurdler: isn't it better like that?
 		if (w_chat[i] < HU_FONTSTART)
 		{
@@ -1953,8 +1952,8 @@ void HU_Drawer(void)
 {
 	// draw chat string plus cursor
 	if (chat_on)
-	{	
-		// count down the scroll timer. 
+	{
+		// count down the scroll timer.
 		if (chat_scrolltime > 0)
 			chat_scrolltime--;
 		if (!cv_consolechat.value && vid.width > 320)	// don't even try using newchat sub 400p, I'm too fucking lazy
@@ -1965,27 +1964,27 @@ void HU_Drawer(void)
 	else
 	{
 		if (!cv_consolechat.value)
-		{	
+		{
 			HU_drawMiniChat();		// draw messages in a cool fashion.
 			chat_scrolltime = 0;	// do scroll anyway.
 			typelines = 1;			// make sure that the chat doesn't have a weird blinking huge ass square if we typed a lot last time.
-		}	
+		}
 	}
-	
+
 	if (netgame)	// would handle that in hu_drawminichat, but it's actually kinda awkward when you're typing a lot of messages. (only handle that in netgames duh)
 	{
 		size_t i = 0;
-		
+
 		// handle spam while we're at it:
 		for(; (i<MAXPLAYERS); i++)
-		{	
+		{
 			if (stop_spamming_you_cunt[i] > 0)
 				stop_spamming_you_cunt[i]--;
-		}	
-		
+		}
+
 		// handle chat timers
 		for (i=0; (i<chat_nummsg_min); i++)
-		{	
+		{
 			if (chat_timers[i] > 0)
 				chat_timers[i]--;
 			else
@@ -2036,7 +2035,7 @@ void HU_Drawer(void)
 
 		if (cv_crosshair2.value && !camera2.chase && !players[secondarydisplayplayer].spectator)
 			HU_DrawCrosshair2();
-	
+
 		if (cv_crosshair3.value && !camera3.chase && !players[thirddisplayplayer].spectator)
 			HU_DrawCrosshair3();
 
@@ -2145,29 +2144,29 @@ void HU_drawPing(INT32 x, INT32 y, INT32 ping, boolean notext)
 	SINT8 i = 0;
 	SINT8 yoffset = 6;
 	if (ping < 128)
-	{	
+	{
 		numbars = 3;
 		barcolor = 184;
-	}	
+	}
 	else if (ping < 256)
-	{	
+	{
 		numbars = 2;	// Apparently ternaries w/ multiple statements don't look good in C so I decided against it.
 		barcolor = 103;
-	}	
-	
+	}
+
 	INT32 dx = x+1 - (V_SmallStringWidth(va("%dms", ping), V_ALLOWLOWERCASE)/2);
 	if (!notext || vid.width >= 640)	// how sad, we're using a shit resolution.
 		V_DrawSmallString(dx, y+4, V_ALLOWLOWERCASE, va("%dms", ping));
-	
+
 	for (i=0; (i<3); i++)		// Draw the ping bar
-	{	
+	{
 		V_DrawFill(x+2 *(i-1), y+yoffset-4, 2, 8-yoffset, 31);
 		if (i < numbars)
 			V_DrawFill(x+2 *(i-1), y+yoffset-3, 1, 8-yoffset-1, barcolor);
-		
+
 		yoffset -= 2;
 	}
-}	
+}
 
 //
 // HU_DrawTabRankings
@@ -2192,13 +2191,13 @@ void HU_DrawTabRankings(INT32 x, INT32 y, playersort_t *tab, INT32 scorelines, I
 	{
 		if (players[tab[i].num].spectator || !players[tab[i].num].mo)
 			continue; //ignore them.
-		
+
 		if (!splitscreen)	// don't draw it on splitscreen,
 		{
 			if (!(tab[i].num == serverplayer))
 				HU_drawPing(x+ 253, y+2, playerpingtable[tab[i].num], false);
-		}	
-		
+		}
+
 		V_DrawString(x + 20, y,
 			((tab[i].num == whiteplayer)
 				? hilicol|V_ALLOWLOWERCASE
@@ -2332,10 +2331,10 @@ void HU_DrawTabRankings(INT32 x, INT32 y, playersort_t *tab, INT32 scorelines, I
 		}
 		V_DrawRightAlignedThinString(x+120, y-1, ((players[tab[i].num].health > 0) ? 0 : V_TRANSLUCENT), va("%u", tab[i].count));
 		if (!splitscreen)
-		{	
+		{
 			if (!(tab[i].num == serverplayer))
 				HU_drawPing(x+ 113, y+2, playerpingtable[tab[i].num], false);
-		}	
+		}
 	}
 }
 
diff --git a/src/lua_baselib.c b/src/lua_baselib.c
index 587f9514..068ae204 100644
--- a/src/lua_baselib.c
+++ b/src/lua_baselib.c
@@ -20,6 +20,7 @@
 #include "m_random.h"
 #include "s_sound.h"
 #include "g_game.h"
+#include "hu_stuff.h"
 #include "k_kart.h"
 
 #include "lua_script.h"
diff --git a/src/m_menu.c b/src/m_menu.c
index 63eae220..4428ab3a 100644
--- a/src/m_menu.c
+++ b/src/m_menu.c
@@ -1047,7 +1047,7 @@ static menuitem_t OP_MainMenu[] =
 	{IT_SUBMENU|IT_STRING,		NULL, "Video Options...",		&OP_VideoOptionsDef,		 30},
 	{IT_SUBMENU|IT_STRING,		NULL, "Sound Options...",		&OP_SoundOptionsDef,		 40},
 
-	{IT_SUBMENU|IT_STRING,		NULL, "HUD Options...",		&OP_HUDOptionsDef,			 60},
+	{IT_SUBMENU|IT_STRING,		NULL, "HUD Options...",			&OP_HUDOptionsDef,			 60},
 	{IT_STRING|IT_CALL,			NULL, "Screenshot Options...",	M_ScreenshotOptions,		 70},
 
 	{IT_SUBMENU|IT_STRING,		NULL, "Gameplay Options...",	&OP_GameOptionsDef,			 90},
@@ -1334,13 +1334,14 @@ static menuitem_t OP_SoundOptionsMenu[] =
 
 	{IT_STRING|IT_CALL,			NULL, "Restart Audio System",	M_RestartAudio,			 50},
 
-	{IT_STRING|IT_CVAR,			NULL, "Reverse L/R Channels",	&stereoreverse,			 70},
-	{IT_STRING|IT_CVAR,			NULL, "Surround Sound",			&surround,				 80},
+	{IT_STRING|IT_CVAR,			NULL, "Reverse L/R Channels",	&stereoreverse,			 65},
+	{IT_STRING|IT_CVAR,			NULL, "Surround Sound",			&surround,				 75},
 
+	{IT_STRING|IT_CVAR,			NULL, "Chat sounds",			&cv_chatnotifications,	 90},
 	{IT_STRING|IT_CVAR,			NULL, "Character voices",		&cv_kartvoices,			100},
 	{IT_STRING|IT_CVAR,			NULL, "Powerup Warning",		&cv_kartinvinsfx,		110},
 
-	{IT_KEYHANDLER|IT_STRING,	NULL, "Sound Test",				M_HandleSoundTest,		130},
+	{IT_KEYHANDLER|IT_STRING,	NULL, "Sound Test",				M_HandleSoundTest,		125},
 };
 
 /*static menuitem_t OP_DataOptionsMenu[] =
@@ -1393,19 +1394,27 @@ static menuitem_t OP_EraseDataMenu[] =
 
 static menuitem_t OP_HUDOptionsMenu[] =
 {
-	{IT_STRING | IT_CVAR, NULL, "Show HUD (F3)",					&cv_showhud,			 10},
+	{IT_STRING | IT_CVAR, NULL, "Show HUD (F3)",			&cv_showhud,			 10},
 	{IT_STRING | IT_CVAR | IT_CV_SLIDER,
 	                      NULL, "HUD Visibility",			&cv_translucenthud,		 20},
 
 	{IT_STRING | IT_CVAR | IT_CV_SLIDER,
-						  NULL, "Minimap Visibility",		&cv_kartminimap,		 40},
-	{IT_STRING | IT_CVAR, NULL, "Speedometer Display",		&cv_kartspeedometer,	 50},
-	{IT_STRING | IT_CVAR, NULL, "Show \"CHECK\"",			&cv_kartcheck,			 60},
+						  NULL, "Minimap Visibility",		&cv_kartminimap,		 35},
+	{IT_STRING | IT_CVAR, NULL, "Speedometer Display",		&cv_kartspeedometer,	 45},
+	{IT_STRING | IT_CVAR, NULL, "Show \"CHECK\"",			&cv_kartcheck,			 55},
 
-	{IT_STRING | IT_CVAR, NULL, "Console Color",			&cons_backcolor,		 80},
-	{IT_STRING | IT_CVAR, NULL, "Console Text Size",		&cv_constextsize,		 90},
+	{IT_STRING | IT_CVAR, NULL, "Menu Highlights",			&cons_menuhighlight,     70},
+	// highlight info - (GOOD HIGHLIGHT, WARNING HIGHLIGHT) - 80 (see M_DrawHUDOptions)
 
-	{IT_STRING | IT_CVAR, NULL, "Menu Highlights",			&cons_menuhighlight,    110},
+	//{IT_STRING | IT_CVAR, NULL, "Chat mode",				&cv_consolechat,		 95}, -- will ANYONE who doesn't know how to use the console want to touch this
+	{IT_STRING | IT_CVAR | IT_CV_SLIDER,
+	                      NULL, "Chat box width",			&cv_chatwidth,		 	 95},
+	{IT_STRING | IT_CVAR | IT_CV_SLIDER,
+	                      NULL, "Chat box height",			&cv_chatheight,		 	105},
+	{IT_STRING | IT_CVAR, NULL, "Chat fadeout time",		&cv_chattime,			115},
+
+	{IT_STRING | IT_CVAR, NULL, "Background Color",			&cons_backcolor,		130},
+	{IT_STRING | IT_CVAR, NULL, "Console Text Size",		&cv_constextsize,		140},
 };
 
 static menuitem_t OP_GameOptionsMenu[] =
@@ -1420,7 +1429,7 @@ static menuitem_t OP_GameOptionsMenu[] =
 	{IT_STRING | IT_CVAR, NULL, "Exit Countdown Timer",			&cv_countdowntime,		 80},
 
 	//{IT_STRING | IT_CVAR, NULL, "Time Limit",					&cv_timelimit,			100},
-	{IT_STRING | IT_CVAR, NULL, "Starting Bumpers",			&cv_kartbumpers,		100},
+	{IT_STRING | IT_CVAR, NULL, "Starting Bumpers",				&cv_kartbumpers,		100},
 	{IT_STRING | IT_CVAR, NULL, "Karma Comeback",				&cv_kartcomeback,		110},
 
 	{IT_STRING | IT_CVAR, NULL, "Force Character #",			&cv_forceskin,          130},
@@ -1440,10 +1449,10 @@ static menuitem_t OP_ServerOptionsMenu[] =
 
 #ifndef NONET
 	{IT_STRING | IT_CVAR,    NULL, "Max Player Count",				&cv_maxplayers,			 80},
-	{IT_STRING | IT_CVAR,    NULL, "Allow Players to Join",		&cv_allownewplayer,		 90},
+	{IT_STRING | IT_CVAR,    NULL, "Allow Players to Join",			&cv_allownewplayer,		 90},
 	//{IT_STRING | IT_CVAR,    NULL, "Join on Map Change",			&cv_joinnextround,		100},
 
-	{IT_STRING | IT_CVAR,    NULL, "Allow WAD Downloading",		&cv_downloading,		100},
+	{IT_STRING | IT_CVAR,    NULL, "Allow WAD Downloading",			&cv_downloading,		100},
 	{IT_STRING | IT_CVAR,    NULL, "Attempts to Resynch",			&cv_resynchattempts,	110},
 #endif
 };
@@ -8364,7 +8373,7 @@ static void M_DrawHUDOptions(void)
 	const char *str1 = " Warning highlight";
 	const char *str2 = ",";
 	const char *str3 = "Good highlight";
-	INT32 x = BASEVIDWIDTH - currentMenu->x + 2, y = currentMenu->y + 120;
+	INT32 x = BASEVIDWIDTH - currentMenu->x + 2, y = currentMenu->y + 80;
 	INT32 w0 = V_StringWidth(str0, 0), w1 = V_StringWidth(str1, 0), w2 = V_StringWidth(str2, 0), w3 = V_StringWidth(str3, 0);
 	M_DrawGenericMenu();
 	x -= w0;

From b319c2d9b848bfcf5fa83d4ac6ce2dd221a4d58f Mon Sep 17 00:00:00 2001
From: toaster <rollerorbital@gmail.com>
Date: Fri, 3 Aug 2018 23:01:09 +0100
Subject: [PATCH 10/10] * Homogenise old chat mode detection, which includes
 `cv_consolechat.value`, `dedicated`, and `vid.width < 640`. * Make the chat
 notification sounds work in old chat mode.

---
 src/console.c     |  2 +-
 src/hu_stuff.c    | 26 ++++++++++----------------
 src/hu_stuff.h    |  2 ++
 src/lua_baselib.c | 19 +++++++++++++------
 4 files changed, 26 insertions(+), 23 deletions(-)

diff --git a/src/console.c b/src/console.c
index eaa98550..212e6c8d 100644
--- a/src/console.c
+++ b/src/console.c
@@ -1442,7 +1442,7 @@ static void CON_DrawHudlines(void)
 	if (con_hudlines <= 0)
 		return;
 
-	if (chat_on && (cv_consolechat.value || vid.width < 640))
+	if (chat_on && OLDCHAT)
 		y = charheight; // leave place for chat input in the first row of text
 	else
 		y = 0;
diff --git a/src/hu_stuff.c b/src/hu_stuff.c
index dd0d61fe..338fd26c 100644
--- a/src/hu_stuff.c
+++ b/src/hu_stuff.c
@@ -388,6 +388,8 @@ static void HU_removeChatText_Log(void)
 
 void HU_AddChatText(const char *text)
 {
+	if (cv_chatnotifications.value)
+		S_StartSound(NULL, sfx_radio);
 
 	// TODO: check if we're oversaturating the log (we can only log CHAT_BUFSIZE messages.)
 
@@ -791,18 +793,12 @@ static void Got_Saycmd(UINT8 **p, INT32 playernum)
 
 		}
 
-		if (cv_consolechat.value)
-		{
+		HU_AddChatText(va(fmt2, prefix, cstart, dispname, cend, msg)); // add it reguardless, in case we decide to change our mind about our chat type.
+
+		if OLDCHAT
 			CONS_Printf(fmt, prefix, cstart, dispname, cend, msg);
-			HU_AddChatText(va(fmt2, prefix, cstart, dispname, cend, msg));	// add it reguardless, in case we decide to change our mind about our chat type.
-		}
 		else
-		{
-			HU_AddChatText(va(fmt2, prefix, cstart, dispname, cend, msg));
-			CON_LogMessage(va(fmt, prefix, cstart, dispname, cend, msg));	// save to log.txt
-			if (cv_chatnotifications.value)
-				S_StartSound(NULL, sfx_radio);
-		}
+			CON_LogMessage(va(fmt, prefix, cstart, dispname, cend, msg)); // save to log.txt
 
 		if (tempchar)
 			Z_Free(tempchar);
@@ -1956,19 +1952,17 @@ void HU_Drawer(void)
 		// count down the scroll timer.
 		if (chat_scrolltime > 0)
 			chat_scrolltime--;
-		if (!cv_consolechat.value && vid.width > 320)	// don't even try using newchat sub 400p, I'm too fucking lazy
+		if (!OLDCHAT)
 			HU_DrawChat();
 		else
 			HU_DrawChat_Old();	// why the fuck.........................
 	}
 	else
 	{
-		if (!cv_consolechat.value)
-		{
+		chat_scrolltime = 0;	// do scroll anyway.
+		typelines = 1;			// make sure that the chat doesn't have a weird blinking huge ass square if we typed a lot last time.
+		if (!OLDCHAT)
 			HU_drawMiniChat();		// draw messages in a cool fashion.
-			chat_scrolltime = 0;	// do scroll anyway.
-			typelines = 1;			// make sure that the chat doesn't have a weird blinking huge ass square if we typed a lot last time.
-		}
 	}
 
 	if (netgame)	// would handle that in hu_drawminichat, but it's actually kinda awkward when you're typing a lot of messages. (only handle that in netgames duh)
diff --git a/src/hu_stuff.h b/src/hu_stuff.h
index b4a78338..90ffeb42 100644
--- a/src/hu_stuff.h
+++ b/src/hu_stuff.h
@@ -80,6 +80,8 @@ extern patch_t *iconprefix[MAXSKINS];
 
 #define CHAT_BUFSIZE 64		// that's enough messages, right? We'll delete the older ones when that gets out of hand.
 
+#define OLDCHAT (cv_consolechat.value || dedicated || vid.width < 640)
+
 // some functions
 void HU_AddChatText(const char *text);
 
diff --git a/src/lua_baselib.c b/src/lua_baselib.c
index 068ae204..e13c1b0d 100644
--- a/src/lua_baselib.c
+++ b/src/lua_baselib.c
@@ -21,6 +21,7 @@
 #include "s_sound.h"
 #include "g_game.h"
 #include "hu_stuff.h"
+#include "console.h"
 #include "k_kart.h"
 
 #include "lua_script.h"
@@ -96,11 +97,14 @@ static int lib_chatprint(lua_State *L)
 	int len = strlen(str);
 	if (len > 255)	// string is too long!!!
 		return luaL_error(L, "String exceeds the 255 characters limit of the chat buffer.");
-	
-	if (cv_consolechat.value || !netgame)
+
+	HU_AddChatText(str);
+
+	if OLDCHAT
 		CONS_Printf("%s\n", str);
 	else
-		HU_AddChatText(str);
+		CON_LogMessage(str); // save to log.txt
+
 	return 0;
 }
 
@@ -124,11 +128,14 @@ static int lib_chatprintf(lua_State *L)
 	int len = strlen(str);
 	if (len > 255)	// string is too long!!!
 		return luaL_error(L, "String exceeds the 255 characters limit of the chat buffer.");
-	
-	if (cv_consolechat.value || !netgame)
+
+	HU_AddChatText(str);
+
+	if OLDCHAT
 		CONS_Printf("%s\n", str);
 	else
-		HU_AddChatText(str);
+		CON_LogMessage(str); // save to log.txt
+
 	return 0;
 }