X-Git-Url: http://git.shiar.net/netris.git/blobdiff_plain/3b453bab5c990f862a4915ae4e5e4a0e90b167f2..HEAD:/curses.c

diff --git a/curses.c b/curses.c
index a8af702..d24a110 100644
--- a/curses.c
+++ b/curses.c
@@ -15,8 +15,6 @@
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
- * $Id: curses.c,v 1.33 1999/05/16 06:56:25 mhw Exp $
  */
 
 #include "netris.h"
@@ -31,30 +29,27 @@
 #include "curses.h"
 #include "util.h"
 #include "board.h"
-#include "msg.en.h"
+#include "msg.h"
 
 #ifdef NCURSES_VERSION
 # define HAVE_NCURSES
 #endif
 
+window_t window[MAX_SCREENS];
+
 static MyEventType KeyGenFunc(EventGenRec *gen, MyEvent *event);
 static EventGenRec keyGen = {
-//	NULL, 0, FT_read, STDIN_FILENO, KeyGenFunc, EM_key
 	NULL, 0, FT_read, STDIN_FILENO, KeyGenFunc, EM_key
 };
 
-static int boardYPos[MAX_SCREENS], boardXPos[MAX_SCREENS];
-static int boardSize[MAX_SCREENS];
-//^^^struct
 static int statusYPos, statusXPos;
 static int messageYPos, messageXPos, messageHeight, messageWidth;
 WINDOW *msgwin;
 static int haveColor;
-int PlayerDisp[MAX_SCREENS];
 
 #define MSG_HEIGHT 64  //max history
-char *message[MSG_HEIGHT];
-char messages[MSG_HEIGHT][MSG_WIDTH];
+static char *message[MSG_HEIGHT];
+static char messages[MSG_HEIGHT][MSG_WIDTH];
 
 static char *term_vi;  /* String to make cursor invisible */
 static char *term_ve;  /* String to make cursor visible */
@@ -70,7 +65,7 @@ void InitScreens(void)
 	 * Ctrl-C during initialization might leave the terminal in a bad state.
 	 */
 	BlockSignals(&oldMask, SIGINT, 0);
-	initscr();		//start curses
+	initscr();  //start curses
 
 #ifdef CURSES_HACK
 	{
@@ -87,14 +82,14 @@ void InitScreens(void)
 			char type;
 			short color;
 		} myColorTable[] = {
-			{ BT_white,   COLOR_WHITE },
-			{ BT_blue,    COLOR_BLUE },
-			{ BT_magenta, COLOR_MAGENTA },
-			{ BT_cyan,    COLOR_CYAN },
-			{ BT_yellow,  COLOR_YELLOW },
-			{ BT_green,   COLOR_GREEN },
-			{ BT_red,     COLOR_RED },
-			{ BT_none,    0 }
+			{ BT_T, COLOR_WHITE },
+			{ BT_I, COLOR_BLUE },
+			{ BT_O, COLOR_MAGENTA },
+			{ BT_L, COLOR_CYAN },
+			{ BT_J, COLOR_YELLOW },
+			{ BT_S, COLOR_GREEN },
+			{ BT_Z, COLOR_RED },
+			{ BT_none, 0 }
 		}; //myColorTable
 		int i = 0;
 
@@ -137,7 +132,7 @@ void CleanupScreens(void)
 	OutputTermStr(term_ve, 1);
 }
 
-void GetTermcapInfo(void)
+static void GetTermcapInfo(void)
 {
 	char *term, *buf, *data;
 	int bufSize = 8192;
@@ -194,7 +189,7 @@ void GetTermcapInfo(void)
 		term_vi = term_ve = NULL;
 }
 
-void OutputTermStr(char *str, int flush)
+static void OutputTermStr(char *str, int flush)
 {
 	if (str) {
 		fputs(str, stdout);
@@ -202,10 +197,10 @@ void OutputTermStr(char *str, int flush)
 	}
 }
 
-void DrawTitle(void)
+static void DrawTitle(void)
 {
 	int rows, cols;
-	char s[255];
+	char *s;
 
 #ifdef HAVE_NCURSES
 	attrset(A_REVERSE);
@@ -213,17 +208,19 @@ void DrawTitle(void)
 	standout();
 #endif
 	getmaxyx(stdscr, rows, cols);
-	sprintf(s, " NETRIS %s", version_string);
-	memset(&s[strlen(s)], ' ', 254 - strlen(s));
-	if (cols > 56 + strlen(version_string))
-		memcpy(&s[cols - 48],
-			"(C)1994-1996,1999 Mark H. Weaver, (C)2002 Shiar \0", 49);
-	else memcpy(&s[cols], "\0", 1);
+	s = malloc(cols + 1);
+	sprintf(s, " " MSG_TITLE " %s", version_string);
+	const int titlelen = strlen(s);
+	memset(&s[titlelen], ' ', cols - titlelen); // pad
+	if (cols > titlelen + 1 + strlen(MSG_TITLESUB))
+		memcpy(&s[cols - 1 - strlen(MSG_TITLESUB)], MSG_TITLESUB, sizeof(MSG_TITLESUB) - 1);
+	memcpy(&s[cols], "\0", 1);
 	mvaddstr(0, 0, s);
+	free(s);
 	standend();	//normal text
 }
 
-void DrawBox(int x1, int y1, int x2, int y2)
+static void window_border(int x1, int y1, int x2, int y2)
 { //draw grid
 	int y, x;
 
@@ -243,106 +240,102 @@ void DrawBox(int x1, int y1, int x2, int y2)
 	addch(Sets.ascii ? '+' : ACS_LRCORNER);
 }
 
-void DrawField(int scr)
-{ //draw field for player scr
-	if (!PlayerDisp[scr]) return; 
-	DrawBox(boardXPos[scr] - 1, boardYPos[scr] - Players[scr].boardVisible,
-		boardXPos[scr] + boardSize[scr] * Players[scr].boardWidth, boardYPos[scr] + 1);
+void window_draw(int player)
+{ //draw field for player
+	if (!window[player].shown) return; 
+	window_border(window[player].posx - 1, window[player].posy - Players[player].boardVisible,
+		window[player].posx + window[player].size * Players[player].boardWidth, window[player].posy + 1);
 	{
-		char s[boardSize[scr]*Players[scr].boardWidth+1];
+		char s[window[player].size * Players[player].boardWidth + 1];
 
-		if (Players[scr].host && Players[scr].host[0])
+		if (Players[player].host && Players[player].host[0])
 			snprintf(s, sizeof(s), " %s <%s> ",
-				Players[scr].name, Players[scr].host);
-		else snprintf(s, sizeof(s), " %s ", Players[scr].name);
+				Players[player].name, Players[player].host);
+		else snprintf(s, sizeof(s), " %s ", Players[player].name);
 		s[sizeof(s)] = 0;
-		if (haveColor && Players[scr].team > 0 && Players[scr].team <= 7)
-			attrset(A_REVERSE | COLOR_PAIR(Players[scr].team + 1));
-		mvaddstr(1, boardXPos[scr], s);
+		if (haveColor && Players[player].team > 0 && Players[player].team <= 7)
+			attrset(A_REVERSE | COLOR_PAIR(Players[player].team + 1));
+		mvaddstr(1, window[player].posx, s);
 		if (haveColor) standend();
 	} //display playername/host
 
 	{
 		int x, y;
-		for (y = 0; y <= Players[scr].boardVisible; y++)
-			for (x = 0; x <= Players[scr].boardWidth; x++)
-				PlotBlock(scr, y, x, GetBlock(scr, y, x));
+		for (y = 0; y <= Players[player].boardVisible; y++)
+			for (x = 0; x <= Players[player].boardWidth; x++)
+				block_draw_window(player, y, x, block_get(player, y, x));
 	} //draw field
 
-	ShowPause(scr);
+	window_msg_status(player);
 }
 
-void InitFields(void)
+void screen_setup(void)
 { //calculate positions of all fields
-	int scr, prevscr;
+	int i, prev;
 	int y, x;
 	int spaceavail;
 
 	clear();
 	DrawTitle();
 	getmaxyx(stdscr, y, x);
-	boardSize[me] = 2;
-	boardXPos[me] = 1;
-	boardYPos[me] = 21;
-	PlayerDisp[me] = 1;
-	statusXPos = boardSize[me] * Players[me].boardWidth + 3;
+	window[me].size = 2;
+	window[me].posx = 1;
+	window[me].posy = 21;
+	window[me].shown = 1;
+	statusXPos = window[me].size * Players[me].boardWidth + 3;
 	statusYPos = 21;
-	ShowScore(me, Players[me].score);
+	status_draw(me, Players[me].score);
 
 	messageXPos = 2;
 	messageYPos = 24;
-	if ((messageWidth = x - messageXPos - 2) > MSG_WIDTH) messageWidth = MSG_WIDTH;
-	if ((messageHeight = y - messageYPos - 1) > MSG_HEIGHT) messageHeight = MSG_HEIGHT;
-	if (messageHeight <= 0) {
-		messageWidth = 27;
+	messageWidth  = MIN(x - messageXPos - 2, MSG_WIDTH);
+	messageHeight = MIN(y - messageYPos - 1, MSG_HEIGHT);
+	if (messageHeight < 3) {
+		messageWidth = MIN(x - statusXPos - 18, 27);
 		messageHeight = y - 3;
 		messageXPos = statusXPos + 16;
 		messageYPos = 2;
 	} //messagebox doesn't fit below
-	DrawBox(messageXPos - 2, messageYPos - 1,
+	window_border(messageXPos - 2, messageYPos - 1,
 		messageXPos + messageWidth + 1, messageYPos+messageHeight);
 	if (msgwin = subwin(stdscr, messageHeight, messageWidth,
-				messageYPos, messageXPos))
+	                    messageYPos, messageXPos))
 		scrollok(msgwin, 1);  //allow scrolling
 	wmove(msgwin, messageHeight - 2, 0);
-	for (scr = messageHeight - 2; scr >= 0; scr--) //display message history
-		DisplayMessage(message[scr]);
+	for (i = messageHeight - 2; i >= 0; i--) //display message history
+		msg_draw(message[i]);
 
 	spaceavail = x;
-	for (scr = 1; scr <= maxPlayer; scr++)
-		spaceavail -= Players[scr].boardWidth+2;
-	prevscr = me;
-	for (scr = 1; scr < MAX_SCREENS; scr++) if (scr != me) {
-		boardYPos[scr] = 21;
-		boardXPos[scr] =
-			boardXPos[prevscr] + 2 + boardSize[prevscr] * Players[prevscr].boardWidth;
-		if (prevscr == me) {
-			boardXPos[scr] += 15; //scorebar
+	for (i = 1; i <= maxPlayer; i++)
+		spaceavail -= Players[i].boardWidth+2;
+	prev = me;
+	for (i = 1; i < MAX_SCREENS; i++) if (i != me) {
+		window[i].posy = 21;
+		window[i].posx =
+			window[prev].posx + 2 + window[prev].size * Players[prev].boardWidth;
+		if (prev == me) {
+			window[i].posx += 15; //scorebar
 			if (messageYPos < 24)
-				boardXPos[scr] += messageWidth + 4; //messagebox
-			spaceavail -= boardXPos[scr] - 3;
+				window[i].posx += messageWidth + 4; //messagebox
+			spaceavail -= window[i].posx - 3;
 		} //stuff before second player
 		if (spaceavail >= 0) {
-			boardSize[scr] = 2;
-			spaceavail -= Players[scr].boardWidth;
+			window[i].size = 2;
+			spaceavail -= Players[i].boardWidth;
 		} //not enough space, half width
 		else
-			boardSize[scr] = 1;
-		if (x < boardXPos[scr] + 1 + boardSize[scr] * Players[scr].boardWidth)
-			PlayerDisp[scr] = 0; //field doesn't fit on screen
+			window[i].size = 1;
+		if (x < window[i].posx + 1 + window[i].size * Players[i].boardWidth)
+			window[i].shown = 0; //field doesn't fit on screen
 		else
-			PlayerDisp[scr] = 1;
-		prevscr = scr;
+			window[i].shown = 1;
+		prev = i;
 	}
-	for (scr = 1; scr <= maxPlayer; scr++)
-		DrawField(scr);
-}
-
-void CleanupScreen(int scr)
-{
+	for (i = 1; i <= maxPlayer; i++)
+		window_draw(i);
 }
 
-void DisplayMessage(char *p)
+static void msg_draw(char *p)
 {
 	char s[MSG_WIDTH];
 	char *psearch;
@@ -354,7 +347,7 @@ void DisplayMessage(char *p)
 	while (psearch = strchr(p, '\\')) {
 		*psearch = '\0';
 		waddstr(msgwin, p);
-		c = atoi(++psearch)+1;
+		c = atoi(++psearch) + 1;
 		if (haveColor) wattrset(msgwin, A_REVERSE | COLOR_PAIR(c));
 		p = ++psearch;
 	} //search for color escapes (\)
@@ -363,7 +356,7 @@ void DisplayMessage(char *p)
 	waddch(msgwin, '\n');
 }
 
-void Message(char *fmt, ...)
+void msg_add(char *fmt, ...)
 { //print game/bot message
 	va_list args;
 	char s[MSG_WIDTH];
@@ -381,12 +374,12 @@ void Message(char *fmt, ...)
 	strcpy(p, s);
 
 	wmove(msgwin, messageHeight - 1, 0);
-	DisplayMessage(s);
+	msg_draw(s);
 	wclrtoeol(msgwin);
 	wrefresh(msgwin);
 }
 
-void Messagetype(char c, int x, char *s)
+void msg_add_char(char c, int x, char *s)
 { //show single typed character
 	if (c == 27) {
 		mvwaddch(msgwin, messageHeight-1, (x+1) % (messageWidth-1), ' ');
@@ -402,7 +395,7 @@ void Messagetype(char c, int x, char *s)
 	wrefresh(msgwin);
 }
 
-void PlotBlock1(int y, int x, unsigned char type)
+static void block_draw_2(int y, int x, unsigned char type)
 { //display block on screen
 	move(y, x);
 	if (type == BT_none) addstr("  ");
@@ -410,86 +403,63 @@ void PlotBlock1(int y, int x, unsigned char type)
 	else {
 #ifdef HAVE_NCURSES
 		if (Sets.standout) {
-			if (haveColor) attrset(COLOR_PAIR(type & 15));
-			else attrset(A_REVERSE);
+			attrset(haveColor ? COLOR_PAIR(type & 15) : A_REVERSE);
 		}
 #endif
 		switch (Sets.drawstyle) {
-			case 2:
-				switch (type & 192) {
-				 case 64:  //right neighbour
-					 addstr("[[");
-					 break;
-				 case 128: //left
-					 addstr("]]");
-					 break;
-				 default:  //both/none
-					 addstr("[]");
-					 break;
-				} //horizontal stickiness
-				break; //ascii horizontally grouped
-			case 3:
-				switch (type & 240) {
-				 case 48:
-					 addstr("||"); break; //middle
-				 case 64: case 80: case 96:
-					 addstr("[="); break; //left end
-				 case 112:
-					 addstr("|="); break;
-				 case 128: case 144: case 160:
-					 addstr("=]"); break; //right end
-				 case 176:
-					 addstr("=|"); break;
-				 case 192: case 208: case 224:
-					 addstr("=="); break;
-				 default:
-					 addstr("[]"); break; //top/bottom/mid
-				} //neighbours
-				break; //ascii semi-grouped
-			case 7:
-				switch (type & 240) {
-				 case 16:  addch(ACS_ULCORNER); addch(ACS_URCORNER); break;//top end
-				 case 32:  addch(ACS_LLCORNER); addch(ACS_LRCORNER); break;//bottom end
-				 case 48:  addch(ACS_VLINE); addch(ACS_VLINE); break;	//vertical middle
-				 case 64:  addch(' '); addch(ACS_HLINE); break;		//left end
-				 case 80:  addch(ACS_ULCORNER); addch(ACS_TTEE); break;	//top left corner
-				 case 96:  addch(ACS_LLCORNER); addch(ACS_BTEE); break;	//bottom left corner
-				 case 112: addch(ACS_LTEE); addch(ACS_PLUS); break;	//vertical+right
-				 case 128: addch(ACS_HLINE); addch(' '); break;		//right end
-				 case 144: addch(ACS_TTEE); addch(ACS_URCORNER); break;	//top right corner
-				 case 160: addch(ACS_BTEE); addch(ACS_LRCORNER); break;	//bottom right corner
-				 case 176: addch(ACS_PLUS); addch(ACS_RTEE); break;	//vertical+left
-				 case 192: addch(ACS_HLINE); addch(ACS_HLINE); break;	//horizontal middle
-				 case 208: addch(ACS_TTEE); addch(ACS_TTEE); break;	//horizontal+down
-				 case 224: addch(ACS_BTEE); addch(ACS_BTEE); break;	//horizontal+up
-				 default:  addstr("[]"); break;
-				} //neighbours
-				break; //curses grouped
-			default:
-				addstr("[]");
-				break; //ascii non-grouped
-		} //draw block
+		case 2: // ascii horizontally grouped
+			switch (type & 0xC0) {
+			case 0x40:  // right neighbour
+				addstr("[["); break;
+			case 0x80: // left
+				addstr("]]"); break;
+			default:  // both/none
+				addstr("[]"); break;
+			} // horizontal stickiness
+			break;
+		case 3: // curses grouped
+			switch (type & 0xF0) {
+			case 0x10: addch(ACS_ULCORNER); addch(ACS_URCORNER); break; // top end
+			case 0x20: addch(ACS_LLCORNER); addch(ACS_LRCORNER); break; // bottom end
+			case 0x30: addch(ACS_VLINE);    addch(ACS_VLINE);    break; // vertical middle
+			case 0x40: addch('[');          addch(ACS_HLINE);    break; // left end
+			case 0x50: addch(ACS_ULCORNER); addch(ACS_TTEE);     break; // top left corner
+			case 0x60: addch(ACS_LLCORNER); addch(ACS_BTEE);     break; // bottom left corner
+			case 0x70: addch(ACS_LTEE);     addch(ACS_PLUS);     break; // vertical+right
+			case 0x80: addch(ACS_HLINE);    addch(']');          break; // right end
+			case 0x90: addch(ACS_TTEE);     addch(ACS_URCORNER); break; // top right corner
+			case 0xA0: addch(ACS_BTEE);     addch(ACS_LRCORNER); break; // bottom right corner
+			case 0xB0: addch(ACS_PLUS);     addch(ACS_RTEE);     break; // vertical+left
+			case 0xC0: addch(ACS_HLINE);    addch(ACS_HLINE);    break; // horizontal middle
+			case 0xD0: addch(ACS_TTEE);     addch(ACS_TTEE);     break; // horizontal+down
+			case 0xE0: addch(ACS_BTEE);     addch(ACS_BTEE);     break; // horizontal+up
+			default:   addstr("[]");                             break; // all/none
+			} // neighbours
+			break;
+		default: // non-grouped
+			addstr("[]");
+			break;
+		}
 #ifdef HAVE_NCURSES
 		if (Sets.standout) standend();
 #endif
 	} //display one brick
 }
-void PlotBlock1S(int y, int x, unsigned char type)
+
+static void block_draw_1(int y, int x, unsigned char type)
 { //display block small
 	move(y, x);
 	if (type == BT_none) addch(' ');
 	else if (type == BT_shadow) addch(':');
 	else {
-		if (Sets.standout) {
 #ifdef HAVE_NCURSES
-			if (haveColor)
-				attrset(COLOR_PAIR(type & 15));
-			else attrset(A_REVERSE);
-#endif
+		if (Sets.standout) {
+			attrset(haveColor ? COLOR_PAIR(type & 15) : A_REVERSE);
 		}
-		if ((type & 192) == 64)
+#endif
+		if ((type & 0xC0) == 0x40)
 			addch('[');
-		else if ((type & 192) == 128)
+		else if ((type & 0xC0) == 0x80)
 			addch(']');
 		else
 			addch('|');
@@ -498,30 +468,31 @@ void PlotBlock1S(int y, int x, unsigned char type)
 #endif
 	} //display one brick
 }
-void PlotBlock(int scr, int y, int x, unsigned char type)
+
+void block_draw_window(int player, int y, int x, unsigned char type)
 {
-	if (y >= 0 && y < Players[scr].boardVisible
-	 && x >= 0 && x < Players[scr].boardWidth) {
-		if (boardSize[scr] > 1)
-			PlotBlock1(boardYPos[scr] - y, boardXPos[scr] + 2*x, type);
+	if (y >= 0 && y < Players[player].boardVisible
+	 && x >= 0 && x < Players[player].boardWidth) {
+		if (window[player].size > 1)
+			block_draw_2(window[player].posy - y, window[player].posx + 2*x, type);
 		else
-			PlotBlock1S(boardYPos[scr] - y, boardXPos[scr] + x, type);
+			block_draw_1(window[player].posy - y, window[player].posx + x, type);
 	} //on screen
 }
-void PlotBlockXY(int y, int x, unsigned char type)
-{ //Draw block at specified position on screen (not on field)
-	PlotBlock1(20 - y, 2 * x, type);
+void block_draw_status(int y, int x, unsigned char type)
+{ //Draw block at specified position next to field
+	block_draw_2(20 - y, 2 * x, type);
 }
 
-void ShowScore(int scr, struct _Score score)
+void status_draw(int player, struct score_t score)
 { //show score stuff
 	float timer;
 
 	mvaddstr(13, statusXPos, MSG_NEXT " ");
 	mvaddstr(14, statusXPos + 5,  "        ");
-	ShapeIterate(Players[scr].nextShape, scr,
-		8, statusXPos/2 + (Players[scr].nextShape/4 == 5 ? 3 : 4),
-		GlanceFunc); //draw; stick one more to the left
+	shape_iterate(Players[player].nextShape, player, 8,
+		statusXPos/2 + (Players[player].nextShape/4 == 5 ? 3 : 4),
+		block_iter_set_status); //draw; BT_I one more to the left
 	mvprintw(3, statusXPos, MSG_LEVEL, score.level);
 	mvprintw(5, statusXPos, MSG_SCORE, score.score);
 	mvprintw(6, statusXPos, MSG_LINES, score.lines);
@@ -540,57 +511,91 @@ void ShowScore(int scr, struct _Score score)
 	} //too early to display stats, remove old..
 }
 
-void FieldMessage(int playa, char *message)
-{ //put a message over playa's field
-	if (!PlayerDisp[playa]) return;
+void window_msg(int player, char *message)
+{ //put a message over player's field
+	if (!window[player].shown) return;
 	if (message) {
-		char s[MAX_BOARD_WIDTH+1];
-		memset(s, ' ', MAX_BOARD_WIDTH);
-		memcpy(&s[(boardSize[playa] * Players[playa].boardWidth / 2) - (strlen(message) / 2)],
-			message, strlen(message));
-		s[boardSize[playa] * Players[playa].boardWidth] = 0;
+		const int fieldsize = Players[player].boardWidth * window[player].size;
+		const int centered = (fieldsize - strlen(message)) / 2;
+		char s[fieldsize + 1];
+
+		memset(s, ' ', fieldsize);
+		memcpy(&s[centered], message, strlen(message));
+		s[fieldsize] = 0;
 #ifdef HAVE_NCURSES
 		attrset(A_REVERSE);
 #else
 		standout();
 #endif
-		mvprintw(boardYPos[playa] - Players[playa].boardVisible / 2,
-			boardXPos[playa], "%s", s);
+		mvprintw(window[player].posy - Players[player].boardVisible / 2,
+			window[player].posx, "%s", s);
 		standend();
 	} //display
 	else {
 		int x, y;
-		y = Players[playa].boardVisible / 2;
-		for (x = 0; x <= Players[playa].boardWidth; x++)
-			PlotBlock(playa, y, x, GetBlock(playa, y, x));
+		y = Players[player].boardVisible / 2;
+		for (x = 0; x <= Players[player].boardWidth; x++)
+			block_draw_window(player, y, x, block_get(player, y, x));
 	} //restore field
 }
 
-void ShowPause(int playa)
-{ //put paused over player's field
-	if (Players[playa].alive > 0)
-		if (Players[playa].flags & SCF_paused)
+void window_msg_wide(int player, char *message)
+{
+	int i;
+	char *messagewide = malloc(strlen(message) * 2); // max += strlen - 1
+	const int fieldsize = Players[player].boardWidth * window[player].size;
+
+	const bool sep = strchr(message, ' ') != NULL;
+		// whitespace to pad at convenience
+	const bool pad = strlen(message) * 2 - sep <= fieldsize;
+		// (space to) put whitespace between all characters
+	bool odd = fieldsize & 1;
+		// odd number of characters (center off; try to change padding at sep)
+	if (!pad) odd ^= strlen(message) & 1;
+		// for odd strings, check for even fieldsize instead
+
+	if (pad || (sep && odd && strlen(message) < fieldsize)) {
+		// generate padded message in messagewide
+		for (i = 0; ; message++) {
+			messagewide[i++] = *message;
+			if (message[1] == 0) {
+				messagewide[i] = 0;
+				break;
+			}
+			if (pad ? (*message != ' ' || odd) : (*message == ' ' && odd)) {
+				// add padding if wide; different padding at space if odd
+				messagewide[i++] = ' ';
+				odd = 0;
+			}
+		}
+		message = messagewide;
+	}
+	window_msg(player, message);
+}
+
+void window_msg_status(int player)
+{ //put status (pause, readiness, game over) over player's field
+	if (Players[player].alive > 0)
+		if (Players[player].flags & SCF_paused)
 			if (Game.started > 1)
-				FieldMessage(playa, boardSize[playa] > 1 ? "P A U S E D" : "PAUSED");
+				window_msg_wide(player, MSG_PLAYER_PAUSE);
 			else
-				FieldMessage(playa,
-					boardSize[playa] > 1 ? "N O T  R E A D Y" : "NOT  READY");
+				window_msg_wide(player, MSG_PLAYER_JOIN);
 		else
 			if (Game.started > 1)
-				FieldMessage(playa, NULL);
+				window_msg(player, NULL);
 			else
-				FieldMessage(playa, boardSize[playa] > 1 ? "R E A D Y" : "READY");
-	else if (!Players[playa].alive)
-		FieldMessage(playa,
-			boardSize[playa] > 1 ? "G A M E  O V E R" : "GAME  OVER");
+				window_msg_wide(player, MSG_PLAYER_START);
+	else if (!Players[player].alive)
+		window_msg_wide(player, MSG_PLAYER_STOP);
 	else
-		FieldMessage(playa, boardSize[playa] > 1 ? "E M P T Y" : "EMPTY");
+		window_msg_wide(player, MSG_PLAYER_PART);
 }
 
 
-void ShowTime(void)
+void status_tick(void)
 { //display timer
-	mvprintw(statusYPos, statusXPos, "timer %7.0f ", CurTimeval() / 1e6);
+	mvprintw(statusYPos, statusXPos, MSG_TIME, CurTimeval() / 1e6);
 }
 
 void ScheduleFullRedraw(void)
@@ -598,11 +603,11 @@ void ScheduleFullRedraw(void)
 	touchwin(stdscr);
 }
 
-void CatchWinCh(int sig)
+static void CatchWinCh(int sig)
 { //handle window resize
 	endwin();      //exit curses
 	refresh();     //and reinit display (with different sizes)
-	InitFields();  //manually redraw everything
+	screen_setup();//manually redraw everything
 	refresh();     //refresh
 }